c++ 分段故障(内核转储)但无法确定

oug3syen  于 2022-11-27  发布在  其他
关注(0)|答案(1)|浏览(270)

根据我的理解，segfault通常是由无效的内存访问或泄漏引起的？但我不知道它在哪里。有没有像程序一样的方法来检查你的代码并找出它在哪里引起这个错误？请帮助。
我正在尝试用诸如insert find和predict completions这样的函数构建一个三元trie。
这是我的头文件：

  1. #include <vector>
  2. #include <string>
  3. #include <list>
  4. #include <iostream>
  6. using namespace std;
  8. class TNode {
  9.         public:
  10.                 TNode* left;
  11.                 TNode* right;
  12.                 TNode* middle;
  13.                 TNode* parent;
  14.                 int freq;
  15.                 char symbol;
  16.                 bool isWord;
  18.                 TNode(const char c, bool b, const unsigned int f);
  19. };
  21. class DictionaryTrie {
  23.         public:
  25.         DictionaryTrie();
  27.         bool insert(std::string word, unsigned int freq);
  29.         bool find(std::string word) const;
  31.         std::vector<std::string> predictCompletions(std::string prefix, unsigned int numcompletions);
  33.         ~DictionaryTrie();
  35.         private:
  37.         TNode* root;
  39.         void deleteAll(TNode* root) const;
  41.         void predictHelper(TNode* n, string s, list<pair<string, unsigned int>> &  allWords) const;
  43. };
  44. #endif

