Saya kira ini agak subyektif; Saya tidak yakin apakah pendapatnya akan bulat (saya telah melihat banyak cuplikan kode tempat referensi dikembalikan).

Menurut komentar terhadap pertanyaan ini, saya baru saja bertanya, mengenai inisialisasi referensi , mengembalikan referensi bisa jahat karena, [seperti yang saya mengerti] membuatnya lebih mudah untuk tidak menghapusnya, yang dapat menyebabkan kebocoran memori.

Ini membuat saya khawatir, karena saya telah mengikuti contoh (kecuali saya membayangkan hal-hal) dan melakukan ini di beberapa tempat yang adil ... Apakah saya salah paham? Apakah itu jahat? Kalau begitu, seberapa jahatkah?

Saya merasa bahwa karena kantong campuran pointer dan referensi saya, dikombinasikan dengan fakta bahwa saya baru menggunakan C ++, dan kebingungan total tentang apa yang harus digunakan ketika, aplikasi saya pasti kehabisan memori ...

Juga, saya mengerti bahwa menggunakan pointer pintar / bersama umumnya diterima sebagai cara terbaik untuk menghindari kebocoran memori.

Secara umum, mengembalikan referensi sangat normal dan terjadi setiap saat.

Jika yang kamu maksud:

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

Itu semua jenis kejahatan. Tumpukan yang dialokasikan iakan hilang dan Anda tidak merujuk apa pun. Ini juga jahat:

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

Karena sekarang klien pada akhirnya harus melakukan yang aneh:

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

Perhatikan bahwa referensi nilai masih hanya referensi, jadi semua aplikasi jahat tetap sama.

Jika Anda ingin mengalokasikan sesuatu yang hidup di luar cakupan fungsi, gunakan pointer pintar (atau secara umum, wadah):

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

Dan sekarang klien menyimpan pointer pintar:

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

Referensi juga boleh digunakan untuk mengakses hal-hal yang Anda tahu seumur hidup tetap terbuka pada tingkat yang lebih tinggi, misalnya:

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

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

Di sini kita tahu tidak apa-apa untuk mengembalikan referensi i_karena apa pun yang memanggil kita mengelola masa instance kelas, jadi i_akan hidup setidaknya selama itu.

Dan tentu saja, tidak ada yang salah dengan hanya:

int getInt() {
   return 0;
}

Jika seumur hidup harus diserahkan kepada penelepon, dan Anda hanya menghitung nilainya.

Ringkasan: tidak apa-apa untuk mengembalikan referensi jika umur objek tidak akan berakhir setelah panggilan.

Tidak. Tidak, tidak, seribu kali tidak.

Apa yang jahat adalah membuat referensi ke objek yang dialokasikan secara dinamis dan kehilangan pointer asli. Ketika Anda newsebuah objek Anda mengasumsikan kewajiban untuk memiliki jaminan delete.

Tetapi lihat, misalnya operator<<: yang harus mengembalikan referensi, atau

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

tidak akan bekerja

Anda harus mengembalikan referensi ke objek yang ada yang tidak segera pergi, dan di mana Anda tidak bermaksud melakukan transfer kepemilikan.

Jangan pernah mengembalikan referensi ke variabel lokal atau semacamnya, karena itu tidak akan ada untuk dirujuk.

Anda dapat mengembalikan referensi ke sesuatu yang terpisah dari fungsi, yang tidak Anda harapkan fungsi pemanggilannya bertanggung jawab untuk dihapus. Ini adalah kasus untuk tipikaloperator[] fungsi .

Jika Anda membuat sesuatu, Anda harus mengembalikan nilai atau penunjuk (biasa atau pintar). Anda dapat mengembalikan nilai secara bebas, karena akan menjadi variabel atau ekspresi dalam fungsi panggilan. Jangan pernah mengembalikan pointer ke variabel lokal, karena itu akan hilang.

Saya menemukan jawabannya tidak memuaskan jadi saya akan menambahkan dua sen saya.

Mari kita menganalisis kasus-kasus berikut:

Penggunaan yang salah

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

Ini jelas kesalahan

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

Penggunaan dengan variabel statis

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

Ini benar, karena variabel statis ada sepanjang masa program.

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

Ini juga cukup umum ketika menerapkan pola Singleton

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

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

}

Pemakaian:

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

Operator

Kontainer perpustakaan standar sangat bergantung pada penggunaan operator yang mengembalikan referensi, misalnya

T & operator*();

dapat digunakan sebagai berikut

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

Akses cepat ke data internal

Ada saat-saat & dapat digunakan untuk akses cepat ke data internal

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

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

dengan penggunaan:

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

NAMUN, ini dapat menyebabkan jebakan seperti ini:

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!

Itu tidak jahat. Seperti banyak hal dalam C ++, ada baiknya jika digunakan dengan benar, tetapi ada banyak jebakan yang harus Anda perhatikan saat menggunakannya (seperti mengembalikan referensi ke variabel lokal).

Ada hal-hal baik yang dapat dicapai dengannya (seperti peta [nama] = "halo dunia")

"Mengembalikan referensi adalah kejahatan karena, hanya [seperti yang saya mengerti] itu membuatnya lebih mudah untuk tidak menghapusnya"

