【1++的C++初阶】之string

news2024/11/17 3:31:40

👍作者主页：进击的1++
🤩 专栏链接：【1++的C++初阶】

文章目录

  • 一，浅谈string类
  • 二，string 类常用接口
    • 2.1 string的构造
    • 2.2 string类对象的容量操作
    • 2.3 string类对象的访问及遍历操作
    • 2.4 string类对象的修改操作
    • 2.5 getline函数
  • 三，string 类的结构与大小
  • 四，string类的实现
    • 4.1 深拷贝
    • 4.2 写时拷贝
    • 4.3 string类实现代码

一，浅谈string类

在C语言中，字符串是以‘\0’结尾的一些字符的集合，并且在C的标准库里有专门一些库函数用来操作字符串，这些库函数与字符串是分离开的，不符合“面向对象”的思想，因此，我们在前面学习过类与对象，我们可以将这些字符串的操作函数以及保存字符串的变量，封装成类，类实例化成对象后，数据与方法也就不会分开，这样就极大的方便了我们的操作，而且在操作时还不容易出错。因此在C++中就有了string类。
还需要注意的是：

  1. string在底层实际是：basic_string模板类的别名，
    typedef basic_string<char, char_traits, allocator> string;
  2. 不能操作多字节或者变长字符的序列。
  3. 要包含头文件。

二，string 类常用接口

2.1 string的构造

在这里插入图片描述

void Test2()
{
	string s1;//空构造
	const char* str = "jhstdg";
	string s2("hellow world");//C语言字符串构造
	string s3(str);//字符串构造
	string s4(s3);//拷贝构造
	//cout << s4 << endl;
	string s5(s3, 0,10);//子串构造，当要拷贝的的长度超过子串的长度时，
	//拷贝到子串最后一个字符就会结束
	//cout << s5 << endl;
	string s6(str, 1);//序列构造，从str中拷贝1个字符作为参数构造s6。
	//cout << s6 << endl;
	string s7(7, 'x');//用7个字符x填充字符串。
	cout << s7 << endl;
}

2.2 string类对象的容量操作

在这里插入图片描述

void Test3()
{
	string s("hellow world");
	string s1;
	cout << s.size() << endl;//返回字符串的有效长度
	cout << s.length()<< endl;//与size的作用相同
	cout << s.capacity() << endl;//返回空间总大小，与动态顺序表中的容量功能类似
	cout << s1.empty() << endl;//检测字符串是否为空串，是则返回1，不是返回0
	//s.clear();//清空有效字符
	cout << s.empty() << endl;
	s.reserve(10);//为字符串预留空间
	cout << s.capacity() << endl;
	s.resize(17,'l');//将字符串的有效个数改为17，多出的空间用字符l填充。
	cout << s << endl;
}

需要注意的是：

  1. clear是清空有效字符，但是底层空间大小并不会改变
  2. resreve（n) 是预留空间，当n小于底层空间大小是，预留的空间大小不一定会变。
  3. resize是将字符串中的有效字符个数改为n，其中resize(n)与resize(n,s)的区别是，前者将多出的空间用0填充，后者用s填充，并且，元素减少，底层空间不一定会减少。

2.3 string类对象的访问及遍历操作

在这里插入图片描述

void Test1()
{
	string s1("hellow world");
	string s2 = "hellow world";
	//cout << s1[3] << endl;
	//cout << s1.operator [](3) << endl;
	s2[2] = '\0';
	if (s2[s2.size()] == '\0')
	{
		cout << "YES" << endl;//运行结果为YES，证明，C++中字符串的结尾确实是'\0'，
		//但是，并不是以'\0’作为结束标志。
	}
	else
	{
		cout << "NO" << endl;
	}
	//cout << s2 << endl;
	//string::iterator it = s1.begin();//获取第一个字符
	//while (it != s1.end())   //end()为最后一个字符的下一个位置
	//{
	//	cout << *it;
	//	it++;
	//}
	//cout << endl;
	/*string::reverse_iterator rit = s1.rbegin();
	while (rit != s1.rend())
	{
	    cout << *rit ;	
		++rit;
	}*/
	//reverse(s1.rbegin(),s1.rend());//逆置函数
	//string::reverse_iterator rit = s1.rbegin();//获取最后一个字符
	//while (rit != s1.rend())//第一个字符的前一个位置
	//{
	//	cout << *rit;
	//	++rit;
	//}

	//范围for
	for (auto it : s1)//范围for实质工作原理就是迭代器
	{
		cout << it;
	}
}

