How to know whether a optional function parameter was passed or is it using the default function parameter?

Question

void foo (  int arg1, int arg2)

foo(1)

foo(1,2)

how do i know whether the int arg2 is using the optional function parameter that was passed like in the second foo call or the default one was used like in the 1st foo?

Update:

public:

header file

// Point 1
void fireworkShipment(stack<Firework*>&);
void sellFireworks(stack<Firework*>&, int quantity);

// Point 2
void metalShipment(stack<Metal>&);
~FireworkFactory();

// Point 3 for correctness, Point 4 for O(1) runtime
void sellFireworks(stack<Firework*>&, int quantity, Color color);
void sellFireworks(stack<Firework*>&, int quantity); //error here

cpp file:

    void FireworkFactory::sellFireworks(stack<Firework*>& customerStack, int quantity, Color color){
    // TODO
    cout<< "which color: " << color << "\n";
    for (int i = 0; i< fireworkstorage.size(); i++) {
        if (fireworkstorage.front()->getColor() == color && quantity != 0) {
            customerStack.push(fireworkstorage.front());
            cout<< "Color: " <<fireworkstorage.front()->getColor() << "\n";
            fireworkstorage.pop();
            quantity--;
            cout<<  "Quantity: " <<quantity << "\n";
        } else {
            fireworkstorage.push(fireworkstorage.front());
            fireworkstorage.pop();
        }
    }    
}

void FireworkFactory::sellFireworks(stack<Firework*>& customerStack, int quantity){
    for (int i = 0; i<quantity; i++) {
        customerStack.push(fireworkstorage.front());
        fireworkstorage.pop();
    }
}

what i wanted to ask is there a way to determine whether an optional function parameter was supplied (arg2) when foo was call? — DST, Mar 02 '16 at 05:59
because what i wanted to do is that if arg2 was supplied ->do second thing. If not, if optional parameter was not suppled -> do first thing. — DST, Mar 02 '16 at 06:00
I dont think there is no way to determine whether a particular paremeter was passed or not by the caller if it is an optional argument. — sunny1304, Mar 02 '16 at 06:01
You defined `void sellFireworks(stack&, int quantity);` twice: in the `Point 1` and `Point 3` blocks. — awesoon, Mar 02 '16 at 06:58
@soon oh, ya i kinda forgot the previous function as i was so focus on this. — DST, Mar 02 '16 at 07:28

awesoon · Accepted Answer · 2016-03-02T06:14:31.843

4

You cannot. However, you may create overloaded function with one parameter:

#include <iostream>

void awesome_function_with_default_parameters(int arg1, int arg2 = 42)
{
    std::cout << "Doing some awesome work with " << arg1 << " and " << arg2 << std::endl;
}

void foo(int arg1, int arg2)
{
    std::cout << "Both parameters passed" << std::endl;
    awesome_function_with_default_parameters(arg1, arg2);
}

void foo(int arg1)
{
    std::cout << "Only one parameter passed" << std::endl;
    awesome_function_with_default_parameters(arg1);
}

int main()
{
    foo(1);
    foo(1, 314);
    return 0;
}

edited Mar 02 '16 at 06:14

answered Mar 02 '16 at 05:58

awesoon

32,469
11
74
99

can it be done in one function? like only in void foo(int arg1, int arg2) { bool arg2waspassed = true; } something like that. – DST Mar 02 '16 at 06:03
2

@DST: The first sentence answers that. – Benjamin Lindley Mar 02 '16 at 06:03
owh ok, kinda missed that, thank you for pointing it out. – DST Mar 02 '16 at 06:04
@DST, if you cannot modify original function, you could create a function-wrapper, which delegates actual work to the original function. – awesoon Mar 02 '16 at 06:05
@soon how do i do that? can you point me to a example, thanks. – DST Mar 02 '16 at 06:08
@DST, see updated answer. – awesoon Mar 02 '16 at 06:15
@soon i tried using the original method you showed me, but i am getting error for redefinition of my foo class and its giving me an error. How do i fix that? – DST Mar 02 '16 at 06:22
Are you sure, you removed default value from the function signature? It should be passed in the function with one parameter instead. – awesoon Mar 02 '16 at 06:24
@soon I have a header function that declare foo (int arg1, int arg2), so i having error having another foo(int arg1) in my .cpp file. Anyway to fix that? – DST Mar 02 '16 at 06:35
Could you add update the question with the header and implementation files, please? – awesoon Mar 02 '16 at 06:38
@soon updated, above – DST Mar 02 '16 at 06:47

score 1 · Answer 2 · answered Mar 02 '16 at 05:56

1

There is no way to know. if foo(1) works then you assume that optional parameter is used.

answered Mar 02 '16 at 05:56

sunny1304

1,684
3
17
30

Sorry, if i am kinda clumsy asking this question. – DST Mar 02 '16 at 05:57
Is there anyway i know whether the arg2 was supplied when foo is call? – DST Mar 02 '16 at 05:57
yes, when you see foo(1,2), you know that arg2 was supplied :) – sunny1304 Mar 02 '16 at 05:58

score 0 · Answer 3 · answered Mar 02 '16 at 07:41

There is, as others have already pointed out, no way to tell whether or not the default parameter was used, or a value specified explicitly. This is because default parameters are entirely handled at compile time and the program at run-time has no idea about them. So in theory you could have

void myFunc(int a, int b = 42);

in the header and in the cpp do

void myFunc(int a, int b) {
  bool defaultParamUsed = (b ==42);
  // rest of function
}

but this would mean that even someone providing the 42 explicitly would be deemed to have used the default parameter.

Just to make matters more complicated, because the compiler handles default parameters, you can quite nicely shoot yourself in the foot by providing different default parameter declarations for the same function signature. Consider in header a.h:

void myFunc(int a, int b=42);

In header b.h:

void myFunc(int a, int b=70);

and in the implementation file aMess.cpp:

void myFunc(int a, int b) // ...

The compiler would probably (I'm pretty sure but have not tried) complain (due to duplicate declaration) if both a.h and b.h were included anywhere, but different parts of your program could include different headers and thus work with different optional parameters.
It's hard to see under what circumstances one would want this. One case might be a function of the form

void doSomething(int param, int version);

Now different headers could specify different versions as default, and the user could still explicitly override the behaviour in case he or she requires the behaviour of a specific version.

How to know whether a optional function parameter was passed or is it using the default function parameter?

3 Answers3