C++新增关键字

1.bool

bool类型有两个enum值，在C语言中不支持源生bool类型，是采用自定义的方式设置的（typedef int bool）；

C++中支持源生bool类型，函数的重载机制认为bool是不同的类型。

// C代码
typedef int bool;
// C++代码,会被认为是函数重载
int add(bool a,bool b);
int add(int a,int b);

2.C++的字符类型

2.1 char

一般占一个字节，表示字符（ASCI/unicode）；

C++14开始char默认是unsigned还是signed取决于目标平台（Arm，X86），最好显示的指定符号类型；

char类型cout输出的是字符，int类型cout输出的是数字；

2.2 wchar_t

宽字符，对应字符编码超过一个字节的unicode编码；

char和wchar_t的数组都能存下unicode编码，区别是需要几个单元才能存一个字；

用wcin 和 wcout来输入输出，对应的字符串为wstring;

2.3 char8_t(C++20起)  char16_t(C++11起) char32_t(C++11起)

优点：明确指定占用字节数，且都是无符号的；

C++20起，新增字符串类型u8string,u16string,u32string;

3.运算符代用关键字

运算符代用关键字便于理解，用C语言的人一般还是习惯使用运算符；

#include <iostream>

using namespace std;

int main()
{
    int a,b;
    a=4;
    b=5;
    if((a>1)and(b<8))
    {
        cout <<"true"<<endl;
    }else{
        cout <<"false"<<endl;
    }

    bool b1 =  !a;
    bool b2 = not a;
    cout<<boolalpha<<b1<<endl;
    cout<<boolalpha<<b2<<endl;

    return 0;
}

4.新增引用&

4.1 定义

引用符号在定义时候必须初始化，以后不能再另外赋值，只能使用；实质上，变量名和引用名都是指向同一段内存单元的不同名称而已。

#include <iostream>

using namespace std;

int main()
{
    int a= 2;
    int &b = a;
    b = 3;
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;

    return 0;
}

4.2 C++中的指针使用

#include <iostream>

using namespace std;

class clock
{
public:
    clock(int h,int m,int s)
    {
        hour = h;
        minute = m;
        sec =s;
    }
    void get_clock();
// private:
    int hour;
    int minute;
    int sec;
};

void clock::get_clock()
{
    cout <<hour<<':'<<minute<<':'<<sec<<endl;
}

int main()
{
    clock *pt;                       // 指向类对象的指针变量
    clock t1(12,39,23);
    int *p1 = &t1.hour;             // 定义指针变量p1指向对象t1的数据成员hour
    *p1 = 15;
    pt = &t1;
    pt->get_clock();
    void(clock:: *p3)();            // 定义指向 clock类成员函数的指针变量p3
    p3 = &clock::get_clock;
    (t1.*p3)();

    return 0;

}

4.3 引用与指针的对比

(1) 指针在C和C++中都有，本质和使用方法都是相同的，引用只能在C++中使用；

(2) 引用就是指向变量的一个别名，引用定义的时候就绑定了一个变量，后面无法更改，而指针是可以更改的，但是引用不会造成野指针的问题，可以理解为功能弱化，安全行增强的低配版指针；

(3) 引用主要是用于函数传参和返回值；

利用交换函数来理解引用，代码如下

#include <iostream>

using namespace std;

// 无法完成交换任务
void swap1(int a, int b)
{
    int tmp;
    tmp =a;
    a = b;
    b = tmp;
}
// 利用指针完成交换任务
void swap2(int* pa,int* pb)
{
    int tmp;
    tmp = *pa;
    *pa = *pb;
    *pb = tmp;
}
// 利用引用完成交换任务
void swap3(int& a,int& b)
{
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}

int main()
{
    int a=1,b=2;
    //swap1(a,b);
    //swap2(&a,&b);
    swap3(a,b);
    cout<<"a="<<a<<"b="<<b<<endl;
    return 0;
}

4.3 引用与const

在C++面向对象的程序设计中，经常使用指向常对象的指针和常引用作为函数参数，这样既能保证数据的安全，同时又能提高程序的运行效率，在调用函数是不必建立实参的拷贝。

const用于函数的形参中，表明在函数的调用过程中，不希望变量的值在函数内部被修改，这时候就可以用const引用来传参1

4.4 引用与sizeof

sizeof(*)的大小是指针本身的大小，跟指向变量的大小没有关系；

sizeof(&)的大小是引用所关联的目标的大小；

在struct和class中会有所不同，int 类型的引用在结构体占8个字节

#include <iostream>

using namespace std;

struct s1
{
  int a;
  int &b;
};

int main()
{
    int a = 1;
    double b =5.5;
    char c = 'A';

    int &ra = a;
    double &rb = b;
    char &rc = c;

    cout << sizeof (ra)<<endl;                  // 结果 4
    cout << sizeof (rb)<<endl;                  // 结果 8
    cout << sizeof (rc)<<endl;                  // 结果 1

    // 结构体中sizeof测试
    cout<< sizeof(struct s1)<<endl;             // 结果 16

    return 0;

}

4.5 引用的本质

int &b = a;
// 类似于
int* const b = &a;
// 指针b是const的，指向a的地址，不能够被改变，所以在64位系统中就是占8字节

引用是天然const的，所以定义时必须初始化指向变量，否则就没有意义；

引用的本质就是指针，所以引用能够实现传址调用，引用就是指针在定义时增加把指针变量本身const化；