Dominando Estruturas em C: Organize Dados Complexos Eficientemente

Arrays permitem definir tipos de variáveis que podem conter vários itens de dados do mesmo tipo. Similarmente, structure (estrutura) é outro tipo de dado definido pelo usuário disponível em C que permite combinar itens de dados de diferentes tipos.

Estruturas são usadas para representar um registro. Suponha que você queira acompanhar seus livros em uma biblioteca. Você pode querer rastrear os seguintes atributos sobre cada livro:

• Título
• Autor
• Assunto
• ID do Livro

Definindo uma Estrutura

Para definir uma estrutura, você deve usar a instrução struct. A instrução struct define um novo tipo de dado, com mais de um membro. O formato da instrução struct é o seguinte:

struct [structure_tag] {
    member_definition;
    member_definition;
    ...
    member_definition;
} [one_or_more_structure_variables];

O structure_tag (tag da estrutura) é opcional e cada definição de membro é uma definição de variável normal, como int i; ou float f; ou qualquer outra definição de variável válida. No final da definição da estrutura, antes do ponto e vírgula final, você pode especificar uma ou mais variáveis de estrutura, mas é opcional. Aqui está como você declararia a estrutura Book:

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

Acessando Membros da Estrutura

Para acessar qualquer membro de uma estrutura, usamos o operador de acesso a membro (.). O operador de acesso a membro é codificado como um ponto entre o nome da variável de estrutura e o membro da estrutura que desejamos acessar. Você usaria a palavra-chave struct para definir variáveis de tipo estrutura. O exemplo a seguir mostra como usar uma estrutura em um programa:

Live Demo

#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 Book1 do tipo Book */
    struct Books Book2; /* Declara Book2 do tipo Book */
    
    /* especificação do livro 1 */
    strcpy(Book1.title, "C Programming");
    strcpy(Book1.author, "Nuha Ali");
    strcpy(Book1.subject, "C Programming Tutorial");
    Book1.book_id = 6495407;
    
    /* especificação do livro 2 */
    strcpy(Book2.title, "Telecom Billing");
    strcpy(Book2.author, "Zara Ali");
    strcpy(Book2.subject, "Telecom Billing Tutorial");
    Book2.book_id = 6495700;
    
    /* imprime info do Book1 */
    printf("Título do Livro 1 : %s\n", Book1.title);
    printf("Autor do Livro 1 : %s\n", Book1.author);
    printf("Assunto do Livro 1 : %s\n", Book1.subject);
    printf("ID do Livro 1 : %d\n", Book1.book_id);
    
    /* imprime info do Book2 */
    printf("Título do Livro 2 : %s\n", Book2.title);
    printf("Autor do Livro 2 : %s\n", Book2.author);
    printf("Assunto do Livro 2 : %s\n", Book2.subject);
    printf("ID do Livro 2 : %d\n", Book2.book_id);
    
    return 0;
}

Quando o código acima é compilado e executado, produz o seguinte resultado:

Título do Livro 1 : C Programming
Autor do Livro 1 : Nuha Ali
Assunto do Livro 1 : C Programming Tutorial
ID do Livro 1 : 6495407
Título do Livro 2 : Telecom Billing
Autor do Livro 2 : Zara Ali
Assunto do Livro 2 : Telecom Billing Tutorial
ID do Livro 2 : 6495700

Estruturas como Argumentos de Função

Você pode passar uma estrutura como argumento de função da mesma forma que passa qualquer outra variável ou ponteiro.

Live Demo

#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 Book1 do tipo Book */
    struct Books Book2; /* Declara Book2 do tipo Book */
    
    /* especificação do livro 1 */
    strcpy(Book1.title, "C Programming");
    strcpy(Book1.author, "Nuha Ali");
    strcpy(Book1.subject, "C Programming Tutorial");
    Book1.book_id = 6495407;
    
    /* especificação do livro 2 */
    strcpy(Book2.title, "Telecom Billing");
    strcpy(Book2.author, "Zara Ali");
    strcpy(Book2.subject, "Telecom Billing Tutorial");
    Book2.book_id = 6495700;
    
    /* imprime info do Book1 */
    printBook(Book1);
    /* Imprime info do Book2 */
    printBook(Book2);
    
    return 0;
}

