八、引用

1、引用简介

变量名，本身是一段内存的引用，即别名(alias)。引用，是为己有变量起一个别名。
Type& name = var;

 int a;
     int &b = a;

普通引用在定义时必须使用同类型的变量进行初始化。

2、引用的规则

A、引用没有定义，是一种关系型声明。声明它和原有某一变量(实体)的关系。故 而类型与原类型保持一致，且不分配内存，与被引用的变量有相同的地址。
B、声明的时候必须初始化，一经声明，不可变更。
C、可对引用再次引用。多次引用的结果，是某一变量具有多个别名。
D、&符号前有数据类型时，是引用。其它皆为取地址。

#include 

using namespace std;

int main(int argc, char *argv[])
{
    int a = 3;
    int c = 6;
    float f = 3.14;
    int& b = a;
    printf("&a = 0x%X\n", &a);
    printf("&b = 0x%X\n", &b);
    //error: redeclaration of 'int& b'
    int& b = c;//error
    //给b赋值
    b = c;
    //引用的类型必须与变量类型相同
    int& d = f;//error
    //error: invalid initialization of reference of type 'int&' from expression of type 'float'

    //引用在定义时必须初始化
    int& rd;//error
    //error: 'rd' declared as reference but not initialized
    //引用不可以使用字面值初始化
    int& r = 10;//error
    //error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int'
    return 0;
}

3、引用的应用

函数中的引用形参不需要进行初始化，函数调用时进行初始化。

#include 

using namespace std;
//引用
void swap(int &a, int &b)
{
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
    printf("swap(int &a, int &b)\n");
}
//指针
void swap(int* a, int* b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
    printf("swap(int* a, int* b)\n");
}

int main(int argc, char *argv[])
{
    int a = 3;
    int b = 6;
    swap(a,b);
    printf("a = %d\n",a);//6
    printf("b = %d\n",b);//3
    swap(&a,&b);
    printf("a = %d\n",a);//3
    printf("b = %d\n",b);//6
    return 0;
}

4、引用的提高
A、可以定义指针的引用，但不能定义引用的引用。

  int a;
    int* p = &a;
    int*& rp = p; // ok
    int& r = a;
    int&& rr = r; // error

B、可以定义指针的指针(二级指针)，但不能定义引用的指针。

  int a;
    int* p = &a;
    int** pp = &p; // ok
    int& r = a;
    int&* pr = &r; // error

C、可以定义指针数组，但不能定义引用数组，可以定义数组引用。

  int a, b, c;
    int* parr[] = {&a, &b, &c}; // ok
    int& rarr[] = {a, b, c}; // error
    int arr[] = {1, 2, 3};
    int (&rarr)[3] = arr; // ok 的

数组是连续的存储空间，数组中的元素如果是引用，会导致数组的元素存储不连续。引用数组会破坏数组存储空间的连续性。

5、const引用

const引用所引用的对象必须是const的，将普通引用绑定到const引用对象是不合法的。
const type& name = var;
const引用可使用相关类型的对象(常量，非同类型的变量或表达式)初始化，const引用让变量具有只读属性，是const引用与普通引用大的区别。
非const引用只能绑定到与该引用同类型的对象。
当const引用使用字面常量值初始化时，C++编译器会为常量值分配空间，使用字面常量对const引用初始化将生成一个只读变量。

#include 

using namespace std;

int main(int argc, char *argv[])
{
    int a = 10;
    const int& ra = a;//const引用，为只读变量
    //只读变量不能作为左值
    ra = 100;//error: assignment of read-only reference 'c'
    int* p = (int*)&ra;
    *p = 5;
    printf("ra = %d\n", ra);//5
    const int& rb = 10;//rb为只读变量，占用内存空间
    //只读变量不能作为左值
    rb = 100;//error
    int arraya[ra] = {0};//error
    //error: variable-sized object 'arraya' may not be initialized
    int arrayb[rb] = {0};//error
    //error: variable-sized object 'arrayb' may not be initialized
    double pi = 3.14;
    int& rpi = pi;//非法
    //error: invalid initialization of reference of type 'int&' from expression of type 'double'
    const int& crpi = pi;//合法
    printf("rpi= %d\n",crpi);//3
    return 0;
}

