Как посмотреть код ехе

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
 
// Programm optimiert für exakten Widerstand zu gegebenem R2, nicht für möglichst kleines Verhältnis
 
/**
 * Das folgende Programm berechnet einen resistiven Spannungsteiler basierend auf diversen Nutzereingaben.
 * Der Nutzer muss eine Widerstands-E-Reihe und ein gewünschtes Widerstandsverhältnis angeben.
 * Optional ist es möglich, einen gewünschten Widerstand R2 einzugeben; das Programm rechnet dann mit dem Wert der
 * geringsten Abweichung aus der gewählten E-Reihe.
 *
 * Das Programm wurde auf einem Windows-System getestet; es wird nicht für die Funktion auf anderen Betriebssystemen
 * garantiert.
 *
 */
 
 
typedef struct{
    unsigned int rtop;
    unsigned int rbot;
    double error;
    int scale;
} rdiv_t;
 
unsigned int eseries_getval(unsigned int nth, unsigned int eseries){
    unsigned int e24[24] = {100, 110, 120, 130, 150, 160, 180, 200, 220, 240, 270, 300, 330, 360, 390, 430, 470, 510,
                            560, 620, 680, 750, 820, 910};
    unsigned int e192[192] = {100, 101, 102, 104, 105, 106, 107, 109, 110, 111, 113, 114, 115, 117, 118, 120, 121, 123,
                              124, 126, 127, 129, 130, 132, 133, 135, 137, 138, 140, 142, 143, 145, 147, 149, 150, 152,
                              154, 156, 158, 160, 162, 164, 165, 167, 169, 172, 174, 176, 178, 180, 182, 184, 187, 189,
                              191, 193, 196, 198, 200, 203, 205, 208, 210, 213, 215, 218, 221, 223, 226, 229, 232, 234,
                              237, 240, 243, 246, 249, 252, 255, 258, 261, 264, 267, 271, 274, 277, 280, 284, 287, 291,
                              294, 298, 301, 305, 309, 312, 316, 320, 324, 328, 332, 336, 340, 344, 348, 352, 357, 361,
                              365, 370, 374, 379, 383, 388, 392, 397, 402, 407, 412, 417, 422, 427, 432, 437, 442, 448,
                              453, 459, 464, 470, 475, 481, 487, 493, 499, 505, 511, 517, 523, 530, 536, 542, 549, 556,
                              562, 569, 576, 583, 590, 597, 604, 612, 619, 626, 634, 642, 649, 657, 665, 673, 681, 690,
                              698, 706, 715, 723, 732, 741, 750, 759, 768, 777, 787, 796, 806, 816, 825, 835, 845, 856,
                              866, 876, 887, 898, 909, 920, 931, 942, 953, 965, 976, 988};
 
    switch (eseries){
        case 3:
            return e24[(nth-1)*8];
        case 6:
            return e24[(nth-1)*4];
        case 12:
            return e24[(nth-1)*2];
        case 24:
            return e24[nth-1];
        case 48:
            return e192[(nth-1)*4];
        case 96:
            return e192[(nth-1)*2];
        case 192:
            return e192[nth-1];
        default:
            return 0;
    }
}
 
 
/**
 * Berechnet einen Widerstand rtop, um für einen gegebenen Widerstand rbot und eine gegebene E-Reihe eseries ein
 * gewünschtes Widerstandsverhältnis resratio möglichst genau zu erreichen. Da das meist nicht exakt möglich ist, wird
 * der nächst kleinere (größere) Widerstand und die prozentuale Abweichung zum gewünschten Verhältnis in rdiv_poserr
 * (rdiv_negerr) hinterlegt.
 */
