AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C++练级之路——类和对象（中二）

2024-06-24 25
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++练级之路——类和对象（中二）

1、运算符重载


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


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

函数原型：返回值类型 operator操作符（参数列表）。

注意：


1.不能通过链接其他符号来创建新的操作符：比如 operator@；

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

3.用于内置类型的运算符，其含义不能改变，例如：内置类型的+，不能改变其含义；

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

5.  .*   ::     sizeof     ?:    .    注意以上五个运算符不能重载，这个经常在笔试选择题中出现。

//运算符重载
bool operator<(const Date& d);
bool operator==(const Date& d);
bool operator<=(const Date& d);
bool operator>(const Date& d);
bool operator>=(const Date& d);
bool operator!=(const Date& d);
 
//函数实现
bool Date::operator<(const Date& d)
{
  if (_year < d._year)
    return true;
 
  else if (_year == d._year)
  {
    if (_month < d._month)
      return true;
 
    else if (_month == d._month)
      return _day < d._day;
  }
  return false;
}
 
bool Date::operator==(const Date& d)
{
  return _year == d._year
    && _month == d._month
    && _day == d._day;
}
 
bool Date::operator<=(const Date& d)
{
  return *this < d && *this == d;
}
bool Date::operator>(const Date& d)
{
  return !(*this <= d);
}
bool Date::operator>=(const Date& d)
{
  return !(*this <d);
}
bool Date::operator!=(const Date& d)
{
  return !(*this == d);
}


当我们重载了  <  和 ==  时，就可以复用这两个运算符，重载<=  >   >=   != ，更加方便了。

2、赋值运算符重载

1.参数类型：const  参数名&，传递引用可以提高传参效率，（不用再调用拷贝构造了）；

2.返回值类型：参数名&  返回引用可以提高返回的效率，有返回值的目的是为了支持连续赋值；

3.检测是否自己给自己赋值

4.返回this，要符合连续赋值的含义；


//声明
Date& operator=(const Date& d);
 
//定义
Date& Date:: operator=(const Date& d)
{
  _year = d._year;
  _month = d._month;
  _day = d._day;
  return *this;
}

2、赋值运算符只能重载成成员函数，不能重载成全局函数

因为赋值运算符第一个参数是this指针，重载成全局函数，就需要传this指针，而当类里面没有显式定

义赋值运算符时，编译器会自动生成一个默认的。此时就会和类外的赋值运算符重载形成冲突，所以赋值运算符只能是成员函数。



3、用户没有显式实现时，编译器会自动生成一个默认的赋值操作符重载，以值的方式逐字节拷贝


注意：内置类型成员变量是直接赋值的，而自定义成员变量需要调用对应类的赋值运算符重载完成赋值，如果自定义类中没有显式实现赋值运算符重载，编译器也会默认生成赋值重载；

class Time
{
public:
  Time()
  {
    _hour = 1;
    _minute = 1;
    _second = 1;
  }
    //这个赋值运算符重载写不写都可以，不写的话编译器也会自动生成
  /*Time& operator=(const Time& t)
  {
    if (this != &t)
    {
      _hour = t._hour;
      _minute = t._minute;
      _second = t._second;
    }
    return *this;
  }*/
  
//private:
  int _hour;
  int _minute;
  int _second;
};
 
class Date1
{
public:
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  // 基本类型(内置类型)
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date1 d1;
  Date1 d2;
  d1 = d2;
 
  d1.print();
  d2.print();
  return 0;
}


但是，我们真的不需要自己写了吗？

不是的，如果类中涉及到资源管理，开辟空间的，就要自己实现赋值重载了，因为编译器自己实现的是浅拷贝，也就是值拷贝，不会额外开辟空间，所以我们自己写深拷贝，和拷贝构造，析构函数差不多。



3、前置++和后置++重载


前置++，返回+1之后的结果，

注意：this指向的对象函数结束后不会销毁，故用引用的方式返回提高效率；

后置++，返回+1之前的结果

为了能够区分


C++规定：后置++重载时多增加一个Int 参数，但调用函数时，用户不用传递，编译器会自动传递，（问就是C++规定的）

后置++，要用值的方式返回，因为要在函数内创建一个临时对象tem来保存*this，然*this++


