C 我试图找到四个int中最大的一个。但程序不起作用

不同类型的答案正在出现。有时代码是有效的。有时候不是。我找不到解决办法

#include<stdio.h>

 int max_of_four (int a, int b, int c,int d)
   {
    
    if(a>b)
    { 
      if(a>c)
      {
        if(a>d)
        {
          printf("%d",a);
          }
          else
          { 
          printf ("%d", d);
          }
      }
    }
    else if (b>c)
    {
         if (b>d)
         {
            printf ("%d", b);
         }
         else 
         printf ("%d", d);
    }
    else if (c>d)
    {
        printf("%d", c);
    }
    else("%d",d);
    return a, b,c,d;
   }


 int main (void)
    {
      
      int a, b, c, d;
      
      scanf("%d %d %d %d", &a, &b, &c, &d);
      
      int ans = max_of_four(a, b, c, d);
      
      printf("%d", and);
    
      return 0;
   }

#包括
int max_of_four（int a，int b，int c，int d）
{
如果（a>b）
{ 
如果（a>c）
{
如果（a>d）
{
printf（“%d”，a）；
}
其他的
{ 
printf（“%d”，d）；
}
}
}
否则，如果（b>c）
{
如果（b>d）
{
printf（“%d”，b）；
}
其他的
printf（“%d”，d）；
}
否则如果（c>d）
{
printf（“%d”，c）；
}
否则（“%d”，d）；
返回a、b、c、d；
}
内部主（空）
{
INTA、b、c、d；
scanf（“%d%d%d%d”、&a、&b、&c、&d）；
int ans=四（a，b，c，d）中的最大值；
printf（“%d”，和）；
返回0；
}

您需要一个变量来存储最大值。当你找到最大的数字时，你只需要把它放在变量中求最大值

if(a>b) { 
    if(a>c) { 
        if(a>d) { 
            max = a;
...and so on...

然后在函数结束时返回变量

max

，然后在

main

中打印它。（您甚至可以在

max\u of_four（）

中打印值，但为什么要返回值？）

更好的办法是：

scanf("%d", &max);

for( i = 0; i < 3; i++ ) {

    scanf("%d", &n);

    if( n > max ) {
        max = n;
    }
}

scanf（“%d”和&max）；
对于（i=0；i<3；i++）{
scanf（“%d”和“&n”）；
如果（n>最大值）{
max=n；
}
}

或者，如果需要对输入执行其他操作，甚至可以使用数组

“代码有时有效，有时无效。我找不到解决方案。”

代码中的逻辑很难遵循，因此很容易忽略逻辑错误的原因

为了简化问题，这种方法将主要的重复逻辑封装到宏中，然后重复调用它。（请注意，这里也可以使用函数，在清理代码方面也有类似的好处。）

---

printf（）

如果OP需要查看中间结果，可以将语句添加回中，但保持原样以突出其简单性。

OP的原始版本

max\u of_four

并没有搜索所有可能性。搜索所有可能性的版本如下所示：

int max_of_four(int a, int b, int c, int d)
{
    if (a > b)
    {
        if (a > c)
        {
            if (a > d)
            {
                return a;
            }
            else
            {
                return d;
            }
        }
        else
        {
            if (c > d)
            {
                return c;
            }
            else
            {
                return d;
            }
        }
    }
    else
    {
        if (b > c)
        {
            if (b > d)
            {
                return b;
            }
            else
            {
                return d;
            }
        }
        else
        {
            if (c > d)
            {
                return c;
            }
            else
            {
                return d;
            }
        }
    }
}

这种方法的主要问题是代码量与2的n-1的幂成正比。通过对控制流进行一些谨慎的更改，可以减少一点，以避免重复相同的代码片段：

int max_of_four(int a, int b, int c, int d)
{
    if (a > b)
    {
        if (a > c)
        {
            if (a > d)
            {
                return a;
            }
            else
            {
                return d;
            }
        }
    }
    else
    {
        if (b > c)
        {
            if (b > d)
            {
                return b;
            }
            else
            {
                return d;
            }
        }
    }
    if (c > d)
    {
        return c;
    }
    else
    {
        return d;
    }
}

上述常见的片段组合技术节省了一些代码行，但程序员更难检查是否考虑了所有可能性，因为代码没有很好的“结构化”（在“结构化编程”的意义上）

一种简单得多的方法是使用变量跟踪最大值。此方法所需的代码量与n成正比：

int max_of_four(int a, int b, int c, int d)
{
    int m = a;
    if (m < b)
    {
        m = b;
    }
    if (m < c)
    {
        m = c;
    }
    if (m < d)
    {
        m = d;
    }
    return m;
}

intmax\u of四（inta，intb，intc，intd）
{
int m=a；
if（m
返回a、b、c、d这是什么？让一个函数只返回两个数字的
max
？然后将其用作
max（max（a，b），max（c，d））
。肯定会看起来更干净，性能可能会明显降低。
返回a、b、c、d
与
返回d基本相同
（假设没有使用
volatile
限定符声明）。可以使用一个变量：
int m=a
如果（m
如果（m
如果（m
返回m。有时，在对复杂问题进行故障排除时，一个好的开始是将复杂问题分解为它们的组成部分，然后逐个查看。当你查看整个代码库时，你无法识别任何组件，然后考虑简化算法。
int max_of_four(int a, int b, int c, int d)
{
    int m = a;
    if (m < b)
    {
        m = b;
    }
    if (m < c)
    {
        m = c;
    }
    if (m < d)
    {
        m = d;
    }
    return m;
}