C++中的友元机制是语言特性中用于打破封装性的一种方式，它允许非成员函数或外部类访问通常受保护的类成员，如私有（private）和保护（protected）成员。这种机制使得某些特定情况下代码的编写和设计更加灵活。
1. 友元函数
友元函数是不在类的成员列表中，但被类声明为友元的普通函数。要声明一个友元函数，需要在类定义内部使用`friend`关键字。友元函数可以直接访问类的私有和保护成员，无需通过公有接口。在例子中，`Point`类声明了`Dist`函数为其友元，因此`Dist`可以计算两个`Point`对象之间的距离，而不需要`Point`提供额外的公共接口。
```cpp
class Point{
public:
Point(double xx=0, double yy=0);
double GetX() {return X;}
double GetY() {return Y;}
friend double Dist(Point &a, Point &b); // 声明友元函数
private:
double X,Y;
};
// 实现友元函数
double Dist(Point& a, Point& b){
double dx=a.X-b.X;
double dy=a.Y-b.Y;
return sqrt(dx*dx+dy*dy);
}
```
2. 友元类
友元类是指一个类声明另一个类为它的友元，这样友元类的所有成员函数都可以访问原类的私有和保护成员。声明友元类时，在原类中使用`friend`关键字加上友元类的名字。例如：
```cpp
class A{
friend class B;
public:
...
private:
int x;
};
class B{
public:
void Set(int i);
void Display();
private:
A a;
};
```
在上面的例子中，`B`类可以访问`A`类的私有成员`x`，并可以直接设置`A`对象的值。
3. 示例
在第二个友元类的例子中，`birthday`类声明了`people`类为它的友元。`people`类可以访问`birthday`的私有成员`year`, `month`, 和 `day`。这样在`people`类的构造函数和复制构造函数中可以直接操作`birthday`对象，无需暴露额外的公共接口。
```cpp
class birthday{
private:
int year,month,day;
public:
friend class people;
birthday(int Year=0,int Month=0,int Day=0){
year=Year;
month=Month;
day=Day;
}
};
class people{
private:
birthday b;
int number;
char sex;
int id;
public:
people(int n,char m,int s,birthday d);
people(people &a);
~people();
void display();
};
// people类的构造函数可以访问birthday的私有成员
people::people(int n, char m, int s, birthday d)
: number(n), sex(m), id(s), b(d) {
cout << "constructer be called." << endl;
}
// 复制构造函数同样可以访问
people::people(people &a)
: number(a.number), sex(a.sex), id(a.id), b(a.b) {
cout << "copy constructer be called." << endl;
}
// 显示people的信息，包括birthday的详细信息
void people::display(){
cout << "birthday:" << b.year << "-" << b.month << "-" << b.day << endl;
cout << "number:" << number << "\tsex:" << sex << "\tid:" << id << endl;
}
```
总结来说，友元机制虽然增加了代码的灵活性，但也可能导致封装性的降低，使得代码更难维护。因此，应谨慎使用友元，尽量通过公有接口来实现类之间的协作。在设计时，要充分考虑类的接口设计，以保持代码的清晰性和可维护性。