然后返回tem,

//前置++
Date& Date::operator++()
{
  *this += 1;
  return *this;
}
 
//后置++
//int 只是一个标志，代表他是后置的--，没有实际意义
Date Date::operator++(int)
{
  Date tem = *this;
  *this += 1;
  return tem;
}
 
//前置--
Date& Date::operator--()
{
  *this -= 1;
  return *this;
}
 
//后置--
Date Date::operator--(int)
{
  Date tem = *this;
  *this -= 1;
  return tem;
}


4、const成员变量

将const修饰的成员函数成为“const成员函数”，const修饰类成员函数，实际上是修饰该类成员函数隐函的 this 指针，表明在该成员函数中不能对类的成员进行修改。

class Date1
{
public:
  Date1(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << "Print()" << endl;
    cout << "year:" << _year << endl;
    cout << "month:" << _month << endl;
    cout << "day:" << _day << endl << endl;
  }
  void Print() const
  {
    cout << "Print()const" << endl;
    cout << "year:" << _year << endl;
    cout << "month:" << _month << endl;
    cout << "day:" << _day << endl << endl;
  }
private:
  int _year; // 年
  int _month; // 月
  int _day; // 日
};
void Test()
{
  Date1 d1(2022, 1, 13);
  d1.Print();
  const Date1 d2(2022, 1, 13);
  d2.Print();
}
  int main()
{
    Test();
    return 0;
}


注意：权限可以缩小，平移，但是不可以放大；

请思考下面的几个问题：


1. const对象可以调用非const成员函数吗？

2. 非const对象可以调用const成员函数吗？

3. const成员函数内可以调用其它的非const成员函数吗？

4. 非const成员函数内可以调用其它的const成员函数吗？


5、日期类的实现


       我们还可以重载流插入和流提取

流插入我们要在类外实现，因为在类中实现，第一个参数是隐形的this指针，而我们希望第一个参数

是ostream& out，那我们就定义在类外可以解决这个问题，但是定义在类外我们就无法访问类中的私有的成员变量，就用到了另一个办法，友元，友元的概念就是我是你的朋友，我可以访问你的元素，不管是公有还是私有，这里暂且了解一下，下节会讲；


下面来看日期类的实现，上面的运算符重载都会用到；

//Date.h
#pragma once
#include<iostream>
using namespace std;
 
int is_year(int y);
 
class Date
{
  friend ostream& operator<<(ostream& out, const Date& d);
  friend istream& operator>>(istream& in, Date& d);
public:
 
  Date(int year=1 ,int month=1, int day=1);
  Date(const Date& d);
  //在类里面定义的函数默认就内联函数
  int GetMonthDay(int y, int m)
  {               
    static int months[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    if (m == 2)
      return months[m] + is_year(y);
    return months[m];
  }
 
  //日期+=天数
  Date& operator+=(int day);
  Date operator+(int day);
  Date& operator-=(int day);
  Date operator-(int day);
 
  //++和--
  Date& operator++();
  Date operator++(int);
  Date& operator--();
  Date operator--(int);
 
  //日期-日期
  int operator-(const Date& d);
 
 
  //运算符重载
  Date& operator=(const Date& d);
  bool operator<(const Date& d);
  bool operator==(const Date& d);
  bool operator<=(const Date& d);
  bool operator>(const Date& d);
  bool operator>=(const Date& d);
  bool operator!=(const Date& d);
 
 
  //流插入和流输出
  ~Date();
  void print();
 
private:
  int _year;
  int _month;
  int _day;
};
 
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in,  Date& d);
2.


//Date.cpp
 
