新闻

当前位置:手机版美高梅网站 > 新闻 > 0x核心进展的朝气蓬勃组简讯代码

0x核心进展的朝气蓬勃组简讯代码

来源:http://www.best-sclae.com 作者:手机版美高梅网站 时间:2019-12-09 16:36

Concepts无疑是C++0x的剑客级天性之大器晚成(大概称它“剑客级”还应该有八个缘由:杀死新手:卡塔尔国)。如今有关concepts的议事原案终于汇集了Bjarne Stroustrup和DouglasGregor领导的两派做法之长,已然有大局渐定的线索。超级多两派之间直接以来的差别拿到了卓越的迁就;辅以concept_map那样卓越而实用的特征,着实非常常有说性格很顽强在艰难险阻或巨大压力面前不屈力,并且,concept这段时间的达成居然隐含着一个暧昧的decltype设施,今天看见Douglas在boost.devel上涉及,吓了豆蔻年华跳,自个儿怎么没有想到呢?出主意也道理当然是那样的,人家不过ConceptGCC(GCC with Concepts support)的完成者那后生可畏,对于自身落成的东东,当然最熟练了,呵呵。连DavidAbrahams看见这几个trick时都在说自个儿其实是dumb。DougRuss给出的事例是演绎函数/仿函数的回来值类型的,最近boostCurry面包车型客车result_type设施的贯彻仍为侵入式的,远缺乏周全。而有了concept之后,只需两三行代码就可以兑现二个圆满的非侵入式result_type设施。实际上,concept作为aspect traits可以推导出一个类的其余成员具名里含有的项目来,当然也囊括使其产生仿函数的operator(卡塔尔国的归来值类型了。别的,就小编的思虑,concept恐怕蕴涵着decltype的三个比较康健的非侵入式完毕,最少比现行反革命boostCurry面包车型客车BOOST_TYPEOF用起来轻松,后面一个须要登记项目,同理可得,concept引进了比当下的模板类型推导系统粒度越来越细的花色推导手艺。

正文翻译自modern effective C++,由于水平有限,故无法作保翻译完全正确,应接建议错误。多谢!

作者:hearts zh
链接:
来源:知乎
文章权归小编全体。商业转发请联系小编获得授权,非商业转发请表明出处。

其他,concept的定义语法也稳步成型成熟。就算像late checking那样的风味笔者要么比较可疑(实在有些“补丁”的认为到,如今这一个特点也是成套concept系统之中最不平稳的,关于late_check的使用粒度难题还在研讨在那之中,但是小编想超大概这一个特点会被去除掉,而顶替以更视而不见的东西,毕竟显得太“孤立”了。)但终究来讲一切concept系统现已展现出所谓的“文雅”的认为了,正如数学里面包车型客车“美”往往意味着准确同样,语言设计里的“文雅”也是那样。希望C++0x的这几个非常重要特色能够优越的实现。本来计划单独介绍一下concept于今截止走过的野史脚印的,不过重于还是抽不出时间能够组织一下,所以干脆只介绍一下最新进展了,风乐趣的朋友能够去C++ Committee Website上搜未来的proposal。

博客已经搬迁到手机版美高梅网站 ,这里啦

decltype是四个意想不到的东西。给出多个名字恐怕二个表明式,decltype能够告诉您名字或表明式的档案的次序。大多景况下,他告诉你的正是确实你想的那么。不过有的时候,他会提供三个脱离你想像的结果,那招致了您必需去找一本参谋书大概去在线Q&A网站寻求答案。

我们从平时情状(未有意外的结果)起初。相比template和auto的品类推导,decltype模仿你给的名字或表明式:

const int i = 0;            //decltype(i)是const int

bool f(cosnt Widget& w);    //decltype(w)是const Widget&
                            //decltype(f)是bool(const Widget&)

struct Point {
    int x, y;               //decltype(Point::x)是int
};                          //decltype(Point::y)是int

Widget w;                   //decltype(w)是Widget

if(f(w))...                 //decltype(f(w))是bool

template<template T>
class vector{
public:
    ...
    T& operator[](std::size_t index);
    ...
};

vector<int> v;              //decltype(v)是vector<int>
...
if(v[0] == 0)...            //decltype(v[0])是int&

看吗,未有别的的奇怪之处。

在C++11中,恐怕decltype最关键的用场就是用来注脚 回到值类型信赖于参数类型的 函数模板。比如,若是你要写三个函数,这几个函数要求叁个支撑下标操作("[]")的容器,然后依照下标操作来甄别出顾客,函数的归来值类型应该和下标操作的门类相仿。

以T为要素类型的器皿,operator[]操作常常再次回到T&,那是std::deque的图景,举例说,那是std::vector的绝大多数情景。不过,对于std::vectoroperator[]操作不回来bool&。取代他的,它回到一个意味着意气风发致值的新对象,对于这种状态的座谈将身处item 6,不过在那间,入眼是:operator[]函数重临的花色决计于容器的档期的顺序。

decltype让表达式变得简单。大家将写下首先个template,显示怎样用decltype总结再次回到值。template能够进一层总结,不过大家先写成这么:

template<typename Container,typename Index>
auto authAndAccess(Container& c, Index i)   //需要精炼
    ->decltype(c[i])
{
    authenticateUser();
    return c[i];
}

函数后面包车型的士不行auto的运用未有做其他类型的推理。当然了,那申明着C++11施用了回到值类型前置的语法。也便是,函数的回到值类型将跟在参数列表("->"的背后)后边注解。二个前置的回来类型具备多个亮点,正是函数的参数能用来规定再次回到值类型。在authAndAccess中,为了比方,大家用c和i来分明函数的归来值类型。按古板的接纳办法,大家让再次回到值类型处于函数名的前方,那么c和i就无法接受了,因为分析到那儿,他们尚未被声称出来。

应用那个宣称方式,就和我们的须求生机勃勃致,authAndAccess依据大家传入的容器,以这么些容器的operator[]操作再次回到的体系来作为它自己的回到值类型。

C++11同意大家推导一些比较简单的lambdas表明式的回到类型,况兼在C++14中,把这种推导增至了全体的lambdas表达式和装有的函数中,包罗那多少个有多条语句的复杂的函数。在authAndAccess中,那表示在C++14中,大家能忽略重临值类型,只需使用auto就能够。在如此的宣示方式下,auto意味着项目推导将会时有产生。特别是,它代表编写翻译器将会基于函数的贯彻来演绎函数的回到值类型。

template<typename Container, typename Index>
auto authAndAccess(Container& c, Index i) //需要精炼
{
    authenticateUser();
    return c[i];
}

Item 2释疑了八个回来auto的函数,编写翻译器选取template的品种推导准则。在这里种景色下,那是反常的。就好像我们谈谈的那样,对于当先一半容器,operator[]回来的是T&,但是Item 1分解了在template类型推导中,表达式的援用属性会被忽视(意况3),构思下这对于顾客代码意味着什么样:

std::deque<int> d;
...
authAndAccess(d, 5) = 10;   //这会返回d[5],然后把10赋给它。
                            //但是这会出现编译错误(给一个右值赋值)

这里,d[5]再次来到三个int&,可是对authAndAccess的auto再次回到类型的推理将去掉援引属性,那产生了一个int类型,int是函数的回到值类型,是八个右值,然后这段代码尝试给三个右值int赋值多少个10.这在C++中是制止的,所以代码不能够编写翻译。

为了让authAndAccess能专门的职业地像我们愿意的那么,我们要求对回到值类型使用decltype类型推导,也正是总的来说authAndAccess应该回到表明式c[i]回去的花色。C++的平整制订者,预料到了在某些门类须求推断的意况下,用decltype类型推导法则来演绎的供给,所以在C++14中,通过decltype(auto卡塔尔(قطر‎类型表达符来让之形成大概。这一方始看起来也可以有一点矛盾的事物(decltype和auto)确实完美地结合在一块儿:auto显著了项目须求被演绎,decltype鲜明了推导时选择decltype推导法则。因而大家像那样能写出authAndAccess的代码:

template<typename Container, typename Index>
decltype(auto)
authAndAccess(Container& c, Index i) //需要精炼
{
    authenticateUser();
    return c[i];
}

当今authAndAccess能真正地赶回c[i]重返的项目了。特别是对此部分c[i]回去二个T&的状态,authAndAccess也会重临四个T&,何况在不平凡的场地下,当c[i]再次来到三个目的,authAndAccess也会回去叁个对象。

decltype(auto卡塔尔的利用持续局限于函数再次回到类型,当您对正值最早化的表达式使用decltype类型的门类推导法规时,它也能很有益于地用在变量的证明上:

Widget w;

cosnt Widget& cw = w;

auto myWidget1 = cw;    //myWidget1的类型是Widget

decltype(auto) myWidget2 = cw
                        //myWidget2的类型是const Widget&

自己精晓今后有两件事干扰着你,二个是本身上面提到却绝非座谈的对于authAndAccess的简单,现在让我们管理它:

再二次看一下C++14版本的authAndAccess的扬言:

template<typename Container, typename Index>
decltype(auto) authAndAccess(Container& c, Index i);

容器以非const左值引用(lvalue-reference-to-non-cosnt)的格局传入,因为二个对成分的援引允许客户校订容器,可是这表示我们不能够传一个rvalue容器给这几个函数。rvalue不能够和lvalue引用绑定(除非他们是const左值引用(lvalue-references-to-const),不过此间不是)。

公众感到地,传二个rvalue的容器给authAndAccess是很稀有的状态。二个rvalue容器是叁个不时对象,它在authAndAccess的调用语句停止的时候就能被灭亡,那意味着对这样七个容器(authAndAccess的再次回到值)的援引在说话停止时会发生未定义的结果。不过,传递贰个权且变量给authAndAccess依旧有意义的。一个客商恐怕轻易地想发出一时容器1十月素的生机勃勃份拷贝,比方:

std::deque<std::string> makeStringDeque();

//拷贝一份makeStringDeque返回的deque的下标为5的元素
auto s = authAndAccess(makeStringDeque(), 5);

为了支持那样的应用,意味着我们要求改善authAndAccess的注脚,让它能同期选择lvalues和rvalues。重载能够很好的劳作(多个接纳lvalue援引参数的函数,叁个收受rvalue援引参数的函数),然则那样的话会大家须要保险四个函数。三个制止那样的法子是使用二个征引参数(universal引用),它能而且选择lvalues和rvalues,在item 24中会解释universal援用具体做了什么样。因而authAndAccess能宣称成这么:

template<typename Container, typename Index>
decltype(auto) authAndAccess(Container&& c, Index i);

在这里个template中,大家不知道容器的项目,所以,那象征大家相像不晓得容器对象使用的索引类型。对于未知对象使用传值(pass-by-value)格局常常会因为没供给的正片而对效用产生十分大的熏陶,以致对象切割(item 41)的难题,并会被大家的同事嘲讽,可是在容器索引的采用上,跟随规范库(例如,std::string,std::vector以及std::deque的operator[])的步子看起来是有理的。所以我们将坚贞不屈以传值(pass-by-value)的措施利用它。

不过,大家需求运用std::forward履新template对universal引用的贯彻来让它切合item 25的告诫。

template<typename Container, typename Index>
decltype(auto)
authAndAccess(Container&& c, Index i)
{
    authnticateUser();
    return std::forward<Container>(c)[i];
}

以那一件事例应该会成功全体大家想要的事情了,可是它须求C++14的编写翻译器。假诺您未曾,你将索要利用C++11版本的template。除了你要求和谐明白再次来到值类型外,它和C++14的版本是后生可畏律的:

template<typename Container, typename Index>
auto
authAndAccess(Container&& c, Index i)
    -> decltype(std::forward<Container>(c)[i])
{
    authnticateUser();
    return std::forward<Container>(c)[i];
}

另一个或许纠葛你的主题材料是自身在大器晚成从头的信口开河,笔者说decltype在大部景色下回发生你想要的类别,大约不会拉动意料之外。诚实说,你不太恐怕遭受这么些差异法则除非你是三个至关心保养要的库的实现者。

为了完全清楚decltype的行事,你一定要让您本身深谙一些特出情形。大许多这一个境况都太刚毅了为此不会方便地在书中探讨,然则为了看清楚decltype的当中景色以致他的应用需求信任这种处境。

使用decltype来发生一个名字(name)的类型,假若名字(name)是左值表达式,不影响decltype的一坐一起。比起名字(names)lvalue表明式特别复杂,然则decltype有限支撑推导的花色总是lvalue引用。那正是,贰个lvalue表明式除了name会推导出T,别的景况decltype推导出来的类别便是T&。那很稀少影响,因为好多lvalue表达式本质上带有二个lvalue援用的修饰符。比方函数重临lvalues时,它连接回到左值援引。

这里有一个富含的一举一动值得您去发掘到,在

int x = 0;

x是三个变量的名字,所以decltype(x)int,可是倘使把x包装在括号中---"(x)"---将时有发生多少个比名字更复杂的表明式。作为二个名字,x是三个lvalue,并且C++定义表达式(x)也是三个左值。decltype((x))因此是int&。把括号放在name的外缘将纠正decltype推导出来的连串。

在C++11中,没什么好奇怪的,然则结合C++14对decltype(auto卡塔尔(英语:State of Qatar)的援救,那表示你在函数中写的回来语句将震慑到函数类型的推理:

decltype(auto) f1()
{
    int x = 0;
    ...
    return x;   //decltypex(x)是int,所以f1返回int
}

decltype(auto) f2()
{
    int x = 0;
    ...
    return (x); //decltype((x))是int&,所以f2返回int&
}

纪事f2不独有是重回值和f1分歧,它还回去了贰个局地变量。那是生机勃勃种把你推进未定义行为的圈套代码。

最根本的教诲正是,在行使decltype(auto卡塔尔的时候小心再小心。在说明式中,对品种的演绎看起来无关大局的底细能影响到decltype(auto卡塔尔(قطر‎的推理。为了确认保证项指标演绎和您想的风姿洒脱致,请使用item 4陈诉的办法。

况兼,不要忽视大局。当然,decltype(满含单独接纳以至和auto一齐使用)大概一时候产生出意外的花色,可是那不是平日的景况。日常,decltype发生你想要的连串。当decltype应用在name时,它总生产手艺生你想要的情事,在这里景况下,decltype就疑似听起来那样:它演绎出name的宣示类型。

实质上今后的proposal超级多过多,不出意外也可以有格外部分没时间增添c++17。c++17会是多个大改良,下叁个小修补会是c++20

另一个自己可怜尊敬的template特性——variadic templates——方今也暴露了非常可爱的征象。道格Russ终于在gcc上做出了第黄金年代份达成,并顺便了大器晚成份新的议案和三个Introduction 帕佩r,别的还用那么些新特征重新达成了tuple、bind、function那多少个已加盟tr1的库,特别了不起,光是代码量来讲,tuple的自身算了一下大概节省了2/3,别的还会有大幅升高的可读性和优雅性等等。这一个新闻那阵子在新闻组上分外挑起了一些提神~:卡塔尔(英语:State of Qatar)跟早先的两份议案比较,新的议事原案如今回降了多少个小的风味,但第朝气蓬勃的风味都早就贯彻了。这几个快五年从未动静,可是十一分雅淡的言语特色总算迈出了一大步,说真话,前阵子看见C++议会语言进行列表里面把它排在“不活跃”一栏时就是有个别顾虑吗,心想别又等到花都谢了菜都凉了。今后既是编写翻译器完毕已出,看来离成熟之期已然不远矣。热心如Alexandrescu者在comp.std.c++上对此也建议了众多建设性意见,看得出来不菲人照旧很看好那朝气蓬勃特点的,越发是boosters,光是它给模板库代码可读性带给的进步正是一大亮点,更况且还也许有代码量的广大节省,一些格外奇怪的(宏的、元编制程序的)技艺的抛开,等等,全数这几个都会使得模板库代码朝向更名贵的来头前进。加上近年来补助者甚众,预计步向0x是骨干不会错的了。

            你要牢牢记住的事
  • decltype大大多意况下三番四遍不加校勘地现身变量和表达式的类型
  • 对于T花色的lvalue表达式,decltype总是现身T&
  • C++14支撑decltype(auto卡塔尔国,和auto相像,他从八个早先化器中国对外演出公司绎类型,只但是使用的是decltype类型推导法则。

自个儿个人认为从发展角度来讲,c++最近最亟需的,是module,网络库,以至更全面包车型地铁并行库。作者只微微搬一下Stroustrup桑二零一两年流行提交的议事原案,提到了他感到的c++17是急需满含哪些东西。

 

全文具体链接。
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4492.pdf

并发内存模型是另三个刺客级个性,就算是个名无名鼠辈的剑客级特性。明显,那是有着新特征里面最难搞领会的,因为四线程编制程序本来正是极度微妙的事物。Java前一年在此个方木槿了相当多的技术,呵呵,此番C++也就不允许备重新发明轮子了,把现存的Java内存模型裁减一些不附合C++国情的上面,“抄”过来就可以:卡塔尔(قطر‎风野趣的能够参见Java标准里面的内存模型部分,以致Boehm的主页上那方面包车型地铁剧情,Boehm是到位过Java内存模型的修正职业的,干起那方面来熟习( template这几个fancy的语法天性。而说它无声无息则是因为它实际不是内需技师在平时编制程序中须求时刻关怀的东西,就好像GC相同,它们都归属在背后默默地提供支撑和维系的特征。正如有了GC程序猿就只需关怀对象成立同样,有了产出内存模型的语言级扶助,程序猿就足以放心地将集中力放到真正的现身编程工夫上边了。个人感觉C++在此个时候完备内存模型应该不算晚,以致方便,Herb Sutter说过现身编制程序的技巧发展了这样长此未来到后天适逢其时算是踏入产业界广泛使用的前夕,并发时期将在赶到,而C++刚好将要现在八年内做好策动。对于像C++那样一门首要利用于周围系统级应用/游戏/图形等开发中的语言,功效是相当的重大的,而并发则是对功能的无敌提高。

第风华正茂,C++长久性的目标就是运营作用。无论怎么设计都不会违反那点。

 

Whatever we do, we should preserve C++’s fundamental strengths:
• A direct map to hardware (initially from C)
• Zero-overhead abstraction (initially from Simula)
Depart from these and the language is no longer C++.

别的二个只好说的“工业级”天性正是Module(模块),那也是叁个对相近C++应用能够拉动显然好处的表征,相信熟稔的相恋的人都通晓多少个实际,今后C++应用特别是广大使用的系统编写翻译营造速度更是成难点,英特尔内部的二个计算注解C++头文件中的代码量占总体项目代码量的比重从90时期的一成左右间接涨到未来的超出二分之一!并且还有上增趋势,因为以模板技能为根基的C++今世库将大气的代码放在头文件中,并且多量运用宏以致高等模板才能,使得编写翻译塑造时间大大增添。举个例子win32gui便是因为boost.signal带给的编写翻译时间太巨而友好安排了三个轻量级的signal类(Qt用的也是温馨的QSignal)。《Large Scale C++ Software Design》里面也说头文件的parse是项目塑造里面很虚耗光阴的二个进程(并用多加生机勃勃层“包括哨位”的笨重手法来消弭)。Module的产出,依据原来就有经验的远望,能够小幅度缓慢解决这一难点。那也是其主要动机原因之大器晚成(Java是曾经有了Module的)。其余Module仍可以够带给其余一些好处(C++里面到场新特色就是那般,平时总要想尽办法发掘新特征的隐私好处)。然而,像Module那样的工业级个性在新闻组上赢得的喧哗反而远远比不上一些不错的语法/类型系统层面包车型客车性状,希望不会在投票上落选吧:卡塔尔国

  1. 至于遍布软件系统的支撑

 

  • Modules:不出意外,这几个主意太高了。不但是编写翻译速度,就连最根基的One Definition Rule的各样家有家规都能搞死人。最新的2篇modules议事原案:
    http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4465.pdfhttp://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4466.pdf谈起来轻松,实现起来麻烦。近些日子议事原案者正在Visual C++中实现那一个议案。因为那个意见相当的高,有理由相信步向c++17的恐怕相当的大。即使近期行行还不是高速的以为。看proposal前段时间还应该有生龙活虎部分小的design decision未有分明下来,举例是或不是须要interface这一个第一字之类的。

    有了modules写出来的代码是什么样体统吗,差十分少是这些样子,

    import std.vector;
    import std.string;
    import std.iostream;
    import std.iterator;
    

末段就是多少个已经卓越干练的特征了,auto算是以此,实际上那样一个精致实用,早该步入正规的东东从被提出那一天起就曾经是铁钉铁铆了。可是,跟auto算是孪生双胞胎的decltype倒是还在摆动,笔者倍感decltype还并未有定数首要依旧它看起来太“难看”了,何况违反D奥迪Q5Y原则,其提议的函数的新注明语法实在是有一些别扭,倒是期望concept系统能够富含其力量,免得搞得太复杂。

怎样写module呢?  

    //abc.cpp (文件名无需和module名重合)
    module abc;
    struct internal {  };
    int internal_f() {  }
    export namespace abc 
    {
      class abc { };
    }


注意C++的module仅仅只是编译范畴的,并不是二进制范畴的。效率为王。

当然,还大概有rvalue/move那一个宠儿,rvalue/move也早就进来尾声“改过“阶段了,所做的便是生机勃勃对微小的调度,相同,那也是一个打一提议就极度是鱼上砧板的性状,用一句老美的话,It just feels right!(关于auto和rvalue/move,笔者原先的风姿浪漫篇做过部分介绍)

  • Contracts:经过11年被洗礼之后,此番加进去难题应当超级小了。最新的议事原案:

    http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4415.pdf

    出去时间比较久了,我们也都驾驭是干嘛的,也可能有刘雨培童鞋说过新型议案,小编就没有多少说了,其实Contracts简化后也是蛮复杂的,但基本上正是你未曾接触过,读懂外人写的代码的难度也非常的小。

  • A type-safe union:也正是variant,基本上是在往functional-programming上靠。

    Stroustrup桑还给了三个链接,13年他的三个学子(?)的散文,叁个c++的pattern matching库,蛮坑的。作者觉着不开展大改革,那个pattern matching库步向c++的专门的学问大概相当的小。

    诡异的童鞋们不用找了,作者拷个最简便易行的事例出来。有了variant之后,这几个match库可以match类型+值。可是仅仅是库实际不是言语层面包车型客车支撑,真是不三不四啊。

    int factorial(int n) {
      int m;
      Match(n) {
        Case (1) return 0;
        Case (m) return m*factorial(m-1);
        Case (_) throw std::invalid_argument(""); 
      } EndMatch
    }
    

 

  1. 至于互相

除了一些还相比有精力的特点有:Initializer(Bjarne领导,目的在于统黄金时代开头化语法情势、以更加好的支撑C++的泛型系统。别的还提供更有益于的早先化花招)、opaque typedef(比较风趣的表征,可以更加的加深C++的体系系统,收缩一些因项目系统远远不足康健而带给的藏身错误的空子,马特hew在《Imperfect C++》中有风姿罗曼蒂克章就提到那个问题),跟opaque typedef有一点点关联的strong typed enums(那么些不说大家也通晓)、别的,还会有aliasing template、new for-loop。

  • 幼功互联网库:那几个太急需了,未有底子网络库,别的任何网络有关的操作都以草木皆兵。

    据说boost::asio的风靡议案,

    http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4478.html

    boost::asio的async模型基本是callback。但那几个proposal其实实际不是大致的boost::asio直接拷贝过来,除了主导的asio之外,还基于future和co-routine加了比比较多料。

    例如,基于future的async模型,

    std::future<std::size_t> fut =
      socket.async_read_some(buffer(buffer_space), use_future);
    
    // ...
    
    std::size_t length = fut.get();
    

    复杂一点仍是可以够这么,

    socket.async_read_some(buffer(buffer_space), use_future).then([](std::size_t) {});
    

 

例如,基于co-routine的async模型(例子是stackful的,stackless需要语言层面支持)。  

    void coro_connection(tcp::socket& socket, yield_context yield)
    {
      try
      {
        std::vector<char> buffer_space(1024);
        for (;;)
        {
          std::size_t length = socket.async_read_some(buffer(buffer_space), yield);
          uppercase(buffer_space.begin(), buffer_space.begin() + length);
          async_write(socket, buffer(buffer_space, length), yield);
        }
      }
      catch (std::system_error& e)
      {
        // ...
      }
    }

基本上可以看出网络库是一个async模型的大杂烩,只要你有,我就支持。  

最后,这个proposal还加了一些高级的库(无需关注底层细节)。  

    tcp::iostream s("www.boost.org", "http");

    s << "GET / HTTP/1.0rn";
    s << "Host: www.boost.orgrn";
    s << "Accept: */*rn";
    s << "Connection: closernrn";

    std::string header;
    while (std::getline(s, header) && header != "r")
      std::cout << header << "n";
    std::cout << s.rdbuf();

或许吧,最要紧的语言特征都在地方了。最让人缺憾的正是,看上去C++在0x是别期望能有reflection工夫了。从新闻组上的感应来看,就像committee guys和boosters对这一表征不是非常的热心,的确存在多少个第三方的实现,但是都要依附C++编写翻译器之外的工具。看来很短生龙活虎段时间内C++别指望有一个非侵入式的康健serialization库了。此外倒没太大关系,究竟,C++的应用领域跟以后欣欣向荣的动态语言分化,前面一个极度信赖于相像reflection的技能。只怕那也是那叁个guru们不关怀这几个的案由吧:卡塔尔

  • SIMD vector:数学总结啊,游戏啊,没什么好说的,商量那地点的自然懂,不研讨的这些定义也没啥复杂的。上边这一个议案提出三个matrix 类,乘法等操作使用simd搞计算。

    http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4492.pdf

  • Improved Future: 基本上都以微软依据.Net阅历提出来的。就举个例子互联网库的.then,正是依据此。你能够async_read( 卡塔尔国.then(卡塔尔.then(卡塔尔(英语:State of Qatar).then(卡塔尔,等等。具体看proposal吧,蛮简单易懂的。

    http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3857.pdf

  • Co-routines:主体也是微软搞出来的议案,基本和.net同样的语法。在VC++上早就有落实。本来那东西就分stackful照旧stackless。微软应当是比较趋向于stackless的,google一个人也建议了stackful和stackless的语法能够统大器晚成的二个议案。具体尚未定。很也许是都援助,客商可自由选取的。其实微软的议事原案或许相比吸引人。关键字:await,yield

    https://isocpp.org/files/papers/N4402.pdf

    自己要多说一些,因为蛮有趣,

    复制一下微软的design goal:

    * Highly scalable (to billions of concurrent coroutines)
    * Highly efficient resume and suspend operations comparable in cost to a function call overhead
    * Seamless interaction with existing facilities with no overhead
    * Open ended coroutine machinery allowing library designers to develop coroutine libraries exposing various high-level semantics, such as generators, goroutines, tasks and more
    * Usable in environments where exception are forbidden or not available

    就看他的design goal就很想敢用了

    写出来的代码什么体统吗?await和yield关键字其实.net, python啊,java啊之类的也都有,没什么好解释的,要说下generator和goroutine,你没看错,是类Go语言的goroutine援助。

    generator:

    generator<int> fib(int n) {
      int a = 0;
      int b = 1;
      while (n-- > 0) {
        yield a;
        auto next = a + b;
        a = b;
        b = next;
      }
    }
    

    goroutine:

    goroutine pusher(channel<int>& left, channel<int>& right)
    {
      for(;;) {
        auto val = await left.pull();
        await right.push(val + 1);
      }
    }
    int main() {
      static const int N = 1000 * 1000;
      std::vector<channel<int>> c(N + 1);
      for(int i = 0; i < N; ++i)
        goroutine::go(pusher(c[i], c[i + 1]));
      c.front().sync_push(0);
      std::cout << c.back().sync_pull() << std::endl;
    }
    

写得心急,链接和文献就不生机勃勃一列举了。主要源于C++ committee website

  • Trasactional Memory: 底部支持,没什么好说的。基本是铁板钉钉。
  • Parallel STL

    差不离正是相互实现的stl,可以筛选形式,例如sort

    sort(begin(v), end(v)); //无并行
    sort(seq, begin(v), end(v)); //无并行
    sort(pal, begin(v), end(v)); //并行
    sort(par_vec, begin(v), end(v)); //并行矢量化
    execution_policy exec=seq; //动态决定
    if (v.size() > 1000) exec = par;
    sort(exec, begin(v), end(v));
    
  1. 言语用法简化
  • Concepts: 不说了
  • Ranges: 也可以有童鞋说过了,不说了。总体来说ranges便是一对数[i, j卡塔尔(英语:State of Qatar),也许局地iterator。需求对STL库实行加多支持针对Ranges的操作。举例你可以sort(v卡塔尔,而没有须要sort(begin(v卡塔尔(قطر‎, end(v卡塔尔卡塔尔国
  • Default comparisons:正是说会自动生成operator >, ==之类的。对客户自定义move只怕copy的不会自动生成。
  • Uniform call syntex:也是有童鞋说过了。

    现阶段以此议案大约是认可了:假如f(x,y卡塔尔国,那么就先找函数,若是函数未有,再找x.f(y卡塔尔。而x.f(y卡塔尔相反,找不到类x的f函数,再去找 f(x,y卡塔尔国函数。也可能有其余一个选项,正是x.f(y卡塔尔(قطر‎和f(x,y卡塔尔(قطر‎全体相符的全体放置一同然后做overloading resolution。那样只怕会破坏现存的代码。还也可以有2年岁月能够谈谈选哪一种。

  • Operator dot: 没什么可说的

  • array_view和string_view: 蛮风趣的东西。

    设若你有多个字符串“abcde, xyz",近日来讲,假诺你达成二个函数,从逗号分割那么些字符串,你会拿走2个字符串"abcd", "xyz"。但假如有了string_view,你会博得2个string_view,每个string_view里面是七个(start, size卡塔尔(英语:State of Qatar)对,那样就省去了八个字符串拷贝。

    array_view能够更有趣,

    auto M = 32;
    auto N = 64;
    auto v = vector<float>(M * N);
    auto av = array_view<float, 2>({M, N}, v);
    

    您要问为啥不间接vector<vector<float>>,因为那样不可能确认保证内部存款和储蓄器延续分配啊。

  • stack_array:还没有proposal

  • optional,和variant相同吧。前段时间从未有过proposal,除非pattern matching被加到c++17中去了,不然不太可能17里福寿齐天。

如上正是stroustrup桑眼里的c++17应当大致支持那一个。当然不是四个完好列表,不包涵部分库的精耕细作和语法小矫正。

 

 

 

不要想啊,C++ 17 毛都不曾。。。未有 Module, 未有 Coroutine, 未有Ranges,没有 Reflection,未有 Contracts,未有……
唯朝气蓬勃有期望的 Concepts 争论相当大。。也玄。
Network TS 也玄。
所以,……


自家的天,见到那一个主题材料本人打动得不掌握说些什么好。在 BS 的那篇 Thoughts about C++ 17 里面已经涉及了众多议事原案了。作者说一点笔者商量过的呢,算是进行试探:
先说一些消痈菜吧。

  • 模板的模版参数允许使用 typename(此前仅同意利用 class)
  • 修改了 initializer_list 的演绎原则:

For copy-list-initialization, auto deduction will either deduce a std::initializer_list (if the types of entries in the braced-init-list are all identical) or be ill-formed otherwise.

For direct list-initialization:
1.For a braced-init-list with only a single element, auto deduction will deduce from that entry;
2.For a braced-init-list with more than one element, auto deduction will be ill-formed.

  • 还缓慢解决了迷之 ill-formed/UB(那个详细请自行阅读http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4089.pdf)

    unique_ptr const []> ptr1(new Foo[10]); Foo const * ptr = ptr1[9];

  • 嵌套的 namespace:

    namespace A::B::C {

    //…
    

    }

相当于:

namespace A {
    namespace B {
        namespace C {
            //…
        }
    }
} 
  • Fold Expressions:

    template

    auto sum(T... s){

    return (... + s);
    

    }

再者说说大的:

  • Concepts

在CppCon 二零一六里边BS发布了宗旨为 Make Simple Things Simple 的讲演,里面涉及了Concepts。依照她的意味,我们以后能够如此写代码:

&lt;img src="" data-rawheight="717" data-rawwidth="964" class="origin_image zh-lightbox-thumb" width="964" data-original="

手机版美高梅网站 1注意!Sortable可不是Java/C#里的Interface,它叫做Concept。

  • Module

对此Module也能够说是意见相当高了,能够大幅度加快编写翻译速度,带给一定多的低价,可是笔者对于Module的议案未有太多商量。

  • Contracts

Contracts 近些日子的议事原案是N4415。大致敬思正是为每一种函数钦定一个pre-conditions 与 post-conditions。大约疑似那样:

T& operator[](size_t i) [[expects: i < size()]]; 

ArrayView(const vector<T>& v) [[ensures: data() == v.data()]];   

那么不满意那一个conditions会发生什么呢?议事原案中正是“implemention-defined”。并且应该允许各类TU独立张开装有的测量检验,关闭全体,展开/关闭pre,打按键闭post。

  • Unified Call Syntax

以此实乃太美观了。HS和BS分别提了生机勃勃篇议事原案,后来俩人又一齐弄了风流倜傥篇议案。这几个说的是怎么着呢,就是统生龙活虎f(x,y卡塔尔与x.f(y卡塔尔国,那样就不用std::begin三个,container.begin(卡塔尔又三个了。HS的议事原案中关系了这么的运用项景:

void f(FILE* file)
{
   fseek(file,9,SEEK_SET);
}

//proposed new C++ code
void f(FILE* file)
{
    file->fseek(9,SEEK_SET); //nice autocomplete after "->"
}

然最近后以此议案还应该有好多细节在情商。
说了部分笔者掌握的Core Language本性,说有个别库的事物吧!先说点小东西

  • std::invoke

让大家看看怎么着完毕多少个apply:

template <class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>)
{
    return std::invoke(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
    // Note: std::invoke is a C++17 feature
}
template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t)
{
    return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
        std::make_index_sequence < std::tuple_size<std::decay_t<Tuple>>::value > {});
} 

INVOKE的概念一向在正规里面,这回终于有了确实的invoke了。

  • void_t

有了Expression SFINAE和void_t,写模板真的是便利了太多了。就像是那样:

template<typename Iterator,
            typename = void>
    struct reference_type
    {
        using type = decltype(*declval<Iterator>()); // no reference, use operator*
    };

    template<typename Iterator>
    struct reference_type<Iterator,
        void_t<typename Iterator::reference>
    >
    {
        using type = typename Iterator::reference; //I have a reference
    }; 

并且说大的。方今那几个都归属 TS 。

  • 利用variable templates:

    namespace std { namespace experimental { inline namespace fundamentals_v2 {

    // See C++14 §20.10.4.1, primary type categories template constexpr bool is_void_v

    = is_void<T>::value;
    

    template constexpr bool is_null_pointer_v

    = is_null_pointer<T>::value;
    

    //....

  • filesystem

  • network
  • Ranges

Ranges!那个本人必得说一说。我们平时写

std::sort(std::begin(v),std::end(v),std::greater<>{});

那么些begin end太烦了。Ranges正是为着化解这几个标题:

std::sort(v,std::greater<>{});

无可置疑远远不止这点,Ranges 里面包车型客车事物还足以花样组合。你还足以写出如此的事物:

int total = accumulate(view::iota(1) |
                       view::transform([](int x){return x*x;}) |
                       view::take(10), 0);

实质上骨子里的概念仍旧挺多的,比如 Iterable 等等。详细的可以去看Ranges for the Standard Library, Revision 1 。

  • Type-erased Allocator

其意气风发确实是深得小编心啊!我方今正在依据前段时间的TS Draft完成这一个东西。正是说三个vector:

std::vector<int,std::allocator<int>> v1;
std::vector<int,MyAllocator<int>> v2;
v1 = v2;//Error

是因为Allocator归属类型的黄金时代局部,引致不一致Allocator的vector不能copy啊之类。并且个人感到std::allocator有一点鸡肋。那回好了,有了多少个誉为memory_resource的抽象类:

class memory_resource {
  // For exposition only
  static constexpr size_t max_align = alignof(max_align_t);

public:
  virtual ~memory_resource();

  void* allocate(size_t bytes, size_t alignment = max_align);
  void deallocate(void* p, size_t bytes,
                  size_t alignment = max_align);

  bool is_equal(const memory_resource& other) const noexcept;

protected:
  virtual void* do_allocate(size_t bytes, size_t alignment) = 0;
  virtual void do_deallocate(void* p, size_t bytes,
                             size_t alignment) = 0;

  virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
};

事后有七种内置的多态allocator:

  • new_delete_resource(),使用::operator new/delete
  • null_memory_resource(卡塔尔(英语:State of Qatar),使用allocate就能够抛出std::bad_alloc
  • synchronized_pool_resource
  • unsynchronized_pool_resource
  • monotonic_buffer_resource

有一个pmr::polymorphic_allocator的类满意Allocator requirements,将一个memory_resource包装起来:

#include <deque>

namespace std {
namespace experimental {
inline namespace fundamentals_v2 {
namespace pmr {

  template <class T>
  using deque = std::deque<T,polymorphic_allocator<T>>;

} // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
} // namespace std

#include <forward_list>

namespace std {
namespace experimental {
inline namespace fundamentals_v2 {
namespace pmr {

  template <class T>
  using forward_list =
    std::forward_list<T,polymorphic_allocator<T>>;

} // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
} // namespace std

本来,小编只是说了自个儿询问的。还恐怕有大多任何的产出、并行算法、SIMD vector、string_view/array_view、optional/variant/any小编从没做浓烈通晓,就不诱导大家了。

本文由手机版美高梅网站发布于新闻,转载请注明出处:0x核心进展的朝气蓬勃组简讯代码

关键词: