QT学习C++（7）

已于 2022-08-19 15:30:02 修改
阅读量591 收藏 3
点赞数 1
文章标签： c++ 学习 开发语言
于 2022-08-02 16:12:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhdhhy/article/details/126010352
版权

构造函数和析构函数

对象的构造和析构

构造和析构函数，这两个函数将会被编译器自动调用，构造函数完成对象的初始化动作，析构函数在对象清理工作。

注意：对象的初始化和清理工作时编译器强制我们要做的事情，即使你不提供初始化操作和清理操作，编译器也会增加默认的操作，只是这个默认初始化操作不会做任何事。

构造函数：实例化对象的时候系统自动调用

析构函数：对象释放的时候系统自动调用

构造和析构函数的定义

构造函数语法：构造函数函数名和类名相同，没有返回类型，连void都不可以，但可以有参数。

析构函数语法：构造函数函数名是在类名前面加“~”组成，没有返回类型，连void都不可以，不能有参数，不能重载。

例：

#include <iostream>

using namespace std;
class data{
public:
    int num;
public:
    //构造函数
    data(){
        num = 0;
        cout<<"无参的构造函数= "<<num<<endl;
    }
    data(int n){
        num = n;
        cout<<"有参的构造函数= "<<num<<endl;
    }

    //析构函数
    ~data(){
        cout<<"析构函数"<<endl;
    }
};

int test(void){
    data ob1;
    return 0;
};
int main(int argc, char *argv[])
{
    cout << "-----001--------" << endl;
    test();//类实例化对象，系统自动调用构造函数
    cout << "-----002--------" << endl;
    data ob;
    cout << "-----003--------" << endl;
    return 0;
}

类的实例化，系统自动调用构造函数，在test()中ob1是局部对象，因此在test()结束时调用析构：而ob是对象在main中，因此在main函数结束时调用析构函数。

构造函数分类

按参数：无参构造和有参构造函数

按类型：普通构造和拷贝（复制）构造函数

构造函数的调用

调用形式：

#include <iostream>

using namespace std;
class data{
public:
    int num;
public:
    //构造函数
    data(){
        num = 0;
        cout<<"无参的构造函数= "<<num<<endl;
    }
    data(int n){
        num = n;
        cout<<"有参的构造函数= "<<num<<endl;
    }

    //析构函数
    ~data(){
        cout<<"析构函数= "<<num<<endl;
    }
};

int test(void){
    data ob1; //调用无参构造或默认构造（隐式调用构造函数）
    data ob2 = data(); //显示式调用构造函数
    data ob3(10); //调用有参构造函数（隐式调用）=ob3.data(10)
    data ob4 = data(20); //调用有参构造函数（显式调用）=ob4.data(20)

    //隐式转换的方式 调用有参构造（针对只有一个数据成员）少用
    data ob5 = 30; //=ob5.data(30)

    //匿名对象
    cout << "-----匿名对象--------" << endl;
    data(40); //当前语句结束，匿名对象立即释放
    cout << "-----匿名对象释放--------" << endl;
    return 0;
};
int main(int argc, char *argv[])
{
    cout << "-----001--------" << endl;
    test();//类实例化对象，系统自动调用构造函数
    cout << "-----002--------" << endl;
    //data ob;
    cout << "-----003--------" << endl;
    return 0;
}

析构函数的调用是出栈的顺序（后入先出），在同一作用域构造和析构顺序相反

拷贝构造函数的调用

//拷贝构造函数
Date(const Data &ob){
    cout<<"拷贝构造函数"<<endl;
}

顾名思义，拷贝构造函数用于对象复制对方的构造函数

如果不定义，则系统会有默认的拷贝构造函数

#include <iostream>

using namespace std;
class Data{
public:
    int num;
public:
    //构造函数
    Data(int n){
        num = n;
        cout<<"构造函数= "<<num<<endl;
    }
//    //拷贝构造函数
//    Date(const Data &ob){
//        cout<<"拷贝构造函数"<<endl;
//    }

    //析构函数
    ~Data(){
        cout<<"析构函数= "<<num<<endl;
    }
};

int test(void){
    Data ob1(10);
    Data ob2 = ob1;
    cout <<"ob1.num= "<<ob1.num<< endl;
    cout <<"ob2.num= "<<ob2.num<< endl;
    return 0;
};
int main(int argc, char *argv[])
{
    cout << "-----001--------" << endl;
    test();//类实例化对象，系统自动调用构造函数
    cout << "-----002--------" << endl;
    //data ob;
    cout << "-----003--------" << endl;
    return 0;
}

如图ob2默认拷贝了ob1的构造函数，因为是系统默认的， 因此未显示。

  • 用户不实现拷贝构造，系统会调用默认的拷贝构造；
  • 默认的拷贝构造也就是单纯的整体赋值（浅拷贝）；
  • 如果用户实现了，系统调用用户实现的拷贝函数；