void calc_rtop(unsigned int rbot, double resratio, unsigned int eseries, rdiv_t *rdiv_poserr, rdiv_t *rdiv_negerr){
    double err1 = 1;
    double err2 = 1;
 
    unsigned int e_counter = 1;
    int rtop_scale = -4;
 
 
    while(err1 > 0){
        err2 = err1;
 
        double current_rtop = eseries_getval(e_counter, eseries) * pow(10.0, rtop_scale);
        double current_resratio = rbot / (rbot + current_rtop);
 
        err1 = (current_resratio - resratio) / resratio;
 
        if(e_counter < eseries){
            e_counter ++;
        } else{
            e_counter = 1;
            if(rtop_scale < 6){
                rtop_scale ++;
            } else {
                e_counter = 0;
                break;
            }
        }
    }
 
    double low_rtop;
    int low_rtop_scale = rtop_scale;
    if (e_counter > 2){             // Wenn Counter groß genug, problemloses Subtrahieren möglich
        low_rtop = eseries_getval(e_counter - 2, eseries) * pow(10.0, low_rtop_scale);
    } else {                        // Wenn nicht muss eine Dekade nach unten gesrpungen werden
        if (low_rtop_scale > -4){       // Dazu zuerst testen, ob nicht die niedrigste betrachtete Dekade bereits verwendet wird
            low_rtop_scale --;          // Scale anpassen, damit später die Ganzzahl-Arithmetik stimmt
            low_rtop = eseries_getval(e_counter + eseries - 2, eseries) * pow(10.0, low_rtop_scale);
        } else {
            low_rtop = 0;
        }
    }
 
    double high_rtop;
    int high_rtop_scale = rtop_scale;
    if (e_counter > 1){
        high_rtop = eseries_getval(e_counter - 1, eseries) * pow(10.0, high_rtop_scale);
    } else {
        if (high_rtop_scale > -4){
            high_rtop_scale --;
            high_rtop = eseries_getval(e_counter + eseries - 1, eseries) * pow(10.0, high_rtop_scale);
        } else {
            high_rtop = 0;
        }
    }
 
     // An diesem Punkt: Alle Widerstände korrekt so wie sie sein sollen, allerdings eventuell noch Gleitkommazahlen --> Über Dekade (scale) anpassen
 
    if (low_rtop_scale < 0){
        rdiv_poserr->rtop = low_rtop * pow(10.0, abs(low_rtop_scale));          // Narrowing conversion hier irrelevant, da durch Multiplikation mit dem Betrag der Dekadenkennung sicher die Ganzzahl-Arithmetik eingehalten wird.
        rdiv_poserr->rbot = rbot * pow(10.0, abs(low_rtop_scale));
        rdiv_poserr->scale = low_rtop_scale;
    } else{
        rdiv_poserr->rtop = low_rtop;                                           // Narrowing conversion hier irrelevant, da der scale hier nicht negativ ist und somit sicher keine Gleitkommazahlen in den Widerständen hinterlegt sind.
        rdiv_poserr->rbot = rbot;
        rdiv_poserr->scale = low_rtop_scale;
    }
 
    if (high_rtop_scale < 0){
        rdiv_negerr->rtop = high_rtop * pow(10.0, abs(high_rtop_scale));
        rdiv_negerr->rbot = rbot * pow(10.0, abs(high_rtop_scale));
        rdiv_negerr->scale = high_rtop_scale;
    } else{
        rdiv_negerr->rtop = high_rtop;
        rdiv_negerr->rbot = rbot;
        rdiv_negerr->scale = high_rtop_scale;
    }
 
    rdiv_poserr->error = low_rtop == 0 ? -1 : err2;
//    rdiv_poserr->rtop = low_rtop;
    rdiv_negerr->error = high_rtop == 0 ? 1 : err1;
//    rdiv_negerr->rtop = high_rtop;
 
//    printf("Zu kleiner Widerstand: %u\nDaraus resultierender Fehler: %f\n", rdiv_poserr->rtop, rdiv_poserr->error);
//    printf("Zu grosser Widerstand: %u\nDaraus resultierender Fehler: %f\n", rdiv_negerr->rtop, rdiv_negerr->error);
}
 
