क्या C ++ 11 में C # -स्टाइल गुण हैं?

Question

सी # में, गटर और सेटर के साथ खेतों के लिए एक अच्छा सिंटैक्स चीनी है। इसके अलावा, मुझे ऑटो-कार्यान्वित गुण पसंद हैं जो मुझे लिखने की अनुमति देते हैं

public Foo foo { get; private set; }

C ++ में मुझे लिखना है

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

क्या C ++ 11 में कुछ ऐसी अवधारणा है जो मुझे इस पर कुछ सिंटैक्स चीनी की अनुमति दे रही है?

Comments

यह मैक्रों के एक जोड़े के साथ किया जा सकता है। शर्म की बात है

— 15

@ एलॉफ़: बस सब कुछ सार्वजनिक करना हमेशा एक बुरा विचार है।

— कैसरलुडी

ऐसी कोई अवधारणा नहीं है! और आपको इसकी आवश्यकता भी नहीं है: seanmiddleditch.com/why-c-does-not-need-c-like-properties

— CinCout

a) यह प्रश्न काफी पुराना है, b) मैं सिंटैक्स शुगर के लिए कह रहा था, इससे मुझे कोष्ठक से छुटकारा मिल सकेगा) हालांकि यह आलेख गुणों को स्वीकार करने के खिलाफ वैध तर्क प्रस्तुत करता है, चाहे C ++ 'को इन गुणों की आवश्यकता हो या न हो बहुत व्यक्तिपरक है। सी ++ उनके बिना भी टूरिंग-मशीन के बराबर है, लेकिन इसका मतलब यह नहीं है कि इस तरह की सिंटैक्स शुगर होने से सी ++ अधिक उत्पादक बन जाएगा।

— रेडिम वैनसा

निश्चित रूप से नहीं।

Answer 1

C ++ में आप अपने फीचर्स लिख सकते हैं। यहां अनाम वर्गों का उपयोग करते हुए गुणों का एक उदाहरण कार्यान्वयन है। विकिपीडिया लेख

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

आप अपने खुद के गेटर्स और सेटर्स लिख सकते हैं और यदि आप धारक वर्ग सदस्य का उपयोग चाहते हैं तो आप इस उदाहरण कोड को बढ़ा सकते हैं।

Comments

इस कोड को संशोधित करने के बारे में कोई भी विचार अभी भी एक निजी सदस्य चर है जिसे फू आंतरिक रूप से एक्सेस कर सकता है, जबकि सार्वजनिक एपीआई केवल संपत्ति को उजागर करता है? मैं बेशक फू को अल्फ़ा / बीटा का दोस्त बना सकता हूं, लेकिन तब मुझे मूल्य हासिल करने के लिए अभी भी अल्फा.वेल्यू लिखना होगा, लेकिन मैं यह पसंद करूंगा कि अगर सीधे फू चर के अंदर से सदस्य चर का उपयोग किया जाए तो अधिक महसूस होगा फू के एक सदस्य तक खुद पहुंचना और विशेष नेस्टेड संपत्ति वर्ग का सदस्य नहीं।

— कैसरलुडी

@ कैसरलुडी हां: इस मामले में, अल्फा और ब्रावो को निजी बनाएं। फू में, आप ऊपर उन "गुणों" के साथ पढ़ / लिख सकते हैं, लेकिन फू के बाहर, यह अब संभव नहीं होगा। इसे दरकिनार करने के लिए, एक कास्ट रेफरेंस बनाएं जो सार्वजनिक है। यह बाहर से सुलभ है, लेकिन केवल पढ़ने के लिए क्योंकि यह एक निरंतर संदर्भ है। एकमात्र चेतावनी यह है कि आपको सार्वजनिक कॉन्स्ट रेफरेंस के लिए दूसरे नाम की आवश्यकता होगी। मैं _alphaनिजी चर के alphaलिए और संदर्भ के लिए व्यक्तिगत रूप से उपयोग करूंगा ।

— कपिचु

@ कापीचू: 2 कारणों से समाधान नहीं। 1) C # प्रॉपर्टी गेटर्स / सेटर्स में अक्सर उन सुरक्षित चेक को एम्बेड करने के लिए उपयोग किया जाता है जो क्लास के सार्वजनिक उपयोगकर्ताओं के लिए मजबूर किए जाते हैं, जबकि सदस्य फ़ंक्शन को सीधे मूल्य तक पहुंचने की अनुमति देते हैं। 2) कास्ट संदर्भ मुक्त नहीं हैं: संकलक / प्लेटफॉर्म के आधार पर वे विस्तार करेंगे sizeof(Foo)।

— Ceztko

@psx: इस दृष्टिकोण की सीमाओं के कारण, मैं इससे बचता और मानक के उचित उपयोग की प्रतीक्षा करता, यदि यह कभी प्रकट होता।

— ceztko

@ कैचीचू: लेकिन उदाहरण कोड में अल्फा और ब्रावो गुण हैं। मैं एक संपत्ति का उपयोग करने की आवश्यकता के बिना, फू के कार्यान्वयन के अंदर से चर को सीधे एक्सेस करना चाहूंगा, जबकि मैं केवल एपीआई में एक संपत्ति के माध्यम से पहुंच को उजागर करना चाहूंगा।

— कैसरलुडी

Answer 2

C ++ में यह अंतर्निहित नहीं है, आप एक टेम्पलेट को गुण की कार्यक्षमता की नकल करने के लिए परिभाषित कर सकते हैं :

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

एक संपत्ति को परिभाषित करने के लिए :

Property<float> x;

एक कस्टम गेटर / सेटर लागू करने के लिए सिर्फ विरासत:

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;

केवल पढ़ने के लिए संपत्ति को परिभाषित करने के लिए :

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

और इसे कक्षा में उपयोगOwner करने के लिए :

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

आप इसे अधिक संक्षिप्त बनाने के लिए मैक्रोज़ में उपरोक्त कुछ को परिभाषित कर सकते हैं ।

Comments

मैं उत्सुक हूँ अगर यह एक शून्य-लागत सुविधा के लिए संकलित करता है, तो मुझे नहीं पता कि प्रत्येक डेटा-सदस्य को एक वर्ग उदाहरण में लपेटने के परिणामस्वरूप उसी तरह की संरचना-पैकिंग होगी, उदाहरण के लिए।

— दाई

"कस्टम गाइटर / सेटर" तर्क को लैम्ब्डा कार्यों के उपयोग द्वारा वाक्य-रचनात्मक रूप से क्लीनर बनाया जा सकता है, दुर्भाग्य से आप C ++ (अभी तक!) में एक निष्पादन योग्य संदर्भ के बाहर एक लैम्ब्डा को परिभाषित नहीं कर सकते हैं, इसलिए प्रीप्रोसेसरी मैक्रो का उपयोग किए बिना आप कोड के साथ समाप्त होते हैं! के रूप में मूर्ख रूप में गूंगा पाने वाले / बसने वाले, जो दुर्भाग्यपूर्ण है।

— दाई

अंतिम उदाहरण में "वर्ग: ..." दिलचस्प है, और अन्य उदाहरणों से गायब है। यह एक नए वर्ग के नाम को प्रस्तुत किए बिना - आवश्यक मित्र-घोषणा बनाता है।

— हंस ओल्सन

इसके और 2010-नवंबर -19 के उत्तर के बीच एक बड़ा अंतर यह है कि यह मामला-दर-मामला आधार पर गेट्टर या सेटर को ओवरराइड करने में सक्षम बनाता है। इस तरह एक इनपुट रेंज में हो सकता है, या इवेंट श्रोताओं को बदलने के लिए एक बदलाव अधिसूचना भेजने के लिए, या एक ब्रेकपॉइंट को लटकाने के लिए जगह हो सकती है।

— एलजय जूल 25'19

ध्यान दें कि virtualहै शायद सबसे उपयोग के मामलों के लिए अनावश्यक है, क्योंकि एक संपत्ति उपयोग polymorphically होने की संभावना नहीं है।

