cnstring.cpp

这是一个远程控制程序

//---------------------------------------------------------------------------

#pragma hdrstop
#include "CNString.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

void* __fastcall TCNString::GlobalAllocPtr(UINT Flag,DWORD Bytes) const
{
#ifdef  GLOBAL_ALLOCMEM
        return GlobalLock(GlobalAlloc(Flag,Bytes));
#else
        return LocalLock(LocalAlloc(Flag,Bytes));
#endif
}
void* __fastcall TCNString::GlobalReAllocPtr(void *Ptr,DWORD Bytes,UINT Flag) const
{
        HGLOBAL hMem;
#ifdef  GLOBAL_ALLOCMEM

        hMem = GlobalHandle(Ptr);
        GlobalUnlock(hMem);
        hMem = GlobalReAlloc(hMem,Bytes,Flag);
        return GlobalLock(hMem);
#else
        hMem = LocalHandle(Ptr);
        LocalUnlock(hMem);
        hMem = LocalReAlloc(hMem,Bytes,Flag);
        return LocalLock(hMem);
#endif
}
HGLOBAL __fastcall TCNString::GlobalFreePtr(void *Ptr) const
{
        HGLOBAL hMem;

#ifdef  GLOBAL_ALLOCMEM

        hMem = GlobalHandle(Ptr);

        GlobalUnlock(hMem);

        hMem = GlobalFree(hMem);
#else
        hMem = LocalHandle(Ptr);

        LocalUnlock(hMem);

        hMem = LocalFree(hMem);
#endif
        return hMem;
}
DWORD __fastcall TCNString::GlobalSizePtr(void *Ptr) const
{
        HGLOBAL hMem;

#ifdef  GLOBAL_ALLOCMEM

        hMem = GlobalHandle(Ptr);

        return GlobalSize(hMem);
#else
        hMem = LocalHandle(Ptr);

        return LocalSize(hMem);
#endif
}

void __fastcall TCNString::Error(const char *ErrorMsg) const
{
        throw;
}
__fastcall TCNString::TCNString(const char* src)
{
        DWORD Size = strlen(src) + 1;

        if( strlen(src) == 0)
        {
                this->Data = NULL;
                return;
        }
        this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Size);

        if( this->Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                strcpy(this->Data,src);
        }
}
__fastcall TCNString::TCNString(const TCNString& src)
{
        DWORD Size = src.Length() + 1;

        if( src.IsEmpty())
        {
                this->Data = NULL;
                return;
        }
        
        this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Size);

        if( this->Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                strcpy(this->Data,src.Data);
        }

}
__fastcall TCNString::TCNString(const char* src, unsigned int len)
{
        if( len > strlen(src) ) len = strlen(src);

        if( len == 0)
        {
                this->Data = NULL;
                return;
        }
        DWORD Size = len + 1;

        this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Size);

        if( this->Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                memcpy(this->Data,src,len);
                this->Data[len] = '\0';
        }
}
__fastcall TCNString::TCNString(char src)
{
        this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,2);

        if( this->Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                this->Data[0] = src;
                this->Data[1] = '\0';
        }
}

__fastcall TCNString::~TCNString()
{
        if( this->Data != NULL && this->Length() > 0)
        {
                GlobalFreePtr(this->Data);    //??????????
        }
        this->Data = NULL;
}

TCNString& __fastcall TCNString::operator  =(const TCNString& rhs)
{
        DWORD Length = this->Length();
        DWORD Size   = rhs.Length();

        if( rhs.IsEmpty())
        {
                this->Data = NULL;
                return *this;
        }

        if( Length != Size)
        {
                if( (this->Data != NULL) && (Length > 0) )
                {
                        GlobalFreePtr(this->Data);
                }

                this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Size + 1);

                if( this->Data == NULL)
                {
                        Error("无法分配内存!");
                }
        }
        if( this->Length() > 0)  strcpy(this->Data,rhs.Data);

        return *this;
}
TCNString& __fastcall TCNString::operator  =(const char *s)
{
        DWORD Length = this->Length();
        DWORD Size   = strlen(s);

        if( strlen(s) == 0)
        {
                this->Data = NULL;
                return *this;
        }
        if( Length != Size)
        {
                if( Length != 0) GlobalFreePtr(this->Data);

                this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Size + 1);

                if( this->Data == NULL)
                {
                        Error("无法分配内存!");
                }
        }
        if( this->Length() > 0) strcpy(this->Data,s);

        return *this;
}

TCNString __fastcall TCNString::operator +(const TCNString& rhs) const
{
        TCNString Tmp ;

        DWORD Size = Length() + rhs.Length() + 1;

        if( rhs.IsEmpty())  return *this;

        Tmp.Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Size);

        if( Tmp.Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                if( Length() > 0)
                {
                        strcpy(Tmp.Data,this->Data);
                        strcat(Tmp.Data,rhs.Data);
                }
                else
                {
                        strcpy(Tmp.Data,rhs.Data);
                }
        }
        return Tmp;
}

TCNString __fastcall TCNString::operator +(char *s) const
{

        TCNString Tmp;

        DWORD Size = this->Length() + strlen(s) + 1;

        if( strlen(s) == 0) return *this;
        
        Tmp.Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Size);

        if( Tmp.Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                if( this->Length() > 0)
                {
                        strcpy(Tmp.Data,this->Data);
                        strcat(Tmp.Data,s);
                }
                else
                {
                        strcpy(Tmp.Data,s);
                }
        }
        return Tmp;
}
TCNString __fastcall operator +(char *src, const TCNString& rhs)
{
        TCNString sTmp;

        if(!rhs.IsEmpty())
        {
                sTmp = src;
        }

        sTmp = sTmp + rhs;

        return sTmp;
}

TCNString& __fastcall TCNString::operator +=(const TCNString& rhs)
{
        int Len = this->Length() + rhs.Length() + 1;

        if( rhs.IsEmpty()) return *this;

        if( this->Length() > 0)
        {
                this->Data = (char *)GlobalReAllocPtr(this->Data,Len,GMEM_MOVEABLE);
        }
        else
        {
                this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,Len);
        }

        if( this->Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                strcat(this->Data,rhs.Data);
        }

        return *this;
}
TCNString& __fastcall TCNString::operator +=(const char *s)
{
        int Len = this->Length() + strlen(s) + 1;

        if( strlen(s) == 0) return *this;

        if( this->Length() > 0)
        {
                this->Data = (char *)GlobalReAllocPtr(this->Data,Len,GMEM_MOVEABLE);
        }