Bu biraz öznel olduğunu düşünüyorum; Ben görüş oybirliği ile emin değilim (ben başvuruları döndürülür kod parçacıkları bir sürü gördüm).

Bu soruyla ilgili bir açıklamaya göre , referansların başlatılmasıyla ilgili olarak , bir referansın geri döndürülmesi kötü olabilir, çünkü [anladığım kadarıyla] onu silmeyi kolaylaştırır, bu da bellek sızıntılarına neden olabilir.

Örnekleri takip ettiğim için (beni hayal etmiyorsam) ve bunu adil bir yerde yapmadım, bu beni endişelendiriyor ... Yanlış anladım mı? Kötü mü? Eğer öyleyse, ne kadar kötülük?

C ++ için yeni olduğum gerçeği ve ne zaman kullanacağım konusunda toplam karışıklık ile birleştiğim karışık işaretçiler ve referans çantam, uygulamalarımın bellek sızıntısı olması gerektiğini hissediyorum ...

Ayrıca, akıllı / paylaşılan işaretçiler kullanmanın genellikle bellek sızıntılarını önlemenin en iyi yolu olduğunu kabul ediyorum.

Genel olarak, bir referansın döndürülmesi tamamen normaldir ve her zaman olur.

Şunu mu demek istediniz:

int& getInt() {
    int i;
    return i;  // DON'T DO THIS.
}

Bu her türlü kötülüktür. Yığın tahsisi igider ve siz hiçbir şeyden bahsedersiniz. Bu da kötüdür:

int& getInt() {
    int* i = new int;
    return *i;  // DON'T DO THIS.
}

Çünkü şimdi müşteri garip bir şekilde yapmak zorunda:

int& myInt = getInt(); // note the &, we cannot lose this reference!
delete &myInt;         // must delete...totally weird and  evil

int oops = getInt(); 
delete &oops; // undefined behavior, we're wrongly deleting a copy, not the original

Değer referanslarının hala sadece referans olduğunu unutmayın, bu nedenle tüm kötü uygulamalar aynı kalır.

İşlevin kapsamı dışında kalan bir şey ayırmak istiyorsanız, akıllı bir işaretçi (veya genel olarak bir kap) kullanın:

std::unique_ptr<int> getInt() {
    return std::make_unique<int>(0);
}

Ve şimdi müşteri akıllı bir işaretçi saklıyor:

std::unique_ptr<int> x = getInt();

Referanslar, yaşam süresinin daha yüksek bir seviyede açık tutulduğunu bildiğiniz şeylere erişmek için de uygundur, örneğin:

struct immutableint {
    immutableint(int i) : i_(i) {}

    const int& get() const { return i_; }
private:
    int i_;
};

Burada referansı geri göndermenin uygun olduğunu biliyoruz, i_çünkü bizi arayan her şey sınıf örneğinin ömrünü yönetiyor, bu yüzden i_en azından bu kadar uzun yaşayacak.

Ve elbette, sadece yanlış bir şey yok:

int getInt() {
   return 0;
}

Ömür boyu arayana bırakılmalı ve sadece değeri hesaplıyorsanız.

Özet: Nesnenin ömrü çağrıdan sonra bitmezse bir referans döndürmeniz uygundur.

Hayır. Hayır, hayır, bin kere hayır.

Kötülük, dinamik olarak tahsis edilmiş bir nesneye gönderme yapmak ve orijinal işaretçiyi kaybetmektir. Bir newnesne olduğunuzda garantiye sahip olma yükümlülüğünüzü üstlenirsiniz delete.

Ama, örneğin bir göz, operator<<: o olmalıdır başvuru döndürmek veya

cout << "foo" << "bar" << "bletch" << endl ;

çalışmaz.

Hemen gitmeyen ve herhangi bir sahiplik aktarımı yapmak istemediğiniz mevcut bir nesneye başvuru göndermelisiniz.

Asla yerel bir değişkene veya bazılarına bir referans döndürmeyin, çünkü referans alınmayacaktır.

Arama işlevinin silme sorumluluğunu almasını beklemediğiniz işlevden bağımsız bir şeye başvuru döndürebilirsiniz. Tipik operator[]fonksiyon için durum böyledir .

Bir şey oluşturuyorsanız, bir değer veya işaretçi (normal veya akıllı) döndürmelisiniz. Çağıran işlevde bir değişkene veya ifadeye girdiği için bir değeri serbestçe döndürebilirsiniz. İşaretçiyi asla yerel bir değişkene döndürmeyin, çünkü bu işlev kaybolacaktır.

Cevapları tatmin edici bulmuyorum, bu yüzden iki sentimi ekleyeceğim.

Aşağıdaki durumları analiz edelim:

Hatalı kullanım

int& getInt()
{
    int x = 4;
    return x;
}

Bu açıkça bir hatadır

int& x = getInt(); // will refer to garbage

Statik değişkenlerle kullanım

int& getInt()
{
   static int x = 4;
   return x;
}

Bu doğrudur, çünkü statik değişkenler bir programın ömrü boyunca vardır.

int& x = getInt(); // valid reference, x = 4

Bu, Singleton kalıbını uygularken de oldukça yaygındır

Class Singleton
{
    public:
        static Singleton& instance()
        {
            static Singleton instance;
            return instance;
        };

        void printHello()
        {
             printf("Hello");
        };

}

Kullanımı:

 Singleton& my_sing = Singleton::instance(); // Valid Singleton instance
 my_sing.printHello();  // "Hello"

Operatörler

Standart kütüphane kapları, büyük ölçüde referans veren operatörlerin kullanımına bağlıdır.

T & operator*();

aşağıdakilerde kullanılabilir

std::vector<int> x = {1, 2, 3}; // create vector with 3 elements
std::vector<int>::iterator iter = x.begin(); // iterator points to first element (1)
*iter = 2; // modify first element, x = {2, 2, 3} now

Dahili verilere hızlı erişim

Dahili verilere hızlı erişim için kullanılabilecek ve kullanılabilecek zamanlar vardır

Class Container
{
    private:
        std::vector<int> m_data;

    public:
        std::vector<int>& data()
        {
             return m_data;
        }
}

kullanım ile:

Container cont;
cont.data().push_back(1); // appends element to std::vector<int>
cont.data()[0] // 1

ANCAK, bu böyle bir tuzağa neden olabilir:

Container* cont = new Container;
std::vector<int>& cont_data = cont->data();
cont_data.push_back(1);
delete cont; // This is bad, because we still have a dangling reference to its internal data!
cont_data[0]; // dangling reference!

Kötü değil. C ++ 'daki birçok şey gibi, doğru kullanılırsa iyidir, ancak kullanırken dikkat etmeniz gereken birçok tuzak vardır (yerel bir değişkene referans döndürmek gibi).

Bununla başarılabilecek iyi şeyler var (map [name] = "merhaba dünya" gibi)

"bir referansı döndürmek kötüdür, çünkü basitçe [anladığım kadarıyla], onu silmeyi özlemeyi kolaylaştırır"

Doğru değil. Bir referansın döndürülmesi sahiplik semantiği anlamına gelmez. Sadece bunu yaptığınız için:

Value& v = thing->getTheValue();

... artık v ile belirtilen belleğe sahip olduğunuz anlamına gelmez;

Ancak, bu korkunç bir kod:

int& getTheValue()
{
   return *new int;
}

Böyle bir şey yapıyorsanız, çünkü "o örnekte bir işaretçiye ihtiyacınız yoktur" : o zaman: 1) bir referansa ihtiyacınız varsa işaretçiyi serbest bırakın ve 2) sonunda işaretçiye ihtiyacınız olacaktır, çünkü bir bir delete ile yeni ve delete aramak için bir işaretçiye ihtiyacınız var.

İki durum söz konusudur:

• const referans - iyi fikir, bazen, özellikle ağır nesneler veya proxy sınıfları, derleyici optimizasyonu

• const olmayan referans - kötü fikir bazen kapsüllemeyi keser

Her ikisi de aynı sorunu paylaşıyor - potansiyel olarak yok edilen nesneye işaret edebilir ...

Bir referans / işaretçi döndürmeniz gereken birçok durum için akıllı işaretçiler kullanmanızı öneririm.

Ayrıca, aşağıdakilere dikkat edin:

Resmi bir kural vardır - C ++ Standardı (eğer ilgilenirseniz bölüm 13.3.3.1.4), bir geçici öğenin yalnızca const referansına bağlanabileceğini belirtir - const olmayan bir referans kullanmaya çalışırsanız derleyici bunu şöyle işaretlemelidir bir hata.

Sadece kötülük değil, bazen de şarttır. Örneğin, std :: vector'un [] operatörünü bir referans dönüş değeri kullanmadan uygulamak imkansızdır.

Kabul edilen cevaba ek:

struct immutableint {
    immutableint(int i) : i_(i) {}

