Inserting std::shared_ptr with lambda into a vector - c++

Question

I have a vector defined as:
std::vector<std::shared_ptr<Orders> > vOrders;
When adding to vOrders I want to add like:
vOrders.push_back(<std::shared_ptr<Orders> >([]() {
TimerForProcessingOrders _timerForProcessingOrders;
_timerForProcessingOrders.detach();
}));
but the compiler is giving me an error:
Expected expression: Expected '(' for function-style cast or type construction
It looks weird the < and > around std::shared_ptrbut removing it gives an error:
No matching conversion for functional-style cast from '<lambda >' to 'std::shared_ptr<Orders>'
What mistake am I making?

Answer 1

What this code does (in an ill formed way) is take the object constructed by the lambda, and store the lambda itself into the vector -- not an object of type shared_ptr<Order> which is what the vector requires.
but the compiler is giving me an error:
This is because the extra < > are completely invalid syntax, so the best the compiler can give you is "invalid expression".
It looks weird the < and > around std::shared_ptrbut removing it gives an error:
No matching conversion for functional-style cast from '<lambda >' to 'std::shared_ptr<Orders>'
Basically what you have here is shared_ptr<Orders>(/* .. Lambda .. */) -- and the compiler is saying that it has no idea how to turn the lambda into an Orders* to go into the shared_ptr.
What are you actually trying to accomplish here?
If you just want to transfer a pointer into the shared_ptr you can do something like
TimerForProcessingOrders _timerForProcessingOrders;
std::shared_ptr<Orders> ptr(_timerForProcessingOrders.detach());
vOrders.emplace_back(std::move(ptr));
no lambda is required.

Answer 2

What type is Orders? Actually, it doesn't really matter: the expression [](){ ... } certainly isn't of a type convertible to Orders*. ... and the angle brackets around the argument to push_back() a definitely wrong.
Did you mean to call the lambda expression?
vOrders.push_back(std::shared_ptr<Orders>([]() {
TimerForProcessingOrders _timerForProcessingOrders;
return _timerForProcessingOrders.detach();
})()
); // ^^ note these extra parenthesis
... but even that shouldn't work as the lambda expression doesn't return anything (hence the also added return).

Answer 3

Firstly, I'd suggest you follow Billy ONeals train of thought. But if you want to do it your way this is a SSCE of it.
There are two changes, this lambda returns an object and is executed, thereby returning.
#include <vector>
#include <memory>
#include <iostream>
struct Foo {
int val;
};
int main(int argc, char** argv) {
std::vector<std::shared_ptr<Foo> > v;
v.push_back([]() -> std::shared_ptr<Foo> { Foo f; f.val = 5; return std::make_shared<Foo>(f); }());
std::cout <<v[0]->val <<std::endl;
return 0;
}