Question

我正在使用一个成员变量，并且在程序的某个时刻我想要更改它，但我更喜欢在其他地方“锁定”以防止意外更改。

代码解释：

class myClass {
    int x;  // This should be prevented to being changed most of the time
    int y;  // Regular variable
    myclass() {x = 1;}
    void foo1 () {x++; y++;} // This can change x
    void foo2 () {x--; y--;} // This shouldn't be able to change x
                             // I want it to throw a compile error
};

问题是：能以某种方式实现吗？像永久const_cast？

我知道我可以立即使用构造函数初始化列表和常量，但我需要稍后更改我的变量。

Answer 1

好吧，我不喜欢所有其他答案，所以这是我的想法：隐藏变量。

#define READONLY(TYPE, VAR) const TYPE& VAR = this->VAR //C++03
#define READONLY(VARIABLE) const auto& VARIABLE = this->VARIABLE //C++11

class myClass {
    int x;  // This should be prevented to being changed most of the time
    int y;  // Regular variable
    myClass() :x(1), y(2) {}
    void foo1 () {// This can change x
        x++; 
        y++;
    } 
    void foo2 () {// This shouldn't be able to change x
        READONLY(x); //in this function, x is read-only
        x++; //error: increment of read-only variable 'x'
        y++;
    } 
};

仍有办法绕过变量的锁定（例如this->x），但对于这些情况无法做任何事情。

Answer 2

class myClass {
    int x;
    mutable int y;
public:
    myclass() : x(1) {}
    void foo1 () {x++; y++}      // this can change x or y
    void foo2 () const { y--; }  // this can't change x by can change y
};

如果您像这样标记成员函数const，则您无法在该成员中执行任何可修改对象成员的内容（除非该成员为mutable或static - 而且static根本不是对象的成员。

请注意，这不会简单地阻止您调用尝试进行此类修改的函数 - 而是标记为const但尝试修改对象状态的函数根本不会编译。< / p> 但是，我应该补充一点，我完全不相信这是最好的设计。恰恰相反，我觉得你对x和y的要求足够复杂，以至于他们可能更直接地强制执行适当的约束（例如，通过提供重载operator=仅在正确的情况下接受输入。）

换句话说，我上面显示的mutable的使用是（我认为）对您提出的问题的最简单和最直接的答案，但似乎公平可能你并没有真正提出你应该提出的问题，而且你更有可能从更改设计中受益 - 不幸的是，你没有告诉我们足够的“大图”来暗示更好的设计可能是什么

Answer 3

嗯，我不确定这是值得你努力的，无论如何，以防万一这是测验或者......，尝试将私人继承与朋友结合起来：

class MyClassX {
protected:
  MyClassX() : x(1) {}
  int x;
public:
  int getX() const { return x; } // read only access
};
class MyClassY {
protected:
  MyClassY() : y(0) {}
  int y;
  friend class MyClass;
public:
  int getY() const { return y; }
};
class MyClassXY : private MyClassX, private MyClassY {
public:
    void foo1 () {x++; y++}      // this can change x or y
};
MyClass : public MyClassXY {
public:
    void foo2 () const { y--; }  // this can't change x but can change y
};

Answer 4

让x成为private的{{1}}成员，并使subClass成为foo1的朋友功能。像这样：

subClass

这会抛出编译器错误，就在你想要的地方。

Answer 5

嗯，你不能做你想做的事...... 如果我错了，有人会纠正我。

Answer 6

从技术上讲，答案是否定的，只要类可以看到变量并且它不是常量 - 它可以修改它。但是你可以通过将你想要锁定的变量分离到一个单独的类来完成你想要的。

Answer 7

使用私有x变量创建一个类。在里面写下你的方法。

从这个班级派生你的实际班级。使x持有者成为实际类的朋友。

X持有者在x持有者中使用类似CRTP的投射（静态转换为基础），将其转换为指向实际类的指针。

从x支架上露出x吸气剂。

我不会打扰自己，但这比滥用mutable和const更好。

可以锁定变量以防止在c ++中对其进行更改吗？

7 个答案: