我是C++ 11的新手.我正在编写以下递归lambda函数,但它不编译.
#include <iostream>
#include <functional>
auto term = [](int a)->int {
return a*a;
};
auto next = [](int a)->int {
return ++a;
};
auto sum = [term,next,&sum](int a, int b)mutable ->int {
if(a>b)
return 0;
else
return term(a) + sum(next(a),b);
};
int main(){
std::cout<<sum(1,10)<<std::endl;
return 0;
}
vimal @ linux-718q:〜/ Study/09C++/c ++ 0x/lambda> g ++ -std = c ++ 0x sum.cpp
sum.cpp:在lambda函数中:sum.cpp:18:36:错误:' ((<lambda(int, int)>*)this)-><lambda(int, int)>::sum'不能用作函数
gcc版本4.5.0 20091231(实验性)(GCC)
但如果我改变sum()下面的声明,它的作用是:
std::function<int(int,int)> sum = [term,next,&sum](int a, …在C#中,对于具有getter和setter的字段,有一个很好的语法糖.而且,我喜欢允许我编写的自动实现的属性
public Foo foo { get; private set; }
在C++中我必须写
private:
Foo foo;
public:
Foo getFoo() { return foo; }
在C++ 11中是否有一些这样的概念允许我对此有一些语法糖？
C++ 17的当前标准(我已经观察到类似于C++ 11的措辞)对于简单的可复制类型具有非常混乱的措辞.我首先使用以下代码(GCC 5.3.0)偶然发现了这个问题:
class TrivialClass {};
std::is_trivially_copyable<int volatile>::value; // 0
std::is_trivially_copyable<TrivialClass volatile>::value; // 1 ??
让混乱更加糟糕,我试着检查std::is_trivial一下这件事情有什么说法,只是让人更加困惑.
class TrivialClass {};
std::is_trivial<int volatile>::value; // 1 ??
std::is_trivial<TrivialClass volatile>::value; // 1
很困惑,我检查了最新的C++ 17草案,看看是不是有问题,我发现了一些有些含糊不清的措辞可能是罪魁祸首:
http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4567.pdf#page.73
cv-非限定标量类型,平凡可复制类类型(第9节),此类类型的数组以及这些类型的非易失性const限定版本(3.9.3)统称为平凡可复制类型.
以下是关于平凡可复制类的信息:
http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4567.pdf#page.226
一个简单的可复制类是一个类:
- (6.1)没有非平凡的复制构造函数(12.8),
- (6.2)没有非平凡的移动构造函数(12.8),
- (6.3)没有非平凡的副本分配操作员(13.5.3,12.8),
- (6.4)没有非平凡的移动指派算子(13.5.3,12.8),和
- (6.5)有一个简单的析构函数(12.4).
http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4567.pdf#section.12.8
构造函数:
如果不是用户提供的,则类X的复制/移动构造函数是微不足道的,其参数类型列表等效于隐式声明的参数类型列表,如果
- (12.1)类X没有虚函数(10.3),没有虚基类(10.1),和
- (12.2)类X 没有volatile限定类型的非静态数据成员,和
- (12.3)选择复制/移动每个直接基类子对象的构造函数是微不足道的,并且
- (12.4)对于类型(或其数组)的X的每个非静态数据成员,选择复制/移动该成员的构造函数是微不足道的;
否则复制/移动构造函数是非平凡的.
分配:
如果类X不是用户提供的,则类X的复制/移动赋值运算符是微不足道的,其参数类型列表等效于隐式声明的参数类型列表,如果
- (25.1)类X没有虚函数(10.3),没有虚基类(10.1),和
- (25.2)类X 没有volatile限定类型的非静态数据成员,和
- (25.3)选择复制/移动每个直接基类子对象的赋值运算符是微不足道的,并且
- (25.4)对于类型(或其数组)的X的每个非静态数据成员,选择复制/移动该成员的赋值运算符是微不足道的;
否则复制/移动赋值运算符是非常重要的.
注意:更新了此部分以及更多信息.我现在相信这是GCC中的一个错误.然而,仅凭这一点并不能回答我的所有问题.
我可以看到,也许是因为TrivialClass没有非静态成员,因为它会传递上述规则,所以我添加了一个int,它仍然可以简单地复制.
class TrivialClass { …功能数据结构(例如Haskell/Clojure/Scala中使用的Hash Array Mapped Trie)依赖于底层数据结构中的大量共享.例如,如果我们实现insert类似于地图的数据类型,通常通过在实现数据结构的树上进行路径复制来实现.
鉴于这些数据结构在很大程度上依赖于基础价值的共享(并且没有主要所有者),借款是否会妨碍实施此类结构？
我有一个使用函数引用的类:
double u( const double& x, const double& y )
{
return x * y;
}
class equation
{
equation( double (&in_u)(const double&, const double&) );
//...
protected:
double (&u)(const double&, const double&);
}
该功能将被称为像10周8典型的运行过程中的时间.
该类进入库,该函数u由库的用户定义.所以我不能在类中有函数定义.
我读过这个:
(
std::function)...的缺点是在被调用时引入一些(非常小的)开销(所以在一个非常严重的性能问题上它可能是一个问题,但在大多数情况下它不应该)
有没有更有效的方法将函数传递u给类equation？这会被视为"一个非常严重的性能危机"吗？
编辑
似乎有点混乱.只是要清楚,该功能u 是在可执行文件编译时已知,但不是在图书馆的.在运行时获取该功能是我将在库的更高版本中考虑的功能,但现在不是.
我的课程是
Base
Derived_ADerived_BParent
Child_OneChild_TwoBase有两个签名功能:
virtual void foo( const Parent& ) = 0;
virtual void bar( const Base& ) = 0;
,该计划的其他部分期望.
问题是:
Derived_A对待Child_One和Child_Two相同.但Derived_B对待他们的方式不同.
我该如何实现呢？
一种方法是找出传递给哪种对象Derived_B.foo.这显然是"设计缺陷".我尝试的另一种方法是将签名函数更改为:
class Base
{
class Derived_A;
class Derived_B;
// virtual void bar( const Base& ) = 0;
virtual void bar( const Derived_A& ) = 0;
virtual void bar( const Derived_B& ) = 0;
}
class Derived_A: public virtual Base
{
virtual void foo( …如果我有std::deque并且std::vector想要将它们组合到std::deque，我可以通过以下方式进行：
typedef int T; // type int will serve just for illustration
std::deque< T > deq(100); // just some random size here
std::vector< T > vec(50);
// ... doing some filling ...
// now moving vector to the end of queue:
deq.insert(
deq.end(),
std::make_move_iterator( vec.begin() ),
std::make_move_iterator( vec.end() )
);
std::cout << deq.size() << std::endl;
我们知道向量的大小，但我们不能在最后std::deque使用之前保留内存std::deque.insert(...)。那么这是将所有元素移动std::vector到末尾的最快方法std::deque吗？还是我错过了什么？
谢谢你。
假设以下代码:
#include <iostream>
#include <string>
int func() { return 2; }
int main()
{
std::string str("str");
str = func();
std::cout << "Acquired value: '" << str << "'" << std::endl;
return 0;
}
为什么行str = func();编译时没有出现类型不匹配的警告？
我正在使用编译器gcc v.4.7.1并设置-std = c ++ 11标志.
输出:
Acquired value: ''
我有一个类（C）用vector的unique_ptrs到一个抽象类（A）作为成员。这是因为C必须与所有类型的类一起使用A，即它的子类。
问题是我无法弄清楚如何为 编写复制构造函数C，因为在编译时不知道指针指向的对象的类型。在我看来，这实际上是不可能的。谁能确认这是不可能的？您对如何解决问题有什么建议吗？一个没有复制构造函数的类是不是太糟糕了？
我是C++ 11的新手,我遇到了enable_shared_from_this.我不明白它想要达到的目的是什么？所以我有一个使用enable_shared_from_this的程序.
struct TestCase: enable_shared_from_this<TestCase>
{
std::shared_ptr<testcase> getptr() {
return shared_from_this();
}
~TestCase() { std::cout << "TestCase::~TestCase()"; }
};
int main()
{
std::shared_ptr<testcase> obj1(new TestCase);
std::shared_ptr<testcase> obj2 = obj1->getptr();
// The above can be re written as below
// std::shared_ptr<testcase> obj2 = shared_ptr<testcase>(obj1);
}
我的问题是当我需要一个指向'this'的指针时,为什么不使用obj本身.为什么要从该类的函数返回'this',比如使用getptr()然后返回shared_from_this()???? 我不明白.
第二个问题,如果不使用enable_shared_from_this,为什么dtor被调用两次会产生问题,崩溃!!!!
我可以绕过使用enable_shared_from_this的另一种方法是这样的.在TestCase类中添加它
std::shared_ptr getptr1(shared_ptr obj) {
return std::shared_ptr(obj);
}
从主要打电话给这个:
std::shared_ptr bp2 = bp1->getptr1(bp1);
并做了.我们不需要enable_shared_from_this.为什么在地球上我们需要它？