Datasets:

Mxode

/

CSDN-Community-C-Language-3years

like 2

[ { "cid": "1", "user": "user-1", "content": "sum 是个随机值", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "明白了，谢谢", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "char p0[10]; strcpy(p0,p1); strcpy(p1,p2); strcpy(p2,p0);", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "多谢！！", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "没看明白你要干啥", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "已解决！", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "如果确实是空间限制引起的的话，堆栈说的是栈，和malloc系列没关系，上方的堆才是管这个的。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "我改了堆也不行，是通过用x64编译器才成功的😂", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "每个定义了 8个字符空间，输入多了就到了下一个的地方了，后面输入又会破坏前面渗透到其位置的，形成了前一个的前8个字符加后一个的（如果它也超长，还会向后继续），即最后的 11 是第二个的，可以第二个时输入 22 试试。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "我在第一条记录里输了这样三个字符串：\"11 11 11ssssssss\",\"22\",\"33\"。结果打印出来相应的是：\"11 11 1111\",\"22\",\"33\"，所有看起来第一个字符串末尾多出现的两个\"11\"不是来自第二个字符串\"22\"呀？", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "理解有误，后面的是第二记录的第一个域的字符串，不是同一记录的第二个域的；因为数据定义是同类的储存在一起的，不是同一记录储存在一起。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "哦哦", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "那个“说明”还不清楚？翻译下也没什么意思的。照着做就是了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "还有是否有将1/6转化为字符串的函数", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "f = (double)1 / 6; sprintf(s, \"%f\", (double)1/6); 是不是这意思？", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "是的谢谢，因为 / 得到的一直是整型 没考虑强转 原来强转就行了 谢谢", "referer": "user-1" }, { "cid": "4", "user": "user-0", "content": "麻烦能给我讲下原理吗？1/6等于0 强转之后应该还是0啊 有点不太明白", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "首先从日期（想必是年月日）规范为年份，也就是2月28日之前的日期只算到前一年。然后对于一个年份，从公元开始到这个年份共有多少个闰年是直接算的，y/4-y/100+y/400即可。两个年份算的闰年数一减即可。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "控制面板、程序和功能、Visual Studio xxxx、修复", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "一般是重新安装。或者看看这个文件被移到哪啦，拷回来。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "江湖救急", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "@赵4老师，过来帮忙", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "https://github.com/thradams/conio", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "？？？？", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "试试 TC2.0", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "？？你的意思是说开发环境有问题", "referer": "user-2" }, { "cid": "5", "user": "user-2", "content": "是吧，vc2008 没过，tc2.0 过了，大概就是了；题目本身应该也能看出来吧。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "你使用TC2.0编译能通过，是吗？哦，那应该就是开发环境的问题了。那个TC2.0的官网能顺便发一下？？", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "同出现复数定义不出来的问题，请问楼主解决了吗？", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "我用vs2022也出现这个问题了，看有的说是编译器不同的原因。请问楼主解决了吗？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "关闭UAC、防火墙、杀毒软件、……以管理员身份运行……", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "什么叫文件无法写入？截个图什么的说明一下呗？", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "scanf (\"%s\",&Text); 修改为 scanf (\"%s\",Text); 取掉前面的 &", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "定义 stu 里的应该是 struct student*next; 吧，有输入错误；其它还有类似的键入错误", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "100 - 1 - 0.5 = 98.5 / 5 ≈ 19100 - 5 - 0.5 = 94.5 / 1 ≈ 94 ----- 95?100 - 5 - 1 = 94 （94/0.5=188 > 100）", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "题目里 换成5元、1元、0.5元面值的零钱100张，以上三种面值的零钱至少有一张，限死了，再多循环也是无用功。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "每种都要有，那 0.5 最低只能 (100-5-1)=94 再乘以 2 又限制总共 100张，所以，合适的最大值似乎应该是 98；取大了也没太大关系，只是多算了些可能组合。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include<stdio.h> int main() { for (int i = 1; i < 8; i++) { int step = 6; int sum = 0; for (int j = 1; j <= i; j++) { if (j == 1) { sum = i; } else { sum += step; step--; } printf(\"%-4d\", sum); } printf(\"\\n\"); } return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "简化一些： #include <stdio.h> int main() { for (int i = 1, j = 1, k = 6; i < 8; j <= (k + 8) * i / 2 ? printf(\"%d \", j), j += k-- : (j = (puts(\"\"), ++i), k = 6)); return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "我来一种", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "供参考： #include <stdio.h> int main() { int i, j, n = 7, k; scanf(\"%d\", &n); for (i = 0; i < n; i++) { for (j = 0, k = i + 1; j <= i; k += (n - j - 1), j++) printf(j == i ? \"%d\\n\" : \"%-4d\", k); } return 0; }", "referer": "user-0" }, { "cid": "5", "user": "user-5", "content": "帅", "referer": "user-4" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf里面不能有\\n", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "第二个数4.3 写成了 4,3 了吧，即小数点写成了逗号", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢蠢死了", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-0", "content": "【UDT】求纯C语言实现的UDT库源码，急急急！！！", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "求纯C语言实现的UDP库源码，有重谢！！！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "是什么问题我也是这样，我找不到原因", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "啊我找到问题了，把char打成int了。谢谢各位啊", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "board初始化为{0}， printf(\"%c\", board.....); 这个打不出东西的。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "这个我改好了", "referer": "user-2" }, { "cid": "5", "user": "user-2", "content": "觉得你用的竖线是全角字符，横线和空格是半角字符，全都改成一样的字符应该就可以啦。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "不是欸，我试了全半角一样不行", "referer": "user-2" }, { "cid": "7", "user": "user-0", "content": "这个是我输出的结果", "referer": "user-0" }, { "cid": "8", "user": "user-3", "content": "看着不象是字体的缘故。那就单步吧，就看第一行，首个空好像是 3 个空格大小，而中间的却似 2 个，绘制语句一个字符一个字符地运行了看，哪里有不对。", "referer": "user-0" }, { "cid": "9", "user": "user-3", "content": "命令行窗口的字体不是等距字体？", "referer": "user-0" }, { "cid": "10", "user": "user-0", "content": "什么意思，能详细说下吗", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-1", "content": "char *p;只是给申请了指针变量p的地址，地址的值不能被修改。char [] p=\"ABCDE\";是将字符串的值放进了找个字符数组里，这种写法会自动补全\"\\0\"", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "这说法不对哦，是指针p指向了常量区，常量区内存不允许被修改。char []p 本身会放一份在常量区，并且会在栈中开辟一块内存区域，并把常量区的字符复制到来。 以上两种都会默认加“\\0”。", "referer": "user-1" }, { "cid": "3", "user": "user-3", "content": "constint,AMOMNT=?", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "char * p = \"ABCDE\";指向的是常量的地址，不可以修改。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "...是什么让你认为能在用户态的程序里面调用内核函数？", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "使用驱动模块的方式是可以的，只是觉得这种方法太复杂", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "那是必然的啊，自己挂个驱动封装 ioctl 算了", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "还有其它不用驱动这种的方法吗？", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "赋值=的优先级比较低，所以先计算 getchar() != '\\n' ，结果赋值给 c[i]", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "(c[i] = getchar()) != '\\n'", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢彭于晏！", "referer": "user-1" }, { "cid": "4", "user": "user-2", "content": "(c[i] = getchar()) != '\\n", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "谢谢吴彦祖！", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "在头文件前加这一段代码#define _CRT_SECURE_NO_WARNINGS", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "scanf返回值被忽略 就是scanf有一个返回值，是返回接收到的数据的个数，如果你用不到这个参数，可以不用管他 putchar(a);这是一个问题，a是双精度浮点数，你用输出字符的函数去输出，这是无理的行为，不会有正确结果的，应该用printf(\"%lf\\n\",a)输出，另外，程序中的错误提示意思是使用了不安全的函数scanf 可以改用scanf_s 函数代替。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "putchar((int)a);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "好像是PlayMusic函数后加个循环，否则程序直接结束了。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "assert(40-1<strlen(\"D:\\\\music\\\\You_Never_Leave.mp3 alias bkmusic\"));", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "赵老师最近回答的水平偏低啊，拼接上 alias bkmusic 的那段是 70 的长度", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "#include <stdio.h> int main() { float fahr,celsius; //float fahr, float celsius; int step; float lower,upper; //float lower, float upper; lower = 0, upper = 300.00, step = 20; fahr = lower; while (fahr <= upper) { celsius = (5.0 / 9.0) * (fahr - 32.0); printf(\"fahr:%f℉, celsius:%f℃\\n\",fahr,celsius); fahr = fahr + step; //return 0; } return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "搞明白了，非常感谢！", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "类型声明的格式是一个类型，后面跟一个或多个被声明的标识符，多个的情况用逗号分隔，最后用分号结束。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "没看懂，请问要怎么修改？", "referer": "user-2" }, { "cid": "5", "user": "user-0", "content": "搞明白了，非常感谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "我都是复制错误信息直接百度", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "sqrt() 就是浮点数啊，单精度或高精度的，要给整形，可能要加个类型转换。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "如果你仅希望ptr2指向aa[1][0]这个后果的话，没有区别。 但是稍有冗余。 其实可以 int * ptr2 = (int * )(aa+1); 也可以 int * ptr2 = * (aa+1); 也就是说，在有了这个解引用以后，它前面的强制类型转换就是多余的了，因为右侧表达式 * (aa+1)本来就是int * 类型的了。 但是没有这个解引用的话，由于(aa+1)这个表达式是int (* ) [5]类型的，所以强制类型转换是需要写上去的。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "真累人，网站总是把星号理解成斜体格式符，建议网站关注。", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "懂了,感谢大佬 *(aa+1)之后 类型是int*", "referer": "user-1" }, { "cid": "4", "user": "user-2", "content": "也就是说，在有了这个解引用以后，它前面的强制类型转换就是多余的了，因为右侧表达式 * (aa+1)本来就是int * 类型的了。 这是不是有问题啊？解引用出来后是数组的值，怎么会是地址呢？", "referer": "user-1" }, { "cid": "5", "user": "user-2", "content": "同学，不是加不加*的问题，，看似赋值没问题，但你这句根本是错误的，左边是指针，右边是数组aa的第2个位置的值。so1、如果你是想将ptr2指向数组的第2个位置，这样：int *ptr2 = aa + 1;（这样也可以：int ptr2 = &((aa+1));，但就多些一举了）2、如果你是想获取数组的第2个位置的值，这样：int ptr2 = *(aa + 1);", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "老铁 int *ptr2 = aa + 1; //这个右边是数组左边是指针,最好不是应该强制转化一下吗,(虽然地址是相同的) 第2个你是写错了吗? 如果像你这样子写 int ptr2 = *(aa + 1); 不就成把地址赋给整形了吗?", "referer": "user-2" }, { "cid": "7", "user": "user-2", "content": "数组的名称就是数组的首地址啊，怎么了？为什么要强转？*(aa + 1)就是解引用，得到就是数组下标1的值啊", "referer": "user-0" }, { "cid": "8", "user": "user-2", "content": "对，它是二维数组！", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "既然1000 0101可以是-5，那么1001 1011是-27那不是顺理成章的么？", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "至于为什么用原码而不是补码，那得问系统设计者。 不过咱得承认原码对人类肉眼更友好不是么？", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "是因为，我就拿你的a = i++来回答吧。编译器在遇到a = i++的时候，它会这样理解：i先把自己值赋给a，再i+1而编译器再遇到a = ++i的时候，它会这样理解：i先加1，再返回a里你看看，i先 + 1和后+1都是一样的，而a就不同了：一个是得到i原来的值，一个是得到i+1后的值。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "一是 for() 循环体执行序列的问题，先执行初始化语句，再执行判断语句若成立执行循环体否则结束循环，循环体执行完后是第三个增量语句，再去判断语句；单独的语句，自增在前或在后，对变量自己没影响，影响的是以之赋值的对象，所以第二个例子，i 为 1，a 为 0 （因为自增在后，先执行赋值语句[其时a=i=0]再自增[i=1，a仍为0]）。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": ".data当然名字是无所谓的，加载后都合并了，只是映射的页面属性不一样而已。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "好的大佬", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "使用vc 2022时在头文件前加#define _CRT_SECURE_NO_WARNINGS，就不用scanf_s了", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "scanf_s(\"%s%s\", stu[a].num, 10, stu[a].name, 20);", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢大佬，解决了。这是scanf_s函数必须要限定范围吗？刚刚接触vs studio的时候我就知道scanf_s是防止越界的，但是发现在日常使用中scanf_s并不需要设定范围,就没有注意。在数组，结构体这种可能越界的都需要限定范围吗？", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "结构体在创建时，会按照占用空间最大的那个类型为单位开辟空间，所以都是按照8开辟的，第一个结构体，他会开辟88，后面的2和4，可以放到第2个8里面。第二个，先开辟一个8，放short a2,剩余6个，不够存放long a1，载开辟一个8,存放a1，然后第三次开辟一个8存放a3.这个也就面试的时候可能会问到，用处不太大。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "明白了，谢谢大佬", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "内存对齐这种事，知道有这回事就行，不求自己算。因为不同平台不同编译器不同编译参数造成不同的对齐后果，所以没法算。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "哦，谢谢大佬", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "c语言里面的变量名称是区分大小写的将pa 改为 Pa，或者将Pa改为pa，即可", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "c语言的代码里面是区分大小写的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "在我印象中，二分查找好象不是这样吧？是不是应该改为这样呢？ int search(int* nums, int numsSize, int target) { int low = 0; int hight = numsSize -1; while (low <= high) { int middle = (low + high) / 2; if (target == nums[middle]) { return middle; } else if (target > nums[middle]) { low = middle + 1; } else { high = middle - 1; } } return -1; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "意义在于，用来通知这个函数的调用者，你刚才让我做的问题有解，别忘了free 。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "只是有无解的话，返回值就可以的，是 NULL 还是其它有效指针。", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "所以说写代码和答题是两回事。", "referer": "user-2" }, { "cid": "4", "user": "user-2", "content": "这个函数其实返回两个内容，一个是 return 语句返回的，一个就是这个 returnSize 表示的，它应该是调用者里的一个变量的地址，那个变量用来存放所寻得区间的大小；从这个函数里的语句来看，是没有意义，因为固定了返回有效时它总是 2，但便于函数后来的扩展和变更。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "如果不能换老师的话，就换系统吧。在自己的机器上装虚拟机或者租用云主机用它的远程桌面，然后在里面安装windows98，接着在上面安装VC6。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "顶", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "用初中的话说，就是变量和代入变量的值嘛。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "这个问题，其实不需要深究，我的理解，举个例子吧，当定义一个函数时，比如： int max(int a, int b) { if (a > b) return a; return b; } 参数a,b就是型参，在实际使用该函数时，比如：max(10,5);此时，此时a=10,b=5,10和5就是实参。注意，C语言中函数的声明可以不写形参，比如：int max(int, int);也是可以的。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "嗯嗯我知道形参和实参的概念，但是我就是发现翁恺的定义还有网上搜到的定义当中都有一个点，就是在定义一个函数时，参数表里面那个是形参，我就在想那如果是主函数的话没有参数表这个说法是不是也就不存在形参这个说法了", "referer": "user-2" }, { "cid": "4", "user": "user-2", "content": "一样啊，标准C语言中，主函数int main (int argc,char *argv[])不是有参数吗？多数时候，为了方便，你不需要参数，直接就void main()。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "好的！谢谢大佬！！", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "这些题其实也没什么意义，只不过就是让你明白，函数的传参类型有好几种，其中当传值时，即使在函数内改变了参数a的值，返回后，a还是原来的值，没改变。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "这道题考的是变量的作用域，我审题不清", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "没什么意义，相当于return c++;", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "还是不太明白，按照题目我的理解是，把a++代入函数funa，但是在函数funa里并没有关于a的计算式，只有一个赋值式a=c++，也就是说之前一个代入白做，完全没起到作用，我哪里理解错了？", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "代码与特定的库相和图形环境关联，没办法测试。请把相关的编译及运行信息贴出来看看，能不能找到问题所在。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "11", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "int flag = 0;这个地方会使 if (flag == 1) 永不成立", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "int len = sizeof(nums) / sizeof(int);这个地方错啦，这里会使len等于1为什么不直接len = target;", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "最好把需求列出来。可以把下面的int flag=0去掉，这个会覆盖flag之前的值", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "break只能跳出一个for循环 可以在外面判断flag跳出外面的for", "referer": "user-0" }, { "cid": "5", "user": "user-4", "content": "正解", "referer": "user-3" }, { "cid": "6", "user": "user-5", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "建议楼主看一下其他题目，如果也是这么不清不楚的，就放弃那个网站吧。 严格说来，那个代码声明了一个结构体类型，而没有定义该类型的变量，所以就不应该占用内存。但从编译原理角度，一个类型总得有个内部handle，而handle么，一般就是机器字大小。 也许我想多了，扯远了，但总归是因为题目含糊其辞造成的。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "这是 csdn技能树的题", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "我的理解，1机器字=2个int=4个char=8位，结构体=1char*+1char+1int=2+2+4=8，是这样吗？", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "我用dev 运行sizeof(Test) 得到16 定义了结构体类型的变量t 运行sizeof(t) 也是16", "referer": "user-2" }, { "cid": "5", "user": "user-2", "content": "dev本身默认一个机器字就是32位啊，跟题目不一样", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "首先1个机器字是8位（8bit） 那题目中这个系统应该是64位（1byte=8bit），抛开这个不谈 我也问了别人 32位机 *占4字节 char1字节 int 4字节 对齐那应该是12 ；64位机 *占8字节 char1字节 int 4字节 对齐应该是16；", "referer": "user-2" }, { "cid": "7", "user": "user-3", "content": "我肯定蒙 2+2+4", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "直接从文件读数据到结构中，结构的字段没结束符，所以会把S一起带出来。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "请粘贴完整代码", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "渣哇中参数只有数组和对象是传引用，所有基础类型都传值，你可以int a[1]，然后传a就可以了", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢大佬，问题解决，C语言区果然给力", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "读文件不应该这样写，读取的语句重复了2次，文件读取完成后都要关闭它，一开始就应该判定是否文件结尾，像这样会好点： int isExist = 0; // 先假定用户不存 while(!feof(fp)) { fread(&b, sizeof(struct Users), 1, fp); if (0 == strcmp(user->Cid, b.Cid)) { // 用户已存在，标记它，退出 isExist = 1; break; } } flcose(fp); if (isExist) { ......................如果存在，做些什么 }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "好的，我试试", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "for 循环后 n 是 0，除以 0 还不溢出啊。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "哦对，没留意，谢谢", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "试试： #include <stdio.h> #include <math.h> int main() { double a, b, c, f; scanf(\"%lf%lf%lf\", &a, &b, &c); f = b * b - 4 * a * c, -b > -1E-16 ? b = 0 : b = - b; f > 1E-16 ? printf(\"x1=%.5f;x2=%.5f\\n\", b + sqrt(f) / (2 * a), b - sqrt(f) / (2 * a)) : f < 0 ? printf(\"x1=%.5f+%.5fi;x2=%.5f-%.5fi\\n\", b / (2 * a), sqrt(-f) / (2 * a), b / (2 * a), sqrt(-f) / (2 * a)) : printf(\"x1=x2=%.5f\\n\", b); return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "修改出来一个错误，但还是显示回答错误", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "不能直接计算 sqrt(b*b-4*a*c) 吧，因为里面可能小于 0 啊。先比较 b*b 和 4*a*c 的关系，再针对情况和题目要求进行下面的计算吧。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "因为学生的学号 名字不可能是一个字符啊 所以就用数组啊", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "字符串转int，知识点可能在于 ASCII 的数字提取？ #include<stdio.h> int main() { static char a[]=\"-12345\"; int k=0,symbol,m; if(a[k]=='+'||a[k]=='-') // 取符号 symbol=(a[k++]='+')?1:-1; // 正或者负 for(m=0;a[k]>='0'&&a[k]<='9';k++) // 取数字，非数字则退出循环 m=m*10+a[k]-'0'; // 每多一位数字，加在前一位数字进十后 printf(\"number=%d\\n\",symbol*m); }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这种形式叫做递归调用展开是一个层级的形式", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "那能解释一下这个展开是怎么回事，p最后赋值为7，有点不懂", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "递归的理解你得先到最后一层，也就是 x==0||x==1 得情况，第一次x=9，第二次x=7...最终x==1的时候退出，返回3，反推上一层调用时，x等于3，p等于3-3=0，再反推上一层，x等于5，p等于5-0=5，再反推上一层x=7，p等于7-5=2，再反推一层x=9，p等于9-2=7 以最终程序运行结果为准，上面只是思路，可能不正确...", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "用宏很容易解决楼主的癖好：#define memcopy(src, size, dest) memcpy(dest, src, size)", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "让我想起了《仙剑奇侠传》里面的沉思鬼：”让我走可以，但你告诉我，我到底应该先迈左脚还是先迈右脚呢？“书中仙：”把脚剁掉！“沉思鬼：”然也。”(^_^)", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "与x86指令设计无关(只是语法层面的设计，同样x86指令,，AT&T语法和intel语法的src、dest顺序就是反的)，dennis ritchie设计C语言的时候还没有x86，当初他移植unix的PDP-11计算机，mov指令是mov src, dest这种格式，dennis ritchie也许故意反其道而行之，算是一种恶趣味吧。", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "我觉得(目的，源）这样更合理。2个差不多的函数strcpy和strncpy都是把目的地址放前面，如果把目的地址放后面，这函数参数的位置就很别扭。", "referer": "user-0" }, { "cid": "5", "user": "user-4", "content": "是intel的x86架构造成了 mov eax,ebx 是把ebx复制到eax 不知道为什么会这么反人类的设计方式", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "我建议开头加 #pragma warning(disable:4996)", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "谢谢了", "referer": "user-1" }, { "cid": "3", "user": "user-3", "content": "没有解决", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "为什么还是报错啊", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include<bits/stdc++.h> using namespace std; int main(){ cout<<\"********************\"<<endl; cout<<\" Hello,World!\"<<endl; cout<<\"********************\"<<endl; return 0; } 这么写！", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "是不是中文逗号错了HELLO,WORLD", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "第一行总共20个号，后面无空格，第二行先是4个空格，然后是Hello,World!，两个单词之间有一个逗号，第二个单词后面跟一个感叹号，后面没有任何空格。第三行是20个号。 上面这句话，是要求还是你的理解？", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "是要求", "referer": "user-3" }, { "cid": "6", "user": "user-4", "content": "兄弟 截图出来看一下，", "referer": "user-0" }, { "cid": "7", "user": "user-2", "content": "可能把第三个\\n去掉？", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "试过了,不行", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-0", "content": "问题解决了https://blog.csdn.net/AlbertFly/article/details/52065629", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "可以自己作一个实验，像这样： printf(\"%p\\n\", &un.s); printf(\"%p\\n\", un.c); 分别在屏幕上打印出un.s和un.c的首地址，它们是指向相同的地址，是不是就很好理解了？", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢，我问题没说清楚，其实是16进制怎么存的问题，现在搞懂了", "referer": "user-1" }, { "cid": "4", "user": "user-2", "content": "union 成员是同一个东西，就如麻将里的一付牌 一二三万，在一起就是这么一组牌，分开看，不就分别是 一万、二万、三万嘛。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "谢谢，我问题没说清楚，其实是16进制怎么存的问题，现在搞懂了", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "点manage替换已安装的版本", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "安装后显示这个对话框请问该选哪个？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "jmeubank.github.io/tdm-gcc/about/简单说，TDM就是基于MinGW（gcc的windows移植版本）的一个实现", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "系统这个词有歧义吧？", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "32位\"系统\"是这个么，直接复制过来，应该是32位以下分布", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf(\"%d\",n); 应该是 scanf(\"%d\", &n);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "f(0)=1f(1)=1f(2)=f(1)+f(0)=2f(3)=f(2)+f(1)=3f(4)=f(3)+f(2)=5f(5)=f(4)+f(3)=8f(6)=f(5)+f(4)=13 这个递归公式就是f(n)=f(n-1)+f(n-2)", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "多谢大牛", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "优化手痒系列：int f(int n){ return n < 2 ? n > -1 : f(n - 1) + f(n - 2);}", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "six", "referer": "user-2" }, { "cid": "5", "user": "user-3", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "感谢大牛", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-1", "content": "31行 ，不是s=&i; 应是*s=i;", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "j<n,i<m是一个逗号运算，逗号运算的机理：先计算左边的操作数，再计算右边的操作数。右操作数的类型和值作为整个表达式的结果。因此，你程序中只有i<m有效，j<n被抛弃了。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "哪有问题", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "好像是格式不对，就是删去一个int 就没有问题", "referer": "user-2" }, { "cid": "4", "user": "user-2", "content": "同一般声明变量一样逗号后面当然是不用再声明类型", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "除了不少心打了中文符号，这个for循环好象没有问题啊，贴完整代码吧。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "就是我删去一个Int就没有问题，不知道为什么", "referer": "user-3" }, { "cid": "7", "user": "user-4", "content": "j<n,i<m; 这个中间语句有问题吧，中间语句是作为判断条件的，你这么写，怎么理解呢？写成 (j<n)&&(i<m); 或 (j<n)|| (i<m); 分别对应两个条件必须同时满足，两个条件某一满足即可，看你实际的情况了。", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "哦哦，我好像没考虑过这个问题，感谢", "referer": "user-4" }, { "cid": "9", "user": "user-5", "content": "我一直说要把语法学透，我是认真的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "输入省略b=1;输出省略", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "用不到嵌套", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "有个打字错误。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "html搞定，还C语言", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "出现这个，就说明你的代码有问题，最可能是引用了野指针、超标（越界）。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "谢谢，现在明白了，修改了很久，还有就是发现txt文档的编码是UTF-8，读出来全是乱码，改成ANSI才行", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "fp = fopen() 这个地方应该检查文件打开是否异常char p[8][9] = {0};读文件应该是 for (i = 0; i < 7; ++i)", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "还有这么神奇的工具吗？这编码规范太舒服了，强求一个linux的版本！", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "这不是很好么~", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "不要把fopen(\"...\",\"...\");fscanf,fprintf,fgets,fgetc,fputc,fclose //读时把\\r\\n替换成\\n，写时把\\n替换成\\r\\n;读到\\x1a就设置EOF;读写的内容当字符看待和fopen(\"...\",\"...b\");fseek,ftell,fread,fwrite,fscanf,fprintf,fgets,fgetc,fputc,fclose //不作以上替换，遇到\\x1a仍继续读;读写的内容当字节看待弄混了", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢支持！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "int i,j; char a[101]; gets(a); if(a[0]>='a'&&a[i]<='z')//这里的i 是局部变量 而且没有赋初始值，它是一个随机值，所以a[i]很可能会越界；改成a[0]//后面的 if(a[i]=='\\0') '\\0'是字符串结束的标志，不是语句间的间断标识符", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "这里if里面一个a[0]一个a[i]好像有点不对", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "同学，请参考： #include <stdio.h> // #include <string.h> struct MyBook { char number[20]; // 书号 char title[100]; // 书名 char author[20]; // 作者 double price; // 单价 char publisher[100]; // 出版社 }; #define MAX_BOOKS 1 // 书的数量 MyBook myBooks[MAX_BOOKS]; // 书本列表 int HighestIndex = 0; // 最高价书的索引 int LowestIndex = 0; // 最低价书的索引 void inputData(); // 输入资料 void printData(int index); // 打印资料 int main() { inputData(); printf(\"\\n\\n列印所有书本的资料：\\n\"); printData(-1); printf(\"\\n\\n列印最高价的书本资料：\\n\"); printData(HighestIndex); printf(\"\\n\\n列印最低价的书本资料：\\n\"); printData(LowestIndex); return 0; } // 输入资料 void inputData() { double highestPrice = 0.00; // 最高价 double lowestPrice = 999999.00; // 最低价 for (int index = 0; index < MAX_BOOKS; index++) { // 如果严谨点，应该检测书号是否重复以及单价不能少于等于0 printf(\"--- 请输入第%d本书的资料 ---\", index + 1); printf(\"\\n\\t书号：\"); scanf(\"%s\", myBooks[index].number); printf(\"\\t书名：\"); scanf(\"%s\", myBooks[index].title); printf(\"\\t作者：\"); scanf(\"%s\", myBooks[index].author); printf(\"\\t单价：\"); scanf(\"%lf\", &myBooks[index].price); printf(\"\\t出版社：\"); scanf(\"%s\", myBooks[index].publisher); // 比较最高价 if (myBooks[index].price > highestPrice) { highestPrice = myBooks[index].price; HighestIndex = index; } // 比较最低价 if (myBooks[index].price < lowestPrice) { lowestPrice = myBooks[index].price; LowestIndex = index; } } } // 打印资料 void printData(int index) { int startNumber = 0; int endNumber = MAX_BOOKS; if (index != -1) { startNumber = index; endNumber = index + 1; } printf(\"================================================================\\n\"); for (int i = startNumber; i < endNumber; i++) { printf(\"书 号：%s\\n\", myBooks[i].number); printf(\"书 名：%s\\n\", myBooks[i].title); printf(\"作 者：%s\\n\", myBooks[i].author); printf(\"单 价：%6.2lf\\n\", myBooks[i].price); printf(\"出版社：%s\\n\", myBooks[i].publisher); printf(\"----------------------------------------------------------------\\n\"); } }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "两层for之间加上flag=1;", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "二、填空题1.定义s[0].x 等于 1;s[0].y 等于 3;s[1].x 等于 2;s[1].y 等于 7;问 s[0].x 乘以 s[1].x 等于几？(也就是printf语句中的内容) ：）", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "同学，如果把s[2]={1,3,2,7}改为s[2] = {{1, 3}, {2, 7}}是否更容易理解？是不是一下子就明白了？在C语言中所有的多维数组其实在内部都是一块连续的储存空间，也就是，它其实就是一维数组的扩展。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "还是不理解。。。", "referer": "user-2" }, { "cid": "4", "user": "user-2", "content": "s[2]={1,3,2,7}相当于定义了一个上述结构的数组，那么，s[0].x=1，s[0].y=3，s[1].x=2，s[2].y=7，结果，1*2=2，就是这么简单啊。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "谢谢", "referer": "user-2" }, { "cid": "6", "user": "user-3", "content": "我想知道这样直接的问题怎么会有歧义的", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "不，我只是不懂它的意思，那s【0】.x*s[1].x是什么意思", "referer": "user-3" }, { "cid": "8", "user": "user-4", "content": "这位同学可能没整明白*是乘以的意思吧哈哈哈", "referer": "user-3" }, { "cid": "9", "user": "user-0", "content": "是的，我还以为是什么别的意思", "referer": "user-4" } ]

[ { "cid": "1", "user": "user-1", "content": "malloc的空间都不够大，所以就越界访问了。sizeof一个指针只有4字节，应该sizeof(struct xxx)或者sizeof(*Edge)", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "看不懂，但从运行上来看，CreateGraph() 里的 malloc() 应该是 malloc(sizeof(GNode)) 吧。 另外，输入的 scanf() 里不要用中文汉字的逗号做分隔符，最好是用英文的空格吧。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "请大家帮帮忙吧", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "实际应用中，不见得所有环境都是‘好系统’，‘好机器’，‘好软件’...；vc6.0作为c语言基础的学习工具，个人认为很有必要，再过几年，新的又变成旧的了...，其实掌握知识才应是重点。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "如果只是计算数组中的元素个数，为什么不用 sizeof(A)/sizeof(A[0]); 代码中的指针数组和数组能混用？！", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "阻止编译成功的是下面的error，而不是显示出来的这两个warning当然对照error改完回头再改这些warning也好", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "看来如今大学老师都是误人子弟,还用20年前的工具,可以下载VS2019,好用多了,报错也更智能易懂", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "看最后的输出，是要找出最低成绩的记录号，就以 &i 为参数啊： fun(a,&i);找出最小成绩数，一次遍历就可以了吧，两重循环，是排序性的了： void fun(struct Student a[],int *s) { int i,b; *s = 0; // s=&a[0]; b = a[0].score; for ( i = 1; i < N; i++) if (a[i].score < b) { *s = i; b = a[i].score; } return; /* for(i=0;i<N;i++) { for(b=1;b<=N-i-1;b++) { if(a[i].score>a[i+b].score) *s=a[i+b]; else *s=a[i]; } } */ }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "代码中 'if(a > b)' 的意思是地址比较，不是(int)比较", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "void swap(int* a, int* b) { int temp = 0; if( (*a) > (*b) ) { temp = (*a); (*a) = (*b); (*b) = temp; } }", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "明明是你自己换成这样的。那两个1换了位置，然而你看不出来它们的不同。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "我执行的3个当中 swap(n1,n2) n1&lt;n2 不执行 swap（n2，n3） n2&gt;n3 执行 n3=2 n2=1 swap（n1，n2） n1=n2 不执行啊 这样不该是 n1=1 n2=1 n3 =2 么 是我哪理解错误了么求教", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "26行那里，应该是 scanf(\"％lf\",&item); 吧", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "如果非要用NUMBER，可以改为char s[NUMBER+1]=\"hello\"，另外，变量j没有使用，int temp改为char temp更好。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "懂了谢谢", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "字符串需要结束符，所以你不写NUMBER的那个相当于数组大小是6，而写了NUMBER的那个就造成位置不够，被迫越界了。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "懂了谢谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "#include <stdio.h> int main() { int s[3][5]; int max = 0; // 假设最高分=0 int z = 0; // 假设第1个学生是最高分 int x = 0; // 假设第1课程是最高分 for(int i = 0; i < 3; i++) { for(int j =0; j < 5; j ++) { while(1) { printf(\"\\n请输入第%d个学生的第%d门课程的成绩：\", i + 1, j + 1); scanf(\"%d\", &s[i][j]); if (s[i][j] < 0 || s[i][j] > 100) { printf(\"输入的成绩无效，请重新输入！\\n\"); } if (s[i][j] > max) { // 输入的最高分比假设的高，替换它 max = s[i][j]; z = i + 1; x = j + 1; } break; } } } printf(\"\\n最高分数是：%d\", max); printf(\"\\n所对应的学生是：%d\", z); printf(\"\\n所对应的课程是是：%d\", x); return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "跟昨天这位同学的题目没差多少啊，你们是不是同一学校？https://bbs.csdn.net/topics/603675455", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "八进制的数字只能是0-7，逢8要进1。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "可能 c 里把 0 打头的数值认为是八进制而非其它，所以 8 出现在 068 里就突兀了。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "原来是这样，非常感谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "同学，函数的声明，不要在main()内，这是最基本的语法基础了。还有，为什么要做的这么复杂呢？在输入的时候就直接可以找到最高分，根本不需要另写函数啊，请参考我的代码： #include <stdio.h> int main() { int s[3][5]; int max = 0; // 假设最高分=0 int z = 0; // 假设第1个学生是最高分 int x = 0; // 假设第1课程是最高分 for(int i = 0; i < 3; i++) { for(int j =0; j < 5; j ++) { while(1) { printf(\"\\n请输入第%d个学生的第%d门课程的成绩：\", i + 1, j + 1); scanf(\"%d\", &s[i][j]); if (s[i][j] < 0 || s[i][j] > 100) { printf(\"输入的成绩无效，请重新输入！\\n\"); } if (s[i][j] > max) { // 输入的最高分比假设的高，替换它 max = s[i][j]; z = i + 1; x = j + 1; } break; } } } printf(\"\\n最高分数是：%d\", max); printf(\"\\n所对应的学生是：%d\", z); printf(\"\\n所对应的课程是是：%d\", x); return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "用c++做，超级简单（sort（））。你写的懒得看。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "c都还没学明白", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "标记一下，周六日有时间把它写了，一起学习。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "int ivar=10; int *pvar=&ivar; // 它指向ivar的地址 *pvar=8; // 相当于ivar=8 printf(\"ivar=%d\\n\",ivar); // ivar=8，是没有问题。 printf(\"pvar=%d\\n\",*pvar); // 这句就有问题了，pvar是指针，显示的却是解引用，会让人感到迷惑的", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "我在初学指针的时候，也容易搞混指针声明和解引用。", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-1" }, { "cid": "4", "user": "user-2", "content": "int *p=&a;的正确理解是int * p;p=&a;而不是像你以为那样理解。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "谢谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-0", "content": "已经找到原因并解决", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "所以你提问的时候希望别人解释，解决了以后自己却不解释的做法是会给别人添堵的。 真的懒得解释不妨删贴哦。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "请用数据库来实现这个功能,非常简单。去搜索 C语言连接操作数据库", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "请用数据库来实现这个功能,非常简单。去Google C语言连接操作数据库", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "先标记，周六日有时候，把代码写出来，跟你一起学习。", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "因为你说你只学到指针，所以这题目里边没有要求你上次输入的数据下次使用，很合理呀。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "同学，请参考我之前的作业，可以求出C语言任意整数的位数及其对应位的数值： #include <stdio.h> #define MAX_UNIT 10 // C语言，32位最大整数是10位 int main() { const char *units[MAX_UNIT] = {\"个\", \"十\", \"百\", \"千\", \"万\", \"十万\", \"百万\", \"千万\", \"亿\", \"十亿\"}; int digits[MAX_UNIT] = {0}; int number; printf(\"请输入一个整数：\"); scanf(\"%d\",&number); int remainder = number; // 余数 int length = 0; // 位数 for(; length < MAX_UNIT; length++) { int result = remainder % 10; // 对应位数的数字 if (result > 0) { digits[length] = result; } remainder /= 10; if (remainder <= 0) { // 当没有余数时，中止循环 break; } } printf(\"位数：%d\\n\", length + 1); for(int i = MAX_UNIT - 1; i >=0 ; i--) { if (digits[i] > 0 || i <= length) { printf(\"%s位：%d\\n\",units[i], digits[i]); } } return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "百位应该是b=a/100", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "不太理解", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "sprintf或者itoa", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "s是数组s[i]是char", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "老师我是用char定义的啊s［］", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "哦哦老师我懂了我没有区分开两个的意义谢谢老师", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "楼主这代码，级联10个for，太凶猛了~", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "汗，其他的什么递归回溯看不懂，就能看懂for。😥", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "仅供参考： #include <stdio.h> int d[8][8]; int n; void queen8(int L) { int x,y; if (8==L) { n++; printf(\"%d\\n\",n); for (y=0;y<8;y++) { for (x=0;x<8;x++) { // printf(\"%d\",d[y][x]); if (d[y][x]) printf(\"■\"); else printf(\"□\"); } printf(\"\\n\"); } return; } for (x=0;x<8;x++) { for (y=0;y<L;y++) { if ( d[y][x ] || (x-(L-y)>=0 && d[y][x-(L-y)]) || (x+(L-y)< 8 && d[y][x+(L-y)])) break; } if (y>=L) { d[L][x]=1; queen8(L+1); d[L][x]=0; } } } int main() { int y,x; for (y=0;y<8;y++) { for (x=0;x<8;x++) { d[y][x]=0; } } queen8(0); return 0; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "同学，这个排序函数float average(float a[10])不能传值，要么引用或指针，否则，返回的不是你所要的。我之前有做过差不多的作业，请参考：https://blog.csdn.net/SuperC_Game/article/details/121540497?spm=1001.2014.3001.5502", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "怎么要这样写初始化链表函数？除了逻辑不对外，还要传一个参数进去，直接在里面分配一个，然后返回不是更好吗？像这样： /** * @brief 创建节点 * @return 返回创建后的节点，它的数据域、指针域都指向NULL **/ MYNODE *MyLinkedListCreate() { // 分配链表的节点储存空间（使用c语言库函数malloc分配储存空间实质就是在内存分配了一块连续 // 的储存空间，它返回的就是这块储存空间的首地址，所以，需要对它进行强制转换为LinkedList*指针类型 MYNODE *pNode = (MYNODE *) malloc(sizeof(MYNODE)); // 要养成将还没有分配到内存空间的指什指向NULL的好习惯！ pNode->_pData = NULL; // 它的数据域指向NULL pNode->_pNext = NULL; // 它的指针域也指向NULL（下一个节点） return pNode; } // End of LinkedListCreate() 同学，你如果对这段代码有兴趣，可以去我在的B站下载，里面有百度网盘的分享，可以下载全部的源码：https://space.bilibili.com/1901488254", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "逻辑上整个不对啊。Init() 函授里，L=malloc() 了，接着却 L=NULL; ？在 Tail() 函授里，p==NULL 时，却硬要往 p 里塞数据？", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "哦哦，那把L=malloc删掉，直接L=NULL，那请问第一个元素怎么添加", "referer": "user-2" }, { "cid": "4", "user": "user-0", "content": "我知道了，谢谢大佬提醒！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "同学，请参考我的修改： #include <stdio.h> int main() { int i, j, n, m, flag = 1, max, c = 0, d = 0, k; scanf(\"%d%d\", &n, &m); int a[n][m]; for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { scanf(\"%d\", &a[i][j]); } } // 下面是原式，不知道想表达什么，需要这么多个for循环？ // for (i = 0; i < n; i++) { // flag = 1; // for (j = 0; j < m; j++) { // max = a[i][0]; // if (a[i][j] > max) { // max = a[i][j]; // c = j; // d = i; // } // } // for (k = 0; k < n; k++) { // if (a[k][c] > max) { // flag = 0; // } // } // if (1 == flag) { // printf(\"%d %d %d\\n\", max, d + 1, c + 1); // } // } // 把上面的原式，改为这样： max = a[0][0]; // 假设第1个元素就是最大值 for(i = 0; i < n ; i++) { for(j = 0; j < m; j++) { if (a[i][j] > max) { max = a[i][j]; c = i; d = j; } } } printf(\"%d %d %d\\n\", max, d + 1, c + 1); return 0; } 除了上面的方法，还有更紧凑的，因为C语言的多维数组实质是一维数组的扩展，所以，也可以只使用一个for即可。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "没仔细看题哦", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "对，我没仔细看题目，以为只是求它的最大值。", "referer": "user-2" }, { "cid": "4", "user": "user-0", "content": "for(i=0;i&lt;n;i++) { flag=1; for(j=0;j&lt;m;j++) { max=a[i][0]; if(a[i][j]&gt;max) { max=a[i][j]; c=j; d=i; } } 上面这个for循环我是先把最大值定义为每一行的第一个值，找出一行的最大值后记录他的行标和列标 然后下面这个for循环是判断它所在列是否还有比它大的值， 有就flag=0不输出位标 for(k=0;k&lt;n;k++) { if(a[k][c]&gt;max) { flag=0; } } if(1==flag) { printf(\"%d %d %d\\n\", max, d+1, c+1); }if(1==flag) { printf(\"%d %d %d\\n\", max, d+1, c+1); } 然后回到第一个for循环， 接着找出i=1也就是第二行所在的最大值，重复上面再判断所在列是否为最大；", "referer": "user-1" }, { "cid": "5", "user": "user-2", "content": "调试啊，走一下第二行，就会发现，max=a[i][0] 应该是在 for(j) 循环的外面吧。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "哦哦，对对，我调整了一下，输出498的值了", "referer": "user-2" }, { "cid": "7", "user": "user-0", "content": "多谢多谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "那个10.3的安装实测是可以的，如果不行应该是你的当地网络访问github有问题", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "或者下载这里：https://github.com/jmeubank/tdm-gcc-src/releases", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "gcc 10.3我下载了，但是不会安装，打开是这样的tdm64-gcc-10.3.0-2.exe 前面两个选了提示什么下载失败，最后一个我也不敢选，还有为什么只有exe版，没有压缩包？", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "同学，欢迎看看我弟弟在B站有关Dev-C++安装视频（在百度网盘有最新的下载版本）。", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "https://www.bilibili.com/video/BV1eq4y1M7XY", "referer": "user-2" }, { "cid": "6", "user": "user-0", "content": "你没有回答我的问题", "referer": "user-2" }, { "cid": "7", "user": "user-0", "content": "正好我问一下，源码包和预编译的二进制发布有什么区别？分别代表什么，这是我下载的8.1版本，x86_64-8.1.0-release-posix-seh-rt_v6-rev0.7z，解压缩到DEV C++里就可以直接用，这是源码还是二进制？如果要下载下来直接用的话，应该下载哪个？ 打开是这样的", "referer": "user-0" }, { "cid": "8", "user": "user-1", "content": "这个是源码包还是预编译的二进制发布，二进制发布一般都用TDM，目前只更新到gcc 10.3：https://jmeubank.github.io/tdm-gcc/download/", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "win10，但是应该一样的，控制台子系统从win2000以来几乎没有变化", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "难道是系统的原因，你是win7还是10？", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "我试了，是好的：", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "因为它默认存储的源文件编码是utf8，中文字符串都是utf8编码，你需要在控制台执行chcp 65001，然后再运行你的程序就正常了。也可以存源程序的时候选择ANSI编码，这样就和dev-c++ 5.11一样了。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "默认就是ANSI，没动过，换成utf8也不行。你说控制台是指cmd命令下输入chcp 65001吗，我试了，还是不行", "referer": "user-1" }, { "cid": "6", "user": "user-2", "content": "在regedit中找到HKEY-CURRENT-USER下面的console，然后找cpp后缀的，看你那个控制台是在那个盘里面，如果是c盘就找到c盘那个，然后找到旁边的codepage，弹出来的对话框里面选择十进制改为，65001，点确定，然后重新编译允许就可以了", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "没有吧，vc2008后一切正常。可能是你输入数据不合 scanf() 的规格，它要求两数据用一个英文逗号分隔。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "是的，解决了， 谢谢大佬", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "j 的除以 10 的余数，是 0-9 间的数值，+'0' 就是对应的用于显示的字符了；所以，不是没有存起来，而是存的数值，要显示成字符，就要 +'0'", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "对啊，我就奇怪为什么加了0就可以把数字显示成字符", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "同学，第一、二个你使用的是传进来的实数，它分配空间已是固定了，你不能简单地重声明一下或不声明就认为能改变它们的大小，就是错误的。我老师说，在习惯上，主程序main最好在它的形参前加上关键字const会比较好。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "学到了，谢谢", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "要写代码，请对语法规则保持尊重。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "同学，goto语句+label语句，其实就是一个循环，你的代码不算复杂，还是比较好修改的，请参考： #include <stdio.h> #include <string.h> #include <stdlib.h> #include <conio.h> void login(char *username, char *password); void change_password(char *old_password); int main() { char username[1000] = \"asdf\"; char password[1000] = \"123456\";//username和password数组开这么大是为了避免操作指针的时候发生越界的问题 int mod = 0;//设定一个变量mod,用来让用户选择系统工作的模式 while (1) { // 增加一个while循环 // remake: // 原式：去掉label printf(\"\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\t***** 请输入你要选择的模式 ******\\n\"); printf(\"\\t*********1.登录系统*************\\n\"); printf(\"\\t*********2.修改密码*************\\n\"); printf(\"\\t*********3.退出系统*************\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\n\"); scanf(\"%d\", &mod); //读入用户的选择 switch (mod) { //使用switch来控制分支 case 1: login(username, password); //向登录函数传入所给定的用户名和用户密码 // goto remake; // 原式：去掉label break; case 2: change_password(password); // goto remake; // 原式：去掉label break; case 3: printf(\"\\t再见，欢迎下次使用！\"); return 0; default: printf(\"\\t输入错误，重新输入\\n\"); // goto remake; // 原式：去掉label break; } } } void login(char *username, char *password) { //模块化程序设计的思路，这个是登录模块，单独来做个函数，传入的参数为主函数中给定的正确的用户名和密码 char name[1000]; char word[1000]; int n; printf(\"\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\t********* 用户登录系统 *********\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\n\\n\"); printf(\"\\t请输入用户名.\\n\"); printf(\"\\t用户名:\"); scanf(\"%s\", name); printf(\"\\n\"); if ( strcmp(username, name) == 0) { printf(\"\\t输入用户名.\\n\"); printf(\"\\t输入密码:\"); scanf(\"%s\", word); for (n = 0; n < 5; n++) { if ( strcmp( password, word) == 0 ) { printf(\"\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\t********* 欢迎用户！ *********\\n\"); printf(\"\\t*********3.返回上一级界面*************\\n\"); printf(\"\\t*******************************\\n\"); // re: // 原式：去掉label while (1) { // 增加一个while循环 int flag = 1; scanf(\"%d\", &flag); if (flag == 3) { return ; } else { printf(\"\\t******* 无效命令！请重新输入 ******\\n\"); // goto re ; // 原式：去掉label } printf(\"\\n\"); } break; } else { printf(\"\\t\\t请重试!\\n\"); printf(\"\\t密码:\"); scanf(\"%s\", word); if ( strcmp( password, word) == 0 ) { printf(\"\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\t********* 欢迎用户！ *********\\n\"); printf(\"\\t*********3.返回上一级界面*************\\n\"); printf(\"\\t*******************************\\n\"); // re1: // 原式：去掉label while (1) { // 增加一个while循环 int flag = 1; scanf(\"%d\", &flag); if (flag == 3) { return ; } else { printf(\"无效命令\"); // goto re1; // 原式：去掉label } printf(\"\\n\"); } break; } } } } else if ( strcmp(username, name) != 0) { printf(\"\\t用户名错误! 请重新输入!\\n\"); } } void change_password(char *old_password) { char temp_mima[1000], temp_mima1[1000], temp_mima2[1000]; //三个字符串密码，原始密码，新密码1，新密码2 // printf(\"请输入原来的密码：\"); // 原式：移动到while循环内 // loop: // 原式：去掉label // scanf(\"%s\", temp_mima); // 原式：移动到while循环内 while (1) { printf(\"请输入原来的密码：\"); // 原式：移动到while循环内 scanf(\"%s\", temp_mima); // 原式：移动到while循环内 if (strcmp(temp_mima, old_password) == 0) { printf(\"\\n\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\t********* 密码正确！ *********\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\\t请输入新密码：\\n\"); scanf(\"%s\", temp_mima1); printf(\"\\t请再次输入密码：\\n\"); scanf(\"%s\", temp_mima2); if (strcmp(temp_mima1, temp_mima2) == 0) { printf(\"\\t*******************************\\n\"); printf(\"\\t*****修改密码正确！请牢记密码!******\\n\"); printf(\"\\t*******************************\\n\"); printf(\"\"); strcpy(old_password, temp_mima1); //用新的密码代替旧的密码， return; //返回主函数 // 原式：可以改为break;更好 } else { printf(\"\\t*******************************\\n\"); printf(\"\\t***两次输入的密码不一致！修改失败！***\\n\"); printf(\"\\t*******************************\\n\"); // printf(\"\\t请输入原来的密码：:\"); // 原式：重复多余了 // goto loop; //实现用户输出错误密码了，重新输入密码 ， // 原式：去掉label // getch(); // 原式：多余 return; // 原式：可以改为break;更好 } } else { printf(\"\\t*******************************\\n\"); printf(\"\\t*********输入的密码错误！**********\\n\"); printf(\"\\t*******************************\\n\"); // printf(\"\\t请输入原来的密码：:\"); // 原式：重复多余了 // goto loop; // 原式：去掉label // getch(); // 原式：多余 // break; // 原式：因为需要重复修改，所以，不能使用它中止while循环 } } }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "感谢大佬的帮助，太感谢了", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "整数的数组可能包括负数，累加的结果出现负数，有什么问题呢？", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "可是我输入的是正数", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "我又发了图您看看哪里出问题了", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "同学，它们累计后的值，超出C语言的整数取值范围了，改为long long试试，还有，把运算改在同一个for循环内，可以使代码更紧凑。", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "-1、-2、-3的平均值是多少", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "有的正数得出也是负的", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "switch内的break只break switch，不会 break while", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "同学，你输入了多个字符后，如果你没有清除键盘缓冲区，getchar()会将它们都读取，所以，每一次调用getchar()函数后，最好清除一下键盘缓冲区，像这样： #include <stdio.h> int main(void) { int i, ch; int cnt[10] = {0}; /* 数字字符的出现次数 */ while ((ch = getchar()) != EOF) { setbuf(stdin, NULL); // 加上这1行：清除键盘缓冲区【windows可以直接用fflush(stdin)】 switch (ch) { case '0' : cnt[0]++; break; case '1' : cnt[1]++; break; case '2' : cnt[2]++; break; case '3' : cnt[3]++; break; case '4' : cnt[4]++; break; case '5' : cnt[5]++; break; case '6' : cnt[6]++; break; case '7' : cnt[7]++; break; case '8' : cnt[8]++; break; case '9' : cnt[9]++; break; } } puts(\"数字字符的出现次数\"); for (i = 0; i < 10; i++) printf(\"'%d'：%d\\n\", i, cnt[i]); return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "哦哦哦懂了谢谢老师了", "referer": "user-2" }, { "cid": "4", "user": "user-3", "content": "那就是 break; 只 break 了 switch() 吧，外面还有个 while()", "referer": "user-0" }, { "cid": "5", "user": "user-4", "content": "写switch 为什么没有 default ???", "referer": "user-0" }, { "cid": "6", "user": "user-5", "content": "那么while是啥意思呢？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "感谢!", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "关系运算符优先级高于赋值符号事实上tmp要么是1要么是0，从来不是getchar的返回值啊", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "看生成的代码，大致是被理解成了 tmp=(getchat()!='\\n') 但看你的描述，似乎应该是 (tmp=getchar())!='\\n' 就是符号的优先级和想象的不一样，加全了保险但可能看着眼花缭乱了。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "求求 ！十分感谢。", "referer": "user-0" } ]