Ponteiro vs. Referência

Qual seria a melhor prática ao atribuir a uma função a variável original para trabalhar:

unsigned long x = 4;

void func1(unsigned long& val) {
     val = 5;            
}
func1(x);

ou:

void func2(unsigned long* val) {
     *val = 5;
}
func2(&x);

IOW: Existe algum motivo para escolher um sobre o outro?

Minha regra de ouro é:

Use ponteiros se desejar fazer a aritmética do ponteiro com eles (por exemplo, incrementar o endereço do ponteiro para percorrer uma matriz) ou se precisar passar um ponteiro NULL.

Use referências caso contrário.

Realmente acho que você se beneficiará do estabelecimento da seguinte função, chamando diretrizes de codificação:

1. Como em todos os outros lugares, sempre esteja constcorreto.

   • Nota: Isso significa, entre outras coisas, que apenas os valores externos (consulte o item 3) e os valores passados ​​pelo valor (consulte o item 4) podem não ter o constespecificador.

2. Somente passe um valor por ponteiro se o valor 0 / NULL for uma entrada válida no contexto atual.

   • Justificativa 1: Como chamador , você vê que tudo o que você passa deve estar em um estado utilizável.

   • Fundamentação 2: Conforme chamado , você sabe que tudo o que entra está em um estado utilizável. Portanto, nenhuma verificação NULL ou manipulação de erros precisa ser feita para esse valor.

   • Razão 3: As razões 1 e 2 serão aplicadas pelo compilador . Sempre pegue erros em tempo de compilação, se puder.

3. Se um argumento de função for um valor externo, passe-o por referência.

   • Fundamentação da petição: Não queremos quebrar o item 2 ...

4. Escolha "passar por valor" sobre "passar por referência de const" apenas se o valor for um POD (estrutura de dados antiga simples ) ou pequeno o suficiente (em memória) ou de outras maneiras barato o suficiente (em tempo) para copiar.

   • Justificativa: Evite cópias desnecessárias.
   • Nota: pequeno o suficiente e barato o suficiente não são mensuráveis ​​absolutos.

Isso acaba sendo subjetivo. A discussão até agora é útil, mas não acho que haja uma resposta correta ou decisiva para isso. Muito dependerá das diretrizes de estilo e das suas necessidades no momento.

Embora existam alguns recursos diferentes (se algo pode ou não ser NULL) com um ponteiro, a maior diferença prática para um parâmetro de saída é puramente a sintaxe. O Guia de estilo C ++ do Google ( https://google.github.io/styleguide/cppguide.html#Reference_Arguments ), por exemplo, exige apenas ponteiros para os parâmetros de saída e permite apenas referências que são const. O raciocínio é de legibilidade: algo com sintaxe de valor não deve ter um significado semântico de ponteiro. Não estou sugerindo que isso seja necessariamente certo ou errado, mas acho que o ponto aqui é que é uma questão de estilo, não de correção.

Você deve passar um ponteiro se quiser modificar o valor da variável. Mesmo que tecnicamente passar uma referência ou um ponteiro seja o mesmo, passar um ponteiro no seu caso de uso é mais legível, pois "anuncia" o fato de que o valor será alterado pela função.

Se você possui um parâmetro em que pode precisar indicar a ausência de um valor, é prática comum transformar o parâmetro em um valor de ponteiro e passar NULL.

Uma solução melhor na maioria dos casos (de uma perspectiva de segurança) é usar o boost :: opcional . Isso permite que você transmita valores opcionais por referência e também como um valor de retorno.

// Sample method using optional as input parameter
void PrintOptional(const boost::optional<std::string>& optional_str)
{
    if (optional_str)
    {
       cout << *optional_str << std::endl;
    }
    else
    {
       cout << "(no string)" << std::endl;
    }
}

// Sample method using optional as return value
boost::optional<int> ReturnOptional(bool return_nothing)
{
    if (return_nothing)
    {
       return boost::optional<int>();
    }

    return boost::optional<int>(42);
}

Use uma referência quando puder, use um ponteiro quando precisar. Do FAQ do C ++: "Quando devo usar referências e quando devo usar ponteiros?"

Ponteiros

• Um ponteiro é uma variável que contém um endereço de memória.
• Uma declaração de ponteiro consiste em um tipo base, um * e o nome da variável.
• Um ponteiro pode apontar para qualquer número de variáveis ​​durante a vida útil

• Um ponteiro que atualmente não aponta para um local válido da memória recebe o valor nulo (que é zero)

  BaseType* ptrBaseType;
  BaseType objBaseType;
  ptrBaseType = &objBaseType;

• O & é um operador unário que retorna o endereço de memória de seu operando.

• O operador de desreferenciação (*) é usado para acessar o valor armazenado na variável para a qual o ponteiro aponta.

     int nVar = 7;
     int* ptrVar = &nVar;
     int nVar2 = *ptrVar;

Referência

• Uma referência (&) é como um alias para uma variável existente.

• Uma referência (&) é como um ponteiro constante que é automaticamente desreferenciado.

• Geralmente é usado para listas de argumentos de função e valores de retorno de função.

• Uma referência deve ser inicializada quando é criada.

• Depois que uma referência é inicializada para um objeto, ela não pode ser alterada para se referir a outro objeto.

• Você não pode ter referências NULL.

• Uma referência const pode se referir a uma const int. Isso é feito com uma variável temporária com o valor da const

  int i = 3;    //integer declaration
  int * pi = &i;    //pi points to the integer i
  int& ri = i;    //ri is refers to integer i – creation of reference and initialization

Uma referência é um ponteiro implícito. Basicamente, você pode alterar o valor para o qual a referência aponta, mas não pode alterar a referência para apontar para outra coisa. Então, meus 2 centavos é que, se você quiser alterar apenas o valor de um parâmetro, passe-o como referência, mas se precisar alterar o parâmetro para apontar para um objeto diferente, passe-o usando um ponteiro.

Considere a palavra-chave de saída do C #. O compilador requer que o chamador de um método aplique a palavra-chave out a qualquer argumento de saída, mesmo que ele já saiba se o é. Isso tem como objetivo melhorar a legibilidade. Embora com os IDEs modernos, estou inclinado a pensar que este é um trabalho de destaque de sintaxe (ou semântica).

Passe por referência const, a menos que haja uma razão pela qual você queira alterar / manter o conteúdo que está passando.

Este será o método mais eficiente na maioria dos casos.

Certifique-se de usar const em cada parâmetro que você não deseja alterar, pois isso não apenas protege você de fazer algo estúpido na função, mas também fornece aos outros usuários o que a função faz com os valores passados. Isso inclui fazer um ponteiro const quando você deseja alterar apenas o que é indicado ...

Ponteiros:

• Pode ser atribuído nullptr(ou NULL).
• No site de chamada, você deve usar &se o seu tipo não for um ponteiro, tornando explicitamente a modificação do seu objeto.
• Os ponteiros podem ser recuperados.

Referências:

• Não pode ser nulo.
• Uma vez vinculado, não pode mudar.
• Os chamadores não precisam usar explicitamente &. Isso às vezes é considerado ruim porque você deve ir para a implementação da função para ver se seu parâmetro foi modificado.

Uma referência é semelhante a um ponteiro, exceto que você não precisa usar um prefixo ∗ para acessar o valor referido pela referência. Além disso, não é possível fazer uma referência para se referir a um objeto diferente após sua inicialização.

As referências são particularmente úteis para especificar argumentos de função.

para obter mais informações, consulte "Um tour pelo C ++" de "Bjarne Stroustrup" (2014) Páginas 11-12