— एलजय

Answer 3

C ++ भाषा में ऐसा कुछ भी नहीं है जो सभी प्लेटफार्मों और कंपाइलरों पर काम करेगा।

लेकिन यदि आप क्रॉस-प्लेटफ़ॉर्म संगतता को तोड़ने और एक विशिष्ट कंपाइलर के लिए प्रतिबद्ध हैं, तो आप ऐसे सिंटैक्स का उपयोग करने में सक्षम हो सकते हैं, उदाहरण के लिए Microsoft Visual C ++ में आप कर सकते हैं

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

Comments

यह क्लैंग के साथ

— राहगीर

Answer 4

आप समर्पित प्रकार के एक सदस्य होने और अधिभावी द्वारा कुछ हद तक गेटर और सेटर का अनुकरण कर सकते हैं operator(type)और operator=इसके लिए। क्या यह एक अच्छा विचार है एक और सवाल है और मैं +1अपनी राय व्यक्त करने के लिए केरेक एसबी के जवाब पर जा रहा हूं :)

Comments

आप इस प्रकार के असाइन-इन या रीडिंग-ऑन पर एक विधि को कॉल करने का अनुकरण कर सकते हैं, लेकिन आप यह निर्दिष्ट नहीं कर सकते हैं कि असाइन किए गए ऑपरेशन को कॉल कौन करता है (यदि यह फ़ील्ड स्वामी नहीं है तो इसे प्रतिबंधित करने के लिए) - मैं अलग-अलग पहुंच निर्दिष्ट करके क्या करने की कोशिश कर रहा हूं गेट्टर और सेटर के लिए स्तर।

— रदीम वंस

@ फैवेलियस: बस एक friendको जोड़ दें, फ़ील्ड के मालिक को।

— kennytm

Answer 5

शायद पिछले घंटों के दौरान इकट्ठे हुए संपत्ति वर्ग पर आपकी नज़र है: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

यह आपको इस तरह व्यवहार करने की अनुमति देता है:

CTestClass myClass = CTestClass();

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

Comments

हालांकि, हालांकि यह उपयोगकर्ता-परिभाषित एक्सेसरों की अनुमति देता है, लेकिन सार्वजनिक गेटटर / निजी सेटर सुविधा नहीं है जिसकी मुझे तलाश थी।

— रादिम वंस जनता

Answer 6

C ++ 11 के साथ आप एक संपत्ति वर्ग टेम्पलेट को परिभाषित कर सकते हैं और इसे इस तरह उपयोग कर सकते हैं:

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

और यहाँ संपत्ति वर्ग टेम्पलेट है।

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

Comments

क्या C::*मतलब है? मैंने पहले कभी ऐसा कुछ नहीं देखा?

— रिका

यह कक्षा में एक गैर-स्थैतिक सदस्य फ़ंक्शन के लिए एक संकेतक है C। यह एक सादे फ़ंक्शन पॉइंटर के समान है लेकिन सदस्य फ़ंक्शन को कॉल करने के लिए आपको एक ऑब्जेक्ट प्रदान करने की आवश्यकता होती है जिस पर फ़ंक्शन कहा जाता है। यह itsObject->*itsSetter(theValue)ऊपर के उदाहरण में लाइन के साथ हासिल किया गया है। इस सुविधा के अधिक विस्तृत विवरण के लिए यहां देखें ।

— क्रिस्टोफ बॉहम

@ निमन, क्या उपयोग का एक उदाहरण है? एक सदस्य के रूप में यह बहुत महंगा प्रतीत होता है। यह स्थिर सदस्य के रूप में विशेष रूप से उपयोगी नहीं है।

— ग्रिम फैंडैंगो

Answer 7

जैसा कि कई अन्य पहले ही कह चुके हैं, भाषा में कोई अंतर्निहित समर्थन नहीं है। हालाँकि, यदि आप Microsoft C ++ कंपाइलर को लक्षित कर रहे हैं, तो आप उन संपत्तियों के लिए Microsoft-विशिष्ट एक्सटेंशन का लाभ उठा सकते हैं, जो यहाँ प्रलेखित हैं।

