自定义的字符串类型

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

类头文件，如下：

class AnsiString : public Array<char>
{
public:
typedef Array<char> super;
	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])//不完全是数字的返回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;
}