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

[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.

[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 */

[Emmanuel Delahaye]

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++ ??

J'ai pas dit ça. J'ai dit qu'un source C (donc écrit selon les règles du C), compilé avec un compilateur C++ (donc avec d'autres règles), invoque un comportement indéfini. C'est tout. Il y a probablement des codes qui sont valables en C et en C++, mais c'est plus par hasard qu'autre chose. Bonne réalisation et hasard ne font pas bon ménage.

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)...

A priori, c'est du C++ ( () signifie 'pas de paramètres' en C++, mais pas en C). En C, on mettrait :

Code :

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

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

voire

Code :

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

1
2
3
int main(void)
{
}

en C99.