【关键字】c++关键字

1. alignas (c++11)

设置类和struct的字节对齐方式

默认取值是:  2n : 0, 1, 2, 4 , 6, 8.....

2. alignof

区分sizeof(), alignof得到字节对齐的字节数

#include <iostream>
using namespace std;

//对结构体或类进行表示, 设置对齐方式为8字节
struct alignas() S {};

//struct alignas(1) U { S s; }  // warning

//有字节对齐(以4字节为对齐方式)
struct Foo
{
    int i;
    float f;
    char c;
};

struct Empty {};

struct alignas() Empty64 {};

struct alignas() Double {
    double d;
};

//以四字节为对齐方式, 即sizeof(Obj) == 8
struct Obj {
    char a;
    int b;
};

void alignInfo()
{
    cout << "sizeof(Obj)        : " << sizeof(Obj)      << endl; //
    cout << "alignof(Obj)       : " << alignof(Obj)     << endl; //
    cout << "sizeof(Foo)        : " << sizeof(Foo)      << endl; //
    cout << "sizeof(Double)     : " << sizeof(Double)   << endl; //
    cout << "sizeof(Empty64)    : " << sizeof(Empty64)  << endl; //

    cout << "\n";

    cout << "Alignment of " << endl;
    cout << "- char             : " << alignof(char)    << endl; //
    cout << "- pointer          : " << alignof(int*)    << endl; //
    cout << "- class Foo        : " << alignof(Foo)     << endl; //
    cout << "- empty class      : " << alignof(Empty)   << endl; //
    cout << "- alignas(64) Empty: " << alignof(Empty64) << endl; //
    cout << "- alignas(1) Double: " << alignof(Double)  << endl; //
}

int main()
{
    alignInfo();

    return ;
}

3. auto (c++11)

#include <iostream>
using namespace std;

double add(double a, double b)
{
    return a + b;
}

double get_fun(int a)
{
    return a;
}

void showAuto()
{
    int aa =  + ;
    auto a =  + ;
    cout << "type of a: " << typeid(a).name() << endl;

    auto b = add(, 1.2);
    cout << "type of b: " << typeid(b).name() << endl;

    auto c = {, };
    cout << "type of c: " << typeid(c).name() << endl;

    auto my_lambda = [](int x) { return x + ; };
    std::cout << "my_lambda: " << my_lambda() << endl;

    auto my_fun = get_fun();
    cout << "type of my_fun: " << typeid(my_fun).name() << endl;
    cout << "my_fun: " << get_fun() << endl;

}

int main()
{

    showAuto();
    return ;
}

4. bitand 和 bitor

#include <iostream>
using namespace std;             

void showBitAndOr()
{
    auto a = 3L;
    auto b = ;                  

    //long
    auto c = a bitand b;  // &
    auto d = a bitor b;   // |   

    cout << c << endl;           

    cout << d << endl;
}                                

int main()
{
    showBitAndOr();              

    return ;
}                                

5. constexpr: 常量表达式(c++11)

• 用于编译时的常量与常量函数。
• 声明为constexpr函数的意义是：如果其参数均为合适的编译期常量，则对这个constexpr函数的调用就可用于 期望常量表达式 的场合（如模板的非类型参数，或枚举常量的值）。

#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;

int fact(int n)
{
    return n <  ?  : (n * fact(n - ));
}

//编译器在编译器时, 就求出来返回的值了
constexpr int factorial(int n)
{
    return n <=  ?  : (n * factorial(n - ));
}

template<int N>
struct NN {
    void print()
    {
        cout << N << endl;
    }
};

int main(int argc, char *argv[])
{

    //在编译器编译时调用的
    if (argc > ) factorial(atoi(argv[]));

    auto aa = fact();
    auto bb = factorial();
    char group[factorial()];   //编译器在编译时, 就求出来了

    NN<factorial()> nn;
    nn.print();

    return ;

}

输出: 6

6. const_cast(避免使用)

7. decltype指定符(c++11)

检查实体的声明类型或表达式的类型及值分类。

#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;

struct A {
    double x;
    A(double t) : x(t) {}

};

void testDecltype()
{
    A* a = new A();

    auto aa = a->x;          // aa : double
    decltype(a->x) y;        // decltype(a->x) : double
    decltype((a->x)) z = y;  // decltype((a->x)) : double&
    z = 23.5;
    cout << y << endl;       // 23.5

    //其他用法
}

//c++11, 后置返回类型, 返回值类型由 后面的表达式确定的
//返回值不损失任何精度
template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b)
{
    return a + b;
}

template<typename T, typename U>
auto add(T a, U b) {
    auto c = a + b;
    //return c;   //返回值
    //return (c); //返回引用
    return c;
}  

int main(int argc, char **argv)
{
    testDecltype();

    return ;
}  

8. dynamic_cast转换

沿继承层级向上、向下及侧向转换到类的指针和引用。

#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;        

struct Base
{
    virtual ~Base() {}
};                                                    

struct Derived : public Base
{
    virtual void name() {}
};                                                    

void testDynatic_cast()
{
    Base *b1 = new Base();
    //拥有基类指针, base指针-->derived指针, 失败
    if (Derived *d = dynamic_cast<Derived *> (b1))
    {
        cout << "donwcast from b1 to d successful\n";
        d->name();    // safe to call
    }                                                 

    Base *b2 = new Derived();
    //成功, 因为b2的确指向derived
    if (Derived *d = dynamic_cast<Derived *> (b2))
    {
        cout << "donwcast from b2 to d successful\n";
        d->name();    // safe to call
    }
}                                                     

int main(int argc, char **argv)
{                                                                                                     

    testDynatic_cast();                               

    return ;
}                                                     

9. explicit

• 指定构造函数或转换函数 (C++11 起)为显式，即它不能用于隐式转换和复制初始化。

struct A
{
    A(int) { }      // 转换构造函数
    A(int, int) { } // 转换构造函数 (C++11)
    operator bool() const { return true; }
};

struct B
{
    explicit B(int) { }
    explicit B(int, int) { }
    explicit operator bool() const { return true; }
};

int main()
{
    A a1 = ;      // OK ：复制初始化选择 A::A(int)
    A a2();       // OK ：直接初始化选择 A::A(int)
    A a3 {, };   // OK ：直接列表初始化选择 A::A(int, int)
    A a4 = {, }; // OK ：复制列表初始化选择 A::A(int, int)
    A a5 = (A);   // OK ：显式转型进行 static_cast
    if (a1) ;      // OK ：A::operator bool()
    bool na1 = a1; // OK ：复制初始化选择 A::operator bool()
    bool na2 = static_cast<bool>(a1); // OK ：static_cast 进行直接初始化

//  B b1 = 1;      // 错误：复制初始化不考虑 B::B(int)
    B b2();       // OK ：直接初始化选择 B::B(int)
    B b3 {, };   // OK ：直接列表初始化选择 B::B(int, int)
//  B b4 = {4, 5}; // 错误：复制列表初始化不考虑 B::B(int,int)
    B b5 = (B);   // OK ：显式转型进行 static_cast
    if (b2) ;      // OK ：B::operator bool()
//  bool nb1 = b2; // 错误：复制初始化不考虑 B::operator bool()
    bool nb2 = static_cast<bool>(b2); // OK ：static_cast 进行直接初始化
}

10. static_assert: 编译时检查

#include <iostream>
using namespace std;

template<typename T>
void func(T t)
{
    static_assert(alignof(T) == , "only for alignof 4");
}

int main()
{
    int a = ;

    func(a);

    return ;
}