default-parameters

When I try to compile and run this code (only the first three lines really matter): class object; object getObject(); void doSomething(object o = getObject()); class object{ public: int num = 0; }; object getObject(){ return {}; } void doSomething(object o){ o.num = 5; } int main(){} I get this error: main.cpp:3:39: error: invalid use of incomplete type 'class object' void doSomething(object o = getObject()); ^ main.cpp:1:7: note: forward declaration of 'class object' class object; ^ How would I get it to compile without changing the order of everything? In my actual code, the declarations are

I have trouble understanding how default parameters interact with multiple clauses in named functions. It boils down to, why does the following snippet work? defmodule Lists do def sum([], total \\ 0), do: total def sum([h|t], total), do: h + sum(t, total) end From my understanding this gets expanded by the compiler into: defmodule Lists do def sum([]), do: sum([], 0) def sum([], total), do: total def sum([h|t], total), do: h + sum(t, total) end So I would expect the following to happen: iex(1)> Lists.sum [1,2,3,4] ** (FunctionClauseError) no function clause matching in Lists.sum/1 instead it

Following code can't be compiled with g++ version 5.4.0 with option -std=c++1y : void f(int=0) ; int main() { f(); // ok (*f)(2);// ok (*f)();// ok c++11; error with c++14: too few arguments to function return 0; } The function declared to have default argument, so what is wrong here? thanks for help. And why does g++ -c -std=c++11 compile? Accepting (*f)() as valid is a GCC bug. The letter of the standard indicates that using a function name with unary * should cause the function name to decay into a pointer. The pointer should then be dereferenced to obtain the functions address for the call

I have the following class: template <typename Type = void> class AlignedMemory { public: AlignedMemory(size_t alignment, size_t size) : memptr_(0) { int iret(posix_memalign((void **)&memptr_, alignment, size)); if (iret) throw system_error("posix_memalign"); } virtual ~AlignedMemory() { free(memptr_); } operator Type *() const { return memptr_; } Type *operator->() const { return memptr_; } //operator Type &() { return *memptr_; } //Type &operator[](size_t index) const; private: Type *memptr_; }; And attempt to instantiate an automatic variable like this: AlignedMemory blah(512, 512); This

My Javascript function leads my console to return me : TypeError: style is null Here the snippet: let style = { one: 1, two: 2, three: 3 } function styling(style = style, ...ruleSetStock) { return ruleSetStock.map(ruleSet => { console.log(ruleSet) return style[ruleSet] }) } console.log(styling(null, "one", "two", "three")) I can't understand why. It seems to me everything is great, Any hint would be great, thanks. Default parameters is assigned only if no value or undefined is passed let defaultStyle = { one: 1, two: 2, three: 3 } function styling(style = defaultStyle, ...ruleSetStock) {