¿C ++ 11 tiene propiedades de estilo C #?

En C #, hay un buen azúcar de sintaxis para campos con getter y setter. Además, me gustan las propiedades implementadas automáticamente que me permiten escribir

public Foo foo { get; private set; }

En C ++ tengo que escribir

private:
    Foo foo;
public:
    Foo getFoo() { return foo; }

¿Existe algún concepto de este tipo en C ++ 11 que me permita tener algo de sintaxis en esto?

En C ++ puedes escribir tus propias características. Aquí hay una implementación de ejemplo de propiedades usando clases sin nombre. Artículo de Wikipedia

struct Foo
{
    class {
        int value;
        public:
            int & operator = (const int &i) { return value = i; }
            operator int () const { return value; }
    } alpha;

    class {
        float value;
        public:
            float & operator = (const float &f) { return value = f; }
            operator float () const { return value; }
    } bravo;
};

Puede escribir sus propios captadores y definidores en su lugar y si desea acceso de miembros de la clase titular, puede extender este código de ejemplo.

C ++ no tiene esto integrado, puede definir una plantilla para imitar la funcionalidad de las propiedades:

template <typename T>
class Property {
public:
    virtual ~Property() {}  //C++11: use override and =default;
    virtual T& operator= (const T& f) { return value = f; }
    virtual const T& operator() () const { return value; }
    virtual explicit operator const T& () const { return value; }
    virtual T* operator->() { return &value; }
protected:
    T value;
};

Para definir una propiedad :

Property<float> x;

Para implementar un getter / setter personalizado, simplemente herede:

class : public Property<float> {
    virtual float & operator = (const float &f) { /*custom code*/ return value = f; }
    virtual operator float const & () const { /*custom code*/ return value; }
} y;

Para definir una propiedad de solo lectura :

template <typename T>
class ReadOnlyProperty {
public:
    virtual ~ReadOnlyProperty() {}
    virtual operator T const & () const { return value; }
protected:
    T value;
};

Y para usarlo en claseOwner :

class Owner {
public:
    class : public ReadOnlyProperty<float> { friend class Owner; } x;
    Owner() { x.value = 8; }
};

Puede definir algunos de los anteriores en macros para hacerlo más conciso.

No hay nada en el lenguaje C ++ que funcione en todas las plataformas y compiladores.

Pero si está dispuesto a romper la compatibilidad multiplataforma y comprometerse con un compilador específico, es posible que pueda usar dicha sintaxis, por ejemplo, en Microsoft Visual C ++ , puede hacerlo

// declspec_property.cpp  
struct S {  
   int i;  
   void putprop(int j) {   
      i = j;  
   }  

   int getprop() {  
      return i;  
   }  

   __declspec(property(get = getprop, put = putprop)) int the_prop;  
};  

int main() {  
   S s;  
   s.the_prop = 5;  
   return s.the_prop;  
}

Puede emular getter y setter hasta cierto punto si tiene un miembro de tipo dedicado y anulando operator(type)y operator=para él. Si es una buena idea es otra pregunta y voy a +1la respuesta de Kerrek SB para expresar mi opinión al respecto :)

Quizás eche un vistazo a la clase de propiedad que he reunido durante las últimas horas: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

Te permite tener propiedades que se comporten así:

CTestClass myClass = CTestClass();

myClass.AspectRatio = 1.4;
myClass.Left = 20;
myClass.Right = 80;
myClass.AspectRatio = myClass.AspectRatio * (myClass.Right - myClass.Left);

Con C ++ 11 puede definir una plantilla de clase de propiedad y usarla así:

class Test{
public:
  Property<int, Test> Number{this,&Test::setNumber,&Test::getNumber};

private:
  int itsNumber;

  void setNumber(int theNumber)
    { itsNumber = theNumber; }

  int getNumber() const
    { return itsNumber; }
};

Y aquí está la plantilla de la clase Propiedad.

template<typename T, typename C>
class Property{
public:
  using SetterType = void (C::*)(T);
  using GetterType = T (C::*)() const;

  Property(C* theObject, SetterType theSetter, GetterType theGetter)
   :itsObject(theObject),
    itsSetter(theSetter),
    itsGetter(theGetter)
    { }

  operator T() const
    { return (itsObject->*itsGetter)(); }

  C& operator = (T theValue) {
    (itsObject->*itsSetter)(theValue);
    return *itsObject;
  }

private:
  C* const itsObject;
  SetterType const itsSetter;
  GetterType const itsGetter;
};

Como muchos otros ya han dicho, no hay soporte integrado en el idioma. Sin embargo, si su objetivo es el compilador de Microsoft C ++, puede aprovechar la extensión específica de Microsoft para las propiedades que se documenta aquí.

Este es el ejemplo de la página vinculada:

// declspec_property.cpp
struct S {
   int i;
   void putprop(int j) { 
      i = j;
   }

   int getprop() {
      return i;
   }

   __declspec(property(get = getprop, put = putprop)) int the_prop;
};

int main() {
   S s;
   s.the_prop = 5;
   return s.the_prop;
}

