友元
- 友元函数
  - 在C++中，友元函数是一个非成员函数，但它可以访问类的私有成员和保护成员。
  - 通过将函数声明为类的友元，我们可以授权函数访问类的私有成员，即使该函数不是类的成员函数。
  - 在类的定义中，可以使用friend关键字来声明友元函数。在类中声明的友元函数可以访问类的私有和保护成员。
  - 友元函数在类的定义之外进行定义，但在定义时需要使用类名和作用域解析运算符来指定该函数是类的友元函数。
```
#include <iostream>
 
class Person
{
public:
	//友元函数
	friend void FriendAsk(Person& ref);
 
public:
	Person(int age, int money) : m_Aage(age), m_Money(money){}
	int GetInfo()
	{
		return this->m_Money;
	}
 
public:
	int m_Aage;
 
private:
	int m_Money;
};
 
void FriendAsk(Person& ref)
{
	std::cout << ref.m_Money << std::endl;
}
 
int main()
{
	Person p1(18, 100);
	std::cout << p1.GetInfo() << std::endl;
	FriendAsk(p1);
 
	return 0;
}
```
- 友元类
  - 友元类是指一个类可以访问另一个类的私有成员和保护成员。要将一个类声明为另一个类的友元类，可以在类的定义中使用friend关键字。
```
#include <iostream>
 
class MyClass 
{
private:
    int value;
 
public:
    MyClass(int v) : value(v) {}
 
    friend class FriendClass;
};
 
class FriendClass {
public:
    void displayValue(const MyClass& obj) {
        std::cout << "The value is: " << obj.value << std::endl;
    }
};
 
int main() {
    MyClass obj(42);
    FriendClass fc;
    fc.displayValue(obj);  // 使用友元类的成员函数访问私有成员
 
    return 0;
}
```
- 友元特性
  - 友元函数的访问权限：
    - 友元函数具有对类的所有成员的访问权限，包括私有成员和保护成员。
    - 友元函数不是类的成员函数，因此它们不能通过类对象的成员访问运算符（.）或箭头运算符（->）来访问类的成员。
  - 友元函数的声明和定义：
    - 友元函数应该在类的声明中进行声明，以便在类中使用。
    - 友元函数的定义可以在类的声明之外进行，但是需要使用类名和作用域解析运算符来指定该函数是类的友元函数。
  - 友元函数和封装：
    - 友元函数可以突破类的封装性，因为它们可以直接访问类的私有成员。这可能会导致破坏类的封装性原则，因此在使用友元函数时应谨慎考虑。
  - 友元函数的应用：
    - 友元函数常用于重载运算符，使其能够操作类的私有成员。
    - 友元函数还可以在类之间共享信息或提供类之间的特定功能

运算符重载

运算符重载符号

算术运算符：+、-、*、/、%等


#include <iostream>
 
class Calc
{
public:
 
	//友元函数
	friend Calc operator-(const Calc& ref1, const Calc& ref2);
 
	//构造函数
	Calc(int nNum):n_Num(nNum){}
 
	Calc operator+(const Calc& ref)
	{
		return Calc(this->n_Num + ref.n_Num);
	}
 
 
private:
	int n_Num;
};
 
Calc operator-(const Calc& ref1, const Calc& ref2)
{
	return Calc(ref1.n_Num - ref2.n_Num);
}
 
int main()
{
 
	Calc c1(10);
	Calc c2(5);
	Calc c3 = c1 + c2;
	Calc c4 = c1 - c2;
 
	return 0;
}

关系运算符

==、!=、>、<、>=、<=等


#include <iostream>
 
class Calc
{
public:
 
	//友元函数
	friend Calc operator-(const Calc& ref1, const Calc& ref2);
 
	//构造函数
	Calc(int nNum):n_Num(nNum){}
 
	//算数运算
	Calc operator+(const Calc& ref)
	{
		return Calc(this->n_Num + ref.n_Num);
	}
 
	Calc operator-(const Calc& ref)
	{
		return Calc(this->n_Num - ref.n_Num);
	}
 
	Calc operator*(const Calc& ref)
	{
		return Calc(this->n_Num * ref.n_Num);
	}
 
	Calc operator/(const Calc& ref)
	{
		return Calc(this->n_Num / ref.n_Num);
	}
 
	Calc operator%(const Calc& ref)
	{
		return Calc(this->n_Num % ref.n_Num);
	}
 
	//比较运算
	bool operator==(const Calc& ref)
	{
		return this->n_Num == ref.n_Num;
	}
 
	bool operator!=(const Calc& ref)
	{
		return this->n_Num != ref.n_Num;
	}
 
