NULL?? How come??

[mike79]

Hi all,

I have a the following simple piece of code which has taken me hours
to try and sort out the problem, but still unable to find what is
wrong.

void main( void )
{
char (*string)[20]; ............... ........(1)

string = malloc(10 * sizeof *string); .....(2)
string[0] = NULL; ............... ..........(3)
}

Basically, I am allocating memory to an array of strings of 20 chars
max, and setting element 0 of the array to be a NULL value.
Lines (1) to (2) work OK, but line (3) does not work. I wish to set
the string of element 0 to be a NULL value, but keeps getting an error
saying:

"left operand must be l-value"

Please help me, I dont understand what's wrong.

Thank you all in advance,
mike79

[rihad]

On 3 Nov 2003 03:43:45 -0800, mi****@iprimus. com.au (mike79) wrote:

Hi all,

I have a the following simple piece of code which has taken me hours
to try and sort out the problem, but still unable to find what is
wrong.

void main( void )
{
char (*string)[20]; ............... ........(1)

string = malloc(10 * sizeof *string); .....(2)
/* set the first element of the array to an empty string */
if (string != NULL) {
string[0][0] = '\0';
}}
Basically, I am allocating memory to an array of strings of 20 chars
max, and setting element 0 of the array to be a NULL value.
Lines (1) to (2) work OK, but line (3) does not work. I wish to set
the string of element 0 to be a NULL value, but keeps getting an error
saying:

"left operand must be l-value"

Each element of the array has type (char [20]), array of 20 chars. You can't
assign to arrays! See the corrections to your code above

[Rune Flaten Værnes]

> I have a the following simple piece of code which has taken me hours

to try and sort out the problem, but still unable to find what is
wrong.

void main( void )
{
char (*string)[20]; ............... ........(1)

string = malloc(10 * sizeof *string); .....(2)
string[0] = NULL; ............... ..........(3)
}

Try
(*string)[0] = NULL;

--
runefv

[rihad]

On Mon, 3 Nov 2003 13:03:21 +0100, "Rune Flaten VÖrnes"
<re************ ******@remove.k ongsberg.remove .com> wrote:

I have a the following simple piece of code which has taken me hours
to try and sort out the problem, but still unable to find what is
wrong.

void main( void )
{
char (*string)[20]; ............... ........(1)

string = malloc(10 * sizeof *string); .....(2)
string[0] = NULL; ............... ..........(3)
}

Try
(*string)[0] = NULL;

Let's see. *string is of type (char [20]). **string (which is the same thing as
(*string)[0] and even *string[0] (in this case)) is of type (char). Why are you
assigning NULL to a char?

(as a side note, using NULL over 0 here is advantageous because the compiler
will catch the incorrect assignment (assuming NULL does not expand to just 0)
and possibly a bug in your reasoning).

[Bruno Desthuilliers]

mike79 wrote:

Hi all,

I have a the following simple piece of code which has taken me hours
to try and sort out the problem, but still unable to find what is
wrong.

void main( void )
it's int main(void) or int main(int argc, char **argv).
{
char (*string)[20]; ............... ........(1)
Not an expert, but I'm not sure the above is correct (any guru out there
?).

But well, let's pretend it is and it really means what you want...
string = malloc(10 * sizeof *string); .....(2)
string[0] = NULL; ............... ..........(3)
}
Basically, I am allocating memory to an array of strings of 20 chars
max, and setting element 0 of the array to be a NULL value.
Lines (1) to (2) work OK, but line (3) does not work. I wish to set
the string of element 0 to be a NULL value, but keeps getting an error
saying: "left operand must be l-value"
Please help me, I dont understand what's wrong.

<gurus, please correct me if I'm wrong>

This last line is basically the same as writing :
int main(void)
{
char str20[20];
str20 = NULL;
return 0;
}

This gives me (gcc 3.x, with -Wall -ansi -pedantic switches) :
'incompatible types in assignment'

This does not surprise me, since, while sharing some mechanisms, an
automatic array and a pointer to a dynamically allocated memory block
are two different things.

You can consider str20 as a pointer to the first element of a 20 chars
array (and yes it is, technically), but it's a 'read-only' pointer, in
the meaning that you *can not* modify the *address* it points to.

If what you want is to init each element in the 'string' array to the
empty string, you may want to have a look at calloc() or memset() :

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

int main(void)
{
char (*strings)[20];
int i;
int j;
size_t size = 10 * sizeof *strings;

strings = malloc(size);
memset(strings, 0, size);

for (i = 0; i < 10; i++) {
printf("strings[%d] : \n", i);
for (j = 0; j < 20; j++) {
printf(" '%c' ", strings[i][j] + '0');
}
printf("\n");
}

free(strings);
return 0;
}
Note that it *may* not be necessary (at least it *seems* not to be on
Linux with gcc 3.2.2 : commenting out the 'memset()' call doesn't seems
to change the output), but as this could be an UB, I would not rely on
this without the enlightening advices of some guru here (any guru around ?-)

HTH,
Bruno

[Irrwahn Grausewitz]

mi****@iprimus. com.au (mike79) wrote:

I have a the following simple piece of code which has taken me hours
to try and sort out the problem, but still unable to find what is
wrong.
Provide a correct prototype for malloc():

#include <stdlib.h>
void main( void )
main() always returns an int:

int main( void )
{
char (*string)[20]; ............... ........(1)

string = malloc(10 * sizeof *string); .....(2)
Check the return value of malloc here!
string[0] = NULL; ............... ..........(3)
string[0] is an array to which you cannot assign directly; write:

string[0][0] = '\0';

or (after inclusion of string.h):

strcpy( string[0], "" );

to make string[0] contain an empty string.

main() always returns an int:

return 0; }

Basically, I am allocating memory to an array of strings of 20 chars
max, and setting element 0 of the array to be a NULL value.
Lines (1) to (2) work OK, but line (3) does not work. I wish to set
the string of element 0 to be a NULL value,
As I said above, you cannot assign to an array. Assuming that you want
string[0] to contain an empty string, remember that NULL is a null
pointer constant and neither an empty string nor a null character.
but keeps getting an error
saying:

"left operand must be l-value"

Funny enough, in C99 string[0] /is/ an lvalue, yet not a modifiable one,
thus you still cannot assign to it.

HTH
Regards.
--
Irrwahn
(ir*******@free net.de)

[Bruno Desthuilliers]

Bruno Desthuilliers wrote:

sorry, code needed a bit correction before posting...

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

int main(void)
{
char (*strings)[20];
int i;
int j;
size_t size = 10 * sizeof *strings;

strings = malloc(size); if (strings != NULL) { memset(strings, 0, size);

for (i = 0; i < 10; i++) {
printf("strings[%d] : \n", i);
for (j = 0; j < 20; j++) {
printf(" '%c' ", strings[i][j] + '0');
}
printf("\n");
}

free(strings); }
else {
printf("malloc( ) failed \n");
} return 0;
}

Bruno

[Irrwahn Grausewitz]

Bruno Desthuilliers <bd***********@ removeme.free.f r> wrote:

mike79 wrote:

char (*string)[20]; ............... ........(1)
Not an expert, but I'm not sure the above is correct (any guru out there
?).

Not an expert too, but if OP wants to declare a pointer to array of
20 chars: yes, it's correct.
But well, let's pretend it is and it really means what you want...

string = malloc(10 * sizeof *string); .....(2)
string[0] = NULL; ............... ..........(3)
}
<gurus, please correct me if I'm wrong>

This last line is basically the same as writing :
int main(void)
{
char str20[20];
str20 = NULL;
return 0;
}

Not a guru, but it is similar in that in both cases an attempt is made
to assign to something that is not an (modifiable) lvalue.
This gives me (gcc 3.x, with -Wall -ansi -pedantic switches) :
'incompatible types in assignment'

This does not surprise me, since, while sharing some mechanisms, an
automatic array and a pointer to a dynamically allocated memory block
are two different things.

You can consider str20 as a pointer to the first element of a 20 chars
array (and yes it is, technically), but it's a 'read-only' pointer, in
the meaning that you *can not* modify the *address* it points to.
Yup.
If what you want is to init each element in the 'string' array to the
empty string, you may want to have a look at calloc() or memset() :
Note: the code below not only sets the strings to empty strings,
it 'zeroes' out the whole array.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
char (*strings)[20];
int i;
int j;
size_t size = 10 * sizeof *strings;

strings = malloc(size);
Better check the return value of malloc here.
(OK, I noticed you have already corrected this in a followup post)
memset(strings, 0, size);

for (i = 0; i < 10; i++) {
printf("strings[%d] : \n", i);
for (j = 0; j < 20; j++) {
printf(" '%c' ", strings[i][j] + '0');
This produces misleading output. Better write:

printf(" %d", strings[i][j] );
}
printf("\n");
}

free(strings);
return 0;
}
Note that it *may* not be necessary (at least it *seems* not to be on
Linux with gcc 3.2.2 : commenting out the 'memset()' call doesn't seems
to change the output), but as this could be an UB, I would not rely on
this without the enlightening advices of some guru here (any guru around ?-)

Still not a guru, but malloc just happens to have allocated some memory
that was filled with zeros coincidentally. Relying on this is calling
for nasal demons (aka undefined behaviour).

HTH
Regards
--
Irrwahn
(ir*******@free net.de)

[TheDruid]

Hi mike79.

I am french so my English isn't good. First, I don't understand what
this code means. Can you tell me what is your workstation. I am using
Linux and gcc.
Your code doesn't compile on my box. The error is "incompatib le types
assignment in (3)". Tell me what you want to do, maybe I can help you

Hi all,

I have a the following simple piece of code which has taken me hours
to try and sort out the problem, but still unable to find what is
wrong.

void main( void )
{
char (*string)[20]; ............... ........(1)

string = malloc(10 * sizeof *string); .....(2)
string[0] = NULL; ............... ..........(3)
}

Basically, I am allocating memory to an array of strings of 20 chars
max, and setting element 0 of the array to be a NULL value.
Lines (1) to (2) work OK, but line (3) does not work. I wish to set
the string of element 0 to be a NULL value, but keeps getting an error
saying:

"left operand must be l-value"

Please help me, I dont understand what's wrong.

Thank you all in advance,
mike79

[Bruno Desthuilliers]

Irrwahn Grausewitz wrote:

Bruno Desthuilliers <bd***********@ removeme.free.f r> wrote:

Note: the code below not only sets the strings to empty strings,
it 'zeroes' out the whole array.

Yeps. But the result is technically the same, or IMHO even better since
you're sure to not have garbage trailing in the strings (my 2 cents...).

Or am I wrong ?

(snip code)

Note that it *may* not be necessary (at least it *seems* not to be on
Linux with gcc 3.2.2 : commenting out the 'memset()' call doesn't seems
to change the output), but as this could be an UB, I would not rely on
this without the enlightening advices of some guru here (any guru around ?-)

Still not a guru, but malloc just happens to have allocated some memory
that was filled with zeros coincidentally. Relying on this is calling
for nasal demons (aka undefined behaviour).

Yeps, I guessed it may not be defined behavior (hence my advice not to
rely on this).

Bruno