blocks|key|635983|text|你不能做你想做的事...如果我错了，谁来纠正我。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|635984|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Well you cannot do what your are trying to do...
Somebody correct me if I am wrong.

blocks|key|636041|text|class+myClass+{
++++int+x;
++++mutable+int+y;
public:
++++myclass()+:+x(1)+{}
++++void+foo1+()+{x%2B%2B;+y%2B%2B}++++++//+this+can+change+x+or+y
++++void+foo2+()+const+{+y--;+}++//+this+can't+change+x+by+can+change+y
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|636042|如果像这样将成员函数标记为const，则不能在该成员中执行任何修改对象成员的操作(除非该成员是mutable或static+--而static根本不是对象的成员)。|unstyled|offset|length|style|CODE|636043|请注意，这不会简单地阻止您调用试图执行此类修改的函数--相反，标记为const但试图修改对象状态的函数根本不会编译。|636044|然而，我应该补充说，我一点也不相信这真的是最好的设计。相反，在我看来，您对x和y的要求足够复杂，它们作为单独的类直接执行适当的约束可能更有意义(例如，通过为只在正确的环境下接受输入的operator=提供重载)。|636045|换句话说，我在上面展示的mutable的用法(我认为)是对您提出的问题的最简单和最直接的回答，但是您似乎很可能没有真正提出您应该问的问题，并且您更有可能从更改设计中获益--不幸的是，您还没有告诉我们更好的设计可能是什么的“大局”。|636046|entityMap^0|0|D|5|1B|7|1J|6|1T|6|0|Y|5|0|11|1|13|1|2J|9|0|C|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@$G|U|H|V|I|J]|$G|W|H|X|I|J]|$G|Y|H|Z|I|J]|$G|10|H|11|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@$G|13|H|14|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|15|8|@$G|16|H|17|I|J]|$G|18|H|19|I|J]|$G|1A|H|1B|I|J]]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@$G|1D|H|1E|I|J]]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|1F|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>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
};
</code></pre>

If you mark a member function <code>const</code> like this, you can't do anything in that member that would modify a member of the object (unless that member is <code>mutable</code> or <code>static</code> -- and <code>static</code> isn't really a member of an object at all).

Note that this won't simply prevent you from calling a function that attempts to do such modification -- rather, a function that's marked <code>const</code> but tries to modify the object state won't compile at all.

I should add, however, that I'm not at all convinced that this is really the best design. Rather the contrary, it sounds to me like your requirements on <code>x</code> and <code>y</code> are sufficiently complex that they would probably make more sense as separate classes that enforce the proper constraints directly (e.g., by providing an overload for <code>operator=</code> that only accepts input under the correct circumstances).

In other words, the use of <code>mutable</code> I've shown above is (I think) the simplest and most direct answer to the question you've asked, but it seems fairly probable that you're not really asking the question you should, and you're more likely to benefit from changing the design -- unfortunately, you haven't told us enough about the "big picture" to suggest what the better design might be.

blocks|key|636119|text|好吧，我不确定这是否值得你的努力，无论如何，只是为了以防万一这是一个测验或什么，试着把私人继承和朋友结合起来：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|636120|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%2B%2B;+y%2B%2B}++++++//+this+can+change+x+or+y
};
MyClass+:+public+MyClassXY+{
public:
++++void+foo2+()+const+{+y--;+}++//+this+can't+change+x+but+can+change+y
};|code-block|syntax|javascript|636121|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Well, I am not sure it is worth your effort, anyway, just in case this is quiz or sth, try to combine private inheritance with friend:

<pre><code>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
};
</code></pre>

blocks|key|4466216|text|从技术上讲，答案是否定的，只要类可以看到变量并且它不是常量-它可以修改它。但是您可以通过将您想要锁定的变量解耦到一个单独的类中来实现您想要的功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4466217|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Technically, the answer is no, as long the class can see the variable and it's not constant - it can modify it.
But you could accomplish what you want by decoupling the variable you want locked into a separate class.

blocks|key|3985236|text|创建一个具有私有x变量的类。在其中编写你的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3985237|从这个类派生出你的实际类。使x持有者成为实际类的朋友。|3985238|X+holder在x+holder中使用类似于强制转换(静态类型转换为base)的CRTP，将其转换为指向实际类的指针。|3985239|从你的x持有者中暴露一个x+getter。|3985240|我不想麻烦自己，但这比滥用mutable和const要好。|3985241|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Create a class with a private x variable. In it write your method.

