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

【c++】类和对象3

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

拷贝构造函数

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

  1. 拷贝构造函数是构造函数的一个重载形式。
    函数名相同，参数不同

先定义一个类

class Date
{
public:
  Date(int year = 1, 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 Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  // 内置类型
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1(2024, 1, 28);
  Date d2(d1);
  d1.Print();
  d2.Print();
  return 0;
}

使用拷贝构造函数将d1的值拷给d2.

为了更好的理解，我们可以先定义两个函数

void func1(Date d)
{
}
void func2(Date& rd)
{
}
int main()
{
  Date d1(2024, 1, 28);
  
  func1(d1);
  func2(d1);
  return 0;
}

在调试过程中我们发现调用func1的时候，他会调用类的拷贝构造函数，如果调用func2函数的话，我们发现他不会去调用拷贝构造函数，而C++规定自定义的类型都会调用拷贝构造

这里有两个问题？

1.为什么构造拷贝函数要用传引用？

上面的例子也说明了，直接传类对象的话，他会自动的去递归找类对象的拷贝构造函数，如果拷贝构造函数的参数也是类对象的话，他又会去递归找拷贝构造函数，形成无穷递归.而传引用实际就是他的拷贝构造函数.

2.为什么拷贝构造函数的参数要加const?

因为我们可能会出现以下情况

Date( Date& d)//拷贝构造函数
  {
    d._year = this->_year;
        d._month = this->_month;
        d._day = this->_day;
    /* _year = d._year;
    _month = d._month;
    _day = d._day;*/
  }

如果出现颠倒，编译器也不会报错

本来要把d2修改成d1,但是搞反，d1就会被修改成d2的值.

  1. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
  1. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象将内置类型按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
#include<iostream>
using namespace std;
class Date
{
public:
  Date(int year = 1, 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, 28);
  Date d2(d1);
  d1.Print();
  d2.Print();
  return 0;
}

我们删除掉拷贝构造函数，看编译器会不会自动生成

编译器的确在我们没有定义拷贝构造函数会自动生成来默认拷贝构造函数进行拷贝.

而自定义类型需要调用他自己的默认拷贝函数.

因为自定义类型中可能会设计到申请内存，不能使用浅拷贝（单单只是值的拷贝）

  1. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？
#include<iostream>
#include <stdlib.h>
using namespace std;
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(s1);
  return 0;
}

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

运算符重载

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

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

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

注意：

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

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

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

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

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

现。

这里有几个问题？

1.运算符重载函数可以定义在全局吗？

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

2.赋值运算符重载，检测是否自己给自己赋值返回.*this ：要复合连续赋值的含义.

3.用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。这里的拷贝还是属于浅拷贝，如果类成员变量中有栈类型，赋值就会有问题，两个指针指向同一块空间.析构两个类对象会出现问题.

4.为了防止自己给自己赋值的情况

修改前：

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

修改后：

Date& Date:: operator=(const Date& d)
{
  if (this != &d)//这里是地址
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
  return *this;
}

5.为什么有些类成员函数返回时用传引用返回，有些是传值返回？

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

因为一个是临时变量，出作用域要被销毁，所以不能通过引用返回，这个之前讲过在引用那节.

6.后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

日期类的实现

date.cpp

#include "date.h"
Date::Date(int year, int month, int day)
{
  _year = year;
  _month = month;
  _day = day;
}
void Date:: print()
{
  cout << _year << "." << _month << "." << _day<<endl;
}
Date::Date(const Date& d)
{
  
  _year = d._year;
  _month = d._month;
  _day = d._day;
}
Date::~Date()
{
  
  _year = 0;
  _month = 0;
  _day = 0;
}
int Date:: GetMonthDay(int year, int month)
{
  int arr[13] = { 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;
  }
  return arr[month];
}
Date& Date:: operator=(const Date& d)
{
  if (this != &d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
  return *this;
}
Date & Date::operator+=(int day)
{
  _day+= day;
  while (_day > GetMonthDay(_year,_month))
  {
    _day -= GetMonthDay(_year, _month);
    _month++;
    if (_month == 13)
    {
      _month = 0;
    }
  }
  return *this;
}
Date Date:: operator+(int day)
{
  Date tmp = *this;
  tmp._day += day;
  while (tmp._day > GetMonthDay(tmp._year, tmp._month))
  {
    tmp._day -= GetMonthDay(tmp._year, tmp._month);
    tmp._month++;
    if (tmp._month == 13)
    {
      tmp._month = 0;
    }
  }
  return tmp;
  
}
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 tmp = *this;
  tmp -= (day);
  return tmp;
}
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)
        {
          if (_day > d._day)
            return true;
        }
      }
    }
  }
  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));
}
Date& Date::operator++()
{
  *this = *this + 1;
  return *this;
}
Date Date:: operator++(int)
{
  Date tmp = *this;
  *this=*this+ 1;
  return tmp;
}
Date Date::operator--(int)
{
  Date tmp =*this;
  *this=*this-1;
  return tmp;
}
Date& Date:: operator--()
{
  *this = *this - 1;
  return *this;
}
int Date::operator-(const Date& d)
{
  Date max = *this;
  Date min = d;
  int flag = 1;
  if (min > (max))
  {
    max = d;
    min = *this;
    flag = -1;
  }
  int n = 0;
  while (max != min)
  {
    n++;
    min++;
  }
  return flag*n;
}

