社区应用 最新帖子 精华区 社区服务 会员列表 统计排行 银行

  • 26561阅读
  • 45回复

C++0x2011年8月10日获通过正式成为国际标准

级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 40楼 发表于: 2013-03-16
主流c++编译器-Visual Studio, GCC, Clang, Intel 对 C++11 特性的支持一览表

GCC的下个版本是4.8,以及Clang即将到来的版本是3.3 。如果你使用Visual Studio 2012,你可以安装2012年11月更新支持C++11额外特征的体验版CTP。

throwable
throwable
翻译于 2天前

0人顶

 翻译的不错哦!

我也对V.13.0的Intel C++编译器感到好奇,虽然它还不是预览版并且我也找不到有关它的新特性的信息。我没找到任何有关这个即将发行版本的编译器的信息。

FeatureVS2012
Nov CTP
g++ 4.8Clang 3.3Intel 13.0
autoYesYesYesYes
decltypeYesYesYesYes
Rvalue references and move semanticsYesYesYesYes
Lambda expressionsYesYesYesYes
nullptrYesYesYesYes
static_assertYesYesYesYes
Range based for loopYesYesYesYes
Trailing return type in functionsYesYesYesYes
extern templatesYesYesYesYes
>> for nested templatesYesYesYesYes
Local and unnamed types as template argumentsYesYesYesYes
Variadic macrosYesYesYesYes
Variadic templatesYesYesYesYes
Default template arguments in function templatesYesYesYesYes
final method keywordYesYesYesNo
override method keywordYesYesYesNo
Strongly typed enumsYesYesYesPartial
Forward declared enumsYesYesYesPartial
Initializer listsYesYesYesPartial
explicit type conversion operatorsYesYesYesNo
Raw string literalsYesYesYesNo
Forwarding constructorsYesYesYesNo
Template aliasesNoYesYesYes
Defaulted methodsNoYesYesYes
Deleted methodsNoYesYesYes
New built-in typesPartialYesYesPartial
Alignment supportPartialYesYesNo
Inline namespacesNoYesYesNo
sizeof on non-static data members without an instanceNoYesYesNo
Changed restrictions on union membersNoYesYesNo
User defined literalsNoYesYesNo
Encoding support in literalsNoYesYesNo
Arbitrary expressions in template deduction contextsNoYesYesDon’t know
Non-static data member initializersNoYesYesDon’t know
noexceptNoYesYesPartial
constexprNoYesYesPartial
C99 compatibilityPartialYesPartialYes
Generalized attributesNoYesPartialYes
Thread local storagePartialYesNoPartial
Inheriting constructorsNoYesNoNo
Rvalue references for *thisNoNoYesNo
Minimal support for garbage collectionYesNoNoDon’t know


看起来GCC正取代Clang成为最支持C++11的编译器。Visual Studio已经增加了好几个重要C++11特性,像变参模板,初始化器和原生字。

jimmyjmh
jimmyjmh
翻译于 2天前

0人顶

 翻译的不错哦!

我真的不能在一个更为细致的层面去评论这些编译器实现到底完成得怎样,还有没有bug。(除了VS2012——我在我的书(《C++11 Rocks》)里详细列出过VS2012最初版本的大量bug)。

看下库的支持情况也是比较有用的。由于各编译器对标准库的支持都有较多小改动,我并不打算对此给出详细的细节。我也打算在这次的比较中省略Intel的库。

我可以说,这些库的主要附件大多由第三方实现提供(随后在下面的表格中展现),尽管这是有各种各样的警告。

throwable
throwable
翻译于 昨天(14:03)

0人顶

 翻译的不错哦!

微软的库实现中没有那些需求尚未被实现的语言功能的东西,例如 constexpr(如VS2012的最初发行版)。库文件还没有更新,以支持2012年11月在 CTP 提出的编译器功能,如初始化列表和可变参数模板。

GCC 的 libstdc++ 也有些滞后,例如它并不支持正则表达式以及地称并发功能。同样,在很多情况下,它也没有实现 constexpr 方法。

Khiyuan
Khiyuan
翻译于 昨天(12:06)

0人顶

 翻译的不错哦!

Clang的libc++是100%兼容MacOS的,但是它有部分的特性还不兼容Windows和Linux。