Derive from this class your actual class. Make the x holder a friend of the actual class.

X holder uses CRTP like casting (static cast to base) in the x holder to turn this into a pointer to your actual class.

Expose an x getter from your x holder.

I would not bother myself, but this is better than abusing mutable and const.

blocks|key|81930|text|好的，所有其他我不喜欢的答案，所以我的想法是:隐藏变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|81931|#define+READONLY(TYPE,+VAR)+const+TYPE&+VAR+=+this->VAR+//C%2B%2B03
#define+READONLY(VARIABLE)+const+auto&+VARIABLE+=+this->VARIABLE+//C%2B%2B11

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%2B%2B;+
++++++++y%2B%2B;
++++}+
++++void+foo2+()+{//+This+shouldn't+be+able+to+change+x
++++++++READONLY(x);+//in+this+function,+x+is+read-only
++++++++x%2B%2B;+//error:+increment+of+read-only+variable+'x'
++++++++y%2B%2B;
++++}+
};|code-block|syntax|javascript|81932|仍然有一些方法可以绕过变量的锁定(比如this->x)，但是对于这些情况什么也做不了。|offset|length|style|CODE|81933|entityMap^0|0|0|J|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Alright, all the other answers I dislike, so here's my idea: hide the variable.

<pre><code>#define READONLY(TYPE, VAR) const TYPE&amp; VAR = this-&gt;VAR //C++03
#define READONLY(VARIABLE) const auto&amp; VARIABLE = this-&gt;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++;
 } 
};
</code></pre>

There are still ways to bypass the locking of the variable (such as <code>this-&gt;x</code>), but nothing can be done for those situations.

blocks|key|81954|text|使x成为subClass的private成员，并使foo1成为subClass的朋友函数。如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|81955|class+myClass+{
++++int+y;++//+Regular+variable
++++myClass()+:+x+(1)+{}
++++void+foo1+()+{x.x%2B%2B;+y%2B%2B;}+//+This+can+change+x
++++void+foo2+()+{x.x--;+y--;}+//+This+shouldn't+be+able+to+change+x
++++++++++++++++++++++++++++//+I+want+it+to+throw+a+compile+error
++++class+subClass+{
++++++friend+void+myClass::foo1()+;+//+This+must+come+after+the+declaration+of+foo1
++++++int+x+;+//+private
++++public:
++++++subClass+(int+x)+:+x+(x)+{+}
++++++int+read_x()+const+{+return+x+;+}
++++++}+x+;
};|code-block|syntax|javascript|81956|这将抛出一个编译器错误，恰好是您想要的位置。|81957|entityMap^0|1|1|4|8|D|7|P|4|V|8|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

Make <code>x</code> a <code>private</code> member of a <code>subClass</code>, and make <code>foo1</code> a friend function of the <code>subClass</code>. Like this:

<pre><code>class myClass {
 int y; // Regular variable
 myClass() : x (1) {}
 void foo1 () {x.x++; y++;} // This can change x
 void foo2 () {x.x--; y--;} // This shouldn't be able to change x
 // I want it to throw a compile error
 class subClass {
 friend void myClass::foo1() ; // This must come after the declaration of foo1
 int x ; // private
 public:
 subClass (int x) : x (x) { }
 int read_x() const { return x ; }
 } x ;
};
</code></pre>

This throws a compiler error, just where you wanted it.

I am using a member variable and at some point of the program I want to change it, but i prefer to "lock it" everywhere else to prevent unintended changes. 

Code to explain:

<pre><code>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
};
</code></pre>

The question is: Can it be achieved in some way? Something like permanent const_cast?

I know I could use constructor initialization list and constant right away, but i need to change my variable later.

Can a variable be locked to prevent changes to it in c++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我使用了一个成员变量，并且在程序的某个点上我想要更改它，但我更喜欢在其他地方“锁定它”，以防止意外的更改。用于解释的代码：class myClass {    int x;  // This should be prevented to being changed most of the time    int y; ...

问是否可以锁定变量以防止在c++中对其进行更改？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否可以锁定变量以防止在c++中对其进行更改？EN