Forem: Andrey Arthur Sousa e Silva

Orientação a Objetos em C? Implementando uma interface do zero.

Andrey Arthur Sousa e Silva — Tue, 21 Jan 2025 01:54:58 +0000

Sempre fui um cara curioso quando se trata de computação, daquele tipo que pensa: "Ok, entendi como usar, mas como isso funciona de verdade?". Nesse processo, sempre faço um exercício de imaginação: se eu tivesse que implementar isso do zero, como faria? Neste artigo, vamos explorar como interfaces funcionam na orientação a objetos usando Java e, em seguida, implementar uma versão rudimentar de interface em C.

Vamos ao nosso exemplo

O nosso exemplo será muito simples: calcularemos o preço de um veículo. Se for um carro, o preço será calculado com base na velocidade que ele pode alcançar; se for uma moto, o preço será calculado com base nas cilindradas. Começamos definindo o comportamento de um veículo com uma interface:

public class Main {
    public interface Vehicle {
        Integer price();
    }
}

Nada demais aqui, apenas um método que retorna um inteiro. Agora vamos implementar a classe do carro:

public class Main {
    // ...

    public static class Car implements Vehicle {
        private final Integer speed;

        public Car(Integer speed) {
            this.speed = speed;
        }

        @Override
        public Integer price() {
            return speed * 60;
        }
    }
}

Clássico: um construtor e a implementação do método price, multiplicando a velocidade por 60. Agora, vamos implementar a classe da moto:

public class Main {
    // ...

    public static class Motorcycle implements Vehicle {
        private final Integer cc;

        public Motorcycle(Integer cc) {
            this.cc = cc;
        }

        @Override
        public Integer price() {
            return cc * 10;
        }
    }
}

Praticamente igual, com a única diferença de que agora estamos multiplicando as cilindradas por 10. Vamos então implementar um método que imprime o preço de um veículo:

public class Main {
    // ...

    public static void printVehiclePrice(Vehicle vehicle) {
        System.out.println("$" + vehicle.price() + ".00");
    }
}

Sem segredos. Por fim, nosso método main:

public class Main {
    // ...

    public static void main(String[] args) {
        Car car = new Car(120);
        Motorcycle motorcycle = new Motorcycle(1000);

        printVehiclePrice(car);
        printVehiclePrice(motorcycle);
    }
}

$ java Main.java
$7200.00
$10000.00

É esse o modelo que queremos alcançar, mas agora do zero, em C.

Como vamos resolver esse problema?

Quando penso em objetos, a primeira coisa que me vem à mente é um conjunto de dados que representa um estado e métodos que manipulam e gerenciam esse estado. A maneira mais direta de representar um conjunto de dados em C é uma struct. Já para métodos, a forma mais próxima seria uma função que recebe o estado como argumento. Esse estado corresponderia ao this em uma classe, por exemplo. Um exemplo prático seria:

typedef struct {
    int height_in_cm;
    int weight_in_kg;
} Person;

float person_bmi(Person *person) {
    float height_in_meters = (float)person->height_in_cm / 100;
    float bmi =
        (float)person->weight_in_kg / (height_in_meters * height_in_meters);

    return bmi;
}

Aqui definimos os dados de uma pessoa na struct Person e utilizamos esses dados para fazer um cálculo simples. Isso é uma das coisas mais próximas de uma classe que podemos ter em C. Talvez usar ponteiros de função dentro da struct também seja uma boa ideia? Bom, isso fica para um próximo artigo.

Ok, temos uma espécie de classe. Agora, como podemos definir uma interface em C? Se pensarmos bem, um compilador/interpretador não faz mágica para adivinhar quais classes implementam uma interface. Ele consegue determinar isso em tempo de compilação e trocar todas as partes onde usamos interfaces pelos tipos concretos. No programa compilado, as interfaces nem sequer existem.

Como o compilador de C não nos oferece essa possibilidade, teremos que implementar todo esse esquema sozinhos. Precisamos saber todos os tipos que implementam nossa interface e dar um jeito de usar as funções dessas implementações.

