c++初阶------类和对象(六大默认构造函数的揭破)-2

简介: c++初阶------类和对象(六大默认构造函数的揭破)

c++初阶------类和对象(六大默认构造函数的揭破)-1

https://developer.aliyun.com/article/1499142


  1. 深拷贝
#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
  Stack(int capacity = 3)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (_a == NULL)
    {
      perror("malloc");
      exit(-1);
    }
    _capacity = capacity;
    _top = 0;

  }
  //深拷贝
  Stack(const Stack& st)
  {
    _a = (int*)malloc(sizeof(int) * st._capacity);
    if (_a == NULL)
    {
      perror("malloc");
      exit(-1);
    }
    _capacity = st._capacity;
    _top = st._top;

  }
private:
  int *_a;
  int _top;
  int _capacity;
};
int main()
{
  Stack d1(5);
  Stack d2(d1);
  return 0;
}

创建两个一模一样的空间,深拷贝就是要进行一比一的复制,浅拷贝在这里会公用一块地址,

浅拷贝的示意图:

注意:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请

时,则拷贝构造函数是一定要写的,否则就是浅拷贝。

简单的来说,如果涉及到地址就要考虑一下是否需要深拷贝,如是简单的拷贝值的化,拷贝函数可以写也可以不写,不写的话,编译器会默认构造一个拷贝函数,(浅拷贝)


#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
  //构造函数
  Stack(int capacity = 3)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (_a == NULL)
    {
      perror("malloc");
      exit(-1);
    }
    _capacity = capacity;
    _top = 0;

  }
  //深拷贝
  Stack(const Stack& st)
  {
    _a = (int*)malloc(sizeof(int) * st._capacity);
    if (_a == NULL)
    {
      perror("malloc");
      exit(-1);
    }
    _capacity = st._capacity;
    _top = st._top;

  }
  //析构函数
  ~Stack()
  {
    free(_a);
    cout << "释放了空间" << endl;
    _a = nullptr;
    _top = 0;
    _capacity = 0;
  }
private:
  int *_a;
  int _top;
  int _capacity;
};
class MyQueue
{
private:
  Stack _d1;
  Stack _d2;
  int _size = 0;

};
int main()
{
  MyQueue q1;
  MyQueue q2(q1);//调用了拷贝构造
  return 0;
}

这里的情况就是q1会开辟成员变量的空间,调用了MyQueue的默认构造函数,然后_d1和_d2调用Stack的自定义的默认构造.

q1和q2之间的联系,之间调用的是拷贝函数,调用MyQueue的默认拷贝构造函数,而Stack调用的就是自定义的拷贝构造函数

一些场合

自定义当返回值

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
  //构造函数
  Stack(int capacity = 3)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (_a == NULL)
    {
      perror("malloc");
      exit(-1);
    }
    _capacity = capacity;
    _top = 0;

  }
  //深拷贝
  Stack(const Stack& st)
  {
    cout << "拷贝" << endl;
    _a = (int*)malloc(sizeof(int) * st._capacity);
    if (_a == NULL)
    {
      perror("malloc");
      exit(-1);
    }
    _capacity = st._capacity;
    _top = st._top;

  }
  //析构函数
  ~Stack()
  {
    free(_a);
    cout << "释放了空间" << endl;
    _a = nullptr;
    _top = 0;
    _capacity = 0;
  }
private:
  int *_a;
  int _top;
  int _capacity;
};
class MyQueue
{
private:
  Stack _d1;
  Stack _d2;
  int _size = 0;

};
Stack fun()
{
  Stack d1;
  return  d1;
}
int main()
{
  fun();
  return 0;
}

可以看出返回值,不会直接返回d1,而是d1的拷贝,也就是d1的临时对象

如果换成

Stack& fun()
{
  static Stack d1;
  return  d1;
}

可以把图中的Test函数换成我们的fun函数,看懂了就可以了。

为了提高程序效率,一般对象传参时,尽量使用引用类型,返回时根据实际场景,能用引用尽量使用引用。

赋值运算符重载

运算符重载

前面我们学习C语言,知道内置类型(int 、char…)可以直接使用各种运算符,但是自定义类型是不可以的

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
  //构造函数
  Date(int year, int month, int day)
  {
    cout << "构造函数" << endl;
    _year = year;
    _month = month;
    _day = day;
  }
  //浅拷贝
  Date(const Date& d1)
  {
    cout << "拷贝" << endl;
    _year = d1._year;
    _month = d1._month;
    _day = d1._day;
  }
  //析构函数
  ~Date()
  {
    cout << "析构函数" << endl;
  }
  int _year;
  int _month;
  int _day;
};
//相等
bool Equal(Date x, Date y)
{
  return x._year == y._year
    && x._month == y._month
    && x._day == y._day;
}
//大于
bool Greater(Date x, Date y)
{
  if (x._year > y._year)
  {
    return true;
  }
  else if (x._year == y._year && x._month > y._month)
  {
    return true;
  }
  else if (x._year == y._year && x._month == y._month && x._day > y._day)
  {
    return true;
  }
  else
    return false;
}
int main()
{
  Date a(2024,1,3);
  Date b(2024, 1, 5);
  cout << Equal(a, b) << endl;
  return 0;
}

我们如果要比较这些自定义类型就有可能要写成函数,但是不太方便,所以c++改变了一些

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

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

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

//相等
bool operator==(Date x, Date y)
{
  return x._year == y._year
    && x._month == y._month
    && x._day == y._day;
}
//大于
bool operator>(Date x, Date y)
{
  if (x._year > y._year)
  {
    return true;
  }
  else if (x._year == y._year && x._month > y._month)
  {
    return true;
  }
  else if (x._year == y._year && x._month == y._month && x._day > y._day)
  {
    return true;
  }
  else
    return false;
}

函数名就更改过成这样的,使用这个函数方法有两种,一种是直接写函数名直接调用

另一种

这里使用a ==b 就是 operator==(x, y)的简写,需要注意的是 << 的优先级比 == 、>…高。

函数重载和运算符重载两者毫不相关,函数重载允许参数不同的同名函数,而运算符重载允许自定义类型直接使用运算符

我们还可以在类里面写

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
  //构造函数
  Date(int year, int month, int day)
  {
    cout << "构造函数" << endl;
    _year = year;
    _month = month;
    _day = day;
  }
  //浅拷贝
  Date(const Date& d1)
  {
    cout << "拷贝" << endl;
    _year = d1._year;
    _month = d1._month;
    _day = d1._day;
  }
  //析构函数
  ~Date()
  {
    cout << "析构函数" << endl;
    cout << _year << '-' << _month << '-' << _day << endl;
  }

  //相等
  bool operator==(Date& y)
  {
    return _year == y._year
      && _month == y._month
      &&_day == y._day;
  }
private:
  int _year;
  int _month;
  int _day;
  //大于
  bool operator>(Date& y)
  {
    if (_year > y._year)
    {
      return true;
    }
    else if (_year == y._year && _month > y._month)
    {
      return true;
    }
    else if (_year == y._year && _month == y._month && _day > y._day)
    {
      return true;
    }
    else
      return false;
  }
  void exchengtime(int* a)
  {
    if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
      a[2] = 29;
    else
      a[2] = 28;
  }
  Date& operator+=(int day)//这里返回引用是防止对象拷贝返回
  {
    int a[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    _day += day;
    exchengtime(a);
    while (_day > a[_month])
    {
      _day -= a[_month];
      _month++;
      if (_month > 12)
      {
        _year++;
        exchengtime(a);
        _month %= 12;
      }

    }
    return *this;
  }
};
int main()
{
  Date a(2024,1,3);
  Date b(2024, 1, 5);
  cout << (a == b) << endl; // a.operator==(b)  -> a.operator==(&a, b)
  a += 363;
  return 0;
}

赋值运算符重载

有时候就是我们会看见到i = 5; j = 20;

我们有时需要对对象进行赋值

#include<iostream>
//using namespace std;
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
  //构造函数
  Date(int y, int m, int d)
  {
    _year = y;
    _month = m;
    _day = d;

  }
  //拷贝
  Date(const Date& d1)
  {
    _year = d1._year;
    _month = d1._month;
    _day = d1._day;
  }
  //析构函数
  ~Date()
  {
    cout << _year << endl;
    cout << _month << endl;
    cout << _day << endl;
  }
  Date& operator=(const Date& d1)
  {
    //防止自己给自己赋值(特别是深拷贝的时候)
    if (this != &d1)
    {
      _year = d1._year;
      _month = d1._month;
      _day = d1._day;
    }
    return *this;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  int a = 10;
  cout << a << endl;
  Date d1(2024, 1, 15);
  Date d2(2024,1,16);
  Date d3(2024,1,17);
  d3 = d1 = d2;


  return 0;
}

这样就可以不使用到拷贝构造,

还需要注意的是operator=是默认成员函数,不写编译器会默认生成,跟拷贝构造的行为类似,对内置类型进行值拷贝,自定义类型调用他的赋值

赋值运算符重载格式:

1. 参数类型:const T&,传递引用可以提高传参效率

2. 返回值类型:T&,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值

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

4. 返回*this :要复合连续赋值的含义

全部代码总和:

test.h

#pragma once
#include<iostream>
#include<assert.h>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
  //构造函数
  Date(int y = 2024, int m = 1, int d = 15);
  //拷贝
  Date(const Date& d1);
  //析构函数
  ~Date();

  int Getmonthday(int year, int month);

  bool operator<(const Date& d1);
  bool operator>(const Date& d1);
  bool operator==(const Date& d1);
  bool operator<=(const Date& d1);
  bool operator>=(const Date& d1);

  Date& operator=(const Date& d1);
  Date& operator+=(int day);
  Date operator+(int day);
  
private:
  int _year;
  int _month;
  int _day;
};

test.cpp

#include"Date.h"
Date::Date(int y, int m, int d)
{
  _year = y;
  _month = m;
  _day = d;
  if (_year < 0 || _month < 1 || _month >12 || _day > Getmonthday(_year, _month) || _day < 0)
  {
    cout << _year << "-" << _month << "-" << _day << endl;
    cout << "非法日期" << endl;
    exit(-1);
  }

}
int Date::Getmonthday(int year, int month)
{
  int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
  if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
  {
    monthday[2] = 29;
  }
  return monthday[month];

}
//拷贝
Date::Date(const Date& d1)
{
  _year = d1._year;
  _month = d1._month;
  _day = d1._day;
}
//析构函数
Date::~Date()
{
  cout << _year << endl;
  cout << _month << endl;
  cout << _day << endl;
}
Date& Date::operator=(const Date& d1)
{
  //防止自己给自己赋值(特别是深拷贝的时候)
  if (this != &d1)
  {
    _year = d1._year;
    _month = d1._month;
    _day = d1._day;
  }
  return *this;
}
Date& Date::operator+=(int day)
{
  *this = *this + day;
  return *this;
}
Date Date::operator+(int day)
{
  Date tmp(*this);
  int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
  tmp._day += day;
  if ((tmp._year % 4 == 0 && tmp._year % 100 != 0) || (tmp._year % 400 == 0))
  {
    monthday[2] = 29;
  }
  else
  {
    monthday[2] = 28;
  }
  while (tmp._day - monthday[tmp._month] > 0)
  {
    
    tmp._day -= monthday[tmp._month];
    tmp._month++;
    if (tmp._month > 12)
    {
      tmp._month %= 12;
      tmp._year++;
      if ((tmp._year % 4 == 0 && tmp._year % 100 != 0) || (tmp._year % 400 == 0))
      {
        monthday[2] = 29;
      }
      else
      {
        monthday[2] = 28;
      }
    }
  }
  return tmp;


}
bool Date::operator<(const Date& d1)
{
  if (_year < d1._year)
  {
    return true;
  }
  if (_year == d1._year && _month < d1._month)
  {
    return true;
  }
  if (_year == d1._year && _month == d1._month && _day < d1._day)
  {
    return true;
  }
  return false;

}
bool Date::operator==(const Date& d1)
{
  return _year == d1._year && _month == d1._month && _day == d1._day;
}
bool Date::operator<=(const Date& d1)
{
  return (*this) < d1 || (*this) == d1;
}
bool Date::operator>(const Date& d1)
{
  return !((*this) <= d1);
}
bool Date::operator>=(const Date& d1)
{
  return !((*this)< d1);
}

