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

最新推荐文章于 2024-07-02 21:33:53 发布
最新推荐文章于 2024-07-02 21:33:53 发布
阅读量502 收藏 8
点赞数 11
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74937538/article/details/135315908
版权

1、构造函数

1.1 基本使用

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

  • 函数名必须与类名完全相同
  • 构造函数不写返回值
  • 如果程序员不手动编写构造函数，编译器就会自动添加一个无参的构造函数

手动添加构造函数，编译器就不会自动添加构造函数。

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

#include <iostream>

using namespace std;

// 帕斯卡命名法（大驼峰命名法）
// 每个单词首字母大写
class MobilePhone
{
private: // 私有权限，最封闭的权限，只能在类内访问
    string brand;   // 品牌
    string modle;   // 型号
    int weight;     // 重量

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

    MobilePhone() // 默认构造函数
    {
        brand = "8848";
        modle = "M6 巅峰版";
        weight = 500;
    }
    // 品牌的get函数
    string get_brand()
    {
        return brand;
    }
    // 型号的get函数
    string get_modle()
    {
        return modle;
    }
    // 重量的get函数
    int get_weight()
    {
        return weight;
    }
    // 品牌的set函数
    void set_brand(string b)
    {
        brand = b;
    }
};
int main()
{
    // 栈内存对象
    MobilePhone mp1;
    cout << mp1.get_brand() << endl;
    cout << mp1.get_modle() << endl;
    cout << mp1.get_weight() << endl;
    return 0;
}

    • 构造函数也支持函数重载和函数参数默认值

#include <iostream>
using namespace std;
// 帕斯卡命名法（大驼峰命名法）
// 每个单词首字母大写
class MobilePhone
{
private: // 私有权限，最封闭的权限，只能在类内访问
    string brand;   // 品牌
    string modle;   // 型号
    int weight;     // 重量
public: // 权限：public是最开放的权限。
    MobilePhone() // 默认构造函数
    {
        brand = "8848";
        modle = "M6 巅峰版";
        weight = 500;
    }
    // 有参构造函数（函数重载）
    MobilePhone(string b,string m,int w)
    {
        brand = b;
        modle = m;
        weight = w;
    }
    // 品牌的get函数
    string get_brand()
    {
        return brand;
    }

    // 型号的get函数
    string get_modle()
    {
        return modle;
    }

    // 重量的get函数
    int get_weight()
    {
        return weight;
    }
    // 品牌的set函数
    void set_brand(string b)
    {
        brand = b;
    }
};
int main()
{
    // 栈内存对象
    MobilePhone mp1("vivo","iqoo12",300);
    cout << mp1.get_brand() << endl;
    cout << mp1.get_modle() << endl;
    cout << mp1.get_weight() << endl;
    return 0;
}

在创建对象的时候，必须调用任意构造函数。

    • 函数参数默认值（全缺省默认构造函数）
  • 缺省部分往前写

#include <iostream>
using namespace std;
// 帕斯卡命名法（大驼峰命名法）
// 每个单词首字母大写
class MobilePhone
{
private: // 私有权限，最封闭的权限，只能在类内访问
    string brand;   // 品牌
    string modle;   // 型号
    int weight;     // 重量
public: // 权限：public是最开放的权限。
    MobilePhone() // 默认构造函数
    {
        brand = "8848";
        modle = "M6 巅峰版";
        weight = 500;
    }
    // 有参构造函数
    MobilePhone(string b,string m,int w)
    {
        brand = b;
        modle = m;
        weight = w;
    }
    MobilePhone(int w,string b = "oppo",string m = "findx")
    {
        brand = b;
        modle = m;
        weight = w;
    }
    // 品牌的get函数
    string get_brand()
    {
        return brand;
    }

    // 型号的get函数
    string get_modle()
    {
        return modle;
    }

    // 重量的get函数
    int get_weight()
    {
        return weight;
    }

    // 品牌的set函数
    void set_brand(string b)
    {
        brand = b;
    }
};


int main()
{
    // 栈内存对象
    MobilePhone mp1;
    cout << mp1.get_brand() << endl;
    cout << mp1.get_modle() << endl;
    cout << mp1.get_weight() << endl;

    MobilePhone *mp2 = new MobilePhone();

    return 0;
}

1.2 构造初始化列表

构造初始化列表是一种更简单的给成员变量赋予初始值的写法。传参遵寻就近原则。

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

