Question
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.
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
};
#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);
}
Step by Step Solution
There are 3 Steps involved in it
Step: 1
Get Instant Access to Expert-Tailored Solutions
See step-by-step solutions with expert insights and AI powered tools for academic success
Step: 2
Step: 3
Ace Your Homework with AI
Get the answers you need in no time with our AI-driven, step-by-step assistance
Get Started