【C++】掌握C++类的六个默认成员函数:实现高效内存管理与对象操作(三)

简介: 【C++】掌握C++类的六个默认成员函数:实现高效内存管理与对象操作

【C++】掌握C++类的六个默认成员函数:实现高效内存管理与对象操作(二)https://developer.aliyun.com/article/1617297

六、 赋值运算重载

赋值运算符重载格式:

  1. 参数类型:const typename &传递引用可以提高传参效率
  2. 返回值类型:typename&返回引用可以减少拷贝,提高返回的效率,有返回值目的是为了支持连续赋值
  3. 检查是否存在自己给自己赋值
  4. **返回*this:**要复合连续赋值的含义

6.1 判断拷贝构造函数与赋值运算重载

class Date
{
    public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    void operator=(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2024, 1, 23);
    Date d2 = (2024, 2, 28);
    d2 = d1;
    Date d3 = d1;
    return 0;
}

无论是赋值运算符重载还是拷贝构造函数都可以完成对内置类型处理,那么如何识别属于赋值还是拷贝呢?那么d2 = d1是赋值还是拷贝,Date d3 = d1;赋值还是拷贝?

判断方法:

  • 拷贝构造:同类型定义对象需要初始化要创建对象
  • 赋值运算符重载:已经存在的对象,一个拷贝赋值给另一个

6.2 关于连续赋值

int main()
{
  Date d1(2024, 1, 23);
  Date d2(2024, 2, 28);
  Date d3;
  int i; int j = 10;
  i = j = 20;
  
  d3 = d2 = d1;
  return 0;
}
  • 内置类型:连续赋值是从右到左,这里先处理j=20表达式,返回临时变量存储返回值,再跟i赋值。
  • 自定义类型:连续赋值,先处理d2=d1这里就会调用赋值运算符重载。连续赋值返回值需要改为Date,并且返回对象*this
Date operator=(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this;
  }

这种写法不推荐由于返回值传值返回先存储到寄存器中,传值不会返回对象本身,而是会返回他的拷贝。如果是同类,就需要调用拷贝构造。无论如何会导致浪费,不如使用引用做返回值,减少拷贝次数。这也是指针跟引用差异。

Date& operator=(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this;
  }

6.3 自己给自己赋值

可能会存在一种情况,自己给自己赋值(一般人都不这么干,主要是白干),对此一般会加给判断语句

Date& operator=(const Date& d)
{
  if(this!=&d)
    {
    _year=d._year;
        _month=d._month;
        _day=d._day;
    }
    return *this;
}

6.4 赋值运算符重载不能重载为全局函数

赋值运算符重载跟拷贝构造类似,如果不显式实现,编译器会生成一个默认的赋值运算符重载,此时用户再类外自己实现一个全局的赋值运算符重载,就和编译器在类中生成的默认赋值运算符重载冲突,故而赋值运算符只能是类的成员函数(其他运算符函数可以重载为全局函数)

  • 特性:用户没有显式实现时,编译器会生成一个默认赋值运算符重载,以值的方式逐字节拷贝

默认生成赋值运算符重载对于内置类型与自定义类型处理方式

  • 内置类型成员变量直接赋值的
  • 自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值

6.5 赋值运算符中深拷贝

既然编译器生成的默认赋值运算符重载已经可以完成字节序的值拷贝,还需要自己实现吗?

接下来如果继续使用浅拷贝程序就会崩溃掉,就需要使用深拷贝解决。因为这里两个对象调用同一个函数,对同一块空间进行free,重复free会报错

// 这里会发现下面的程序会崩溃掉?这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 10)
    {
    _array = (DataType*)malloc(capacity * sizeof(DataType));
    if (nullptr == _array)
    {
    perror("malloc申请空间失败");
    return;
}
       _size = 0;
    _capacity = capacity;
}
void Push(const DataType& data)
{
    // CheckCapacity();
    _array[_size] = data;
    _size++;
}
~Stack()
{
    if (_array)
    {
        free(_array);
        _array = nullptr;
        _capacity = 0;
        _size = 0;
    }
}
private:
    DataType *_array;
    size_t _size;
    size_t _capacity;
};
int main()
{
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2;
    s2 = s1;
    return 0;
} 

小结:

  • 如果类中未涉及到资源管理,赋值运算符是否实现都是可以的
  • 如果类中涉及到资源管理,赋值运算符则必须实现

七、前置++与后置++运算符重载

前置++和后置++ 都这样子写,编译器是无法区分的。对此需要进行特殊处理(解决语法逻辑不自洽)。虽然++operator可以解决问题,但是C++给出其他解决方式

//++d1
Date operator++();
//d1++
Date operator++();

C++规定后置++重载时,多增加一个int类型的参数(用来完成重载,没有实际意义),但是调用函数时该参数不用传参,编译器会自动传递。

//前置++
Date& operator++()
{
    _day += 1;
    return *this;
}
//后置++
Date operator++(int)
{
    Date temp(*this);
    _day += 1;
    return temp;
}

八、const成员函数

const修饰的"成员函数"称之为const成员函数,const修饰类成员函数,实际修饰改成员隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改

问题:

  1. cosnt对象可以调用非const成员函数吗?
  2. 非const对象可以调用const成员函数吗?
  3. const成员函数内可以调用其他的非const成员函数吗?
  4. 非const成员函数内可以调用其他的const成员函数吗?

接下来,带着我们的问题进行下去

int main()
{
  Date d1(2024, 1, 31);
  d1.Print();
  const Date d2(2024, 3, 31);
  d2.Print();
  return 0;
}

这里原因很显然是d2的权限被放大了(权限可以缩小,但是不能放大)

既然const修饰类成员函数,实际修饰改成员隐含的this指针。那么只要const修饰this指针就可以解决权限问题。但是对于我们需要修饰this指向的内容,但是规定在this形参和实参位置不允许显式,也是不能修改的,那么怎么修改呢?

8.1 函数定义添加const修饰

祖师爷给出解决措施,在函数定义地方加个constvoid fname() const,至于为什么不是 const void fname()还是那一句,我们是语法的学习者。这样处理完了之后,对于const对象和非const对象都可以调用该函数

8.2 const修饰全部函数可行?

  • 如果对成员变量只进行读访问的函数建议加const,这样const对象和非const对象都可以使用;
  • 如果对成员变量进行读写访问的函数,不能加上const,否则不能修改成员变量(需要修改读写权限)

补充:全局实现的运算符重载函数不存在this指针,而const修饰成员函数是修饰this指针的。那么流插入与流提取不是在类中实现,没有隐含的this指针,不能使用const修饰。

对于上面的几个问题的答案:

  • cosnt对象可以调用非const成员函数吗?(不可以,权限放大)
  • 非const对象可以调用const成员函数吗?(可以,权限缩小)
  • const成员函数内可以调用其他的非const成员函数吗?(不可以,权限放大)
  • 非const成员函数内可以调用其他的const成员函数吗?(可以,权限缩小)

九、&取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义,编译器会默认生成的

class Date
{
public:
  Date* operator&()
  {
    return this;
  }
  const Date* operator&() const
  {
    return this;
  }
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
};
int main()
{
  int a = 0;
  const int b = 10;
  cout << &a << endl;
  cout << &b << endl;
  return 0;
}

那么对于返回地址具有选择性,可以指定返回空或者返回一个像模像样的地址(传了假地址都很难发现,写bug小妙招~)

class Date
{
public:
  Date* operator&()
  {
    return null;
  }
  const Date* operator&() const
  {
    return (const Date*)0xeeffee;
  }
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
};

以上就是本篇文章的所有内容,在此感谢大家的观看!这里是店小二呀C++笔记,希望对你在学习C++语言旅途中有所帮助!

目录
打赏
0
0
0
0
21
分享
相关文章
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
32 12
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
48 16
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
|
1月前
|
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
108 6
|
3月前
|
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
116 19
【C++篇】深度解析类与对象(中)
在上一篇博客中,我们学习了C++类与对象的基础内容。这一次,我们将深入探讨C++类的关键特性,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键,也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。

热门文章

最新文章