String类

举栗子，通过讲解String类，了解C++类的设计

1. 构造函数

  • string(); //无参构造
  • string(const char*);

  • string(const string& that); //拷贝构造

    2. 赋值

  • string& operator=(const string& s); //把字符串s赋值给当前字符串

  • string& operator=(const char* s); //用字符串赋值

    3. 容量

  • int size()const; //当前字符串的长度

  • bool empty() const; //测试是否为空字符串

  • int max_size() const; //可以存放的最大字符个数

    4. 元素访问

  • char& operator; //返回下标为n的字符引用，不执行边界检查

  • char& at(int n); //返回下标为n的字符引用，执行边界检查
  • const char* c_str()const; /返回指向内部字符数组的const指针

  • string substr(int pos = 0, int n = npos)const; //返回pos开始的n个字符组成的子串，string::npos是一个很大的常数，用来表示不存在的位置

    5. 字符串操作

  • 增

    • string& insert(int pos, const string& s); //在pos位置插入字符串s
  • 删
    • void clear(); //移除string的所有字符。
    • string& erase(int pos = 0, int n = npos); //删除pos开始的n个字符，返回修改后的字符串。
  • 改
    • string& operator+=(const string& s); //把字符串s连接到当前字符串的结尾
    • string& replace(int start, int n, const char* s); //将从start开始的n个字符用字符串s替换
    • void resize(int len, char c); //将当前字符串大小设置为len,空白部分用字符串
    • int copy(char* s, int n, int pos = 0) const; //把当前字符串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目

  • 查

    • int find(const char* s, int pos = 0) const; //从pos开始搜索字符串s，返回找到的首个字符串s的首字符位置，或若找不到这种字符串则为string::npos

      6. 全局函数

  • string operator+(const string& s1, const string& s2); //连接s1和s2

  • bool operator==(const string& s1, const string& s2)const; //比较两个字符串是否相等
  • bool operator!=(const string& s1, const string& s2)const; //比较两个字符串是否相等
  • bool operator>(const string& s1, const string& s2)const; //比较两个字符串大小
  • bool operator<(const string& s1, const string& s2)const; //比较两个字符串大小
  • int stoi(const string& str, int* pos = 0, int base = 10); //pos用来保存转换后的字符的个数
  • double stod(const string& str, double* pos = 0);
  • string to_string(int value);
  • string to_string(double value);

    7. 示例代码：

    ```cpp

    include

    using namespace std;

int main(){ string str; string str1(“hello”); string str2(str1);

  1. str = str1;
  2. str = "world";
  3. cout << "str : " << str << endl;
  4. cout << "str1 : " << str1 << endl;
  5. cout << "str2 : " << str2<< endl;
  7. cout << "size : " << str.size() << endl;
  8. cout << "empty : " << str.empty() << endl;
  9. cout << "max_size : " << str.max_size() << endl;
  11. cout << "[] : " << str[3] << endl;
  12. cout << "at : " << str.at(3) << endl;
  14. cout << "[] : " << str[7] << endl;
  15. //cout << "at : " << str.at(7) << endl;
  17. cout << "c_str : " << str.c_str() << endl;
  18. cout << "c_str : " << (void*)str.c_str() << endl;
  20. cout << "substr : " << str.substr(1, 3) << endl;
  21. cout << "substr : " << str.substr(1) << endl;
  23. cout << "insert : " << str.insert(1, string("abc")) << endl;
  24. //str.clear();
  25. cout << "str : " << str << endl;
  27. str.resize(10, 'x');
  28. cout << "str : " << str << endl;
  30. char strArr[4] = {0};
  31. str.copy(strArr, 4, 3);
  32. cout << "copy : " << strArr << endl;
  34. int n;
  35. n = stoi(string("123"));
  36. cout << "n = " << n << endl;
  37. n = stoi(string("123"), 0, 16);
  38. cout << "n = " << hex << n << endl;
  40. str = to_string(123);
  41. cout << "str : " << str << endl;
  42. return 0;

}

  1. <a name="qVTke"></a>
  2. ## 8. 手写String类
  3. <a name="JWMHs"></a>
  4. ### - main.cpp
  5. ```cpp
  6. #include "mystring.h"
  8. int main(int argc, const char *argv[]){
  9.  MyString str1("Hu");
  10.  cout << str1 << endl;
  11.  cout << str1.size() << endl;
  12.  cout << str1[1] << endl;
  14.  MyString str2 = str1;
  15.  cout << str2 << endl;
  17.  MyString str3("Mingdong");
  18.  cout << str3 << endl;
  19.  cout << str3.size() << endl;
  20.  cout << str3[1] << endl;
  22.  cout << "---------------" << endl;
  23.  cout << str1 + str3 << endl;
  25.  MyString newStr;
  26.  cin >> newStr;
  27.  cout << newStr  << endl;
  28.  cout << newStr.size() << endl;
  30.  return 0;
  31. }

