c++基本使用（构造函数和析构函数）

已于 2023-03-07 12:26:57 修改
阅读量186 收藏
点赞数
分类专栏： C++11简单的使用方法 文章标签： c++ java 开发语言
于 2023-03-06 23:59:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41701723/article/details/129373468
版权

c++基本使用（构造函数和析构函数）

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

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

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

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

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

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

  7. 本质的区别：

CGirl girl = CGirl("西施"20);  // 显式创建对象。

CGirl girl;                   // 创建对象。
girl = CGirl("西施"20);        // 创建匿名对象，然后给现有的对象赋值。
  1. 用new/delete创建/销毁对象时，也会调用构造/析构函数。.
  2. 不建议在构造/析构函数中写太多的代码，可以调用成员函数
  3. 除了初始化，不建议让构造函数做太多工作（只能成功不会失败）。
  4. C++11支持使用统一初始化列表
  5. 如果类的成员也是类，创建对象的时候先构造成员类，销毁对象的时候先析构成员类。
CGirl girl = {"西施"20};
CGirl girl  {"西施"20};
CGirl* girl = new CGirl{ "西施"20 };

5的例子

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                                  // 姓名属性。
    int         m_age;                                     // 年龄属性。
    char      m_memo[301];                        // 备注。
    CGirl()                                        // 没有参数的构造函数。  
    {
        m_name.clear(); m_age = 0; memset(m_memo, 0, sizeof(m_memo));
        cout << "调用了CGirl()构造函数。\n";
    }
    CGirl(string name)                   // 一个参数（姓名）的构造函数。
    {
        CGirl();       //没有调用构造函数，而是创建了匿名对象（创建后马上被销毁了）
        cout << "调用了CGirl(name)构造函数。\n";
        m_name = name;
    }
    CGirl(int age)                           // 一个参数（年龄）的构造函数。
    {
        CGirl();  //没有调用构造函数，而是创建了匿名对象（创建后马上被销毁了）
        cout << "调用了CGirl(age)构造函数。\n";
        m_age = age;
    }
    CGirl(string name, int age)      // 两个参数的构造函数。
    {
        CGirl();  //没有调用构造函数，而是创建了匿名对象（创建后马上被销毁了）
        cout << "调用了CGirl(name,age)构造函数。\n";
        m_name = name; m_age = age;
    }
    CGirl(string name, int age ,char memo[301])      // 两个参数的构造函数。
    {
        CGirl();  //没有调用构造函数，而是创建了匿名对象（创建后马上被销毁了）
        cout << "调用了CGirl(name,age)构造函数。\n";
        m_name = name; m_age = age; 
        strcpy(m_memo,memo);
    }
    // void initdata()
    // {
    //     m_name.clear(); m_age = 0; memset(m_memo, 0, sizeof(m_memo));
    // }
    ~CGirl()                                     // 析构函数。  
    {
        cout << "调用了~CGirl()\n";
    }
    void show()                               // 超女自我介绍的方法。
    {  cout << "姓名：" << m_name << "，年龄：" << m_age << "，备注：" << m_memo<< endl; }
};

int main()
{
    //CGirl girl();
    CGirl girl("西施");
    //CGirl girl("西施",8);     // 创建超女对象，为成员姓名和年龄设置初始值。
    
    girl.show();    // 显示超女的自我介绍。
    
}

构造函数

在创建对象时，自动的进行初始化工作。（例如初始化变量的代码）

 访问权限必须是public。
 函数名必须与类名相同。
 没有返回值，不写void。
 可以有参数，可以重载，可以有默认参数。
 创建对象时只会自动调用一次，不能手工调用。

析构函数

在销毁对象前，自动的完成清理工作。（例如释放内存的代码）

 访问权限必须是public。
 函数名必须在类名前加~。
 没有返回值，也不写void。
 没有参数，不能重载。
 销毁对象前只会自动调用一次，但是可以手工调用。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                                  // 姓名属性。
    int         m_age;                                     // 年龄属性。
    char      m_memo[301];                        // 备注。
    CGirl()                                        // 没有参数的构造函数。  
    {
        initdata();
        cout << "调用了CGirl()构造函数。\n";
    }
    CGirl(string name)                   // 一个参数（姓名）的构造函数。
    {
        initdata();
        cout << "调用了CGirl(name)构造函数。\n";
        m_name = name;
    }
    CGirl(int age)                           // 一个参数（年龄）的构造函数。
    {
        initdata();
        cout << "调用了CGirl(age)构造函数。\n";
        m_age = age;
    }
    CGirl(string name, int age)      // 两个参数的构造函数。
    {
        initdata();
        cout << "调用了CGirl(name,age)构造函数。\n";
        m_name = name; m_age = age;
    }
    void initdata()
    {
        m_name.clear(); m_age = 0; memset(m_memo, 0, sizeof(m_memo));
    }
    ~CGirl()                                     // 析构函数。  
    {
        cout << "调用了~CGirl()\n";
    }
    void show()                               // 超女自我介绍的方法。
    {  cout << "姓名：" << m_name << "，年龄：" << m_age << "，备注：" << m_memo<< endl; }
};

int main()
{
    // CGirl girl;                     // 创建超女对象，不设置任何初始值。
    // CGirl girl("西施");        // 创建超女对象，为成员姓名设置初始值。
    // CGirl girl("西施",8);     // 创建超女对象，为成员姓名和年龄设置初始值。

    //CGirl girl=CGirl();                   // 创建超女对象，不设置任何初始值。
    // CGirl girl=CGirl("西施");        // 创建超女对象，为成员姓名设置初始值。
    // CGirl girl=CGirl("西施",8);     // 创建超女对象，为成员姓名和年龄设置初始值。

    //CGirl girl = 8;                         // 使用赋值语法初始化对象。

    // CGirl *girl=new CGirl;                   // 创建超女对象，不设置任何初始值。
    // CGirl *girl=new CGirl("西施");        // 创建超女对象，为成员姓名设置初始值。
    CGirl *girl=new CGirl("西施",8);     // 创建超女对象，为成员姓名和年龄设置初始值。
    
    girl->show();    // 显示超女的自我介绍。
    delete girl;
}

拷贝构造函数

用一个已存在的对象创建新的对象，不会调用（普通）构造函数，而是调用拷贝构造函数。

如果类中没有定义拷贝构造函数，编译器将提供一个拷贝构造函数，它的功能是把已存在对象的成员变量赋值给新对象的成员变量。

用一个已存在的对象创建新的对象语法：

类名 新对象名(已存在的对象名);
类名 新对象名=已存在的对象名;

拷贝构造函数的语法：

类名(const 类名& 对象名){......}
  1. 访问权限必须是public。
  2. 函数名必须与类名相同。
  3. 没有返回值，不写void。
  4. 如果类中定义了拷贝构造函数，编译器将不提供默认的拷贝构造函数。
  5. 以值传递的方式调用函数时，如果实参为对象，会调用拷贝构造函数。
  6. 函数以值的方式返回对象时，可能会调用拷贝构造函数（VS会调用，Linux不会，g++编译器做了优化）。
  7. 拷贝构造函数可以重载，可以有默认参数。
    类名(…,const 类名& 对象名,…){…}
  8. 如果类中重载了拷贝构造函数却没有定义默认的拷贝构造函数，编译器也会提供默认的拷贝构造函数。