date.h

#pragma once
#include<iostream>
using namespace std;
class Date
{
public:
  // 获取某年某月的天数
  int GetMonthDay(int year, int month);
  // 全缺省的构造函数
  Date(int year = 1900, int month = 1, int day = 1);
  // 拷贝构造函数
  // d2(d1)
  Date(const Date& d);
  // 赋值运算符重载
  // d2 = d3 -> d2.operator=(&d2, d3)
  Date& operator=(const Date& d);
  // 析构函数
  ~Date();
  // 日期+=天数
  Date& operator+=(int day);
  // 日期+天数
  Date operator+(int day);
  // 日期-天数
  Date operator-(int day);
  // 日期-=天数
  Date& operator-=(int day);
  // 前置++
  Date& operator++();
  // 后置++
  Date operator++(int);
  // 后置--
  Date operator--(int);
  // 前置--
  Date& operator--();
  // >运算符重载
  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);
  // 日期-日期 返回天数
  int operator-(const Date& d);
  void print();
  
private:
  int _year;
  int _month;
  int _day;
};
文章标签：
编译器
C++
关键词：
C++对象
C++类对象
C++类
嘎嘎旺
目录
相关文章
羑悻的小杀马特
|
2天前
|
编译器 C语言 C++
类和对象的简述（c++篇）
类和对象的简述（c++篇）
羑悻的小杀马特
49 28
RossyYan
|
1月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。成员可以在派生类（继承该类的子类）中访问。成员，在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务，你需要掌握。
RossyYan
68 19
RossyYan
|
1月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类（头歌实践教学平台习题）【合集】
声明一个CPU类，包含等级（rank）、频率（frequency）、电压（voltage）等属性，以及两个公有成员函数run、stop。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中，类是创建对象的蓝图。类的声明定义了类的成员，包括数据成员（变量）和成员函数（方法）。一个简单的类声明示例如下： classMyClass{ public: int
RossyYan
50 13
RossyYan
|
1月前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用（头歌实践教学平台习题）【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括： 1. **类的继承关系基础概念**：介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**：详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**：解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类，添加特定属性并测试这些类的功能。最终通过创建教师和助教实例，验证代码
RossyYan
51 5
RossyYan
|
1月前
|
存储 算法 搜索推荐
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类（头歌实践教学平台习题）【合集】
1. **相关排序和查找算法的原理**：介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**：讲解如何定义`Array`类，包括类的声明和实现，以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**：探讨内存管理和正确访问数组元素的方法，确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**：解释排序和查找函数的参数传递方式及返回值处理，确保函数功能正确实现。 通过掌握这些知识，可以顺利地将排序和查找算法封装到`Array`类中，并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
RossyYan
40 5
RossyYan
|
1月前
|
Serverless 编译器 C++
【C++面向对象——类的多态性与虚函数】计算图像面积（头歌实践教学平台习题）【合集】
本任务要求设计一个矩形类、圆形类和图形基类，计算并输出相应图形面积。相关知识点包括纯虚函数和抽象类的使用。 **目录：** - 任务描述 - 相关知识 - 纯虚函数 - 特点 - 使用场景 - 作用 - 注意事项 - 相关概念对比 - 抽象类的使用 - 定义与概念 - 使用场景 - 编程要求 - 测试说明 - 通关代码 - 测试结果 **任务概述：** 1. **图形基类（Shape）**：包含纯虚函数 `void PrintArea()`。 2. **矩形类（Rectangle）**：继承 Shape 类，重写 `Print
RossyYan
48 4
RossyYan
|
1月前
|
设计模式 IDE 编译器
【C++面向对象——类的多态性与虚函数】编写教学游戏：认识动物（头歌实践教学平台习题）【合集】
本项目旨在通过C++编程实现一个教学游戏，帮助小朋友认识动物。程序设计了一个动物园场景，包含Dog、Bird和Frog三种动物。每个动物都有move和shout行为，用于展示其特征。游戏随机挑选10个动物，前5个供学习，后5个用于测试。使用虚函数和多态实现不同动物的行为，确保代码灵活扩展。此外，通过typeid获取对象类型，并利用strstr辅助判断类型。相关头文件如&lt;string&gt;、&lt;cstdlib&gt;等确保程序正常运行。最终，根据小朋友的回答计算得分，提供互动学习体验。 - **任务描述**：编写教学游戏，随机挑选10个动物进行展示与测试。 - **类设计**：基类
RossyYan
32 3
ephemerals__
|
3月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
89 2
ephemerals__
|
3月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
156 5
ephemerals__
|
3月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
170 4