C 中的面向对象编程？从头开始实现接口

程序员的好奇心总是驱使着我们深入探究技术的底层运作机制。本文将探讨如何在面向对象编程中使用Java接口，并尝试用C语言实现一个简化的接口版本。

示例：计算车辆价格

我们的示例场景很简单：计算不同类型车辆的价格。汽车的价格取决于其速度，而摩托车则取决于发动机排量。首先，我们用Java定义一个车辆接口：

public interface Vehicle {
    int price();
}

接下来，实现汽车类：

public class Car implements Vehicle {
    private final int speed;

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

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

摩托车类的实现类似：

public class Motorcycle implements Vehicle {
    private final int cc;

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

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

最后，编写一个打印车辆价格的方法：

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

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

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

输出结果：

$7200.00
$10000.00

现在，让我们尝试用C语言实现类似的功能。

C语言中的接口模拟

在C语言中，没有直接的接口概念。我们可以通过结构体和函数指针来模拟接口行为。首先定义一个枚举和基本结构体：

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

typedef enum { VEHICLE_CAR, VEHICLE_MOTORCYCLE } VehicleType;

typedef struct {
    VehicleType type;
    //  添加一个函数指针，指向price函数
    int (*price)(void *);
} Vehicle;

然后，实现汽车和摩托车结构体：

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

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

接下来，实现各个结构体的初始化和价格计算函数：

Car *car_init(int speed) {
    Car *car = malloc(sizeof(Car));
    car->type = VEHICLE_CAR;
    car->speed = speed;
    return car;
}

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


Motorcycle *motorcycle_init(int cc) {
    Motorcycle *motorcycle = malloc(sizeof(Motorcycle));
    motorcycle->type = VEHICLE_MOTORCYCLE;
    motorcycle->cc = cc;
    return motorcycle;
}

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

最后，实现打印价格函数和内存释放函数：

void print_vehicle_price(Vehicle *vehicle) {
    printf("$%d.00n", vehicle->price(vehicle));
}

void vehicle_free(Vehicle *vehicle) {
    if (vehicle->type == VEHICLE_CAR) {
        free((Car *)vehicle);
    } else if (vehicle->type == VEHICLE_MOTORCYCLE) {
        free((Motorcycle *)vehicle);
    }
}

int main(void) {
    Vehicle *car_v = malloc(sizeof(Vehicle));
    car_v->type = VEHICLE_CAR;
    car_v->price = car_price;
    Car *car = car_init(120);
    *(Car*)car_v = *car;

    Vehicle *motorcycle_v = malloc(sizeof(Vehicle));
    motorcycle_v->type = VEHICLE_MOTORCYCLE;
    motorcycle_v->price = motorcycle_price;
    Motorcycle *motorcycle = motorcycle_init(1000);
    *(Motorcycle*)motorcycle_v = *motorcycle;

    print_vehicle_price(car_v);
    print_vehicle_price(motorcycle_v);

    vehicle_free(car_v);
    vehicle_free(motorcycle_v);

    free(car);
    free(motorcycle);
    return 0;
}

这段C代码模拟了Java接口的功能，虽然实现方式不同，但最终达到了相同的效果。 需要注意的是，C语言的这种模拟方式需要更细致的内存管理，并且代码复杂度也相对较高。

实际应用场景

这种接口模拟方式在C语言中，常用于构建抽象语法树（AST）解析器等场景，可以有效地处理各种语法节点。

总结

通过这个例子，我们可以看到，虽然C语言没有Java那样的接口机制，但我们可以通过巧妙地运用结构体和函数指针来实现类似的功能。这再次印证了编程语言的灵活性和多样性。