Question

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

    #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 );

选项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足够的空间，因为你只给予他们尽可能多的内存空间，而Quad_node会占用，并且大概Quad_node占用的空间小于Quadrant s。

C - 奇怪的Seg故障错误

2 个答案: