代码库

代码库之七－异常类

longest — Sat, 29 Apr 2006 15:19:00 GMT

写程序免不了有异常，没碰到过异常的请举手（哦，新来的啊，好，坐下），好闲话少说，看说明。
这个异常类，在程序出错的时候会输出一些信息，比如发生错误的函数（自填），错误描述（自填如果是标准错误可以自动生成)，错误代码（自填，或者标准错误填入GetLastError，或者WSAGetLastError),这样在出现错误的时候你就知道是哪个函数发生什么样的错误，便于调试。

/////////////////////////////////////////H////////////////////////////////////////////////////
#ifndef LG_EXCEPTION_H
#define LG_EXCEPTION_H

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
//#include <exception>
#include <string>

using namespace std;

namespace lglib
{
/*!
*异常处理的主要成员，是所有其他异常处理器的基类
*的异常处理类，确保了整体的标准兼容。
*/
class __LGLIB__ lg_Exception// : public exception
{
public:// 构造/析构
  lg_Exception(const string& Method, const string& Message, int ErrCode) throw();
  lg_Exception( const string& Method,DWORD ErrCode ) throw();
  virtual ~lg_Exception();
public:
  /*****************************说明*************************************/
  //void foo() throw (int);      // 只能抛出int型异常
  //void bar() throw ();         // 不抛出任何异常
  //void baz();                  // 可以抛出任意类型的异常或者不抛出异常
  /**********************************************************************/
  const string getMethod( void ) const throw() { return m_szMethod; }
  const string getMessage( void ) const throw() { return m_szMessage; }
  const DWORD getErrCode( void ) const throw() { return m_nErrCode; }
  virtual const char* What( void ) const throw()
  {
   return getMessage().c_str();
  }
protected: // 保护数据
  string m_szMethod;     // tell u witch function send this exception
  string m_szMessage;     // describe this exception
  uint32 m_nErrCode;     // code of exception
private: // 私有方法
  void processErrCode( void ); // 处理错误代码
};
}

#endif
/////////////////////////////////////////CPP////////////////////////////////////////////////////

#include "stdafx.h"
#include "lg_Exception.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

using namespace std;

namespace lglib
{

lg_Exception::lg_Exception( const string& Method, const string& Message, int ErrCode ) throw()
: m_szMethod( Method ), m_szMessage( Message ), m_nErrCode( ErrCode )
{
}

  lg_Exception::lg_Exception( const string& Method,DWORD ErrCode ) throw()
   : m_szMethod( Method ), m_nErrCode( ErrCode )
{
  processErrCode();
}

lg_Exception::~lg_Exception(void)
{
}

void lg_Exception::processErrCode( void ) // 处理错误代码
{

  const uint32 nTempSize = 2048;
  char* szTemp = new char[ nTempSize ];

  // 格式化错误信息
  FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, m_nErrCode,
   MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
   szTemp,
   nTempSize,
   NULL);
  m_szMessage = szTemp;
  delete [] szTemp;
}
}

代码库之六－信号量

longest — Sat, 29 Apr 2006 14:35:00 GMT

信号量的用法和互斥的用法很相似，不同的是它可以同一时刻允许多个线程访问同一个资源

/////////////////////////////////////////////////////H/////////////////////////////////////////////////////////////
#ifndef LGLIB_SEMAPHORE_H
#define LGLIB_SEMAPHORE_H

class __LGLIB__ lg_Semaphore
{
private: // 数据
  HANDLE m_semHandle;
  lg_AtomicCounter m_nCount;
public:  // 构造

  /*!
   * 可以指定信号量的初始值。这个初始值通常用于指定锁定有限个资源或者指定
   * 线程实例可以访问的指定资源的最大值。
    */
      lg_Semaphore( uint32 resource = 0 );

  /*!
   * 析够函数
   */
      ~lg_Semaphore();

public:  // 方法

  /*!
   * 等待资源可用。
   *
   * @param timeout 等待超时值。默认为0，表示永远不超时。
   * @return 当指定超时值是，TRUE资源可用，FALSE资源不可用，超时；
   *  当没有指定超时值时，TRUE资源可用，FALSE发生错误。
   */
  bool wait( timeout_t timeout = 0 );

