类变量：公共访问只读，但私有访问读/写

Question

哎呀，暂时不在那个套接字库上工作。我正在尝试在 C++ 方面对自己进行更多的教育。

对于类，有没有办法使变量对公众只读，但在私有访问时读+写？例如像这样：

class myClass {
    private:
    int x; // this could be any type, hypothetically

    public:
    void f() {
        x = 10; // this is OK
    }
}

int main() {
    myClass temp;

    // I want this, but with private: it's not allowed
    cout << temp.x << endl;


    // this is what I want:

    // this to be allowed
    temp.f(); // this sets x...

    // this to be allowed
    int myint = temp.x;

    // this NOT to be allowed
    temp.x = myint;
}

简而言之，我的问题是如何允许从 f() 内完全访问 x，但从其他任何地方进行只读访问，即允许 int newint = temp.x;，但不允许 temp.x = 5;？类似于 const 变量，但可从 f() 写入...

编辑：我忘了提到我打算返回一个大向量实例，使用 getX() 函数只会复制它，它并不是真正的最佳选择。我可以返回一个指向它的指针，但这是 iirc 的不好做法。

P.S.：如果我只是想基本上展示我的指针知识并询问它是否完整，我会在哪里发布？谢谢！

Answer 1

当然可以：

class MyClass
{
    int x_;

public:
    int x() const { return x_; }
};

如果您不想复制（对于整数，没有开销），请执行以下操作：

class MyClass
{
    std::vector<double> v_;

public:
    decltype(v)& v() const { return v_; }
};

或使用 C++98：

class MyClass
{
    std::vector<double> v_;

public:
    const std::vector<double>& v() const { return v_; }
};

这不会进行任何复制。它返回一个reference to const。

Answer 2

虽然我认为返回 const T& 的 getter 函数是更好的解决方案，但您几乎可以使用您要求的语法：

class myClass {
    private:
    int x_; // Note: different name than public, read-only interface

    public:
    void f() {
        x_ = 10; // Note use of private var
    }
    const int& x;
    myClass() : x_(42), x(x_) {} // must have constructor to initialize reference
};

int main() {
    myClass temp;

    // temp.x is const, so ...
    cout << temp.x << endl; // works
    // temp.x = 57;  // fails

}

编辑：使用代理类，您可以准确地获得您要求的语法：

class myClass {
public:

    template <class T>
    class proxy {
        friend class myClass;
    private:
        T data;
        T operator=(const T& arg) { data = arg; return data; }
    public:
        operator const T&() const { return data; }
    };

    proxy<int> x;
    // proxy<std::vector<double> > y;


    public:
    void f() {
        x = 10; // Note use of private var
    }
};

temp.x 在类中似乎是可读写的int，但在main 中是只读的int。

Answer 3

一个简单的解决方案，like Rob's，但没有构造函数：

class myClass {
private:
    int m_x = 10; // Note: name modified from read-only reference in public interface
public:
    const int& x = m_x;
};

int main() {
    myClass temp;

    cout << temp.x << endl; //works.
    //temp.x = 57;  //fails.
}

它更像get 方法，但更短。

常量指针很简单，应该适用于您可以指向的所有类型。

Answer 4

这可能会做你想做的事。

如果您想要一个只读变量，但不希望客户端更改他们访问它的方式，请尝试使用这个模板类：

template<typename MemberOfWhichClass, typename primative>                                       
class ReadOnly {
    friend MemberOfWhichClass;
public:
    inline operator primative() const                 { return x; }

    template<typename number> inline bool   operator==(const number& y) const { return x == y; } 
    template<typename number> inline number operator+ (const number& y) const { return x + y; } 
    template<typename number> inline number operator- (const number& y) const { return x - y; } 
    template<typename number> inline number operator* (const number& y) const { return x * y; }  
    template<typename number> inline number operator/ (const number& y) const { return x / y; } 
    template<typename number> inline number operator<<(const number& y) const { return x <<y; }
    template<typename number> inline number operator>>(const number& y) const { return x >> y; }
    template<typename number> inline number operator^ (const number& y) const { return x ^ y; }
    template<typename number> inline number operator| (const number& y) const { return x | y; }
    template<typename number> inline number operator& (const number& y) const { return x & y; }
    template<typename number> inline number operator&&(const number& y) const { return x &&y; }
    template<typename number> inline number operator||(const number& y) const { return x ||y; }
    template<typename number> inline number operator~() const                 { return ~x; }

protected:
    template<typename number> inline number operator= (const number& y) { return x = y; }       
    template<typename number> inline number operator+=(const number& y) { return x += y; }      
    template<typename number> inline number operator-=(const number& y) { return x -= y; }      
    template<typename number> inline number operator*=(const number& y) { return x *= y; }      
    template<typename number> inline number operator/=(const number& y) { return x /= y; }      
    template<typename number> inline number operator&=(const number& y) { return x &= y; }
    template<typename number> inline number operator|=(const number& y) { return x |= y; }
    primative x;                                                                                
};      

使用示例：

class Foo {
public:
    ReadOnly<Foo, int> x;
};

现在您可以访问 Foo.x，但不能更改 Foo.x！ 请记住，您还需要添加按位和一元运算符！这只是一个让您入门的示例

Answer 5

您可能想模仿 C# properties 进行访问（取决于您的目标、预期环境等）。

class Foo
{
  private:
    int bar;

  public:
    __declspec( property( get = Getter ) ) int Bar;

    void Getter() const
    {
      return bar;
    }
}

Answer 6

有一种使用成员变量的方法，但这可能不是可取的方法。

有一个可写的私有成员和一个 const 引用公共成员变量，该变量为其自己的类的成员起别名。

class Foo
{
  private:
      Bar private_bar;

  public:
      const Bar& readonly_bar; // must appear after private_bar
                              // in the class definition

  Foo() :
       readonly_bar( private_bar )
  {
  }
};

这会给你你想要的。

void Foo::someNonConstmethod()
{
    private_bar.modifyTo( value );
}

void freeMethod()
{
    readonly_bar.getSomeAttribute();
}

你能做什么和你应该做什么是不同的事情。我不确定我刚刚概述的方法是否流行并且会通过许多代码审查。它还不必要地增加 sizeof(Foo) （尽管增加了少量），而简单的访问器“getter”不会，并且可以内联，因此它也不会生成更多代码。

Answer 7

您必须将其保留为私有，然后创建一个函数来访问该值；

private:

    int x;

public:

    int X()
    {
        return x;
    }

Answer 8

正如其他答案中提到的，您可以通过将其设为私有并定义 getter 函数但不定义 setter 来为类成员创建只读功能。但这对每个班级成员来说都是很多工作。

您还可以使用宏自动生成 getter 函数：

#define get_trick(...) get_
#define readonly(type, name) \
private: type name; \
public: type get_trick()name() {\
    return name;\
}

那么你就可以这样来上课了：

class myClass {
    readonly(int, x)
}

扩展为

class myClass {
    private: int x;
    public: int get_x() {
        return x;
    }
}

Answer 9

您需要将成员设为private 并提供public getter 方法。

Answer 10

我知道在 c++ 类中授予对私有数据成员只读访问权限的唯一方法是拥有一个公共函数。在你的情况下，它会喜欢：

int getx() const { return x; }

或

int x() const { return x; }.

默认情况下，通过将数据成员设为私有，您可以使其在类之外的范围内不可见（也就是无权访问）。本质上，类的成员对私有数据成员具有读/写访问权限（假设您没有将其指定为const）。类的friends 可以访问私有数据成员。

请参阅here 和/或任何good C++ book 访问说明符。

Answer 11

编写一个公共 getter 函数。

int getX(){ return x; }

Answer 12

但是 temp.x = 5;不允许？

这在发布的 sn-p 中是不允许的，因为它无论如何都被声明为 private 并且只能在类范围内访问。

这里要求访问

cout

但这里不是为了-

int myint = temp.x;

这听起来很矛盾。