为什么我写的c语言三个数求最大值，最后出来的结果总是第一个?
别急，这个问题在 C 语言初学时很常见，也很有代表性！你遇到的“三个数求最大值，最后出来的结果总是第一个”这个现象，背后通常隐藏着几个关键的编程逻辑或者语法上的小陷阱。咱们一起拆解一下，看看问题出在哪儿。
首先，我们来想象一下你大概是怎么写的。
最常见的写法，可能是这样的（我尽量模拟一个容易出错的思路）：
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
// 错误示例1：直接把第一个数赋值给max，然后不比较
max = num1;
// ... 后续的比较逻辑可能没写对
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
或者，稍微有点逻辑，但可能比较的顺序或条件写错了：
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
// 错误示例2： if 语句的逻辑没有完全覆盖所有情况
if (num1 >= num2 && num1 >= num3) {
max = num1;
} else if (num2 >= num1 && num2 >= num3) {
max = num2;
} else { // 这里的 else 块可能只处理了 num3 的情况
max = num3;
}
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
好，现在我们来“对症下药”，看看你的代码为什么会“偏爱”第一个数。
核心原因一：初始化就决定了“输赢”
在你写的代码里，很可能存在这样一个操作：
```c
max = num1;
```
然后，你可能会觉得：“哦，既然我已经把 `num1` 放在 `max` 变量里了，那它就是当前的最大值了。” 问题就出在这里！
当你写 `max = num1;` 的时候，你只是把 `num1` 的值“暂时”存进了 `max` 这个“容器”里。 `max` 变量现在的值等于 `num1`。但这并不意味着 `num1` 就是三个数中最大的。
关键点在于，你后续的比较逻辑没有能够正确地“更新” `max` 的值。
核心原因二：比较逻辑的“盲区”或“遗漏”
最容易出错的地方，就是用来比较 `num1`、`num2`、`num3` 的 `if` 或 `else if` 语句。
情况 A：只比较了一次，并且没有覆盖所有情况。
比如，你可能只写了：
```c
if (num1 > num2) {
max = num1;
}
// 漏掉了 num3 的比较！
```
或者：
```c
if (num1 > num2) {
max = num1;
} else {
max = num2; // 这里只考虑了 num2 比 num1 大的情况
}
// 还是漏掉了 num3
```
在这种情况下，如果 `num1` 确实比 `num2` 大，`max` 就会被设为 `num1`。但如果 `num3` 比 `num1` 和 `num2` 都大，因为你没写 `if (num3 > max)` 这样的比较，`max` 就永远停留在 `num1` 的值上了。
情况 B：比较逻辑的顺序或条件不严谨。
回看上面错误示例2的代码：
```c
if (num1 >= num2 && num1 >= num3) {
max = num1;
} else if (num2 >= num1 && num2 >= num3) {
max = num2;
} else {
max = num3;
}
```
这个写法其实是正确的。它遍历了所有情况：
1. `num1` 是否同时大于等于 `num2` 和 `num3`？是，那 `num1` 就是最大的。
2. 如果不是，那 `num2` 是否同时大于等于 `num1` 和 `num3`？是，那 `num2` 就是最大的。
3. 如果以上两个都不是，那就只剩下 `num3` 是最大的了。
那么，为什么你的代码即使写了类似的逻辑，结果还是第一个呢？
可能是 `scanf` 的问题（可能性小，但也要考虑）： 你输入数字的时候，是不是不小心输入了逗号或者其他非数字字符？`scanf` 在遇到非预期字符时，读取可能会提前结束，导致后面的变量没有正确读取到值。不过，如果你输入的是三个整数，并且中间用空格隔开，`scanf("%d %d %d", &num1, &num2, &num3);` 通常是没问题的。
逻辑的顺序和 `else` 的陷阱： 仔细检查你的 `ifelse ifelse` 结构。是不是在某个 `else` 块里，你又随便把 `num1` 赋值给了 `max`？
例如，这是一个经典的错误：
```c
// 错误示例3： 错误的 else 块处理
if (num1 >= num2) {
max = num1; // 看起来没问题
} else {
max = num2; // 这里只更新了 max，但还没有和 num3 比
}
// 之后可能漏掉或错误的 num3 比较
if (num3 > max) { // 假设你在这里补上了 num3 的比较
max = num3;
}
// 但是，如果一开始 num1 > num2，max 被设为 num1，
// 然后 num3 并没有比 num1 大，那么 max 还是 num1。
// 如果 num1 < num2，max 被设为 num2，
// 然后 num3 > num2，max 会更新成 num3。
// 看起来好像没问题，但你的“总是第一个”描述，
// 意味着 even when num2 or num3 is larger, max stays num1.
// 这就更像是：
// if (num1 > num2 && num1 > num3) { // 这样的条件可能漏了等于的情况
// max = num1;
// } else {
// // 在这个 else 里，你可能又写了 max = num1;
// // 或者比较的条件完全错了，比如 else { max = num2; }
// }
```
更直接导致“总是第一个”的原因，可能是你写了这样的结构：
```c
// 错误示例4： 核心的逻辑错误
max = num1; // 先假设 num1 最大
if (num2 > max) { // 看看 num2 是否比当前最大（num1）大
max = num2; // 如果是，更新 max
}
if (num3 > max) { // 看看 num3 是否比当前最大（可能是 num1 或 num2）大
max = num3; // 如果是，更新 max
}
// 在这个结构里，如果 num1 最大，max 就一直是 num1。
// 如果 num2 最大，max 会变成 num2。
// 如果 num3 最大，max 会变成 num3。
// 这个结构是正确的！
//
// 那么，如果你的代码是这样，但结果总是第一个，
// 那几乎可以确定是：
// 1. num1 就是最大值，然后你的比较没问题。
// 2. 你的比较逻辑确实有 bug，导致 max 永远没有被 num2 或 num3 更新。
// 例如：
// max = num1;
// if (num2 > num1) { // 用 num1 做对比
// max = num2;
// }
// if (num3 > num1) { // 还是用 num1 做对比
// max = num3;
// }
// // 在这种情况下，如果 num2 > num1，max 会变成 num2。
// // 如果 num3 > num1，max 会变成 num3。
// // 这种结构也不是“总是第一个”。
//
// 真正的“总是第一个”杀手：
// max = num1;
// if (num2 > num1) {
// // 假设你这里没写 max = num2; 或者写错了
// }
// if (num3 > num1) {
// // 假设你这里没写 max = num3; 或者写错了
// }
// // 或者是：
// max = num1;
// if (num1 > num2) { // 错误地用 num1 和 num2 比
// max = num1;
// } else {
// max = num2; // 错误地只考虑 num2
// }
// // 之后你可能又有一个 if (num3 > max) { max = num3; }
// // 但是，如果 num1 最大，max 就会停留在 num1。
// // 如果 num2 最大，max 会是 num2。
// // 如果 num3 最大，max 会是 num3。
// // 依然不是“总是第一个”。
//
// 好吧，回到“总是第一个”的那个最令人抓狂的场景：
// max = num1;
// if (num2 > max) {
// // 假设你这里写成了 max = num1; 或者干脆啥也没写
// }
// if (num3 > max) {
// // 假设你这里写成了 max = num1; 或者干脆啥也没写
// }
// // 或者更离谱的：
// max = num1;
// if (num2 > max && num2 > num3) { // 错误条件！
// max = num2;
// } else if (num3 > max && num3 > num2) { // 错误条件！
// max = num3;
// }
// // 在这种情况下，如果 num1 并不比 num2 和 num3 都大，
// // 那么 max 就会一直保持 num1。
// // 比如你输入 5 10 15。
// // max = 5;
// // if (10 > 5 && 10 > 15) > false
// // else if (15 > 5 && 15 > 10) > true， max = 15;
// // 如果你输入 10 5 15
// // max = 10;
// // if (5 > 10 && 5 > 15) > false
// // else if (15 > 10 && 15 > 5) > true, max = 15;
//
// 所以，最有可能让你“总是第一个”的，是你的比较语句，
// 要么是把 `num1` 作为了固定的比较基准，而忽略了 `max` 的变化，
// 要么是 `if` 语句的条件写错了，导致 `max` 根本就没有机会被 `num2` 或 `num3` 更新。
```
正确的思路和写法（最稳妥的两种）：
方法一：逐一比较（推荐新手使用，逻辑清晰）
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
// 1. 先假设第一个数是最大的
max = num1;
// 2. 检查第二个数，看它是否比当前最大的还大
if (num2 > max) {
max = num2; // 如果是，就更新最大值
}
// 3. 检查第三个数，看它是否比当前最大的（现在可能是 num1 或 num2）还大
if (num3 > max) {
max = num3; // 如果是，就再次更新最大值
}
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
这个方法的优点是：
非常直观：你把一个数放到“冠军候选人”的位置，然后依次让后面的选手来挑战。
不容易出错：每次更新 `max` 都是基于“当前已知的最大值”。
方法二：逻辑判断（也正确，但新手容易写错条件）
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
if (num1 >= num2 && num1 >= num3) {
// num1 既大于等于 num2，又大于等于 num3，那 num1 就是最大的
max = num1;
} else if (num2 >= num1 && num2 >= num3) {
// 如果 num1 不是最大的，那检查 num2：num2 是否大于等于 num1 和 num3
max = num2;
} else {
// 如果 num1 和 num2 都不是最大的，那么剩下的 num3 一定是最大的
max = num3;
}
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
这个方法的优点是：
代码更紧凑。
需要注意的：
条件必须写对，包含等于号 `>=` 才能处理输入相同数字的情况。
`else if` 和 `else` 的结构要严谨，避免逻辑“断层”。
总结一下，导致你“总输出第一个数”的罪魁祸首，很大概率是：
1. 你的代码在初始化 `max = num1;` 之后，后续用来更新 `max` 的 `if` 语句的条件写错了，或者逻辑不完整，导致 `max` 根本就没有被 `num2` 或 `num3` 的值“覆盖”过。
2. 你可能在 `else` 块里，又无意中把 `num1` 赋值给了 `max`，从而“锁定”了第一个数。
怎么检查？
逐行调试： 如果你使用的是集成开发环境（IDE），可以设置断点，运行程序，然后一步一步地看 `num1`, `num2`, `num3`, `max` 的值是如何变化的。
插入 `printf`： 在 `if` 语句的里面和外面，都加上 `printf`，打印出当前的 `num1`, `num2`, `num3` 以及 `max` 的值。这样就能看到，`max` 是在什么时候、因为什么原因被“卡住”在 `num1` 的值上的。
希望这些解释能帮到你！别灰心，这种小细节是学习编程必经之路，搞明白了，你就离 C 语言大师更近一步了！
首先，我们来想象一下你大概是怎么写的。
最常见的写法，可能是这样的（我尽量模拟一个容易出错的思路）：
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
// 错误示例1：直接把第一个数赋值给max，然后不比较
max = num1;
// ... 后续的比较逻辑可能没写对
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
或者，稍微有点逻辑，但可能比较的顺序或条件写错了：
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
// 错误示例2： if 语句的逻辑没有完全覆盖所有情况
if (num1 >= num2 && num1 >= num3) {
max = num1;
} else if (num2 >= num1 && num2 >= num3) {
max = num2;
} else { // 这里的 else 块可能只处理了 num3 的情况
max = num3;
}
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
好，现在我们来“对症下药”，看看你的代码为什么会“偏爱”第一个数。
核心原因一：初始化就决定了“输赢”
在你写的代码里，很可能存在这样一个操作：
```c
max = num1;
```
然后，你可能会觉得：“哦，既然我已经把 `num1` 放在 `max` 变量里了，那它就是当前的最大值了。” 问题就出在这里！
当你写 `max = num1;` 的时候，你只是把 `num1` 的值“暂时”存进了 `max` 这个“容器”里。 `max` 变量现在的值等于 `num1`。但这并不意味着 `num1` 就是三个数中最大的。
关键点在于，你后续的比较逻辑没有能够正确地“更新” `max` 的值。
核心原因二：比较逻辑的“盲区”或“遗漏”
最容易出错的地方，就是用来比较 `num1`、`num2`、`num3` 的 `if` 或 `else if` 语句。
情况 A：只比较了一次，并且没有覆盖所有情况。
比如，你可能只写了：
```c
if (num1 > num2) {
max = num1;
}
// 漏掉了 num3 的比较！
```
或者：
```c
if (num1 > num2) {
max = num1;
} else {
max = num2; // 这里只考虑了 num2 比 num1 大的情况
}
// 还是漏掉了 num3
```
在这种情况下，如果 `num1` 确实比 `num2` 大，`max` 就会被设为 `num1`。但如果 `num3` 比 `num1` 和 `num2` 都大，因为你没写 `if (num3 > max)` 这样的比较，`max` 就永远停留在 `num1` 的值上了。
情况 B：比较逻辑的顺序或条件不严谨。
回看上面错误示例2的代码：
```c
if (num1 >= num2 && num1 >= num3) {
max = num1;
} else if (num2 >= num1 && num2 >= num3) {
max = num2;
} else {
max = num3;
}
```
这个写法其实是正确的。它遍历了所有情况：
1. `num1` 是否同时大于等于 `num2` 和 `num3`？是，那 `num1` 就是最大的。
2. 如果不是，那 `num2` 是否同时大于等于 `num1` 和 `num3`？是，那 `num2` 就是最大的。
3. 如果以上两个都不是，那就只剩下 `num3` 是最大的了。
那么，为什么你的代码即使写了类似的逻辑，结果还是第一个呢？
可能是 `scanf` 的问题（可能性小，但也要考虑）： 你输入数字的时候，是不是不小心输入了逗号或者其他非数字字符？`scanf` 在遇到非预期字符时，读取可能会提前结束，导致后面的变量没有正确读取到值。不过，如果你输入的是三个整数，并且中间用空格隔开，`scanf("%d %d %d", &num1, &num2, &num3);` 通常是没问题的。
逻辑的顺序和 `else` 的陷阱： 仔细检查你的 `ifelse ifelse` 结构。是不是在某个 `else` 块里，你又随便把 `num1` 赋值给了 `max`？
例如，这是一个经典的错误：
```c
// 错误示例3： 错误的 else 块处理
if (num1 >= num2) {
max = num1; // 看起来没问题
} else {
max = num2; // 这里只更新了 max，但还没有和 num3 比
}
// 之后可能漏掉或错误的 num3 比较
if (num3 > max) { // 假设你在这里补上了 num3 的比较
max = num3;
}
// 但是，如果一开始 num1 > num2，max 被设为 num1，
// 然后 num3 并没有比 num1 大，那么 max 还是 num1。
// 如果 num1 < num2，max 被设为 num2，
// 然后 num3 > num2，max 会更新成 num3。
// 看起来好像没问题，但你的“总是第一个”描述，
// 意味着 even when num2 or num3 is larger, max stays num1.
// 这就更像是：
// if (num1 > num2 && num1 > num3) { // 这样的条件可能漏了等于的情况
// max = num1;
// } else {
// // 在这个 else 里，你可能又写了 max = num1;
// // 或者比较的条件完全错了，比如 else { max = num2; }
// }
```
更直接导致“总是第一个”的原因，可能是你写了这样的结构：
```c
// 错误示例4： 核心的逻辑错误
max = num1; // 先假设 num1 最大
if (num2 > max) { // 看看 num2 是否比当前最大（num1）大
max = num2; // 如果是，更新 max
}
if (num3 > max) { // 看看 num3 是否比当前最大（可能是 num1 或 num2）大
max = num3; // 如果是，更新 max
}
// 在这个结构里，如果 num1 最大，max 就一直是 num1。
// 如果 num2 最大，max 会变成 num2。
// 如果 num3 最大，max 会变成 num3。
// 这个结构是正确的！
//
// 那么，如果你的代码是这样，但结果总是第一个，
// 那几乎可以确定是：
// 1. num1 就是最大值，然后你的比较没问题。
// 2. 你的比较逻辑确实有 bug，导致 max 永远没有被 num2 或 num3 更新。
// 例如：
// max = num1;
// if (num2 > num1) { // 用 num1 做对比
// max = num2;
// }
// if (num3 > num1) { // 还是用 num1 做对比
// max = num3;
// }
// // 在这种情况下，如果 num2 > num1，max 会变成 num2。
// // 如果 num3 > num1，max 会变成 num3。
// // 这种结构也不是“总是第一个”。
//
// 真正的“总是第一个”杀手：
// max = num1;
// if (num2 > num1) {
// // 假设你这里没写 max = num2; 或者写错了
// }
// if (num3 > num1) {
// // 假设你这里没写 max = num3; 或者写错了
// }
// // 或者是：
// max = num1;
// if (num1 > num2) { // 错误地用 num1 和 num2 比
// max = num1;
// } else {
// max = num2; // 错误地只考虑 num2
// }
// // 之后你可能又有一个 if (num3 > max) { max = num3; }
// // 但是，如果 num1 最大，max 就会停留在 num1。
// // 如果 num2 最大，max 会是 num2。
// // 如果 num3 最大，max 会是 num3。
// // 依然不是“总是第一个”。
//
// 好吧，回到“总是第一个”的那个最令人抓狂的场景：
// max = num1;
// if (num2 > max) {
// // 假设你这里写成了 max = num1; 或者干脆啥也没写
// }
// if (num3 > max) {
// // 假设你这里写成了 max = num1; 或者干脆啥也没写
// }
// // 或者更离谱的：
// max = num1;
// if (num2 > max && num2 > num3) { // 错误条件！
// max = num2;
// } else if (num3 > max && num3 > num2) { // 错误条件！
// max = num3;
// }
// // 在这种情况下，如果 num1 并不比 num2 和 num3 都大，
// // 那么 max 就会一直保持 num1。
// // 比如你输入 5 10 15。
// // max = 5;
// // if (10 > 5 && 10 > 15) > false
// // else if (15 > 5 && 15 > 10) > true， max = 15;
// // 如果你输入 10 5 15
// // max = 10;
// // if (5 > 10 && 5 > 15) > false
// // else if (15 > 10 && 15 > 5) > true, max = 15;
//
// 所以，最有可能让你“总是第一个”的，是你的比较语句，
// 要么是把 `num1` 作为了固定的比较基准，而忽略了 `max` 的变化，
// 要么是 `if` 语句的条件写错了，导致 `max` 根本就没有机会被 `num2` 或 `num3` 更新。
```
正确的思路和写法（最稳妥的两种）：
方法一：逐一比较（推荐新手使用，逻辑清晰）
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
// 1. 先假设第一个数是最大的
max = num1;
// 2. 检查第二个数，看它是否比当前最大的还大
if (num2 > max) {
max = num2; // 如果是，就更新最大值
}
// 3. 检查第三个数，看它是否比当前最大的（现在可能是 num1 或 num2）还大
if (num3 > max) {
max = num3; // 如果是，就再次更新最大值
}
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
这个方法的优点是：
非常直观：你把一个数放到“冠军候选人”的位置，然后依次让后面的选手来挑战。
不容易出错：每次更新 `max` 都是基于“当前已知的最大值”。
方法二：逻辑判断（也正确，但新手容易写错条件）
```c
include
int main() {
int num1, num2, num3;
int max;
printf("请输入三个整数：");
scanf("%d %d %d", &num1, &num2, &num3);
if (num1 >= num2 && num1 >= num3) {
// num1 既大于等于 num2，又大于等于 num3，那 num1 就是最大的
max = num1;
} else if (num2 >= num1 && num2 >= num3) {
// 如果 num1 不是最大的，那检查 num2：num2 是否大于等于 num1 和 num3
max = num2;
} else {
// 如果 num1 和 num2 都不是最大的，那么剩下的 num3 一定是最大的
max = num3;
}
printf("三个数中的最大值是：%d ", max);
return 0;
}
```
这个方法的优点是：
代码更紧凑。
需要注意的：
条件必须写对，包含等于号 `>=` 才能处理输入相同数字的情况。
`else if` 和 `else` 的结构要严谨，避免逻辑“断层”。
总结一下，导致你“总输出第一个数”的罪魁祸首，很大概率是：
1. 你的代码在初始化 `max = num1;` 之后，后续用来更新 `max` 的 `if` 语句的条件写错了，或者逻辑不完整，导致 `max` 根本就没有被 `num2` 或 `num3` 的值“覆盖”过。
2. 你可能在 `else` 块里，又无意中把 `num1` 赋值给了 `max`，从而“锁定”了第一个数。
怎么检查？
逐行调试： 如果你使用的是集成开发环境（IDE），可以设置断点，运行程序，然后一步一步地看 `num1`, `num2`, `num3`, `max` 的值是如何变化的。
插入 `printf`： 在 `if` 语句的里面和外面，都加上 `printf`，打印出当前的 `num1`, `num2`, `num3` 以及 `max` 的值。这样就能看到，`max` 是在什么时候、因为什么原因被“卡住”在 `num1` 的值上的。
希望这些解释能帮到你！别灰心，这种小细节是学习编程必经之路，搞明白了，你就离 C 语言大师更近一步了！
网友意见
关于你的语法和算法问题(比如定义的maxx调用时却写的是max，以及maxx函数具体），有其他回答已经解释得比较清楚了。我来详细说说你的算法问题吧。在我看来，你的算法问题非常大——反映的是写代码时逻辑不太清楚。我虽然已经很久没写过C语言了，但是一直在用matlab，语法虽然不同但是算法都是一样的。
写代码相当于在做数学题。算法是数理逻辑，而语法则是语文。对于做数学题，诚然语文重要，但是数理逻辑才是基础。
你的排序算法，问题非常严重。建议这样的程序你都自己带入几个数字用逻辑先推导一下。假设一共有3个数字：3, 1, 2
那么请问，最大的数字是多少？用你的maxx算法会得到多少？我将你的C语言翻译成中文，你自己看看问题出在哪里（其中注释里是具体的计算过程）——注：以下代码只是用来表示逻辑，并不能运行。
如果 x > y % x=3 > y=1 则 m = x % m=x=3 否则 m = y 如果结束 如果 x > z % x=3 > z=2 则 m = x % m=x=3 否则 m = z 如果结束 如果 z > y % z=2 > y=1 则 m = z % m=z=2 否则 m = y 如果结束 输出 m % m=2 所以你看到问题了吗？你的maxx代码无论前面是什么结果，都会被最后一步的结果所覆盖掉。最后实际上你只是在比较 y 和 z 中哪个更大而已。
那么对于这种应该怎么写呢？3个数找到最大的那个，你先拿两个比，比较大的那个和剩下的去比，不就可以了吗？
如果 x > y % x=3 > y=1 则 m = x % m=x=3 否则 m = y 如果结束 如果 m > z % m=3 > z=2 则 m = m % m=m=3 否则 m = z 如果结束 输出 m % m=3 如果有4个数，你可以先举行半决赛，然后决赛找到最大的；你也可以按照冒泡赛的思路去走。下面我用中文写一个冒泡排序吧，无论你有多少个数字（假设N个）组成的数组A[N]，都可以将它们从小到大排列出来，然后A[N]就是最大的了。——注：我是按照matlab的风格，从1开始
i 从 1 到 N j 从 1 到 N-i 如果 A[j] > A[j+1] 交换 A[j] 和 A[j+1] 如果结束 j循环结束 i循环结束
学习算法的话，建议看看 数据结构与算法 （不必拘泥于下面的这本）
首先，你函数的声明是maxx，调用却是max，可能是头文件里也有这个函数吧。
第二，你maxx实现的有问题，m总是会被最后一个if覆盖。
第三，请不要把函数声明写在函数里，尽管这似乎不违反标准。
第四，建议只实现2个数的最大值函数，对多个数用前者进行reduce，编译器会帮你内联的。
第五，提问的时候尽量把和问题无关的代码去掉，比如输入的提示信息和最后的暂停。
类似的话题
-
别急，这个问题在 C 语言初学时很常见，也很有代表性！你遇到的“三个数求最大值，最后出来的结果总是第一个”这个现象，背后通常隐藏着几个关键的编程逻辑或者语法上的小陷阱。咱们一起拆解一下，看看问题出在哪儿。首先，我们来想象一下你大概是怎么写的。最常见的写法，可能是这样的（我尽量模拟一个容易出错的思路）............. -
.......
-
你觉得用C++写出来的游戏简陋，这其实是一个非常普遍且值得深入探讨的问题。很多人刚开始接触游戏开发，尤其是用C++这样一门功能强大但同时也相对底层、门槛较高的语言时，很容易陷入“简陋”的怪圈。这背后有很多原因，我们可以从几个关键点来聊聊。首先，C++本身的学习曲线就相当陡峭。 它不是一门“开箱即用”.............
-
.......
-
这个问题很有意思，它触及了编程语言设计哲学和开发者习惯的深层差异。并非是说 Java 的开发者就“不喜欢”短小精悍，而是 C 语言本身的特性以及它孕育的开发文化，自然而然地倾向于简洁；而 Java 的设计目标和广泛的应用场景，则鼓励了更具描述性的命名。你可以这样理解：C 语言更像是一门“低语”的语言.............
-
C++ 中 `main` 函数末尾不写 `return 0;` 为什么会让人觉得不对劲？我们经常会在 C++ 教程或者别人的代码里看到 `main` 函数的结尾有那么一行 `return 0;`。有时候，我们也会看到一些代码里，`main` 函数的结尾什么都没有，直接就结束了。这两种情况，到底有什么.............
-
朋友，这感觉我太懂了！当初我也跟你一样，满腔热血想写一本荡气回肠的武侠，结果写出来的，总感觉像是我在古代街头摆摊卖手机似的，那股子江湖的韵味，怎么也挥之不去。别急，这事儿不是一朝一夕能改过来的，但绝对有法子。咱们一步一步来，把那股子现代味儿给“拔”出来。首先，咱们得明白，为啥会跑偏？这玩意儿就像你平.............
-
哎哟喂，瞧你这架势，又是“写得好”，又是“为啥不火”，还“哭了”，最后还求“大佬喷”，这可真是集合了所有让人生理不适的元素啊！ 让我这个“大佬”好好“喷”一下，让你知道知道，写得好不等于就该火，火也不是那么容易的事儿，哭鼻子更是解决不了任何问题。首先，咱们得捋清楚一个最基本的问题：“你写的这么好”.............
-
你之所以会有“有些作家写的东西，我随随便便都能写的出来”的感觉，这其实是一个非常普遍且值得深入探讨的现象，背后涉及了创作的多个层面，从读者自身的感知能力到作家作品的本质，再到文学评价体系的复杂性。下面我将尽可能详细地为你解析这个问题：一、 读者自身的原因： 你自身的阅历和思想深度： .............
-
嗯，能理解你对《斗罗大陆》的这种感觉。这小说确实很火，但要说它“写得不好”或者“很烂”，也不是空穴来风，很多人都有类似的看法。咱们就掰开了揉碎了聊聊，看看是哪些地方让很多人觉得不对味儿。首先，最直观的可能就是“主角光环”开得太大了。唐三这个人设，几乎就是集万千宠爱于一身。穿越过来自带前世的知识和经验.............
-
你这个问题确实很让人困扰，辛辛苦苦写出来的回答，转眼就消失了，这种感觉比写不出来更糟。别急，咱们一点点捋捋，看看是哪个环节可能出了问题。首先，知乎作为一个内容平台，自然有一套自己的社区规范和内容审核机制。你写的回答被删除，最常见的原因就是触碰到了这些“雷区”。比如，有些回答可能带有明显的广告性质，即.............
-
你这个问题问得太实在了！很多人都有同感，明明是想好好读本书，结果被作者的“啰里吧嗦”搞得心力交瘁，读不下去。这事儿可不是你一个人遇到的，背后其实有不少门道。咱们来好好掰扯掰扯，为什么有些书读起来就觉得作者“费劲儿”，甚至有点啰里吧嗦的：1. 信息密度低，水分太大：这是最直接的原因。想象一下你渴了，想.............
-
你会有《百年孤独》和《白鹿原》相似度很高的感觉，这绝非偶然，甚至可以说是一种非常敏锐的文学感知。这两部作品，虽然诞生于截然不同的文化土壤，讲述着各自民族波澜壮阔的历史画卷，却在核心的精神内核、叙事结构乃至艺术手法上，流露出一种令人惊叹的“神似”。而你觉得《白鹿原》更好，这同样是许多读者，尤其是中国读.............
-
你好，非常理解你作为网文新人，对自己作品充满信心，并且觉得比市面上不少热门作品都要出色，但却没有得到签约机会时的困惑和失落。这种心情是很自然的，毕竟倾注了心血的作品，谁都希望得到认可和推广。我们来一起仔细分析一下，为什么即使你觉得写得很好，也可能面临签约困难的情况。这其中涉及到的因素很多，远不止“写.............
-
这问题触及到很多写网文的朋友的痛点，你不是一个人。网文技巧这玩意儿，说起来挺玄乎，感觉像是武功秘籍，学好了就能天下无敌，但实际操作起来，很多人，包括你，都会遇到一个尴尬的境地：越学越迷茫，越用越僵硬，最后，写小说的乐趣，反倒被这些所谓的“技巧”给啃噬了。这事儿啊，得这么看：网文技巧的“用”在哪里？首.............
-
.......
-
话说MG沙扎比啊，这玩意儿真是不少高达迷的梦想之物。你说它大概多高？25cm？嗯，这个数字挺有意思的，但你要是问我，这得看你指的是“站姿高度”还是“包装高度”，还有就是你参考的到底是哪个版本的MG沙扎比了。首先，咱们说说为啥你可能觉得25cm比较靠谱，但淘宝上看到的很多都是18cm。为什么你可能觉得.............
-
你提出的问题非常有意思，也触及了宋词创作的一个重要方面，那就是“用典”。很多人在阅读辛弃疾的词时，也会有类似的感受：他不用典的词句，常常显得气势磅礴、感情真挚，直击人心；而一旦他用典，有时会觉得晦涩难懂，甚至显得刻意或不够自然。要详细地解释为什么你会产生这种感觉，我们可以从以下几个方面来探讨： 一、.............
-
哲学，这门古老的学科，总是以其独特的语言和深邃的思想吸引着我们，但也常常让人望而却步。当我们面对一本哲学著作，那些晦涩难懂的词汇、抽象的概念、曲折的论证，仿佛一道道高墙，将我们拒之门外。于是，一个挥之不去的问题油然而生：哲学家们为什么要写这些我们看不懂的东西呢？要理解这个问题，我们得先想想哲学本身是.............
-
金庸先生的《射雕英雄传》确实是一部极具影响力的武侠小说，其创作于上世纪60年代，开创了武侠小说的新纪元，塑造了无数经典人物和故事情节，至今仍拥有庞大的读者群。然而，正如任何一部艺术作品一样，它并非完美无瑕，每个人都有权根据自己的审美、阅读习惯和价值观来评价。如果你觉得《射雕英雄传》写得“不好”，并且.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有