友元类

#include<iostream>
using namespace std;
class Date; //对Date类的提前引用声明
class Time
{
public:
    Time(int,int,int);
    void add_a_second(Date &);  //增加1秒,1秒后可能会到了下一天,乃到下一月、下一年
    void display(Date &);  //显示时间,格式:月/日/年 时:分:秒
private:
    int hour;
    int minute;
    int sec;
};
Time::Time(int x,int y,int z):hour(x),minute(y),sec(z) {}
class Date
{
public:
    Date(int,int,int);
    friend class Time; //Time为Date的友元类
private:
    int month;
    int day;
    int year;
};
Date::Date(int x,int y,int z):month(x),day(y),year(z) {}
int main( )
{
    int i;
    Time t1(23,59,32);
    Date d1(2,28,2013);
    for(i=0;i<=100; i++)
    {
        t1.add_a_second(d1);
        t1.display(d1);
    }
    return 0;
}
int judge(int y,int m);
int judge(int y,int m)
{
    int t[]= {0,31,28,31,30,31,30,31,31,30,31,30,31};

    if((y%100==0&&y%4!=0)||(y%400==0)) t[2]=29;
    return t[m];
}
void Time::add_a_second(Date &t)
{
    sec=sec+1;
    if(sec>=60)
    {
        minute+=1;
        sec-=60;
    }
    if(minute>=60)
    {
        hour+=1;
        minute-=60;
    }
    if(hour>24)
    {
        hour-=24;
        t.day+=1;
    }
    if(t.day>judge(t.year,t.month))
    {
        t.day-=judge(t.year,t.month);
        t.month+=1;
    }
    if(t.month>12)
    {
        t.month-=12;
        t.year+=1;
    }

}
void Time::display(Date &t)
{
    cout<<t.year<<" "<<t.month<<" "<<t.day<<" "<<hour<<" "<<minute<<" "<<sec<<" ";
}

<think>我们正在讨论C++中的友元类(friend class)。根据引用内容,友元类允许一个(称为友元类)访问另一个的私有(private)和保护(protected)成员。这是C++中打破封装性的一种机制,需要谨慎使用。 ### 友元类的基本概念 - **定义**:如果A将B声明为(即在A的定义中使用`friend class B;`),那么B的所有成员函数都可以访问A的私有成员和保护成员。 - **特性**: 1. **单向性**:关系是单向的。如果A声明B是它的,这并不意味着A可以访问B的私有成员(除非B也声明A为)。 2. **非传递性**:如果A是B的B是C的,这并不意味着A是C的。 3. **非继承性**:关系不能被继承。如果A是B的C继承自A,那么C不是B的(除非B显式声明C为)。 ### 友元类的使用方法 在声明友元类时,通常将`friend`关键字和友元类名放在的定义中。例如: ```cpp class A { private: int private_data; public: // 声明B是A的友元类 friend class B; }; class B { public: void accessA(A& a) { // 由于B是A的,可以直接访问A的私有成员 std::cout << a.private_data << std::endl; } }; ``` ### 示例代码分析 引用[3]提供了一个引擎(Engine)和汽车(Car)的示例: ```cpp #include <iostream> using namespace std; class Engine { private: int horsepower; public: Engine(int hp) : horsepower(hp) {} // 声明Car为友元类 friend class Car; }; class Car { public: void showEnginePower(const Engine& e) { // 由于Car是Engine的,可以直接访问Engine的私有成员horsepower std::cout << "Engine horsepower: " << e.horsepower << std::endl; } }; int main() { Engine engine(500); Car car; car.showEnginePower(engine); // 输出:Engine horsepower: 500 return 0; } ``` 在这个例子中: - `Engine`将`Car`声明为,因此`Car`的成员函数`showEnginePower`可以访问`Engine`的私有成员`horsepower`。 ### 使用注意事项 1. **破坏封装**:打破了的封装性,因此应该只在必要的情况下使用,例如当两个在逻辑上紧密耦合,且需要频繁访问对方私有成员时。 2. **替代方案**:在可能的情况下,优先考虑使用公有成员函数(getter/setter)来访问私有数据,以保持封装性。 3. **声明位置**:声明可以在的任何部分(private、protected或public)出现,因为声明不受访问控制符的影响。但通常放在定义的开始或结束位置以保持清晰。 ### 模板友元类 引用[4]中提到了模板的情况。当是一个模板时,需要在声明中指定模板参数。例如: ```cpp template<typename T> class A { private: T data; public: // 声明模板B为 template<typename U> friend class B; }; // 这样,对于任何型U,B<U>都是A<T>的,但注意:通常我们可能需要更精确的控制。 ``` 但是,上述声明意味着对于每一个特化的`A<T>`,所有特化的`B<U>`都是它的。如果我们希望只有相同型的`B<T>`才是`A<T>`的,可以这样声明: ```cpp template<typename T> class B; // 前置声明 template<typename T> class A { private: T data; public: // 声明特定特化的B<T>为 friend class B<T>; }; ``` ### 总结 友元类提供了一种访问其他私有成员的机制,但应谨慎使用。在需要两个紧密协作的情况下,友元类可以避免使用公共接口带来的性能开销或设计复杂性。然而,过度使用会破坏封装,增加之间的耦合度。 §§相关问题§§ 1. 函数和友元类有什么区别? 2. 在C++中,如何声明一个模板作为? 3. 使用友元类可能会带来哪些设计上的问题? 4. 除了,还有哪些方法可以访问的私有成员?</think>### C++ 友元类详解 友元类(friend class)是 C++ 中允许特定访问另一个私有成员的机制。通过 `friend` 关键字声明,它打破了严格的封装性,在特定场景下可提升代码效率和灵活性。 #### 一、核心特性 1. **单向访问权限** 若 A 声明 B 为,则 B 可访问 A 的私有成员,但 A **不能**访问 B 的私有成员。 示例: ```cpp class Storage { friend class Display; // 声明 private: int secret = 42; }; class Display { public: void show(const Storage& s) { std::cout << s.secret; // 允许访问私有成员 } }; ``` 2. **非传递性** 若 A 是 B 的,B 是 C 的,**不等于** A 是 C 的。 3. **非继承性** 派生**不继承**基关系。若基声明,派生仍需单独声明。 #### 二、使用场景 1. **紧密协作的** 如引擎(Engine)和汽车(Car): ```cpp class Engine { friend class Car; // 声明 private: int horsepower; public: Engine(int hp) : horsepower(hp) {} }; class Car { public: void showPower(const Engine& e) { std::cout << "Power: " << e.horsepower; // 直接访问私有成员 } }; ``` [^3] 2. **工具辅助** 如日志(Logger)访问多个的内部状态: ```cpp class Network { friend class Logger; private: int packetCount; }; class Logger { public: static void log(const Network& net) { std::cout << "Packets: " << net.packetCount; } }; ``` #### 三、模板友元类 当涉及模板时,需前置声明并指定模板参数: ```cpp template<typename T> class Box { friend class Inspector<T>; // 声明模板 private: T content; }; template<typename T> class Inspector { public: void check(const Box<T>& box) { std::cout << "Content: " << box.content; } }; ``` [^4] #### 四、注意事项 1. **谨慎使用** 过度使用会破坏封装性,增加耦合度。优先考虑公有接口(getter/setter)。 2. **声明位置无关** `friend` 声明可放在的任何区域(public/private/protected),效果相同。 3. **替代方案** 考虑使用组合(composition)或中介模式(mediator pattern)替代。 > **最佳实践**:仅当两个在逻辑上高度内聚(如引擎与汽车),且频繁访问私有数据时使用友元类。其他场景建议保持封装[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值