Wow C++11
什么是C++11？
一句话C++11是最新的C++标准，在2011年发布，所以叫C++11。在新的标准出现前，我们一直在用的是C++98，可想而知这份标准是1998年发布的，之后再2003年最过小的修改发布了C++03。C++之父说C++11就像一门全新的语言，这份标准孕育了10年之久，是它的匠心之作。听起来C++11很牛，那它带来了哪些特性呢？让我从一个普通的不能再不普通的程序员角度去解读。
从哪里能了解到C++11
-
维基百科C+11
-
C++11 FAQ http://www.stroustrup.com/C++11FAQ.html
-
买第五版的《C++ primer》，用C++11重新编写。（我看的就是这个）
-
还有一些关于C++11的书是英文版的，《C++11程序设计》第四版（C++之父写的），《C++标准库：自学教程与参考手册》第二版。
-
还有网络上关于C++11特性的闲言琐语。
看过之后还能记住的C++11特
- 万能关键字auto
但我们定义一个类型时，应该首先使用它，短小方便。特别是配合STL中的容器使用时让人感觉到得心应手。
auto int_variable = 12;
auto double_variable = 12.5;
auto int_ptr = &int_variable;
std::vector<int> stl_vector = { 1, 2, 3 }; // 初始化列表
auto beg = stl_vector.begin();// 为迭代器类型
auto end = stl_vector.end();
auto stl_vector2(stl_vector);
- 自动类型推导decltype。
它可以推导出变量，表达式，函数指针的类型。
decltype (stl_vector) stl_vector3;
int(*ptr_compare) (int*, int*)=Compare; //指向Compare
decltype(Compare) ptr_compare2;
/*auto和decltype配合使用*/
template<class T1, class T2>
auto Min(T1 t1, T2 t2)->decltype(t1+t2)
{
return (t1 < t2 ? t1 : t2);
}
- 列表初始化
列表初始化统一了C++的初始化方式，当初始化对象或者给对象赋新值时。
/*变量列表初始化*/
int c{ 0 };
double d = { 0.65 };
auto s = { "hello,world! " };
/*容器列表初始化*/
std::list<int> set= {1,2,3};
decltype(set) set2{ set };
/*类中变量列表初始化*/
class Object
{
public:
Object() :a{ 0 }, b{0.0}{}
private:
int a;
double b;
};
- 范围for循环
/*复制容器中的元素*/
for (auto e : set)
{
std::cout << e << "\t";
}
/*引用容器中的元素*/
for (auto & e : set2)
{
e = 0;
std::cout << e << "\t";
}
/*应用字符串*/
for (auto e : str)
{
std::cout << e << "\t";
}
- constexpr变量
如果你认定变量是一个常量表达式，那就把它声明成constexpr类型。编译器会判断它是否为一个常量。constexpr还可用来定义常量函数。Constexpr函数的参数和返回值必须是字面值类型，函数体内只有一条return语句。
/*constexpr变量*/
constexpr int iconst = 25;
constexpr double dconst = 0.25;
/*constexpr 函数*/
constexpr int new_sz(){ return 42; }
constexpr size_t scale(size_t cnt) { return new_sz()*cnt; }
int arr[scale(2)];
- 类型别名声明
新标准使用using声明类型别名，相比于typedef来说，using有更强的灵活性，类型中可以模板typdef不行。
using ivec = std::vector<int>;
using citer = std::vector<int>::const_iterator;
- 类中的变量初始化
/*类内初始化，内置类型和自定义类型*/
-
class Screen
{
public:
Screen() = default;
using pos = std::string::size_type;
Screen(pos ht, pos wd, char c) :height(ht), width(wd), contents(ht*wd,c)
{}
private:
pos cursor = 0;
pos height = 0, width = 0;
std::string contents;
};
class WindowMsg
{
public:
private:
std::vector<Screen> screens{ Screen(24, 80, ' ') };
std::string window_name{"hello world"};
double a = 1.0;
};
-
类中的default、delete、override和final
/*抽象类*/
class Shape
{
public:
Shape() = default;
Shape(const Shape& shape) = delete;
Shape& operator=(const Shape& shape) = delete;
virtual void Draw() const = 0;
private:
};
/*具体类*/
class Circle:public Shape
{
public:
Circle(double new_radius) :radius(new_radius){}
virtual void Draw() const override final{}
private:
double radius=0.5;
};
-
nullptr指针
更安全，没什么好说的。使用NULL有时候会出现问题。
-
智能指针
智能指针是最应该去学习的特性，一句话智能指针自动内存管理，减少内存泄露的可能性。两种指正指针，shared_pr和unique_ptr。shared_ptr用于需要共享对象的时候，其删除器类型时运行时绑定的，只需reset时候传递给它一个可调用对象。（可调用对象包含，函数指针，lamda表达式，重载了调用运算符的类的对象）unique_ptr在编译时绑定，因此需要在创建时指定其类型。一般能使用静态对象就不动态创建，当需要管理对象的生存期时，首先考虑使用unique_ptr。如果多个类要共享成员那么使用shared_ptr。
std::shared_ptr<Circle> circle_ptr std::make_shared<Circle>(Circle(5));
std::unique_ptr<Circle> circle_ptr2{ new Circle(5)};
class Foo;
template<typename T>
std::shared_ptr<Foo> Factory(T arg)
{
return make_shared<Foo>(arg);
}
-
标准库move函数
获得绑定到左值的右值引用，左值位于等号的左边，右值位于等号右边。变量既是左值又是右值。常量表达式是右值。右值引用智能绑定到临时对象上，由此可知它所引用的对象将要被销毁，该对象没有其他用户。
int &&rr1 = 42;
int && rr3 = std::move(rr1);
-
lamda表达式
lamda是C++11的重头戏，lamda表达式是匿名类的匿名对象，可用作函数参数，可配合STL算法使用，可以用函数指针调用。Lamda表达式形如[捕获列表]（函数参数）->返回值{函数体}
/*函数指针调用lamda*/
auto f = []{return 42; };
std::cout << f() << "\n";
/*配合STL算法使用*/
std::vector<std::string> words = {"helllo","world","c++11"};
std::stable_sort(words.begin(), words.end(),
[](const std::string& s1, const std::string& s2){return s1.size() < s2.size(); });
const std::size_t sz = 3;
auto wc = std::find_if(words.begin(), words.end(),
[sz](const std::string& s){return s.size()>=sz; });
std::for_each(words.begin(), words.end(), [](const std::string& s){std::cout << s<<" "; });
/*指定lamda返回类型*/
std::transform(stl_vector.begin(), stl_vector.end(), stl_vector.begin(),
[](int i)->int{if (i < 0) return -i; else return i; });
-
标准库bind函数
bind可以理解为函数适配器，它接受一个可调用对象，生成一个新的可调用对象来适应原对象的参数列表。
/*-1是占位符，表示check6只有一个形参*/
auto check6 = std::bind(CheckSize, std::placeholders::_1, 6);
std::string s = { "hello" };
bool b1 = check6(s);
auto wc = std::find_if(words.begin(),words.end(),std::bind(CheckSize,std::placeholders::_1,sz));
-
标准库的begin和end函数
/*begin和end是STL的*/
for (auto it = std::begin(stl_vector); it != std::end(stl_vector); ++it)
{
std::cout << *it << "\t";
}
-
标准库initializer_list
为编写形参类型相同数量不同的函数
void ErrorMsg(std::initializer_list<std::string> il)
{
for (auto e : il)
{
std::cout << e << " ";
}
std::cout << std::endl;
}
ErrorMsg({ "funcionX", "okay" });
-
标准库加入的容器array，forward_list，unordered_set，unordered_map
分别为定长数组，单链表，哈希表实现的set，哈希表实现的map。
namespace std
{
template<>
struct hash<SalesData>
{
typedef size_t result_type;
typedef SalesData argument_type;
size_t operator()(const SalesData& s) const;
};
/*自定义哈希函数*/
size_t hash<SalesData>::operator()(const SalesData& s) const
{
return hash<string>()(s.book_no) ^ hash<unsigned>()(s.units_sold) ^ hash<double>()(s.revenue);
}
}
std::unordered_multiset<SalesData> sales_data;
-
默认模板参数
template<typename T=int>
std::shared_ptr<Foo> Factory(T arg)
{
return make_shared<Foo>(arg);
}
-
可变参数模板
/*可参数递归打印*/
template<typename T>
std::ostream& Print(std::ostream& os, const T& t)
{
return os << t;
}
template<typename T, typename...Args>
std::ostream& Print(std::ostream& os, const Args&...rest)
{
os << t << ",";
return Print(os, rest...);
}
那些忘记的但却很有用的C++11特性
-
列表初始化返回值
std::vector<std::string> Process(const std::string& expected)
{
if (expected.empty())
return{};
else if (expected == "aucual")
return{ "hello ", "world " };
else
return{ "bingo" };
}
-
委托构造函数
说白了就是构造函数调用构造函数。
class SalesData
{
public:
SalesData(std::string s, unsigned cnt, double price) :book_no{ s }, units_sold{ cnt }, revenue{ price }
{}
SalesData() :SalesData("", 0, 0){}
SalesData(std::string s) :SalesData(s, 0, 0){}
friend class std::hash<SalesData>;
private:
std::string book_no;
unsigned int units_sold;
double revenue;
};
-
移动构造和移动赋值
class Hasptr
{
public:
/*复制构造*/
Hasptr(const Hasptr& p) :ps{ p.ps }, i{ p.i }{}
/*赋值操作符*/
Hasptr& operator=(const Hasptr& p);
/*移动构造*/
Hasptr(Hasptr&& p) :ps{ p.ps }, i{ p.i }{ p.ps = 0; }
/*移动赋值操作符*/
Hasptr& operator=(Hasptr&& rhs)
{
std::swap(*this, rhs); return*this;
}
private:
std::string * ps;
int i;
};
-
function类模板
std::function<int(int, int)> f1 = add;
std::function<int(int, int)> f2 = [](int i, int j){return i*j; };
-
随机数库
/*每次调用都生成不同随机数*/
std::vector<unsigned> GenRand()
{
static std::default_random_engine e;
static std::uniform_int_distribution<unsigned> u(0, 9);
std::vector<unsigned> ret;
for (size_t i = 0; i < 100; ++i)
ret.push_back(u(e));
return ret;
}
/*实随机数*/
std::default_random_engine e;
std::uniform_real_distribution<double> u(0, 1);
for (size_t i = 0; i < 10; ++i)
std::cout << u(e) << "";
/*正太分布的随机数*/
std::normal_distribution<>n(4, 1.5);// 4 均值 1.5标准差
如何使用C++11
-
微软编译器支持最全的是vs2013。
-
Clang几乎全部支持，Clang是一款开源编译器。
-
G++也支持的非常全面。
具体情况参考http://www.oschina.net/translate/c11-compiler-support-shootout-visual-studio-gcc-clang-intel
