C++Item 05:了解C++默默编写并调用哪些函数

Item 05: Know waht functions C++ silently writes and calls.

绿意幽然

空类并不一定是拖欠的

好家伙时空类不再是只空类呢?答案是:当C++处理过之后。

假设你协调从来不声明,编译器就见面否她声明(编译器版本的)一个拷贝构造函数一个赋值操作符一个析构函数。此外要您没有声明任何构造函数,编译器也会见吧而声明一个默认构造函数。所有这些函数都是publicinline的。

如,如果你写下:

class Empty{};

立马虽象是写起下这样的代码:

class Empty {
public:
    Empty() { ... }                                  // default constructor
    Empty(const Empty& rhs) { ... }                  // copy constructor
    ~Empty() { ... }                                 // destructor — 是否该是
                                                     // virtual稍后说明。
    Empty& operator=(const Empty& rhs) { ... }       // copy assignment operator
};

才当这些函数被用(被调用),它们才见面让编译器创建出来。程序中得它们是蛮平常的从事。下面的代码造成上述各一个函数被编译器产生下:

Empty e1;             // default constructor;
                      // destructor
Empty e2(e1);         // copy constructor
e2 = e1;              // copy assignment operator

编译器为卿写来这些函数,但这些函数做了声称也?默认构造函数和析构函数要是叫编译器一个地方因此来放置“藏身幕后”的代码,像调用base
classes和non-static成员变量的构造函数和析构函数。

专注,编译器产生有的析构函数是只non-virtual,除非是class的base
class自身声明发出vitual析构函数。(这种状况下此函数的虚属性主要来自base
class)

有关拷贝构造函数和赋值操作符,编译器创建的本知识就地拿自对象的各一个non-static成员变量拷贝到对象对象。

拷贝构造函数

考虑一个NameObject
template,它同意你拿一个个称号及类为T的靶子来关联:

template<typename T>
class NamedObject {
public:
    NamedObject(const char *name, const T& value);
    NamedObject(const std::string& name, const T& value);
    ...
private:
    std::string nameValue;
    T objectValue;
};

是因为内部声明了构造函数,编译器于是不再为其创建default构造函数。NamedObject既没声明拷贝构造函数,也从未声明赋值操作符,所以编译器会为她创建那些函数(如果她于调用的言辞)。

NamedObject<int> no1("Smallest Prime Number", 2);
NamedObject<int> no2(no1);                             // calls copy constructor

编译器生成的正片构造函数必须坐no1.nameValue和no1.objectValue为初值设定no2.nameValue以及no2.objectValue。两者中,nameVlaue的种类是string,而正式的string有个拷贝构造函数,所以no2.nameValue底初始化式是调用string的正片构造函数并以no1.nameValue为实参。另一个分子NamedObject<int>::objectValue的门类是int,那是只放置类型,所以no2.objectValue会盖“拷贝no1.objectValue内的各个一个bits”来就初始化。

拷贝赋值操作符

编译器为NamedObject<int>所生的赋值操作符,其一言一行大多和拷贝构造函数一样,但貌似而言只有当有出之代码合法且发出适量时机证明其发生意义,其变现才会暨我们预料的同样。万一出谱不适合,编译器会拒绝也class生出operator=。

推个例子,假设NamedObject定义如下,其中nameValue是单援,objectValue是单const
T:

template<typename T>
class NamedObject {
public:
    NamedObject(std::string& name, const T& value);
    ... 
private:
    std::string& nameValue;      // this is now a reference
    const T objectValue;         // this is now const
};

如今考虑下会生什么事:

std::string newDog("A");
std::string oldDog("B");

NamedObject<int> p(newDog, 2); 

NamedObject<int> s(oldDog, 36); 

p = s;         //what should happen to the data members in p?

赋值之前,不论p.nameValue和s.nameVlaue都对准string对象(当然不是同一个)。赋值动作该如何影响p.nameValue呢?赋值之后,p.nameValue应该是依靠为s.nameValue所指的坏string吗?也就是是说reference自身可让反呢?

对这难题,C++的响应是拒绝编译那一行赋值动作。因为C++并无允许“让reference改指为不同目标”。同样道理更改变const值也是私自的。如果有base
class将拷贝赋值操作符声明也private,编译器也不容为那个derived
class产生有一个正片赋值操作符。因为编译器为derived
class生成的正片赋值操作符想象中得拍卖base class成分,这是做不顶之。

来一个切实一点的事例:

class Person{
public:
    Person(string& str,int x): name(str),value(x){ }

    string & name;
    const int value;
};

int main()
{
    string s1 = "A", s2 = "B";
    Person p1(s1,1),p2(s2,2);
    Person p3(p2);            //拷贝构造函数可以正常调用,和预期结果一样。

    cout << p1.name << " " << p1.value << endl;        //A 1
    cout << p2.name << " " << p2.value << endl;        //B 2
    cout << p3.name << " " << p3.value << endl;        //B 2

    p1 = p2;    //编译错误
                //error: non-static reference member 'std::string& Person::name', can't use default assignment operator
                //error: non-static const member 'const int Person::value', can't use default assignment operator

    return 0;
}

Note:

  • 编译器可以呢class创建默认构造函数、拷贝构造函数、拷贝赋值操作符,以及析构函数。
  • 除非这些函数被调用的时段,它们才见面让编译器创建出来。
  • 变化的析构函数是否为vitual,根据base class而定。
  • 假定你显式的任性定义了一个构造函数,编译器就未会见呢您大成一个默认构造函数了。
  • 打算于一个“内含reference成员”的 class 内支持
    赋值操作,必须自己定义copy assignment操作符。
  • 对“内含const成员”的classes,编译器的影响啊一如既往,因为改变const成员是免合法的。
  • 而某 base classes 将copy assignment操作符声明也
    private,编译器将不容也那个 derived classes 生成 copy assignment
    操作符。

Effective C++