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

【C++打怪之路Lv4】-- 类和对象（中）

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

类的6个默认成员函数

1、特殊成员函数

2、不写编译器会自动生成


构造函数

概念

构造函数是初始化对象，不是开空间

C语言中没有初始化，会出现随机值

六个特性

  1. 函数名与类名相同
  2. 无返回值
  3. 对象实例化 自动调用 该函数
  4. 构造函数可以重载
  5. 如没有显式定义的构造函数，编译器自动生成(隐式的无参构造函数)；反之，则不会自动生成

注：①不显式写默认构造，对于内置类型成员变量，看编译器是否处理； 对于自定义类型成员变量才会调用它的 无参构造(不传参就可以调用的那个构造)

②默认构造函数包括：无参构造函数、全缺省构造函数、编译器默认生成的构造函数(隐式的无参构造函数)


6、内置类型成员变量在类中声明时可以给默认值

默认构造函数的意义

在两个栈实现一个队列，编译器给了初始化(在某种情况下有意义)


析构函数

概念

对象在销毁时自动调用析构函数，完成对象中的资源清理

C语言没有写Destroy，会造成内存泄漏

四个特性

  1. 析构函数名在类名前加~
  2. 无参数无返回值
  3. 一个类只能析构一个函数，析构函数不能重载
  4. 在生命周期结束时自动调用
  • 析构函数内置类型不做处理，自定义类型会调用它的析构
  • 析构函数可以显式写

小结

  1. 有资源清理(开空间)才需要析构函数；如Stack、Queue
  2. 有两种场景不需要显式析构，用默认生成的就OK了
  • ①没有资源清理，如Date
  • ②内置类型成员没有资源需要清理，剩下的都是自定义类型成员；如MyQueue


拷贝构造函数

概念

用同类型的对象拷贝初始化

三个特性

  1. 拷贝构造函数是构造函数的一个重载形式
  2. 拷贝构造函数的参数只有一个且必须是类类对象的引用，使用传值方式编译器直接报错，会引发无穷递归
  3. 未显式定义，编译器会默认生成拷贝构造函数

总结

  1. 一般情况下，不需要显式写析构函数，就不用写拷贝构造函数(值拷贝)
  2. 如果 内部有指针 或者 一些值指向资源，需要显式写析构函数释放，需要写构造完成深拷贝； 如Satck、Queue、List


赋值运算符重载

运算符重载

相等操作符重载函数(比较Date中的两个对象是否相等)

在全局中

在全局中写 operator== 函数，要屏蔽 Date类 中private，

那封装性如何保证？用 友元 和 重载成员函数 解决

这里讲的是重载成员函数，把 内置类型成员 公有，这样在全局中函数就能 访问 内置类型成员

在类中

注意点

在主函数中

this 和 *this 的区别

赋值运算符重载

赋值运算符重载格式

注意点

赋值运算符重载 和 拷贝构造函数 的区别

传值返回 和 传引用返回 的区别

传值返回 会生成当前对象的一个拷贝，拷贝一个临时对象

引用返回 生成某别名，出了作用域就销毁了

总结 虽然引用返回减少了拷贝，但出了函数作用域，返回对象还在才能用引用（在静态）

前置++ 和 后置++ 重载


const成员

含义

const修饰的是*this，本质上是改变this的类型

在哪用

  1. 运算符重载
  2. 不改变自身


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

不显式实现，编译器默认生成


日期类的实现

Date.h

#pragma once
 
#include<iostream>
#include<stdlib.h>
using namespace std;
 
class Date
{
  // 友元函数，可以访问私有
  friend ostream& operator<<(ostream& out, const Date& d);
  friend istream& operator>>(istream& in, Date& d);
 
public:
  // 构造函数
  Date(int year, int month, int day);
 
  // 打印
  void Print();
 
  // 运算符重载
  // 实现＜/＞，==就可以了，其他的复用（要建立栈帧，内联，不能声明和定义分离，在类里面定义就是内联）
  bool operator==(const Date& d) const;
  bool operator!=(const Date& d) const;
  bool operator>(const Date& d) const;
  bool operator>=(const Date& d) const;
  bool operator<(const Date& d) const;
  bool operator<=(const Date& d) const;
 
