calculatorrep.cpp

大学时用c++做的计算器

#include "calculatorrep.h"

#include <QChar>

CalculatorRep::CalculatorRep(CalculatorRep::RDState s, CalculatorRep::OutputFormat f,
                             CalculatorRep::OutputBase b)
    : __format(f), __base(b)
{
    setRDState(s);
    __newCalculation = false;
    __error = false;
    __result = 0;
    __outStream.flags(__outStream.flags() | std::ios_base::showbase |
                      std::ios_base::uppercase);
    __outStream.precision(15);
}

bool CalculatorRep::newCalculation() const
{
    return __newCalculation;
}

void CalculatorRep::setNewCalculation(bool n)
{
    __newCalculation = n;
}

bool CalculatorRep::error() const
{
	return __error;
}

void CalculatorRep::setError(bool e)
{
	__error = e;
}

void CalculatorRep::setOutputFormat(CalculatorRep::OutputFormat f)
{
    __format = f;
}

void CalculatorRep::setOutputBase(CalculatorRep::OutputBase b)
{
    __base = b;
}

void CalculatorRep::setRDState(CalculatorRep::RDState s)
{
    __engine.setRDState(s);
}

void CalculatorRep::setExpression(const QString& expr)
{
    __expression = expr;

    QChar* data = __expression.data();
    std::string expression;
    for (int i = 0; i < __expression.size(); i++)
        expression.append(1, data[i].toAscii());
    expression.append(";");
    __engine.setExpression(expression);
}

QString CalculatorRep::expression() const
{
    return __expression;
}

ValueType CalculatorRep::calculate()
{
	try {
	    __result = __engine.calculate();
	    __engine.pushIdentifier("Ans", __result);
	    __engine.pushIdentifier("ans", __result);
	    __engine.pushIdentifier("ANS", __result);
    	return __result;
	}
	catch (...) {
		setError(true);
		throw;
	}
}

ValueType CalculatorRep::result() const
{
    return __result;
}

const char* CalculatorRep::resultString()
{
    switch (__format) {
    case Normal:
        __outStream.setf(std::ios_base::fmtflags(0), std::ios_base::floatfield);
        break;
    case Fixed:
        __outStream.setf(std::ios_base::fixed, std::ios_base::floatfield);
        break;
    case Scientific:
        __outStream.setf(std::ios_base::scientific, std::ios_base::floatfield);
        break;
    }

    __outStream.str("");
    __outStream.clear();
    __outStream << __result;

    return __outStream.str().c_str();
}

const char* CalculatorRep::baseResultString()
{
    __outStream.str("");
    __outStream.clear();

    __outStream.flags(__outStream.flags() | std::ios_base::showbase |
                      std::ios_base::uppercase);
    switch (__base) {
    case Oct:
        __outStream.setf(std::ios_base::oct, std::ios_base::basefield);
        break;
    case Dec:
        __outStream.setf(std::ios_base::dec, std::ios_base::basefield);
        break;
    case Hex:
        __outStream.setf(std::ios_base::hex, std::ios_base::basefield);
        break;
    }

	__outStream << (long long)(__result);
	return __outStream.str().c_str();
}

void CalculatorRep::staStore()
{
	__statistic.store(__result);
}

void CalculatorRep::staClear()
{
	__statistic.clear();
}

void CalculatorRep::staNum()
{
	__result = __statistic.num();
}

void CalculatorRep::staSum()
{
	__result = __statistic.sum();
}

void CalculatorRep::staAverage()
{
	__result = __statistic.average();
}

void CalculatorRep::staStdDiff()
{
	__result = __statistic.stdDiff();
}

void CalculatorRep::staMin()
{
	__result = __statistic.min();
}

void CalculatorRep::staMax()
{
	__result = __statistic.max();
}

void CalculatorRep::memClear()
{
	__memory.clear();
}

void CalculatorRep::memRecall()
{
	__result = __memory.recall();
}

void CalculatorRep::memSubtract()
{
	__memory.subtract(__result);
}

void CalculatorRep::memPlus()
{
	__memory.plus(__result);
}

void CalculatorRep::staDelete(const int index)
{
    __statistic.del(index);
}

ValueType CalculatorRep::staLoad(const int index)
{
    return __statistic.load(index);
}