यह लिंक किए गए पृष्ठ से उदाहरण है:

// 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 8

नहीं, C ++ में संपत्तियों की कोई अवधारणा नहीं है। हालाँकि यह getThis () या setThat (मान) को परिभाषित करने और कॉल करने के लिए अजीब हो सकता है, आप उन तरीकों के उपभोक्ता को एक बयान दे रहे हैं जो कुछ कार्यक्षमता हो सकती हैं। दूसरी ओर, C ++ में फ़ील्ड्स एक्सेस करना, उपभोक्ता को बताता है कि कोई अतिरिक्त या अप्रत्याशित कार्यक्षमता नहीं होगी। गुण इसे कम स्पष्ट कर सकते हैं क्योंकि पहली नज़र में संपत्ति का उपयोग एक क्षेत्र की तरह प्रतिक्रिया करता प्रतीत होता है, लेकिन वास्तव में एक विधि की तरह प्रतिक्रिया करता है।

एक तरफ के रूप में, मैं एक .NET एप्लिकेशन (एक बहुत अच्छी तरह से ज्ञात सीएमएस) में काम कर रहा था जो ग्राहक सदस्यता प्रणाली बनाने का प्रयास कर रहा था। जिस तरह से उन्होंने अपने उपयोगकर्ता वस्तुओं के लिए गुणों का इस्तेमाल किया था, उसके कारण कार्रवाई बंद हो गई थी, जिसका मुझे अनुमान नहीं था, जिससे मेरे कार्यान्वयन को असीम पुनरावृत्ति सहित विचित्र तरीकों से निष्पादित किया गया। ऐसा इसलिए था क्योंकि StreetAddress जैसी सरल चीजों को एक्सेस करने का प्रयास करते समय उनकी उपयोगकर्ता ऑब्जेक्ट्स ने डेटा एक्सेस लेयर या कुछ ग्लोबल कैशिंग सिस्टम को कॉल किया था। उनकी पूरी प्रणाली की स्थापना इस बात पर हुई कि मैं संपत्तियों का दुरुपयोग क्या कहूंगा। अगर उन्होंने गुणों के बजाय तरीकों का इस्तेमाल किया है, तो मुझे लगता है कि मुझे यह पता चल गया होगा कि क्या बहुत जल्दी गलत हो रहा था। अगर उन्होंने खेतों का उपयोग किया है (या कम से कम उनके गुणों ने खेतों की तरह अधिक व्यवहार किया है), मुझे लगता है कि सिस्टम को विस्तारित करने और बनाए रखने में आसान होता।

[संपादित करें] मेरे विचारों को बदल दिया। मैं एक बुरा दिन था और एक शेख़ी पर चला गया। यह सफाई अधिक पेशेवर होनी चाहिए।

Answer 9

Https://stackoverflow.com/a/23109533/404734 पर आधारित यहां एक सार्वजनिक गेट और निजी सेट के साथ एक संस्करण है:

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

Answer 10

यह बिल्कुल एक संपत्ति नहीं है, लेकिन यह वही करता है जो आप सरल तरीके से चाहते हैं:

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

यहाँ बड़ा X public int X { get; private set; }, C # सिंटैक्स की तरह व्यवहार करता है । यदि आप पूर्ण विकसित गुण चाहते हैं, तो मैंने उन्हें यहां लागू करने के लिए पहला शॉट बनाया ।

Comments

यह एक अच्छा विचार नहीं है। जब भी आप इस वर्ग की किसी वस्तु की प्रतिलिपि बनाते हैं, तब Xभी नई वस्तु का संदर्भ पुरानी वस्तु के सदस्य को इंगित करेगा, क्योंकि यह सिर्फ एक पॉइंटर सदस्य की तरह कॉपी किया जाता है। यह अपने आप में बुरा है, लेकिन जब पुरानी वस्तु को हटा दिया जाता है, तो आपको इसके ऊपर मेमोरी भ्रष्टाचार मिलता है। इस काम को करने के लिए, आपको अपने खुद के कॉपी कंस्ट्रक्टर, असाइनमेंट ऑपरेटर और मूव कंस्ट्रक्टर को भी लागू करना होगा।

