Files
mir_server/sdk/srvlib/include/AnsiString.hpp
aixianling 5c9f1dae4a init
2025-01-09 17:45:40 +08:00

348 lines
6.9 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#ifndef _WYLIB_ANSISTRING_H_
#define _WYLIB_ANSISTRING_H_
/******************************************************************
*
* wyLib库 2008 - 2010
*
* $ UCS2字符串类 $
*
* - 主要功能 -
*
* 实现UCS字符串的基本操作包括与UCS2字符指针的相互操作
*
*****************************************************************/
#include <stdlib.h>
namespace wylib
{
namespace string
{
class CWideString;
class CAnsiString
{
public:
typedef char CharType;
typedef char* RawStrType;
private:
char* m_sStr;
private:
static const char* EMPTY_STR;
protected:
/**
* realloc 内存申请、释放函数,如果需要关心内存的申请和释放,子类可以继承此函数
* ptr: 申请、释放的指针
* newsize: 申请内存字节数若为0则表示释放ptr指针
* 若ptr和newsize都不为0则表示对ptr内存块重新申请大小
*/
virtual void* alloc(void* ptr, size_t newsize)
{
if ( newsize == 0 )
{
if ( ptr ) free( ptr );
return NULL;
}
return realloc( ptr, newsize );
}
/**
*setData:设定字符串数据
*data: 指向原始字符串的指针
*/
inline void setData(const char* data)
{
if ( data )
{
size_t size = strlen(data) + 1;
size *= sizeof(*data);
m_sStr = (char*)alloc( m_sStr, size );
memcpy( m_sStr, data, size );
}
else m_sStr = (char*)alloc( m_sStr, 0 );
}
/**
* catData 与现有字符串内容连接
* data: 指向原始字符串的指针,字符串内容会被连接到当前字符串之后
*/
inline void catData(const char* data)
{
if ( data )
{
size_t cat_size = strlen(data);
size_t cur_size = length();
m_sStr = (char*)alloc( m_sStr, (cat_size + cur_size + 1) * sizeof(*data) );
memcpy( &m_sStr[cur_size], data, (cat_size + 1) * sizeof(*data) );
}
}
public:
CAnsiString()
{
m_sStr = NULL;
}
CAnsiString(const char* data)
{
m_sStr = NULL;
setData( data );
}
CAnsiString(const CAnsiString &str)
{
m_sStr = NULL;
setData( str.m_sStr );
}
virtual ~CAnsiString()
{
setData( NULL );
}
public:
/**
* 类型转换函数,转换为(const char*)。
* 注意: 如果当前字符串为NULL则会返回""而不是NULL。
*/
inline operator const char*() const
{
return m_sStr ? m_sStr : EMPTY_STR;
}
/**
* 类型转换函数,转换为(const char*)。
* 注意如果当前字符串为NULL则会返回""而不是NULL。
*/
inline operator char*()
{
return m_sStr ? m_sStr : NULL;
}
/**
*赋值函数,赋予(const char*)类型的值
*/
inline void operator = (const char* data)
{
if ( data != m_sStr )
{
setData( data );
}
}
/**
* 赋值函数,赋予相同类型的值
*/
inline void operator = (const CAnsiString& str)
{
if ( &str != this )
{
setData( str.m_sStr );
}
}
/**
* 与(const char*)类型的字符串连接
*/
inline void operator += (const char* data)
{
if ( data != m_sStr )
{
catData( data );
}
else
{
CAnsiString wstr(m_sStr);
catData(wstr.m_sStr);
}
}
/**
* 与自己或其他字符串连接
*/
inline void operator += (const CAnsiString& str)
{
if ( &str != this )
{
catData( str.m_sStr );
}
else
{
CAnsiString wstr(m_sStr);
catData(wstr.m_sStr);
}
}
/**
* 与(const char*)类型进行加法运算并返回连接后的CAnsiString类
*/
inline const CAnsiString operator + (const char* data)
{
CAnsiString str( m_sStr );
str.catData( data );
return str;
}
/**
* 与另一个字符串进行加法运算并返回连接后的CAnsiString类
*/
inline const CAnsiString operator + (const CAnsiString& str)
{
CAnsiString _str( m_sStr );
_str.catData( str.m_sStr );
return _str;
}
/**
* 判断与(const char*)类型的字符串指针中的字符串数据是否相同(区分大小小写)
*/
inline bool operator == (const char* data) const
{
return compare( data ) == 0;
}
/**
* 判断与另一个字符串的数据是否相同(区分大小小写)
*/
inline bool operator == (const CAnsiString& str) const
{
return compare( str.m_sStr ) == 0;
}
/**
* 判断与(const char*)类型的字符串指针中的字符串数据是否不相同(区分大小小写)
*/
inline bool operator != (const char* data) const
{
return compare( data ) != 0;
}
/**
* 判断与另一个字符串的数据是否不相同(区分大小小写)
*/
inline bool operator != (const CAnsiString& str) const
{
return compare( str.m_sStr ) != 0;
}
/**
* 判断是否非空
*/
inline bool operator ! () const
{
return !m_sStr || !m_sStr[0];
}
public:
/**
* 取得字符串指针
*/
inline const char* rawStr() const
{
return m_sStr;
}
/**
* 取得字符串指针
*/
inline char* rawStr()
{
return m_sStr;
}
/**
* 取得字符串长度
*/
inline size_t length() const
{
return m_sStr ? strlen(m_sStr) : 0;
}
/**
* 设置字符串长度(保留空间)
*/
inline void setLength(const size_t len)
{
if ( len > 0 )
{
m_sStr = (char*)alloc( m_sStr, sizeof(m_sStr[0]) * (len + 1) );
if ( m_sStr ) m_sStr[len] = 0;
}
else m_sStr = (char*)alloc( m_sStr, 0 );
}
/**
* 与另一个字符串指针对比
*/
inline int compare(const char* data) const
{
if ( !m_sStr || !m_sStr[0] )
{
if ( !data || !data[0] )
return 0;
else return 1;
}
return strcmp( m_sStr, data );
}
/**
* 与另一个字符串类进行对比
*/
inline int compare(const CAnsiString& str) const
{
if ( !m_sStr || !m_sStr[0] )
{
if ( !str.m_sStr || !str.m_sStr[0] )
return 0;
else return 1;
}
return strcmp( m_sStr, str.m_sStr );
}
/**
*判断是否为空字符串
*/
inline bool isEmpty() const
{
return !m_sStr || !m_sStr[0];
}
/**
* 转换字符串编码为UCS-2LE格式。
* 如果sOutput参数不为且编码转换成功则函数将转换结果赋值给sOutput参数并返回sOutput
* 若转换失败则返回null且sOutput的内容可能仍然会改变
* 如果sOutput参数为空且函数转换编码成功则返回新的CWideString对象此时调用者需要再合适的时候delete返回值
* 转换失败则函数返回NULL
*/
CWideString* toWStr(CWideString* sOutput = NULL) const;
/**
* 格式化字符串
*/
size_t format(const char* fmt, ...);
size_t format_args(const char* fmt, va_list _Args);
};
};
};
#endif