#include"Date.h"
 
 
int is_year(int y)
{
  if (y % 4 == 0 && y % 100 != 0 || y % 400 == 0)
    return 1;
  return 0;
}
  Date::Date(int year , int month , int day )
  {
    _year = year;
    _month = month;
    _day = day;
  }
  Date::Date(const Date& d)
  {
    cout << "Date::Date(const Date& d)" << endl;
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
    
  Date& Date::operator+=(int day)
  {
    _day += day;
    while (_day > GetMonthDay(_year, _month))
    {
      _day -= GetMonthDay(_year, _month);
      _month++;
      if (_month == 13)
      {
        _year++;
        _month = 1;
      }
    }
    return *this;
  }
 
  Date Date::operator+(int day)
  {
    Date tem = *this;
    tem += day;
    return tem;
  }
 
  Date& Date::operator-=(int day)
  {
    _day -=day;
    while (_day < 0)
    {
      _month--;
      if (_month == 0)
      {
        _year--;
        _month = 12;
      }
      _day += GetMonthDay(_year, _month);
    }
    return *this;
  }
 
  Date Date::operator-(int day)
  {
    Date tem = *this;
    tem -= day;
    return tem;
  }
 
 
  //前置++
  Date& Date::operator++()
  {
    *this += 1;
    return *this;
  }
 
  //后置++
  //int 只是一个标志，代表他是后置的--，没有实际意义
  Date Date::operator++(int)
  {
    Date tem = *this;
    *this += 1;
    return tem;
  }
 
  //前置--
  Date& Date::operator--()
  {
    *this -= 1;
    return *this;
  }
 
  //后置--
  Date Date::operator--(int)
  {
    Date tem = *this;
    *this -= 1;
    return tem;
  }
 
  //日期-日期
  int Date:: operator-(const Date& d)
  {
    Date max = *this;
    Date min = d;
    int n = 0;
    int flag = 1;
    if (max < min)
    {
      max = d;
      min = *this;
      flag = -1;
    }
 
    while (min!=max)
    {
      ++min;
      ++ n;
    }
    return n*flag;                                                 
  }
 
 
 
  //赋值运算符重载
  Date& Date:: operator=(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this;
  }
 
  bool Date::operator<(const Date& d)
  {
    if (_year < d._year)
      return true;
 
    else if (_year == d._year)
    {
      if (_month < d._month)
        return true;
 
      else if (_month == d._month)
        return _day < d._day;
    }
    return false;
  }
 
  bool Date::operator==(const Date& d)
  {
    return _year == d._year
      && _month == d._month
      && _day == d._day;
  }
 
  bool Date::operator<=(const Date& d)
  {
    return *this < d && *this == d;
  }
  bool Date::operator>(const Date& d)
  {
    return !(*this <= d);
  }
  bool Date::operator>=(const Date& d)
  {
    return !(*this <d);
  }
  bool Date::operator!=(const Date& d)
  {
    return !(*this == d);
  }
 
  void Date::print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
  Date::~Date()
  {
    //cout << "Date::~Date()" << endl;
 
  }
 
  ostream& operator<<(ostream& out, const Date& d)
  {
    out << d._year << "年" << d._month << "月" << d._day << endl;
    return out;
  }
 
  istream& operator>>(istream& in, Date& d)
  {
    cout << "请输入日期:" << endl;
 
    in >> d._year >> d._month >> d._day;
    return in;
  }
 
 
//Test.cpp
#include"Date.h"
 
//Date func()
//{
//  Date d3(2024, 4, 14);
//  return d3;
//}
int fx()
{
  int a = 10;
  int b = 20;
  int c = 30;
  return a + b + c;
}
//int main()
//{
//  
//    Date ret = func();
//    ret.print();
//
//
//  /*Date d1(2024, 4, 14);
//  Date d2(2024, 5, 14);
//  d1.print();
//  d2.print();
//  cout << (d2 < d1) << endl;
//  cout << (d2 <= d1) << endl;
//  cout << (d2 > d1) << endl;
//  cout << (d2 >= d1) << endl;
//  cout << (d2 == d1) << endl;
//  cout << (d2 != d1) << endl;*/
//
//  return 0;
//}
 
//Date func()
//{
//  Date d3(2024, 4, 14);
//  return d3;
//}
//Date& func()
//{
//  Date d3(2024, 4, 14);
//  return d3;
//}
//int main()
//{
//  //const Date& ret = func();
//  //ret.print();
//
//  return 0;
//}
 
//Date& func()
//{
//  static Date d3(2024, 4, 14);
//  return d3;
//}
//int main()
//{
//   Date& ret = func();
//   ret.print();
//
//  return 0;
//}
//class Time
//{
//public:
//  Time()
//  {
//    _hour = 1;
//    _minute = 1;
//    _second = 1;
//  }
//  /*Time& operator=(const Time& t)
//  {
//    if (this != &t)
//    {
//      _hour = t._hour;
//      _minute = t._minute;
//      _second = t._second;
//    }
//    return *this;
//  }*/
//  
private:
//  int _hour;
//  int _minute;
//  int _second;
//};
//
//class Date1
//{
//public:
//  void print()
//  {
//    cout << _year << "-" << _month << "-" << _day << endl;
//  }
//private:
//  // 基本类型(内置类型)
//  int _year = 1970;
//  int _month = 1;
//  int _day = 1;
//  // 自定义类型
//  Time _t;
//};
//int main()
//{
//  Date1 d1;
//  Date1 d2;
//  d1 = d2;
//
//  d1.print();
//  d2.print();
//  return 0;
//}
//int main()
//{
//  Date d1(2024, 4, 15);
//  Date d2(2024, 2, 15);
//  d2 = d1;
//
//  d1.print();
//  d2.print();
//
//  
//  return 0;
//}
 
 
 
 
//class Date1
//{
//public:
//  Date1(int year, int month, int day)
//  {
//    _year = year;
//    _month = month;
//    _day = day;
//  }
//  void Print()
//  {
//    cout << "Print()" << endl;
//    cout << "year:" << _year << endl;
//    cout << "month:" << _month << endl;
//    cout << "day:" << _day << endl << endl;
//  }
//  void Print() const
//  {
//    cout << "Print()const" << endl;
//    cout << "year:" << _year << endl;
//    cout << "month:" << _month << endl;
//    cout << "day:" << _day << endl << endl;
//  }
//private:
//  int _year; // 年
//  int _month; // 月
//  int _day; // 日
//};
//void Test()
//{
//  Date1 d1(2022, 1, 13);
//  d1.Print();
//  const Date1 d2(2022, 1, 13);
//  d2.Print();
//}
//  int main()
//{
//    Test();
//    return 0;
//}
int main()
{
  Date d1(2024, 4, 17);
  Date d2(2024, 9, 14);
 
  cin >> d1 >> d2;
  cout << d1 << d2;
  /*cout << (d2 - d1) << endl;
 
  d1.print();
  d2.print();*/
  return 0;
}

6、取地址及const取地址操作符重载


这两个默认构造函数一般不用重新定义，编译器会默认生成；


class Date1
{
public:
  Date1* operator&()
  {
    return this;
  }
  const Date1* operator&()const
  {
    return this;
  }
private:
  int _year;
  int _month;
  int _day;
};


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


撒花！！！

文章标签：
C++
编译器
关键词：
C++类
C++对象
C++类对象
C++类和对象
C++练级类
风掣长空
目录
相关文章
二二*一一
|
10天前
|
编译器 C++
C++ 类构造函数初始化列表
构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。
二二*一一
56 30
可能只会写BUG
|
24天前
|
C++
C++(十一)对象数组
本文介绍了C++中对象数组的使用方法及其注意事项。通过示例展示了如何定义和初始化对象数组，并解释了栈对象数组与堆对象数组在初始化时的区别。重点强调了构造器设计时应考虑无参构造器的重要性，以及在需要进一步初始化的情况下采用二段式初始化策略的应用场景。
可能只会写BUG
33 3
游客zi3qmblbcdexu
|
24天前
|
存储 编译器 C++
C ++初阶：类和对象（中）
C ++初阶：类和对象（中）
游客zi3qmblbcdexu
23 3
可能只会写BUG
|
24天前
|
C++
C++(十六)类之间转化
在C++中，类之间的转换可以通过转换构造函数和操作符函数实现。转换构造函数是一种单参数构造函数，用于将其他类型转换为本类类型。为了防止不必要的隐式转换，可以使用`explicit`关键字来禁止这种自动转换。此外，还可以通过定义`operator`函数来进行类型转换，该函数无参数且无返回值。下面展示了如何使用这两种方式实现自定义类型的相互转换，并通过示例代码说明了`explicit`关键字的作用。
可能只会写BUG
20 2
可能只会写BUG
|
24天前
|
存储 设计模式 编译器
C++(十三) 类的扩展
本文详细介绍了C++中类的各种扩展特性，包括类成员存储、`sizeof`操作符的应用、类成员函数的存储方式及其背后的`this`指针机制。此外，还探讨了`const`修饰符在成员变量和函数中的作用，以及如何通过`static`关键字实现类中的资源共享。文章还介绍了单例模式的设计思路，并讨论了指向类成员（数据成员和函数成员）的指针的使用方法。最后，还讲解了指向静态成员的指针的相关概念和应用示例。通过这些内容，帮助读者更好地理解和掌握C++面向对象编程的核心概念和技术细节。
可能只会写BUG
22 2
游客zi3qmblbcdexu
|
1月前
|
存储 算法 编译器
c++--类（上）
c++--类（上）
游客zi3qmblbcdexu
23 4
真的很搞笑
|
1月前
|
编译器 C++
virtual类的使用方法问题之在C++中获取对象的vptr（虚拟表指针）如何解决
virtual类的使用方法问题之在C++中获取对象的vptr（虚拟表指针）如何解决
真的很搞笑
59 4
可能只会写BUG
|
24天前
|
存储 C++
C++(五)String 字符串类
本文档详细介绍了C++中的`string`类，包括定义、初始化、字符串比较及数值与字符串之间的转换方法。`string`类简化了字符串处理，提供了丰富的功能如字符串查找、比较、拼接和替换等。文档通过示例代码展示了如何使用这些功能，并介绍了如何将数值转换为字符串以及反之亦然的方法。此外，还展示了如何使用`string`数组存储和遍历多个字符串。
可能只会写BUG
13 0
Liuqz2009
|
1月前
|
存储 C++
C++ dll 传 string 类 问题
C++ dll 传 string 类 问题
Liuqz2009
20 0
睡觉待开机
|
1月前
|
存储 安全 编译器
【C++】类和对象(下)
【C++】类和对象(下)
睡觉待开机
23 2
【C++】类和对象(下)

热门文章

最新文章

  • 1
    C++模板初阶
  • 2
    c++打印乘法表
  • 3
    C/C++程序员上手C#应该知道的100件事（21~30）
  • 4
    教你如何使用 Visual Studio IDE 正确的进行 C++ 桌面开发
  • 5
    C++ Internals: STL之Map
  • 6
    Eclipse C/C++开发环境搭建
  • 7
    C++中的显式类型转化
  • 8
    Visual Studio Installer打包后生成的安装文件每次执行都需要重新安装C++ 2010运行库(x86)的解决方案
  • 9
    C++ STL算法系列4---unique , unique_copy函数
  • 10
    C++：多态之重载
  • 1
    C++ new和delete的用法
    69
  • 2
    为什么c++要引入class关键字
    55
  • 3
    【C++】使用g++指令控制【翻译】各个过程
    45
  • 4
    【C++】一文深入浅出带你参透库中的几种 [ 智能指针 ]及其背后实现原理（代码＆图示）
    54
  • 5
    【C++】C++中的【文件IO流】使用指南 [手把手代码演示] ＆ [小白秒懂]
    63
  • 6
    【C++】istream类型对象转换为逻辑条件判断值
    43
  • 7
    【C++】一文全解四种经典 [ 特殊类 ]的设计
    46
  • 8
    【C++】【C++的常变量取地址问题（对比C的不同）】const修饰的常变量＆volatile修饰用法详解（代码演示）
    39
  • 9
    【C++】C++中规范[ 类型转换标准 ] 的四种形式
    46
  • 10
    【C++小小知识点】重载、覆盖(重写)、隐藏(重定义)的对比【详解】（23）
    69

    • 相关课程

    更多
  • C++ 入门教程开发文档
  • 深入浅出白话Serverless-1024程序员节创造营公益课
  • 程序设计类比赛汇总
  • 【科技少年】Python绘画编程第一课
  • 学生—职场人的进阶指南
  • Java面向对象编程

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce

    • 相关实验场景

    更多
  • 代码质量提升小妙招
  • 重温童年的“五子棋”，赢取专属阿里云Serverless证书
    • 下一篇
    使用OSS上传下载文件