string类详解

我详细讲解一下string类的方法，便于以后查看！

构造函数和析构函数如下：

a)    string s;  //生成一个空字符串s
b)    string s(str) //拷贝构造函数 生成str的复制品
c)    string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值
d)    string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值
e)    string s(cstr) //将C字符串作为s的初值
f)    string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。
g)    string s(num,c) //生成一个字符串，包含num个c字符
h)    string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值
i)    s.~string() //销毁所有字符，释放内存

2．字符串操作函数
    这里是C++字符串的重点，我先把各种操作函数罗列出来，不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数，再到后面看他的详细解释。
a) =,assign()   //赋以新值
b) swap()   //交换两个字符串的内容
c) +=,append(),push_back() //在尾部添加字符
d) insert() //插入字符
e) erase() //删除字符
f) clear() //删除全部字符
g) replace() //替换字符
h) + //串联字符串
i) ==,!=,<,<=,>,>=,compare()  //比较字符串
j) size(),length()  //返回字符数量
k) max_size() //返回字符的可能最大个数
l) empty()  //判断字符串是否为空
m) capacity() //返回重新分配之前的字符容量
n) reserve() //保留一定量内存以容纳一定数量的字符
o) [ ], at() //存取单一字符
p) >>,getline() //从stream读取某值
q) <<  //将谋值写入stream
r) copy() //将某值赋值为一个C_string
s) c_str() //将内容以C_string返回
t) data() //将内容以字符数组形式返回
u) substr() //返回某个子字符串
v)查找函数
w)begin() end() //提供类似STL的迭代器支持
x) rbegin() rend() //逆向迭代器

y) get_allocator() //返回配置器

#ifndef _MYSTRING_H_

#define _MYSTRING_H_

#include <iostream>
using namespace std;


class myString
{
public:
    myString();                 //构造函数 
	~myString();
    myString(const myString &); // 拷贝构造函数 
    myString(const char *);     //字符串赋值 
    myString(const size_t, const char); //用size_t 个字符c初始化 
    
    size_t length();                 //返回字符串长度 
    bool empty();                    //字符串是否为空 
    const char * c_str();            //返回c风格的字符串指针。 
 
    friend ostream & operator<<(ostream &,const myString &);
	friend istream & operator>>(istream &, myString &); 
	
	friend myString operator+(const myString &, const myString &);
	
	friend bool operator==(const myString &, const myString &);
	friend bool operator!=(const myString &, const myString &);
	friend bool operator<(const myString &, const myString &);
	friend bool operator>=(const myString &, const myString &);
	friend bool operator>(const myString &, const myString &);
	friend bool operator>=(const myString &, const myString &);
	
	char & operator[](const size_t);
	const char& operator[](const size_t);
	
	myString & operator=(const myString &);
	myString & operator+=(const myString &);
	
	myString substr(size_t,size_t);
	
	myString & append(const myString &);
	
	myString & insert(size_t, const myString&);
	
	myString & assign(const myString &, size_t, size_t);
	
	myString & erase(size_t, size_t);
	
	
	  
   

private:
    size_t strLength;
    char * p_str;
};



#endif

#include "myString.h"

#include <iostream>
using namespace std;


myString::myString() : strLength(0),p_str(NULL){}

myString::myString(const myString &str)
{
	this->strLength = str.strLength;
	this->p_str = new char[strLength+1];
	strcpy(p_str,str.p_str);
}

myString::myString(const char *str)
{
	if(str == NULL)
	{
		return ;
	}
	strLength = strlen(str);
	p_str = new char[strLength+1];
	strcpy(p_str,str);
}

myString::myString(const size_t len, const char ch)
{
	strLength = len;
	p_str = new char[strLength + 1];
	*(p_str+strLength) = '\0';
	strset(p_str,ch);             //strset函数设置p_str字符串里面全是ch； 
}

myString::~myString()
{
	delete [] p_str;
}

size_t myString::length()
{
	return strLength;
}

bool myString::empty()
{
	return strLength == 0 ? true : false;
}


const char * myString::c_str()
{
	return p_str;
}

ostream & operator<<(ostream & out, const myString & str)
{
	if(str.p_str != NULL)
	{
		out << p_str;
	}
	return out;
}

