本文内容来源于我在SDCC2015上的演讲，演讲的主题是关于C++11/14的新特性，通过一些案例和旧标准C++98/03做了对比，展示了新特性在解决问题时的优雅与强大。
C++11/14相比以往的C++98/03在很多方面做了简化和增强，尤其是在泛型编程方面，让C++的泛型编程的威力变得更加强大，本文将用三个案例来介绍C++11相比C++98/03如何以一种更灵活、更简洁和更泛化的方式去解决问题。
检查成员函数是否存在
有这样一个场景，需要判断某个类型是否存在成员函数foo，如果存在就调用这个成员函数，否则就执行默认的函数，下面是伪代码。 - template<typename T>
- void foo(const T& t)
- {
- if (t has foo)
- t.foo();
- else
- default();
- }
- template<typename T>
- struct has_member_foo
- {
- template<typename U, void(U::*)()> struct SFINAE {};
-
- template<typename U> static char check(SFINAE<U, &U::foo>*);
- template<typename U> static int check(...);
-
- static const bool value = sizeof(check<T>(0)) == sizeof(char);
- };
元函数has_member_foo中定义了一个辅助结构体SFINAE和重载函数check，辅助结构体在模板实例化的时候可以确定类型U是否存在fooh函数；check重载函数利用了SFINAE（substitution is not an error）特性，编译器会根据重载决议选择最合适的函数，当辅助结构体实例化成功时，第一个check函数的优先级更高，如果实例化失败则会选择优先级最低的check(...)函数，这两个重载函数的返回类型不相同，我们根据函数返回类型的size就可知道类里是否存在成员函数foo了。下面是测试代码。
- struct MyStruct
- {
- void foo() { }
- };
- static_assert(has_member_foo<MyStruct>::value, "true");
- static_assert(has_member_foo<int>::value, "false");
- template<typename T>
- struct has_member_foo11
- {
- private:
- template<typename U> static auto check(int) ->
- decltype(std::declval<U>().foo(), std::true_type());
-
- template<typename U> static std::false_type check(...);
- public:
- enum { value = std::is_same<decltype(check<T>(0)),
- std::true_type>::value };
- };
虽然C++98/03和C++11两种写法都可以推断出是否存在成员函数foo，但是当情况稍微发生一点变化时，就会出现一个问题，比如下面的代码。 - struct MyStruct
- {
- int foo() { }
- };
- static_assert(has_member_foo<MyStruct>::value, "false");
- static_assert(has_member_foo11<MyStruct>::value, "true");
- template<typename T, typename... Args>
- struct has_member_foo11
- {
- private:
- template<typename U> static auto check(int) -> decltype(std::declval<U>().foo(std::declval<Args>()...), std::true_type());
-
- template<typename U> static std::false_type check(...);
- public:
- enum { value = std::is_same<decltype(check<T>(0)), std::true_type>::value };
- };
测试代码：
- struct MyStruct
- {
- string foo() { return ""; }
- int foo(int i) { return i; }
- };
-
- static_assert(has_member_foo<MyStruct>::value, "true");
- static_assert(has_member_foo<MyStruct, int>::value, "true");
- #define HAS_MEMBER(member)\
- template<typename T, typename... Args>struct has_member_##member\
- {\
- private:\
- template<typename U> static auto Check(int) -> decltype(std::declval<U>().member(std::declval<Args>()...), std::true_type());\
- template<typename U> static std::false_type Check(...);\
- public:\
- enum{value = std::is_same<decltype(Check<T>(0)), std::true_type>::value};\
- };
- HAS_MEMBER(foo)
- HAS_MEMBER(func)
测试代码： - struct MyStruct
- {
- string foo() { return ""; }
- int func(int i) { return i; }
- };
-
- static_assert(has_member_foo<MyStruct>::value, "true");
- static_assert(has_member_func<MyStruct, int>::value, "true");
- template<typename T>
- typename std::enable_if<has_member_foo11<T, int>::value>::type testfun(T t) {
- cout << "has foo" << endl;
- }
-
- template<typename T>
- typename std::enable_if<!has_member_foo11<T, int>::value>::type testfun(T t) {
- cout << "has no foo" << endl;
- }
最终我们借助C++11完美地解决了编译期检查成员函数是否存在并且在编译期选择分支的问题，实现方式相比C++98/03更加简洁、灵活和通用。
函数缓存
为了优化程序性能我们经常使用缓存，比如某个函数非常耗时，频繁调用的时候性能会很低，这时我们就可以通过缓存来提高性能。先看看下面的代码。 - size_t fibonacci(size_t n)
- {
- return (n < 2) ? n : fibonacci(n - 1) + fibonacci(n - 2);
- }
-
- void test()
- {
- Timer t;
- size_t n = fibonacci(45);
- cout << n << " " << t.elapsed() << endl;
- }
- size_t fibonacci(size_t n)
- {
- return (n < 2) ? n : sugar(fibonacci2)(n - 1) + sugar(fibonacci2)(n - 2);
- }
- template <typename R, typename... Args>
- std::function<R(Args...)> sugar(R(*func)(Args...), bool needClear = false)
- {
- using function_type = std::function<R(Args...)>;
- static std::unordered_map<decltype(func), function_type> functor_map;
-
- if (needClear)
- return functor_map[func] = cache(func);
-
- if (functor_map.find(func) == functor_map.end())
- functor_map[func] = cache(func);
-
- return functor_map[func];
- }
- template <typename R, typename... Args>
- std::function<R(Args...)> cache(R(*func) (Args...))
- {
- auto result_map = std::make_shared<std::map<std::tuple<Args...>, R>>();
-
- return ([=](Args... args){
- std::tuple<Args...> t(args...);
- if (result_map->find(t) == result_map->end())
- (*result_map)[t] = func(args...);
-
- return (*result_map)[t];
- });
- }
图1 fibonacci函数缓存的过程
C++11实现的这个函数缓存相比传统的缓存方法来说有下面几个优点：
1．相比传统的缓存实现方式，它更通用，可以适应任何函数，无需为每一个被缓存函数定义专门的缓存对象。
2．更简洁，只需要一个sugar既可以实现缓存。
实现一个http router
http router是web服务器的一个核心模块，它会解析url，然后路由到正确的handler上，下面是cinatra框架（一个现代C++写的web framework）的用法。 - Cinatra app;
- app.route("/hello", [](Request& req , Response& res)
- {
- res.end("Hello ");
- });
-
- app.route("/hello/:name/:age", [](Request& req, Response& res,
- const std::string& a, int b)
- {
- res.end("Name: " + a + ", Age: " + boost::lexical_cast<std::string>(b));
- });
图2
如果想通过C++98/03来实现几乎是不可能完成的任务，但对于C++11来说却不是难题。
C++11的实现思路如下：
1. 解析url将参数分割，分割之后的字符串放到列表中{"hello", "test", "2"}；
2. 将列表中的参数转换为function的实参；
2-1. 将列表中的参数分别转换为function的实参。
2-2. 将转换后的实参一个一个保存到“容器”--tuple中。
2-3. 将tuple转换为函数实参。
3. handler调用。
实现的关键在于如何将分割的字符串一个一个转换为handler的实参，转换之后又如何实现调用。将字符串转换为handler的实参借助了function_traits，它可以获取函数每一个参数的类型，知道这个类型之后我们就可以将字符串转换为对应类型的值了，即函数实参。转换之后还要考虑保存的问题，因为函数实参的类型是不同的，普通的容器是无法保存不同类型的数据的，这里借助tuple来保存类型不同的实参。保存实参之后还需要完成函数调用，这里需要通过可变模版参数和tuple相互转换来实现函数调用。下面来看看实现的关键技术。
【字符串转换为对应的函数实参】
通过function_traits来获取函数参数个数和每个参数的类型，获取之后就可以调用boost.lexicast来将字符串转换为对应的参数值了，接下来将转换之后的参数放到tuple中，以备用于在下一步的函数调用。下面是实现的关键代码，完整的代码读者可以参考我github上的代码：https://github.com/kxjhcs/cosmos/blob/master/router.hpp。
- template<typename Function, size_t N = 0, size_t M = function_traits<Function>::arity>
- struct invoker
- {
- template<typename Args>
- static inline void apply(const Function& func, token_parser & parser, Args const & args)
- {
- typedef typename function_traits<Function>::template args<N>::type arg_type;
- router::invoker<Function, N + 1, M>::apply(func, parser,
- std::tuple_cat(args, std::make_tuple(parser.get<arg_type>())));
- }
- };
-
- template<typename Function, size_t M>
- struct invoker<Function, M, M>
- {
- template<typename Args>
- static inline void apply(const Function& func, token_parser &, Args const & args)
- {
-
- call(func, args);
- }
- };
【实现函数调用】
在前面我们已经将字符串转换为实参并保存到tuple中了，接下来我们需要将tuple转换为函数实参列表，这需要通过将tuple转换为可变模版参数，下面是实现的关键代码。 - template<typename F, int ... Indexes, typename ... Args>
- static void call_helper(F f, IndexTuple<Indexes...>, const std::tuple<Args...>& tup)
- {
- f(std::get<Indexes>(tup)...);
- }
-
- template<typename F, typename ... Args>
- static void call(F f, const std::tuple<Args...>& tp)
- {
- call_helper(f, typename MakeIndexes<sizeof... (Args)>::type(), tp);
- }
C++11实现的http router不仅仅可以用于http服务器端的路由，还可以实现rpc和mvc框架的路由，所以用C++11去做web开发也是完全可以的。
总结
本文先通过介绍检查成员函数是否存在，比较了C++98/03和C++11的实现差异，C++11的实现无疑更加简洁和通用，完美地解决了问题，体现了现代C++解决问题的极致之美。接着介绍了如何实现一个通用的函数缓存，仅仅一个泛化的函数既可以实现缓存任意函数，体现了现代C++的简洁之美和泛化之美。最后展示了现代C++在做web开发的时候如何实现灵活的路由，完成了之前C++98/03几乎不可能完成的任务，体现了现代C++的威力，不仅仅是生产力的巨大提升。
现代C++仍然在发展完善当中，除了近年出现的C++11/14，未来的C++17/20标准正在规划制定当中。C++17将引入更多地激动人心的特性，有并行、并发、网络库、协程、modules和concepts等等，这将是C++发展史上的一座里程碑。
现代C++先天的性能优势与后天的效率（现代、快速开发）优势，除了传统的服务端、游戏、安全、嵌入式和音视频等领域外，用来做移动互联网、云平台和大数据分析正当其时。 |