    const int& get() const { return i_; }
private:
    int i_;
};

Bu örneğin iyi olmadığını ve mümkünse kaçınılması gerektiğini savunuyorum. Neden? Sarkan bir referansla son bulmak çok kolaydır .

Noktayı bir örnekle göstermek için:

struct Foo
{
    Foo(int i = 42) : boo_(i) {}
    immutableint boo()
    {
        return boo_;
    }  
private:
    immutableint boo_;
};

tehlike bölgesine girme:

Foo foo;
const int& dangling = foo.boo().get(); // dangling reference!

dönüş referansı genellikle büyük Nesne için C ++ 'da aşırı yüklenen operatörde kullanılır, çünkü bir değer döndürmek kopyalama işlemine ihtiyaç duyar.

Ancak geri gönderme başvurusu bellek ayırma sorununa neden olabilir. Sonuca yapılan bir başvuru, dönüş değerine bir başvuru olarak işlevden geçirileceğinden, dönüş değeri otomatik bir değişken olamaz.

dönen refernce kullanmak istiyorsanız, statik nesne arabelleği kullanabilirsiniz. Örneğin

const max_tmp=5; 
Obj& get_tmp()
{
 static int buf=0;
 static Obj Buf[max_tmp];
  if(buf==max_tmp) buf=0;
  return Buf[buf++];
}
Obj& operator+(const Obj& o1, const Obj& o1)
{
 Obj& res=get_tmp();
 // +operation
  return res;
 }

bu şekilde, geri dönen referansı güvenle kullanabilirsiniz.

Ancak functiong içinde değer döndürmek için her zaman başvuru yerine pointer kullanabilirsiniz.

Ben işlevin dönüş değeri olarak başvuru kullanarak işaretçinin işlevin dönüş değeri olarak kullanmak daha düz olduğunu düşünüyorum. İkincisi, dönüş değerinin bahsettiği statik değişkeni kullanmak her zaman güvenlidir.

En iyi şey, nesne oluşturmak ve onu bu değişkeni ayıran bir işleve referans / işaretçi parametresi olarak iletmektir.

İşlevdeki nesneyi ayırmak ve bir başvuru veya işaretçi olarak döndürmek (ancak işaretçi daha güvenlidir), işlev bloğunun sonunda bellek boşalması nedeniyle kötü bir fikirdir.

    Class Set {
    int *ptr;
    int size;

    public: 
    Set(){
     size =0;
         }

     Set(int size) {
      this->size = size;
      ptr = new int [size];
     }

    int& getPtr(int i) {
     return ptr[i];  // bad practice 
     }
  };

getPtr işlevi, silindikten sonra dinamik belleğe hatta boş bir nesneye erişebilir. Bu, Kötü Erişim İstisnalarına neden olabilir. Bunun yerine alıcı ve ayarlayıcı uygulanmalı ve iade edilmeden önce boyut doğrulanmalıdır.

Lvalue işlevi (diğer bir deyişle, sabit olmayan başvuruların döndürülmesi) C ++ 'dan kaldırılmalıdır. Son derece kasıtsız. Scott Meyers bu davranışla bir dakika () istedi.

min(a,b) = 0;  // What???

ki bu gerçekten bir gelişme değil

setmin (a, b, 0);

İkincisi daha mantıklı.

Ben lvalue olarak bu fonksiyonun C ++ tarzı akışlar için önemli olduğunu, ancak C ++ tarzı akışlarının korkunç olduğunu belirtmeye değer. Bunu düşünen tek kişi ben değilim ... Alexandrescu'nun nasıl daha iyi yapılacağına dair büyük bir makalesi olduğunu hatırladığım için, desteğin de daha iyi bir güvenli G / Ç yöntemi yaratmaya çalıştığına inanıyorum.

Gerçekten kötü olan gerçek bir problemle karşılaştım. Temelde bir geliştirici, bir vektördeki bir nesneye bir başvuru döndürdü. O kötüydü!!!

Janurary'de yazdığım tüm ayrıntılar: http://developer-resource.blogspot.com/2009/01/pros-and-cons-of-returing-references.html

Korkunç kod hakkında:

int& getTheValue()
{
   return *new int;
}

Yani, gerçekten, bellek işaretçisi dönüşten sonra kayboldu. Ancak böyle paylaşılan_ptr kullanıyorsanız:

int& getTheValue()
{
   std::shared_ptr<int> p(new int);
   return *p->get();
}

Bellek geri döndükten sonra kaybolmaz ve atamadan sonra serbest bırakılır.