通过const std::function引用传递临时lambda应该会失败，但似乎可以工作
。
首先，让我们来解释一下问题的核心：const std::function引用传递临时lambda。lambda表达式是一种轻量级的匿名函数，常用于编写简短的、局部的代码块。在C++中，我们可以使用lambda表达式来创建一个可调用的对象。std::function是C++11引入的一个通用函数封装类，可以用于存储任何可调用对象（函数、函数指针、成员函数指针、lambda等）。
根据C++语言规范，当我们通过引用传递临时对象时，会产生问题，因为临时对象的生命周期是非持久的，引用传递会导致引用悬空，即引用指向了一个已经被销毁的对象。然而，经过测试发现，通过const std::function引用传递临时lambda似乎可以正常工作，即lambda表达式可以被成功调用。这是因为const修饰符保证了lambda表达式的不可修改性，从而避免了对已销毁对象的访问。
虽然这种方法可能在某些编译器上可以工作，但是根据C++语言规范，这种行为是未定义的。这意味着，在不同的编译器和编译选项下，结果可能会有所不同。因此，强烈建议避免通过const std::function引用传递临时lambda。
如果您需要在代码中传递lambda表达式，建议使用值传递或者将lambda表达式存储在具有持久生命周期的变量中，然后通过引用传递该变量。
腾讯云相关产品和产品介绍链接地址不适用于这个问题。
相关·内容
1回答
我想知道为什么在将std::function<...(...)> &作为输入参数传递给函数时，需要将其指定为const。AFAIK没有办法改变它，对吗？下面是一个编译并运行良好的示例。如果删除const限定符，就会得到一个错误：
#include <iostream>
#include <functional>
//int foo(std::function<int(int)> &f)
int foo(const std::function<int(int)> &f)
{
return f(6);
}
浏览 4提问于2020-04-18得票数 2
回答已采纳
1回答
我有一个数据成员，其类型为：
std::function<T(T&, T&)>&
构造函数接受相同类型的参数。
如何使用lambdas发送这样的函数？
我试过了
MyClass tmp([](Foo &a, Foo &b) { return a+b; }, ...);
但失败了。
例如：
main.cpp
#include "MyClass.h"
int main()
{
MyClass a([](int x, int y) { return x+y;});
return 0;
}
MyClass.h
#p
浏览 1提问于2016-07-02得票数 1
回答已采纳
1回答
鉴于这一职能：
void foo(std::function<void(int, std::uint32_t, unsigned int)>& f)
{
f(1, 2, 4);
}
这为什么要编译：
std::function<void(int a, std::uint32_t b, unsigned int c)> f =
[] (int a, std::uint32_t b, unsigned int c) -> void
{
std::cout << a << b << c <<
浏览 1提问于2015-09-14得票数 2
回答已采纳
这个代码正确吗？
它似乎在g++ 4.8.3和clang (bcc64)中工作，但似乎不能保证正确性:)
其目的是能够替换对成员函数的调用：
void Master::go()
{
std::string s;
func(s); // func is a member function of Master
}
使用包装此调用的函数模板(并且确实可以处理任何类，而不仅仅是Master)：
void Master::go()
{
std::string s;
call_function( func, s ); // pseudocode
}
最后打电
浏览 0提问于2014-07-27得票数 3
在gcc 4.5中，以下代码可以像预期的那样与-std=c++0x一起编译和工作。
#include <stdio.h>
template<typename H>
void caller(H h)
{
h();
}
int main()
{
auto c = [](){ printf("A\n"); };
caller(c);
caller([](){ printf("B\n"); });
return 0;
}
指纹，
A
B
但是，如果将caller定义为引用，
template<ty
浏览 4提问于2012-09-07得票数 4
回答已采纳
我在处理c++λ表达式时遇到了一个问题。下面是我的代码：
using FUNC = std::function<int(int, int)>;
FUNC unit( const FUNC& lf, const FUNC& rt ) {
return [&]( int first, int second ) -> int {
return lf( first, second ) + rt( first, second );
};
}
int input( int first, int second ) {
re
浏览 0提问于2018-06-14得票数 0
1回答
我有一个类，它将一个std::function作为参数，并指定一个lambda函数。它在构造函数中工作，但之后停止工作。调试器说f在运行第一行后是“空”的。为什么？
#include <iostream>
#include <string>
#include <functional>
typedef std::function<void(std::string)> const& fn;
class TestClass
{
public:
TestClass(fn _f) : f(_f) { F(); }
void F(
浏览 4提问于2016-08-08得票数 5
回答已采纳
有人能解释一下以下代码的行为吗？
当我解释地将lambda转换为std::function时，lambda正确地捕获了变量n。
当它被隐式转换为std::function (使用临时的)时，捕获就失败了。
我正在使用g++-4.9 (Ubuntu 4.9-20140406-1ubuntu1) 4.9.0 20140405 (experimental) [trunk revision 209157]
#include <chrono>
#include <iostream>
#include <memory>
#include <thread>
浏览 3提问于2014-06-18得票数 2
回答已采纳
假设您有以下程序：
static std::function<int(int)> pack_a_lambda( std::function<int(int)> to_be_packed ) {
return [=]( int value ) {
return to_be_packed( value * 4 );
};
}
int main() {
auto f = pack_a_lambda( []( int value ) {
return value * 2;
} );
int result
浏览 2提问于2020-05-22得票数 2
回答已采纳
以下是这个问题的内容：
我有一个固定的代码片段：
// global variable
std::thread worker_thread;
// Template function
template <typename Functor>
void start_work(const Functor &worker_fn) // lambda passed by const ref
{
worker_thread = std::thread([&](){
worker_fn();
});
}
这就是所谓的：
void do_work
浏览 0提问于2018-04-23得票数 8
回答已采纳
让我们来关注这个例子：
template<typename T>
class C{
public:
void func(std::vector<T>& vec, std::function<T( const std::string)>& f){
//Do Something
}
};
现在，我正在尝试：
std::vector<int> vec;
auto lambda = [](const std::string& s) { return std::stoi(s); };
C<
浏览 3提问于2016-03-16得票数 63
回答已采纳
我有一个非常简单的代码示例，在gcc 8.2.0下使用-O2进行优化时会崩溃
#include <vector>
#include <functional>
#include <iostream>
template<typename T, typename Container>
class Lambda_Expression
{
using Lambda = std::function<T()>;
const Lambda & _lambda;
public:
Lambda_Expression(c
浏览 0提问于2019-03-27得票数 3
回答已采纳
我正在实现一个计时器库，
在的第二个参数中，std::chrono::steady_clock::now() + 2000ms工作正常，而std::chrono::steady_clock::now() + std::chrono::milliseconds(2000)没有。
请指导我所缺少的东西，以及以后如何使用。
/*
* Inspired by:
* https://www.fluentcpp.com/2018/12/28/timer-cpp/
* */
#include <thread>
#include <chrono>
#include <at
浏览 1提问于2021-01-29得票数 0
回答已采纳
从开始，我意识到std::function有更根本的问题--特别是当返回对lambda中的静态变量的引用时，但是只有当lambda封装在std::function中时，才会出现分段错误。
#include <iostream>
#include <functional>
using namespace std::string_literals;
namespace
{
const auto hello = "Hello"s;
}
int main()
{
using func_t = std::function<const std::
浏览 1提问于2018-03-16得票数 2
回答已采纳
下面的代码给出了分段错误。经过调试，我发现这个问题可以通过将lambda声明为auto而不是函数来解决。为什么是这种情况？
#include <functional>
#include <iostream>
#include <vector>
typedef std::vector<double> Vec;
typedef std::function<const Vec&(Vec)> Function;
int main()
{
//Function func = [](const Vec& a)-&g
浏览 4提问于2017-08-01得票数 3
回答已采纳
在over上，使用boost 1.55.0和clang-500.2.79 (基于LLVM 3.3svn)，我试图使用std::map中的boost::for_each和boost:sub_range迭代一个子范围。在我的函数对象中，我希望接收一个std：：偶数&。相反，我似乎收到了一个const：：pair &。为什么？
#include <map>
#include <boost/range/algorithm.hpp>
#include <boost/range/sub_range.hpp>
using std::map;
using
浏览 3提问于2014-02-09得票数 0
回答已采纳
因此，下面是代码中与错误相关的部分：
Array Array::transform(std::function<int(int)>&f)
{
std::for_each(niz, niz + n, [&f](Tacka &r) {r.setX(f(r.getX())), r.setY(f(r.getY())); });
return *this;
}
Array Array::operator+=(const int a)
{
return transform([&a](int b) { return b + a; });
浏览 4提问于2016-11-15得票数 1
回答已采纳
让我们假设我有一个具有以下签名的函数：
void foo(std::function<void(int&)>& bar);
以下调用成功编译：
foo([](int& x) { ++x; });
这也成功地编译了：
std::function<void(int&)> myFunction = [](int& x) { ++x; };
foo(myFunction);
但是，通过自动类型推断，它突然无法编译：
auto myFunction = [](int& x) { ++x; };
foo(myFunction);
AF
浏览 10提问于2017-01-20得票数 2
回答已采纳
以下每一种行为是如何不同的？
我不清楚const对函数参数有什么影响，在这种情况下，通过值传递、通过引用传递还是通过rvalue引用传递会有什么区别。
请注意，我理解按值传递和通过引用传递之间的区别。但是，在std::function的具体例子中，或者更具体的是lambda，我不知道通过值传递lambda和通过引用传递lambda会做什么。按价值传递羔羊意味着什么？要复制的数据是什么？
另外，const和lambdas之间有什么实际区别吗？
#include <functional>
void foo_with_func( std::function<void()
浏览 0提问于2015-04-02得票数 0
回答已采纳
给定以下工作代码(main.cpp)：
#include <functional>
#include <iostream>
struct worker
{
std::function<bool(std::string)> m_callback;
void do_work(std::function<bool(std::string)> callback) // <--- this line
{
m_callback = std::bind(callback, std::placeholders::_1);
浏览 0提问于2018-08-29得票数 0
回答已采纳
2回答
何时可以使用auto作为用lambda函数初始化的变量的类型说明符？我试图在以下程序中使用auto：
#include <iostream>
#include <functional>
class A
{
const std::function <void ()>* m_Lambda = nullptr;
public:
A(const std::function <void ()>& lambda): m_Lambda (&lambda) {}
void ExecuteLambda()
{
浏览 0提问于2021-09-29得票数 1
回答已采纳
我有一个单独的类来处理线程，并且有一个函数需要创建一个线程并在特定的时间间隔内重复该函数 void timer_start_custom(std::function<void(string, string&, vector<CustomObject>&)> func, string filename, string& lastline, vector<CustomObject>& dict, unsigned int interval){
std::thread([func, interval, filename,
浏览 36提问于2019-04-01得票数 2
回答已采纳
给予：
void foo(std::string &s) {
...
}
为什么这会导致编译器错误：
foo(std::string("fail"));
因为这很好：
std::string s("winning");
foo(s);
故障情况的错误是error: no matching function for call to ‘foo(std::string)’。
在获胜的情况下，我认为编译器还是会优化出s。我在这里错过了什么概念？
浏览 2提问于2014-10-06得票数 1
回答已采纳
1回答
#include <iostream>
#include <memory>
class Base{
};
class Derive : public Base{
};
void foo(std::shared_ptr<Base>& p){
}
void bar(const std::shared_ptr<Base>& p){
}
int main(){
auto base = std::make_shared<Base>();
foo(base);
bar(base);
aut
浏览 0提问于2017-09-15得票数 1
我想将boost::model::polygon转换为boost::model::multi_point，下面是我的实现：
namespace bg = boost::geometry;
typedef bg::model::point<double, 3, bg::cs::cartesian> point3d;
bg::model::multi_point<point3d> result;
std::function<void(point3d)> appendPoint = [result](point3d point){
bg::append(
浏览 2提问于2014-08-19得票数 1
回答已采纳
1回答
考虑以下片段：
#include <iostream>
#include <vector>
#include <functional>
int main()
{
std::vector<int>v = {0,1,2,3,4,5,6};
std::function<const int&(int)> f = [&v](int i) { return v[i];};
std::function<const int&(int)> g = [&v](int i) ->
浏览 0提问于2015-04-13得票数 29
从我的经验来看，其中之一是：
函数调用中创建的lambda表达式在调用后立即销毁。
调用一个需要std::function的函数会从lambda中创建一个临时对象(std:: function )，并且该对象在调用后被销毁。
下面的代码片段可以观察到这种行为：
const function<void()>* pointer;
void a(const function<void()> & f)
{
pointer = &f;
}
void b()
{
(*pointer)();
}
int main()
{
浏览 3提问于2012-12-09得票数 8
回答已采纳
我创建了decorator函数来向现有函数添加功能。该程序输出正确的函数指针地址，并按照预期迭代10x helloworld所用的时间。
但是，如果我将decorator函数更改为original_function by value (FunctionPointer original_function)，程序就会因分段错误而终止，我不知道它失败的原因。
#include <iostream>
#include <chrono>
typedef void (*FunctionPointer)();
auto
decorator(FunctionPointer &
浏览 2提问于2019-07-09得票数 1
我正在做一些C++测试，我不理解下面的代码：
class A
{
public:
A(int n = 0): m_n(n)
{
std::cout << 'd';
}
A(const A& a): m_n(a.m_n)
{
std::cout << 'c';
}
private:
int m_n;
};
void f(const A &a1)
{
}
int main()
{
//Call 'f' function and prints: d
f(3);
浏览 1提问于2014-08-29得票数 2
回答已采纳
在下面的代码中，编译器似乎有时更喜欢调用模板化的构造函数，并且在复制构造函数应该很好的时候无法编译。根据值被捕获为v还是v= v，行为似乎会发生变化，我认为它们应该是完全相同的。我遗漏了什么？
我使用gcc 11.2.0并用"g++ file.cpp -std=C++17“编译它
#include <functional>
#include <iostream>
#include <string>
using namespace std;
template <class T>
struct record {
explicit re
浏览 5提问于2022-07-06得票数 16
回答已采纳
我希望将空std::unique_ptr移动到std::shared_ptr，如下所示：
std::unique_ptr<float> test = nullptr;
std::shared_ptr<float> test2 = std::move(test);
据我所知，这样做是合法的，而且它在2015和GCC中运行得很好。
但是，对于具有删除声明的std::unique_ptr，我不能这样做，如下所示：
std::unique_ptr<float,void(*)(float*)> test = nullptr;
std::shared_ptr<fl
浏览 1提问于2018-03-16得票数 2
回答已采纳
我使用std：：string流构造一个字符串，然后尝试将已完成的字符串作为引用传递给函数，该函数以std:: string &作为参数。
我收到了GCC的一个编译错误：
../src/so.cpp:22:21: error: invalid initialization of non-const reference of type ‘std::string& {aka std::basic_string<char>&}’ from an rvalue of type ‘std::basic_stringstream<char>::__string
浏览 3提问于2015-02-10得票数 4
回答已采纳
考虑到以下代码：
template <typename U> U func1(std::function<U()> func2) {
return func2();
}
const int x = 1;
const int& result1 = func1<const int&>([&x]() { return x; });
// result1 = ??????? (random garbage)
const int& result2 = [&x]() { return x; }();
// result2 =
浏览 2提问于2018-01-04得票数 2
回答已采纳
2回答
我像这样定义了一个类： class foo {
public:
// I define const and non-const versions of the 'visit' function
// nb. the lambda is passed by reference
virtual void visitWith(std::function<void(foo&)>&);
virtual void visitWith(std::function<void(const foo&)>&) const;
}
浏览 20提问于2020-09-28得票数 4
回答已采纳
2回答
值参数类型与引用值参数类型的std::function之间有什么实际区别吗？考虑以下代码：
auto foo = [] (VeryBigType i) {
};
auto bar = [] (const VeryBigType& i) {
};
std::function<void(VeryBigType)> a;
a = foo;
a = bar;
std::function<void(const VeryBigType&)> b;
b = foo;
b = bar;
这段代码编译时没有问题，运行良好。我知道，按值传递与按引用传递具有不
浏览 5提问于2020-05-07得票数 2
回答已采纳
2回答
#include <iostream>
void f(const int * & p)
{
int i =0;
i = p[0];
std::cout << i << std::endl;
}
int main()
{
int * p =new int[1];
p[0] =102;
f(p);
return 1;
}
对于此代码，gcc编译器会给出错误：
prog.cpp: In function ‘int main()’:
prog.cpp:16: error: invalid init
浏览 1提问于2011-04-07得票数 3
回答已采纳
在下面的代码中，我想将shared_ptr<Derived>作为shared_ptr<Base>&参数传递，但失败了。
错误显示，
cannot bind non-const lvalue reference of type 'std::shared_ptr<Base>&' to an rvalue of type 'std::shared_ptr<Base>'
所以看起来我只能将shared_ptr<Derived>作为const参数传递，但这不是我想要做的，如何作为non-const
浏览 0提问于2020-10-14得票数 1
今天遇到了一个有趣的问题，这是由我自己的错误引起的。我创建了一个lambda，它接受对结构的引用，并错误地将其设置为一个std::function，该函数通过值接收它的参数。
这里有一个更简洁的版本：
#include <functional>
struct InputStruct
{
int i;
InputStruct(): i(1){}
};
void function_rcv(std::function<bool(InputStruct)> & func_ref)
{
InputStruct in;
func_ref(
浏览 2提问于2019-02-20得票数 6
回答已采纳
2回答
我有一个问题，如何用更少的局部变量和符号使代码更易读，比如"*"，"&“
当我写这样的代码时：
inline std::string&
EmbraceBySQuote (
std::string& str ) {
str = "'" + str + "'";
return str;
} /* ----- end of function EmbraceBySQuote ----- */
我不能做这样的事
fmter % ( *detail::EmbraceB
浏览 2提问于2012-11-10得票数 0
2回答
我试图将一个函数传递给一个模板，到目前为止，我获得了以下内容：
template <typename T, typename U> void special_sort(std::vector<T>& container, std::vector<U>& ordering_container,
std::function<std::vector<std::pair<unsigned int, unsigned int>>(std::vector<U>&)>& sort_fu
浏览 0提问于2019-04-10得票数 1
回答已采纳
我在std::visit和overloaded中遇到了我认为是一个奇怪的情况，这给了我一个编译器错误。为了说明我正在尝试做什么，我有一个使用std：：访问3种不同方式的示例。
方法1，直接对返回一个std::visit的变量调用T const&，
方法2，将std::visit代码包装成一个免费函数：T const& fn(variantT const&)
方法3，使用访问器T const& get_XXX() const将变体包装在结构中
，我的目标是能够将std::visit部件封装在一个函数中，因为在我的用例中，它不是一小部分代码。我有
浏览 7提问于2022-04-04得票数 2
回答已采纳
我希望在C++11中按照实现一个“可中断”线程。
我已经参数化了我的可中断类，这样它就可以包装任何具有类似构造函数的线程类(用于std：：线程，但也应该适用于类似于boost：：线程之类的线程(尽管boost：：线程已经具有此功能)。那部分应该不重要。
尽管链接的答案有一些问题我必须纠正，这对我来说很有意义，所以我想找出我的错误所在。
我已经列出了相关的资料来源和结果。
interruptible.hpp
#include <atomic>
#include <exception>
#include <thread>
class interrupted_e
浏览 4提问于2015-01-03得票数 1
2回答
这是我的程序的精简版本，用来说明这个问题：
#include <functional>
#include <iostream>
template<class T>
class Piped {
public:
typedef T value_type;
};
template<class P1, class P2, class T>
class PipeConnector : public Piped<T> {
public:
PipeConnector(const P1 &p1, const P2 &
浏览 4提问于2015-05-26得票数 1
回答已采纳
我试图更好地理解lvalue和rvalue是如何作为引用处理的，因此我创建了这个玩具示例：
#include <iostream>
struct Val
{
Val(int num) : num(num){};
~Val()
{
std::cout << "Destructing with value " << num << std::endl;
}
int num;
};
const Val &test(const Val &val)
{
re
浏览 5提问于2020-09-20得票数 3
回答已采纳
我试图使用lambda来传递函数指针，但是VS2010似乎无法转换它。我试过使用std：：像这样的函数，它会崩溃，我不知道我是否做对了！
#include <windows.h>
#include <conio.h>
#include <functional>
#include <iostream>
#include <concrt.h>
void main()
{
std::function<void(void*)> f = [](void*) -> void
{
std::
浏览 1提问于2010-07-28得票数 10
回答已采纳
我想在lambda表达式中捕获一个std::vector<std::unique_ptr<MyClass>>类型的变量(换句话说，“通过移动捕获”)。我找到了一个使用std::bind来捕获unique_ptr ()的解决方案，并决定将其作为一个起点。然而，我所能得到的建议代码的最简化版本不能编译(很多模板错误，它似乎试图调用unique_ptr的复制构造函数)。
#include <functional>
#include <memory>
std::function<void ()> a(std::unique_ptr<i
浏览 2提问于2013-06-24得票数 3
回答已采纳
也许有些东西我没有完全理解，但是在读完"Use decltype on auto&& parameters to std::forward them“(来自高效现代C++)后，我发现了一些非常奇怪的东西。
让我们假设我们有
int size(std::string &&s) { std::cout <<"std::string&&" <<std::endl; return s.size(); }
int size(const std::string &s) { std::cout <&
浏览 0提问于2016-02-09得票数 1
我写了以下代码：
#include <iostream>
class A
{
public:
A(){ std::cout << "created" << std::endl; }
A(A& other) { std::cout << "copied" << std::endl; }
A& get(){ std::cout <<"got" << std::endl; return *this; }
~A(){ st
浏览 0提问于2011-10-22得票数 2
回答已采纳
2回答
我怎么能让这件事行得通？
#include <iostream>
#include <thread>
using namespace std;
int main()
{
auto thr = []<typename PrintType>( PrintType &p )
{
cout << p << endl;
};
string str = "hello world";
jthread jt( thr, ref( str ) );
}
我甚至不明白这有
浏览 5提问于2021-12-07得票数 -1
我尝试以这种方式使用C++0x初始化程序列表作为构造函数调用的参数：
Foo<float> foo("Foo 1", std::vector<const char *>({ "foo A", "foo B" }) );
使用构造函数
Foo(const char *name, std::vector<const char *> &foos)
对于这个构造函数，编译器抱怨道：
error: no matching function for call to Foo<float>::Foo(
浏览 1提问于2011-06-10得票数 8
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
