PROBLEMA Risultati di Operazioni

[JDany]

Salve. Mi spiego meglio: ho creato una calcolatrice in C che fa delle operazioni su 2 numeri. Qualche giorno fa, così per caso, ho scoperto che alcuni risultati delle divisioni vengono sbagliati. Faccio un esempio:

primo numero: 123456789
secondo numero: 3

Il risultato con la mia calcolatrice è: 41.152.264.0000, mentre il risultato dovrebbe essere: 41.152.263. Si sbaglia di 1 unità.
Cosa c'è di sbagliato?

 

[Andretti60]

Probabilmente è un errore di arrotondamento.
Pubblica il tuo codice.

 

[JDany]

Probabilmente è un errore di arrotondamento.
Pubblica il tuo codice.

Si anche io pensavo ad un problema di arrotondamento visto che alcune volte fa arrotondamenti strani.
Si accettano consigli perché ancora non sono bravo e di sicuro ho fatto alcuni errori di cui non so l'esistenza :hihi:

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <math.h>

void operazioni(){
    printf("Cosa vuoi fare? \n");
    printf("1) Somma \n");
    printf("2) Sottrazione \n");
    printf("3) Prodotto \n");
    printf("4) Divisione \n");
    printf("5) Elevamento a potenza\n");
    printf("6) Conversioni \n\n");
    printf("Digita qui il numero dell'operazione: ");
}
void convers(){
    printf("\nConversione: \n");
    printf("1) Celsius - Fahreneit\n");
    printf("2) Fahreneit - Celsius \n");
    printf("3) Celsius - Kelvin\n");
    printf("4) Kelvin - Celsius\n");
}

void continuare();
void continuare1();

// PROTOTIPAZIONE SOMMA
float somma(float num1, float num2, float ris);

// PROTOTIPAZIONE SOTTRAZIONE
float sottrazione(float num1, float num2, float ris);

// PROTOTIPAZIONE MOLTIPLICAZIONE
float moltiplicazione(float num1, float num2, float ris);

// PROTOTIPAZIONE DIVISIONE
float divisione(float num, float nuM, float ris);

// PROTOTIPAZIONE POTENZA
float potenz(float numero, float potenza, float risultato, float n, float p, float ris);

// PROTOTIPAZIONE CONVERSIONE
float conve(float numero, float ris, int v);
 
// PROTOTIPAZIONE CONVERSIONE1
float conve1(float numero, float ris, int v);

// FUNZIONE CONTINUARE
void continua();

// PROTOTIPAZIONE CALCOLO
float calcolo(float ritorno, float ris);

// PROTOTIPAZIONE CALCOLO1   
float calcolo1(float ritorno, float ris);

// \/\/\/\/\/\/\/\/\/\/\/\ //
// \/\/\/\/\/\/\/\/\/\/\/\ //
main(){
    float ritorno; // VAR per CALCOLO
    int valore, v;
    float num1, num2, ris; // SOMMA - SOTTRAZIONE - MOLTIPLICAZIONE
    float num, nuM; // DIVISONE
    float numero, potenza, risultato, n, p; // POTENZA

    calcolo(ritorno, ris);
    
    getchar();
    return(ritorno);
}
// \/\/\/\/\/\/\/\/\/\/\/\ //
// \/\/\/\/\/\/\/\/\/\/\/\ //

float somma(float num1, float num2, float ris){
    float risultato = ris;
    float *pointer = &num1;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num1);
    float *pointer1 = &num2;
    pointer1 = (float*)malloc(sizeof(int)*11);
    printf("Inserisci il secondo numero: ");
    scanf("%f", &num2);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num1 + num2;
    printf("%-9.4f \n", ris);

    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float sottrazione(float num1, float num2, float ris){
    float risultato = ris;
    float *pointer = &num1;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num1);
    float *pointer1 = &num2;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci il secondo numero: ");
    scanf("%f", &num2);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num1 - num2;
    printf("%-9.4f \n", ris);
    
    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float moltiplicazione(float num1, float num2, float ris){
    float risultato = ris;
    float *pointer = &num1;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num1);
    float *pointer1 = &num2;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci il secondo numero: ");
    scanf("%f", &num2);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num1 * num2;
    printf("%-9.4f \n", ris);

    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float divisione(float num, float nuM, float ris){
    float risultato = ris;
    float *pointer = &num;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num);
    float *pointer1 = &nuM;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci il secondo numero: ");
    scanf("%f", &nuM);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num / nuM;
    printf("%-9.4f \n", ris);

    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float potenz(float numero, float potenza, float risultato, float n, float p, float ris){
    double ritorno = ris;
    float *pointer = &numero;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci la base: ");
    scanf("%f", &numero);
    float *pointer1 = &potenza;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci la potenza: ");
    scanf("%f", &potenza);
    n = numero;
    p = potenza;
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = pow(n, p);
    printf("%-8.0f \n", ris);
    
    free(pointer);
    free(pointer1);
    free(pointer2);
    return(ritorno);
}
float conve(float numero, float ris, int v){
    float ritorno = ris;
    convers();
    printf("\nDigita il numero della conversione: ");
    scanf("%i", &v);
    float *pointer = &numero;
    pointer = (float*)malloc(sizeof(int));
    float *pointer1 = &ris;
    pointer1 = (float*)malloc(sizeof(int));
    switch(v){
        case 0:
            printf(" ");
        break;
        case 1:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero * 1.8 + 32;
            printf("%-8.4f", ris);
            
    
        break;
        case 2:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = (numero - 32) / 1.8;
            printf("%-8.4f", ris);
            
    
        break;
        case 3:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero + 273.15;
            printf("%-8.4f", ris);
    
        break;
        case 4:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero - 273.15;
            printf("%-8.4f", ris);
    
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            conve1(numero, ris, v);
    }
    free(pointer);
    free(pointer1);
    return(ritorno);
}
float conve1(float numero, float ris, int v){
    float ritorno = ris;
    convers();
    printf("\nDigita il numero della conversione: ");
    scanf("%i", &v);
    float *pointer = &numero;
    pointer = (float*)malloc(sizeof(int));
    float *pointer1 = &ris;
    pointer1 = (float*)malloc(sizeof(int));
    switch(v){
        case 0:
            printf("");
        break;
        case 1:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero * 1.8 + 32;
            printf("%-8.4f", ris);
    
        break;
        case 2:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = (numero - 32) / 1.8;
            printf("%-8.4f", ris);

    
        break;
        case 3:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero + 273.15;
            printf("%-8.4f", ris);
    
        break;
        case 4:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero - 273.15;
            printf("%-8.4f", ris);
    
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            conve(numero, ris, v);
    }
    free(pointer);
    free(pointer1);
    
    return(ritorno);
}
float calcolo(float ritorno, float ris){
    operazioni();
    ritorno = ris;
    int v, valore;
    float num1, num2; // SOMMA - SOTTRAZIONE - MOLTIPLICAZIONE
    float num, nuM; // DIVISONE
    float numero, potenza, risultato, n, p; // POTENZA
    ritorno = ris;
    
    scanf("%d", &valore);
    
    switch(valore){
        case 0:
            printf("");
        break;
        case 1:
            somma(num1, num2, ris);
    
        break;
        case 2:
            sottrazione(num1, num2, ris);
    
        break;
        case 3:
            moltiplicazione(num1, num2, ris);
    
        break;
        case 4:
            divisione(num, nuM, ris);
    
        break;
        case 5:
            potenz(numero, potenza, risultato, n, p, ris);
    
        break;
        case 6:
            conve(numero, ris, v);
    
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            calcolo1(ritorno, ris);
    }
    continuare();
    return(ritorno);
}   
float calcolo1(float ritorno, float ris){
    operazioni();
    ritorno = ris;
    int v, valore;
    float num1, num2; // SOMMA - SOTTRAZIONE - MOLTIPLICAZIONE
    float num, nuM; // DIVISONE
    float numero, potenza, risultato, n, p; // POTENZA
    ritorno = ris;
    
    scanf("%d", &valore);
    
    switch(valore){
        case 0:
            printf("");
        break;
        case 1:
            somma(num1, num2, ris);
    
        break;
        case 2:
            sottrazione(num1, num2, ris);
    
        break;
        case 3:
            moltiplicazione(num1, num2, ris);
    
        break;
        case 4:
            divisione(num, nuM, ris);
    
        break;
        case 5:
            potenz(numero, potenza, risultato, n, p, ris);
    
        break;
        case 6:
            conve(numero, ris, v);
    
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            calcolo(ritorno, ris);
    
            
    }
    continuare();
    return(ritorno);
}
void continuare(){
    float ritorno, ris;
    int i;
    int *pointer = &i;
    pointer = (int*)malloc(sizeof(int)*1);
    printf("\nVuoi continuare?\n");
    printf("0) Si\n");
    printf("1) No\n");
    scanf("%i", &i);
        switch(i){
            case 0:
                calcolo(ritorno, ris);
            break;
            case 1:
            break;
            default:
                fprintf(stderr, "Hai sbagliato!!");
                continuare1();
        }
    free(pointer);
}
void continuare1(){
    float ritorno, ris;
    int i;
    int *pointer = &i;
    pointer = (int*)malloc(sizeof(int)*1);
    printf("\nVuoi continuare?\n");
    printf("0) Si\n");
    printf("1) No\n");
    scanf("%i", &i);
        switch(i){
            case 0:
                calcolo(ritorno, ris);
            break;
            case 1:
            break;
            default:
                fprintf(stderr, "Hai sbagliato!!");
                continuare();
        }
    free(pointer);
}

 

