Ir para o conteúdo
Leudassdf

Duvida-Mudar endereço de ponteiro

Mensagens Recomendadas

Leudassdf

Boas pessoal,

Eu gostaria de saber se é possível fazer o seguinte. Inicialmente tenho uma variável que aponta para um endereço de memoria.

O problema que tenho reside no facto de quando chamo uma função, essa consegue alterar o endereço apontado?

Vou tentar explicar por código no entanto saliento que o mesmo não está certo.

/* localtime example */
#include <stdio.h>	  /* puts, printf */
#include <time.h>	   /* time_t, struct tm, time, localtime */
#include <stdlib.h>
void teste( int *ptr)
{

   int *p=malloc(sizeof(int));
   *p=10;
   ptr=&p;
}
int main ()
{
   int i=0;
   int *test=&i;
 printf("%d\n",*test);
   teste(test);
   printf("%d",*test);
   return 0;
}

No segundo printf o valor que deveria ser mostrado seria 10. Pois supostamente o meu ponteiro test estaria a apontar para um outro endereço de memoria.

No entanto isso nao acontece. Quando a funcao teste termina a ponteiro teste aponta para o endereço de memoria de i.

NOTA:O objectivo nao é trabalhar com numero inteiros mas sim com estruturas...

Agradeço qualquer ajuda....

Cumprimentos,

Leandro

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

vou fazer um desenho do que estás a fazer para ver se percebes o que tens mal:

int main ()
{
                                   //  <variavel> | <pos. memória> | <valor>
   int i=0;                        //    i        | 0x40000000     | 0
   int *test=&i;                   //    test     | 0x40000004     | 0x40000000
   printf("%d\n",*test);           //    *test    | 0x40000000     | 0

//  teste(test/ptr);
   ptr = test                      //    ptr      | 0x60000000     | 0x40000004
   int *p=malloc(sizeof(int));     //    p        | 0x60000004     | 0x80000000
   *p=10;                          //    *p       | 0x80000000     | 10
   ptr=&p;                         //    ptr      | 0x60000000     | 0x60000004

   printf("%d",*test);             //    *test    | 0x40000000     | 0
   return 0;
}

por outras palavras o que fizeste dentro da função não altera nada nas variáveis "test" ou "i" ...


IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
Leudassdf

vou fazer um desenho do que estás a fazer para ver se percebes o que tens mal:

int main ()
{
								//  <variavel> | <pos. memória> | <valor>
int i=0;						//	i		| 0x40000000	 | 0
int *test=&i;				   //	test	 | 0x40000004	 | 0x40000000
printf("%d\n",*test);		   //	*test	| 0x40000000	 | 0

//  teste(test/ptr);
ptr = test					  //	ptr	  | 0x60000000	 | 0x40000004
int *p=malloc(sizeof(int));	 //	p		| 0x60000004	 | 0x80000000
*p=10;						  //	*p	   | 0x80000000	 | 10
ptr=&p;						 //	ptr	  | 0x60000000	 | 0x60000004

printf("%d",*test);			 //	*test	| 0x40000000	 | 0
return 0;
}

por outras palavras o que fizeste dentro da função não altera nada nas variáveis "test" ou "i" ...

Obrigado pelo desenho. Espero que não segundas intenções. :P

Eu percebi o que tinha mal. O que gostaria de saber é como posso alterar o ponteiro dentro da funcao teste.

Penso que através de um **, ponteiro para ponteiro, passado por argumento, resolvo o meu problema. No entanto existe alguma solução mais eficaz?

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

responde a estas duas questões :

- o que fazes quando queres alterar o valor de uma variável dentro de uma segunda função ?

- qual a diferença de um ponteiro e uma variável ?


IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
Leudassdf

responde a estas duas questões :

- o que fazes quando queres alterar o valor de uma variável dentro de uma segunda função ? Uma varivel como? do tipo ponteiro? Se sim, então, suponde ptr com o ponteiro *ptr=valor;

- qual a diferença de um ponteiro e uma variável ?Uma variável é uma posição na memoria que contem um determinado valor. Um ponteiro é um indicador que irá indicar "apontar" para um determinado endereço de memoria de uma varivel.

Acho que é mais ou menos isso não

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

- o que fazes quando queres alterar o valor de uma variável dentro de uma segunda função ?

exemplo:

int i = 10;
// como chamar uma função para alterar o valor de 'i' dentro dessa função ?

- qual a diferença de um ponteiro e uma variável ?

errado, não existe diferença nenhuma entre uma variável e um ponteiro. somente no processo de interpretação dos dados que cada um referência

Editado por HappyHippyHippo

IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
Leudassdf

exemplo:

int i = 10;
// como chamar uma função para alterar o valor de 'i' dentro dessa função ?

chamo funcao(&i);

Aquilo que eu queria fazer era isto:

Claro que para o tipo de dados inteiro não faz sentido. Mas isto é para adaptar a uma Estrutura e ai já me dá jeito.