istream & operator>>(istream & in, myString& str)
{
	char temp[100];
	if(in>>temp)
	{
		delete [] str.p_str;
		str.strLength = strlen(temp);
		str.p_str = new char[str.strLength+1];
		strcpy(str.p_str,temp);
	}
	return in;
}

char & myString::operator[](const size_t index)
{
	assert(index >= 0 && index <= strLength);
	return p_str[index];
}

const char & myString::operator[](const size_t index) const
{
	assert(index >= 0 && index <= strLength);
	return p_str[index];
}


myString operator+(const myString& lhs, const myString& rhs)
{
	myString ret;
	ret.strLength = lhs.strLength + rhs.strLength;
	ret.p_str = new char[ret.strLength+1];
	strcpy(ret.p_str,lhs.p_str);
	strcat(ret.p_str,rhs.p_str);
	return ret;
}

myString& myString::operator=(const myString& str)
{
	if(this != &str)
	{
		if(strLength < str.strLength)
		{
			delete [] p_str;
			p_str = new char[str.strLength+1];
		}
		strLength = str.strLength;
		strcpy(p_str,str.p_str);
	}
	return *this;
}

myString& myString::operator+=(const myString& str)
{
	if(this == &str)
	{
		myString copy(str);
		return *this+=copy;
	}
	strLength += str.strLength;
	char *p_old = p_str;
	p_str = new char[strLength+1];
	strcpy(p_str,p_old);
	delete [] p_old;
	strcat(p_str,p_str);
	return *this;
}


bool operator==(const myString& lhs, const myString& rhs)
{
	return strcmp(lhs.p_str,rhs.p_str)==0;
}
bool operator!=(const myString& lhs,const myString& rhs)
{
	return strcmp(lhs.p_str,rhs.p_str)!=0;
}
bool operator<(const myString &lhs, const myString& rhs)
{
	return strcmp(lhs.p_str,rhs.p_str)<0;
}
bool operator<=(const myString &lhs, const myString& rhs)
{
	return strcmp(lhs.p_str,rhs.p_str)<=0;
}
bool operator>(const myString &lhs, const myString& rhs)
{
	return strcmp(lhs.p_str,rhs.p_str)>0;
}
bool operator>=(const myString &lhs, const myString& rhs)
{
	return strcmp(lhs.p_str,rhs.p_str)>=0;
}

//返回一个myString类型的字符串，从下标pos开始的n个字符
myString myString::substr(size_t pos,size_t n)
{
	assert(pos+n<=strLength);
	myString ret;
	ret.strLength = n;
	ret.p_str = new char[ret.strLength+1];
	for(size_t i = 0; i != n; ++i)
	{
		ret[i] = (*this)[pos+i];
	}
	ret[i] = '\0';
	return ret;
}
//将一个字符串的副本添加到原字符串的末尾，同+=类似 
myString& myString::append(const myString& str)
{
	*this+=str;
	return *this;
}
 
//在下标为pos的元素之前插入myString对象的副本
myString& myString::insert(size_t pos,const myString& str)
{
	assert(pos<strLength);
	char *p_old = p_str;
	p_str = new char[strLength+1];
	for(size_t i = 0; i != pos; ++i)
	{
		*(p_str+i) = *(p_old+i);
	}
	for(size_t i = pos;i != str.strLength+pos; ++i)
	{
		*(p_str+i) = *(str.p_str+i);
	}
	*(p_str+strLength) = '\0';
	delete [] p_old;
	return *this;
} 

//用s2中从下标pos开始的len个字符副本替换原字符串 
myString& myString::assign(const myString& s2, size_t pos, size_t len)
{
	if(strLength < len)
	{
		strLength = len;
		delete [] p_str;
		p_str = new char[strLength+1];
	}
	for(size_t i = 0; i != len; ++i)
	{
		*(p_str+i) = s2[pos+i];
	}
	*(p_str+strLength) = '\0';
	return *this;
}

//删除从下标pos开始的len个字符
myString& myString::erase(size_t pos,size_t len)
{
	assert(pos+len <= strLength);
	size_t index = pos + len;
	while(*(p_str+index) != '\0')
	{
		*(p_str+index-len) = *(p_str+index);
	    ++index;
	}
	*(p_str+index-len) = '\0';
	return *this;
}