小编hel*_*vio的帖子

我希望B类继承除A类的几个方法之外的所有方法(假设它们都是可复制的),并且仍然可以轻易地复制.在C++ 11中,我可以删除方法.举个例子:

class A { // trivially copyable
   // private stuff here
public:
   A& operator += (const A&);
   // other public stuff here
};

class B: public A {
public:
   B& operator += (const A&) = delete;
};

B是否可以复制？我知道有关删除特殊方法的问题,但复合赋值不是一种特殊的方法(对吧？).

我在尝试从父结构继承函数调用操作符时遇到问题.我创建了一个简单的代码来说明我的问题:

#include <iostream>
using namespace std;

template <class T, int N>
struct array
{
    T value[N];
    T& operator() (int);
};

template <class T, int N>
T& array<T,N>::operator() (int i)
{ return value[i]; }

template <class T, int N>
struct matrix: public array<T,N*N>
{
    T& operator() (int,int);
};

template <class T, int N>
T& matrix<T,N>::operator() (int i, int j)
{ return this->value[i*N+j]; }

int main()
{
    matrix<double,100> a;
    a(0) = 3.5;
    cout << a(0) << endl;
    return 0;
};

我希望'matrix'类从'array'类继承operator(),并用本地operator()重载它; 我希望这是因为参数的数量不同.但是,这段代码的编译失败了,例如"错误:不匹配调用'(矩阵)(int)'"和"注意:候选人需要2个参数,1提供".如果未在类'matrix'中定义operator(),则继承正常发生,并且代码编译并运行正常,如预期的那样. …

考虑以下用于方形矩阵的(模板化)C++结构的精简示例(不需要模拟问题发生):

#include <array>
#include <complex>
using namespace std;

double conj (double &x) { return x; };

template <typename T, int N>
struct matrix: array<T,N*N> {
    void conj() {
        for (int ij=0; ij<100; ++ij) {
            T z = (*this)[ij];
            (*this)[ij] = conj(z);
        }
    }
};

int main() {
    matrix<double,10> a;
    a.conj();
    return 0;
}

我想实现一个执行矩阵复共轭的方法,使用名称.conj()与<complex>库中使用的命名系统一致.但是,我收到以下错误:

$ g++ example.cpp -std=c++11
example.cpp: In instantiation of ‘void matrix<T, N>::conj() [with T = double; int N = 10]’:
example.cpp:19:12:   required from here
example.cpp:12:26: error: no …

检查STL库的源代码,我遇到了指定模板变量的宏_Tp和_Up.他们在哪里定义,两者有什么区别？为什么要使用这样的宏？我找不到有关此编程策略的任何信息.

编辑:我指的是GCC STL库,特别是复杂类,它是一个模板类,内容如下:

00115   template<typename _Tp>
00116     class complex
00117     {
00118     public:
00120       typedef _Tp value_type;
00121       
00124       complex(const _Tp& = _Tp(), const _Tp & = _Tp());
00125 
00126       // Lets the compiler synthesize the copy constructor   
00127       // complex (const complex<_Tp>&);
00129       template<typename _Up>
00130         complex(const complex<_Up>&);
00776   };

我正在尝试理解复制构造函数及其注释的含义,并决定这是否是一个简单的可复制类.