适合于Unix与Win32下的字符串处理类,可以以此为基类进行扩展

原创 2002年06月20日 09:35:00

/****************************CString.h******************************/

#ifndef MyStringH
#define MyStringH

#ifndef WIN32
typedef int bool;
#define false 0
#define true !false
#endif

class CString{
public:
       CString();
       CString(const char *str);
       CString(CString &str);
       virtual ~CString();

      
       const char * c_str()const;
       CString& sprintf(const char* format, ...);
       int Length() const;
       CString  Trim() const;
       CString  TrimLeft() const;
       CString  TrimRight() const;
       CString  UpperCase() const;
       CString  LowerCase() const;
       CString  StringOfChar(char ch, int count)const;//StringOfChar('A',4)returns "AAAA"  

       CString  operator+(const CString &str); file://Not return reference
       CString  operator +(const char* lhs);
       CString &operator +=(const CString& rhs);
       CString &operator=(const CString &str);

       char &operator [](const int idx);
       bool  operator !=(const CString& rhs) const;
       bool  operator <(const CString& rhs) const;
       bool  operator <=(const CString& rhs) const;
       bool  operator ==(const CString& rhs) const;
       bool  operator >(const CString& rhs) const;
       bool  operator >=(const CString& rhs) const;
       file://返回被分隔符分割的字符串,如CString("ab|cd")::GetDelimitedString("|",1)返回"cd"
       CString GetDelimitedString(const char *delimiter,int index);
private:
       char cTmp;//when operator[] over range,use this var
       char *_data;//store the data
};

#endif

/****************************CString.cpp******************************/

file://---------------------------------------------------------------------------

#include "CString.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>