— toster

Answer 11

आप शायद जानते हैं कि लेकिन मैं बस निम्नलिखित करूंगा:

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

यह दृष्टिकोण सरल है, कोई चालाक चाल का उपयोग नहीं करता है और यह काम पूरा कर लेता है!

हालांकि मुद्दा यह है कि कुछ लोग अपने निजी क्षेत्रों को अंडरस्कोर के साथ उपसर्ग करना पसंद नहीं करते हैं और इसलिए वे वास्तव में इस दृष्टिकोण का उपयोग नहीं कर सकते हैं, लेकिन सौभाग्य से जो लोग ऐसा करते हैं, वह वास्तव में सीधा है। :)

प्राप्त और सेट उपसर्ग आपके एपीआई में स्पष्टता नहीं जोड़ते हैं, लेकिन उन्हें और अधिक क्रियाशील बनाते हैं और इसका कारण मुझे नहीं लगता कि वे उपयोगी जानकारी जोड़ते हैं क्योंकि जब किसी को एपीआई का उपयोग करने की आवश्यकता होती है यदि एपीआई समझ में आता है तो उसे शायद यह एहसास होगा कि यह क्या है उपसर्गों के बिना करता है।

एक और बात, यह समझ लेना आसान है कि ये गुण हैं क्योंकि nameक्रिया नहीं है।

सबसे खराब स्थिति, अगर एपीआई संगत है और व्यक्ति को यह समझ नहीं आया कि name()एक एक्सेसर और हैname(value) एक एक्सेसर है एक उत्परिवर्ती है तो उसे पैटर्न को समझने के लिए प्रलेखन में केवल एक बार इसे देखना होगा।

जितना मैं सी # से प्यार करता हूं, मुझे नहीं लगता कि सी ++ को गुणों की आवश्यकता है!

Comments

आपके म्यूटर्स को समझ में आता है कि अगर कोई foo(bar)(धीमे के बजाय foo = bar) का उपयोग करता है , लेकिन आपके एक्सेसर्स को गुणों से कोई लेना-देना नहीं है ...

— Matthias

@ माथियास ने कहा कि इसका संपत्तियों से कोई लेना-देना नहीं है, मुझे कुछ भी नहीं बताना, क्या आप विस्तार से बता सकते हैं? इसके अलावा मैंने उनकी तुलना करने की कोशिश नहीं की, लेकिन अगर आपको एक म्यूटेटर और एक्सेसर की आवश्यकता है तो आप इस सम्मेलन का उपयोग कर सकते हैं।

— ईयाल सोलनिक

यह सवाल प्रॉपर्टीज के सॉफ्टवेयर कॉन्सेप्ट के बारे में है। संपत्तियों का उपयोग इस तरह किया जा सकता है जैसे कि वे सार्वजनिक डेटा सदस्य (उपयोग) हैं, लेकिन वे वास्तव में विशेष तरीके हैं जिन्हें एक्सेसर्स (घोषणा) कहा जाता है। आपका समाधान घोषणा और उपयोग के लिए तरीकों (साधारण गेटर्स / सेटर) से चिपक जाता है। तो यह है, सबसे पहले, निश्चित रूप से उपयोग ओपी के लिए नहीं पूछ रहा है, बल्कि कुछ अजीब और अपरंपरागत नामकरण सम्मेलन (और इस प्रकार, दूसरी बात, कोई सिंथेटिक चीनी भी नहीं है)।

— मथायस

एक मामूली दुष्प्रभाव के रूप में, आपका उत्परिवर्ती आश्चर्यजनक रूप से एक संपत्ति के रूप में काम करता है, क्योंकि सी ++ में एक सबसे अच्छा इनिशियलाइज़ होता है जिसके foo(bar)बजाय एक सदस्य चर पर एक म्यूटेटर विधि के foo=barसाथ प्राप्त किया जा सकता है । void foo(Bar bar)_foo

