Isso é um pouco subjetivo, eu acho; Não tenho certeza se a opinião será unânime (já vi muitos trechos de código em que as referências são retornadas).

De acordo com um comentário sobre essa pergunta que acabei de fazer, em relação à inicialização de referências , o retorno de uma referência pode ser ruim porque, como eu entendo, fica mais fácil deixar de excluí-la, o que pode levar a vazamentos de memória.

Isso me preocupa, pois tenho seguido exemplos (a menos que esteja imaginando coisas) e feito isso em poucos lugares ... Entendi mal? Isso é mau? Se sim, quão mal?

Eu sinto que, por causa do meu pacote misto de ponteiros e referências, combinado com o fato de eu ser novo em C ++, e total confusão sobre o que usar quando, meus aplicativos devem ser um inferno de vazamento de memória ...

Além disso, entendo que o uso de ponteiros inteligentes / compartilhados geralmente é aceito como a melhor maneira de evitar vazamentos de memória.

Em geral, retornar uma referência é perfeitamente normal e acontece o tempo todo.

Se você diz:

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

Isso é todo tipo de mal. A pilha alocada idesaparecerá e você está se referindo a nada. Isso também é mau:

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

Porque agora o cliente precisa fazer o estranho:

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

Observe que as referências rvalue ainda são apenas referências; portanto, todos os aplicativos inválidos permanecem os mesmos.

Se você deseja alocar algo que vive além do escopo da função, use um ponteiro inteligente (ou, geralmente, um contêiner):

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

E agora o cliente armazena um ponteiro inteligente:

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

Referências também são boas para acessar itens em que você sabe que a vida está sendo mantida aberta em um nível superior, por exemplo:

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

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

Aqui sabemos que não há problema em retornar uma referência a i_ porque o que quer que esteja nos chama gerencia o tempo de vida da instância da classe, e assim permanecerá i_pelo menos por tanto tempo.

E, claro, não há nada errado com apenas:

int getInt() {
   return 0;
}

Se o tempo de vida útil for deixado para o chamador, e você está apenas computando o valor.

Resumo: não há problema em retornar uma referência se a vida útil do objeto não terminar após a chamada.

Não. Não, não, mil vezes não.

O que é mau é fazer referência a um objeto alocado dinamicamente e perder o ponteiro original. Quando você é newum objeto, assume uma obrigação de ter uma garantia delete.

Mas dê uma olhada, por exemplo, em operator<<: isso deve retornar uma referência, ou

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

não vai funcionar.

Você deve retornar uma referência a um objeto existente que não desaparece imediatamente e para o qual não pretende transferir a propriedade.

Nunca retorne uma referência a uma variável local ou algo parecido, porque ela não estará lá para ser referenciada.

Você pode retornar uma referência a algo independente da função, que não espera que a função de chamada assuma a responsabilidade de excluir. Este é o caso do típicooperator[] função .

Se você estiver criando algo, retorne um valor ou um ponteiro (regular ou inteligente). Você pode retornar um valor livremente, pois ele está entrando em uma variável ou expressão na função de chamada. Nunca retorne um ponteiro para uma variável local, pois ela desaparecerá.

As respostas não são satisfatórias, então adicionarei meus dois centavos.

Vamos analisar os seguintes casos:

Uso incorreto

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

Isso é obviamente erro

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

Uso com variáveis ​​estáticas

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

Isso está certo, porque variáveis ​​estáticas existem durante toda a vida útil de um programa.

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

Isso também é bastante comum ao implementar o padrão Singleton

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

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

}

Uso:

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

Operadores

Os contêineres de biblioteca padrão dependem muito do uso de operadores que retornam referências, por exemplo

T & operator*();

pode ser usado no seguinte

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

Acesso rápido a dados internos

Há momentos em que & pode ser usado para acesso rápido a dados internos

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

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

com o uso:

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

No entanto, isso pode levar a armadilhas como esta:

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!

Isso não é mau. Como muitas coisas no C ++, é bom se usado corretamente, mas há muitas armadilhas que você deve estar ciente ao usá-lo (como retornar uma referência a uma variável local).

Há coisas boas que podem ser alcançadas com ele (como map [name] = "olá mundo")

"retornar uma referência é ruim porque, simplesmente [como eu entendo], é mais fácil deixar de excluí-la"

