C++ 面向对象基础-构造函数

于 2024-08-03 16:25:33 发布
阅读量277 收藏 8
点赞数 11
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67273669/article/details/140891144
版权

目录

1. 构造函数

1.1 基本使用

1.2 函数参数默认值

1.3 构造初始化列表

 1.4 隐式调用构造函数

2. 拷贝构造函数

2.1 概念

2.2 浅拷贝

2.3 深拷贝

3. 析构函数

1. 构造函数

1.1 基本使用

构造函数是一种特殊的成员函数，用于创建对象时初始化，写法上有以下要求：

● 函数名称必须与类名完全相同。

● 构造函数不写返回值

● 如果程序员不手动编写构造函数，编译器会自动添加一个默认无参的构造函数。

 

 

● 手动添加构造函数后，编译器就不会自动添加默认无参构造函数了。

● 构造函数在创建对象时，常用于给对象的属性赋予初始值。

● 构造函数也支持构造函数重载

● 也支持函数参数默认值

利用构造函数赋初值：

无参构造函数创建对象时：在构造函数内进行默认值进行初始化，

有参构造函数创建对象时，通过传入的参数进行初始化。 

#include <iostream>

using namespace std;

// 构造函数---
class MoblePhone1
{
private:
    string bread;
    string model;
    int weight = 200;

public:  // 权限：最开放的权限

    MoblePhone1() // 无参
    {
        bread = "8848";
        model = "鳄鱼皮";
        weight = 5500;
        cout << "无参构造函数被调用了" << endl;
    }

    MoblePhone1(string b,string m,int w)  // 有参
    {
        bread = b;
        model = m;
        weight = w;
        cout << "有参构造函数被调用了" << endl;

    }

    string get_bread()
    {
        return bread;
    }

    void set_bread(string b)
    {
        bread = b;
    }

    string get_model()
    {
        return model;
    }

    void set_model(string c)
    {
        model = c;
    }

    int get_weight()
    {
        return weight;
    }
};


int main()
{
    // 构造函数
    // 栈内存
    cout << "栈内存，无参" << endl;
    MoblePhone1 mp3;  // 无参
    cout << mp3.get_bread() << endl;
    cout << mp3.get_model() << endl;
    cout << mp3.get_weight() << endl;
    cout << endl;

    cout << "栈内存，有参" << endl;
    MoblePhone1 mp4("小米","14Pro", 500);  // 有参
    cout << mp4.get_bread() << endl;
    cout << mp4.get_model() << endl;
    cout << mp4.get_weight() << endl;
    cout << endl;

    // 堆内存
    cout << "堆内存，无参" << endl;
    MoblePhone1 *mp5 = new MoblePhone1;  // 无参
    cout << mp5->get_bread() << endl;
    cout << mp5->get_model() << endl;
    cout << mp5->get_weight() << endl;
    cout << endl;

    cout << "堆内存，有参" << endl;
    MoblePhone1 *mp6 = new MoblePhone1("红米","70ulurt",500);  // 有参
    cout << mp6->get_bread() << endl;
    cout << mp6->get_model() << endl;
    cout << mp6->get_weight() << endl;
    cout << endl;


    return 0;
}

1.2 函数参数默认值

函数参数默认值，从一个添加默认值的变量开始，后边的变量都要添加默认值。

比如 MoblePhone2(string b ,string m = "13Pro",int w = 200)  // 有参，string m 赋予了默认值，那么后面的int w也必须赋予默认值。

无参函数与全部参数都加默认值的函数，调用时候写法一样，不能同时存在。因为编译器无法区分。

#include <iostream>

using namespace std;

// 构造函数---函数默认值
class MoblePhone2
{
private:
    string bread;
    string model;
    int weight = 200;

public:  // 权限：最开放的权限
    // 无参函数与全部参数都加默认值的函数，调用时候写法一样；
    // 不能同时存在。因为编译器无法区分
    MoblePhone2() // 无参
    {
        bread = "8848";
        model = "鳄鱼皮";
        weight = 5500;
        cout << "无参构造函数被调用了" << endl;
    }
    //    MoblePhone2(string b = "8848",string m = "鳄鱼皮",int w = 5500)  // 有参
    //    {
    //        bread = b;
    //        model = m;
    //        weight = w;
    //    }

    MoblePhone2(string b ,string m = "13Pro",int w = 200)  // 有参
    {
        bread = b;
        model = m;
        weight = w;
        cout << "默认参数构造函数被调用了" << endl;
    }


    string get_bread()
    {
        return bread;
    }

    void set_bread(string b)
    {
        bread = b;
    }