test1.cpp

#include"Date.h"
int main()
{
  Date d1(2024, 1, 3);
  Date d2(2024,1,16);
  Date d3(2020,1,17);
  int a = d1 == d2;
  cout << a << endl;
  a = d1 >= d2;
  cout << a << endl;
  a = d1 <= d2;
  cout << a << endl;
  d3 += 366;
  return 0;
}

需要注意的是代码中的**operator+(int day)**函数 和 **operator+=(int day)**函数的效率是很低效的

这张图里面可以说明,上图的代码的对象拷贝是次数多,造成了效率的低效,

对象的赋值进行了一次拷贝对象

*this + day 创建了一个临时的 Date 对象,表示当前对象的值加上 day 天的结果。*this = … 将上面提到的临时对象的值赋给了当前对象 *this。这个赋值操作涉及到对象的拷贝。赋值操作符 = 的行为是根据类的定义而定的,,它会执行对象的成员逐个拷贝。


实现 - 和-=

这里的实现方法和上面的方法是不一样的,

Date& Date::operator-=(int day)
{
  _day -= day;
  int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
  if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
  {
    monthday[2] = 29;
  }
  else
  {
    monthday[2] = 28;
  }
  while (_day <= 0)
  {
    _month--;
    
    if (_month <= 0)
    {
      _year--;
      if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
      {
        monthday[2] = 29;
      }
      else
      {
        monthday[2] = 28;
      }
      _month = 12;
    }
    _day += monthday[_month];

  }
  return *this;


}
Date Date::operator-(int day)
{
  Date tmp(*this);
  tmp -= day;
  return tmp;


}


可以看看这里,这里的情况就是,在operator-函数里面套用operator-=,这样的效率就变高了

实现++

前置++

Date& Date::operator+=(int day)
{
  _day += day;
  int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
  if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
  {
    monthday[2] = 29;
  }
  else
  {
    monthday[2] = 28;
  }
  while (_day - monthday[_month] > 0)
  {
    _day -= monthday[_month];
    _month++;
    if (_month > 12)
    {
      _month %= 12;
      _year++;
      if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
      {
        monthday[2] = 29;
      }
      else
      {
        monthday[2] = 28;
      }
    }

  }
  return *this;
}
Date& Date::operator++()
{
  *this += 1;
  return *this;
}

后置++

后置++不能和上面写的一样,因为要构成重载,我们只能从参数那里下手,不然就会无法构成重载,

Date Date::operator++(int)
{
  Date tmp(*this);
  *this += 1;
  return tmp;

}

编译器链接的时候,函数的名字只和函数的名字和函数的参数类型有关,跟函数的形参名字没有关系。

就是说c++的函数在链接的时候有自己的函数名修饰规则,


c++初阶------类和对象(六大默认构造函数的揭破)-3

https://developer.aliyun.com/article/1499148

