cnstring.cpp

这是一个远程控制程序

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

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

bool __fastcall TCNString::operator ==(const TCNString& rhs) const
{
        if( (this->Data == NULL && rhs.Data != NULL) || (this->Data != NULL && rhs.Data == NULL))
        {
                return false;
        }
        else if(this->Data == NULL && rhs.Data == NULL)
        {
                return true;
        }
        else
        {
                return strcmp(this->Data,rhs.Data) == 0;
        }
}
bool __fastcall TCNString::operator ==(const char *s) const
{
        if( (this->Data == NULL && s != NULL) || (this->Data != NULL && s == NULL))
        {
                return false;
        }
        else if(this->Data == NULL && s == NULL)
        {
                return true;
        }
        else
        {
                return strcmp(this->Data,s) == 0;
        }
}
bool __fastcall TCNString::operator !=(const TCNString& rhs) const
{
        return strcmp(this->Data,rhs.Data) != 0;
}
bool __fastcall TCNString::operator !=(const char *s) const
{
        return strcmp(this->Data,s) != 0;
}

bool __fastcall TCNString::operator < (const TCNString& rhs) const
{
        return strcmp(this->Data,rhs.Data) < 0;
}
bool __fastcall TCNString::operator > (const TCNString& rhs) const
{
        return strcmp(this->Data,rhs.Data) > 0;
}
bool __fastcall TCNString::operator <=(const TCNString& rhs) const
{
        return !operator>(rhs);
}
bool __fastcall TCNString::operator >=(const TCNString& rhs) const
{
        return !operator<(rhs);
}

int __fastcall TCNString::Find(char c,int Start) const
{
        int MatchIndex;

        for(MatchIndex = Start; MatchIndex < this->Length(); MatchIndex++)
        {
                if( this->Data[MatchIndex] == c)
                {
                        return MatchIndex;
                }
        }
        return -1;
}
int __fastcall TCNString::FindLast(char c) const
{
        int MatchIndex;
        for(MatchIndex = this->Length() - 1; MatchIndex >= 0; MatchIndex--)
        {
                if( this->Data[MatchIndex] == c)
                {
                        return MatchIndex;
                }
        }
        return -1;
}

int __fastcall TCNString::Pos(const TCNString& subStr) const
{
        char    PatStartChar,PatEndChar;
        int     PatLength;

        int     PatInc;

        int SearchIndex,MatchStart,MatchEnd;
        int LastStrIndex;

        TCNString InsidePattern;

        PatStartChar = subStr[0];
        PatLength    = subStr.Length();
        PatInc       = PatLength - 1;
        PatEndChar   = subStr[PatInc];

        if( PatLength > 2)
                InsidePattern = subStr.SubString(1,PatLength - 2);

        LastStrIndex = this->Length() - 1;

        SearchIndex = 0;

        MatchStart = Find(PatStartChar,SearchIndex);

        MatchEnd = MatchStart + PatInc;

        while( MatchStart != -1 && MatchEnd <= LastStrIndex)
        {
                if( (this->Data)[MatchEnd] == PatEndChar)
                {
                        if( PatLength <= 2)
                                return MatchStart;
                        if( SubString(MatchStart + 1, PatLength - 2) == InsidePattern)
                                return MatchStart;
                }
                SearchIndex = MatchStart + 1;
                MatchStart = Find(PatStartChar,SearchIndex);
                MatchEnd = MatchStart + PatInc;
        }
        return -1;
}
TCNString   __fastcall TCNString::LowerCase() const
{
        TCNString Tmp;

        Tmp.Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,this->Length());

        if( Tmp.Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                strcpy(Tmp.Data,this->Data);
        }
        for(register i = 0; i < this->Length(); i++)
        {
                if( Tmp.Data[i] >= 'A' && Tmp.Data[i] <= 'Z')
                {
                        Tmp.Data[i] = 'a' + (Tmp.Data[i] - 'A');
                }
        }
        return Tmp;
}
TCNString   __fastcall TCNString::UpperCase() const
{
        TCNString Tmp;

        Tmp.Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,this->Length());

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

        for(register i = 0; i < this->Length(); i++)
        {
                if( Tmp.Data[i] >= 'a' && Tmp.Data[i] <= 'z')
                {
                        Tmp.Data[i] = 'A' + (Tmp.Data[i] - 'a');
                }
        }
        return Tmp;
}
TCNString __fastcall TCNString::Trim() const
{
        int i,j;
        TCNString Tmp;

        j = this->Length() -1;
        i = 0;
        while ((i <= j) && ((*this)[i] <= ' ')) i++;

        if( i > j)
        {
                Tmp = "";
        }
        else
        {
                while( (*this)[j] <= ' ') j--;

                Tmp = this->SubString(i,(j-i) + 2);
        }
        return Tmp;
}
TCNString __fastcall TCNString::TrimLeft() const
{
        int I, L;
        TCNString sTmp;

        L = this->Length() - 1;
        I = 0;
        while ((I <= L) && ((*this)[I] <= ' ')) I++;

        if( I > L )
        {
                sTmp = "";
        }
        else
        {
                sTmp = this->SubString(I, L-I + 1);
        }

        return sTmp;
}
TCNString   __fastcall TCNString::TrimRight() const
{
        int I;
        TCNString sTmp;
        I = this->Length() - 1;
        while ((I >= 0) && ((*this)[I] <= ' ')) I--;
        if( I < 0)
        {
                sTmp = "";
        }
        else
        {
                sTmp = this->SubString(0,I + 1);
        }
        return sTmp;
}
TCNString   __fastcall TCNString::SubString(int index, int count) const
{
        int i;
        int CharsLeft = this->Length() - index - 1;

        TCNString Tmp;
        char *p,*q;

        if( (index >= this->Length()) || (this->Length() == 0) )
        {
                return Tmp;
        }

        if( (index + count) > this->Length())
        {
                count = this->Length() - index;
        }

        Tmp.Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,count + 1);

        if( Tmp.Data == NULL)
        {
                Error("无法分配内存!");
        }
        else
        {
                memcpy( Tmp.Data, (this->Data + index), count);
                Tmp.Data[ count ] = '\0';
        }
        return Tmp;
}
int __fastcall TCNString::ToInt() const
{
        return atoi(this->Data);
}
double __fastcall TCNString::ToDouble() const
{
        return atof(this->Data);
}
TCNString&  __fastcall TCNString::Insert(const TCNString& str, int index)
{
        return *this;
}
TCNString&  __fastcall TCNString::Delete(int index, int count)
{
        DWORD TotalSize = this->Length();

        if( (DWORD)(index + count) <= TotalSize)
        {
                MoveMemory(this->Data + index,this->Data + (index + count),TotalSize - (index + count) + 1);
                SetLength(TotalSize - count + 1);                
        }
        return *this;
}
TCNString&  __fastcall TCNString::SetLength(int newLength)
{
        if( this->Length() < newLength)
        {
                if( this->Length() == 0)
                {
                        this->Data = (char *)GlobalAllocPtr(GMEM_MOVEABLE,newLength);
                }
                else
                {
                        this->Data = (char *)GlobalReAllocPtr(this->Data,newLength,GMEM_MOVEABLE);
                }
        }
        return *this;
}
int  __fastcall TCNString::Length() const
{
        if( this->Data == NULL)
                return 0;
        else    return strlen(this->Data);
}