Kann eine Variable gesperrt werden, um Änderungen in C++ zu verhindern?

Question

Ich benutze eine Member-Variable und an einem Punkt des Programms möchte ich es ändern, aber ich bevorzuge es "überall zu sperren", um unbeabsichtigte Änderungen zu verhindern.

-Code zu erklären:

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 
}; 

Die Frage ist: Kann es in irgendeiner Weise erreicht werden? Etwas wie permanente const_cast?

Ich weiß, ich könnte Konstruktor Initialisierungsliste und Konstante sofort verwenden, aber ich muss später meine Variable ändern.

Answer 1

Okay, all die anderen Antworten, die ich nicht mag, also hier ist meine Idee: Verstecke die Variable.

#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++; 
    } 
}; 

Es gibt immer noch Möglichkeiten, um die Verriegelung der Variablen (wie this->x) zu umgehen, aber nichts kann für solche Situationen durchgeführt werden.

Answer 2

Nun, Sie können nicht tun, was Sie versuchen zu tun ... Jemand korrigiert mich, wenn ich falsch liege.

Answer 3

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 
}; 

Wenn Sie eine Memberfunktion const wie diese markieren, können Sie nichts in diesem Element tun, die ein Mitglied des Objekts ändern würde (es sei denn, dass die Mitglieds mutable oder static ist - und static ist nicht wirklich ein Mitglied eines Objekts überhaupt).

Beachten Sie, dass dies Sie nicht einfach daran hindert, eine Funktion aufzurufen, die versucht, eine solche Änderung durchzuführen - eine Funktion, die mit const markiert ist, aber versucht, den Objektstatus zu ändern, wird überhaupt nicht kompiliert.

Ich sollte jedoch hinzufügen, dass ich überhaupt nicht davon überzeugt bin, dass dies wirklich das beste Design ist. Eher im Gegenteil, es klingt für mich so, als ob Ihre Anforderungen an x und y ausreichend komplex sind, dass sie wahrscheinlich sinnvoller wären als separate Klassen, die die richtigen Einschränkungen direkt erzwingen (z. B. durch Bereitstellung einer Überlast für operator=, die nur Eingaben unter dem richtigen akzeptiert Umstände).

Mit anderen Worten, die Verwendung von mutable ich oben gezeigt habe, ist (glaube ich) die einfachste und direkteste Antwort auf die Frage, die Sie gefragt haben, aber scheint es ziemlich wahrscheinlich, dass Sie nicht wirklich sind gefragt die Frage, die Sie sollten, und Sie werden wahrscheinlich von der Änderung des Designs profitieren - leider haben Sie uns nicht genug über das "große Bild" gesagt, um vorzuschlagen, was das bessere Design sein könnte.

Answer 4

Nun, ich bin nicht sicher, ob es mir lohnt, Ihre Bemühungen, wie auch immer, nur für den Fall des Quiz oder etw ist, versuchen private Vererbung mit Freund zu kombinieren:

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 5

Technisch gesehen ist die Antwort nein, wie lang kann die Klasse die Variable sehen und sie ist nicht konstant - sie kann sie verändern. Aber Sie könnten erreichen, was Sie wollen, indem Sie die Variable, die Sie sperren möchten, in eine separate Klasse entkoppeln.

Answer 6

Erstellen Sie eine Klasse mit einer privaten x-Variablen. Schreibe darin deine Methode.

Ableiten von dieser Klasse Ihre tatsächliche Klasse. Machen Sie den x-Halter zu einem Freund der aktuellen Klasse.

X Halter verwendet CRTP wie Casting (statisch zu Base) in den X Halter, um dies zu einem Zeiger auf Ihre tatsächliche Klasse zu machen.

Setzen Sie einen x-Getter von Ihrem x-Halter frei.

Ich würde mich nicht stören, aber das ist besser als missbrauchen veränderlich und const.

Answer 7

Make x ein private Mitglied einer subClass und machen foo1 ein Freund Funktion des subClass. Gefällt mir:

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 ; 
}; 

Dies wirft einen Compilerfehler, genau dort, wo Sie es wollten.