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

En C #, il existe un bon sucre de 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; }

Y a-t-il un tel concept dans le C ++ 11 qui me permet d'avoir du sucre de syntaxe à ce sujet?

En C ++, vous pouvez écrire vos propres fonctionnalités. Voici un exemple d'implémentation de propriétés utilisant des classes sans nom. Article Wikipédia

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 et setters en place et si vous voulez un accès aux membres de la classe de détenteurs, vous pouvez étendre cet exemple de code.

C ++ n'a pas cela intégré, 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;
};

Pour définir une propriété :

Property<float> x;

Pour implémenter un getter / setter personnalisé, héritez simplement:

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 une 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 classeOwner :

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

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

Il n'y a rien dans le langage C ++ qui fonctionnera sur toutes les plates-formes et tous les compilateurs.

Mais si vous êtes prêt à rompre la compatibilité multiplateforme et à vous engager dans un compilateur spécifique, vous pourrez peut-être utiliser une telle syntaxe, par exemple dans Microsoft Visual C ++, vous pouvez le 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;  
}

Vous pouvez émuler getter et setter dans une certaine mesure en ayant un membre de type dédié et en remplaçant operator(type)et operator=pour lui. Que ce soit une bonne idée est une autre question et je vais à +1la réponse de Kerrek SB pour exprimer mon opinion là-dessus :)

Jetez peut-être un œil à la classe de propriété que j'ai assemblée au cours des dernières heures: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

Cela vous permet d'avoir des propriétés qui se comportent comme ceci:

CTestClass myClass = CTestClass();

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

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

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 Property.

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

Comme beaucoup d'autres l'ont déjà dit, il n'y a pas de support intégré dans la langue. Toutefois, si vous ciblez le compilateur Microsoft C ++, vous pouvez profiter de l'extension spécifique à Microsoft pour les propriétés qui est documentée ici.

Voici l'exemple de la page liée:

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

Non, C ++ n'a pas de concept de propriétés. Bien qu'il puisse être difficile de définir et d'appeler getThis () ou setThat (valeur), vous faites une déclaration au consommateur de ces méthodes que certaines fonctionnalités peuvent se produire. L'accès aux champs en C ++, en revanche, indique au consommateur qu'aucune fonctionnalité supplémentaire ou inattendue ne se produira. Les propriétés rendraient cela moins évident car l'accès aux propriétés semble à première vue réagir comme un champ, mais réagit en fait comme une méthode.

En passant, je travaillais dans une application .NET (un CMS très connu) essayant de créer un système d'adhésion client. En raison de la manière dont ils utilisaient les propriétés de leurs objets utilisateur, des actions se déclenchaient que je n'avais pas anticipées, provoquant l'exécution de mes implémentations de manière bizarre, y compris une récursivité infinie. Cela était dû au fait que leurs objets utilisateur appelaient la couche d'accès aux données ou un système de mise en cache global lorsqu'ils tentaient d'accéder à des choses simples comme StreetAddress. Tout leur système était fondé sur ce que j'appellerais un abus de propriété. S'ils avaient utilisé des méthodes plutôt que des propriétés, je pense que j'aurais compris ce qui n'allait pas beaucoup plus rapidement. S'ils avaient utilisé des champs (ou du moins fait en sorte que leurs propriétés se comportent plus comme des champs), je pense que le système aurait été plus facile à étendre et à maintenir.

[Edit] J'ai changé d'avis. J'avais eu une mauvaise journée et j'ai fait un peu de diatribe. Ce nettoyage devrait être plus professionnel.

Basé sur https://stackoverflow.com/a/23109533/404734, voici une version avec un getter public et un setter privé:

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

Ce n'est pas exactement une propriété, mais il fait ce que vous voulez de manière simple:

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

Ici, le grand X se comporte comme public int X { get; private set; }dans la syntaxe C #. Si vous voulez des propriétés à part entière, j'ai fait un premier plan pour les implémenter ici .

Vous le savez probablement, mais je ferais simplement ce qui suit:

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

Cette approche est simple, n'utilise aucune astuce intelligente et elle fait le travail!

Le problème est cependant que certaines personnes n'aiment pas préfixer leurs champs privés avec un trait de soulignement et ne peuvent donc pas vraiment utiliser cette approche, mais heureusement pour ceux qui le font, c'est vraiment simple. :)

Les préfixes get and set n'ajoutent pas de clarté à votre API mais les rendent plus verbeux et la raison pour laquelle je ne pense pas qu'ils ajoutent des informations utiles est que lorsque quelqu'un a besoin d'utiliser une API si l'API a du sens, elle réalisera probablement de quoi il s'agit se passe des préfixes.

Encore une chose, il est facile de comprendre que ce sont des propriétés car name n'est pas un verbe.

Dans le pire des cas, si les API sont cohérentes et que la personne n'a pas réalisé qu'il name()s'agit d'un accesseur etname(value) est un mutateur, elle n'aura qu'à la rechercher une fois dans la documentation pour comprendre le modèle.

Autant j'aime C #, je ne pense pas que C ++ ait besoin de propriétés du tout!

Non .. Mais vous devriez considérer si c'est juste la fonction get: set et aucune tâche supplémentaire préformée dans les méthodes get: set ne la rendent publique.

J'ai rassemblé les idées de plusieurs sources C ++ et les ai mises dans un bel exemple encore assez simple pour les 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;
}

Production:

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

Vous pouvez le tester en ligne ici: http://codepad.org/zosxqjTX

Votre classe a-t-elle vraiment besoin d'appliquer un invariant ou s'agit-il simplement d'un groupement logique d'éléments membres? Si c'est ce dernier, vous devriez envisager de faire de l'objet une structure et d'accéder directement aux membres.

Il existe un ensemble de macros écrites ici . Cela a des déclarations de propriétés pratiques pour les types valeur, les types référence, les types en lecture seule, les types forts et faibles.

class MyClass {

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

 public:
 ...

}