[_Achille]

Si anche io pensavo ad un problema di arrotondamento visto che alcune volte fa arrotondamenti strani.
Si accettano consigli perché ancora non sono bravo e di sicuro ho fatto alcuni errori di cui non so l'esistenza :hihi:

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <math.h>

void operazioni(){
    printf("Cosa vuoi fare? \n");
    printf("1) Somma \n");
    printf("2) Sottrazione \n");
    printf("3) Prodotto \n");
    printf("4) Divisione \n");
    printf("5) Elevamento a potenza\n");
    printf("6) Conversioni \n\n");
    printf("Digita qui il numero dell'operazione: ");
}
void convers(){
    printf("\nConversione: \n");
    printf("1) Celsius - Fahreneit\n");
    printf("2) Fahreneit - Celsius \n");
    printf("3) Celsius - Kelvin\n");
    printf("4) Kelvin - Celsius\n");
}

void continuare();
void continuare1();

// PROTOTIPAZIONE SOMMA
float somma(float num1, float num2, float ris);

// PROTOTIPAZIONE SOTTRAZIONE
float sottrazione(float num1, float num2, float ris);

// PROTOTIPAZIONE MOLTIPLICAZIONE
float moltiplicazione(float num1, float num2, float ris);

// PROTOTIPAZIONE DIVISIONE
float divisione(float num, float nuM, float ris);

// PROTOTIPAZIONE POTENZA
float potenz(float numero, float potenza, float risultato, float n, float p, float ris);

// PROTOTIPAZIONE CONVERSIONE
float conve(float numero, float ris, int v);

// PROTOTIPAZIONE CONVERSIONE1
float conve1(float numero, float ris, int v);

// FUNZIONE CONTINUARE
void continua();

// PROTOTIPAZIONE CALCOLO
float calcolo(float ritorno, float ris);

// PROTOTIPAZIONE CALCOLO1  
float calcolo1(float ritorno, float ris);

// \/\/\/\/\/\/\/\/\/\/\/\ //
// \/\/\/\/\/\/\/\/\/\/\/\ //
main(){
    float ritorno; // VAR per CALCOLO
    int valore, v;
    float num1, num2, ris; // SOMMA - SOTTRAZIONE - MOLTIPLICAZIONE
    float num, nuM; // DIVISONE
    float numero, potenza, risultato, n, p; // POTENZA

    calcolo(ritorno, ris);
   
    getchar();
    return(ritorno);
}
// \/\/\/\/\/\/\/\/\/\/\/\ //
// \/\/\/\/\/\/\/\/\/\/\/\ //

