The C++ Standard Library (Second Edition)Nicolai Josuttis 在其着作中指出,编译器可以比普通函数更好地优化lambdas.
此外,C++编译器比普通函数更好地优化lambdas.(第213页)
这是为什么？
我认为在内联时不应该有任何差别.我能想到的唯一原因是编译器可能有一个更好的本地上下文与lambdas,这样可以做出更多假设并执行更多优化.
我是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, …问题如下:考虑这段代码:
#include <iostream>
class aClass
{
public:
void aTest(int a, int b)
{
printf("%d + %d = %d", a, b, a + b);
}
};
void function1(void (*function)(int, int))
{
function(1, 1);
}
void test(int a,int b)
{
printf("%d - %d = %d", a , b , a - b);
}
int main (int argc, const char* argv[])
{
aClass a();
function1(&test);
function1(&aClass::aTest); // <-- How should I point to a's aClass::test function?
return 0;
}
我如何使用a's aClass::test …
c++ arguments function-pointers parameter-passing pointer-to-member
可能重复:
c ++ 0x中的递归lambda函数
这是一个普通的旧递归函数:
int fak(int n)
{
return (n <= 1) ? 1 : n * fak(n - 1);
}
我如何编写像lambda函数这样的递归函数？
[](int n) { return (n <= 1) ? 1 : n * operator()(n - 1); }
// error: operator() not defined
[](int n) { return (n <= 1) ? 1 : n * (*this)(n - 1); }
// error: this wasn't captured for this lambda function
是否有任何表达当前lambda的表达式,因此它可以递归调用自身？
在某些情况下std::function可以取代继承.以下两个代码片段非常相似(调用函数时的成本大致相同,签名中的用法几乎相同,在大多数情况下,std :: function也不需要我们制作额外的副本A):
struct Function
{
virtual int operator()( int ) const =0;
};
struct A
: public Function
{
int operator()( int x ) const override { return x; }
};
使用std::function,我们可以重写为
using Function = std::function<int (int)>;
struct A
{
int operator()( int x ) const { return x; }
};
为了更清楚,两个片段是如何相关的:它们都可以通过以下方式使用:
int anotherFunction( Function const& f, int x ) { return f( x ) + f( x ); }
int main( int …许多标准库算法都采用谓词函数.但是,这些谓词的类型是用户提供的任意模板参数.为什么C++ 11没有指定这些类型采用特定类型std::function？例如:
template< class InputIt >
InputIt find_if( InputIt first, InputIt last,
std::function<bool()> p );
是不是使用这个而不是模板作为参数类型不是更干净？
我想在c ++类中使用GSL而不将成员函数声明为static.原因是因为我不太了解它们,我不确定线程的安全性.从我读到的,std::function可能是一个解决方案,但我不知道如何使用它.
我的问题归结为如何static在声明中删除g？
#include<iostream>
#include <functional>
#include <stdlib.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_monte.h>
#include <gsl/gsl_monte_plain.h>
#include <gsl/gsl_monte_miser.h>
#include <gsl/gsl_monte_vegas.h>
using namespace std;
class A {
public:
static double g (double *k, size_t dim, void *params)
{
double A = 1.0 / (M_PI * M_PI * M_PI);
return A / (1.0 - cos (k[0]) * cos (k[1]) * cos (k[2]));
}
double result() {
double res, err;
double xl[3] = { 0, 0, 0 …我不太明白std::function实际包含的实例是什么.
通过按值或按引用传递它是否更有效？
以下示例中的性能影响是什么？
通过值:
void printStats(std::function<void(const char *)> printer);
. . .
std::string tmp;
printStats([&tmp](const char * msg){ tmp += msg; });
通过rvalue-reference:
void printStats(std::function<void(const char *)>&& printer);
. . .
std::string tmp;
printStats([&tmp](const char * msg){ tmp += msg; });
这是受到这个问题/答案以及随后在评论中讨论的启发:"易变"这个定义是不稳定的,还是GCC有一些标准的合规性问题？.基于其他人以及我对应该发生的事情的解释,如评论中所讨论的,我已将其提交给GCC Bugzilla:https://gcc.gnu.org/bugzilla/show_bug.cgi ？ id = 71793 其他相关回复仍然存在欢迎.
此外,该线程引发了这个问题:通过易失性引用/指针访问声明的非易失性对象是否会在所述访问时赋予易失性规则？
我知道volatile这不是大多数人认为的,而且是实施定义的毒蛇巢.我当然不想在任何实际代码中使用以下结构.也就是说,我对这些例子中发生的事情感到非常困惑,所以我真的很感激任何解释.
我的猜测是,这是由于对标准的高度细微差别的解释,或者(更可能的是)对于所使用的优化器的角落情况.无论哪种方式,虽然更具学术性而非实际性,但我希望这对于分析是有价值的,特别是考虑到通常误解的volatile情况.一些更多的数据点 - 或者更有可能是针对它的点 - 必须是好的.
鉴于此代码:
#include <cstddef>
void f(void *const p, std::size_t n)
{
unsigned char *y = static_cast<unsigned char *>(p);
volatile unsigned char const x = 42;
// N.B. Yeah, const is weird, but it doesn't change anything
while (n--) {
*y++ = x;
}
}
void g(void *const p, std::size_t n, volatile unsigned char …我有一个名为Graph的C++类,它有一个算法方法for_each_node().我可以把它变成一个模板,像这样:
template <class UnaryFunction>
UnaryFunction Graph::for_each_node (UnaryFunction f)
{
/* ... */
}
或者使用std :: function,如下所示:
typedef std::function<void (Node&)> ForEachNodeFunc;
ForEachNodeFunc Graph::for_each_node (ForEachNodeFunc f)
{
/* ... */
}
标准算法,例如std :: for_each,使用第一种方法,而一些库,例如gtkmm(它是GTK +的C++绑定),将函数作为包含它们的对象的函数指针.
每个选项有哪些优点和缺点？我不知道该选哪个.应该影响选择的是什么:我的Graph类是一个类模板,或者算法方法或速度要求预计会使用多少个不同的函数？