C++高级编程技巧（模板友元声明全攻略）

第一章：模板友元的声明方式

模板友元的基本语法

template<typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}

    // 声明一个模板友元函数
    template<typename U>
    friend void printValue(const Box<U>& box);
};

// 友元函数定义
template<typename U>
void printValue(const Box<U>& box) {
    std::cout << box.value << std::endl; // 可访问私有成员
}

常见使用场景

• 重载比较运算符以支持不同类型间的比较
• 实现序列化或输入输出操作符（如operator<<）
• 构建工厂模式中需要访问私有构造函数的辅助类

注意事项与限制

第二章：非模板类中的友元函数声明

2.1 友元函数的基本语法与作用域解析

基本语法结构

class MyClass {
private:
    int secret;
public:
    MyClass(int s) : secret(s) {}
    friend void displaySecret(const MyClass& obj); // 声明友元函数
};

void displaySecret(const MyClass& obj) {
    std::cout << "Secret value: " << obj.secret << std::endl; // 可直接访问私有成员
}

作用域特性

• 友元函数不隶属于类，不具有this指针
• 声明在类内，但定义在类外，作用域为全局
• 不受访问控制符（如private）影响其声明位置

2.2 声明全局函数为友元：理论与实例

语法结构与语义

#include <iostream>
class Counter {
    int value;
public:
    Counter() : value(0) {}
    friend void reset(Counter& c); // 声明友元
};

void reset(Counter& c) {
    c.value = 0; // 合法：友元可访问私有成员
}

典型应用场景

• 运算符重载（如 operator<< 输出自定义对象）
• 跨类状态同步函数
• 调试与日志注入接口

2.3 成员函数作为友元：跨类访问控制

语法与基本用法

class ClassA {
private:
    int secret;
public:
    ClassA(int s) : secret(s) {}
    friend void ClassB::accessSecret(ClassA&); // 声明ClassB的成员函数为友元
};

class ClassB {
public:
    void accessSecret(ClassA& a);
};

void ClassB::accessSecret(ClassA& a) {
    std::cout << "Accessing secret: " << a.secret << std::endl; // 可直接访问私有成员
}

访问权限的粒度控制

• 仅授予必要函数访问权限，避免将整个类声明为友元
• 提升封装性的同时，支持协同操作
• 适用于数据同步、联合调试等场景

2.4 友元函数的重载与参数匹配规则

重载友元函数的基本规则

• 友元函数不能通过类对象调用，必须显式传参；
• 多个同名友元函数需有不同的参数列表以支持重载；
• 参数匹配遵循C++标准的类型转换优先级。

代码示例：重载友元函数

class MyClass {
    int val;
public:
    MyClass(int v) : val(v) {}
    friend void display(const MyClass& obj);
    friend void display(const MyClass& obj, int format);
};

void display(const MyClass& obj) {
    std::cout << "Value: " << obj.val << std::endl;
}

void display(const MyClass& obj, int format) {
    if (format == 1)
        std::cout << "Hex: " << std::hex << obj.val << std::endl;
}

2.5 实践案例：构建高效的数据访问代理类

核心设计思路

type DataProxy struct {
    db    *sql.DB
    cache map[string]interface{}
}

func (p *DataProxy) Query(sql string) interface{} {
    if result, ok := p.cache[sql]; ok {
        return result // 缓存命中
    }
    // 否则执行数据库查询并缓存结果
    result := p.executeQuery(sql)
    p.cache[sql] = result
    return result
}

性能优化策略

• 使用连接池限制并发连接数，防止数据库过载
• 引入LRU算法管理缓存，控制内存占用
• 通过延迟加载减少初始化开销

第三章：类模板中的友元声明机制

3.1 类模板中友元函数的声明语法详解

基本声明形式

template<typename T>
class Box {
    T value;
public:
    friend void printValue(const Box& b) {
        std::cout << b.value << std::endl; // 可访问私有成员
    }
};

非模板友元与模板友元对比

• 非模板友元：在类模板内部定义的友元函数不依赖模板参数，所有实例共享同一函数
• 模板友元：需前置声明模板，允许不同模板参数间灵活访问，适用于跨类型操作

3.2 模板参数在友元声明中的绑定行为

依赖性与非依赖性声明

template<typename T>
class MyClass {
    friend void independent();           // 非依赖：立即绑定
    friend void dependent(T t) { }      // 依赖：实例化时绑定
};

class Matrix {
    std::vector> data;
    int rows, cols;
public:
    Matrix(int r, int c) : rows(r), cols(c), data(r, std::vector(c)) {}

    friend Matrix operator+(const Matrix& a, const Matrix& b) {
        if (a.rows != b.rows || a.cols != b.cols) 
            throw std::invalid_argument("Matrix dimensions mismatch");
        
        Matrix result(a.rows, a.cols);
        for (int i = 0; i < a.rows; ++i)
            for (int j = 0; j < a.cols; ++j)
                result.data[i][j] = a.data[i][j] + b.data[i][j];
        return result;
    }
};

template<typename T>
class MyClass {
    template<typename U>
    friend void process(const MyClass<U>& obj);
};

template class std::vector<MyClass>; // 显式实例化类模板
template void swap<int>(int&, int&); // 显式实例化函数模板

template
class Container {
    template
    friend void process(const Container&);
};

template
void process(const Container&) { /* 处理逻辑 */ }

Container obj;
process(obj); // 显式指定U = int

type Serializer interface {
    Serialize(v interface{}) ([]byte, error)
    Deserialize(data []byte, v interface{}) error
}

// 优化前：频繁的字符串拼接
result := ""
for _, s := range strings {
    result += s // O(n²) 时间复杂度
}

// 优化后：使用 strings.Builder
var builder strings.Builder
for _, s := range strings {
    builder.WriteString(s) // O(n)
}
result := builder.String()