FeatureMSVClibstdc++libc++
Concurrency: async/future/promise/packaged_taskYesYesYes
Concurrency: thread and relatedYesYesYes
Concurrency: condition variablesYesYesYes
Concurrency: mutexesYesYesYes
Concurrency: atomic types and operationsYesYesYes
Concurrency: relaxed memory ordering and fencesYesNoYes
Smart pointersYesYesYes
TuplesYesYesYes
std::bindYesYesYes
std::functionYesYesYes
Regular expressionsYesNoYes
Type traitsYesPartialYes
std::forward_listYesYesYes
std::arrayYesYesYes
Hash tablesYesYesYes
Random number generationYesYesYes
Compile time rational numbers (ratio)YesYesYes
Time utilities (chrono)YesYesYes
Initializer listsYesYesYes
Diagnostics (system_error)YesYesYes
STL refinements and new algorithmsYesYesYes
General purpose (move, forward, declval etc.)YesYesYes


比较高兴的是能看到语言和库的支持在稳步改善。Clang和GCC距离完全支持C++11已经很近了。Visual Studio同样在改善对C++11的支持,令我感到欣慰的是C++编译器的更新都是在主分支上。这份Intel的编译器特征支持列表也越来越多。

谁知道明年这4个编译器会不会全部支持C++11的特征呢!

QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 41楼 发表于: 2013-04-23
Clang 宣布全面支持 C++11 标准
Clang 的开发者宣布支持所有的 C++11 语言标准特性,C++11 语言标准是在 2011年夏季发布的。最新的 ISO 标准特性添加了支持继承构造器和 thread_local 变量。


LLVM 3.3 和 Clang 计划在 2013年6月推出,这应该是首个完全支持 C++11 特性的编译器。而今年3月发布的 GCC 4.8 版本尽管也支持大多数该语言特性,但还是有很少一部分尚未实现,详情请看此页。关于支持 C++11 标准的编译器概览可以查看此页。


现在 Clang 对 C++11 的支持已经完成,开发者将继续实现对其他 C++ 特性的支持,目前已经在开始实现 C++1y 特性,也就是 C++14,这是 C++ 的下一个小更新版本,计划在 2014 年推出。Clang 将支持其普通 lambdas、返回类型的简化处理以及更好的处理 constexpr 关键字。
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 42楼 发表于: 2013-07-02
Visual Studio 2013 对 C++ 标准支持情况
微软过去经常在支持 C++ 标准方面倍受批评,特别是其对 C99 和 C++98 的支持都还没有完全实现,而现在优先级在 C++11 和其继任者 C++14 估计也好不到哪去。拿 C++11 来说,该标准发布已经将近 2 年时间了,Visual Studio 2013 也只是将实现该标准最重要部分而已。


在今年微软的 BUILD 大会上发布了 Visual Studio 2013 正式版,该版本实现了 C++11 语言规范中的大多数函数,而其他诸如 GCC 和 LLVM 编译器架构过去也刚刚完全实现了所有 C++11 的特性,这比微软要早不少时间。


来自微软的 Herb Sutter 领导着 C++ 标准委员会,承诺微软将完全实现 C++14 规范,目前该规范尚未最终定稿,还有下下一个版本 C++17.


微软也计划要在 C# 5.0 实现 async 和 await 关键字,这允许异步的调用某个函数。这并不是 C++ 语言规范的部分,可能会在 2013  以后的版本中实现。


Visual Studio 2013 的新特性介绍请看这里。


你可以通过 这里 来获取 Visual Studio 2013 预览版,使用 "Go Live" 许可证,该许可证允许微软开发者在产品环境中使用该软件。
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 43楼 发表于: 2013-07-19
Apache 基金会决定废弃其 C++ 标准库
Apache 软件基金会决定结束其 Apache C++ 标准库项目 —— stdcxx。


该项目远没有 GCC 的 libstdc++ 甚至是 LLVM 的 libc++ 使用广泛。自动 2005 开始 Apache 一直在支持 stdcxx 的开发。这是一个 ISO/IEC 14882 C++ 标准的免费开源实现库,这是在 Rogue Wave 软件开源了其商业实现之后的事情。


最新版本的 stdcxx 版本是 4.2.1 ,这是 2008 年中发布的。在本月的 ASF 董事会上已经做出决定将停止该项目开发和支持。该决定是通过 stdcxx mailing list 发布的。


当然,这样的行为肯定会招来反对的声音,有人称这是官僚主义下的愚蠢决定,因为该项目还很有潜力。


如果想了解更多 stdcxx 的信息,可访问该项目官网 stdcxx project page
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 44楼 发表于: 2013-07-27
VS2013中的C++11新特性
介绍