void calc_divs(double givenr2, double resratio, unsigned int eseries, rdiv_t *rdiv_poserr, rdiv_t * rdiv_negerr){
    if(givenr2 == 0){
        double lowest_poserr = 1;
        unsigned int lp_r_bot = 0;
        unsigned int lp_r_top = 0;
        int lp_scale = 0;
 
        double lowest_negerr = -1;
        unsigned int ln_r_bot = 0;
        unsigned int ln_r_top = 0;
        int ln_scale = 0;
 
        for (int i = -1; i < 6; ++i) {              // Dekaden-Schleife
            for (unsigned int j = 1; j <= eseries; ++j) {    // E-Reihen-Schleife
                unsigned int current_r2 = eseries_getval(j, eseries);
                calc_rtop(current_r2, resratio, eseries, rdiv_poserr, rdiv_negerr);
 
                if (rdiv_poserr->error < lowest_poserr) {       // Wenn aktueller Fehler geringer als zuvor geringster, Daten als neue kleinster-Fehler-Daten speichern
                    lowest_poserr = rdiv_poserr->error;
                    lp_r_bot = current_r2;
                    lp_r_top = rdiv_poserr->rtop;
 
                    lp_scale = i;
                }
                if (rdiv_negerr->error > lowest_negerr) {
                    lowest_negerr = rdiv_negerr->error;
                    ln_r_bot = current_r2;
                    ln_r_top = rdiv_negerr->rtop;
 
                    ln_scale = i;
                }
            }
        }
 
        rdiv_poserr->rtop = lp_r_top;               //Schreiben niedrigsten Wert in struct
        rdiv_poserr->rbot = lp_r_bot;
        rdiv_poserr->error = lowest_poserr;
        rdiv_poserr->scale += lp_scale;
 
        rdiv_negerr->rtop = ln_r_top;
        rdiv_negerr->rbot = ln_r_bot;
        rdiv_negerr->error = lowest_negerr;
        rdiv_negerr->scale += ln_scale;
 
//        printf("Geringster positiver Fehler: %f    Zugehoeriger R1 (rtop): %f   R2 (rbot): %f\n", rdiv_negerr->error, rdiv_negerr->rtop * pow(10, rdiv_negerr->scale), rdiv_negerr->rbot * pow(10, rdiv_negerr->scale));
//        printf("Geringster negativer Fehler: %f    Zugehoeriger R1 (rtop): %f   R2 (rbot): %f\n", rdiv_poserr->error, rdiv_poserr->rtop * pow(10, rdiv_poserr->scale), rdiv_poserr->rbot * pow(10, rdiv_poserr->scale));
    } else if(givenr2 > 0){
        // rbot so nah wie möglich an givenr2 annähern (aus gegebener eseries)
        // rtop passend zu rbot berechnen (calc_rtop)
 
        int scale = 0;
 
        if (givenr2 < 100){                                 //Passt r2 in ganz zahl arithmektik? r2 der zwischen 100 und 1000
            while(givenr2 < 100){                           //R2 wird danach zwischen 100 und 1000 liegen
                givenr2 *= 10;
                scale --;
            }
        } else{
            while(givenr2 >= 1000){
                givenr2 /= 10;
                scale ++;
            }
        }
 
 
        int val_counter = 1;
 
        while(givenr2 > eseries_getval(val_counter, eseries)){
            if(val_counter < eseries){
                val_counter ++;
            } else{
                val_counter = -1;
                break;
            }
        }
 
        unsigned int lower_r;
        unsigned int higher_r;
 
        if(val_counter == -1){
            lower_r = eseries_getval(eseries, eseries);
            higher_r = eseries_getval(1, eseries) * 10;
 
        } else{
            lower_r = eseries_getval((val_counter == 1) ? val_counter : val_counter - 1, eseries); // Widerstand am nähesten von unten
            higher_r = eseries_getval(val_counter, eseries); //Widerstand am nähesten von oben
        }
 
        unsigned int rbot = (givenr2 - lower_r) < (higher_r - givenr2) ? lower_r : higher_r;
 
        if (rbot >= 1000){
            rbot /= 10;
            scale ++;
        }
 
        calc_rtop(rbot, resratio, eseries, rdiv_poserr, rdiv_negerr);
 
        rdiv_poserr->scale += scale; // im nachhinein draufhauen (weil für rtop und rbot gleichermaßen)
        rdiv_negerr->scale += scale;
 
//        printf("Geringster positiver Fehler: %f    Zugehoeriger R1 (rtop): %f   R2 (rbot): %f\n", rdiv_negerr->error, rdiv_negerr->rtop * pow(10, rdiv_negerr->scale), rdiv_negerr->rbot * pow(10, rdiv_negerr->scale));
//        printf("Geringster negativer Fehler: %f    Zugehoeriger R1 (rtop): %f   R2 (rbot): %f\n", rdiv_poserr->error, rdiv_poserr->rtop * pow(10, rdiv_poserr->scale), rdiv_poserr->rbot * pow(10, rdiv_poserr->scale));
    }
}
 
 
/**
 * - ignoriert eventuell eingegebene Zeichen nach der geforderten Zahl(-Buchstaben) Kombination (vgl. resistorso)
 * - maximal 10 Stellen pro Eingabe (für realistischen Anwendungsfall vollkommen ausreichend)
 *
 * - resistorso akzeptiert 10er-Exponent bei Spannungsverhältnis (z.B.: 0.1 = 1e-1); hier wird dies bewusst unterbunden
 */
 
