strings to pointers

[COBOL2C++]

I have setup a new class and in that new class I have a private pointer. I need to make that private pointer point to a string, let's say "Good Luck". My compiler doesn't allow me to code my private pointer like this

char *message = "Good Luck";

So I use

char *message;

instead. Then in my constructor I am trying to set my private pointer, called message, to "Good Luck" and have not been able to get it to work.

Is this possible? If so can anybody help.

Thanks,

[FillYourBrain]

class Test
     {
     public:
          Test() : message("Good Luck")
               {
               std::cout << message << std::endl;
               }
     private:
          const char
               *message;
     };

int main(void)
     {
     Test test;
     return 0;
     }

Putting it on the constructor like that is what we call the initializer list.

[COBOL2C++]

That worked.

Thank you

[darksaidin]

Do you understand it ?

[Dante Shamest]

Out of curiousity, where is the string "Good Luck" stored? Does it last as long as the object exists?

[FillYourBrain]

it is const, much the same way as if you did a global:

char *GlobalString = "Hello There";

[Dante Shamest]

So just to confirm, do all string literals last throughout the lifetime of a program?

[Wick]

I thought you had to use addresses, like:

char* stringPtr;
stringPtr = &"Hello There";

or

char hThere[12] = "Hello There";
char* stringPtr;
stringPtr = &hThere;

[FillYourBrain]

Originally posted by Dante Shamest
So just to confirm, do all string literals last throughout the lifetime of a program?

hardcoded things are basically part of the program and thus are there for the entire time the code is loaded.

[grib]

All string literals last throughout the lifetime of the program. Furthermore duplicates may or may not be "folded" such that only one copy of the string exists. In addition they generally live in a section of memory known in technical circles as the "fiddly bits" such that writing to them invokes dark and mystirous forces. Frequently they live in the code/text segment, same as the instructions, unless you would find this desireable for any reason, whereupon the compiler will figure out a way to make them live on the stack.

The relationship between
char *s1 = "Hello";
char s2[] = "Hello";
char *s3 = s2;
can be confusing. s2 looks like an address of elements of type char. That is, it is a value sutable for a pointer of type char*. Much the same way as 7 is a value suitable for assignment to an int. Same deal with "Hello" it looks like an address to your program. &s2 is the location where s2 lives, it's just redundant and is a value of type address of chars. &s1 is a totally different beast and is the address where the pointer s1 lives and is a value of type pointer to char. There is no s2 pointer, it's a symbol for your convenence. There may or may not be another location in your program that contains the "Hello" literal information that is copied to the six chars at location s2. &"Hello" makes my head hurt but my guess is that it is the same deal as &s2.