首页 > 编程语言 > C++构造和析构

C++构造和析构

时间：2023-02-13 17:02:28浏览次数：47  
标签：name MM age 构造 int C++ 拷贝 和析构 构造函数


category: cpp

参考书籍:

C++ Primer
Essential C++

编译器:

gcc / g++

C++构造和析构

构造函数

  • 名字和类名相同
  • 没有返回值
  • 构造函数是用来构造对象，构造对象时候必定调用构造函数
  • 不写构造函数，存在一个默认的构造函数，默认的构造函数是无参，所以可以构造无参对象
  • 默认的构造函数可以删掉，通过delete删除默认的构造函数
  • 显示使用默认的构造函数, 通过default做显示调用
  • 通常情况构造函数是public属性
  • 自己写了构造函数，默认的构造函数就不存在了
  • 构造函数决定对象的长相(构造函数无参，对象无参，构造有一个，对象必须也要一个参数)
  • 构造函数通常做的事情，就是给数据成员初始化
  • 构造函数也是函数，所以也可以重载，也可以缺省
  • 通过重载和缺省，实现构造不同长相对象
#include <iostream>
#include <string>
using namespace std;
class MM {
   public:
    // MM() = default;     //显式使用默认的构造函数
    // MM() = delete;         //删掉默认的构造函数
    MM(string name, int age) {
        m_name = name;
        m_age = age;
        cout << "两个参数的构造函数" << endl;
    }
    MM() = default;  //默认无参构造函数，据说速度更快
    void printMM() {
         cout << m_name << "\t" << m_age << endl; 
    }

   protected:
    string m_name;
    int m_age;
};
// MM::MM()
//{
// cout << "调用无参构造函数" << endl;
// }
struct Boy {
    string name;
    int age;
    int num;
    //一旦C++结构体中写了构造函数，必须当做类去操作，不能用C语言的那种方式使用
    Boy() {}
    Boy(string bname, int bage) {
        name = bname;
        age = bage;
    }
};
void testStruct() {
    // Boy boy = { "string",18,1001};   //错误
    //这个地方也是创建对象过程，所以数据也需要和构造函数
    Boy boy = {"string", 18};  //这里数据必须和构造函数的一致
    Boy boy2;
    Boy array[3];
}
int main(int argc, char** argv) {
    // MM mm;
    // //因为构造函数有两个参数，对象也必须带有两参数
    MM mm("对象", 18);  //这步创建对象的过程就是调用构造函数构造函数的过程
    mm.printMM();
    MM empty;  //调用无参构造函数

    // new一个对象
    MM* p = new MM;               //调用无参的构造函数
    MM* p2 = new MM("对象", 29);  //调用有参的构造函数

    return 0;
}

析构函数

  • ~类名 当做析构函数名字
  • 没有参数
  • 释放数据成员new的内存
  • 在对象死亡前自动调用
  • 通常如果数据成员没有做new操作，就可以不写析构函数
  • 不写析构函数，存在一个默认的析构函数
#include <cstring>
#include <iostream>
using namespace std;
class MM {
   public:
    MM(const char* str ="ILoveyou") {  //缺省,相当于存在两个构造函数，一个是无参的，一个是有参
        int length = strlen(str) + 1;
        name = new char[length];
        strcpy(name, str);
    }
    ~MM();

   protected:
    char* name;
};
MM::~MM() {
    if (name != nullptr) {
        delete[] name;
        name = nullptr;
    }
    cout << "析构函数....\n" << endl;
}
int main(int argc, char** argv) {
    {
        MM mm;
        MM* p = new MM;
        cout << "1......" << endl;
        delete p;  //立刻调用析构函数
        p = nullptr;
        cout << "2......." << endl;
    }
    {
         MM beauty("Continue"); 
    }
    cout << "对象死亡" << endl;
    return 0;
}

拷贝构造函数

  • 拷贝构造函数也是构造函数
  • 拷贝构造函数参数是固定的:对对象的引用
  • 拷贝构造函数不写会存在一个默认的拷贝构造函数
  • 拷贝构造函数作用： 通过一个对象产生另一个对象
  • 关键点：一定是有一个新的对象产生
#include <iostream>
#include <string>
using namespace std;
class MM {
   public:
    MM() {}
    MM(string name, int age) {
        m_name = name;
        m_age = age;
    }
    MM(MM& object);
    void printMM() {
         cout << m_name << "\t" << m_age << endl; 
    }