  /*!
   * 增加可用资源，获释放可用资源给其他线程。
   */
  void release( void );

  /*!
   * 获得当前可用资源数量。
   *
   * @return 可用资源数量
   */
  int32 getValue( void );

};
#endif
//////////////////////////////////////////////CPP/////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
// 构造函数
lg_Semaphore::lg_Semaphore( uint32 resource )
{
  m_semHandle = ::CreateSemaphore( ( LPSECURITY_ATTRIBUTES )NULL,
         ( uint32 )resource, MAX_SEM_VALUE,
         ( LPCTSTR )NULL );
}

//---------------------------------------------------------------------------
// 析够函数
lg_Semaphore::~lg_Semaphore()
{
  ::CloseHandle( m_semHandle );
}

//---------------------------------------------------------------------------
// 等待信号
bool lg_Semaphore::wait( timeout_t timeout )
{
  if ( m_nCount )
  {
   --m_nCount;
  }

  if( !timeout )
  {
   timeout = INFINITE;
  }

  return WaitForSingleObject( m_semHandle, timeout) == WAIT_OBJECT_0;
}

//---------------------------------------------------------------------------
// 递增可用资源数量
void lg_Semaphore::release( void )
{
  ++m_nCount;
  ::ReleaseSemaphore( m_semHandle, 1, ( LPLONG )NULL );
}

//---------------------------------------------------------------------------
// 获得当前可用资源数量
int32 lg_Semaphore::getValue( void )
{
  return m_nCount;
}

代码库之五－互斥

longest — Sat, 29 Apr 2006 02:23:00 GMT

// 互斥对象能够确保线程拥有对单个资源的互斥访问权。

//////////////////////////////////////////////H////////////////////////////////////////////
#ifndef LGLIB_MUTEX_H
#define LGLIB_MUTEX_H

namespace lglib
{
  class __LGLIB__ lg_Mutex
{
private: // 私有成员
  HANDLE m_hMutex;
public:  // 构造/析构

      lg_Mutex();
      virtual ~lg_Mutex();

public:  // 方法

  /*!
   * 互斥锁，对互斥体进行上锁操作。
   */
  void lock( void );

  /*!
   * 互斥解锁，对上锁的互斥体解锁。
   */
  void unlock( void );

  /*!
   * 检测互斥体，用于判断当前互斥体的状态。
   *
   * @return true表明互斥体已经上锁，false互斥体没有上锁。
   */
  bool tryLock( void );
};
}
#endif

///////////////////////////////////////CPP/////////////////////////////////////////////
namespace lglib
{
// 构造
lg_Mutex::lg_Mutex()
{
  m_hMutex = CreateMutex( NULL, FALSE, NULL );
  if ( m_hMutex == NULL )
  {
   throw( this );
  }
}

// 析构
lg_Mutex::~lg_Mutex()
{
   ::CloseHandle( m_hMutex );
}

// 互斥锁
void lg_Mutex::lock( void )
{
  WaitForSingleObject( m_hMutex, INFINITE );
}

// 互斥解锁
void lg_Mutex::unlock( void )
{
  ReleaseMutex( m_hMutex );
}

// 检测互斥体
bool lg_Mutex::tryLock( void )
{
  return ( WaitForSingleObject( m_hMutex, 0 ) == WAIT_OBJECT_0 );
}
}

代码库之四－多事件

longest — Sat, 29 Apr 2006 02:03:00 GMT

多事件类
在线程中经常要等待多个事件，每次创建很多事件很繁琐，所以写了这个类
你可以为按照事件序号为每个事件定义枚举，这样使用的时候很方便。这个代码能帮到你我很高兴，有什么问题请告诉我。
//////////////////////////////////H////////////////////////////////////////////////////////////
#ifndef LGLIB_MULTIEVENT_H
#define LGLIB_MULTIEVENT_H

namespace lglib
{
class __LGLIB__ lg_MultiEvent
{
public:
  lg_MultiEvent(uint16 count);
  virtual ~lg_MultiEvent();
public:
  void resetall();
  BOOL reset( uint16 npos);

  void setall();
  BOOL set( uint16 npos);

  int32 wait( BOOL bWaitAll = FALSE );
  int32 wait( uint32 timeout , BOOL bWaitAll = FALSE );

