C++学习小记之构造函数和析构函数

对象的初始化和清理

构造函数和析构函数

对象的初始化和清理是非常重要的安全问题

• 一个对象或者变量没有初始化状态，对其使用后果是未知的
• 同样的使用完一个对象或变量，没有及时的处理，也会造成一定的安全问题

构造函数：创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
析构函数：对象销毁前自动调用，执行一些清理工作

当我们不提供构造和析构时，编译器会提供，而编译器提供的时空实现的

构造函数语法：类名(){}

1. 无返回值也不写void
2. 函数名称与类名相同
3. 可以有参数，因此可以发生重载
4. 程序再调用对象时候会自动调用，无须手动调用，而且仅会调用一次

析构函数语法：~类名(){}

1. 无返回值也不写void
2. 函数名称与类名相同，在前面加上~
3. 不可以有参数，因此不可以发生重载
4. 对象销毁前自动调用析构，无需手动调用，且仅调用一次

#include <iostream>
using namespace std;

class Person
{
public:
    Person()
    {
        cout << "构造函数的调用" << endl;
    }
    ~Person()
    {
        cout << "析构函数的调用" << endl;
    }

};

void test01()
{
    Person p;
} //为局部变量，函数调用后被立刻释放，因此析构和构造函数都会被调用

int main()
{
    Person p2;  //仅调用构造函数，析构函数在main函数执行完才会调用
    test01();
    return 0;
}

构造函数的分类

• 按照参数分类，可以分为有参和无参的构造函数，无参又称为默认构造函数
• 按照类型分类分为普通构造和拷贝构造

#include <iostream>
using namespace std;

class Person
{
   
public:
    int age;
    Person()  //无参构造函数
    {
        cout << "默认构造函数的调用" << endl;
    }
    Person(int a)
    {
        age = a;
        cout << "有参构造函数的调用" << endl;
    }
    Person(const Person& p)
    {
        age = p.age;
        cout << "拷贝构造函数的调用" << endl;
    }
    ~Person()  //析构函数
    {
        cout << "析构函数的调用" << endl;
    }
};

void test01()
{
    Person p1;//调用无参的构造函数
    Person p2(10);//调用有参的构造函数
    Person p3(p2);//调用拷贝构造函数

} 

void test02()
{
    //括号法
    Person p1(10);
    //ps:调用无参构造函数不能加括号，如果加了编译器会认为i这是一个函数声明
    //Person p2()not right

    //显示法
    Person p2= Person(10);
    Person p3 = Person(p2);

    //Person(10)单独写为匿名对象，当前行结束后，马上析构

    //不能利用拷贝函数初始化匿名对象，编译器会认为是对象声明
    //Person p5(p4);

    //隐式转换法
    Person p4 = 10;//Person p4 = Person(10);
    Person p5 =p4;//Person p5 = Person(p4);
}   

    

int main()
{
    Person p2;  //仅调用构造函数，析构函数在main函数执行完才会调用
    test01();
    return 0;
}

拷贝构造函数调用时机

C++中拷贝构造函数调用的时机通常有三种情况

• 使用一个已经创建完毕的对象来初始化一个新的对象
• 值传递的方式给函数参数传值
• 以值的方式返回局部对象

#include <iostream>
using namespace std;
class Person{
public:
   Person(){
          cout <<"无参构造函数调用"<<end;
          mAge=0;
            }
  Person(int age){
     cout <<"有参构造函数函数调用"<<end;
     mAge=age;
     }
   Person(const Person &p){
     mAge=p.age;
     }
int age;


 ~Person(){
     cout <<"Person析构构造函数调用"<<end;
         }

};
//1.使用一个已经创建完毕的对象来初始化一个新的对象
void test01()
{
Person p1(20);
Person p2(p1);
}
//2.值传递的方式给函数参数传值
void doWork(Person p)
{
//此处的p是拷贝过的，在此处更改p的值对于test02()中的数据无影响。
}
void test02()
{
Person p;
dowork(p);
}

//3.值方式返回局部对象
Person doWork2()
{
Person p1;
cout<<(int*)&p1<<endl;
return p1;//用值的方式返回，返回的是拷贝出来的新的对象，而不是函数中的p1；

}

void test03()
{
Person p=doWork2();
cout<<(int*)&p<<endl;//打印地址可以发现该地址与上面doWork2()中p1的地址不同。
}
int main()
{
test01(); //1.使用一个已经创建完毕的对象来初始化一个新的对象
test02();//2.值传递的方式给函数参数传值
test03();//3.值方式返回局部对象
return 0;
}

构造函数的调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1. 默认构造函数无参（函数体为空）
2. 默认析构函数无参 (函数体为空)
3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，C++不会再提供其它构造函数

#include <iostream>
using namespace std;
class Person{
public:
   Person(){
          cout <<"无参构造函数调用"<<end;
          m_Age=0;
            }
  Person(int age){
     cout <<"有参构造函数函数调用"<<end;
     m_Age=age;
     }
   Person(const Person &p){
     cout <<"拷贝构造函数函数调用"<<end;
     m_Age=p.age;
     }
int m_Age;


 ~Person(){
     cout <<"Person析构构造函数调用"<<end;
         }

};


void test01()
{
   Person p;
   p.m_Age=18;
   Person p2(p);    //当类中拷贝构造函数备注释掉后，p2的年龄依然为18，但不会输出"拷贝构造函数函数调用"的显示。
   count <<"p2的年龄为："<<p2.m_Age<<endl;

}

void test02()
{
Person p;//此时如果注释掉类中的默认构造函数，编译器会报错，因为当用户定义了有参构造函数，那么C++不再提供无参构造函数。
//如果讲有参和无参构造函数注释掉，则此行依然会出错，因为如果用户定义拷贝构造函数，C++不会再提供其它构造函数
Person p1;
Person p2(p1);//注释掉拷贝构造函数和默认构造函数，此段代码不会出错
}

int main()
{
test01();
test02();

return 0;
}

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝
深拷贝：在堆区重新申请空间，进行拷贝操作

#include <iostream>
using namespace std;
class Person{
public:
   Person(){
          cout <<"无参构造函数调用"<<end;
          m_Age=0;
            }
  Person(int age,int height){
     cout <<"有参构造函数函数调用"<<end;
     m_Age=age;
     m_Height=new int(height);
     }
   Person(const Person &p){
     cout <<"拷贝构造函数函数调用"<<end;
     m_Age=p.age;
     //m_Height=p.m_Height;//此为编译器默认实现的代码
     //深拷贝的操作
     m_Height=new int(*p.m_Height);
     }
int m_Age;
int *m_Height;

 ~Person(){
 //析构代码，将堆区开辟数据做释放的操作
     if(m_Height!=NULL)
     {
      delet m_Height;
      m_Height=NULL;
     }//此时会出错，因为此时p1和p2的身高所指向的空间是同一个空间，而当p2的析构函数释放该处的内存后(先进后出p2先被释放)，p1的析构函数会再次释放此内存，因此会出错
     //解决此问题应当自己写拷贝函数，使得两个函数指向的空间不同
     cout <<"Person析构构造函数调用"<<end;
         }

};
void test01()
{
  Person p1(18,160);
  cout<<"p1的年龄为:"<<p1.m_Age<<"身高为："<<*p1.m_Height<<endl;
  Person p2(p1);
  cout<<"p2的年龄为:"<<p2.m_Age<<"身高为："<<*p2.m_Height<<endl;
 
}
int main()
{
test01();

  return 0;
}