C++類別中三大函數詳解(構造、解構和拷貝)

class Person
{
  public:
  //建構函式
  Person()
 {
  cout << "Person的建構函式呼叫" << endl;
 }
//解構函式
~Person()
 {
   cout << "Person的解構函式呼叫" << endl;
 }
};
void test01()
{
  Person p;
}
int main()
 {
   test01();
   system("pause");
   return 0;
 }

//1、建構函式分類
// 按照引數分類分為 有參和無參構造 無參又稱為預設建構函式
// 按照型別分類分為 普通構造和拷貝構造
class Person {
public:
 
//無參（預設）建構函式
Person() {
cout << "無參建構函式!" << endl;
}
 
//有參建構函式
Person(int a) {
age = a;
cout << "有參建構函式!" << endl;
}
 
//拷貝建構函式
Person(const Person& p) {
age = p.age;
cout << "拷貝建構函式!" << endl;
}
 
//解構函式
~Person() {
cout << "解構函式!" << endl;
}
 
public:
int age;
};
 
//2、建構函式的呼叫
//呼叫無參建構函式
void test01() {
Person p; //呼叫無參建構函式
}
 
//呼叫有參的建構函式
void test02() {
//2.1 括號法，常用
Person p1(10);
//注意1：呼叫無參建構函式不能加括號，如果加了編譯器認為這是一個函數宣告
//Person p2();
 
//2.2 顯式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)單獨寫就是匿名物件 當前行結束之後，馬上解構
 
//2.3 隱式轉換法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2：不能利用 拷貝建構函式 初始化匿名物件 編譯器認為是物件宣告
//Person p5(p4);
}
int main() {
test01();
//test02();
system("pause");
return 0;
}

class Person {
public:
Person() {
cout << "無參建構函式!" << endl;
mAge = 0;
}
Person(int age) {
cout << "有參建構函式!" << endl;
mAge = age;
}
Person(const Person& p) {
cout << "拷貝建構函式!" << endl;
mAge = p.mAge;
}
//解構函式在釋放記憶體之前呼叫
~Person() {
cout << "解構函式!" << endl;
}
public:
int mAge;
};
//1. 使用一個已經建立完畢的物件來初始化一個新物件
void test01() {
Person man(100); //p物件已經建立完畢
Person newman(man); //呼叫拷貝建構函式
Person newman2 = man; //拷貝構造
//Person newman3;
//newman3 = man; //不是呼叫拷貝建構函式，賦值操作
}
//2. 值傳遞的方式給函數引數傳值
//相當於Person p1 = p;
void doWork(Person p1) {}
void test02() {
Person p; //無參建構函式
doWork(p);
}
//3. 以值方式返回區域性物件
Person doWork2()
{
Person p1;
cout << (int *)&p1 << endl;
return p1;
}
void test03()
{
Person p = doWork2();
cout << (int *)&p << endl;
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}

class Person {
public:
//無參（預設）建構函式
Person() {
cout << "無參建構函式!" << endl;
}
//有參建構函式
Person(int a) {
age = a;
cout << "有參建構函式!" << endl;
}
//拷貝建構函式
Person(const Person& p) {
age = p.age;
cout << "拷貝建構函式!" << endl;
}
//解構函式
~Person() {
cout << "解構函式!" << endl;
}
public:
int age;
};
void test01()
{
Person p1(18);
//如果不寫拷貝構造，編譯器會自動新增拷貝構造，並且做淺拷貝操作
Person p2(p1);
cout << "p2的年齡為： " << p2.age << endl;
}
void test02()
{
//如果使用者提供有參構造，編譯器不會提供預設構造，會提供拷貝構造
Person p1; //此時如果使用者自己沒有提供預設構造，會出錯
Person p2(10); //使用者提供的有參
Person p3(p2); //此時如果使用者沒有提供拷貝構造，編譯器會提供
//如果使用者提供拷貝構造，編譯器不會提供其他建構函式
Person p4; //此時如果使用者自己沒有提供預設構造，會出錯
Person p5(10); //此時如果使用者自己沒有提供有參，會出錯
Person p6(p5); //使用者自己提供拷貝構造
}
int main() {
test01();
system("pause");
return 0;
}

class Person {
public:
//無參（預設）建構函式
Person() {
cout << "無參建構函式!" << endl;
}
//有參建構函式
Person(int age ,int height) {
cout << "有參建構函式!" << endl;
m_age = age;
m_height = new int(height);
cout << "拷貝建構函式!" << endl;
//如果不利用深拷貝在堆區建立新記憶體，會導致淺拷貝帶來的重複釋放堆區問題
m_age = p.m_age;
m_height = new int(*p.m_height)
}
//拷貝建構函式
Person(const Person& p) {
;
}
//解構函式
~Person() {
cout << "解構函式!" << endl;
if (m_height != NULL)
{
delete m_height;
}
}
public:
int m_age;
int* m_height;
};
void test01()
{
Person p1(18, 180);
Person p2(p1);
cout << "p1的年齡： " << p1.m_age << " 身高： " << *p1.m_height << endl;
cout << "p2的年齡： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}
int main() {
test01();
system("pause");
return 0;
}