Visual C++ 2013 Preview 在6月发布了,C++开发者又找到一个编译器可以更好的支持ISO C++ 11 的特性了.本文介绍了这些新的特性并附有代码实例.
你想动手尝试编译文中的这些代码话,需要去下载并安装Visual Studio 2013 Preview (话说:付费吗?),我尚未在其他编译器上测试这些代码,所以我并不知道与Gcc 或Clang的兼容性(可恶的C++).
MtrS
MtrS
翻译于 4天前
0人顶
顶 翻译的不错哦!
原始字符串字面值


VC++ 2013现在支持原始字符串字面值了。注意:它并不支持统一码字符串字面值。一个原始字符串字面值允许你避免转义那些在HTML,XML和正则表达式里运用得得心应手的特殊字符。下面是一个示例用法:
1
auto s1 = R"(This is a "raw" string)";
现在,s1是一个指向常量字符串值为“This is a "raw" string”的指针。尽管不支持嵌套双引号,这与C#支持的@string文字是类似的。那么要在一个字符串字面值中嵌入R"(...)"会怎样。这种情况下,你可以使用以下语法:
1
auto s2 = R"QQ(Example: R"(This is my raw string)")QQ";
现在,s2包含 Example: R"(This is my raw string)"。 在这个例子中,我把QQ作为界定符。这个界定符可以是任何长度不超过16的字符串。原始字符串字面值也可以包含换行:
1
auto s3 = R"(<tr>
2
<td>data</td>
3
</tr>)";
最后,不论他们什么时候添加统一码字符串字面值的支持,你都可以将它们连接起来并构成原始统一码字符串字面值。
jimmyjmh
jimmyjmh
翻译于 3天前
0人顶
顶 翻译的不错哦!
可变参数模板


可变参数模板是一个允许多个参数的模板。在我看来,这是个提供给库作者而不是给库使用者的特性,所以我也不是很确定它在C++程序员中会有多流行。以下我们用一个非常简单的例子来展示如何在实际开发中使用可变参数模板。
01
// Variadic template declaration
02
template<typename... Args> class Test;
03

04
// Specialization 1
05
template<typename T> class Test<T>
06
{
07
public:
08
  T Data;
09
};
10

11
// Specialization 2
12
template<typename T1, typename T2> class Test<T1, T2>
13
{
14
public:
15
  T1 Left;
16
  T2 Right;
17
};
18

19
void Foo()
20
{
21
  Test<int> data;
22
  data.Data = 24;
23

24
  Test<int, int> twovalues;
25
  twovalues.Left = 12;
26
  twovalues.Right = 15;
27
}
当使用可变参数模板时,智能感应(intellisense)能很好地配合我们的开发。可变参数模板的实现包括一个叫asizeof的函数,这个函数能返回这个模板的参数个数。
01
template<typename... Args> class Test
02
{
03
public:
04
  size_t GetTCount()
05
  {
06
    return sizeof...(Args);
07
  }
08
};
09

10
// . . .
11

12
Test<int> data;
13
size_t args = data.GetTCount(); //1
14

15
Test<int, int, char*> data2;
16
args = data2.GetTCount(); //3
17

18
Test<int, float> data3;
19
args = data3.GetTCount(); //2
这其实就是一个数个数的例子,但我猜他们之所以使用一个现存的函数名是因为这样子做会让C++程序员们更容易上手。
大志darcy
大志darcy
翻译于 4天前
0人顶
顶 翻译的不错哦!
对于可变参数模板,一个常用的做法就是专攻其中一个参数,然后把其余的参数都变为可选。这个做法可以以递归的形式实现。以下是一个比较傻的例子,但它能让你明白什么时候不应该用可变参数模板,继而更好地了解这个语言特性。
01
template<typename... Args> class Test;
02

03
// Specialization for 0 arguments
04
template<> class Test<>
05
{
06
};
07

08
// Specialization for at least 1 argument
09

10
template<typename T1, typename... TRest> class Test<T1, TRest...>
11
  : public Test<TRest...>
12
{
13
public:
14
  T1 Data;
15

16
  // This will return the base type
17
  Test<TRest...>& Rest()
18
  {
19
    return *this;
20
  }
21
};
22

23
void Foo()
24
{
25
  Test<int> data;
26
  data.Data = 24;
27

28
  Test<int, int> twovalues;
29
  twovalues.Data = 10;
30
  // Rest() returns Test<int>
31
  twovalues.Rest().Data = 11;
32

33
  Test<int, int, char*> threevalues;
34
  threevalues.Data = 1;
35
  // Rest() returns Test<int, int>
36
  threevalues.Rest().Data = 2;
37
  // Rest().Rest() returns Test<char*>
38
  threevalues.Rest().Rest().Data = "test data";
39
}
大家请注意了,千万别把代码写成这样。这个例子仅仅是用来教学的,正确的做法我会在下一个章节中告诉大家。
大志darcy
大志darcy
翻译于 4天前
1人顶
顶 翻译的不错哦!
Tuple的实现


