c++：构造函数，析构函数介绍以及初始化的一些说明

最新推荐文章于 2023-05-23 17:39:26 发布
最新推荐文章于 2023-05-23 17:39:26 发布
阅读量1.2k 收藏 5
点赞数 11
分类专栏： c++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2998658795/article/details/125981346
版权

1.构造函数

1.1什么是构造函数

1.构造函数是一个非常特殊的函数，他的作用就是对类中的属性进行初始化的。

2.构造函数带void 都没有。

3.构造函数也是函数，也遵从C++函数重载机制。

1.2语法形式

函数名字与类型名字相同 + 函数形参列表
{
    //对类中的属性进行初始化
}

1.3代码

1.3.1无参数代码

#include <iostream>

using namespace std;

class Stu{
private:
    int age;
    string name;
public:

    void set_xinxi(int age,string name){
           this->age=age;
           this->name=name;
    }

    Stu(){
        cout << "这是一个无参的空构造" << endl;
    }


    void show_info(){
        cout << "name=" << this->name << ",age=" << this->age << endl;
    }
};

int main()
{
   Stu stu;
   stu.set_xinxi(12,"peter");
   stu.show_info();

    return 0;
}

1.3.2有参数代码

#include <iostream>

using namespace std;

class Stu{
private:
    int age;
    string name;
public:

    void set_xinxi(int age,string name){
           this->age=age;
           this->name=name;
    }

    Stu(int age,string name){
        this->age=age;
        this->name=name;
        cout << "这是一个有参的构造" << endl;
    }

    void show_info(){
        cout << "name=" << this->name << ",age=" << this->age << endl;
    }
};

int main()
{
   Stu stu(12,"lisi");
   
   stu.show_info();

    return 0;
}

1.4构造函数的调用方式

1.4.1显示调用

class Stu{
private:
    int age;
    string name;
public:

    Stu(int age,string name){
        this->age=age;
        this->name=name;
        cout << "这是一个有参的构造" << endl;
    }

    void show_info(){
        cout << "name=" << this->name << ",age=" << this->age << endl;
    }
};

int main()
{
   Stu stu(12,"lisi");

   stu.show_info();

    return 0;
}

1.4.2隐式调用

#include <iostream>

using namespace std;

class Stu{
private:
    int age;
public:



    Stu(int age){
        this->age=age;
        cout << "这是一个有参的构造" << endl;
    }

    void show_info(){
        cout << "age=" << this->age << endl;
    }
};

int main()
{
   Stu stu=12;

   stu.show_info();

    return 0;
}

1.4.3调用说明，因为一般来说隐式调用比较难理解一些所以大多数情况下还是用显示调用，explicit是用来修饰类中的构造函数，防止隐式调用，如下：

#include <iostream>

using namespace std;

class Stu{
private:
    int age;
public:



    explicit Stu(int age){
        this->age=age;
        cout << "这是一个有参的构造" << endl;
    }

    void show_info(){
        cout << "age=" << this->age << endl;
    }
};

int main()
{
   Stu stu(12);

   stu.show_info();

    return 0;
}

1.5构造函数的调用时机

当使用带用带括号的构造来构造对象，编译器自动对类中属性进行初始化。（优化操作）

#include <iostream>

using namespace std;

class Stu{
private:
    int age;
    int a;
    int b;
public:


    void show_info(){
        cout << this->age << this->a << this->b << endl;
    }
};

int main()
{


   Stu stu=Stu();
   stu.show_info();

    return 0;
}

2析构函数

2.1析构函数的意义：

用来回收类中属性成员属性指针指向堆区的资源的。

2.2语法格式

~类名()
{
    //析构函数的函数体
    //析构函数的函数中书写回收为类中有属性指针指堆区资源的逻辑。
}

2.3代码说明

#include <iostream>

using namespace std;

class Stu
{
    int age;
    string name;
    int *p;

    Stu(){
        p=new int [1024] {0};
        cout << "Stu的无参的构造" << endl;
    }

    ~Stu(){
        delete [] p;
        cout << "Stu的析构" << endl;
    }
};


int main()
{
    return 0;
}

总结:

1.在堆区定义对象时，首先使用new开辟空间，然后调用类中与之相对应的构造函数，构造对象，构造对象的过程就是对象中的属性初始化的过程。

2.当定义的对象要被销毁时，使用delect或者delect[]；首先调用析构函数，然后再释放。

3.特殊属性的初始化：

3.1const修饰的类中的属性常成员对象的初始化及没有默认构造的成员对象的初始化。