   protected:
    string m_name;
    int m_age;
};
//拷贝构造函数
//通过传入对象属性确定创建对象的属性
MM::MM(MM& object) {
    m_name = object.m_name;
    m_age = object.m_age;
    cout << "调用自己写的拷贝构造函数" << endl;
}

//函数传参也可以隐式调用
void print(MM object) {  // MM object=girl
    object.printMM();
}
// C++中传参能用引用就用，效率搞
void printData(MM& object) {  //引用就是别名，没有产生新的对象
    object.printMM();
}
int main(int argc, char** argv) {
    MM mm("C神", 18);
    //产生一个对象
    MM beauty = mm;   //隐式调用拷贝构造函数
    MM girl(beauty);  //显式调用拷贝构造函数
    print(girl);      //调用拷贝构造函数
    printData(girl);
    MM boy;
    //对象先有了，才赋值，不调用拷贝
    boy = girl;  //不调用拷贝构造函数-->默认重载=运算符(后续会详细阐述)

    return 0;
}

深浅拷贝问题

浅拷贝

  • 没有在拷贝构造函数中给数据成员做new操作
  • 默认拷贝构造函数都是浅拷贝

深拷贝

  • 在拷贝构造函数中做了new操作

浅拷贝导致内存释放问题

浅拷贝会导致同一段内存重复释放问题

#include <cstring>
#include <iostream>
using namespace std;
class MM {
   public:
    MM() {}
    MM(const char* str) {
        int length = strlen(str) + 1;
        name = new char[length];
        strcpy(name, str);
    }
    // MM(MM& object) {
    //     name = object.name;
    // }
    ~MM() {
        if (name != nullptr) {  //浅拷贝导致内存释放问题
            //浅拷贝会导致同一段内存重复释放问题
            //两个指针都指向同一段内存
            delete[] name;
            name = nullptr;
        }
    }

   private:
    char* name;
};
int main(int argc, char** argv) {
    {
        MM girl("girl");
        MM mm = girl;  //调用拷贝构造函数
    }
    return 0;
}

深拷贝解决方案

#include <cstring>
#include <iostream>
using namespace std;
class MM {
   public:
    MM() {}
    MM(const char* str) {
        int length = strlen(str) + 1;
        name = new char[length];
        strcpy(name, str);
    }
    MM(MM& object) {
        // name = object.name;
        int length = strlen(object.name) + 1;
        name = new char[length];
        strcpy(name, object.name);
    }
    ~MM() {
        if (name != nullptr) {
            delete[] name;
            name = nullptr;
        }
    }

   private:
    char* name;
};
int main(int argc, char** argv) {
    {
        MM girl("girl");
        MM mm = girl;  //调用拷贝构造函数
    }
    return 0;
}

综上： 一旦类中有指针，做了内存申请，并且要对对象做拷贝操作，就必须使用深拷贝

匿名对象

匿名对象就是无名对象，匿名对象只能充当右值，所以匿名对象拷贝必须存在移动拷贝，或者准备一个ecosnt限定普通拷贝构造函数。

#include <iostream>
#include <string>
using namespace std;
class MM {
   public:
    MM(){};
    MM(string name, int age) {
        m_name = name;
        m_age = age;
    }
    void printMM() {
         cout << m_name << "\t" << m_age << endl; 
    }
    MM(MM& object) {
        m_name = object.m_name;
        m_age = object.m_age;
    }
    //移动构造--->新标准的
    MM(MM&& object) {
        m_name = object.m_name;
        m_age = object.m_age;
        cout << "调用移动构造" << endl;
    }
    ~MM() {
         cout << "析构打印name:" << m_name << endl; 
    }

   private:
    string m_name;
    int m_age;
};
MM returnMM(string name, int age) {
    return MM(name, age);  //构造一个匿名对象当做函数返回值
}
int main(int argc, char** argv) {
    {
        MM girl("girl", 19);
        //匿名对象是一个右值
        MM mm = MM("mm", 29);  //匿名对象  --->匿名对象转正 ，mm接管所有权
        cout << "匿名对象已死亡" << endl;
    }
    MM beauty = returnMM("返回值", 18);
    beauty.printMM();

    return 0;
}

