gpt4 book ai didi

c++ - 解析、词法分析、C++ 内存错误

转载 作者:行者123 更新时间:2023-11-28 06:08:48 27 4
gpt4 key购买 nike

<分区>

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

  • 我收到 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");
}

27 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com