file://---------------------------------------------------------------------------
CString::CString():_data(0)
{
  _data=new char[1];
  _data[0]='/0';
}
file://-------------------------------------------------------------------
CString::CString(const char *str):_data(0)
{
  if(str)
  {
    _data=new char[strlen(str)+1];
    file://memset(_data,0x00,strlen(str)+1);
    strcpy(_data,str);
  }
  else
  {
    _data=new char[1];
    _data[0]='/0';           
  }
}
file://--------------------------------------------------------------------
CString::CString(CString &str):_data(0)
{
  file://必须在拷贝函数中为动态分配空间的指针分配空间
  _data=new char[str.Length()+1];
  strcpy(_data,str._data);
}
file://----------------------------------------------------------------------
CString::~CString()
{
  delete []_data;
}
file://---------------------------------------------------------------------
file://return the length of this string,not counting the null-terminating character.
int CString::Length() const
{
  return strlen(_data);
}
file://-----------------------------------------------------------------------
CString & CString::operator=(const CString &str)
{      
  if(this==&str) file://can't be "this==str"
  {
    return *this;
  }
  delete []_data;//for the previous 'new'
  _data=new char[str.Length()+1];
  strcpy(_data,str._data);
  return *this;
}
file://------------------------------------------------------------------------
file://the value returned by c_str points to the internal character
file://array referenced by the _data property
const char * CString::c_str()const
{
  return _data;
}
file://----------------------------------------------------------------------
CString&  CString::sprintf(const char* format, ...)
{
#ifdef WIN32
    delete []_data;
    va_list paramList;
    va_start(paramList, format);
    int size = vsnprintf(NULL, 0, format, paramList);
    _data=new char[size+1];
    memset(_data,0x00,size+1);
    vsnprintf(_data, size, format, paramList);//Only for WIN32
    va_end(paramList);
    return *this;
#else
    delete []_data;
    _data=new char[1024*5];//maxsize:5k,may cause overflow
    va_list paramList;
    va_start(paramList, format);
    vsprintf(_data,format, paramList);
    va_end(paramList);
    return *this;
#endif
}
file://--------------------------------------------------------------------
CString CString::operator+(const CString &str)
{
  CString tmp;
  tmp=*this;
  delete []_data;
  _data=new char[tmp.Length()+str.Length()+1];
  memset(_data,0x00,tmp.Length()+str.Length()+1);
  strcpy(_data,tmp.c_str());
  strcat(_data,str.c_str());
  return *this;
}
file://-----------------------------------------------------------------------
CString  CString::operator +(const char* str)
{
  CString tmp;
  tmp=*this;
  delete []_data;
  _data=new char[tmp.Length()+strlen(str)+1];
  memset(_data,0x00,tmp.Length()+strlen(str)+1);
  strcpy(_data,tmp.c_str());
  strcat(_data,str);
  return *this;
}
file://-----------------------------------------------------------------------
CString &CString::operator +=(const CString& rhs)
{
  CString tmp;
  tmp=*this;
  delete []_data;
  _data=new char[tmp.Length()+rhs.Length()+1];
  memset(_data,0x00,tmp.Length()+rhs.Length()+1);
  strcpy(_data,tmp.c_str());
  strcat(_data,rhs.c_str());
  return *this;
}
file://------------------------------------------------------------------------
char &CString::operator [](const int idx)
{
  if( (idx<0) || (idx>Length()-1) )
    return cTmp;//if over range,return the reference of cTmp
  else
    return _data[idx];
}
file://----------------------------------------------------------------------
bool  CString::operator !=(const CString& rhs) const
{
   if( strcmp(_data,rhs.c_str())!=0)
     return true;
   else
     return false;
}
file://--------------------------------------------------------------------------
bool  CString::operator <(const CString& rhs) const
{
   if( strcmp(_data,rhs.c_str())<0)
     return true;
   else
     return false;
}
file://----------------------------------------------------------------------
bool  CString::operator <=(const CString& rhs) const
{
   if( strcmp(_data,rhs.c_str())<=0)
     return true;
   else
     return false;
}
file://-----------------------------------------------------------------------
bool  CString::operator ==(const CString& rhs) const
{
   if( strcmp(_data,rhs.c_str())==0)
     return true;
   else
     return false;
}
file://--------------------------------------------------------------------
bool  CString::operator >(const CString& rhs) const
{
   if( strcmp(_data,rhs.c_str())>0)
     return true;
   else
     return false;
}
file://----------------------------------------------------------------------
bool  CString::operator >=(const CString& rhs) const
{
   if( strcmp(_data,rhs.c_str())>=0)
     return true;
   else
     return false;
}
file://-----------------------------------------------------------------------
CString  CString::TrimLeft() const
{
  CString Result;
  char *pDest,*pTmp;
  pTmp=new char[Length()+1];
  memset(pTmp,0x00,Length()+1);
  strcpy(pTmp,_data);
  pDest=pTmp;

  for(int i=0;i<Length();i++)
  {
    if( (*pDest==' ') || (*pDest=='/n') || (*pDest=='/t') )
      pDest++;
    else
      break;
  }
  Result=pDest;
  delete []pTmp;
  return Result;
}
file://-----------------------------------------------------------------------
CString  CString::TrimRight() const
{
  CString Result;
  char *pDest,*pTmp;
  pTmp=new char[Length()+1];
  memset(pTmp,0x00,Length()+1);
  strcpy(pTmp,_data);
  pDest=pTmp+Length()-1;

  for(int i=Length();i>0;i--)
  {
    if( (*pDest==' ') || (*pDest=='/n') || (*pDest=='/t') )
      pDest--;
    else
      break;
  }
  *(++pDest)=0;//Cut to here
  Result=pTmp;
  delete []pTmp;
  return Result;
}
file://-----------------------------------------------------------------------
CString  CString::Trim() const
{
  CString Result;
  char *pDest,*pTmp,*p;
  pTmp=new char[Length()+1];
  memset(pTmp,0x00,Length()+1);
  strcpy(pTmp,_data);
  pDest=pTmp;

  for(int i=0;i<Length();i++)
  {
    if( (*pDest==' ') || (*pDest=='/n') || (*pDest=='/t') )
      pDest++;
    else
      break;
  }
  p=pTmp+Length()-1;

  for(int j=Length();j>0;j--)
  {
    if( (*p==' ') || (*p=='/n') || (*p=='/t') )
      p--;
    else
      break;
  }
  *(++p)=0;//Cut to here

  Result=pDest;
  delete []pTmp;
  return Result;
}
file://-----------------------------------------------------------------------
CString  CString::UpperCase() const
{
  CString Result;
  char *pTmp;
  pTmp=new char[Length()+1];
  memset(pTmp,0x00,Length()+1);
  strcpy(pTmp,_data);
  for(int i=0;i<Length();i++)
  {
    if( (pTmp[i]>='a') && (pTmp[i]<='z') )
    {
      pTmp[i]-=('a'-'A');
    }
  }
  Result=pTmp;
  delete []pTmp;
  return Result;
}
file://-----------------------------------------------------------------------
CString  CString::LowerCase() const
{
  CString Result;
  char *pTmp;
  pTmp=new char[Length()+1];
  memset(pTmp,0x00,Length()+1);
  strcpy(pTmp,_data);
  for(int i=0;i<Length();i++)
  {
    if( (pTmp[i]>='A') && (pTmp[i]<='Z') )
    {
      pTmp[i]+=('a'-'A');
    }
  }
  Result=pTmp;
  delete []pTmp;
  return Result;
}
file://-------------------------------------------------------------------------
CString  CString::StringOfChar(char ch, int count)const
{
  CString str;
  char *pTmp;
  pTmp=new char[count+1];
  memset(pTmp,0x00,count+1);
  for(int i=0;i<count;i++)
  {
    pTmp[i]=ch;
  }
  str=pTmp;
  delete []pTmp;
  return str;
}
file://-----------------------------------------------------------------------
file://返回被分隔符分割的字符串,如
file://GetDelimitedString("ab,cd,ef",",",1) 返回"cd"
file://GetDelimitedString("ab,,ef",",",1) 返回"ef"
CString CString::GetDelimitedString(const char *delimiter,int index)
{
   CString strResult;
   int iIndex=0;
   int iLength=Length()+1;
   char *pSource=new char[iLength];
   char *p=NULL;
   memset(pSource,0,iLength);
   memcpy(pSource,_data,iLength);
   p=strtok(pSource,delimiter);
   while(p)
   {
     if(iIndex==index)
     {
        strResult=CString(p);
        break;
     }
     iIndex++;
     p=strtok(NULL,delimiter);
   }
   delete []pSource;
   pSource=NULL;
   return strResult;
}
file://-----------------------------------------------------------------------
#ifdef TEST
main()
{
  char *p="test";
  CString strA("1234");
  CString strB="123456";
  strA=strB.GetDelimitedString("/",1);
  CString strF;
  strF.sprintf("[%s]",strA.c_str());
  strF=strA.StringOfChar('A',3);
  printf("[%s]/n",strF.c_str());
}   
#endif

 