— मथियास

@ मैथियास मुझे पता है कि क्या गुण हैं, मैं एक दशक से अधिक समय से सी ++ काफी लिख रहा हूं और सी #, मैं गुणों के लाभ के बारे में बहस नहीं कर रहा हूं और वे क्या हैं लेकिन मुझे वास्तव में सी ++ में उनकी आवश्यकता नहीं है, वास्तव में आप यह कहते हुए कि उन्हें सार्वजनिक डेटा के रूप में उपयोग किया जा सकता है और यह ज्यादातर सच है लेकिन C # में ऐसे मामले हैं जहां आप सीधे संपत्तियों का उपयोग नहीं कर सकते हैं, जैसे कि किसी सार्वजनिक क्षेत्र के साथ रेफरी द्वारा संपत्ति पारित करना, आप कर सकते हैं।

— इल सोलनिक

Answer 12

नहींं .. लेकिन आपको यह विचार करना चाहिए कि क्या यह बस है: सेट फ़ंक्शन और कोई अतिरिक्त कार्य प्राप्त नहीं हुआ अंदर: सेट विधियाँ बस इसे सार्वजनिक करें।

Answer 13

मैंने कई C ++ स्रोतों से विचारों को एकत्र किया और इसे 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;
}

आउटपुट:

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

आप इसे यहां ऑनलाइन टेस्ट कर सकते हैं: http://codepad.org/zosxqjTX

Comments

सेल्फ रिफ्रेन्स, + akward ctor syntax रखने के लिए एक मेमोरी ओवरहेड है।

— Red.Wave

गुणों का प्रस्ताव करने के लिए? मुझे लगता है कि इस तरह के प्रस्तावों को खारिज कर दिया गया है।

— रेड। ववे २ Red

@ Red.Wave भगवान और फिर अस्वीकृति के गुरु को नमन। C ++ में आपका स्वागत है। यदि आप स्वयं संदर्भ नहीं चाहते हैं, तो Clang और MSVC के पास गुणों के लिए कस्टम एक्सटेंशन हैं।

— लामा १२४५

मैं कभी झुक नहीं सकता। मुझे लगता है कि हर सुविधा भी नहीं है। मेरे लिए ऑब्जेक्ट्स सेटर + गेट्टर फ़ंक्शंस की एक जोड़ी से कहीं अधिक हैं। मैंने अनावश्यक स्थायी स्मृति ओवरहेड से बचने के लिए स्वयं के कार्यान्वयन की कोशिश की है, लेकिन उदाहरणों को घोषित करने का वाक्यविन्यास और कोर संतोषजनक नहीं था; मुझे घोषणात्मक मैक्रोज़ का उपयोग करने के लिए तैयार किया गया था, लेकिन मैं किसी भी तरह मैक्रोज़ का बहुत बड़ा प्रशंसक नहीं हूं। और मेरा दृष्टिकोण आखिरकार, फ़ंक्शन सिंटैक्स के साथ पहुंच वाले छिद्रों के लिए नेतृत्व किया, जो कि स्वयं सहित कई अनुमोदन नहीं करते हैं।

— रेड। ववे २ Red

Answer 14

क्या आपको कक्षा को वास्तव में कुछ अपरिवर्तनीय लागू करने की आवश्यकता है या यह केवल सदस्य तत्वों का एक तार्किक समूह है? यदि यह बाद की बात है तो आपको इस चीज़ को एक ढांचा बनाने और सदस्यों तक सीधे पहुँचने पर विचार करना चाहिए।

Answer 15

मैक्रों का एक सेट यहां लिखा गया है । थीस के पास मूल्य प्रकार, संदर्भ प्रकार, केवल प्रकार, मजबूत और कमजोर प्रकार पढ़ने के लिए आश्वस्त संपत्ति घोषणाएं हैं।

class MyClass {

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

 public:
 ...

}