Pourquoi écrire que 1 000 000 000 d'1000*1000*1000 en C?

Dans le code créé par Apple, il y a cette ligne:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

Est-il une raison à exprimer 1,000,000,000 comme 1000*1000*1000?

Pourquoi ne pas 1000^3 pour que la matière?

  • La clarté et la lisibilité du code. Vous ne pouvez pas le mettre , ou " comme séparateurs dans C, de sorte que la prochaine meilleure chose, c'est le calcul de la valeur à partir d'une multiplication. ^ est un autre opérateur en C - OU-exclusif.
  • il est surtout utilisé pour des durées comme : 2*60*60 .. c'est facile de remarquer que est de 2 heures..
  • Pour celui que je soupçonne 1,000,000,000 n'est pas valide la syntaxe
  • Même s'il était valide la syntaxe, de la syntaxe doivent être localisées. Dans de grandes parties du monde", " est la marque décimale.
  • Par la voie, de langages de programmation modernes ont autre façon d'écrire la même chose, par exemple dans Swift 1_000_000_000. Cependant, avec des constantes de temps c'est plus difficile. C'est plus lisible d'écrire 30 * 60 (30 minutes en secondes) que de l'écrire 1800. Il ya effectivement des langues qui va vous permettre d'écrire des unités, par exemple meters, vous permettant de vous protéger contre les mauvaises affectations.
  • Un plus léger avantage de 1000*1000*1000 plus de 1000^3 (si l'alimentation de l'opérateur existe dans la langue), c'est qu'il est plus facile de voir l'ordre de grandeur rapidement.
  • Pour la même raison 1.0f / 255 est plus lisible que 0.0039215689f. Voir ce post.
  • Aussi, comme une note de côté, si il y en a de beaucoup de travail avec les unités physiques, regardez pour les bibliothèques qui fournissent des classes pour les unités d'écrire, par exemple, 1000 * Kilometers ou 15_min.
  • ^ est un XOR, pas un exposant ou de la puissance de l'opérateur.
  • Voir ce commentaire.
  • En C++, 1,000,000,000 est une erreur de syntaxe, et evalues pour 0.
  • comme pour moi, il est plus à l'aise de voir que 1e9 1000*1000*1000 🙂
  • Êtes-vous demander à propos de C ou Objective-C?
  • bien, mais ce serait un double littérale, pas un int.
  • euh...de sorte que vous pouvez le convertir en int en place si vous avez besoin d' 🙂
  • (1,000,000,000) == 0
  • C++ prend désormais en charge 1'000'000!
  • - Vous déjà entendu parler de l'erreur d'arrondi?
  • Lèche C spécifie le minimum de précision et une gamme de double. Le double de @kot331107, 1e9, est dans la gamme et exactement représentable comme un double, donc pas d'erreur d'arrondi se produit lors de la conversion de 32(plus) bits entier. Les plus grandes valeurs peuvent avoir arrondi.
  • FWIW, La gcc préprocesseur va accepter #define BILLION 1000 ## 000 ## 000, si le compilateur n'accepte pas 1000 ## 000 ## 000 comme un littéral. Vous ne savez pas si cela s'applique à objective-c ou pas.
  • Double Possible de Représentant des grands nombres dans le code source, pour des raisons de lisibilité?
  • connexes: Pourquoi le C analyseur de ne pas autoriser les espaces entre les chiffres d'un entier littéral?, Pourquoi le caractère espace n'a pas choisie pour C++14 chiffres de séparateurs?
  • erreur d'arrondi avec (int)1e9 ?
  • Peut-être pas pour cette valeur, mais si vous avez utilise habituellement le régime, vous obtiendrez peu.
  • D'accord, mais cette certaine valeur 1e9.

