Les variables j'ai catalogué lorsque vous effectuez des opérations mathématiques en C/C++?

Par exemple, quand je suis à la division de deux entiers et qui veulent un flotteur de retour, j'ai superstitiously écrire quelque chose comme ceci:

int a = 2, b = 3;
float c = (float)a / (float)b;

Si je n'ai pas jeté a et b de flotteurs, il va faire de division entière et retourner un int.

De la même façon, si je veux multiplier signé un nombre de 8 bits avec un entier non signé de 8 bits, je vais la jeter à signé de 16 bits avant de multiplier par crainte de débordement:

u8 a = 255;
s8 b = -127;
s16 = (s16)a * (s16)b;

Comment fonctionne exactement le compilateur se comporter dans ces situations, lorsqu'il n'est pas de la coulée, ou lors de la coulée seulement l'une des variables? Ai-je vraiment besoin de convertir explicitement toutes les variables, ou tout simplement celle de gauche ou celle de droite?

InformationsquelleAutor Jeremy Ruten | 2008-10-29
  1. 26

    Question 1: Float division

    int a = 2, b = 3;
float c = static_cast<float>(a) / b;  //need to convert 1 operand to a float

    Question 2: Comment le compilateur travaille

    Cinq règles d'or à retenir:

    • Opérations arithmétiques sont toujours effectuées sur des valeurs de même type.
    • Le type de résultat est le même que les opérandes (après la promotion)
    • Le plus petit type arithmétique des opérations sont effectuées sur des est int.
    • ANSCI C (et donc C++) de la valeur d'usage de préserver entier de promotion.
    • Chaque opération se fait dans l'isolement.

    Le C ANSI règles sont les suivantes:

    La plupart de ces règles s'appliquent également aux C++ mais pas tous les types sont officiellement pris en charge (encore).

    • Si l'un des deux opérandes est un long double l'autre est converti en long double.
    • Si l'un des deux opérandes est un double l'autre est converti en double.
    • Si l'un des deux opérandes est un float l'autre est converti en float.
    • Si l'un des deux opérandes est un unsigned long long l'autre est converti en unsigned long long.
    • Si l'un des deux opérandes est un long l'autre est converti en long.
    • Si l'un des deux opérandes est un unsigned long l'autre est converti en unsigned long.
    • Si l'un des deux opérandes est un long l'autre est converti en long.
    • Si l'un des deux opérandes est un unsigned int l'autre est converti en unsigned int.
    • Sinon, à la fois opérandes sont convertis int.

    Débordement

    Débordement est toujours un problème. Remarque. Le type du résultat est le même que l'entrée d'opérandes de sorte que toutes les opérations peuvent déborder, donc oui, vous ne devez pas vous inquiéter à ce sujet (bien que la langue ne fournit pas de manière explicite pour attraper ce qui se passe.

    Comme une note de côté:

    Unsigned division ne peut pas de débordement, mais signé division.

    std::numeric_limits<int>::max() / -1  //No Overflow
std::numeric_limits<int>::min() / -1  //Will Overflow
    • Belle vue d'ensemble - peut-être utiliser le terme "promotion" iso "converti"?
    • "Le dépassement est toujours un problème". Sauf qu'une fois-dans-un-vie cas où l'arithmétique modulo est ce que vous voulez vraiment.
    InformationsquelleAutor Martin York
  2. 13

    En général, si les opérandes sont de différents types, le compilateur va promouvoir tout à la plus grande ou la plus précise du type:

    Si un seul numéro est... Et l'autre est... Le compilateur fera la promotion de... 
------------------- ------------------- ------------------------------- 
char int int 
signé non signé non signé 
char ou int float float 
float double double

    Exemples:

    char + int ==> int 
signé int + unsigned char ==> unsigned int 
flotteur + int ==> float

    Méfiez-vous, cependant, que la promotion se produit uniquement lorsque cela est nécessaire pour chaque calcul intermédiaire, donc:

    4.0 + 5/3 = 4.0 + 1 = 5.0

    C'est parce que la division entière est réalisée en premier, puis le résultat est promu à flotteur pour le plus.

    • Je pense que vous vouliez dire "signé + unsigned = signée"?
    • Kasprzol: Les règles de promouvoir signé vars non signé; la promotion est généralement à partir de la plus petite à la plus grande des types, puis à partir de signé non signé.
    InformationsquelleAutor Adam Liss
  3. 5

    Vous pouvez juste lancer l'un d'eux. Il n'est pas n'importe qui un bien.

    Chaque fois que les types ne correspondent pas, la "petite" de type est automatiquement promu le "plus" de type, avec virgule flottante être "plus" que les types integer.

    InformationsquelleAutor Matthew Crumley
  4. 2

    Division de nombres entiers: fonte d'un des opérandes, pas besoin de les jeter à la fois. Si les deux opérandes sont des entiers, l'opération de division est une division entière, sinon c'est une division flottante.

    Comme pour le dépassement de la question, il n'est pas nécessaire de convertir explicitement, comme le compilateur implicitement le fait pour vous:

    #include <iostream>
#include <limits>

using namespace std;
int main()
{
    signed int a = numeric_limits<signed int>::max();
    unsigned int b = a + 1; //implicit cast, no overflow here
    cout << a << ' ' <<  b << endl;
    return 0;
}
    InformationsquelleAutor wilhelmtell
  5. 1

    Dans le cas de la division flottante, tant qu'une variable est de un virgule flottante type de données (float ou double), puis de l'autre variable devrait être élargi à une variable de type point, et la division flottante devrait se produire; il n'ya donc pas besoin de vous jeter à l'eau.

    Cela dit, j'ai toujours jeté à la fois à un flotteur, de toute façon.

    InformationsquelleAutor mipadi
  6. 1

    Je pense que tant que vous êtes casting juste l'une des deux variables, le compilateur se comporter correctement (Au moins sur les compilateurs que sais-je).

    Donc tous:

    float c = (float)a /b;

    float c = a /(float)b;

    float c = (float)a /(float)b;

    aura le même résultat.

    InformationsquelleAutor user21785
  7. 1

    Puis il y a des anciens du cerveau endommagées par des types comme moi qui, ayant à utiliser l'ancienne langues, tout sans réfléchir écrire des trucs comme

    int a;
int b;
float z;

z = a*1.0*b;

    Bien sûr, ce n'est pas universel, ne sont bons qu'à peu près juste ce cas.

    InformationsquelleAutor DarenW
  8. 1

    Ayant travaillé dans le domaine de la sécurité des systèmes critiques, j'ai tendance à être parano et toujours fonte de deux facteurs: float(a)/float(b) - juste au cas où certains subtil gotcha est de la planification à la mords-moi plus tard. Peu importe la façon dont le compilateur est dit, peu importe comment bien défini les détails sont dans la langue officielle de spécifications. Paranoïa: un programmeur est le meilleur ami de!

    InformationsquelleAutor DarenW
  9. 0

    Avez-vous besoin de jeter un ou deux côtés? La réponse n'est pas dicté par le compilateur. Il doit savoir exactement, precse règles. Au lieu de cela, la réponse doit être dicté par la personne qui va lire le code plus tard. Pour cette seule raison, la fonte de deux côtés d'un même type. Implicite de la troncature peut être suffisamment visible, de sorte que la fonte pourrait être redondant.

    par exemple, cette fonte float->int est évident.

    int a = float(foo()) * float(c);
    InformationsquelleAutor MSalters