C - 一个奇怪的Seg故障错误

Question

由于段错误，我无法编译它。使用树象限显示最大容量会给我那个错误。奇怪的是它在函数象限内工作，但在插入点不起作用。创建树功能很好，也是象限。但是当我尝试访问树象限内的某个东西时（这个象限不是NULL，我之前检查过）让我运行一个segfault问题通知。恐怕这是一个非常简单的错误，但我看不到它是什么。我试图在互联网上搜索（并没有发现任何东西），但我没有时间来完成这个完整的程序（并且我坚持了几个小时）。 任何人都可以帮助我吗？ 下面的代码：

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



     typedef struct dot{ 
      double x; 
      double y; 
     }Dot; 


     typedef struct quadrant{ 
      int max_capacity, used_capacity; 
      Dot max,min; 
      Dot * dots_; 
     }Quadrant; 


     typedef struct quad_node * Quad_node_Pointer; 

     typedef struct quad_node{ 
      Quadrant * key; 
      Quad_node_Pointer child[4]; 
      Quad_node_Pointer father; 
     }Quad_node; 


     typedef struct tree{ 
      Quad_node * end_; 
      Quad_node * start_; 
     }Tree; 





     void insert_dot(Tree * A, Dot b){ 
      printf("lalala\n"); 
      Quad_node * Aux, *Aux2, * New_leafs[4]; 
      Dot min_aux,max_aux; 
      int i; 
      Aux=(Quad_node_Pointer) malloc (sizeof(Quad_node)); 
      Aux2=(Quad_node_Pointer) malloc (sizeof(Quad_node)); 
      printf("lalala\n"); 
      //Here's the segfault line: 
      printf("this doesnt works %i",A->start_->key->max_capacity); 

     void Create_quadrant (Quadrant * A, int capacity, Dot max, Dot min){ 
      A=(Quadrant*)malloc(sizeof(Quadrant)); 
      A->dots_ = (Dot*) malloc (capacity * sizeof(Dot)); 
      int i; 
      for (i=0;i<capacity;i++){ 
       A->dots_[i].x=-1; 
       A->dots_[i].y=-1; 
      } 
      A->max_capacity=capacity; 
      //But here it works perfectly. What's the diference from the other that do 
      //a segfault? 
      printf("\n this works \n %i \n",A->max_capacity); 
      A->used_capacity=0; 
      A->max.x=max.x; 
      A->max.y=max.y; 
      A->min.y=min.y; 
      A->min.x=min.x; 
      } 

    void Create_tree (Tree * A, int capacity){ 
     int i; 
     Dot max,min; 
     max.x=DBL_MAX; 
     max.y=DBL_MAX; 
     min.x=0; 
     min.y=0; 
     A->end_ = (Quad_node_Pointer) malloc (sizeof(Quad_node)); 
     A->start_=(Quad_node_Pointer) malloc (sizeof(Quad_node)); 
      for (i=0;i<4;i++){ 
       A->start_->child[i]=A->end_; 
      } 
      A->start_->father=A->end_; 

     Create_quadrant(A->start_->key,capacity,max,min); 
    } 

这里的主，只是一个例子：

int main(int argc, char *argv[]) 
{ 
    Tree * A; 
    int i; 
    A = (Tree*) malloc (sizeof(Tree)); 
    Dot b,teste[10]; 
    b.x=5.0; 
    b.y=6.0; 
    Create_tree(A,8); 
    for (i=0;i<10;i++){ 
     teste[i].x=(double)2.0*i; 
     teste[i].y=(double)2.0*i; 
     insert_dot(A,teste[i]); 
    } 
    insert_dot(A,b); 
    free(A); 
    return EXIT_SUCCESS; 
} 

感谢您的阅读和/或帮助我。编辑： 只是为了记住，我忘记了。插入点函数在那里没有满。重点在于段故障问题。主要来自基于全功能运行的示例。对不起，有任何麻烦。但现在我的问题是这个奇怪的段错误。我认为该函数的其余部分是可以的，我省略了让我的问题更简单（并且与函数的其余部分无关）。

Answer 1

我们走吧......我将展示相关的代码，忽略其中不相关的行。

首先，分配存储空间和初始化树...

A = (Tree*) malloc (sizeof(Tree)); 
Create_tree(A,8); 

的Create_tree函数初始化上A东西：

A->end_ = (Quad_node_Pointer) malloc (sizeof(Quad_node)); 
    A->start_=(Quad_node_Pointer) malloc (sizeof(Quad_node)); 
    for (i=0;i<4;i++){ 
     A->start_->child[i]=A->end_; 
    } 
    A->start_->father=A->end_; 

好了，现在A->start_和A->end_有未初始化的存储，除了你已经在A->start_->child[]中设置了四个子指针。

此时，您致电Create_quadrant初始化A->start_->key，传递一个未初始化的指针。

Create_quadrant(A->start_->key,capacity,max,min); 

下面是函数声明：

void Create_quadrant (Quadrant * A, int capacity, Dot max, Dot min); 

有没有办法让你的新初始化象限取消入A->start_->key。显然，你想这样做，因为该函数的第一行做到这一点：

 A=(Quadrant*)malloc(sizeof(Quadrant)); 

这打破你的代码的模式，到目前为止，在那里你承担责任的分配数据，然后调用一个函数初始化它。如果你想让init函数返回一个在函数内部分配的指针，你需要返回它或者传递一个双指针。

所以选项1：

Quadrant * Create_quadrant (int capacity, Dot max, Dot min) 
{ 
    A=(Quadrant*)malloc(sizeof(Quadrant)); 
    //... 
    return A; 
} 

// Called like this: 
A->start_->key = Create_quadrant(capacity, max, min); 

和Option 2：

void Create_quadrant (Quadrant ** pA, int capacity, Dot max, Dot min) 
{ 
    A=(Quadrant*)malloc(sizeof(Quadrant)); 
    // ... 
    *pA = A;   
} 

// Called like this: 
Create_quadrant(&A->start_->key, capacity, max, min); 

我忘了提，选择0继续，因此到目前为止，你已经使用的惯例：

// Called like this: 
A->start_->key = (Quadrant*)malloc(sizeof(Quadrant)); 
Create_quadrant(A->start_->key, capacity, max, min); 

// And obviously you DON'T malloc a new A inside Create_quadrant(). 

Answer 2

我的猜测是，你不malloc荷兰国际集团足够的空间，为您Quadrant S，因为你只给他们尽可能多的房间内存为Quad_node会占用了，想必Quad_node。就拿起来比Quadrant更少的空间秒。