#include<iostream>
#include<pthread.h>
#include<sys/types.h>

using namespace std;

// this class is used to make generic calls to the run function
// in any object which have been inherited from object class

class Object
{
    public:
      virtual void run(){}
};

// now we will create an executer non member function
//which can call the run function of any Object class instance

void* executer(void* param)
{
   Object *obj=(Object*)param;
   obj->run();
   // this will definitely call the run function associated with the object obj
   // from this general function--the rest i guess u can figure out!
}

//now we will create the threading framework

class thread : public Object
{
  pthread_t thid;
  int ret;
  public:
   void start();
   void join();
};

// this member function will call the run function of the derived class
void thread::start()
{
   ret=pthread_create(&thid,NULL,executer,(void*)this);
}
// this is to join the object threads
void thread::join()
{
   pthread_join(thid,NULL);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// thats all thats required for the basic one
// now we use the above code...
// if we have to call a member function of a class
// we inherit it from the class thread and call the derived calss object //start function
// the run function will get executed as a thread!!!! just as java does it
// note that only the run function is threadable here
// further modifications is up to u - this is only the base
// by the way i hav not provided nything for synchronisation-give it where
//required, alogo to pass arg to threads, calling functions other than the //run() etc....
//  as an example of the above frame work we shall see a small example
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class multicount : public thread
{
   char *name;
  public:
    multicount(char n[])
    {
      name=n;
    }
    void run();
};
void multicount::run()
{
   for(int i=0;i<10000;i++)
   {
     cout<<"\n"<<name<<" : "<<i;
   }
}

int main()
{
  // we first create 3 instances(objects) of multicount a,b,c
  multicount a("thread1"),b("thread2"),c("thread3");
  // then we call the a.start() of object a to create a thread for doing  
  // a.run() and similarly for others
  a.start();
  b.start();
  c.start();
  // finally we wait for all threads to join
  a.join();
  b.join();
  c.join();

  //creating such frameworks greatly reduces programming difficulty with 
  // OOP
  // see how eazy the thread operations became with the simple 
  //architecture

  return 0;
}