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

// new edit on 2020.7.23
#pragma once
#include <iOStream>
using namespace std;

class ClassTest {
 public:

  //定义默认构造函数
  ClassTest()  
  {
    c[0] = '\0';
    cout << "1) ClassTest()" << endl;
  }

  // 直接初始化
  ClassTest(const char* pc)  
  {
    strcpy_s(c, pc);
    cout << "2) ClassTest (const char *pc)" << endl;
  }

  //复制/拷贝构造函数
  ClassTest(const ClassTest& ct)  
  {
    strcpy_s(c, ct.c);
    cout << "3) ClassTest(const ClassTest& ct)" << endl;
  }

  //重载赋值操作符
  ClassTest& operator=(const ClassTest& ct)  
  {
    strcpy_s(c, ct.c);
    cout << "4) ClassTest& operator=(const ClassTest &ct)" << endl;
    return *this;
  }

 private:
  char c[256];
};

ClassTest func(ClassTest temp) { return temp; }

int demo_test() {
  cout << "ct1: ";
  ClassTest ct1("ab");  // 直接初始化
  cout << "ct2: ";
  ClassTest ct2 = "ab"; // 直接初始化

  
  cout << "ct3: ";
  ClassTest ct3 = ct1;  // 复制初始化
  cout << "ct4: ";
  ClassTest ct4(ct1);   // 复制初始化
  cout << "ct5: ";
  ClassTest ct5 = ClassTest();  // 默认构造函数
  
  cout << "\nct6: "; // 依次調用 1)、2）、4），即默认、直接、重载
  ClassTest ct6;  
  ct6 = "caoyan is a Good boy!"; 

  cout << "\nct7: ";  
  ClassTest ct7;  // 依次調用 1)、3）、3）、4）
  ct7 = func(ct6);

  return 0;
}

// （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');/
  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;
}

int x = 0;          // 显示初始化x
SubClass subClass;  // 依赖SubClass的default constructor进行初始化

#include <iostream> 
#include <vector> 
#include <map> 
#include <string> 
 
using std::cout; 
using std::endl; 
using std::vector; 
using std::map; 
using std::string; 
 
class NumbericInitTestClass 
{ 
public: 
    void PrintCounter() 
    { 
        cout <<"counter = " <<counter <<endl; 
    } 
private: 
    int counter; 
}; 
 
 
int main() 
{ 
    NumbericInitTestClass tnc; 
    tnc.PrintCounter(); 
 
    map<string, int> mapTest; 
    cout <<mapTest["me"] <<endl; 
 
    vector<NumbericInitTestClass> vecNumbericTestClass(1); 
    vecNumbericTestClass[0].PrintCounter(); 
 
    return 0; 
}