20分钟了解C++11
9 override关键字 (虚函数使用)
*
* 避免在派生类中意外地生成新函数
*/
// C++ 03
class Dog {
virtual void A(int);
virtual void B() const;
}
class Yellowdog : public Dog {
virtual void A(float); // 生成一个新函数
virtual void B(); //生成一个新函数
}
// C++ 11
class Dog {
virtual void A(int);
virtual void B() const;
void C();
}
class Yellowdog : public Dog {
virtual void A(float) override; // Error: no function to override
virtual void B() override; // Error: no function to override
void C() override; // Error: not a virtual function
}
10 final (虚函数和类使用)
class Dog final { // 在类名后添加表示不能再从该类派生子类
...
};
class Dog {
virtual void bark() final; // 在虚函数后添加表示该函数不能再被覆写
};
11 编译器生成默认构造函数
class Dog {
Dog(int age) {}
};
Dog d1; // 错误：编译器不会自动生成默认构造函数，因为已经有构造函数了
// C++ 11:
class Dog {
Dog(int age);
Dog() = default; // 强制编译器生成默认构造函数
};
12 delete 禁用某些函数
class Dog {
Dog(int age) {}
}
Dog a(2);
Dog b(3.0); // 3.0会从double类型转成int类型
a = b; // 编译器会生成赋值运算符
// C++ 11 手动禁用:
class Dog {
Dog(int age) {}
Dog(double ) = delete;
Dog& operator=(const Dog&) = delete;
}
13 constexpr 常量表达式
int arr[6]; //OK
int A() { return 3; }
int arr[A()+3]; // 编译错误
// C++ 11
constexpr int A() { return 3; } // 强制计算在编译时发生
int arr[A()+3]; // 生成一个大小为6的数组
// 利用constexpr写更快的程序
constexr int cubed(int x) { return x * x * x; }
int y = cubed(1789); // 在编译时计算
//cubed()函数:
//1. 非常快，不消耗运行时计算
//2. 非常小，不占据二进制空间
14 新的字符串字面值
// C++ 03:
char* a = "string";
// C++ 11:
char* a = u8"string"; // UTF-8 string.
char16_t* b = u"string"; // UTF-16 string.
char32_t* c = U"string"; // UTF-32 string.
char* d = R"string \\" // raw string.
15 lambda函数
cout << [](int x, int y){return x+y}(3,4) << endl; // Output: 7
auto f = [](int x, int y) { return x+y; };
cout << f(3,4) << endl; // Output: 7
template<typename func>
void filter(func f, vector<int> arr) {
for (auto i: arr) {
if (f(i))
cout << i << " ";
}
}
int main() {
vector<int> v = {1, 2, 3, 4, 5, 6 };
filter([](int x) {return (x>3);}, v); // Output: 4 5 6
...
filter([](int x) {return (x>2 && x<5);}, v); // Output: 3 4
int y = 4;
filter([&](int x) {return (x>y);}, v); // Output: 5 6
//注: [&] 告诉编译器要变量捕获
}
// Lambda函数几乎像是一个语言的扩展，非常方便
// template
// for_nth_item
17 用户自定义的字面值
// C ++在很大程度上使用户定义的类型（类）与内置类型的行为相同.
// 用户自定义的字面值使其又往前迈出一步
//老的C++，不知道到底表示多长?
long double height = 3.4;
// 在学校物理课的时候
height = 3.4cm;
ratio = 3.4cm / 2.1mm;
// 为什么在编程时不这么做?
// 1. 语言不支持
// 2. 单位转换需要运行时开销
// C++ 11:
long double operator"" _cm(long double x) { return x * 10; }
long double operator"" _m(long double x) { return x * 1000; }
long double operator"" _mm(long double x) { return x; }
int main() {
long double height = 3.4_cm;
cout << height << endl; // 34
cout << (height + 13.0_m) << endl; // 13034
cout << (130.0_mm / 13.0_m) << endl; // 0.01
}
//注: 加constexpr使单位转换在编译时计算
// 限制: 只能用于以下参数类型:
char const*
unsigned long long
long double
char const*, std::size_t
wchar_t const*, std::size_t
char16_t const*, std::size_t
char32_t const*, std::size_t
// 返回值可以是任何类型
// 例子:
int operator"" _hex(char const* str, size_t l) {
// 将十六进制格式化字符串str转成int ret
return ret;
}
int operator"" _oct(char const* str, size_t l) {
// 将格式化8进制字符串str转成 int ret
return ret;
}
int main() {
cout << "FF"_hex << endl; // 255
cout << "40"_oct << endl; // 32
}
18 可变参数模板 Variadic Template
*
* 可以接受任意个数的任意类型模板参数的模板
* 类和函数模板都可以是可变的
*/
template<typename... arg>
class BoTemplate;
BoTemplate<float> t1;
BoTemplate<int, long, double, float> t2;
BoTemplate<int, std::vector<double>> t3;
BoTemplate<> t4;
// 可变参数和非可变参数组合
template<typename T, typename... arg>
class BoTemplate;
BoTemplate<> t4; // Error
BoTemplate<int, long, double, float> t2; // OK
// 定义一个默认模板参数
template<typename T = int, typename... arg>
class BoTemplate;
19 模板别名 Template Alias
template<class T> class Dog { /* ... */ };
template<class T>
using DogVec = std::vector<T, Dog<T>>;
DogVec<int> v; // 同: std::vector<int, Dog<int>>
20 decltype
* 相当于GNU typeof
*/
const int& foo(); // 声明一个函数foo()
decltype(foo()) x1; // 类型是const int&
struct S { double x; };
decltype(S::x) x2; // x2类型double
auto s = make_shared<S>();
decltype(s->x) x3; // x3类型double
int i;
decltype(i) x4; // x4类型int
float f;
decltype(i + f) x5; // x5类型float
// decltype对于模板泛型编程非常有用
template<type X, type Y>
void foo(X x, Y y) {
...
decltype(x+y) z;
...
}
// 如果返回值要使用decltype?
template<type X, type Y>
decltype(x+y) goo(X x, Y y) { // 错误：x 和 y 未定义
return x + y;
}
// auto和decltype组合实现具有尾随返回类型的模板
template<type X, type Y>
auto goo(X x, Y y) -> decltype(x+y) {
return x + y;
}