char* and char

[Ying Yang]

Hi,

whats the difference between:

char* a = new char;

char* b = new char[10];

char c [10];
Regards
BN

[Default User]

Kevin Goodsell wrote:

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.

I wasn't either, so I hedged my bets :)

I'm not as strong on templates as I should be, I wasn't sure if you
could instantiate with array types or not. They'd be tricky, because any
resulting variables in a class would not be modifiable lvalues and all
that.

Brian Rodenborn

[White Wolf]

Default User wrote:

I wasn't either, so I hedged my bets :)

I'm not as strong on templates as I should be, I wasn't sure if you
could instantiate with array types or not. They'd be tricky, because
any resulting variables in a class would not be modifiable lvalues
and all that.

Really? How come? What do you mean by that?

--
WW aka Attila

[David White]

Kevin Goodsell <us************ *********@never box.com> wrote in message
news:DK******** *********@newsr ead4.news.pas.e arthlink.net...

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*.

Perhaps this is a bit too strong. It's liable to cause some people to think
of an array more as a pointer than as an array.

What about
char ch = c[i];
?
Is this using 'c' as an array or a pointer? The result is the same whether
'c' is an array or a pointer, but I'd prefer to think of the pointer case as
behaving like an array than the array case behaving like a pointer.

What happens to the array here?
struct S
{
char c[10];
};

void f(S &s1, S &s2)
{
s1 = s2;
}

There's no pointer behaviour in this case.

I think it's better to list the cases where one type decays to another than
to list the exceptions.

DW

[White Wolf]

David White wrote:

Perhaps this is a bit too strong. It's liable to cause some people to
think of an array more as a pointer than as an array.

What about
char ch = c[i];
?
Is this using 'c' as an array or a pointer?
Pointer.
The result is the same
whether 'c' is an array or a pointer, but I'd prefer to think of the
pointer case as behaving like an array than the array case behaving
like a pointer.
There is no array arithmetics in C++, but there is pointer arithmetics.
What happens to the array here?
Here you do not use the array.
struct S
{
char c[10];
};

void f(S &s1, S &s2)
{
s1 = s2;
}

There's no pointer behaviour in this case.
Because you do not use the name of the array.
I think it's better to list the cases where one type decays to
another than to list the exceptions.

Except if the exceptions are way less.

BTW if you do not believe me that in you example case above "c" indeed
decayed to a pointer try the following:

// Warning1 Untested code typed with flue and migrene
#include <iostream>
typedef int not_void_ever;

not_void_ever main() {
char const gree_thing[] = "Hello world!";
std::cout << "char 6: " << 6[gree_thing] << std::endl;
}

Compile it. It will. Run it. It will and it will print "char 5: w".

Why? Because 6 is an array? Nope. But because gree_thing decays into a
pointer to the first element of the character array. And then what we have
is:

something[something]

which translates to

*(something+som ething)

in our case

*(6+gree_thing)

--
WW aka Attila

[Kevin Goodsell]

Default User wrote:

Kevin Goodsell wrote:

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.
I wasn't either, so I hedged my bets :)

I'm not as strong on templates as I should be,

It seems like few people are. I know I'm not. It's a complicated topic.
I wasn't sure if you
could instantiate with array types or not. They'd be tricky, because any
resulting variables in a class would not be modifiable lvalues and all
that.

I'm not sure how it would work either, outside of things like this:

template<class T, size_t N>
void foo(T (&array)[N])
{
}

I'm not sure if this counts or not (it's what I thought of when I read
Attila's message, but maybe he was talking about something else). But I
think it points to another situation where arrays don't decay to
pointers - binding to a reference:

int a[20];
int (&r)[20] = a;

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

[Kevin Goodsell]

David White wrote:

Perhaps this is a bit too strong. It's liable to cause some people to think
of an array more as a pointer than as an array.

What about
char ch = c[i];
?
Is this using 'c' as an array or a pointer?
A pointer, of course.

What happens to the array here?
struct S
{
char c[10];
};

void f(S &s1, S &s2)
{
s1 = s2;
}

The conversion applies when the array is referred to by name. It's often
stated something like "The name of an array becomes a pointer to the
first element of the array in most case. The exceptions are..."
I think it's better to list the cases where one type decays to another than
to list the exceptions.

But there are far more cases where it becomes a pointer - that's the
norm. I doubt I could list them all. In C there are only the 2 cases
where it doesn't. We're still discussing what additional cases are added
in C++.

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

[David White]

White Wolf <wo***@freemail .hu> wrote in message
news:bk******** **@phys-news1.kolumbus. fi...

David White wrote:

Perhaps this is a bit too strong. It's liable to cause some people to
think of an array more as a pointer than as an array.

What about
char ch = c[i];
?
Is this using 'c' as an array or a pointer?
Pointer.

The result is the same
whether 'c' is an array or a pointer, but I'd prefer to think of the
pointer case as behaving like an array than the array case behaving
like a pointer.

There is no array arithmetics in C++, but there is pointer arithmetics.

What happens to the array here?

Here you do not use the array.

Yes I do, implicitly.

struct S
{
char c[10];
};

void f(S &s1, S &s2)
{
s1 = s2;
}

There's no pointer behaviour in this case.

Because you do not use the name of the array.

Does it really matter? The array is being used in the code above, and not
like a pointer. The contents of s1.c are replaced.

I think it's better to list the cases where one type decays to
another than to list the exceptions.

Except if the exceptions are way less.

BTW if you do not believe me that in you example case above "c" indeed
decayed to a pointer try the following:

// Warning1 Untested code typed with flue and migrene
#include <iostream>
typedef int not_void_ever;

not_void_ever main() {
char const gree_thing[] = "Hello world!";
std::cout << "char 6: " << 6[gree_thing] << std::endl;
}

Compile it. It will. Run it. It will and it will print "char 5: w".

Why? Because 6 is an array? Nope. But because gree_thing decays into a
pointer to the first element of the character array. And then what we

have is:

something[something]

which translates to

*(something+som ething)

in our case

*(6+gree_thing)

So, an array, unlike a pointer, contains no address and some number of
actual characters, yet we are to think of it as an address and no
characters. And a pointer, which contains just an address and no characters,
we are to think of as an array of characters (for the purposes of array[i]
anyway). It's not surprising that newbies have to ask lots of questions
here.

Nothing above surprises me, though I'd forgotten the quirky reversal of
array and index that I now remember seeing years ago, but for practical
purposes I'll stick to thinking of an array as an array and a pointer as a
pointer. Below is one reason why:

char c[10];
char d[10];
char *p = &c[0];
char *q = &d[0];

p = q; // okay
p = d; // okay
c = d; // error

This is another exception.

DW

[David White]

Kevin Goodsell <us************ *********@never box.com> wrote in message
news:bg******** *********@newsr ead4.news.pas.e arthlink.net...

David White wrote:
The conversion applies when the array is referred to by name. It's often
stated something like "The name of an array becomes a pointer to the
first element of the array in most case. The exceptions are..."

I would think that people, newbies in particular, are interested in all the
differences betweeen pointers and arrays, not just those where the name is
used. I can see no good reason to single out uses of the name alone.

I think it's better to list the cases where one type decays to another than to list the exceptions.

But there are far more cases where it becomes a pointer - that's the
norm. I doubt I could list them all. In C there are only the 2 cases
where it doesn't. We're still discussing what additional cases are added
in C++.

If you list the exceptions and you miss one, the statement "An array is
treated as a pointer except..." becomes a false statement. But if you say,
"An array decays to a pointer where a pointer is expected," you at least
aren't making a false statement if there are other cases as well. So far the
exceptions in C++ are:
sizeof, address of, template parameter, default assignment of structs and
classes, and that an array is not an l-value.

That's quite a few, and are we certain there aren't more?

DW

[White Wolf]

David White wrote:

What happens to the array here?
Here you do not use the array.

Yes I do, implicitly.

No, you are not. Using the array in this context (decaying) means using the
arrays name. It is not the array which decays, it is name.

Because you do not use the name of the array.

Does it really matter?

Yes it does. It is nto the array decaying into a pointer: its name does.
So, an array, unlike a pointer, contains no address and some number of
actual characters, yet we are to think of it as an address and no
characters.
No. We are talking about array *names* and not arrays.
And a pointer, which contains just an address and no
characters, we are to think of as an array of characters (for the
purposes of array[i] anyway). It's not surprising that newbies have
to ask lots of questions here.
Nope. Array *names* behave like pointers to the arrays first element - most
of the cases. Pointers _never_ behave like arrays.
Nothing above surprises me, though I'd forgotten the quirky reversal
of array and index that I now remember seeing years ago, but for
practical purposes I'll stick to thinking of an array as an array and
a pointer as a pointer.

No one asked you to stop think about an array as an array and a pointer as a
pointer. But please also think about the _name_ of the array as one which ,
in certain contexts, can decay into naming a pointer rvalue. Not ever as an
lvalue as you example tried to show.

--
WW aka Attila

[White Wolf]

David White wrote:

I would think that people, newbies in particular, are interested in
all the differences betweeen pointers and arrays, not just those
where the name is used. I can see no good reason to single out uses
of the name alone.
You mean that we should not mention one very important rule of the language
just because at first sight it differs from other languages?
If you list the exceptions and you miss one, the statement "An array
is treated as a pointer except..." becomes a false statement.
It is _always_ a false statement. And array is *never* treated as a
pointer. The *name* of the array *variable* can behave as or decay into a
pointer.
But if
you say, "An array decays to a pointer where a pointer is expected,"
you at least aren't making a false statement
You are. The array never decays into anything.

T foo[S];

Suppose the above is an array declaration. The array is a variable. It has
an object part (the associated continuous region of storage) and a name
part, which we use to refer to that storage and a type part, which tells
what is in that storage, how big that storage is etc.

The array is the object (the storage) with its type. The word foo is the
name of the variable. We use the name of the variable to refer to the
storage. Now in some cases, foo refers to that storage as a pointer to its
first element, while in another cases it represent the whole storage with
all the elements in it.
So far the exceptions in C++ are:
sizeof, address of, template parameter,
Yes.
default assignment of structs
and classes,
No. In the default assignment of classes the _name_ of the array is not
used.
and that an array is not an l-value.
That's quite a few, and are we certain there aren't more?

The standard lists those.

--
WW aka Attila