我们来看一下std tuple的头文件 (由VC++团队的Stephan T. Lavavej负责维护 - 最初的代码由P.J. Plauger编写),浏览这些代码,让我的大脑几乎要宕掉了。为了更好的理解代码,我将代码进行简化,摘出其中可以访问tuple的值的最少的代码(能够支持读和写)。这有助于理解在设计模板类时,通常可变参数模板是如何通过递归展开来大幅减少代码的行数。
01
// tuple
02
template<class... _Types> class tuple;
03

04
// 空tuple
05
template<> class tuple<> {};
06

07
// 递归的tuple定义
08
template<class _This,
09
  class... _Rest>
10
  class tuple<_This, _Rest...>
11
  : private tuple<_Rest...>
12
{
13
public:
14
  _This _Myfirst;
15
};
LinuxQueen
LinuxQueen
翻译于 3天前
0人顶
顶 翻译的不错哦!
这里的递归特化使用了继承,因此tuple的每个类型成员都确定的时候递归会终止。读取tuple值的时候,tuple_element类起到读取辅助类的作用。
01
// tuple_element
02
template<size_t _Index, class _Tuple> struct tuple_element;
03

04
// select first element
05
template<class _This, class... _Rest>
06
struct tuple_element<0, tuple<_This, _Rest...>>
07
{
08
  typedef _This& type;
09
  typedef tuple<_This, _Rest...> _Ttype;
10
};
11

12
// recursive tuple_element definition
13
template <size_t _Index, class _This, class... _Rest>
14
struct tuple_element<_Index, tuple<_This, _Rest...>>
15
  : public tuple_element<_Index - 1, tuple<_Rest...> >
16
{
17
};
这里又一次使用了递归继承,同时边界条件也特化了。注意这里的两个typedef,其中一个定义为对应值类型的引用,另一个定义为和tuple_element类型参数相同的tuple类型。因此,给定一个_Index值,在那个递归层次上我们就能得到对应tuple的类型和tuple值的类型。下面的get方法就使用了这个特性。
1
// get reference to _Index element of tuple
2
template<size_t _Index, class... _Types> inline
3
  typename tuple_element<_Index, tuple<_Types...>>::type
4
  get(tuple<_Types...>& _Tuple)
5
{
6
  typedef typename tuple_element<_Index, tuple<_Types...>>::_Ttype _Ttype;
7
  return (((_Ttype&) _Tuple)._Myfirst);
8
}
无奈的钝刀
无奈的钝刀
翻译于 昨天(12:28)
0人顶
顶 翻译的不错哦!
注意返回类型,它使用上面定义的类型 typedef。同样,元组(tupleis)转换为上述定义过的类型 _TType ,然后我们访问 _Myfirst 成员 (它表示的值)。现在你可以如下所示,编写代码,
1
tuple<int, char> t1;
2
get<0>(t1) = 959;
3
get<1>(t1) = 'A';
4

5
auto v1 = get<0>(t1);
6
auto v2 = get<1>(t1);
现在 , 这 不用 说 , 但 我会 说 只是 可以 肯定 的是 ------ 这 里只 是 为了 演示 。 不 要在 实际 代码 中 使用 这些 方法, 而是调用 std::tuple, 它可以完成比 这 一切多的功能 ( 这就是为什么他有800行长).
MtrS
MtrS
翻译于 昨天(9:11)
0人顶
顶 翻译的不错哦!
代理构造函数


代理构造函数已经在C#中用了好长时间,所以将其引入到C++中也很不错。编译器允许一个类型的构造函数(代理构造函数)在其初始化列表中包含另一个构造函数。以前编写代码形式如下:
01
class Error
02
{
03
public:
04
  Error()
05
  {
06
    Init(0, "Success");
07
  }
08

09
  Error(const char* message)
10
  {
11
    Init(-1, message);
12
  }
13

14
  Error(int errorCode, const char* message)
15
  {
16
    Init(errorCode, message);
17
  }
18

19
private:
20
  void Init(int errorCode, const char* message)
21
  {
22
    //...
23
  }
24
};
采用代理构造函数是,可以写成如下形式:
01
class Error
02
{
03
public:
04
  Error() : Error(0, "Success")
05
  {
06
  }
07

08
  Error(const char* message) : Error(-1, message)
09
  {
10
  }
11

12
  Error(int errorCode, const char* message)
13
  {
14
    // ...
15
  }
16
};
相关阅读-  Herb Sutter和Jim Hyslop在十年前(2003年5月)写的一篇有趣的关于代理构造函数的文章。
Delegating Constructors
soaring
soaring
翻译于 2天前
0人顶
顶 翻译的不错哦!
函数模板中的默认模板参数