如何对一个类进行扩展?

如何对一个类进行扩展? 在对类的处理中,我们会应用到的主要由四种方式, 一、    继承(inherit) 面向对象程序有三大特性,封装、继承、多态。    封装就是对一个类或者我们需要的一系...
  • V5V6_neil
  • V5V6_neil
  • 2014年07月06日 20:48
  • 745

java中常用的字符串处理类

JAVA中用于处理字符串常用的有三个类:java.lang.String、java.lang.StringBuffer、java.lang.StringBuilder,这三者的共同之处都是final类...
  • guangmingfupin
  • guangmingfupin
  • 2016年02月24日 17:22
  • 1207

深入理解Win32结构化异常处理(三)

转载URL:http://www.cnblogs.com/salomon/archive/2012/06/20/2556349.html [翻译]深入理解Win32结构化异常处理(三) __e...
  • cosmoslife
  • cosmoslife
  • 2015年09月30日 11:04
  • 562

Win32 窗体风格说明

体风格是各种窗口开发的重要基础之一。它可以分为普通风格(WS_系列)和扩展风格(WS_EX_系列)。从其特点上来说,主要分两大类: 1、一类表明窗口和其他窗口的关系,如:WS_CHILD、WS_...
  • leehong2005
  • leehong2005
  • 2013年02月25日 14:35
  • 1811

win32宽字符串处理

文章首发:http://pjf.name/post-118.html 本文基于"姓名标识-非商业性-相同方式分享 4.0国际"协议创作或转载,转载原创文章请注明来源于疯子的自留地,否则请勿转载或...
  • penjianfeng
  • penjianfeng
  • 2014年03月19日 10:36
  • 330

C#扩展方法类库StringExtensions

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.T...
  • fuyifang
  • fuyifang
  • 2014年10月21日 22:29
  • 2491

OC中的类别、类扩展与协议

类别(category)功能: 1. 类别可以给原有的类添加新功能 2. 可以在方法内部访问原有类的成员变量和方法//ZZPerson.h @interface ZZPerson : NSObje...
  • zhongjiezheng
  • zhongjiezheng
  • 2015年10月31日 20:17
  • 688

java处理json的工具类

下载jar 包 net.sf.json package com.itjh.mmp.util; import java.io.BufferedReader; import java.io.InputSt...
  • youyou_yo
  • youyou_yo
  • 2015年06月11日 11:39
  • 1132

Java 7之基础类型第6篇 - Java可变字符串类型

String、StringBuilder、StringBuffer的异同点 结合之前写的博文,我们对这三个常用的类的异同点进行分析: 异同点: 1>String的对象是不可变的;而StringBui...
  • mazhimazh
  • mazhimazh
  • 2013年12月31日 20:59
  • 3465

UNIX操作系统类型

UNIX操作系统类型 由于Unix操作系统众所周知的稳定性、可靠性,用来提供各种Internet服务的计算机运行的操作系统占很大比例的是Unix及Unix类操作系统。目前比较常见的运行在PC机上的U...
  • zxxSsdsd
  • zxxSsdsd
  • 2014年03月26日 11:27
  • 2104
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:适合于Unix与Win32下的字符串处理类,可以以此为基类进行扩展
举报原因:
原因补充:

(最多只允许输入30个字)