第十八章 字符串

第十八章 字符串

1.  char型字符串

①

char man[5]={“jack”};等价于char man[]={“jack”};

等价于man[5]={'j','a','c','k',''};

请不要小看这个代表字符串结束的标志‘’，‘’是一个空字符标志，它的ASCII码为0，C++有好多处理字符串的函数，它们都以‘’为结束标志，也就是以空字符为结束标志，比如说cin和cout，它们也是以空字符为结束标志，假如它们在碰到空字符后将会停止输入或输出。

字符串常量系统会自动加上 。字符常量系统不会自动加上

②

char man[]={'a',32,'b',''};等价于char man[]={'a',32,'b',0};

32为ASCII码不能加单引号，否则不能代表空格符

0代表空字符

若不加 man就不能代表字符串。只能代表数组man[]输出就会越界就会打出乱码。

空字符：ASCII为：0， 其字符标识符为：’’；为字符串结束标识符

空格符：ASCII为：32，其字符标识符为：’  ’；

③

cin>>cha;遇到空格符就会结束；

cin.get（cha，n）；遇到 才结束。因为它会在末尾自动加上 ，实际保存.字符只有n-1；

字符数组必须要加一个字符串结束标志’’ 不然不知道结束；

char man[]={‘a’,’b’,’c’};出现乱码

char man[]={“abc”};不会出现乱码，自动加上;

2.  string型字符串

char型是C语言风格的字符串 是用数组来保存字符串的

string型是C++风格的字符串 要添加<string>类，所以定义的变量时是string类 的对象。

2.1  string型字符串的赋值

注意：赋值要先清0再赋值（strcpy），替换不需要（strncpy）

char字符串有两种方法：①strcpy②每个元素一个一个的赋值，如a[0]=b[0]；

/*
strcpy和memcpy主要有以下3方面的区别。
1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符""才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy
*/

//①使用strcpy
//#include <iostream>
//using namespace std;
//int main()
//{
//    char a[20]="My name is";
//    char b[]=" Jack.";
//    std::cout<<strcpy(a,b);// string copy 先清除a中的所有字符，再将b中的所有字符（包括空字符）复制到a中
//    return 0;
//}

//②常规赋值
#include <iostream>
#include"string"
using namespace std;
int main()
{
    char a[20]="My name is";
    char b[]=" Jack.";
    memset(a,0,sizeof(a));//一般和extern void *memcpy(void *dest, void *src, unsigned int count); 配套使用
    for(int i=0; i< strlen(b); i++)
    {
        a[i]=b[i];
    }
    cout<< a << endl;
    return 0;
}

而string型字符串可以直接赋值

//string型字符串对象的赋值实例的程序代码如下：
/*
#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str1="what's your name";
   string str2="my name is Jack";
   str1=str2;
   cout<<str1<<endl;
   cout<<str2<<endl;
   return 0;
}
*/

//另外，我们也可以调用string类的赋值函数assign，该函数可以取第2个字符串的任意字符赋给第1个字符串，如：
#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str1=" gh ";
   string str2 = " abcdef ";
   str1.assign( str2, 3, 1 );  
   cout << str1 << endl;
   return 0;
}

2.2  string型字符串的合并

//要避免这个错误，要将ch1的长度修改为能容纳两个数组的长度。如：

//#include <iostream>
//using namespace std;
//int main()
//{
//  char ch1[36]="what's your name.";//必须要能容纳两个字符数组的长度
//  char ch2[]=" my name is Jack";
//  //strcat(ch1,ch2);        //string catenate  ①
//  //cout<<ch1<<endl;
//  //cout<<ch2<<endl;
//  strncat(ch1,ch2,8);        //将ch2的头8个字符连接到ch1后；  ②
//  cout<<ch1<<endl;
//  return 0;
//}

/*C++ string append()添加文本
使用append()添加文本常用方法:
直接添加另一个完整的字符串:
①如str1.append(str2);
添加另一个字符串的某一段子串:
②如str1.append(str2, 11, 7);
添加几个相同的字符:
③如str1.append(5, '.');
注意,个数在前字符在后.上面的代码意思为在str1后面添加5个"."  */

//string型字符串的合并的实例的程序代码如下：

