Problème de précision en C++

Le problème est qu'il n'y pas eu de préconisation. Mais à un moment, les notations ont évolués la fonction fabs() retournait un float, et la syntaxe à évolué en :
float fabsf( float arg );
double fabs( double arg );
long double fabsl( long double arg );
Ça a été officialisé avec le C99, mais les compilateurs de l'époque avaient une option pour savoir si fabs() et autres retournaient un float ou un double.

De même pour indiquer un littéral flottant on ajoute un suffixe f, alors que le double n'en a pas besoin.
Donc le float serait alors devenu la cas particulier et le double le cas normal.
Le plus caractéristique est comment est mis un float sur la pile, il est désormais converti en double (si on donne un float à une fonction attendant un float on se prend une double conversion intermédiaire!) C'est pourquoi dans un printf() le paramètre désignant un float ou un double est désormais le même "%f".
Les processeurs de l'époque étaient même plus rapide pour les double car c'était celui qui était hardcodé. C'est moins le cas aujourd'hui avec les unités de calcul parallèles.

Ils ont gardé par contre le fait que dans un scanf, ça n'est pas le float l'exception, c'est le double qui utilise "%lf".

Alors pourquoi beaucoup de cours continuent d'utiliser les float? Je ne sais pas vraiment, mais on trouve encore des cours qui indiquent qu'on doit déclarer ses variables au début des fonctions (cf le code ci-dessus!) alors!!

PS: en fait je travaille dans l'embarqué et donc je n'utilise quasiment jamais les flottants, et si je dois je me restreint au float, car les processeurs que j'utilise n'ont pas de coprocesseurs ni d'unité flottante.

Le plus caractéristique est comment est mis un float sur la pile, il est désormais converti en double

Oui c'est le cas en C# aussi.

peux-tu partager les valeurs affichées par l'un et l'autre?

pourquoi as-tu absolument besoin que le nombre qui va être affiché soit égal à la calculatrice? de quelle calculatrice s'agit-il?

J'ai besoin que le nombre soit égal à la calculatrice parce que l'opération peux s'effectuer à la main mais je crée un programme pour automatiser cette tâche et peux importe la calculatrice qu'on utilise. Mon programme, pour le premier résultat, il affiche 44.999997467 et ce pour l'inverse du sinus, et sur la calculatrice il affiche 44,999997469, mais j'ai absolument besoins qu'ils soient égal.

Merci

non, il ne faut pas, sauf si tu veux des résultats plus précis.

D'accord mais même si je les enlèves tous et que je les remplaces par des double, le résultat va encore être différent.

peux-tu montrer le nouveau résultat?

Si je retire tout les float, voici mon code :

       #include <iostream>
    #include <list>
    #include <algorithm>
    #include <math.h>
    #include <iomanip>
    #include <windows.h>
    #define pi 3.14159265358979323846264338328
    using namespace std;

    double myArr[] = { 113, 111, 109, 107, 103, 103, 101, 100, 99, 98, 97, 95, 93, 93, 92, 91, 90, 89, 89, 87, 85, 83, 81, 80, 79, 77, 76, 75, 74, 73, 72, 71, 71, 70, 69, 67, 66, 65, 63, 62, 61, 60, 60, 59, 58, 57, 56, 55, 55, 53, 52, 51, 50, 50, 49, 48, 48, 47, 46, 46, 45, 45, 44, 43, 43, 42, 41, 40, 39, 37, 36, 36, 36, 36, 35, 34, 33, 32, 31, 30, 30, 29, 29, 26, 26, 25, 24, 24, 23, 22, 20, 20 };
    list <double> value{};
    double ele;
    double ele1;
    double ele2;
    double ele3;
    double getClosest() {    
        for (double ele : myArr) {
            for (double ele1 : myArr) {
                for (double ele2 : myArr) {
                    for (double ele3 : myArr) {
                        value.push_back((ele / ele1) * (ele2 / ele3));
                    }
                }
            }
        }
        return 0;
    }
// Fin fonction pour calculer les ratios des gear

// Début fonction pour connaitre la valeur la plus proche
    double getClosest2(double search) {
        double closest;
        closest = 0;
        double item;
        for (double item : value) {
            if (closest == 0 || abs(search - closest) > abs(item - search)) {
                closest = item;
            }
        }
        return closest;
    }
