18 CPP构造函数和析构函数

最新推荐文章于 2023-04-13 20:17:21 发布
最新推荐文章于 2023-04-13 20:17:21 发布
阅读量736 收藏
点赞数
分类专栏： c++ 文章标签： c++ 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wade1010/article/details/128357941
版权

18 CPP构造函数和析构函数

1）构造函数

语法：类名(){.....}

1 访问权限一般是public,有时候可以设置为private，比如单例的时候

2 函数名称必须与类名相同

3 没有返回值，也不写void

4 可以有参数，可以重载，可以有默认参数

5 创建对象时会自动调用一次，不能手工调用。

2）析构函数

语法：~类名(){....}

1 访问权限一般是public,有时候可以设置为private

2 函数名称必须与类名相同,且加~

3 没有返回值，也不写void

4 没有参数，不能重载

5 销毁对象时会自动调用一次，但是可以手工调用。

手动调用析构函数

#include <iostream>

using namespace std;

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

void test() {
    Person p;
    p.~Person();//手动调用析构函数
}

int main() {
    test();
    return 0;
}
//调用了析构函数
//调用了析构函数

注意：

1 如果没有提供构造/析构函数，编译器将提供空实现的构造/析构函数。

2 如果提供了构造/析构函数，编译器将不提供空实现的构造/析构函数。

3 创建对象的时候，如果重载了构造函数，编译器根据实参匹配相应的构造函数，没有参数的构造函数也叫默认构造函数。

4 创建对象的时候不要再对象名后面加空的圆括号，编译器误认为是声明函数。（如果没有构造函数、构造函数没有参数、构造函数的参数都有默认参数）（后面有说明）

5 在构造函数名后面加括号和参数不是调用构造函数，是创建匿名对象。 （后面有说明）

6 接受一个参数的构造函数允许使用赋值语法将对象初始化为一个值（可能会导致问题，不推荐）(后面有说明)

7 以下两行代码有本质的区别：

Person p = Person("hello", 20);//显示创建对象

Person p;//创建对象
p = Person("hello", 20);//创建匿名对象，然后给现有的对象赋值

8 用new/delete 创建/销毁对象时，也会调用构造函数/析构函数。

9 不建议在构造/析构函数中写太多工作（只能成功不会失败，因为没有返回值）

10 除了初始化，不建议让构造函数做太多工作（只能成功不会失败）

11 c++11支持使用统一初始化列表 （后面有说明）

12 如果类的成员也是类，创建对象的时候，先构造成员类；销毁对象时，先析构成员类。

4 创建对象的时候不要再对象名后面加空的圆括号，编译器误认为是声明函数。（如果没有构造函数、构造函数没有参数、构造函数的参数都有默认参数）的代码演示

#include <iostream>
#include <cstring>

using namespace std;

//创建对象的时候不要再对象名后面加空的圆括号，编译器误认为是声明函数。
// （如果没有构造函数、构造函数没有参数、构造函数的参数都有默认参数）
class Person {
public:
    Person() {
        m_Name.clear();
        m_Age = 0;
        memset(m_Hobby, 0, sizeof(m_Hobby));
    }

    Person(string name) {
        m_Name = name;
        m_Age = 0;
        memset(m_Hobby, 0, sizeof(m_Hobby));
        cout << "调用了构造函数" << endl;
    }

    Person(string name, int age) {
        m_Name = name;
        m_Age = age;
        memset(m_Hobby, 0, sizeof(m_Hobby));
        cout << "调用了构造函数" << endl;
    }

    void show() {
        cout << "show" << endl;
    }

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

private:
    string m_Name;
    int m_Age;
    char m_Hobby[30];
};

void test() {
    Person p();//编译不会报错
//    编译warning如下 empty parentheses interpreted as a function declaration
//意思就是 空括号被解释为函数声明
//    p.show();//调用不了
//其实Person p();的意思是声明一个函数返回值为Person的函数，函数名叫p
}

int main() {
    test();
    return 0;
}

