Ytukyg

Here's another 'reinventing-the-wheel' problem we were given in our Introduction to C++ classes:

Write a function that returns the position of the first occurrence of
a sequence of characters in a string, i.e. a variation of the strstr
function.

I started writing the function as follows:

int strstr2(const char *text, const char *pattern) {

    int pos = 0;

    char *temp;

    temp = text;

}

I thought I'd remember the address of the first character of the string for future use within the function, but the compiler said:

A value of type "const char*" cannot be assigned to an entity of type "char*".

I know that one cannot change a constant once it has been initialized, but why am I not able to assign a pointer to a constant char to another non-constant pointer?

I read several questions referring to pointers and constants, and it seems the bottom of the accepted answer to this post might answer my question, but I'm not a hundred percent sure, as the discussion is still at too advanced a level for me.

My second question is, what is the workaround? How can I define a pointer pointing at the beginning of the string?

Thanks.

This has to do with const-correctness. const char *text means text is a pointer to a constant char. That means if you try to do something like

*text = 'a'

The compiler will issue an error since you are trying to modify a const object. If you could do

char *temp;

temp = text;

then you could do

*temp = 'a'

and there would be no error, even though you just modified a const object. This is why C++ requires you to use const_cast if you actually want to cast away const (there are a few use cases for this but they are by far not what you normally want to do).

^{Danger, there be dragons below. Be very, very careful if you decide to use const_cast}

Lets say you have to deal with an old API call that only takes a char*, but it guarantees it wont modify, then you could use something like

int wrap_api(const char *text)

{

    return api_call(const_cast<char*>(text));

}

and this will be "okay" since api_call guarantees it wont modify the string. If on the other hand api_call could modify then this would only be legal if what text points to isn't actually const like

char foo = "test"

wrap_api(foo);

would be legal if foo gets modified but

const char foo* = "test"

wrap_api(foo);

would not be legal if foo gets modified and is undefined behavior.

If the assignment would be allowed, you would be able to legally write:

*temp = 'x'; // write to char* is legal in general

But that would be bad in this case because you'd be writing to a constant.

The standard could have said that the temp = text assignment is legal and the *text = 'x' is undefined behavior, but that wouldn't make sense because the only difference between T* and const T* is whether you can write to it.

So it is only logical that C++ disallows assigning a T* type the value of a const T* type to save you from later doing something bad, and instead forces you to use const char* temp; temp = text; in this case.

This is a part of const-correctness type safety. Since text is a pointer to const char, you can't modify the characters it points to through it. This is a good thing and a safety measure.

However, the whole safety would be invalidated if it would be allowed to assign a pointer to non-const character to it! Because than you would modify the character through said pointer and bypass the safety!

Because of that, this assignment is not allowed. To fix it, mark your temp as pointer to const char as well: const char* temp.