9.构造函数和析构函数

文章内容

  1. 构造函数和析构函数的由来？
  2. 构造函数和析构函数的基本语法
  3. C++编译器构造析构方案 PK 对象显示初始化方案
  4. 构造函数的分类以及调用
  5. 默认的构造函数
  6. 构造函数调用规则
  7. 构造函数和析构函数的总结
  8. 例子

1.构造函数和析构函数的由来？

　　类的数据成员不能在类的声明时候初始化，如何解决这个问题? 使用构造函数处理对对象的初始化。构造函数是一种特殊的成员函数，与其他函数不同，不需要用户调用它，而是创建对象的时候自动调用。析构函数是对象不再使用的时候，需要清理资源的时候调用。

2.构造函数和析构函数的基本语法

A.构造函数:

  • C++中的类需要定义与类名相同的特殊成员函数时，这种与类名相同的成员函数叫做构造函数;
  • 构造函数可以在定义的时候有参数;
  • 构造函数没有任何返回类型。
  • 构造函数的调用：一般情况下，C++编译器会自动的调用构造函数。特殊情况下，需要手工的调用构造函数。
class Maker
{
    public:
        //构造函数的作用是初始化成员变量，是编译器去调用的
        Maker()
        {
            a = 10;
            cout << "构造函数" << endl;
        }

        //析构函数，在对象销毁前，编译器调用析构函数
        ~Maker()
        {
            cout << "析构函数" << endl;
        }
    public:
        int a;
};

B.析构函数:

  • C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的函数是析构函数;
  • 析构函数没有参数和没有任何返回类型;
  • 析构函数在对象销毁的时候自动调用;
  • 析构函数调用机制: C++编译器自动调用。
class Maker
{
    public:
        //构造函数的作用是初始化成员变量，是编译器去调用的
        Maker()
        {
            a = 10;
            cout << "构造函数" << endl;
        }

        //析构函数，在对象销毁前，编译器调用析构函数
        ~Maker()
        {
            cout << "析构函数" << endl;
        }
    public:
        int a;
};

3.C++编译器构造析构方案 PK 对象显示初始化方案

class Test
{
private:
    int x;
public:
    Test(int x)
    {
        this->x = x;
        cout << "对象被创建" << endl;
    }
    Test()
    {
        x = 0;
        cout << "对象被创建" << endl;
    }
    void init(int x)
    {
        this->x = x;
        cout << "对象被创建" << endl;
    }
    ~Test()
    {
        cout << "对象被释放" << endl;
    }
    int GetX()
    {
        return x;
    }
};

int main()
{
    //1.我们按照C++编译器提供的初始化对象和显示的初始化对象
    Test a(10);
    Test b;      //显示创建对象但是还是调用无参构造函数,之后显示调用了初始化函数
    b.init(10);

    //创建对象数组（使用构造函数）
    Test arr[3] = {Test(10),Test(),Test()};
    //创建对象数组 (使用显示的初始化函数)
    Test brr[3];   //创建了3个对象,默认值
    cout<<brr[0].GetX()<<endl;
    brr[0].init(10);
    cout<<brr[0].GetX()<<endl;
    return 0;
}
————————————————
版权声明：本文为CSDN博主「下忍」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/wue1206/article/details/81137353

　　根据上面的代码, 我们得出使用显示的初始化方案: a.必须为每个类提供一个public的init函数; b. 对象创建后必须立即调用init函数进行初始化。
优缺点分析:

A. init函数只是一个普通的函数,必须显示的调用;
B. 一旦由于失误的原因,对象没有初始化,那么结果也是不确定的。没有初始化的对象,其内部成员变量的值是不定的;
C. 不能完全解决问题。

4.构造函数的分类以及调用

A. 无参构造函数

class Test
{
  private:
       int x;
  public:
       Test()
       {
         this->x=10;
       }
}

无参构造函数的调用: Test a;

B. 有参构造函数

class Test
{
  private:
       int x;
  public:
       Test(int x)
       {
         this->x=x;
       }
}

有参数构造函数的调用时机:

  • Test a(10); 调用有参数构造函数
  • Test b=(2,3); 逗号表达式的值是最后一位,调用有参数构造函数
  • Test c=Test(2); 产生一个匿名对象,直接转化成c（只会调用一次有参数构造函数）

C. 拷贝构造函数: 使用对象a初始化对象b

class Test
{
   private:
          int x;
   public:
          Test(const Test& a)
          {
             this->x=a.x;
          }
}

拷贝构造函数的调用时机:

class Test
{
private:
    int x;
public:
    Test(int x)
    {
        this->x = x;
        cout << "对象被创建" << endl;
    }
    Test()
    {
        x = 0;
        cout << "对象被创建" << endl;
    }
    ~Test()
    {
        cout << "对象被释放" << endl;
    }
    Test(const Test& a)
    {
        this->x = a.x;
        cout << "对象被释放（拷贝构造函数）" << endl;
    }
};
————————————————
版权声明：本文为CSDN博主「下忍」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/wue1206/article/details/81137353
  • 第一个场景: 用对象a初始化对象b:
