C++ 但问题是我的main（）只是调用这个类中的方法集。因此，只要它尝试调用createHuffmanNodes（）方法，它就会崩溃。事实上，它告诉我segfault发生在我试图在队列中插入一个Huffman节点的时刻。我仍然不明白我做错了什么。@Tinashe
C++ 但问题是我的main（）只是调用这个类中的方法集。因此，只要它尝试调用createHuffmanNodes（）方法，它就会崩溃。事实上，它告诉我segfault发生在我试图在队列中插入一个Huffman节点的时刻。我仍然不明白我做错了什么。@Tinashe,c++,segmentation-fault,compare,priority-queue,C++,Segmentation Fault,Compare,Priority Queue,但问题是我的main（）只是调用这个类中的方法集。因此，只要它尝试调用createHuffmanNodes（）方法，它就会崩溃。事实上，它告诉我segfault发生在我试图在队列中插入一个Huffman节点的时刻。我仍然不明白我做错了什么。@TinasheChirongoma如果你要粘贴那么多代码，你最好完成它。在这种情况下，HuffmanNode丢失。只有在上面的注释中，您才提到它失败的地方。关于您所说的函数中唯一导致它失败的东西，您创建了一个HuffmanNode实例。哪种代码，您还没有显示
但问题是我的main（）只是调用这个类中的方法集。因此，只要它尝试调用createHuffmanNodes（）方法，它就会崩溃。事实上，它告诉我segfault发生在我试图在队列中插入一个Huffman节点的时刻。我仍然不明白我做错了什么。@TinasheChirongoma如果你要粘贴那么多代码，你最好完成它。在这种情况下，
HuffmanNodeHuffmanNodeHuffmanNodeHuffmanNodeHuffmanNodeHuffmanNodeHuffmanNodeHuffmanNode#include <iostream> // Includes the input and output stream header file.
#include <string> // Includes the string library.
#include <exception> // Includes the exceptions header file.
#include "HuffmanNode.h" // Includes the Huffman node class and all its respective components.
#include "HuffmanTree.h" // Includes the Huffman tree class and all its respective components.
#include <fstream> // Includes the file stream header file.
using namespace FOOBAR; // Declare the use of my custom made namespace.
int main(int argc, char* argv[]) {
std::string input_file, output_file;
try {
std::cout << "" << std::endl;
input_file = std::string(argv[1]); output_file = std::string(argv[2]);
HuffmanTree my_huffman_tree = HuffmanTree(/*fptr compare*/);
my_huffman_tree.generateMap(input_file);
my_huffman_tree.createHuffmanNodes();
std::cout << "" << std::endl;
}
catch(std::exception e) {
std::cout << "" << std::endl;
std::cout << "Error: " << e.what() << std::endl; // Print out the exact nature of the error.
std::cout << "" << std::endl;
exit(0); // Terminate program execution.
}
return 0;
}
// Preprocessor directives that guard against redeclaration should image_manipulator.h be defined elsewhere in the program
#ifndef HUFFMANNODE_H
#define HUFFMANNODE_H
// These are the included header files that are required for the execution of the program.
#include <memory>
// This is my custom namespace for the program.
namespace FOOBAR {
class HuffmanNode {
private:
char character; int frequency; // These are the constituents of each node i.e. consists of a character as well as a frequency.
std::shared_ptr<HuffmanNode> left_node, right_node; // Left and right attributes for my left and right nodes.
public:
HuffmanNode(char the_char, int the_frequency); // Declaration of default constructor.
HuffmanNode(int the_frequency); // Declaration of default constructor.
HuffmanNode(const HuffmanNode& rhs); // Copy constructor.
HuffmanNode(const HuffmanNode&& rhs); // Move constructior.
HuffmanNode & operator=(const HuffmanNode& rhs); // Copy assignment operator.
HuffmanNode && operator=(const HuffmanNode&& rhs); // Move assignment operator.
char getCharacter() const; // Retrieve a key in the map.
int getFrequency() const; // retrieve a value in the map.
std::shared_ptr<HuffmanNode> getLeftNode(); // Fetch the left node.
std::shared_ptr<HuffmanNode> getRightNode(); // Fetch the right node.
~HuffmanNode(); // Destructor.
// Declare other methods to be used here.
};
}
#endif
#include "HuffmanNode.h"
namespace CHRTIN006 {
// This is the implementation one of the Huffman Node constructor method.
HuffmanNode::HuffmanNode(char the_char, int the_frequency) {
HuffmanNode::character = the_char; HuffmanNode::frequency = the_frequency;
}
// This is the implementation one of the Huffman Node constructor method.
HuffmanNode::HuffmanNode(int the_frequency) {
HuffmanNode::frequency = the_frequency;
}
// This is the implementation of the Huffman Node copy constructor.
HuffmanNode::HuffmanNode(const HuffmanNode &rhs) {
HuffmanNode::character = rhs.HuffmanNode::character;
HuffmanNode::frequency = rhs.HuffmanNode::frequency;
}
// This is the implementation of the Huffman Node move constructor.
HuffmanNode::HuffmanNode(const HuffmanNode &&rhs) {
}
// This is the implementation of the Huffman Node copy assignment operator.
HuffmanNode& HuffmanNode::operator=(const HuffmanNode &rhs) {
if(this == &rhs) {
return *this;
}
HuffmanNode::character = rhs.HuffmanNode::character;
HuffmanNode::frequency = rhs.HuffmanNode::frequency;
return *this;
}
// This is the implementation of the Huffman Node move assignment operator.
HuffmanNode && HuffmanNode::operator=(const HuffmanNode &&rhs) {
}
// This method will return the key of an entry in the map.
char HuffmanNode::getCharacter() const{
return HuffmanNode::character;
}
// This method will return the value of an entry in the map.
int HuffmanNode::getFrequency() const{
return HuffmanNode::frequency;
}
// Retrieve the left most node of that particular branch.
std::shared_ptr<HuffmanNode> HuffmanNode::getLeftNode() {
return HuffmanNode::left_node;
}
// Retrieve the right most node of that particular branch.
std::shared_ptr<HuffmanNode> HuffmanNode::getRightNode() {
return HuffmanNode::right_node;
}
// This is the implementation of the Huffman Node destructor.
HuffmanNode::~HuffmanNode() {
}
}
// Preprocessor directives that guard against redeclaration should HuffmanTree.h be defined elsewhere in the program.
#ifndef HUFFMANTREE_H
#define HUFFMANTREE_H
// These are the included header files that are required for the execution of the program.
#include <queue> // For building the huffman tree.
#include "HuffmanNode.h" // Includes the Huffman Node header file.
#include <unordered_map> // Header file for my map that is going to store the respective frequencies of each letter.
#include <memory> // For making use of smart pointers.
#include <vector> // For making use of vectors within the program.
#include <functional> // For including the comparison method in the constructor of the queue.
// This is my custom namespace for the program.
namespace FOOBAR {
class HuffmanTree { // This is where my Huffman tree class starts.
public: // Objects an variables declared under this specifier are treated as being public.
// Going to be used to determine how to order entries in the queue.
typedef bool (*fptr)(const HuffmanNode&, const HuffmanNode&);
bool compare(const HuffmanNode& node_a, const HuffmanNode& node_b); /////////////////////////////
HuffmanTree(/*fptr compare*/); // Default constructor.
HuffmanTree(const HuffmanTree& rhs); // Copy constructor.
HuffmanTree(const HuffmanTree&& rhs); // Move constructior.
HuffmanTree& operator=(const HuffmanTree& rhs); // Copy assignment operator.
HuffmanTree&& operator=(const HuffmanTree&& rhs); // Move assignment operator.
~HuffmanTree(); // Destructor.
// This method is going to count the number of occurrences of each letter.
void generateMap(std::string file);
// Create Huffman nodes and populate them in the priority queue.
void createHuffmanNodes();
// Declare other methods to be used here.
private: // Objects an variables declared under this specifier are treated as being private.
std::shared_ptr<HuffmanNode> root_node; // The root node for the Huffman tree.
std::unordered_map<char, int> my_map; // Map containing the respective frequencies of each letter.
std::unordered_map<char, int>::iterator my_iterator; // Iterator for indexing every element in my map.
// This is the queue that is going to have entries of my shared pointers.
std::priority_queue<HuffmanNode, std::vector<HuffmanNode>, fptr> my_queue;
}; // This is where my Huffman tree class ends.
} // End of namespace.
#endif
This is the source file for my Huffman Tree class:
#include "HuffmanTree.h"
#include <fstream>
#include <iostream>
#include <boost/lexical_cast.hpp> // Includes the lexical cast functionlaity from the boost library.
namespace FOOBAR {
// This is the implementation of the Huffman Tree default constructor method.
HuffmanTree::HuffmanTree(/*fptr compare*/) /*: my_queue(compare)*/ {
root_node = nullptr;
}
// This is the implementation of the Huffman Tree copy constructor.
HuffmanTree::HuffmanTree(const HuffmanTree& rhs) {
root_node = rhs.root_node;
}
// This is the implementation of the Huffman Tree move constructor.
HuffmanTree::HuffmanTree(const HuffmanTree&& rhs) {
}
// This is the implementation of the Huffman Tree copy assignment operator.
HuffmanTree& HuffmanTree::operator=(const HuffmanTree& rhs) {
if(this == &rhs) {
return *this;
}
root_node = rhs.root_node;
return *this;
}
// This is the implementation of the Huffman Tree move assignment operator.
HuffmanTree&& HuffmanTree::operator=(const HuffmanTree&& rhs) {
}
// This is the implementation of the compare method that is going to be used to determine how to order entries in the queue.
bool compare(const HuffmanNode& node_a, const HuffmanNode& node_b) { ////////////////////////////////////////
if(node_a.getFrequency() > node_b.getFrequency()) {
return true;
}
else {
return false;
}
}
// This method is going to count the number of occurrences of each letter.
void HuffmanTree::generateMap(std::string file) {
std::ifstream input_stream(file); std::string line = "";
if(input_stream.fail()) {
std::cerr << "Error: Could not open the file specified." << std::endl; // Print this error message.
}
else {
while(std::getline(input_stream, line)) {
for(int i = 0; i < line.length(); i++) {
char my_character = line.at(i);
my_iterator = HuffmanTree::my_map.find(my_character);
if(my_iterator == my_map.end()) {
HuffmanTree::my_map.insert(std::make_pair(my_character, 1));
}
else {
my_iterator -> second++;
}
}
}
}
}
void HuffmanTree::createHuffmanNodes() {
for(my_iterator = my_map.begin(); my_iterator != my_map.end(); ++my_iterator) {
HuffmanNode some_huffman_node = HuffmanNode(boost::lexical_cast<char>(my_iterator -> first), boost::lexical_cast<int>(my_iterator -> second));
//my_queue.push(some_huffman_node); <---- Causes Segfault error
}
}
// This is the implementation of the Huffman Tree destructor.
HuffmanTree::~HuffmanTree() {
HuffmanTree::root_node = nullptr;
}
}
std::priority_queue<HuffmanNode, std::vector<HuffmanNode>, fptr> my_queue;
^^^
typedef bool (*fptr)(const HuffmanNode&, const HuffmanNode&);
struct CompareHuffmanNode {
bool operator()(HuffmanNode& n1, HuffmanNode& n2)
{
return n1.getFrequency() > n2.getFrequency();
}
};
std::priority_queue<HuffmanNode, std::vector<HuffmanNode>, CompareHuffmanNode> my_queue;
HuffmanTree::HuffmanTree(/*fptr compare*/) /*: my_queue(compare)*/ {
^ HERE ^ HERE ^ HERE ^
bool compare(const HuffmanNode& node_a, const HuffmanNode& node_b);
HuffmanTree::HuffmanTree() : my_queue(&HuffmanTree::compare) {