C++友元函数与友元类

C++友元函数与友元类

友元机制允许特定的函数或类访问另一个类的私有和保护成员。虽然友元打破了封装性，但在某些场景下可以提供更清晰的接口设计。

友元函数可以访问类的私有成员，常用于运算符重载。

#include
#include

class Vector2D {
double x_, y_;

public:
Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}

friend Vector2D operator+(const Vector2D& a, const Vector2D& b);
friend Vector2D operator*(const Vector2D& v, double scalar);
friend double dot(const Vector2D& a, const Vector2D& b);
friend std::ostream& operator<<(std::ostream& os, const Vector2D& v);

double magnitude() const {
return std::sqrt(x_ * x_ + y_ * y_);
}
};

Vector2D operator+(const Vector2D& a, const Vector2D& b) {
return Vector2D(a.x_ + b.x_, a.y_ + b.y_);
}

Vector2D operator*(const Vector2D& v, double scalar) {
return Vector2D(v.x_ * scalar, v.y_ * scalar);
}

double dot(const Vector2D& a, const Vector2D& b) {
return a.x_ * b.x_ + a.y_ * b.y_;
}

std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
os << "(" << v.x_ << ", " << v.y_ << ")";
return os;
}

void friend_function_example() {
Vector2D v1(3, 4);
Vector2D v2(1, 2);

Vector2D sum = v1 + v2;
Vector2D scaled = v1 * 2.0;
double product = dot(v1, v2);

std::cout << "v1: " << v1 << "\n";
std::cout << "v2: " << v2 << "\n";
std::cout << "sum: " << sum << "\n";
std::cout << "scaled: " << scaled << "\n";
std::cout << "dot product: " << product << "\n";
}

友元类可以访问另一个类的所有私有成员。

class Engine {
int rpm_;
double temperature_;

friend class Car;

public:
Engine() : rpm_(0), temperature_(20.0) {}

private:
void start() {
rpm_ = 1000;
temperature_ = 90.0;
std::cout << "Engine started\n";
}

void stop() {
rpm_ = 0;
temperature_ = 20.0;
std::cout << "Engine stopped\n";
}
};

class Car {
Engine engine_;
bool running_;

public:
Car() : running_(false) {}

void start() {
if (!running_) {
engine_.start();
running_ = true;
std::cout << "Car started, RPM: " << engine_.rpm_ << "\n";
}
}

void stop() {
if (running_) {
engine_.stop();
running_ = false;
std::cout << "Car stopped\n";
}
}

void display_status() const {
std::cout << "Engine RPM: " << engine_.rpm_
<< ", Temperature: " << engine_.temperature_ << "°C\n";
}
};

void friend_class_example() {
Car car;
car.start();
car.display_status();
car.stop();
}

友元声明可以用于实现特殊的访问控制模式。

class BankAccount {
double balance_;
std::string account_number_;

friend class Bank;
friend class Auditor;

public:
BankAccount(const std::string& number, double initial)
: account_number_(number), balance_(initial) {}

void deposit(double amount) {
if (amount > 0) {
balance_ += amount;
std::cout << "Deposited: " << amount << "\n";
}
}

double get_balance() const {
return balance_;
}
};

class Bank {
public:
void transfer(BankAccount& from, BankAccount& to, double amount) {
if (from.balance_ >= amount) {
from.balance_ -= amount;
to.balance_ += amount;
std::cout << "Transferred " << amount << " from "
<< from.account_number_ << " to " << to.account_number_ << "\n";
} else {
std::cout << "Insufficient funds\n";
}
}
};

class Auditor {
public:
void audit(const BankAccount& account) {
std::cout << "Auditing account " << account.account_number_
<< ", Balance: " << account.balance_ << "\n";
}
};

void access_control_example() {
BankAccount acc1("ACC001", 1000);
BankAccount acc2("ACC002", 500);

Bank bank;
bank.transfer(acc1, acc2, 200);

Auditor auditor;
auditor.audit(acc1);
auditor.audit(acc2);
}

友元函数可以是另一个类的成员函数。

class Display;

class Data {
int value_;

friend void Display::show(const Data& d);

public:
explicit Data(int v) : value_(v) {}
};

class Display {
public:
void show(const Data& d) {
std::cout << "Data value: " << d.value_ << "\n";
}
};

友元关系不是对称的，也不能传递。

class A {
int secret_;

friend class B;

public:
explicit A(int s) : secret_(s) {}
};

class B {
int data_;

public:
explicit B(int d) : data_(d) {}

void access_A(const A& a) {
std::cout << "B accessing A's secret: " << a.secret_ << "\n";
}
};

class C {
public:
void try_access_A(const A& a) {
std::cout << "C cannot access A's secret\n";
}
};

友元机制应该谨慎使用，只在确实需要打破封装时才使用。过度使用友元会降低代码的可维护性。