C++ 类使用

最新推荐文章于 2024-08-05 15:13:47 发布

爱吃红萝卜的小白兔

最新推荐文章于 2024-08-05 15:13:47 发布

阅读量497

点赞数

文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/cloud323/article/details/121141809

版权

一、运算符重载

二、友元

通常，公有类方法提供唯一对类对象进行访问途径，但是有时候这种限制太严格，不适合特定的编程问题。在这种情况下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;
}

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

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

1.2、友元函数的作用

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

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

但是下面的语句没法处理

A = 5 * B;

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

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

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;
}

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;
}

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

使用友元类要注意的事项

友元关系不能被继承
友元关系是单向的，不具有交换性。若类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;
}