Comment retourner une valeur avec la fonction vide sans paramètre c

Question

Je suis nouveau langage C et le codage et je rencontrais une question me demandant de changer l'en-tête de fonction:

float RealRoot_1(float a, float b, float c); 
float RealRoot_2(float a,float b,float c); 

pour devenir:

void RealRoot_1(void); 
void RealRoot_2(void); 

On m'a dit que cela avait quelque chose à voir avec les variables globales mais je n'arrivais toujours pas à le comprendre après avoir essayé assez longtemps. Quelqu'un peut-il expliquer s'il vous plaît sur la façon de le faire? Merci beaucoup.

Le fichier source est comme ci-dessous:

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

int main() 
{ 
    float RealRoot_1(float a, float b, float c); // Prototype declaration 
    float RealRoot_2(float a, float b, float c);  

    // Defining Input Variables 
    float x, y, z; 

    // Defining Output Variables 
    float Root_1, Root_2; 

    printf("Please enter the factor of X^2: "); 
    scanf("%f",&x); 

    printf("Please enter the factor of X: "); 
    scanf("%f",&y); 

    printf("Please enter the free factor: "); 
    scanf("%f",&z); 

    Root_1 = RealRoot_1(x,y,z); 
    Root_2 = RealRoot_2(x,y,z); 

    printf("the First Root is: %f \n", Root_1); 
    printf("the Second Root is: %f \n", Root_2); 

    system("pause"); 
} 


float RealRoot_1(float a, float b, float c) 
{ 
    float x; 
    x = (-1*b + sqrt(pow(b,2) - 4 * a * c))/(2 * a); 

    return x; 
} 

float RealRoot_2(float a, float b, float c) 
{ 
    float x; 
    x = (-1*b - sqrt(pow(b,2) - 4 * a * c))/(2 * a); 

    return x; 
} 

Answer 1

Cela peut être fait en utilisant des variables globales. Vous devez vous assurer que les noms de variables utilisés dans la fonction sont les mêmes que ceux utilisés dans le code principal.

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

void RealRoot_1(void); // Prototype declaration 
void RealRoot_2(void);   

float x, y, z; 
float Root_1, Root_2; 

int main() 
{ 

    // Defining Output Variables 

    printf("Please enter the factor of X^2: "); 
    scanf("%f",&x); 

    printf("Please enter the factor of X: "); 
    scanf("%f",&y); 

    printf("Please enter the free factor: "); 
    scanf("%f",&z); 

    RealRoot_1(); 
    RealRoot_2(); 

    printf("the First Root is: %f \n", Root_1); 
    printf("the Second Root is: %f \n", Root_2); 

    system("pause"); 
} 


void RealRoot_1(void) 
{ 
    Root_1 = (-1*y + sqrt(pow(y,2) - 4 * x * z))/(2 * x); 
} 

void RealRoot_2(void) 
{ 
    Root_2 = (-1*y - sqrt(pow(y,2) - 4 * x * z))/(2 * x); 
} 

S'il vous plaît noter que ce est pire façon de faire que ce qui était donné dans le problème initial. Dans l'exercice initial. Vous perdez la modularité et utiliser trop de globals est en général une mauvaise idée.

Vous pouvez également voir Are global variables bad?

Answer 2

Cela devrait être explicite:

float RR_a, RR_b, RR_c; 
float RR_d; // store result here(like a return value) 

void RealRoot_1(void); // prototypes 
void RealRoot_2(void); 

void main(void) 
{ 
    printf("Please enter the factor of X^2: "); 
    scanf("%f",&RR_a); 

    printf("Please enter the factor of X: "); 
    scanf("%f",&RR_b); 

    printf("Please enter the free factor: "); 
    scanf("%f",&RR_c); 

    RealRoot_1(); 
    printf("the First Root is: %f \n", RR_d); 

    RealRoot_2(); 
    printf("the Second Root is: %f \n", RR_d); 

    system("pause"); 
} 

void RealRoot_1(void) 
{ 
    float x; 
    x = (-1*RR_b + sqrt(pow(RR_b,2) - 4 * RR_a * RR_c))/(2 * RR_a); 

    RR_d = x; 
} 

void RealRoot_2(void) 
{ 
    float x; 
    x = (-1*RR_b - sqrt(pow(RR_b,2) - 4 * RR_a * RR_c))/(2 * RR_a); 

    RR_d = x; 
} 

Notez que après avoir appelé RealRoot_1 nous imprimons maintenant le résultat avant d'appeler RealRoot_2. C'est parce que le résultat de RealRoot_1 qui est stocké dans RR_d est écrasé par RealRoot_2, donc il est perdu. Vous pouvez contourner ceci en déclarant une deuxième variable de retour, RR_d_2 et en y stockant le résultat de RealRoot_2.

Nous n'avons pas besoin de doublons pour RR_a, RR_b ou RR_c car leurs valeurs ne sont pas modifiées dans les fonctions.

Cette façon d'écrire des fonctions a des limites, ce qui sera évident en présence de récursivité ou de multi-threading.