sstring.h

vc当中比较容易遇到的过河问题

#include "iostream.h"
#include "string.h"//包含C++字符串的头文件，则可以用C++内置的函数对C++的字符串进行操作
class String{
public:
	//构造函数,与类同名,给类中的对象初始化,而对不同类型的变量初始化时,调用相应类型的构造函数
	String();

	String(char);

	String(unsigned);

	String(const char *);//指向字符的指针(c++字符串)

	String(const String &);//用户定义类中的对象,引用

	//析构函数,用于释放字符串所占的空间

	~String();

	char * pointer(void);//无参数,返回对象缓冲区的首址,用于输出整个字符串

	unsigned StrLength(void);//返回字符个数,用于返回字符串的长度

	//运算符重载,用关键字operator,一般定义为类的成员函数或友元函数;一元运算符定义时不用参数,二元
	//运算符则只用一个参数

	String & operator = (const String & );//类本身的对象,用用户定义的字符串赋值

	String & operator = (const char *);//用c++字符串赋值

	String & operator += (const String & );

	char & operator[] (unsigned);//下标运算

	String operator ( )(unsigned, unsigned) const;//函数操作

	friend istream & operator >> (istream &,String &);//输入重载,友元函数不是类的成员,可以访问类
	                                                   //的私有成员

	friend ostream & operator << (ostream &,const String &);

	const String operator + (const String &) const;

	int operator == (const String &) const;

	int compare(const String & str) const;//字符串比较函数

private:
	//数据域:字符缓冲区,缓冲区长度

	unsigned buflen;//buflen是无符号整型的变量,记录缓冲区的长度,此长度字符所占的内存空间1,
	                //多了一个字符串的结束符

	char * buffer;//*buffer是字符型的指针,指向存放字符串的区域
};

String::String( ){//对空字符串进行初始化的操作

	//建立一个空字符串
    buflen = 1;
    buffer = new char [buflen];//动态分配长度为1的存储区,并将首地址赋给指针buffer

    buffer[0] = '\0';//把结束符赋给缓冲区的第一个元素
}

String::String(char c){//对一个单字符的字符串进行初始化的操作

	//建立一个单字符的字符串
    buflen = 2;
    buffer = new char [buflen];
    buffer[0] = c;
    buffer[1] ='\0';
}

String::String(const char *s){//对c++字符串进行初始化的操作

	//设置数据域值(初始化数据域)

    buflen = strlen(s) + 1;//用c++内置函数strlen()算出指针s所指向的字符串
                           //的长度,因为缓冲区要存放字符串的结束符,所以要加1
    buffer = new char [buflen];
    strcpy(buffer,s);//把指针s指向的字符串拷贝戈buffer
}

String::String(unsigned n){//对数字字符串进行初始化的操作
    buflen = n + 1;
    buffer = new char [buflen];
	//对缓冲区做初始化
    for (unsigned i=0;i<buflen;i++)
        buffer[i]='\0';//每个字符都被赋上结束符，因为buffer是指向C++字符串（内置）的指针
	                   //所以可以用下标运算
}

String::String(const String & str){//对用户定义的类中的字符串进行初始化的操作

    buflen = str.buflen;//把对象str.buflen的字符串长度赋给buflen
    buffer = new char [buflen];
    strcpy(buffer,str.buffer);//把str.buflen所指对象的首地址拷贝给指针buflen，因为buflen
	                           //是指向C++字符的指针，所以能用C++的内置函数
}

String::~String(void){
	//释放缓冲区
    delete [] buffer;//[]表示释放的是一个数组所占的空间
}

char* String::pointer(void){
	return buffer;//返回字符串的首地址，用于输出字符串
}

unsigned String::StrLength(void){
	return buflen-1;//返回字符串长度，而buflen是缓冲区的长度，所以要减1
}