#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str1;
   cout<<"str1:"<<str1.size()<<endl;
   str1 ="what's your name. ";
   cout<<"str1:"<<str1.size()<<endl;
   string str2="my name is Jack";
   cout<<"str2:"<<str2.size()<<endl;
   //str1=str1+str2;            //    ①
   str1.append(str2,11,4);        //    ②

   cout<<str1<<endl;
   cout<<str2<<endl;
   cout<<"str1:"<<str1.size()<<endl;
   cout<<"str2:"<<str2. length()<<endl;
   return 0;
}

2.3  string型字符串的替换  

注意：赋值要先清0再赋值（strcpy），替换不需要（strncpy）

//char型字符串的替换。程序代码如下：

//#include <iostream>
//using namespace std;
//int main()
//{
//   char ch1[10] = "ghadfadf";
//   char ch2[]= "abcdef";
//   strncpy(ch1,ch2,3);    //不需要将ch1清零//   cout<<ch1<<endl;
//   return 0;
//}



//string类成员函数 replace的第3种重载方式程序代码如下：
//#include <iostream>
//#include <string>
//using namespace std;
//int main()
//{
//   string str1 = "gh";
//   string str2 = "abcdef";
//   str1.replace(0,1,str2,4,2);
//   cout<<str1<<endl;    // 输出结果为： efh
//   return 0;
//}

////replace重载函数支持char型字符串，如：

//#include <iostream>
//#include <string>
//using namespace std;
//int main()
//{
//  string str1 = "gh";
//  char str2[] = "abcdef";
//  str1.replace(0,1,str2,4,2);
//  cout<<str1<<endl;    // 输出结果为： efh
//  return 0;
//}



////另外，replace重载函数也支持char型字符，也就是第5种重载格式，如：
#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str1 = "gh";
   char ch1='1';
   str1.replace(0,2,2,ch1);
   cout << str1 << " " << ch1 << endl;
   return 0;
}

2.4  string型字符串的复制（其实和替换一样的）

//char型字符串的复制。程序代码如下：

//#include <iostream>
//using namespace std;
//int main(void)
//{
//   char ch1[15] = "abcdefghijklmn";
//   char ch2[] = "1234567890";
//   cout<<"源字符串"<<ch1<<endl;
//   memmove(ch1, ch2, 9);
//   cout<<"拷贝后:" <<ch1<<endl;
//   return 0;
//}


//string型字符串的复制，程序代码如下：

#include <iostream>
#include <string>
using namespace std;
int main(void)
{
   string str = "abcd";
   char ch []= "1234";
   int n;
   cout<<"源字符串"<<ch<<endl;
   n=str.copy(ch, 4,0);
   cout<<"拷贝了"<<n<<"字符"<<endl;
   cout<<"拷贝后:" <<ch<<endl;
   return 0;
}

2.5  string型字符串的插入

//string类insert成员函数的使用。程序代码如下：
#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str="12789";
   string str1="3456";
   str.insert(2,str1,0,3);
   cout<<str<<endl;
   return 0;
}

2.6  string型字符串的删除

//string类erase成员函数的使用。程序代码如下：
#include <iostream>
#include <string>
using namespace std;
int main()
{
   string s("give me");
   cout << "原始字符串为：" << s<< endl; // give me
   s.erase( 2, 2 );
   cout << "现在字符串为：" << s << endl;// gi me
   s.erase( 2 );
   cout << "现在字符串为：" << s << endl;// gi
   s.erase();
   cout << "现在字符串为：" << s << endl;// 
   return 0;
}

2.7  string型字符串的查找

f=str1.find(‘w’,0);//在str1中从零开始查找，

//如何没有找到f的值等于string::npos(各编译器值不同，vc为-1)

f=str1.rfind(‘w’,10);//reverse find

f=str1.find_first _of(‘w’,0);

f=str1.find_first_not_of(‘w’,0);

f=str1.find_last _of(‘w’);

f=str1.find_last _not_of(‘w’);

//查找char型字符串。程序代码如下：
//#include <iostream>
//using namespace std;
//int main(void)
//{
//   char ch1[15];
//   char *p, c = 'w';
//   strcpy(ch1, "hello world");
//   p = strchr(ch1, c);　　//extern char *strchr(const char *s,char c);查找字符串s中首次出现字符c的位置//p返回的是一个地址，如果没有找到返回NULL
//   if (p)
//   cout<<"字符"<<c<<"位于第"<<p-ch1<<endl;//输出：字符w位于第6//☆P-ch1  p偏移了ch1几位，是个int型数值
//   else
//   cout<<"没有找到";
//   return 0;
//}



