Duvida teorica

Say · 2 de maio de 2010

Galera estou estudando listas, pilhas e filas.

Eu sei usar um pouco o seguinte termo "->" mas não sei ao certo seu significado.

Alguém poderia me explicar um pouco como esse termo funciona?

obrigado

dontpanic · 2 de maio de 2010


struct teste {
   int x;
   int y;
};

struct teste UmTeste;

Com isso você criou uma variável chamada "UmTeste" do tipo "struct teste". Essa parte você já deve saber.


UmTeste.x = 0;
UmTeste.y = 2;

Pra acessar os membros da variável UmTeste você usa um ponto (.)

Isso você já deve saber também.

Agora criando uma variável dinamica.


typedef struct teste {
   int x;
   int y;
} Teste;

Teste *UmTeste;
UmTeste = (Teste) malloc(sizeof(Teste));

Se usar c++ em vez de c, é só trocar malloc por new.

Agora, pra acessar os campos dessa estrutura você usa um ponto, e como ela é um ponteiro você precisa colocar o asterisco na frente e parenteses pra delimitar o que é ponteiro e o que é campo da estrutura. Ficando assim:


(*UmTeste).x = 0;
(*UmTeste).y = 123;

Então, considerando isso tudo agora... o "->" é nada mais que um atalho pra você não precisar escrever esse monte de parenteses e asteriscos sempre que for acessar os campos de um ponteiro de estrutura.

Ou seja, o código abaixo é exatamente a mesma coisa do de cima:


UmTeste->x = 0;
UmTeste->y = 123;

É isso.

Say · 4 de maio de 2010

Galera, já terminei o estudo do assunto mas tem duas coisas que não me sinto seguro(meio que decorei), se alguém puder me ajudar fico muito agradecido.

Uma parte da estrutra :

struct Celula {

float valor_;

Celula* prox_; //O que quer dizer isto especificadamente??? Um ponteiro tipo Celula ??

Celula(float valor, Celula* prox);

};

Uma parte do código esta assim:

if (base_->prox_->prox_ == NULL)

interpretanto: (*base_).(*prox_).prox_== NULL

Estou batendo cabeça com este termo faz tempo mas isto esta intrigante.

(*prox_).prox_ estou acessando uma variavel prox_ dentro de uma estrutura prox_

(*base_).prox_ estou acessando uma variavel base dentro de uma estrutura prox_

mas ligando as duas coisas fica sem sentido.

Alguém me da uma luz aí

dontpanic · 4 de maio de 2010

Parece meio estranho e dá um pouco nó na cabeça, mas é só você interpretar do mesmo jeito que você lê. A estrutura celula possui duas variáveis, uma delas é um float, a outra é um ponteiro pra outra estrutura do tipo celula.


  ---------
|         | (valor) ---> 12.3
| CelulaA |               ---------
|         | (prox) ----> |         | (valor) ---> 55.5
 ---------               | CelulaB |               ---------
                         |         | (prox) ----> |         | (valor) -->
                          ---------               | CelulaC |
                                                  |         | (prox) --->
                                                   ---------

Então, se você tiver tres variáveis ponteiro do tipo celula:

Celula *CelulaA;

Celula *CelulaB;

Celula *CelulaC;

Depois em algum ponto do código você declarou que:

CelulaA->prox = CelulaB;

e

CelulaB->prox = CelulaC;

Então a expressão "CelulaA->prox->prox" faz isso:

(CelulaA->prox)->prox

A parte entre parenteses corresponde a "CelulaB", ou seja, o endereço de celulaB. Então fica:

(CelulaB)->prox