后台开发核心技术03常用的STL之string

为更熟悉string的构造，动手写一写string的简单实现；

#include<string.h>
class String{
public:
    String(const char*str=NULL);
    String(const String &other);
    ~String();
    String & operator =(const String &other);
    String & operator +(const String &other);
    bool operator == (const String &other);
    int getLength();
private:
    char *m_data;
}
//普通构造函数
String::String(const char*str){
  if(str==NULL){
     m_data=new char[1];
     *m_data='\0';
     }
  else{
     int length=strlen(str);
     m_data=new char[length+1];
     strcpy(m_data,str);
     }
}
//析构函数
String::~String(){
   if(m_data){
     delete[] m_data;
     m_data=NULL;
     }
}
//拷贝构造函数
String::String(const String &other){
   if(!other.m_data){
     m_data=0;
   }
   m_data=new char[strlen(other.m_data)+1];
   strcpy(m_data,other.m_data);
}
//赋值函数
String& String::operator =(const String& other){
   if(this!= &other){
      delete[] m_data;
      if(!other.m_data){
         m_data=0;
      }
      else{
         m_data=new char[strlen(other.m_data)+1];
         strcpy(m_data,other.m_data);
         }
      }
      return *this;
}
//字符串连接
String & String::operator+(const String &other){
   String newString;
   if(!other.m_data){
      newString=*this;
    }
    else if(!m_data)
       newString=other;
    }
    else{
       newString.m_data=new char[strlen(m_data)+strlen(other.m_data)+1];
       strcpy(newString.m_data,m_data);
       strcat(newString.m_data,other.m_data);
       }
       return newString;
}
//判断相等
bool String::operator==(const String& other){
   if(strlen(m_data)!=strlen(other.m_data)
      return false;
   else{
       return strcmp(m_data,other.m_data)?false:true;
       }
}
//返回长度
int String::getLength(){
   return strlen(m_data);
}

STL中的string有很多常用接口，这里总结以下：
构造函数：

函数原型：
string();               //创建一个空字符串
string(const char*s);   //使用字符串s进行初始化
string(const string& str); //使用一个string对象初始化
string(int n,char c)    //用 n 个字符 c 进行初始化

#include<string>
void test01(){
  string str1;    //创建一个空字符串
  const char* s="hello world";
  string str2 (s); //用字符串 s 初始化 str2；
  string str3（str2）; //用 str2 初始化 str3；
  string str4 (5,'a'); //用 5 个 a 初始化str4；

赋值函数：

函数原型：
string& operator =(const char* s);  //使用char* 型字符串赋值
string& operator =(const string& s);//使用字符串s赋值
string& operator =(char s);         //使用一个字符赋值

字符串拼接：

函数原型：
string& operator +=(const char* s);
string& operator =(const string& s);
string& operator =(const char s)；

字符串查找：

函数原型：
int find(const string& str,int pos=0)const; //查找str
int find(const char* s,int pos=0)const;     //查找 s
int find(const char* s,int pos;int n)const; //查找 s的前n个字符
int find(const char c,int pos=0)const;      //查找字符 c

从后向前查找：

函数原型：
int rfind(const string& str,int pos=npos)const; //查找str最后一次的位置
int rfind(const char* s,int pos=npos);
int rfind(const char* s,int pos,int n)const;
int rfind(const char c,int pos=npos)const;

替换函数：

string& replace (int pos,int n,const string& s);
string& replace (int pos,int n,const char* s);
//替换从pos开始的n个字符 为 s

字符串比较：

int compare(const string &s)const; //与字符串s比较
int compare(const char* s)const;   //与字符串s比较
//大于返回 >0 的数， 小于返回 <0 的数 ，等于返回 0；

字符存取：

char& operator[](int n); //通过 [] 存取字符
char& at(int n);         //通过 at 方式存取

插入和删除：

string& insert(int pos,const char* s);
string& insert(int pos,const string& s);
string& insert(int pos,int n,char c);
string& erase(int pos,int n=npos); 
//删除从pos开始的 n 个字符，默认删除到最后位置；

string子串：

string substr(int pos=0,int n=npos)const;
//返回由 pos 位置开始的 n 个字符组成的字符串，默认是原型

bye~bye