//Some Python functionalities implemented in c++ //by baptiste prunier //Python lists : unfortunatelly, they can only contain the same type /* The project became too big for sololearn (it was hard to work on it here) so I moved it to GitHub Here is the link of all this stuff plus some more : https://github.com/Klevh/CppPython */ /* Special thanks to @Denis who inspired me with his code (link in comment) */ /* The objectif of this small project is to reproduce Python "behavior" to do nice display If you have python things you want me to implement, if you noticed a bug or have questions, please comment this code with what you want to say ! I try to make the syntax List l=(1,2,3,4); but overloading operator comma is not possible for raw types I replaced it by the l(1,2,3,4); syntax way to do something like this : l=[i for i in range(15) if i%2==0], it is not beautiful but for now, I did not find another way For now : For(lambda expression to generate the value,range (can be any list),lambda expression of the condition (optional)) */ /*Done elif Python List implentation l=[1,2,3] -> l(1,2,3) max,min and sum with lots of parameters (unknown number) or with list print function with format (link to behavior in comments) some functions of random (randint, choice, randrange,shuffle) for loop of python and range function way to do something like this : l=[i for i in range(15) if i%2==0] in boolean operator input function */ /* What is more on github Done : TODO : file handler python's 'with' */ #include #include #include #include #include #include #include using std::cout; using std::endl; using std::ostream; using std::range_error; using std::string; using std::ostringstream; using std::stringstream; using std::function; using std::cin; #define elif else if // --------------------------------------- //python's lists //An element of the linked list template struct Element{ T value; //value of the element Element * next; //next element Element * prec; //previous element Element(T value); //element's constructor }; //The python linked list template class List{ Element * first; //first Element of the list Element * last; //last element of the list unsigned long size; //size of the list bool wasCleared; //is useful for the () operator public: //constructors and destructor of the list List(); List(T val); template List(T val,U ...args) :first(nullptr),last(nullptr),size(0) ,wasCleared(false){ operator()(val,args...); } template List(const List& l, U ...args) :first(nullptr),last(nullptr),size(0) ,wasCleared(false){ operator()(l,args...); } ~List(); List(const List& l); // overloading of operators =,+,+=,*= in this order List& operator=(const List& l); List operator+(const List& l); List& operator+=(const List& l); List& operator*=(const unsigned& times); //overloading of [] accessor, one with unsigned to access values, one with string to copy a part of the list like in python T& operator[](const int& id) const; List operator[](const string& s) const; //overloading of List*unsigned operator List operator*(const unsigned times); //getLength method, used in len function unsigned getLength() const; //append and insert methods, return true if there was an error, false if not bool append(T value); bool insert(int id,T value); //pop and del methods T pop(); T del(unsigned id); //overloading of opperator << (for append) and >> (for pop) List& operator<<(const T& val); List& operator>>(T& val); //overloading of cast from List to string explicit operator const string(); //list creation operator, is the same as the python syntax l=[1,2,3,4], if a list is inside, for example l2(1,2,l), it will result as l2(1,2,1,2,3,4) template List& operator()(T val,U ...args){ if(!wasCleared){ wasCleared = true; while(size) pop(); } append(val); return operator()(args...); } template List& operator()(const List& l,U ...args){ if(!wasCleared){ wasCleared = true; while(size) pop(); } for(List::iterator it(l);!it.end();++it) append(*it); return operator()(args...); } List& operator()(T val){ if(!wasCleared){ while(size) pop(); }else wasCleared = false; append(val); return *this; } List& operator()(const List& l){ if(!wasCleared){ while(size) pop(); }else wasCleared = false; for(List::iterator it(l);!it.end();++it) append(*it); return *this; } //List iterator class iterator{ Element * curr; //current element of the iterator Element * first; //first element of the iterator bool _end; //tells whether or not the iterator reached its end public: //iterator's constructors iterator(const List& l); iterator(const List::iterator& it); //reset method, set first as curr void reset(); //set the iterator to its end void setEnd(); //!= operator to compare iterators bool operator!=(const List::iterator& it); //= operator List::iterator& operator=(const List::iterator& it); //overloading of operators *iterator, ++iterator and iterator++ T operator*(); T operator++(); T operator++(int); //method to tells whether or not the iterator reached its end bool end(); }; //iterator's begin and end functions List::iterator begin() const; List::iterator end() const; }; //unsigned*List overloading operator template List operator*(const unsigned& times,const List& l); //python's len function template unsigned len(const List& l); //overloading of << operator for terminal display purpose template ostream& operator<<(ostream& os,const List& l); // --------------------------------------- //Standard function //python's sum function template T sum(const List& l); template T sum(T a); template T sum(T a, U ...args); //python's min function template T min(const List& l); template T min(T a); template T min(T a, U ...args); //python's max function template T max(const List& l); template T max(T a); template T max(T a, U ...args); //python's print function (not exactly the same) void print(); template void print(T a); template void print(string s,T value); template void print(string s, T value, U ...args); template void print(const char * s, T value, U ...args); template void print(T value, U ...args); // python's range template List range(T end); template List range(T begin, T end); template List range(T begin,T end,T inc); //list's for syntax constructor (l=[i for i in ... if ...]) template List For(Val valueGenerator,const List& l); template List For(Val valueGenerator,const List& l,Condition condFunc); //python's input string input(const string& s){ string str; cout<>str; return str; } string input(){ string str; cin>>str; return str; } // --------------------------------------- //Random module namespace Random{ //do not use this variable, it tells whether or not srand was call bool _initialized = false; //calls srand if it was not already void _init(){ if(!_initialized){ srand(time(0)); _initialized=true; } } //python's randint function int randint(int a,int b){ _init(); return rand()%(b-a+1)+a; } //python's randrange function int randrange(int a,int b,int inc=1){ _init(); --b; return rand()%((b-a)/inc+1)*inc+a; } int randrange(int end){ return randrange(0,end); } //python's choice function template T choice(const List& l){ return l[randint(0,len(l)-1)]; } //python's shuffle function template void shuffle(List& l){ unsigned id, size=len(l); T * arr = new T[size]; T tmp; if(arr){ for(unsigned i=0;i struct operator_lhs{ Function f; }; template struct operator_rhs{ Function f; T value; }; template const operator_lhs new_operator(Function f){ return {f}; } template operator_rhs operator<(const T& value,const operator_lhs& lhs){ return {lhs.f,value}; } template auto operator>(const operator_rhs& rhs,const U& value){ return rhs.f(rhs.value,value); } template auto operator>(const operator_lhs& lhs,T value){ return lhs.f(value); } } namespace Python_operator{ template Custom_operator::operator_lhs &)>> in(){ return {[](T v,const List& l){ for(T i : l) if(i==v) return true; return false; }}; } } // --------------------------------------- int main() { using Python_operator::in; List l,l2; print("---TESTS ON PYTHON LIST---"); print("Creating the list l :"); for(int i=0;i<10;++i) l.append(i); print(l); print(); l2(1,2,3,4,l); print("l2(1,2,3,4,l) :"); print(l2); print(); print("3 ()> l ?"); print(3 ()> l); print(); print("-10 ()> l ?"); print(-10 ()> l); print(); List l3(1,2,3,4,5),l4(l,0,0); print("List l3(1,2,3,4,5) :"); print(l3); print(); print("List l4(l,0,0) :"); print(l4,'\n'); l[0]=3; print("List after l[0]=3:"); print(l,"\n"); print("l[\"::-1\"] :"); l2=l["::-1"]; //to test copy's constructor and = operator as they have nearly the same code //test also insert as it is used when increment is negative print(l2,"\n"); print("3*l[\"2:-2:2\"] :"); print(3*l["2:-2:2"],'\n'); print("Empty list :"); print(List(),"\n"); print("l[\"6:\"] + l[\":3\"]:"); print(l["6:"]+l[":3"]); print(); print("len(l) == ",len(l)); int val=l.pop(); print("Value poped : ",val); print("len(l) == ",len(l)); print("l after pop :"); print(l,"\n"); print("len(l) == {}",len(l)); val=l.del(3); print("Value gotten after l.del(3) : ",val); print("len(l) == ",len(l)); print("l after del :"); print(l,"\n"); print("---TESTS ON PYTHON FUNCTIONS---"); print("sum(1,2,3) == ",sum(1,2,3)); print("sum(1,2,6,-3) == ",sum(1,2,6,-3)); print("sum(l) == ",sum(l),'\n'); print("min(1,2,3) == ",min(1,2,3)); print("min(1,2,6,-3) == ",min(1,2,6,-3)); print("min(l) == ",min(l),"\n"); print("max(1,2,3) == ",max(1,2,3)); print("max(1,2,6,-3) == ",max(1,2,6,-3)); print("max(l) == ",max(l),"\n"); l2=For([](int i){return i*i;},range(5),[](int i){return i&1;}); print("l2 = [i*i for i in range(5) if i&1]"); print("l2=For([](int i){return i*i;},range(5),[](int i){return i&1;}) :"); print(l2,'\n'); print("input() = "); print(input(),'\n'); print("---TESTS ON RANDOM FUNCTIONS---"); for(int i=0;i<5;++i) print("randint(-5,5) == ",Random::randint(-5,5)); print(); for(int i=0;i<5;++i) print("choice(l) == ",Random::choice(l)); cout< Element::Element(T value) :value(value),next(nullptr),prec(nullptr) {} //class list implementation //Constructor : just initialize attributes template List::List() :first(nullptr),last(nullptr),size(0),wasCleared(false) {} template List::List(T val) :first(nullptr),last(nullptr) ,size(0),wasCleared(false){ append(val); } //Destructor : free the memory used by the list template List::~List(){ Element * curr=first, *tmp; //we go through all the elements of the list, deleting them one by one while(curr){ tmp=curr->next; delete curr; curr=tmp; } } //Copy's constructor : copy the elements of another list in the newly created list template List::List(const List& l) :first(nullptr),last(nullptr),size(0),wasCleared(false){ List::iterator it(l); //iterator to the list to be copied //we append every element of the list to be copied in our list, so that they keep the same order while(!it.end()){ append(*it); ++it; } } //= operator : same behavior as copy's constructor but clear our list first template List& List::operator=(const List& l){ List::iterator it(l); while(getLength()) pop(); while(!it.end()){ append(*it); ++it; } return *this; } //+ operator : create a new list and append all the element of our list into it, then all the element of the other list, and return it template List List::operator+(const List& l){ List::iterator it(l); Element * curr; List res; curr=first; while(curr){ //appending the element of our list res.append(curr->value); curr=curr->next; } while(!it.end()){ //appending the elements of the other list res.append(*it); ++it; } return res; } //+= operator : appends all the element of the list to our list then return a reference to our list template List& List::operator+=(const List& l){ for(List::iterator it(l);!it.end();++it) append(*it); return *this; } //*= operator : if the unsigned argument is 0, it clears our list, if not, it appends time-1 times the list to itself. The method then return a reference to the list template List& List::operator*=(const unsigned& times){ if(times) //append the list for(unsigned i=0;i::iterator it(*this);!it.end();++it) append(*it); else //clear the list while(getLength()) pop(); return *this; } //[int] operator : accessor to the list's elements, allow doing like in python : l[-1], l[5]=5, ... template T& List::operator[](const int& id) const{ Element * curr = first; unsigned i; if(id>=size || id<-(int)size)//throw an error when the id is out of range throw range_error("List : [int] : id out of range exception"); if(id<0)//convert negative id into positive one i = size + id; else i = static_cast(id); while(i--) curr=curr->next; return curr->value; } //[string] operator : return a sublist of your list depending of the range described by the string : l[::-1], l[:3], l[2:], l[1:8:3], ... template List List::operator[](const string& s) const{ int i = 0, j = 0, k = 0; //three numbers of the range : l[i:j:k] int signe=1; //used to remember the signe while translating characters to number bool guessI=false, guessJ=false; //those bools are set to true if the variable (i and j respectively) had to be guessed unsigned id =0;//tells where we are in the string to analyse it List res; //resulting list Element * curr; //element to go through our list //we ignore spaces at the beginning while(s[id]==' ') ++id; //if the first character after all those spaces is not a :, we try to read an integer next if(s[id]!=':'){ if(s[id]=='-'){ signe=-1; ++id; } if(s[id]<'0' || s[id]>'9') throw range_error("List : [string] : NaN in first index of range"); while(s[id]>='0' && s[id]<='9'){ i=i*10+(int)(s[id]-'0'); ++id; } i*=signe; while(s[id]==' ') ++id; }else //else we have to guess i guessI=true; if(s[id]!=':') //if at the end of the reading if the integer and extra spaces, we are not on a :, then there is a "syntax error" in the string throw range_error("List : [string] : Bad range of indexes"); ++id; //we do the same thing for j while(s[id]==' ') ++id; if(s[id]!=':' && s[id]){ if(s[id]=='-'){ signe=-1; ++id; }else signe=1; if(s[id]<'0' || s[id]>'9') throw range_error("List : [string] : NaN in second index of range"); while(s[id]>='0' && s[id]<='9'){ j=j*10+(int)(s[id]-'0'); ++id; } j*=signe; while(s[id]==' ') ++id; }else guessJ=true; if(s[id]!=':' && s[id]) //here, there is no error if we do not have a : because we are at the end of the string, if not, error throw range_error("List : [string] : Bad range of indexes"); //lastly, we read k the same way if(s[id] && s[id]==':'){ ++id; if(s[id]=='-'){ signe=-1; ++id; }else signe=1; if(s[id]<'0' || s[id]>'9') throw range_error("List : [string] : NaN in third index of range"); while(s[id]>='0' && s[id]<='9'){ k=k*10+(int)(s[id]-'0'); ++id; } k*=signe; }else k=1; //then we correct i and j si that they are positives if(i<0) i=size+i; if(j<0) j=size+j+1; //we throw out of range exception if we need to if(i<0 || i>=size) throw range_error("List : [string] : first index out of range"); if(j<0 || j>size) throw range_error("List : [string] : second index out of range"); //the increment has to be different from zero, if not, error if(!k) throw range_error("List : [string] : range increment can not be zero"); //now we save the sublist in two different ways depending on the signe of k if(k>0){ //if k positive, we read and ignore the i first elements then append to the resulting list the j-i next element if(guessI) i=0; if(guessJ) j=size; curr=first; for(unsigned a=0;anext; for(unsigned a=i;avalue); curr=curr->next; for(int i=0;inext; } }else{ //if k is negative, we read and ignore the first j elements, then read and insert the i-j next elements each time at the beginning of the resulting list to invert their order if(guessJ) j=0; if(guessI) i=size; curr=first; for(unsigned a=0;anext; for(unsigned a=j;avalue); curr=curr->next; for(int i=0;i>k+1 && curr;--i) curr=curr->next; } } return res; } //* operator : do like *= operator but instead of modifying our list, it creates a new list template List List::operator*(const unsigned times){ List res; Element * curr; for(unsigned i=0;ivalue); curr=curr->next; } } return res; } //returns the length of the list (to be used by len function) template unsigned List::getLength() const{ return size; } //append : add the valur at the end of the list, return true if there was an error, false if not template bool List::append(T value){ Element * curr=new Element(value);; if(curr){ if(last){ last->next=curr; curr->prec=last; last=curr; }else{ first=curr; last=curr; } ++size; return false; } return true; } //insert : add the value at the position id if possible, if id is out of range, throw an exception, if there was a memory error, return true, else return false template bool List::insert(int id,T value){ Element ** curr=&first, *tmp; if(id>size) throw range_error("List : insert : index out of bound"); if(id==size){ return append(value); }else{ for(unsigned i=0;inext); tmp=*curr; *curr=new Element(value); if(*curr){ (*curr)->next=tmp; (*curr)->prec=tmp->prec; if(tmp->prec) tmp->prec->next=*curr; tmp->prec=*curr; ++size; return false; }else{ *curr=tmp; return true; } } } //remove and return the last value of the list template T List::pop(){ T res = {}; Element * curr = last; if(size){ if(!last->prec) first=nullptr; else last->prec->next=nullptr; last=last->prec; res=curr->value; delete curr; size--; }else throw range_error("List : pop : the list is empty"); return res; } //del : remove and return the value at the index id of the list template T List::del(unsigned id){ T res = {}; Element * curr=first; if(id>=size) throw range_error("List : del : index out of range"); if(id==size-1){ return pop(); }else{ for(unsigned i=0;inext; res=curr->value; curr->next->prec=curr->prec; curr->prec->next=curr->next; delete curr; size--; } return res; } //operator << : behave like append template List& List::operator<<(const T& val){ append(val); return *this; } //operator >> : behave like pop template List& List::operator>>(T& val){ val=pop(); return *this; } //const string cast operator : return a string version of the list template List::operator const string(){ ostringstream s; s<<*this; return s.str(); } //iterator's begin and end functions template typename List::iterator List::begin() const{ return List::iterator(*this); } template typename List::iterator List::end() const{ List::iterator it(*this); it.setEnd(); return it; } //other functions using list //* operator for when the unsigned is put before the list template List operator*(const unsigned& times,const List& l){ List res; typename List::iterator it(l); for(unsigned i=0;i unsigned len(const List& l){ return l.getLength(); } //operator<< for display purpose template ostream& operator<<(ostream& os,const List& l){ typename List::iterator it(l); os<<"["; while(!it.end()){ os<<*it; ++it; if(!it.end()) os<<", "; } os<<"]"; return os; } //List::iterator class implementation //Iterator's constructor template List::iterator::iterator(const List& l) :curr(l.first),first(l.first){} //Iterator copy constructor template List::iterator::iterator(const List::iterator& it) :curr(it.curr),first(it.first){} //reset the iterator to its beginning template void List::iterator::reset(){ curr=first; } //set the iterator to its end template void List::iterator::setEnd(){ curr=nullptr; } //!= operator to compare iterators template bool List::iterator::operator!=(const List::iterator& it){ return curr!=it.curr; } //= operator template typename List::iterator& List::iterator::operator=(const List::iterator& it){ curr=it.curr; first=it.first; return *this; } //unary operator * : getter for the current value of the iterator template T List::iterator::operator*(){ return curr->value; } //++ operator : go to the next element and return its value if possible template T List::iterator::operator++(){ T val={}; if(curr) curr=curr->next; if(curr) val=curr->value; return val; } //operator ++: return the value of the current element and go to the next template T List::iterator::operator++(int){ T val={}; if(curr){ val=curr->value; curr=curr->next; } return val; } //tells whether or not the iterator reached its end template bool List::iterator::end(){ return !curr; } // -------------------------------------- //I will not explained those functions as they are parts of other codes of mine, if you are still currious, go see print with variadic template (link in comments) and variadic template functions //Standard functions template T sum(const List& l){ T res={}; for(typename List::iterator it(l);!it.end();++it) res+=*it; return res; } template T sum(T a){ return a; } template T sum(T a, U ...args){ return a+sum(args...); } template T min(const List& l){ T m; if(len(l)){ m=l[0]; for(typename List::iterator it(l);!it.end();++it) if(*it < m) m = *it; }else m={}; return m; } template T min(T a){ return a; } template T min(T a, U ...args){ T m = min(args...); return (m>a?a:m); } template T max(const List& l){ T m; if(len(l)){ m=l[0]; for(typename List::iterator it(l);!it.end();++it) if(*it > m) m = *it; }else m={}; return m; } template T max(T a){ return a; } template T max(T a, U ...args){ T m = max(args...); return (m void print(T a){ cout< void print(string s,T value){ unsigned long size=s.length(), deb=0,fin=0; unsigned long id; bool isFormated = false; id=s.find_first_of('{'); if(id='0') ++id; isFormated=s[id]=='}'; } if(isFormated){ while(deb='0' && s[fin]<='9'){ id*=10; id+=s[fin]-'0'; ++fin; } if(fin void print(string s, T value, U ...args){ stringstream ss; unsigned long size=s.length(), deb=0,fin=0; unsigned long id,idGen=-1; bool findNonGen=false, isFormated = false; id=s.find_first_of('{'); if(id='0') ++id; isFormated=s[id]=='}'; } if(isFormated){ while(deb='0' && s[fin]<='9'){ id*=10; id+=s[fin]-'0'; ++fin; } if(findeb+1){ ss<=0){ deb=-1; do{ deb=s.find_first_of('{',deb+1); }while(deb void print(const char * s, T value, U ...args){ print(string(s),value,args...); } template void print(T value, U ...args){ cout< List range(T end){ return range({},end); } template List range(T begin, T end){ List res; if(begin>end) for(T i=begin;i>end;--i) res.append(i); else for(T i=begin;i List range(T begin,T end,T inc){ List res; if(begin>end) for(T i=begin;i>end;i-=inc) res.append(i); else for(T i=begin;i List For(Val valueGenerator,const List& l){ List res; for(auto i : l) res.append(valueGenerator(i)); return res; } template List For(Val valueGenerator,const List& l,Condition condFunc){ List res; for(auto i : l) if(condFunc(i)) res.append(valueGenerator(i)); return res; } // --------------------------------------

Python functions