C++初阶类与对象(三):详解复制构造函数和运算符重载

简介: C++初阶类与对象(三):详解复制构造函数和运算符重载

上次介绍了构造函数和析构函数

今天就来接着介绍新的内容:



1.拷贝构造函数


1.1引入和概念


拷贝构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存在的类类型对象创建新对象时由编译器自动调用(是构造函数的重载)


拷贝构造函数典型调用场景(自动调用):


使用已存在对象创建新对象

函数参数类型为类类型对象

函数返回值类型为类类型对象

之前在c语言实现各种数据结构时,我们都会传入结构体的指针(也可以传入值,没效果但是不会报错)。现在有这种情况:在c++里调用函数就要传入值

#include<iostream>
#include<assert.h>
using namespace std;
class Date
{
public:
  Date(int year = 2024, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
class Stack
{
public:
  Stack(size_t capacity = 3)
  {
    cout << "调用了Stack构造函数" << endl;
    _a = (int*)malloc(sizeof(int) * capacity);
    if (nullptr == _a)
    {
      perror("malloc");
    }
    _capacity = capacity;
    _top = 0;
  }
  ~Stack()
  {
    cout << "调用了~Stack()" << endl;
    free(_a);
    _capacity = _top = 0;
    _a = nullptr;
  }
private:
  int* _a;
  int _capacity;
  int _top;
};
// 浅拷贝/值拷贝
void func1(Date d)//两个函数都是值传入,要进行拷贝
{
  d.Print();
}
void func2(Stack st)
{
  //...
}
int main()
{
  Date d1(2024, 1, 24);
  func1(d1);
  Stack st1;
  func2(st1);
  return 0;
}

我们调用fun1()函数时没有问题,但是在调用fun2()时发生了问题。因为:


Stack类里成员变量有一个指针,当我们传值调用函数会形成一个拷贝,在函数结束,fun2里st对象生命周期结束会自动调用析构函数进行销毁,所以指针指向的空间已经被free()还给操作系统了,而main函数里的st1中仍然指向那片空间,此时已经有野指针了。再次销毁必然崩溃


看到c++里值拷贝是有风险的(默认拷贝),所以解决方案:


规定,自定义类型对象拷贝的时候,调用一个函数,这个函数就叫拷贝构造函数


1.2特性


拷贝构造函数也是特殊的成员函数,其特征如下:


拷贝构造函数是构造函数的一个重载形式。


拷贝构造函数的参数只有一个且必须是类类型对象的引用(&),使用传值方式编译器直接报错,因为会引发无穷递归调用


为什么会无限递归:当我们传值调用函数时,首先传参–>因为是传值会调用新的一个拷贝构造–>新的拷贝构造又要传参–> …

  1. 若未显式定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝(默认的只会值拷贝)

注意:在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定义类型是调用其拷贝构造函数完成拷贝的

#include<iostream>
#include<assert.h>
using namespace std;
class Date
{
public:
  Date(int year = 2014, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;//三个都是内置类型,没有资源申请
};
int main()
{
  Date d1(2024, 1, 4);
  d1.Print();
  Date d2(d1);
  d2.Print();
  return 0;
}

这里看到使用默认的也可以

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,还需要自己显式实现吗?当然像日期类这样的类是没必要的。那如果是Stack类呢?

Stack类涉及到涉及到资源申请有一个_a指针和动态开辟,使用默认的会发生最初的问题(连续两次释放)


注意:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请时,则拷贝构造函数是一定要写的(要用深拷贝),否则就是浅拷贝


现在来解决:自己来写拷贝构造


class Stack
{
public:
  Stack(size_t capacity = 3)
  {
    cout << "调用了Stack构造函数" << endl;
    _a = (int*)malloc(sizeof(int) * capacity);
    if (nullptr == _a)
    {
      perror("malloc");
    }
    _capacity = capacity;
    _top = 0;
  }
  Stack(const Stack& stt)//自己来写
  {
    cout << "拷贝完成" << endl;
    // 深拷贝
    _a = (int*)malloc(sizeof(int) * stt._capacity);
    if (_a == nullptr)
    {
      perror("malloc fail");
      exit(-1);
    }
    memcpy(_a, stt._a, sizeof(int) * stt._top);
    _top = stt._top;
    _capacity = stt._capacity;
  }
  ~Stack()
  {
    cout << "调用了~Stack()" << endl;
    free(_a);
    _capacity = _top = 0;
    _a = nullptr;
  }
private:
  int* _a;
  int _capacity;
  int _top;
};
int main()
{
  Stack st1;
  Stack st2(st1);
  return 0;
}

  1. 拷贝构造函数典型调用场景:
  • 使用已存在对象创建新对象
  • 函数参数类型为类类型对象
  • 函数返回值类型为类类型对象


2.赋值运算符重载


2.1运算符重载


C++为了增强代码的可读性引入了运算符重载,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。


函数名字为:关键字operator后面接需要重载的运算符符号。


函数原型:返回值类型 operator操作符(参数列表)


注意:


重载双操作数的运算符,第一个参数是左操作数,第二个参数是右操作数


不能通过连接其他符号来创建新的操作符:比如operator@


重载操作符必须有一个类类型参数


用于内置类型的运算符,其含义不能改变,例如:内置的整型+,不 能改变其含义


作为类成员函数重载时,其形参看起来比操作数数目少1,因为成员函数的第一个参数为隐藏的this


.* :: sizeof ? : . 注意以上5个运算符不能重载。笔试会有


2.2放在哪里


  1. 全局处

运算符重载成全局的就需要成员变量是公有的,那么问题来了,封装性如何保证?

不会这样干

  1. 使用友元函数

友元函数后面会给大家详解,在这里先下结论:能不使用友元函数就不使用

  1. 放在类里面

我们选择直接重载成成员函数


2.3运算符重载示例


我们就先使用大家最为熟悉的日期类作为演示,我们没有写的那些,都是编译器帮我们完成的。

例如,如果你重载了加法运算符 +,那么当你在程序中使用 + 运算符时,编译器会根据运算符的左右操作数的类型决定调用哪个函数


2.3.1日期相比==和>(开胃小菜)


class Date
{
public:
  Date(int year = 2024, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  bool operator==(Date d)
  {
    return _year == d._year
      && _month == d._month
      && _day == d._day;
  }
  bool operator>(Date d)
  {
    if (_year > d._year)
    {
      return true;
    }
    else if (_year == d._year && _month > d._month)
    {
      return true;
    }
    else if (_year == d._year && _month == d._month && _day > d._day)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  d1.Print();
  Date d2(2024, 1, 1);
  d2.Print();
  bool ret1 = d1 > d2;//实际上是:d1.operator>(d2)  -->  d1.operator>(&d1,d2);
  bool ret2 = d1 == d2;//实际上是:d1.operator==(d2)  -->  d1.operator==(&d1,d2);
  cout << ret1 << endl;
  cout << ret2 << endl;
  return 0;
}


2.3.2赋值运算符重载


  1. 赋值运算符重载格式
  • 参数类型:const T&,传递引用可以提高传参效率
  • 返回值类型:T&,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值
  • 返回*this :要复合连续赋值的含义
class Date
{
public:
  Date(int year = 2024, 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;
  }
  ~Date()
  {
    ;
  }
  // 赋值运算符重载
// d2 = d3 -> d2.operator=(&d2, d3)
  Date& operator=(const Date& d)
  {
    if (this != &d)
    {
      _year = d._year;
      _month = d._month;
      _day = d._day;
    }
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  d1.Print();
    Date d2;
  d2 = d1;//使用重载赋值
  d2.Print();
  return 0;
}


赋值运算符只能重载成类的成员函数不能重载成全局函数

原因:赋值运算符如果不显式实现,编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载,就和编译器在类中生成的默认赋值运算符重载冲突了,故赋值运算符重载只能是类的成员函数


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


注意:内置类型成员变量是直接赋值的(浅拷贝),而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值(跟拷贝构造的行为类似,内置类型值拷贝,自定义类型调用他的赋值)


既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了。和上面拷贝构造一样:日期类这样的是不需要实现的(使用默认的就够了);但是像是Stack类这样的一旦涉及到资源申请时,则拷贝构造函数是一定要写的(要用深拷贝)


赋值运算符重载与拷贝构造调用区别:

int main()
{
  Date d1;//调用构造函数
  Date d2 = d1;//这是调用拷贝构造;
  //一个已经存在的对象,拷贝初始化另一个要创建的对象时拷贝构造
  Date d3;
  d3 = d1;//这是赋值重载函数:两个对象都存在,进行赋值拷贝
  return 0;
}


2.3.3前置++和后置++重载


class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  // 前置++:返回+1之后的结果
  Date& operator++()
  {
    (*this) += 1;
    return *this;// 注意:this指向的对象函数结束后不会销毁,故以引用方式返回提高效率
  }
  // 后置++:
  // C++规定:后置++重载时多增加一个int类型的参数,但调用函数时该参数不用传递,编译器自动传递
  Date operator++(int)// 前置++和后置++都是一元运算符,加个int为了让前置++与后置++形成能正确重载
  {
    Date temp(*this);
    (*this) += 1;
    return temp;//temp是临时对象,因此只能以值的方式返回,不能返回引用
  }
// 注意:后置++是先使用后+1,因此需要返回+1之前的旧值,故需在实现时需要先将this保存一份,然后给this + 1
private:
  int _year;
  int _month;
  int _day;
};

前置递增运算符++的重载函数返回的是Date对象的引用,因为前置递增运算符会先对对象进行加一操作,然后返回加一后的对象本身,因此返回的是引用。这样可以实现连续的递增操作。


后置递增运算符++的重载函数多增加了一个int类型的参数(虽然在调用时不需要传递),这是为了与前置递增运算符形成重载。在函数内部,先将当前对象的值保存到临时对象temp中,然后对当前对象进行加一操作,最后返回保存了旧值的临时对象temp。这样可以实现先返回旧值再进行递增的语义


2.3.4重载<<和>>


首先我们知道:双操作数的运算符,第一个参数是左操作数,第二个参数是右操作数


如果放在类内,那==第一个参数默认是Date this==,这样调用时就是d1<<cout 了。所以不能放在类内实现,要在全局实现,那又该怎么访问私有成员呢?*


就要使用友元函数了(下一次会给大家详细讲解)


class Date
{
public:
  Date(int year = 2024, 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;
  }
  ~Date()
  {
    ;
  }
  friend ostream& operator<<(ostream& out,const Date& d);//cout是ostream类的对象
  friend istream& operator>>(istream& in,Date& d);//cin是istream类的对象
private:
  int _year;
  int _month;
  int _day;
};
ostream& operator<<(ostream& out, const Date& d)
{
  out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
  return out;//来进行多次输出
}
istream& operator>>(istream& in, Date& d)
{
  in >> d._year >> d._month >> d._day;
  return in;
}
int main()
{
  Date d1(2024, 1, 1);
  Date d2;
  cin >> d2;
  cout << d1 << d2;
  return 0;
}

为什么没有声明cout是ostream类的对象,甚至声明后还会报错???

  • std::ostream是一个抽象类,它不能被直接实例化
  • std::cout是标准输出流对象,已经在标准库中定义好了,并且支持输出运算符<<的重载,所以传入参数就好了


3.const成员


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

const成员函数主要是给对象常量来使用(const Date d1;),因为:

如果const对象调用非const成员函数有可能会扩大权限;非const对象调用const成员函数可以,只会缩小权限

大家看下面这段代码:

bool Date::operator < (const Date& d)
{
  return !((*this) >= d);
}
int main()
{
  const Date d1(2024, 1, 1);
  Date d2(2024,15);
  d2 < d1;
  d1 < d2;
  return 0;
}

看似d2 < d1; d1 < d2;两句都没错,但实际上欠着正确,后者错误:

结论:

  1. 能定义成const的成员函数都应该定义成const,这样const对象和非const对象都可以调用
  2. 要修改成员变量的成员函数,不能定义成const,这样const对象不能调用 (会报错) 非const才能调用


4.取地址及const取地址操作符重载


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

class Date
{
public:
  Date* operator&()
  {
    return this;
  }
  const Date* operator&()const//参数是const Date* this,因为保证*this不变(内容不变,指向可以变)
  {
    return this;//返回const Date* 类型
  }
private:
  int _year;
  int _month;
  int _day;
};

对于非const对象,我们返回指向对象的指针;对于const对象,我们返回指向const对象的指针。


这两个运算符一般不需要重载,使用编译器生成的默认取地址的重载即可,只有特殊情况,才需要重载,比如想让别人获取到指定的内容


好啦,这次就到这里啦,剩下的内容我快马加鞭!!!感谢大家支持!!!


目录
相关文章
|
8月前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
|
7月前
|
编译器 C++
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
|
7月前
|
存储 编译器 C++
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
|
7月前
|
编译器 C++
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
|
8月前
|
安全 编译器 C语言
【C++篇】深度解析类与对象(中)
在上一篇博客中,我们学习了C++类与对象的基础内容。这一次,我们将深入探讨C++类的关键特性,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键,也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。
|
4月前
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
94 0
|
4月前
|
存储 编译器 程序员
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
170 0
|
6月前
|
编译器 C++ 容器
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
181 12
|
7月前
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
131 16
|
8月前
|
编译器 C语言 C++
类和对象的简述(c++篇)
类和对象的简述(c++篇)