C++ std:：带有指向成员函数和back_插入器的指针的转换包装器

我为std:：transform创建了一个包装器，使其每次都不传递begin和end

template <typename C, typename C2, typename UnaryOperation>
void transform(const C& c1, C2& result, const UnaryOperation& up)
{
    std::transform(std::begin(c1), std::end(c1), std::begin(result), up);
}

我想要另一个签名，我可以这样做

struct X {
    Object foo(std::string const& ) const;

    void bar(std::vector<std::string> const& container) const
    {
        std::vector<Object> result;
        utils::transform(container, std::back_inserter(result), &X::foo);
        // do something with result
    }
};

struct X{
对象foo（std:：string const&）const；
空条（标准：：向量常量和容器）常量
{
std：：向量结果；
utils:：transform（容器、std:：back\u插入器（result）和X:：foo）；
//做一些有结果的事情
}
};

---

但这不起作用。我错过了什么？签名里有什么？如何使其工作？

您可以像第一个使用示例一样使用lambda

Object object;
auto lambda_for_member_myFunction = [object](const auto& o) {
   return object.myFunction(o);
};
utils::transform(container, std::back_inserter(result), lambda_for_member);

---

现在，您可以将其包装到另一个帮助器中，但仍然需要添加

对象

作为参数

在您的示例中，

&X:：foo

是一个接受两个参数的函数：显式参数（std:：string const&）和隐式参数（

X

）。但是您的

transform（）

需要一个一元可调用函数。这里有一个不匹配

您需要将隐式对象参数“绑定”到

&X:：foo

，使其成为一元。最简单的方法是使用lambda：

utils::transform(container, std::back_inserter(result),
    [this](auto const& s) { return foo(s); });

---

您还可以使用

std:：bind（）

。。。但是不需要。

您还需要为对象传递

this

，而不仅仅是成员函数指针。@CaptainGiraffe关于

std:：mem\u fn

？您还需要在那里传递object/this。即使使用

auto f=std:：bind（std:：mem\u fn（&object:：func）），这也可以utils:：transform（container，，&Object:：myFunction）

时，将

f

作为最后一个参数传递给std:：transform不会编译。。。此处的

容器

包含要调用

myFunction

的

对象

s，对吗？

std:：bind（&Object:：member\u func，this，std:：placeholder:：\u 1）应该可以工作，但它不太容易使用。
std:：begin（std:：back\u inserter（result））
仍然无效。@Jarod42我正在使用
C2&&
并将
std:：begin（result）
替换为
std:：forward
utils::transform(container, std::back_inserter(result),
    [this](auto const& s) { return foo(s); });