segmentation fault on calloc

[laberth]

I've got a segmentation fault on a calloc and I don'tunderstand why?
Here is what I use :

typedef struct noeud {
int val;
struct noeud *fgauche;
struct noeud *fdroit;
} *arbre; //for those who don't speak french arbre means tree.
An this is the fonction where I use the calloc :

arbre CreerNoeud(int valeur, arbre fg, arbre fd){
arbre A;
A=(arbre)calloc (1,sizeof(struc t noeud)); //segmentation fault just
here.
A->val=valeur;
A->fgauche=fg;
A->fdroit=fd;
return A;
}

I also tried A=(arbre)calloc (1,sizeof(struc t noeud));
and
A=(arbre*)callo c(1,sizeof(stru ct noeud));

but it doesn't work. Help me please !

[Hallvard B Furuseth]

laberth wrote:

I've got a segmentation fault on a calloc and I don'tunderstand why?
The simplest explanation I can think of is that you
may have forgotten '#include <stdlib.h>' which declares calloc().

Which reminds me:
A=(arbre)calloc (1,sizeof(struc t noeud)); //segmentation fault just

In C programs, don't cast the result of malloc, calloc & co. It is not
necessary, and hides bugs like forgetting to declare calloc.
Anyway, if stdlib.h did not fix the problem, maybe the problem is
elsewhere - e.g., you modify some freed memory, which can corrupt
malloc's internal structures. If so, the following program should not
segfault, and you'll have to look for the problem elsewhere. A malloc
debugger like the commercial Purify or the free Elecetric Fence
(ftp://ftp.perens.com/pub/ElectricFence/) may detect the problem for
you.

#include <stdlib.h>

typedef struct noeud {
int val;
struct noeud *fgauche;
struct noeud *fdroit;
} *arbre;

arbre CreerNoeud(int valeur, arbre fg, arbre fd) {
arbre A;
A=calloc(1,size of(struct noeud));
A->val=valeur;
A->fgauche=fg;
A->fdroit=fd;
return A;
}

int main() {
(void) CreerNoeud(0, NULL, NULL);
return 0;
}

--
Hallvard

[Peter Nilsson]

<la*****@voila. fr> wrote in message
news:84******** *************** ***@posting.goo gle.com...

I've got a segmentation fault on a calloc and I don'tunderstand why?
Here is what I use :

typedef struct noeud {
int val;
struct noeud *fgauche;
struct noeud *fdroit;
} *arbre; //for those who don't speak french arbre means tree.
It's generally not considered good form to typedef pointers this way. Just
typedef the struct, leave the pointer (*) for the readability in the
subsequent declarations of struct noeud objects.

I.E. prefer...

arbre *A;

....over...

arbre A;
An this is the fonction where I use the calloc :

arbre CreerNoeud(int valeur, arbre fg, arbre fd){
arbre A;
A=(arbre)calloc (1,sizeof(struc t noeud)); //segmentation fault just
here.
I'm guessing you didn't include <stdlib.h>. I.e. you didn't supply a
function prototype for calloc().
A->val=valeur;
A->fgauche=fg;
A->fdroit=fd;
Not that calloc will properly initialise pointers to null anyway (at least
not portably), but since you clobber the zero-ed contents, why bother with
calloc? Why not just use...

A = malloc(sizeof *A);

If this fails to compile, then my guess was likely correct.
return A;
}

--
Peter

[Christopher Benson-Manica]

Peter Nilsson <ai***@acay.com .au> spoke thus:

Not that calloc will properly initialise pointers to null anyway (at least

^not

Just in case anyone was confused, although the rest of your sentence
indicates that you were not.

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.

[Kevin Goodsell]

Christopher Benson-Manica wrote:

Peter Nilsson <ai***@acay.com .au> spoke thus:

Not that calloc will properly initialise pointers to null anyway (at least

^not

Just in case anyone was confused, although the rest of your sentence
indicates that you were not.

I think he had it right, but it's a little confusing to see that idiom
written rather than spoken. In conversational English, I might say
something like, "Not that it will work, but you could try..." implying
that it may not work.

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

[Christopher Benson-Manica]

Kevin Goodsell <us************ *********@never box.com> spoke thus:

I think he had it right, but it's a little confusing to see that idiom
written rather than spoken. In conversational English, I might say
something like, "Not that it will work, but you could try..." implying
that it may not work.

Curses, foil'd again ;( You're quite right, of course...

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.

[CBFalconer]

la*****@voila.f r wrote:

I've got a segmentation fault on a calloc and I don'tunderstand why?
Here is what I use :

typedef struct noeud {
int val;
struct noeud *fgauche;
struct noeud *fdroit;
} *arbre; //for those who don't speak french arbre means tree.

An this is the fonction where I use the calloc :

arbre CreerNoeud(int valeur, arbre fg, arbre fd){
arbre A;
A=(arbre)calloc (1,sizeof(struc t noeud)); //segmentation fault just

Don't use // comments in newsgroups, they don't wrap well!

Don't cast the result of malloc. It hides the error of failing to
#include <stdlib.h>

At any rate, by the time you get here there is no such thing as
"sizeof struct noeud". You never defined such. If you had used
the better and simpler form:

A = calloc(1, sizeof *A);

the problem would not arise.

WARNING: my guess is that you are using calloc to try to
initialize the gauche et droit pointers to NULL. This is NOT
valid. You should use explicit discrete initialization. You
should also test the allocation result. Thus the sequence would
become:

if (A = malloc(sizeof *A)) {
A->gauche = NULL; A->droit = NULL;
/* whatever */
}
else {
/* lack of memory action */
}

--
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!

[Jared Dykstra]

Hallvard B Furuseth <h.b.furuseth(n ospam)@usit.uio (nospam).no> wrote in message news:<HB******* *******@bombur. uio.no>...

laberth wrote:

I've got a segmentation fault on a calloc and I don'tunderstand why?

The simplest explanation I can think of is that you
may have forgotten '#include <stdlib.h>' which declares calloc().

Failure to #include something is only going to confuse the compiler.
The linker doesn't care, and of course has no effect at runtime being
a preprocessor directive. A segmentation fault indicates a runtime
error.

Runtime errors are common on the C memory management API when the heap
was mismanaged in previous calls. free()ing a pointer twice is very
likely to cause a failure in the next malloc/calloc/realloc/etc call
because the call to free() is likely to (but may not) the heap in an
invalid state.

Many tools exist for debugging memory management. Start with Electric
Fence if you're still boggled by the failure. It will pinpoint the
location where the an over/underrun was made--before it segfaults

---
Jared Dykstra
http://www.bork.org/~jared

[Martin Dickopp]

dy******@hotmai l.com (Jared Dykstra) writes:

Hallvard B Furuseth <h.b.furuseth(n ospam)@usit.uio (nospam).no> wrote in message news:<HB******* *******@bombur. uio.no>...

laberth wrote:

I've got a segmentation fault on a calloc and I don'tunderstand why?

The simplest explanation I can think of is that you
may have forgotten '#include <stdlib.h>' which declares calloc().

Failure to #include something is only going to confuse the compiler.
The linker doesn't care, and of course has no effect at runtime being
a preprocessor directive. A segmentation fault indicates a runtime
error.

Failure to #include <stdlib.h> makes the compiler believe that `calloc'
returns `int', while in fact it returns `void *'. Normally the compiler
would emit a diagnostic when an `int' is assigned to a pointer, however
the OP prevented this by casting the return value of `calloc'. The result
is undefined behavior, which may well cause a runtime error.

Martin

[Jared Dykstra]

Martin Dickopp <ex************ ****@zero-based.org> wrote in message news:<bs******* ******@news.t-online.com>...

dy******@hotmai l.com (Jared Dykstra) writes:

Hallvard B Furuseth <h.b.furuseth(n ospam)@usit.uio (nospam).no> wrote in message news:<HB******* *******@bombur. uio.no>...

laberth wrote:

> I've got a segmentation fault on a calloc and I don'tunderstand why?

The simplest explanation I can think of is that you
may have forgotten '#include <stdlib.h>' which declares calloc().

Failure to #include something is only going to confuse the compiler.
The linker doesn't care, and of course has no effect at runtime being
a preprocessor directive. A segmentation fault indicates a runtime
error.

Failure to #include <stdlib.h> makes the compiler believe that `calloc'
returns `int', while in fact it returns `void *'. Normally the compiler
would emit a diagnostic when an `int' is assigned to a pointer, however
the OP prevented this by casting the return value of `calloc'. The result
is undefined behavior, which may well cause a runtime error.

Martin

True, but only if sizeof(int) != sizeof(void *). This is, of course,
entirely possible.

Given that the original poster said:
"I also tried A=(arbre)calloc (1,sizeof(struc t noeud));
and
A=(arbre*)callo c(1,sizeof(stru ct noeud));"

It is clear he is not too familiar with calloc() and/or dynamic memory
management.

---
Jared Dykstra
http://www.bork.org/~jared