kill me

// SOURCE.CPP
#include "Operand.h"
#include <queue>
#include <stack>
#include <iostream>

double Calculate(std::queue<Operand*> opn)
{
  std::stack<double> values;
  const long int INITIAL_SIZE = opn.size();
  for (int i = 0; i < INITIAL_SIZE; i++)
  {
    auto n = dynamic_cast<Number*>(opn.front());
    auto m = dynamic_cast<Operator*>(opn.front());
    if (n)
      values.push(n->number);
    else if (m)
    {
      double temp1 = values.top();
      values.pop();
      double temp2 = values.top();
      if (dynamic_cast<Add*>(opn.front()))
      {
        values.pop();
        values.push(temp1 + temp2);
      }
      else if (dynamic_cast<Subtract*>(opn.front()))
      {
        values.pop();
        values.push(temp2 - temp1);
      }
      else if (dynamic_cast<Multiply*>(opn.front()))
      {
        values.pop();
        values.push(temp1 * temp2);
      }
      else if (dynamic_cast<Divide*>(opn.front()))
      {
        values.pop();
        values.push(temp2 / temp1);
      }
      else if (dynamic_cast<Square*>(opn.front()))
      {
        values.pop();
        values.push(pow(temp2, temp1));
      }
    }
    opn.pop();
  }

  return values.top();
}


int main()
{
  std::queue<Operand*> l;
  l.push(new Number(6));
  l.push(new Number(8));
  l.push(new Add());
  l.push(new Number(2));
  l.push(new Square());
  l.push(new Number(102));
  l.push(new Number(53));
  l.push(new Subtract());
  l.push(new Divide());
  l.push(new Number(428));
  l.push(new Number(379));
  l.push(new Subtract());
  l.push(new Number(7));
  l.push(new Divide());
  l.push(new Add());

  std::cout << "The value of this expression is: " << Calculate(l) << "\n";

  system("PAUSE");
  return 0;
}


// OPERAND.H
#pragma once

class Operand
{
public:
  virtual void yo() = 0;
  virtual ~Operand();
};

class Number : public Operand
{
public:
  void yo()
  {
  }
  Number() {}
  Number(double num)
  {
    number = num;
  }

  double number;
};

class Operator : public Operand
{
  void yo()
  {
  }
  virtual ~Operator();
};

class Add : public Operator
{
public:
  Add();
  void yo()
  {
  }
};

class Subtract : public Operator
{
public:
  Subtract();
  void yo()
  {
  }
};

class Multiply : public Operator
{
public:
  Multiply();
  void yo()
  {
  }
};

class Divide : public Operator
{
public:
  Divide();
  void yo()
  {
  }
};

class Square : public Operator
{
public:
  Square();
  void yo()
  {
  }
};