自定义的字符串类型

标签：

自定义字符串对象，继承于动态数组模板类（动态数组模板类实现了内存管理，可减少内存分配和内存拷贝，优化追加数组等，参考http://blog.csdn.net/chenjiayi_yun/article/details/44752051），重载了字符串常用的追加字符串、格式化字符串、字符串比较等操作。

类头文件，如下：

class AnsiString : public Array<char>
{
public:
typedef Array<char> super;
public:
AnsiString():super()//默认构造函数
{
}
AnsiString(const AnsiString &another)//拷贝构造函数
	:super(another)
{
}
AnsiString(const char* str)//字符串初始化构造函数
	:super(str, str ? strlen(str) : 0)
{
}
AnsiString(const char* str, size_t len)//字符串初始化构造函数
	:super(str, len)
{
}
AnsiString(const size_t len):super(len)//构造函数（预留内存大小）
{
}
AnsiString(size_t max, const char* fmt, ...):super() //字符串格式化
{
	va_list args;
	va_start(args, fmt);
	if (max != 0)
		formatArgs(max, fmt, args);
	else formatArgs(fmt, args);
	va_end(args);
}
inline AnsiString& operator = (const char* str)
{
	size_t len = str ? strlen(str) : 0;
	setLength(0);
	if (len > 0)
	{
		setLength(len);
		memcpy(m_ptr, str, len * sizeof(*m_ptr));
	}
	return *this;
}
inline AnsiString& operator = (const AnsiString& str)
{
	super::operator = (str);
	return *this;
}
inline AnsiString& operator += (const char* str)
{
	if (!str || !str[0])
		return *this;
	cat(str, strlen(str));
	return *this;
}
inline AnsiString& operator += (const AnsiString& str)
{
	super::operator += (str);
	return *this;
}
AnsiString operator + (const char* str) const;
inline AnsiString operator + (const AnsiString& str) const
{
	AnsiString as = *this;
	as += str;
	return as;
}
inline bool operator == (const AnsiString& another) const
{
	const char* aptr = another.ptr();
	if (m_ptr == aptr)
		return true;
	if (!m_ptr || !aptr)
		return false;
	if (length() != another.length())
		return false;
	return compare(another) == 0;
}
inline bool operator == (const char* str) const
{
	if (m_ptr == str)
		return true;
	if (!m_ptr || !str)
		return false;
	return compare(str) == 0;
}
//比较字符串是否相等
inline bool operator != (const AnsiString& another) const
{
	return !(operator == (another));
}
//比较字符串是否相等
inline bool operator != (const char* str) const
{
	return !(operator == (str));
}
//重载小于操作符
inline bool operator < (const AnsiString& another) const
{
	return compare(another) < 0;
}
//重载小于操作符
inline bool operator < (const char* another) const
{
	return compare(another) < 0;
}
//重载大于操作符
inline bool operator > (const AnsiString& another) const
{
	return compare(another) > 0;
}
//重载大于操作符
inline bool operator > (const char* another) const
{
	return compare(another) > 0;
}
//比较字符串大小
int compare(const AnsiString& another) const;
//比较字符串大小
inline int compare(const char* str) const
{
	return strcmp(m_ptr, str);
}
//字符串格式化
AnsiString& format(const AnsiString fmt, ...);
AnsiString& format(const char* fmt, ...);
AnsiString& format(size_t max, const AnsiString fmt, ...);
AnsiString& format(size_t max, const char* fmt, ...);
AnsiString& formatArgs(const char *fmt, va_list args);
AnsiString& formatArgs(size_t max, const char *fmt, va_list args);
AnsiString& catWith(size_t max, const char *fmt, ...);
AnsiString& catWithArgs(size_t max, const char *fmt, va_list args);
inline static size_t formatStringArgs(char *buffer, size_t max, const char *fmt, va_list args);
double toNumber() const;
inline float toSingle() const
{
	return (float)toNumber();
}
inline int toInt() const
{
	return (int)toNumber();
}
long long toInt64() const;

AnsiString AnsiString::operator + (const char* str) const//追加字符串长度
{
	if (!str || !str[0])
		return *this;

	size_t myCount = length();//本对象的有效长度
	size_t srcLen = strlen(str);//追加字符串长度
	AnsiString result(myCount + srcLen);//结果对象
	char *destPtr = result.own_ptr();//获取结果对象的可写内存指针（新的内存对象，需要获取新的可写对象，否则result的内存对象会在本函数结束时回收）
	if (myCount > 0)
	{
		memcpy(destPtr, m_ptr, myCount * sizeof(*m_ptr));//复制本对象的数组对象数据到结果对象的内存中
		destPtr += myCount;//移动数据指针
	}
	memcpy(destPtr, str, srcLen * sizeof(*m_ptr));//拷贝字符串的数据到结果对象的追加位置
	destPtr += srcLen;
	return result;
}
//比较两个字符串对象大小
int AnsiString::compare(const AnsiString& another) const
{
	if (another.ptr() == m_ptr)
		return 0;
	int cmp = (int)(length() - another.length());//字符串长度比较
	if (cmp != 0)
		return cmp;
	return strcmp(m_ptr, another.m_ptr);//比较字符串数据指针指向的字符串数据
}
//字符串格式化到字符串对象数据内存 
AnsiString& AnsiString::format(const AnsiString fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	formatArgs(fmt.ptr(), args);
	va_end(args);
	return *this;
}
//字符串格式化到字符串对象数据内存 
AnsiString& AnsiString::format(const char* fmt, ...)//字符串格式化
{
	va_list args;
	va_start(args, fmt);
	formatArgs(fmt, args);
	va_end(args);
	return *this;
}
//字符串格式化到字符串对象数据内存(指定最大长度)
AnsiString& AnsiString::format(size_t max, const AnsiString fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	formatArgs(max, fmt.ptr(), args);
	va_end(args);
	return *this;
}
//字符串格式化(指定最大长度)
AnsiString& AnsiString::format(size_t max, const char* fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	formatArgs(max, fmt, args);
	va_end(args);
	return *this;
}
//格式化字符串到字符对象的数据内存(限定最大长度)
AnsiString& AnsiString::formatArgs(const char *fmt, va_list args)
{
	char buffer[4059];
	size_t len = formatStringArgs(buffer, sizeof(buffer)/sizeof(buffer[0]), fmt, args);
	setLength(len);
	memcpy(m_ptr, buffer, len * sizeof(*m_ptr));
	return *this;
}
//格式化字符串到字符对象的数据内存(限定最大长度)
AnsiString& AnsiString::formatArgs(size_t max, const char *fmt, va_list args)
{
	setLength(max);
	// warning C4996: 'vsnprintf': This function or variable may be unsafe. 
#pragma warning (disable:4996)
	size_t len = formatStringArgs(m_ptr, max, fmt, args);
	setLength(len);
	return *this;
}
//追加字符串(限定格式化最大长度)
AnsiString& AnsiString::catWith(size_t max, const char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);//获取参数列表
	catWithArgs(max, fmt, args);
	va_end(args);
	return *this;
}


