devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C++】————string基础用法及部分函数底层实现_c++ string

作者：木道寻08 | 2024-07-07 01:17:58

赞

踩

c++ string

 9efbcbc3d25747719da38c01b3fa9b4f.gif

                                                      作者主页：     作者主页

                                                      本篇博客专栏：C++

                                                      创作时间 ：2024年6月30日

9efbcbc3d25747719da38c01b3fa9b4f.gif

前言：

 本文主要介绍STL容器之一  ----  string，在学习C++的过程中，我们要将C++视为一个语言联邦（摘录于Effective C++ 条款一）。如何理解这句话呢，我们学习C++，可将其分为四个板块；分别为C、Object-Oriented C++（面向对象的C++）、Template C++（模板）、STL。本文就介绍STL中的string；

一、string是什么?

  string是STL文档的容器之一，是一个自定义类型，是一个类，由类模板basic_string实例化出来的一个类；

我们看一下cplusplus上是咋介绍的？

我们简单看一下即可，下面我来为大家做介绍。

二、string的使用：

  由于string出现的时间实际是早于STL的，是后来划分进STL库的，所以string开始的设计比较冗余，有许多没有必要的接口（一共106个接口函数）；这也是被广大C++程序员吐槽的一个槽点，我们无需将每一个接口都记住，我们需要将核心接口记住并熟练使用，遇见一些默认的接口查看文档即可；

2.1构造函数

        在C++98中，string的构造函数一种有如下7种；

  1. int main()
  2. {
  3. 	// 1、无参默认构造
  4. 	// string();
  5. 	string s1;
  6. 	// 2、拷贝构造   
  7. 	// string (const string& str);
  8. 	string s2(s1);
  9. 	// 4、通过字符串常量初始化   
  10. 	// string (const char* s);
  11. 	string s4("hello world");
  12. 	// 3、通过字符串子串初始化   
  13. 	// string (const string& str, size_t pos, size_t len = npos);
  14. 	string s3(s4, 5, 5);
  15. 	// 5、通过字符串前n个字符初始化   
  16. 	// string (const char* s, size_t n);
  17. 	string s5("hello wrold", 6);
  18. 	// 6、用n个字符c初始化字符串  
  19. 	//  string (size_t n, char c);
  20. 	string s6(10, 'x');
  21. 	// 7、迭代器区间初始化（暂不介绍）
  22. 	return 0;
  23. }

 其中提一下第三种，pos为子串的位置，len子串的长度，若len大于从子串pos位置开始后面字符总数，则表示初始化到子串结尾即可，比如我们要用 “hello world” 初始化字符串，若pos为6，len为20，则用world初始化字符串s1；len还有一个缺省值npos，其数值为无符号整型的-1，也就是无符号的最大值（无符号无负数）；

2.2赋值重载：

赋值重载使string能够用=对string对象重新赋值，string的赋值重载一共有有如下三种；

  1. int main()
  2. {
  3. 	string tmp("hello world");
  4. 	string s1;
  5. 	string s2;
  6. 	string s3;
  7. 	// 1、string类进行赋值重载
  8. 	s1 = tmp;
  9. 	// 2、使用字符串常量赋值重载
  10. 	s2 = "hello world";
  11. 	// 3、使用字符赋值重载
  12. 	s3 = 'A';
  13.     return 0;
  14. }

2.3容量相关接口

 首先介绍如下六个简单一些的接口；

  1. int main()
  2. {
  3. 	string s1("hello world");
  4. 	// string中储存的字符个数（不包括\0）
  5. 	cout << s1.length() << endl;
  6. 	// 与length功能相同
  7. 	cout << s1.size() << endl;
  8. 	// 可以最多储存多少个字符(理论值，实际上并没有那么多)
  9. 	cout << s1.max_size() << endl;
  10. 	// string的当前容量
  11. 	cout << s1.capacity() << endl;
  12. 	// 当前string对象是否为空
  13. 	cout << s1.empty() << endl;
  14. 	// 清空s1中所有字符
  15. 	s1.clear();
  16.     return 0;
  17. }

 其中的length与size两种并无相异，由于string出现的较早，当时没有STL其他容器，先出现了length，后来为了统一接口，于其他容器接口保持一致，因此出现了size；

  1. int main()
  2. {
  3. 	// reserve 提前开空间（可能会大于指定的大小，因此开空间规则不同）
  4. 	string s1;
  5. 	s1.reserve(100);
  6. 	cout << s1.size() << endl;
  7. 	cout << s1.capacity() << endl;
  8. 	// resize 提前开空间并初始化 缺省值为0
  9. 	string s2;
  10. 	s2.resize(100);
  11. 	cout << s2.size() << endl;
  12. 	cout << s2.capacity() << endl;
  13. 	s2 += "hhhhhh";
  14.     return 0;
  15. }

  我们发现reserve仅仅只是修改capacity，而resize不仅会修改capacity，还会修改size，然后用第二个参数取去初始化新增的区间；当指定大小小于原来空间时，reserve什么都不会做，而resize则会则断大于指定大小后面的区域（在后面补零）；

总结：reserve仅改变capacity，resize既改变capacity又改变size；当指定大小小于字符串的size时，resize还可以截断（在后面补 \0 ）

2.4迭代器

    迭代器是STL库中的一个特殊的存在，我们可以通过迭代器对string类中的字符进行增删查改； 在string类中，我们可将其视为指针；string类中的迭代器接口有如下几种；

 begin函数返回的是字符串中第一个字符的位置的迭代器，而end函数返回的字符串中最后一个字符的下一个位置的迭代器； 因此遍历一个string类，有一下三种方法；

  1. int main()
  2. {
  3. 	string s1("hello world");
  4. 	// 三种遍历方式
  5. 	// 1、通过[]来访问每一个字符
  6. 	for (int i = 0; i < s1.size(); i++)
  7. 	{
  8. 		cout << s1[i] << " ";
  9. 	}
  10. 	cout << endl;
  11. 	// 2、通过迭代来来访问每一个字符
  12. 	string::iterator it = s1.begin();
  13. 	while (it != s1.end())
  14. 	{
  15. 		cout << *it << " ";
  16. 		it++;
  17. 	}
  18. 	cout << endl;
  19. 	// 3、通过范围for（其实范围for就是编译器替换成了迭代器遍历的方法）
  20. 	for (auto ch : s1)
  21. 	{
  22. 		cout << ch << " ";
  23. 	}
  24. 	cout << endl;
  25.     return 0;
  26. }

     rbegin与rend系列为反向迭代器；rbegin返回的是最后一个字符的位置的迭代器，rend返回的是第一个字符的前一个位置的迭代器；

 我们可以通过反向迭代器，对其逆向遍历；反向迭代器的类型为 string::reverse_iterator；

  1. int main()
  2. {	
  3.     string s1("hello world");
  4.     string::reverse_iterator rit = s1.rbegin();
  5. 	while (rit != s1.rend())
  6. 	{
  7. 		cout << *rit << " ";
  8. 		rit++;
  9. 	}
  10.  
  11. }

2.5下标访问：

    关于元素的访问，也有如下四个接口，最常用的还是方括号； 

  1. int main()
  2. {
  3. 	// []重载使string可以像字符数组一样访问
  4. 	string s1("hello world");
  5. 	cout << s1[0] << endl;
  6. 	cout << s1[1] << endl;
  7. 	// at 于[] 功能相同，只不过[]的越界是由assert来限制，而at则是抛异常
  8. 	cout << s1.at(0) << endl;
  9. 	cout << s1.at(1) << endl;
  10. 	// front访问string中第一个字符
  11. 	cout << s1.front() << endl;
  12. 	// back访问string中最后一个字符
  13. 	cout << s1.back() << endl;
  14.     return 0;
  15. }

方括号的使用如同数组的方括号使用相同；at与方括号用法相同，只是遇见非法访问时是抛异常解决；

2.6修改

