C++ 类使用_c++类的使用方法

一、运算符重载

二、友元

通常，公有类方法提供唯一对类对象进行访问途径，但是有时候这种限制太严格，不适合特定的编程问题。在这种情况下C++提供了另外一种形式的访问权限：友元，友元有下面三种

• 友元函数
• 友元类
• 友元成员函数

1、友元函数

通过让函数称为类的友元函数，可以赋予该函数与类的成员函数相同的访问权限。

1.1、如何声明友元函数？

第一步：将函数的原型声明放到类声明中，并在原型声明前面加上friend关键字。
第二步：编写友元函数。

class Time
{
private:
    int hours;
    int minutes;

public:
    friend Time operator*(double m, const Time &t);
};

Time operator*(double m, const Time &t){
    Time result;
    result.minutes = t.minutes * m;
    result.hours = t.hours * m + result.minutes / 60;
    result.minutes = result.minutes % 60;
    return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

注意：声明友元函数时，要注意下面的问题

• 友元函数不是成员函数，定义友元函数时不要使用::限定符
• 定义友元函数时，不要使用friend关键字

1.2、友元函数的作用

为类重载二元运算符时，常常需要友元函数。例如：把Time对象乘以一个整数

A = B * 5;
//转换为下面的函数调用
A = B.operator*(5);
1
2
3

但是下面的语句没法处理

A = 5 * B;
1

把运算符重载为类的成员函数，则运算符的第一个操作数必须是类对象。如果想把非类对象作为第一个操作数，则必须使用友元函数来反转操作数的顺序。对于非成员重载运算符函数来说，运算符表达式左边的操作数对应于运算符函数的第一个参数，运算符表达式右边的操作数对应于运算符函数的第二个参数。下面使用友元函数解决上面的问题

friend Time operator*(double m, const Time &t);
1

1.3、常用的友元

经常对<<运算符进行重载，使之能够与cout一起来显示对象内容。ostream类对<<进行了重载，将其转换为一个输出工具，下面使用友元函数来重载<<

class Time
{
private:
    int hours;
    int minutes;

public:
    friend ostream & operator<<(ostream &os, const Time &t);
};

ostream & operator<<(ostream &os, const Time &t){
    os<<t.hours<<" "<<t.minutes<<endl;
    return os;
}

int main()
{
    Time t1(1, 20);
    cout << t1;   // 输出结果 1 20
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2，友元类

友元类也是对类接口的扩展，友元类的所有的方法都可以访问原始类的私有成员和保护成员。继承并不能描述现实生活中所有类之间的关系，我们有一个TV类来表示电视机，一个Remote类表示遥控器，很显然这两个类之间并没有继承关系。遥控器可以访问电视机，但是电视机不能访问遥控器，可以把遥控器声明为电视机的友元类。例如：

#include <iostream>
using namespace std;

//Remote类的前向声明
class Remote;
class Tv{
private:
    int state;
public:
    friend class Remote;
    Tv(int s):state(s){}
};

class Remote{
private:
    int model;
public:
    void getState(Tv &t){
        cout<<t.state<<endl;
    }
};

int main() {
    Tv tv(5);
    Remote r;
    r.getState(tv);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

注意：友元声明可以位于私有、公有或保护部分，其所在的位置无关紧要

使用友元类要注意的事项

• 友元关系不能被继承
• 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
• 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的声明。

3、友元成员函数

使用友元成员函数可以把类的部分函数成为另一个类的友元，但是， 当用到友元成员函数时，需注意友元声明和友元定义之间的相互依赖。在下面的示例中类B必须先定义，否则类A就不能将一个B的函数指定为友元。然而，只有在定义了类A之后，才能定义类B的该成员函数。更一般的讲，必须先定义包含成员函数的类，才能将成员函数设为友元。另一方面，不必预先声明类和非成员函数来将它们设为友元。

#include <iostream>
 
using namespace std;
 
class A;    //当用到友元成员函数时，需注意友元声明与友元定义之间的互相依赖。这是类A的声明
class B
{
public:
    void set_show(int x, A &a);             //该函数是类A的友元函数
};
 
class A
{
public:
    friend void B::set_show(int x, A &a);   //该函数是友元成员函数的声明
private:
    int data;
    void show() { cout << data << endl; }
};
 
void B::set_show(int x, A &a)       //只有在定义类A后才能定义该函数，毕竟，它被设为友元是为了访问类A的成员
{
    a.data = x;
    cout << a.data << endl;
}
 
int main(void)
{
    class A a;
    class B b;
 
    b.set_show(1, a);
 
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

4、友元的优缺点

优点：

• 可以灵活地实现需要访问若干类的私有或受保护的成员才能完成的任务
• 便于与其他不支持类概念的语言(如C语言、汇编等)进行混合编程
• 通过使用友元函数重载可以更自然地使用C++语言的IO流库

缺点：

• 一个类将对其非公有成员的访问权限授予其他函数或者类，会破坏该类的封装性，降低该类的可靠性和可维护性