title: How to fix compiler error "class has no member named X"?
body: <p>I'm currently coding an expression evaluator and have run into an issue regarding polymorphism.
  My class hierarchy is as follows: Divide inherits from Operator which inherits from the base class Expression. When I instantiate an Object of type Divide with base class Expression and try to access the function divide(int, int) i get the following error:</p>
  
  <p>"Expression.cpp: In member function ‘int Expression::evaluate()’:
  Expression.cpp:37:6: error: ‘class Expression’ has no member named ‘divide’"</p>
  
  <p>Here is "Expression.h"</p>
  
  <pre><code>#ifndef EXPRESSION_H
  #define EXPRESSION_H
  #include &lt;string&gt;
  using namespace std;
  class Operator;
  class Divide;
  class Expression 
  {
    protected:
      char **ana, *exp;
  
    public:
     Expression();
     ~Expression();
     Expression(char* ex);
     int evaluate();
     void tokenize();
  
      class EmptyException
      {
         public:
       EmptyException(string a){reason = a;};
       string getReason() const{return reason;};
         private:
       string reason;
      };
  
  };
  
  #endif
  </code></pre>
  
  <p>And here is "Expression.cpp"</p>
  
  <pre><code>#include "Expression.h"
  #include "Stack.h"
  #include "Queue.h"
  #include "Node.h"
  #include &lt;iostream&gt;
  #include &lt;cstring&gt;
  #include &lt;stdio.h&gt;
  #include &lt;ctype.h&gt;
  #include "Operator.h"
  #include "Divide.h"
  
  Expression::Expression()
  {
  
  } 
  
  Expression::~Expression()
  {
     delete [] exp;
  }
  
  Expression::Expression(char* ex)
  {
     exp = ex;
     //tokenize();
  
  }
  
  int Expression::evaluate()
  {
    Stack stack;
  
    Expression *tmp;
    Divide d;
    tmp = &amp;d;
    tmp-&gt;divide(4, 2);
    stack.push(tmp);
     tmp = stack.pop();
  
   }
  
   void Expression::tokenize()
   {  
     int space = 0;
  
     for(int i  =0 ; i &lt; strlen(exp); i++)
     {
       if(exp[i] == ' ')
       space++;
     } 
  
     char ** ana = new char*[space + 1];
     ana[0] = strtok(exp, " ");
  
     for(int i = 1 ; i &lt; space + 1; i++)
     {        
     ana[i]= strtok (NULL, " ");
     }
  
    } 
  </code></pre>
  
  <p>And now the "operator.h"</p>
  
  <pre><code>#ifndef OPERATOR_H
  #define OPERATOR_H
  #include "Expression.h"
  
  using namespace std;
  
  class Operator : public Expression
  {
    protected:
      bool unary, binary;
    public:
      Operator();
      bool isUnary() const;
      bool isBinary() const;
  };
  
  #endif
  </code></pre>
  
  <p>"Operator.cpp"</p>
  
  <pre><code>#include "Operator.h"
  #include &lt;string&gt;
  #include &lt;cmath&gt;
  #include "Expression.h"
  
  Operator::Operator()
  {
  
  }
  
  bool Operator::isUnary() const 
  {
        if(unary)
      return true;
        else
      return false;
  
  }
  
  bool Operator::isBinary() const 
  {
        if(binary)
      return true;
        else
      return false; 
  }
  </code></pre>
  
  <p>"Divide.h"</p>
  
  <pre><code>#ifndef DIVIDE_H
  #define DIVIDE_H
  
  #include &lt;string&gt;
  #include "Operator.h"
  class Expression;
  using namespace std;
  
  
  class Divide : public Operator
  {
          private:
        char id;
      public:
          Divide();
          Divide(char);
          int divide(int a, int b);
          char identity() const;
  };
  
  #endif
  </code></pre>
  
  <p>"Divide.cpp"</p>
  
  <pre><code>#include "Divide.h"
  
  int Divide::divide(int a, int b)
  {
    return a/b;
  }
  
  Divide::Divide(char _id)
  {
   id = _id; 
  }
  
  char Divide::identity() const
  {
    return id;
  }
  </code></pre>
  
  <p>and for in case the makefile</p>
  
  <pre><code>main: Expression.o Equation.o Operator.o Divide.o Stack.o Queue.o main.o
     g++ -static main.o Equation.o Expression.o Operator.o Divide.o Stack.o Queue.o -o main
  
  main.o : main.cpp 
          g++ -c main.cpp 
  
  Equation.o : Equation.cpp Equation.h
      g++ -c Equation.cpp
  
  Expression.o : Expression.cpp Expression.h 
      g++ -c Expression.cpp 
  
  Operator.o : Operator.cpp Operator.h Expression.h 
      g++ -c Operator.cpp 
  
  Divide.o : Divide.cpp Divide.h Operator.h
      g++ -c Divide.cpp 
  
  Stack.o : Stack.cpp Stack.h Node.h
      g++ -c Stack.cpp
  
  Queue.o : Queue.cpp Queue.h Node.h
      g++ -c Queue.cpp
  </code></pre>
  
  <p>I have left out all the other operators such as eg. Plus, minus etc because they are all identical to what Divide is and would just complicate this question even further.</p>