- mystring.h

  1. #ifndef __MYSTRING_H__
  2. #define __MYSTRING_H__
  4. using namespace std;
  5. #include <iostream>
  6. #include <cstring>
  8. class MyString {
  9.  private:
  10.   char* mstr;
  12.  public:
  13.   MyString();  //无参构造
  14.   MyString(const char* str); //有参构造
  15.   MyString(const MyString& that); //拷贝构造
  16.   ~MyString(); //析构
  17.   int size(); //计算字符串的字符个数
  18.   void clear(); //清空字符串的字符
  19.   MyString& operator=(const MyString& other); //字符串赋值运算
  20.   MyString& operator+=(const MyString& other); //字符串+=运算
  21.   char operator[](unsigned int n);  //字符串下标运算
  23.   //友元函数
  24.   friend ostream& operator<<(ostream& out, const MyString& string); //字符串输出
  25.   friend istream& operator>>(istream& in, MyString& string); //字符串输入
  26.   friend MyString operator+(const MyString& string1, const MyString& string2); //字符串+运算
  27.   friend bool operator==(const MyString& string1, const MyString& string2); //字符串==运算
  28.   friend bool operator!=(const MyString& string1, const MyString& string2); //字符串!=运算
  29. };
  31. #endif

- mystring.cpp

  1. #include "mystring.h"
  3. MyString::MyString()  //无参构造
  4. {
  5.     mstr = new char[1];
  6.     mstr[0] = '\0';
  7. }
  9. MyString::MyString(const char* str) //有参构造
  10. {
  11.     if(str == NULL)
  12.     {
  13.         mstr = new char[1];
  14.         mstr[0] = '\0';
  15.     }
  16.     else
  17.     {
  18.         int len = strlen(str);
  19.         mstr = new char[len + 1];
  20.         strcpy(mstr, str);
  21.     }
  22. }
  24. MyString::MyString(const MyString& that) //拷贝构造
  25. {
  26.     int len = strlen(that.mstr);
  27.     mstr = new char[len + 1];
  28.     strcpy(mstr, that.mstr);
  29. }
  30. MyString::~MyString() //析构
  31. {
  32.     delete[] mstr;
  33. }
  35. int MyString::size() //计算字符串的字符个数
  36. {
  37.     return strlen(mstr);
  38. }
  40. void MyString::clear() //清空字符串的字符
  41. {
  42.     int len = strlen(mstr);
  43.     if(len == 0)
  44.     {
  45.         return;
  46.     }
  47.     else
  48.     {
  49.         for(int i = 0; i < len; i++)
  50.         {
  51.             mstr[i] = '\0';
  52.         }
  53.         return;
  54.     }
  55. }
  57. MyString& MyString::operator=(const MyString& other) //字符串赋值运算
  58. {
  59.     if(this == &other)
  60.     {
  61.         return *this;
  62.     }
  63.     else
  64.     {
  65.         delete[] mstr;
  66.         int len = strlen(other.mstr);
  67.         mstr = new char[len + 1];
  68.         strcpy(mstr, other.mstr);
  69.         return *this;
  70.     }
  71. }
  73. MyString& MyString::operator+=(const MyString& other) //字符串+=运算
  74. {
  75.     MyString old = *this;
  76.     delete[] mstr;
  77.     int len = strlen(old.mstr) + strlen(other.mstr);
  78.     mstr = new char[len + 1];
  79.     strcpy(mstr, old.mstr);
  80.     strcat(mstr, other.mstr);
  81.     return *this;
  82. }
  84. char MyString::operator[](unsigned int n)  //字符串下标运算
  85. {
  86.     return mstr[n];
  87. }
  89. //友元函数的定义实现
  91. ostream& operator<<(ostream& out, const MyString& string) //字符串输出
  92. {
  93.     out << string.mstr;
  94.     return out;
  95. }
  97. istream& operator>>(istream& in, MyString& string) //字符串输入
  98. {
  99.     in >> string.mstr;
  100.     return in;
  101. }
  103. MyString operator+(const MyString& string1, const MyString& string2) //字符串+运算
  104. {
  105.     MyString string = string1;
  106.     string += string2;
  107.     return string;
  108. }
  110. bool operator==(const MyString& string1, const MyString& string2) //字符串==运算
  111. {
  112.     return !strcmp(string1.mstr, string2.mstr);
  113. }
  115. bool operator!=(const MyString& string1, const MyString& string2) //字符串!=运算
  116. {
  117.     return strcmp(string1.mstr, string2.mstr);
  118. }