5 在构造函数名后面加括号和参数不是调用构造函数，是创建匿名对象。的代码演示

#include <iostream>

using namespace std;

class Person {
public:
    Person() {
        m_Name.clear();
        m_Age = 0;
        memset(m_Hobby, 0, sizeof(m_Hobby));
//        cout << "调用了构造函数Person() " << endl;

    }

    Person(string name) {
        Person();
        m_Name = name;
//        m_Age = 0;
//        memset(m_Hobby, 0, sizeof(m_Hobby));
//        cout << "调用了构造函数Person(string name)" << endl;
    }

    Person(string name, int age) {
        Person();
        m_Name = name;
        m_Age = age;
//        memset(m_Hobby, 0, sizeof(m_Hobby));
//        cout << "调用了构造函数Person(string name, int age)" << endl;
    }

    void show() {
        cout << "姓名：" << m_Name << "，年龄：" << m_Age << " 兴趣：" << m_Hobby << endl;
    }

    ~Person() {
//        cout << "调用了析构函数" << endl;
    }

private:
    string m_Name;
    int m_Age;
    char m_Hobby[30];
};

void test() {
    Person p("kobe", 22);
    p.show();
}

int main() {
    test();
    return 0;
}
/*
 *调用输出内容为：
姓名：kobe，年龄：22 兴趣：�

如果粗心的人，这事就这么过了，留下巨大的bug，因为没有调用构造函数
 16行 24行的 Person(); 的真正含义不是调用构造函数，而是创建一个匿名对象，也叫临时对象
 临时对象的特点，没有名字，创建之后立马就销毁（;后面就开始销毁）
 */

 证明下创建后就销毁了。启用打印日志

#include <iostream>

using namespace std;

class Person {
public:
    Person() {
        m_Name.clear();
        m_Age = 0;
        memset(m_Hobby, 0, sizeof(m_Hobby));
        cout << "调用了构造函数Person() " << endl;

    }

    Person(string name) {
        Person();
        m_Name = name;
//        m_Age = 0;
//        memset(m_Hobby, 0, sizeof(m_Hobby));
//        cout << "调用了构造函数Person(string name)" << endl;
    }

    Person(string name, int age) {
        cout << "start" << endl;
        Person();
        cout << "end" << endl;
        m_Name = name;
        m_Age = age;
//        memset(m_Hobby, 0, sizeof(m_Hobby));
//        cout << "调用了构造函数Person(string name, int age)" << endl;
    }

    void show() {
        cout << "姓名：" << m_Name << "，年龄：" << m_Age << " 兴趣：" << m_Hobby << endl;
    }

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

private:
    string m_Name;
    int m_Age;
    char m_Hobby[30];
};

void test() {
    Person p("kobe", 22);
    p.show();
}

int main() {
    test();
    return 0;
}
/*
 *调用输出内容为：
start
调用了构造函数Person()
调用了析构函数
end
姓名：kobe，年龄：22 兴趣：�
调用了析构函数

 可以从上面输出结果看出
start
调用了构造函数Person()
调用了析构函数
end
 上面输出是25行 Person();  临时对象 创建和销毁时调用的

 */

构造函数没被调用，后果就很难说了，这个要看你的类里面有什么数据类型了，上面的例子不调用构造函数问题不大，如果类里面有指针，那就很危险了。

视频里面说的是：（他的环境是VS）

如下面的代码，加入m_ptr指针，如果构造函数没有被调用，指针不会初始化为空，并且别的地方也没有为指针分配内存，那么m_ptr就是野指针了，然后析构里面的delete m_ptr可能会让程序崩溃。

但是我g++ 测试 delete 没问题

m_ptr默认就是0x0

#include <iostream>
#include <cstring>
using namespace std;

class Person
{
public:
    Person()
    {
        m_Name.clear();
        m_Age = 0;
        m_ptr = nullptr;
        memset(m_Hobby, 0, sizeof(m_Hobby));
        cout << "调用了构造函数Person() 1" << endl;
    }

