当前位置: 首页 > news >正文

【C++】类和对象(中)(万字详解)

类与对象
在C++中,类和对象的出现,是为了完善C语言的不足,在struct的基础上慢慢进步,慢慢完善,将其的功能发挥到最大,也方便使用!

类与对象可谓是非常的重要了,所以在这里我们分为几篇来学习类与对象,在接下来的学习中,我们需要反复琢磨,去好好复习,才能学的好,学的牢,学的扎实!


目录

前言

一、🏠类的六个默认成员函数

 1.🚀构造函数

         1.😯定义 

2.😯特征

2.🚀默认构造函数

3.🚀析构函数

1.😯概念

2.😯特性

4.🚀拷贝构造函数

1.😯概念

2.😯特性

5.🚀运算符重载

1.😯为什么要重载运算符

2.😯赋值运算符重载格式

3.😯加法的实现

6.🚀赋值运算符重载

1.😯赋值运算符重载格式

2.😯拷贝构造和赋值重载

7.🚀<<和>>运算符重载

8.🚀const修饰的成员函数

1.😯const修饰的权限问题

2.😯取地址重载

🏠总结


前言

有没有这种情况,在C语言阶段编写数据结构的时候,是不是多多少少会忘记初始化??

结果定义以后,忘记Init??在一顿操作以后,总会忘记destroy??

对,我们多多少少会忘记,所以在C++类和对象中呢,就出现了这样的函数:构造函数和析构函数


一、🏠类的六个默认成员函数

默认成员函数:用户没有显式实现,编译器会生成的成员函数称为默认成员函数。

 1.🚀构造函数

    1.😯定义 

   构造函数,他不是真正去构造一个函数,只是向我们上面所说的,去初始化一个对象。

class Date
{
public:
 void Init(int year, int month, int day)
 {
  _year = year;
  _month = month;
  _day = day;
 }

 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }

private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 d1.Init(2022, 7, 5);
 d1.Print();
 Date d2;
 d2.Init(2022, 7, 6);
 d2.Print();

 return 0; 
}

      对于Date类,可以通过 Init 公有方法给对象设置日期,但如果每次创建对象时都调用该方法设置 信息,未免有点麻烦,那能否在对象创建时,就将信息设置进去呢?

构造函数 是一个 特殊的成员函数, 名字与类名相同 , 没有返回值 创建类类型对象时由编译器 自动调用 ,以保证每个数据成员都有 一个合适的初始值,并且在对象整个生命周期内只调用一次
所以有了构造函数以后,就可以直接这样:


class Date
{
public:
 //构造函数
 Data(int year, int month, int day)
 {
  _year = year;
  _month = month;
  _day = day;
 }
   ......
};

int main()
{
 Date d1(2022, 7, 5);
 d1.Print();
 Date d2(2022, 7, 6);
 d2.Print();

 return 0; 
}

2.😯特征

 构造函数可以重载(重载(点击链接有详细解释),函数名相同,参数不同就构成重载)
为什么要构成重载呢? 目的是为了实现多种初始化的方式:
  Date(int year, int month, int day)
     {
          _year = year;
          _month = month;
          _day = day;
     }

  Date()
     {
          _year = 0;
          _month = 0;
          _day = 0;
     }

   Date(int year=1, int month=1, int day=1)
     {
          _year = year;
          _month = month;
          _day = day;
     }

三种初始化的函数都构成函数重载,但是第二个和第三个却不能同时在一起使用,因为全缺省和无参数是一种情况,当调用时,会发生二义性,运行失败:

int main()
{
 Date d1(2022, 7, 5);
 Date d2(2022, 7, 6);
// 无参数时,要这样调用,不可以Data d3();,会与函数声明发生冲突
//,就相当于 Data func();,是错误的
 Date d3;

 return 0; 
}
如果类中没有显式定义构造函数,则 C++ 编译器会自动生成一个无参的默认构造函数,一旦
用户显式定义编译器将不再生成。
那么编译器自动生成的无参默认构造函数可以直接使用吗?
没有类中显示的构造函数,使用默认的构造函数:
class Date
{
public:
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }

private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 d1.Print();
}

