static修饰全局变量使变量成为静态全局变量。该变量存储在静态存储区，只能在本文件中使用，因此其他文件还可以定义名字相同的变量，不会发生冲突。
是指static修饰局部变量。作用域仍然是局部作用域，存放在内存的全局数据区，直至程序运行结束前都不会消失，但只在定义它的函数中可见，只初始化一次。未赋初值时会自动为0。
指static修饰函数时，该函数变为静态函数。只能在声明他的文件中可见，不能被其他文件使用。其它文件中可以定义相同名字的函数，不会发生冲突。
static修饰类的数据成员。特点：
指static修饰类的成员函数。
同静态数据成员一样，静态成员函数不属于任何一个对象，它为整个类服务，所有该类对象共享同一个函数。因此与普通的成员函数不同。由于普通的成员函数是属于类的某一个具体的对象，因此普通成员函数会有一个隐藏的this指针来操作该对象拥有的资源。但静态成员函数不属于任何一个对象，因此，静态成员函数没有this指针，也就不能访问属于类对象的任何的非静态成员函数和非静态数据成员。即：静态成员函数只能访问静态成员函数和静态数据成员。使用方法如下：
1、使用对象访问
2、使用类名访问。静态成员函数与静态数据成员一样，必须在类内声明，类外定义，并且定义时不能加static关键字。
使用静态成员函数的一个原因就是可以用它在建立任何对象之前处理静态数据成员这是普通成员函数不能实现的。
静态成员函数不能被申明为const，因为static成员不是任何对象的组成部分
静态成员函数不能被申明为虚函数
注意点：当使用类的成员函数作为仿函数时，如sort的第三个参数（排序时选择的算法），必须使用属于类而不是属于对象的静态成员函数。
class A {
public:
static bool cmp(int& a, int& b) {
return a > b;
}
void mySort(vector<int>& nums) {
sort(nums.begin(), nums.end(), cmp); //cmp函数的static不能省略
}
};
string& foo() {
string* ptr = new string("123");
return *ptr;
}
string temp = foo(); //new生成的这块内存无法释放
//上面这句话可以如下处理，但会麻烦
string& tmp = foo();
string str = tmp;
delete &tmp;
左值：既能够出现在等号左边，也能出现在等号右边的变量。即左值是可寻址的变量，有持久性，能被修改的变量
右值：只能出现在等号右边的变量。即右值一般是不可寻址的常量，或在表达式求值过程中创建的无名临时对象，短暂性的。右值无法被修改
左值引用：引用一个对象；
右值引用：就是必须绑定到右值的引用，C++11中右值引用可以实现“移动语义”，通过 && 获得右值引用。
右值引用的作用之一：移动语义（std::move），用来减少临时资源的开辟
class Person {
public:
//默认构造函数
Person() {
m_Age = 0;
m_Height = nullptr;
}
//拷贝构造函数
Person(const Person& p) {
m_Age = p.m_Age;
m_Height = new int(*p.m_Height); //深拷贝，防止浅拷贝
//cout << "拷贝构造函数申请的地址为：" << m_Height << endl;
cout << "调用了拷贝构造函数" << endl;
}
//移动构造函数
Person(Person&& p) noexcept {
m_Age = p.m_Age;
m_Height = p.m_Height;
p.m_Height = nullptr;
cout << "调用了移动构造函数" << endl;
}
//赋值运算符
Person& operator=(Person& p) {
m_Age = p.m_Age;
m_Height = new int(*p.m_Height);
//cout << "赋值运算符申请的地址为：" << m_Height << endl;
return *this;
}
//移动赋值运算符
Person& operator=(Person&& p) noexcept {
//先自我检测,释放自身资源
if (this != &p) {
delete m_Height;
}
m_Age = p.m_Age; //接管p的资源
m_Height = p.m_Height;
p.m_Height = nullptr; //将p的资源置空
}
//有参构造函数
Person(int age, int height) {
m_Age = age;
m_Height = new int(height);
//cout << "有参构造函数申请的地址为：" << m_Height << endl;
cout << "调用了有参构造函数" << endl;
}
//析构函数
~Person() {
if (m_Height != nullptr) {
delete m_Height;
m_Height = nullptr;
}
}
int m_Age;
int* m_Height;
};
int main(){
//传统的左值引用
int a = 10;
int& b = a; // 定义一个左值引用变量
b = 20; // 通过左值引用修改引用内存的值
//下面一行代码无法通过编译，因为等号右边的数无法取地址
int &var = 10;
//上面一行代码可以改成如下的常引用，理由上面已经说过
const int& var = 10;
//但改成常引用就无法修改var的值了，因此需要使用右值引用来解决问题
//下面这行代码就能编译通过
int&& var = 10;
//并且右值引用也能改变值
var = 1;
vector<Person> vec;
Person p1(20, 160);
vec.push_back(p1); //p1会在传入参数时调用赋值构造函数被拷贝一次，之后马上销毁
vec.push_back(std::move(p1)); //p1会被转换成右值，于是会调用移动构造函数，不会调用拷贝构造，
//提升效率
}
右值引用的作用之二：完美转发
完美转发，它指的是函数模板可以将自己的参数“完美”地转发给内部调用的其它函数。所谓完美，即不仅能准确地转发参数的值，还能保证被转发参数的左、右值属性不变。
看下面这段代码
template<typename T>
void f(T&& x){
cout << ++x;
}
f(2); // 3
函数f接受一个右值x，但是f(2)这条语句将2传入时，可以对2进行自增。这说明右值引用本身时左值，即x时左值。那么在传参时就会出现问题。看下面这段代码
template<typename T>
void g(T&& x) {
cout << "右值" << endl;
}
template<typename T>
void g(T& x) {
cout << "左值" << endl;
}
template<typename T>
void f(T&& x) {
cout << "f右值引用" << endl;
g(x);
}
template<typename T>
void f(T& x) {
cout << "f左值引用" << endl;
g(x);
}
结果如下：
一共有三个函数，f函数调用了g函数，g函数的作用是如果传入的参数是左值就输出左值，如果传入的参数是右值就输出右值。但是由于g函数的参数是通过f函数传入的（即x先通过外部的f函数传入，再由f函数传给g），经过第一次传参时x已经变为左值了（可以和第一个例子比对着看），所以g(x)永远只会输出左值（即永远只会和第二个函数模板匹配）,这明显与我们想要的结果不匹配。那么我们可以这么写：
template<typename T>
void f(T&& x) {
cout << "f右值引用" << endl;
g(std::forward<T>(x));
}
template<typename T>
void f(T& x) {
cout << "f左值引用" << endl;
g(std::forward<T>(x));
}
此时，输出的结果如下：
符合我们的预期。std::forward函数保持了 x 的引用类型。
那么再结合移动语义想象一下这样的一个例子：你需要通过函数传入的参数进行一个赋值（或者拷贝操作），但是如果不保持参数的性质，虽然你为了减小开销，外面传入的是一个右值，但是一进入函数就会变成左值。举个例子：
回到之前的移动语义的例子中来，之前的代码不变，我们增加一个函数
void fun(Person&& p) {
Person p2(p);
}
int main(int argc, char* argv[])
{
Person p1(20, 160);
fun(std::move(p1));
}
结果如下：
我们在主函数中构造了P1对象，fun()函数本义是利用移动构造函数来减小复制次数，但是可以看到尽管我们在main函数中使用了右值，但是fun函数里任然使用了拷贝构造函数。我们做如下修改：
Person p2(std::forward<Person>(p));
结果如下：
可以看到符合我们的预期
相同点：都能从堆上申请、释放空间
区别：