Não é verdade. Retornar uma referência não implica em semântica de propriedade. Ou seja, apenas porque você faz isso:

Value& v = thing->getTheValue();

... não significa que agora você possui a memória mencionada por v;

No entanto, este é um código horrível:

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

Se você estiver fazendo algo assim porque "você não precisa de um ponteiro nessa instância", então: 1) simplesmente desreferencie o ponteiro se precisar de uma referência e 2) você acabará precisando do ponteiro, porque precisa corresponder a um novo com uma exclusão e você precisa de um ponteiro para chamar a exclusão.

Existem dois casos:

• referência const - boa idéia, às vezes, especialmente para objetos pesados ​​ou classes proxy, otimização do compilador

• referência não-const - idéia ruim, às vezes, quebra encapsulamentos

Ambos compartilham o mesmo problema - podem apontar para um objeto destruído ...

Eu recomendaria o uso de ponteiros inteligentes para muitas situações em que você precisa retornar uma referência / ponteiro.

Além disso, observe o seguinte:

Existe uma regra formal - o Padrão C ++ (seção 13.3.3.1.4, se você estiver interessado) declara que um temporário só pode ser vinculado a uma referência const - se você tentar usar uma referência não const, o compilador deve sinalizar isso como um erro.

Não apenas não é mau, como às vezes é essencial. Por exemplo, seria impossível implementar o operador [] do std :: vector sem usar um valor de retorno de referência.

Além da resposta aceita:

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

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

Eu diria que este exemplo não está bem e deve ser evitado, se possível. Por quê? É muito fácil terminar com um referência pendente .

Para ilustrar o ponto com um exemplo:

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

entrar na zona de perigo:

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

A referência de retorno geralmente é usada na sobrecarga do operador em C ++ para Objeto grande, pois o retorno de um valor precisa de operação de cópia. (na sobrecarga do perator, geralmente não usamos ponteiro como valor de retorno)

Mas a referência de retorno pode causar problemas de alocação de memória. Como uma referência ao resultado será eliminada da função como uma referência ao valor de retorno, o valor de retorno não pode ser uma variável automática.

se você quiser usar referência de retorno, poderá usar um buffer de objeto estático. por exemplo

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

Dessa forma, você pode usar a referência retornada com segurança.

Mas você sempre pode usar ponteiro em vez de referência para retornar valor em functiong.

Eu acho que usar referência como valor de retorno da função é muito mais direto do que usar ponteiro como valor de retorno da função. Em segundo lugar, seria sempre seguro usar a variável estática à qual o valor de retorno se refere.

O melhor é criar um objeto e passá-lo como parâmetro de referência / ponteiro para uma função que aloca essa variável.

Alocar um objeto na função e retorná-lo como uma referência ou ponteiro (porém, o ponteiro é mais seguro) é uma má idéia, pois libera memória no final do bloco de funções.

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

A função getPtr pode acessar a memória dinâmica após a exclusão ou mesmo um objeto nulo. O que pode causar exceções de acesso incorreto. Em vez disso, getter e setter devem ser implementados e o tamanho verificado antes de retornar.

A função como lvalue (também conhecido como retorno de referências não const) deve ser removida do C ++. É terrivelmente pouco intuitivo. Scott Meyers queria um minuto () com esse comportamento.

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

o que não é realmente uma melhoria

setmin (a, b, 0);

O último ainda faz mais sentido.

Sei que a função como lvalue é importante para os fluxos de estilo C ++, mas vale ressaltar que os fluxos de estilo C ++ são terríveis. Eu não sou o único que pensa isso ... Lembro-me de que Alexandrescu tinha um grande artigo sobre como fazer melhor, e acredito que o boost também tentou criar um método de E / S seguro de tipo melhor.

Eu me deparei com um problema real, onde era realmente mau. Essencialmente, um desenvolvedor retornou uma referência a um objeto em um vetor. Isso foi ruim!!!

Os detalhes completos sobre os quais escrevi no Janurary: http://developer-resource.blogspot.com/2009/01/pros-and-cons-of-returing-references.html

Sobre código horrível:

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

Então, de fato, o ponteiro da memória perdeu após o retorno. Mas se você usar shared_ptr assim:

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

A memória não é perdida após o retorno e será liberada após a atribuição.