Hello. I am fairly new to C++ and am writing a program that evaluates expressions. However, I keep getting these errors from the main.cpp file. The main class is listed below and I will list all the .h and rest of .cpp files for reference. I am running Visual Studio 2017 on Widows 10 Thanks in advance.

ERRORS:

- Error C2079 'fin' uses undefined class 'std::basic_ifstream>'

-Error C2440 'initializing': cannot convert from 'const char [10]' to 'int'

-Error C2228 left of '.getline' must have class/struct/union

-Error C2065 'cout': undeclared identifier (this occurs twice)

#include

#include

#include

#include

#include

#include "stdafx.h"

#include "expression.h"

#include "subexpression.h"

#include "symboltable.h"

#include "parse.h"

using namespace std;

SymbolTable symbolTable;

void parseAssignments(stringstream& cin);

int main()

{

const int SIZE = 256;

Expression* expression;

char paren, comma, line[SIZE];

string program;

ifstream fin("input.txt");

while (true)

{ //The first 2 error codes are said be located at this line

symbolTable.init();

fin.getline(line,SIZE);

if (!fin) break;

stringstream cin(line, ios_base::in); //error 3

cin >> paren;

cout << line << ""; //1st cout error

try {

expression = SubExpression::parse(cin);

cin >> comma;

parseAssignments(cin);

cout << "Value = " << expression->evaluate() << endl; //second cout error

}

catch (exception) {

return EXIT_FAILURE;

}

}

return 0;

}

void parseAssignments(stringstream& cin)

{

char assignop, delimiter;

string variable;

double value;

do

{

variable = parseName(cin);

cin >> ws >> assignop >> value >> delimiter;

symbolTable.insert(variable, value);

} while (delimiter == ',');

}

//end main.cpp

======================================================================

/** .h files*/

//and.h

#pragma once

#ifndef AND_H

#define AND_H

#include "subexpression.h"

#include "expression.h"

using namespace std;

class And : public SubExpression {

public:

And(Expression*left, Expression*right): SubExpression(left,right){}

double evaluate() {

return left->evaluate() && right->evaluate();

}

};

#endif

===================================================================================

//divide.h

#pragma once

#ifndef DIVIDE_H

#define DIVIDE_H

#include "subexpression.h"

#include "expression.h"

using namespace std;

class Divide : public SubExpression {

public:

Divide(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return left->evaluate() / right->evaluate();

}

};

#endif

===================================================================================

//equality.h

#pragma once

#ifndef EQUALITY_H

#define EQUALITY_H

#include "subexpression.h"

#include "expression.h"

using namespace std;

class Equality : public SubExpression {

public:

Equality(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return left->evaluate() == right->evaluate();

}

};

#endif

===================================================================================

//expression.h

#pragma once

#ifndef EXPRESSION_H

#define EXPRESSION_H

using namespace std;

class Expression

{

public:

virtual double evaluate() = 0;

};

#endif

===================================================================================

//lessthan.h

#pragma once

#ifndef LESSTHAN_H

#define LESSTHAN_H

#include "subexpression.h"

#include "expression.h"

using namespace std;

class LessThan : public SubExpression {

public:

LessThan(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return left->evaluate() < right->evaluate();

}

};

#endif

===================================================================================

//literal.h

#pragma once

#ifndef LITERAL_H

#define LITERAL_H

#include "operand.h"

using namespace std;

class Literal : public Operand

{

public:

Literal(double value)

{

this->value = value;

}

double evaluate()

{

return value;

}

private:

double value;

};

#endif

===================================================================================

//minus.h

#pragma once

#ifndef MINUS_H

#define MINUS_H

#include "subexpression.h"

#include"expression.h"

using namespace std;

class Minus : public SubExpression {

public:

Minus(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return left->evaluate() - right->evaluate();

}

};

#endif

===================================================================================

//morethan.h

#pragma once

#ifndef MORETHAN_H

#define MORETHAN_H

#include "subexpression.h"

#include "expression.h"

using namespace std;

class MoreThan : public SubExpression {

public:

MoreThan(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return left->evaluate() > right->evaluate();

}

};

#endif

===================================================================================

//negation.h

#pragma once

#ifndef NEGATION_H

#define NEGATION_H

#include "subexpression.h"

#include"expression.h"

using namespace std;

class Negation : public SubExpression {

public:

Negation(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return !(left->evaluate());

}

};

#endif

===================================================================================

//operand.h

#pragma once

#ifndef OPERAND_H

#define OPERAND_H

#include "Expression.h"

#include

using namespace std;

class Operand : public Expression

{

public:

static Expression* parse(stringstream& cin);

};

#endif

===================================================================================

//or.h

#pragma once

#ifndef OR_H

#define OR_H

#include "Expression.h"

#include"subexpression.h"

using namespace std;

class Or : public SubExpression {

public:

Or(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return left->evaluate() || right->evaluate();

}

};

#endif

===================================================================================

//parse.h

#pragma once

#ifndef PARSE_H

#define PARSE_H

#include

using namespace std;

string parseName(stringstream& cin);

#endif

===================================================================================

//plus.h

#pragma once

#ifndef PLUS_H

#define PLUS_H

#include "Expression.h"

#include "subexpression.h"

using namespace std;

class Plus : public SubExpression

{

public:

Plus(Expression* left, Expression* right) : SubExpression(left, right)

{

}

double evaluate()

{

return left->evaluate() + right->evaluate();

}

};

#endif

===================================================================================

//subexpression.h

#pragma once

#ifndef SUBEXPRESSION_H

#define SUBEXPRESSION_H

#include "Expression.h"

#include

using namespace std;

class SubExpression : public Expression

{

public:

SubExpression(Expression* left, Expression* right);

static Expression* parse(stringstream& cin);

protected:

Expression * left;

Expression* right;

};

#endif

===================================================================================

//symboltable.h

#pragma once

#ifndef SYMBOLTABLE_H

#define SYMBOLTABLE_H

#include

#include

using namespace std;

class SymbolTable

{

public:

SymbolTable(){}

void insert(string variable, double value);

double lookUp(string variable) const;

void init();

private:

struct Symbol

{

Symbol(string variable, double value)

{

this->variable = variable;

this->value = value;

}

string variable;

double value;

};

vector elements;

};

#endif

===================================================================================

//ternary.h

#pragma once

#ifndef TERNARY_H

#define TERNARY_H

#include "subexpression.h"

#include "expression.h"

using namespace std;

class Ternary : public SubExpression {

public:

Ternary(Expression*left, Expression*right, Expression* condition) : SubExpression(left, right) {

this->condition = condition;

}

double evaluate() {

return condition -> evaluate() ? left->evaluate() : right->evaluate();

}

private:

Expression * condition;

};

#endif

===================================================================================

//times.h

#pragma once

#ifndef TIMES_H

#define TIMES_H

#include "subexpression.h"

#include "expression.h"

using namespace std;

class Times : public SubExpression {

public:

Times(Expression*left, Expression*right) : SubExpression(left, right) {}

double evaluate() {

return left->evaluate() * right->evaluate();

}

};

#endif

===================================================================================

//variable.h

#pragma once

#ifndef VARIABLE_H

#define VARIABLE_H

#include"operand.h"

#include

using namespace std;

class Variable : public Operand

{

public:

Variable(string name)

{

this->name = name;

}

double evaluate();

private:

string name;

};

#endif

=====================================================================================

/** . cpp files*/

//operand.cpp

#include

#include

#include

#include

#include

#include "stdafx.h"

#include "expression.h"

#include "subexpression.h"

#include "operand.h"

#include "variable.h"

#include "literal.h"

#include "parse.h"

#include "Or.h"

#include "and.h"

#include "equality.h"

#include "MoreThan.h"

#include "LessThan.h"

#include "Ternary.h"

#include "negation.h"

using namespace std;

Expression* Operand::parse(stringstream& cin)

{

char paren;

double value;

cin >> ws;

if (isdigit(cin.peek()))

{

cin >> value;

Expression* literal = new Literal(value);

return literal;

}

if (cin.peek() == '(')

{

cin >> paren;

return SubExpression::parse(cin);

}

else

return new Variable(parseName(cin));

return 0;

}

=====================================================================================

//parse.cpp

#include

#include

#include

#include

#include "stdafx.h"

#include "parse.h"

using namespace std;

string parseName(stringstream& cin)

{

char alnum;

string name = "";

cin >> ws;

while (isalnum(cin.peek()))

{

cin >> alnum;

name += alnum;

}

return name;

}

=====================================================================================

//subexpression.cpp

#include

#include

#include "stdafx.h"

#include "expression.h"

#include "subexpression.h"

#include "operand.h"

#include "plus.h"

#include "minus.h"

#include "times.h"

#include "divide.h"

#include "Negation.h"

#include "Ternary.h"

#include "LessThan.h"

#include "MoreThan.h"

#include "And.h"

#include "Equality.h"

#include "Divide.h"

#include "Or.h"

using namespace std;

SubExpression::SubExpression(Expression* left, Expression* right)

{

this->left = left;

this->right = right;

}

Expression* SubExpression::parse(stringstream& cin)

{

Expression* left;

Expression* right;

Expression* condtion;

char operation, paren;

left = Operand::parse(cin);

cin >> operation;

if(operation=='!'){

cin>>paren;

return new Negation(left, NULL);

}else if(operation == ':'){

right = Operand::parse(cin);

cin>>paren;

condtion =Operand::parse(cin);

cin>>paren;

return new Ternary(left, right, condtion);

}else{

right = Operand::parse(cin);

cin >> paren;

switch (operation)

{

case '+':

return new Plus(left, right);

case '-':

return new Minus(left, right);

case '*':

return new Times(left, right);

case '/':

return new Divide(left, right);

case '|':

return new Or(left, right);

case '&':

return new And(left, right);

case '=':

return new Equality(left, right);

case '>':

return new MoreThan(left, right);

case '<':

return new LessThan(left, right);

}

}

return 0;

}

=====================================================================================

//variable.cpp

#include

#include

#include "stdafx.h"

#include "expression.h"

#include "operand.h"

#include "variable.h"

#include "symboltable.h"

using namespace std;

extern SymbolTable symbolTable;

double Variable::evaluate()

{

return symbolTable.lookUp(name);

}