1.=default 通常对于 默认构造函数，拷贝构造函数，拷贝赋值构造函数，析构函数，+ 对应的move 构造函数，如果自定义了改函数则编译器不会自动产生该构造函数。 但是为了减轻开发负担在需要默认构造函数时可以= default指定让编译器帮忙产生该类型构造函数，如果不想要该类型构造函数 可以=delete。 =default,=delete 可以在类体内部和外部 inline widget& widget::operator=(const widget&) = default; =delete 可以用在函数提上表示禁止重载某一类函数
bool isLucky(int number); // original function bool isLucky(char) = delete; // reject chars bool isLucky(bool) = delete; // reject bools bool isLucky(double) = delete; // reject doubles and float可以用来指定禁止某类模版偏特化
class Widget { public: template<typename T> void processPointer(T* ptr) { … } }; template<> void Widget::processPointer<void>(void*) = delete; // still public, but deleted参考： 之前的实现形式时将该方法或特化声明在private中但不实现。 想使某一类class不自动产生 拷贝构造，拷贝赋值，可以定义一个uncopyable class 将其 拷贝构造，拷贝赋值放在private中可以避免其子类实现默认或非默认拷贝构造，拷贝赋值构造函数。 http://www.cnblogs.com/xinxue/p/5503836.html 2. using
//c++98 typedef std::unique_ptr<std::unordered_map<std::string,std::string>> Uptrmap; //same with C++ 11 using Uptrmap = std::unique_ptr<std::unordered_map<std::string,std::string>>; typedef void (*Fn) (int, const std::string&); //same with using Fn = void (*)(int, const std::string&); //容易识别Fn为其别名 //以下为区别 typedef cannot be a template template <typename T> using Vec = std::vector<T,Myalloc<T>> Vec<int> col;//可以编译通过 template<typename T> typedef std::vector<T,Myalloc<T>> Vec;//编译失败,error: a typedef cannot be a template //只能 typedef std:::vector<int,Myalloc<int>> Vec; //或者 template <typename T> clss Vec { typedef std::vector<T,MyAalloc<T>> type; }; Vec<int>::type col;//用在模板类内部或者进行参数传递时必须加上typename 用以指定为类型。 //即typedef不能直接作为模板使用 using value_type = T;//用在类内部代替typedef T value_type;使用 using 别名后不能特化也不能偏特化 1.typedefs don’t support templatization, but alias declarations do. 2.Alias templates avoid the “::type” suffix and, in templates, the “typename” prefix often required to refer to typedefs. 3.C++14 offers alias templates for all the C++11 type traits transformations. 参考： https://zhuanlan.zhihu.com/p/21264013 3.noexcept 从语法上讲，noexcept修饰符有两种形式，一种就是简单地在函数声明后加上noexcept关键字。比如： void excpt_func() noexcept;
另外一种则可以接受一个常量表达式作为参数，如下所示： void excpt_func() noexcept (常量表达式);
常量表达式的结果会被转换成一个bool类型的值。该值为true，表示函数不会抛出异常，反之，则有可能抛出异常。这里，不带常量表达式的noexcept相当于声明了noexcept(true)，即不会抛出异常。 noexcept形如其名地，表示其修饰的函数不会抛出异常。不过与throw()动态异常声明不同的是，在C++11中如果noexcept修饰的函数抛出了异常，编译器可以选择直接调用std::terminate()函数来终止程序的运行，这比基于异常机制的throw()在效率上会高一些。这是因为异常机制会带来一些额外开销，比如函数抛出异常，会导致函数栈被依次地展开（unwind），并依帧调用在本帧中已构造的自动变量的析构函数等。
#include <iostream> using namespace std; void Throw() { throw 1; } void NoBlockThrow() { Throw(); } void BlockThrow() noexcept { Throw(); } int main() { try { Throw(); } catch(...) { cout << "Found throw." << endl; // Found throw. } try { NoBlockThrow(); } catch(...) { cout << "Throw is not blocked." << endl; // Throw is not blocked. } try { BlockThrow(); // terminate called after throwing an instance of 'int' } catch(...) { cout << "Found throw 1." << endl; } } //BlockThrow() 会直接 terminate不会被catch 而noexcept作为一个操作符时，通常可以用于模板。比如：
template <class T> void fun() noexcept(noexcept(T())) {}这里，fun函数是否是一个noexcept的函数，将由T()表达式是否会抛出异常所决定。这里的第二个noexcept就是一个noexcept操作符。当其参数是一个有可能抛出异常的表达式的时候，其返回值为false，反之为true（实际noexcept参数返回false还包括一些情况，这里就不展开讲了）。这样一来，我们就可以使模板函数根据条件实现noexcept修饰的版本或无noexcept修饰的版本。从泛型编程的角度看来，这样的设计保证了关于“函数是否抛出异常”这样的问题可以通过表达式进行推导。因此这也可以视作C++11为了更好地支持泛型编程而引入的特性。
比如在C++98中，存在着使用throw()来声明不抛出异常的函数。
template<class T> class A { public: static constexpr T min() throw() { return T(); } static constexpr T max() throw() { return T(); } static constexpr T lowest() throw() { return T(); } ... 而在C++11中，则使用noexcept来替换throw()。 template<class T> class A { public: static constexpr T min() noexcept { return T(); } static constexpr T max() noexcept { return T(); } static constexpr T lowest() noexcept { return T(); } ... 又比如，在C++98中，new可能会包含一些抛出的std::bad_alloc异常。 void* operator new(std::size_t) throw(std::bad_alloc); void* operator new[](std::size_t) throw(std::bad_alloc); 而在C++11中，则使用noexcept(false)来进行替代。 void* operator new(std::size_t) noexcept(false); void* operator new[](std::size_t) noexcept(false); 当然，noexcept更大的作用是保证应用程序的安全。比如一个类析构函数不应该抛出异常，那么对于常被析构函数调用的delete函数来说，C++11默认将delete函数设置成noexcept，就可以提高应用程序的安全性。 void operator delete(void*) noexcept; void operator delete[](void*) noexcept;特别的 you need inform C++(specially std::vector,deque)that your move constructor and destructor does not throw. Then the move constructor will be called when vector grows. if the constructor is not noexcept std::vector cannot use it. since then it cannot ensure the exception guranteesdemnaded by the standard. 参考 ： http://book.2cto.com/201306/25351.html
4.override 描述：override保留字表示当前函数重写了基类的虚函数。
目的：1.在函数比较多的情况下可以提示读者某个函数重写了基类虚函数（表示这个虚函数是从基类继承，不是派生类自己定义的）；2.强制编译器检查某个函数是否重写基类虚函数，如果没有则报错。
用法：在类的成员函数参数列表后面添加该关键字既可。
例子： class Base ｛ virtual void f(); }；
class Derived : public Base { void f() override; // 表示派生类重写基类虚函数f void F() override;//错误：函数F没有重写基类任何虚函数 }；
注意：override只是C++保留字，不是关键字，这意味着只有在正确的使用位置，oerride才启“关键字”的作用，其他地方可以作为标志符（如：int override；是合法的）。
相关：override还有一个姊妹保留字final。 参考： http://www.cnblogs.com/kyxyes/p/3995937.html
5.final 用在类上表示不能被继承，用在 virtual func上表示不能被重写。 参考： http://blog.csdn.net/nighsen/article/details/6363370
6.decltype let compiler find the type of an expression. semantic same with pyhon type(),semantic typeof() 用法1 declare return type
template <typename T1, typename T2> auto add(T1 a, T2 b)->decltype(a+b) {}用法2。用于meta programming
typedef typename decltype(obj)::iterator iType;用法3.use to pass the type of lambda func
auto cmp = [](const Person& p1, const Person& p2){ return p1.name() < p2.name(); } //此时想获得lambda type 用于设定set的cmp func std::set<Person, decltype(cmp)> coll(type);define inline function can be used as a parameter or local obj. format: []()mutalbe throwspec ->retType{} lambda have no default constructor and no assignment operator 1. [] 不截取任何变量 2. [&} 截取外部作用域中所有变量，并作为引用在函数体中使用 3. [=] 截取外部作用域中所有变量，并拷贝一份在函数体中使用 4. [=, &foo] 截取外部作用域中所有变量，并拷贝一份在函数体中使用，但是对foo变量使用引用 5. [bar] 截取bar变量并且拷贝一份在函数体重使用，同时不截取其他变量 6. [x, &y] x按值传递，y按引用传递 7. [this] 截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。 C++ 14以后可以使用 template
template <typename T> a = [=](const T& n) {cout << T << endl;} a<int>(1)注意lmabda在没有捕获外界变量的情况下可以直接转换为函数指针，一旦捕获了就只能转换function<…> obj; 参考： http://blog.csdn.net/booirror/article/details/26973611 http://blog.csdn.net/u010102854/article/details/52857312 区别 function http://blog.163.com/lvan100@yeah/blog/static/6811721420127511289750/ 补充 ： 将析构函数定义为私有意味着只能在堆上new对象并且使用者需要自己负责destroy对象。这是由于c++语言为静态语言在编译时需要对所有静态函数检查可入性，在栈上创建的不具有可入性。 参考：http://blog.csdn.net/zyq522376829/article/details/48438037
补充 求最大值两种方式1.initializer-list
template<typename _Tp> inline _Tp max(initializer_list<_Tp> __l) { return *max_element(__l.begin(),__l.end()); } template<typename _ForwardIterator> inline _ForwardIterator max(_ForwardIterator __first,_ForwardIterator __last) { return __max_element(__first,__last,__iter_less_iter()); } template<typename _ForwardIterator, typename _Compare> _ForwardIterator _max_element(_ForwardIterator __First, _ForwardIterator __Last,_Compare __comp){ if(__first == __last) return __first; ForwardIterator __result = __first; while(++__first != __last) if (__comp(__result,__first)) __result = __first; return __result; } inline _Iter_less_iter(){ return _Iter_less_iter(); } variadic template parameters int maximum(int n){ return n; } template<typename... Args> int maximum(int n, Args... args){ return std::max(n,maximum(args...)); }print tuple
template <typename... Args> ostream& operator << (ostream& os, const tuple<Args...>& t){ os << "["; PRINT_TUPLE<0,sizeof...(Args),Args...>::print(os,t); return os << "]"; } template<int IDX,int MAX，typename... Args> struct PRINT_TUPLE{ static void print(ostream& os, const tuple<Args...>& t ){ os << get<IDX>(t) << (IDX+1)==MAX?"":","; PRINT_TUPLE<IDX+1,MAX,Args...>(os,t); } }; template <int MAX, typename...Args> struct PRINT_TUPLE<MAX,MAX,Args...>{ static void print (std::ostream& os,const tuple<Args...>& t){} };//end statment## 1. make 语法 参考： http://www.kuqin.com/shuoit/20150225/344882.html http://lpn520.iteye.com/blog/774919 2.swap 参考： http://www.cnblogs.com/xloogson/p/3360847.html 3.exception 参考： http://blog.csdn.net/zkreats/article/details/50550786 http://www.cnblogs.com/crazyacking/p/4951638.html 4.set实现 set 是一个rb_tree 的adaptor具体实现如GNU4.9下
template <typename _Key, typename _Compare = s s td::less<_Key>, typename _Allloc = std::allocator<_Key>> class set { typedef typename _Alloc::value_type _Alloc_value_type; public: typedef _Key key_type; typedef _Key value_type; typedef _Compare key_compare; typedef _Compare value_compare; typedef _Alloc allocator_type; private: typedef typename __gnu_cxx::__alooc_traits<_Alloc>::template rebind<_Key>::other _Key_alloc_type; typedef _Rb_tree<key_type, value_type, Identity<value_type>, key_compare, _Key_alloc_type> _Rep_type; _Rep_type _M_t;//adaptor define rb_tree typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits; public: //Iterator relaited typedef typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Rep_type::const_iterator iterator; typedef typename _Rep_type::const_iterator const_iterator; typedef typename _Rep_type::const_reverse_iterator reverse_iterator; typedef typename _Rep_type::const_reverse_ierator const_reverse_iterator; typedef typename _Rep_type::size_type size_type; typedef typename _Rep_type::difference_type difference_type; set():_M_t(){} explicit set(const _Compare& __comp, const allocator_type& __a = allocator_type()) :_M_t(__comp,__key_alloc_type(__a)){} .... //C++11 set(set&& __x) noexcept(is_nothrow_copy_constructible<_Compare>::value) :_M_t(std::move(__x._M_t)){} set(initializer_list<value_type> __l, const allocator_type& __a = allocator_type()) :_M_t(__comp,_Key_alloc_type(__a)) //所有操作均是调用rb_tree内来实现 };使用：
#include <iostream> #include <set> bool fncomp (int lhs, int rhs) {return lhs<rhs;} struct classcomp { bool operator() (const int& lhs, const int& rhs) const {return lhs<rhs;} }; int main () { std::set<int> first; // empty set of ints int myints[]= {10,20,30,40,50}; std::set<int> second (myints,myints+5); // range std::set<int> third (second); // a copy of second std::set<int> fourth (second.begin(), second.end()); // iterator ctor. std::set<int,classcomp> fifth; // class as Compare bool(*fn_pt)(int,int) = fncomp; std::set<int,bool(*)(int,int)> sixth (fn_pt); // function pointer as Compare return 0; }参考：http://www.cplusplus.com/reference/set/set/set/ http://blog.csdn.net/jinzhilong580231/article/details/8666877 5.remove_if meta programming http://blog.csdn.net/tianshuai1111/article/details/7674327
partial_sum 实现Fib
array<int, 10> input;//不会默认初始化 array<int，10> result; for(int i = 0; i < input.size();i++){ input[i] = i;//replace(iv.begin(),iv.end(),6,3);初始化可以用replace result[i] = 0; } partial_sum(input.begin(),input.end(),result.begin(),plus2<int>());//accumulate() int my_sum(int a, int b){return a + b;}模板实现编译其期间Fib
template<int N> class Fib { public: enum{Result = Fib<N-1>::Result + Fib<N-2>::Result}; }; template<> Fib<1> class Fib { enum{Result = 1}; }; template<> Fib<0> class Fib{ enum{Result = 0}; }累加vector使用lambda
std::for_each(vector.begin(), vector.end(), [&] (int n) { sum_of_elems += n; });补充python 实现fib http://blog.csdn.net/buaa_shang/article/details/8283309
remove_if 使用
// remove_if example #include <iostream> // std::cout #include <algorithm> // std::remove_if bool IsOdd (int i) { return ((i%2)==1); } int main () { int myints[] = {1,2,3,4,5,6,7,8,9}; // 1 2 3 4 5 6 7 8 9 // bounds of range: int* pbegin = myints; // ^ int* pend = myints+sizeof(myints)/sizeof(int); // ^ ^ pend = std::remove_if (pbegin, pend, IsOdd); // 2 4 6 8 ? ? ? ? ? // ^ ^ std::cout << "the range contains:"; for (int* p=pbegin; p!=pend; ++p) std::cout << ' ' << *p; std::cout << '\n'; return 0; }6.虚继承，多继承 https://www.oschina.net/translate/cpp-virtual-inheritance http://blog.csdn.net/wangxingbao4227/article/details/6772579 http://blog.csdn.net/u013630349/article/details/47057929
7.memcpy（），memset（），memcmp() 注意区分POD（plain old data） http://www.cnblogs.com/jingliming/p/4737409.html http://www.cnblogs.com/mayingkun/p/3234137.html
模版内模版 非类型实参参考：http://www.cnblogs.com/gw811/archive/2012/10/25/2738929.html http://www.cnblogs.com/gw811/archive/2012/10/25/2736224.html重点参考http://www.cnblogs.com/assemble8086/archive/2011/10/02/2198308.html
