Tutorial Básico de Linguagem C

Controle de Fluxo de Linguagem C

Funções do C

Matrizes do C

Ponteiros do C

Strings no C

Estruturas de Linguagem C

Arquivos de Linguagem C

Outros C

Manual de Referência do C

Biblioteca Padrão <assert.h> do C gets() e puts() no C

Estrutura struct no C

Neste tutorial, você aprenderá sobre os tipos de estrutura no C. Você aprenderá a definir e usar estruturas com exemplos.

No desenvolvimento de programas em C, às vezes é necessário armazenar várias propriedades de entidades. A entidade não precisa ter todas as informações de um tipo. Pode ter diferentes atributos de diferentes tipos de dados.

Arrays de C permitem definir variáveis que podem armazenar itens do mesmo tipo de dados.estruturaé outro tipo de dados personalizado disponível em C, que permite armazenar itens de diferentes tipos de dados.

A estrutura é usada para representar um registro, supondo que você queira rastrear a dinâmica dos livros em uma biblioteca, você pode precisar rastrear as seguintes propriedades de cada livro:

Título
Autor
Tema
ID do livro

definir estrutura

Para definir uma estrutura, você deve usar struct palavra-chave. A declaração struct define um novo tipo de dados que contém vários membros, e o formato da declaração struct é o seguinte:

struct　tag　{　
　　　　membro-list
　　　　membro-list　
　　　　membro-list　　
　　　　...
}　variable-lista　;

tag é uma etiqueta de estrutura.

membro-list é uma definição de variável padrão, como int i; ou float f, ou outras definições de variáveis válidas.

variable-list Variáveis de estrutura, definidas no final da estrutura, antes do último ponto e vírgula, você pode especificar uma ou mais variáveis de estrutura. Abaixo está a forma de declarar a estrutura Book:

struct Books
{
　　　char title[50];
　　　char author[50];
　　　char subject[100];
　　　int book_id;
} book;

Em geral,tag, member-list, variable-list isto 3 pelo menos uma parte deve aparecer 2 pontos. Abaixo está um exemplo:

//Essa declaração declara uma estrutura com3membros, respectivamente, inteiros a, caracteres b e doubles c
//E declarou a variável da estrutura s1
//Essa estrutura não especifica seu rótulo
struct　
{
　　　　int a;
　　　　char b;
　　　　double c;
} s1;
　
//Essa declaração declara uma estrutura com3membros, respectivamente, inteiros a, caracteres b e doubles c
//O rótulo da estrutura é chamado SIMPLE, não há declaração de variável
struct SIMPLE
{
　　　　int a;
　　　　char b;
　　　　double c;
};
//Estrutura com rótulo SIMPLE, outra declaração de variável t1、t2、t3
struct SIMPLE t1, t2[20],　*t3;
　
//Também pode usar typedef para criar novos tipos
typedef struct
{
　　　　int a;
　　　　char b;
　　　　double c;　
} Simple2;
//Agora pode usar Simple2Para declarar uma nova estrutura de tipo
Simple2　u1, u2[20],　*u3;

No exemplo acima, as primeiras duas declarações são tratadas pelo compilador como tipos completamente diferentes, mesmo que suas listas de membros sejam iguais, se o comando t3=&s1é ilegal.

Os membros da estrutura podem conter outras estruturas, bem como ponteiros para o tipo da própria estrutura, e geralmente a aplicação desses ponteiros é para implementar estruturas de dados mais avançadas, como listas e árvores, etc.

//A declaração dessa estrutura contém outras estruturas
struct COMPLEX
{
　　　　char string[100];
　　　　struct SIMPLE a;
};
　
//A declaração dessa estrutura contém um ponteiro para o tipo dela mesma
struct NODE
{
　　　　char string[100];
　　　　struct NODE　*next_node;
};

Se duas estruturas se referirem mutuamente, é necessário declarar uma delas de forma incompleta, conforme exemplo a seguir:

struct B;　　　　//Para estruturas que se referem mutuamente, é necessário declarar uma delas de forma incompleta, conforme mostrado a seguir:
　
//A estrutura A contém um ponteiro para a estrutura B
struct A
{
　　　　struct B　*partner;
　　　　//other members;
};
　
//A estrutura B contém um ponteiro para a estrutura A, que é declarada após a A ser declarada, a B também é declarada
struct B
{
　　　　struct A　*partner;
　　　　//other members;
};

Inicialização de variáveis de estruturas

Como outras variáveis de tipos, para variáveis de estruturas, é possível especificar valores iniciais na definição.

Exemplo

#include <stdio.h>
　
struct Books
{
　　　char title[50];
　　　char author[50];
　　　char subject[100];
　　　int book_id;
} book = {"Linguagem C", "w3codebox", "Linguagem de programação",　123456};
　
int main();
{
　　　　printf("Nome do livro：%s\nAutor：%s\nTema：%s\nID do livro：%d\n", book.title, book.author, book.subject, book.book_id);
}

O resultado da execução é:

Título: Linguagem de Programação C
Autor: w3codebox
Tópico: Linguagem de Programação
BookID　123456

Acesso aos membros da estrutura

Para acessar os membros da estrutura, usamosOperador de acesso a membro (.).operador de acesso a membro é um ponto entre o nome da variável da estrutura e o membro da estrutura que queremos acessar. Você pode usar struct Palavras-chave para definir variáveis do tipo estrutura. O exemplo a seguir demonstra o uso da estrutura:

Exemplo

