Ola amigos!
Estou fazendo uma revisão de C++... Fique um bom tempo parado!

E estudando me veio a seguinte dúvida!
Sabemos que uma variável ocupa lugar na memória e que ponteiros são um tipo 'especial' de variáveis que foram projetos para trabalhar com endereços de memória... como o tipo int foi projeto para trabalhar com valores inteiros! Ok.

Mas e as referências... elas se assemelham aos ponteiros mas será que ocupam lugar na memória ou são penas 'alias' em tempo de compilação que são resolvidos e dessa forma não ocupam lugar na memória!???
Se nós usar-mos o operador unário (&) conhecido como "o endereço de" em uma referência vamos pegar na verdade o endereço da variável que é referenciada pela referência... fiz um código para demonstrar!



A saída é a seguinte:



Bem como vcs podem ver quando eu uso: &p ele me dá o endereço onde o ponteiro p está armazenado (0x22ff04)...
Mas quando eu uso: &ref ele me dá o endereço: (0x22ff08) que é o mesmo o dá variável var: (0x22ff08)... Daí conclui que as referências não são armazenas na memória como ponteiros estou certo? Comentários são bem vindos!

O que é armazenado na memória é só um ponteiro para aquela variável, não uma copia, que é o principio básico do &: Passar a variável sendo utilizada para que seja modificada dentro das funções SEM criar uma cópia, otimizando e obtendo o resultado desejado.

Que eu lembre o & do C++ é só uma facilitação, se você usar C vai ter que passar um ponteiro comum *.

Caro amigo PhGodinho, acho que tu não leu o texto quando diz:


Quando vc diz que é armazenado na memória então quer dizer que é alocado espaço na memória para conter esse endereço de uma outra varíavel... Mas como foi demonstrado o uso do & em:


Os dois endereços são os mesmo então não foi criado armazenamento para essa referência. Esse é ponto da questão.
Já com o ponteiro foi alocado na memória um espaço para armazenar o endereço para o qual o ponteiro aponta...

Desta forma como havia tido antes, me parece que não é alocado qualquer espaço para armazenar a referência???
É essa a minha dúvida.

Os endereços são os mesmos pois o compilador não permite acessar o valor do ponteiro. As referencias são como "ponteiros de alto nível", ela aponta para um local da memória da mesma forma de um ponteiro, porém você a usa exatamente como uma variável normal.

Sim mas minha pergunta é! ela está armazenada em algum lugar? ou é uma alias apenas em tempo de compilação?

Por que entendo que se ela está armazenada de fato em algum lugar na memória e o compilar "safadiiinho" não me permiti acessar esse endereço com o operador & então deve haver em algum lugar uma regra que diga algo como:

"Quando se usa o operador unário & 'o endereço de' com uma referência o compilador informa a posição de memória onde a variável referenciada se encontra e não o endereço de onde a referência se encontra"

Só que nunca ouvi falar nessa regra e por isso minha dúvida!
É isso mesmo?

Ele ocupa espaço da mesma forma que o ponteiro, na verdade ele é um ponteiro, mas o compilador esconde isso pois ele faz a desreferência desse ponteiro automaticamente sempre que ele é usado, enquanto que no ponteiro normal você tem que fazer isso manualmente.

Como disse o compilador é "safadiiinho" e esconde isso!
Então é isso obrigado pela ajuda e até a próxima!

Talvez uma forma melhor de explicar isso seja a sequinte: Referências, em C++, podem se comportar de duas maneiras. Como se fossem ponteiros ou como se fossem "apelidos", dependendo de como sejam usadas.

Nos exemplos mostrados:

A referência 'b' é apenas um "apelido", um "alias", para a variável 'a' e não ocupa espaço algum na memória ('a' ocupa, 'b' não). Mas, no exemplo abaixo:

O parâmetro 'x' é um ponteiro "maquiado", já que não precisamos usar a notação ou aritimética de ponteiros dentro da função quando é feita uma referência a 'x'.

