Hat C ++ 11 Eigenschaften im C # -Stil?

In C # gibt es einen schönen Syntaxzucker für Felder mit Getter und Setter. Außerdem mag ich die automatisch implementierten Eigenschaften, mit denen ich schreiben kann

public Foo foo { get; private set; }

In C ++ muss ich schreiben

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

Gibt es ein solches Konzept in C ++ 11, das es mir ermöglicht, etwas Syntaxzucker dafür zu haben?

In C ++ können Sie Ihre eigenen Funktionen schreiben. Hier ist ein Beispiel für die Implementierung von Eigenschaften mit unbenannten Klassen. Wikipedia-Artikel

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

Sie können Ihre eigenen Getter und Setter an Ort und Stelle schreiben. Wenn Sie Zugriff auf Mitglieder der Inhaberklasse wünschen, können Sie diesen Beispielcode erweitern.

In C ++ ist dies nicht integriert. Sie können eine Vorlage definieren , um die Funktionalität der Eigenschaften nachzuahmen:

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

So definieren Sie eine Eigenschaft :

Property<float> x;

Um einen benutzerdefinierten Getter / Setter zu implementieren, erben Sie einfach:

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;

So definieren Sie eine schreibgeschützte Eigenschaft :

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

Und um es im UnterrichtOwner zu benutzen :

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

Sie können einige der oben genannten Punkte in Makros definieren , um sie übersichtlicher zu gestalten.

In der C ++ - Sprache gibt es nichts, was auf allen Plattformen und Compilern funktioniert.

Aber wenn Sie bereit sind , plattformübergreifende Kompatibilität zu brechen und zu einem bestimmten Compiler begehen Sie in der Lage sein eine solche Syntax zu verwenden, zum Beispiel in Microsoft Visual C ++ können Sie tun

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

Sie können mit einem Mitglied von engagierter Art und zwingenden Getter und Setter zu einem gewissen Grad emulieren operator(type)und operator=für sie. Ob es eine gute Idee ist, ist eine andere Frage und ich gehe zu +1Kerrek SBs Antwort, um meine Meinung dazu zu äußern :)

Vielleicht werfen Sie einen Blick auf die Eigenschaftsklasse, die ich in den letzten Stunden zusammengestellt habe: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

Sie können Eigenschaften haben, die sich wie folgt verhalten:

CTestClass myClass = CTestClass();

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

Mit C ++ 11 können Sie eine Eigenschaftsklassenvorlage definieren und wie folgt verwenden:

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

Und hier ist die Eigenschaftsklassenvorlage.

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

Wie viele andere bereits gesagt haben, gibt es keine integrierte Unterstützung in der Sprache. Wenn Sie jedoch auf den Microsoft C ++ - Compiler abzielen, können Sie die Microsoft-spezifische Erweiterung für Eigenschaften nutzen, die hier dokumentiert ist.

Dies ist das Beispiel von der verlinkten Seite:

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

Nein, C ++ hat kein Konzept von Eigenschaften. Obwohl es umständlich sein kann, getThis () oder setThat (value) zu definieren und aufzurufen, geben Sie dem Verbraucher dieser Methoden eine Erklärung ab, dass einige Funktionen auftreten können. Der Zugriff auf Felder in C ++ teilt dem Verbraucher hingegen mit, dass keine zusätzlichen oder unerwarteten Funktionen auftreten. Eigenschaften würden dies weniger offensichtlich machen, da der Zugriff auf Eigenschaften auf den ersten Blick wie ein Feld zu reagieren scheint, aber tatsächlich wie eine Methode reagiert.

