[Resolvido] passar um ponteiro por referencia...

[gRoOvE 0]

Estou tentando fazer uma pilha de forma dinâmica aqui, porém sem usar variáveis globais. Eu tenho que incrementar a posição do ponteiro *p dentro da função...já tentei de todas as formas mas só incrementa a posição do ponteiro dentro da função e não altera realmente como a passagem de argumentos por referência deveria fazer, acho que tenho que tratar como um ponteiro para ponteiro para conseguir incrementar a posição dentro da função né? Caraca, que confusão...hasiueasseseases

 

Segue o código:

 

#include <stdio.h>
#include <stdlib.h>

#define MAX 5

void menu();
void empilhar(int num, int** p, int* boP);
void desempilhar(int* p, int* toP);
void exibir(int* toP, int* p);

int main()
{
	
	int* p;
	int* toP;
	int* boP;
	int opcao = 0, num;

	if(!(p = (int*)malloc(MAX * sizeof(int))))
	{
		printf("\nMemoria Insuficiente!\n");
		return(1);
	}
	toP = p;
	boP = p + (MAX-1);

	do
	{	
		menu();
		printf("Digite uma opcao: ");
		scanf("%d%*c",&opcao);

		switch(opcao)
		{
			case 1:
				system("cls");
				printf("Digite um numero para entrar na pilha: ");
				scanf("%d%*c",&num);
				empilhar(num,&p,boP);
				break;
			case 2:
				system("cls");
				desempilhar(p,toP);
				break;
			case 3:
				system("cls");
				exibir(toP,p);
				break;
			case 4:
				printf("%d",*p);
				printf("%d",*p++);
				system("pause");
				exit(0);
			default:
				printf("Opcao Invalida!");
				break;
		}
	}while(opcao != 4);

	return 0;
}

void menu()
{
	printf("\n------------------------\n");
	printf("1 - Incluir na Pilha\n");
	printf("2 - Excluir da Pilha\n");
	printf("3 - Exibir Pilha\n");
	printf("4 - Sair\n\n");
}
void empilhar(int num, int** p, int* boP)
{
	if(*p > boP)
	{
		printf("Pilha Cheia!\n");
		return;
	}
	**p = num;

	**(p++);
}

void desempilhar(int* p, int* toP)
{
	if(p <= toP)
	{
		printf("Pilha Vazia!\n");
		return;
	}
	p--;
	printf("Elemento desempilhado: %d\n",*p);
}

void exibir(int* toP, int* p)
{
	for(int* i = toP; i<p; i++)
	{
		printf("%d\n",*(i));
	}
}

[VictorCacciari 42]

(edit: agora que li que você não consegue mudar o endereço do ponteiro *p, esquece o que eu digitei.

Desculpa)

 

não li o teu código agora (lerei hj a tarde), mas lembrei que eu tinha feito um exercício parecido sobre isso ha algum tempo, da uma olhada:

void proximo(int*);

int main()
{
int ptr[]={20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10};
int i;

	for (i=0; i<11; i++)
	proximo(ptr);



return 0;
}

void proximo(int *pt)
{
static int pos=0;

	printf("%x -> %d\n", (pt+pos), (*(pt + pos)));
	pos++;

/*
(pt + n) aponta para n endereços após pt
*(pt + n) pega o conteúdo do endereço apontado por (pt+n)
*/

}

[gRoOvE 0]

Victor eu to fazendo assim, mas não da certo...tipo incrementa dentro da função, mas retornar o endereço como se não tivesse sido incrementado...ai sempre fica gravando em cima do p[0] "/

 

void empilhar(int num, int* p, int* boP)
{
	if(p > boP)
	{
		printf("Pilha Cheia!\n");
		return;
	}
	*p = num;
	p++;
}

[VictorCacciari 42]

Cara, você nm pode mudar p permanentemente...

você declarou um Array com ele.

 

você precisa de um menbro "static" como eu mostrei ali em cima, e usar como "indicador".

Mas não tenho certeza, vou dar uma pesquisada sobre isso tbm

fiquei curioso..hahahaha

 

 

[]

[gRoOvE 0]