#include <iostream>
using namespace std;
// 帕斯卡命名法（大驼峰命名法）
// 每个单词首字母大写
class MobilePhone
{
private: // 私有权限，最封闭的权限，只能在类内访问
    string brand;   // 品牌
    string modle;   // 型号
    int weight;     // 重量
public: // 权限：public是最开放的权限。
    // 构造初始化列表：编译器成员变量与局部变量可以做区分
    MobilePhone()://直接赋值，成员变量已经创建。
        brand("8848"),modle("M6 巅峰版"),weight(500){}
    MobilePhone(string brand,string modle,int weight)://默认传参
        brand(brand),modle(modle),weight(weight){}
            //对象创造之前被调用，还没有创造对象，成员变量已经创建。不能放到函数体内，函数无法识别局部变量与成员变量
    // 品牌的get函数
    string get_brand()
    {
        return brand;
    }
    // 型号的get函数
    string get_modle()
    {
        return modle;
    }
    // 重量的get函数
    int get_weight()
    {
        return weight;
    }
};
int main()
{
    // 栈内存对象
    MobilePhone mp1;
    cout << mp1.get_brand() << endl;
    cout << mp1.get_modle() << endl;
    cout << mp1.get_weight() << endl;

    MobilePhone *mp2 = new MobilePhone("三星","note7",100);
    cout << mp2->get_brand() << endl;
    cout << mp2->get_modle() << endl;
    cout << mp2->get_weight() << endl;

    delete mp2;
    mp2 = NULL;
    return 0;
}

1.3 隐式调用构造函数

截至到目前为止，对于构造函数的调用都是显式调用的。

#include <iostream>

using namespace std;

class Test
{
private:
    int val;
public:
    Test(int v,int i,string str,double d)
    {
        val = v;
        cout << "构造函数" << endl;
    }

    int get_val()
    {
        cout << &val << endl;
        return val;
    }

};

int main()
{
//    Test t1(2);  // 显式调用构造函数
//    cout << t1.get_val() << endl;
    Test t2 = {123,2,"string",2.4}; // 隐式调用构造函数，多参数传递C++11支持
    cout << t2.get_val() << endl;

    return 0;
}

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

1.4 拷贝构造函数

1.4.1 概念

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

#include <iostream>

using namespace std;

class Test
{
private:
    int val;
public:
    Test(int v)
    {
        val = v;
        cout << "构造函数" << endl;
    }
    // 手动添加默认的拷贝构造函数
    Test(Test &t)
    {
        val = t.val;
    }

    int get_val()
    {
        return val;
    }

};

int main()
{
    Test t1(4);
    cout << t1.get_val() << endl;

    Test t2(t1); // 调用拷贝构造函数
    cout << t2.get_val() << endl;

    return 0;
}

没有任何构造函数的时候：编译器会给我们创建一个默认构造函数、拷贝构造函数。

如果我们有一个默认构造函数，编译器不会创建默认构造函数，会创建拷贝构造函数。

如果我们有一个有参构造函数，编译器不会创建默认构造函数，会创建拷贝构造函数。

如果我们有一个拷贝构造函数，编译器不会创建默认构造函数，不会创建拷贝构造函数。

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

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

1.4.2 浅拷贝

存在的问题：更改一处三处都会改变

#include <iostream>
#include <string.h>
using namespace std;
class Dog
{
private:
    char *name;
public:
    Dog(char *n)
    {
        name = n;
    }
    void show_name()
    {
        cout << name << endl;
    }
};
int main()
{
    char arr[20] = "旺财";
    Dog d1(arr);
    Dog d2(d1); // 调用的是拷贝构造函数，不调用构造函数
    strcpy(arr,"大黄");//两个都会改变
    d1.show_name(); // 大黄
    d2.show_name(); // 大黄
    return 0;
}

这种情况必须要手写构造函数，使每次赋值都创建一个新的副本，从而每个对象单独持有自己的成员变量，这种方式被称为“深拷贝”。

1.4.3 深拷贝

new开辟的空间无法释放，造成内存泄漏的问题。

#include <iostream>
#include <string.h>
using namespace std;
class Dog
{
private:
    char *name;
public:
    Dog(char *n)
    {
        name = new char[20];
        strcpy(name,n);
    }
    Dog(Dog &d)
    {
       name = new char[20];
       strcpy(name,d.name);
    }
    void show_name()
    {
        cout << name << endl;
    }
};
int main()
{
    char arr[20] = "旺财";
    Dog d1(arr);
    Dog d2(d1); // 拷贝构造函数

    strcpy(arr,"大黄");

    d1.show_name(); // 旺财
    d2.show_name(); // 旺财

    return 0;
}



#include <iostream>
#include <string.h>
using namespace std;

