Re: char table / pointer memory allocation
On 12 mai, 08:58, Paavo Helde <nob...@ebi.ee> wrote:
James Kanze <james.ka...@gmail.com> wrote in news:9b653ea1-eadb-464e-
abc7-11c9ee293...@8g2000hse.googlegroups.com:
On May 7, 9:47 pm, Paavo Helde <nob...@ebi.ee> wrote:
meh...@gmail.com wrote in news:b1ee3325-348a-41ec-88bd-d3aea0a2c784
@f36g2000hsa.googlegroups.com:
Besides, I recommend to get familiar with std::string and
forget the string lifetime issues forever.
I can't let that pass. The only times I use C style strings is
when lifetime is an issue; a static char[] with a constant
initializer is static initialized, and effectively has an
infinite lifetime.
And not much of use in a multithreaded application
(presumably, char[] array is used for changing the content,
otherwise one should just use string literals).
A string literal is a char[]. (OK, a char const[].) But the
char[] will often occur in structures. A char const* is more
usual, but there are exceptions. (And of course, the char
const* points to a char const[], usually a string literal.)
Any global mutable object will create problems in
multithreaded environment (and if you are writing a library
you don't know if it is going to be used in singlethreaded or
multithreaded fashion).
That depends on the library, and the targetted users. I know
that the ones I work on professionally will be used in a
multithreaded environment, since they create threads themselves.
A static char[] has to be externally locked by each access.
This should better be encapsulated in a class managing this
string - and voila, we are back to the statics initialization
order problem. One needs singleton pattern or something
similar here. And in a singleton one could easily use
std::string as well.
A static std::string can easily be accessed before it is
constructed, or after it is destructed.
Yes, avoid namespace-level statics, these are evil ;-) (no pun
intended!).
Local statics aren't necessarily any better. In fact, they can
be worse, since they aren't necessarily constructed before main.
In the end, the surest bet is statically initialized constant
values. They're guaranteed to be initialized before any code
actually runs. Thus, for example, I'll often use a statically
initialized struct Something const [] and std::find_if, rather
than std::map, because it is 100% free of order of
initialization issues.
Note also that a static char[] array is of limited size.
Yes, but the compiler will define the size in accordance with
the initializer.
The size should be checked explicitly by every mutating
operation, which does not sound very reliable. I would argue
this solution has problems even in single- threaded code.
Nobody suggested using char[] for mutable objects.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34