//查找string型字符串。程序代码如下：
#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str1( "hello world" );
   int f = str1.find( "w",0);
   if( f!= string::npos )//npos是一个常数，用来表示不存在的位置，类型一般是std::container_type::size_type 
                        //许多容器都提供这个东西。取值由实现决定，一般是-1，这样做，就不会存在移植的问题了。npos表示string的结束位子，
   cout << "在第 " << f<<"个字符" << endl;
   else
   cout << "没有找到" << endl;
   return 0;
}

2.8  string型字符串的比较

比较（string重载了==运算符）

①char型字符串的比较：strcmp（ch1，ch2）；

②string型字符串的比较：

str1.compare(str2);

str1.compare(0,2,str2);

str1.compare(0,2,str2,0,1);

注意str2可以换成ch

char ch=“pig”；if（ch==“pig”）；//不可以比较（ch为数组）（只能单个比较或者用strcmp）

#include<iostream>
using namespace std;
void main( )
{
    char a[]="ABC";
    char b[]="ABd";
    if(strcmp(a,b)==1)    // string compare
        cout << "a大" << endl;
    else if(strcmp(a,b)==0)    
        cout << "a等于b" << endl;
    else if(strcmp(a,b)==-1)    
        cout << "b大" << endl;
}

string str=“pig”；if（str==“pig”）；//可以比较（str为对象）//“pig” 未命名字符串是常量是储存在文字常量区，只能读取不能更改

#include <iostream>
#include <string>
using namespace std;
int main()
{
   string s1="155";
   string s2="52";
   char c[]="12";
   int i,j,k,l,m,n;
   i=s1.compare(s2);            //将s2与s1比较，返回0为相等，返回1为s1大于s2，    返回-1为s1小于s2
   j=s2.compare(c);            //将char型字符串c与s2比较
   k=s1.compare(0,2,s2);        //取s1前两个字符与s1进行比较，参数2表示取的s1的字符长度
   l=s1.compare(1,1,s2,0,1);    //取s1[1]与s2[0]进行比较，第2个参数和第5个参数分别表示取的s1和s2的字符长度
   m=s1.compare(1,1,c,0,1);    //取s1[1]与c[0]进行比较，第2个参数和第5个参数分别表示取的s1和c的字符长度
   n=s1.compare(1,1,c,1);        //取s1[1]与c[0]进行比较，第2个参数表示取的s1的字符长度
   cout<<s1<<":"<<s2<<"="<<i<<endl;     //依次输出各次比较结果
   cout<<s2<<":"<<c<<"="<<j<<endl;
   cout<<s1[0]<<s1[1]<<":"<<s2<<"="<<k<<endl;
   cout<<s1[1]<<":"<<s2[0]<<"="<<l<<endl;
   cout<<s1[1]<<":"<<c[0]<<"="<<m<<endl;
   cout<<s1[1]<<":"<<c[0]<<"="<<n<<endl;
   return 0;
} 

2.9  判断string型字符串是否为空

str.empty();//若str为空，返回真

#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str="";
   if(str.empty())
   cout<<"字符串为空！";
   else
   cout<<str;
   return 0;
}

3.1   swap 交换两个字符串的内容

swab(ch1,ch2,strlen(ch1));

str1.swap( str2 );

//char
//#include <iostream>
//using namespace std;
//char ch1[15] = "ofru";
//char ch2[15]="";
//int main(void)
//{
//   swab(ch1, ch2, strlen(ch1));//用法:void swab(char *from, char *to, int nbytes);功 能: 交换相临的两个字节
//   cout<<ch1<<endl;
//   cout<<ch2<<endl;
//   return 0;
//}



//string型字符串的交换。程序代码如下：
#include <iostream>
#include <string>
using namespace std;
int main()
{
   string str="give me";
   string str1="a cup";
   str.swap(str1);//交换两个字符串
   cout<<str<<endl;
   cout<<str1<<endl;
   return 0;
}

3.2  将string型字符串转为char型字符串

atoi(S3.c_str())c_str是将str的对象转化成char的数组

#include<iostream>
#include <string>
#include <sstream>

