const char* = new char[6]

[S S]

Hi Everyone

I have

const char *p = "Hello";

So, here memory is not allocated by C++ compiler for p and hence I
cannot access p[0] to modify the contents to "Kello"
p[0] = 'K'; // error at runtime

So I did

const char *p = new char[6];

But then how do I initialize it to "Hello"? My requirement is - I want
a const char* initialised and later want to modify the contents.

I know a way as written below

const char p[] = "hello";
const_cast<char &>(p[0]) = 'K'; //OK

But how to acheive this with pointers?

What I know is - C compiler allocates memory when I do
const char* = "hello";

But C++ compiler does not do that. Any help is welcome.

Thanks
SS

[Frederick Gotham]

benben posted:

>I am sorry, please read my first line as
char * p = "hello";

Try not to do that. A string literal is of type const char*.

Incorrect. The type of "Hello" is: char[sizeof"Hello"]

It is an array, not a pointer.

If you want to modify, why put up with const in the first place?

Either do

char p[] = {'h', 'e', 'l', 'l', 'o', 0};
p[0] = 'K'; // OK

or

char* p = new char[6];

I would advocate defining "p" as const, because we don't want its value to
change until we call "delete".

char *const p = new char[6];

--

Frederick Gotham

[Frederick Gotham]

Frederick Gotham posted:

char str[] = "Hello";

Don't be fooled by the syntax -- the thing on the left is NOT a string
literal

Should have written "thing on the right", not left.

--

Frederick Gotham

[Rolf Magnus]

S S wrote:

But then how do I initialize it to "Hello"? My requirement is - I want
a const char* initialised and later want to modify the contents.

I know a way as written below

const char p[] = "hello";
const_cast<char &>(p[0]) = 'K'; //OK

That's not OK, that's very bad. If the program appeared to work, it's
only because you were unlucky. If you use const_cast to modify
something that is actually const then you get Undefined Behaviour
(which seems to be considered one of the 4 horsemen of the apocalypse
around these parts). In any case, don't do it.

I think you are wrong here, when you see sizeof(p) here you will see
the size of string which means memory is allocated here and can always
be modified.

Your deduction is wrong. It's true that the literal gets copied over to the
array p, and so the above code doesn't write to the literal, but you
defined the array as const, and modifying an object that was initially
defined const results in undefined behavior.

IF I can not use const_cast which is actually const then what is purpose
of const_cast then.

It's often used to deal with erroneous code that wants a pointer or
reference to an object and doesn't modify it, but fails to declare it
const.

[Rolf Magnus]

Frederick Gotham wrote:

benben posted:

>>I am sorry, please read my first line as
char * p = "hello";

Try not to do that. A string literal is of type const char*.

Incorrect. The type of "Hello" is: char[sizeof"Hello"]

That's incorrect too. "Hello" is const.

[Frederick Gotham]

Rolf Magnus posted:

>Incorrect. The type of "Hello" is: char[sizeof"Hello"]

That's incorrect too. "Hello" is const.

Incorrect. Your compiler is non-conforming if it refuses to compile the
following when in International Standard C++ mode:

void Func(char*){}

int main() { Func("Hello"); }

You would be correct to think that the altering of a string literal produces
undefined behaviour, but nonetheless, string literals are not const.

--

Frederick Gotham

[Andrew Koenig]

"S S" <sa***********@ gmail.comwrote in message
news:11******** *************@m 73g2000cwd.goog legroups.com...

So I did

const char *p = new char[6];

But then how do I initialize it to "Hello"? My requirement is - I want
a const char* initialised and later want to modify the contents.

The right way to this is:

char* q = new char[6];
const char* p = q;

When you want to modify the contents of the memory, use q.

[Rolf Magnus]

Frederick Gotham wrote:

Rolf Magnus posted:

>>Incorrect. The type of "Hello" is: char[sizeof"Hello"]

That's incorrect too. "Hello" is const.

Incorrect.

No, it's not.

