Assigning values to char arrays

[emyl]

Hi all,

here's an elementary question. Assume I have declared two variables,

char *a, **b;

I can then give a value to a like

a="hello world";

The question is, how should I assign values to b? A simple

b[0]="string";

results in a segmentation fault.

Answers greatly appreciated.

Regards, Emyl.

[Ben Bacarisse]

James Kuyper <ja*********@ve rizon.netwrites :

Ark Khasin wrote:
...

>Is it so that a consensus emerges that ^ | & on negative numbers
depend

I can't speak for the consensus; this is just my understanding of what
the standard says. In many cases my understanding differs distinctly
from the consensus understanding.

>on representation (or, to tell the truth, act on representations )
and so are implementation-defined (although only 3 ways to implement
are recognized)?

Those operators don't act on the representations of objects; otherwise
cases like

x += (a+1) | (b-2);

You have written a correct statement because, of course, a+1 is not an
object. The question is, does '(a+1) | (b-2)' depend (or act) on the
representation of 'a+1' and 'b-2' and I'd say it does.

Section 6.2.6 is called "Representation s of types" (not objects) and
6.2.6.1 p4 takes some pains to define a new term -- the "object
representation" -- which is not quite the same thing as the
representation of the type.

I don't want to suggest that | operates on padding bits. I don't
think one can determine that either way, but it seems to be pushing the
meaning of representation to its limits (and beyond that used in the
standard) to say that |, &, and ^ act on the value not the
representation.

would be undefined. The way that they operate on or generate negative
values must, however, be consistent with whichever of 3 permitted ways
of handling the sign bits that the implementation chose for the
relevant type.

These "permitted ways" are described in the section called
"Representa tion of types". Your sentence would be simpler if you had
said that the bits they operate on (and the meaning of the bits that
are produced) are determined by the representation used for signed
integer types.

It is possible to define the result of | on signed types by talking
only about the value of the operands, but it is complicated to do so
and the standard clearly distinguishes between the terms
"representation " and "object representation" so that there is simple
way to understand the operation. The standard uses only few words to
define | (and the others) because the term "correspond ing bits" is
clearly intended to refer back to the bits used to represent the
value as described in 6.2.6.

I see no way for those operators to operate on the
padding bits in any sense that is meaningful within the context of the
standard.

I agree, but padding bits are only one part of the representation of
the type.

--
Ben.

[James Kuyper]

Ben Bacarisse wrote:

James Kuyper <ja*********@ve rizon.netwrites :

....

>Those operators don't act on the representations of objects; otherwise
cases like

x += (a+1) | (b-2);

You have written a correct statement because, of course, a+1 is not an
object. The question is, does '(a+1) | (b-2)' depend (or act) on the
representation of 'a+1' and 'b-2' and I'd say it does.

Section 6.2.6 is called "Representation s of types" (not objects) and
6.2.6.1 p4 takes some pains to define a new term -- the "object
representation" -- which is not quite the same thing as the
representation of the type.

That is not clear to me. The standard defines what "object
representation" means, but it never defines what "representation " means.
As far as I can tell, the term "representation " is almost always used
in the standard as a short form for "object representation" . The
standard uses the term "value representation" exactly once, in
6.2.6.2p2, and oddly enough, while it is worded as a definition, it not
italicized as a definition should be. If it were an official definition,
from context it would appear to be defined only for unsigned types.

When the word "representation " is used without either "object" or
"value" preceding it, I found only a few cases where it was clear that
it was not a reference to the object representation; in every case, it
was also clear that it did not refer to the value representation.
Examples include such things as the representation of characters on the
display screen, or the representation of data in the output file. In
both of those cases, that only thing the standard says is that those are
details outside of its scope.

I'm not saying there's no instances where a lone "representation "
clearly refers to the value representation, where inserting the word
"object" before "representation " would clearly change the intended
meaning. There's too many instances for me to check reliably. However, I
didn't find any - do you know of any?

>would be undefined. The way that they operate on or generate negative
values must, however, be consistent with whichever of 3 permitted ways
of handling the sign bits that the implementation chose for the
relevant type.

