#ifdef _UNIX
   #define beginThread befinUnixThread
   #define acquireLock acquireLockUnix
...
#ifdef _WIN32
   #define beginThread begnWinThread
   #define acquireLock acquireLockWin
...
#endif

typedef struct tagGenericApi {
   PFN1 beginThread; 
   PFN2 acquireLock; 
...
} GenericApi;

void loadWinApi(GenericApi* api) {
  api->beginThread = &BeginWinThread;
  api->acquireLock = &acquireLockWin;
}

void loadUnixApi(GenericApi* api) {
  api->beginThread = &BeginUnixThread;
  api->acquireLock =  &acquireLockUnix;
}
void loadApi(GenericApi* api) {
#ifdef _UNIX
   loadUnixApi(api);
#ifdef _WIN32
   loadWinApi(api);
#endif
}

class MyObject {
   void run(int n);
};

MyObject obj;

obj.run( 123 );

void* alloc();
void dealloc(void*);
run(void* obj, int n);

void* obj = alloc();
run(obj,  123 );
dealloc(obj);

..................

#define O_SERV  0x01   // server   
#define O_HOST  0x02   // host are resolved 
#define O_PORT  0x04   // port are resolved
#define O_CONN  0x08   // connection established
#define O_OK	0x06   // host and port  parameters are  set
#define O_POOL  0x10   // pool is  master
#define O_RR      0x20   // ready for read
#define O_RW     0x40   // ready for write
#define O_ERR   0X80   //  socket failed

class c_netconn: public c_nettimer   // network  connection
{
int s ; //  socket descriptor
int s_idx;  // pool index
int p_port; // connections port
struct sockaddr_in  s_addr; 
struct hostent  * shost;
char s_status;  // object status    
/*********connections satus description ***************************
                      sets
8765 - in the pool    4321 - server/client  O_SERV
||+-ready for read    ||+---  host          O_HOST
|+--ready for write    |+----  port	    O_PERT
+---                  +-----  connected	   
error flag apears when  operation is attempted and failed.

*******************************************************************/
int max_atempts;  // max attempts( intit by default by  MAXATTEMPT)
int  s_queue;        // 
sbuffs s_rdbuff;     // buffer for read  message
sbuffs s_wrbuff;    // buffer for write message
sbuffs s_statstr;    // string of connection status  |host:port|status|
public:
c_netconn();    //  default cork 
c_netconn(char* f_host, int f_port);
c_netconn(int f_ds);   // servers socket constructor 
virtual ~c_netconn();

bool  pool(int f_num );             // pool is master of this object and destroy it  
	  	    		    // espesially for call by  c_netpool.add(.....)  f_num is index in the pool.

hostent* host(char* f_host=NULL); // set and return host
int   port(char* f_port=NULL);        // set and return port
void  port(int f_port);                   // set port from integer
virtual int   connect();		         // attempt to connect
int   operator()();                       // return  socket descriptor( try to connect when have not done)    
int   fds();                    // the  same  as operator()(); 
virtual int   writemsg(char * f_msg, int f_size); // write message to the socket
virtual int   readmsg( char* f_msg=NULL,  int f_size= 1024  ); // read message from socket  
                                                  //to the internal buffer f_size is an buffer size
                                                   
int   queued();                 // how many  massages have sent but responce did not received
inline char status(){return s_status;};
inline const  int number() const
	{
	    return s_idx;
	};	    
virtual char* stat(); // return statistics string
};

//============================================================================
//
// 	class netconnpool retreive  sockets(descriptors) pool
//	with multiplexing message traffic and provide  async I/O  operations
//
//===========================================================================
class c_netconnpool:public c_nettimer
{
c_netconn* s_conn[MAXCONN]; 
fd_set s_set;                     // mask of descriptors
int s_socs;			//how many live  sockets  is	 there	
int s_current;			// current socket
int s_readyr;                                  // how many sockets is ready to read;
int s_readyw;
int s_sec;			// default sleep in second(select syscall)
int s_usec;			// default sleep in milisecond(select syscall)

public:
         c_netconnpool();
virtual        ~c_netconnpool();

int add(char* f_host, int f_port);    // add connection to the pool
int add(c_netconn* f_conn);           // 
virtual int netconn();			      // make and/or accept connections 
                                                        //create new c_netconn object when 
                                                        //new connection is accepted 
virtual int socket();                               // retrun free socket

int readyr();			      // number  socket is ready for read
//char* stat();                         // gathering statistics for all sockets
virtual  c_netconn*  nextw(int f_idxset= 0 );    // return next socket  from idxset  which is ready to write
virtual  c_netconn*  nextr(int f_idxset= 0 );    // return next socket from  idx_set which is ready  to read;
c_netconn*  first(int f_idxset= 0 );    // first  live socket
};

#endif
(C) onstat- 

Любое копирование и использованине только с согласия автора(onstat-)