#include <stdio.h>
#include <string.h>
　
struct Books
{
　　　char title[50];
　　　char author[50];
　　　char subject[100];
　　　int book_id;
};
　
int main( )
{
　　　struct Books Book1;　　　　　　　　/*　declaração Book1，do tipo Books　*/
　　　struct Books Book2;　　　　　　　　/*　declaração Book2，do tipo Books　*/
　
　　　/*　Book1　detalhamento　*/
　　　strcpy( Book1.title, "Linguagem de Programação C");
　　　strcpy( Book1.author, "Nuha Ali");　
　　　strcpy( Book1.subject, "Tutorial de Linguagem de Programação C");
　　　Book1.book_id =　6495407;
　
　　　/*　Book2　detalhamento　*/
　　　strcpy( Book2.title, "Linguagem de Programação JAVA");
　　　strcpy( Book2.author, "Seagull Ali");
　　　strcpy( Book2.subject, "Tutorial de Linguagem de Programação JAVA");
　　　Book2.book_id =　6495700;
　
　　　/*　Saída Book1　informações　*/
　　　printf("Book　1　Título: %s\n", Book1.title);
　　　printf("Book　1　Autor: %s\n", Book1.author);
　　　printf("Book　1　Tópico: %s\n", Book1.subject);
　　　printf("Book　1　Número: %d\n", Book1.book_id);
　
　　　/*　Saída Book2　informações　*/
　　　printf("Book　2　Título: %s\n", Book2.title);
　　　printf("Book　2　Autor: %s\n", Book2.author);
　　　printf("Book　2　Tópico: %s\n", Book2.subject);
　　　printf("Book　2　Número: %d\n", Book2.book_id);
　
　　　return 0;
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Book　1　Título: Linguagem de Programação C
Book　1　Autor: Nuha Ali
Book　1　Tópico: Tutorial de Linguagem de Programação C
Book　1　Número:　6495407
Book　2　Título: Linguagem de Programação JAVA
Book　2　Autor: Seagull Ali
Book　2　Tópico: Tutorial de Linguagem de Programação JAVA
Book　2　Número:　6495700

Estrutura como parâmetro de função

Você pode passar a estrutura como parâmetro de função, da mesma forma que outros tipos de variáveis ou ponteiros. Você pode usar o método do exemplo acima para acessar a variável da estrutura:

Exemplo

#include <stdio.h>
#include <string.h>
　
struct Books
{
　　　char title[50];
　　　char author[50];
　　　char subject[100];
　　　int book_id;
};
　
/*　declaração de função　*/
void printBook(struct Books book);
int main( )
{
　　　struct Books Book1;　　　　　　　　/*　declaração Book1，do tipo Books　*/
　　　struct Books Book2;　　　　　　　　/*　declaração Book2，do tipo Books　*/
　
　　　/*　Book1　detalhamento　*/
　　　strcpy( Book1.title, "Linguagem de Programação C");
　　　strcpy( Book1.author, "Nuha Ali");　
　　　strcpy( Book1.subject, "Tutorial de Linguagem de Programação C");
　　　Book1.book_id =　6495407;
　
　　　/*　Book2　detalhamento　*/
　　　strcpy( Book2.title, "Linguagem de Programação JAVA");
　　　strcpy( Book2.author, "Seagull Ali");
　　　strcpy( Book2.subject, "Tutorial de Linguagem de Programação JAVA");
　　　Book2.book_id =　6495700;
　
　　　/*　Saída Book1　informações　*/
　　　printBook(Book1　);
　
　　　/*　Saída Book2　informações　*/
　　　printBook(Book2　);
　
　　　return 0;
}
void printBook(struct Books book)
{
　　　printf("Book título: %s\n", book.title);
　　　printf("Book autor: %s\n", book.author);
　　　printf("Book tópico: %s\n", book.subject);
　　　printf("Book número: %d\n", book.book_id);
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Book Título: Linguagem de Programação C
Book Autor: Nuha Ali
Book Tema: Tutorial de Linguagem de Programação C
Book Número:　6495407
Book Título: Linguagem de Programação JAVA
Book Autor: Seagull Ali
Book Tema: Tutorial de Linguagem de Programação JAVA
Book Número:　6495700

Ponteiro para estrutura

Você pode definir um ponteiro para a estrutura da mesma forma que define um ponteiro para outro tipo de variável, conforme mostrado a seguir:

struct Books　*struct_pointer;

Agora, você pode armazenar o endereço da variável da estrutura no variável de ponteiro definida acima. Para encontrar o endereço da variável da estrutura, coloque o operador & na frente do nome da estrutura, conforme mostrado a seguir:

struct_pointer = &Book1;

Para acessar os membros da estrutura usando um ponteiro para a estrutura, você deve usar -operadores, conforme mostrado a seguir:

struct_pointer-title;

Vamos usar um ponteiro de estrutura para reescrever o exemplo acima, o que ajudará a entender o conceito de ponteiros de estrutura:

Exemplo

#include <stdio.h>
#include <string.h>
　
struct Books
{
　　　char title[50];
　　　char author[50];
　　　char subject[100];
　　　int book_id;
};
　
/*　declaração de função　*/
void printBook( struct Books　*book　);
int main( )
{
　　　struct Books Book1;　　　　　　　　/*　declaração Book1，do tipo Books　*/
　　　struct Books Book2;　　　　　　　　/*　declaração Book2，do tipo Books　*/
　
　　　/*　Book1　detalhamento　*/
　　　strcpy( Book1.title, "Linguagem de Programação C");
　　　strcpy( Book1.author, "Nuha Ali");　
　　　strcpy( Book1.subject, "Tutorial de Linguagem de Programação C");
　　　Book1.book_id =　6495407;
　
　　　/*　Book2　detalhamento　*/
　　　strcpy( Book2.title, "Linguagem de Programação JAVA");
　　　strcpy( Book2.author, "Seagull Ali");
　　　strcpy( Book2.subject, "Tutorial de Linguagem de Programação JAVA");
　　　Book2.book_id =　6495700;
　
　　　/*　através da transmissão de Book1　do endereço para exibir Book1　informações　*/
　　　printBook( &Book1　);
　
　　　/*　através da transmissão de Book2　do endereço para exibir Book2　informações　*/
　　　printBook( &Book2　);
　
　　　return 0;
}
void printBook( struct Books　*book　)
{
　　　printf( "Book Título: %s\n", book->title);
　　　printf( "Book Autor: %s\n", book->author);
　　　printf( "Book Tema: %s\n", book->subject);
　　　printf( "Book Número: %d\n", book->book_id);
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Book Título: Linguagem de Programação C
Book Autor: Nuha Ali
Book Tema: Tutorial de Linguagem de Programação C
Book Número:　6495407
Book Título: Linguagem de Programação JAVA
Book Autor: Seagull Ali
Book Tema: Tutorial de Linguagem de Programação JAVA
Book Número:　6495700

campo de bits

Alguns informações, ao armazenar, não precisam ocupar um byte completo, mas apenas alguns ou um bit binário. Por exemplo, ao armazenar um valor de chave, há apenas 0 e 1 dois estados, usando 1 Os bits binários são suficiente. Para economizar espaço de armazenamento e tornar o processamento mais simples, o C oferece uma estrutura de dados chamada "campo de bits" ou "segmento de bits".

O que se chama de "campo de bits" é dividir os bits de um byte em várias diferentes áreas e explicar o número de bits de cada área. Cada campo tem um nome de campo, que permite operar com o nome do campo no programa. Dessa forma, vários objetos diferentes podem ser representados por um campo de bits binário de um byte.

Exemplo típico: }}

usar 1 Quando um campo de bits armazena um valor de chave, apenas 0 e 1 dois estados.
Leitura de formatos de arquivos externos - pode ler formatos de arquivos não padrão. Por exemplo:9 do inteiro.

Definição e descrição dos campos de bits

A definição de campos de bits é semelhante à definição de estruturas, e sua forma é:

struct Nome_da_strutura_de_campos_de_bits　
{
　Lista de campos de bits
};

A forma da lista de campos de bits é:

Sinal de tipo - Nome do campo de bits: comprimento do campo de bits

Por exemplo:

struct bs{
　　　　int a:8;
　　　　int b:2;
　　　　int c:6;
}; data;

Descrição data é a variável bs, que ocupa dois bytes. O campo de bits a ocupa 8 bits, o campo de bits b ocupa 2 bits, o campo de bits c ocupa 6 bits.

Vamos olhar para outro exemplo:

struct packed_struct {
　　unsigned int f1:1;
　　unsigned int f2:1;
　　unsigned int f3:1;
　　unsigned int f4:1;
　　unsigned int type:4;
　　unsigned int my_int:9;
}; pack;

Aqui, packed_struct contém 6 um membro: quatro 1 do identificador do campo de bits f1..f4, um 4 do type e um 9 do my_int.

Existem algumas observações adicionais sobre a definição de campos de bits:

Um campo de bits é armazenado no mesmo byte, se o espaço restante em um byte não for suficiente para armazenar outro campo de bits, ele será armazenado a partir da próxima unidade. Também é possível intencionalmente fazer com que um campo de bits comece na próxima unidade. Por exemplo:
```
struct bs{
　　　　unsigned a:4;
　　　　unsigned :4;　　　　/*　Espaço vazio　*/
　　　　unsigned b:4;　　　　/*　A partir da próxima unidade　*/
　　　　sem sinal　c:4
}
```
Nesta definição de campo de bits, a a ocupa o primeiro byte 4 bits, depois 4 bits preenchidos com 0 indicam que não são usados, b começa no segundo byte e ocupa 4 bits, c ocupa 4 bits.
Como os campos de bits não permitem que sejam divididos em dois bytes, o comprimento dos campos de bits não pode ser maior do que o comprimento de um byte, ou seja, não pode ser maior do que8Bits binários. Se o comprimento máximo for maior do que o comprimento do inteiro do computador, alguns compiladores podem permitir que os domínios se sobreponham na memória, enquanto outros compiladores podem armazenar partes maiores de um domínio no próximo word.
Os campos de bits podem ser anônimos, neste caso, eles são usados apenas para preencher ou ajustar a posição. Os campos de bits anônimos não podem ser usados. Por exemplo:
```
struct k{
　　　　int a:1;
　　　　int :2;　　　　/*　Este　2　Os bits não podem ser usados　*/
　　　　int b:3;
　　　　int c:2;
};
```

A análise acima mostra que os campos de bits, essencialmente, são um tipo de estrutura, mas seus membros são alocados de acordo com os bits binários.

Uso dos campos de bits

O uso dos campos de bits e dos membros da estrutura são idênticos, e sua forma geral é:

Nome do campo de bits. Nome do campo de bits
Nome do campo de bits->Nome do campo de bits

Os campos de bits permitem a saída em vários formatos.

Veja o exemplo a seguir:

Exemplo

main(){
　　　　struct bs{
　　　　　　　　unsigned a:1;
　　　　　　　　unsigned b:3;
　　　　　　　　sem sinal　c:4;
　　　　}　bit,*pbit;
　　　　bit.a=1;　　　　/*　Atribuição de campo de bits (devemos notar que a atribuição não pode exceder o intervalo permitido pelo campo de bits)　*/
　　　　bit.b=7;　　　　/*　Atribuição de campo de bits (devemos notar que a atribuição não pode exceder o intervalo permitido pelo campo de bits)　*/
　　　　bit.c=15;　　　　/*　Atribuição de campo de bits (devemos notar que a atribuição não pode exceder o intervalo permitido pelo campo de bits)　*/
　　　　printf("%d,%d,%d\n",bit.a,bit.b,bit.c);　　　　/*　Imprimimos o conteúdo dos três campos no formato de inteiro　*/
　　　　pbit=&bit;　　　　/*　Passamos o endereço da variável de campo de bits bit para o ponteiro pbit　*/
　　　　pbit->a=0;　　　　/*　Atribuímos novamente o valor 0 ao campo de bits a usando o ponteiro　*/
　　　　pbit->b&=3;　　　　/*　Usamos o operador de operação composta "&=", equivalente a: pbit->b=pbit->b&3com o valor original do campo de bits b　7com　3　o resultado da operação de AND bit a bit é　3（111&011=011com valor decimal　3）　*/
　　　　pbit->c|=1;　　　　/*　Usamos o operador de operação composta "|=", equivalente a: pbit->c=pbit->c|1Seu resultado é　15　*/
　　　　printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);　　　　/*　Os valores desses três campos foram impressos de forma pontuada　*/
}