string的修改接口设计得十分冗余；其中我们可以用+=替代append与push_back;实际中，也是+=用得比较多，但是我们还是了解一下相关用法； 

  +=我们可以加等一个string类，可以加等一个字符，也可以加等一个字符指针；因此有以下用法；

  1. int main()
  2. {
  3. 	string tmp("xxxx");
  4. 	string s1("hello world");
  5. 	// += 字符
  6. 	s1 += ' ';
  7. 	// += string类
  8. 	s1 += tmp;
  9. 	// += 字符指针
  10. 	s1 += " hello world";
  11. 	cout << s1 << endl;
  12. }

  1. int main()
  2. {
  3. 	string tmp("xxxx");
  4. 	string s1;
  5. 	// 尾加字符
  6. 	// void push_back (char c);
  7. 	s1.push_back('c');
  8. 	// 尾加string类  
  9. 	// string& append (const string& str);
  10. 	s1.append(tmp);
  11. 	// 尾加string从subpos位置开始的sublen个字符   
  12. 	//string& append (const string& str, size_t subpos, size_t sublen);
  13. 	s1.append(tmp, 2, 3);
  14. 	// 用字符指针指向的字符串/字符尾加
  15. 	// string& append (const char* s);
  16. 	s1.append("hello world");
  17. 	// 用字符指针指向的字符串的前n个字符尾加
  18. 	// string& append (const char* s, size_t n);
  19. 	s1.append("hello world", 6);
  20. 	// 尾加n个c字符   
  21. 	// string& append (size_t n, char c);
  22. 	s1.append(5, 'x');
  23. 	// 迭代器区间追加
  24. 	// template <class InputIterator>
  25. 	// string& append(InputIterator first, InputIterator last);
  26.     s1.append(tmp.begin(), tmp.end());
  27. 	cout << s1 << endl;
  28.     return 0;
  29. }

 assign为string的赋值函数；是一个扩增版的operator =，用的并不多，主要用法如下；

  1. int main()
  2. {
  3. 	string tmp("hello world");
  4. 	string s1;
  5. 	// 使用string类对其赋值
  6. 	// string& assign (const string& str);
  7. 	s1.assign(tmp);
  8. 	cout << s1 << endl;
  9. 	// 使用string类中从subpos位置开始的sublen个串来赋值
  10. 	// string& assign (const string& str, size_t subpos, size_t sublen);
  11. 	s1.assign(tmp, 2, 5);
  12. 	cout << s1 << endl;
  13. 	// 使用字符指针所指向的字符串对其赋值
  14. 	// string& assign (const char* s);
  15. 	s1.assign("hello naiths");
  16. 	cout << s1 << endl;
  17. 	// 使用字符指针所指向的字符串的前n个对其赋值
  18. 	// string& assign (const char* s, size_t n);
  19. 	s1.assign("hello naiths", 7);
  20. 	cout << s1 << endl;
  21. 	// 使用n个c字符对其赋值
  22. 	// string& assign (size_t n, char c);
  23. 	s1.assign(10, 'x');
  24. 	cout << s1 << endl;
  25. 	// 使用迭代器对其赋值
  26. 	// template <class InputIterator>
  27. 	// string& assign(InputIterator first, InputIterator last);
  28.     s1.assign(tmp.begin(), tmp.end());
  29.     cout << s1 << endl;
  30.     return 0;
  31. }

  1. int main()
  2. {
  3. 	string tmp("hello world");
  4. 	string s1;
  5. 	// 在pos位置插入string类字符串
  6. 	// string& insert (size_t pos, const string& str);
  7. 	s1.insert(0, tmp);
  8. 	cout << s1 << endl;
  9. 	// 在pos位置插入str的子串（subpos位置开始的sublen个字符）
  10. 	// string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);
  11. 	s1.insert(7, tmp, 0, 6);
  12. 	cout << s1 << endl;
  13. 	// 在pos位置插入字符指针指向的字符串
  14. 	// string& insert (size_t pos, constchar* s);
  15. 	s1.insert(2, "xxx");
  16. 	cout << s1 << endl;
  17. 	// 在pos位置插入字符指针指向的字符串的前n个字符
  18. 	// string& insert (size_t pos, const char* s, size_t n);
  19. 	s1.insert(7, "hello naiths", 8);
  20. 	cout << s1 << endl;
  21. 	// 在pos位置插入n个c字符
  22. 	// string& insert (size_t pos, size_t n, char c);
  23. 	s1.insert(0, 5, 'y');
  24. 	cout << s1 << endl;
  25. 	// 指定迭代器的位置插入n个字符c
  26. 	// void insert (iterator p, size_t n, char c);
  27. 	string::iterator it = s1.begin() + 10;
  28. 	s1.insert(it, 10, 'z');
  29. 	cout << s1 << endl;
  30. 	// 指定迭代器的位置插入字符c
  31. 	// iterator insert (iterator p, char c);
  32. 	s1.insert(s1.begin(), 'A');
  33. 	cout << s1 << endl;
  34. 	// 指定p位置插入迭代器区间的字符
  35. 	// template <class InputIterator>
  36. 	// void insert(iterator p, InputIterator first, InputIterator last);
  37. 	s1.insert(s1.begin(), tmp.begin() + 3, tmp.begin() + 8);
  38. 	cout << s1 << endl;
  39. 	// 删除pos位置开始的len个字符
  40. 	// string& erase (size_t pos = 0, size_t len = npos);
  41. 	s1.erase(2, 5);
  42. 	cout << s1 << endl;
  43. 	// 删除迭代器位置的那个字符
  44. 	// iterator erase (iterator p);
  45. 	s1.erase(s1.begin());
  46. 	cout << s1 << endl;
  47. 	// 删除迭代器区间的字符
  48. 	// iterator erase (iterator first, iterator last);
  49. 	s1.erase(s1.begin() + 2, s1.begin() + 5);
  50. 	cout << s1 << endl;
  51.     return 0;
  52. }