总结：iterator提供一种统一的方式访问和修改容器的数据

2.4 string类对象的修改操作

string& insert(size_t pos,  char c)
		{
			assert(pos <= _size);
			//扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			
			int begin = pos;
			int end = _size;
			while (end >= begin)
			{
				_str[end + 1] = _str[end];
				end--;
			}
			_str[end+1] = c;
			_size++;
			return *this;
			
		}
		
		//

		string& insert(size_t pos, const char* s)
		{
			assert(pos <= _size);
			size_t len = strlen(s);
			//扩容
			if (_size+len > _capacity)
			{
				reserve(_size+len);
			}
			int begin = pos;
			int end = _size + len;
			int i = _size ;
			while (end >= begin + len)
			{
				_str[end--] = _str[i--];
			}
			size_t j = 0;
			while (j<len)
			{
				_str[++i] = s[j++];
			}
			_size += len;
			return *this;
			
	}
				
//
		string& erase(size_t pos, size_t len=npos)
		{
			assert(pos < _size);
			if (pos+len>=_size || len == npos)
			{
				_str[pos] = '\0';
				_size = pos;
				
			}
			else
			{
				int end = _size;
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			
			return *this;
		}
		
//
		size_t find(char c, size_t pos=0)
		{
			assert(pos <= _size);
			while (pos < _size)
			{
				if (_str[pos] == c)
					return pos;
				pos++;
			}
			return npos;
		}
		
//
		size_t find( const char* sub, size_t pos=0)const
		{
			assert(sub);
			assert(pos < _size);
			char* _pos = std::strstr(_str, sub);
			if (_pos == nullptr)
				return npos;
			else
				return _pos - _str;
		}
		
//
		string& push_back(char c)
		{
			insert(_size, c);
			return *this;
		}
		
//
		string& append(const char* s)
		{
			insert(_size, s);
			return *this;
		}


//
		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}

		string& operator+=(const char* s)
		{
			append(s);
			return *this;
		}

//

		string substr(size_t pos, size_t len = npos)const
		{
			assert(pos < _size);
			string tmp;
			size_t reallen = len;
			if (len == npos || pos + len > _size)
			{
				reallen = _size - pos;
			}
			for (size_t i = pos; i < pos + reallen; i++)
			{
				tmp += _str[i];
			}
			return tmp;
		}
//
     string substr(size_t pos, size_t len = npos)const
		{
			assert(pos < _size);
			string tmp;
			size_t reallen = len;
			if (len == npos || pos + len > _size)
			{
				reallen = _size - pos;
			}
			for (size_t i = pos; i < pos + reallen; i++)
			{
				tmp += _str[i];
			}
			return tmp;
		}

//
 string operator+(const char* s)
		{
			string tmp(*this);
			tmp += s;
			return tmp;
		}

2.5 getline函数

void Test1()
{
	string s2;
	cin >> s2  ;
	cout << s2 << endl;
}

在这里插入图片描述
通过观察上述代码及其运行结果我们发现当用cin进行输入后，cin遇到空格就会将缓冲区中的变量刷入变量中，而空格后的字符仍留在缓冲区中，所以其分隔字符为 ’ ‘（空格） ，getline()函数可以自定义分隔字符，这就解决了某些输入上的问题。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

getline默认的分割符为‘\n’。

三，string 类的结构与大小

我们先说结论，string 总共占28字节。好多人可能会有疑问，为什么是28，而不是12。
在细说之前，我们不妨再次来谈谈什么是内存对齐。

先来说需要内存对齐的原因：
pu在处理我们的数据时，需要通过内存进行处理，而且cpu一次在内存中取到的内存大小是有限的，因此，如果没有内存对齐，某些变量的数据可能会被分开两次才能取完，因此就需要内存对齐，以空间换时间，来提高效率。
对齐规则：
第一个成员变量在结构体变量偏移量为0的地址处；
其他成员变量要对齐到某个对齐数（编译器默认对齐数与该成员变量大小中取较小值）；
结构体的总大小为最大对齐数的整数倍；
嵌套结构体对齐得到自己的最大对齐数的整数倍。