//追加字符串(限定格式化最大长度)
AnsiString& AnsiString::catWithArgs(size_t max, const char *fmt, va_list args)
{
	char buffer[4059];
	char* bufferPtr;
	size_t myLen = length();
	if (max != 0)
	{
		setLength(myLen + max);//预留空间
		bufferPtr = m_ptr + myLen;
	}
	else
	{
		bufferPtr = buffer;
		max = sizeof(buffer)/sizeof(buffer[0]);//没有限定最大长度的使用字符数组缓存
	}
	size_t len = formatStringArgs(bufferPtr, max, fmt, args);
	setLength(myLen + len);
	if (bufferPtr == buffer)
		memcpy(m_ptr + myLen, buffer, len * sizeof(*m_ptr));//拷贝字符数组缓存到对象的内存
	return *this;
}
//格式化到缓冲区
size_t AnsiString::formatStringArgs(char *buffer, size_t max, const char *fmt, va_list args)
{
	// warning C4996: 'vsnprintf': This function or variable may be unsafe. 
#pragma warning (disable:4996)
	size_t len = vsnprintf(buffer, max, fmt, args);
	if (len == -1)//-1表示填满了缓冲区
		len = max;
	return len;
}
//转换为浮点型数
double AnsiString::toNumber() const
{
	if (!m_ptr)
		return 0;
	char* e = NULL;
	double d = strtod(m_ptr, &e);
	if (e && e[0])
		return 0;
	return d;
}
//转换为长整形数
long long AnsiString::toInt64() const
{
	if (!m_ptr)
		return 0;
	const char *ptr = m_ptr;
	long long lu = 0;
	while (*ptr)
	{
		lu *= 10;
		lu += *ptr - '0';
		ptr++;
	}
	return lu;
}

自定义的字符串类型

标签：

原文地址：http://blog.csdn.net/chenjiayi_yun/article/details/44755823