C++构造函数，析构函数，拷贝构造函数详解

最新推荐文章于 2022-11-18 10:43:41 发布
最新推荐文章于 2022-11-18 10:43:41 发布
阅读量292 收藏 3
点赞数 1
分类专栏： C++学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovelyGFR/article/details/107627825
版权

文章目录

一 . 对象的初始化和清理

c++利用构造函数和析构函数进行对象的初始化和清理，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供

编译器提供的构造函数和析构函数是空实现。

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

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

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

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

  1. 析构函数，没有返回值也不写void
  2. 函数名称与类名相同,在名称前加上符号 ~
  3. 析构函数不可以有参数，因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
#include <iostream>
using namespace std;

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

};

void test01()
{
    Person p;       //在栈上的数据，test01执行完毕后，释放这个对象，调用析构函数
}

int main() {

    test01();       //test01执行完毕后，释放这个对象，调用析构函数
    //Person p;       //在这儿不会调用析构函数，因为main函数还没有执行完毕，并且有“按任意键继续挡住了”，在程序退出的那一瞬间，调用析构函数
    system("pause");

    return 0;
}

初始化列表


#include <iostream>
using namespace std;

class Person {
public:

    传统方式初始化
    //Person(int a, int b, int c) {
    //	m_A = a;
    //	m_B = b;
    //	m_C = c;
    //}

    //初始化列表方式初始化
    Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
    void PrintPerson() {
        cout << "mA:" << m_A << endl;
        cout << "mB:" << m_B << endl;
        cout << "mC:" << m_C << endl;
    }
private:
    int m_A;
    int m_B;
    int m_C;
};

int main() {

    Person p(1, 2, 3);
    p.PrintPerson();


    system("pause");

    return 0;
}


二 . 构造函数的分类及调用

两种分类方式：

​ 按参数分为： 有参构造和无参构造

​ 按类型分为： 普通构造和拷贝构造

三种调用方式：

​ 括号法

​ 显示法

​ 隐式转换法

#include <iostream>
using namespace std;

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

class Person {
public:
    int age;

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

//2、构造函数的调用
//调用无参构造函数
void test01() {
    Person p1; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

    //2.1  括号法，常用
    Person p2(10);
    Person p3(p2);
    //注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
    //Person p2();

    //2.2 显式法
    Person p4 = Person(10);
    Person p5 = Person(p2);
    //Person(10)单独写就是 匿名对象  当前行结束之后，马上析构

    //注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明  Person(p4)  == Person p4   ,p4重定义，名称重复了
    //Person(p4);

    //2.3 隐式转换法
    Person p6 = 10; // Person p4 = Person(10);
    Person p7 = p4; // Person p5 = Person(p4);

}

int main() {

//    test01();
    test02();

    system("pause");

    return 0;
}


三 . 拷贝构造函数调用时机

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

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值
  • 以值方式返回局部对象
#include <iostream>
using namespace std;

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;
}

四 . 构造函数调用规则

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

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝


构造函数调用规则如下：

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

  • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

#include <iostream>
using namespace std;

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();
    test02();
    system("pause");

    return 0;
}


五 . 深拷贝与浅拷贝


浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作


#include <iostream>
using namespace std;

class Person {
public:
    //无参（默认）构造函数
    Person() {
        cout << "无参构造函数!" << endl;
    }
    //有参构造函数
    Person(int age ,int height) {

        cout << "有参构造函数!" << endl;

        m_age = age;
        //在堆区开辟一块内存
        m_height = new int(height);

    }
    //拷贝构造函数
    Person(const Person& p) {
        cout << "拷贝构造函数!" << endl;
        //如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
        //编译器的浅拷贝
        //m_age = age;
        //m_height = height;
        //***********************************************
        // 这儿(m_height = height;)指向的就是堆区的同一个位置，
        // 在执行析构函数的过程中，先释放 p2，堆区的内存被释放 ，
        // 在释放 p1的时候 ， 造成了内存重复释放的问题 ，报错！！
        //***********************************************

        //深拷贝
        m_age = p.m_age;
        m_height = new int(*p.m_height);

    }