6、引用的本质

C++编译器在编译过程中使用指针常量作为引用的内部实现，因此引用所占用空间大小与指针相同。引用的本质是一个指针常量。
type & name<====> type * const name；
使用引用时不能返回局部变量的引用

#include 

using namespace std;

int main(int argc, char *argv[])
{
    printf("sizeof(char&) = %d\n", sizeof(char&));//1
    char c = 'a';
    char& rc = c;
    printf("sizeof(char&) = %d\n", sizeof(rc));//1
    return 0;
}

上述代码的汇编代码如下：

将字符’a’(0x61)存储到指针寄存器0x1b，将0x1b放入eax数据寄存器中，再将eax数据寄存器存储内容放入指针寄存器0x1c中。

九、new/delete

C语言中提供了malloc和free两个系统函数，完成对堆内存的申请和释放。而C++则提供了两关键字new和delete。

1、new

new分配内存空间时，不能保证按需分配，分配内存空间大小可能会大于所需空间大小。因此，new会分配至少申请大小的内存空间。
A、开辟单变量地址空间

  int *p = new int; //开辟大小至少为sizeof(int)空间
    int *a = new int(5); //开辟大小至少为sizeof(int)空间，并初始化为 5

B、开辟数组空间
一维: int a = new int[100];//开辟一个大小不少于400字节的整型数组空间
二维: int (a)[6] = new int[5][6]
三维: int (*a)[5][6] = new int[3][5][6]

2、delete

A、释放单变量空间

int *a = new int;
delete a; //释放单个 int 的空间

B、释放数组空间

int *a = new int[5];
delete []a; //释放 int 数组空间

3、new/delete应用

  int *p = new int(5);
    cout<<*p<

4、返回值

//C++ 内存申请失败会抛出异常
try{
    int *p = new int[10];
}
catch(const std::bad_alloc e) 
{
    return -1;
}
//C++ 内存申请失败不抛出异常版本
int *q = new (std::nothrow)int[10];
if(q == NULL)
    return -1;

5、注意事项

C++中堆空间的分配和释放注意事项如下：
A、new/delete 是关键字，效率高于 malloc 和 free.
B、配对使用，避免内存泄漏和多重释放。
C、避免交叉使用。比如 malloc 申请的空间去 delete，new 出的空间被 free;
D、重点用在类对像的申请与释放。申请的时候会调用构造器完成初始化，
释放的时候，会调用析构器完成内存的清理。

6、malloc与new区别

malloc与new的区别如下：
A、new是C++关键字，malloc是C语言库函数
B、new以具体类型为单位进行内存分配，malloc以字节位单位分配内存
C、new在申请单个类型变量时可以进行初始化，malloc不具备
D、new在所有C++编译器中都支持，malloc在某些系统开发中不可调用
E、new能够触发构造函数的调用，malloc仅分配需要的内存空间
F、对象的创建只能使用new，malloc不适合面向对象开发

7、free与delete的区别

free与delete的区别如下：
A、delete是C++关键字，free是库函数
B、delete在所有C++编译器中都支持，free在某些系统开发中不可调用
C、delete能够触发析构函数的调用，free仅归还分配的内存空间
D、对象的销毁只能使用delete，free不适合面向对象开发
E、free可以归还new申请的内存空间，但不会调用析构函数，可能会造成内存泄漏
F、delete可以释放malloc分配的内存空间，但会调用析构函数，会造成其他问题。

十、内联函数

1、内联函数简介

C语言中有宏函数的概念。宏函数的特点是内嵌到调用代码中去，避免了函数调用的开销。但宏函数的处理发生在预处理阶段，缺少作用域检查和类型检查。
C++提供了inline关键字，请求C++编译器将一个函数进行内联编译（C++编译器可以拒绝），C++编译器会直接将内联的函数体代码插入函数调用的地方。
内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器会直接忽略内联请求。

inline int sqr(int x)
{
    return x*x;
}

2、内联函数的优缺点

