c++ - 具有不同访问权限的类 : read-only to the many, 可写入特权

Question

我有一些大量的字符串分组在一些类中，所有这些都分组在一个最终的巨型类中。这个类必须由另一个类填充，并且它的不可变内容暴露给一些客户。 (当然，这些类比较复杂，这是一个简化的示意图。)

解决方案一:

class A
{
friend class M;

private:
    B m_b;
    C m_c;
    D m_d;

public:
    const B& GetB() const { return m_b;}
    const C& GetC() const { return m_C;}
    const D& GetD() const { return m_D;}

private:
    B& GetB() { return m_b;}
    C& GetC() { return m_C;}
    D& GetD() { return m_D;}
}

其中 B 是这样的:

class B
{
friend class M;

private:
    std::string m_camel;
    std::string m_pink;
    std::string m_vandergraaf;

public:
    const std::string& Camel() const { return m_camel;}
    const std::string& PinkFloyd() const { return m_pink;}
    const std::string& VanDerGraafGenerator() const { return m_vandergraaf;}

private:
    void SetCamel(const char* prog) { m_camel = prog;}
    void SetPinkFloyd(const char* prog) { m_pink = prog;}
    void SetVanDerGraafGenerator(const char* prog) { m_vandergraaf = prog;}
}

一个更好的解决方案，避免 friend 为 protected 公开写访问类给 M 和基础类，只读给世界。

解决方案 2:

class A
{
protected:
    B m_b;
    C m_c;
    D m_d;

public:
    const B& GetB() const { return m_b;}
    const C& GetC() const { return m_C;}
    const D& GetD() const { return m_D;}
}

//  only visible to M
class A_Write: public A
{
public:
    B& GetB() { return m_b;}
    C& GetC() { return m_C;}
    D& GetD() { return m_D;}
}

也许 B 也一样。这不是一个很好的解决方案，因为客户也可以派生他们自己的类。

更好但更多约束的变体是解决方案 3:

class A
{
private:
    const B m_b;
    const C m_c;
    const D m_d;

public:
    const B& GetB() const { return m_b;}
    const C& GetC() const { return m_C;}
    const D& GetD() const { return m_D;}

protected:
    A(const B& b, const C& c, const D& d): m_b(), m_c(c), m_d(d) {}
}

//  only visible to M
class A_Write: public A
{
public:
    A_Write(const B& b, const C& c, const D& d): A(b, c, d) {}
}

我的首选解决方案是 4，也就是 ... 3，但 B、C、D 是简单的 struct 而不是 class。所以M可以直接在B、C、D中做任何它想做的事情，然后构造一个A_Write。

有什么更好的主意吗？

Answer 1

一种可能的方法是使用代理来减少类的接口(interface)。
类 M 将实例化/接收 S 的实例(以便能够使用其接口(interface)修改它)，但它将返回一个代理 P 给读者(不会设法修改它)。
它遵循一个最小的例子:

struct S {
    void value(int v) noexcept { t = v; }
    int value() const noexcept { return t; }
private:
    int t{0};
};

struct P {
    P(S& s): b{s} { }
    int value() const noexcept { return b.value(); }
private:
    S& b;
};

int main() {
    // the class: full interface
    S s;
    // the proxy: reduced interface
    P p{s};
}