Question

我已经编写了一小段代码来计算二次方程，但如果判别式为负，我希望它写出这个二次方程没有真正的数值。为了实现这一点，我不得不调用第四个参数为0的函数，我认为，我不知道为什么，这将是一个糟糕的编程习惯？是这样的，还是我对我的代码过于挑剔？谢谢。（我之所以这么说是因为我不想在我的编程'职业生涯'早期发现一些坏习惯）。这是代码。

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

double quadratic_equation(double a, double b, double c, double d);

int main(void)
{
    char command[20];
    int i;

    printf("Enter your command: ");
    fgets(command, 20, stdin);

    for (i = 0; i < 20; i++) {
        if (command[i] == '\n') {
            command[i] = '\0';
            break;
        }
    }

    if (strcmp(command, "quadratic equation") == 0) {
        double a, b, c, x;

        printf("Enter A: ");
        scanf("%lf", &a);
        printf("Enter B: ");
        scanf("%lf", &b);
        printf("Enter C: ");
        scanf("%lf", &c);

        x = quadratic_equation(a, b, c, 0); // THIS PIECE HERE MIGHT BE BAD PRACITCE ? 

        if (x == 0) {
            printf("There are no real numerical values to this quadratic equation.");
        }

        else {
            printf("------------\n");
            printf("x1 = %.2f\n", quadratic_equation(a, b, c, 1));
            printf("x2 = %.2f", quadratic_equation(a, b, c, -1));
        }
    }

    return 0;
}

double quadratic_equation(double a, double b, double c, double d) {
    double discriminant, x, insideroot;

    insideroot = ((b*b) - (4*a*c));

    if (insideroot < 0) {
        return 0;
    }

    discriminant = sqrt(insideroot);
    x = (-b + (d * discriminant)) / (2 * a);

    return x;
}

非常感谢你的帮助：d！

Answer 1

这当然是不好的做法。由于公式a，b和c的根可以是任何double，做需要某种传递。

我建议一个参数，它是指向int的指针。如果指针是NULL，它将被忽略，否则它将被设置为1或0，具体取决于是否存在真正的根：

double quadratic_equation(double a, double b, double c, int *root_exists) {
    double discriminant;

    discriminant = ((b*b) - (4*a*c));

    if (discriminant < 0) {
        if (root_exists != NULL) *root_exists = 0;
        return 0.0;
    }

    x = (-b + sqrt(discriminant)) / (2 * a);

    if (root_exists != NULL) *root_exists = 1;

    return x;
}

更严格的方法是：

typedef struct {
    int num_roots;
    double roots[2];
} quadratic_roots_t;

quadratic_roots_t quadratic_equation(double a, double b, double c) {
    quadratic_roots_t roots;
    double d;

    d = b*b - 4*a*c;

    if (d < 0.0) {
        roots.num_roots = 0;
    } else if (d == 0.0) {
        roots.num_roots = 1;
        roots.roots[0] = -b / (2 * a);
    } else {
        roots.num_roots = 2;
        roots.roots[0] = (-b - sqrt(d)) / (2 * a);
        roots.roots[1] = (-b + sqrt(d)) / (2 * a);
    }

    return roots;
}

Answer 2

我说这样做并不好。你能做的就是这样：

int quadratic_equation(double a, double b, double c, double *root_a, double *root_b) {
    double discriminant = ((b*b) - (4*a*c));

    if (discriminant < 0) {
        return -1;
    }

    if (root_a != NULL) {
        *root_a = (-b + sqrt(discriminant)) / (2 * a);
    }
    if (root_b != NULL) {
        *root_b = (-b - sqrt(discriminant)) / (2 * a);
    }

    return 0;
}

然后你可以这样称呼它：

double root_a;
double root_b;
int ok = quadratic_equation(a, b, c, &root_a, &root_b);
if (ok < 0) {
    // It wasn't OK. Print out an error.
} else {
    // It was OK. Print out the results.
}

请注意，您还应该检查函数中的其他错误情况，并为它们返回-1。例如。 a为零。

Answer 3

考虑使用返回值来指示是否一切正常，并将数组传递给函数以接收返回值：

enum QE_Status { QE_OK = 0, QE_NON_QUADRATIC, QE_COMPLEX_ROOTS, QE_NULL_POINTER };

enum QE_Status quadratic_equation(double a, double b, double c, double *r)
{
    double discriminant;

    if (r == 0)
        return QE_NULL_POINTER;
    if (a == 0.0)
        return QE_NON_QUADRATIC;

    discriminant = (b * b) - (4 * a * c);

    if (discriminant < 0)
        return QE_COMPLEX_ROOTS;

    discriminant = sqrt(discriminant);
    r[0] = (-b + discriminant) / (2 * a);
    r[1] = (-b - discriminant) / (2 * a);
    return QE_OK;
}

您可以扩展系统以处理数值不稳定（因为b*b几乎等于4*a*c，或者因为a非常小，等等。）

调用代码可以是：

 double a, b, c, x[2];

 if (quadratic_equation(a, b, c, x))
     ...oops, something went wrong...

或者：

 switch (quadratic_equation(a, b, c, x))
 {
 case QE_OK:
     ...print or use results in x...
     break;
 case QE_NON_QUADRATIC:
 case QE_COMPLEX_ROOTS:
     ...print appropriate error message about user's data...
     break;
 case QE_NULL_POINTER:
     ...Oops - programming error...
     break;
 }

Answer 4

我当然称之为不好的做法，因为代码很不清楚。

首先，你应该调用该函数三次，一次就足够了。

我会考虑在quadratic_equation()函数中返回/填充列表，而不是逐个返回根。

这也可以让你确定是否有真正的根 - 如果没有，只返回一个空列表。

总的来说，这将比您当前的解决方案更优雅，并且无需事先检查是否有任何解决方案。

C编程好的做法与否？

4 个答案: