C++中的对象初始化操作代码

// （1）默认初始化
int i1;//默认初始化，在函数体之外(初始化为0)  


int f(void)  
{  
int i2;//不被初始化，如果使用此对象则报错  
}  

string empty;//empty非显示的初始化为一个空串，调用的是默认构造函数  

// （2）拷贝初始化
string str1(10,'9');//直接初始化  
string str2(str1);//直接初始化  
string str3 = str1;//拷贝初始化  

 // （3）值初始化
vector<int> v1(10);//10个元素，每个元素的初始化为0  
vector<string> v2(10);//10个元素，每个元素都为空   

int *pi = new int;//pi指向一个动态分配的，未初始化的无名对象  
string *ps = new string;//初始化为空string  
int *pi = new int;//pi指向一个未初始化的int  

int *pi = new int(1024);//pi指向的对象的值为1024  
string *ps = new string(10,'9');//*ps为"9999999999"  


string *ps1 = new string;//默认初始化为空string  
string *ps2 = new string();//值初始化为空string  
int *pi1 = new int;//默认初始化  
int *pi2 = new int();//值初始化为0   

1、C++ Copy初始化

在《inside the c++ object model》一书中谈到copy constructor的构造操作，有三种情况下，会以一个object的内容作为另一个object的初值：

• 第一种情况：XXaa=a;第二种情况：XXaa(a);
• 第三种情况：externfun(XXaa);fun(a)函数调用
• 第四种情况：XXfun(){...};XXa=fun();函数返回值的时候

下面我们就上述的四种情况来一一验证

#include <iostream>
using namespace std;

class ClassTest {
public:
  ClassTest() //定义默认构造函数
  {
    c[0] = '\0';
    cout << "ClassTest()" << endl;
  }
  ClassTest(const char *pc) // 直接初始化
  {  
    strcpy_s(c, pc);
    cout << "ClassTest (const char *pc)" << endl;
  }
  ClassTest(const ClassTest &ct) //复制构造函数
  {
    strcpy_s(c, ct.c);
    cout << "ClassTest(const ClassTest& ct)" << endl;
  }
  ClassTest &operator=(const ClassTest &ct)  //重载赋值操作符
  {
    strcpy_s(c, ct.c);
    cout << "ClassTest& operator=(const ClassTest &ct)" << endl;
    return *this;
  }

private:
  char c[256];
};

ClassTest func(ClassTest temp) { return temp; }

int main() {
  cout << "ct1: ";
  ClassTest ct1("ab"); //直接初始化
  cout << "ct2: ";
  ClassTest ct2 = "ab"; //复制初始化
  /*输出说明：
  ClassTest ct2 = "ab";
  它本来是要这样来构造对象的：
  首先,调用构造函数ClassTest(const char *pc)函数创建一个临时对象。
  然后,调用复制构造函数，把这个临时对象作为参数，构造对象ct2。然而，编译也发现，复制构造函数是
  公有的，即你明确地告诉了编译器，你允许对象之间的复制，而且此时它发现可以通过直接调用重载的
  构造函数ClassTest(const char *pc)来直接初始化对象，而达到相同的效果，所以就把这条语句优化为
  ClassTest ct2（"ab"）。
  */
  cout << "ct3: ";
  ClassTest ct3 = ct1; //复制初始化
  cout << "ct4: ";
  ClassTest ct4(ct1); //直接初始化
  cout << "ct5: ";
  ClassTest ct5 = ClassTest(); //复制初始化
  cout << "ct6: ";
  ClassTest ct6; //复制初始化
  ct6 = "caoyan is a good boy!";
  cout << "ct7: ";
  ClassTest ct7;
  ct7 = func(ct6);
  return 0;
}

测试结果：

#include <iostream>
 
using std::cout;
using std::endl;
 
class MyCppClass
{
public:
    MyCppClass()
    {
        std::cout <<"In Default Constructor!" <<std::endl;
    }
 
    MyCppClass(const MyCppClass& rhs)
    {
        std::cout <<"In Copy Constructor!" <<std::endl;
    }
 
    MyCppClass& operator= (const MyCppClass& rhs)
    {
        std::cout <<"In Copy Assignment Operator!" <<std::endl;
 
        return *this;
    }
};
 
int main()
{
    MyCppClass testClass1;                 // default constructor
    MyCppClass testClass2(testClass1);     // copy constructor
    testClass1 = testClass2;               // copy assignment operator
 
    MyCppClass testClass3 = testClass1;    // copy constructor
 
    return 0;
}

// 数据成员类型为内置类型
class MyCppClass
{
public:
    // 赋值操作进行成员初始化
    MyCppClass 
    {
        counter = 0;
    }
    
    // 初始化列表进行成员初始化
    MyCppClass : counter(0)
    {
    }

private:
    int    counter;
}

// 数据成员类型为自定义类型：一个类
class MyCppClass
{
public:
    // 赋值操作进行成员初始化
    MyCppClass(string name) 
    {
        counter = 0;
        theName = name;
    }

    // 初始化列表进行成员初始化
    MyCppClass : counter(0), theName(name)
    {
    }

private:
    int    counter;
    string theName;
}

#include <iostream>
#include <string>
 
class SubClass
{
public:
    SubClass()
    {
        std::cout <<" In SubClass Default Constructor!" <<std::endl;
    }
 
    SubClass(const SubClass& rhs)
    {
        std::cout <<" In SubClass Copy Constructor!" <<std::endl;
    }
 
    SubClass& operator= (const SubClass& rhs)
    {
        std::cout <<" In SubClass Copy Assignment Operator!" <<std::endl;
 
        return *this;
    }
};
 
class BaseClass
{
public:
    BaseClass(const SubClass &rhs)
    {
        counter = 0;
        theBrother = rhs;
        std::cout <<" In BaseClass Default Constructor!" <<std::endl;
    }
 
    BaseClass(const SubClass &rhs, int cnt):theBrother(rhs),counter(cnt)
    {
        std::cout <<" In BaseClass Default Constructor!" <<std::endl;
    }
 
    BaseClass(const BaseClass& rhs)
    {
        std::cout <<" In BaseClass Copy Constructor!" <<std::endl;
    }
 
    BaseClass& operator= (const BaseClass& rhs)
    {
        std::cout <<" In BaseClass Copy Assignment Operator!" <<std::endl;
 
        return *this;
    }
private:
    int counter;
    SubClass theBrother;
};
 
int main()
{
    SubClass subClass;
 
    std::cout <<"\nNo Member Initialization List: " <<std::endl;
    BaseClass BaseClass1(SubClass);
 
    std::cout <<"\nMember Initialization List: " <<std::endl;
    BaseClass BaseClass2(SubClass, 1);
 
    return 0;
}