Estrutura e ponteiro do C

Neste tutorial, você aprenderá a usar ponteiros para acessar membros de estruturas em linguagem C. Você também aprenderá a alocar memória dinamicamente para tipos de estrutura.

Antes de entender como usar ponteiros com estruturas, certifique-se de ler o seguinte tutorial:

• Ponteiro do C

• Estrutura

Ponteiro para estrutura C

Este é o método de criação de ponteiros para estruturas.

struct name {
　　　　membro1;
　　　　membro2;
　　　　.
　　　　.
};
int main()
{
　　　　struct name　*ptr, Harry;
}

Aqui, ptr é um ponteiro para struct.

Exemplo: Acessar membros usando ponteiros

Para acessar os membros da estrutura usando ponteiros, usamos-operador.

#include　<stdio.h>
struct person
{
　　　int age;
　　　float weight;
};
int main()
{
　　　　struct person　*personPtr, person1;
　　　　personPtr = &person1;　　　
　　　　printf("Digite a idade: \t");
　　　　scanf("%d", &personPtr->age);
　　　　printf("Digite o peso: \t");
　　　　scanf("%f", &personPtr->weight);
　　　　printf("Exibir:\n");
　　　　printf("Idade: \t%d\n", personPtr->age);
　　　　printf("Peso:　%f",　personPtr)->weight);
　　　　return 0;
}

Resultados de saída

Insira idade:　25
Insira peso:　55
Exibir:
Idade:　25
Peso:　55.000000

Neste exemplo, use personPtr =＆person1;Armazene o person1endereço armazenado no ponteiro personPtr.

Agora, você pode usar o ponteiro personPtr para acessar person1membros.

A propósito,

• personPtr->age é equivalente a (*personPtr).age

• personPtr->weight é equivalente a (*personPtr).weight

Alocação dinâmica de memória de estruturas

Antes de continuar com esta seção, recomenda-se verificarAlocação dinâmica de memória C。

Às vezes, o número de variáveis struct declaradas pode não ser suficiente. Pode ser necessário alocar memória em tempo de execução. Este é um dos métodos que pode ser implementado em programação C.

Exemplo: alocação dinâmica de memória de estruturas

#include　<stdio.h>
#include　<stdlib.h>
struct person {
　　　int age;
　　　float weight;
　　　char name[30];
};
int main()
{
　　　struct person　*ptr;
　　　int i, n;
　　　printf("Insira o número de pessoas:　");
　　　scanf("%d",　&n);
　　　//Alocar memória para n structs person
　　　ptr = (struct person*) malloc(n　*　sizeof(struct person));
　　　for(i = 0;　i < n;　++i)
　　　{
　　　　　　　printf("Insira nome e idade:　");
　　　　　　　　　//Para acessar o membro do primeiro struct person,
　　　　　　　　　//Pode usar ptr->name e ptr->age
　　　　　　　　//Para acessar o membro do segundo struct person,
　　　　　　　　//Usando (ptr　+　1）->Nome e (ptr　+　1）->　age
　　　　　　　scanf("%s　%d",　(ptr+i)->name,　&(ptr+i)->age);
　　　}
　　　printf("Exibir informações:\n");
　　　for(i = 0;　i < n;　++i)
　　　　　　　printf("Nome:　%s	idade:　%d\n",　(ptr+i)->name,　(ptr+i)->age);
　　　return 0;
}

Quando o programa é executado, a saída é:

Insira o número de pessoas:　　2
Insira nome e idade:　　Harry　24
Insira nome e idade:　　Gary　32
Exibir informações:
Nome:　Harry	idade:　24
Nome:　Gary	idade:　32

No exemplo acima, foram criados n variáveis struct no lugar da entrada do usuário n.

Para alocar memória para n structs person, usamos,

ptr = (struct person*) malloc(n　*　sizeof(struct person));

Então, usamos o ponteiro ptr para acessar os elementos de person.