C 寻找悬空的指针

我的代码有问题。我得到了一个分段错误，我知道这是一个悬空指针问题（通常）或内存分配错误。编译器没有显示问题可能出现在哪一行，因此我的问题是如何检测这些问题以供进一步关注？我的问题在代码中的什么地方？ 这是我的密码：

`#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ARRAY_SIZE(a) sizeof(a)/sizeof(a[0])
#define ALPHABET_SIZE (256)
#define CHAR_TO_INDEX(c) ((int)c - (int)'a')
#define LEVELS 255

// trie node
struct n
{
    char value,level,isLeaf;
    struct n* children[ALPHABET_SIZE];
    struct n* failLink;
};
typedef struct n node;
//trie
struct t
{
    node *root;
    int count;
};
typedef struct t trie;

void bytesCpy(char *to, char *from, int len)
{
    int i;
    for(i=0;i<len;i++)
    {
        to[i]=from[i];
    }
}

// Returns new trie node (initialized to NULLs)
node *getNode(trie *t, char value,char level)
{
    node *pNode = NULL;
    pNode = (node *)malloc(sizeof(node));
    if (pNode)
    {
        printf("ok\n");
        int i;
        for (i = 0; i < ALPHABET_SIZE; i++)
        {
            pNode->children[i] = NULL;
        }
        pNode->failLink = t->root;
        pNode->value=value;
        pNode->level=level;
        pNode->isLeaf=0;
    }
    else
        printf("error\n");
    return pNode;
}
// Initializes trie (root is dummy node)
void initialize(trie *t)
{
    t->root = getNode(t, '[', 0);
    //t->count = 0;
}
// If not present, inserts key into trie
// If the key is prefix of trie node, just marks leaf node
void insert(trie *t, char key[], int len)
{
    int level;
    char value;
    node *node = t->root;

    for (level = 0; level<len; level++)
    {
        value = key[level];
        printf("value: %c\n",value);
        if (node->children[value] == NULL)
        {
            node->children[value] = getNode(t, value, level+1);
        }
        node = node->children[value];
    }
    node->isLeaf=1;

}
// Returns non zero, if key presents in trie
int search(trie *t, char key[])
{
    int level;
    int length = strlen(key);
    int value;
    node *node;
    node = t->root;
    for (level = 0; level < length; level++)
    {
        value =  key[level];//CHAR_TO_INDEX(key[level]);
        if (!node->children[value])
        {
            node = node->failLink;
            return 0;
        }
        node = node->children[value];
    }
    return (0 != node);// && node->value);
}

void search1(trie *t, char *c, int len)
{
    node *curNode = t->root;
    int i;

    for(i=0; i<=len; i++)
    {
        printf("i=%d curnode=%p\n",i,curNode);
        if(curNode->isLeaf) //leaf: cuvant gasit
        {
            printf("if1 curGasit \n");
            do{
                curNode=curNode->failLink;
                if(curNode->isLeaf)
                    printf("if1 curGasit \n");
                else break;
            }while(1);
            continue;
        }
        else //nu e gasit inca
        {
            if(curNode->children[c[i]]==NULL) //fail
            {
                printf("if2\n");
                curNode = curNode->failLink;
                continue;
            }
            else //litera gasita: go on
            {
                printf("el2\n");
                curNode=curNode->children[c[i]];
            }
        }
    }
    printf("end of search\n");
}

node* searchAux(trie *t, node *curRoot, char cuv[], char len, int level ,int failLevel)
{
    char cuvAux[1024];
    bytesCpy(cuvAux,cuv,len);


    printf("searchAux level:%d cuvAux:%s curRootLevel:%d\n",level,cuvAux,curRoot->level);
    if(cuvAux[level+1] == '\0')  //got to the end of cuvAux
    {
        printf("1st if\n");
        return curRoot;
    }

    if(curRoot->children[cuvAux[level+1]] == NULL)   //fail: letter not found
    {
        printf("3rd if\n");
        return searchAux(t, t->root, &cuvAux[failLevel+1], len, 0, failLevel+1);
    }
    else                          //letter found: go on
    {
        printf("3rd else\n");
        if(cuvAux[level+2] == '\0') //the found letter was the last of the string
        {
            printf("4th if\n");
            return curRoot->children[cuvAux[level+1]]; //return final pointer
        }
        else //the found letter was not the last of the string: continue with the next one
        {
            printf("4th else\n");
            return searchAux(t, curRoot->children[cuvAux[level+1]], cuvAux, len, level+1, failLevel);
        }
    }
}

void createFailLinks(trie *t, node* curRoot, char cuv[], int level)
{
    int i;
    char cuvAux[1024];

    bytesCpy(cuvAux,cuv,1024);

    if(curRoot == NULL)
        return;

    for(i=0;i<ALPHABET_SIZE/*curRoot->children[i] != NULL*/;i++)
    {
        if(curRoot->children[i] == NULL)
            continue;
        else
        {
            cuvAux[level] = curRoot->children[i]->value;
            printf("createFailLinks  %c%d\n",cuvAux[level],curRoot->children[i]->level);
            curRoot->children[i]->failLink = searchAux(t, t->root, cuvAux, level+1, 0, 0);
            createFailLinks(t,curRoot->children[i],cuvAux,level+1);
        }
    }
    printf("got\n");

}

void printTrie(node *curRoot)
{
    int i;

    if(curRoot == NULL)
        return;

    printf("%c: ", curRoot->value);

    for(i=0;i<ALPHABET_SIZE;i++)
        if(curRoot->children[i] != NULL)
        {
            printf("%c ", i);
        }
    printf("\n");

    for(i=0;i<ALPHABET_SIZE;i++)
        if(curRoot->children[i] != NULL)
        {
            printTrie(curRoot->children[i]);
        }
}

void checkLinks(node* curRoot)
{
    int i;
    if(curRoot == NULL)
        return;
    printf("node %c%d: ",curRoot->value,curRoot->level);
    for(i=0;i<256;i++)
        if(curRoot->children[i] != NULL)
            printf("\n\t%c%d:%c%d",curRoot->children[i]->value, curRoot->children[i]->level, curRoot->children[i]->failLink->value,curRoot->children[i]->failLink->level);
    printf("\n");
    for(i=0;i<256;i++)
        if(curRoot->children[i] != NULL)
            checkLinks(curRoot->children[i]);
}

int mai()
{
    FILE *fd = fopen("VirusDatabase.txt","r");//O_RDONLY);
    int i;
    char c;


    for(i=0;i<1000;i++)
    {
        fscanf(fd, "%c", &c);

        printf("%c",c);
    }
}

int main()
{
    // Input keys (use only 'a' through 'z' and lower case)
    char keys[][1024] = { "he", "she", "her", "his", "heres"};
    char cuv[] = {'\0','\0','\0','\0','\0','\0'};
    trie t;
    char output[][32] = { "Not present in trie", "Present in trie" };
    int i;
    char text[]={"andreiherutshevlastashecristihiskatjaheres"};

    initialize(&t);


    // Construct trie
    for (i = 0; i < ARRAY_SIZE(keys); i++)
    {
        insert(&t, keys[i], strlen(keys[i]));
    }

    createFailLinks(&t, t.root, cuv, 0);


    printTrie(t.root);
    printf("\n\n");

    checkLinks(t.root);
    search1(&t, text, strlen(text));

    return 0;
    // Search for different keys
    printf("%s --- %s\n", "abcd", output[search(&t, "abcd")]);
    printf("%s --- %s\n", "ab", output[search(&t, "ab")]);
    printf("%s --- %s\n", "ccdd", output[search(&t, "ccdd")]);
    printf("%s --- %s\n", "thaw", output[search(&t, "thaw")]);
    return 0;
    char a = getchar();
}`