三、string底层实现

其实对于上面的这些库里面的函数，我们不需要全去记住，记住一些常用的即可，其他的等到我们要用到的时候去cplusplus网站里面找即可，对于下面我们要自己实现的函数，一定要记住，这些函数用的都是比较多的。

  1. #pragma once
  2. #define _CRT_SECURE_NO_WARNINGS
  3.  
  4. #include<iostream>
  5. #include<assert.h>
  6. using namespace std;
  7.  
  8.  
  9. namespace bit
  10. {
  11. 	class string
  12. 	{
  13. 	public:
  14. 		//string();//不传参的情况
  15. 		string(const string& s);
  16. 		string(const char* str = "");//这里可以之际全缺省
  17. 		~string();
  18. 		const char* c_str() const;
  19.  
  20. 		size_t size() const;
  21. 		char& operator[](size_t pos);
  22. 		const char& operator[](size_t pos) const;
  23. 		string& operator=(const string& s);
  24. 		//实现一个迭代器
  25. 		typedef char* iterator;
  26. 		iterator begin();
  27. 		iterator end();
  28.  
  29. 		typedef const char* const_iterator;
  30. 		const_iterator begin() const;
  31. 		const_iterator end() const;
  32.  
  33.  
  34.  
  35. 		void reserve(size_t n);
  36.  
  37. 		void push_back(char ch);
  38. 		void append(const char* str);
  39.  
  40. 		string& operator+=(char ch);
  41. 		string& operator+=(const char* str);
  42.  
  43.  
  44. 		void insert(size_t pos, char ch);
  45. 		void insert(size_t pos, const char* str);
  46. 		void erase(size_t pos, size_t len=npos);
  47. 		size_t find(char ch, size_t pso = 0);
  48. 	    size_t find(const char* str, size_t pos = 0);
  49. 		void swap(string& s);
  50. 		string substr(size_t pos,size_t len);
  51. 		void clear();
  52. 	private:
  53. 		char* _str;
  54. 		size_t _size;
  55. 		size_t _capacity;
  56.  
  57.  
  58. 		const static size_t npos;
  59. 	};
  60. 	
  61.  
  62. 	istream& operator>>(istream& is, string& str);
  63. 	ostream& operator<<(ostream& os, const string& str);
  64.  
  65. }
  66.  
  67.

上面这些就是我们要实现的一些函数的底层是什么样的，当然，我只是基于自己的理解去写这些，比起C++库里面的肯定要low一点，所以我们理解基础的一些思路即可。