这是我的cpp文件

  1. #include "DictionaryTrie.hpp"
  2. #include <list>
  3. #include <string>
  4. #include <vector>
  6. using namespace std;
  8. TNode::TNode(const char c, bool b, const unsigned int f) : symbol(c), isWord(b), freq(f), left(0), middle(0), right(0), parent(0) {}
  10. DictionaryTrie::DictionaryTrie():root(0){}
  12. bool DictionaryTrie::insert(string word, unsigned int freq) {
  13.         if (word.empty())
  14.                         return false;
  16.         TNode* curr = root;
  18.         if (curr == nullptr) {
  19.                 
  20.                 if (word.length() == 1)
  21.                         root = new TNode (word[0], true, freq);
  22.                 else
  23.                         root = new TNode(word[0], false, 0);
  24.         }
  25.         
  26.         for (unsigned int i = 0; i < word.length();) {
  27.                 
  28.                 if (curr->symbol == word[i]) {
  30.                         if (curr->middle != NULL) {
  31.                                 if (i == word.length()-1) {
  32.                                         if(curr->isWord == false) {
  33.                                                 curr->isWord = true;
  34.                                                 curr->freq = freq;
  35.                                                 return true;
  36.                                         }
  37.                                         else
  38.                                                 return false;
  39.                                 }
  40.                                 else {
  41.                                         curr = curr->middle;
  42.                                         i++;
  43.                                         continue;
  44.                                 }
  45.                         }
  47.                         else if (curr->middle == NULL) {
  48.                                 if(i!=word.length() - 1){
  49.                                         curr->middle = new TNode(word[i+1], (i==word.length()-2),(i==word.length()-2)?freq:0);
  51.                                         curr=curr->middle;
  52.                                         i++;
  53.                                         if (i==word.length()-2) return true;
  54.                                 }
  55.                                 else if (i == word.length() - 1) {
  56.                                         if(curr->isWord == false) {
  57.                                                 curr->isWord = true;
  58.                                                 curr->freq = freq;
  59.                                                 return true;
  60.                                         }
  61.                                 }
  62.                                 else return false;
  63.                         }
  64.                 }
  65.                 else if(word[i] > curr->symbol) {
  66.                         if (curr->right != NULL) {
  67.                                 curr=curr->right;
  68.                                 continue;
  69.                         }
  70.                         else {
  71.                                 curr->right = new TNode(word[i], (i==word.length()-1), (i==word.length()-1)?freq:0);
  72.                                curr = curr->right;
  73.                         if (i==word.length()-1)
  74.                                 return true;
  75.                         }
  76.                 }
  77.                 else {
  78.                         if (curr->left != NULL) {
  79.                                 curr = curr->left;
  80.                                 continue;
  81.                         }
  82.                         else {
  83.                                 curr->left = new TNode(word[i], (i==word.length()-1), (i==word.length()-1)?freq:0);
  84.                                 curr = curr->left;
  85.                                 if (i==word.length()-1)
  86.                                         return true;
  87.                         }
  88.                 }
  89.         }
  90. }
  91. bool DictionaryTrie::find(string word) const {
  93.         TNode* curr = root;
  95.         if(word.length() == 0)
  96.                 return false;
  98.         for (unsigned int i = 0; i < word.length();) {
  99.                 if (curr != NULL) {
  100.                         if(curr->symbol == word[i]) {
  101.                                 i++;
  102.                                 if(i==word.length()) {
  103.                                         if(curr->isWord == true)
  104.                                                 return true;
  105.                                         else
  106.                                                 return false;
  107.                                 }
  108.                                 curr = curr->middle;
  109.                         }
  110.                         else if (word[i] > curr->symbol) {
  111.                                 curr = curr->right;
  112.                         }
  113.                         else
  114.                                 curr = curr->right;
  115.                 }
  116.                 else return false;
  117.         }
  118. }
  119. vector<string> DictionaryTrie::predictCompletions(string prefix, unsigned int numCompletions) {
  120.         vector<string> completions;
  122.         list<pair<string, unsigned int>> allWords;
  124.         if (numCompletions == 0 || prefix == "")
  125.                 return completions;
  127.         TNode* curr = root;
  129.         for (unsigned int i = 0; i < prefix.length();) {
  130.                 if (curr != NULL) {
  131.                         if (curr->symbol == prefix[i]) {
  132.                                 i++;
  133.                                 if (i==prefix.length())
  134.                                         break;
  135.                                 curr = curr->middle;
  136.                         }
  138.                         else if (prefix[i] < curr->symbol)
  139.                                 curr=curr->left;
  140.                         else
  141.                                 curr=curr->right;
  142.                 }
  143.                 //prefix is not in trie
  144.                 else
  145.                         return completions;
  146.         }
  148.         if (curr->isWord)
  149.                 allWords.push_back(make_pair(prefix, curr->freq));
  151.         predictHelper (curr->middle, prefix, allWords);
  153.         allWords.sort([](auto const& a, auto const& b) {
  155.                 if (a.second > b.second)
  156.                         return true;
  157.                 if (a.second < b.second)
  158.                         return false;
  159.                 return a.first < b.first;
  160.                 //return tie(b.second, a.first) < tie(a.second, a.first);
  161.         });
  163.         for(auto const& p: allWords) {
  164.                 if (completions.size() < numCompletions)
  165.                         completions.push_back(p.first);
  166.                 else
  167.                         break;
  168.         }
  169. }
  171. void DictionaryTrie::predictHelper(TNode* n, string s, list<pair<string, unsigned int>> & allWords)const {
  172.         if (n==NULL) return;
  174.         else {
  175.                 string temp = s + n->symbol;
  177.                 //check if node is a valid word
  178.                 if (n->isWord == true)
  179.                         allWords.push_back(make_pair(temp, n->freq));
  181.         predictHelper(n->middle, temp, allWords);
  182.         predictHelper(n->left, temp, allWords);
  183.         predictHelper(n->right, temp, allWords);
  184.         }
  185. }
  187. DictionaryTrie::~DictionaryTrie() {
  188.         deleteAll(root);
  189. }
  191. void DictionaryTrie::deleteAll(TNode* n) const {
  193.         if(!n) return;
  195.         else {
  196.                 deleteAll(n->left);
  197.                 deleteAll(n->middle);
  198.                 deleteAll(n->right);
  199.                 delete n;
  200.                 return;
  201.         }
  202. }
c++

1条答案

按热度按时间
jdzmm42g

jdzmm42g1#

当您使用调试器时，应该会看到在if (cur->symbol == word[i])处出现访问冲突。（请在家里尝试一下。）为什么会发生这种情况？
在DictionaryTrie::insert中，如果curr（== root）是一个空指针，则分配一个节点并将其存储在root中，但不更新curr。然后进入for循环，并引用curr->symbol。由于curr是一个空指针，因此会出现访问冲突。
简单的解决方法是将

  1. curr = root;

在给root赋值之后。

赞(0）分享  回复(0）举报  2022-11-27
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com