• 从零开始的C++之旅——string类的模拟实现

    1.string类是什么

            在C++中，stirng 类是标准库提供的一个非常强大的字符串处理工具。相比于C语言中的字符
            数组（char[ ]) , string 类提供了更多方便且安全的操作。同时也更符合我们面向对象语言的特
            点。

    2.stirng类的模拟实现

            string类的模拟实现我们就模拟实现一些高频使用的容器操作，在逐步的实现过程中了解其底
            层的实现方式。需要注意地是，我们需要将直接实现的string类与系统中自带的string类分开，
            使用，我将其包在一个自定义的命名空间里面

            同时由于定义声明分离，我们在定义函数时需要指定类域

    2.1 定义成员变量

            string类型的成员变量其实跟我们之前数据结构定义的顺序表十分相似，同时一些操作的实现
            也与顺序表类似，因此实现方式也基本类似，无非就是多了类和对象的相关只是，在实现
            string类的过程中也可以帮助我们对c++的一些相关知识有更好的掌握

            既然和顺序表类似类似，那么其自然是三个成员变量，一个是大小size，一个是存储空间大小
            capacity，一个是char*类型的指针

                    

    2.2 构造函数

    string(const char* str = "")

            构造函数我们实现一个带缺省值的构造函数，使得我们实例化一个对象时，若没有传参则会
            调缺省值生成一个空串，若传参了则按吗传的参数进行初始化。

            所以首先我们的参数类型应该是接受字符串的首元素地址所以是char*类型，同时保证传递参
            数不被修改加上const

            对_str的初始化，自然是使用new 去申请一块空间，需要注意的是申请空间的大小应比字符串
            的大小大一位，因为还需要存储 “ \0  ”。size和capacity自然是初始化为0。

            同时，要调用strcpy函数将传入的字符串拷贝到string类当中

    1. 	string::string(const char* str)
    2. 		:_str(new char[strlen(str) + 1])
    3. 		, _size(strlen(str))
    4. 		, _capacity(strlen(str))
    5. 	{
    6. 		strcpy(_str, str);
    7. 	}

    2.3 析构函数 

            有了构造函数，我们自然可以实现对应的析构函数。只需要使用delete[ ]释放掉new[ ]申请的
            空间，并将str=nullptr，size，capacity=0即可

    1. 	string::~string()
    2. 	{
    3. 		delete[] _str;
    4. 		_str = nullptr;
    5. 		_size = _capacity = 0;
    6. 	}

    2.4 开辟空间函数

            在实现pushback之前，我们要实现一个函数reserve，实现空间的扩容，避免空间不足。

            首先我们函数的参数是一个size_t类型的参数n，即表示我们需要扩容的大小。我们使用if条件
            判断一下当前扩容的空间n是否是否小于当前的有空间capacity，避免产生缩容

            扩容的第一步自然是申请一片空间，大小为n+1，随后使用strcpy将原对象中的数据拷贝到新
            开辟的空间，随后释放掉原空间申请的内存，再使_str指向新开辟的空间，最后更新capacity

    1. 	void string::reserve(size_t n)
    2. 	{
    3. 		if (n > _capacity)//判断，因为reserve功能不是缩容
    4. 		{
    5. 			char* tmp = new char[n + 1];
    6. 			strcpy(tmp, _str);
    7. 			delete[] _str;
    8. 			_str = tmp;
    9. 			_capacity = n;
    10. 		}
    11.     }

    2.5 迭代器

            string类的迭代器相对比较简单，一位他的数据无论是逻辑顺序还是逻辑顺序都是连续的，因
            此我们简单的用指针的遍历来模拟迭代器。

    1. 		typedef char* iterator;
    2. 		typedef const char* const_iterator;

    普通迭代器

    1. 		iterator begin()
    2. 		{
    3. 			return _str;
    4. 		}
    5.  
    6. 		iterator end()
    7. 		{
    8. 			return _str + _size;
    9. 		}

    const 迭代器

    1. 	    const_iterator begin() const
    2. 		{
    3. 			return _str;
    4. 		}
    5.  
    6. 		const_iterator end() const
    7. 		{
    8. 			return _str + _size;
    9. 		}

    2.6 插入函数

            有了reserve函数之后，我们便可以实现尾插函数，而尾插函数又分为尾插一个字符和一个字
            符串。插入函数的逻辑与顺序表的插入大致类似。熟悉了顺序表的插入这自然也得心应手。

    尾插一个字符（push_back）

            尾插一个字符逻辑非常简单，只需要先判断一下空间是否需要扩容，之后再尾部加上要插入
            的字符，随后更新size即可

    1. 	void string::push_back(char ch)
    2. 	{
    3. 		if (_size == _capacity)
    4. 		{
    5. 			reserve(_capacity == 0 ? 4 : 2 * _capacity);
    6. 		}
    7. 		_str[_size++]=ch;
    8. 	}

    尾插一个字符串（append）

            由于我们扩大逻辑一般为二倍扩容，因此若插入的字符串有可能出现及时扩容后空间依然不
            足的情况，所以我们需要一个if条件判断扩容后的空间只否足够插入字符串。若扩容后的空间
            依然不足插入字符串，则直接扩容至size+len的大小。扩容完毕后只需要使用strcpy将需要插
            入的字符串拷贝到str的末尾即可

    1. 	void string::append(const char* str)
    2. 	{
    3. 		size_t len = strlen(str);
    4. 		if (_size + len >= _capacity)
    5. 		{
    6. 			size_t newcapacity = 2 * _capacity;
    7. 			if (newcapacity < _size + len)
    8. 				newcapacity = _size + len;
    9. 			
    10. 			reserve(newcapacity);
    11. 		}
    12. 		strcpy(_str + _size, str);
    13. 		_size += len;
    14. 	}

     指定位置插入（insert）

    指定位置插入单个字符

            首先自然是扩容,其逻辑与append一致，不再过多赘述。

            在扩容完成之后，需要定义一个指针end，将pos位置以后的数据依次往后挪动一位，再将
            字符插入到pos位置即可

    1. 	void string::insert(size_t pos, char ch)
    2. 	{
    3. 		if (_size == _capacity)
    4. 		{
    5. 			reserve(_capacity == 0 ? 4 : 2 * _capacity);
    6. 		}
    7. 		size_t end = _size + 1;
    8.  
    9. 		while (end != pos)
    10. 		{
    11. 			_str[end] = _str[end - 1];
    12. 			end--;
    13. 		}
    14. 		_str[pos] = ch;
    15. 		_size++;
    16. 	}
    插入一个字符串

            插入字符串则是再扩容之后，需要将一段区间的数据往后挪，这时候我们就需要定义指针end
            end指向末尾之后的len个长度（len为插入字符串的大小），在将依次将原数据的末尾字符从
            头往前挪动，最后使用strcpy将要插入的字符串拷贝到pos位置。

    insert的复用

            在有了指定位置插入insert函数之后，我们便可以复用我们的insert来实现pushback和
            apped。

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

    2.7 删除函数 

    指定位置删除（erase）

            指定位置删除我们要实现的是删除从pos位置开始的n个字符

            因此我们首先要计算出我们需要前移几个数据，，再定义一个end指针指向要移除的元素区间
            的下一元素，将其赋值给（end-n）位置的元素，再让end++，直到将剩余元素移完

    1. 	void string::erase(size_t pos, size_t len)
    2. 	{
    3. 		assert(pos < _size);
    4. 		if (len >= _size - pos)
    5. 		{
    6. 			_str[pos] = '\0';
    7. 			_size = pos;
    8. 		}
    9. 		else
    10. 		{
    11. 			size_t end = pos;
    12. 			while (end + len <= _size)
    13. 			{
    14. 				_str[end] = _str[end + len];
    15. 				end++;
    16. 			}
    17. 			_size -= len;
    18. 		}
    19. 	}

    2.8 交换函数

            库中虽然有交换函数，但是其行为对于类来说要进行多次深拷贝，代价非常的大，因此我们
            自己实现一个函数，进行拷贝构造，提高其效率。

    swap（string& s）

            在一开始的时候我们就定义了类的成员变量，那么其实我们只要交换两个类的成员变量就可
            以实现两个类的交换，这时候就可以调用库中的swap来进行成员变量的交换，因为其只涉及
            浅拷贝，代价较小

    1. 	void string::swap(string& s)
    2. 	{
    3. 		std::swap(_str, s._str);
    4. 		std::swap(_size, s._size);
    5. 		std::swap(_capacity, s._capacity);
    6. 	}

    2.9 拷贝构造

            由于我们的stirng在构造时候申请了资源，因此编译器自动生成的拷贝构造浅拷贝行为无法完
            成我们的需要，这回导致两个对象指向同一片空间从而析构两次而报错。因此我们就需要自
            己写拷贝构造。

    string(const string& s)

            有了类的交换函数之后我，就可以轻松的实现拷贝构造，我们只需用被拷贝的对象创建一个
            临时变量tmp，再调用我们自己实现的swap函数将其与我们要创建的对象交换即可，并且tmp
            这个临时对象也会在出函数的时候自动销毁不需要我们去手动销毁，一举两得

    1. 	string::string(const string& s)
    2. 	{
    3. 		string tmp(s._str);
    4. 		swap(tmp);
    5. 	}

    2.10 赋值重载

            同理于拷贝构造，我们自然也要自己实现那赋值重载。

    string& operator=(string s)

            由于这里的函数参数并不是对象的引用，因此是传递的参数锁构造出来的一个临时对象，我
            们只需调用我们实现的swap函数进行交换最后返回*this即可，临时对象s也会在出函数之后自
            己销毁。

    1.  
    2. 	string& string::operator=(string s)
    3. 	{
    4. 		swap(s);
    5. 		return *this;
    6. 	}

    2.11 运算符重载

            运算符的重载可以复用，这意味着我们只需要实现一两个运算符的重载即可复用从而实现
            其他的。

            由于运算符重载的函数其第一个参数并不是累的this指针，因此我们将其实现在类的外部
            又因为我们的string类是实现在自己的命名空间中，因此不需要将其再重载为友元函数，编译
            器会自己在命名空间中寻找。

     重载+=

            +=的逻辑与插入函数一致，我们只需要复用我的的两个插入函数即可

    1. 	string& string::operator+=(char ch)
    2. 	{
    3. 		push_back(ch);
    4. 		return *this;
    5. 	}
    6.  
    7. 	string& string::operator+=(const char* str)
    8. 	{
    9. 		append(str);
    10. 		return *this;
    11. 	}

     重载==

            ==运算符的逻辑是字符串的比较，因此我们只需要调用哭函数中的strcmp即可

    1. 	bool bit::operator==(const string& lhs, const string& rhs)
    2. 	{
    3. 		return strcmp(lhs.c_str(), rhs.c_str()) == 0;
    4. 	}

     重载>

            >的重载本质也是比较字符串，调用strcmp即可实现

    1. 	bool bit::operator>(const string& lhs, const string& rhs)
    2. 	{
    3. 		return strcmp(lhs.c_str(), rhs.c_str()) > 0;
    4. 	}

     重载>= , != , < , <= 

    1. 	bool bit::operator<(const string& lhs, const string& rhs)
    2. 	{
    3. 		return !(lhs >= rhs);
    4. 	}
    5. 	bool bit::operator>=(const string& lhs, const string& rhs)
    6. 	{
    7. 		return lhs == rhs || lhs > rhs;
    8. 	}
    9. 	bool bit::operator<=(const string& lhs, const string& rhs)
    10. 	{
    11. 		return !(lhs > rhs);
    12. 	}
    13. 	bool bit::operator!=(const string& lhs, const string& rhs)
    14. 	{
    15. 		return !(lhs == rhs);
    16. 	}

    2.12 流插入流提取重载

             

    1. 	ostream& operator<<(ostream& os, const string& str)
    2. 	{
    3. 		for (size_t i = 0; i < str.size(); i++)
    4. 		{
    5. 			os << str[i];
    6. 		}
    7. 		return os;
    8. 	}
    9.  
    10. 	istream& operator>>(istream& is, string& str)
    11. 	{
    12. 		str.clear();
    13.  
    14. 		int i = 0;
    15. 		char buff[256];//建立临时数组，避免频繁开空间，并且栈上开空间比堆上开空间效率高
    16.  
    17. 		char ch;
    18. 		ch = is.get();
    19. 		while (ch != ' ' && ch != '\n')
    20. 		{
    21. 			buff[i++] = ch;
    22. 			if (i == 255)
    23. 			{
    24. 				buff[255] = '\0';
    25. 				str += buff;
    26. 				i = 0;
    27. 			}
    28. 			ch = is.get();
    29. 		}
    30.  
    31. 		if (i > 0)
    32. 		{
    33. 			buff[i] = '\0';
    34. 			str += buff;
    35. 		}
    36. 		return is;
    37. 	}

    3. 源代码 

    stirng.h

    1. #pragma once
    2. #include<iostream>
    3. #include<assert.h>
    4. using namespace std;
    5.  
    6. namespace bit
    7. {
    8.  
    9. 	class string
    10. 	{
    11. 	public:
    12. 		typedef char* iterator;
    13. 		typedef const char* const_iterator;
    14. 		string(const char* str = "");
    15. 		~string();
    16. 		string(const string& s);
    17.  
    18. 		void reserve(size_t n);
    19. 		void push_back(char ch);
    20. 		void append(const char* str);
    21. 		string& operator+=(char ch);
    22. 		string& operator+=(const char* str);
    23. 		string& operator=(string s);
    24.  
    25. 		void insert(size_t pos, char ch);
    26. 		void insert(size_t pos, const char* str);
    27. 		void erase(size_t pos, size_t len = npos);
    28. 		size_t find(char ch, size_t pos = 0);
    29. 		size_t find(const char* str, size_t pos = 0);
    30.  
    31. 		string substr(size_t pos, size_t len = npos);
    32. 		void swap(string& s);
    33.  
    34. 		const char* c_str() const
    35. 		{
    36. 			return _str;
    37. 		}
    38.  
    39. 		size_t size() const
    40. 		{
    41. 			return _size;
    42. 		}
    43.  
    44. 		char& operator[](size_t i)
    45. 		{
    46. 			assert(i < _size);
    47. 			return _str[i];
    48. 		}
    49.  
    50. 		char& operator[](size_t i) const
    51. 		{
    52. 			assert(i < _size);
    53. 			return _str[i];
    54. 		}
    55.  
    56. 		iterator begin()
    57. 		{
    58. 			return _str;
    59. 		}
    60.  
    61. 		iterator end()
    62. 		{
    63. 			return _str + _size;
    64. 		}
    65.  
    66. 		const_iterator begin() const
    67. 		{
    68. 			return _str;
    69. 		}
    70.  
    71. 		const_iterator end() const
    72. 		{
    73. 			return _str + _size;
    74. 		}
    75.  
    76. 		void clear()
    77. 		{
    78. 			_str[0] = '\0';
    79. 			_size = _capacity = 0;
    80. 		}
    81.  
    82. 	private:
    83. 		size_t _size;
    84. 		size_t _capacity;
    85. 		char* _str;
    86. 	public:
    87. 		//static const size_t npos = -1;
    88. 		//静态成员变量不能给缺省值必须类内定义类外声明
    89. 		// 但const 整形静态成员可以直接给缺省值，算是特殊处理
    90. 		static const size_t npos;
    91. 	};
    92.  
    93. 	void swap(string& s1, string& s2);
    94.  
    95. 	bool operator==(const string& lhs, const string& rhs);
    96. 	bool operator!=(const string& lhs, const string& rhs);
    97. 	bool operator>(const string& lhs, const string& rhs);
    98. 	bool operator<(const string& lhs, const string& rhs);
    99. 	bool operator>=(const string& lhs, const string& rhs);
    100. 	bool operator<=(const string& lhs, const string& rhs);
    101.  
    102. 	ostream& operator<<(ostream& os, const string& str);
    103. 	istream& operator>>(istream& is, string& str);
    104. 	istream& getline(istream& is, string& str, char delim = '\n');
    105. }


    string.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"string.h"
    3.  
    4. namespace bit
    5. {
    6. 	const size_t string::npos = -1;
    7.  
    8. 	string::string(const char* str)
    9. 		:_str(new char[strlen(str) + 1])
    10. 		, _size(strlen(str))
    11. 		, _capacity(strlen(str))
    12. 	{
    13. 		strcpy(_str, str);
    14. 	}
    15.  
    16. 	string::~string()
    17. 	{
    18. 		delete[] _str;
    19. 		_str = nullptr;
    20. 		_size = _capacity = 0;
    21. 	}
    22.  
    23. 	//b2(b1)
    24. 	string::string(const string& s)
    25. 	{
    26. 		string tmp(s._str);
    27. 		swap(tmp);
    28. 	}
    29.  
    30. 	void string::reserve(size_t n)
    31. 	{
    32. 		if (n > _capacity)//判断，因为reserve功能不是缩容
    33. 		{
    34. 			char* tmp = new char[n + 1];
    35. 			strcpy(tmp, _str);
    36. 			delete[] _str;
    37. 			_str = tmp;
    38. 			_capacity = n;
    39. 		}
    40. 	}
    41.  
    42. 	void string::push_back(char ch)
    43. 	{
    44. 		/*if (_size == _capacity)
    45. 		{
    46. 			reserve(_capacity == 0 ? 4 : 2 * _capacity);
    47. 		}
    48. 		_str[_size++] = ch;*/
    49. 		insert(_size, ch);
    50. 	}
    51.  
    52. 	void string::append(const char* str)
    53. 	{
    54. 		//size_t len = strlen(str);
    55. 		//if (_size + len >= _capacity)
    56. 		//{
    57. 		//	size_t newcapacity = 2 * _capacity;
    58. 		//	if (newcapacity < _size + len)
    59. 		//		newcapacity = _size + len;
    60. 		//	
    61. 		//	reserve(newcapacity);
    62. 		//}
    63. 		//strcpy(_str + _size, str);
    64. 		//_size += len;
    65. 		insert(_size, str);
    66. 	}
    67.  
    68.  
    69. 	string& string::operator+=(char ch)
    70. 	{
    71. 		push_back(ch);
    72. 		return *this;
    73. 	}
    74.  
    75. 	string& string::operator+=(const char* str)
    76. 	{
    77. 		append(str);
    78. 		return *this;
    79. 	}
    80.  
    81. 	void string::insert(size_t pos, char ch)
    82. 	{
    83. 		if (_size == _capacity)
    84. 		{
    85. 			reserve(_capacity == 0 ? 4 : 2 * _capacity);
    86. 		}
    87. 		size_t end = _size + 1;
    88.  
    89. 		while (end != pos)
    90. 		{
    91. 			_str[end] = _str[end - 1];
    92. 			end--;
    93. 		}
    94. 		_str[pos] = ch;
    95. 		_size++;
    96. 	}
    97. 	void string::insert(size_t pos, const char* str)
    98. 	{
    99. 		size_t len = strlen(str);
    100. 		if (_size + len >= _capacity)
    101. 		{
    102. 			size_t newcapacity = 2 * _capacity;
    103. 			if (newcapacity < _size + len)
    104. 				newcapacity = _size + len;
    105.  
    106. 			reserve(newcapacity);
    107. 		}
    108.  
    109. 		len = strlen(str);
    110. 		size_t end = _size + len;
    111. 		while (end != pos + len - 1)
    112. 		{
    113. 			_str[end] = _str[end - len];
    114. 			end--;
    115. 		}
    116. 		for (size_t i = 0; i < len; i++)
    117. 		{
    118. 			_str[pos + i] = str[i];
    119. 		}
    120. 		_size += len;
    121. 	}
    122.  
    123. 	void string::erase(size_t pos, size_t len)
    124. 	{
    125. 		assert(pos < _size);
    126. 		if (len >= _size - pos)
    127. 		{
    128. 			_str[pos] = '\0';
    129. 			_size = pos;
    130. 		}
    131. 		else
    132. 		{
    133. 			size_t end = pos;
    134. 			while (end + len <= _size)
    135. 			{
    136. 				_str[end] = _str[end + len];
    137. 				end++;
    138. 			}
    139. 			_size -= len;
    140. 		}
    141. 	}
    142.  
    143. 	size_t string::find(char ch, size_t pos)
    144. 	{
    145. 		assert(pos < _size);
    146. 		for (size_t i = pos; i < _size; i++)
    147. 		{
    148. 			if (_str[i] == ch)
    149. 				return i;
    150. 		}
    151. 		return npos;
    152. 	}
    153.  
    154. 	size_t string::find(const char* str, size_t pos)
    155. 	{
    156. 		assert(pos < _size);
    157. 		const char* ptr = strstr(_str + pos, str);
    158. 		if (ptr == nullptr)
    159. 			return npos;
    160. 		else
    161. 			return ptr - _str;
    162. 	}
    163.  
    164. 	string string::substr(size_t pos, size_t len)
    165. 	{
    166. 		if (len > (_size - pos))
    167. 		{
    168. 			len = _size - pos;
    169. 		}
    170.  
    171. 		bit::string sub;
    172. 		sub.reserve(len);
    173. 		for (size_t i = 0; i < len; i++)
    174. 		{
    175. 			sub += _str[pos + i];
    176. 		}
    177.  
    178. 		return sub;
    179. 	}
    180.  
    181. 	string& string::operator=(string s)
    182. 	{
    183. 		swap(s);
    184. 		return *this;
    185. 	}
    186.  
    187. 	void string::swap(string& s)
    188. 	{
    189. 		std::swap(_str, s._str);
    190. 		std::swap(_size, s._size);
    191. 		std::swap(_capacity, s._capacity);
    192. 	}
    193.  
    194. 	void swap(string& s1, string& s2)
    195. 	{
    196. 		s1.swap(s2);
    197. 	}
    198.  
    199.  
    200. 	bool bit::operator==(const string& lhs, const string& rhs)
    201. 	{
    202. 		return strcmp(lhs.c_str(), rhs.c_str()) == 0;
    203. 	}
    204. 	bool bit::operator!=(const string& lhs, const string& rhs)
    205. 	{
    206. 		return !(lhs == rhs);
    207. 	}
    208. 	bool bit::operator>(const string& lhs, const string& rhs)
    209. 	{
    210. 		return strcmp(lhs.c_str(), rhs.c_str()) > 0;
    211. 	}
    212. 	bool bit::operator<(const string& lhs, const string& rhs)
    213. 	{
    214. 		return !(lhs >= rhs);
    215. 	}
    216. 	bool bit::operator>=(const string& lhs, const string& rhs)
    217. 	{
    218. 		return lhs == rhs || lhs > rhs;
    219. 	}
    220. 	bool bit::operator<=(const string& lhs, const string& rhs)
    221. 	{
    222. 		return !(lhs > rhs);
    223. 	}
    224.  
    225. 	ostream& operator<<(ostream& os, const string& str)
    226. 	{
    227. 		for (size_t i = 0; i < str.size(); i++)
    228. 		{
    229. 			os << str[i];
    230. 		}
    231. 		return os;
    232. 	}
    233.  
    234. 	istream& operator>>(istream& is, string& str)
    235. 	{
    236. 		str.clear();
    237.  
    238. 		int i = 0;
    239. 		char buff[256];//建立临时数组，避免频繁开空间，并且栈上开空间比堆上开空间效率高
    240.  
    241. 		char ch;
    242. 		ch = is.get();
    243. 		while (ch != ' ' && ch != '\n')
    244. 		{
    245. 			buff[i++] = ch;
    246. 			if (i == 255)
    247. 			{
    248. 				buff[255] = '\0';
    249. 				str += buff;
    250. 				i = 0;
    251. 			}
    252. 			ch = is.get();
    253. 		}
    254.  
    255. 		if (i > 0)
    256. 		{
    257. 			buff[i] = '\0';
    258. 			str += buff;
    259. 		}
    260. 		return is;
    261. 	}
    262.  
    263. 	istream& getline(istream& is, string& str, char delim)
    264. 	{
    265. 		str.clear();
    266.  
    267. 		int i = 0;
    268. 		char buff[256];
    269.  
    270. 		char ch;
    271. 		ch = is.get();
    272. 		while (ch != delim)
    273. 		{
    274. 			buff[i++] = ch;
    275. 			if (i == 255)
    276. 			{
    277. 				buff[255] = '\0';
    278. 				str += buff;
    279. 				i = 0;
    280. 			}
    281. 			ch = is.get();
    282. 		}
    283.  
    284. 		if (i > 0)
    285. 		{
    286. 			buff[i] = '\0';
    287. 			str += buff;
    288. 		}
    289. 		return is;
    290. 	}
    291. }

  • 相关阅读:
    C语言scanf_s函数的使用
    面了一个00后测试工程师，问啥啥不会开口就要15k，我也是麻了····
    java 多excel下载 打成zip压缩包 程序中创建文件 响应到浏览器
    sqlalchemy 连接池
    带头的循环双向链表的简单介绍
    Java面试题整理面向对象
    UE4 AI行为树实现随机和跟随移动
    Spring Security -- 前后端分离时的安全处理方案
    Pandas 数据可视化
    ElementUI validate 验证结果错误的问题解决过程
  • 原文地址：https://blog.csdn.net/2302_81813630/article/details/143394582