g ++坏了吗？无法向类添加新方法

Question

我正在创建一个符号表类，用于我为编译器课程编写的分析器/解析器。到目前为止，一切进展顺利，但我无法使用g ++在我学校的Linux机器上编译这些类文件：

SymbolTable.h：

// Multiple definition guard
#ifndef SYMBOLTABLE_H
#defineSYMBOLTABLE_H

// Includes
#include <iostream>
#include <string>
#include "stddef.h"

// Namespace
using namespace std;

// Class for storing all encountered symbols while parsing
class SymbolTable
{
public:
    SymbolTable();                          // Constructor
    ~SymbolTable();                         // Destructor
    void scopeUp();                         // Increases current scope
    void scopeDown();                       // Decreases current scope
    void addSymbol(string symbolTitle);     // Adds a symbol to table
    void addSymboll(string symbolTitle);    // g++ doesn't think this exists

private:
    int scope;

    // Structure for storing symbols.  Currently only contains title from
    // identifier.  Will expand upon / derive from this structure after
    // initial testing.  Symbols are stored in a simple stack, with the
    // container class responsible for keeping track of the top Symbol.
    struct Symbol
    {
        Symbol* previousSymbol;
        string title;
    };

    // Structure for tracking current scope.  All symbols will belong to a
    // particular scope, and are stored in a simple stack to maintain
    // declaration order.  When the scope changes, currentScope will point to
    // a new scope structure with its own list of symbols.  Scopes themselves
    // are also stored in a stack, where currentScope points to the top.
    struct Scope
    {
        Scope* previousScope;
        Symbol* currentSymbol;
    };
    Scope* currentScope;

    // This is a recursive display function used for printing all of the items
    // in a given scope.  This is called from within the scopeDown function, so
    // that the final list of items for that scope can be logged before it is
    // destroyed
    void displayScope(Symbol* displaySymbol);
};

#endif // Multiple definition guard

SymbolTable.cpp：

// Multiple definition guard
#ifndef SYMBOLTABLE_CPP
#define SYMBOLTABLE_CPP

// Includes
#include "SymbolTable.h"


// Constructor
SymbolTable::SymbolTable()
{
    scope = 0;
    currentScope = NULL;
    return;
}

// Destructor
SymbolTable::~SymbolTable()
{
    Scope* nextScopeToDelete = NULL;
    Symbol* nextSymbolToDelete = NULL;

    // While there are scopes left to delete from the table...
    while(currentScope != NULL)
    {
        // Save the pointer to the next scope on the stack
        nextScopeToDelete = currentScope->previousScope;

        // While there are symbols left to delete from the scope...
        while(currentScope->currentSymbol != NULL)
        {
            // Save the pointer to the next symbol on the stack
            nextSymbolToDelete = currentScope->currentSymbol->previousSymbol;

            // For debugging
            cout << "deleting symbol " << currentScope->currentSymbol->title << endl;

            // Delete the current top symbol
            delete currentScope->currentSymbol;

            // Move on to the next one
            currentScope->currentSymbol = nextSymbolToDelete;
        }

        // For debugging
        cout << "deleting scope " << scope << endl;

        // Delete the current top scope
        delete currentScope;
        scope--;

        // Move on to the next one
        currentScope = nextScopeToDelete;
    }
    return;
}

// This is a recursive display function used for printing all of the items
// in a given scope.  This is called from within the scopeDown function, so
// that the final list of items for that scope can be logged before it is
// destroyed
void SymbolTable::displayScope(Symbol* displaySymbol)
{
    // If we've reached the bottom of the scope stack...
    if(displaySymbol == NULL)
    {
        return; // Nothing to do
    }

    // We haven't reached the bottom of the scope stack
    else
    {
        displaySymbol = displaySymbol->previousSymbol; // Keep going
        displayScope(displaySymbol); // Recursive call
    }

    // Display this symbol after all lower ones have been displayed recursively
    cout << displaySymbol->title << endl;
    return;
}

