Function Overloading

Code:

---

#include<iostream>
using namespace std;

int main()
{
  void disp(char *);
  void disp(const char *);
 
  char *a = "Vaibhav";
  const char *b = "Gaurav";
 
  disp(a);
  disp(b);
  getchar();   
}

void disp(char *a)
{
    cout<<"char";
}

void disp(const char *b)
{
    cout<<endl<<endl<<"const char";
}

---

now a is implicitly const, so shouldnt the both disp() calls go to

void disp(const char *b)

however, the run shows, first disp() calling void disp(char *a) and second disp() calling void disp(const char *b)

It goes to the exact match first. So since a is a char* and there is a function overload for char*, that is the one that is chosen.

Despite the fact that string literals are "constant" in that they usually are placed in read-only memory, their type is still just "char *" not "const char *." A string literal is not "implicitly const," it just happens to be unmodifiable on most platforms.

When C was first being designed, full memory protection wasn't common and so there was no way to force string literals to be unwritable. So it made no sense to make the type of a string literal be "const char *" because it defied reality. C++ inherited from C and so it inherited this quirk.

Actually, string literals do have the type of const char* in C++. However there is a deprecated feature that allows you to assign them to a regular char*.

I thought the reason literals were char* in C was that C didn't have const.

Quote:

---

Originally Posted by brewbuck

Despite the fact that string literals are "constant" in that they usually are placed in read-only memory, their type is still just "char *" not "const char *." A string literal is not "implicitly const," it just happens to be unmodifiable on most platforms.

When C was first being designed, full memory protection wasn't common and so there was no way to force string literals to be unwritable. So it made no sense to make the type of a string literal be "const char *" because it defied reality. C++ inherited from C and so it inherited this quirk.

---

Actually that's not completely true. The standard defines the type of a string literal as “array of n const char”. However the standard explicitly allows the conversion of string literal to "pointer to char".

it might seem inconsequential but it matters when you're specialising function templates (as opposed to overloading functions)

for example this code

Code:

---

#include <iostream>

template <typename T>
int f(T t)
{
        return 0;
}

template <>
int f<char *>(char *t)
{
        return 1;
}

template <>
int f<const char *>(const char *t)
{
        return 2;
}

int main()
{
        char *p = "test";
        std::cout << f(1);
        std::cout << f(p);
        std::cout << f("test2");
}

---

will print 012.

Quote:

---

Originally Posted by Daved

I thought the reason literals were char* in C was that C didn't have const.

---

K&R C might not have, but I'm pretty sure ANSI C has const. I could be wrong though.

Yes, ANSI C most definitely does have const.

Quote:

---

The following keywords have been added to the language:

const
enum
signed
void
volatile

---

From http://www.ericgiguere.com/articles/ansi-c-summary.html

That's the original ANSI C, not amendment 1.

So why aren't string literals const char* in C89?

Or are they?

Good question.

I'm fairly certain that in C89 at least string literals are of type const char*. This thread seems to support this: http://www.thescripts.com/forum/thread441942.html

But this says otherwise:

Quote:

---

C: The type of a narrow string literal is array of char and the type of a wide string literal is array of wchar_t.

C++: The type of a narrow string literal is array of const char and the type of a wide string literal is array of const wchar_t. Both types have static storage duration.

---

From http://publib.boulder.ibm.com/infoce...rc02stricn.htm