1.将亡值(xvalue)：在一个表达式中，函数调用也是一个表达式，在函数表达式过程中产生的不具有名字的实体，有可能是内置类型，也有可能是自定义类型，不管是什么类型，这个不具有名字的实体就叫做将亡值，它的生存期只在表达式的调用过程中，表达式调用一旦结束，将亡值就会被销毁
2.左值，右值，纯右值
右值引用可以作为将亡值(xvalue)和纯右值的别名(prvalue)，右值引用只能引用不具有名字的实体(比如无名对象和字面常量)
右值引用不能是左值的别名，字面常量叫做纯右值(比如说10)
左值有地址，生存期和名字是一样的，名字存在生存期就存在
右值没有名字，不能取地址
c是10的右值引用，当运行到int&& d = c;时，它就具名了，就变成左值了
int a = 10;
int& b = a;
int&& c = 10;
int&& d = c;//error
3.判断下面程序为什么不能编译通过？
String&& fun()
{
String s2("hello");
return s2;
}
int main()
{
String s1;
s1 = fun();
cout << s1 << endl;
}
原因：右值引用只能引用不具有名字的对象，s2是名字，所以不能右值引用
注意：String&& s1 = String(“hello”);也是可以的，右值引用是可以引用无名对象的
注意：String& s1 = String(“hello”);是不可以的，普通引用(左值引用)不能引用无名对象，必须引用有名对象
4.画出下面程序的内存分布图
//移动构造
String(String&& s)
{
cout << "move copy construct :" << this << endl;
str = s.str;
s.str = NULL;
}
//移动赋值
String& operator=(String&& s)
{
if(this != &s)
{
str = s.str;
s.str = NULL;
}
cout << this << "move operator=:" << &s <<endl;
return *this;
}
String&& fun()
{
String s2("hello");
return s2;
}
int main()
{
String s1;
s1 = fun();
cout << s1 << endl;
}
解析：在main函数栈帧中先创建对象s1，s1.str指向的是一个堆区的空间，大小为一个字节，为’\0’，然后调用fun函数，在fun函数栈帧空间中创建对象s2，s2.str指向的是一个堆区的空间，为"hello"，然后return s2的时候在main函数栈帧空间中创建一个无名对象，调用移动构造函数，让无名对象的str指向s2.str，然后把s2.str置为空，相当于对象s2把它的数据给了无名对象，然后s2的生存期到了，调用析构函数，但是此时s2为空，没有空间可以释放，所以跳过结束，然后回到main函数中，无名对象给s1赋值时，调用移动赋值函数，s1.str指向无名对象的str，然后把无名对象的str置为空，此时无名对象的生存期到了，调用析构函数，但是此时无名对象为空，没有空间可以释放，所以跳过结束，相当于无名对象把他的数据给了s1
如果没有移动构造函数和移动赋值函数，会在产生无名对象的时候多一次对堆空间的申请和释放
移动构造就是用于建立将亡值对象，如果有移动构造就优先调用移动构造，如果没有，调用拷贝构造
s2是有具名对象，为什么可以用右值引用来引用呢？
其实编译器在编译的时候将return s2;变成了return std::move(s2);它把s2强转成了右值对象，所以可以用右值引用了
上面程序存在的问题就是s1和s2指向的堆区的空间并没有释放掉，久而久之就会导致严重的内存泄露问题，那么如何修改呢？可以在str = s.str;前面加上delete[] str;也就是在赋值之前，将str之前指向的堆空间释放掉
5.柔性数组
我们来先看一个结构体的设计：
#define MAXLEN 1024
typedef struct kd_node
{
struct kd_node * left;
struct kd_node * right;
int dim;
unsigned long long data[MAXLEN];
}kd_node;
在这段代码中，为了存储数据，申请了长度为1024的unsigned long long 型数组，如果数据的长度远远小于MAXLEN，这样的设计，是极其浪费空间的，在C99和C11标准中给出了新的设计方法，就是通过柔性数组可以解决这个问题
示例：
struct sd_node
{
int num;
int size;
char data[];//方法一
};
//或
struct sd_node
{
int num;
int size;
char data[0];//方法二
};
数组的大小声明为0或者不给出大小，称之为柔性数组，注意：全局数组和局部数组不能这样定义
柔性数组是一种数组大小待定的数组，在C语言中，可以使用结构体产生柔性数组，结构体的最后一个元素可以是大小未知的数组
在struct sd_node结构体中data，仅仅是一个待使用的标识符，不占用存储空间，所以sizeof(struct sd_data) = 8
用途：长度为0的数组的主要用途是为了满足长度可变的结构体
用法：在一个结构体的最后，声明一个长度为0的数组，就可以使得这个结构体是可变长的，对于编译器来说，此时长度为0的数组并不占用空间，因为数组名本身不占空间，它只是一个偏移量，数组名这个符号本身代表了一个不可修改的地址常量，但对于这个数组的大小，我们可以进行动态分配
注意：如果结构体是通过calloc、malloc或者realloc等动态分配方式生成，在不需要时要释放相应的空间
优点：比起在结构体中声明一个指针变量、再进行动态分配的方法，这种方法效率要高，因为简单
缺点：在结构体中，数组为0的数组必须在最后声明，在设计结构体类型有一定限制
对于编译器而言，数组名仅仅是一个符号，它不会占用任何空间，它在机构提中，只是代表了一个偏移量，代表一个不可修改的地址常量
6.友元
友元不具有自反性、传递性、继承性
①友元不具有自反性，如A是B的友元，但是B不一定是A的友元
②友元不具有传递性，如A是B的友元，B是C的友元，但是A不一定是C的友元
③友元不具有继承性，如A和B的父类C是友元，但是A和B不一定是友元
友元的三种实现方案
①函数友元：为了使外部函数能够访问对象的私有函数，就把外部函数设置为类的友元函数
class Object
{
private:
int value;
public:
Object(int x):value(x) {}
friend ostream& operator<<(ostream& out, const Object& obj);
friend int main();
};
ostream& operator<<(ostream& out,const Object& obj)
{
out << obj.value;
return out;
}
int main()
{
Object obja(10);
cout << obja << endl;
cout << obja.value << endl;
return 0;
}
②成员函数友元
class Object;//如果不声明在编译到void fun(Object&);时就会出错
class Base
{
private:
int sum;
public:
Base(int x = 0):sum(x) {}
void fun(Object&);
};
class Object
{
private:
int value;
public:
Object(int x):value(x) {}
friend void Base::fun(Object& obj);//在Object中声明Base::fun函数是友元函数，那么在Base::fun函数中就可以使用Object的私有成员
};
void Base:fun(Object& obj)
{
obj,value = obj.value + sum;
}
int main()
{
Base base(10);
Object obja(20);
base.fun(obja);
return 0;
}
第一行class Object;//如果不声明在编译到void fun(Object&)时就会出错
friend void Base::fun(Object& obj);//在Object中声明Base::fun函数是友元函数，那么在Base::fun函数中就可以使用Object的私有成员
没有公有友元函数和私有友元函数这种概念，它是一种独立的可访问概念，和其他的可访问概念不同，友元破坏了对象的封装性
③类友元