这是我们模拟实现的string类：
在这里插入图片描述
在我们自己实现的string类中，通过计算我们得出其结构体大小为12 。
但在STL中string的实现更为复杂，为了解决，频繁开辟空间消耗过多的问题，并且，大多数字符串长度也不会超过16，因此，在其成员变量中还有一个联合体，联合体中有一个16个字符数组的空间，用来存放长度小于16的字符串。有了这个数组后，当字符串长度小于16时就不需要在堆上开辟空间，效率就提高了。
联合体又叫共用体，其内部的变量共用一块空间，其大小为最大变量的大小。因此string的大小为16+4+4+4=28。

四，string类的实现

4.1 深拷贝

在类与对象篇中我们提到了浅拷贝，只是将对象的值拷贝过来，但是如果对象中设计到了对象管理，那么若仍用浅拷贝，就会发生，两个指针指向同一块空间的情况，当调用析构时就会发生同一块空间被释放两次的情况，因此就有了深拷贝。

深拷贝：给每个对小尼姑独立分配资源，来保证其不会被多次释放。
代码如下：

拷贝构造
		传统写法
		string(const string& s)
		{
			_size = s._size;
			_capacity = s._capacity;
			_str = new char[s._size + 1];
			strcpy(_str, s._str);
		}

		//s1=s2
		string& operator =(const string& s)
		{
			if (this != &s)
			{
				delete[] _str;
				_size = s._size;
				_capacity = s._capacity;
				_str = new char[s._size + 1];
				strcpy(_str, s._str);
			}
			return* this;
		}

		//现代写法
		void swap(string& tmp)
		{
			std::swap(_str, tmp._str);
			std::swap(_size, tmp._size);
			std::swap(_capacity, tmp._capacity);
		}
		string(const string& s)
			: _str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			string tmp(s._str);
			swap(tmp);
		}

		string& operator=(string s)
		{
			swap(s);
			return* this;//返回值是为了连续赋值
		}

4.2 写时拷贝

写时拷贝就是类似与一种拖延症，采用引用计数，用来记录共同使用这块空间的对象的个数，只有堆某个对象进行修改时，才会进行拷贝构造，为这个对象开辟一块空间，并且在销毁时也会进行计数的判断，直到剩下最后一个使用者时才进行释放。

4.3 string类实现代码

namespace hyp
{
	class string
	{
	public:
		string(const char* str="")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_size + 1];
			strcpy(_str, str);
		}

		const char* c_str()const
		{
			return this->_str;
		}

		//拷贝构造
		//传统写法
		//string(const string& s)
		//{
		//	_size = s._size;
		//	_capacity = s._capacity;
		//	_str = new char[s._size + 1];
		//	strcpy(_str, s._str);
		//}

		//s1=s2
	/*	string& operator =(const string& s)
		{
			if (this != &s)
			{
				delete[] _str;
				_size = s._size;
				_capacity = s._capacity;
				_str = new char[s._size + 1];
				strcpy(_str, s._str);
			}
			return* this;
		}*/

		//现代写法
		void swap(string& tmp)
		{
			std::swap(_str, tmp._str);
			std::swap(_size, tmp._size);
			std::swap(_capacity, tmp._capacity);
		}
		string(const string& s)
			: _str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			string tmp(s._str);
			swap(tmp);
		}

		string& operator=(string s)
		{
			swap(s);
			return* this;//返回值是为了连续赋值
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}

		char& operator [](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
			
		}

		const char& operator [](size_t pos)const
		{
			assert(pos < _size);
			return _str[pos];
		}

		size_t size()const
		{
			return _size;
		}

		size_t  capacity()const
		{
			return _capacity;
		}

		void resize(size_t n, char c = '\0')
		{
			if (n < _size)
			{
				_str[n] = '\0';
				_size = n;
			}
			else
			{
				reserve(n);
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = c;
				}
				_str[n] = '\0';
				_size = n;
			}
		}

		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}


		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		string& insert(size_t pos,  char c)
		{
			assert(pos <= _size);
			//扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			
			int begin = pos;
			int end = _size;
			while (end >= begin)
			{
				_str[end + 1] = _str[end];
				end--;
			}
			_str[end+1] = c;
			_size++;
			return *this;
			
		}

		string& insert(size_t pos, const char* s)
		{
			assert(pos <= _size);
			size_t len = strlen(s);
			//扩容
			if (_size+len > _capacity)
			{
				reserve(_size+len);
			}
			int begin = pos;
			int end = _size + len;
			int i = _size ;
			while (end >= begin + len)
			{
				_str[end--] = _str[i--];
			}
			size_t j = 0;
			while (j<len)
			{
				_str[++i] = s[j++];
			}
			_size += len;
			return *this;

		}

		string& erase(size_t pos, size_t len=npos)
		{
			assert(pos < _size);
			if (pos+len>=_size || len == npos)
			{
				_str[pos] = '\0';
				_size = pos;
				
			}
			else
			{
				int end = _size;
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			
			return *this;
		}

		size_t find(char c, size_t pos=0)
		{
			assert(pos <= _size);
			while (pos < _size)
			{
				if (_str[pos] == c)
					return pos;
				pos++;
			}
			return npos;
		}

		size_t find( const char* sub, size_t pos=0)const
		{
			assert(sub);
			assert(pos < _size);
			char* _pos = std::strstr(_str, sub);
			if (_pos == nullptr)
				return npos;
			else
				return _pos - _str;
		}

		string& push_back(char c)
		{
			insert(_size, c);
			return *this;
		}

		string& append(const char* s)
		{
			insert(_size, s);
			return *this;
		}



		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}

		string& operator+=(const char* s)
		{
			append(s);
			return *this;
		}

		string substr(size_t pos, size_t len = npos)const
		{
			assert(pos < _size);
			string tmp;
			size_t reallen = len;
			if (len == npos || pos + len > _size)
			{
				reallen = _size - pos;
			}
			for (size_t i = pos; i < pos + reallen; i++)
			{
				tmp += _str[i];
			}
			return tmp;
		}

		bool operator>(const string& s)const
		{
			int  ret = strcmp(_str,s._str);
			if (ret > 0)
			{
				return true;
			}
			return false;
		}

		bool operator==(const string& s)const
		{
			int ret = strcmp(_str, s._str);
			if (ret == 0)
				return true;
			else
				return false;
		}

		bool operator>=(const string& s)const
		{
			if (*this > s || *this == s)
				return true;
			else
				return false;
		}

		bool operator<(const string& s)const
		{
			if (*this >= s)
				return false;
			else
				return true;
		}

		bool operator<=(const string& s)const
		{
			if (*this < s || *this == s)
				return true;
			else
				return false;
		}

		bool operator!=(const string& s)const
		{
			if (*this == s)
				return false;
			else
				return true;
		}

		string operator+(const char* s)
		{
			string tmp(*this);
			tmp += s;
			return tmp;
		}


	private:
	    char* _str;
		size_t _size;
		size_t _capacity;
		public:
		const static size_t npos = -1;
	};

	ostream& operator <<(ostream& out, string& s)
	{
		for (int i = 0; i < (int)s.size(); i++)
		{
			out << s[i] ;
		}
		return out;

	}

	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		const size_t N = 32;
		char buff[N];
		char ch;
		ch = in.get();
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == N - 1)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		buff[i] = '\0';
		s += buff;
		return in;

	}
	
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/734585.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python 有趣的模块之pynupt——通过pynput控制鼠标和键盘

Python 有趣的模块之pynupt——通过pynput控制鼠标和键盘

Python 有趣的模块之pynupt ——通过pynput控制鼠标和键盘 文章目录 Python 有趣的模块之pynupt ——通过pynput控制鼠标和键盘1️⃣简介2️⃣鼠标控制与移动3️⃣键盘控制与输入4️⃣结语&#x1f4e2; 1️⃣简介 &#x1f680;&#x1f680;&#x1f680;学会控制鼠标和键盘是…
阅读更多...
Mongodb连接数据库

Mongodb连接数据库

1.初始化 npm init 2.安装mongoose npm i mongoose 3.导入mongoose const mongooserequire("mongoose") 4.连接mongodb服务 mongoose.connect("mongodb://127.0.0.1:27017/user") 说明&#xff1a;mongodb是协议,user是数据库&#xff0c;如果没有会自动创…
阅读更多...
经OPA运放后，读取电压出错

经OPA运放后，读取电压出错

问题&#xff1a; 在焊接完两块板子上传程序测试时&#xff0c;程序上传完成&#xff0c;有一块板子在使用OPA读取电压时&#xff0c;在未插入电阻情况下&#xff0c;电压读取是正确的&#xff0c;在插入50K电压后&#xff0c;电压值应该是之前的两倍&#xff0c;但是电压变化…
阅读更多...
unittest单元测试2

unittest单元测试2

目录 unittest框架解析 构建测试套件 用例的执行顺序 unittest断言 HTML报告生成 异常捕捉与错误截图 数据驱动 &#x1f381;更多干货 完整版文档下载方式&#xff1a; unittest框架解析 unittest 是python 的单元测试框架&#xff0c;unittest 单元测试提供了创建测…
阅读更多...
怎么把CAJ转换成PDF文件格式？分享这两个方法！

怎么把CAJ转换成PDF文件格式？分享这两个方法！

随着互联网的发展&#xff0c;中国知网(CNKI)已成为许多学术研究人员和学生们获取文献资料的重要来源。在CNKI上&#xff0c;常见的文件格式是CAJ&#xff08;China Academic Journals&#xff09;。然而&#xff0c;由于个人喜好或特定需求&#xff0c;我们有时会希望将这些CA…
阅读更多...
PDF文档转化为HTML网页格式怎么操作？分享这三个方法给大家！

PDF文档转化为HTML网页格式怎么操作？分享这三个方法给大家！

PDF文档作为一种常见的文档格式&#xff0c;广泛应用于各个领域。然而&#xff0c;如果您想将PDF文档直接发布到网站上&#xff0c;或是想在网页上进行展示&#xff0c;您可能需要将PDF转化为HTML格式。在此&#xff0c;我为大家介绍三种将PDF转化为HTML格式的方法。 方法一&am…
阅读更多...
mysql语句练习题，创建表create ，枚举中文字符集设置，修改（update）

mysql语句练习题，创建表create ，枚举中文字符集设置，修改（update）

作业&#xff1a; 1.创建表&#xff1a; 创建员工表employee&#xff0c;字段如下&#xff1a; id&#xff08;员工编号&#xff09;&#xff0c;name&#xff08;员工名字&#xff09;&#xff0c;gender&#xff08;员工性别&#xff09;&#xff0c;salary&#xff08;员工薪…
阅读更多...
d3dx9_43.dll丢失怎么解决（分享三个解决方法）

d3dx9_43.dll丢失怎么解决（分享三个解决方法）

d3dx9_43.dll是一个Microsoft DirectX的动态链接库文件&#xff0c;它包含了一系列用于图形、音频和输入的功能和接口。它是DirectX 9的一部分&#xff0c;用于提供游戏和其他图形应用程序所需的图形和声音效果。如果计算机中d3dx9_43.dll丢失&#xff0c;会造成很多游戏无法打…
阅读更多...
opencv图片根据规则改变颜色

opencv图片根据规则改变颜色

解析 1. 读入图片 2.通道分离 3.像素值在【100&#xff0c;200】之间&#xff0c;赋值128。大于200赋值255&#xff0c;小于100赋值0。 源码 import cv2 img_raw_path"past/unet-test_result0-0-1-0.png" img_rawcv2.imread(img_raw_path) (r,g,b)cv2.split(img_…
阅读更多...
运动控制介绍

运动控制介绍

运动控制介绍 1 介绍1.1 概述1.2 运动控制的基本架构1.3 常见的控制功能1.4 运动控制研究的问题分类位置变化问题周期式旋转速度变化问题 1.5 知识体系1.6 路径规划 和 轨迹规划区别与联系1.7 运动控制系统 2 《运动控制系统》[班华 李长友 主编] 摘要1 绪论1.1 运动控制研究的…
阅读更多...
信息系统项目管理师（第四版）教材精读思维导图-第二章信息技术发展

信息系统项目管理师（第四版）教材精读思维导图-第二章信息技术发展

