C语言 分段错误背后的原因是什么?

Question

我无法在任何调试器中调试以下代码，因为它显示"在启动期间程序以分段错误 SIGEGV 结束">

这是用于查找图形是否为二分图的代码。

#include <stdlib.h>
#define ll long long
ll queue[1000000000];
ll last=0;
ll top=0;
int qempty()
{
if(top==last) return 1;
else return 0;
}
void emptyq()
{
top=0;
last=0;
}
void enqueue(long long x)
{
queue[top++] = x;
}
void dequeue()
{
queue[last++];
}

在这里，我定义了队列。以下是图形的函数。

struct node
{
ll vertex;
struct node* next;
};
struct node* createNode(ll v)
{
struct node *newnode = malloc(sizeof(struct node));
newnode->vertex = v;
newnode->next = NULL;
return newnode;
}
struct Graph
{
ll numVertices;
struct node** adjLists;
};
struct Graph *createG (ll vertices)
{
struct Graph *G = malloc(sizeof(struct Graph));
G->numVertices = vertices;
G->adjLists = malloc(vertices*sizeof(struct node*));
for(int i=0;i<vertices;i++) G->adjLists[i]=NULL;
return G;
}
void add(struct Graph* G, ll src, ll dest)
{
struct node* newnode = createNode(dest);
newnode->next = G->adjLists[src];
G->adjLists[src] = newnode;
newnode = createNode(src);
newnode->next = G->adjLists[dest];
G->adjLists[dest] = newnode;
}

这是用于检查广度优先搜索同一层之间的边缘的功能。

ll BU(struct Graph *G, ll src, ll *color)
{ 
color[src] = 1;
emptyq();
enqueue(src);
while (qempty); 
{ 
ll u = queue[last];
dequeue;
struct node *y = G->adjLists[u];
while(y)
{ 
if(color[y->vertex]==-1)
{ 
color[y->vertex] = 1-color[u]; 
enqueue(y->vertex);
} 
else if (color[y->vertex] == color[u]) return 0;
y=y->next;
}
} 
return 1; 
}
ll B(struct Graph *G) 
{ 
ll x = G->numVertices;
ll *color = malloc(x*sizeof(long long));
for (ll i = 0; i < x; ++i) color[i] = -1; 
for (ll i = 0; i < x; i++) 
if (color[i] == -1) 
if (BU(G,i,color)==0) 
return 0; 
else  return 1; 
} 

这是主要功能。我在 main 函数的第一行添加了一个断点，但它拒绝继续。

int main()
{
ll t;
scanf("%lld",&t);
printf("%lld",t);
while(t--)
{
ll V,E;
scanf("%lld %lld",&V,&E);
printf("%lld %lld",V,E);
struct Graph *G = createG(V);
while(E--)
{
ll x,y;
scanf("%lld %lld",&x,&y);
add(G,x,y);
}
if(B(G)==1) printf("Yesn");
else printf("Non");
}
return 0;
}

Answer 1

您可能希望减小此大小：

ll queue[1000000000];

到更合理的值，说1024.

Answer 2

进程的静态分配数据的最大大小通常很小。这是地址空间映射的固有问题，如果取决于系统，则确切大小，但实际上不要超过几兆字节。

您可以执行以下操作之一：

• 动态分配内存
• 使用较少的静态内存块
• 您可以更改同样高度依赖于平台的设置，从而增加初始静态数据大小。