当前位置：首页 > article >正文

C++字符串相关内容

article 2025/2/10 23:48:17

字符串

字符串，本质上是一个接一个字符的一组字符。字母、数字、符号等。

const char* 字符串名

字符后面会有一个空终止符，为0。

字符串从指针的内存地址开始，然后继续下去，直到它碰到0，然后意识到字符串终止了。

#include <iostream>
int main()
{
	const char* name = "Miles";  //使用const之后，就不能再改变该字符串的内容。
	//name[2] = "a";
	char name2[5] = {'M','i','l','e','s'};
	std::cout << name << std::endl;
	std::cout << name2 << std::endl;
	std::cin.get();
}

为了使得代码更加简洁，通常会引入string。

string中有一个构造函数，它接收char*或const char*参数。

#include <iostream>
#include <string>
int main()
{
	std::string name1 = "Miles";
	std::cout << name1 << std::endl;
	std::cin.get();
}

std::string 是一个有很多功能的类。

name.size()可以找到其尺寸；strlen()，字符串的长度；strcpy，复制字符串；

字符串相加，可以考虑重载运算符：“+=”。

#include <iostream>
#include <string>
int main()
{
	std::string name1 = "Miles";
	name1 += " hello!";
	std::cout << name1 << std::endl;
	std::cin.get();
}
//输出：
//Miles hello!

字符串相加，或者可以用另一种方法进行：将两个相加的字符数组的其中一个，显式调用一个string构造函数。相当于创建了一个字符串，然后附加这个字符串给另一个。

#include <iostream>
#include <string>
int main()
{
	std::string name1 = std::string("Miles")+ " hello!";
	std::cout << name1 << std::endl;
	std::cin.get();
}
//输出：
//Miles hello!

如果要寻找字符串中的文本，可以使用name.find()。

#include <iostream>
#include <string>
int main()
{
	std::string name1 = std::string("Miles")+ " hello!";
	bool contains = name1.find("es") != std::string::npos;  
	std::cout << name1 << std::endl;
	std::cin.get();
}

其中，std::string::npos代表一个不存在的位置。将结果给contains。

#include <iostream>
#include <string>
void PrintString(std::string string)
{
	string += "h";
	std::cout << string << std::endl;
}
int main()
{
	std::string name1 = std::string("Miles")+ " hello!";
	PrintString(name1);
	bool contains = name1.find("es") != std::string::npos;  
	std::cout << name1 << std::endl;
	std::cin.get();
}
//输出：
//Miles hello!h
//Miles hello!

需要分配一个全新的char数组，来存储我们已经得到的完全相同的文本。

字符串复制，实际上相当慢。

当我们需要传递一个字符串，而且在只读的情况下，需要确保通过常量引用传递它。此时通常在前面加上const和引用&。

void PrintString(const std::string& string)
{
	//string += "h";
	std::cout << string << std::endl;
}

字符串字面量

字符串字面量，是在双引号之间的一串字符。

字符串后面有一个额外的字符，叫做：空终止字符。

#include <iostream>
#include <string>

#include <stdlib.h>
int main()
{
	const char name[7] = "Mi\0les";
	std::cout << strlen(name) << std::endl; //打印出字符串的长度。
	std::cin.get();
}

字符串的相加，还能用到string_literals库。在字符串后面加上s，即可实现字符串的相加。

#include <iostream>
#include <string>
#include <stdlib.h>
int main()
{
	using namespace std::string_literals;
	std::string name = "Miles"s + " hello!";
	std::cout << name << std::endl; 
	std::cin.get();
}
//输出：
//Miles hello!

其中，s实际上是一个函数。操作符函数，它返回标准字符串（对象）。

R可以用来忽略转义字符。使得代码更加简洁。

#include <iostream>
#include <string>

#include <stdlib.h>
int main()
{
	const char* example = R"(Line1
line2
line3)"  ;//R忽略转义字符
	const char* ex = "Line1\n"
		"line2\n"
		"line3\n";
	std::cout << example << std::endl;
	std::cout << ex << std::endl;
	std::cin.get();
}

字符串字面量永远保存在内存的只读区域，