构造和析构顺序问题

  • 一般情况构造顺序和析构是相反的
  • 静态的和全局的是最后释放的
  • delete 立刻调用析构函数
#include <iostream>
#include <string>
using namespace std;
class Test {
   public:
    Test(string data = "A") {
        m_data = data;
        cout << m_data;
    }
    ~Test() { cout << m_data; }

   protected:
    string m_data;
};

int main(int argc, char** argv) {
    {
        Test t1;                  // A
        static Test t2("B");      // B
        Test array[3];            // AAA   //数组就是多个无参
        Test* p = new Test("C");  // C
        delete p;                 // C
        p = nullptr;
    }
    // ABAAACCAAAAB
    return 0;
}
//用构造函数的方式简单实现单链表
#include <iostream>
using namespace std;
struct Node {
    int data;
    Node* next;
    Node() : next(nullptr) {}
    Node(int data) : data(data), next(nullptr) {}
    Node(int data, Node* next) : data(data), next(next) {}
};
class List {
   public:
    List();
    void insertData(int data);
    void printList() {
        Node* pmove = headNode->next;
        while (pmove != nullptr) {
            cout << pmove->data << " ";
            pmove = pmove->next;
        }
        cout << endl;
    }

   private:
    Node* headNode;
};
List::List() {
    headNode = new Node;
}
void List::insertData(int data) {
    headNode->next = new Node(data, headNode->next);
}

int main(int argc, char** argv) {
    List list;
    list.insertData(1);
    list.insertData(2);
    list.insertData(3);
    list.printList();
    return 0;
}

标签：name,MM,age,构造,int,C++,拷贝,和析构,构造函数
From： https://blog.51cto.com/u_15959862/6054512

相关文章

  • 【C++复习】运算符优先级（简）
    不同优先级的运算符混在一起，就根据优先级算相同优先级的运算符混在一起，就看它们的结合性（这里不谈）1、运算符有哪些？单目运算符*++自增，有前置和后置--自减，有前置和后置......
  • C++ 修改防火墙firewall设置（Linux、Ubuntu、CentOS）
    1、简介1.1Ubuntuhttps://ubuntu.com/download/desktopUbuntu是一个以桌面应用为主的Linux操作系统，其名称来自非洲南部祖鲁语或豪萨语的“ubuntu"一词，意思是“人性”“......
  • Calling C++ Code From Go With SWIG
    http://zacg.github.io/blog/2013/06/06/calling-c-plus-plus-code-from-go-with-swig/ RecentlywhileworkingonaGobasedprojectIneededtousesomefunctio......
  • VScode 配置C++环境记录
    gcc/g++是c/c++编译器，Windows需要借助Mingw来使用c++的编译器，下面是安装MinGW的教程：搬运：https://blog.csdn.net/jjxcsdn/article/details/123058745在VScode中配置编译......
  • Visual C++课程设计选题任务书[2023-02-13]
    VisualC++课程设计选题任务书[2023-02-13]VisualC++课程设计选题任务书课程设计要求：每个课题最多供2名学生选择。使用VisualStudio平台进行开发（推荐使用VisualStu......
  • C/C++图书入库管理系统[2023-02-13]
    C/C++图书入库管理系统[2023-02-13]题目21图书入库管理系统[说明及要求]实现图书信息(书号、书名、作者、定价、数量)的新增、修改、删除和查询功能;实现入库信息(书号......
  • C/C++物业费管理系统[2023-02-13]
    C/C++物业费管理系统[2023-02-13]12物业费管理系统完成小区物业费用管理系统设计。功能要求:(1)新住户信息的添加。(户主姓名、性别、身份证号、联系电话、楼号、单元......
  • C/C++飞机订票系统[2023-02-12]
    C/C++飞机订票系统[2023-02-12]飞机订票系统1、需求分析航班信息用文件保存，因而要提供文件的输入输出操作:航班信息浏览功能需要提供显示操作;要查询航线需要提供查找功......
  • C++分隔符分割字符串
    ///<summary>///分割字符串///</summary>///<paramname="str">字符串</param>///<paramname="split">分隔符</param>///<paramname="res">子字符串集合</param>vo......
  • C++类和对象
    参考书籍:C++PrimerEssentialC++编译器:gcc/g++C++类和对象初识类的创建类和结构体区别在没写构造函数之前，C语言结构体就按照C语言的方式用即可用了构造函数时候，结构体......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99