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

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

一、先看初始化：

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

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 DEBUGstralloc += a;
#endifdata = (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 DEBUGstralloc += a - b;
#endifdata = (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 listsint 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)
{
}

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