-2

由于段错误，我无法编译它。使用树象限来显示最大容量给了我这个错误。奇怪的是，它在 Quadrant 函数中起作用，但在插入点中不起作用。创建树功能很好，象限也很好。但是，当我尝试访问树象限内的某些内容时（象限不是 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;
}

感谢您阅读或/和帮助我。

编辑：记住，我忘了。插入点功能在那里不完整。重点是段错误问题。主要来自它基于完整功能运行的示例。很抱歉有任何麻烦。但我现在的问题是这个奇怪的段错误。我认为函数的其余部分没问题，我省略了让我的问题更简单（并且与函数的其余部分无关）。

4

2 回答 2

2

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

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

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().
于 2013-03-21T03:21:11.707 回答
0

我的猜测是你没有malloc为你的 s 提供足够的空间Quadrant，因为你只给它们提供了尽可能多的内存空间Quad_node，并且可能Quad_nodes 占用的空间比Quadrants 少。

于 2013-03-21T03:04:13.563 回答