5的例子：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                                  // 姓名属性。
    int         m_age;                                     // 年龄属性。
    
    // 没有参数的普通构造函数。  
    CGirl() { m_name.clear(); m_age = 0;  cout << "调用了CGirl()构造函数。\n"; }

    //拷贝构造函数的功能是把已存在对象的成员变量赋值给新对象的成员变量。
    // 没有重载的拷贝构造函数（默认拷贝构造函数）。  
    CGirl(const CGirl &gg) { m_name="漂亮的"+gg.m_name; m_age = gg.m_age-1;  cout << "调用了CGirl(const CGirl &gg)拷贝构造函数。\n"; }

    // 重载的拷贝构造函数。  
    CGirl(const CGirl& gg,int ii) { m_name = "漂亮的" + gg.m_name; m_age = gg.m_age - ii;  cout << "调用了CGirl(const CGirl &gg,int ii)拷贝构造函数。\n"; }

    // 析构函数。  
    ~CGirl() { cout << "调用了~CGirl()\n"; }

    // 超女自我介绍的方法，显示姓名和年龄。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << endl; }
};

void func(CGirl g){
    g.show();
}

int main()
{
    CGirl g1;
    g1.m_name = "西施"; g1.m_age = 23;
    //用一个已存在的对象创建新的对象，
    CGirl g2(g1,3);
    g2.show();

    cout<<"以值传递的方式调用函数时，如果实参为对象，会调用拷贝构造函数。"<<endl;
    func(g1);
}

6的例子：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                                  // 姓名属性。
    int         m_age;                                     // 年龄属性。
    
    // 没有参数的普通构造函数。  
    CGirl() { m_name.clear(); m_age = 0;  cout << "调用了CGirl()构造函数。\n"; }

    //拷贝构造函数的功能是把已存在对象的成员变量赋值给新对象的成员变量。
    // 没有重载的拷贝构造函数（默认拷贝构造函数）。  
    CGirl(const CGirl &gg) { m_name="漂亮的"+gg.m_name; m_age = gg.m_age-1;  cout << "调用了CGirl(const CGirl &gg)拷贝构造函数。\n"; }

    // 重载的拷贝构造函数。  
    CGirl(const CGirl& gg,int ii) { m_name = "漂亮的" + gg.m_name; m_age = gg.m_age - ii;  cout << "调用了CGirl(const CGirl &gg,int ii)拷贝构造函数。\n"; }

    // 析构函数。  
    ~CGirl() { cout << "调用了~CGirl()\n"; }

    // 超女自我介绍的方法，显示姓名和年龄。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << endl; }
};

CGirl func(){
    CGirl g;
    g.m_name="西施";
    g.m_age=22;
    return g;
}

int main()
{
    CGirl gg = func();
    gg.show();

}

8的例子：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

class CGirl                 // 超女类CGirl。
{
public:
    string    m_name;                                  // 姓名属性。
    int         m_age;                                     // 年龄属性。
    
    // 没有参数的普通构造函数。  
    CGirl() { m_name.clear(); m_age = 0;  cout << "调用了CGirl()构造函数。\n"; }

    //拷贝构造函数的功能是把已存在对象的成员变量赋值给新对象的成员变量。
    // 没有重载的拷贝构造函数（默认拷贝构造函数）。  
    //CGirl(const CGirl &gg) { m_name="漂亮的"+gg.m_name; m_age = gg.m_age-1;  cout << "调用了CGirl(const CGirl &gg)拷贝构造函数。\n"; }

    // 重载的拷贝构造函数。  
    CGirl(const CGirl& gg,int ii) { m_name = "漂亮的" + gg.m_name; m_age = gg.m_age - ii;  cout << "调用了CGirl(const CGirl &gg,int ii)拷贝构造函数。\n"; }

    // 析构函数。  
    ~CGirl() { cout << "调用了~CGirl()\n"; }

    // 超女自我介绍的方法，显示姓名和年龄。
    void show() { cout << "姓名：" << m_name << "，年龄：" << m_age << endl; }
};

