c - main 之前的段错误

Question

所以我遇到了一个问题，在我的任何主程序实际运行之前，我的代码以某种方式导致了段错误。我以前从未发生过这种情况，而且我几乎没有四分之一的编码经验，所以我不确定我是否做错了什么。一切都可以编译，至少在我的计算机上，但是在运行它时，我的 main 永远不会到达。

上下文:我正在尝试连接邻接矩阵中的顶点和边，然后使用 Prim 的算法构建 MST，但那是稍后的事。我构建了一个头文件，该文件最初仅包含对结构和函数的typdef 调用。但是，我将结构定义切换到头文件，因为我遇到了内存错误；因此我认为结构存在问题。

图.h:

//Leland Wong 00000897031
//graph header file



#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

#ifndef GRAPH_H
#define GRAPH_H

typedef struct vertex
{
    double longitude;
    double latitude;
    char city[30];
    int index;
    int visited; //0: not visited, 1: visited, 2: visited
    struct edge* nexte;
    struct vertex* nextv;
    double projected;
}VERTEX;


typedef struct edge
{
    struct vertex* start;
    struct vertex* destination;
    double distance;
    struct edge* nexte;
}EDGE;


typedef struct graph
{
    struct vertex* list[756];
    struct edge* matrix[756][756];
}GRAPH;


/*
typedef struct vertex VERTEX;
typedef struct edge EDGE;
typedef struct graph GRAPH;
*/

double findDistance(VERTEX* v1, VERTEX* v2); //compute the distance between two locations
EDGE* connect(VERTEX* v1, VERTEX* v2); //connects two vertices and returns the connecting EDGE
GRAPH primMatrix(GRAPH *g); //connects all vertices using Prim's Algorithm in an adjacency matrix
//void lPrimConnect(VERTEX v); //connects all vertices using Prim's Algorithm in an adjacency list
EDGE* findSmallestEdge(VERTEX v, GRAPH *g); //finds the smallest EDGE connected to v


#endif

graph.c:包含我所有函数的实现

//functions

//computes the distance between v1 and v2
double findDistance(VERTEX* v1, VERTEX* v2)
{
    printf("findDistance");
    double long1 = v1->longitude;
    double long2 = v2->longitude;
    double lat1 = v1->latitude;
    double lat2 = v2->latitude;
    double distance = 0;

    if(long1 < 0)
        long1 += 360;
    if(long2 < 0)
        long2 += 360;

    distance = powf((long1-long2), 2) + powf((lat1 - lat2), 2);
    distance = sqrt(distance);
    return distance;
}

//creates and returns an edge that connects v1 and v2
EDGE* connect(VERTEX* v1, VERTEX* v2)
{
    printf("connect");
    EDGE *new; 
    new->start = v1;
    new->destination = v2;
    new->distance = findDistance(v1, v2);
    return new;
}


//finds smallest edge connected to v in GRAPH g
EDGE* findSmallestEdge(VERTEX v, GRAPH *g)
{
    printf("findSmallestEdge");
    EDGE *tempe;
    int i, index;
    index = v.index;

    //set tempe equal to the first edge connected to v
    tempe = g->matrix[index][0];
    //find smallest edge connected to v
    for(i = 0; i < 756; i++)
    {
        if(g->matrix[index][i] -> distance < tempe->distance && g->list[index]->visited == 0)
        {
            tempe = g->matrix[index][i];
        }
    }
    return tempe;
}

//creates an MST out of GRAPH g using Prim's algorithm
GRAPH primMatrix(GRAPH *g)
{
    printf("primMatrix");
    GRAPH new; // = malloc(sizeof(GRAPH));
    EDGE *smallest;
    EDGE *tempe;
    int i, x;
    i = 1;
    x = 0;

    new.list[0] = g->list[0];   //add root node to MST
    g->list[0]->visited = 2;
    smallest = findSmallestEdge(*new.list[0], g); 
    new.matrix[0][smallest->destination->index] = smallest;
    //MST will contain all 756 nodes, so run this 755 times to ensure all nodes are reached
    while(i < 756)
    {
        x = 0;
        smallest = findSmallestEdge(*new.list[i], g);
        //i = number of vertices already reached
        while(x < i)
        {
            tempe = findSmallestEdge(*new.list[x], g);
            if(tempe -> distance < smallest -> distance)
            {
                smallest = tempe;
            }
            x++;
        }
        new.list[i] = smallest -> destination;
        smallest -> destination -> visited = 2;
        new.matrix[smallest->start->index][smallest->destination->index] = smallest;
        i++;
    }
    return new;
}

graphmatrixmain.c:我构建图表的主要函数

#include "graph.h"

int main(int argc, char* argv[])
{
    FILE *fp;
    static GRAPH g;
    char buffer[200];
    int i, j;
    char city[30];
    char *long1;
    char *lat1;

    if(argc == 1)
    {   
        printf("could not open file\n");
        return 0;
    }

    else
        fp = fopen(argv[1], "r");

    //read in line of data from txt file, build a new vertex, and insert into list
    while(fgets(buffer, 200, fp) != NULL)
    {
        VERTEX *new =  malloc(sizeof(VERTEX)); 
        printf("%s", buffer);
        sscanf(buffer, "%s %s %s", city, long1, lat1);
        //sscanf(buffer, "%[^\t]\t%[^\t]\t%s", city, long1, lat1); 
        printf("scanned in data\n");
        new->longitude = atof(long1);
        new->latitude = atof(lat1);
        new->index = i;
        g.list[i] = new;
        printf("%s: (%lf, %lf)", new->city, new->longitude, new->latitude);
        i++;
    }
    //create EDGE and make connects between every VERTEX in list
    for(i = 0; i < 756; i++)
    {
        for(j = 0; j < 756; j++)
        {
            g.matrix[i][j] = connect(g.list[i], g.list[j]);
            if(j == 0)
            {
                g.list[i]->nexte = g.matrix[i][j];
            }
        }
    }
    return 0;
}

如果有必要，这是我正在读取的文件:city.txt 它总共包含 756 个条目，但就代码而言，大小不应该相关

Shanghai    121.47  31.23
Bombay  72.82   18.96
Karachi 67.01   24.86
Buenos Aires    -58.37  -34.61
Delhi   77.21   28.67
Istanbul    29  41.1
Manila  120.97  14.62
Sao Paulo   -46.63  -23.53
Moscow  37.62   55.75

Answer 1

I've been running into a problem where somehow my code is causing segmentation faults before any of my main actually runs.

通常，这意味着您的 main 尝试放入自动存储区域的数据结构溢出堆栈。在您的情况下，看起来 GRAPH 是执行此操作的合适嫌疑人:它有一个包含 571536 个指针的 2D 数组，这很可能在您的 main 之前溢出堆栈> 有机会开始。

此问题的一个解决方案是将 GRAPH 移至 static 区域:因为您在 main 中分配它，所以它将无论如何，它只是它的一个实例，因此将其声明为静态应该可以解决问题:

static GRAPH g;

您可能还想使用 malloc 在动态区域中分配它，但在这种情况下，这可能并不重要。