【关键字】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(8) S {};

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

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

struct Empty {};

struct alignas(64) Empty64 {};

struct alignas(1) Double {
    double d;
};

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


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

    cout << "
";

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


int main()
{
    alignInfo();

    return 0;
}

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 = 1 + 2;
    auto a = 1 + 2;
    cout << "type of a: " << typeid(a).name() << endl;

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

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

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

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

}

int main()
{

    showAuto();
    return 0;
}

4. bitand 和 bitor 

#include <iostream>              
using namespace std;             
                                 
void showBitAndOr()              
{                                
    auto a = 3L;                 
    auto b = 4;                  
                                 
    //long                       
    auto c = a bitand b;  // &   
    auto d = a bitor b;   // |   
                                 
    cout << c << endl;           
                                 
    cout << d << endl;           
}                                
                                 
                                 
int main()                       
{                                
    showBitAndOr();              
                                 
    return 0;                    
}                                

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

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

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

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

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

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

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

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


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

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

    return 0;

}

输出: 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(0);

    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 0;
}  

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
"; 
        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
"; 
        d->name();    // safe to call                 
    }                                                 
}                                                     
                                                      
                                                      
int main(int argc, char **argv)                       
{                                                                                                     
                                                      
    testDynatic_cast();                               
                                                      
    return 0;                                         
}                                                     

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 = 1;      // OK ：复制初始化选择 A::A(int)
    A a2(2);       // OK ：直接初始化选择 A::A(int)
    A a3 {4, 5};   // OK ：直接列表初始化选择 A::A(int, int)
    A a4 = {4, 5}; // OK ：复制列表初始化选择 A::A(int, int)
    A a5 = (A)1;   // 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(2);       // OK ：直接初始化选择 B::B(int)
    B b3 {4, 5};   // OK ：直接列表初始化选择 B::B(int, int)
//  B b4 = {4, 5}; // 错误：复制列表初始化不考虑 B::B(int,int)
    B b5 = (B)1;   // 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) == 4, "only for alignof 4");
}

int main()
{
    int a = 3;
        

    func(a);


    return 0;
}