C++关键字

1 const

2 const_cast

3 decltype

4 default

5 delete

6 dynamic_cast

7 explicit

8 mutable

9 reinterpret_cast

10 static_cast

11 typeid

1 const

类的数据如果是const属性，需要初始化，否则报错

error C2789: “fush::d”: 必须初始化常量限定类型的对象

struct fushu
{
    const int d;//error C2789: “fush::d”: 必须初始化常量限定类型的对象
};

类的函数如是是const属性，则内部不能修改数据，否则报错

error C3490: 由于正在通过常量对象访问“a”，因此无法对其进行修改

struct fushu
{
    int a;
    mutable int b;
    void showabc() const
    {
        this->a = 10;//error C3490: 由于正在通过常量对象访问“a”，因此无法对其进行修改
        this->b = 10;
    }
};

2 const_cast

const_cast用于去掉常量const属性

dynamic_cast用于类的多态之间的指针转换，只能用于含有虚函数的类。将多态类型向下转型dowcast为其实际类型。

reinterpret_cast用于指针的转换。

static_cast用于常规的数据类型转换。只有当类型转换有所定义，整个转换才会成功。

const_cast，用于修改类型的const或volatile属性。

const_cast<type_id> (expression)

该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

一、常量指针被转化成非常量的指针，并且仍然指向原来的对象；

二、常量引用被转换成非常量的引用，并且仍然指向原来的对象；

三、const_cast一般用于修改底指针。如const char *p形式。

#include <iostream>
using namespace std;

void main()
{
    const int num = 5;

    int *p = const_cast<int *>(&num);//强制去掉const属性
    
    *p = 4;

    std::cout << num << std::endl;//仍然是5，无法通过指针修改
     
    system("pause");
}

//const int num=10;可以修改，但是无法生效，编译的时候不读内存

//const int *p指向变量限定权限，只读不可写

//const_cast去掉常量属性

//error C3892: “p”: 不能给常量赋值

#include <iostream>
using namespace std;

//const int num=10;可以修改，但是无法生效，编译的时候不读内存
//const int *p指向变量限定权限，只读不可写
//const_cast去掉常量属性

void main()
{
    int num[3] = { 1,2,3 };

    const int *p = num;

    //*p = 10;//error C3892: “p”: 不能给常量赋值

    int *pnew = const_cast<int *>(p);

    *pnew = 10;

    system("pause");
}

3 decltype

根据一个变量，创建一个备份

#include <iostream>
using namespace std;

void main()
{
    double db(10.9);

    decltype(db) newdb(10.9);//通用备份接口，类似Java反射

    std::cout << sizeof(newdb) << " " << newdb << std::endl;

    system("pause");
}

//自动数据类型，根据实际推导出类型

#include <iostream>
using namespace std;

//自动数据类型，根据实际推导出类型

template <class T1, class T2>//根据参数类型获取类型
auto get(T1 data, T2 bigdata)->decltype(data*bigdata)
{
    return data*bigdata;
}

void main()
{
    std::cout << typeid(get(12.0, 'A')).name() << std::endl;//double

    std::cout << get(12.0, 'A') << std::endl;//780

    std::cout << typeid(get(12, 'A')).name() << std::endl;//int

    std::cout << get(12.0, 'A') << std::endl;//780

    system("pause");
}

4 default

default和delete搭配使用，用于函数

5 delete

//delete可以禁用默认生成的函数

//禁用构造可以无法实例化

//禁用拷贝构造函数，可以实现禁止别人复制

//default默认存在

//error C2280: “myclassA::myclassA(const myclassA &)”: 尝试引用已删除的函数

#include <iostream>

//delete可以禁用默认生成的函数
//禁用构造可以无法实例化
//禁用拷贝构造函数，可以实现禁止别人复制
//default默认存在
class myclassA
{
public:
    myclassA() = default;//default默认存在
    myclassA(const myclassA &) = delete;//拷贝构造函数，delete禁用
};

void main()
{
    myclassA myclassa1;

    myclassA myclassa2(myclassa1);//error C2280: “myclassA::myclassA(const myclassA &)”: 尝试引用已删除的函数

    myclassA myclassa3 = myclassa1;//error C2280: “myclassA::myclassA(const myclassA &)”: 尝试引用已删除的函数

    system("pause");
}

6 dynamic_cast

const_cast用于去掉常量const属性

dynamic_cast用于类的多态之间的指针转换，只能用于含有虚函数的类。将多态类型向下转型dowcast为其实际类型。

reinterpret_cast用于指针的转换

static_cast用于常规的数据类型转换。只有当类型转换有所定义，整个转换才会成功。

将一个基类对象指针（或引用）cast到继承类指针，dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理

dynamic_cast <type-id> (expression)

该运算符把expression转换成type-id类型的对象。Type-id 必须是类的指针、类的引用或者void*；

如果 type-id 是类指针类型，那么expression也必须是一个指针，如果 type-id 是一个引用，那么 expression 也必须是一个引用。

面试，虚函数有虚函数表，可以确定数据类型

dynamic_cast必须要有虚函数，根据虚函数表进行转换，否则转换失败

dynamic_cast转换成功是地址，转换失败为空

类的空指针可以调用不调用数据成员的成员函数

#include <iostream>

//面试，虚函数有虚函数表，可以确定数据类型
//dynamic_cast必须要有虚函数，根据虚函数表进行转换，否则转换失败
//dynamic_cast转换成功是地址，转换失败为空
//类的空指针可以调用不调用数据成员的成员函数

class A
{
public:
    int num;
    static int data;
    virtual void run()//虚函数
    {
        std::cout << "Arun" << std::endl;
    }
};

class B :public A
{
public:
    int num;
    static int data;
    virtual void run()//虚函数
    {
        std::cout << "Brun" << std::endl;
    }
    void test()
    {
        std::cout << "Btest" << std::endl;
    }
};

int A::data = 1;
int B::data = 2;

void main()
{
    A a1;
    B b1;

    A *p1 = &a1;//直接用基类指针引用基类对象
    A *p2 = &b1;//用基类指针引用一个派生类对象
    B *p3(nullptr);//派生类指针，为空

    p3 = dynamic_cast<B *>(p1);

    p3->test();
    
    system("pause");
}

7 explicit

C++提供了关键字explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。

//error C2440 : “初始化” : 无法从“int”转换为“classobj”

//note : class“classobj”的构造函数声明为“explicit”

#include <iostream>

class classobj
{
public:
    int num;
public:
    explicit classobj(int data)
    {
        this->num = data;
        std::cout << "被构造" << std::endl;
    }
    ~classobj()
    {

    }
};

void main()
{
    //classobj num = 5;//让人误会以为是类型转换

    //error C2440 : “初始化” : 无法从“int”转换为“classobj”
    //note : class“classobj”的构造函数声明为“explicit”

    classobj data(5);

    system("pause");
}

8 mutable

mutable 可以用来指出，即使成员函数或者类变量为const，其某个成员也可以被修改。

在c++的类中， 如果一个成员函数被const 修饰，那么它将无法修改其成员变量的，但是如果这个成员变量是被mutable修饰的话，则可以修改。

e有mutable，即使成员函数为const，e仍然可以被修改

    mutable int e = 9;

    void showabc() const
    {
        this->e = 10;
        std::cout << this->a << this->b << this->c << std::endl;
    }

9 reinterpret_cast

const_cast用于去掉常量const属性

dynamic_cast用于类的多态之间的指针转换，只能用于含有虚函数的类。将多态类型向下转型dowcast为其实际类型。

reinterpret_cast用于指针的转换

static_cast用于常规的数据类型转换。只有当类型转换有所定义，整个转换才会成功。

reinterpret_cast是C++里的强制类型转换符。

reinterpret_cast<type-id> (expression) type-id 必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，再把该整数转换成原类型的指针，还可以得到原先的指针值）。

//指针，强类型，类型决定了数据的解析方式，内存占多大

#include <iostream>
using namespace std;

//指针，强类型，类型决定了数据的解析方式，内存占多大

