C++基础知识五

1.赋值运算符重载

赋值运算符只能重载类的成员函数不能重载成全局函数

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

Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}

这里会报错，因为如果运算符重载不显式实现，编译器会生成一个默认的，此时用户在类外实现一个全局的赋值运算符重载就和编译器在类中生成的默认赋值运算符重载冲突了。所以运算符重载只能是类的成员函数。

2.前置++和后置++重载

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//前置++：返回+1后的结果
	//this指针指向的对象函数结束后不会销毁，故用引用方式提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
	//后置++
	//前置++和后置++都是一元运算符，重载也有区别
	//C++规定:后置++重载时多增加一个int型参数，但是调用函数的时候不用传参数过去，编译器会自动给函数一个参数
	//注意：后置++时先使用完后再去+1，因此需要返回+1前的旧值，故需要实现时先将this保存一份，如何再
	//给this+1
	//temp是临时对象，因此只能以传值的方式返回，不能返回引用
	Date operator++(int)
	{
		Date temp = *this;
		_day += 1;
		return temp;
	}
private:
	int _year;
	int _month;
	int _day;
};

3.const成员

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

比如下面的代码，d1前面有const，代表着类d1是不可以改变的，而在Print函数里面，参数是Date* const this，this指针是不可以改变的，但是this指针指向的内容是可以改变的，const只是修饰this，并没有限制*this，这样就是权限放大了，会报错，所以要在参数最前面再加一个const就不会出现权限放大的问题，但是这个const是加在函数后面，这样就是表示const Date* const this的形式，需要注意的是权限放大不行，但是可以缩小

 

 

4.友元函数

友元提供一种突破封装的方式，有时提供了便利，但是友元会增加耦合度，破坏了封装，所以友元函数少用

friend istream& operator>>(istream& in, Date& d);
friend ostream& operator<<(ostream& out, Date& d);

在函数的最前面加friend就是友元函数了，可以访问类里面private里面的成员

 

5.输出流和输入流

在C语言中我们一般使用printf和scanf来输出与输入，C++则是下面的形式来完成

istream& operator>>(istream& in, Date& d)
{
	while (1)
	{
		cout << "请依次输入年月日:>";
		in >> d._year >> d._month >> d._day;

		if (!d.CheckDate())
		{
			cout << "输入日期非法:";
			d.Print();
			cout << "请重新输入!!!" << endl;
		}
		else
		{
			break;
		}
	}

	return in;
}

ostream& operator<<(ostream& out,Date& d)
{
	out << d._year << d._month << d._day;
	return out;
}

in 和 cin 在 C++ 中有以下区别：

1.cin:

2.cin 是一个预定义的全局对象，代表标准输入流，通常是键盘输入。
3.它是 std::istream 的实例，通常用于直接从用户那里读取输入。
4.用法示例: cin >> variable;

5.in:

6.in 是一个函数参数，通常是 istream& 类型的引用，可以代表任意输入流对象（如 cin, ifstream, istringstream 等）。
7.在重载流操作符时，in 允许你使用不同的流对象，提供灵活性。
8.用法示例: 在 operator>> 函数中 in 可以是 cin 或其他 istream 对象。

示例对比
使用 cin:
int main() {
    int number;
    cout << "Enter a number: ";
    cin >> number; // 直接从标准输入读取
    return 0;
}

使用 istream& in:
#include <iostream>
#include <sstream>
using namespace std;

void readData(istream& in) {
    int number;
    in >> number; // 可以是 cin, ifstream, istringstream 等
    cout << "Number: " << number << endl;
}

int main() {
    int number;
    cout << "Enter a number: ";
    readData(cin); // 传递 cin

    istringstream iss("42");
    readData(iss); // 传递 istringstream 对象

    return 0;
}

总结

9.cin 是标准输入流的具体实例，用于直接读取用户输入。
10.in 是一个函数参数，代表任意类型的输入流对象，使得代码更加灵活和可重用。
 

在 C++ 中，out 和 cout 的区别如下：
cout

1.定义: cout 是 C++ 标准库中定义的全局对象，代表标准输出流（通常是屏幕）。
2.类型: cout 是 std::ostream 类型的实例，定义在头文件 <iostream> 中。
3.用途: 用于将数据输出到标准输出设备，比如屏幕。

示例:
#include <iostream>
using namespace std;

int main() {
    cout << "Hello, World!" << endl; // 将文本输出到屏幕
    return 0;
}

out

4.定义: out 不是 C++ 标准库中的一个全局对象，而是一个常用的名称，用于表示用户自定义的 ostream 对象或函数参数中的 ostream 引用。
5.类型: out 可以是任何类型的 ostream 对象，例如 std::ofstream, std::ostringstream, 以及 std::ostream 的其他实例。
6.用途: out 用于表示一个输出流对象，通常在函数中作为参数使用，或作为自定义输出流的实例。

示例:

7.作为函数参数:

   #include <iostream>
   using namespace std;

   void printMessage(ostream& out) {
       out << "Hello from function!" << endl;
   }

   int main() {
       printMessage(cout); // 使用 cout 作为参数传递
       return 0;
   }

8.作为自定义输出流对象:

   #include <iostream>
   #include <fstream>
   using namespace std;

   int main() {
       ofstream outFile("output.txt"); // 创建一个文件输出流
       if (outFile.is_open()) {
           outFile << "Hello, File!" << endl; // 将数据写入文件
           outFile.close();
       }
       return 0;
   }

总结

9.cout 是 C++ 标准库提供的一个全局对象，用于直接向标准输出（通常是屏幕）输出数据。
10.out 是一个通用的名称，用于代表任何类型的输出流对象（例如 std::ofstream, std::ostringstream 或其他 ostream 对象），它可以是自定义函数的参数或局部变量。

在实际编程中，out 用作参数或自定义流对象的名称，而 cout 是特定的全局对象。

 在C++中输出流和输入流是绑定在一起的，表面了cin指向每一个i/o操作之前，cout的缓冲区都会被刷新。

5.隐式转换

整型2构造一个A的临时对象，再用这个临时对象拷贝构造a1

编译器遇到连续构造+拷贝构造就会优化为直接构造

A a1=2;

//错误行为 因为临时变量具有常性，而A是可变的，权限放大了

A& a2=2；

//改为

const A& a2=2；而这个就没有优化了，因为就是把2产生的临时变量拷贝给a2