AMD opteron 64

[Lionel Valero]

Hello,

I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
*************** ********
main (argc, argv)
int argc;
char *argv[];
{
int *ka;
int nka;

/* allocation dynamique entiere */
ka = (int *) malloc(nka * sizeof(int));
if (!ka) {
printf ("<ERROR> : Out of heap space (malloc) !\n");
printf ("<ERROR> : %d int words required\n", nka);
exit (-1);
}
}
*************** ********

But under linux suse AMD opteron 64, i get this message from the compiler :

warning: cast to pointer from integer of different size

Any explanation ?

Regards,
Lionel.
--
-=O=------------------------------------------=O=-
Lionel Valéro
Analyste Informatique Département Génie Chimique
École Polytechnique de Montréal
C.P. 6079, succ. centre-ville
Montréal (Québec) H3C 3A7
Tel: (514) 340 - 4711 # 4805 / C552
Fax: (514) 340 - 4159
-=O=------------------------------------------=O=-

[Mike Wahler]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > wrote in message
news:3F******** ******@jpl.nasa .gov...

Ben Pfaff wrote:

I don't recommend casting the return value of malloc():

* The cast is not required in ANSI C.
But an ANSI/ISO C++ compiler will complain.

So what? This is comp.lang.c.

* Casting its return value can mask a failure to
#include <stdlib.h>, which leads to undefined behavior.
No! It may mask the fact that malloc was not declared
but a good C compiler will warn you about that.

It might, but it's not required to. I'd rather rely upon
accurate knowledge than depend upon a convenience feature
of a tool, which might or might not exist.

* If you cast to the wrong type by accident,
odd failures can result.
Can you show us an example?

The OP's original message is a perfect example.

In fact, the second problem is your problem here. Fix it.

When calling malloc(), I recommend using the sizeof operator on
the object you are allocating, not on the type. For instance,
*don't* write this:

int *p = malloc (sizeof (int) * 128); /* Don't do this! */

Instead, write it this way:

int *p = malloc (sizeof *p * 128);

There's a few reasons to do it this way:

* If you ever change the type that `p' points to, it's not
necessary to change the malloc() call as well.

A better solution would be:

typedef int T;
T* p = (T*)malloc(128* sizeof(T));

Casting the return value from malloc() is never 'better'.
And your typdef only obfuscates things.
-Mike

[Ben Pfaff]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > writes:

Ben Pfaff wrote:

I don't recommend casting the return value of malloc():
* The cast is not required in ANSI C.

But an ANSI/ISO C++ compiler will complain.

Fortunately, we are not discussing C++. malloc() should not
normally be used in C++.

* Casting its return value can mask a failure to
#include <stdlib.h>, which leads to undefined behavior.

No! It may mask the fact that malloc was not declared
but a good C compiler will warn you about that.

This is in fact the OP's problem, so I don't see how you can
discount it.

* If you cast to the wrong type by accident,
odd failures can result.

Can you show us an example?

Casting to (char) instead of (char *) is bound to be a problem.

In fact, the second problem is your problem here. Fix it.
When calling malloc(), I recommend using the sizeof operator on
the object you are allocating, not on the type. For instance,
*don't* write this:
int *p = malloc (sizeof (int) * 128); /* Don't do this! */
Instead, write it this way:
int *p = malloc (sizeof *p * 128);
There's a few reasons to do it this way:
* If you ever change the type that `p' points to, it's not
necessary to change the malloc() call as well.

A better solution would be:

typedef int T;
T* p = (T*)malloc(128* sizeof(T));