    Person(string name)
    {
        Person();
        m_Name = name;
        //        m_Age = 0;
        //        memset(m_Hobby, 0, sizeof(m_Hobby));
        //        cout << "调用了构造函数Person(string name)" << endl;
    }

    Person(string name, int age)
    {
        cout << "start" << endl;
        Person();
        cout << "end" << endl;
        m_Name = name;
        m_Age = age;
        //        memset(m_Hobby, 0, sizeof(m_Hobby));
        //        cout << "调用了构造函数Person(string name, int age)" << endl;
    }

    void show()
    {
        cout << "姓名：" << m_Name << "，年龄：" << m_Age << " 兴趣：" << m_Hobby << endl;
    }

    ~Person()
    {
        //        delete m_ptr;//直接写也行，因为对空指针delete是安全的
        cout << m_ptr << endl;
        if (m_ptr != nullptr)
        { // 这样写也行
            delete m_ptr;
            m_ptr = nullptr;
        }
        cout << "调用了析构函数" << endl;
    }

private:
    string m_Name;
    int m_Age;
    char m_Hobby[30];
    int *m_ptr;
};

void test()
{
    Person p("kobe", 22);
    p.show();
}

int main()
{
    test();
    return 0;
}
/*
start
调用了构造函数Person() 1
0x0
调用了析构函数
end
姓名：kobe，年龄：22 兴趣：
0x0
调用了析构函数
 */

6 接受一个参数的构造函数允许使用赋值语法将对象初始化为一个值（可能会导致问题，不推荐）

#include <iostream>

using namespace std;

class Person {
public:
    Person() {
        m_Name.clear();
        m_Age = 0;
        m_ptr = nullptr;
        memset(m_Hobby, 0, sizeof(m_Hobby));
    }

    Person(string name) {
        m_Name = name;
        m_Age = 0;
        m_ptr = nullptr;
        memset(m_Hobby, 0, sizeof(m_Hobby));
    }

    Person(int age) {
        m_Name.clear();
        m_Age = age;
        m_ptr = nullptr;
        memset(m_Hobby, 0, sizeof(m_Hobby));
    }

    void show() {
        cout << "姓名：" << m_Name << "，年龄：" << m_Age << " 兴趣：" << m_Hobby << endl;
    }

    ~Person() {
//        delete m_ptr;//直接写也行，因为对空指针delete是安全的
        cout << m_ptr << endl;
        if (m_ptr != nullptr) {//这样写也行
            delete m_ptr;
            m_ptr = nullptr;
        }
        cout << "调用了析构函数" << endl;
    }

private:
    string m_Name;
    int m_Age;
    char m_Hobby[30];
    int *m_ptr;
};

void test() {
    Person p = string("hello");
    p.show();
    Person p2 = 11;
    p2.show();
}

int main() {
    test();
    return 0;
}
/*
姓名：hello，年龄：0 兴趣：
姓名：，年龄：11 兴趣：
0x0
调用了析构函数
0x0
调用了析构函数
 */

11 c++11支持使用统一初始化列表

#include <iostream>

using namespace std;

class Person {
public:
    Person() {
        m_Name.clear();
        m_Age = 0;
        m_ptr = nullptr;
        memset(m_Hobby, 0, sizeof(m_Hobby));
        cout << "调用构造函数Person()" << endl;
    }

    Person(string name, int age) {
        m_Name = name;
        m_Age = age;
        m_ptr = nullptr;
        memset(m_Hobby, 0, sizeof(m_Hobby));
        cout << "调用构造函数Person(string name, int age)" << endl;
    }

    void show() {
        cout << "姓名：" << m_Name << "，年龄：" << m_Age << " 兴趣：" << m_Hobby << endl;
    }

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

private:
    string m_Name;
    int m_Age;
    char m_Hobby[30];
    int *m_ptr;
};

void test() {

    Person p = {"hello", 19};
    Person p2{"hello", 19};
    Person *ptr = new Person{"hello", 19};
}

