Discussion :

[mdabire]

Bonjour,
Quelle est la différence des écritures:

int ptr;

-----------------------------------
ptr = (int *) malloc(10 * sizeof(int))

et

ptr = malloc(10 * sizeof(int))
-----------------------------------

Qu'apporte la présence ou l'absence de (int *) ?

[Thierry Chappuis]

Bonjour,
Quelle est la différence des écritures:

int ptr;

-----------------------------------
ptr = (int *) malloc(10 * sizeof(int))

et

ptr = malloc(10 * sizeof(int))
-----------------------------------

Qu'apporte la présence ou l'absence de (int *) ?

Le cast n'apporte rien. Il est même déconseillé, car il peux être source de problèmes en cas d'absence d'inclusion du fichier d'en-tête standard stdlib.h.

Thierry

[Sve@r]

Bonjour,
Quelle est la différence des écritures:

int ptr;

-----------------------------------
ptr = (int *) malloc(10 * sizeof(int))

et

ptr = malloc(10 * sizeof(int))
-----------------------------------

Qu'apporte la présence ou l'absence de (int *) ?

Le cast n'apporte rien. Il est même déconseillé, car il peux être source de problèmes en cas d'absence d'inclusion du fichier d'en-tête standard stdlib.h.

Thierry

Et surtout, ça ne marchera dans aucun des deux cas car "ptr" n'est pas un pointeur...

Sinon, sans rire, la première écriture était utilisée à l'époque où le "void *" n'existait pas. La fonction malloc() était alors de type "char *" (le type utilisé aussi comme "universel") et fallait ensuite le caster pour copier ce pointeur dans autre chose qu'un char*.
Aujourd'hui, malloc() est de type "void *" et ce type ce copie sans problème dans n'importe quel pointeur sans besoin de cast.

[Emmanuel Delahaye]

Qu'apporte la présence ou l'absence de (int *) ?

En admettant que prt soit un pointeur ! (int *ptr) :

http://emmanuel-delahaye.developpez....tes.htm#malloc

[Vincent Rogier]

le seul éventuel interêt de caster la valeur de retour de malloc est si ton source C est compilé par un compilo C++ qui oblige le cast (pointeur générique -> pointeur typé).

Par exemple, dans un projet C++ sous VS2005, si tu inclus un code source C qui utilise malloc sans cast vers un pointeur typé, le compilo gueule.

Sinon, si tu code uniquement en C et utilise un compilo C ou compile un projet 100% C, caster est strictement inutile.

[Médinoc]

Par exemple, dans un projet C++ sous VS2005, si tu inclus un code source C qui utilise malloc sans cast vers un pointeur typé, le compilo gueule.

Euh, non. Visual studio 2005 peut parfaitement compiler un fichier source C en tant que C, même si tous les autres fichiers source sont en C++...

[Melem]

Oui mais ce que voulait dire vicenzo je pense c'est que si tu penses un jour réutiliser un morceau de code C dans du code C++ alors le cast de malloc est utile puisque ton code est alors à la fois compatible C et C++.

Sinon, si tu code uniquement en C et utilise un compilo C ou compile un projet 100% C, caster est strictement inutile.

Inutile? Moi je dirais dangereux .

[Vincent Rogier]

Euh, non. Visual studio 2005 peut parfaitement compiler un fichier source C en tant que C, même si tous les autres fichiers source sont en C++

Euh ... Autant pour moi, effectivement ca roule si on spécifie "compiler comme code C" dans les propriétés avancées du fichier...

Et Pan sur le bec !

[Médinoc]

Pire, chez moi c'est le cas par défaut du moment que le fichier possède l'extension ".c"...

Ce qui n'est pas le cas sous Code::Blocks par exemple, surtout quand on importe un projet de Visual...

[Vincent Rogier]

Medinoc,

Sur mon VS2005, si j'inclus un fichier .c dans un projet C++, il le compile par défaut comme C++ et donc malloc sans cast le fait gueuler... Il faut donc aller à chaque fois préciser dans les options du fichier " compiler comme code C"...

Si tu connais l'option à modifier pour ne pas avoir à le faire, je suis preneur ...

[Médinoc]

Eh bien je suis désolé, chez moi ça marche nickel directement, et je ne pense pas qu'il y ait une "option" documentée pour ça...

Si tu as la version Express, c'est peut-être une de ses limitations...

[Melem]

Moi aussi j'ai VS 2005 mais ca compile du C comme du C. Donc pas de cast de malloc.

[Vincent Rogier]

J'ai pourtant un VS2005 pro (full version, tous langages) fournie par MS en temps que "partenaire"...

Si le projet inclu des cpp et que le main est dans un cpp et que ensuite j'inclus un .c, il est compilé comme code c++ par défaut.

Bon, je verrai ce détail à l'occasion...

[Emmanuel Delahaye]

le seul éventuel interêt de caster la valeur de retour de malloc est si ton source C est compilé par un compilo C++ qui oblige le cast (pointeur générique -> pointeur typé).

Si on compile un source C avec un compilateur C++, le comportement est indéfini.

Par exemple, dans un projet C++ sous VS2005, si tu inclus un code source C qui utilise malloc sans cast vers un pointeur typé, le compilo gueule.

VS2005 est parfaitement capable de compiler un source C en C, il suffit de le configurer correctement.

Il sait aussi gérer des projets mixtes avec des sources C et des sources C++ qui seront respectivement compilés avec le bon compilateur.

[Emmanuel Delahaye]

Sur mon VS2005, si j'inclus un fichier .c dans un projet C++, il le compile par défaut comme C++ et donc malloc sans cast le fait gueuler...<...>

Il faut vérifier que c'est bien .c (C) et non .C (C++)

[Vincent Rogier]

Je sais bien !
Les fichiers en question sont bien des *.c

[Vincent Rogier]

Autant pour moi...

Je viens de récréer un projet de test et effectivement tout est nickel...

J'avais du avoir une merdouille dans un ancien projet C++ utilisant des sources C mal configuré....

Et pan sur le bec pour la 2eme fois aujourd'dui !

[Sve@r]

Si on compile un source C avec un compilateur C++, le comportement est indéfini.

Euh... un source C++ qui n'utiliserait aucun outil C++ comme les objets, les namespace et tutti quanti et qui serait donc compilable par un compilo C n'est-il pas compilable par un compilo C++ ??

A la limite j'écris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int main()
{
    return 0;
}

Est-ce du C ou du C++ ? (et si quelqu'un me dit ce que c'est surtout qu'il me dise pourquoi ce n'est pas l'autre)...

[Médinoc]

Ça, c'est du C++, car tu as oublié void entre les parenthèses: Ce n'est pas défini par la norme C.

Pour être franc, il m'arrive de pondre du code fait pour être compilable en C comme en C++, notamment des fonctions inline.

Mais à Cthulhu ne plaise que j'utilise des casts C dans le code C++, ou un cast de void* en C! J'utilise toute une batterie de macros pour ajuster le code aux spécificités de chaque langage...

Code C/C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/* Casting.h : Définitions d'opérateurs de cast pour C et C++
   ==========================================================
 
FROMVOID_CAST: Cast d'un pointeur void* en un autre pointeur
	En C	: Rien du tout, le cast est implicite
	En C++	: static_cast
 
STATIC_CAST: Opérateur de cast standard du C++
	En C	: Cast de type C (parenthèses)
	En C++	: static_cast
 
REINTERPRET_CAST: Opérateur de cast standard du C++
	En C	: Cast de type C (parenthèses)
	En C++	: reinterpret_cast
 
CONST_CAST: Opérateur de cast standard du C++
	En C	: Cast de type C (parenthèses)
	En C++	: const_cast
(rien pour reproduire le dynamic_cast, qui est spécifique au C++)
*/
#ifndef CASTING_H_INCLUDED
#define CASTING_H_INCLUDED
 
#ifdef __cplusplus
/* Version C++ */
#define FROMVOID_CAST(t, p)        static_cast< t >(p)
#define STATIC_CAST(t, x)          static_cast< t >(x)
#define REINTERPRET_CAST(t, x)     reinterpret_cast< t >(x)
#define CONST_CAST(t, x)           const_cast< t >(x)
#define CAST_POINTER(dest, t, p)   do{ void* dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }while(0)
#define CAST_POINTER_(dest, t, p)    { void* dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }
#define CAST_POINTERC(dest, t, p)  do{ void const * dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }while(0)
#define CAST_POINTERC_(dest, t, p)   { void const * dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }
#define ALLOC_ONE(t)               (new t)
#define ALLOC_MANY(t,n)            (new t[n])
#define FREE_ONE(p)                delete (p)
#define FREE_MANY(p)               delete[] (p)
/* Fin version C++ */
#else
/* Version C */
#define FROMVOID_CAST(t, p)        (p)
#define STATIC_CAST(t, x)          ((t)(x))
#define REINTERPRET_CAST(t, x)     ((t)(x))
#define CONST_CAST(t, x)           ((t)(x))
#define CAST_POINTER(dest, t, p)   do{ void* dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }while(0)
#define CAST_POINTER_(dest, t, p)    { void* dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }
#define CAST_POINTERC(dest, t, p)  do{ void const * dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }while(0)
#define CAST_POINTERC_(dest, t, p)   { void const * dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }
#define ALLOC_ONE(t)               malloc(sizeof(t))
#define ALLOC_MANY(t,n)            malloc(sizeof(t)*(n))
#define FREE_ONE(p)                free(p)
#define FREE_MANY(p)               free(p)
/*Fin opérateurs de cast*/
#endif
 
#endif/* ! CASTING_H_INCLUDED */

[Sve@r]

Ça, c'est du C++, car tu as oublié void entre les parenthèses: Ce n'est pas défini par la norme C.

Pour être franc, il m'arrive de pondre du code fait pour être compilable en C comme en C++, notamment des fonctions inline.

Mais à Cthulhu ne plaise que j'utilise des casts C dans le code C++, ou un cast de void* en C! J'utilise toute une batterie de macros pour ajuster le code aux spécificités de chaque langage...

Code C/C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/* Casting.h : Définitions d'opérateurs de cast pour C et C++
   ==========================================================
 
FROMVOID_CAST: Cast d'un pointeur void* en un autre pointeur
	En C	: Rien du tout, le cast est implicite
	En C++	: static_cast
 
STATIC_CAST: Opérateur de cast standard du C++
	En C	: Cast de type C (parenthèses)
	En C++	: static_cast
 
REINTERPRET_CAST: Opérateur de cast standard du C++
	En C	: Cast de type C (parenthèses)
	En C++	: reinterpret_cast
 
CONST_CAST: Opérateur de cast standard du C++
	En C	: Cast de type C (parenthèses)
	En C++	: const_cast
(rien pour reproduire le dynamic_cast, qui est spécifique au C++)
*/
#ifndef CASTING_H_INCLUDED
#define CASTING_H_INCLUDED
 
#ifdef __cplusplus
/* Version C++ */
#define FROMVOID_CAST(t, p)        static_cast< t >(p)
#define STATIC_CAST(t, x)          static_cast< t >(x)
#define REINTERPRET_CAST(t, x)     reinterpret_cast< t >(x)
#define CONST_CAST(t, x)           const_cast< t >(x)
#define CAST_POINTER(dest, t, p)   do{ void* dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }while(0)
#define CAST_POINTER_(dest, t, p)    { void* dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }
#define CAST_POINTERC(dest, t, p)  do{ void const * dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }while(0)
#define CAST_POINTERC_(dest, t, p)   { void const * dest ## _tmp_ ## p = p; dest = static_cast< t >(dest ## _tmp_ ## p); }
#define ALLOC_ONE(t)               (new t)
#define ALLOC_MANY(t,n)            (new t[n])
#define FREE_ONE(p)                delete (p)
#define FREE_MANY(p)               delete[] (p)
/* Fin version C++ */
#else
/* Version C */
#define FROMVOID_CAST(t, p)        (p)
#define STATIC_CAST(t, x)          ((t)(x))
#define REINTERPRET_CAST(t, x)     ((t)(x))
#define CONST_CAST(t, x)           ((t)(x))
#define CAST_POINTER(dest, t, p)   do{ void* dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }while(0)
#define CAST_POINTER_(dest, t, p)    { void* dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }
#define CAST_POINTERC(dest, t, p)  do{ void const * dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }while(0)
#define CAST_POINTERC_(dest, t, p)   { void const * dest ## _tmp_ ## p = p; dest = dest ## _tmp_ ## p; }
#define ALLOC_ONE(t)               malloc(sizeof(t))
#define ALLOC_MANY(t,n)            malloc(sizeof(t)*(n))
#define FREE_ONE(p)                free(p)
#define FREE_MANY(p)               free(p)
/*Fin opérateurs de cast*/
#endif
 
#endif/* ! CASTING_H_INCLUDED */

C'est du boulot surtout que je ne connais pas la majorité de ces cast C++ (mais comme je ne suis pas un expert C++...). Mais à quoi servent ces "do {...} while(0)" ? Je sens bien là une astuce de folie pour éviter un gros problème mais j'arrive pas à voir lequel...