pointer array problem

[termin]

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

[DevarajA]

termin ha scritto:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because arr is already declared as a char* array and the name of an
array becomes a const pointer to the first element of the array. So it
can't be modified to point to other locations.

--
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[Chris Dollin]

termin wrote:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because `arr` is an array, and you can't assign to an
entire array - only to elements of one.

--
Chris "electric hedgehog" Dollin
It's called *extreme* programming, not *stupid* programming.

[Chris Dollin]

DevarajA wrote:

termin ha scritto:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because arr is already declared as a char* array and the name of an
array becomes a const pointer to the first element of the array.

No, /it does not/.

The types are different, as seventeen seconds with `sizeof`
and your favourite compiler - and other experiments - will
support.

--
Chris "electric hedgehog" Dollin
It's called *extreme* programming, not *stupid* programming.

[DevarajA]

Chris Dollin ha scritto:

DevarajA wrote:

termin ha scritto:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because arr is already declared as a char* array and the name of an
array becomes a const pointer to the first element of the array.

No, /it does not/.

The types are different, as seventeen seconds with `sizeof`
and your favourite compiler - and other experiments - will
support.

It doesnt when you use sizeof, initialize with a string literal or use
operator &. In other cases it does. Anyway you're right, it would have
been better to say "it acts like a pointer".

--
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[Chris Dollin]

DevarajA wrote:

Chris Dollin ha scritto:

DevarajA wrote:

termin ha scritto:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because arr is already declared as a char* array and the name of an
array becomes a const pointer to the first element of the array.

No, /it does not/.

The types are different, as seventeen seconds with `sizeof`
and your favourite compiler - and other experiments - will
support.

It doesnt when you use sizeof, initialize with a string literal or use
operator &. In other cases it does. Anyway you're right, it would have
been better to say "it acts like a pointer".

No, it would have been better to say that it's an array, and
arrays aren't assignable in C.

Pretending it's a pointer only defers the pain, and gives it
a chance to grow.

--
Chris "electric hedgehog" Dollin
It's called *extreme* programming, not *stupid* programming.

[John Bode]

termin wrote:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because arr is a 5-element array of pointer to char, not a pointer to a
5-element array of char, and you cannot write to an array object. If
your intent was to create an array of 5 20-character strings, the
general procedure is

#include <stdlib.h>
#include <string.h>

int main(void)
{
char *arr[5];
int i;

for (i = 0; i < sizeof arr / sizeof arr[0]; i++)
{
arr[i] = malloc(sizeof arr[i] * 20);
if (arr[i])
{
strcpy(arr[i], "initial string");
}
}

/* do something interesting */
return 0;
}

If your intent was to create a single 20-element array of char, you
would do one of the following:

1. char *arr;
...
arr = malloc(20 * sizeof *arr);
if (arr)
{
strcpy(arr, "some string value");
}

2. char (*arr)[20];
...
arr = malloc(sizeof *arr); // note difference
if (arr)
{
strcpy(*arr, "some string value"); // note difference
}

The second method isn't as commonly used, mainly because it isn't as
flexible and introduces an extra level of indirection. I just included
it for completeness.

Remember:

char *arr[5]; -- arr is array of pointer to char
char (*arr)[5]; -- arr is pointer to array of char

[Martin Ambuhl]

termin wrote:

consider this
char *arr[5]; why doesn't
arr=malloc(20);
this work ?

arr is an array (of 5 pointers to char). It is not a pointer.

[Netocrat]

Chris Dollin wrote:

DevarajA wrote:

Chris Dollin ha scritto:

DevarajA wrote:
termin ha scritto:

>consider this
>
>char *arr[5];
>
>why doesn't
>
>arr=malloc(20);
>
>this work ?

Because arr is already declared as a char* array and the name of an
array becomes a const pointer to the first element of the array.
Strictly speaking it becomes not a "const pointer" but a "non-lvalue
pointer".
No, /it does not/.

