一个简单的string类，读书看报系列(一)

对于这个类，写过程序的都知道应该含有的方法是

初始化、销毁、拼接、求长度、清除、判断是否为空等、还有一些操作符重载

一、先看初始化：

可以想到应该有默认构造的的、带有字符串的、带有默认字符的、还有一个拷贝构造函数

string()

string(const char * sc, intlength);

string(const char * sc);

string(char c);

string(const string& s);

~string();

我们可以分别写5个initialize函数，去对应这些构造函数

    void initialize()  { data = emptystr; }
    void initialize(const char*, int);
    void initialize(const char*);
    void initialize(char);
    void initialize(const string& s);

二、销毁

~string()

写一个函数finalize，让其在销毁的时候执行

三、成员变量

很简单就一个char*data就足够了，写成protected类型的

四、看看他的实现

写一个myString.cpp去对应这个ptypes.h

void string::initialize(const char* sc)
{
	initialize(sc, hstrlen(sc));
}

void string::initialize(const char* sc, int initlen)
{
	if (initlen <= 0 || sc == nil)
	{
		data = emptystr;
	}
	else
	{
		_alloc(initlen);
		memmove(data, sc, initlen);
	}
}

void string::initialize(char c)
{
	_alloc(1);
	data[0] = c;
}

void string::initialize(const string& s)
{
	data = s.data;
	pincrement(&STR_REFCOUNT(data));
}

那么现在构造函数算是完成了

看看里面，动态分配内存的函数(这里也是string的成员函数)

void _alloc(int);
void _realloc(int);
void _free(int);

从上面上看用处显而易见

void string::_alloc(int numchars)
{
	if (numchars <= 0)
	{
		stringoverflow();
	}
	size_t a = quantize(numchars);
#ifdef DEBUG
	stralloc += a;
#endif
	data = (char*)(memalloc(a)) + strrecsize;
	STR_LENGTH(data) = numchars;
	STR_REFCOUNT(data) = 1;
	data[numchars] = 0;
}

void string::_realloc(int numchars)
{
 	 if (numchars <= 0 || STR_LENGTH(data) <= 0)
 	 {
		 stringoverflow();
 	 }
	 int a = quantize(numchars);
	 int b = quantize(STR_LENGTH(data));
	 if (a != b)
	 {
#ifdef DEBUG
		 stralloc += a - b;
#endif
		 data = (char*)(memrealloc(data - strrecsize, a)) + strrecsize;
	 }
	 STR_LENGTH(data) = numchars;
	 data[numchars] = 0;
}

void string::_free(int numchars)
{
	_freestrbuf(data);
	data = emptystr;
}

具体到细节里面有可以在框架接口common.h中加入内存处理的函数：

//
// memory management (undocumented)
// hides some BSD* incompatibility issues
//

ptpublic void* ptdecl memalloc(uint a);
ptpublic void* ptdecl memrealloc(void* p, uint a);
ptpublic void  ptdecl memfree(void* p);
ptpublic void  ptdecl memerror();
ptpublic int   ptdecl memquantize(int);

ptpublic int   __PFASTCALL pincrement(int* target);
ptpublic int   __PFASTCALL pdecrement(int* target);

咱们用pmem.cpp去实现这里的函数

#include "stdio.h"
#include "stdlib.h"

#include "common.h"

// dynamic reallocation policy for strings and lists

int ptdecl memquantize(int a)
{
……
}

void* ptdecl memalloc(uint a)
{
……
}

void  ptdecl memerror()
{
……
}

void* ptdecl memrealloc(void* p, uint a)
{
……
}

void  ptdecl memfree(void* p)
{
……
}

下来是string应该实现的操作：比如指派assgin函数

void assign(const char* sc, int initlen);
void assign(const char* sc);
void assign(char c);
void assign(const string& s);

这个函数只需要和构造函数和_alloc这些函数配合起来使用就行

下来是重载操作符：

string operator+ (const char* sc) const;
string operator+ (char c) const;
string operator+ (const string& s) const;

bool operator== (const char* sc)  const		{ return (strcmp(sc, data) == 0); }
bool operator== (char c) const;
bool operator== (const string& s) const;
bool operator!= (const char* sc)  const		{ return !(*this == sc); }
bool operator!= (char c) const			{ return !(*this == c);  }
bool operator!= (const string& s) const		{ return !(*this == s); }

operator const char*() const			{ return data; }

[]操作符是，因为都需要进行条件判断，所以写成一个函数idx，进行长度的检查

void idx(int index) const 	 	{ if(unsigned(index) >= unsigned(STR_LENGTH(data))) idxerror(); }

char&	operator[] (int i)	 	{ idx(i); return unique(*this)[i]; }
const char& operator[] (int i) const 	{ idx(i); return data[i]; }

还有一类的操作符重载是友元函数类型的：