关键字const

关键字

const，称为伪关键字。因为它在改变生成代码方面做不了什么。有点像类和结构体的可见性。

#include<iostream>
#include<string>
int main()
{
	const int MAX_AGE = 90;
	std::cin.get();
}

在堆上建立一个整数，就能得到一个指针。此时有两个方案：

逆向引用dereference
重新分配实际的指针，这样会指向别的东西

用const强制定义一个变量为只读常量。但可以强制改变这个定义，如下，利用(int*)可以将const只读常量的值，逆向引用传给另一个变量。

#include<iostream>
#include<string>
int main()
{
	const int MAX_AGE = 90;
	int* a = new int;
	*a = 2;
	a = (int*)&MAX_AGE;
	std::cout << *a << std::endl;
	std::cin.get();
}
//输出：
//90

但，const int* 意味着，不能修改指针指向的内容。该用法和int const*一致。

const int* a = new int;
int const* a = new int;

int* const可以改变指针指向的内容，但不能把实际的指针本身重新赋值，指向别的东西。

#include<iostream>
#include<string>
class Entity
{
private:
	int m_X, m_Y;
public:
	int GetX() const //此用法，只能读，不能写。该方法只能进行读操作，不能进行其他的修改操作。
	{
		return m_X;
	}
	void SetX(int x)
	{
		m_X = x;
	}
};
int main()
{
	const int MAX_AGE = 90;
	int* a = new int;
	*a = 2;
	a = (int*)&MAX_AGE;
	std::cout << *a << std::endl;
	std::cin.get();
}

如果用再次复制Entity类的方式，需要分配空间，那样会很慢。可以通过常量引用传递的方式。也就是：const Entity& e

#include<iostream>
#include<string>
class Entity
{
private:
	int m_X, m_Y;
public:
	int GetX() const
	{
		return m_X;
	}
	void SetX(int x)
	{
		m_X = x;
	}
};
void PrintEntity(const Entity& e)
{
	std::cout << e.GetX() << std::endl; //由于GetX()用到了const，才能在这里用到e.GetX()
}
int main()
{
	const int MAX_AGE = 90;
	int* a = new int;
	*a = 2;
	a = (int*)&MAX_AGE;
	std::cout << *a << std::endl;
	std::cin.get();
}

如果要对int GetX() const中的变量进行修改的话，可以引入mutable：

#include<iostream>
#include<string>
class Entity
{
private:
	int m_X, m_Y;
	mutable int var;
public:
	int GetX() const
	{
		var = 2;
		return m_X;
	}
	void SetX(int x)
	{
		m_X = x;
	}
};

mutable允许函数是常量的方法，可以修改变量。

关键字mutable

mutable的两种不同用途：

与const一同使用。
用在lambda表达式中。

或者mutable可以同时覆盖两种情况。

#include <iostream>
#include <string>
class Entity
{
private:
	std::string m_Name;
	mutable int m_DebugCount;
public:
	const std::string& GetName() const
	{
		m_DebugCount++;  //每次调用get的时候，都会记一次数
		return m_Name;
	}
};
int main()
{
	const Entity e;
	e.GetName();

	std::cin.get();
}

在类成员中使用mutable。

lambda基本上像一个一次性的小函数，可以写出来并赋值给一个变量。

#include <iostream>
#include <string>

class Entity
{
private:
	std::string m_Name;
	mutable int m_DebugCount;
public:
	const std::string& GetName() const
	{
		m_DebugCount++;  
		return m_Name;
	}
};
int main()
{
	const Entity e;
	e.GetName();
//lambda的使用如下：
	int x = 8;
	auto f = [&]()
	{
		x++;
		std::cout << x << std::endl;
	};
	f();
	std::cin.get();
}

lambda还有其他的用法，三种auto用法一致。

int x = 8;
auto f = [&]()
{
	x++;
	std::cout << x << std::endl;
};
auto f = [=]() mutable
{
	x++;
	std::cout << x << std::endl;
};
auto f = [=]()
{
	int y = x;
	y++;
	std::cout << x << std::endl;
};
f();

查看全文

http://www.kler.cn/a/539902.html