这是VC++ 2013现在支持的另一项C++ 11特性。目前为止,下面的代码仍然无法通过VC++编译。
1
template <typename T = int> void Foo(T t = 0) { }
2

3
// error C4519: default template arguments are only
4
// allowed on a class template
Visual C++ 2013 能够顺利编译这些代码,模板参数推断也能正确进行。
1
Foo(12L); // Foo<long>
2
Foo(12.1); // Foo<double>
3
Foo('A'); // Foo<char>
4
Foo(); // Foo<int>
这项特性的实用性在下面的例子里尤为明显。
01
template <typename T> class Manager
02
{
03
public:
04
  void Process(T t) { }
05
};
06

07
template <typename T> class AltManager
08
{
09
public:
10
  void Process(T t) { }
11
};
12

13
template <typename T, typename M = Manager<T>> void Manage(T t)
14
{
15
  M m;
16
  m.Process(t);
17
}
18

19
Manage(25); // Manage<int, Manager<int>>
20
Manage<int, AltManager<int>>(25); // Manage<int, AltManager<int>>
并不是所有的参数都需要默认参数。
1
template <typename B, typename T = int> void Bar(B b = 0, T t = 0) { }
2

3
Bar(10); // Bar<int, int>
4
Bar(10L); // Bar<long, int>
5
Bar(10L, 20L); // Bar<long, long>
6
Bar(); // will not compile
如果带默认参数的函数模板有重载的话,类型无法推断的时候编译器将会给出错误。
1
template <typename T = int> void Foo(T t = 0) { }
2
template <typename B, typename T = int> void Foo(B b = 0, T t = 0) { }
3

4
Foo(12L); // will not compile
5
Foo(12.1); // will not compile
6
Foo('A'); // will not compile
7
Foo(); // Foo<int>
使用函数模板的默认模板参数时应当在这里注意。
无奈的钝刀
无奈的钝刀
翻译于 2天前
0人顶
顶 翻译的不错哦!
显式转换运算符


我仍然记得2004年八月的一天,那个时候我意识到尽管我是一个还不错的C++程序员,我对explicit关键字一无所知,这令我十分局促不安。那之后我写了一篇博客文章
Applying explicit on your constructors(需要翻墙)
简单说明一下explicit的使用。考虑一下下面的例子。
01
class Test1
02
{
03
public:
04
  explicit Test1(int) { }
05
};
06

07
void Foo()
08
{
09
  Test1 t1(20);
10
  Test1 t2 = 20; // will not compile
11
}
尽管转换构造函数可以达到这一目的,转换运算符因为缺乏标准支持而无法完成类似的任务。坏消息是你无法确保转换构造函数和转换运算符的行为是一致的。考虑一下下面的例子。
01
class Test1
02
{
03
public:
04
  explicit Test1(int) { }
05
};
06

07
class Test2
08
{
09
  int x;
10
public:
11
  Test2(int i) : x(i) { }
12
  operator Test1() { return Test1(x); }
13
};
14

15
void Foo()
16
{
17
  Test2 t1 = 20;
18
  Test1 t2 = t1; // will compile
19
}
上面的代码能通过编译。现在有了C++ 11的新特性,explicit也可以用在转换运算符上了。
01
class Test2
02
{
03
  int x;
04
public:
05
  Test2(int i) : x(i) { }
06
  explicit operator Test1() { return Test1(x); }
07
};
08

09
void Foo()
10
{
11
  Test2 t1 = 20;
12
  Test1 t2 = (Test1)t1; // this compiles
13
  Test1 t3 = t1; // will not compile
14
}
下面的这个例子里隐式应用了bool类型的转换运算符。
01
class Test3
02
{
03
public:
04
  operator bool() { return true; }
05
};
06

07
void Foo()
08
{
09
  Test3 t3;
10
  if (t3)
11
  {
12
  }
13

14
  bool b = t3;
15
}
这段代码能通过编译。现在试一下在运算符上加上explicit关键字
01
class Test3
02
{
03
public:
04
  explicit operator bool() { return true; }
05
};
06