    string get_model()
    {
        return model;
    }

    void set_model(string c)
    {
        model = c;
    }

    int get_weight()
    {
        return weight;
    }
};


int main()
{
    // 函数默认值
    MoblePhone2 mp7;
    cout << mp7.get_bread() << endl;
    cout << mp7.get_model() << endl;
    cout << mp7.get_weight() << endl;
    cout << endl;

    MoblePhone2 mp8("小米");
    cout << mp8.get_bread() << endl;
    cout << mp8.get_model() << endl;
    cout << mp8.get_weight() << endl;
    cout << endl;

    return 0;
}

 

1.3 构造初始化列表

构造初始化列表是一种更简单的给成员变量赋予初始值的写法。

当构造函数的局部变量与成员变量重名时，除了this指针的方式外，也可以使用构造初始化列表进行区分。

如果成员函数的形参名字与成员变量的名字一样，那么在赋值时就会出现类似 a = a 的情况，这时候编译器会分不清形参与成员变量，这时候可以用初始化列表进行区分。

利用构造初始化列表进行初始化赋值：

#include <iostream>

using namespace std;

// 构造初始化列表
class MoblePhone3
{
private:
    string bread;
    string model;
    int weight = 200;

public:  // 权限：最开放的权限

    MoblePhone3(string b,string m,int w)  // 有参
        :bread(b),model(m),weight(w)
    {
        cout << "构造初始化列表" << endl;
    }

    string get_bread()
    {
        return bread;
    }

    void set_bread(string b)
    {
        bread = b;
    }

    string get_model()
    {
        return model;
    }

    void set_model(string c)
    {
        model = c;
    }

    int get_weight()
    {
        return weight;
    }
};

int main()
{
    // 构造初始化列表
    MoblePhone3 mp9("小米","14Pro",500);
    cout << mp9.get_bread() << endl;
    cout << mp9.get_model() << endl;
    cout << mp9.get_weight() << endl;
    cout << endl;

    return 0;
}

 

 1.4 隐式调用构造函数

构造函数的调用可以分为显式调用和隐式调用。

显式调用指的是在创建对象的时候手写构造函数的名称和参数列表。

隐式调用指的是在创建对象时不写构造函数的参数列表，编译器会尝试调用对应参数的构造函数。

隐式调用实例：

Student s1(13);  // 显式调用  

Student s2 = Student(14);  // 显式调用

像以上显式调用可以直接根据传入的参数来判断调用构造函数，并且直接进行性对应成员变量的初始化赋值。

Student s3 = 15;  // 隐式调用

以上隐式调用，编译器需要先自行判断进行初始化赋值的成员变量。

#include <iostream>

using namespace std;

// 隐是调用
class Student
{
private:
    int age;

public:
    // 隐式调用
    Student(int a)
        :age(a)
    {
        cout << "构造函数" << endl;
    }

    explicit Student(int a,int b) // 屏蔽隐式调用
        :age(a)
    {
        cout << "构造函数" << endl;
    }

    int get_age()
    {
        return age;
    }

};


int main()
{
    //隐式调用构造函数
    Student s1(13);  // 显式调用
    cout << s1.get_age() <<endl;
    cout << endl;

    Student s2 = Student(14);  // 显式调用
    cout << s2.get_age() << endl;
    cout << endl;

    Student s3 = 15;  // 隐式调用
    cout << s3.get_age() << endl;
    cout << endl;

    Student *s4 = new Student(16);
    cout << s4->get_age() << endl;
    cout << endl;

    return 0;
}

建议使用显式调用，可以使用 explicit 关键字屏蔽隐式调用语法。

2. 拷贝构造函数

2.1 概念

当用一个对象给另一个对象进行二次赋值时，就需要用到拷贝构造函数。

当程序员不手写拷贝构造函数时，编译器会自动添加一个拷贝构造函数，使对象的创建可以通过这个构造函数实现。

利用拷贝及构造函数进行赋值实例：

用对象s1 给对象 s2 进行赋值，会调用自己定义的构造函数 Student1(const Student1 &st) 。

#include <iostream>

using namespace std;

// 拷贝构造函数
class Student1
{
private:
    int age;

public:

    Student1(int a)
        :age(a)
    {
        cout << "构造函数" << endl;
    }

    // 拷贝构造函数
    Student1(const Student1 &st)
    {
        age = st.age;
        cout << "调用了拷贝构造函数" << endl;
    }

    int get_age()
    {
        return age;
    }

};

