Initializing variable in C++ function header

I've come across some C++ code that looks like this (simplified for this post):

(Here's the function prototype located in someCode.hpp)

void someFunction(const double & a, double & b, const double c = 0, const double * d = 0);

(Here's the first line of the function body located in someCode.cpp that #include's someCode.hpp)

void someFunction(const double & a, double & b, const double c, const double * d);

Can I legally call someFunction using:

someFunction(*开发者_StackOverflowptr1, *ptr2);

and/or

someFunction(*ptr1, *ptr2, val1, &val2);

where the variables ptr1, ptr2, val, and val2 have been defined appropriately and val1 and val2 do not equal zero? Why or why not?

And if it is legal, is this syntax preferred vs overloading a function to account for the optional parameters?

---

Yes, this is legal, this is called default arguments. I would say it's preferred to overloading due to involving less code, yes.

Regarding your comment about const, that doesn't apply to the default value itself, it applies to the argument. If you have an argument of type const char* fruit = "apple", that doesn't mean it has to be called with a character pointer whose value is the same as the address of the "apple" string literal (which is good, since that would be hard to guarantee). It just means that it has to be called with a pointer to constant characters, and tells you that the function being called doesn't need to write to that memory, it is only read from.

---

Yes, the parameters are optional and when you don't pass them, the given default values will be used.

It has some advantages and disadvantages to use default parameter values instead of overloading. The advantage is less typing in both interface and implementation part. But the disadvantage is that the default value is a part of interface with all its consequences. Then when you change the default value, you for example need to recompile a lot of code instead of a single file when using overloading.

I personally prefer default parameters.

---

I'd like to expand a bit on whether Default Parameters are preferred over overloading.

Usually they are for all the reasons given in the other answers, most notably less boilerplate code.

There are also valid reasons that make overloading a better alternative in some situations:

Default values are part of the interface, changes might break clients (as @Juraj already noted) Additionally Overloads make it easier to add additional (combinations of) parameters, without breaking the (binary) interface.

Overloads are resolved at compile time, which can give the compiler better optimization (esp inlining) possibilities. e.g. if you have something like this:

void foo(Something* param = 0) {
   if (param == 0) {
      simpleAlgorithm();
   } else {
      complexAlgorithm(param);
   }
}

It might be better to use overloads.

---

Can I legally call someFunction using:

someFunction(*ptr1, *ptr2);

Absolutely! Yes, the other 2 variables that the function accepts would have default values you have set in the header file which is zero for both the arguments.

But if you do supply the 3rd and the 4th argument to the function, then those values are considered instead of the default values.