/* localtime example */
#include <stdio.h>	  /* puts, printf */
#include <time.h>	   /* time_t, struct tm, time, localtime */
#include <stdlib.h>
void teste(int **ptr)
{
int *p = (int *)malloc(sizeof(int));
*ptr = p;
*(*ptr) = 100;
}
int main()
{
int *i = (int *)malloc(sizeof(int));
*i = 10;
int **test = (int **) malloc(sizeof(int **));
printf("Endereco de [i]:[%p].\n", i);
*test = i;
printf("Valor de [i]:[%d].\n", *i);
printf("Endereco de [teste]:[%p].\n",test);
printf("Endereco apontado por [teste]:[%p].\n", *test);
printf("Valor apontado por [teste]:[%d].\n",*(*test));
teste(test);
printf("\n\nDepois da invocacao de teste:\n\n");
printf("Endereco de [i]:[%p].\n", i);
printf("Valor de [i]:[%d].\n",*i);
printf("Endereco de [teste]:[%p].\n", test);
printf("Endereco apontado por [teste]:[%p].\n", *test);
printf("Valor apontado por [teste]:[%d].\n", *(*test));
getchar();
free(i);
free(*test);
*test = NULL;
free(test);
return 0;
}

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

- qual a diferença de um ponteiro e uma variável ?

não existe diferença nenhuma entre uma variável e um ponteiro

- o que fazes quando queres alterar o valor de uma variável dentro de uma segunda função ?

int i = 10;

chamo funcao(&i);

agora é só somar 2 mais 2 ...

Editado por HappyHippyHippo

IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
Leudassdf

- qual a diferença de um ponteiro e uma variável ?

não existe diferença nenhuma entre uma variável e um ponteiro

- o que fazes quando queres alterar o valor de uma variável dentro de uma segunda função ?

int i = 10;

chamo funcao(&i);

agora é só somar 2 mais 2 ...

eu sei o que tenho de fazer para alterar o valor da variavel.

Eu coloquei acima um exemplo do que queria fazer. Na prática nao é alterar o valor do ponteiro mas sim alterar o endereço que é apontado por esse ponteiro. Não sei se me fiz entender.

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

eu sei o que tenho de fazer para alterar o valor da variavel.

Eu coloquei acima um exemplo do que queria fazer. Na prática nao é alterar o valor do ponteiro mas sim alterar o endereço que é apontado por esse ponteiro. Não sei se me fiz entender.

ok ... estás a dizer que não sabes somar 2 mais 2 ... certo ?


IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

vamos então pegar na questão inicial:

O problema que tenho reside no facto de quando chamo uma função, essa consegue alterar o endereço apontado?

dado como exemplo o seguinte código (do qual já expliquei o porquê de estar errado) :

void teste( int *ptr) {
   int *p=malloc(sizeof(int));
   *p=10;
   ptr=&p;
}

int main () {
   int i=0;
   int *test=&i;
// ...
   teste(test);
// ...
   return 0;
}

depois perguntei :

- o que fazes quando queres alterar o valor de uma variável dentro de uma segunda função ?

ao qual tu respondeste correctamente:

chamo funcao(&i);

do qual eu presumo que percebes que para alterar o valor de uma variável dentro de uma outra função, o que necessitas é saber onde alterar o valor, sendo então necessário enviar para a função a posição de memória da variável a ser alterada.

no memso post, mas em segundo lugar, fiz a seguinte questão:

- qual a diferença de um ponteiro e uma variável ?

ao qual te respondi:

não existe diferença nenhuma entre uma variável e um ponteiro

o que assumindo a pergunta anterior, indica que um ponteiro não passa de uma variável.

e como tal, se queres alterar o valor dessa variável dentro de outra função, voltas a necessitar de saber onde alterar o valor.

conclusão, 2+2 =

void foo(int** ptr) {
   *ptr = malloc(sizeof(int));    // guardar a posição da memória reservada no ponteiro da função main
   **ptr = 20;                    // guardar o valor "20" na memória reservada
}

int main() {
   int i = 10;                    // criar uma variavel de controlo
   int* ptr = &i;                 // guardar no ponteiro a posição de memória da variável de controlo

   printf("valor : &d\n", *ptr);  // apresentar o valor de controlo : 10

   foo(&ptr);                     // chamar a função que irá alocar a memória e guardar no ponteiro "ptr" a posição de memória
   printf("valor : &d\n", *ptr);  // apresentar o valor guardado no memória reservada : 20

   free(ptr);                     // não esquecer de libertar a memória reservada dentro da função "foo"

   return 0;
}


IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
Leudassdf

vamos então pegar na questão inicial:

logo, o exemplo que coloquei acima está certo.

Editado por Leudassdf

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites
HappyHippyHippo

logo, o exemplo que coloquei acima está certo.

dado como exemplo o seguinte código (do qual já expliquei o porquê de estar errado) :

vou fazer um desenho do que estás a fazer para ver se percebes o que tens mal:

int main ()
{
                                   //  <variavel> | <pos. memória> | <valor>
   int i=0;                        //    i        | 0x40000000     | 0
   int *test=&i;                   //    test     | 0x40000004     | 0x40000000
   printf("%d\n",*test);           //    *test    | 0x40000000     | 0

//  teste(test/ptr);
   ptr = test                      //    ptr      | 0x60000000     | 0x40000004
   int *p=malloc(sizeof(int));     //    p        | 0x60000004     | 0x80000000
   *p=10;                          //    *p       | 0x80000000     | 10
   ptr=&p;                         //    ptr      | 0x60000000     | 0x60000004

   printf("%d",*test);             //    *test    | 0x40000000     | 0
   return 0;
}

por outras palavras o que fizeste dentro da função não altera nada nas variáveis "test" ou "i" ...


IRC : sim, é algo que ainda existe >> #p@p

Partilhar esta mensagem


Ligação para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!

Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.

Entrar Agora

×

Aviso Sobre Cookies

Ao usar este site você aceita os nossos Termos de Uso e Política de Privacidade. Este site usa cookies para disponibilizar funcionalidades personalizadas. Para mais informações visite esta página.