Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Declarador de referência a lvalue (&)

Num declarador, `&` forma um tipo de referência a lvalue. Aprende a que se pode ligar, quando permite escrever e como evitar referências pendentes.

Versão: ISO C++23; implementation support may vary

Sintaxe

int x = 2;
int& r = x;
const int& view = x;
const int& temporary = 42;
void update(int& value);
int observe(const int& value);
int& bump(int& value);
using IntRef = int&;
int a[3]{};
int (&row)[3] = a;

Em int& r = x;, & faz parte do declarador. r torna-se um alias de x; a associação não copia x. A definição de uma referência local precisa de um inicializador, mas uma declaração de referência com âmbito de bloco que inclua explicitamente extern pode omiti-lo. Depois de estabelecida, a associação não muda: r = y; atribui um valor a x em vez de associar r a y.

int& liga-se a um lvalue int não constante, mas não ao literal 42. const int& pode ligar-se a um lvalue int, constante ou não, ou ao objeto temporário materializado a partir de 42. const impede a escrita através dessa referência, mas não alterações através de outro alias. Se as únicas sobrecargas forem f(int&) e f(const int&), um lvalue int não constante seleciona a primeira e f(42) seleciona a segunda.

Um parâmetro T& permite alterar o objeto de quem faz a chamada, se T o permitir. Um retorno T& dá a quem chama acesso a um objeto existente. Se o iterador fornecer o elemento como lvalue, for (const auto& item : items) liga-se ao elemento sem o copiar. int (&row)[3] é uma referência ao array completo de três elementos int.

Uma referência não é proprietária do objeto referenciado. A declaração local const int& t = 42; prolonga o tempo de vida do temporário até ao fim do tempo de vida de t. Numa chamada normal, um temporário ligado a um parâmetro de referência dura só até ao fim da expressão completa que inclui a chamada. Devolver essa referência não prolonga o tempo de vida do temporário. Não devolvas uma referência para um objeto local com duração de armazenamento automática: ler através de uma referência pendente provoca comportamento indefinido.

Numa expressão, o operador incorporado em &x obtém um endereço, enquanto 6 & 3 é uma operação AND bit a bit. int&& representa uma referência a rvalue, [&] indica a captura por referência por omissão numa lambda e o & final de void f() &; é um qualificador de referência que exige um objeto lvalue para chamar a função membro.

Exemplos

#include <iostream>

int& bump(int& value) {
    ++value;
    return value;
}

int observe(const int& value) {
    return value;
}

int main() {
    int value = 2;
    int other = 7;
    auto& ref = bump(value);
    std::cout << "after bump: " << value << '\n';

    ref = other;
    ++other;
    int* ptr = &ref;
    std::cout << "value: " << observe(ref) << ", other: " << other << '\n';
    std::cout << "same object: " << static_cast<int>(ptr == &value)
              << ", mask: " << (6 & 3)
              << ", temporary: " << observe(42) << '\n';
}

Resultado

after bump: 3
value: 7, other: 8
same object: 1, mask: 2, temporary: 42

`bump` altera `value` de 2 para 3 e devolve uma referência ao mesmo objeto. `ref = other` escreve 7 em `value`; incrementar `other` até 8 não altera `value`. A comparação dos endereços confirma a identidade do objeto. `6 & 3` dá 2 e `observe(42)` lê o temporário em segurança durante a chamada.

Lições relacionadas

  • C++ · Lição 1 · Avançado · Versão: 3
  • C++ · Lição 2 · Avançado · Versão: 3
  • C++ · Lição 3 · Avançado · Versão: 3
  • C++ · Lição 5 · Avançado · Versão: 3
  • C++ · Lição 6 · Avançado · Versão: 3
  • C++ · Lição 9 · Avançado · Versão: 3
  • C++ · Lição 10 · Avançado · Versão: 3
  • C++ · Lição 11 · Avançado · Versão: 3
  • C++ · Lição 12 · Avançado · Versão: 3
  • C++ · Lição 13 · Avançado · Versão: 3
  • C++ · Lição 14 · Avançado · Versão: 3
  • C++ · Lição 15 · Avançado · Versão: 3
  • C++ · Lição 16 · Avançado · Versão: 3
  • C++ · Lição 18 · Avançado · Versão: 3
  • C++ · Lição 19 · Avançado · Versão: 3
  • C++ · Lição 21 · Avançado · Versão: 3
  • C++ · Lição 22 · Avançado · Versão: 3
  • C++ · Lição 23 · Avançado · Versão: 3
  • C++ · Lição 25 · Avançado · Versão: 3
  • C++ · Lição 26 · Avançado · Versão: 3
  • C++ · Lição 27 · Avançado · Versão: 3
  • C++ · Lição 28 · Avançado · Versão: 3
  • C++ · Lição 29 · Avançado · Versão: 3
  • C++ · Lição 30 · Avançado · Versão: 3
  • C++ · Lição 31 · Avançado · Versão: 3
  • C++ · Lição 32 · Avançado · Versão: 3
  • C++ · Lição 33 · Avançado · Versão: 3
  • C++ · Lição 34 · Avançado · Versão: 3
  • C++ · Lição 35 · Avançado · Versão: 3
  • C++ · Lição 36 · Avançado · Versão: 3
  • C++ · Lição 38 · Avançado · Versão: 3
  • C++ · Lição 41 · Avançado · Versão: 3
  • C++ · Lição 42 · Avançado · Versão: 3
  • C++ · Lição 43 · Avançado · Versão: 3
  • C++ · Lição 45 · Avançado · Versão: 3
  • C++ · Lição 48 · Avançado · Versão: 3
  • C++ · Lição 49 · Avançado · Versão: 3
  • C++ · Lição 51 · Avançado · Versão: 3
  • C++ · Lição 53 · Avançado · Versão: 3
  • C++ · Lição 54 · Avançado · Versão: 3
  • C++ · Lição 55 · Avançado · Versão: 3
  • C++ · Lição 57 · Avançado · Versão: 3
  • C++ · Lição 59 · Avançado · Versão: 3
  • C++ · Lição 60 · Avançado · Versão: 3

Fontes