Na linguagem C usamos as
estruturas para definir uma variável composta, como a declaração de um registro
em algoritmos. A definição das estruturas em C se dá através do comando
“struct”. Abaixo segue a forma de declaração e um exemplo de criação de uma estrutura:
Declaração:
struct nome-estrutura {
declaração dos membros
} definição de variáveis
(opcional);
Exemplo:
struct nome {
int idNome;
char nomePessoa[40];
};
Neste exemplo, estamos criando um
registro chamado de nome com os campos idNome, do tipo int, e nomePessoa do
tipo char.
Toda a vez que criarmos uma
struct, devemos criar uma variável do tipo dela. Ou seja, ao criarmos uma
struct é como se tivéssemos criando um tipo especial de variável, na verdade
definindo um tipo, e não criando uma variável. Vejamos isso com o exemplo:
struct nome {
int idNome;
char nomePessoa[40];
};
struct nome pessoa;
No exemplo acima, declaramos uma
struct nome e uma variável chamada de “pessoa” do tipo nome.
Uma vez declarada a struct , é
criada uma variável deste tipo (“struct nome pessoa”), lembrando que a criação
da struct deve ser feita antes da função principal main() e a declaração da
variável struct dentro de main(), podemos manipular valores fazendo referência
à struct e no campo no qual desejamos trabalhar, vejamos o exemplo:
pessoa.idNome = 20;
pessoa.nomePessoa = “Antônio Carlos”;
Assim, sempre usamos o nome
seguido do ponto e o campo do registro o qual queremos manipular. Podemos criar
diversas variáveis do tipo struct. Vejamos:
struct nome {
int idNome;
char nomePessoa[40];
};
struct nome pessoa1; struct nome
pessoa2; struct nome pessoaN;
Todas as variáveis declaradas
acima (“pesoa1”, “pessoa2”, “pessoaN”) são do tipo struct definido
anteriormente. A declaração das
variáveis também pode ser feita da seguinte maneira: struct nome {
int idNome;
char nomePessoa[40];
}; pessoa1, pessoa2, pessoaN;
Dessa forma, também podemos criar
vetores de struct e assim termos um conjunto de registros para trabalhar.
Vejamos o exemplo abaixo:
#include <stdio.h> #include
<stdlib.h>
//definição de uma estrutura tipo
registro
struct cadastro {
int idnome; char nome[20];
};
int main () {
//defino um vetor com 3 posições
que chamaremos de cad do tipo registrado definido acima
struct cadastro cad[2]; int i;
//inserindo dados no cadastro
pessoa for (i=0; i<3; i++){
cad[i].idnome=i;
printf("entre com o %d nome
para cadastrar \n", i+1); scanf("%s", &cad[i].nome);
}
//escrevendo os dados do registro
for (i=0; i<3; i++){
printf("\n %d, %s \n",
cad[i].idnome, cad[i].nome);
}
system("pause"); return
0;
}
Observe que na declaração “struct
cadastro cad[2];” estamos definindo um conjunto de 3 registros para
trabalharmos, do tipo estrutura cadastro, definido anteriormente. Perceba que,
para trabalharmos com a variável vetor de struct cad[], temos de fazer
referência da seguinte forma: nome_da_variavel[posição]. nome_do_campo.
É comum usarmos uma espécie de
atalho em C para definirmos um tipo de variável, e o comando typedef
faz isso. Seu uso permite criar
um apelido para o tipo da struct diretamente, por exemplo: typedef struct {
int idNome;
char nomePessoa[40];
} nome;
nome pessoa1; nome pessoa2;
Também podemos passar uma struct
para uma função, desde que o parâmetro da mesma seja do mesmo tipo struct.
Vejamos o exemplo:
#include <stdio.h> #include
<stdlib.h>
//definição de uma estrada tipo
registro
typedef struct {
int idnome; char nome[20];
} CAD;
void escrevestruct (CAD dados);
int main () {
CAD cad = {144,
"fulaninho"}; escrevestruct(cad); system("pause");
return 0;
}
void escrevestruct (CAD dados){
printf("\n %d, %s \n",
dados.idnome, dados.nome);
}
Neste exemplo, definimos uma
struct CAD, iniciamos uma variável do tipo struct “cad” e atribuímos valores a
ela (semelhante à atribuição de valores em um vetor), depois a enviamos seu
valor para uma função que também tem uma variável do mesmo tipo da struct
definida para então imprimirmos o valor desta na tela.
No exemplo abaixo, passaremos um
vetor de struct para uma função. Observe: #include <stdio.h>
#include <stdlib.h>
//definição de uma estrutura tipo
registro
typedef struct {
int idnome; char nome[20];
} CAD;
void escrevestruct (CAD *dados);
int main() {
//defino um vetor com 3 posições
que chamaremos de cad no tipo registro definido acima
CAD cad[2]; int i;
//inserindo dados no cadastro
pessoa for (i=0; i<3; i++){
cad[i].idnome=i;
printf("entre com o %d nome
para cadastrar \n", i+1); scanf("%s", &cad[i].nome);
}
//Passando o vetor struct
escrevestruct(cad); system("pause");
return 0;
}
//Recebe o endereço de memória do
vetor do struct void escrevestruct (CAD *dados){
int x;
for(x=0; x<3; x++){
printf("\n %d, %s \n",
dados[x].idnome, dados[x].nome);
}
}
O detalhe está na passagem de
parâmetro para a função, que acontece normalmente. Porém, a função receberá o
endereço de memória do tipo struct e assim trabalhará normalmente com os
valores.
Vejam como é a inserção de dados
com o ponteiro, que segue a mesma lógica do qual já vimos aqui anteriormente.
No exemplo abaixo, veremos a passagem de parâmetro para duas funções, uma para
inserir os dados e outra para escrever os dados. Vejamos como fica:
#include <stdio.h> #include
<stdlib.h>
//definição de uma estrutura tipo
registro
typedef struct {
int idnome;
} CAD;
char nome[20];
void dadosestruct (CAD *dados);
void escrevestruct (CAD *dados); int main() {
//defino um vetor com 3 posições
que chamaremos de cad no tipo registro definido acima
CAD cad[2];
//inserindo dados no cadastro
pessoa dadosestruct(cad);
//Passando o vetor struct
escrevestruct(cad); system("pause");
return 0;
}
//Recebe o endereço de memória do
vetor de struct para inserção de dados void dadosestruct (CAD *dados){
int i;
for (i=0; i<3; i++){
dados[i].idnome=i;
printf("entre com o %d nome
para cadastrar \n", i+1); scanf("%s", &dados[i].nome);
}
}
//Recebe o endereço de memória do
vetor de struct para mostrar de dados void escrevestruct (CAD *dados){
int x;
for(x=0; x<3; x++){
printf("\n %d, %s \n",
dados[x].idnome, dados[x].nome);
}
}
Fonte: Linguagem da programação I, UFERSA, Macedo, Luiz