//Main.cpp
#include <stdio.h>
#include <conio.h>
#include  "ZC_ADO.hpp" 

ZC_COMInitialize COMInit;

int main(){
   try {
     _bstr_t ConnStr =  "Provider=SQLOLEDB;    \
                        Data Source=(local);  \
                        Initial Catalog=pubs; \
                        Integrated Security=SSPI" ;

     ZC_ADOConnection zcConn;
     ZC_ADORecordSet  zcRS(zcConn);
     ZC_ADOStoredProc zcSP(zcConn);
     ZC_ADOCommand    zcCm(zcConn);

     try {
       zcConn.zm__Open(ConnStr, "","  ");//" 
       zcRS.zm__Open( "select au_id, au_lname from authors" );

       while(! zcRS.zm__EOF()){
          fprintf(stderr, "%-12s%-s\n" 
           ,(LPCSTR)(_bstr_t)zcRS.zm__FV( "au_id" )
           ,(LPCSTR)(_bstr_t)zcRS.zm__FV (1 )
          );
          zcRS.zm__Next();
       }
       
       _bstr_t Cmd =  "if exists (select * from dbo.sysobjects \
                      where id=object_id(N'[dbo].[MySP]')and  \
                      OBJECTPROPERTY(id, N'IsProcedure')=1 )   \
                      drop procedure MySP";
       zcCm.zm__Exec(Cmd);

       Cmd =  "CREATE PROCEDURE [dbo].[MySP] \n \
                 @P1 int,                   \n \
                 @P2 int out                \n \
              AS                            \n \
                 set nocount on             \n \
                 set @P2 = @P1+100           \n \
                 return(@P2 +1000000 )        \n \
             ";
       zcCm.zm__Exec(Cmd);

       zcSP.zm__AP( "@P1" , adParamInput,  adInteger,  0 ,  123 );
       zcSP.zm__AP( "@P2" , adParamOutput, adInteger,  0 ,    0 );
       zcSP.zm__Exec( "MySP" );


       fprintf(stderr, "\nMySP\n" );
       fprintf(stderr, "@RETURN = %d\n" ,(int)zcSP.zm__PV( "@RETURN" ));
       fprintf(stderr, "@P1     = %d\n" ,(int)zcSP.zm__PV( "@P1" ));
       fprintf(stderr, "@P2     = %d\n" ,(int)zcSP.zm__PV (2 ));

       zcCm.zm__Exec( "drop procedure MySP" );
     }
     catch(_com_error& e){
        fprintf(stderr, "%s\n" ,(LPCSTR)e.Description());
     }
     zcSP.zm__ClearParameter();
     zcConn.zm__Close();
   }
   catch(...){
      fprintf(stderr, "Unhandled Exception\n" );
   }

   getch();
   return  0 ;
}

//ZC_ADO.hpp
#import  "C:\Program Files\Common Files\System\ADO\msado15.dll"  \
        no_namespace rename( "EOF" ,  "adoEOF" )

const _bstr_t C_RollBackOpenTran =  "if(@@trancount>0 )rollback";

struct ZC_COMInitialize {
  ZC_COMInitialize(){::CoInitialize (0 ); }
 ~ZC_COMInitialize(){::CoUninitialize();}
}; 

class ZC_ADOConnection {
  friend class ZC_ADORecordSet;
  friend class ZC_ADOStoredProc;
  friend class ZC_ADOCommand;
  public:
     ZC_ADOConnection();
    ~ZC_ADOConnection();
  private:
     _ConnectionPtr m_objConnection;
     _bstr_t        m_strConnString;
  public:
     void zm__Open  (const _bstr_t&,
                     const _bstr_t&,
                     const _bstr_t&
                    );
     void zm__Close ();
};

class ZC_ADORecordSet {
  public:
     ZC_ADORecordSet(const ZC_ADOConnection&);
    ~ZC_ADORecordSet();
  private:
    _RecordsetPtr  m_objRecordSet;
    _ConnectionPtr m_objConnection;
  public:
    void       zm__Open  (const _bstr_t&);
    void       zm__Close ();
    void       zm__Next  ();
    bool       zm__EOF   ();
    _variant_t zm__FV    (const _bstr_t&);
    _variant_t zm__FV    (const long&);
};

class ZC_ADOStoredProc {
  public:
    ZC_ADOStoredProc(const ZC_ADOConnection&);
   ~ZC_ADOStoredProc();
  private:
    _CommandPtr    m_objCommand;
    _ConnectionPtr m_objConnection;
    ParametersPtr  m_objParameters;
  public:
    void       zm__ClearParameter();
    void       zm__AP   (const _bstr_t&,
                         const ParameterDirectionEnum&,
                         const DataTypeEnum&,
                         const int&,
                         const _variant_t&
                        );
    _variant_t zm__PV   (const _bstr_t&);
    _variant_t zm__PV   (const long&);
    void       zm__Exec (const _bstr_t&);
};

class ZC_ADOCommand {
  public:
    ZC_ADOCommand(const ZC_ADOConnection&);
   ~ZC_ADOCommand();
  private:
    _CommandPtr    m_objCommand;
    _ConnectionPtr m_objConnection;
  public:
    void zm__Exec (const _bstr_t&);
};

//ZC_ADO.cpp
#include  "ZC_ADO.hpp" 

ZC_ADOConnection::ZC_ADOConnection(){
  m_strConnString =  "";//" 
  m_objConnection.CreateInstance(__uuidof(Connection));
  m_objConnection->CommandTimeout =  300 ;
  m_objConnection->CursorLocation = adUseServer;
  m_objConnection->IsolationLevel = adXactReadCommitted;
  m_objConnection->Attributes     =  0 ;
}

ZC_ADOConnection::~ZC_ADOConnection(){
  zm__Close();
  m_objConnection =  0 ;
}

void ZC_ADOConnection::zm__Open(const _bstr_t& ConnStr,
                                const _bstr_t& UserID,
                                const _bstr_t& Passw
                               ){
  m_objConnection->Open(ConnStr,UserID,Passw,adConnectUnspecified);
}

void ZC_ADOConnection::zm__Close(){
  if(m_objConnection->State != adStateClosed)m_objConnection->Close();
}
 /******************************************************************************/ 
ZC_ADORecordSet::ZC_ADORecordSet(const ZC_ADOConnection& Conn){
  m_objConnection = Conn.m_objConnection;
  m_objRecordSet  =  0 ;
}

ZC_ADORecordSet::~ZC_ADORecordSet(){zm__Close();}

void ZC_ADORecordSet::zm__Open(const _bstr_t& SQL){
  zm__Close();
  _CommandPtr cmd;
  cmd.CreateInstance(__uuidof(Command));
  try {
    cmd->ActiveConnection = m_objConnection;
    cmd->CommandType      = adCmdText;
    cmd->CommandTimeout   =  300 ;
    cmd->CommandText      = SQL;
    m_objRecordSet        = cmd->Execute (0  ,0 ,adCmdText);
  }catch(_com_error &e){
    m_objConnection->Execute(C_RollBackOpenTran ,0  ,0 );
    throw e;
} }

void ZC_ADORecordSet::zm__Close(){
  if(m_objRecordSet){
    if(m_objRecordSet->State != adStateClosed)m_objRecordSet->Close();
    m_objRecordSet =  0 ;
} }

void ZC_ADORecordSet::zm__Next(){
  if(m_objRecordSet)if(m_objRecordSet->State != adStateClosed)m_objRecordSet->MoveNext();
}

bool ZC_ADORecordSet::zm__EOF(){
  if (0 ==m_objRecordSet)return TRUE;
  if(adStateClosed == m_objRecordSet->State)return TRUE;
  return !(VARIANT_FALSE==m_objRecordSet->adoEOF);
}

_variant_t ZC_ADORecordSet::zm__FV(const _bstr_t& Name){
  return m_objRecordSet->Fields->Item[Name]->Value;
} 

_variant_t ZC_ADORecordSet::zm__FV(const long& Index){
  return m_objRecordSet->Fields->Item[Index]->Value;
} 
 /******************************************************************************/ 
ZC_ADOStoredProc::ZC_ADOStoredProc(const ZC_ADOConnection& Conn){
  m_objConnection = Conn.m_objConnection;

  m_objCommand.CreateInstance(__uuidof(Command));
  m_objCommand->CommandType    = adCmdStoredProc;
  m_objCommand->CommandTimeout =  300 ;

  m_objParameters = m_objCommand->Parameters;
  m_objParameters->Append(
    m_objCommand->CreateParameter(
        "@RETURN" ,
       adInteger,
       adParamReturnValue,
        0 ,
        0 
    )
  );
}

ZC_ADOStoredProc::~ZC_ADOStoredProc(){
  zm__ClearParameter();
  if(m_objParameters->Count&gt ;0 )m_objParameters->Delete(0L);
  m_objParameters =  0 ;
  m_objCommand    =  0 ;
}

void ZC_ADOStoredProc::zm__Exec(const _bstr_t& CmdText){
  m_objCommand->CommandText      = CmdText;
  m_objCommand->ActiveConnection = m_objConnection;
  try {
    m_objCommand->Execute (0  ,0 ,adCmdStoredProc);
    m_objCommand->ActiveConnection =  0 ;
  }catch(_com_error &e){
    m_objConnection->Execute(C_RollBackOpenTran ,0  ,0 );
    throw e;
} }

void ZC_ADOStoredProc::zm__AP(const _bstr_t& Name,
                              const ParameterDirectionEnum& Direction,
                              const DataTypeEnum& Type,
                              const int& Size,
                              const _variant_t& Value){
  m_objParameters->Append(
     m_objCommand->CreateParameter(
       Name,
       Type,
       Direction,
       Size,
       Value
     )
  );
}

void ZC_ADOStoredProc::zm__ClearParameter(){
  while( m_objParameters->Count&gt ;1  )m_objParameters->Delete(1L);
}

_variant_t ZC_ADOStoredProc::zm__PV(const _bstr_t& Name){
  return m_objParameters->Item[Name]->Value;
}

_variant_t ZC_ADOStoredProc::zm__PV(const long& Index){
  return m_objParameters->Item[Index]->Value;
}
 /******************************************************************************/ 
ZC_ADOCommand::ZC_ADOCommand(const ZC_ADOConnection& Conn){
  m_objConnection = Conn.m_objConnection;
  m_objCommand.CreateInstance(__uuidof(Command));
  m_objCommand->CommandType    = adCmdText;
  m_objCommand->CommandTimeout =  300 ;
}

ZC_ADOCommand::~ZC_ADOCommand(){m_objCommand =  0 ;}

void ZC_ADOCommand::zm__Exec(const _bstr_t& CmdText){
  m_objCommand->CommandText      = CmdText;
  m_objCommand->ActiveConnection = m_objConnection;
  try {
    m_objCommand->Execute (0  ,0 ,adCmdText);
    m_objCommand->ActiveConnection =  0 ;
  }catch(_com_error &e){
    m_objConnection->Execute(C_RollBackOpenTran ,0  ,0 );
    throw e;
} }