The type of a template parameter in a function can’t be deduced from a default argument. As shown in the example on cppreference.com: Type template parameter cannot be deduced from the type of a function default argument: template<typename T> void f(T = 5, T = 7); void g() { f(1); // OK: calls f<int>(1, 7) … Read more
You can’t have non-default parameters after your default parameters begin. Put another way, how would you specify a value for b leaving word to the default of “hello” ?
Looks like this bug was fixed in 4.8.3/4.9.0, the bug report which has a similar example and also seg-faults says: The attached minimal testcase has the following function with default-constructed default argument: void do_something( foo f = {} ) { std::cout << “default argument is at ” << &f << std::endl; } The constructor for … Read more
The std::exchange was proposed in N3511 without default template argument, and later N3608 with a default template argument. Note that in N3608 the following reasoning was provided: Giving the second template argument a default value fixes the following two cases: DefaultConstructible x = …; if (exchange(x, {})) { … } int (*fp)(int); int f(int); double … Read more
Note: Foo me; without template arguments is legal as of C++17. See this answer: https://stackoverflow.com/a/50970942/539997. Original answer applicable before C++17: You have to do: Foo<> me; The template arguments must be present but you can leave them empty. Think of it like a function foo with a single default argument. The expression foo won’t call … Read more
There is no real reason that lambdas can’t have default arguments. However, there are two main ways to use lambdas, and only one of them would allow default arguments without changing the type system. You can call the lambda directly, or through a template. Default parameters would work fine in this case. You can call … Read more
According to PEP8, you should “Always use a def statement instead of an assignment statement that binds a lambda expression directly to a name.” So, one thing I would change is: def blank_fn(*args, **kwargs): pass However, I think a more pythonic way to do this is: def perform_task(callback=None): print ‘doing stuff’ if callback is not … Read more
You can’t have non-default parameters after your default parameters begin. Put another way, how would you specify a value for b leaving word to the default of “hello” ?
You can’t really define this as the default value, since the default value is evaluated when the method is defined which is before any instances exist. The usual pattern is to do something like this instead: class C: def __init__(self, format): self.format = format def process(self, formatting=None): if formatting is None: formatting = self.format print(formatting) … Read more
According to the C++17 standard (11.3.6 Default arguments) 9 A default argument is evaluated each time the function is called with no argument for the corresponding parameter. A parameter shall not appear as a potentially-evaluated expression in a default argument. Parameters of a function declared before a default argument are in scope and can hide … Read more