Thread: Function overloading....with const as one of the argument

My question is that can i overload function in c++ on the basis of declaring one argument as with const (constant).........

Eg..

Code:

int foo(int a)
{
 bla bla....
}

and

Code:

int foo(const int a)
{
bla bla....
}

are these two function same................i did it but got error....

Function Overloading this link say function overloading can be done with const ....YES is given there

> are these two function same................i did it but got error....
Posting actual code and actual error messages would help.

All you're going to get is "works for me" posts.

Code:

$ cat m1.cpp
#include <iostream>
using namespace std;

void foo ( const int *a ) {
  cout << "const " << *a << endl;
}
void foo ( int *a ) {
  cout << "var " << *a << endl;
}

int main ( ) {
  const int a = 1;
  int b = 2;
  foo(&a);
  foo(&b);
}
$ g++ m1.cpp
$ ./a.out 
const 1
var 2

See - works for me!

You've left out "int" from your second function, but it wouldn't work even if you put it in. The reason is that there is no essential difference between those two. It's basically useless to declare an int parameter as const since it's just getting a copy of the value anyway. const is a guarantee to the caller that it's data won't be modified when it's passed by reference or pointer.

So the way to overload on const is like this:

Code:

int foo(int *a) {  // or int &a
    //...
}

int foo(const int *a) { // or const int &a
    //...
}

Your example is getting more stupid. Now you have one that's an int and one that's a (const) POINTER to an int, so obviously they are very different. You ask for "DETAIL" from us, but you yourself are being very sloppy. Re-read the examples above. I suspect that's all you're gettin'.

Originally Posted by Rohit Kumar

i used "*" pointer and it worked ...with const

Code:

int fun(int b)
{
    //..........
}

Code:

int fun(const int* b)
{
   //............
}

can u pls tell me IN DETAIL why..now these two function become different......

For some real 'fun', try calling that with zero!

Originally Posted by iMalc

For some real 'fun', try calling that with zero!

Or NULL - same thing. To fix that, you should use nullptr if you have a C++11 compiler.

I'm no expert on the overloading/conversion/promotion riles, but I believe the real reason you can't overload int and const int the way you did is because a number (without postfixes), such as as 5, is pretty much a const int (because it's an int and you can't assign to a number).

Now, that int can be passed to the int overload (because a copy is made, the compiler won't break constness). But it can also be passed to const int, because again, the same logic applies. Either way, a copy is made, so the compiler cannot decide which function to call.

In Salem's example, it works because with a const int*, it cannot call the int* function, because that would allow the function to be able to modify the original value, hence breaking the const promise. That leaves only one overload, and that is the one it picks.

Well, essentially it says that any const and volatile specifiers that are not part of a pointer or reference type are ignored, so

void foo(int);
void foo(const int);
void foo(volatile int);
void foo(const volatile int);

are all considered equivalent. But if you add a pointer or reference type, the const or volatile becomes significant (i.e. not ignored), so

void foo(int*)
void foo(const int*)
void foo(int&)
void foo(const int&)

are all different signatures.

And so these are considered equivalent too:

void foo(int * const)
void foo(int * )

(same with & instead of *; or volatile (or const volatile) instead of const)

Basically, if it doesn't make a difference to the caller, it's equivalent.

You can't overload based on const-ness when it's pass-by value, because that const only says something about the copy, not the original.

Plus, using const while passing by value should be avoided anyway.

O_o

Nonsense.

One may avoid it if they desire, but if one desires the "firewall" of the compiler preventing one from accidentally mutating a variable, the approach is fine.

Soma

A gotcha with top level const variables, including parameters, is that if the type is movable, then making it top-level-const prevents it from being moved. This mostly creates an inefficiency error when returning such a variable by value. This is particularly relevant when there are multiple return statements in the function that return different variables, because RVO tends to fail in those cases. It can also create the same problem when you explicitly move the variable, but in that case the error is more obvious.

So that's a reasonable C++11 reason to avoid them.