No, C ++ no tiene concepto de propiedades. Aunque puede ser incómodo definir y llamar a getThis () o setThat (valor), está haciendo una declaración al consumidor de esos métodos de que puede ocurrir alguna funcionalidad. Acceder a campos en C ++, por otro lado, le dice al consumidor que no ocurrirá ninguna funcionalidad adicional o inesperada. Las propiedades harían esto menos obvio ya que el acceso a la propiedad a primera vista parece reaccionar como un campo, pero de hecho reacciona como un método.

Aparte, estaba trabajando en una aplicación .NET (un CMS muy conocido) intentando crear un sistema de membresía de cliente. Debido a la forma en que habían usado las propiedades para sus objetos de usuario, se dispararon acciones que no había anticipado, lo que provocó que mis implementaciones se ejecutaran de formas extrañas, incluida la recursividad infinita. Esto se debía a que sus objetos de usuario realizaban llamadas a la capa de acceso a datos o algún sistema de almacenamiento en caché global cuando intentaban acceder a cosas simples como StreetAddress. Todo su sistema se basó en lo que yo llamaría un abuso de propiedad. Si hubieran usado métodos en lugar de propiedades, creo que me habría dado cuenta de lo que estaba fallando mucho más rápidamente. Si hubieran usado campos (o al menos hubieran hecho que sus propiedades se comportaran más como campos), creo que el sistema hubiera sido más fácil de extender y mantener.

[Editar] Cambió mis pensamientos. Había tenido un mal día y fui un poco enfadado. Esta limpieza debería ser más profesional.

Basado en https://stackoverflow.com/a/23109533/404734, aquí hay una versión con un captador público y un configurador privado:

struct Foo
{
    class
    {
            int value;
            int& operator= (const int& i) { return value = i; }
            friend struct Foo;
        public:
            operator int() const { return value; }
    } alpha;
};

Esto no es exactamente una propiedad, pero hace lo que quiere de la manera más sencilla:

class Foo {
  int x;
public:
  const int& X;
  Foo() : X(x) {
    ...
  }
};

Aquí la gran X se comporta como public int X { get; private set; }en la sintaxis de C #. Si desea propiedades completas, hice un primer intento para implementarlas aquí .

Probablemente lo sepas, pero yo simplemente haría lo siguiente:

class Person {
public:
    std::string name() {
        return _name;
    }
    void name(std::string value) {
        _name = value;
    }
private:
    std::string _name;
};

¡Este enfoque es simple, no utiliza trucos ingeniosos y hace el trabajo!

Sin embargo, el problema es que a algunas personas no les gusta prefijar sus campos privados con un guión bajo y, por lo tanto, realmente no pueden usar este enfoque, pero afortunadamente para quienes lo hacen, es realmente sencillo. :)

Los prefijos get y set no agregan claridad a su API, pero los hacen más detallados y la razón por la que no creo que agreguen información útil es porque cuando alguien necesita usar una API si la API tiene sentido, probablemente se dará cuenta de qué prescinde de los prefijos.

Una cosa más, es fácil comprender que se trata de propiedades porque nameno es un verbo.

En el peor de los casos, si las API son coherentes y la persona no se dio cuenta de que name()es un acceso yname(value) es un mutador, solo tendrá que buscarlo una vez en la documentación para comprender el patrón.

Por mucho que me guste C #, ¡no creo que C ++ necesite propiedades en absoluto!

No, pero debería considerar si se trata de una función get: set y no se realiza ninguna tarea adicional dentro de los métodos get: set, simplemente hágalo público.

Recopilé las ideas de múltiples fuentes de C ++ y las puse en un ejemplo agradable, todavía bastante simple para getters / setters en C ++:

class Canvas { public:
    void resize() {
        cout << "resize to " << width << " " << height << endl;
    }

    Canvas(int w, int h) : width(*this), height(*this) {
        cout << "new canvas " << w << " " << h << endl;
        width.value = w;
        height.value = h;
    }

    class Width { public:
        Canvas& canvas;
        int value;
        Width(Canvas& canvas): canvas(canvas) {}
        int & operator = (const int &i) {
            value = i;
            canvas.resize();
            return value;
        }
        operator int () const {
            return value;
        }
    } width;

    class Height { public:
        Canvas& canvas;
        int value;
        Height(Canvas& canvas): canvas(canvas) {}
        int & operator = (const int &i) {
            value = i;
            canvas.resize();
            return value;
        }
        operator int () const {
            return value;
        }
    } height;
};

int main() {
    Canvas canvas(256, 256);
    canvas.width = 128;
    canvas.height = 64;
}

Salida:

new canvas 256 256
resize to 128 256
resize to 128 64

Puede probarlo en línea aquí: http://codepad.org/zosxqjTX

¿Su clase realmente necesita hacer cumplir algún invariante o es solo una agrupación lógica de elementos miembros? Si es lo último, debería considerar convertir la cosa en una estructura y acceder a los miembros directamente.

Hay un conjunto de macros escrito aquí . Esto tiene declaraciones de propiedad convenientes para tipos de valor, tipos de referencia, tipos de solo lectura, tipos fuertes y débiles.

class MyClass {

 // Use assign for value types.
 NTPropertyAssign(int, StudentId)

 public:
 ...

}