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;
}

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