C ++ 11'in C # tarzı özellikleri var mı?

C # 'da alıcı ve ayarlayıcılı alanlar için güzel bir sözdizimi şekeri vardır. Dahası, otomatik olarak uygulanan özellikleri de yazmama izin veren

public Foo foo { get; private set; }

C ++ ile yazmalıyım

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

C ++ 11'de bu konuda biraz sözdizimi şekeri almama izin veren böyle bir kavram var mı?

C ++ 'da kendi özelliklerinizi yazabilirsiniz. İsimsiz sınıfların kullanıldığı örnek bir özellik uygulaması. Wikipedia makalesi

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

Kendi alıcılarınızı ve ayarlayıcılarınızı yerinde yazabilir ve sahip sınıf üyesi erişimini istiyorsanız bu örnek kodu uzatabilirsiniz.

C ++ 'da bu yerleşik değildir, özellikler işlevselliğini taklit etmek için bir şablon tanımlayabilirsiniz :

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

İçin bir özellik tanımlamak :

Property<float> x;

Özel bir alıcı / ayarlayıcı uygulamak için sadece devralın:

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;

Salt okunur bir özellik tanımlamak için :

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

Ve sınıfta kullanmak içinOwner :

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

Yukarıdakilerden bazılarını daha kısa hale getirmek için makrolarda tanımlayabilirsiniz .

C ++ dilinde tüm platformlarda ve derleyicilerde çalışacak hiçbir şey yoktur.

Ancak, platformlar arası uyumluluğu bozmaya ve belirli bir derleyiciyi taahhüt etmeye istekliyseniz, bu tür bir sözdizimini kullanabilirsiniz, örneğin Microsoft Visual C ++ ' da

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

Adanmış türde bir üyeye sahip olarak operator(type)ve operator=bunun için geçersiz kılarak alıcı ve ayarlayıcıyı bir dereceye kadar taklit edebilirsiniz . İyi bir fikir olup olmadığı başka bir soru ve ben bu +1konudaki fikrimi ifade etmek için Kerrek SB'nin cevabına gidiyorum :)

Belki son saatlerde topladığım mülk sınıfına bir göz atabilirsiniz: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

Aşağıdaki gibi davranan özelliklere sahip olmanızı sağlar:

CTestClass myClass = CTestClass();

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

C ++ 11 ile bir Özellik sınıfı şablonu tanımlayabilir ve şu şekilde kullanabilirsiniz:

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

Ve işte burada Özellik sınıfı şablonu.

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

Diğerlerinin de söylediği gibi, dilde yerleşik bir destek yok. Ancak, Microsoft C ++ derleyicisini hedefliyorsanız, burada belgelenen özellikler için Microsoft'a özgü uzantıdan yararlanabilirsiniz .

Bu, bağlantılı sayfadaki örnektir:

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

Hayır, C ++ 'nın özellik kavramı yoktur. GetThis () veya setThat (değer) 'i tanımlamak ve çağırmak zor olsa da, tüketiciye bazı işlevlerin ortaya çıkabileceği konusunda bu yöntemlerin ifadesini veriyorsunuz. C ++ 'daki alanlara erişim ise tüketiciye hiçbir ek veya beklenmedik işlevin oluşmayacağını bildirir. Mülk erişimi, ilk bakışta bir alan gibi tepki verdiğinden, ancak aslında bir yöntem gibi tepki verdiğinden, özellikler bunu daha az belirgin hale getirir.

Bir kenara, bir müşteri üyelik sistemi oluşturmaya çalışan bir .NET uygulamasında (çok iyi bilinen bir CMS) çalışıyordum. Kullanıcı nesneleri için özellikleri kullanma biçimleri nedeniyle, beklemediğim eylemler ateşleniyor ve uygulamalarımın sonsuz özyineleme dahil tuhaf şekillerde yürütülmesine neden oluyordu. Bunun nedeni, kullanıcı nesnelerinin StreetAddress gibi basit şeylere erişmeye çalışırken veri erişim katmanına veya bazı küresel önbelleğe alma sistemlerine çağrı yapmasıydı. Tüm sistemleri, mülklerin kötüye kullanılması dediğim şey üzerine kuruldu. Mülkler yerine yöntemler kullanmış olsalardı, neyin yanlış gittiğini çok daha çabuk anlardım. Alanları kullansalar (veya en azından özelliklerinin daha çok alan gibi davranmasını sağlasalar), sistemi genişletmek ve sürdürmek daha kolay olurdu.

[Düzenle] Düşüncelerimi değiştirdim. Kötü bir gün geçirdim ve biraz rant yaptım. Bu temizlik daha profesyonel olmalı.

Https://stackoverflow.com/a/23109533/404734 temel alınarak burada genel alıcı ve özel ayarlayıcıya sahip bir sürüm bulunmaktadır:

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

Bu tam olarak bir mülk değildir, ancak istediğiniz şeyi basit bir şekilde yapar:

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

Burada büyük X public int X { get; private set; }, C # sözdizimindeki gibi davranır . Tam gelişmiş özellikler istiyorsanız, bunları burada uygulamak için ilk atışı yaptım .

Muhtemelen bunu biliyorsunuzdur ama ben sadece şunu yapardım:

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

Bu yaklaşım basittir, akıllıca numaralar kullanmaz ve işi halleder!

Sorun şu ki, bazı insanlar özel alanlarının önüne bir alt çizgi koymaktan hoşlanmıyorlar ve bu yüzden bu yaklaşımı gerçekten kullanamıyorlar, ancak neyse ki bunu yapanlar için bu gerçekten basit. :)

Get ve set önekleri API'nize netlik katmaz, ancak onları daha ayrıntılı hale getirir ve yararlı bilgiler eklediklerini düşünmememin nedeni, API'nin mantıklı olması durumunda birisinin bir API kullanması gerektiğinde muhtemelen bunun farkına varmasıdır. önekler olmadan yapar.

Bir şey daha, bunların özellikler olduğunu kavramak kolay çünkü name bir fiil değildir.

En kötü durum senaryosu, API'ler tutarlıysa ve kişi bunun name()bir erişimci olduğunu anlamadıysa vename(value) bir mutatör olduğunu anlamadıysa, modeli anlamak için dokümantasyonda yalnızca bir kez bakması gerekecektir.

Ne kadar C # sevsem de C ++ 'nın özelliklere ihtiyacı olduğunu düşünmüyorum!

Hayır .. Ama sadece get: set işlevi olup olmadığını ve get: set metodlarının içinde önceden oluşturulmuş ek görev olmadığını düşünmelisiniz.

Fikirleri birden fazla C ++ kaynağından topladım ve C ++ 'daki alıcılar / ayarlayıcılar için güzel, yine de oldukça basit bir örneğe koydum:

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

Çıktı:

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

Çevrimiçi olarak burada test edebilirsiniz: http://codepad.org/zosxqjTX

Sınıfınızın gerçekten bazı değişmezleri zorlaması mı gerekiyor yoksa bu sadece üye öğelerin mantıksal bir gruplaması mı? İkincisi ise, şeyi bir yapı haline getirmeyi ve üyelere doğrudan erişmeyi düşünmelisiniz.

Yazılı makrolar kümesi vardır İşte . Bu, değer türleri, referans türleri, salt okunur türler, güçlü ve zayıf türler için uygun özellik bildirimlerine sahiptir.

class MyClass {

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

 public:
 ...

}