int main(void) {
    char eseries_string[10];
    unsigned int eseries;
 
    char resratio_string[10];
    double resratio;
 
    char givenr2_string[10];
    char* givenr2_ptr;
    double givenr2;
 
    rdiv_t negerr, poserr;
 
 
    eseries_input:
    printf("Bitte waehle die E-Reihe (3, 6, 12, 24, 48, 96, 192): ");
    fflush(stdin);
 
    scanf("%s", eseries_string);
    if(eseries_string[0] == '-' || eseries_string[0] == '+' || eseries_string[0] == '0'){           // Filtert eventuelle Vorzeichen heraus, da strloul diese durchlassen würde; mit -4294967293 wäre also durch einen Integer-Overflow wieder 3 eingebbar. Außerdem Filter für vorangestellte Nullen, da diese zu Fehlern führen würden.
        eseries_string[0] = 'a';                                                                    // Wenn Vorzeichen gefunden: erstes Zeichen des Strings auf 'a', damit strtoul einen Fehler wirft
    }
    eseries = strtoul(eseries_string, NULL, 0);
 
    if (eseries != 3 && eseries != 6 && eseries != 12 && eseries != 24 && eseries != 48 && eseries != 96 && eseries != 192){
        printf("Das ist keine gueltige E-Reihe. Bitte erneut versuchen.\n");
        goto eseries_input;
    }
    printf("Gewaehlte E-Reihe: %u\n", eseries);
 
 
    resratio_input:
    printf("\nBitte gib das gewuenschte Spannungsteilerverhaeltnis ein (0-1): ");
    fflush(stdin);
 
    scanf("%s", resratio_string);
    if(resratio_string[0] != ' ' && resratio_string[0] != '0'){
        resratio_string[0] = 'a';
    }
    resratio = strtod(resratio_string, NULL);
 
    if (resratio <= 0 || resratio >= 1){
        printf("Das Spannungsteilerverhaeltnis muss zwischen 0 und 1 liegen. Bitte erneut versuchen.\n");
        goto resratio_input;
    }
    printf("Gewaehltes Spannungsteilerverhaeltnis: %f\n", resratio);
 
 
    givenr2_input:
    printf("\nGewuenschter Wert fuer R2 (0 oder leer fuer beliebig): ");
    fflush(stdin);
 
    int r2_input_cntr = 0;
    char r2_input_char;
    int flag_hasContent = 0;
    while(1){
        r2_input_char = (char)getchar();
 
        if (r2_input_char == 0x0A){         // Wenn Enter gedrückt wird, while-Schleife abbrechen
            break;
        }
 
        if (r2_input_char != ' ' && r2_input_char != '0'){      // Testen, ob ein Character eingegeben wurde, der nicht space, 0 oder Enter ist.
            flag_hasContent = 1;                                // Wenn ja, entsprechendes Flag setzen
        }
 
        givenr2_string[r2_input_cntr] = r2_input_char;
 
        r2_input_cntr ++;
    }
 
    if(flag_hasContent == 0){           // Wenn Flag gesetzt, enthält Eingabe keine Zeichen; zwei Widerstände müssen gesucht werden
        printf("Kein Widerstand gewaehlt.\n");
        calc_divs(0, resratio, eseries, &negerr, &poserr);
    } else{                             // Wenn Flag nicht gesetzt, Input ganz normal parsen
        givenr2 = strtod(givenr2_string, &givenr2_ptr);
 
        if (givenr2_ptr[0] == 'k'){
            givenr2 *= 1000;
        } else if (givenr2_ptr[0] == 'M'){
            givenr2 *= 100000;
        }
 
        if (givenr2 == 0){
            printf("\nDer eingegebene Widerstandswert ist nicht gueltig. Bitte erneut versuchen.\n");
            memset(givenr2_string, 0, sizeof givenr2_string);               // Alle Werte im Array überschreiben, damit "alte" Eingaben nicht die neue Eingabe verfälschen.
            flag_hasContent = 0;                                                 // Flag zurücksetzen.
            goto givenr2_input;
        }
        printf("Gewaehlter R2: %f\n", givenr2);
 
        calc_divs(givenr2, resratio, eseries, &negerr, &poserr);
    }
 
    if(poserr.error == 0){
        printf("R1: %f, R2: %f (Fehler: %f%%)\n", poserr.rtop * pow(10, poserr.scale), poserr.rbot * pow(10, poserr.scale), poserr.error * 100);
    }else if (negerr.error == 0){
        printf("R1: %f, R2: %f (Fehler: %f%%)\n", negerr.rtop * pow(10, negerr.scale), negerr.rbot * pow(10, negerr.scale), negerr.error * 100);
    }else{
        printf("Zu kleines Verhaeltnis:    R1: %f, R2: %f (Fehler: %f%%)\n", poserr.rtop * pow(10, poserr.scale), poserr.rbot * pow(10, poserr.scale), poserr.error * 100);
        printf("Zu grosses Verhaeltnis:    R1: %f, R2: %f (Fehler: %f%%)\n", negerr.rtop * pow(10, negerr.scale), negerr.rbot * pow(10, negerr.scale), negerr.error * 100);
    }
 
    fflush(stdin);
    printf("\nEnter zum Fortfahren druecken. ");
    getchar();
 
    return EXIT_SUCCESS;
}