2015年4月 C/C++大版内专家分月排行榜第三
匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。c++类中私有成员只能通过类设定的接口函数访问。举个例子_百度知道
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。
c++类中私有成员只能通过类设定的接口函数访问。举个例子
我有更好的答案
class person{
public getName() {
return this-&
}};在这段代码中如果要获取person类的name值，必须要调用getName函数，假如有一个person类型的变量p，则如果要获取p的name需要进行如下的操作p.getName()而不能直接用p.name获取
采纳率：29%
b =错误int b =/正确a.SetPrivate(1);//&#47.m_&#47class A{private:int m_public.m_public = 1;/a;错误a;/&#47:int m_public:void SetPrivate(int temp){m_private =}int GetPrivate(){return m_private.m_private = 1;/正确int b = a.GetPrivate();/&#47.m_}}A a
本回答被网友采纳
public func{
cout&&a&&}
class Gun{ private:
int fire();
void reload(unsigned int);}Gun::fire(){
if(bullets&0)
bullets--;
return -1;
}void Gun::reload(unsigned int counts){
rife.reload(10);
//私有变量赋值
// rife.bullets =10; 这样用编译器会报错 因为是私有变量
if(rife.fire()==0)
//私有变量bullets 值发生变化
其他1条回答
为您推荐：
其他类似问题
函数的相关知识
换一换
回答问题，赢新手礼包C++11 新特性：Lambda 表达式 | DevBean Tech World
&/&&/&C++11 新特性：Lambda 表达式
C++11 新特性：Lambda 表达式
参考文章：
或许，Lambda 表达式算得上是 C++ 11 新增特性中最激动人心的一个。这个全新的特性听起来很深奥，但却是很多其他语言早已提供（比如 C#）或者即将提供（比如 Java）的。简而言之，Lambda 表达式就是用于创建匿名函数的。GCC 4.5.x 和 Microsoft Visual Studio 早已提供了对 lambda 表达式的支持。在 GCC 4.7 中，默认是不开启 C++ 11 特性的，需要添加
-std=c++11 编译参数。而 VS2010 则默认开启。
为什么说 lambda 表达式如此激动人心呢？举一个例子。标准 C++ 库中有一个常用算法的库，其中提供了很多算法函数，比如 sort() 和 find()。这些函数通常需要提供一个“谓词函数 predicate function”。所谓谓词函数，就是进行一个操作用的临时函数。比如 find() 需要一个谓词，用于查找元素满足的条件；能够满足谓词函数的元素才会被查找出来。这样的谓词函数，使用临时的匿名函数，既可以减少函数数量，又会让代码变得清晰易读。
下面来看一个例子：
#include &algorithm&
#include &cmath&
void abssort(float *x, unsigned N)
std::sort(x,
[](float a, float b) { return std::abs(a) & std::abs(b); });
#include &algorithm&#include &cmath&&void abssort(float *x, unsigned N){&&std::sort(x,&&&&&&&&&&&&x + N,&&&&&&&&&&&&[](float a, float b) { return std::abs(a) & std::abs(b); });}
从上面的例子来看，尽管支持 lambda 表达式，但 C++ 的语法看起来却很“神奇”。lambda 表达式使用一对方括号作为开始的标识，类似于声明一个函数，只不过这个函数没有名字，也就是一个匿名函数。这个匿名函数接受两个参数，a和b；其返回值是一个 bool 类型的值，注意，返回值是自动推断的，不需要显式声明，不过这是有条件的！条件就是，lambda 表达式的语句只有一个 return。函数的作用是比较 a、b 的绝对值的大小。然后，在此例中，这个 lambda 表达式作为一个闭包被传递给 std::sort() 函数。
下面，我们来详细解释下这个神奇的语法到底代表着什么。
我们从另外一个例子开始：
std::cout && [](float f) { return std::abs(f); } (-3.5);
std::cout && [](float f) { return std::abs(f); } (-3.5);
输出值是什么？3.5！注意，这是一个函数对象（由 lambda 表达式生成），其实参是 -3.5，返回值是参数的绝对值。lambda 表达式的返回值类型是语言自动推断的，因为std::abs()的返回值就是 float。注意，前面我们也提到了，只有当 lambda 表达式中的语句“足够简单”，才能自动推断返回值类型。
C++ 11 的这种语法，其实就是匿名函数声明之后马上调用（否则的话，如果这个匿名函数既不调用，又不作为闭包传递给其它函数，那么这个匿名函数就没有什么用处）。如果你觉得奇怪，那么来看看 JavaScript 的这种写法：
JavaScript
function() {} ();
function(a) {} (-3.5);
function() {} ();&function(a) {} (-3.5);
C++ 11 的写法完全类似 JavaScript 的语法。
如果我不想让 lambda 表达式自动推断类型，或者是 lambda 表达式的内容很复杂，不能自动推断怎么办？比如，std::abs(float)的返回值是 float，我想把它强制转型为 int。那么，此时，我们就必须显式指定 lambda 表达式返回值的类型：
std::cout && [](float f) -& int { return std::abs(f); } (-3.5);
std::cout && [](float f) -& int { return std::abs(f); } (-3.5);
这个语句与前面的不同之处在于，lambda 表达式的返回时不是 float 而是 int。也就是说，上面语句的输出值是 3。返回值类型的概念同普通的函数返回值类型是完全一样的。
当我们想引用一个 lambda 表达式时，我们可以使用auto关键字，例如：
auto lambda = [] () -& int { return val * 100; };
auto lambda = [] () -& int { return val * 100; };
auto关键字实际会将 lambda 表达式转换成一种类似于std::function的内部类型（但并不是std::function类型，虽然与std::function“兼容”）。所以，我们也可以这么写：
std::function&int()& lambda = [] () -& int { return val * 100; };
std::function&int()& lambda = [] () -& int { return val * 100; };
如果你对std::function&int()&这种写法感到很神奇，可以查看 C++ 11 的有关std::function的用法。简单来说，std::function&int()&就是一个可调用对象模板类，代表一个可调用对象，接受 0 个参数，返回值是int。所以，当我们需要一个接受一个double作为参数，返回int的对象时，就可以写作：std::function&int(double)&。
引入 lambda 表达式的前导符是一对方括号，称为 lambda 引入符（lambda-introducer）。lambda 引入符是有其自己的作用的，不仅仅是表明一个 lambda 表达式的开始那么简单。lambda 表达式可以使用与其相同范围 scope 内的变量。这个引入符的作用就是表明，其后的 lambda 表达式以何种方式使用（正式的术语是“捕获”）这些变量（这些变量能够在 lambda 表达式中被捕获，其实就是构成了一个闭包）。目前为止，我们看到的仅仅是一个空的方括号，其实，这个引入符是相当灵活的。例如：
float f0 = 1.0;
std::cout && [=](float f) { return f0 + std::abs(f); } (-3.5);
float f0 = 1.0;std::cout && [=](float f) { return f0 + std::abs(f); } (-3.5);
其输出值是 4.5。[=] 意味着，lambda 表达式以传值的形式捕获同范围内的变量。另外一个例子：
float f0 = 1.0;
std::cout && [&](float f) { return f0 += std::abs(f); } (-3.5);
std::cout && '\n' && f0 && '\n';
float f0 = 1.0;std::cout && [&](float f) { return f0 += std::abs(f); } (-3.5);std::cout && '\n' && f0 && '\n';
输出值是 4.5 和 4.5。[&] 表明，lambda 表达式以传引用的方式捕获外部变量。那么，下一个例子：
float f0 = 1.0;
std::cout && [=](float f) mutable { return f0 += std::abs(f); } (-3.5);
std::cout && '\n' && f0 && '\n';
float f0 = 1.0;std::cout && [=](float f) mutable { return f0 += std::abs(f); } (-3.5);std::cout && '\n' && f0 && '\n';
这个例子很有趣。首先，[=]意味着，lambda 表达式以传值的形式捕获外部变量。C++ 11 标准说，如果以传值的形式捕获外部变量，那么，lambda 体不允许修改外部变量，对 f0 的任何修改都会引发编译错误。但是，注意，我们在 lambda 表达式前声明了mutable关键字，这就允许了 lambda 表达式体修改 f0 的值。因此，我们的例子本应报错，但是由于有 mutable 关键字，则不会报错。那么，你会觉得输出值是什么呢？答案是，4.5 和 1.0。为什么 f0 还是 1.0？因为我们是传值的，虽然在 lambda 表达式中对 f0 有了修改，但由于是传值的，外部的 f0 依然不会被修改。
上面的例子是，所有的变量要么传值，要么传引用。那么，是不是有混合机制呢？当然也有！比如下面的例子：
float f0 = 1.0f;
float f1 = 10.0f;
std::cout && [=, &f0](float a) { return f0 += f1 + std::abs(a); } (-3.5);
std::cout && '\n' && f0 && '\n';
float f0 = 1.0f;float f1 = 10.0f;std::cout && [=, &f0](float a) { return f0 += f1 + std::abs(a); } (-3.5);std::cout && '\n' && f0 && '\n';
这个例子的输出是 14.5 和 14.5。在这个例子中，f0 通过引用被捕获，而其它变量，比如 f1 则是通过值被捕获。
下面我们来总结下所有出现的 lambda 引入符：
// 不捕获任何外部变量
// 以值的形式捕获所有外部变量
// 以引用形式捕获所有外部变量
[x, &y] // x 以传值形式捕获，y 以引用形式捕获
[=, &z]// z 以引用形式捕获，其余变量以传值形式捕获
// x 以值的形式捕获，其余变量以引用形式捕获
另外有一点需要注意。对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[]的形式，如果要使用 this 指针，必须显式传入：
[this]() { this-&someFunc(); }();
[this]() { this-&someFunc(); }();
至此，我们已经大致了解了 C++ 11 提供的 lambda 表达式的概念。建议通过结合 lambda 表达式与std::sort()或std::for_each()这样的标准函数来尝试使用一下吧！How to use lambda expression as a template parameter? E.g. as a comparison class initializing a std::set.
The following solution should work, as lambda expression merely creates an anonymous struct, which should be appropriate as a template parameter. However, a lot of errors are spawned.
Code example:
struct A {};
std::set &A, [](const A lhs, const A &rhs) -&bool {
return lhs.x & rhs.x;
} & SetOfA;
Error output (I am using g++ 4.5.1 compiler and --std=c++0x compilation flag):
error: ‘lhs’ cannot appear in a constant-expression
error: ‘.’ cannot appear in a constant-expression
error: ‘rhs’ cannot appear in a constant-expression
error: ‘.’ cannot appear in a constant-expression
At global scope:
error: template argument 2 is invalid
Is that the expected behavior or a bug in GCC?
As someone pointed out, I'm using lambda expressions incorrectly as they return an instance of the anonymous struct they are referring to.
However, fixing that error does not solve the problem. I get lambda-expression in unevaluated context error for the following code:
struct A {};
typedef decltype ([](const A lhs, const A &rhs) -&bool {
return lhs.x & rhs.x;
std::set &A, Comp & SetOfA;
解决方案 The 2nd template parameter of std::set expects a type, not an expression, so it is just you are using it wrongly.
You could create the set like this:
auto comp = [](const A& lhs, const A& rhs) -& bool { return lhs.x & rhs.x; };
auto SetOfA = std::set &A, decltype(comp)& (comp);
本文地址： &
如何使用lambda表达式作为模板参数？例如。作为初始化std :: set的比较类。
以下解决方案应该可以工作，因为lambda表达式只创建一个匿名结构，它应该适合作为模板参数。
代码示例：
struct A {};
std :: set& A，[]（const A lhs，const A& rhs） - & bool { return lhs.x& rhs.x; }& SetOfA;
错误输出（我使用g ++ 4.5.1编译器和--std = c ++ 0x编译标志）：
错误：'lhs'不能出现在常量表达式中错误：'。'不能出现在常量表达式中错误：'rhs'不能出现在常量表达式中错误：'。'不能出现在常量表达式中在全局范围：错误：模板参数2无效
是GCC中预期的行为还是错误？
正如有人指出，我使用lambda表达式不正确，
但是，修复该错误并不能解决问题。我得到 lambda表达式在未评估的上下文错误下面的代码：
struct A {};
typedef decltype（[]（const A lhs，const A& rhs） - & bool { return lhs.x& rhs.x; }
std :: set& A，Comp& SetOfA;
std :: set 需要一个类型，而不是一个 表达式，所以它只是你错误地使用。
您可以这样创建集合：
auto comp = []（const A& lhs ，const A& rhs） - & bool {return lhs.x& rhs.x; };
auto SetOfA = std :: set& A，decltype（comp）& （comp）;
本文地址： &
扫一扫关注官方微信深入理解C++11：C++11新特性解析与应用 清晰PDF_Linux下载_Linux公社-Linux系统门户网站
你好，游客
深入理解C++11：C++11新特性解析与应用 清晰PDF
来源：Linux社区&
作者：Linux
　　国内首本全面深入解读C++11新标准的专著，由C++标准委员会代表和IBM XL编译器中国开发团队共同撰写。不仅详细阐述了C++11标准的设计原则，而且系统地讲解了C++11新标准中的所有新语言特性、新标准库特性、对原有特性的改进，以及如何应用所有这些新特性。
　　《华章科技：深入理解C++11：C++11新特性解析与应用》一共8章：第1章从设计思维和应用范畴两个维度对C++11新标准中的所有特性进行了分类，呈现了C++11新特性的原貌；第2章讲解了在保证与C语言和旧版C++标准充分兼容的原则下增加的一些新特性；第3章讲解了具有广泛可用性、能与其他已有的或者新增的特性结合起来使用的、具有普适性的一些新特性；第4章讲解了C++11新标准对原有一些语言特性的改进，这些特性不仅能让C++变得更强大，还能提升程序员编写代码的效率；第5章讲解了C++11在安全方面所做的改进，主要涵盖枚举类型安全和指针安全两个方面的内容；第6章讲解了为了进一步提升和挖掘C++程序性能和让C++能更好地适应各种新硬件的发展而设计的新特性，如多核、多线程、并行编程方面的新特性；第7章讲解了一些颠覆C++一贯设计思想的新特性，如lambda表达式等；第8章讲解了C++11为了解决C++编程中各种典型实际问题而做出的有效改进，如对Unicode的深入支持等。附录中则介绍了C++11标准与其他相关标准的兼容性和区别、C++11中弃用的特性、编译器对C++11的支持情况，以及学习C++11的相关资源。
免责声明第1章 新标准的诞生 1.1 曙光：C++11标准的诞生 1.1.1 C++11/C++0x（以及C11/C1x）-新标准诞生 1.1.2 什么是C++11/C++0x 1.1.3 新C++语言的设计目标 1.2 今时今日的C++ 1.2.1 C++的江湖地位 1.2.2 C++11语言变化的领域 1.3 C++11特性的分类 1.4 C++特性一览 1.4.1 稳定性与兼容性之间的抉择 1.4.2 更倾向于使用库而不是扩展语言来实现特性 1.4.3 更倾向于通用的而不是特殊的手段来实现特性 1.4.4 专家新手一概支持 1.4.5 增强类型的安全性 1.4.6 与硬件紧密合作 1.4.7 开发能够改变人们思维方式的特性 1.4.8 融入编程现实 1.5 本书的约定 1.5.1 关于一些术语的翻译 1.5.2 关于代码中的注释 1.5.3 关于本书中的代码示例与实验平台 第2章 保证稳定性和兼容性 2.1 保持与C99兼容 2.1.1 预定义宏 2.1.2 __func__预定义标识符 2.1.3 _Pragma操作符 2.1.4 变长参数的宏定义以及__VA_ARGS__ 2.1.5 宽窄字符串的连接 2.2 long long整型 2.3 扩展的整型 2.4 宏__cplusplus 2.5 静态断言 2.5.1 断言：运行时与预处理时 2.5.2 静态断言与static_assert 2.6 noexcept修饰符与noexcept操作符 2.7 快速初始化成员变量 2.8 非静态成员的sizeof 2.9 扩展的friend语法 2.10 final/override控制 2.11 模板函数的默认模板参数 2.12 外部模板 2.12.1 为什么需要外部模板 2.12.2 显式的实例化与外部模板的声明 2.13 局部和匿名类型作模板实参 2.14 本章小结 第3章 通用为本，专用为末 3.1 继承构造函数 3.2 委派构造函数 3.3 右值引用：移动语义和完美转发 3.3.1 指针成员与拷贝构造 3.3.2 移动语义 3.3.3 左值、右值与右值引用 3.3.4 std：：move：强制转化为右值 3.3.5 移动语义的一些其他问题 3.3.6 完美转发 3.4 显式转换操作符 3.5 列表初始化 3.5.1 初始化列表 3.5.2 防止类型收窄 3.6 POD类型 3.7 非受限联合体 3.8 用户自定义字面量 3.9 内联名字空间 3.10 模板的别名 3.11 一般化的SFINEA规则 3.12 本章小结 第4章 新手易学，老兵易用 4.1 右尖括号&的改进 4.2 auto类型推导 4.2.1 静态类型、动态类型与类型推导 4.2.2 auto的优势 4.2.3 auto的使用细则 4.3 decltype 4.3.1 typeid与decltype 4.3.2 decltype的应用 4.3.3 decltype推导四规则 4.3.4 cv限制符的继承与冗余的符号 4.4 追踪返回类型 4.4.1 追踪返回类型的引入 4.4.2 使用追踪返回类型的函数 4.5 基于范围的for循环 4.6 本章小结 第5章 提高类型安全 5.1 强类型枚举 5.1.1 枚举：分门别类与数值的名字 5.1.2 有缺陷的枚举类型 5.1.3 强类型枚举以及C++11对原有枚举类型的扩展 5.2 堆内存管理：智能指针与垃圾回收 5.2.1 显式内存管理 5.2.2 C++11的智能指针 5.2.3 垃圾回收的分类 5.2.4 C++与垃圾回收 5.2.5 C++11与最小垃圾回收支持 5.2.6 垃圾回收的兼容性 5.3 本章小结 第6章 提高性能及操作硬件的能力 6.1 常量表达式 6.1.1 运行时常量性与编译时常量性 6.1.2 常量表达式函数 6.1.3 常量表达式值 6.1.4 常量表达式的其他应用 6.2 变长模板 6.2.1 变长函数和变长的模板参数 6.2.2 变长模板：模板参数包和函数参数包 6.2.3 变长模板：进阶 6.3 原子类型与原子操作 6.3.1 并行编程、多线程与C++11 6.3.2 原子操作与C++11原子类型 6.3.3 内存模型，顺序一致性与memory_order 6.4 线程局部存储 6.5 快速退出：quick_exit与at_quick_exit 6.6 本章小结 第7章 为改变思考方式而改变 7.1 指针空值-nullptr 7.1.1 指针空值：从0到NULL，再到nullptr 7.1.2 nullptr和nullptr_t 7.1.3 一些关于nullptr规则的讨论 7.2 默认函数的控制 7.2.1 类与默认函数 7.2.2 &= default&与&= deleted& 7.3 lambda函数 7.3.1 lambda的一些历史 7.3.2 C++11中的lambda函数 7.3.3 lambda与仿函数 7.3.4 lambda的基础使用 7.3.5 关于lambda的一些问题及有趣的实验 7.3.6 lambda与STL 7.3.7 更多的一些关于lambda的讨论 7.4 本章小结 第8章 融入实际应用 8.1 对齐支持 8.1.1 数据对齐 8.1.2 C++11的alignof和alignas 8.2 通用属性 8.2.1 语言扩展到通用属性 8.2.2 C++11的通用属性 8.2.3 预定义的通用属性 8.3 Unicode支持 8.3.1 字符集、编码和Unicode 8.3.2 C++11中的Unicode支持 8.3.3 关于Unicode的库支持 8.4 原生字符串字面量 8.5 本章小结 附录A C++11对其他标准的不兼容项目 附录B 弃用的特性 附录C 编译器支持 附录D 相关资源
深入理解C++11：C++11新特性解析与应用 清晰PDF 百度网盘下载：
------------------------------------------分割线------------------------------------------
在 2015年\12月\深入理解C++11：C++11新特性解析与应用 清晰PDF\
下载方法见
------------------------------------------分割线------------------------------------------
本文永久更新链接地址：
相关资讯 & & &
& (01月26日)
& (05/11/:29)
& (05月22日)
& (12/07/:36)
& (04/28/:26)
　　　同意评论声明
　　　发表
尊重网上道德，遵守中华人民共和国的各项有关法律法规
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
本站管理人员有权保留或删除其管辖留言中的任意内容
本站有权在网站内转载或引用您的评论
参与本评论即表明您已经阅读并接受上述条款}