  uint16 GetEventCount() const;

private:
  uint16 m_EventCount;
  HANDLE *m_hCond;
};
}
#endif

///////////////////////////////////CPP//////////////////////////////////////////////////////////

namespace lglib
{
lg_MultiEvent::lg_MultiEvent(uint16 count)
{
  //////////////////////////////////////////////////////////////////////////
  //MAXIMUM_WAIT_OBJECTS = 64
  //WaitForMultipleObjects 最多能等待 64个事件，所以事件的定义不能超过64
  //////////////////////////////////////////////////////////////////////////
  m_EventCount = (count > 64 ) ? 64 : count;

  m_hCond = new HANDLE[count];

  for( uint16 i = 0; i < m_EventCount ; i++)
  {
   m_hCond[i] = CreateEvent(NULL,TRUE,FALSE,NULL);
  }
}

lg_MultiEvent::~lg_MultiEvent()
{
  for(uint16 i = 0;i < m_EventCount;i++)
  {
   CloseHandle(m_hCond[i]);
  }

  delete [] m_hCond;
}
void lg_MultiEvent::resetall()
{
  for(int16 i = 0; i < m_EventCount; i++)
  {
   reset(i);
  }
}
BOOL lg_MultiEvent::reset( uint16 npos )
{
  if(npos >= m_EventCount)
   return FALSE;

  ::ResetEvent( m_hCond[npos] );

  return TRUE;
}
void lg_MultiEvent::setall()
{
  for(uint16 i = 0;i < m_EventCount; i++)
  {
   set(i);
  }
}

BOOL lg_MultiEvent::set( uint16 npos)
{
if(npos >= m_EventCount)
return FALSE;

::SetEvent( m_hCond[npos] );

return TRUE;
}

int32 lg_MultiEvent::wait( BOOL bWaitAll )
{
uint32 Ret = ::WaitForMultipleObjects(m_EventCount, m_hCond, bWaitAll,INFINITE );

  if(Ret < (WAIT_OBJECT_0 + m_EventCount))
   return (Ret - WAIT_OBJECT_0);

  return -1;
}
int32 lg_MultiEvent::wait( uint32 timeout , BOOL bWaitAll)
{
  uint32 Ret = WaitForMultipleObjects(m_EventCount, m_hCond, bWaitAll, timeout );

  if(Ret < (WAIT_OBJECT_0 + m_EventCount))
   return (Ret - WAIT_OBJECT_0);
  return -1;
}
uint16 lg_MultiEvent::GetEventCount() const
{
  return m_EventCount;
}
}

代码库之三－事件

longest — Fri, 28 Apr 2006 05:00:00 GMT

没有废话直接看代码

///////////////////////////////////////H/////////////////////////////////////////////////
#ifndef LGLIB_EVENT_H
#define LGLIB_EVENT_H

namespace lglib
{
class __LGLIB__ lg_Event
{
private: // 私有数据

  HANDLE m_hCond;

public:  // 公用数据

  enum
  {
   EVENT = 0, // 事件发生
   TIME_OUT, // 超时
   EVENT_ERR // 发生错误
  };

public:  // 构造

      lg_Event();
      virtual ~lg_Event();

public:  // 方法
  /*!
   * 重置事件状态，在一个事件发生后必须重置才能继续使用。
   */
  void reset( void );

  /*!
   * 事件通知，像等待事件的线程发送这个事件。
   */
  void set( void );

  /*!
   * 等待事件通知
   */
  int wait( void );

