Salut les (ex) Zér0s,

Je commence l'apprentissage du C++ et je suis actuellement aux types de données en C++

Pour les floats, il est possible d'ajouter un suffixe f pour préciser si le nombre est de type float ou un suffixe l pour préciser si le nombre est de type long double.
Or je ne comprends pas à quoi servent ces suffixes étant donné que l'on précise déjà le type de donnée à l'initialisation de la variable
Quel est l'intérêt d'écrire

float monflottant = 14.5f

ou

double mondouble = 168.23l

?

Merci d'avance

Edit: Ah oui et quelle différence entre var++ et ++var ?

-
Edité par pitittatou 13 novembre 2018 à 20:53:09

Salut, ce sont des conventions d'écriture.
Pour ce qui est de la différence entre var++ et ++var est :

var++ renvoie la valeur puis l'incremente ensuite
++var incremente puis renvoie la valeur
Exemple : 
si i = 0 : cout <<i++<<; // renvoie affiche 0 puis incremente i
cout <<++i<<; //incremente i et affiche la valeur, affiche donc 1

D'accord merci beaucoup pour ce qui est de ++
Par contre je ne comprends pas les conventions d'écriture. A quoi cela sert-il d'écrire quelquechose d'inutile, ce n'est pas dans l'idée que je me fais du C++. De plus j'ai vu pendant mes recherches que cela avait un impact réel sur la taille de la donnée. Mais dans quels cas utiliser f et l ?

J'ai vu qu'il était possible d'écrire

double mondouble = 14.3f

De quel type est alors mondouble ?

Et j'ai aussi vu que sans suffixe f la donnée est automatiquement de type double alors à quoi sert le float d'initialisation ?

Désole pour mon flot de questions mais je n'arrive vraiment pas à saisir le principe

Melin Alexandre a écrit:

var++ renvoie la valeur puis l'incrémente ensuite

Ce qui implique que l'opérateur de post-incrémentation crée une copie (même si on ne l'utilise pas).

En conséquence, préférer l'operateur de pré-incrémentation (++var).

double monDouble = 14.3f;

La variable est du type double, le type demandé est toujours celui de la variable. On a initialisé la variable à partir de la valeur d'un float. A ton avis que fais ce code :

if ( monDouble == 14.3 ) std::cout << "on a bien 14.3" << std::endl;
else std::cout << "la valeur n'est pas 14.3!!!" << std::endl;

Et oui, les deux valeurs 14.3f et 14.3 sont différentes! C'est dû au fait que les nombre flottants sont stockés en base 2. En base 2, la valeur 14.3 est constituée d'une infinité de décimales (comme l'est 1/3 en base 10) et le double étant plus précis que le float les décimales ne sont pas les même.

Le 'f' à la fin sert donc bien à quelque chose. Ici, il sert à faire une énorme bourde!
La valeur sans suffixe correspond à un double, c'est plus sécuritaire car une conversion double vers float a peu de risques. Inversement comme on vient de le voir, aussi bien la conversion float vers double que d'effectuer un test d'égalité sur un quelconque flottant est dangereux.

Les très rares fois où on utilise 'f' seront pour forcer une dégradation de la précision pour permettre une optimisation en taille ou en vitesse de traitement. Pour débuter, je te propose d'éviter d'utiliser le suffixe 'f'.

Il faut bien comprendre que dans "double monDouble = 14.3f" tu as 2 entités :
  monDouble qui est une variable de type double
  14.3f qui est une littérale de type float

Par conséquent tu effectues un transtypage (cast) implicite float -> double avec cette affectation

#include <iostream>

void f(float)
{
    std::cout << "appel avec un float" << std::endl;
}

void f(double)
{
    std::cout << "appel avec un double" << std::endl;
}

void f(long double)
{
    std::cout << "appel avec un long double" << std::endl;
}

int main(int, char*[])
{   
    f(14.3);   // appel avec un double
    f(14.3l);  // appel avec un long double
    f(14.3f);  // appel avec un float
    
    {
        double monDouble = 14.3f; // affectation d'un float dans un double
        f(monDouble);  // appel avec un double quand même
    }
    
    return 0;
}

-
Edité par romantik 15 novembre 2018 à 16:38:09