Dynamic arrays

[Rick]

Hi,

I'm trying to use a dynamic array but for some reason it won't work. This is
my code :

int *test;
int numElements = 2;

test = (int *) malloc (numElements * sizeof(int));
if (test= NULL) printf("Can't allocate\n"); // Nothing happens here
so it's ok I guess
test[0] = 10; // <- CRASH!
printf( "test= %d\n",test[0] );

I copied it from the internet and it seems that they all do it this way?
Then why won't this work? My computer sure has enough for 2 integers...

Greetings,
Rick

 

[Jirka Klaue]

I'm trying to use a dynamic array but for some reason it won't work. This is
my code :

int *test;
int numElements = 2;

test = (int *) malloc (numElements * sizeof(int));
if (test= NULL) printf("Can't allocate\n"); // Nothing happens here

^
Hur, hur!

You want ==.

Jirka

 

[Irrwahn Grausewitz]

Hi,

I'm trying to use a dynamic array but for some reason it won't work. This is
my code :

It's certainly not, it won't even compile.

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

int main(void)
{

int *test;
int numElements = 2;

test = (int *) malloc (numElements * sizeof(int));

^ spurious cast, you'd better write:

test = malloc ( numElements * sizeof *test );

if (test= NULL) printf("Can't allocate\n"); // Nothing happens here

^ you assign NULL to test here

so it's ok I guess

No, you want:

if ( test == NULL )
{
printf("Can't allocate\n");
return EXIT_FAILURE;
}

test[0] = 10; // <- CRASH!

It's not surprising for NULL[0] = 10; to crash. You invoked undefined
behaviour.

printf( "test= %d\n",test[0] );

return EXIT_SUCCESS;
}

I copied it from the internet and it seems that they all do it this way?

No, fortunately not.

Then why won't this work? My computer sure has enough for 2 integers...

See above.

HTH
Regards

 

[sellountos euripides]

^
Hur, hur!

You want ==.

To OP.
That's why many programmers prefer to write:
if (NULL==test) {
/* ... */
}
To catch the error at compile time.

e.j.s.

 

[Rick]

Ok, ok, I quickly typed it over. ( s = NULL ) is stupid indeed but in the
real code there are really 2 == And no, although there's a bug it does
compile. But look, an exact copy now :

int *da;
int numElements = 2;

da = (int *) malloc (numElements * sizeof(int));
if (da== NULL) printf("damn\n");
da[0] = 10; // The same problem
printf( "test= %d\n",da[0] );

Also tried without the == null line, just for sure, but it doesn't work
neither. I also tried it without (int *)but it keeps crashing.

Greetings,
Rick

 

[Al Bowers]

Ok, ok, I quickly typed it over. ( s = NULL ) is stupid indeed but in the
real code there are really 2 == And no, although there's a bug it does
compile. But look, an exact copy now :

int *da;
int numElements = 2;

da = (int *) malloc (numElements * sizeof(int));
if (da== NULL) printf("damn\n");
da[0] = 10; // The same problem
printf( "test= %d\n",da[0] );

Also tried without the == null line, just for sure, but it doesn't work
neither. I also tried it without (int *)but it keeps crashing.

You have a flaw. You should not simply print a message
if the allocation failed and then continue on as if it was
successful. You need and if-else or an exit.

Try this and see if this crashes:

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

int main(void)
{
int *da;
int numElements = 2;

da = malloc(numElements * sizeof(int));
if (da == NULL) printf("damn\n");
else
{
da[0] = 10;
printf( "test= %d\n",da[0] );
free(da);
}
return 0;
}

 

[Rick]

Very True, but it doesn't solve the problem...

Greetings,
Rick

 

[Alex]

To OP.
That's why many programmers prefer to write:
if (NULL==test) {
/* ... */
}
To catch the error at compile time.

I prefer to increase the warning level from my compiler, which also sets off
an alarm bell in this type of situation:

int i, j;
/* ... */
if (i = /* whoops! */ j) { /* ... */ }

Alex

 

[Rick]

Ow, Al, I tried you code (thanks for that) in the main but it still crashes.
What the heck is going on? Even my drunken brain can store 2 integers. It's
just a normal pc. Maybe it are some settings in the old Borland C++??

Greetings,
Rick

 

[Rick]

Wait! I talk too fast. It does work now, after including #include <stdlib.h>
as well. Are their more versions of malloc or something? The compiler didn't
say anything.

Thanks!
Rick

 

[Irrwahn Grausewitz]

Ok, ok, I quickly typed it over. ( s = NULL ) is stupid indeed but in the
real code there are really 2 == And no, although there's a bug it does
compile. But look, an exact copy now :