用户定义了拷贝构造：

#include <iostream>

using namespace std;
class Data{
public:
    int num;
public:
    //构造函数
    Data(int n){
        num = n;
        cout<<"构造函数= "<<num<<endl;
    }
    //拷贝构造函数
    Data(const Data &ob){
        num = ob.num*ob.num;
        cout<<"拷贝构造函数"<<endl;
    }

    //析构函数
    ~Data(){
        cout<<"析构函数= "<<num<<endl;
    }
};

int test(void){
    Data ob1(10);
    Data ob2 = ob1;
    cout <<"ob1.num= "<<ob1.num<< endl;
    cout <<"ob2.num= "<<ob2.num<< endl;
    return 0;
};
int main(int argc, char *argv[])
{
    cout << "-----001--------" << endl;
    test();//类实例化对象，系统自动调用构造函数
    cout << "-----002--------" << endl;
    //data ob;
    cout << "-----003--------" << endl;
    return 0;
}

 拷贝构造函数的调用

#include <iostream>

using namespace std;
class Data{
public:
    int num;
public:
    //构造函数
    Data(int n){
        num = n;
        cout<<"构造函数= "<<num<<endl;
    }
    //拷贝构造函数
    Data(const Data &ob){
        num = ob.num*ob.num;
        cout<<"拷贝构造函数"<<endl;
    }

    //析构函数
    ~Data(){
        cout<<"析构函数= "<<num<<endl;
    }
};

int test(void){
    Data ob1(10);
    Data ob2(ob1);//隐式调用拷贝构造函数
    Data ob3 = Data(ob1);//显示调用拷贝构造函数
    Data ob4 = ob1;//=隐式转换调用
    cout <<"ob1.num= "<<ob1.num<< endl;
    cout <<"ob2.num= "<<ob2.num<< endl;
    cout <<"ob3.num= "<<ob3.num<< endl;
    cout <<"ob4.num= "<<ob4.num<< endl;
    return 0;
};
int main(int argc, char *argv[])
{
    cout << "-----001--------" << endl;
    test();//类实例化对象，系统自动调用构造函数
    cout << "-----002--------" << endl;
    //data ob;
    cout << "-----003--------" << endl;
    return 0;
}

 拷贝构造函数（旧对象初始化新对象）

注意：

只是单纯的赋值，例如：

#include <iostream>

using namespace std;
class Data{
public:
    int num;
public:
    //构造函数
    Data(){
        num = 5;
        cout<<"wucan构造函数= "<<num<<endl;
    }
    Data(int n){
        num = n;
        cout<<"youcan构造函数= "<<num<<endl;
    }
    //拷贝构造函数
    Data(const Data &ob){
        num = ob.num*ob.num;
        cout<<"拷贝构造函数"<<endl;
    }

    //析构函数
    ~Data(){
        cout<<"析构函数= "<<num<<endl;
    }
};

int test(void){
    Data ob1(10);
    Data ob2;
    cout <<"ob2.num= "<<ob2.num<< endl;
    ob2 = ob1;
    cout <<"ob1.num= "<<ob1.num<< endl;
    cout <<"ob2.num= "<<ob2.num<< endl;
    return 0;
};
int main(int argc, char *argv[])
{
    cout << "-----001--------" << endl;
    test();//类实例化对象，系统自动调用构造函数
    cout << "-----002--------" << endl;
    //data ob;
    cout << "-----003--------" << endl;
    return 0;
}

 注意：

 

 

 构造函数的调用规则：

系统会对任何一个类提供三个成员函数：

默认构造函数、默认析构函数、默认拷贝构造函数（浅拷贝）

1、如果用户提供了有参构造，将会屏蔽系统的默认构造函数。

2、如果用户提供了有参构造，不会屏蔽系统的默认拷贝构造函数。

3、如果用户提供了拷贝构造函数，将屏蔽系统的默认构造函数和默认拷贝构造函数。

 总结

对于构造函数：用户一般要实现无参构造、有参构造、拷贝构造、析构函数。

深拷贝和浅拷贝问题

浅拷贝：拷贝对象和被拷贝对象指向同一存放区域，在释放时会导致空间被释放两次

#include <iostream>
#include <string.h>
using namespace std;
class Person{
private:
    char* name;
    int num;
public:
    Person(){
       cout<<"无参构造"<<endl;
    }
    Person(char* n, int nu){
        //因为name指针无指向，为name申请空间
        //C语言的方式，从堆处申请
        name = (char*)calloc(1,strlen(n)+1);//n传过来不会包含/0,因此需要+1给/0
        if(name == NULL){
            cout<<"构造失败"<<endl;//因为C语言的calloc申请空间容易失败
        }
        cout<<"申请空间"<<endl;
        strcpy(name, n);
        num = nu;
        cout<<"有参构造"<<endl;
    }
    ~Person(){//析构函数作用：在结束时释放空间
        if(name != NULL){
            free(name);
            name = NULL;
            cout<<"释放空间"<<endl;
        }
        cout<<"析构"<<endl;
    }
    void show(void){
        cout<<"name= "<<name<<" age= "<<num<<endl;
    }
};
int main(int argc, char *argv[])
{
    Person lucy("lucy", 20);
    lucy.show();

    //浅拷贝问题
    Person bob = lucy;
    return 0;
}