07
void Foo()
08
{
09
  Test3 t3;
10
  if (t3) // this compiles!
11
  {
12
  }
13

14
  bool b = t3; // will not compile
15
}
正如预期,第二个转换无法通过编译,但是第一个通过了。这是因为if里的bool转换被视为显式转换。因此在这里你要小心谨慎,仅仅添加explicit关键字无法防止意外情况下的类型转换,类型可能仍然是不安全的。
无奈的钝刀
无奈的钝刀
翻译于 2天前
0人顶
顶 翻译的不错哦!
初始化列表和统一初始化


一直以来我们都可以用初始化列表初始化数组,现在对于有类型为std::initializer_list<T>(包含构造函数)的类型我们也可以这么做。标准库中的容器现在都支持这一特性。
01
void foo()
02
{
03
  vector<int> vecint = { 3, 5, 19, 2 };
04
  map<int, double> mapintdoub =
05
  {
06
    { 4, 2.3},
07
    { 12, 4.1 },
08
    { 6, 0.7 }
09
  };
10
}
自己实现这些功能很浪费时间
1
void bar1(const initializer_list<int>& nums)
2
{
3
  for (auto i : nums)
4
  {
5
    // use i
6
  }
7
}
8

9
bar1({ 1, 4, 6 });
用户自定义类型也可以使用这一特性
01
class bar2
02
{
03
public:
04
  bar2(initializer_list<int> nums) { }
05
};
06

07
class bar3
08
{
09
public:
10
  bar3(initializer_list<bar2> items) { }
11
};
12

13
bar2 b2 = { 3, 7, 88 };
14

15
bar3 b3 = { {1, 2}, { 14 }, { 11, 8 } };
C++11也新增了一个相关特性:统一初始化( Uniform initialization)。这一特性将自动匹配合适的构造函数
01
class bar4
02
{
03
  int x;
04
  double y;
05
  string z;
06

07
public:
08
  bar4(int, double, string) { }
09
};
10

11
class bar5
12
{
13
public:
14
  bar5(int, bar4) { }
15
};
16

17
bar4 b4 { 12, 14.3, "apples" };
18

19
bar5 b5 { 10, { 1, 2.1, "bananas" } };
使用初始化列表的构造函数将被优先使用
01
class bar6
02
{
03
public:
04
  bar6(int, int) // (1)
05
  {
06
    // ...
07
  }
08

09
  bar6(initializer_list<int>) // (2)
10
  {
11
    // ...
12
  }
13
};
14
  
15
bar6 b6 { 10, 10 }; // --> calls (2) above
就是这些内容。像往常一样,欢迎反馈和批评建议。谢谢。
QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
级别: 管理员
发帖
8532
金币
2762
威望
3231
贡献值
0
元宝
0
只看该作者 45楼 发表于: 2014-11-26
C++17 将会增加什么?
这是我对当前在厄巴纳举行的C++委员会会议上的提案方面文章的第三部分。 这次是全部关于子组变革的,对这方面,我写了很多文章,所以这仅仅是第一部分。 前面那些部分是关于并发(concurrency)的, 然后 第二部分是关于核心,网络,模型以及未定义行为方面的。
变革
N4126 - 显式默认比较操作符


这个提议已经在上一部分的反射部分提到了,在那里我们用反射和std::tie解决这个问题。这份提议想让 = default变得合法; 对于所有的操作符 (>,<,==,!=, ...)。这些操作符仍然使用友元方法来实现,如下例所示:
?
1
2
3
4
5
6
7
8
9
10
class Thing
{
    int a, b;
public:
    // ...
    friend bool operator<(const Thing&, const Thing&) = default;
    friend bool operator>(const Thing&, const Thing&) = default;
    friend bool operator<=(const Thing&, const Thing&) = default;
    friend bool operator>=(const Thing&, const Thing&) = default;
};


junker
junker
翻译于 1周前
1人顶
顶 翻译的不错哦!
N4127 - 检查后的解引用条件
因为已经提议过有范围的for(ranged-for)循环,这个提议转移到auto和默认类型.如果没有提供类型,它也希望,在其它语句中,引进或采用有范围的for的语法,使之合法,例如if语句:
?
1
2
std::weak_ptr<foo> wp;
if(x: wp.lock())
对于C++来说,这是一个巨大的改变,并且不是每个人都喜欢它,特别地,编译器的创建者不得不处理这所波及的范围.然而,如果委员会认可了下个版本的有范围的for循环,那么在其他C++控制结构,如if,while,for等,中允许同样的语法也就说得通了.
gones945
gones945
翻译于 1周前
1人顶
顶 翻译的不错哦!
N4131 - 显式的绝不应该是隐式的