    //析构函数
    ~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;
}


六 . 类对象作为类成员的调用规则

当类中成员是其他类对象时，我们称该成员为 对象成员

构造的顺序是 ：先调用对象成员的构造，再调用本类构造

析构顺序与构造顺序相反


#include <iostream>
using namespace std;

class Phone
{
public:
    Phone(string name)
    {
        m_PhoneName = name;
        cout << "Phone构造" << endl;
    }

    ~Phone()
    {
        cout << "Phone析构" << endl;
    }

    string m_PhoneName;

};


class Person
{
public:

    //初始化列表可以告诉编译器调用哪一个构造函数
    //Phone m_Phone = pName    隐式转换法
    Person(string name, string pName) :m_Name(name), m_Phone(pName)
    {
        cout << "Person构造" << endl;
    }

    ~Person()
    {
        cout << "Person析构" << endl;
    }

    void playGame()
    {
        cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
    }

    string m_Name;
    Phone m_Phone;

};
void test01()
{
    //当类中成员是其他类对象时，我们称该成员为 对象成员
    //构造的顺序是 ：先调用对象成员的构造，再调用本类构造
    //析构顺序与构造相反
    Person p("张三" , "苹果X");
    p.playGame();

}


int main() {

    test01();

    system("pause");

    return 0;
}


七 . 静态成员

静态成员就是在成员变量和成员函数前加上关键字static ，称为静态成员

静态成员分为：

  • 静态成员变量
    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化
  • 静态成员函数
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量

#include <iostream>
using namespace std;

class Person
{
public:
    static int m_A; //静态成员变量

    //静态成员变量特点：
    //1 在编译阶段分配内存
    //2 类内声明，类外初始化
    //3 所有对象共享同一份数据

private:
    static int m_B; //静态成员变量也是有访问权限的
};

//类内定义，类外初始化静态变量
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
    //静态成员变量两种访问方式

    //1、通过对象
    Person p1;
    p1.m_A = 100;
    cout << "p1.m_A = " << p1.m_A << endl;

    Person p2;
    p2.m_A = 200;
    cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
    cout << "p2.m_A = " << p2.m_A << endl;

    //2、通过类名
    cout << "m_A = " << Person::m_A << endl;


    //cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {

    test01();

    system("pause");

    return 0;
}


#include <iostream>
using namespace std;

class Person
{

public:

    //静态成员函数特点：
    //1 程序共享一个函数
    //2 静态成员函数只能访问静态成员变量

    static void func()
    {
        cout << "func调用" << endl;
        m_A = 100;
        //m_B = 100; //错误，不可以访问非静态成员变量
    }

    static int m_A; //静态成员变量
    int m_B; //
private:

    //静态成员函数也是有访问权限的
    static void func2()
    {
        cout << "func2调用" << endl;
    }
};
int Person::m_A = 10;


void test01()
{
    //静态成员变量两种访问方式

    //1、通过对象
    Person p1;
    p1.func();

    //2、通过类名
    Person::func();


    //Person::func2(); //私有权限访问不到
}

int main() {

    test01();

    system("pause");

    return 0;
}


参考资料 ：

https://www.bilibili.com/video/BV1et411b73Z

小黑GFR
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
构造函数，复制构造函数，析构函数
weixin_43810326的博客
08-12 264
构造函数： 创建对象时利用特定的值构造对象，将对象初始化为一个特定的状态。 构造函数的函数名与类名相同，且没有返回值。通常被声明为公有函数。 默认构造函数：如果没有声明构造函数时，编译器自动生成一个无参的构造函数。 函数体为空的构造函数并非什么都不做，因为它还要负责基类的构造和成员对象的构造。 构造函数的执行顺序： 如果该类存在虚基类，则先调用虚基类的构造函数完成对虚基类成员的初始化。（虚基类）...
C++入门：构造函数，析构函数，拷贝构造函数详解
m0_54850825的博客
05-19 952
目录 类的6个默认成员函数 一.构造函数 1.概念 2.特征如下： 1. 函数名与类名相同。 2. 无返回值。 3. 对象实例化时编译器自动调用对应的构造函数。 4. 构造函数可以重载。 5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。 ?6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 7. 关于编译器生成的默认成员函数，很多同学会有疑惑： ?8. （了解）C++11打的补丁： 二.析构函数 1.概
C++对象的初始化和清理
qq_46359697的博客
10-12 482
对象的初始化和清理1.构造函数和析构函数2.构造函数的分类及调用3. 拷贝构造函数调用时机4.构造函数调用规则5.深拷贝与浅拷贝6.总结 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全 C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。 1.构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 ​ 一个对象或者变量没有初始状态，对其使用后果是未知 ​ 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安
C++之构造函数，析构函数，拷贝构造函数
雨于鱼的博客
05-06 854
一、定义    构造函数：是在一个定义在类里面的函数，它的作用是在你创建这个类的对象时被自动调用。                    如果你自己定义了则调用自己定义的，否则调用默认的。    析构函数：是一个在类里面定义的函数，它的作用是在你的类对象死亡时被调用删除这个类对                    象同样的你自己定义了则调用自己的，否则调用默认的。    在了解拷贝构造函数之前先...
C++ 构造函数、析构函数、拷贝构造函数
baidu_41388533的博客
06-03 1941
原文链接：构造函数、析构函数、拷贝构造函数 一、构造函数 概念(作用)： 用来在创建对象时，对对象进行初始化 特点 构造函数无返回值，函数名与类名相同，必须存在于public中 构造函数可以重载 不用来初始化static数据成员，因为static数据成员不属于类 默认构造函数（合成的构造函数） 如果没有在类中给出构造函数，编译器自动生成一个默认的构造函数(无参数、函数体为空) 当在类中手动给出构造函数时，默认的构造函数消失 编译器自动生成的默认的构造函数又称为“合成的默认构造.
【C++】构造函数、析构函数、拷贝构造函数
m0_55752775的博客
11-17 2039
C++的构造函数、析构函数、拷贝构造函数
C++构造函数，析构函数以及浅拷贝
m0_53101047的博客
10-08 179
构造函数 当进行构造对象的时候默认调用的成员方法 如果没有实现构造函数，系统会生成一个默认构造函数 当自己实现了构造函数之后，系统就不会生成默认构造函数了 默认构造函数：除了this指针以外没有其他参数的构造函数 在调用默认构造函数时，不带括号，与定义对象的形式的一致。例如：Person p1;//ok Person p1();//error 为什么要引入构造函数？ 如果在创建一个对象时，要给它赋初值，如果给一个对象赋值，很容易，可如果要给多个对象赋值，就得一个一个的来，比较费时，所以..
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
08-29
在C++编程中，正确地管理类的构造函数、拷贝构造函数、析构函数和赋值函数是创建健壮、无内存泄漏程序的关键。接下来将详细介绍如何为自定义的String类编写这些函数，并通过实例来加深理解。 首先，我们定义一个...
C++中构造函数与析构函数的调用顺序详解
12-31
在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。 简单来说，其构造函数...
C++ 类中的 构造函数、拷贝构造函数、析构函数
Super-Father
10-27 750
一、构造函数 ① 概念 构造函数就是和类名一样，而且是没有返回值的函数。如下所示: class demo_class { public: demo_class();//构造函数 如果不指定属性，则默认为私有的 }; 如果类里面的构造函数demo_class是私有的，那样就会编译器就会报错。如下图所示： ② 特点 ① 如果自己没有定义构造函数，则编译器会使用默认构造函数。 ② 默认的构造函数是一个空的函数。 ③ 构造函数可以重载，只需要通过形参的不同辨别即可。 ③ 作用
C++实现 类string的 普通构造函数， 拷贝构造函数 析构函数 和赋值函数
10-04
C++实现 类string的 普通构造函数， 拷贝构造函数 析构函数 和赋值函数
构造函数，拷贝构造函数，析构函数，赋值函数
一步两步先生的博客
10-15 1101
例一： class CGoods {     //行为，成员方法 public:     CGoods(char *name = NULL, int amount = 0, double price = 0.0) //构造函数     {         if (name == NULL)         {             mpName = new char[1];          ...
C++ 构造函数、析构函数、拷贝构造函数
weixin_52571040的博客
11-09 996
C++ 5 类和对象（中）构造函数概念及特性析构函数概念特性 构造函数 概念及特性 对于类中的成员变量，可以通过调用方法来给对象赋值，但如果每次创建对象都得调用一次，未免有些麻烦 那有没有方法能在实例化对象时就调用并能将信息设置进去呢 1 #include <iostream> 2 using namespace std; 3 4 class Test
构造函数、析构函数、拷贝构造函数、
最新发布
嘴大且吃雯的博客
11-18 1175
默认构造函数的重要性、析构函数的参数只能为类类型对象的引用，浅拷贝对于资源管理方面的处理。
C++入门--构造函数、拷贝构造函数、析构函数
weixin_44627813的博客
02-08 500
构造函数 构造函数：主要作用在于创建对象时为对象的成员属性赋值，由编译器自动调用，无须手动调用。在对象的生命周期中只调用一次。 特性 特性如下： ■ 1、函数名和类名相同。 ■ 2、没有返回值，而且不能有void。 ■ 3、有参数，支持重载。 ■ 4、对象实例化时编译器自动调用对应的构造函数。 class Date{ public: //无参构造函数 Date(){ } //有参构造函数 Date(int year,int month,int day){ _year=year; _mo
构造函数、拷贝构造函数、析构函数
PYTHON的博客
07-24 326
构造函数、拷贝构造函数、析构函数 构造函数 一、概念 构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时，由编译器自动调用，在对象的生命周期内只调用一次且是在创建对象时被调用的，它保证了每个成员都有一个合适的初始值。 //代码 //构造函数 class Date { public: Date(int year, int month, int day) { ...
构造函数、拷贝构造函数和析构函数
Better_JH的博客
10-18 464
构造函数  构造函数：是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，在对象的生命周期内只且只调用一次，以保证每个数据成员都有一个合适的初始值。 构造函数的特性：      1、函数名与类名相同；      2、不具有任何类型，没有返回值；      3、有初始化列表（可以不用）：每个数据成员在初始化列表中只能出现一次；初始化列表仅用于初始化数据成员，并不指定数据
构造函数，析构函数，拷贝构造函数
qq_42560102的博客
09-10 699
构造函数 析构函数 构造函数的重载 拷贝构造函数 构造函数     构造函数是一种特殊的成员函数， 别声明为公有成员，其作用是为类的对象分配内存空间，进行初始化。 构造函数的性质：     构造函数的名字必须与类的名字完全相同。     构造函数没有返回值， 不能定义返回类型，包括void型在内。     对象定义时， 编译系统会自动地调用构造函数完成对象内存空间的分配和初始化工作。     ...
构造函数，复制构造函数和析构函数
qq_36284852的博客
05-12 281
这些函数在网上很容易就可以查到定义和写法，这里就不赘述了。令人感兴趣的是这些函数什么时候执行， 特别是复制构造函数和析构函数。 用编写的一段（很丑的）代码来说明。 #include<iostream> #include<cstdio> #include<cmath> class Point { private: /* data */ double x, y ; friend Point& __doa(Point *ths, const Point&amp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值