第五节 · 偷懒的诀窍 · 合成函数与虚析构

良好的类设计是写出高质量代码的关键。这一节我们探讨一些高级的类设计技巧。

---

友元

class Box
{
private:
    double width;
    
public:
    Box(double w) : width(w) {}
    
    // 友元函数：可以访问私有成员
    friend void printWidth(const Box& b);
    
    // 友元类：整个类都可以访问
    friend class BoxFactory;
};

void printWidth(const Box& b)
{
    cout << "Width: " << b.width << endl;  // OK：友元可以访问
}

class BoxFactory
{
public:
    static Box createBox(double w)
    {
        Box b(w);
        b.width *= 2;  // OK：友元类可以访问
        return b;
    }
};

注意：友元会破坏封装，谨慎使用。

---

内部类

class LinkedList
{
private:
    // 内部类
    struct Node
    {
        int data;
        Node* next;
        Node(int d) : data(d), next(nullptr) {}
    };
    
    Node* head = nullptr;
    
public:
    void add(int data)
    {
        Node* node = new Node(data);
        node->next = head;
        head = node;
    }
    
    // 迭代器也可以是内部类
    class Iterator
    {
        Node* current;
    public:
        Iterator(Node* n) : current(n) {}
        int& operator*() { return current->data; }
        Iterator& operator++()
        {
            current = current->next;
            return *this;
        }
        bool operator!=(const Iterator& other)
        {
            return current != other.current;
        }
    };
    
    Iterator begin() { return Iterator(head); }
    Iterator end() { return Iterator(nullptr); }
};

---

单例模式

class Singleton
{
private:
    // 私有构造函数
    Singleton() { cout << "Singleton created" << endl; }
    
    // 禁止复制
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
public:
    // 获取唯一实例
    static Singleton& getInstance()
    {
        static Singleton instance;  // C++11 保证线程安全
        return instance;
    }
    
    void doSomething()
    {
        cout << "Doing something" << endl;
    }
};

int main()
{
    Singleton::getInstance().doSomething();
    Singleton::getInstance().doSomething();  // 同一个实例
    
    return 0;
}

---

工厂模式

class Product
{
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

class ConcreteProductA : public Product
{
public:
    void use() override { cout << "Using product A" << endl; }
};

class ConcreteProductB : public Product
{
public:
    void use() override { cout << "Using product B" << endl; }
};

// 工厂类
class ProductFactory
{
public:
    static unique_ptr<Product> create(const string& type)
    {
        if (type == "A")
            return make_unique<ConcreteProductA>();
        else if (type == "B")
            return make_unique<ConcreteProductB>();
        return nullptr;
    }
};

int main()
{
    auto p = ProductFactory::create("A");
    p->use();
    
    return 0;
}

---

PIMPL 模式（指针到实现）

// Widget.h - 头文件
class Widget
{
public:
    Widget();
    ~Widget();
    void doSomething();
    
private:
    class Impl;           // 前向声明
    unique_ptr<Impl> pImpl;
};

// Widget.cpp - 实现文件
class Widget::Impl
{
public:
    void doSomething()
    {
        cout << "Implementation details" << endl;
    }
};

Widget::Widget() : pImpl(make_unique<Impl>()) {}
Widget::~Widget() = default;

void Widget::doSomething()
{
    pImpl->doSomething();
}

优点：

• 隐藏实现细节

• 减少编译依赖

• 改变实现不需要重新编译用户代码

---

Builder 模式

class Pizza
{
public:
    string dough;
    string sauce;
    string topping;
    
    void show()
    {
        cout << "Pizza: " << dough << ", " << sauce << ", " << topping << endl;
    }
};

class PizzaBuilder
{
    Pizza pizza;
    
public:
    PizzaBuilder& setDough(const string& d)
    {
        pizza.dough = d;
        return *this;
    }
    
    PizzaBuilder& setSauce(const string& s)
    {
        pizza.sauce = s;
        return *this;
    }
    
    PizzaBuilder& setTopping(const string& t)
    {
        pizza.topping = t;
        return *this;
    }
    
    Pizza build()
    {
        return pizza;
    }
};

int main()
{
    Pizza pizza = PizzaBuilder()
        .setDough("thin")
        .setSauce("tomato")
        .setTopping("cheese")
        .build();
    
    pizza.show();
    
    return 0;
}

---

不可复制类

class NonCopyable
{
public:
    NonCopyable() = default;
    ~NonCopyable() = default;
    
    // 禁止复制
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
    
    // 允许移动
    NonCopyable(NonCopyable&&) = default;
    NonCopyable& operator=(NonCopyable&&) = default;
};

// 继承使用
class UniqueResource : private NonCopyable
{
    // ...
};

---

类型擦除

#include <functional>

// 使用 std::function 实现类型擦除
class Callback
{
    function<void()> fn;
    
public:
    template<typename F>
    Callback(F f) : fn(f) {}
    
    void invoke() { fn(); }
};

int main()
{
    Callback c1([]{ cout << "Lambda" << endl; });
    
    struct Functor
    {
        void operator()() { cout << "Functor" << endl; }
    };
    Callback c2(Functor());
    
    c1.invoke();
    
    return 0;
}

---

命名参数模式

class Config
{
public:
    string host = "localhost";
    int port = 8080;
    bool ssl = false;
    
    Config& setHost(const string& h) { host = h; return *this; }
    Config& setPort(int p) { port = p; return *this; }
    Config& setSSL(bool s) { ssl = s; return *this; }
};

void connect(const Config& config)
{
    cout << "Connecting to " << config.host << ":" << config.port << endl;
}

int main()
{
    connect(Config().setHost("example.com").setPort(443).setSSL(true));
    return 0;
}

---

习题

• 实现一个线程安全的单例类。

• 使用 PIMPL 模式重构一个类。

• 设计一个使用 Builder 模式的 HTML 生成器。