Question

下面是我执行词法分析的代码。我有几个要求。

我收到LNK2019错误。 LNK2019未解析的外部符号 “public：__thiscall Stack :: Stack（void）” 函数中引用了（?? 0？$ Stack @ UToken @ LexicalAnalysis @@@@ QAE @ XZ） “public：__ thiscall LexicalAnalysis :: LexicalAnalysis（void）” （?? 0LexicalAnalysis @@ @ QAE XZ）。我认为它与tokens变量有关，以及它是如何在构造函数中构造的。我不确定。
请查看我的代码，看看我是否正确管理内存，以及
看看我对问题的初步处理方法是否正确。

-

// Stack.h
#pragma once

#include <iostream>
#include <string>

using namespace std;

template <typename T>
class Stack
{
public:
    // Constructors
    Stack();
    Stack(const Stack<T>& rhs);
    Stack(Stack<T>&& rhs);

    // Destructor
    ~Stack();

    // Helper Functions
    inline int getSize() const
    {
        return size;
    }

    // Is the stack empty, no memory
    inline bool isEmpty()
    {
        return (size == 0) ? true : false;
    }

    // Add an element to the stack
    inline void push(const T& value) 
    {
        if (size == capacity) 
        {
            capacity = capacity ? capacity * 2 : 1;

            T* dest = new T[capacity];

            // Copy the contents of the old array into the new array
            copy(data, data + size, dest);

            delete[] data;

            data = dest;
        }

        // Stack size is increased by 1
        // Value is pushed
        data[size++] = value;
    }

    // Add an element to the stack (rvalue ref) IS THIS RIGHT??
    inline void push(const T&& value)
    {
        if (size == capacity)
        {
            capacity = capacity ? capacity * 2 : 1;

            T* dest = new T[capacity];

            // Copy the contents of the old array into the new array
            copy(data, data + size, dest);

            delete[] data;

            data = dest;
        }

        // Stack size is increased by 1
        // Value is pushed
        data[size++] = value;
    }

    // Remove an element from the stack
    inline const T& pop()
    {
        if (size > 0)
        {
            T value;

            size--;

            value = data[size];

            T* dest = new T[size];

            // Copy the contents of the old array into the new array
            copy(data, data + (size), dest);

            delete[] data;

            data = dest;

            return value;
        }

        return NULL;
    }

    // Search stack starting from TOP for x, return the first x found

    T& operator[](unsigned int i)
    {
        return data[i];
    }

    T operator[](unsigned int i) const
    {
        return data[i];
    }

private:
    T* data;

    size_t size, capacity;
};

// Stack.cpp
#include "Stack.h"

// Constructor
template <typename T>
Stack<T>::Stack()
{
    data = nullptr;

    size = 0;
    capacity = 0;
}

// Copy Constructor
template <typename T>
Stack<T>::Stack(const Stack<T>& rhs)
{
    this->size = rhs.size;
    this->capacity = rhs.capacity;

    this->data = new T[size];

    for (int i = 0; i < size; i++)
    {
        data[i] = rhs.data[i];
    }
}

// Move Constructor
template <typename T>
Stack<T>::Stack(Stack<T>&& rhs)
{
    this->size = rhs.size;
    this->capacity = rhs.capacity;
    this->data = rhs.data;

    rhs.data = nullptr;
}

// Destructor
template <typename T>
Stack<T>::~Stack()
{
    delete[] data;
}

// LexicalAnalysis.h
#pragma once

#include <iostream>
#include <string>

#include "Stack.h"

#define NUM_KEYWORDS 3
#define NUM_REL_OP 6
#define NUM_OTHER_OP 2

using namespace std;

class LexicalAnalysis
{
public:
    // Constructor
    LexicalAnalysis();

    // Destructor
    ~LexicalAnalysis();

    // Methods
    void createTokenStack(const string& inputString);

    inline bool isAlpha(const char& ch) const
    {
        int asciiVal = ch;

        if (((asciiVal >= 65) && (asciiVal <= 90)) ||
            ((asciiVal >= 97) && (asciiVal <= 122)))
            return true;

        return false;
    }

    inline bool isWord(const string& str) const
    {
        if (str.length() > 1)
            return true;

        return false;
    }

    inline bool isDigit(const char& ch) const
    {
        int asciiVal = ch;

        if ((asciiVal >= 48) && (asciiVal <= 57))
            return true;

        return false;
    }

    inline bool isRelationalOperator(const char& ch) const
    {
        if (ch == '=' || ch == '<' || ch == '>')
            return true;

        return false;
    }

    inline bool isOtherOperator(const char& ch) const
    {
        if (ch == ',' || ch == '*')
            return true;

        return false;
    }

    inline void printTokenStack()
    {
        for (int i = 0; i < tokens->getSize(); i++)
        {
            cout << tokens[i][0].instance << endl;
        }
    }

private:
    enum TokenType {
        IDENTIFIER,
        KEYWORD,
        NUMBER,
        REL_OP,     // such as ==  <  >  =!  =>  =<
        OTHER_OP,   // such as , * 

        UNDEF,      // undefined
        EOT         // end of token
    };

    struct Token {
        TokenType tokenType;
        string instance;
    };

    Stack<Token>* tokens;

    // Methods
    void splitString(const string& inputString, Stack<string>& result);
};

// LexicalAnalysis.cpp
#include "LexicalAnalysis.h"

LexicalAnalysis::LexicalAnalysis()
{
    tokens = new Stack<Token>();
}


LexicalAnalysis::~LexicalAnalysis()
{
}

void LexicalAnalysis::splitString(const string& inputString, Stack<string>& result)
{
    const char delim[2] = { ',', ' ' };
    char* dup = strdup(inputString.c_str());
    char* token = strtok(dup, delim);

    while (token != NULL)
    {
            result.push(string(token));
            token = strtok(NULL, delim);
        }

        // ARE THESE DELETES NECESSARY?
        delete dup;
        delete token;
    }
}

// main.cpp
#include <iostream>
#include <string>

#include "LexicalAnalysis.h"

using namespace std;

int main(int argv, char* argc)
{
    LexicalAnalysis lex = LexicalAnalysis();

    lex.createTokenStack("GET id, fname, lname FROM employee WHERE id > 5");

    system("PAUSE");
}

Answer 1

问题是您在cpp文件中定义了Stack方法。所有模板代码都应该放在头文件中。

在使用定义时，编译器必须可以使用模板定义。所以把模板代码放在stack.h文件中，而不是放在stack.cpp中，链接错误就会消失。实际上所有的stack.cpp代码都应该在stack.h中，你可以完全摆脱stack.cpp。

关于第二个问题，你的pop方法真的很奇怪。为什么要在pop上分配内存？只是递减大小，不需要分配更多内存。

inline const T& pop()
{
    if (size == 0)
        throw std::runtime_error("stack underflow");
    return data[--size];
}

解析，词法分析，C ++内存错误

1 个答案: