char* and char

[Ying Yang]

Hi,

whats the difference between:

char* a = new char;

char* b = new char[10];

char c [10];
Regards
BN

[David White]

"Ying Yang" <Yi******@hotma il.com> wrote in message
news:3f******** @news.iprimus.c om.au...

Hi,

whats the difference between:

char* a = new char;

char* b = new char[10];
'a' and 'b' are both pointers to a char. That is, they each contain the
address in memory of a char. In the case of 'b', there happens to be another
9 chars after the first one, but it is up to the programmer to be aware of
that (including using "delete[]" for 'b' and just "delete" for 'a' later
when you delete them). Once created, the compiler treats both pointers the
same.
char c [10];

'c' is an array of 10 chars. If you use 'c' where a char * is expected, the
compiler will create the char * by taking the address of the first char in
the array. But 'c' itself is an array, not a pointer, so it is a different
type from 'a' and 'b'.

DW

[Attila Feher]

Ying Yang wrote:

Hi,

whats the difference between:

char* a = new char;
"a" is a pointer to a character, initialized by the expression new char.
The expression new char allocates memory for one character from the free
store and (according to the current wording of the standard) initialized it
by doing nothing. So "a" will point at that "random" character in the free
store (sometimes called heap).

If new char cannot allocate memory for one object of type char it will throw
an std::bad_alloc exception, which will be either caught by an appropriate
ctach-handler or will cause the system to call a function named terminate(),
which will by default call a function named abort() and that one will stop
the programs' execution.
char* b = new char[10];
"b" is a pointer to a character, initialized by the expression new char[10].
The expression new char[10] allocates a block of continuous memory for 10
character from the free store and (according to the current wording of the
standard) initialized it by doing nothing. After initialization "b" will
point at the first of those 10 "random" characters in the free store
(sometimes called heap).

Rest is the same as before.
char c [10];

This one can be many things. So let's skip initialization and meaning
(because it can be namespace scope or automatic or member declaration) and
let's just go for the type.

"c" is an array of 10 characters. This means that it has the type: array of
10 characters. When using "c" in certain expressions it will (so-called)
decay into a pointer to the first element of that array. In such a case it
will behave much like "b" before, except that the memory area belonging to
"c" is not necessarily from the free-store:

c[2]; // third element of c
b[2]; // third element of b

It is important to note that while many many times "c" will behave as a
pointer to the first element of the array it represents, it is not one. It
just can behave as one (in certain expressions) for our convenience.

--
Attila aka WW

[Karl Heinz Buchegger]

Ying Yang wrote:

Hi,

whats the difference between:

char* a = new char;
a
+-------+ +---+
| o------------------>| |
+-------+ +---+
char* b = new char[10];

b
+-------+ +---+---+---+---+---+---+---+---+---+---+
| o------------------>| | | | | | | | | | |
+-------+ +---+---+---+---+---+---+---+---+---+---+
char c [10];

c
+---+---+---+---+---+---+---+---+---+---+
| | | | | | | | | | |
+---+---+---+---+---+---+---+---+---+---+

HTH

--
Karl Heinz Buchegger
kb******@gascad .at

[Default User]

David White wrote:

'c' is an array of 10 chars. If you use 'c' where a char * is expected, the
compiler will create the char * by taking the address of the first char in
the array.

Except for a few well-documented cases, such as when used with the
sizeof and address-of (&) operators.


Brian Rodenborn

[David White]

"Default User" <fi********@com pany.com> wrote in message
news:3F******** *******@company .com...

David White wrote:

'c' is an array of 10 chars. If you use 'c' where a char * is expected, the compiler will create the char * by taking the address of the first char in the array.

Except for a few well-documented cases, such as when used with the
sizeof and address-of (&) operators.

But neither of these cases is using 'c' where a char * is expected, is it?

DW

[Kevin Goodsell]

David White wrote:

'c' is an array of 10 chars. If you use 'c' where a char * is expected, the
compiler will create the char * by taking the address of the first char in
the array.

A stronger statement is called for here. If you use 'c' for any purpose
other than as the operand for the address-of or sizeof operator, the
compiler will convert it to char*. It does not have to occur in a
context that calls for a char*.

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[White Wolf]

Kevin Goodsell wrote:

David White wrote:

'c' is an array of 10 chars. If you use 'c' where a char * is
expected, the compiler will create the char * by taking the address
of the first char in the array.

A stronger statement is called for here. If you use 'c' for any
purpose other than as the operand for the address-of or sizeof
operator, the compiler will convert it to char*. It does not have to
occur in a
context that calls for a char*.

Not exactly. Template argument deduction will not (AFAIK) decay it into a
pointer.

--
WW aka Attila

[Kevin Goodsell]

White Wolf wrote:

Not exactly. Template argument deduction will not (AFAIK) decay it into a
pointer.

Good point. In C what I said holds true, but I was never very sure if
C++ added other contexts where the "decay to pointer" would be bypassed.
No one bothered to point this out until now, and it simply never
occurred to me.

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[Default User]

David White wrote:

"Default User" <fi********@com pany.com> wrote in message
news:3F******** *******@company .com...

David White wrote:

'c' is an array of 10 chars. If you use 'c' where a char * is expected, the compiler will create the char * by taking the address of the first char in the array.

Except for a few well-documented cases, such as when used with the
sizeof and address-of (&) operators.

But neither of these cases is using 'c' where a char * is expected, is it?

I'm pointing out the cases where no conversion takes place. Many people
are unaware of these exceptions, you'll often see the phrase, "the name
of the array is a pointer to the first element". Naturally, the
operators mentioned take any type.

Brian Rodenborn