No exemplo do programa, foi definida a estrutura de campo bit bs, com três campos bit a, b, c. Isso ilustra a variável do tipo bs e o ponteiro para o tipo bs. Isso mostra que os campos de bits também podem ser usados com ponteiros.

Palavra-chave typedef

Usamos a palavra-chave typedef para criar nomes alternativos para tipos de dados. Isso geralmente é usado com estruturas para simplificar a sintaxe de declaração de variáveis.

Este código

struct　Distance{
　　　　int　feet;
　　　　float　inch;
};
int　main()　{
　　　　struct　Distance　d1,　d2;
}

equivalente a

typedef　struct　Distance{
　　　　int　feet;
　　　　float　inch;
}　distances;
int　main()　{
　　　　distances　d1,　d2;
}

estrutura aninhada

Você pode criar estruturas dentro de estruturas em linguagem C. Por exemplo,

struct　complex
{
　int　imag;
　float　real;
};
struct　number
{
　　　struct　complex　comp;
　　　int　integers;
}　num1,　num2;

Suponha, você deseja configurar num2O valor da variável imag é11Como fazer isso? Veja o exemplo a seguir:

num;2.comp.imag　=;　11;

Por que usar estruturas em C?

Suponha que você precise armazenar informações sobre uma pessoa: ele/Seu nome, número de identidade e salário. Você pode criar variáveis diferentes como name, citNo e salary para armazenar essas informações.

E se precisar armazenar informações de várias pessoas? Agora, você precisa criar variáveis diferentes para cada informação de cada pessoa: nome1número de identidade civil1salário1nome2número de identidade civil2salário2etc.

Uma maneira melhor é agrupar todas as informações relacionadas em uma estrutura de nome único Person e usá-la para cada pessoa.

Mais sobre Estrutura

Biblioteca Padrão <assert.h> do C gets() e puts() no C