Hallo Community,
habe vor einen AST programmtechnisch umzusetzen.
Dazu habe ich folgenden Code bereits geschrieben.
Aber wie kann man nach Elementen suchen....
habe vor einen AST programmtechnisch umzusetzen.
Dazu habe ich folgenden Code bereits geschrieben.
Aber wie kann man nach Elementen suchen....
C:
#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;
}
Zuletzt bearbeitet von einem Moderator: