Wenn Klasse A seine Konstruktionsparameter ändert, kann ich const A mit const Parametern initialisieren?

Question

Angenommen, ich habe

class A final { 
    int& ir; 
public: 
    A(int& x) : ir(x) { } 
    void set(int y) { ir = y; } // non-const method! 
    int get() const { return ir; } 
}; 

und

const int i; 

Offensichtlich ich nicht

A a(i); 

da diese Pausen Konstantheit haben kann. Aber ich kann auch nicht haben

const A a(i); 

trotz der Tatsache, dass dies constness de-facto nicht brechen wird. C++ unterstützt keine "Const-Only" -Ktors, z.B. in diesem Fall würde man eine const int& nehmen. Gibt es eine Möglichkeit const A a Einwickeln einen Verweis auf i zu erhalten - anders als

A a(const_cast<int &>(i)) 

?

Answer 1

class A { 
    const int& ir; // <<-- it's a const int. 
    /* ... */ 
public: 
    A(int& x) : ir(x) { } 
}; 

Answer 2

Es ist komisch, aber

class A final { 
    union{ 
    int& ir; 
    const int ○ 
    }; 
public: 
    A(int& x) : ir(x) { } 
    A(const int& x) : cir(x) { } 
    void set(int y) { ir = y; } // non-const method! 
    int get() const { return ir; } 
}; 

int main(int argc, char *argv[]) 
{ 
    const int cv = 8; 
    int v = 6; 
    A a(cv); 
    std::cout << a.get() << std::endl; 
    a.set(v); 
    std::cout << a.get() << std::endl; 
    return 0; 
} 

Auch Ihr Set und Verfahren opearates auf Werte keine Referenzen bekommen, es ist so aussieht wie Sie etwas falsch

Answer 3

C++ nicht über ein Konzept vollständig konstante Klassen, und der Compiler wird möglicherweise nicht ausgeführt, wenn die Referenz int & nur als const int & verwendet wird. Also im Grunde kannst du es nicht tun.

Answer 4

"Const" bedeutet, dass das Objekt zwischen dem Konstruktorende und dem Destruktorbeginn konstant ist (während der Konstruktion muss es möglich sein, das Objekt zu ändern). C++ hat keinen "Vorbereitungskonstruktor", der für konstante Objekte bevorzugt wird.

Sie können diese Problemumgehung versuchen, indem Sie anwenden. Dies ist zum Zeitpunkt der Kompilierung nicht vollständig typsicher, erkennt jedoch Fehler zur Laufzeit, indem mindestens eine Ausnahme ausgelöst wird.

#include <boost/variant.hpp> 
#include <iostream> 

class R { 
    boost::variant<int&, const int&> v; 
public: 
    R(int&v):v(v) { } 
    R(const int&v):v(v) { } 

    // works with both 
    int get() const { 
    return boost::apply_visitor( 
     [](int x){return x;}, v); 
    } 

    // only works for non-const A. If at construction, a const 
    // int was passed, throws an error at runtime 
    void set(int x) { 
    boost::get<int&>(v) = x; 
    } 
}; 


int main() { 
    int a = 0; 
    const int b = a; 
    R r1(a); 
    R r2(b); 
    const R r3(a); 
    std::cout << r1.get() << r2.get() << r3.get(); 
    // r3.set(1); // compile error 
    r1.set(1); // works 
    r2.set(1); // runtime error 
} 

Answer 5

Dies ist nicht, wie ich den Code schreiben würde, aber es funktioniert irgendwie. Wenn Sie eine Template-Klasse aus der const-Variablen konstruieren, wird die set() -Funktion auch const definiert und ändert den Status nicht. Durch Konstruieren aus einer nichtkonstanten Variablen kann die Mengenfunktion den Zustand ändern.

#include <iostream> 
#include <string> 
#include <type_traits> 

template<typename T> 
class A 
{ 
    T &_i; 
public: 
    A(T &i) : _i(i) {} 

    template <typename D = T, 
      typename = std::enable_if_t<std::is_const<D>::value 
             > 
      > 
    void set(T i) const { std::cout << "Do nothing on set" << std::endl; } 

    template <typename D = T, 
      typename = std::enable_if_t<!std::is_const<D>::value> 
      >  
    void set(T i) { std::cout << "Do something on set" << std::endl; } 
}; 

int main() 
{ 
    { 
     std::cout << "Construct from NON const variable" << std::endl; 
     int b = 5; 

     A<decltype(b)> a(b); 

     a.set(3); 
    } 

    { 
     std::cout << "Construct from const variable" << std::endl; 
     int const b = 5; 

     A<decltype(b)> a(b);  

     a.set(3); 
    } 
} 

Diese Drucke:

Construct from NON const variable 
Do something on set 
Construct from const variable 
Do nothing on set