相关文章
|
7天前
|
设计模式 安全 编译器
【C++11】特殊类设计
【C++11】特殊类设计
26 10
|
12天前
|
C++
C++友元函数和友元类的使用
C++中的友元(friend)是一种机制,允许类或函数访问其他类的私有成员,以实现数据共享或特殊功能。友元分为两类:类友元和函数友元。类友元允许一个类访问另一个类的私有数据,而函数友元是非成员函数,可以直接访问类的私有成员。虽然提供了便利,但友元破坏了封装性,应谨慎使用。
41 9
|
7天前
|
存储 编译器 C语言
【C++基础 】类和对象(上)
【C++基础 】类和对象(上)
|
15天前
|
编译器 C++
【C++】string类的使用④(字符串操作String operations )
这篇博客探讨了C++ STL中`std::string`的几个关键操作,如`c_str()`和`data()`,它们分别返回指向字符串的const char*指针,前者保证以&#39;\0&#39;结尾,后者不保证。`get_allocator()`返回内存分配器,通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组,不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量,表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
|
15天前
|
C++
【C++】string类的使用④(常量成员Member constants)
C++ `std::string` 的 `find_first_of`, `find_last_of`, `find_first_not_of`, `find_last_not_of` 函数分别用于从不同方向查找目标字符或子串。它们都返回匹配位置,未找到则返回 `npos`。`substr` 用于提取子字符串,`compare` 则提供更灵活的字符串比较。`npos` 是一个表示最大值的常量,用于标记未找到匹配的情况。示例代码展示了这些函数的实际应用,如替换元音、分割路径、查找非字母字符等。
|
15天前
|
存储 C++
【C++】string类的使用③(非成员函数重载Non-member function overloads)
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容,包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容,成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接,关系运算符(如`==`, `&lt;`等)用于比较字符串,以及`swap`非成员函数。此外,还介绍了`getline`函数,用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用,并给出了多个示例代码。
|
20天前
|
C++
【C++】日期类Date(详解)②
- `-=`通过复用`+=`实现,`Date operator-(int day)`则通过创建副本并调用`-=`。 - 前置`++`和后置`++`同样使用重载,类似地,前置`--`和后置`--`也复用了`+=`和`-=1`。 - 比较运算符重载如`&gt;`, `==`, `&lt;`, `&lt;=`, `!=`,通常只需实现两个,其他可通过复合逻辑得出。 - `Date`减`Date`返回天数,通过迭代较小日期直到与较大日期相等,记录步数和符号。 ``` 这是236个字符的摘要,符合240字符以内的要求,涵盖了日期类中运算符重载的主要实现。
|
15天前
|
C++
C++】string类的使用③(修改器Modifiers)
这篇博客探讨了C++ STL中`string`类的修改器和非成员函数重载。文章介绍了`operator+=`用于在字符串末尾追加内容,并展示了不同重载形式。`append`函数提供了更多追加选项,包括子串、字符数组、单个字符等。`push_back`和`pop_back`分别用于在末尾添加和移除一个字符。`assign`用于替换字符串内容,而`insert`允许在任意位置插入字符串或字符。最后,`erase`函数用于删除字符串中的部分内容。每个函数都配以代码示例和说明。
|
15天前
|
安全 编译器 C++
【C++】string类的使用②(元素获取Element access)
```markdown 探索C++ `string`方法:`clear()`保持容量不变使字符串变空;`empty()`检查长度是否为0;C++11的`shrink_to_fit()`尝试减少容量。`operator[]`和`at()`安全访问元素,越界时`at()`抛异常。`back()`和`front()`分别访问首尾元素。了解这些,轻松操作字符串!💡 ```
|
15天前
|
存储 编译器 Linux
【C++】string类的使用②(容量接口Capacity )
这篇博客探讨了C++ STL中string的容量接口和元素访问方法。`size()`和`length()`函数等价,返回字符串的长度;`capacity()`提供已分配的字节数,可能大于长度;`max_size()`给出理论最大长度;`reserve()`预分配空间,不改变内容;`resize()`改变字符串长度,可指定填充字符。这些接口用于优化内存管理和适应字符串操作需求。