int main()
{
    //拷贝构造函数
    Student1 st1(12);
    Student1 st2(st1);
    cout << "st1.get_age:" << " " << st1.get_age() << endl;
    cout << "st2.get_age:" << " " << st2.get_age() << endl;

    return 0;
}

 

2.2 浅拷贝

【思考】：拷贝构造函数会存在隐患吗？

存在，当成员变量存在指针类型时，默认的拷贝构造函数会导致两个对象的成员变量指向同一处，不符合面向对象的设计规范，这种现象被称为“浅拷贝”。

// 浅拷贝更改外部内存，当对任意一个对象进行操作时，因为几个拷贝的对象是指向同一个空间，所以几个对象内部的数据也被更改了， 因为操作的都是同一块内存 。

浅拷贝实例：

刚开始对象d1初始化赋值为 “旺财”，将通过拷贝及构造函数，用d1 给d2进行赋值，然后对d2进行修改，会发现对象d1的成员变量的值跟对象d2成员变量的值都发生了改变。

#include <iostream>
#include <string.h>

using namespace std;

// 浅拷贝
class Dog
{
private:
    char *name;

public:
    Dog(char *n)
    {
        name = n;
    }

    void show_dog()
    {
          cout << name << endl;
    }

};


int main()
{
    // 浅拷贝
    char dog[32] = "旺财";
    Dog d1(dog);  // 赋值
    Dog d2(d1);   // 调用拷贝构造函数

    cout << "修改前" << endl;
    d1.show_dog(); // 旺财
    d2.show_dog(); // 旺财
    cout << endl;
    cout << "修改后" << endl;

    strcpy(dog,"大黄");
    d1.show_dog(); // 大黄
    d2.show_dog(); // 大黄
    cout << endl;

    return 0;
}

2.3 深拷贝

如果要解决浅拷贝存在的问题，就必须在拷贝时开辟一块新的空间，这种情况必须手动重写构造函数，使每次赋值都创建一个新的副本，从而每个对象单独持有自己的成员变量。这种方式被称为“深拷贝”。

【思考】深拷贝的代码是否存在隐患？

存在，new开辟的空间没有释放，造成内存泄漏的问题。

 深拷贝实例：

用dog数组给对象d3 和 d4进行赋值，因为采用的是深拷贝，当arr改变之后，对d3 和d4的成员变量没有影响，依旧是旺财。

#include <iostream>
#include <string.h>

using namespace std;

// 深拷贝
class Dog2
{
private:
    char *name;

public:
    Dog2(char *n)
    {
        name = new char[32];
        strcpy(name,n);
    }

    Dog2(const Dog2 &d)
    {
        name = new char[32];
        strcpy(name,d.name);
    }

    void show_dog()
    {
        cout << name << endl;
    }

};


int main()
{
    // 深拷贝
    char dog2[32] = "旺财";
    Dog2 d3(dog2);  // 赋值
    Dog2 d4(d3);    // 调用拷贝构造函数

    cout << "修改前" << endl;
    d3.show_dog(); // 旺财
    d4.show_dog(); // 旺财
    cout << endl;

    cout << "修改后" << endl;
    strcpy(dog2,"大黄");
    d3.show_dog(); // 旺财
    d4.show_dog(); // 旺财
    cout << endl;

    return 0;
}

 

3. 析构函数

析构函数是与构造函数对立的函数。

delete 销毁数组时，需要添加 []

构造函数

析构函数

创建对象时手动调用

当对象销毁时，自动调用

函数名称是 类名

函数名称是 ~类名

构造函数可以重载

析构函数没有参数，不能重载

用于创建对象时并初始化

用于销毁对象时释放资源

有返回值但是不写，返回值是新创建的对象

没有返回值

 

// 析构函数
~Dog()
{
cout <<"我被调用了"<< endl;
delete []name;// []表示销毁数组
}

