Ponteiro para ponteiro

[GRSa]

Hello guys.

Na prática, qual a serventia de um ponteiro para um ponteiro? Existe algum exemplo em que a aplicação do recurso traz alguma vantagem?

main(){
int value = 100;
int *pointer = &value;
int **pointerToPointer = &pointer; //Aqui está um ponteiro de ponteiro
}

Edited April 7, 2015 at 01:41 AM by GRSa

[HappyHippyHippo]

se as coisas que aprendes não parecem ter utilizade é porque ainda não te deparaste com nenhuma situação para a utilizar, isto porque tudo tem a sua utilidade.

o mesmo poderia perguntar qual a utilidade de:

int* (**pt)[]; // um ponteiro para um ponteiro para um array de ponteiros para inteiros

é estranho, mas não quer dizerque nunca ninguem tenha utilizado ou venha a necessitar.

agora, para o caso que perguntas (ponteiro para ponteiro), é muito habitual ser utilizado. eu, por exemplo, estou sempre a utilizar na geração de ADO's (Abstract Data Objects)

exemplo:

// ponto.h
typedef struct Ponto Ponto; // estrutura opaca (não é possivel saber os dados da estrutura directamente fora do .c onde vai ser declarada)

Ponto* ponto_create(int x, int y);
int    ponto_destroy(Ponto** ponto); // <--- ponteiro para ponteiro (consegues saber porque faço assim ?)
int    ponto_get_x(Ponto* ponto, int* x);
int    ponto_get_y(Ponto* ponto, int* x);
int    ponto_set(Ponto* ponto, int x, int y);

// ponto.c
// ponto.c
struct Ponto {
 int x;
 int y;
}

Ponto* ponto_create(int x, int y) {
Ponto* ponto;

if ((ponto = malloc(sizeof(Ponto))) != NULL) {
	ponto->x = x;
	ponto->y = y;
}

return ponto;
}

int ponto_destroy(Ponto** ponto) {
if (!ponto || !*ponto)
	return -1;

free(*ponto);
*ponto = NULL;

return 0;
}

int ponto_get_x(Ponto* ponto, int* x) {
if (!ponto || !x)
	return -1;

*x = ponto->x;

return 0;
}

int ponto_get_y(Ponto* ponto, int* x) {
if (!ponto || !y)
	return -1;

*y = ponto->y;

return 0;
}

int ponto_set(Ponto* ponto, int x, int y) {
if (!ponto)
	return -1;

ponto->x = x;
ponto->y = y;

return 0;
}

isto é um exemplo muito simples, porque o que não faltam são situações onde o uso de ponteiro para ponteiro é algo utilizado ...

[GRSa]

HappyHippyHippo, estive a construir um arithmetic parser e enfim acabei por esbarrar na necessidade de usar um ponteiro para ponteiro. A seguinte função realiza o popping de um nodo de uma pilha. A função retorna o nodo extraído e altera o endereço armazenado pelo ponteiro submetido como parâmetro na chamada da função. Não poderia alterar o endereço armazenado por este ponteiro para ser acessível fora da função, não fosse o uso de ponteiro para ponteiro.

/*
It pops the first node from the stack and returns it.
*/
struct T_Token_Node *popFromTokenNodeStack(struct T_Token_Node **firstTokenNode){
struct T_Token_Node *nodePopped;
if (firstTokenNode != NULL){
 nodePopped = *firstTokenNode;
 *firstTokenNode = nodePopped->associated;
} else {
 nodePopped = NULL;
}
return nodePopped;
};

popFromTokenNodeStack(&lastOperatorStackTokenNode); //Chamada da função

Edited July 31, 2015 at 11:17 AM by GRSa