（申请一次释放两次）

 拷贝构造函数可以通过自定义形成深拷贝，解决浅拷贝的问题

#include <iostream>
#include <string.h>
using namespace std;
class Person{
private:
    char* name;
    int num;
public:
    Person(){
       cout<<"无参构造"<<endl;
    }
    Person(char* n, int nu){
        //因为name指针无指向，为name申请空间
        //C语言的方式，从堆处申请
        name = (char*)calloc(1,strlen(n)+1);//n传过来不会包含/0,因此需要+1给/0
        if(name == NULL){
            cout<<"构造失败"<<endl;//因为C语言的calloc申请空间容易失败
        }
        cout<<"申请空间"<<endl;
        strcpy(name, n);
        num = nu;
        cout<<"有参构造"<<endl;
    }
    Person(const Person &o){
        //因为name指针无指向，为name申请空间
        //C语言的方式，从堆处申请
        name = (char*)calloc(1,strlen(o.name)+1);//n传过来不会包含/0,因此需要+1给/0
        if(name == NULL){
            cout<<"构造失败"<<endl;//因为C语言的calloc申请空间容易失败
        }
        cout<<"申请空间"<<endl;
        strcpy(name, o.name);
        num = o.num;
        cout<<"有参构造"<<endl;
    }
    ~Person(){//析构函数作用：在结束时释放空间
        if(name != NULL){
            free(name);
            name = NULL;
            cout<<"释放空间"<<endl;
        }
        cout<<"析构"<<endl;
    }
    void show(void){
        cout<<"name= "<<name<<" age= "<<num<<endl;
    }
};
int main(int argc, char *argv[])
{
    Person lucy("lucy", 20);
    lucy.show();

    //浅拷贝问题
    Person bob = lucy;
    return 0;
}

 （申请两次，释放两次）

注：本文档仅学习总结

QT学习C++（6）_爱吃糖葫芦的大熊的博客-CSDN博客

QT学习C++（8）_爱吃糖葫芦的大熊的博客-CSDN博客