InformationsquelleAutor SpaceDog | 2016-11-16
  1. 193

    Une raison pour déclarer des constantes multiplicatives façon est d'améliorer la lisibilité, pendant le temps de la performance n'est pas affectée.
    Aussi, pour indiquer que l'auteur a été pensée de manière multiplicative sur le nombre.

    Considérez ceci:

    double memoryBytes = 1024 * 1024 * 1024;

    C'est clairement mieux que:

    double memoryBytes = 1073741824;

    que ce dernier ne semble pas, au premier coup d'œil, le troisième bloc de 1024.

    Comme Amin Negm-Awad mentionné, la ^ l'opérateur est le binaire XOR. De nombreuses langues manque intégré, au moment de la compilation opérateur exponentiel, d'où la multiplication.

    • Et dans les langues qui ont un opérateur exponentiel, il n'est pas nécessairement '^'. En Fortran, par exemple, c'est '**'.
    • Vous devez également inclure un lien pointant vers la mise en garde importante, mentionnée dans la réponse ci-dessous, à partir de @chux : stackoverflow.com/a/40637622/1841533 (d'autant que les OP tagged "c", qui est très sensible à cette " droite-côté de l'opération semblent avoir tous les termes limité à un type plus petit, et donc la multiplication peut déborder problème). securecoding.cert.org/confluence/display/c/... peut aider à éviter ces dans le cas général?
    • Il convient également de noter que le calcul est effectué au moment de la compilation. La Norme exige la mise en œuvre pour être en mesure de calculer des expressions constantes au moment de la compilation pour les différentes fonctions de la langue, et nous pouvons supposer, il est vrai, lorsqu'une expression constante est utilisée, comme dans cet exemple.
    • Le stockage de mémoire qu'un double? Cela semble être une source potentielle d'erreur.
    • Here une question que j'avais posée sur le signe de l'opérateur a été choisi pour XOR qui pourrait expliquer un certain nombre de choses.
    • Toutes les valeurs entières jusqu'à et y compris 9,007,199,254,740,992 sont exactement représentable. Les Machines ne disposent généralement pas que la quantité de mémoire encore, et si l'on considère l'espace de disque dur, qui sont souvent attribués par blocs de 4096 octets, de sorte que le nombre de ces blocs dans une machine avec jusqu'à 36,893,488,147,419,103,232 octets de stockage. Peut-être que certaines de ces machines existent, mais elles ne sont certainement pas banal à compter de 2016.
    • Je suis conscient de cela, mais en utilisant le double, vous pourriez avoir un cas où, par exemple, vous voulez une partie de la mémoire de la plage, vous divisez par x pour obtenir la taille de la sous-intervalle... et tout à coup vous avez une fraction d'octets, ce qui peut nécessiter de la logique supplémentaire pour compenser.
    • pensez-vous que nous voulions plein octets? Nous avons seulement besoin d'un nybble ou deux."

    InformationsquelleAutor Piotr Falkowski
  2. 72

    Pourquoi ne pas 1000^3?

    Le résultat de 1000^3 est 1003. ^ est le bit-opérateur XOR.

    Même qu'elle ne traite pas avec le Q, j'ai ajouter une précision. x^y ne pas toujours évaluer à x+y comme il le fait dans la interlocuteur de l'exemple. Vous devez xor chaque bit. Dans le cas de l'exemple:

    1111101000₂ (1000₁₀)
0000000011₂ (3₁₀)
1111101011₂ (1003₁₀)

    Mais

    1111101001₂ (1001₁₀)
0000000011₂ (3₁₀)
1111101010₂ (1002₁₀)
    • monsieur, je ne suis pas clair comment 1003^3 est 1003. Google et Mac Calculatrice indique 1000^3 = 1 000 000 000 d'. pouvez-vous expliquer?
    • Le ^ opérateur XOR en C/C++/Objective-C etc. Dans les calculateurs, cela signifie généralement des x-de-la-y de pouvoir.
    • Bah, les bits de 1000 et 3 ne se chevauchent pas. Cela ressemble si mal.
    • Les bits ne se chevauchent. Mais pas la 1 du. :-]
    • en effet, il a l'air si mal ! ... J'espère que beaucoup de gens ne pense pas que "A^B" donne toujours A+B (mais je crains que certains pourraient...)
    • Je vais ajouter une explication.
    • Fait amusant: XOR est ajouter-sans-porter (en binaire, pas de chiffres après la virgule).
    • Pas vraiment un plaisir de fait. Quand j'ai commencé à développer des ordinateurs, il n'était pas rare de construire additionneur-vous des portes. Cependant, il semble que "près d'un additionneur", mais donne de mauvais résultats dans 99 % des cas, l'ajout de deux nombres 16 bits.
    • XOR n'est certainement donner de mauvais résultats dans 99% des cas, l'ajout de deux nombres 16 bits. En fait, c'est seulement correcte (100 * (3/4)^n) pour cent du temps lors de l'ajout de deux n-bits.
    • C'est exactement la façon dont j'ai calculé qu'.
    • si les gens pensent que A^B signifie que A+B et écrire l'ancienne à la place de ce dernier pour un look smart et finissent par faire des erreurs, ils ne méritent pas d'être des programmeurs

    InformationsquelleAutor Amin Negm-Awad
  3. 63

    Il y a des raisons pas à utiliser 1000 * 1000 * 1000.

    Avec 16 bits int, 1000 * 1000 les débordements. Donc, en utilisant 1000 * 1000 * 1000 réduit la portabilité.

    Avec 32-bit int, à la suite de débordements.

    long long Duration = 1000 * 1000 * 1000 * 1000;  //overflow
long long Duration = 1000000000000;  //no overflow, hard to read

    Suggèrent que la valeur correspond au type de la destination pour des raisons de lisibilité, la portabilité et exactitude.

    double Duration = 1000.0 * 1000 * 1000;
long long Duration = 1000LL * 1000 * 1000 * 1000;

    Pourrait également simple d'utilisation e notation pour les valeurs qui sont exactement représentable comme un double. Bien sûr, cela conduit à savoir si double peut représenter avec exactitude la valeur de nombre entier - quelque chose de préoccupation avec des valeurs supérieures à 1e9. (Voir DBL_EPSILON et DBL_DIG).

    long Duration = 1000000000;
//vs.
long Duration = 1e9;
    • Très remarque importante ! securecoding.cert.org/confluence/display/c/... peut aider dans beaucoup de cas?
    • Un double peut exactement représenter tous les entiers jusqu'à 2^53 ≈ 9e15.
    • Vrai que binary64 peut représenter un nombre entier allant jusqu'à environ 9e15. Mais C n'a pas de spécifier double utilisation de binary64, même si elle est très couramment utilisée. Par le C spec, des valeurs jusqu'à 1e9 sont exactement représentable. Cela dépend de si vous voulez le code de spécification ou de s'appuyer sur des pratiques communes.
    • Pourquoi, de longue de longue Durée = 1 billion de' dépassement de capacité si vous y arriver avec de la multiplication, mais pas autrement?
    • Les deux 1000 et 1000000000000 sont les constantes entières. Chacun de façon indépendante avec le type sélectionné à partir de int, long ou long long. Le compilateur utilise le premier type de ces 3, dans lequel le constante entière s'adapte. 1000 * 1000 * 1000 * 1000 est fait avec int mathématiques comme chaque 1000 dans un int. Le produit déborde de 32 bits int. 1000000000000 est certainement représentable comme un long long (ou peut-être plus étroite) - pas de débordement. Le type de la cible long long Duration n'affecte pas ce "côté droit de l' =" detemrination.
    • En plaçant le plus large d'abord, d'où la multiplication est important. Avec 16 bits int, long x = 1000 * 1000 * 1000L; serait de débordement, tout en long x = 1000L * 1000 * 1000; ne le serait pas.

    InformationsquelleAutor chux
  4. 50

    Pour des raisons de lisibilité.

    Placer les virgules et des espaces entre les zéros (1 000 000 000 ou 1,000,000,000) produirait une erreur de syntaxe, et d'avoir 1000000000 dans le code, ce qui rend difficile de voir exactement combien de zéros sont là.

    1000*1000*1000 il ressort que c'est 10^9, parce que nos yeux peuvent traiter les morceaux plus facilement. Aussi, il n'y a pas d'exécution de coût, parce que le compilateur remplacera avec la constante 1000000000.

    • Pour info, il existe un concept de chiffres séparateurs que j'ai appris récemment. Java a eu pendant un certain temps maintenant, et C# 7.0 peut l'obtenir. Je souhaite à toutes les langues aurait cet eye-candy fonctionnalité. 🙂
    • En fonction du contexte à l'aide de 1,000,000,000 ne produit pas d'erreur de syntaxe, il serait juste de dire autre chose. Par exemple CMTimeMakeWithSeconds( newDurationSeconds, 1,000,000,000 )
    • C# est déjà si vous installez VS15 version preview, peut être écrite comme 1_000_000_000
    • Python est arriver _ comme séparateur, trop 🙂
    • Et le C++ a récemment obtenu le ' séparateur, en C++14, de sorte que vous pouvez utiliser 1'000'000'000. (Il a été choisi parce que 1,000,000,000 pourrait être interprété à tort comme l'opérateur virgule ou 4 paramètres distincts, et _1_000_000_000 est valide (mais probablement mauvais) nom de la variable.)
    InformationsquelleAutor Tamás Zahola
  5. 25

    Pour des raisons de lisibilité. Pour comparaison, Java prend en charge _ en nombre afin d'améliorer la lisibilité (d'abord proposée par Stephen Colebourne comme un répondre à Derek Foster PROPOSITION: Binaire Littéraux pour Projet de Pièce de monnaie/JSR 334) . On pourrait écrire 1_000_000_000 ici.

    À peu près dans l'ordre chronologique, de la plus ancienne de soutien à la plus récente:

    C'est un élément relativement nouveau pour les langues à réaliser qu'ils doivent appuyer (et puis il y a Perl). Comme dans chux@'s réponse excellent, 1000*1000... est une solution partielle, mais qui ouvre le programmeur à des bugs de débordement de la multiplication, même si le résultat final est un grand type.

    • De nombreux langages de programmation modernes ont le même, par exemple Swift. Rien de nouveau.
    • Autant que je sache, cela vient de Perl. PL/M utilisé $ pour le même but, l'e.g: 0100$0010B
    • est assez nouveau, cependant. La fonctionnalité est peut-être de 5 ans. La plupart des autres langues de l'appui de cette syntaxe sont assez nouveau -- Swift lui-même est seulement un quelques années. Python ajoute la prise en charge en 3.6, qui n'a pas encore été dévoilé.
    • C++14, a cette avec 1'000000'000. Je trouve ça très pratique pour les constantes de l'écriture en binaire: 0b11'10'01'00 ou quelque chose pour un échange ou d'un mélange de contrôle arg à une valeur intrinsèque.
    • Voir l'historique de la révision de cette. C'était un non-post.
    • Ada a pris en charge le souligne dans les littéraux entiers depuis 33 ans maintenant.
    • Python 3.6: 10**9 ou 1 000**3. À moins que j'ai raté quelques mise à jour importante, les chiffres ne peuvent être des chiffres.
    • Btw, je pense que l'écriture 1000000000 ou 1000*1000*1000 est l'équivalent en C, nécessitant l'identique de la compilation dépassement de temps de diagnostic, le cas échéant (une valeur dans le type du représentable valeurs est une compilation contrainte de temps pour les constantes ainsi que pour les expressions constantes).
    • J'ai pris la liberté d'ajouter plus d'informations, à peu près dans l'ordre chronologique. Je me suis trompé avant, à en juger par le Projet de Pièce de monnaie de fil, Stephen Colebourne probablement eu l'idée de trait de soulignement dans les littéraux entiers à partir du Fandom et/ou Ruby. Ruby a probablement eu l'idée de Perl, Perl et de l'Ada.
    • Maintenant que nous sommes bien au-delà de quelque chose qui pourrait être relégué à un commentaire, je rétracte tous les anciens commentaires et des votes. Le roi est mort, vive le roi!

    InformationsquelleAutor djechlin
  6. 6

    Qui pourrait être plus simple à lire et à obtenir certaines associations avec la 1,000,000,000 forme.

    De l'aspect technique je suppose qu'il n'y a pas de différence entre le nombre direct ou de multiplication. Le compilateur va générer constante milliards de numéro de toute façon.

    Si vous parlez d'objective-c, puis 1000^3 ne fonctionne pas car il n'existe pas de syntaxe pour pow (il est xor). Au lieu de cela, pow() fonction peut être utilisée. Mais dans ce cas, il ne sera pas optimal, il sera à l'exécution de l'appel de fonction pas un, généré par le compilateur constante.

    InformationsquelleAutor Madars Vi
  7. 2

    Pour illustrer les raisons de considérer le programme de test suivant:

    $ cat comma-expr.c && gcc -o comma-expr comma-expr.c && ./comma-expr
#include <stdio.h>

#define BILLION1 (1,000,000,000)
#define BILLION2 (1000^3)

int main()
{
        printf("%d, %d\n", BILLION1, BILLION2);
}
0, 1003
$
    InformationsquelleAutor Peter A. Schneider
  8. 0

    Une autre façon d'obtenir un effet similaire en C pour des nombres décimaux est d'utiliser littérale à virgule flottante notation-tant qu'un double peut représenter le nombre que vous voulez sans aucune perte de précision.

    IEEE 754 double de 64 bits peut représenter n'importe quel nombre entier non négatif <= 2^53, sans problème. Généralement, long double (80 ou 128 bits) peut aller encore plus loin. Les conversions sera fait au moment de la compilation, il n'y a pas de gestion d'exécution et vous aurez probablement obtenir des avertissements si il y a une perte soudaine de la précision et vous avez un bon compilateur.

    long lots_of_secs = 1e9;
    InformationsquelleAutor jschultz410