using namespace std;
void main()
{
// 将 int 转成 string
    //方法一 sprintf
    int N1 = 123;
    char C1[10];
    string S1;
    sprintf(C1,"%d",N1);    //只能将int型转换成char型*******************************①
    //sprintf(S1,"%d",A1);  //不能直接将int型转成string型
    S1 = C1;            //将char型转换成string型********************************②
    cout << N1 << " " << C1 << " " << S1 << endl;
    
    //方法二 #include <sstream>
    stringstream Ss1;
    int N2 = 123;
    string S2;
    Ss1<<N2;    //将n放入ss流中
    Ss1>>S2;    //从ss流中提取放入str中
    cout<< N2 << " " << S2 << endl;
    
// string 转 int
    //方法一 atoi(S3.c_str())
    string S3 = "qwe";
    int N3 = atoi(S3.c_str());//只适合将string型的整形转换成int型的整形。如str="123"转换成int=123 
    cout<< S3 << " " << N3 << endl;
    //方法二 #include <sstream>
    stringstream Ss2;        //只适合将string型的整形转换成int型的整形。如str="123"转换成int=123
    int N4;
    string S4 = "qwe";
    Ss2<<S4;    //将n放入ss流中
    Ss2>>N4;    //从ss流中提取放入str中
    cout<< S4 << " " << N4 << endl;
}

3.3  char型字符串与函数

①字符串数组要利用数组名和空字符

int get(const char p[])
{
    int count = 0;
    while(*p)　　//地址
    {
        count++;
        p++;    
    }        
    return count;
}

②c语言三种不同字符串表达方式

1.”study”;//字符串常量，只有头地址，不能单个元素输出

2.char* p=”very well”;// 字符串常量，只有头地址不能单个元素输出

3.char ch[15]=”hello world”;//可以单个输出

4.char man[5]={'J','a','c','k',''};

3.4  函数如何返回字符串

//返回一个字符串的地址。程序代码如下：
#include <iostream>
#include <string>
using namespace std;
char *get(char*str);
int main()
{
   char c[10];
   char *ch;
   cout<<"请输入您的名字！";
   cin>>c;
   ch=get(c);
   cout<<"您的名字是"<<ch<<endl;
   delete []ch;
   ch=get("Jack");
   cout<<"您的名字是"<<ch<<endl;
   delete []ch;
   char *ch1="Mike";
   ch=get(ch1);
   cout<<"您的名字是"<<ch<<endl;
   delete []ch;
   return 0;
}
char *get(char*str)
{
   char *p=new char[strlen(str)+1];//换成char *p=new char[sizeof(str)]=new char[4]; 就出错？？？
   strcpy(p,str);
   cout<<p;
   return p;
}

4.  结构体

结构体与类唯一不同的是成员默认为公有。也正因为如此我们可以将结构体当成复杂的数据类型使用

//#include <iostream>
//using namespace std;
//struct people
//{
//    double weight;
//    double tall;
//    int age;
//    char *name;
//    char *native;
//    bool sex;
//};
//void check(bool s){if(s==1)cout<<"男"<<endl;else cout<<"女"<<endl;}
//int main()
//{
//    people Jack=
//    {                    //注意：此处是{}***********************************①
//        180.5,
//        179.3,
//        34,
//        "Jack",
//        "济南",
//        1
//    };
//    cout<<Jack.name<<endl;
//    cout<<Jack.native<<endl;
//    cout<<Jack.tall<<endl;
//    cout<<Jack.weight<<endl;
//    cout<<Jack.age<<endl;
//    check(Jack.sex);
//    return 0;
//}



//结构体与构造函数。程序代码如下：
#include <iostream>
#include <string>
using namespace std;
struct people
{
   people(double t_weight,double t_tall,int t_age,string t_name, char *t_native,bool t_sex);
   double weight;
   double tall;
   int age;
   string name;
   char *native;
   bool sex;
};
people::people(double t_weight,double t_tall,int t_age,string t_name, char *t_native,bool t_sex)
{
   weight = t_weight;
   tall = t_tall;
   age = t_age;
   name = t_name;
   native = t_native;
   sex = t_sex;
};
void check(bool s){if(s==1)cout<<"男"<<endl;else cout<<"女"<<endl;}

int main()
{
   people Jack
    (                //注意：此处是()*************************②
      180.5,
      179.3,
      34,
      "Jack",
      "济南",
      1
   );
   cout<<Jack.name<<endl;
   cout<<Jack.native<<endl;
   cout<<Jack.tall<<endl;
   cout<<Jack.weight<<endl;
   cout<<Jack.age<<endl;
   check(Jack.sex);
   return 0;
}