这篇文章对应的是N4074,它争论提议的变化内容,即让{expr}显式的返回是错误的,因为显式的决不应该是隐式的.关于草案中的更多细节,作者甚至给出了一个例子,说N4074提案可能导致未定义的行为.
N4135 -运行时按规定校验的语言支持 (修订8)


作者提供了很好的概述:
如果足够仔细,我们可以创建本质上无缺陷的库.但是即便是最好的库,只要使用不当,都可能产生灾难性的的后果.运行时按规定校验的实际应用:当函数调用时,检测前缀条件的过程,有助于在早期测试中,发现误用的情况.同时也有助于提升开发速度,增强软件健壮性.将按规定校验拓展为开发阶段而不仅仅是早期测试阶段,将带来更多长远的益处.




gones945
gones945
翻译于 1周前
0人顶
顶 翻译的不错哦!
N4147 - 内联变量,或封装表达式
作者再一次提供了很好的概述:
内联函数为对外无法暴露对象的接口,提供了合适的行为.尽管是不自然的样版,通常还是会鼓励用户使用它们来包装全局变量.其它的变通方法包括类的静态数据成员,枚举,宏和变量模板,所有这些都有奇怪的语法或缺陷,限制了适用性.这个提议在变量定义上面指定了inline标识符,这意味着在语义上类似于内联函数的评估和链接.更通用的,这为命名值或非持续性变量提供了一种工具,它可以替代或补充 各种各样的变通方法.


N4148 - 不允许来自易拷贝类型的不可访问操作符


当前对于易拷贝类型(trivially copyable type)的定义有一个缺陷:它对于不可访问的/删除的 拷贝/移动 构造函数和赋值操作符同样有效.一个易拷贝对象也可以通过使用std::memcpy来拷贝,特别是当有一个易拷贝对象数组的时候,这在性能上更优.然而,对于一个删除的/不可访问的 拷贝/移动 构造函数或者赋值操作符,这样做是不明智的.作者提议更新标准里面的措辞,并提高特性,让std::is_trivially_copyable针对不可访问的/删除的 拷贝/移动 构造函数和操作符返回错误.
gones945
gones945
翻译于 1周前
0人顶
顶 翻译的不错哦!
N4149 - 明确且合适的类


同样的,这篇文章也有很好的概述:
一些类只在某些上下文中工作: 作用域守护(scope guard)作为子表达式通常是没有用处的,表达式模板占位符作为局部变量也会出现问题.一个没有使用的函数的结果可能意味着调用者会使用不同的协议,如std::async.这个提议拓展了类的声明来阻止这类错误,并增加了通过类型替换自动解决它们的技术,例如一个表达式模板的值类型.另外,不可移动的对象的生成变得更加容易处理.


增加的功能包括"自动评估"提议里面提到的.这个提议更具表现力,可以更广泛的应用,并且易于接受和使用.




gones945
gones945
翻译于 5天前
0人顶
顶 翻译的不错哦!
N4150 - 别名集合属性: 针对C++中restrict一样的别名语义
这个提议想增加restrict修饰符到C++,因为它已经存在于C99之中,同时,一些编译器已经提供了restrict作为一个C++拓展。由于目前没有定义restrict修饰符,作者寻求定义如何正确的使用它,特别是在C++ 11中像lambda一样的特性。
N4152 - 未捕获的异常


这篇文章想提高std::uncaught_exception的可用性:
函数 int std::uncaught_exceptions() 返回了异常对象的数目,这些对象已经初始化,并被抛出或者被重新抛出,但是没有激活任何处理程序.




gones945
gones945
翻译于 3天前
0人顶
顶 翻译的不错哦!
N4154 - 操作符断言
这个提议想让assert(断言)成为语言结构,而不是一个宏定义:
assert宏定义从未表现得像一个真正的函数,在可以预见的未来,它将更像是一个操作符.在C中宏定义的表现方式,阻止了生产模式下的优化,但是在调试模式下却允许产生任意的副作用.增加assert作为一个关键字和内置的操作符将产生益处,而不会存在任何副作用.


N4160 - 值约束


这篇文章分析了如何在C++中支持契约式编程(contract programming)风格的特性.它尝试着提供一个概况,关于如何在编译时而不是运行时检查的时候支持契约.作者定义了文档的范围,如下:
鉴于[N1962] 是一篇关于在C++之中增加契约式编程支持的相当完整的提议,这个文档提供的是问题范围,而不是一个特定的提议.我们集中于确认期望值,潜在的实现困难以及代价.


