function call with default parameter

Question

I wrote an examination about C++ programming. There was one question where I and my professor didn't agree. The question was, does the following function work or not:

#include <iostream>
using namespace std;

void f(int=4, long=10, double=3.14);

int main( int argc , char ** argv )
{
    f( , ,8);
      return EXIT_SUCCESS;
}

void f(int i, long l, double d) {
    cout << i << " " << " " << l << " " << d;
}

I said it would not work, but my professor said it will definitely work because of the default parameter in the function declaration. I tried it with MSVC and it didn't work. Is that compiler-specific? How can I convince my professor it doesn't work in any compiler, to raise my mark in the examination?

score 6 · Accepted Answer · answered May 22 '13 at 18:21

To begin with, you're right, the professor is wrong. And the fact that he claims that this should work (when it's trivial to show that it doesn't) means he probably shouldn't be teaching C++. But how to show him?

Just try to compile it with at least two different compilers. If both fail to compile it, then there's a very good chance it's not valid code. That's the fastest way.

If that fails, quote the C++ standard. Here's the syntax for a call expression, as described in [expr.post]p1 and following the non-terminal references:

postfix-expression:
    ...
    postfix-expression ( expression-list[opt] )

expression-list:
    initializer-list

initializer-list: ([dcl.init]p1)
    initializer-clause ...[opt]
    initializer-list , initializer-clause ...[opt]

initializer-clause:
    assignment-expression
    braced-init-list

braced-init-list:
    { initializer-list ,[opt] }
    { }

I'm not going to list assignment-expression, but note that an expression cannot ever be nothing, there has to be at least one token. Which means that an initializer-clause can never be nothing, and thus there always has to be something between the commas in the function arguments.

Thanks, now I am in the position to provide perfect counterarguments — tzwickl, May 22 '13 at 19:02

score 4 · Answer 2 · edited Jun 20 '20 at 09:12

From the Standard (emphasis mine, note particularly the word trailing) :

8.3.6 Default arguments [dcl.fct.default]

If an initializer-clause is specified in a parameter-declaration this initializer-clause is used as a default argument. Default arguments will be used in calls where trailing arguments are missing.

[ Example: the declaration

void point(int = 3, int = 4);

declares a function that can be called with zero, one, or two arguments of type int. It can be called in any of these ways:
point(1,2); point(1); point();
The last two calls are equivalent to point(1,4) and point(3,4), respectively.

— end example ]

Enjoy getting your points back. ;)

Thank you the fact that only trailing arguments are allowed to omit, sounds to be a good argument :) I will try to explain it to him on this way. — tzwickl, May 22 '13 at 18:26

score 1 · Answer 3 · answered May 22 '13 at 18:16

1

That's not even valid C++ syntax.

answered May 22 '13 at 18:16

Kerrek SB

464,522
92
875
1,084

1

@tom1991te: You cannot say `f( , , 8)`. That's not allowed. – Kerrek SB May 22 '13 at 18:24
Yes I know exactly this was my question :) I know that this isn't valid but my prof doesn't know that :D – tzwickl May 22 '13 at 18:28
@KerrekSB: not *that* pointless since the professor removed points from OP's test because of that. ;) – syam May 22 '13 at 18:32

score 1 · Answer 4 · edited May 30 '13 at 19:18

1

It's probably because it only works for omitted trailing parameters, as said by msdn. Try calling the function like this:

f(); // should use all default values for arguments
f(3); // should use 3 for the first, default for the last two 
f(2, 5); // uses 2 for first, 5 for second, default for last
f(5, 6, 3.4); // does not use any default values

edited May 30 '13 at 19:18

Kate Gregory

18,808
8
56
85

answered May 22 '13 at 18:18

tay10r

4,234
2
24
44

function call with default parameter

4 Answers4

Linked

Related