I don't see how that's a better solution at all.
--
int main(void){char p[]="ABCDEFGHIJKLM NOPQRSTUVWXYZab cdefghijklmnopq rstuvwxyz.\
\n",*q="kl BIcNBFr.NKEzjwC IxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+= strchr(p,*q++)-p;if(i>=(int)si zeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}

[Eric Sosman]

"E. Robert Tisdale" wrote:

Ben Pfaff wrote:

I don't recommend casting the return value of malloc():

* The cast is not required in ANSI C.

But an ANSI/ISO C++ compiler will complain.

A COBOL compiler will complain even louder. So what?

--
Er*********@sun .com

[Mark McIntyre]

On Mon, 01 Dec 2003 18:21:07 GMT, in comp.lang.c , Lionel Valero
<li***********@ polymtl.ca> wrote:

Hello,

I have a test program that is compiled fine on a 32 bits redhat linux using gcc :
************** *********
main (argc, argv)
int argc;
char *argv[];
{
int *ka;
int nka;

/* allocation dynamique entiere */
ka = (int *) malloc(nka * sizeof(int));

Everyone else has explained your immediate problem.forgett ing

HoweverI notice you are using nka to size your array. But you didn't
initialise it to any value. So it contains garbage, and may crash your
program.

--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.angelfire.c om/ms3/bchambless0/welcome_to_clc. html>
----== Posted via Newsfeed.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
---= 19 East/West-Coast Specialized Servers - Total Privacy via Encryption =---

[Joona I Palaste]

Eric Sosman <Er*********@su n.com> scribbled the following:

"E. Robert Tisdale" wrote:

Ben Pfaff wrote:

> I don't recommend casting the return value of malloc():
>
> * The cast is not required in ANSI C.
But an ANSI/ISO C++ compiler will complain.

A COBOL compiler will complain even louder. So what?

ERT seems to have a fascination with compiling C code with a C++
compiler these days. Can you say "one-trick pony", ERT?

--
/-- Joona Palaste (pa*****@cc.hel sinki.fi) ------------- Finland --------\
\-- http://www.helsinki.fi/~palaste --------------------- rules! --------/

[Jack Klein]

On Mon, 01 Dec 2003 13:07:09 -0800, "E. Robert Tisdale"
<E.************ **@jpl.nasa.gov > wrote in comp.lang.c:

Lionel Valero wrote:

I have a test program
that is compiled fine on a 32 bits redhat linux using gcc :
***************
Still playing the fool I see, Tisdale.
> cat malloc.c #include <stdlib.h>
#include <stdio.h>

int main (int argc, char* argv[]) {
int nka = atoi(argv[1]);

What happens when you run it without command line arguments and
dereference the null pointer? Can you say "segfault"?
/* allocation dynamique entiere */
int* ka = (int*)malloc(nk a*sizeof(int));
About one in 20 times you actually post something of value. Sadly,
this is not one of those times...

int *ka = malloc(nka * sizeof *ka);

Note the pleasing symmetry of the dual asterisks.
if (NULL == ka) {
fprintf(stderr, "<ERROR>: Out of free storage (malloc)!\n");
fprintf(stderr, "<ERROR>: %d int words required\n", nka);
exit (EXIT_FAILURE);
}
return EXIT_SUCCESS;
}

> gcc -Wall -std=c99 -pedantic -o malloc malloc.c
> ./malloc 13
> ./malloc 999999999999

<ERROR>: Out of free storage (malloc)!
<ERROR>: 2147483647 int words required

Why didn't you show the results of running:

./malloc

???

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++ ftp://snurse-l.org/pub/acllc-c++/faq

[CBFalconer]

*** topposting fixed ***

Lionel Valero wrote:

Lionel Valero wrote:

I have a test program that is compiled fine on a 32 bits redhat linux
using gcc :
*************** ********
main (argc, argv)
int argc;
char *argv[];
Do not use old fashioned function declarations, they have been
obsolete for at least 15 years. main returns int, say so.
{
int *ka;
int nka;

/* allocation dynamique entiere */
ka = (int *) malloc(nka * sizeof(int));
Do not cast malloc results. nka is uninitialized. Use sizeof
*ka.
if (!ka) {
printf ("<ERROR> : Out of heap space (malloc) !\n");
printf ("<ERROR> : %d int words required\n", nka);
exit (-1);
-1 is not a portable value here. EXIT_FAILURE and
EXIT_SUCCESS come to mind, after #including <stdlib.h>
}
}
*************** ********

But under linux suse AMD opteron 64, i get this message from the compiler :

warning: cast to pointer from integer of different size

Any explanation ?

Increase the gcc warning levels. -W -Wall -ansi -pedantic -O1 are
the recommended minimum.

I forgto the headers :
#include <stdio.h>
#include <sys/types.h>
This is not a valid ISO C header. Omit it.
#include <time.h>

This is not used. omit it.

Please Do Not Toppost.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Keith Thompson]

"E. Robert Tisdale" <E.************ **@jpl.nasa.gov > writes:

Ben Pfaff wrote:

I don't recommend casting the return value of malloc():
* The cast is not required in ANSI C.

But an ANSI/ISO C++ compiler will complain.

So don't use a C++ compiler on C source (or a Fortran compiler, or an
Intercal compiler). There's no good reason C source code should be
constrained to be valid C++.

<OT>
Well-written C++ code doesn't use malloc() anyway; it uses the "new"
operator.
</OT>

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://www.sdsc.edu/~kst>
Schroedinger does Shakespeare: "To be *and* not to be"
(Note new e-mail address)

[Barry Schwarz]

On Mon, 01 Dec 2003 13:20:48 -0800, "E. Robert Tisdale"
<E.************ **@jpl.nasa.gov > wrote:

Ben Pfaff wrote:

I don't recommend casting the return value of malloc():

* The cast is not required in ANSI C.

But an ANSI/ISO C++ compiler will complain.

* Casting its return value can mask a failure to
#include <stdlib.h>, which leads to undefined behavior.

No! It may mask the fact that malloc was not declared
but a good C compiler will warn you about that.

On a machine where the method of returning a pointer differs from the
method of returning an int (such as using a different register), the
behavior is indeed undefined. malloc will return the pointer using
the correct procedure. The compiler will generate code to convert the
assumed returned int. Since malloc did not return an int, this code
will operate on residual data.
<<Remove the del for email>>

[Richard Bos]

Joona I Palaste <pa*****@cc.hel sinki.fi> wrote:

Eric Sosman <Er*********@su n.com> scribbled the following:

"E. Robert Tisdale" wrote:

Ben Pfaff wrote:
> I don't recommend casting the return value of malloc():
>
> * The cast is not required in ANSI C.

But an ANSI/ISO C++ compiler will complain.

Which proves once again that C++ is broken, since the cast is useless
and useless casts should be anathema.
A COBOL compiler will complain even louder. So what?

ERT seems to have a fascination with compiling C code with a C++
compiler these days.

That's because ERT has, and AFAICT has always had, a bee in his bonnet
about C++ being "the new C". Not even Bjarne Stroustrup has that
delusion, but some people are impossible to disconfuse.

Richard