Re: Global Variables
pramod wrote:
I don't know if this falls in this group or not but if someone
can answer it will be appreciated.
What's the difference between:
const char* pS1 = "abc"; and
This one defined a pointer, and initializes it with the address
of the first char of a nameless char const[4].
const char pS2[] = "abc";
This one defines an array of four characters, and initializes
them with 'a', 'b', 'c', '\0'.
Which one goes to which segment? I believe there's a storage
created for pS1 but not necessarily for pS2.
Both are definitions, so both create storage. Where the storage
is located depends on the implementation. In both cases, the
storage for the array *can* be allocated in write only store
(but isn't required to be). In the first case, the pointer
itself cannot be in write only store, because you're allowed to
modify it.
In the first case, the array has static lifetime; it must
persist until the end of program execution. So it cannot be on
the stack. In the second case, if pS2 is a local variable, it
almost certainly will be on the stack (and so not in write
protected memory).
Also pS1 goes into data segment whereas string "abc" goes into
the constant segment.
That would be a typical implementation if pS1 is a variable at
namespace scope.
Can there be any system in which data segment is missing?
What segments are present, and even if segments are present, is
an implementation detail. So I'm not sure what you mean by the
data segment being missing. An implementation must provide
read/write memory somewhere for objects with static lifetime;
whether it calls this a data segment, or even speaks in terms of
segments, is not defined by the language.
In that case, how will these two statements be treated?
All that is required is that the pointer in the first example
and the array in the second have the lifetime corresponding to
where the definition appears, and that the unnamed array in the
first example have static storage duration; i.e. that the memory
allocated to it remain allocated until the end of program
execution. In addition, the pointer in the first definition
must be writable.
How are the pS1 (or pS2) symbols transformed in binary?
Symbols aren't transformed into binary. How the defined objects
are transformed into binary is very implementation dependant,
but the results must be the same as if in the first example,
there is a pointer to the first byte of an array, and the array,
and in the second, as if there is an array.
Are they offsets from the program base?
What does that mean?
Is there any exception to this?
Exception to whay?
When should one be preferred over the other?
If you want pointer semantics, you use the pointer. If you want
array semantics, you use the array.
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]