void printBook(struct Books book) {
    printf("Título do Livro : %s\n", book.title);
    printf("Autor do Livro : %s\n", book.author);
    printf("Assunto do Livro : %s\n", book.subject);
    printf("ID do Livro : %d\n", book.book_id);
}

Quando o código acima é compilado e executado, produz o seguinte resultado:

Título do Livro : C Programming
Autor do Livro : Nuha Ali
Assunto do Livro : C Programming Tutorial
ID do Livro : 6495407
Título do Livro : Telecom Billing
Autor do Livro : Zara Ali
Assunto do Livro : Telecom Billing Tutorial
ID do Livro : 6495700

Ponteiros para Estruturas

Você pode definir ponteiros para estruturas da mesma forma que define ponteiro para qualquer outra variável:

struct Books *struct_pointer;

Agora, você pode armazenar o endereço de uma variável de estrutura no ponteiro definido acima. Para encontrar o endereço de uma variável de estrutura, coloque o operador '&' antes do nome da estrutura da seguinte forma:

struct_pointer = &Book1;

Para acessar os membros de uma estrutura usando um ponteiro para essa estrutura, você deve usar o operador -> da seguinte forma:

struct_pointer->title;

Vamos reescrever o exemplo acima usando ponteiro de estrutura.

Live Demo

#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 Book1 do tipo Book */
    struct Books Book2; /* Declara Book2 do tipo Book */
    
    /* especificação do livro 1 */
    strcpy(Book1.title, "C Programming");
    strcpy(Book1.author, "Nuha Ali");
    strcpy(Book1.subject, "C Programming Tutorial");
    Book1.book_id = 6495407;
    
    /* especificação do livro 2 */
    strcpy(Book2.title, "Telecom Billing");
    strcpy(Book2.author, "Zara Ali");
    strcpy(Book2.subject, "Telecom Billing Tutorial");
    Book2.book_id = 6495700;
    
    /* imprime info do Book1 passando endereço do Book1 */
    printBook(&Book1);
    /* imprime info do Book2 passando endereço do Book2 */
    printBook(&Book2);
    
    return 0;
}

void printBook(struct Books *book) {
    printf("Título do Livro : %s\n", book->title);
    printf("Autor do Livro : %s\n", book->author);
    printf("Assunto do Livro : %s\n", book->subject);
    printf("ID do Livro : %d\n", book->book_id);
}

Quando o código acima é compilado e executado, produz o seguinte resultado:

Título do Livro : C Programming
Autor do Livro : Nuha Ali
Assunto do Livro : C Programming Tutorial
ID do Livro : 6495407
Título do Livro : Telecom Billing
Autor do Livro : Zara Ali
Assunto do Livro : Telecom Billing Tutorial
ID do Livro : 6495700

Bit Fields (Campos de Bits)

Bit Fields permitem a compactação de dados em uma estrutura. Isso é especialmente útil quando memória ou armazenamento de dados está em falta. Exemplos típicos incluem:

• Empacotar vários objetos em uma palavra de máquina. Ex: flags de 1 bit podem ser compactadas.

• Leitura de formatos de arquivo externos - formatos de arquivo não-padrão podem ser lidos, ex: inteiros de 9 bits.

C nos permite fazer isso em uma definição de estrutura colocando :bit_length após a variável. Por 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, o packed_struct contém 6 membros: Quatro flags de 1 bit f1..f3, um tipo de 4 bits e um my_int de 9 bits.

C empacota automaticamente os campos de bits acima da forma mais compacta possível, desde que o comprimento máximo do campo seja menor ou igual ao comprimento da palavra inteira do computador. Se este não for o caso, alguns compiladores podem permitir sobreposição de memória para os campos, enquanto outros armazenariam o próximo campo na próxima palavra.