• 【C++】泛型编程

            为了让函数或者类有更好的复用性，C++引入了摸板的技术。让不同的数据类型，能使用到相同的函数或者类中去，这种编程的思想也叫做泛型编程。

    一、摸板

    1. void Swap(int &left,int & right)
    2. {
    3.     int temp =left;
    4.     left = right;
    5.     right = temp;
    6. }

            在学习C语言的时候，写一个交换变量数据的函数，会发现一个问题就是这个函数只能用来交换int类型的变量，那么我要交换其他类型的变量要怎么办呢，多写几个对应的函数吗？这种方法其实不是很好，因为会造成代码冗余。

            这里使用C++的摸板可以轻松的解决

    1. template<typename T> 
    2. void Swap(T& left, T& right)
    3. {
    4.     T temp=left;
    5.     left=right;
    6.     right=temp;
    7. }
    8.  
    9. int i=1,j=2;
    10. double x=1.1,y=2.2;
    11. Swap(i,j);
    12. Swap(x,y);

            摸板格式template< typename(也可以用class) + 后面的类型名字T是随便取的 >，Ty,K,V,一般是大写字母或者单词首字母大写。

            T 代表是一个摸板类型(当成变量的类型就可以了int、char这些，也可以是自定义类型)。

    PS：这里交换变量使用了一个中间变量，那么可以不可以直接使用异或来交换呢，其实不行，因为异或交换要 int 类型才可以使用。

    PS：这里int和double类型的两个调用，实际上调用的不是同一个函数。

    1. template<class T>
    2. T Add(const T& left,const T& right)
    3. {
    4.     return left+right;
    5. }
    6.  
    7. //编译器自动推演，隐式实例化
    8. Add(1.1,2);     //这里推演实例化出错
    9.  
    10. //强制类型转换后可以继续使用
    11. Add((int)1.1,2);
    12. Add(1.1,(double)2);

            摸板有个隐式类型的转换，直接输入数据编译器就能根据数据判断是什么类型的变量，但是要注意，如果两个变量类型不同，那么它就不会知道你到底想用哪个类型的变量。

    1. //或者定义两个参数
    2.  
    3. template<class T1，class T2>
    4. T1 Add(const T1& left,const T2& right)
    5. {
    6.     return left+right;
    7. }
    8.  
    9. //这里就可以编译器自动推导。
    10.  
    11. Add(1.1,2);
    12. Add(1,2.2); //这里会出警告，double到int会损失精度

            摸板中定义两个类型的参数，这里编译器就会帮你自动强制转换数据类型，这里double类型和int类型计算，int类型就会被提升为double类型。

    1. //显示实例化
    2. Add<int>(1.1,2);

            使用这种方法也可以解决，明确的告知编译器，我就是想用 int 类型的变量。

    1. template<class T>
    2. T* func(int n)
    3. {
    4.     T* a = new T[n];
    5.     return a;
    6. }
    7.  
    8.  
    9. //所以这里必需显示实例化
    10. func<int>(20);

            这种摸板函数没法自动推演，编译器不知道返回值的类型，所以使用的时候必须明确告知要返回变量的类型。

    1. int Add(int left,int right)
    2. {
    3.     
    4. }
    5.  
    6. template<class T>
    7. T Add(T left,T right)
    8. {
    9. 	return left+right;    
    10. }
    11.  
    12.  
    13. Add(1,2);

            摸板函数和普通函数可以同时存在，调用时会先去检查有没有专门处理int类型的函数，如果没有就调用摸板。

           

    二、类摸板

             

    1. typedef char STDateType;
    2.  
    3. class Stack
    4. {
    5.     private:
    6.     	STDateType *a;
    7.     	int top;
    8.     	int capacity;
    9. };
    10.  
    11. Stack st1;
    12. Stack st2;

            在C语言中为了方便使用不同类型的变量，这里一般用宏定义。但是并没有解决在两个对象中，一个存储变量int，一个存储double。

            也就是说定义的所有对象只能存储一种类型的数据。但是实际使用的时候是需要灵活变通的，要多种类型一起使用包括自定义类型。所以类也可以使摸板。

    PS：函数能根据传入的数据推导出数据类型，但是类摸板不能，所以使用摸板类实例化对象的时候，必须显示实例化。

    1. template<typename T>
    2. class Stack
    3. {
    4. 	public:
    5.     	Stack(size_t capacity = 4)
    6.             :_a(nullptr)
    7.           	 ,_capacity(0)
    8.              ,_top(0);
    9.         {
    10.             if(capacity > 0)
    11.             {
    12.                 _a = new T[capacity];  
    13.                _capacity = capacity;
    14.                 _top = 0;
    15.             }
    16.         }
    17.     	
    18.     	~Stack()
    19.         {
    20.             delete[] _a;
    21.             _a = nullptr;
    22.             _capacity = _top =0;
    23.         }
    24.     
    25.     	void Push(const T& x)
    26.         {	
    27.              //如果插入满了，开辟新空间
    28.              if(_top == _capacity){
    29. 				size_t NewCapacity = _capatcity == 0 ? 4 : _capacity*2;
    30.                 T* tmp =new T[NewCapacity];
    31.                 if(_a){
    32.                     memcpy(tmp,_a,sizeof(T)*_top);
    33.                     delete[] _a;
    34. 				}
    35.                 
    36.                  _a = tmp;
    37.                  _capacity = NewCapacity;
    38.              }
    39.             
    40.             _a[_top]=x;
    41.             ++_top;
    42.         }
    43.     	
    44.     	void Pop()
    45.         {
    46.             assert(_top > 0);
    47.             --_top;
    48.         }
    49.     
    50.     
    51.     	bool Empty()
    52.         {
    53.             return _top == 0;
    54.         }
    55.     
    56.     	T& Top() //这边使用了引用，那么可以修改,不想修改要加const。
    57.         {
    58.             assert(_top > 0);
    59.             return _a[_top-1];
    60.         }
    61.     
    62.     private:
    63.     	T *_a;
    64.     	int _top;
    65.     	int _capacity;
    66.  
    67. };
    68.  
    69. Stack<int> st1;
    70. Stack<char> st2;
    71.     
    72. st1.Top()++;

            这里两个Stack类型的变量就可以存储多种类型的数据了，包括自定义类型，而摸板其实就是为了能更好的支持自定义类型而创建出来的。

    PS：摸板不支持分离编译，声明放在.h 定义放在 .cpp ！！！！但是可以在当前文件分开写，所以可以创建一个.hpp的文件，这个是约定俗称的，方便人一看到就知道是什么意思。
            

    1. //声明定义在本文件分离。
    2. template<class T>
    3. class Stack
    4. {
    5. 	public:
    6.     	Stack(size_t capacity = 4)
    7.             :_a(nullptr)
    8.           	 ,_capacity(0)
    9.              ,_top(0);
    10.         {
    11.             if(capacity > 0)
    12.             {
    13.                 _a = new T[capacity];  
    14.                _capacity = capacity;
    15.                 _top = 0;
    16.             }
    17.         }
    18.     	
    19.     	~Stack()
    20.         {
    21.             delete[] _a;
    22.             _a = nullptr;
    23.             _capacity = _top =0;
    24.         }
    25.     
    26.     	void Push(const T& x);
    27.     	void Pop();
    28.     	bool Empty();
    29.     	T& Top();
    30.  
    31.     private:
    32.     	T *_a;
    33.     	int _top;
    34.     	int _capacity;
    35.  
    36. };
    37.  
    38. //注意这里的写法
    39. template<class T>
    40. void Stack::Push(const T& x)
    41. {	
    42.        if(_top == _capacity){
    43.                 
    44.             size_t NewCapacity = _capatcity == 0 ? 4 : _capacity*2;
    45.                 
    46.             T* tmp =new T[NewCapacity];
    47.                 
    48.             if(_a){
    49.                 memcpy(tmp,_a,sizeof(T)*_top);
    50.                 delete[] _a;
    51. 			}
    52.                 
    53.                 _a = tmp;
    54.                 _capacity = NewCapacity;
    55.                 
    56.        }
    57.             
    58.        _a[_top]=x;
    59.        ++_top;
    60. }

            

    三、STL

             

             标准模板库（Standard Template Library，STL）是惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。虽说它主要出现到C++中，但在被引入C++之前该技术就已经存在了很长时间。

            STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。

            STL六大组件：容器（数据结构），算法，迭代器，配接器，仿函数，空间配置器。   

    sting：

    1. #include
    2.  
    3. //string是一个宏定义
    4. typedef basic_string<char> string;
    5.  
    6. string str; //等价于
    7. basic_string<char> str

            使用string容器要加载头文件，并且其中的很多函数都在std的命名空间中，string是 basic_string 的宏，其中 basic_string 就是类名了。        

             

            basic_string根据不同的摸板参数，宏定义了多个不同的容器，定义多个是为了匹配对应的编码，因为不同的编码大小不一样。

           这里先学习string容器和其中常用函数的使用，这个是一通百通的，因为其他的容器相似度非常高，也是编写库的人特意设置的，学会这一个其他的也会使用了。

    构造函数：

            string可以用同样的string对象来进行初始化，也可以使用字符串(char*)来进行初始化(隐式类型装)。

            还可以指定要初始化的数据段，指定开始的位置，和要初始化的长度。如果给与的长度大于了字符串后面的长度，那么把后面全部复制下来。

            其中如果不指定长度，其默认的缺省值为一个静态变量npos，值为-1。

    PS：npos的类型为size_t，是一个无符号的整形，给值-1会变成一个非常大的整数。那么其意思就很明确了，不输入指针的长度，则从开始位置往后全部给要初始的对象。

       

            这种对象的初始化的方法，在STL里面是通用的，其他容器大差不差。

            

    重载运算符[ ]:

            我们知道字符串其实就是一个字符数组，可以通过[ ]访问每个单个的字符，所以string里面重载了运算符[ ]，给我们用来访问字符。

            [ ]返回的是字符的引用，所以可以通过这个运算符修改单个的字符。

    迭代器：

            迭代器每个容器因为其特性不一样实现的方法也不一样，在string里面因为其本质还是使用数组来存储数据的，所以这里的迭代器就是指针。

            既然[ ]、指针就能遍历string，为何要定义一个迭代器出来？因为并不是所有的容器都是使用指针来实现迭代器的。但是迭代器使用的方法都是一样的，是STL遍历容器的通用方法。

            

            使用string里面的一个宏定义iterator来定义一个变量it，it就是string容器的迭代器，其使用方法和指针相似。

    1. it!=s.end();
    2.  
    3. itend();

            这里迭代器判断是不是到了容器尾部的时候，最好使用!=，而不是使用<符号，虽然两个效果在这里是一样的(因为string底层迭代器就是指针)。但是在其容器中会出错(比如list)。

    1. for (auto ch : s)
    2. {
    3. 	cout << ch << endl;
    4. }
    5.  
    6. //想修改用使用引用
    7. for(auto & ch : it)
    8. {
    9.     ch++;
    10. }

            范围for的底层就是迭代器。

    PS：范围for里面的迭代器，能自动遍历，自动迭代，自动判断结束 。

    反向迭代器：

            其实看名字就大概能明白其是什么意思了，就是从容器尾部往开始位置遍历。

    PS：要注意这里迭代器++是往容器前面走(左边)，--是往容器后面走(右边)。

    常量迭代器：

            

    常量反向迭代器：

    PS：常量迭代器是不能修改对象中的数据的。 

    push_back():

            push_back()这个函数只能在string尾部插入一个字符。

            

    append():

            

            在string尾部插入一个字符串，并且可以指定插入字符串的开始位置和长度。

     

    重载+=符号：

            

            

            用法跟append()差不多，只不过看起来更容易理解了，用起来也方便。

    insert(): 

            

             在指定位置插入一个字符串，同样可以指定插入字符串的开始位置和长度。

    reserve()和resize():

            在插入数据的时候，函数内部就已经帮我们判断了如果容器满了，则会重新扩容空间。但是我们如果知道要输入数据大小，那么就可以提前开辟空间。

            reserve()开辟空间，resize()则是开辟空间并初始化。

    PS：string内置了一个函数capacity()，可以得知现在string的容量。

    c_str:

            有时候需要兼容C语言，所以里面包含了兼容C语言的函数，c_str()函数返回的是const char*的类型。

    1. string filename("test.cpp");
    2. FILE* fp = fopen(filename.c_str,"r");
    3. char ch=getc(fp);
    4.  
    5. while(ch != EoF){
    6.     cout<
    7.     char ch=getc(fp);
    8. }

            这里filename和filename.c_str是有区别的，filename 是以容器的size()为准。filename.c_str是常量字符串，以“\0”为结束标识。

    find():

             查找字符串，查找到了返回匹配字符串第一个字符的位置，没找到返回npos。

            find()，在查找字符串的时候，可以指定开始查找的位置，也可以指定查找的字符串长度。但是要注意，如果有多个字符串可以匹配上，这里只返回第一个匹配上的位置。

            

    find_first_of():

            

            这个函数比较难理解，它不是要把完全匹配的字符串位置给找出来。而是匹配的字符串的字符，谁第一个在主串出现，就返回该处匹配的位置。

            这里e是最先在主串里面出现的，所以这里返回1。匹配失败返回npos。

    四、模拟实现string

    1. namespace STR
    2. {
    3.  
    4.     class string
    5.     {    
    6.     public:
    7.  
    8.         //构造函数 使用初始化列表
    9. 		string(const char* str = "")           //这里的缺省值是 \0
    10. 			:_str(new char[strlen(str)+1])     //加1 是加上 \0的空间
    11. 			,_size(strlen(str))
    12. 			,_capacity(strlen(str))     //capacity不包括 \0
    13. 		{
    14. 			strcpy(_str, str);
    15. 		}
    16.  
    17.  
    18.  
    19.         //构造函数  另一种写法
    20.         string(const char* str = "") //这里的缺省值是 \0
    21. 		{
    22.  
    23.             //这样写可以复用变量，如果写在初始列表，变量初始顺序要严格匹配声明顺序。
    24.  
    25. 			_size = strlen(str);
    26. 			_capacity = _size;
    27. 			_str = new char[_capacity + 1];    //加1 是加上 \0的空间
    28. 			
    29. 			strcpy(_str, str);
    30. 		}
    31.  
    32.  
    33.         //析构函数
    34.         ~string()
    35.         {
    36.             delete[] _str;
    37.             _str = nullptr;
    38.             _capacity = _size = 0;
    39.         }
    40.     
    41.  
    42.     private:
    43.         char* _str;
    44. 		size_t _size;    //字符串的长度 不包括\0
    45. 		size_t _capacity;    //数组的容量 不统计\0
    46.  
    47.  
    48.         static size_t nops_t;
    49.     };
    50.  
    51. }
    52.  
    53. //静态变量 类外面定义
    54. size_t STR::string::nops_t = -1;

    PS：这里为了能方便与库里面的string进行区分，这里自定义了一个命名空间STR。

            这里开始写拷贝构造函数的时候就要注意了，成员变量中定义了一个数组，那么就要注意深浅拷贝的问题，为了避免浅拷贝，这里初始化的时候要为 _str 重新开辟一段空间。

    传统写法：

    1. //拷贝构造函数  传统写法
    2. string(const string& str)
    3. 	:_str(new char[str._capacity + 1])    //新开辟一段空间
    4. 	, _size(str._size)
    5. 	, _capacity(str._capacity)
    6. {
    7.  
    8.     strcpy(_str, str._str);
    9.  
    10. }

     现代写法：

    1. const char* c_str() const  //const string* const this
    2. {
    3. 	return _str;
    4. }
    5.  
    6.  
    7. void swap(string& str)
    8. {
    9.     std::swap(_str, str._str);
    10.     std::swap(_size, str._size);
    11.     std::swap(_capacity, str._capacity);
    12. }
    13.  
    14. //拷贝构造函数  现代写法
    15. string(const string& str)
    16. 	   :_str(nullptr)
    17. 		, _size(0)
    18. 		, _capacity(0)
    19. {
    20.     //注意这里是str._str是char*类型的字符串,这里复用了构造函数
    21.     string tmp(str._str); 
    22.  
    23.     swap(tmp);
    24. }

            拷贝构造函数的现代写法非常巧妙、简洁，并且借用了构造函数来进行深拷贝。

            这里定义了一个交换函数swap()，里面复用了库里面的swap()来交换数据。

            库里面的swap()被摸板化了，可以直接进行自定义类型的交换，但是这里会多次调用拷贝构造，浪费效率。

            所以这里在string内部又重载了一个 swap()函数，其本身只是进行变量数据的交换，所以效率比较高。  

            现代写法的思路就是把传进来的字符串重新生成一个对象，再把对象的数据跟自己交换，而且由于tmp是函数内部的局部变量，出了函数就会调用析构函数销毁，不用手动释放地址。

            这种写法也可以在重载赋值符号上，重载赋值符号的时候也要考虑深浅拷贝的问题。

    1. //传统写法
    2. string& operator=(const string& str)
    3. {
    4.  
    5. 	if (this!=&str) {
    6.  
    7. 		delete[] _str;
    8. 		_str = new char[str._capacity + 1];  //+1是给\0留的空间
    9. 		strcpy(_str, str._str);
    10. 		_capacity = str._capacity;
    11. 		_size = str._size;
    12.  
    13. 	}
    14.  
    15. 		return *this;
    16. }
    17.  
    18. //现代写法
    19. string& operator=(const string& str)
    20. {
    21. 	if (this != &str) {
    22.  
    23. 		string tmp(str._str);
    24. 		swap(tmp);
    25. 	}
    26. 		return *this;
    27. }

            套路一样把传进来的字符串重新生成一个对象，再把对象的数据跟自己交换。

    1. string& operator=(const string& str)
    2. {
    3. 	if(this!=&str){
    4.         string tmp(str);
    5.         std::swap(*this,tmp); //这里使用库里面的swap,会造成错误
    6.     }
    7.     return *this;
    8. }

            还有一点， 如果重载赋值符号，使用库里面的swap()进行交换，swap（*this，tmp），函数内部还是使用的赋值符号，会再去调用赋值，所以这里会死循环，造成栈溢出。

    1. //重载[]  返回pos位置的字符的引用
    2.  
    3. //常量的调用 ，只能读，不能写
    4. const char& operator[](size_t pos) const
    5. {
    6. 	assert(pos < _size);
    7. 	return _str[pos];
    8. }
    9.  
    10. //普遍调用， 可以读，可以写
    11. char& operator[](size_t pos)
    12. {
    13. 	assert(pos < _size);
    14. 	return _str[pos];
    15. }

            重载[ ]非常简单，直接复用数组的[ ]即可。

    1. //扩容
    2. void reserve(size_t n)
    3. {
    4. 	if (n > _capacity) {
    5.  
    6. 		char* tmp = new char[n + 1];
    7. 		strcpy(tmp, _str);
    8. 		delete[] _str;
    9.  
    10. 		_str = tmp;
    11. 		_capacity = n;
    12.  
    13. 	}
    14.  
    15. }
    16.  
    17. //开空间并初始化
    18. void resize(size_t n,char ch='\0')
    19. {
    20. 	//1.比当前的空间大
    21. 	if (n>_size) {
    22.  
    23. 		reserve(n);
    24. 		for (size_t i = _size; i < n; i++) {
    25.  
    26. 			_str[i] = ch;
    27. 					
    28. 	    }
    29.  
    30. 		_str[n] = '\0';
    31. 		_size = n;
    32. 	}
    33. 	else {	//2.比当前的空间小
    34. 		_str[n] = '\0';
    35. 		_size = n;
    36.  
    37.     }
    38. }

            扩容函数，如果string内部已经有内容的话，要把数据拷贝到新开辟的空间里面去。开辟空间的时候要多留一个字节给"\0"。

    1. //插入一个字符串
    2. void push_back(char cn)
    3. {
    4.  
    5. 	if (_size == _capacity) { //如果空间满了，要扩容
    6.  
    7. 		//如果string容器里面没有数据，开4个字节的空间。
    8. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
    9. 	}
    10.  
    11. 		_str[_size] = cn;
    12. 		_size++;
    13. 		_str[_size] = '\0';
    14.  
    15. }
    16.  
    17. //插入一个字符串
    18. void append(const char* str)
    19. {
    20. 	size_t len = strlen(str);
    21. 	if (_size + len > _capacity) {
    22.  
    23. 		reserve(_size + len);
    24.  
    25. 	}
    26.  
    27. 	strcpy(_str + _size, str);
    28. 	//strcat(_str,str) 也可以使用这个函数追加，不过要找\0，效率低
    29. 	_size += len;
    30. }
    31.  
    32.  
    33. void append(const string& str)
    34. {
    35. 	append(str._str);
    36. }
    37.  
    38.  
    39. void append(size_t n, char ch)
    40. {
    41.  
    42. 	for (size_t i = 0; i < n; i++) {
    43. 		push_back(ch);
    44. 	}
    45.  
    46. }
    47.  
    48.  
    49. string& operator+=(char ch)
    50. {
    51. 	push_back(ch);
    52. 	return *this;
    53. }
    54.  
    55.  
    56. string& operator+=(const char* str)
    57. {
    58. 	append(str);
    59. 	return *this;
    60. }
    61.

            插入字符或者字符串，实现其实比较简单，主要是注意判断如果数组的容量占满了要重新开辟空间。

            

    1. //插入字符
    2. string& insert(size_t pos, char ch)
    3. {
    4. 	assert(pos <= _size);
    5. 	if (_size == _capacity) {
    6.  
    7. 		reserve(_capacity == 0 ? 4 : _capacity * 2);
    8.  
    9. 	}
    10.  
    11. 	size_t end = _size + 1;
    12. 	while (end > pos) {
    13.  
    14. 		_str[end] = _str[end - 1];
    15. 		end--;
    16. 	}
    17.  
    18. 	_str[pos] = ch;
    19. 	_size++;
    20.  
    21. 	return *this;
    22. }
    23.  
    24. //插入字符串
    25. string& insert(size_t pos, const char* str)
    26. {
    27. 	assert(pos <= _size);
    28. 	size_t len = strlen(str);
    29.  
    30. 	if (_size + len > _capacity) {
    31. 		reserve(_size + len);
    32. 	}
    33.  
    34. 	size_t end = _size + len;
    35. 	while (end >= pos + len) {
    36.  
    37. 		_str[end] = _str[end - len];
    38. 		end--;	
    39. 	}
    40.  
    41. 	strncpy(_str + pos, str, len);
    42. 	_size += len;
    43.  
    44. 	return *this;
    45. }

            在指定位置插入时，要把插入位置后面的数据往后挪动。这里不要用strcpy()会把\0也拷贝进去，所以这里使用了strncay()；

    1. size_t end = _size;
    2. while (end >= pos) {
    3.     
    4.     //这里pos==0,end减到最后变为-1的时候，会变得非常大，造成越界。		
    5.     _str[end + 1] = _str[end];
    6.     end--;
    7. }
    8.  
    9. size_t end = _size+1;
    10. while (end > pos) {
    11. 				
    12.     _str[end] = _str[end-1];
    13.     end--;
    14. }

    PS：这里挪动数据有两种写法，最好使用下面的写法，因为上面在开头插入数据时，最后end会变为-1，而这里end是size_t类型的数据，会变得非常大，从而出错。

    1. void push_back(char ch)
    2. {
    3.     insert(_size,ch);
    4. }
    5.  
    6. void append(const char* str)
    7. {
    8.     intsert(_size,str);
    9. }

            其实也可以先实现insert()，然后复用实现push_back()和append()。

    1. //删除
    2. void erase(size_t pos, size_t n = nops_t) //如果不写，那么全删除了
    3. {
    4. 	assert(pos < _size);
    5.  
    6. 	//如果没给参数，或者给的参数过大，则pos后面的全部删除
    7. 	if (n == nops_t || n + pos > _size) {
    8. 		_str[0] = '\0';
    9. 		_size = 0;
    10. 	}
    11. 	else
    12. 	{
    13. 		//把要删除的数据，用后面的数据覆盖
    14. 		strcpy(_str + pos, _str + pos + n);
    15. 		_size -= n;
    16.  
    17. 	}
    18. }
    19.  
    20. void clear()
    21. {
    22. 	_str[0] = '\0';
    23. 	_size = 0;
    24. }

            删除函数比较简单没什么要注意的地方。

    1. //查找字符
    2. size_t find(char ch, size_t pos = 0) 
    3. {
    4. 	assert(pos < _size);
    5. 	for (size_t i = pos; i < _size;i++) {
    6. 		if (ch==_str[i]) {
    7. 			return i;
    8. 		}
    9. 	}
    10.  
    11. 	return nops_t;
    12. }
    13.  
    14. //查找字符串
    15. size_t find(const char* sub, size_t pos = 0)
    16. {
    17. 	assert(pos < _size);
    18. 	const char* ret = strstr(_str + pos,sub);
    19. 	if (ret == nullptr) {
    20. 		return nops_t;
    21. 	}
    22. 	else {
    23. 		return ret - _str;
    24. 	}
    25.  
    26. }

            这里使用了库里面的串匹配函数，这里也可以自己写个KMP算法来查找，不过其实效率也差不多。

            这里返回查找到字符串位置的写法比较巧妙，使用的是指针减指针的知识点，获得的是中间元素的个数，而_str又是数组的起始地址，所以这里就返回的就是查找到的位置。

    1. bool operator>(const string& str)const
    2. {
    3. 	//大于0就是真
    4. 	return strcmp(_str, str._str) > 0;
    5. }
    6.  
    7. bool operator==(const string& str)const
    8. {
    9. 	return strcmp(_str, str._str) == 0;
    10. }
    11. 		
    12. bool operator<=(const string& str)const
    13. {
    14. 	return  !(*this > str);
    15. }
    16. 		
    17. bool operator>=(const string& str)const
    18. {
    19. 	return *this > str || *this == str;
    20. }
    21. 		
    22. bool operator<(const string& str)const
    23. {
    24. 	return !(*this >= str);
    25. }
    26. 		
    27. bool operator!=(const string& str)const
    28. {
    29. 	return !(*this == str);
    30. }

            C语言里面字符串是可以比较大小的，所以这里也要重载一下，这里直接复用strcmp()，以后比较字符串的大小的时候，就可以直接使用运算符，很方便也容易理解。

    1. string substr(size_t pos, size_t len = nops_t)const
    2. {
    3. 	assert(pos < _size);
    4. 	size_t realLen = len;
    5.     //如果没给参数，或者给的参数过大，则pos后面的全部返回为子串
    6. 	if (len == nops_t || pos + len > _size)
    7. 	{
    8. 		realLen = _size - pos;
    9. 	}
    10.  
    11. 	string sub;
    12. 	for (size_t i = 0; i < realLen;i++) {
    13. 		sub += _str[pos + i];
    14. 	}
    15.  
    16. 	return sub;
    17. }

            把主串中的一段数据作子串返回。分割字符串的时候用的比较多。

    1. //重载流提取和流插入
    2. //实现成全局函数，避免和this指针的位置问题。
    3. std::ostream& operator<<(std::ostream& out, const string& str);
    4.  
    5.  
    6. std::istream& operator>>(std::istream& in, string& str);
    7.  
    8.  
    9. std::ostream& STR::operator<<(std::ostream& out, const string& str)
    10. {
    11. 	for (size_t i = 0; i < str.size(); i++)
    12. 	{
    13. 		out << str[i];
    14. 	}
    15.  
    16. 	return out;
    17. }
    18.  
    19.  
    20.  
    21. //这种写法+=多次，扩容多次
    22. std::istream& STR::operator>>(std::istream& in, string& str)
    23. {
    24. 	
    25. 	char ch;
    26. 	//in>>ch 不能使用这个，这个无法检查到空格
    27. 	ch = in.get();
    28. 	while (ch != ' ' && ch != '\n') {
    29.  
    30. 	    str += ch;
    31. 		ch = in.get();
    32.  
    33. 	}
    34.  
    35. 	return in;
    36. }
    37.  
    38.  
    39.  
    40. std::istream& STR::operator>>(std::istream& in, string& str)
    41. {
    42. 	str.clear();
    43. 	char ch;
    44.  
    45. 	const size_t N = 32;
    46. 	char buff[N]={0};
    47. 	size_t i = 0;
    48.  
    49. 	ch = in.get();
    50. 	//其思路是，buff满了，再追加到str里面
    51. 	while (ch != ' ' && ch != '\n') {
    52. 	
    53. 		buff[i++] = ch;
    54. 		if (i == N-1) {
    55. 			
    56. 			buff[i] = '\0';
    57. 			str += buff;
    58. 			i = 0;
    59.  
    60. 		}
    61. 		ch = in.get();
    62. 	
    63. 	}
    64.  
    65. 	buff[i] = '\0';
    66. 	str += buff;
    67.  
    68. 	return in;
    69.  
    70. }

            这里流提取比较好理解，但是流插入要注意一下，流插入是可以连续对多个对象进行插入的。

            但是使用cin>>ch；这种写法不能接收到空格和换行符，因为它本身检查到空格和换行就是输入的间隔，会造成这里退出不了循环，所以这里使用了cin里面自带的get()函数。

            如果输入的内容很长，使用+=的效率很低。所以这里使用一个数组先接收一定的数据，数组的数据满了才添加到对象里面(和缓冲区的概念相似)。

    1. //迭代器
    2. typedef char* iterator;
    3. //const 迭代器
    4. typedef const char* const_iterator;
    5. iterator begin()
    6. {
    7. 	return _str;
    8. }
    9.  
    10. iterator end()
    11. {
    12. 	return _size + _str;
    13. }

            迭代器的实现也比较简单，因为string就是用数组来存储的字符串，用指针也可以访问，这里只不过是把指针进行了宏定义，但是这种写法也是可以使用范围for的。

     

  • 相关阅读:
    Splunk UBA audit log 发送到 Splunk ES
    Python中向量的表示
    金翅擘海|人大女王金融硕士庞雪雨：行学之道，在自律、在勤勉、在止于至善
    2022.07.05
    【华为OD机试】选修课【2023 B卷|100分】
    java计算机毕业设计会员商城管理系统MyBatis+系统+LW文档+源码+调试部署
    C#和Excel文件的读写交互
    Redis 缓存穿透、缓存击穿、缓存雪崩
    cengbox2靶机(hydra爆破、公私钥免密登录)
    C语言连接【MySQL】
  • 原文地址：https://blog.csdn.net/weixin_45423515/article/details/126593257