Eu acho que, fora do contexto dos operadores sobrecarregados e do construtor de cópia, em C++, as referências causam mais confusão do que ajudam. Prefiro usar ponteiros.

[]s
Fred

Isso pode variar de acordo com o compilador, por exemplo, dado o seguinte código:


Compilando esse código com o VC++ 2010 em modo Debug e olhando ele em um disassembler você vai ver que a referencia e o ponteiro usam exatamente as mesmas instruções, porém em modo Release ele otimiza isso e passa a nem mesmo usar a referencia, alias, se você compilar apenas isso em Release ele remove todo esse código que não faz nada.

Referencias no C++ é o que chamam de "Syntatic Sugar", é um ponteiro que age como se não fosse um ponteiro, tudo por trabalho do compilador, e o melhor é que sempre que possível o compilador nem mesmo vai usar um ponteiro, otimizando o código.

Tem muita coisa implícita numa referência que um ponteiro não possui e por isso facilitam a vida:

1 - referências não podem ser null (a não ser com o uso de gambiarras) e tem que sempre serem inicializadas
2 - referências não podem ser modificadas
3 - Você não pode "deletar" uma referência

Isso implica em muita coisa, tipo:



Aqui fica claro que func sempre vai retornar uma referência para algo valido e que não é sua responsabilidade liberar essa memória.

Agora sim, referências sempre vão ocupar espaço, o mesmo que um ponteiro.



Referências não são apenas syntax sugar. Syntax sugar é algo que automatiza uma operação feita de outra maneira. Como o foreach do C#. Referências são uma extensão da linguagem, são quase como ponteiros, mas possuem restrições como as que mencionei que fazem total diferença e não tem como fazer outra forma.

Sobre otimizações, me modo release o compilador otimiza ponteiros também e se possível os remove. Mas como referências possuem muito mais restrições que ponteiros, certamente são mais simples de se otimizar.

T+

Um padrao cada vez mais utilizado (inclusive eh o padrao da Google) eh o de passar como parametros apenas referencias constantes (const A& a), nunca referencias simples.

A razao para isso eh: quando voce ve uma chamada de funcao como faz_algo(x), sem saber como funciona a funcao faz_algo, voce mais ou menos assume que essa nao alterara o valor de x (compare com faz_algo(&x)).

Ou seja, se A for um tipo grande, o padrao seria:

O mesmo serve para ponteiros....

Alias, sempre usar referências e const (a não ser em tipos primitivos que não vale o custo de passar por referência, se não for uma situação onde se deseja alterar o valor original). Só tirar o const quando não for possível e só usar ponteiros quando não houver outro jeito.

T+

O que eu quis dizer eh: Se for para tirar o const da referencia, use ponteiros. Mesmo que seja possivel fazer com referencias. Em outras palavras, sempre que usar referencias, use const.

Aqui esta o link para o padrao do Google (essa parte especifica): http://google-styleguide.googlecode.com ... _Arguments

Agora entendi o que quis dizer. Na verdade isso ajuda em algo que sempre me incomodou nas referências, que é o fato de você olhar uma chamada de função e nunca saber se o valor esta sendo passado por referência ou não.

Leandro, se for considerar o código gerado sem otimizações, então TODAS as variáveis são ponteiros "indiretos"... Por exemplo: Uma variável local:

Sem a otimização 'a' é referenciada provavelmente como:

Onde EBP é o ponteiro base para a pilha. Num código otimizado essa referência pode sumir, com o compilador usando um dos registradores para conter a variável durante o tempo de vida da função.

Isso também acontece com variáveis globais, onde a referência pode ser:

Aqui 'x' é o endereço da variável - um "ponteiro constante", por assim dizer...

Não é isso que eu quis dizer sobre aliases e ponteiros. Considero apenas o código otimizado para essa explicação.

Com isso eu concordo!

[]s
Fred