C++----析构函数，拷贝构造函数（6）

已于 2023-06-16 12:14:02 修改
阅读量66 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-06-16 12:10:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46546201/article/details/131243516
版权

析构函数

概念

析构函数是一个特殊的函数，函数名和类名相同，但是要在前面加~，既没有参数，也没有返回值。析构函数在对象被销毁自动调用一次

如果类中没有析构函数，编译器会生成一个什么也不做的析构函数

如果类中有析构函数，编译器不再做该动作

如果类中有类类型成员，先析构自己，在析构成员(先构造的要后析构)

练习： 为mystring类实现析构函数和获取指定位置字符的成员函数

/*06-字符串类的拷贝构造函数*/
#include <iostream>
#include <cstring>

using namespace std;

class mystring{
public:
    //构造函数
    mystring(const char *s=NULL)
    {
        if(!s){//没有传参数
            this->len = 10;
            this->str = new char[this->len];
            memset(this->str,0,10);
        }
        else{
            this->len = strlen(s)+1;
            this->str = new char[this->len];
            strcpy(this->str,s);
        }
    }

    //拷贝构造函数
    mystring(const mystring &s)
    {
        this->len = s.len;
        this->str = new char[this->len];
        strcpy(this->str,s.str);
    }

    //析构函数
    ~mystring()
    {
        delete[] this->str;
    }

    //打印字符串
    void show()
    {
        cout<<this->str<<endl;
    }

    //获取空间大小
    size_t get_len()
    {
        return this->len;
    }

    //获取字符串长度
    size_t get_size()
    {
        return strlen(this->str);
    }

    //获取指定位置的字符
    char at(size_t n)
    {
        if(n>=this->len){//越界
            return -1;
        }

        return this->str[n];
    }

    //修改字符串内容 健壮性
    void modify_str(const char *s)
    {
        if(!s){//为空修改为长度为10的空串
            delete[] this->str;
            this->len = 10;
            this->str = new char[this->len];
            memset(this->str,0,10);
        }
        else{//非空
            if(this->len<strlen(s)+1){//空间不够
                //调整空间
                delete[] this->str;
                this->len = strlen(s)+1;
                this->str = new char[this->len];
            }
            strcpy(this->str,s);
        }
    }

private:
    char *str;//字符串内容首地址
    size_t len;//空间大小
};


int main()
{
    //mystring str1;
    mystring str1("welcome to GEC!");
    str1.show();

    mystring str2 = str1;
    str2.show();
    str1.modify_str("byebye");
    str1.show();
    str2.show();

    cout<<str1.get_size()<<endl;

    return 0;
}

拷贝构造函数

概念

拷贝构造函数是一个特殊的构造函数，使用一个已有对象去初始化一个新建对象时，调用拷贝构造函数。

//A是类类型
A a;//构造函数
A b = a;//拷贝构造函数
A c;
c = a;//不是拷贝构造

实现语法

class A{
public:
A(…){…}//构造函数
/拷贝构造/
A(const A &a){…}
};

拷贝构造函数调用的时机

使用已有的对象去初始化新对象

A a;
A b = a;//拷贝构造
把一个对象传递给本类型的形参
把一个对象作为函数的返回值(编译器会优化成传递构造)

什么情况需要重写拷贝构造函数

如果一个类没有拷贝构造函数，编译器会自动生成一个按逐字节拷贝的拷贝构造函数

如果希望自定义拷贝构造的过程可以重写拷贝构造函数，其实就是对象中存在独立的内存(资源)重写拷贝构造

默认的拷贝构造函数属于浅拷贝

为独立内存重新分配空间，并拷贝空间中的数据就叫深拷贝

拷贝构造是由一个旧对象初始的值去拷贝新对象的值

在这里插入图片描述

/*09-字符串类的静态函数*/
#include <iostream>
#include <cstring>

using namespace std;

class date {
public:


    date(int year = 2022, int month = 7, int day = 9) {
        this->year = year;
        this->month = month;
        this->day = day;
    }

    void show() {
        cout << "year  " << this->year << " month  " << this->month << " day " << day << endl;

    }

    date(const date &dt) {
        cout << "  date(const date &t)" << endl;
        this->year = dt.year;
        this->month = dt.month;
        this->day = dt.day;

    }

    ~date() {  //析构要跟类名相同
        cout << "~getdate" << endl;
    };

private:
    int year;
    int month;
    int day;
};


int main() {

    date dt1(2000, 11, 20);
    dt1.show();

    date dt2(0000, 0000, 00);
    dt2 = dt1;
    dt2.show();
    //析构函数会在函数结束后执行
    return 0;

}

练习：

为mystring类直线拷贝构造函数，并提供获取字符串长度(有效字符个数)的成员函数。

/*06-字符串类的拷贝构造函数*/
#include <iostream>
#include <cstring>

using namespace std;

class mystring{
public:
    //构造函数
    mystring(const char *s=NULL)
    {
        if(!s){//没有传参数
            this->len = 10;
            this->str = new char[this->len];
            memset(this->str,0,10);
        }
        else{
            this->len = strlen(s)+1;
            this->str = new char[this->len];
            strcpy(this->str,s);
        }
    }

    //拷贝构造函数
    mystring(const mystring &s)
    {
        this->len = s.len;
        this->str = new char[this->len];
        strcpy(this->str,s.str);
    }

    //析构函数
    ~mystring()
    {
        delete[] this->str;
    }

    //打印字符串
    void show()
    {
        cout<<this->str<<endl;
    }

    //获取空间大小
    size_t get_len()
    {
        return this->len;
    }

    //获取字符串长度
    size_t get_size()
    {
        return strlen(this->str);
    }

    //获取指定位置的字符
    char at(size_t n)
    {
        if(n>=this->len){//越界
            return -1;
        }

        return this->str[n];
    }

    //修改字符串内容 健壮性
    void modify_str(const char *s)
    {
        if(!s){//为空修改为长度为10的空串
            delete[] this->str;
            this->len = 10;
            this->str = new char[this->len];
            memset(this->str,0,10);
        }
        else{//非空
            if(this->len<strlen(s)+1){//空间不够
                //调整空间
                delete[] this->str;
                this->len = strlen(s)+1;
                this->str = new char[this->len];
            }
            strcpy(this->str,s);
        }
    }

private:
    char *str;//字符串内容首地址
    size_t len;//空间大小
};


int main()
{
    //mystring str1;
    mystring str1("welcome to GEC!");
    str1.show();

    mystring str2 = str1;
    str2.show();
    str1.modify_str("byebye");
    str1.show();
    str2.show();

    cout<<str1.get_size()<<endl;

    return 0;
}

类中的特殊成员

const对象和const成员

语法

class A{
public:
    A(int n=0,int m=0):num(n),num_1(m){}
    void show(){....}
    void show()const{....}//const成员函数

private:
    const int num;//const成员变量
    int num_1;            
};

A a;
const A b;//const对象

应用

1.const成员函数和同名的非const成员函数构成重载关系
非const对象优先调用非const函数，const对象只能调用const函数
2.const成员函数只能读取成员变量，不能修改成员变量
如果一定要修改，必须在声明该成员变量前加mutable修饰符
如果一个成员函数不会修改成员变量，就应该将其设计为const成员函数
3.const成员变量和const对象都不能修改

静态(static)成员

静态成员分为静态成员变量和静态成员函数，静态成员属于类，不属于某个对象。

静态成员变量

静态成员变量在成员变量声明前加static，必须初始化，而且应该在类外初始化，默认初始化为0，类类型的静态成员变量调用默认构造函数。

静态成员函数

静态成员变量在成员函数声明前加static，静态成员函数只能访问静态成员变量，不能访问普通成员变量。
语法：

class A{
public:
    static int num;//静态成员变量    
    static void show(){......}//静态成员函数
};

//类外初始化
int A::num = xxx;

//访问静态成员
类名::静态成员;

静态成员无需通过对象来访问，可以直接通过类名访问。实现的机制是静态成员存储在独立的内存中，不能在在静态成员函数中使用this指针。所有同类型的对象访问的是同一个静态成员。

练习：

为mystring类提供一个静态成员函数，该函数返回一个指定长度的存储字符串的空间(char *)。

/*07-const对象和const成员*/
#include <iostream>
#include <cstring>

using namespace std;

class mystring {

public:
    static char *getSpace(size_t t) {
        return new char[t];

    }

private:
    size_t len;
    char *s;

};

int main() {
    char *string1 = mystring::getSpace(10);
    strcpy(string1, "helloworld");
    cout << string1 << endl;
    cout << sizeof(string1) << endl; //8
    return 0;
}

友元

友元的作用就是让类外数据突破访问权限的限制，可以将 类/函数 声明为某个类的友元，友元类和友元函数可以访问类中的所有数据，不受访问权限的限制。

友元函数

友元函数是一个全局函数，在类内将函数声明为友元，这个全局函数就可以访问类中的所有数据，语法如下：

在类内部声明：
friend 函数声明;

友元类

有一个类A，在类A中将类B声明为友元，类B就可以访问类A中的所有数据，语法如下：

在类的内部声明：
    friend class 友元类名;

注意：友元不受访问权限的限制，可以访问类中的所有数据，破坏了类的封装属性，如非必要，不要使用。

作业：

实现以下类的构造函数(默认构造长度为10，值为0的数组)，析构函数和拷贝构造函数

