#include<iostream>
/*
transmiterea proprietatilor in momentul derivarii unei clase

[A] in clasa de baza ( parinte ) pot avea specificiatori
       - private
       - public
       - protected
[B] derivarea se poate face cu un specificator de acces
      in proprietatile bazei
       - private
       - public
       - protected

       [clasa de baza]
           |
           |
            *
     [clasa derivata]

    daca derivarea se executa cu specificator "public"
    de acces in clasa parinte toate proprietatile
    din baza ( parinte ) se transmit in derivata ( copil )
    cu aceleasi vizibilitati precum in parinte

ATT :
in momentul in care instantiez ( declar o variabila de
                                tip obiect )
un reprezentant al unei clase pe o ierahie
SE APELEAZA [ toti ] !!! constructorii pana la acel obiect

*/

using namespace std;
int n;
// obiect element din lista
class element {

                            private :
                            int info;
                            class element *next;
                            public :
                            // metode pe care le pot utiliza
                            // pentru a ccesa date "private"
                            // din interiorul obiectului
                            element(){next=NULL;}
                            int set_value(int thisvalue) { info=thisvalue;}
                            int reveal_value(){return info;}
                            int set_next(element *next_element){next=next_element;}
                            int *reveal_next(){return next;}
                          };
// descrierea generica a unei liste simplu inlantuite
// ( din care prin derivari vom dori sa dezvoltam clase
//  specializate pentru lucrul cu restictii LIFO,FIFO )

class some_list
{
private :
class element *start,*curent,*sfarsit;
int lungime;
public :
// metoda ( functie ) speciala ( de tip eveniment )
// constructor ( se apeleaza automat cand
// declar un obiect reprezentant al clasei
// ( cand declar o variabila de tipul obiectului )
some_list(){  // creez o lista vida
                  start=curent=sfarsit=NULL;
                  lungime=0;
                 }
int reveal_lenght(){return lungime;}
int print_me() { element *walker=start;
                        while (walker->reveal_next()!=NULL) {
                                cout<<endl<<walker->reveal_value();
                                //walker=walker->next;
                                walker->set_next(walker->reveal_next())   }
                        cout<<endl<<walker->reveal_value();}
};

class some_stack:public some_list
{
    public:
    some_stack(){start=curent=sfarsit=NULL;
                        lungime=0;
                       }
    int push_stack(some_list this_stack,int some_value);  // operatie adaugare element
    int pop_stack(some_list,int *some_value);  // operatie eliminare element
    int stack_empty();                                     // instrument consultate lista
};

some_stack L;

int main()
{
L.push_stack(L,13);
cout<<endl;
L.print_me();
// L.push_stack(L,17);
L.print_me();
}

int some_stack::stack_empty()
{
if (this->reveal_lenght()>=1) return 0;
return 1;
}

int some_stack::push_stack(some_list this_stack,int some_value)
{
element *new_one=new element;
if (this_stack.reveal_lenght()==0)
        {
        if (new_one!=NULL) {
                               new_one->set_value(some_value);
                               start=curent=sfarsit=new_one;
                               lungime=1;
                               return 1;
                              }
        }
   else  {
      // !!!  task [1]
     // (*new_one).info=some_value;
     new_one->info=some_value;
     new_one->next_element=NULL;
     sfarsit=curent=new_one;


           }

return 0;
}


int some_stack::pop_stack(some_list this_stack,int *old_value)
{
// !!! task [2]

}

/*
De terminat :
[1] push sa functioneze si pe liste alocate dinamic
      simplu inlantuit operate LIFO
      si in cazul cand stiva are o inaltime >1
[2] de creat toate functionalitatile pop
*/