salut
Je me demande quel est l'interet d'appeler la fonction exit() plutot que
return.
Par exemple, si j'ai le programme suivant:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
(void) printf("salutn") ;
return EXIT_SUCCESS ;
}
et celui-ci:
int main(void)
{
(void) printf("salutn") ;
exit(EXIT_SUCCESS) ;
}
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
salut
Je me demande quel est l'interet d'appeler la fonction exit() plutot que
return.
Par exemple, si j'ai le programme suivant:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
(void) printf("salutn") ;
return EXIT_SUCCESS ;
}
et celui-ci:
int main(void)
{
(void) printf("salutn") ;
exit(EXIT_SUCCESS) ;
}
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
salut
Je me demande quel est l'interet d'appeler la fonction exit() plutot que
return.
Par exemple, si j'ai le programme suivant:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
(void) printf("salutn") ;
return EXIT_SUCCESS ;
}
et celui-ci:
int main(void)
{
(void) printf("salutn") ;
exit(EXIT_SUCCESS) ;
}
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
salut
Je me demande quel est l'interet d'appeler la fonction exit() plutot que
return.
Par exemple, si j'ai le programme suivant:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
(void) printf("salutn") ;
return EXIT_SUCCESS ;
}
et celui-ci:
int main(void)
{
(void) printf("salutn") ;
exit(EXIT_SUCCESS) ;
}
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
did
did what ?-)
salut
Je me demande quel est l'interet d'appeler la fonction exit() plutot que
return.
Par exemple, si j'ai le programme suivant:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
(void) printf("salutn") ;
return EXIT_SUCCESS ;
}
et celui-ci:
int main(void)
{
(void) printf("salutn") ;
exit(EXIT_SUCCESS) ;
}
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
did
did what ?-)
salut
Je me demande quel est l'interet d'appeler la fonction exit() plutot que
return.
Par exemple, si j'ai le programme suivant:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
(void) printf("salutn") ;
return EXIT_SUCCESS ;
}
et celui-ci:
int main(void)
{
(void) printf("salutn") ;
exit(EXIT_SUCCESS) ;
}
Qu'est-ce que ca change? Je comprend pas tres bien...si quelqu'un peut
m'eclairer. :)
did
did what ?-)
void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
Emmanuel Delahaye wrote:void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
Quel est l'interêt de mettre une boucle do { ... } while(0) ?
De même la construction (a)?b:c est-elle vraiment plus rapide qu'un
if-else avec les compilateurs actuels faisant de l'optimisation ?
Ca me fait penser à cet boucle :
for(i=0; i < n; ++i) { ... }
où le prof nous disait qu'il parassait que de mettre ++i générait un
code plus rapide que la même boucle avec i++...
Et j'ai attendu ça de la bouche d'autre personne. Alors, légende ou
bien était-ce vrai à l'époque où les compilateurs n'optimisaient pas
bien ?
Emmanuel Delahaye wrote:
void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
Quel est l'interêt de mettre une boucle do { ... } while(0) ?
De même la construction (a)?b:c est-elle vraiment plus rapide qu'un
if-else avec les compilateurs actuels faisant de l'optimisation ?
Ca me fait penser à cet boucle :
for(i=0; i < n; ++i) { ... }
où le prof nous disait qu'il parassait que de mettre ++i générait un
code plus rapide que la même boucle avec i++...
Et j'ai attendu ça de la bouche d'autre personne. Alors, légende ou
bien était-ce vrai à l'époque où les compilateurs n'optimisaient pas
bien ?
Emmanuel Delahaye wrote:void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
Quel est l'interêt de mettre une boucle do { ... } while(0) ?
De même la construction (a)?b:c est-elle vraiment plus rapide qu'un
if-else avec les compilateurs actuels faisant de l'optimisation ?
Ca me fait penser à cet boucle :
for(i=0; i < n; ++i) { ... }
où le prof nous disait qu'il parassait que de mettre ++i générait un
code plus rapide que la même boucle avec i++...
Et j'ai attendu ça de la bouche d'autre personne. Alors, légende ou
bien était-ce vrai à l'époque où les compilateurs n'optimisaient pas
bien ?
Personellement, j'utilise exit() dans mon 'ASSERT()' maison, qui permet une
sortie plus propre que le assert() standard sur ma plateforme de debug.
Personellement, j'utilise exit() dans mon 'ASSERT()' maison, qui permet une
sortie plus propre que le assert() standard sur ma plateforme de debug.
Personellement, j'utilise exit() dans mon 'ASSERT()' maison, qui permet une
sortie plus propre que le assert() standard sur ma plateforme de debug.
for(i=0; i < n; ++i) { ... }
où le prof nous disait qu'il parassait que de mettre ++i générait un
code plus rapide que la même boucle avec i++...
C'est n'importe quoi.Et j'ai attendu ça de la bouche d'autre personne. Alors, légende ou
bien était-ce vrai à l'époque où les compilateurs n'optimisaient pas
bien ?
Ne pas être capable d'optimiser à ce niveau, c'est nul. Et puis
pour les compilo qui n'optimisent pas, il n'y a pas de raison pour
que l'une forme soit systématiquement plus rapide que l'autre.
for(i=0; i < n; ++i) { ... }
où le prof nous disait qu'il parassait que de mettre ++i générait un
code plus rapide que la même boucle avec i++...
C'est n'importe quoi.
Et j'ai attendu ça de la bouche d'autre personne. Alors, légende ou
bien était-ce vrai à l'époque où les compilateurs n'optimisaient pas
bien ?
Ne pas être capable d'optimiser à ce niveau, c'est nul. Et puis
pour les compilo qui n'optimisent pas, il n'y a pas de raison pour
que l'une forme soit systématiquement plus rapide que l'autre.
for(i=0; i < n; ++i) { ... }
où le prof nous disait qu'il parassait que de mettre ++i générait un
code plus rapide que la même boucle avec i++...
C'est n'importe quoi.Et j'ai attendu ça de la bouche d'autre personne. Alors, légende ou
bien était-ce vrai à l'époque où les compilateurs n'optimisaient pas
bien ?
Ne pas être capable d'optimiser à ce niveau, c'est nul. Et puis
pour les compilo qui n'optimisent pas, il n'y a pas de raison pour
que l'une forme soit systématiquement plus rapide que l'autre.
Emmanuel Delahaye wrote:void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
Quel est l'interêt de mettre une boucle do { ... } while(0) ?
Emmanuel Delahaye wrote:
void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
Quel est l'interêt de mettre une boucle do { ... } while(0) ?
Emmanuel Delahaye wrote:void SYS_assertfail (char const *exp
,char const *file
,int line);
#ifndef NDEBUG
#define ASSERT(a)
do
{
(a) ? (void)0 : SYS_assertfail (#a
, __FILE__
, __LINE__
);
}
while (0)
#else
#define ASSERT(a) ((void)0)
#endif
Quel est l'interêt de mettre une boucle do { ... } while(0) ?
Alors d'accord, c'est une super vieille architecture, c'est plus
vraiment utilise (meme les applis embarques utilisent des PowerPC et
autres SPARCs maintenant), mais que ++i produise du code plus rapide
que i++ c'est pas n'importe quoi. C'est juste vieux et perime.
Alors d'accord, c'est une super vieille architecture, c'est plus
vraiment utilise (meme les applis embarques utilisent des PowerPC et
autres SPARCs maintenant), mais que ++i produise du code plus rapide
que i++ c'est pas n'importe quoi. C'est juste vieux et perime.
Alors d'accord, c'est une super vieille architecture, c'est plus
vraiment utilise (meme les applis embarques utilisent des PowerPC et
autres SPARCs maintenant), mais que ++i produise du code plus rapide
que i++ c'est pas n'importe quoi. C'est juste vieux et perime.
