C++ - const Mitglieder / return-const int& vs return int

Diese beiden sind zwei mögliche Signaturen für eine member-Funktion in einer Klasse, verspricht nicht zu ändern, das Objekt selbst. Im ersten Fall wird es wieder eine Konstante Referenz auf einen integer (ggf. ein member-Attribut), der Verweis wird const bedeutet, dass der Anrufer nicht in der Lage, es zu benutzen, ändern Sie das Attribut internal zu. Der zweite Fall, es gibt einen integer-Wert.

Gibt es leichte Unterschiede in der Semantik, aber in den meisten Fällen werden Sie nicht sein, wichtig ist, sollten Sie in zwei Funktionen zu erhalten einen Wert. Für einen Fall, wo es macht einen Unterschied sehen:

class test {
public:
   test() : m_value() {
      std::cout << &m_value << std::endl; //print where the attribute is
   }
   int const & getValue() const {
      return m_value;
   }
   int copyValue() const {
      return m_value;
   }
   void setValue( int value ) {
      m_value = value;
   }
private:
   int m_value;
};
int main() {
   test t;                      //will printout an address [1]
   int v1 = t.getValue();       //caller copies the value
   int v2 = t.copyValue();      //caller copies the value (itself a copy in hte calle)
   int const &r = t.getValue(); //reference to t.m_value
   int const &c = t.copyValue();//reference to *copy* [2]
   std::cout << v1 << v2 << r << c
      << std::cout;             //0000
   std::cout << &v1 << &v2      //4 pointers, the third is [1] a r *is* t.m_value
      << &r << &c << std::cout; //    the rest should be different
   t.setValue( 5 );
   std::cout << v1 << v2 << r   //0050, v1 and v2 where copies, r *is* t.m_value
      << c << std::cout;
}

Die Zeile gekennzeichnet mit [2] verwendet eine seltsam Merkmal der Sprache durch, die wenn Sie erhalten einen Konstante Referenz zu einem r-Wert (temporäre) der compiler binden, die vorübergehend auf den Bezug und lebendig zu halten, bis die Referenz den Gültigkeitsbereich verlässt (im Grunde dreht sich die r-Wert temporär in eine versteckte variable und bindet den Verweis darauf).

Ich Hinzugefügt, dass die Linie zu explizit, dass der Unterschied im Verhalten ist nicht durch das empfangende Ende main eine Kopie der Aufrechterhaltung einer Referenz, sondern (auch um genau zu sein) durch die Unterschrift des Accessors.

const int& a() const;

a() gibt eine const-Referenz auf ein int. const modifier am Ende bedeutet, dass Sie nicht ändern Sie den Status des Objekts abgerufen.

int getA() const;

Gleiche wie die obige Beschreibung, außer, dass der Rückgabetyp ist int muss eine Kopie der variable zurückgegeben, wenn erfasst.

Was gemeint ist, wenn gesagt, nicht ändern der Zustand des Objekts?

class foo
{
    int m_Var ;
    public:
        foo(int arg1) : m_Var(arg1){}
        void mutableMethod()
        {
            m_Var = 20 ;  //"this" has the variable m_Var and
                          // by assigning it a value changes the state of
                          // m_Var. Changing the state of it's member variable
                          // is meant changing the state of object.
        }

        void nonMutableMethod() const
        {
             m_Var = 20 ;  // This assignment is not allowed because of const 
                           // modifier. The method is not allowed to change the
                           // the state of object on which it is called ( this )
        }
};

Ebenfalls, Konstante Methoden nicht zurück-member-Variablen von nicht-const-Referenz.

Können wir cast zurückgegebene Referenz auf Zeiger, also theoretisch macht es mehr info zur Verfügung (Adresse und Wert) als die Rückkehr einer Kopie (Wert).

Und es ist möglich zu hacken const ref zu veränderlich mit const_cast.

Compiler wird versuchen, sich mit dem Wert von original-register, Adresse oder wörtliche sowieso.

Alternative Wege für das Ziel? Um sicherzustellen, dass der Aufenthalt ständig korrigieren würde nicht fügen Sie zusätzliche Arbeit. Für const-reference und const-ich finde CR & CN-Makros hilfreich.

#define CN  const
#define CR  const&         //Constant reference
#define CDa const*         //mutable pointer to constant data
#define CPD const * const  //constant pointer to constant data
const int&  verbose() const;
int CR      shorter() CN;

Nebeneffekt ist, dass die Erklärungen kürzer und wie die Linien werden kürzer, die Anzahl der Linien verringert sich ebenfalls. Frage des Geschmacks tho... Aber wenn kombiniert mit DMAP makro, es scheint um einen Vorteil zu haben.

typedef std::map<size_t, float>     TypeMap_Of_size_t_vs_float;
TypeMap_Of_size_t_vs_float          m_Map;
const TypeMap_Of_size_t_vs_float&   verboseIsNice() const
{
    return m_MyMap;
}
for each (auto myElement in verboseIsNice()) 
{
    myElement.foo();
}

vs

DMAP(SZ, Flo)  m_Map;                    //typedefs MSZFlo=std::map<size_t, float>
MSZFlo CR      tldr()                 CN { return m_Map; }
fe(el, tldr()) el.foo();

Ohne auto und mit der Verwendung von Iteratoren im Beispiel würde zeigen, mehr als 333% Unterschied.