对象的c++内存副本出现损坏

作为实现编译器的类项目的一部分，我还实现了一个哈希表，用作编译器的符号表。

哈希表的实现是非常低级的，是手工打包的原始内存块，它仅用于存储Token对象。因此，为了优化哈希表的可序列化性，我决定简单地内联表中的Token，也就是说，在第一次插入Token时，简单地将Token对象记忆到表的内存中。

我知道一个人不应该memcpy类有虚函数或指针，一般使用memcpy类的对象是不好的做法。然而，Token类没有虚函数或指针，这可以从下面的声明中看到，如果这不是低级编程的练习，我不会使用memcpy。

class Token {
    public:
        Token() : tag(BAD) {}
        Token(Tag t) : tag(t) {}
        Tag tag;
        size_t getSize(){ return sizeof(Token); }
};

我遇到的问题是，哈希表正确地插入Token，并且在寻找相同的键时找到相同的内存位置，但是，当我试图访问返回的Token指针的成员时，似乎数据已经损坏。

我写了一个程序在一个简单的输入上测试符号表。程序执行以下操作:

1. 读取输入文件到缓冲区
2. 初始化Lexer，将所有内置令牌插入Lexer符号表。
3. 在输入时调用Lexer的getToken方法并打印Token的标记，直到读取EOF Token。

虽然符号表返回它插入Token的内存位置，但Token的标记属性不再与插入的原始标记属性匹配。下面是程序将关键字program插入符号表时的日志输出:

[debug]   Entering SymbolTable.insert(const char* key)
[debug]   bin: 48 Searching for the last element in this bin's linked list.
[debug]   Last entry found... writing to entry's next location field.
[debug]   Writing the new entry's identifier to the table.
[debug]   The identifier: program has been written to the table.
[debug]   The memory blocks are not equal prior to assignment.
[debug]   The memory blocks are equal.
[debug]   nextLoc: 571 tag: 46
[debug]   Location of Token: 14287688

下面是程序随后在符号表中查找标识符程序时的日志输出。

[debug]   Entering Lexer.getToken()
[debug]   Entering SymbolTable.contains(const char* key)
[debug]   Entering SymbolTable.find(const char* key) key: program
[debug]   bin: 48
[debug]   Search location: 541
[debug]   Comparing key char: p to table char: p
[debug]   Comparing key char: r to table char: a
[debug]   Tag of entry: 1684368227
[debug]   Location of Token: 14287653
[debug]   Search location: 557
[debug]   Comparing key char: p to table char: p
[debug]   Comparing key char: r to table char: r
[debug]   Comparing key char: o to table char: o
[debug]   Comparing key char: g to table char: c
[debug]   Tag of entry: 1920296037
[debug]   Location of Token: 14287668
[debug]   Search location: 0
[debug]   Comparing key char: p to table char: p
[debug]   Comparing key char: r to table char: r
[debug]   Comparing key char: o to table char: o
[debug]   Comparing key char: g to table char: g
[debug]   Comparing key char: r to table char: r
[debug]   Comparing key char: a to table char: a
[debug]   Comparing key char: m to table char: m
[debug]   Tag of entry: 1207959598
[debug]   Location of Token: 14287688
The 1th token: 60

因此，从Token消息的位置可以看出，符号表在内存中找到了它写入Token的相同位置，但Token的标记不同。我不知道为什么会这样。

为完整起见，下面是SymbolTable类的定义。

template<class sizeType>    
class SymbolTable{      
    public:    
        SymbolTable();                                                             
        ~SymbolTable();        
        Token* operator[](const char* key);    
        bool contains(const char* key);    
        Token* insert(const char* key, Token value);    
    private:    
        void* find(const char* key);                                                        
        static const size_t nbins = 64;    
        sizeType nextLoc;                                                      
        void* table;       
        size_t hash(const char* key){    
            return (size_t)key[0] % nbins;    
        }            
}; 

下面是符号表的insert, find和operator[]函数的源代码。

template<class sizeType> Token* SymbolTable<sizeType>::insert(const char* key, Token value){
    BOOST_LOG_TRIVIAL(debug) << "Entering SymbolTable.insert(const char* key)";
    size_t bin = hash(key);
    void *sizeType_ptr,
         *tbl_char_ptr,
         *idSize_ptr;
    unsigned char idSize = 0;
    const char *key_ptr = key;
    Token *token_ptr = NULL;
    // Find the last entry in this bin's linked list.
    BOOST_LOG_TRIVIAL(debug) << "bin: " << bin
                             << " Searching for the last element in this bin's linked list.";
    sizeType_ptr = table + sizeof(sizeType)*bin;
    while(*((sizeType*)sizeType_ptr) != 0){
        sizeType_ptr = table + *((sizeType*)sizeType_ptr);
    }
    BOOST_LOG_TRIVIAL(debug) << "Last entry found... writing to entry's next location field.";
    // Write the location of the new entry to this entry's next field.
    *((sizeType*)sizeType_ptr) = nextLoc;
    // Move to new entry's location.
    sizeType_ptr = table + nextLoc;
    // Write identifier
    BOOST_LOG_TRIVIAL(debug) << "Writing the new entry's identifier to the table.";
    tbl_char_ptr = sizeType_ptr + sizeof(sizeType) + sizeof(unsigned char);
    while(*key_ptr != ''){
        *((char*)tbl_char_ptr) = *key_ptr;
        tbl_char_ptr = tbl_char_ptr + sizeof(char);
        ++key_ptr;
        ++idSize;
    }
    BOOST_LOG_TRIVIAL(debug) << "The identifier: " << key << " has been written to the table.";
    // Write length of identifier.
    idSize_ptr = sizeType_ptr + sizeof(sizeType);
    *((unsigned char*)idSize_ptr) = idSize;
    token_ptr = (Token*)(tbl_char_ptr + sizeof(char));
    void *tk = &value,
         *tb = token_ptr;
    for(int i = 0; i < value.getSize(); ++i){
        if(*((char*)tk) != *((char*)tb)){
            BOOST_LOG_TRIVIAL(debug) << "The memory blocks are not equal prior to assignment.";
            break;
        }
    }
    memcpy((void*)token_ptr, &value, value.getSize());
    bool areEqual = true;
    for(int i = 0; i < value.getSize(); ++i){
        if(*((char*)tk) != *((char*)tb)){
            areEqual = false;
            BOOST_LOG_TRIVIAL(debug) << "The memory blocks are not after assignment.";
            break;
        }
    }
    if(areEqual){
        BOOST_LOG_TRIVIAL(debug) << "The memory blocks are equal.";
    }
    nextLoc = nextLoc + sizeof(sizeType) + sizeof(unsigned char)
                + idSize*sizeof(char) + value.getSize();
    BOOST_LOG_TRIVIAL(debug) << "nextLoc: " << nextLoc
                             << " tag: " << token_ptr->tag;
    BOOST_LOG_TRIVIAL(debug) << "Location of Token: " << (size_t)token_ptr;
    return token_ptr;
}
template<class sizeType>
void* SymbolTable<sizeType>::find(const char* key){
    BOOST_LOG_TRIVIAL(debug) << "Entering SymbolTable.find(const char* key) "
                             << "key: " << key;
    bool found = false;
    size_t bin = hash(key);
    void *idSize,
         *sizeType_ptr,
         *tbl_char_ptr,
         *result_ptr = NULL;
    const char* key_ptr = key;
    BOOST_LOG_TRIVIAL(debug) << "bin: " << bin;
    sizeType_ptr = table + sizeof(sizeType)*bin;

    while(!found){
        found = true;
        // Is this the last element in this bin?
        if(*((sizeType*)sizeType_ptr) == 0){ 
            result_ptr = NULL;
            return result_ptr;
        }
        // Advance to the next element in this bin's linked list.
        sizeType_ptr = table + *((sizeType*)sizeType_ptr);
        idSize = sizeType_ptr + sizeof(sizeType);
        tbl_char_ptr = idSize + sizeof(unsigned char);
        BOOST_LOG_TRIVIAL(debug) << "Search location: " << *((sizeType*)sizeType_ptr);
        // Check if the passed key matches the current key in the table.
        for(int i = 0; i < *((unsigned char*)idSize); ++i){
            BOOST_LOG_TRIVIAL(debug) << "Comparing key char: " << *key_ptr
                                     << "to table char: " << *((const char*)tbl_char_ptr);
            // Check if the key is too short or if the chars do not match.
            if(*key_ptr != *((const char*)tbl_char_ptr)){
                found = false;
                break;
            }   
            ++key_ptr;
            tbl_char_ptr = tbl_char_ptr + sizeof(char);
            BOOST_LOG_TRIVIAL(debug) << "*(const char*)tbl_char_ptr: "
                                     << *((const char*)tbl_char_ptr);
        }
        result_ptr = tbl_char_ptr + sizeof(char);
        BOOST_LOG_TRIVIAL(debug) << "Tag of entry: " << ((Token*)result_ptr)->tag;
        BOOST_LOG_TRIVIAL(debug) << "Location of Token: " << (size_t)result_ptr;
        key_ptr = key;
    }   
    return result_ptr;
}
template<class sizeType>
Token* SymbolTable<sizeType>::operator[](const char* key){
    BOOST_LOG_TRIVIAL(debug) << "Entering SymbolTable.operator[](const char* key)";
    void* void_ptr = find(key);
    Token* token_ptr = (Token*)void_ptr;
    return token_ptr;
}

下面是测试程序的源代码。

int main(){
    cout << "Executing testLexer.cpp" << endl;
    ifstream file("./pascalPrograms/helloworld.pas");
    string program((istreambuf_iterator<char>(file)), istreambuf_iterator<char>());
    cout << "program:nn" << program << endl;
    int fileSize = program.length();
    const char* buffer = program.c_str();
    const char* scanp = buffer;
    cout << "Instantiating Lexer" << endl << endl;
    Lexer lexer = Lexer(scanp);
    Token* tok;
    int i = 0;
    cout << "Entering while loop to fetch tags." << endl << endl;
    do{ 
        i++;
        tok = lexer.getToken();
        cout << "The " << i << "th token: " << tok->tag << endl;
    } while(tok->tag != END_OF_FILE);
    return 0;
}

提前感谢您的帮助!: D

---

编辑:

下面是输入的Pascal程序:

program Hello;
begin
  writeln ('Hello, world.');
  readln
end.

为了澄清这个问题:

为什么从符号表中检索到的Token的标记与放入符号表中的Token的标记不同，而符号表中的Token是原始Token的精确副本?

nextLoc = nextLoc + sizeof(sizeType) + sizeof(unsigned char)
            + idSize*sizeof(char) + value.getSize();

    for(int i = 0; i < *((unsigned char*)idSize); ++i){
     ...
        tbl_char_ptr = tbl_char_ptr + sizeof(char);
    ...
    }
    result_ptr = tbl_char_ptr + sizeof(char);