// Fin fonction pour connaitre la valeur la plus proche
int main() {
   
    // Début de l'équation pour la valeur recherche du MOD 
            double recherche = 9*(sin(45*(pi/180)) / 5.8);
    // Fin de l'équation pour la valeur recherche du MOD 
   
    // Début de la recherche de la première valeur la plus proche
            getClosest();
            double valPlusProche = getClosest2(recherche);
            double tab[4][1];
            for (double ele : myArr) {
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele/ele1)*(ele2/ele3);
                            if (calc == valPlusProche) {
                                tab[0][0] = ele;
                                tab[1][0] = ele1;
                                tab[2][0] = ele2;
                                tab[3][0] = ele3;
                                tab[4][0] = (tab[0][0]/tab[1][0])*(tab[2][0]/tab[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table = tab[4][0];
    // Fin de la recherche de la première valeur la plus proche

    // Début de l'éffacement de la première valeur la plus proche dans le tableau value
            double value_to_remove = valPlusProche;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove), value.end()); 
    // Fin de l'éffacement de la première valeur la plus proche dans le tableau value

    // Début de la recherche de la deuxième valeur la plus proche
            double valPlusProche1 = getClosest2(recherche);
            double tab1[4][1];
            for (double ele : myArr){
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche1) {
                                tab1[0][0] = ele;
                                tab1[1][0] = ele1;
                                tab1[2][0] = ele2;
                                tab1[3][0] = ele3;
                                tab1[4][0] = (tab1[0][0]/tab1[1][0])*(tab1[2][0]/tab1[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table1 = tab1[4][0];
    // Fin de la recherche de la deuxième valeur la plus proche

    // Début de l'éffacement de la deuxième valeur la plus proche dans le tableau value
            double value_to_remove1 = valPlusProche1;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove1), value.end()); 
    // Fin de l'éffacement de la deuxième valeur la plus proche dans le tableau value

    // Début de la recherche de la troisième valeur la plus proche
            double valPlusProche2 = getClosest2(recherche);
            double tab2[4][1];
            for (double ele : myArr){
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche2) {
                                tab2[0][0] = ele;
                                tab2[1][0] = ele1;
                                tab2[2][0] = ele2;
                                tab2[3][0] = ele3;
                                tab2[4][0] = (tab2[0][0]/tab2[1][0])*(tab2[2][0]/tab2[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table2 = tab2[4][0];
    // Fin de la recherche de la troisième valeur la plus proche

    // Début de l'éffacement de la troisième valeur la plus proche dans le tableau value
            double value_to_remove2 = valPlusProche2;
            value.erase(std::remove(value.begin(), value.end(), value_to_remove2), value.end()); 
    // Fin de l'éffacement de la troisième valeur la plus proche dans le tableau value

    // Début de la recherche de la quatrième valeur la plus proche
            double valPlusProche3 = getClosest2(recherche);
            double tab3[4][1];
            for (double ele : myArr){
                for (double ele1 : myArr) {
                    for (double ele2 : myArr) {
                        for (double ele3 : myArr) {
                            double calc = (ele / ele1) * (ele2 / ele3);
                            if (calc == valPlusProche3) {
                                tab3[0][0] = ele;
                                tab3[1][0] = ele1;
                                tab3[2][0] = ele2;
                                tab3[3][0] = ele3;
                                tab3[4][0] = (tab3[0][0]/tab3[1][0])*(tab3[2][0]/tab3[3][0]);
                                break;
                            }
                        }
                    }
                }
            }
            double table3 = tab3[4][0];
    // Fin de la recherche de la quatrième valeur la plus proche

    // Début affichage des informations
           
            printf("Ratio recherch%c : %.7f\n", 130, recherche);
            printf("R%csultat ratio #1 : %.7f \n", 130, table);
            cout << "Engrenages " << tab[0][0] << ", " << tab[1][0] << ", " << tab[2][0] << " et " << tab[3][0] << endl;
            double sinangle = (table * 5.8)/9;
            double transformsin = (asin(sinangle))*180/pi;
         
           
            printf("Donnera un angle de %.9f\n", transformsin);
            cout << "=============================================================" << endl;
            
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #2 : %.7f \n", 130, table1);
            cout << "Engrenages " << tab1[0][0] << ", " << tab1[1][0] << ", " << tab1[2][0] << " et " << tab1[3][0] << endl;
            double sinangle1 = (table1 * 5.8)/9;
            double transformsin1 = (asin(sinangle1))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin1);
            cout << "=============================================================" << endl;
          
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #3 : %.7f \n", 130, table2);
            cout << "Engrenages " << tab2[0][0] << ", " << tab2[1][0] << ", " << tab2[2][0] << " et " << tab2[3][0] << endl;
            double sinangle2 = (table2 * 5.8)/9;
            double transformsin2 = (asin(sinangle))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin2);

            cout << "=============================================================" << endl;
           
            printf("Ratio recherch%c : %.7f \n", 130, recherche);
            printf("R%csultat ratio #4 : %.7f \n", 130, table3);
            cout << "Engrenages " << tab3[0][0] << ", " << tab3[1][0] << ", " << tab3[2][0] << " et " << tab3[3][0] << endl;
            double sinangle3 = (table3 * 5.8)/9;
            double transformsin3 = (asin(sinangle))*180/pi;
            printf("Donnera un angle de %.9f\n", transformsin3);

            cout << "=============================================================\n" << endl;
    // Fin affichage des informations
        }
        
        

Et le résultat du premier ratio est de l'arc du sinus est 44.999997467 sur le programme et sur la calculatrice c'est 44,99999684278048340310258988422.