我们知道的其它契约式编程提议 — [N4075], [N4110] — 建立在一个假设之上.即前置条件的支持,必须以提供某种形式之下:在函数调用之前评估前置条件,偶尔取消前置条件的评估以及安装未履行契约的处理程序.在这篇文章中,我们不会想当然的做这种假设.运行时支持只是我们分析范围的一个子集.我们更细致的探索了一个可选方案:集中于静态分析.




gones945
gones945
翻译于 3天前
0人顶
顶 翻译的不错哦!
N4164 - 前向引用
作为正式的通用引用, 类型T&& 总是右值(r-value)引用,除了作为模板参数或者使用了auto关键字。技术上仍然是右值引用,但是在这种情况下,表现上是非常不同。到目前为止,标准不识别这点,作者想介绍这个术语前向引用(forwarding reference),关于在模板和auto关键字之中的右值引用。
N4165 - 统一调用语法


成员函数的调用语法是x.f() 或者 x->f(),而非成员函数则是f(x).这在泛型编程代码中会是一个问题,因为没有统一的调用语法,而泛型编程代码必须决定是调用成员函数还是非成员函数。
为了解决这个问题,作者提议允许使用语法x./->f()来调用自由函数,如果函数的第一个参数是x的指针或者引用。这也很好的满足C的用法,当函数第一个指针参数是一个结构体的时候。作者使用FILE*和fseek作为例子。
gones945
gones945
翻译于 3天前
0人顶
顶 翻译的不错哦!
N4166 - 可移动的初始化列表


当前,std::initializer_list不是可移动的,它是在移动语义变得重要之前设计的.同时,那个时候只提供拷贝语义看起来是足够的,但是今天的情况已经发生了变化.作者提议一个模板化版本的std::intializer_list,它继承于非右值intializer_list类型:
template< typename T >
struct initializer_list< T && >
  : initializer_list< T > {
这个构造实现了所有权和移动语义.
gones945
gones945
翻译于 3天前
0人顶
顶 翻译的不错哦!
N4172 - 命名参数


命名参数的语法看起来和提议中的 "有范围的for(ranged-for)循环" 类似。但是在近似(几乎一样)的语法表达下面,两者有不同的意义。在一个函数调用过程中,你可以像下面例子中这样对命名参数赋值:
?
1
2
void foo(int x, int y, int z);
foo(40,z: 30, y:20);
在这个例子里面的函数调用过程中,参数z的值是30, 参数x的值是40。另外,非命名参数不能放在命名参数之后。
nzchris
nzchris
翻译于 2天前
0人顶
顶 翻译的不错哦!
N4173 - 点操作符


同样的,这篇文章也有很好的概述:
这个提议允许用户定义点操作符(操作符.()),这样我们可以提供"智能引用"类似于"智能指针".这个提议的要点在于,如果类Ref定义了操作符.(),那么默认在Ref对象上的每个操作都在操作符.()的结果之前.不管怎样,显式声明为Ref成员函数的操作,应用到Ref对象上时不需要前置.程序员可以通过声明操作符.()为private,来阻止指向一个引用对象的指针"渗透"到更大的程序之中.


N4174 - 调用语法: x.f(y) vs. f(x,y)


这个很像N4165 - 统一调用语法.简单的描述:
基本的建议是定义x.f(y)和f(x,y)是等价的.另外,为了增加兼容性和模块性,我建议探索,当查询可调用成员函数(或函数对象)时,忽略不可调用和不可访问的成员函数的可能性,.




gones945
gones945
翻译于 1天前
0人顶
顶 翻译的不错哦!
N4175 - 系统设定的比较
这份文档广泛的讨论了在C++中预设的比较该是什么样子,以及它能够将比较运算符设置为默认值有什么意义。本文和N4126有很大关联,同时也与N4239相对应。
N4176 - 对比较的思考
Bjarne总结了下关于预设比较的讨论:
这是一份摘录了系统预设比较草稿的部分讨论的摘要。它提出了许多提议并且根据一系列标准做了比较。我将会对关于比较标准的选择有关的评论尤其感兴趣(故意的双关语)。






英文原文:Where will Evolution lead C++17?


http://www.oschina.net/translate/where-will-evolution-lead-cpp17?p=2#comments



参与翻译(4人)gones945, junker, nzchris, MagicBLS


QQ: 378890364 微信:wwtree(省短信费) 紧急事宜发短信到0061432027638  本站微博:http://t.qq.com/wwtree QQ群:122538123
描述
快速回复

您目前还是游客,请 登录注册
批量上传需要先选择文件,再选择上传