C Alocação Dinâmica em C

[blvsman]

Olá, estou tendo dificuldades para alocar um ponteiro que está definido numa struct. Tenho que calcular a área de um polígono utilizando essas structs. O problema que estou tendo é:

 

O campo vertices do registro poligono, que deve receber um vetor com as coordenadas dos vertices do polıgono no sentido anti-horario, deve ser alocado dinamicamente, exatamente do tamanho necessario.

 

Só que não estou conseguindo fazer isso. Não estou sabendo associar alocação dinâmica com a struct.

struct ponto{
	float x; // coordenada x
 	float y; // coordenada y
};

struct poligono{
	int N; // numero de vertices
	struct ponto *vertices // ponteiro para o vetor de vertices
};

 

[arfneto]

provavelmente o que você quer fazer é acessar os vértices como um vetor, como argv[1], argv[2] .. argv[N] certo?

 

[blvsman]

@arfneto  Sim ! Para que eu possa fazer os cálculos futuramente dentro de um for.

[arfneto]

Pense como no caso de main()

 

O protótipo de main é 
 

    int main( int argc, char** argv);

para um efeito como o que você quer. Mas declarou

struct poligono{
	int N; // numero de vertices
	struct ponto *vertices // ponteiro para o vetor de vertices
};

Então vertices aponta para uma única estrutura. Nem deveria estar no plural  

 

Recomendo sempre --- sem querer entrar em discussões religiosas aqui --- declarar o tipo precisamente e não usar * nas variáveis. Pense nisso: formalmente você quer declarar um vértice e o vértice é do tipo ponteiro para struct ponto e assim:

struct ponto*        vertices;

é mais real que assim

    struct ponto        *vertices;

a variável é vertices. *vertices não é uma variável.

 

De volta ao problema:

 

você quer declarar uma série de ponteiros para vertice e então está errado assim. 

 

vertice deve apontar para uma série de ponteiros para pontos, um depois do outro.

 

Compare com esse trecho

typedef struct
{
	float x; // coordenada x
	float y; // coordenada y
}	Ponto;

typedef struct
{
	int     N;			// numero de vertices
	Ponto** vertices;   // ponteiro para o vetor de vertices
}	Poligono;

Entende a diferença?

 

 

 

adicionado 0 minutos depois

E agora o plural é que está errado  

adicionado 19 minutos depois

Entendeu melhor?

[blvsman]

@arfneto acho que entendi, mas como isso iria me ajudar a criar o vetor da struct ponto ? 

[arfneto]

16 minutos atrás, blvsman disse:

acho que entendi, mas como isso iria me ajudar a criar o vetor da struct ponto ? 

 

Como assim? Essa é a declaração da estrutura. Nada mais.

typedef struct
{
	float x; // coordenada x
	float y; // coordenada y
}	Ponto;

Ponto é assim, digamos. E

typedef struct
{
	int     N;         // numero de vertices
	Ponto** vertice;   // vertice[0] a vertice[N] apontam para
                       // um vertice...
}	Poligono;

O polígono é assim. Tem N vértices, que vão corresponder a N ponteiros logo abaixo, 

    vertice[0], vertice[1], ... vertice[N]

Não é o que quer? Exatamente como o sistema faz com argv[]?

 

Não é que isso vai te ajudar. Isso é a declaração.

 

Quanto aos pontos, pode usar por exemplo 

    Ponto teste;
    Ponto lista[10];
    lista[5].x = 12.3f;

Não sei de onde você vai obter os vértices

[arfneto]

typedef struct
{
	float x; // coordenada x
	float y; // coordenada y
}	Ponto;

typedef struct
{
	int     N;  // numero de vertices
	Ponto** v;  // ponteiro para os ponteiros para vertices
}	PlanoA;

typedef struct
{
	int     N;  // numero de vertices
	Ponto   v[];// ponteiro para um vetor de vertices
}	PlanoB;

A bem da verdade também pode declarar como no planoB acima, mas é menos flexível. E incomum, Nunca vi na verdade.

 

Isso só se usa em listas de parâmetros de funções e em geral em programas de escola apenas. Os profissionais preferem o uso mais flexível e a notação usando ponteiros ao invés de colchetes [ ] e índices.

 

Mas é perfeitamente possível. E mais próximo do que você quer fazer.

 

Isso é como um formulário, e você vai preencher. Com memória. Alocando espaço para as variáveis.

 

Usando o PlanoB você não pode sequer declarar uma variável desse tipo. Apenas ponteiros. No caso do PlanoA pode.