请参阅我的另一篇文章&#xff0c;综合介绍软考高项&#xff1a; 信息系统项目管理师&#xff08;软考高项&#xff09;备考总结_计算机技术与软件专业技术_铭记北宸的博客-CSDN博客 思维导图源文件下载&#xff1a; https://download.csdn.net/download/hanjingjava/88023847 …
阅读更多...
SpringBoot 如何使用 EmbeddedDatabaseBuilder 进行数据库集成测试

SpringBoot 如何使用 EmbeddedDatabaseBuilder 进行数据库集成测试

SpringBoot 如何使用 EmbeddedDatabaseBuilder 进行数据库集成测试 在开发 SpringBoot 应用程序时&#xff0c;我们通常需要与数据库进行交互。为了确保我们的应用程序在生产环境中可以正常工作&#xff0c;我们需要进行数据库集成测试&#xff0c;以测试我们的应用程序是否能…
阅读更多...
非线性规划快速入门和练习题集

非线性规划快速入门和练习题集

目录 定义 标准形式 练习题1 练习题2 练习题3 定义 当目标函数或者约束条件中含有非1次项的时候,会出现非线性函数的规划。 标准形式 ​​​​​​​ ​​​​​​​ ​​​​​​​ ​​​​​​​ 其中f(x)是标准函数&#xff0c;A,b,Ae…
阅读更多...
MAYA滴状曲面（瞎弄）

MAYA滴状曲面（瞎弄）

阅读更多...
Basic——C++类型转换（转型操作符详解）

Basic——C++类型转换（转型操作符详解）

C转型操作符 1.C语言类型转换存在的隐患2.static_cast3.const_cast介绍测试案例 4.dynamic_cast5.reinterpret_cast 1.C语言类型转换存在的隐患 数据丢失&#xff1a;当将一个较大的数据类型转换为较小的数据类型时&#xff0c;可能会导致数据丢失。例如&#xff0c;将一个浮点…
阅读更多...
mac M1 安装nacos

mac M1 安装nacos

背景 m1不支持本地安装&#xff0c;只能用docker &#xff1a; “由于 rocksdb 暂不支持 M1 平台&#xff0c;所以使用 Zulu JDK 的小伙伴们运行 Nacos 2.x 版本会报错&#xff0c;网上通用的解决方案是使用 Oracle JDK 来运行 Nacos 2.x 版本&#xff0c;但对于强迫症的我来说…
阅读更多...
计算机网关原理、子网掩码原理（路由器、交换机）

计算机网关原理、子网掩码原理（路由器、交换机）

文章目录 网关网关的历史网关的功能网关的原理相关疑问为什么用子网掩码与IP地址进行与运算来确定一个IP地址所属的子网&#xff1f;网关地址是谁定的&#xff0c;是配置路由的人随意定的吗&#xff1f;&#xff08;配置人员定的&#xff09;如何正确设置网关地址&#xff08;路…
阅读更多...
java的断言

java的断言

断言介绍 Java的断言就是一条assert 声明&#xff0c;其中包含了一个布尔表达式。 断言可以被启用或者禁用&#xff0c;默认是禁用的。 断言被启用的情况下&#xff0c;执行到断言的声明&#xff0c;就会计算布尔表达式的值。如果表达式的值为false&#xff0c;那么就会抛出一…
阅读更多...
【Elasticsearch】安装elasticsearch

【Elasticsearch】安装elasticsearch

目录 安装elasticsearch 1.部署单点es 1.1.创建网络 1.2.加载镜像 1.3.运行 2.部署kibana 2.1.部署 2.2.DevTools 3.安装IK分词器 3.1.在线安装ik插件&#xff08;较慢&#xff09; 3.2.离线安装ik插件&#xff08;推荐&#xff09; 1&#xff09;查看数据卷目录 …
阅读更多...
十三、Docker Compose使用和主要功能

十三、Docker Compose使用和主要功能

学习参考&#xff1a;尚硅谷Docker实战教程、Docker官网、其他优秀博客(参考过的在文章最后列出) 目录 一、核心概念二、主要功能二、docker compose常用命令三、docker compose 案例3.1 自己写一个微服务模块3.2 用Dockerfile将上面的模块编排(不使用compose)3.3 使用compose编…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023