strcmp confusion - c++

Question

To my knowledge the standard strcmp function looks something like this:
int strcmp(const char* string1, const char* string2)
{
while(*pString1++ == *pString2++)
{
if(*pString1 == 0) return 0;
}
return *pString1 - pString2;
}
My question is that wouldn't this increment the pointers passed into strcmp? In the following example it seems like it would trash the pointers and cause invalid stuff to happen.
const char* string1 = "blah";
const char* string2 = "blah";
const char* string3 = "blah";
if(strcmp(string1, string2) {doSomething();}
// Won't this make string1 = "" because it incremented the pointer to the end?
else if (strcmp(string1, string3) {doSomethingElse();}
Sorry I'm just confused because it seems like if I pass a pointer into strcmp, I shouldn't expect that pointer to suddenly hold an empty string. It seems like strcmp should take const char* const. Am I totally misunderstanding something?

Answer 1

Your misunderstanding is this: Arguments are passed by value (copy), but you seem to think they are passed by reference.
You could get your expected behaviour by declaring the parameters to strcmp as references, like this:
int strcmp(const char*& string1, const char*& string2)

Answer 2

No, the pointers string1 and string2 are local to the function (passed by value). Any changes made to them are not visible to the caller.

Answer 3

The pointer itself is passed by value, so although it's a pointer to something, changing it does change the local declaration only.
To be able to modify the pointer itself from the inner scope of the function you would need to have a pointer to pointer to char.

Answer 4

The pointers are passed by value, strcmp is using copies of the ones you send in, so the original ones aren't touched.

Answer 5

First, the classical obfuscated implementation of strcmp is even
simpler:
int
strcmp(char const* s1, char const* s2)
{
while ( *s1 ++ == *s2 ++ )
;
return *s1 - *s2;
}
(I would hope that no one would actually write code like this in
practice.)
As for your actual question: C++ (and C, since this is really a C
question) pass arguments by value, so any pointer that strcmp gets is
a copy; it can't possibly modify any of the pointers in the calling
code. All making the parameters char const* const would mean is that
strcmp couldn't modify its local copies of the pointers.

Answer 6

C++ passed parameters to functions "by value". Consider this code:
void f(int i) { i = 7; }
...
int j = 0;
f(j);
assert(j == 0);
The variable j is unrelated to the variable i. Indeed, i local to the function f. It is initialized with a copy of of j. Changes to i are never communicated to j.
Now consider this code:
void f(char *i) { i = i + 1; }
...
char *j = "Hello";
f(j);
assert(*j == 'H');
Similarly, i is initialized with a copy of j. Changes to i are never communicated back to j.
Note: One can force parameters to be initialized "by reference" thusly:
void f(int& i) { i = 7; }
...
int j = 3;
f(j);
assert(j==7);
In this case, rather than being initialized with a copy of j, i is bound to a j. But this only applies if you have & in the declaration.

Answer 7

Try this, your will find that they are totally different pointer.
What cause you misunderstand is that they point to the same area
#include <iostream>
using namespace std;
int strcmp2(char const *s1, char const *s2)
{
cout << "In strcmp" << endl;
cout << &s1 << " " << &s2 << endl;
cout << endl;
}
int main()
{
char a[100];
char b[100];
cout << "In main function" << endl;
cout << &a << " " << &b << endl;
cout << endl;
strcmp2(a, b);
}