c - 在C编程中使用oop

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center。
                            
                        
                    
                
                                7年前关闭。
            
                    

gcc (GCC) 4.7.2
c89

我正在练习在C中使用一些面向对象的样式。因为我想对一些较大的项目进行此操作。

但是，在下面的代码中，我有一个父结构车和一个子sport_cars。但是，所有常用服装或汽车结构都将出现在子结构中。

我有一个问题，那就是init和destory函数。由于他们是共同的，我希望我的孩子继承继承和破坏的结构。但是我认为我做错了。

car->init = init_car;

因为我有指向init_car的init函数指针，所以在我看来并不正确。

非常感谢您的任何建议，

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

typedef struct tag_car car_t;
struct tag_car {
    size_t wheels;
    char *name;

    void (*init)(void *self);
    void (*destroy)(void *self);
    size_t (*wheels_get)(void *self);
    void (*wheels_set)(void *self, size_t num_wheels);
};

typedef struct tag_sports sports_t;
struct tag_sports {
    car_t base_car;

    size_t top_speed;
    size_t (*top_speed_get)(void *self);
    void (*top_speed_set)(void *self, size_t max_top_speed);
};

void destroy_car(void *self)
{
    car_t *car = self;

    free(car);
}

void init_car(void *self)
{
    car_t *car = car;

    car->wheels = 4;
    car->name = NULL;

    car->init = init_car;
    car->destroy = destroy_car;

}

size_t wheels_count_get(void *self)
{
    car_t *car = self;

    return car->wheels;
}

void wheels_count_set(void *self, size_t num_wheels)
{
    car_t *car = self;

    car->wheels = num_wheels;
}

size_t sports_top_speed_get(void *self)
{
    sports_t *sports_car = self;

    return sports_car->top_speed;
}

void sports_top_speed_set(void *self, size_t max_top_speed)
{
    sports_t *sports_car = self;

    sports_car->top_speed = max_top_speed;
}

sports_t* init_sports()
{
    sports_t *sports_car = malloc(sizeof(sports_t));

    /* Parent struct */
    sports_car->base_car.init = init_car;
    sports_car->base_car.destroy = destroy_car;
    sports_car->base_car.wheels_get = wheels_count_get;
    sports_car->base_car.wheels_set = wheels_count_set;

    /* Child struct */
    sports_car->top_speed_set = sports_top_speed_set;
    sports_car->top_speed_get = sports_top_speed_get;

    return sports_car;
}

int main(void)
{
    sports_t *farreri = init_sports();
    sports_t *lamborghini = init_sports();

    farreri->base_car.wheels_set(farreri, 10);
    farreri->top_speed_set(farreri, 240);

    printf("farreri has wheel count [ %ld ]\n", farreri->base_car.wheels_get(farreri));
    printf("Farreri has a top speed [ %ld ]\n", farreri->top_speed_get(farreri));

    lamborghini->base_car.wheels_set(lamborghini, 6);
    lamborghini->top_speed_set(lamborghini, 220);

    printf("lamborghini has wheel count [ %ld ]\n", lamborghini->base_car.wheels_get(lamborghini));
    printf("Lamborghini has a top speed [ %ld ]\n", lamborghini->top_speed_get(lamborghini));

    farreri->base_car.destroy(farreri);
    lamborghini->base_car.destroy(lamborghini);

    return 0;
}

最佳答案

在您的init_car行中

car->init = init_car;
car->destroy = destroy_car;

不应该存在。您正在将构造行为与初始化混合在一起。在C ++中，构造函数负责完成这两项工作。如果要模拟相同的行为，则应公开分配接口（例如，称为construct），该接口将分配内存（您的malloc并将对象“方法”设置为适当的函数）和初始化接口（它将执行初始化操作：car->wheels = 4; car->name = NULL;）。分配方法可以调用初始化方法来实现C ++行为。您将拥有以下内容：

void init_car(void *self)
{
    car_t *car = self;

    car->wheels = 4;
    car->name = NULL;
}

sports_t* construct()
{
    sports_t *sports_car = malloc(sizeof(sports_t));

    /* Set the methods */
    sports_car->base_car.init = init_car;
    sports_car->base_car.destroy = destroy_car;
    sports_car->base_car.wheels_get = wheels_count_get;
    sports_car->base_car.wheels_set = wheels_count_set;

    /* initialize the object */
    sports_car->base_car.init();

    return sports_car;
 }

int main(void)
{
    /* construct and init the objects */
    sports_t *ferrari = construct();
    sports_t *lamborghini = construct();

    /* do your manipulations */

    /* destroy the objects */
    ferrari->base_car.destroy(farreri);
    lamborghini->base_car.destroy(lamborghini);

    return 0;
}

如果您不希望构造初始化对象，则仅不要从construct调用初始化，而是在构造之后通过调用sports_car->base_car.init调用它。

关于c - 在C编程中使用oop ，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/13511847/