int main() {
    test();
    return 0;
}
/*

 */

3333333_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CPP杂记——移动构造函数中需要注意的问题
01-08
默认的浅拷贝构造函数在临时变量被析构时还会释放其中的动态元素内存，这时便会对其他部分产生影响，c++11前未仔细优化的代码大都直接编写深拷贝构造函数，但由于作为参数的临时性，这种行为是无必要的。 . 这时的...
CPP之构造函数
zhuxiaoqiang1hao的博客
06-26 1675
C++中的构造函数可以分为4类：默认构造函数、初始化构造函数、拷贝构造函数、移动构造函数。 需要注意的是：仅当没有定义任何构造函数的时候，编译器才会提供默认的构造函数，为类定义了构造函数，程序员就必须为他提供默认构造函数。两种创建方式：1.给已有的构造函数所有参数提供默认值 2.定义一个没有参数的构造函数。 有了有参的构造函数，编译器就不提供默认的构造函数。 构造函数默认实现的是值拷贝（浅拷贝）。**用于将其它类型的的变量，隐式转换为本类对象。**下面的转换构造函数，将int类型的r转换为student类型
Cpp_构造函数
Jerry的专栏
02-25 4631
构造函数1)函数名与类名相同，且没有返回类型。 2)构造函数在对象被创建时自动被调用。 3)构造函数负责确定对象的初始状态以及分配必要的资源。 4)构造函数在每个对象的整个生命周期内，一定会被调用，且仅被调用一次对象的创建过程：A.首先为对象分配足量的内存空间；B.以构造实参调用构造函数，完成如下任务： a)依次调用各个基类的构造函数，初始化所有基类子对象； b)依次调用类类型成
【一天一篇CPP】派生类的构造函数和析构函数
c熊
10-10 869
1.基类的构造函数是不能继承的，在声明派生类时，派生类并没有把基类的构造函数继承过来，但是可以通过一种显式的声明来调用基类的构造函数。 对于析构函数，系统会自动调用基类的析构函数，详细看下面的 “3注意点”。 2.构造函数调用的例子： #include #include using namespace std; class Student{ public: Student (in
析构函数
Magic_o的博客
11-04 271
定义 也是成员函数，在删除所创建的对象的时候执行。 析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。 注意哦，构造函数是有参数的。 构造函数和析构函数在main里面不用特别进行定义。 ~Line() Line::~Line(void) { cout << "Object is being deleted" << endl; } #include <iostream> using namespa
C/Cpp / 构造函数种类
布袋和尚
11-15 326
2018-03-15 创建人：Ruo_Xiao 开发环境：VS2010 邮箱：[email protected] 2018-04-16 修改人：Ruo_Xiao 添加对类型转换构造函数隐式转换的抑制使用的说明，即：explicit。 2019-06-19 修改人：Ruo_Xiao 修正对转换构造函数的说明。 一、默认构造函数（无参数构造函数） Father() { s...
day3 分文件创建类/构造/析构/深浅拷贝/
01-08
编译器会默认提供构造函数, 析构函数, 拷贝构造函数(对非静态成员属性简单值拷贝) 编译器会默认调用构造和析构, 如果不写, 系统会默认实现一个空的 必须写在public下 构造函数 与类名相同, 没有返回值, 不写void, ...
c++模拟测试题
09-16
c++基础练习题 类有两个特殊的成员函数，构造函数和虚函数。...Y 17、类的构造函数和析构函数都可以是虚函数。 错 18、运算符重载属于静态多态。 正确 19、从逻辑上分析，除类的静态成员之外，所有其他
奥特曼打怪兽.cpp 源码
05-13
3. 掌握构造函数、拷贝构造函数和析构函数的定义和实现 4. 掌握类成员函数调用的方法 5. 阅读并理解程序代码 6. 编程工具的使用 二、实验内容 在奥特曼的世界，打怪兽就是全部。现在人人都有机会成为奥特曼，加入到...
CPP.rar_静态数据成员
09-23
1.编写一个类，声明一个数据成员和一个静态数据成员，其构造函数初始化数据成员，并把静态数据成员加1，其析构函数把静态数据成员减1。 (1) 编写一个应用程序，创建该类的3个对象，然后显示其数据成员和静态数据成员...
【cpp】构造函数
qq_44784242的博客
04-13 591
构造函数主要分为三类：默认构造函数（无参构造函数）、有参构造函数、拷贝构造函数（包括了拷贝赋值运算符，移动构造函数，移动赋值运算符）
cpp——类——析构函数
mardax的专栏
02-13 2762
概述 析构函数特点： 函数名为“~类名”，用来标记和识别析构函数 没有返回值，析构函数是对自身的销毁行为，返回值无意义，因为没有返回值的接收者 形参列表为空，所以析构函数没有重载，唯一的 构造函数VS析构函数： 构造函数是对自身的初始化，生成(定义)对象时自动调用 析构函数是对自身的销毁，销毁对象时自动调用 辅助类 class CAnimal { public: CAnimal() : mGroup(0) { cout << "CAnimal()" << endl;
Cpp_析构函数
Jerry的专栏
02-28 1318
1.this指针1)每个类的构造函数和成员函数中都包含一个隐藏的该类类型的指针参数，名为this，该指针指向调用这个成员函数或正在被构造的对象。成员函数和构造函数中对该类其它成员的访问，都是通过this指针进行的。this指针可以在成员函数或构造函数内部直接显式地引用。2)显式使用this的场合A.区分作用域 B.从类的内部向外部传递该类对象地址 C.从类的内部向外返回该类对象自身——返回自引用 D
常数据成员(1)
这是一个c++热爱者的博客哟
07-31 2259
代码】常数据成员(1)
cpp_8.1类和对象中（五） --- 构造函数
weixin_42536748的博客
04-20 253
1 引入构造函数 对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？ #if 0 class Date { public: void SetDate(int year, int month, int day) { _year = year; _month = month; _day = day; } void PrintDate() { cout <<
Cpp--拷贝构造函数
samkieth
03-07 1122
拷贝构造函数，是一种特殊的构造函数，具有一般构造函数所有的特性。拷贝构造函数只有一个形参，而且其形参为本类对象的引用。原形为：（&）；它的作用是使用一个已存在的对象----由拷贝构造函数的参数指定的对象（的各成员当前值）去初始化另一个相同的新对象（尚不存在，正在创建）。 如果用户没有声明类的拷贝构造函数（即没有给出显式的拷贝构造函数时），系统会自动生成一个隐含的（缺省的）拷贝构造函数，它只进行对
C++中的构造函数与析构函数
师范大学生的博客
09-12 292
  在总结构造函数与折构函数之前，先拿《C++ primer plus》这本书中经典的“股票类”作为研究对象，稍微复习一下类有关的知识和技巧。对于原先的类我做了一些修改： class Stock { private: std::string companyName;//公司名称 long m_shares;//持有股票数量 double m_share_price;//每股价格 doubl...
C++ 构造函数和析构函数
qq_45449625的博客
12-04 550
构造函数和析构函数构造函数和析构函数是两个特殊的成员函数，这个函数的名字和类名相同，构造函数定义对象的时候由系统自动调用，析构函数在删除对象的时候由系统自动调用。
cpp_8.2类和对象中（六） --- 析构函数
weixin_42536748的博客
04-20 180
析构函数1 什么是构造函数2 析构函数特性 1 什么是构造函数 析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。 #if 0 typedef int DataType; class SeqList { public: //构造函数 SeqList(int capacity = 10) { _array = (DataType*)malloc(sizeof(DataType)*capacit
写一个c++构造函数和析构函数
最新发布
06-07
好的，下面是一个简单的 C++ 类的构造函数和析构函数示例： ```cpp class MyClass { public: // 构造函数 MyClass() { // 在此处进行初始化工作 std::cout 对象已创建" ; } // 析构函数 ~MyClass() { // ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值