class Dog
{
private:
    char *name;
public:
    // 构造函数，初始化对象的name成员变量
    Dog(char *n)
    {
        name = n; // 将传入的指针赋值给name，这会导致问题后面会解释
    }
    // 拷贝构造函数，用于创建一个新的对象并复制已有对象的数据
    Dog(Dog &d)
    {
        name = new char[20]; // 为name分配内存空间
        strcpy(name, d.name); // 复制参数对象的name值到当前对象的name
    }
    // 打印狗的名字
    void show_name()
    {
        cout << name << endl;
    }
};

int main()
{
    char arr[20] = "旺财"; // 创建一个字符数组，并存储字符串"旺财"
    Dog d1(arr); // 创建一个Dog对象d1，传入arr作为参数
    
    Dog d2(d1); // 使用拷贝构造函数，创建一个新的Dog对象d2，复制d1的数据
    
    strcpy(arr, "大黄"); // 修改arr中的字符串为"大黄"
    
    d1.show_name(); // 输出：旺财，因为d1的构造函数只是将name指针指向arr的地址，所以修改arr后，d1的name也改变了
    
    d2.show_name(); // 输出：旺财，因为拷贝构造函数在创建d2时复制了d1的name，所以不受arr的修改影响
    
    return 0;
}

  1. 创建有参构造函数，编译器不会创建无参构造函数，会创建拷贝构造函数。
  2. 创建无参构造函数，编译器不会创建无参构造函数，会创建拷贝构造函数。
  3. 创建拷贝构造函数，编译器不会创建无参构造函数，不会创建拷贝构造函数。

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

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

