Classes em C

Embora o C seja uma linguagem de programação estruturada e não ofereça suporte nativo à Programação Orientada a Objetos (POO), é possível simular alguns conceitos de classes e objetos utilizando estruturas (structs) e funções. Neste post veja classes em C.

O que é uma classe?

Uma classe, no contexto da POO, é um modelo ou estrutura que define as propriedades (atributos) e comportamentos (métodos) de um objeto. No C++, por exemplo, as classes são um recurso nativo, mas em C não temos esse suporte diretamente.

Porém, podemos simular o comportamento de classes em C usando structs para armazenar os atributos e funções para simular os métodos.

Simulando uma classe em C

Vamos imaginar que queremos criar uma “classe” Carro, que possui dois atributos: marca e velocidade. Além disso, terá métodos para acelerar e frear.

Passo 1: Definir a estrutura (struct) para os atributos

No C, usamos a estrutura struct para agrupar os atributos de uma classe. Esse será o esqueleto de nossa “classe”.

#include <stdio.h>
#include <string.h>

// Definindo a estrutura Carro
typedef struct {
    char marca[50];
    int velocidade;
} Carro;

Aqui, estamos criando uma estrutura Carro com dois campos:

• marca (uma string para armazenar o nome da marca do carro).
• velocidade (um inteiro para representar a velocidade atual do carro).

Passo 2: Criar funções (métodos) para a classe

Agora, vamos definir funções que irão operar na estrutura Carro, simulando métodos de uma classe.

// Função para inicializar o carro
void iniciarCarro(Carro* carro, const char* marca) {
    strcpy(carro->marca, marca);
    carro->velocidade = 0; // Carro começa parado
}

// Função para acelerar o carro
void acelerar(Carro* carro, int incremento) {
    carro->velocidade += incremento;
    printf("%s acelerou para %d km/h\n", carro->marca, carro->velocidade);
}

// Função para frear o carro
void frear(Carro* carro, int decremento) {
    carro->velocidade -= decremento;
    if (carro->velocidade < 0) {
        carro->velocidade = 0;
    }
    printf("%s freou para %d km/h\n", carro->marca, carro->velocidade);
}

• iniciarCarro: Inicializa o carro com uma marca e uma velocidade inicial de 0.
• acelerar: Aumenta a velocidade do carro.
• frear: Reduz a velocidade do carro, garantindo que não fique negativa.

Passo 3: Usar a “classe” Carro

Agora que temos a estrutura e as funções prontas, podemos criar e manipular instâncias da “classe” Carro.

int main() {
    // Criando uma instância de Carro
    Carro meuCarro;

    // Inicializando o carro
    iniciarCarro(&meuCarro, "Ferrari");

    // Acelerando e freando
    acelerar(&meuCarro, 50);  // Ferrari acelerou para 50 km/h
    acelerar(&meuCarro, 30);  // Ferrari acelerou para 80 km/h
    frear(&meuCarro, 40);     // Ferrari freou para 40 km/h
    frear(&meuCarro, 50);     // Ferrari freou para 0 km/h

    return 0;
}

Aqui, estamos criando um objeto meuCarro do tipo Carro e manipulando sua velocidade usando os métodos simulados (acelerar e frear).

Simulando encapsulamento

Em linguagens orientadas a objetos, o encapsulamento permite que os atributos de uma classe sejam protegidos e acessados apenas por meio de métodos. Em C, podemos simular esse comportamento usando modificadores de acesso implícitos e funções que controlam como os dados são manipulados.

Por exemplo, podemos controlar o acesso ao atributo velocidade criando uma função “getter” para obter a velocidade atual:

// Função para obter a velocidade atual
int obterVelocidade(Carro* carro) {
    return carro->velocidade;
}

Agora, ao invés de acessar diretamente o atributo velocidade, podemos usar a função obterVelocidade():

int velocidadeAtual = obterVelocidade(&meuCarro);
printf("A velocidade atual é: %d km/h\n", velocidadeAtual);

Herança e polimorfismo em C

Embora o C não suporte herança e polimorfismo de forma nativa, podemos usar técnicas como composição para simular a herança. Composição significa incluir uma estrutura dentro de outra estrutura.

Exemplo de composição:

// Definindo uma estrutura Veiculo
typedef struct {
    char tipo[50];
    int ano;
} Veiculo;

// Definindo uma estrutura Caminhao que "herda" Veiculo
typedef struct {
    Veiculo veiculo;  // Composição
    int capacidadeCarga;
} Caminhao;

Aqui, Caminhao contém um Veiculo, simulando uma relação de herança.

Embora o C não ofereça suporte direto à Programação Orientada a Objetos, podemos usar conceitos como estruturas, **fun

ções** e ponteiros para simular o comportamento de classes em C. Utilizando essas técnicas, conseguimos criar uma arquitetura que se aproxima da programação orientada a objetos, implementando atributos, métodos e até simulando conceitos como encapsulamento e herança por meio de composição.

Resumo dos passos:

1. Estruturas: Use structs para definir os atributos de sua “classe”.
2. Funções: Crie funções para simular os métodos.
3. Encapsulamento: Proteja os atributos criando “getters” e “setters” quando necessário.
4. Composição: Simule herança incluindo uma struct dentro de outra.

Esses conceitos permitem implementar soluções mais organizadas e modulares, mesmo em uma linguagem não orientada a objetos como o C.

Dúvidas ou sugestões sobre classes em C? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: class | classes