These "permitted ways" are described in the section called
"Representa tion of types". Your sentence would be simpler if you had
said that the bits they operate on (and the meaning of the bits that
are produced) are determined by the representation used for signed
integer types.

Which is the way that the standard says the same thing. I don't think
there's a difference in meaning, just a difference in clarity.

....

and the standard clearly distinguishes between the terms
"representation " and "object representation" so that there is simple

Citation, please? The definition of "object representation" does not
clearly distinguish them.

[James Kuyper]

Ben Bacarisse wrote:
....

If section 6.2.6 was called "Object representation of types" so that
it was unambiguously about how values are stored and nothing else,
then I believe '-1 | -2' would be undefined. If values, not stored in
objects, do not have a representation, then what "bits" are there to
or together? It is because values may be represented as collections
of bits (as it happens in three different ways) that such expressions
can have a meaning defined by combining "correspond ing bits".

6.5p4 says "Some operators (the unary operator ~, and the binary
operators <<, >>, &, ^, and |, collectively described as bitwise
operators) are required to have operands that have integer type. These
operators yield values that depend on the internal representations of
integers, and have implementation-defined and undefined aspects for
signed types".

As I understand it, that statement about the "internal representations "
refers to the object representation, and does not imply that the
standard attaches any meaning to the representation of a value that is
not currently stored in any C object. It merely requires that the
bitwise operators act on values in such a way that if the resulting
value were saved in an object of that value's type, it would have the
correct bit pattern.

....

I have no other citation than the definition I already cited. I agree
the distinction is not crystal clear, but if your reading of the words
is that there is essentially no difference between "representation "
and "object representation" then how do you give '-1 | -2' a meaning?
You could, of course, say that | (and friends) behaves as if its
operands where stored in objects and the corresponding bits are
combined together, but you'd *still* be referencing the allowed
representations .

That's exactly how I understand it. I never denied that the allowed
representations were referenced, only that the concept of a
representation of a value only aquires a meaning in the event that it is
stored in an object.

[Ben Bacarisse]

James Kuyper <ja*********@ve rizon.netwrites :

Ben Bacarisse wrote:
...

>If section 6.2.6 was called "Object representation of types" so that
it was unambiguously about how values are stored and nothing else,
then I believe '-1 | -2' would be undefined. If values, not stored in
objects, do not have a representation, then what "bits" are there to
or together? It is because values may be represented as collections
of bits (as it happens in three different ways) that such expressions
can have a meaning defined by combining "correspond ing bits".

6.5p4 says "Some operators (the unary operator ~, and the binary
operators <<, >>, &, ^, and |, collectively described as bitwise
operators) are required to have operands that have integer type. These
operators yield values that depend on the internal representations of
integers, and have implementation-defined and undefined aspects for
signed types".

As I understand it, that statement about the "internal
representations " refers to the object representation, and does not
imply that the standard attaches any meaning to the representation of
a value that is not currently stored in any C object.

I can accept that this is the intent, but I do not think it is clear
and unambiguous. Since it can't be detected by a C program, I don't
really care if there is one representation (when a value is stored) or
another, transient one, as well. The latter just seemed to me a
convenient expository device for exactly these cases, but if it is a
fiction of my imagination, so be it!

It merely
requires that the bitwise operators act on values in such a way that
if the resulting value were saved in an object of that value's type,
it would have the correct bit pattern.

...

>I have no other citation than the definition I already cited. I agree
the distinction is not crystal clear, but if your reading of the words
is that there is essentially no difference between "representation "
and "object representation" then how do you give '-1 | -2' a meaning?
You could, of course, say that | (and friends) behaves as if its
operands where stored in objects and the corresponding bits are
combined together, but you'd *still* be referencing the allowed
representation s.

That's exactly how I understand it. I never denied that the allowed
representations were referenced,

Well that was exactly what I thought you were doing when you said:

"In general, the bitwise operations are defined in terms of their
actions on the values, not the representations ."

I just can't square this with your last remark above. For four of the
six, the representation is a required part of the definition.

only that the concept of a
representation of a value only aquires a meaning in the event that it
is stored in an object.

--
Ben.