深入解析 C++ 高级特性：友元、运算符重载与仿函数

深入解析 C++ 高级特性：友元、运算符重载与仿函数

在 C++ 面向对象编程中，除了基本的类和对象操作，还有一些高级特性，如友元函数、运算符重载和仿函数。这些特性可以极大地增强类的功能和灵活性，使代码更加简洁和高效。本文将通过一个综合性的 C++ 程序，深入探讨这些高级特性的使用方法和最佳实践。

一、程序概述

这个程序涵盖了 C++ 中的友元函数、运算符重载和仿函数的使用。通过这些示例，我们可以看到如何利用这些特性来实现更高效、更灵活的类设计。程序通过多个类和函数的调用展示了这些特性的具体应用。

二、友元函数

1. 友元函数的概念

友元函数是一种特殊的函数，它可以访问类的私有成员。友元函数不是类的成员函数，但它可以访问类的私有成员变量和私有成员函数。

示例：全局友元函数

cpp复制

class class1
{
	friend void gfunc(class1& c); // 声明全局友元函数
public:
	int m_a = 0;
private:
	int m_b = 0;
};

void gfunc(class1& c)
{
	cout << c.m_b << endl; // 访问私有成员变量
}

在 main 函数中调用：

cpp复制

class1 c1;
gfunc(c1); // 输出 0

2. 类作为友元

类也可以作为友元，访问另一个类的私有成员。

示例：类作为友元

cpp复制

class class3
{
	friend class class2; // 声明类友元
public:
	class3();
private:
	int m_b = 0;
};

class3::class3()
{
	m_b = 10086;
}

class class2
{
public:
	class3* c3;
	class2();
	void visit() const;
};

class2::class2()
{
	c3 = new class3;
}

void class2::visit() const
{
	cout << c3->m_b << endl; // 访问私有成员变量
}

在 main 函数中调用：

cpp复制

class2 c2;
c2.visit(); // 输出 10086

三、运算符重载

1. 运算符重载的概念

运算符重载允许用户自定义类的运算符行为。通过重载运算符，可以实现更自然的类操作，使代码更加简洁和直观。

示例：+ 运算符重载

cpp复制

class my_class1
{
public:
	int m_a = 0;
	string m_b = "0";
	my_class1(int a, string b) :m_a(a), m_b(b) {};
	my_class1 operator+(my_class1& p) const
	{
		my_class1 p1(0, "0");
		p1.m_a = this->m_a + p.m_a;
		p1.m_b = this->m_b + p.m_b;
		return p1;
	}
};

在 main 函数中调用：

cpp复制

my_class1 p1(1, "Hello");
my_class1 p2(2, " World");
my_class1 p3 = p1 + p2; // 使用重载的 + 运算符
cout << p3.m_a << " " << p3.m_b << endl; // 输出 3 Hello World

2. 全局函数重载

运算符重载也可以通过全局函数实现。

示例：全局函数重载

cpp复制

static my_class1 operator+(my_class1 p1, my_class1 p2)
{
	my_class1 p(0, "0");
	p.m_a = p1.m_a + p2.m_a;
	p.m_b = p1.m_b + p2.m_b;
	return p;
}

在 main 函数中调用：

cpp复制

my_class1 p4 = operator+(p1, p2); // 使用全局函数重载
cout << p4.m_a << " " << p4.m_b << endl; // 输出 3 Hello World

3. 输入输出运算符重载

输入输出运算符（<< 和 >>）也可以通过全局函数重载。

示例：<< 运算符重载

cpp复制

class my_class2
{
	friend static ostream& operator<<(ostream& cout, my_class2 p);
private:
	int m_a;
	double m_b;
	string m_c;
public:
	my_class2(int a, double b, string c) :m_a(a), m_b(b), m_c(c) {};
};

static ostream& operator<<(ostream& cout, my_class2 p)
{
	cout << p.m_a << "  " << p.m_b << "  " << p.m_c << endl;
	return cout;
}

在 main 函数中调用：

cpp复制

my_class2 p(3, 3.1415, "PI");
cout << p; // 使用重载的 << 运算符

四、递增运算符重载

1. 前置递增与后置递增

递增运算符（++）也可以通过成员函数重载。

示例：前置递增与后置递增

cpp复制

class my_class3
{
public:
	int m_a;
	my_class3(int a)
	{
		m_a = a;
	}
	my_class3& operator++() // 前置递增
	{
		this->m_a++;
		return *this;
	}
	my_class3 operator++(int) // 后置递增
	{
		my_class3 temp = *this;
		this->m_a++;
		return temp;
	}
};

在 main 函数中调用：

cpp复制

my_class3 p(8);
cout << ++(++p).m_a << endl; // 输出 10
cout << p.m_a << endl; // 输出 10
cout << p++.m_a << endl; // 输出 10
cout << p.m_a << endl; // 输出 11

五、赋值运算符重载

1. 赋值运算符的概念

赋值运算符（=）可以通过成员函数重载，以实现更复杂的赋值逻辑。

示例：赋值运算符重载

cpp复制

class my_class4
{
public:
	int* m_a;
	my_class4(int a)
	{
		m_a = new int(a);
	}
	my_class4& operator=(my_class4& p)
	{
		m_a = new int(*p.m_a); // 深拷贝
		return *this;
	}
	~my_class4()
	{
		if (m_a != NULL)
		{
			delete m_a;
			m_a = NULL;
		}
	}
};

在 main 函数中调用：

cpp复制

my_class4 p1(1);
my_class4 p2(10);
p1 = p2; // 使用重载的赋值运算符
cout << *p1.m_a << " " << *p2.m_a << endl; // 输出 10 10

六、关系运算符重载

1. 关系运算符的概念

关系运算符（如 == 和 !=）可以通过成员函数重载，以实现更复杂的比较逻辑。

示例：== 运算符重载

cpp复制

class my_class5
{
private:
	int m_a;
	double m_b;
	string m_c;
public:
	my_class5(int a, double b, string c) :m_a(a), m_b(b), m_c(c) {};
	bool operator==(my_class5& p)
	{
		return (this->m_a == p.m_a && this->m_b == p.m_b && this->m_c == p.m_c);
	}
};

在 main 函数中调用：

cpp复制

my_class5 p1(3, 3.1415, "PI");
my_class5 p2(3, 3.1415, "PI");
my_class5 p3(3, 3.141, "PI");
cout << (p1 == p2) << endl; // 输出 1
cout << (p1 == p3) << endl; // 输出 0

七、仿函数

1. 仿函数的概念

仿函数是一种通过重载 () 运算符实现的类，它可以像函数一样被调用。仿函数可以用于实现更灵活的函数对象。

示例：仿函数

cpp复制

class my_class6
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}
	int operator()(int a, int b)
	{
		return a + b;
	}
};

在 main 函数中调用：

cpp复制

my_class6 p;
p("Hello"); // 调用仿函数
int ret = p(1, 2); // 调用仿函数
cout << ret << endl; // 输出 3

八、总结

通过这个综合性的 C++ 程序，我们深入探讨了友元函数、运算符重载和仿函数的使用。这些特性是 C++ 面向对象编程中的高级工具，可以进一步增强类的功能和灵活性。

• 友元函数：允许访问类的私有成员，可以用于实现更复杂的类间交互。

• 运算符重载：允许自定义类的运算符行为，使代码更加简洁和直观。

• 仿函数：允许类像函数一样被调用，可以用于实现更灵活的函数对象。

在实际编程中，合理使用这些特性可以提高代码的效率和可维护性。通过不断练习和积累经验，我们可以更好地掌握这些核心概念，从而编写出更高效、更可靠的 C++ 程序。