申屠武
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 面向对象 - 构造函数与析构函数
Junds0的博客
03-28 1848
第1关：构造函数 —— 学生信息类 本关任务：设计一个带有构造函数和析构函数的学生类。 #include<iostream> #include<string> using namespace std; class Student { /********* Begin *********/ //在此处声明所需的成员 private: int ID; string Name; public: Student(int sid,string name); Stu
头歌--C++ 面向对象 - 构造函数与析构函数
m0_56638814的博客
04-12 2432
头歌--C++ 面向对象 - 构造函数与析构函数
C++面向对象程序设计 - 构造函数
觉醒法师的专栏
04-02 1156
C++提供了构造函数来处理对象的初始化，构造函数是一种特殊的成员函数，与其他成员函数不同，它不需要用户来调用，而是在建立对象时自动执行。构造函数名称必须与类同名，而不能由用户任意命名，以便编译系统能识别它把它作为构造函数处理。它不具体任何类型，也不返回任何值。构造函数的功能由用户定义，可根据初始化的要求设计函数体和函数参数。而且如果用户未定义构造函数，C++系统会自动生成一个构造函数，只是这个构造函数体是空的。
头歌：C++ 面向对象 - 构造函数与析构函数
qq_65628600的博客
05-22 5817
第一题： #include<iostream> #include<string> using namespace std; class Student { public: int SID; string Name; Student();//无参的构造函数：Student()，在函数中将学号初始化为0，姓名初始化为王小明 Student(int sid,string name); ~Student(
C++面向对象-2-类的构造函数和析构函数
Anthony_tester的博客
01-11 1055
上一篇学习了C++中的类定义，用了两个练习题来演示一个class的属性和行为的定义和调用，以及展开了权限控制和一个类的属性还可以是其他类的一个实例。其中有好多代码是set和get, 写多了有时候很烦，当然写set和get方法是一个好习惯。例如Point，我们需要setX和setY, 有没有一个方法直接SetPoint(X,Y)呢， 这个就本篇要学习的类的构造函数。 区别：struct vs...
C++面向对象程序设计——构造函数
m0_54587903的博客
08-30 1372
一、问题引入：数据成员初始化 对数据成员进行初始化 方法1： ClassTime {public： Hour; Minute; Sec; }; Time T1={14,56,30}; 这种初始化方法仅用于对象的成员均为public的情况。如果数据成员是私有的，或者类中有private或protected的数据成员就不能用这种方法进行初始化 方法2： 用成员函数对对象中的数据成员赋初值。 二、构造函数概述 构造函数的定义 不需要用户来调用他；，而是在建立对...
【Educoder作业】C++ 面向对象 - 构造函数与析构函数
JZYshuraK的博客
01-02 968
这个感觉没啥需要说的，就是一类特殊的函数。有的时候题目报错的话，可以看看是不是没写构造函数。
C/C++基础 -- 构造函数 constructor
不世峰兄 的博客
10-15 1732
C/C++基础 -- 构造函数 constructor1、什么是构造函数2、构造函数的定义2.1、定义构造函数2.2、关于构造函数的说明2.3、构造函数初始化列表3、构造函数的重载4、带默认参数的构造函数关于构造函数默认参数的说明 本博文由 西北工业大学MOOC 总结而来，以备以后回顾。（侵删） 1、什么是构造函数   我们在建立一个对象时，通常需要立即对这个对象进行初始化，如对数据成员的赋值...
C++面向对象-5-类的构造函数调用规则
Anthony_tester的博客
01-12 1921
继续来学习构造函数的知识，通过前面学习，我们知道一个类中可以有 无参构造，有参构造，拷贝构造，那么编译器是如何决定调用这些构造函数，本篇就来学习这个调用规则。 知识点： 默认情况下，C++编译器至少给一个类添加3个函数 1.默认构造函数（无参，函数体为空） 2.默认析构函数（无参，函数体为空） 3.默认拷贝构造函数，对属性进行值拷贝 构造函数的调用规则如下： 如果用户定义有参构造函数，c++...
头歌（Educoder）——程序设计基础——第4章 面向对象 - 构造函数与析构函数
weixin_60732009的博客
05-18 820
第1关：构造函数 —— 学生信息类 第2关：对象数组 —— 学生信息表 第3关：静态成员 —— 模拟共享书店
面向对象作业1-构造函数+运算符重载.docx
07-06
综上所述，这个练习涵盖了面向对象编程的基础概念，包括类的设计、构造函数、运算符重载、友元函数以及C++标准库的应用等重要知识点。通过这个实践项目，学生不仅可以巩固面向对象编程的基本原理，还能提高解决实际...
面向对象-构造函数-调用&内存图解
05-12
当我们谈论“面向对象-构造函数-调用&内存图解”时，我们将深入探讨构造函数的工作原理以及它们如何影响内存分配。 首先，让我们理解什么是构造函数。在Java、C++或Python等面向对象的语言中，构造函数是一个与类...
C++面向对象1-11.zip
05-22
《C++面向对象编程深度解析》 C++是一种强大的、高度灵活的编程语言，尤其以其面向对象特性著称。在"C++面向对象1-11.zip"这个压缩包中，包含了一系列关于C++面向对象编程的重要主题，让我们逐一探讨。 1. **基本...
C++面向对象多线程编程-pdf
09-12
在"C++面向对象多线程编程"这一主题中，我们将深入探讨以下几个关键知识点： 1. 面向对象编程（OOP）基础： - 类与对象：类是对象的蓝图，定义了一组属性（数据成员）和行为（成员函数）。对象是类的实例，具有...
c++基础语法:构造函数与析构函数
09-05
C++是一种强大的面向对象编程语言，其核心特性之一就是类和对象的概念。在这个主题中，我们将深入探讨构造函数和析构函数，这是C++中两个关键的生命周期管理工具。 构造函数是C++类的一个特殊成员函数，它的主要...
【C++】输入输出
最新发布
2401_83948390的博客
08-02 271
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
【2024蓝桥杯/C++/B组/传送阵】
m0_73669127的博客
07-30 366
【代码】2024蓝桥杯/C++/B组/传送阵。
第六章 - c语言中的数组-二维数组（下）
百知_zmj的博客
08-02 155
二维数组案例：杨辉三角形。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 482
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
c++ 面向对象 - 构造函数与析构函数
06-28
### 回答1： C++面向对象编程中，构造函数和析构函数是两个非常重要的概念。 构造函数是一种特殊的函数，它在对象被创建时自动调用，用于初始化对象的数据成员。构造函数的名称与类名相同，没有返回值类型，可以有参数，可以有多个构造函数，以便在创建对象时进行不同的初始化操作。 析构函数是一种特殊的函数，它在对象被销毁时自动调用，用于清理对象的资源。析构函数的名称与类名相同，前面加上一个波浪号(~)，没有返回值类型，不接受任何参数。 构造函数和析构函数是C++面向对象编程中的两个重要概念，它们的作用是初始化对象和清理对象的资源，是面向对象编程的基础。 ### 回答2： 面向对象是一种程序设计的方法，它以对象为中心，通过封装、继承和多态等机制来组织和管理代码，使程序更加可靠、可重用和易于维护。其中，构造函数和析构函数是面向对象程序设计中的重要概念。 构造函数是一种特殊的成员函数，它在对象创建时自动被调用，用于对对象进行初始化。构造函数的名称与类名相同，没有返回值，可以重载，可以带参数，也可以不带参数。构造函数的作用是保证对象在创建时始终处于一种可靠的状态，从而避免程序运行时的错误和异常。 析构函数是与构造函数相对应的一种成员函数，它在对象销毁时自动被调用，用于对对象进行善后处理。析构函数的名称与类名相同，前面加上一个波浪号（~），没有参数，也没有返回值。析构函数的作用是释放对象所占用的资源，例如动态分配的内存、打开的文件、建立的连接等，在对象销毁之前要确保这些资源已经被回收，从而避免内存泄漏和资源浪费。 构造函数和析构函数是面向对象程序设计中的重要组成部分，它们体现了对象的生命周期和和管理方式，尤其是在涉及到动态内存分配和释放时更为重要。正确使用构造函数和析构函数可以提高程序的可靠性、可重用性和可维护性，从而更好地实现程序模块化和复用。因此，在面向对象程序设计中，构造函数和析构函数应该被视为重要的设计关注点，特别是在涉及到大型程序或长期运行的系统时。 ### 回答3： 面向对象编程是一种广泛使用的编程范式，它关注的是对象的行为和属性，而不是函数和逻辑。构造函数和析构函数是面向对象编程中的两个重要概念，在类的实例化和释放过程中起到了关键的作用。 构造函数是一个类的特殊函数，它习惯性地与类名相同，用于初始化类的实例。构造函数可以接收参数，这些参数可以用来初始化类的成员变量。每当一个新的对象被创建时，构造函数会自动调用，以确保对象被正确地初始化。如果类没有定义构造函数，编译器将提供一个默认构造函数。 析构函数是一个类的另一个重要函数，它也习惯性地与类名相同，用于释放由该类创建的资源。析构函数通常用于释放内存、关闭打开的文件、关闭网络连接等等，以防止资源泄漏和造成程序崩溃。当一个对象被删除或销毁时，析构函数会自动调用，以确保类能够正确地清理资源。 需要注意的是，当一个对象被复制时，也会调用构造函数和析构函数。使用深拷贝和浅拷贝来管理类的复制，以确保不会复制对象的私有数据。此外，有一些 C++ 特殊语法，如移动语义和智能指针等等，可以用于提高构造函数和析构函数的效率和安全性。 总之，构造函数和析构函数是面向对象编程中不可或缺的两个概念。它们可以保证类的正确初始化和释放，从而防止资源泄漏和程序崩溃。编写好构造函数和析构函数是编写高质量 C++ 代码的关键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值