默认构造函数对内置类型不进行处理,只对自定义类型进行处理。
所以需要我们自己去写构造函数!
内置类型:语言自己提供的类型:int,double,char....
自定义类型:class/struct  + stack/queue/person....  类或者结构体等...
所以,我们自己不写,编辑器会自动生成,内置不处理,只处理自定义类型。
但是需要看需求才来决定是否需要自己写,不能光看内置类型还是自定义类型
面向需求:编译器默认生成就可以满足,就不用自己写,不满足就需要自己写
class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity = 4)" << endl;

		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}

		_top = 0;
		_capacity = capacity;
	}

	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue {
public:
	void push(int x)
	{
		_pushST.Push(x);
	}

	Stack _pushST;
	Stack _popST;

	//size_t _size;
};

对于MyQueue这个类中,有Stack _pushST;  Stack _popST;两个自定义类型,发现在MyQueue类中没有显示的构造函数,就会使用自定义类型默认的构造函数,回Stack中使用构造函数。

那么说不对内置类型处理,那如果成员变量中,既有内置类型,又有自定义类型,那应该怎么办?

利用缺省值来处理内置类型:
class MyQueue {
public:
	void push(int x)
	{
		_pushST.Push(x);
	}

	Stack _pushST;
	Stack _popST;

	size_t _size=0;
};

这样既有内置类型,又有自定义类型时,就可以调用构造函数初始化了。

2.🚀默认构造函数

无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为
是默认构造函数。
举例说明:
class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity = 4)" << endl;

		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}

		_top = 0;
		_capacity = capacity;
	}

	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue {
public:
	void push(int x)
	{
		_pushST.Push(x);
	}

	Stack _pushST;
	Stack _popST;

	size_t _size=0; //这里不是初始化,是缺省值
};

int main()
{
	MyQueue q;
	return 0;
}

在定义一个MyQueue类的 对象q时,类中没有已经写好的构造函数,就要使用编译器默认的构造函数,那么内置类型有缺省值,自定义类型也要使用默认构造函数,默认构造函数只有三种情况:无参构造函数、全缺省构造函数、我们没写默认给出的,stack类中,刚好时全缺省作为了默认构造函数,有默认构造函数,可以使用。

但如果改变一个条件,将stack缺省值去掉:

还可以使用吗?当然不可以!

首先,Queue类创建对象初始化时,我们发现Queue本身没有构造函数,那么他就会调用编译器提供的默认构造 ,内置类型不处理,但有缺省值,自定义类型调用默认构造,但发现Stack类中,没有默认构造函数(无参构造函数、全缺省构造函数、我们没写默认给出的),因为自己写了,stack类就不会自己提供。所以无法初始化。

若使用编译器自己提供的,能满足我们需求吗?

 可以看出,默认提供的并没有将数组开辟空间,不能满足我们的需求。

结论:面向需求:编译器默认生成就可以满足,就不用自己写,不满足就需要自己写

那我们可不可以直接把    int* _a = (int*)malloc(sizeof(int)*4);  malloc作为缺省值呢?

居然发现是可以的,但是有坏处是,无法调试他是否开辟成功。


3.析构函数

1.概念

那么定义类时,构造函数会自动初始化,

那结束时,有没有自动destroy,自动清理内存空间的函数呢?

当然有:

析构函数 :与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由
编译器完成的,而是 对象在销毁时会自动调用析构函数,完成对象中资源的清理工作

2.特性

1. 析构函数名是在类名前加上字符 ~ 。(~这个符号在C语言里面是二进制取反)
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。 注意:析构
函数不能重载,因为没有参数,所以不存在析构函数。
4. 对象 生命周期 结束时, C++ 编译系统系统自动调用析构函数。
    析构函数在对象生命周期结束时自动调用,生命周期得具体看,如果在局部域(函数内部),则函数调用完毕后,就会结束局部变量的生命周期,全局域,malloc(手动结束)。
class Stack
{
public:

   //析构函数名是在类名前加上字符 ~
	~Stack()
	{
		free(_a);
        _a=nullptr;
        _top=_capacity=0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

析构函数也是一样的,类比构造函数。如果自己没写,那么编译器就会自动生成,且内置类型不处理,自定义类型处理。就比如 int*_a,编译器他不清楚是一个单纯的指针,还是它指向动态内存空间,不知道应该怎么处理。

至于要不要自己写,就要看默认的,即编译器自动生成的满不满足我们的需求。


4.拷贝构造函数

1.概念

首先要知道,拷贝构造函数也是构造函数的重载。

那在创建对象时,可否创建一个与已存在对象一模一样的新对象呢?

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

举例:日期类:

class Date
{
public:
    //构造函数
    Date(int year = 1900, 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(2022, 10, 10);
    Date d2(d1); //拷贝d1
    d1.print();
    d2.print();
    return 0;
}

2.特性

拷贝构造函数也是特殊的成员函数,其特征如下:
1. 拷贝构造函数是构造函数的一个重载形式。函数名相同,参数不同。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,因为会引发无穷递归调用。
发生递归的原因:
Date(Date d)  //去掉引用,就是传值调用
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}
传值调用:当调用拷贝构造函数时,
形参是实参的一份临时拷贝
调用拷贝构造Date d2(d1);,先得传参,传参调用完拷贝构造以后,本身又要调用拷贝构造,而后又要传参,然后一直自己调用自己,导致一直递归下去......

那么传地址可不可以?可以,但不就麻烦了吗?
Date(Date *d)  //去掉引用,就是传值调用
{
    _year = d->_year;
    _month = d->_month;
    _day = d->_day;
}

所以还是引用是最好的方式!

3.拷贝构造函数只有单个形参,该形参是对本类类型对象的引用,一般常用const修饰

为什么要加const呢?

Date(const  Date & d)  //去掉引用,就是传值调用
{
    _year = d._year;
 
  d._month=_month ; //有时候会写反,而改变了原本对象的值。
    _day = d._day;
}

 Date d2(d1); //拷贝d1

所以加了const以后,就不能改变d1原对象了

4. 若未显示定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定
义类型是调用其拷贝构造函数完成拷贝的。所以内置类型处理,自定义类型不处理,自定义类型可能复杂多变,需要自己写拷贝函数,这样就叫 深拷贝。
浅拷贝: 自己没有写,使用默认的  (日期类)
class Date
{
public:
   //构造函数
 Date(int year = 1900, int month = 1, int day = 1)
 {
 cout << "构造函数" << endl; //验证调用所需
 _year = year;
 _month = month;
 _day = day;
 }

private:
 int _year;
 int _month;
 int _day;
};

int main()
{
    Date d1(2022, 10, 10);
    Date d2(d1); //拷贝d1
    return 0;
}

是可以实现我们想要的功能的,所以不需要我们自己写。

举例:(栈类)

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity = 4)" << endl;

		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}

		_top = 0;
		_capacity = capacity;
	}
	 //析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	Stack s2(s1);
}

当使用默认拷贝函数时,是否能实现我们想要的需求:

 

 这是怎么了??编译器自己提供的默认拷贝构造函数居然把s1拷贝到s2类中时,两个类中的指针变量指向了同一块空间!!

那么,栈的特性就是先进后出,所以s2先调用析构函数,把空间清理了,然后s1再去调用析构函数,又去清理,这不是瞎搞嘛,造成内存重复释放!

所以默认的拷贝构造函数解决不了我们的需求,需要我们自己写。

//st2(st1)拷贝构造
	Stack(const Stack& st)
	{
		cout << "Stack(const Stack& st)" << endl;

		_a = (int*)malloc(sizeof(int)*st._capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_a, st._a, sizeof(int)*st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

 即解决了指针重复指向一块空间,又把已经创建好的s1对象和其中的内容都拷贝到了s2。

 总结:需要写析构函数的类,都需要写深拷贝的拷贝构造,如:Stack

不需要写析构函数的类,默认生成的浅拷贝的拷贝构造就可以用 。如:Date/MyQueue

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

5.运算符重载

1.为什么要重载运算符

为了让自定义类型可以使用 运算符

对于日期类,我们会经常用到,某个日期加多少天来得到另一个日期。

所以日期需要加减,也需要比较,那么使用+  =   -  ,在C++中,就需要运算符重载,与函数重载没有关系。

2.赋值运算符重载格式

返回值+operator+运算符 +(所需参数),参数个数就是参与运算符的参数个数

class Data
{
public:
	Data(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

bool operator==(Data& d1,Data& d2)
	{
		return d1._year == d2._year
			&& d1._month == d2._month
			&& d1._day == d2._day;
	}

int main()
{
	Data d1(2022, 10, 11);
	Data d2(2023, 1, 1);
    d1==d2;//可以显式调用 operator==(d1,d2);
	cout << (d1 == d2) << endl;
	cout << (d1 > d2) << endl;
}

1.定义运算符重载时,参数为引用的好处是,不需要调用拷贝函数,若是传值,参数为对象,则需要拷贝对象,调用拷贝函数。

2.定义在类外,需要将类的成员变量设置为公开,会造正麻烦,那么我们直接就定义到了类的内部。

3.若直接放入类的内部定义运算符重载,则会出现问题:

class Data
{
public:
	Data(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

      bool operator==(Data& d)
	{
		return this->_year == d2._year
			&& this->_month == d2._month
			&& this->_day == d2._day;
	}

private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Data d1(2022, 10, 11);
	Data d2(2023, 1, 1);
    d1==d2;//可以显式调用 operator==(d1,d2);
	cout << (d1 == d2) << endl;
	cout << (d1 > d2) << endl;
}

那为什么在类中,显示的是一个参数呢?
      bool operator==(Data& d)
    {
        return this->_year == d2._year
            && this->_month == d2._month
            && this->_day == d2._day;
    }

因为在类中定义的成员函数,都在公共区,自动会在参数中带一个this指针,为该类的创建的对象的地址。而且运算符重载限定了参数个数,则参数部分:bool operator==(Data& d)即为这样,实现则为 return this->_year == d2._year
                              && this->_month == d2._month
                              && this->_day == d2._day;

3.加法的实现

值得注意的一点是:加 +和 加等于+=是不一样的:

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

class Data
{
public:
	Data(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	int Getmonthday(int year, int month)
	{
		int a[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 4 == 0))
		{
			return 29;
		}
		else
			return a[month];
	}

	Data& operator+=(int day)
	{
		_day += day;
		while (_day> Getmonthday(this->_year, this->_month))
		{
				_day -= Getmonthday(this->_year, this->_month);
				_month++;
			if (_month > 12)
			{
				_month -= 12;
				_year++;
			}
		}
		cout << _year<<_month<<_day << endl;
		return *this;
	}

	Data operator+(int day)
	{
		Data ret(*this);
		ret +=day;
		return ret;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Data d1(2022, 10, 11);
	Data d2(2023, 1, 1);
	d1 + 100;
	d1 += 100;
	return 0;
}

还有其他运算符重载需要大家自己实现!


6.赋值运算符重载

1.赋值运算符重载格式

参数类型 const T& ,传递引用可以提高传参效率(赋值
返回值类型 T& ,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值
返回 *this :要复合连续赋值的含义
Date& operator=(const Date& d)
{
	if (this != &d)
	{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	}
	return *this;
}

d1=d2;

赋值也是一样的,有两个参数,只不过第一个是隐藏的,赋值重载也是有顺序的:d1=d2;那么传参时,d1就是第一个参数,d2就是第二个参数。(像有双操作数的运算符,前后顺序就是参数顺序)

参数加const是因为原赋值对象不希望被改变,引用作为参数也可以避免拷贝;返回类型为引用是因为可以避免调用一次拷贝构造;遇到连等的情况:d1=d2=d3;链式访问(从右到左依次执行),d2=d3;会返回d2,再执行d1=d2;这就是有返回值的好处。

引用在传值传参和传值返回时,都可以减少拷贝构造的调用,节省时间空见。

返回值返回d1和d2都是可以的,只不过在返回d2时,前面返回类型就要加const,否则会扩大权限,所以为了更加方便,返回d1,即*this。

2.拷贝构造和赋值重载

d1=d2;就是把d2的值赋值给d1,那么是不是和拷贝构造也有相似之处呢??

当然,但二者的区别是:拷贝构造:已存在的类类型对象  创建新对象,赋值重载:已存在的两个对象之间的拷贝

他们都是会对内置类型进行处理,自定义类型会调用它的默认构造函数。

他们都是默认成员函数,自己不写,编译器就会默认生成。关键在于,编译器默认提供的,能不能符合我们的需求!

那么我们之前总结过,拷贝构造,当要调用析构函数时,就需要我们自己去写,赋值重载也是一样的。

举例说明:栈

如果使用编译器默认的赋值重载:

class Stack
	{
	public:
		Stack(int capacity = 4)
		{
			cout << "Stack(int capacity = )" <<capacity<<endl;
	
			_a = (int*)malloc(sizeof(int)*capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
	
			_top = 0;
			_capacity = capacity;
		}
		
		// st2(st1)
		Stack(const Stack& st)
		{
			cout << "Stack(const Stack& st)" << endl;
	
			_a = (int*)malloc(sizeof(int)*st._capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
			memcpy(_a, st._a, sizeof(int)*st._top);
			_top = st._top;
			_capacity = st._capacity;
		}
	
	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack st1;
	st1.Push(1);
	Stack st2(10);
	st2.Push(1);
	st2.Push(2);
	st2.Push(3);
	st1 = st2;
	return 0;
}

 会发现和之前的拷贝构造出现的问题挺一样的,d1和d2的_a指向的空间是一样的,结果同一块空间还析构了两次,d1原本指向的空间,没人析构,造成内存泄露。当要调用析构函数时,就需要我们自己去写。

解决方案:既然是赋值,就得内存空间一样大,里面内容一样。

索性直接将d1内存空间直接释放,创建一个和d2一样大的内存空间,然后将里面内容拷贝进去。

也防止自己赋值自己,直接把自己的内存空间释放了。

代码如下:

Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			free(_a);
			_a = (int*)malloc(sizeof(int) * st._capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
			memcpy(_a, st._a, sizeof(int) * st._top);
			_top = st._top;
			_capacity = st._capacity;
		}

		return *this;
	}

7.<<和>>运算符重载

<<在C语言中是左移的意思,但在c++中却是流插入的意思。

int i=5;

cout<<i;   <<流插入运算符,这个运算符支持内置类型(int,double,char......),是因为他在库中就已经实现了,而cout能用<<,是因为cout的类中也已经实现了使用流插入的功能。

cin和cout在库中对应的类是:istream,ostream,都已经支持自定义类型。

自定义类型要用运算符,就必须要重载,内置类型天生就可以用运算符。

void operator<<(ostream& out)
	{
		out << _year << " " << _month << " " << _day << endl;
	}

若写在类中,那么参数就只能这么写,因为第一个参数为隐藏this指针,第二个是ostream类。

对于双操作数的运算符,写的顺序就是参数的顺序,那么调用时,我们只能这么写:

d1<<cout;但是这样总是很怪,流插入不应该流向cout吗?那么我们放在类外依旧在.h中,写成全局函数试试:

void operator<<(const ostream& out, const Date& d)
	{
		out << _year << " " << _month << " " << _day << endl;
	}

问题一:

这样的话,在.cpp和其他包含.h头文件的文件里,在编译预处理时,.cpp->.o /.obj 就会在各个文件中,都有<<流插入运算符重载的定义,那么在其他文件中就会产生符号表,符号表中有重名的就会报错。

解决办法:

1.static修饰函数,会改变链接属性(是在当前文件可见),在其他文件不会产生符号表。那么不产生符号表,直接就会使用定义,不会发生冲突。

2.声明和定义分离 .h中声明,.cpp中定义,就不会发生符号表重复。

3.加inline内联,加了内联,就不会产生符号表,也是直接展开,定义到了每个有.h的文件,直接使用定义,不会链接。void operator<<(const ostream&  out, const Date&  d);

问题二:

既然出了类,类中的私有成员变量就不能通过对象去使用。

解决办法:

1.偷家,私有成员变量不可以用,但我可以通过公有的成员函数去使用。

2.友元:友元声明(在类和对象下我们会详细说明),在类中的声明前加一个friend.

friend void operator<<(const ostream&  out, const Date&  d);


那么有时候我们也会遇到这样的情况:cout<<d1<<d2;

链式访问,这就和之前的赋值重载很一样了,需要返回值,不同的是,<<的链式访问是从左到右的。而且返回值当然得是cout了

ostream& operator<<(const ostream&  out, const Date&  d);   你懂了吗??

流插入是一样的!


 8.const修饰的成员函数

1.const修饰的权限问题

将const修饰的“成员函数”称之为const成员函数。

而在调用的时候会经常出现 权限放大的问题。权限可以缩小,平移,但不可以放大

1.举例说明:

为什么就会报错呢??

 当d2去调用的时候&d2(即const Date*),这里const修饰的是指针所指的对象不可以被修改,只读。但是传参的时候就成了Print(Date*const this),可读可写(不明白可以回顾以前文章)。所以扩大了权限,无法调用。

解决方法就是在函数定义后面加一个const

就相当于 const Date*const,权限此时就相同了。

而加了const以后,d1调用时&d1,Date*,可读可写,但是Print形参中是只读,虽然权限缩小,但是可以!

2.举例说明:

日期类相减:

int Date:: operator-(const Date& d)
{
    Date max = *this;
    Date min = d;
    int flag = 1;
    //if (*this < d)

   换为

   if(d>*this)  可以吗??  当然不可以,d.operator>(*this);
    {                                   &d ->(const Date*)d此时是只读,结果到了>运算符的参数就是

                                         Date*const可读可写,权限放大。
        max = d;
        min = *this;
        flag = -1;
    }
    int count = 0;
    while (max != min)
    {
        max--;
        count++;
    }
    return count * flag;;
}

所以最好的方式是:凡是内部不改变成员变量,其实也就是不改变*this对象的数据的,这些成员函数都应该加const。

2.取地址重载

六大类默认成员函数就是:自己不写,编译器会给出。

当然,取地址重载也不例外,所以在大多数的时候,我们使用取地址都不需要自己写,除非一种情况!!

 就是我不想让他取出地址:

    Date* operator&()
	{
		return nullptr;
		//return this;
	}


   //第二种返回值加const是因为,返回参数是this时,为了返回时不扩大权限
	const Date* operator&() const
	{
		return nullptr;
		//return this;
	}

总结

看到这里,类和对象中篇就结束了,是不是收获满满,当然也需要反复琢磨,让我们一起期待类和对象下。跨过难关,旗开得胜!!

相关文章:

  • Python:文档注释、类型标注和注释宏# type:
  • python函数参数中独立星号*的作用
  • 【MySQL探索之旅】MySQL数据表的增删查改——约束
  • 测试人员如何提交一条高质量的bug
  • 图片标注编辑平台搭建系列教程(3)——画布拖拽、缩放实现
  • 远程技术支持软件方案如何帮助一线客服提升效率?
  • skywalking展示http请求和响应
  • 大数据面试总结三
  • Linux按键输入实验-按键功能完善
  • Python爬虫实战入门:爬取360模拟翻译(仅实验)
  • Android 打包和安装命令二合一的好用脚本
  • springboot + easyRules 搭建规则引擎服务
  • CockroachDB架构-存储层
  • 【DDR3 控制器设计】(1)MIG IP 核的详解与配置
  • 牛客网专项练习30天Pytnon篇第26天
  • 【Golang开发面经】得物(两轮技术面)
  • Linux vmalloc原理与实现
  • 李沐论文精读系列二:Vision Transformer、MAE、MoCo、Swin-Transformer(持续更新 )
  • 【我想找一份实习】算法篇
  • uniapp 微信小程序和H5的弹窗滚动穿透解决
  • linux安装tomcat、mysql、redis、宝塔,rpm命令
  • Linux命令老是记不住?一篇文章帮你解决。Linux常用命令汇总
  • 接口测试用例生成工具介绍及应用
  • 【axios】二次封装——避免重复发送请求
  • Maven 高级 5 多环境配置与应用 5.1 多环境开发
  • [ vulhub漏洞复现篇 ] Apache APISIX 默认密钥漏洞 CVE-2020-13945
  • 【图像分割】基于电磁算法优化多级阈值实现图像分割附matlab代码
  • SushiSwap历任“主厨”史
  • 【数据结构与算法】用队列实现栈用栈实现队列设计循环队列
  • 【模型训练】YOLOv7吸烟行为检测
  • stm32f4xx-ADC
  • 吃透Jmeter,5小时搞定5天工作量