Nebenbei habe ich in einer .NET-Anwendung (einem sehr bekannten CMS) versucht, ein Kundenmitgliedschaftssystem zu erstellen. Aufgrund der Art und Weise, wie sie Eigenschaften für ihre Benutzerobjekte verwendet hatten, wurden Aktionen ausgelöst, die ich nicht erwartet hatte, und meine Implementierungen wurden auf bizarre Weise ausgeführt, einschließlich unendlicher Rekursion. Dies lag daran, dass ihre Benutzerobjekte beim Versuch, auf einfache Dinge wie StreetAddress zuzugreifen, die Datenzugriffsschicht oder ein globales Caching-System aufriefen. Ihr gesamtes System basierte auf dem, was ich als Missbrauch von Immobilien bezeichnen würde. Hätten sie Methoden anstelle von Eigenschaften verwendet, hätte ich wahrscheinlich viel schneller herausgefunden, was schief gelaufen ist. Hätten sie Felder verwendet (oder zumindest ihre Eigenschaften eher wie Felder verhalten lassen), wäre das System meiner Meinung nach einfacher zu erweitern und zu warten gewesen.

[Bearbeiten] Meine Gedanken geändert. Ich hatte einen schlechten Tag gehabt und war ein bisschen geschimpft. Diese Bereinigung sollte professioneller sein.

Basierend auf https://stackoverflow.com/a/23109533/404734 gibt es hier eine Version mit einem öffentlichen Getter und einem privaten Setter:

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

Dies ist nicht gerade eine Eigenschaft, aber es macht das, was Sie wollen, auf einfache Weise:

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

Hier verhält sich das große X wie public int X { get; private set; }in der C # -Syntax. Wenn Sie vollständige Eigenschaften wünschen, habe ich einen ersten Versuch unternommen, um sie hier zu implementieren .

Sie wissen das wahrscheinlich, aber ich würde einfach Folgendes tun:

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

Dieser Ansatz ist einfach, verwendet keine cleveren Tricks und erledigt den Job!

Das Problem ist jedoch, dass einige Leute ihren privaten Feldern keinen Unterstrich voranstellen möchten und diesen Ansatz daher nicht wirklich verwenden können, aber zum Glück für diejenigen, die dies tun, ist es wirklich einfach. :) :)

Die get- und set-Präfixe verleihen Ihrer API keine Klarheit, machen sie jedoch ausführlicher. Ich glaube nicht, dass sie nützliche Informationen hinzufügen, weil jemand, der eine API verwenden muss, wenn die API sinnvoll ist, wahrscheinlich erkennt, was sie ist verzichtet auf die Präfixe.

Eine weitere Sache, es ist leicht zu verstehen, dass dies Eigenschaften sind, weil namees kein Verb ist.

Im schlimmsten Fall muss die Person, wenn sie konsistent ist und die Person nicht erkannt hat, dass name()es sich um einen Accessor und name(value)einen Mutator handelt, diese nur einmal in der Dokumentation nachschlagen, um das Muster zu verstehen.

So sehr ich C # liebe, ich glaube nicht, dass C ++ überhaupt Eigenschaften braucht!

Nein. Aber Sie sollten überlegen, ob es nur get: set-Funktion und keine zusätzliche Aufgabe gibt, die in get: set-Methoden ausgeführt wird. Machen Sie es einfach öffentlich.

Ich habe die Ideen aus mehreren C ++ - Quellen gesammelt und in ein schönes, immer noch recht einfaches Beispiel für Getter / Setter in C ++ eingefügt:

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

Ausgabe:

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

Sie können es hier online testen: http://codepad.org/zosxqjTX

Muss Ihre Klasse wirklich eine Invariante erzwingen oder handelt es sich nur um eine logische Gruppierung von Elementelementen? Wenn es das letztere ist, sollten Sie erwägen, das Ding zu einer Struktur zu machen und direkt auf die Mitglieder zuzugreifen.

Es gibt eine Reihe von Makros geschrieben Hier . Dies hat praktische Eigenschaftsdeklarationen für Werttypen, Referenztypen, schreibgeschützte Typen, starke und schwache Typen.

class MyClass {

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

 public:
 ...

}