float somma(float num1, float num2, float ris){
    float risultato = ris;
    float *pointer = &num1;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num1);
    float *pointer1 = &num2;
    pointer1 = (float*)malloc(sizeof(int)*11);
    printf("Inserisci il secondo numero: ");
    scanf("%f", &num2);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num1 + num2;
    printf("%-9.4f \n", ris);

    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float sottrazione(float num1, float num2, float ris){
    float risultato = ris;
    float *pointer = &num1;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num1);
    float *pointer1 = &num2;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci il secondo numero: ");
    scanf("%f", &num2);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num1 - num2;
    printf("%-9.4f \n", ris);
   
    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float moltiplicazione(float num1, float num2, float ris){
    float risultato = ris;
    float *pointer = &num1;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num1);
    float *pointer1 = &num2;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci il secondo numero: ");
    scanf("%f", &num2);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num1 * num2;
    printf("%-9.4f \n", ris);

    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float divisione(float num, float nuM, float ris){
    float risultato = ris;
    float *pointer = &num;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci il primo numero: ");
    scanf("%f", &num);
    float *pointer1 = &nuM;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci il secondo numero: ");
    scanf("%f", &nuM);
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = num / nuM;
    printf("%-9.4f \n", ris);

    free(pointer);
    free(pointer1);
    free(pointer2);
    return(risultato);
}
float potenz(float numero, float potenza, float risultato, float n, float p, float ris){
    double ritorno = ris;
    float *pointer = &numero;
    pointer = (float*)malloc(sizeof(int));
    printf("Inserisci la base: ");
    scanf("%f", &numero);
    float *pointer1 = &potenza;
    pointer1 = (float*)malloc(sizeof(int));
    printf("Inserisci la potenza: ");
    scanf("%f", &potenza);
    n = numero;
    p = potenza;
    float *pointer2 = &ris;
    pointer2 = (float*)malloc(sizeof(int));
    ris = pow(n, p);
    printf("%-8.0f \n", ris);
   
    free(pointer);
    free(pointer1);
    free(pointer2);
    return(ritorno);
}
float conve(float numero, float ris, int v){
    float ritorno = ris;
    convers();
    printf("\nDigita il numero della conversione: ");
    scanf("%i", &v);
    float *pointer = &numero;
    pointer = (float*)malloc(sizeof(int));
    float *pointer1 = &ris;
    pointer1 = (float*)malloc(sizeof(int));
    switch(v){
        case 0:
            printf(" ");
        break;
        case 1:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero * 1.8 + 32;
            printf("%-8.4f", ris);
           
   
        break;
        case 2:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = (numero - 32) / 1.8;
            printf("%-8.4f", ris);
           
   
        break;
        case 3:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero + 273.15;
            printf("%-8.4f", ris);
   
        break;
        case 4:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero - 273.15;
            printf("%-8.4f", ris);
   
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            conve1(numero, ris, v);
    }
    free(pointer);
    free(pointer1);
    return(ritorno);
}
float conve1(float numero, float ris, int v){
    float ritorno = ris;
    convers();
    printf("\nDigita il numero della conversione: ");
    scanf("%i", &v);
    float *pointer = &numero;
    pointer = (float*)malloc(sizeof(int));
    float *pointer1 = &ris;
    pointer1 = (float*)malloc(sizeof(int));
    switch(v){
        case 0:
            printf("");
        break;
        case 1:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero * 1.8 + 32;
            printf("%-8.4f", ris);
   
        break;
        case 2:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = (numero - 32) / 1.8;
            printf("%-8.4f", ris);

   
        break;
        case 3:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero + 273.15;
            printf("%-8.4f", ris);
   
        break;
        case 4:
            printf("\nNumero da convertire: ");
            scanf("%f", &numero);
            ris = numero - 273.15;
            printf("%-8.4f", ris);
   
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            conve(numero, ris, v);
    }
    free(pointer);
    free(pointer1);
   
    return(ritorno);
}
float calcolo(float ritorno, float ris){
    operazioni();
    ritorno = ris;
    int v, valore;
    float num1, num2; // SOMMA - SOTTRAZIONE - MOLTIPLICAZIONE
    float num, nuM; // DIVISONE
    float numero, potenza, risultato, n, p; // POTENZA
    ritorno = ris;
   
    scanf("%d", &valore);
   
    switch(valore){
        case 0:
            printf("");
        break;
        case 1:
            somma(num1, num2, ris);
   
        break;
        case 2:
            sottrazione(num1, num2, ris);
   
        break;
        case 3:
            moltiplicazione(num1, num2, ris);
   
        break;
        case 4:
            divisione(num, nuM, ris);
   
        break;
        case 5:
            potenz(numero, potenza, risultato, n, p, ris);
   
        break;
        case 6:
            conve(numero, ris, v);
   
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            calcolo1(ritorno, ris);
    }
    continuare();
    return(ritorno);
}  
float calcolo1(float ritorno, float ris){
    operazioni();
    ritorno = ris;
    int v, valore;
    float num1, num2; // SOMMA - SOTTRAZIONE - MOLTIPLICAZIONE
    float num, nuM; // DIVISONE
    float numero, potenza, risultato, n, p; // POTENZA
    ritorno = ris;
   
    scanf("%d", &valore);
   
    switch(valore){
        case 0:
            printf("");
        break;
        case 1:
            somma(num1, num2, ris);
   
        break;
        case 2:
            sottrazione(num1, num2, ris);
   
        break;
        case 3:
            moltiplicazione(num1, num2, ris);
   
        break;
        case 4:
            divisione(num, nuM, ris);
   
        break;
        case 5:
            potenz(numero, potenza, risultato, n, p, ris);
   
        break;
        case 6:
            conve(numero, ris, v);
   
        break;
        default:
            printf("Hai sbagliato!! Riprova:\n\n");
            calcolo(ritorno, ris);
   
           
    }
    continuare();
    return(ritorno);
}
void continuare(){
    float ritorno, ris;
    int i;
    int *pointer = &i;
    pointer = (int*)malloc(sizeof(int)*1);
    printf("\nVuoi continuare?\n");
    printf("0) Si\n");
    printf("1) No\n");
    scanf("%i", &i);
        switch(i){
            case 0:
                calcolo(ritorno, ris);
            break;
            case 1:
            break;
            default:
                fprintf(stderr, "Hai sbagliato!!");
                continuare1();
        }
    free(pointer);
}
void continuare1(){
    float ritorno, ris;
    int i;
    int *pointer = &i;
    pointer = (int*)malloc(sizeof(int)*1);
    printf("\nVuoi continuare?\n");
    printf("0) Si\n");
    printf("1) No\n");
    scanf("%i", &i);
        switch(i){
            case 0:
                calcolo(ritorno, ris);
            break;
            case 1:
            break;
            default:
                fprintf(stderr, "Hai sbagliato!!");
                continuare();
        }
    free(pointer);
}