  /*!
   * 等待事件一段时间
   */
  int wait( uint32 timeout );

};
}
#endif
///////////////////////////////////////CPP/////////////////////////////////////////////////////////
namespace lglib
{
//---------------------------------------------------------------------------
// 构造
lg_Event::lg_Event()
{
  m_hCond = CreateEvent( NULL, TRUE, FALSE, NULL );
  if ( m_hCond == NULL )
  {
   throw( this );
  }
}

//---------------------------------------------------------------------------
// 析构
lg_Event::~lg_Event()
{
   ::CloseHandle( m_hCond );
}
//---------------------------------------------------------------------------
// 设置事件通知
void lg_Event::set( void )
{
  ::SetEvent( m_hCond );
}

//---------------------------------------------------------------------------
// 重置事件通知
void lg_Event::reset( void )
{
  ::ResetEvent( m_hCond );
}

//---------------------------------------------------------------------------
// 等待事件通知
int lg_Event::wait( void )
{
  if ( ::WaitForSingleObject( m_hCond, INFINITE ) == WAIT_OBJECT_0 )
  {
   return EVENT;
  }
  else
  {
   return EVENT_ERR;
  }
}

//---------------------------------------------------------------------------
// 等待事件通知
int lg_Event::wait( uint32 timeout )
{
  int ret = WaitForSingleObject( m_hCond, timeout );
  switch( ret )
  {
  case WAIT_OBJECT_0:
   {
    return EVENT;
   }
  case WAIT_TIMEOUT:
   {
    return TIME_OUT;
   }
  case WAIT_FAILED:
   {
    return EVENT_ERR;
   }
  }
  return ret;
}
}

代码库之一－全局定义

longest — Fri, 28 Apr 2006 04:42:00 GMT

#define _LGLIB_APP_
//#define _LGLIB_DLL_

# ifdef _LGLIB_DLL_
#  define __LGLIB__ __declspec(dllexport)
# else
#  ifdef _LGLIB_APP_
#   define __LGLIB__
#  else
#   define __LGLIB__ __declspec(dllimport)
#  endif
# endif

# define MAX_SEM_VALUE 1000000 // 最大信号量

typedef int socklen_t;
typedef unsigned char  uint8;
typedef unsigned short uint16;
typedef unsigned long  uint32;
typedef unsigned __int64 uint64;
typedef char   int8;
typedef short   int16;
typedef long   int32;
typedef __int64  int64;

typedef unsigned long ( __stdcall *exec_t )( void* );
typedef const char* cpstr;

typedef uint16 Port_t;  //!端口类型
typedef uint32 timeout_t; //!超时
const uint32 LG_SOCKET_OPEN  = 0x0001; //!< 套接字已经打开
const uint32 LG_SOCKET_CLOSE  = 0x0002; //!< 套接字没有打开或已经关闭
const uint32 LG_SOCKET_NOSERVICE = 0x0003; //!< 服务类型法错
const uint32 LG_SOCKET_NOMUTLICAST = 0x0004; //!< 没有设置多播模式
const uint32 LG_SOCKET_NOCONNECT = 0x0005; //!< 没有建立连接
const uint32 LG_SOCKET_OVERFLOW  = 0x0006; //!< 缓冲区溢出
const uint32 LG_SOCKET_CONNECT  = 0x0007; //!< 已经连接或正在连接
const uint32 LG_SOCKET_NO_LISTENING = 0x0008; //!< 套接字不处于监听状态
/*!
*}
*/

/*!lg_TcpStream
*{
*/
const uint32 LG_TCPSTREAM_HAVE_CONNECT = 0x1001; //!< 已经创建了连接
const uint32 LG_TCPSTREAM_BAD_ADDRESS = 0x1002; //!< 错误的地址
/*!
*}
*/

/*!lg_UdpSocket
*{
*/
const uint32 LG_UDPSOCKET_HAVE_BOUND = 0x3001; //!< 套接字已经被绑定了
const uint32 LG_UDPSOCKET_NOFOUND_NAME = 0x3002; //!< 没有找到目标名
const uint32 LG_UDPSOCKET_NOFOUND_ADDR = 0x3003; //!< 没有找到目标地址
/*!
*}
*/

/*!lg_SocketAddress
*{
*/
const uint32 LG_SOCKETADDRESS_NO_IP_CODE = 0x2001; //!< 无效IP地址
const uint32 LG_SOCKETADDRESS_OFF_RANGE_CODE = 0x2002; //!< 地址索引超出边界
/*
*}
*/

/*!lg_Thread
*{
*/
const uint32 LG_THREAD_NO_INIT  = 0x4001; //!< 线程还没有初始化
const uint32 LG_THREAD_HAVE_RUN  = 0x4002; //!< 线程已经运行
const uint32 LG_THREAD_NO_OBJECT = 0x4003; //!< 创建线程对象失败
const uint32 LG_THREAD_NO_SEM  = 0x4004; //!< 线程没有设置启动信号
const uint32 LG_THREAD_NO_HANDLE = 0x4005; //!< 线程关闭了挂起功能
const uint32 LG_THREAD_NO_RUN  = 0x4006; //!< 线程没有运行
/*!
*}
*/