Implementando uma interface em C

Para começar, vamos definir o esqueleto da nossa interface rudimentar. Criaremos um enum com as diferentes implementações e a assinatura das nossas funções.

#include <stdio.h>
#include <stdlib.h>

typedef enum { VEHICLE_CAR, VEHICLE_MOTORCYCLE } VehicleType;

typedef struct {
    VehicleType type;
} Vehicle;

void vehicle_free(Vehicle *vehicle);

int vehicle_price(Vehicle *vehicle);

Aqui definimos nosso enum com as implementações que faremos posteriormente. Pode não parecer, mas essa é a parte mais importante. Em seguida, declaramos as funções vehicle_free, que explicarei mais adiante, e vehicle_price, que desejamos implementar nas nossas "classes". Agora vamos à implementação do carro:

// ...

typedef struct {
    VehicleType type;
    int speed;
} Car;

Car *car_init(int speed) {
    Car *car = malloc(sizeof(Car));

    car->type = VEHICLE_CAR;
    car->speed = speed;

    return car;
}

void car_free(Car *car) {
    free(car);
}

int car_price(Car *car) {
    return car->speed * 60;
}

A função car_init inicializa um novo "objeto" Car na memória. Em Java, isso seria feito automaticamente com new. Aqui, precisamos fazer manualmente. A função vehicle_free será usada para liberar a memória alocada por qualquer "objeto" inicializado anteriormente, utilizando implementações como car_free. A implementação da Motorcycle é bem parecida:

// ...

typedef struct {
    VehicleType type;
    int cc;
} Motorcycle;

Motorcycle *motorcycle_init(int cc) {
    Motorcycle *motorcycle = malloc(sizeof(Motorcycle));

    motorcycle->type = VEHICLE_MOTORCYCLE;
    motorcycle->cc = cc;

    return motorcycle;
}

void motorcycle_free(Motorcycle *motorcycle) {
    free(motorcycle);
}

int motorcycle_price(Motorcycle *motorcycle) {
    return motorcycle->cc * 10;
}

Praticamente igual, só muda que agora inicializamos com VEHICLE_MOTORCYCLE e multiplicamos por 10. Agora vamos pra função que imprime o preço do veículo:

// ...

void print_vehicle_price(Vehicle *vehicle) {
    printf("$%d.00\n", vehicle_price(vehicle));
}

Tão simples... Vendo assim nem parece que estamos tendo todo esse trabalho. Agora, por último, e mais importante, temos que implementar as funções que declaramos na definição da nossa interface lá em cima, lembra? Para a nossa sorte, nem precisamos pensar tanto nessa implementação. Sempre teremos um simples switch/case exaustivo, nada mais.

// ...

void vehicle_free(Vehicle *vehicle) {
    switch (vehicle->type) {
    case VEHICLE_CAR:
        car_free((Car *)vehicle);
        break;
    case VEHICLE_MOTORCYCLE:
        motorcycle_free((Motorcycle *)vehicle);
        break;
    }
}

int vehicle_price(Vehicle *vehicle) {
    switch (vehicle->type) {
    case VEHICLE_CAR:
        return car_price((Car *)vehicle);
    case VEHICLE_MOTORCYCLE:
        return motorcycle_price((Motorcycle *)vehicle);
    }
}

Agora podemos usar tudo o que fizemos:

// ...

int main(void) {
    Car *car = car_init(120);
    Motorcycle *motorcycle = motorcycle_init(1000);

    print_vehicle_price((Vehicle *)car);
    print_vehicle_price((Vehicle *)motorcycle);

    vehicle_free((Vehicle *)car);
    vehicle_free((Vehicle *)motorcycle);

    return 0;
}

$ gcc -o main main.c
$ ./main
$7200.00
$10000.00

Funcionou! Mas você pode estar pensando: "Ok, mas para que serve?".

Um caso de uso real