  static int GetMonthDay(int year, int month)
  {
    int GetMonthDayArr[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    if (month == 2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
    {
      return 29;
    }
    else return GetMonthDayArr[month];
  }
 
  // 检查日期是否正确
  bool checkDate()
  {
    if (_month < 1 || _month > 12 || _day <= 0 || _day > GetMonthDay(_year, _month)) return false;
    else return true;
  }
 
  // 日期 + 天数
  Date& operator+=(int day);
  Date operator+(int day) const;
 
  // 日期 - 天数
  Date& operator-=(int day);
  Date operator-(int day) const;
 
  // 前置++
  Date& operator++();
  // 后置++
  Date operator++(int) const;
 
  // 前置--
  Date& operator--();
  // 后置--
  Date operator--(int) const;
 
  // d1 - d2
  int operator-(const Date& d) const;
 
private:
  int _year;
  int _month;
  int _day;
};
 
// 流插入重载
ostream& operator<<(ostream& out, const Date& d);
// 流提取重载
istream& operator>>(istream& in, Date& d);

Date.cpp

#define _CRT_SECURE_NO_WARNINGS 1
 
#define _CRT_SECURE_NO_WARNINGS 1
 
#include"Date.h"
 
Date::Date(int year, int month, int day)
{
  //cout << "Date(int year, int month, int day)" << endl;
 
  _year = year;
  _month = month;
  _day = day;
}
 
void Date::Print()
{
  cout << _year << "-" << _month << "-" << _day << endl;
}
 
bool Date::operator==(const Date& d) const
{
  return  this->_year == d._year
    && this->_month == d._month
    && this->_day == d._day;
}
 
bool Date::operator!=(const Date& d) const
{
  return !(*this == d);
}
 
bool Date::operator>(const Date& d) const
{
  if (this->_year > d._year) return true;
  else if (this->_year == d._year && this->_month > d._month) return true;
  else if (this->_year == d._year && this->_month == d._month && this->_day > d._day) return true;
  return false;
}
 
bool Date::operator>=(const Date& d) const
{
  return *this > d || *this == d;
}
 
bool Date::operator<(const Date& d) const
{
  return !(*this >= d);
}
 
bool Date::operator<=(const Date& d) const
{
  return !(*this > d);
}
 
// 日期 + 天数
Date& Date::operator+=(int day)
{
  if (day < 0) return *this -= -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) const
{
  Date tmp = *this;
  tmp += day;
 
  return tmp;
}
 
Date& Date::operator-=(int day)
{
  if (day < 0) return *this += -day;
 
  _day -= day;
  while (_day <= 0)
  {
    --_month;
    if (_month == 0)
    {
      _month = 12;
      --_year;
    }
    _day += GetMonthDay(_year, _month);
  }
  return *this;
}
 
Date Date::operator-(int day) const
{
  Date tmp = *this;
  tmp -= day;
  return tmp;
}
 
// 前置++
Date& Date::operator++()
{
  *this += 1;
  return *this;
}
 
// 后置++
Date Date::operator++(int) const
{
  Date tmp = *this;
  tmp += 1;
  return tmp;
}
 
// 前置--
Date& Date::operator--()
{
  *this -= 1;
  return *this;
}
 
// 后置--
Date Date::operator--(int) const
{
  Date tmp = *this;
  tmp -= 1;
  return tmp;
}
 
int Date::operator-(const Date& d) const
{
  Date max = *this;
  Date min = d;
  int n = 0, flag = 1;
  if (*this < d)
  {
    max = d;
    min = *this;
    flag = -1;
  }
 
  while (min != max)
  {
    ++min;
    ++n;
  }
 
  return flag * n;
}
 
//ostream& Date::operator<<(ostream& out)
//{
//  out << _year << "-" << _month << "-" << _day << endl;
//  return out;
//}
 
ostream& operator<<(ostream& out, const Date& d)
{
  out << d._year << "-" << d._month << "-" << d._day << endl;
  return out;
}
 
istream& operator>>(istream& in, Date& d)
{
  cout << "请输入年、月、日：";
  in >> d._year >> d._month >> d._day;
  if (!d.checkDate()) {
    cout << "输入的日期无效，请重新输入。" << endl;
    in.clear(); // 清除错误标志
    in.ignore(numeric_limits<streamsize>::max(), '\n'); // 忽略错误输入直到下一个换行符
    return in;
  }
  return in;
}

Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
 
#include"Date.h"
void test1()
{
  Date d1(2024, 9, 26);
  Date d2(2024, 9, 26);
  bool ret1 = d1 > d2;
  bool ret2 = d1 >= d2;
  bool ret3 = d1 < d2;
  bool ret4 = d1 <= d2;
  bool ret5 = d1 == d2;
  bool ret6 = d1 != d2;
 
  cout << ret1 << endl;
  cout << ret2 << endl;
  cout << ret3 << endl;
  cout << ret4 << endl;
  cout << ret5 << endl;
  cout << ret6 << endl;
}
 
void test2()
{
  Date d1(2024, 9, 26);
  Date d2(2024, 9, 26);
 
  // += // 11-15
  Date tmp = d1 -= -100;
  d1.Print();
  //tmp.Print();
   + 
  //Date tmp2 = d2 + 50;
  //d2.Print();   // 9-26
  //tmp2.Print(); // 11-15
 
  //Date d3(2024, 9, 26);
  //Date d4(2024, 9, 26);
 
   -= //8-7
  //Date tmp3 = d3 -= 50;
  //d3.Print();
  //tmp3.Print();
   - 
  //Date tmp4 = d4 - 50;
  //d4.Print();
  //tmp4.Print();
}
 
void test3()
{
  Date d1(2024, 9, 26);
  Date d2(2024, 9, 26);
 
  Date tmp = --d1;
  d1.Print();
  tmp.Print();
 
  Date tmp2 = d2--;
  d2.Print();
  tmp2.Print();
}
 
void test4()
{
  Date d1(2024, 9, 26);
  Date d2(2024, 10, 1);
  int ret = d1 - d2;
  cout << ret << endl;
}
 
void test5()
{
  // 流插入和流提取 / 内置类型 直接用，为什么？
  //cout << "1";
  //printf("2");
  //cout << "3";
  //printf("4");
 
  Date d1(2024, 9, 26);
  //d1 << cout; // 类中
  cout << d1;   // 全局
}
 
void test6()
{
  Date d1(2024,9,27);
  Date d2(2024,10,1);
  cin >> d1 >> d2;
  cout << d1 << d2;
}
 
void test7()
{
  const Date d1(2024, 9, 27);
  Date d2(2024, 9, 27);
 
  bool d3 = d1 > d2;
  Date d4 = d1 - 10;
}
 
int main()
{
  //test1();
  //test2();
  //test3();
  //test4();
  //test5();
  //test6();
  test7();
}
文章标签：
编译器
C++
C语言
关键词：
C++类
C++对象
C++类对象
C++打怪类
C++打怪
白子寰
目录
相关文章
ephemerals__
|
12月前
|
编译器 C++ 容器
【c++11】c++11新特性（上）（列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式）
C++11为C++带来了革命性变化，引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式，initializer_list简化了容器多元素初始化；右值引用和移动语义优化了资源管理，减少拷贝开销；类新增移动构造和移动赋值函数提升性能；lambda表达式提供匿名函数对象，增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展，提升了开发效率与程序性能。
ephemerals__
468 12
hahaha无
|
10月前
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果：注意：类模板中的成员函数若是放在类外定义时，需要加模板参数列表。return 0;
hahaha无
253 0
hahaha无
|
10月前
|
存储 编译器 程序员
c++的类（附含explicit关键字，友元，内部类）
本文介绍了C++中类的核心概念与用法，涵盖封装、继承、多态三大特性。重点讲解了类的定义（`class`与`struct`）、访问限定符（`private`、`public`、`protected`）、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数（构造函数、析构函数、拷贝构造、赋值重载）以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员（变量与函数）、友元（友元函数与友元类）的概念及其使用场景，并简要介绍了内部类的特性。
hahaha无
397 0
预备女程序员a
|
编译器 C++
类和对象（中 ）C++
本文详细讲解了C++中的默认成员函数，包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系，如构造函数的主要任务是初始化对象，而非创建空间；析构函数用于清理资源；拷贝构造与赋值运算符的区别在于前者用于创建新对象，后者用于已存在的对象赋值。同时，文章还探讨了运算符重载的规则及其应用场景，并通过实例加深理解。最后强调，若类中存在资源管理，需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
预备女程序员a
304 1
预备女程序员a
|
编译器 C++
类和对象（下）C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化，尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中，`explicit`可禁用隐式转换。静态成员属类而非对象，受访问限定符约束。内部类是独立类，可增强封装性。匿名对象生命周期短，常用于临时场景。编译器会优化对象拷贝以提高效率。最后，鼓励大家通过重复练习提升技能！
预备女程序员a
276 0
平凡程序猿~
|
编译器 C++ 开发者
【C++篇】深度解析类与对象（下）
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
平凡程序猿~
354 0
羑悻的小杀马特
|
编译器 C语言 C++
类和对象的简述（c++篇）
类和对象的简述（c++篇）
羑悻的小杀马特
319 28
蓝易云
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨，我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性，而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧，对于提升C++编程水平至关重要。
蓝易云
235 16
预备女程序员a
|
存储 编译器 C++
类和对象（上）（C++）
本篇内容主要讲解了C++中类的相关知识，包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符（public、protected、private）的使用规则，以及class与struct的区别。同时分析了类实例化的概念，对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制，解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
预备女程序员a
297 1
ephemerals__
|
安全 C++
【c++】继承（继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员）
本文深入探讨了C++中的继承机制，作为面向对象编程（OOP）的核心特性之一。继承通过允许派生类扩展基类的属性和方法，极大促进了代码复用，增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式（public、protected、private）、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题，并对比了继承与组合的优缺点。最后总结指出，虽然继承提高了代码灵活性和复用率，但也带来了耦合度高的问题，建议在“has-a”和“is-a”关系同时存在时优先使用组合。
ephemerals__
841 6

热门文章

最新文章

  • 1
    读书笔记 effective c++ Item 31 把文件之间的编译依赖降到最低
  • 2
    C/C++代码覆盖工具gcov与lcov入门
  • 3
    C++实现队列
  • 4
    加载exe的PE信息并输出相关PE信息的一段c++代码
  • 5
    【C/C++ 随机数】深入探索C++随机数生成，random 模块的应用
  • 6
    c++ 静态持续变量
  • 7
    C++重要知识点小结---1
  • 8
    【计算机基础 ELF文件】深入探索ELF文件：C++编程中的关键组成部分
  • 9
    【C++ 泛型编程 高级篇】 C++ 14 模版元编程 遍历元组 编译期生成整数序列 std::index_sequence和std::make_index_sequence 使用指南（一）
  • 10
    C/C++网络编程基础知识超详细讲解第一部分（系统性学习day11）
  • 1
    给我介绍一些C++中引用的使用注意事项
    449
  • 2
    Visual C++运行库、.NET Framework和DirectX运行库的作用及常见问题解决方案，涵盖MSVCP140.dll丢失、0xc000007b错误等典型故障的修复方法
    1515
  • 3
    C++标准库、Windows API及Ubuntu API的综合应用
    266
  • 4
    msvcp100.dll,msvcp120.dll,msvcp140.dll，Microsoft Visual C++ 2015 Redistributable，Visual C++ 运行库安装
    816
  • 5
    无法启动0xc000007b怎么解决？Visual C++ 运行库下载
    1337
  • 6
    C++进阶（1）——继承
    452
  • 7
    01.C++基础语法
    368
  • 8
    大数相加（c/c++）
    466
  • 9
    基本二叉树与排序二叉树（C++源码）
    410
  • 10
    C++零拷贝网络编程实战：从理论到生产环境的性能优化之路
    447

    • 相关课程

    更多
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce
    • 下一篇
    开通oss服务