C++ 中有没有办法创建“超级私有”变量？

Question

我有一个 C++ 功能的想法，我想知道是否可以创建。

假设我希望“MyClass”中的私有变量只能由公共 getter 和 setter 这两个函数访问。也就是说，如果 MyClass 的另一个公共或私有函数试图获取或更改我的超级私有变量的值，我将得到一个编译错误。但是，getter 和 setter 行为正常。

有什么想法吗？

编辑 1：一个用例是让 getter/setter 执行错误检查或其他形式的逻辑。我什至不希望类本身直接接触变量。

编辑 2： 然后是这样的：

template <class T>
class State{
private:
    T state;

public:
    State()
    {
        state = 0;
    }

    T getState()
    {
        return state;
    }

    void setState(T state)
    {
        this->state = state;
    }
};

然后任何类都可以继承它并只能通过 getter/setter 访问“状态”。当然，如果不根据你想要的逻辑修改 getter 和 setter，这个类是没有用的。

Answer 1

C++ 中可访问性的粒度是类。

所以如果你需要让一个变量只能被两个方法访问，你需要将变量和这两个方法移动到一个单独的类中，专门用于维护隐私..

Answer 2

您可以将变量包装在一个类中，并在那里将其设为私有并使用const T& getter。然后将包含类的 get 和 set 成员函数声明为该包装器的朋友。现在，您将包装类保留为原始类中的成员。这应该可以实现您想要的，尽管它看起来很难维护并且不是很有用。

所以这里有一些虚拟实现来展示它是如何工作的（请注意，整个 new VeryPrivateWrapper 业务只是一种古怪的声明方式，unique_ptr 会更有帮助）：

class VeryPrivateWrapper;

class Original {
  VeryPrivateWrapper* m_wrapper;

public:
  Original();
  // imagine that I remembered the rule of three here
  void set(int);
  void other();
};

// make this a template for more fun
class VeryPrivateWrapper {
  int m;
public:
  const int& get() const { return m; } 
  // !!!
  // the important bit 
  // !!!
  friend void Original::set(int);
};

Original::Original() : m_wrapper(new VeryPrivateWrapper) {}

void Original::set(int i) {
    m_wrapper->m = i;
}

void Original::other() {
  // this borks as we would like
  // m_wrapper->m = 23;
}

int main()
{
  Original o;
  o.set(3);
  return 0;
}

Answer 3

我相信这就是您所要求的。这是可取的吗？有些人会认为这是可憎的。

如果您决定使用它，您可能希望从宏中提取公共 Get 和 Set 并手动编写它们。

#define SUPER_PRIVATE(c,t,m) \
template <typename C, typename T> \
class SuperPrivate##m { \
    friend T& C::Get##m(); \
    friend void C::Set##m(const T&); \
    T value; \
}; \
public: \
    t& Get##m() { return m.value; } \
    void Set##m(const t& value) { m.value = value; } \
private: \
    SuperPrivate##m<c,t> m; 

class SomeClass
{
public:
    SomeClass()
    {
        SetX(42);
        SetY(58);
    }
    int DosomethingWithX() { return GetX() * 2; }
//  int DosomethingWithX2() { return X.value * 2; } // error
//  int DosomethingWithX3() { return X; } // error

    SUPER_PRIVATE(SomeClass, int, X);
    SUPER_PRIVATE(SomeClass, int, Y);
};

int main()
{
    SomeClass someObject;
    int x1 = someObject.GetX();
    int y1 = someObject.GetY();
    someObject.SetY(89);
    int y2 = someObject.GetY();
    int x2 = someObject.DosomethingWithX();

}

Answer 4

我会给变量取一个非常丑陋的名字，给 getter/setter 取个好听的名字：

class Foo
{
private:
    int _hey_do_not_use_me_im_super_private_whatever;
public:
    int get_whatever() const
    {
        //extra logic
        return _hey_do_not_use_me_im_super_private_whatever;
    }
    void set_whatever(int we)
    {
        //extra logic
        _hey_do_not_use_me_im_super_private_whatever = we;
    }
};

解释超级私有意味着什么的评论将受到继承您代码的人的欢迎。