The types are different, as seventeen seconds with `sizeof`
and your favourite compiler - and other experiments - will
support.
It doesnt when you use sizeof, initialize with a string literal or use
operator &. In other cases it does.
The string literal initialisation applies to the string literal itself,
not the array being initialised, which doesn't decay and remains an
array.
Anyway you're right, it would have
been better to say "it acts like a pointer".

Perhaps "it decays to a pointer".
No, it would have been better to say that it's an array, and
arrays aren't assignable in C.
For the reply to this specific post, you are right.
Pretending it's a pointer only defers the pain, and gives it
a chance to grow.

But not being aware that an array in most situations decays to a
pointer can become just as painful.

[ozbear]

On 19 Jul 2005 09:07:30 -0700, "John Bode" <jo*******@my-deja.com>
wrote:

termin wrote:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because arr is a 5-element array of pointer to char, not a pointer to a
5-element array of char, and you cannot write to an array object. If
your intent was to create an array of 5 20-character strings, the
general procedure is

#include <stdlib.h>
#include <string.h>

int main(void)
{
char *arr[5];
int i;

for (i = 0; i < sizeof arr / sizeof arr[0]; i++)
{
arr[i] = malloc(sizeof arr[i] * 20);
if (arr[i])
{
strcpy(arr[i], "initial string");
}
}

/* do something interesting */
return 0;
}

<snip>

I believe the malloc call
arr[i] = malloc(sizeof arr[i] * 20);
should have been
arr[i] = malloc(sizeof arr[i][0] * 20);
or, probably better
arr[i] = malloc(20);

The original overallocates by a factor of sizeof(arr[i]) since
arr[i] is a char pointer, not a char.

Oz
--
A: Because it fouls the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Lawrence Kirby]

On Tue, 19 Jul 2005 14:16:50 +0000, DevarajA wrote:

Chris Dollin ha scritto:

DevarajA wrote:

termin ha scritto:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?
Because arr is already declared as a char* array and the name of an
array becomes a const pointer to the first element of the array.

arr is declared (and also defined) as an array of 5 pointers to char. It
is NOT declared as a char *.
No, /it does not/.

The types are different, as seventeen seconds with `sizeof` and your
favourite compiler - and other experiments - will support.

It doesnt when you use sizeof, initialize with a string literal or use
operator &.

In those cases an array operand/initialiser is used directly, ...
In other cases it does.
.... in other cases it is converted to a pointer to the first element of
the array. A pointer to the first element of arr has type char **, not
char *.
Anyway you're right, it would have
been better to say "it acts like a pointer".

The significant point here is not that it evaluates to a pointer, it is
that it is not modifiable i.e. cannot appear on the LHS of an assignment
operator.

Lawrence

[John Bode]

ozbear wrote:

On 19 Jul 2005 09:07:30 -0700, "John Bode" <jo*******@my-deja.com>
wrote:

termin wrote:

consider this

char *arr[5];

why doesn't

arr=malloc(20);

this work ?

Because arr is a 5-element array of pointer to char, not a pointer to a
5-element array of char, and you cannot write to an array object. If
your intent was to create an array of 5 20-character strings, the
general procedure is

#include <stdlib.h>
#include <string.h>

int main(void)
{
char *arr[5];
int i;

for (i = 0; i < sizeof arr / sizeof arr[0]; i++)
{
arr[i] = malloc(sizeof arr[i] * 20);
if (arr[i])
{
strcpy(arr[i], "initial string");
}
}

/* do something interesting */
return 0;
}

<snip>

I believe the malloc call
arr[i] = malloc(sizeof arr[i] * 20);
should have been
arr[i] = malloc(sizeof arr[i][0] * 20);
or, probably better
arr[i] = malloc(20);

The original overallocates by a factor of sizeof(arr[i]) since
arr[i] is a char pointer, not a char.

Yeah, typo. That was supposed to read

arr[i] = malloc(sizeof *arr[i] * 20);

I make it a habit to include the sizeof for the target, rather than
just a raw number of bytes; for one thing, I think it makes the intent
of the code clearer (I'm allocating N elements of M size, rather than X
bytes), and for another, I'm usually allocating arrays of something
other than char, so I have to include the sizeof anyway.