C++11 a-t-il des propriétés de type C# ?

Question

En C#, il existe une belle syntaxe pour les champs avec getter et setter. De plus, j'aime les propriétés auto-implémentées qui me permettent d'écrire

public Foo foo { get; private set; }

En C++, je dois écrire

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

Existe-t-il un concept de ce type dans le C++11 qui me permette de bénéficier d'une certaine souplesse syntaxique à cet égard ?

Answer 1

En C++, vous pouvez écrire vos propres fonctionnalités. Voici un exemple d'implémentation de propriétés utilisant des classes non nommées. Article 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;
};

Vous pouvez écrire vos propres getters & setters à la place et si vous voulez un accès aux membres de la classe du titulaire, vous pouvez étendre cet exemple de code.

Answer 2

Le C++ n'intègre pas cette fonctionnalité, mais vous pouvez définir un modèle pour imiter la fonctionnalité des propriétés :

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

A définir une propriété :

Property<float> x;

Pour mettre en œuvre un getter/setter personnalisé juste hériter :

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;

Pour définir un propriété en lecture seule :

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

Et pour l'utiliser en classe Owner :

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

Vous pourriez définir certains des éléments ci-dessus dans macros pour le rendre plus concis.

Answer 3

Il n'y a rien dans le langage C++ qui fonctionne sur toutes les plateformes et tous les compilateurs.

Mais si vous êtes prêt à renoncer à la compatibilité multiplateforme et à vous engager dans un compilateur spécifique, vous pouvez utiliser une telle syntaxe, par exemple dans Microsoft Visual C++ vous pouvez faire

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

Answer 4

Avec C++11, vous pouvez définir un modèle de classe de propriété et l'utiliser comme suit :

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

Et voici le modèle de classe de propriété.

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

Answer 5

Vous pouvez émuler le getter et le setter jusqu'à un certain point en ayant un membre du type dédié et en surchargeant operator(type) y operator= pour ça. Savoir si c'est une bonne idée est une autre question et je vais +1 Réponse de Kerrek SB pour exprimer mon opinion à ce sujet :)