C++ 光速入门指南day14-构造函数和析构函数

已于 2022-07-08 18:20:55 修改
阅读量194 收藏
点赞数
文章标签： c++
于 2021-07-14 22:15:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39276337/article/details/118736415
版权

构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

  • 一个对象或者变量没有初始状态，对其使用后果是未知

  • 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

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

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

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

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

析构函数语法 : ~类名(){}
5. 析构函数，没有返回值也不写void
6. 函数名称与类名相同,在名称前加上符号 ~
7. 析构函数不可以有参数，因此不可以发生重载
8. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

#include <iostream>
#include <cstring>
using namespace std;
class Person{
public:  Person(){
        cout<< "constructor called"<< endl;
    }

public:  ~Person(){
        cout<< "xigou constructor called"<< endl;
    }
};
int main() {
    Person p1;

4.2.2 构造函数的分类及调用

两种分类方式：

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

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

三种调用方式：

括号法

显示法

隐式转换法

#include <iostream>
#include <cstring>
using namespace std;
class Person{
    // 无参构造函数 (默认)
public:  Person() {
        cout<< "constructor called"<< endl;
    }
    // 有参构造
     Person(int a) {
        age = a;
        cout<< "youcan constructor called"<< endl;
    }
    // 拷贝构造函数
    Person(const Person& p){
        age = p.age;
        cout<< "copy constructor called"<< endl;

    }
    // 析构函数
    ~Person(){
        cout<< "xigou constructor called"<< endl;
    }

public:
    int age;
};
int main() {
//    Person p1; // 自动调用无参构造函数
//    cout<<  p1.age << endl;  // 0
    // 调用方式
    //1. 括号法 (常用)
    ///注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
//    Person p2(18);
//    Person p3(p2);

//    cout<<  p2.age << endl;
    // 2 显示法
//    Person p3 = Person(10);
//    // 调用拷贝构造
//    Person p4 = Person(p3);
    // 3隐式转换法
    Person p5 = 10; // =  Person p3 = Person(10);
    Person p6 = p5; // =  Person p4 = Person(p3);
}

拷贝构造函数调用时机

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

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值
  • 以值方式返回局部对象
#include <iostream>
#include <cstring>
using namespace std;
class Person{
    // 无参构造函数 (默认)
public:  Person() {
        cout<< "wucan constructor called"<< endl;
        mAge = 0;
    }
    // 有参构造
     Person(int age) {
        mAge = age;
        cout<< "youcan constructor called"<< endl;
    }
    // 拷贝构造函数
    Person(const Person& p){
        cout<< "copy constructor called"<< endl;
        mAge = p.mAge;
    }
    // 析构函数
    ~Person(){
        cout<< "xigou constructor called"<< endl;
    }

public:
    int mAge;
};
void test01(){
    // 1 使用一个已经创建完毕的对象来初始化一个新对象
    Person man1(100);
//    Person man2(man1); // 调用拷贝构造
//    Person man3 = man1;  // 调用拷贝构造

//    Person man4;
//    man4 = man1; //man4 在之前已经创建完了, 这里赋值操作
}
void doWork(Person p1){}
void test02(){
    Person p; // 无参构造
    // 2 值传递的方式给函数参数传值
    doWork(p);
}


Person doWork2(){
    Person p1;
    cout << &p1 << endl;
    return p1;
}
// 3.以值方式返回局部对象
void test03(){
    Person p =  doWork2();
    cout << &p << endl;
}
int main() {
    // 1 使用一个已经创建完毕的对象来初始化一个新对象
//    test01();
    // 2 值传递的方式给函数参数传值
//    test02();
    // 3.以值方式返回局部对象
    test03();

}

构造函数调用规则

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

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

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

3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：

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

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

#include <iostream>
#include <cstring>
using namespace std;
class Person{
//     无参构造函数 (默认)
public:  Person() {
        cout<< "wucan constructor called"<< endl;
        mAge = 0;
    }
    // 有参构造
     Person(int age) {
        mAge = age;
        cout<< "youcan constructor called"<< endl;
    }
//     拷贝构造函数
    Person(const Person& p){
        cout<< "copy constructor called"<< endl;
        mAge = p.mAge;
    }
//     析构函数
    ~Person(){
        cout<< "xigou constructor called"<< endl;
    }

public:
    int mAge;
};
void test01(){
   Person p1(18);
//   Person p2; 只提供有参这样不能调用了
    // 如果不写拷贝构造函数,编译器会自动添加拷贝构造,并且是浅拷贝操作
    Person p2(p1);
    cout<< p2.mAge << endl;
   //
}
void test02(){
    // 如果用户提供拷贝构造, 编译器不会提供其他构造函数
    Person p1; // 会报错
    Person p2(p1); // 会报错

}
int main() {
//    test01();
    test02();


}

初始化列表

作用：

C++提供了初始化列表语法，用来初始化属性
语法: 构造函数(): 属性1(值1), 属性2(值2)…{}

#include <iostream>
#include <cstring>
using namespace std;
class Person{
//     无参构造函数 (默认)
public:
//     Person(int a, int b, int c, int d) {
//         m_A = a;
//         m_B = b;
//         m_C = c;
//         m_D = d;
//    }
    Person(int a, int b, int c, int d):m_A(a), m_B(b), m_C(c), m_D(d){}
    void print(){
    cout<< m_A <<endl;
    cout<< m_B <<endl;
    cout<< m_C <<endl;
    cout<< m_D <<endl;
}
private:
    int m_A;
    int m_B;
    int m_C;
    int m_D;
};

int main() {
    Person p1(1, 2, 3, 4);
    p1.print();

}

类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

class A{}
classB(){
	A   a;
}

B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

#include <iostream>
#include <cstring>
using namespace std;
class Phone{
public:
    Phone(string name) : m_PhoneName(name) {
        cout << "Phone constructor called"<<endl;
    }

    Phone() {}
    ~Phone() {
        cout << "Phone xigou constructor called"<<endl;

    }

public:
    string m_PhoneName;
};
class Person{
public:
    Person(string name,  string pNmae) : m_Name(name), m_Phone(pNmae) {
        cout << "Person constructor called"<<endl;
    }
    ~Person(){
        cout << "Person xigou constructor called"<<endl;
    }
    void playGame(){
        cout<< m_Name << "use" << m_Phone.m_PhoneName<<" phone playGame"<<endl;
    }
private:
    string  m_Name;
    Phone m_Phone;
};

int main() {
    //当类中成员是其他类对象时，我们称该成员为 对象成员
    //构造的顺序是 ：先调用对象成员的构造，再调用本类构造
    //析构顺序与构造相反
    Person p("Eric", "Huawei");
    p.playGame();

}

在这里插入图片描述

静态成员

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

静态成员分为：

  • 静态成员变量
    • 所有对象共享同一份数据(具有记忆作用)
    • 在编译阶段分配内存
    • 类内声明，类外初始化
  • 静态成员函数
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量
#include <iostream>
#include <cstring>
using namespace std;
class Person{

public:
   // 特点:
   // 在编译阶段分配内存
   // 类内声明 类外初始化
   // 所有对象共享同一份数据
   static int m_A; //静态成员变量
private:
   static int m_B; //静态成员变量也是有访问权限的

};
// :: 作用域符
int Person::m_A = 10;
int Person::m_B = 10;
int main() {
   // 通过类名进行访问
   cout << "m_A = " << Person::m_A << endl;
//    cout << "m_A = " << Person::m_B << endl; // 权限限制
   // 通过对象
   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 << "p1.m_A  = " << p2.m_A  << endl; // 共享一份数据

}
__Miracle__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入解析C++中的构造函数和析构函数
12-31
调用构造函数和析构函数的顺序：先构造的后析构，后构造的先折构。它相当于一个栈，先进后出。 代码如下:#include<iostream>#include<string>using namespace std;class Student{ public: Student(string,string,...
C++类和对象：拷贝构造函数和运算符重载
weixin_43908419的博客
02-28 1045
本文对C++类的拷贝构造函数和运算符重载函数进行了详解
C++面向对象的特性：封装知识点一
qq_46087622的博客
11-02 163
一、封装 封装的意义： 将属性和行为作为一个整体，表现生活中的事物，将属性和行为加以权限控制 1、在设计类的时候，属性和行为写在一起，表现事物。 2、语法： class 类名{ 访问权限： 属性 / 行为 }; 3、类在设计时，可以把属性和行为放在不同的权限下，加以控制 访问权限有三种： public 公共权限 protected 保护权限 private 私有权限 4、成员属性设置为私有 优点1：将所有成员属性设置为私有，可以自己控制读写权限 优点2：对于写权限，我们可以检测数据的有效性 struct
构造函数、拷贝构造函数、析构函数和运算符重载函数
01-11 328
一、构造函数与析构函数 （1）构造函数概念： 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。 构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。 （2）析构函数概念: 类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。 析构函数的名称与类的名称是完全相同的，只是在前面加...
递增运算符重载
码云仓库地址：https://gitee.com/lance-gyq
08-29 293
递增运算符重载 作用：通过重载递增运算符，实现自己的整形数据 代码示例： #include <iostream> using namespace std; //重载递增运算符 //自定义整形 class MyIntegrer { friend ostream& operator<<(ostream& cout, MyIntegrer myint); public: MyIntegrer() {
拷贝构造函数和赋值重载函数详解
weixin_66828150的博客
04-30 964
注意：++和--分为前置和后置，前置不需要传参，只有一个隐藏的“this”形参，后置需要传一个形参和隐藏的“this”参数，一共两个形参，自己传的形参根据情况而定，为内置类型。C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。因为使用值传递，会发生无穷递归，因为传值会引发值拷贝，值拷贝又要传值，而传值又会引发值拷贝，无穷下去，导致无穷递归，所以一定不要使用值传递。这五个操作符不能被重载！
C++6 --- 拷贝构造函数、拷贝构造函数
kyrie_sakura的博客
10-23 625
拷贝构造函数 拷贝构造函数
C++面向对象知识点三：拷贝构造函数
08-25 266
拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于： 通过使用另一个同类型的对象来初始化新创建的对象。 复制对象把它作为参数传递给函数。 复制对象，并从函数返回这个对象。 如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造...
4.【拷贝构造函数与重载】
qq_69683957的博客
07-31 692
【没有明确提供拷贝构造函数的时候回调用默认的拷贝构造函数】 #include <iostream> #include <string.h> using namespace std; class Student { private: int number; string name; public: Student(int nu, string na) :number(nu), name(na) {} Student() {} v.........
2021-09-30
hhf1732641824的博客
09-30 806
Miracle密码算法开源库（零） 项目综述 2021SC@SDUSC 山东大学软件学院软件工程应用与实践 一．MIRACL简介 MIRACL(Multiprecision Integer and RationalArithmetic C/c++ Library)是一套由Shamus Software Ltd.所开发的一套关于大数运算函数库，用来设计与大数运算相关的密码学之应用，包含了RSA 公开密码学、Diffie-Hellman密钥交换(Key Exchange)、AES、DSA数字签名，还包含了较新的
C++ 基础之公有、私有和保护（一句话说清楚）
热门推荐
LSEC小陆的博客
03-03 1万+
C++ 基础之公有、私有和保护 公有继承、私有继承和保护继承，什么七七八八的，一句话说清楚。 数据成员和成员函数的公有、私有和保护 类的定义 我们知道，定义一个类，类里面的成员包括数据成员（属性）和成员函数（方法）。数据成员是描述类的属性的一些数据，成员函数是描述类的行为的一些数据。 类的成员根据它们的访问权限，在类内被分成了三类：公有（public）、私有（private）和保护（prote...
C++构造函数和析构函数顺序
12-22
构造函数 　先看看构造函数的调用顺序规则，只要我们在平时编程的时候遵守这种约定，任何关于构造函数的调用问题都能解决；构造函数的调用顺序总是如下： 　1.基类构造函数。如果有多个基类，则构造函数的调用顺序...
c++ 入门——浅析构造函数和析构函数
12-17
关于C++的环境搭建请参考下面链接： https://www.jb51.net/article/186542.htm 由于本人具有C#开发经验，部分相同的知识就不再赘述了。只列一下需要记录的知识。 HelloWorld cout 代表输出<< cin 代表输入 >> ...
C++构造函数和析构函数的使用与讲解
01-20
构造函数(constructor) 1.构造函数是种特殊的类成员函数，遵循如下规则： a.函数名与类名必须相同。...3.构造函数和普通成员函数不一样，一般不显示调用。在创建一个对象时，构造函数自动调用(编译器来完成
C++面向对象三大特性——封装与信息隐蔽
pangyou3s的博客
12-09 458
c++面向对象三大特性——封装
C++基础——面向对象的三大特性：封装、继承、多态
Volador的博客
10-28 478
封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。C++ 通过创建类来支持封装和数据隐藏（public、protected、private）。我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。
C++ 面向对象三大特性：封装
小白的逆袭
07-16 625
21.面向对象三大特性：封装 21.1 什么是封装 前面我们在设计C++的类时，会把类的属性和类的函数以类成员的身份写在类的{ }中。反过来也可以说类能被拆解为两种基本要素：属性和函数。 在面向对象程序设计中封装就是把互相关联的数据和操作这些数据的函数写在同一个类中的意思。 我们可以从两个层面来理解封装： 一是类的封闭性。类的数据和功能函数被类的{ }封闭在类的作用域内，他们互相协...
C/C++易忘点复习（二）
槿梓的博客
03-26 421
文章目录4 类和对象4.1 封装4.1.1 封装的意义4.1.2 struct和class区别4.1.3 成员属性设置为私有 4 类和对象 C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有其属性和行为 例如： ​ 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌… ​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐...
C++面向对象三大特性之一封装
码云仓库地址：https://gitee.com/lance-gyq
01-31 189
封装是C++面向对象三大特性之一 封装的意义： 1.将属性和行为作为一个整体，表现生活的事物。 2.将属性和行为加以权限控制 封装意义一： 在设计类的时候，属性和行为写在一起，表现事物 语法： class 类名{ 访问权限：属性/行为}； 案例：设计一个圆类，求圆的周长 示例代码： #include <iostream> using namespace std; //圆周率 const double PI = 3.14; //设计一个圆类，求圆的周长 //圆求周长的公式：2*PI*半径
C++结构体构造函数和析构函数
最新发布
12-01
C++结构体也可以拥有构造函数和析构函数，它们的作用和类的构造函数和析构函数相同。下面是一个结构体的构造函数和析构函数的例子： ```c++ #include #include using namespace std; struct Person { string ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值