C++：无法弄清楚如何正确隐藏实现细节

Question

我有以下设置：

foo.h:

class A {
    friend class B;
private:
    A() {}
};

class B {
public:
    void addObject(Object &o); // adds to myMember; A is not exposed!
    void computeResult(Result &r); // uses myMember to compute result
private:
    vector<A> myMember;
};

A 的对象永远不会暴露给包括foo.h 在内的任何程序。带有A 的向量仅用于帮助B 发挥其计算适配器的作用。通过将A 的构造函数设为私有，我想我可以避免其他编译单元使用它，而且它似乎可以工作。但是问题出在

foo.cpp

void B::computeResult(Result &r) {
    MyCustomStorage<A> storage;
    A *a = storage.allocate(); // error: "A::A() is private"
}

MyCustomStorage 的一部分看起来像这样：

template <typename T>
class MyCustomStorage {
    T *allocate() {
        ...
        T *ptr = new T[count]; // error: "A::A() is private"
        ...
    }
};

但我认为既然allocate() 是从成员函数调用的，这不会发生！我该如何解决这个问题？

让A 成为MyCustomStorage 的朋友似乎非常意大利面。将A 设为B 的私有嵌套类会使foo.cpp 中的各种帮助类失败，因为“A 是私有的”。

那么解决这个问题的最干净的方法是什么？

解决方案

我最终选择了@potatoswatter 的第二个解决方案，并进行了以下适当的更改：

foo.h

class B {
public:
    void addObject(Object &o); // adds to myMember; A is not exposed!
    void computeResult(Result &r); // uses myMember to compute result
private:
    class A {
    private:
        A() {}
    };
    class Helper; // forward declared!
    vector<A> myMember;
};

foo.cpp

class B::Helper {
    int help(A& a) { return 42; } // no problem! Helper is a member of B
}

void B::computeResult(Result &r) {
    MyCustomStorage<A> storage;
    A *a = storage.allocate(); // no problem! A is a member of B
    Helper h;
    h.help(*a); // no problem!
}

Answer 1

私有的不是A的构造函数，而是整个类。

最好的解决方案是创建一个“私有”命名空间。 C++ 没有命名空间级别的访问保护，但可以合理地预期用户不会访问不熟悉的命名空间。

namespace impl {
struct A {
    A() {}
};
}

class B {
public:
    void addObject(Object &o); // adds to myMember; A is not exposed!
    void computeResult(Result &r); // uses myMember to compute result
private:
    vector<impl::A> myMember;
};

另一种方法是让A 成为B 的成员。这以更深的嵌套为代价提供了“真正的”访问保护。我个人更喜欢第一种解决方案，并避免嵌套类。

class B {
public:
    void addObject(Object &o); // adds to myMember; A is not exposed!
    void computeResult(Result &r); // uses myMember to compute result
private:
    struct A {
        A() {}
    };

    vector<A> myMember;
};

任何需要A 的助手都需要成为朋友。有多种解决方法，例如将 A 嵌套在具有 protected 访问权限的基类中，但实际上，namespace impl 提供的妥协最少。

Answer 2

恕我直言，您有几个选择。您可以 1) 使用 Pimpl 成语，或者，2) 您可以使用前向声明。

Pimpl 成语例子：

class B {
public:
    void addObject(Object &o); // adds to myMember; A is not exposed!
    void computeResult(Result &r); // uses myMember to compute result
private:
    class Impl;
    Impl *pimpl;
};

在您的 *.cpp 文件中，您可以定义 Impl 类并使用它。

class B::Impl {
public:
    std::vector<A> stuff;
}

B::B() : pimpl(new Impl) {
}

B::~B() {
    delete pimpl;
}

void B::AddObject(Object &o) {
    pimpl->stuff.Fx(o);
}

您也可以为 Pimpl 习语使用智能指针，我只是为了清晰/简洁而没有在这里。

如果A 与B 在同一个命名空间中，也可以使用前向声明

class B {
public:
    void addObject(Object &o); // adds to myMember; A is not exposed!
    void computeResult(Result &r); // uses myMember to compute result
private:
    std::vector<class A*> myMember;
};

但是这个习惯用法与您的要求根本不同，并限制您在对象myMember 中使用指针，您可能不想这样做。内联定义class A* 也是一种非标准的前向声明方法。当然，使用智能指针会降低该位置内存泄漏的可能性。