void main()
{
    int num(3);

    char *p = reinterpret_cast<char *>(&num);

    for (int i = 0; i < 4; i++)
    {
        printf("%c,%d,%p
", *(p + i), *(p + i), p + i);
    }

    system("pause");
}

10 static_cast

const_cast用于去掉常量const属性

dynamic_cast用于类的多态之间的指针转换，只能用于含有虚函数的类。将多态类型向下转型dowcast为其实际类型。

reinterpret_cast用于指针的转换

static_cast用于常规的数据类型转换。只有当类型转换有所定义，整个转换才会成功。

float x = 10.1f;
std::cout << static_cast<int>(x) << std::endl;//由float转换到int有所定义

f(static_cast<std::string>("hello world!"));//由char *转换到string有所定义

该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。

static_cast < type-id > ( expression )

#include <iostream>
using namespace std;

void main()
{
    int n = static_cast<int>(78.98);

    std::cout << n << std::endl;//78
    
    int *p = static_cast<int *>(malloc(100));

    system("pause");
}

11 typeid

在C++中，typeid用于返回指针或引用所指对象的实际类型。

#include <iostream>
using namespace std;

void main()
{
    double db(10.9);
    double *pdb(&db);

    auto num(pdb);//通用传入接口

    std::cout << typeid(db).name() << std::endl;//double
    std::cout << typeid(pdb).name() << std::endl;//double *
    std::cout << typeid(num).name() << std::endl;//double *

    system("pause");
}

typeid是根据指针检查类型的，如果类中没有虚函数，那么可能会检测不准确

1类中没有虚函数，检测不准确

直接用基类指针引用基类对象

用基类指针引用一个派生类对象

#include <iostream>

//typeid是根据指针检查类型的，如果类中没有虚函数，那么可能会检测不准确

class A
{
public:
    int num;
    static int data;
    void run()
    {
        std::cout << "Arun" << std::endl;
    }
};

class B :public A
{
public:
    int num;
    static int data;
    void run()
    {
        std::cout << "Brun" << std::endl;
    }
    void test()
    {
        std::cout << "Btest" << std::endl;
    }
};

int A::data = 1;
int B::data = 2;

void main()
{
    A *p1 = new A;//直接用基类指针引用基类对象
    A *p2 = new B;//用基类指针引用一个派生类对象
    
    std::cout << typeid(p1).name() << " " << typeid(p2).name() << std::endl;//检查两个指针类型

    std::cout << typeid(*p1).name() << " " << typeid(*p2).name() << std::endl;//检查两个指针指向的类型，实际上是不一样的，但是检测不准确

    std::cout << (typeid(p1) == typeid(p2)) << std::endl;//1，检查两个指针类型

    std::cout << (typeid(*p1) == typeid(*p2)) << std::endl;//1，检查两个指针指向的类型，实际上是不一样的，但是检测不准确

    system("pause");
}

2类中有虚函数，检测准确

直接用基类指针引用基类对象

用基类指针引用一个派生类对象

#include <iostream>

//typeid是根据指针检查类型的，如果类中没有虚函数，那么可能会检测不准确

class A
{
public:
    int num;
    static int data;
    virtual void run()//虚函数
    {
        std::cout << "Arun" << std::endl;
    }
};

class B :public A
{
public:
    int num;
    static int data;
    virtual void run()//虚函数
    {
        std::cout << "Brun" << std::endl;
    }
    void test()
    {
        std::cout << "Btest" << std::endl;
    }
};

int A::data = 1;
int B::data = 2;

void main()
{
    A *p1 = new A;//直接用基类指针引用基类对象
    A *p2 = new B;//用基类指针引用一个派生类对象
    
    std::cout << typeid(p1).name() << " " << typeid(p2).name() << std::endl;//检查两个指针类型

    std::cout << typeid(*p1).name() << " " << typeid(*p2).name() << std::endl;//检查两个指针指向的类型

    std::cout << (typeid(p1) == typeid(p2)) << std::endl;//1，检查两个指针类型

    std::cout << (typeid(*p1) == typeid(*p2)) << std::endl;//0，检查两个指针指向的类型

    system("pause");
}