C 指向结构的嵌套指针包含指向包含结构的指针？_C_Pointers_Struct_Unions_Double Pointer

C 指向结构的嵌套指针包含指向包含结构的指针？

c pointers struct

C 指向结构的嵌套指针包含指向包含结构的指针？,c,pointers,struct,unions,double-pointer,C,Pointers,Struct,Unions,Double Pointer,首先，我有一个结构： typedef struct { int type; union expr value; }lval; 以及定义如下的联合，以节省空间： union expr{ long num; char* err; char* sym; sexpr* sexpr1; }; 在sexpr*中 typedef struct { int count; struct lval** cell; }sexpr; 我试着使用它如下

首先，我有一个结构：

typedef struct {
    int type;
    union expr value;
}lval;

以及定义如下的联合，以节省空间：

union expr{
    long num;
    char* err;
    char* sym;
    sexpr* sexpr1;
};

在

sexpr*

中

typedef struct {
    int count;
    struct lval** cell;
}sexpr;

我试着使用它如下

void lval_del(lval* v){
     lval_del(v->value.sexpr1->cell[i]); 
}

但我的编译器给了我一个警告：

参数类型不匹配：不兼容指针类型为“lval*”和“struct anonymous:：lval*”

当我尝试下面这样的代码时

lval* lval_add(lval* v,lval* x) {
    v->value.sexpr1->cell = realloc(v->value.sexpr1->cell, sizeof(lval*)*v->value.sexpr1->count);
    v->value.sexpr1->cell[v->value.sexpr1->count-1]=x;
    return v;
}

我收到了同样的警告

我忽略了警告并成功编译了它，但当我运行它时，它崩溃了。我认为是问题引起了警告。我怎样才能解决它

编辑：我编译的完整代码如下：

typedef struct {
   int count;
   struct lval** cell;
}sexpr;

union expr{
    long num;
    char* err;
    char* sym;
    sexpr* sexpr1;
};

typedef struct {
    int type;
    union expr value;
}lval;

void lval_del(lval* v){
    switch (v->type) {
        case LVAL_NUM:
            break;
        case LVAL_ERR:
            free(v->value.err);
            break;
        case LVAL_SYM:
            free(v->value.sym);
            break;
        case LVAL_SEXPR:
            for (int i=0;i<v->value.sexpr1->count;i++){
                lval_del(v->value.sexpr1->cell[i]);
            }
            free(v->value.sexpr1->cell);
        default:break;
    }
}

lval* lval_add(lval* v,lval* x) {
    v->value.sexpr1->count ++;
    v->value.sexpr1->cell = realloc(v->value.sexpr1->cell,sizeof(lval*)*v->value.sexpr1->count);
    v->value.sexpr1->cell[v->value.sexpr1->count-1]=x;
    return v;
}

typedef结构{
整数计数；
结构层**单元；
}sexpr；
联合出口{
长数；
字符*错误；
字符*sym；
sexpr*sexpr1；
};
类型定义结构{
int型；
联合表达式值；
}左心室；
无效lval_del（lval*v）{
开关（v->类型）{
案例LVAL_NUM：
打破
案例LVAL_错误：
自由（v->value.err）；
打破
案例LVAL_SYM：
自由（v->value.sym）；
打破
案件LVAL_SEXPR：
对于（int i=0；ivalue.sexpr1->count；i++）{
lval_del（v->value.sexpr1->cell[i]）；
}
自由（v->value.sexpr1->单元格）；
默认：中断；
}
}
lval*lval_添加（lval*v，lval*x）{
v->value.sexpr1->count++；
v->value.sexpr1->cell=realloc（v->value.sexpr1->cell，sizeof（lval*）*v->value.sexpr1->count）；
v->value.sexpr1->cell[v->value.sexpr1->count-1]=x；
返回v；
}

编辑：7.24 我通过按以下顺序定义它们来消除警告。复杂结构对我来说是一场噩梦，我放弃了处理指针问题。下面是我的新代码，仍然带有错误的指针

struct init_lval;
struct init_sexpr;
typedef struct init_sexpr sexpr;
union expr{
    long num;
    char* err;
    char* sym;
    sexpr* sexpr1;
};
typedef struct init_lval lval;

struct init_lval
{
    int type;
    union expr value;
};

struct init_sexpr{
   int count;
   lval** cell;
};
lval* lval_add(lval* v, lval* x) {
    v->value.sexpr1->count ++;
    v->value.sexpr1->cell = realloc(v->value.sexpr1->cell,sizeof(lval*)*v->value.sexpr1->count);
    v->value.sexpr1->cell[v->value.sexpr1->count-1]=x;
    return v;
}
void lval_del(lval* v){
    switch (v->type) {
        case LVAL_NUM:
            break;
        case LVAL_ERR:
            free(v->value.err);
            break;
        case LVAL_SYM:
            free(v->value.sym);
            break;
        case LVAL_SEXPR:
            for (int i=0;i<v->value.sexpr1->count;i++){
                lval_del(v->value.sexpr1->cell[i]);
            }
            free(v->value.sexpr1->cell);
            free(v->value.sexpr1);
        default:break;
    }
    free(v);
}

