Que signifie "int i = 1;Why (i >= 60 * 60 * 1000 / 1 * 1000)" ?

Question

D'abord, définir deux expressions constantes sans parenthèses est ma faute :

#define BIG_INTERVAL 60 * 60 * 1000
#define SMALL_INTERVAL 1 * 1000

int i = 1;

if (i >= BIG_INTERVAL / SMALL_INTERVAL - 1)
{
    printf("Oops!\n");
}

En if après l'expansion de la macro est if(i >= 60 * 60 * 1000 / 1 * 1000 - 1) .

Ce n'est pas mon intention. Mais je trouve quelque chose d'étrange si j'écris if (i >= 3600000000 - 1) . C'est faux.

Quel type est 60 * 60 * 1000 / 1 * 1000 - 1 ? int ?

Answer 1

Il est fort probable que vous sortez de la plage de valeurs valables pour un nombre entier signé - 3600000000 est un grand nombre !

Lorsque cela se produit, la valeur devient la plus petite valeur négative pour le type de données int.

Ainsi, votre affirmation sera vraie.

Answer 2

Chacun des arguments de cette expression est un nombre entier, le résultat sera donc un nombre entier.

Answer 3

Je pense que vous ne comprenez pas bien le fonctionnement des macros. Vous n'utilisez pas les valeurs de ces macros mais les équations elles-mêmes. Je pense que c'est là que réside votre confusion. Je pense que vous devriez mettre des parenthèses dans vos macros ou ne pas utiliser de macros.

Answer 4

Je n'ai vu personne mentionner le fait que même en mettant les définitions des macros entre parenthèses, le problème n'est pas complètement résolu.

La question a :

#define BIG_INTERVAL 60 * 60 * 1000

(et l'auteur de la question reconnaît que l'absence de parenthèses est un problème). Mais même avec :

#define BIG_INTERVAL (60 * 60 * 1000)

chacune des constantes (60, 60 et 1000) est bien représentable comme un int, mais le produit est 3600000, alors que le langage garantit seulement que INT_MAX >= 32767 .

Le langage dit que les constantes entières sont d'un type suffisamment grand pour contenir leurs valeurs (par exemple, 100000 peut être de type int ou de type long int selon les plages de ces types), mais il n'a pas de règle de ce type pour les expressions, même les expressions constantes.

Vous pouvez contourner ce problème de la manière suivante :

#define BIG_INTERVAL (60L * 60L * 1000L)

mais cela le rend de type long même si ce n'est pas nécessaire.

Quant à la question de la préséance des opérateurs, voici mon exemple préféré :

#include <stdio.h>

#define SIX 1+5
#define NINE 8+1

int main(void)
{
    printf("%d * %d = %d\n", SIX, NINE, SIX * NINE);
    return 0;
}

Le résultat, bien sûr, est

6 * 9 = 42

(voir Douglas Adams).