callable-object

I have various functions in my codebase that take a generic callable object and pass it to a series of nested lambdas before calling it. Example: template <typename TF> void interface(TF&& f) { nested0([/*...*/]() { nested1([/*...*/](auto& x) { nested2([&x, /*...*/]() { f(x); }); }); }); } Note that interface is taking a callable object of type TF by forwarding reference (previously known as universal reference) . The callable object is usually a lambda with various captured variables, both by value and by reference. What is the best (in terms of performance) way of capturing f in the nested

I have a list of numbers. I am trying to filter the list and only keep the positive numbers. I am trying to do it by passing a lambda as an argument. I wonder why I get function mismatch error. #include <vector> #include <algorithm> #include <functional> template<typename T> std::vector<T> keep( const std::vector<T> &original, std::function<bool(const T&)> useful) { std::vector<T> out; for(T item:original) { if(useful(item)) out.push_back(item); } return out; } int main() { std::vector<int> a={4,6,2,-5,3,-8,13,-11,27}; a=keep(a,[](const int& x)->bool{return x>0;}); for(int y:a) { std::cout<<y<

Basically, what I want to achieve is compile-time verification (with possibly nice error message) that registered callable (either a function, a lambda, a struct with call operator) has correct signature. Example (contents of the static_assert are to be filled): struct A { using Signature = void(int, double); template <typename Callable> void Register(Callable &&callable) { static_assert(/* ... */); callback = callable; } std::function<Signature> callback; }; Most of the answers are focused on basically answering the question: can you call the given function object with values of these types.

I want to know the difference between __init__ and __call__ methods. For example: class test: def __init__(self): self.a = 10 def __call__(self): b = 20 Cat Plus Plus The first is used to initialise newly created object, and receives arguments used to do that: class Foo: def __init__(self, a, b, c): # ... x = Foo(1, 2, 3) # __init__ The second implements function call operator. class Foo: def __call__(self, a, b, c): # ... x = Foo() x(1, 2, 3) # __call__ avasal Defining a custom __call__() method in the meta-class allows the class's instance to be called as a function, not always modifying the