struct init_lval；
结构初始化sexpr；
typedef struct init_sexpr sexpr；
联合出口{
长数；
字符*错误；
字符*sym；
sexpr*sexpr1；
};
typedef struct init_lval lval；
结构初始值
{
int型；
联合表达式值；
};
struct init_sexpr{
整数计数；
lval**细胞；
};
lval*lval_添加（lval*v，lval*x）{
v->value.sexpr1->count++；
v->value.sexpr1->cell=realloc（v->value.sexpr1->cell，sizeof（lval*）*v->value.sexpr1->count）；
v->value.sexpr1->cell[v->value.sexpr1->count-1]=x；
返回v；
}
无效lval_del（lval*v）{
开关（v->类型）{
案例LVAL_NUM：
打破
案例LVAL_错误：
自由（v->value.err）；
打破
案例LVAL_SYM：
自由（v->value.sym）；
打破
案件LVAL_SEXPR：
对于（int i=0；ivalue.sexpr1->count；i++）{
lval_del（v->value.sexpr1->cell[i]）；
}
自由（v->value.sexpr1->单元格）；
自由（v->value.sexpr1）；
默认：中断；
}
免费（五）；
}

结构层**单元

无效，您没有

struct lval

，您

typedef

将匿名结构添加到

lval

将其更改为

lval**单元格
您也不会在add
函数中增加v->value.sexpr1->count
，因此它将始终写入相同的位置。
struct lval**cell
无效，您没有struct lval
，您typedef
将匿名结构添加到lval

将其更改为lval**单元格
在add
函数中，您也不会递增v->value.sexpr1->count
，因此它将始终写入相同的位置。
参数类型不匹配：不兼容的指针类型“lval*”和“struct anonymous:：lval*”
上面的警告是因为您有一个匿名结构。尝试：
typedef struct lval {
    int type;
    union expr value;
};

这至少可以解决此警告。
参数类型不匹配：指针类型“lval*”和“struct anonymous:：lval*”不兼容
上面的警告是因为您有一个匿名结构。尝试：
typedef struct lval {
    int type;
    union expr value;
};

这至少可以解决此警告。
这里的问题是realloc。您正在尝试重新锁定从未被删除的内存。此外，在表达式中使用v->value.sexpr1->cell

试试这个：
lval* lval_add(lval* v,lval* x) {
    v->value.sexpr1->count ++;
    if(v->value.sexpr1->cell == NULL) {
        v->value.sexpr1->cell = malloc(sizeof(lval*)*v->value.sexpr1->count);
    } else {
        v->value.sexpr1->cell = realloc(v->value.sexpr1->cell,sizeof(lval*)*v->value.sexpr1->count);
    }
    v->value.sexpr1->cell[v->value.sexpr1->count-1]= (struct lval*)x;
    return v;
}

并初始化传递给lval\u add
的lval
，如下所示：
lval *z = malloc(sizeof(lval));
z->value.sexpr1 = malloc(sizeof(sexpr));
z->value.sexpr1->cell= NULL;

希望这有帮助
 这里的问题是realloc。您正在尝试重新锁定从未被删除的内存。此外，在表达式中使用v->value.sexpr1->cell

试试这个：
lval* lval_add(lval* v,lval* x) {
    v->value.sexpr1->count ++;
    if(v->value.sexpr1->cell == NULL) {
        v->value.sexpr1->cell = malloc(sizeof(lval*)*v->value.sexpr1->count);
    } else {
        v->value.sexpr1->cell = realloc(v->value.sexpr1->cell,sizeof(lval*)*v->value.sexpr1->count);
    }
    v->value.sexpr1->cell[v->value.sexpr1->count-1]= (struct lval*)x;
    return v;
}

并初始化传递给lval\u add
的lval
，如下所示：
lval *z = malloc(sizeof(lval));
z->value.sexpr1 = malloc(sizeof(sexpr));
z->value.sexpr1->cell= NULL;

希望这有帮助
 我忽略了警告并成功地遵守了它。
。所有问题的根源。除了警告之外，lval_del是否真的是递归的？如果是，您认为递归应该在运行时何时停止？您是否忘记预先声明struct lval？这两个结构是递归定义的，但我在添加结构lval时尝试了您的方法；在sexpr之前，然后在lval*下面编辑到struct lval*，它仍然会崩溃。我可能不明白你的真正意思，希望你能给出你的代码。你想用这段代码实现什么样的数据结构？cell
是否真的需要成为lval**
？我忽略了警告并成功地遵守了它。
。所有问题的根源。除了警告之外，lval\u del
真的是递归的吗？如果是，您认为递归应该在运行时何时停止？您是否忘记预先声明struct lval？这两个结构是递归定义的，但我在添加结构lval时尝试了您的方法；在sexpr之前，然后在lval*下面编辑到struct lval*，它仍然会崩溃。我可能不明白你的真正意思，希望你能给出你的代码。你想用这段代码实现什么样的数据结构？cell
是否真的需要成为一个lval**
？它不好。更改后，compli