// A new procedure has caused us to increase scope, so we'll create a new
// scope structure with its own symbol stack
void SymbolTable::scopeUp()
{
    // Generate the new scope structure
    Scope* newScope = new Scope;
    newScope->previousScope = currentScope;
    newScope->currentSymbol = NULL;

    // Notification for debugging
    cout << "ENTERING SCOPE " << scope + 1 << endl;
    cout << "--------------------------------------------------";
    cout << "-------------------------" << endl;

    // Switch to the new scope
    currentScope = newScope;
    scope++;
    return;
}

// The end of a procedure has caused us to decrement scope, so we'll delete
// the contents of the current one and fall back to the last scope on the stack
void SymbolTable::scopeDown()
{
    // If we're already at the bottom of the stack...
    if(currentScope == 0)
    {
        // Something is very wrong
        cerr << "CANNOT DELETE SCOPE 0!!!!" << endl;
    }
    else
    {
        // Save the pointer to the next scope on the stack
        Scope* previousScope = currentScope->previousScope;
        Symbol* nextSymbolToDelete = NULL;

        // Display the contents of this scope before deleting it (debugging)
        displayScope(currentScope->currentSymbol);

        // While there are still symbols in this scope to delete...
        while(currentScope->currentSymbol != NULL)
        {
            // Save the pointer to the next symbol on the stack
            nextSymbolToDelete = currentScope->currentSymbol->previousSymbol;

            // Delete the current top symbol on the stack
            delete currentScope->currentSymbol;

            // Move on to the next one
            currentScope->currentSymbol = nextSymbolToDelete;
        }

        // Notification for debugging
        cout << "EXITING SCOPE " << scope-- << endl;
        cout << "==================================================";
        cout << "=========================" << endl;

        // Delete the old top scope from the stack
        delete currentScope;

        // Move on to the next one
        currentScope = previousScope;
    }
    return;
}

// Adds a symbol to the table.  Specifically:  adds a symbol to the top of the
// symbol stack in the scope at the top of the scope stack.  This will soon be
// interfacing with more expansive data structure, but currently just stores
// the title of the symbol as detected in the parser.
void SymbolTable::addSymbol(string symbolTitle)
{
    Symbol* newSymbol = new Symbol;
    newSymbol->previousSymbol = currentScope->currentSymbol;
    newSymbol->title = symbolTitle;
    currentScope->currentSymbol = newSymbol;
    return;
}

// g++ doesn't think this was declared in the class
void SymbolTable::addSymboll(string symbolTitle)
{
    Symbol* newSymbol = new Symbol;
    newSymbol->previousSymbol = currentScope->currentSymbol;
    newSymbol->title = symbolTitle;
    currentScope->currentSymbol = newSymbol;
    return;
}

#endif // Multiple definition guard

错误：

[...]$ touch SymbolTable.h SymbolTable.cpp
[...]$ g++ -c SymbolTable.cpp
SymbolTable.cpp:67: error: no âvoid SymbolTable::displayScope(SymbolTable::Symbol*)â member function declared in class âSymbolTableâ
SymbolTable.cpp:167: error: no âvoid SymbolTable::addSymboll(std::string)â member function declared in class âSymbolTableâ
[...]$

据我所知，它似乎认为我的displayScope函数未在类头文件中声明。为了进一步研究这个问题，我添加了一个名为addSymboll的新函数，它与现有的addSymbol函数相同。但是，它为这个新功能提供了相同的错误消息。事实上，经过几个小时的努力来编译它之后，似乎我根本无法为这个类添加任何新函数。关于造成这种情况的原因，我完全不知所措。 任何想法都会受到赞赏！

Answer 1

G ++也告诉我：

  

错误：预处理指令无效#defineSYMBOLTABLE_H

在#define之后添加空格：

  

#defineSYMBOLTABLE_H

Answer 2

我之前只是在清理时删除了对象（.o）文件。我最终要做的就是删除.gch文件。实际代码或g ++没有任何问题（尽管旧版本在学校服务器上运行）。