//运算符重载时，是运算符左边的对象调用函数，所以只需声明一个参数
String & String::operator = (const String & str){//函数赋值时做左值，所以必须返回引用的函数

    if (str.buflen != buflen){//判断缓冲区是否够大，若不够就释放旧的缓冲区，然后再申请新的缓冲区，
		                       //再把新的字符串拷到新的缓冲区，否则只需直接拷贝
        buflen = str.buflen;
        delete [] buffer;//释放原缓冲区
        buffer = new char [buflen];//申请新缓冲区
    }
	strcpy(buffer, str.buffer);
    return *this;//指向类当前对象的指针，对原有字符串重新赋值
}

String & String::operator = (const char * s){//用C++字符串对原有字符串重新赋值

    unsigned slen = strlen(s) + 1;//算出S所指向的C++字符串的长度再加1
    if (slen != buflen) {
        delete [] buffer;
        buffer = new char [slen];
        buflen = slen;
    }
    strcpy(buffer,s);//拷贝指针
    return *this;//this指针不能被重新赋值
}

String & String::operator+=(const String & str){//实现两字符串首尾相接
    char * tempstr;
    unsigned len;
    len = buflen + str.buflen-1;//因为两个字符串的缓冲区都有存放结束符，所以新缓冲区的长度要减1
    tempstr = new char [len];
    strcpy(tempstr,buffer);
	strcat(tempstr,str.buffer);//把str.buffer接在tempstr之后，并加上结束符，实现连接
    delete [] buffer;
    buffer = tempstr;
    buflen = len;
    return *this;
}

char & String::operator [] (unsigned n){//下标运算符重载，对对象的下标运算
    return buffer[n];//返回第n个元素的地址，是对下标的运算
}


//函数调用，返回String类的数据
String String::operator( )(unsigned start, unsigned len) const{//重载（），用于截取子串
	//取子串的简单实现
    unsigned tlen;
	if (start >= buflen)//判断子串的起始位置是否在原字符串内，若不在，则返回空串
        return "";
    if (start-1+len >= buflen)//起始位置+长度-1，计算所截字符串的长度，若此长度大于缓冲区长度
		                      //则截取余下的全部，否则按照要求的长度截取
        tlen = buflen-start;
    else
        tlen = len;//充分长度
    char * temp;//建立临时指针
	temp=new char [tlen+1];//把字符序列复制到一个临时缓冲区
	//实际复制
    for(unsigned i=0;i < tlen;i++)
        temp[i] = buffer[start+i-1];//按对应的位置赋值给指针temp
	                       //因为start为起始位置的位数，而位从1开始，下标从0开始，所以要-1
	temp[i]='\0';
    return temp;
}

istream & operator >> (istream & in,String & str){//从键盘读入数据，要重复的使用cin>>，所以用引用
	//字符串输入：读入流中的一个词，存放到参数字符串中

    char inbuffer[1000]={'\0'};//建立缓冲区，声明一个足够大的数组，第一个元素为结束符
	cout<<"请输入字符串：";
//    if (in >> inbuffer)//直接用in输入
//        str=inbuffer;//把所输入字符串放如缓冲区
//    else
//		str="";

	//读入一个行到字符串中
	in.getline(inbuffer,1000,'\n');//getline()是系统函数,用于读入一个整行,且用1000作为读入字符数的
	                                //限制,用\n作为行结束的字符
	str=inbuffer;//把inbuffer的首地址赋给了	str
    return in;
}

ostream & operator << (ostream & out,const String & str){//字符串输出
	out << str.buffer;//把str.buffer传给out,通过 out来输出字符串str.buffer 
    return out;
}


//串连接
const String String::operator + (const String& str) const{//实现用户定义类的对象的连接
	String temp;//用String 声明字符串常量temp
	//求出并置后字符串的总长
	temp.buflen=buflen+str.buflen-1;
	temp.buffer=new char [temp.buflen];
	strcpy(temp.buffer,buffer);
	strcat(temp.buffer,str.buffer);//字符串连接函数
	return temp;
}

int String::operator == (const String& str) const{//判断两字符串是否相等
	if (strcmp(buffer,str.buffer)==0)
		return 1;
	else
		return 0;
}

int String::compare(const String & str) const{//比较字符串函数
    return strcmp(buffer,str.buffer);//内置的C++字符串比较,返回函数strcmp()的值
}