	bool operator>(const Calc& ref)
	{
		return this->n_Num > ref.n_Num;
	}
 
	bool operator<(const Calc& ref)
	{
		return this->n_Num < ref.n_Num;
	}
 
	bool operator>=(const Calc& ref)
	{
		return this->n_Num >= ref.n_Num;
	}
 
	bool operator<=(const Calc& ref)
	{
		return this->n_Num <= ref.n_Num;
	}
 
 
 
private:
	int n_Num;
};
 
 
int main()
{
	Calc c1(10);
	Calc c2(5);
 
	//算数运算
	Calc c3 = c1 + c2;
 
	//笔记运算
	bool bret = c1 > c2;
 
	return 0;
}

逻辑运算符

!、&&、||等


#include <iostream>
 
class Calc
{
public:
	//构造函数
	Calc(int nNum) :n_Num(nNum) {}
 
	bool operator!()
	{
		return !this->n_Num;
	}
 
	bool operator||(const Calc& ref)
	{
		return this->n_Num || ref.n_Num;
	}
 
	bool operator&&(const Calc& ref)
	{
		return this->n_Num && ref.n_Num;
	}
 
private:
	int n_Num;
};
 
 
int main()
{
	Calc c1(10);
	Calc c2(5);
 
	// ||
	// &&
	// !
	std::cout << !c1 << std::endl;
	std::cout << (c1 || c2) << std::endl;
	std::cout << (c1 && c2) << std::endl;
 
 
	return 0;
}

赋值运算

=、+=、-=、*=、/=等


#include <iostream>
 
class Number 
{
private:
    int value;
 
public:
    Number(int val) : value(val) {}
 
    // 赋值运算符重载：=
    Number& operator=(const Number& other) 
    {
        if (this == &other) 
        {
            return *this;
        }
        value = other.value;
        return *this;
    }
 
    // 复合赋值运算符重载：+=
    Number& operator+=(const Number& other) 
    {
        value += other.value;
        return *this;
    }
 
    // 复合赋值运算符重载：-=
    Number& operator-=(const Number& other) 
    {
        value -= other.value;
        return *this;
    }
 
    // 复合赋值运算符重载：*=
    Number& operator*=(const Number& other) 
    {
        value *= other.value;
        return *this;
    }
 
    // 复合赋值运算符重载：/=
    Number& operator/=(const Number& other) 
    {
        if (other.value == 0) 
        {
            throw std::runtime_error("Divide by zero error");
        }
        value /= other.value;
        return *this;
    }
 
    void display() const 
    {
        std::cout << "Value: " << value << std::endl;
    }
};
 
int main() {
    Number num1(10);
    Number num2(0);
    try
    {
        num1 += num2;
        num1.display();
 
        num1 -= num2;
        num1.display();
 
        num1 *= num2;
        num1.display();
 
        num1 /= num2;
        num1.display();
    }
    catch (const std::exception& e)
    {
        std::cout << e.what() << std::endl;
    }
 
 
    return 0;
}

自增自减运算符

++、--等


#include <iostream>
 
class Counter 
{
private:
    int count;
 
public:
    Counter(int c = 0) : count(c) {}
 
    // 前置自增运算符重载：++
    Counter& operator++() 
    {
        count++;
        return *this;
    }
 
    // 后置自增运算符重载：++
    Counter operator++(int) 
    {
        Counter temp = *this;
        ++(*this);
        return temp;
    }
 
    // 前置自减运算符重载：--
    Counter& operator--() 
    {
        count--;
        return *this;
    }
 
    // 后置自减运算符重载：--
    Counter operator--(int) 
    {
        Counter temp = *this;
        --(*this);
        return temp;
    }
 
    void display() const 
    {
        std::cout << "Count: " << count << std::endl;
    }
};
 
int main() 
{
    Counter c(5);
 
    ++c;
    c.display();
 
    c--;
    c.display();
 
    return 0;
}

下标访问运算符

[]


#include <iostream>
 
class StudentInfo
{
public:
	StudentInfo(int nCount): m_Data(new int[nCount]), m_Count(nCount){}
 
	int& operator[](int nIndex)
	{
		return m_Data[nIndex];
	}
 
	void display() const
	{
		for (size_t i = 0; i < m_Count; i++)
		{
			std::cout << "m_Data[" << i <<"] -> " << m_Data[i] << std::endl;
		}
	}
 
private:
	int		m_Count;
	int*	m_Data;
};
 
 
 
int main()
{
	StudentInfo Info(5);
	Info[2] = 3;
 
	Info.display();
 
 
	return 0;
}

输入输出运算符

重载输入运算符


