Structs como Objetos

Parte da seção Programação Orientada a Objetos do Journey de C da Coddy. Lição 6 de 61.

Em linguagens orientadas a objetos, um objeto é uma entidade que reúne dados (estado) com funções que operam sobre esses dados (métodos). C não possui objetos integrados, mas podemos alcançar o mesmo conceito usando estruturas e funções.

Pense em uma struct como a parte de "dados" de um objeto. Ela mantém o estado: os valores que definem o que o objeto é atualmente:

typedef struct {
    int value;
} Counter;

Essa struct Counter representa uma entidade com um único estado: seu valor atual. Para atribuir comportamento a ela, escrevemos funções que aceitam a struct como parâmetro:

void counter_increment(Counter *c) {
    c->value++;
}

int counter_get(Counter *c) {
    return c->value;
}

Essas funções funcionam como métodos. Elas operam especificamente em dados de Counter. Ao passar a estrutura para as funções, estamos simulando o que outras linguagens fazem automaticamente quando você chama counter.increment().

int main() {
    Counter my_counter = {0};
    counter_increment(&my_counter);
    printf("%d\n", counter_get(&my_counter)); // Imprime: 1
    return 0;
}

A convenção de nomenclatura typename_action (como counter_increment) ajuda a organizar seu código e deixa claro a qual struct uma função pertence. Esse padrão é a base da programação orientada a objetos em C.

Desafio

Fácil

Vamos criar um módulo simples Counter que trata uma struct como um objeto com comportamento. Você organizará seu código em três arquivos para praticar o padrão de agrupar dados com funções que operam sobre eles.

Você criará três arquivos:

counter.h: seu arquivo de cabeçalho que declara a struct Counter com um único membro int value. Declare também duas funções que atuam como "métodos" do contador: counter_increment (recebe um ponteiro para Counter e aumenta seu valor em 1) e counter_get (recebe um ponteiro para Counter e retorna seu valor atual). Use guardas de inclusão com o símbolo COUNTER_H.
counter.c: seu arquivo-fonte que implementa ambas as funções. Lembre-se de incluir seu arquivo de cabeçalho.
main.c: seu arquivo principal que cria um Counter, executa operações sobre ele e exibe os resultados.

Você receberá duas entradas inteiras: o valor inicial do seu contador e o número de vezes que ele deve ser incrementado.

No arquivo principal, inicialize um Counter com o valor inicial e, em seguida, chame counter_increment o número de vezes especificado. Por fim, use counter_get para obter e imprimir o valor final.

Imprima o resultado neste formato:

Final value: {result}

Por exemplo, com um valor inicial de 5 e 3 incrementos, a saída seria:

Final value: 8

Experimente você mesmo

#include <stdio.h>
#include "counter.h"

int main() {
    // Ler entrada
    int starting_value;
    int num_increments;
    scanf("%d", &starting_value);
    scanf("%d", &num_increments);
    
    // TODO: Crie um Counter e inicialize-o com starting_value
    
    // TODO: Chame counter_increment o número especificado de vezes
    
    // TODO: Use counter_get para recuperar o valor final e imprima-o
    // Formato de impressão: "Final value: {result}"
    
    return 0;
}