C++ templates für AST

[jkallup]

Hallo Community,

habe vor einen AST programmtechnisch umzusetzen.
Dazu habe ich folgenden Code bereits geschrieben.

Aber wie kann man nach Elementen suchen....

#include <iostream>
#include <utility>
#include <string>
#include <memory>
template <typename T>
class dBaseObject  {
public:
   dBaseObject(std::string  ="") { }
   void add(std::unique_ptr<T> &o)
   {
     if (object.get() == o.get())
     std::cout << "twice add" << std::endl;
     set(o);   
   }
   void set(std::unique_ptr<T> &o)
   {
     if (object.get() == o.get())
     std::cout << "twice set" << std::endl;
     object = std::move(o);
   }
private:
   std::unique_ptr<T> object;
};
template <class T>
class dBaseStatement: public dBaseObject<T> {
public:
  dBaseStatement(std::string s) { }
   void add(class dBaseAssign &o)
   {   if (isEmpty()) {
       stmt = std::move(o.node);
     }   else {
       dBaseAssign item(new dBaseAssign);
       item->value = std::move(stmt->node);
     }
   }
  void add(dBaseStatement o)
  {  if (isEmpty()) {
    stmt = std::move(o);
    }  else {
    dBaseStatement item(new dBaseStatement);
    item->stmt = nullptr;
    stmt  = std::move(item);
    }
  }
  bool isEmpty () const { return (stmt == nullptr) ? true : false; }
private:
  std::unique_ptr<dBaseStatement> stmt;
};
template <class T1, class T2>
class dBaseVariable: public dBaseObject<T2> {
public:
  explicit dBaseVariable() { }
  explicit dBaseVariable(T1,T2) { }
private:
   std::unique_ptr<std::pair<T1, T2> > value;
};
template <class T1, class T2, class T3>
class dBaseAssign {
public:
  explicit dBaseAssign(std::string = "") { }
  explicit dBaseAssign(
  std::unique_ptr<class dBaseVariable <std::string, T1> > &lval,
  std::unique_ptr<class dBaseVariable <std::string, T2> > &rval,
  std::unique_ptr<class dBaseStatement<T3> > &stmt)  {
  left  = std::move(lval);
  right  = std::move(rval);
  node  = std::move(stmt);
   
  }

  bool isLEmpty () const  { return (left  == nullptr) ? true : false; }
  bool isREmpty () const  { return (right == nullptr) ? true : false; }
private:
  std::unique_ptr<class dBaseVariable<std::string, T1> > left ;
  std::unique_ptr<class dBaseVariable<std::string, T2> > right;
  std::unique_ptr<class dBaseStatement<T3>  > node;
};
template <class T>
class dBaseAST: public dBaseObject<T>
{
public:
  explicit dBaseAST() { }
  std::unique_ptr<class dBaseStatement<T> > stmt;
};
std::unique_ptr<class dBaseAST<class dBaseStatement<std::string> > > root
(new class dBaseAST<class dBaseStatement<std::string> >);
int main(int argc, char **argv)
{
   std::unique_ptr<class dBaseStatement< std::string> > state1 (new class dBaseStatement<std::string>("test")) ;
   std::string strA = "varA";  double valA = 2.48;
   std::string strB = "varB";  double valB = 1.02;
   std::unique_ptr<class dBaseVariable < std::string, double > > varA (new class dBaseVariable <std::string, double>);
   std::unique_ptr<class dBaseVariable < std::string, double > > varB (new class dBaseVariable <std::string, double>);
   std::unique_ptr<class dBaseAssign  < double, double , std::string > > ass1 (new
  class dBaseAssign< double, double , std::string > (varA, varB, state1 ));

   state1->add(ass1  );
   root  ->add(state1);
   return 0;
}

 

[Cromon]

Hi jkallup

Paar andere Punkte:
Was bedeutet das Präfix d bei dir vor jedem Typ?
Für deine unique_ptr könntest du ein einfaches typedef machen, wird dann deutlich kürzer.
Du scheinst aus irgendeinem Grund überall noch "class" anzugeben. Das ist ein Überbleibsel aus der Vergangenheit und ist nur noch wegen Rückwärtskompatibilität drin. Verwende "typename". Wenn du es an einem Ort nicht verwenden kannst ist das da auch nicht nötig.

Viele Grüsse
Cromon

 

[jkallup]

Hallo Cromon,

das d? meinst Du dBase? och das ist halt so ne liebhaberrei zum dBase System.