C ++ 11 ha proprietà in stile C #?

In C #, c'è una bella sintassi sugar per i campi con getter e setter. Inoltre, mi piacciono le proprietà implementate automaticamente che mi consentono di scrivere

public Foo foo { get; private set; }

In C ++ devo scrivere

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

C'è qualche concetto di questo tipo in C ++ 11 che mi consente di avere un po 'di zucchero sintattico su questo?

In C ++ puoi scrivere le tue caratteristiche. Ecco un esempio di implementazione di proprietà che utilizzano classi senza nome. Articolo di 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;
};

Puoi scrivere i tuoi getter e setter sul posto e se desideri l'accesso ai membri della classe titolare puoi estendere questo codice di esempio.

C ++ non ha questo integrato, puoi definire un modello per imitare la funzionalità delle proprietà:

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

Per definire una proprietà :

Property<float> x;

Per implementare un getter / setter personalizzato è sufficiente ereditare:

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;

Per definire una proprietà di sola lettura :

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

E per usarlo in classeOwner :

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

Potresti definire alcuni dei precedenti nelle macro per renderlo più conciso.

Non c'è niente nel linguaggio C ++ che funzionerà su tutte le piattaforme e compilatori.

Ma se sei disposto a rompere la compatibilità multipiattaforma e impegnarti con un compilatore specifico potresti essere in grado di utilizzare tale sintassi, ad esempio in Microsoft Visual C ++ puoi fare

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

Puoi emulare getter e setter in una certa misura avendo un membro di tipo dedicato e sovrascrivendo operator(type)e operator=per esso. Se sia una buona idea è un'altra domanda e vado alla +1risposta di Kerrek SB per esprimere la mia opinione al riguardo :)

Magari dai un'occhiata alla classe di proprietà che ho assemblato nelle ultime ore: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

Ti consente di avere proprietà che si comportano in questo modo:

CTestClass myClass = CTestClass();

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

Con C ++ 11 puoi definire un modello di classe Property e usarlo in questo modo:

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

Ed ecco il template della 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;
};

Come molti altri hanno già detto, non c'è supporto integrato nella lingua. Tuttavia, se stai prendendo di mira il compilatore Microsoft C ++, puoi sfruttare l'estensione specifica di Microsoft per le proprietà che è documentata qui.

Questo è l'esempio dalla pagina collegata:

// 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 ++ non ha il concetto di proprietà. Sebbene possa essere scomodo definire e chiamare getThis () o setThat (value), stai dichiarando al consumatore di quei metodi che alcune funzionalità possono verificarsi. L'accesso ai campi in C ++, d'altra parte, indica al consumatore che non si verificherà alcuna funzionalità aggiuntiva o imprevista. Le proprietà renderebbero questo meno ovvio poiché l'accesso alla proprietà a prima vista sembra reagire come un campo, ma in realtà reagisce come un metodo.

Per inciso, stavo lavorando in un'applicazione .NET (un CMS molto noto) cercando di creare un sistema di appartenenza del cliente. A causa del modo in cui avevano utilizzato le proprietà per i loro oggetti utente, si stavano attivando azioni che non avevo previsto, facendo sì che le mie implementazioni venissero eseguite in modi bizzarri, inclusa la ricorsione infinita. Questo perché i loro oggetti utente hanno effettuato chiamate al livello di accesso ai dati o ad un sistema di memorizzazione nella cache globale durante il tentativo di accedere a cose semplici come StreetAddress. Il loro intero sistema era fondato su quello che chiamerei abuso di proprietà. Se avessero usato metodi anziché proprietà, penso che avrei capito cosa stava andando storto molto più rapidamente. Se avessero usato i campi (o almeno fatto che le loro proprietà si comportassero più come i campi), penso che il sistema sarebbe stato più facile da estendere e mantenere.

[Modifica] Ha cambiato i miei pensieri. Avevo avuto una brutta giornata e sono andato un po 'a farneticare. Questa pulizia dovrebbe essere più professionale.

Basata su https://stackoverflow.com/a/23109533/404734, ecco una versione con un getter pubblico e un setter privato:

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

Questa non è esattamente una proprietà, ma fa quello che vuoi in modo semplice:

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

Qui la grande X si comporta come public int X { get; private set; }nella sintassi C #. Se vuoi proprietà in piena regola, ho fatto un primo colpo per implementarle qui .

Probabilmente lo sai, ma vorrei semplicemente fare quanto segue:

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

Questo approccio è semplice, non utilizza trucchi intelligenti e porta a termine il lavoro!

Il problema però è che ad alcune persone non piace anteporre ai loro campi privati ​​un carattere di sottolineatura e quindi non possono davvero utilizzare questo approccio, ma fortunatamente per coloro che lo fanno, è davvero semplice. :)

I prefissi get e set non aggiungono chiarezza alla tua API ma li rendono più dettagliati e il motivo per cui non penso aggiungano informazioni utili è perché quando qualcuno ha bisogno di usare un'API se l'API ha senso, probabilmente si renderà conto di cosa si tratta fa a meno dei prefissi.

Un'altra cosa, è facile capire che queste sono proprietà perché namenon è un verbo.

Nel peggiore dei casi, se le API sono coerenti e la persona non si è resa conto che name()è un accessorio ed name(value)è un mutatore, dovrà cercarlo solo una volta nella documentazione per comprendere il modello.

Per quanto io ami C #, non credo che il C ++ abbia bisogno di proprietà!

No .. Ma dovresti considerare se è solo la funzione get: set e nessun compito aggiuntivo preformato all'interno dei metodi get: set lo rendono pubblico.

Ho raccolto le idee da più fonti C ++ e le ho inserite in un bell'esempio ancora abbastanza semplice per getter / setter in 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;
}

Produzione:

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

Puoi testarlo online qui: http://codepad.org/zosxqjTX

La tua classe ha davvero bisogno di applicare qualche invariante o è solo un raggruppamento logico di elementi membri? Se è quest'ultimo dovresti considerare di rendere la cosa una struttura e di accedere direttamente ai membri.

Ci sono una serie di macro scritte qui . Questo ha dichiarazioni di proprietà convenienti per tipi di valore, tipi di riferimento, tipi di sola lettura, tipi forti e deboli.

class MyClass {

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

 public:
 ...

}