内联函数的优点：避免调用时的额外开销（入栈与出栈操作）
内联函数的缺点：内联函数的函数体在代码段中会出现多个“副本”，因此会增加代码段的空间。
内联函数的本质：以牺牲代码段空间为代价，提高程序的运行时间的效率。
内联函数的适用场景：函数体很“小”，且被“频繁”调用。

3、内联函数示例

Inline关键字是对编译器的建议，如果编译器认为inline声明的函数可以内联，则编译器会将函数内联，如果编译器认为inline声明的函数的函数体太长，则不会内联，按普通函数处理。

using namespace std;

inline int func(int a, int b)
{
    return a*a + b*b;
}

int main(int argc, char *argv[])
{
    int a = 3;
    int b = 4;
    int c = func(a,b);
    return 0;
}

上述代码在QtCreator+MinGW编译器下调试时，查看汇编代码如下：

调用func函数时，C++编译器没有将func函数内联，仍然使用函数调用。
inline声明的函数，内联请求可能被C++编译器拒绝。
现代C++编译器能够进行编译优化，一些函数即使没有inline关键字声明也能够内联编译，同时现代C++编译器提供了扩展的语法，能够对函数进行强制内联。如现代G++编译器使用__attribute__((always_inline))声明强制内联，MSVC编译器使用__forceinline声明强制内联，不再使用inline关键字。

#include 

using namespace std;

__attribute__((always_inline))
int func(int a, int b);

int main(int argc, char *argv[])
{
    int a = 3;
    int b = 4;
    int c = func(a,b);
    return 0;
}

int func(int a, int b)
{
    return a*a + b*b;
}

上述代码在QtCreator+MinGW编译器中进行调试时，main函数中func函数调用代码的汇编代码如下：

MinGW编译器已经对func函数进行了内联。

4、内联函数使用的限制

C++中使用inline关键字内联编译函数的限制：
A、不能存在任何形式的循环语句
B、不能存在过多的条件判断语句
C、函数体不能过于庞大
D、不能对函数进行取地址操作
E、函数内联声明必须在调用语句前
对于现代C++编译器的扩展语法提供的强制内联不受上述条件限制。

十一、类型强制转换

1、C++类型转换

C语言中的类型转换是强制转换，任何类型间都可以转换，过于粗暴。
C++语言引入了static_cast、dynamic_cast、const_cast、reinterpret_cast四个关键字处理不同类型间的转换。

2、静态类型转换

静态类型转换是在编译期内即可决定其类型的转换。
静态类型转换的使用场合：
A、用于基本类型间的转换
B、不能用于基本类型指针间的转换
C、用于有继承关系类对象间的转换和类指针间的转换（转换一般从子对象向父对象转换）
语法格式：

static_cast<目标类型> (标识符)

应用实例：

#include 

class A
{
private:
    int a;
    int b;
public:
    A()
    {
        a = 0;
        b = 0;
    }
    void print()
    {
        printf("a = %d, b = %d\n", a, b);
    }

};

class B : public  A
{
private:
    int c;
    int d;
public:
    void display()
    {
        printf("c = %d, d = %d\n", c, d);
    }

};

class C
{
public:
    void print()
    {
        printf("hello\n");
    }
};

int main()
{
    float f = static_cast(9)/10;//基本类型的转换
    printf("f = %f\n", f);
    A a;
    B b;
    A aa = static_cast(b);//将子类对象转换为父类对象
    aa.print();
    //B bb = static_cast(a);//不能将父对象转换为子对象
    A* pa = static_cast(&a);//在同类型对象指针间转换
    pa->print();
    pa = static_cast(&b);//将子类对象指针转换为父类对象指针
    pa->print();
    B* pb = static_cast(&b);
    pb->display();
    pb = static_cast(&a);
    pb->display();
    //C c = static_cast(a);//没有转换构函数，不能将A类型转换为C类型
    //c.print();
    return 0;
}

3、动态类型转换

动态类型转换的使用场合：
A、用于有继承关系的类指针间的转换
B、有交叉关系的类指针间的转换
C、具有类型检查
D、必须有虚函数支持
语法格式：

dynamic_cast<目标类型> (标识符)