friend bool operator== (const char* sc, const string& s);
friend bool operator== (char c, const string& s);
friend bool operator!= (const char* sc, const string& s);
friend bool operator!= (char c, const string& s);

因为他的实现很简单，只是调用原来已经被重载的=号操作符

inline bool operator== (const char* sc, const string& s)		{ return s == sc; }
inline bool operator== (char c, const string& s)			{ return s == c; }
inline bool operator!= (const char* sc, const string& s)		{ return s != sc; }
inline bool operator!= (char c, const string& s)			{ return s != c; }

还有一类是需要导出的，所以前面跟上stdcall

ptpublic friend string operator+(const char* sc, const string& s);
ptpublic friend string operator+(char c, const string& s);

假如你看一下他的调用方式，你就应该知道他为何这么写了：

// test ptpublic friend string operator+(const char* sc, const string& s);
s2 = "str" + s1 + "ing";
// test ptpublic friend string operator+(char c, const string& s);
s2 = 's' + s1;

下来是类的友元函数，他们不需要进行外部调用，但是需要访问类的成员：

friend int length(const string& s);
friend int refcount(const string& s);
friend void clear(string& s);
friend char* ptdecl unique(string& s);
friend int pos(const string& s1, const string& s);
friend void assgin(string& s, const char* buf, int len);

这些可以写得很简单：

inline int length(const string& s)						{ return STR_LENGTH(s.data); }
inline int refcount(const string& s)						{ return STR_REFCOUNT(s.data); }
inline void assgin(string& s, const char* buf, int len)			        { s.assign(buf, len); }
inline void clear(string& s)							{ s.finalize(); }
inline bool isempty(const string& s)						{ return length(s) == 0; }
inline int  pos(const string& s1, const string& s)				{ return pos(s1.data, s); }

下面的这些函数需要被外部调用，又需要访问成员变量的：

ptpublic friend int    ptdecl pos(const char* s1, const string& s);
ptpublic friend int    ptdecl pos(char s1, const string& s);
ptpublic friend int    ptdecl rpos(char s1, const string& s);
ptpublic friend void   ptdecl concat(string& s, const char* sc, int catlen);
ptpublic friend void   ptdecl concat(string& s, const char  c);
ptpublic friend void   ptdecl concat(string& s, const string& s1);
ptpublic friend string ptdecl copy(const string& s, int from, int cnt);
ptpublic friend string ptdecl copy(const string& s, int from);
ptpublic friend char*  ptdecl setlength(string& s, int newlen);
ptpublic friend void   ptdecl del(string& s, int at, int cnt);
ptpublic friend void   ptdecl del(string& s, int from);
ptpublic friend void   ptdecl ins(const char* s1, int s1len, string& s, int at);
ptpublic friend void   ptdecl ins(const char* s1, string& s, int at);
ptpublic friend void   ptdecl ins(char s1, string& s, int at);
ptpublic friend void   ptdecl ins(const string& s1, string& s, int at);
ptpublic friend bool   ptdecl contains(const char* s1, int s1len, const string& s, int at);
ptpublic friend bool   ptdecl contains(const char* s1, const string& s, int at);
ptpublic friend bool   ptdecl contains(char s1, const string& s, int at);
ptpublic friend bool   ptdecl contains(const string& s1, const string& s, int at);

咱们可以另外写一个pstrmanip.cpp去实现上面的函数，其实还可以把一些操作符重载也写在这里：

#include "stdlib.h"
#include "ptypes.h"

string string::operator+ (const char* sc) const
{
}

string string::operator+ (char c) const
{
}

string string::operator+ (const string& s) const
{
}

string operator+(const char* sc, const string& s)
{
}

string operator+(char c, const string& s)
{
}

bool string::operator== (char c) const
{
}

bool string::operator== (const string& s) const
{
}

int ptdecl pos(const char* sc, const string& s)
{
}

int ptdecl pos(char c, const string& s)
{
}

int ptdecl rpos(char c, const string& s)
{
}

string ptdecl copy(const string& s, int from, int cnt)
{
}

string ptdecl copy(const string& s, int from)
{
}

void ptdecl del(string& s, int from, int cnt)
{
}

void ptdecl del(string& s, int from)
{
}

void ptdecl ins(const char* s1, int s1len, string& s, int at)
{
}

void ptdecl ins(const char* s1, string& s, int at)
{
}

void ptdecl ins(char s1, string& s, int at)
{
}

void ptdecl ins(const string& s1, string& s, int at)
{
}

bool ptdecl contains(const char* s1, int s1len, const string& s, int at)
{
}

bool ptdecl contains(const char* s1, const string& s, int at)
{
}

bool ptdecl contains(char s1, const string& s, int at)
{
}

bool ptdecl contains(const string& s1, const string& s, int at)
{
}

这样整个类就被分开了，但是有个缺点。。用助手不好使了= =