c - 如何解决三个头文件之间的循环依赖

Question

这个问题已经有答案了:

Resolve circular typedef dependency? (6 个回答)

已关闭 3 年前。

请注意:此类问题已在 SO 上提出，但我相信我的问题有所不同，因为单独使用部分 struct X* 的解决方案类型并不能解决这个问题。我已经阅读了其他答案，但没有找到解决方案，所以请耐心等待。

我遇到以下循环依赖问题(导致编译错误)，但无法解决。

value.h依赖 chunk.h ，它依赖于value_array.h ，它依赖于value.h .

原来是-chunk.h以前直接依赖value.h以及。我已经通过 addConstant 成功消除了这种依赖性。拍个struct Value*而不是Value .

但我仍然没有弄清楚如何消除 value_array.h 之间的依赖关系和value.h 。问题在于 value_array.c 中起作用需要知道sizeof(Value) ，因此他们的签名不能采用部分类型 struct Value* .

欢迎提出建议。

稍微简化的代码:

value.h

#ifndef plane_value_h
#define plane_value_h

#include "chunk.h"

typedef enum {
    VALUE_NUMBER,
    VALUE_BOOLEAN,
    VALUE_CHUNK
} ValueType;

typedef struct Value {
    ValueType type;
    union {
        double number;
        bool boolean;
        Chunk chunk;
    } as;
} Value;

#endif

chunk.h

#ifndef plane_chunk_h
#define plane_chunk_h

#include "value_array.h"

typedef struct {
    uint8_t* code;
    ValueArray constants;
    int capacity;
    int count;
} Chunk;

void initChunk(Chunk* chunk);
void writeChunk(Chunk* chunk, uint8_t byte);
void setChunk(Chunk* chunk, int position, uint8_t byte);
void freeChunk(Chunk* chunk);
int addConstant(Chunk* chunk, struct Value* constant);

#endif

value_array.h

#ifndef plane_value_array_h
#define plane_value_array_h

#include "value.h"

typedef struct {
    int count;
    int capacity;
    Value* values;
} ValueArray;

void value_array_init(ValueArray* array);

void value_array_write(ValueArray* array, Value value);

void value_array_free(ValueArray* array);

#endif

value_array.c

#include "value_array.h"

void value_array_init(ValueArray* array) {
    array->values = NULL;
    array->count = 0;
    array->capacity = 0;
}

void value_array_write(ValueArray* array, Value value) {
    if (array->count == array->capacity) {
        int oldCapacity = array->capacity;
        array->capacity = GROW_CAPACITY(oldCapacity);
        array->values = reallocate(array->values, sizeof(Value) * oldCapacity, sizeof(Value) * array->capacity, "Dynamic array buffer");
    }

    array->values[array->count++] = value;
}

void value_array_free(ValueArray* array) {
    deallocate(array->values, array->capacity * sizeof(Value), "Dynamic array buffer");
    value_array_init(array);
}

Answer 1

ValueArray 不必知道值是什么，因为它只包含一个不透明的指针。不要包含 ValueArray.h 中的 Value.h

一个问题是，当 C++ 中有像 vector 这样的模板类可以为您执行此操作时，为什么要执行此操作，但如果您决定用 C 编写自己的列表，那么

#pragma once
struct Value;

typedef struct {
    int count;
    int capacity;
    struct Value* values;
} ValueArray;

void value_array_init(ValueArray* array);
void value_array_write(ValueArray* array, const Value* value);
void value_array_free(ValueArray* array);




#include "value_array.h"
#include "value.h"

void value_array_init(ValueArray* array) {
    array->values = NULL;
    array->count = 0;
    array->capacity = 0;
}

void value_array_write(ValueArray* array, const Value* value) {
    if (array->count == array->capacity) {
        int oldCapacity = array->capacity;
        array->capacity = GROW_CAPACITY(oldCapacity);
        array->values = reallocate(array->values, sizeof(Value) * oldCapacity, sizeof(Value) * array->capacity, "Dynamic array buffer");
    }

    array->values[array->count++] = value;
}

void value_array_free(ValueArray* array) {
    deallocate(array->values, array->capacity * sizeof(Value), "Dynamic array buffer");
    value_array_init(array);
}

换句话来说，你只是认为这不是与其他问题的重复，答案是，当然是。唯一的另一种可能性是您有一个递归定义，其中一个对象包含其他对象，在这种情况下您的代码将是不可能的。

您不想编写按值传递值的函数。不，鉴于您的循环定义，它不起作用，而且速度很慢。为什么要复制堆栈上的大对象？通过引用传递它。