用于有直接或间接继承关系的指针（引用）的强制转换
转换指针成功将会得到目标类型的指针，转换失败将得到一个空指针；
转换引用成功将得到目标类型的引用，转换失败将得到一个异常操作信息。
使用实例：

#include 
#include 

using namespace std;

class Base
{
public:
    Base()
    {
        cout << "Base::Base()" << endl;
    }
    virtual ~Base()
    {
        cout << "Base::~Base()" << endl;
    }
};

class Derived : public Base
{
};

int main()
{
    Base* p = new Derived;
    Derived* pd = dynamic_cast(p);//将指向子类对象的父类指针转换为子类指针，转换成功
    if( pd != NULL )
    {
        cout << "pd = " << pd << endl;
    }
    else
    {
        cout << "Cast error!" << endl;
    }
    delete p;
    cout << endl;
    p = new Base;
    pd = dynamic_cast(p);//将指向父类对象的父类指针转换为子类指针，转换失败
    if( pd != NULL )
    {
        cout << "pd = " << pd << endl;
    }
    else
    {
        cout << "Cast error!" << endl;
    }
    delete p;
    return 0;
}

4、常量类型转换

常量类型转换的使用场合：
A、用于去除变量的只读属性
B、目标类类型只能是指针或引用
语法格式：

const_cast<目标类型> (标识符) //目标类类型只能是指针或引用。

const_cast将转换掉表达式的const属性
应用实例：

#include 

using namespace std;

int main()
{
    const int& a = 10;
    int& b = const_cast(a);//将a的只读属性去除，并初始化b
    b = 0;
    cout << "a = " << a << endl;//0
    cout << "b = " << b << endl;//0
    const int c = 100;
    int& d = const_cast(c);//为c分配一个只读空间
    //int x = const_cast(c);//error,目标类型只能为指针和引用
    d = 1000;
    cout << "c = " << c << endl;//100
    cout << "d = " << d << endl;//1000

    return 0;
}

5、重解释类型转换

重解释类型转换使用场合：
A、用于指针类型间的强制转换
B、用于整数和指针类型间的强制转换
语法格式：

reinterpret_cast<目标类型> (标识符)

为数据的二进制形式重新解释，但是不改变其值。
使用实例：

#include 

using namespace std;

int main(int argc, char *argv[])
{
    int a = 100;
    char c = 'a';
    int* pa = reinterpret_cast(&c);
    printf("*pa = %d\n", *pa);//687781729
    printf("*pa = %c\n", *pa);//'a'
    //int x = reinterpret_cast(c);//error
    //int y = reinterpret_cast(1.1);//error

    return 0;
}

namespace NAMESPACE
{
    全局变量 int a;
    数据类型 struct Stu{};
    函数 void func();
}

#include 
using namespace std;
namespace MySpace
{
    int x = 1;
    int y = 2;
}
namespace Other {
    int x = 3;
    int y = 4;
}
int main()
{
    {
        using namespace MySpace;
        cout<

namespace MySpace
{
    int x = 1;
    int y = 2;
    namespace Other {
        int m = 3;
        int n = 4;
    }
}

#ifndef A_H
#define A_H
namespace XX {
    class A
    {
        public:
            A();
            ~A();
    };
}
#endif // A_H

#include "a.h"
using namespace XXX
{
        A::A()
        {}
        A::~A()
        {}
}

  string str;
  str = "china";
    string str2 = " is great ";
    string str3 = str2;

string str = "china";
cout << sizeof(str) << " " << str.max_size() << " " << str.size()<

string s1 = "abcdeg";
string s2 = "12345";
if(s1>s2)
cout<<"s1>s2"<

string sArray[10] = {
    "0",
    "1",
    "22",
    "333",
    "4444",
    "55555",
    "666666",
    "7777777",
    "88888888",
    "999999999",
};
for(int i=0; i<10; i++)
{
    cout<

int capacity()const;  //返回当前容量（即string中不必增加内存即可存放的元素个数）
int max_size()const;    //返回string对象中可存放的大字符串的长度
int size()const;        //返回当前字符串的大小
int length()const;       //返回当前字符串的长度
bool empty()const;        //当前字符串是否为空
void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分