default-parameters

I am trying to figure out if it is possible to handle multiple levels of default parameters with destructuring. Since it is not easy to explain with words, here is a step-by-step example... 1 - Flat object destructuring with default parameters Destructuring this object is easy: let obj = { foo: 'Foo', bar: 'Bar' }; With {foo = 'Foo', bar = 'Bar'} = {} in a function signature, an object will be created if there is no argument passed when the function is called. If an object is passed but some referenced properties are undefined , they will be replaced by their default values. This code works

How does C++ handle function pointers in relation to functions with defaulted parameters? If I have: void foo(int i, float f = 0.0f); void bar(int i, float f); void (*func_ptr1)(int); void (*func_ptr2)(int, float); void (*func_ptr3)(int, float = 10.0f); Which function pointers can I use in relation to which function? Both foo() and bar() can only be assigned to func_ptr2 . §8.3.6/2 : A default argument is not part of the type of a function. [Example: int f(int = 0); void h() { int j = f(1); int k = f(); // OK, means f(0) } int (*p1)(int) = &f; int (*p2)() = &f; // error: type mismatch --end

In fortran, we can define default arguments. However, if an optional argument is not present, it can also not be set. When using arguments as keyword arguments with default values, this leads to awkward constructs like PROGRAM PDEFAULT CALL SUB CALL SUB(3) CONTAINS SUBROUTINE SUB(VAL) INTEGER, OPTIONAL :: VAL INTEGER :: AVAL ! short for "actual val" IF(PRESENT(VAL)) THEN AVAL = VAL ELSE AVAL = -1 ! default value END IF WRITE(*,'("AVAL is ", I0)') AVAL END SUBROUTINE SUB END PROGRAM PDEFAULT Personally, I often ran into the problem of accidentially typing VAL instead of AVAL , i.e. the

I changed a paremeter in a function to accept any kind of object using a template but I can't use it in conjunction with other default parameters, is there something I am missing? #include <string> #include <iostream> class MyClass { public: std::wstring msg = L"hey"; MyClass(){}; }; class MyClass2{ public: template<class T> MyClass2(T* t, int i); }; template<class T> MyClass2::MyClass2(T* t,int i=0){ std::wcout << t->msg << std::endl; } int main(int argc, char **argv) { MyClass mc; MyClass2 mc2(&mc); return 0; } Output: practice.cpp:16:32: error: redeclaration of 'MyClass2::MyClass2(T*, int)'

So... ES6¹ (which happens to be standardized a few hours ago) brings default parameters for functions similar to those in PHP, Python etc. I can do stuff like: function foo (bar = 'dum') { return bar; } foo(1); // 1 foo(); // 'dum' foo(undefined); // 'dum' MDN says that the default value for the parameter is evaluated at call time. Which means each time I call the function, the expression 'dum' is evaluated again (unless the implementation does some weird optimizations which we don't care about). My question is, how does this play into this? let x = { foo (bar = this.foo) { return bar; } } let

Caution: This problem is limited to MSVS I have this function signature: void do_somthing(std::vector<foo>& bar={}); Is it possible to differ between those two calls for the function: First: do_something() Second: std::vector<foo> v; do_something(v); In other words, I want something like: void do_somthing(std::vector<foo>& bar={}){ if(/* bar was defaulted*/){ } else{ } } EDIT: The actual code: template<class Tinput_iterator> Tmodel perform_fitting(Tinput_iterator begin_data, Tinput_iterator end_data, std::vector<Tpoint>& inliers = {}); I have this function signature: void do_somthing(std: