Creating read-only (public) class members in C++

Question

I'm coming from a background in languages like Actionscript 3 where we have a special way of defining a member variable as both an instance and a method for setting/fetching the value of a protected or private member. Let me give an example:

Within a class, we can say something like this:

private var _myString:String;

public get myString():String 
{
    return _myString;
}

public set myString(newValue:String):void
{
    //Do some super secret member protection n' stuff
    _myString = newValue;
}

And then outside of that object I can do the following:

trace(myClass.myString); //Output whatever _myString is. (note the lack of (). It's being accessed like property not a method...

And even further, I could do something like delete the "public set myString" method, so if someone tried to do this with my class:

myClass.myString = "Something"; //Try to assign - again note the lack of ()

It would throw an error, letting the user know that the property is available as read-only.

Now since I'm using C++ and it's infinitely more awesome than Actionscript 3, I'm wondering how I can mimic this type of behavior. I don't want to use a bunch of dirty getVariable() and setVariable() methods. I was hoping through some operator overloading trickery I could make the exact same thing possible here. Note I am a noob, so please address me as such. :)

Update I guess the easiest way to explain this is, I'm trying to essentially have getters and setters but invoke them through assignment rather than with the parentheses ().

Answer 1

Sorry, with C++, the syntactic sugar is not there, which means you have to implement the get/set methods yourself. So in your case you will have to implement a getVariable() method without it's equivalent Set method in order to make it read only.

And please don't resort to macro's to make it Look like you have some read only properties. That will just piss people off when they read your code 5 years from now.

Answer 2

If I understand your question correctly, you want to create const public member variable in C++ terms.

class myClass
{
//...
public:
  const std::string myString;

  myClass(std::string s) : myString(s) {}
};

So now, myClass::myString is initialized when you declare the class object and it remains unmutable (read only) throughout its life time.

As side effect of this approach, now myClass objects cannot be default assignable. i.e.

myClass o1("s"), o2("t");
o1 = o2; // error

Answer 3

Actually it is possible using templated primatives.

If you want a readonly variable but don't want the client to have to change the way they access it, try this templated class:

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

Example Use:

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

Now you can access Foo.x, but you can't change Foo.x! Remember you'll need to add bitwise and unary operators as well! This is just an example to get you started

Answer 4

It's not impossible to get the kind of behavior you want. But it's also not necessarily a good idea.

You can, in principle, do something like this:

template<typename T>
class AbstractGetter {
  T &refT;
public:
  operator const T() const { return refT; }
  AbstractGetter(T &refT_) : refT(refT_) { }
};

class Foo {
  int foo_private;
public:
  AbstractGetter<int> foo;

  Foo() : foo(foo_private) { }
};

HOWEVER: AbstractGetter here costs you sizeof(int&) in additional memory. And it's a rather ugly hack, too - if you start needing to represent anything more complex than just a reference (maybe your getter needs to have some logic?) either the syntax or memory overhead gets much worse.

As such, it's normal C++ style to use getter functions, rather than hacks like this.

Answer 5

C++ is flexible so you can do so much nasty things. it is possible but with bit more typing.

Here is a wrapper template.

// element wrapper for creating a getter and setter.
template <typename Base, typename T>
class getterSetter{
  T value;
  // below members required for setting up setter logic in owner class.
  Base *parent;            //owner object pointer
  bool (Base::*setter)(T&); //setter callback return true to set, false to not set.

public:
  getterSetter(T& v, Base *p, bool (Base::*set)(T&))
    : value(v),
      parent(p),
      setter(set)
  {} // read-write constructor.                                                                                                             
  getterSetter(T& v): value(v),parent(NULL), setter(NULL) {} // read only constructor.                                                      

  // setter implemented via operator overloading of = operator.
  const getterSetter& operator=(const T& v) {
    if (this->parent && this->setter && (parent->*(this->setter))(v)) {
      value = v;
    }
    else {
      // throw an exception here.                                                                                                           
    }
    return *this;
  }

  // cast sometimes helps for a getter.
  operator T() const{
    return value;
  }
};

The implementation be like

class MyClass {
public:
  getterSetter<MyClass, std::string> myString;
  MyClass(std::string v): myString(v, this, &test::setX){}
  // MyClass(std::string v): myString(v) {} ;//for readonly myString.
  MyClass(MyClass&) = delete;

  bool setX(std::string& v) {
    // your setter logic here.                                                                                                                     
    return true;
  }
};

By this way this can be used as setter and getter without paranthesis.

declare MyClass x("hello");

then x.myString = "new value"; // this will call setter implementation in MyClass

assignment like

std::string newString;
newString = x.myString;

will work.

Although this can be done, it is not a good thing to do in c++. it uses two additional pointer memory for each property which is bad. also need to write more operator overloading to work with STL and external code. There may be better way.