Usa variabili double. Comunque non ho idea cosa ti serva il puntatore a cui allochi memoria dinamicamente...

 

[JDany]

Usa variabili double. Comunque non ho idea cosa ti serva il puntatore a cui allochi memoria dinamicamente...

Perché mentre creavo questa calcolatrice stavo anche studiando l'"Allocazione Dinamica Della Memoria"; così per fare un po' di pratica li ho usati, non per altro.

Ok, userò variabili double.

 

[_Achille]

Perché mentre creavo questa calcolatrice stavo anche studiando l'"Allocazione Dinamica Della Memoria"; così per fare un po' di pratica li ho usati, non per altro.

Ok, userò variabili double.

L’allocazione dinamica non ha nulla a che fare con una calcolatrice. E ho visto che dai pure prima l’indirizzo di i al puntatore e poi allochi. Dare l’indirizzo è così inutile.
E sappi che i prototipi di funzione si fanno senza dichiarare completamente i parametri ma solo il tipo

 

[JDany]

L’allocazione dinamica non ha nulla a che fare con una calcolatrice. E ho visto che dai pure prima l’indirizzo di i al puntatore e poi allochi. Dare l’indirizzo è così inutile.
E sappi che i prototipi di funzione si fanno senza dichiarare completamente i parametri ma solo il tipo

Si ho letto che nei prototipi di funzione si può come non, dare i nomi ai parametri. Io lo faccio perché mi resta più comodo. Penso che sia un fatto oggettivo, ok che non gli interessa nulla del nome del parametro, ma per me è meglio così.
Per l'allocazione dinamica, ripeto, è solo per fare un po' di pratica non perché serve al programma.

 

[_Achille]

Si ho letto che nei prototipi di funzione si può come non, dare i nomi ai parametri. Io lo faccio perché mi resta più comodo. Penso che sia un fatto oggettivo, ok che non gli interessa nulla del nome del parametro, ma per me è meglio così.
Per l'allocazione dinamica, ripeto, è solo per fare un po' di pratica non perché serve al programma.