①直接单个赋值：Jack.weight=150;

②没有构造函数时的成员赋值：注意{};

③有了构造函数时的成员赋值：注意();

④结构体对象相互赋值：people Mick={12,34,34,54};people Jack={42,24,54,64};Mick=Jack;

19．结构体与函数

#include <iostream>
using namespace std;
struct time
{
    int hour;
    int minute;
};
const int perhour=60;
time &sum(time t1,time t2);
void show(time t);
int main()
{
    time one={8,15};
    time two={6,55};
    time *day=&sum(one,two);
    cout<<"两天总计:";
    show(*day);
    time day2={9,35};
    cout<<"三天总计:";
    time *p1=&sum(*day,day2);
    show(*p1);
    delete day;
    delete p1;
    return 0;
}

time &sum(time t1,time t2)
{
    time *total=new time;
    total->minute=(t1.minute+t2.minute)%perhour;
    total->hour=t1.hour+t2.hour+(t1.minute+t2.minute)/perhour;
    return *total;
}

void show(time t)
{
    cout<<t.hour<<":"<<t.minute<<endl;
}

20．结构体与string

21．string数组与函数

22．流的简介

 

23．重载输出运算符

由于每次调用都会返回s（即cout）所以cout<<a<<b；可以级联；

//错误代码。程序代码如下：
/*
#include <iostream>
using namespace std;
class A 
{
public:
A(int x,int y){rx=x;ry=y;}
private:
int rx;
int ry;
};

int main()
{
A a(3,4),b(5,6);
cout<<a<<b;    //不可以直接输出对象
return 0;
}
*/

//纠正代码 如下：
#include <iostream>
using namespace std;
class A 
{
public:
    A(int x,int y){rx=x;ry=y;}
public:
    int rx;　　　　//公有的
    int ry;　　　　//
};
ostream & operator << (ostream & s,const A & c)//ostream没有公有的复制构造函数，所以只能按引用复制对象返回对象。
{
    s<<c.rx;
    s<<c.ry;
    return s;
}
int main()
{
    A a(3,4),b(5,6);
    cout<<a<<b;
    return 0;
} 

☆24．友元的方式重载输出运算符

①

<<在未遇到cout时是左移运算符。遇到之后是输出运算符。

②

//友元的方式重载输出运算符。程序代码如下：
#include <iostream>
using namespace std;
class A 
{
public:
    A(int x,int y){rx=x;ry=y;}
    friend ostream& operator<<(ostream &s,const A c)
    {
        s<<c.rx;
        s<<c.ry;
        return s;
    }
private:
    int rx;　　　　//私有的
    int ry;
};
int main()
{
    A a(3,4),b(5,6);
    cout<<a<<b<<endl;
    return 0;
}

25．重载自加运算符的执行次序

