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