满山的猴子我的腚最红
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
面向对象之构造函数
你是时光轻轻呵唱的博客
06-04 482
本文首发于个人博客:www.wyb.plus 1. 构造函数基本概念 1.1 什么是构造函数 构造函数就是用来创造新对象的(函数,数组,正则表达式,日期等都是对象) 它必须用过关键字NEW来创造 如果将构造函数用作普通函数的话,往往不会正常工作的 按照一惯的约定, 我们开发者把构造函数的首字母大写用作辨别 一个构造函数创造的对象被称为该构造函数的实例 1.2 常见构造函数 Object() Array() RegExp() Function() Date() 1.3 判断 判断该变量的数据
C++之面向对象、构造函数、析构函数
YiHeboy的博客
07-28 476
C++之面向对象、构造函数、析构函数
【深入浅出C#】章节 4: 面向对象编程基础：构造函数和析构函数
喵叔
06-25 1466
构造函数是一个特殊的成员函数，用于在创建对象时进行初始化操作。它具有与类同名的特点，没有返回类型，并且可以包含参数。访问修饰符 类名([ 参数列表 ]) {// 构造函数的实现代码 }其中，访问修饰符可以是 public、private、protected 或 internal，用于控制构造函数的访问权限。类名与构造函数同名，参数列表是可选的，用于传递参数给构造函数。构造函数可以重载，即在同一个类中定义多个具有不同参数的构造函数，以便根据不同的参数列表来创建对象。
面向对象总结—构造函数
m0_51694071的博客
11-05 271
this指针： 在谈构造函数之前，有这样两个问题： 1.this指针存在哪里？ 2.this指针可以为空吗？ 问题1：this 指针是形参，形参和函数中局部变量都是存在函数栈帧里面的，所以this指针可以认为是存在栈的；vs为了提高效率，this指针是通过寄存器ecx传递的。 问题2: 成员函数的地址不在对象中存储，存在公共代码段；这里调用成员函数，不会去访问p指向的空间，也就不存在空指针解引用了，这里会把p传递给隐含的this指针，但是Show函数也没有解引用this指针。 底层并没有对空指针引用；
11 面向对象
Bei_Chen的博客
12-03 259
面向过程的结构化程序设计方法 自顶向下、逐步求精。采用模块分解与功能抽象，自顶向下、分而治之。 程序的模块是由函数构成的。 程序=数据结构+算法 可重用性差 面向对象的方法 将数据及对数据的操作方法封装在一起，作为一个相互依存、不可分离的整体——对象。对同类型对象抽象出其共性，形成类。对象与对象之间通过消息进行通讯。 程序的模块是由类构成的。 程序＝对象＋消息 对象＝算法＋数据结构 特点：封装性、继承性、多态性 面向对象程序设计-类与对象.ppt 1本章主要内容 [外链图片转存失败,源站可能有防盗链机制,建
C++ 构造函数详解
热门推荐
a1367666195的博客
10-16 1万+
在定义类的成员函数的时候，一般的成员函数与普通的全局函数没有太大的区别，在定义函数的时候都需要说明要返回的类型，但是，类中有一种函数比较特殊，函数名与类名相同，且没有返回值类型，这中函数称为构造函数，它承担着类初始化的工作，非常重要。常用的构造函数有默认构造函数、一般构造函数、拷贝构造函数、转换构造函数、移动构造函数。
C++中构造函数的超详细讲解
guishangppy的博客
07-25 9330
详细讲解C++种的构造函数
C++面向对象基础
m0_75156557的博客
01-10 88
面向对象的编程语言，关注重点是“对象”，可以认为“对象”的本质是一系列由于某种联系聚焦在一起数据单元体。不同单元体之间进行数据交互，从而实现代码运行的结果，程序员只需要站在更高层次去管理这些单元体，这种思考方式更接近人类的思考方式。优点是程序的开发效率高；缺点是执行效率低。1. 类与对象的概念类：类是对同一类对象的抽象总结，是一个概念。对象：按照类的规定创建的实体。一个类主要包括：● 属性。
面向对象作业1-构造函数+运算符重载.docx
最新发布
07-06
自定义一个时间类，有两种构造方法：给三个数值或给一个字符串。 要求可以使用cout输出该对象。两个对象可以相差，得到两个时间的间隔秒数（正数）。 假设主程序main及运行结果如下： int main() { MyTime t1(12,30...
面向对象-构造函数-调用&内存图解
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）基础： - 类与对象：类是对象的蓝图，定义了一组属性（数据成员）和行为（成员函数）。对象是类的实例，具有...
面向对象的程序设计-个人复习笔记
10-26
在C++编程语言中，面向对象编程是一种核心概念，它基于类和对象的概念，使得代码更加模块化和易于管理。...通过阅读和理解这些笔记，可以巩固对C++面向对象编程的理解，为解决实际问题打下坚实基础。
【JavaScript】面向对象——构造函数（详解）
qq_49002903的博客
06-01 1576
文章目录理解并上手使用javascript中的构造函数1、我们先理解什么是构造函数？2、JavaScript中的构造函数是怎么样的？3、使用new操作符会发生什么？4、构造函数的属性5、构造函数与函数的区别 理解并上手使用javascript中的构造函数 1、我们先理解什么是构造函数？ 构造函数也称之为构造器，通常是我们在创建对象时会调用的函数； 在其他面向对象的编程语言里面，构造函数是是存在于类中的一个方法，称之为构造函数； 但是在JavaScript中的构造函数有点不太一样； 2、JavaScrip
【C++】类和对象——构造函数
Ye_Ming_OUC的博客
08-16 1703
文章摘要：什么是构造函数、默认构造函数、初始化列表、通过构造函数进行隐式类型转换的条件、C++11变量初始化新玩法
C++学习之路—面向对象—构造函数
weixin_45452278的博客
01-21 932
C++面向对象之构造函数定义构造函数的用途使用构造函数有几点需要注意 定义 构造函数也叫构造器，在对象创建的时候自动调用，一般用于完成对象的初始化工作 下方示例中Person()就是类的构造函数 class Person { public: Person();//创建类时自动创建的构造函数，也可以手动添加，这个为构造函数的声明 ~Person();//虚构函数，后续文章会记录 int m_member; private: }; Person::Person()//构造函数的实现-无参数构造
C++面向对象程序设计——构造函数
m0_54587903的博客
08-30 1360
一、问题引入：数据成员初始化 对数据成员进行初始化 方法1： ClassTime {public： Hour; Minute; Sec; }; Time T1={14,56,30}; 这种初始化方法仅用于对象的成员均为public的情况。如果数据成员是私有的，或者类中有private或protected的数据成员就不能用这种方法进行初始化 方法2： 用成员函数对对象中的数据成员赋初值。 二、构造函数概述 构造函数的定义 不需要用户来调用他；，而是在建立对...
面向对象及构造函数
忘川的博客
08-10 404
面向对象：一种编程思想，用程序里面的对象来描述现实中的一个具体的事务 对象：封装了一个事务的属性和功能的程序结构 封装：将一个具体事务的属性和功能集中定义在一个对象中，事物的属性会成为对象的属性，事物的功能会成为对象的方法。 1、创建自定义对象（封装） 访问对象的属性： 输出结果为： 访问对象的方法： 输出结果为： 给对象中的属性赋值 输出结果为： ...
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 628
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
c++ 面向对象 - 构造函数与析构函数
06-28
C++面向对象编程中，构造函数和析构函数是两个非常重要的概念。 构造函数是一种特殊的函数...构造函数和析构函数是C++面向对象编程中的两个重要概念，它们的作用是初始化对象和清理对象的资源，是面向对象编程的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

满山的猴子我的腚最红

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值