/*!Other
*{
*/
const uint32 LG_NO_IMP = 0xFF01; //!< 没有实现该功能
// 常量定义
const uint32 TIMEOUT_INF = ~(uint32)0; //!不允许超时标记

const uint32 LG_BUFFER_LEN_LIMIT = 0x5001;//数据长度不够
const uint32 LG_TYPE_DISMATCH = 0x5002;//类型不匹配
const uint32 LG_STRING_END_ERROR = 0x5003;

#define VERSION 100

#pragma warning( disable : 4251 )
#pragma warning( disable : 4786 )

代码库之二－原子计数

longest — Thu, 27 Apr 2006 18:21:00 GMT

这段时间忙着整理代码，想写一个简单的封装库，所以这里的文字比较少，但代码比较简单应该比较好看懂。另外对我的代码有什么看法，错误的地方，请具体提出，我会非常感激，对于只会骂人的人请你哪儿凉快哪儿呆着去。
今天提供一个原子计数的类
///////////.H/////

#ifndef LGLIB_SYNCLOCK_H
#define LGLIB_SYNCLOCK_H

#if _MSC_VER>1000
#pragma once
#endif

#include <WINDOWS.H>
namespace lglib
{
/*!
* lg_AtomicCounter类提供了一个线程安全的整数计数器。AotomicCounter依赖于平
* 台是否提供“原子”整数操作。
*/
class __LGLIB__ lg_AtomicCounter
{
private:

int32 atomic;

public:

  /*!
   * 默认构造函数
   */
  lg_AtomicCounter();

  /*!
   * 赋初值构造函数
   *
   * @param value 初始值
   */
  lg_AtomicCounter(int value);

  /*! 自增量运算。 */
  int32 operator++(void);
  /*! 自减量运算。 */
  int32 operator--(void);

/*! 增量运算。 */
int32 operator+=( int change );

/*! 减量运算。 */
int32 operator-=( int change );

/*! 加法运算。 */
int32 operator+( int change );

  /*! 减法运算。 */
  int32 operator-( int change );

  /*! 赋值运算。 */
  int32 operator=(int value);
  /*! 非运算。 */
  bool operator!(void);

  /*! 类型转换，将该类转换为int型量。 */
  operator int32();
};
}
/////////////////////////.CPP////////////////////////////////
namespace lglib {
//---------------------------------------------------------------------------
// 默认构造函数
lg_AtomicCounter::lg_AtomicCounter()
{ atomic = 0; }

/*!
* 赋初值构造函数
*
* @param value 初始值
*/
lg_AtomicCounter::lg_AtomicCounter(int value)
{ atomic = value; }

/*! 自增量运算。 */
int32 lg_AtomicCounter::operator++(void)
{ return InterlockedIncrement( &atomic ); }

/*! 自减量运算。 */
int32 lg_AtomicCounter::operator--(void)
{ return InterlockedDecrement( &atomic ); }
//---------------------------------------------------------------------------
// 增量运算。
int32 lg_AtomicCounter::operator+=( int change )
{
  InterlockedExchangeAdd( &atomic, change );
  return atomic;
}

//---------------------------------------------------------------------------
// 减量运算
int32 lg_AtomicCounter::operator-=( int change )
{
  InterlockedExchangeAdd( &atomic, -change );
  return atomic;
}
/*! 加法运算。 */
int32 lg_AtomicCounter::operator+( int change )
{ return atomic + change; }

/*! 减法运算。 */
int32 lg_AtomicCounter::operator-( int change )
{ return atomic - change; }

/*! 赋值运算。 */
int32 lg_AtomicCounter::operator=(int value)
{ return InterlockedExchange(&atomic, value); }

/*! 非运算。 */
bool lg_AtomicCounter::operator!(void)
{ return ( atomic == 0 ) ? true : false; }

/*! 类型转换，将该类转换为int型量。 */
lg_AtomicCounter::operator int32()
{ return atomic; }
}

代码库