中国C++大会招募讲师

2017年8月29日 qicosmos 3条评论

大会介绍

从1985年由Bjarne Stroustrup在贝尔实验室发明以来，C++作为一门系统级语言，早已超越一门编程语言的影响。由其构建的庞大的系统级软件，已经成为当今世界IT与互联网应用的关键支撑。秉承“全球专家、连接智慧”的理念，我们特邀众多C++和系统软件领域的海内外技术领袖与一线工程实战专家，于2017年11月17日-18日在北京举办“全球C++及系统软件技术大会”。

大会的主办方是博览网, purecpp是大会的合作方之一，purecpp社区创始人祁宇作为大会的技术出品人之一，负责招募国内外的优秀讲师。这将是purecpp社区参与举办一场高水平、国际化的C++大会，大会的形式和内容将会与cppcon类似但又具备中国特色，如果你不能亲自前往美国参加cppcon那么就不要错过这次在中国举行的C++大会。希望参会的观众可以在官网购票。

大会主题

C++ 14/17揭秘
高性能与高可用
框架与库应用
多线程与并发编程
分布式与网络应用
设计模式与实践
低延迟与嵌入式
行业案例研究

讲师报名

不管你是什么学历、什么公司、什么国家，只要你有和C++有关的创新的idea，你就可以报名！
讲师报名需要填一个报名表，类似于cppcon，你需要提供演讲者的信息、演讲的摘要信息和主要内容。如果你有很有说服力的证明材料就更好了，证明材料是能证明你演讲内容的代码或之前的ppt。

讲师报名阶段一个月左右，报名阶段结束之后就是评审阶段。采取的是专家评审方式，由两名中国专家和两名外国专家对演讲内容进行评审，评审通过的讲师就可以参会了。无论评审通过与否我们都会告知报名者结果。

这次大会的外国讲师和中国的讲师比例大约为1:2，竞争也会比较激烈，因此填一份好的讲师报名表很重要。

希望中国的C++高手和天才们赶紧报名成为讲师，中国的C++大会将因你而不同！

讲师报名表

中国C++大会讲师报名表

C++17

C++17中的deduction guide

2017年8月11日 qicosmos 4条评论

deduction guide可以根据参数自动推导出对应的类型，这可以让我们的代码变得更加简洁，看下面的写法：

std::pair p(1, 1.5); //推导为std::pair<int, double>

std::tuple t(1, 2, 2.5); //推导为std::tuple<int, int, double>

std::vector v{1,2,3}; //推导为std::vector<int>

std::array ar{1,2}; //推导为std::array<int, 2>

从上面的例子中可以看到隐式的deduction guide可以让我们的代码写得更加简洁，不用再写模版参数等细节了，有一种写动态语言的感觉。

除了隐式的deduction guide，还有一种显式的deduction guide，作用和隐式deduction guide差不多，也是让写法变得更简洁。下面是显式deduction guide的例子：

template<typename T>

struct Dummy { T t; };

Dummy(double) -> Dummy<double>;

Dummy(std::pair<int, int>) -> Dummy<std::pair<int, int>>;

void test()

{

Dummy dm{2.5};

Dummy<int> dm1{2};

std::pair<int, int> pr{1,2};

Dummy dm2{pr};

}

如果没有通过Dummy(double) -> Dummy显式地做deduction guide，我们在定义Dummy的时候是需要显式带着模版参数的。也许有人觉得就为了省掉一个模版参数却要多定义一个显式的deduction guide，似乎还变麻烦了。其实显式deduction guide主要是为了简化定义可变模版参数的变量，之前介绍过通过std::visit来访问variant, 通过auto lambda和if constexpr来访问variant的做法不是很方便，我们可以通过可变模板和显式deduction guide的来实现一个访问variant的更好的方法。

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };

template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

void visit_variant()