Tidak benar. Mengembalikan referensi tidak menyiratkan kepemilikan semantik. Yaitu, hanya karena Anda melakukan ini:

Value& v = thing->getTheValue();

... tidak berarti Anda sekarang memiliki memori yang disebut oleh v;

Namun, ini adalah kode yang mengerikan:

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

Jika Anda melakukan sesuatu seperti ini karena "Anda tidak memerlukan pointer pada contoh itu" maka: 1) cukup referensi pointer jika Anda memerlukan referensi, dan 2) Anda akhirnya akan membutuhkan pointer, karena Anda harus mencocokkan baru dengan delete, dan Anda perlu pointer untuk memanggil delete.

Ada dua kasus:

• referensi const - ide bagus, kadang-kadang, terutama untuk objek berat atau kelas proxy, pengoptimalan kompiler

• referensi non-const --bad ide, kadang-kadang, istirahat enkapsulasi

Keduanya berbagi masalah yang sama - berpotensi menunjuk ke objek yang hancur ...

Saya akan merekomendasikan menggunakan smart pointer untuk banyak situasi di mana Anda harus mengembalikan referensi / pointer.

Perhatikan juga hal-hal berikut:

Ada aturan formal - Standar C ++ (bagian 13.3.3.1.4 jika Anda tertarik) menyatakan bahwa sementara hanya dapat terikat ke referensi const - jika Anda mencoba menggunakan referensi non-const, kompiler harus menandai ini sebagai kesalahan.

Bukan saja itu bukan kejahatan, terkadang juga penting. Sebagai contoh, akan mustahil untuk mengimplementasikan operator [] std :: vector tanpa menggunakan nilai balik referensi.

Tambahan untuk jawaban yang diterima:

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

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

Saya berpendapat bahwa contoh ini tidak baik dan harus dihindari jika memungkinkan. Mengapa? Sangat mudah untuk berakhir dengan referensi yang menggantung .

Untuk mengilustrasikan poin dengan contoh:

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

memasuki zona bahaya:

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

referensi pengembalian biasanya digunakan dalam overloading operator di C ++ untuk Objek besar, karena mengembalikan nilai perlu operasi penyalinan (dalam overloading perator, kami biasanya tidak menggunakan pointer sebagai nilai balik)

Tetapi pengembalian referensi dapat menyebabkan masalah alokasi memori. Karena referensi ke hasil akan dikeluarkan dari fungsi sebagai referensi ke nilai kembali, nilai kembali tidak bisa menjadi variabel otomatis.

jika Anda ingin menggunakan referensi yang kembali, Anda dapat menggunakan buffer objek statis. sebagai contoh

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

dengan cara ini, Anda dapat menggunakan referensi pengembalian dengan aman.

Tapi Anda selalu bisa menggunakan pointer daripada referensi untuk mengembalikan nilai di functiong.

saya pikir menggunakan referensi sebagai nilai kembali fungsi jauh lebih lurus daripada menggunakan pointer sebagai nilai balik fungsi. Kedua Akan selalu aman untuk menggunakan variabel statis yang merujuk nilai kembali.

Hal terbaik adalah membuat objek dan meneruskannya sebagai parameter referensi / penunjuk ke fungsi yang mengalokasikan variabel ini.

Mengalokasikan objek dalam fungsi dan mengembalikannya sebagai referensi atau pointer (pointer lebih aman namun) adalah ide yang buruk karena membebaskan memori di akhir blok fungsi.

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

Fungsi getPtr dapat mengakses memori dinamis setelah penghapusan atau bahkan objek null. Yang dapat menyebabkan Pengecualian Akses Buruk. Sebaliknya pengambil dan penyetel harus diimplementasikan dan ukuran diverifikasi sebelum kembali.

Berfungsi sebagai lvalue (alias, pengembalian referensi non-const) harus dihapus dari C ++. Ini sangat tidak intuitif. Scott Meyers ingin min () dengan perilaku ini.

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

yang tidak benar-benar perbaikan

setmin (a, b, 0);

Yang terakhir bahkan lebih masuk akal.

Saya menyadari bahwa fungsi sebagai lvalue penting untuk aliran gaya C ++, tetapi perlu menunjukkan bahwa aliran gaya C ++ mengerikan. Saya bukan satu-satunya yang berpikir ini ... seingat saya, Alexandrescu memiliki artikel besar tentang bagaimana melakukan yang lebih baik, dan saya percaya dorongan juga telah mencoba untuk menciptakan metode I / O aman jenis yang lebih baik.

Saya mengalami masalah nyata di mana itu memang jahat. Pada dasarnya seorang pengembang mengembalikan referensi ke objek dalam vektor. Itu buruk!!!

Rincian lengkap yang saya tulis di Janurary: http://developer-resource.blogspot.com/2009/01/pros-and-cons-of-returing-references.html

Tentang kode mengerikan:

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

Jadi, memang, penunjuk memori hilang setelah kembali. Tetapi jika Anda menggunakan shared_ptr seperti itu:

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

Memori tidak hilang setelah kembali dan akan dibebaskan setelah penugasan.