字符串
字符串，本质上是一个接一个字符的一组字符。字母、数字、符号等。
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();