Um dos meus tipos de projetos favoritos são parsers, desde interpretadores até simples parsers de expressões matemáticas. Geralmente quando você está implementando um desses, vai esbarrar em algo chamado AST (Abstract Syntax Tree). Como o próprio nome diz, ela é uma árvore que vai representar a sintaxe que você está processando, por exemplo, uma declaração de variável int foo = 10; é um nó da AST que contém mais três outros nós, um nó de tipo, para o int, um nó de identificador, para o foo, e um nó de expressão para o 10, esse que contém outro nó de inteiro com o valor numérico 10. Viu como fica complexo?

Quando fazemos isso em C, temos que escolher entre uma struct gigante com diversos campos, para reprensentar qualquer possível nó da AST, ou várias structs pequenas implementando uma definição abstrata, representando cada uma um nó diferente, como fizemos aqui, com a nossa "interface". Se quiser ver um exemplo simples, nesse parser de expressões matemáticas eu implemento a segunda forma.

Conclusão

Nada que um compilador ou interpretador faz é mágica. Tentar implementar algo por conta própria é sempre um exercício interessante. Espero que tenha sido uma leitura proveitosa. Obrigado!

Object-Oriented Programming in C? Implementing an Interface from Scratch

Andrey Arthur Sousa e Silva — Tue, 21 Jan 2025 01:53:46 +0000

I've always been a curious person when it comes to computing—someone who thinks, "Okay, I understand how to use this, but how does it actually work?" As part of this mindset, I like to challenge myself: if I had to implement this from scratch, how would I do it? In this article, we'll explore how interfaces work in object-oriented programming using Java and then implement a rudimentary version of an interface in C.

Let’s Dive into Our Example

Our example will be simple: we’ll calculate the price of a vehicle. If it’s a car, the price will be based on the speed it can reach; if it’s a motorcycle, the price will be based on its engine displacement (cc). We’ll start by defining the behavior of a vehicle with an interface:

public class Main {
    public interface Vehicle {
        Integer price();
    }
}

Nothing fancy here—just a method that returns an integer. Now let’s implement the Car class:

public class Main {
    // ...

    public static class Car implements Vehicle {
        private final Integer speed;

        public Car(Integer speed) {
            this.speed = speed;
        }

        @Override
        public Integer price() {
            return speed * 60;
        }
    }
}

Classic: a constructor and the implementation of the price method, multiplying the speed by 60. Next, we implement the Motorcycle class:

public class Main {
    // ...

    public static class Motorcycle implements Vehicle {
        private final Integer cc;

        public Motorcycle(Integer cc) {
            this.cc = cc;
        }

        @Override
        public Integer price() {
            return cc * 10;
        }
    }
}

Practically the same, with the only difference being that now we multiply the engine displacement by 10. Let’s then implement a method to print the price of a vehicle:

public class Main {
    // ...

    public static void printVehiclePrice(Vehicle vehicle) {
        System.out.println("$" + vehicle.price() + ".00");
    }
}

Straightforward. Finally, our main method:

public class Main {
    // ...

    public static void main(String[] args) {
        Car car = new Car(120);
        Motorcycle motorcycle = new Motorcycle(1000);

        printVehiclePrice(car);
        printVehiclePrice(motorcycle);
    }
}

$ java Main.java
$7200.00
$10000.00

This is the model we want to achieve, but now from scratch, in C.

How Are We Going to Solve This?

When I think about objects, the first thing that comes to mind is a set of data representing a state and methods to manipulate and manage that state. The most direct way to represent a set of data in C is a struct. For methods, the closest equivalent would be a function that receives the state as an argument. This state would correspond to the this in a class, for instance. A practical example would be:

typedef struct {
    int height_in_cm;
    int weight_in_kg;
} Person;

float person_bmi(Person *person) {
    float height_in_meters = (float)person->height_in_cm / 100;
    float bmi =
        (float)person->weight_in_kg / (height_in_meters * height_in_meters);

    return bmi;
}

Here, we define the data of a person in the struct Person and use it to perform a simple calculation. This is one of the closest things we can have to a class in C. Maybe using function pointers inside the struct is also a good idea? Well, that’s a topic for another article.

Okay, we have a kind of class. Now, how can we define an interface in C? If you think about it, a compiler/interpreter doesn’t use magic to figure out which classes implement an interface. It determines this at compile time and replaces all parts where we use interfaces with the concrete types. In the compiled program, interfaces don’t even exist.

Since the C compiler doesn’t give us this capability, we’ll have to implement this whole mechanism ourselves. We need to know all the types that implement our interface and find a way to use the functions of these implementations.

Implementing an Interface in C

To start, let’s define the skeleton of our rudimentary interface. We’ll create an enum for the different implementations and declare the signatures of our functions.

#include <stdio.h>
#include <stdlib.h>

typedef enum { VEHICLE_CAR, VEHICLE_MOTORCYCLE } VehicleType;

typedef struct {
    VehicleType type;
} Vehicle;

void vehicle_free(Vehicle *vehicle);

int vehicle_price(Vehicle *vehicle);

Here, we define our enum with the implementations we’ll create later. It may not seem like much, but this is the most important part. Then we declare the vehicle_free function, which I’ll explain later, and the vehicle_price function, which we want to implement in our "classes." Now let’s implement the Car:

// ...

typedef struct {
    VehicleType type;
    int speed;
} Car;

Car *car_init(int speed) {
    Car *car = malloc(sizeof(Car));

    car->type = VEHICLE_CAR;
    car->speed = speed;

    return car;
}

void car_free(Car *car) {
    free(car);
}

int car_price(Car *car) {
    return car->speed * 60;
}

The car_init function initializes a new Car "object" in memory. In Java, this would be done automatically with new. Here, we must handle it manually. The vehicle_free function will be used to free the memory allocated for any "object" initialized earlier, using implementations like car_free. The Motorcycle implementation is quite similar:

// ...

typedef struct {
    VehicleType type;
    int cc;
} Motorcycle;

Motorcycle *motorcycle_init(int cc) {
    Motorcycle *motorcycle = malloc(sizeof(Motorcycle));

    motorcycle->type = VEHICLE_MOTORCYCLE;
    motorcycle->cc = cc;

    return motorcycle;
}

void motorcycle_free(Motorcycle *motorcycle) {
    free(motorcycle);
}

int motorcycle_price(Motorcycle *motorcycle) {
    return motorcycle->cc * 10;
}

Pretty much the same—only now we initialize with VEHICLE_MOTORCYCLE and multiply by 10. Now let’s implement the function to print the vehicle’s price:

// ...

void print_vehicle_price(Vehicle *vehicle) {
    printf("$%d.00\n", vehicle_price(vehicle));
}

So simple… Seeing it like this, it doesn’t even feel like we’re doing all this work. Finally, and most importantly, we need to implement the functions we declared when defining our interface earlier. Fortunately, we don’t need to overthink this implementation. We’ll always have a simple exhaustive switch/case, nothing more.

// ...

void vehicle_free(Vehicle *vehicle) {
    switch (vehicle->type) {
    case VEHICLE_CAR:
        car_free((Car *)vehicle);
        break;
    case VEHICLE_MOTORCYCLE:
        motorcycle_free((Motorcycle *)vehicle);
        break;
    }
}

int vehicle_price(Vehicle *vehicle) {
    switch (vehicle->type) {
    case VEHICLE_CAR:
        return car_price((Car *)vehicle);
    case VEHICLE_MOTORCYCLE:
        return motorcycle_price((Motorcycle *)vehicle);
    }
}

Now we can use everything we’ve built:

// ...

int main(void) {
    Car *car = car_init(120);
    Motorcycle *motorcycle = motorcycle_init(1000);

    print_vehicle_price((Vehicle *)car);
    print_vehicle_price((Vehicle *)motorcycle);

    vehicle_free((Vehicle *)car);
    vehicle_free((Vehicle *)motorcycle);

    return 0;
}

$ gcc -o main main.c
$ ./main
$7200.00
$10000.00

It works! But you might be thinking, "Okay, but what’s the point?"

A Real-World Use Case

One of my favorite types of projects is parsers, ranging from interpreters to simple math expression parsers. When working on these, you’ll often encounter something called an AST (Abstract Syntax Tree). As the name suggests, it’s a tree that represents the syntax you’re processing. For example, a variable declaration like int foo = 10; is a node in the AST containing three child nodes: one for the type (int), one for the identifier (foo), and one for the expression (10), which itself contains another node for the integer value 10. See how complex this gets?

When doing this in C, you have to choose between a giant struct with fields for all possible nodes in the AST or several smaller structs implementing an abstract definition, each representing a different node—like we did here with our "interface." If you want a simple example, check out this math expression parser, where I implement the latter approach.

Conclusion

Nothing a compiler or interpreter does is magic. Trying to implement something yourself is always an interesting exercise. I hope this was an enjoyable read. Thank you!

Integers in C: A Bit of History

Andrey Arthur Sousa e Silva — Wed, 25 Dec 2024 13:30:16 +0000

Integers are the most fundamental data structure in computing—if we can even call them a "structure." Our job as programmers is to give meaning to these numbers. No matter how complex the software: in the end, it’s just an integer, and your processor only understands integers.

If we need negative numbers, we invented two's complement. If we need fractional numbers, we create a sort of scientific notation and — boom — we have a float. At the end of the day, there's no escaping from zeros and ones.

Little History of Integers

In C, the int is almost the natural type. Although compilers might complain, with a few flags here and there, most will allow you to write something like this:

main(void) {
    return 0;
}

Technically, this is the same as:

int main(void) {
    return 0;
}

This behavior comes from a time when it was common sense to assume that, if the programmer didn’t specify a type, it was reasonable to default to an integer.

C was designed with this idea in mind. Initially, int didn’t have a standard size. The PDP-11 processor — the machine for which C was originally created — used 16-bit addressing. So it was assumed that it made sense for an int to also be 16 bits. The idea was that the size of int would grow as processors evolved.

The Mysterious Size

This approach created some problems. If the size of int varies between platforms, programs compiled for different processors could behave differently. This broke the idea of C being an "agnostic" language that compiles to diverse architectures.

Unlike int, the char, for example, always had a well-defined size: 8 bits, signed. Despite its name, char is not an abstract type for text characters; it’s just an 8-bit number. For example, the literal 'a' is converted at compile time to the number 97, plain and simple.

And what about other types, like short and long? The idea was straightforward:

short <= int <= long

Compiler implementers had complete freedom to decide the specific sizes.

ANSI C (1989) Brings Some Order

With the ANSI C standard, some rules were established:

char: at least 8 bits
short: at least 16 bits
int: the size of a short or larger (16 or 32 bits)
long: at least 32 bits

This organization helped, but the size of int remained confusing, to say the least. Things improved with the C99 standard, which introduced the stdint.h header.

Now we have fixed-size types:

int8_t: 8 bits
int16_t: 16 bits
int32_t: 32 bits
int64_t: 64 bits

From then on, it was up to the compiler to implement this header with fixed-size types.

The Current State of Integers

Today, with modern compilers like GCC and Clang, sizes are more predictable:

Type	Size
`char`	8 bits
`short`	16 bits
`int`	32 bits
`long`	64 bits (32 bits on 32-bit systems)
`long long`	64 bits

Although long long is still somewhat peculiar, at least it brings some consistency (I even find long long stylish, to be honest).

What to Do?

Today, we are well-equipped with headers like stddef.h and stdint.h. Use int only where necessary, like for the return type of the main function. For anything beyond prototyping, prefer using fixed-size integers from stdint.h, and for array indices or loops, use size_t from stddef.h. I hope this spares you some headaches down the road.

Thanks for making it this far — see you next time!