{

std::variant<int, double, std::string> v, w;

v = 1;

w = "abc";

std::vector<std::variant<int, std::string>> vec;

vec.push_back(v);

vec.push_back(w);

for (auto& it: vec) {

std::visit(overloaded {

[](auto arg) { std::cout << arg << '\n'; },

[](double arg) { std::cout << std::fixed << arg << '\n'; },

[](const std::string& arg) { std::cout << arg << '\n'; },

}, it);

}

上面的例子中先通过可变模版参数的CRTP获得参数的operater()，然后通过显式的deduction guide来省去定义含可变模版参数overloaded的变量时，需指定变参类型的麻烦，让代码变得非常简洁。这里不仅仅是让代码变得简洁，还直接避免了一个难题，因为overloaded参数是lambda，它是一个匿名类型，你无法获取lambda的类型并实例化overloaded模版。

社区活动

Modern C++ Meta-programming组织今天成立

2017年8月9日 qicosmos 4条评论

purecpp社区在6月份的时候就发出加入Modern C++ Meta-programming组织的邀请, 陆续收到十几份typelist的实现，大部分实现都挺不错的，思路各异，殊途同归。现在成立Modern C++ Meta-programming组织的时机已经成熟，专门的qq群已经建立，后面可能会将大家实现的typelist代码在社区公开出来。
Modern C++ Meta-programming组织的主要目标是研究modern c++的元编程，新的技术，新的思想，新的编程范式以及应用。
如果有想加入Modern C++ Meta-programming组织的朋友请按之前邀请中的要求发送typelist源码到社区邮箱purecpp@163.com，经审核通过之后才可以加入组织。

技术探讨、社区精华

一个C++14模板元实现的深度学习神经网络模板类，支持任意层数

2017年8月3日杨清风发表回复

构造编译期矩阵以及数据传递代码，headonly
搜遍了github，在模板元这块机器学习还是空白，正好是个填补，我接下来会逐渐丰富这个库（倒是有几个模板元数学运算库，都很简陋）
大量的矩阵运算用模板元进行有几个让人非常惬意的优势，也发觉模板元其实很适合这种编程
（不知道是否唯有C++才有的优势，数学专用语言不算在内，比如m、r这些）：
1、永远不用担心数组越界，也不用写检查数组越界的代码
2、矩阵运算不用检查行列是否匹配，行列的要求通过模板函数参数就能限定了
3、快，只有cpper才懂的快
代码在这里 https://github.com/bowdar/DeepLearning

先看使用方法，过程极其简单

#include "NeuralNetwork.hpp"

int main()

{

/// 1. 创建一个输入层，两个隐含层，一个输出层的神经网络

mtl::BPNeuralNet<20, 30, 20, 2> mynn;

/// 2. 初始化

mynn.init(0.001, 0.8);

/// 3. 输入

mtl::Matrix<double, 1, 20> inMatrix;

mtl::Matrix<double, 1, 2> outMatrix;

/// 录入你的矩阵数据...

/// 4. 训练

mynn.train(inMatrix, outMatrix, 100);

/// 5. 仿真

mynn.simulate(inMatrix, outMatrix);

}

模板类的申明，开头是用来迭代整形模板参数的UnpackInts，根据Index取值，没有使用TypeList
代码使用到的矩阵模板类和数学公式就没贴了

/// Unpack ints from variadic template

/// The compile-time integer array, following RCInt is reverse of ints e.g.

/// G{5, 3, 2, 4, 2} the (0, G) is 2 and (4, G) is 5

template<int N, int... Tail>

struct RCInt;

template<int N, int Tail>

struct RCInt<N, Tail>

{

enum { value = Tail };

};

template<int N, int Head, int... Tail>

struct RCInt<N, Head, Tail...>

{

enum { value = (N == sizeof...(Tail)) ? Head : RCInt<N, Tail...>::value };

};

template<int N, int... Ints>

struct UnpackInts

{

enum { value = RCInt<(int)sizeof...(Ints) - N - 1, Ints...>::value };

};

/// Type helper

template<typename I, int... Layers> struct NNType;

template<std::size_t... I, int... Layers>

struct NNType<std::index_sequence<I...>, Layers...>

{

typedef /// Weights type

std::tuple<

Matrix<

double,

UnpackInts<I, Layers...>::value,

UnpackInts::value

>...

> Weights;

typedef /// Thresholds type

std::tuple<

Matrix<

double,

UnpackInts::value

>...

> Thresholds;

};

/// The neural network class

template<int... Layers>

class BPNeuralNet

{

static const int N = sizeof...(Layers);

using InMatrix = Matrix<double, 1, UnpackInts<0, Layers...>::value>;

using OutMatrix = Matrix<double, 1, UnpackInts<N - 1, Layers...>::value>;

public:

void init();

template<class LX, class LY, class W, class T>

void forward(LX& layerX, LY& layerY, W& weight, T& threshold);

template<class LX, class LY, class W, class T, class DX, class DY>

void reverse(LX& layerX, LY& layerY, W& weight, T& threshold, DX& deltaX, DY& deltaY);

template<std::size_t... I>

bool train(const InMatrix& input, const OutMatrix& output, int times, std::index_sequence<I...>);

bool train(const InMatrix& input, const OutMatrix& output, int times = 1)

{

return train(input, output, times, std::make_index_sequence<N - 1>());

}

template<std::size_t... I>

void simulate(const InMatrix& input, OutMatrix& output, std::index_sequence<I...>);

void simulate(const InMatrix& input, OutMatrix& output)

{

simulate(input, output, std::make_index_sequence<N - 1>());

}

public:

std::tuple<Matrix<double, 1, Layers>...> m_layers;

typename NNType<std::make_index_sequence<N - 1>, Layers...>::Weights m_weights;

typename NNType<std::make_index_sequence<N - 1>, Layers...>::Thresholds m_thresholds;

std::tuple<Matrix<double, 1, Layers>...> m_deltas;

OutMatrix m_aberrmx;

public:

double m_aberration = 0.001;

double m_learnrate = 0.1;

};

模板类的实现

template<int... Layers>

void BPNeuralNet<Layers...>::init()

{

for_each(m_weights, [](auto& weight) mutable

{

weight.random(0, 1);

});

for_each(m_thresholds, [](auto& threshold) mutable

{

threshold.random(0, 1);

});

}

template<int... Layers>

template<class LX, class LY, class W, class T>

void BPNeuralNet<Layers...>::forward(LX& layerX, LY& layerY, W& weight, T& threshold)

{

layerY.multiply(layerX, weight); /// layerY = layerX * weight

layerY += threshold;

layerY.foreach(logsig);

};

template<int... Layers>

template<class LX, class LY, class W, class T, class DX, class DY>

void BPNeuralNet<Layers...>::reverse(LX& layerX, LY& layerY, W& weight, T& threshold, DX& deltaX, DY& deltaY)

{

weight.adjustW(layerX, deltaY, m_learnrate);

threshold.adjustT(deltaY, m_learnrate);

/// 计算delta

deltaX.multtrans(weight, deltaY);

layerY.foreach(dlogsig);

deltaX.hadamard(layerX);

};

template<int... Layers>

template<std::size_t... I>

bool BPNeuralNet<Layers...>::train(const InMatrix& input, const OutMatrix& output, int times, std::index_sequence<I...>)

{

/// 1. 输入归一化

auto& layer0 = std::get<0>(m_layers);

layer0 = input;

layer0.normaliz1();

auto& layerN = std::get<N - 1>(m_layers);

auto& deltaN = std::get<N - 1>(m_deltas);

for(int i = 0; i < times; ++i)

{

/// 2. 正向传播

using expander = int[];

expander {(forward(std::get(m_layers),

std::get(m_layers),

std::get(m_weights),

std::get(m_thresholds)),

0)...};

/// 3. 判断误差

double aberration = m_aberrmx.subtract(output, layerN).squariance() / 2;

if (aberration < m_aberration) return true;

/// 4. 反向修正

deltaN.hadamard(m_aberrmx, layerN.foreach(dlogsig));

expander {(reverse(std::get<N - I - 2>(m_layers),

std::get<N - I - 1>(m_layers),

std::get<N - I - 2>(m_weights),

std::get<N - I - 2>(m_thresholds),

std::get<N - I - 2>(m_deltas),

std::get<N - I - 1>(m_deltas)),

0)...};

}

return false;

}

template<int... Layers>

template<std::size_t... I>

void BPNeuralNet<Layers...>::simulate(const InMatrix& input, OutMatrix& output, std::index_sequence<I...>)

{

/// 1. 输入归一化

auto& layer0 = std::get<0>(m_layers);

layer0 = input;

layer0.normaliz1();

/// 2. 正向传播

using expander = int[];

expander {(forward(std::get(m_layers),

std::get(m_layers),

std::get(m_weights),

std::get(m_thresholds)),

0)...};

/// 3. 输出结果

output = std::get<N - 1>(m_layers);

}

社区活动

cppcon2017详细日程公布

2017年8月3日 qicosmos 发表回复

cppcon2017将于9.23-9.29在华盛顿的贝尔维尤举办，cppcon的详细日程正式公布在官网上了，本次大会的主旨演讲嘉宾有4位，分别是：

Bjarne Stroustrup，C++之父。
Herb Sutter， C++标准委员会主席。
Lars Knoll， QT公司CTO。
Matt Godbolt，Compiler Explorer的创始人

另外还有来自世界各地的100多位演讲嘉宾将出席本次大会。
purecpp社区将会第一时间带来关于本次cppcon大会的最新资讯。

社区活动

cppcon2017将于九月在华盛顿州的贝尔维尤举行

2017年7月19日 qicosmos 1条评论

今年的cppcon将于9.24-9.27在华盛顿州的贝尔维尤举办，将有一百多位来自世界各地的C++好手和专家奉上精彩的演讲，世界各大知名公司均会参会，这是一场C++技术盛宴。随着C++17的确定，相信今年会涌现出更多的新思想和新技术。purecpp社区创始人祁宇也将在这次的大会上做一个演讲。purecpp社区将持续关注cppcon2017技术大会的最新资讯。

欢迎关注purecpp社区的微信公众号。

社区活动

欢迎加入Modern C++ Meta-programming组织

2017年6月24日 qicosmos 6条评论

purecpp社区将建一个专门讨论现代C++元编程的组织（注：不是c++98/03的元编程，是c++11/14/17的元编程），欢迎报名加入。
报名方式：
实现一个有5个算法的type_list，要有测试代码并能编译通过，将实现的代码发到purecpp@163.com邮箱，同时还有你的QQ号。如果审核通过之后会将你拉到专门的群。
期待你们的type_list, have fun!

C++17

C++17中的string_view

2017年6月14日 qicosmos 发表回复

基本用法

C++17中的string_view是一个char数据的视图或者说引用，它并不拥有该数据，是为了避免拷贝，因此使用string_view可以用来做性能优化。你应该用string_view来代替const char和const string了。string_view的方法和string类似，用法很简单：

const char* data = "test";

std::string_view str1(data, 4);

std::cout<<str1.length()<<'\n'; //4

if(data==str1)

std::cout<<"ok"<<'\n';

const std::string str2 = "test";

std::string_view str3(str2, str2.size());

构造string_view的时候用char*和长度来构造，这个长度可以自由确定，它表示string_view希望引用的字符串的长度。因为它只是引用其他字符串，所以它不会分配内存，不会像string那样容易产生临时变量。我们通过一个测试程序来看看string_view如何来帮我们优化性能的。

using namespace std::literals;

constexpr auto s = "it is a test"sv;

auto str = "it is a test"s;

constexpr int LEN = 1000000;

boost::timer t;

for (int i = 0; i < LEN; ++i) {

constexpr auto s1 = s.substr(3);

}

std::cout<<t.elapsed()<<'\n';

t.restart();

for (int i = 0; i < LEN; ++i) {

auto s2 = str.substr(3);

}

std::cout<<t.elapsed()<<'\n';

//output

0.004197

0.231505

我们可以通过字面量””sv来初始化string_view.
string_view的substr和string的substr相比，快了50多倍，根本原因是它不会分配内存。

string_view的生命周期

由于string_vew并不拥有锁引用的字符串，所以它也不会去关注被引用字符串的生命周期，用户在使用的时候需要注意，不要将一个临时变量给一个string_view，那样会导致string_view引用的内容也失效。

std::string_view str_v;

{

std::string temp = "test";

str_v = {temp};

}

这样的代码是有问题的，因为出了作用域之后，string_view引用的内容已经失效了。

C++17

C++17中的structured bindings

2017年6月13日 qicosmos 发表回复

基本用法

structured bindings让我们能通过tuple，std::pair或是没有静态数据成员的结构体来初始化变量。在C++17之前如果要解包一个结构体时，我们需要借助tie，像这样：

auto tp = std::make_tuple(1, 2.5, 'c');

int a;

double b;

char c;

std::tie(a, b, c) = tp;

现在有了C++17的structured bindings，我们可以很方便地解包tuple了，像这样。

1 2	auto tp = std::make_tuple(1, 2.5, 'c'); auto [a, b, c] = tp;

遍历map的时候也不用像以前一样写pair然后it->first, it->second了，而是用更加简洁的方式，像这样：

std::map<int, int> mp = { {1, 2}, {3, 4} };

for(auto&& [k, v] : mp)

std::cout<<"key: "<<k<<" "<<"value: "<<v<<'\n';

更酷的是你可以用来解包一个结构体。

struct Foo

{

int i;

char c;

std::tuple<double> d;

std::map<int, int> e;

};

std::tuple<double> tp(2.3);

Foo f { 1, 'a', tp, {{1,2}} };

auto& [i,c,d, e] = f;

std::cout<<i<<" "<<c<<" "<<e[1]<<'\n';

i = 2;

c = 'b';

需要注意的是，你必须提供和结构体或tuple字段个数相同的变量，否则会出现编译错误，而且你不能像std::ignore一样忽略某些字段，必须全部解包出来。解包的时候你可以选择引用或拷贝，auto&就是引用方式解包。

特殊用法

我们可以借助这个特性来做一点有趣的事，比如把一个结构体变成一个tuple。

template <class T, class... TArgs> decltype(void(T{std::declval<TArgs>()...}), std::true_type{}) test_is_braces_constructible(int);

template <class, class...> std::false_type test_is_braces_constructible(...);

template <class T, class... TArgs> using is_braces_constructible = decltype(test_is_braces_constructible<T, TArgs...>(0));

struct any_type {

template<class T>

constexpr operator T(); // non explicit

};

template<class T>

auto to_tuple(T&& object) noexcept {

using type = std::decay_t<T>;

if constexpr(is_braces_constructible<type, any_type, any_type, any_type, any_type>{}) {

auto&& [p1, p2, p3, p4] = object;

return std::make_tuple(p1, p2, p3, p4);

} else if constexpr(is_braces_constructible<type, any_type, any_type, any_type>{}) {

auto&& [p1, p2, p3] = object;

return std::make_tuple(p1, p2, p3);

} else if constexpr(is_braces_constructible<type, any_type, any_type>{}) {

auto&& [p1, p2] = object;

return std::make_tuple(p1, p2);

} else if constexpr(is_braces_constructible<type, any_type>{}) {

auto&& [p1] = object;

return std::make_tuple(p1);

} else {

return std::make_tuple();

}

//test code

struct s {

int p1;

double p2;

int mp3[2];

std::map<std::string, int> v4;

};

std::map<std::string, int> v = {{"a", 2}};

auto t = to_tuple(s{1, 2.0, {2,3}, v});

实现的思路很巧妙，先判断某个类型是否由指定个数的参数构造，is_braces_constructible<type, any_type>{}就是判断type是否能由一个参数构造；接着通过constexpr if在编译期选择有效的分支，其它的分支将会被丢弃；最后通过structured bindings来获取结构体字段的值，并将这些值重新构造一个tuple，这样就可以实现将结构体转换为tuple了。上面的例子中由于有四个字段所以会走第一个分支。需要注意的是，这个方法只是一个示例，还没解决构造函数被delete的问题，还有隐式转换的问题，如果你想看更完整的解决方案可以看这里：http://playfulprogramming.blogspot.hk/2016/12/serializing-structs-with-c17-structured.html。

structured bindings具备解包结构体的能力，虽然限制条件也不少，我相信它的用法值得深入探索。

C++17

C++17中的constexpr

2017年6月12日 qicosmos 1条评论

constexpr if

constexpr标记一个表达式或一个函数的返回结果是编译期常量，它保证函数会在编译期执行。相比模版来说，实现编译期循环或递归，C++17中的constexpr if会让代码变得更简洁易懂。比如实现一个编译期整数加法：

template<int N>

constexpr int sum()

{

return N;

}

template <int N, int N2, int... Ns>

constexpr int sum()

{

return N + sum<N2, Ns...>();

}

C++17之前你可能需要像上面这样写，但是现在你可以写更简洁的代码了

template <int N, int... Ns>

constexpr auto sum17()

{

if constexpr (sizeof...(Ns) == 0)

return N;

else

return N + sum17<Ns...>();

}

当然，你也可以用C++17的fold expression

template<typename ...Args>

constexpr int sum(Args... args) {

return (0 + ... + args);

}

constexpr还可以用来消除enable_if了，对于讨厌写一长串enable_if的人来说会非常开心。比如我需要根据类型来选择函数的时候：

template<typename T>

std::enable_if_t<std::is_integral<T>::value, std::string> to_str(T t)

{

return std::to_string(t);

}

template<typename T>

std::enable_if_t<!std::is_integral<T>::value, std::string> to_str(T t)

{

return t;

}

经常不得不分开几个函数来写，还需要写长长的enable_if，比较繁琐，通过if constexpr可以消除enable_if了。

template<typename T>

auto to_str17(T t)

{

if constexpr(std::is_integral<T>::value)

return std::to_string(t);

else

return t;

}

constexpr if让C++的模版具备if-else if-else功能了，是不是很酷，C++程序员的好日子来了：）

不过需要注意的是这种写法是有问题的哦。

template<typename T>

auto to_str17(T t)

{

if constexpr(std::is_integral<T>::value)

return std::to_string(t);

return t;

}

这个代码把else去掉了，当输入如果是非数字类型的时候代码可以编译过，以为if constexpr在模版实例化的时候会丢弃不满足条件的部分，因此函数体中的前两行代码将失效，只有最后一句有效。当输入的为数字的时候就会产生编译错误了，因为if constexpr满足条件了，这时候就会有两个return了，就会导致编译错误。

constexpr if还可以用来替换#ifdef宏，看下面的例子

enum class OS { Linux, Mac, Windows };

//Translate the macros to C++ at a single point in the application

#ifdef __linux__

constexpr OS the_os = OS::Linux;

#elif __APPLE__

constexpr OS the_os = OS::Mac;

#elif __WIN32

constexpr OS the_os = OS::Windows;

#endif

void do_something() {

//do something general

if constexpr (the_os == OS::Linux) {

//do something Linuxy

}

else if constexpr (the_os == OS::Mac) {

//do something Appley

}

else if constexpr (the_os == OS::Windows) {

//do something Windowsy

}

//do something general

}

//备注：这个例子摘自https://blog.tartanllama.xyz/c++/2016/12/12/if-constexpr/

代码变得更清爽了，再也不需要像以前一样写#ifdef那样难看的代码块了。

constexpr lambda

constexpr lambda其实很简单，它的意思就是可以在constexpr 函数中用lambda表达式了，这在C++17之前是不允许的。这样使用constexpr函数和普通函数没多大区别了，使用起来非常舒服。下面是constexpr lambda的例子：

template <typename I>

constexpr auto func(I i) {

//use a lambda in constexpr context

return [i](auto j){ return i + j; };

}

constexpr if和constexpr lambda是C++17提供的非常棒的特性，enjoy it.

知行一

中国C++大会招募讲师

大会介绍

大会主题

讲师报名

讲师报名表

C++17中的deduction guide

Modern C++ Meta-programming组织今天成立

一个C++14模板元实现的深度学习神经网络模板类，支持任意层数

cppcon2017详细日程公布

cppcon2017将于九月在华盛顿州的贝尔维尤举行

欢迎加入Modern C++ Meta-programming组织

C++17中的string_view

基本用法

string_view的生命周期

C++17中的structured bindings

基本用法

特殊用法

C++17中的constexpr

constexpr if

constexpr lambda

顶级C++社区