Hm, entendi...eu tava tentando mudar o endereço dele pra sempre né, tem que ter realmente uma variável pra guardar pra onde ele apontou pela última vez...o problema é que não queria usar variável global, é mais uma pra passar pras funções agora...e como tenho mais funções que precisarão saber a posição do ponteiro não tem como usar o "static"...

[VictorCacciari 42]

tenta declarar o seu array como static....

talvez de algum resultado, ou então, declare dois ponteiros da seguinte forma:

 

int *array; //seu array
int *ptr;
		
	   //no inicio, coloque o seu ponteiro "auxiliar" na mesma posição que o array, e faça as alterações conforme necessário, no ponteiro auxiliar
	  ptr = array;

é só uma idéia!

[gRoOvE 0]

Victor, se reparar no meu código ta feito isso...eu tenho um ponteiro que vai indiciar o topo da pilha, iniciado apontando pro mesmo endereço de p. Nessa situação o ponteiro p foi declarado pra percorrer a pilha, ele começa na primeira e posição e fica se movimentando, qual o problema de eu incrementar a posição dele? Ele começou apontando pra 0x00010, agora quero que ele aponte pro terceiro elemento 0x00018...o problema é fazer essa bedita incrementação dentro da função e retornar pra main o endereço certo "/

[VictorCacciari 42]

*Que burro, da zero pra eleee (pra mim....)*

esqueci de escrever o resto do ultimo post

UAEHUAEAEUHAE

 

Eu ia dizer pra você fazer as suas funções retornarem um *int.

 

por exemplo:

 

int main()
{
int *array; //seu array
int *ptr;
		
	   //no inicio, coloque o seu ponteiro "auxiliar" na mesma posição que o array, e faça as alterações conforme necessário, no ponteiro auxiliar
	  ptr = array;


	   //.... 
	  ptr = empilha(23, array, ptr);


}

int* empilhar(int num, int* arr, int* curr) //arr é o endereço do array, curr é o "current position"
{
	if((curr - arr) > MAX_ITEMS)
	{
		printf("Pilha Cheia!\n");
		return;
	}
	*curr = num;
	return curr++;
}

[gRoOvE 0]

Consegui fazer retornando, se alguém souber como fazer por referência se é que tem como, por favor poste ae :D

 

Agora não to conseguindo liberar a memória, to dando um free() antes de encerrar o programa, porque tá dando erro?

 

#include <stdio.h>
#include <stdlib.h>

#define MAX 5

void menu();
int* empilhar(int num, int* p, int* boP, int* toP);
int* desempilhar(int* p, int* toP);
void exibir(int* toP, int* p);

int main()
{
	
	int* p;
	int* toP;
	int* boP;
	int opcao = 0, num;

	if(!(p = (int*)malloc(MAX * sizeof(int))))
	{
		printf("\nMemoria Insuficiente!\n");
		return(1);
	}
	toP = p;
	boP = p + (MAX - 1);

	do
	{	
		menu();
		printf("Digite uma opcao: ");
		scanf("%d%*c",&opcao);

		switch(opcao)
		{
			case 1:
				system("cls");
				printf("Digite um numero para entrar na pilha: ");
				scanf("%d%*c",&num);
				p = empilhar(num,p,boP,toP);
				break;
			case 2:
				system("cls");
				p = desempilhar(p,toP);
				break;
			case 3:
				system("cls");
				exibir(toP,p);
				break;
			case 4:
				free(p);
				return(0);
			default:
				printf("Opcao Invalida!");
				break;
		}
	}while(opcao != 4);
	
	return 0;
}

void menu()
{
	printf("\n------------------------\n");
	printf("1 - Incluir na Pilha\n");
	printf("2 - Excluir da Pilha\n");
	printf("3 - Exibir Pilha\n");
	printf("4 - Sair\n\n");
}
int* empilhar(int num, int* p, int* boP, int* toP)
{
	if(p > boP)
	{
		printf("Pilha Cheia!\n");
		return(p);
	}
	*p = num;
	return(++p);
}

int* desempilhar(int* p, int* toP)
{
	if(p <= toP)
	{
		printf("Pilha Vazia!\n");
		return(p);
	}
	printf("Elemento desempilhado: %d\n",*(p-1));
	return(--p);
}

void exibir(int* toP, int* p)
{
	int* i;
	for(i = (--p); i>=(toP); i--)
	{
		printf("%d\n",*i);
	}
}

[VictorCacciari 42]

Aqui não deu erro não!

Compilou e rodou bunitinho!

 

Que compilador você ta usando?

Compilei com o gcc e correu tudo bonitinho!

(tanto em windows como em linux)

 

 

ps.:

Passagens por referencia não são nada mais do que passar endereços de memória, em C e no seu caso, resolveria-se passando um ponteiro para um ponteiro, assim:

void change(int*, int);
void changeAddr(int**, int*);
void show(int*);

int main()
{
int *ptr1;
int *ptr2;
int a, b;

ptr1 = &a;
ptr2 = &b;

change(ptr1, 30);
change(ptr2, 12);
printf("Valores e enderecos originais\n");

printf("*ptr1 = "); show(ptr1);
printf("*ptr2 = "); show(ptr2);

printf("Mudando o endereco de ptr1...\n*ptr1 = ");
changeAddr(&ptr1, (int*)&b);
show(ptr1);
}

void change(int *pt, int vl)
{
	(*pt) = vl;
}

void changeAddr(int** ini, int *alt)
{
	*ini = alt;
}

void show(int* pt)
{
	printf("%d\t[%X]\n", (*pt), pt);
}

[gRoOvE 0]

Sinceramente brother, eu tava tentando fazer assim ponteiro pra ponteiro mas não sei o que tava fazendo errado...agora arrumei e foi tudo certo, uso o Visual C++ 2008. Sabe se tem como confirmar se a memória foi liberada certo? Ahh, tava dando erro no free() pq coloquei um breakpoint nele e tava rodando no modo debug, só não entendi pq o erro "/

 

#include <stdio.h>
#include <stdlib.h>

#define MAX 5

void menu();
void empilhar(int num, int** p, int* boP, int* toP);
void desempilhar(int** p, int* toP);
void exibir(int* toP, int* p);

int main()
{
	
	int* p;
	int* toP;
	int* boP;
	int opcao = 0, num;

	if(!(p = (int*)malloc(MAX * sizeof(int))))
	{
		printf("\nMemoria Insuficiente!\n");
		return(1);
	}
	toP = p;
	boP = p + (MAX - 1);

	do
	{	
		menu();
		printf("Digite uma opcao: ");
		scanf("%d%*c",&opcao);

		switch(opcao)
		{
			case 1:
				system("cls");
				printf("Digite um numero para entrar na pilha: ");
				scanf("%d%*c",&num);
				empilhar(num,&p,boP,toP);
				break;
			case 2:
				system("cls");
				desempilhar(&p,toP);
				break;
			case 3:
				system("cls");
				exibir(toP,p);
				break;
			case 4:
				free(p);
				return(0);
			default:
				printf("Opcao Invalida!");
				break;
		}
	}while(opcao != 4);
	
	return 0;
}

void menu()
{
	printf("\n------------------------\n");
	printf("1 - Incluir na Pilha\n");
	printf("2 - Excluir da Pilha\n");
	printf("3 - Exibir Pilha\n");
	printf("4 - Sair\n\n");
}
void empilhar(int num, int** p, int* boP, int* toP)
{
	if(*p > boP)
	{
		printf("Pilha Cheia!\n");
		return;
	}
	**p = num;
	(*p)++;
}

void desempilhar(int** p, int* toP)
{
	if(*p <= toP)
	{
		printf("Pilha Vazia!\n");
		return;
	}
	printf("Elemento desempilhado: %d\n",*(*p-1));
	--(*p);
}

void exibir(int* toP, int* p)
{
	int* i;
	for(i = --p; i>=(toP); i--)
	{
		printf("%d\n",*i);
	}
}

[VictorCacciari 42]

o.O

que estranho dar erro em modo Debug...

Ai nós precisariamos de um debugger e um cara que soubesse muito assembly pra nos explicar o pq do erro...

 

Agora fico show o código!

=D

 

deu trabalho mas valeu a pena!

[gRoOvE 0]

melhor deixar pra lá o erro...aheausihiasuehase

Agora fico legal, certinho :D

Se puder dá uma ajuda pra eu acabar aquele do desafio lá :D

abraço!