int main()
{
    CGirl gg;
    gg.m_name="西施",gg.m_age=22;
    //调用了系统提供的默认拷贝构造函数；
    CGirl g2(gg);
    g2.show();
}
计算机CV民工
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记12 - 构造函数和析构函数
qq_38958704的博客
08-09 474
1、元素2、实战中，一般一个cpp和一个hpp文件配对，描述一个class，class的名字和文件名相同。3、面向对象式编程总结4、C++学习的三重境界1、什么是构造函数2、构造和析构一般用法3、为什么需要构造函数和析构函数1、析构函数的使用2、在class中使用动态内存变量3、用valgrind工具查看内存泄漏1、构造函数一大功能就是初始化成员变量2、C++的成员初始化列表3、构造函数使用参数默认值...
【C++】构造函数（包括默认构造函数） ，析构函数的使用与特性
m0_74774759的博客
05-16 1492
则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
C++中的构造函数与析构函数
scott198512的博客
12-02 2268
C++构造函数与析构函数
C++构造函数和析构函数
weixin_56745394的博客
02-01 764
对象的初始化和清理是两个非常重要的安全问题，一个对象或者变量没有初始状态，对其使用后果是未知，同样的使用完一个对象或变量，没有及时清理，也会造成—定的安全问题。 C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。 构造函数：主腰作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。 对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构.
C++构造函数与析构函数
TJW25的博客
11-01 106
C++构造函数与析构函数 构造函数 当定义一个对象时，必须调用构造函数建立该对象并进行初始化，也叫做实例化函数。构造函数绝大情况下是共有的成员函数。 构造函数的特征： 1.函数名与类名相同 2.构造函数没有返回值，返回的就是构造的对象 3.构造函数只能被系统调动一次 4.构造函数可以重载，可以构造不同参数的对象。 5.如果类中没有定义构造函数，则系统会自动给出一个缺省的构造函数。 //构造函数举例 class CGoods { private: char Name[21]; int Amount;
深入解析C++中的构造函数和析构函数
12-31
调用构造函数和析构函数的顺序：先构造的后析构，后构造的先折构。它相当于一个栈，先进后出。 代码如下:#include<iostream>#include<string>using namespace std;class Student{ public: Student(string,string,...
C++构造函数和析构函数顺序
12-22
构造函数 　先看看构造函数的调用顺序规则，只要我们在平时编程的时候遵守这种约定，任何关于构造函数的调用问题都能解决；构造函数的调用顺序总是如下： 　1.基类构造函数。如果有多个基类，则构造函数的调用顺序...
C++构造函数和析构函数的使用与讲解
01-20
构造函数(constructor) 1.构造函数是种特殊的类成员函数，遵循如下规则： a.函数名与类名必须相同。...3.构造函数和普通成员函数不一样，一般不显示调用。在创建一个对象时，构造函数自动调用(编译器来完成
C++类成员构造函数和析构函数顺序示例详细讲解
01-20
(1)如果某个类具体基类，执行基类的默认构造函数。 (2)类的非静态数据成员，按照声明的顺序创建。 (3)执行该类的构造函数。 即构造类时，会先构造其父类，然后创建类成员，最后调用本身的构造函数。 下面看一个例子...
c++基本使用（类）
记录我目之所及的世界
03-06 234
class类
【C++】（二十二）析构函数
weixin_44378835的博客
11-02 2923
文章目录析构函数1 析构函数的定义2 合成析构函数3 何时需要编写析构函数4 构造函数和析构函数的调用次序 析构函数 1 析构函数的定义 析构函数：当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统会自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一段内存空间，则在该对象消亡前应在析构函数中用delete释放这段存储空间）。 C++规定析构函数的名字是类名的前面加一个波浪号（~）。其定 义形式为： ~类名() { 函数体 } 析构函数不返回任何值，没有
C++构造函数
weixin_40763897的博客
08-14 2683
C++构造函数分两种：普通构造函数和复制构造函数。其中复制构造函数的参数为自身类型的常引用，即const 类名 &修饰。为什么要传个常引用呢？因为是引用，所以对引用的操作会影响到原来的对象。为了防止复制构造函数里对引用的修改，所以加上const去修饰，const修饰的对象是不能被修改的，包括它的任何成员。...
C++中的构造函数
MBuger的博客
10-01 509
构造函数 概念：在每个类中都定义了它的对象被初始化的方式，类通过一个或者几个特殊的成员函数来控制其对象的初始化过            程，这些函数叫做构造函数。 特征：构造函数的名字与类名字相同，构造函数没有返回类型，它有一个（可能为空的）参数列表和一个（可能为空            的）函数体。 注意：构造函数不能被申明成const的。            一个类中可以包含多个构造
C++类与对象之构造函数，拷贝构造函数，析构函数浅谈
m0_62755690的博客
11-09 411
本期我们来聊一聊类与对象的一个重要内容，构造函数，拷贝构造和析构函数的定义和使用。其实，就算程序员自己不编写这三个函数，C++编译器也会有默认的这三个函数，但是由于有时候默认的这三个函数不能满足我们的需求，所以我们需要自行编写这三个函数。 1.构造函数 首先我们要先知道什么叫构造函数，构造函数用于在进行类与对象编程时候使用的一个函数，它的作用正常我们用来初始化类中的各个成员数据，构造函数又分为两种，无参构造函数和有参构造函数，这两种很好理解，第一种就是参数列表里没有参数，第二种则是参数列表中有参数，我们
C++析构函数
天道酬勤
04-20 1583
什么是析构函数 析构函数是类的一个成员函数，名字由波浪号接类名构成，没有返回值，不接受参数，一个类只有一个析构函数。当一个类未定义自己的析构函数时，编译器会为它定义一个合成的析构函数。 析构函数完成什么工作 在构造函数中，成员的初始化时在函数体执行前完成的，且按照他们在类中的顺序进行初始化。在析构函数中，首先执行函数体，然后按照初始化顺序的逆序销毁成员。 析构函数销毁类类型成员时执行成员自己的析构...
第二十节 C++- 析构函数的使用及调用
菜鸟博客
03-28 9504
析构函数是类的一种特殊函数，只有在对象被销毁时才被调用，在析构函数内，可以对堆内存进行释放，如new（构造函数），delete（析构函数）。构造函数可以有多个（重载），而析构函数只有一个（不能对析构函数进行重载）。如果忘记实现析构函数，编译器会自动生成一个伪析构函数（空函数），从下面代码，可以看出析构函数的使用及调用顺序。/*Human.h*/ #include &lt;string&gt; c...
如何使用C++析构函数
lunei
02-18 2029
析构函数 析构函数通常用于释放在构造函数或在对象生命期内获取的资源（如动态分配的内存） 。 析构函数的作用并不仅限于释放资源方面， 它可以包含任意操作， 用来执行“对象即将被撤销之前程序员所期待的任何操作” 。 如果类需要析构函数， 则该类几乎必然需要定义自己的复制构造函数和赋值运算符重载， 这个规则称为析构函数三法则（rule of three） 。
构造函数和析构函数以及初始化参数列表、匿名对象
qq_46111138的博客
05-13 679
构造函数 是一种特殊的函数，函数名与类名相同，没有返回值；是C++引入的一个机制，专门用于初始化。 C++保证每个对象被创建时都会调用构造函数。 分为以下几种（默认构造和有参构造） 默认构造 如果没有显式的定义任何构造函数，系统会默认的生成一个无参构造函数（什么都不做）。 当我们声明了任何一个构造函数后，系统不会生成默认构造函数。 例如，（系统默认生成的无参构造函数） 1 class A { 2 public: 3 A() { 4
【C++提高编程-05】----C++之Deque容器实战
最新发布
一伦明悦的博客
06-15 900
Deque（双端队列）是C++ STL中的一种序列容器
用c++包含构造函数和析构函数
05-16
在C++中，构造函数和析构函数是特殊的成员函数，它们用于对象的创建和销毁。构造函数负责对象的初始化，而析构函数负责对象的清理工作。下面是一个简单的示例，展示了如何在C++中包含构造函数和析构函数： ``` #...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值