I have always been curious about computers and always thought: "Okay, I know how to use it, but how does it really work?" In this process, I often do a thought experiment: If I were asked to start from Starting from scratch, what would I do? In this article, we will explore how interfaces work in object-oriented programming (using Java), and then implement a humble version of the interface in C.

Let’s look at an example

Our example is simple: calculate the price of a vehicle. If it's a car, the price will be based on its top speed; if it's a motorcycle, the price will be based on its displacement. We first define the behavior of the vehicle using an interface:

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

Nothing special 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;
        }
    }
}

Very classic: an implementation of a constructor and price method, multiplying the speed by 60. Now, let's 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;
        }
    }
}

Almost the same, the only difference is that now we multiply the displacement by 10. Then, we implement a method to print the vehicle price:

public class Main {
    // ...

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

No secrets. 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);
    }
}

<code>$ java Main.java
00.00
000.00</code>

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

How can we solve this problem?

When I think of objects, the first thing that comes to mind is a set of data that represents a state and methods to operate and manage that state. The most direct way to represent a data collection in C language is a structure. For methods, the closest approach is a function that receives a state as a parameter. This state will correspond to this in the class, for example:

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 a person's data in the Person structure and use these data to perform simple calculations. This is the closest structure to a class we can have in C. Maybe using function pointers in structs is also a good idea? Well, I’ll leave that for the next article.

Okay, we have a class-like structure. Now, how do we define interface in C language? If you think about it, the compiler/interpreter doesn't do magic to guess which classes implement the interface. It determines this at compile time and replaces all the parts where we use the interface with concrete types. In the compiled program, the interface doesn't even exist.

Since the C language compiler does not provide this possibility, we must implement this solution ourselves. We need to know all the types that implement our interface and figure out how to use the functions of these implementations.

Implement interface in C language

First, let’s define the skeleton of our humble interface. We will create an enumeration that contains the different implementations and signatures of our functions.

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

Here we define our enum which contains the implementation we will implement later. This may not seem like it, but this part is very important. Next, we declare the vehicle_free function (will be explained later) and the vehicle_price function, which we want to implement in our "class". Now let’s look at the car implementation:

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;
        }
    }
}

The car_init function initializes a new "object" Car in memory. In Java this will be done automatically via new. Here we need to do it manually. The vehicle_free function will be used to release the memory allocated by any previously initialized "object", implemented using car_free etc. The implementation for motorcycles is very similar:

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;
        }
    }
}

Almost the same, except now we initialize with VEHICLE_MOTORCYCLE and multiply by 10. Now let’s look at the function that prints the vehicle price:

public class Main {
    // ...

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

So simple...it doesn't look like we're doing much work. Now, the last and most important point is that we have to implement the functions we declared in the interface definition above, remember? Fortunately, we don't even need to think about this implementation. We always have a simple exhaustive switch/case and that's it.

public class Main {
    // ...

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

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

Now we can use everything we did:

<code>$ java Main.java
00.00
000.00</code>

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;
}

Success! But you might be thinking: "Well, what's the use?"

A real use case

One of my favorite types of projects is parsers, from parsers to simple math expression parsers. Typically when you implement these parsers you encounter something called an AST (Abstract Syntax Tree). As the name suggests it is a tree which will represent the syntax you are dealing with, for example the variable declaration int foo = 10; is a node of the AST which contains three other nodes, a type node, for int, an identifier node, for foo, and an expression node, for 10, which contains another integer node with a value of 10. See how complicated it is?

When we do this in C, we have to choose between a huge struct with multiple fields to represent any possible AST node, or an abstract definition using multiple small structs, each Structures represent different nodes, just like we do here with our "interfaces". If you want to see a simple example, in this math expression parser I implemented the second approach.

Conclusion

Nothing a compiler or interpreter does is magic. It's always a fun exercise to try to implement something yourself. Hope this was a helpful read. Thanks!

The above is the detailed content of Object Orientation in C? Implementing an interface from scratch.. For more information, please follow other related articles on the PHP Chinese website!