Your compiler is non-conforming if it refuses to compile the
following when in International Standard C++ mode:

void Func(char*){}

int main() { Func("Hello"); }

That's right, but for another reason. For backwards compatiblilty with C, an
implicit conversion of a string literal to char* is allowed.

You would be correct to think that the altering of a string literal
produces undefined behaviour, but nonetheless, string literals are not
const.

I'll answer that with a quote from the standard:

2.13.4 String literals

[...]
An ordinary string literal has type “array of n const char� and static
storage duration (3.7), where n is the size of the string as defined
below, and is initialized with the given characters.

[S S]

Frederick Gotham wrote:

S S posted:

I am sorry, please read my first line as
char * p = "hello";
in my previous mail

Extremely il-advised. You're storing the address of non-modifiable data in a
pointer to non-const.

But I am able to get the desired result by the following way , but I am
amazed how it has worked?

const char* ptrc = new char[6];

Here you store the address of non-const data in a pointer to const. Be
consistent! Either use:

char const *const p = new char const[6];

or:

char *const p = new char[6];

Thanks for above piece of advise.

memcpy(const_ca st<char*>(ptrc) ,"hello",6);

This behaviour of this statement is well-defined, as it does not modify const
data.

Yes, but it would have been undefined if I would have written
char const *p = new char const[6]; //here , let p be non const pointer
, here I satisfy the condition, lhs and rhs are consistent

>

//memcpy((char*)p trc,"hello",6); // this also works

Yes, this is equivalent.

printf("%s\n",p trc); // hello

You're mixing C and C++ all over the place! If you're hell-bent on using C
functions in C++ code, you must change:

#include <stdio.h>

printf(...

to:

#include <cstdio>

std::printf(...

const_cast<char &>(ptrc[0]) = 'K'; //Kello

Again, the behaviour is well-defined because the data is ours to modify.

My question is "How I am able to modify the constness of memory by
using 2nd statement which actually is supposed to remove the constness
of pointers only???

Your question is flawed. The following denotes a const pointer:

char *const p;

The following two denote a pointer to const:

char const *p;
const char *p;

The following two denote a const pointer to const:

char const *const p;
const char *const p;

A "const_cast " can be used to strip away either of the constnesses (i.e.
whether the pointer itself is const, or whether the data it points to may be
modified by the pointer in question.)

Thanks again. Can you please give 2 syntaxes in the given context where
we strip away constness
1- for pointer itself is const
2- data is const
3- both
I want to know what you have in mind when you say const_cast can be
used to remove both constness.
Thanks in advance

>

Is my compiler wrong?

You'll get your head around all this soon enough. Keep asking questions until
you're absolutely certain you know what's going on -- that's what sets the
good programmers from the great programmers.

--

Frederick Gotham

[S S]

Frederick Gotham wrote:

Rolf Magnus posted:

Incorrect. The type of "Hello" is: char[sizeof"Hello"]

That's incorrect too. "Hello" is const.

Incorrect. Your compiler is non-conforming if it refuses to compile the
following when in International Standard C++ mode:

void Func(char*){}

int main() { Func("Hello"); }

Incorrect, type of "hello" is const char[]
that can be confirmed when you overload the function
void func(char* str); //1st fxn
void func(const char* str); //2nd fxn
func("hello"); // calls the 2nd fxn

>
You would be correct to think that the altering of a string literal produces
undefined behaviour, but nonetheless, string literals are not const.

--

Frederick Gotham

[Frederick Gotham]

Rolf Magnus posted:

>You would be correct to think that the altering of a string literal
produces undefined behaviour, but nonetheless, string literals are not
const.

I'll answer that with a quote from the standard:

2.13.4 String literals

[...]
An ordinary string literal has type “array of n const char� and
static storage duration (3.7), where n is the size of the string as
defined below, and is initialized with the given characters.

I stand corrected.

void Func(char (&str)[6]) {}

int main()
{
Func("Hello"); /* Compile ERROR */
}

--

Frederick Gotham