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

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

news 来源：原创 2024/12/22 20:33:30

类与对象
在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;
	}

总结

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

相关文章：

  • 我的世界怎么做的好看视频网站/电商怎么注册开店
  • 成都网站排名提升/外贸seo软件
  • 网站建设助您购选/百度官网入口
  • html5网站链接标签/自己接单的平台
  • wordpress 判断是否页面/seo网址
  • 朝阳周边网站建设/专业郑州企业网站建设
  • 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】二次封装——避免重复发送请求