爱吃糖葫芦的大熊
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++基础（7）
weixin_53617926的博客
07-18 113
C++基础（7）
qt下文件拷贝函数
11-10
不错的使用qt编程实现文件拷贝，初学者可以借鉴哦！
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)解析
weixin_41157654的博客
06-26 8758
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow), queryTimer(), payTimer(), httpRequestManager(new QNetworkAccessManager()), state(Init), trad...
QT学习（六）C++构造函数和初始化列表
ryh2004812的博客
02-06 1018
中，使用初始化列表来初始化类的字段是一种高效的初始化方式，尤其在构造函数中。初始化列表直接在对象的构造过程中初始化成员变量，而不是先创建成员变量后再赋值。：对于非基本类型的对象，使用初始化列表比在构造函数体内赋值更高效，因为它避免了先默认构造然后再赋值的额外开销。的成员变量，必须使用初始化列表，因为这些类型的成员变量在构造函数体内不能被赋值。：成员变量的初始化顺序是按照它们在类中声明的顺序，而不是初始化列表中的顺序。中推荐的初始化类成员变量的方式，因为它提供了更好的性能和灵活性。构造，那构造的是什么呢？
【QT】QT的学习：QT中构造函数
热门推荐
ipfpm的博客
09-27 1万+
在创建QT的项目的时候或者参照别人的例子的时候会发现在类中构造函数的定义声明中有如下： 在h文件中：   class MainWindow : public QMainWindow {     Q_OBJECT public:     MainWindow(QWidget *parent = 0);//MainWindow不会作为任何控件的子部件；     ~
C++ Qt中 类的构造函数 & 析构函数
cherry-keven
10-26 6784
类的构造函数 类的构造函数是一个特殊的成员函数，它会在每次创建类的新对象时执行。 构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。 #include <iostream> using namespace std; class Line { public: void setLength( double len ); double getLength( void ); Line(); // 这是构造函数
QT C++学习代码案例
08-27
QT C++学习代码案例是为初学者准备的一系列实践教程，旨在帮助他们快速掌握QT库在C++编程中的应用。这个资源包含32个精心设计的代码实例，涵盖了QT库的基础到进阶功能，使学习者能够从实践中理解并运用QT。 首先，...
Qt 5.9 C++开发指南-Qt核心特点源码
09-16
**Qt 5.9 C++ 开发指南：深入理解Qt核心特点与源码解析** Qt是一个流行的开源跨平台应用程序开发框架，广泛应用于桌面、移动和嵌入式系统。Qt 5.9是其一个重要的版本，它在稳定性和性能上都有显著提升，同时也引入...
QT+C++学习嵌入式
09-24
QT+C++学习嵌入式 本资源主要介绍了使用 QT 和 C++ 进行嵌入式开发的学习指南。该指南涵盖了从基础知识到实践应用的所有方面，旨在帮助开发者快速掌握 QT 和 C++ 在嵌入式开发中的应用。 第一部分：入门篇 在本...
《QT5.9C++开发指南》源码
05-02
配合B站阿西拜的QT课程，你可以逐步学习并实践上述知识点，通过实际操作理解每一个概念，并逐步掌握QT5.9C++的开发技巧。记得根据课程内容适当修改源码，以加深理解和记忆。在实践中不断学习和探索，你将成为一名...
Qt5.9C++书本代码资源.zip
11-04
总的来说，这个"Qt5.9C++书本代码资源.zip"是学习和进阶Qt5.9与C++编程的宝贵资料，对于希望在跨平台应用开发领域提升技能的开发者来说，这是一个不可或缺的学习工具。通过深入研究并动手实践，你将能够熟练地运用Qt...
[QT入门篇]窗口类的应用
风间琉璃的博客
07-17 2111
QWidget类是所有窗口类的父类，控件类也属于窗口类,并且QWidget类的父类是QObject,所有的窗口类对象只要指定了父对象,都可以实现内存资源的自动回收。通过QWidget()构造一个窗口，并可以通过setParent设置窗口的父对象。获取/设置窗口的位置和大小一般移动窗口只需要移动左上角的坐标即可。窗口的标题和图标也可以进行设置。...
构造函数、析构函数、拷贝构造函数
Evan_work的博客
03-18 582
1、构造函数 构造函数函数名和类名相同，没有返回类型，连void都不可以，但可以有参数，可以重载 构造函数：实例化对象的时候系统自动调用 2、析构函数 析构函数函数名是在类名前面加”~”组成,没有返回类型，连void都不可以,不能有参数，不能重载 析构函数：对象释放的时候系统自动调用 案例： class Data { public: int num; public: //构造函数(...
QT第18-22节课程笔记 - 构造函数 - 拷贝构造函数完整笔记
chenlichenforlinux21的博客
12-19 1247
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造，那构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。// 使用std命名空间public:// 不需要使用std::stringint year;// 无参构造函数Car() {brand = "未知";year = 0;cout << "无参构造函数被调用" << endl;
13.拷贝构造函数
m0_45388819的博客
02-21 190
13.拷贝构造函数 1.拷贝构造函数的作用：本质上拷贝构造函也是一种构造函数 2.拷贝构造函数的调用时机：与普通的构造函数不同的是，当用一个对象创建另一个对象时才调用拷贝构造函数 3.缺省拷贝构造函数的作用：如果我们自己没有书写拷贝构造函数，默认情况下系统会创建默认拷贝构造函数，默认的拷贝构造函数就是完全将对象1拷贝给对象2，以memcpy的形式 4.如何自己创建拷贝构造函数 //前面已有CStudent的构造函数 class CStudent { CStudent(){};//构造函数 //拷贝构
拷贝构造函数
m0_51918781的博客
07-19 251
浅拷贝与类类型作为形参和返回值
构造函数 继承qt_派生QT类的复制构造函数
weixin_39943220的博客
01-17 237
I have a class which is publicly inherited from QWidget:class MyWidget : public QWidget{Q_OBJECTpublic:MyWidget(const MyWidget& other):obj1(other.obj1),obj2(other.obj2)private:some_class obj1;some...
构造函数与析构函数以及在QT中的使用（持续更新）
qq_43138346的博客
02-02 2038
1.构造函数在QT中定义类的时候自动执行。
构造函数和析构函数，以及拷贝构造，explicit关键字作用
A_ns_wer_的博客
03-03 318
构造函数 作用：初始化成员变量 无参构造： Maker() { a = 10; cout << "无参构造函数" << endl; } 有参构造 Maker(int A) { a = A; cout << "有参构造函数" << endl; } 析构函数 作用：在对象销毁前，编译器调用析构函数，为了避免内存泄露，一般系统会自动调用默认的析构函数，系统
c++ qt 学习路线
最新发布
05-25
如果你想学习C++和Qt，以下是一个适合初学者的学习路线： 1. 先学习C++基础知识，包括语法、变量、控制语句、函数、指针和数组等。可以参考一些经典的C++教材，比如《C++ Primer》和《Effective C++》等。 2. 掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值