C++对象模型（二）

一、默认构造函数的建构

在需要的时候被编译器产生出来：1、编译器需要它的时候；2、程序的需要（程序员编写）。

• 带有默认构造函数的类成员对象

如：

class Foo {public: Foo();Foo(int) ...};class Bar {public: Foo foo; char *str};void foo_bar(){      //Bar::foo 在此初始化      Bar bar;      if(str)      {...}      //...}

编译器合成的默认构造函数：

inline Bar::Bar(){     foo.Foo::Foo();}

它不产生任何代码初始化 Bar::str.

因此程序员有责任定义默认构造函数：

Bar::Bar(){     str=0;}

编译器的行动：如果class没含一个或一个以上的成员类对象，那么class的每个构造函数必须调用每一个成员类的默认构造函数。

上述代码就被扩张为：

Bar::Bar(){   foo.Foo::Foo();   str=0;}

例子：

class Dopey{public: Dopey();...};class Sneezy{public: Sneezy(int); Sneezy();...};class Bashful{public: Bashful();};class Snow_White{    public:          Dopey dopey;          Sneezy  sneezy;          Bashful bashful;          //...      private:           int mumble;};//程序员所写的 默认构造函数Snow_White::Snow_White:sneezy(1024){       mumble=2048;}

编译器将其扩张为：

Snow_White::Snow_White:sneezy(1024){     dopey.Dopey::Dopey();     sneezy.Sneezy::Sneezy(1024);     bashful.Bashful::Bashful();     mumble=2048;}

• 带有默认构造函数基类

派生类都会被合成默认构造函数；

如果设计者提供多个构造函数，但没有默认构造函数，编译器会扩张每一个构造函数，而不会合成一个新的默认构造函数

• 带有一个虚函数的类 

1、类声明或继承一个虚函数

2、类派生自一个继承串链，其中有一个或多个的虚基类

不管哪种情况，由于缺乏用户声明的构造函数，编译器会详细记录合成一个默认构造函数的必要信息。

合成的默认构造函数主要工作： 为 vptr 设定初值，放置适当的虚表地址。

• 带有一个虚基类的类 

如：      

                  

//无法在编译时期决定出  pa->X::i 的位置void foo(const A*pa) {pa->i=1024}

总之，在合成的默认构造函数中，只有基类子对象和成员类对象会被初始化，所以其它的非静态数据成员，如 整数、整数指针、整数数组等等不会被初始化。

 

二、拷贝构造函数的建构操作

1、明确的初始化操作： X x;  X  xx=x;

2、当做参数交给某个函数：  extern void foo（X  x）;           X  xx； foo( xx );

3、函数传回一个类对象：

X  foo_bar() { X xx；  ...  return xx; }

编译器扩张：

void foo_bar(X& __result){     X  xx;     xx.X::X();         __result.X::X(xx);   return;}

“Bitwise Copy Semantics”(位逐次拷贝)下不需要合成出一个默认拷贝构造函数，如：

class Word{     public:          Word(const char*);          ~Word() {delete [] str;}           //...      private:          int cnt;          char* str;};

非“Bitwise Copy Semantics”，即需要合成拷贝构造函数：

1、当类内含一个成员对象，而后者的类声明里有拷贝构造函数；

2、当类继承自一个基类，而后者存在有一个拷贝构造函数；

3、当类声明了一个或多个虚函数时；

4、当类派生自一个继承串链，其中包含虚基类。

 

何时调用调用拷贝构造函数与赋值操作符：

拷贝函数本质是一个构造函数，只不过他是依据一个已存在的对象（对象内容）来构造另一个对象。

赋值运算符，本质是使一个已存在的对象内容与目的对象的内容相同。
例子：

#include <stdio.h>#include <iostream>class CTest{public:    CTest()        : mInt(0)    {        printf("Default Constructor.\n");    }    CTest(const CTest& copyCons)    {        printf("Copy Constructor.\n");        this->mInt = copyCons.getIntValue();     }    ~CTest()                {}    void printIntValue()    {        printf("%d\n", mInt);    }    int getIntValue() const    {        return mInt;    }    void operator = (const CTest& copyCons)    {        printf("Operator =\n");        this->mInt = copyCons.getIntValue();    }private:    int mInt;};int main(){    CTest a;    CTest b(a);    CTest c = a;    c = b;    system("pause");    return 0;}输出：Default Constructor.Copy Constructor.Copy Constructor.Operator =请按任意键继续. . .

三、成员初始化列表

必须使用初始化列表的情况：

1、当初始化一个引用成员时；

2、当初始化一个 const 成员时；

3、当调用一个基类的构造函数，而它拥有一组参数时；

4、当调用一个成员类的构造函数，而它拥有一组参数时。

初始化列表的效率：

class Word{    String _name;    int _cnt;   public:    Word()   {       _name=0;       _cnt=0;   }};

构造函数，编译器扩张：

Word::Word(){    _name.String::String();    //产生临时对象   String temp=String(0);    _name.String::operator=(temp);   temp.String::~String();  _cnt=0;}

较佳形式

Word::Word():_name(0){      _cnt=0}

扩张：

Word::Word(){   _name.String::String(0);   _cnt=0;}

注：初始化列表中项目次序是有类中的成员声明次序决定，不是由列表的排列次序决定。