Test a(10);
//调用的是拷贝构造函数
Test b = a;
  • 第二个场景: 用对象a初始化对象b
Test a(10);
//调用的是拷贝构造函数
Test b(a)

第一个场景和第二个场景是一样的,用一个对象初始化另一个对象。

  • 第三个场景: 实参初始化形参的时候,会调用拷贝构造函数
Test a(10);
    //实参初始化形参
    PrintF(a);
  • 第四个场景: 函数返回一个匿名对象
    我们分析第四个场景前,我们看看下面的这个全局函数:
//该函数返回的是谁?
Test p()
{
    Test c(4);
    return c;
}

根据输出结果表明:

03构造函数和析构函数1

函数返回的是一个匿名对象。我们现在可以知道第四个调用场景是函数返回一个匿名对象的时候,会调用拷贝构造函数。
我们接着分析下面的两种情况:(接收匿名对象),判断匿名对象的去和留
A. 匿名对象初始化另一个对象:

Test a=p();

输出结果:

03构造函数和析构函数2

表明使用匿名对象初始化一个对象的时候, 匿名对象直接转化成初始化的那个对象。
B. 匿名对象赋值时:

 Test b;
    //匿名对象赋值另一个对象
    b = p();

输出结果:

03构造函数和析构函数3

表明使用匿名对象赋值另一个对象的时候,匿名对象赋值以后就会被析构。
匿名对象去和留总结:
A. 匿名对象初始化另一个对象时,匿名对象直接变成有名的对象(初始化的那个对象);
B. 匿名对象赋值另一个对象时,匿名对象赋值成功会被析构。

5.默认的构造函数

两个特殊的构造函数:
a. 默认的无参数构造函数: 当类中没有定义构造函数时,编译器会提供一个无参数构造函数,并且函数体为空;
b. 默认的拷贝构造函数: 当类中没有定义拷贝构造函数时,编译器会提供一个默认的拷贝构造函数,简单的进行成员变量的值复制。

6.构造函数调用规则

A. 当类中没有定义一个构造函数的时候,C++编译器会提供默认的无参数构造函数和拷贝构造函数;
B. 当类中定义了拷贝构造函数,C++编译器不会提供无参数构造函数;
C. 当类中定义了任意的非拷贝构造函数,C++编译器不会提供默认的无参数构造函数;
D. 默认的拷贝构造函数只是进行成员变量的简单赋值;

7.构造函数和析构函数的总结

A. 构造函数时C++中用于初始化对象状态的特殊函数;
B. 构造函数在对象创建的时候自动调用;
C. 构造函数和普通成员函数都遵循重载原则;
D. 拷贝构造函数是对象正确初始化的重要保障;
E. 必要的时候必须手工的写拷贝构造函数。

8.例子

//2022年9月5日09:09:45
#include <iostream>
using namespace std;

class Maker
{
    public:
        //构造函数的作用是初始化成员变量，是编译器去调用的
        Maker()
        { 
            a = 10;
            cout << "构造函数" << endl;
        }

        //析构函数，在对象销毁前，编译器调用析构函数
        ~Maker()
        {
            cout << "析构函数" << endl;
        }
    public:
        int a;
}; 

void test01()
{
    //实例化对象，内部做了两件事，1.分配空间， 2.调用构造函数进行初始化
    Maker m;
    int b = m.a;
    cout << b << endl;
}

//析构函数的作用
class Maker2
{
    public:
        //有参构造
        Maker2(const char *name, int age)
        {
            cout << "有参构造" << endl;
            //从堆区空间申请
            pName = (char *)malloc(strlen(name) + 1);
            strcpy(pName, name);
            mAge = age;
        }

        void printMaker2()
        {
            cout << "name: " << pName << " age: " << mAge << endl;
        }

        ~Maker2()
        {
            cout << "析构函数" << endl;
            //释放堆区空间
            if (pName != NULL)
            {
                free(pName);
                pName = NULL;
            }
        }

    private:
        char * pName;
        int mAge;
};

void test02()
{
    Maker2 m2("翠花", 18);
    m2.printMaker2();  
}
int main()
{
    test02();
    Maker m2;

    system("pause");
    return EXIT_SUCCESS;
}

参考资料

参考资料来源于黑马程序员等

posted @   CodeMagicianT  阅读(60)  评论(0)  编辑  收藏  举报
相关博文：
· day03笔记
· 第三天总结
· C++构造函数和析构函数
· C++对象的初始化与清理
· 【C++】类的构造函数&析构函数
阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）
点击右上角即可分享
微信分享提示