class MyArray{
public:

private:
    int *pdata;//数组首地址
    size_t len;//数组元素个数        
};
「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++-构造函数与析构函数
Asincereman的专栏
01-04 753
析构函数调用的次序是先派生类的析构后基类的析构，也就是说在基类的的析构调用的时候,派生类的信息已经全部销毁了。定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数；析构的时候恰好相反：先调用派生类的析构函数、然后调用基类的析构函数。自己的理解：因为基类的析构函数不是虚函数所以说派生类的析构函数不会重写基类的析构函数//这种情况下基类析构函数不是virtual，只会调用基类的析构函数//这种情况下正常派生类的析构函数也是在派生类对象释放的时候进行清理工作的。
C++类的学习记录
wyxznb的博客
05-18 135
例题 设计一个用于人事管理的“人员”类。由于考虑到通用性，这里只抽象出所有类型人员都具有的属性：编号、姓名、性别、出生日期、身份证号等。其中“出生日期”定义为一个“日期”类内嵌子对象。用成员函数实现对人员信息的初始化和显示。要求包括：构造函数和析构函数、复制构造函数、内联成员函数、带默认形参值的成员函数、类的组合。 #include<iostream> #include<cstring> using namespace std; class date { public: date(
C++初级-类和对象（2）
qq_42627691的博客
04-15 210
C++初级-类和对象（2） 1.拷贝构造函数 （1）是特殊的成员函数 （2）是构造函数的一个重载形式 （3）参数只有一个并且必须使用引用传参，使用传值方式会引发无限的递归调用 （4）若未显示定义，系统则生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储，按字节序完成拷贝，称为浅拷贝或者值拷贝 #pragma once #include<iostream> using names...
【珠姐】C++设计一个人员类
⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄. 菜鸟不吃草！
03-14 1185
题目一： //JNU Orion 233 //created by Wang Yuchen @ 2018/03/14 //第五次试实验 人员类Staff #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;string&gt; #include &lt;cstring&gt; using namespace ...
【C++学习笔记】----类和对象（上篇）
qq_41152046的博客
04-30 174
1.类的定义 #include<iostream> using namespace std; int& f2() { int m=1; return m; } class Date { //成员函数 //成员变量 public: Date Date1();//成员函数声明 void Date2() {//类内定义 } //private: int _yea...
C++ 第6章 类与对象
SongYuLong
04-08 705
类与对象 类(Class)是面向对象程序设计(OOP,Object-Oriented Programming)实现信息封装的基础。 6.1 类和对象的定义与访问 类是在结构的基础上发展而来的。数组、结构描述了对基本数据类型的组识。在过程化程序设计中，程序的基本单位是函数。在面向对象的程序设计中，程序的基本单位是类。 6.1.1 定义类和对象 具有相同性质和功能的东西构成的集合，通常归...
详解析构函数、拷贝构造函数
weixin_61857742的博客
07-26 2169
在销毁对象时，编译器会自动调用析构函数。因此析构函数不写参数。①析构函数不是销毁对象，而是清理对象内定义的空间。比如malloc、new空间的释放之类 ②定义多个对象时，先定义的后调用析构函数，后定义的先调用析构函数。这符合栈先入后出的原则。当然在静态区存放的对象是在局部变量后析构的，例如static和全局变量。 ③析构函数一般不必自定义，编译器有默认生成。但如果有malloc、new之类自定义类型，需要手动写。④析构函数的意义就是便于对象空间的释放，当有多个对象时，不必再每个都free/delet...
C++:06---构造函数、析构函数
董哥的黑板报
03-28 725
一、构造函数 概念(作用)： 用来在创建对象时，对对象进行初始化 特点 构造函数无返回值，函数名与类名相同，必须存在于public中 构造函数可以重载 不用来初始化static数据成员，因为static数据成员不属于类 默认构造函数（合成的构造函数） 如果没有在类中给出构造函数，编译器自动生成一个默认的构造函数(无参数、函数体为空) 当在类中手动给出构造函数时，默认的构...
【C++】拷贝构造函数，析构函数详解！
luhaoran814的博客
11-23 1741
内置类型系统会默认生成拷贝构造进行值拷贝，对自定义类型调用它的拷贝构造。类中如果没有涉及资源申请时（例如 new申请空间），拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。拷贝构造也是构造，是拷贝构造的一个重载。
【C++】构造函数与析构函数
明朗晨光的专栏
11-01 4412
C++构造函数和析构函数
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
08-29
主要介绍了详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数的相关资料,这里提供实例帮助大家理解掌握这部分内容，需要的朋友可以参考下
深入C++中构造函数、拷贝构造函数、赋值操作符、析构函数的调用过程总结
01-01
用同一个类的源对象构造一个目标对象时，会调用拷贝构造函数来构造目标对象，如果没有定义拷贝构造函数，将调用类的默认拷贝函数来构造目标对象。2 . 当一个函数的返回值为一个类的对象时，如果在调用函数中，没有...
C++高级程序设计实验三-类和对象构造函数与析构函数
03-11
C++高级程序设计实验报告三：类和对象—构造函数与析构函数 实验三类和对象—构造函数与析构函数： 1．理解掌握this指针的作用和用法； 2．理解掌握构造函数的定义和作用； 3．掌握构造函数的使用； 4．理解掌握拷贝...
C++函数返回值为对象时，构造析构函数的执行细节
09-05
如果没有RVO，那么会调用拷贝构造函数`TestConstructor(const TestConstructor&)`来生成这个临时对象，同时析构函数`~TestConstructor()`会被调用来销毁`testInFunc`。 3. **赋值操作**：回到`main()`函数，`test =...
函数模板与类模板
程序员_小兵
07-12 1552
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
Linux C | 管道open打开方式
I_feige的博客
07-12 318
1.
C++ 多态
wxk2227814847的博客
07-10 789
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Reversing Numbers C++
FGGFFoj的博客
07-11 377
在默认情况下，C++的输入输出流（比如 cin, cout）与C标准库的输入输出流是同步的，这意味着在使用C++的输入输出流时，可能会因为需要与C标准库的同步而导致性能略有损失。在 C++ 中，默认情况下，cin 和 cout 是绑定在一起的，意味着在输入时，输出可能需要等待输入完成才会进行，这样可能会造成一些性能上的损失，特别是在需要频繁输入输出的场景下。需要注意的是，在取消同步后，应确保不要混合使用C++的输入输出和C标准库的输入输出，因为这可能会导致未定义的行为。
c++ 生成随机字符串
最新发布
m0_56306892的博客
07-15 94
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值