`include
#包括
#包括
#定义数组大小（a）sizeof（a）/sizeof（a[0]）
#定义字母表大小（256）
#定义字符到索引（c）（（int）c-（int）“a”）
#定义级别255
//三节点
结构
{
字符值、级别、isLeaf；
结构n*子项[字母表大小]；
结构n*failLink；
};
typedef结构n节点；
//特里亚
结构t
{
节点*根；
整数计数；
};
typedef结构t trie；
void bytesCpy（char*to，char*from，int len）
{
int i；
对于（i=0；ichildren[i]=NULL；
}
pNode->failLink=t->root；
pNode->value=value；
pNode->level=level；
pNode->isLeaf=0；
}
其他的
printf（“错误\n”）；
返回pNode；
}
//初始化trie（根节点是虚拟节点）
无效初始化（trie*t）
{
t->root=getNode（t，['，0）；
//t->count=0；
}
//如果不存在，则将密钥插入trie
//如果键是trie节点的前缀，则只标记叶节点
无效插入（trie*t，字符键[]，整数len）
{
智力水平；
字符值；
node*node=t->root；
对于（级别=0；级别子级[值]==NULL）
{
node->children[value]=getNode（t，value，level+1）；
}
节点=节点->子节点[值]；
}
节点->isLeaf=1；
}
//如果trie中存在键，则返回非零
int搜索（trie*t，char键[]）
{
智力水平；
int length=strlen（键）；
int值；
节点*节点；
node=t->root；
用于（级别=0；级别<长度；级别++）
{
value=key[level]；//字符到索引（key[level]）；
如果（！节点->子项[值]）
{
节点=节点->故障链接；
返回0；
}
节点=节点->子节点[值]；
}
返回（0！=节点）；/&&node->value）；
}
无效搜索1（trie*t、char*c、int len）
{
节点*curNode=t->root；
int i；
for（i=0；iisLeaf）//leaf:cuvant gasit
{
printf（“if1 curGasit\n”）；
做{
curNode=curNode->failLink；
如果（curNode->isLeaf）
printf（“if1 curGasit\n”）；
否则就断了；
}而(1),；
持续
}
else//nu e gasit inca
{
if（curNode->children[c[i]]==NULL）//失败
{
printf（“if2\n”）；
curNode=curNode->failLink；
持续
}
else//litera gasita:继续
{
printf（“el2\n”）；
curNode=curNode->children[c[i]]；
}
}
}
printf（“搜索结束”）；
}
node*searchAux（trie*t，node*curRoot，char-cuv[]，char-len，int-level，int-failLevel）
{
char-cuvAux[1024]；
bytesCpy（cuvAux，cuv，len）；
printf（“搜索辅助级别：%d cuvAux:%s curRootLevel:%d\n”，级别，cuvAux，curRoot->level）；
if（cuvAux[level+1]='\0'）//到达cuvAux的末尾
{
printf（“第1个if\n”）；
返回电流；
}
if（curRoot->children[cuvAux[level+1]]==NULL）//失败：找不到字母
{
printf（“第三个if\n”）；
返回searchAux（t，t->root，&cuvAux[failLevel+1]，len，0，failLevel+1）；
}
否则//找到的信：继续
{
printf（“第三个其他\n”）；
if（cuvAux[level+2]=='\0'）//找到的字母是字符串的最后一个
{
printf（“第四个if\n”）；
return curRoot->children[cuvAux[level+1]]；//返回最终指针
}
else//找到的字母不是字符串的最后一个：继续下一个
{
printf（“第四个其他\n”）；
返回searchAux（t，curRoot->children[cuvAux[level+1]]，cuvAux，len，level+1，failLevel）；
}
}
}
void createFailLinks（trie*t，节点*curRoot，字符cuv[]，整数级）
{
int i；
char-cuvAux[1024]；
bytesCpy（cuvAux，cuv，1024）；
if（curRoot==NULL）
回来
对于（i=0；ichildren[i]！=NULL*/；i++）
{
if（curRoot->children[i]==NULL）
持续
其他的
{
cuvAux[level]=curRoot->children[i]->value；
printf（“createFailLinks%c%d\n”，cuvAux[level]，curRoot->children[i]->level）；
curRoot->children[i]->failLink=searchAux（t，t->root，cuvAux，级别+1,0,0）；
createFailLinks（t，curRoot->children[i]，cuvAux，level+1）；
}
}
printf（“got\n”）；
}
void printTrie（节点*curRoot）
{
int i；
if（curRoot==NULL）
回来
printf（“%c:”，curRoot->value）；
对于（i=0；ichildren[i]！=NULL）
{
printf（“%c”，i）；
}
printf（“\n”）；
对于（i=0；ichildren[i]！=NULL）
{
printTrie（curRoot->children[i]）；
}
}
无效检查链接（节点*curRoot）
{
int i；
if（curRoot==NULL）
回来
printf（“节点%c%d:”，curRoot->value，curRoot->level）；
对于（i=0；ichildren[i]！=NULL）
printf（“\n\t%c%d:%c%d”，curRoot->children[i]->value，curRoot->children[i]->level，curRoot->children[i]->failLink->value，curRoot->children[i]->failLink->level）；
printf（“\n”）；
对于（i=0；ichildren[i]！=NULL）
选中链接（curRoot->children[i]）；
}
int mai（）
{
FILE*fd=fopen（“VirusDatabase.txt”，“r”）；//ordonly）；
int i；
字符c；
对于（i=0；i，可以在代码行中添加打印语句

    #include <iostream>

    std::cout << "At Line: " << __LINE__ << endl;

#包括
std:：cout您有权访问调试器吗？我在调试器中运行了您的代码，在这里的第157行出现了内存访问冲突：

return searchAux(t, t->root, &cuvAux[failLevel+1], len, 0, failLevel+1);

您似乎在递归地调用searchAux.ie，即：

node* searchAux(trie *t, node *curRoot, char cuv[], char len, int level ,int failLevel)
{
  char cuvAux[1024];
  ...
  return searchAux(t, t->root, &cuvAux[failLevel+1], len, 0, failLevel+1);
  ...

无论如何，缓冲区大小变量failLevel最终会超过缓冲区的大小，因此您试图访问数组边界之外的内存，这就是为什么您会