istream& operator>>(istream& input, YourType& object) 
{
    // 从输入流中读取数据，存储到 object 中
    // 对输入进行验证和处理
    // 返回输入流对象
    return input;
}

重载输出运算符


ostream& operator<<(ostream& output, const YourType& object) 
{
    // 将 object 的数据输出到输出流中
    // 格式化输出
    // 返回输出流对象
    return output;
}

示例代码


#include <iostream>
 
class Student
{
public:
	friend std::ostream& operator<<(std::ostream& output, const Student& object);
	friend std::istream& operator>>(std::istream& intput, Student& object);
 
private:
	int m_Age;
	int m_Id;
};
 
std::ostream& operator<<(std::ostream& output, const Student& object)
{
	// 将 object 的数据输出到输出流中
	output << object.m_Age << "|" << object.m_Id;
 
	// 返回输出流对象
	return output;
}
 
std::istream& operator>>(std::istream& intput, Student& object)
{
	// 将 object 的数据输出到输出流中
	intput >> object.m_Age >> object.m_Id;
 
	// 返回输出流对象
	return intput;
}
 
 
int main()
{
	Student s1;
	std::cin >> s1;
	std::cout << s1 << std::endl;
 
	return 0;
}

两种方式不同特性
- 访问权限：
  - 成员函数：运算符重载作为类的成员函数，可以直接访问类的私有成员变量和其他成员函数。这提供了更方便的访问权限，避免了使用友元函数时需要将其声明为类的友元的复杂性。
  - 友元函数：运算符重载作为友元函数，可以在类的外部定义，并被授权访问类的私有成员。这允许了更大的灵活性，可以重载运算符以适应不同类型的操作数。
- 左操作数和右操作数：
  - 成员函数：运算符重载作为成员函数时，左操作数是调用对象，右操作数是函数的参数。这使得运算符重载的使用看起来更像是对象的成员方法，例如 object1 + object2。
  - 友元函数：运算符重载作为友元函数时，左操作数是第一个参数，右操作数是第二个参数。这使得运算符重载的使用更加对称，例如 value1 + value2。
- 参数传递方式：
  - 成员函数：运算符重载作为成员函数时，左操作数（调用对象）被隐式传递给函数，而右操作数作为显式参数传递。这意味着左操作数可以直接访问成员变量，而右操作数需要作为参数传递给函数。
  - 友元函数：运算符重载作为友元函数时，左操作数和右操作数都作为显式参数传递给函数。这意味着在友元函数中无法直接访问类的私有成员变量，需要使用访问器函数或公有接口来访问。
- 对称性：
  - 成员函数：运算符重载作为成员函数时，左右操作数的顺序是固定的，无法改变。例如，对于 obj1 + obj2，左操作数将始终是 obj1。
  - 友元函数：运算符重载作为友元函数时，可以在重载时指定参数的顺序，从而实现对称性。例如，可以定义 operator+ 和 operator+= 来支持 obj1 + obj2 和 obj2 + obj1。

全局函数方式重载

全局函数方式的运算符重载是将运算符重载函数定义为全局函数，而不是类的成员函数。

全局函数方式的运算符重载函数可以在函数定义中访问类的私有成员，通过将类声明为友元来实现。


#include <iostream>
 
class Complex {
private:
    double real;
    double imag;
 
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
 
    // 声明全局函数为友元
    friend Complex operator+(const Complex& c1, const Complex& c2);
 
    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};
 
// 全局函数方式的运算符重载
Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
 
int main() {
    Complex c1(2.0, 3.0);
    Complex c2(4.0, 5.0);
 
    Complex sum = c1 + c2;
 
    sum.display();  // 输出：6 + 8i
 
    return 0;
}

成员函数方式重载

成员函数方式的运算符重载是将运算符重载函数定义为类的成员函数。

运算符重载函数作为成员函数时，隐含地访问了类的成员变量和成员函数。


#include <iostream>
 
class Complex {
private:
    double real;
    double imag;
 
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
 
    // 运算符重载函数作为类的成员函数
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
 
    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};
 
int main() {
    Complex c1(2.0, 3.0);
    Complex c2(4.0, 5.0);
 
    Complex sum = c1 + c2;
 
    sum.display();  // 输出：6 + 8i
 
    return 0;
}

运算符重载语法


返回类型 operator 运算符(参数列表) 
{
    // 实现运算符的操作
}

运算符重载核心
- 运算符重载是指为类类型的对象定义自定义行为的过程，使得对象可以使用像基本数据类型一样的运算符进行操作。
- 通过运算符重载，我们可以使用自定义类型的对象进行像内置类型一样的操作。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/50920