#include <iostream>
using namespace std;
class A 
{
public:
    A(int x){rx=x;}
    int operator++(){cout<<"++i
";rx++;return rx;}
    int operator++(int){cout<<"i++
";int i=rx;rx++;return i;}
    friend ostream& operator<<(ostream &s,const A c)
    {
        s<<c.rx;
        return s;
    }

private:
    int rx;
};

int main()
{
    A a(4);
    cout<<++a<<" "<<a++<<endl; //首先将参数的值求出，然后再压栈，在无括号的情况下求参的值是从右向左，因此首先求最右侧的参数a++
    return 0;
}
//输出 6 4

26．重载输入运算符

当二元运算符重载函数 定义为成员函数时二元运算符只能带一个参数

即operator运算符（只能含一个参数）

解救方法：将此operator函数设置成friend；

#include <iostream>
using namespace std;
class A
{
public:
    A(int i){x=i;}
    friend istream &operator>>(istream &s,  A &c)//重载输入运算符
    {
        s>>c.x;    
        return s;
    }
    friend ostream &operator<<(ostream &o, const A &c)//重载输出运算符
    {
        o<<c.x;
        return o;
    }
private:
    int x;
};
int main()
{
    A a(3),b(4);
    cin>>a>>b;
    cout<<a<<b;
    return 0;
}

27．编写一个String类

该类具有的功能：

//完成后的String类的程序代码如下：
#include <iostream>
using namespace std;
class String 
{
public:
    String();                            //默认构造函数用于创建空字符串
    ~String();
    String(const String&rs);
    String(const char*const ch);        //带一个参数的构造函数用来初始化字符串
    char&operator[](unsigned short int length);
    char operator[](unsigned short int length)const;//函数体前加const只能const函数才能调用，而且const函数体内不能调用非const函数。可防止基类函数被派生类修改
    String&operator=(const String&s);    //赋值函数用于两个字符串之间的赋值
    String operator+(const String &);
    void operator+=(const String&rs);
    friend ostream &operator<<(ostream & o, const String &str)
    {
        o<<str.str;
        return o;
    }
    friend istream &operator>>(istream&i, String &str)
    {
        i>>str.str;
        return i;
    }
    friend bool operator<(const String&str1,const String &str2)
    {
        if(strcmp(str1.str,str2.str)<0)
            return 1;
        else
            return 0;
    }
    friend bool operator>(const String&str1,const String &str2)
    {
        if(strcmp(str1.str,str2.str)>0)
            return 1;
        else
            return 0;
    }
    friend bool operator==(const String&str1,const String &str2)
    {
        if(strcmp(str1.str,str2.str)==0)
            return 1;
        else
            return 0;
    }
    unsigned short int getlen()const{return len;}
    const char*getstr()const{return str;}
private:
    String(unsigned short int);
    unsigned short int len;
    char* str;

};
String::String(unsigned short int length)
{
    str=new char[length+1];
    int i;
    for(i=0;i<=length;i++)
        str[i]='';
    len=length;
}
String::String()
{
    len=0;
    str=new char[1];
    str[0]='';
}
String::~String()
{
    delete []str;
    len=0;
}
String::String(const String&rs)
{
    len=rs.getlen();
    str=new char[len+1];
    for(int i=0;i<len;i++)
        str[i]=rs[i];
    str[len]='';
}
String::String(const char*const ch)
{
    len=strlen(ch);
    str=new char[len+1];
    for(int i=0;i<len;i++)
        str[i]=ch[i];
    str[len]='';
}
char&String::operator[](unsigned short int length)
{
    if(length>len)
        return str[len-1];
    else
        return str[length];
}
char String::operator[](unsigned short int length)const
{
    if (length>len)
    {
        return str[len-1];
    }
    else
        return str[length];
}
String&String::operator=(const String&s)
{
    if (this==&s)
        return *this;
    delete[]str;
    len=s.getlen();
    str=new char[len+1];
    for(int i=0;i<len;i++)
    {
        str[i]=s[i];
    }
    str[len]='';
    return *this;
}
String String::operator+(const String&rs)
{
    int total=len+rs.getlen();
    String temp(total);
    int i,j;
    for( i=0;i<len;i++)
        temp[i]=str[i];
    for( j=0;j<rs.getlen();j++,i++)
        temp[i]=rs[j];
    temp[total]='';
    return temp;
}
void String::operator+=(const String&rs)
{
    int total=len+rs.getlen();
    String temp(total);
    int i,j;
    for(i=0;i<len;i++)
        temp[i]=str[i];
    for(j=0;j<rs.getlen();j++,i++)
        temp[i]=rs[j];
    temp[total]='';
    *this=temp;
}
int main()
{
    String s1;
    cout<<"s1的长度:"<<s1.getlen()<<endl;
    char*temp="help me";
    s1=temp;
    cout<<"s1:"<<s1.getstr()<<"	 s1的长度:"<<s1.getlen()<<endl;
    char ch[10];
    strcpy(ch,"all right");
    s1+=ch;
    cout<<"ch:	"<<ch<<endl;
    cout<<"s1:	"<<s1.getstr()<<endl;
    cout<<"s1:"<<s1<<endl;
    s1[2]='o';
    cout<<"s1:"<<s1<<endl;
    cout<<"s1[999]:"<<s1[999]<<endl;
    String s2="mother";
    String s3("Mother");
    cout<<"s2:"<<s2<<"	 s3:"<<s3<<endl;
    String s4=s2+s3;
    cout<<"s2+s3="<<s4<<endl;
    int check=s2>s3;
    cout<<"s2>s3:"<<check<<endl;
    check=s2<s3;
    cout<<"s2<s3:"<<check<<endl;
    check=s2==s2;
    cout<<"s2==s2:"<<check<<endl;
    cin>>s2[0]>>s3[0];
    s2=s2+s3;
    cout<<"s2:"<<"	"<<s2<<endl;
    return 0;
}

38．总结