如果你没有声明下列函数,体贴的编译器会声明它自己的版本。这些函数是:一个拷贝构造函数,一个赋值运算符,一个析构函数,一对取址运算符。另外,如果你没有声明任何构造函数,它也将为你声明一个缺省构造函数。所有这些函数都是公有的。
class Empty {
public:
Empty(); // 缺省构造函数
Empty(const Empty& rhs); // 拷贝构造函数
~Empty(); // 析构函数---- 是否
// 为虚函数看下文说明
Empty&
operator=(const Empty& rhs); // 赋值运算符
Empty* operator&(); // 取址运算符
const Empty* operator&() const;
};
const Empty e1; // 缺省构造函数
// 析构函数
Empty e2(e1); // 拷贝构造函数
e2 = e1; // 赋值运算符
Empty *pe2 = &e2; // 取址运算符
// ( 非 const)
const Empty *pe1 = &e1; // 取址运算符
// (const)
缺省构造函数和析构函数实际上什么也不做,它们只是让你能够创建和销毁类的对象。
这些函数实际上就如同下面所定义的那样:
inline Empty::Empty() {}
inline Empty::~Empty() {}
inline Empty * Empty::operator&() { return this; }
inline const Empty * Empty::operator&() const
{ return this; }
至于 拷贝构造函数和赋值运算符:官方的规则是:缺省拷贝构造函数(赋值运算符)对 类的非静态数据成员进行" 以成员为单位的" 逐一拷贝构造(赋值)。即,如果 m 是类 C 中类型为 T 的非静态数据成员, 并且 C 没有声明拷贝构造函数(赋值运算符), m 将会通过类型 T 的拷贝构造函数(赋值运算符)被拷贝构造(赋值)---- 如果 T 有拷贝构造函数(赋值运算符)的话。如果没有, 规则递归应用到 m 的数据成员,直至找到一个拷贝构造函数 (赋值运算符)或 固定类型(例如,int,double,指针,等)为止。默认情况下, 固定类型的对象拷贝构造(赋值)时是从源对象到目标对象的" 逐位" 拷贝。对于从别的类继承而来的类来说,这条规则适用于继承层次结构中的每一层,所以,用户自定义的构造函数和赋值运算符无论在哪一层被声明,都会被调用。
template<class T>
class NamedObject {
public:
NamedObject(const char *name, const T& value){ nameValue=name;objectValue=value;}
private:
string nameValue;
T objectValue;
};
int main(int argc, char* argv[])
{
NamedObject<int> no1("Smallest Prime Number", 2);
NamedObject<int> no2(no1); // 调用拷贝构造函数
}
因为 NamedObject 类声明了至少一个构造函数, 编译器将不会生成缺省构造函数。
NamedObject<int> no1("Smallest Prime Number", 2);
NamedObject<int> no2(no1); // 调用拷贝构造函数
编译器生成的拷贝构造函数必须分别用 no1.nameValue 和 no1.objectValue来初始化 no2.nameValue 和 no2.objectValue
nameValue 的类型是 string , string有一个拷贝构造函数。所以 no2.nameValue 初始化时将调用 string 的拷贝构造函数,参数为no1.nameValue。另一方面,NamedObject<int>::objectValue 的类型是 int (因为这个模板实例中, T 是 int ), int 没有定义拷贝构造函数,所以 no2.objectValue是通过从 no1.objectValue 拷贝每一个比特(bit)而被初始化的。
请注意:编译器生成的默认赋值运算符。生成默认赋值运算符的条件比较苛刻。
1.如果包含一个“内含引用成员”,不会生成默认的赋值操作符,就必须定义自己的默认拷贝赋值操作符。
2.如果包含一个“const 成员”,不会生成默认的赋值操作符,就必须定义自己的默认拷贝赋值操作符。
3.如果派生类的基类将标准赋值运算符声明为 private, 编译器也将拒绝为这个派生类生成赋值运算符。
template<class T>
class NamedObject {
public:
NamedObject(string& name, const T& value): nameValue(name),objectValue(value){ }
// 同上,假设没有
// 声明 operator=
private:
<strong>string& nameValue; // 现在是一个引用
const T objectValue; // 现在为 const</strong>
};
int main(int argc, char* argv[])
{
string newDog("Persephone");
string oldDog("Satch");
NamedObject<int> p(newDog, 2);
NamedObject<int> s(oldDog, 29);
<strong>p=s;</strong>
}
编译就会出错: error C2582: “operator =”函数在“NamedObject<T>”中不可用
因为类包含了引用成员和const成员,所以,不会生成默认的赋值函数,
p=s就会出错;
理由:
赋值之前,p.nameValue 指向某个 string 对象,s.nameValue 也指向一个string,但并非同一个。赋值会给 p.nameValue 带来怎样的影响呢?赋值之后,p.nameValue 应该指向"被 s.nameValue 所指向的 string" 吗,即,引用本身应该被修改吗?如果是这样,那太阳从西边出来了,因为 C++没有办法让一个引用指向另一个不同的对象(参见条款 M1) 。或者, p.nameValue 所指的 string对象应该被修改吗? 这样的话,含有"指向那个 string 的指针或引用" 的其它对象也会受影响,也就是说,和赋值没有直接关系的其它对象也会受影响。
pointer和reference之间的一个重要差异是,pointer可以被重新赋值,指向另一个对象,reference却总是指向它最初获得的那个对象。
string s1("Nancy");
string s2("Clancy");
string& rs=s1;//rs代表s1
string* ps=&s1;//ps指向s1
rs=s2;//但是s1的值现在变成了“Clancy”
ps=&s2;//ps指向了s2
如果派生类的基类将标准赋值运算符声明为 private, 编译器也将拒绝为这个派生类生成赋值运算符。因为,编译器为派生类生成的赋值运算符也应该处理基类部分(见条款 16 和 M33) ,但这样做的话,就得调用对派生类来说无权访问的基类成员函数,这当然是不可能的.