#include <iostream>

using namespace std;

class A{
public:
  A(int num)
  {

  }
};


class Stu
{
private:
    const int id;
    int age;
    string name;
    int *p;
    A a;
public:

    Stu(int _id,int _age,string _name):id(_id),age(_age),name(_name),p(new int [1024]),a(A(1))
    {

        cout << "Stu的无参的构造" << endl;
    }

    ~Stu()
    {
        delete [] p;

        p=nullptr;

        cout << "Stu的析构" << endl;
    }

    void show_info()
    {
        cout << this->age << this->name << this->id << endl;
    }
};


int main()
{
    Stu stu(1001,12,"lisi");
    stu.show_info();
    return 0;
}

3.2初始化注意的几点

1.每个成员变量在初始化列表中，只能初始化一次。

2.类中有特列成员时的初始化：const修饰的对象或变量，引用类型成员或变量，自定义类型指定调用构造函数时使用（特别是有explicit修饰的构造函数的类类型对象时）。

3.如果类中有比较大的结构体对象的初始始化可以入在初始化列表中进行。

4.初始化列表顺序尽量保持与类中成员声明顺序相同

3.3类中static修饰的初始化

我们先来看一看static修饰的成员变量具有那些特点：

 当一个进程被加载时，系统会首先加载静态区数据，静态区的数据就包括了什么呢？
1.文件代码段：编译好的机器码，内容即是一个个函数机器码及保存函数地址的指针。
2.rodata段：即全局只读数据，比如：全局const修饰的全局变量或常量字符串。
3.data段：已初始化的全局变量或static修饰且初始化的变量。（data段数据将在程序执行前系统调用copy_data()函数向程序中拷贝一分副本）
4.bss段：未被初始化的全局变量，或局部定义使用static 修饰的静态变量。（bss段数据在程序执行前系统会调用bss_clear()函数对其进行初始化）
当用static在类中修饰一个成员变量时，由于类中定义的static是隐藏在类中，系统无法调用bss_clear()直接进行初始化。所有C++语法规定，当系统加载时，必须要在类外进static修饰的成员变量进行首次初始化。
如果没有在类外对static修饰的成员变量进行初始化，那么此变量在类中仅为一个声明，而没有定义，当对象引用这个成员变量时就会发生链接错误。

所以如果类中的变量在类中有用static修饰，必须要在类外进行初始化。我们一般在main函数前或类的.cpp文件中进行初始化。

3.3代码

3.3.1代码实现

#include <iostream>

using namespace std;

class A{
public:
  A(int num)
  {

  }
};


class Stu
{
private:
    int age;
    string name;
    static int counts;

public:

    Stu(int _age,string _name):age(_age),name(_name)
    {

        cout << "Stu的无参的构造" << endl;
        counts++;
    }


    void show_info()
    {
        cout << &counts << endl;
    }
};

int Stu::counts=0;

int main()
{
    Stu stu(12,"lisi");
    stu.show_info();

    Stu stu1(13,"zhansan");
    stu.show_info();
    return 0;
}

#include <iostream>
#include <unistd.h>
using namespace std;
class A
{
public:
    A(int score)
    {
    }
};

class Stu
{
private:
    const int id;
    string name;
    int age;
    int* p;
    A a;
    static int count;
public:
    //类中的初始化列表的使用方式。
    //即对类中的const修饰的属性进行初始化的，同时也可以对类中有自定义类类型却没有默认构造的对象，用来指定调用那一个构造来构造对象的。
    //类中的初始化列表的初始化顺序，尽量保持与类中的属性的声明顺序相同。
    Stu(int _id,string _name,int _age):id(_id),name(_name),age(_age),p(new int[1024]),a(A(1))
    {
        cout << "Stu的有参的构造" << endl;
        count++;
    }
    ~Stu()
    {
        //所以说析构函数：就是用回收类中属性指针指向堆区资源的。
        delete []p;
        cout << "Stu的析构" << endl;
    }
    void showInfo()
    {
        cout << "学号：" << this->id << "，姓名：" << this->name << ",年龄：" << this->age << endl;
    }
    int get_count()
    {
        cout << &count << endl;
        return count;


    }
};
//类外静态成员变量（属性）初始化方式：
int Stu::count = 0;
//static 在局部空间的使用：static修饰的局部变量只能被初始化一次。
void test()
{
    while (true) {
        static int i = 0;
        i++;
        sleep(1);
        cout << i << endl;
    }
}


int main()
{
    Stu stu(1001,"zhangsan",18);
    stu.showInfo();
    cout << stu.get_count() << endl;


    Stu stu1(1002,"lisi",20);
    cout << stu.get_count() << endl;



    //测试局部作用域的static修饰的变量。
    test();
    return 0;
}

#include <iostream>

using namespace std;



class Stu
{
private:

    static int counts;

};

int Stu::counts=0;

int main()
{
    cout << sizeof (Stu) << endl;

    return 0;
}

3.3.2现象

         

 

 

3.3.3总结说明

1.由于类中静态成员变量，是属于整个进程的，进程执行前就已经在静态区存在了，而类对象是生存在动态区的，所以此成员不依赖于某个类对象的，他是属于整个进程的，因为他又隐藏于类中，所以我们可以使用类域访问的形式对直接访问。（当于有类内的访问权限的限制。）
2.static只能被初始化一次，下一次的值是在这个基础之上，进行变化的

3.static修饰的成员变量必须在类外进行初始化。

4.static修饰的成员变量不依赖于某个对象，可以直接使用类名 + 域名访问符的形式，直接访问。

5.static修饰的成员变量不占有类对象的空间，且此静态成员数据只有一分，被所有类对象共享。

6.所以当类中有需要定义一个为这个类而服务，而不是某个对象而服务的属性时，就可以把它升级static的成员属性。

7.由于静态成员变量定义在静态区定义内存，而对象是存在于动态区之中，所以静态成员变量并不占用类对象的内存空间。

向着太阳迎着光_
关注
  • 11
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【2016-08-18】转载：总结C++中几种结构体初始化的方法
dflkg8956的专栏
08-18 4181
作者：Ac_Von 博客地址：http://www.cnblogs.com/vongang/ 文章地址：http://www.cnblogs.com/vongang/archive/2011/07/30/2122076.html 结构体能自由组装数据，是一种很常见的数据打包方法。 当我们定义一个结构体后，没有初始化就使用，就会使用到垃圾数据，而且这种错误很难发现。 在编程时对于...
【C/C++】构造函数初始化结构体
weixin_44413191的博客
07-29 1488
本文为 C/C++ 学习总结。讲解使用构造函数初始化结构体
C++构造和析构函数
最新发布
dyyfyyds_的博客
05-23 161
构造函数是特殊的公用成员函数（在特殊用途中可以定义为私有或者保护）class Intprivate:int value;int main()//error,在没有定义构造函数时，只有当成员数据为公有时，才能这样初始化，否则就需要构造函数当定义一个对象时，C++自动调用构造函数建立该对象并进行初始化，那么当一个对象的生命周期结束时，C++也会自动调用一个函数注销该对象并进行善后工作，这个特殊的成员函数即析构函数：1.构函数名与类名相同，但在前面加上字符~，如 : ~CGoods ()。
【C++入门】(拷贝)构造函数和析构函数
weixin_42031299的博客
10-06 1656
(1)：字面意思就是构造对象的函数，当我们定义类的对象时调用，可以帮我们完成对象的初始化；(2)：可以看做是构造函数的逆过程，当销毁类的时候调用，做一些收尾的工作；比如：定义类的对象时构造函数申请了动态内存，那在销毁对象时调研员的析构函数中就要释放申请的动态内存，否则就会造成内存泄漏；(3)。程序员可以在定义类时使用默认的构造/析构函数，或者自己定义构造/析构函数，但是构造/析构函数的调用却不是程序员主动去调用，而是C++语言自动帮我们调用。
c语言结构体 构造函数,CC++结构体的初始化结构体初始化本来就是可以用大括号,但是如果在结构体内写构造函数,...
weixin_28982089的博客
05-19 703
https://blog.csdn.net/k346k346/article/details/51537077CC++结构体的初始化 结构体初始化本来就是可以用大括号,但是如果在结构体内写构造函数,那就是要使用构造函数初始化,={}:使用没有参数的构造函数={1,3,4}:使用带参数的构造函数然后再利用operate=将新的类对象赋值在这个对象上面.今天看到项目中对自定义结构体初始化方式有点陌生，...
c++基础语法:构造函数与析构函数
01-20
构造函数用来构造一个对象，主要完成一些初始化工作，如果类中不提供构造函数，编译器会默认的提供一个默认构造函数(参数为空的构造函数就是默认构造函数) ；析构函数是隐式调用的，delete对象时候会自动调用完成...
C++构造函数初始化顺序详解
01-01
1.构造函数、析构函数与拷贝构造函数介绍 构造函数 1.构造函数不能有返回值 2.缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都初始化为零或空 3.创建一个对象时，系统自动...
C++的全局构造与析构函数
01-20
即C++ 的全局对象构造函数在main 函数之前执行，而C++ 全局对象的析构函数在main函数之后被执行。 　Linux系统中，一般程序的入口是“ _start ， 这个函数是Linux系统库(Glibc)的一部分。当我们的程序与Glibc库链接...
深入C++中构造函数、拷贝构造函数、赋值操作符、析构函数的调用过程总结
01-01
1 . 用同一个类的源对象构造一个目标对象时，会调用拷贝构造函数...3. 当类有一个带有一个参数的构造函数时，可以用这个参数同类型的数据初始化这个对象，默认会调用这个构造函数。 代码如下: #include “stdafx.h” 
c c++ 函数内数组初值_C++ 结构体：超级数组，与C不同
weixin_39604516的博客
11-28 111
原创连载，喜欢点关注。15.结构体15.1 什么是结构体编程中如果有多条数据需要保存，比如说市场上各种蔬菜价格、期末考试成绩，你可以选择声明C++数组。但是使用数组有个限制——数组中的数据必须是相同的类型。如果我们想保存一组学生个人信息数据比如包含学生的姓名、年龄、身高、体重，就不能使用数组了。或许现在你认为解决这个难题，只能是给每个数据声明一个变量这一个办法了。假如要在学生用户和学校后台之间传递...
结构体构造函数使用总结
ww的博客
01-17 3314
三种结构体初始化方法 1.利用结构体自带的默认构造函数 2.利用带参数的构造函数 3.利用默认无参的构造函数 在建立结构体数组时,如果只写了带参数的构造函数将会出现数组无法初始化的错误！！！ 结构体是否有构造函数和析构函数,C里面没有，C++里面有。 C++里根本就没有结构,仅仅为了兼容c才有结构这种东西,实际上除了名字以外,C++的结...
【深入理解C++】析构函数
脚踏实地，仰望星空
01-27 1390
析构函数
c++ 结构体初始化 构造函数
yrk0556的博客
03-06 2336
struct Node{ int ts; int id; Node(int ts,int id):ts(ts),id(id){} };
C++构造函数中的初始化
yiyunoo的专栏
05-16 7988
很多的人对中构造函数寝初始化很多的困惑,对冒号后初始化不是太明白,总搞不清楚它们之间的区别,我想把我对这个问题的理解和看法和大家讨论讨论。  　　在程序中定义变量并初始化的机制中,有两种形式,一个是我们传统的初始化的形式,即赋值运算符赋值,还有一种是括号赋值,如:  　　int a=10;  　　char b=r;//赋值运算符赋值  　int a(10);/  　　char b(r)
C++的构造函数和析构函数（三）构造函数参数初始化列表
qq_47329614的博客
06-23 587
构造函数参数初始化列表 C++中提供了一种新的初始化成员变量的方法，那就是对象初始化列表；使用方法是在函数首部和函数体之间加一冒号，后面紧跟要初始化的参数，如下所示 class Test { public: int m_a; int m_b; Test(int a, int b) :m_a(a), m_b(b) { } }; 上面的代码与下面两种写法等价 class Test { public: int m_a; int m_b; Test(int a, int b){ this-
C++构造函数与析构函数
是鲤鱼啊
09-09 102
https://blog.csdn.net/u011392772/article/details/42772697?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.
C++中构造函数初始化
qq_44194231的博客
05-17 330
1.括号 Person p1; //默认构造函数 Person p2(10); //构造函数 Person p3(p2); //拷贝构造函数 2.显示 Person p1; //默认构造函数 Person p2 = Person(10); //构造函数， Person(10)单独写就是匿名对象，当前行结束后机会被析构 Person p3 = Person(p2); //拷贝构造函数 3.隐式转换法 Person p2 = 10; //构造函数 //编译器会转化成第二种方法 Person
全局对象的构造函数会在main函数之前执行？
晚晴小筑
09-27 366
#include &lt;iostream&gt; using namespace std; class CTest { public: CTest() { cout &lt;&lt; "构造函数..." &lt;&lt; endl; } ~CTest() { cout &lt;&lt; "析构函数..." &lt;&lt; endl; } }; int main
面向对象程序设计(C++)复习题(1).docx
11-11
1. 构造函数和析构函数的特性：构造函数用于初始化对象，是可重载的，而析构函数用于对象销毁时清理资源，C++中两者均不可重载。理解它们的区别对于正确使用类至关重要。 2. 类的继承特性：继承允许派生类从基类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值