C++17

C++17中的deduction guide

2017年8月11日 qicosmos 2条评论

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/NeuralNetwork

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

#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 4条评论

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.

社区活动

中国的cppcon需要您的参与！

2017年6月6日 qicosmos 发表回复

为什么要举办这样一个C++大会

C++标准在不断的发展和演进，从C++11到C++14，再到现在的C++17，还有接下来的C++20和C++23.历史的车轮一直在滚滚向前，C++这个有着三十多年历史的语言也在顺应着时代潮流不断地向前发展演进。C++语言正在发生着深刻的变革，这些变革给工业界带来了很多变化，比如让我们的程序变得更安全、更高效和更简洁，而这些新技术正在提高工业生产力，谁先掌握这些新技术会谁将会先享受到到新技术带来的红利。在美国，在欧洲，现代C++正在如火如荼的讨论和应用，每年在美国举办的cppcon无疑是工业界、学术界中水平最高的C++技术盛会，cppcon每年有超过2000人参会，上百位来自美欧的C++专家和高手分享和交流C++最新的技术和新的idea。

然而cppcon一直在美国举办，中国的C++爱好者想参与往往受限于距离和英文语言等因素不便参加。现在有一个好消息：purecpp社区将会在今年晚些时候参与举办一场高水平、国际化的C++大会，大会的形式和内容将会与cppcon类似但又具备中国特色，如果你不能亲自前往美国参加cppcon那么就不要错过这次在中国举行的C++大会。

举办方的资质

purecpp社区自2015年成立以来一直致力于现代C++的研究、应用和推广，在各大社区和《程序员》杂质发表了大量的技术文章，同时也开源了一批现代C++项目。purecpp社区的创始人祁宇在今年5月份参加了在美国举办的c++ now技术大会并在会上做了演讲，后面相关视频会放在youtube上。祁宇还将参加今年在华盛顿举办的cppcon2017, 将在会上做1小时演讲。作为深度的参会人员，他知道C++未来的发展方向，知道国际上正在研究的C++热点，也知道广大的C++er希望听到什么内容。cppcon和cppnow为人称道的原因就在于它们的专业性，因此，purecpp社区作为举办方之一就是希望在中国办一场cppcon那样专业的、受欢迎的C++大会。

大会的日程

大会的日期、地点和议程目前还没确定，需要您参与进来，我们希望知道一些基本信息：

有多少人愿意参加这次大会；
你想听关于哪些方面的内容；

有了这些条件之后我们才能更好地确定大会日程，请参与我们的调查（文末有一个调查表），这场C++盛会需要您的参与！

大会内容

我们希望这次大会能聚焦于现代C++（C++11/14/17）以及工业界热点，比如C++在人工智能领域、分布式数据处理引擎（GraphLab）领域、区块链领域的应用，当然最重要的是你创新的idea！！

就以Cppcon的主题作为这次大会的主题：

C++ Best Practices
Concurrent Thinking in C++
Crafting Embedded Software in C++
Modern C++ Template Programming
Modernizing your C++
Move Semantics: Everything You Always Wanted to Know, But Were Afraid to Ask
Moving to C++17: The New Language and Library Features
Debugging and Profiling C++ Code on Linux
Exploring the C++ Standard Library
Practical Modern C++
Programming with Qt/Widgets
The Standard Library from Scratch

如何报名

到时候报名的相关信息会放在purecpp.org上，敬请关注，先说一下讲师和观众的报名流程。

讲师报名流程

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

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

这次大会的外国讲师和中国的讲师比例大约为1:2。

观众报名流程

观众需要在官网上购票参会，具体等待后续的通知，学生的话会有折扣。

知行一

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

中国的cppcon需要您的参与！

为什么要举办这样一个C++大会

举办方的资质

大会的日程

大会内容

如何报名

讲师报名流程

观众报名流程

需要您的参与

顶级C++社区