下面我们来看一下这些代码，大家看一下，想要更好的理解可以自己去实现一遍。

  1. #include"string.h"
  2.  
  3.  
  4.  
  5.  
  6. namespace bit
  7. {
  8. 	//深拷贝
  9. 	string::string(const string& s)
  10. 	{
  11. 		_str = new char[s._capacity + 1];
  12. 		strcpy(_str, s._str);
  13. 		_size = s._size;
  14. 		_capacity = s._capacity;
  15. 	}
  16. 	 const size_t string::npos = -1;
  17. 	//不传参的析构
  18. 	//string::string()
  19. 	/*{
  20. 		_str = new char[1] {'\0'};
  21. 		_size = 0;
  22. 		_capacity = 0;
  23. 	}*/
  24.  
  25. 	//构造函数
  26. 	string::string(const char* str)
  27. 		//strlen是运行时计算长度，效率比较低，三个strlen重复计算了
  28. 		//但是如果像下面这样写，还是会出现一些问题，因为初始化列表的初始化是按声明的顺序初始化，这里就会出现问题
  29. 		/*:_str(new char[strlen(str) + 1])
  30. 		,_size(strlen(str))
  31. 		,_capacity(strlen(str))*/
  32. 		: _size(strlen(str))
  33. 		
  34. 	{
  35. 		_capacity = _size;
  36. 		_str = new char[_size + 1];
  37. 		strcpy(_str, str);
  38. 	}
  39.  
  40. 	//赋值
  41. 	string& string::operator=(const string& s)
  42. 	{
  43. 		//避免自己给自己赋值
  44. 		if (this != &s)
  45. 		{
  46. 			char* tmp = new char[s._capacity + 1];
  47. 			strcpy(tmp, s._str);
  48. 			//这样写是为了避免前面的空间大小小于后面的那个
  49. 			delete[] _str;
  50. 			_str = tmp;
  51. 			
  52. 		}
  53. 		return *this;
  54. 	}
  55.  
  56. 	//析构
  57. 	string::~string()
  58. 	{
  59. 		delete[] _str;
  60. 		_size = 0;
  61. 		_capacity = 0;
  62. 	}
  63.  
  64. 	//打印
  65. 	const char* string::c_str() const//像这种用于打印的函数，可以在后面加上一个const，
  66. 		                             //加上const意味着不能修改指向的内容和本事的值，这样即使放生权限的缩小依然不会报错
  67. 	{
  68. 		return _str;
  69. 	}
  70.  
  71.  
  72. 	size_t string::size() const
  73. 	{
  74. 		return _size;
  75. 	}
  76.  
  77. 	char& string::operator[](size_t pos)//可读可写
  78. 	{
  79. 		assert(pos < _size);
  80. 		return _str[pos];
  81. 	}
  82.  
  83. 	const char& string::operator[](size_t pos) const
  84. 	{
  85. 		assert(pos < _size);
  86. 		return _str[pos];
  87. 	}
  88.  
  89.  
  90. 	//迭代器
  91. 	string::iterator string::begin()
  92. 	{
  93. 		return _str;
  94. 	}
  95. 	string::iterator string::end()
  96. 	{
  97. 		return _str + _size;
  98. 	}
  99.  
  100. 	//无法修改的迭代
  101. 	string::const_iterator string::begin() const
  102. 	{
  103. 		return _str;
  104. 	}
  105. 	string::const_iterator string::end() const
  106. 	{
  107. 		return _str + _size;
  108. 	}
  109.  
  110.  
  111. 	void string::reserve(size_t n)
  112. 	{
  113. 		if (n > _capacity)
  114. 		{
  115. 			char* tmp = new char[n + 1];
  116. 			strcpy(tmp, _str);
  117. 			delete[]_str;
  118.  
  119. 			_str = tmp;
  120. 			_capacity = n;
  121. 		}
  122. 		
  123. 	}
  124.  
  125. 	void string::push_back(char ch)
  126. 	{
  127. 		if (_size == _capacity)
  128. 		{
  129. 			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
  130. 			reserve(newcapacity);
  131. 		}
  132. 		_str[_size] = ch;
  133. 		_str[++_size] = '\0';
  134. 	}
  135.  
  136. 	void string::append(const char* str)
  137. 	{
  138. 		size_t len = strlen(str);
  139. 		if (_size + len > _capacity)
  140. 		{
  141.             reserve(_size + len);
  142. 		}
  143. 		strcpy(_str + _size, str);
  144. 		_size += len;
  145. 	}
  146. 	
  147.  
  148. 	string& string::operator+=(char ch)
  149. 	{
  150. 		push_back(ch);
  151.  
  152. 		return *this;
  153. 	}
  154.  
  155. 	string& string::operator+=(const char* str)
  156. 	{
  157. 		append(str);
  158.  
  159. 		return *this;
  160. 	}
  161.  
  162. 	void string::insert(size_t pos, const char* str)
  163. 	{
  164. 		assert(pos <= _size);
  165.  
  166. 		size_t len = strlen(str);
  167. 		if (_size + len >= _capacity)
  168. 		{
  169. 			reserve(_size + len);
  170. 		}
  171. 		int end = _size;
  172. 		while (end >= pos)
  173. 		{
  174. 			_str[end+len] = _str[end];
  175. 			--end;
  176. 		}
  177.  
  178. 		memcpy(_str + pos, str, len);
  179. 		_size += len;
  180. 		
  181. 	}
  182.  
  183. 	void string::insert(size_t pos,char ch)
  184. 	{
  185. 		if (_size == _capacity)
  186. 		{
  187. 			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
  188. 			reserve(newcapacity);
  189. 		}
  190. 		
  191. 		size_t end = _size;
  192. 		while (end >= pos)
  193. 		{
  194. 			_str[end + 1] = _str[end];
  195. 			--end;
  196. 		}
  197. 		_str[pos] = ch;
  198.  
  199. 	}
  200.  
  201. 	void string::erase(size_t pos, size_t len)
  202. 	{
  203. 		assert(pos <= _size);
  204.  
  205. 		//当len大于前面的个数
  206. 		if (len>=_size-pos)
  207. 		{
  208. 			_str[pos] = '\0';
  209. 			_size = pos;
  210. 		}
  211. 		else
  212. 		{
  213. 			strcpy(_str + pos, _str + pos + len);
  214. 			_size -= len;
  215. 		}
  216. 	}
  217.  
  218. 	size_t string::find(char ch, size_t pos)
  219. 	{
  220. 		
  221. 		while (pos!=_size)
  222. 		{
  223. 			if (ch == _str[pos])
  224. 			{
  225. 				return pos;
  226. 			}
  227. 			++pos;
  228. 		}
  229. 		return npos;
  230. 	}
  231.  
  232.     size_t string::find(const char* str, size_t pos)
  233. 	{
  234. 		char* p = strstr(_str + pos, str);
  235. 		return p - _str;
  236. 	}
  237.  
  238.  
  239. 	void string::swap(string& s)
  240. 	{
  241. 		std::swap(_str, s._str);
  242. 		std::swap(_capacity, s._capacity);
  243. 		std::swap(_size, s._size);
  244. 	}
  245.  
  246. 	string string::substr(size_t pos, size_t len)
  247. 	{
  248. 		//len大于后面的剩余字符，有多少取多少
  249. 		if (len > _size - pos)
  250. 		{
  251. 			string sub(_str - pos);
  252. 			return sub;
  253. 		}
  254. 		else
  255. 		{
  256. 			string sub;
  257. 			sub.reserve(len);
  258. 			for (size_t i = 0; i < len; i++)
  259. 			{
  260. 				sub += _str[pos + i];
  261.  
  262. 			}
  263. 			return sub;
  264. 		}
  265. 	}
  266.  
  267. 	void string::clear()
  268. 	{
  269. 		_str[0] = '\0';
  270. 		_size = 0;
  271. 	}
  272.  
  273. 	istream& operator>>(istream& is, string& str)
  274. 	{
  275. 		char ch;
  276. 		is >> ch;
  277. 		while (ch != ' ' && ch != '\n')
  278. 		{
  279. 			str += ch;
  280. 			is >> ch;
  281. 		}
  282.  
  283. 		return is;
  284. 	}
  285.  
  286. 	ostream& operator<<(ostream& os, const string& str)
  287. 	{
  288. 		for (size_t i = 0; i < str.size(); i++)
  289. 		{
  290. 			os << str[i];
  291. 		}
  292.  
  293. 		return os;
  294. 	}
  295. 	
  296. }
  297.

最后：

十分感谢你可以耐着性子把它读完和我可以坚持写到这里，送几句话，对你，也对我：

1.一个冷知识：
屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。

2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。
正所谓：君子可内敛不可懦弱，面不公可起而论之。

3.成年人的世界，只筛选，不教育。

4.自律不是6点起床，7点准时学习，而是不管别人怎么说怎么看，你也会坚持去做，绝不打乱自己的节奏，是一种自我的恒心。

5.你开始炫耀自己，往往都是灾难的开始，就像老子在《道德经》里写到：光而不耀，静水流深。

最后如果觉得我写的还不错，请不要忘记点赞✌，收藏✌，加关注✌哦(｡･ω･｡)

愿我们一起加油，奔向更美好的未来，愿我们从懵懵懂懂的一枚菜鸟逐渐成为大佬。加油，为自己点赞！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/794497
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号