int *da;
int numElements = 2;

da = (int *) malloc (numElements * sizeof(int));
if (da== NULL) printf("damn\n");
da[0] = 10; // The same problem
printf( "test= %d\n",da[0] );

Sorry, but your code confuses my compiler:

4: conflicting types for `da'
1: previous declaration of `da'
4: warning: implicit declaration of function `malloc'
4: warning: initialization makes integer from pointer without a cast
4: initializer element is not constant
4: warning: data definition has no type or storage class
5: parse error before "if"
6: warning: type defaults to `int' in declaration of `da'
6: conflicting types for `da'
4: previous declaration of `da'
6: invalid initializer
6: warning: data definition has no type or storage class
7: parse error before string constant
7: warning: type defaults to `int' in declaration of `printf'
7: warning: conflicting types for built-in function `printf'
7: warning: data definition has no type or storage class

Please post a compilable version of your code.

Regards

 

[Rick]

Strange you compiler doesn't take it. Well, maybe it's because of my very
old Borland version. But it's fixed now, the only thing I forgot the whole
time was including stdlib

Greetings,
Rick

 

[Irrwahn Grausewitz]

Wait! I talk too fast. It does work now, after including #include <stdlib.h>
as well. Are their more versions of malloc or something? The compiler didn't
say anything.

You just dicovered the reasons why it's usually bad practice to cast the
return value of malloc (it may hide the fact that you forgot to include
stdlib.h), and why it's good practice to turn up the warning level of
your compiler to maxinmum and treat warnings as errors.

Regards

 

[Irrwahn Grausewitz]

Strange you compiler doesn't take it. Well, maybe it's because of my very
old Borland version. But it's fixed now, the only thing I forgot the whole
time was including stdlib

Plus including stdio.h, plus wrapping your code in a main function, plus
casting the return value of malloc, plus failing to pump up your
compilers warning level.

Regards

 

[Rick]

Do you have magic powers? How do you know I forgot all that stuff? I only
gave a piece of the code, not the complete thing. Anyway, everybody thanks
for helping!

Greetings,
Rick

 

[Irrwahn Grausewitz]

Do you have magic powers?

Not yet, but I've got an ACME Crystal Ball [TM]. ;-)

How do you know I forgot all that stuff? I only
gave a piece of the code, not the complete thing.

That was the main (sic) problem.

Anyway, everybody thanks
for helping!

You're welcome.

Regards

 

[Dan Pop]

Wait! I talk too fast. It does work now, after including #include <stdlib.h>
as well. Are their more versions of malloc or something? The compiler didn't
say anything.

You shot yourself in the foot, by casting the malloc call. Without the
cast, the compiler MUST emit a diagnostic, if you don't include <stdlib.h>
because malloc is implicitly declared as returning int, but used in a
pointer context.

The first rule of computer programming: know what you're doing.
The second rule of computer programming: know how to use your tools.

Actually, these rules apply to any human activity...

Compile these two programs and note the difference:

int main()
{
char *p = malloc(10);
return 0;
}

and

int main()
{
char *p = (char *)malloc(10);
return 0;
}

They're both equally broken (due to the lack of declaration for malloc),
but only the first one requires a diagnostic from the compiler.

The next exercise is to find out how to use your compiler so that even
the second program generates a diagnostic, because you're using a function
without declaring it. C89 allows this, but it is such an atrocious idea
that practically all compilers can warn about it, if you raise their
warning level high enough. You really don't want to use undeclared
functions in your programs and, if you have to declare them yourself,
make sure you use prototype declarations.

If the compiler can find your bugs, it is downright idiotic not to let it
do it for you.

Dan

 

[Default User]

Do you have magic powers? How do you know I forgot all that stuff? I only
gave a piece of the code, not the complete thing. Anyway, everybody thanks
for helping!

Please quote a relevant portion of the post you are replying to.




Brian Rodenborn

 

[Mark McIntyre]

Wait! I talk too fast. It does work now, after including #include <stdlib.h>
as well. Are their more versions of malloc or something? The compiler didn't
say anything.

Rick, sorry about this, but I'm going to store your post for
perpetuity, as it a classic example of someone actually getting bitten
by the reason for NOT casting malloc.

 

[Mark McIntyre]

Wait! I talk too fast. It does work now, after including #include <stdlib.h>
as well. Are their more versions of malloc or something?

There's only one version ,declared in stdlib.h.

The compiler didn't say anything.

Its not required to. Your cast silenced the only warning it could have
made, "implicit conversion from int to pointer". In the absence of a
proper prototype for a function, the compiler assumes that it returns
an int. DONT cast malloc in C code, for this very reason.