Lascia perdere in programmi che non centrano nulla con alcune cose. Si introduce solo altro margine d'errore. Se vuoi utilizzare la memoria dinamica creati una struttura array che quando gli dai la dimensione alloca il vettore.

 

[JDany]

Lascia perdere in programmi che non centrano nulla con alcune cose. Si introduce solo altro margine d'errore. Se vuoi utilizzare la memoria dinamica creati una struttura array che quando gli dai la dimensione alloca il vettore.

Ok ma non ho capito cosa hai scritto sopra per l'allocazione. Ho sbagliato a dare l'indirizzo di memoria ad un puntatore e poi ad allocarlo?

 

[Andretti60]

e' un problema di arrotondamento, i numeri sono raprresentati in memoria correttamente solo se sono una potenza di due. Mai usare float in C (e simili) ma sempre e solo double quando si fanno operazioni matematiche.
Questo mio codice funziona perfettamente:

void Dividi()
{
    double num1, num2, ris;
    printf("Numeratore: ");
    scanf("%lf", &num1);
    printf("Denominatore: ");
    scanf("%lf", &num2);
    ris = num1 / num2;
    printf("%-9.4lf / %-9.4lf = %-9.4lf\n", num1, num2, ris);
}

un appunto sulle dichiarazioni delle funzioni.
I parametri servono per passare dei valori, se i valori li inizializzi (come nel tuo caso leggendoli da tastiera) nella funzioni non c'e' bisogno che li passi. Lo stesso per il valore di ritorno, se non lo utilizzi dichiara la funzione void
A riguardo la allocazione di memoria, va bene che la stai provando ma rende piu' difficile leggere il tuo codice. La prossima volta pubblica solo le parti essenziali.

 

[JDany]

e' un problema di arrotondamento, i numeri sono raprresentati in memoria correttamente solo se sono una potenza di due. Mai usare float in C (e simili) ma sempre e solo double quando si fanno operazioni matematiche.
Questo mio codice funziona perfettamente:

void Dividi()
{
    double num1, num2, ris;
    printf("Numeratore: ");
    scanf("%lf", &num1);
    printf("Denominatore: ");
    scanf("%lf", &num2);
    ris = num1 / num2;
    printf("%-9.4lf / %-9.4lf = %-9.4lf\n", num1, num2, ris);
}

un appunto sulle dichiarazioni delle funzioni.
I parametri servono per passare dei valori, se i valori li inizializzi (come nel tuo caso leggendoli da tastiera) nella funzioni non c'e' bisogno che li passi. Lo stesso per il valore di ritorno, se non lo utilizzi dichiara la funzione void
A riguardo la allocazione di memoria, va bene che la stai provando ma rende piu' difficile leggere il tuo codice. La prossima volta pubblica solo le parti essenziali.

Anche io all'inizio avevo usato i double, solo che quando andavo tipo a mettere un numero come 12.345, il programma si arrestava quindi ho usato i float.
Per la memoria, la prossima volta pubblico senza di quella.
Comunque il valore di ritorno l'ho messo uguale al risultato, perché il valore che ritorna è un float quindi mi sembrava giusto.

 

[Andretti60]

Quando hai usato il tipo double, leggevi i numeri con il formato giusto (%lf) ?
Come ho gia' detto, se NON usi il valore di ritorno di una funzione, non ha alcun senso che ritorni un valore :)

 

[JDany]

Quando hai usato il tipo double, leggevi i numeri con il formato giusto (%lf) ?
Come ho gia' detto, se NON usi il valore di ritorno di una funzione, non ha alcun senso che ritorni un valore :)

No io leggevo con %d.
Ok, cambierò tutte le funzioni che ho creato con void.

 

[Andretti60]

No io leggevo con %d.
Ok, cambierò tutte le funzioni che ho creato con void.

"%d"? Ci credo che non funzionava, 'd' sta per 'decimal' ed e' usato per leggere interi.

http://www.cplusplus.com/reference/cstdio/scanf/

 

[JDany]

"%d"? Ci credo che non funzionava, 'd' sta per 'decimal' ed e' usato per leggere interi.

http://www.cplusplus.com/reference/cstdio/scanf/

Eh, lo so che sbagliavo. Da dove studiavo tralasciavano molte cose (html.it per intenderci :suicidio:). Però ora ho iniziato da zero prendendo il libro di Deitel sul C.