C++ 是否有基于宏的适配器从类生成函子？

创建函子需要一个不必要的锅炉板。州必须写4次

struct f{
  double s; // 1st
  f(double state): s(state) {} // 2nd, 3rd and 4th
  double operator() (double x) {
    return x*s;
  }
};

是否有一个包含宏的库，该宏将是

双函子（状态）（x）{return x*state；}

或类似的东西

BOOST\u-FOREACH

是一个运行良好的宏适配器。我在找类似的东西

任何关于如何写一个的建议也很感激

对函子使用struct比bind更快

更新（1）

关于lambdas：

---

函子必须是模块化的，也就是说，它应该可以在其他函数中重用。lambda必须在一个函数中——lambda必须在main中才能从main和main之外的其他函数调用，不能调用main中定义的lambda。

将所需的功能（例如，乘法）定义为函数，然后使用

std:：bind（）

创建合适的函数对象：

#include <functional>

double some_operation(double state, double x) {
    return state * x;
}

int main() {
    auto function = std::bind(&some_operation, 17, std::placeholders::_1);
    return function(18);
}

在使用

-O2

选项优化的MacOS系统上使用最新版本的（更准确地说：

clang版本3.4（trunk 182411）

）。使用and（更准确地说：

gcc版本4.9.0 20130811（实验性）（gcc）

）会得到类似的结果

函数对象是在本地上下文中构建的，还是通过模板参数传递给单独的函数，这似乎是有区别的。这种差异很有趣，因为我预计函数的大多数用法都会导致在某个地方传递结果函数对象

该准则基于：

#包括
#包括
#包括
使用名称空间std；
使用名称空间std:：占位符；
使用名称空间std:：chrono；
结构fs{
双s；
fs（双态）：s（态）{}
双运算符（）（双x）{
返回x*s；
}
};
结构ff{
双运算符（）（双x，双状态）常量{
返回x*状态；
}
};
双fb（双x，双状态）{
返回x*状态；
}
模板
无效度量（字符常量*什么，函数）
{
const auto stp1=高分辨率时钟：：now（）；
双sresult（0.0）；
对于（双x=0.0；x<1.0e8；++x）{
sresult+=函数（x）；
}
const auto stp2=高分辨率时钟：：now（）；
const auto sd=持续时间（stp2-stp1）；
cout将您想要的功能定义为函数，例如乘法，然后使用
std:：bind（）
创建合适的函数对象：

#include <functional>

double some_operation(double state, double x) {
    return state * x;
}

int main() {
    auto function = std::bind(&some_operation, 17, std::placeholders::_1);
    return function(18);
}

在使用
-O2
选项进行优化的MacOS系统上使用最新版本的（更准确地说：
clang版本3.4（trunk 182411）
）。使用和（更准确地说：
gcc版本4.9.0 20130811（实验性）（gcc）
）会给出类似的结果

函数对象是在本地上下文中构建还是通过模板参数传递给单独的函数似乎有区别。这个区别很有趣，因为我认为大多数使用
bind（）
函数都会导致在某个地方传递结果函数对象

该准则基于：

#包括
#包括
#包括
使用名称空间std；
使用名称空间std:：占位符；
使用名称空间std:：chrono；
结构fs{
双s；
fs（双态）：s（态）{}
双运算符（）（双x）{
返回x*s；
}
};
结构ff{
双运算符（）（双x，双状态）常量{
返回x*状态；
}
};
双fb（双x，双状态）{
返回x*状态；
}
模板
无效度量（字符常量*什么，函数）
{
const auto stp1=高分辨率时钟：：now（）；
双sresult（0.0）；
对于（双x=0.0；x<1.0e8；++x）{
sresult+=函数（x）；
}
const auto stp2=高分辨率时钟：：now（）；
const auto sd=持续时间（stp2-stp1）；
cout我们有lambdas用于此：

double s = 42;
auto f = [s](double x) {
    return s * x;  
};

在第2行只提到一次状态（因为在实际表达式中，您似乎不算一次）。第1行上的初始化是否算一次状态是有争议的，您所需的表单不包含任何初始化，这是必需的，因此我认为这是可以接受的

在c++14中，我们将获得lambda捕获语法的扩展，允许更简洁的形式：

auto f = [s{42}](double x) {
    return s * x;  
};

我们有兰博达斯来做这个：

double s = 42;
auto f = [s](double x) {
    return s * x;  
};

在第2行只提到一次状态（因为在实际表达式中，您似乎不算一次）。第1行上的初始化是否算一次状态是有争议的，您所需的表单不包含任何初始化，这是必需的，因此我认为这是可以接受的

在c++14中，我们将获得lambda捕获语法的扩展，允许更简洁的形式：

auto f = [s{42}](double x) {
    return s * x;  
};

依赖聚合初始化如何？只需不声明构造函数：

struct f {
    double s;
    double operator()(double x) {
        return x * s;
    }
};

像这样使用它

int main()
{       
    auto ff = f{42};
    std::cout << ff(2);
    return 0;
}

intmain（）
{       
自动ff=f{42}；
std:：cout依赖聚合初始化如何？只需不声明构造函数：

struct f {
    double s;
    double operator()(double x) {
        return x * s;
    }
};

像这样使用它

int main()
{       
    auto ff = f{42};
    std::cout << ff(2);
    return 0;
}

intmain（）
{       
自动ff=f{42}；
std：：cout看看哪一个似乎正是你想要的，因为你甚至提到了一个宏：）

个人提示：如果你有一个现代化的编译器，就使用C++11 lambdas。
看看哪一个似乎正是你想要的，因为你甚至提到了一个宏：）

个人提示：如果你有一个现代化的编译器，请使用C++11 lambdas。
我发现
[s]（双x）{return x*s；}
相当简洁。@Casey它不是一个可以在其他函数中使用的模块化解决方案。我发现
[s]（双x）{return x*s；}
相当简洁。@Casey这不是一个可以在其他函数中使用的模块化解决方案。这很好，但速度要慢10倍。是的，通过函数指针调用不能内联。这是否重要取决于你在函数中做了什么。使用函数对象并绑定它应该和实现包装器一样快但是self.bind的编译速度与使用优化t编译的速度相同吗