{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "intunsigned intlong longunsigned long long统统容纳不下29的阶乘，早就溢出了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <math.h>  int main(void) {     int i = 1;     long long sum = 1; // 使用 long long 类型来存储阶乘结果     int x;      printf(\"请输入一个非负整数: \");     if (scanf(\"%d\", &x) != 1 || x < 0) {         printf(\"输入无效，请输入一个非负整数。\\n\");         return 1; // 返回错误码     }      while (i <= x) {         sum *= i;         i++;     }      printf(\"%d 的阶乘是 %lld\\n\", x, sum);     return 0; }", "referer": "user-0"}]}
{"question": "为什么总是有问题啊！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "疑似你建立的项目的类型不对，不是控制台应用。", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "第三个for的循环控制条件有错，如果此处改正，还是可以输出上面一半的。", "referer": "user-0"}]}
{"question": "Visual Studio 2022中用release版本运行时显示msvcp140.dll报错（C++语言）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个错误通常是由于缺少Visual C++ Redistributable for Visual Studio导致的。msvcp140.dll是一个动态链接库文件，属于Microsoft Visual Studio 2015 Redistributable包。要解决这个问题，您通常需要重新安装或修复Microsoft Visual C++ Redistributable。 这里有一些可能帮助您解决问题的步骤： 重新安装Visual C++ Redistributable for Visual Studio 2015：您可以从Microsoft官网下载并重新安装Visual C++ Redistributable for Visual Studio 2015。请记得下载和安装适合您系统的x86或x64版本。 修复Visual Studio安装：您也可以尝试修复Visual Studio安装。打开“添加或删除程序”（Add or Remove Programs），找到Visual Studio 2022，点击“修改”（Modify），然后选择“修复”（Repair）。 运行Windows Update：请确保您的Windows操作系统是最新的。运行Windows Update，安装所有推荐的更新和补丁。 检查项目设置：如果在Release模式下出现问题，但在Debug模式下一切正常，请检查项目的设置，确保Release配置的设置是正确的。 关于“找不到xlocale:源链接身份验证失败”，这个错误可能是由于编译器在链接时找不到xlocale库。xlocale通常是在Linux和Unix系统中使用的库，Windows中不包含这个库。如果您的项目是跨平台的，并且在Windows中使用了xlocale，您可能需要找到一个Windows下的替代库或者使用条件编译来避免在Windows中包含xlocale。", "referer": "user-0"}]}
{"question": "求解两个矩形面积，重叠只算一次，我写的代码我自己测没问题，但网站显示60分，求各位大佬看看哪里有问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "return 0； 应该修改为 return 0;。分号应该放在语句末尾，而不是在中间。函数 founc1 的参数命名不够清晰，可能会导致混淆。应该使用更具描述性的参数名，以便代码的可读性更好。函数 founc1 的算法实现有问题。它的目标是找出两个数中第二大的数，但实际上它只进行了一次比较和交换。正确的方法应该是找出最大的数和第二大的数，然后返回它们的差值。在 main 函数中，需要考虑输入错误的情况。如果输入的坐标信息不满足矩形的要求，应该进行错误处理，而不是直接计算面积。缺少注释和代码说明，难以理解代码的逻辑和目的。添加注释可以提高代码的可维护性和可读性。变量命名不够清晰，可以通过更具描述性的变量名来提高代码的可读性。代码中没有考虑输入数据的合法性，如负数坐标等情况。应该添加适当的输入验证来确保输入数据的有效性。 #include<stdio.h>  // 函数用于找出两个数中第二大的数 int findSecondLargest(int a, int b, int c, int d) {     int arr[4] = {a, b, c, d};          // 对数组进行冒泡排序，找出最大的数和第二大的数     for (int i = 0; i < 3; i++) {         for (int j = 0; j < 3 - i; j++) {             if (arr[j] > arr[j + 1]) {                 int temp = arr[j + 1];                 arr[j + 1] = arr[j];                 arr[j] = temp;             }         }     }          // 返回第二大数和最大数的差值     return arr[2] - arr[3]; }  int main() {     int x11, x12, y11, y12, x21, x22, y21, y22;          // 输入两个矩形的坐标信息     scanf(\"%d %d %d %d\", &x11, &y11, &x12, &y12);     getchar(); // 消耗换行符     scanf(\"%d %d %d %d\", &x21, &y21, &x22, &y22);         // 判断两个矩形是否有重叠     if (x12 < x21 || x11 > x22 || y12 < y21 || y11 > y22) {         int s = (x11 - x12) * (y11 - y12) + (x21 - x22) * (y21 - y22);         printf(\"%d\\n\", s);         return 0;     }      // 计算 x 轴和 y 轴上的重叠部分的长度     int overlapX = findSecondLargest(x11, x12, x21, x22);     int overlapY = findSecondLargest(y11, y12, y21, y22);      // 计算重叠部分的面积，然后从总面积中减去     int s = (x11 - x12) * (y11 - y12) + (x21 - x22) * (y21 - y22) - overlapX * overlapY;     printf(\"%d\\n\", s);      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "x11y11x12y12​分别是两个矩形左下角的横坐标、纵坐标，右上角的横坐标、纵坐标。", "referer": "user-0"}]}
{"question": "请问运行后显示这个怎么办？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "变成颠佬", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "颠佬？？？", "referer": "user-1"}]}
{"question": "createprocess失败 代码740\n", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可能不是代码权的事。如果是不重要的代码使用的却是重要的服务，也有可能被拒绝。系统资源是有限的，对于任务的评判是自动化的。彩虹岛应该是个重要项目，感觉需要评审一下相关代码的效率和使用的服务价量，并不是有钱就可以胡来。", "referer": "user-0"}]}
{"question": "请问这个一直调试不来是怎么了啊，编译选项的都试过啦...还是不可以...大佬求救！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先保存文件，指定一个文件名。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "哇趣，还真的是啊，谢谢大佬", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "你说的是什么问题？可以交换", "referer": "user-0"}]}
{"question": "这个该咋写啊uu们··", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  int main() {   int c, n = 0;   char s[10][5] = {\"ling\", \"yi\", \"er\", \"san\", \"si\", \"wu\", \"liu\", \"qi\", \"ba\", \"jiu\"};    for (; c = getchar(), c != 10 && c != EOF; c > 47 && c < 58 ? n += c - 48 : 0);   n > 99 ? printf(\"%s %s %s\\n\", s[n / 100], s[n % 100 / 10], s[n % 10]) :    n >  9 ? printf(\"%s %s\\n\", s[n / 10], s[n % 10]) :             printf(\"%s\\n\", s[n]);    return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "不行啊兄弟", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "实测可以", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "这是已经写的#include<stdio.h>int main() { long long a; int i; int sum = 0; scanf(\"%lld\", &a); do {     i = a % 10;     sum = sum + i;     a = a / 10; } while (a > 0);  int mask = 1; int t = sum;  while (t > 9) {     t /= 10;     mask *= 10; } do {     int b = sum / mask;     if (b == 0)     {         printf(\"ling\");     }     else if (b == 1)     {         printf(\"yi\");     }     else if (b == 2)     {         printf(\"er\");     }     else if (b == 3)     {         printf(\"san\");     }     else if (b == 4)     {         printf(\"si\");     }     else if (b == 5)     {         printf(\"wu\");     }     else if (b == 6)     {         printf(\"liu\");     }     else if (b == 7)     {         printf(\"qi\");     }     else if (b == 8)     {         printf(\"ba\");     }     else if (b == 9)     {         printf(\"jiu\");     }     if (mask > 9) {         printf(\" \");     }     sum %= mask;     mask /= 10; } while (mask > 0); return 0;  }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "怎么能输入一个这么大的整数啊，就差这一步了", "referer": "user-0"}]}
{"question": "为什么这里的min一直在下面不会被重新赋值？", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "？arr1[j] = arr[j+i];这个语句是对的吗？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你写的 x < min 的情况下，min才会被重新赋值，你可以输出x和min看看，有符合 x < min 的情况吗？", "referer": "user-0"}]}
{"question": "map.insert()里面是（value, key）?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "很多高级语言都是可以直接map.insert(key,val) c++里面是 map.insert(make_pair(key,val)) 一般来讲，插入可以写成map[key]=val;对于存在的key会更新，对于不存在的key会直接创建 但是查询时最好还是用map.find,map.count，因为用map[key]形式访问一定会创建这个键。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "回答的好详细，我懂了，谢谢大佬👍", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "insert(插入的位置，插入的值)", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "这是我在力扣上面跟着卡尔刷的一道题，我如果把nums[i]和i调换位置就会报错，这是为啥？", "referer": "user-2"}]}
{"question": "一个来自小学生的求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把 = 改为 == 就可以了 = 是赋值的意思不是等于的意思", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "是的，您说的对，可是我不明白的是，为什么if(a&gt;=2)         printf(\"Today, I ate %d apples.\",a);这个不执行呢，我输入5的时候，这一条不是也应该执行吗", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "不管你输入的啥，在它上面一条都被赋值成0了。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "我用c++结果没问题啊，你可以试试把%d改成%i?", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "我打错了，您看到的是我修改以后的，我原来是“a=1\"和\"a=0\"", "referer": "user-3"}]}
{"question": "大一新生，寻求大佬帮助，请问这个代码为什么运行之后只能得到0或1", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "除了int main，int全换float", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "牛，Thanks♪(･ω･)ﾉ大佬", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "用double更好一点", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "结果溢出。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "有范围咯，用数组int a[30];", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "溢出了， long int也就20几左右的阶层就上限了，用数组存吧", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "为什么呢，怎么解决的呢", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "循环嵌套，一个累加，一个累乘；不会找我要代码", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "结果溢出。", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "第一次见这样写的，建立个数组存起来吧，也就是闰年特殊的时候那个月加一天而已", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "如果输入0 0 0你的代码会输出啥？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "AI回答：https://www.fudai.fun/ 这段代码目前无法运行的原因是由于您的代码中有两个地方存在错误。 首先，在使用scanf函数接收输入时，需要在代码文件开头添加#include<stdlib.h>头文件。 其次，在使用printf函数打印输出时，您没有输出换行符\\n，结果会打印在同一行上。 下面是修改后的代码： #include <stdio.h> #include <stdlib.h> #include <math.h>  int main(void) {     int a, b, c, d;     scanf(\"%d %d %d\", &a, &b, &c);      if ((a % 4 == 0 && a % 100 != 0) || a % 400 == 0) {         switch (b) {             case 1: d = c; break;             case 2: d = 31 + c; break;             case 3: d = 31 + 29 + c; break;             case 4: d = 31 + 29 + 31 + c; break;             case 5: d = 31 + 29 + 31 + 30 + c; break;             case 6: d = 31 + 29 + 31 + 30 + 31 + c; break;             case 7: d = 31 + 29 + 31 + 30 + 31 + 30 + c; break;             case 8: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + c; break;             case 9: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + c; break;             case 10: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + c; break;             case 11: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + c; break;             default: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + c; break;         }         printf(\"%d\\n\", d);     } else {         if (c == 29) {             printf(\"data error!\\n\");         } else {             switch (b) {                 case 1: d = c; break;                 case 2: d = 31 + c; break;                 case 3: d = 31 + 28 + c; break;                 case 4: d = 31 + 28 + 31 + c; break;                 case 5: d = 31 + 28 + 31 + 30 + c; break;                 case 6: d = 31 + 28 + 31 + 30 + 31 + c; break;                 case 7: d = 31 + 28 + 31 + 30 + 31  ```c    ```", "referer": "user-0"}]}
{"question": "请问，为什么卸载不了电脑上的python？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "see the log file", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "#include<stdio.h>#include<math.h>int main(void){    double a, b, c;    double dt,t,x1,x2;    scanf(\"%lf %lf %lf\", &a, &b, &c);    dt = b * b - 4 * a * c; /* 这个才是判别式*/   if (dt<0)  { /*判别式小于0*/        print(\"-1\");   /* 没有实根 */    }    else if ( dt<=0.0000001 ) {  /* 判别式为0 */        x1= -1*b/(2*a);        printf(\"x1=x2=%.2f\\n\",x1);    }    else {         t = sqrt(dt);        x1= (-1*b + t) / (2*a);        x2= (-1*b - t) / (2*a);        if (x1 > x2){            printf(\"x1=%.2f\\n\", x1);            printf(\"x2=%.2f\\n\", x2);        }        else{           printf(\"x1=%.2f\\n\", x2);          printf(\"x2=%.2f\\n\", x1);       }    }    return 0;}", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "您已经分不清判别式和它的平方根了？", "referer": "user-0"}]}
{"question": "求大佬解答，感激不尽！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第一,water要么赋初值要么放int main上面,第二,float精度不够,建议所有涉及小数的都用double", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你molecule变量赋值的时候，其实water变量还没有正确初始化和正确赋值，所以这时water的值是一个随机的数，就造成了molecule的值是不符合你意图的。你把第10行语句，放到14行前面就好了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "太感谢啦，问题解决啦", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "在这个进度，你写一句，机器就用小学三年级的思维计算一句，四则运算。你不能企图这样建立函数关系。所以那个赋值执行的时候，变量water还没有值，只能瞎编一个，所以是错的。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢，已经改好啦", "referer": "user-3"}]}
{"question": "萌新遇问题求大佬帮忙解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "while(x>0)    后面没有;号       判断x>0      试一试。", "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-2", "content": "while那行末尾多敲了一个分号。因此以那个分号为循环体一直死循环了。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "不行唉。。", "referer": "user-2"}, {"cid": "6", "user": "user-0", "content": "去掉分号还有个等号也要去掉现在可以啦，谢谢大佬", "referer": "user-0"}]}
{"question": "求各路gis大神帮助！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据路径可能有问题", "referer": "user-0"}]}
{"question": "W5500 UDP接收不到数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果这俩原来是直连的，就分别插到交换机上去。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "或者插到小路由的两个内网口。 因为W5500这玩意不会自动识别双绞线线序。", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "IP、端口都没问题，怀疑是W5500不知道对方的MAC地址导致的。。。", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "没有输出", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你是不是没输出？🤦‍♂️", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "虽然我没学c，但我学了c++，一看就没输出", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "关于为什么不能正确运行，首先输入安排的顺序和题目要求不一致；第二不能把scanf_s当作scanf用，要么用scanf，要么给%c增加长度字段如scanf_s(\"%c%lf%lf\",&x,1,&a,&b);第三缺少输出，你计算了不输出等于白算。第四算我主观了，输出格式要按照题目要求来，也就是说，要审题。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "", "referer": "user-4"}, {"cid": "7", "user": "user-5", "content": "#include<stdio.h>#include<math.h>int main(){    char x;    double a, b;    scanf(\"%c %lf %lf\",&x,&a,&b);    switch (x)    {    case'+':        printf(\"%.2f\\n\",a+b);        break;    case'-':        printf(\"%.2f\\n\",a-b);        break;    case'':        printf(\"%.2f\\n\",ab);        break;    case'/':        printf(\"%.2f\\n\",a / b);        break;    default:        printf(\"未知运算符\\n\");    }    return 0;}希望能帮到你", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "", "referer": "user-5"}, {"cid": "9", "user": "user-6", "content": "如果输入的是 * 2 3.6，那你代码scanf_s(\"%lf %lf %c\",&a,&b,&x);输入顺序错了如果报错undefined reference to `scanf_s'，改成scanf修改后：#include<stdio.h>#include<math.h>int main(){    char x;    double a, b;    scanf(\"%c %lf %lf\",&x,&a,&b);    switch (x)    {    case'+':printf(\"%.2lf\",a+b); break;    case'-':printf(\"%.2lf\",a-b); break;    case'':printf(\"%.2lf\",ab); break;    case'/':printf(\"%.2lf\",a / b); break;    default: puts(\"未知运算符\");    }    return 0;}", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "", "referer": "user-6"}]}
{"question": "怎么办，如何解决。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这是什么语言", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "显然是因为你把main写成了mian，所以系统找不到主函数。", "referer": "user-0"}]}
{"question": "兄弟们，输出没结果怎么搞", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "程序跑完了，可能是你没写输出或者输入。贴下源码", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "✓，我没写输出", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "既然返回值是0，大约是正常结束的。那么大概率是你没写输出或者流程执行不到输出。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "我也这么想的", "referer": "user-2"}, {"cid": "5", "user": "user-0", "content": "对的", "referer": "user-3"}]}
{"question": "求助：cmake构建后没有exe程序", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "找找是不是在src的文件夹里，或者并列src生成了一些debug,release文件夹", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "嗯，证明一个东西不存在是很困难的。我是说，它可能藏在角落里，箱子里，或者袜子里。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "大佬在不在", "referer": "user-0"}]}
{"question": "求助很像之前写的变了一点地方", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的return结束掉了这个函数", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "瞎了", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "int n;float i=1,j=1;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "额，for语句可以这样写吗？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "计算机老师这么写的", "referer": "user-3"}, {"cid": "6", "user": "user-3", "content": "有没有一种可能你只执行一次，就return0了。。。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "我玩傻掉了", "referer": "user-3"}, {"cid": "8", "user": "user-0", "content": "输出一直是1.000000", "referer": "user-0"}]}
{"question": "不是只能下划线或者字母开头吗 a是错的啊", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "题出错了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "c++标识符所有标识符必须由一个字母(az或AZ)或下划线(_)开头，标识符的其它部分可以用字母、下划线或数字(09)组成。A和D错在不能以数字开头，B有非法字符，正确答案是C", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "C是关键字啊", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "哦对，关键字不可以充当标识符，题目没有正确答案", "referer": "user-4"}, {"cid": "6", "user": "user-5", "content": "没办法了，刷题刷到你这样，恐怕只能先休息（禁言）一段时间了。系统估计已经对你免疫了（老师见到你就乱讲，通常是被你气糊涂了，想起你就头疼）。正确答案是C，注意是标示符而不是变量名。", "referer": "user-0"}]}
{"question": "大佬们 为什么这段代码没有输入 直接运行结束了\n", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你n的值呢？", "referer": "user-0"}]}
{"question": "求求已经不知道改多少次了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf这个函数最好少用，因为它很复杂", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "i/（2 * i-1）是整数运算，结果也是整数，第一次算出来是1，后面i增大，就舍去小数变成0了，所以sum一直是1，所以要转换成浮点数运算2 * i改成2. * i，或者直接强制转换在前面加上float，变成float(2*i-1)", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢 ( ੭ ˙ᗜ˙ )੭", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "2*i改为2.*i不就行了？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢，谢谢", "referer": "user-3"}, {"cid": "6", "user": "user-4", "content": "不知道你要干嘛，但是确定的是你必然都是1，从1后，+后面的数值都会是0", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "那要怎么改才行", "referer": "user-4"}, {"cid": "8", "user": "user-5", "content": "因为当i大于1的时候i/（2*i-1）都等于零", "referer": "user-0"}]}
{"question": "大学C语言新生求教~", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "不安全哥们", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你用的是vs，vs中使用scanf会报错，你没看见下面的ERROR吗，它建议你使用scanf_s，而不是使用scanf，或者在代码的最顶端输入#define  _CRT_SECURE_NO_WARNINGS", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "已解决，谢谢", "referer": "user-3"}]}
{"question": "蓝桥杯题目：六六大顺测试用例总是不通过，能帮我看看问题在哪吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "题目里没有关于范围的约定，于是你使用了内置的最长数据类型。然而仍然不够用。你得做好结果是个500位数或者100000位数的心理准备。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "那如果超出了最长数据类型，该怎么去表示", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "用数组记录大数据，每个元素记录其中的一位或者几位，然后自己写计算步骤。可参考 https://blog.csdn.net/CX_YX_0/article/details/128046342", "referer": "user-0"}]}
{"question": "顺序栈中top为指针类型的，怎么判定栈满", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "顺序栈中，top指针指向栈顶元素的位置。当栈满时，意味着栈中已经没有剩余的空间可以存储新的元素了。在这种情况下，我们需要判断栈是否满，以便进行相应的处理。 如果top是指针类型，我们可以通过比较top所指向的内存地址和栈的容量来判断栈是否满。因为在顺序栈中，栈底位置固定，栈顶位置随着入栈和出栈操作改变。当top指向的内存地址超过了栈的容量，就表示栈已满。 使用if(*(S.top) >= S.size)判别栈满的原理是通过比较top指针所指向的地址和栈的容量来判断。*(S.top)表示获取top指针所指向的内存地址中的值。如果该值大于等于栈的容量，说明栈已满。", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果你使用的使Visual stdio编程的话，我建议你把scanf改为scanf_s", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "您是否确切地知道啥叫“一个单精度数”？", "referer": "user-0"}]}
{"question": "c++ 溢出问题求解决！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "也许是下水道有杂物加上雨比较大，就造成溢出了。", "referer": "user-0"}]}
{"question": "为什么两个hello world代码不一样？", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "因为下面使用宏定义using namespace std，故不需要加std::", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "我不造啊", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "回字有四种写法你知道么？", "referer": "user-0"}]}
{"question": "救救萌新，为什么电脑输出结果和gpt说的不一样😿😿😿😿", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "gpt追求拟人，这次拟的是一位犯错误的新手，这效果相当赞。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "因为--n会修改n的值啊。你要想return，就得先算出n+f吧你要想算n+f就得先算f吧你一算f就得先--n啊n就变成4了所以你算的是4+f(4)啊没有5被累加的动作啊", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "典型的CPU都不会先把5放在那儿晾着再回头去求f的。", "referer": "user-1"}, {"cid": "4", "user": "user-0", "content": "🥺🥺🥺醍醐灌顶了！！！谢谢！", "referer": "user-1"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先，输出的时候，不能用%d这个表示整型的格式符搭配非整型数据。其次，关系运算符不能连用，连用的结果是错的。以a>b>c为例，其中a>b部分的结果是0或1，接下来是0或1判断是否>c 。故应写作a>b && b>c还有，题目说输入无序，没说互不相等啊。", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf(\"%.2f\",(int)(x*100+0.5)/100.0);", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "运算符%不能接收非整型运算数。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "那要怎么改呢", "referer": "user-1"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先，你不能先计算后输入。第二，余弦函数的正确调用形式需要括号。第三，三角函数的自变量需要是弧度值。第四，scanf的除了格式串的参数需要是地址。第五，double型对应的scanf格式符必须是%lf，缺一个小写L。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf(\"%f%f%f%f,&a,&b,&c,&d);", "referer": "user-0"}]}
{"question": "求助 C语言顺序表问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先输出date[5]，而上面scanf只输入到date[4]，date5，在初始化时未赋值，其值为0", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第一个输出是多余的，也就是说你的输出函数第一次循环是多余的，跳过即可。for(i=L->Length-1;...", "referer": "user-0"}]}
{"question": "求助！！！这个C语言程序是哪里错了 ？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢大家支持！但是只是单词拼错了！！！再次感谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "⊙∀⊙！发错位置了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "<stdio.h>为标准输入和输出函数，#include<stdio.h>d调用标准库函数，为头文件指令", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "应该在第一行加入#include <stdio.h>", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "c++标准库是&lt;iostream&gt;,万能头文件是&lt;bits/stdc++.h&gt;", "referer": "user-2"}, {"cid": "6", "user": "user-3", "content": "printf函数属于文件里面的函数，应该include此头文件", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "缺少包含头文件指令。", "referer": "user-0"}]}
{"question": "有哪位好心人可以帮忙看看吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我仔细看了一下,您所写的代码的思路应该是没有问题的。不过图片不是很清楚这边建议您检查一下每一句最后分号是不是打错了（如错打成冒号或中文分号） 另外第9行的printf好像有问题,为什么ta没有颜色？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢，我找到原因了", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "你在scanf那行末尾误敲了一个中文的分号。需要英文的。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢，我找到原因了", "referer": "user-2"}]}
{"question": "急急急！！！ 小白求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先，不要在意汉字部分，忽略它。其次，不要复制代码，自己一点一点敲上去。", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "（后面的\\n可以不要）你的问题是‘\\’中的\\前面也是要转义的，你只是少了一个\\而已", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "printf(\"He said:\\\"The symbol is \\'\\\\\\'\\\".\");", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "C/C++中单引号是不要转义的", "referer": "user-2"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的前4个printf都少参数（a,b,c)而最后一个%要用%%转义的改好的完整程序为 #include <stdio.h> int main(void) {     int a, b, c;     scanf(\"%d %d %d\", &a, &b, &c);     printf(\"%d+%d+%d=%d\\n\", a,b,c,a + b + c);     printf(\"%d-%d-%d=%d\\n\", a,b,c,a - b - c);     printf(\"%d*%d*%d=%d\\n\", a,b,c,a * b * c);     printf(\"%d/%d/%d=%d\\n\", a,b,c,a / b / c);     printf(\"%d%%%d%%%d=%d\\n\", a,b,c,a % b % c);     return 0; }   结果", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "printf()和scanf()作为可变参数方法，是从右向左传参（入栈操作），在最左边的参数进行执行（出栈操作）时每遇到标识符(%d等)进行一次出栈，你写了四次出栈一次入栈，编译会报错。正常来说在使用开发工具写的时候就会有报错提示，你可以看看提示信息，避免语法错误。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "printf函数“”里面一个%d应该对应逗号后面一个整数变量，可以改成：printf(\"%d+%d+%d=%d\\n\",a,b,c,a+b+c);其他同理", "referer": "user-0"}]}
{"question": "刚学C语言，为什么这个代码运行不了呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "程序有两处错，改好的#include <stdio.h>int main(void){    int n, m,a, b;    scanf(\"%d %d\", &n,&m);    b= (m -2* n) / 2;    a = n - b;    if (a < 0 || b < 0) //这个后面不能有分号        puts(\"No answer\");    else        printf(\"%d %d\\n\", a, b); //puts只能一个参数    return 0;}", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢提醒！", "referer": "user-2"}]}
{"question": "在32位操作系统下，任何类型的指针变量都占四个字节,为什么输出结果是8呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "你看看编译器是32位还是64位，64位打印出来是8", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "理论上，它与操作系统无关，与编译器及生成代码的位数有关（当然，32位系统下是不能运行63位程序的）在64位系统上，用分别用32/64位结果如下", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "电脑是64位操作系统", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "64位操作系统全部输出4？", "referer": "user-0"}]}
{"question": "奇怪的问题，，，，中文显示不出来了", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "用记事本打开cpp文件，另存为，选择编码为 ANSI /UTF-8试试看？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "画面上是没有通过编译，不是什么中文显示不出来。关掉黑窗口，重新编译。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "可能是语法检查在括号、分号扫描时遇到了问题。突然发现程序中第一个printf();语句肯定是错误的，导致了编译扫描刚开始就退出了。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "这个是编码格式的问题，工具选项里改下字体就行了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "字体已经改成成简体中文了，还是不行", "referer": "user-5"}, {"cid": "7", "user": "user-6", "content": "工具显示不出来中文吗？把 编码格式替换一下呢，换成 GB2312或者GBK", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "找不到编码格式，，，，", "referer": "user-6"}]}
{"question": "求大佬教教我  qaq", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "运行窗口的长度是有限的，当有足够长的输出时，它会选择性遗忘最古老的内容，这很合理吧？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "原来是这样，我以为我写错了什么，谢谢大佬", "referer": "user-1"}]}
{"question": "有没有大佬救救我QAQ", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "import requestsfrom bs4 import BeautifulSoup url = 'https://yield.chinabond.com.cn/cbweb-czb-web/czb/queryGjqxInfo' data = {\"zblx\": \"xy\", \"srrq_rq\": \"2021-12-31\", \"locale\": \"zh_CN\", \"qxmc\": \"1\"} html_data = requests.post(url, data=data, headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36'}) html_data = html_data.content.decode('utf-8') soup = BeautifulSoup(html_data, 'html.parser') tb = soup.findAll(\"table\", {\"class\": \"ds\"}) tenYear = tb[0].select('tr')[1] deadline = tenYear.select('td')[0].text incomeRate = tenYear.select('td')[1].text data = '标准期限：{0} 收益率(%)：{1}'.format(deadline, incomeRate)print(data)", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "为什么我看不懂QAQ", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "【1】= requests【2】= BeautifulSoup【3】= 'https://yield.chinabond.com.cn/cbweb-czb-web/czb/queryGjqxInfo'【4】= \"dt\"【5】= post【6】= User-Agent【7】= text【8】= table【9】= 9【10】= format", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "大佬我还是运行不出来QAQ", "referer": "user-3"}]}
{"question": "笔记本电脑开机黑屏，求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "程序员不是修电脑的，也不知道Windows的内核代码，引起这种情况发生的原因有很多，没办法给你一一列举，一般建议你重装电脑", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "此事不找售后，更待何时？", "referer": "user-0"}]}
{"question": "刚学C语言，求助大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你把出错的代码放到chatgpt中，叫他找出其中的错误。后续有啥更离奇的问题，也难得到处找人问了，而且答案得到的也快。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "OK，感谢你的建议", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "哈哈，从未见过如此离谱之人。加油。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "刚学，眼神有点不好", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "括号括错了，正确的应该是：#include <stdio.h>int main(){    const int price = 3;    int weight = 5;    int sum = price * weight;    printf(\"%d\\n\", sum);    return 0;}", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "OK，谢谢", "referer": "user-2"}, {"cid": "7", "user": "user-3", "content": "这个事儿这样理解，就是我们日常都是把头放在衣服外面的。所以函数头也得放在花括号外面。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "谢谢", "referer": "user-3"}, {"cid": "9", "user": "user-4", "content": "int main () {程序体}花括号位置错误", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "谢谢", "referer": "user-4"}]}
{"question": "大伙们好，我是刚学的C语言，为什么我这个strcmp函数这样写没有返回值，按理来说不是应该是-1吗", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "-1是整数，不是字符串啊，puts表示它心有余而力不足啊。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "所以到那行就异常结束了，没有往下继续执行。", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "噢噢原来是这样哈哈哈哈哈哈哈，谢谢你", "referer": "user-2"}]}
{"question": "C语言 单链表出现RE问题 求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "经评论区好心人提醒，发现图没截全，补上没截全的那部分", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "所以结果图各列的标题是啥？我是说尤其是第十列？为啥AC的都是0呢？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "啊抱歉，没截全，分别是用时和内存", "referer": "user-1"}, {"cid": "4", "user": "user-0", "content": "您可以看我在评论区补充的图", "referer": "user-1"}, {"cid": "5", "user": "user-1", "content": "既然AC的内存占用都显示0，我瞎猜哈，有没有一种可能是测试集数据量较大的时候占用内存过多引起的呢？ 我主观上觉得这个问题没必要用那么多内存，个人看法，仅供参考哈。", "referer": "user-0"}]}
{"question": "c语言求助实现2022年北京高考最后一题连续可表数列", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先，不能搞升序排列，你得保持数组元素的原始顺序。其次，别先入为主地认定m的值啊，按照题意m的值是从1开始一个一个试，试到最后得到的。然后，没啥更好的思路之前，最朴实的办法就是写循环一个一个试呗。", "referer": "user-0"}]}
{"question": "想用gcc编译器怎么一开始就报错？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的电脑似乎是windows电脑，建议使用Linux系统再安装gcc。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "显然没配置对，或者说没配置完整。", "referer": "user-0"}]}
{"question": "‘设计一个名为alter()的函数，接受两个int类型的变量x和y，把它们的值分别改成两个变量之和以及两变量之差’这是练习题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不好理解吗？第一行后，x 已经不是 x 了，而是 x+y ；这样，第二行，右边其实就是 x+y - 2y = x-y  -> y", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "请问2y咋来的", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "那不写着 2*(*y) 吗", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "痛苦在于，你不知道楼主到底问的是啥。如果楼主能清晰描述出具体的问题，就这个问题来说，他就不必发问了。", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "关键是既没有名为alter的函数，也没有两个int类型的参数，不知道干煞嘞", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "忽然发现自己词穷，这种事咋解释啊，痛苦。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "主要是没看懂，不知道从哪个方向得来的", "referer": "user-2"}, {"cid": "8", "user": "user-2", "content": "代个数呗 一个5一个8 第一行得13 第二行得-3", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "第二行的*x已经是第一行的值了", "referer": "user-2"}]}
{"question": "请问一下，x=3.1,y=3.1时的打印结果为什么会是10m，", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "-1 < x < -3  这样写是不对的 ，这是自然语言的写法；x > -1 && x < -3 C语言是这样写的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢，现在理解了", "referer": "user-2"}]}
{"question": "求帮忙555555555555", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <iostream> #include <stdlib.h> #include <vector> using namespace std; struct metal {     int a;     int b;     int c;     int d; }; int main() {     int n=10, ma = 0, mi = 100, j, k = 0;     cin >> n;     std::vector<metal> m(n);     for (int i = 0; i < n; i++)     {         cin >> m[i].a >> m[i].b;         m[i].c = m[i].a / m[i].b;         m[i].d = m[i].a / (m[i].b + 1);         ma = max(m[i].c, ma);         mi = min(m[i].d, ma);     }     int x = 0;     std::vector<int> b;     for (int j = mi; j <= ma; j++)     {         cout << m[0].a << endl;         for (int i = 0; i < n; i++)         {             if (m[i].a / j == m[i].b)             {                 k++;             }             while (k == n)             {                 b.push_back(j);                 ++x;                 k = 0;             }         }         k = 0;     }     cout << b[0] << \" \" << b[x - 1];     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "大佬能解释一下为啥我原来的代码里面的结构体数据会变吗", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "b[n] 会越界。b的个数实际上比n大。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢感谢", "referer": "user-1"}]}
{"question": "求助换行输入的问题。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <vector> #include <string.h> int main() {     int n = 0;     std::vector<int> a, b;      char line[256] = { 0 };      gets_s(line);     sscanf_s(line, \"%d\", &n);      gets_s(line);     char* context = 0;     const char* token = \" \";     char* temp = strtok_s(line, token,&context);     while (temp)     {         int c = 0;         sscanf_s(temp, \"%d\", &c);         a.push_back(c);         temp = strtok_s(NULL, token, &context);     }      gets_s(line);     temp = strtok_s(line, token, &context);     while (temp)     {         int c = 0;         sscanf_s(temp, \"%d\", &c);         b.push_back(c);         temp = strtok_s(NULL, token, &context);     }      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "以前参加ACM时，如果是这种输入，超级不喜欢直接 fscanf以及 cin<< 有时候尾巴的 \\015\\012 两个字符和Linux下的一个字符会导致不同的编译器读出来的不一样。 解决方法： 用 fgets 读取一行，而后在行内 sscanf, 这样无论对方裁判编译器是啥子，都能读出来。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "\\n", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "打印的结果后面要换行的地方加个\\n", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "写多个scanf就行了", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "理论上不用考虑换行与否，你就考虑那些数值就行。", "referer": "user-0"}]}
{"question": "codeblocks  输出字符串与所得结果不一样", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "大约是因为str这个东西的预留空间不够大。", "referer": "user-0"}]}
{"question": "memcpy将数据拷贝到buf中，在将数据拷贝出来，为什么数据不对呢", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "哪儿不对呢？你得说它咋不对了，咱才好分析为啥。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "代码中存在一些类型不匹配的问题，导致数据拷贝出现错误。给你分析一下：1、你声明了 buf 为 unsigned char，但是原始的 char 类型的数据被拷贝到了 buf 中。char 类型可以是有符号或无符号的，取决于编译器的实现。因此，在将 char 数据拷贝到 unsigned char 类型的 buf 中时，可能会出现类型截断和符号位扩展的问题。 2、在将数据拷贝回来时，你使用了 char e;，但是 e 的类型是有符号的，而你之前将数据拷贝到了 unsigned char* 类型的 buf 中，这样可能导致数据截断和符号位扩展。 修改之后的代码：  ```c++    char a = 170;char b = 68;char c = 18;char d = 28; unsigned char* buf = new unsigned char[1024];unsigned char* p = buf; memcpy(p, &a, sizeof(a));p += sizeof(a); memcpy(p, &b, sizeof(b));p += sizeof(b); memcpy(p, &c, sizeof(c));p += sizeof(c); memcpy(p, &d, sizeof(d));p += sizeof(d); p = buf; unsigned char e;  // 注意这里改为 unsigned char 类型memcpy(&e, p, sizeof(e));  // 使用 sizeof(e) 而不是 1 cout << std::hex << static_cast(e) << endl;  // 将 e 转换为 int 输出 ```", "referer": "user-0"}]}
{"question": "清除缓存区的函数不是fflush(stdin)吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  int main() {     char password[20] = { 0 };     printf(\"请输入密码：>\");     gets_s(password);      printf(\"请确认密码：>\");     char confirmed[20] = { 0 };     gets_s(confirmed);     if ('Y' == confirmed[0])     {         printf(\"Yes\\n\");     }     else     {         printf(\"No\\n\");     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "又是因为windows下 CR/LF 搞的鬼。win下换行有2字符。第二个输入直接读了上一个换行，导致相当于按了两次回车。 使用 gets 和 sscanf来处理，可以避免这个问题。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "rewind(stdin);", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "fflush函数是设计来处理输出缓冲区的，拿来处理输入缓冲区的话，后果不可预计。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "en，我刚开始学，没太理解说的什么意思", "referer": "user-3"}, {"cid": "6", "user": "user-0", "content": "我是想用 fflush 函数清除缓存区里面存放的东西的", "referer": "user-3"}, {"cid": "7", "user": "user-0", "content": "fflush 函数不能这样用吗", "referer": "user-3"}]}
{"question": "结构体到底要怎么输入输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "结构体里 char *name; 定义是个指针，在给它赋值前需分配空间，修改如下，供参考： #include <stdio.h> #include <stdlib.h>  typedef struct{     char *name;     int num;     double score; }student; student* gethigh(student* s1,student* s2){     return s1->score > s2->score? s1 : s2; } int main(){     student s1,s2;         s1.name = (char *)malloc(sizeof(char)*16);  // 修改         s2.name = (char *)malloc(sizeof(char)*16);  // 修改     printf(\"请输入学生的姓名学号成绩：\");     scanf(\"%s%d%lf\",s1.name,&s1.num,&s1.score); // 修改         //scanf(\"%s%d%lf\",&s1.name,&s1.num,&s1.score);     scanf(\"%s%d%lf\", s2.name,&s2.num,&s2.score);// 修改         //scanf(\"%s%d%lf\",&s2.name,&s2.num,&s2.score);     student s = *gethigh(&s1,&s2);     printf(\"学号%d的学生%s的成绩更高：%lf\",s.num,s.name,s.score);     //printfin(&s);      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的name是指针，没有保存字符串的空间。", "referer": "user-0"}]}
{"question": "vs里写成的代码，能生成链接或其他形式，给没有编译器的电脑看运行效果吗，比如说写个贪吃蛇游戏，怎么给没有编译器的朋友玩呢\n\n", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你是用什么编程语言写，可以打包一下如果是python的话，可以考虑用", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "目前是c语言 这张图提供了宝贵思路 谢谢呀", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "没事，我可以给你看看c的", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "为什么你会觉得不可以", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "可以的吧，给对方的就是生成的那个 exe 文件了，他可能还需要安装你的 vs 对应版本的运行库（这些网上有标准的可以下载了安装）。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "好的 我去试试 谢谢呀", "referer": "user-3"}]}
{"question": "帮帮孩子吧，实在是太难受了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你把代码发出来，我帮你改一下", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "en，不是代码的问题，是运行代码的窗口问题", "referer": "user-1"}]}
{"question": "c语言可修改左值问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不是吧，if() 语句的最后一个，j = N - 1 应该是 j == N - 1 吧；看判断逻辑，应该是求数组边界元素之和", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢，我一会去看看", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "确实是求那个M×N数组的边界值和。我改了还是不行🙃", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "没改对吧？刚在 vc2008 里试了，就改动这一处，是可以通过编译没有错误或警告提示的。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "if (i == 0 || i == M - 1 || j == 0 || j = N - 1)这里边 i == M-1 不能这么定义吧，应该是i = M-1", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢，我一会去看看", "referer": "user-2"}]}
{"question": "求助！在这个代码中‘bool inword = false’存在的意义是什么？没看懂，求大佬解惑！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "表示当前是不是单词里，只有遇到字母，才进入单词，然后只有遇到空格（如题所言暂未考虑标点类），才结束当前单词；如此循环。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的谢谢", "referer": "user-1"}]}
{"question": "求助！l输入500时，循环进行到第五次l会自动归零，是为什么？（c语言）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "好的，谢谢谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> int main() {     int l;     int *i = (int*)malloc(sizeof(int) * l);     int n=0;               scanf(\"%d\",&l);          for(n=0;n!=l;n++){         i[n]=0;         printf(\"%d\\n\",i[n]);     }     return 0; }  ```c    ```", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "c里面不能直接int i[n]，这样它并不能动态的根据n的值去分配空间，需要用malloc手动申请", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "你的free没啦", "referer": "user-1"}]}
{"question": "新手求助大佬！求大佬来解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "外部循环 'for（a=3;a<num;a+=2）'：这个循环从3开始迭代，每次迭代增加2，直到达到给定的输入 'num' 值之前。这样做是因为偶数除了2外都不可能是素数，所以只检查奇数。 内部循环 'for（b=3;b*b<a;b+=2）'：在每次外部循环迭代时，这个循环用来检查是否有因子可以整除当前的奇数 'a'。它从3开始迭代，每次迭代增加2，直到 'b*b >= a' 为止。这是因为如果存在一个小于等于 'sqrt（a）' 的因子，那么一定会存在一个大于等于 'sqrt（a）' 的因子。所以，只需检查 'b' 的平方是否大于等于 'a'。 'if（a%b==0）'：如果在内部循环中找到了一个可以整除 'a' 的因子 'b'，那么说明 'a' 不是素数，应该中断内部循环。 'if（bb>a）'：在内部循环结束后，如果没有找到能够整除 'a' 的因子，就说明 'a' 是素数。此时，'bb' 的值将大于 'a'，因为在内部循环的最后一次迭代时，'b' 的平方刚好不小于 'a'。所以，如果 'b*b > a'，则打印当前的素数 'a'。  总之，这段代码使用两个嵌套的循环来检查并打印小于给定输入值 'num' 的所有素数。外部循环遍历奇数，内部循环检查是否有因子能够整除当前的奇数，最终根据是否找到因子来判断是否为素数。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "万分谢谢，讲解的真详细，谢谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "第一个问题：for(b=3;b*b<a;b+=2)你应该理解为，b从3开始，只要b的平方小于a，b就循环下去，而且每一次循环，b都等于b+2。第二个问题：如果b的平方大于a，则输出a的值", "referer": "user-0"}]}
{"question": "C语言子进程全局变量问题", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "劝你C里别乱用全局变量，要么用静态的全局变量，通过get函数让外部获取。设计中，把全局变量规划到结构体中，需要与其他模块交互的，结构体放在头文件内，不需要与其他模块交互的，放在.c文件，这是种仿照C++的面向对象式构建，类似class里public和private。如此一来，不管模块是单实例还是多实例，全局变量也不会产生冲突。", "referer": "user-0"}]}
{"question": "萌新求助！感谢感谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "@explicit_man能说一下你这个是几几年的版本吗？因为VS2015的调试连接进程叫““VsHub.exe””，后续版本不太清楚。很可能是\"vshost.exe\"。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "抱歉，前段时间有点事，是2022版的，我试一试，非常感谢", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "我试了一下，结束vshost.exe之后，重新生成一下就可以解决这个问题了，感谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这是个比较大的可能，“任务管理器”里应该是找到进程 test1.exe 并强行终止它试试", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "@explicit_man你好！这个应该是编译时出现错误，在程序调试时被强制终止，导致编译器一直卡在上一次调试的进程中。在下一次编译时程序文件被占用，所以无法打开也无法写入。可以进入“任务管理器”，选择标有“进程”的选项卡，进入“Visual Studio”进程，展开并找到“VsHub.exe”，点“结束任务”，然后重启电脑试试。希望能帮到你。", "referer": "user-0"}]}
{"question": "递归的轨迹，需要弄明白吗，怎样在程序里理解递归呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出", "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-2", "content": "这个也很容易啊   最简单的方式就是debug方式查看有问题的地方；而且递归一般除非出不来，因为一般递归条件都是一样的如果有问题那就是没办法递归  也就是每一层都有问题   那如果是中间有问题   那就是看业务了   可以在每一层可能会出现问题的地方打log输出   这样也可以清除的看到当前递归到哪一层以及当前的数据是哪一样的了    毕竟递归就是一层一层往下找  然后找到对应的层数返回的时候也是一层一层往回返回的（走回头路）", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "哦明白了 谢谢帮助", "referer": "user-2"}]}
{"question": "判断能否构成三角形的代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if ((a + b) > c and (b + c) > a and ( a + c) > b);多打了一个;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "嗯嗯，现在知道了，谢谢😜", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "你再if那打了个分号是什么意思？？？？？？？？？？？？？？？？？？？？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "才学c，不太清楚", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "oh", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "if ((a + b) > c and (b + c) > a and ( a + c) > b);有2个错误1.if ((a + b) > c && (b + c) > a &&( a + c) > b);2.行末去掉分号;", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "OK，感谢", "referer": "user-3"}, {"cid": "8", "user": "user-4", "content": "这个and像极了以前刚学的样子", "referer": "user-3"}, {"cid": "9", "user": "user-5", "content": "if 语句那行的最后不能有语句结束标记的分号吧，之前好像有个帖子有类似问题", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "那个分号一旦用了的话，if就不能管后面的那个else了是吧？", "referer": "user-5"}]}
{"question": "问题                ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "理论上你看到的一切桌面效果，都可以用C实现，只是比较麻烦C的优势是简练，是很理想的算法描述语言所以一般用于入门和基础学习", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "当你刚开始学习C语言时，有许多适合练手的项目可以帮助你巩固所学知识并提高编程技能。这些项目应该是简单而有趣的，以保持你的学习动力。下面是几个适合初学者的C语言练手项目建议： 简易计算器：编写一个可以进行基本算术运算（如加法、减法和乘法）的程序，让用户能够输入数字和操作符，然后显示结果。 游戏猜数字：创建一个猜数字的小游戏，让用户尝试猜一个随机生成的数字，直到猜对为止。 单词计数器：编写一个程序，读取一个文本文件，并计算其中单词的数量、行数或字符数等信息。 简易日历：设计一个控制台程序，用户可以输入年份和月份，然后显示对应的日历。 迷宫游戏：实现一个简单的控制台迷宫游戏，让用户通过键盘输入移动指令来寻找出口。  至于C语言的应用范围，并不仅局限于后端开发。虽然C语言在系统级编程和嵌入式设备开发方面非常出色，但它也被广泛运用于其他领域。例如，它可用于游戏开发、科学计算、设备驱动程序编写、嵌入式系统开发和网络编程等。因此，学习C语言将为你打开许多不同领域的机会，并让你能够参与各种有趣的项目和应用开发。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢", "referer": "user-2"}]}
{"question": "求助！想问一下win11系统，缺少msvcr110D.dll文件打不开应用该如何解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先，从微软官网下载 Visual C++ Redistributable for Visual Studio 2012。你可以在以下链接找到下载页面：https://www.microsoft.com/en-us/download/details.aspx?id=30679 在下载页面中，选择适用于你的系统的版本（32位或64位），然后点击下载按钮。 下载完成后，运行下载的安装程序。 在安装向导中，按照提示进行操作。通常情况下，你只需点击 \"Next\" 或 \"Install\" 按钮来完成安装过程。 安装完成后，重新启动你的电脑。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "msvcrt， vc 运行库，需要什么版本的 vc执行库吧，网上有合集的，干脆找了下载来全装上拉倒，免得不时地唧唧歪歪", "referer": "user-0"}]}
{"question": "萌新求助！为啥我用scanf_s会出现下图，感谢帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf_s为scanf", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "当使用scanf_s函数时，可能会出现运行时错误或警告。这是因为scanf_s是安全版本的输入函数，用于防止缓冲区溢出。该函数在输入时需要提供缓冲区的大小作为参数。 示例代码： #include <stdio.h>  int main() {     char name[20];     printf(\"请输入您的名字：\");     scanf_s(\"%19s\", name, sizeof(name));      printf(\"您好，%s！\\n\", name);      return 0; }  上述代码中，我们声明一个大小为20的字符数组name作为缓冲区，并在scanf_s函数中指定缓冲区的大小为sizeof(name)。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "理解，感谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "https://blog.csdn.net/weixin_59799963/article/details/120811513", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "感谢分享", "referer": "user-3"}]}
{"question": "求助！为什么会重复打印You are 65.Here is your gold watch.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "判断出错了，if(age=65)，修改为if(age==65)", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "原来如此，谢谢", "referer": "user-1"}]}
{"question": "C语言小白，刚学两天，请问这里else后面的应输入一个语句是啥意思", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我学习c语言就是为了考试，工作上从来没用过 0.0", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我们做嵌入式的主要还是C", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "学习c语言还用vs studio这么重型的开发工具么，不过你学习c语言干嘛呢，开发数据库还是服务器？这些都有公司开发过了，非常成熟的产品，推荐你学Go语言，更加实用性", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "大学要学，笨鸟先飞嘛", "referer": "user-1"}, {"cid": "5", "user": "user-3", "content": "加油呀！", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "if(判断条件){  // 要执行的代码}else{  // 要执行的代码}", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "谢谢谢谢", "referer": "user-3"}, {"cid": "8", "user": "user-4", "content": "判断条件后面没有冒号", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "你的语法不对 if后面不用接;   加了;就等于if结束了", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "谢谢，把；删了果然就可以了", "referer": "user-2"}]}
{"question": "DAPP数字货币交易所开发搭建", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "当涉及到DAPP（去中心化应用程序）和数字货币交易所的开发时，涉及到了许多技术和概念。下面是一个简要的教程，介绍了一些你需要考虑和学习的主要方面。 区块链基础知识：首先，你需要了解区块链技术的基本原理和概念，比如共识机制、智能合约和去中心化存储等。这将有助于你更好地理解以太坊等智能合约平台的工作原理。 以太坊（Ethereum）平台：以太坊是最常用的智能合约平台之一，提供了构建DAPP的基础设施。你可以学习以太坊的背后的技术和工具，以及如何使用Solidity编写智能合约。 智能合约：智能合约是DAPP的核心组成部分。你需要学习如何使用Solidity或其他智能合约语言编写智能合约，并理解如何部署和调用它们。 客户端应用程序开发：为了与智能合约进行交互，你需要开发一个前端应用程序。使用Web3.js或其他以太坊开发库可以帮助你与智能合约进行交互，实现用户界面和交易功能。 安全性：当涉及到数字货币交易所时，安全是至关重要的。你需要学习如何保护用户的数字资产，预防潜在的攻击、漏洞和合约错误。 用户注册和身份验证：你可能需要实现用户注册和身份验证系统，以确保只有授权的用户可以访问和使用交易所。 数字货币钱包集成：为了存储和管理用户的数字货币资产，你需要与不同的数字货币钱包进行集成。学习如何与以太坊钱包进行交互，并确保安全性和良好的用户体验。 交易执行和结算：为了实现数字货币的交易，你需要学习如何执行和结算交易，包括手续费计算、订单匹配和资金转移等。 监管合规性：数字货币交易所通常需要遵守当地的金融监管法规。你需要了解相关的法律法规，并确保你的交易所符合监管要求。 运维和部署：最后，你需要考虑如何部署和维护你的DAPP交易所，包括服务器架构、数据库管理和监控等。  请注意，以上仅是一个简单的概览，涉及到DAPP交易所开发的许多复杂性细节。因此，我建议你进一步学习相关的课程、教程和文档，以获得更深入的理解和技术知识。 希望这些信息对你有帮助！如果你还有其他问题，请随时提问。 欢迎注册使用 http://www.zuixin.org.cn/ 它可以解答你遇到的大部分问题", "referer": "user-0"}]}
{"question": "C#中如何调用C++生成DLL的unsigned char*参数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "根据您提供的信息，错误可能是由于以下原因引起的： DLL文件不存在或路径不正确：请确保将ClientDLL.dll文件放在正确的位置，并检查调用代码中的路径是否正确。 DLL文件与应用程序的位数不匹配：如果您的应用程序是64位的，而ClientDLL.dll是32位的，或者反之亦然，就会出现这个错误。请确保您的应用程序和DLL文件具有相同的位数。 函数的参数类型不正确：请仔细检查GenerateKeyEx函数的参数类型并与C#中的定义进行对比。确保参数类型、大小和布局都正确匹配。 可能需要进一步设置DllImport属性：您可以尝试通过设置DllImport属性中的CallingConvention属性来解决此问题，例如：  [DllImport(\"ClientDLL.dll\", EntryPoint = \"GenerateKeyEx\", CallingConvention = CallingConvention.Cdecl)]public static extern int GenerateKeyEx(    [MarshalAs(UnmanagedType.LPArray)]    byte[] ipSeedArray,    uint iSeedArraySize,    uint iSecurityLevel,    [MarshalAs(UnmanagedType.LPArray)]    byte[] ipVariant,    [MarshalAs(UnmanagedType.LPArray)]    byte[] iopKeyArray,    uint iMaxKeyArraySize); 请尝试根据上述建议进行修改，如果问题仍然存在，请提供更多的代码和错误信息，以便我可以更好地帮助您。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "试下stringbuilder", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "https://blog.csdn.net/bruce135lee/article/details/80050662", "referer": "user-0"}]}
{"question": "目前的人工智能太让人失望了，你们觉得呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "还优化？代码都是网上抄来的，你当它真的会编程？你断网让它写个程序试试(以前没写过的)～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "从大部分专业领域讲，如果以10分制代表目前人类达到的顶尖水平，那么目前AI经过优化后能做到23，少部分领域能达到4甚至5。人类水平近似指数分布，也就是说AI至少超越了30%50%的人类。或许你觉得AI并不咋地，但我评估过GPT对文章的润色和程序代码的优化，对于缺少项目经验的应届生而言基本上是碾压的……应该庆幸目前的AI仍是一个个孤岛。如果有朝一日这些孤岛联成了网络，并且把人类所有的研究成果不设防地喂狗，那么这个狗子超越人类是指日可待的事情。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "嗯嗯嗯，但是吧，能替我们解决很多专业方面的问题，尤其是谷歌上的chat4，真的有程序员思维。国内的文心一言，我在用内测的，感觉上那个比较类似于搜索引擎，不会和我进行连续的对话，这是相对而言的一个比较大的差距。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "认同这个观点", "referer": "user-0"}]}
{"question": "串口发送文件，发送的文件和接收到的文件大小为什么会不一致呢？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "多线程需要加锁", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "请问 哪里需要加锁？", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "void *sersend(void *arg) // 串口发送线程函数{    int ik = 0; std::ifstream file; // 以只读方式打开文件 file.open(\"yyj.pdf\", std::ios::in);  // 指针定位到文件末尾 file.seekg(0, std::ios::end); int fileLength = file.tellg();  // 指定定位到文件开始 file.seekg(0, std::ios::beg);  cout << \"fileLength:\" << fileLength << endl; char *buffer = new char[fileLength + 1]; file.read(buffer, fileLength); buffer[fileLength] = '\\0'; // string contents = buffer; // cout << \"contents:\" << contents << endl; write_serial_data(fd, (char *)buffer, fileLength); if (buffer) {     delete[] buffer; } file.close();  }  我读文件改成 这个读的模式， 测试几次，这个PDF文件是没有问题的，具体啥原因不是太清楚。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "所以是原始文件大小和发送字节数不一致？还是发送字节数和接收字节数不一致？还是接受字节数和写出来的文件大小不一致？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "看我这个问题是 发送，接收是正确的，问题应该是出在读文件上了， 上述回复我已经把这个代码贴出来了，方便大家", "referer": "user-2"}]}
{"question": "C 嵌入 SQL统带 连接数据库报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "infomix esql/c？这个东西的原理是用一个专用的预处理器将源码中嵌入的sql语句转换为对esql库函数的调用。所以嵌入的sql语句必须是编译时可求值的常量，只有参数可以用变量", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "学习了。原本不了解还有这样的解决方案。", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "问题太简洁了，缺乏约束条件。所以可能性太多。", "referer": "user-0"}]}
{"question": "树的应用与实现  我的代码有什么问题 用的Dev-c++", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在函数InitCtree中，使用scanf函数接收输入时，应该使用\"%d\"格式化符来接收整数，而不是\"%c\"格式化符来接收字符。 在函数AddChild中，应该在创建CTNode结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数ExchangeTree中，应该在创建BTNode结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数ExchangeTree中，应该在创建第一个孩子结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数ExchangeTree中，应该在创建兄弟结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数PostOrder中，应该在访问完根结点之后，将mark指向根结点，而不是将mark指向p。 在函数PostOrder中，应该在访问完根结点之后，将p出栈，而不是将p指向栈顶指针。 在函数PostOrder中，应该在访问完根结点之后，将mark指向根结点的父结点，而不是将mark指向根结点。 在函数PostOrder中，应该在访问完根结点之后，将p出栈之前，先将p赋值给e，然后再出栈。 在函数main中，应该在调用ExchangeTree函数之后，判断是否成功转换二叉树，如果转换失败应该进行相应的错误处理。 在函数main中，应该在调用InitCtree函数之后，判断是否成功初始化树，如果初始化失败应该进行相应的错误处理。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-1"}]}
{"question": "大佬们，为啥会出现3221225477错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "3221225477 = 0xC0000005 拒绝访问，一般是使用了空/错误指针；看源程序，scanf(...) 里，那些 int 类型的域，都没有引用地址，全错了。", "referer": "user-0"}]}
{"question": "这个 gcc openmp code 实现并行了吗？怎么速度没变？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "某银行分理处，说我处日常开8个窗口为广大用户提供服务。然而在岗的柜员只有1组，她(们)在1号窗口办理一件以后连忙跑到2号窗口坐下，还得面带笑容地问，为啥我的工作效率没有提高到8倍呢？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "实现并行：根据你的代码，你使用了OpenMP的并行指令#pragma omp parallel for，并设置了线程数为8（omp_set_num_threads(8)）。这应该可以实现并行计算。然而，你的代码中的计算任务非常简单（对一个循环变量赋值），这种情况下并行化可能不会带来明显的性能提升。 耗时不减少的原因：你的计算任务实际上是一个很轻量级的任务，循环中的计算操作很快就会完成。在这种情况下，并行化的开销可能会超过并行计算带来的性能提升。此外，你的代码中没有涉及到对共享数据的访问或复杂的计算操作，这也限制了并行计算的效果。 减少耗时的方法：如果你想看到并行计算带来的明显性能提升，你需要选择更复杂、耗时较长的计算任务。例如，可以尝试在循环中进行更复杂的数值计算或数据处理操作。 实现并行：你的代码中已经使用了OpenMP来实现并行计算。如果你的代码运行时没有报错，并且输出结果与预期一致，那么你的代码已经成功并行化了。 核心数量与性能提升：服务器的核心数量决定了能够同时执行的线程数。在你的代码中，你设置了8个线程，因此在多核服务器上运行时可以同时执行8个线程。然而，并行计算的性能提升不仅取决于核心数量，还受限于任务的性质、计算复杂度以及数据访问模式等因素。 在实际情况下，性能提升的幅度取决于并行计算的可扩展性和负载平衡。对于复杂的计算任务和合理的并行算法，提高性能的幅度可以达到核心数量的数量级。然而，并行化不会线性地提高性能，因为存在一些开销，例如线程之间的同步、数据划分和通信等。  总结：对于像你提供的代码中的简单计算任务，可能无法通过并行化获得明显的性能提升。如果你想看到并行计算的效果，可以选择更复杂的计算任务，并确保任务本身足够耗时和具有合理的并行算法。此外，性能提升也受到硬件限制、负载平衡和算法设计等因素的影响。", "referer": "user-0"}]}
{"question": "win10.bat文件无法使用", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "应该是基于32位系统开发，然后64位不支持。或者封闭有问题。", "referer": "user-0"}]}
{"question": "小萌新寻求大佬们的帮助，阿里嘎多，嘤", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你好朋友，看起来这个问题是 Visual Studio 编译器对 scanf 函数的一个警告。该警告是由于 scanf 函数可能面临缓冲区溢出、格式化字符串漏洞等安全问题而引起的。 为了解决这个问题，Microsoft 引入了 scanf_s 函数作为 scanf 函数的替代品，它提供了更多的安全保障。scanf_s 与 scanf 的使用方式相似，但在格式说明符之后需要指定读取的数据长度。 例如，以下代码展示了如何使用 scanf_s 从标准输入读取一个整数： #include <stdio.h>  int main() {     int num;     printf(\"Enter a number: \");     scanf_s(\"%d\", &num, sizeof(num));     printf(\"You entered: %d\\n\", num);     return 0; }  如果你必须使用 scanf 函数，可以通过在源代码中添加预编译指令 #define _CRT_SECURE_NO_WARNINGS 来抑制此警告。然而，这并不推荐，因为这么做可能会降低程序的安全性。除此之外，有些编译器不支持这个指令，这样就会导致编译失败。答题不易，有帮助可以支持一下", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好哒，非常感谢", "referer": "user-1"}]}
{"question": "萌新跪请大佬们指点这个代码的问题到底在哪里", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "@CSDN-Ada助手 标红的地方代码不能运行。得出的结果始终是一个空字典。但是之前用另外的excel表格又是可以的。萌新完全懵逼了，请大佬们拔冗指点一下，", "referer": "user-0"}]}
{"question": "找一个开发C语言的浏览器的填表程序。有意联系我。在页面进行循环操作。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "?什么意思", "referer": "user-0"}]}
{"question": "排列组合查找算法求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "选定了三个号后，可能的组合相当于C(46, 4) = 163185种，可以直接生成~", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考： #include <stdio.h> #include <stdlib.h> #define MAX_NUM 26 int comb[MAX_NUM]; int c1,c2; void combination(int m,int n) {     int i,j;      for (i=m;i>=n;i--) {         comb[n]=i; /* 选择当前的“头”元素 */         if (n>1) {             combination(i-1,n-1); /* 进入下一次更小的组合问题 */         } else { /* 满了需要的组合数，输出 */             for (j=comb[0];j>0;j--) printf(\"%c\",'A'+c1-comb[j]);             printf(\"\\n\");         }     }     return; } int main(int argc,char **argv) {     if (argc<3) {         printf(\"%s 组合下标 组合上标\\n\",argv[0]);         return 1;     }     c1=atoi(argv[1]);     if (c1<1 || MAX_NUM<c1) {         printf(\"1<=组合下标<=%d\\n\",MAX_NUM);         return 2;     }     c2=atoi(argv[2]);     if (c2<1 || c1<c2) {         printf(\"1<=组合上标<=组合下标\\n\");         return 3;     }     comb[0]=c2;     combination(c1,c2);     return 0; }    //qplw.cpp #include <stdio.h> #include <string.h> #include <stdlib.h> int v=0; int w=0; int m;//记录字符串长度 int n;//记录字符串中的字符种类数 char map[256];//记录是哪几种字符 int count[256];//记录每种字符有多少个 int stack[1000];//递归用的栈，并记录当前生成的排列 void Make_Map(char *str) {//统计字符串的相关信息     int s[256];     int i;     memset(s,0,sizeof(s));     memset(count,0,sizeof(count));     m=strlen(str);     if (w<1 || m<w) w=m;     while(*str) {         s[*str]++;         str++;     }     n=0;     for (i=0;i<256;i++)         if (s[i]) {             map[n]=i;             count[n]=s[i];             n++;         } } void Find(int depth) {//递归式回溯法生成全排列     if (depth==w) {         int i;         for (i=0;i<depth;i++) putchar(map[stack[i]]);         putchar('\\n');     } else {         int i;         if (v && depth>0) {             for (i=0;i<depth;i++) putchar(map[stack[i]]);             putchar('\\n');         }         for (i=0;i<n;i++)             if (count[i]) {                 stack[depth]=i;                 count[i]--;                 Find(depth+1);                 count[i]++;             }     } } void main(int argc,char**argv) {     if (argc<2) {         printf(\"%s 要产生全排列的字符串 [限定长度|-1]\\n\",argv[0]);         return;     }     if (argc>=3) w=atoi(argv[2]);     if (-1==w) v=1;     Make_Map(argv[1]);     Find(0); } //C:\\test>qplw //qplw 要产生全排列的字符串 [限定长度|-1] // //C:\\test>qplw 123 //123 //132 //213 //231 //312 //321 // //C:\\test>qplw 123 2 //12 //13 //21 //23 //31 //32 // //C:\\test>qplw 122333 3 //122 //123 //132 //133 //212 //213 //221 //223 //231 //232 //233 //312 //313 //321 //322 //323 //331 //332 //333 // //C:\\test>qplw 123 -1 //1 //12 //123 //13 //132 //2 //21 //213 //23 //231 //3 //31 //312 //32 //321 //", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "某三个号码是固定组合？没有次序变化吧", "referer": "user-0"}]}
{"question": "关于ME2159升压电路的疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "用芯生美的CSM9201试试，可以提供DEMO测试", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你的原理图上少画了一个肖特基二极管。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "@CSDN-Ada助手 有请ada 来解释一下。", "referer": "user-0"}]}
{"question": "求助，有注释，我的代码没有问题，但运行到一半总会跳过一段代码，怀疑是内存不足，希望有大佬指点迷津，软件为dev-c++", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "贴主，请你去 ask.csdn.net 提问，会有更多人回答。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "@CSDN-Ada助手 请看这个程序的问题，谢谢。 程序的任务是做一个迷宫并走通", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "程序运行到一半就退出", "referer": "user-x"}, {"cid": "6", "user": "user-3", "content": "后面没看，只看到**,**存放在长度5的字符数组了，没处放结束符。如果没有使用字符串相关的库函数，这样用是可以的，然而您愉快地使用了字符串库函数。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "是不是我的注释不够清晰啊，本人大一，写出来的代码基本是一坨，大家有被我弄迷惑的可以在评论里说一下", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "忘了说了，我的任务是做一个迷宫并走通", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "你看看 user-3 给你的解释", "referer": "user-0"}]}
{"question": "小白请教问题  :)", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "return 0；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "那个scanf(\"%d %d\")中间别加空格", "referer": "user-0"}]}
{"question": "小白请教这个代码为啥崩了", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "使用更改后的代码重新运行，你打印字符串就好好打印字符串，不要变动指针 #include <stdio.h> #include <stdlib.h>  void modify(char*& p) {     p = (char*)malloc(100);     fgets(p, 100, stdin); }  int main() {     char* p;     modify(p);     printf(\"%s\\n\", p);     free(p);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "嗯是的没错", "referer": "user-2"}, {"cid": "4", "user": "user-4", "content": "@CSDN-Ada助手请问上面的代码有什么问题呢？", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "啥叫崩了呢？", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "进程意外退出", "referer": "user-5"}]}
{"question": "gcc openmp 入门问题", "poster": "user-0", "comments": [{"cid": "2", "user": "user-0", "content": "根据 OpenMP-master.zip 里的示例，我进行了以下尝试。但是无论其中 openmp 的代码写不写进去，运行时间都是大约10秒。而且这个耗时还是可重复的，总是这么长时间。这台服务器是多核的，不是单核的。 请问： 它到底实现没实现并行？如果实现了，为什么耗时不减少？怎么样才能减少耗时？如果没有实现并行，怎么样才能实现并行？如果能实现并行，是不是这台服务器有几个核，速度最多就只能提高到几倍？ 谢谢。 #include <stdio.h>#include <string.h>#include <stdlib.h>#include <omp.h> int main(){ unsigned long i, j; omp_set_num_threads(8); #pragma omp parallel for for(i=0;i<4294967296;i++) {  j = i; } return 0;}", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#pragma omp parallel for num_threads(8)这一行前面的#改为//。C代码里面单行注释是//", "referer": "user-0"}]}
{"question": "询问了几个人都有点模糊，这是对定义字符串的模糊。", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "C", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "C只初始化了一个4字符的数组，不是字符串~", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "你是对的。", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "D", "referer": "user-0"}]}
{"question": "求大神解答一下哪里有问题", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "1、结构体里没有“英语成绩”2、main函数第一个for循环中第一个输入cin>>studentS，这个变量名写错了3、第二个for前面变量声明的时候空格丢个4、最后输出名字的时候变量名又写错了 #include <iostream> #include <string>   using namespace std;  struct Student {     string name;     float c_s;     float m_s;     float eh_s;     float avg_s; };   int main() {     Student students[3];     for (int i=0; i<3; i++) {         cout<< \"input the \"<< i+1 <<\"student name:\";         cin >> students[i].name;         cout<< \"input Ch score:\";         cin >> students[i].c_s;         cout<< \"input math score:\";         cin >> students[i].m_s;         cout<< \"input eh score:\";         cin >> students[i].eh_s;         students[i].avg_s = ( students[i].c_s + students[i].m_s + students[i].eh_s )/3.0;     }           int max_index = 0;          for (int i=1; i<3; i++) {         if (students[i].avg_s > students[max_index].avg_s) {             max_index=i;         }     }          cout << \"max \" << students[max_index].name << endl;     cout << \"avg score \" << students[max_index].avg_s << endl; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "球球了", "referer": "user-0"}]}
{"question": "求解，请问哪里出错了？", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "请问main你的  return 0；到哪里去了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你的返回值类型是int，而你没有返回值,return ;解决办法1：将返回值类型int改为void解决办法2：加返回值", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "你好，现在改了，还是有这个问题 【】", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "在这段代码中有几个语法错误，需要进行修正。首先，for 循环后面应该是一个代码块，而不应该以分号 ; 结尾。此外，在判断式中的 a % 6 = 5 应该修改为 a % 6 == 5。最后，printf() 函数调用中的逗号 , 应该修改成英文状态下的逗号 ,。 修正后的代码如下： #include <stdio.h>  int main() {     int a;     for (a = 0;; a++) {         if (a % 2 == 1 && a % 3 == 2 && a % 5 == 4 && a % 6 == 5 && a % 7 == 0) {             break;         }     }     printf(\"%d\", a);     return 0; }  这段代码利用了 for 循环和条件判断语句，对变量 a 进行递增操作，直到找到符合要求的取值停止循环，并且将该值通过 printf() 函数输出。其中 % 表示模运算符，表示对于两个整数，返回它们相除的余数。因此如果 a%2 ==1 则表示 a 除以 2 的余数为 1，其他判断条件同理。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "好像不是这几个原因", "referer": "user-4"}]}
{"question": "函数调用时参数内容发生变化", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "@赵4老师谢谢老师。我打了断点，下图是反汇编模式下看到的调用情况： 当执行这一行指令时可以看到，下方打印出这个地址的值是正确的，然后单步执行到下一行，如下图：  这个地址的第一个字符被修改成了\\000，后面的字符没有变化，这是什么原因呢？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "仅供参考： #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢老师，但是我没看懂是什么意思。", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "意思就是当你发现某个变量的值莫名其妙不知道被哪里的代码改变了的时候，在这个变量所在地址设置数据断点，再重新开始调试运行，一旦值被改，就会停在修改值的C语句或汇编指令处，此时可以按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "补充hashmap和list的数据结构", "referer": "user-0"}]}
{"question": "请问这个程序有什么问题吗，为什么把c设置为整型就可以打印出来，但是如果设置为字符型就什么都不显示。", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "你没发现两个逗号长得不一样吗？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "嗯嗯 刚刚发现了 是自己手残、", "referer": "user-2"}]}
{"question": "函数内部变量可以被外部访问", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "栈中的变量通常包括函数参数和函数里声明的临时变量。栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。而栈中的类变量退出其作用域时，会自动执行其析构函数，……所谓在栈中“申请”N字节的空间，其实只是将栈指针寄存器（16位sp，32位esp，64位rsp）的值多减N而已。 其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。 计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢老师", "referer": "user-2"}]}
{"question": "请问我这个程序有什么问题嘛，为什么只会输出等级A?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "90<=a && a<=100", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if条件都错了……2个条件是不是应该用a<=100&&a>=90来表达", "referer": "user-0"}]}
{"question": "java初学者正在跟着翁恺老师学，有一个数数字的问题搞不懂，希望大神们能给解答一下。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "打印一下看数字位数，你就明白了", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int number=... 这是个整数，若到了个位数，再 /10 结果就是 0 了", "referer": "user-0"}]}
{"question": "求教-windows控制台CMD putc 打印问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "严格的说是你括号的位置不对while (ch = (getc(fp)) != EOF)改为while ((ch = getc(fp)) != EOF) {", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "少写了括号，优先级问题while (ch = (getc(fp)) != EOF)改为while ((ch = (getc(fp))) != EOF)", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不是中文，是全英文写的hello world", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "@CSDN-Ada助手 putc输出方框乱码是什么原因？", "referer": "user-0"}]}
{"question": "DEVC++写C语言代码，第一次运行时正常的，但退出再运行就不出现结果了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "换VS2022（安装时注意勾选C++桌面开发，默认不勾选）", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可能出现了卡顿情况,电脑刷新一下再试试,如果还不行，就把代码复制到一个新的界面,重新编译运行,如果还不行，就是电脑或者devc++的问题了。", "referer": "user-0"}]}
{"question": "求助，各位大佬们，明天就要交作业啦，呜呜呜", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "@CSDN-Ada助手 \"scanf: This function or variable may be unsafe, Consider using scanf_s\" 请写代码对比scanf和scanf_s用法，C4996警告应该怎样解决。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-1"}, {"cid": "4", "user": "user-0", "content": "谢谢啦", "referer": "user-x"}, {"cid": "5", "user": "user-3", "content": "在源代码最上方加上#pragma warning(disable:4996)或者#define _CRT_SECURE_NO_WARNINGS 1都可以。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢，辛苦了", "referer": "user-3"}]}
{"question": "C语言编译没有错误但运行时结果没有出来", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "调试可以解决百分之九十的问题", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "可以单步跟踪看看问题出现在哪里", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "例如我现在正在说的这句话，语法是正确的，然而是废话，不产生输出。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "你真是人才", "referer": "user-4"}]}
{"question": "Huffman树的创建，编码，解码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <iostream> #include <string> using namespace std; struct huffTree {     int parent;     int lchild;     int rchild;     int weight;     string flag; }; struct Lowest_node {     char ch;     int ch_num; }; void coding(int length,huffTree *tree,int n,int &a,int &b) {     int i;     int r,s;      r=s=length;     for (i=0;i<n;i++) {         if (tree[i].weight<r          && tree[i].parent==-1) {             r=tree[i].weight;             a=i;         }     }     for (i=0;i<n;i++) {         if (tree[i].weight<s          && i!=a          && tree[i].parent==-1) {             s=tree[i].weight;             b=i;         }     } } void frequency(string str) {     int i,j;     int length=str.length();     Lowest_node *node=new Lowest_node[length];      for (i=0;i<length;i++) node[i].ch_num=0;      int char_type_num=0;     for (i=0;i<length;i++) {         for (j=0;j<char_type_num;j++)             if (str[i]==node[j].ch             || ('a'<=node[j].ch && node[j].ch<='z'                 && str[i]+32==node[j].ch))                 break;//         if (j<char_type_num) node[j].ch_num++;         else {             if ('A'<=str[i] && str[i] <= 'Z') node[j].ch=str[i]+32;             else node[j].ch=str[i];             node[j].ch_num++;             char_type_num++;         }     }     for (i=0;i<char_type_num;i++) {         for (j=i;j<char_type_num;j++) {             if (node[j].ch_num<node[j+1].ch_num) {                 int temp;                 char ch_temp;                 temp=node[j].ch_num;                 ch_temp=node[j].ch;                 node[j].ch_num=node[j+1].ch_num;                 node[j].ch=node[j+1].ch;                 node[j+1].ch_num=temp;                 node[j+1].ch=ch_temp;             }         }     }     for (i=0;i<char_type_num;i++)         cout<<\"字符\"<<node[i].ch<<\"出现了\"<<node[i].ch_num<<\"次\"<<endl;     huffTree *huff=new huffTree[2*char_type_num-1];     huffTree temp;     string *code=new string[2*char_type_num-1];      for (i=0;i<2*char_type_num-1;i++) {         huff[i].lchild=-1;         huff[i].parent=-1;         huff[i].rchild=-1;         huff[i].flag=-1;     }     for (j=0;j<char_type_num;j++) huff[j].weight=node[j].ch_num;     int min1,min2;     for (int k=char_type_num;k<2*char_type_num-1;k++) {         coding(length,huff,k,min1,min2);         huff[min1].parent=k;         huff[min2].parent=k;         huff[min1].flag=\"0\";         huff[min2].flag=\"1\";         huff[k].lchild=min1;         huff[k].rchild=min2;         huff[k].weight=huff[min1].weight+huff[min2].weight;     }     for (i=0;i<char_type_num;i++) {         temp=huff[i];         while (1) {             code[i]=temp.flag+code[i];             temp=huff[temp.parent];             if (temp.parent==-1) break;//         }     }     cout<<\"字符串的每个字符huffman编码为：\"<<endl;     for (i=0;i<char_type_num;i++) cout<<node[i].ch<<\"  \"<<code[i]<<endl;     cout<<\"整个字符串的huffman编码为：\"<<endl;     for (i=0;i<length;i++) {                                                                                     //S?         for (j=0;j<char_type_num;j++) {             if (str[i]==node[j].ch)                 cout<<code[j];         }     }     delete[] node;     node=NULL;     delete[] huff;     huff=NULL;     delete[] code;     code=NULL; } int main() {     int length=0;     string str;     cout<<\"请输入一个字符串：\";     cin>>str;     frequency(str);     return 0; } //请输入一个字符串：2333abcde //字符3出现了3次 //字符2出现了1次 //字符a出现了1次 //字符b出现了1次 //字符c出现了1次 //字符d出现了1次 //字符e出现了1次 //字符串的每个字符huffman编码为： //3  11 //2  000 //a  001 //b  010 //c  011 //d  100 //e  101 //整个字符串的huffman编码为： //000111111001010011100101", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1"}]}
{"question": "程序设计题目：排班系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "每周只上一天班？这保安也太舒服～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "lz排出的是轮休表，不是值日表。。。", "referer": "user-1"}]}
{"question": "求问只能正常运行调用的第一个函数的原因", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在每个最后不带\\n的printf后面加fflush(stdout);在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin);另外请检查scanf的返回值。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "do {       printf(\"Enter 1 to calculate factorial\\n\");       printf(\"Enter 2 to calculate fibonacci\\n\");       printf(\"Enter 3 to exit\\n\");       printf(\"Enter your choice: \");       scanf(\"%d\", &choice);        switch (choice) {           case 1: {               int n, i;               printf(\"Enter a number: \");               scanf(\"%d\", &n);               srand(time(NULL));               factorial(n);               break;           }            case 2: {               int n;               printf(\"Enter the number of elements: \");               scanf(\"%d\", &n);               srand(time(NULL));               fibonacci(n);               break;           }            case 3: {               printf(\"Goodbye!\\n\");               break;           }            default: {               printf(\"Invalid choice! Please try again.\\n\");               break;           }       }        printf(\"Do you want to continue? (yes/no): \");       scanf(\"%s\", answer);   } while (strcmp(answer, \"yes\") != 0);", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢您的回复，但内容与问题无关", "referer": "user-2"}]}
{"question": "我有点懵了，这么做会被卡住吗？线程玩的熟的帮忙看看。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在析构函数中，线程pool在等待所有子线程退出时一直持有taskQueMtx_的锁，这会导致在子线程尝试获取任务时无法获取到锁，从而导致互锁的情况。为了避免这种情况，可以使用线程安全的等待所有子线程退出的方式，例如使用std:🧵:join_all()函数等待所有子线程退出。这样可以避免在等待过程中一直持有锁的情况，从而避免互锁问题。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢回复 我理解也是会卡住 关键这段代码一直在生产环境使用 从没有卡过。。。", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "谢谢回复 我理解也是会卡住 关键这段代码一直在生产环境使用 从没有卡过。。。", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "常在c用多线程处理数据，没在c++用过，但原理应该差不多。看你的程序只有一个锁，在一个线程上锁后其他线程无法使用这个锁，所以应该不会有冲突。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢回答 冲突到没发生 析构的线程和任务的线程肯定不同 但是析构的阻塞掉了 我感觉任务线程有可能卡在④上啊，这块是不是应该会有风险，即使是运气最差的情况下", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "4这个位置不会卡，它会等1这个位置的锁解锁后才可以对锁进行操作，即使它们属于不同线程也会等待。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "但是有可能出现互锁呢 1等4 4等1", "referer": "user-2"}]}
{"question": "力扣：11. 盛最多水的容器", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "要让p2指向传入数组的最后一个元素，可以将p2的初始值设置为height + heightSize - 1，即&height[heightSize - 1]。这样，在循环中每次移动指针时，p2就会指向数组的最后一个元素。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "数量这玩意只能传进来，不传进来谁知道有几个", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "第二参数难道不是做这个的么？", "referer": "user-3"}, {"cid": "5", "user": "user-0", "content": "int *p2 = &height[heightSize-1];我之前这样写打错了，", "referer": "user-3"}]}
{"question": "vsc怎样配置调用外部函数的那个参数", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "在当前项目中有实现GetAngle的.c/.cpp源代码或附加连接库里有GetAngle的实现。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "我在同一目录下命名了两个文件：Test1.c和Test2.c，这是1里面的，我也在2里面定义了GetAngle函数", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "还请大佬说的详细点", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "同一目录下不一定有用，得在makefile（使用nmake生成）或当前项目中添加现有项选Test2.c（使用VS20xx生成）", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "大佬，求解", "referer": "user-0"}]}
{"question": "为什么函数里第二行int nums[len];会报错", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "数组的大小使用变量len来指定，而len的值是在运行时计算得到的，编译器无法确定数组大小，所以会报错。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int *nums=new int[len]; delete [] nums;//nums用完后", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "len是变量", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "哦哦，我知道了，不能在运行时才知道数组的大小，我以为java", "referer": "user-4"}, {"cid": "7", "user": "user-5", "content": "你的编译器应该已经告诉你了，它不支持动态大小的数组。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "啊？len不是定义的吗", "referer": "user-5"}, {"cid": "9", "user": "user-0", "content": "我在vsc调式的时候到这里要点好多次下一步，也可以正常出结果", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "抱歉，我知道了，不能在运行时才知道数组的大小，我以为java", "referer": "user-5"}]}
{"question": "程序语言设计基础的课程设计【大哭】，C语言小白表示太难了，题目是会员卡计费系统，想问问有没有C语言大佬帮我解答一下疑问，我的消费总额和充值总额算不出来【大哭】，代码如有雷同他人的，我就是借鉴的那个。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "加油，继续努力！！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你add（）函数里打开文件进行追加时（fp=fopen（“emploee_list”，“a”）；），文件名有拼写错误。它应该是“employee_list”，", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "大哥教教我我新手.网课大学生现在啥也不会求带", "referer": "user-2"}, {"cid": "5", "user": "user-0", "content": "您可以帮我解答一下消费总额和充值总额为什么算不出来吗？【大哭】", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "建议使用charGPT", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "希望有大佬能为我解答，急！", "referer": "user-0"}]}
{"question": "c语言学生成绩系统课程设计", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我也小白，首先我感觉int n 完全没必要传参，sort函数里t没有初始化", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "174   应该定义一个指针，把满足条件的保存         char *p = (char*)malloc( N * sizeof(char));        好吧我也不知道这能不能行", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "感谢我去试试", "referer": "user-1"}]}
{"question": "硬件CRC校验和软件CRC校验的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考zlib\\crc32.c: /* crc32.c -- compute the CRC-32 of a data stream  * Copyright (C) 1995-2006, 2010 Mark Adler  * For conditions of distribution and use, see copyright notice in zlib.h  *  * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster  * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing  * tables for updating the shift register in one step with three exclusive-ors  * instead of four steps with four exclusive-ors.  This results in about a  * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.  */  /* @(#) $Id$ */  /*   Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore   protection on the static variables used to control the first-use generation   of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should   first call get_crc_table() to initialize the tables before allowing more than   one thread to use crc32().  */  #ifdef MAKECRCH #  include <stdio.h> #  ifndef DYNAMIC_CRC_TABLE #    define DYNAMIC_CRC_TABLE #  endif /* !DYNAMIC_CRC_TABLE */ #endif /* MAKECRCH */  #include \"zutil.h\"      /* for STDC and FAR definitions */  #define local static  /* Find a four-byte integer type for crc32_little() and crc32_big(). */ #ifndef NOBYFOUR #  ifdef STDC           /* need ANSI C limits.h to determine sizes */ #    include <limits.h> #    define BYFOUR #    if (UINT_MAX == 0xffffffffUL)        typedef unsigned int u4; #    else #      if (ULONG_MAX == 0xffffffffUL)          typedef unsigned long u4; #      else #        if (USHRT_MAX == 0xffffffffUL)            typedef unsigned short u4; #        else #          undef BYFOUR     /* can't find a four-byte integer type! */ #        endif #      endif #    endif #  endif /* STDC */ #endif /* !NOBYFOUR */  /* Definitions for doing the crc four data bytes at a time. */ #ifdef BYFOUR #  define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \\                 (((w)&0xff00)<<8)+(((w)&0xff)<<24))    local unsigned long crc32_little OF((unsigned long,                         const unsigned char FAR *, unsigned));    local unsigned long crc32_big OF((unsigned long,                         const unsigned char FAR *, unsigned)); #  define TBLS 8 #else #  define TBLS 1 #endif /* BYFOUR */  /* Local functions for crc concatenation */ local unsigned long gf2_matrix_times OF((unsigned long *mat,                                          unsigned long vec)); local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2);   #ifdef DYNAMIC_CRC_TABLE  local volatile int crc_table_empty = 1; local unsigned long FAR crc_table[TBLS][256]; local void make_crc_table OF((void)); #ifdef MAKECRCH    local void write_table OF((FILE *, const unsigned long FAR *)); #endif /* MAKECRCH */ /*   Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:   x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.    Polynomials over GF(2) are represented in binary, one bit per coefficient,   with the lowest powers in the most significant bit.  Then adding polynomials   is just exclusive-or, and multiplying a polynomial by x is a right shift by   one.  If we call the above polynomial p, and represent a byte as the   polynomial q, also with the lowest power in the most significant bit (so the   byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,   where a mod b means the remainder after dividing a by b.    This calculation is done using the shift-register method of multiplying and   taking the remainder.  The register is initialized to zero, and for each   incoming bit, x^32 is added mod p to the register if the bit is a one (where   x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by   x (which is shifting right by one and adding x^32 mod p if the bit shifted   out is a one).  We start with the highest power (least significant bit) of   q and repeat for all eight bits of q.    The first table is simply the CRC of all possible eight bit values.  This is   all the information needed to generate CRCs on data a byte at a time for all   combinations of CRC register values and incoming bytes.  The remaining tables   allow for word-at-a-time CRC calculation for both big-endian and little-   endian machines, where a word is four bytes. */ local void make_crc_table() {     unsigned long c;     int n, k;     unsigned long poly;                 /* polynomial exclusive-or pattern */     /* terms of polynomial defining this crc (except x^32): */     static volatile int first = 1;      /* flag to limit concurrent making */     static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};      /* See if another task is already doing this (not thread-safe, but better        than nothing -- significantly reduces duration of vulnerability in        case the advice about DYNAMIC_CRC_TABLE is ignored) */     if (first) {         first = 0;          /* make exclusive-or pattern from polynomial (0xedb88320UL) */         poly = 0UL;         for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)             poly |= 1UL << (31 - p[n]);          /* generate a crc for every 8-bit value */         for (n = 0; n < 256; n++) {             c = (unsigned long)n;             for (k = 0; k < 8; k++)                 c = c & 1 ? poly ^ (c >> 1) : c >> 1;             crc_table[0][n] = c;         }  #ifdef BYFOUR         /* generate crc for each value followed by one, two, and three zeros,            and then the byte reversal of those as well as the first table */         for (n = 0; n < 256; n++) {             c = crc_table[0][n];             crc_table[4][n] = REV(c);             for (k = 1; k < 4; k++) {                 c = crc_table[0][c & 0xff] ^ (c >> 8);                 crc_table[k][n] = c;                 crc_table[k + 4][n] = REV(c);             }         } #endif /* BYFOUR */          crc_table_empty = 0;     }     else {      /* not first */         /* wait for the other guy to finish (not efficient, but rare) */         while (crc_table_empty)             ;     }  #ifdef MAKECRCH     /* write out CRC tables to crc32.h */     {         FILE *out;          out = fopen(\"crc32.h\", \"w\");         if (out == NULL) return;         fprintf(out, \"/* crc32.h -- tables for rapid CRC calculation\\n\");         fprintf(out, \" * Generated automatically by crc32.c\\n */\\n\\n\");         fprintf(out, \"local const unsigned long FAR \");         fprintf(out, \"crc_table[TBLS][256] =\\n{\\n  {\\n\");         write_table(out, crc_table[0]); #  ifdef BYFOUR         fprintf(out, \"#ifdef BYFOUR\\n\");         for (k = 1; k < 8; k++) {             fprintf(out, \"  },\\n  {\\n\");             write_table(out, crc_table[k]);         }         fprintf(out, \"#endif\\n\"); #  endif /* BYFOUR */         fprintf(out, \"  }\\n};\\n\");         fclose(out);     } #endif /* MAKECRCH */ }  #ifdef MAKECRCH local void write_table(out, table)     FILE *out;     const unsigned long FAR *table; {     int n;      for (n = 0; n < 256; n++)         fprintf(out, \"%s0x%08lxUL%s\", n % 5 ? \"\" : \"    \", table[n],                 n == 255 ? \"\\n\" : (n % 5 == 4 ? \",\\n\" : \", \")); } #endif /* MAKECRCH */  #else /* !DYNAMIC_CRC_TABLE */ /* ========================================================================  * Tables of CRC-32s of all single-byte values, made by make_crc_table().  */ #include \"crc32.h\" #endif /* DYNAMIC_CRC_TABLE */  /* =========================================================================  * This function can be used by asm versions of crc32()  */ const unsigned long FAR * ZEXPORT get_crc_table() { #ifdef DYNAMIC_CRC_TABLE     if (crc_table_empty)         make_crc_table(); #endif /* DYNAMIC_CRC_TABLE */     return (const unsigned long FAR *)crc_table; }  /* ========================================================================= */ #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1  /* ========================================================================= */ unsigned long ZEXPORT crc32(crc, buf, len)     unsigned long crc;     const unsigned char FAR *buf;     uInt len; {     if (buf == Z_NULL) return 0UL;  #ifdef DYNAMIC_CRC_TABLE     if (crc_table_empty)         make_crc_table(); #endif /* DYNAMIC_CRC_TABLE */  #ifdef BYFOUR     if (sizeof(void *) == sizeof(ptrdiff_t)) {         u4 endian;          endian = 1;         if (*((unsigned char *)(&endian)))             return crc32_little(crc, buf, len);         else             return crc32_big(crc, buf, len);     } #endif /* BYFOUR */     crc = crc ^ 0xffffffffUL;     while (len >= 8) {         DO8;         len -= 8;     }     if (len) do {         DO1;     } while (--len);     return crc ^ 0xffffffffUL; }  #ifdef BYFOUR  /* ========================================================================= */ #define DOLIT4 c ^= *buf4++; \\         c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \\             crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4  /* ========================================================================= */ local unsigned long crc32_little(crc, buf, len)     unsigned long crc;     const unsigned char FAR *buf;     unsigned len; {     register u4 c;     register const u4 FAR *buf4;      c = (u4)crc;     c = ~c;     while (len && ((ptrdiff_t)buf & 3)) {         c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);         len--;     }      buf4 = (const u4 FAR *)(const void FAR *)buf;     while (len >= 32) {         DOLIT32;         len -= 32;     }     while (len >= 4) {         DOLIT4;         len -= 4;     }     buf = (const unsigned char FAR *)buf4;      if (len) do {         c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);     } while (--len);     c = ~c;     return (unsigned long)c; }  /* ========================================================================= */ #define DOBIG4 c ^= *++buf4; \\         c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \\             crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4  /* ========================================================================= */ local unsigned long crc32_big(crc, buf, len)     unsigned long crc;     const unsigned char FAR *buf;     unsigned len; {     register u4 c;     register const u4 FAR *buf4;      c = REV((u4)crc);     c = ~c;     while (len && ((ptrdiff_t)buf & 3)) {         c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);         len--;     }      buf4 = (const u4 FAR *)(const void FAR *)buf;     buf4--;     while (len >= 32) {         DOBIG32;         len -= 32;     }     while (len >= 4) {         DOBIG4;         len -= 4;     }     buf4++;     buf = (const unsigned char FAR *)buf4;      if (len) do {         c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);     } while (--len);     c = ~c;     return (unsigned long)(REV(c)); }  #endif /* BYFOUR */  #define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */  /* ========================================================================= */ local unsigned long gf2_matrix_times(mat, vec)     unsigned long *mat;     unsigned long vec; {     unsigned long sum;      sum = 0;     while (vec) {         if (vec & 1)             sum ^= *mat;         vec >>= 1;         mat++;     }     return sum; }  /* ========================================================================= */ local void gf2_matrix_square(square, mat)     unsigned long *square;     unsigned long *mat; {     int n;      for (n = 0; n < GF2_DIM; n++)         square[n] = gf2_matrix_times(mat, mat[n]); }  /* ========================================================================= */ local uLong crc32_combine_(crc1, crc2, len2)     uLong crc1;     uLong crc2;     z_off64_t len2; {     int n;     unsigned long row;     unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */     unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */      /* degenerate case (also disallow negative lengths) */     if (len2 <= 0)         return crc1;      /* put operator for one zero bit in odd */     odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */     row = 1;     for (n = 1; n < GF2_DIM; n++) {         odd[n] = row;         row <<= 1;     }      /* put operator for two zero bits in even */     gf2_matrix_square(even, odd);      /* put operator for four zero bits in odd */     gf2_matrix_square(odd, even);      /* apply len2 zeros to crc1 (first square will put the operator for one        zero byte, eight zero bits, in even) */     do {         /* apply zeros operator for this bit of len2 */         gf2_matrix_square(even, odd);         if (len2 & 1)             crc1 = gf2_matrix_times(even, crc1);         len2 >>= 1;          /* if no more bits set, then done */         if (len2 == 0)             break;          /* another iteration of the loop with odd and even swapped */         gf2_matrix_square(odd, even);         if (len2 & 1)             crc1 = gf2_matrix_times(odd, crc1);         len2 >>= 1;          /* if no more bits set, then done */     } while (len2 != 0);      /* return combined crc */     crc1 ^= crc2;     return crc1; }  /* ========================================================================= */ uLong ZEXPORT crc32_combine(crc1, crc2, len2)     uLong crc1;     uLong crc2;     z_off_t len2; {     return crc32_combine_(crc1, crc2, len2); }  uLong ZEXPORT crc32_combine64(crc1, crc2, len2)     uLong crc1;     uLong crc2;     z_off64_t len2; {     return crc32_combine_(crc1, crc2, len2); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢赵4老师！辛苦你了。咱们论坛能不能选择最佳答案呀？", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "赵4老师，我用devc++软件，C工程，提示找不到zutil.h", "referer": "user-1"}, {"cid": "4", "user": "user-0", "content": "赵4老师，这是不是linux的代码呀？太难懂了", "referer": "user-1"}, {"cid": "5", "user": "user-1", "content": "你需要看HAL_CRC_Calculate的实现", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "我看了，这个看不出来的，是硬件CRC，设置好在之后，自动出数。", "referer": "user-1"}, {"cid": "7", "user": "user-2", "content": "你的意思是需要一个工具计算出aDataBuffer 对应的crc值吗可以用http://www.ip33.com/crc.html .", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "谢谢！你理解错了，我想知道计算的过程。比如单片机使用硬件CRC，上位机使用软件CRC，怎么得出和硬件CRC一样的结果。", "referer": "user-2"}]}
{"question": "求教，想了很久没明白什么道理", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你自己能看见出错信息都需要想很久，那么其他人看不见你的出错信息会需要想更久，成本太高了。", "referer": "user-0"}]}
{"question": "void *形参，传参时候的用法", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "实参传给形参时类型需要匹配，有几种情况是特例：1.实参类型可以自动转换为形参类型，例如char->int，float-double.2.形参的权限比实参的权限小，如char*->const char*.100字面量是int，传参时不会自动转换为指针类型，所以需要强制转换", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "调用函数时使用的实参表达式的值的类型必须与形参类型一致，或者能够自动转换为形参类型，或者强制转换为形参类型。", "referer": "user-0"}]}
{"question": "流水灯怎么中断循环执行下个语句", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "在最后main函数里的死循环里，建议改成四个判断，不要再嵌入while while(1)     {         keynum=key();         if(keynum == 1){           led1(); } else if(keynum == 2 ){    led2(); }     }   类似这样", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你点灯的函数中也嵌入了一个死循环while(1)", "referer": "user-2"}]}
{"question": "进程recv卡住，怎么办？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "\"recv卡住\": 你的socket fd是设置成非阻塞了吗？如果是非阻塞的，recv的返回值有正确处理吗？（比如特殊判断EAGAIN）还有看你描述用的是UDP，UDP本身就是不可靠的，假如某个UDP包丢了，那么对方就收不到了，项目里有针对UDP做可靠性的开发吗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我这不是“某个UDP包丢了”，\"recv卡住\"是recv长时间卡住", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "你没把socket fd设置成非阻塞吧？", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "fd默认是阻塞的，如果调用recv，但此时缓冲区没有内容就会卡住", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "对方不send了，或网络临时断开或拥塞了，同步recv当然也就卡住了。", "referer": "user-0"}]}
{"question": "getchar相关的，清除缓存不懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf一个不以\\n结尾的字符串，要想确保字符串真正显示出来，别缓存在标准输出缓冲区中，需要紧跟一句fflush(stdout);rewind(stdin);//这才是C清标准输入缓存的正确方式cin.clear();cin.sync();//这才是C++清标准输入缓存的正确方式", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "输入密码参考下面： #include <conio.h> #include <stdio.h> char pw[40]; int i,ch; FILE *f; void main() {     cprintf(\"\\r\\nPassword:\");     i=0;pw[i]=0;     while (1) {         ch=getch();         if (ch==13 || i>=39) break;         switch (ch) {         case 27:             cprintf(\"\\rPassword: %40s\",\" \");             cprintf(\"\\rPassword: \");             i=0;pw[i]=0;             break;         case 8:             if (i>0) {                 i--;                 pw[i]=0;                 cprintf(\"\\b \\b\");             }             break;         default:             pw[i]=ch;             i++;             pw[i]=0;             cprintf(\"*\");             break;         }     }     cprintf(\"\\r\\n\");     f=fopen(\"password.txt\",\"w\");     fprintf(f,\"%s\\n\",pw);     fclose(f); }", "referer": "user-0"}]}
{"question": "devc++源代码未编译", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "手工确认一下有没有生成exe文件。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "生成了", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "既然生成了那就执行它呗。", "referer": "user-0"}]}
{"question": "大佬们帮我看看代码，C++代码返回值3221226356，谢谢了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个返回值 3221226356 在 Windows 平台上通常是由于程序发生了访问非法内存的错误，也就是所谓的“段错误”（Segmentation Fault）。 经过查看代码，可能存在以下问题： 在函数 List_HeadInsert 中，你已经为头结点 L 分配了空间，却又在循环内部重新分配结点空间并且没有释放。这会导致内存泄漏和无法预料的错误。建议将头结点初始化放到 InitList 函数中。 在函数 display 中，当 L 为空链表时，循环内部会出现对 NULL 指针的访问，这也会导致非法访问内存的问题。可以添加判断语句来避免这种情况。 在输入数据时，没有判断是否已经读入完毕，如果输入完最后一个结点后没有及时退出，会进入死循环，导致程序崩溃。  根据以上问题，下面给出修改后的代码： #include <iostream> #include <cstring>  using namespace std;  typedef int ElemType; typedef struct LNode {     ElemType sn;     ElemType sc;     string name;     struct LNode *next; } *LinkList, LNode;  void InitList(LinkList &L); LinkList List_HeadInsert(LinkList &L); void InsertLink(LinkList &L1, LinkList &L2); void display(LinkList L);  int main() {     LinkList L1;     InitList(L1);     List_HeadInsert(L1);     display(L1);     return 0; // 程序结束 }  void InitList(LinkList &L) {     L = (LNode *)malloc(sizeof(LNode));     L->next = NULL; }  LinkList List_HeadInsert(LinkList &L) {     ElemType tsn, tsc;     string tname;     LNode *s, *r = L;     while (cin >> tsn >> tname >> tsc) { // 添加输入判断条件，如果输入完毕就退出循环         s = (LinkList)malloc(sizeof(LNode));         s->name = tname;         s->sc = tsc;         s->sn = tsn;         r->next = s;         r = s;     }     r->next = NULL;     return L; }  void InsertLink(LinkList &L1, LinkList &L2) {     L2->next = L1->next;     L1->next = L2; }  void display(LinkList L) {     if (L == NULL || L->next == NULL) { // 当链表为空或只有头结点时退出函数         return;     }     for (LNode *p = L->next; p != NULL; p = p->next)         cout << p->sn << \" \" << p->name << \" \" << p->sc << endl;     cout << endl; }  希望这些修改能够帮助你解决问题。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序  http://bbs.csdn.net/topics/392201633", "referer": "user-0"}]}
{"question": "请帮我看看scanf_s输入结束后就没有下文了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该改为scanf_s(\"%s\"，&name，sizeof（name）)；第二个参数要加上&，第三个参数是长度。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "name前面加&", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "输入姓名那里：scanf_s(\"%s\", name); 修改为：scanf_s(\"%s\", name, 40);", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "scanf_s() 的参数不对吧，看看帮助，好像对字符和字符串类参数，要有可许空间大小参数的。", "referer": "user-0"}]}
{"question": "二叉树建立，遍历，叶子节点数，层数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*T)->data = data;         //生成根结点         CreateBiTree(&(*T)->lchild);//构造左子树         CreateBiTree(&(*T)->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf(\"%c \",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf(\"%c \",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(&T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}]}
{"question": "稀疏矩阵；找不到这个矩阵相加哪里错了，怎么改啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在稀疏矩阵相加的函数 add() 中，判断 A 和 B 矩阵当前位置非零元素相加后是否为 0 的语句有误。应该是： if (sum != 0) {    D.data[D.terms].i = A.data[apos].i;    D.data[D.terms].j = A.data[apos].j;    D.data[D.terms++].v = sum; }  即如果相加后不为 0，才将结果添加到 D 矩阵中。 完整的修改代码如下： #include<stdio.h> #include<stdlib.h>   #define SMAX 100 //三元组非零元素的最大个数  struct SPNode //三元组非零元素的行、列和值 {     int i,j,v; };  typedef struct sparmatrix //定义稀疏矩阵(三元组顺序表类型) {     int rows,cols,terms;//稀疏矩阵的行、列和非零元素的个数      struct SPNode data[SMAX]; //三元组表  } sparmatrix;   sparmatrix CreateSparmatrix()//创建稀疏矩阵 {     sparmatrix A;     printf(\"请输入列表的行数 列数 非零元的个数 \\n\");     scanf(\"%d%d%d\", &A.rows, &A.cols, &A.terms);     for (int n = 1; n <= A.terms; n++)     {         printf(\"请依次输入元素行数 列数 值\\n\");         scanf(\"%d%d%d\", &A.data[n].i, &A.data[n].j, &A.data[n].v);     }     return A; }   sparmatrix Trans(sparmatrix  A)//转置稀疏矩阵  {     sparmatrix C;     C.rows = A.cols;     C.cols = A.rows;     C.terms = A.terms;     for (int n = 1; n <= A.terms; n++)     {         C.data[n].i = A.data[n].j;         C.data[n].j = A.data[n].i;         C.data[n].v = A.data[n].v;     }     return C; }  void ShowSparmatrixA(sparmatrix A)  //显示稀疏矩阵A   {          printf(\"矩阵A的元素为：\\n\");     int k,x,y,n;     for(x = 1; x <= A.rows; x++)     {         for(y = 1; y <= A.cols; y++)         {             k = 0;             for(n = 1; n <= A.terms; n++)             {                 if ((A.data[n].i == x) && (A.data[n].j == y))                 {                     printf(\"%5d\", A.data[n].v);                     k = 1;                     break;                 }             }             if (k == 0)              {                 printf(\"%5d\", 0);             }         }         printf(\"\\n\");     } }  void ShowSparmatrixB(sparmatrix B)  //显示稀疏矩阵B   {          printf(\"矩阵B的元素为：\\n\");     int k,x,y,n;     for(x = 1; x <= B.rows; x++)     {         for(y = 1; y <= B.cols; y++)         {                k = 0;             for(n = 1; n <= B.terms; n++)             {                 if ((B.data[n].i == x) && (B.data[n].j == y))                 {                     printf(\"%5d\", B.data[n].v);                     k = 1;                     break;                 }             }             if (k == 0)              {                 printf(\"%5d\", 0);             }         }         printf(\"\\n\");     } }  sparmatrix add(sparmatrix A, sparmatrix B) {        sparmatrix D;      // 初始化结果矩阵 D 的行、列和非零元素个数     D.rows = A.rows;     D.cols = A.cols;     D.terms = 0;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数组下标这玩意，您有时是从0开始用的，有时是从1开始用的，不乱才怪。", "referer": "user-0"}]}
{"question": "make时出现错误，怎么解决呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "没声明出错了那就声明一下呗。", "referer": "user-0"}]}
{"question": "以单词为单位倒序输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数组要初始化为空。", "referer": "user-0"}]}
{"question": "求助一下这个报错该怎么解决", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "明显不就是提示花括号不匹配吗？花括号一对一对的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "一看这个报错就是说少了}", "referer": "user-0"}]}
{"question": "求 矩阵LUP分解 为什么直接赋值，得到结果正确，语句计算赋值，得到结果错误，请帮看下为什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "tmp_matrix_d[ik] = sum;你这里的 sum是float，计算结果已经损失精度了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "REAL  原始是double，我这里也更改成double过，一样是不正确的结果，很诧异的是这个东西就是损失精度，得到结果是颠覆的。", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "换个编译器试试，或者关闭优化选项试试", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "应该是如 user-2所说，基本是tmp_matrix_d 计算得到输出和tmp_a有细小的差别， 矩阵求逆 就出现颠覆性的值", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "tmp_matrix_d 是怎么计算来的吧，这意味着由于浮点的表示限制，和 tmp_a 还是有误差的。将提及的那个贴里的 matrix.c 中 solve_matrix_equation_by_lup_decomposition() 每一步都对涉及到刚才变化了的 matrix 进行输出，对比了两个的结果，发现，好像是有细微的误差慢慢累积起来的，很是奇怪，怎么最后会有如此的大不同。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "就这个问题，你也没找到为什么是吧，直接赋值就OK，计算得到就出现很大的偏差", "referer": "user-2"}, {"cid": "7", "user": "user-2", "content": "好像就是这样的，在“数字帝国”站上，用它的矩阵求逆功能，从你的数据里取了前 4x4 如： 15.27 15.48 13.79 10.44 15.48 17.42 17.09 14.54 13.79 17.09 18.17 16.83 10.44 14.54 16.83 16.95 求逆的结果： 12.063130\t-29.127886\t24.652281\t-6.921387 -29.127886\t78.401900\t-74.196654\t24.357593 24.652281\t-74.196654\t77.738316\t-28.724857 -6.921387\t24.357593\t-28.724857\t11.949217 将最右下的数据由 16.95 改为 16.96，再算，结果是： 11.635207\t-27.62195\t22.876335\t-6.182613 -27.62195\t73.102244\t-67.946782\t21.757716 22.876335\t-67.946782\t70.367855\t-25.658828 -6.182613\t21.757716\t-25.658828\t10.673783 两次的结果差异甚大；所以，细微的误差，可能会引发巨震。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "看来就是数据的细小差异导致的，", "referer": "user-2"}]}
{"question": "我在写计时器用system(\"cls\")清屏但是它跳过了", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "#define _CRT_SECURE_NO_WARNIGS #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<math.h> #include<string.h> #include<time.h> #include<Windows.h> int main() {     for (int  i = 0; i < 24; i++)     {         for (int j = 0; j < 60; j++)         {             for (int k = 0; k < 60; k++)             {                 cprintf(\"\\r%02d:%02d:%02d\", i, j, k);                 Sleep (950);                          }         }     }     return  EXIT_SUCCESS; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "win7 x64 + vc2008 好像是执行了的；其实，无须这个调用，输出的把 \\n 改为 \\r 试试。", "referer": "user-0"}]}
{"question": "请问高手指针做参数的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "指针作参数要传递什么取决于参数本身存在的意义，即 “这个参数是什么？以及它要用来干什么？”函数调用时，系统为函数分配栈区内存，函数的返回值、参数、局部变量、临时变量等都会在函数的栈内存中占据一席之地。普通变量传参的时候，是把实参的数据拷贝了一份到函数参数的所在栈内存中。指针变量传参的时候，也是把一个地址作为数据拷贝到了函数参数所在的栈内存中，不同之处在于，指针支持( * 解引用 )、( -> 结构体/联合体的成员访问)、( [ ] 数组下标访问 )等操作，可以通过传入的目标内存地址去访问以及读写目标内存的数据。当然上述这些操作的前提是传入的地址是有效的，即地址指向的确实是一个已存在的内存实例，或者说内存里确实已经有了这么个东西。传入的内容可以是一个局部变量的地址，也可以是一个已经malloc分配过得堆内存地址。 SPI_HandleTypeDef hspi; memset(&hspi, 0, sizeof(SPI_HandleTypeDef)); uint6_t buf[1024] = { 0 }; HAL_StatusTypeDef status = HAL_SPI_Receive(&hspi, buf, sizeof(buf), 100); //----------------------------------------------------- SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)malloc(sizeof(SPI_HandleTypeDef)); memset(&hspi, 0, sizeof(SPI_HandleTypeDef)); uint8_t *buf = (uint8_t *)malloc(sizeof(uint8_t) * 1024); memset(buf, 0, sizeof(uint8_t) * 1024); HAL_StatusTypeDef status = HAL_SPI_Receive(hspi, buf, sizeof(uint8_t) * 1024, 100); // ... free(hspi); free(buf);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢！", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "SPI_HandleTypeDef *hspi; uint8_t buf[1024];  HAL_StatusTypeDef rtn=HAL_SPI_Receive(hspi, buf,1024, 100);", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢赵4老师", "referer": "user-2"}, {"cid": "5", "user": "user-0", "content": "谢谢！我试试。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "习惯上定义一个够大的数组作为接收缓冲区即可，把数组名当作实参传给它即可。", "referer": "user-0"}]}
{"question": "C 语言问题   输入n行ASCII字符，计算每一行字符的个数（不包括换行符），并找出最大的字符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "以下是一个用C语言实现的程序，可以计算输入的n行ASCII字符中每一行字符的个数，并找出最大的字符。 #include <stdio.h>      int main() {       int n, i, max_char, max_count = 0;       char c;          printf(\"请输入行数n: \");       scanf(\"%d\", &n);          printf(\"请输入%d行ASCII字符：\\n\", n);          // 初始化最大字符和行数计数器       max_char = 0;       max_count = 0;          // 逐行读取输入       for (i = 0; i < n; i++) {           scanf(\" %c\", &c);              // 如果这是第一个字符，则更新最大字符和行数计数器           if (i == 0) {               if (c > max_char) {                   max_char = c;                   max_count = 1;               }           } else {               // 否则，将这一行字符的个数和行数计数器加1               if (c > max_char) {                   max_char = c;                   max_count++;               }           }       }          // 找出最大字符并输出       if (max_count > max_char) {           printf(\"最大字符为：%c\\n\", max_char);       } else {           printf(\"最大字符为：%c\\n\", max_char);           printf(\"该行字符的个数为：%d\\n\", max_count);       }          return 0;   }  这个程序首先提示用户输入行数n，然后逐行读取输入的ASCII字符，并计算每一行字符的个数和行数计数器。当读取到第一个字符时，程序会更新最大字符和行数计数器。最后，程序会找出最大字符并输出该行字符的个数和行数计数器，如果两个计数器中有一个比最大字符还要大，则程序会输出最大字符和行数计数器，但不输出该行字符的个数。 请注意，这个程序假设输入的每一行字符都是合法的ASCII字符，即不包含空格、制表符或换行符。如果输入的字符不合法，程序可能会出现错误。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "写个循环n次的循环即可。", "referer": "user-0"}]}
{"question": "如何直接通过指针引用私有成员数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "cout<< p->get() << \"    \" << p->n << endl;", "referer": "user-0"}]}
{"question": "题目合并两个有序数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "没仔细看您的代码，初步判断是函数 fun 中 else 后面的 for 语句缺少了大括号。 下面给出我的合并方法： int merge(int array1[], const int length1, int array2[], const int length2) {     int ind1 = length1 - 1;     int ind2 = length2 - 1;     int indMerged = length1 + length2 - 1;     while (ind1 >= 0 && ind2 >= 0)     {         if (array1[ind1] > array2[ind2])         {             array2[indMerged] = array1[ind1];             --ind1;         }         else         {             array2[indMerged] = array2[ind2];             --ind2;         }         --indMerged;     }     while (ind1 >= 0)     {         array2[indMerged] = array1[ind1];         --indMerged;         --ind1;     }     return length1 + length2; }", "referer": "user-0"}]}
{"question": "c语言作业题，求好心人解惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "5i乘号不能省", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "还是不行呢", "referer": "user-2"}]}
{"question": "求助大佬们，c语言学习有什么系统好学的资料吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C Primer Plus 第六版", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "推荐先看《啊哈C》，因为我刚看过了。 入门级别的", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "已买，我也用用入门，谢谢🙏", "referer": "user-2"}]}
{"question": "关于一些结构体的问题", "poster": "user-0", "comments": [{"cid": "2", "user": "user-2", "content": "这个完全不关结构体的事，是基本输入输出不过关。字符变量存不下字符串；接受输入值的变量需要取地址。", "referer": "user-0"}]}
{"question": "linux进程卡死，无法通信", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "要说最可笑的理由，甚至有可能是写日志的文件系统满了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "根据提供的问题描述，可能的原因有如下几点： 1、网络通信问题：由于U进程无法以sendto方式给日志打印进程吐日志，而且H进程给U进程发sendto消息时也无法得到回复，这可能是由于网络通信发生了问题，导致H和U进程之间无法正常通信。 2、内存泄漏问题：U进程在一段时间后卡死，可能是因为U进程存在内存泄漏问题导致的。当内存泄漏严重时，会导致系统资源被大量占用，从而导致系统出现卡顿或崩溃。 3、死锁问题：由于U进程不再以sendto方式给日志打印进程吐日志，而且H进程重启了U进程，这可能导致了死锁问题。例如，U进程可能在等待某个锁的释放，而H进程又在等待U进程的响应，这样就会形成死锁。 为了排查问题，可以采取如下步骤： 1、检查网络连接是否正常，尝试使用其他工具测试网络连接性。 2、检查U进程的代码，是否存在内存泄漏问题。 3、使用调试工具如gdb分析U进程的状态，看是否处于死锁状态。 4、检查U进程的日志打印代码，看是否存在bug或异常情况。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成core或dmp文件、……这些方法都不行！ 写日志到文件参考下面： #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER     #pragma warning(disable:4996)     #include <windows.h>     #include <io.h> #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  _vsnprintf         vsnprintf #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]=\"MyLog1.log\"; char logfilename2[]=\"MyLog2.log\"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef _MSC_VER void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     _vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,\"%03d\",tb.millitm);     printf(\"%s %s.%s %s\",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,\"a\");     if (NULL!=flog) {         fprintf(flog,\"%s %s.%s %s\",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} int main(int argc,char * argv[]) {     int i; #ifdef _MSC_VER     InitializeCriticalSection(&cs_log); #else     pthread_mutex_init(&cs_log,NULL); #endif     for (i=0;i<10000;i++) {         Log(\"This is a Log %04d from FILE:%s LINE:%d\\n\",i, __FILE__, __LINE__);     } #ifdef _MSC_VER     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_log); #endif     return 0; } //1-79行添加到你带main的.c或.cpp的那个文件的最前面 //82-86行添加到你的main函数开头 //90-94行添加到你的main函数结束前 //在要写LOG的地方仿照第88行的写法写LOG到文件MyLog1.log中", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "H进程卡死的原因可能是U进程的资源被耗尽，导致无法回复H进程的消息，最终导致H进程等待超时而卡死。 要排查这个问题，可以先查看U进程的日志，看看是否有相关的错误或警告信息。还可以使用系统监控工具，如top、ps等，查看U进程的资源占用情况，例如CPU、内存、网络等。如果发现U进程的资源占用过高，可能需要对其进行优化或调整。另外，可以尝试使用调试工具，如gdb、strace等，来跟踪U进程的执行过程，找出可能的问题点。", "referer": "user-0"}]}
{"question": "小白求教!!!!各位大神，这个语句哪里有问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "去掉内存while死循环，直接写n+=ret;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "内层while是个死循环，在它范围内a的值一直不变。", "referer": "user-0"}]}
{"question": "求助！！！jupyter在导入包时用的import 、as、from都出现乱码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请问解决了吗？我也是这个问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我也是一样的情况 为什么啊", "referer": "user-0"}]}
{"question": "[求助]nt!KiApcInterrupt蓝屏原因", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个错误消息通常表明您的驱动程序在处理异常时出现了问题。KMODE_EXCEPTION_NOT_HANDLED是一个常见的错误消息，通常指向引起问题的驱动程序或函数。 在这种情况下，您应该记录异常的地址和包含该地址的驱动程序/库的链接日期。您还应该记录异常的参数，以便在未来的调试和分析中使用。 在这个错误消息中，有一些寄存器的值可能为零或不正确。rax、rbx、rcx、rdx、rsi、rdi、rip、rsp、r8、r9、r10、r11、r12、r13、r14、r15和iopl都是可能的值。请注意，这些值可能会被修改或不正确，因此在分析代码时请务必小心。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "ChatGPT?", "referer": "user-1"}]}
{"question": "vs code调试c语言为啥不行，这是咋回事啊，搞了3，4个小时了，求助大佬们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": ".c文件的的路径中不要带中文字符", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "VS Code本身并不支持C语言调试，因为它是一个基于JavaScript的编辑器，而不是一个完整的集成开发环境（IDE）。 如果您需要在C语言中进行调试，您需要使用一个集成开发环境（IDE），例如Visual Studio或Eclipse。这些IDE通常都有内置的调试器，可以帮助您在代码中设置断点，并在运行时跟踪变量和函数的值。 如果您使用的是Visual Studio Code，您可以安装一个名为“C/C++ Intellisense”的扩展程序，它可以帮助您在编辑器中显示C/C++代码的语法高亮和自动完成。但是，这并不能完全替代使用IDE进行调试", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "用run code运行是可以的，但就是调试不了，直接运行也不行", "referer": "user-0"}]}
{"question": "c语言统计代码行数，注释行数，空行数，文件总行数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这作业挺有意思，我折腾了几天，写好又重写，写好又重写......。勉强捣鼓出一个。还特地做了一份测试用的c文件，也贴在后面。当作业交的话应该能合格。 #include <stdio.h> #include <cstdlib> #include <fstream>  /** * 统计c源程序总行数、空行数、代码行数、注释行数。根据当前行 * 中是否包含//、/*和* /来判断是否是注释行，但要忽略注释和 * 字符串常量和字符常量中的这些符号。 * * （2023-4-21. Mr Yao） */  /* * 读取当前字符，且忽略所有非换行空白符。 */ inline int get_cur_char(FILE* fp, int* ch) {     while ((*ch = getc(fp)) && *ch != EOF && *ch != '\\n' && isspace(*ch));      if (*ch != EOF) return 1;     else return 0; }  /* * 读取当前字符，包括空白符。 */ inline int get_cur_char_space(FILE* fp, int* ch) {     *ch = getc(fp);     if (*ch != EOF) return 1;     else return 0; }  int main(int argc, char* argv[]) {     FILE* fp = 0;     char filename[100];      /**     * DEFAULT 默认状态。     * STRING 字符串常量状态。     * CHAR 字符常量状态。     * BLOCKCOMMENT 块注释状态。     * LINECOMMENT 行注释状态。     */     enum State { DEFAULT = 0, STRING, CHAR, BLOCKCOMMENT, LINECOMMENT };      State cur_state = DEFAULT;    //当前状态。     /**     * total_lines--总行数，comment_lines--注释行数，blank_lines--空行数，code_lines--代码行数     */     int total_lines = 0, comment_lines = 0, blank_lines = 0, code_lines = 0;     /**     * is_comment_line--标记当前行是否是含有注释，is_code_line--标记当前行是否含有代码，     * is_blank_line--标记当前行是空行     */     int is_comment_line = 0, is_blank_line = 0, is_code_line = 0;      int cur_char = DEFAULT;    //当前待分析字符。      if(argc > 1)         fopen_s(&fp, argv[1], \"r\");      while (fp == 0) {         printf(\"Failed to open file.\\n\");         printf(\"Please input file name:\");         scanf_s(\"%s\", filename, 100);         fopen_s(&fp, filename, \"r\");     }      while (get_cur_char(fp, &cur_char)) {         //开始新行。         is_comment_line = 0; is_code_line = 0; is_blank_line = 0;         if (cur_char == '\\n') is_blank_line = 1; //空行         else {             do {                 switch (cur_char)                 {                 case '\\n':        //换行则关闭行注释状态                     if (cur_state == LINECOMMENT)                         cur_state = DEFAULT;                     break;                 case '\\\\':        //忽略转义字符                     if (cur_state != BLOCKCOMMENT) {                         get_cur_char_space(fp, &cur_char);                         if (cur_char == '\\n') {                             if(cur_state != LINECOMMENT)is_code_line = 1;                             else is_comment_line = 1;                         }                     }                     break;                 case '/':        //在默认状态下，判断下一个字符                     if (cur_state == DEFAULT) {                         if (get_cur_char_space(fp, &cur_char) && cur_char == '*') {                             //找到块注释，标记该行为注释行，转换成块注释状态                             is_comment_line = 1;                             cur_state = BLOCKCOMMENT;                             break;                         }                         else if (cur_char == '/') {                             //找到行注释，标记该行是注释行，转换成行注释状态                             is_comment_line = 1;                             cur_state = LINECOMMENT;                             break;                         }                         is_code_line = 1;                     }                     break;                 case '*':    //在块注释状态下，找* /                     if (cur_state == BLOCKCOMMENT) {                         is_comment_line = 1;                         while (cur_char == '*') {                             get_cur_char_space(fp, &cur_char);                         }                         if (cur_char == '/') {                             //找到，转换成默认状态                             cur_state = DEFAULT;                         }                     }                     break;                 case '\"':    //默认状态下，转换成字符串状态，字符串状态下转换成默认状态                     if (cur_state == DEFAULT || cur_state == STRING) {                         cur_state = (State)((int)cur_state ^ (int)STRING);                         is_code_line = 1;                     }                     break;                 case '\\'':    //默认状态下，转换成字符状态，字符状态下转换成默认状态                     if (cur_state == DEFAULT || cur_state == CHAR) {                         cur_state = (State)((int)cur_state ^ (int)CHAR);                         is_code_line = 1;                     }                     break;                 default:                     if (cur_state == DEFAULT) is_code_line = 1;                     else if (cur_state == BLOCKCOMMENT || cur_state == LINECOMMENT)                         is_comment_line = 1;                     break;                 }             } while (cur_char != '\\n' && get_cur_char(fp, &cur_char));         }                  /*         * 当前行分析结束，累加数据。         */         ++total_lines;         comment_lines += is_comment_line;         blank_lines += is_blank_line;         code_lines += is_code_line;     }      printf(\"Total lines: %d\\n\", total_lines);     printf(\"Code lines: %d\\n\", code_lines);     printf(\"Comment lines: %d\\n\", comment_lines);     printf(\"Blank lines: %d\\n\", blank_lines);      fclose(fp);     return 0; }   测试文件：test.c /**  *  * 这是一份没有语法错误的c源程序，共有28行，代码11行，注释15行，空行6行  *  * （2023-4-21. Mr Yao） **/   #include <stdio.h>  int main(int, char**) { //这行有代码和注释     //\\ 本行只有注释， /* \" ' 下面2行只有代码。     char a[] = \"\\     // */ /* abcd\";          /*本行只有注释\\*/         //本行只有注释      char f[] = \"// \\\"\"; //本行既有代码也有注释         /**本行有代码和注释。// *\\*/char b = '\\\"';//本行有代码和注释\\     \\     /**上一行只有注释，本行也只有注释\\      * 本行只有注释*/int a = 1;       /*本行既有注释也有代码*/char c[] = \"\\     \\     \\\\\\\\\\\\\\\\\"\"//上一行只有代码，本行也只有代码\";     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "非常感谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>      int main() {       FILE *fp;       char filename[100];       int total_lines = 0, comment_lines = 0, blank_lines = 0;          printf(\"Enter the filename: \");       scanf(\"%s\", filename);          fp = fopen(filename, \"r\");          if (fp == NULL) {           printf(\"Failed to open file.\\n\");           return 1;       }          while (fgets(filename, sizeof(filename), fp)) {           if (filename[0] == '#') {               comment_lines++;           } else if (filename[0] == '\\n') {               blank_lines++;           } else {               total_lines++;           }       }          fclose(fp);          printf(\"Total lines: %d\\n\", total_lines);       printf(\"Comment lines: %d\\n\", comment_lines);       printf(\"Blank lines: %d\\n\", blank_lines);          return 0;   }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢啦", "referer": "user-2"}]}
{"question": "用递归正序逆序输出整数的各位数字", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if(n) { f1(n/10); cout<<n%10<<\"  \"; }  ... if(n){cout<<n%10<<\"  \"; f2(n/10);}", "referer": "user-0"}]}
{"question": "帮帮忙看看一下兄弟们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "百度搜“正则表达式 邮件地址”", "referer": "user-0"}]}
{"question": "cpu烧了，有没有大神帮我看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "小伙子有前途，不要写代码了，转行去网站当小编～", "referer": "user-0"}]}
{"question": "用C语言做简易公交车查询系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "以下是一个简单的C语言实现公交车查询系统的示例代码： #include <stdio.h>   #include <string.h>      #define MAX_LINES 100   #define MAX_LINE_LEN 3      typedef struct {       char line[MAX_LINE_LEN];   } Line;      int compare_lines(const void *a, const void *b) {       Line *l = (Line*) a;       Line *r = (Line*) b;       return l->line[0] - r->line[0];   }      int main() {       Line lines[MAX_LINES];       int num_lines = 0;          // 添加公交车路线记录       strcpy(lines[num_lines].line, \"N10\");       num_lines++;       strcpy(lines[num_lines].line, \"北京市\");       num_lines++;       strcpy(lines[num_lines].line, \"1号线\");       num_lines++;       strcpy(lines[num_lines].line, \"天安门\");       num_lines++;       strcpy(lines[num_lines].line, \"5号线\");       num_lines++;       strcpy(lines[num_lines].line, \"国家博物馆\");       num_lines++;          // 显示所有公交车信息       printf(\"\\n公交车信息如下：\\n\");       for (int i = 0; i < num_lines; i++) {           printf(\"%s\\n\", lines[i].line);       }          // 修改公交车路线信息       strcpy(lines[2].line, \"N10\");       num_lines--;       strcpy(lines[2].line, \"北京市\");          // 显示所有公交车信息       printf(\"\\n修改后的公交车信息如下：\\n\");       for (int i = 0; i < num_lines; i++) {           printf(\"%s\\n\", lines[i].line);       }          // 删除公交车路线记录       strcpy(lines[1].line, \"N10\");       num_lines--;       num\\n\");           return 1;       }          strcpy(fp->ptr, \"\\n公交车信息如下：\\n\");       for (int i = 0; i < num_lines; i++) {           strcpy(fp->ptr + strlen(fp->ptr), lines[i].line);       }          fclose(fp);          return 0;   }  这个示例代码实现了一个简单的公交车查询系统，包括添加、显示、修改、删除和保存公交车路线信息等功能。你可以根据自己的需求进行修改和扩展。", "referer": "user-0"}]}
{"question": "求大佬解惑，c语言作业题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "很遗憾，one function one x 。你的代码里只有一个变量x，你把它浪费了x=x/10之后，回过头去x<=y意义就不大了，x++就没意思了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "🔗ChatGPT、AI绘图在线体验🔗Admin、Vue、Vite、Node、Midway、uniapp、Iot、外包、小程序🔗Cool-Admin、快速开发、CRUD、权限管理系统", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "if (n==3)", "referer": "user-0"}]}
{"question": "求回答     C语言中输入%s 最后的输出结果出现乱码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf里面的%和变量的一一对应关系scanf里面的%和变量以及变量前加不加&的一一对应关系是C代码中非常容易出错的地方，而且通常编译还不出错。所以在编译源代码之前值得专门仔细检查一遍甚至多遍。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "那里应该是%c而不是%s", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "%c的话  就该设清除缓冲区", "referer": "user-2"}]}
{"question": "求助（数据结构）:为什么这个“取出函数运行不了，怎么改啊？”", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不保证对，仅供参考： #include<stdio.h> #define MAXLEN 100 typedef struct {     char vec[MAXLEN];     int len; } str;//定义结构体类型 str void ConcatStr(str *r1,str *r2)//连接串r1和r2放到串r1中 {     int i=0;     if(r1->len+r2->len>MAXLEN)         printf(\"两个串太长，无法连接!\");     else     {         for(i=0;i<r2->len;i++)             r1->vec[r1->len+i]=r2->vec[i];         r1->vec[r1->len+i]='\\0';         r1->len=r1->len+r2->len;     } } void SubStr(str *r,str **pr1,int i,int j)//从第i个位置 ，取j个位置 {     int k=0;     if(i+j-1>r->len)     {         printf(\"子串超界!\");         return ;     }     else     {         for(k=0;k<j;k++)             (*pr1)->vec[k]=r->vec[i+k-1];         (*pr1)->len=j;         (*pr1)->vec[(*pr1)->len]='\\0';     }     printf(\"取出字符为:\");     puts((*pr1)->vec); } void DelStr(str *r,int i,int j)//从字符串r的第i个位置开始删除j个字符 {     int k=0;     if(i<1||i>r->len||j<1||i+j-1>r->len)         printf(\"位置参数数据错误或所要删除的子串超界!\");     else     {         for(k=i+j-1;k<r->len;k++,i++)             r->vec[i-1]=r->vec[k];  //将后面的字符串前移覆盖         r->len=r->len-j;         r->vec[r->len]='\\0';     } } str *InsStr(str*r,str*r1,int i)//在i个位置插入串r1 {     int k;     if(i<0||i>r->len+1||r->len+r1->len>MAXLEN)         printf(\"不能插入!\");     else     {         for(k=r->len-1;k>=i-1;k--)             r->vec[r1->len+k]=r->vec[k];//后移，空出r1->len个位置         for(k=0;k<r1->len;k++)             r->vec[i-1+k]=r1->vec[k];         r->len=r->len+r1->len;         r->vec[r->len]='\\0';     }     return r; } int IndexStr(str *r,str *r1)//模式匹配 {     int i,j,k;     for(i=0;r->vec[i];i++)         for(j=i,k=0;r->vec[j]==r1->vec[k];j++,k++)             if(!r1->vec[k+1])                 return i;     return 0; } int LenStr(str *r)//求串长 {     int i=0;     while(r->vec[i]!='\\0')         i++;     return i; } str*CreateStr(str *r)//创建串 {     gets(r->vec);     r->len=LenStr(r);     return r; } int EqualStr(str *r1,str *r2)//串比较 {     int i;     for(i=0;r1->vec[i]==r2->vec[i]&&r1->vec[i]&&r2->vec[i];)         i++;     return(r1->vec[i]-r2->vec[i]); } int main() {     str a,b,c,d;     str *r=&a,*r1;     char choice;     int i,j,ch=1,k;     r->vec[0]='\\0';     printf(\"\\n\");     printf(\"     串子系统\\n\");     printf(\"        1--输入字串\\n\");     printf(\"        2--连接字串\\n\");     printf(\"        3--取出字串\\n\");     printf(\"        4--删除字串\\n\");     printf(\"        5--插入字串\\n\");     printf(\"        6--查找字串\\n\");     printf(\"        7--比较字串\\n\");     printf(\"        8--显示字串\\n\");     printf(\"        0--返回\\n\");     while(ch!=0)     {         printf(\"请选择菜单号(0-8):\");fflush(stdout);         rewind(stdin);scanf(\"%c\",&choice);         switch(choice)         {         case '1':             printf(\"\\n请输入一个字符串:\");fflush(stdout);             gets(r->vec);             r->len=LenStr(r);             break;         case '2':             {                 printf(\"\\n请输入要连接的串:\");fflush(stdout);                 r1=CreateStr(&b);  //给串r1赋初值                 ConcatStr(r,r1);                 printf(\"\\n连接以后的新串值为:\");                 puts(r->vec);                 break;             }         case '3':             printf(\"\\n请输入从第几个字符开始:\");fflush(stdout);             rewind(stdin);scanf(\"%d\",&i);             printf(\"\\n请输入取出的连接字符数:\");fflush(stdout);             rewind(stdin);scanf(\"%d\",&j);             SubStr(r,&r1,i,j);             break;         case '4':             printf(\"\\n请输入从第几个字符开始:  \");fflush(stdout);             rewind(stdin);scanf(\"%d\",&i);             printf(\"\\n请输入删除的连续字符数:\");fflush(stdout);             rewind(stdin);scanf(\"%d\",&j);             DelStr(r,i ,j);             break;         case '5':             {                 printf(\"\\n请输入在第几个字符前插入:\");fflush(stdout);                 rewind(stdin);scanf(\"%d\",&i);                 printf(\"\\n请输入所要插入的字符串:\");                 r1=CreateStr(&b);                 InsStr(r,r1,i);                 break;             }         case '6':             {                 printf(\"\\n请输入所要查找的字符串:\");fflush(stdout);                 r1=CreateStr(&b);                 i=IndexStr(r,r1);                 if(i!=-1)                     printf(\"\\n第一次出现的位置是第%d个\\n\",i);                 else                     printf(\"\\n该字串不在其中\\n\");                 break;             }         case '7':             {                 printf(\"\\n请输入第一个串:\");fflush(stdout);                 gets(c.vec);                 printf(\"\\n请输入第二个串:\");fflush(stdout);                 gets(d.vec);                 k=EqualStr(&c,&d);                 if(k>0)                     printf(\"\\n\\t\\t第一个串大!\");                 else                     if(k<0)                         printf(\"\\n\\t\\t第二个串大!\");                     else                         printf(\"\\n\\t\\t两个串一样大!\");                 break;             }         case '8':             {                 printf(\"\\n\\t\\t该串值为:\");                 if(r->vec[0]=='0')                     printf(\"空!\\n\");                 else                     puts(r->vec);                 break;             }         case '0':             ch=0;break;         default:             printf(\"输入菜单有误，请重新输入!\");break;         }     }     return 0; }", "referer": "user-0"}]}
{"question": "程序可以编译成功就是运行后显示Press any key to continue,一按回车就直接退出来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！scanf的格式字符串中不要包含空格和\\n", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "您说的应该是以前码农做的操作，我没有学过计算机操作系统和lunix只知道一些简单的dos命令，用cmd窗口运行代码就见过郝斌的视频操作过，C语言具体怎么做真不知道", "referer": "user-1"}]}
{"question": "关于vscode，C++问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "text.c这个名字暗示着里面是C语言代码，所以C++不好使。你可以查一下该环境下应该使用的扩展名。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "配置了还是不行，文件名字后缀也换成c++了", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "text.cpp", "referer": "user-0"}]}
{"question": "想知道主函数里输入的参数怎么用到自定义的以二维数组作参数的函数中二维数组的维度啊（截图里的程序是错误的，下边是高清版）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "了解一下OpenCV中的Mat", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "语法性的错误太多。但是就标题提出的问题而言，简单地说，在相当多版本的C编译器下，根本不支持动态尺寸的数组。所以你首先要确定你的编译器支持，然后再说怎么写，以及修正其他错误。", "referer": "user-0"}]}
{"question": "C语言新手入门，老师写的这个代码输出是2，3，4，5，6，7，8，9，10，11\n我的输出什么都没有，哪位大佬找下原因", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "题主的问题在于while循环那块，下面给上代码： #include<stdio.h>void test(){    static int a=1;    a++;    printf(\"%d\",a);}int main(){    int i=0;    while(i<10)//题主这里加了分号，陷入while死循环且没有输出    {        test();            i++;    }    return 0;} 运行结果为：234567891011", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢！！", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "放到while外面也不行", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "return 0放外面 删了分号", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "return 0放在while循环里面了", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "关键原因是while行末有个多余的分号，这个分号篡夺了循环体的地位，构成了死循环。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "把return 0；放while外，return 0；会结束while的操作", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "把 return 0; 放到while外面", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "放到while外面了还是不行，也不报错就是无输出", "referer": "user-6"}]}
{"question": "C语言外卖订餐管理系统求助：折扣数据无法读入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在scanf系列函数里，我是说包括fscanf对应double类型的变量的格式符需要使用%lf而不是%f", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "您是认真的么？编译能成功的话，起码得有含有错误的运行截图吧？还有无法读入的数据文件，你得确认它存在，位置正确，名字正确，权限正确，内容正确呀。", "referer": "user-0"}]}
{"question": "求键盘输入的一组数据的极值和均值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你不妨想一想为什么你输出的最小值是正确的，在和要求的最大值对比一下", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢啊，找到问题了。能再问一下为什么这个题目里引用函数一定要用到指针啊。", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "你不妨琢磨一下，为什么scanf引用变量要用指针（取地址），而printf一般不用。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我这学期刚学，没有接触过scanf和printf。", "referer": "user-2"}]}
{"question": "linux纯C下，调用excel或system函数启动外部程序，全路径中名含中文则会卡死（使用Qt 5.14.2环境编译)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已解决。PCB利用好就OK", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我在ubuntu,fedora下测试都是如此，哎，基础知识不过关啊", "referer": "user-0"}]}
{"question": "为什么我的数码管一直闪啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "那玩意是显示部件，你得保证它每秒刷新25次以上，才能看不出来闪。我的意思是说，它实际上就应该一直闪，只不过弄好了就看不出来而已。", "referer": "user-0"}]}
{"question": "求解！C语言基础问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "OK了搞定", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "在 C 语言中，可以使用scanf函数读取用户输入的数字，并通过判断来限制其大小。以下是一些实现方式： 使用循环和条件语句 int num;printf(\"请输入一个小于100的整数：\");while (scanf(\"%d\", &num) == 1 && num >= 100) {    printf(\"输入错误，请重新输入：\");    while (getchar() != '\\n') ; //清空输入缓冲区}printf(\"您输入的数字是：%d\\n\", num);", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这个有问题", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "你判断一下不就好了嘛，设置一个最大值和最小值。不在范围内你返回重新输入", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "输入不在限定范围内，提示并重新输入", "referer": "user-0"}]}
{"question": "地址总线和数据总线问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "具体问题具体分析。理论上每个系统都可以有不同的设计。", "referer": "user-0"}]}
{"question": "请问怎么把这个数值转化成 十六进制显示", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数字不对吧~", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址；人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "union hex_value{    char buf[8];    long long value;};  union hex_value fv_hex; fv_hex.value = amplitude_balue;        tx_Setbuffer[0] = fv_hex.buf[0];        tx_Setbuffer[1] = fv_hex.buf[1];        tx_Setbuffer[2] = fv_hex.buf[2];        tx_Setbuffer[3] = fv_hex.buf[3];        tx_Setbuffer[4] = fv_hex.buf[4];        tx_Setbuffer[5] = fv_hex.buf[5];        tx_Setbuffer[6] = fv_hex.buf[6];        tx_Setbuffer[7] = fv_hex.buf[7]; 是可以的，当时写的是short  ，范围小了，导致是00", "referer": "user-0"}]}
{"question": "求大佬解决 为啥其所占字节大小不随参数改变而改变", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "sizeof是编译期运算；不是运行时运算。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "因为形参数组名的实质是一个指向首元素的指针。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "哦哦哦  谢谢", "referer": "user-2"}]}
{"question": "求助：vscode 开发stm32 时出现“unknown type name”的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "找不到HAL_StatusTypeDef的定义https://www.baidu.com/s?wd=HAL_StatusTypeDef", "referer": "user-0"}]}
{"question": "C语言小白，设计了一个“输入一个整型数据，判断其是奇数还是偶数”的C语言程序，但输入除了0之外的数结果都是奇数，我自己找不出来哪里出了问题，有没有大佬帮我看一下程序哪里出错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "有什么特殊环境限制吗，C语言的求模运算是编译器自带的，不依赖库的，因该可以直接用求模看余数是否为0来判断啊。你是用加减2趋近0来判断奇数偶数，那你的两个do while 的判断正负的条件弄反了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你这个算法，有些费事。while() 里的判断条件不对吧，m>0 时，应该是 while(m>0) 吧，否则也不能循环了；下面的 while() 类似。", "referer": "user-0"}]}
{"question": "请教一个指针的问题 @赵四老板@各路老板。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！） 单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。 栈中的变量通常包括函数参数和函数里声明的临时变量。栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。而栈中的类变量退出其作用域时，会自动执行其析构函数，……所谓在栈中“申请”N字节的空间，其实只是将栈指针寄存器（16位sp，32位esp，64位rsp）的值多减N而已。 VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。”但我又不得不承认： 有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物； 而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。而我本人属前者。 不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质，而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。 这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！ 提醒：“学习用汇编语言写程序”和“VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。（Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）想要从本质上理解C指针，必须学习C和汇编的对应关系。”不是一回事！ 不要迷信书、考题、老师、回帖；要迷信CPU、编译器、调试器、运行结果。并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "多谢!", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "写一行，调试一行，行行出BUG", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "例2的a一样能得到num的地址，没问题。只不过离开这个函数也就是a的作用域以后a本身就不在了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "见过大佬N次。例2，用在实际情况里，我的程序没有正常运行。而且，指针 一般不都是要  malloc 的吗？", "referer": "user-3"}, {"cid": "7", "user": "user-3", "content": "所以说您把实际存在问题的部分当作无关紧要的内容，从而简化掉了。 指针变量首先是个变量，变量肯定是对应着一小块存储空间的，这个不需要另外申请。 一般要malloc的是目标空间，也就是把自己的首地址送去给指针变量保存的那个空间。而您这里的目标已经有了，就是num，所以不存在什么空间问题。 问题就是局部变量a离开作用域以后失去了定义。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "待验证！谢谢大佬！", "referer": "user-3"}]}
{"question": "#C语言遇到这个报错该怎么解决啊[Error] 'rand' cannot be used as a function", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdlib.h>//int rand;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "删掉那行int rand;", "referer": "user-0"}]}
{"question": "我这个为什么编译不通过呀（第二个图片的就编译通过）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "函数名前置类限定嘛", "referer": "user-0"}]}
{"question": "C 语言 关于清空缓存 while (getchar() != '\\n') continue;", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "另外这样写（无论前者后者）严谨地说不算是清空，因为它只清到行末。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "功能上没有区别。效率上前者不可能高于后者，现代编译器中大概率编译成一样的。至于为什么，恐怕您得问编者了。", "referer": "user-0"}]}
{"question": "蓝桥杯c++练习系统提交总是显示运行错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int *a = new int [n];", "referer": "user-0"}]}
{"question": "循环队列，求助大佬：为什么显示的运行结果不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "调式噻，一步步运行看哪里不对噻；加数据函数里，应该先放数据，在调 rear 吧；其它，显示数据，你显示的是下标，数据应该是 q->data[q->rear] 吧，而且显示过程把数据清空了，对还是不对。", "referer": "user-0"}]}
{"question": "这个输出结果怎么不对啊？有大佬帮忙看一下吗 感谢！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不是哥们，你不会debug一下吗", "referer": "user-0"}]}
{"question": "arduino编程，红灯不亮是怎么回事，求助大佬，程序如下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所以，红灯凭什么要亮呢？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "使用arduino-ide_2.0.4可以单步调式", "referer": "user-0"}]}
{"question": "请教大佬一下，为什么这个程序不能得出想要的结果？（我编写的这个函数好像失效了）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "帮你改了两个地方。  #include <stdio.h> #define SIZE_ONE 7 #define SIZE_TWO 3 void copy_fun(double array_ar[],double source_ar[]); int main(void) {     int index;     double source[SIZE_TWO];     double array[SIZE_ONE] = { 1.2, 2.3, 4.2, 7.9, 6.3, 9.3, 9.3 };     copy_fun(array,source);//删去void      printf(\"source's value as following:\\n\");     for (index = 0; index < SIZE_TWO; index++)         printf(\"%.1f \", source[index]);     return 0; }   void copy_fun(double array_ar[],double source_ar[]) {     int i, index;      for (index = 0, i = 2; index < SIZE_ONE- 4; index++, i++)//SIZE改为SIZE_ONE          source_ar[index] = array_ar[i]; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h>  #define SRC_ARR_LENGTH 7 #define DST_ARR_LENGTH 3  void copy_fun(double src_ar[], double dst_ar[]) {     int j = 0;     for (int i = 0; i < SRC_ARR_LENGTH; i++)     {         if ((i>=2) && (i<=4))         {             dst_ar[j++] = src_ar[i];         }     } }  int main() {     double dstArray[DST_ARR_LENGTH] = {0, 0};     double srcArray[SRC_ARR_LENGTH] = { 1.2, 2.3, 4.2, 7.9, 6.3, 9.3, 9.3 };      copy_fun(srcArray, dstArray);      printf(\"source's value as following:\\n\");     for (int i = 0; i < DST_ARR_LENGTH; i++)     {         printf(\"%.1f \", dstArray[i]);     }     printf(\"\\n\");      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "函数调用语句不能带前面的void，带着那玩意就被编译器理解为函数原型声明了。另外，啥地方定义了SIZE了？你的函数里SIZE-4没法解释啊。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "十分感谢，我已经对代码进行了修改，可以输出想要的结果了。", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "失效，什么阶段什么表现；编译时，照着提示的错误信息和错误所在行，去修改；若运行结果不对，调试，在复制语句上断点，看每次复制时的状况，有错误，看错哪里，改。", "referer": "user-0"}]}
{"question": "大神们，帮帮忙，新人学习，找找出什么问题了，谢谢了。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%d,&gread\"); 注意引号位置scanf(\"%d\",&gread);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> int main() {     int grade;     scanf(\"%d\", &grade);      if(grade >= 90)     {         printf(\"成绩为优秀\\n\");     }     else if((grade >= 70) && (grade <90))     {         printf(\"成绩为良好\\n\");     }     else if((grade >= 30) && (grade < 70))     {         printf(\"成绩为合格\\n\");     }     else     {         printf(\"成绩为差\\n\");     }      return 0;  }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> int main() {     int gread;     scanf(\"%d\",&gread);          if (90<=gread            ) printf(\"成绩为优秀\\n\");     else if (70<=gread && gread<90) printf(\"成绩为合格\\n\");     else if (30<=gread && gread<70) printf(\"成绩为良好\\n\");     else if ( 0<=gread && gread<30) printf(\"成绩为差\\n\");     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "码的漂亮，应该效仿！", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "https://bbs.csdn.net/topics/380157851", "referer": "user-4"}, {"cid": "6", "user": "user-5", "content": "子曾经说过，思而不学则die所以咱得学，而不是想当然地随便写。", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "scanf() 语句的后双引号放哪里去了", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "兄弟，我改完了以后，还是不行。 运行是不能正常运行，就无论输入什么数值，它都是只有一个输出（成绩为优秀和成绩为差）一起输出的", "referer": "user-6"}]}
{"question": "小白求助，用逗号和空格输出结果为什么不一样", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf() 语句里不是要求用逗号么，还问为什么？", "referer": "user-0"}]}
{"question": "到底错在哪里？求解答。谢谢谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if 和 else if 行末不应该有语句结束标记字符分号 ;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "; 号", "referer": "user-0"}]}
{"question": "问下各位大神，我这个代码怎么t输入18.6-18.9，结果都是错的，输入18.6  s1应该等于1，怎么等于0\n18.5结果是对的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "随意敲数据类型的后果。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不调试么，走一边大概就能知道问题在哪里吧；好像数据类型有不对", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "Coe() 里的 s ，最前面的声明是 int 但看函数里的使用，又是 float", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "这个问题可能与浮点数精度有关，因为浮点数在计算机中的表示方式可能存在精度损失。在程序中，你将浮点数输入到s变量中，但在Coe函数中，你将其与18.5进行比较。由于在计算机内部存储和表示浮点数时的精度限制，可能会导致s变量与18.5进行比较时的结果不是你期望的。因此，建议你可以将s变量与一个非常接近的整数进行比较，而不是浮点数18.5。例如，你可以定义一个整数常量，如下所示： #define BASE_S 185  然后，将s与BASE_S进行比较，如下所示： if (s <= BASE_S) {     s1 = 0; } else if (s - BASE_S <= 5) {     s1 = 1; } else if (s - BASE_S > 5) {     s1 = (s - BASE_S) / 5 + 1; }  这样，你就可以将浮点数s转换为整数进行比较，避免了由于精度误差导致的计算结果错误的问题。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢🙏，懂", "referer": "user-4"}, {"cid": "7", "user": "user-0", "content": "t输入16     s输入18.6      ch选择211  结果应该是525，输出的却是450.", "referer": "user-0"}]}
{"question": "0x0FA7EF8C (ucrtbased.dll)处(位于 c语言.exe 中)引发的异常: 0xC0000005: 写入位置 0x01300000 时发生访问冲突。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%9s\",Name);", "referer": "user-0"}]}
{"question": "新手入门求大佬教一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "还请麻烦您细讲一下什么是定义标识符  现在我只是跟着翁恺老师的视频跟着敲代码  当然老师的代码是输出了出来", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "标识符，identifier，指的是程序代码里的那些“名字”，各种东西的名字。 变量名是标识符的重要子集。 C中一个变量使用之前需要定义/声明，定义和声明当然还有自己的差别。 变量声明是一个说明，清晰表达这个名字的变量是什么类型的，这将会决定以后什么样的操作才是合法的，因为不同类型的操作集是有区别的。 而变量定义除了具有声明类型的功能，还向编译器要求在计算机内存里分配一块空间来存放这个变量。 综上，您敲代码时跳过的 int price; （在这个程序里简约形式可以这样写，也就是省略初始化，=0字样）就是一个承担了定义任务的声明。 上面最后这行内容再笼统一下就表达为  标识符price未定义。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "教材还是要看的，细看，尤其不要主观上觉得哪部分没用或者“聪明地发现”内容重复，于是就忽略一些内容。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "哦哦好的谢谢您  教材现在在看谭浩强老师的版本  当然只是粗看  之后我定会细看  感谢你提出的意见", "referer": "user-1"}, {"cid": "5", "user": "user-1", "content": "我一直说，初学者排错只看第一个错，改之，重新编译。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "意思是未定义标识符的问题吗？我的理解是；如果正确了应该就可以定义了不知道我的理解是否正确   还请指正", "referer": "user-1"}, {"cid": "7", "user": "user-1", "content": "当然不正确，因为您的确没有定义标识符price。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "您看看上面的那个回复   这里回复我发不了图片给您", "referer": "user-1"}]}
{"question": "链表求助：为什么建表不对啊，怎么改？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序  http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的第一个函数，init...忘记调用了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "看 ShowList() 里，你的表链有个起始的空表头项，那 Linklist L; 就不对了，应该是 linnode L; 吧，这样的话，那些函数调用参数也要改下变成 &L 了。", "referer": "user-0"}]}
{"question": "更好的方法定义故障bit位", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h>  #define WIRTE_UINT(des ,x ,pos ,len)  (                                   \\     (des)                                                                 \\     &                                                                     \\        ~(                                /* 除要修改的位为0，其余都为1 */ \\             (                                                             \\                 (1<<(len))-1             /* 长度为len位的1             */ \\             )                                                             \\             <<(32-(pos)-(len))           /* 左移32-(pos)-(len)位       */ \\         )                                                                 \\     |                                                                     \\         (                                                                 \\             (x)                                                           \\             <<(32-(pos)-(len))                                            \\         )                                                                 \\ ) #define READ_UINT(src ,pos ,len)      (                                   \\     (                                                                     \\         (                                                                 \\             (unsigned)(src)                                               \\         )                                                                 \\         >>(32-(pos)-(len))               /* 逻辑右移32-(pos)-(len)位   */ \\     )                                                                     \\     &                                                                     \\     (                                                                     \\         (1<<(len))-1                     /* 长度为len位的1             */ \\     )                                                                     \\ )  int main()                              //                1111111111222222222233 {                                       //bit   01234567890123456789012345678901     unsigned int des = 0x661;           //      00000000000000000000011001100001     unsigned int r;      des = WIRTE_UINT(des ,3 ,28 ,2);    //      00000000000000000000011001101101     printf(\"des==0x%08X\\n\",des);     r = READ_UINT(des ,28 ,2);     printf(\"r==%d\\n\",r);     return 0; } //des==0x0000066D //r==3", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "参考C:\\Program Files (x86)\\Windows Kits\\8.1\\Include\\um\\WinUser.h /*  * Extended Window Styles  */ #define WS_EX_DLGMODALFRAME     0x00000001L #define WS_EX_NOPARENTNOTIFY    0x00000004L #define WS_EX_TOPMOST           0x00000008L #define WS_EX_ACCEPTFILES       0x00000010L #define WS_EX_TRANSPARENT       0x00000020L #if(WINVER >= 0x0400) #define WS_EX_MDICHILD          0x00000040L #define WS_EX_TOOLWINDOW        0x00000080L #define WS_EX_WINDOWEDGE        0x00000100L #define WS_EX_CLIENTEDGE        0x00000200L #define WS_EX_CONTEXTHELP       0x00000400L  #endif /* WINVER >= 0x0400 */ #if(WINVER >= 0x0400)  #define WS_EX_RIGHT             0x00001000L #define WS_EX_LEFT              0x00000000L #define WS_EX_RTLREADING        0x00002000L #define WS_EX_LTRREADING        0x00000000L #define WS_EX_LEFTSCROLLBAR     0x00004000L #define WS_EX_RIGHTSCROLLBAR    0x00000000L  #define WS_EX_CONTROLPARENT     0x00010000L #define WS_EX_STATICEDGE        0x00020000L #define WS_EX_APPWINDOW         0x00040000L   #define WS_EX_OVERLAPPEDWINDOW  (WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE) #define WS_EX_PALETTEWINDOW     (WS_EX_WINDOWEDGE | WS_EX_TOOLWINDOW | WS_EX_TOPMOST)  #endif /* WINVER >= 0x0400 */  #if(_WIN32_WINNT >= 0x0500) #define WS_EX_LAYERED           0x00080000  #endif /* _WIN32_WINNT >= 0x0500 */   #if(WINVER >= 0x0500) #define WS_EX_NOINHERITLAYOUT   0x00100000L // Disable inheritence of mirroring by children #endif /* WINVER >= 0x0500 */  #if(WINVER >= 0x0602) #define WS_EX_NOREDIRECTIONBITMAP 0x00200000L #endif /* WINVER >= 0x0602 */  #if(WINVER >= 0x0500) #define WS_EX_LAYOUTRTL         0x00400000L // Right to left mirroring #endif /* WINVER >= 0x0500 */  #if(_WIN32_WINNT >= 0x0501) #define WS_EX_COMPOSITED        0x02000000L #endif /* _WIN32_WINNT >= 0x0501 */ #if(_WIN32_WINNT >= 0x0500) #define WS_EX_NOACTIVATE        0x08000000L #endif /* _WIN32_WINNT >= 0x0500 */", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "故障bit需要是变量，需要set和reset", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "既然是单片机，为什么不外置编码器来直接提供故障号呢？有了号，再来个函数指针数组直接搞定。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "硬件不做改动", "referer": "user-2"}, {"cid": "6", "user": "user-0", "content": "单从软件角度有没有更好的定义方法？", "referer": "user-2"}, {"cid": "7", "user": "user-2", "content": "既然是软的那为什么不用故障号变量，却一定要用比特表达呢？ 所以您得说清楚什么需求什么约束，否则问题没啥意义呀。", "referer": "user-0"}]}
{"question": "有个问题想问一下 。。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这是蝙蝠侠的第二台座驾的草稿啊，你从哪里翻出来的？当年还可以卖给超人，现在估计他不感兴趣了。", "referer": "user-0"}]}
{"question": "新手求助大佬， 如图", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "logged in被翻译为登录然后误作登陆然后再翻回去成了landed这种事会被人笑的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "另外数组名就是地址，所以这个scanf里面就不要对数组名取地址了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "arr2 数组溢出了，你就定义了一个字符的空间，输入字符串，起码得两个吧，一个字符，一个字符串结束标记字节 0x00；所以，把 arr2 定义得大些试试，如 arr2[64]", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "懂了懂了，谢谢", "referer": "user-2"}]}
{"question": "新手求助，求各位大佬看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "%lf%lf%lf", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "另外我眼神不行，认不出%和f中间是数字1还是小写L，请确保用小写L 。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "是小写l，感谢您的回答", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "格式串里的非格式符，例如逗号，是需要你精确地原样输入的。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "好像还真是逗号的问题，把逗号换成空格就正常了。", "referer": "user-2"}]}
{"question": "三个程序员批斗JS.JPG", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要做A语言代码修改为B语言代码的无用功。也不要做用A语言代码直接调用B语言代码库这样复杂、这样容易出错的傻事。只需让A、B语言代码的输入输出重定向到文本文件，或修改A、B语言代码让其通过文本文件输入输出。即可很方便地让A、B两种语言之间协调工作。比如：A将请求数据写到文件a.txt，写完后改名为aa.txtB发现aa.txt存在时，读取其内容，调用相应功能，将结果写到文件b.txt，写完后删除aa.txt，再将b.txt改名为bb.txtA发现bb.txt存在时，读取其内容，读完后删除bb.txt以上A可以替换为任何一种开发语言或开发环境，B可以替换为任何一种与A不同的开发语言或开发环境。除非A或B不支持判断文件是否存在、文件读写和文件更名。但是谁又能举出不支持判断文件是否存在、文件读写和文件更名的开发语言或开发环境呢？可以将临时文件放在RamDisk上提高效率减少磨损磁盘。数据的结构很复杂的话，文本文件的格式问题可参考json或xml 共享临时文本文件这种进程之间的通讯方法相比其它方法的优点有很多，下面仅列出我现在能想到的：·进程之间松耦合·进程可在同一台机器上，也可跨机，跨操作系统，跨硬件平台，甚至跨国。·方便调试和监视，只需让第三方或人工查看该临时文本文件即可。·方便在线开关服务，只需删除或创建该临时文本文件即可。·方便实现分布式和负载均衡。·方便队列化提供服务，而且几乎不可能发生队列满的情况（除非硬盘空间满）·…… “跨语言、跨机，跨操作系统，跨硬件平台，跨国，跨*.*的”苦海无边，回头是“使用共享纯文本文件进行信息交流”的岸！", "referer": "user-0"}]}
{"question": "没有报错但是输出时没有结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。不要依赖调试器输出复杂数据结构！而要将复杂数据结构的整个内容在处理它的每一步使用一小段代码按自己很容易理解的格式输出，非常有助于调试！或者可以说是“基础设施”数据结构对单链表进行数据排序  http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "initlist; 没有带入 l 指针，应该是 initlist(l); 吧；listinsert() 里最后没有填入数据；交换部分，没看懂，也不知道对不对。", "referer": "user-0"}]}
{"question": "求求ctf的re大佬帮帮", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "是因为ida版本问题吗还是在用ida打开文件的时候一些框框我没点", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "求教教了", "referer": "user-0"}]}
{"question": "C语言斜上抛运动 的仿真", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://xege.org/", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "easyx.cn", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "能不能详细说一说，我们书上没这个内容，现在束手无策了，谢谢谢谢", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "绘图用easyx库，算法参考 https://blog.csdn.net/liuyuan_jq/article/details/6314261 中的python代码： from visual import *  scene.width = 400 scene.height = 300  scene.autoscale = 0 scene.range = (100,100,100) scene.center = (50,40,0)  ball = sphere(pos=(0,2,0),radius=2, color=color.green) ground = box(pos=(50,-1,0),size=(100,2,10))   gravity = 9.8  # m/s**2 velocity = 25   # m/s angle = 45     # degrees angle = angle * (pi/180) # converted to radians  VelocityY = velocity * sin(angle) VelocityX = velocity * cos(angle)  seconds = 0 dt = .01  finished = False while not finished:     rate(100) # go thru the loop no more than 100 times/s     seconds += dt      # position equation: y(t) = y0 + v0*t + .5 * a * t**2     ballY = 2 + VelocityY * seconds - .5 * gravity * seconds**2     ballX = VelocityX * seconds      ball.pos = vector(ballX,ballY,0)      if ballY - 2 &lt;= 0:         finished = True         print \"initial velocity: \" + str(velocity)         print \"angle thrown: \" + str(angle)         print \"seconds in flight: \" + str(seconds)         print \"distance in the x direction: \" + str(ballX)", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "有没有用C语言写的那种呢？", "referer": "user-2"}, {"cid": "6", "user": "user-0", "content": "谢谢各位朋友了，帮帮孩子", "referer": "user-0"}]}
{"question": "统计输入字符，结果没有输出，各位大老请帮忙看下。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "用 EOF 来判别，最后得按个 Ctrl+Z 组合键吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "放话了     已经好了", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-1"}]}
{"question": "帮忙写个c语言程序设计", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "easyx.cn", "referer": "user-0"}]}
{"question": "求助，需求就是输出所有特定的是三位数，三位数个位十位百位相应数字，分别立方后相加等于这个三位数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "/* 快来抄作业 */ #include <stdio.h> int main(){    int i, j, m, n, sum; for (i=100; i<1000; i++) {     m = i;     sum = 0;      for (j=0; j<3; j++)     {         n = m%10;         m /= 10;         sum += n*n*n;     }      if (sum == i)     {         printf(\"%d\\n\", i);     } }  return 0;  }", "referer": "user-0"}]}
{"question": "求问这里为什么会输出3个乱码？指针数组这里第四个元素不是NULL吗，*p=NULL后为什么还会输出？后来我多加了一个整型变量i，并赋值为1后乱码消失了，但printf不了任何东西。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所以是概念性错误，数组没有第四元素。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数组越界你的修改只是瞎猫碰上死耗子罢了 char *a[]={\"asd\",\"asda\",\"sx\",NULL};", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-2"}]}
{"question": "vs报错，实参与形参不兼容", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "有两个问题： 1.在函数printHero的参数列表中，struct hero heroArray[]应该改为struct Hero heroArray[]，大小写不匹配导致编译错误。 2.在函数bubbleSort的实现中，应该包含头文件#include，以便在比较字符串时使用string类型，否则将无法编译程序", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢你！研究了好久都没发现自己写错了orz", "referer": "user-1"}]}
{"question": "大一小白提问C语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "b是静态变量，也就是说每次调用b，都是在上一个b的基础上进行调用。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第二第三次调用fun的时候，进去以后b就不是2了，上次结束时b是多少现在还是多少。这就是static的用处。", "referer": "user-0"}]}
{"question": "程序被异常情况关闭掉，该程序自己重新开启，导致再次写文件时候发现，在上次文件尾部会出现不可见的@@@，该如何解决。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "目前是别的异常导致开发板出现断电重启，只能是在重启后，自己在遍历一次该文件，去掉这些不可见字符，在继续写了。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这个没办法。就好象头疼，如果不找到原因，你没办法直接避免头疼。同样的道理。", "referer": "user-0"}]}
{"question": "大一c语言题目期末练习题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学会在IDE中调试时看每句C对应的汇编指令", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "184#include <stdio.h>int d=1;void fun(int p){int d=15;            /* 这里定义个局部变量d，且初始化等于15 /d+=p++;             / 这个d是局部变量d, p++没啥意义，结果不会传出函数外面 /printf(\"%d\",d);    / p=3 时 d=18 注意这里没换行 /}int main( ){int a=3;fun(a);d+=a++;           / 这个d是全局变量d，所以d等于4 */printf(\"%d\",d);return 0;} /* 所以最终结果输出184 */", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "求解析 越详细越好", "referer": "user-0"}]}
{"question": "请大佬帮忙看一下此题，百思不能完成全部要求", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "灰常灰常简单滴啦，当然你非要什么函数的话就要增加几行代码~ #include <stdio.h>   int main() {   int b[1024], n = 0;     for (int c; (c = getchar()) != 10;)     if (c == '+' || c == '-' || (c > 47 && c < 58))     {       ungetc(c, stdin);       if (scanf(\"%d\", &b[n]) == 1) n++;     }   for (int i = 0; i < n; i++) printf(\"%d \", b[i]); puts(\"\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "非常感谢大佬", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "int flg = 0; // 标记是否已经执行atoiint n = 0;  // b数组下标char * str = \"abc456sd78fd123s 789df\";char * p = NULL; for (p = str; *p; ++p){    if (*p >= '0' && *p <= '9' && 0 == flg)    {        b[n++] = atoi(p);        flg = 1;    }    if (*p < '0' || *p > '9' && 1 == flg)    {        flg = 0;    }}", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "非常感谢，懂了！那要是随意输入一个字符串，去判断呢？", "referer": "user-2"}, {"cid": "5", "user": "user-0", "content": "百思不能写出稍微完美的程序", "referer": "user-0"}]}
{"question": "C语言中的数组的比较", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你知道，回字有四种写法。什么时候用哪一种呢？仅仅这样问是不是挺扯？ 上下文都是简体字的时候，你自然写简体标准。上下文都是繁体字的时候，你就要写繁体写法。搞书法的时候尤其是写对联的时候呢，一般用繁体字，但是上下联用到同一个字的时候一般需要变体，于是变体也有用的地方了。 而楼主的问题就失之于表面，你不要背代码，你得理解进去，然后知该从0开始就从0开始，该从1开始就从1开始，该从2开始就从2开始...", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这得看后续是什么功能和实现的方法吧；如排序，由于是两两比较，所以 10 个数 9 次比较就可实现一遍；如输出，就得是 10 次了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "1！", "referer": "user-0"}]}
{"question": "C++递归,什么情况会栈溢出？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "step-- 的缘故吧，后自减，即语句执行后再减，那就是始终是 return(func2(1000));  了，所以，就溢出了。换 --step 试试？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "对，是因为这个", "referer": "user-1"}]}
{"question": "有用Linux下c 读写spi从机，该如何操作，我下面是spi 主机模式，我想知道从机模式怎么写，谢谢了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "spi从机是个外设，站在楼主的代码的角度看，外设那边一般没有处理器，也就没有代码，应该是靠芯片实现的功能。就好象U盘，U盘端本身一般是不运行软件代码的。", "referer": "user-0"}]}
{"question": "CMD命令中的参数带有双引号，如何转义双引号？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h> void main(int argc,char *argv[]) {     int i;     for (i=0;i<argc;i++) {         printf(\"argv[%d]=[%s]\\n\",i,argv[i]);     } } //C:\\>arg 1 2 3 //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2] //argv[3]=[3] // //C:\\>arg 1 \"2 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 3] // //C:\\>arg 1 \"2 \"\"3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"3] // //C:\\>arg 1 \"2 \"\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"] //argv[3]=[3] // //C:\\>arg 1 \"2 \\\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \" 3] // //C:\\>arg 1 \"2 \\\\\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \\] //argv[3]=[3] // //C:\\>arg 1 \"2 \\\\\\\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \\\" 3] // //C:\\>arg 1 \"2 \\\"\\ 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"\\ 3] // //C:\\>arg 1 \"2 \\\"\\\\ 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"\\\\ 3] // //C:\\>arg 1 \"|\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[|] // //C:\\>arg 1 | //命令语法不正确。 // //C:\\>arg 1 ^| //argv[0]=[arg] //argv[1]=[1] //argv[2]=[|] // //C:\\>arg 1 > //命令语法不正确。 // //C:\\>arg 1 ^> //argv[0]=[arg] //argv[1]=[1] //argv[2]=[>] // //C:\\>arg 1 < //命令语法不正确。 // //C:\\>arg 1 ^< //argv[0]=[arg] //argv[1]=[1] //argv[2]=[<] // //C:\\>arg 1 & //argv[0]=[arg] //argv[1]=[1] // //C:\\>arg 1 && //命令语法不正确。 // //C:\\>arg 1 ^& //argv[0]=[arg] //argv[1]=[1] //argv[2]=[&] // //C:\\>arg 1 ^&& //argv[0]=[arg] //argv[1]=[1] //argv[2]=[&] // //C:\\>arg 1 ^&^& //argv[0]=[arg] //argv[1]=[1] //argv[2]=[&&] // //命令行解释器概述命令行解释器是一个单独的软件程序，它可以在用户和操作系统之间提供直接的通讯。非图形命令行解释器用户界面提供运行基于字符的应用程序和实用程序的环境。通过使用类似于 MS-DOS 命令解释程序 Command.com 的单独字符，命令行解释器执行程序并在屏幕上显示其输出。Windows 服务器操作系统命令行解释器使用命令解释程序 Cmd.exe（该程序加载应用程序并指导应用程序之间的信息流动）将用户输入转换为操作系统可理解的形式。 // //可以使用命令行解释器创建和编辑可自动执行常规任务的批处理文件（也称作脚本）。例如，可以使用脚本自动管理用户帐户或夜间备份。还可以使用 Windows 脚本宿主 CScript 的命令行版本在命令行解释器中运行更高级的脚本。详细信息，请参阅运行 Windows 脚本宿主。通过使用批处理文件来执行操作，可比使用用户界面更有效率。批处理文件接受命令行上可用的所有命令。有关批处理文件和脚本的详细信息，请参阅使用批处理文件。 // //您可以自定义命令提示符窗口以易于查看并增强对程序运行方式的控制。有关自定义命令提示符窗口的详细信息，请参阅配置命令提示符。 // //使用命令语法 //语法按命令及所带参数必须遵循的键入顺序出现。下面的 xcopy 命令示例显示了各种语法文本格式： // //xcopy Source [Destination] [/w] [/p] [/c] [/v] [/q] [/f] [/l] [/g] [/d[:MM-DD-YYYY]] [/u] [/i] [/s [/e]] [/t] [/k] [/r] [/h] [{/a | /m}] [/n] [/o] [/x] [/exclude:File1[+[File2]][+[File3]] [{/y | /-y}] [/z] // //下表说明如何解释不同的文本格式。 // //格式化图例 //    格式    含义 //    斜体    用户必须提供的信息 //    粗体    用户必须准确键入的要显示的元素 //    省略号  (...) 在命令行中可多次重复的参数 //    中括号  ([]) 可选项 //    大括号  ({})；选项用竖线 (|) 分隔。例如：{even|odd} 用户必须从选项集合中选择一个 // //使用多个命令和条件处理符号 //使用条件处理符号可以在单个命令行或脚本中运行多个命令。通过条件处理符号运行多个命令时，条件处理符号右边的命令根据条件处理符号左边命令的执行结果来发挥作用。例如，只有在前一个命令失败的情况下才可能需要运行一个新命令。或者，只有在前一个命令成功时才可能需要运行一个新命令。 // //可以使用下表列出的特殊字符来传递多个命令。 // //字符       语法                   定义 //& [...]    Command1 & Command2    用来分隔一个命令行中的多个命令。Cmd.exe 运行第一个命令，然后运行第二个命令。 //&& [...]   Command1 && Command2   只有在符号 && 前面的命令成功时，才运行该符号后面的命令。Cmd.exe 运行第一个命令，然后只有在第一个命令运行成功时才运行第二个命令。 //|| [...]   Command1 || Command2   只有在符号 || 前面的命令失败时，才运行符号 || 后面的命令。Cmd.exe 运行第一个命令，然后只有在第一个命令未能运行成功（接收到大于零的错误代码）时才运行第二个命令。 //( ) [...]  (Command1 & Command2)  用来分组或嵌套多个命令。 // // 注意 // //“与”符号 (&)、管道符号 (|) 以及括号 () 是特殊字符，将它们作为参数传递时，必须在其前面加上转义字符 (^) 或引号。 //如果某个命令成功完成操作，该命令就返回零 (0) 退出代码或不返回任何退出代码。有关退出代码的详细信息，请参阅 Microsoft Windows 部署和资源工具包。 //嵌套命令行解释器 //通过在命令提示符下打开新的 Cmd.exe 实例，可以在 Cmd.exe 内嵌套命令行解释器。默认情况下，Cmd.exe 的每个实例继承其父 Cmd.exe 应用程序的环境。通过嵌套 Cmd.exe 的实例，可以更改局部环境，而不会影响 Cmd.exe 的父应用程序。这使您能够保留 Cmd.exe 的原始环境，并在终止嵌套的命令行解释器之后返回到原始环境。但是在嵌套的命令行解释器中所做的更改将不会被保存。 // //要嵌套命令行解释器，请在命令提示符下键入： // //cmd // //出现类似于下面内容的消息： // //Microsoft (R) Windows Server 2003 Standard Edition (TM) //(C) 版权所有 1985-2002 Microsoft Corp. //要关闭嵌套的命令行解释器，请键入 exit。 // //使用 setlocal 和 endlocal 命令，可以在 Cmd.exe 的实例中（或在脚本中）进一步将更改局部化。Setlocal 创建局部作用范围，而 endlocal 终止局部作用范围。在 setlocal 和 endlocal 作用范围内所做的更改将会被放弃，从而保持原始环境不变。这两个命令的嵌套最高可达到 32 级。有关 setlocal 和 endlocal 命令的详细信息，请参阅 Setlocal 和 Endlocal。 // //将环境变量与 Cmd.exe 一起使用 //Cmd.exe 命令行解释器环境由确定命令行解释器和操作系统行为的变量进行定义。可以使用两种类型的环境变量（系统和局部）来定义命令行解释器环境或整个操作系统环境的行为。系统环境变量定义全局操作系统环境的行为。局部环境变量定义 Cmd.exe 当前实例环境的行为。 // //系统环境变量预置于操作系统之中，并可用于所有 Windows 服务器操作系统进程。只有具有管理凭据的用户才可以更改系统变量。这些变量最常用于登录脚本。 // //局部环境变量只有在创建变量时针对的目标用户登录到计算机时才有效。HKEY_CURRENT_USER 配置单元中设置的局部变量只对当前用户有效，但它们可定义全局操作系统环境的行为。 // //下表按优先顺序的降序描述变量的各种类型： // //内置系统变量 //在 HKEY_LOCAL_MACHINE 配置单元中找到的系统变量 //在 HKEY_CURRENT_USER 配置单元中找到的局部变量 //在 Autoexec.bat 文件中设置的所有环境变量和路径 //在登录脚本（如果有的话）中设置的所有环境变量 //在脚本或批处理文件中交互使用的变量 //在命令行解释器中，Cmd.exe 的每个实例都继承其父应用程序的环境。因此，可以在不影响父应用程序环境的情况下更改新的 Cmd.exe 环境中的变量。 // //下表列出 Windows server operating system 的系统和本地环境变量。 // //变量                     类型       描述 //%ALLUSERSPROFILE%        本地       返回“所有用户”配置文件的位置。 //%APPDATA%                本地       返回默认情况下应用程序存储数据的位置。 //%CD%                     本地       返回当前目录字符串。 //%CMDCMDLINE%             本地       返回用来启动当前的 Cmd.exe 的准确命令行。 //%CMDEXTVERSION%          系统       返回当前的“命令处理程序扩展”的版本号。 //%COMPUTERNAME%           系统       返回计算机的名称。 //%COMSPEC%                系统       返回命令行解释器可执行程序的准确路径。 //%DATE%                   系统       返回当前日期。使用与 date /t 命令相同的格式。由 Cmd.exe 生成。有关 date 命令的详细信息，请参阅 Date。 //%ERRORLEVEL%             系统       返回上一条命令的错误代码。通常用非零值表示错误。 //%HOMEDRIVE%              系统       返回连接到用户主目录的本地工作站驱动器号。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。 //%HOMEPATH%               系统       返回用户主目录的完整路径。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。 //%HOMESHARE%              系统       返回用户的共享主目录的网络路径。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。 //%LOGONSERVER%            本地       返回验证当前登录会话的域控制器的名称。 //%NUMBER_OF_PROCESSORS%   系统       指定安装在计算机上的处理器的数目。 //%OS%                     系统       返回操作系统名称。Windows 2000 显示其操作系统为 Windows_NT。 //%PATH%                   系统       指定可执行文件的搜索路径。 //%PATHEXT%                系统       返回操作系统认为可执行的文件扩展名的列表。 //%PROCESSOR_ARCHITECTURE% 系统       返回处理器的芯片体系结构。值：x86 或 IA64（基于 Itanium）。 //%PROCESSOR_IDENTFIER%    系统       返回处理器说明。 //%PROCESSOR_LEVEL%        系统       返回计算机上安装的处理器的型号。 //%PROCESSOR_REVISION%     系统       返回处理器的版本号。 //%PROMPT%                 本地       返回当前解释程序的命令提示符设置。由 Cmd.exe 生成。 //%RANDOM%                 系统       返回 0 到 32767 之间的任意十进制数字。由 Cmd.exe 生成。 //%SYSTEMDRIVE%            系统       返回包含 Windows server operating system 根目录（即系统根目录）的驱动器。 //%SYSTEMROOT%             系统       返回 Windows server operating system 根目录的位置。 //%TEMP%和%TMP%            系统和用户 返回对当前登录用户可用的应用程序所使用的默认临时目录。有些应用程序需要 TEMP，而其他应用程序则需要 TMP。 //%TIME%                   系统       返回当前时间。使用与                                                                                   time       /t                                                                     命令相同的格式。由         Cmd.exe                  生成。有关                       time   命令的详细信息，请参阅 Time。 //%USERDOMAIN%             本地       返回包含用户帐户的域的名称。 //%USERNAME%               本地       返回当前登录的用户的名称。 //%USERPROFILE%            本地       返回当前用户的配置文件的位置。 //%WINDIR%                 系统       返回操作系统目录的位置。 // //设置环境变量 //使用 set 命令创建、更改、删除或显示环境变量。set 命令只更改当前解释器环境中的变量。 // //要查看变量，请在命令提示符下键入： // //set VariableName // //要添加变量，请在命令提示符下键入： // //set variablename=Value // //要删除变量，请在命令提示符下键入： // //set VariableName= // //可以将大多数字符用作变量值，其中包括空格。如果使用特殊字符 <、>、|、& 或 ^，则必须在它们前面加上转义字符 (^) 或引号。如果使用引号，则必须将引号作为值的组成部分，因为等号后面的任何内容都会被视为值。请考虑下列示例： // //要创建变量值 new&name，请键入： //set varname=new^&name // //要创建变量值 \"new&name\"，请键入： //set varname=\"new&name\" // //如果在命令提示符下键入 set varname=new&name，就会出现与下面内容类似的错误消息： //“'name' 不是内部或外部文件，也不是可运行的程序或批处理文件。” //变量名不区分大小写。但是，set 显示的变量与您键入的完全相同。可以在变量名中结合使用大写字母和小写字母，这样可以使代码更具有可读性（例如，UserName）。 // // 注意 // //单个环境变量的最大大小为 8192 字节。 //所有环境变量的大小总和（包括变量名和等号）最大为 65,536 KB。 //替换环境变量值 //要在命令行或脚本中启用变量值替换，请将变量名包括在百分号之中（即，%VariableName%）。使用百分号可以确保 Cmd.exe 引用变量值，而不是进行文字比较。为变量名定义变量值之后，请将变量名包括在百分号之中。Cmd.exe 搜索该变量名的所有实例，并用定义的变量值进行替换。例如，如果创建包含不同值（例如，用户名）的脚本，并且想要用这些值为每个用户定义 USERNAME 环境变量，可以使用包括在百分号之中的 USERNAME 来编写代码。运行此脚本时，Cmd.exe 将用变量值替换 %USERNAME%，这样就消除了为每个用户手动执行此任务的必要。变量替换是不可递归的。Cmd.exe 检查变量一次。有关变量替换的详细信息，请参阅 For 和 Call。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "命令行里转义字符好像是 Shift+6 的那个上尖角符号 ^ ；引号，直接使用不对的话，试试 ^\" ?", "referer": "user-0"}]}
{"question": "[C语言]关于数组指针的问题，代码如下：", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "p后面的方括号是多余的。", "referer": "user-0"}]}
{"question": "C语言新手求助帖子，求大佬解答疑惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、输入的时候敲 a=7 b=9 2、3、一样的，等号左右的表达式评估过程不分先后，所以像 *b++= *b*2; 这样写不对。 4、级别不同不好相容，所以应该写 int *p=a[0];", "referer": "user-0"}]}
{"question": "求代码急需，在线等，快快快！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "呃，前面的代码确实有考虑不全的地方。但是简洁呢，还是要的，很多年以前，在我开始学习编程的时候，一位师兄告诉我：代码不是old二，越长越好，从那之后，我一直记着这句话，作为代码的基本要求~修改一下： #include <stdio.h>  int main() {   int n, k, x = 0;    for (int i = (scanf(\"%d%d\", &n, &k), 1); n; n /= 10, i *= k + 1)     x += (n % 10 < k ? n % 10 : k) * i;   printf(\"%d\\n\", x);    return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "老赵的代码写得太繁琐，须知代码不是小二，越长越好~ #include <stdio.h>  int main() {   char n[8];   int k, x = 1;    for (int i = (scanf(\"%s%d\", n, &k), 0), j; n[i]; i++)     x *= (n[i] - '0' > k ? k : n[i] - '0') + 1;   printf(\"%d\\n\", x - 1);    return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "xs，自己代码都是错的 来说别人繁琐？", "referer": "user-1"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> int main() {     int n,k,i,t,f;     char s[8],*p;     scanf(\"%d%d\",&n,&k);     t=0;     for (i=1;i<=n;i++) {         sprintf(s,\"%d\",i);         f=1;         p=&s[0];         while (1) {             if (*p==0) break;             if (*p>'0'+k) {                 f=0;                 break;             }             p++;         }         if (f) t++;     }     printf(\"%d\\n\",t);     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "灰常灰常简单滴啦～", "referer": "user-0"}]}
{"question": "qsort对动态内存排序问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <malloc.h> struct PC {     int a;     char b; } *pc; int i; int compare( const void *arg1, const void *arg2 ) {     return ((struct PC *)arg1)->b - ((struct PC *)arg2)->b; } int main() {     pc=(struct PC *)malloc(3*sizeof(struct PC));     pc[0].a=1;     pc[0].b='z';     pc[1].a=2;     pc[1].b='y';     pc[2].a=3;     pc[2].b='x';     qsort( (void *)pc, 3, sizeof(struct PC), compare );     for (i=0;i<3;i++) {         printf(\"pc[%d].a:%d, pc[%d].b:'%c'\\n\",i,pc[i].a,i,pc[i].b);     }     free(pc);     return 0; } //pc[0].a:3, pc[0].b:'x' //pc[1].a:2, pc[1].b:'y' //pc[2].a:1, pc[2].b:'z' //", "referer": "user-0"}]}
{"question": "再问数据类型转化的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "不明白你什么意思。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "如果你熟悉MarkDown语法，在代码的前后加 ``` 可以让代码有语法高亮效果。例如： #include <stdio.h> int main(int argc,char** argv){   print(\"hello,wolrd!\");   return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "错误不在调用上，在于你的指针没有目标空间，你得给它目标空间然后才好干活。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢！得怎么给它目标空间呢？我比较愚钝，还请明示。", "referer": "user-2"}]}
{"question": "数据类型转化的为问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "SERCOM6_SPI_Write((void *)&dat, 1);", "referer": "user-0"}]}
{"question": "完全懵逼了，不符合小学数学啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E  http://bbs.csdn.net/topics/391003898", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#define square(x) ((x) * (x))", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "1+1*1+1=3 (1+1)*(1+1)=4", "referer": "user-0"}]}
{"question": "怎么不是16呢？木天理", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-Ehttp://bbs.csdn.net/topics/391003898", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "3+1*3+1當然等於7啦。 #define sqr(x) (x* x)", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "( (x) * (x))", "referer": "user-2"}]}
{"question": "难道*i = *i * *i 运行了两次？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我一运行，他输出4,9毫无破绽啊", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "用個中間變量過度下，不要直接*i=*i**i", "referer": "user-0"}]}
{"question": "求助 C语言习题水仙花数的bug疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "100g改爲 100 * g 还有10s也改下，%dn\\改为 %d\\n", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢你 bug已经修好啦", "referer": "user-1"}]}
{"question": "求助 改错(C语言_数据结构单链表删除，学生管理系统)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序  http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "86行造成结点自循环了嘛，所以后面的结点就都丢了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "那请问要改成啥压，，这里我改了好几遍，例如p=phead->next,pre->next=phead-next,等等，要么就是循环了，要么就是段错误 绕不出来 请帮忙做出改正和更加详细的解释谢谢谢谢谢谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "p 和 pre 的 next 不应该再设置的，你只是给 p 和 pre 初始化下，表里 next 成员这时又不应该发生变动。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "也就是在这里将pre和p初始化成为一个在前一个在后的指针，然后并排跑是嘛", "referer": "user-3"}]}
{"question": "求助，有关结构体指针的初始化", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fat* fat1 = (fat*)(v_addr0 + BLOCKSIZE);这个不是初始化，是指向v_addr0 + BLOCKSIZE 这个偏移地址。猜测BLOCKSIZE是fat结构体的大小，那么这个偏移就是指向下一个结构体。fat1当然可以当做数组了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不是初始化结构体，只是让那指针指向已有的数据某部分；指针当数组，全看编译器是否支持了，指针类型确定了，作为数组指向某单元，偏移是可以确定的", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不懂的部分就去溯源，不去找的话，大佬们也一样不懂。", "referer": "user-0"}]}
{"question": "请问怎么修改代码，能让输出的结果既能输出“没有与别人生日相同的人”，也能输出“生日相同的人”？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "输入a 2000:1:3b 2000:1:2c 2000:1:2则输出1:2 b c1:3 a 以上本来就已经实现了既能输出“没有与别人生日相同的人”，也能输出“生日相同的人”呀？", "referer": "user-0"}]}
{"question": "for (k = 1; 1; ++k)是什么意思", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for (A;B;C) D; //等价于 {  A;  while (1) {   if (!(B)) break;   D;   C;  } }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "是的", "referer": "user-0"}]}
{"question": "请问 gcc 怎么查询默认的设置项？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "gcc -v --help", "referer": "user-0"}]}
{"question": "keil遇到问题了，真心求解。main.c（350）：错误 C141：语法错误接近“void”，预期为“__asm”", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void nao_zhong(); 这个后面的分号是否多余？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好像，没有太大关系", "referer": "user-1"}]}
{"question": "自学了x86汇编，说一下我对内存的理解，如有错误请大家指正。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "比较新的处理器通常是56位物理地址了，当然内存控制器一般只能支持几百GB的内存~", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "对于裸内存来说，您理解的都对。只是现有的硬件一般实现地址总线时不会搞64根，典型值是48根。所以理论上那么长的那根绳子在现阶段的实践中可能只有65536分之一的长度是实际可用的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址；人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息…… 栈中的变量通常包括函数参数和函数里声明的临时变量。栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。而栈中的类变量退出其作用域时，会自动执行其析构函数，……所谓在栈中“申请”N字节的空间，其实只是将栈指针寄存器（16位sp，32位esp，64位rsp）的值多减N而已。 计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！） 单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。 VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。”但我又不得不承认： 有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物； 而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。而我本人属前者。 不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质，而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。 这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！ 提醒：“学习用汇编语言写程序”和“VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。（Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）想要从本质上理解C指针，必须学习C和汇编的对应关系。”不是一回事！ 不要迷信书、考题、老师、回帖；要迷信CPU、编译器、调试器、运行结果。并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "很欣慰，一年前你这段话还完全不理解，现在已经理解了至少80%。是你把我带进汇编这个坑里的。", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "我都说了：【 提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！ 】 为什么你还认为是我把你带“坑”里了呢？ (^_^)", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "《深度探索C++对象模型》 《C++反汇编与逆向分析技术揭秘》", "referer": "user-0"}]}
{"question": "请教大佬C++编译后Windows Defender和360报毒怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "使用360杀毒杀一杀你的电脑", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "虚拟机里面跑的，主机没用360，其他杀毒软件（金山毒霸，腾讯电脑管家，火绒）都没报毒，只有360和Windows Defender报毒。", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "那就虚拟机里面杀毒", "referer": "user-0"}]}
{"question": "有一道非常简单的循环我实在搞不懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "原因是scanf会默认读取末尾空白字符并跳过，你输入的数字（比如1  2 3     4   6 7     8）后面有几个空格都无所谓，scanf会读取并抛弃，直到遇到一个非空白字符。也就是说你输入1 2之后，“1”才会被真正读取，\"2\"进入缓冲区。同理，你输入“8”之后，必须有一个非空白字符才会读取到“8”。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的scanf的%d后面有空格，意味着你敲完8以后也得带个空格，然后再敲回车。而不是直接敲回车。所以，%d为什么要带空格呢？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "并不是这个原因。scanf 不会读取空格。", "referer": "user-2"}]}
{"question": "先学完汇编基础，是否C语言的学习就不成问题了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "汇编更底层吧，C语言和汇编差别还是挺大的，语法也差很多，就当做一门新课程学了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！） 想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。”但我又不得不承认： 有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物； 而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。而我本人属前者。 不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质，而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。 这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！ 提醒：“学习用汇编语言写程序”和“VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。（Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）想要从本质上理解C指针，必须学习C和汇编的对应关系。”不是一回事！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "汇编只对于理解高级语言生成的二进制代码有所帮助，对于高级语言编程并没有什么作用（几乎没有，如果你不使用嵌入汇编的话），二者并非楼房一层和二层之间的关系，只能说类似手工业和工业化大生产之间的关系~", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "也不是全无作用，比如没学汇编之前对C的指针和数组理解不透彻，所有文章都试图用printf解释，越解释越乱。学过汇编就能明白内存长什么样子，数组和指针就自然理解了。", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "不能理解，走路之前为什么一定要先砍一条腿呢？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "每天只有1个小时学习，研究C的汇编代码就没空看书，看书就没空研究汇编。", "referer": "user-4"}, {"cid": "7", "user": "user-4", "content": "问题是一个人只能有一棵技能树，独立于其他人，独特于其他人。 培养树是一辈子的事。 如果你坚持认为浇水施肥捉虫等等事情只能挑着做一件，那是没法培养树的。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "家里养花吗，你真的有时间天天浇水施肥捉虫？大多数时候有浇水就不错了。等退休并且没子女拖累时，才能天天养花。 实际上我们每个人都是偏科的，因为人的精力和时间有限。我40岁，学编程只在坚持活到老学到老的最求。", "referer": "user-4"}]}
{"question": "#求助  在输出数组时不知为何第一个数为0", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的代码第五行是干嘛的？你把它给忘了。", "referer": "user-0"}]}
{"question": "求助！不知道代码哪里出错了，运行不了，求求各位大佬帮忙看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "错误挺多的，首要的问题是，您没写输出有效信息的printf，运行它就不会有可见的结果啊。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "接收輸入&a[i].s改爲a[i].s或&a[i].s[0]", "referer": "user-0"}]}
{"question": "编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/n(利用指针函数)。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "sum+=(float)1/x;", "referer": "user-0"}]}
{"question": "如何实现跨平台、跨硬件读取CPUID等信息？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个是无法做到硬件无关的，好比你要测量每个人老二的大小~", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "可能我的表达有误，我的意思其实是想说，因为不同的架构所以需要不同的指令，应该有代码可以判断或者读取的，只是我似乎搜索不到这样的代码，网上已有的代码千篇一律，只能查INTEL系列的，我只想看哪里能找得到，是LINUX的内核源码吗？", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "CPUID这个词本来就是Intel的私有术语，您不能凭想象把它推广到其他硬件啊。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这么说吧，如果能实现的话，Java还会这么滋润么？", "referer": "user-0"}]}
{"question": "救命啊！！为什么链表尾插数据无法退出循环，不知道哪里出问题，大佬救命！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "while (y != NULL && strcmp(y->bookid, p->bookid) <= 0) {                             yf = y; y = y->next;                         }                         if (y == NULL) { yf->next = p; }                         else { p->next = y; yf->next = p; }  谢谢谢大佬，已解决。y = null 时， y->bookid 已经没有值无法比较while条件前后互换一下&&", "referer": "user-0"}]}
{"question": "请问有哪些书介绍C语言和汇编之间的对应关系？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C编译器都支持生成lst汇编代码并且带对应C源代码注释", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没这样的书，高级语言和低级语言之间不是一对一的关系，而是多对多的干系~", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "我学习了一段时间x86汇编，visual studio的C语言反汇编可以看懂部分。 想要看懂全部，苦于网上资料零碎，希望有书全方位介绍。", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "我觉得作为司机没必要学习发动机制造过程中的金属表面热处理工艺。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "如果您写一本的话，我买一本表示一下支持。", "referer": "user-0"}]}
{"question": "求助！这代码循环结构那里出问题了，但是不知道怎么改,感谢大佬！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for(i=1;i<n;i++) {   for(j=i+1;j<=n;j++)     {    if((p[i].a==p[j].a&&p[i].b==p[j].b) || (p[i].a==p[j].a&&p[i].c==p[j].c) || (p[i].b==p[j].b&&p[i].c==p[j].c))         ans++;     } }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢大佬！！！！！", "referer": "user-1"}]}
{"question": "#求助 fread函数总会读进一些意料之外的字符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Line 47把info当作字符串输出，但是从文件读出的info的内容是没有'\\0'结尾的，所以，printf函数会越过info的边界继续输出字符，直到遇到'\\0‘。而内存中info后面的内容是随机的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "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": "3", "user": "user-3", "content": "fread本来是用来读二进制文件的，整个读结构体数组什么的很方便。你偏要用他读文本文件当然是各种别扭了。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "想象一下给汽车去掉方向盘装上自行车车把的效果。", "referer": "user-3"}, {"cid": "5", "user": "user-0", "content": "确实，很不方便", "referer": "user-3"}, {"cid": "6", "user": "user-4", "content": "有可能是文件编码的一些问题，或者是out.txt末尾有不可见字符。如果在out.txt随便加入一些中文字符，程序的输出是？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "我另起一行加了个“你好“，输出结果里没有中文字符，但是有更多的乱码 具体结果是这样的： Sum is: 33 Sum is: 45 浣犲ソ LOGONSERVERn?萬", "referer": "user-4"}, {"cid": "8", "user": "user-4", "content": "首先确定out.txt的编码是Windows的缺省编码。notepad点击另存为，它显示的编码是Ansi吗？ 如果是其他编码，就会出现中文打印乱码的情况。 另外，在get_info()里面，建议里面的代码改成： char* get_info(FILE*fp) { \tint size=tell_len(fp); \tchar*info= (char*)malloc(sizeof(char) *size + 1); \t.....  \tfread(info,size,1,fp); \t// print %s 打印时， 字符串需要0结尾 \tinfo[size] = 0;      rewind(fp); \treturn info; }", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "out 的编码是utf-8不是ANSI", "referer": "user-4"}]}
{"question": "我正在参加年度博客之星评选，请大家帮我投票打分，您的每一分都是对我的支持与鼓励。\nhttps://bbs.csdn.net/topics/611386885?spm=1001.2014.3001.69", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "已5星，欢迎回访！诚信互评⭐⭐⭐⭐⭐http://t.csdn.cn/KMfwt已5星，欢迎回访！诚信互评⭐⭐⭐⭐⭐http://t.csdn.cn/KMfwt已5星，欢迎回访！诚信互评⭐⭐⭐⭐⭐http://t.csdn.cn/KMfwt", "referer": "user-0"}]}
{"question": "2022年「博客之星」参赛博主：1 + 1=王", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐：https://bbs.csdn.net/topics/611386885", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "已支持， 五星互访 https://bbs.csdn.net/topics/611390868", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "# 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "已回投", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "https://bbs.csdn.net/topics/611390422 ， 已五星好评，谢谢！", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "欢迎一起互访五星！https://bbs.csdn.net/topics/611390545", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "欢迎一起互访五星！！https://bbs.csdn.net/topics/611387550?spm=1001.2014.3001.6953", "referer": "user-0"}, {"cid": "10", "user": "user-9", "content": "已五星支持，http://t.csdn.cn/4YvCK", "referer": "user-0"}, {"cid": "11", "user": "user-10", "content": "⭐⭐⭐⭐⭐诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611387545⭐⭐⭐⭐⭐五星后,请留下链接🔗,必回访⭐⭐⭐⭐⭐", "referer": "user-0"}, {"cid": "12", "user": "user-11", "content": "已五星，欢迎回访https://bbs.csdn.net/topics/611390140", "referer": "user-0"}, {"cid": "13", "user": "user-12", "content": "已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2 已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2  有🧧领 ✨✨✨✨✨", "referer": "user-0"}, {"cid": "14", "user": "user-13", "content": "已投，诚信五星，五星必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X欢迎互访五星评论互投必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X", "referer": "user-0"}, {"cid": "15", "user": "user-14", "content": "已投诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261", "referer": "user-0"}, {"cid": "16", "user": "user-15", "content": "已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531", "referer": "user-0"}, {"cid": "17", "user": "user-16", "content": "已5星，http://t.csdn.cn/Xr6pq", "referer": "user-0"}, {"cid": "18", "user": "user-17", "content": "五星支持，原力7级，欢迎互投https://bbs.csdn.net/topics/611387935", "referer": "user-0"}, {"cid": "19", "user": "user-18", "content": "五星已评！⭐⭐⭐⭐⭐满级原力最高加分互相五星支持！欢迎回访：https://bbs.csdn.net/topics/611389757", "referer": "user-0"}, {"cid": "20", "user": "user-19", "content": "已五星 https://bbs.csdn.net/topics/611388380?utm_medium=notify.im.notify-business-fans.16584a08e070f000.a&username=wnn654321", "referer": "user-0"}, {"cid": "21", "user": "user-20", "content": "已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126 已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126", "referer": "user-0"}, {"cid": "22", "user": "user-21", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐ https://bbs.csdn.net/topics/611388731", "referer": "user-0"}, {"cid": "23", "user": "user-22", "content": "已五星支持。 https://bbs.csdn.net/topics/611389981", "referer": "user-0"}]}
{"question": "2022年「博客之星」参赛博主：1 + 1=王", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐：https://bbs.csdn.net/topics/611386885", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "已支持， 五星互访 https://bbs.csdn.net/topics/611390868", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "# 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "已回投", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "https://bbs.csdn.net/topics/611390422 ， 已五星好评，谢谢！", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "欢迎一起互访五星！https://bbs.csdn.net/topics/611390545", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "欢迎一起互访五星！！https://bbs.csdn.net/topics/611387550?spm=1001.2014.3001.6953", "referer": "user-0"}, {"cid": "10", "user": "user-9", "content": "已五星支持，http://t.csdn.cn/4YvCK", "referer": "user-0"}, {"cid": "11", "user": "user-10", "content": "⭐⭐⭐⭐⭐诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611387545⭐⭐⭐⭐⭐五星后,请留下链接🔗,必回访⭐⭐⭐⭐⭐", "referer": "user-0"}, {"cid": "12", "user": "user-11", "content": "已五星，欢迎回访https://bbs.csdn.net/topics/611390140", "referer": "user-0"}, {"cid": "13", "user": "user-12", "content": "已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2 已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2  有🧧领 ✨✨✨✨✨", "referer": "user-0"}, {"cid": "14", "user": "user-13", "content": "已投，诚信五星，五星必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X欢迎互访五星评论互投必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X", "referer": "user-0"}, {"cid": "15", "user": "user-14", "content": "已投诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261", "referer": "user-0"}, {"cid": "16", "user": "user-15", "content": "已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531", "referer": "user-0"}, {"cid": "17", "user": "user-16", "content": "已5星，http://t.csdn.cn/Xr6pq", "referer": "user-0"}, {"cid": "18", "user": "user-17", "content": "五星支持，原力7级，欢迎互投https://bbs.csdn.net/topics/611387935", "referer": "user-0"}, {"cid": "19", "user": "user-18", "content": "五星已评！⭐⭐⭐⭐⭐满级原力最高加分互相五星支持！欢迎回访：https://bbs.csdn.net/topics/611389757", "referer": "user-0"}, {"cid": "20", "user": "user-19", "content": "已五星 https://bbs.csdn.net/topics/611388380?utm_medium=notify.im.notify-business-fans.16584a08e070f000.a&username=wnn654321", "referer": "user-0"}, {"cid": "21", "user": "user-20", "content": "已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126 已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126", "referer": "user-0"}, {"cid": "22", "user": "user-21", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐ https://bbs.csdn.net/topics/611388731", "referer": "user-0"}, {"cid": "23", "user": "user-22", "content": "已五星支持。 https://bbs.csdn.net/topics/611389981", "referer": "user-0"}]}
{"question": "#求助 Python", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把代码重新发一下，方便查看 m=3 while m<10:     n=2     while n<=m-1:         if m%n==0:             break         if n==m-1:             print(m)         n+=1     m+=1  这段代码是打印<10的质数把，因为当m=6时，n从2到5循环，测试是否 m%n==0,由于6%2==0, 会执行break,所以不会打印出来  想知道满足了if语句，那么n+=1还需要执行吗？  当 m%n==0时，会执行break, 跳出 while n<=m-1: 的循环，不会执行n+=1否则会执行", "referer": "user-0"}]}
{"question": "为什么c的程序运算结果不对？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这里错了：scanf(\"%d %d &d\",&a,&b,&c); 应该是：scanf(\"%d%d%d\",&a,&b,&c);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "printf(\"请输入3个整数：\");   scanf(\"%d%d%d\", &a, &b, &c);   if (b > c) c += b -= c, b = c - b;   if (a > b) b += a -= b, a = b - a;   if (b > c) c += b -= c, b = c - b;   printf(\"max = %d, min = %d, median = %d\\n\", c, a, b);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "max太多余了，把max删了", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "在scanf后把三個值都打出來就知道是哪的問題啦。懷疑是最後那個%d沒改，還是寫&d。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "scanf(\"%d %d &d\",&a,&b,&c); 改为   scanf(\"%d%d%d\",&a,&b,&c);", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "改了也不对的。我输入 3 5 9，结果显示最大值为5。", "referer": "user-5"}]}
{"question": "C语言fscanf无法将N赋值（一直都是0）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "用 vc2008 编译执行了，有结果：6.0， -1.0, 1.0 。那，可能是你的 data.txt 不对，不是 ascii 格式？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "也可能是文件存放的路径不对。 VS的运行环境，当前路径是项目目录，不是exe所在目录。 总之是不知道文件打开成功没有。", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "我是用dev写的", "referer": "user-1"}]}
{"question": "有没有大佬帮我看看这个基础链表（萌新求助，人已裂开？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "struct data* p1 = new (struct data);  这个，去掉开头的 struct data* 否则是又定义了个新的变量 p1 和前面的不是一个变量，所以两处的 p1 是不一样的，就不对了。", "referer": "user-0"}]}
{"question": "清空数据栈的参数为什么可以是地址也可以不用地址", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "那个是引用，不是地址。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "嗷嗷，那为什么引用和不引用都可以压，数据栈的清空有指针变化不应该只有引用可以吗", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "画面上没有证据表明可以，是你自己说可以的。", "referer": "user-0"}]}
{"question": "求助大佬   为什么输出的结果不对？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf() 里的第三个多了个 % 是两个了：%%d", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "看到了", "referer": "user-1"}]}
{"question": "这个代码的分析结果是啥呀", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先来看一下C语言的运算优先级：   #include<stdio.h>  int main()  {     //定义数组     int a[]= {2,4,6,8,10};      //定义指针p指向数组a     int *p=a;      //指针p指向的数组元素为2，这里是(*(p++))     //实际上p++是表示指针p+1了但是返回的还是+之前的值     //再对这个值*引用，所以就是2     printf(\"%d\\n\",(*p++));      //上一行代码已经让p + 1了,这里指针p先运行(++p)指针+1     //然后在用*引用，也就是*(p + 2)的值     printf(\"%d\\n\",(* ++p));      //接着又先进行++p操作此时p指向的是8，但是执行的是(* ++p)++     //也就把8加一，只不过返回的还是8     printf(\"%d\\n\",(* ++p)++);      //实际上8+1=9     printf(\"%d\\n\",*p);     return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "指针的花花，头疼；结果是啥，先自己看看琢磨琢磨呗，结果记下来，再编译了运行下，看和自己的一样否。", "referer": "user-0"}]}
{"question": "大佬们，C语言怎么对sqlserver实现增删改查", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C DAO/ADO SQL", "referer": "user-0"}]}
{"question": "求大佬帮帮孩子写一条小小的代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "百度一搜一大堆", "referer": "user-0"}]}
{"question": "求助大佬  为什么程序有时运行结果正确，有时又不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "m, n, x, y 都没有初始化，遇到首单元就是最大或最小的，就不对了；另外，最大和最小，可以一个循环。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢大佬，懂了", "referer": "user-1"}]}
{"question": "printf 打印总是乱码？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看上面图，那些 FF 应该是单字节被符号扩展到了双字的缘故。加密对否，可以和标准的代码的结果比较，也可以用解密模块解密下看看是否还原。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "aes加密？加密后的数据，本来就是乱的啊；不乱的加密，往往只是简单的替换，强度在计算机面前近乎 0", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不是我的意思是说，即使是乱码，应该也是ASCII码不是?然而返回的并不是啊", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "应该也是 ascii? 哪来的说法? aes 是 16字节一组进行的，结果是可能任何的 16字节数据，且是一个整体，'abc' 加密了后，不可能只是 'xyz' 。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "我基础差啊，所以大侠，请假下如何屏幕打印这些字节码，以验证加密后的字符串数据是否正确？", "referer": "user-1"}]}
{"question": "求助，字符串大小写转换的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "明白你的問題在哪啦，把c[ temp - 47]刪掉就可以啦。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "if ( n[i]<'0' || n[i]>'9' )   continue; temp = n[i] - '0'; if ( c[temp] >= 'a' && c[temp] <= 'z' )     c[temp] &= 0x5f; if ( c[temp] >= 'A' && c[temp] <= 'Z' )     c[temp] != 0x20;", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "哦，第二个if前应该加上 else", "referer": "user-1"}, {"cid": "4", "user": "user-0", "content": "thanks 我看看", "referer": "user-1"}, {"cid": "5", "user": "user-0", "content": "你好，我想再请教一下，按位与计算的思路是怎么来的呢？（位运算不太了解有什么用（（（", "referer": "user-1"}, {"cid": "6", "user": "user-2", "content": "竟然没看懂题意，输入的数字字符串怎样用，大小写变换的依据是", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "大小写转换的依据就是后面输入的数字，如果输入1那就是将字符数字中c［1］位转换大小写", "referer": "user-2"}, {"cid": "8", "user": "user-3", "content": "或许是对题目的理解有误。这个事儿很常见。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "但是我的代码执行结果跟我的预期也有出入，我想知道为什么", "referer": "user-3"}, {"cid": "10", "user": "user-3", "content": "那两个函数是处理字符串的，不是处理字符的，用在这里不合适。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "但是我如果取地址的话，不应该也相当于字符串吗？", "referer": "user-3"}]}
{"question": "请问这段代码应该怎么理解？（c语言初学者）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "递归求斐波那契数列吧", "referer": "user-0"}]}
{"question": "求解：c语言矩阵置。急急！求求！谢谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "将25行printf(\"% 3d \",num1[i][j]);改成了printf(\"   %d\",num1[i][j]);或者printf(\"%4d\",num1[i][j]);就可以了；字符里面的空格运用不当。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "%4d就占4字節啦", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "改成4运行的时候，第一列占4个宽度，第二、三列占5个宽度。", "referer": "user-1"}, {"cid": "4", "user": "user-0", "content": "已解决，谢谢。", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "所以你在格式串里写空格的目的是什么？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "对空格的运用不准确，已修改，谢谢。", "referer": "user-2"}]}
{"question": "初学者 不会用xcode", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先搞清楚打不开的是哪个。", "referer": "user-0"}]}
{"question": "求助,C语言关于如何得到数组存放元素的个数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你自己用常量记下数组的大小就可以了：    const int len1=3, len2=3;    int num1[len1]={1,2,3};    int num2[len2]={1,2,3};C因为是基础语言，很多语法糖都省略了，所以不是很适合用于开发应用软件，尤其是事务处理型软件，比如说连函数重载都不支持，不是做不到，而是为了追求简单灵活。一个C编译器，最小可以只用不到100KB源码实现，而C++编译器，比如gcc，光是前端语法解析部分，parser.c，就有12MB大小~", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "思维习惯不对呀，C里面的数组你就永远不应该企图“获取”它的大小，因为它的大小是由程序员主观意志决定的。换句话说是先有大小后有数组的。这么说吧，假如是上帝创造了人，那么上帝怎么可能需要数一数才知道人有几个手指头呢？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢回复，我才开始学习C语言，感谢提醒。", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "C语言不象java,c#这些， 数组可以通过length属性获取个数，在C中，静态分配的数组，比如: int num1[3], 可以通过 sizeof(num1)/sizeof(num1[0])  获取数组的大小动态分配的数组，比如: int* num2; num2=new int[1000]; 则程序需要自己记住分配的大小至于为什么while... 有可能得不到正确的结果， 是因为，在内存中，1,2,3  后面有可能是任何其它数据，比如：1,2,3, 0   这种可以正确获得大小，但，如果是其它，就会出错。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢回复，我后来了解到num[3]并不是直接是的给了3个位置存放数字，就算打印num[3],num[4]也会出现结果的，但是我并不知道为什么会出现这种情况。", "referer": "user-3"}, {"cid": "6", "user": "user-3", "content": "建议从一些基础的了解开始， 比如 blog.csdn.net/weixin_55305220/article/details/116665000   当然， 适当的了解点 系统结构，数据结构 也会些帮助，网上也有很多这些资料， 加油！", "referer": "user-0"}]}
{"question": "怎么使下面的代码可多次查询", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "图中最后的 break 改为和上面一样的 continue ？", "referer": "user-0"}]}
{"question": "result = (unsigned char*)calloc(length, 1); 的calloc使用困惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "函數調用改爲other_function(&resule)，函數體內也做相應修改，調用free前要判斷指針是否爲空。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没有问题啊，如果有问题那就是其他的问题，不是申请内存的问题。所以您没有问到点儿上。", "referer": "user-0"}]}
{"question": "求助，c语言程序运行超时", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "简单一点： double funcos(double e, double x) {   double f, i, v, xx, y;    for (f = i = 2, xx = x * x, x = -xx, y = 1; ; i += 2)   {     y += v = x / f, f *= (i + 1) * (i + 2), x *= -xx;     if (abs(v) < e) break;   }    return y; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <math.h> double funcos( double e, double x ); int main() {     double e, x; scanf(\"%lf %lf\", &e, &x);     printf(\"cos(%.2f) = %.6f\\n\", x, funcos(e, x));     return 0; } double funcos(double e,double x) {     int i=2,j,t=1;     double a,sum=0;     if(x<e)         sum=x;     a=x;     while(a>e||a<(-e))     {         sum=sum+a;         for(j=1;j<=i;j++)             t=t*j;         a=-(pow(x,i)/j);         i=i+2;         return sum;     }     return sum;   }  注意while循环用法，你的代码while无限循环了，用break、continue、return退出", "referer": "user-0"}]}
{"question": "新人求大神解答呀 ，这段代码到底哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if（b==0 && a>=1）时即可", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "首先是if行末尾有个多余的分号。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "大神 请指点下还有啥地方是错的吧 或者逻辑哪里不对 感谢了", "referer": "user-2"}]}
{"question": "C语言字符串存储问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "还记得HelloWorld么？", "referer": "user-0"}]}
{"question": "我的这段代码软件没有报错，但是调试时有一段直接跳过了（我在VS调试的）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%d\\n\"...  格式里，别有 \\n 吧，如 scanf(\"%d\", &_S1);", "referer": "user-0"}]}
{"question": "求求大佬帮忙，为啥读文件读不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "程序中存在的问题：ReadLine()里面又调用 CountLine(), 程序会比较慢string.find()  返回的是 size_t , -1 表示没找到，C语言中， 只要不是0就返回true, 所以，程序的判断是否会有问题？另外，if (a.find(\"link\"&&\"code\")),  \"link\"&&\"code\" 表示的是？ 字符串连接是用 \"link\" + \"code\",  还是应该是:?        if (a.find(\"link\")!=string::npos && a.find(\"code\")!=string::npos)如果test.txt里面是Link , Code, 代码也应该做相应大小写改动。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "“只能读取第二个以后的”，什么意思？上面的代码运行了，可以完整显示 test.txt 的内容啊；内容再复制一份，照样能显示所有的。", "referer": "user-0"}]}
{"question": "将一个数拷贝到字符数组中，结果多出六个f,是怎么回事？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为类型提升，ca[0]被作为int传入，char默认是有符号数，所以0x83被符号扩展为0xffffff83。可以：sprintf_s(str, sizeof(str), \"%x\", (unsigned char)ca[0]);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "都是字符型拷贝到字符型，类型怎么会提升？", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "传入sprintf_s的参数做了类型提升，参考printf、sprintf的说明：https://en.cppreference.com/w/cpp/io/c/fprintf", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "不是多出，是0x66按照字符理解就是'f'", "referer": "user-0"}]}
{"question": "图形打印 求助各位大佬帮帮忙解答一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "思路如下:双重for循环,j表示次数,j小于等于i，i小于等于n,然后在j循环李打印i就行了，记得换行", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "思路，就是循环啊，一行行的是外循环，行内的几个字符是内循环；其它的就是输入和输出函数。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "能不能写一下，不太明白", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "麻烦说说设计思路", "referer": "user-0"}]}
{"question": "我想问一下，a, *a, a[0]这种，为什么不输出他指向的内存单元，而都是输出地址", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "CPU只认地址不认标识符，CPU根据地址访问与其建立映射关系的物理内存，读写数据。你写得源代码中的一切变量名、函数名等等标识符，都仅仅只是你自己的设想。你的源代码要变成可执行程序，最终要经过编译器编译，将它翻译成CPU可识别的指令流程编译器中的符号表数据结构会收集你源代码中的标识符，然后把它们转换成相对进程基址的偏移地址可执行文件相当于是一个进程的内存模板，它描述了进程的内存分布和初始值所有你源代码中的变量名在可执行程序中都是一个地址", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "子曰：吾日！三省吾身～～～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "子曰，思而不学则殆。", "referer": "user-0"}]}
{"question": "如果全部及格则输出没有不及格的科目，应该怎么改，请教大佬，部分程序如下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "一般是增加个变量吧，查询前初始化为 0，后面查询到个不及格就 +1，最后看是否为 0 ；也可用逻辑类型的。", "referer": "user-0"}]}
{"question": "同样的C代码，不同的编译器生成的汇编代码是不同的吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "對200多字節都覺得誇張的話改用匯編吧。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "即便同一个编译器，不同编译选项，生成的代码也不能保证相同。至于楼主的代码，只是debug版本，如果是release版本，至少a, b都会被优化掉。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "现代计算机平台上，两百多字节真不算大，咱不能拿单片机和1980年的计算机来与现代比较。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "C语言不是简洁快速体积小吗？怎么没事还要搞掉那么多栈空间？", "referer": "user-3"}]}
{"question": "第一个判断能计算并排序，但是第二个往后就排序不了了，都是套用的不知道为什么后面的排序不了，求大神指点，部分程序如下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该是 for(j=41; j<81-i+41; j++)  吧，要加上首单元序号的，上面的是 0 就可以不加了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1"}]}
{"question": "用for循环结构变成死循环了，不知道怎么解决，求大神指点，部分程序如下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if(j=2) 应该是 if(j==2) 吧，下面的类似；j=2 是赋值了，j 跳不出去的。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1"}]}
{"question": "总感觉myFun函数调用后，变量a没有被赋值或者变量a就没有传进去。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要止步于感觉呀，验证一下。", "referer": "user-0"}]}
{"question": "【C语言有问题看过来这里】有问必答。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "有问题看过来这里啊！", "referer": "user-0"}]}
{"question": "C语言求助（这个只是部分正确）求求各位大佬帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "t未初始化。", "referer": "user-0"}]}
{"question": "为什么在函数里sizeof（a）（a是数组）是8而不是4", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你但凡不那么细心地切图，就能看见上方某处有x64或amd64字样。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我去看看", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "这是我的图片", "referer": "user-0"}]}
{"question": "删除字符串中第m个字符哪位大神帮我看看哪里不对c语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "前面定義char s[10] 最多可以用到s[9]，後面卻用到s[50]。", "referer": "user-0"}]}
{"question": "求助大神！！！！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "float Fscore(struct Student stu…) 這個結構名首字母是大寫 函數應該有個return", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "应该是 stu[i].sum += stu[i].score[j]; 吧", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "但楼主自己说的错误应该来源于大小写不分。", "referer": "user-2"}]}
{"question": "求大佬帮助   ！！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把struct test 改成： struct test {unsigned short a :4;unsigned short b :2;unsigned short c :4;unsigned short d :6;};整个struct test占用2个字节， 它每个字段在内存中的位置是： 15 ... .. .... ........ 0ddddddccccbbaaaa注意低位在右边 av->a = 0xf;test: 000....01111 (二进制)av->b = 0x0;test: 不变av->c = 0xf;test: 00...1111001111av->d = 0xf;test: 0011 1111 1100 11113 f c f (16进制)最后输出的时候，是从低地址输出的，所以是cf 3f", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "有可能是因为一些填充的原因，在我的机器上， printf(\"sizeof = %d\\n\", sizeof(struct test))打印的是4， 而不是2建议把程序改成:struct test{        unsigned short a :4;        unsigned short b :2;        unsigned short c :4;        unsigned short d :6;};", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢您的回答，不知道您试过没，结果是一样的， 不知道有一点您有没有注意到，这是bit赋值，添加类型应该没意义吧！", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "你好，如果我没记错的话，unsigned a :4 这里的unsigned 定义了一个unsigned int, struct test最后是 4个字节， 如果改成 unsigned short, struct test 则为2个字节，所以还是有影响的，的确， 程序的最后输出有点晕，可能跟编译器的存放字节顺序有关。。。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "Android-Unity一起交流学习啊", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "位序的问题啊，这个，得看书上怎么说的了，全是规定，搞不好不同平台还不一样", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "位序无非是大端小端，我的平台是小端，不应该出现字节反转的现象啊", "referer": "user-3"}]}
{"question": "请教大神Dev-C++报错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个有点难度看不懂了……", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Android-Unity一起交流学习啊", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "上面提示了啊，Netbios 没定义，大概是少了相应的 .h 文件", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "@是#include \"nb30.h\" #pragma comment(lib, \"netapi32.lib\")", "referer": "user-3"}]}
{"question": "请教，在vs用x64能启动我的代码，用x86不能。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我查到原因了，卡巴斯基误报。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "选择了新模式后，要重新编译创建吧", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "请问如何重新编译，我只知道按F5。", "referer": "user-1"}]}
{"question": "一道编程题不知道为什么输出只能是整型，如何改动", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "i和c沒有初始化", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "循环里加个 printf() 语句，打印每次的 a,b,c 看看就知道了；不知题意，应该是你计算逻辑错了。", "referer": "user-0"}]}
{"question": "求这题怎么做？各位大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Android-Unity，一起交流啊", "referer": "user-0"}]}
{"question": "devc++  指针和数组   最大值和最小值输出后是相反的，但程序看不出问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "实参次序反了嘛。", "referer": "user-0"}]}
{"question": "unsigned long long 返回值为零", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "都是int类型乘积当然也是int类型。把随便哪项强转为结果的类型就好了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "求大佬解答", "referer": "user-0"}]}
{"question": "为啥VS2022 scanf函数用不了，求大佬帮助😘", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "链接选项里加入legacy_stdio_definitions.lib", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "前辈啊", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "看编译输出提示，是不是让你用scanf_s代替？你可以在项目->属性->C/C++->预处理器->预处理器定义中添加_CRT_SECURE_NO_WARNINGS", "referer": "user-0"}]}
{"question": "c语言循环练习，小白求帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>double Power(double x,int n); double Power(double x,int n){    if(x == 0 && n < 0)    {        printf(\"参数不正确\\n\");        return 0;    }    else    {        double y = x;        if(n > 0)        {            while (--n > 0)            {                x*=y;            }        }        else        {             while (++n < 0)            {                x*=y;            }            x = 1/x;        }    }    return x;} int main(int argc, char const *argv[]){   double x;   int n;   scanf(\"%lg%d\",&x,&n);   printf(\"%.8g\\n\",Power(x,n));}", "referer": "user-0"}]}
{"question": "一个函数动态分配一个数组空间为什么要使用指向指针的指针才能实现？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "至于你说的为什么要用指针的指针实现，如果不转这一道函数的话是可以直接用malloc的。涉及到指针的参数传递一级指针的地址就必须要二级指针才能接收", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "malloc和free就是向程序员手动向堆区申请和释放空间，了解堆区和栈区的区别吗？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "我不知道，我作业也是这个，求大佬解答！！", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "建议自己先百度一下，这是一个程序员的基本素质", "referer": "user-2"}]}
{"question": "大佬看看我哪里错了，有一个测试点一直过不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "随机最大n ，是不是没有对输入的 n 进行限定检验啊，预定义的是 100010，输入比这更大的呢？", "referer": "user-0"}]}
{"question": "数据结构二叉树求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*T)->data = data;         //生成根结点         CreateBiTree(&(*T)->lchild);//构造左子树         CreateBiTree(&(*T)->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf(\"%c \",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf(\"%c \",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(&T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}]}
{"question": "VS2012为何没有内存监控画面", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "等程序中断在断点处或单步运行时，再看看。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "正如赵4老师所说啊，感谢感谢！", "referer": "user-1"}]}
{"question": "我看老师讲的while(ture)我的怎么报错 while（1）也不行 求求告诉我", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "true 不是 ture；while(1) 应该可以吧，除非又有其它的笔误", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "package Demo; import java.util.Random;import java.util.Scanner; public class 猜数游戏 { public static void main(String[] args) {     // TODO 自动生成的方法存根  //        生成1-100随机数            Random r=new Random();            int number=r.nextInt(100)+1;            Scanner sc=new Scanner(System.in);            System.out.println(\"请输入猜测数字：\");            int luck=sc.nextInt();     while(ture){           if(luck>number){               System.out.println(\"猜大了\");           }else if(luck<number){               System.out.println(\"猜小了\");           }else{               System.out.println(\"恭喜您 猜对了 请买单~~~\");               break;           }                  }                    }  }", "referer": "user-0"}]}
{"question": "利用指针排序三个数，输出第2和第3个数为何是地址值！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf() 中间的 % 误输入成 & 了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "非常感谢您的指点!", "referer": "user-1"}]}
{"question": "求助float怎么转变成u8啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果数据float data的取值范围在0.0f～255.0f，直接u8 b=(u8)data; 如果数据float data的取值范围在0.0f～65535.0f，u8 b0=((unsigned short)data)%256;u8 b1=((unsigned short)data)/256;以此类推", "referer": "user-0"}]}
{"question": "64位windows 向系统申请40位的内存地址", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "把地址限制在低40bits，想问怎么样才可以申请到符合这种条件的地址", "referer": "user-0"}]}
{"question": "运行程序时崩溃，显示\"program received signal sigsegv，segmentation fault\"怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int n=0;   int a[n]; 的问题？vc 是不支持的，用 DEV-C 看，试了 3个 或 4个数据，没有问题。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我是用的dev写的，好像n输入很小的数是没问题的，但是我输入n=10就出问题了，调试的时候for循环进行到i=9就显示这个错误崩溃了", "referer": "user-1"}]}
{"question": "萌新小白求解c语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。▼  http://bbs.csdn.net/topics/391975224", "referer": "user-0"}]}
{"question": "对数组指针进行解引用，得到数组的地址还是数组首元素的地址呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "既然你把从p到*p称之为退化， 那么很自然你也可以把从*p到&*p称为进化嘛， 进化了就变大了不是很正常么？ 因为变量p的声明中是有5存在的，编译器牢记着这个，所以不是偏偏，而是顺理成章的5 。", "referer": "user-0"}]}
{"question": "c语言递归练习题求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢啦", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "void PrintDec(unsigned x) {   if(x>9)PrintDec(x/10)   putchar(x%10+48); }", "referer": "user-0"}]}
{"question": "学生求助11111111111", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> int suma,sumb; void func(int x){   if(x>0)  suma+=x;   else if(x<0 )  sumb++; } int main(){   printf(\"输入整数:\\n\");   int x;   while(scanf(\"%d\",&x)){     if(x==999)  break;     func(x);   }   printf(\"%d %d\",suma,sumb);   return 0; }  不知道是不是这个意思，没做过这种题（）", "referer": "user-0"}]}
{"question": "性能测试， 进程cpu占用率上不去， 维持在30%左右， 如何分析？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你也说了，单线程工作，也就是每个时刻只占用单核。然后现代的系统怕CPU局部过热，所以使用的单核具体是哪一个物理核这件事是一直在变化的，以维持温度均匀。这就是上不去的原因。在进程级并发的情况下，只要保证你的并发服务进程的数量超过处理器的核数，就能上去了。", "referer": "user-0"}]}
{"question": "c语言关于数组输出问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "gets_s(c, 9); 试试？ 这个函数对字符、字符串类要求跟随有最大长度参数的。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "可能是没有把数组所有单元都置 0 而只是首个", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不是，我试了一遍，我输入8个字符最后就有个问号，输入其他个数的字符就不会", "referer": "user-1"}, {"cid": "4", "user": "user-0", "content": "我是一个大一小白，刚学c语言", "referer": "user-0"}]}
{"question": "为什么没有进行操作，但是变量的值自己在变化。万分感谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "count++递增了count的值，count怎么能不变呢", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "还没执行到那就停下来了，在停着的时间里，count 还在变化；直接运行应该是没问题的。", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "你怎么确定没有执行，count 值变化代表程序在运行", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "楼主上面图示的和文字叙述的很清楚啊，执行到 &lt;font color=blue&gt;int i=3;&lt;/font&gt; 就停下来了，没再继续；然后，偶尔地，光标移动到 count 上，就会提示当前的 count 值，这个值慢慢地就会变；如果 count 加到查看里，那里的内容是不变的，但删除了重加，就是变化后的值；count 实际是变了的，再运行下去，后面程序会出错，因为大于 1 的是无效的。", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "挺好奇的，想着也不会是无中生有，就去下载了个 gcc 来在虚拟机上安装了，把上面的代码敲了进去，折腾了一番，好像还真是哦。用 windbg 打开生成的 exe 程序文件，是正常的；所以，要么这 gcc 的调试功能有问题，要么就是哪里设置有不对，我对 gcc 也不熟，所以无从解决了，主要是它不能和 vs 似的可以切换到汇编码状态，对 count 内存进行写入断点设置，这样可以抓住哪里向 count 写入的。另外，上面的代码是有问题的，main() 里的 if() 行最后不应有大括号，i++; 语句应该是和 if() 语句平齐的，再下来的 for() 的后面就多了一个大括号。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "好的，谢谢，错误的地方还没改，就是这个count乱跳导致无法去调试。", "referer": "user-2"}, {"cid": "7", "user": "user-0", "content": "我看了一下，我截图完之后已经改掉了。谢谢", "referer": "user-0"}]}
{"question": "为什么必须要换行才能用EOF停止程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf（）这个函数是有返回值的，返回值是它接收的格式化字符的个数（%d算一个）“ctrl + z”可以认为是取消输入，如果不输入，scanf 就没有接收值，编译器就会返回  -1循环里的 -1 != -1 判断为假就会退出循环", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "while((scanf(\"%d\",&a)) == 1)", "referer": "user-0"}]}
{"question": "为什么编译通过进不了函数，红色的那个", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为e的类型不是QElemType", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "请问应该怎么修改啊", "referer": "user-1"}]}
{"question": "小白求解，为什么不输出结果呀？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0"}]}
{"question": "救命，C语言，图书管理系统，不用链表", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "链表只是一种数据组织形式，还有很多其它的，比如用数组。", "referer": "user-0"}]}
{"question": "求助各路大佬，for循环判断后不执行for下{}中的语句直接开始循环，循环完才往{}中走", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for() 那行最后多了个分号 ; 前面好像有贴有类似问题的", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢大佬，现在行了。我还专门去人家博客贴了一个同样的来运行，也是一样的结果就不知所以然了哈哈", "referer": "user-1"}]}
{"question": "结构体里的指针是字符，怎么改才可以可以输入整型？（小白）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "\"%d%d\" 后面少了个分隔的逗号", "referer": "user-0"}]}
{"question": "求大佬带带我这个初学者", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://jingyan.baidu.com/article/6d704a134d9c4e28da51ca4d.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://blog.csdn.net/goldenhawking/article/details/119845838 如果是VC应该要在项目属性设置里配置C++/ include ，Link/Library 等属性。", "referer": "user-0"}]}
{"question": "请教C语言宏定义 函数 问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://blog.csdn.net/qq_27898413/article/details/121291412", "referer": "user-0"}]}
{"question": "请教一个关于指针的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "A(*buffer,buff_cnt) {}B(*buffer,count) {   A(buffer,count);}", "referer": "user-0"}]}
{"question": "这道题怎么实现输出c位小数，还有题目中说的数据陷阱是什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  int main(int argc, char * argv[]) {     int a = 0, b = 0, c = 0, i = 0;          scanf(\"%d,%d,%d\",&a,&b,&c);     printf (\"\\n%d/%d=%.14lf\\n\",a,b,1.0*a/b);     if (b==0)         return 0;     int array[103];     do      {         int d = a / b;         int e = a % b;         array[i] = d;         a = e;         a *=10;             }while (i++ <= c+1);          if (array[c+1]>=5)     {         i = c;         do{             ++array[i];             --i;         }while (i>=0 && !array[i]);     }          for (i = 0; i<=c;++i)     {         printf (\"%d\",array[i]);         if (!i)             putchar('.');     }          return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "呵呵请注意 c<=100   double哪儿来的那么高的精度？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "題目并不是要自己做除法函數，儘管題目寫著c<=100，實際并不要求考慮c是否超double精度的問題。", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "题目中的表达不是输出c位小数，而是精确到小数点后c位。", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "陷阱，估计说的是（double）", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "char fmt[8] = {0};  sprintf(fmt, \"%%.%df\"，c); printf(fmt, (double)a / b);", "referer": "user-0"}]}
{"question": "有关调用函数实现大小写改变的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为scanf看见空格就认为输入结束了。", "referer": "user-0"}]}
{"question": "恳请各位大佬帮我看看这该怎么处理？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "那两个白色的a应该就是输入输出吧，程序应该都执行完了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "输入 a 运行程序？你的源文件是 1.c，生成的执行程序通常是 1.exe 吧，输入一般是输入 1 或 1.exe 运行它。", "referer": "user-0"}]}
{"question": "小白求解，为啥没有输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以去 ask.csdn.net 提问", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第一个if行末有个多余的分号。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-2"}]}
{"question": "有大佬帮我看一下为什么错了吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "异常，被 0 除，可能是 i=0 时作为除数求余引起的吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1"}]}
{"question": "#include\nint main() {\n\tint x = 1, y = 0;\n\tprintf(\"%d\\n\",x-->(x + y));\n\n}", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "求值顺序的问题，先求值x---还是x+y未定义", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "请截个图证明一下dev显示是1", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "看看我的图,我都有点蒙了", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "的确无法解释，懵C中。", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "我已经知道答案了,1&gt;(0+0),x到了大于号右边已经变成0了", "referer": "user-3"}]}
{"question": "【C语言】函数递归的简单理解 &画图理解递归过程_[初阶篇 _学习专用]", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出", "referer": "user-0"}]}
{"question": "求解一道C语言题目.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个挺容易的， 你自己先通关这个  clang.csdn.net", "referer": "user-0"}]}
{"question": "菜鸟求助，简单的问题但我写完就报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "大佬写完代码之后报更高级的错。平衡了么，亲？", "referer": "user-0"}]}
{"question": "新手小白求问（赋值从指针生成整数没有强制转换）的警告该如何解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我觉得你想的，和编译器对你源码的理解可能不一样。你是想把 \"YES\" 或 “NO\" 字符串放进 a[i] 里吧，编译器应该是以为你要放的是指针；这样的话，因为只是 ”YES“ 和 \"NO\" 两个内容，可以用简单的数据标记代替它，放入和取出显示时进行转换，只定义 a[n] 就可以了；一定要把字符串复制进去，首先，空间要保证够或进行检查截断，其次恐怕得用字符串复制函数。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢您的解答，给我提供了一种编译思路，十分感谢", "referer": "user-1"}]}
{"question": "不带别名的struct应该怎么样引用(cgo)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "typedef  struct  A{...}B; 引用它时要么用struct A  xxx要么用B xxx不要混着来。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "你得注意到第一个你说正常的那个其实从未使用带_t的东西。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "去掉带_t的你称为别名的东西的前面的struct就好。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "按照您的说法改动之后，报错变了", "referer": "user-1"}]}
{"question": "fabs返回值是一个奇怪的数值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为你缺少了必要的头文件，因而缺少了必要的原型声明，所以函数值被误以为是整型。", "referer": "user-0"}]}
{"question": "大佬们救救，测试没问题，提交答案错误，hlep！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if (*p[j]>*p[j+1])应改为if (strcmp(p[j]>p[j+1])>0)", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "提交编译错误了。。。", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "不是应该是strcmp（p[j],p[j+1])吗", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "对，我刚才&gt;忘改为,了", "referer": "user-0"}]}
{"question": "求大佬解答一下结果不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "每个 i 循环，k=0;；min=a[0][k]; 要后移到循环外，同时 y=0; ；break; 应在 if 里     for(i=0;i<m;i++)//筛选开始     {         k = 0;         for(j=0;j<n;j++)//寻找每行最大值         {               if(a[i][k]<a[i][j])              {                  k=j;                  a[i][k]=a[i][j];              }              max=a[i][k];         }         min=a[0][k];         y = 0;         for(z=0;z<n;z++)         {             if(a[z][k]<min)             {                 min=a[z][k];                 y=z;             }         }         if(min==max)         {             printf(\"该数组a[%d][%d]有一个鞍点是%4d\",y,k,a[y][k]);             printf(\"\\n\");             o++;             break;         }     }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢啦，大佬可以给个关注位置吗？", "referer": "user-1"}]}
{"question": "调试和运行结果不一样", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "srand() 随机数初始化，time() 返回以秒为单位，这样程序运行时，每次的 srand() 几乎每次都一样，因为循环总共才 9次，跨秒的可能性极小，即使侥幸跨秒，数组里也只会有两不同的数，不会有整体随机的效果（也难个与个都不同）。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "讲解很详细明白了谢谢啦", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "srand(); 应该挪到循环圈外面吧，即 for(i) 之前", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢已经解决了 ，不过这个原因是什么呢？烦请解释一下可以吗？", "referer": "user-1"}]}
{"question": "请问这个代码为什么编译的时候没有输出？跪谢了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "通过简单的变换得出，要使两个表达式同时成立，必须是x比z大10。如x=10,y=0,z=0，或者z为负数，但是循环里y和z都是从1开始的，所以永远找不到能使两个表达式同时成立的数值，自然也就不会运行输出语句了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "x+y+z==10 3x+2y+ z==30 這2個表達式不可能同時成立。", "referer": "user-0"}]}
{"question": "这个哪里出错了  ？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "abs是处理整数的，返回值也是整数。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "浮点需要fabs", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "正常了，谢谢", "referer": "user-1"}]}
{"question": "谁能告诉我，为什么会这样啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这里的C99特性有两点一是随处定义变量二是用变量定义数组大小现在你愉快地使用了这两个特性，换个开发环境不让用了还不明说，就会很懵", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "第一，scanf里面不要带转义字符第二，使用C99特性是有风险的，很可能和你以后考试的环境不符第三，数组下标合法值在0到j-1之间，而且你得写个循环来输入才行", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "为什么scanf里不能带\\n，书上都是这么写的", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "要不您去找找书？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "你可能是看错了，一般是printf打印里面添加\\n换行符，scanf带\\n会存在有一个数据缓存区的问题，scanf遇到换行或者空格就会停止输入", "referer": "user-0"}]}
{"question": "为什么从指定文件取出来结构数组只有第一列是对的，其它列读的都好像是地址。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf(\"Text_Chinese:%s image:%p W:%d h:%d\\n\",        lv_btn_image1[i].btn_text_Chinese , lv_btn_image1[i].btn_image, lv_btn_image1[i].btn_witch, lv_btn_image1[i].btn_hietch);", "referer": "user-0"}]}
{"question": "需要一位千里马！苦等", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "于是我陷入沉思，那么一定有问题，问题在哪儿呢？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "凡是钱能解决的问题都不是问题。——《蜗居》宋思明", "referer": "user-0"}]}
{"question": "C语言新人求大佬帮我看一下这个代码的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这道题还是有些难度的， 上面的程序有可能在： 当m<k时， 存在问题。下面程序抛砖引玉，还请大伙指正。  #include <stdio.h>  int min(int a, int b) {     if(a<b) {         return a;     }     return b; } unsigned long long cnt1(int m, int n, int k) {     if(k>n) {         return 0;     }      int i;     unsigned long long cnt = 1;      int x = min(k,m);     for(i=0;i<x;i++) {         cnt = cnt * (n-i);     }     for(i=k;i<m;i++) {         cnt = cnt * (n - k + 1);     }     return cnt; }  int main() {     int m, n, k;     scanf(\"%d %d %d\", &m, &n, &k);      unsigned long long sum = cnt1(m,n,k);     if (sum==0) {         printf(\"Input Error\");     }     else {         printf(\"%llu\", sum);     }     return 0; } ```c    ```", "referer": "user-0"}]}
{"question": "新人C语言求助，程序没报错，但是运行不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两 for 循环里的 a 或 b 都应该是大写的 A 或 B 吧，除了 int 语句里的：     for (int A=a; A != 0; A=A / 10)     {         e = A % 10;         f = f * 10 + e;     }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "a = a / 10", "referer": "user-0"}]}
{"question": "数据类型求答案，谢谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "0,2,1,15.000000,1.000000,1.500000", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "5,2,1,15.000000,1.500000,0.200000", "referer": "user-0"}]}
{"question": "没有这两个为什么运行是会一直显示error呢?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为你在每次输入完数字之后都会输入一个回车键，而回车键也是一个字符（‘\\n’），会被scanf（“%c”）读取，而‘\\n’ 属于小于'0' || 大于‘9’的范围，所以会输出“error”加getchar函数，或者%*c都是不可取的，得到输出结果应该不是博主想要的建议在第一个if后边加 &&p！=‘\\n’", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "为什么加getchar函数，或者%*c最后结果是我想要的呢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "在每个最后不带\\n的printf后面加fflush(stdout);在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin);另外请检查scanf的返回值。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0"}]}
{"question": "请问这个代码为什么没法运行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我按照你写的能运行啊", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "刚才查了一会，是需要在name后加40，提高它的准确性和安全性，不知道为啥你的可以运行，我的加了这个40后才行", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "你代码里面name后面加了40 啊", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "是在第九行那的name后加", "referer": "user-1"}]}
{"question": "运行问题，求大佬解析", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你试试在在输入的后面加上长度，比如scanf_s(\"%s\",first_name,40);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "可以也，这是什么原理？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "好像是scanf_s就得加这个长度，如果是scanf就不用", "referer": "user-0"}]}
{"question": "第6段改为什么可以使键盘输入如何格式数据，输出结果都是1，2，34", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如此修改，这般输入。", "referer": "user-0"}]}
{"question": "题目 一元二次方程代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在输入数据之前进行 X, x （这两个变量名也值得商榷）计算？这，显然不合逻辑啊。", "referer": "user-0"}]}
{"question": "解一元二次方程，怎么总是显示有两个相等实根啊，求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "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": "输入数据没带逗号造成输入错误。代码里要求逗号分隔输入数据的。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢了，是这样的", "referer": "user-2"}]}
{"question": "c语言有关字符串数据库的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "结束符是'\\0'而不是'/0'所以很难理解为什么能通过编译。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改后后面的乱码消失了，但是输出结果是原s内容，没有显示d之前的字符串", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "编译出错信息都不看的么？ d两边应该是单引号 malloc(strlen(s)+1) 这里和p没啥关系", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "好了！感谢大佬", "referer": "user-1"}]}
{"question": "我想请问一下问出现什么问题了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fab 函数改为 fabs 函数，没有 fab 函数吧。以后发图片，建议用截图的方式，手机拍照可能会拍不清楚，QQ 截图快捷键：Ctrl + Alt + A", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fabs吧", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "undefined reference to 'fab'你的fab没有定义", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "下面的提示，第一行说 fab 不知道是啥，我看了，也不知道是什么函数", "referer": "user-0"}]}
{"question": "大一新生关于最小公倍数问题的不理解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "OJ是不是不能手工输入？scanf(\"%d%d\",&a,&b)!=EOF", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢，已解决，穷举法过于费力，已经改为辗转相除法，谢谢你的回答！", "referer": "user-1"}]}
{"question": "大一新生刚学c语言遇到问题了，问问题求解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "printf(\"%d+%d=%d\\n\",a,b,c);这样是会输出a的值加b的值等于c的值。如果像单纯显示a，b的值是多少的话，直接printf(\"%d %d\",a,b);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "c也可以不需要，直接用a + b、a - b", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "printf(\"%d+%d=%d\\n\",a,b,c);  // 这样的吧", "referer": "user-0"}]}
{"question": "C语言 日期推算：输入当前日期 输出两天后的日期", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "yday = month==2 ? ((year%400==0||year%4==0&&year%100!=0)+28) : ((int)fabs(month-7.5)%2 ? 30 : 31) ;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "很有用，感谢作者帮助！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "很简洁的代码，太厉害了", "referer": "user-0"}]}
{"question": "学习C语言的新手可以在哪里找C语言的练习题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "国家出台的：终身教育平台里面的教程全部免费，看看教学视频跟着做，做好课堂笔记，不懂的就去网上查资料，实在找不到，论坛这么多大神总会有比较热心的大佬点拨一下的；又不是考试，没必要去找练习册；多在论坛看看别人写的东西，看看别人的评论有时候就会有答案了", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "搜索一下OJ", "referer": "user-0"}]}
{"question": "求大佬们帮忙                     ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "（‘a’+'b）2=(97+98)×2=390ab=6×3.4=20.4c/d=10.0÷5=2.0390+20.4-2.0=408.4double类型", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "困难在哪里？", "referer": "user-0"}]}
{"question": "大一新生，学校教python，自学c语言，请问为什么不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> int main (){    int a = 1;    int b;    scanf (\"%d\",&b);    printf (\"%d\",a); while (a<b-1)//先循环后判断 {     a=a+2;     printf (\" %d\",a); } system (\"pause\"); return 0;  }你看看，这样不就行了，没必要判断他的奇数还是偶数", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的谢谢，想错了。。。", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "if ( m % 2 == 1) 吧，不过没意义；else 里的 while (m <= n) 吧，不能写成 =<", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "应该就是n吧 后面你说的是对的，我后来自己注意到了，改成这样了 #include &lt;stdio.h&gt; int main() { \tint n; \tint m = 1; \tscanf(\"%d\",&n); \tif ( n % 2 == 1){         while(m &lt;= n){             printf(\"%d\",m);             m += 2;         } \t\t}else{ \t\twhile(m &lt;= n){ \t\t\tprintf(\"%d\",m); \t\t\tm = m + 2; \t\t} \t \t} \treturn 0; } 但五分只得了2分，说我“检查程序输出格式”", "referer": "user-2"}, {"cid": "5", "user": "user-3", "content": "既然两块里面内容一样，那为什么还要写两遍？ 另外你的输出格式不对，没有空格。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "确实内容一样，当时想错了，但我不太知道哪里没有空格", "referer": "user-3"}]}
{"question": "为什么我运行不出想达到的效果，求解大神", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%d\",&x);while 循环中也要有 scanfif(x == 34) #include  <stdio.h> int  main() {     int  a=34;     int   x;     int  n=0;     printf(\"请输入猜的数字   \");     scanf(\"%d\",&x);     while  (x!=34)     {              n++;         if(x<34)         {             printf(\"小了\\n\");          }         else  {printf(\"大了\\n\");                                       }         scanf(\"%d\",&x);     }      if   (x==34)     {         printf(\"正确\\n\");         n++;      }     printf(\"一共猜测次数为  %d\\n\",n);      return  0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if   (x==34)", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "while(x!=34) 等於34時不會進去while", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "看錯啦", "referer": "user-3"}]}
{"question": "请教各位大神C语言中如何编写&&&&", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "用puts少4个字符~~~", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> int main() {  printf( \"****\\n\" \"****\\n\" \"****\\n\" \"\\n\" \"\\n\" \"\\n\" \"&&&&&&\\n\" \" &&&&&&\\n\" \"  &&&&&&\\n\"  );  return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "没懂什么意思", "referer": "user-0"}]}
{"question": "linux下的container_of宏拿到win下面编译", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "错误列表： typeof  在windows下c中是没有的。宏实现最外层有() 会导致解析错误。这个好解决，删掉最外层括号。", "referer": "user-0"}]}
{"question": "c语言中给变量赋的初值不同有什么影响", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看给谁赋值的。局部变量？ 栈区。char *str=NULL; 和 char *str=\"123\"；。因为要存\"123\"这个常量字符串，编译的固件会比较大。也有可能影响业务逻辑。全局变量? 全局变量初始化为0 会影响这个变量是放到 数据段还是bss段。....", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没啥影响。", "referer": "user-0"}]}
{"question": "萌新应该怎样学习C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C语言教程（附带C语言100例）  http://download.csdn.net/detail/zhao4zhong1/8830817", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "一般情况下，理论强的人，动手不行。实践强的人，动脑不行。我们要理论和实践相结合。既不动手，也不动脑。 =====就是用起来，理论+实践。去github找点简单的项目，看懂了。先模仿，在超越。？", "referer": "user-0"}]}
{"question": "大一新生求教！！！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你先推导它的表达式，然后就简单了。", "referer": "user-0"}]}
{"question": "【Linux】不得不掌握的开发工具 —— vim", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "TSEPro11_Setup.exe 百万军中取上将首级如探囊取物， 千万行里改关键源码在弹指瞬间。 功能超强的程序编辑器！  https://blog.csdn.net/zhao4zhong1/article/details/126596717", "referer": "user-0"}]}
{"question": "动态内存管理（malloc,calloc, realloc）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "收藏大佬文章了，大佬支持下我呗，感谢：https://bbs.csdn.net/topics/611387347", "referer": "user-0"}]}
{"question": "冲冲冲冲冲冲冲冲冲冲冲冲冲冲冲冲冲冲冲冲冲", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这是什么情况", "referer": "user-0"}]}
{"question": " 求解C:\\Users\\59659\\Documents\\C-Free\\Temp\\未命名4.cpp:11: error: case label `'+'' not within a switch", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "switch(c) 后面不应该有那个分号 ; 吧", "referer": "user-0"}]}
{"question": "运行卡死了，求助zsbd", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你觉得好奇，于是决定租一块地，种四颗double菜尝试一下。地主（系统）租给你一块地，在地头打了个桩子上面写着p_d然后你看看你都干了啥？你种地你收获这都没啥说的。你悄悄把桩子挪了个位置，然后企图把地还给地主的时候，地主揍了你。还觉得冤吗，亲？", "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-0", "content": "那如果我只是把桩子挪了个位置，会产生哪些影响呢", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "p_d都+=1了，就不能再delete[] p_d了", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "可以详细解释下吗，我刚学这个看不懂谢谢", "referer": "user-2"}, {"cid": "7", "user": "user-2", "content": "new返回的内容在delete的时候不能变，您应该另外用一个变量比如p_d_old记住p_d刚刚new返回的值，delete[] p_d_old而不能delete[] p_d，因为你已经使用p_d+=1改动了p_d的值。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "谢谢", "referer": "user-2"}]}
{"question": "cmake 怎么指定所有源目录", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "百度搜“跟我一起写MakeFile”", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "makefile我会  太麻烦 没有cmake方便 现在我都用cmake", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "makefile指定目录我会", "referer": "user-0"}]}
{"question": "为什么这个while 循环只进行了一次？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "k=0", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "while(scanf(\"%d\",&num))把数字输入完成后，最后再输入一个非数字字符作为结束。    for(j=0;j<n;j++)  //不是j<=n    {        printf(\"% d\",list[j]);        sum += list[j] ;    }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "while((scanf(\"%d\",&num)!=EOF)) 显示偶数的循环，应该是 list[j]", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢！！", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "scanf(\"%d\",&num)", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢，但是我试了一下还是循环不了", "referer": "user-4"}, {"cid": "7", "user": "user-5", "content": "有没有一种可能，除此之外还有其他错误？", "referer": "user-0"}]}
{"question": "这个三角型怎末输出啊，我输出的正好反了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我总是在说：代码不是2nd~ #include <stdio.h>  int main() {   for (int n, i = (scanf(\"%d\", &n), 1); i <= n; i++, puts(\"\"))   {     for (int j = 0; j < n - i; j++) printf(\"   \");     for (int j = 1; j <= i; j++) printf(\"%3d\", j);   }        return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "看要求的模样，输出数据前，不应该是要输出相应的空格的吗，(10-i) 个 printf(\"   \");", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h>  int main() {     int N;     int a;      scanf(\"%d\", &N);       for (int i = 1; i <= N; i++) {         a=i;         while(a<N){             printf(\"   \");//空格的数量根据 \"%3d\"，是3就3个空格，是4就四个空格              a++;         }         for (int j = 1; j <= i; j++) {             printf(\"%3d\", j);         }         if (i < N) {             printf(\"\\n\");         }     }     return 0; }", "referer": "user-0"}]}
{"question": "C语言编写计，要满足下列条件算器", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #pragma warning(disable:4996) /*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console) 功能： 目前提供了10多个常用数学函数: ⑴正弦sin ⑵余弦cos ⑶正切tan ⑷开平方sqrt ⑸反正弦arcsin ⑹反余弦arccos ⑺反正切arctan ⑻常用对数lg ⑼自然对数ln ⑽ｅ指数exp ⑾乘幂函数^ ⑿向上取整ceil ⒀向下取整floor ⒁四舍五入取整round ⒂取符号sign ⒃取绝对值abs 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率Pi键入字母时不区分大小写,以方便使用。 16进制整数以0x或0X开头。 ----------------------------------------*/ #include <stdlib.h> #include <string.h> #include <ctype.h> #include <math.h> #include <stdio.h> #include <string.h> #include <locale.h> #include <windows.h> const char Tab = 0x9; const int  DIGIT = 1; #define MAXLEN 16384 char s[MAXLEN],t[MAXLEN], *endss; int pcs = 15; FILE *fp; double sign(double dVal) {          if (dVal>0.0) return  1.0;     else if (dVal<0.0) return -1.0;     else               return  0.0; } double round(double dVal, short iPlaces) {//iPlaces>=0     char tmp[30];     double dRetval;      sprintf(tmp, \"%.*lf\", iPlaces, dVal);     sscanf(tmp, \"%lf\", &dRetval);     return (dRetval); } double fun(double x, char op[], int *iop) {     while (op[*iop - 1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>         switch (op[*iop - 1]) {         case  7: x = sin(x);    (*iop)--; break;         case  8: x = cos(x);    (*iop)--; break;         case  9: x = tan(x);    (*iop)--; break;         case 10: x = sqrt(x);   (*iop)--; break;         case 11: x = asin(x);   (*iop)--; break;         case 12: x = acos(x);   (*iop)--; break;         case 13: x = atan(x);   (*iop)--; break;         case 14: x = log10(x);  (*iop)--; break;         case 15: x = log(x);    (*iop)--; break;         case 16: x = exp(x);    (*iop)--; break;         case 17: x = ceil(x);   (*iop)--; break;         case 18: x = floor(x);  (*iop)--; break;         case 19: x = round(x,0);(*iop)--; break;         case 20: x = sign(x);   (*iop)--; break;         case 21: x = fabs(x);   (*iop)--; break;         }     return x; } int isKMG(char c) {     if (c=='k'||c=='K'||c=='m'||c=='M'||c=='g'||c=='G') return 1;     return 0; } double calc(char *expr, char **addr) {     static int deep; //递归深度     static char *fname[] = { \"sin\",\"cos\",\"tan\",\"sqrt\",\"arcsin\",\"arccos\",\"arctan\",\"lg\",\"ln\",\"exp\",\"ceil\",\"floor\",\"round\",\"sign\",\"abs\",NULL };     double ST[10] = { 0.0 }; //数字栈     char op[10] = { '+' }; //运算符栈     char c, *rexp, *pp, *pf;     int ist = 1, iop = 1, last, i, n;     __int64 i64;      if (!deep) {         pp = pf = expr;         do {             c = *pp++;             if (c != ' '&& c != Tab && c != ',')//跳过半角逗号(通常作为千分位分割符)                 *pf++ = c;         } while (c != '\\0');     }     pp = expr;     if ((c = *pp) == '-' || c == '+') {         op[0] = c;         pp++;     }     last = !DIGIT;     while ((c = *pp) != '\\0') {         if (c == '(') {//左圆括弧             deep++;             ST[ist++] = calc(++pp, addr);             deep--;             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             pp = *addr;             last = DIGIT;             if (*pp == '(' || isalpha(*pp) && strnicmp(pp, \"Pi\", 2) && !isKMG(*pp)) {//目的是：当右圆括弧的右侧为左圆括弧或函数名字时，默认其为乘法                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }         else if (c == ')') {//右圆括弧             pp++;             break;         }         else if (isalpha(c)) {             if (!strnicmp(pp, \"Pi\", 2)) {                 if (last == DIGIT) {                     fprintf(fp,\"π左侧遇）\\n\"); if (fp!=stdout) fclose(fp); exit(1);                 }                 ST[ist++] = 3.14159265358979323846264338328;                 ST[ist - 1] = fun(ST[ist - 1], op, &iop);                 pp += 2;                 last = DIGIT;                 if (isalpha(pp[0]) && pp[0]!='x' && pp[0]!='X') {                     fprintf(fp,\"两个π或K/M/G相连\\n\"); if (fp!=stdout) fclose(fp); exit(2);                 }                 if (*pp == '(') {                     fprintf(fp,\"π右侧遇（\\n\"); if (fp!=stdout) fclose(fp); exit(3);                 }             } else if (isKMG(pp[0])) {                 if (last == DIGIT) {                     fprintf(fp,\"%c左侧遇）\\n\",pp[0]); if (fp!=stdout) fclose(fp); exit(1);                 }                 double value=1.0;                 switch (pp[0]) {                 case 'k':value=1000.0      ;break;                 case 'K':value=1024.0      ;break;                 case 'm':value=1000000.0   ;break;                 case 'M':value=1048576.0   ;break;                 case 'g':value=1000000000.0;break;                 case 'G':value=1073741824.0;break;                 }                 ST[ist++] = value;                 ST[ist - 1] = fun(ST[ist - 1], op, &iop);                 pp += 1;                 last = DIGIT;                 if (isalpha(pp[0]) && pp[0]!='x' && pp[0]!='X') {                     fprintf(fp,\"两个π或K/M/G相连\\n\"); if (fp!=stdout) fclose(fp); exit(2);                 }                 if (*pp == '(') {                     fprintf(fp,\"%c右侧遇（\\n\",pp[-1]); if (fp!=stdout) fclose(fp); exit(3);                 }             } else {                 for (i = 0; (pf = fname[i]) != NULL; i++)                     if (!strnicmp(pp, pf, strlen(pf))) break;                 if (pf != NULL) {                     op[iop++] = 07 + i;                     pp += strlen(pf);                 } else {                     fprintf(fp,\"陌生函数名\\n\"); if (fp!=stdout) fclose(fp); exit(4);                 }             }         }         else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '^') {             char cc;             if (last != DIGIT) {                 fprintf(fp,\"运算符粘连\\n\"); if (fp!=stdout) fclose(fp); exit(5);             }             pp++;             if (c == '+' || c == '-') {                 do {                     cc = op[--iop];                     --ist;                     switch (cc) {                     case '+':  ST[ist - 1] += ST[ist]; break;                     case '-':  ST[ist - 1] -= ST[ist]; break;                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 } while (iop);                 op[iop++] = c;             }             else if (c == '*' || c == '/' || c == '%') {             operate:        cc = op[iop - 1];                 if (cc == '+' || cc == '-') {                     op[iop++] = c;                 } else {                     --ist;                     op[iop - 1] = c;                     switch (cc) {                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 }             } else {                 cc = op[iop - 1];                 if (cc == '^') {                     fprintf(fp,\"乘幂符连用\\n\"); if (fp!=stdout) fclose(fp); exit(6);                 }                 op[iop++] = c;             }             last = !DIGIT;         } else {             if (last == DIGIT) {                 fprintf(fp,\"两数字粘连\\n\"); if (fp!=stdout) fclose(fp); exit(7);             }             if (pp[0] == '0' && (pp[1] == 'x' || pp[1] == 'X')) {                 sscanf(pp + 2, \"%I64x%n\", &i64, &n);                 rexp = pp + 2 + n;                 ST[ist++] = (double)i64;             }             else ST[ist++] = strtod(pp, &rexp);             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             if (pp == rexp) {                 fprintf(fp,\"非法字符\\n\"); if (fp!=stdout) fclose(fp); exit(8);             }             pp = rexp;             last = DIGIT;             if (*pp == '(' || isalpha(*pp)) {                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }     }     *addr = pp;     if (iop >= ist) {         fprintf(fp,\"表达式有误\\n\"); if (fp!=stdout) fclose(fp); exit(9);     }     while (iop) {         --ist;         switch (op[--iop]) {         case '+':  ST[ist - 1] += ST[ist]; break;         case '-':  ST[ist - 1] -= ST[ist]; break;         case '*':  ST[ist - 1] *= ST[ist]; break;         case '/':  ST[ist - 1] /= ST[ist]; break;         case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;         case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;         }     }     return ST[0]; } void pretreatment() {//预处理     int i,L,n,r;     char *p,*q;     double v;     char D[2];      //x2star将两边不是字母且左边不是非数字或串开头紧跟0的x替换为*,目的是支持用x代替*,且和0x开头的16进制数不冲突     L=strlen(s);     for (i=1;i<L;i++) {         if (s[i]=='x' && (!isalpha(s[i-1]) || isKMG(s[i-1])) && !isalpha(s[i+1])) {             if (!(                  (i==1 && s[0]=='0')               || (i>1 && s[i-1]=='0' && !isdigit(s[i-2]))                )) s[i]='*';         }     }      //将\"数字\\.数字[kmgKMG]\"用()括住     strcpy(t,s);     p=&t[0];     q=s;     while (1) {         r=sscanf(p,\"%lf%n%1[GKMgkm]\",&v,&n,D);         if (r==EOF) break;//         if (r==0) {             L=sprintf(q,\"%c\",*p);             q+=L;             p++;         } else if (r==1) {             L=sprintf(q,\"%.*s\",n,p);             q+=L;             p+=n;         } else if (r==2) {             L=sprintf(q,\"(%.*s%c)\",n,p,D[0]);             q+=L;             p+=n+1;         }     } } int main(int argc, char **argv) {     int a;      setlocale( LC_ALL,\"chs\");     fp=stdout;     if (argc<2) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         printf(\"计算函数表达式的值。\\n支持(),+,-,*,x,/,%%,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs,k,m,g,K,M,G\\n\");         while (1) {             printf(\"请输入表达式：\");             fgets(s,MAXLEN,stdin);             if ('\\n' == s[strlen(s)-1]) s[strlen(s) - 1] = 0;             if (s[0] == 0) break;//             pretreatment();printf(\"%s=%.15lg\\n\",s,calc(s, &endss));         }         return 0;     }     if (argc == 2 && 0 == strcmp(argv[1], \"/?\")) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         printf(             \"计算由≥1个命令行参数给出的函数表达式的值。\\n\"             \"最后一个参数是.0～.15表示将计算结果小数点后保留0～15位\\n\"             \"最后一个参数是g1～g15表示将计算结果保留有效数字1～15位\\n\"             \"最后一个参数是e0～e15表示将计算结果用科学计数法表示，且小数点后保留0～15位\\n\"             \"最后一个参数是x表示将计算结果以16进制正整数格式输出\\n\"             \"支持(),+,-,*,x,/,%%,^^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs,k,m,g,K,M,G\\n\"             \"16进制整数以0x或0X开头\\n\"             \"忽略表达式中的半角逗号(通常作为千分位分割符)\\n\"             \"如果第一个参数是/f且c:\\\\jsresult.txt可写，就将所有输出重定向到该文件\\n\"         );         return 0;     }     if (argc>2 && 0 == strcmp(argv[1], \"/f\")) {         fp=fopen(\"c:\\\\jsresult.txt\",\"w\");         if (NULL==fp) fp=stdout;         for (a=2;a<argc;a++) argv[a-1]=argv[a];         argc--;     }     strncpy(s, argv[1], MAXLEN - 1); s[MAXLEN - 1] = 0;     if (argc>2) {         for (a = 2; a<argc - 1; a++) strncat(s, argv[a], MAXLEN - 1);//将空格间隔的各参数连接到s         if (1 == sscanf(argv[a], \".%d\", &pcs) && 0 <= pcs && pcs <= 15) {//最后一个参数是.0～.15表示将计算结果保留小数0～15位             pretreatment();fprintf(fp,\"%.*lf\\n\", pcs, calc(s, &endss));         } else if (1 == sscanf(argv[a], \"g%d\", &pcs) && 1 <= pcs && pcs <= 15) {//最后一个参数是g1～g15表示将计算结果保留有效数字1～15位             pretreatment();fprintf(fp,\"%.*lg\\n\", pcs, calc(s, &endss));         } else if (1 == sscanf(argv[a], \"e%d\", &pcs) && 0 <= pcs && pcs <= 15) {//最后一个参数是e0～e15表示将计算结果用科学计数法表示，且小数点后保留0～15位             pretreatment();fprintf(fp,\"%.*le\\n\", pcs, calc(s, &endss));         } else if (argv[a][0] == 'x' || argv[a][0] == 'X') {//最后一个参数是x表示将计算结果以16进制正整数格式输出             pretreatment();fprintf(fp,\"0x%016I64x\\n\", (__int64)calc(s, &endss));         } else {             strncat(s, argv[a], MAXLEN - 1);             pretreatment();fprintf(fp,\"%.15lg\\n\", calc(s, &endss));         }     } else {         pretreatment();fprintf(fp,\"%.15lg\\n\", calc(s, &endss));     }     if (fp!=stdout) fclose(fp);     return 0; }", "referer": "user-0"}]}
{"question": "这个用c语言怎么写啊？大神们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> int main() {     int a[] = {12,20,6,4,52,6,77,83,91} ;     int arrsize = 8;     int left=0,right=arrsize,temp;     while(left<right)     {         if(a[left]%2==0)         {             while(left<right)             {                 if(a[right]%2==1)                 {                     temp = a[left];                     a[left]=a[right];                     a[right]= temp;                     right--;                     break;                 }                  right--;             }         }         left++;     }     for (temp=0;temp<=arrsize;temp++)         printf(\"%d \", a[temp]);       return 0;   }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h>void move(int arr[], int sz){    int left = 0;    int right = sz - 1;    while (left < right)    {        while ((left < right) && (arr[left] % 2 == 1))        {            left++;        }        while ((left < right) && (arr[right] % 2 == 0))        {            right--;        }        if (left <right)        {            int temp = arr[left];            arr[left] = arr[right];            arr[right] = temp;        }    }}void print(int arr[],int sz){    for (int i = 0; i < sz; i++)    {        printf(\"%d \", arr[i]);    }}int main(){    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};    int sz = sizeof(arr) / sizeof(arr[0]);    move(arr, sz);    print(arr, sz);    return 0;}可以参考一下", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "如果不用排序的话：从数组第一个数开始判断，如果是偶数则接着判断数组最后一个数是奇数还是偶数，最后一个是奇数则把其和第一个数交换；如果是偶数则不动，继续判断倒数第二个数，同样处理。如果第一个数是奇数或者第一个数已完成处理，则继续判断第二个数，同上处理。以此类推直到把数组遍历一遍后，数组就符合要求了，这时再把数组输出就行了。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "遍历2次A数组，第一次输出奇数，第二次输出偶数。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "另声明一个数组B，遍历一遍A,将奇数依次放入B,再遍历一遍A,将偶数继续放入B,将B所有元素依次放入A覆盖旧A", "referer": "user-0"}]}
{"question": "小白请教一个问题。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "a[i]=true;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "脑子临时卡住了", "referer": "user-0"}]}
{"question": "第一次接触，输出的时候是黑屏，帮帮新人吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf中各%X之间应该啥也没有，输入时用空格或Tab键或回车换行间隔各项数据", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你得输入用空格分隔的两个整数吧，然后才输出它们的和；交互友好计，可以输入前来个提示；输入整数无须用 scanf_s()", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "刚上大学的萌新", "referer": "user-0"}]}
{"question": "dev c++源文件未编译，怎么办？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "建立一个含有该源文件的项目。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "怎么建立呀？", "referer": "user-1"}]}
{"question": "求助怎么不用getche输入输出一行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "一行就可以了：for (int c = getchar(); printf(\"%c%c%c\\n\", c - 1, c, c + 1);) break;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "题目没有让你输入输出在一行，你想多了。", "referer": "user-0"}]}
{"question": "小白求助！！未声明的标识符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要啃故弄玄虚的视频，谢谢。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "看下面的图，那个_Format: 应该只是提示当前输入域的参数说明，不是要你也输入这么个内容的", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "好的，十分感谢！！", "referer": "user-2"}]}
{"question": "求助各位大佬们，在c中数字字符串可以进行运算吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "按照字符串接收输入内容，直接通过查找定位小数点在字符串中的位置，剩下的就是字符串索引的事儿了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "嗯嗯，谢谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "不可以的，可以通过读取转换函数转换为内部浮点数值 12.36 然后再行后续处理；如果仅仅是获取整数部分个各小数位，可以通过查询小数点来对字符串进行切分。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "好的，感谢老哥", "referer": "user-2"}]}
{"question": "C#求解方程组 进行到一半 不知道怎么写了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "思路，一个是试差迭代，一个是求反函数；你这里好像求反函数即 di 的公式简单，A=f1(...)*di^2，V=f2(...)di^(2/3) AV=di^(8/3)*f3(...) 这样 di 的公式就出来了。", "referer": "user-0"}]}
{"question": "%s出现了冲突什么原因呢，求大神帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "Visual Studio 2017 这个软件", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "什么编译器？应该不是scanf_s导致的，其他代码的问题", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "加了_s以后的参数与原来不同了，不要直接把它当作scanf用。对于%s和%c两个格式符，后面需要有两个参数与之对应，分别是地址和长度。文档还是要读的。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "地址和长度，这个我没有设定long这个变量啊所以还需要设定一个吗 还是", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "形如 scanf_s(\"%s\",buf,128);", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "scanf_s(\"%s\", &buf); 这里加&画蛇添足了，直接用buf就好，但并不是错误。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "这个&地址我已经去掉了，但是呢还是会冲突  特别是%s  其他还好", "referer": "user-1"}, {"cid": "8", "user": "user-3", "content": "你把地址运算符去掉试试", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "这个我知道但是呢 一样还是有冲突", "referer": "user-3"}, {"cid": "10", "user": "user-4", "content": "感谢", "referer": "user-3"}]}
{"question": "求大神求解决啊大神们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "在下已经把全部代码都放在网了，还请各位大神帮忙解决 在下在此谢过了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "并非在下惜墨如金是以此%s为误啊而以此%c%d皆可罢了就以各位所说予以改善", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "楼主惜墨如金吾等徒呼奈何", "referer": "user-0"}]}
{"question": "有人遇到  c写文本文件 ，个别时候内容前多一串不可见的@@@@，为什么，有什么办法解决这个问题，请指教，谢谢了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "_tmp_Data_DateFormat.tmpNowtime有问题，不知道这字符串怎么来的。用ue打开文本文件，可以看到写入的不可见字符是什么。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "显然在某些情况下，_tmp_Data_DateFormat.tmpNowtime、strdata的内容就是错的，你得先检查这两个数据的写操作，而且这两个数据就是字符串，你还sprintf干嘛呢～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "进程意外退出或电脑意外掉电都有可能导致文件中多一串看不见的@", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "遇到这样的问题  只能人为去修复这样的数据，让他标准化，是这样吗", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "大抵如此", "referer": "user-0"}]}
{"question": "我不知道为什么我i这个运行不了，代码没问题啊。。求解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanner是接收输入的所以要输数字然后以一个非数字结束 类似这样", "referer": "user-0"}]}
{"question": "把DOS时代的C代码运行在手机上了,感觉很神奇", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "DosBox了解一下", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不存在 BorlandC++3.2 这个产品～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "bc 到 vc ，改动不小吧；纯 dos ，简单的就是直接上 dosbox 了，什么都不用改", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "bc当年为win3.2提供了支持,所以改动真不大,我的目的是编译运行源代码,和把EXE放到虚拟机里面跑是两个概念.这玩得是编程.不过说到这里又让我感叹了,这年头哪里还有我这样的业余编程爱好者,从CSDN就看的出来,一说到编程就像一群饿红了眼的狼,满脑子就是钱钱钱.代码就是个搞钱的工具,谁还会去研究把玩这些.", "referer": "user-3"}]}
{"question": "udp服务端的socket与多个UDP客户端同时通讯的话，能处理的过来吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考一下BIND ，它大概率就是这么干活的。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "药科学生有个梗，叫做抛开剂量谈毒性都是耍流氓。用在这里就是说，抛开工作量不能探讨是否处理得过来。工作量在一定规模以下，那就处理得过来。BTW: 性能分析与优化这种事相当复杂，也确实值钱。因为它需要具体情况具体分析。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "150个左右客户端不知怎样？", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "一条铁路线上两端每天对开两对列车够不够？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "现在正在考虑做这个事情，之前没做过，所以不知从何下手。", "referer": "user-1"}, {"cid": "6", "user": "user-2", "content": "多线程，每个线程处理若干个客户端的数据，如果仍然处理不过来就要用集群了", "referer": "user-0"}]}
{"question": "执行SQL后的table有三条数据，for循环，报错在第三行没有任何值。怎么解决。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "求解", "referer": "user-0"}]}
{"question": "求大佬帮做C语言学生成绩管理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "活太大，建议去悬赏区或者去网上找个demo改下", "referer": "user-0"}]}
{"question": "请问一下scanf的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf输入要考虑内存问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考： #include <stdio.h> char s[]=\"123 ab 4\"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,\"%d%n\",&v,&n);         printf(\"k,v,n=%d,%d,%d\\n\",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf(\"skip char[%c]\\n\",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf(\"End.\\n\"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "%c一次读一个字符%s一次读一串字符，引起内存溢出", "referer": "user-0"}]}
{"question": "C语言学习第一天，记录一下自己的代码池", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "加油", "referer": "user-0"}]}
{"question": "为什么C语言运行没有结果,c语言编程代码感觉没错，dev c++也没报错，为什么运行结果始终不对？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果想看s值，可以printf打印下s。 如果觉得回答的不错，欢迎关注下我", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "结果，你要什么结果？你让程序怎么结果了？程序如何知道你要什么结果？", "referer": "user-0"}]}
{"question": "有木有大佬求教这两种寄存器该怎么用地址来配置数值   没有单独一位一位的功能 卡住了！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "强制转换+位运算大多单片机不都是这么干的么？", "referer": "user-0"}]}
{"question": "char a='a'; --a 为什么还是 a", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为 a++ 的又被 --a 给抵消了；自运算，前置和后置的区别", "referer": "user-0"}]}
{"question": "有没有大神看看我这报错是为啥啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "RA_开头的变量是结构体指针，后面的值却是宏（实际是数值），类型不匹配。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "那请问一个结构体指针 要把它等于一个宏定义的地址 要怎么写呢  我网上找了很久都没找到！！！ 救命", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "强制类型转换", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "亲，关注下我还行？", "referer": "user-0"}]}
{"question": "各位大佬，请问这个到底错在哪里了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢，明白了！", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "while(n == 0)， 你想要判断的是n != 0的时候继续计算", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢！", "referer": "user-2"}]}
{"question": "C语言小白在线求查错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "10 的 n 次方，不是 ^ 操作符吧，这个是逻辑异或，可能要用 pow() 函数？其它问题，要么调试，要么关键步上放个 printf() 函数显示内容。", "referer": "user-0"}]}
{"question": "编程如何 通过netfilter 修改 目标ip地址", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "配置是可以实现功能，我在开发一个网络安全的系统，需要通过代码修改目标ip地址", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "不能理解您的意图，打算做什么？您提到了netfilter我觉得就应该是配置问题而不是编程问题。可是您又提到编程代码，这就让我糊涂了。不过您提到的那个函数的返回值是32位的类型，所以显然没有能力处理128位的类型。", "referer": "user-0"}]}
{"question": "NTFS用FSCTL_GET_RETRIEVAL_POINTERS读取小挡案的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "小文件没有分配到磁盘的数据空间, 而是直接储存在mft, 所以没有这个东西", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "直接储存在mft, 要如何找出小文件的资料区位置?", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "NTFS每个文件都在MFT存储属性, 比如文件名, 时间等, 小文件直接在这个里面有个数据属性, 数据就在这里 数据不是独立的, 是属性的一部分  ntfs系统比较复杂, 如果要读取这个文件的数据, 过程: 1. 从MFT的root根据目标文件路径, 找到文件对应的mft的索引 2. 读取并解释该索引的属性, 其中就有文件的数据", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "这方面是初学者, 请问有没有C CODE范例能参考?", "referer": "user-1"}]}
{"question": "求解答，如何利用scanf()函数的返回值终止循环", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "运行中做不到，反思一下，就说明这样写是不对的。%c格式符是荤素不计的，任意内容都能满足它----跟是否字母没啥关系。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf()的返回值是实际输入的参数个数，所以可以用x[a]的值是否是字母来判断。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不要用带回显的输入函数，用getch()，这个虽然不是标准c库函数，但是几乎所有c库实现都支持", "referer": "user-0"}]}
{"question": "基础c语言奇偶大小排序的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "排序上有问题吧，简单的冒泡，得两重循环的，一个循环无法实现。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "哦哦，是吼，谢谢大佬指点", "referer": "user-1"}]}
{"question": "为什么else后面不执行直接跳过", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“确认删除”后面的那个 else ？如果是的话，可能是你的 scanf() 有问题，格式字符串里 %c 前面竟然有个空格？", "referer": "user-0"}]}
{"question": "初学拷贝构造函数VC能过编译DEV过不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Add的返回类型是CBall，你return r;肯定不行。可以：    CBall& Add(CBall& t)  // 注意返回的是引用，不是临时对象    {      r = ...      return *(CBall *)this;    }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢啦", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "报错是在鼠标光标那行", "referer": "user-0"}]}
{"question": "请各位大佬看看代码有什么问题 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if (*p > n) 这个改成 if(*p > num) 因为要和输入num比大小  *q = n;    这里改成 *q = num，把num插入数组 printf(\"%2d\", *p); 这里改成 printf(\"%2d \", *p);，在2d后面加一个空格，显示的更清楚", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢谢写大佬，我检查的时候没看见，真的是太感动了，真的十分感谢老哥", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "再次感谢老哥，真的是非常感动", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "不客气，互相学习", "referer": "user-0"}]}
{"question": "求代码！急！新人表示很难。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "#include<stdio.h>#include<math.h>int Func(int n){    int i,leap=1;    for(i=2;i<=sqrt(n);i++)        {            if(n%i==0)                leap=0;        }    return leap;}int main(){    int n,i,sum=0,a[10],j=0;    printf(\"请输入n的值：\");    scanf(\"%d\",&n);    for(i=2;i<=n;i++)    {        if(Func(i))        //判断从2开始到n(包括n)的数是否是质数        {            a[j]=i;        //是质数的存入数组            sum+=i;            j++;        }    }    for(i=0;i<j-1;i++)        printf(\"%d+\",a[i]);        //最后一个先不打，因为最后一个数后面没有+号    printf(\"%d=%d\",a[i],sum);    //打印最后一个数和它们的和。}", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢", "referer": "user-1"}, {"cid": "5", "user": "user-2", "content": "百度可以搜到的", "referer": "user-0"}]}
{"question": "求大神帮我看看 为什么输出不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "getcher改为getchar", "referer": "user-0"}]}
{"question": "c语言怎么设置单独修改信息", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "cout << \"旧姓名：\" << abs->personArray[ret].m_Name << endl;         cout << \"请输入新姓名(输入_保持旧姓名不变)：\" << endl;         string name;         cin >> name;         if (name!=\"_\") abs->personArray[ret].m_Name = name;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢！！！我还想问一下为什么我修改另一个邮政编码的时候！=报错了", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "单看这段代码似乎没啥问题", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "就是不知道怎么单独修改姓名或者编码这些，就不用再重复输入别的信息了", "referer": "user-1"}, {"cid": "5", "user": "user-1", "content": "修改前，显示旧信息，修改时，提示输入一个下划线\"_\"表示保持原来内容不修改，输入后，判断如果刚输入的是\"_\"就不赋值给原来内容。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "这个应该怎么写呀", "referer": "user-1"}]}
{"question": "c语言怎么设置不重复输入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "/添加联系人 void addPerson(Addressbooks * abs) {     //判断联系人是否满了     if (abs->m_Size == MAX)     {         cout << \"通讯录已满，无法添加\" << endl;         return;     }     else     {     string name;     cout << \"请输入姓名：\" << endl;     cin >> name;     int ret = isExist(abs, name);     if (ret != -1)     {         cout << \"通讯录中已经有姓名为 \"<<name<<\" 的人，无法重复添加\" << endl;         return;     }     abs->personArray[abs->m_Size].m_Name = name;      cout << \"请输入邮政编码：\" << endl;     int postcode;     cin >> postcode;     abs->personArray[abs->m_Size].m_Code = postcode;      cout << \"请输入联系电话：\" << endl;     string phone = \"\";     cin >> phone;     abs->personArray[abs->m_Size].m_Phone = phone;      cout << \"请输入家庭住址：\" << endl;     string address;     cin >> address;     abs->personArray[abs->m_Size].m_Addr = address;      cout << \"请输入E_mail：\" << endl;     string e_mail;     cin >> e_mail;     abs->personArray[abs->m_Size].m_Mail = e_mail;      //更新通讯录人数     abs->m_Size++;      cout << \"添加成功：\" << endl;     system(\"pause\");     system(\"cls\");  } }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢你！！！！太厉害了老师", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "Who am I！", "referer": "user-0"}]}
{"question": "求助 求助怎么修改字串", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "ue看出来是这样的看不到前面那个源代码不知道哪里改", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这里应该把是上面的地方吧，直接用 211.149... 搜索，若搜不到试试 unicode 模式，还搜不到，就是压缩或加密了；修改 exe ，可能有问题，你这里，看顶楼都有 align 4 语句，可能正好还有 1个字节的空间，但实际 exe 里就要看了，若无空间，就麻烦了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "用UE改", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我不懂啊就是ue打开看都看不懂个", "referer": "user-2"}, {"cid": "5", "user": "user-1", "content": "这是源程序，不就是直接改下面一行吗，如 db  '192.168.200.100', 0 ；标签不能改的，改了其它地方引用这里的就会找不到了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "我是用pe反编辑看的但是字串哪里改不了，标签改的了，我要把211 ip改成192 ip的，能私信我帮一下不", "referer": "user-1"}]}
{"question": "文件操作函数read(...)返回值不正确？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "对read这个函数不熟，我一般喜欢用fread。还有你里边的lseek，也属于已经被废弃的函数名。不如换成fseek，，， open,read,close,lseek，好像就这4个函数吧，建议使用stdio.h标准库里边的函数将你的程序重写一下： open==fopen read==fread close==fclose lseek==fseek 注意有些函数的参数顺序会存在差异，你研究一下应该不难替代。完事再试试看还有没有问题。头文件也不用包含辣么多，windows.h一个足矣。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fd = open(_pcFullFileName, O_RDWR｜O_BINARY, 0x604);不要把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": "3", "user": "user-0", "content": "确实 那个位置的字符是 0x1A...", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "Who am I !", "referer": "user-0"}]}
{"question": "求各位大神们帮帮孩子！！！真的做不出来了啊.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "回复有分吗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "什么分，哥", "referer": "user-1"}]}
{"question": "能帮忙看看这是什么问题吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "红字说得很清楚了，有啥不好理解的么？", "referer": "user-0"}]}
{"question": "请看一看为什么没有输出结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第一个for循环中你写的是p='\\0'，应该改成p=='\\0'，写代码要细心呀", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "OKOK😅", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "敲代码时丢掉了一个感叹号。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "OK😅", "referer": "user-2"}]}
{"question": "Windows API函数CryptUIWizImport在部分系统调用时卡住", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://docs.microsoft.com/zh-tw/windows/win32/api/cryptuiapi/nf-cryptuiapi-cryptuiwizimport", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "参数看起来没有问题，怎么会卡住呢，而且是个别电脑上", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "UAC、防火墙、杀毒软件、以管理员身份运行、未打最新补丁、未导入最新证书、……", "referer": "user-0"}]}
{"question": "二叉树递归搜索的return为什么可有可无？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个函数要是没有return的话，你还写他干嘛？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "不好意思，我没有说清楚问题，现在已将问题补充完整了", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "哦，是这样啊。 那么不加return理论上是不对的。 如果运行结果是对的，那都是偶然的恰巧的，毕竟彩票中奖这种事也发生过。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "", "referer": "user-1"}]}
{"question": "求大佬讲讲，int整型变量初始化不赋值的话，在for循环里打印出来值为什么会是1？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "sum 是个随机值", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "明白了，谢谢", "referer": "user-1"}]}
{"question": "以指针作为参数进行传递的问题", "poster": "user-0", "comments": [{"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"}]}
{"question": "我给堆栈区内存足够大,为何realloc返回了NULL", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果确实是空间限制引起的的话，堆栈说的是栈，和malloc系列没关系，上方的堆才是管这个的。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我改了堆也不行，是通过用x64编译器才成功的😂", "referer": "user-1"}]}
{"question": "关于gets函数和空格的问题", "poster": "user-0", "comments": [{"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"}]}
{"question": "一直出现这个告警，不知道怎么解决，望大家告知", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "那个“说明”还不清楚？翻译下也没什么意思的。照着做就是了。", "referer": "user-0"}]}
{"question": "怎么将分数字符串转化为浮点型数据？", "poster": "user-0", "comments": [{"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"}]}
{"question": "请问如何不用循环求出两个日期之间的闰年个数？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先从日期（想必是年月日）规范为年份，也就是2月28日之前的日期只算到前一年。然后对于一个年份，从公元开始到这个年份共有多少个闰年是直接算的，y/4-y/100+y/400即可。两个年份算的闰年数一减即可。", "referer": "user-0"}]}
{"question": "求助，好像是误删了一个东西导致的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "控制面板、程序和功能、Visual Studio xxxx、修复", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "一般是重新安装。或者看看这个文件被移到哪啦，拷回来。", "referer": "user-0"}]}
{"question": "加了-mcmode=large无效，一直relocation truncate to fit。model.o文件超过4GB", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "江湖救急", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "@赵4老师，过来帮忙", "referer": "user-0"}]}
{"question": "C语言conio.h文件", "poster": "user-0", "comments": [{"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"}]}
{"question": "如何在VS里用C语言实现复数的定义与输出？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同出现复数定义不出来的问题，请问楼主解决了吗？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我用vs2022也出现这个问题了，看有的说是编译器不同的原因。请问楼主解决了吗？", "referer": "user-0"}]}
{"question": "为什么文件无法写入啊", "poster": "user-0", "comments": [{"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"}]}
{"question": "[Warning] assignment from incompatible pointer typ怎么解决 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "定义 stu 里的应该是 struct student*next; 吧，有输入错误；其它还有类似的键入错误", "referer": "user-0"}]}
{"question": "100人民币换零问题（C语言）", "poster": "user-0", "comments": [{"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"}]}
{"question": "开局一张图，题目全靠猜", "poster": "user-0", "comments": [{"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"}]}
{"question": "输入数据后程序为什么不运行，不显示计算结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf里面不能有\\n", "referer": "user-0"}]}
{"question": "这代码啥问题 奇怪的初始化元素太多", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第二个数4.3 写成了 4,3 了吧，即小数点写成了逗号", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢蠢死了", "referer": "user-1"}]}
{"question": "【UDT】求纯C语言实现的UDT库源码，急急急！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "【UDT】求纯C语言实现的UDT库源码，急急急！！！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "求纯C语言实现的UDP库源码，有重谢！！！", "referer": "user-0"}]}
{"question": "三子棋的棋盘 无法对齐", "poster": "user-0", "comments": [{"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"}]}
{"question": "c语言 字符串指针 请教各位大神 帮帮孩子！！！", "poster": "user-0", "comments": [{"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"}]}
{"question": "linux源码问题？？？？", "poster": "user-0", "comments": [{"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"}]}
{"question": "字符型数组输出全是方框是怎么回事", "poster": "user-0", "comments": [{"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"}]}
{"question": "新手学习 问题请教1：Scanf使用问题 请高手指教", "poster": "user-0", "comments": [{"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"}]}
{"question": "输入文件路径时，直接输入的可以正常使用，通过strcat拼接而成的无法使用；并且有时直接输入路径也无法使用，如何解决？", "poster": "user-0", "comments": [{"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"}]}
{"question": "求救VS2022输入这个代码，是什么问题", "poster": "user-0", "comments": [{"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"}]}
{"question": "请问各位运行多源文件程序时出现下列错误怎么破？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我都是复制错误信息直接百度", "referer": "user-0"}]}
{"question": "vscode报错信息含义及主函数如何定义", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "sqrt() 就是浮点数啊，单精度或高精度的，要给整形，可能要加个类型转换。", "referer": "user-0"}]}
{"question": "二维数组加一和二维数组加一解引用", "poster": "user-0", "comments": [{"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"}]}
{"question": "求值 9Bh=-27，1Bh=27 如何计算这个值，c ", "poster": "user-0", "comments": [{"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"}]}
{"question": "这个里面的c++和++c两种自增出来的结果为什么是一样的？", "poster": "user-0", "comments": [{"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"}]}
{"question": "静态变量和初始化为0的全局变量在.bss段吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": ".data当然名字是无所谓的，加载后都合并了，只是映射的页面属性不一样而已。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的大佬", "referer": "user-1"}]}
{"question": "求助 代码在dev-c++成功运行，vs2022却运行失败", "poster": "user-0", "comments": [{"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"}]}
{"question": "我又来了，内存对齐问题", "poster": "user-0", "comments": [{"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"}]}
{"question": "c语言指针交换两个值的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "c语言里面的变量名称是区分大小写的将pa 改为 Pa，或者将Pa改为pa，即可", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "c语言的代码里面是区分大小写的。", "referer": "user-0"}]}
{"question": "求助，leetcode heap buffer overflow错误", "poster": "user-0", "comments": [{"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"}]}
{"question": "力扣网的练习题，请问这个 *returnSize = 2; 这一句意义何在", "poster": "user-0", "comments": [{"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"}]}
{"question": "求大佬解答该如何让此软件运行，本人电脑是windows11，这个软件是老师上课要求要下载的。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果不能换老师的话，就换系统吧。在自己的机器上装虚拟机或者租用云主机用它的远程桌面，然后在里面安装windows98，接着在上面安装VC6。", "referer": "user-0"}]}
{"question": "TCP TIME_WAIT问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "顶", "referer": "user-0"}]}
{"question": "关于形参和实参的概念", "poster": "user-0", "comments": [{"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"}]}
{"question": "这道题的形参有什么意义", "poster": "user-0", "comments": [{"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"}]}
{"question": "代码没有错误 但是运行不出来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码与特定的库相和图形环境关联，没办法测试。请把相关的编译及运行信息贴出来看看，能不能找到问题所在。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "11", "referer": "user-0"}]}
{"question": "C语言题目，想知道哪错了，为什么总是输出不存在", "poster": "user-0", "comments": [{"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"}]}
{"question": "技能树看到的题 为啥是8 我不理解8 1 4怎么也是16吧。。", "poster": "user-0", "comments": [{"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"}]}
{"question": "第一个是录入文件的数据，为什么我想把学号输出来，却把S也带出来了，S是学生的意思，第三个是我录入的方式，a是结构体指针", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "直接从文件读数据到结构中，结构的字段没结束符，所以会把S一起带出来。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请粘贴完整代码", "referer": "user-0"}]}
{"question": "（JAVA区成鬼区了，问问题还得来C语言区）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "渣哇中参数只有数组和对象是传引用，所有基础类型都传值，你可以int a[1]，然后传a就可以了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢大佬，问题解决，C语言区果然给力", "referer": "user-1"}]}
{"question": "为什么我这个只能检查第一个数据，无法检测剩下的账户是否存在", "poster": "user-0", "comments": [{"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"}]}
{"question": "这么小的数也会溢出吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for 循环后 n 是 0，除以 0 还不溢出啊。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "哦对，没留意，谢谢", "referer": "user-1"}]}
{"question": "openjudge的题，大佬们帮帮忙，我实在看不出来该修改哪里", "poster": "user-0", "comments": [{"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"}]}
{"question": "求助为什么结构体的大括号里定义变量要用数组（红色那里）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为学生的学号 名字不可能是一个字符啊  所以就用数组啊", "referer": "user-0"}]}
{"question": "求解析，谢谢各位大佬！", "poster": "user-0", "comments": [{"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"}]}
{"question": "问题 。。。。。。。。。。。。。。。。。。", "poster": "user-0", "comments": [{"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"}]}
{"question": "C语言中memcpy的参数顺序设计思想是什么？为什么这样设计？", "poster": "user-0", "comments": [{"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"}]}
{"question": "严重性\t代码\t说明\t项目\t文件\t行\t禁止显示状态 错误\tC4996\t'strcpy': This function or variable may be unsafe. Consider using ", "poster": "user-0", "comments": [{"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"}]}
{"question": "c语言输出hello,world 但判断结果一直是WA,给孩子整不会了,看不出错误.", "poster": "user-0", "comments": [{"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"}]}
{"question": "字节问题（凑够10个字太离谱了）", "poster": "user-0", "comments": [{"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"}]}
{"question": "已安装DEV C情况下如何装VScode", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "点manage替换已安装的版本", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "安装后显示这个对话框请问该选哪个？", "referer": "user-0"}]}
{"question": "为什么DEV C++内外编译器不一样？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "jmeubank.github.io/tdm-gcc/about/简单说，TDM就是基于MinGW（gcc的windows移植版本）的一个实现", "referer": "user-0"}]}
{"question": "进程虚拟内存空间的问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "系统这个词有歧义吧？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "32位\"系统\"是这个么，直接复制过来，应该是32位以下分布", "referer": "user-1"}]}
{"question": "递归求和 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%d\",n); 应该是  scanf(\"%d\", &n);", "referer": "user-0"}]}
{"question": "递归......................", "poster": "user-0", "comments": [{"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"}]}
{"question": "求解求解 c语言文件方面的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "31行 ，不是s=&i; 应是*s=i;", "referer": "user-0"}]}
{"question": "这个for 循环哪里出错了，系统一直报错", "poster": "user-0", "comments": [{"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"}]}
{"question": " . ", "poster": "user-0", "comments": [{"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"}]}
{"question": "简单的民宿预约系统代码编写 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "html搞定，还C语言", "referer": "user-0"}]}
{"question": "调试时候出现这个对话框是什么意思", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "出现这个，就说明你的代码有问题，最可能是引用了野指针、超标（越界）。", "referer": "user-0"}]}
{"question": "<C语言>我感觉我的程序漏洞百出，有没有大佬帮忙看一下……", "poster": "user-0", "comments": [{"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"}]}
{"question": "为什么DEV C 5.15会自动添加空格？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "还有这么神奇的工具吗？这编码规范太舒服了，强求一个linux的版本！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这不是很好么~", "referer": "user-0"}]}
{"question": "十分钟带你学会C语言的文件操作", "poster": "user-0", "comments": [{"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"}]}
{"question": "C语言大一PTA输入一个英文句子，将每个单词的第一个字母改成大写字母。", "poster": "user-0", "comments": [{"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"}]}
{"question": "有5本书，每本书包含书号，书名，作者，价格，出版社的信息，编写函数：1.输出5本书信息。2.输出价格最高的那本书的信息。3.输出价格最低的那本书信息。在主函数中使用这3个函数", "poster": "user-0", "comments": [{"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"}]}
{"question": "C语言题目，想知道哪里错了，为什么输不出素数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两层for之间加上flag=1;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1"}]}
{"question": "问题 ", "poster": "user-0", "comments": [{"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"}]}
{"question": "在调试时出现了unhandled exception 0xC0000005:Access Violation的错误", "poster": "user-0", "comments": [{"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"}]}
{"question": "为什么运行不起啊，求教", "poster": "user-0", "comments": [{"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"}]}
{"question": "c语言结构 这个结果一直都是不对的", "poster": "user-0", "comments": [{"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"}]}
{"question": "为什么运行起来不能执行么，我令n1=3就能正常运行，不该是swap(n1,n2)不发生改变swap（n2，n3发生换位么", "poster": "user-0", "comments": [{"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"}]}
{"question": "C程序设计里面的一道题：手动输入动态数组求平均数。我试了下返回得到的是0，打印max是0", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "26行那里，应该是  scanf(\"％lf\",&item); 吧", "referer": "user-0"}]}
{"question": "为什么字符串中带有NUMBER后换显示乱码啊", "poster": "user-0", "comments": [{"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"}]}
{"question": "一道循环题 ", "poster": "user-0", "comments": [{"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"}]}
{"question": "关于整型的一点小疑问，求大佬解惑", "poster": "user-0", "comments": [{"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"}]}
{"question": "各位能不能帮我改善一下，感觉我的有点奇怪", "poster": "user-0", "comments": [{"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"}]}
{"question": "求用c语言编写一个课程管理系统 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "标记一下，周六日有时间把它写了，一起学习。", "referer": "user-0"}]}
{"question": "这个值为什么是8，我实在想不通。", "poster": "user-0", "comments": [{"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"}]}
{"question": "select可读问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已经找到原因并解决", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "所以你提问的时候希望别人解释，解决了以后自己却不解释的做法是会给别人添堵的。 真的懒得解释不妨删贴哦。", "referer": "user-0"}]}
{"question": "计算机大一上课设作业", "poster": "user-0", "comments": [{"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"}]}
{"question": "求一个三位数的个位，十位，百位？ 1）用3种方法解题？数学法2种+字符法1种。 2）求一个四位数？ 3）求一个不固定位数？", "poster": "user-0", "comments": [{"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"}]}
{"question": "不是字符串数组不能带&么为什么这个程序不带运行不起，反而带了可以运行呢求解", "poster": "user-0", "comments": [{"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"}]}
{"question": "我的这个8皇后for循环出不来怎么办", "poster": "user-0", "comments": [{"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"}]}
{"question": "这问题怎么解决啊？新手，求指点", "poster": "user-0", "comments": [{"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"}]}
{"question": "【求助】无头结点单链表尾插法失效，编译无报错，运行终止", "poster": "user-0", "comments": [{"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"}]}
{"question": "求二维整型数组的“最大点”。二维数组的“最大点”定义为：某个数是所在行的最大值，并且是所在列的最大值。注意：某行或某列上可能有多个“最大点” 求大佬帮忙看一下，为什么得不到想要的输出", "poster": "user-0", "comments": [{"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"}]}
{"question": "下了个gcc11.2，不知道怎么安装", "poster": "user-0", "comments": [{"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"}]}
{"question": "DEV C++ 中文乱码是什么原因", "poster": "user-0", "comments": [{"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"}]}
{"question": "最大公约数问题 新手求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "没有吧，vc2008后一切正常。可能是你输入数据不合 scanf() 的规格，它要求两数据用一个英文逗号分隔。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "是的，解决了， 谢谢大佬", "referer": "user-1"}]}
{"question": "为什么第十行去掉0就不能将数字保存到s[]中", "poster": "user-0", "comments": [{"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"}]}
{"question": "为什么第一二个打印不出来，而第三个可以", "poster": "user-0", "comments": [{"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"}]}
{"question": "怎么把goto语句换成其他的语句？", "poster": "user-0", "comments": [{"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"}]}
{"question": "如果avg出现负数是不是因为数字越界了", "poster": "user-0", "comments": [{"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"}]}
{"question": "我输入3.142412swich不应该只加3就退出了么，为什么后面会显示其他数字也加了啊求问", "poster": "user-0", "comments": [{"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"}]}
{"question": "求助getchar清理缓冲区的问题", "poster": "user-0", "comments": [{"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"}]}
{"question": "为啥我c语言 程序 本地可以 传到oj 就出现了运行错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，我修改了部份代码，你看改成这样是不是更好： #include <stdio.h>  int main() {     long n, k;     scanf(\"%ld%ld\", &n, &k);     // long a[1100]; // 原式：没有必需啊，重量怎么可能是长整数呢？     int a[1100];     // long long sum; // 原式：没有必需啊，重量怎么可能是长整数呢？     int sum;     for (int i = 1; i <= n; i++) {         // scanf(\"%ld\", &a[i]); // 原式         scanf(\"%d\", &a[i]);     }     for (int i = 1; i <= k; i++) {         int l, r;         l = 0;         r = 0;         scanf(\"%d%d\", &l, &r);         sum = 0; //        while (l <= r) { // 直接用for循环不是更好吗 //            while (a[l] == 0) { // 原式：不明白想表达什么意思？ //                l = l + 1; //                if (l > r) //                    break; //            } //            if (l > r) // 这个退出条件也是多余的 //                break; //            sum = sum + a[l]; //            l = l + 1; //        }         for (; l <= r && r < n; l++) { // 使用for循环，同时也要检测是否越界             sum += a[l];         }         // printf(\"%lld\\n\", sum); // 原式         printf(\"%d\\n\", sum);     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "同学，这一段想表达什么呢？跟题意没一点关系，如果a很大，它就是个死循环无异？while(a[l]==0){    l=l+1;    if(l>r)break;}", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "数组改成a[11000]也是运行错误", "referer": "user-0"}]}
{"question": "为啥我c语言 程序 本地可以 传到oj 就出现了运行错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "求各位大神解答", "referer": "user-0"}]}
{"question": "求助！我的字符串输出结果最后一位总是随机多一个符号TAT", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，下面这一行中，m是不是没有初始化值，是不是应该把它的条件改为j<260    ?    for (int j = 0; j <= m; j++) {        line1[j] = line2[j] = '\\0';    }", "referer": "user-0"}]}
{"question": "请大佬帮忙看看这个约瑟夫环问题，不知道为什么我这个代码没有输出结果 呜呜", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，你的代码有些地方出错了，也有些不合理，我已修改，请参考： #include <stdio.h>  int main() {     int i, j, k, m, n, x, nout;     int N, S, W;     printf(\"请输入小孩数N:\\n\");     scanf(\"%d\", &N);     // int people[N + 1]; // 原式：N + 1是什么意思呢？     int people[N];     char result[N];     char name[N];     printf(\"请依次输入他们的名字：\\n\");     for (m = 0; m < N; m++) {         scanf(\"%s\", &name[m]);         people[m] = 0; // 在这里初始化，不需要多一个for循环     }     printf(\"请输入W，S。输入时用','隔开\\n\");     scanf(\"%d,%d\", &W, &S);     // for (i = 0; i < N; i++) { // 原式：多余的循环     //    people[i] = 0;     // }     k = 0;     x = W - 1;     nout = 0;     while (nout != N) {         x++;         // if (x = N + 1) { // 原式：逻辑表达式错误了         if (x >= N) { // 改为这个就可以了             x = 0;         }         if (people[x] == 0) {             k++;             if (k == S) {                 people[x] = 1;                 k = 0; //                for (j = 0; j < N; j++) { // 不明白想表达什么？ //                    result[j] = name[x]; //                }                 result[nout++] = name[x];             }         }     }     for (n = 0; n < N; n++) {         // printf(\"%s\", result[n]); // 原式：你定义的是char数组！         printf(\"%c\", result[n]);     }      return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "非常感谢大佬的修改与指正!☺️ 感激不尽", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "我还是小学生", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "哇！那你也太厉害了", "referer": "user-1"}]}
{"question": "学C的原动力 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果不做运动员，或者说想做也做不了，那么跑步有什么用，这关系到你的第一需要", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "汇编和C是基础语言，程序员必会，否则属于不及格～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "所以说80%的程序员都不及格", "referer": "user-2"}]}
{"question": "求教（如何理解这段代码？）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，我开始学C语言的时候，都习惯都每一行的代码都写注解，像这样： #include <stdio.h> // 包含标准输入输出的头文件 #include <stdlib.h> // 包含标准库函数的头文件：如果不使用system()函数，可以不包含  int main() { // C语言主程序入口：无参数     int i, j; // 声明两个整型变量：i, j     i = 1; // 将变量i初始化为1          while (i <= 10) { // 第1个while循环开始，它的执行条件是变量i小于或等于10         j = 1; // 将变量j初始化为1         while (j <= i) { // 第2个while循环开始，它的执行条件是变量j小于或等于i             printf(\"OK  \\n\"); // 每一循环，在控制台窗口上打印\"OK\"并换行             // printf(\"i = %d, j = %d, OK\\n\", i, j); // 可以把i,j的值都打印出来，更好理解它             j++; // 每一循环，变量j自增1，也就是j = j + 1;         }         i++; // 每一循环，变量i自增1，也就是i = i + 1;     }          system(\"pause\"); // 调用系统命令，暂停程序运行，直到按下任何键才继续          return 0; // 程序结束，并返回值0（返加值0通常表示程序没有问题） }  // 进阶学习，可以发现，将上述程序改为for循环更好，可以试一下能否自己改为for循环呢？", "referer": "user-0"}]}
{"question": "同时int两个变量，为什么一个是0而另一个是1？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "变量是先定义再赋值最后是使用。int i,j;这样写只是定义了两个变量，从内存的角度说就是分配了两个连续的4字节空间，用于存储i和j。但是没有给这两个空间中赋初始值，内存中现有的数据是什么，谁都不知道。所以就出现你说的这种情况。你反复的执行这段代码，每次执行可能都没有更改分配到的内存空间，所以是你看的的样子。你把代码换到其他人的电脑上试试，或者重启计算机后再运行，可能结果就不一样了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "程序里未初始化的变量，相当于食堂里的碗（这个比方有点恶心，忍一忍）由于是内存里的事，不涉及卫生，所以这俩碗没必要洗，接着用就行。之前盛过米饭的就有两粒米在上面，之前盛过肉片的就有两滴油在上面。你碰巧拿的就是这俩碗，你喜欢叫它 i 或者 j 都无所谓。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "函数内的变量是在栈里的，其初始内容，和调用这个函数的那里刚才如何使用堆栈有关，尤其的之前调用的另外个函数，操作和动作比较固定，那这里基本上也是固定。可以试试把这个函数复制为另外个名字，先调用复制后的，给 i 和 j 设下值，再进这个函数直接看看是什么内容。", "referer": "user-0"}]}
{"question": "求大佬帮助指点，不知道哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "定义的数组太小，题目里明确了数组大小要到1000×1000", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1、是不是忘记判定数组的大小（n)是否有效？操作（b）是否有效？行列号（c）是否有效？2、每个操作（b）最后都要用同一语句：printf(\"\\n\");，是不是可以放到for(i=0;i<a;i++)循环体的最后呢？", "referer": "user-0"}]}
{"question": "此道wihle题，为什么我的写法和书上的不一样？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两个情况下，分别输入 0 看看结果？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "确实，书后面也有注释，我没看到", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "我们小学数学里面，明确最小的一位数是1，不是0，你是对的。", "referer": "user-0"}]}
{"question": "为什么while里不能用1来表示", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你就这么无视题意地追求死循环么？必要时可以写死循环，关键是...到必要时了么？", "referer": "user-0"}]}
{"question": "为什么我输入0后它还是让我继续输入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，请修改条件：while(i != 0)", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "那可以告诉我while(1)怎么用吗？感激不尽", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "非要用while(1)不可，这么倔强吗？那就在scanf(\"%d\", &i);这一行的后面，增加1个退出条件：if (i ==0) break;", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "OK，谢谢你", "referer": "user-1"}]}
{"question": "这个删去重复数字的代码哪里出问题了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，同一个数组，你左移一下，右移一下，就会出现空窿，还是原来的数组吗？不就是删除重复的数字吗，为什么要搞的这么复杂呢？在输入的时候，查询一下数组有没有刚输入的数字，有就取消它，让它重新输入就不行了吗？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "可是我不知道怎么取消它，能给点提示吗", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "同学，代码如下，所有提示非必要，只是让人容易理解： #include <stdio.h>  int main() {     int N = 5;     int num[N];     int i, j, k;     int n, repeat;      for (i = 0; i < N;) {         printf(\"请输入第%d个数字（共%d个）：\", i + 1, N);         scanf(\"%d\", &n);         repeat = 0;         for (k = 0; k <= i; k++) { // 查询已输入的数字，有没有重复的             if (num[k] == n) { // 已有这个数字，不记录它，重新输入                 repeat = 1;                 break;             }         }         if (!repeat) { // 没有重复，记录它             num[i++] = n;         } else {             printf(\"数字：%d已存在，请重新输入！\\n\", n);         }     }      // 打印出来，验证有没有重复 //    for (i = 0; i < N; i++) { //        printf(\"num[%d] = %d\\n\", i, num[i]); //    }      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢感谢", "referer": "user-1"}]}
{"question": "为什么红字部分和橙色部分位置互换结果不一样", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf接受%d%e%f%lf%u等等数值数据的时候会跳过前置白空格找到合适的数据，读到不能接受的字节为止，然后把不接受的内容留在缓冲区里。然而%c不行，它只抓缓冲区里的第一个字节，不管它是啥。红字在上的时候，刚开始运行，缓冲区是空的，看起来正常。红字换到橙色下方，它就只能收到缓冲区里遗留的空格回车神马的了。除非先清空一下标准输入缓冲区rewind(stdin);", "referer": "user-0"}]}
{"question": "PTA最后一个测试点过不了，大佬帮我看看哪里错了呜呜呜", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，我写了一个不使用递归，而且，很容易理解的代码，请参考： #include <stdio.h>  #define MaxWorks 100  int main() {     int works; // 工作数量     int feeList[MaxWorks][MaxWorks]; // 费用列表     int workers[MaxWorks]; // 工人的标记     int jobs[MaxWorks]; // 工作的标记     int maxFee = 0; // 最大费用     int totalMinFee = 0; // 最小费用合计      printf(\"请输入工作数量：\");     scanf(\"%d\", &works);     if (works <= 0 || works > MaxWorks) {         printf(\"输入的工作数量无效!\\n\");         return 1;     }      for (int i = 0; i < works; i++) {         for (int j = 0; j < works; j++) {             printf(\"请输入第%d行，第%d列个工作的费用：\", i, j);             scanf(\"%d\", &feeList[i][j]);             maxFee += feeList[i][j]; // 累计所有工作费用作为最小工作费用的初始值         }         workers[i] = 0; // 初始化工人的标记         jobs[i] = 0; // 初始化工作的标记     }           for (int k = 0; k < works; k++) {         int minFee = maxFee; // 最小费用         int workerTag; // 已分配的工人标记         int JobTag; // 已分配的工作标记         for (int i = 0; i < works; i++) {             if (workers[i] != 0) { // 此工人已有工作，跳过它                 continue;             }             for (int j = 0; j < works; j++) {                 if (jobs[j] == 0 && feeList[i][j] < minFee) { // 此工人收取的最小费用是最低的                     minFee = feeList[i][j];                     workerTag = i;                     JobTag = j;                 }             }         }         totalMinFee += minFee;         workers[workerTag] = 1;         jobs[JobTag] = 1;         printf(\"k = %d, workerTag = %d, JobTag = %d, minFee = %d\\n\", k, workerTag, JobTag, minFee);     }      printf(\"最小的工作费用：%d\\n\", totalMinFee);      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "同学，你想的太复杂了，需要用到递归算法吗？而且，你的代码有几个地方不合理，我试试改一下，你参考： #include <iostream> using namespace std; int n;  int fee[100][100];//工作费用矩阵 int minfee = 100000; //最小的费用（这个假设是不合理的） int curfee;//目前的费用 int x[100];//记录工作分配方案 void swap(int a, int b) {     int tmp = x[a];     x[a] = x[b];     x[b] = tmp; }  void Backtrack(int t) { //遍历第t层     if (t > n) { //判断是否到达叶子节点         if (curfee < minfee) {             minfee = curfee;             return; // 改在这里         }         // return; 不能在这里就返回了！     }     for (int i = t; i <= n; i++) { //第t次选择要走到的城市         if (curfee + fee[t][x[t]] < minfee) { //提高效率，剪枝,限界函数             swap(t, i);             curfee += fee[t][x[t]];             Backtrack(t + 1);             curfee -= fee[t][x[t]];    //回溯             swap(i, t);         }     } }  int main() {     cin >> n;     for (int i = 1; i <= n; i++) { //输入工作费用         for (int j = 1; j <= n; j++) {             cin >> fee[i][j];             minfee += fee[i][j]; // 累计所有的工作费用作为最小的费用         }         x[i] = i; // x数组初始化(不需要多一个循环对它进行初始化）     }     // for (int i = 1; i <= n; i++) { // x数组初始化     //    x[i] = i;     // }     Backtrack(1);     cout << minfee; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "同学，为什么例子给出的答案是9，不是8吗？难道，我理解错了？它是标准答案，还是随便举例子？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "标准答案.我的理解是三份工作三个人，安排每个人做不同的一份工作，比如第一排取2，第二排取4，那第三排只能取3", "referer": "user-1"}]}
{"question": "Notepad++中配置C++编译环境问题。MinGW成功安装，但notepad里运行仍有看不懂的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "缺依赖，要么是你没有引对头文件，要么是没有加动态库，具体缺啥得看代码", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1"}]}
{"question": "阶乘与（-1）的n次方的累加和输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "a*=m;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢大佬", "referer": "user-1"}]}
{"question": "我用if else语句，是否有更简洁的写法？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "f = (a > 1000 ? 8 + (a - 501) / 500 * 4 : 8) + (c != 'N' && c != 'n') * 5;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "同学，请参考： #include <stdio.h>  int main() {     int a, b, f; //a是重量，b是超重部分，c是加急，f是总费用     char c;      printf(\"输入重量，是否加急？\");     scanf(\"%d %c\", &a, &c);     b = (a - 1000) / 500;      f = 8; // 基本费用，一定要收的     if (a > 1000 && a % 500 != 0) { // 整收         b++;     }     f += b * 4; // 超重收费     if (c == 'y') { // 加急费         f += 5;     }      printf(\"总费用为：%d\", f);      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢", "referer": "user-2"}]}
{"question": "为什么这个循环输入数组没有输出结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "差点怀疑之前学的东西。。。scanf(\"%d \",&a[i]); 多了一个空格。", "referer": "user-0"}]}
{"question": "关于switch语句的嵌套问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，你第2个switch语句的break只能中止当前switch，出来后还是继续执行第1个switch语句的4，6，9，11后面的case！", "referer": "user-0"}]}
{"question": "定义一个字符数组a，字符数组a中的字符是有序的；另一个字符数组s是无序的。要求将数组s中的字符插入到有序字符数组a中(大佬求解！)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include <string.h> int main() {     char a[100] = \"afhjlmp\";     char s[100] = \"boimyr\";     int lb = strlen(s);     for (int j = 0; j < lb; j++) {         int la = strlen(a) - 1;         while (la >= 0 && a[la] > s[j]) {             a[la + 1] = a[la];             la--;         }         a[la+1] = s[j];      }     for (int i = 0; a[i]; i++) {          printf(\"%c\", a[i]);     } }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "同学，你想的太复杂了，排序首先冒泡啊，学C语言必会的排序，请参考： #include <stdio.h>  int main() {     char a[] = \"afhjlmp\";     char s[] = \"boimyr\";      // 1、先连接成一个字符串     strcat(a, s);     int len = strlen(a);     // 2、使用冒泡重新排序它     for (int i = 0; i < len - 1; i++) {         for (int j = 0; j < len - i - 1; j++) {             if (a[j] > a[j + 1]) { // 从小到大排序                 char temp = a[j];                 a[j] = a[j + 1];                 a[j + 1] = temp;             }         }     }     // 打印排序好的字符串     printf(\"%s\\n\", a);      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢Thanks♪(･ω･)ﾉ 又学到一个新方法。 不过我已经写出来了--- #include&lt;stdio.h&gt; #include&lt;string.h&gt; int paixu(char *arr ,char *brr); int main(){   char c[20]=\"awfer\";  char x[]=\"crf\";  paixu(c,x);  } int paixu(char *arr,char *brr){  int n,m;  n=strlen(arr);  m=strlen(brr);  int i,j,k;  for(i=0;i&lt;m;i++){   for(j=0;j&lt;n;j++){    if(arr[j]&gt;brr[i]){     for(k=n;k&gt;j;k--){      arr[k]=arr[k-1] ;     }     arr[j]=brr[i];      break;    }   }   n++;  }  puts(arr); }", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "同学，题意不明啊，插入有序数组后，是否要保持有序，还是间隔插入即可？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "要保持有序", "referer": "user-2"}, {"cid": "6", "user": "user-3", "content": "a[] 没有给 s[] 留下空间啊；还是要用到各自字符串长度，因为 a[] 里后移给 s[?] 腾空间时，是要从最后一个字符向前移的。具体的细节上的问题也有，因不合大的逻辑就不提了。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "需要a数组留一定的空间吗，我原以为不给定范围数组会自己判断", "referer": "user-3"}]}
{"question": "有老板知道这个用c语言怎么写么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，怎么不是王子呢？呵呵，请参考我的代码： #include <stdio.h> #include <math.h>  #define TargetNumber 7140229933 // 目标是10位数，可以由2个5位数相乘得到 #define StartNumber 10000 // 最小的5位数 #define EndNumber 99999 // 最大的5位数  int PrimeList[EndNumber - StartNumber]; int TotalPrime = 0; void makePrimeList();  int main() {     makePrimeList();     for (int i = 0; i < TotalPrime; i++) { // 双循环，暴力求解         for (int j = 0; j < TotalPrime; j++) {             // 我的妈啊，这句花了我不少时间，dev-c++居然要强转，让我怀疑人生啊！             long long int m = (long long int) PrimeList[i] * PrimeList[j];             if (TargetNumber == m) {                 printf(\"公主的微信号：li%d%d\\n\", PrimeList[i], PrimeList[j]);                 return 0;             } else if (m > TargetNumber)  { // 小小优化                 break;             }         }     }      return 0; }  // 产生质数列表 void makePrimeList() {     long m, k, i;     for (m = StartNumber; m < EndNumber; m++) {         k = (int)sqrt((double)m);         for (i = 2; i <= k; i++) {             if (m % i == 0) {                 break;             }         }         if (i > k) {              PrimeList[TotalPrime++] = m;         }     } }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "83777 85229", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "BTW：要通过做题之前的海选，叫九章啊，九歌啥的还行，叫九离那很有可能就没机会做题啊。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "最简单就是用暴力求解啦", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "你想应聘驸马就要自己写出来～", "referer": "user-0"}]}
{"question": "位置不相交嘛意思，一头雾水？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "意思就是不同类型的括号不能有交叉，([)]这种", "referer": "user-0"}]}
{"question": "总说超出时间限制，请求支援", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "试看int n = 0; while (n > -1)scanf(\"%d\",&n);total/=q;...", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我考试的时候，通常出现超时，都是算法比它的标准答案复杂，优化后都能通过。这1行：printf(\"%.1lf %d\\n\",1.0*total/q,num);total本身就是double，为什么还要乘1.0呢，它会不会认为是多余，所以，就说超时呢？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "如果还不行，估计最大可能就是这行：while(scanf(\"%d\",&n)!=EOF&&n!=-1)太复杂了，输入的时候几乎没可能出现EOF，把这个条件删除了，直接改为：while(scanf(\"%d\",&n)&&n!=-1)", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "同学，代码应该没有问题啊，是不是最后的输出行格式不对了？把它改成这样试试： printf(\"%.1lf\\t%d\\n\", 1.0 * total / q, num);", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "还是不行，而且提示答案错误", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "我考试的时候，通常出现超时，都是算法比它的标准答案复杂，优化后都能通过。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "希望有空的大佬能瞄一下我的题，万分感谢", "referer": "user-0"}]}
{"question": "C语言中自增自减问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "为啥写这么复杂的程序，炫技么？如果不炫技，拆开写吧，另外同一个编译器可能理解一致，换平台就不好说了，所以不要搞这种花里胡哨的", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C说，它得几都行。所以我们不能这么写代码。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "1、前置++/--在此行的语句中，是先执行+/--+，再执行本行语句2、后置++/--在此行的语句中，是先执行本行语句，再++/--所以，输出是5是对的，但，此行执行完后，c的值就等于6了3、另外，不同的编译器对很复杂的前置++/--、后置++/--的解释可能是不一样的（特别是在同一条语句有多个++或--）", "referer": "user-0"}]}
{"question": "求助求助孩子想不懂啊。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，你传进函数的结构体变量不能是传值啊，要么传指针或引用，否则，传到函数里面是它的复制品，在函数内修改的是复制品，不是你想要的。", "referer": "user-0"}]}
{"question": "求助，求大神指导！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  int main(int argc, char *argv[]) {     for (int i = 1; i <= 9; i++) {         for (int j = 1; j <= i; j++) {             printf(\"%d x %d = %d\\t\", i, j, i * j);         }         printf(\"\\n\");     }      return 0; }   ```c    ```", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "看我博客，有详解版，怎么打印9*9乘法口诀表", "referer": "user-0"}]}
{"question": "想请问一下这个程序超时应该怎么改？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，我看你的代码很费劲，你直接把问题写出来，我们一起学习，可能我写代码比修改你的更快呢", "referer": "user-0"}]}
{"question": "用指针修改const int为什么打印出来还是原值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "使用指针操作常量区是没有任何问题的，但有时即使修改了常量区的值也对运行结果没有影响，编译器会优化在使用常量时不去常量的存储位置取值，而是编译阶段直接将值写入到代码区 另：即使写入到代码区的值也可以修改，通过某种神奇的方法找到编译后代码的位置，将逻辑修改为从内存寻值；或者暴力点内嵌汇编......https://blog.csdn.net/weixin_39583222/article/details/117062110", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不知道你想干啥？ const， 又要非const，你写规则这么复杂的程序，不怕别人看不懂么？ 还是就想别人看不懂", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "同学，关键字const的作用是不是忘记了？你是不能更改const声明的变量的值的，把它去掉试试吧！", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "const是可读常量，视频讲解的就是可以通过指针来修改const常量，我去查了查这种现象叫做常量折叠，有的说可以显示出来不同的值，有的说相同的值", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "如果是C语言，除非是特定的编译器，一般正常的编译器都不支持修改const常量，再说，你都把它声明了常量，还去修改它，这不是折腾吗？不管如何，有这么厉害的视频，贴个地址，我上去学习一下！", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "我老师说，C++还有一个关键字：volatile，在const加上这个，有些编译器是可以编译通过的，不过，这样做真是没事找事，真折腾了！", "referer": "user-3"}, {"cid": "7", "user": "user-4", "content": "你的源代码文件扩展名是.c么？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "是的", "referer": "user-4"}]}
{"question": "新手照抄为什么都报错啊？求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "换visual studio吧 devc++不还用。。vs全给你部署好了 有问题可以百度  很多人用 很多回答", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "他这会儿在自闭中。。用个好点的IDE，加个插件。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢大家", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我弄好了", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "同学，你在第9行重复定义了struct Student，这里的定义是空的结构，把此行前面的关键字struct 去掉试试。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "没有用", "referer": "user-3"}, {"cid": "7", "user": "user-4", "content": "4 float score;16 c.next=NULL;21,22行有不是字母数字的汉字字符", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "{printf(\"%ld%5.1f\\n\",p-&gt;num,p-&gt;score);     p=p-&gt;next;    } while(p!=NULL)；     return 0； 没有吧，老师你看看", "referer": "user-4"}]}
{"question": "有没有检测C代码规范的工具？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "轻量级的可以试下PC-Lint，重量级的可以用klockwork和coverity。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C++Builder有CodeGuard", "referer": "user-0"}]}
{"question": "get 传参问题，该如何解答。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "如果是data的话，url上面没有参数", "referer": "user-0"}]}
{"question": "c语言循环结构求输入的数字是几位数。十位数以上的为什么判断不了位数？ 跪求！谢谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你用int num存储输入的数，但是int是有极限的，你可以试试输入10位以上的数，用int型保存，然后输出，你会发现并不会输出你输入的数，所以你要存储输入的数字，就需要考虑上限会输入多少，以及用什么去存储，然后再解析", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "因为存不下。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "同学，我突然想到一个很简单的方法，请参考： #include <stdio.h> #include <string.h>  int main(int argc, char *argv[]) {     int a, num;     a = 0;     printf(\"请输入一个正整数：\");     scanf(\"%d\", &num);     char sBuffer[255];      sprintf(sBuffer, \"%d\", num); // 把输入的整数转为字符串     printf(\"%d\\n\", strlen(sBuffer)); // 字符串的长度就是它的位数      return 0; }", "referer": "user-0"}]}
{"question": "C语言读取二进制文件出错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "指针这一概念在内存中实现是地址在文件中实现是文件偏移量", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fwrite(&da,sizeof(DynamicArray),1,fp); 这种写法只能把指针地址和后面两个long 变量写入文件。 想要把指针结构体内容写入文件，可以这么写fwrite(&da.item[0],sizeof(Item),1,fp),接着把另外两个变量写入，读取的时候也要这么处理。 针对数组长度大于1的，循环写几遍或者一次性写入sizeof(Item)*数组长度。  读取的时候建议把    long maxSize;    long currentSize;连个变量放在结构体最前面，先读取数组长度，然后根据数组长度再去读取指针内容", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "我好像发现问题所在了，保存数据到文件中的是动态数组的地址。下次取出来的时候，取出的是一个地址，而不是一个结构体。然后这个地址与某个其他地址冲突导致异常。但是发现问题了，我也不知道怎么实现将动态数组存入文件中。", "referer": "user-0"}]}
{"question": "sprintf赋值255个char型数组 有什么好方法？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#pragma warning(disable:4996) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include <stdio.h> char s[8192]; int DayGridWeights[255]; int NightGridWeights[255]; int i,L,p; int main() {     for (i=0;i<255;i++) {           DayGridWeights[i]=i;         NightGridWeights[i]=i;     }      p=0;     L=0;      p+=L;  L=sprintf(s+p,\"{\\\"DayGridWeights\\\":[\");     for (i=0;i<255-1;i++) {         p+=L;  L=sprintf(s+p,\"%d,\",DayGridWeights[i]);     }     p+=L;  L=sprintf(s+p,\"%d]\",DayGridWeights[255-1]);      p+=L;  L=sprintf(s+p,\",\\\"NightGridWeights\\\":[\");     for (i=0;i<255-1;i++) {         p+=L;  L=sprintf(s+p,\"%d,\",NightGridWeights[i]);     }     p+=L;  L=sprintf(s+p,\"%d]}\",NightGridWeights[255-1]);     p+=L;      printf(\"len:%d\\n\",p);     printf(\"%s\",s);      return 0; } //len:1861 //{\"DayGridWeights\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254],\"NightGridWeights\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254]}", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我的理解，你是不是想这样做：     char buffer[255];     for (int i = 0; i < 255; i++) {         sprintf(buffer, \"{i = %d, \\\"DayGridWeights\\\":[%d],\\\"NightGridWeights\\\":[%d]}\", i, DayGridWeights[i], NightGridWeights[i]);         printf(\"buffer = %s\\n\", buffer);     }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "sprintf函数会清空的，你这相当于重复赋值了255次而已。 sprintf(buffer, \"%s {i = %d, \\\"DayGridWeights\\\":[%d],\\\"NightGridWeights\\\":[%d]}\",buffer, i, DayGridWeights[i], NightGridWeights[i]); 这样才能把255次拼接成一个字符串", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "不好意思 我应该表达的不清楚 我想是：sprintf(\"{\\\"DayGridWeights\\\":[%d,%d,%d....],\\\"NightGridWeights\\\":[%d,%d,%d....]}\", DayGridWeights[0],DayGridWeights[1],DayGridWeights[2],.....NightGridWeights[0],NightGridWeights[1],NightGridWeights[2]........)); 一次把225个成员全部赋值进去，一个一个的 一直要写225次，太麻烦，所以想问下有没有简单的方法", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "开个大区间，循环了往里加，一次加一组数据？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "不好意思 我应该表达的不清楚 我想是：sprintf(\"{\\\"DayGridWeights\\\":[%d,%d,%d....],\\\"NightGridWeights\\\":[%d,%d,%d....]}\", DayGridWeights[0],DayGridWeights[1],DayGridWeights[2],.....NightGridWeights[0],NightGridWeights[1],NightGridWeights[2]........)); 一次把225个成员全部赋值进去，一个一个的 一直要写225次，太麻烦，所以想问下有没有简单的方法，，sprintf怎么用循环往里加？恕我知识浅薄，麻烦详细说明", "referer": "user-4"}, {"cid": "7", "user": "user-5", "content": "根据已有的描述，无法理解你的意图。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "不好意思 我应该表达的不清楚 我想是：sprintf(\"{\\\"DayGridWeights\\\":[%d,%d,%d....],\\\"NightGridWeights\\\":[%d,%d,%d....]}\", DayGridWeights[0],DayGridWeights[1],DayGridWeights[2],.....NightGridWeights[0],NightGridWeights[1],NightGridWeights[2]........)); 一次把225个成员全部赋值进去，一个一个的 一直要写225次，太麻烦，所以想问下有没有简单的方法", "referer": "user-5"}]}
{"question": "如何用C语言将txt文本中的数据改成如下的格式", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#define _CRT_SECURE_NO_WARNINGS #include \"Stdio.h\" #include \"Conio.h\" #include <sys\\stat.h>  #include <time.h> #include \"ctype.h\" #include \"stdlib.h\" #include \"string.h\"   char* NopEnter(char* str)  // 此处代码是抄的,  但是比较 好懂. {     char* p=NULL;          if ((p = strchr(str, '\\n')) != NULL)     {     *p = '\\0';          }              return str; }   int main() {     FILE* fpSS;     FILE* fpDS;     int err;     char* str;     char* temp;     char t11[] = \"  1\\n\";     char t22[] = \"  0\\n\";     //指定哪行需要标识，且标识为是0还是1     //第一行 需要标识 ，标识 为0     //第二行需要标识 ，标识 为1     int a[10][2] = { 1,0,2,1,3,0,4,1,6,1,8,1};     int j = 1;     int i = 0;     char t3 = 0;     system(\"color 17\");      str = (char*)malloc(sizeof(char) * 101);     temp = (char*)malloc(sizeof(char) * 101);     err = fopen_s(&fpSS, \"filess.txt\", \"r\");     err = fopen_s(&fpDS, \"fileds.txt\", \"w\");     if (fpDS == NULL)     {     puts(\"-fileds.txt- 文件打开错误!!\\n\");     exit(-1);     }     if (fpSS == NULL)     {     puts(\"-filess.Txt- 文件打开错误\\n\");     fputs(\"源文件打开错误!\", fpDS);     exit(-1);     }       while (fgets(str, 100, fpSS) != NULL)     {          if (j == a[i][0])   //需要标识      {          puts(str);         str = NopEnter(str);  //去掉回车          t3 = a[i][1];         if(t3==1)         strcat(str, t11);         else         strcat(str, t22);                   fputs(str, fpDS);         i++;     }     else  //不需要标识      {         fputs(str, fpDS);     }          j++;      }     fclose(fpSS);     fclose(fpDS);         return(0); }   ```c    ```", "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-3", "content": "根据现有描述不足以理解您的意图。", "referer": "user-0"}]}
{"question": "在编辑数据结构线性表的顺序储存结构上出现取消对null指针的引用 咋解决啊大佬们？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我想知道99个闲置的结构体是干啥用的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "高版本高要求啊，连 scanf 都不让用了，用 vc2008 cl 了下，没有这些问题。点下前面的小三角，看看怎么个解释和建议，照着做就是了；就如下面的对 scanf 的说明。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "好吧ヽ( ￣д￣;)ノ 我就想把书上的东西好好自己弄一下  下个2022还有问题了真的是", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "那我感觉真的好挫败啊  昨天为这个折腾半天 刚刚我用vc运行出来了  唉😔", "referer": "user-2"}]}
{"question": "程序设计题——小白求救SOS！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为不知道你是否确定输入只有4个整数，我将它的输入范围设定为最多100个整数，请参考： #include <stdio.h>  #define MaxData 100  int main(int argc, char *argv[]) {     int data[MaxData];     int count;      printf(\"请输入整数的个数：\");     scanf(\"%d\", &count);     if (count > MaxData || count <= 0) {         printf(\"整数的个数不能超过%d，也不能是负数或等于0！\\n\", MaxData);         return 0;     }      int maxNumber = 0;     for (int i = 0; i < count; i++) {         printf(\"请输入第%d个整数：\", i + 1);         scanf(\"%d\", &data[i]);         if (data[i] > maxNumber) {             maxNumber = data[i];         }     }      for (int result = maxNumber; result > 0; result++) { // 暴力求解         int isOK = 1;         for (int i = 0; i < count; i++) {             if (result % data[i] != 0) {                 isOK = 0;                 break;             }         }         if (1 == isOK) {             printf(\"它们的最小公倍数是：%d\\n\", result);             break;         }     }      return 0; }", "referer": "user-0"}]}
{"question": "这代码没错啊，为什么PTA显示部分正确？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我最后将感叹号改成中文的就可以了😅", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> int main(int argc, char *argv[]) {     int m;     scanf(\"%d\", &m);     switch (m) {         case 1:             printf(\"星期一 8节课\\n\");             break;         case 2:             printf(\"星期二 10节课\\n\");             break;         case 3:             printf(\"星期三 6节课\\n\");             break;         case 4:             printf(\"星期四 8节课\\n\");             break;         case 5:             printf(\"星期五 6节课\\n\");             break;         case 6:         case 7:             printf(\"今天没有课，可以好好休息一下啦!\\n\");             break;         default:             printf(\"输入无效，只能输入1-7!\\n\");             break;     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "switch完整呗。吧default:break;也加上试试", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "这个也没错：int main(){return 0;}", "referer": "user-0"}]}
{"question": "大一新生，讲的递归调用，不知道哪里错了，求大神解答  ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1：注意if(c=='+') 这里的写法，常量写前面。2：F函数再加一个非 +-*/的 else分支3：除法要判断一下被除数是否为0", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "要说错，可能是标题里提及的“递归调用”，而你这里，却没有，虽然我也看不出来你代码里表现出来的功能和递归有多大关系。", "referer": "user-0"}]}
{"question": "排序，从小到大输出n个输入的数字，运行不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for (k = 0; k < n - 1; i++) 这里错误，应该为：for (k = 0; k < n - 1; k++)", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢，自己怎么看都没看出来敲错了。", "referer": "user-1"}]}
{"question": "一个小白对数组的疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "对cout进行了重载，如果是学习C而不是C++，就不应该使用cout，应该先学会使用printf()函数可以这样理解吧：第1个cout << a，相当于printf(\"%p\",a)，第2个cout << a相当于printf(\"%s\",a)", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "重载这个词的意思是，看起来长得一样，其实根本不是同一个东西。我在说流输出运算符。", "referer": "user-0"}]}
{"question": "大家有没有发现最近的品牌电脑读不出来硬盘序列号了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "有类似问题的网友，请百度EasyHardwareID 这个工具", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "原因是wmic不支持NVME。需要自己写", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "都有，在硬盘的SMART数据中", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "scsi硬盘没有smart", "referer": "user-1"}, {"cid": "5", "user": "user-1", "content": "ATA-3+、SCSI-3、SATA、SAS接口的硬盘都支持SMART，基本上90年代后期以来的硬盘全支持", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "硬盘序列号，准确说是IDE标准下的东西，很古老了，具体说就是在某个位置存放的2进制数据。读不出有几种情况：1、本身就没有序列号，比如非IDE类的scsi硬盘；2、读取方法有问题，比如最近这些版本的windows就需要管理员权限之类的才能读取，又比如这些直进制数据本身就是空白的内容，还有一种序列号前面是若干个空格，有的软件没有考虑到这种情况就不能正确处理；3、LZ说的这种，也有可能人家的序列号本身就是那样的，为什么一定要是：非空格的标准ascii字符呢？", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "补充一点：序列号可能有组织或存放形式的区别，或者说对2进制的解析不对", "referer": "user-2"}, {"cid": "8", "user": "user-0", "content": "识别错误的序列号，四位字符间隔", "referer": "user-0"}]}
{"question": "第3个for小括号里面是什么意思啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "逗号间隔的多个表达式", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "i从0开始，条件是i<5，如果满足，那么就做花括号里的，接着i+1，然后再继续判断条件是否成立，成立则做括号里，不成立就跳出了，理解否？", "referer": "user-0"}]}
{"question": "运用数组逆序输出1到11的数字，求问以下代码运行逻辑？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为你运行的exe程序不是你这段源代码生成的。", "referer": "user-0"}]}
{"question": "结构体的地址引用问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼上正解，像楼上一样定义，就没有警告 typedef struct tt{ char data; struct tt *lchild,*rchild; }test;  这个警告就是说你的类型不对应，你这里struct test不规范。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "typedef struct  tt{char data;struct tt *lchild,*rchild;}test;", "referer": "user-0"}]}
{"question": "二叉树建树编译不通过", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改如下，供参考： #include<stdio.h> #include<stdlib.h>  typedef struct TreeNode // 修改 {     char   val;     struct TreeNode* left;     struct TreeNode* right; }TNode, * T_Pointer;  void Build_Tree(T_Pointer& T) {     char ch;     scanf(\"%c\", &ch);     if (ch == '#')     {         T = NULL;     }     else     {         T = (T_Pointer)malloc(sizeof(TNode));         T->val = ch;         Build_Tree(T->left);         Build_Tree(T->right);     } }  void Printf_Tree(T_Pointer& T)//修改 {     if (T != NULL)     {         printf(\"%c\", T->val);         Printf_Tree(T->left);         Printf_Tree(T->right);     } }  int main(void) {     T_Pointer root;     root = NULL;     Build_Tree(root);     Printf_Tree(root);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。", "referer": "user-0"}]}
{"question": "visual studio 2019 Windows 10 sdk的应用实例在哪里？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我的没有。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "", "referer": "user-0"}]}
{"question": "编译后 sum=sum+a[i]*(x^i);为什么说double和int有无效操作", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "c里这个运算符是逻辑异或，不是指数吧，指数要用 pow() 函数。", "referer": "user-0"}]}
{"question": "c语言 怎么把输入的字符串输出成若干个单个的字符啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "存数组里面挨个打印出来啊", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "putchar(a[0]);for(i=1;a[i];i++)printf(\",%c\",a[i]);", "referer": "user-0"}]}
{"question": "浙大的c语言程序设计 page70 例4-1 运行不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%lf\",&eps);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "scanf那里双引号位置错了，谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "双引号敲错位置了。", "referer": "user-0"}]}
{"question": "有关魔方阵，救救孩子吧！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>#include <stdlib.h> int main(){    int n,i,j,k,s[100][100];    scanf(\"%d\",&n);    for(i=0;i<100;i++)        for(j=0;j<100;j++)        s[i][j]=0;//数组初始化    for(i=1;i<=n;i++)//一共n个正方形        for(j=i;j<=2n-i;j++)//坐标从i到2n-i            for(k=i;k<=2n-i;k++)                s[j][k]+=1;//面积填充    for(i=1;i<=2n-1;i++)    {        for(j=1;j<=2*n-1;j++)            printf(\"%d\",s[i][j]);//输出        printf(\"\\n\");    }}", "referer": "user-0"}]}
{"question": "关于谭浩强书里不同类型数据间的混合运算问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "书上说的不对呗内外有别不要混淆语言规则与硬件运算硬件浮点固然都是double的但是语言规则说float/float=float所以那个商是被转换为float，然后再考虑送给printf的", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "请问“硬件浮点固然都是double的”能详细说下是什么意思吗？另外您的意思是：那个商根据c语句规则，就应该是float，然后转换成double类型，传给printf作为参数吗？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "CPU里面或者CPU身边的真正进行浮点运算的部件，它只能处理64位（或更长）的浮点数，它不会处理32位的浮点数。 然而C语言讨论的是内存里面的事儿，float是32位存储单元，double是64位存储单元。对于CPU来说，内存在它外面。 所以按照C语言的规则，我们有三个32位的存储单元，这几个单元向/从浮点运算部件传送数据的时候要有个额外的32/64位格式转换，但这个转换是编译器在后台暗戳戳地加上的，本质上和我们的代码无关。 结论是C程序员只要不写操作系统或编译器，那就应该忽略掉书上“都是double”的描述，这样对谁都好。", "referer": "user-0"}]}
{"question": "延时函数更改值后无变化（延时函数没有延时）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for(j=100;j>0;j--); //改为 for(j=1000;j>0;j--);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#define u16 unsigned short", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "有可能是循环里没实际操作被编译器给优化掉了。应该用 sleep() 类函数吧；用硬循环来实现，即使有效也让人不适（一是不同平台延时不一，二是无谓的消耗）。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不要骗自己啊，unsigned char怎么可能放得下5000呢？就算放得下，延时也还是太短。", "referer": "user-0"}]}
{"question": "一个开辟动态内存后的小问题（再次修改）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不调试的吗？上面代码的 16行有问题吧，不能有它，删除了即可；它即破坏了 原始的 P 这个又要被作为结果返回值的，下面的循环里又有 malloc() 的。", "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-2", "content": "我说的是你之前问的scanf问题，你不要把不同的问题混在一起思考，不利于理顺思路。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "好的哥，salute", "referer": "user-2"}, {"cid": "7", "user": "user-0", "content": "自己尝试debug发现第二个scanf会直接跳过，每两次while才输入一次scanf，不知为何", "referer": "user-0"}]}
{"question": "有没有大佬帮我为什么总么算都是一个数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%lf\",&Amount);把lf改为f就行了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "2000500.00这个工资有点离谱", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "粗看一眼是int 和float疯狂混用，导致commission一直为0？？？，这个是dev c++？debug一下马上就知道为什么了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "float和%lf不搭应该用%f其他逻辑错误慢慢找。", "referer": "user-0"}]}
{"question": "大佬们解释一下这个代码(●'◡'●)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "就是从n到m每个数加起来的和", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "有什么书籍推荐吗", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "明解C语言", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "说句难听的，你不要不高兴。不想学就不要学，但凡把c语言前三章学完了也不会问这种问题", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "了解", "referer": "user-2"}, {"cid": "7", "user": "user-0", "content": "有什么书籍推荐吗", "referer": "user-2"}, {"cid": "8", "user": "user-3", "content": "这个代码还要解释？哪里看不明白？", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "对初学者来说有什么书籍推荐吗", "referer": "user-3"}]}
{"question": "这个在c语言中的意思是什么啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果a是’.‘这个符号，p为真，否则如果 a<=’9‘且a>=‘0’,且!p为真的情况执行下面操作结合语境去看代码啊，单引号内的内容表示为字符而不是真的数字", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if (a == '.')     p = true; else if ((!p) && (a <= '9') && (a >= '0'))    // ....", "referer": "user-0"}]}
{"question": "有没有大佬帮我看看这个代码有什么问题啊？（用的VS2019）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我看最明显的是这个代码不产生输出，但既然你这样写，想必是有自己的理由的，因此对你来说这个不算是问题。", "referer": "user-0"}]}
{"question": "linux下用c写多进程服务器端时，对sigaction函数与信号处理的时机有点小问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "主函数里的调用一系列库函数的顺序，应遵循你学习到的正确顺序，不能自己发挥。因为涉及到库函数里相应数据结构的正确初始化。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "这样子啊，感谢～", "referer": "user-1"}]}
{"question": "编写程序：计算y年m1月d1日与同年的m2月d2日之间的天数（m2>m1）,若m2=m1且d2=d1则算1天。 输入：2017，2，27，3，10 输出：12", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把switch语句放到for(month=0;month<m;month++)这个for循环内，试试。", "referer": "user-0"}]}
{"question": "以下说明语句哪句是错的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Dstutype是typedef定义的类型名", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢！", "referer": "user-1"}]}
{"question": "这个表达式10！=9的值是多少", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "值就是1啊，逻辑表达式如果成立，值就是1，不成立值就是0", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "非零值", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "严格来说，应该是 true 吧，虽然它常被定义为 1", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢！", "referer": "user-3"}]}
{"question": "这个题为什么打印没有输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#pragma comment(linker,\"/SECTION:.rdata,RW\") //加这句可以让常量区可写，后果自负！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "strcat() 的问题吧，它不是形成临时变量，而是把第二个字符串添加到第一个末尾，p1 是没空间存放额外的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢！看来答案有问题", "referer": "user-2"}]}
{"question": "运行结果变量b没有减1", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为逻辑短路", "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": "那个b的值呢？", "referer": "user-0"}]}
{"question": "求教，一直不知道错在哪里了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你试的数不够大。", "referer": "user-0"}]}
{"question": "静态库太麻烦了不同平台不同工程都要重新编译，有没有简单的方式", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "You need a cup of JAVA.", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "可惜用的是C", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "难道这就是JAVA的优势吗？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "大家怎么处理的？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "没人啊？", "referer": "user-0"}]}
{"question": "这怎么解决啊，求解？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先声明那个函数，或者把主函数整个拉到下面去。", "referer": "user-0"}]}
{"question": "为什么会报错[Error] expected declaration specifiers or &#039;...&#039; before numeric constant", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为你把函数调用写成了函数声明的格式。去掉主函数里面的两个void", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我就是声明了一个函数，然后在主函数里面调用这个函数，我这个程序在vss里面可以运行但是到了vec里面就一直说我错", "referer": "user-1"}]}
{"question": "请问这行代码是什么意思？void (*io_isr_cbfun)(u8 index) = NULL;", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼上说的都对 : )", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "给io_isr_cbfun这个指针变量赋初值NULL其类型是一个函数指针，指向  “没有返回值，带一个u8类型的参数index\"这类原型的函数", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "函数指针赋值", "referer": "user-0"}]}
{"question": "C++队列舞会问题触发断点，求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： //舞会上，男士们（m人）和女士们（n人, n<m）进入舞厅时，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。 //男队中未配对者等待下一轮舞曲。现要求写一算法模拟上述舞伴配对问题。在第t首曲子时，第x个女生和第几个男生配对跳舞？ #include <stdio.h> #include <string.h> #define MAX 26 int m,n,t,x,y,i,j,k; char md[MAX]; char nd[MAX]; char c; void main() {     while (1) {         printf(\"Input n m(1<=n<m<=%d):\",MAX);         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&n,&m)) {             if (1<=n && n<m && m<=MAX) break;         }     }     while (1) {         printf(\"Input t x(1<=t<=%d 1<=x<=%d):\",MAX,n);         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&t,&x)) {             if (1<=t && t<=MAX && 1<=x && x<=n) break;         }     }     for (i=0;i<m;i++) md[i]='A'+i;     for (i=0;i<n;i++) nd[i]='a'+i;     k=0;     for (i=0;i<t;i++) {         printf(\"%2d: \",i+1);         for (j=0;j<n;j++) {             c=' ';             if (i==t-1 && j==x-1) {c='*';y=k+1;}             printf(\"%c%c%c\",md[k],nd[j],c);             k=(k+1)%m;         }         printf(\"\\n\");     }     printf(\"%d\\n\",y);  }", "referer": "user-0"}]}
{"question": "求教一道题，请大佬解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "发现问题了，改成5.0就好了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "c=5*...改为c=5.0f*", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "整数计算得不到浮点结果非法数据判断条件也不对", "referer": "user-0"}]}
{"question": "C++作业求大牛看一下 实在是不会！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "发觉自己能力退步了哎  写个这种东西居然调试了很久 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <string.h>  struct Data {     unsigned int s;     unsigned char c[4];     int n,A,B; }; void Clear( Data *d ){ memset( (void*)d,0,sizeof(Data) ); } void Printf( Data *d ){ printf(\"%d%d%d%d\\n\",d->c[0],d->c[1],d->c[2],d->c[3]); } int AddNum( Data *d,unsigned char v ) {     if( (d->s)&(1<<v) ) return d->n;     d->c[d->n++]=v;     (d->s)|=(1<<v);     return d->n; } int Check( Data *d,int in ) {     if(in<1000||in>9999) return 0;     unsigned char c[4]={0};     for( int i=3;i>=0;i-- ){         c[i]=in%10; in/=10;         if( c[i]==0 ) return 0;     }     unsigned int v=0;     for( int i=0;i<4;i++ ){  v|= 1<<c[i];  }     unsigned int n;     for (n = 0; v; v >>= 1) { n += v & 1; }      if(n!=4) return n;     int x=0,y=0;     for( int i=0;i<4;i++ )     {     if( c[i]==d->c[i] ){ x++; }     if( d->s&(1<<c[i]) ) { y++; }     }     d->A=x; d->B=y-x;     return 4; }  int main() {      srand(time(NULL));      Data D;      Clear(&D);      while( AddNum( &D,1+rand()%9 )<4 ){}      unsigned int In=0,Pass=10;      while(1)      {      printf(\"Enter 4 num:\\n\");      scanf(\"%d\",&In);      if( Check( &D,In )!=4 ){         printf(\"Num cant't be 0 or repeat!\\n\");         In=0;      }      else if( D.A==4 ){        printf(\"You win!\\n\");        break;      }      else{ printf(\"%dA%dB\\n\",D.A,D.B); Pass--; }      printf( \"Left:%d\\n\",Pass );      if( Pass==0 ){ printf(\"You lost! Num is:\\n\"); Printf(&D);break; }      }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "百度搜“猜数字 C源代码”，这是经典题目。", "referer": "user-0"}]}
{"question": "萌新发现一个问题，求大佬解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看看C新标准里有没有定义这种用法，没有就是错误的", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好！谢谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "这是要做啥，10个字符指针的数组？应该：typedef char** Strings;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "理解不了的就是不正确的。嗯，编译器理解不了的。", "referer": "user-0"}]}
{"question": "运行之后不显示顺序表的元素，只显示这是一个空表", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "调试啊，写代码不调试是不行的，代码难免会有异常，不能总是寻求别人，自己也未必能一眼就瞅出问题所在。你这个，主要问题可能是在 ListInsert() 函数开头的判断 i<1 这个似乎应该是 i<0 因为首个元素的序号为 0，这样就总也无法插入数据了。", "referer": "user-0"}]}
{"question": "请教一下，这个咋解决， 纯新手，完全不懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "大约是你在42行重复定义了函数f", "referer": "user-0"}]}
{"question": "放在pta上全是段错误 求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "段错误是理论上可以单步找到的。不调试，无新知。", "referer": "user-0"}]}
{"question": "请教一下，这个错在哪里了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "a 是你定义的那个结构的名，不是个变量名；还需定义个变量如 a va1; 然后 ..., &va1.x, &va1.y, ...", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "也就是说仅仅定义了一个结构是不行的，需要再定义结构变量再进行操作是嘛", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "是这个意思。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢", "referer": "user-1"}]}
{"question": "我的问题我的问题求答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我知道了，scanf格式字符串中最后一个转换说明后面打了一个空格。 感谢你们。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "调试卡在scanf这里，就算输入数据一直点下一步也没有办法继续。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "用 switch 不合适吧，要用循环从 1月加到 (month-1)月；而闰月，还要看 month 是不是大于 2 了；严格点儿的话，甚至还应对 month 和 day 进行检查是否合法。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这样的话是结果未必对的问题。然而楼主是输入了没结果。 大概率是输入格式不对，按代码来，年月日空格分开。", "referer": "user-1"}, {"cid": "5", "user": "user-0", "content": "好像也不是，我输入的格式特地加了空格。", "referer": "user-2"}, {"cid": "6", "user": "user-0", "content": "我也想用循环其实，但这里老师要求用switch。 头痛。", "referer": "user-1"}]}
{"question": "请问c语言中这个错误是怎么回事啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的main()函数定义了有返回值，但是，你并没有提供返回值，增加一条return 0;即可 #include <stdio.h> int main() {     char c[] = {\"China\"};          printf(\"%s\", c);          return 0; } ```c", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这就相当于你考试把答案写在草稿纸上，所以没有成绩。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "百度搜了但没看懂", "referer": "user-0"}]}
{"question": "求答，if else问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "float a,b;  //定义单精度浮点数scanf(\"%lf %lf\",&a,&b);// %lf 是错误的，应该为:%fprintf(\"%d\",a); // a 是浮点数，%d 输出是整形数", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "爱你！", "referer": "user-1"}]}
{"question": "请问这个转化为c语言代码是什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if的条件也要使用()包起来", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "if/else内只有一条语句，直接把then去掉就可以了，如果有多条语句，使用{}包起来即可", "referer": "user-0"}]}
{"question": "求教学 感谢大佬帮助！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "能发一个完整的过程么？谢谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "printf(\"%d\\n\",y/4-y/100+y/400);", "referer": "user-0"}]}
{"question": "PTA作业求助，感谢大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>int main(){    int a,b,c,t;    scanf(\"%d %d %d\",&a,&b,&c);    t=a;    a=b;    b=c;    c=t;    printf(\"%d %d %d\",a,b,c);    return 0;}", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf(\"%d%d%d\",&c,&a,&b);printf(\"%d %d %d\\n\",a,b,c);", "referer": "user-0"}]}
{"question": "如何理解for（i=2;i<=m;i++）中i<=m", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "判断一个正整数n是不是素数，只要从2递增判断到小于等于n的平方根的所有素数都不是n的因数，那么n就是素数。", "referer": "user-0"}]}
{"question": "求助，如何从标准输入中读取指令", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "自己逐个字符判断并取子串正则表达式有限状态自动机 以上方法都可行", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "指令库应该是棵树。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "建议了解一下词法分析，和语法分析", "referer": "user-0"}]}
{"question": "socket传输效率问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "无profiler不谈效率", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "脱离实际谈效率那是耍流氓啊。一个长期连接，每10秒发来1字节和文件下载能同日而语么？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "当然是一次读取多个字节，每次recv都会有一次系统调用", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "read 底层不也是 一字节一字节的读吗？", "referer": "user-3"}, {"cid": "5", "user": "user-4", "content": "有文章或者资料吗？想看看read底层实现", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "另外，就算底层是一字节一字节的读，你代码里也写成一字节一字节的读，但是最外面始终都得有个while吧？ ```c read(fd, _1KBData, 1024); // 一次函数调用，底层 for 循环 1024 次 for(int i = 0; i &lt; 1024; ++i) { // 调用时 for 循环 1024 次，同时1024次函数调用     read(fd, &_1KBData[i], 1); } ```", "referer": "user-0"}]}
{"question": "问题。。。。。。。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <=  'z'   ch >= '0' && ch < '9'  ch == 32  else", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fabs(ch-77.5)<12.6 || fabs(ch-109.5)<12.6fabs(ch-52.5)<4.6!(ch-32)", "referer": "user-0"}]}
{"question": "请问这个代码应该怎么写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "小学老师告诉我们，这玩意得拆项消项，它得(double)n/(2*n+1)极限是0.5，不可能得14.2。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "百度", "referer": "user-0"}]}
{"question": "请问这个代码有啥问题（用的VS2019）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf_s(\"%s\",name,(unsigned)_countof(ws));", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改部分如下： scanf_s(\"%s\", name,20);//表示最多读取19个字符，name[19]放'\\0'  输入字符时scanf_s比scanf多一个参数！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢大哥，我自己找了两天都没有搞定，谢谢谢谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "scanf_s(\"%s\"&name);少了&符号", "referer": "user-0"}]}
{"question": "关于vj上Time Limit Exceeded问题的请教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "题目是啥？", "referer": "user-0"}]}
{"question": "各位大佬求解，为啥我的自反闭包会出现乱码？？？最后一行的两个？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这里的else语句，没有使用}吧？else{   int i,j;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "有的", "referer": "user-1"}]}
{"question": "C语言嵌入式开发去哪里招人？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "求职招聘     https://bbs.csdn.net/forums/jobdiscussion?category=0", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢大佬", "referer": "user-1"}]}
{"question": "关于指向数组的指针作函数参数的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为数组名是地址常量，把它传给变量的时候需要类型兼容。score是float [3][4]类型，兼容于指针类型float (*)[4]*score是float [4]类型，兼容于指针类型float *", "referer": "user-0"}]}
{"question": "puts(words);编译器指出words未初始化，怎么回事？？求解。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "换编译器吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我也懵了，感觉没问题的", "referer": "user-1"}]}
{"question": "C语言标准库＜limits.h＞", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "下一篇建议楼主写float.h", "referer": "user-0"}]}
{"question": "如何ros_qt中实现终端快捷指令中用Ctrl+c来结束终端指令", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "百度搜“python 捕获ctrl+c”", "referer": "user-0"}]}
{"question": "求求将下面的C语言转成Java语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "import java.io.IOException; public class MyInput {     public static void main(String[] args) throws IOException {          int x, n, i, j;         x = System.in.read();         n = System.in.read();         int count = 0;         while(0 == count) {             x++;             for(j = 2; j <=x; j++) {                 if (0 == x % j ) {                     break;                 }                 if (x == j) {                     System.out.print(\"x = \" + x + \" \");                     ++count;                 }             }         }     }", "referer": "user-0"}]}
{"question": "为什么当a重复输入时就会出现奇怪的东西求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "char a[81] = {0};char b[81] = {0};或者每次 给数组赋值之前先清理一下数组memset(a,0,sizeof(a));", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "改成char a[81]{0}；b也如此", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "把if语句改为这个试试：        if (a[i] == 'a' || a[i] == 'e' || a[i] == 'i' || a[i] == 'u' || a[i] == 'o' || a[i] == 0x00) {", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "puts(b); 输出字符串吧，字符串，是以 0x00 字节标记结束的，但好像没看到你的代码里有设置这个结束标记字节的地方；puts(b); 前加个 b[c]=0x0; 语句试试？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "字符串的结尾我看书上写的是\\0...我改成\\0行不通改成0x00是可以的谢谢,能告诉一下是为什么吗", "referer": "user-4"}, {"cid": "6", "user": "user-5", "content": "应为\\0这个东西既然叫做转义字符，那就得放在字符该放的环境，单引号里面才是它的用武之地。", "referer": "user-0"}]}
{"question": "求助为啥后面会多一个o", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把if语句改为这个试试：        if (a[i] == 'a' || a[i] == 'e' || a[i] == 'i' || a[i] == 'u' || a[i] == 'o' || a[i] == 0x00) {", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "字符串的结尾我看书上写的是\\0...我改成\\0行不通改成0x00是可以的谢谢,能告诉一下是为什么吗", "referer": "user-1"}]}
{"question": "这个错在哪怎么改求解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你这样是死循环，break只能中止最接近的for循环，不能中止外层的for循环，改成这样试试： #include <stdio.h> int main() {      int i;     int x;     int isprime = 1;     int cnt = 0;     for (x = 2; cnt < 50; x++) {         for (i = 2; i < x; i++) {             if (x % i == 0) {                 isprime = 0;                 break;             }         }         if (isprime == 1) {             printf(\"%d\", x);             cnt++;         } else {             break;         }     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这不是问题，虽然算法上可以改进；主要还是 isprime=1; 放错了地方，应该在 x 循环里的开头。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "我纯新手刚学10天,不对别骂我0.0感觉i和x是不是刚开始都等于2for不太好用", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "isprime=1; 语句要放在 x 循环的首部吧，否则可能会被前次的 isprime=0; 给错了。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "输出时 ％d 后面加个空格把各数据分开，否则全糊在一起看不清。", "referer": "user-2"}, {"cid": "6", "user": "user-4", "content": "至少看上去缺少主函数结束的花括号。", "referer": "user-0"}]}
{"question": "简述学习编程遇到的问题，并求荐书！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个思路有个问题就是，即使有这样的书，也会被抨击以偏概全。或者说适合您的思路的适合您的职业需求的，反而不适用于大多数人。就轮子来说，学机械的可能认为核心是轴承，学化工的可能认为重要的是橡胶优化，学材料的会说核心技术是滚珠的表面热处理。所以写书的人才会泛泛地说轮子。其实是留下空白，也留下无限的可能。  既然说到这儿了，再扯几句。预设过于明确的学习目标，然后围绕这个目标学习，固然看起来效率会提高，但是，我是说但是这正是现行的培养AI的思路！也就是说这样培养出来的“人材”迟早会被AI取代！！！——人类要维持自己对AI的优势，就不能走捷径，只能是广泛学习触类旁通，收敛成自己那棵与众不同的科技树。这就是人类的格。", "referer": "user-0"}]}
{"question": "[Error] invalid conversion from 'char' to 'char*' [-fpermissive]，这是我写的冒泡程序的一部分，标记红色字体的部分都是着给错误，望解惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "字符是字符，字符串是字符串", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "strcpy()是字符串拷贝函数，代码里是要对单个字符操作吗，单个字符可以直接赋值操作：d[i] = sex[i]; sex[i] = sex[min]; sex[min] = d[i];", "referer": "user-0"}]}
{"question": "用c语言编程的时候出现了[Error] ld returned 1 exit status，求大佬帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "函数声明：int getlen(char s[]);函数实现：int gatlen(char s[]){getlen() 写成 gatlen() ，e 写成 a  了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好嘞，谢谢大佬", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "我刚接触c语言编程，还不怎么会哈哈哈，求大佬们指点哈哈", "referer": "user-0"}]}
{"question": "管理代码应该看什么书？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "期待有启发的优质回答！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "使用笔记相关软件使用everything软件", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "工具好说，方法呢？", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "无他，唯手熟尔。", "referer": "user-0"}]}
{"question": "GetFileSize和FTell获取的大小与实际文件获取大小不同", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "是不应该，实际不是同一个文件，或，文件其时被修改了？", "referer": "user-0"}]}
{"question": "c语言的基础，救救我！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "前面输入的回车的残留吧，先用 fflush(stdin); 语句清理下试试？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这是一个历史悠久的错误，fflush是用来处理输出缓冲区的，不应用来处理输入。而且不是清除，而是催促输出不要再缓了。 四老师建议使用rewind(stdin)做这个事儿。", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "谢谢老师的建议，可是我还没学rewind(stdin)，不知道怎么样，我们老师说要加getchar（），但我不知道加哪里", "referer": "user-2"}]}
{"question": "新手小白学习C语言笔记", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "既然问题是无条件的，那么回答也是无条件且不负责任的：从全部学习C语言的人群的统计数据来看，学好的可能性不大。理智地回头吧，不要往坑里跳。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "老哥稳", "referer": "user-1"}, {"cid": "3", "user": "user-3", "content": "好家伙直接劝退", "referer": "user-1"}]}
{"question": "通过宏，怎么判断当前编译器是 gcc 还是 arm-linux-gnueabihf-gcc 呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不用代码格式则连续的下划线被删除了，这个属于csdn特色？ #if defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__)) // gcc ARM/ARM64 compiler #endif  #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64__) || defined(__amd64__)) // gcc x86/x64 compiler #endif", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "多谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "#if defined(_ECLIPSE)||defined(__ANDROID__)||defined(__ARM_EABI__)", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "找不到的话自己制造一个宏就好。", "referer": "user-0"}]}
{"question": "关于在unix中建立C语言编译环境的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "系统自带的，安装好就可以用，方便。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "FreeBSD带有Linux兼容层，所以可以用大部分Linux下的软件，打开一个终端，输入命令：pkg install lang/gcc", "referer": "user-0"}]}
{"question": "C语言中time.h的计时是从1970年开始的，这个怎么改变，比如改为2000年", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "非常感谢大家的回复，非常感谢！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "定义一个偏移量常数，宏替换一下就行了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "自己加偏移量改变一下", "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": "谢谢", "referer": "user-3"}]}
{"question": "大佬们帮忙看看C语言代码，vs2019可以跑，但是vc6反而报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C不够地道，当然不行。改用C++，就行了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码不够ANSI，应该啥也没做之前声明所有变量，包括i，然后再干活。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "明白了", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "源代码扩展名改为.cpp", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "VC6根本不给我出输出窗口", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "抱什么错？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "vs6调试只给了errors（1） 要是知道哪有问题我就自己解决了", "referer": "user-4"}, {"cid": "8", "user": "user-0", "content": "学校非要用vc6上课", "referer": "user-4"}, {"cid": "9", "user": "user-4", "content": "我没有vc6,你把输出窗口的内容贴出来", "referer": "user-0"}]}
{"question": "做作业的时候遇到的问题，求大佬帮看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "要ANSI把变量c的声明提到前面去。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "具体最后代码是什么样的呢，急！", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "行 7 类型前少了分号，看前面好像没少，那可能是误输入了汉字全角的分号？", "referer": "user-0"}]}
{"question": "biosdisk函数报错0x09", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这年头很难找到运行这个的硬件啊。所以我倾向于认为是系统或硬件不支持。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "在dos下创建了软盘", "referer": "user-1"}]}
{"question": "大佬帮忙看看哪里出问题了，刚学编程的小白...", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学会单步和设断点调试", "referer": "user-0"}]}
{"question": "为什么从txt文件读入的数据不能在其他功能上应用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学会单步和设断点调试程序", "referer": "user-0"}]}
{"question": "请问是在哪里添加分号呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第二行末？不过这行完全可以不要，它是主程，无需什么声明或预定义的，毕竟其意义明确，也不会有哪个会引用到它。", "referer": "user-0"}]}
{"question": "c语言帮忙帮忙！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Visual C++ 2010 Express简体中文版 ▼     http://pan.baidu.com/s/1bnwRVLt", "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-2", "content": "你是要学习C语言的软件还是能编译C语言的软件", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "能编译c语言的软件 因为平时学的时候自己也想上手一下", "referer": "user-2"}]}
{"question": "初学者求解关于建立C程序的最基本问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf(\"a=%d(10)=%o(8)=%x(16)\", a, a, a);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢！", "referer": "user-1"}]}
{"question": "这个指针为什么无法输出元素，", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "最后一个 printf() 输出的是指针吧，不是指向的元素；要输出指向的元素的值，应加上取值的 * 如 printf(..., *p, *v, *u);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢，大佬。那大佬怎么保存vs2019的对与处理器的修改。", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "什么是指针指向多维数组？ int a； p=a 那＊p=a是否相等？＊p改变了a改变吗？", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "多维数组，就是如 aArrp[6][8] 这样的有两个或以上下标的数组，指向这样数组的指针就是了。 不相等，应该是 p=&a; 吧，就是把 a 的地址给 p 即让 p 指向 a；这样，*p=b; 就会改变 a 的，使其和 b 内容一样。", "referer": "user-0"}]}
{"question": "C语言求助一题，如何归并两个本就有序的文本文件", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以当cvs文件处理", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "好像是有些麻烦，不如分两步，首先简单合并如 A aaa\\nA bbb\\nA ccc\\nB aaa\\n... 然后再对其进行关键字同项合并。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "好像就是这样，谢谢！但是怎么才能同项合并呢", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "同项合并简单吧，读入一行，分解为关键字和值，比较此关键字和前面是否一样，若一样，输出空格和本次值，若不一样输出回车换行、本次关键字、空格、本次值；继续读入下一行到文件末。", "referer": "user-0"}]}
{"question": "x+z%3*(int)(x+y)%2/4这里的int 是什么意思？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "(type)...将...强转为type类型", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "(int)(x+y) 将 x+y 得到的值取整。", "referer": "user-0"}]}
{"question": "求大神帮忙解答一下为什么程序有时候可以正常运行有时候会崩掉", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "MakeNode() 里的 malloc() 里的 sizeof(ElemType) 是不对的，应该是 sizeof(LNode)", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好像确实是这个问题 不过那为什么总会在第二个循环出错", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "不是总的，我在 win7 32位下用 vc2008 生成，有时第一行就出错的，但在 Ollydbg 加载执行却又能正常，没去细究，大致就是堆内存管理上结构被破坏导致内存访问了错误的地方（malloc() 函数里重设内存块部分）。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "哦哦 好的谢谢", "referer": "user-1"}]}
{"question": "C语言1-100求和", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for后面的；", "referer": "user-0"}]}
{"question": "输入a,b两个数字，求解n的取值范围（新人），求大佬帮忙解惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int a = 2010, b = 2011;     int n = 1;     double tx = 1;     double lf = 1;     bool bf = false;     while (true) {         if (tx >= a && !bf) {             cout << n<<endl;             bf = true;         }         if (tx > b) {             cout << n - 1;             break;         }         n++;         lf = lf + 1.0 / n;         tx = tx + 1.0 / lf;     }", "referer": "user-0"}]}
{"question": "深度解析 Filebeat 工作原理，轻松玩转大数据！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "1", "referer": "user-0"}]}
{"question": " 贪吃蛇（队列实现）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <iostream> #include <iomanip> #include <vector> using namespace std; int main() {     int dir[4][2]{ {0,1},{1,0},{0,-1},{-1,0} };     int n;      std::cin >> n;     int r = n - 1;     int u = 1;     int d = n - 1;     int l = 0;     vector<vector<int>> board(n, vector<int>(n));     int x = 0, y = 0;     int dict = 0;     for (int i = 0; i < n * n; i++) {         board[x][y] = i;         if (y == r && dict == 0) {             dict=(dict+1)%4;             r--;         }         if (y == l && dict == 2) {             dict = (dict + 1) % 4;             l++;         }         if (x == u && dict == 3) {             dict = (dict + 1) % 4;             u++;         }         if (x == d && dict == 1) {             dict = (dict + 1) % 4;             d--;         }         x += dir[dict][0];         y += dir[dict][1];     }     for (int i = 0; i < n; i++) {         for (int j = 0; j < n; j++) {             cout <<setw(4) << board[i][j];         }            } }", "referer": "user-0"}]}
{"question": "多线程间的消息通知机制", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你觉得会有这样的机制吗？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个，好像不需要吧，线程1 写就是了，写完了给线程2 发个自定义消息让它去读；因为要隔段时间才设置一次，不会发生线程1 在写时，上次的线程2 还没读完，除非线程2 读一个字符处理半天再读下一个字符。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "您没明白我的意思，线程2线程1操作共享内存，肯定是要有同步机制的， 但是我还不知道怎么设置同步机制，让他不阻塞，因为像互斥锁这样的同步机制得不到锁是不向下运行的", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "WaitForSingleObject() 这样的函数不是有 dTimeOut 参数吗，到点了即便没拿到所有权，也是会返回的，不会死锁。", "referer": "user-0"}]}
{"question": "低级问题。。。。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "按你的代码，输入的时候71.82和A之间不能留空格。或者按你的输入，最后一个scanf的第一个%c前面留个空格试试。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "噢，是哦，我就说为什么从=c1没输出，原来是输出了空格", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "感谢感谢", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "scanf(\"a=%d b=%d\", &a, &b)改为scanf(%d %d\", &a, &b)scanf(\"%c,%c\", &c1, &c2)改为scanf(%c %c\", &c1, &c2)x,y的值小数点后那么多位是咋回事?在printf中，可以限定小数位的个数为2个，改x=%6.2f,y=%6.2f", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "感谢", "referer": "user-2"}, {"cid": "6", "user": "user-0", "content": "两个%c中间不能用逗号隔开吗？", "referer": "user-2"}]}
{"question": "大佬们，为什么这个程序中第12行sum=sum+1.0/c;是对的，sum=sum+1/c;就错了呢？这个.0有什么讲究吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为常量也有类型", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "sum=sum+1.0/c;算出来是浮点数，sum=sum+1/c;算出来是整数，而且，C语言的整数除法跟我们的算术除法是不同，它不会帮你四舍五入，它是直接不要小数部份，算出来的结果当然是不对了。", "referer": "user-0"}]}
{"question": "大佬们，这咋回事啊，什么意思啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "double后面是分号不是逗号这里printf拼写错误", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请仔细校对标点符号和拼写。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "%lf %16.7lf", "referer": "user-0"}]}
{"question": "学校让做一个词典，加载的时候出问题了，不报错，自动进调试页面 ，希望大佬给看看怎么回事", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "自己改过了 运行成功", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "希望大佬看看是哪里的错误，指正一下", "referer": "user-0"}]}
{"question": "1~4组成无重复数字的三位数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <iostream> #include <vector> using namespace std; void func(int nums[4],int pos,int len,int item[3]){     if (len == 0) {         for (int i = 0; i < 3; i++)             printf(\"%d \", item[i]);         printf(\"\\n\");         return;     }     for (int i = pos; i < 4; i++) {         item[pos]=nums[i];         swap(nums[pos], nums[i]);         func(nums, pos + 1, len - 1, item);         swap(nums[pos], nums[i]);              }  } void pailie(int nums[4], int len) {     int item[3]{ 0 };     func(nums, 0, len, item); }  int main() {     int nums[4]{ 1,2,3,4 };     pailie(nums, 3);     }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//qplw.cpp #include <stdio.h> #include <string.h> #include <stdlib.h> int v=0; int w=0; int m;//记录字符串长度 int n;//记录字符串中的字符种类数 char map[256];//记录是哪几种字符 int count[256];//记录每种字符有多少个 int stack[1000];//递归用的栈，并记录当前生成的排列 void Make_Map(char *str) {//统计字符串的相关信息     int s[256];     int i;     memset(s,0,sizeof(s));     memset(count,0,sizeof(count));     m=strlen(str);     if (w<1 || m<w) w=m;     while(*str) {         s[*str]++;         str++;     }     n=0;     for (i=0;i<256;i++)         if (s[i]) {             map[n]=i;             count[n]=s[i];             n++;         } } void Find(int depth) {//递归式回溯法生成全排列     if (depth==w) {         int i;         for (i=0;i<depth;i++) putchar(map[stack[i]]);         putchar('\\n');     } else {         int i;         if (v && depth>0) {             for (i=0;i<depth;i++) putchar(map[stack[i]]);             putchar('\\n');         }         for (i=0;i<n;i++)             if (count[i]) {                 stack[depth]=i;                 count[i]--;                 Find(depth+1);                 count[i]++;             }     } } void main(int argc,char**argv) {     if (argc<2) {         printf(\"%s 要产生全排列的字符串 [限定长度|-1]\\n\",argv[0]);         return;     }     if (argc>=3) w=atoi(argv[2]);     if (-1==w) v=1;     Make_Map(argv[1]);     Find(0); } //C:\\test>qplw //qplw 要产生全排列的字符串 [限定长度|-1] // //C:\\test>qplw 123 //123 //132 //213 //231 //312 //321 // //C:\\test>qplw 123 2 //12 //13 //21 //23 //31 //32 // //C:\\test>qplw 122333 3 //122 //123 //132 //133 //212 //213 //221 //223 //231 //232 //233 //312 //313 //321 //322 //323 //331 //332 //333 // //C:\\test>qplw 123 -1 //1 //12 //123 //13 //132 //2 //21 //213 //23 //231 //3 //31 //312 //32 //321 //   运行qplw 1234 3输出123124132134142143213214231234241243312314321324341342412413421423431432", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "同学，请参考： #include <stdio.h>  int main() {     int number[] = {1, 2, 3, 4};      for (int indexI = 0; indexI < 4; indexI++) {         for (int indexJ = 0; indexJ < 4; indexJ++) {             for(int indexK = 0; indexK < 4; indexK++) {                 // 保证不重复                 if (indexI!=indexJ && indexI !=indexK &&indexJ!=indexK) {                     printf(\"%d%d%d\\t\", number[indexI], number[indexJ], number[indexK]);                 }             }         }         printf(\"\\n\");     } }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "排列数4x3x2种", "referer": "user-0"}]}
{"question": "问一下为什么LocateList里运行到L->length或L->data程序就会结束", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，你这个 CreateList传入的是一个指向结构体的二级指针，在此函数内使用了malloc分配后，它的地址与你传入的地址是不同的，所以，CreateList返回后，L指向的一个空指针或野指针，所以，你应该传入L的一级指针。还有malloc分配的空间也借了。这个CreateList函数建议简单点，直接传入一个需要创建的元素个数即可，然后，返回创建好的指针，我将它改成这样： /*函数的声明*/ SeqList* CreateList(int n) {     // L = (SeqList *)malloc(ListSize * sizeof(int)); // 原式是错的，分配内存空间与实际的不符     SeqList *L = (SeqList *)malloc(sizeof(SeqList));         printf(\"要输入的元素:\");     for (int i = 0; i < n; i++) {         int p;         scanf(\"%d\", &p);         L->data[i] = p;     }     printf(\"顺序表创建成功:\");     L->length = n - 1;     for (int j = 0; j < n; j++) {         printf(\"%d \", L->data[j]);     }     printf(\"\\n\");          return L; // 返回创建好的指针 }", "referer": "user-0"}]}
{"question": "C语言写简单猜数游戏", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "前几天也有同学发了这个：     https://bbs.csdn.net/topics/601319902  呵呵，你们是不是同一学校？ #include <stdio.h> #include <time.h> #include <stdlib.h> #include <math.h>  int main() { srand(time(0)); int weishu; printf(\"请选择猜的位数【1为一位数 2为2位数 3为三位数】\"); scanf(\"%d\", &weishu); int a = 0; int n = 0; int number = rand() % ((int) pow(10, weishu)) + 1; printf(\"number = %d\\n\", number); printf(\"请输入%d以内的数字\\n\", (int) pow(10, weishu)); do { n++; printf(\"输入你认为的数是：\"); scanf(\"%d\", &a); if (number > a) { printf(\"小了\\n\"); } else if (number < a) { printf(\"大了\\n\"); } } while (number != a); printf(\"对了，你用%d次了\\n\", n); system(\"pause\");  return 0; }", "referer": "user-0"}]}
{"question": "要输出这样一个3*3的二维数组 1 2 3 4 5 6 7 8 9 为什么我这个只有123？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、数组的下标是从0开始，你的2个for循环已经越界2、printf函数的数据类型也不对3、第2个for循环完了后就可以直接换行，为什么要if条件？我把它改了，应该这样就可以了： int main () {    float a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};    int i, j;    for (i = 0; i < 3; i++) {        for (j = 0; j < 3; j++) {            printf(\"%3.0f\", a[i][j]);        }        printf(\"\\n\");    }    return 0;}", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> int main() {     float a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};     int i,j,n;     for(i=0;i<3;i++){     for(j=0;j<3;j++,n++)         { if(n%3==0) printf(\"\\n\");             printf(\"%3.f\",a[i][j]);                     }     } }", "referer": "user-0"}]}
{"question": "为什么会出错代码本身并没有错 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//scanf_s(\"%s\", name,sizeof(name));    scanf_s(\"%s\", name);好像这儿不对。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我没看到上面的C代码里面什么地方引用memset，所以无法理解两个图之间的联系。另外，忠告是关注一下两个warning，也许有什么线索呢。", "referer": "user-0"}]}
{"question": "如何学好C语言，个人认为不错的一篇文章", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个文章也许有部分说得有道理，但是有一个最大的问题：提出了问题，却没有给出解决问题的办法", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "学好C语言，关键是遇到一个会教C语言的老师。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "写这些文章的人，只有两种可能：大牛，扯蛋。对号入座。。如：C语言，谭浩强的C，确实有很多瑕疵，但是适合入门。一个没编程基础的人，看K & R的C，无疑天书。。", "referer": "user-0"}]}
{"question": "统计一个排列中逆序对 的个数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果用的是计算机而不是手机APP的话，往下方看。", "referer": "user-0"}]}
{"question": "跪求大神指导 安装fftw3时 ./configure --enable-mpi CC=mpicc CXX=mpiCC F77=mpif77，结果出来下面的错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主解决了吗 我的也是了！求解", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "--with-compiler=/path/to/gcc", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "try sudo", "referer": "user-0"}]}
{"question": "vc6代码正确，输入数值，不显示结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "好的好的谢谢谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "BTW:scanf的格式串里面，字符是不转义的。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "如果你认定了代码没错的话，那就只能是输入的错了你得输入 11\\n这样然后再敲回车，这样才能满足scanf的胃口。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "代码是没有错，你错在scanf(\"%d\\n\",&x); 这里不应该多加一个换行符\\n，去掉之后，输入数字，直接回车，就可以计算出来了。 但是你加了这个换行符，就相当于你一定要先换行，再输入，才可以。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "代码是没有错，你错在        scanf(\"%d\\n\",&x);", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "scanf()里，把那个 \\n 去掉试试？", "referer": "user-0"}]}
{"question": "求帮助！帮忙改下错误（萌新遇难）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "前两个拼写错误吧，第一个是前面预定义时错写了个小写成 SearchPresentplan，第二个是前面预定义时多敲了个字母 t 成 Intput...第三个，就是定义和使用的类型上不一样，自己看着怎么改吧。", "referer": "user-0"}]}
{"question": "想做一个译码的题，除了把大写字母比如A就专程A+4的字母 ，但是大写字母可以了输入数字或者小写就乱码是什么问题呢，不知道怎么将数组中是数字的单个元素输出，查了百度说如果是用%c输出要将单个元素加''", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "主要问题在于关系运算符不能连着用。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "同学，首先，你不能直接循环整个字符数组，如果输入小于10个字符你就出错了，所以，循环条件改用sizeof更好。大写字母那个条件改为：if (ch[i] >= 65 && ch[i] <=90)，小写字母的条件改为if(ch[i]>=97 && ch[i] <=122)，还要增加一个数字的条件：if(ch[i]>=30 && ch[i] <=39)", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "老师，请问一下在循环条件里面怎么用sizeof", "referer": "user-2"}]}
{"question": "求大佬们支个招呀！！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我用Dev C++可以跑起来", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "代码在哪里？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "重新发了一下", "referer": "user-1"}]}
{"question": "刚大一，这个看不懂，希望老哥们帮忙看一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "此贴终结，输入的时候输入成10,10了，不能用逗号，要用空格", "referer": "user-0"}]}
{"question": "，大一新手。pta一个题目怎么都过不了。麻烦好心人看看哪里错了。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考： #include<stdio.h> int main() {     int T,n,k,s;     scanf(\"%d\",&T);     while(T--)     {         scanf(\"%d\",&n);         s = 0;         while(n--)         {             scanf(\"%d\",&k);             s += k;         }         if(s%5==0 && s%7==0 && s%3==0)             printf(\"YES\\n\");         else             printf(\"NO\\n\");     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢！感谢！", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "第一，你想的太多了。只要判断一组就输出一个结论就行了，不必煞费苦心地“一起输出”。因为OJ系统没有交互式输入，不会乱的。第二，你想的太少了。要是数据组数稍微多一点，你的a根本就不够用。第三，非必要不用浮点数，因为浮点数不精确。我的意思是不要用pow函数。 当然，落实了第一，后面就都是多余的了。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "按照您的思路确实是对的！", "referer": "user-2"}, {"cid": "5", "user": "user-0", "content": "我的代码再要输出十几组是就会出错", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "感谢！", "referer": "user-2"}]}
{"question": "第一次在csdn发帖，本人新手刚入门c语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，提示你变量a和number重复定义了，而且，你写的也太复杂 了，我把它简化了：#include <stdio.h>#include <time.h>#include <stdlib.h>#include <math.h> int main() {    srand(time(0));    int weishu;    printf(\"请选择猜的位数【1为一位数 2为2位数 3为三位数】\");    scanf(\"%d\", &weishu);    int a = 0;    int n = 0;    int number = rand() % ((int) pow(10, weishu)) + 1;    printf(\"number = %d\\n\", number);    printf(\"请输入%d以内的数字\\n\", (int) pow(10, weishu));    do {        n++;        printf(\"输入你认为的数是：\");        scanf(\"%d\", &a);        if (number > a) {            printf(\"小了\\n\");        } else if (number < a) {            printf(\"大了\\n\");        }    } while (number != a);    printf(\"对了，你用%d次了\\n\", n);    system(\"pause\"); return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "出错理由你的图片里已经说的很清楚了。你可以把三个case下面具体的内容分别用花括号括起来试试。", "referer": "user-0"}]}
{"question": "realloc, 静态数组，扩容。为什么可行？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请明白什么是堆，什么是栈，堆是自由存储区，一般使用链表。栈是连续存储区，堆可以改变一个单元大小，但需要你自己去操作他的生死。栈是连续的，有系统自动创建和回收。也就是说一个单元大小确定了就不能更改。因为更改它会影响下一个单元。realloc，malloc free这些都是针对堆，而不能针对栈。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "实践是检验真理的唯一标准。这句话经常有意无意地被误解或者曲解。这种追求易传易记的口号实际上要求简短，所以实际上省略了很多修饰语和限定词。至少不是随便什么行为都有资格称为实践，也不是所有的实践都有资格检验真理的。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "如果这样运行是可以的，那么去掉里面realloc那行以后运行，结果将还是一样的。这就足以说明那句realloc实际上不起作用。  异想天开并非进取之道，还是要把思维调整回到C语言的规范轨道上来。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "这个，应该不可以吧，应该检查一下 realloc() 的返回值。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "既然realloc这么好用，就没有什么风险吗？", "referer": "user-0"}]}
{"question": "c语言贪吃蛇游戏 网上找的代码，根据自己的编译环境作了修改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看看我跟老师学的雷霆战机，有文档、素材、源代码全套：     https://space.bilibili.com/1901488254", "referer": "user-0"}]}
{"question": "哪位大吓有C的题来刷一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "// 下面是我写的代码，使用了二维数组，没有使用结构体#include <stdio.h>#include <string.h> #define STUDENTS 5 // 宏定义学生的人数：5个#define SUBJECTS 5 // 宏定义每个学生的科目：英语、数学、语文、体育、音乐 char Name[STUDENTS][11]; // 定义学生的姓名字符数组：Name[0]=\"小明\"，Name[1]=\"王一呜\"float Score[STUDENTS][SUBJECTS + 1]; // 总成绩=英语+数学+语文+体育+音乐 // 函数的声明// 输入学生的姓名和它每科的成绩void inputDate();// 打印排序前的学生的姓名和成绩void printData();// 按学生的总成绩排序（从高到低：冒泡排序）void sortData(); int main() {    // 1、输入学生的姓名和它每科的成绩    inputDate();    // 2、打印排序前的学生的姓名和成绩    printf(\"排序前的学生的姓名和成绩：\\n\");    printData();    // 3、按学生的总成绩排序（从高到低）    sortData();    // 4、打印排序后的学生的姓名和成绩    printf(\"排序后的学生的姓名和成绩：\\n\");    printData();    return 0;} // 函数的定义// 输入学生的姓名和它每科的成绩void inputDate() {    // 使用for循环，输入每个学生的姓名和他们每科的成绩    for (int indexI = 0; indexI < STUDENTS; indexI++) {        // 1、输入学生的姓名        printf(\"请输入第%d个学生的姓名（一共%d个）：\", indexI + 1, STUDENTS);        scanf(\"%s\", Name[indexI]);        // 2、输入这个学生的每科成绩        printf(\"请输入%s的英语、数学、语文、体育、音乐成绩（使用逗号分隔它们）：\", Name[indexI]);        scanf(\"%f,%f,%f,%f,%f\", &Score[indexI][0], &Score[indexI][1], &Score[indexI][2], &Score[indexI][3], &Score[indexI][4]);        // 3、统计这个学生的总成绩        // Score[indexI][SUBJECTS] = Score[indexI][0] + Score[indexI][1] + Score[indexI][2] +Score[indexI][3] +Score[indexI][4];        Score[indexI][SUBJECTS] = 0.00; // 初始化总成绩为0.00        for (int indexJ = 0; indexJ < SUBJECTS; indexJ++) {            Score[indexI][SUBJECTS] += Score[indexI][indexJ];        }        // printf(\"%s的英语=%8.2f、数学=%8.2f、语文=%8.2f、体育=%8.2f、音乐=%8.2f、总成绩=%8.2f\\n\", Name[indexI], Score[indexI][0],        //       Score[indexI][1], Score[indexI][2], Score[indexI][3], Score[indexI][4], Score[indexI][5]);    }} // 打印排序前的学生的姓名和成绩void printData() {    // 1、打印标题    printf(\"+----------+--------+--------+--------+--------+--------+--------+\\n\");    printf(\"|   姓名   |  英语  |  数学  |  语文  |  体育  |  音乐  | 总成绩 |\\n\");    printf(\"+----------+--------+--------+--------+--------+--------+--------+\\n\");    // 2、使用for循环打印每个学生的姓名和成绩    for (int indexI = 0; indexI < STUDENTS; indexI++) {        printf(\"|%10s|\", Name[indexI]); // 打印学生的姓名        for (int indexJ = 0; indexJ < SUBJECTS + 1; indexJ++) {            printf(\"%8.2f|\", Score[indexI][indexJ]); // 打印学生每科的成绩（包括总成绩）        }        printf(\"\\n\" );        printf(\"+----------+--------+--------+--------+--------+--------+--------+\\n\");    }} // 按学生的总成绩排（从高到低：冒泡排序）void sortData() {    for (int indexI = 0; indexI < STUDENTS - 1; indexI++) {        for (int indexJ = 0; indexJ < STUDENTS - 1 - indexI; indexJ++) {            if (Score[indexJ][SUBJECTS] < Score[indexJ + 1][SUBJECTS]) {                // 1、交换他们的姓名                char tempName[11];                strcpy(tempName, Name[indexJ]); // 把当前位置学生的姓名拷贝到临时变量中                strcpy(Name[indexJ], Name[indexJ + 1]); // 把下一个位置的学生姓名拷贝到当前位置                strcpy(Name[indexJ + 1], tempName); // 把临时变量拷贝到下一个位置的学生姓名中                // 2、交换他们每一科的成绩                for (int indexK = 0; indexK < SUBJECTS + 1; indexK++) {                    float tempScore = Score[indexJ][indexK]; // 把当前位置学生的每一科成绩存放到临时变量中                    Score[indexJ][indexK] = Score[indexJ + 1][indexK]; // 把下一个位置的学生成绩存放到当前位置上                    Score[indexJ + 1][indexK] = tempScore; // 把临时变量存放到下一个位置的学生成绩中                }            }        }    }}", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "#include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996) #define N 5 struct Student {     int name;     float chinese;     float mathematics;     float english;     float sports;     float music;     float total_score; }stu[N]; struct Student* p;    int main() {     printf(\"please enter the grades of Nstudents in each subject:\\n\");     int y;     for (y=0;y<N;y++)     {         scanf(\"%d,%f,%f,%f,%f,%f\",&stu[y].name, &stu[y].chinese, &stu[y].mathematics, &stu[y].english, &stu[y].sports, &stu[y].music );         stu[y].total_score = (stu[y].chinese + stu[y].mathematics + stu[y].english + stu[y].sports + stu[y].music);     }            int i, j, k;     struct Student temp;     for (i = 0; i < N - 1; i++)     {         k = i;         for (j = i + 1; j < N; j++)         {             if (stu[j].total_score > stu[k].total_score) k = j;             temp = stu[k]; stu[k] = stu[i]; stu[i] = temp;         }      }      printf(\"Results of %d students in each subject : \\n\",N);     for (p = stu; p < stu + N; p++)     {         printf(\"name:%d,chinese:%0.2f,mathematics:%0.2f,english:%0.2f,sports:%0.2f,music%0.2f,totoal_socre:%0.2f\", p->name, p->chinese,p->mathematics, p->english, p->sports, p->music,p->total_score);         printf(\"\\n\");     }                       return 0; }        ```c #include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996) #define N 5 struct Student {     int name;     float chinese;     float mathematics;     float english;     float sports;     float music;     float total_score; }stu[N]; struct Student* p;    int main() {     printf(\"please enter the grades of Nstudents in each subject:\\n\");     int y;     for (y=0;y<N;y++)     {         scanf(\"%d,%f,%f,%f,%f,%f\",&stu[y].name, &stu[y].chinese, &stu[y].mathematics, &stu[y].english, &stu[y].sports, &stu[y].music );         stu[y].total_score = (stu[y].chinese + stu[y].mathematics + stu[y].english + stu[y].sports + stu[y].music);     }            int i, j, k;     struct Student temp;     for (i = 0; i < N - 1; i++)     {         k = i;         for (j = i + 1; j < N; j++)         {             if (stu[j].total_score > stu[k].total_score) k = j;             temp = stu[k]; stu[k] = stu[i]; stu[i] = temp;         }      }      printf(\"Results of %d students in each subject : \\n\",N);     for (p = stu; p < stu + N; p++)     {         printf(\"name:%d,chinese:%0.2f,mathematics:%0.2f,english:%0.2f,sports:%0.2f,music%0.2f,totoal_socre:%0.2f\", p->name, p->chinese,p->mathematics, p->english, p->sports, p->music,p->total_score);         printf(\"\\n\");     }                       return 0; }          ```", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "多复制了一份，只看一份就可以了。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "我今天的作业要求：1、输入不少于5名学生的姓名和他们语文、数学、英语、体育、音乐的成绩（小数保留2位即可）2、按他们的总成绩从高到低进行排序（冒泡、选择、快速、希尔随便选一个）3、输出像如下形式的报表：    +----------+--------+--------+--------+--------+--------+--------+    |   姓名   |  语文  |  数学  |  英语  |  体育  |  音乐  | 总成绩 |    +----------+--------+--------+--------+--------+--------+--------", "referer": "user-0"}]}
{"question": "大一新生C++小白，程序错误百出，但是不知道哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，我帮你改好了，真的错了很多，最关键是C语言的case语句只能是整数（字符也是整数的特例）： #include #include #include using namespace std; int main() {    double a, b;    char ys;    cin >> a >> b >> ys;    switch (ys) {        case '+':            cout << a << ys << b << \"=\" << a + b;            break;        case '-':            cout << a << ys << b << \"=\" << a - b;            break;        case '*':            cout << a << ys << b << \"=\" << a *b;            break;        case '/': {            if (b == 0.00)                cout << \"除数不能为0\";            else                cout << a << ys << b << \"=\" << a / b;        }        break;     case '%':         cout << (int)a << ys << (int)b << \"=\" << ((int)a % (int)b);         break;     default:         cout << \"error!\"; } cout << endl;  return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢感谢，我懂了", "referer": "user-1"}]}
{"question": "为什么gcc默认的char类型是有符号的？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "既然C语言标准放任了这个问题存在于Implementation Defined，那就是公说公理，婆说婆理的事儿了，咱们就不要企图从理上理解他了，接受就好。也就是心中不做假设。如果语义上真的只需要字符，那就上char如果需要它来表达小整数，那就按自己的需要明确使用signed char或者unsigned char", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "与硬件架构相关，gcc也不总是默认char是signed char，在ARM、PPC平台上默认就是unsigned char", "referer": "user-0"}]}
{"question": "求助！！新手小白的疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "while (scanf_s(\"%d\", &x)!=EOF);这一句是啥意思", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "while (scanf_s(\"%d\", &x)!=EOF);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你while语句的那行多写了一个 ;", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢！解决啦", "referer": "user-2"}]}
{"question": "高性能接收和处理消息问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、自己写吧，练练手，没啥难度。2、s2全局序号没任何意义。s1发送N个数据包，s2可能一次就接收完了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "自己顶一下", "referer": "user-0"}]}
{"question": "老是报fopen_s参数太少，但用fopen,又报不安全。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "鼠标右键点fopen_s,再弹出的菜单中选转到定义", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "老师，转到定义之后呢，怎么操作", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "按照函数定义调用函数", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "刚刚解决了，在vs2019中已经取消了fopen，在头文件从新声明（加入）#pragma warning(disable:4996) 就可以了。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "好像不太行啊大哥", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "已经解决：", "referer": "user-0"}]}
{"question": "对于计算函数的n次方该如何用c语言写出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "double pow(double,double)declared in math.h", "referer": "user-0"}]}
{"question": "实在搞不懂了，救救。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我主要强调转义字符是一个编译期概念，编译结束以后就再也没有什么转义字符了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢感谢。", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "同学，你这个小程序至少有2个地方有问题：1、char *st;这里你只定义了一个字符指针，没有为它分配空间，它在下面读取的时候会出现不可预料的错误。2、输入的“pro\\ngrme\"，每一个都是正常可显示的字符，不是换行符也不是回车符，所以，它不可能与'\\n'或'\\0’相等如果你非要将某个字符转换为换行符或回车符，建议使用反斜杠‘/’。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢感谢。", "referer": "user-2"}]}
{"question": "编写一个JavaScript脚本，在浏览器中输出3位整数中的所有对称数（个位和百位相同）。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "最近刚好在折腾JS  帮你改了下 <html> <body> <script>      var str=\"3位整数中的所有对称数如下：<br />\";      var g,s,b,i=100;                          for(var i=100;i<1000;i++){                 g=i%100;                 s=(i-i%10)/10;                 b=(i-i%100)/100;                 if(b==g){                 str+=\" \"+i+\" \";                    }                         }     document.write(str);  </script> </body> </html>", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "想不出来啊，有没有大佬啊", "referer": "user-0"}]}
{"question": "不知道为什么Compilation Error。求大佬解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int m,n,x=0,y=0,i,j,k,t; int a[j];  在这里j没有初始值，是不能定义数组a。还有一点，如果你的编译器不支持c99，数组的大小还不可以是变量。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "太谢谢了，大佬强啊👏", "referer": "user-1"}]}
{"question": "分享一下写了N年的自用编辑器 -- EDX", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "使用了下，不错，功能强大，把python调试环境支持下就完美了。！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "能undo,redo吗？ 支持键盘宏/脚本宏吗？", "referer": "user-0"}]}
{"question": "新人求解，刚入门，很简单的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int a;scanf(\"%d\",&a);int b=a%10100+a/100+a%100/1010;printf(\"%d\",b);  同学，这样才对。你a还没有初值，怎么可以使用它呢？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "int main(){    int a;    scanf(\"%d\",&a);printf(\"%d\",a%10100+a/100+a%100/1010); 这个就是对的，那我原来那个错哪了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "printf语句里面不要加&", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "还是不对", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "a初值没有赋初值，程序是依次执行的，你要使用a就要先赋值再使用，其次，printf不要加&", "referer": "user-0"}]}
{"question": "学生刚入门，求解问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的输出有问题printf(\"语文成绩为 %f\\n数学成绩为 ：%f\\n\",y,s)", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的s有啥用吗？输入是不是得是%lf，倒数第二行差，&y，&s （我也不确定 我也是小白）", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "输入的话float是%f，double是%lf，printf里面不加&", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "", "referer": "user-0"}]}
{"question": "四则运算计算器怎么才能让输出的负数带括号", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、输入第1个操作数2、输入四则中任一个运算符3、输入第2个操作数4、使用switch语句，根据运算符，进行四则运算。如果在除法中，除数为0，输出“除数不能为0”。否则，在printf中输出结果，如果操作数小于0，加括号。  这位哥哥好象是大学生，我还是小学生，打扰了！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "so easy! 妈妈再也不用担心你的学习问题～", "referer": "user-0"}]}
{"question": "四则运算计算器怎么才能让输出的负数带括号", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "格式字符串那里是可以换成一个字符数组名或者字符指针的。", "referer": "user-0"}]}
{"question": "哪里错了或者是语法错误 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为当把一个字符串改为整形的时候，系统是以ASCII把来输出的，无需强制转换。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把a=int(x),修改为    a =x;", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "看着没什么问题啊。", "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": "该代码就是将英文字母转化为序号1,2,3，——26", "referer": "user-0"}]}
{"question": "我不李姐 天哪 我认为的是p=5+6+7 q=6+7+8", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我的是vs2019，运行的结果是15，24，懒得去研究得，反正后面一般用得最多的就只是一个递增或递减，不会无聊的用到这个。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "特别安装了一个vs2019看看，果然与我用开的dev-c++是不同的，vs是遵从后置++当整行运算完成后，才改变自身的值！vs2019：15，22dev-c++：18，22", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不同编译器不同结果，李不李姐无所谓。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "1、后置++（--），是在整行运算完成后才改变自身的值，2、前置++（--），是先改变身的值，再参与整行的运算", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "我认为p=5+6+7 q=6+7+8是对的，但vs不这么认为，我也不理解，呵呵", "referer": "user-2"}]}
{"question": "这个问题怎么解决啊 球球了 大佬们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C 库函数 double pow(double x, double y) 返回 x 的 y 次幂，即 xy。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据范围很重要，写个最简单的整数的次幂，提供大致的思路，供参考： #include<stdio.h> int fun(int n,int m) {      int  s=1;      while(m--) s *= n;      return s; } int main() {      int a,b,c;      scanf(\"%d%d%d\",&a,&b,&c);      printf(\"%-9d%-9d%-9d\\n%-9d%-9d%-9d\\n%-9d%-9d%-9d\\n\",                               fun(a,1),fun(a,2),fun(a,3),                               fun(b,1),fun(b,2),fun(b,3),                               fun(c,1),fun(c,2),fun(c,3));            return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢谢谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "数的大小没说  那可不是写个代码就能解决的问题啊", "referer": "user-0"}]}
{"question": "关于字符指针定义奇怪的地方", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你发送是一个结构体，接收也应该是一个结构体。message = (struct tcp_msg *)buf;这句肯定是错的，buf是字符串数组，怎么能强转成message结构体？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "这个是可以的，就将字符串按照结构体的类型划分空间", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "一般是这样用吧 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <syspes.h> #include <sys/socket.h> #include <arpa/inet.h> #include <string.h>  #include \"proto.h\"  #define DATASIZE    128  int main(int argc,char **argv) {     int sock_fd;     struct sockaddr_in s_addr;     uint8_t data[DATASIZE];     int res;      if(argc < 2)     {         fprintf(stderr,\"error : %s + destip!\\n\",argv[1]);         exit(1);     }      if((sock_fd = socket(AF_INET,SOCK_STREAM,0)) < 0)     {         perror(\"socket\");         exit(1);     }          s_addr.sin_family = AF_INET;     s_addr.sin_port = htons(PORT);     inet_pton(AF_INET,argv[1],&s_addr.sin_addr);     if(connect(sock_fd,(void *)&s_addr,sizeof(s_addr)) < 0)     {         perror(\"conne);ct\");         exit(2);     }          while(1)     {         gets(data);         if(!strcmp(data,\"exit\"))             break;          if(write(sock_fd,data,DATASIZE) < 0)         {             perror(\"write\");             break;         }          res = read(sock_fd,data,DATASIZE);         if(res < 0)         {             perror(\"read\");             break;         }                      if(res == 0)         {             printf(\"server is shutdown!\\n\");             break;         }                  puts(data);     }      close(sock_fd);     exit(0); }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "ssize_t send(int sockfd, const void *buf, size_t len, int flags); 这个应该传空类型的指针吧，也没见过传结构体的。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "这个空指的是可以传任何类型的指针", "referer": "user-2"}]}
{"question": "在线等，a[2]={1,2,3,4};这个数组啥意思呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "a[2]={1,2,3,4};就是定义了一个num结构体数组，它的大小是2这样写可能有点费解，如果你把它改为这样：a[2] = {{1, 2}, {3, 4}};就很好理解了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢您的回复，a[2]不是应该表示这个数组中的第三个元素吗？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "同学，a[2]在这个位置上是定义，不是取值，而且，你这个数组的数据类型是结构体啊，每个结构体里面定义了2个整型。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "就是这里有点糊涂，给您添麻烦了！那 *p=a;是不是表示指针指向了a数组的第一个位置呢", "referer": "user-1"}]}
{"question": "gbk编码中怎么区分中文和英文？判断方式是什么？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "转为Unicode，切分，转回GBK", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "IsDBCSLeadByte", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "大佬，这是什么意思？没有看懂", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "IsDBCSLeadByte只是判断一个指定字节是否为一个双字节字符的头一个字符，而汉字的高字节和低字节都是大于0x80的，所以没什么区别", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "方法，方法，方法... 从buffer[0]开始怎么判断到需要截取的位置", "referer": "user-0"}]}
{"question": "求求了 想一晚上了 if语句没生效", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "没事了没事了 我处理好了 谢谢大家", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主的意思，是输入三个一位数，1--9 之间？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "啥叫“当有0的时候消掉0”？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "刚把if删了。。", "referer": "user-0"}]}
{"question": "为什么输出结果数据有问题？求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "是不是因为BMR是浮点数，而655和230都是整型", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "单步运行，看看各处的各相关值是否和预期一致，就象你这里好像没给 M 和 F 变量赋值就用上了，编译时不给 error 起码也是 warning 么？数据的输入，好像要和设定的格式完全一致的，否则可能有误。", "referer": "user-0"}]}
{"question": "代码看起来没有错，可是为什么不会停止", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已解决，第一个for语句的括号位置不对：以下是正确的代码：#include <stdio.h>#include <string.h> struct Person{    char name[30];    int count; }leader[3] = { \"li\",0,\"zhang\",0,\"ran\",0 }; int main() { int i, j; for (i = 0; i < 10; i++) {     char leader_name[30];     printf_s(\"please enter the name of the elector:\\n\");     scanf_s(\"%s\", leader_name, 30);     for (j = 0; j < 3; j++)     {         if (strcmp(leader_name, leader[j].name) == 0) leader[j].count++;      } } printf_s(\"\\nResult:\\n\"); for (i = 0; i < 3; i++)     {         printf_s(\"%s,%d\", leader[i].name, leader[i].count);     }            return 0;", "referer": "user-0"}]}
{"question": "老师们帮我看一下这个代码错在哪里。输入和输出不相符。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "就是这个问题，非常感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "scanf_s要给出输入字符串的长度", "referer": "user-0"}]}
{"question": "json-c库的浮点型存储问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "浮点数格式  ▼     http://bbs.csdn.net/topics/390676437", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主您对标准的误会到今天就打住吧，这样的才是标准的，而不是您以为那样。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "是吗？肤浅了", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "别只知道喷 那点资料让我这个菜鸟学习学习嘛， 你说这句话对你我都没啥益处对不对", "referer": "user-2"}]}
{"question": "为什么下面这段用c语言判断回文数的代码在vs2019上跑的出来，在vc++2010上跑不出来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <string.h> #define N 80  int fun(char* str) {     int sz = strlen(str);     int i = 0, j = sz-1;     while (str[i] == str[j])     {         i++;         j--;         if (i >= j)             break;     }      return (i >= j); }   void main() {     char s[N];     FILE* out;     char* test[] = { \"1234321\",\"123421\",\"123321\",\"abcdCBA\" };     int i;     printf(\"Enter a string : \");     gets(s);     printf(\"\\n\\n\");     puts(s);          if (fun(s))         printf(\"YES\\n\");     else         printf(\"NO\\n\");     /************************************/     out = fopen(\"out.dat\", \"w\");     for (i = 0; i < 4; i++)         if (fun(test[i]))             fprintf(out, \"%s --> YES\\n\", test[i]);         else             fprintf(out, \"%s --> NO\\n\", test[i]);     fclose(out);     /************************************/ }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的“int sz = sizeof(str) / sizeof(str[0]);”这条语句错了，sizeof(str)返回的是指针的大小，32位程序是4，64位程序是8。如果要返回空终结字符数组中元素的个数，应该用strlen(str)。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "嗯，我也不信这个代码能在vs任何版本上得到正确结果。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "sz 的求取是错的，直接用求字符串长度减1 就是了。", "referer": "user-0"}]}
{"question": "codeblock怎么打开dev c++的项目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "为什么要打开其他软件的项目呢？作业这种东西只需要交源程序就可以了，基本和项目无关。就算有关，也只需要在codeblock中打开源程序，编写完成后使用dev c++编译调试。 最后，我感觉你应该是对老师的要求理解有误！这种要求最多就是上机考试时只提供dev c++环境，所以叫你们熟悉它", "referer": "user-0"}]}
{"question": "求大佬帮忙看看这是咋了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，你错误的地方就是scanf这句用错了！使用scanf时最好给输入者清析的提示，把它改成这样就更好啦： int main() {    float a, b, h, s; printf(\"请输入梯形的上、下底和高(请用,分隔它们)：\"); scanf(\"%f,%f,%f\", &a, &b, &h); s = (a + b) * h / 2; printf(\"梯形上底=%8.2f, 下底=%8.2f, 高=%8.2f, 它的面积=%8.2f\\n\", a, b, h, s);  return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "ok,感谢，想这个想了好久", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "and cut '&' off from printf", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "typea=4,b=6,h=4then press enteras if your scanf format", "referer": "user-0"}]}
{"question": "急turboc的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该是环境没设置好。另外没在dosbox下玩过，我在virtualbox下玩过。路径里有没有超过8个的文件名，空格等字符，dos都是不支持的  好久不见有人用这个了，你是什么学校的，竟然还在用tc？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "图怎么换了。应该#include <graphics.h>", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "哦，图形啊，我近些年来一直认为怀念TC图形的行为只能叫做抱残守缺。是的，说的就是布置这种作业的老师。你知道让大黄蜂把自己伪装成农用小四轮拖拉机有多么困难么，居然还抱怨人家装得不像。//---------------------------------------------------------------//以上是吐槽。//---------------------------------------------------------------编译出错说明你设置的不对。回VC去加装easyx库用来模拟TC图形库是可行的方案。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "貌似程序在等输入。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "代码内容帖上来", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "老师求你帮忙看看", "referer": "user-4"}, {"cid": "7", "user": "user-2", "content": "哦，你是TC都没运行起来，可能是你下载的版本有问题", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "Alt+F，OS Shell，再运行你的程序", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "大神，不行唉 我能私信问你吗", "referer": "user-2"}]}
{"question": "调用函数的返回类别...", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "使用struct fa就是值传递，因为它是一个结构体，所以，传递进函数需要将原数据复制一份副本，而且，你在函数内修改的是这份复制的副本，对原数据是没有影响的， 这样降低效率又不是你想要的，因此，只能是使用struct fa *传结构体的指针。另外，因为函数传进来的是结构体指针，所以，也不需要返回值。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请不要碎片化学习，知识这玩意是有体系的，只有学习了前置内容，才能正确使用术语进行提问。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这是一道改错题，不懂为什么调用函数返回指针的地址，其类别为什么是struct fa *,不用’*‘可以吗", "referer": "user-2"}]}
{"question": "简单的题但却疑惑并且新人懵逼中", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我经常说，学习汇编和C之前，要抛弃小时候的”自动“观念，机器不会自动做任何事。我是说，你输入一个数和输出一个数之间啥也没有，在那中间机器不会自动给你做任何事。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我懂了！谢谢！", "referer": "user-1"}]}
{"question": "这个错误怎么改呢，求大神", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、先声明函数：int insertSeqList(SeqList *L, int i);2、不能在函数里面，定义另一个函数。我刚学C语言时，最常犯的错误就是在main()函数里定义了另一个函数，呵呵。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "直译一下：函数定义不能放在这里。所以和你贴出来的部分没啥关系，问题在你没贴出来的部分里面。", "referer": "user-0"}]}
{"question": "怎么将b链表中有的数但a链表中没有的数插进a链表中", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同学，参考我在B站的分享：     https://space.bilibili.com/1901488254   循环A链表，遍历B链表查找，没有再插入。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "复杂度有点高了，直接用一个数组进行提前记录可以更好", "referer": "user-1"}]}
{"question": "二级指针的问题。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "定义时： ... *p;表示p为指向...的指针 ... &r;表示r为...的引用，且只有c++才有引用  表达式中： *p表示取指针p指向的内容 &r表示取指向r的指针", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "同学，我举个简单的例子，你就明白了：int main() {    int **a;    int *p;    int data = 100;    p = &data;    a = &p;  printf(\"**a = %X, *a = %X, data = %d\\n\", a, p, **a);  return 0;  }", "referer": "user-0"}]}
{"question": "为什么我不能输出我的单链表", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序  ▼     http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "似乎是第38行并没有改变L，InitList对L的修改只停留在InitList内，当我在InitList内输出时就可以成功了 修改后，代码如下： #include <stdio.h> #include <stdlib.h>  typedef struct LNode {     int data;     struct LNode *next; } LNode, *LinkList;  void InitList(LinkList L) {     LNode *s, *p;                       //S指向新申请的结点，P指向后结点     L = (LNode *)malloc(sizeof(LNode)); //建立头结点     L->data = -1;     L->next = NULL;     p = L; //P指向头结点     int n;     scanf(\"%d\", &n);     for (; n != 0;) {         s = (LinkList)malloc(sizeof(LNode)); //新建结点         s->data = n; //放入data         s->next = NULL;         p->next = s;                        //P结点指向新结点S         p = s;                        //p取代s结点         scanf(\"%d\", &n);     }     p->next = NULL; //终端结点不指向     outlist(L); }  void outlist(LinkList L ) {     LNode *p;     for (p = L->next; p != NULL; p = p->next) {         printf(\"%d \", p->data);     }     printf(\"\\n\"); }  int main() {     LinkList L;     InitList(&L);     //相当于传入一个变量，而非地址？     //outlist(L);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "修改如下，供参考： #include <stdio.h> #include <stdlib.h>  typedef struct LNode {     int data;     struct LNode *next; } LNode, *LinkList;  void InitList(LinkList * L) {     LNode *s, *p;                       //S指向新申请的结点，P指向后结点     (*L) = (LNode *)malloc(sizeof(LNode)); //建立头结点     (*L)->data = -1;     (*L)->next = NULL;     p = (*L); //P指向头结点     int n;     scanf(\"%d\", &n);     for (; n != 0;) {         s = (LNode *)malloc(sizeof(LNode)); //新建结点         s->data = n;                        //放入data         p->next = s;                        //P结点指向新结点S         p = p->next;                        //p取代s结点         scanf(\"%d\", &n);     }     p->next = NULL; //终端结点不指向 }  void outlist(LinkList L ) {     LinkList p = L->next;//LinkList p = L;                          //L = L->next;     while ( p != NULL ) {         printf(\"%d \", p->data);         p = p->next;     } }   int main() {     LinkList L;     InitList(&L);     outlist(L);          return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "同学，你这个程序很多错误的地方，重复的语句，你可以从我分享的网盘中下载我关于链表的实现（增、删、改、查、排序）：     https://space.bilibili.com/1901488254", "referer": "user-0"}]}
{"question": "关于反序输出递归函数的疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "reverse(&s[1]);就是reverse(s+1);嘛。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "试了一下，发现确实可以这样，谢谢大佬的建议", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "递归算法都比较烧脑，这个算法关键在于这句： reverse(&s[1]);它实质上就是每次都向右移动了字符串的首地址一个位置，你把 putchar(s[0]);换成这样：printf(\"s=%s, s[0]=%c\\n\", s, s[0]);就很容易看出，它是如何做的。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "对，就是这句 reverse(&s[1]);我不理解它是如何运作以达到这个效果的，使用了后面的方法看到了怎么“归”，就是不知道怎么递出去的 谢谢大佬解惑", "referer": "user-2"}]}
{"question": "sqrt的用法是怎样的。。。。。。 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "常量也有类型", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "因为sqrt的函数原型的参数就是double，而不是int。如果sqrt参数是Int，那么他计算double,必然会丢失参数的浮点部分，而如果是double，int转double，是不会丢失什么的", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "那是使用数学函数时，都要转换吗", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "查函数说明", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "原来你关心这个，那么检查一下你的代码里头文件写对写全了么？", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "不用强转吧，你什么IDE?", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "嗯，这是您应该做的。", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "k=sqrt((double(i)+100); m=sqrt((double(i)+268);同学，你粗心了，强转都写错了，应该是这样吧：k = sqrt((double)i + 100);m = sqrt((double)i + 268);", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "知道，但是为什么要强转后才能使用sqrt函数呢", "referer": "user-5"}, {"cid": "10", "user": "user-5", "content": "虽然sqrt形参是double，但也不需要强转，除非你所用的编译器非常古老，否则，现在的编译器基本上都能帮你自己转换", "referer": "user-0"}]}
{"question": "数组传参，数组指针自加减，GCC编译报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所以我们应该知道，在不同编译器上表现不同的写法应该规避。这个才是重要的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "强转之后就是右值了", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "void* my_memcpy(void* dest, const void* src, size_t count) {     char* ret = dest;     assert(dest != NULL);     assert(src != NULL);     //char* pd = dest;     //const char* ps = src;      while (count--)     {         *(char*)dest=*(char*)src;         ++dest;         ++src;     }     return ret; }  去掉(char*)强制转换后，GCC倒是编译通过了，但是Vistual studio 又报错了。。。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "前面的(char *)是蛇足啊，不加它也能保证++是加1的。加上它以后gcc认为强制转换后的结果不是左值了，所以不能++", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢，但是去掉(char*) 强制转换后vs报错。。，GCC倒是编译通过了  严重性\t代码\t说明\t项目\t文件\t行\t禁止显示状态 错误(活动)\tE0852\t表达式必须是指向完整对象类型的指针\tProject1\tD:\\Micsoft Visual Studio 2019\\source\\repos\\Project1\\struct.c\t16", "referer": "user-1"}, {"cid": "6", "user": "user-3", "content": "不喜欢下面的代码?while((*dest++ = *src++ )!= '\\0');", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "楼主的意图不是复制字符串，所以无法使用空字符作为结束标准。", "referer": "user-3"}, {"cid": "8", "user": "user-0", "content": "感谢，但是就像@forever74 所说，需求是内存拷贝，不是string拷贝。", "referer": "user-3"}]}
{"question": "有关if的问题。。。。。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把continue去掉就好了，因为你只有一层循环，所以当第一次执行完if的printf之后continue到了下一次循环，跳过了printf（“%d，--x”）此时第一次循环完成后的x=6，进入循环后，x--得到5，以此类推，每次遇到continue就直接进入了下一次循环，所以得到的是8542", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int main() {    int x = 8;    for (; x > 0; x--) {        if (x % 3) {            printf(\"3x!=%d,\", x--);            continue;     }     printf(\"3x=%d,\", --x); }  return 0;  }把它改为这样，你就会很容易看明白，它的结果是：3x!=8,3x=5,3x!=4,3x!=2,当最后一次x=2时，打印完后，它自减1，变成1，然后continue回到for循环，又自减1，此时，x=0，它已符合for循环的中止条件了，退出。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "if(x%3)  相当于   if (x % 3 != 0) ，所以x=8 时，打印出 8 ，x-- =>7 ,countinue 跳到 for(;;x--)  x=7-1 = 6;    x=6%3==0 执行printf(\"%d\",--x)；x=6先自减1  x=5 ,打印出 5 ，回到for(;;x--)   x=4 ,以此类推，输出了：8542 .", "referer": "user-0"}]}
{"question": "球球大神帮我看看这是为什么啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可为什么我做的时候要将b=sqrt(a+100)变成b=sqrt((double)a+100)呢，不然显示错误，这是为什么呢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "不用啊，你是不是代码打错了", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "将if(bb==a+100&&cc==b+268)改为 if(bb==a+100&&cc==a+268)", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢大哥", "referer": "user-2"}, {"cid": "5", "user": "user-3", "content": "因为您打字马虎了混淆了两个变量。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢大哥", "referer": "user-3"}]}
{"question": "大家好，请帮我看一下，为什么最后的字符输不出来。（chr_d）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "另外，最后一个输入从参数上看应写为scanf_s(\"%c\",&chr_d,1);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "在printf_s(\"please chr a number:\");之前加多一句fflush(stdin);这是因为，你在scanf_s(\"%lf\", &dbe_c);输入时，按下了回车键确认，回车符还留在键盘输入缓冲区，所以，要把它清除掉。", "referer": "user-0"}]}
{"question": "字符指针值可以直接相减吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "p-'0'相当于49-48=1，q-'0'相当于53-48=5（对应的字符ASCII码相减）也就是将字符转为整数。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "为什么不能直接用*p+*q得出结果为5呢", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "‘1’的ASCII码是49，‘5’的ASCII码是53，*p+*q就变成49+53。减去字符0相当于将字符转为数字。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢", "referer": "user-1"}]}
{"question": "关于16进制与内存地址的几个疑惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先地址在计算机中肯定是以2进制表示的。16进制只是在书写或源程序中出现。为什么书写中经常出现16进制（其实有些地方是8进制，效果和原理一样）而不是10进制，可以参考一下赵4老师的回复，原因就是：以小数点为基准，每4个2进制对应一个16进制，熟练后一眼就可以转换，10进制做不到这点。也许你要抬杠，说为什么不直接用2进制，原因是：2进制太长且一大堆0、1（对于人来说）容易搞错", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "二进制：1111 0101 1010 1000 16进制：F    5    A    8 十进制：62888", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "我觉得对这一块的理解到一定点就可以了，没有必要深究，再说也用不上。就像牛顿定理，已经告诉你这样可以实现或解决一些现象，那我们记住就可以了，没有必要再往下问，如果一直这样问下去，会影响学习，再者，老师都回答不上来。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "有一点题外话。学校里的学习是循序的，每门课的大纲上都有先修课程一说，而互联网上的学习破坏了这一点。因此建议借助互联网学习的人士要自行循序，这样知识才能自洽，不至于碎片化。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "1、书上应该提到，四位二进制的组合共有16种，与十六进制数字是一一对应的，这就是转换简单的意思。2、确切地说地址就是个整数，天生是二进制的，只不过由于上述理由转换容易，经常缩写为十六进制形式而已。地址本身不用保存，可以说它就是存储单元在存储芯片上的坐标，就像经纬度不需要刻在地面上一样。但是寻址的时候需要表达这个地址，前面说了，地址就是个整数，它占用的空间大小要分开来说：物理地址长度取决于硬件平台有多少根地址总线，经典的32位硬件经常带32位地址总线，所以使用32位地址；常见的64位平台经常支持48根地址总线，所以使用48位地址。逻辑地址长度看操作系统和程序语言的喜好，它们各有各的喜好。从逻辑到物理的映射不是一个一个的，而是一块一块的，因此只需要记录用得到的块的首地址。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "1、书上应该提到，四位二进制的组合共有16种，与十六进制数字是一一对应的，这就是转换简单的意思。————书上教了。但是我觉得难易度和二进制与十进制转换方法差不多。故有此问。 2、还有什么讲这个问题比较好的书推荐么？", "referer": "user-4"}, {"cid": "7", "user": "user-4", "content": "1、那么您心算一定很快，对于难易度的看法与普通人有一些分歧，而书本一般都假设读者是普通人。 2、有肯定是有，但因为我不记得哪件事是从哪里看到过的，所以无法推荐。前置课程大约硬的方面是数字电路和微机原理，软的方面是操作系统吧。", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "二进制到16进制转换只需要移位就可以了，二进制到十进制需要用到除法，怎么转换方法差不多呢？你写过这两种转换的C代码吗？", "referer": "user-0"}]}
{"question": "关于C语言的向上取整", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "按照 你自己的代码，我运行了一次，在我的计算机上是可以运行并计算的。并且采用了两种输入试了一下都是可以正常计算，并且按整数输出。第一次输入 ，，10，2 第二次输入，，7，3 一次输出没有小数，和一次输出有小数都呆以正常取整", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这跟C没啥关系吧？如果i/j正好能整除呢？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "正好整除向上取整也得加一吧，我是做题用到后者AC了，但是前者WA了，搞不懂i/j+1为什么不行", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "那一定是我对向上取整有误解，抱歉。", "referer": "user-0"}]}
{"question": "关于递归调用的理解？？？？？？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "递归这里我老是肯不动。学习中", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你起床后打算吃米饭，于是你开始递归：要吃总得先盛到碗里吧，先调用盛饭函数。锅里居然是空的，先调用做饭函数。然而上次用完后锅还没刷，先调用刷锅函数。注意你的输出，1010是这样产生的：你刷了锅然后淘了米放了水点了火煮好了以后打开锅盖挖一勺到碗里开始......递归做菜", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢，瞬间懂了", "referer": "user-3"}]}
{"question": "51单片机函数声明和函数传参的问题。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主您的代码段没有表现出和两个问题的联系，这就很难回答了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "您好 就是 能不能把SMG1 传到函数里呢？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "首先肯定是能。 但是传进来干嘛？你的函数都不使用它，直接就重新赋值，也就扔掉传进来的值了。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我明白了，他传进来，替换smg，然后又被赋值了，对吧？实际上P0,P1并没有被传进来。我应该做的是吧P0或者P1传进来，而不是把SMG1SMG2传进来。。。是这样理解吗？", "referer": "user-1"}]}
{"question": "{已解决}C Primer Plus初学，请教第四章的一道编程题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int main() {    char first_name[40];    char last_name[40];    char* p1;    char* p2;    p1 = first_name;    p2 = last_name; printf_s(\"Please input your first name:\\n\"); gets(p1); printf_s(\"Please input your last_name:\\n\"); gets(p2); printf_s(\"%s %s\", p1, p2); return 0;  }", "referer": "user-0"}]}
{"question": "指针，，，，，，， ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "给p赋值，是修改p的指向，并不能修改p的目标里面的内容。尤其需要这样理解的是p=\"sffd\";这句。是在内存另外的位置保存了sffd这样的内容，然后用p指向那里的意思。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1"}]}
{"question": "void 类型的指针可以存储任何类型的数据吗 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "感觉最好声明清楚比较好，否则后面容易混淆 void * p;    int a = 3;    p = &a;    printf(\"%d\", *p);    return 0;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "是可以的，但是在你取回原来的类型值时，就需要强转了。比如，你要拿回p指向的值（也就是整型3），就需要这样做：*(int *)p", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "也就是void 指针可以存储任何类似的数据，但要使用的时候，就要用*(int*)p进行强转后取值吗", "referer": "user-2"}]}
{"question": "帮我看看编译错哪了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "试一了下，还是在中文下面输入符号的问题引起。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢，问题已解决", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "printf(\"math = %d, eng = %d, comp = %d, average = %d\"，（这个逗号，你用了纯中文符号）87,72,93,（（这个括号，你用了纯中文符号）87+72+93）（这个括号，你用了纯中文符号）/3)；（这个分号，你用了纯中文符号） return 0；（这个分号，你用了纯中文符号） 我不知道你用的是什么IDE，但最好能选择一种在纯中文与英文符号有明显区别的字体。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "计算的结果不是整数，跟%d不匹配", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "......是分号的问题可以直接输出", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "不能直接在输出函数中直接输入数据进行输出", "referer": "user-0"}]}
{"question": "关系数据库中范式的简单讲解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "数据库中的第一范式是什么意思", "referer": "user-0"}]}
{"question": "求教：同样的功能，一个main()实现vs几个函数实现，哪种情况效率高？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "最明显的一条定律：同样的函数，能用宏定义实现，优先使用宏定义，它比online函数的效率更高。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢指点", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "啥叫效率？实现同样功能的代码简短叫效率；代码被编译的过程占用的时间短叫效率；代码执行的时候用的总时间短叫效率；代码执行的CPU时间短叫效率；代码执行时占用的存储空间小叫效率；代码执行时的IO次数少也叫效率；......偏偏这些效率往往是互相矛盾的，压下葫芦起来瓢。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢指点", "referer": "user-2"}, {"cid": "5", "user": "user-3", "content": "基本没区别。 无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢指点", "referer": "user-3"}]}
{"question": "。。。。。。。。。。。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你先说你的理解，为什么你觉得不起作用", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "p=s+a表示指向c[9]的位置，s=s+b表示指向c[6]的位置，c[6]&gt;c[9],while条件为假，所以没运行", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "c[6]大于c[9]", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "但是你while条件里面的指针没有解引用，比较的其实是地址值呀", "referer": "user-0"}]}
{"question": "typedef的作用。。 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "typedef typedef type-declaration synonym;  The typedef keyword defines a synonym for the specified type-declaration. The identifier in the type-declaration becomes another name for the type, instead of naming an instance of the type. You cannot use the typedef specifier inside a function definition.  A typedef declaration introduces a name that, within its scope, becomes a synonym for the type given by the decl-specifiers portion of the declaration. In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types — they introduce new names for existing types.  Example  // Example of the typedef keyword typedef unsigned long ulong;  ulong ul;     // Equivalent to \"unsigned long ul;\"  typedef struct mystructtag {    int   i;    float f;    char  c; } mystruct;  mystruct ms;   // Equivalent to \"struct mystructtag ms;\"  typedef int (*funcptr)();  // funcptr is synonym for \"pointer                            //    to function returning int\"  funcptr table[10];   // Equivalent to \"int (*table[10])();\"   typedef 要定义的类型 类型的别名; typedef int *T;//定义T为int *  T a[20];//声明一个数组a，包含20个元素，元素的类型是T，也就是int *", "referer": "user-0"}]}
{"question": "有没有大佬说下什么问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在main()函数之前，加入这行：using namespace std;这样才可以直接使用cout", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdlib.h>std::cout", "referer": "user-0"}]}
{"question": "关于calloc的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、如果你在函数内要为传进来的指针重新分配空间，要传它的一级地址，也就是指向指针的指针。2、在fun(int *p1,int *p2,int *s)你分配了空间，又将它释放了，这个操作很让人费解！3、直接将fun(int *p1,int *p2,int *s)改为这样就行了：void fun(int *p1,int *p2,int *s) {  *s=*p1+*p2;}", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "说实话，这个不是calloc什么的问题。而是楼主您对参数传递的理解有问题；也许对变量生存周期的理解也有一定问题？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "程序结束前，你已经释放了，就算不释放，你也得不到", "referer": "user-0"}]}
{"question": "为啥编译后运行不了啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、不要直接编译单一的CPP文件，要先创建一个项目，然后，根据你的代码是C还是C++选择对应的项目类型，再创建源代码文件。2、关键词：cuot也打错了，应该是cout3、根据编译器返回的信息，你的Dev-C++没有正确安装好。安装Dev-C++之前一定要将旧版本的完全卸载掉才可以。4、关于如何安装Dev-C++可以参考我在B站的视频：      https://www.bilibili.com/video/BV1eq4y1M7XY?", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "cuot和cout不是一回事！关于自己是否适合编程的很简单的测试：在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案： A里面有10处以上文字或标点错误B里面没有文字或标点错误并敢为此跟人打赌C里面没有文字或标点错误并且字体和排版完全与原稿一致D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感 A不适合编程（理由：打字准确度偏低、粗心大意）B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念）C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证）D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！） 如果想从A变成B的话，到我的资源 ▼     http://download.csdn.net/detail/zhao4zhong1/4084259  里面下载“适合程序员的键盘练习”", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "\"<<\"不是左移符号吗，只能用于二进制中", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "他写的应该是c++ ，然后输出语句要用&lt;&lt;", "referer": "user-3"}, {"cid": "5", "user": "user-5", "content": "疑似安装过程有问题，所以没有编译，而不是编译后如何。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "安装过程？", "referer": "user-5"}, {"cid": "7", "user": "user-0", "content": "我重新安装了还是这", "referer": "user-5"}]}
{"question": "有关i++的问题，求请教 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C语言中序号是从0开始的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的问题跟昨天这位同学一样，可以参考我的回答：      https://bbs.csdn.net/topics/600693833", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "如果没有猜错你的问题的话，应该可以这么回答。先使用再++是对于它所在的那个唯一语句来说的，i++在while语句中，而不在下面的循环体中，所以是对于i++来说，先使用是拿去判断真假，之后，判断完了即使用完了，进行++。i++跟你while下面的不管啥玩意都没关系，它只负责while这一个语句。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "i%2 == 0 假  跳转", "referer": "user-0"}]}
{"question": " 在C语言中，SUM / M 与 1 / M * SUM 表示的含义不一样吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "注意：◆常量也有类型。1是整型，1.0f是float型，1.0是double型◆按照（）、*/、+-的运算符优先级计算，◆整型除整型只能得到整型而不会自动转为浮点型，比如1/2得到0而不会得到0.5f或0.5", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "抛开电脑编程中的精度，数据类型，就这个式子，最明显的区别下面这个t = 1 / M * SUM - (sumx / M) * (sumx / M)中M * SUM有可能为0，除数为0是没有意义的！如果你能保证不为0，那就是数据类型的精度差别了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "理由大约是M是某种整数类型而sum不是。", "referer": "user-0"}]}
{"question": "这个为啥错了，大佬教教我~~", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "sanf输入的时候不存在顶格（如：5.2f）只有输出的时候才有这种说法。int main() {    int a, b;    float c;    double d;    printf_s(\"please input int nums:\\n\");    scanf_s(\"%d,%d\", &a, &b); printf_s(\"please input float nums:\\n\"); scanf_s(\"%f\", &c);  printf_s(\"please input double nums:\\n\"); scanf_s(\"%lf\", &d);  printf_s(\"%d,%d,%f,%lf\", a, b, c, d); return 0;      }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "重新看一下scanf和printf的差别，就明白了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "%5.2f改为%f%1f改为%lf", "referer": "user-0"}]}
{"question": "怎么提取\" \"中的字符串？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "BTW:楼主您的sscanf操作从buf到buf这个挺不好的，严重建议像四老师举例那样写入另一个数组。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我只是举个例子，代表俩缓存区", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "char buf[] = \"\\\"192.168.3.201\\\"\"; char ip[16]; if (1==sscanf(buf,\"\\\"%15[0-9.]\")) printf(\"ip:[%s]\\n\",ip);", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "char buf[] = \"\\\"192.168.3.201\\\"\"; char ip[16]; if (1==sscanf(buf,\"\\\"%15[0-9.]\",ip)) printf(\"ip:[%s]\\n\",ip);", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢您的回复 感谢", "referer": "user-2"}]}
{"question": "inet_addr一直返回-1", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "估计是这个json_object_to_json_string(val)有问题，只能自己单步调试", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我找到问题了，谢谢", "referer": "user-1"}]}
{"question": "为什么我的codeblocks不能反编译？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请问解决了吗 我也遇到了这个问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "需要配置gdb，我猜。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不用试探了，我们没有站在你身后偷看。 所以没有看到你的现场，所以无法回答这个问题。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "emmm", "referer": "user-3"}]}
{"question": "没有对象，只能 New 吗？大揭秘：像写诗一样优雅的生产对象！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "4", "referer": "user-0"}]}
{"question": "请问为什么都是n,但是输出的值与输入的值不一样?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf 里面的 n 为什么要加 & 符号？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "已经发现了,谢谢", "referer": "user-1"}]}
{"question": "（数据结构）不知道哪里出错了，程序无法执行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考我现在学习的游戏编程：     https://space.bilibili.com/1901488254  里面有个独立的MyLinkedList（单链表），已实现了增、删、改、查功能，其中还有一个函数是关于冒泡使用链表排序的。我老师写的代码，每一行都有注解，请参考。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0"}]}
{"question": "是语法错误还是编译器的问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C不支持到处定义变量。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C99+就可以了", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "您好 那么P0 在while里开始处初始化为什么也会报错呀", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "keil u4 可能不支持C99+", "referer": "user-2"}, {"cid": "5", "user": "user-0", "content": "n定义在外面，keil u4 确实会报错不知道咋回事", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "你的P0 在哪儿定义了？ 是没有定义报警吧? 我试了一下，放哪儿都不会报警。。。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "P0 应该是reg52.h里定义的吧  然后我太粗心了 下面应该用LED 但写的P0 可能是因此产生的错误。", "referer": "user-3"}, {"cid": "8", "user": "user-3", "content": "就报错而言：放在while 外定义不会有问题。", "referer": "user-0"}]}
{"question": "求教哇，C语言编程习题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果用指针的话，比较好理解：int main() {    int a, b, c,num,twosum; char q[40]; char* p; p = q;  printf_s(\"please,input str num:\\n\"); gets(p);  printf_s(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n\"); printf_s(\"输入的三位数是:\"); puts(p); printf_s(\"\\n\"); a = *(p + 2); b = *(p + 1); c = *p; printf_s(\"%c,%c,%c\", a, b, c); printf_s(\"\\n\");  num = a * 100 + b * 10 + c; printf_s(\"逆数为：%d\",num);  printf_s(\"逆数两倍为：%d\", num * 2);   return 0;      }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "差个&      scanf(\"%d\", &sum);", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "看到了，谢谢大佬，已经好了", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "不用客气", "referer": "user-0"}]}
{"question": "字符变量与字符常量的比较问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "@AQ_No_Happy 明白了，谢谢。题目(6.14)： test.c #include <stdio.h> #include <Windows.h>   int main(void) {     char ch1, ch2;     int i=0;       while (ch1 = (ch2=getchar()) == 'A')     {         printf(\"ch1 = %d\\n\", ch1);         printf(\"ch2 = %d\\n\", ch2);         i++;     }       printf(\"=============================\\n\");     printf(\"ch1 = %d\\n\", ch1);     printf(\"ch2 = %d\\n\", ch2);     printf(\"\\'\\\\n\\'=%d\\n\", '\\n');     printf(\"i = %d\\n\", i);      system(\"pause\");     return 0; }  结果：", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "\\n 的 ASCII码对应 10", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "没有搞错，当开始打A的时候，A在缓冲区，当按下回车的时候，第一个getchar()才获取到A这个值 顺利存到ch里 但回车既是确定又是字符，回车'\\n'它也跟着进了缓冲区，并且和A一起被释放，A到了程序里 回车（'\\n'）也到了程序里，并且被第2个循环的 getchar（）获取，获取后与常量字符A进行比较，结果是0，循环终止，输出0。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "其次，从语义上看，似乎不该用while，这里应该是个if吧？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "首先，去掉while行末的分号。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "这是一道填空题。  **6.14** 若变量已正确定义，在执行以下 `while` 语句时，输入字符 `A` 后，`ch` 的值是______。 ```c     while (ch = getchar() == 'A'); ```", "referer": "user-2"}]}
{"question": "计算栈内部的元素，栈的空间结构是怎样的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "31", "referer": "user-0"}]}
{"question": "通过指针函数找出二维数组中不符合要求的元素所在的行，并打印出来。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <string.h>  #define printf_s printf  int main() {     float score[][4] = { {60,70,80,90},{56,89,67,88},{34,78,90,66} };     float* search(float(*pointer)[4]);     float* p;     int i;     int j;     for (i = 0; i < 3; i++)     {         p = search(score + i);         if (!p)             continue;         //if (p == *(score + i))         //{             printf_s(\"第%d个学生成绩有不及格\\n\", i);             for (j = 0; j < 4; j++)             {                 printf_s(\"%2.1f \", *(p + j));             }             printf_s(\"\\n\");         //}     }        return 0;  }  float* search(float(*pointer)[4]) {     int i;     float * pt;     pt = NULL;     for (i = 0; i < 4; i++)     {         if (*(*pointer + i) < 60) pt = *pointer;     }       return (pt); }   供参考～", "referer": "user-0"}]}
{"question": "【求解答】switch 的用法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "刚才我试着将代码敲到电脑里运行看看时，发现D选项中 case10 : 空格的位置不对，应该是 case 和 常量表达式(10) 之间有一个空格，而 常量表达式(10) 和冒号 : 之间不能加空格，正确的写法应该是 case 10:。看这几个选项太考验眼力👀和细心😯了", "referer": "user-0"}]}
{"question": "c语言难题，好难呀，，，， ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我是按循环队列算的。如果不是循环队列，就是count=rear-front;到题中front>rear,怪了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "你好，请问一下 void fun() { char a; a=getchar(); if(a!='c')  fun(); putchar(a); } int main() { fun(); }  当输入‘abc'时，为什么输出的结果不是c呢？？？？？？？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "单步调试一下就知道了。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "if (rear>=front) count=rear-front; else count=rear+a-front;", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "怎么别人说是加初始状态的值呀", "referer": "user-1"}]}
{"question": "Visual Studio 2019使用scanf()函数报错的解决方法 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "收藏了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "谢谢！很有帮助！！！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "我的博文有很多文章的。", "referer": "user-1"}]}
{"question": "关于C语言基本数据类型float的困惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "改成 double", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "精度有限，也就是有效数字位数有限，它只能记住7位呀。当你有100亿入账的时候，你忘记了自己原本还有的两元三角四分，不是很正常么？", "referer": "user-0"}]}
{"question": "巨难的问题，通俗易懂的讲解一下static 定义的变量是什么意思 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "就是你在哪个文件里面定义了一个函数为static 那么就只能在这个文件里面引用这个函数。其他的文件想调用这个static函数会编译报错。就这个意思。 对于变量一样的。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "就是你在哪个文件里面定义了一个函数为static 那么就只能在这个文件里面引用这个函数。其他的文件想调用这个static函数会编译报错。就这个意思。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "static主要就是限定作用域： #include <stdio.h> #include <unistd.h>  static float p = 3.1415;  static int test(void);  int main(int argc, char **argv) { while(1) { test(); sleep(1); } }  static int test(void) { static int time = 0; time ++; printf(\"test times: %d\\n\", time); }  1.`p`本身是个全局变量，然后添加`static`，意思就是将这个全局变量只在这个文件中使用，如果其他文件中有相同名字的全局变量，在这个文件也就只用这个变量的值。 2. `test`是个函数，但是添加了`static`表示为只在文件中调用，在生成库文件的时候不会生成这个函数的符号，就是外部不可见。 3. `time`是个局部变量，添加`static`修饰后，那么你就可以将他看作一个全局变量，但是作用域只在这个函数里面，`static int time = 0;`这个语句呢在调用函数的时候也不会运行，所以每次调用test函数，这个变量的值都会继续加一。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "局部变量：我们知道，不写static的局部变量默认是auto的（这里是ANSIＣ的auto语义），定义它的块或函数结束的时候，这样的变量会失去定义从而“消失”，如果有机会再来，那会重新产生一个新的变量。——它“转世”了自然没有“前世”的记忆。所以有static的局部变量从现象上看是全局的生命周期，不会随着某块代码或函数的结束而消失，会一直存在直到程序结束。当然其可见性仍然是局部的。 全局变量：前面加static的唯一作用是把这个变量的可见性局限在当前源文件，不准在其他源文件通过extern引用这个变量。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "这个讲解真牛呀，瞬间就懂了", "referer": "user-3"}]}
{"question": "tcp服务器怎么判断客户端是否断开连接？或者异常中断？释放线程？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果TCP链接被对方断开,协议栈会发送挥手包。这时候,你去读取TCP包的时候就会报错。这种情况下,你就可以认为断开,还有一种情况就是中间的路由或者网络出问题了。那么这种情况下你就需要心跳包来检测。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "超时，再超时，又超时，失去耐心。不管是显式表达，还是底层释放，统统是这个原理。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "心跳包了解一下", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢您的回复 已经解决，使用getsockopt检测连接状态即可", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "比不上用心跳包可靠且自主可控", "referer": "user-0"}]}
{"question": "在计算机编程中，网络可谓是主心骨之一，扛起了网络互通，连接万物的重任！其互通的关键 “ HTTP 连接 ” 是重中之重！那么征服 “ 三次握手、四次挥手 \" ，是踏入计算机编程行业的敲门砖！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "1", "referer": "user-0"}]}
{"question": "求助求助，求两个数组之间的交集并集和差集", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <algorithm> #include <iostream> #include <functional> #include <cstring> using namespace std; int main() {     char *Alphabet = \"abcdefghijklmnopqrstuvwxyz\" ;     char *Vowels   = \"aeiou\" ;     char *AlphaNum = \"0123456789abcdef\" ;     char result[45] ;     char *last ;      int lenA  = strlen(Alphabet) ;     int lenV  = strlen(Vowels  ) ;     int lenAN = strlen(AlphaNum) ;      cout << \"Alphabet = \" << Alphabet << endl ;     cout << \"Vowels   = \" << Vowels   << endl ;     cout << \"AlphaNum = \" << AlphaNum << endl ;      cout << \"\\nusing non-predicate versions\" << endl ;      //non-predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result) ;     *last = 0 ;     cout << \"set_difference(Alphabet, AlphaNum) =  \" << result << endl ;      //non-predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result) ;     *last = 0 ;     cout << \"set_intersection(Alphabet, AlphaNum) =  \" << result << endl ;      //non-predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result) ;     *last = 0 ;     cout << \"set_symmetric_difference(Alphabet, Vowels) =  \" << result << endl ;      //non-predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result) ;     *last = 0 ;     cout << \"set_union(Alphabet, AlphaNum) =  \" << result << endl ;      cout << \"\\nusing predicate versions\" << endl ;      //predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result  , less<char>()) ;     *last = 0 ;     cout << \"set_difference(Alphabet, AlphaNum) =  \" << result << endl ;      //predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result  , less<char>()) ;     *last = 0 ;     cout << \"set_intersection(Alphabet, AlphaNum) =  \" << result << endl ;      //predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result  , less<char>()) ;     *last = 0 ;     cout << \"set_symmetric_difference(Alphabet, Vowels) =  \" << result << endl ;      //predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result  , less<char>()) ;     *last = 0 ;     cout << \"set_union(Alphabet, AlphaNum) =  \" << result << endl ;      return 0 ; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "建议直接调用std::set的相应方法", "referer": "user-0"}]}
{"question": "关于斐波那契查找的算法问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "与二分查找相比，它有任何优点吗？", "referer": "user-0"}]}
{"question": "问题求教，谢谢，感激不尽", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主的代码修改如下，问题见注释处： #include <stdio.h>     #include <stdlib.h>     #include <math.h>   int main() {     int x, y, t;     double z;     scanf(\"%d %d\", &x, &y);     t = x;     x = x % 12;   //这里少了24小时制的转换            y = y % 60;     z = 5.5 * y - 30 * x;     if (z < -180)// ; 这里多了 ’; '号         z = 360 + z;     else if (z >= -180 && z <= 0)//这里少了 else ，>=  <=         z = -z;     else if (z > 180)      //这里少了 else         z = 360 - z;     else         z = z;     printf(\"At %d:%02d the angle is %0.1lf degrees.\\n\", t, y, z);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "感谢分享", "referer": "user-1"}]}
{"question": "TCP协议socket在子线程向缓冲区写数据出现 段错误 (核心已转储) 问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "需要加mutex锁", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "AnswerThread::AnswerThread(ros::NodeHandle& _nh,TCPClient _client)这里_client只是一个临时对象，    client2 = &_client; 指向它，出了构造函数就无效了", "referer": "user-0"}]}
{"question": "手撕算法，是面试中必遇的一道坎，迈过去就是康庄大道，不然就是重头再来！拿下这些，你将走向柏油…", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "1", "referer": "user-0"}]}
{"question": "请问学生用什么软件写C语言比较好，谢谢谢谢谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "windows 用visual studio 比较方便,如果在Linux上的话用vs code +  GCC", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用Visual stdio 2019版本，这个挺好用的！链接： https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Community&rel=16这个是社区版，免费的，完全够用！！！     https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Community&rel=16%E8%BF%99%E4%B8%AA%E6%98%AF%E7%A4%BE%E5%8C%BA%E7%89%88%EF%BC%8C%E5%85%8D%E8%B4%B9%E7%9A%84%EF%BC%8C%E5%AE%8C%E5%85%A8%E5%A4%9F%E7%94%A8%EF%BC%81%EF%BC%81%EF%BC%81", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "业界写C都用sourceinsight, 然后工具链编译运行", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "Visual C++ 2010 Express简体中文版 ▼     http://pan.baidu.com/s/1bnwRVLt", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢", "referer": "user-4"}, {"cid": "7", "user": "user-5", "content": "免费的就用dev-c++:      https://github.com/Embarcadero/Dev-Cpp/", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "谢谢", "referer": "user-5"}, {"cid": "9", "user": "user-6", "content": "vs 2013", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "谢谢", "referer": "user-6"}, {"cid": "11", "user": "user-7", "content": "codeblocks比较好一些 而且工具自带有gcc  不需要额外的下载，链接如下：     https://blog.csdn.net/baolibin528/article/details/53709602/", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "谢谢", "referer": "user-7"}]}
{"question": "scanf 使用上的一些问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这里有关于scanf()的详解，是另一位博主的     https://bbs.csdn.net/topics/600546032", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Format Specification Fields: scanf and wscanf FunctionsA format specification has the following form: %[*] [width] [{h | l | I64 | L}]type The format argument specifies the interpretation of the input and can contain one or more of the following:  White-space characters: blank (' '); tab ('\\t'); or newline ('\\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input. Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates. Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read. When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string. An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification. Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.  The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%. An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h> #include <string.h>   int main(){     char str1[30] = {0};     char str2[30] = {0};     char str3[30] = {0};     char str4[30] = {0};       printf(\"first:\\n\");      scanf(\"%[a-zA-Z]\", str1);            scanf(\"%s\", str2);                   printf(\"str1 = %s\\n\", str1);          printf(\"str2 = %s\\n\", str2);           printf(\"\\nsecond:\\n\");     rewind(stdin);     scanf(\"%[a-zA-Z]\", str3);             scanf(\"%s\", str4);              printf(\"str3 = %s\\n\", str3);     printf(\"str4 = %s\\n\", str4);       return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "那是每次使用 scanf 后都要清除缓冲区吗？为什么我连续使用两个scanf(\"%s\", str1);  scanf(\"%s\", str2); 打印出来都很正常？", "referer": "user-2"}, {"cid": "5", "user": "user-3", "content": "代码一样但是环境不同啊。第一次结束之后输入缓冲区里残留着一个换行符，于是它干扰了第二次的输入。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "我还是不明白，第一次输入不是被 str2 给接收了吗？为什么会还会留到 str3 接收换行呢？", "referer": "user-3"}, {"cid": "7", "user": "user-3", "content": "默认的%s会接受并忽略前置白空格，并在前瞻到后置白空格的时候停下，并不接受它。 而你的正则式显然是另外一个脾气。", "referer": "user-0"}]}
{"question": "求出n！的值中末尾为0的个数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "sum += n/5; // ① n /= 5; // ②", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "大概是个找规律题。每五次就出现一个0。", "referer": "user-0"}]}
{"question": "用指针把a字符串数组复制到b字符串数组。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}]}
{"question": "MSVC如何用命令行编译出64位程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "私信只能发三句，我在这里回你。setvbuf的第二个参数，是给流（stdin/stdout/文件等）的缓冲区（我们叫它buffer）。因为是测试stdin，所以用scanf函数，它的第二个参数是被读入变量的地址（字符数组，因为是数组，直接，写字符数组名，我们叫他string）。这两个量，是两个独立的内存，不应该，把string传入到setvbuf做它的第二个参数。如果，把string作为参数传入到setvbuf中，那么就会出现，你当时提出的问题。你要是还感兴趣，可以看一下，我这个回答。关于setvbuf(stdin，......)的问题？ - 觉渺的回答 - 知乎https://www.zhihu.com/question/54681443/answer/2378633586", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\amd64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\amd64_arm\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\amd64_x86\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\x86_amd64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\x86_arm\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\BuildTools\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx64\\x64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\BuildTools\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx64\\x86\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\BuildTools\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx86\\x64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\BuildTools\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx86\\x86\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Enterprise\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx64\\x64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Enterprise\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx64\\x86\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Enterprise\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx86\\x64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Enterprise\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx86\\x86\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise\\VC\\Tools\\MSVC\\14.29.30037\\bin\\Hostx64\\x64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise\\VC\\Tools\\MSVC\\14.29.30037\\bin\\Hostx64\\x86\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise\\VC\\Tools\\MSVC\\14.29.30037\\bin\\Hostx86\\x64\\cl.exeC:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise\\VC\\Tools\\MSVC\\14.29.30037\\bin\\Hostx86\\x86\\cl.exe", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "VC++2005就支持64位了，否则xp和vista的64位版本是怎么编译出来的呢VC++的设计是不同版本（x86、x64、ARM、ARM64等等）的编译器独立存在，不是gcc那种一个编译器生成不同平台可执行文件的设计，安装好之后，只需要在命令行运行vcvars32.bat、vcvars64.bat... 就可以使用对应的命令行工具", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我用的VC2010学习版，只有vcvars32.bat，没有vcvars64.bat，是安装错了还是？vcvars32.bat运行出来是什么样子，我运行了好像没啥结果", "referer": "user-3"}, {"cid": "5", "user": "user-2", "content": "VC2010是不是不支持编译生成64位程序？ 如果是VS2015，参考下面：生成Release|x64\"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Common7\\IDE\\devenv.exe\" d:\\test\\test.sln /rebuild \"Release|x64\" /out d:\\test\\c.log或生成Debug|x64\"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Common7\\IDE\\devenv.exe\" d:\\test\\test.sln /rebuild \"Debug|x64\" /out d:\\test\\c.log", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "CL不可以吗？VC2010好像没devenv.exe", "referer": "user-2"}]}
{"question": "Ab Test 在互联网产品精细化运营中发挥着重要且出色的作用，通过实验的形式，以数据为依据，科学决策，使产品在市场中保持强劲竞争力！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "2", "referer": "user-0"}]}
{"question": "C语言#define预处理宏定义详细解说 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "理解和讨论之前，请先学会如何观察！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E  ▼     http://bbs.csdn.net/topics/391003898", "referer": "user-0"}]}
{"question": "应提交哪个文件到码云？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "源代码，可执行以及输出文件不提交", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议全部提交。", "referer": "user-0"}]}
{"question": "Linux 中用select 机制实现多个客户端并发在线问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "老赵，你那个select对吗？我觉得有点问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可以是可以，有点儿蹩脚了先创建监听的fd，和连接fd列表（里面还有记录已经写了多少了），然后循环开始【将监听fd和所有连接fd加入集合，然后开始select，返回后先判断是否有新的连接，如果有就accept，将产生的连接fd加入连接列表，遍历所有连接fd，每个fd写1k数据，如果已经写完了，则关闭这个连接，从连接fd列表里删除】大概是这样吧", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "大概是这样，不过要同时遍历读写的fd集合才能实现", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "嗯对是要区分读写，赵老师的框架就可以，改成linux的就行", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "仅供参考：（尽管是windows下的例子） /******************************************************************************\\ * ioctl.c - TCP server * *       This is a part of the Microsoft Source Code Samples. *       Copyright 1996-1997 Microsoft Corporation. *       All rights reserved. *       This source code is only intended as a supplement to *       Microsoft Development Tools and/or WinHelp documentation. *       See these sources for detailed information regarding the *       Microsoft samples programs. \\******************************************************************************/    #define WIN32_LEAN_AND_MEAN #include <winsock2.h> #include <stdlib.h> #include <stdio.h> #include <string.h>  #define DEFAULT_PORT 5001  int ReadAndEcho(SOCKET , char *,int ) ; int WriteMessage(SOCKET , char *,int ) ;  void Usage(char *progname) {     fprintf(stderr,\"Usage\\n%s -e [endpoint] -i [interface]\\n\",         progname);     fprintf(stderr,\"Where:\\n\");     fprintf(stderr,\"\\tendpoint is the port to listen on\\n\");     fprintf(stderr,\"\\tinterface is the ipaddr (in dotted decimal notation)\");     fprintf(stderr,\" to bind to\\n\");     fprintf(stderr,\"Defaults are 5001 and INADDR_ANY\\n\");     WSACleanup();     exit(1); } int main(int argc, char **argv) {      char Buffer[128];     char *interface= NULL;     unsigned short port=DEFAULT_PORT;     int    fromlen;     int    i, ioctl_opt =1;     struct sockaddr_in local, from;     WSADATA    wsaData;     SOCKET listen_socket, msgsock;     fd_set readfds,    writefds, exceptfds;      /* Parse arguments */     if (argc >1) {         for(i=1;i <argc;i++) {             if ( (argv[i][0] ==    '-') || (argv[i][0] == '/') ) {                 switch(tolower(argv[i][1]))    {                     case 'i':                         interface =    argv[++i];                         break;                     case 'e':                         port = atoi(argv[++i]);                         break;                     default:                         Usage(argv[0]);                         break;                 }             }             else                 Usage(argv[0]);         }     }          if (WSAStartup(0x202,&wsaData) == SOCKET_ERROR) {         fprintf(stderr,\"WSAStartup failed with error %d\\n\",WSAGetLastError());         WSACleanup();         return -1;     }          if (port == 0){         Usage(argv[0]);     }      //     // The fd sets should be zeroed out before using them to prevent errors.     FD_ZERO(&readfds);     FD_ZERO(&writefds);     FD_ZERO(&exceptfds);     memset(Buffer,0,sizeof(Buffer));      local.sin_family = AF_INET;      //     // bind to specific interface if desired.      local.sin_addr.s_addr = (!interface)?INADDR_ANY:inet_addr(interface);      /*      * Port MUST be in Network Byte Order      */     local.sin_port = htons(port);      listen_socket = socket(AF_INET, SOCK_STREAM,0); // TCP socket     if (listen_socket == INVALID_SOCKET){         fprintf(stderr,\"socket() failed with error %d\\n\",WSAGetLastError());         WSACleanup();         return -1;     }     //     // bind() associates a local address and port combination with the     // socket just created.      if (bind(listen_socket,(struct sockaddr*)&local,sizeof(local) )         == SOCKET_ERROR) {         fprintf(stderr,\"bind() failed with error %d\\n\",WSAGetLastError());         WSACleanup();         return -1;     }      //     // start listening on the socket for incoming connections     //     if (listen(listen_socket,5) == SOCKET_ERROR) {         fprintf(stderr,\"listen() failed with error %d\\n\",WSAGetLastError());         WSACleanup();         return -1;     }     printf(\"%s: Listening on port %d\\n\",argv[0],port);      //     // Set the socket to non-blocking mode.     //     if (ioctlsocket(listen_socket,FIONBIO,&ioctl_opt) == SOCKET_ERROR) {         fprintf(stderr,\"ioctlsocket failed %d\\n\",WSAGetLastError());         WSACleanup();         return -1;     }     //     // The structure of    the    loop below is very simple. We only accept one     // connection at a time. As    soon as    another    client connects, we     // disconnect the first    one, and start talking to the new client.     // All this    server does    is to echo the data    received on    the    socket     // back    to the client.     //     // This    is not a very realistic    server,    but    it does    serve to show that     // select()    does not scale very    well on    win32. If we were dealing     // with    more than one client, we would have    to have    a list of sockets     // that    are    in each    fdset to be    able to    check them when    select()     // returns.     //     while(1) {          //         // A socket    in the listen()    state becomes ready    to read    when a         // client connects to it. An accept() will complete    without         // blocking.         // Since select    sets the sockets that are ready    to be read from    or         // written to, we have to include listen_socket    in the fdset each time         // through the loop.         //          FD_SET(listen_socket,&readfds);          i =    select(0,&readfds,&writefds,&exceptfds,NULL);         if (i == SOCKET_ERROR) {             fprintf(stderr,\"select failed %d\\n\",WSAGetLastError());         }         if (i==0){             fprintf(stderr,\"Select returned no fds ready\\n\");         }          if (FD_ISSET(listen_socket,    &readfds)){             //             // close the previous client socket.             // We must also    clear it from the fdset    to prevent select()             // from    failing.             //             closesocket(msgsock);             FD_CLR(msgsock,&readfds);             FD_CLR(msgsock,&writefds);             fromlen    = sizeof(from);             msgsock= accept(listen_socket,(struct sockaddr*)&from,&fromlen);             if (msgsock    == INVALID_SOCKET) {                 fprintf(stderr,\"accept failed %d\\n\",WSAGetLastError());                 WSACleanup();                 return -1;             }             FD_SET(msgsock,&writefds);             FD_SET(msgsock,&readfds);             continue;         }         if (FD_ISSET(msgsock,&readfds) ) {             //             // socket is ready to read,    i.e., there    is data    on the socket.             //             if (ReadAndEcho(msgsock,Buffer,sizeof(Buffer))<0) {                 fprintf(stderr,\"terminating connection\\n\");                 FD_CLR(msgsock,&readfds);                 FD_CLR(msgsock,&writefds);                 closesocket(msgsock);                 continue;             }         }         if (FD_ISSET(msgsock,&writefds)    ){             if (WriteMessage(msgsock,Buffer,sizeof(Buffer))    <=0) {                 fprintf(stderr,\"terminating connection\\n\");                 FD_CLR(msgsock,&readfds);                 FD_CLR(msgsock,&writefds);                 closesocket(msgsock);                 continue;             }         }         FD_SET(msgsock,&writefds);         FD_SET(msgsock,&readfds);     } } int ReadAndEcho(SOCKET insock, char *Buffer,int size) {     int    rc;      rc = recv(insock,Buffer,size,0);      if (rc == SOCKET_ERROR)    {         fprintf(stderr,\"recv() failed with error %d\\n\",WSAGetLastError());           return -1;     }     if (rc ==0)    {         fprintf(stderr,\"Connection closed by client\\n\");         return 0;     }     printf(\"Received [%s] from client\\n\",Buffer);     return rc; } int WriteMessage(SOCKET outsock, char *Buffer,int size) {     int    rc;     int    lasterr;      printf(\"Sending [%s] to client\\n\",Buffer);     rc = send(outsock,Buffer,size, 0);      if (rc == SOCKET_ERROR)    {       lasterr =    WSAGetLastError();       if (lasterr == WSAEWOULDBLOCK)         return 0;       else {         fprintf(stderr,\"send() failed with error %d\\n\",lasterr);             return -1;       }     }     if (rc ==0)    {         fprintf(stderr,\"Connection closed by client\\n\");     }     return rc; }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢，后来同时使用读写文件描述符集合实现了", "referer": "user-3"}, {"cid": "7", "user": "user-3", "content": "多进程同时下载不香吗？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "导师给的一个任务，要求用select呢", "referer": "user-3"}, {"cid": "9", "user": "user-4", "content": "不起新线程是不可能的cpu是流水线作业，就算多核，也是按顺序执行你的代码代码里规定了流程，cpu就会完全按照你给定的流程来输出结果", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "是的，但是我可以通过降低阻塞时间来使两个都在输出，比如我下载两个文件，a下载1024byte，b下载1024byte，循环这样，本质上可能不是并发，但从客户端看来是不是在同时下载呢？", "referer": "user-4"}, {"cid": "11", "user": "user-4", "content": "哦，是的，这样是可以的，遍历句柄集合，每个发1k，可以的。accept设置为非阻塞模式，每次accept到之后遍历select集合，所有可写的都写1k数据（或者自己做一些管理，想着都烦）,但是对链接状态的管理也挺麻烦，之前好像看过有相关的文章。4老师的代码，你先看看能不能用吧", "referer": "user-0"}, {"cid": "12", "user": "user-5", "content": "收到可写信号后新起线程", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "你好，能否不使用线程做到呢，仅使用i/o复用", "referer": "user-5"}, {"cid": "14", "user": "user-5", "content": "对多线程这么排斥？参考一下libevent，muduo等高效的网络通讯框架，直接用就行了", "referer": "user-0"}]}
{"question": "这是书本上的得用指针输出多维数组各元素的值，简单，但感觉不好理解。逻辑性不强。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> int main() {     int a[3][4] = {         {1, 2, 3, 4},         {5, 6, 7, 8},         {9,10,11,12}};     int* p;     int y,x;     for (y=0;y<3;y++) {         for (x=0;x<4;x++) {             printf(\"%p \",&a[y][x]);         }         printf(\"\\n\");     }     for (p = a[0];p < a[0] + 12; p++) {         printf(\"%8d \", *p);         if ((p-a[0])%4==3) {             printf(\"\\n\");         }     }     system(\"pause\");     return 0;  } //00EFFC48 00EFFC4C 00EFFC50 00EFFC54 //00EFFC58 00EFFC5C 00EFFC60 00EFFC64 //00EFFC68 00EFFC6C 00EFFC70 00EFFC74 //       1        2        3        4 //       5        6        7        8 //       9       10       11       12 //请按任意键继续. . . //   这是zhao4zhong1改写的输出多维数组各元素的地址和用指针输出多维数组各元素的值，简单，且感觉好理解。逻辑性强。", "referer": "user-0"}]}
{"question": "通过指针变量输出二维数组各元素的值。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "这种方法和书上的不一样，我没有按书上的写，看起来没有书上的简单，但是我个人觉得好理解 ，比较有逻辑。", "referer": "user-0"}]}
{"question": "性能调优之三十六计 —— 「取而代之」Echo/Json 篇", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "1", "referer": "user-0"}]}
{"question": "求大佬解题，代码运行无数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<string.h>  int main(int argc, char **argv) {     char s[100] = { \"This is C programming text\" };     char t[100] = { \"This is a text for C programming\" };      int i = 0;     int j = 0;     int count = 0;     int start_count = 0;     int max = 0;      for (i= 0; i <= strlen(s) ; i++)     {         for(j = 0; j <= strlen(t); j++)// 字符串s中单个字符与字符串t中所有字符比较         {             if ((s[i] == t[j]) && (t[j] != ' ') && (i != strlen(s)))// 判断相同字符             {                 count++;// 单词长度计数                 i++;// 单词逐个字母比较移位             }             else             {                 i = count > 0 ? i - count: i;// 将i恢复循环计数                 if (count > max)// 判断是否位最长相同单词                 {                     max = count;// 保存单词长度                     start_count = j -max;// 相同单词在字符串的开始位                 }                 count = 0; // 清空单词长度             }         }     }      // 打印信息     for (i = 0; i < max; i++)     {         printf(\"%c\", t[start_count + i]);     }     printf(\"\\n\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<string.h>  int main(int argc, char **argv) {     char s[100] = { \"This is C programming text\" };     char t[100] = { \"This is a text for C programming\" };      int i = 0;     int j = 0;     int count = 0;     int start_count = 0;     int max = 0;      for (i= 0; i <= strlen(s) ; i++)     {         for(j = 0; j <= strlen(t); j++)// 字符串s中单个字符与字符串t中所有字符比较         {             if ((s[i] == t[j]) && (t[j] != ' ') && (i != strlen(s)))// 判断相同字符             {                 count++;// 单词长度计数                 i++;// 单词逐个字母比较移位             }             else             {                 i = count > 0 ? i - count: i;// 将i恢复循环计数                 if (count > max)// 判断是否位最长相同单词                 {                     max = count;// 保存单词长度                     start_count = j -max;// 相同单词在字符串的开始位                 }                 count = 0; // 清空单词长度             }         }     }      // 打印信息     for (i = 0; i < max; i++)     {         printf(\"%c\", t[start_count + i]);     }     printf(\"\\n\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "if (s[i] == t[j])        {            count++;            i++;            j++;     if (s[i] == ' ')       {             k = count;              count = 0;              a = i-1;        }   }  在i与j等于8时因为C与a不相等，就无法跳入if里面，那么i，j就不会改变数值了，就会进入死循环", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "if (s[i] == t[j])        {            count++;            i++;            j++;         if (s[i] == ' ')         {              k = count;               count = 0;               a = i-1;         }     }  这里。。你应该把i，j++给移出来，不然会进入死循环，无法结束，自然就没法打印了", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "i，和j移到哪里呢？", "referer": "user-2"}, {"cid": "6", "user": "user-0", "content": "我移了以后，结果并不对", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "我也不知道，我移出来，只能得到ming相等，但不是完整单词，我觉得应该不符合你的结果", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "char str[100] = {0};   //初始化一个字符串数组，长度为1，里面有一个字符char(0)     for (i = 0; i <= max; i++)         str[i] = s[a - max + 1 + i];    //字符串数组的长度能否更改？     str[i] = '\\0';     printf(\"%s\", str);     return 0;", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "#include&lt;stdio.h&gt; #include&lt;string.h&gt;  int main(void *arg) { \tchar s[100] = { \"This is C programming text\" }; \tchar t[100] = { \"This is a text for C programming\" }; \tint i = 0; \tint j = 0; \tint count = 0; \tint start_count = 0; \tint max = 0; \tint k = 0; \twhile ((s[i] != '\\0') && (t[j] != '\\0')) \t{ \t\tif (s[i] == t[j]) \t\t{ \t\t\tif (s[i] == ' ') \t\t\t{ \t\t\t\tk = count; \t\t\t\tcount = 0; \t\t\t} \t\t\telse \t\t\t{ \t\t\t\tcount++; \t\t\t} \t\t} \t\tif (k &gt; max) \t\t{ \t\t\tmax = k; \t\t\tstart_count = i - k;// 相同单词在字符串的开始位 \t\t} \t\ti++; \t\tj++; \t}  \tchar str[100] = {0}; \tfor (i = 0; i &lt; max; i++) \t{ \t\tstr[i] = s[start_count + i]; \t} \tstr[max] = '\\0'; \tprintf(\"%s \\n\", str); \treturn 0;\t\t } // 改成这样应该就可以了，主要是逻辑感觉有点问题。", "referer": "user-3"}, {"cid": "10", "user": "user-0", "content": "还是不对运行结果是This", "referer": "user-1"}, {"cid": "11", "user": "user-1", "content": "#include&lt;stdio.h&gt; #include&lt;string.h&gt;  int main(void *arg) { \tchar s[100] = { \"This is C programming text\" }; \tchar t[100] = { \"This is a text for C programming\" }; \t \tint i = 0; \tint j = 0; \tint count = 0; \tint start_count = 0; \tint max = 0;  \tfor (i= 0; i &lt;= strlen(s) ; i++) \t{ \t\tfor(j = 0; j &lt;= strlen(t); j++)// 字符串s中单个字符与字符串t中所有字符比较 \t\t{ \t\t\tif ((s[i] == t[j]) && (t[j] != ' ') && (i != strlen(s)))// 判断相同字符 \t\t\t{ \t\t\t\tcount++;// 单词长度计数 \t\t\t\ti++;// 单词逐个字母比较移位 \t\t\t} \t\t\telse  \t\t\t{ \t\t\t\ti = count &gt; 0 ? i - count: i;// 将i恢复循环计数\t \t\t\t\tif (count &gt; max)// 判断是否位最长相同单词\t \t\t\t\t{ \t\t\t\t\tmax = count;// 保存单词长度 \t\t\t\t\tstart_count = j -max;// 相同单词在字符串的开始位 \t\t\t\t} \t\t\t\tcount = 0; // 清空单词长度 \t\t\t} \t\t}\t \t} \t \t// 打印信息 \tfor (i = 0; i &lt; max; i++) \t{ \t\tprintf(\"%c\", t[start_count + i]); \t} \tprintf(\"\\n\"); \treturn 0;\t\t } // 再试试这个", "referer": "user-0"}]}
{"question": "求一个简单计算的方式。一列数值，想统计各列的总数，最大值，最小值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以使用SSE/AVX指令maxps、minps、addps，#include <intrin.h>", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "能不能详细点，我这个是在开发板上的Linux 的 要通用点的", "referer": "user-1"}]}
{"question": "大神这个循环看不懂，求解释。http://blog.csdn.net/chenguolinblog/article/details/8991408", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "千句解释不如一句例子啊！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "/* Problem Description 电子科大本部食堂的饭卡有一种很诡异的设计，即在购买之前判断余额。如果购买一个商品之前，卡上的剩余金额大于或等于5元，就一定可以购买成功（即使购买后卡上余额为负），否则无法购买（即使金额足够）。所以大家都希望尽量使卡上的余额最少。 某天，食堂中有n种菜出售，每种菜可购买一次。已知每种菜的价格以及卡上的余额，问最少可使卡上的余额为多少。    Input 多组数据。对于每组数据： 第一行为正整数n，表示菜的数量。n<=1000。 第二行包括n个正整数，表示每种菜的价格。价格不超过50。 第三行包括一个正整数m，表示卡上的余额。m<=1000。  n=0表示数据结束。    Output 对于每组输入,输出一行,包含一个整数，表示卡上可能的最小余额。 */ #include \"stdafx.h\" #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std;   const int N = 1010; const int MAXN = N*50;   int n , m , sum; int v[N] , dp[MAXN];   int solve(){     memset(dp , 0 , sizeof(dp));\t\t\t\t\t\t//初始化dp数组，全部赋值为0     sort(v+1 , v+1+n);\t\t\t\t\t\t\t\t\t//对数组v中的v[1]~v[n]进行排序，也就是对main函数中输入的n个数字进行排序 \tfor(int i = 1 ; i <= n ; i++)\t\t\t\t\t\t//输出排序后的v[1]~v[n] \t\tprintf(\"%d \",v[i]); \tprintf(\"\\n\");     sum = m-5;\t\t\t\t\t\t\t\t\t\t\t//以下几行需要结合题目以及解题思路理解 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//本题的解题思路是：留最贵的菜最后买，然后选择性购买其它的菜，使饭卡剩余钱数最接近5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//所以这里的sum就是购买其它菜可以使用的钱数 \t\t\t\t\t\t\t\t\t\t\t\t\t\t// \t\t\t\t\t\t\t\t\t\t\t\t\t\t// \t\t\t\t\t\t\t\t\t\t\t\t\t\t//     for(i = 1 ; i < n ; i++){\t\t\t\t\t\t\t//从最便宜的菜开始遍历 \t\tprintf(\"i=%d\\n\",i);\t\t\t\t\t\t\t\t//输出i，也就是第i便宜的菜         for(int j = sum ; j >= v[i] ; j--){\t\t\t\t//v[i]就是第i便宜的菜的价格，这个循环从sum开始递减到v[i]，将j称之为剩余的钱数             dp[j] = __max(dp[j] , dp[j-v[i]]+v[i]);\t\t//为dp数组赋值，这里算是算法的关键 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//dp[j]存储的值实际上就是当饭卡里还有j+5的钱数时，j元钱可以在前n-1个菜中消费的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//通过两层for循环实现对dp数组的赋值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//举个例子：4种菜，价格分别2、3、5、7，饭卡剩余12元 \t\t\t\t\t\t\t\t\t\t\t\t\t\t/*本程序的输出结果为： \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t4 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t2 3 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t2 3 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t12 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t2 3 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\ti=1 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdp[7]=2 dp[6]=2 dp[5]=2 dp[4]=2 dp[3]=2 dp[2]=2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0 0 2 2 2 2 2 2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\ti=2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdp[7]=5 dp[6]=5 dp[5]=5 dp[4]=3 dp[3]=3 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0 0 2 3 3 5 5 5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\ti=3 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdp[7]=7 dp[6]=5 dp[5]=5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0 0 2 3 3 5 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t*/ \t\t\t\t\t\t\t\t\t\t\t\t\t\t//从i=1开始看，v[1]=2，饭卡里有12元，减去5，还有7元可用 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//进入内层for循环，j从7到2，对应的输出dp[7]~dp[2]的值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//因为只有一个菜，而且一个菜只能买一次，所以dp[7]~dp[2]的值均为这个菜的价格，即v[1] \t\t\t\t\t\t\t\t\t\t\t\t\t\t//内层循环结束后，外层循环i++，即i=2,v[2]=3,这时表示有两个菜，而且第二个菜的价格比第一个高 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//再次进入内层循环,j从7到3,这时dp[7]~dp[3]会被重赋值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//首先是dp[7],它的取值是当前dp[7]，也就是2，与dp[7-v[2]]+v[2]的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//dp[j-v[i]]表示先消费当前最贵的菜v[i]后,剩余的钱能花掉的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//结合例子来说，就是先花掉v[i]=3后，在前i-1个菜中还能花掉的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//这里i=2，也就是说7元，花掉3元后，还可以买第一个菜花掉2元，所以dp[7]=5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//此处可能不理解我们明明有7元，为什么还要计算dp[6], \t\t\t\t\t\t\t\t\t\t\t\t\t\t//dp[6]~dp[2]都是为后面的i=3、4时计算dp[7]服务的 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//__max(dp[j] , dp[j-v[i]]+v[i])表示剩余j元钱可以花掉的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//在这两层循环过程中，dp[7]是会变化的，直到循环结束，得出剩余sum=7元时，可以花掉的最大值 \t\t\tprintf(\"dp[%d]=%d \",j,dp[j]); \t\t}  \t\tprintf(\"\\n\");\t \t\tfor(int k=0;k<=sum;k++) \t\t\tprintf(\"%d \",dp[k]); \t\tprintf(\"\\n\");     }     return m-dp[sum]-v[n];\t\t\t\t\t\t\t\t//m是指饭卡里的钱，减去dp[sum],通过上面的计算分析可知(m-dp[sum])>5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//(m-dp[sum])再减去最贵的菜v[n]，就是饭卡里可以剩余的最小值。 }   int main(){     while(scanf(\"%d\" , &n) && n){\t\t\t\t\t//输入一个数字n，n为0则循环终止，结合题目，n就是饭菜的种类          for(int i = 1 ; i <= n ; i++)\t\t\t\t//循环输入n个数字，存储到数组v[1]~v[n],即n种饭菜的价格，这里没有使用v[0]              scanf(\"%d\" , &v[i]); \t\t for(i = 1 ; i <= n ; i++)\t\t\t\t\t//打印输入的n个数字 \t\t\t printf(\"%d \",v[i]); \t\t printf(\"\\n\");          scanf(\"%d\" , &m);\t\t\t\t\t\t\t//输入一个数字，结合题目，就是饭卡里剩余的钱          printf(\"%d\\n\" , m < 5 ? m : solve());\t\t//如果饭卡里的钱m小于5，不能买任何东西，直接输出m；否则执行solve函数，并打印solve的返回值，这是一个条件表达式     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 4 楼 zhao4zhong1 的回复:千句解释不如一句例子啊！ 很受伤，竟然没给分。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 lovesmiles 的回复:这是背包问题的 解法。 那个双重循环怎么解释？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "这是背包问题的 解法。", "referer": "user-0"}]}
{"question": "大神这个循环看不懂，求解释。http://blog.csdn.net/chenguolinblog/article/details/8991408", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "千句解释不如一句例子啊！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "/* Problem Description 电子科大本部食堂的饭卡有一种很诡异的设计，即在购买之前判断余额。如果购买一个商品之前，卡上的剩余金额大于或等于5元，就一定可以购买成功（即使购买后卡上余额为负），否则无法购买（即使金额足够）。所以大家都希望尽量使卡上的余额最少。 某天，食堂中有n种菜出售，每种菜可购买一次。已知每种菜的价格以及卡上的余额，问最少可使卡上的余额为多少。    Input 多组数据。对于每组数据： 第一行为正整数n，表示菜的数量。n<=1000。 第二行包括n个正整数，表示每种菜的价格。价格不超过50。 第三行包括一个正整数m，表示卡上的余额。m<=1000。  n=0表示数据结束。    Output 对于每组输入,输出一行,包含一个整数，表示卡上可能的最小余额。 */ #include \"stdafx.h\" #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std;   const int N = 1010; const int MAXN = N*50;   int n , m , sum; int v[N] , dp[MAXN];   int solve(){     memset(dp , 0 , sizeof(dp));\t\t\t\t\t\t//初始化dp数组，全部赋值为0     sort(v+1 , v+1+n);\t\t\t\t\t\t\t\t\t//对数组v中的v[1]~v[n]进行排序，也就是对main函数中输入的n个数字进行排序 \tfor(int i = 1 ; i <= n ; i++)\t\t\t\t\t\t//输出排序后的v[1]~v[n] \t\tprintf(\"%d \",v[i]); \tprintf(\"\\n\");     sum = m-5;\t\t\t\t\t\t\t\t\t\t\t//以下几行需要结合题目以及解题思路理解 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//本题的解题思路是：留最贵的菜最后买，然后选择性购买其它的菜，使饭卡剩余钱数最接近5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//所以这里的sum就是购买其它菜可以使用的钱数 \t\t\t\t\t\t\t\t\t\t\t\t\t\t// \t\t\t\t\t\t\t\t\t\t\t\t\t\t// \t\t\t\t\t\t\t\t\t\t\t\t\t\t//     for(i = 1 ; i < n ; i++){\t\t\t\t\t\t\t//从最便宜的菜开始遍历 \t\tprintf(\"i=%d\\n\",i);\t\t\t\t\t\t\t\t//输出i，也就是第i便宜的菜         for(int j = sum ; j >= v[i] ; j--){\t\t\t\t//v[i]就是第i便宜的菜的价格，这个循环从sum开始递减到v[i]，将j称之为剩余的钱数             dp[j] = __max(dp[j] , dp[j-v[i]]+v[i]);\t\t//为dp数组赋值，这里算是算法的关键 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//dp[j]存储的值实际上就是当饭卡里还有j+5的钱数时，j元钱可以在前n-1个菜中消费的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//通过两层for循环实现对dp数组的赋值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//举个例子：4种菜，价格分别2、3、5、7，饭卡剩余12元 \t\t\t\t\t\t\t\t\t\t\t\t\t\t/*本程序的输出结果为： \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t4 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t2 3 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t2 3 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t12 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t2 3 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\ti=1 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdp[7]=2 dp[6]=2 dp[5]=2 dp[4]=2 dp[3]=2 dp[2]=2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0 0 2 2 2 2 2 2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\ti=2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdp[7]=5 dp[6]=5 dp[5]=5 dp[4]=3 dp[3]=3 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0 0 2 3 3 5 5 5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\ti=3 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdp[7]=7 dp[6]=5 dp[5]=5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0 0 2 3 3 5 5 7 \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-2 \t\t\t\t\t\t\t\t\t\t\t\t\t\t*/ \t\t\t\t\t\t\t\t\t\t\t\t\t\t//从i=1开始看，v[1]=2，饭卡里有12元，减去5，还有7元可用 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//进入内层for循环，j从7到2，对应的输出dp[7]~dp[2]的值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//因为只有一个菜，而且一个菜只能买一次，所以dp[7]~dp[2]的值均为这个菜的价格，即v[1] \t\t\t\t\t\t\t\t\t\t\t\t\t\t//内层循环结束后，外层循环i++，即i=2,v[2]=3,这时表示有两个菜，而且第二个菜的价格比第一个高 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//再次进入内层循环,j从7到3,这时dp[7]~dp[3]会被重赋值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//首先是dp[7],它的取值是当前dp[7]，也就是2，与dp[7-v[2]]+v[2]的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//dp[j-v[i]]表示先消费当前最贵的菜v[i]后,剩余的钱能花掉的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//结合例子来说，就是先花掉v[i]=3后，在前i-1个菜中还能花掉的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//这里i=2，也就是说7元，花掉3元后，还可以买第一个菜花掉2元，所以dp[7]=5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//此处可能不理解我们明明有7元，为什么还要计算dp[6], \t\t\t\t\t\t\t\t\t\t\t\t\t\t//dp[6]~dp[2]都是为后面的i=3、4时计算dp[7]服务的 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//__max(dp[j] , dp[j-v[i]]+v[i])表示剩余j元钱可以花掉的最大值 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//在这两层循环过程中，dp[7]是会变化的，直到循环结束，得出剩余sum=7元时，可以花掉的最大值 \t\t\tprintf(\"dp[%d]=%d \",j,dp[j]); \t\t}  \t\tprintf(\"\\n\");\t \t\tfor(int k=0;k<=sum;k++) \t\t\tprintf(\"%d \",dp[k]); \t\tprintf(\"\\n\");     }     return m-dp[sum]-v[n];\t\t\t\t\t\t\t\t//m是指饭卡里的钱，减去dp[sum],通过上面的计算分析可知(m-dp[sum])>5 \t\t\t\t\t\t\t\t\t\t\t\t\t\t//(m-dp[sum])再减去最贵的菜v[n]，就是饭卡里可以剩余的最小值。 }   int main(){     while(scanf(\"%d\" , &n) && n){\t\t\t\t\t//输入一个数字n，n为0则循环终止，结合题目，n就是饭菜的种类          for(int i = 1 ; i <= n ; i++)\t\t\t\t//循环输入n个数字，存储到数组v[1]~v[n],即n种饭菜的价格，这里没有使用v[0]              scanf(\"%d\" , &v[i]); \t\t for(i = 1 ; i <= n ; i++)\t\t\t\t\t//打印输入的n个数字 \t\t\t printf(\"%d \",v[i]); \t\t printf(\"\\n\");          scanf(\"%d\" , &m);\t\t\t\t\t\t\t//输入一个数字，结合题目，就是饭卡里剩余的钱          printf(\"%d\\n\" , m < 5 ? m : solve());\t\t//如果饭卡里的钱m小于5，不能买任何东西，直接输出m；否则执行solve函数，并打印solve的返回值，这是一个条件表达式     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 4 楼 zhao4zhong1 的回复:千句解释不如一句例子啊！ 很受伤，竟然没给分。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 lovesmiles 的回复:这是背包问题的 解法。 那个双重循环怎么解释？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "这是背包问题的 解法。", "referer": "user-0"}]}
{"question": "求助：C语言Windows程序设计-编译工具和使用函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学习一下里面的例子代码：MSDN98_1.ISO  ▼     http://pan.baidu.com/s/1dDF41ix  ,MSDN98_2.ISO  ▼     http://pan.baidu.com/s/1bnGo0Vl", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的，谢谢老师，我会努力学习的~希望下次再上来我就是不一样的我了~ 我昨天发的代码本身就有问题后来问题找出来了。然后我昨天也算是把功能简单弄出来了。 感谢~", "referer": "user-1"}]}
{"question": "又来求大佬们解题了~~", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "重启系统，重启大法好", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主的代码修改，供参考： #include<stdio.h> #include<math.h> //int flag; int present(int x) {      int i,k,flag=0;      k = (int)sqrt((double)x);       if(x <= 1)   return flag;      for (i = 2; i <= k; i++)           if (x % i == 0)           {                 flag = 0;                 break;           }      if (i > k) flag = 1;      return flag; } int main() {      int n, a, b;      int t = 0;      for (n = 10; n < 100; n++)      {          if (present(n) != 0)                              //if (flag == 0)                              //    continue;                              //else          {              t = 0;              a = n;              while(a)              {                  t = t*10 + a%10;                  a /= 10;              }                            //b = n - a * 10;                            //t = b * 10 - a;              if(present(t))                            //if (flag == 1)                  printf(\"%d是绝对素数\\n\", n);          }      }      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢大佬", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "/tmp/ccGpTL9R.o：在函数‘present’中： 1.c:(.text+0x1c)：对‘sqrt’未定义的引用 collect2: error: ld returned 1 exit status 大佬，为啥会出现这个报错呢", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "math.h   这个头文件有没有加", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "/找出无暇素数.所谓无暇素数是指本身为素数,且其逆序数也是素数的数,这例计算全逆序,如107=>701/     https://blog.csdn.net/xianfajushi/article/details/25125133?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162988560716780265447767%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=162988560716780265447767&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-1-25125133.pc_v2_rank_blog_default&utm_term=%E8%B4%A8%E6%95%B0&spm=1018.2226.3001.4450", "referer": "user-0"}]}
{"question": "求问大佬代码，到底哪里有问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不能用库函数？请考虑使用scanf从控制台输入整数字符串并得到整数变量，或是使用sscanf从字符串指针进行格式行输入。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "了解一下 ASCII 码简单来说，char类型 8bits，无符号数范围 0~255ASCII 码把常用的字符转成数值，因此你需要转换才能得到或者你可以简单的写代码看看 char s[11] = \"0123456789\"; for(int i = 0; i < 5; ++i) {     if (s[i] != '\\0') {         printf(\"%d \", s[i]);     } }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "以及 ```c for(int i = 0; i &lt;= 0xFF; ++i) {         printf(\"%c \", i); ```", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "懂了，感谢", "referer": "user-2"}, {"cid": "5", "user": "user-3", "content": "供参考: #include<stdio.h> int main() {     long int i, num;     char s[10];     gets_s(s,10);     num = 0;     i = 0;     while (s[i] != '\\0'){                 num = num * 10 + s[i]-'0';         i++;     }     printf(\"%d\", num);     return 0; }", "referer": "user-0"}]}
{"question": "这种警告如何处理！！！！！大佬帮帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "销毁动态顺序表 的逻辑有问题，在检查一下", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用一个临时指针变量接收realloc返回值，判断非空后，再赋值给 sq->data#define INIT_SIZE 10L #define EXPAND_SIZE 5L", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这是什么IDE...warning提示都这么智能，解决方法都写出来的吗？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "VS", "referer": "user-2"}]}
{"question": "大佬们，谁能帮帮我看看这行代码是怎么运行的？？？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "单步调试，注意观察left和right的值变化", "referer": "user-0"}]}
{"question": "C语言printf()函数详细解说", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": ".*    以星号代替数值，类似于width中的*，在输出参数列表中指定精度。的示例呢？", "referer": "user-0"}]}
{"question": "通过extern来改变全局变量的作用域", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "建议少用全局变量，否则项目大了以后，bug不断", "referer": "user-0"}]}
{"question": "关于选择排序的问题，不知道错在哪里", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "找到原因了，少了一段判断语句：if (array[j] < array[k]) 完整个代码如下：#include<stdio.h>int main(){    void sort(int array[], int n);    int i;    int a[10] = { 6,7,4,3,8,9,44,1,2,3 }; /* printf(\"请输入需要排序的整数：\\n\"); for (i = 0; i < 10; i++) {     scanf_s(\"%d\", &a[i]);  } */      sort(a, 10); printf(\"\\n\"); for (i = 0; i < 10; i++) {     printf_s(\"%d,\", a[i]); }  return 0;  }void sort(int array[], int n){    int i, j, k, t;    for (i = 0; i < n - 1; i++)    {        k = i;        for (j = i + 1; j < n; j++)         {         if(array[j]<array[k])               k = j;         }           t = array[k]; array[k] = array[i]; array[i] = t;      }  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "把段落注释的符号去掉", "referer": "user-0"}]}
{"question": " 关于报scanf返回值被 忽略不能运行的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "这是因为编译系统 是vs2019，而在2019中已经没有使用scanf了，而是使用scanf_s输出。 改过来就可以了", "referer": "user-0"}]}
{"question": "一维数组作为函数参数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #pragma warning(disable : 4996) int main() {     float arry(float num[]);     float a[3];     int i;     float aver;     for (i = 0; i < 3; i++)     {         printf(\"请输入第%d个学生的成绩:\",i+1);         scanf(\"%f\", &a[i]);     }     aver = arry(a);     printf(\"平均成绩是：%5.2f\", aver);          return 0; }  float arry(float num[]) {     float sum = 0;     float aver = 0;     int i;     for (i = 1; i < 3; i++)     {         sum = sum + num[i];     }     aver = sum / 3;     return aver; }", "referer": "user-0"}]}
{"question": "关于 lame pcm转化MP3 音频 发现声音和原始的pcm比较变小了，请高手指点下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "lame_set_brate(lame, 32);这个函数不是设置位深度的, 而是设置比特率的, 取值128~320(kbps)", "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-2", "content": "降低一下比特率试试？16位就够了。", "referer": "user-0"}]}
{"question": "C语言逻辑运算符(&&和||)的短路求值知识", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第一个逻辑与判断第一个表达式为假了，后面的就不会执行", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不错，长知识了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "了解短路机制就好了...短路求值这种，debug都不好找问题的写法，最好不要出现在代码里", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "我就想问(a=0)&&(b=4);写的意义何在？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "短路求值是个知识点", "referer": "user-4"}]}
{"question": "来个大佬指点下，卡了个下午，还是没搞懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "i是你得到的字符串长度啊，返回它用来下面进行比较，不是很舒适么？你得区分表达式和声明，这个printf后面的括号里的是表达式，如果带着方括号，就是在表示单个字符了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "多谢指教，不过还是有点没搞懂，字符串长度不是保存在s[i]里面吗，他返回 i 的话不是只返回了第几行吗？", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "仔细看了下，是我理解错了，懂了，谢谢大佬", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "还有printf为啥不加【】啊?这是C语言 字符串基础，longest在这里代表字符串首地址，%s打印算从首地址到结束符的内容。另外longest使用前最好memset,置空。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "我现在还写不出这么简洁的程序，这是C程序语言设计里面的一道例题所以说为啥返回 i 啊，还有printf为啥不加【】啊", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "MAXLINE应设为32767比较保险，因为超过1000太容易了", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "Hi，这不是你自己写的吗？  循环扫描文件时max在记录最长那行的字符数，longest记录最长的行内容。", "referer": "user-0"}]}
{"question": "碰到一个指针方面的问题，求解答。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf(\"*b = %d\\n\", *b);   //9975 printf(\"*b++ = %d\\n\", *b++);    //== *(b++) 中++优先级高于* 但是b++是后计算 所以是 9975 然后指针+1指向未知空间 printf(\"(*b)++ = %d\\n\", (*b)++);  //上一步 *(b++) 已经计算 指向未知空间 乱码 printf(\"*(b++) = %d\\n\", *(b++));   //同上乱码  // printf(\"*b = %d\\n\", *b);   //9975     // printf(\"*b++ = %d\\n\", *b++);    //== *(b++) ++优先级高于* 但是b++是后计算 所以是 9975     printf(\"(*b)++ = %d\\n\", (*b)++);  //9975 *b先输出9975 然后 *b = 9976     printf(\"*(b++) = %d\\n\", *(b++));   //9976  *b指向值为9976", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢解答", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "printf(\"*b = %d\\n\", *b);// *b = 取值 9975     printf(\"*b++ = %d\\n\",*b++);//先取值：*b = 9975 ,再b地址加1, b++,这条执行完 b就不指向a了      printf(\"(*b)++ = %d\\n\", (*b)++);//取值*b , 然后值加 1 ，b 已经不指向a 了，所以就是一个乱值     printf(\"*(b++) = %d\\n\", *(b++));//这里和上一条相同，看不懂的一个值", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢解答。", "referer": "user-2"}]}
{"question": "Creating new notebook in Bad file descriptor (bundled\\zeromq\\src\\epoll.cpp:100)创建文件错误问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请问你现在输入jupyter notebook能直接跳转到网页吗", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请问你现在解决了吗？我也遇到了这个问题", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "解决了，原来是我的C盘用户名设置成中文导致的，改成英文就好了", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "请问如何更改？急", "referer": "user-0"}]}
{"question": "求助 为什么突然出现断点了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "realloc后还应assert(p1);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "The  realloc()  function changes the size of the memory block pointed to by ptr to size bytes.  The contents will be unchanged in the range from the start of the region up to the minimum of the old and new sizes.  If the new size is larger than the old size, the added memory will not be  initialized.   If ptr is NULL, then the call is equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call is equivalent to free(ptr).  Unless ptr is NULL, it must have been returned by an earlier call to malloc(), calloc(),  or  realloc().   If  the area pointed to was moved, a free(ptr) is done.The  realloc()  function  returns a pointer to the newly allocated memory, which is suitably aligned for any built-in type and may be different from ptr, or NULL if the request fails.  If size was equal to 0, either NULL or a pointer suitable to be passed to  free()  is  returned.   If  realloc()  fails, the original block is left untouched; it is not freed or moved. realloc 之后，你应该free的是 p1，而不是 p 了", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "太感谢了", "referer": "user-2"}]}
{"question": "求助，找子序列的算法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//用C语言实现：给定SJPDMFLJDDMFLJPDMFJNDMKL序列。查找JPDMFL（六个字符中最多只能有一个不同） #include <stdio.h> #include <string.h> int main() {     char *s=\"SJPDMFLJDDMFLJPDMFJNDMKL\";     char *f=\"JPDMFL\";     int L=strlen(s);     int M=strlen(f);     int i;     int j;     int c;      printf(\"%s\\n\",s);     for (i=0;i<L-M;i++) {         c=0;         for (j=0;j<M;j++) {             if (f[j]==s[i+j]) c++;         }         if (c>=M-1) {             for (j=0;j<i;j++) printf(\" \");             printf(\"%s\\n\",f);         }     }     return 0; } //SJPDMFLJDDMFLJPDMFJNDMKL // JPDMFL //       JPDMFL //             JPDMFL //", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢大佬，一下就懂了", "referer": "user-1"}]}
{"question": "c语言国家二级练习题库", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "国家二级c语言真题练习 (^_^)", "referer": "user-0"}]}
{"question": "小白求解.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为编译器不知道你前面有strstr(buf, flag) != NULL的判断，怕运行出错，所以给出了警告，既然你前面已经有了判断，就可以忽略这个警告了如果有强迫症，可以按楼上的改一下", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "改成这样试试：     char* s;     if ((s=strstr(buf, flag)) != NULL) {          fputs(s, out);      }", "referer": "user-0"}]}
{"question": "Docker 服务之间是如何通信的呢？指定服务端口的背后隐藏了哪些秘密？带你揭秘 Docker 网络的神秘面纱！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "ss", "referer": "user-0"}]}
{"question": "自定义函数指针传参，数值传参", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "看了半天终于发现错误，定义时 /** 将串str中的oldStr替换成newStr */ Status Replace_HeapString(Hstring * str, Hstring oldStr, Hstring newStr);  而调用时 Replace_HeapString(str1, &str5, &str4);  调用错误，改成Replace_HeapString(str1, str5,str4)即可，原定义的参数2和参数3要求的是传入Hstring类型的值，而我错误的传入了它们的地址，该死", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#pragma comment(linker,\"/SECTION:.rdata,RW\") //加这句可以让常量区可写，后果自负！ #include <stdio.h> #include <malloc.h> #include <string.h> enum Status {OK,ERROR}; /** 串的堆式顺序存储结构（heap）*/ typedef struct hstring {     char * ch;     int length; }Hstring; int Index_HeapString(Hstring *str,Hstring *findstr,int start) {     int i;     for (i=start-1;i<str->length - findstr->length;i++) {         if (0==strncmp(str->ch+i,findstr->ch,findstr->length)) return i+1;     }     return 0; } /** 将串str中的oldStr替换成newStr */ Status Replace_HeapString(Hstring * str, Hstring oldStr, Hstring newStr) {     int i,index;     if(!str || oldStr.length!=newStr.length)         return ERROR;     index = Index_HeapString(str, &oldStr, 1);     if(index && index <= str->length)     {         for(i = 0; i < newStr.length; i++)         {             str->ch[index - 1 + i] = newStr.ch[i];         }         return OK;     }     return ERROR; } void StrAssign(Hstring *str,const char *val) {     str->ch=(char *)val;     str->length=strlen(val); } void PrintString(Hstring *str) {     printf(\"%.*s\\n\",str->length,str->ch); } int main() {     Hstring * str1 = NULL;     Hstring str4;     Hstring str5;     str1 = (Hstring*)malloc(sizeof(Hstring));     //为str1赋值     StrAssign(str1, \"helloword\");     //为str4赋值     StrAssign(&str4, \"eee\");     //为str5赋值     StrAssign(&str5, \"llo\");     //将串str1中的\"llo\"替换成\"eee\"     Replace_HeapString(str1, str5, str4);     PrintString(str1); //heeeeword     free(str1);     return 0; }", "referer": "user-0"}]}
{"question": "求大神帮我看下printf函数有什么问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要迷信书、考题、老师、回帖；要迷信CPU、编译器、调试器、运行结果。并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：C语言中，char 和 int 的区别？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "char型取值范围-128~127", "referer": "user-0"}]}
{"question": "求大神帮我看下scanf函数有什么问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Aa回车", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：scanf （计算机语言函数）", "referer": "user-0"}]}
{"question": "一个严肃的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要老是加夜班，长发短发都无所谓", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "脱发不都是肾的错,脾胃不好也会脱发,用白纸贴头上看看是否有很多油可判断.", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "我自觉出去", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "短发，天天洗头，保证有效果", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "多吃枸杞少熬夜", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "南辕北辙？舍本逐末？舍弃自家宝贝不用，怨天尤人何益！发为血之余。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "何为自家宝贝", "referer": "user-2"}, {"cid": "8", "user": "user-2", "content": "自家宝贝分2说，1为中华瑰宝中医中药2为自身五脏六腑健康，可笑的是有些论调程序员要打字飞快才算是程序员？未知打字打得飞快能产生几何效益？以至于挖空心思加班加点损伤血气，不知劳逸结合及顾护身心健康，受尽苦难皆属咎由自取。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "说实在的，不喜欢严肃，更喜欢严谨，因为中医就是以配伍严谨为特色从慈悲情怀，所谓医者父母心。", "referer": "user-2"}, {"cid": "10", "user": "user-6", "content": "半秃的长发，参考banana大师～～～", "referer": "user-0"}, {"cid": "11", "user": "user-7", "content": "作为程序猿，想必数学都不错，那么就好说了，每个抽样行为都是独立的，整体的概率对于个体的预测其实并没有什么用。脱了就是脱了，不脱就是不脱。就像彩票一样。", "referer": "user-0"}]}
{"question": "蓝桥杯汉诺塔问题 求大佬帮忙看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "汉诺塔问题为什么不用递归程序做呢。 #include <stdio.h>  void move(int n, char src, char tmp, char dst){     if(n == 1){         printf(\"%c -> %c\\r\\n\", src, dst);         return;     }else{         move(n-1,src,dst,tmp);         move(1,src,tmp,dst);         move(n-1,tmp,src,dst);     } }  int main(){          int n = 6;     char src = 'a', tmp = 'b', dst = 'c';          move(n,src,tmp,dst);          return 0; }", "referer": "user-0"}]}
{"question": "请问各位大佬代码的{}怎么写？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "节省空间应该是指减少行数，不是文件大小，因为早期的显示器分辨率低，每屏只能显示25行甚至十几行，所以才有了K&R风格这种无奈的选择", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "只在C系语言中看到过后一种。目前大多数语言（包括C语言在linux下的主流）格式化工具使用的是第一种。感觉没什么差别。不过部分特殊的编译器可能不认可某一种格式。比如CCS中只有一行的函数会报错，改成第二种写法就没问题，不是bug就是执念。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "为了节省空间大可不必，像JS这种需要下载源码到本地运行的脚本语言才需要压缩空间，这种一般都在写好之后把所有代码压缩成一行。", "referer": "user-2"}, {"cid": "4", "user": "user-0", "content": "嗯嗯", "referer": "user-2"}, {"cid": "5", "user": "user-3", "content": "参考下面自成一派的风格，供大家吐槽和膜拜： //定义下面5种运算顺序： // ((A @   B) @  C)  @ D  = //  (A @   B) @ (C   @ D) = //  (A @  (B  @  C)) @ D  = //   A @ ((B  @  C)  @ D) = //   A @  (B  @ (C   @ D))= //23.99<计算结果<24.01 //其中： //1≤A、B、C、D≤13 //@为“+、-、*、/”之一 //用浮点数计算，循环遍历以上所有情况即可。 #include <stdio.h> #define when break;case int A,B,C,D,N; float r,r1,r2; char op1,op2,op3; char opc[4]={'+','-','*','/'}; void main() {     N=0;     for (A  =1;A  <=13;A  ++) {     for (B  =1;B  <=13;B  ++) {     for (C  =1;C  <=13;C  ++) {     for (D  =1;D  <=13;D  ++) {     for (op1=0;op1<  4;op1++) {     for (op2=0;op2<  4;op2++) {     for (op3=0;op3<  4;op3++) {         // ((A @   B) @  C)  @ D         r=(float)A;         switch (op1) {case 0:r =r +B ;when 1:r =r -B ;when 2:r =r *B ;when 3:                                      r =r /B ;break;}         switch (op2) {case 0:r =r +C ;when 1:r =r -C ;when 2:r =r *C ;when 3:                                      r =r /C ;break;}         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         if (23.99f<r && r<24.01f) {N++;printf(\"%5d: ((%2d %c   %2d) %c  %2d)  %c %2d  =24\\n\",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //  (A @   B) @ (C   @ D)         r1=(float)A;         switch (op1) {case 0:r1=r1+B ;when 1:r1=r1-B ;when 2:r1=r1*B ;when 3:                                      r1=r1/B ;break;}         r2=(float)C;         switch (op3) {case 0:r2=r2+D ;when 1:r2=r2-D ;when 2:r2=r2*D ;when 3:                                      r2=r2/D ;break;}         switch (op2) {case 0:r =r1+r2;when 1:r =r1-r2;when 2:r =r1*r2;when 3:if (-0.01f<r2 && r2<0.01f) goto STEP3;r =r1/r2;break;}         if (23.99f<r && r<24.01f) {N++;printf(\"%5d:  (%2d %c   %2d) %c (%2d   %c %2d) =24\\n\",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //  (A @  (B  @  C)) @ D     STEP3:         r=(float)B;         switch (op2) {case 0:r =r +C ;when 1:r =r -C ;when 2:r =r *C ;when 3:                                      r =r /C ;break;}         switch (op1) {case 0:r =A +r ;when 1:r =A -r ;when 2:r =A *r ;when 3:if (-0.01f<r  && r <0.01f) goto STEP4;r =A /r ;break;}         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         if (23.99f<r && r<24.01f) {N++;printf(\"%5d:  (%2d %c  (%2d  %c  %2d)) %c %2d  =24\\n\",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //   A @ ((B  @  C)  @ D)     STEP4:         r=(float)B;         switch (op2) {case 0:r =r +C ;when 1:r =r -C ;when 2:r =r *C ;when 3:                                      r =r /C ;break;}         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         switch (op1) {case 0:r =A +r ;when 1:r =A -r ;when 2:r =A *r ;when 3:if (-0.01f<r  && r <0.01f) goto STEP5;r =A /r ;break;}         if (23.99f<r && r<24.01f) {N++;printf(\"%5d:   %2d %c ((%2d  %c  %2d)  %c %2d) =24\\n\",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //   A @  (B  @ (C   @ D))     STEP5:         r=(float)C;         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         switch (op2) {case 0:r =B +r ;when 1:r =B -r ;when 2:r =B *r ;when 3:if (-0.01f<r  && r <0.01f) continue  ;r =B /r ;break;}         switch (op1) {case 0:r =A +r ;when 1:r =A -r ;when 2:r =A *r ;when 3:if (-0.01f<r  && r <0.01f) continue  ;r =A /r ;break;}         if (23.99f<r && r<24.01f) {N++;printf(\"%5d:   %2d %c  (%2d  %c (%2d   %c %2d))=24\\n\",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}     }//op3     }//op2     }//op1     }//D     }//C     }//B     }//A } //运行结果： //    1: (( 1 +    1) +   1)  *  8  =24 //    2:  ( 1 +  ( 1  +   1)) *  8  =24 //    3:  ( 1 +    1) * ( 1   + 11) =24 // ... ... //53280:  (13 +   13) / (13   / 12) =24 //53281:  (13 -  (13  /  13)) + 12  =24 //53282:   13 - ((13  /  13)  - 12) =24", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "老湿的新作", "referer": "user-3"}, {"cid": "7", "user": "user-3", "content": "不是新作，是老作品，但开了点新花。原帖在这里：https://bbs.csdn.net/topics/380157851?spm=1001.2014.3001.6377", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "难怪这么眼熟，原来的帖子又看得到了，不错", "referer": "user-3"}, {"cid": "9", "user": "user-1", "content": "K&R风格是历史遗留，目前来说属于垃圾～～～", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "去查了一下，原来还有k&r和ms这么一回事~~~", "referer": "user-1"}, {"cid": "11", "user": "user-3", "content": "比用什么风格更重要的是在任何地方，任何时候都坚持用一种风格。比爱哪种美眉更重要的是在任何地方，任何时候都坚持爱一个美眉。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "不愧是老湿", "referer": "user-3"}, {"cid": "13", "user": "user-4", "content": "这个不用问大佬，你试一下就知道了", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "以前习惯换行，现在发现另一种节省空间，代码会短很多，现在正在转变", "referer": "user-4"}, {"cid": "15", "user": "user-4", "content": "节省的只是表面的空间，对整个代码内存方面没有任何影响，其实这个主要还是取决于你以后工作的地方他的标准，没工作之前你觉得哪个方便就用哪个就是了", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "这两种你喜欢哪个就用哪个。编译器把源代码也是当作字符流的，并不以行为单位理解源代码。", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "嗯嗯", "referer": "user-5"}]}
{"question": "取结构体中数组中的数值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "什么原因？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的，谢谢您，已经找到相关资料啦", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "敢为题主解决了吗", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "可以搜索一下总线错误或者对齐错误，学习一下。字数较多，就不贴了。", "referer": "user-0"}]}
{"question": "根据输入的二叉树后序序列（以单个字符作为一个结点的信息）和中序序列，来构造一棵二叉树，然后输出该树的前序序列，以及该树中所有度为1的结点。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*T)->data = data;         //生成根结点         CreateBiTree(&(*T)->lchild);//构造左子树         CreateBiTree(&(*T)->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf(\"%c \",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf(\"%c \",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(&T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "这不是根据先序和中序找后序吗", "referer": "user-1"}]}
{"question": "有人愿意做Linux嵌入式系统下C/C++的兼职开发吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "均已私信联系~顺便补充一下，我们研发团队坐标北京。希望开发者前期有时间到北京交流，并且有些项目需要在北京常驻1-2月~", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "怎么联系？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "拿来吧你", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "怎么联系？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "已私信", "referer": "user-3"}]}
{"question": "pta 乙级1025 小白求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数组长度最大值#define maxsize 100000超限了。", "referer": "user-0"}]}
{"question": "Socket错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "服务器端没有bind 地址信息，也listen端口，设置监听队列，客户端如何connect服务器？ Linux C for TCP服务器参考     int listenfd = socket(AF_INET, SOCK_STREAM, 0);      struct sockaddr_in sin;     bzero(&sin, sizeof(sin));     sin.sin_family = AF_INET;     sin.sin_addr.s_addr = INADDR_ANY; /* 本地所有IP地址 */     sin.sin_port = htons(port);      if (bind(listenfd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {         perror(\"bind error\");         exit(1);     }      if (listen(listenfd, 10) < 0) {         perror(\"listen error\");         exit(1);     }  while (1) {   struct sockaddr_in cliaddr;   socklen_t clilen = sizeof(cliaddr);   int connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen); ... }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "SOCKADDR_IN clientAddr  改为 struct sockaddr_in clientAddr;", "referer": "user-0"}]}
{"question": "使用socket作为图片服务器，直接在HTML中显示图片，该如何操作呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "按字节拷贝，灵活使用指针", "referer": "user-0"}]}
{"question": "大佬们 c语言单行文本输入咋搞啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "链接标题谢谢啊  不过可以有可视化的文本输入框 就类似于qt那种控件吗？ 谢谢大佬们", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <string.h> int main() {   char ln[1024];   fgets(ln,1024,stdin);   if (ln[strlen(ln)-1]=='\\n') ln[strlen(ln)-1]=0;   printf(\"[%s]\\n\",ln);   return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "char a[1024];    gets_s(a,1024);    puts(a);", "referer": "user-0"}]}
{"question": "有没有大佬有C语言的练习题，跪求！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "有不少刷题网站什么PTA计蒜客一大堆高级一点的leetcode牛客", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C语言教程（附带C语言100例）▼", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "在本网站下载里搜  C语言的练习题  啊", "referer": "user-0"}]}
{"question": "scanf混合输入问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "原来你month输入的是三个英文字母的缩写JAN,FEB,MAR,...，我原以为是01,02,03,... 那你改成 char month[4]; ...-%3[^-]-... 另外，scanf是给char[]用的，cin是给string用的。你要想用scanf输入string,可以先输入到char[],再将char[]转换为string", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "老师你太强了，等于说用scanf的话必须先规定长度，太猛了老师", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "我还有个问题就是，数组长度为啥要有4位", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "要留末尾0的存储空间", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "供参考： #include<iostream> #include<map> #include<string> using namespace std;  int main() {     int    year=0,day=0;     string month(11,0);//string类的构造函数     scanf(\"%d-%[^-]-%d\",&year,month,&day);     cout<<year<<endl;     cout<<month<<endl;     cout<<day<<endl;     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "试了一下，这样布星啊哥哥", "referer": "user-2"}, {"cid": "7", "user": "user-1", "content": "char month[3]; scanf(\"%d-%2[^-]-%d\",...", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "谢谢老师！我尝试了可以，但是想用string可以吗？", "referer": "user-1"}, {"cid": "9", "user": "user-0", "content": "而且%2会漏掉一个字符，如果去掉2的话会多一个框框，老师这是咋回事", "referer": "user-1"}, {"cid": "10", "user": "user-3", "content": "scanf(\"%d-%[^-]-%d\", &year, month, &day);   试试这样，month是string类型，本身就是地址了，因此不需要再加&了。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "我试了一下，这样布星，同学", "referer": "user-3"}]}
{"question": "求求大神帮我看下3个数比大小有什么问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考： #include<stdio.h> int main() {     int a,b,c;     void sort(int *x,int *y,int *z);     printf(\"Please enter three numbers:\\n\");     scanf(\"%d%d%d\",&a,&b,&c);     sort(&a,&b,&c);     printf(\"%d %d %d\\n\",a,b,c);     return 0; }  void sort(int *x,int *y,int *z) { int temp;     if(*x<*y)     {     temp=*x;     *x=*y;     *y=temp;     }     if(*x<*z)     {     temp=*x;     *x=*z;     *z=temp;     }     if(*y<*z)     {     temp=*y;     *y=*z;     *z=temp;     } }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "请问我的错在哪儿？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "sort()函数里，交换位置，不能是对值的操作，对值的操作作用范围就在函数体内，函数运行结束返回主函数后，a b c 的值并没有被改变。必须是对地址的操作才能起作用。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "好的，谢谢大神！", "referer": "user-1"}]}
{"question": "怎么在cmake的配置文件里加入-ldl编译选项", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://blog.csdn.net/harryhare/article/details/89143410", "referer": "user-0"}]}
{"question": "今天尝鲜CLion 2021.2 ，结果。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "改成c++的cout试试？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "不会C++，刚接触C，小白一枚", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "原因：printf使用了缓存buffer 解决方案： fflush(stdout);：强制刷新（建议）setbuf(stdout, NULL);：禁用缓存（不建议）", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "有其他解决办法吗？每次加一行代码好麻烦啊", "referer": "user-0"}]}
{"question": "美团酒店点评如何获取orderID？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "解决了吗", "referer": "user-0"}]}
{"question": "有人愿意做嵌入式软件Linux C的兼职开发吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "有   可以加微信聊 630084664", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "自己顶一下~", "referer": "user-0"}]}
{"question": "嵌入式linux c 协议栈 坐标北京 有兼职的吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "都是紧急的么", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "目前有个紧急的项目 后续项目看情况  需要现场沟通", "referer": "user-1"}]}
{"question": "code blocks 调试器结束，其状态码是1 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你用的codeblocks没有调用栈信息吗？我用codelite，按F5开始调试，如果报错就会有调用栈的错误信息，基本上都能定位到报错的一行，除非很诡异的https://codelite.org/,有黑色主题", "referer": "user-0"}]}
{"question": "C语言编译生成的可执行文件自动退出，怎么排查问题呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该写个日志文件，这样才能通过日志文件查找问题。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用codelite，按F5运行如果报错有调用栈直接定位到报错行，", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "StackWalker", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "自己加尽量详细的日志", "referer": "user-0"}]}
{"question": "C语言编写的可执行文件怎么添加附加信息？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://blog.csdn.net/theArcticOcean/article/details/83041198", "referer": "user-0"}]}
{"question": "C语言中的feturn相关问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "错。return语句的作用是结束当前函数的执行，且当前函数如果有返回值的话，return后面要跟返回值。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的谢谢您，么么哒", "referer": "user-1"}]}
{"question": "利用红外扫描实现循迹的小车，遇到这种情况的直角转弯，该如何编写程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "传感器的前探测距离肯定不会刚好大于与出头的那点黑胶带的长短。增加一个保存转弯点的转向选择的变量，继续按直线前进，没路了再退回来，再根据前面转弯选项转弯，继续探路，只能这样。三岔口、五岔口、多岔口，都只能挨个探索，不行了退回来。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "为什么黑胶带要出头？改为圆角是不是好走一些", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "老师设的卡", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "那就问老师。解铃还须系铃人。", "referer": "user-0"}]}
{"question": "各位大佬大家好,入门小弟有一个不会的程序请大佬,帮忙解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h>int main(){  int sum=0;  for(i=1;i<=100;i++)  {    sum+=i;  }  return 0;}", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h>int main(void){    int n, sum;    sum = 0;    n = 100; while (n> 0) {     sum = sum + n;     n--; } printf(\"1+....+100=%d\", sum);  return 0;  }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "#include<stdio.h>  int main() {     int i,s=0;     for(i=1;i<=100;i++)s+=i;     printf(\"s(1+2+3+4+5+6.......+100)=%d\\n\",s);     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "学习的书上没代码例子？int a=0,aa=1;while(aa<=100)a+=aa++;std::cout<<a<<std::endl;", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "printf(5050);", "referer": "user-0"}]}
{"question": "C语言printf打印指针地址疑惑-运行环境win10 64位系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "实际中一般不这么搞，你只要知道这种情况和具体的编译器有关即可。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "关于C,C++表达式求值顺序(转)关于C,C++表达式求值顺序", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不同的编译器，不同的结果。 (int *)p + 1  强制类型转换了。", "referer": "user-0"}]}
{"question": "pta的一道题，有点不明白，最后一个测试点发生浮点错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个题目是什么？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "一个可能是在特定平台上的测试用例中，累成溢出，但是每一步进行公约后可以保证中间结果没有溢出", "referer": "user-0"}]}
{"question": "MacOS平台中，获取执行文件目录路径错误，该如何正确获取路径呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "char path[256] = { 0 }; getcwd(path, sizeof(path)); strcat(path  , \"/a.txt\");", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "a.txt改成./a.txt 看看", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "试过了，不行", "referer": "user-2"}]}
{"question": "相同的数据，Int 强转 Byte 竟然出现了不同的结果！这背后到底隐藏了什么秘密 —— 数据大小端存储》, 一起来围观吧 https://blog.csdn.net/qq_34417408/article/details/118877959?utm_so", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "原来是付费专栏的广告。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "付费？不存在的", "referer": "user-1"}]}
{"question": "（已解决）ReadDirectoryChangesW 监听目录 丢失消息的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "试试每秒创建、拷贝或删除100个文件", "referer": "user-0"}]}
{"question": "将该文件代码改成 任意两个高次多项式的相加与相减", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C++实现任意次元的多项式加法，以及输入输出重载，以及内存管理。Polynominal.h // // Created by Alone on 2021/9/23. //  #ifndef UNTITLED46_POLYNOMINAL_H #define UNTITLED46_POLYNOMINAL_H #include <iostream> //@Node结构体--作为表达式存储的对象 struct Node {     double factor;     int exp;     Node *next;      Node(double x, int y, Node *p = nullptr) : factor(x), exp(y), next(p) {}     //静态方法方便调用     static void swap(Node *a, Node *b) {//仅仅交换数据，不交换指针         std::swap(a->factor, b->factor);         std::swap(a->exp, b->exp);     } }; //@Polynominal类声明 class Polynominal {     Node *head;      friend std::istream &operator>>(std::istream &in, Polynominal &a);      friend std::ostream &operator<<(std::ostream &out, Polynominal &a);      friend std::ostream &handle_one(std::ostream &out, Node &node);  public:     Polynominal &operator+(Polynominal &b);      void Insert(double x, int y);      Polynominal() { //缺省构造         head = new Node(0, -1);//构建一个结点作为头结点，方便头插     }      Polynominal(double x, int y);//带参构造      ~Polynominal(); };  #endif //UNTITLED46_POLYNOMINAL_H  Polynominal.cpp // // Created by Alone on 2021/9/23. //  #include \"Polynominal.h\" //@Polynominal类定义 //@关键的Insert函数实现 void Polynominal::Insert(double x, int y) {     Node *t = new Node(x, y);     t->next = head->next; //头插法插入     head->next = t;     Node *pre = head;     while (t != nullptr && t->next != nullptr) {//进行偷天换日，把指数大的放在前面         if (t->exp < t->next->exp) {//指数大的放在前面             Node::swap(t, t->next);         } else if (t->exp == t->next->exp) {//指数相等时直接加和得到一个表达式             Node *tmp = t->next;             tmp->factor += t->factor; //相等时，只加上系数即可             delete t;             pre->next = tmp;             t = pre;             break;//这种直接找到相等的就处理完了         } else {             break;//如果比它大位置就已经是正确的了         }         pre = t;         t = t->next;     } } Polynominal::Polynominal(double x, int y) {     head = new Node(0, -1);//构建一个结点作为头结点，方便头插     Insert(x, y); } //@重载'+'运算符：利用Insert成员函数实现两个Polynominal类的相加 Polynominal &Polynominal::operator+(Polynominal &b) {     Node *t2 = b.head->next;     while (t2 != nullptr) {         Insert(t2->factor, t2->exp);         t2 = t2->next;     }     return *this; } //@输入操作重载 std::istream &operator>>(std::istream &in, Polynominal &a) {     double x;     int y;     while (1) {         std::cout << \"input a term(coef[double],exp[int]):->Until the end of the input 0 to coef\" << std::endl;         in >> x >> y;         if (x == 0)             break;         a.Insert(x, y);     }     std::cout << \"The polynomial is established successfully!\" << std::endl;     return in; } //@输出操作重载 // --直接重载前，先写一个单个式子处理函数，方便后面处理中间的符号 std::ostream &handle_one(std::ostream &out, Node &node) {     out << node.factor;     switch (node.exp) { //根据指数的不同情况进行打印         case 0:             break;         case 1:             out << \"X\";             break;         default:             out << \"X^\" << node.exp;             break;     }     return out; }  std::ostream &operator<<(std::ostream &out, Polynominal &a) {     out << \"the polynominal is: \";     Node *t = a.head->next;     if (t == nullptr)         return out << \"null\";     handle_one(out, *t);     t = t->next;     while (t != nullptr) {         out << \"+\";         handle_one(out, *t);         t = t->next;     }     out << '\\n';     return out; } //@对链表内存的析构 Polynominal::~Polynominal() {     Node *t = head;     while (t != nullptr) {         Node *cur = t;         t = t->next;         delete cur;     } }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "看看Insert函数的实现就行，减法和加法是一样的，乘法和除法需要作出较大的改变", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "仅供参考： //链表实现一元多项式的加法减法乘法 #include <stdio.h> #include <stdlib.h> typedef struct node {     float coef;   //系数     int expn;     //指数     struct node *next; } PolyNode;      //多项式节点 polynomial node typedef PolyNode* Polynomial; Polynomial createPolynomial() {  //创建多项式     PolyNode *p, *q, *head = (PolyNode *)malloc(sizeof(PolyNode));   //头节点     head->next = NULL;     float coef;     int expn;     printf(\"输入该多项式每一项的系数和指数，每项一行，输入0 0结束！\\n\");     while (scanf(\"%f %d\", &coef, &expn) && coef) {   // 默认，按指数递减排列         if (head->next) {             p = head;             while (p->next && expn < p->next->expn)                 p = p->next;             if (p->next) {                 if (expn == p->next->expn) { //有相同指数的直接把系数加到原多项式                     p->next->coef += coef;                     if (p->next->coef > -0.000001 && p->next->coef < 0.000001) { //若是相加后系数为0，则舍弃该节点                         q = p->next;                         p->next = q->next;                         free(q);                     }                 } else {                     q = (PolyNode*)malloc(sizeof(PolyNode));                     q->coef = coef;                     q->expn = expn;                     q->next = p->next;                     p->next = q;                 }             } else {                 p->next = (PolyNode*)malloc(sizeof(PolyNode));                 p = p->next;                 p->coef = coef;                 p->expn = expn;                 p->next = NULL;             }         } else {             head->next = (PolyNode*)malloc(sizeof(PolyNode));             head->next->coef = coef;             head->next->expn = expn;             head->next->next = NULL;         }     }     return head; } Polynomial multiply(Polynomial poly, float coef, int expn) {  //多项式与指定单项式相乘，该单项式为 coefx^expn     PolyNode *p, *q, *Poly = (PolyNode*)malloc(sizeof(PolyNode));     p = Poly;     q = poly->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = (q->coef*coef);         p->expn = (q->expn + expn);         q = q->next;     }     p->next = NULL;     return Poly; } void add(Polynomial poly1, Polynomial poly2) {  //把 poly2 加到 poly1 上     PolyNode *p, *q, *r;     r = poly1;     p = poly1->next;  //指向第一个节点     q = poly2->next;     poly2->next = NULL;     while (p && q) {         if (p->expn > q->expn) {             r->next = p;             p = p->next;             r = r->next;         } else if (p->expn < q->expn) {             r->next = q;             q = q->next;             r = r->next;         } else {             PolyNode *t;             p->coef += q->coef;             if (!(p->coef > -0.000001 && p->coef < 0.000001)) //系数不为0             {                 r->next = p;                 r = r->next;                 p = p->next;             } else {                 t = p;                 p = p->next;                 free(t);             }             t = q;             q = q->next;             free(t);         }     }     if (p)         r->next = p;     if (q)         r->next = q; } Polynomial polySubtract(Polynomial poly1, Polynomial poly2) {  //多项式减法 poly1-poly2形成一个新的多项式     //把poly2的系数取相反数，形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode)); //构造头节点     PolyNode *p, *q;     p = poly;     q = poly2->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = -(q->coef);  //系数取反         p->expn = q->expn;         q = q->next;     }     p->next = NULL;     add(poly, poly1);  //利用加法     return poly; } Polynomial polyAdd(Polynomial poly1, Polynomial poly2) { //多项式相加 poly1+poly2形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //和多项式的头节点     poly->next = NULL;     PolyNode *p, *q, *r;     r = poly;     p = poly1->next;     q = poly2->next;     while (p&&q) {         if (p->expn > q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = p->coef;             r->expn = p->expn;             p = p->next;         } else if (p->expn < q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = q->coef;             r->expn = q->expn;             q = q->next;         } else {             float m = p->coef + q->coef;             if (!(m > -0.000001 && m < 0.000001)) {                 r->next = (PolyNode*)malloc(sizeof(PolyNode));                 r = r->next;                 r->coef = m;                 r->expn = p->expn;             }             q = q->next;             p = p->next;         }     }     while (p) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = p->coef;         r->expn = p->expn;         p = p->next;     }     while (q) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = q->coef;         r->expn = q->expn;         q = q->next;     }     r->next = NULL;     return poly; } Polynomial polyMultiply(Polynomial poly1, Polynomial poly2) {  //多项式相乘     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //创建多项式和的头节点     poly->next = NULL;     PolyNode *p;     p = poly2->next;     while (p) {         add(poly, multiply(poly1, p->coef, p->expn));         p = p->next;     }     return poly; } void printPoly(Polynomial poly) {  //打印多项式     if (poly && poly->next) {         PolyNode *p = poly->next;  //p指向第一个节点         while (p->next) {             printf(\"%gx^%d\", p->coef, p->expn);             p = p->next;             if (p && (p->coef > 0))                 printf(\"+\");         }         if (p->expn == 0)             printf(\"%g\", p->coef);   //打印常数项         else             printf(\"%gx^%d\", p->coef, p->expn);         printf(\"\\n\");     } else {         printf(\"0\\n\");     } } void freePoly(Polynomial poly) {  //释放内存     if (poly && poly->next) {         PolyNode *p, *q;         p = poly;         while (p) {             q = p->next;             free(p);             p = q;         }     }     poly = NULL; } int main() {     printf(\"用链表实现多项式的加减法\\n\");     Polynomial poly1, poly2, poly3;     printf(\"创建多项式一\\n\");     poly1 = createPolynomial();     printf(\"多项式一：\\n\");     printPoly(poly1);     printf(\"创建多项式二\\n\");     poly2 = createPolynomial();     printf(\"多项式二：\\n\");     printPoly(poly2);     printf(\"两多项式相加，和为：\\n\");     poly3 = polyAdd(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf(\"两个多项式相乘，积为：\\n\");     poly3 = polyMultiply(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf(\"两多项式相减，差为：\\n\");     poly3 = polySubtract(poly1, poly2);     printPoly(poly3);     freePoly(poly1);     freePoly(poly2);     freePoly(poly3);     system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": "C语言编写的程序，编译生成的可执行程序无法双击运行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "在CentOS平台中，可使用desktop文件实现双击执行", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "https://blog.csdn.net/weixin_34160277/article/details/94180772", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "一般都是从控制台启动", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "我都是点右键，选运行", "referer": "user-0"}]}
{"question": "settimeofday 在ubuntu20.04系统中执行总是返回失败，错误码无效的参数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "需要root权限？", "referer": "user-0"}]}
{"question": "DEV C++下古怪的二维堆数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "再次对这个问题进行研究,发现是我理解错误.语句:TYPE (Array)[x]=(TYPE ()[Array[x]])malloc(y*z);可以正常使用.语句中的x值是二维数组的第二个下标,而我理解成了第一个下标了.惭愧!", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "TYPE为unsigned char,z为1", "referer": "user-0"}]}
{"question": "C Primer 第十章 图10.4关于指针递增的图，那地址位数是不是错了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "图的右侧明确了指针ptr1占用0c00  0c01共2个地址，所以它是个2字节指针。鉴定完毕。 但指针本身占几个字节和指针目标占几个字节确实不相关。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "但原书上明确说了这是一个int数组", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "关注一下作者写这个的年代，若是1995年以前提起int大概率都是2字节的。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "ptr1虽然是个占用了4字节空间的指针，但*ptr1存储的数据不见得是4字节数据，可能只是2字节short数据，亦可能是8字节double数据。ptr1++之后的ptr1值视其所指向空间的数据类型而定。若是ptr1是short *类型，那么ptr1++之后，就会是从00dc变为00de。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "不是吧，指向空间的大小在指针定义的时候应该就是确定好的，不可能根据里面的数据类型改变，那还不乱了套了", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "“指向空间的大小在指针定义的时候应该就是确定好的”，这句话是没错的，所以我说“ptr1++之后的ptr1值视其所指向空间的数据类型而定”。但是这不等于说指针本身是4个字节就意味着指针指向的空间也是4字节数据类型。你的问题并没有描述ptr1是哪种类型的指针，如果是short类型，那么指针指向的数据就是只有2字节，所以ptr1++之后的结果是新的ptr1只变化了2字节。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "16进制中，两个字符是一个字节，一个字符的话，是一个字节。 例如：A是一个字节，AA是一个字节，AAA是两个字节，AAAA是两个字节  AAAA AAAA 四字节", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "明白了，这是一种简化的地址表示方法，谢谢！", "referer": "user-3"}]}
{"question": "求帮助，习题7-2 求一批整数中出现最多的个位数字 (20 分)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "用0-9的10个数字数组统计是个好方法，统计方面可参https://ask.csdn.net/questions/912419最后遍历一下数组求最大值，再用最大值输出是那些数即可。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "换种思路，供参考： #include<stdio.h>  int main() {     int  a[10]={0},n,m,i;     scanf(\"%d\",&n);     while(n){             scanf(\"%d\",&m);             while(m){                     a[m%10]++;                     m /= 10;             }             n--;     }     m = a[0];     for(i=0;i<10;i++)         if(m<a[i]) m=a[i];     printf(\"%d:\",m);     for(i=0;i<10;i++)         if(a[i] == m)            printf(\" %d\",i);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "至少你的a数组不够大。", "referer": "user-0"}]}
{"question": "我想问一下程序运行后只输出个0", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个函数有问题： bool initlist(linklist l) {     l=(lnode *)malloc(sizeof(lnode));     if(l==NULL){         return false;     }     l->next=NULL;     return true; }  你的本意是初始化链表头节点，为头节点分配空间，但是C/C++语言函数是传值的，在函数内部对形参赋值并不会改变形参的值，所以l=(lnode *)malloc(sizeof(lnode));这条语句并没有真正影响l的值，而是修改了l在栈中的副本。当你调用bool res = initlist(l);试图初始化l时，l的值其实并未被改变。可以改成这样： bool initlist(linklist *l) {     *l=(lnode *)malloc(sizeof(lnode));     if((*l)==NULL){         return false;     }     (*l)->next=NULL;     return true; }  bool oinitlist(linklist *l) {     *l=NULL;     return true; }  然后：bool res = initlist(&l);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没有问题呀。", "referer": "user-0"}]}
{"question": "怎么打开浏览器，访问指定网页？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "firefoxsafari", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "system是执行命令行的工具，你在命令行怎么敲，在这儿就怎么敲。我的意思是，具体的文件名你不说别人也不知道，你得自己找。", "referer": "user-0"}]}
{"question": "各位大佬们，这是为啥运行不出结果呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "要把自己写的代码当作别人写的代码，然后开始读。这样你才能发挥好挑剔的目光这个天赋----我们都是这么干的。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "嗯嗯", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "问题见注释，供参考： #include<stdio.h> int main() {     int i,j,n,sum=1,all=0;     scanf(\"%d\",&n);     for(i=1;i<=n;i++){//for(i=1;1<n;i++){          sum=1;         for(j=1;j<=i;j++){              sum *= j;         }         all+=sum;     }     printf(\"%d\",all);     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢", "referer": "user-2"}]}
{"question": "编程记不住函数怎么办", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "找一个好的编辑器，有渐进提示的那种。我用的VS就很好用。", "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-0", "content": "那么当你遇到明确需求，不是产品层面的需求，而是代码层面要解决很具体的问题。 举个简单的例子。就是从元素是字符串的二维矩阵中找出匹配的字符串，并返回他在矩阵的坐标。你肯定知道答案。我们假设你不知道答案。你怎么知道是否存在一个函数可以一行代码解决问题？如果存在，怎么找到这样的函数？ 如果你用的是一个比较冷门的语言呢？？？？？？？？？？？？", "referer": "user-3"}, {"cid": "5", "user": "user-3", "content": "所以需要熟，基础语言特性和常用库函数都记住了，你自然就知道要用那个", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "动脑，走心。不要老想着走捷径。难道做厨子就容易了？同样有很多菜谱摆在那需要记住，同样是从点个火都手忙脚乱的状态学起。考驾照也是啊。同样要背科目一啊。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "所以你是怎么记住的？", "referer": "user-4"}, {"cid": "8", "user": "user-5", "content": "记不住有啥，不是有书，有网络吗。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "你用搜索引擎搜索，每次都能立刻找到需要的函数及其使用方法？", "referer": "user-5"}, {"cid": "10", "user": "user-5", "content": "不是吗，搜着搜着，就记住了。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "要是搜索不到呢？", "referer": "user-5"}, {"cid": "12", "user": "user-6", "content": "会百度就行", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "无论是百度还是404搜索引擎。有时你想要实现的功能不一定容易用简短的语言描述。或者搜出的结果与你想要实现的功能并不匹配", "referer": "user-6"}, {"cid": "14", "user": "user-6", "content": "如果很容易就搜出任何问题的确切答案，那人活着还有什么意义？", "referer": "user-0"}]}
{"question": "正在打人生中的第一个C语言代码，求大佬告知哪里错了，为什么vs code显示出红色字体", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个代码每本书上都有，对照一下就是。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> int main() {     printf(\"hellow world.\\n\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "printf 和 return 两条语句后面忘写 ; 分号了", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "感谢大佬，我去改一下", "referer": "user-3"}, {"cid": "6", "user": "user-0", "content": "大佬，我再问一下，我改完之后，他还是失败了，最后，显示：生成已完成，但出现错误，终端进程启动失败（退出代码：-1）    请问这个怎末解决？", "referer": "user-3"}, {"cid": "7", "user": "user-3", "content": "return 0;", "referer": "user-0"}]}
{"question": "求助大佬，思路好像不对，但是又找不出问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果有相同的，记录输出第一次出现的子序列,供参考： #include<stdio.h> #include<string.h>  void findGC(char str[],int n) {     int i,j,a=0,len,max_radio=0,count_radio;     len=strlen(str);     //max_radio=0;     for(i=0;i<len;i+=n)     {         count_radio=0;         for(j=i;j<i+n;j++)         {             if(str[j]=='G'||str[j]=='C')                count_radio++;         }         if(count_radio>max_radio)         {             max_radio=count_radio;             a=i;         }     }     for(i=a;i<a+n;i++)        printf(\"%c\",str[i]); } int main() {     char dna[100]={0};     int n;     printf(\"请输入子序列长度：\\n\");     scanf(\"%d\",&n);     printf(\"请输入序列：\\n\");     getchar();     fgets(dna,sizeof(dna),stdin);     findGC(dna,n);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "正确了，大佬，请问在fgets前面加个getchar(），是什么含义呢？作用是什么？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "吸收输入缓冲区中残留的字符，和赵老师的rewind (stdin); 类似的作用。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "//一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。 //在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。 //给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。 #include<stdio.h> #include<string.h> #define MAXLEN 100 void findGC(char str[],int n) {     int i,j,a,len,max_radio,count_radio;      len=strlen(str);     max_radio=0;     for (i=0;i<len-n;i++) {         count_radio=0;         for (j=i;j<i+n;j++) {             if (str[j]=='G'||str[j]=='C')                count_radio++;         }         if (count_radio>max_radio) {             max_radio=count_radio;         }     }     printf(\"GC-Ratio最高的子序列：\\n\");     for (i=0;i<len-n;i++) {         count_radio=0;         for (j=i;j<i+n;j++) {             if (str[j]=='G'||str[j]=='C')                count_radio++;         }         if (count_radio==max_radio) {             for (j=0;j<i;j++) printf(\" \");             for (j=i;j<i+n;j++) printf(\"%c\",str[j]);             printf(\"\\n\");         }     } } int main() {     char dna[MAXLEN];     int n;      printf(\"请输入子序列长度：\\n\");     scanf(\"%d\",&n);     printf(\"请输入序列：\\n\");     rewind(stdin);     fgets(dna,MAXLEN-1,stdin);     if ('\\n'==dna[strlen(dna)-1]) dna[strlen(dna)-1]=0;     findGC(dna,n);     return 0; } //请输入子序列长度： //4 //请输入序列： //ACGTACGTACGTACGTACGTACGT //GC-Ratio最高的子序列： //ACGT // CGTA //  GTAC //   TACG //    ACGT //     CGTA //      GTAC //       TACG //        ACGT //         CGTA //          GTAC //           TACG //            ACGT //             CGTA //              GTAC //               TACG //                ACGT //                 CGTA //                  GTAC //                   TACG //", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "大佬，我运行后还是输入n的值，程序就直接结束了", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "要么你的回车键坏了，要么你运行的不是我这段代码生成的exe", "referer": "user-0"}]}
{"question": "怎么在U盘重新加载时关闭程序？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "WM_DEVICECHANGE", "referer": "user-0"}]}
{"question": "请问怎么隐藏命令行窗口？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "WinExec(\"xxx.exe\",SW_HIDE);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "WinExec该函数只提供对16位机子的兼容，这个兼容性太差了吧？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "反正我用这个函数从winxp到win10都能用", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "这个只能在Windows平台用。如果是跨平台的，比如Linux、MacOS，那该如何处理呢？", "referer": "user-1"}]}
{"question": "在开发HTTP服务器时，文件读取重复，且有乱码", "poster": "user-0", "comments": [{"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"}]}
{"question": "这个错误怎么解决各位大佬 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "找不到函数sim_at_response的实现", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢老师", "referer": "user-1"}]}
{"question": "帮我的C语言文字游戏提提建议", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "兄弟，C语言做图像太难了QWQ", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "搞个图形界面", "referer": "user-0"}]}
{"question": "用宏定义出现符号错误如何解决？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "能给我个软件吗，我想学C 我的邮箱1225514766qq", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "能给我个软件吗，我想学c", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "Visual C++ 2010 Express简体中文版 http://pan.baidu.com/s/1bnwRVLt", "referer": "user-1"}, {"cid": "4", "user": "user-3", "content": "#define ROW 3#define COL 3最后没有 ';'号", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "嗯嗯，解决了，谢谢。", "referer": "user-3"}]}
{"question": "C/C++测试工具--winAMS", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "可能是", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "看这界面，应该是用C++Builder写的吧", "referer": "user-0"}]}
{"question": "64字节大小的二进制文件在16进制下打开显示2行，怎么显示4行？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "【已解决】将十六进制字符串直接转为uint8_t数组，再写入文件", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "能给我个软件吗，我想学C 我的邮箱1225514766qq", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "可以使用Clion，下载地址：https://www.jetbrains.com/clion/", "referer": "user-1"}, {"cid": "4", "user": "user-2", "content": "typedef unsigned char uint8_t;//确保uint8_t的定义是一个字节 for(...) {   line.data[i] = ret; //请确保i在for循环中每次加1   }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "仅供参考： #include <string.h> FILE *f; char buffer[4096]; int r,a; void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,\"%08x -\",i+addr);             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);             sprintf(binstr,\"%s  \",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf(\"%s\\n\",binstr);         } else {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,\"%s   \",binstr);         }         sprintf(binstr,\"%s  \",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf(\"%s\\n\",binstr);     } } int main(int argc,char **argv) {     if (argc<2) {         fprintf(stderr,\"Usage: %s filename.ext\\n\",argv[0]);         return 2;     }     f=fopen(argv[1],\"rb\");     if (NULL==f) {         fprintf(stderr,\"Can not open file [%s]!\\n\",argv[1]);         return 1;     }     a=0;     while (1) {         r=fread(buffer,1,4096,f);         HexDump(buffer,r,a);         a+=r;         if (r<4096) break;     }     fclose(f);     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "赵老师，我现在的问题是写入文件格式错误，格式应该是 01 02 03 04..., 但实际写入是 01 00 02 00 03 00 04 00...  ，这该如何解决呢？  写入的核心代码是： strncpy(binarys, line+i, 2);//读取十六进制  binarys[2] = '\\0';   uint8_t  ret = convert(binarys);//十六进制转uint8_t  dataLine1.data[i] = ret;  难道是这行代码：  binarys[2] = '\\0';  造成的吗？", "referer": "user-2"}, {"cid": "7", "user": "user-3", "content": "二进制文件本身没有行的概念。二进制文件是个字节流，您喜欢怎么显示就写代码把它摆成什么姿势好了。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "我现在遇到的问题是：同样大小的文件（64字节），使用编辑器在十六进制下，别人的显示是4行，我的显示是两行，导致我保存的文件，别人无法解析。我想知道的是这个该怎么解决呢？写入文件时，该怎么转换？", "referer": "user-3"}, {"cid": "9", "user": "user-3", "content": "我对猜测其实没有兴趣。 话又说回来了，我首先猜测的是因为您的显示器比别人的大。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "我使用WinHex打开，应该是01 02 03 04....这种格式的，但是实际结果是01 00 02 00 03 00 04 00...", "referer": "user-3"}]}
{"question": "BMP转RGB565", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考opencv\\3rdparty\\libjpeg-turbo\\src\\jdcol565.c中的rgb_rgb565_convert_internal函数", "referer": "user-0"}]}
{"question": "为什么定义了一个指针，printf就不输出了？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "p = new Node;   指针只有在new()之后才向系统申请内存，在内存中这时才存在struct Node结构体的东西，因为你没new()指针，这时指针（32位或64位)指向的是一个随机的野地址。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Node* p = new Node;.....这种才是王道", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "Node p;p.date = 3;printf(\"%d\\n\",p.date);是date还是data？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "p没有申请内存，其初值是内存中栈区原来的垃圾随机值，然后你给其date字段赋值3，就会往这个垃圾随机值对应的地址处写3，操作系统发现了这种非法行为，中断当前程序的执行。", "referer": "user-0"}]}
{"question": "使用C语言如何解析GET（或POST）报文", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考libcurl", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "链路层网络层传输层的解析可以玩struct，但是到了http这里就玩不转了。该玩正则表达式了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "仅供参考： #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else                     return string; } void main() {     strcpy(string,\"A \\tstring\\t\\tof ,,tokens\\n\\nand some  more tokens, \");     strcpy(seps1,\",\\n\");strcpy(seps2,\" \\t\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234| LIYI|China | 010 |201110260000|OK\");     strcpy(seps1,\"|\");strcpy(seps2,\" \");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234|LIYI||010|201110260000|OK\");     strcpy(seps1,\"\");strcpy(seps2,\"|\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234|LIYI||010|201110260000|OK\");     strcpy(seps1,\"|\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",a\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",a,,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,a,,b,,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,,\");     strcpy(seps1,\",\");strcpy(seps2,\" \");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     } } // //[A      string          of ,,tokens // //and some  more tokens, ] //Tokens: // <A> <string> <of> <> <tokens> <> <and> <some> <more> <tokens> <> //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234> <LIYI> <China> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <> <010> <201110260000> <OK> //[a] //Tokens: // <a> //[a,b] //Tokens: // <a> <b> //[a,,b] //Tokens: // <a> <> <b> //[,a] //Tokens: // <> <a> //[a,] //Tokens: // <a> <> //[,a,,b] //Tokens: // <> <a> <> <b> //[,,a,,b,,] //Tokens: // <> <> <a> <> <b> <> <> //[,] //Tokens: // <> <> //[,,] //Tokens: // <> <> <> //[,,,] //Tokens: // <> <> <> <>", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "strtokstrstrstrncpy……", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "赵老师，使用strtok时，空行怎么处理呢？", "referer": "user-3"}]}
{"question": "[Error] ld returned 1 exit status和undefined reference to `sa(int)'出现怎么错了？怎么解决的？求哥哥姐姐们指教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改完善如下，供参考对照： #include<stdio.h> #define N 2 #define M 5  float o[N];  int main() {     void  sa(int [][M]);     void  ia(int [][M]);     void  find(int [][M]);//float find(float);     void  fun();          //float fun();     int   a[N][M],i,j;      printf(\"请输入所有学生各门课程分数：\\n\");     for(i=0;i<N;i++)     {         printf(\"输入学号%d学生的成绩：\\n\",i+1);         for(j=0;j<M;j++)         {             scanf(\"%d\",&a[i][j]);         }     }     sa(a);  //sa(a[N][M]);     ia(a);  //ia(a[N][M]);     find(a);//find(a[N][M]);     fun();        return 0; }  void sa(int a[][M]) {     int i,j,s;     printf(\"每个学生的平均成绩依次为：\\n\");     for(i=0;i<N;i++)     {         for(j=0,s=0;j<M;j++)         {             s+=a[i][j];         }         o[i]=s/M;         printf(\"%f    \",o[i]);     }     printf(\"\\n\"); }  void ia(int a[][M]) {     int i,j;     float s;     printf(\"每门课的平均成绩为：\\n\");     for(j=0;j<M;j++)     {         for(i=0,s=0;i<N;i++)         {             s+=a[i][j];         }         printf(\"%f    \",s/N);     }     printf(\"\\n\"); }  void  find(int a[][M]) {     int i,j,m,n;     for(i=0;i<N;i++)     {         for(j=0;j<M-1;j++)         {             if(a[i][j]>a[i][j+1])             {                 m=i;                 n=j;             }             else             {                 m=i;                 n=j+1;             }         }         printf(\"所有分数中最高的学生为%d，相应的课程为课程%d。\\n\",m,n);     } }  void fun() {     int i;     float f=0,s=0;     for(i=0;i<N;i++)     {         f+=o[i]*o[i];     }     s=f/N-(f*f)/(N*N);     printf(\"平均方差为：%f\\n\",s); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢哥", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "把main函数中的     sa(a[N][M]);     ia(a[N][M]);     find(a[N][M]);  改为     sa(a);     ia(a);     find(a);  引用的时候用a[M][N]变成引用a数组的第M行第N列元素了，而sa、ia、find需要的是数组，并非数组元素，所以编译器说你没定义sa(int)、ia(int)、find（int)。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "欧克，谢谢您", "referer": "user-2"}]}
{"question": "禁止显示状态错误\tLNK2019\t无法解析的外部符号 _string，函数 _main 中引用了该符号", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第14行，是否改为：letters = strlen(name);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "试试 ```#include <string>   ```", "referer": "user-0"}]}
{"question": "谭浩强老师第四版学习中遇到了一个问题（chap11链表）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "能给我个软件吗，我想学C 我的邮箱1225514766qq", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if(i=0)  有了这句，不会只自行一次，而是执行第一次就可能出现段错误了，pf是一个野指针；没有初始化", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "第21行：if(i=0) 错误，应该是：if(i==0)", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢感谢，matlab用多了，总是不注意这些", "referer": "user-3"}]}
{"question": "请问谁有VS2010版的，求发，谢谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "我正在下vs2019。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "https://msdn.itellyou.cn/开发人员工具", "referer": "user-0"}]}
{"question": "求软件，我是新来的请大家多多指教！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "能给我个软件吗，我想学C 我的邮箱1225514766qq", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Eclipse CDT", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "linux + vim+gcc/g++", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "vs2017 vs2019 vscode", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "vs2017vim+gcc", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢", "referer": "user-5"}, {"cid": "7", "user": "user-6", "content": "VScode", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "谢谢", "referer": "user-6"}]}
{"question": "求助，c语言作业，不太会", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "一堆问题。基本的问题有三：1，int loadrecord（） 函数申明与函数原型 参数数量都不同。2，打印出版时间的地方，是要打印年月日的。 参数却少了年月日。3，有个函数定义的地方，括号混乱。 是哪儿抄的作业。。。抄都抄不整齐。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int loadrecord(struct library book[],int n);声明的时候是两个形参。int loadrecord(struct library book[]){}  函数实现时只有一个参数。排版 修改如下，供参考： #include<stdio.h> #include<stdlib.h> #include<string.h> #include<ctype.h> #include\"windows.h\" #define M 50   struct date {      int year;      int month;      int day; };  struct library {     int  book_num;     char book_name[40];     char author_name[10];     float book_price;     char publisher[40];     struct date publish_time;     char book_state[2];     char reader_name[10];     int reader_num; };  int input(struct library book[]); int add(struct library book[],int n); void list(struct library book[],int n); void search_num(struct library book[],int n); void search_name(struct library book[],int n); int Delete(struct library book[],int n); void sort(struct library book[],int n); void count(struct library book[],int n); void unborrow(struct library book[],int n); void search_publisher(struct library book[],int n); void saverecord(struct library book[],int n); int loadrecord(struct library book[]);       //,int n); int menu();  void main() {     struct library b[M];     int    length;     while(1)     {       switch(menu())     {              case 1:length=input(b);                     if(length==-1)break;                     else                       saverecord(b,length);                     break;              case 2:length=loadrecord(b);                     length=add(b,length);                     saverecord(b,length);                     break;              case 3:length=loadrecord(b);                     list(b,length);                     break;              case 4:length=loadrecord(b);                     search_num(b,length);                     break;              case 5:length=loadrecord(b);                     search_name(b,length);                     break;              case 6:length=loadrecord(b);                     length=Delete(b,length);                     saverecord(b,length);                     break;              case 7:length=loadrecord(b);                     sort(b,length);                     saverecord(b,length);                     list(b,length);                     break;              case 8:length=loadrecord(b);                     count(b,length);                     saverecord(b,length);                     break;              case 9:length=loadrecord(b);                     unborrow(b,length);              case 10:length=loadrecord(b);                     search_publisher(b,length);                     break;              case 0:exit(0);     }     } } int menu() {    int c;    system(\"mode con:cols=400 lines=30000\"); //调节控制台的宽度和高度    system(\"color 0b\");  //调节控制台的背景和字体颜色      printf(\"\\t\\t\\t\\t\\t-------------------------------------------------\\n\");    printf(\"\\t\\t\\t\\t\\t+ 图书信息管理系统         +\\n\");    printf(\"\\t\\t\\t\\t\\t-------------------------------------------------\\n\");    printf(\"\\t\\t\\t\\t\\t\\t\\t ***************\\n\");    printf(\"\\t\\t\\t\\t\\t\\t\\t 1. 初始化图书信息\\n\");                             printf(\"\\t\\t\\t\\t\\t\\t\\t 2. 添加图书信息\\n\");                       printf(\"\\t\\t\\t\\t\\t\\t\\t 3. 显示图书信息\\n\") ;    printf(\"\\t\\t\\t\\t\\t\\t\\t 4. 按图书编号查询图书信息\\n\");         printf(\"\\t\\t\\t\\t\\t\\t\\t 5. 按图书名称查询图书信息\\n\");                     printf(\"\\t\\t\\t\\t\\t\\t\\t 6. 按图书名称删除图书信息\\n\");         printf(\"\\t\\t\\t\\t\\t\\t\\t 7. 按图书名称从小到大排序图书信息\\n\");                       printf(\"\\t\\t\\t\\t\\t\\t\\t 8. 按价格统计图书信息\\n\") ;    printf(\"\\t\\t\\t\\t\\t\\t\\t 9. 显示未借出图书信息\\n\");    printf(\"\\t\\t\\t\\t\\t\\t\\t 10. 修改图书信息\\n\");    printf(\"\\t\\t\\t\\t\\t\\t\\t 11. 按出版社名称查询图书信息\\n\");    printf(\"\\t\\t\\t\\t\\t\\t\\t 0. 退出\\n\") ;                                           printf(\"\\t\\t\\t\\t\\t\\t\\t ***************\\n\");     do{        printf(\"\\n  Enter your choice(0-10):\");              if(scanf(\"%d\",&c)!=1)        {  while(getchar()!='\\n')             continue;             continue;        }     }while(c<0||c>11);     return c; } int input(struct library book[]) {     int i,n;     system(\"cls\");     printf(\"\\t输入图书的数量：\\n\");     scanf(\"\\t\\t\\t\\t%d\",&n);     system(\"cls\");     printf(\"\\t开始输入记录：\\n\");     for(i=0;i<n;i++)     {          printf(\"\\n\\t第%d条记录的图书编号：\",i+1);          scanf(\"\\t%d\",&book[i].book_num);           printf(\"\\t第%d条记录的图书名称：\",i+1);          scanf(\"\\t%s\",book[i].book_name);           printf(\"\\t第%d条记录的图书作者姓名：\",i+1);          scanf(\"\\t%s\",book[i].author_name);           printf(\"\\t第%d条记录的图书价格：\",i+1);          scanf(\"\\t%f\",&book[i].book_price);           printf(\"\\t第%d条记录的图书出版社：\",i+1);          scanf(\"\\t%s\",book[i].publisher);           printf(\"\\t第%d条记录的图书出版时间：\",i+1);          scanf(\"\\t%d-%d=%d\",&book[i].publish_time.year,                    &book[i].publish_time.month,&book[i].publish_time.day);           printf(\"\\t第%d条记录的图书存在状态(y/n)：\",i+1);          scanf(\"\\t%s\",book[i].book_state);           printf(\"\\t第%d条记录的读者姓名：\",i+1);          scanf(\"\\t%s\",book[i].reader_name);           printf(\"\\t第%d条记录的读者学号：\",i+1);          scanf(\"\\t%d\",&book[i].reader_num);     }     printf(\"\\t******************\\n\");     printf(\"\\t   已输入成功！\\n\");     printf(\"\\t  press any key enter menu......\\n\");     printf(\"\\t******************\\n\");     getchar();     getchar();     system(\"cls\");     return n; }   int add(struct library book[],int n) {     int i,m;     system(\"cls\");     printf(\"\\t输入再增加的记录数：\\n\");     scanf(\"%d\",&m);     printf(\"\\t开始输入记录：\\n\");     for(i=n;i<n+m;i++)     {         printf(\"\\n\\t第%d条记录的图书编号：\",i+1);         scanf(\"\\t%d\",&book[i].book_num);          printf(\"\\t第%d条记录的图书名称：\",i+1);         scanf(\"\\t%s\",book[i].book_name);          printf(\"\\t第%d条记录的图书作者姓名：\",i+1);         scanf(\"\\t%s\",book[i].author_name);          printf(\"\\t第%d条记录的图书价格：\",i+1);         scanf(\"\\t%f\",&book[i].book_price);          printf(\"\\t第%d条记录的图书出版社：\",i+1);         scanf(\"\\t%s\",book[i].publisher);          printf(\"\\t第%d条记录的图书出版时间：\",i+1);         scanf(\"\\t%d-%d=%d\",&book[i].publish_time.year,               &book[i].publish_time.month,&book[i].publish_time.day);          printf(\"\\t第%d条记录的图书存在状态(y/n)：\",i+1);         scanf(\"\\t%s\",book[i].book_state);          printf(\"\\t第%d条记录的读者姓名：\",i+1);         scanf(\"\\t%s\",book[i].reader_name);          printf(\"\\t第%d条记录的读者学号：\",i+1);         scanf(\"\\t%d\",&book[i].reader_num);     }     printf(\"\\t******************\\n\");     printf(\"\\t   已输入成功！\\n\");     printf(\"\\t  press any key enter menu......\\n\");     printf(\"\\t******************\\n\");     getchar();     getchar();     system(\"cls\");     return (n+m); } void list(struct library book[],int n) {      int i;      system(\"cls\");        printf(\"\\t图书馆图书信息如下:\\n\");      printf(\"\\t图书编号\\t图书名称\\t作者\\t单价\\t出版社\\t\\t出版时间\\t存在状态\\t读者姓名\\t读者学号\\n\");      for(i=0;i<n;i++)      {           printf(\"\\t%6d\\t%12s\\t%10s\\t%4.2f\\t%6s\\t\",book[i].book_num,book[i].book_name,                              book[i].author_name,book[i].book_price,book[i].publisher);           printf(\"\\t%4d-%2d-%2d\\t%2s\\t%6s\\t%8d\\t\\n\",book[i].publish_time,book[i].book_state,                                                      book[i].reader_name,book[i].reader_num);      }       printf(\"\\t***************************\\n\");      printf(\"\\t  press any key enter menu......\\n\");      printf(\"\\t***************************\\n\");      getchar();      getchar();      system(\"cls\"); } void search_num(struct library book[],int n) {     int i,flag=0;     int bnum;     system(\"cls\");     printf(\"\\t输入查询编号：\\n\");     scanf(\"%d\",&bnum);     for(i=0;i<n;i++)     {         if(book[i].book_num==bnum)             flag=1;         system(\"cls\");         printf(\"\\t图书馆图书信息如下:\\n\");         printf(\"\\t图书编号\\t图书名称\\t作者\\t单价\\t出版社\\t\\t出版时间\\t存在状态\\t读者姓名\\t读者学号\\n\");         printf(\"\\t%6d\\t%12s\\t%10s\\t%4.2f\\t%6s\\t\",book[i].book_num,book[i].book_name,                            book[i].author_name,book[i].book_price,book[i].publisher);         printf(\"\\t%4d-%2d-%2d\\t%2s\\t%6s\\t%8d\\t\\n\",book[i].publish_time,book[i].book_state,                                                    book[i].reader_name,book[i].reader_num);         printf(\"\\t***************************\\n\");         printf(\"\\t  press any key enter menu......\\n\");         printf(\"\\t***************************\\n\");         getchar();         getchar();         system(\"cls\");     }     if(flag==0)     {         printf(\"查无此书！\\n\");         printf(\"\\t***************************\\n\");         printf(\"\\t  press any key enter menu......\\n\");         printf(\"\\t***************************\\n\");         getchar();         getchar();         system(\"cls\");     } }   void search_name(struct library book[],int n) {     int i,flag=0;     char bname[10];     system(\"cls\");     printf(\"\\n请输入要查询的图书书名:\");     scanf(\"%s\",bname);     for(i=0;i<n;i++)     {        if(strcmp(bname,book[i].book_name)==0)        {           flag=1;           system(\"cls\");           printf(\"\\t此书的信息如下：\\n\");           printf(\"\\t图书编号\\t图书名称\\t作者\\t单价\\t出版社\\t\\t出版时间\\t存在状态\\t读者姓名\\t读者学号\\n\");           printf(\"\\t%6d\\t%12s\\t%10s\\t%4.2f\\t%6s\\t\",book[i].book_num,book[i].book_name,                              book[i].author_name,book[i].book_price,book[i].publisher);           printf(\"\\t%4d-%2d-%2d\\t%2s\\t%6s\\t%8d\\t\\n\",book[i].publish_time,                                  book[i].book_state,book[i].reader_name,book[i].reader_num);           printf(\"\\t***************************\\n\");           printf(\"\\t  press any key enter menu......\\n\");           printf(\"\\t***************************\\n\");           getchar();           getchar();           system(\"cls\");        }     }     if(flag==0)     {          printf(\"没有此书!\\n\");           printf(\"\\t***************************\\n\");          printf(\"\\t  press any key enter menu......\\n\");          printf(\"\\t***************************\\n\");          getchar();          getchar();          system(\"cls\");     } }  int Delete(struct library book[],int n) {     int i,j,flag=0;     char bname[10];     char ch='n';     system(\"cls\");     printf(\"请输入要删除的图书名字\\n\");     scanf(\"%s\",bname);     for(i=0;i<n;i++)     {        if(strcmp(bname,book[i].book_name)==0)        {           flag=1;           printf(\"\\t此书的信息如下:\\n\");           printf(\"\\t图书编号\\t图书名称\\t作者\\t单价\\t出版社\\t\\t出版时间\\t存在状态\\t读者姓名\\t读者学号\\n\");           printf(\"\\t%6d\\t%12s\\t%10s\\t%4.2f\\t%6s\\t\",book[i].book_num,book[i].book_name,                              book[i].author_name,book[i].book_price,book[i].publisher);           printf(\"\\t%4d-%2d-%2d\\t%2s\\t%6s\\t%8d\\t\\n\",book[i].publish_time,book[i].book_state,                                                      book[i].reader_name,book[i].reader_num);                       printf(\"是否要删除此条信息!(y/n):\");           ch=getchar();           ch=getchar();           if(ch=='y'||ch=='Y')           {              for(j=i;j<n-1;j++)                  book[j]=book[j+1];              n--;              printf(\"是否要删除此信息！(y/n):\");           }           printf(\"\\t***************************\\n\");           printf(\"\\t  press any key enter menu......\\n\");           printf(\"\\t***************************\\n\");           getchar();           getchar();           system(\"cls\");        }     }     if(flag==0)     {          printf(\"\\t  查无此书！\\n\");           printf(\"\\t***************************\\n\");          printf(\"\\t  press any key enter menu......\\n\");          printf(\"\\t***************************\\n\");          getchar();          getchar();           system(\"cls\");     }     return n; } void sort(struct library book[],int n) { } void count(struct library book[],int n) {      int i,count1=0;float p;      system(\"cls\");      printf(\"请输入任意一个价格：\");      scanf(\"%f\",&p);       for(i=0;i<n;i++)      {          if(book[i].book_price>p)            count1++;      }      printf(\"\\t图书的数量为:%d \\n\\n\\n\\n\",count1);       printf(\"\\t***************************\\n\");      printf(\"\\t  press any key enter menu......\\n\");      printf(\"\\t***************************\\n\");      getchar();      getchar();      system(\"cls\"); }  void unborrow(struct library book[],int n) { }  void saverecord(struct library book[],int m)//初始化图书信息else {     int i;     FILE *fp;     if((fp=fopen(\"record.txt\",\"w\"))==NULL)     {        printf(\"无法录入信息!!\\n\");        exit(1);     }     for(i=0;i<m;i++)       fwrite(&book[i],sizeof(struct library),1,fp);     fclose(fp); } int loadrecord(struct library book[])//添加图书信息else {     int n=0;     FILE *fp;     if((fp=fopen(\"record.txt\",\"r\"))==NULL)     {         printf(\"无法录入信息!!\\n\");         exit(0);     }     while(fread(&book[n],sizeof(struct library),1,fp))n++;     fclose(fp);     printf(\"从文件中成功读出记录!!!\\n\");     return n; }  void search_publisher(struct library book[],int n) {     int i,flag=0;     char bpublisher[10];     system(\"cls\");     printf(\"\\n请输入要查询的出版社名称:\");     scanf(\"%s\",bpublisher);     for(i=0;i<n;i++)     {         if(strcmp(book[i].publisher,bpublisher)==0)         {            flag=1;            system(\"cls\");            printf(\"\\t此书的信息如下：\\n\");            printf(\"\\t图书编号\\t图书名称\\t作者\\t单价\\t出版社\\t\\t出版时间\\t存在状态\\t读者姓名\\t读者学号\\n\");            printf(\"\\t%6d\\t%12s\\t%10s\\t%4.2f\\t%6s\\t\",book[i].book_num,book[i].book_name,                               book[i].author_name,book[i].book_price,book[i].publisher);            printf(\"\\t%4d-%2d-%2d\\t%2s\\t%6s\\t%8d\\t\\n\",book[i].publish_time,book[i].book_state,                                                       book[i].reader_name,book[i].reader_num);            printf(\"\\t***************************\\n\");            printf(\"\\t  press any key enter menu......\\n\");            printf(\"\\t***************************\\n\");            getchar();            getchar();            system(\"cls\");         }     }     if(flag==0)     {       printf(\"没有此书!\\n\");        printf(\"\\t***************************\\n\");       printf(\"\\t  press any key enter menu......\\n\");       printf(\"\\t***************************\\n\");       getchar();       getchar();       system(\"cls\");     }     //}     //return n; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "C:\\Users\\lenovo\\Desktop\\wangyujie.cpp(53) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(57) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(60) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(63) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(66) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(70) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(75) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(79) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(81) : error C2660: 'loadrecord' : function does not take 1 parametersC:\\Users\\lenovo\\Desktop\\wangyujie.cpp(416) : error C2601: 'search_publisher' : local function definitions are ille这是显示错误的地方", "referer": "user-0"}]}
{"question": "这个程序在vc6.0上编译时会出现许多问题，但在dev上面编译时只有一个错误:\t[Error] ld returned 1 exit status（makefiles.win文件里），想知道这个程序应该怎样改才能正常运行，在Dev里有时可以编译成功。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这是代码运行的部分截图：", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "修改完善如下，供参考： #include<stdio.h> #include<stdlib.h> #include<string.h> #include <time.h> struct Signal {     char  Name[10];    //名字     int   KB;          //开放状态     float Pos;        //地址     int   Type;       //闭锁継电器状态     struct Signal *next,*front; };  struct Signal*head=NULL; int    i_count=0;      //全局 计数  void   write(struct Signal*head); void   read(struct Signal*&head); void   creat(struct Signal *&head); void   chaxun(struct Signal*head); void   change(struct Signal* head); void   delete_xinhaoji(struct Signal*head); void   myfree(struct Signal*head); void   Change(struct Signal *head);  void   creat(struct Signal *&head) {     char answer='t';     struct Signal*p1,*p2,*pr;     if(head==NULL)     {             head=(struct Signal*)malloc(sizeof(struct Signal));             if(!head)  return;             head->next=NULL;     }     pr=head;     p2=head->next;     while(p2){pr=p2; p2=p2->next;}     while(answer!='F'&& answer!='f')     {         p1=(struct Signal*)malloc(sizeof(struct Signal));         p1->next=NULL;         printf(\"请输入第%d架信号机的名称：\\n\",i_count+1);         fflush(stdout);rewind(stdin);         scanf(\"%s\",p1->Name);         printf(\"请输入第%d架信号机的开放状态：\\n\",i_count+1);         fflush(stdout);rewind(stdin);         scanf(\"%d\",&p1->KB);         printf(\"请输入第%d架信号机的地址：\\n\",i_count+1);         fflush(stdout);rewind(stdin);         scanf(\"%f\",&p1->Pos);         printf(\"请输入第%d架信号机的闭锁继电器状态：\\n\",i_count+1);         fflush(stdout);rewind(stdin);         scanf(\"%d\",&p1->Type);//输入后点击两次回车。         pr->next=p1;         pr=p1;         i_count++;         printf(\"是否继续(T/F)\\n\");         fflush(stdout);rewind(stdin);         scanf(\"%c\",&answer);     } }   void Change(struct Signal *head) {     char s[20];     struct Signal* buf;     if(head==NULL) return;     printf(\"\\t请输入想修改的信号机名称:\");     scanf(\"%s\",s);     buf=head->next;     while(strcmp(buf->Name,s)!=0 && buf->next!=NULL)     {            buf=buf->next;//找到要修改的信号机     }     if(buf==NULL || strcmp(buf->Name,s)!=0)     {         printf(\"\\t没有这个信号机!\\n\");         return;     }else{         //输入修改之后的数据         printf(\"\\t信号机名称改为:\");         scanf(\"%s\",buf->Name);         printf(\"\\t信号机开放状态改为:\");         scanf(\"%d\",&buf->KB);         printf(\"\\t信号机位置改为:\");         scanf(\"%f\",&buf->Pos);         printf(\"\\t信号机性质改为:\");         scanf(\"%d\",&buf->Type);         printf(\"\\t修改成功!\\n\");     } } void change(struct Signal* head) {         if(head==NULL)  return;         printf(\"信号机名称\\t信号机开放状态\\t信号机位置\\t信号机性质\\n\");         struct Signal *buf;         buf = head->next;         while(buf!=NULL)   // 输出全部信息         {              printf(\"%5s%15d%15g%15d\\n\",buf->Name,buf->KB,buf->Pos,buf->Type);//输出信息              buf=buf->next;         } }  void delete_xinhaoji(struct Signal*head) {     if(head==NULL) return;     char Signal_num[20];     printf(\"\\t请输入要删除的信号机的名称:\");     scanf(\"%s\",Signal_num);     struct Signal*tmp,*pre;     for(tmp=head->next,pre=head;tmp!=NULL;pre=tmp,tmp=tmp->next)     {         if(strcmp(tmp->Name,Signal_num)==0)         {            pre->next=tmp->next;            free(tmp);//释放temp所占用的内存；            printf(\"\\t\\t\\t删除信号机成功！\\n\");            i_count--;            return ;         }     }     if(tmp==NULL)     {         printf(\"\\t无此信号机！\\n\");     } }  void chaxun(struct Signal*head) {     char s[10];     struct Signal*temp;     if(head==NULL) return;     printf(\"请输入想查询的信号机名称:\\n\");     scanf(\"%s\",s);     temp=head->next;     while(strcmp(temp->Name,s)!=0 && temp->next!=NULL)     {         temp=temp->next;     }     if(temp==NULL || strcmp(temp->Name,s)!=0)     {         printf(\"\\t没有这个信号机!\\n\");     }     else     {         printf(\"\\t此信号机名称:             %s\\n\",temp->Name);         printf(\"\\t此信号机的位置是          %d\\n\",temp->KB);         printf(\"\\t此信号机的开放状态是      %g\\n\",temp->Pos);         printf(\"\\t此信号机的闭锁继电器状态是%d\\n\",temp->Type);     } }    void read(struct Signal*&head)//将文件中的内容读出到链表中，返回值为表头地址 {     FILE *fp; //文件指针     char filename[32]=\"signal.txt\";     struct Signal *p,*p1,*pr=NULL;     //printf(\"请输入打开的文件名(signal.txt):\");     //scanf(\"%s\",filename);     if((fp=fopen(filename,\"r+\"))==NULL)//以二进制的方式打开文件     {         printf(\"cannot open file\\n\");//如有错则输出cannot open file         return;//exit(0);     }     if(head==NULL)     {             head=(struct Signal*)malloc(sizeof(struct Signal));             if(!head)  return;             head->next=NULL;     }     pr=head;     p1=head->next;     while(p1){pr=p1; p1=p1->next;}     while(1)     {            p=(struct Signal*)malloc(sizeof(struct Signal));            p->next=NULL;            if(fscanf(fp,\"%s %d %f %d\",p->Name,&p->KB,&p->Pos,&p->Type)!=4) break;            pr->next=p;            pr=p;            i_count++;     }     fclose(fp);    //关闭文件 }  void write(struct Signal *head) {         struct Signal*p;         FILE *fp;         int  i=0 ;         char filename[32]=\"signal.txt\";         p=head->next;         //printf(\"请输入保存的文件名(signal.txt):\");         //scanf(\"%s\",filename);         if((fp=fopen(filename,\"w+\"))==NULL)         {                printf(\"不能打开文件\\n\");                return;         }         while(p!=NULL)         {                fprintf(fp,\"%5s\\t%15d\\t%15f\\t%15d\\n\",p->Name,p->KB,p->Pos,p->Type);                p=p->next;                i++;         }         //fprintf(fp,\"-------------------------------------------------------------------------\\n\");         //fprintf(fp,\"*****共有%d个信号机*****\\n\",i);         fclose(fp);                  //关闭文件         printf(\"保存成功!\\n\"); }  void myfree(struct Signal*head) {     struct Signal*p=NULL;     for(;head!=NULL;)     {         p=head;         head=head->next;         free(p);     }     i_count=0;     system(\"pause\"); }  int main() {     int option;     read(head);//系统起始，载入文件信息。     while (1)     {         system(\"cls\");         printf(\"    主菜单：\\n\");         printf(\"1,  添加信号机：    \\n\");         printf(\"2,  查看信号机：    \\n\");         printf(\"3,  修改信号机信息：\\n\");         printf(\"4,  删除信号机：    \\n\");         printf(\"5,  保存信号机信息：\\n\");         printf(\"6,  浏览信号机信息：\\n\");         printf(\"7,  保存并退出系统：\\n\");         printf(\"请选择：            \\n\");         scanf(\"%d\",&option);         getchar();         switch(option)         {             case 1:creat(head); break;             case 2:chaxun(head);break;             case 3:Change(head);break;//修改信号机信息             case 4:delete_xinhaoji(head);break;             case 5://write(head);                    break;             case 6:change(head);break;//浏览信号机信息             case 7:write(head);free(head);exit(0);             default:printf(\"enter data error!\\n\");         }         system(\"pause\");     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这个还是只编译成功了但是各部分功能还是没办法运行啊", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "什么功能没办法运行？我把文件读入功能，放在了系统启动时自动加载了，文件保存放在了第7项里了，退出系统前先保存到文件里。所以系统运行时，菜单里的保存信号机信息到文件第5项就给屏蔽了，第6项 读取文件内容改成了浏览信号机信息了。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "编译成功了并不代表没有错误，比如这一行：  while (option=6)  很显然就是一个错误。等你把这些错误改完了再说吧！", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "我在赵四老师改的基础上又改了一下，现在错误应该差不多了，但是程序依然没发运行写入数据后只能保存一组数据，运行其他子程序时直接退出。现在应该怎么办。#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #include &lt;time.h&gt; struct Signal  {     char Name[10];    //名字     int KB;            //开放状态     float Pos;        //地址     int Type;            //闭锁継电器状态     struct Signal *next,*front; }; struct Signal*head; void write(); void read(); void creat(); void chaxun(); void change(); void Change(); void delete_xinhaoji(); void myfree();     void creat() {     int n,i=0;     char answer=' ';     struct Signal*p1,*p2;     n=0;     p1=p2=(struct Signal*)malloc(sizeof(struct Signal));     p1-&gt;Pos=1.0;     printf(\"请输入第1架信号机的名称：\\n\");     scanf(\"%s\",p1-&gt;Name);     printf(\"请输入第1架信号机的开放状态:\\n\");     scanf(\"%d\",&p1-&gt;KB);     printf(\"请输入第1架信号机的地址:\\n\");     scanf(\"%f\",&p1-&gt;Pos);     printf(\"请输入第1架信号机的闭锁继电器状态\\n\");     scanf(\"%d\",&p1-&gt;Type);     head=NULL;     while(answer!='F'&&answer!='f')     {         n=n+1;         if(n==1)  \t\t{             head=p1;         }  \t\telse  \t\t{             p2-&gt;next=p1;         }         p2=p1;         p1=(struct Signal*)malloc(sizeof(struct Signal));         getchar();         printf(\"请输入第%d架信号机的名称：\\n\",i+2);         scanf(\"%s\",p1-&gt;Name);         printf(\"请输入第%d架信号机的开放状态：\\n\",i+2);         scanf(\"%d\",&p1-&gt;KB);         printf(\"请输入第%d架信号机的地址：\\n\",i+2);         scanf(\"%f\",&p1-&gt;Pos);         printf(\"请输入第%d架信号机的闭锁继电器状态：\\n\",i+2);         scanf(\"%d\",&p1-&gt;Type);//输入后点击两次回车。         getchar();         i++;         getchar();         printf(\"是否继续(T/F)\\n\");         scanf(\"%c\",&answer);         getchar();     }     p2-&gt;next=NULL; }    void change()  { \tstruct Signal*buf;     printf(\"%5s%15d%15g%15d\\n\",head-&gt;Name,&head-&gt;KB,&head-&gt;Pos,&head-&gt;Type);          while(1)     {         printf(\"%5s%15d%15g%15d\\n\",head-&gt;Name,&head-&gt;KB,&head-&gt;Pos,&head-&gt;Type);           buf = head-&gt;next;         while(buf!=NULL)        // 输出全部信息         {             printf(\"%5s%15d%15g%15d\\n\",buf-&gt;Name,&buf-&gt;KB,&buf-&gt;Pos,&buf-&gt;Type);   // 输出信息             buf=buf-&gt;next;         }         Change();     } } void Change()  { \tstruct Signal* buf;     char s[20];     buf=head-&gt;next;     printf(\"\\t请输入想修改的信号机:\");     scanf(\"%s\",s);     while(strcmp(buf-&gt;Name,s)!=0&&buf!=NULL) buf=buf-&gt;next;//找到要修改的信号机     if(buf==NULL)     {         printf(\"\\t没有这个信号机!\\n\");         return;     }     //输入修改之后的数据     printf(\"\\t信号机名称:\");     scanf(\"\\t%s\",buf-&gt;Name);     printf(\"\\t信号机开放状态:\");     scanf(\"\\t%d\",&buf-&gt;KB);     printf(\"\\t信号机位置:\");     scanf(\"\\t%f\",&buf-&gt;Pos);     printf(\"\\t信号机性质:\");     scanf(\"\\t%d\",&buf-&gt;Type);     printf(\"\\t修改成功!\\n\"); }    void delete_xinhaoji()  { \tstruct Signal*temp;     char Signal_num[20];     printf(\"\\t请输入要删除的信号机的名称:\");     scanf(\"%s\",Signal_num);     for(temp=head-&gt;next;temp!=NULL;temp=temp-&gt;next)     {         if(strcmp(temp-&gt;Name,Signal_num)==0)         {             // 找到需要删除节点的位置             struct Signal*front=temp-&gt;front;             struct Signal*next=temp-&gt;next;             //进行删除操作；             front-&gt;next=next;             next-&gt;front=front;             free(temp);//释放temp所占用的内存；             printf(\"\\t\\t\\t删除信号机成功！\\n\");             return ;         }     }     if(temp==NULL)     {         printf(\"\\t无此信号机！\\n\");     } }       void chaxun() {     char s[10];     struct Signal*temp=head-&gt;next;     printf(\"请输入想查询的信号机\\n\");     scanf(\"%s\",s);     while(strcmp(temp-&gt;Name,s)!=0&&temp-&gt;next!=NULL)     {         temp=temp-&gt;next;     }     if(strcmp(temp-&gt;Name,s)!=0)     {         printf(\"\\t没有这个信号机!\\n\");         return;     } else {         printf(\"\\t此信号机名称:%s\\n\",temp-&gt;Name);         printf(\"\\t此信号机的位置是%d\\n\",temp-&gt;KB);         printf(\"\\t此信号机的开放状态是%g\\n\",temp-&gt;Pos);         printf(\"\\t此信号机的闭锁继电器状态是%d\\n\",temp-&gt;Type);     } }    void read() {     //将文件中的内容读出到链表中，返回值为表头地址     FILE *fp;       //文件指针     int n=0;     char filename[10];     struct Signal*p2,*p,*pr=NULL;     printf(\"请输入需要打开的文件\");     scanf(\"%s\",filename);     if((fp=fopen(filename,\"r+\"))==NULL)     //以二进制的方式打开文件     {         printf(\"cannot open file\\n\");//如有错则输出cannot open file         exit(0);     }     while(!feof(fp))        //判断文件位置标志是否移动到文件末尾     {         n++;         p=(struct Signal*)malloc(sizeof(struct Signal));         fscanf(fp,\"%s%d%f%d\",p-&gt;Name,&p-&gt;KB,&p-&gt;Pos,&p-&gt;Type);         if(n==1)    {             head=p;             p2=p;         } else {             //创建链表             pr=p2;             p2-&gt;next=p;             p2=p;         }     }     if(pr!=NULL)     {        pr-&gt;next=NULL;     } else {        head=NULL;     }     fclose(fp);    //关闭文件 }    void write()  {     struct Signal*p;     FILE *fp;     int  i=0 ;     char filename[10];     p=head;     printf(\"请输入需要打开的文件\");     scanf(\"%s\",filename);     if((fp=fopen(filename,\"w+\"))==NULL)     {         printf(\"不能打开文件\\n\");         return;     }     while(p!=NULL)     {         fprintf(fp,\"%5s\\t%15d\\t%15f\\t%15d\\n\",p-&gt;Name,p-&gt;KB,p-&gt;Pos,p-&gt;Type);         p=p-&gt;next;         i++;     }     fprintf(fp,\"-------------------------------------------------------------------------\\n\");     fprintf(fp,\"*****共有%d个信号机*****\\n\",i);     fclose(fp);                  //关闭文件     printf(\"保存成功!\\n\"); }       void myfree()  {     struct Signal*p=NULL;     for(;head!=NULL;)     {         p=head;         head=head-&gt;next;         free(p);     }     system(\"pause\"); } \tint main()  \t{     int option;     while (1)     {         system(\"cls\");         printf(\"    主菜单：\\n\");         printf(\"1,  添加信号机：    \\n\");         printf(\"2,  查看信号机：    \\n\");         printf(\"3,  修改信号机信息：\\n\");         printf(\"4,  删除信号机：    \\n\");  \t\tprintf(\"5, 保存信号机信息：\\n\"); \t\tprintf(\"6, 读入信号机信息，\\n\"); \t\tprintf(\"7, 退出菜单 \\n\"); \t\tprintf(\"请选择： \\n\"); \t\tscanf(\"%d\",&option); \t\tgetchar(); \t\tswitch(option)  \t\t{  \t\t\tcase 1:creat(); break;  \t\t\tcase 2:chaxun(); break;  \t\t\tcase 3:change(); break;  \t\t\tcase 4:delete_xinhaoji();break;  \t\t\tcase 5:write(); break;  \t\t\tcase 6:read(); break;  \t\t\tcase 7:myfree(); exit(0);  \t\t\tdefault:printf(\"enter data error!\\n\");  \t\t}  \t}  \treturn 0;  }", "referer": "user-2"}, {"cid": "7", "user": "user-2", "content": "喏，出现了这么多错误！要对着错误修改！https://wandbox.org/permlink/fJaSf3mv7oG8e6aV prog.cc: In function 'void change(Signal*)': prog.cc:113:23: error: too many arguments to function 'void Change()'   113 |                 Change(head);       |                 ~~~~~~^~~~~~ prog.cc:75:6: note: declared here    75 | void Change()       |      ^~~~~~ prog.cc:102:19: warning: unused variable 'temp' [-Wunused-variable]   102 |     struct Signal*temp,*buf;       |                   ^~~~ prog.cc: In function 'void chaxun(Signal*)': prog.cc:153:9: warning: format '%s' expects argument of type 'char*', but argument 2 has type 'char (*)[10]' [-Wformat=]   153 | scanf(\"%s\",&s);       |        ~^  ~~       |         |  |       |         |  char (*)[10]       |         char* prog.cc: In function 'void read(Signal*)': prog.cc:183:17: warning: format '%s' expects argument of type 'char*', but argument 2 has type 'char (*)[10]' [-Wformat=]   183 |         scanf(\"%s\",&filename);       |                ~^  ~~~~~~~~~       |                 |  |       |                 |  char (*)[10]       |                 char* prog.cc:184:35: error: cannot convert 'bool' to 'FILE*' in assignment   184 |         if(fp=fopen(filename,\"r+\")==NULL);     //以二进制的方式打开文件       |                                   ^       |                                   |       |                                   bool prog.cc:184:42: warning: suggest braces around empty body in an 'if' statement [-Wempty-body]   184 |         if(fp=fopen(filename,\"r+\")==NULL);     //以二进制的方式打开文件       |                                          ^ prog.cc:184:9: warning: this 'if' clause does not guard... [-Wmisleading-indentation]   184 |         if(fp=fopen(filename,\"r+\")==NULL);     //以二进制的方式打开文件       |         ^~ prog.cc:185:9: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'   185 |         {       |         ^ prog.cc:192:27: warning: format '%d' expects argument of type 'int*', but argument 4 has type 'int' [-Wformat=]   192 |            fscanf(fp,\"%s,%d,%f,%d\",p->Name,p->KB,p->Pos,p->Type);       |                          ~^                ~~~~~       |                           |                   |       |                           int*                int prog.cc:192:30: warning: format '%f' expects argument of type 'float*', but argument 5 has type 'double' [-Wformat=]   192 |            fscanf(fp,\"%s,%d,%f,%d\",p->Name,p->KB,p->Pos,p->Type);       |                             ~^                   ~~~~~~       |                              |                      |       |                              float*                 double prog.cc:192:33: warning: format '%d' expects argument of type 'int*', but argument 6 has type 'int' [-Wformat=]   192 |            fscanf(fp,\"%s,%d,%f,%d\",p->Name,p->KB,p->Pos,p->Type);       |                                ~^                       ~~~~~~~       |                                 |                          |       |                                 int*                       int prog.cc: In function 'void write(Signal*)': prog.cc:227:25: warning: format '%s' expects argument of type 'char*', but argument 2 has type 'char (*)[10]' [-Wformat=]   227 |                 scanf(\"%s\",&filename);       |                        ~^  ~~~~~~~~~       |                         |  |       |                         |  char (*)[10]       |                         char* prog.cc: In function 'int main()': prog.cc:266:22: warning: suggest parentheses around assignment used as truth value [-Wparentheses]   266 |         while (option=6)       |                ~~~~~~^~", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "这个在Dev上是可以编译成功的，只有一个错误", "referer": "user-2"}, {"cid": "9", "user": "user-3", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h> #include <time.h> struct Signal {     char Name[10];    //名字     int KB;            //开放状态     float Pos;        //地址     int Type;            //闭锁継电器状态     struct Signal *next,*front; }; struct Signal*head; void write(); void read(); void creat(); void chaxun(); void change(); void Change(); void delete_xinhaoji(); void myfree();  void creat() {     int n,i=0;     char answer=' ';     struct Signal*p1,*p2;     n=0;     p1=p2=(struct Signal*)malloc(sizeof(struct Signal));     p1->Pos=1.0;     printf(\"请输入第1架信号机的名称：\\n\");     scanf(\"%s\",p1->Name);     printf(\"请输入第1架信号机的开放状态:\\n\");     scanf(\"%d\",&p1->KB);     printf(\"请输入第1架信号机的地址:\\n\");     scanf(\"%f\",&p1->Pos);     printf(\"请输入第1架信号机的闭锁继电器状态\\n\");     scanf(\"%d\",&p1->Type);     head=NULL;     while(answer!='F'&&answer!='f')     {         n=n+1;         if(n==1) {             head=p1;         } else {             p2->next=p1;         }         p2=p1;         p1=(struct Signal*)malloc(sizeof(struct Signal));         getchar();         printf(\"请输入第%d架信号机的名称：\\n\",i+2);         scanf(\"%s\",p1->Name);         printf(\"请输入第%d架信号机的开放状态：\\n\",i+2);         scanf(\"%d\",&p1->KB);         printf(\"请输入第%d架信号机的地址：\\n\",i+2);         scanf(\"%f\",&p1->Pos);         printf(\"请输入第%d架信号机的闭锁继电器状态：\\n\",i+2);         scanf(\"%d\",&p1->Type);//输入后点击两次回车。         getchar();         i++;         getchar();         printf(\"是否继续(T/F)\\n\");         scanf(\"%c\",&answer);         getchar();     }     p2->next=NULL; }  void Change() {     char s[20];     struct Signal* buf;     buf=head->next;     printf(\"\\t请输入想修改的信号机:\");     scanf(\"%s\",s);     while(strcmp(buf->Name,s)!=0&&buf!=NULL) buf=buf->next;//找到要修改的信号机     if(buf==NULL)     {         printf(\"\\t没有这个信号机!\\n\");         return;     }     //输入修改之后的数据     printf(\"\\t信号机名称:\");     scanf(\"\\t%s\",buf->Name);     printf(\"\\t信号机开放状态:\");     scanf(\"\\t%d\",&buf->KB);     printf(\"\\t信号机位置:\");     scanf(\"\\t%f\",&buf->Pos);     printf(\"\\t信号机性质:\");     scanf(\"\\t%d\",&buf->Type);     printf(\"\\t修改成功!\\n\"); } void change() {     printf(\"%5s%15d%15g%15d\\n\",head->Name,head->KB,head->Pos,head->Type);     struct Signal *buf;     while(1)     {         printf(\"%5s%15d%15g%15d\\n\",head->Name,head->KB,head->Pos,head->Type);          buf = head->next;         while(buf!=NULL)        // 输出全部信息         {             printf(\"%5s%15d%15g%15d\\n\",buf->Name,buf->KB,buf->Pos,buf->Type);   // 输出信息             buf=buf->next;         }         Change();     } } void delete_xinhaoji() {     char Signal_num[20];     printf(\"\\t请输入要删除的信号机的名称:\");     scanf(\"%s\",Signal_num);     struct Signal*temp;     for(temp=head->next;temp!=NULL;temp=temp->next)     {         if(strcmp(temp->Name,Signal_num)==0)         {             // 找到需要删除节点的位置             struct Signal*front=temp->front;             struct Signal*next=temp->next;             //进行删除操作；             front->next=next;             next->front=front;             free(temp);//释放temp所占用的内存；             printf(\"\\t\\t\\t删除信号机成功！\\n\");             return ;         }     }     if(temp==NULL)     {         printf(\"\\t无此信号机！\\n\");     } }  void chaxun() {     char s[10];     struct Signal*temp=head->next;     printf(\"请输入想查询的信号机\\n\");     scanf(\"%s\",&s);     while(strcmp(temp->Name,s)!=0&&temp->next!=NULL)     {         temp=temp->next;     }     if(strcmp(temp->Name,s)!=0)     {         printf(\"\\t没有这个信号机!\\n\");         return;     } else {         printf(\"\\t此信号机名称:%s\\n\",temp->Name);         printf(\"\\t此信号机的位置是%d\\n\",temp->KB);         printf(\"\\t此信号机的开放状态是%g\\n\",temp->Pos);         printf(\"\\t此信号机的闭锁继电器状态是%d\\n\",temp->Type);     } }  void read() {     //将文件中的内容读出到链表中，返回值为表头地址     FILE *fp;       //文件指针     int n=0;     char filename[10];     struct Signal*p2,*p,*pr=NULL;     printf(\"请输入需要打开的文件\");     scanf(\"%s\",&filename);     if((fp=fopen(filename,\"r+\"))==NULL)     //以二进制的方式打开文件     {         printf(\"cannot open file\\n\");//如有错则输出cannot open file         exit(0);     }     while(!feof(fp))        //判断文件位置标志是否移动到文件末尾     {         n++;         p=(struct Signal*)malloc(sizeof(struct Signal));         fscanf(fp,\"%s%d%f%d\",p->Name,p->KB,p->Pos,p->Type);         if(n==1)    {             head=p;             p2=p;         } else {             //创建链表             pr=p2;             p2->next=p;             p2=p;         }     }     if(pr!=NULL)     {        pr->next=NULL;     } else {        head=NULL;     }     fclose(fp);    //关闭文件 } void write() {     struct Signal*p;     FILE *fp;     int  i=0 ;     char filename[10];     p=head;     printf(\"请输入需要打开的文件\");     scanf(\"%s\",&filename);     if((fp=fopen(\"filename\",\"w+\"))==NULL)     {         printf(\"不能打开文件\\n\");         return;     }     while(p!=NULL)     {         fprintf(fp,\"%5s\\t%15d\\t%15f\\t%15d\\n\",p->Name,p->KB,p->Pos,p->Type);         p=p->next;         i++;     }     fprintf(fp,\"-------------------------------------------------------------------------\\n\");     fprintf(fp,\"*****共有%d个信号机*****\\n\",i);     fclose(fp);                  //关闭文件     printf(\"保存成功!\\n\"); }  void myfree() {     struct Signal*p=NULL;     for(;head!=NULL;)     {         p=head;         head=head->next;         free(p);     }     system(\"pause\"); } int main() {     int option;     while (option=6)     {         system(\"cls\");         printf(\"    主菜单：\\n\");         printf(\"1,  添加信号机：    \\n\");         printf(\"2,  查看信号机：    \\n\");         printf(\"3,  修改信号机信息：\\n\");         printf(\"4,  删除信号机：    \\n\");         printf(\"5,  保存信号机信息：\\n\");         printf(\"6,  读入信号机信息，\\n\");         printf(\"7,  退出菜单        \\n\");         printf(\"请选择：            \\n\");         scanf(\"%d\",&option);         getchar();         switch(option)         {             case 1:creat();          break;             case 2:chaxun();         break;             case 3:change();         break;             case 4:delete_xinhaoji();break;             case 5:write();          break;             case 6:read();           break;             case 7:myfree();         exit(0);             default:printf(\"enter data error!\\n\");         }     }     return 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "虽然编译成功了但是功能依然实现不了，输入数据后保存只能保存第一串数据，而且其他像其他程序运行的时候会一直出现这个问题，Process exited after 41.71 seconds with return value 3221225477 请按任意键继续. . .。我觉得是指针的问题，但是又不知道怎么改。", "referer": "user-3"}, {"cid": "11", "user": "user-0", "content": "有时候还会出现这个错误，\t[Error] ld returned 1 exit status", "referer": "user-0"}]}
{"question": "C语言中如何处理0x00?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <string.h> FILE *f; char buffer[4096]; int r,a; void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,\"%08x -\",i+addr);             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);             sprintf(binstr,\"%s  \",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf(\"%s\\n\",binstr);         } else {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,\"%s   \",binstr);         }         sprintf(binstr,\"%s  \",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf(\"%s\\n\",binstr);     } } int main(int argc,char **argv) {     if (argc<2) {         fprintf(stderr,\"Usage: %s filename.ext\\n\",argv[0]);         return 2;     }     f=fopen(argv[1],\"rb\");     if (NULL==f) {         fprintf(stderr,\"Can not open file [%s]!\\n\",argv[1]);         return 1;     }     a=0;     while (1) {         r=fread(buffer,1,4096,f);         HexDump(buffer,r,a);         a+=r;         if (r<4096) break;     }     fclose(f);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "非常感谢赵老师的解答^_^", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "fscanf %x，使用长度再做一个循环；", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "按二进制读取，而不是按文本读取", "referer": "user-0"}]}
{"question": "用户态和内核态的通讯，ioctrl和copy_from_user,什么场景使用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看看ioctrl的定义和实现，有的只需要少量的参数，有的需要多个参数。一般来说，需要多个参数，而且参数数据较大时，很有可能需要copy_from_user。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "要看对应的调用要不要求读写的内存必须是内核内存管理模块管理下的内存。我猜", "referer": "user-0"}]}
{"question": "将其中连续的多个空格用一个空格代替 ,用while遍历空格，最后只输出一个空格，如下代码为何不可？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "putchar->printf", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "对，无法输出空格，并且应该赋值号，不应该为等号", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你putchar(c);只有在c != ' '的情况下才执行，这样就一次也不输出空格了。", "referer": "user-0"}]}
{"question": "求求各位大神指点错误，如何改错？（Dev c++软件）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第136行，文件保存：ofstream outfile(cust[i].name+\".txt\",ios::out);      修改为：               ofstream outfile((cust[i].name+\".txt\").c_str(),ios::out);", "referer": "user-0"}]}
{"question": "关于C语言全局变量问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你不是说第二个（项目4）makefile可以执行吗。你的makefile中没有a.c和b.c的编译规则，最后链接也没有包含a.o和b.o。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不太懂makefile ,b.o应该不用写，另外b.o依赖的是b.h，而不是b.c", "referer": "user-0"}]}
{"question": "这个程序输入时只能输入两串数据，之后就会直接结束，现在知道错误在调用write()函数中，但是不知道具体错误，也不知道怎么改。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改如下，供参考：  #include<stdio.h> #include<stdlib.h> #include<string.h>  struct Signal {     char   Name[10];     int    KB;     float  Pos;     int    Type;     struct Signal *next,*front; }; int n=0,i=0; char ch=0;  void write(struct Signal*head);  int main() {         struct Signal *head=NULL;         struct Signal *p1,*p2;         while(1)         {               p1=(struct Signal*)malloc(sizeof(struct Signal));               if(!p1)  return 1;               p1->next=NULL;               printf(\"请输入第%d架信号机的信息\\n\",++i);               scanf(\"%s\",p1->Name);               if(strcmp(p1->Name,\"#\")==0)  break; //\"#\"结束输入               scanf(\"%d %f %d\",&p1->KB,&p1->Pos,&p1->Type);               n++;               if(n==1){                        head=p1;               }else{                        p2->next=p1;               }               p2=p1;               //write(head);         }         free(p1);         write(head);                  return 0;//return (head); }  void write(struct Signal*head) {         struct Signal*p;         FILE *fp;         int  i=0 ;         p=head;         if((fp=fopen(\"ABC.txt\",\"w+\"))==NULL)         {                printf(\"不能打开文件\\n\");                return;         }         while(p!=NULL)         {                fprintf(fp,\"%5s\\t%15d\\t%15g\\t%15d\\n\",p->Name,p->KB,p->Pos,p->Type);                p=p->next;                i++;         }         fprintf(fp,\"-------------------------------------------------------------------------\\n\");         fprintf(fp,\"*****共有%d个信号机*****\\n\",i);         fclose(fp);                  //关闭文件         printf(\"保存成功!\\n\"); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1"}]}
{"question": "求助：[Error] expected primary-expression before ';' token ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第56 59 69行都是同样错误，行末尾 '<<;' ，应该改为：<<endl;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢您，问题解决了。", "referer": "user-1"}]}
{"question": "ReadDirectoryChangesW 监听目录 丢失消息的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "问题已解决：https://bbs.csdn.net/topics/600348125", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "\"d:/zhouhui/c\", 这里的写法错误了： #include <stdio.h> #include <windows.h> #include <string.h>  int main() {     HANDLE handle = CreateFile(         \"d:\\\\zhouhui\",   //这里的目录字段格式错误         GENERIC_READ,         FILE_SHARE_READ | FILE_SHARE_DELETE | FILE_SHARE_WRITE,         NULL,         OPEN_EXISTING,         FILE_FLAG_BACKUP_SEMANTICS,         NULL     );     FILE_NOTIFY_INFORMATION pNotify[1024] = {0};     LPDWORD lpBytesReturned;     int i = 0;     while(1)     {         ReadDirectoryChangesW(             handle,             pNotify,             1024, //The size of the buffer             TRUE,//bWatchSubtree,             FILE_NOTIFY_CHANGE_FILE_NAME,//FILE_NOTIFY_CHANGE_DIR_NAME             (LPDWORD)& lpBytesReturned,   //lpBytesReturned             NULL,      //lpOverlapped             NULL         );         i++;         printf(\"%d\\n\",i);         } }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这跟目录格式没关系的呀，都能监听到的", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "有关系，\"d:/zhouhui/c\"这个形式，我的电脑上就死循环了。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "好吧，那你改成那样子后，多试几次，会有遗漏消息吗？", "referer": "user-1"}, {"cid": "6", "user": "user-0", "content": "while(1)     {             ReadDirectoryChangesW(             handle,              pNotify,             5000, //The size of the buffer             TRUE,//bWatchSubtree,             FILE_NOTIFY_CHANGE_FILE_NAME,//FILE_NOTIFY_CHANGE_DIR_NAME             (LPDWORD)& lpBytesReturned,   //lpBytesReturned             NULL,      //lpOverlapped             NULL         );                  DWORD dw = 0;             FILE_NOTIFY_INFORMATION* p;                  do {             p = &pNotify[dw];                          i++;                      printf(\"%d\\n\",i);                          dw += p->NextEntryOffset;         }         while(p->NextEntryOffset !=0);     }   网上有说要循环  FILE_NOTIFY_INFORMATION 链表的，我也照着做了，可还是会丢呢（如下图，添加时是10个，删除时，却只出来3个）。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "这是我刚刚又测试的，往里面放10张图片，然后又删除这个文件夹，结果只输出几次。。。", "referer": "user-0"}]}
{"question": "这个开源文本识别系统我粉了（附源码）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "新版没有表情了", "referer": "user-0"}]}
{"question": "求助 C动态内存问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "p=(int *)realloc(p,SIZE*2*sizeof(int));", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢！正常输出了", "referer": "user-1"}]}
{"question": "求助 老师给出的题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这代码逻辑混乱不堪，问题多多，这个能当题目也是醉了fission函数返回应该是个指针，因此int s[10]需要定义为static的，或者直接定义为全局变量，s里的内容没初始化。。。。", "referer": "user-0"}]}
{"question": "求一个list保存的数据 ，计算与判断方式的算法。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "了解一下“有限状态自动机”", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的  谢谢了", "referer": "user-1"}]}
{"question": "急求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "用排序的方法是可以的，但是效率不是最优，可以用这个比较好的方法，遍历一次就可以了。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> int main(void) {     int score[100], i, cnt = 0;     int max[3]; for (i = 0; i < 100; i++) {     if (scanf(\"%d\", &score[i]) && score[i] >= 0) {         cnt++;         continue;     }     break; }  max[0] = max[1] = max[2] = -1; for (i = 0; i < cnt; i++) {     if (score[i] > max[0]) {         max[2] = max[1];         max[1] = max[0];         max[0] = score[i];     } else if (score[i] > max[1]){         max[2] = max[1];         max[1] = score[i];     } else if (score[i] > max[2]) {         max[2] = score[i];     } }  printf(\"%d,%d,%d\\n\", max[0], max[1], max[2]);  return 0;  }  ```#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h>  int main(void) {     int score[100], i, cnt = 0;     int max[3];      for (i = 0; i < 100; i++) {         if (scanf(\"%d\", &score[i]) && score[i] >= 0) {             cnt++;             continue;         }         break;     }      max[0] = max[1] = max[2] = -1;     for (i = 0; i < cnt; i++) {         if (score[i] > max[0]) {             max[2] = max[1];             max[1] = max[0];             max[0] = score[i];         } else if (score[i] > max[1]){             max[2] = max[1];             max[1] = score[i];         } else if (score[i] > max[2]) {             max[2] = score[i];         }     }      printf(\"%d,%d,%d\\n\", max[0], max[1], max[2]);      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "录入的时候就可以找前三大了，可以优化不用两个循环", "referer": "user-1"}, {"cid": "3", "user": "user-3", "content": "这个就是排序吧，很简答的吧。你是想知道思路还是代码", "referer": "user-0"}]}
{"question": "急求解！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考： #include<stdio.h>  int main() {     double S=1.0,eps,tmp=1.0;     int    N=1;     scanf(\"%lf\",&eps);     while(tmp >= eps){           tmp *= 1.0/N;           S += tmp;           N ++;     }     printf(\"e=%.3f,count=%d\\n\",S,N);         return 0; }", "referer": "user-0"}]}
{"question": "输出上三角数字阵列.求解急", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考： #include<stdio.h> int main() {     int i,j,n,m;     scanf(\"%d%d\",&n,&m);     for(i=n-1;i>=0;i--)     {         for(j=0;j<=i;j++)         {             printf(\"%-4d\",m++);         }         printf(\"\\n\");     }          return 0; }", "referer": "user-0"}]}
{"question": "这个错误怎么改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> int option; void AddNew() {     //TODO } void FindMenu() {     //TODO } void ModifyData() {     //TODO } void Delete() {     //TODO } void MainMenu() {     system(\"cls\");     printf(\"主菜单：\\n\");     printf(\"1,  添加信号机：    \\n\");     printf(\"2,  查看信号机：    \\n\");     printf(\"3,  修改信号机信息：\\n\");     printf(\"4,  删除信号机：    \\n\");     printf(\"5,  退出程序：      \\n\");     printf(\"请选择：            \\n\");     scanf(\"%d\",&option);     getchar(); } int main() {     MainMenu();     switch (option)     {     case 1:AddNew()        ;break;     case 2:FindMenu()    ;break;     case 3:ModifyData()    ;break;     case 4:Delete()        ;break;     case 5:exit(0);     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "嗯，谢谢“赵4老师”。", "referer": "user-1"}]}
{"question": "小白求一段字符串截取方法。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <string.h> int main() {     char p[]=\"/data/detect/20210630/OPIA2021063099459/f93fb93a70ee4f048f3e35445d10fd57.jpg\";     char *q;     q=strrchr(p,'/');     if (q) {         q[1]=0;         printf(\"%s\\n\",p);// \"/data/detect/20210630/OPIA2021063099459/\"     } else {         printf(\"Can not find / in %s\\n\",p);     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "赵老师武威", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "要是可修改，就从后往前查找 / 字符，然后把它后面一个位置赋值为'\\0'。", "referer": "user-0"}]}
{"question": "求助一道strout strerr问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为stout和stderr是两个不同的输出管道，且输出字符串没有以'\\n'结尾且没有fflush,输出都被缓存在各自管道的内部缓冲区中，直到程序退出前，输出缓冲区中的信息才会被flush而一起显示。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢！", "referer": "user-1"}]}
{"question": "浙江大学PTA练习4-11", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "只需遍历2 ~ sqrt(n)之间的整数去除就可以了", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：  #include<stdio.h>  int f(int);   int main() {     int a,b,count,s,c,i;     scanf(\"%d %d\",&a,&b);     count=0;     s=0;     for(i=a;i<=b;i++){         if(f(i)!=0){             count++;             s += i;         }     }     printf(\"%d %d\\n\",count,s);          return 0; }   int f(int n) {     int i;     if(n <= 3) return n>1;     for(i=2;i*i <= n;i++)        if(n%i == 0) return 0;     return 1; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "大概不是错了，而是慢了吧？", "referer": "user-0"}]}
{"question": "为什么保存到文件的数据不是十进制的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两次打开文件； 写文件时那些变量取地址干嘛； 第四个格式符也不对，那是浮点的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你所指的十进制可能是想保存的文本文件看起来和输入的一样吧，是这样的话，保存时必须把数据转换成字符或字符串再按字符串保存，正常情况保存，都是二进制的，比如 字母 '1'  保存时值是49，十六进制为31，虽然你保存的文件指定后缀名为.txt,但值不会自动为你变成文本. 数字123 ,保存时就是31 32 33 ，保存到文本文件看起来要是123，那就要转换成字符串再保存，读取回来时也要将字符串“123” 转换成数字123", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……   推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。", "referer": "user-0"}]}
{"question": "c语言如何让一组数据跟着另一组数据变动", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把代码贴上来，才可以帮到你。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "给学生排名时，如何让每个人各科的成绩与他们的总成绩相对应，（每次我把总成绩排出来了，但是每个人的成绩没有变),设置一个结构体变量 struct student temp;  ，然后整体搬迁。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "指针指向同一个实体。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "不知道你问的是啥意思。", "referer": "user-0"}]}
{"question": "为什么我这个代码会缓冲区溢出想两天了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，掰手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <string.h> #define LEN 8 char * mystrncat(char*,char*,int); int main(void) {     char s1[LEN],s2[LEN];      while (fgets(s1,LEN,stdin)!=NULL&&(s1[0]!='\\n')) {         fgets(s2,LEN,stdin);         printf(\"\\n%s\",mystrncat(s1,s2,LEN));     }     printf(\"Bye.\\n\");     return 0; } char * mystrncat(char*s1,char*s2,int n) {     char* ps=s1;      for (;*ps!='\\n'&&*ps!='\\0';ps++)         continue;      for(int i=0;i<=(n-1);i++,ps++)         *ps=s2[i];      *ps='\\0';      return s1; } //1234 //abcde // //1234abcde // //Bye. //  显然结果超出了LEN个字符，即缓冲区溢出。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你从一个总长度80的数组中间某个位置开始写入80字节，溢出难道不是应该的么？", "referer": "user-0"}]}
{"question": "有一组关键码序列{12，5,9,20,6,31,24,27,13}", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "/*** *qsort.c - quicksort algorithm; qsort() library function for sorting arrays * *       Copyright (c) 1985-2001, Microsoft Corporation. All rights reserved. * *Purpose: *       To implement the qsort() routine for sorting arrays. * *******************************************************************************/  //#include <cruntime.h> #include <stdlib.h> #include <stdio.h> #include <search.h> //#include <internal.h>  /* Always compile this module for speed, not size */ #pragma optimize(\"t\", on)  /* prototypes for local routines */ static void __cdecl shortsort(char *lo, char *hi, size_t width,                 int (__cdecl *comp)(const void *, const void *)); static void __cdecl swap(char *p, char *q, size_t width);  /* this parameter defines the cutoff between using quick sort and    insertion sort for arrays; arrays with lengths shorter or equal to the    below value use insertion sort */  #define CUTOFF 8            /* testing shows that this is good value */  /*** *qsort(base, num, wid, comp) - quicksort function for sorting arrays * *Purpose: *       quicksort the array of elements *       side effects:  sorts in place *       maximum array size is number of elements times size of elements, *       but is limited by the virtual address space of the processor * *Entry: *       char *base = pointer to base of array *       size_t num  = number of elements in the array *       size_t width = width in bytes of each array element *       int (*comp)() = pointer to function returning analog of strcmp for *               strings, but supplied by user for comparing the array elements. *               it accepts 2 pointers to elements and returns neg if 1<2, 0 if *               1=2, pos if 1>2. * *Exit: *       returns void * *Exceptions: * *******************************************************************************/  /* sort the array between lo and hi (inclusive) */  #define STKSIZ (8*sizeof(void*) - 2)  void __cdecl myqsort (     void *base,     size_t num,     size_t width,     int (__cdecl *comp)(const void *, const void *)     ) {     /* Note: the number of stack entries required is no more than        1 + log2(num), so 30 is sufficient for any array */     char *lo, *hi;              /* ends of sub-array currently sorting */     char *mid;                  /* points to middle of subarray */     char *loguy, *higuy;        /* traveling pointers for partition step */     size_t size;                /* size of the sub-array */     char *lostk[STKSIZ], *histk[STKSIZ];     int stkptr;                 /* stack for saving sub-array to be processed */      if (num < 2 || width == 0)         return;                 /* nothing to do */      stkptr = 0;                 /* initialize stack */      lo = (char *)base;     hi = (char *)base + width * (num-1);        /* initialize limits */      /* this entry point is for pseudo-recursion calling: setting        lo and hi and jumping to here is like recursion, but stkptr is        preserved, locals aren't, so we preserve stuff on the stack */ recurse:      int *p;     int i;     for (i=0,p=(int *)base;i<(int)num;i++,p++) printf(\"%d \",*p);     printf(\"\\n\");      size = (hi - lo) / width + 1;        /* number of el's to sort */      /* below a certain size, it is faster to use a O(n^2) sorting method */     if (size <= CUTOFF) {         shortsort(lo, hi, width, comp);     }     else {         /* First we pick a partitioning element.  The efficiency of the            algorithm demands that we find one that is approximately the median            of the values, but also that we select one fast.  We choose the            median of the first, middle, and last elements, to avoid bad            performance in the face of already sorted data, or data that is made            up of multiple sorted runs appended together.  Testing shows that a            median-of-three algorithm provides better performance than simply            picking the middle element for the latter case. */          mid = lo + (size / 2) * width;      /* find middle element */          /* Sort the first, middle, last elements into order */         if (comp(lo, mid) > 0) {             swap(lo, mid, width);         }         if (comp(lo, hi) > 0) {             swap(lo, hi, width);         }         if (comp(mid, hi) > 0) {             swap(mid, hi, width);         }          /* We now wish to partition the array into three pieces, one consisting            of elements <= partition element, one of elements equal to the            partition element, and one of elements > than it.  This is done            below; comments indicate conditions established at every step. */          loguy = lo;         higuy = hi;          /* Note that higuy decreases and loguy increases on every iteration,            so loop must terminate. */         for (;;) {             /* lo <= loguy < hi, lo < higuy <= hi,                A[i] <= A[mid] for lo <= i <= loguy,                A[i] > A[mid] for higuy <= i < hi,                A[hi] >= A[mid] */              /* The doubled loop is to avoid calling comp(mid,mid), since some                existing comparison funcs don't work when passed the same                value for both pointers. */              if (mid > loguy) {                 do  {                     loguy += width;                 } while (loguy < mid && comp(loguy, mid) <= 0);             }             if (mid <= loguy) {                 do  {                     loguy += width;                 } while (loguy <= hi && comp(loguy, mid) <= 0);             }              /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,                either loguy > hi or A[loguy] > A[mid] */              do  {                 higuy -= width;             } while (higuy > mid && comp(higuy, mid) > 0);              /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,                either higuy == lo or A[higuy] <= A[mid] */              if (higuy < loguy)                 break;              /* if loguy > hi or higuy == lo, then we would have exited, so                A[loguy] > A[mid], A[higuy] <= A[mid],                loguy <= hi, higuy > lo */              swap(loguy, higuy, width);              /* If the partition element was moved, follow it.  Only need                to check for mid == higuy, since before the swap,                A[loguy] > A[mid] implies loguy != mid. */              if (mid == higuy)                 mid = loguy;              /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top                of loop is re-established */         }          /*     A[i] <= A[mid] for lo <= i < loguy,                A[i] > A[mid] for higuy < i < hi,                A[hi] >= A[mid]                higuy < loguy            implying:                higuy == loguy-1                or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */          /* Find adjacent elements equal to the partition element.  The            doubled loop is to avoid calling comp(mid,mid), since some            existing comparison funcs don't work when passed the same value            for both pointers. */          higuy += width;         if (mid < higuy) {             do  {                 higuy -= width;             } while (higuy > mid && comp(higuy, mid) == 0);         }         if (mid >= higuy) {             do  {                 higuy -= width;             } while (higuy > lo && comp(higuy, mid) == 0);         }          /* OK, now we have the following:               higuy < loguy               lo <= higuy <= hi               A[i]  <= A[mid] for lo <= i <= higuy               A[i]  == A[mid] for higuy < i < loguy               A[i]  >  A[mid] for loguy <= i < hi               A[hi] >= A[mid] */          /* We've finished the partition, now we want to sort the subarrays            [lo, higuy] and [loguy, hi].            We do the smaller one first to minimize stack usage.            We only sort arrays of length 2 or more.*/          if ( higuy - lo >= hi - loguy ) {             if (lo < higuy) {                 lostk[stkptr] = lo;                 histk[stkptr] = higuy;                 ++stkptr;             }                           /* save big recursion for later */              if (loguy < hi) {                 lo = loguy;                 goto recurse;           /* do small recursion */             }         }         else {             if (loguy < hi) {                 lostk[stkptr] = loguy;                 histk[stkptr] = hi;                 ++stkptr;               /* save big recursion for later */             }              if (lo < higuy) {                 hi = higuy;                 goto recurse;           /* do small recursion */             }         }     }      /* We have sorted the array, except for any pending sorts on the stack.        Check if there are any, and do them. */      --stkptr;     if (stkptr >= 0) {         lo = lostk[stkptr];         hi = histk[stkptr];         goto recurse;           /* pop subarray from stack */     }     else         return;                 /* all subarrays done */ }   /*** *shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays * *Purpose: *       sorts the sub-array of elements between lo and hi (inclusive) *       side effects:  sorts in place *       assumes that lo < hi * *Entry: *       char *lo = pointer to low element to sort *       char *hi = pointer to high element to sort *       size_t width = width in bytes of each array element *       int (*comp)() = pointer to function returning analog of strcmp for *               strings, but supplied by user for comparing the array elements. *               it accepts 2 pointers to elements and returns neg if 1<2, 0 if *               1=2, pos if 1>2. * *Exit: *       returns void * *Exceptions: * *******************************************************************************/  static void __cdecl shortsort (     char *lo,     char *hi,     size_t width,     int (__cdecl *comp)(const void *, const void *)     ) {     char *p, *max;      /* Note: in assertions below, i and j are alway inside original bound of        array to sort. */      while (hi > lo) {         /* A[i] <= A[j] for i <= j, j > hi */         max = lo;         for (p = lo+width; p <= hi; p += width) {             /* A[i] <= A[max] for lo <= i < p */             if (comp(p, max) > 0) {                 max = p;             }             /* A[i] <= A[max] for lo <= i <= p */         }          /* A[i] <= A[max] for lo <= i <= hi */          swap(max, hi, width);          /* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */          hi -= width;          /* A[i] <= A[j] for i <= j, j > hi, loop top condition established */     }     /* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,        so array is sorted */ }   /*** *swap(a, b, width) - swap two elements * *Purpose: *       swaps the two array elements of size width * *Entry: *       char *a, *b = pointer to two elements to swap *       size_t width = width in bytes of each array element * *Exit: *       returns void * *Exceptions: * *******************************************************************************/  static void __cdecl swap (     char *a,     char *b,     size_t width     ) {     char tmp;      if ( a != b )         /* Do the swap one character at a time to avoid potential alignment            problems. */         while ( width-- ) {             tmp = *a;             *a++ = *b;             *b++ = tmp;         } } int cmp(const void *pa, const void *pb) {     return *(int *)pa - *(int *)pb; } int main() {     int d[9]={12,5,9,20,6,31,24,27,13};     myqsort(&d[0],9,sizeof(int),cmp);     for (int i=0;i<9;i++) printf(\"%d \",d[i]);     return 0; } //12 5 9 20 6 31 24 27 13 //6 5 9 12 20 31 24 27 13 //5 6 9 12 20 31 24 27 13 //5 6 9 12 13 20 24 27 31 //", "referer": "user-0"}]}
{"question": "Java泛型看不懂 求代码注释解释 急急急！！万分感谢ballball!!!", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这里是C语言版面，这个问题应该发到Java版面去。", "referer": "user-0"}]}
{"question": "动态链表，有两个问题，能正常跑起来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "经过大半天的调试，总算发现了问题，最大的问题在于creat()函数在初始化链表的时候，多了一个节点没有加入到链表的末尾，导致链表丢失NULL没法正常结束，从而导致输出最后一个数据的时候会卡顿0.5s左右。同时也导致了，输出函数末尾或者主函数输出函数后的换行符失效(可能是链表没有NULL，没能正常过结束)。调试后的代码就能正常了，也不会卡顿 #include<stdio.h> #include<stdlib.h>  //定义结构体 struct Joseph {     int People;     int Jundge;     struct Joseph *next; }; #define Len sizeof(struct Joseph) typedef struct Joseph SCJP; int n = 1; //建立动态链表。 struct Joseph *creat(void) {     struct Joseph *head = NULL;     struct Joseph *p1, *p2;     p1 = p2 = NULL;     printf(\"请输入总计有多少个人：\");     int NumPeople = 0;     scanf_s(\"%d\", &NumPeople);     rewind(stdin);     while (1)                //输入人数优化     {         if (NumPeople == 0 || NumPeople == 1)         {             printf(\"请重新输入：\");             scanf_s(\"%d\", &NumPeople);         }         else break;     }     p2 = p1 = (struct Joseph*)malloc(Len);     p1->People = n;     while (1)                    //循环优化     {         if (n == 1)head = p1;         else         {             p2->next = p1;         }         if (n == NumPeople)break;       //位置修改，原导致链表丢失NULL的判断语句，         p2 = p1;         p1 = (struct Joseph*)malloc(Len);         n++;         p1->People = n;     }     p1->next = NULL;     return(head); } int main(void) {     struct Joseph *p_head = NULL;     p_head = creat();     void Print_Link(struct Joseph *p);     Print_Link(p_head);     printf(\"\\n\");                        //原换行符无效的地方     free(p_head);     return 0; } //输出函数，检测输入人员编号是否有问题。 void Print_Link(struct Joseph *p) {     SCJP *Print_Temp = p;     int count = 1;     if (Print_Temp != NULL)     do{         printf(\" %5d\", Print_Temp->People);    //换行符在此有效，         if ((count++) % 15 == 0)             printf(\"\\n\");                             //原换行符无效的地方         //fflush(stdout);         Print_Temp = Print_Temp->next;     } while (Print_Temp != NULL);     fflush(stdout);     printf(\"\\n\");                                    //原换行符无效的地方     return; }     //fflush(stdout);     //printf(\"\\n\");                                    //原换行符无效的地方     return; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。 do语句也一样！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "好的，我再试试。", "referer": "user-1"}, {"cid": "4", "user": "user-1", "content": "在每个最后不带\\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 [size=24px][code=c]//请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。[/code][/size]", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "4老师牛逼。", "referer": "user-1"}, {"cid": "6", "user": "user-0", "content": "去查了一下一下fflush和rewind的用法，然后加上去好像还是没法控制换行。", "referer": "user-1"}]}
{"question": "最后一位数据后面的逗号怎么消除", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1、楼主你的代码不输出逗号啊？ 2、如果要以眼睛为标准，可以最后printf(\"\\b\\n\"); 3、转换一下思路，你以为是每个数后面带逗号，能不能想象第一个数专门输出为啥也不带，然后循环输出每个数前面带逗号呢？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "正解。", "referer": "user-1"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> int main() {     int n,i;     scanf(\"%d\", &n);     int a[n];     for(i=0;i<n;i++) {         scanf(\"%d\",&a[i]);     }     for(i=0;i<n;i++) {         if( i % 2 != 0) {              printf(\"%d\",a[i]);             if (i != n-1 && i != n-2)                  printf(\",\");         }     }     printf(\"\\n\");     return 0; }", "referer": "user-0"}]}
{"question": "堆区内存释放的疑问!", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以，注意在主函数异常处理时，该释放的时候也要释放。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可以，只要在一个模块里面就行。 不能跨DLL，释放。 跨函数释放是没有问题的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "参考【算法分享】基于WinSocket的TCP分包组包传输算法_yiyefangzhou24的专栏-CSDN博客", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "这和是否主函数无关，如果是dll内部函数malloc的内存，只能在dll内部free，如果都在同一个空间，你说的可以。 malloc原则上谁申请谁释放原则，实在不行可以使用c++的string或者内存池", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "可以", "referer": "user-0"}]}
{"question": "怎么让之前输入的内容不影响到后面的输入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fflush(stdin) 清空输入缓冲区。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "在每个最后不带\\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 [size=24px][code=c]//请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。[/code][/size]", "referer": "user-0"}]}
{"question": "char *name[] = { \"Follow me\", \"BASIC\", \"Great Wall\" };", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "char *name[] = { \"Follow me\", \"BASIC\", \"Great Wall\" }; 要看编译器怎么处理，这样的字符指针数组一般是，存放3个整形指针，每个指针指向存放字符串的地址，字符串可能不连续在一起，一般可能是连续在一起（每个字符串后至少会有一个'\\0'，也可能编译器多加‘\\0'),所以地址差值不一定等于长度加一个0的位置", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用我惯用的方式表达，就是张三的鼻子到肚脐的距离是有意义的，但是张三的鼻子到李四的耳朵的距离在我们讨论的范畴下是没有意义的。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "四老师的解释是站在编译器开发者的角度，解释了一下编译器对静态地址的分配。 而站在程序猿的立场，你需要知道，那三个用于初始化指针数组的字符串，互相之间是没有法定关系的。 我的意思是，那三个字符串并不属于同一个数组什么的，是你把它们的地址组织成了一个数组，而已。 不是同一数组的元素地址之间求差无意义。 所以你那个差值，固然描述了你的机器上你的系统上这一时刻的事实，但它（差值）是个C范畴下的无意义的量。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "懂意思了，谢谢～", "referer": "user-2"}, {"cid": "5", "user": "user-3", "content": "刚在vs2019上测试了一下, 指针数组的各字符串元素并不一定要连续存储, 元素间的空白存储单元也是随机的.", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "我的理解，对齐到4的倍数。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "看了你的，发现明白了什么意思了。但是字符存储的时候一个字符不是占用1个字节吗？", "referer": "user-4"}, {"cid": "8", "user": "user-4", "content": "将地址对齐到4的倍数是为了让CPU读的时候不因为地址不是4的倍数分两次读或抛出异常。", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "//#pragma warning(disable:4996) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include<stdio.h> #include<string.h> void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,\"%08x -\",i+addr);             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);             sprintf(binstr,\"%s  \",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf(\"%s\\n\",binstr);         } else {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,\"%s   \",binstr);         }         sprintf(binstr,\"%s  \",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf(\"%s\\n\",binstr);     } } int main(void) {     char *name[] = { \"Follow me\", \"BASIC\", \"Great Wall\" };     printf(\"sizeof(name[0]):%d\\n\", sizeof(name[0]));     for (int i = 0; i < 3; i++)     {         printf(\"name[%d]:0x%p strlen(name[%d]):%d\\n\",i,name[i],i,strlen(name[i]));     }     HexDump((char *)(name[2]),48,(int)(name[0]));     return 0; } //sizeof(name[0]):4 //name[0]:0x00403074 strlen(name[0]):9 //name[1]:0x0040306C strlen(name[1]):5 //name[2]:0x00403060 strlen(name[2]):10 //00403074 - 47 72 65 61 74 20 57 61 6c 6c 00 00 42 41 53 49  Great.Wall..BASI //00403084 - 43 00 00 00 46 6f 6c 6c 6f 77 20 6d 65 00 00 00  C...Follow.me... //00403094 - 73 69 7a 65 6f 66 28 6e 61 6d 65 5b 30 5d 29 3a  sizeof(name[0]):  VC6 Release", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "#pragma warning(disable:4996) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include<stdio.h> #include<string.h> void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,\"%08x -\",i+addr);             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);             sprintf(binstr,\"%s  \",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf(\"%s\\n\",binstr);         } else {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,\"%s   \",binstr);         }         sprintf(binstr,\"%s  \",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf(\"%s\\n\",binstr);     } } int main(void) {     char *name[] = { \"Follow me\", \"BASIC\", \"Great Wall\" };     printf(\"sizeof(name[0]):%d\\n\", sizeof(name[0]));     for (int i = 0; i < 3; i++)     {         printf(\"name[%d]:0x%p strlen(name[%d]):%d\\n\",i,name[i],i,strlen(name[i]));     }     HexDump((char *)(name[0]),48,(int)(name[0]));     return 0; } //sizeof(name[0]):4 //name[0]:0x003E2134 strlen(name[0]):9 //name[1]:0x003E2140 strlen(name[1]):5 //name[2]:0x003E2148 strlen(name[2]):10 //003e2134 - 46 6f 6c 6c 6f 77 20 6d 65 00 00 00 42 41 53 49  Follow.me...BASI //003e2144 - 43 00 00 00 47 72 65 61 74 20 57 61 6c 6c 00 00  C...Great.Wall.. //003e2154 - 73 69 7a 65 6f 66 28 6e 61 6d 65 5b 30 5d 29 3a  sizeof(name[0]):   VS2015 release", "referer": "user-0"}]}
{"question": "各位大神，下面这个C代码，转成Java代码该怎么写啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "基本运算java和C是一样的，把数据结构和函数转换过去就行了，例如char *变成String，memset和memcpy本质上是赋值操作", "referer": "user-0"}]}
{"question": "大学c语言考纲，运用c语言统计字符数组(“字符串”)中某个单词出现的次数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：  #include<stdio.h>  int main() {     int i=0;     char str[512],substr[32],*s=str,*p,*q;     gets(str);     getchar();     gets(substr);     while(*s){             p=s;             q=substr;             while(*q){                    if(*q==*p)                       {q++;p++;}                    else                       break;                    if(*q=='\\0')i++;           }           s++;     }     printf(\"%d\\n\",i);          return 0; }", "referer": "user-0"}]}
{"question": "C语言编写FFT程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fftw 凑字凑字。。。。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我做过c的FFT库，有现成代码。", "referer": "user-0"}]}
{"question": "为什么我按行读取txt是这样的呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：  //NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen(\"data.txt\",\"r\");     if (NULL==f) {         printf(\"Can not open file data.txt!\\n\");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,\"NAME: %31[^\\n]\",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,\"DIMENSION: %d\",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,\"DATA\\n\")) st=3;         } else if (st==3) {             if (3==sscanf(ln,\"%d%d%d\",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf(\"s.NAME=[%s]\\n\",s.NAME);     printf(\"s.DIMENSION=%d\\n\",s.DIMENSION);     for (i=0;i<n;i++) {         printf(\"s.DATA[%d].NO,X,Y=%d,%d,%d\\n\",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "就是还会多一行", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "那句格式读取文件改这样试试：fscanf(fp,\"%s %s %d %f %c %s %s\",L.elem[i].id,L.elem[i].name,&L.elem[i].inventory,&L.elem[i].price....)", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "可以哎！", "referer": "user-2"}, {"cid": "5", "user": "user-2", "content": "多一行这样改：while(1){},这里循环里改成1，文件读取那句改成：if（fscanf(fp,\"%s %s %d %f %c %s %s\",L.elem[i].id,L.elem[i].name,&L.elem[i].inventory,&L.elem[i].price....)!=7) break;", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "OK啦，谢谢！", "referer": "user-2"}]}
{"question": "萌新求带啊啊，为什么初始化的值会莫名其妙被改了。我定义的direction[0].incX=1,direction[0].incY=0;为什么被调用的时候都变为零了；", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "至少得是调用了 startdirtion()之后。 如果还发生值莫名其妙被改变，请参考下面：  #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "全局变量被显式赋值之前就应该是0来着。 您回避了这个关键点，就是上述图片是调试到哪个位置时的状态。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "我是在定义findpath里的  while (di &lt; 4)         {             system(\"pause\");             //system(\"cls\");             line = x + direction[di].incX;             col = y + direction[di].incY;  //加的断点", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "函数findpath里面的direction是来自形参的局部变量，并在函数调用时得到了一个错误的实参。 为什么不直接使用全局变量呢？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "啊 确实，我脑子可能瓦特了。而且我发现了更多错误，而且在findpath函数里调用的print函数打印不出来画面。问题越来越多了2333", "referer": "user-2"}, {"cid": "6", "user": "user-0", "content": "这是所有的代码。求教。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "#include<stdio.h> #include<malloc.h> #include<stdlib.h> #include<Windows.h> #define M 20//迷宫长度 #define N 20//迷宫宽度 int maze[M][N] = {0}; typedef struct//角色可行驶方向 {     int incX;     int incY; }Direction; Direction direction[4]; typedef struct Box//角色当前位置与当前方向 {     int dirction_x, dirction_y;     int dir;     struct Box* next; }BOX,*PBOX; typedef struct Stack {     PBOX pTop;     PBOX pBttom;                 }STACK,*PSTACK; void init(PSTACK S)//创建头节点 {     S->pTop = (PBOX)malloc(sizeof(BOX));     if (S->pTop == NULL)     {         printf(\"内存分配失败\");         exit(-1);     }     S->pBttom = S->pTop;     S->pTop->next = NULL; } void Push(PSTACK S,PBOX b) {     PBOX bNew = (PBOX)malloc(sizeof(BOX));     if (bNew)     {         bNew->dirction_x = b->dirction_x;         bNew->dirction_y = b->dirction_y;         bNew->dir = b->dir;         bNew->next = S->pTop;         S->pTop = bNew;     } } void Pop(PSTACK S,PBOX b) {     if (S->pTop == S->pBttom)return;     b->dirction_x = S->pTop->dirction_x;     b->dirction_y = S->pTop->dirction_y;     b->dir = S->pTop->dir;     PBOX L = S->pTop;     S->pTop = L->next;     free(L);     L = NULL; } void startdirtion()//填充行走方向 {     direction[0].incX = 1; direction[0].incY = 0;     direction[1].incX = 0; direction[1].incY = 1;     direction[2].incX = -1; direction[2].incY = 0;     direction[3].incX = 0; direction[3].incY = -1; } void print(int maze[M][N])//输出画面 {     for (int j = 0; j < N; j++)     {         for (int i = 0; i < M; i++)         {             if (maze[i][j] == 9)printf(\"@\");             if (maze[i][j] == 1)printf(\"#\");             if (maze[i][j] == 0)printf(\" \");         }         printf(\"\\n\");     } } bool findpath(int maze[M][N],Direction direction[],PSTACK S)//判断是否有路可走 {     BOX temp;     int x, y, di;     int line, col;     maze[1][1] = -1;     temp = { 1,1,-1 };     Push(S,&temp);     while (S->pTop != S->pBttom)     {         Pop(S,&temp);         x = temp.dirction_x; y = temp.dirction_y; di = temp.dir + 1;         while (di < 4)         {             system(\"pause\");             //system(\"cls\");             line = x + direction[di].incX;             col = y + direction[di].incY;             if (maze[line][col] == 0)             {                 temp = { x,y,di };                 Push(S, &temp);                 maze[x][y] = 9;                 print(maze);                 maze[x][y] = 0;                 x = line; y = col; maze[line][col] = -1;                 if (x == M && y == N)return true;                 else di = 0;             }             else di++;         }     }     return false; } void startmaze()//初始化迷宫 {     for (int i = 0; i < M; i++)//给迷宫上下两行的墙赋值     {         maze[i][0] = 1;         maze[i][N-1] = 1;     }     for (int i = 0; i < N; i++)//给左右赋值     {         maze[0][i] = 1;         maze[M-1][i] = 1;     } } void startdate()//数据集中初始化 {     startdirtion();     startmaze(); } int main() {     STACK S;     init(&S);     startdate();     //print(maze);     findpath(maze, &direction[4], &S);          char text = getchar(); }", "referer": "user-0"}]}
{"question": "在keil芯片仿真遇到单步调试与实际不符的情况", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "最终确认是因为没做好措施，因为静电原因导致的电路板某处短路，造成了一系列不正常的状况", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "经检查可能是某个引脚初始化的时候漏电了，，，，，，注释掉相关部分运行就没有问题了，但是这个初始化的部分和显示完全不沾边，，，，，等待后续检测", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "速度太快？", "referer": "user-0"}]}
{"question": "Vc++6.0清屏！！小白求带：（", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "system(\"cls\");不会退出程序吧，是你程序自己结束了？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "system(\"cls\");还有这功能?", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "请证明您的描述确有其事，然后再继续哭。", "referer": "user-0"}]}
{"question": "为什么用float配合%f会溢出用double配合%lf不会？？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "对于double的变量,scanf要用%lf，printf也建议用%lf", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "图文不一致，南辕北辙了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "1.C语言中printf输出float和double都可以用%f,而double型数据还可以用%lf。 2.scanf当中若是对双精度的变量赋值是必须是%后跟lf,而printf当中可以用%f也可以用%lf没有限制", "referer": "user-0"}]}
{"question": "一个关于结构指针的疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "注释的三行大约是p和t一起抄了第一名同学的作业，然后p撕掉了自己的作业本。 然而， 下面四行是说第一名同学小名叫做p，t童鞋抄了他的作业，然后p撕掉了自己的作业本。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我的问题是为什么运行注释掉的三行后hashtab[0]!=NULL, 而运行它下面的四行后, hashtab[0]==NULL?", "referer": "user-1"}, {"cid": "5", "user": "user-1", "content": "我说的正是这个事儿啊。 上面的第一名同学的作业还在，自然就不是NULL了； 下面的第一名同学作业被撕了，自然就NULL了。", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "不打比方的说法是，四行版里面*p就是hashtab[0]本身，你修改了人家的值。", "referer": "user-0"}]}
{"question": "vscode'cmd' 不是内部或外部命令，也不是可运行的程序或批处理文件。如何解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“终端”就是控制台 cmd.exe ，你所谓的“黑窗口”。 你或许需要呼吸点新鲜空气了。", "referer": "user-0"}]}
{"question": "求助帖", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "新改的论坛乱码了？？#include &lt;stdio.h&gt; 好像行了，显然不行，那是你的编译器放了你一马。多换几个编译器，早晚出错。 1. 用动态分配，楼上提到的malloc。 2. 定义一个足够大的数组。int Num[100]，假设输入的n小于100。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的，多谢，鄙人纯新手，感谢指教", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "#include <stdio.h> int main()  {     int n,i=0;     scanf(\"%d\",&n);     int Num[n];     while (i<=n)     {         if(i>=0&i<n)         {             scanf(\"%d\",&Num[i]);             i=i+1;         }              else         break;     } } 修改了一下，好像可以？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "int Num[n];这个C语言不清楚应该给这个数组Num定义多大，因为这个n是需要我们输入才会知道。所以，不建议这么写（C++可以）", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "好的好的，谢谢", "referer": "user-2"}, {"cid": "6", "user": "user-2", "content": "数组需要是一个定值（确定的）；如果要这么做也是可以，使用malloc吧；  #include <stdio.h> #include <stdlib.h> //Windows下用<malloc.h> int main()  {     int n,i=0;     scanf(\"%d\",&n);     int *N = (int *)malloc(sizeof(int) * n);//[n];     while (1)     {         for(i=0;i<n;i++)         scanf(\"%d\",&N[i]);     }     free(N);     return 0; } 供参考～", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "int *N = (int *)malloc(sizeof(int) * n);  这一语句的意思是不是定义一个个数为n的整型数组啊？ 另 #include &lt;stdio.h&gt; int main()  {     int n,i=0;     scanf(\"%d\",&n);     int Num[n];     while (i&lt;=n)     {         if(i&gt;=0&i&lt;n)         {             scanf(\"%d\",&Num[i]);             i=i+1;         }         else         break;     } } 这个好像可以实现读入一个个数已知的数组？", "referer": "user-2"}, {"cid": "8", "user": "user-3", "content": "数组n不能是变量", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "好的，感谢", "referer": "user-3"}, {"cid": "10", "user": "user-0", "content": "#include &lt;stdio.h&gt; int main()  {     int n,i=0;     scanf(\"%d\",&n);     int Num[n];     while (i&lt;=n)     {         if(i&gt;=0&i&lt;n)         {         \tscanf(\"%d\",&Num[i]);         \ti=i+1; \t\t} \t         else         break;     } } 这样好像就行了，不知道有没有问题？", "referer": "user-3"}, {"cid": "11", "user": "user-4", "content": "int N[n] 在编译的时候需要在栈上预分配n个int类型的空间, 但是你的n是一个变量, 一个不确定的变量. 这是错误的根本原因. 对照规则有2中修复方式: 1. n 定义为一个常量, 这个时候可以预分配成功. 2. 数组N 在堆上动态分配, 使用new操作符.", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "好的，感谢", "referer": "user-4"}, {"cid": "13", "user": "user-0", "content": "#include &lt;stdio.h&gt; int main()  {     int n,i=0;     scanf(\"%d\",&n);     int Num[n];     while (i&lt;=n)     {         if(i&gt;=0&i&lt;n)         {         \tscanf(\"%d\",&Num[i]);         \ti=i+1; \t\t} \t         else         break;     } } 这样好像就行了，不知道有没有问题？", "referer": "user-4"}]}
{"question": "C语言中如何处理10万组级别的数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要说什么栈空间。 楼主的代码别的不看，就那一个数组的大小，数一数，那是百万行百万列，4TB数量级。 我根本就不信楼主的机器有那么大的内存啊，包括虚拟的。你们信么？ ------------------------------------------------------------ 对数据规模我们应保有基本的敬畏。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "您好，多谢您的提醒， 1. 我现有的手上数据是10W行，2列，我如果用malloc分配内存空间的话，就需要2x10万x4字节=0.8Mb的空间，对吗?  2. 如果真的需要处理百万行与百万列的话，如果还是用malloc分配，是否只能在物理上扩大内存来解决？有其他途径吗？", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "0.8MB直接写数组就行。 但是真的那么大就只能一块一块处理了，先研究算法。 那么大的数据全部装进内存既不现实，也没必要。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "仅供参考：  #pragma warning(disable:4996 4244) #include <stdio.h> #include <string.h> #include <stdlib.h> #include <assert.h> #define MAXW 1024 char A[MAXW],B[MAXW]; FILE *fb; #define CUTOFF 8            /* testing shows that this is good value */  /* Note: the theoretical number of stack entries required is    no more than 1 + log2(num).  But we switch to insertion    sort for CUTOFF elements or less, so we really only need    1 + log2(num) - log2(CUTOFF) stack entries.  For a CUTOFF    of 8, that means we need no more than 62 stack entries for    64-bit platforms. */ //#define STKSIZ (8*sizeof(void*) - 2) #define STKSIZ   (8*8             - 2)  /*** *swap(a, b, w) - swap two elements * *Purpose: *       swaps the two file elements of size width * *Entry: *       long long int a, b = pointer to two elements to swap *       long long int width = width in bytes of each file element * *Exit: *       returns void * *Exceptions: * *******************************************************************************/  static void swap(     long long int a,     long long int b,     long long int w     ) {     if ( a != b ) {         _fseeki64(fb,a,SEEK_SET);         fread(A,w,1,fb);         _fseeki64(fb,b,SEEK_SET);         fread(B,w,1,fb);         _fseeki64(fb,a,SEEK_SET);         fwrite(B,w,1,fb);         _fseeki64(fb,b,SEEK_SET);         fwrite(A,w,1,fb);     } }  /*** *shortsort(hi, lo, width, comp) - insertion sort for sorting short file * *Purpose: *       sorts the file of elements between lo and hi (inclusive) *       side effects:  sorts in place *       assumes that lo < hi * *Entry: *       long long int lo = pointer to low element to sort *       long long int hi = pointer to high element to sort *       long long int width = width in bytes of each file element *       int (*comp)() = pointer to function returning analog of strcmp for *               strings, but supplied by user for comparing the file elements. *               it accepts 2 pointers to elements, together with a pointer to a context *               (if present). Returns neg if p1<p2, 0 if p1==p2, pos if p1>p2. * *Exit: *       returns void * *Exceptions: * *******************************************************************************/  static void shortsort(     long long int lo,     long long int hi,     long long int width,     int (*comp)(long long int, long long int,long long int)     ) {     long long int p, maxp;      /* Note: in assertions below, i and j are alway inside original bound of        file to sort. */      while (hi > lo) {         /* A[i] <= A[j] for i <= j, j > hi */         maxp = lo;         for (p = lo+width; p <= hi; p += width) {             /* A[i] <= A[maxp] for lo <= i < p */             if (comp(p, maxp, width) > 0) {                 maxp = p;             }             /* A[i] <= A[maxp] for lo <= i <= p */         }          /* A[i] <= A[maxp] for lo <= i <= hi */          swap(maxp, hi, width);          /* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */          hi -= width;          /* A[i] <= A[j] for i <= j, j > hi, loop top condition established */     }     /* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,        so file is sorted */ }  /*** *fqsort(base, num, width, comp) - quicksort function for sorting file * *Purpose: *   quicksort the file of elements *   side effects:  sorts in place *   maximum file size is number of elements times size of elements, *   but is limited by the file size of the OS and disk free space. * *Entry: *   long long int base = pointer to base of file *   long long int num  = number of elements in the file *   long long int width = width in bytes of each file element *   int (*comp)() = pointer to function returning analog of strcmp for *           strings, but supplied by user for comparing the file elements. *           it accepts 2 pointers to elements. *           Returns neg if p1<p2, 0 if p1==p2, pos if p1>p2. * *Exit: *   returns void * *Exceptions: *   Input parameters are validated. Refer to the validation section of the function. * *******************************************************************************/  void fqsort(     long long int base,     long long int num,     long long int width,     int (*comp)(long long int, long long int, long long int)     ) {     long long int lo, hi;              /* ends of sub-file currently sorting */     long long int mid;                  /* points to middle of subarray */     long long int loguy, higuy;        /* traveling pointers for partition step */     long long int size;                /* size of the sub-file */     long long int lostk[STKSIZ], histk[STKSIZ];     int stkptr;                 /* stack for saving sub-file to be processed */      /* validation section */     assert(base>=0 && num > 0);     assert(width > 0);     assert(comp != NULL);      if (num < 2)         return;                 /* nothing to do */      stkptr = 0;                 /* initialize stack */      lo = base;     hi = base + width * (num-1);        /* initialize limits */      /* this entry point is for pseudo-recursion calling: setting        lo and hi and jumping to here is like recursion, but stkptr is        preserved, locals aren't, so we preserve stuff on the stack */ recurse:      size = (hi - lo) / width + 1;        /* number of el's to sort */      /* below a certain size, it is faster to use a O(n^2) sorting method */     if (size <= CUTOFF) {         shortsort(lo, hi, width, comp);     }     else {         /* First we pick a partitioning element.  The efficiency of the            algorithm demands that we find one that is approximately the median            of the values, but also that we select one fast.  We choose the            median of the first, middle, and last elements, to avoid bad            performance in the face of already sorted data, or data that is made            up of multiple sorted runs appended together.  Testing shows that a            median-of-three algorithm provides better performance than simply            picking the middle element for the latter case. */          mid = lo + (size / 2) * width;      /* find middle element */          /* Sort the first, middle, last elements into order */         if (comp(lo, mid, width) > 0) {             swap(lo, mid, width);         }         if (comp(lo, hi, width) > 0) {             swap(lo, hi, width);         }         if (comp(mid, hi, width) > 0) {             swap(mid, hi, width);         }          /* We now wish to partition the file into three pieces, one consisting            of elements <= partition element, one of elements equal to the            partition element, and one of elements > than it.  This is done            below; comments indicate conditions established at every step. */          loguy = lo;         higuy = hi;          /* Note that higuy decreases and loguy increases on every iteration,            so loop must terminate. */         for (;;) {             /* lo <= loguy < hi, lo < higuy <= hi,                A[i] <= A[mid] for lo <= i <= loguy,                A[i] > A[mid] for higuy <= i < hi,                A[hi] >= A[mid] */              /* The doubled loop is to avoid calling comp(mid,mid,width), since some                existing comparison funcs don't work when passed the same                value for both pointers. */              if (mid > loguy) {                 do  {                     loguy += width;                 } while (loguy < mid && comp(loguy, mid, width) <= 0);             }             if (mid <= loguy) {                 do  {                     loguy += width;                 } while (loguy <= hi && comp(loguy, mid, width) <= 0);             }              /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,                either loguy > hi or A[loguy] > A[mid] */              do  {                 higuy -= width;             } while (higuy > mid && comp(higuy, mid, width) > 0);              /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,                either higuy == lo or A[higuy] <= A[mid] */              if (higuy < loguy)                 break;              /* if loguy > hi or higuy == lo, then we would have exited, so                A[loguy] > A[mid], A[higuy] <= A[mid],                loguy <= hi, higuy > lo */              swap(loguy, higuy, width);              /* If the partition element was moved, follow it.  Only need                to check for mid == higuy, since before the swap,                A[loguy] > A[mid] implies loguy != mid. */              if (mid == higuy)                 mid = loguy;              /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top                of loop is re-established */         }          /*     A[i] <= A[mid] for lo <= i < loguy,                A[i] > A[mid] for higuy < i < hi,                A[hi] >= A[mid]                higuy < loguy            implying:                higuy == loguy-1                or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */          /* Find adjacent elements equal to the partition element.  The            doubled loop is to avoid calling comp(mid,mid,width), since some            existing comparison funcs don't work when passed the same value            for both pointers. */          higuy += width;         if (mid < higuy) {             do  {                 higuy -= width;             } while (higuy > mid && comp(higuy, mid, width) == 0);         }         if (mid >= higuy) {             do  {                 higuy -= width;             } while (higuy > lo && comp(higuy, mid, width) == 0);         }          /* OK, now we have the following:               higuy < loguy               lo <= higuy <= hi               A[i]  <= A[mid] for lo <= i <= higuy               A[i]  == A[mid] for higuy < i < loguy               A[i]  >  A[mid] for loguy <= i < hi               A[hi] >= A[mid] */          /* We've finished the partition, now we want to sort the subarrays            [lo, higuy] and [loguy, hi].            We do the smaller one first to minimize stack usage.            We only sort arrays of length 2 or more.*/          if ( higuy - lo >= hi - loguy ) {             if (lo < higuy) {                 lostk[stkptr] = lo;                 histk[stkptr] = higuy;                 ++stkptr;             }                           /* save big recursion for later */              if (loguy < hi) {                 lo = loguy;                 goto recurse;           /* do small recursion */             }         }         else {             if (loguy < hi) {                 lostk[stkptr] = loguy;                 histk[stkptr] = hi;                 ++stkptr;               /* save big recursion for later */             }              if (lo < higuy) {                 hi = higuy;                 goto recurse;           /* do small recursion */             }         }     }      /* We have sorted the file, except for any pending sorts on the stack.        Check if there are any, and do them. */      --stkptr;     if (stkptr >= 0) {         lo = lostk[stkptr];         hi = histk[stkptr];         goto recurse;           /* pop subarray from stack */     }     else         return;                 /* all subarrays done */ }   /*** *long long int fbsearch() - do a binary search on an file * *Purpose: *   Does a binary search of a sorted file for a key. * *Entry: *   const void *key    - key to search for *   const long long int base   - base of sorted file to search *   unsigned int num   - number of elements in file *   unsigned int width - number of bytes per element *   int (*compare)()   - pointer to function that compares key and file *           elements, returning neg when #1 < #2, pos when #1 > #2, and *           0 when they are equal. Function is passed pointers to key *           and pointer to file elements. * *Exit: *   if key is found: *           returns pointer to occurrence of key in file *   if key is not found: *           returns -1 * *Exceptions: *   Input parameters are validated. Refer to the validation section of the function. * *******************************************************************************/  long long int fbsearch(     const void *key,     long long int base,     long long int num,     long long int width,     int (*compare)(const void *, long long int, long long int)     ) {     long long int lo = (long long int)base;     long long int hi = (long long int)base + (num - 1) * width;     long long int mid;     long long int half;     int result;      /* validation section */     assert(base>=0 && num > 0);     assert(width > 0);     assert(compare != NULL);          /*         We allow a NULL key here because it breaks some older code and because we do not dereference         this ourselves so we can't be sure that it's a problem for the comparison function         */      while (lo <= hi)     {         if ((half = num / 2) != 0)         {             mid = lo + (num & 1 ? half : (half - 1)) * width;             if (!(result = compare(key, mid, width)))                 return(mid);             else if (result < 0)             {                 hi = mid - width;                 num = num & 1 ? half : half-1;             }             else             {                 lo = mid + width;                 num = half;             }         }         else if (num)             return (compare(key, lo, width) ? -1 : lo);         else             break;     }      return -1; } int cmp(long long int a, long long int b, long long int w) {     _fseeki64(fb,a,SEEK_SET);     fread(A,w,1,fb);     _fseeki64(fb,b,SEEK_SET);     fread(B,w,1,fb);     return strncmp(A,B,w); } int cmps(const void *k, long long int b, long long int w) {     _fseeki64(fb,b,SEEK_SET);     fread(B,w,1,fb);     return strncmp((const char *)k,B,w); } void test(int n,int w,void *k1,void *k2) {     int i,v;     long long int r;      assert(w<MAXW);     fb=fopen(\"test.bin\",\"wb\");     if (NULL==fb) {         printf(\"Can not create file test.bin!\\n\");         return;     }     for (i=0;i<n;i++) {         v=10+rand()%90;         printf(\"%02d \",v);         fprintf(fb,\"%02d\\r\\n\",v);     }     printf(\"\\n\");     fclose(fb);      fb=fopen(\"test.bin\",\"rb+\");     if (NULL==fb) {         printf(\"Can not open file test.bin!\\n\");         return;     }     fqsort(0,n,w,cmp);     r=fbsearch(k1,0,n,w,cmps);     printf(\"%s r1:%lld\\n\",k1,r);     r=fbsearch(k2,0,n,w,cmps);     printf(\"%s r2:%lld\\n\",k2,r);     fclose(fb);     system(\"type test.bin\"); } int main() {     srand(0);      test(  8,4,\"75\\r\\n\",\"12\\r\\n\");     test(100,4,\"94\\r\\n\",\"95\\r\\n\");      return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "栈没那么大，前面加上static试试，如果不行，建议把数组定义为合适的大小，数组定义这么大，是可以存放10w × 10w个float数据的，这个是你需要的大小吗？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "即使加上static不合适，那么把数组定义成合适大小，也需要加上static", "referer": "user-3"}, {"cid": "7", "user": "user-4", "content": "使用文件游标,一次读一部分数据(固定行数,比如100行)到缓冲区处理.", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "把数组a做成全局变量，或者用动态内存分配。", "referer": "user-0"}]}
{"question": "C语言-求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "typedef struct Student {     double num;     //struct Studnet *next;     struct Student *next; }stu; 单词拼写错误，比较低级的错误～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> typedef struct Student { \tdouble num; \tstruct Student* next; } *stu;  int main() { \tstu student(int),  head; \tvoid sum(stu  head,double *,double *,double *); \tint n; \tdouble sums,max,min;  \tscanf_s(\"%d\", &n); \thead = student(n); \tsums = max = 0.0; \tsum(head,&sums,&max,&min); \tprintf(\"average = %.1f\\nmax = %.1f\\nmin = %.1f\", sums / n, max, min); \treturn 0; } stu student(int n) { \tstu head,  p;  \thead = NULL; \twhile (n > 0) { \t\tp = (stu)(malloc(sizeof(struct Student))); \t\tif (p == NULL) \t\t\treturn NULL; \t\tscanf_s(\"%lf\", &p->num); \t\tp->next = head; \t\thead = p; \t\tn--; \t} \treturn head; } void sum(stu head,double* sums,double *max,double *min) { \tstu p; \tp = head; \t*min = p->num; \twhile (p != NULL) { \t\t*sums +=  p->num; \t\tif (p->num > *max) { \t\t\t*max = p->num; \t\t} else if (p->num < *min) { \t\t\t*min = p->num; \t\t} \t\tp = p->next; \t}  }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "typedef struct Student { \tdouble num; \tstruct Studnet *next; }stu;  结构体重的 struct Studnet *next；中的Studnet拼写错误，应该是struct Student *next", "referer": "user-0"}]}
{"question": "请问这个语句怎么改写，提示 将 NULL 转换到非指针类型‘char’ ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "全局变量（或静态变量）不手动初始化，系统会默认给初始化的。即static CMDS commands;这样定义，系统会给初始化的，默认是0和NULL，字符串是'\\0'", "referer": "user-0"}]}
{"question": "请问 关于读 TXT文件到 结构体 关于typedef void (*handler)(void) 这样的如何赋值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "既然是格式化的数据内容，可以用fscanf读取； on / off这些可以直接赋值，函数指针就不能用字符串直接赋值了。可以比较字符串比如strcmp(str, \"Cmd_on\");然后xxx.cmd_operate = Cmd_on;    cmd_operate", "referer": "user-0"}]}
{"question": "请教诸位大佬，关于一定范围内隔数随机数的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "提供一种思路   #include <stdio.h> #include <stdlib.h> #include <time.h>  /*生成随机数 6，10，14，18，22 */  int GenerateSpecifyRandomNumber(int baseNumber) {     return baseNumber + rand() % 5 * 4; }  int main() {     srand((unsigned int)time(NULL));     int randomNumber;     for (int i = 0; i < 10; i++)     {         randomNumber = GenerateSpecifyRandomNumber(6);         printf(\"%d\\n\", randomNumber);     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的 我再仔细看看  万分感谢", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "将这四个数放到数组里，然后随机产生两个数（数组下表），只要随机产生的这两个数（5个数，对5取余）相差1，那么这两个数作为下表对应的数就是相差4的～", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "原来是这样 因为还没有学到数组 所以没想到这里   感谢大佬", "referer": "user-2"}]}
{"question": "Mips 怎么读取 cache 命中率", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "查对应的芯片手册，找到对应的cache章节的寄存器，看有没有你需要的寄存器。 顺便说一句，性能的提升一般来通过算法来解决，代码级的优化把常用的结构体尽量cache line对齐。", "referer": "user-0"}]}
{"question": "【求助】有无大佬知道如何用C语言去编写CGI通信录", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "长大？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "是，呜呜呜", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "CGI是一个接口，可以网上搜一下CGI源码～", "referer": "user-0"}]}
{"question": "为啥会是b=0.000000", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf(\"b=%f\",&b); 去掉b前面的&就好了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "//printf(\"b=%f\",&b);     printf(\"b=%f\",b); &b是地址，类型是unsigned long类型，用%f输出unsigned long，得到是是0.00000正常的，建议看一下浮点型和整型变量在内存里的表示方法，它们是有区别的。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "输出变量的值: printf(\"b=%f\",b); 输出存放变量值的地址:printf(\"%p\",&b);", "referer": "user-0"}]}
{"question": "关于Visual Studio 2015下载后不能使用的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "安装的时候不能直接选择下一步，要手动选择所需要的功能，默认不安装c++环境的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "显然安装错了工作负荷, 应安装\"使用C++的桌面开发\"; 可以运行\"Visual studio Installer\"修改.", "referer": "user-0"}]}
{"question": "求助帖", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个函数返回值是   int * 指针，这个指针指向  int* ret = malloc(sizeof(int) * 2);   ret[2]数组。", "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"}]}
{"question": "C初学者的求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "试试这样：  #include <stdio.h> #include <windows.h> #include <math.h> #include <string.h> int main() { \tint i = 0; \tconst char *s = \"你好，我的朋友。\\n\"; \tint size = strlen(s);          printf(\"%c\",s[0]);         printf(\"%c\",s[1]);         printf(\"\\n\");  \tprintf(\"size = %d\", size); \t }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我大概知道了。char类型1个字节装不下中文，中文应该是多个字节储存的，所以size才会为17。只输出s[0]，屏幕上不会显示中文，但是在后面接上s[1]时，s[0]和s[1]组成了中文符号“你”。 但让我疑惑的时s[0]和s[1]进行了什么运算或者过程，最终才会显示为中文。 我还是什么都不知道。", "referer": "user-1"}, {"cid": "3", "user": "user-1", "content": "去了解下汉字的编码方式。", "referer": "user-0"}]}
{"question": "有人可以帮我分析一下每条语句的作用是什么吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。 VS IDE中，在不明白的符号上点鼠标右键，选转到定义。", "referer": "user-0"}]}
{"question": "帮帮新手c语言程序出现问题无法输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改如下，供参考：  #include<stdio.h> #include<string.h> #include<stdlib.h> #include<conio.h>  #define MAX 100  struct Book {     char ids[16];     //订单号     char date[32];       //订票日期     char name[16];   //航空公司名称     char hangban[16];//航班号     char src[16];   //出发地     char dst[16];   //目的地     int  price;      //票价     char guest[20];  //订票人名     char guid[20];   //订票人身份证号 };  typedef struct Book* PBook;  //显示菜单 void displayMenu() {  system(\"CLS\");//清屏  printf(\"-------订票系统-------\\n\");  printf(\"-----1.添加航班-------\\n\");  printf(\"-----2.修改航班-------\\n\");  printf(\"-----3.删除航班-------\\n\");  printf(\"----4.按编号查找航班--\\n\");  printf(\"----5.按名称查找航班--\\n\");  printf(\"----6.显示航班列表----\\n\");  printf(\"-------7.退出---------\\n\");  printf(\"-------输入选项:------\\n\"); } //显示指航班信息 void display(PBook pBook) {    printf(\"订单号  订单日期   航空公司名称   航班号  出发地  目的地  票价  姓名  身份证\\n\");    printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%d\\t%s\\t%s\\n\",pBook->ids,pBook->date,pBook->name,pBook->hangban,                                     pBook->src,pBook->dst,pBook->price,pBook->guest,pBook->guid); } //显示所有航班列表 void displayList(PBook list,int count) {    printf(\"列表:\\n\");    printf(\"航班号  出发地 目的地  票价\\n\");    for(int i=0;i<count;i++)    {       printf(\"%s\\t%s\\t%s\\t%d\\n\",list[i].hangban,list[i].src,list[i].dst,list[i].price);    } } //添加航班  void add(PBook list,int* count) {    int n;    PBook pBook;    printf(\"添加航班数量:\");    scanf(\"%d\",&n);    for(int i=0;i< n;(*count)++,i++)    {                                          //pBook=(PBook)malloc(sizeof(struct Book));         printf(\"----第%d个航班：----\\n\",i+1);         strcpy(list[(*count)].ids, \"010\");         strcpy(list[(*count)].date,\"2021.6.12\");         printf(\"航空公司名称:\");         fflush(stdout);rewind(stdin);         scanf(\"%s\",list[(*count)].name);    // pBook->name);         printf(\"航班号\");         fflush(stdout);rewind(stdin);         scanf(\"%s\",list[(*count)].hangban);   //pBook->hangban);         printf(\"出发地:\");         fflush(stdout);rewind(stdin);         scanf(\"%s\",list[(*count)].src);      //pBook->src);         printf(\"目的地:\");         fflush(stdout);rewind(stdin);         scanf(\"%s\",list[(*count)].dst);       //pBook->dst);         printf(\"票价:\");         fflush(stdout);rewind(stdin);         scanf(\"%d\",&list[(*count)].price);     //&pBook->price);         printf(\"姓名：\");         fflush(stdout);rewind(stdin);         scanf(\"%s\",list[(*count)].guest);     //pBook->guest);         printf(\"身份证:\");         fflush(stdout);rewind(stdin);         scanf(\"%s\",list[(*count)].guid);      //pBook->guid);    } } //修改 void update(PBook list,int count) {    char temp[20];    printf(\"要修改航班号:\");    fflush(stdout);rewind(stdin);    scanf(\"%s\",temp);    for(int i=0;i<count;i++)    {       if(strcmp(list[i].hangban,temp)==0)       {           printf(\"航班号:\");           fflush(stdout);rewind(stdin);           scanf(\"%s\",list[i].hangban);           printf(\"姓名:\");           fflush(stdout);rewind(stdin);           scanf(\"%s\",list[i].guest);           printf(\"身份证:\");           fflush(stdout);rewind(stdin);           scanf(\"%s\",list[i].guid);           printf(\"修改成功!\\n\");           return;       }    }    printf(\"没有找到该航班!\"); } //删除 void del(PBook list,int* count) {    char temp[20];    printf(\"要删除航班号:\");    fflush(stdout);rewind(stdin);    scanf(\"%s\",temp);    for(int i=0;i<(*count);i++)    {        if(strcmp(list[i].hangban,temp)==0)        {            //PBook pBook=list[i];            for(int j=i;j<(*count)-1;j++)            {                list[j]=list[j+1];            }            //delete(pBook);            (*count)--;            printf(\"删除成功!\\n\");            return;        }    }    printf(\"没有找到该航班!\"); } //按航班查询 void searchById(PBook list,int count) {    char temp[20];    printf(\"要查找的航班号:\");    fflush(stdout);rewind(stdin);    scanf(\"%s\",temp);    for(int i=0;i<count;i++)    {        if(strcmp(list[i].hangban,temp)==0)        {             display((list+i));             return;        }    }    printf(\"没有找到该航班!\"); } //按姓名查询 void searchByName(PBook list,int count) {    char temp[20];    printf(\"要查找的姓名:\");    fflush(stdout);rewind(stdin);    scanf(\"%s\",temp);    for(int i=0;i<count;i++)    {        if(strcmp(list[i].guest,temp)==0)        {            display(list+i);            return;        }    }    printf(\"没有找到该航班!\"); }  /**/ void main() {    PBook list;    int   count=0;    char  key;    list=(PBook)malloc(MAX*sizeof(struct Book));    while(1)    {         displayMenu();         fflush(stdin);//清除输入缓存         key=getchar();         switch(key)         {                   case '1'://添加                            add(list,&count);                            break;                   case '2'://修改                            update(list,count);                            break;                   case '3'://删除                            del(list,&count);                            break;                   case '4'://按航班号查找                            searchById(list,count);                            break;                   case '5'://按姓名查找                            searchByName(list,count);                            break;                   case '6'://显示列表                            displayList(list,count);                            break;                   case '7'://退出                            return;                            break;                    default:                            break;         }         printf(\"按任意键返回..\");         getch();    } }", "referer": "user-0"}]}
{"question": "10进制转2进制时带有小数的该怎么转换", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "浮点数格式 [url=http://bbs.csdn.net/topics/390676437][/url]", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "整数转除2取余，小数部分乘2，取积的整数部分。", "referer": "user-0"}]}
{"question": "那位大佬帮我看一下这个程序 非常简单", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>  int format(char* str, int* cnt) {   if (!str || !cnt) return -1;    if (strlen(str) == 0) {     printf(\"###\\n\");     return 0;   }    *cnt = 0;   int len = strlen(str);   char* tmp = (char*)malloc(strlen(str) * sizeof(char));   memset(tmp, 0, strlen(str) * sizeof(char));   for (int i = 0; i < strlen(str); i++) {     if (str[i] == '#') {       *cnt += 1;       if (i) *(tmp + i) = ' ';     } else       *(tmp + i) = *(str + i);   }   if (strlen(tmp) == 0) {     printf(\"###\\n\");   } else if (str[0] == '#' && str[strlen(str) - 1] == '#') {     printf(\"%d %d %s\\n\", *cnt - 1, *cnt, tmp);   } else if (str[0] != '#' && str[strlen(str) - 1] != '#') {     printf(\"%d %d %s\\n\", *cnt + 1, *cnt, tmp);   } else {     printf(\"%d %d %s\\n\", *cnt, *cnt, tmp);   }   if (!tmp) free(tmp);   return 0; }  int main() {   int line = 0;   scanf(\"%d\", &line);   while (line--) {     char input[128] = {0};     scanf(\"%s\", input);     int cnt = 0;     int len = strlen(input);     if (format(input, &cnt)) return -1;   }   return 0; }", "referer": "user-0"}]}
{"question": "请教一个函数指针的问题。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "自问自答了！直接汇编调试时可以发现，ptr 指针里 的值里的地址存放的是一条 jmp 跳转指令，直接跳转到了 Add 函数的首地址，不是我之前想象中的把 add 的地址直接赋值给 ptr....", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "// ConsoleApplication2.cpp : 此文件包含 \"main\" 函数。程序执行将在此处开始并结束。 //  #include <iostream>   int(*ptr)(int, int);  int Add(int c1, int c2) { \treturn c1 + c2; } int main(int, char**) { \tint a = 10; \tint b = 20; \tint c = 0;  \tc = a;  \tptr = &Add; \tusing namespace std; \tcout << Add << endl; \tcout << ptr << endl;  \treturn 0; }   00791195 00791195 C:\\Users\\Administrator\\source\\repos\\ConsoleApplication2\\Debug\\ConsoleApplication2.exe (进程 5736)已退出，返回代码为: 0。 按任意键关闭此窗口...", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "麻烦您再帮我看看。我的问题在哪儿。", "referer": "user-1"}, {"cid": "5", "user": "user-0", "content": "调试栏的地址为啥不一样咧？", "referer": "user-1"}, {"cid": "6", "user": "user-1", "content": "你的cmd显示是正确的。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "ptr=&Add  ptr是一个函数指针类型变量，它指向了Add这地址，他就是Add这个函数啊", "referer": "user-0"}]}
{"question": "【C语言】纯char实现超大数运算", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：  #include <stdio.h> #include <string.h> #define MAXLEN 1000 char a1[MAXLEN]; char a2[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; void main(void) {     scanf(\"%d\",&n);     for (j=0;j<n;j++) {         scanf(\"%s%s\",a1,a2);          L=strlen(a1);         for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';          L=strlen(a2);         for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';          for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];          for (i=0;i<MAXLEN;i++) {             if (v3[i]>=10) {                 v3[i+1]+=v3[i]/10;                 v3[i]=v3[i]%10;             }         }          printf(\"Case %d:\\n\", j+1);         printf(\"%s + %s = \", a1, a2);          z=0;         for (i=MAXLEN-1;i>=0;i--) {             if (z==0) {                 if (v3[i]!=0) {                     printf(\"%d\",v3[i]);                     z=1;                 }             } else {                 printf(\"%d\",v3[i]);             }         }         if (z==0) printf(\"0\");          printf(\"\\n\");     } } //Sample Input //3 //0 0 //1 2 //112233445566778899 998877665544332211 // //Sample Output //Case 1: //0 + 0 = 0 //Case 2: //1 + 2 = 3 //Case 3: //112233445566778899 + 998877665544332211 = 1111111111111111110", "referer": "user-0"}]}
{"question": "哪位大佬看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%c\", G->vexs[i]); 参数为数组元素也要用地址，scanf(\"%c\", &G->vexs[i]);", "referer": "user-0"}]}
{"question": "新人请教一下关于三重for嵌套循环的疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢各位大佬的帮助  万分感谢！！!", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 真的小白啊 的回复:感觉你写的有点复杂啊  好的 感谢各位大佬的帮助 我再仔细看看", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "后面两个图案不对  纠正", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "不难 就是有点琐碎", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "按照你这个第2，3个for语句控制输出每行s*（i+1）个空格，第一个for语句控制输出每行一个*号；s每次自减1，i每次自增1；第一次执行i=0，输出s的初值，也就是9个空格，第二次i=1，s=8，输出16个空格；所以，代码就用二楼的", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "其实两个循环就可以啦，在第二个循环里面判断一下位置是否超过规定，超过则打星，不超则打空格。 你的肯定错了，for(j) 应该是具体打印每个行中的数据，而你打印*的语句并不包含在内，而且你包含在内也不对。语言不好描述，直接上代码吧.  \tfor (i = 0; i < 10; i++) { \t\tfor (k = s; k > 0; k--) { \t\t\tprintf(\" \"); \t\t} \t\tfor(j=i;j>=0;j--) \t\t\tprintf(\"*\"); \t\ts--; \t\tprintf(\"\\n\");  \t}", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "感觉你写的有点复杂啊", "referer": "user-0"}]}
{"question": "关于mtrace调试内存泄漏时的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Linux不是开源的吗？看_IO_file_doallocate函数中都干了什么。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "mtrace(); 看一下这个函数里怎么操作的。", "referer": "user-0"}]}
{"question": "定时器不执行 OnTimer方法，要怎么改？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 10 楼 真相重于对错 的回复:查settime的原型啊 感谢大佬，大佬移步，这个帖子随便回复我结贴给分，https://bbs.csdn.net/topics/399174441", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "查settime的原型啊", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 7 楼 真相重于对错 的回复:定时器不执行 OnTimer方法，要怎么改？OnTimer现在查到的是只有使用MFC才可以自动调用这个函数，MFC 内部实现了函数映射，但是 我现在不是使用MFC也想用定时器，现在查到的是使用回调函数，现在回调函数可以实现定时器想要的功能了，又出现新问题，我不知道怎么关闭定时器，无论我把KillTimer(NULL,2);这句话写在回调函数第一行还是定时器后面都不执行关闭定时器操作，请问您有什么思路吗？ void CALLBACK TimerProc (   HWND hWnd,   UINT nMsg,   UINT nTimerid,   DWORD dwTime   ){ \t   \t//KillTimer(NULL,2); \tkeybd_event(VK_RETURN, 0, 0, 0);//按键下去 \tkeybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);//，按键上来，模拟\"回车\"命令\t \t\t }; int main(){ \tSetTimer(NULL,2, 1000, TimerProc); \tint ret = MessageBox(NULL,TEXT(\"0000\"),NULL, MB_YESNO); \tKillTimer(NULL,2); \twhile(1){ \t//\tSetTimer(NULL,2, 1000, TimerProc); \t\tMessageBox(NULL,TEXT(\"111111\"),NULL, MB_YESNO); \t\tSleep(2000); \t} \t \tsystem(\"PAUSE\"); \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:仅供参考：#pragma comment(lib,\"user32\") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,\"%03d\",tb.millitm);     printf(\"%s %s.%s %s\",datestr,timestr,mss,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc1\\n\"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc2\\n\"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log(\"In main\\n\");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2   还有个问题需要问一下，  void CALLBACK TimerProc (   HWND hWnd,   UINT nMsg,   UINT nTimerid,   DWORD dwTime   ){ \t   \tKillTimer(NULL,2); \tkeybd_event(VK_RETURN, 0, 0, 0);//按键下去 \tkeybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);//，按键上来，模拟\"回车\"命令\t \t\t }; int main(){  \tSetTimer(NULL,2, 1000, TimerProc); \tint ret = MessageBox(NULL,TEXT(\"111111\"),NULL, MB_YESNO); \tsystem(\"PAUSE\"); \treturn 0; } 我这个样子写定时器的关闭，可以实现定时器关闭吗？我不知道要怎么测试，希望得到解答，谢谢啦！  引用 2 楼 赵4老师 的回复:仅供参考：#pragma comment(lib,\"user32\") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,\"%03d\",tb.millitm);     printf(\"%s %s.%s %s\",datestr,timestr,mss,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc1\\n\"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc2\\n\"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log(\"In main\\n\");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2  使用回调函数的定时器要怎么关闭呢？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "定时器不执行 OnTimer方法，要怎么改？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 2 楼 赵4老师 的回复:仅供参考：#pragma comment(lib,\"user32\") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,\"%03d\",tb.millitm);     printf(\"%s %s.%s %s\",datestr,timestr,mss,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc1\\n\"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc2\\n\"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log(\"In main\\n\");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2     还有个问题需要问一下，  void CALLBACK TimerProc (   HWND hWnd,   UINT nMsg,   UINT nTimerid,   DWORD dwTime   ){      KillTimer(NULL,2);  keybd_event(VK_RETURN, 0, 0, 0);//按键下去  keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);//，按键上来，模拟\"回车\"命令     }; int main(){   SetTimer(NULL,2, 1000, TimerProc);  int ret = MessageBox(NULL,TEXT(\"111111\"),NULL, MB_YESNO);  system(\"PAUSE\");  return 0; } 我这个样子写定时器的关闭，可以实现定时器关闭吗？我不知道要怎么测试，希望得到解答，谢谢啦！", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:仅供参考：#pragma comment(lib,\"user32\") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,\"%03d\",tb.millitm);     printf(\"%s %s.%s %s\",datestr,timestr,mss,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc1\\n\"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc2\\n\"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log(\"In main\\n\");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2  谢谢，解决了", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:你又没有把定时器和回调函数绑定，系统怎么知道要调用那个函数我知道没绑定，我在查，我没查到才问的！！！！", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "仅供参考：#pragma comment(lib,\"user32\") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,\"%03d\",tb.millitm);     printf(\"%s %s.%s %s\",datestr,timestr,mss,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc1\\n\"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log(\"In myTimerProc2\\n\"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log(\"In main\\n\");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "你又没有把定时器和回调函数绑定，系统怎么知道要调用那个函数", "referer": "user-0"}]}
{"question": "新手小白，找个大佬带带我", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "好的好的，谢谢大家", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 7 楼 qq_45773596 的回复:[quote=引用 6 楼 自信男孩的回复:][quote=引用 2 楼 真的小白啊 的回复:]这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf(\"sum = %lf\\n\", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；  [/quote] 我晕了，哪一个方法是对的呀[/quote] 跟方法没关系的。是类型运算出现的问题。这位朋友给你推荐的算法没问题的，而是变量的类型有点问题，改成long double（自测）就可以。 当然，用unsigned long long也是没问题的。  这也是楼主需要注意的，需要考虑类型的取值范围，考虑是否会溢出以及类型的运算等等", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 2 楼 真的小白啊 的回复:]这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf(\"sum = %lf\\n\", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；  [/quote]  感谢对小白的指正，在变量类型方面我还存在许多不足", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 自信男孩的回复:[quote=引用 2 楼 真的小白啊 的回复:]这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf(\"sum = %lf\\n\", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；  [/quote] 我晕了，哪一个方法是对的呀", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 2 楼 真的小白啊 的回复:这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf(\"sum = %lf\\n\", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 3 楼 qq_45773596 的回复:刚才试了。谢谢哈 不过第四行和倒数第二行代码，我不太理解 在做ACM题时，经常都会遇到一些比较大的整数。而常用的内置整数类型常常显得太小了:其中long 和 int 范围 是[-2^31,2^31)，即-2147483648~2147483647。而unsigned范围是[0,2^32)，即0~4294967295。也就是说， 常规的32位整数只能够处理40亿以下的数。 那遇到比40亿要大的数怎么办呢？这时就要用到C++的64位扩展了。不同的编译器对64位整数的扩展 有所不同。VC6.0的64位整数分别叫做__int64与unsigned __int64，其范围分别是[-2^63, 2^63)与[0,2^64)，即-9223372036854775808~9223372036854775807与0~18446744073709551615(约1800亿亿)。对64位整数的运算与32位整数基本相同，都支持四则运算与位运算等。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 真的小白啊的回复:这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf(\"sum = %lf\\n\", sum);     return 0; }  懂了，谢谢哈", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "刚才试了。谢谢哈 不过第四行和倒数第二行代码，我不太理解", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf(\"sum = %lf\\n\", sum);     return 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "20!很大了，装不下了，供参考：#include<stdio.h>  int main() {     int i;     __int64 s=0,tmp=1;     for(i=1;i<=20;i++)     {        tmp *= i;        s+=tmp;     }     printf(\"%I64d\\n\",s);          return 0; }", "referer": "user-0"}, {"cid": "11", "user": "user-4", "content": "过来学习，谢谢分享", "referer": "user-0"}]}
{"question": "新人求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "windows下cls在linux和mac下是clear。 也可以编辑.bashrc文件，添加一行 alias cls='clear';", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 H-M-A-L 的回复:[quote=引用 1 楼 自信男孩的回复:]建议使用system(\"clear\"); MAC系统是unix（源）因此，和windows还是有区别的。 LINUX下可以用clear来清屏～ 我就是用clear，然后显示TERM environment variable not set[/quote] 再试试reset命令", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:建议使用system(\"clear\"); MAC系统是unix（源）因此，和windows还是有区别的。 LINUX下可以用clear来清屏～ 我就是用clear，然后显示TERM environment variable not set", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "建议使用system(\"clear\"); MAC系统是unix（源）因此，和windows还是有区别的。 LINUX下可以用clear来清屏～", "referer": "user-0"}]}
{"question": "求助！mfc如何在单步调试时，跳过对系统dll的调试？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "分清楚F10和F11 该用哪个用哪个，不要坚持一个键敲到底。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "按Shift+F11键", "referer": "user-0"}]}
{"question": "补全程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1）int x 2) return 1;", "referer": "user-0"}]}
{"question": "如果用switch语句怎么做。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个没办法用switch做，只能用if else if做，如果用switch，需要枚举每个分数，写起来不是一点的冗繁。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可以先用if ---else写一下，然后改成switch ... case形式；", "referer": "user-0"}]}
{"question": "完全不晓得咋做啊啊啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "百度背包问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先遍历所有可能，得到一个或一组≤N的最大值， 然后再在上一步的结果中遍历得到总体评分最高的一个即可。", "referer": "user-0"}]}
{"question": "base64解码的长度怎么算?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 5 楼 qq_40162781 的回复:[quote=引用 3 楼 舉杯邀明月 的回复:]假设编码之后的字符数是Ｌ，那么解码长度： n = L/4*3 +(3&(L-1))%3  不管BASE64文本的后面是否补了＝，上面的计算结果肯定是“原始长度”n。   为什么是+， 还有(3&(L-1))%3是什么意思。。  [/quote] 刚才把我以前写的BASE64模块找来看了一下，发现我在3楼的说法不太准确。   Ｌ的值 是BASE64编码文本去掉分隔符（按“标准”要76字符换行）、 　去掉末尾的=字符之后的“纯编码”长度值。 昨天回复时，忘记我的“中间处理层”接口函数了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 5 楼 qq_40162781 的回复:[quote=引用 3 楼 舉杯邀明月 的回复:]假设编码之后的字符数是Ｌ，那么解码长度： n = L/4*3 +(3&(L-1))%3  不管BASE64文本的后面是否补了＝，上面的计算结果肯定是“原始长度”n。   为什么是+， 还有(3&(L-1))%3是什么意思。。  [/quote]  你在C版块提问，不至于看不懂 C语言格式的运算表达式吧。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 舉杯邀明月 的回复:假设编码之后的字符数是Ｌ，那么解码长度： n = L/4*3 +(3&(L-1))%3  不管BASE64文本的后面是否补了＝，上面的计算结果肯定是“原始长度”n。   为什么是+， 还有(3&(L-1))%3是什么意思。。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "另外： 如果BASE64文本的编码长度为Ｌ 如果： 3 & L ==1 那么： 编码长度不合法！", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "假设编码之后的字符数是Ｌ，那么解码长度： n = L/4*3 +(3&(L-1))%3  不管BASE64文本的后面是否补了＝，上面的计算结果肯定是“原始长度”n。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "太帅了啊", "referer": "user-2"}, {"cid": "8", "user": "user-3", "content": "好像字节对齐也是用这原理?", "referer": "user-2"}, {"cid": "9", "user": "user-1", "content": "仅供参考：#include <stdio.h> #include <string.h> #include <stdlib.h>  #define BASE64_VALUE_SZ 256 int     base64_value[BASE64_VALUE_SZ]; const unsigned char alphabet[65] = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"; class Base64Utility { public:     Base64Utility();     int base64_encode(char *src, int srclen, char *dst, int tail);     int base64_decode(char *src, int srclen, char *dst); private:     void base_64_init(void); }; Base64Utility::Base64Utility() {     base_64_init(); } void Base64Utility::base_64_init(void) {     int i;      for (i = 0; i < BASE64_VALUE_SZ; i++) base64_value[i] = -1;     for (i = 0; i < 64; i++) base64_value[(int) alphabet[i]] = i;     base64_value['='] = 0; } int Base64Utility::base64_encode(char *src, int srclen, char *dst, int tail) {     int     bits, char_count, len;     char    *o_char, *lim, *o_lim;     unsigned char   c;      if ( !src || !dst) return 0;     len = srclen;     lim = src + len;     o_char = dst;     o_lim  = dst + (len*4)/3 + 1;     char_count = 0;     bits = 0;     while ( (src < lim) && (o_char < o_lim)) {         c = *(src++);         bits += c;         char_count++;         if (char_count == 3) {             *(o_char++) = alphabet[bits >> 18];             *(o_char++) = alphabet[(bits >> 12) & 0x3f];             *(o_char++) = alphabet[(bits >> 6) & 0x3f];             *(o_char++) = alphabet[bits & 0x3f];             bits = 0;             char_count = 0;         } else {             bits <<= 8;         }     }     if (char_count != 0) {         bits <<= 16 - (8 * char_count);         *(o_char++) = alphabet[bits >> 18];         *(o_char++) = alphabet[(bits >> 12) & 0x3f];         if (char_count == 1) {             if (tail) {                 *(o_char++) = '=';                 *(o_char++) = '=';             }         } else {             *(o_char++) = alphabet[(bits >> 6) & 0x3f];             if (tail) {                 *(o_char++) = '=';             }         }     }     *(o_char) = 0;     return strlen(dst); } int Base64Utility::base64_decode(char *src, int srclen, char *dst) {     int j;     unsigned int k;     int c, base_result_sz;     long val;      if (!src || !dst) return 0;     base_result_sz = srclen;     val = c = 0;     for (j = 0; *src; src++) {         k = (int) *src % BASE64_VALUE_SZ;         if (base64_value[k] < 0) continue;         val <<= 6;         val += base64_value[k];         if (++c < 4) continue;         dst[j++] = (char) (val >> 16);         dst[j++] = (val >> 8) & 0xff;         dst[j++] = val & 0xff;         val = c = 0;     }     switch (c) {         case 2://xxxxxx xx0000             dst[j++] = (val >> 4) & 0xff;         break;         case 3://XXXXXX XXxxxx xxxx00             dst[j++] = (char) (val >> 10);             dst[j++] = (val >> 2) & 0xff;         break;     }     return j; } Base64Utility b64u; #define MAXLENS 1024768 #define MAXLEND 1366360 char bufd[MAXLEND]; char bufs[MAXLENS]; FILE *fs,*fd; int fsize; int main(int argc,char *argv[]) {     if (argc<4) {     USE:         printf(\"%s <-e|-E|-d> srcfile desfile\\n\",argv[0]);         return 1;     }     if (stricmp(argv[1],\"-e\") && stricmp(argv[1],\"-d\")) goto USE;     if (0==stricmp(argv[1],\"-e\")) {         fs=fopen(argv[2],\"rb\");         if (NULL==fs) {             printf(\"Can not open file %s!\\n\",argv[2]);             return 2;         }         fsize=fread(bufs,1,MAXLENS,fs);         if (fsize<=0) {             fclose(fs);             printf(\"Can not read file %s!\\n\",argv[2]);             return 3;         }         if (MAXLENS==fsize) printf(\"Warning: Up to %d bytes.\\n\",MAXLENS);         fclose(fs);         b64u.base64_encode(bufs,fsize,bufd,('E'==argv[2][1]));         fd=fopen(argv[3],\"w\");         if (NULL==fd) {             printf(\"Can not create file %s!\\n\",argv[3]);             return 4;         }         fprintf(fd,\"%s\",bufd);         fclose(fd);     } else {//0==stricmp(argv[1],\"-d\")         fd=fopen(argv[2],\"rb\");         if (NULL==fd) {             printf(\"Can not open file %s!\\n\",argv[2]);             return 2;         }         fsize=fread(bufd,1,MAXLEND,fd);         if (fsize<=0) {             fclose(fd);             printf(\"Can not read file %s!\\n\",argv[2]);             return 3;         }         if (MAXLEND==fsize) printf(\"Warning: Up to %d bytes.\\n\",MAXLEND);         fclose(fd);         fsize=b64u.base64_decode(bufd,fsize,bufs);         fs=fopen(argv[3],\"wb\");         if (NULL==fs) {             printf(\"Can not create file %s!\\n\",argv[3]);             return 4;         }         if (fsize!=(int)fwrite(bufs,1,fsize,fs)) {             printf(\"Write %s error!\\n\",argv[3]);             fclose(fs);             return 5;         }         fclose(fs);     }     return 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "因为base64存在补=号，所以算出来的只是一个范围，长度*3/4+1最大长度，如果要具体算出来编码之前的长度，需要自行判断补=号情况减去对应的占位", "referer": "user-0"}]}
{"question": "为什么int变量一下子 变成29972，应该一直加1才对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：#include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数组最好用memset初始化一下0，这样能保证后面的数值都是空的，否则可能会出现你现在这个情况", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#define _CRT_SECURE_NO_WARNINGS #include<cstdio> #include<cstring> #include<stdlib.h>  struct str {     //char a[];     char a[1024]; };   int main() {     //FILE *p;     FILE *fp;     char myfile[] = \"C:\\\\Users\\\\hmc\\\\Desktop\\\\mynum.txt\";      str aa;     printf(\"请输入字符串：\");     if ((fp = fopen(myfile, \"w\")) == NULL)     {         printf(\"未找到%s\", myfile);         return 0;     }     int mycout = 0;//字符串个数     scanf(\"%s\", &aa.a);     while (strncmp(aa.a,\"#\", 1) != 0)     {         for (int i = 0; i < strlen(aa.a)+1; i++)         {             if (aa.a[i] >= 65 && aa.a[i] <=90)             {                 aa.a[i] += 32;             }         }         fwrite(&aa.a, strlen(aa.a)+1, 1, fp);         mycout++;         printf(\"mycout实时值%d \", mycout);         //printf(\"加32了\");         scanf(\"%s\", &aa.a);     }     fclose(fp);     printf(\"mycount最终值%d\",mycout);      return 0; } 供参考～  数组长度需要确定的。要么定义为char a[1024];/*举例，长度可以根据需要而定*/，定义成char a[];等价定义了一个char *a;这个a是一个野指针，需要给其分配空间；两种方式选其一吧。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "修改，供参考：#include<cstdio> #include<cstring> #include<stdlib.h>  struct str {        char a[256]; }; int main() {     FILE *p;     char myfile[] = \"C:\\\\Users\\\\hmc\\\\Desktop\\\\mynum.txt\";     str aa;     if ((p = fopen(myfile, \"w\")) == NULL)     {          printf(\"未找到%s\", myfile);          return 0;     }     printf(\"请输入字符串：\");     int mycout = 0;       //字符串个数     scanf(\"%s\", aa.a);    //scanf(\"%s\", &aa.a);     while (strcmp(aa.a,\"#\")!=0) //while (strcmp(aa.a,\"#\")==1)     {         for (int i = 0; i < strlen(aa.a)+1; i++)         {               if (aa.a[i] >= 65 && aa.a[i] <=90)               {                   aa.a[i] += 32;               }         }         fwrite(&aa.a, strlen(aa.a)+1, 1, p);         mycout++;         printf(\"mycout实时值%d \", mycout);         //printf(\"加32了\");         scanf(\"%s\", aa.a);//scanf(\"%s\", &aa.a);     }     fclose(p);     printf(\"mycount最终值%d\",mycout);          return 0; }   //请输入字符串：C:\\\\Users\\\\hmc\\\\Desktop\\\\mynum.txt # //mycout实时值1 mycount最终值1请按任意键继续. . .  //mynum.txt: //c:\\\\users\\\\hmc\\\\desktop\\\\mynum.txt", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "struct str { char a[]; }; 这个用法是错误的 1. 柔性数组要求 第一个元素是完整类型 并且空数组是最后一个元素 2. 柔性数组的使用方式是 用malloc等函数分配内存的时候 指定柔性数组大小 没有使用malloc等函数 无法应用柔性数组  然后 没有不固定长度的数组  哪怕是std::string 也是固定长度  遇到长度不足的情况手动重新分配内存", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "换了个编译器就没问题，这是为什么？", "referer": "user-0"}]}
{"question": "求助！C语言malloc与结构体调用导致读取字符串的字符时出错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 自信男孩的回复:[quote=引用 6 楼 weixin_45710571 的回复:][quote=引用 3 楼 狐帝的回复:]代码不完整，所以只能从你现有代码来琢磨。fileData是个全局变量吧？在ReadInputFile函数里，读完文件之后，fileData.data = data，本意是想通过fileData将读入的数据带回？但是ReadInputFile的后面有free(data)，data（以及fileData.data）指向的存储区就被释放掉了，那么fileData.data就指向了无效的存储区。所以其他代码再访问fileData.data时就会出错。 原来是这样的，感谢指导！再请教一下如果不释放malloc申请过的空间，那如何才能保证程序复用时内存不泄露，代码循环时不出错呢，或者在何处释放才是正确的呢[/quote]  不在使用的时候要释放。内存泄露是因为程序在运行的时候malloc之后没有free才会出现，如果free了就不会泄露，如果程序退出了，即使不free，系统也会给予释放（系统回收）；所以，一般说内存泄露是指程序一直运行，不退出，而程序不停的申请空间，而不free；  注意释放的地址应该是malloc的地址，这个应该是相同的地址，否则会出现释放错误； malloc的空间是可以反复使用的，注意保存好malloc的地址值就好了，等不用的时候记着释放即可；[/quote] 嗯嗯，懂了，谢谢你！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 6 楼 weixin_45710571 的回复:[quote=引用 3 楼 狐帝的回复:]代码不完整，所以只能从你现有代码来琢磨。fileData是个全局变量吧？在ReadInputFile函数里，读完文件之后，fileData.data = data，本意是想通过fileData将读入的数据带回？但是ReadInputFile的后面有free(data)，data（以及fileData.data）指向的存储区就被释放掉了，那么fileData.data就指向了无效的存储区。所以其他代码再访问fileData.data时就会出错。 原来是这样的，感谢指导！再请教一下如果不释放malloc申请过的空间，那如何才能保证程序复用时内存不泄露，代码循环时不出错呢，或者在何处释放才是正确的呢[/quote]  不在使用的时候要释放。内存泄露是因为程序在运行的时候malloc之后没有free才会出现，如果free了就不会泄露，如果程序退出了，即使不free，系统也会给予释放（系统回收）；所以，一般说内存泄露是指程序一直运行，不退出，而程序不停的申请空间，而不free；  注意释放的地址应该是malloc的地址，这个应该是相同的地址，否则会出现释放错误； malloc的空间是可以反复使用的，注意保存好malloc的地址值就好了，等不用的时候记着释放即可；", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 狐帝的回复:代码不完整，所以只能从你现有代码来琢磨。fileData是个全局变量吧？在ReadInputFile函数里，读完文件之后，fileData.data = data，本意是想通过fileData将读入的数据带回？但是ReadInputFile的后面有free(data)，data（以及fileData.data）指向的存储区就被释放掉了，那么fileData.data就指向了无效的存储区。所以其他代码再访问fileData.data时就会出错。 原来是这样的，感谢指导！再请教一下如果不释放malloc申请过的空间，那如何才能保证程序复用时内存不泄露，代码循环时不出错呢，或者在何处释放才是正确的呢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "调试代码的必要知识：到啥时候说啥话。 不要指望刚执行一句的时候就看见结果。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "unsigned char* data;  这个也要分配内存才能存放数据的", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "Filep = data = NULL; 这句得分开写： Filep = NULL;  data  = NULL;", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "代码不完整，所以只能从你现有代码来琢磨。fileData是个全局变量吧？在ReadInputFile函数里，读完文件之后，fileData.data = data，本意是想通过fileData将读入的数据带回？但是ReadInputFile的后面有free(data)，data（以及fileData.data）指向的存储区就被释放掉了，那么fileData.data就指向了无效的存储区。所以其他代码再访问fileData.data时就会出错。", "referer": "user-0"}]}
{"question": "用c语言读取文本，一直都出错，到文件路径应该没问题的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "或者加一句#pragma warning(disable:4996)", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-4的回复:第2行应该放在第1行的上面吧。 谢谢，可以了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 forever74的回复:[quote=引用 2 楼 qq_52473673 的回复:][quote=引用 1 楼 user-4的回复:]第2行应该放在第1行的上面吧。 貌似没区别吧，我在dev上试了一下，是可以打开的，但在visual中，就是打不开[/quote]  你得这么想：要是没区别，那你这趟就白来了。 既然来都来了，为什么不试一试再说呢？[/quote] 非常感谢大家的帮助，正如一楼所说，可以，没来的看消息，所以回复晚了，还是谢谢大家，嘻嘻", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 2 楼 qq_52473673 的回复:[quote=引用 1 楼 user-4的回复:]第2行应该放在第1行的上面吧。 貌似没区别吧，我在dev上试了一下，是可以打开的，但在visual中，就是打不开[/quote]  你得这么想：要是没区别，那你这趟就白来了。 既然来都来了，为什么不试一试再说呢？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "编译就没能成功，没能生成可执行文件，所以没有课运行的程序。如楼上所言，把第1、2行互换一下就行。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-4的回复:第2行应该放在第1行的上面吧。 貌似没区别吧，我在dev上试了一下，是可以打开的，但在visual中，就是打不开", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "第2行应该放在第1行的上面吧。", "referer": "user-0"}]}
{"question": "求问这段代码怎么叙述运行过程", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把注释抄下来，再润色一下。", "referer": "user-0"}]}
{"question": "求助！！！有大牛能用c语言帮帮我这个苦逼的大学生吗  上学期才学完的c ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include<stdio.h>  int fun(int n) {     if(n%2==0 || n%3==0 || n%5==0)           return 1;     else  return 0; }  int main() {     int i,cnt,n;     while(scanf(\"%d\",&n)!=EOF && n>=1 && n<=10000){           cnt=0;           for(i=1;cnt < n;i++)               if(i==1 || fun(i)) cnt++;           printf(\"%d\\n\",i-1);     }          return 0; }", "referer": "user-0"}]}
{"question": "nulltrp怎么意思，怎么解决，求大佬指教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "nullptr是空指针的意思,类型是nullptr_t，之前使用NULL可能会出现问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "如果你只是想问nullptr是什么意思，参考https://blog.csdn.net/qq_42956179/article/details/115408545 C++11里面对于指针安全做了很大改善，NULLC++里面的宏定义其实是个0，而nullptr则为空，你可以自行看一下为什么void和NULL为什么会出现问题", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "仅供参考：#include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*T)->data = data;         //生成根结点         CreateBiTree(&(*T)->lchild);//构造左子树         CreateBiTree(&(*T)->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf(\"%c \",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf(\"%c \",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(&T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}]}
{"question": "有一个字符串，内有若干个字符，现输入一个字符，要求程序将字符串中该字符删去。用外部函数实现。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1. file2.cpp: 应该先#include <stdio.h>，否则编译失败，从而无法生成enter_string符号，会导致最终链接失败。 2. file4.cpp: 应该先#include <stdio.h>，否则编译失败，从而无法生成print_string符号，会导致最终链接失败。 3. 设定project时是不是设置成Win32或Windows应用程序了？应该设置成Console或控制台应用程序，否则就会出现找不到WinMain函数的链接错误。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "几个文件必须全部编译成功后才能链接生成exe程序，你的第2 4个文件，由于没有头文件编译失败，这种去情况应先改正编译错误。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 3 楼 weixin_58044954 的回复:已经用extern联了呀extern 只是在这个文件里声明了这几个函数是外部的，告知这几个函数不在本部门里，至于这个外部的范围它的也不知道呢。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "已经用extern联了呀", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "几个文件之间得让他有关联，不然它不知道到哪去找这个声明为外部的函数，无路可走。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "链接错误，猜测一下，几个文件应先分别编译最后再构建，你可能没有编译其他的几个文件。", "referer": "user-0"}]}
{"question": "请教一个16进制问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "不是 0x2710对应的是10000，除以10，对应的是3e8。舍弃的是10进制下的最后一位。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你的意思 0x2710 转换到 0x3e 最后的8 忽略 对吗", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "int mmlen; struct oh {  unsigned int cm:12; } cmlen; mmlen=10000; cmlen.cm=mmlen/10;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "不就是x / 10吗", "referer": "user-0"}]}
{"question": "有一个字符串，内有若干个字符，现输入一个字符，要求程序将该字符串中该字符删去。用外部函数实现。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "重新发了个帖子，麻烦你看一下", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "那你把代码和编译错误都发出来", "referer": "user-0"}]}
{"question": "while的用法求助！！！！！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第一个while里面不会更新ch，相当于只会从文件里读取到一个字节的数据；  第二个是循环读取文件内容的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "第一个ch = fgetc(fp); 在while（）循环体外，ch只从文件读入一次，只要这一次不在文件尾，在while(ch!=EOF)永远成真，死循环了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "第一种写法，在while循环中，ch就没变化，当然会陷入死循环。 第二种写法，每次while循环，ch都会重新被fgetc(fp)赋值，总会读到EOF，所以就能跳出循环。", "referer": "user-0"}]}
{"question": "改正错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "改这样试试：#include  <stdio.h>  struct  stu{         int  id;  //学号         char name[20];//姓名         int  age;  //年龄         int  score;  //成绩 };  int  main(){              //声明函数及变量         void   readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]);         void   stdoutForStu(struct  stu  *p,  int  num);         const  int  NUM  =  2;     //学生数量         struct  stu  students[NUM]; //stu型数组         struct  stu  *p  = students;  //指向stu型一维数组型指针         char  filename[] = \"ex804.txt\"; //待读取的文件路径及名称          ///文件获取输入         readFileForStu(p,NUM,filename,\"r\");          //向屏幕输出显示         stdoutForStu(p,NUM);                  return  0; }  // //  *  函数名称：readFileForStu //  *  函数功能：从文件格式化读取数据 //  *  写入格式：共读取  num  行；每行读出一个  stu  型数据，每个成员变量之间用空格分隔 //  *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址。该数组用于保存文件读取数据 //  *  形式参数：int  num，一维数组元素个数，也即读取文件的行数 //  *  形式参数：char  filename[]，待读取的文件路径及名称 //  *  形式参数：char  mode[]，文件使用方式 //  *  返  回  值：无  void  readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]) {         //  请编程实现本函数         int i;         FILE *fp;         fp=fopen(filename,mode);         if(fp==NULL){            printf(\"Open file fail!\\n\");            return;         }         for(i=0;i<num;i++)         {          //fread(&p[i],sizeof(struct stu),1,fp);          fscanf(fp,\"%d%s%d%d\",&p[i].id,p[i].name,&p[i].age,&p[i].score);         }         fclose(fp); }  // //  *  函数名称：stdoutForStu //  *  函数功能：向显示器输出显示数据 //  *  输出格式：共输出  num  行；每行输出一个  stu  型数据，每个成员变量之间用空格分隔 //  *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址 //  *  形式参数：int  num，一维数组元素个数 //  *  返  回  值：无  void  stdoutForStu(struct  stu  *p,  int  num) {         //  请编程实现本函数         int i;         for(i=0;i<num;i++)             printf(\"%d %s %d %d\\n\",p[i].id,p[i].name,p[i].age,p[i].score); }  //1 libai 100 100 //2 lihei 200 200 //请按任意键继续. . .  //10001 ZhangSan 25 99 //10002 ZhaoLiu 18 100 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qzjhjxj的回复:修改如下，供参考：#include  <stdio.h>  struct  stu{         int  id;  //学号         char name[20];//姓名         int  age;  //年龄         int  score;  //成绩 };  int  main(){              /*声明函数及变量*/         void   readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]);         void   stdoutForStu(struct  stu  *p,  int  num);         const  int  NUM  =  2;     //学生数量         struct  stu  students[NUM]; //stu型数组         struct  stu  *p  = students;  //指向stu型一维数组型指针         char  filename[] = \"ex804.txt\"; //待读取的文件路径及名称          /*从文件获取输入*/         readFileForStu(p,NUM,filename,\"r\");          /*向屏幕输出显示*/         stdoutForStu(p,NUM);                  return  0; }  /*   *  函数名称：readFileForStu   *  函数功能：从文件格式化读取数据   *  写入格式：共读取  num  行；每行读出一个  stu  型数据，每个成员变量之间用空格分隔   *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址。该数组用于保存文件读取数据   *  形式参数：int  num，一维数组元素个数，也即读取文件的行数   *  形式参数：char  filename[]，待读取的文件路径及名称   *  形式参数：char  mode[]，文件使用方式   *  返  回  值：无     */ void  readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]) {         //  请编程实现本函数         int i;         FILE *fp;         fp=fopen(filename,mode);         if(fp==NULL){            printf(\"Open file fail!\\n\");            return;         }         for(i=0;i<num;i++)         {          fread(&p[i],sizeof(struct stu),1,fp);         }         fclose(fp); }  /*   *  函数名称：stdoutForStu   *  函数功能：向显示器输出显示数据   *  输出格式：共输出  num  行；每行输出一个  stu  型数据，每个成员变量之间用空格分隔   *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址   *  形式参数：int  num，一维数组元素个数     *  返  回  值：无     */ void  stdoutForStu(struct  stu  *p,  int  num) {         //  请编程实现本函数         int i;         for(i=0;i<num;i++)             printf(\"%d %s %d %d\\n\",p[i].id,p[i].name,p[i].age,p[i].score); }  //1 jjjj 18 90 //2 kkkk 19 91 //请按任意键继续. . . 大佬，我把你的程序放在测试平台上跑了一遍。输出结果不正确 测试数据1输出错误   错误输出： 1768693809 bai 100 1002 lihei 200 200 540028978 31580664196240  0 0 期望输出： 1 libai 100 1002 lihei 200 200 测试数据2输出错误   错误输出： 808464433 1 ZhangSan 25 9910002 ZhaoLiu 18 100@ 1512059440 1282367848824210793 8 100@ 0 0 期望输出： 10001 ZhangSan 25 9910002 ZhaoLiu 18 100", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "修改如下，供参考：#include  <stdio.h>  struct  stu{         int  id;  //学号         char name[20];//姓名         int  age;  //年龄         int  score;  //成绩 };  int  main(){              /*声明函数及变量*/         void   readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]);         void   stdoutForStu(struct  stu  *p,  int  num);         const  int  NUM  =  2;     //学生数量         struct  stu  students[NUM]; //stu型数组         struct  stu  *p  = students;  //指向stu型一维数组型指针         char  filename[] = \"ex804.txt\"; //待读取的文件路径及名称          /*从文件获取输入*/         readFileForStu(p,NUM,filename,\"r\");          /*向屏幕输出显示*/         stdoutForStu(p,NUM);                  return  0; }  /*   *  函数名称：readFileForStu   *  函数功能：从文件格式化读取数据   *  写入格式：共读取  num  行；每行读出一个  stu  型数据，每个成员变量之间用空格分隔   *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址。该数组用于保存文件读取数据   *  形式参数：int  num，一维数组元素个数，也即读取文件的行数   *  形式参数：char  filename[]，待读取的文件路径及名称   *  形式参数：char  mode[]，文件使用方式   *  返  回  值：无     */ void  readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]) {         //  请编程实现本函数         int i;         FILE *fp;         fp=fopen(filename,mode);         if(fp==NULL){            printf(\"Open file fail!\\n\");            return;         }         for(i=0;i<num;i++)         {          fread(&p[i],sizeof(struct stu),1,fp);         }         fclose(fp); }  /*   *  函数名称：stdoutForStu   *  函数功能：向显示器输出显示数据   *  输出格式：共输出  num  行；每行输出一个  stu  型数据，每个成员变量之间用空格分隔   *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址   *  形式参数：int  num，一维数组元素个数     *  返  回  值：无     */ void  stdoutForStu(struct  stu  *p,  int  num) {         //  请编程实现本函数         int i;         for(i=0;i<num;i++)             printf(\"%d %s %d %d\\n\",p[i].id,p[i].name,p[i].age,p[i].score); }  //1 jjjj 18 90 //2 kkkk 19 91 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "fp=fopen(\"ex804.txt\",\"mode\");  这条语句不会，应该是fp=fopen(\"ex804.txt\",mode); 这条语句的错误会导致文件无法打开，导致fp为NULL，后面就可能会引发异常。", "referer": "user-0"}]}
{"question": "新手小白，想询问一下，哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "猜一猜，下面的程序片断将打印什么内容？ int m = 5;  switch (0) {     m ++;     default: printf (\"%d\\n\", m); }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 user-2 的回复:case ' b>max':  这里的类型不对，'b>max' 是什么类型呢，不是 字符型，也不是 字符串，case 后面跟整形才对。 这种说法是不正确的。  首先，case 后面必须跟整型常量表达式（而不是通常意义上的整型）。  其次，'b>max' 是字符常量，它的类型是 int 。因此，'b>max' 的类型是 int 。根据整型常量表达式的定义，'b>max' 也是整型常量表达式。  所以 case 'b>max' 在语法上是没有问题的。  问题在哪里呢？对于单字符的字符常量，比如 'x'，在编译时转换为 int 类型的字符编码。但是，对于包含多个字符的字符常量，比如 'abcd'，在编译时如何打包成 int 类型的编码，由编译器（C实现）决定。有很多机器上，int 类型的长度是 4 个字节，正好可以编码4个字符，但超过4个字符就会出现警告。  来看下面这个例子，这个例子可以正常执行并打印 “Okay.”： switch ('b>ma') {     case 'b>ma' : printf (\"Okay.\\n\"); } 在很多机器上，这个示例不会产生“字符太长”的警告，但有可能出现“字符常量由多个字符组成”的警告。但相对于字符太长的警告，后面一个警告是可以接受的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢侬，嘿嘿", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考：#include<stdio.h>  int main() {    int a,b,c;    printf(\"请输入三个数:\\n\");    scanf(\"%d%d%d\",&a,&b,&c);    printf(\"最大值:%d\\n\",a>b?(a>c?a:c):(b>c?b:c));        return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "case ' b>max':  这里的类型不对，'b>max' 是什么类型呢，不是 字符型，也不是 字符串，case 后面跟整形才对。", "referer": "user-0"}]}
{"question": "看不懂指针，唉！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "编译不过与指针没关系 ，执行语句应放在函数定义中，你没写函数定义，啥编译器也通不过。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "TC编译器是不是目前只有学校里教学会使用了。 建议使用VS编译调试工具；  代码没写在函数里呢？看着不符合语法规则～ p = a;只能出现在函数里。int *p, a[3];可以放在函数外，因为这是定义，定义的全局变量；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "换一个编辑器吧", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "应该用 #include <stdio.h> ... <>和\"\"内的头文件查找路径不一样", "referer": "user-0"}]}
{"question": "哪位大神帮忙看一下哪点错了。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 1 楼 自信男孩 的回复:struct studeng stud[n];这儿有问题呢。n是随机值，不确定大小；C语言不支持不确定的数组长度； 可以考虑用动态申请空间的方式来实现：  struct studeng *stud = NULL;  在scanf后面加上一句申请空间的语句：  stud = (struct student *)malloc(sizeof(struct student)); if (!stud)     exit(0);  后面对stud可以以数组的形式访问和操作；  最后注意不适用stud时，记得free(stud);释放；  stud = (struct student *)malloc(sizeof(struct student) * n); if (!stud)     exit(0); 用这个，上面那个有问题，忘了乘于n了。这个n是输入之后的n；", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "struct studeng stud[n];这儿有问题呢。n是随机值，不确定大小；C语言不支持不确定的数组长度； 可以考虑用动态申请空间的方式来实现：  struct studeng *stud = NULL;  在scanf后面加上一句申请空间的语句：  stud = (struct student *)malloc(sizeof(struct student)); if (!stud)     exit(0);  后面对stud可以以数组的形式访问和操作；  最后注意不适用stud时，记得free(stud);释放；", "referer": "user-0"}]}
{"question": "怎么调用随机四参数法生成多孔介质", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "师兄，我也想问这个问题，怎么把随机四参数的代码和LBM的代码进行联动啊？您这个问题解决了么？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "老哥，现在会用了吗？方便加个QQ吗？1974595531", "referer": "user-0"}]}
{"question": "请教一下，为什么我的sprintf转化double类型数据的时候全成0了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 7 楼 狐帝 的回复:单看这段代码，没什么问题。恐怕还是有其他的代码影响到了tmpbuffer的内容。 建议测试一下，楼主的代码是有问题的。%.15lf是有必要的。从输出的默认精确位数上可以理解是需要吧", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 6 楼 狐帝 的回复:[quote=引用 5 楼 自信男孩 的回复:][quote=引用 3 楼 qzjhjxj 的回复:]这样改下，供参考：#include<stdio.h> int main() {     int    i;     char   tmpbuffer[8][20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466,0.02414235618335,                        -0.158289852824976, 1.54926741892562, 0.162671275351189,0.55};    for (i=0;i<8;i++)    {        sprintf(tmpbuffer[i],\"%18.15f\",U13Coef[i]);        printf(\"%s\\n\",tmpbuffer[i]);    }        return 0; }   // -0.000000428344451 // 0.000041556454936 //-0.001508777414466 // 0.024142356183350 //-0.158289852824976 // 1.549267418925620 // 0.162671275351189 // 0.550000000000000 //请按任意键继续. . . 注意列的长度，18+15>20，所以20的长度是不合适的。[/quote] %18.15f 是指总长度18个字符，其中小数点后占15个字符。总长并不是18+15。[/quote] 用到sprintf，哪儿18+15个字符不是占18+15个字节吗？当然楼主的例子整数部分没有那么大，我的考虑是如果是整数部分比较大，这样就会有问题的～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "单看这段代码，没什么问题。恐怕还是有其他的代码影响到了tmpbuffer的内容。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 5 楼 自信男孩 的回复:[quote=引用 3 楼 qzjhjxj 的回复:]这样改下，供参考：#include<stdio.h> int main() {     int    i;     char   tmpbuffer[8][20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466,0.02414235618335,                        -0.158289852824976, 1.54926741892562, 0.162671275351189,0.55};    for (i=0;i<8;i++)    {        sprintf(tmpbuffer[i],\"%18.15f\",U13Coef[i]);        printf(\"%s\\n\",tmpbuffer[i]);    }        return 0; }   // -0.000000428344451 // 0.000041556454936 //-0.001508777414466 // 0.024142356183350 //-0.158289852824976 // 1.549267418925620 // 0.162671275351189 // 0.550000000000000 //请按任意键继续. . . 注意列的长度，18+15>20，所以20的长度是不合适的。[/quote] %18.15f 是指总长度18个字符，其中小数点后占15个字符。总长并不是18+15。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 3 楼 qzjhjxj 的回复:这样改下，供参考：#include<stdio.h> int main() {     int    i;     char   tmpbuffer[8][20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466,0.02414235618335,                        -0.158289852824976, 1.54926741892562, 0.162671275351189,0.55};    for (i=0;i<8;i++)    {        sprintf(tmpbuffer[i],\"%18.15f\",U13Coef[i]);        printf(\"%s\\n\",tmpbuffer[i]);    }        return 0; }   // -0.000000428344451 // 0.000041556454936 //-0.001508777414466 // 0.024142356183350 //-0.158289852824976 // 1.549267418925620 // 0.162671275351189 // 0.550000000000000 //请按任意键继续. . . 注意列的长度，18+15>20，所以20的长度是不合适的。", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "#include <stdio.h>  int main(void) {     int i;     //char tmpbuffer[20];     char tmpbuffer[64];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466, 0.02414235618335,-0.158289852824976, 1.54926741892562, 0.162671275351189, 0.55};      for (i=0; i<8; i++) {         sprintf(tmpbuffer,\"%.15lf\",U13Coef[i]);         puts(tmpbuffer);     }     return 0; } 供参考～ 注意小数点后的保留位数；  默认是6位，多余6位的不显示； 自然不转换到buffer里。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "这样改下，供参考：#include<stdio.h> int main() {     int    i;     char   tmpbuffer[8][20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466,0.02414235618335,                        -0.158289852824976, 1.54926741892562, 0.162671275351189,0.55};    for (i=0;i<8;i++)    {        sprintf(tmpbuffer[i],\"%18.15f\",U13Coef[i]);        printf(\"%s\\n\",tmpbuffer[i]);    }        return 0; }   // -0.000000428344451 // 0.000041556454936 //-0.001508777414466 // 0.024142356183350 //-0.158289852824976 // 1.549267418925620 // 0.162671275351189 // 0.550000000000000 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "#include <stdio.h> int main() {     char tmpbuffer[20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466, 0.02414235618335,-0.158289852824976, 1.54926741892562, 0.162671275351189, 0.55};     for (int i=0;i<8;i++) {         sprintf(tmpbuffer,\"%.15lf\",U13Coef[i]);         printf(\"i:%d tmpbuffer:[%s]\\n\",i,tmpbuffer);     }     return 0; } //i:0 tmpbuffer:[-0.000000428344451] //i:1 tmpbuffer:[0.000041556454936] //i:2 tmpbuffer:[-0.001508777414466] //i:3 tmpbuffer:[0.024142356183350] //i:4 tmpbuffer:[-0.158289852824976] //i:5 tmpbuffer:[1.549267418925620] //i:6 tmpbuffer:[0.162671275351189] //i:7 tmpbuffer:[0.550000000000000] //", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "#include <stdio.h> int main() {     char tmpbuffer[20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466, 0.02414235618335,-0.158289852824976, 1.54926741892562, 0.162671275351189, 0.55};     for (int i=0;i<8;i++) {         sprintf(tmpbuffer,\"%.15lg\",U13Coef[i]);         printf(\"i:%d tmpbuffer:[%s]\\n\",i,tmpbuffer);     }     return 0; } //i:0 tmpbuffer:[-4.28344451e-07] //i:1 tmpbuffer:[4.1556454936e-05] //i:2 tmpbuffer:[-0.001508777414466] //i:3 tmpbuffer:[0.02414235618335] //i:4 tmpbuffer:[-0.158289852824976] //i:5 tmpbuffer:[1.54926741892562] //i:6 tmpbuffer:[0.162671275351189] //i:7 tmpbuffer:[0.55] //", "referer": "user-0"}]}
{"question": "【求助】写一个统计文件中单词和字符个数的程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "k=open(\"in.txt\",\"r\")j=k.read()x=len(j)a=0for i in range(0,x+1):    if 65<=ord(j[i])<=90 or 97<=ord(j[i])<=122:        if ord(j[i+1])<65 or 90<ord(j[i+1])<97 or ord(j[i+1])>122:            a=a+1print(str(a)+\" \"+str(x-1))", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int main()                 //写一个统计文件中单词和字符个数的程序。在此，单词指的是仅由字母组成的串。诸如is7years这样的串按照两个单词计算。{ FILE *f; char word[100]; char c; int i =0,len,m=0,n=0; f = fopen(\"in.txt\",\"r\"); while((c=fgetc(f))!=EOF) {                                       word[i++] = c; } word[i]='\\0'; len = strlen(word); /*printf(\"%d\\n\",len);*/ for(i=0;i<len;i++) {     if(word[i]!='\\0') n++;      if((i==len-1) && ((word[i+1]>='a' && word[i+1]<='z') || (word[i+1]>='A' && word[i+1]<='Z')))     {         m++;         break;          }     if(((word[i]>='a' && word[i]<='z') || (word[i]>='A' && word[i]<='Z')))     {     if(((word[i+1]>='a' && word[i+1]<='z') || (word[i+1]>='A' && word[i+1]<='Z')))     {              continue;     }else{             m++;          }      } } printf(\"%d %d\",m,n); fclose(f);  }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "k=open(\"in.txt\",\"r\") j=k.read() x=len(j) a=0 for i in range(0,x+1):     if 65&lt;=ord(j[i])&lt;=90 or 97&lt;=ord(j[i])&lt;=122:         if ord(j[i+1])&lt;65 or 90&lt;ord(j[i+1])&lt;97 or ord(j[i+1])&gt;122:             a=a+1 print(str(a)+\" \"+str(x-1))", "referer": "user-2"}, {"cid": "4", "user": "user-3", "content": "写错了", "referer": "user-2"}, {"cid": "5", "user": "user-4", "content": "供参考：#include <stdio.h> #include <stdlib.h>  int main() {     char fname[]=\"in.txt\";     char str[1024];     int  i,sum=0,k=0,n;     FILE *fp;     if((fp = fopen(fname,\"r\")) == NULL){         printf(\"cannot open the file!\");         exit(0);     }     i=0;     while((str[i++]=fgetc(fp))!=EOF);//读入文件到数组     str[i-1] = '\\0';     fclose(fp);     n = i;     for(i=0;i<n;i++)  //文件内容输出         printf(\"%c\",str[i]);     for(i=0;i<n;i++){  //计算单词个数         if((str[i]<='z'&&str[i]>='a')||(str[i]<='Z'&&str[i]>='A')) {             k = 1;             continue;         }         if(k) sum++;         if(str[i]>'z'||str[i]<'a'||str[i]>'Z'||str[i]<'A'){             k = 0;             continue;         }     }     printf(\"\\n共%d个单词,共%d个字符\\n\",sum,n-1);          return 0; }   //I am an (BeiHang)student.is7years //共7个单词,共33个字符 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "k=open(\"in.txt\",\"r\") j=k.read() x=len(j) a=0 for i in range(0,x+1):     if 65&lt;=ord(j[i])&lt;=90 or 97&lt;=ord(j[i])&lt;=122:         if ord(j[i+1])&lt;65 or 90&lt;ord(j[i+1])&lt;97 or ord(j[i+1])&gt;122:             a=a+1 print(str(a)+\" \"+str(x-1))", "referer": "user-4"}, {"cid": "7", "user": "user-5", "content": "#include <stdio.h> #include <ctype.h> #include <string.h> #include <errno.h>  #define     FILE_PATH   \"in.txt\" #define     WORD_LEN    64 #define     METHOD_ONE  int main() {     FILE *fp; #ifdef METHOD_ONE     int flag = 0; #else     int pre_ch = 0; #endif     int ch, word_cnt = 0, ch_cnt = 0;     char word[WORD_LEN];     int i = 0;      fp = fopen(FILE_PATH, \"r\");     if (!fp) {         fprintf(stderr, \"open %s error: %s\\n\", FILE_PATH, strerror(errno));         return -1;     }      while ((ch = fgetc(fp)) != EOF) {         if (ch == '\\n')             continue;         ch_cnt++; #ifdef METHOD_ONE         if (isalpha(ch)) {             flag = 1;             if (i >= WORD_LEN - 1) {                 word[i] = 0;                 puts(word);                 fprintf(stdout, \"Word is too length!\\n\");                 i = 0;                 continue;             }             word[i++] = ch;         } else if (!isalpha(ch) && flag) {             word_cnt++;             word[i] = '\\0';             puts(word);             i = 0;             flag = 0;         } #else         if (isalpha(ch)) {             if (i >= WORD_LEN - 1) {                 word[i] = 0;                 puts(word);                 fprintf(stdout, \"Word is too length!\\n\");                 i = 0;                 continue;             }             word[i++] = ch;         }          if (!isalpha(ch) && isalpha(pre_ch)) {             word_cnt++;             word[i] = 0;             i = 0;             puts(word);         }         pre_ch = ch; #endif     }      fclose(fp);      printf(\"word:%d, ch:%d\\n\", word_cnt, ch_cnt);      return 0; } 供参考～", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "k=open(\"in.txt\",\"r\") j=k.read() x=len(j) a=0 for i in range(0,x+1):     if 65&lt;=ord(j[i])&lt;=90 or 97&lt;=ord(j[i])&lt;=122:         if ord(j[i+1])&lt;65 or 90&lt;ord(j[i+1])&lt;97 or ord(j[i+1])&gt;122:             a=a+1 print(str(a)+\" \"+str(x-1))", "referer": "user-5"}]}
{"question": "srand((unsigned)time(NULL))；如何声明time", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "缺少头文件吧，看看引入的头文件里有没time.h吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好了，谢谢各位", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "在随机数里要用time的话，就要#include <time.h>", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "还有上边的[M]我自己定义成了int型函数，不知道对不对", "referer": "user-0"}]}
{"question": "离散数学", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:穷举法，不行么？ 可以可以，之前两个字母写反了，一直出错", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "穷举法，不行么？", "referer": "user-0"}]}
{"question": "大佬，教教孩子吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 qzjhjxj 的回复:[quote=引用 4 楼 qq_57019597 的回复:] 这种是什么情况呀 哭了 头文件：Windows下为--> windows.h，Sleep是区分大小写的，有的编译器是大写，有的是小写。  第2行改为：  #include<windows.h>     第19行：Sleep(1); 第16行改为：if(fabs(x-1)<1e-6){  [/quote] 懂了懂了，谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 4 楼 qq_57019597 的回复: 这种是什么情况呀 哭了 头文件：Windows下为--> windows.h，Sleep是区分大小写的，有的编译器是大写，有的是小写。  第2行改为：  #include<windows.h>     第19行：Sleep(1); 第16行改为：if(fabs(x-1)<1e-6){", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这种是什么情况呀 哭了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢你们啦", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h> #include <unistd.h> #include <math.h>  int main(void) {     int i, j, k, z;     float x;      for (i = 1; ;i++)         for (j = 1; j <= i;j++)             for (k = 1; k <= j; k++)                 for (z = 1; z <= k; z++) {                     x = 1.0/i + 1.0/j + 1.0/k + 1.0/z;                      if (fabsf(x - 1) < 1e-6) {                         printf(\"%d, %d, %d, %d\\n\", i, j, k, z);                         printf(\"%.2f+%.2f+%.2f+%.2f = %.2f\\n\", 1.0/i, 1.0/j, 1.0/k, 1.0/z, x);                         sleep(1);                         //return 0;                     }                 }      return 0; } 供参考～  sleep需要等待一个一个的输出～", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "float a = 4, b = 4, c = 4,d = 4; 写完手工", "referer": "user-0"}]}
{"question": "C语言分割字符串strtok和strsep", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢楼上两位的指导，收获很大。 谢谢。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "仅供参考：#include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else                     return string; } void main() {     strcpy(string,\"A \\tstring\\t\\tof ,,tokens\\n\\nand some  more tokens, \");     strcpy(seps1,\",\\n\");strcpy(seps2,\" \\t\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234| LIYI|China | 010 |201110260000|OK\");     strcpy(seps1,\"|\");strcpy(seps2,\" \");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234|LIYI||010|201110260000|OK\");     strcpy(seps1,\"\");strcpy(seps2,\"|\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234|LIYI||010|201110260000|OK\");     strcpy(seps1,\"|\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",a\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",a,,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,a,,b,,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,,\");     strcpy(seps1,\",\");strcpy(seps2,\" \");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     } } // //[A      string          of ,,tokens // //and some  more tokens, ] //Tokens: // <A> <string> <of> <> <tokens> <> <and> <some> <more> <tokens> <> //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234> <LIYI> <China> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <> <010> <201110260000> <OK> //[a] //Tokens: // <a> //[a,b] //Tokens: // <a> <b> //[a,,b] //Tokens: // <a> <> <b> //[,a] //Tokens: // <> <a> //[a,] //Tokens: // <a> <> //[,a,,b] //Tokens: // <> <a> <> <b> //[,,a,,b,,] //Tokens: // <> <> <a> <> <b> <> <> //[,] //Tokens: // <> <> //[,,] //Tokens: // <> <> <> //[,,,] //Tokens: // <> <> <> <>", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "strdup返回是malloc的首地址，因此str会跟着变化，但是str_bak会保存的malloc的首地址，这样free(str_bak);就不会有问题。free的参数是malloc返回的值（地址值）；     引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h> #include <string.h>  int main(int arg, const char *argv[]) {     //char* string = strdup( \"aaa#test#test#\");          /*字符串不能为常量，所以strdup*/     char *str,  *str_bak;     char* p;      str = str_bak = strdup(\"aaa#test#test#\");          /*字符串不能为常量，所以strdup*/      while((p = strsep(&str, \"#\")) != NULL)     {         printf(\"%s\\n\", p);     }      free(str_bak);      return 0;  }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>  int main(int arg, const char *argv[]) {     //char* string = strdup( \"aaa#test#test#\");          /*字符串不能为常量，所以strdup*/     char *str,  *str_bak;     char* p;      str = str_bak = strdup(\"aaa#test#test#\");          /*字符串不能为常量，所以strdup*/      while((p = strsep(&str, \"#\")) != NULL)     {         printf(\"%s\\n\", p);     }      free(str_bak);      return 0;  }", "referer": "user-0"}]}
{"question": "从大到小排序，为啥我的结果是错的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "万分感谢，嘿嘿", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "if (k != i)引用缺少大括号  for (i = 0; i < 7; i++) {     k = i;     for (j = i + 1; j < 7; j++)         if (a[j] > a[k])             k = j;     if (k != i)     {         t = a[k];         a[k] = a[i];         a[i] = t;     } }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 自信男孩 的回复:#include<stdio.h>   //void main() int main() {     int a[7]={15,34,6,27,48,4,20},i,j,k,t;     printf(\"排序前的数列：\");     for(i=0;i<7;i++)         printf(\"%5d\",a[i]);     for(i=0;i<7;i++)     {         k=i;         for(j=i+1;j<7;j++)             if(a[j]>a[k])                 k=j; #if 0         if(k!=i){             t=a[k];a[k]=a[i];a[i]=t;         } #else         if (k != j)             t = a[k], a[k] = a[i], a[i] = t; #endif     }     printf(\"\\n从大到小排序后（选择法）\\n\");     for(i=0;i<7;i++)         printf(\"%5d\",a[i]);      printf(\"\\n\");      return 0; } 供参考～  少一个大括号，或者用逗号代替分号; 把if (k != j)改成if (k != i)因为上面初始的是k = i;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "把你的内层for循环里第二个if后交换的部分，三个语句加上花括号，那是个整体  if(k!=i)  { t=a[k];a[k]=a[i];a[i]=t; }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include<stdio.h>   //void main() int main() {     int a[7]={15,34,6,27,48,4,20},i,j,k,t;     printf(\"排序前的数列：\");     for(i=0;i<7;i++)         printf(\"%5d\",a[i]);     for(i=0;i<7;i++)     {         k=i;         for(j=i+1;j<7;j++)             if(a[j]>a[k])                 k=j; #if 0         if(k!=i){             t=a[k];a[k]=a[i];a[i]=t;         } #else         if (k != j)             t = a[k], a[k] = a[i], a[i] = t; #endif     }     printf(\"\\n从大到小排序后（选择法）\\n\");     for(i=0;i<7;i++)         printf(\"%5d\",a[i]);      printf(\"\\n\");      return 0; } 供参考～  少一个大括号，或者用逗号代替分号;", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "修改如下，供对照：#include<stdio.h> void main() {     int a[7]={15,34,6,27,48,4,20},i,j,k,t;     printf(\"排序前的数列：\");     for(i=0;i<7;i++)         printf(\"%5d\",a[i]);     for(i=0;i<7-1;i++)     {         k=i;         for(j=i+1;j<7;j++)            if(a[j]>a[k]) k=j;         if(k!=i)         {            t   =a[k];            a[k]=a[i];            a[i]=t;         }     }     printf(\"\\n从大到小排序后（选择法）\\n\");     for(i=0;i<7;i++)         printf(\"%5d\",a[i]);     printf(\"\\n\");      }", "referer": "user-0"}]}
{"question": "请问这道题答案为什么是20？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "夜已深，上面的发言有一些手误的地方。  规则一：除非明确指定，否则，子表达式的值计算和副作用是无序的； 规则二：对运算符的操作数的值计算，前序于运算符本身的值计算（也就是整个表达式的值）。  对于表达式 p -> age = p -> age ++ 来说，子表达式 p -> age ++ 的值计算用 V++ 表示，而 S++ 代表它的副作用；整个赋值表达式的副作用记为 S=。那么，依据规则，这里有两种可能的顺序：  先 V++（20），再 S++ （21），最后 S= （20）  或者  先 V++（20），再 S=（20），最后 S++（21）。  给赵4老湿点赞吧，我是代替赵老湿回答问题的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "p->age = p->age++;自增是有副作用的。要么p->age++;要么p->age = p->age + 1;楼主题目里的写法不常见，结果不好理解和推理，因为有矛盾在里面；  如果是20，那么p->age++的++最终要计算的。如果是21，那么就是先以p->age++为整体，然后再算++，相当于写了2次的age。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 1 楼 浪客 的回复:++在后面，先赋值再+1 我代表赵4老湿指出你的两点错误。  首先，表达式 p -> age = p -> age ++ 的行为是未定义的。最后输出的结果可能是 20，也可能是 21。  其次，说先 ++ ，再赋值，这是没有任何依据的。  后缀递增表达式的值是递增前的原值，同时还有修改操作数存储值的副作用。所以，从总体上，表达式 p -> age = p -> age ++ 有三个基本动作：  1，计算表达式 p -> age ++ 的值。这个值是结构成员 age 的原始值 20； 2，表达式 p -> age ++ 发起一个副作用，这会修改结构成员 age 的存储值，修改为 21； 3，表达式  p -> age = p -> age ++ 发起一个副作用，用子表达式 p -> age ++ 的值修改赋值运算符左边的 p -> page，修改为 20。 注意，表达式   p -> age = p -> age ++ 也要计算一个值，它是 p -> page 被赋值后的值，但被丢弃，所以不用管。  以上三个动作按什么顺序发生呢？按照规定，必须先计算运算符操作数的值。总体上，先计算子表达式 p -> age ++ 的值，这个值是 20。所以，这三个动作发生的次序可能是 2 -> 1 -> 3 也可能是 2 -> 3 -> 1 不管哪种顺序，成员 age 都会被写入两次，但最终结果不同。如果是第一种顺序，那么，成员 age 最终的值是 20；如果是第二种顺序，则成员 age 最终的值是 21。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "++在后面，先赋值再+1", "referer": "user-0"}]}
{"question": "警告处理", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 13 楼 赵4老师 的回复:被鄙视相对被无视还是要好很多。我的阿Q精神胜利法又奏效了。 赵4老湿，你个糟老头子，坏得很。朕要忙去了，过半个月再来看你们都咧咧啥了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "被鄙视相对被无视还是要好很多。我的阿Q精神胜利法又奏效了。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 9 楼 赵4老师 的回复:我要说的话别人都替我说完了。 “别人”？太不礼貌了。赵4，还老湿呢，朕鄙视你。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 8 楼 均陵鼠侠的回复:[quote=引用 5 楼 佛系咸鱼en 的回复:][quote=引用 楼主 佛系咸鱼en的回复:]出现这个警告该如何处理，求指点 for (int j = 0; j < 20; ++j)  \t\t{ \t\t\tif (d[i] == j) \t\t\t{ \t\t\t\tk[i] = j; \t\t\t\tbreak; \t\t\t} \t\t\telse if (d[i] > j && d[i] < j + 1) //其中数组d为double在j+1处有误 \t\t\t{ \t\t\t\tk[i] = j + 1; \t\t\t\tbreak; \t\t\t}  \t\t}[/quote]  窝哈哈哈，原来如此。赵4老湿将会告诉你，对于表达式 d [i] < j + 1 来说，依据常规算术转换（Usual arithmetic conversions）的规则，要先计算子表达式 d [i] 和 j + 1 的值，再将这两个值转换为相同的类型，然后进行比较。  子表达式 d [i] 的结果类型是 double，先按下不表；  在子表达式 j + 1 中，子表达式 j 的类型是 int ，常量 1 的类型也是 int，相加后的结果类型是 int。  如此一来，需要将子表达式 j + 1 的结果从它原来的 int 类型转换为 double 类型。  但是，在计算子表达式 j + 1 的时候，如果 j 的值是 int 类型的最大值，则这个计算可能会溢出。在这种情况下，编译器就可能会倾向于认为，既然表达式 j + 1 的结果迟早要转换为 double ，那么，何不将 j 或者 1 提前转换为 double 呢？这样就可以避免溢出。例如： d [i] < (double) j + 1; 或者 d [i] < j + 1.0; 不管是采用哪一种方式，对于加法运算来说，也是先进行常规算术转换，将两个操作数都转换为 double 类型，于是相加的结果自然是不会溢出的、double 类型的值。[/quote] 太详细了，非常感谢，比心❤️", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 9 楼 赵4老师的回复:我要说的话别人都替我说完了。 你们两个太好了，感谢，比心❤️", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "我要说的话别人都替我说完了。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用 5 楼 佛系咸鱼en 的回复:[quote=引用 楼主 佛系咸鱼en的回复:]出现这个警告该如何处理，求指点 for (int j = 0; j < 20; ++j)  \t\t{ \t\t\tif (d[i] == j) \t\t\t{ \t\t\t\tk[i] = j; \t\t\t\tbreak; \t\t\t} \t\t\telse if (d[i] > j && d[i] < j + 1) //其中数组d为double在j+1处有误 \t\t\t{ \t\t\t\tk[i] = j + 1; \t\t\t\tbreak; \t\t\t}  \t\t}[/quote]  窝哈哈哈，原来如此。赵4老湿将会告诉你，对于表达式 d [i] < j + 1 来说，依据常规算术转换（Usual arithmetic conversions）的规则，要先计算子表达式 d [i] 和 j + 1 的值，再将这两个值转换为相同的类型，然后进行比较。  子表达式 d [i] 的结果类型是 double，先按下不表；  在子表达式 j + 1 中，子表达式 j 的类型是 int ，常量 1 的类型也是 int，相加后的结果类型是 int。  如此一来，需要将子表达式 j + 1 的结果从它原来的 int 类型转换为 double 类型。  但是，在计算子表达式 j + 1 的时候，如果 j 的值是 int 类型的最大值，则这个计算可能会溢出。在这种情况下，编译器就可能会倾向于认为，既然表达式 j + 1 的结果迟早要转换为 double ，那么，何不将 j 或者 1 提前转换为 double 呢？这样就可以避免溢出。例如： d [i] < (double) j + 1; 或者 d [i] < j + 1.0; 不管是采用哪一种方式，对于加法运算来说，也是先进行常规算术转换，将两个操作数都转换为 double 类型，于是相加的结果自然是不会溢出的、double 类型的值。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "警告的内容是让你用4字节存储的数据改成8字节存储，因为已经溢出了。贴代码吧，或许更好的解决问题～", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "short int si; int i; i=(int)si+10000;", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "Warning C26451", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 1 楼 user-4的回复:Warning C26451 有看过，有点无从下手", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 4 楼 均陵鼠侠的回复:[quote=引用 2 楼 赵4老师 的回复:]short int si; int i; i=(int)si+10000; 不得了，赵4老湿终于回来了。大家快来看呐，别让他跑了！ short int si; int i; i = (int) si + 10000; 嘻，赵老湿你是认真的吗？ 变量 si 没有初始化或者赋值，而且，10000 是一个整型常量，它的类型是 int。在做这个加法运算时， 要对变量 si 的值做整型提升。提升之后，两个操作数的类型相同，不再进一步转换，直接做加法。  当然，赵老湿说这我知道，我只是做一个例子来说明，不要在意这些细节。不过我有一个更好的例子： char c; int i = 50; c = i + 60ULL; 赵老湿你看，这个例子多明显呐。唉，不过楼主的信息不完整，人家写的也许并不是 C 语言程序。[/quote] 是C语言程序", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 楼主 佛系咸鱼en的回复:出现这个警告该如何处理，求指点 for (int j = 0; j < 20; ++j)  \t\t{ \t\t\tif (d[i] == j) \t\t\t{ \t\t\t\tk[i] = j; \t\t\t\tbreak; \t\t\t} \t\t\telse if (d[i] > j && d[i] < j + 1) //其中数组d为double在j+1处有误 \t\t\t{ \t\t\t\tk[i] = j + 1; \t\t\t\tbreak; \t\t\t}  \t\t}", "referer": "user-0"}, {"cid": "14", "user": "user-1", "content": "引用 2 楼 赵4老师 的回复:short int si; int i; i=(int)si+10000; 不得了，赵4老湿终于回来了。大家快来看呐，别让他跑了！ short int si; int i; i = (int) si + 10000; 嘻，赵老湿你是认真的吗？ 变量 si 没有初始化或者赋值，而且，10000 是一个整型常量，它的类型是 int。在做这个加法运算时， 要对变量 si 的值做整型提升。提升之后，两个操作数的类型相同，不再进一步转换，直接做加法。  当然，赵老湿说这我知道，我只是做一个例子来说明，不要在意这些细节。不过我有一个更好的例子： char c; int i = 50; c = i + 60ULL; 赵老湿你看，这个例子多明显呐。唉，不过楼主的信息不完整，人家写的也许并不是 C 语言程序。", "referer": "user-0"}]}
{"question": "求帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你得贴运行图，才知道是向左错还是向上错的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf(\"%d\\n\",&a[i]); 试试？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "从代码上看没什么问题的，不知道你的输入数据是怎么样的，结果不对又是什么内容，所以贴出你运行时的测试数据和结果～", "referer": "user-0"}]}
{"question": "C语言程序设计题，帮帮忙。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "老赵比曹操跑的快~", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 4 楼 lin5161678 的回复:[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h>  int count(int n);  int main() {     int m;      scanf(\"%d\", &m);      printf(\"%d\\n\", count(m));     return 0; }  int count(int n) {     static int bit;     if (n == 0)         return 0;     bit++;     count(n/10);      return bit; }  供参考～不应该使用static 这样写 调用2次就错了[/quote] 考虑改进呀，没有不应该，只有做不好。   #include <stdio.h>  static int bit; int count(int n);  int main() {     int m, ret;      do {         ret = scanf(\"%d\", &m);         printf(\"%d\\n\", count(m));         bit = 0;     } while (ret == 1);      return 0; }  int count(int n) {     if (n == 0)         return 0;     bit++;     count(n/10);      return bit; } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h>  int count(int n);  int main() {     int m;      scanf(\"%d\", &m);      printf(\"%d\\n\", count(m));     return 0; }  int count(int n) {     static int bit;     if (n == 0)         return 0;     bit++;     count(n/10);      return bit; }  供参考～不应该使用static 这样写 调用2次就错了", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 2 楼 早打大打打核战争 的回复:int count(int n) {   return n < 10 ? 1 : count(n / 10) + 1; } 你这是抄袭我已经想好的，但还没有发表出来的答案！我代表赵4老湿严肃滴批评你！", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "引用 3 楼 均陵鼠侠 的回复:[quote=引用 2 楼 早打大打打核战争 的回复:]int count(int n) {   return n < 10 ? 1 : count(n / 10) + 1; } 你这是抄袭我已经想好的，但还没有发表出来的答案！我代表赵4老湿严肃滴批评你！[/quote]  那也应该跟老赵没关系吧~", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "int count(int n) {   return n < 10 ? 1 : count(n / 10) + 1; }", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "#include <stdio.h>  int count(int n);  int main() {     int m;      scanf(\"%d\", &m);      printf(\"%d\\n\", count(m));     return 0; }  int count(int n) {     static int bit;     if (n == 0)         return 0;     bit++;     count(n/10);      return bit; }  供参考～", "referer": "user-0"}]}
{"question": "64位全FF左右移64位还是全FF是为什么？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 user-2 的回复:任何情况下，若 rhs 为负或大于或等于提升后的 lhs 中的位数，则行为未定义。  https://zh.cppreference.com/w/c/language/operator_arithmetic 引用 3 楼 自信男孩 的回复:https://blog.csdn.net/huqinwei987/article/details/70941199 供参考～  感谢两位的回答。结帖撒花。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "https://blog.csdn.net/huqinwei987/article/details/70941199 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "任何情况下，若 rhs 为负或大于或等于提升后的 lhs 中的位数，则行为未定义。  https://zh.cppreference.com/w/c/language/operator_arithmetic", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "上边是GDB调试打印信息，下边是源码，就这几行", "referer": "user-0"}]}
{"question": "R7-7 找出数组中元素的最大数，并指出其位置 (10 分) ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<string.h>  #define MAX_SIZE    10  int main(void) {     int array[MAX_SIZE];     int i, idx = 0;      for (i = 0; i < MAX_SIZE; i++) {         scanf(\"%d\", &array[i]);         if (array[i] > array[idx])             idx = i;     }       printf(\"No.%d = %d\\n\", idx+1, array[idx]);     return 0; }   供参考～  如果在数组内有多个相同的最大值，那么需要特殊处理一下，楼主可以自己试着修改一下～", "referer": "user-0"}]}
{"question": "Python：随机产生10个100以内的整数，找出差值相差最小的两个整数。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这是C/C++的板块，你提用python？C语言可以实现一下", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "import random origin_list = [random.randint(0, 99) for i in range(10)] print(\"10个100以内的随机整数是：\", origin_list) origin_list.sort() dif_list = [[origin_list[i] - origin_list[i-1], (origin_list[i], origin_list[i-1])] for i in range(1, len(origin_list))] dif_list.sort(key=lambda x: x[0]) result = [i[1] for i in dif_list if i[0] == dif_list[0][0]] print(\"差值最小的两个数是：\", result, \",其差为：\", dif_list[0][0])", "referer": "user-0"}]}
{"question": "求助！！！！使用c/c++读取16进制文件问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "解决链接： Java实现将16进制转10进制浮点型输出到文件中： https://blog.csdn.net/weixin_43917334/article/details/117033747 c语言16进制转txt可读文件： https://blog.csdn.net/weixin_43917334/article/details/117033192", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "FILE *fp=fopen(\"d.txt\",\"w\"); fprintf(fp,\"%g\\n\",f); fclose(fp);", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "将起始地址对应的数强制类型转换为float *类型后，取其值即可。如果字节序反了，先颠倒一下。 float f; unsigend char b[4]={0xBA,0x12,0x2A,0x43}; f=*(float *)&b[0];", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "先读取到缓存里（按照字符串），然后可以考虑调用sscanf，转换成对应数值，memcpy到int数据内（4个一组）", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "已解决：方案  使用c语言把dat文件转txt文件然后使用Java按行读取txt，将每8个字符串进行一次转换", "referer": "user-0"}]}
{"question": "输入正整数n，计算s = 1/1! + 1/2! + 1/3! + ……+ 1/n!的值。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "???有毒", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "???", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "楼主什么问题？头文件写到函数内，没见过这么写的呢。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "供参考：#include<stdio.h>  int main() {     int    j,k,n;     double f,s;      scanf(\"%d\",&n);     s=0.0;          //2分     for(k=1;k<=n;k++){         f=1.0;      //2分         for(j=1;j<=k;j++)//3分            f *= j;   //3分         s=s+1.0/f;     }     printf(\"sum=%f\\n\",s);          return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "厉害", "referer": "user-4"}]}
{"question": "程序运行时出现堆已损坏", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该是文件路径问题吧，可以通过strerror(errno);看一下fopen打开失败的原因。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "蹭分的来了[face]emoji:019.png[/face]", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "已经解决了，但是无满意结帖不退分，不想浪费分数，随便来几个人我把分散一下", "referer": "user-0"}]}
{"question": "大佬们求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：//1.输出1~100之间 各位数的乘积 > 各位数的和 的数  #include<stdio.h>  int fun(int n) {     int sum=0,product=1,m;     while(n){           m = n%10;           product *= m;           sum += m;           n /= 10;     }     if(product > sum)        return 1;     else        return 0; }  int main() {     int i,j=0;     for(i=1;i<100;i++)         if(fun(i))printf(\"%d%c\",i,++j%9!=0?' ':'\\n');         return 0; } //2.哥德巴赫猜想  #include<stdio.h>  int  isPrime(int n) {     int i;     if(n<=3) return n>1;     for(i=2;i*i<=n;i++)        if(n%i == 0) return 0;     return 1; }  int main() {     int i,j;     for (i=4;i<=20;i+=2){         for(j = i/2; j >= 2; j--){             if(isPrime(j) && isPrime(i-j)){                printf(\"%2d = %2d + %2d\\n\",i,j,i-j);//输出                break;             }         }     }          return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第一题   void test() {     int n,k,s;     for(n=11; n<100; n++)     {         k=(n%10)*(n/10);         s=n%10+n/10;         if(k>s)         {             printf(\"%d\\n\",n);         }     } }", "referer": "user-0"}]}
{"question": "单片机数码管显示万年历", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "单片机也要说明是哪类的,万年历也要说明是否含农历.", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不会的时候，基础总要会的，上网找个别人做的例程，运行仿真，结合现象来看代码，理解一点后，尝试 修改代码仿真测试", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "proteus仿真和keil软件不会，", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "1.设计个电路板，自己焊接一下。 2.业务逻辑，用单片机处理。 3.处理结果，送数码管显示出来即可。", "referer": "user-0"}]}
{"question": "求一元二次方程的解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 user-2 的回复:修改如下，供参考：#include <stdio.h> #include <math.h>  void Calculate(double a, double b, double c) {       double esp=pow(10,-6);//防止输出 -0.0000       if(a==0) return;       double m = b * b - 4 * a * c;       if (m == 0)       {           printf(\"该方程只有一个根:x=%.4f\\n\",(-b)/(a * 2)+esp);       }       if (m > 0)       {           printf(\"该方程有两个不同的实根\\n\");           double m0 = (-b + sqrt(m)) / (2 * a)+esp;           double n0 = (-b - sqrt(m)) / (2 * a)+esp;           printf(\"x1=%.4f x2=%.4f\\n\",m0,n0);       }       if (m < 0)       {           printf(\"该方程有两个不同的复数根\\n\");           if (b != 0)           {               double m1 = -b  / (2 * a)+esp;               double m2 = sqrt(-m) / (2 * a)+esp;               double n1 = -b  / (2 * a)+esp;               double n2 = - sqrt(-m) / (2 * a)+esp;               printf(\"x1=%.4f%c%.4fi x2=%.4f%c%.4fi\\n\",m1,(m2 > 0 ? '+' : '-'),fabs(m2),                                                        n1,(n2 > 0 ? '+' : '-'),fabs(n2));           }           else           {               double m3 = sqrt(-m) / (2 * a)+esp;               double n3 = -sqrt(-m)/ (2 * a)+esp;               printf(\"x1=%.4fi x2=%.4fi\\n\",m3,n3);           }       } }  int main() {       double a, b, c;        scanf(\"%lf%lf%lf\",&a,&b,&c);       Calculate(a, b, c);              return 0; }  关于浮点数与0的比较，不能完全按照整型数与0直接进行比较；可以参考楼主的比较fabsf(m) < 1e-6（单精度），双精度:fabs(m) < 1e-16  https://blog.csdn.net/qq_40679299/article/details/79338570 https://www.cnblogs.com/youxin/p/3306136.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改如下，供参考：#include <stdio.h> #include <math.h>  void Calculate(double a, double b, double c) {       double esp=pow(10,-6);//防止输出 -0.0000       if(a==0) return;       double m = b * b - 4 * a * c;       if (m == 0)       {           printf(\"该方程只有一个根:x=%.4f\\n\",(-b)/(a * 2)+esp);       }       if (m > 0)       {           printf(\"该方程有两个不同的实根\\n\");           double m0 = (-b + sqrt(m)) / (2 * a)+esp;           double n0 = (-b - sqrt(m)) / (2 * a)+esp;           printf(\"x1=%.4f x2=%.4f\\n\",m0,n0);       }       if (m < 0)       {           printf(\"该方程有两个不同的复数根\\n\");           if (b != 0)           {               double m1 = -b  / (2 * a)+esp;               double m2 = sqrt(-m) / (2 * a)+esp;               double n1 = -b  / (2 * a)+esp;               double n2 = - sqrt(-m) / (2 * a)+esp;               printf(\"x1=%.4f%c%.4fi x2=%.4f%c%.4fi\\n\",m1,(m2 > 0 ? '+' : '-'),fabs(m2),                                                        n1,(n2 > 0 ? '+' : '-'),fabs(n2));           }           else           {               double m3 = sqrt(-m) / (2 * a)+esp;               double n3 = -sqrt(-m)/ (2 * a)+esp;               printf(\"x1=%.4fi x2=%.4fi\\n\",m3,n3);           }       } }  int main() {       double a, b, c;        scanf(\"%lf%lf%lf\",&a,&b,&c);       Calculate(a, b, c);              return 0; }", "referer": "user-0"}]}
{"question": "请问这道题我的答案为什么不对？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主这么说，我还是很高兴的，这又给了我继续在这里混的兴趣。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 20 楼 均陵鼠侠的回复:[quote=引用 12 楼 早打大打打核战争 的回复:]你的答案是错的，老师的答案是对的。*a实际上是a[0]，不是a[0][0]，是int[3]类型，所以 int a[2][3]={{1,2,3},{4,5,6}}; int i,j;  for(i=0; i<2;i++) for(j=0;j<3;j++) printf(\"%d \",*(*a+5*i+j)); i=0时输出的是*(a[0]+0)==a[0][0]、*(a[0]+1)==a[0][1]、*(a[0]+2)==a[0][2] i=1时输出的则是*(a[0]+5+0)==a[0][5]==a[1][2]、*(a[0]+5+1)==a[0][6]、*(a[0]+5+2)==a[0][7]，越界了  不，表达式 * a 的确是得到了数组 a 的首元素，但因为这个元素的类型是数组，所以，就表达式 * (* a + 5 * i + j) 而言，它会继续转换为指向数组首元素的指针。即，转换为指向“数组 a 的首元素的首元素”的指针。有点绕，其实就是指向 a [0][0] 的指针。  还有，楼主的答案是正确的，没有任何问题，前面有我的分析过程（虽然我知道基本上没人看，但我还是写出来了）。有不同意见请提出，我们继续讨论。[/quote] 我有认真看了一遍的 感谢您认真仔细的解答对我这个刚接触c语言的小白很有帮助", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "啊，我是依据楼主的程序写的，但是楼主的程序写错了(当时我也没注意到楼主程序的数组和题目不一样)，所以那个分析的结论无效(不过分析过程还是对的，只是无的放矢了)～～～", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 12 楼 早打大打打核战争 的回复:你的答案是错的，老师的答案是对的。*a实际上是a[0]，不是a[0][0]，是int[3]类型，所以 int a[2][3]={{1,2,3},{4,5,6}}; int i,j;  for(i=0; i<2;i++) for(j=0;j<3;j++) printf(\"%d \",*(*a+5*i+j)); i=0时输出的是*(a[0]+0)==a[0][0]、*(a[0]+1)==a[0][1]、*(a[0]+2)==a[0][2] i=1时输出的则是*(a[0]+5+0)==a[0][5]==a[1][2]、*(a[0]+5+1)==a[0][6]、*(a[0]+5+2)==a[0][7]，越界了  不，表达式 * a 的确是得到了数组 a 的首元素，但因为这个元素的类型是数组，所以，就表达式 * (* a + 5 * i + j) 而言，它会继续转换为指向数组首元素的指针。即，转换为指向“数组 a 的首元素的首元素”的指针。有点绕，其实就是指向 a [0][0] 的指针。  还有，楼主的答案是正确的，没有任何问题，前面有我的分析过程（虽然我知道基本上没人看，但我还是写出来了）。有不同意见请提出，我们继续讨论。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "题目中的数组是int a[3][5]; 楼主可能为了省事，测试代码用的是int a[2][3]; 但是数组元素计算公式没有改 printf(\"%d \",*(*a+5*i+j)); 应该是 printf(\"%d \",*(*a+3*i+j));", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 16 楼 forever74的回复:[quote=引用 4 楼 m0_55062981 的回复:][quote=引用 1 楼 forever74的回复:]你的答案没错。  老师的错误在于，如果没有耐心分析学生的答案，那就不要出开放式的题目。 那个请问这样运行了代码只有第一行输出正确，其它行都是乱的是哪里出了问题吗？[/quote]  显然是你的验证代码写得不对。[/quote] 是的 非常感谢", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 17 楼 早打大打打核战争的回复:题目中的数组是int a[3][5]; 楼主可能为了省事，测试代码用的是int a[2][3]; 但是数组元素计算公式没有改 printf(\"%d \",*(*a+5*i+j)); 应该是 printf(\"%d \",*(*a+3*i+j)); 对 我代码写错了", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 4 楼 m0_55062981 的回复:[quote=引用 1 楼 forever74的回复:]你的答案没错。  老师的错误在于，如果没有耐心分析学生的答案，那就不要出开放式的题目。 那个请问这样运行了代码只有第一行输出正确，其它行都是乱的是哪里出了问题吗？[/quote]  显然是你的验证代码写得不对。", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "结果跟编译器有关？&a[i][j]是个整形数的指针，加1就是地址移动一个整形数位置，*a取的是数组名所代表的指针。那代表的是整形数的指针？整形数组的指针？存在两种解释，若是整形数的指针，结果是一样的;要是整形数组的指针，加1表示地址加了一个数组长度，就访问溢出了，就有问题了。", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "理解和讨论之前请先学会如何观察！  //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]   不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "int a[][]; 可能的结果是： 系统同步声明了以下几个标记（a[][], *a[], **a;），类似*a操作是不规范但不少系统会支持的标记。 数组的[]标记和指针的*还有引用的&标记，严格的讲，是可以互相取代但却有不同含义或者不同实现的。（&标记比较常用于单个数据，较少应用于数组操作） 过去有不少黑客尝试在不支持指针的系统（比如：Java）中通过null数组获取void指针（好像没有成功，至少没有相关的危害报告）。", "referer": "user-0"}, {"cid": "13", "user": "user-2", "content": "你的答案是错的，老师的答案是对的。*a实际上是a[0]，不是a[0][0]，是int[3]类型，所以 int a[2][3]={{1,2,3},{4,5,6}}; int i,j;  for(i=0; i<2;i++) for(j=0;j<3;j++) printf(\"%d \",*(*a+5*i+j)); i=0时输出的是*(a[0]+0)==a[0][0]、*(a[0]+1)==a[0][1]、*(a[0]+2)==a[0][2] i=1时输出的则是*(a[0]+5+0)==a[0][5]==a[1][2]、*(a[0]+5+1)==a[0][6]、*(a[0]+5+2)==a[0][7]，越界了", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 6 楼 focuslight的回复:你代码贴出来看看 请您帮忙看看 #include <stdio.h> int main() { \tint a[2][3]={{1,2,3},{4,5,6}}; \tint i,j;  \tfor(i=0; i<2;i++) \t\tfor(j=0;j<3;j++) \t\t\tprintf(\"%d \",*(*a+5*i+j)); }", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 7 楼 均陵鼠侠的回复:首先，题目本身是值得商榷的。题目中暗示 a 的元素类型为 int，但其实不然。a是一个元素类型为 int [5]的数组。如下图所示，a 是具有3个元素的、元素类型为“具有5个int类型元素的数组”。  表面上看，这是一个扣字眼的无聊话题，但它很重要，尤其是有助于分析含有数组的表达式。言归正传，就题目的实际所指而言，楼主的答案是：  * (* (a + i) + j) * (* a + 5 * i + j)  先来看第一个答案。首先，表达式 a 的类型为 int [3][5]，在这里自动转换为指向数组 a 首元素的指针。数组 a 的元素类型是 int [5]，所以转换为 int (*) [5]；  接着，表达式 a + i 得到另一个指针，指向数组 a 的元素 i，元素的类型是 int [5]；  接着，表达式 * (a + i) 得到指针所指向的实体，即，得到数组 a 的元素 i，元素的类型是 int [5]；  接着，因为数组 a 的元素 i 是数组（即，表达式 * (a + i) 的结果是 int [5] 类型的数组），在这里自动转换为指向其首元素的指针。元素的类型是 int ，所以转换为指向 int 的指针，指向数组 a 的元素 i 的元素 0。  接着，表达式 * (a + i) + j 的结果是指针，指向数组 a 的元素 i 的元素 j；  最后，表达式 * (* (a + i) + j) 的结果是得到数组 a 的元素 i 的元素 j 本身。当然了，在一个需要值的场合，这个左值会执行左值转换，转换为该元素的存储值。  所以，第一个答案是正确的。  再来看第二个答案。首先，表达式 a 的类型为 int [3][5]，在这里自动转换为指向数组 a 首元素的指针。数组 a 的元素类型是 int [5]，所以转换为 int (*) [5]；  接着，表达式 * a 得到指针所指向的实体，即，得到数组 a 的首元素。数组 a 的元素类型是 int [5]，所以是得到一个 int [5] 类型的数组。因为后面要做加法，所以这个数组自动转换为指向其首元素的指针（int *），实际上指向数组 a 的元素 0 的元素 0；  接着，表达式 * a + 5 * i 将刚才的指针向后移动 5 * i 个 int 大小的位置。在 C 语言里，数组的成分具有连续分配的特点，所以，这实际上是得到一个指向数组 a 的元素 i 的元素 0 的指针；  接着，表达式 * a + 5 * i + j 继续移动指针，再移动 j 个 int 大小的位置，得到一个指向数组 a 的元素 i 的元素 j 的指针。  最后，表达式 * (* a + 5 * i + j) 的结果是得到数组 a 的元素 i 的元素 j 本身。当然了，在一个需要值的场合，这个左值会执行左值转换，转换为该元素的存储值。  所以，第二个答案也是正确的。  通过上面的分析可知，表达式 * a 等价于 & a [0][0] 。既然 & a [0] [0] 可以使用，那么 * a 也没有任何问题。 好的 非常感谢", "referer": "user-0"}, {"cid": "16", "user": "user-7", "content": "你代码贴出来看看", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "引用 2 楼 focuslight的回复:运行代码一下，你的答案也对，可能题库里答案没你这种形式。  a表示二维数组a的首地址，而*a表示二维数组a第一行a[0]的首地址。这样在使用的时候就有所区别。比如 对a的操作a[4]表示a的第四行首地址，而对*a的操作(*a)[4]则代表第一行的第4个元素，即a[0][4]。 请问我运行了一下代码只有第一行输出正确其它行都是乱的是哪里出了问题吗？那个题目的正确答案我也试了都是一样的", "referer": "user-0"}, {"cid": "18", "user": "user-0", "content": "引用 1 楼 forever74的回复:你的答案没错。  老师的错误在于，如果没有耐心分析学生的答案，那就不要出开放式的题目。 那个请问这样运行了代码只有第一行输出正确，其它行都是乱的是哪里出了问题吗？", "referer": "user-0"}, {"cid": "19", "user": "user-8", "content": "题目明确指出五种访问方式, 显然标准答案是最适合的. 楼主的答案仅仅是等价而已. 第5种强调的是从基地址(&a[0][0])出发的一种访问方式. 用*a表达第0个元素的地址,已在第3种方式中体现.", "referer": "user-0"}, {"cid": "20", "user": "user-7", "content": "运行代码一下，你的答案也对，可能题库里答案没你这种形式。  a表示二维数组a的首地址，而*a表示二维数组a第一行a[0]的首地址。这样在使用的时候就有所区别。比如 对a的操作a[4]表示a的第四行首地址，而对*a的操作(*a)[4]则代表第一行的第4个元素，即a[0][4]。", "referer": "user-0"}]}
{"question": "[c语言求助]", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "open -- read -- /* 处理 */ -- close", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "少不了打开文件，读取文件，然后是一些类似字符串判断的操作；特定的一条可能会考虑使用字符串比较～", "referer": "user-0"}]}
{"question": "c语言毕设看不太懂啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所有LED端口设置为推挽输出，且输出为低电平。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "“将所有LED端口的模式设置为推拉模式，并将输出电平设置为低电平 ” 这是数模电相关的吧，", "referer": "user-0"}]}
{"question": "求大神解答一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "非常感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考：//输入十进制数，转换为 r进制 数输出。 #include<stdio.h> #include<string.h>  int n,r,count=0; void print( int x ) {      if( x <= 9 )          printf( \"%d\",x );      else          printf( \"%c\",x - 10 + 'A' );  } void change( int n,int r ) {      if( n )  //递归条件是：n/r != 0      {          change( n / r, r ); //递归调用          print( n % r );      }  } int main( ) {     scanf( \"%d%d\",&n,&r ) ;     change( n,r );    //递归函数          return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:[quote=引用 2 楼 m0_58034981 的回复:]嗯，谢谢，同时请问一下chang(n / r,r)是什么意思 同样的道理嘛， n/r的结果给change的第一个形参n，r给第二个形参r，虽然是同名但是在内存中是相互独立的。[/quote] 非常感谢你。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 2 楼 m0_58034981 的回复:嗯，谢谢，同时请问一下chang(n / r,r)是什么意思 同样的道理嘛， n/r的结果给change的第一个形参n，r给第二个形参r，虽然是同名但是在内存中是相互独立的。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "嗯，谢谢，同时请问一下chang(n / r,r)是什么意思", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "print( n % r );print是一个自定义函数，形参是int类型的，n%r就是把结果作为实参传递给形参；即n % r的结果赋值给x", "referer": "user-0"}]}
{"question": "为什么在 DLL 中 malloc() 的内存出现 access violation", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢各位的回复，经过了一段时间的尝试，我把这段代码挂到进程上去调试，最后找到问题的所在了，来此结帖，并感谢各位的热心回复。代码上各位看不出问题来，是因为有问题的地方其实没有体现出来，在第二个malloc()调用所处的文件中，我没有写 #include <stdlib.h>，我使用的编译器也没有报错 (C99 的话这里会报错)，导致了 malloc() 函数成为了隐式声明函数，隐式函数声明默认返回值是 int，所以返回值从 void* 被编译器改成了 int，机器现在都是 64 位的，指针的高 32 位地址由于返回值是 int 被截断，后续再尝试访问这个地址空间，肯定属于非法操作了，因此出现了 access violation。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢各位的回复，经过了一段时间的尝试，我把这段代码挂到进程上去调试，最后找到问题的所在了，来此结帖，并感谢各位的热心回复。代码上各位看不出问题来，是因为有问题的地方其实没有体现出来，在第二个malloc()调用所处的文件中，我没有写 #include <stdlib.h>，我使用的编译器也没有报错 (C99 的话这里会报错)，导致了 malloc() 函数成为了隐式声明函数，隐式函数声明默认返回值是 int，所以返回值从 void* 被编译器改成了 int，机器现在都是 64 位的，指针的高 32 位地址由于返回值是 int 被截断，后续再尝试访问这个地址空间，肯定属于非法操作了，因此出现了 access violation。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 7 楼 forever74 的回复:我觉得鼠侠的意思是，这段代码是在把油门当作刹车踩，因此不能以此为证据说明刹车有问题。 而我想刹车或许是好的，或许有问题，或许...好吧，我没见过那辆车。 是的。 而且单就已经公布的这部分代码来说，是没有任何问题的。毕竟你很难想象内存已经分配成功却无法用一个简单的表达式来访问，这是不可思议的。如果代码检查和调试的方法都已经用过了，那就试着从编写一个最简单的DLL，只包含以上功能（再添加一个释放内存的接口，在DLL中分配内存，也应该在DLL中释放，不然可能会出问题的），如果没有问题，再说。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "我一直觉得，论坛什么的只能解决领进门阶段的一些小问题，到了修行在个人的阶段，论坛就没啥用了。 四老师强调在入门阶段多锻炼调试，我想就是这个意思。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "我觉得鼠侠的意思是，这段代码是在把油门当作刹车踩，因此不能以此为证据说明刹车有问题。 而我想刹车或许是好的，或许有问题，或许...好吧，我没见过那辆车。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:C Run-Time Libraries https://msdn.microsoft.com/en-us/library/abx4dbyh.aspx感谢回复，但是我感觉我这个问题和CRT没什么太大的关系，因为我在DLL的AMI_init()函数中也 malloc()了内存，都能正常访问，但是在AMI_Get()函数中的malloc()就不行了。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 5 楼 均陵鼠侠 的回复:你给出的信息相对有限，而且程序也是错的，所以通常没有办法准确判断。 struct {     int data;     struct list* next; }list;   void init() {     struct list* n;     n = (struct list*)malloc(sizeof(struct list));     // access n->data caused memory access violation. } 就这，list 是一个变量，你确定 struct list 是合法的并且这段代码能通过编译？  感谢回复，抱歉造成疑惑，全部的代码很长，我怕误导大家，这是我自己随手写的一段主要的示意，我感觉上觉得和DLL被两次调用有关，第一次调用 AMI_Init()，第二次调用 AMI_Get()，但是似乎第二次调用和第一次调用之间的内存空间是两个导致越界无法访问。", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "你给出的信息相对有限，而且程序也是错的，所以通常没有办法准确判断。 struct {     int data;     struct list* next; }list;   void init() {     struct list* n;     n = (struct list*)malloc(sizeof(struct list));     // access n->data caused memory access violation. } 就这，list 是一个变量，你确定 struct list 是合法的并且这段代码能通过编译？", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:调试，判断n是否为空？ 感谢回复，n 不为空，分配成功了，但是无法访问。", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "调试，判断n是否为空？", "referer": "user-0"}, {"cid": "11", "user": "user-4", "content": "C Run-Time Libraries https://msdn.microsoft.com/en-us/library/abx4dbyh.aspx", "referer": "user-0"}]}
{"question": "__stdcall与变参函数的栈清理", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 Intel0011 的回复:看了一下gcc的汇编代码，与VC是相似的，没什么不同，没明白你说的意思 关于那个__cdecl函数指针调用__stdcall却正常的问题，我搞懂了，和你说下我的心得吧  在gcc上测试 之前__cdecl指针能调用__stdcall函数应该只是个巧合，函数自身的栈空间足够大，调用__stdcall函数的次数少，所以没出岔子，调用次数一多就出问题了，因为esp一直是在加的  __stdcall指针调用__cdecl函数却是可行的，因为调用函数后不修改esp，esp就是在减的，相当于增加了main的栈空间。而且函数变量gcc通过ebp定位，而ebp在传参之后、调用函数之后入栈，最后可以准确还原，而传参通过esp定位，esp又是在减的，也就是传参的入栈位置都是在新的栈空间。  然后是cl的测试 __cdecl调用__stdcall一下就失败了，记得之前调用WinAPI是测试成功了的，忘了是什么情况了  不过它的__stdcall调用__cdecl也成功了，原因应该跟gcc的差不多，传参通过push，那么就是以esp定位，但不同的是，它变量是直接写的变量名，如move dword ptr[c] , 0 ，我估计本质应该也是用的ebp定位", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "1. 变参函数用__stdcall 是无法实现的, 所以编译器强制编译成了__cdecl 2. 函数参数进栈一般用push, 但是也可以直接 mov [esp+x], vvv 的方式, 作用是等效的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 3 楼 六道佩恩 的回复:话说调用约定会影响变参函数的参数的类型提升吗？  LoadLibrary+__cdecl函数指针调用Windows API，按理说会出问题的对吧，怪就怪在GCC和CL在命令行的编译结果运行正常，而VC的IDE上（CPP）就出问题了，得__stdcall函数指针。这波没出问题反而搞不懂，__cdecl和__stdcall都试了，汇编是不同的（调用后修改esp与否），但运行都正常？？？Windows API使用__stdcall的话，最后应该是修改了栈顶的吧？  还是这个__cdecl和__stdcall，在gcc上，__cdecl，调用函数后没有调整栈顶；__stdcall，调用后反而调整栈顶了，函数最后修改了栈顶，结果调用结束后gcc又改了回来，使栈顶还是指向调用各个函数时通用的传参空间。我是不是可以认为，表面上看是gcc对__cdecl没有修改栈顶而对__stdcall修改了，是由于它对栈的使用方式和VC不同，所以才造成了表象相反，在它的使用方式内，__cdecl没有改esp仍视为清理了栈，而__stdcall改了esp应视为没有清理栈，是吧？ 函数的参数的类型提升是在C语言标准中已经规定了的，与调用约定的类型无关，调用约定只是规定了参数的压栈顺序以及由谁来做栈平衡的动作 Windows API大部分是__stdcall，只有变参函数是__cdecl，因为Windows API是已经编译好的，其调用约定已定  看了一下gcc的汇编代码，与VC是相似的，没什么不同，没明白你说的意思  int __attribute__((__stdcall__)) fun1(int num) {     return num + num; }  fun1:         push    ebp         mov     ebp, esp         mov     eax, DWORD PTR [ebp+8]         add     eax, eax         pop     ebp         ret     4  //这里有清栈，由于是__stdcall，所以由自己清栈  int __attribute__((__cdecl__)) fun2(int i, int j) {     return i + j; }  fun2:         push    ebp         mov     ebp, esp         mov     edx, DWORD PTR [ebp+8]         mov     eax, DWORD PTR [ebp+12]         add     eax, edx         pop     ebp         ret   //这里没有清栈，由于是__cdecl，所以由调用方清栈  int main(void) {     fun1(1);     fun2(1, 2);     return 0; }  main:         push    ebp         mov     ebp, esp         push    1 //传参的栈空间         call    fun1 //fun1自己清栈         push    2 //传参的栈空间         push    1 //传参的栈空间         call    fun2         add     esp, 8 //调用方清栈         mov     eax, 0         leave         ret", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 4 楼 Intel0011 的回复:Windows API大部分是__stdcall，只有变参函数是__cdecl，因为Windows API是已经编译好的，其调用约定已定  我的意思是，那些函数已经确定，__stdcall导致末尾的ret会修改栈顶对吧？ 那么调用方也需要按__stdcall来调用对吧？ 但问题在于，我测试调用方按__cdecl来调用，结果也能正常运行？  为了确定gcc确实是按__cdecl编译的，对比__stdcall和__cdecl调用函数后的操作，一个没动作，一个有修改esp的操作，所以它确实按我指示的__cdecl调用了__stdcall函数，但却正常运行了（不是一个函数，是多个）", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 Intel0011 的回复:1、对于变参函数，其调用约定只能为__cdecl，因为只有调用者才知道传了多少个参数，被调用者是无法知道的（有标志意义的参数除外），所以这时也只能由调用者来做栈清理，恢复到调用前的状态 2、每次传参都是拿同一段空间反复使用，这本身就是栈的处理方式，是优于堆的地方，每一次函数调用后，都会恢复到调用前的状态，所以一般情况下栈不需要特别大的空间，函数式编程中的尾递归就是栈的极致利用方式 3、不论是那种调用约定，只要每一次函数调用后将栈恢复到调用前的状态，都可以认为是栈清理，也叫栈平衡   话说调用约定会影响变参函数的参数的类型提升吗？  LoadLibrary+__cdecl函数指针调用Windows API，按理说会出问题的对吧，怪就怪在GCC和CL在命令行的编译结果运行正常，而VC的IDE上（CPP）就出问题了，得__stdcall函数指针。这波没出问题反而搞不懂，__cdecl和__stdcall都试了，汇编是不同的（调用后修改esp与否），但运行都正常？？？Windows API使用__stdcall的话，最后应该是修改了栈顶的吧？  还是这个__cdecl和__stdcall，在gcc上，__cdecl，调用函数后没有调整栈顶；__stdcall，调用后反而调整栈顶了，函数最后修改了栈顶，结果调用结束后gcc又改了回来，使栈顶还是指向调用各个函数时通用的传参空间。我是不是可以认为，表面上看是gcc对__cdecl没有修改栈顶而对__stdcall修改了，是由于它对栈的使用方式和VC不同，所以才造成了表象相反，在它的使用方式内，__cdecl没有改esp仍视为清理了栈，而__stdcall改了esp应视为没有清理栈，是吧？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 楼主 六道佩恩 的回复:我主要有两个问题： 1. 关于变参函数，是不是不管声明何种调用约定，其都会实现为__cdecl？下面是VC的汇编，实际指定的是__stdcall。 2. gcc的对栈清理的方式怎么和VC不一样啊？或者说这算栈清理吗？ 观察了它几次调用，发现它每次传参都是拿同一段空间反复使用，就是图中入栈的那段，对不同函数的调用，传参都是用的这同一段，作为调用方把控了传参的栈空间，是不是也相当于做了栈清理？或者说这能算栈清理吗？ （编译用的32位，非x64约定） 1、对于变参函数，其调用约定只能为__cdecl，因为只有调用者才知道传了多少个参数，被调用者是无法知道的（有标志意义的参数除外），所以这时也只能由调用者来做栈清理，恢复到调用前的状态 2、每次传参都是拿同一段空间反复使用，这本身就是栈的处理方式，是优于堆的地方，每一次函数调用后，都会恢复到调用前的状态，所以一般情况下栈不需要特别大的空间，函数式编程中的尾递归就是栈的极致利用方式 3、不论是那种调用约定，只要每一次函数调用后将栈恢复到调用前的状态，都可以认为是栈清理，也叫栈平衡", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "1. stdcall 等调用约定的规则就限制了他们进行变参函数的使用   。    当然也有些特殊情况。 2.栈清理  是什么东西??    参数传递的入栈和出栈吗？   gcc 和 vc 传参时对栈的使用基本是相同的   ，只不过 gcc 提前分配了空间  而vc使用push ，但是每次使用完栈都是平衡的 。", "referer": "user-0"}]}
{"question": "const char *和char *的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "const的作用用于限制该字符串在该函数内（比如strcmp）是不能被修改的，是只读的。  加了比不加更好，虽然不影响结果；比如自定义mystrcmp(char *s1, char *s2);这样自定义形参也是没问题的，从功能上考虑是比较，自然不需要修改s1, s2两个字符串；因此加上const更严谨；", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2 的回复：对，没错。 尤其是在一个人写代码的时候。  而在团队合作的环境下，函数原型里的一个const相比洋洋洒洒地用文字约定神马东西不能改就简洁多了，也明确多了。谢谢🙏", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "对，没错。 尤其是在一个人写代码的时候。  而在团队合作的环境下，函数原型里的一个const相比洋洋洒洒地用文字约定神马东西不能改就简洁多了，也明确多了。", "referer": "user-0"}]}
{"question": "新手求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "main开始吧，既然是字符串，那么应该定义成char str[80];，形参也应该是char p[]; ， p[i]-'0'", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "赵4老湿正在赶来的路上，但他不愿意回答这种简单问题，所以我代替他回答一下： # include <string.h>   int BinToDec (char p []) {     if (strlen (p) == 0) return 0;       return * p - '0' << strlen (p) - 1 | BinToDec (p + 1); } 我们采用了递归的方法，按照每个 0、1 的阶，将它移动到二进制数的指定位置，移完之后就是最终结果。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "可参https://bbs.csdn.net/topics/399167039", "referer": "user-0"}]}
{"question": "C程里面这个看不懂了，求助！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "clock() &(,<<8)比  (clock() >> 8) & 1更快吧.", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "clock()的返回值右移8位，然后最低位是不是1。这个返回值的第二个8位可能比较特殊；应该是多长时间会为1吧", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "The clock() function returns an approximation of processor time used by the program. The value returned is the CPU time used so far as a clock_t; to get the number of seconds used, divide by CLOCKS_PER_SEC.  If the processor time used is not available or its value cannot be represented, the function returns the value (clock_t) -1.  还有很多注意事项，建议搜索一下 clock 函数，你贴的这段函数应该是在循环代码块里边儿吧？轮循 clock 获取时间，满足条件就显示 _", "referer": "user-0"}]}
{"question": "c语言链表出现段错误怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  struct ListNode {     int address;     int data;     int next;     struct ListNode *Next; };  int main() {     int k;     struct ListNode *head;      head=(struct ListNode *)malloc(sizeof(struct ListNode));     head->Next=NULL;      struct ListNode *p,*q;     p = head;     int first;     int number;     int i;     int m;     scanf(\"%d%d%d\",&first,&number,&m);     int l=m;     for(i=0; i<number; i++)     {         q=(struct ListNode *)malloc(sizeof(struct ListNode));         scanf(\"%d %d %d\",&q->address,&q->data,&q->next);          /*         if(head==NULL)      //head不会为NULL了，这个判断是冗余的         {             head=p=q;         }         else         {*/             p->Next=q;             p=q;         //}     }     p->Next=NULL;     p = head->Next;      //输入链表里了     //m=4     struct ListNode *head1,*temp;     head1=(struct ListNode *)malloc(sizeof(struct ListNode));     head1->Next=NULL;     temp=head1;     //while(m)     while(m && p)       //这里可能出现段错误     {         if(p->data==m)         {             q=(struct ListNode *)malloc(sizeof(struct ListNode));             q->address=p->address;             q->data=p->data;             q->next=p->next;             /*             if(head1==NULL)     //同样冗余             {                 head1=temp=q;             }             else             {*/                 temp->Next=q;                 temp=q;             //}             m--;             p=head->Next;         }         else         {             p=p->Next;         }     }   //现在head1内 4 3 2 1     if(number==l)     {         temp->Next=NULL;         p=head1->Next;         int a=0;         while(p)         {             if(a==0)             {                 printf(\"%05d %d \",p->address,p->data);             }             else             {                 if(p->next!=-1)                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 else                 {                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 }              }             p=p->Next;         }         printf(\"-1\");     }     else     {         p=head->Next;         int a;         a=l+1;         while(a<=number)         {             if(p->data==a)             {                 q=(struct ListNode *)malloc(sizeof(struct ListNode));                 q->address=p->address;                 q->data=p->data;                 q->next=p->next;                 if(head1==NULL)                 {                     head1=temp=q;                 }                 else                 {                     temp->Next=q;                     temp=q;                 }                 a++;                 p=head->Next;             }             else             {                 p=p->Next;             }         }         //printf(\"1\\n\");         temp->Next=NULL;         //printf(\"3\\n\");         p=head1->Next;         a=0;         while(p)         {             if(a==0)             {                 printf(\"%05d %d \",p->address,p->data);                 a++;             }             else             {                 if(p->next!=-1)                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 else                 {                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 }             }             p=p->Next;         }         printf(\"-1\");      }     return 0; } 供参考～  功能都写在main中很难理解逻辑；建议功能分别用自定义函数实现，main函数调用的方式谢谢~ 加上之后可能有的测试用例通过了 某些还是会有段错误 我再好好看看", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 自信男孩 的回复:发一下需求里提到的测试用例，以及用例的输出样例；", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "发一下需求里提到的测试用例，以及用例的输出样例；", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  struct ListNode {     int address;     int data;     int next;     struct ListNode *Next; };  int main() {     int k;     struct ListNode *head;      head=(struct ListNode *)malloc(sizeof(struct ListNode));     head->Next=NULL;      struct ListNode *p,*q;     p = head;     int first;     int number;     int i;     int m;     scanf(\"%d%d%d\",&first,&number,&m);     int l=m;     for(i=0; i<number; i++)     {         q=(struct ListNode *)malloc(sizeof(struct ListNode));         scanf(\"%d %d %d\",&q->address,&q->data,&q->next);          /*         if(head==NULL)      //head不会为NULL了，这个判断是冗余的         {             head=p=q;         }         else         {*/             p->Next=q;             p=q;         //}     }     p->Next=NULL;     p = head->Next;      //输入链表里了     //m=4     struct ListNode *head1,*temp;     head1=(struct ListNode *)malloc(sizeof(struct ListNode));     head1->Next=NULL;     temp=head1;     //while(m)     while(m && p)       //这里可能出现段错误     {         if(p->data==m)         {             q=(struct ListNode *)malloc(sizeof(struct ListNode));             q->address=p->address;             q->data=p->data;             q->next=p->next;             /*             if(head1==NULL)     //同样冗余             {                 head1=temp=q;             }             else             {*/                 temp->Next=q;                 temp=q;             //}             m--;             p=head->Next;         }         else         {             p=p->Next;         }     }   //现在head1内 4 3 2 1     if(number==l)     {         temp->Next=NULL;         p=head1->Next;         int a=0;         while(p)         {             if(a==0)             {                 printf(\"%05d %d \",p->address,p->data);             }             else             {                 if(p->next!=-1)                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 else                 {                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 }              }             p=p->Next;         }         printf(\"-1\");     }     else     {         p=head->Next;         int a;         a=l+1;         while(a<=number)         {             if(p->data==a)             {                 q=(struct ListNode *)malloc(sizeof(struct ListNode));                 q->address=p->address;                 q->data=p->data;                 q->next=p->next;                 if(head1==NULL)                 {                     head1=temp=q;                 }                 else                 {                     temp->Next=q;                     temp=q;                 }                 a++;                 p=head->Next;             }             else             {                 p=p->Next;             }         }         //printf(\"1\\n\");         temp->Next=NULL;         //printf(\"3\\n\");         p=head1->Next;         a=0;         while(p)         {             if(a==0)             {                 printf(\"%05d %d \",p->address,p->data);                 a++;             }             else             {                 if(p->next!=-1)                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 else                 {                     printf(\"%05d\\n%05d %d \",p->address,p->address,p->data);                 }             }             p=p->Next;         }         printf(\"-1\");      }     return 0; } 供参考～  功能都写在main中很难理解逻辑；建议功能分别用自定义函数实现，main函数调用的方式", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "输入测试用例调试运行下去都没有错误", "referer": "user-0"}]}
{"question": "C语言两个数的最小公倍数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "// 最大公约数 int greatest_common_divisor(int a, int b) {     if(b == 0) return a;     else return greatest_common_divisor(b, a % b); } // 最小公倍数 int least_common_multiple(int a, int b) {     return a * b / greatest_common_divisor(a, b); }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include <stdio.h>  int main() { \tint a,b; \tint yu; \tint m,n; \tprintf(\"input two numbers:\\n\"); \tscanf(\"%d%d\", &m, &n);     m>n?(a=m,b=n):(a=n,b=m); //大值放a，小值放b \twhile (a%b != 0)//辗转相除法 ,得到最大公约数b \t{ \t      yu = a%b; \t      a = b;           b = yu;     } \tprintf(\"最小公倍数为:%d\\n\",m*n/b);//最小公倍数=两数的乘积 ÷ 最大公约数          \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 真相重于对错的回复:我去，先把基本语法搞清楚。 初学者，希望大佬可以指出", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "我去，先把基本语法搞清楚。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "，望采纳，不懂的可以关注私信我。", "referer": "user-0"}]}
{"question": "C入门代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用#include<stdio.h> int main(){     int n[10];     int i;     int max = n[0];     printf(\"请输入10个数：\");     for(int i = 0;i <= 10;++i)         scanf(\"%d\",&n[i]);     for(int i = 0;i <= 10;++i)         max = n[i] > max ? n[i] : max;         printf(\"max = %d\\n\",max);     return 0; } for（）里对数组下标操作越界，应改为：for(int i=0; i<10 ;i++)", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) 这句改一下： if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) 逻辑更清晰一些～  #include<stdio.h> int main(){     int n[10];     //int i;     //int max = n[0]; //随机值，可能max也放不下的随机值     int max;      printf(\"请输入10个数：\");     for(int i = 0;i <= 10;++i)         scanf(\"%d\",&n[i]);     max = n[0]; //在这初始化     for(int i = 0;i <= 10;++i)         max = n[i] > max ? n[i] : max;     printf(\"max = %d\\n\",max);     return 0; } 供参考  max初始化有问题，可能导致程序结果异常；", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "好的，谢谢", "referer": "user-0"}]}
{"question": "求解！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你莫不是用了全角的小于号＜？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没看出什么问题来。第一个else建议和后面的if写在一行。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "好像没啥问题，报错< 是非法的。望采纳，不懂的可以关注私信我。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "‘<'  是非法字符", "referer": "user-0"}]}
{"question": "【新手求助】二进制转十进制", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,\"%032s\",b);     printf(\"i=%d,bs=%s\\n\",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,\"%08s\",h);     printf(\"i=%d,hs=%s\\n\",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,\"00000400\");     sscanf(hs,\"%x\",&i);     printf(\"hs=%s,i=%d\\n\",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,\"00000000000000000000010000000000\");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,\"%08s\",h);     printf(\"bs=%s,hs=%s\\n\",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,\"00000000000000000000010000000000\");     i=strtol(bs,&e,2);     printf(\"bs=%s,i=%d\\n\",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,\"00000400\");     sscanf(hs,\"%x\",&i);     ltoa(i,b,2);     sprintf(bs,\"%032s\",b);     printf(\"hs=%s,bs=%s\\n\",hs,bs); // ASC\\GBK字符串转十六进制串     strcpy(s,\"a汉\");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,\"%02X\",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,\"chs\");     printf(\"s=%s,hs=%s\\n\",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,\"61BABA\");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,\"%2x\",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf(\"hs=%s,s=%s\\n\",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h>  int main() {     int remainder, number = 0, decimal_number = 0, temp = 1;     printf(\"\\n Enter any binary number= \");     scanf(\"%d\", &number);      // Iterate over the number until the end.     while (number > 0)     {         remainder = number % 10;         number = number / 10;         decimal_number += remainder * temp;         temp = temp * 2;  // used as power of 2     }      printf(\"%d\\n\", decimal_number); }    望采纳，不懂的可以关注私信我。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "可参https://bbs.csdn.net/topics/399167039", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "供参考：#include<stdio.h>  int BinToDec(char p[]) {     int sum=0,i=0;     while(p[i]!='\\0')     {         sum = sum*2 + p[i]-'0';         i++;     }     return sum;  }  int main() {     int  s;     char str[80];     printf(\"Enter only 0,1 string:\");     scanf(\"%s\",str);     s=BinToDec(str);     printf(\"Bin=%s<=>Dec=%d\\n\",str,s);          return 0; }", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "return new int[]{i,j}; 返回的是 函数指针，return new int[2]; 返回的是函数，望采纳，不懂的可以关注私信我。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "实事求是地说，在这个版块内，这个问题还得赵老湿来。你@赵老湿。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "public int[]  这是C++的语法吧，C语言没有public关键字；  int []这样作为返回值类型不常见，常见的是int *返回指针。从函数实现的返回值来看就是这样的，返回的是指针（地址值）  #include <stdio.h> int main() {     int num[10]={2,9,17,21,35,99,333,128,101,121,};      int i,j;     for(i=0;i<=9;i++)     {         for(j=0;j<=9;j++)         {             if(i != j && num[i]+num[j]==120)             {                 printf(\"%d %d \",i,j);                 //i=100;  //这里赋值会导致数组越界，因为第二层循环可能还没结束，if (num[i]这里就会出现数组越界了；                 break;             }         }         if (j <= 9)     //继续跳出循环             break;     } } 供参考～  代码有点问题修复一下，如上；", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "另贴出我自己写的： #include <stdio.h> int main() { \tint num[10]={2,9,17,21,35,99,333,128,101,121,}; \tint i,j; \tfor(i=0;i<=9;i++) \t{ \t\tfor(j=0;j<=9;j++) \t\t{ \t\t\tif(num[i]+num[j]==120) \t\t\t{ \t\t\t\tprintf(\"%d %d \",i,j); \t\t\t\ti=100; \t\t\t} \t\t} \t}  }", "referer": "user-0"}]}
{"question": "大佬，救命", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C语言教程（附带C语言100例）http://download.csdn.net/detail/zhao4zhong1/8830817", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "大学应该有课本吧，建议先把课程里的学习了再考虑扩展性的学习。", "referer": "user-0"}]}
{"question": "各路大神，帮帮孩子吧( •︠ˍ•︡ )", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C语言教程（附带C语言100例）http://download.csdn.net/detail/zhao4zhong1/8830817", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "<<linux C prime plus>>可以找找，或者买一本～", "referer": "user-0"}]}
{"question": "求助，急需帮助，纯C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:[quote=引用 2 楼 weixin_52677262 的回复:][quote=引用 1 楼 自信男孩的回复:]为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。 我当然写了几个功能[/quote] 那你只把需求发出来，你的代码一条也不贴。你是想让大家帮你写全，调试完，测试完，没问题的？还是其他要求？  需求不明确。  [/quote] 明白了，下次发问题时会写清楚需求", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 weixin_52677262 的回复:[quote=引用 1 楼 自信男孩的回复:]为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。 我当然写了几个功能[/quote] 那你只把需求发出来，你的代码一条也不贴。你是想让大家帮你写全，调试完，测试完，没问题的？还是其他要求？  需求不明确。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。 我当然写了几个功能", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。", "referer": "user-0"}]}
{"question": "文件读取问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "行吧，我在理解理解，谢谢你", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你还是没理解，有没有EOF字符不重要，指不指向EOF字符不重要，feof都不会因此而为真。 feof为真的理由只有一个，那就是刚才有别的函数曾经撞上文件尾，撞是个动词，生动表达了某函数企图跨越文件尾读取数据然而失败了的过程。  四老师给出的解决方案是 while(1) { fgets(...); if(feof(p))break; others... ... } ...", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢耐心解答，我想问一下能将文件内容想成asd\\nEOF吗，刚开始文件指针指向a，每读入一个字符往后移一位，如果这样的话，那第一次循环结束p不就是指向EOF吗，第二次循环判断feof返回1跳出循环", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "函数又没长眼睛，它没法在撞到文件末尾之前就知道前方是文件末尾。 你的循环执行第一次，没到结尾，读入第一行，去掉末字符（当时是换行）剩下正常字符在str里面。 循环第二次，没撞上过文件尾，因此条件为真，进入循环体。fgets读取新行失败，有两个后果，第一是撞过了文件尾，下次feof会返回真；第二是str没有更新，还是原来的内容。接下去去掉末字符，按你的说法的话这时去掉的是'd'。文件指针说的是读取位置吧，它没有返回开头，还在末尾呢。 循环条件第三次，这次因为feof为真，所以循环条件为假，跳过循环。 综上。 这样写的代码总会在最后是空行的时候出问题，建议参考四老师在其他帖子的回复进行修改。", "referer": "user-0"}]}
{"question": "请问，以上程序为何不能输出汉字", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "汉字应该用字符串保存，你怎么用int", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "现在程序可以这么写了啊？ 请问：1. getch(); 的返回值范围？ 2. printf(“%c%c”,a,b); 的输出内容？ 3. 你能不能解释一下a=(dat&0xff00)>>8;和b=dat&0x00ff; 的可能输出结果？ 4. 如果输出汉字，编码应该是16位字长，但是那么多编码方案你准备为哪种编程？ 5. 如果你不准备想清楚编码和算法有关的事，至少你应该研究一下把两个%c数据合成一个16位字长的数据吧？不然你怎么输出中文？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "赵4老湿不老实！没有正面回答我滴问题！差评！中午不准吃饭！  实际上， wprintf 是将宽字符转换为多字节字符输出。正因为有一个转换过程，等价于 wcstomb，所以需要根据当前区域设置来决定如何将宽字符转换为多字节字符。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "setlocale, _wsetlocale Define the locale.  char *setlocale( int category, const char *locale );  wchar_t *_wsetlocale( int category, const wchar_t *locale );  Routine Required Header Compatibility  setlocale <locale.h> ANSI, Win 95, Win NT  _wsetlocale <locale.h> or <wchar.h> Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  If a valid locale and category are given, the function returns a pointer to the string associated with the specified locale and category. If the locale or category is invalid, the function returns a null pointer and the current locale settings of the program are not changed.  For example, the call  setlocale( LC_ALL, \"English\" );  sets all categories, returning only the string English_USA.1252. If all categories are not explicitly set by a call to setlocale, the function returns a string indicating the current setting of each of the categories, separated by semicolons. If the locale argument is a null pointer, setlocale returns a pointer to the string associated with the category of the program’s locale; the program’s current locale setting is not changed.  The null pointer is a special directive that tells setlocale to query rather than set the international environment. For example, the sequence of calls  // Set all categories and return \"English_USA.1252\" setlocale( LC_ALL, \"English\" ); // Set only the LC_MONETARY category and return \"French_France.1252\" setlocale( LC_MONETARY, \"French\" ); setlocale( LC_ALL, NULL );  returns   LC_COLLATE=English_USA.1252; LC_CTYPE=English_USA.1252; LC_MONETARY=French_France.1252; LC_NUMERIC=English_USA.1252; LC_TIME=English_USA.1252  which is the string associated with the LC_ALL category.  You can use the string pointer returned by setlocale in subsequent calls to restore that part of the program’s locale information, assuming that your program does not alter the pointer or the string. Later calls to setlocale overwrite the string; you can use _strdup to save a specific locale string.  Parameters  category  Category affected by locale  locale  Locale name  Remarks  Use the setlocale function to set, change, or query some or all of the current program locale information specified by locale and category. “Locale” refers to the locality (country and language) for which you can customize certain aspects of your program. Some locale-dependent categories include the formatting of dates and the display format for monetary values.   _wsetlocale is a wide-character version of setlocale; the locale argument and return value of _wsetlocale are wide-character strings. _wsetlocale and setlocale behave identically otherwise.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tsetlocale setlocale setlocale _wsetlocale    The category argument specifies the parts of a program’s locale information that are affected. The macros used for category and the parts of the program they affect are as follows:  LC_ALL  All categories, as listed below  LC_COLLATE  The strcoll, _stricoll, wcscoll, _wcsicoll, and strxfrm functions  LC_CTYPE  The character-handling functions (except isdigit, isxdigit, mbstowcs, and mbtowc, which are unaffected)  LC_MONETARY  Monetary-formatting information returned by the localeconv function  LC_NUMERIC  Decimal-point character for the formatted output routines (such as printf), for the data-conversion routines, and for the nonmonetary-formatting information returned by localeconv   LC_TIME  The strftime and wcsftime functions  The locale argument is a pointer to a string that specifies the name of the locale. If locale points to an empty string, the locale is the implementation-defined native environment. A value of “C” specifies the minimal ANSI conforming environment for C translation. The “C” locale assumes that all char data types are 1 byte and that their value is always less than 256. The “C” locale is the only locale supported in Microsoft Visual C++ version 1.0 and earlier versions of Microsoft C/C++. Microsoft Visual C++ supports all the locales listed in Appendix A, Language and Country Strings. At program startup, the equivalent of the following statement is executed:  setlocale( LC_ALL, \"C\" );  The locale argument takes the following form:  locale :: \"lang[_country[.code_page]]\"              | \".code_page\"             | \"\"             | NULL  The set of available languages, countries, and code pages includes all those supported by the Win32 NLS API. The set of language and country codes supported by setlocale is listed in Appendix A, Language and Country Strings.  If locale is a null pointer, setlocale queries, rather than sets, the international environment, and returns a pointer to the string associated with the specified category. The program’s current locale setting is not changed. For example,  setlocale( LC_ALL, NULL );  returns the string associated with category.   The following examples pertain to the LC_ALL category. Either of the strings \".OCP\" and \".ACP\" can be used in place of a code page number to specify use of the system default OEM code page and system-default ANSI code page, respectively.  setlocale( LC_ALL, \"\" );  Sets the locale to the default, which is the system-default ANSI code page obtained from the operating system.  setlocale( LC_ALL, \".OCP\" );  Explicitly sets the locale to the current OEM code page obtained from the operating system.  setlocale( LC_ALL, \".ACP\" );  Sets the locale to the ANSI code page obtained from the operating system.  setlocale( LC_ALL, \"[lang_ctry]\" );  Sets the locale to the language and country indicated, using the default code page obtained from the host operating system.  setlocale( LC_ALL, \"[lang_ctry.cp]\" );  Sets the locale to the language, country, and code page indicated in the [lang_ctry.cp] string. You can use various combinations of language, country, and code page. For example:  setlocale( LC_ALL, \"French_Canada.1252\" ); // Set code page to French Canada ANSI default setlocale( LC_ALL, \"French_Canada.ACP\" ); // Set code page to French Canada OEM default setlocale( LC_ALL, \"French_Canada.OCP\" ); setlocale( LC_ALL, \"[lang]\" );  Sets the locale to the country indicated, using the default country for the language specified, and the system-default ANSI code page for that country as obtained from the host operating system. For example, the following two calls to setlocale are functionally equivalent:  setlocale( LC_ALL, \"English\" ); setlocale( LC_ALL, \"English_United States.1252\" ); setlocale( LC_ALL, \"[.code_page]\" );  Sets the code page to the value indicated, using the default country and language (as defined by the host operating system) for the specified code page.   The category must be either LC_ALL or LC_CTYPE to effect a change of code page. For example, if the default country and language of the host operating system are “United States” and “English,” the following two calls to setlocale are functionally equivalent:  setlocale( LC_ALL, \".1252\" ); setlocale( LC_ALL, \"English_United States.1252\");  For more information see the setlocale pragma in Preprocessor Reference.  Example  /* LOCALE.C: Sets the current locale to \"Germany\" using the  * setlocale function and demonstrates its effect on the strftime  * function.  */  #include <stdio.h> #include <locale.h> #include <time.h>  void main(void) {        time_t ltime;        struct tm *thetime;        unsigned char str[100];         setlocale(LC_ALL, \"German\");        time (<ime);        thetime = gmtime(<ime);         /* %#x is the long date representation, appropriate to         * the current locale         */        if (!strftime((char *)str, 100, \"%#x\",                       (const struct tm *)thetime))                printf(\"strftime failed!\\n\");        else                printf(\"In German locale, strftime returns '%s'\\n\",                        str);         /* Set the locale back to the default environment */        setlocale(LC_ALL, \"C\");        time (<ime);        thetime = gmtime(<ime);         if (!strftime((char *)str, 100, \"%#x\",                       (const struct tm *)thetime))                printf(\"strftime failed!\\n\");        else                printf(\"In 'C' locale, strftime returns '%s'\\n\",                        str); }   Output  In German locale, strftime returns 'Donnerstag, 22. April 1993' In 'C' locale, strftime returns 'Thursday, April 22, 1993'   Locale Routines  See Also   localeconv, mblen, _mbstrlen, mbstowcs, mbtowc, strcoll Functions, strftime, strxfrm, wcstombs, wctomb", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 11 楼 均陵鼠侠 的回复:[quote=引用 7 楼 m0_51507696 的回复:][quote=引用 3 楼 赵4老师 的回复:]getwchar可以返回汉字 老师，您看一下，我将程序改成了这样，结果输出如图那样您觉得有可能是什么原因  #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <wchar.h>  int main(void){ \tint dat=0; \twhile(1){ \t\tprintf(\"输入：\");  \t\tdat=getwchar(); \t\tprintf(\"%d——\",dat); \t\tprintf(\"%c%c\",((dat&0xff00)>>8),(dat&0x00ff)); \t} \tsystem(\"pause\"); \treturn 1; }  [/quote]  大胆！你这是为难赵4老湿。  我来替赵4老湿回答你的问题。你只需要用下面的方法即可解决：  # include <locale.h> # include <wchar.h> # include <stdio.h>  int main (void) {     setlocale (LC_ALL, \"chs\");     wprintf (L\"->%lc\", getwchar ()); }  注：在Linux环境下，程序中的“chs”要改成“zh_CN.UTF-8”（如果默认是UTF-8编码）。  帮了赵4老湿这么大的忙，请赵老湿回答一下，为什么这个程序要用 setlocale 设置区域呢？如果不设置有什么问题？[/quote] https://www.baidu.com/s?wd=setlocale%20LC_ALL%20chs%20zh_CN.UTF-8", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "来，按你的意思改一波  #include<stdio.h> #include<conio.h> int main( void ) {     int a=0, b=0;     while(1)     {     \ta=getch();     \tprintf(\"%c\", a );     }     return 0;  }    注意，getch不回显，这个“哈哈哈”是printf输出来的", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "#include<stdio.h> #include<conio.h> int main( void ) {     int a=0, b=0;     a=getch();     b=getch();     printf(\"得到%c%c %x %x\", a, b, a, b );     return 0;  }    这不是可行吗，B9 FE，这就是汉字'哈'的GBK编码呀", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 7 楼 m0_51507696 的回复:[quote=引用 3 楼 赵4老师 的回复:]getwchar可以返回汉字 老师，您看一下，我将程序改成了这样，结果输出如图那样您觉得有可能是什么原因  #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <wchar.h>  int main(void){ \tint dat=0; \twhile(1){ \t\tprintf(\"输入：\");  \t\tdat=getwchar(); \t\tprintf(\"%d——\",dat); \t\tprintf(\"%c%c\",((dat&0xff00)>>8),(dat&0x00ff)); \t} \tsystem(\"pause\"); \treturn 1; }  [/quote]  大胆！你这是为难赵4老湿。  我来替赵4老湿回答你的问题。你只需要用下面的方法即可解决：  # include <locale.h> # include <wchar.h> # include <stdio.h>  int main (void) {     setlocale (LC_ALL, \"chs\");     wprintf (L\"->%lc\", getwchar ()); }  注：在Linux环境下，程序中的“chs”要改成“zh_CN.UTF-8”（如果默认是UTF-8编码）。  帮了赵4老湿这么大的忙，请赵老湿回答一下，为什么这个程序要用 setlocale 设置区域呢？如果不设置有什么问题？", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "引用 9 楼 m0_51507696 的回复:[quote=引用 6 楼 均陵鼠侠 的回复:]汉字处理是个复杂的话题，但是就你这个程序而言，又不是太难。 # include <stdio.h>  int main (void) {     char b [2048] = {0};     int c, x = 0;      while ((c = getchar ()) != EOF) b [x ++] = c;      printf (b); } 函数 getchar 每次只读取 1 个字节，然后扩展到 int 类型。所以，我们的任务是将这些字节依次读取并存储起来。这个程序的好处是不必考虑操作系统实际使用的执行字符集，因为发送给程序的字符编码与系统输出（即 printf 内部调用的操作系统接口部分）使用的字符编码方案总是一致的。  请问，这个printf (b);是怎么回事,没有格式控制字符串编译器会自动判断输出类型吗[/quote]  因为 printf 本来就是一个变参函数，第一个参数是指向字符串的指针，如果里面有格式控制字符，后面才会有别的参数：  int printf (const char * restrict, ...);", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 6 楼 均陵鼠侠 的回复:汉字处理是个复杂的话题，但是就你这个程序而言，又不是太难。 # include <stdio.h>  int main (void) {     char b [2048] = {0};     int c, x = 0;      while ((c = getchar ()) != EOF) b [x ++] = c;      printf (b); } 函数 getchar 每次只读取 1 个字节，然后扩展到 int 类型。所以，我们的任务是将这些字节依次读取并存储起来。这个程序的好处是不必考虑操作系统实际使用的执行字符集，因为发送给程序的字符编码与系统输出（即 printf 内部调用的操作系统接口部分）使用的字符编码方案总是一致的。  请问，这个printf (b);是怎么回事,没有格式控制字符串编译器会自动判断输出类型吗", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 6 楼 均陵鼠侠 的回复:汉字处理是个复杂的话题，但是就你这个程序而言，又不是太难。 # include <stdio.h>  int main (void) {     char b [2048] = {0};     int c, x = 0;      while ((c = getchar ()) != EOF) b [x ++] = c;      printf (b); } 函数 getchar 每次只读取 1 个字节，然后扩展到 int 类型。所以，我们的任务是将这些字节依次读取并存储起来。这个程序的好处是不必考虑操作系统实际使用的执行字符集，因为发送给程序的字符编码与系统输出（即 printf 内部调用的操作系统接口部分）使用的字符编码方案总是一致的。 引用 6 楼 均陵鼠侠 的回复:汉字处理是个复杂的话题，但是就你这个程序而言，又不是太难。 # include <stdio.h>  int main (void) {     char b [2048] = {0};     int c, x = 0;      while ((c = getchar ()) != EOF) b [x ++] = c;      printf (b); } 函数 getchar 每次只读取 1 个字节，然后扩展到 int 类型。所以，我们的任务是将这些字节依次读取并存储起来。这个程序的好处是不必考虑操作系统实际使用的执行字符集，因为发送给程序的字符编码与系统输出（即 printf 内部调用的操作系统接口部分）使用的字符编码方案总是一致的。   谢谢您，您的回答解决了我的问题", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 3 楼 赵4老师 的回复:getwchar可以返回汉字 老师，您看一下，我将程序改成了这样，结果输出如图那样您觉得有可能是什么原因  #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <wchar.h>  int main(void){ \tint dat=0; \twhile(1){ \t\tprintf(\"输入：\");  \t\tdat=getwchar(); \t\tprintf(\"%d——\",dat); \t\tprintf(\"%c%c\",((dat&0xff00)>>8),(dat&0x00ff)); \t} \tsystem(\"pause\"); \treturn 1; }", "referer": "user-0"}, {"cid": "13", "user": "user-6", "content": "希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "14", "user": "user-4", "content": "getwchar可以返回汉字", "referer": "user-0"}, {"cid": "15", "user": "user-7", "content": "汉字不是占1个字节的字符（可以了解一下一个汉子占几个字节），之所以getch返回int就像getchar()返回int是一样的道理：类型提升；  因此如果要输出汉子，建议用字符串；", "referer": "user-0"}, {"cid": "16", "user": "user-4", "content": "因为getch()返回不了汉字对应的GBK或UTF8或Unicode编码。", "referer": "user-0"}, {"cid": "17", "user": "user-3", "content": "汉字处理是个复杂的话题，但是就你这个程序而言，又不是太难。 # include <stdio.h>  int main (void) {     char b [2048] = {0};     int c, x = 0;      while ((c = getchar ()) != EOF) b [x ++] = c;      printf (b); } 函数 getchar 每次只读取 1 个字节，然后扩展到 int 类型。所以，我们的任务是将这些字节依次读取并存储起来。这个程序的好处是不必考虑操作系统实际使用的执行字符集，因为发送给程序的字符编码与系统输出（即 printf 内部调用的操作系统接口部分）使用的字符编码方案总是一致的。", "referer": "user-0"}]}
{"question": "c语言自定义输入一个数组，循环打出后数组改变了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 qq_34918605 的回复:[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h>  int main() {     //int j = 1;     int j = 0;     int  arr[100] = { 0 };      printf(\"请输入你需要输入的数据 回车结束\");     for (int i = 0; i < 100&&getchar()!='\\n'; i++)     {         scanf(\"%d\", &arr[i]);         j++;     }      for (int i = 0; i < j; i++)     {         printf(\"%d\\n\", arr[i]);     }      return 0; } 有什么办法解决前面应为getchar吞的元素从而直接输入数字，而且循环输出后莫名多了一个0 元素， 多以个0，已经给你解释了，因为j=1从1开始就出现，从0开始就没问题了。  解决getchar吞的问题，可以考虑用我下面的例子。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "[quote=引用 2 楼 自信男孩 的回复:]#include <stdio.h>  int main() {     //int j = 1;     int j = 0, ret;     int  arr[100] = { 0 };      printf(\"请输入你需要输入的数据 回车结束\");     for (int i = 0; i < 100; i++)     {         if ((ret = scanf(\"%d\", &arr[i])) != 1)                 break;         j++;     }      for (int i = 0; i < j; i++)     {         printf(\"%d\\n\", arr[i]);     }      return 0; } 还是出现问题 直接打出了后面的空空间", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h>  int main() {     //int j = 1;     int j = 0;     int  arr[100] = { 0 };      printf(\"请输入你需要输入的数据 回车结束\");     for (int i = 0; i < 100&&getchar()!='\\n'; i++)     {         scanf(\"%d\", &arr[i]);         j++;     }      for (int i = 0; i < j; i++)     {         printf(\"%d\\n\", arr[i]);     }      return 0; } 有什么办法解决前面应为getchar吞的元素从而直接输入数字，而且循环输出后莫名多了一个0 元素，", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "#include <stdio.h>  int main() {     //int j = 1;     int j = 0, ret;     int  arr[100] = { 0 };      printf(\"请输入你需要输入的数据 回车结束\");     for (int i = 0; i < 100; i++)     {         if ((ret = scanf(\"%d\", &arr[i])) != 1)                 break;         j++;     }      for (int i = 0; i < j; i++)     {         printf(\"%d\\n\", arr[i]);     }      return 0; } 供参考～  退出输入使用ctrl+d(LINUX）或ctrl+z（Windows）", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "#include <stdio.h>  int main() {     //int j = 1;     int j = 0;     int  arr[100] = { 0 };      printf(\"请输入你需要输入的数据 回车结束\");     for (int i = 0; i < 100&&getchar()!='\\n'; i++)     {         scanf(\"%d\", &arr[i]);         j++;     }      for (int i = 0; i < j; i++)     {         printf(\"%d\\n\", arr[i]);     }      return 0; } 供参考～  输入时需要注意下，在输入第一个数字之前先输入一个空格，用于匹配getchar();根据循环的执行顺序，首先执行int i=0;然后不是执行循环体，而是判断i < 100 && getchar() !='\\n'，如果满足才会执行循环体。所以，如果输入的第一个字符是数字，那么这个数字的第一个数字就会被getchar()接收；  因此需要注意下，另外j应该从0开始。否则后面printf会多打印一个，甚至会导致越界，比如输入了100个，j=101；i<j，那么i=100是满足的，但是数组已经越界了。", "referer": "user-0"}]}
{"question": "实现pow()函数的源代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "注意 pow 可以传入小数  比如 pow(100.0, 0.5); 表示 √100", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1.你定义的变量全是整型无法接受到你想要的小数。 2.如果想用小数来表示开根号的运算那么你现在的算法公式也是错误的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 lin5161678的回复:注意 pow 可以传入小数  比如 pow(100.0, 0.5); 表示 √100 你好，我的代码运行传入小数，但运行的结果不正确，请问可以解惑吗？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "幂参数y可作已初始化的临时局部变量, 减少额外变量, 代码更紧凑: int pow(int x, int y) { \tint z; \tfor (z = 1; y > 0; --y) \t\tz *= x; \treturn z; }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:注意x, y接收的实参值可能会导致z溢出。需要考虑溢出的情况～比如10^15，int类型数据无法装的下～ 嗯嗯好的，谢谢哈", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "注意x, y接收的实参值可能会导致z溢出。需要考虑溢出的情况～比如10^15，int类型数据无法装的下～", "referer": "user-0"}]}
{"question": "这个地方哪里错误了，求大佬指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if这行少一个右括号，需要注意一下", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 13 楼 赵4老师 的回复://是注释 ||才是或 楼主脖子歪了还是眼睛斜了或者楼主所处位置地心引力方向不是严格向下？  正解！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "if((year -> if(year)", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "想复杂了，后来又忘记了。不少人编程时都是这样子的。 一个Bug坑一天，找到后发现什么也没干，就崩溃了。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "if 左边多一个（", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "学代码要看注释啊，下面都说了（)的问题。", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "第7行没错， 第6行错了，   if 语句的条件，多了一个左括号 ‘(‘ ， 删除一个 左括号即可。", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "啊这个。。。。", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "左括号和右括号数量不一样。。。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 11 楼 qq_45773596的回复:[quote=引用 2 楼 赵4老师的回复:]前一句if后多一个（ 不是的if()     中间//是或，所以两个语句在()内。不是这个问题，我看了[/quote] 难道我的思路有问题吗，我再试试", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:前一句if后多一个（ 不是的if()     中间//是或，所以两个语句在()内。不是这个问题，我看了", "referer": "user-0"}, {"cid": "12", "user": "user-10", "content": "借楼，发一个小玩意儿。GNU C 扩展的功能，详情参见：https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html # include <stdio.h>  int main (void) {     printf (\"%d\\n\", ({int n = 1, sum = 0;                       for (; n <= 100;) sum += n ++;                       sum;})); }", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:前一句if后多一个（ 这个没问题，你再看看", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "我看了，不是", "referer": "user-0"}, {"cid": "15", "user": "user-11", "content": "第6行，多了一个左括号", "referer": "user-0"}, {"cid": "16", "user": "user-12", "content": "说句重一点的话，你在代码的规范性上做的很差。按照规范你再写一遍代码，肯定就没问题。", "referer": "user-0"}, {"cid": "17", "user": "user-10", "content": "好象不够复杂，再合并一下。请用 GCC 编译运行。 # include <stdio.h>  int main (void) {     printf (({int year; scanf (\"%d\", & year); year % 400 == 0 ? \"yes.\\n\" : \"no.\\n\";})); }", "referer": "user-0"}, {"cid": "18", "user": "user-10", "content": "赵4老湿有理有据。建议用下面这段代码测试一下，如果能用 GNU C 一次性编译执行而没有问题，说明是个细心的银。 # include <stdio.h>  int main (void) {     int year;      printf (({scanf (\"%d\", & year); year % 400 == 0 ? \"yes.\\n\" : \"no.\\n\";})); }", "referer": "user-0"}, {"cid": "19", "user": "user-2", "content": "关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”", "referer": "user-0"}, {"cid": "20", "user": "user-2", "content": "//是注释 ||才是或 楼主脖子歪了还是眼睛斜了或者楼主所处位置地心引力方向不是严格向下？", "referer": "user-0"}]}
{"question": "求解大哥们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "解什么？问题说明确一下吧", "referer": "user-0"}]}
{"question": "关于单链表删除指定位置结点的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个代码删除除头结点外的节点是没问题的。但是如果删除头结点，这个就会有问题，需要额外处理一下～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个没问题：int ListDelete(LinkList *L,int i,ElemType *e) {     int j;     LinkList p,q;     p = *L;     j = 1;     while (p->next && j < i)     {         p = p->next;         ++j;     }     if (!(p->next) || j > i) return 0;     q = p->next;  //q指向i=3结点的头部     p->next = q->next; // p->next 指向i=3结点的尾部，即i=4结点的头部，                        //等同于 p->next = p->next->next,把i=2结点的尾部指针指向i=4结点的头部     *e = q->data;     free(q);   //释放q     return 1; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这里面有， 希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html。", "referer": "user-0"}]}
{"question": "C语言程序设计题，帮帮忙。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "调用prime函数求大于m的10最小素数之和？这题目没看懂呢。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:调用prime函数求大于m的10最小素数之和？这题目没看懂呢。 10个最小素数之和", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考：#include<stdio.h>  int isPrime(int n) {     int i;     if(n<=3) return n>1;     for(i=2;i*i<=n;i++)         if(n%i==0)return 0;     return 1; }  int main() {     int m,i,j=0,sum=0;     scanf(\"%d\",&m);     for(i=m+1;;i++){         if(isPrime(i)){            sum += i;            if(++j==10)break;         }     }     printf(\"sum=%d\\n\",sum);         return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "英语没有量词嘛。 求大于m的10个最小素数之和。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "判断质数可参", "referer": "user-0"}]}
{"question": "为什么第二个i++没有进行加1，而是直接等于上一个i++后的值?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "问题的根源是很多人没意识到，表达式是有值的，在一个大的表达式中，运算符操作的是子表达式的值。如果需要，任何表达式都有一个值，即使是 void 表达式，也会有一个（空）值。  表达式 i ++ 的值是左值 i 递增前的原值，同时，这个表达式还有一个将 i 的存储值加一的副作用。因此， x = i ++; 是将表达式 i ++ 的值赋给 x （同时 i 的存储值递增）。传统的解释是将 i 的值赋给 x ，然后 i 再递增，但它无法从逻辑上解释，i 是和 ++ 结合的，它凭什么，有什么义务要把自己的值赋给左边的 x 呢？毕竟，赋值运算符的右操作数是 i ++ 而不是 i  。  表达式 ++ i 的值是左值 i 递增后的新值，同时，这个表达式还有一个将 i 的存储值加一的副作用。因此， x =++ i; 是将表达式 ++ i 的值赋给 x （同时 i 的存储值递增）。传统的解释是先递增 i ，再把 i 赋给 x，但它同样无法从逻辑上解释，i 是和 ++ 结合的，它的义务是按照 ++ 的要求完成递增，它凭什么，有什么义务要把递增后的值赋给左边的 x 呢？毕竟，赋值运算符的右操作数是 ++ i 而不是 i  。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "因为s1[i++]是先以i++为整体的值作为s1的下表，然后在改变i的值，原因是这儿的自增是后增，如果是++i就是相反的。", "referer": "user-0"}]}
{"question": "用C语言编写一个简单的模拟打卡程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}]}
{"question": "求助：C语言程序在Linux系统下可以运行，在Windows系统里没有报错却无法运行该怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 it_xiangqiang的回复:希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 好的好的，我学习一下，谢谢你", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "在windows下把路径改了，但是没有用，应该是null的问题，我上机试试，谢谢你", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "/home/cbp/score.c这个在windows有这个路径和文件吗？  if((fd = fopen(\"/home/cbp/score.c\", \"rw\" ))<0){ perror(\"open:\"); exit(1); } 这个有问题呢，fd应该是和NULL比较。 原因是这个地方没有执行到exit，其实是因为找不到文件fd是NULL了，但是NULL < 0又不满足，所以没有exit，后面直接用fd出现段错误了。  解决办法：  if((fd = fopen(\"/home/cbp/score.c\", \"rw\" ))==  NULL){ perror(\"open:\"); exit(1); } 在Windows下试试，看看能不能直接运行perror和exit（windows下没有/home/目录）  楼主需要了解windows 和LINUX系统的区别，不能拿到代码就用，因为会有移植的问题～", "referer": "user-0"}]}
{"question": "求100以内的素数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修正11#楼的第19行：if(n%i==0) return 0;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 9 楼 智者知已应修善业的回复:２楼的文字点击即可达例子，查看例子中代码。 好的，了解了，谢谢哈", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "供参考：//方法1：  int f(int n) {     int i;     if(n<=1) return 0;     for(i=2;i<n;i++)         if(n%i==0) break;     if(i<n) return 0;     else    return 1; }  //方法2： int f(int n) {     int i;     if(n<=3) return n>1;     for(i=2;i*i<n;i++)         if(n%i==0) retrun 0;     return 1; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "２楼的文字点击即可达例子，查看例子中代码。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "在２楼判断质数可参就是链接地址，难道这都不知？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "提供的网址？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 5 楼 智者知已应修善业的回复:按提供的网址例子修改即可。 提供的网址？", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "按提供的网址例子修改即可。", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "函数f有问题呢，你的if (i < n)和else都应该放在循环外呢，而不是应该是循环内。  if (i < n) y=0; else y = 1; 这几条语句放到循环外应该就是没问题了。试试～", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 2 楼 智者知已应修善业的回复:判断质数可参 大神，请问有修改方案吗", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "判断质数可参", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "不用看，准是判断质数有问题。", "referer": "user-0"}]}
{"question": "C 语言中，关于 ( ) 运算符的解释", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在 for 语句中，关键字 for 后面的圆括号以及被括住的部分并不是语句，更不是复合语句，它只是组成 for 语句的一个成份：  for (声明/表达式1； 表达式2； 表达式3） 语句  下面这个程序，在标准C中是非法的、不可思议的，但它就是可以用 GNU C 编译并正常运行： # include <stdio.h>  int main (void) {     int n = 1, sum = 0;     printf (\"%d\\n\", ({for (; n <= 100;) sum += n ++; sum;})); }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 6 楼 十敷 的回复:[quote=引用 3 楼 均陵鼠侠的回复:]这种写法在标准的C和C++中都是不合法的，属于 GNU C 的扩展。在 GNU C 中，可以用一对圆括号将复合语句括起来，如此一来，你就可以在表达式中使用循环语句、选择语句和局部变量。  具体的说明，详见 GCC 的这篇文档：https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html 那这么说来 for 循环也是gnuc 拓展嘛？ [/quote] for 怎么是 GNU C 的扩展呢？说说你的理由。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 3 楼 均陵鼠侠的回复:这种写法在标准的C和C++中都是不合法的，属于 GNU C 的扩展。在 GNU C 中，可以用一对圆括号将复合语句括起来，如此一来，你就可以在表达式中使用循环语句、选择语句和局部变量。  具体的说明，详见 GCC 的这篇文档：https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html 那这么说来 for 循环也是gnuc 拓展嘛？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 7 楼 均陵鼠侠的回复:[quote=引用 6 楼 十敷 的回复:][quote=引用 3 楼 均陵鼠侠的回复:]这种写法在标准的C和C++中都是不合法的，属于 GNU C 的扩展。在 GNU C 中，可以用一对圆括号将复合语句括起来，如此一来，你就可以在表达式中使用循环语句、选择语句和局部变量。  具体的说明，详见 GCC 的这篇文档：https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html 那这么说来 for 循环也是gnuc 拓展嘛？ [/quote] for 怎么是 GNU C 的扩展呢？说说你的理由。[/quote] 第一 用小括号括的复合语句 第二 在括号里可以用局部变量 其实我都不大了解啥是gnu 只是看到您的解释突发奇想", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 均陵鼠侠 的回复:这种写法在标准的C和C++中都是不合法的，属于 GNU C 的扩展。在 GNU C 中，可以用一对圆括号将复合语句括起来，如此一来，你就可以在表达式中使用循环语句、选择语句和局部变量。  具体的说明，详见 GCC 的这篇文档：https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html 感谢大哥解惑", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "这种写法在标准的C和C++中都是不合法的，属于 GNU C 的扩展。在 GNU C 中，可以用一对圆括号将复合语句括起来，如此一来，你就可以在表达式中使用循环语句、选择语句和局部变量。  具体的说明，详见 GCC 的这篇文档：https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "Order of Evaluation This section discusses the order in which expressions are evaluated but does not explain the syntax or the semantics of the operators in these expressions. The earlier sections in this chapter provide a complete reference for each of these operators.  Expressions are evaluated according to the precedence and grouping of their operators. (Table 1.1 in Chapter 1, Lexical Conventions, shows the relationships the C++ operators impose on expressions.) Consider this example:  #include <iostream.h>  void main() {     int a = 2, b = 4, c = 9;      cout << a + b * c << \"\\n\";     cout << a + (b * c) << \"\\n\";     cout << (a + b) * c << \"\\n\"; }  The output from the preceding code is:  38 38 54  Figure 4.1   Expression-Evaluation Order     The order in which the expression shown in Figure 4.1 is evaluated is determined by the precedence and associativity of the operators:   Multiplication (*) has the highest precedence in this expression; hence the subexpression b * c is evaluated first.   Addition (+) has the next highest precedence, so a is added to the product of b and c.   Left shift (<<) has the lowest precedence in the expression, but there are two occurrences. Because the left-shift operator groups left-to-right, the left subexpression is evaluated first and then the right one.  When parentheses are used to group the subexpressions, they alter the precedence and also the order in which the expression is evaluated, as shown in Figure 4.2.  Figure 4.2   Expression-Evaluation Order with Parentheses    Expressions such as those in Figure 4.2 are evaluated purely for their side effects — in this case, to transfer information to the standard output device.  Note   The left-shift operator is used to insert an object in an object of class ostream. It is sometimes called the “insertion” operator when used with iostream.", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "Expression Statement Expression statements cause expressions to be evaluated. No transfer of control or iteration takes place as a result of an expression statement.  Syntax  expression-statement:  expressionopt ;  All expressions in an expression statement are evaluated and all side effects are completed before the next statement is executed. The most common expression statements are assignments and function calls. C++ also provides a null statement.    {语句1;语句2;} //将两个语句组合成一个语句 Compound Statements (Blocks) A compound statement consists of zero or more statements enclosed in curly braces ({ }). A compound statement can be used anywhere a statement is expected. Compound statements are commonly called “blocks.”  Syntax  compound-statement :  { statement-listopt }  statement-list :  statement statement-list  statement  The following example uses a compound statement as the statement part of the if statement (see The if Statement for details about the syntax):  if( Amount > 100 ) {     cout << \"Amount was too large to handle\\n\";     Alert(); } else     Balance -= Amount;  Note   Because a declaration is a statement, a declaration can be one of the statements in the statement-list. As a result, names declared inside a compound statement, but not explicitly declared as static, have local scope and (for objects) lifetime. See Scope in Chapter 2 for details about treatment of names with local scope.    (语句) //将语句当作表达式计算其值 C++ Operators Operators specify an evaluation to be performed on one of the following:   One operand (unary operator)   Two operands (binary operator)   Three operands (ternary operator)  The C++ language includes all C operators and adds several new operators. Table 1.1 lists the operators available in Microsoft C++.  Operators follow a strict precedence which defines the evaluation order of expressions containing these operators. Operators associate with either the expression on their left or the expression on their right; this is called “associativity.” Operators in the same group have equal precedence and are evaluated left to right in an expression unless explicitly forced by a pair of parentheses, ( ).", "referer": "user-0"}]}
{"question": "这道题，中间那里出错了。运行没问题，输出错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "程序没看出什么问题，输出是什么错误？输入又是什么内容，这些建议都贴出来吧。", "referer": "user-0"}]}
{"question": "求助 大一C语言课程设计", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 weixin_52677262 的回复:[quote=引用 2 楼 it_xiangqiang的回复:] 希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 咋还要付钱[/quote] 你认为呢？这是推销个人付费博客的，几乎每个帖子都发，谁付钱给谁看，csdn也推荐这个很无语；", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 it_xiangqiang的回复:希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 咋还要付钱🐶", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 it_xiangqiang的回复:希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 咋还要付钱，而且没看见有什么与我的问题相关的啊😂", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}]}
{"question": "大佬们，我这个哪里出问题了，我是个新手。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "计算机代码不允许使用中文符号", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> int main(void) { \tint a=2,b=3; \ta=a+b; \tb=a-b; \ta=a-b; \tprintf(\"%d,%d\\n\",a,b); \treturn 0; } 注意细节问题，把结构背清楚 而且你这个运算意义不大，可以尝试四则运算", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "好歹发一下源码啊！", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "注意中英文和单词拼写错误～这是最基本的语法问题～", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "这个教程适合你，希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "哪里错了呀，是空格还是啥出问题了", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "是  printf  不是 prirtf        另外怀疑你的 \" \" 用的是中文字符， 关闭输入法", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "第四行mint ,多打了m 呀，int a=2,b=3;", "referer": "user-0"}]}
{"question": "返回值是什么?为什么?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "忽视了, 应该设置变量保存初始地址", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 aguang 的回复:char *mystrcpy(char *s,const char *t) { \twhile (*s++=*t++); \t*s='\\0'; \treturn s; } 返回字符串末尾地址？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "返回值是目的串的地址，这个函数用于字符串拷贝，将源串拷贝到目的串（那个参数是目的串地址可以自由指定），可以通过两种方式获取目的串的地址，一个是参数，再一个就是这个返回值。  楼主写的不对，应该返回s1。另外，既然是所有都拷贝，因此，不需要用两个循环变量，用一个即可，或者一个也不用，如下供参考～  char *mystrcpy(char *dst, const char *src) {     char *tmp = dst;      while (*src)         *dst++ = *src++;     *dst = 0; //'\\0'      return tmp; }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "char *mystrcpy(char *s,const char *t) { \twhile (*s++=*t++); \t*s='\\0'; \treturn s; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "函数需要返回的是数组s1的第一个元素的指针，相当于返回&s1[0]，楼主的函数返回的是  return s2; ,  修改如下，供参考：char *mystrcpy(char *s1,char *s2) {     int i=0;     for(i=0;s2[i];i++)         s1[i] = s2[i];     s1[i] = '\\0';     return s1;//返回的是s1的首地址 }", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "根据C语言定义, 对于 'T s[常量表达式]' 即s是T类型的数组;   表达式s的值是指向数组中第1个对象的指针(表达式&/ziseof情形除外). 所以s的值是一个地址,而且 *s==s[0]", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "这里面有，希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}]}
{"question": "求帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf是一种方式输入，printf是一种方式输出，fprintf是不是也算一种  fgets，fputs也算一种输入输出？", "referer": "user-0"}]}
{"question": "不太清楚哪里错了，一直显示错误(๑´0`๑)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这里面有，希望对您有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "方法多 #include <stdio.h> int main() {   int n, b=0,s=0;   for (; (n=getchar())&&n!='\\n'; b++, s += n-'0')   printf(\"%d %d\\n\", b, s);   return 0; } #include <stdio.h> int main (void) {     int a=0,b=0,c;     scanf(\"%d\",&c);     for(;c>0;a++,b+=c%10,c/=10);     printf(\"%d %d\",a,b); }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 4 楼 早打大打打核战争 的回复:思路决定代码：  #include <stdio.h>  int main() {   int n, b, s;    for (b = s = 0; ~scanf(\"%1d\", &n); b++, s += n);   printf(\"%d %d\\n\", b, s);    return 0; }  还需要提醒一句吧，怎么输出结果（终止循环）  ctrl+d(linux)或ctrl+z（Windows）", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "思路决定代码：  #include <stdio.h>  int main() {   int n, b, s;    for (b = s = 0; ~scanf(\"%1d\", &n); b++, s += n);   printf(\"%d %d\\n\", b, s);    return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "修改如下，供参考：#include<stdio.h>  int main()  {     int n,i=0,x=0,y;      scanf(\"%d\",&n);      if(n<=1000000000&&n!=0)      {        while(n)//for(i=1;i<=9;i++)          {            y=n%10;            x+=y;            n=n/10;            i++;            //if(n==0)                          //    break;                          // else                          // i++;         }     printf(\"%d %d\",i,x);    }          return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "#include<stdio.h> #include <ctype.h> int main(void) {  #if 1     char digit[128], *pstr;     int cnt = 0, sum = 0;      fgets(digit, sizeof(digit), stdin);      if (digit[0] == '-') {         printf(\"Error input!\\n\");         return -1;     }     pstr = digit;     while (*pstr) {         if (isdigit(*pstr)) {             sum += *pstr - '0';             cnt++;         }         pstr++;     }      printf(\"%d %d\\n\", cnt, sum); #else     int n,i,x=0,y;      scanf(\"%d\",&n);      if(n<=1000000000&&n!=0)     {         for(i=1;i<=9;i++)          {             n=n/10;             y=n%10;             x+=y;             if(n==0)                 break;             else                 i++;         }         printf(\"%d %d\",i,x);     } #endif     return 0;  } 供参考～", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0"}]}
{"question": "C#文件内容修改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。http://bbs.csdn.net/topics/391975224", "referer": "user-0"}]}
{"question": "引发了未经处理的异常:读取访问权限冲突。 q 是 0xCCCCCCCC，求大佬解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h>  typedef int Elemtype; typedef struct link {     int elem;     struct  link* next; }link;  link * initLink() {     link *p = (link *)malloc(sizeof(link));//创建一个头结点     if (!p)         exit(0);     link* temp = p;//声明一个指针指向头结点，用于遍历链表     //生成链表     for (int i = 1; i < 5; i++) {         link* a = (link*)malloc(sizeof(link));         if (!a)             exit(0);         a->elem = i;         a->next = NULL;         temp->next = a;         temp = temp->next;     }      return p; } //void bianli(link* p) void bianli(link* phead) {     if (!phead)         return;     //link* q = phead;     link* q = phead->next;      //while (q->next)     while (q)     {         //q = q->next;         printf(\"%d\",q->elem);         q = q->next;     }     printf(\"\\n\"); }  int main() {     link* p = initLink();     //bianli(&p); //visit     bianli(p); //visit      return 0; } 供参考～  参数类型不匹配，其他问题详见代码～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include<stdio.h> #include<stdlib.h> typedef int Elemtype;  typedef struct link {     int     elem;     struct  link* next; }link;  link * initLink() {     link* p = (link*)malloc(sizeof(link));//创建一个头结点     link* temp = p;//声明一个指针指向头结点，用于遍历链表      //生成链表     for (int i = 1; i < 5; i++) {          link* a = (link*)malloc(sizeof(link));          a->elem = i;          a->next = NULL;          temp->next = a;          temp = a; //  temp = temp->next;     }     return p; } void bianli(link* p) {     link* q = p;     while (q->next)     {           q = q->next;           printf(\"%d \",q->elem);     }     printf(\"\\n\"); }   int main() {     link* p = initLink();     bianli(p);           //bianli(&p);          return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "111求解啊", "referer": "user-0"}]}
{"question": "谁能帮我写个完整的C语言程序解决这个问题，谢谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参见download.csdn.net/user-1", "referer": "user-0"}]}
{"question": "c语言  表达式中连续多次自增运算相加为什么表达式会自加1", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "求值顺序未定义，编译器可以自行决定，甚至同一编译器不同选项的情况下可以有不同的结果，第一个表达式，5+6+7、 6+6+7、7+7+7都有可能", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "关于C,C++表达式求值顺序 http://blog.csdn.net/fefe82/article/details/37833767，http://bbs.csdn.net/topics/370153775", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "当着出这个题目的人面骂他是傻X。然后扔一份C++的标准到他脸上让他自己看", "referer": "user-0"}]}
{"question": "求助帖 这道C语言不知道错哪了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "小白写的，可以参考   #include<stdio.h>  int main() { \tconst int length = 9; \tint numbers[length] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };  \tfor (int i = 0; i < 9; i++) \t{ \t\tprintf(\"%d \", numbers[i]); \t} \tprintf(\"\\n\");  \tprintf(\"要移动的次数：\"); \tint moveCounts; \tscanf_s(\"%d\", &moveCounts);  \tint temp; \tfor (int i = 0; i < moveCounts; i++) \t{ \t\ttemp = numbers[length - 1]; \t\tfor (int j = length - 1; j > 0; j--) \t\t{ \t\t\tnumbers[j] = numbers[j - 1]; \t\t} \t\tnumbers[0] = temp; \t}  \tfor (int i = 0; i < length; i++) \t{ \t\tprintf(\"%d \", numbers[i]); \t}  \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "把a[j]=b[9-i]下一行的k++改成j++", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include<stdio.h> #define N 9 int main() {     int i,j,n,m;     int a[N]={12,54,85,39,51,76,90,14,20};     printf(\"请输入要移动的位数:\");     scanf(\"%d\",&n);     for(i=0;i<n;i++){         for(j=N-1,m=a[j];j>0;j--){             a[j] = a[j-1];         }         a[j]=m;     }     for(i=0;i<N;i++){         printf(\"%d \",a[i]);     }     printf(\"\\n\");          return 0; }", "referer": "user-0"}]}
{"question": "c语言桌面程序无响应", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码完整贴上来。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:个人觉得SDK纯API方式编写Windows程序已经过时了，效率太低，了解一下原理就可以了，主要是消息机制。  图形用户界面（GUI）编程可以学习C++ Builder，架构先进（和C#一样拖控件），入门比较容易。  　　C++ Builder是真正的可视化的开发工具。C++ Builder可以用鼠标拖拉控件加上设置属性轻松的“设计”出一个程序的图形用户界面，利用可视的组件/控件像“搭积木”一样，以“所见即所得”的方式搭建应用程序的界面，这也是C++ Builder这个名字中Builder的概念。这样，只需要用C++语言编写业务逻辑代码，类似于DOS下文本界面编程，只要专注于实现业务逻辑功能就可以了，代码非常简洁。数据的输入和表现，都在图形用户界面，非常直观、易用。这就是RAD开发（Rapid Application Development，快速应用程序开发）。  书籍推荐： 《C++Builder 6程序设计教程（第二版）》 （陆卫忠，刘文亮　等编著 /2011-04-01 /科学出版社）（当当网） 《C++Builder 6编程实例精解》（赵明现），PDF，是数字版的，非扫描版的，里面还有一个俄罗斯方块游戏的完整实现。 《精彩C++Builder 6程序设计》（台湾 吴逸贤），里面有10几个简单小游戏的实现，可以自己看懂以后再重写，才是自己掌握的。 《C++ Builder 5高级编程实例精解》（刘滨 编著）都是较大的实用的程序。  C++ Builder 6.0几个示例程序项目源代码下载：       C++ Builder第一个程序（模拟聊天室）v1.11 C++ Builder模拟数字双时钟示例（未完成）v0.2.1 C++ Builder纸牌游戏Demo v0.05 C++ Builder不规则图像透明贴图（位图的透明显示）三种方法及简单动画v1.3 C++ Builder写的《ZEC 四则运算练习程序》 海底海星情景v0.9.2 C++ Builder简单电话簿Demo例子v1.11 不是就是想简单尝试一下，但是总是找不到bug在哪，一开始输入数据好好的，每次到了一定程度就卡死不动了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "个人觉得SDK纯API方式编写Windows程序已经过时了，效率太低，了解一下原理就可以了，主要是消息机制。  图形用户界面（GUI）编程可以学习C++ Builder，架构先进（和C#一样拖控件），入门比较容易。  　　C++ Builder是真正的可视化的开发工具。C++ Builder可以用鼠标拖拉控件加上设置属性轻松的“设计”出一个程序的图形用户界面，利用可视的组件/控件像“搭积木”一样，以“所见即所得”的方式搭建应用程序的界面，这也是C++ Builder这个名字中Builder的概念。这样，只需要用C++语言编写业务逻辑代码，类似于DOS下文本界面编程，只要专注于实现业务逻辑功能就可以了，代码非常简洁。数据的输入和表现，都在图形用户界面，非常直观、易用。这就是RAD开发（Rapid Application Development，快速应用程序开发）。  书籍推荐： 《C++Builder 6程序设计教程（第二版）》 （陆卫忠，刘文亮　等编著 /2011-04-01 /科学出版社）（当当网） 《C++Builder 6编程实例精解》（赵明现），PDF，是数字版的，非扫描版的，里面还有一个俄罗斯方块游戏的完整实现。 《精彩C++Builder 6程序设计》（台湾 吴逸贤），里面有10几个简单小游戏的实现，可以自己看懂以后再重写，才是自己掌握的。 《C++ Builder 5高级编程实例精解》（刘滨 编著）都是较大的实用的程序。  C++ Builder 6.0几个示例程序项目源代码下载：       C++ Builder第一个程序（模拟聊天室）v1.11 C++ Builder模拟数字双时钟示例（未完成）v0.2.1 C++ Builder纸牌游戏Demo v0.05 C++ Builder不规则图像透明贴图（位图的透明显示）三种方法及简单动画v1.3 C++ Builder写的《ZEC 四则运算练习程序》 海底海星情景v0.9.2 C++ Builder简单电话簿Demo例子v1.11", "referer": "user-0"}]}
{"question": "要求是回文数又是素数，为什么两个代码运行出来不一样。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两个方法都存在漏洞和错误，第一种里，for(f=2;f<=e;f++)if(b%f==0)return 0; ，如果b素数时，if(b%f==0)return 0; 这条语句不会被执行到，也就意味着到函数运行结束，也没有一个明确的返回值，主函数里的if()判断靠什么去判断呢， 这是潜在的隐患。第二种是错上加错，不但第一种的隐患没排除，还把判断if(b%f!=0) return 1; 条件搞反了，把不是 素数的也归到素数里去了，假如b=9时，9%2!=0成立，马上return 1。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qzjhjxj的回复:修改第一个，供参考：#include<stdio.h> #include<math.h> int sushu(int b); int huiwen(int c); int main() {     int a;     for(a=100;a<1000;a++)     {         if(sushu(a) && huiwen(a))            printf(\"%d\\n\",a);     }          return 0; }  int sushu(int b) {     int e,f;     e=sqrt(b);     for(f=2;f<=e;f++)        if(b%f==0)return 0;     return 1; }  int huiwen(int c) {     int g,h;     g=c/100;     h=c%10;     if(g==h)        return 1;     return 0; } 第二种方法的，第二个自定义函数为啥不对。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2的回复:两个都不对啊，验证素数的函数总得既能返回0又能返回1吧？这样才符合逻辑啊。 错在第二个自定义函数if的判断", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:两个都不对啊，验证素数的函数总得既能返回0又能返回1吧？这样才符合逻辑啊。 第一个对的，第二个不对", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "修改第一个，供参考：#include<stdio.h> #include<math.h> int sushu(int b); int huiwen(int c); int main() {     int a;     for(a=100;a<1000;a++)     {         if(sushu(a) && huiwen(a))            printf(\"%d\\n\",a);     }          return 0; }  int sushu(int b) {     int e,f;     e=sqrt(b);     for(f=2;f<=e;f++)        if(b%f==0)return 0;     return 1; }  int huiwen(int c) {     int g,h;     g=c/100;     h=c%10;     if(g==h)        return 1;     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "两个都不对啊，验证素数的函数总得既能返回0又能返回1吧？这样才符合逻辑啊。", "referer": "user-0"}]}
{"question": "用C语言实现排名", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "相同的成绩，不同的排名，给的条件不充分，如果按字面的理解很简单就实现了。", "referer": "user-0"}]}
{"question": "【C语言求助】一道有yi点难的链表题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复: 谢谢你一直以来的帮助", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复: 哈哈哈 我这边C语言的洗礼结束了，但是学习不会止步。 最后的期中考题独立完成，爽爽哒 要去学Python了。。。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "大家先不用回复，我再改改，这个版本甚至都不完善", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "供参考~ 欢迎大家找错（滑稽）#include <stdio.h> #include <stdlib.h> #include <time.h> /*  1.链表与数组综合操作(本题满分100分，每问20分)  a) 生成一个长度100、取值范围在0-300的整数构成的链表，并打印  b) 将其按从小到大的顺序插入到另一个链表，并遍历打印  c) 将这个排好序的链表的结果写入到文件1000_numbers.txt  d) 再从文件读入数据，存储到一个数组，并打印  e) 统计出现频次最多的数字，并打印 */ struct node {     int num;     struct node *next; }; struct node *creat_lianbiao() {     //生成一个长度100，取值范围在0-300的随机整数构成的链表...Done     //int num;     srand( time(0) );      int i = 0;     struct node  *head = NULL, * p = head, *newnode = NULL;     while(1)     {          newnode = (struct node *)malloc(sizeof(struct node));         newnode->num = rand()%301 ;         //printf(\"%d \",newnode->num);          if(head == NULL)         {             head = newnode;             p = head;         }          else if(head != NULL)         {              p->next = newnode;             p = p->next;         }          i++;          if(i == 100)         {             p->next = NULL;             break;         }      }     //p=head;     return head; } //遍历打印链表的函数 void print_lianbiao(struct node *head) {     struct node *p = head;     int i = 0;     while(p != NULL)     {         i++;         printf(\"the %dth number: \", i );         printf(\"%d\\n\", p->num );         p = p->next;      } } /*核心部分：   说明：       1.本题不能在原链表里排序后再插入到另一个链表       2.不能使用链表进行插入       3.我的想法是：循环，找出每次循环的最小值，                     把这个最小值所在的结点插入到新建的链表里，同时在原链表里删除该结点                     这样在下一次循环的时候就不会找到上次的最小值       4.问题是循环无法执行下去  */ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ struct node *creat_sort_lianbiao(struct node *head) {     struct node *p = head, *head_2 = NULL ,*p_min = head ,*p_2 = head_2 ,*newnode_2 = NULL ,*tmpnode = NULL;     int min = p_min->num ,i = 0;      while(1)//     {         p = head;         min = head->num;         p_min = head;         while(1)//每次循环找当前链表里的最小值         {              if(min > p->num)//如果min记录的大于当前值             {                 //printf(\"Done...\\n\");                 min = p->num;                 p_min = p;//把当前值的地址给p_min              }             printf(\"min=%d\\n\",min);             if(p->next == NULL) break; //如果到尾了，break             p = p->next;         }         p = head;          i++;         while(1)//每次循环把原链表的min值所在地址赋给p_2，并将原链表的该结点删除         {              if(p_min == head)             {                        newnode_2 = (struct node *)malloc(sizeof(struct node));//开辟节点                     newnode_2->num = p_min->num;                     newnode_2->next = NULL;                    // p_2->next->next = (struct node *)malloc(sizeof(struct node));//再开辟节点                      if(head_2 == NULL)//如果head_2是空链表                     {                         //printf(\"%d\",head_2);                         head_2 = newnode_2;                         p_2 = head_2;                         p_2->next = NULL;                          tmpnode = head;                         head = head->next;                         free(tmpnode);                          p = head;                          //printf(\"%d\\n\",head_2);                         printf(\"p_2->num = %d\\n\", p_2->num );                         break;                      }                     else if(head_2 != NULL)                     {                         //p_2 = head_2;                         p_2->next = newnode_2;                         p_2 = p_2->next;                         p_2->next = NULL;                          tmpnode = head;                         head = head->next;                         free(tmpnode);                          p = head;                          printf(\"p_2->num = %d\\n\", p_2->num );                         break;                      }              p = p->next;              }              else if(p_min != head)             {                   if(p->next == p_min)//循环搜索，如果匹配到p_min                 {                     printf(\"I find it !\\n\");                      newnode_2 = (struct node *)malloc(sizeof(struct node));//开辟节点                     newnode_2->num = p_min->num;                     newnode_2->next = NULL;                     // p_2->next->next = (struct node *)malloc(sizeof(struct node));//再开辟节点                      if(head_2 == NULL)//如果head_2是空链表                     {                         //printf(\"%d\",head_2);                         head_2 = newnode_2;                         p_2 = head_2;                         p_2->next = NULL;                         p->next = p->next->next; //删除原链表中的min值的节点                         free(p_min);                          //printf(\"%d\\n\",head_2);                         printf(\"p_2->num = %d\\n\", p_2->num );                         break;                      }                     else if(head_2 != NULL)                     {                          p_2->next = newnode_2;                         p_2 = p_2->next;                         p_2->next = NULL;                         p->next = p->next->next;                         free(p_min);                          printf(\"p_2->num = %d\\n\", p_2->num );                         break;                      }                  }                 p = p->next;              }           }         printf(\"The %dth round\\n\",i);         if(i == 100)//如果执行了100次就结束         {             //printf(\"Done...\\n\");             break;         }      }     //printf(\"Done...\\n\");     return head_2;    } //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  void main() {     printf(\"This is the mid-term exam of 张圣儒 no.20344152\\n\");     printf(\"第一题：\\n\");     struct node * head = NULL, * p = head ,* head_2=NULL;      head = creat_lianbiao();//生成一个长度100，取值范围在0-300的随机整数构成的链表...Done     print_lianbiao(head);//打印原链表...Done     putchar('\\n');     putchar('\\n');     head_2 = creat_sort_lianbiao(head);//生成新的链表     //printf(\"Done...\");     print_lianbiao(head_2);//打印新的链表   }  （a）（b）步运行结果：", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "啊。。。经过艰苦的奋斗，我终于。。。终于完成了，bug也修完了(没想到是被自己解决的)", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "第二大段注释那里“不能用链表排序”打错了，应该是“不能用数组辅助排序”", "referer": "user-0"}]}
{"question": "请问这个杨辉三角的第五行的113是怎么得到的啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议贴代码。百度下。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 舉杯邀明月的回复:代码有BUG呗，第5行的数据是 1 4 6 4 1 才对。  怎么解决啊？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "代码有BUG呗，第5行的数据是 1 4 6 4 1 才对。", "referer": "user-0"}]}
{"question": "c语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "c语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:怎么不对？可以把sum <=3000条件改小点，改为sum <=10 看看是否是正确。 没错谢谢是自己电脑问题", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:怎么不对？可以把sum <=3000条件改小点，改为sum <=10 看看是否是正确。 谢啦", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:怎么不对？可以把sum <=3000条件改小点，改为sum <=10 看看是否是正确。 应该没错，我不管改成多少他这个结果都和我第一次输入的数据算出来的结果一样，可能电脑有点问题", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "怎么不对？可以把sum <=3000条件改小点，改为sum <=10 看看是否是正确。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 qzjhjxj的回复:供参考：#include<stdio.h>  void main() {      int i=1,sum=0;      while(sum<=3000)      {          sum += i;          i++;      }      printf(\"1+2+3+...+%d=%d\\n\",--i,sum);       } 为什么我这个运行以后的结果好像不太对", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "变量i没有被初始化", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "供参考：#include<stdio.h>  void main() {      int i=1,sum=0;      while(sum<=3000)      {          sum += i;          i++;      }      printf(\"1+2+3+...+%d=%d\\n\",--i,sum);       }", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "声明一下，我只是看 main 函数的返回类型是 void 觉得不顺眼，所以回复一下，哈哈哈。 # include <stdio.h>  int main (void) {     int n = 1, sum = 0;      while ((sum += n ++) <= 3000) ;      printf (\"%d\\n\", n); }", "referer": "user-0"}]}
{"question": "c语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 浪客的回复:楼主太懒，提示中把题目答案几乎都给出来了。   #include <stdio.h>  void print(int A[4])  //后面都是相同的输出，图省事 { \tfor (int i = 0; i < 4; i++) \t{ \t\tprintf(\"%d\\t\", A[i]); \t} \tprintf(\"\\n\"); }  int main() { \tint C[4][4], AB[4], BB[4], AC[4], i, j; \tint A[4][4] = { 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31 }; \tint B[4][4] = { 2,4,6,8,10,12,14,16,18,20,22,24,46,28,30,32 };  \t// C=A+B \tfor (i = 0; i < 4; i++) \t{ \t\tfor (j = 0; j < 4; j++) \t\t{ \t\t\tC[i][j] = A[i][j] + B[i][j]; \t\t} \t}  \tprintf(\"Array C[4][4]:\\n\"); \tfor (i = 0; i < 4; i++) \t{ \t\tfor (j = 0; j < 4; j++) \t\t{ \t\t\tprintf(\"%d\\t\", C[i][j]); \t\t} \t\tprintf(\"\\n\"); \t}  \t// AB \tfor (i = 0; i < 4; i++) \t{ \t\tAB[i] = A[1][i];\t//第二行：A[1][0]...A[1][3] \t} \tprintf(\"\\nArray AB[4]:\\n\"); \tprint(AB);  \t// BB \tfor (i = 0; i < 4; i++) \t{ \t\tBB[i] = B[i][2];\t//第三列：B[0][2]...B[3][2] \t} \tprintf(\"\\nArray BB[4]:\\n\"); \tprint(BB);  \t// AC \tfor (i = 0; i < 4; i++) \t{ \t\tAC[i] = A[i][i]+B[i][i];\t//这个数组中，对角线行列索引相等 \t} \tprintf(\"\\nArray AC[4]:\\n\"); \tprint(AC);  \treturn 0; }   为什么运行有错误", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "楼主太懒，提示中把题目答案几乎都给出来了。   #include <stdio.h>  void print(int A[4])  //后面都是相同的输出，图省事 { \tfor (int i = 0; i < 4; i++) \t{ \t\tprintf(\"%d\\t\", A[i]); \t} \tprintf(\"\\n\"); }  int main() { \tint C[4][4], AB[4], BB[4], AC[4], i, j; \tint A[4][4] = { 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31 }; \tint B[4][4] = { 2,4,6,8,10,12,14,16,18,20,22,24,46,28,30,32 };  \t// C=A+B \tfor (i = 0; i < 4; i++) \t{ \t\tfor (j = 0; j < 4; j++) \t\t{ \t\t\tC[i][j] = A[i][j] + B[i][j]; \t\t} \t}  \tprintf(\"Array C[4][4]:\\n\"); \tfor (i = 0; i < 4; i++) \t{ \t\tfor (j = 0; j < 4; j++) \t\t{ \t\t\tprintf(\"%d\\t\", C[i][j]); \t\t} \t\tprintf(\"\\n\"); \t}  \t// AB \tfor (i = 0; i < 4; i++) \t{ \t\tAB[i] = A[1][i];\t//第二行：A[1][0]...A[1][3] \t} \tprintf(\"\\nArray AB[4]:\\n\"); \tprint(AB);  \t// BB \tfor (i = 0; i < 4; i++) \t{ \t\tBB[i] = B[i][2];\t//第三列：B[0][2]...B[3][2] \t} \tprintf(\"\\nArray BB[4]:\\n\"); \tprint(BB);  \t// AC \tfor (i = 0; i < 4; i++) \t{ \t\tAC[i] = A[i][i]+B[i][i];\t//这个数组中，对角线行列索引相等 \t} \tprintf(\"\\nArray AC[4]:\\n\"); \tprint(AC);  \treturn 0; }", "referer": "user-0"}]}
{"question": "c语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 weixin_57293030的回复:第一个 if 写的不对  if(n>m)  好像是m>n", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 weixin_57293030的回复:第一个回复写反了，应该是  if(m>n)", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考：#include<stdio.h> void main() {     int m,n,t,i,sum=0,count=0;     printf(\"Enter m,n:\");     scanf(\"%d%d\",&m,&n);     if( m > n){t=m;m=n;n=t;}     for(i=m;i<=n;i++)        if(i%3==0 && i%5!=0)        {           sum += i;           count++;        }     printf(\"sum=%d;count=%d\\n\",sum,count);      }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "第一个回复写反了，应该是  if(m>n)", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "第一个 if 写的不对  if(n>m)", "referer": "user-0"}]}
{"question": "谁能帮我写个完整的C语言程序，解决这个问题，谢谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include<stdio.h> #include<math.h>  int sort(float *a,int n) {     int   i,j;     float t;     for(i=0;i<n-1;i++)         for(j=0;j<n-i-1;j++)             if(fabs(*(a+j)) < fabs(*(a+j+1)))//从大到小                {                   t      =*(a+j);                   *(a+j) =*(a+j+1);                   *(a+j+1)=t;                } }  int main() {     float a[10];     int   i;     for(i=0;i<10;i++)         scanf(\"%f\",&a[i]);     sort(a,10);     for(i=0;i<10;i++)         printf(\"%.2f%c\",a[i],i<9?',':'\\n');      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "好人一生平安！！！", "referer": "user-1"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int main 是不是要return一个int呢？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "楼主这个代码没什么问题，解释见注释，供参考：//程序内容是实现回文数的判断：  //还有一个问题： //为了存储输入数字每一位上的数，我在程序中定义了一个容量为9999的数组，怎么实现根据输入数字 //的位数来定义数组的容量啊？？   #include <stdio.h>  int main() {             //问题一：     int b[10];//C语言中int的取值范围为：-2147483648 ~ 2147483647，十进制最大是10位数，所以b[？]不用这么大      int a,n=0,i=0,j=0,c;     printf(\"请输入一个数\\n\");     scanf(\"%d\",&a);     c=a;     //如果在这里加入动态数组的定义，最前面的 int b[10]; 定义需删除或在头部加'//' 改为注释     //根据输入数字的位数来定义数组容量：你先需计算出输入数字的位数n，     //然后: int *b = (int *)malloc(sizeof(int)*n); memset(b,0,sizeof(int)*n);      for(a=c;a>=10;a=a/10)     {         b[i]=a%10;         i=i+1;     }     b[i]=a%10;     if(i%2==1)     {        for(n=0;n<(i+1)/2;n++)        {           if(b[n]==b[i-n])           {              j=j+1;           }        }        if(j==(i+1)/2)           printf(\"True\");        else           printf(\"False\");     }     else     {       for(n=0;n<=i/2;n++)       {           if(b[n]==b[i-n])           {              j=j+1;           }       }       if(j==i/2+1)          printf(\"True\");       else          printf(\"False\");     }     //如果定义b[]是动态的，在代码结束语句之前输入：free(b);显式释放数组，或不加 = 隐式释放。          return 0; }   //问题二： // error: redefinition of 'main'编译错误,main的重复定义 //这个题库的操作方法就是：只需要补上 欠缺的代码 即可", "referer": "user-0"}]}
{"question": "萌新求助，我到底哪里错了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "重点在第8行末或第9行末的‘;'号 ，scanf(\"%d%d\",&hour2,&minute2); int t1 = hour1 * 60 + minute1; #include<stdio.h>  int main() {      int hour1,minute1;      int hour2,minute2;      scanf(\"%d%d\",&hour1,&minute1);      scanf(\"%d%d\",&hour2,&minute2);      int t1 = hour1 * 60 + minute1;      int t2 = hour2 * 60 + minute2;      int t  = t2-t1;      printf(\"时间差是%d小时%d分钟。\",t/60,t%60);            return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你违背了你的编译器规则，变量声明要在执行语句之前。", "referer": "user-0"}]}
{"question": "萌新求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:两句scanf() 输入在后，计算t值在前，它们用什么计算呢？这样改下，供参考：#include<stdio.h>  int main() {      int hour1,minute1,t1,t2,t;      int hour2,minute2;       scanf(\"%d%d\",&hour1,&minute1);      scanf(\"%d%d\",&hour2,&minute2);       t1 = hour1 * 60 + minute1;      t2 = hour2 * 60 + minute2;      t  = t2-t1;      printf(\"时间差是%d小时%d分钟。\",t/60,t%60);            return 0; } 感谢！学会了！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "两句scanf() 输入在后，计算t值在前，它们用什么计算呢？这样改下，供参考：#include<stdio.h>  int main() {      int hour1,minute1,t1,t2,t;      int hour2,minute2;       scanf(\"%d%d\",&hour1,&minute1);      scanf(\"%d%d\",&hour2,&minute2);       t1 = hour1 * 60 + minute1;      t2 = hour2 * 60 + minute2;      t  = t2-t1;      printf(\"时间差是%d小时%d分钟。\",t/60,t%60);            return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "scanf后面写t1=hour1*60+minute1；t2=hour2*60+minute2;t=t2-t1;", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "输入完后再赋值，hour1，minute1，hour2，minute2，还没开始输入数值赋值，你初始化时就用来给t1和t2和t赋值了，后面输入完数据后又没有给t1，t2，t，赋值。", "referer": "user-0"}]}
{"question": "谁能帮我写个C语言程序解决这个问题吗，谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复:编译之前，我放在#2楼的修正说明，int i=0；那里你改过了吗？#include<stdio.h> //#include<string.h>  int main() {     char str[1024][64]={0},tmp[64]={0};     int  i=0,j,k;     while(gets(str[i++])!=NULL);//ctrl+z 结束输入     for(j=0;j<i-1;j++)         for(k=0;k<i-j-1;k++)             if(strcmp(str[k],str[k+1])>0){                strcpy(tmp,str[k]);                strcpy(str[k],str[k+1]);                strcpy(str[k+1],tmp);             }     for(j=0;j<i;j++) puts(str[j]);     system(\"pause\");     return 0; }   //zwtr //fhoenf //hefe //afe geg^Z  //afe geg //fhoenf //hefe //zwtr //请按任意键继续. . .  开始运行不了是我的问题，谢谢作者！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 qzjhjxj的回复:什么样的问题？ 程序无法执行，或者发生运行时错误", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "什么样的问题？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:供参考：#include<stdio.h> #include<string.h>  int main() {     char str[1024][64]={0},tmp[64]={0};     int  i,j,k;     while(gets(str[i++])!=NULL);//ctrl+z 结束输入     for(j=0;j<i-1;j++)         for(k=0;k<i-j-1;k++)             if(strcmp(str[k],str[k+1])>0){                strcpy(tmp,str[k]);                strcpy(str[k],str[k+1]);                strcpy(str[k+1],tmp);             }     for(j=0;j<i;j++) puts(str[j]);          return 0; } 谢谢，但好像运行有点问题", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "修正楼上第7行，i 初始值int  i=0,j,k;", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "供参考：#include<stdio.h> #include<string.h>  int main() {     char str[1024][64]={0},tmp[64]={0};     int  i,j,k;     while(gets(str[i++])!=NULL);//ctrl+z 结束输入     for(j=0;j<i-1;j++)         for(k=0;k<i-j-1;k++)             if(strcmp(str[k],str[k+1])>0){                strcpy(tmp,str[k]);                strcpy(str[k],str[k+1]);                strcpy(str[k+1],tmp);             }     for(j=0;j<i;j++) puts(str[j]);          return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>  #define MAXLINES 1000 #define BUFSIZE 10000  int readlines(char *[],char buf[],int); void qsort1(char *[],int,int); void writelines(char *[],int);  int main() {     int nlines;     char *lineptr[MAXLINES];     char buf[BUFSIZE];      if ((nlines=readlines(lineptr,buf,MAXLINES))>0){         qsort1(lineptr,0,nlines-1);         writelines(lineptr,nlines);         return 0;     }else{         printf(\"error\");         return 1;     } } #define MAXLINE 100 int readlines(char *lineptr[],char v[],int maxlines) {      int nlines,len;     char line[MAXLINE];     char *p =v;     char *top = v+BUFSIZE;     int getline(char *,int);      nlines =0;     while ((len = getline(line,MAXLINE)) > 0){         if (nlines >= maxlines || (p + len) > top ){             return -1;         }else{             line[len-1] = '\\0';             strcpy(p,line);             lineptr[nlines++] = p;             p += len;          }     }      return nlines; }  int getline(char *s,int imt) {     int c;     char *t =s;     while (--imt > 0 && (c = getchar()) != EOF && c != '\\n')         *s++ = c;     if (c == '\\n')         *s++ = c;     *s = '\\0';     return s-t; }  void writelines(char *s[],int n) {     while (n-- > 0)         printf(\"%s\\n\",*s++); }  void qsort1(char *v[],int left,int right) {     int lastc,i;     void swap(char *[],int,int);      if (left >= right)         return;     swap(v,left,(left+right)/2);     lastc =left;     for (i = left+1;i<=right;i++)         if (strcmp(v[i],v[left])<0)             swap(v,++lastc,i);     swap(v,lastc,left);     qsort1(v,left,lastc-1);     qsort1(v,lastc+1,right); } void swap(char *v[],int i,int j) {     char *temp;      temp = v[i];     v[i] = v[j];     v[j] = temp; }", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "编译之前，我放在#2楼的修正说明，int i=0；那里你改过了吗？#include<stdio.h> //#include<string.h>  int main() {     char str[1024][64]={0},tmp[64]={0};     int  i=0,j,k;     while(gets(str[i++])!=NULL);//ctrl+z 结束输入     for(j=0;j<i-1;j++)         for(k=0;k<i-j-1;k++)             if(strcmp(str[k],str[k+1])>0){                strcpy(tmp,str[k]);                strcpy(str[k],str[k+1]);                strcpy(str[k+1],tmp);             }     for(j=0;j<i;j++) puts(str[j]);     system(\"pause\");     return 0; }   //zwtr //fhoenf //hefe //afe geg^Z  //afe geg //fhoenf //hefe //zwtr //请按任意键继续. . .", "referer": "user-0"}]}
{"question": "谁能帮我写个C语言程序结解决一下，谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <ctype.h> #include <stdlib.h> #define NUMBER '0' #define N 10  //输入浮点数个数  int main(void) {     int i,c,getfloat(char *);     float tmp,a[N], *s,*p = a;     char b[100];      i=0;     printf(\"请输入10个浮点数(空格或回车符分隔): \\n\");     while (i < N && (c = getfloat(b)))     {         if (c == NUMBER)         {             *p++ = atof(b);             i++;         }         else if ((c == '\\n' || c == EOF) && i < N)             printf(\"已输入%d个数, 请继续输入%d个数: \",                    i, N - i);         else         {             printf(\"error: 请输入浮点数.\");             exit(1);         }     }     for (p = a + i - 1; p > a; p--)         for (s = a; s <= p - 1; s++)             if (abs(*s) < abs(*(s + 1)))             {                 tmp = *s;                 *s = *(s + 1);                 *(s + 1) = tmp;             }     for (p = a; p < a + i; p++)         printf(\"%2.2f \", *p);      return 0; }  int getfloat(char *s) {     int c;     static int lastc = 0;      if (lastc == 0)         c = getchar();     else     {         c = lastc;         lastc = 0;     }     while (isspace(s[0] = c) && c != '\\n' && c != EOF)         c = getchar();     s[1] = '\\0';     if (isdigit(c) || c == '-' || c == '.')     {         while (isdigit(*++s = c = getchar()) || c == '-' || c == '.')             ;         *s = '\\0';         lastc = c;         return NUMBER;     }     return c; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h> #include <math.h>  #define N 10  int main(){     float *p;          p=(float *)malloc(sizeof(float)*N);          for(int i=0;i<N;i++)     {       scanf(\"%f\",p+i);      }          float tmp;     for(int i=0;i<N-1;i++)     {         for(int j=i;j<N;j++)         {             if(fabs(*(p+i)) < fabs(*(p+j)))              {                 tmp=*(p+i);                 *(p+i)=*(p+j);                 *(p+j)=tmp;              }         }     }          for(int i=0;i<N;i++)     {         printf(\"%.2f\\n\",*(p+i) );     }          return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 浪客的回复:大概这样子。  float a[10],*p,tmp; p=a; for(int i=0;i<9;i++) {   for(int j=1;j<10;j++)   {     if(abs(*(p+i))<abs(*(p+j)))     {       tmp=*(p+i);*(p+i)=*(p+j);*(p+j)=tmp;     }   } }   能写个完整的程序吗，有点不能理解，希望写个完整的程序，谢谢！", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "大概这样子。  float a[10],*p,tmp; p=a; for(int i=0;i<9;i++) {   for(int j=1;j<10;j++)   {     if(abs(*(p+i))<abs(*(p+j)))     {       tmp=*(p+i);*(p+i)=*(p+j);*(p+j)=tmp;     }   } }", "referer": "user-0"}]}
{"question": "函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考对照：#include<stdio.h>  int isprime(int a) {     int i;     if(a<=3)return a>1;     for(i=2;i*i<=a;i++)     {         if(a%i==0)return 0;     }     return 1; }  int outprime(int z) {      int j,cnt=0;      for(j=2;j<z;j++)      {          if(isprime(j))          {             printf(\"%4d\",j);             cnt++;             if(cnt%6==0)printf(\"\\n\");          }      } }  int main() {      int t;      printf(\"请输入你想要求哪一个数范围内的质数:\");      scanf(\"%d\",&t);      outprime(t);            return 0; } 哇塞，感谢感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考对照：#include<stdio.h>  int isprime(int a) {     int i;     if(a<=3)return a>1;     for(i=2;i*i<=a;i++)     {         if(a%i==0)return 0;     }     return 1; }  int outprime(int z) {      int j,cnt=0;      for(j=2;j<z;j++)      {          if(isprime(j))          {             printf(\"%4d\",j);             cnt++;             if(cnt%6==0)printf(\"\\n\");          }      } }  int main() {      int t;      printf(\"请输入你想要求哪一个数范围内的质数:\");      scanf(\"%d\",&t);      outprime(t);            return 0; }", "referer": "user-0"}]}
{"question": "急急急，", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 阿麦的回复:存在 x !=y, 但f(x)=f(y)，就不存在反函数，否则存在反函数  大概是这个代码，没验证，意思到了。  const int N=100; int main() {     int cnt[N]={0};     bool Yes=True;     for(int x=0;x<n;x++) {         cnt[f(x)]++;     }     for(int x=0; x <n && Yes; x++) {         Yes = cnt[x] < 2;     }     // Yes 为 True 就是存在反函数，否则不存在     return 0; } 谢谢大哥 牛逼", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "存在 x !=y, 但f(x)=f(y)，就不存在反函数，否则存在反函数  大概是这个代码，没验证，意思到了。  const int N=100; int main() {     int cnt[N]={0};     bool Yes=True;     for(int x=0;x<n;x++) {         cnt[f(x)]++;     }     for(int x=0; x <n && Yes; x++) {         Yes = cnt[x] < 2;     }     // Yes 为 True 就是存在反函数，否则不存在     return 0; }", "referer": "user-0"}]}
{"question": "Char变量输入一个大于127的值，返回的结果问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "计算机底层是以二进制补码形式存储的，取数时会还原成原码，char占1字节，也就是8位，最高位为符号位，把197转成二进制就是11000101，而正数的原码反码补码都是一样的，但因为这里最高位为1，机器会把他当做负数，把它转换为原码之后就是-59了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 10 楼 均陵鼠侠的回复:[quote=引用 6 楼 拜你所赐 的回复:][quote=引用 5 楼 均陵鼠侠 的回复:][quote=引用 4 楼 拜你所赐 的回复:][quote=引用 3 楼 均陵鼠侠 的回复:]这是一个简单而又复杂的问题。  首先， %c 和 %d 都要求对应的变参是 int 类型。唯一不同的是，%c 是将这个 int 类型的变参转换为 unsigned char 类型的字符，然后予以显示，而 %d 则是将它转换为有符号十进制格式的数字字符予以显示。  其次，程序是没有问题的。尽管传入的变参是 char 类型的，但依照默认实参转换（default argument conversion）的规则，它是被转换为 int 类型之后传递给 printf 的。  最后，对于 printf 来说， %c 是将传入的值按 int 类型（的长度）取出，然后转换（缩小）为 unsigned char 类型（的长度），将它视为字符编码，然后打印这个字符； %d 是将传入的值按 int 类型（的长度）取出，拆分数位并转换为有符号十进制数字字符打印输出。这里的关键是， %d 要求这个转换过程必须区分数值的正负。这很好办，只需要判断其二进制形式的最高位（符号位）就可以了：为0是正数，为1是负数。然而，在197和198这两个数值的二进制形式中，符号位似乎并不是1。这就回到了开始：在将 char 类型的值转换为 int 类型并传递给 printf 时，是如何转换的？再往前，两个常量197和198的类型都是 int ，将它们赋给变量 c1 和 c2 时，需要从 int 转换为 char ，这个转换过程又是怎样的？  这就涉及到数值转换规则。首先，将一个整数类型的值转换为另一个除_Bool之外的整数类型时，如果这个值能够用新类型来表示，则转换后的值不变。  来看 char c1, c2; c1 = 197; c2 = 198;  在这里，如果 char 等价于 unsigned char ，那么，在主流的机器上，它可以表示的数值范围是 0到255，所以能够容纳，且 printf 不可能打印两个负值。显然，在楼主的环境下，char实际上是signed char。在主流的机器上，它可以表示的数值范围是-127到+128，故无法表示 197 和 198 ，需要转换。  但是，如果新类型是有符号的并且无法表示这个值，转换的结果要依赖于具体的编译器，甚至可能触发信号机制。即，C语言没有规定如何转换。  在很多平台上（显然包括楼主所在的机器环境），是直接把长度为 int 的 197 截断为 char 类型的长度。所以，最终它表示有符号数-59。   您好，非常感谢您的回复，我使用的编译器是VS2012。我是一个C语言的初学者，我对您的回复还有一些疑问，在您的回复中说到“在197和198这两个数值的二进制形式中，符号位似乎并不是1。”197 -->11000101      198  -->  11000110    直接转化成二进制的首位是否会直接成为符号位呢？烦请您帮忙把197到-59的过程详细说一下吗？[/quote]  对，我这两句话没说明白。  赋给 c1 和 c2 的值来自于常量 197 和 198 ，这两个常量的类型是 int 。所以，它们的最高位不是1，而是0。即，如果 int 类型的长度是 32 位，则 197 的二进制形式为 00000000000000000000000011000101 。把它截断为 char 类型的长度时，如果 char 类型的长度是 8，则截断后是 11000101 。[/quote]十分感谢您的解答，还有一个问题我没有搞明白，例如197.对于截断后的二进制11000101。它的最高位是1，即后面表示数值的二进制是“1000101”，转变成二进制之后为69。但是取其补码之后即为“0111010”它的十进制是“58”。截断之后为什么不是直接输出它的十进制而是取其补码呢？这点我有点搞不明白。[/quote] 对机器来说，截断之后，如果最高位是1，即表明它是一个负数，而负数本身就是采用补码的，不需要也不会再次转换为补码。要么是你把机器想得太复杂了，要么是一些不正确的说法影响了你的思维。  另一方面，负数有三种表示方法：符号带大小、对1的补码和对2的补码，C语言并没有限定采用哪种表示方法，这个取决于平台和编译器，只不过对2的补码是普遍的情况。无论采用哪种表示方法，从编程和运行的层面上基本上看不到，也不需要过问，毕竟它不影响输出和结果的正确性。所以，说负数采用补码，眼光过于局限了。[/quote] 谢谢老师，看了老师的回复才豁然开朗，钻了牛角尖，把机器想的太过于复杂了，十分感谢老师的解答！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 6 楼 拜你所赐 的回复:[quote=引用 5 楼 均陵鼠侠 的回复:][quote=引用 4 楼 拜你所赐 的回复:][quote=引用 3 楼 均陵鼠侠 的回复:]这是一个简单而又复杂的问题。  首先， %c 和 %d 都要求对应的变参是 int 类型。唯一不同的是，%c 是将这个 int 类型的变参转换为 unsigned char 类型的字符，然后予以显示，而 %d 则是将它转换为有符号十进制格式的数字字符予以显示。  其次，程序是没有问题的。尽管传入的变参是 char 类型的，但依照默认实参转换（default argument conversion）的规则，它是被转换为 int 类型之后传递给 printf 的。  最后，对于 printf 来说， %c 是将传入的值按 int 类型（的长度）取出，然后转换（缩小）为 unsigned char 类型（的长度），将它视为字符编码，然后打印这个字符； %d 是将传入的值按 int 类型（的长度）取出，拆分数位并转换为有符号十进制数字字符打印输出。这里的关键是， %d 要求这个转换过程必须区分数值的正负。这很好办，只需要判断其二进制形式的最高位（符号位）就可以了：为0是正数，为1是负数。然而，在197和198这两个数值的二进制形式中，符号位似乎并不是1。这就回到了开始：在将 char 类型的值转换为 int 类型并传递给 printf 时，是如何转换的？再往前，两个常量197和198的类型都是 int ，将它们赋给变量 c1 和 c2 时，需要从 int 转换为 char ，这个转换过程又是怎样的？  这就涉及到数值转换规则。首先，将一个整数类型的值转换为另一个除_Bool之外的整数类型时，如果这个值能够用新类型来表示，则转换后的值不变。  来看 char c1, c2; c1 = 197; c2 = 198;  在这里，如果 char 等价于 unsigned char ，那么，在主流的机器上，它可以表示的数值范围是 0到255，所以能够容纳，且 printf 不可能打印两个负值。显然，在楼主的环境下，char实际上是signed char。在主流的机器上，它可以表示的数值范围是-127到+128，故无法表示 197 和 198 ，需要转换。  但是，如果新类型是有符号的并且无法表示这个值，转换的结果要依赖于具体的编译器，甚至可能触发信号机制。即，C语言没有规定如何转换。  在很多平台上（显然包括楼主所在的机器环境），是直接把长度为 int 的 197 截断为 char 类型的长度。所以，最终它表示有符号数-59。   您好，非常感谢您的回复，我使用的编译器是VS2012。我是一个C语言的初学者，我对您的回复还有一些疑问，在您的回复中说到“在197和198这两个数值的二进制形式中，符号位似乎并不是1。”197 -->11000101      198  -->  11000110    直接转化成二进制的首位是否会直接成为符号位呢？烦请您帮忙把197到-59的过程详细说一下吗？[/quote]  对，我这两句话没说明白。  赋给 c1 和 c2 的值来自于常量 197 和 198 ，这两个常量的类型是 int 。所以，它们的最高位不是1，而是0。即，如果 int 类型的长度是 32 位，则 197 的二进制形式为 00000000000000000000000011000101 。把它截断为 char 类型的长度时，如果 char 类型的长度是 8，则截断后是 11000101 。[/quote]十分感谢您的解答，还有一个问题我没有搞明白，例如197.对于截断后的二进制11000101。它的最高位是1，即后面表示数值的二进制是“1000101”，转变成二进制之后为69。但是取其补码之后即为“0111010”它的十进制是“58”。截断之后为什么不是直接输出它的十进制而是取其补码呢？这点我有点搞不明白。[/quote] 对机器来说，截断之后，如果最高位是1，即表明它是一个负数，而负数本身就是采用补码的，不需要也不会再次转换为补码。要么是你把机器想得太复杂了，要么是一些不正确的说法影响了你的思维。  另一方面，负数有三种表示方法：符号带大小、对1的补码和对2的补码，C语言并没有限定采用哪种表示方法，这个取决于平台和编译器，只不过对2的补码是普遍的情况。无论采用哪种表示方法，从编程和运行的层面上基本上看不到，也不需要过问，毕竟它不影响输出和结果的正确性。所以，说负数采用补码，眼光过于局限了。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "数值197是int类型, 赋值于char类型c1, 高位将被截去,即为11000101  当输出格式为%c: 按C定义:字符输出不会是负值, 所以结果为\"?\"; 当输出格式为%d: char类型变量如果没有加限定符(signed/unsigned),由机器本身规则确定是按符号数或无符号数处理.  就楼主例子, 由于对c1/c2没有用限定符,楼主机器是按符号数输出的.", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "计算机是按补码来存储的，所以截断后的11000101是补码，其中最高位的1是符号为表示是负数，后7位补码1000101转为原码是0111011，十进制是59，所以就是-59", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-5 的回复:百度“负数、补码” %c问号的原因是因为找不到对应的ASCII字符 我知道%c是找不到字符  就是不是很理解他那个%d输出的原理", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 5 楼 均陵鼠侠 的回复:[quote=引用 4 楼 拜你所赐 的回复:][quote=引用 3 楼 均陵鼠侠 的回复:]这是一个简单而又复杂的问题。  首先， %c 和 %d 都要求对应的变参是 int 类型。唯一不同的是，%c 是将这个 int 类型的变参转换为 unsigned char 类型的字符，然后予以显示，而 %d 则是将它转换为有符号十进制格式的数字字符予以显示。  其次，程序是没有问题的。尽管传入的变参是 char 类型的，但依照默认实参转换（default argument conversion）的规则，它是被转换为 int 类型之后传递给 printf 的。  最后，对于 printf 来说， %c 是将传入的值按 int 类型（的长度）取出，然后转换（缩小）为 unsigned char 类型（的长度），将它视为字符编码，然后打印这个字符； %d 是将传入的值按 int 类型（的长度）取出，拆分数位并转换为有符号十进制数字字符打印输出。这里的关键是， %d 要求这个转换过程必须区分数值的正负。这很好办，只需要判断其二进制形式的最高位（符号位）就可以了：为0是正数，为1是负数。然而，在197和198这两个数值的二进制形式中，符号位似乎并不是1。这就回到了开始：在将 char 类型的值转换为 int 类型并传递给 printf 时，是如何转换的？再往前，两个常量197和198的类型都是 int ，将它们赋给变量 c1 和 c2 时，需要从 int 转换为 char ，这个转换过程又是怎样的？  这就涉及到数值转换规则。首先，将一个整数类型的值转换为另一个除_Bool之外的整数类型时，如果这个值能够用新类型来表示，则转换后的值不变。  来看 char c1, c2; c1 = 197; c2 = 198;  在这里，如果 char 等价于 unsigned char ，那么，在主流的机器上，它可以表示的数值范围是 0到255，所以能够容纳，且 printf 不可能打印两个负值。显然，在楼主的环境下，char实际上是signed char。在主流的机器上，它可以表示的数值范围是-127到+128，故无法表示 197 和 198 ，需要转换。  但是，如果新类型是有符号的并且无法表示这个值，转换的结果要依赖于具体的编译器，甚至可能触发信号机制。即，C语言没有规定如何转换。  在很多平台上（显然包括楼主所在的机器环境），是直接把长度为 int 的 197 截断为 char 类型的长度。所以，最终它表示有符号数-59。   您好，非常感谢您的回复，我使用的编译器是VS2012。我是一个C语言的初学者，我对您的回复还有一些疑问，在您的回复中说到“在197和198这两个数值的二进制形式中，符号位似乎并不是1。”197 -->11000101      198  -->  11000110    直接转化成二进制的首位是否会直接成为符号位呢？烦请您帮忙把197到-59的过程详细说一下吗？[/quote]  对，我这两句话没说明白。  赋给 c1 和 c2 的值来自于常量 197 和 198 ，这两个常量的类型是 int 。所以，它们的最高位不是1，而是0。即，如果 int 类型的长度是 32 位，则 197 的二进制形式为 00000000000000000000000011000101 。把它截断为 char 类型的长度时，如果 char 类型的长度是 8，则截断后是 11000101 。[/quote]十分感谢您的解答，还有一个问题我没有搞明白，例如197.对于截断后的二进制11000101。它的最高位是1，即后面表示数值的二进制是“1000101”，转变成二进制之后为69。但是取其补码之后即为“0111010”它的十进制是“58”。截断之后为什么不是直接输出它的十进制而是取其补码呢？这点我有点搞不明白。", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "百度“负数、补码” %c问号的原因是因为找不到对应的ASCII字符", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "引用 4 楼 拜你所赐 的回复:[quote=引用 3 楼 均陵鼠侠 的回复:]这是一个简单而又复杂的问题。  首先， %c 和 %d 都要求对应的变参是 int 类型。唯一不同的是，%c 是将这个 int 类型的变参转换为 unsigned char 类型的字符，然后予以显示，而 %d 则是将它转换为有符号十进制格式的数字字符予以显示。  其次，程序是没有问题的。尽管传入的变参是 char 类型的，但依照默认实参转换（default argument conversion）的规则，它是被转换为 int 类型之后传递给 printf 的。  最后，对于 printf 来说， %c 是将传入的值按 int 类型（的长度）取出，然后转换（缩小）为 unsigned char 类型（的长度），将它视为字符编码，然后打印这个字符； %d 是将传入的值按 int 类型（的长度）取出，拆分数位并转换为有符号十进制数字字符打印输出。这里的关键是， %d 要求这个转换过程必须区分数值的正负。这很好办，只需要判断其二进制形式的最高位（符号位）就可以了：为0是正数，为1是负数。然而，在197和198这两个数值的二进制形式中，符号位似乎并不是1。这就回到了开始：在将 char 类型的值转换为 int 类型并传递给 printf 时，是如何转换的？再往前，两个常量197和198的类型都是 int ，将它们赋给变量 c1 和 c2 时，需要从 int 转换为 char ，这个转换过程又是怎样的？  这就涉及到数值转换规则。首先，将一个整数类型的值转换为另一个除_Bool之外的整数类型时，如果这个值能够用新类型来表示，则转换后的值不变。  来看 char c1, c2; c1 = 197; c2 = 198;  在这里，如果 char 等价于 unsigned char ，那么，在主流的机器上，它可以表示的数值范围是 0到255，所以能够容纳，且 printf 不可能打印两个负值。显然，在楼主的环境下，char实际上是signed char。在主流的机器上，它可以表示的数值范围是-127到+128，故无法表示 197 和 198 ，需要转换。  但是，如果新类型是有符号的并且无法表示这个值，转换的结果要依赖于具体的编译器，甚至可能触发信号机制。即，C语言没有规定如何转换。  在很多平台上（显然包括楼主所在的机器环境），是直接把长度为 int 的 197 截断为 char 类型的长度。所以，最终它表示有符号数-59。   您好，非常感谢您的回复，我使用的编译器是VS2012。我是一个C语言的初学者，我对您的回复还有一些疑问，在您的回复中说到“在197和198这两个数值的二进制形式中，符号位似乎并不是1。”197 -->11000101      198  -->  11000110    直接转化成二进制的首位是否会直接成为符号位呢？烦请您帮忙把197到-59的过程详细说一下吗？[/quote]  对，我这两句话没说明白。  赋给 c1 和 c2 的值来自于常量 197 和 198 ，这两个常量的类型是 int 。所以，它们的最高位不是1，而是0。即，如果 int 类型的长度是 32 位，则 197 的二进制形式为 00000000000000000000000011000101 。把它截断为 char 类型的长度时，如果 char 类型的长度是 8，则截断后是 11000101 。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 3 楼 均陵鼠侠 的回复:这是一个简单而又复杂的问题。  首先， %c 和 %d 都要求对应的变参是 int 类型。唯一不同的是，%c 是将这个 int 类型的变参转换为 unsigned char 类型的字符，然后予以显示，而 %d 则是将它转换为有符号十进制格式的数字字符予以显示。  其次，程序是没有问题的。尽管传入的变参是 char 类型的，但依照默认实参转换（default argument conversion）的规则，它是被转换为 int 类型之后传递给 printf 的。  最后，对于 printf 来说， %c 是将传入的值按 int 类型（的长度）取出，然后转换（缩小）为 unsigned char 类型（的长度），将它视为字符编码，然后打印这个字符； %d 是将传入的值按 int 类型（的长度）取出，拆分数位并转换为有符号十进制数字字符打印输出。这里的关键是， %d 要求这个转换过程必须区分数值的正负。这很好办，只需要判断其二进制形式的最高位（符号位）就可以了：为0是正数，为1是负数。然而，在197和198这两个数值的二进制形式中，符号位似乎并不是1。这就回到了开始：在将 char 类型的值转换为 int 类型并传递给 printf 时，是如何转换的？再往前，两个常量197和198的类型都是 int ，将它们赋给变量 c1 和 c2 时，需要从 int 转换为 char ，这个转换过程又是怎样的？  这就涉及到数值转换规则。首先，将一个整数类型的值转换为另一个除_Bool之外的整数类型时，如果这个值能够用新类型来表示，则转换后的值不变。  来看 char c1, c2; c1 = 197; c2 = 198;  在这里，如果 char 等价于 unsigned char ，那么，在主流的机器上，它可以表示的数值范围是 0到255，所以能够容纳，且 printf 不可能打印两个负值。显然，在楼主的环境下，char实际上是signed char。在主流的机器上，它可以表示的数值范围是-127到+128，故无法表示 197 和 198 ，需要转换。  但是，如果新类型是有符号的并且无法表示这个值，转换的结果要依赖于具体的编译器，甚至可能触发信号机制。即，C语言没有规定如何转换。  在很多平台上（显然包括楼主所在的机器环境），是直接把长度为 int 的 197 截断为 char 类型的长度。所以，最终它表示有符号数-59。   您好，非常感谢您的回复，我使用的编译器是VS2012。我是一个C语言的初学者，我对您的回复还有一些疑问，在您的回复中说到“在197和198这两个数值的二进制形式中，符号位似乎并不是1。”197 -->11000101      198  -->  11000110    直接转化成二进制的首位是否会直接成为符号位呢？烦请您帮忙把197到-59的过程详细说一下吗？", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "这是一个简单而又复杂的问题。  首先， %c 和 %d 都要求对应的变参是 int 类型。唯一不同的是，%c 是将这个 int 类型的变参转换为 unsigned char 类型的字符，然后予以显示，而 %d 则是将它转换为有符号十进制格式的数字字符予以显示。  其次，程序是没有问题的。尽管传入的变参是 char 类型的，但依照默认实参转换（default argument conversion）的规则，它是被转换为 int 类型之后传递给 printf 的。  最后，对于 printf 来说， %c 是将传入的值按 int 类型（的长度）取出，然后转换（缩小）为 unsigned char 类型（的长度），将它视为字符编码，然后打印这个字符； %d 是将传入的值按 int 类型（的长度）取出，拆分数位并转换为有符号十进制数字字符打印输出。这里的关键是， %d 要求这个转换过程必须区分数值的正负。这很好办，只需要判断其二进制形式的最高位（符号位）就可以了：为0是正数，为1是负数。然而，在197和198这两个数值的二进制形式中，符号位似乎并不是1。这就回到了开始：在将 char 类型的值转换为 int 类型并传递给 printf 时，是如何转换的？再往前，两个常量197和198的类型都是 int ，将它们赋给变量 c1 和 c2 时，需要从 int 转换为 char ，这个转换过程又是怎样的？  这就涉及到数值转换规则。首先，将一个整数类型的值转换为另一个除_Bool之外的整数类型时，如果这个值能够用新类型来表示，则转换后的值不变。  来看 char c1, c2; c1 = 197; c2 = 198;  在这里，如果 char 等价于 unsigned char ，那么，在主流的机器上，它可以表示的数值范围是 0到255，所以能够容纳，且 printf 不可能打印两个负值。显然，在楼主的环境下，char实际上是signed char。在主流的机器上，它可以表示的数值范围是-127到+128，故无法表示 197 和 198 ，需要转换。  但是，如果新类型是有符号的并且无法表示这个值，转换的结果要依赖于具体的编译器，甚至可能触发信号机制。即，C语言没有规定如何转换。  在很多平台上（显然包括楼主所在的机器环境），是直接把长度为 int 的 197 截断为 char 类型的长度。所以，最终它表示有符号数-59。", "referer": "user-0"}]}
{"question": "大佬来看看这个代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：//用筛法求N之内的素数  #include<stdio.h> int main() { \tint n; \tbool prime[1000]; \tfor(int i=0;i<1000;i++) \t{ \t\tprime[i]=0;//假设所有数都是素数 \t} \tscanf(\"%d\",&n); \tfor(int i=2;i<=n;i++) \t{ \t\tif(prime[i]==0)//每次将一个素数的所有倍数标记为非素数 \t\t{ \t\t\tfor(int j=i*2;j<=n;j=j+i)//从二倍开始标记素数的倍数为非素数 \t\t\t{ \t\t\t\tprime[j]=1; \t\t\t} \t\t} \t} \tfor(int i=2;i<=n;i++) \t{ \t\tif(prime[i]==0)printf(\"%d\\n\",i); \t}     //system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "看不懂", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include<stdio.h> void main() {     int m,n;      scanf(\"%d%d\",&m,&n);     for (int j, i = m; i <= n; i++)     {          for (j = 2; j  < i; j++)         {             if (i % j == 0)                 break;         }         if(j==i)printf(\"%d \",i);     } }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "搞错了，代码是这个： #include <stdio.h> #include <stdlib.h> #define N 100 void Siftprime(int a[], int n); void DoublePrime(int a[],int n);  //筛法求素数 void Siftprime(int a[], int n) { \tint i,j; \tfor (i=2;i<=n;i++) \t{ \t\ta[i]=i; \t} \tfor (i=2;i<=n;i++) \t{ \t\tfor (j=i+1;j<n;j++) \t\t{ \t\t\tif (a[i]!=0&&a[j]!=0&&a[j]%a[i]==0) \t\t\t\ta[j]=0; \t\t} \t} }  void DoublePrime(int a[],int n) { \tint i; \tfor (i=3;i<n;i++) \t{ \t\tif (a[i]!=0&&a[i+2]!=0) \t\t\tprintf(\"%4d/%d\",i,i+2); \t} }  int main() { \tint a[N+1]; \tSiftprime(a,N); \tDoublePrime(a,N); \treturn 0; }", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "随机必然有重复，所谓“不重复的随机”实际上是洗牌。洗牌算法参考下面： #include <stdio.h> #include <stdlib.h> #include <time.h> int d[6]; int i,n,a,b,t; int c,j; void main() {     srand(time(NULL));     printf(\"shuffle 0..n-1 demo\\n\");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf(\"_____n=%d_____\\n\",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=0;i<n;i++) d[i]=i;/* 填写0～n-1 */             for (i=n;i>0;i--) {/* 打乱0～n-1 */                 a=i-1;b=rand()%i;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf(\"%04d:\",c);             for (i=0;i<n;i++) printf(\"%d\",d[i]);             printf(\"\\n\");         }     }     printf(\"shuffle 1..n demo\\n\");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf(\"_____n=%d_____\\n\",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=1;i<=n;i++) d[i]=i;/* 填写1～n */             for (i=n;i>1;i--) {/* 打乱1～n */                 a=i;b=rand()%i+1;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf(\"%04d:\",c);             for (i=1;i<=n;i++) printf(\"%d\",d[i]);             printf(\"\\n\");         }     } }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "大概这样子吧   #include <stdbool.h>  //引入bool类型  bool chachong(int *arr, int index, size_t n) { \tif (!index || !n)   //忽略0值和第一个值 \t{ \t\treturn true; \t}  \twhile (n) //从数组中找重复的值 \t{ \t\tif (arr[n - 1] == index) \t\t{ \t\t\treturn true; \t\t} \t\tn--; \t}  \treturn false; }  //////////////// int arr[13] = {0}; size_t i=0; while (i < 13) { \tdo \t{ \t\tarr[i] = rand() % 55; \t} while (chachong(arr, arr[i], i)); \t \ti++; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "随机打乱顺序后直接给前面的即可", "referer": "user-0"}]}
{"question": "这不就正常的解法吗？为什么总是部分正确。找了好久不知道哪里错了，大佬看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:strcmp不是比较地址值的大小，而是比较地址内数据的大小～ 兄弟，谢了，总以为数组和指针都是一个东西", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "strcmp不是比较地址值的大小，而是比较地址内数据的大小～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "int mystrcmp(const char *a, const char *b) {     assert(a && b);       while (*a && *b) {         if (*a > *b)             return 1;         if (*a < *b)             return -1;         a++, b++;     }      if (*a == 0 && *b == 0)   //0即'\\0'         return 0;     if (*a == '\\0')         return -1;     if (*b == '\\0')         return 1;      return 0;  }  供参考～", "referer": "user-0"}]}
{"question": "求助贴", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "参见eigen。", "referer": "user-0"}]}
{"question": "C语言数组处理", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "非常不错的解答", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 10 楼 lin5161678 的回复:[quote=引用 9 楼 自信男孩 的回复:][quote=引用 8 楼 lin5161678 的回复:]错的就只是 vla长度是0 并且越界 这两点 和指针没有任何关系  理解不一样～[/quote] 那就是你理解错了[/quote] 把数组理解为指针有错吗（当然数组和指针还是有区别的）？数组名除了不能做左值外，还有其他的区别吗？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 9 楼 自信男孩 的回复:[quote=引用 8 楼 lin5161678 的回复:]错的就只是 vla长度是0 并且越界 这两点 和指针没有任何关系  理解不一样～[/quote] 那就是你理解错了", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 8 楼 lin5161678 的回复:[quote=引用 7 楼 自信男孩 的回复:][quote=引用 6 楼 lin5161678 的回复:][quote=引用 3 楼 自信男孩 的回复:]a数组的长度需要事先定义好，C语言不支持可变数组长度的。C支持 这里错的不是用变了定义数组大小 这里错的是越界 并且数组大小是0 [/quote] 这里定义的其实就是一个指针，还是一个野指针。对于野指针的使用结果是未定义的。  可变数组可能描述的有歧义，这个在C语言里应该怎么描述呢？应该描述成：不定长数组；当然这里也不是不定长的，而是指定义了一个长度不足的（或者直接理解为一个野指针或许更好）[/quote]错的就只是 vla长度是0 并且越界 这两点 和指针没有任何关系[/quote]  理解不一样～", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 7 楼 自信男孩 的回复:[quote=引用 6 楼 lin5161678 的回复:][quote=引用 3 楼 自信男孩 的回复:]a数组的长度需要事先定义好，C语言不支持可变数组长度的。C支持 这里错的不是用变了定义数组大小 这里错的是越界 并且数组大小是0 [/quote] 这里定义的其实就是一个指针，还是一个野指针。对于野指针的使用结果是未定义的。  可变数组可能描述的有歧义，这个在C语言里应该怎么描述呢？应该描述成：不定长数组；当然这里也不是不定长的，而是指定义了一个长度不足的（或者直接理解为一个野指针或许更好）[/quote]错的就只是 vla长度是0 并且越界 这两点 和指针没有任何关系", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "引用 6 楼 lin5161678 的回复:[quote=引用 3 楼 自信男孩 的回复:]a数组的长度需要事先定义好，C语言不支持可变数组长度的。C支持 这里错的不是用变了定义数组大小 这里错的是越界 并且数组大小是0 [/quote] 这里定义的其实就是一个指针，还是一个野指针。对于野指针的使用结果是未定义的。  可变数组可能描述的有歧义，这个在C语言里应该怎么描述呢？应该描述成：不定长数组；当然这里也不是不定长的，而是指定义了一个长度不足的（或者直接理解为一个野指针或许更好）", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "引用 3 楼 自信男孩 的回复:a数组的长度需要事先定义好，C语言不支持可变数组长度的。C支持 这里错的不是用变了定义数组大小 这里错的是越界 并且数组大小是0", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "引用 30 楼 lin5161678 的回复:[quote=引用 27 楼 自信男孩 的回复:]  你解析的通透，能被别人理解吗？你通透了，那是你的，不能给别人。在论坛里是帮助别人解决问题，不是炫耀你理解的通透了。 愿意思考当然能够理解 请问 数组类型在特定情况下会隐式转换为指向数组第一个元素的指针 而不是数组是指针 这句话 哪一个字不理解? 没有先入为主并且放弃思考的人 都能理解这句话[/quote] 我真没说过数组就是指针吧，如果说了，那我确实说错了，我道歉，向楼主和看到的帖子的朋友们道歉：我传播了错误的论点。", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "引用 32 楼 均陵鼠侠 的回复:[quote=引用 28 楼 自信男孩 的回复:][quote=引用 25 楼 均陵鼠侠 的回复:]我的发言看起来象是在吵架吗？这是从哪里看出来的。我本不想参与这个讨论，但是看到小林同学在场，所以也掺和一下。如果觉得我是在吵架，我就不说话了，反正CSDN我很少来，就是隔一段时间来瞅瞅。我又不拿CSDN的好处，没必要在这里为一些非常简单的话题浪费时间。 代码写出来是让别人看的，不是炫耀的。写出对的，但是别人不容易理解的代码，意义仅限于自己的吧，代码的可读性呢？  int g; ( & g) [0] = 5; 对于这样的代码～[/quote]我都不知道说什么好了，你为什么总抓不住重点。我强调的是要引入“整数名”和“浮点名”，而且认为“整数名也是数组，也是指针”，所以举了这样一个例子，你又往代码的可读性上扯。没有可读性就不是代码了？没有可读性就不能运行了？它是不是合法的C语言代码呢？这样唠嗑啥时候才能是个头哇。[/quote] 那就不要唠了，那你还回复啥呀～既然知道没有头，越来越不在楼主的频道上了。嘴上说着没意思唠了，手上还很诚实～", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "引用 28 楼 自信男孩 的回复:[quote=引用 25 楼 均陵鼠侠 的回复:]我的发言看起来象是在吵架吗？这是从哪里看出来的。我本不想参与这个讨论，但是看到小林同学在场，所以也掺和一下。如果觉得我是在吵架，我就不说话了，反正CSDN我很少来，就是隔一段时间来瞅瞅。我又不拿CSDN的好处，没必要在这里为一些非常简单的话题浪费时间。 代码写出来是让别人看的，不是炫耀的。写出对的，但是别人不容易理解的代码，意义仅限于自己的吧，代码的可读性呢？  int g; ( & g) [0] = 5; 对于这样的代码～[/quote]我都不知道说什么好了，你为什么总抓不住重点。我强调的是要引入“整数名”和“浮点名”，而且认为“整数名也是数组，也是指针”，所以举了这样一个例子，你又往代码的可读性上扯。没有可读性就不是代码了？没有可读性就不能运行了？它是不是合法的C语言代码呢？这样唠嗑啥时候才能是个头哇。", "referer": "user-0"}, {"cid": "12", "user": "user-4", "content": "引用 29 楼 均陵鼠侠 的回复:我说小林，我在#24楼的发言难道不好笑吗？为什么不笑？[/quote] 我受过严格的训练  无论有多好笑 我都不会笑 除非忍不住", "referer": "user-0"}, {"cid": "13", "user": "user-4", "content": "引用 27 楼 自信男孩 的回复:你解析的通透，能被别人理解吗？你通透了，那是你的，不能给别人。在论坛里是帮助别人解决问题，不是炫耀你理解的通透了。 愿意思考当然能够理解 请问 数组类型在特定情况下会隐式转换为指向数组第一个元素的指针 而不是数组是指针 这句话 哪一个字不理解? 没有先入为主并且放弃思考的人 都能理解这句话", "referer": "user-0"}, {"cid": "14", "user": "user-5", "content": "引用 26 楼 lin5161678 的回复:[quote=引用 22 楼 自信男孩 的回复:]我说小林，我在#24楼的发言难道不好笑吗？为什么不笑？", "referer": "user-0"}, {"cid": "15", "user": "user-3", "content": "引用 25 楼 均陵鼠侠 的回复:我的发言看起来象是在吵架吗？这是从哪里看出来的。我本不想参与这个讨论，但是看到小林同学在场，所以也掺和一下。如果觉得我是在吵架，我就不说话了，反正CSDN我很少来，就是隔一段时间来瞅瞅。我又不拿CSDN的好处，没必要在这里为一些非常简单的话题浪费时间。 代码写出来是让别人看的，不是炫耀的。写出对的，但是别人不容易理解的代码，意义仅限于自己的吧，代码的可读性呢？  int g; ( & g) [0] = 5; 对于这样的代码～", "referer": "user-0"}, {"cid": "16", "user": "user-3", "content": "引用 26 楼 lin5161678 的回复:[quote=引用 22 楼 自信男孩 的回复:] 好吧，继续这样的沟通没有意义，我一说访问，你就提出char和int的区别，这么说还有struct ,union等等这些类型访问的区别呢，所以，这样的反驳我无话可说。你理解的并不是我理解的，看来这句话在我们的沟通中是成立的。  建议不要总批判的去理解别人的话，能从对方的话语中理解或吸收有用的东西，这样是进步的源泉，上来就反对，如果反对的全对还好说，不全对，我感觉没多少意义，除了能获取自己很厉害的快感，还能干啥？ 你的观点不存在值得吸收的内容 所谓的数组是指针  是一个错误的 对理解C语言毫无帮助 对编程实践毫无价值的说法 并且早就被解析通透并早已被我摒弃  数组隐式转换为指向数组第一个元素 可以解释一切关于数组和指针相关的内容 数组是指针 只会遇到越来越多的困惑 越思考越撕裂 放弃思考才会认为这个解释很合理[/quote] 你的语言里透漏出霸气：  并且早就被解析通透并早已被我摒弃  你解析的通透，能被别人理解吗？你通透了，那是你的，不能给别人。在论坛里是帮助别人解决问题，不是炫耀你理解的通透了。", "referer": "user-0"}, {"cid": "17", "user": "user-4", "content": "引用 22 楼 自信男孩 的回复:好吧，继续这样的沟通没有意义，我一说访问，你就提出char和int的区别，这么说还有struct ,union等等这些类型访问的区别呢，所以，这样的反驳我无话可说。你理解的并不是我理解的，看来这句话在我们的沟通中是成立的。  建议不要总批判的去理解别人的话，能从对方的话语中理解或吸收有用的东西，这样是进步的源泉，上来就反对，如果反对的全对还好说，不全对，我感觉没多少意义，除了能获取自己很厉害的快感，还能干啥？ 你的观点不存在值得吸收的内容 所谓的数组是指针  是一个错误的 对理解C语言毫无帮助 对编程实践毫无价值的说法 并且早就被解析通透并早已被我摒弃  数组隐式转换为指向数组第一个元素 可以解释一切关于数组和指针相关的内容 数组是指针 只会遇到越来越多的困惑 越思考越撕裂 放弃思考才会认为这个解释很合理", "referer": "user-0"}, {"cid": "18", "user": "user-5", "content": "我的发言看起来象是在吵架吗？这是从哪里看出来的。我本不想参与这个讨论，但是看到小林同学在场，所以也掺和一下。如果觉得我是在吵架，我就不说话了，反正CSDN我很少来，就是隔一段时间来瞅瞅。我又不拿CSDN的好处，没必要在这里为一些非常简单的话题浪费时间。", "referer": "user-0"}, {"cid": "19", "user": "user-5", "content": "“因为这么理解了，对于很多的使用，比如访问数组或指针地址的方式；便于更好的使用和运用；”------恰恰相反，就是因为和稀泥，搞不清楚，所以很难使用和运用，更谈不上写出优美、简练的代码。你看看赵4老湿平时写的程序就知道了。他的程序我一次也没有读过，太。。。怎么说呢，太闹心了。  我准备建议WG14引入一批新的术语，叫做“整数名”、“浮点名”。而且，因为以下代码 int g; ( & g) [0] = 5; 可以正常工作，所以我决定下一个结论：整数名在某些条件下等同于数组；在某些条件下也等同于指针。", "referer": "user-0"}, {"cid": "20", "user": "user-3", "content": "引用 21 楼 均陵鼠侠 的回复:[quote=引用 15 楼 自信男孩 的回复:][quote=引用 14 楼 lin5161678 的回复:][quote=引用 11 楼 自信男孩 的回复:] 把数组理解为指针有错吗（当然数组和指针还是有区别的）？数组名除了不能做左值外，还有其他的区别吗？ 首先 数组名是左值表达式 然后 数组理解为指针当然是错的  数组本质是内存中一块连续的内存块 相同类型的元素的集合 指针显然完全另一回事  根本区别 数组是一种聚合类型 指针是一种标量类型 两者是C类型系统完全不同 各自独立的组成部分   (int[10])value //是错的 (int*)value //是对的   sizeof(数组类型)和sizeof(指针类型)有区别  int arr[10]; //&arr 是一个数组指针类型表达式 类型是 int(*)[10] int* p; //&p 是一个二级指针表达式 类型是 int**  等等  两者区别多的是  所谓的数组是指针 完全的是对 数组在特定情况下会隐式转换为指向数组第一个元素的指针 这个规则的误读[/quote]  数组和指针在访问上没有区别的，我认为在一些方面是可以将数组理解为指针，也可以把指针理解为数组，你罗列这么多，咱们关注点不一样呢，你关注区别，我专注类似。为什么要关注类似，因为这么理解了，对于很多的使用，比如访问数组或指针地址的方式；便于更好的使用和运用；  指针和数组如果完全一样，我想也没必要定义两个名称了，这个起码的区别我想我还是能够分辨的吧。 比如数组名作为参数传递，那么形参的处理，编译器是按照指针来处理的，虽然你定义的参数是数组形式；  多方面的看待问题，而不是两个面的去评价一个问题：要么对，要么错；不同场景下，可以有不同的理解；  数组和指针有区别又有相似性；我想这个观点你应该认同吧[/quote]  按照这个观点，发明高级语言是错误的，是不必要的。因为这番言论完全否定了抽象的必要性，而高级语言正是对底层以及低一级层次的逻辑抽象。每种语言都要自圆其说，都有其自洽性和完备性，数据类型必须是层次分明的。  分析C语言程序，自然要站在C语言自身的逻辑圈子里进行，你拿汇编语言层面的事物来解释C语言的东西，已经超越了C语言本身的逻辑。更何况，在机器语言里，哪还有什么数组和指针，都是一连串的字节或者比特。[/quote] 你这么理解也没错，但是这是再讨论问题吗？这是在吵架，说一些看是对的，但是与议题无关的内容，这样你觉得很厉害了？", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for(i=100;i<1000;i++)  ;  ------------- for(i=100;i<1000;i++) 多余的分号", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "10的3次方就1000了", "referer": "user-0"}]}
{"question": "GIS粘贴出大问题！求大神解救！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "Excel中复制的内容粘贴在谷歌阅览器中的特定网址中才会变成相同乱码", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "关闭输入法再试试", "referer": "user-0"}]}
{"question": "关于c语言中布尔形式", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "在C99之前，严格来说，C语言是没有布尔类型的。但是这并不妨碍C语言的工作，以及它和其它语言的接口，毕竟在编程语言里的惯例是0为假，非0为真。问题在于，很多人觉得这是一个和语言完备性有关的瑕疵和缺陷，就好比别人家里煮奶有专用的奶锅，你家里炒菜和煮奶都用同一个铁锅。  在WG14，很多委员都具有C++的背景，这些捣子特别喜欢往C标准里添加C++的玩意儿，但多数不会被标准委员会采纳，因为里面很多都是私货。也就是厂商的代表都希望把自己公司的扩展特性加入到标准里。  也许是起哄的人太多，WG14最终妥协了，决定把布尔类型加入到C语言的下一个标准C99里。理想情况下，这需要引入一个关键字boolean，或者至少是一个好记的bool。但是，在此之前，有很多完美主义的程序员为了图方便，满足自己的语言洁癖，已经在程序中定义了自己的“bool”，而且这样的程序肯定有成千上万。为了能够正常编译这些已有的程序，C99决定引入一个带有下划线的关键字_Bool，这样就很难有冲突了。  关键字_Bool被用作类型指定符，用来声明变量，或者函数的参数和返回类型。这种类型的变量具有以下特点：  1，它是一种无符号整数类型； 2，至少可以保存0和1两个值； 3，将任何标量值转换为_Bool类型时，零值转换为零，非零值转换为1；  C语言规定，除了位域（bit-fields），任何对象（变量）都是由一个或多个连续的字节组成。因此，_Bool类型的长度至少是一个字节。  为了方便，在C语言的标准库部分增加了一个头<stdbool.h>。这个头非常简单，就定义了几个宏：  # define bool\t_Bool  # define true\t1 # define false\t0  # define __bool_true_false_are_defined\t1  最后一个宏__bool_true_false_are_defined是个标记，用于表明前面的三个宏已经定义，可以使用。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 2 楼 淘豚 的回复:[quote=引用 1 楼 自信男孩的回复:]枚举定义的，FALSE=0，TRUE=1；  enum是一个关键字，类似struct，union 在布尔形式c语言中到底起什么作用？[/quote] 它就是一种整型值，真或假；", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:枚举定义的，FALSE=0，TRUE=1；  enum是一个关键字，类似struct，union 在布尔形式c语言中到底起什么作用？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "枚举定义的，FALSE=0，TRUE=1；  enum是一个关键字，类似struct，union", "referer": "user-0"}]}
{"question": "救救孩子吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "怎么理解：int *y=0;  就算是C语言太灵活而不够稳定吧？编译器确实可能把*y和*z按照野指针处理了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #pragma warning(disable:4996) void separate(float x, int* y, float* z); int main() { \tfloat data, z; \tint y; \tprintf(\"从键盘输入一个实型数据：\"); \tscanf(\"%f\", &data); \tseparate(data, &y, &z); \tprintf(\"%d,%f\", y, z); } void separate(float x, int* y, float* z) { \t*y = x; \t*z = x - *y;   }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 6 楼 智者知已应修善业 的回复:  void separate(float x, int *y, float *z) { \t*y = (int)x; \t*z = x - *y; }   \tfloat data, *z = (float*)malloc(1); \tint *y = (int*)malloc(1); \tprintf(\"从键盘输入一个实型数据：\"); \tscanf_s(\"%f\", &data); \tseparate(data, y, z); \tprintf(\"%d,%f\", *y, *z); 误人子弟第一名  你就不能好好看看 malloc的参数是什么意思么 全部传递1哦", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 4 楼 智者知已应修善业 的回复: \tfloat data, *z = (float*)malloc(1); \tint *y = (int*)malloc(1); 错的 新朋友别学", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "void separate(float x, int *y, float *z) { \t*y = (int)x; \t*z = x - *y; }   \tfloat data, *z = (float*)malloc(1); \tint *y = (int*)malloc(1); \tprintf(\"从键盘输入一个实型数据：\"); \tscanf_s(\"%f\", &data); \tseparate(data, y, z); \tprintf(\"%d,%f\", *y, *z);", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "#include <stdio.h>  void separate(float x,int *y,float *z);  //void main () int main (void) {     //float data, *z;     float data, z;     //int *y;     int y;      printf (\"从键盘输入一个实型数据：\");     scanf (\"%f\",&data);     printf(\"%f\\n\", data);     separate (data, &y, &z);     //printf (\"%d,%f\",*y,*z);     printf (\"%d,%f\", y, z); }  void separate(float x,int *y,float *z) {     *y = (int)x;     *z = x - *y; } 供参考～  两个指针都是野指针，需要分配空间，或者直接用普通变量吧", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "float data, *z = (float*)malloc(1); \tint *y = (int*)malloc(1);", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "z和y是指针没有指向数据的空间", "referer": "user-0"}, {"cid": "10", "user": "user-8", "content": "void separate(float x,int *y,float *z); int main() {     float data, z;     int y;     printf (\"从键盘输入一个实型数据：\");     scanf (\"%f\",&data);     separate (data, &y, &z);     printf (\"%d,%f\",y, z); } void separate(float x,int *y,float *z) {      *y = (int)x;     *z = x - *y;  }", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 楼主 栀九lyp的回复: #include <stdio.h> void separate(float x,int *y,float *z); void main () { \tfloat data, *z; \tint *y; \tprintf (\"从键盘输入一个实型数据：\"); \tscanf (\"%f\",&data); \tseparate (data,y,z); \tprintf (\"%d,%f\",*y,*z); } void separate(float x,int *y,float *z) {  \t*y = (int)x; \t*z = x - *y;    } 为什么我这样总是运行不出来", "referer": "user-0"}]}
{"question": "vs写的cpp里中文莫名其妙乱码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://blog.csdn.net/qq_42956179/article/details/106075025", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "原因就是： 比如原来的汉字编码是utf8的； 但被无脑编辑器误当gbk进行了一次gbk到utf8的转换。", "referer": "user-0"}]}
{"question": "有人知道这个怎么写吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:#include <stdio.h> void main() {     int x,y;     int *maxaddress(int *a,int*b);     int *minaddress(int *a,int*b);     void process(int *a,int *b,int *(*fun)(int *a,int *b));     printf(\"从键盘输入两个整数，逗号分隔：\");     scanf(\"%d,%d\",&x,&y);     printf(\"最大地址为：\");     process(&x,&y,maxaddress);     printf(\"最小地址为：\");     process(&x,&y,minaddress); }  int *maxaddress(int *a,int*b) {     if (*a>*b) return a;     else return b; }  int *minaddress(int *a,int*b) {     if (*a<*b) return a;     else return b; }  void process(int *a,int *b,int *(*fun)(int *a,int *b)) {     printf(\"%p\\n\",fun(a,b)); } //从键盘输入两个整数，逗号分隔：1,2 //最大地址为：003FFAA0 //最小地址为：003FFA9C //  谢谢老师指导", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h> void main() {     int x,y;     int *maxaddress(int *a,int*b);     int *minaddress(int *a,int*b);     void process(int *a,int *b,int *(*fun)(int *a,int *b));     printf(\"从键盘输入两个整数，逗号分隔：\");     scanf(\"%d,%d\",&x,&y);     printf(\"最大地址为：\");     process(&x,&y,maxaddress);     printf(\"最小地址为：\");     process(&x,&y,minaddress); }  int *maxaddress(int *a,int*b) {     if (*a>*b) return a;     else return b; }  int *minaddress(int *a,int*b) {     if (*a<*b) return a;     else return b; }  void process(int *a,int *b,int *(*fun)(int *a,int *b)) {     printf(\"%p\\n\",fun(a,b)); } //从键盘输入两个整数，逗号分隔：1,2 //最大地址为：003FFAA0 //最小地址为：003FFA9C //", "referer": "user-0"}]}
{"question": "MinGW合并静态库有没有简单点的办法？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "mkdir libABC cd libABC ar x lib/A.a ar x lib/B.a ar x lib/C.a ar rcs libABC.a *.o", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 楼主 六道佩恩 的回复:目前找到的方法都是ar把.a解开成.o再合并 感觉这样挺麻烦的，有没有更简单的方法 像MSVC的lib合并静态库就好方便  如果实在只能用这种方法的话，怎样让分解的目标文件都集中到一个文件夹？不然ar合并*.o容易把不相关的.o文件合并进来 mkdir libABC cd libABC ar x lib/A.a ar x lib/B.a ar x lib/C.a ar rcu libABC.a *.o ranlib libABC.a //Generate an index to speed access to archives", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 6 楼 六道佩恩 的回复:刚简单测试了下，用lib合并.o为.a是可行的 .o和.obj应该都是符合PE结构的，.a和.lib应该也都是吧，这样看的话，用lib管理应该是可以的吧？ 可以用十六进制编辑器对比一下.a和.lib，看看是否符合PE的格式 就算在Windows下可以用lib来管理，但在Linux下还是要使用ar的方式 另外，在Windows下，也是建议使用先提取obj，再合并，这样可以去除不必要的obj，只选取需要的obj再合并为lib  方法1: lib.exe lib1.lib lib2.lib /out:new.lib   方法12: lib.exe可以把lib文件里的obj文件取出来，然后把这些obj文件重新合并成一个lib文件即可。 步骤如下： 1、列出lib文件中的obj文件      lib lib1.lib /list      lib lib2.lib /list 2、提取出obj文件，大小写一定要和上一步列出的一致      lib lib1.lib /extract:.\\Debug\\lib1.obj /out:lib1.obj      lib lib2.lib /extract:.\\Debug\\lib2.obj /out:lib2.obj 3、合并obj文件到新的lib      lib lib1.obj lib2.obj /out:new.lib", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "程序猿的问题用程序解决嘛，手工能做，仅仅是麻烦的这种事是最适合写代码解决的了。 看哪个工具命令好用就自己仿一个。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 Intel0011 的回复:mkdir libABC cd libABC ar x lib/A.a ar x lib/B.a ar x lib/C.a ar rcs libABC.a *.o 刚简单测试了下，用lib合并.o为.a是可行的 .o和.obj应该都是符合PE结构的，.a和.lib应该也都是吧，这样看的话，用lib管理应该是可以的吧？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 Intel0011 的回复:mkdir libABC cd libABC ar x lib/A.a ar x lib/B.a ar x lib/C.a ar rcs libABC.a *.o 可以问下.o和.lib的区别吗，如果兼容的话，用lib来合并如何？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 3 楼 Intel0011 的回复:mkdir libABC cd libABC ar x lib/A.a ar x lib/B.a ar x lib/C.a ar rcs libABC.a *.o  也就是，没办法更简单的办法或相关工具是吗", "referer": "user-0"}]}
{"question": "整理了62套C需要小游戏源码，送给大家", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "链接怎么进去啊", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "", "referer": "user-0"}]}
{"question": "大佬们帮小白纠下错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "感谢大佬们的回答，我懂了好多", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "对题目理解有问题：题意应该是十个数据，输出九个数据，第一个数据与第二个数据的和，第二个数据与第三个数据的和，。。。 审题要仔细，对题意理解错了、很容易的送分题就错过了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 5 楼 qzjhjxj 的回复:][quote=引用 3 楼 自信男孩 的回复:][quote=引用 1 楼 qzjhjxj 的回复:]供参考：#include<stdio.h>  int main() {     int a[10]={0},b[5]={0},i,j;     for(i=0;i<10;i++)         scanf(\"%d\",&a[i]);     for(i=0,j=0;i<10;i+=2,j++)         b[j]=a[i]+a[i+1];     for(j=0;j<5;j++){         printf(\"%3d\",b[j]);         if((j+1)%3==0||(j+1)==5)printf(\"\\n\");     }          return 0; } for(i=0,j=0;i<10;i+=2,j++)           b[j]=a[i]+a[i+1];  //这个地方应该会越界吧，当i=9时，i+1就是10[/quote]不会出现9，i=i+2,到8就跳出了。 [/quote] 确实，不会，没看你的i+=2，这个相邻元素，理解上有分歧～[/quote]楼主的想法", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "引用 5 楼 qzjhjxj 的回复:[quote=引用 3 楼 自信男孩 的回复:][quote=引用 1 楼 qzjhjxj 的回复:]供参考：#include<stdio.h>  int main() {     int a[10]={0},b[5]={0},i,j;     for(i=0;i<10;i++)         scanf(\"%d\",&a[i]);     for(i=0,j=0;i<10;i+=2,j++)         b[j]=a[i]+a[i+1];     for(j=0;j<5;j++){         printf(\"%3d\",b[j]);         if((j+1)%3==0||(j+1)==5)printf(\"\\n\");     }          return 0; }  for(i=0,j=0;i<10;i+=2,j++)           b[j]=a[i]+a[i+1];  //这个地方应该会越界吧，当i=9时，i+1就是10[/quote]不会出现9，i=i+2,到8就跳出了。 [/quote] 确实，不会，没看你的i+=2，这个相邻元素，理解上有分歧～", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 3 楼 自信男孩 的回复:[quote=引用 1 楼 qzjhjxj 的回复:]供参考：#include<stdio.h>  int main() {     int a[10]={0},b[5]={0},i,j;     for(i=0;i<10;i++)         scanf(\"%d\",&a[i]);     for(i=0,j=0;i<10;i+=2,j++)         b[j]=a[i]+a[i+1];     for(j=0;j<5;j++){         printf(\"%3d\",b[j]);         if((j+1)%3==0||(j+1)==5)printf(\"\\n\");     }          return 0; } for(i=0,j=0;i<10;i+=2,j++)           b[j]=a[i]+a[i+1];  //这个地方应该会越界吧，当i=9时，i+1就是10[/quote]不会出现9，i=i+2,到8就跳出了。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "#include<stdio.h>  #define SIZE    10 int main() {     int a[SIZE], b[SIZE]={0};     int i, j;      for(i = 0; i < SIZE; i++)         scanf(\"%d\", &a[i]);      for (i = 0, j = 0; i < SIZE-1; i++) {         b[j++] = a[i] + a[i+1];     }      for (i = 0; i < j; i++)         printf(\"%d%c\", b[i], (i+1) % 3 ? ' ':'\\n');      /*     for(i=0,j=0;i<10;i+=2,j++)         b[j]=a[i]+a[i+1];     for(j=0;j<5;j++){         printf(\"%3d\",b[j]);         if((j+1)%3==0||(j+1)==5)printf(\"\\n\");     }     */      return 0; } 供参考～  相邻两个元素之和，比如0 1 2 3 4 5 6 7 8 9 ，楼主的理解是0 1， 2 3等等，我的理解是0 1, 1 2, 2 3等等这样的一组，这样也叫相邻两个元素吧", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "引用 1 楼 qzjhjxj 的回复:供参考：#include<stdio.h>  int main() {     int a[10]={0},b[5]={0},i,j;     for(i=0;i<10;i++)         scanf(\"%d\",&a[i]);     for(i=0,j=0;i<10;i+=2,j++)         b[j]=a[i]+a[i+1];     for(j=0;j<5;j++){         printf(\"%3d\",b[j]);         if((j+1)%3==0||(j+1)==5)printf(\"\\n\");     }          return 0; }  for(i=0,j=0;i<10;i+=2,j++)           b[j]=a[i]+a[i+1];  //这个地方应该会越界吧，当i=9时，i+1就是10", "referer": "user-0"}, {"cid": "9", "user": "user-6", "content": "b[5]应改为b[9]", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "供参考：#include<stdio.h>  int main() {     int a[10]={0},b[5]={0},i,j;     for(i=0;i<10;i++)         scanf(\"%d\",&a[i]);     for(i=0,j=0;i<10;i+=2,j++)         b[j]=a[i]+a[i+1];     for(j=0;j<5;j++){         printf(\"%3d\",b[j]);         if((j+1)%3==0||(j+1)==5)printf(\"\\n\");     }          return 0; }", "referer": "user-0"}]}
{"question": "我想问一下newline  in constant和 error C2018: unknown character '0xb7'的错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：void sta(table *x) {     int a,b,c,d,e;     float A,B,C,D,E,NUM;     int i;     a=b=c=d=e=0;     NUM=(float)x->length;     for(i=x->length;i>0;i--)     {         if(x->r[i].score>100||x->r[i].score<0)            printf(\"错误！%s同学的分数超出上限！\\n\",x->r[i].name);         else if(x->r[i].score>=90&&x->r[i].score<=100)a++;         else if(x->r[i].score>=80&&x->r[i].score<=89) b++;         else if(x->r[i].score>=70&&x->r[i].score<=79) c++;         else if(x->r[i].score>=60&&x->r[i].score<=69) d++;         else if(x->r[i].score>=0 &&x->r[i].score<=60) e++;      }     A=(float)a/NUM;//A=NUM/(float)a;     B=(float)b/NUM;//B=NUM/(float)b;     C=(float)c/NUM;//C=NUM/(float)c;     D=(float)d/NUM;//D=NUM/(float)d;     E=(float)e/NUM;//E=NUM/(float)e;     printf(\"总共有%d位同学\\n\"            \"分数于90到100的同学有%d位,占总人数的%f\\n\"            \"分数于80到89的同学有%d位,占总人数的%f\\n\"            \"分数于70到79的同学有%d位,占总人数的%f\\n\"            \"分数于60到69的同学有%d位,占总人数的%f\\n\"            \"分数于60以下同学有%d位,占总人数的%f\\n\",            x->length,a,A,b,B,c,C,d,D,e,E); }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "哦对了，第一个错误对应这行printf(\"总共有%d位同学\\n", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "switch (x->r[i].score/10) {             //case 8:             case 9:             case 10:                 a++;                 break;               case 8:                 b++;                 break;               case 7:                 c++;                 break;               case 6:                 d++;                 break;               case 0:             case 1:             case 2:             case 3:             case 4:             case 5:                 e++;                 break;               default:             printf(\"错误！%s同学的分数超出上限！\\n\",x->r[i].name);         } 改一下  供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "void sta(table *x) {     int a,b,c,d,e;     float A,B,C,D,E,NUM;     int i;     a=b=c=d=e=0;     NUM=(float)x->length;     for(i=x->length;i>0;i--)     {  #if 1         switch (x->r[i].score/10) {             case 8:             case 9:             case 10:                 a++;                 break;              case 8:                 b++;                 break;              case 7:                 c++;                 break;              case 6:                 d++;                 break;              case 0:             case 1:             case 2:             case 3:             case 4:             case 5:                 e++;                 break;              default:             printf(\"错误！%s同学的分数超出上限！\\n\",x->r[i].name);         } #else         if(x->r[i].score>100||x->r[i].score<0)             printf(\"错误！%s同学的分数超出上限！\\n\",x->r[i].name);         else if(x->r[i].score>=90&&x->r[i].score<=100)             a++;         else if(x->r[i].score>=80&&x->r[i].score<=89)             b++;         else if(x->r[i].score>=70&&x->r[i].score<=79)             c++;         else if(x->r[i].score>=60&&x->r[i].score<=69)             d++;         else if(x->r[i].score>=0&&x->r[i].score<=60)             e++; #endif     }     /*     A=NUM/(float)a;     B=NUM/(float)b;     C=NUM/(float)c;     D=NUM/(float)d;     E=NUM/(float)e;     */      A= a/NUM;     B= b/NUM;     C= c/NUM;     D= d/NUM;     E= e/NUM;     printf(\"总共有%d位同学\\n             分数于90到100的同学有%d位\\n             占总人数的%f\\n             分数于80到89的同学有%d位\\n             占总人数的%f\\n             分数于70到79的同学有%d位\\n             占总人数的%f\\n             分数于60到69的同学有%d位\\n             占总人数的%f\\n             分数于60以下同学有%d位\\n             占总人数的%f\\n\",x->length,a,A,b,B,c,C,d,D,e,E); } 供参考～", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "2#楼第16行修改为：else if(x->r[i].score>=0 &&x->r[i].score<=59) e++;", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "printf(\"总共有%d位同学\\n 分数于90到100的同学有%d位\\n 占总人数的%f\\n 分数于80到89的同学有%d位\\n 占总人数的%f\\n 分数于70到79的同学有%d位\\n 占总人数的%f\\n 分数于60到69的同学有%d位\\n 占总人数的%f\\n 分数于60以下同学有%d位\\n 占总人数的%f\\n\",x->length,a,A,b,B,c,C,d,D,e,E); //应改为 printf(\"总共有%d位同学\\n\" \"分数于90到100的同学有%d位\\n\" \"占总人数的%f\\n\" \"分数于80到89的同学有%d位\\n\" \"占总人数的%f\\n\" \"分数于70到79的同学有%d位\\n\" \"占总人数的%f\\n\" \"分数于60到69的同学有%d位\\n\" \"占总人数的%f\\n\" \"分数于60以下同学有%d位\\n\" \"占总人数的%f\\n\",x->length,a,A,b,B,c,C,d,D,e,E);", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "要么每行成对的双引号，要么在\\n后面敲回车前敲一个反斜线", "referer": "user-0"}]}
{"question": "请问这第一题怎么用C语言完成啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:供参考：#include<stdio.h> #define N 6 //200  int main() {     int i,score[N],cnt_fail=0;     printf(\"请输入%d个学生成绩:\",N);     for(i=0;i<N;i++)         scanf(\"%d\",&score[i]);     for(i=0;i<N;i++){         if(score[i]<60){            printf(\"%d \",score[i]);            cnt_fail++;         }     }     printf(\"\\n\");     for(i=0;i<N;i++){         if(score[i]>=60)            printf(\"%d \",score[i]);     }     printf(\"\\n\");     printf(\"cnt_fail:%d, cnt_pass:%d\\n\",cnt_fail,N-cnt_fail);          return 0; } 虽然考试过了还是谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考：#include<stdio.h> #define N 6 //200  int main() {     int i,score[N],cnt_fail=0;     printf(\"请输入%d个学生成绩:\",N);     for(i=0;i<N;i++)         scanf(\"%d\",&score[i]);     for(i=0;i<N;i++){         if(score[i]<60){            printf(\"%d \",score[i]);            cnt_fail++;         }     }     printf(\"\\n\");     for(i=0;i<N;i++){         if(score[i]>=60)            printf(\"%d \",score[i]);     }     printf(\"\\n\");     printf(\"cnt_fail:%d, cnt_pass:%d\\n\",cnt_fail,N-cnt_fail);          return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>  #define N   200 int main(void) {     int total, score[N], tmp, ret;     int i, cnt_fail = 0, idx;      idx = 0;     for(i=0;i<N;i++) {         ret = scanf(\"%d\", &tmp);         if (ret != 1)             break;         if(tmp < 60){             cnt_fail++;             printf(\"%d \", tmp);         } else  {             score[idx++] = tmp;         }     }     total = i;      for (i = 0; i < total - cnt_fail; i++)         printf(\"%d \", score[i]);     putchar(10);      printf(\"%d %d\\n\", cnt_fail, total-cnt_fail);      return 0; } 供参考～  在第一个循环里可以完成尽可能多的事情～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你没有必要2个循环判断，一个for就能统计完所有的了", "referer": "user-0"}]}
{"question": "关于结构体指针定义指针变量", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 11 楼 赵4老师 的回复:a前面的&和*们都是运算符你知道不？赵4老湿顾左右而言它，是在遮掩什么？这么说吧， 1，a是数组类型的变量，不是sizeof和一元&的操作数，所以自动转换为指向数组首元素的指针； 2，一元*运算符作用于指针，得到指针所指向的实体，即，* a 得到数组的首元素（但不是指第一个元素的值，而是这个元素本身，是个左值）； 3，一元&运算符要求它的操作数必须是左值或者函数指示符，其结果是得到一个指针（但不是左值）。在这里，* a 是左值，& * a 的结果是指针。 。。。。。。  要点是（2）。很多人一概认为一元 * 运算符是“取值”，这是很荒谬的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "《牛肉干》 C语言上机课，某女同学偷偷吃起牛肉干。 有一粒牛肉干掉到了键盘上，卡在7和8键之间。 女同学就在键盘上抠啊、抠啊、抠啊…… 程序里一行代码变成这个样子： int *pa=&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&a; 后来的结局是 ————程序顺利通过编译，运行结果正确！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "就等价于 CreateBiTree(BiTNode** T)", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "就是二级指针啊", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "a前面的&和*们都是运算符你知道不？", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 9 楼 赵4老师 的回复:自己眼拙看不到&和*的定义还怪别人答非所问。 引用 6 楼 均陵鼠侠 的回复:补充一下，我就想知道，a是什么，& a 得到了什么，从而* & a 又是什么，最后& * & a 又得到了什么。请赵4老湿明示。^  我问的不是这些运算符有什么用，是什么。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "自己眼拙看不到&和*的定义还怪别人答非所问。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "引用 7 楼 赵4老师 的回复://C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+   答非所问。看来很多IT人士的语文水平都不行。", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "补充一下，我就想知道，a是什么，& a 得到了什么，从而* & a 又是什么，最后& * & a 又得到了什么。请赵4老湿明示。^", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "引用 3 楼 赵4老师 的回复:《牛肉干》 C语言上机课，某女同学偷偷吃起牛肉干。 有一粒牛肉干掉到了键盘上，卡在7和8键之间。 女同学就在键盘上抠啊、抠啊、抠啊…… 程序里一行代码变成这个样子： int *pa=&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&a; 后来的结局是 ————程序顺利通过编译，运行结果正确！  请赵4老湿从语法（semantic）的角度解释一下原理。", "referer": "user-0"}]}
{"question": "为啥没有输出哇？好奇怪", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "就是你代码里的指针呀，跟1楼比较一下，那个是正确的，先给指针定个小目标嘛。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2 的回复:变量，指针变量，指针，地址，供参考：#include<stdio.h>  int main() {     int *A,*B,*C,a,b,c,t;     scanf(\"%d%d%d\",&a,&b,&c);     A=&a;B=&b;C=&c;     printf(\"1:%d,%d,%d\\n\",*A,*B,*C);     if(*A > *B)     {         t =*A;         *A=*B;         *B=t;     }     if(*A > *C)     {         t =*A;         *A=*C;         *C=t;     }     if(*B > *C)     {         t =*B;         *B=*C;         *C=t;     }     printf(\"2:%d,%d,%d\\n\",*A,*B,*C);          return 0; } 可以解释一下为什么要这么做吗？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 forever74 的回复:向无目标指针的目标写入数据，有可能引起核弹意外发射。 无目标指针是什么意思？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "需要对指针变量、地址各是什么，深入的学习下，结合上面代码的找找感觉。我们定义：int *A,*B,*C; 三个是指针变量，这三个变量里只能放得下地址门牌号，我们把他们看成三个抽屉。我们又定义了：int a,b,c;  三个变量，我们把他们看成是三间房子，然后把三个宝贝放到三间房子里。现在，我们想把放在a 和 b 房子里的宝贝据为己有，那怎么才能找到他们？我们拉开抽屉A找到a家地址，然后驱车前往取得，然后从抽屉B里得到b家地址，同样驱车前往拿到他们，就是这么个感觉。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "向无目标指针的目标写入数据，有可能引起核弹意外发射。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "变量，指针变量，指针，地址，供参考：#include<stdio.h>  int main() {     int *A,*B,*C,a,b,c,t;     scanf(\"%d%d%d\",&a,&b,&c);     A=&a;B=&b;C=&c;     printf(\"1:%d,%d,%d\\n\",*A,*B,*C);     if(*A > *B)     {         t =*A;         *A=*B;         *B=t;     }     if(*A > *C)     {         t =*A;         *A=*C;         *C=t;     }     if(*B > *C)     {         t =*B;         *B=*C;         *C=t;     }     printf(\"2:%d,%d,%d\\n\",*A,*B,*C);          return 0; }", "referer": "user-0"}]}
{"question": "有没大佬教我指针，学了一学期的C语言，前面还好，直到指针就不知道咋办了。差点挂科了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "谭浩强的书教的挺详细的", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "内存里面都是记录01的电路（可以理解为微型晶体管）。逻辑上，每个数据在内存里都有自己的位置，可以理解为线性的（分页之类的都在系统层面解决了）。  1.  指针，就是一个整数，一般用32位编译器就是INT32,用64位编译器是INT64，里面记录了一个地址。以64位编译器为例子。 2.  指针本身是一个整数，也占用8字节地址。因此，也可以用另一个整数记录该指针自身的地址，也就是“指针的指针”。 3.  地址本身没有类型, char *, int * int ** classA * 这些指针的取值、指针本身的size都是INT64。  C里的指针类型，是为了告诉编译器如何使用以该整数为起点的内存。携带的信息有： （1）单元的大小。比如，对char 指针做++,前进1字节。对 int * ,前进4字节，对 int (*)[4]，前进16字节。 （2）单元的类型，比如 int, double, float. （3）单元的属性，比如是不是 const.", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "以前的回答，感觉很生动。于是找来复制一份你看看：  参加过运动会吧。 我指着（站在左上角的）你说 ：看这一排走的真整齐（排 指针） ：这迎面走来的是3年纪4班的同学们。他们...（班 指针） ：下面将要入场的是3年纪的同学们。他们...（年级 指针）  显然，我都是指着左上角的的你 也就是指向的位置都是相同的。  但是类型不一样。  当我需要指向下一排的时候，则，（排 指针 ++） 当我需要指向下一个班级的时候，则，（班级 指针++） ...  而我，就是那个指针。站在某一处【这里强调的意思是，这个指针(我)也是占了空间的】。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "不复杂怎么能显出老师的水平高呢？ 不对学生显出老师的水平高，学生怎么能服老师，进而能听进去老师讲的知识点呢？", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "不用把代码写的这么复杂吧，把函数，指针，数组类型全部套在一起，看的人头都大了。完全可以封装一下,使用时就这几种: 类型，这种类型的指针，这种类型的数组, 这种类型的指针数组。 比如这种函数类型可以单独定义出来:   typedef char(* Fun())[5];  char num[5]; char (*x00())[5] {     return # }  char (*(*x[3])())[5];  //可以写成 Fun* x[3];  char (*(*x0 )())[5]; //可以写成 Fun* x0;", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "百度下指针，多看几篇，然后思考，然后再看，然后思考上手看编译出来结果是咋个的. 指针相当于一个门牌号，可以任意强转，只是安全性你自己负责.", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "你这个贴子的下面，都是讲指针的，随便找篇看看就差不多了", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "引用 5 楼 宾灬 的回复:指针不难吧。 int a = 10; // 开辟一块内存，别名就是a，大小4个字节，把10存进去。        int* p = &a; //开辟一块内存，大小4个字节，把a这块内存的地址存进去。 *p = 5; //p存的是a的地址，把a这块内存的值改为5 试试这个： //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]", "referer": "user-0"}, {"cid": "11", "user": "user-7", "content": "指针不难吧。 int a = 10; // 开辟一块内存，别名就是a，大小4个字节，把10存进去。        int* p = &a; //开辟一块内存，大小4个字节，把a这块内存的地址存进去。 *p = 5; //p存的是a的地址，把a这块内存的值改为5", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "理解和讨论之前请先学会如何观察！", "referer": "user-0"}, {"cid": "13", "user": "user-6", "content": "计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495", "referer": "user-0"}]}
{"question": "关于宏定义与指针", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 user-1 的回复:供参考：#include<stdio.h>  #define change(a,b)  t=(a),(a)=(b),(b)=t #define compare(a,b) (a)>(b)?change((a),(b)):NULL  int main() {     int *a,*b,*c,t,A,B,C;     scanf(\"%d%d%d\",&A,&B,&C);     a=&A;b=&B;c=&C;     printf(\"1: %d,%d,%d\\n\",*a,*b,*c);      compare((*a),(*b));     compare((*a),(*c));     compare((*b),(*c));     printf(\"2: %d,%d,%d\\n\",*a,*b,*c);      return 0; } 感觉和我另一个帖子犯的错误好像啊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "深入理解指针、地址、变量的概念，然后结合上面的代码再找找感觉。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "供参考：#include<stdio.h>  #define change(a,b)  t=(a),(a)=(b),(b)=t #define compare(a,b) (a)>(b)?change((a),(b)):NULL  int main() {     int *a,*b,*c,t,A,B,C;     scanf(\"%d%d%d\",&A,&B,&C);     a=&A;b=&B;c=&C;     printf(\"1: %d,%d,%d\\n\",*a,*b,*c);      compare((*a),(*b));     compare((*a),(*c));     compare((*b),(*c));     printf(\"2: %d,%d,%d\\n\",*a,*b,*c);      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我怀疑是宏定义不能用指针的问题，然后宏定义里也没加*，但是还是错了。", "referer": "user-0"}]}
{"question": "链表问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "修改如下，供参考：#include<stdio.h> #include<stdlib.h>  typedef struct Syracuse {     int    value;     struct Syracuse *next; } Syracuse_t;  void display_SyracuseSeq(Syracuse_t *ptrL);//头指针ptrL，作用带替printf输出序列 Syracuse_t * create_SyracuseSeq(int n);//运行函数，当值到1就结束 void destroy_SyracuseSeq(Syracuse_t **adptrL);//释放内存函数  int main(int agrc, char *argv[])//argc记录了用户在运行程序的命令行中输入的参数的个数。 {     Syracuse_t *ptrL;     int n=4; // value of u0     ptrL=create_SyracuseSeq(n);     display_SyracuseSeq(ptrL);     destroy_SyracuseSeq(&ptrL);     display_SyracuseSeq(ptrL);          return EXIT_SUCCESS; } void display_SyracuseSeq(Syracuse_t *ptrL)//头指针ptrL，作用带替printf输出序列 {     Syracuse_t *p;     p=ptrL->next; //p=ptrL;     printf(\"Syracuse sequence starts with: \");     while(p)  //->value!=1)     {        printf(\" %d \", p->value);        p=p->next;     }               //printf(\" %d \", p->value);     printf(\"\\n\"); } Syracuse_t * create_SyracuseSeq(int n) {     Syracuse_t *ptrL,*tail;     Syracuse_t *p;     ptrL=(Syracuse_t * )malloc(sizeof(Syracuse_t));     ptrL->value=n;     ptrL->next=NULL;     tail=ptrL;     while(n >= 1)//while(ptrL&&ptrL->value!=1)     {         p=(Syracuse_t * )malloc(sizeof(Syracuse_t));         if (n%2 == 0)             p->value = n/2;         else             p->value = 3*n + 1;         p->next=NULL;         tail->next=p;         tail=p;         n--;     }     return ptrL; } void destroy_SyracuseSeq(Syracuse_t **adptrL) {     Syracuse_t *p;     p=(*adptrL)->next;     while(p!=NULL) //NUll     {         (*adptrL)->next=p->next;         free(p);         p=(*adptrL)->next;     } }", "referer": "user-0"}]}
{"question": "大佬帮帮忙keil程序问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "无图无真相", "referer": "user-0"}]}
{"question": "还是十六进制数据解析的问题，上个回帖有的数据是不正确的，特请教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢了  赵四老师", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 2004v2004的回复:谢谢 赵四老师   能解释下   for (int i=0;i<NBC;i++) {         swapbyte(0+(char *)&(data.Channel[i].Data),3+(char *)&(data.Channel[i].Data));         swapbyte(1+(char *)&(data.Channel[i].Data),2+(char *)&(data.Channel[i].Data));     } 这段代码吗  没看懂 将0123四个字节03交换，12交换，达到大端字节顺序转换为小端字节顺序的目的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢 赵四老师   能解释下   for (int i=0;i<NBC;i++) {         swapbyte(0+(char *)&(data.Channel[i].Data),3+(char *)&(data.Channel[i].Data));         swapbyte(1+(char *)&(data.Channel[i].Data),2+(char *)&(data.Channel[i].Data));     } 这段代码吗  没看懂", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "#pragma warning(disable:4996 4838) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include <stdio.h> #include <string.h> #include <malloc.h> #include <stdlib.h> #pragma pack(push) #pragma pack(1) struct CHANNEL {     short int Stat;     float Data; }; struct DATA {     char Start;     char Address[4];     char Command[2];     char BinaryBlocSize[2];     char StartChannel;     unsigned char NumberOfChannel;     struct CHANNEL *Channel; } data; #pragma pack(pop) void swapbyte(char *a,char *b) {     char t;     t=*a;*a=*b;*b=t; } int main() {     int NBC;     char b0[]={         0x1B,         0x41,0x46,0x32,0x32,         0x32,0x34,         0x00,0x2C,         0x01,         0x07,          0x02,0x00,         0xBD,0xD6,0xD4,0x57,          0x02,0x00,         0x43,0xF5,0x14,0x03,          0x02,0x00,         0x43,0x18,0x48,0x9B,          0x02,0x00,         0x44,0x77,0xAF,0xE5,          0x02,0x00,         0x41,0xA0,0x21,0x12,          0x02,0x00,         0x42,0x48,0x02,0xAB,          0x02,0x00,         0x45,0x24,0x5B,0x7C,          0x41,0x36,         0x03};     memcpy((void *)&data,(const void *)&b0[0],1+4+2+2+1+1);     NBC=(int)(data.NumberOfChannel);     printf(\"NBC:%d\\n\",NBC);     printf(\"sizeof(struct CHANNEL):%d\\n\",sizeof(struct CHANNEL));     data.Channel=(struct CHANNEL *)malloc(NBC*sizeof(struct CHANNEL));     memcpy((void *)(data.Channel),(const void *)&b0[1+4+2+2+1+1],NBC*sizeof(struct CHANNEL));     for (int i=0;i<NBC;i++) {         swapbyte(0+(char *)&(data.Channel[i].Data),3+(char *)&(data.Channel[i].Data));         swapbyte(1+(char *)&(data.Channel[i].Data),2+(char *)&(data.Channel[i].Data));     }     for (int i=0;i<NBC;i++) {         printf(\"%d 0x%04hX %f\\n\",i,data.Channel[i].Stat,data.Channel[i].Data);     }     free(data.Channel);       char b1[]={0x1B,0x4F,0x33,0x34,0x32,0x32,0x34,0x00,0x08,0x01,0x01,0x02,0x00,0x41,0x65,0x5A,0xB9,0x42,0x31,0x03};      memcpy((void *)&data,(const void *)&b1[0],1+4+2+2+1+1);     NBC=(int)(data.NumberOfChannel);     printf(\"NBC:%d\\n\",NBC);     printf(\"sizeof(struct CHANNEL):%d\\n\",sizeof(struct CHANNEL));     data.Channel=(struct CHANNEL *)malloc(NBC*sizeof(struct CHANNEL));     memcpy((void *)(data.Channel),(const void *)&b1[1+4+2+2+1+1],NBC*sizeof(struct CHANNEL));     for (int i=0;i<NBC;i++) {         swapbyte(0+(char *)&(data.Channel[i].Data),3+(char *)&(data.Channel[i].Data));         swapbyte(1+(char *)&(data.Channel[i].Data),2+(char *)&(data.Channel[i].Data));     }     for (int i=0;i<NBC;i++) {         printf(\"%d 0x%04hX %f\\n\",i,data.Channel[i].Stat,data.Channel[i].Data);     }     free(data.Channel);       char b2[]={0x1B,0x41,0x43,0x33,0x32,0x32,0x34,0x00,0x14,0x01,0x03,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x39,0x33,0x03};      memcpy((void *)&data,(const void *)&b2[0],1+4+2+2+1+1);     NBC=(int)(data.NumberOfChannel);     printf(\"NBC:%d\\n\",NBC);     printf(\"sizeof(struct CHANNEL):%d\\n\",sizeof(struct CHANNEL));     data.Channel=(struct CHANNEL *)malloc(NBC*sizeof(struct CHANNEL));     memcpy((void *)(data.Channel),(const void *)&b2[1+4+2+2+1+1],NBC*sizeof(struct CHANNEL));     for (int i=0;i<NBC;i++) {         swapbyte(0+(char *)&(data.Channel[i].Data),3+(char *)&(data.Channel[i].Data));         swapbyte(1+(char *)&(data.Channel[i].Data),2+(char *)&(data.Channel[i].Data));     }     for (int i=0;i<NBC;i++) {         printf(\"%d 0x%04hX %f\\n\",i,data.Channel[i].Stat,data.Channel[i].Data);     }     free(data.Channel);       return 0; } //NBC:7 //sizeof(struct CHANNEL):6 //0 0x0002 -0.104897 //1 0x0002 490.156342 //2 0x0002 152.283615 //3 0x0002 990.748352 //4 0x0002 20.016148 //5 0x0002 50.002605 //6 0x0002 2629.717773 //NBC:1 //sizeof(struct CHANNEL):6 //0 0x0002 14.334649 //NBC:3 //sizeof(struct CHANNEL):6 //0 0x8000 0.000000 //1 0x8000 0.000000 //2 0x8000 0.000000 //", "referer": "user-0"}]}
{"question": "C入门学习", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "程序员用C语言编程 和 中国人用筷子吃饭 一样。", "referer": "user-0"}]}
{"question": "二叉树", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：#include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*T)->data = data;         //生成根结点         CreateBiTree(&(*T)->lchild);//构造左子树         CreateBiTree(&(*T)->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf(\"%c \",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf(\"%c \",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(&T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:不要贴截图，直接贴代码。 你这段代码能编译通过并运行吗？运行不了 遍历不了二叉树", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:不要贴截图，直接贴代码。 你这段代码能编译通过并运行吗？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:不要贴截图，直接贴代码。 你这段代码能编译通过并运行吗？void main()  { \tBiTree *T,*p1,*p2,*p3,*p4,*p5; \tInitiate(&T); \tInitiate(&p1); \tInitiate(&p2); \tInitiate(&p3); \tInitiate(&p4); \tInitiate(&p5); \tT->data = 5; \tp1->data = 2; \tp2->data = 2; \tp3->data = 3; \tp4->data = 6; \tp5->data = 11; \tT->lchild = p1; \tT->rchild = p2; \tp1->lchild = p3; \tp1->rchild = p4; \tp2->rchild = p5; \tgetNode(*T, 2); \t//printf(\"%d\\n\", );  } int getNode(BiTree T, int e) { \tstatic int count = 0; \tif (T.data!=NULL) { \t\tvisit(T.data); \t\tif (T.data == e) \t\t\tcount++; \t\tgetNode(*(T.lchild),e); \t\tgetNode(*(T.rchild),e); \t\t\treturn count; \t}  }", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "不要贴截图，直接贴代码。 你这段代码能编译通过并运行吗？", "referer": "user-0"}]}
{"question": "求，哪个人可以帮帮我", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第二题，供参考：#include<stdio.h>  int sort_mid(int *p,int n);  int main() {     int s[256],i=0,max=0,min=101,avg=0;     while(scanf(\"%d\",&s[i])==1 && s[i] != -1){           if(max < s[i]) max = s[i];           if(min > s[i]) min = s[i];           avg += s[i];           i++;     }     printf(\"max=%d,min=%d,avg=%.1f,mid=%d\\n\",max,min,(float)avg/i,sort_mid(s,i));          return 0; } int sort_mid(int *p,int n)//取中位数 {    int i,k,mid,t;    int *a = (int *)malloc(sizeof(int)*n);    for(i=0,k=0;i<n;k++,i++)        a[k] = p[i];    for(i=0;i<n-1;i++){ //排序       for(k=0;k<n-i-1;k++){           if(a[k]>a[k+1]){              t     = a[k];              a[k]  = a[k+1];              a[k+1]= t;           }       }    }    if(n%2==0)         mid=(a[n/2]+a[n/2-1])/2;    else         mid=a[(n-1)/2];    free(a);    return mid; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> int main(int argc, char* argv[]) {      int a, b, c;  \tscanf(\"%d%d%d\", &a, &b, &c); \t \tif(a==b || a==c || b==c) \t{ \t\tprintf(\"是\\n\"); \t} \telse \t{ \t\tprintf(\"不是\\n\"); \t}  \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "std::set<int> val; \tval.insert(a); \tval.insert(b); \tval.insert(c);  \tswitch (val.size()) \t{ \tcase 1: \t\t// 等边三角形 \t\tbreak; \tcase 2: \t\t// 等腰三角形 \t\tbreak; \tdefault: \t\t// 其他 \t\tbreak; \t}", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "第一题，其实可以简化为统计数量，只要其中两条一样就是等腰，三条全等我不知道你们老师是否算等腰。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 ggglivw的回复:这些题目都很简单啊，都是课程简单的循环统计就可以搞定 大神，现在特别急", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 ggglivw的回复:这些题目都很简单啊，都是课程简单的循环统计就可以搞定 求，帮帮忙了", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "#include <stdio.h>  int main(void) {      int a, b, c;      scanf(\"%d%d%d\", &a, &b, &c);      if (a + b < c || a + c < b || b + c < a) {         printf(\"Not a triangle!\\n\");         return 0;     }      if (a == b || b == c || a == c) {         printf(\"an isosceles triangle!\\n\");         return 0;     } else {         printf(\"Not an isosceles triangle!\\n\");     }      return 0; } 供参考～", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "百度上搜索。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "帮我做一下，谢谢了。", "referer": "user-0"}, {"cid": "11", "user": "user-4", "content": "这些题目都很简单啊，都是课程简单的循环统计就可以搞定", "referer": "user-0"}]}
{"question": "二维数组中找最大特征数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "51节前看到的，有个思路，趁机想把代码写下来。 可惜写了一点点下班了，摸鱼党用不加班。接着放51就没继续写了： 想法是： 010111101010100 111111100000111 011101010101011 101110100011110 011111110111011 找到1最多的前8列。设这8列的编号即为b[8]，当然，结果并不一定如此。获得此时这8列中1111 1111的数量n 我的想法是：如果这n值求得了。那么可以在后续的运算中排除1的数量小于n的列。因为这些列不可能存在b[8]中。 我觉得这个思路在特别多列的时候，又是纯随机的数据，效率提升会非常高【比老老实实算下去】", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "51节前看到的，有个思路，趁机想把代码写下来。 可惜写了一点点下班了，摸鱼党用不加班。接着放51就没继续写了： 想法是： 010111101010100 111111100000111 011101010101011 101110100011110 011111110111011 找到1最多的前8列。设这8列的编号即为b[8]，当然，结果并不一定如此。获得此时这8列中1111 1111的数量n 我的想法是：如果这n值求得了。那么可以在后续的运算中排除1的数量小于n的列。因为这些列不可能存在b[8]中。 我觉得这个思路在特别多列的时候，又是纯随机的数据，效率提升会非常高【比老老实实算下去】", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 96 楼 早打大打打核战争 的回复:可以考虑把每行看作一个二进制数字，对按行排序过的矩阵再做处理？这样可能不需要C(5000, 8)次循环了，只需要循环5000次，每次处理5000、4999... 1行数据 具体怎么实现呢？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "是最多数量的行", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "b[8]的值不重复，找到第八个最多数量的列不就可以了？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 92 楼 GKatHere 的回复:[quote=引用 86 楼 赵4老师 的回复:]使用#78楼的数据，在我#41楼代码的基础上优化了一下，运行不到一分钟： //二维数组中找最大特征数组 //http://bbs.csdn.net/topics/399169928 #pragma warning(disable:4996) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include <conio.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <search.h> #include <time.h>  #define N 50 //5000 static char a[N][N]={   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1}, }; int v[8],u[8],w[N],W,bestv[8],y; int maxfitnum=0; char vstr[1024*1024*32][4*8];//1GB int V=0,CNTold=0; int compare(const void *arg1,const void *arg2) {    return strncmp((char *)arg1,(char *)arg2,4*8); } bool isOldv(char *str) {     void *p;     if (V>0 && (p=bsearch((const void *)str,(const void *)&vstr[0],V,4*8,compare))!=NULL) {         CNTold++;         if (CNTold%100000==0) cprintf(\"y:%02d/%d CNTold:%d V:%d old pattern %d,%s\\r\",y,N,CNTold,V,((int)p-(int)&vstr[0][0])/(4*8),str);         return true;     } else {         if (V>=1024*1024*32) { //          printf(\"Warnning: Too many pattern!\\n\");             return false;         } else {             strncpy(vstr[V],str,4*8);             V++;             if (V%100000==0) cprintf(\"y:%02d/%d CNTold:%d V:%d new pattern:%s\\r\",y,N,CNTold,V,str);             return false;         }     } } unsigned long ulrand(void) {     return (      (((unsigned long)rand()<<24)&0xFF000000ul)     |(((unsigned long)rand()<<12)&0x00FFF000ul)     |(((unsigned long)rand()    )&0x00000FFFul)); }  int first1(int i) {     int j;     for (j=0;j<N;j++) {         if (a[i][j]==1) break;     }     return j; }  void next1(int i,int &p) {     int j;      if (p>=N) {p=N; return;}     for (j=p+1;j<N;j++) {         if (a[i][j]==1) break;     }     p=j; }  void test() {     int fitnum=0,b;     for (int i=0;i<N;i++) {         for (int j=first1(i);j<N-v[7];next1(i,j)) {             b=a[i][v[0]+j]+a[i][v[1]+j]+a[i][v[2]+j]+a[i][v[3]+j]+a[i][v[4]+j]+a[i][v[5]+j]+a[i][v[6]+j]+a[i][v[7]+j];             if (b==8) fitnum++;         }     }     if (fitnum>maxfitnum) {         bestv[0]=v[0];bestv[1]=v[1];bestv[2]=v[2];bestv[3]=v[3];bestv[4]=v[4];bestv[5]=v[5];bestv[6]=v[6];bestv[7]=v[7];         maxfitnum=fitnum;         printf(\"\\nfound a new bestv,maxfitnum:%d\\n\",maxfitnum); //  } else { //      printf(\"fitnum:%d\\n\",fitnum);     } }  void recursion(int m,int L) {     if (L==8) { /*         printf(\"y:%04d u[0..7]:\",y);         for (int i=0;i<8;i++) {             printf(\"%5d\",u[i]);         } //      printf(\"\\n\"); */          for (int i=1;i<8;i++) v[i]=u[i]-u[0];         v[0]=0; /*         printf(\"|y:%04d v[0..7]:\",y);         for (int i=0;i<8;i++) {             printf(\"%5d\",v[i]);         }         printf(\"\\n\"); */         char ln[4*8+1];         for (int i=0;i<8;i++) sprintf(ln+i*4,\"%04d\",v[i]);         if (!isOldv(ln)) test();         return;     }     for (int i=m;i<=W-8+L;i++) {         u[L]=w[i];         recursion(i+1,L+1);     } }  void findpattern(int y) {     W=0;     for (int j=0;j<N;j++) {         if (a[y][j]==1) {             w[W]=j;             W++;         }     }     if (W>=8) { /*      printf(\"y:%04d W:%5d:\",y,W);         for (int j=0;j<W;j++) {             printf(\"%5d\",w[j]);         }         printf(\"\\n\"); */      recursion(0,0);     } }  int main() { //  srand(time(NULL));     srand(0); /*     for (int i=0;i<N;i++) {         for (int j=0;j<N;j++) {             if ((ulrand()%N) < 3) a[i][j]=1; //          printf(\"%d\",a[i][j]);         } //      printf(\"\\n\");     } */     for (y=0;y<N;y++) {         findpattern(y);     }      if (maxfitnum==0) {         printf(\"\\nCan not find pattern!\");     } else {         printf(\"\\nbestv:\");         for (int i=0;i<8;i++) {             printf(\"%6d \",bestv[i]);         }     }     return 0; } // //found a new bestv,maxfitnum:450 //y:48/50 CNTold:26600000 V:346104 old pattern 182573,00000006000800140016001800340036 //bestv:     0      2      4      6      8     10     12     14   [/quote]   b[8]中的值不可重复", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "可以考虑把每行看作一个二进制数字，对按行排序过的矩阵再做处理？这样可能不需要C(5000, 8)次循环了，只需要循环5000次，每次处理5000、4999... 1行数据", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "引用 86 楼 赵4老师 的回复:使用#78楼的数据，在我#41楼代码的基础上优化了一下，运行不到一分钟： //二维数组中找最大特征数组 //http://bbs.csdn.net/topics/399169928 #pragma warning(disable:4996) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include <conio.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <search.h> #include <time.h>  #define N 50 //5000 static char a[N][N]={   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1}, }; int v[8],u[8],w[N],W,bestv[8],y; int maxfitnum=0; char vstr[1024*1024*32][4*8];//1GB int V=0,CNTold=0; int compare(const void *arg1,const void *arg2) {    return strncmp((char *)arg1,(char *)arg2,4*8); } bool isOldv(char *str) {     void *p;     if (V>0 && (p=bsearch((const void *)str,(const void *)&vstr[0],V,4*8,compare))!=NULL) {         CNTold++;         if (CNTold%100000==0) cprintf(\"y:%02d/%d CNTold:%d V:%d old pattern %d,%s\\r\",y,N,CNTold,V,((int)p-(int)&vstr[0][0])/(4*8),str);         return true;     } else {         if (V>=1024*1024*32) { //          printf(\"Warnning: Too many pattern!\\n\");             return false;         } else {             strncpy(vstr[V],str,4*8);             V++;             if (V%100000==0) cprintf(\"y:%02d/%d CNTold:%d V:%d new pattern:%s\\r\",y,N,CNTold,V,str);             return false;         }     } } unsigned long ulrand(void) {     return (      (((unsigned long)rand()<<24)&0xFF000000ul)     |(((unsigned long)rand()<<12)&0x00FFF000ul)     |(((unsigned long)rand()    )&0x00000FFFul)); }  int first1(int i) {     int j;     for (j=0;j<N;j++) {         if (a[i][j]==1) break;     }     return j; }  void next1(int i,int &p) {     int j;      if (p>=N) {p=N; return;}     for (j=p+1;j<N;j++) {         if (a[i][j]==1) break;     }     p=j; }  void test() {     int fitnum=0,b;     for (int i=0;i<N;i++) {         for (int j=first1(i);j<N-v[7];next1(i,j)) {             b=a[i][v[0]+j]+a[i][v[1]+j]+a[i][v[2]+j]+a[i][v[3]+j]+a[i][v[4]+j]+a[i][v[5]+j]+a[i][v[6]+j]+a[i][v[7]+j];             if (b==8) fitnum++;         }     }     if (fitnum>maxfitnum) {         bestv[0]=v[0];bestv[1]=v[1];bestv[2]=v[2];bestv[3]=v[3];bestv[4]=v[4];bestv[5]=v[5];bestv[6]=v[6];bestv[7]=v[7];         maxfitnum=fitnum;         printf(\"\\nfound a new bestv,maxfitnum:%d\\n\",maxfitnum); //  } else { //      printf(\"fitnum:%d\\n\",fitnum);     } }  void recursion(int m,int L) {     if (L==8) { /*         printf(\"y:%04d u[0..7]:\",y);         for (int i=0;i<8;i++) {             printf(\"%5d\",u[i]);         } //      printf(\"\\n\"); */          for (int i=1;i<8;i++) v[i]=u[i]-u[0];         v[0]=0; /*         printf(\"|y:%04d v[0..7]:\",y);         for (int i=0;i<8;i++) {             printf(\"%5d\",v[i]);         }         printf(\"\\n\"); */         char ln[4*8+1];         for (int i=0;i<8;i++) sprintf(ln+i*4,\"%04d\",v[i]);         if (!isOldv(ln)) test();         return;     }     for (int i=m;i<=W-8+L;i++) {         u[L]=w[i];         recursion(i+1,L+1);     } }  void findpattern(int y) {     W=0;     for (int j=0;j<N;j++) {         if (a[y][j]==1) {             w[W]=j;             W++;         }     }     if (W>=8) { /*      printf(\"y:%04d W:%5d:\",y,W);         for (int j=0;j<W;j++) {             printf(\"%5d\",w[j]);         }         printf(\"\\n\"); */      recursion(0,0);     } }  int main() { //  srand(time(NULL));     srand(0); /*     for (int i=0;i<N;i++) {         for (int j=0;j<N;j++) {             if ((ulrand()%N) < 3) a[i][j]=1; //          printf(\"%d\",a[i][j]);         } //      printf(\"\\n\");     } */     for (y=0;y<N;y++) {         findpattern(y);     }      if (maxfitnum==0) {         printf(\"\\nCan not find pattern!\");     } else {         printf(\"\\nbestv:\");         for (int i=0;i<8;i++) {             printf(\"%6d \",bestv[i]);         }     }     return 0; } // //found a new bestv,maxfitnum:450 //y:48/50 CNTold:26600000 V:346104 old pattern 182573,00000006000800140016001800340036 //bestv:     0      2      4      6      8     10     12     14", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "使用#78楼的数据，在我#41楼代码的基础上优化了一下，运行不到一分钟： //二维数组中找最大特征数组 //http://bbs.csdn.net/topics/399169928 #pragma warning(disable:4996) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include <conio.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <search.h> #include <time.h>  #define N 50 //5000 static char a[N][N]={   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1},   {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1}, }; int v[8],u[8],w[N],W,bestv[8],y; int maxfitnum=0; char vstr[1024*1024*32][4*8];//1GB int V=0,CNTold=0; int compare(const void *arg1,const void *arg2) {    return strncmp((char *)arg1,(char *)arg2,4*8); } bool isOldv(char *str) {     void *p;     if (V>0 && (p=bsearch((const void *)str,(const void *)&vstr[0],V,4*8,compare))!=NULL) {         CNTold++;         if (CNTold%100000==0) cprintf(\"y:%02d/%d CNTold:%d V:%d old pattern %d,%s\\r\",y,N,CNTold,V,((int)p-(int)&vstr[0][0])/(4*8),str);         return true;     } else {         if (V>=1024*1024*32) { //          printf(\"Warnning: Too many pattern!\\n\");             return false;         } else {             strncpy(vstr[V],str,4*8);             V++;             if (V%100000==0) cprintf(\"y:%02d/%d CNTold:%d V:%d new pattern:%s\\r\",y,N,CNTold,V,str);             return false;         }     } } unsigned long ulrand(void) {     return (      (((unsigned long)rand()<<24)&0xFF000000ul)     |(((unsigned long)rand()<<12)&0x00FFF000ul)     |(((unsigned long)rand()    )&0x00000FFFul)); }  int first1(int i) {     int j;     for (j=0;j<N;j++) {         if (a[i][j]==1) break;     }     return j; }  void next1(int i,int &p) {     int j;      if (p>=N) {p=N; return;}     for (j=p+1;j<N;j++) {         if (a[i][j]==1) break;     }     p=j; }  void test() {     int fitnum=0,b;     for (int i=0;i<N;i++) {         for (int j=first1(i);j<N-v[7];next1(i,j)) {             b=a[i][v[0]+j]+a[i][v[1]+j]+a[i][v[2]+j]+a[i][v[3]+j]+a[i][v[4]+j]+a[i][v[5]+j]+a[i][v[6]+j]+a[i][v[7]+j];             if (b==8) fitnum++;         }     }     if (fitnum>maxfitnum) {         bestv[0]=v[0];bestv[1]=v[1];bestv[2]=v[2];bestv[3]=v[3];bestv[4]=v[4];bestv[5]=v[5];bestv[6]=v[6];bestv[7]=v[7];         maxfitnum=fitnum;         printf(\"\\nfound a new bestv,maxfitnum:%d\\n\",maxfitnum); //  } else { //      printf(\"fitnum:%d\\n\",fitnum);     } }  void recursion(int m,int L) {     if (L==8) { /*         printf(\"y:%04d u[0..7]:\",y);         for (int i=0;i<8;i++) {             printf(\"%5d\",u[i]);         } //      printf(\"\\n\"); */          for (int i=1;i<8;i++) v[i]=u[i]-u[0];         v[0]=0; /*         printf(\"|y:%04d v[0..7]:\",y);         for (int i=0;i<8;i++) {             printf(\"%5d\",v[i]);         }         printf(\"\\n\"); */         char ln[4*8+1];         for (int i=0;i<8;i++) sprintf(ln+i*4,\"%04d\",v[i]);         if (!isOldv(ln)) test();         return;     }     for (int i=m;i<=W-8+L;i++) {         u[L]=w[i];         recursion(i+1,L+1);     } }  void findpattern(int y) {     W=0;     for (int j=0;j<N;j++) {         if (a[y][j]==1) {             w[W]=j;             W++;         }     }     if (W>=8) { /*      printf(\"y:%04d W:%5d:\",y,W);         for (int j=0;j<W;j++) {             printf(\"%5d\",w[j]);         }         printf(\"\\n\"); */      recursion(0,0);     } }  int main() { //  srand(time(NULL));     srand(0); /*     for (int i=0;i<N;i++) {         for (int j=0;j<N;j++) {             if ((ulrand()%N) < 3) a[i][j]=1; //          printf(\"%d\",a[i][j]);         } //      printf(\"\\n\");     } */     for (y=0;y<N;y++) {         findpattern(y);     }      if (maxfitnum==0) {         printf(\"\\nCan not find pattern!\");     } else {         printf(\"\\nbestv:\");         for (int i=0;i<8;i++) {             printf(\"%6d \",bestv[i]);         }     }     return 0; } // //found a new bestv,maxfitnum:450 //y:48/50 CNTold:26600000 V:346104 old pattern 182573,00000006000800140016001800340036 //bestv:     0      2      4      6      8     10     12     14", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "是离散的8个1", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "引用 82 楼 user-7的回复:外层循环5000次，内层每次记录下最后一个不符合要求的位置，以及当前对比到的最后位置，移动后只需要对比新增的位点，单纬度的特征提取。这样应该效率很高。你的题目好像是找连续的8个1啊 似乎可以是离散的八个1。实际上是任意抽8列，形成5000字节，里面的ff最多", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "可以付费开发", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "期待优化的算法，能在30天内算完就OK！", "referer": "user-0"}, {"cid": "15", "user": "user-5", "content": "引用 87 楼 早打大打打核战争 的回复:老赵的新代码确实不会死循环了 但是性能不行啊，在我的电脑上运行时间32秒。50x50数组和5000x5000数组的时间复杂度可不是1:10000的关系，大约是1:10^17的关系，所以你的代码要计算5000x5000数组在PC上需要大概1000亿年~  这就是穷举法的“绝对优势”！", "referer": "user-0"}, {"cid": "16", "user": "user-3", "content": "老赵的新代码确实不会死循环了 但是性能不行啊，在我的电脑上运行时间32秒。50x50数组和5000x5000数组的时间复杂度可不是1:10000的关系，大约是1:10^17的关系，所以你的代码要计算5000x5000数组在PC上需要大概1000亿年~", "referer": "user-0"}, {"cid": "17", "user": "user-5", "content": "审题！ 人家找的是同一行内8个点的分布特征，不是你画的二维特征。", "referer": "user-0"}, {"cid": "18", "user": "user-7", "content": "我想了个好方法，你把你的a[5000][5000]，画一个5000*5000方格的图片，1用红色填充，0用绿色填充，然后把图片导出来，用人眼看，找出可能的特征，然后再用程序验证。", "referer": "user-0"}, {"cid": "19", "user": "user-7", "content": "一张更好的图片，图片很小，你的a[5000][5000]那么大，查找量太大了。 如图：", "referer": "user-0"}, {"cid": "20", "user": "user-7", "content": "企图通过遍历查找特征是不可能的啊。 关键点在于你的b[8]是不确定，初期最好只检查b[8]的关键几个点的值。，然后你就可以进行移动扫描了。 让我们来举一个具体的例子，找出下面图中的最多的特征：    那么按照你的遍历算法，能找出来吗？", "referer": "user-0"}]}
{"question": "新手使用vs2015遇到问题了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "解决了，中英转换，输入法害人", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把main的返回值设定为int，另外，注意下中英文的字符～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "int main（void）像极了输入了中文括号。", "referer": "user-0"}]}
{"question": "C语言嵌套循环", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用字符串处理比较合适，", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int是有范围的，你的i=i+b*pow会超出int范围 按字符一个以输出就好，不需要转成int再输出", "referer": "user-0"}]}
{"question": "变长十六进制字符串赋值到结构体，该如何写，请指点下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#pragma warning(disable:4996 4838) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS” #include <stdio.h> #include <string.h> #include <malloc.h> #include <stdlib.h> #pragma pack(push) #pragma pack(1) struct CHANNEL {     short int Stat;     float Data; }; struct DATA {     char Start;     char Address[4];     char Command[2];     char BinaryBlocSize[2];     char StartChannel;     unsigned char NumberOfChannel;     struct CHANNEL *Channel; } data; #pragma pack(pop) void swapbyte(char *a,char *b) {     char t;     t=*a;*a=*b;*b=t; } int main() {     char b[]={         0x1B,         0x41,0x46,0x32,0x32,         0x32,0x34,         0x00,0x2C,         0x01,         0x07,          0x02,0x00,         0xBD,0xD6,0xD4,0x57,          0x02,0x00,         0x43,0xF5,0x14,0x03,          0x02,0x00,         0x43,0x18,0x48,0x9B,          0x02,0x00,         0x44,0x77,0xAF,0xE5,          0x02,0x00,         0x41,0xA0,0x21,0x12,          0x02,0x00,         0x42,0x48,0x02,0xAB,          0x02,0x00,         0x45,0x24,0x5B,0x7C,          0x41,0x36,         0x03};     memcpy((void *)&data,(const void *)&b[0],1+4+2+2+1+1);     int NBC=(int)(data.NumberOfChannel);     printf(\"NBC:%d\\n\",NBC);     printf(\"sizeof(struct CHANNEL):%d\\n\",sizeof(struct CHANNEL));     data.Channel=(struct CHANNEL *)malloc(NBC*sizeof(struct CHANNEL));     memcpy((void *)(data.Channel),(const void *)&b[1+4+2+2+1+1],NBC*sizeof(struct CHANNEL));     for (int i=0;i<NBC;i++) {         swapbyte(0+(char *)&(data.Channel[i].Data),3+(char *)&(data.Channel[i].Data));         swapbyte(1+(char *)&(data.Channel[i].Data),2+(char *)&(data.Channel[i].Data));     }     for (int i=0;i<NBC;i++) {         printf(\"%d %hd %f\\n\",i,data.Channel[i].Stat,data.Channel[i].Data);     }     free(data.Channel);     return 0; } //NBC:7 //sizeof(struct CHANNEL):6 //0 2 -0.104897 //1 2 490.156342 //2 2 152.283615 //3 2 990.748352 //4 2 20.016148 //5 2 50.002605 //6 2 2629.717773 //", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "NBYTE    字段  00 2C  表示长度，  我主要不知道怎么 把   4个字节放到一个 变量里去，用循环模式， 例如 ：41 46 32 32 放到一个结构体的变量   BD D6 D4 57放到一个结构体的变量  请指点这里怎么写即可，", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "既然是变长的，那前面是不是有指示这个长度是多长呢？如果没有，有没有这个边长的结束标识？这两个条件有其一就可以解析～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 3 楼 2004v2004 的回复:NBYTE    字段  00 2C  表示长度，  我主要不知道怎么 把   4个字节放到一个 变量里去，用循环模式， 例如 ：41 46 32 32 放到一个结构体的变量   BD D6 D4 57放到一个结构体的变量  请指点这里怎么写即可， 那就先解析到可变长度的具体长度，把这个长度值获取后，这这样就知道接下来读取结果字节，后面的就完全匹配了。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "它这个是大端字节序", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "(NBYTE - 4) / sizeof(float)就是浮点数据的数量", "referer": "user-0"}]}
{"question": "求大佬帮我看下这个c语言链表哪出问题了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "删除和显示输出链表函数，增加对空链表的判断及反馈，供参考：int DeleteList_L(LinkList L, int i)\t\t\t\t//删除L中第i个元素，并用e返回其值 { \tLinkList p, q; \tint j = 0; \tp = L;     if(L == NULL){        printf(\"这是一个空链表！\\n\");        return -1;     } \t//printf(\"请输入要删除的结点位置：\");  \twhile (p->next && j < i-1)                  //寻找第i个结点，并令p指向其前驱 \t{ \t\tp = p->next; \t\t++j; \t} \tif (!(p->next) || j > i) exit(1);            //删除位置不合理 \tq = p->next;                                 //临时保存被删除结点的地址以备释放 \tp->next = q->next;                           //改变删除结点的前驱结点指针域 \tfree(q); //释放     return 0; }  void ShowList(LinkList L)\t\t\t\t\t//打印整个链表 { \tLinkList p; \tif (L == NULL) \t{ \t\tprintf(\"这是一个空链表！\\n\");         return; \t} \tprintf(\"单链表\");     p = L->next; \twhile (p) \t{ \t\tprintf(\" -> %d\", p->data); \t\tp = p->next; \t} \tprintf(\"\\n\"); }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include<stdio.h> #include<stdlib.h>  typedef int Elemtype; typedef struct LNode                                //定义一个结构体 {     Elemtype data;                                   //结点的数据域     struct LNode *next;                              //节点的指针域 }LNode , *LinkList;                                  //指针类型  int InitList(LinkList L)                            //带有头节点的单链表的初始化 {     L= (LinkList)malloc(sizeof(LNode));     if (!L)                                          //储存分配失败退出     {         printf(\"分配内存失败！\\n\");         exit(0);     }     L->next = NULL;                                 //空表长度为null     return 0; }  int LengthList(LinkList L)                    //计算链表长度 {     int length = 0;     LinkList p;     p = L->next;     while (p)     {         length++;         p = p->next;     }     return length; }  int GetElem(LinkList L, int i, Elemtype e)            //用e返回L中第i个元素值 {     LinkList p;                                     //初始化，p指向首元结点，计数器j=1     int j = 1;     p = L->next;                                    //顺序链表向后扫描，直到p为空或者p指向第i个元素     while (p && j < i)     {         p = p->next;                                //p指向下一个元素         ++j;     }     if (!p || j > i)                              //i不合法     {         printf(\"查询不到该元素！\\n\");         return 0;     }     e = p->data;     return 0; }   void CreateList_F(LinkList *L,int n)            //头插法创建一个单链表，n为要插入的元素个数 {     int i;     LinkList p;     (*L) = (LinkList)malloc(sizeof(LNode));     (*L)->next = NULL;     printf(\"请输入您要插入元素的个数：\");     scanf(\"%d\", &n);     printf(\"请输入你要插入的元素值(用空格隔开)：\");     for (i = n; i >0;--i)     {         p = (LNode*)malloc(sizeof(LNode));         //scanf_s(\"%d\", &p->data);         scanf(\"%d\", &p->data);         p->next = (*L)->next;         (*L)->next = p;     }  }  int InsertList_L(LinkList L, int i, Elemtype e)            //在L中第i个位置插入元素e {     LinkList p, s;     int j = 0;     p = L;     while (p && j < i)                                  //寻找第i-1结点     {         p = p->next;         ++j;     }     if (!p || j > i) exit(1);                         //i大于表长+1或者小于1     s = (LinkList)malloc(sizeof(LNode));               //生成新结点s     s->data = e;                                      //将结点的数据域置为e     s->next = p->next;                                 //将结点s插入L中     p->next = s;     return 0; }  int DeleteList_L(LinkList L, int i)                //删除L中第i个元素，并用e返回其值 {     LinkList p, q;     int j = 0;     p = L;     //printf(\"请输入要删除的结点位置：\");      while (p->next && j < i-1)                  //寻找第i个结点，并令p指向其前驱     {         p = p->next;         ++j;     }     if (!(p->next) || j > i) exit(1);            //删除位置不合理     q = p->next;                                 //临时保存被删除结点的地址以备释放     p->next = q->next;                           //改变删除结点的前驱结点指针域     free(q); //释放     return 0; }  void ShowList(LinkList L)                    //打印整个链表 {     LinkList p;     p = L->next;     if (p == NULL)     {         printf(\"这是一个空链表！\\n\");     }     printf(\"单链表\");     while (p)     {         printf(\" -> %d\", p->data);         p = p->next;     }     printf(\"\\n\"); }  //main() int main() {     LinkList L;     int n;     int i,k;     printf(\"单链表的操作：\\n\");     printf(\"\\t1.头插法建立单链表\\n\");     printf(\"\\t2.输出单链表\\n\");     printf(\"\\t3.删除结点\\n\");     printf(\"\\t4.退出\\n\");     do     {          printf(\"选择所需功能: \");         scanf(\"%d\",&k);         switch(k)         {             case 1:CreateList_F(&L, n);                    break;             case 2:printf(\"单链表为：\\n\");                    ShowList(L);                    break;              case 3:                    printf(\"请输入要删除的结点位置: \");                    scanf(\"%d\", &i);                    DeleteList_L( L, i);                    break;              case 4:printf(\"退出\");                    exit(0);             default:printf(\"输入错误\\n\");                     exit(0);         }     }while(1); } 供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "int InitList(LinkList L)                            {     L= (LinkList)malloc(sizeof(LNode));             //修改形参没有用处，离开这个函数形参就结束存在了     if (!L)                                              {         printf(\"分配内存失败！\\n\");         exit(0);     }     L->next = NULL;                                      return 0; }", "referer": "user-0"}]}
{"question": "初学者求解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你是不是编译了错误的.cpp文件呢？再检查一下，你现在编译的是那个文件？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "因为隔壁孩子犯错误你就要打自家孩子一顿？ 看清楚出错的是  源2 缺乏联系的独立程序不要都弄进一个项目，应单立项目，否则接下来还是有错。", "referer": "user-0"}]}
{"question": "DLL调用两个函数，一个函数中有while（1），如何实现在另一个函数中终止它", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "全局变量flag设一个", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "dll的导出函数，就相当于是一个函数功能，只不过封装了一下。 当我们的外部程序在调用dll的接口时，调用该接口的线程或进程，会等顺序执行接口函数的功能；所以，如果我们把while循环写在接口里，例如 void func() {     while(1)     {    ; } }  外部调用部分会一直等待while循环结束才继续往下执行。 这个时候，如果我们想终止这个接口的while循环，就需要另一个线程来做退出处理。 多种思路可解决，核心是多线程。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "楼主啊，你对多线程技术有多了解？ 想要编写 MFC 程序，就先要了解多线程技术的。 窗口程序，都会有消息循环和窗口绘制线程的。 楼主的程序出现的问题，应该是，开始循环的函数与结束循环的函数，他们两个的调用者，都是同一个线程了。 你想想看，先调用了一个函数，结果，里面死循环了，无法退出，那么，它怎么有机会调用下一个函数呢？ 要想实现楼主的那个思路，应该是，死循环的代码，要开启新的线程去执行，然后，主线程或者另外的线程来调用后面的函数，结束死循环。  楼主的想法很正确，设置 flag 结束循环，只是忽略了一点， C程序是面向函数的编程语言，一个函数没有返回或者抛出异常，它是无法再执行其他函数的（嵌套调用除外）。每一个线程就可以创建一个新的调用序列，这些调用序列是相对隔离的，如果多个线程调用的函数中，访问了相同的数据，那么，要注意线程安全的问题。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "不该说“为了照顾赵4老湿”；应该说“为了追求真理”。 这样才能显出高大上。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "最后给一下这个动态链接库的头文件。CSDN不允许连续三次回复，没办法只好等赵4老湿叽叽之后我再回复，哈哈。 // INCLUDE FILE generated by \"Pelles C for Windows, version 8.00\".  #ifndef _HELLOWD_H #define _HELLOWD_H  #ifdef _HELLOWD_ #define HELLOWDAPI  __declspec(dllexport) #else #define HELLOWDAPI  __declspec(dllimport) #endif /* _HELLOWD_ */  #ifndef WINAPI #define WINAPI  __stdcall #endif  HELLOWDAPI void HelloWorld (void); HELLOWDAPI void stopWhile (void);  #endif /* _HELLOWD_H */", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "while(1){} 通常用于守护或者轮询操作，运行权通常不高，只需要触发一个系统中断（ctrl-break）即可停止其运行。如果从另一个线程终止其运行，只需要从系统发一个停止运行指令即可。", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "我最后贴的代码不工作吗？ 我倒是没实际测试过。", "referer": "user-0"}, {"cid": "9", "user": "user-6", "content": "回楼上，没什么可讨论的，在CSDN混纯粹是瞎耽误工夫，不过还是发一下运行效果截图吧：", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "我都不太懂，只能默默的看大佬们讨论。", "referer": "user-0"}, {"cid": "11", "user": "user-6", "content": "引用 19 楼 赵4老师 的回复:我最后贴的代码不工作吗？ 我倒是没实际测试过。  为了照顾赵4老湿，特地写了一个使用POSIX线程的版本，而且用GCC编译就行。至于WIN32的版本，就不写了，用C写Windows程序太恶心，从赵老湿以往发的程序就能有切实感受。  ----------主程序文件 main.c --------- # include <stdio.h> # include <stdlib.h> # include <windows.h>  int main (int argc, char * argv []) {     typedef void (* PFUNC) (void);      HMODULE hMod = LoadLibrary (\"d:\\\\exampls\\\\hellowd\\\\hellowd.dll\");      if (hMod != NULL)     {         PFUNC HelloWorld = (PFUNC) GetProcAddress (hMod, \"HelloWorld\");         PFUNC stopWhile = (PFUNC) GetProcAddress (hMod, \"stopWhile\");          HelloWorld (); \t\tMessageBoxW (NULL, L\"单击“确定”停止DLL内的循环。\", L\"hi\", MB_OK);         stopWhile ();     }  \tgetchar ();            //故意添加的代码，以等待DLL内的线程运行结束。 } 编译方法（源字符集-finput-charset需改为你自己使用的字符集）： gcc gcc main.c -finput-charset=gbk -fwide-exec-charset=UTF-16LE    ----------动态链接库文件 hellowd.c --------- # include <stdio.h> # include <windows.h> # include <pthread.h>  BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {     switch (fdwReason)     {         case DLL_PROCESS_ATTACH://各分支内容从略         case DLL_THREAD_ATTACH:         case DLL_THREAD_DETACH:         case DLL_PROCESS_DETACH:             break;     }      return TRUE; }  int flag = 1, i = 0, c = 0;  void * thrd_proc (void * arg) {     pthread_detach (pthread_self ());      while (flag) printf (\"%d\", c ++);  \tMessageBox (0, \"The LOOP has been broken!\", \"Hi\", MB_ICONINFORMATION); \tprintf (\"The LOOP has been broken!\\n\");  \treturn 0; }  __declspec(dllexport) void HelloWorld (void) {     MessageBox (0,\"Hello World from DLL!\", \"Hi\", MB_ICONINFORMATION);  \tpthread_t t;     pthread_create (& t, NULL, thrd_proc, NULL); }  __declspec(dllexport) void stopWhile (void) {     flag = 0;     printf(\"flag = 0 OK.\\n\"); } 编译方法：（因为没有使用中文，不需要指定源字符集、执行字符集和宽字符集） gcc hellowd.c -shared -o hellowd.dll", "referer": "user-0"}, {"cid": "12", "user": "user-5", "content": "上贴代码最后多了一个}", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> #include <windows.h> #include <io.h> #include <process.h> CRITICAL_SECTION cs_log; int No_Loop=0; typedef void (*FUNT)(); FUNT HelloWorld; FUNT stopWhile; void testThread(void *pcn) {     int n,i;      n=(int)pcn;     i=0;     while (1) {         sleep_ms(1000);         EnterCriticalSection(&cs_log);         printf(\"in testThread %d:i==%ds\\n\",n,++i);         LeaveCriticalSection(&cs_log);         if (i>=5) {             No_Loop=1;             stopWhile();         }     } } int main(int argc,char * argv[]) {     HMODULE hMod = LoadLibrary(\"123.dll\");     if(hMod == NULL) return 1;      HelloWorld = (FUNT)GetProcAddress(hMod,\"HelloWorld\");     stopWhile = (FUNT)GetProcAddress(hMod,\"stopWhile\");      InitializeCriticalSection(&cs_log);      int i;     _beginthread((void(__cdecl *)(void *))testThread,0,(void *)1);     i=0;     while (1) {         Sleep(100);         EnterCriticalSection(&cs_log);         printf(\"in main:i==%d\\n\",++i);         LeaveCriticalSection(&cs_log);         HelloWorld();         if (No_Loop==1) break;//     }      DeleteCriticalSection(&cs_log);      return 0; }   }", "referer": "user-0"}, {"cid": "14", "user": "user-8", "content": "了解一下win32gui程序的构造", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "问题就是while(1)放子线程中的话主线程不是也要加while(1)，不然主线程结束子线程也没了", "referer": "user-0"}, {"cid": "16", "user": "user-9", "content": "起个线程来调用HelloWorld() 啊，这样就能往下走 调用stopWhile();", "referer": "user-0"}, {"cid": "17", "user": "user-10", "content": "引用 楼主 白牙丶 的回复:请教大佬们，DLL是自己写的，调用DLL的两个函数时在一个main函数下的，一个函数有while(1)，怎么用另一个函数终止它。举个例子 创建调用函数： /* Replace \"dll.h\" with the name of your header */ #include \"dll.h\" #include <stdio.h> #include <windows.h>  int flag = 1,i = 0;  //创建调用函数 DLLIMPORT void HelloWorld() { \tMessageBox(0,\"Hello World from DLL!\\n\",\"Hi\",MB_ICONINFORMATION); \t \twhile(flag) \t{ \t\ti++; \t} }  //创建调用函数 DLLIMPORT void stopWhile() { \tflag = 0; \tprintf(\"123\"); }   BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved) { \tswitch(fdwReason) \t{ \t\tcase DLL_PROCESS_ATTACH: \t\t{ \t\t\tbreak; \t\t} \t\tcase DLL_PROCESS_DETACH: \t\t{ \t\t\tbreak; \t\t} \t\tcase DLL_THREAD_ATTACH: \t\t{ \t\t\tbreak; \t\t} \t\tcase DLL_THREAD_DETACH: \t\t{ \t\t\tbreak; \t\t} \t} \t \t/* Return TRUE on success, FALSE on failure */ \treturn TRUE; }  调用： #include <stdio.h> #include <stdlib.h> #include <windows.h> /* run this program using the console pauser or add your own getch, system(\"pause\") or input loop */  int main(int argc, char *argv[]) { \ttypedef void (*FUNT)(); \ttypedef void (*FUNC)();  \tHMODULE hMod = LoadLibrary(\"123.dll\"); \tif(hMod != NULL) \t{ \t\t//printf(\"%s\\n\",\"success!!!\"); \t\tFUNT HelloWorld = (FUNT)GetProcAddress(hMod,\"HelloWorld\"); \t\tFUNT stopWhile = (FUNT)GetProcAddress(hMod,\"sendData\"); \t\t \t\tHelloWorld(); \t\tstopWhile(); \t} } 怎么用stopWhile去终止Helloworld  你的代码会一直执行Helloworld,根本就走不到stop去 不要把工作放在主线程，放到工作线程中去，这样才有机会去执行stop", "referer": "user-0"}, {"cid": "18", "user": "user-8", "content": "单线程你没机会结束它。多线程可以用信号量", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:while中加上退出条件，在另一个函数里修改这个条件，使条件满足退出while循环；但是程序运行不到下一个函数呀", "referer": "user-0"}, {"cid": "20", "user": "user-0", "content": "引用 2 楼 gouyanfen 的回复:FUNT stopWhile = (FUNT)GetProcAddress(hMod,\"sendData\");? dll导出函数名称代码呢？来个sendData别人不知道是不是stopWhile我错了 忘记修改了", "referer": "user-0"}]}
{"question": "关于赋值到结构体的问题，我没理解请指点下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你这打印的都是指针值", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢了，自信男孩，", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> #include <string.h>  struct DATA {     char Start[1];     char Address[4];     char Command[2];     char Date[6];     char StatusCode[1];     char Alarmcode[1]; } data;  int main() {     char b[] = {         0x02,         0x41, 0x43, 0x33, 0x32,         0x31, 0x36,         0x32, 0x31, 0x30, 0x34, 0x32, 0x36,         0x01,         0x07};     int i;     //memcpy((void *)&data, (const void *)&b[0], 1+4+2+6+1+1);     memcpy(&data, &b[0], 1+4+2+6+1+1);       printf(\"Start:%.2X\\n\", data.Start);     //printf(\"Address:%s\\n\", data.Address);     printf(\"Address:\");     for (i = 0; i < 4; i++)         putchar(data.Address[i]);     putchar(10);    //'\\n'     //printf(\"Command:%s\\n\", data.Command);     printf(\"Command:\");     for (i = 0; i < 2; i++)         putchar(data.Command[i]);     putchar(10);    //'\\n'     //printf(\"Date:%s\\n\", data.Date);     printf(\"Date:\");     for (i = 0; i < 6; i++)         putchar(data.Date[i]);     putchar(10);    //'\\n'     printf(\"StatusCode:%.2X\\n\", data.StatusCode[0]);     printf(\"Alarmcode:%.2X\\n\", data.Alarmcode[0]);  } 供参考～  拷贝没问题，问题在于用%s输出你得有'\\0'结束，申请4个字节，全用有效数值填充了，'\\0'在哪呢？  后两个code，既然定义了数组，那就应该用下表去访问值。", "referer": "user-0"}]}
{"question": "求解  各路大神帮帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include <stdio.h>  int isLeap(int y) {     if((y%4==0 && y%100!=0)||(y%400==0))         return 1;     else         return 0; }  int GetDaysOfMonth(int y, int m) {     int daysOfMonth[12] = {31,28,31,30,31,30,31,31,30,31,30,31};     if(isLeap(y) && m == 2) return daysOfMonth[m-1]+1;     return daysOfMonth[m-1]; }   int get_Week(int y,int m,int d) {     int week = 0;     if(m==1 || m == 2){        m += 12;        y--;     }     week=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;     return week; }  int main() {     int  year=0,month=0,day=0;     char week[][8]={\"星期一\",\"星期二\",\"星期三\",\"星期四\",\"星期五\",\"星期六\",\"星期日\"};     while (1){            if(scanf(\"%d%d%d\",&year,&month,&day)==EOF ||                     year==0 && month==0 && day==0)break;//ctrl+z 或 0 0 0 结束输入            if((day > GetDaysOfMonth(year,month)) || day<1 || month>12 || month<1 )               printf(\"Invalid date,input again!\\n\");            else               printf(\"%s\\n\",week[get_Week(year,month,day)]);     }          return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "//2000年元旦是星期六，求2000年后任意日期是星期几 #include <stdio.h> #include <stdlib.h> #include <string.h> int DaysOfMonthInNonLeapYear[12]={31,28,31,30,31,30,31,31,30,31,30,31}; int DaysOfMonthInLeapYear   [12]={31,29,31,30,31,30,31,31,30,31,30,31}; int isLeapYear(int y) {     if (y%400==0 || (y%4==0 && y%100!=0)) return 1;     else return 0; } int isValidDate(int y,int m,int d) {     if (!(2000<=y && y<=3000        &&    1<=m && m<=  12        &&    1<=d && d<=  31)) return 0;     if (isLeapYear(y)) {         if (!(1<=d && d<=DaysOfMonthInLeapYear[m-1])) return 0;     } else {         if (!(1<=d && d<=DaysOfMonthInNonLeapYear[m-1])) return 0;     }     return 1; } int main() {     int y,m,d,total_days,yy,mm,dd;     while (1) {         printf(\"Input YYYY-MM-DD(2000<=YYYY<=3000,01<=MM<=12,01<=DD<=31):\");         fflush(stdout);         rewind(stdin);         if (3==scanf(\"%4d-%2d-%2d\",&y,&m,&d)) {             if (isValidDate(y,m,d)) break;         }     }     total_days=0;     for (yy=2000;yy<=y-1;yy++) {         if (isLeapYear(yy)) { //          printf(\"yy:%d total_days:%d+366\\n\",yy,total_days);             total_days+=366;         } else { //          printf(\"yy:%d total_days:%d+365\\n\",yy,total_days);             total_days+=365;         }     }     for (mm=1;mm<m;mm++) {         if (mm==2) {             if (isLeapYear(y)) { //              printf(\"mm:%2d  total_days:%d+29\\n\",mm,total_days);                 total_days+=29;             } else { //              printf(\"mm:%2d  total_days:%d+28\\n\",mm,total_days);                 total_days+=28;             }         } else { //          printf(\"mm:%2d  total_days:%d+DaysOfMonthInNonLeapYear[mm:%d-1]:%d\\n\",mm,total_days,mm,DaysOfMonthInNonLeapYear[mm-1]);             total_days+=DaysOfMonthInNonLeapYear[mm-1];         }     } //  printf(\"total_days:%d+d:%d\\n\",total_days,d);     total_days+=d; //  printf(\"total_days:%d\\n\",total_days);     total_days+=4;     printf(\"%d\\n\",total_days%7+1);      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include <stdio.h>   const int gmonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};  int is_leap(int year); void print_week_day(int day);  int main(void) {     int day, month, year;     int total = 0, week_day, i;      scanf(\"%d%d%d\", &year, &month, &day);      if (year < 2000)         return -1;      for (i = 2000; i < year; i++) {         if (is_leap(i))             total += 1;     }     total += 365 * (year - 2000);      if (is_leap(year) && month > 2)         total += 1;      for (i = 0; i < month - 1; i++)         total += gmonth[i];      total += (day-1);      printf(\"total days = %d\\n\", total);      week_day = (total+6) % 7;      print_week_day(week_day);     //printf(\"week day is %d\\n\", (6 + week_day) % 7);   }  void print_week_day(int day) {     switch (day % 7) {         case 0:             printf(\"Sunday\\n\");             break;          case 1:             printf(\"Monday\\n\");             break;          case 2:             printf(\"Tuesday\\n\");             break;          case 3:             printf(\"Wednesday\\n\");             break;          case 4:             printf(\"Thursday\\n\");             break;          case 5:             printf(\"Friday\\n\");             break;          case 6:             printf(\"Saturday\\n\");             break;     } }  int is_leap(int year) {     if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))         return 1;      return 0; }  供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "首先笨方法： 2000年元旦是星期六,每加7天为一个循环，到xxxx年任意一天，假设共计天数nDay天，就是  nDay/7  取整  个7，再加余数k 天，所以xxxx年任意一天就是 (星期六 + k) % 7。  网上查到的方法： 引用： https://www.bilibili.com/read/cv8560725", "referer": "user-0"}]}
{"question": "请问有没有做过通信模块 AT指令 数据发送 和 解析的大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 赵4老师 的回复:[quote=引用 6 楼 lyy26655 的回复:][quote=引用 2 楼 赵4老师 的回复:]了解一下有限状态自动机  您好 去用了状态机 真的牛逼 大幅缩短了等待时间 没有用到delay_ms 感谢 目前调试了大半 还算顺利[/quote] 听大神一句话，胜读十年书，胜写1000行代码，胜调试10000行代码！ [/quote]  哈哈哈哈哈感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 6 楼 lyy26655 的回复:[quote=引用 2 楼 赵4老师 的回复:]了解一下有限状态自动机  您好 去用了状态机 真的牛逼 大幅缩短了等待时间 没有用到delay_ms 感谢 目前调试了大半 还算顺利[/quote] 听大神一句话，胜读十年书，胜写1000行代码，胜调试10000行代码！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:了解一下有限状态自动机  您好 去用了状态机 真的牛逼 大幅缩短了等待时间 没有用到delay_ms 感谢 目前调试了大半 还算顺利", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:了解一下有限状态自动机  好的，谢谢您", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 xws245925587 的回复:串口接收到的数据，丢进循环fifo里，然后主线程一直去读fifo，然后做字符协议解析，这种模块的通讯都有固定格式的，一般是以\\r\\n结尾的  感谢您，看了一些资料感觉还是需要一个专门的框架去解析", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "了解一下有限状态自动机", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "串口接收到的数据，丢进循环fifo里，然后主线程一直去读fifo，然后做字符协议解析，这种模块的通讯都有固定格式的，一般是以\\r\\n结尾的", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "用for循环怎么编，我一脸懵", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "找规律，行数和行号，空格的个数与行号的关系；把这些理清楚了，就好写了吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include<stdio.h>  int main() {     int i,j,n=6;     //scanf(\"%d\",&n);     for(i=0;i<n;i++)     {         for(j=0;j<i+1;j++)             printf(\" \");         for(j=0;j<n;j++)             printf(\"%c\",i%2==0?'#':'*');         printf(\"\\n\");     }         return 0; }", "referer": "user-0"}]}
{"question": "7-4 银行业务队列简单模拟 (25 分)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "7-1 简单计算器 (25 分)本题要求你为初学数据结构的小伙伴设计一款简单的利用堆栈执行的计算器。如上图所示，计算器由两个堆栈组成，一个堆栈 S1,存放数字，另一个堆栈 S2,存放运算符。计算器的最下方有一个等号键，每次按下这个键，计算器就执行以下操作：从 S1中弹出两个数字，顺序为 n1和 n2；从 S2 中弹出一个运算符 op；执行计算 n2op n1；将得到的结果压回 S1。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include<stdio.h> #include<malloc.h> #include<stdlib.h> int main() {     int A[1000];     int B[1000];     int N;     int a=0, b=0, temp;     scanf(\"%d\", &N);     for(int i=0; i<N; i++){         scanf(\"%d\", &temp);         if(temp % 2 == 1)             A[a++] = temp;         else             B[b++] = temp;     }     int i = 0, j = 0;     if(a > 1){//A有超过两个人，输出两个         printf(\"%d %d\", A[0], A[1]);         i = 2;     }     else if(a > 0)//A有超过一个人，输出一个         printf(\"%d\", A[i++]);     else if(b > 0)//A没人，B有人，输出B一个         printf(\"%d\", B[j++]);       if(j == 0)//输出了A没输出B，输出一个B来控制输出一组         printf(\" %d\", B[j++]);          while(i < a && j < b){         if(i+1 < a){             printf(\" %d %d\",A[i], A[i+1]);             i += 2;         }         else             printf(\" %d\", A[i++]);         printf(\" %d\", B[j++]);     }     while(i < a)         printf(\" %d\", A[i++]);     while(j < b)         printf(\" %d\", B[j++]); }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include<stdlib.h> #include<stdio.h>  void Print(int);  int main() {     int n;     scanf(\"%d\",&n);     int a[1001];     for(int k=0; k<n; k++)      {         scanf(\"%d\",&a[k]);     }     int i=0,j=0;     while(i<n||j<n)      {         for(; i<n; i++)             if(1==a[i]%2)              {                               Print(a[i++]);                 break;             }         for(; i<n; i++)          {             if(1==a[i]%2)              {                 Print(a[i++]);                 break;             }         }         for(; j<n; j++)          {             if(0==a[j]%2)              {                 Print(a[j++]);                break;             }         }     }      return 0; } void Print(int num) {     static int flag=0;     if(flag) printf(\" \");     else flag=1;       printf(\"%d\",num);  }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "#include<stdio.h> #include<stdlib.h> #define MAX 1000 #define error -1 typedef struct node {     int customer[MAX];     int rear;     int front; }queue; void add(queue* q, int item) {     if ((q->rear + 1) % MAX == q->front)     {         printf(\"队列满\\n\");         return;     }     q->rear = (q->rear + 1) % MAX;     q->customer[q->rear] = item; } int isempty(queue* q) {     return q->front == q->rear; } int deleteq(queue* q) {     if (isempty(q))     {         printf(\"队空\\n\");         return error;     }     q->front = (q->front + 1) % MAX;     return q->customer[q->front]; } void initial(queue* q) {     q->rear = q->front = 0; } int main() {     int N, i, number, flag;     queue A, B;     initial(&A);     initial(&B);     scanf(\"%d\", &N);     for (i = 0; i < N; i++)     {         scanf(\"%d\", &number);         if (number % 2)//奇数存入A             add(&A, number);         else             add(&B, number);//偶数存入B     }     flag = 0;//标记第一个顾客     while (!isempty(&A) && !isempty(&B))//A与B都非空时间隔输出     {         if (flag==0)         {             printf(\"%d\", deleteq(&A));             flag = 1;         }         else             printf(\" %d\", deleteq(&A));         if (!isempty(&A))             printf(\" %d\", deleteq(&A));         printf(\" %d\", deleteq(&B));     }     while (!isempty(&A))     {         if (flag==0)         {             printf(\"%d\", deleteq(&A));             flag = 1;         }         else             printf(\" %d\", deleteq(&A));     }     while (!isempty(&B))     {         if (!flag)         {             printf(\"%d\", deleteq(&B));             flag = 1;         }         else             printf(\" %d\", deleteq(&B));     }     printf(\"\\n\"); }", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "int InitQueue(SqQueue &Q) {     Q.base=new int[MAXSIZE];     if(!Q.base)         return OVERFLOW;     Q.front=Q.rear=0;     return OK; } int DeQueue(SqQueue &Q,int &e) {     if(Q.front==Q.rear)         return ERROR;     e=Q.base[Q.front];     Q.front=(Q.front+1)%MAXSIZE;     return OK; } void Print(int *arr,int n) {     cout<<arr[0];     for(int i=1;i<n;i++)         cout<<\" \"<<arr[i]; }", "referer": "user-0"}]}
{"question": "关于连续k进制输出的一段代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 qzjhjxj 的回复:供参考：#include <stdio.h> #include <string.h> #define exchange(a,b) t=a,a=b,b=t char t; void change(char a[]) {     int start=0,end;     int len;     len=strlen(a);     end=len-1;     while(start<end)     {         exchange(a[start],a[end]);         start++;         end--;     } } void reprintf(char a[],int len) {     len--;     while(len >= 0)         printf(\"%c\",a[len--]);     printf(\"\\n\"); } void main() {     char n[128];     gets(n);           // 123456789     int m,k;           // 10 3     scanf(\"%d%d\",&k,&m);     int s;     change(n);        //将输入字符串数n高低位逆序，低位排在前，高位在后 987654321     for(s=0; s<m; s++)//数n之后的m个数，这里m=3     {         int carry = 1;//数n之后的m个数，初始都是在原数上 +1         int pos = 0;  //数位游标从0位开始         while(n[pos])//从低位9开始，直到字符串数组n结束 =='\\0'  987654321'\\0'         {             n[pos]+=carry;     //低位 9 先加1             if(n[pos] == '0' + k) //如果到达进制数k值,这里k是int型，n[0]为char型，将k转为字符型+'0'             {                 n[pos]= '0'; //n[pos]归零                 carry = 1;   //进位为1             }             else             {                 carry=0;//没有进位，进位为0             }             pos++;  //下一位数值 8         }         if(carry)   //如果最后进位为1，在最高位置1             n[pos++]= '1';         n[pos] =0;  //在n尾部写入字符串结束标志  097654321'\\0'          reprintf(n,pos);//将字符串n数组逆序输出 123456790     } }  //123456789  //10 3 //987654321 //123456790 //123456791 //123456792 //请按任意键继续. . . 写的很详细，已经看懂啦，谢谢！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2 的回复:就是把输入的字符串先左右反过来，目的是为了方便它进位变长。 然后加一的操作当然是要加在原本的最低位也就是“个位”上，然而现在它在最左端，下标最小那个。 加法逢k进一呀，carry就是进位那个1，往高位上加，现在就是往下一位上加。 pos就没什么了，你就当他是循环变量i就好了。谢谢，懂了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "供参考：#include <stdio.h> #include <string.h> #define exchange(a,b) t=a,a=b,b=t char t; void change(char a[]) {     int start=0,end;     int len;     len=strlen(a);     end=len-1;     while(start<end)     {         exchange(a[start],a[end]);         start++;         end--;     } } void reprintf(char a[],int len) {     len--;     while(len >= 0)         printf(\"%c\",a[len--]);     printf(\"\\n\"); } void main() {     char n[128];     gets(n);           // 123456789     int m,k;           // 10 3     scanf(\"%d%d\",&k,&m);     int s;     change(n);        //将输入字符串数n高低位逆序，低位排在前，高位在后 987654321     for(s=0; s<m; s++)//数n之后的m个数，这里m=3     {         int carry = 1;//数n之后的m个数，初始都是在原数上 +1         int pos = 0;  //数位游标从0位开始         while(n[pos])//从低位9开始，直到字符串数组n结束 =='\\0'  987654321'\\0'         {             n[pos]+=carry;     //低位 9 先加1             if(n[pos] == '0' + k) //如果到达进制数k值,这里k是int型，n[0]为char型，将k转为字符型+'0'             {                 n[pos]= '0'; //n[pos]归零                 carry = 1;   //进位为1             }             else             {                 carry=0;//没有进位，进位为0             }             pos++;  //下一位数值 8         }         if(carry)   //如果最后进位为1，在最高位置1             n[pos++]= '1';         n[pos] =0;  //在n尾部写入字符串结束标志  097654321'\\0'          reprintf(n,pos);//将字符串n数组逆序输出 123456790     } }  //123456789  //10 3 //987654321 //123456790 //123456791 //123456792 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你看不懂大约是因为carry搞了个兼职，每次整体加一加到最低位上，这个1也由它表达了，反正最低位没有下面进上来的，闲着也是闲着。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "就是把输入的字符串先左右反过来，目的是为了方便它进位变长。 然后加一的操作当然是要加在原本的最低位也就是“个位”上，然而现在它在最左端，下标最小那个。 加法逢k进一呀，carry就是进位那个1，往高位上加，现在就是往下一位上加。 pos就没什么了，你就当他是循环变量i就好了。", "referer": "user-0"}]}
{"question": "C语言有关链表结点数据存储的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先读取文本，然后解析，创建节点，存放在单词或标点；", "referer": "user-0"}]}
{"question": "请问 关于c 语言 如何解析 32 bits floating point IEEE format 如下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#pragma warning(disable:4996 4838) //开头加这句或项目、属性、配置属性、C/C++、预处理器、预处理器定义中添加“_CRT_SECURE_NO_WARNINGS”  #include <stdio.h>  #include <string.h>  #include <malloc.h>  #include <stdlib.h>  #pragma pack(push)  #pragma pack(1)  struct CHANNEL {      short int Stat;      float Data;  };  struct DATA {      char Start;      char Address[4];      char Command[2];      char BinaryBlocSize[2];      char StartChannel;      unsigned char NumberOfChannel;      struct CHANNEL *Channel;  } data;  #pragma pack(pop)  void swapbyte(char *a,char *b) {      char t;      t=*a;*a=*b;*b=t;  }  int main() {      char b[]={          0x1B,          0x41,0x46,0x32,0x32,          0x32,0x34,          0x00,0x2C,          0x01,          0x07,            0x02,0x00,          0xBD,0xD6,0xD4,0x57,            0x02,0x00,          0x43,0xF5,0x14,0x03,            0x02,0x00,          0x43,0x18,0x48,0x9B,            0x02,0x00,          0x44,0x77,0xAF,0xE5,            0x02,0x00,          0x41,0xA0,0x21,0x12,            0x02,0x00,          0x42,0x48,0x02,0xAB,            0x02,0x00,          0x45,0x24,0x5B,0x7C,            0x41,0x36,          0x03};      memcpy((void *)&data,(const void *)&b[0],1+4+2+2+1+1);      int NBC=(int)(data.NumberOfChannel);      printf(\"NBC:%d\\n\",NBC);      printf(\"sizeof(struct CHANNEL):%d\\n\",sizeof(struct CHANNEL));      data.Channel=(struct CHANNEL *)malloc(NBC*sizeof(struct CHANNEL));      memcpy((void *)(data.Channel),(const void *)&b[1+4+2+2+1+1],NBC*sizeof(struct CHANNEL));      for (int i=0;i<NBC;i++) {          swapbyte(0+(char *)&(data.Channel[i].Data),3+(char *)&(data.Channel[i].Data));          swapbyte(1+(char *)&(data.Channel[i].Data),2+(char *)&(data.Channel[i].Data));      }      for (int i=0;i<NBC;i++) {          printf(\"%d %hd %f\\n\",i,data.Channel[i].Stat,data.Channel[i].Data);      }      free(data.Channel);      return 0;  }  //NBC:7  //sizeof(struct CHANNEL):6  //0 2 -0.104897  //1 2 490.156342  //2 2 152.283615  //3 2 990.748352  //4 2 20.016148  //5 2 50.002605  //6 2 2629.717773  //", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "typedef union {     float a;     char b[4]; } Packet;  Packet packet;  float IEEE2Float(const unsigned int NumFloat32) {     unsigned char i = 0;     unsigned long int Temp32;     float f_Temp;      Temp32 = NumFloat32; // ;     for (int i = 0; i < 4; i++)     {         packet.b[i] = (unsigned char)(Temp32 >> (i * 8));     }     f_Temp = packet.a;     printf(\"%.3f\\n\", f_Temp);     return f_Temp; }  调用 IEEE2Float(0xBDD1F210); 得到是 -0.103   这个值是正确的  0200  是分隔符号，  BDD1F210 = -0.10251247882843018 43F6AB0B =493.336273193  4318540D =152.3283233642578 4477AF9D =990.74395752 41A0201E =20.015682220458984 424804DB =50.0047416687 452464CC=2630.2998046875 计算是这么计算的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "恩，直接拷贝到float变量里就可以了。memcpy可以试一下～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "直接截取，然后拷贝到一个float里面", "referer": "user-0"}]}
{"question": "萌新有个关于补码方面的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "各位 我懂了 异号补码相减可能会溢出 所以结果会出现错误", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "正数补码及本身，负数补码为取反加1，所以你的式子不全对", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你一点都不提背景和代码，所以没法对症下药。 只能说，设计补码这种东西就是为了程序员省心的，所以大概率是你想多了。", "referer": "user-0"}]}
{"question": "c语言中visual studio中用fopen打不开文件", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 qzjhjxj 的回复:修改如下，供参考：#include<stdio.h> #include<stdlib.h> #include<string.h>  void copyFile(char infile[],char outfile[]) {      FILE *fp1,*fp2;      char line[256];      if((fp1=fopen(infile,\"r\"))==NULL){         printf(\"Can't open file %s!\\n\",infile);         exit(1);      }      if((fp2=fopen(outfile,\"w\"))==NULL){         printf(\"Can't open file %s!\\n\",outfile);         exit(2);      }      while(fgets(line,100,fp1)!=NULL){          puts(line);          fputs(line,fp2);      }      fclose(fp1);      fclose(fp2); }   int main() {                          //FILE *fp1,*fp2;      char infile[30],outfile[30];                          //char *p=infile;                          //char *q=outfile;                         //int  i;      printf(\"请输入需要读取的文件名:\");      gets(infile);                         //for(i=0;p<infile+30;p=p+i,i++){                         //    if(*p=='\\n')*p='\\0';                         //}      printf(\"请输入输出的文件名:\");      gets(outfile);                        //for(i=0;q<outfile+30;q=q+i,i++){                        //    if(*q=='\\n')*q='\\0';                        //}                        //printf(\"需要读取的文件名为:%s\",infile);                        //putchar('\\n');      copyFile(infile,outfile);                        //fclose(fp1);                        //fclose(fp2);            return 0; } 使用fputs函数会引入额外的'\\n'，因为fgets会有'\\n'，而fputs又会加'\\n'", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 3 楼 qzjhjxj 的回复:修改如下，供参考：#include<stdio.h> #include<stdlib.h> #include<string.h>  void copyFile(char infile[],char outfile[]) {      FILE *fp1,*fp2;      char line[256];      if((fp1=fopen(infile,\"r\"))==NULL){         printf(\"Can't open file %s!\\n\",infile);         exit(1);      }      if((fp2=fopen(outfile,\"w\"))==NULL){         printf(\"Can't open file %s!\\n\",outfile);         exit(2);      }      while(fgets(line,100,fp1)!=NULL){          puts(line);          fputs(line,fp2);      }      fclose(fp1);      fclose(fp2); }   int main() {                          //FILE *fp1,*fp2;      char infile[30],outfile[30];                          //char *p=infile;                          //char *q=outfile;                         //int  i;      printf(\"请输入需要读取的文件名:\");      gets(infile);                         //for(i=0;p<infile+30;p=p+i,i++){                         //    if(*p=='\\n')*p='\\0';                         //}      printf(\"请输入输出的文件名:\");      gets(outfile);                        //for(i=0;q<outfile+30;q=q+i,i++){                        //    if(*q=='\\n')*q='\\0';                        //}                        //printf(\"需要读取的文件名为:%s\",infile);                        //putchar('\\n');      copyFile(infile,outfile);                        //fclose(fp1);                        //fclose(fp2);            return 0; }   while(fgets(line, sizeof(line),fp1)!=NULL) 改一下～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "大概率是路径不对，你访问的文件不在你以为的位置。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "修改如下，供参考：#include<stdio.h> #include<stdlib.h> #include<string.h>  void copyFile(char infile[],char outfile[]) {      FILE *fp1,*fp2;      char line[256];      if((fp1=fopen(infile,\"r\"))==NULL){         printf(\"Can't open file %s!\\n\",infile);         exit(1);      }      if((fp2=fopen(outfile,\"w\"))==NULL){         printf(\"Can't open file %s!\\n\",outfile);         exit(2);      }      while(fgets(line,100,fp1)!=NULL){          puts(line);          fputs(line,fp2);      }      fclose(fp1);      fclose(fp2); }   int main() {                          //FILE *fp1,*fp2;      char infile[30],outfile[30];                          //char *p=infile;                          //char *q=outfile;                         //int  i;      printf(\"请输入需要读取的文件名:\");      gets(infile);                         //for(i=0;p<infile+30;p=p+i,i++){                         //    if(*p=='\\n')*p='\\0';                         //}      printf(\"请输入输出的文件名:\");      gets(outfile);                        //for(i=0;q<outfile+30;q=q+i,i++){                        //    if(*q=='\\n')*q='\\0';                        //}                        //printf(\"需要读取的文件名为:%s\",infile);                        //putchar('\\n');      copyFile(infile,outfile);                        //fclose(fp1);                        //fclose(fp2);            return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "文件名输类似d:\\mydir\\filename.ext这样的全路径", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "30改为256", "referer": "user-0"}]}
{"question": "不知道要怎么做，希望大佬给个答案，我再来学习学习。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Linux：    <Ctrl+D>  Windows：    <Enter>、<Ctrl+Z>、<Enter>", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "前来观摩观摩", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "# include <stdio.h>  # define N 5  void woo (int a []) {     static int g = 0;      if (g ++ < N) scanf (\"%d\", a), woo (a + 1);     else return;      printf (\"%d \", * a); }  int main (void) {     woo ((int [N]){0}); //需要使用支持C99的编译器 }", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "#include <stdio.h>  #define N 250  int main (void) {     int a [N], * p = a;      while (p < a + N && scanf (\"%d\", p++) == 1)         ;     p--;     while (--p >= a) printf (\"%d \", * p); } 供参考～  终止输入，LINUX用ctrl +d，Windows下用ctrl+z", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 6 楼 均陵鼠侠的回复:# include <stdio.h>  # define N 5  int main (void) {     int a [N], * p = a;     while (p < a + N) scanf (\"%d\", p ++);     while (-- p >= a) printf (\"%d \", * p); } 额，编译错误。。", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "1 2 3 -2 -6^Z -6 -2 3 2 1 请按任意键继续. . .", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "# include <stdio.h>  # define N 5  int main (void) {     int a [N], * p = a;     while (p < a + N) scanf (\"%d\", p ++);     while (-- p >= a) printf (\"%d \", * p); }", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "输入完数字后，想退出，按下CTRL键+Z键，再按回车。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 3 楼 user-6的回复:[quote=引用 2 楼 m0_53683570 的回复:][quote=引用 1 楼 user-6的回复:]供参考：#include<stdio.h> #define N 50  int main() {      int a[N],*p=a,i=0;      while(scanf(\"%d\",&a[i++])!=EOF && i<N);//ctrl+z 结束输入      for(p=p+i-2;p>=a;p--)          printf(\"%d \",*p);      printf(\"\\n\");            return 0; } 为什么一直显示格式错误，我应该没打错[/quote]格式错误，应该是语法上有错误。左上角复制代码，粘贴到编译器里看看。[/quote] 编译器里面为什么输入完数字后换行他没有输出?是没退出循环吗？。。不知道为什么退不出来，", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "引用 2 楼 m0_53683570 的回复:[quote=引用 1 楼 user-6的回复:]供参考：#include<stdio.h> #define N 50  int main() {      int a[N],*p=a,i=0;      while(scanf(\"%d\",&a[i++])!=EOF && i<N);//ctrl+z 结束输入      for(p=p+i-2;p>=a;p--)          printf(\"%d \",*p);      printf(\"\\n\");            return 0; } 为什么一直显示格式错误，我应该没打错[/quote]格式错误，应该是语法上有错误。左上角复制代码，粘贴到编译器里看看。", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 1 楼 user-6的回复:供参考：#include<stdio.h> #define N 50  int main() {      int a[N],*p=a,i=0;      while(scanf(\"%d\",&a[i++])!=EOF && i<N);//ctrl+z 结束输入      for(p=p+i-2;p>=a;p--)          printf(\"%d \",*p);      printf(\"\\n\");            return 0; } 为什么一直显示格式错误，我应该没打错", "referer": "user-0"}, {"cid": "14", "user": "user-6", "content": "供参考：#include<stdio.h> #define N 50  int main() {      int a[N],*p=a,i=0;      while(scanf(\"%d\",&a[i++])!=EOF && i<N);//ctrl+z 结束输入      for(p=p+i-2;p>=a;p--)          printf(\"%d \",*p);      printf(\"\\n\");            return 0; }", "referer": "user-0"}]}
{"question": "遇到难题了，没一点想法，希望大佬帮忙看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fgets，读取一行，遇到回车返回。  也可以用循环判断'\\n'字符；  while ((ch = getchar()) != '\\n')     ;", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include<stdio.h> int main() {     int n=0,m=0;     while(scanf(\"%d%d\",&n,&m)!=EOF && (getchar()!='\\n'));//输入ctrl+z 或 回车 结束输入     printf(\"n=%d,m=%d\\n\",n,m);          return 0; }", "referer": "user-0"}]}
{"question": "取消对NULL指针的引用怎么解决？？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "试了一下，成功了，感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "修改如下，供参考：#include\"stdio.h\" #include\"malloc.h\" typedef char ElemType; typedef struct Node {         ElemType data;         struct Node* next; }LinkNode;  void CreateList(LinkNode** L, ElemType a[], int n)//头插法建立单链表 {         LinkNode* s,*p;         int i;         *L = (LinkNode*)malloc(sizeof(LinkNode));         (*L)->next = NULL;  //L->next = 0;         p = *L;         for (i = 0; i < n; i++)         {                  s = (LinkNode*)malloc(sizeof(LinkNode));                  s->data = a[i];                  s->next = p->next;                  p->next = s;         } } void InitList(LinkNode **L)//初始化 {         *L = (LinkNode*)malloc(sizeof(LinkNode));         (*L)->next = NULL; //L->next = 0; } ElemType Get(LinkNode* L, int i) //查找第i个结点的值 {         int j = 0;         LinkNode* p = L;         while (j < i && p!= NULL)         {                  p = p->next;                  j++;         }         if (i == j)                  return p->data;         else                  return 0; } int Locate(LinkNode* L, ElemType key)//查找结点值等于key的结点 {         LinkNode* p;         int i = 1;         p = L->next;         while (p)//(p != 0)         {                  if (p->data != key)                      p = p->next;                  else                      break;                  i++;         }         return i; } int Insert(LinkNode** L, int i, ElemType x)//插入 {         LinkNode* p = *L, * s;         int j = 0;         if (i <= 0)                  return 0;         while (j < i - 1 && p != NULL)         {                  p = p->next;                  j++;         }         if(p==NULL)//if (p == 0)                  return 0;         else         {                  s = (LinkNode*)malloc(sizeof(LinkNode));                  s->data = x;                  s->next = p->next;                  p->next = s;                  return 1;         } } int Delete(LinkNode* L, int i, ElemType e)//删除 {         LinkNode* p = L, * q;         int j = 0;         while (j < i - 1 && p != 0)         {                  p = p->next;                  j++;         }         if (p == NULL) //(p == 0)                  return 0;         else         {                  q = p->next;                  if (q == NULL)  //(q == 0)                          return 0;                  e = q->data;                  p->next = q->next;                  free(q);                  return 1;         } } void Disp(LinkNode* L)//输出单链表 {         LinkNode* p = L->next;         while (p)  //(p != 0)         {                  printf(\" %c \", p->data);                  p = p->next;         }         printf(\"\\n\"); } int main() {         int x = 1;         LinkNode* h, a;         ElemType e = 1;         h = &a;         printf(\"单链表基本运算如下: \\n\");         printf(\"  (1)初始化\\n\");         InitList(&h);          printf(\"  (2)插入元素a,b,c,d\\n\");         Insert(&h, 1, 'a');         Insert(&h, 2, 'b');         Insert(&h, 3, 'c');         Insert(&h, 4, 'd');         printf(\"  (3)输出链表: \");         Disp(h);          printf(\"  (4)定位\\n\");         printf(\"    定位第%d个结点的值为：%c\\n\",2,Get(h, 2));                  printf(\"  (5)查找\\n\");         printf(\"    查找%c的结点位置：%d\\n\",'c',Locate(h, 'c'));           printf(\"  (6)插入\\n\");         Insert(&h, 4, 'x');         Disp(h);          printf(\"  (7)删除\\n\");         Delete(h, 3, e);         Disp(h);                   return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2的回复:及时让它别NULL。 那怎么改呢？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "及时让它别NULL。", "referer": "user-0"}]}
{"question": "c 关于union结构指针内存释放问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我先以为不可能是double free的，一直以为是corruption (out)， 最后用gdb一点一点调试才发现是double free的问题。 3楼说的对，申请内存http的内存后，email也指向的http的内存，所以不为NULL了，造成了double free.", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "struct a{ ... union { int *x; double *y; } temp; } haha,*pp=&haha; ... pp->temp.x=malloc(sizeof(int)*100); //correct using of x // pp->x=... ;  // incorrect using of x ... free(pp->temp.x);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 1 楼 自信男孩 的回复:两次释放了，看到是double free了。     union {         struct http_context *http;         struct email_context *email;         //TODO ftp smb     }; 这样定义，没有名字，你怎么访问http和email呢？ 你是不是对email已经释放一次了？http和email共用空间，你把申请的空间放在http中，其实email放的是相同的内容。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你是不是其他地方有free(tuple->email)啊？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "两次释放了，看到是double free了。     union {         struct http_context *http;         struct email_context *email;         //TODO ftp smb     }; 这样定义，没有名字，你怎么访问http和email呢？", "referer": "user-0"}]}
{"question": "如何在外部中断while(1)循环？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "按Ctrl+Break键", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的这个函数是在while(1)里吗？如果是可以考虑满足条件时，break出； 如果不在while(1)里，那么就需要其他线程（进程）里调用这个函数，可以考虑写一个变量值，在while(1)判断某个变量值break；出～", "referer": "user-0"}]}
{"question": "刚学指针，还不怎么会用，希望大佬帮帮忙，我运行时输入后没有输出，希望大佬能告诉我为什么?给个正确答案更好", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 m0_53683570 的回复:我写的程序为什么退不出来，能解释一下吗？不是输入换行就会退出吗？ scanf的返回值不会等于'\\n'，看一下scanf的返回值你就知道了：  return the number of input items successfully matched and assigned, which can be fewer than provided for, or even        zero in the event of an early matching failure. return the number of input items successfully matched and assigned, which can be fewer than provided for, or even        zero in the event of an early matching failure. 这是scanf返回值的描述，可以参考一下～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "我写的程序为什么退不出来，能解释一下吗？不是输入换行就会退出吗？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 1 楼 自信男孩 的回复:没有输出的原因是还没有从while循环中退出来，即while是当=='\\n'时退出；  修改一下  #include <stdio.h>  #define MAX_ARR_SIZE    (50) int main(void) {     int array[MAX_ARR_SIZE], *p;      int i = 0;      while (i < MAX_ARR_SIZE && scanf(\"%d\", &array[i++]) == 1)         ;      p = array + i - 2;      for (; p >= array; p--)         printf(\"%d\\n\", *p);      return 0; } 供参考～  #include <stdio.h>  #define MAX_ARR_SIZE    (50) int main(void) {     int array[MAX_ARR_SIZE], *p;      int i = 0;      p = array;     while (p < array + MAX_ARR_SIZE && scanf(\"%d\", p++) == 1)         ;      //p = array + i - 2;      for (p = p - 2; p >= array; p--)         printf(\"%d\\n\", *p);      return 0; } 供参考～ 终止输入的方式Linux用ctrl+d，Windows用ctrl+z", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "没有输出的原因是还没有从while循环中退出来，即while是当=='\\n'时退出；  修改一下  #include <stdio.h>  #define MAX_ARR_SIZE    (50) int main(void) {     int array[MAX_ARR_SIZE], *p;      int i = 0;      while (i < MAX_ARR_SIZE && scanf(\"%d\", &array[i++]) == 1)         ;      p = array + i - 2;      for (; p >= array; p--)         printf(\"%d\\n\", *p);      return 0; } 供参考～  #include <stdio.h>  #define MAX_ARR_SIZE    (50) int main(void) {     int array[MAX_ARR_SIZE], *p;      int i = 0;      p = array;     while (p < array + MAX_ARR_SIZE && scanf(\"%d\", p++) == 1)         ;      //p = array + i - 2;      for (p = p - 2; p >= array; p--)         printf(\"%d\\n\", *p);      return 0; } 供参考～", "referer": "user-0"}]}
{"question": "c语言编程", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "C# 语法问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 zhangm_tt 的回复:[quote=引用 1 楼 真的小白啊的回复:]相当于同时声明一个变量  if (value is int) {      int i = value; }   哦，好像明白了，if（e.control is IStyleInterface ctrl）这句话，就理解为if（e.control is IStyleInterface）｛IStyleInterface ctrl= e.control as IStyleInterface｝ 对吗？[/quote]  是的", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 真的小白啊的回复:相当于同时声明一个变量  if (value is int) {      int i = value; }   哦，好像明白了，if（e.control is IStyleInterface ctrl）这句话，就理解为if（e.control is IStyleInterface）｛IStyleInterface ctrl= e.control as IStyleInterface｝ 对吗？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 真的小白啊的回复:相当于同时声明一个变量  if (value is int) {      int i = value; }   那这句话无法理解啊！如果value是int类型，就返回一个刚定义的i值，不明白", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "相当于同时声明一个变量  if (value is int) {      int i = value; }", "referer": "user-0"}]}
{"question": "这个运行结果为什么是错的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 weixin_56874565 的回复:为啥要定义x=0？ 初始化，不然是一个随机值，如果是随机值正好为'\\n'那岂不是一次也不执行了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "为啥要定义x=0？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include<stdio.h> //void main() int main() {     int a=0,b=0,c=0,d=0;     char x = 0;     while(x!='\\n')     {         x=getchar();         if((x<='z'&&x>='a')||('A'<=x&&x<='Z'))             a++;         else if(x>='0'&&x<='9')             b++;         else if(x==' ')             c++;         else             d++;     }     //printf(\"a=%d,b=%d,c=%d,e=%d\\n\",&a,&b,&c,&d);     printf(\"a=%d,b=%d,c=%d,e=%d\\n\",a,b,c,d); }   供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0"}]}
{"question": "孩子考试重修C语言，一点不会，救救孩子把", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "大学混日子吧，就是这个后果", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "看来从二点到七点都会，值八十多分，足够了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "你上课只听60%，下课练习下也不至于做不来这个。都是超级简单的", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "早干啥去了？", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "网上搜搜吧。一点不会，这个是无解的。因为都给你写出来，你也是看不懂的。", "referer": "user-0"}]}
{"question": "C入门", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> int main(){     int n = 0;     for(n= 100;n <= 200;n++){         int i = 0;         for(i = 2; i*i < n;i++){             if(n % i == 0){                 break;             }         }         if(i >= n){             printf(\"%d\\n\",n);         }     }        return 0; }  供参考～    #include<stdio.h> int main(){     int i;     int num[10];     int max;     printf(\"请输入10个数：\");     for(i = 0;i < 10;i++)         scanf(\"%d\",&num[i]);     for(i =1,max = num[0];i < 10;i++)    //i从1开始         if (max < num[i])             max = num[i];         //max = num[i]>max?num[i] : max;         printf(\"max = %d\\n\",max);     return 0; } 供参考～", "referer": "user-0"}]}
{"question": "pitia上的题目，代码的结果没问题，在线提交总提示运行超时", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 7 楼 qq_37949449 的回复:为什么会这样呢？ 哪位大哥可以解答一下这个没有为什么，其实long int 也没什么问题，就像给一个人安排了500平的房子，不合理而已。long int 占位多点，所以计算的时候，十个手指不够了，还得把脚趾也搬出来了，白白浪费了资源。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "卡时间通常需要O(1)算法，O(n)不行  #include <stdio.h>  int main() {   double h, n, m = 1;    scanf(\"%lf%lf\", &h, &n);   if (n == 0) h = 0;   *(unsigned long long *)&m |= -1ull << (54 - (int)n) & 0x000fffffffffffffull;   printf(\"%.1f %.1f\\n\", h * (((int)n > 1) + m), h / (1ull << (int)n));    return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "为什么会这样呢？ 哪位大哥可以解答一下", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "破案了 超时都是因为定义了long int型变量", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "还是运行超时", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "这样改下，试试：#include <stdio.h> int main() {  \tlong int h; \tlong int n; \tdouble s=0,x=0; \tint i; \tscanf(\"%d %d\",&h,&n); \ts=x=h; \tfor(i=1;i<n;i++)//for(i=1;i<=n;i++) \t                //\tif(i==1) \t                //\t\ts+=x; \t                //\telse        { \t   \tx*=0.5; \t   \ts+=2*x;        }     x*=0.5; \tprintf(\"%.1f %.1f\\n\",s,x);//'\\n'              return 0; }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 user-5 的回复：输出末尾加上换行符？试了，还是报超时[face]monkey2:019.png[/face]", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 8 楼 自信男孩 的回复：#include <stdio.h> int main() {      long int h;     long int n;     double s=0,x=0;     int i;     scanf(\"%ld %ld\", &h,&n);     x = h;      i = 0;     while (i < n) {         s += x + x / 2;         x /= 2;         i++;     }      printf(\"%.1lf %.1lf\\n\", s, x);      return 0;     /*     for(i=1;i<=n;i++)         if(i==1)             s+=x;         else{             x*=0.5;             s+=2*x;         }         x*=0.5;     }     printf(\"%.1f %.1f\",s,x);     */ } 试试这个版本～只要定义了long int型变量，在线提交就会显示超时，代码在vs上运行没问题。", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "#include <stdio.h> int main() {      long int h;     long int n;     double s=0,x=0;     int i;     scanf(\"%ld %ld\", &h,&n);     x = h;      i = 0;     while (i < n) {         s += x + x / 2;         x /= 2;         i++;     }      printf(\"%.1lf %.1lf\\n\", s, x);      return 0;     /*     for(i=1;i<=n;i++)         if(i==1)             s+=x;         else{             x*=0.5;             s+=2*x;         }         x*=0.5;     }     printf(\"%.1f %.1f\",s,x);     */ } 试试这个版本～", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "供参考：#include <stdio.h> int main() {  \tlong int h; \tlong int n; \tdouble s=0,x=0; \tint i; \tscanf(\"%d %d\",&h,&n); \tx=h; \tfor(i=1;i<=n;i++) \t\tif(i==1) \t\t\ts+=x; \t\telse{ \t\t\tx*=0.5; \t\t\ts+=2*x; \t\t}     x*=0.5; \tprintf(\"%.1f %.1f\\n\",s,x);//'\\n'              return 0; }", "referer": "user-0"}, {"cid": "12", "user": "user-5", "content": "输出末尾加上换行符？", "referer": "user-0"}]}
{"question": "51单片机编程", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "烦请各位大牛看一下，关于c语言地址的而想的相关问题，烦请解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  理解和讨论之前请先学会如何观察！ //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "所以存储l.next指向的地址需要定义struct biao *address吗？ 不需要，指针都能存储任意类型变量的地址值的", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "没错，指针在本质上是地址。 但如果你只停留在这个认识层次上，只把指针看成地址，你学不好指针。指针是带有类型的地址好吧。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "教C语言不强调类型系统， 学C语言不注重类型系统， 都是耍流氓。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "引用 7 楼 weixin_46140402 的回复:struct xianxing //线性表 { \tstruct biao *addsize; \tint changdu; }; struct biao//链表的结点（头结点除外） { \tchar date; \tstruct biao *next; }; struct head//链表的头结点 { \tint lenth; \tstruct biao *next; }; void cretate(head &l,xianxing &p) {     l.lenth=0; \tl.next=NULL; \tp.addsize=(struct biao *)malloc(chushi*sizeof(struct biao *)); \tp.changdu=0; } void add(head &l,xianxing &p) { \tint a; \tstruct xianxing *k=&p; \tk->addsize=p.addsize; \tprintf(\"请输入插入节点的位置(1,%d):\",l.lenth+1); \tscanf(\"%d\",&a); \tfor(int b;b<l.lenth;b++) \t{ \t\tk->addsize+=sizeof(biao); \t} \tk->addsize=(biao *)malloc(sizeof(biao)); \tprintf(\"请输入要结点的内容\"); \tgetchar(); \tscanf(\"%c\",&k->addsize->date); \tprintf(\"%d\\n\",k->addsize); \tl.lenth++; } void see(head &l,xianxing &p) { \tstruct xianxing *k=&p; \tint a; \tprintf(\"请输入查看的位置(1,%d):\",l.lenth); \tscanf(\"%d\",&a); \tfor(int b=1;b<a;b++) \t{ \tk->addsize+=sizeof(biao); \t} \tprintf(\"%d\",k->addsize); \tprintf(\"该节点的数值为%c:\",k->addsize->date); } 请问您我现在定义了一个指向结构体的数值指针，在add函数里输入了三个数但查找第一个时候显示的是添加的第三个的值，然后第二个第三个的值都差找不到怎么回事 这样定义数据结构，你不感觉把自己绕晕了吗？ 定义2个不可以吗？  #if 0 struct xianxing //线性表 {     struct biao *addsize;     int changdu; };  struct biao//链表的结点（头结点除外） {     char date;     struct biao *next; };  struct head//链表的头结点 {     int lenth;     struct biao *next; }; #else  struct biao {     int changdu;     char date;     struct biao *next; };  struct node {     int length;     struct biao *head; }; #endif", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "struct xianxing //线性表 { \tstruct biao *addsize; \tint changdu; }; struct biao//链表的结点（头结点除外） { \tchar date; \tstruct biao *next; }; struct head//链表的头结点 { \tint lenth; \tstruct biao *next; }; void cretate(head &l,xianxing &p) {     l.lenth=0; \tl.next=NULL; \tp.addsize=(struct biao *)malloc(chushi*sizeof(struct biao *)); \tp.changdu=0; } void add(head &l,xianxing &p) { \tint a; \tstruct xianxing *k=&p; \tk->addsize=p.addsize; \tprintf(\"请输入插入节点的位置(1,%d):\",l.lenth+1); \tscanf(\"%d\",&a); \tfor(int b;b<l.lenth;b++) \t{ \t\tk->addsize+=sizeof(biao); \t} \tk->addsize=(biao *)malloc(sizeof(biao)); \tprintf(\"请输入要结点的内容\"); \tgetchar(); \tscanf(\"%c\",&k->addsize->date); \tprintf(\"%d\\n\",k->addsize); \tl.lenth++; } void see(head &l,xianxing &p) { \tstruct xianxing *k=&p; \tint a; \tprintf(\"请输入查看的位置(1,%d):\",l.lenth); \tscanf(\"%d\",&a); \tfor(int b=1;b<a;b++) \t{ \tk->addsize+=sizeof(biao); \t} \tprintf(\"%d\",k->addsize); \tprintf(\"该节点的数值为%c:\",k->addsize->date); } 请问您我现在定义了一个指向结构体的数值指针，在add函数里输入了三个数但查找第一个时候显示的是添加的第三个的值，然后第二个第三个的值都差找不到怎么回事", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "引用 5 楼 weixin_46140402 的回复:目前只学习了c，c++，数据结构，数据库，但学习指针的只有c，老师也没有更深入的讲解，所以有些迷惘，百度了好多指针的都是粗略的将所以还不懂需要看什么，根据各位的解答感觉还是没明白这个问题的本质，请问怎么解决我这个问题呀，还没有学过汇编，也没学过堆栈之类的，只知道是一个空间，数值这个我懂，结构体也明白一点 想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。”", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "目前只学习了c，c++，数据结构，数据库，但学习指针的只有c，老师也没有更深入的讲解，所以有些迷惘，百度了好多指针的都是粗略的将所以还不懂需要看什么，根据各位的解答感觉还是没明白这个问题的本质，请问怎么解决我这个问题呀，还没有学过汇编，也没学过堆栈之类的，只知道是一个空间，数值这个我懂，结构体也明白一点", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "32位程序中，int和各种指针类型是可以互相转换的，因为他们都是32位整数，但请为了代码的可读性，请不把随便用int来存储指针。  int m,n; struct biao *p;  m=1234567; p=(struct biao *)m; n=(int)p;  // m, n, p的值都是1234567", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "子曰：思而不学则殆。 语言标准这种东西是前人发明出来的，并不是自然规律。有前人的奇思妙想在里面。光靠琢磨是不能全面掌握的。 诸多教材可以指导循序渐进地学习，就算有这样那样的缺点，有教材指导也好过两眼一抹黑呀。  先学习指针--指针与数组--指向数组元素的指针和指向一维数组的指针--同种指针变量构成的数组--指向指针的指针 再看函数--递归--变量作用域与生存周期--返回指针的函数与指向函数的指针  教材中上述内容当可为你解惑。", "referer": "user-0"}]}
{"question": "c语言利用栈实现四则运算怎么解决啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "老赵翘尾巴了～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 forever74的回复:就可见的部分内容来看，题目承诺了负号只作用在运算数上，不会作用在表达式上做为取相反数用。 那你还担心啥？是%d%f排斥负号啊还是>>不认识它？ 输入的时候要输入字符串不是吗 我就想知道怎么判断他是负号还是运算符", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "立正！ 向赵4老师看齐！ 报数！", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "我的习惯是整行gets进来（或用代用品，此处谢绝吐槽）； 然后用sscanf每步从哪儿开始读就是自己说了算了。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "我们知道，四则运算都是双目，所以合法的表达式开始于括号或者运算数。 看见第一个字符是左括号--去处理它； 否则就一定是运算数，用%f或%lf搞定它就是。 运算数后面一定是运算符，一个%c搞定； 运算符后面一定是左括号或运算数，见上。  我的意思是，不需要识别负号的流程。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "你得识别输入的是操作数还是运算符，因为输入的是中缀表达式，操作数和运算符是交替出现的，可以设置一个状态标志，如果前一个输入是操作数，那么读到+-就是运算符，反之则是操作数的前置符号", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "仅供参考：#pragma warning(disable:4996) /*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console) 功能： 目前提供了10多个常用数学函数: ⑴正弦sin ⑵余弦cos ⑶正切tan ⑷开平方sqrt ⑸反正弦arcsin ⑹反余弦arccos ⑺反正切arctan ⑻常用对数lg ⑼自然对数ln ⑽ｅ指数exp ⑾乘幂函数^ ⑿向上取整ceil ⒀向下取整floor ⒁四舍五入取整round ⒂取符号sign ⒃取绝对值abs 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率Pi键入字母时不区分大小写,以方便使用。 16进制整数以0x或0X开头。 ----------------------------------------*/ #include <iostream> #include <iomanip> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <stdio.h> #include <string.h> #include <windows.h> using namespace std; const char Tab = 0x9; const int  DIGIT = 1; const int MAXLEN = 16384; char s[MAXLEN], *endss; int pcs = 15; double sign(double dVal) {          if (dVal>0.0) return  1.0;     else if (dVal<0.0) return -1.0;     else               return  0.0; } double round(double dVal, short iPlaces) {//iPlaces>=0     char s[30];     double dRetval;      sprintf(s, \"%.*lf\", iPlaces, dVal);     sscanf(s, \"%lf\", &dRetval);     return (dRetval); } double fun(double x, char op[], int *iop) {     while (op[*iop - 1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>         switch (op[*iop - 1]) {         case  7: x = sin(x);    (*iop)--; break;         case  8: x = cos(x);    (*iop)--; break;         case  9: x = tan(x);    (*iop)--; break;         case 10: x = sqrt(x);   (*iop)--; break;         case 11: x = asin(x);   (*iop)--; break;         case 12: x = acos(x);   (*iop)--; break;         case 13: x = atan(x);   (*iop)--; break;         case 14: x = log10(x);  (*iop)--; break;         case 15: x = log(x);    (*iop)--; break;         case 16: x = exp(x);    (*iop)--; break;         case 17: x = ceil(x);   (*iop)--; break;         case 18: x = floor(x);  (*iop)--; break;         case 19: x = round(x,0);(*iop)--; break;         case 20: x = sign(x);   (*iop)--; break;         case 21: x = fabs(x);   (*iop)--; break;         }     return x; } double calc(char *expr, char **addr) {     static int deep; //递归深度     static char *fname[] = { \"sin\",\"cos\",\"tan\",\"sqrt\",\"arcsin\",\"arccos\",\"arctan\",\"lg\",\"ln\",\"exp\",\"ceil\",\"floor\",\"round\",\"sign\",\"abs\",NULL };     double ST[10] = { 0.0 }; //数字栈     char op[10] = { '+' }; //运算符栈     char c, *rexp, *pp, *pf;     int ist = 1, iop = 1, last, i, n;     __int64 i64;      if (!deep) {         pp = pf = expr;         do {             c = *pp++;             if (c != ' '&& c != Tab)                 *pf++ = c;         } while (c != '\\0');     }     pp = expr;     if ((c = *pp) == '-' || c == '+') {         op[0] = c;         pp++;     }     last = !DIGIT;     while ((c = *pp) != '\\0') {         if (c == '(') {//左圆括弧             deep++;             ST[ist++] = calc(++pp, addr);             deep--;             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             pp = *addr;             last = DIGIT;             if (*pp == '(' || isalpha(*pp) && strnicmp(pp, \"Pi\", 2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }         else if (c == ')') {//右圆括弧             pp++;             break;         }         else if (isalpha(c)) {             if (!strnicmp(pp, \"Pi\", 2)) {                 if (last == DIGIT) {                     wcout <<    L\"π左侧遇）\" << endl; exit(1);                 }                 ST[ist++] = 3.14159265358979323846264338328;                 ST[ist - 1] = fun(ST[ist - 1], op, &iop);                 pp += 2;                 last = DIGIT;                 if (!strnicmp(pp, \"Pi\", 2)) {                     wcout <<    L\"两个π相连\" << endl; exit(2);                 }                 if (*pp == '(') {                     wcout <<    L\"π右侧遇（\" << endl; exit(3);                 }             }             else {                 for (i = 0; (pf = fname[i]) != NULL; i++)                     if (!strnicmp(pp, pf, strlen(pf))) break;                 if (pf != NULL) {                     op[iop++] = 07 + i;                     pp += strlen(pf);                 }                 else {                     wcout <<    L\"陌生函数名\" << endl; exit(4);                 }             }         }         else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '^') {             char cc;             if (last != DIGIT) {                 wcout <<    L\"运算符粘连\" << endl; exit(5);             }             pp++;             if (c == '+' || c == '-') {                 do {                     cc = op[--iop];                     --ist;                     switch (cc) {                     case '+':  ST[ist - 1] += ST[ist]; break;                     case '-':  ST[ist - 1] -= ST[ist]; break;                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 } while (iop);                 op[iop++] = c;             }             else if (c == '*' || c == '/' || c == '%') {             operate:        cc = op[iop - 1];                 if (cc == '+' || cc == '-') {                     op[iop++] = c;                 }                 else {                     --ist;                     op[iop - 1] = c;                     switch (cc) {                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 }             }             else {                 cc = op[iop - 1];                 if (cc == '^') {                     wcout <<    L\"乘幂符连用\" << endl; exit(6);                 }                 op[iop++] = c;             }             last = !DIGIT;         }         else {             if (last == DIGIT) {                 wcout <<    L\"两数字粘连\" << endl; exit(7);             }             if (pp[0] == '0' && (pp[1] == 'x' || pp[1] == 'X')) {                 sscanf(pp + 2, \"%I64x%n\", &i64, &n);                 rexp = pp + 2 + n;                 ST[ist++] = (double)i64;             }             else ST[ist++] = strtod(pp, &rexp);             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             if (pp == rexp) {                 wcout <<    L\"非法字符\" << endl; exit(8);             }             pp = rexp;             last = DIGIT;             if (*pp == '(' || isalpha(*pp)) {                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }     }     *addr = pp;     if (iop >= ist) {         wcout <<    L\"表达式有误\" << endl; exit(9);     }     while (iop) {         --ist;         switch (op[--iop]) {         case '+':  ST[ist - 1] += ST[ist]; break;         case '-':  ST[ist - 1] -= ST[ist]; break;         case '*':  ST[ist - 1] *= ST[ist]; break;         case '/':  ST[ist - 1] /= ST[ist]; break;         case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;         case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;         }     }     return ST[0]; } int main(int argc, char **argv) {     int a;      wcout.imbue(locale(\"chs\"));     if (argc<2) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         wcout <<    L\"计算函数表达式的值。\" << endl << L\"支持(),+,-,*,/,%,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs\" << endl;         while (1) {             wcout <<    L\"请输入表达式：\";             fgets(s,16384,stdin);             if ('\\n' == s[strlen(s)-1]) s[strlen(s) - 1] = 0;             if (s[0] == 0) break;//             cout << s << \"=\";             cout << setprecision(15) << calc(s, &endss) << endl;         }     }     else if (argc == 2 && 0 == strcmp(argv[1], \"/?\")) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         wcout <<    L\"计算由≥1个命令行参数给出的函数表达式的值。\\n\"             \"最后一个参数是.0～.15表示将计算结果保留小数0～15位\\n\"             \"最后一个参数是x表示将计算结果以16进制正整数格式输出\\n\"             \"支持(),+,-,*,/,%,^^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs\\n\"             \"16进制整数以0x或0X开头\\n\";     }     else {         strncpy(s, argv[1], MAXLEN - 1); s[MAXLEN - 1] = 0;         if (argc>2) {             for (a = 2; a<argc - 1; a++) strncat(s, argv[a], MAXLEN - 1);//将空格间隔的各参数连接到s             if (1 == sscanf(argv[a], \".%d\", &pcs) && 0 <= pcs && pcs <= 15) {//最后一个参数是.0～.15表示将计算结果保留小数0～15位                 printf(\"%.*lf\\n\", pcs, calc(s, &endss));             }             else if (argv[a][0] == 'x' || argv[a][0] == 'X') {//最后一个参数是x表示将计算结果以16进制正整数格式输出                 printf(\"0x%016I64x\\n\", (__int64)calc(s, &endss));             }             else {                 strncat(s, argv[a], MAXLEN - 1);                 printf(\"%.15lg\\n\", calc(s, &endss));             }         }         else {             printf(\"%.15lg\\n\", calc(s, &endss));         }     }     return 0; }", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 user-5的回复:构建逆波兰式 负数该怎么解决呢", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "构建逆波兰式", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "引用 2 楼 乐乐Q弹 的回复:[quote=引用 1 楼 user-5的回复:]构建逆波兰式 负数该怎么解决呢[/quote]  符号 属于一元运算符， + - * / 属于二元运算符  a = 3 + -4*3  逆波兰：a34-3*+= （这里有优先级别，一元>二元  * > + - > =） 然后遍历逆波兰，遇到操作数，压栈，遇到运算符，判断一元还是二元，二元弹出两个操作数，一元运算符弹出一个操作数，进行计算，计算的结果再次压栈，最终栈里只有一个操作数，就是表达式的返回值", "referer": "user-0"}, {"cid": "12", "user": "user-4", "content": "就可见的部分内容来看，题目承诺了负号只作用在运算数上，不会作用在表达式上做为取相反数用。 那你还担心啥？是%d%f排斥负号啊还是>>不认识它？", "referer": "user-0"}, {"cid": "13", "user": "user-2", "content": "老赵的计算器不错，就是对于楼主的需求属于牛刀杀鸡了。楼主的需求应该50行以内代码实现", "referer": "user-0"}]}
{"question": "间接访问运算(*p)用异或运算交换所指变量的值出错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：#include <stdio.h> #define SWAP(a,b) do ((&(a))!=(&(b)))?((a)^=(b)^=(a)^=(b)):((a)=(a)); while (0) char   *p1=\"1\" ,*p2=\"2\" ; char    c1=1   , c2=2   ; short   s1=1   , s2=2   ; int     i1=1   , i2=2   ; __int64 I1=1i64, I2=2i64; float   f1=1.0f, f2=2.0f; double  d1=1.0 , d2=2.0 ; void main() {     SWAP((int)p1,(int)p2);                printf(\"char *     %5s,   %5s\\n\",p1,p2);     SWAP(c1,c2);                          printf(\"char       %5d,   %5d\\n\",c1,c2);     SWAP(s1,s2);                          printf(\"short      %5d,   %5d\\n\",s1,s2);     SWAP(i1,i2);                          printf(\"int        %5d,   %5d\\n\",i1,i2);     SWAP(I1,I2);                          printf(\"__int64 %5I64d,%5I64d\\n\",I1,I2);     SWAP(*(int     *)&f1,*(int     *)&f2);printf(\"float      %5g,   %5g\\n\",f1,f2);     SWAP(*(__int64 *)&d1,*(__int64 *)&d2);printf(\"double    %5lg,  %5lg\\n\",d1,d2);      SWAP(c1,c1);     printf(\"%d\\n\",c1); } //char *         2,       1 //char           2,       1 //short          2,       1 //int            2,       1 //__int64     2,    1 //float          2,       1 //double        2,      1 //2", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include<stdio.h> int main(void) {     int a=1,b=2;     int *p1,*p2;      p1=&a,p2=&b;     printf(\"a=%d,b=%d,*p1=%d,*p2=%d\\n\",a,b,*p1,*p2); #if 0     printf(\"No.1: %d\\n\", (*p1 ^= *p2));     printf(\"%d\\n\", *p1);     printf(\"No.2: %d\\n\", (*p2 ^= *p1));     printf(\"%d\\n\", *p2);     printf(\"No.2: %d\\n\", (*p1 ^= *p2));     printf(\"%d\\n\", *p1); #else     *p1^=*p2^=*p1^=*p2; #endif     printf(\"a=%d,b=%d,*p1=%d,*p2=%d\\n\",a,b,*p1,*p2);      return 0; } 供参考～  if和else都是一样的，else部分的分解版本就是if 0的执行部分；  执行结果： a=1,b=2,*p1=1,*p2=2 a=2,b=1,*p1=2,*p2=1   我运行了你的代码，结果没变，和原来的一样。。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include<stdio.h> int main(void) {     int a=1,b=2;     int *p1,*p2;      p1=&a,p2=&b;     printf(\"a=%d,b=%d,*p1=%d,*p2=%d\\n\",a,b,*p1,*p2); #if 0     printf(\"No.1: %d\\n\", (*p1 ^= *p2));     printf(\"%d\\n\", *p1);     printf(\"No.2: %d\\n\", (*p2 ^= *p1));     printf(\"%d\\n\", *p2);     printf(\"No.2: %d\\n\", (*p1 ^= *p2));     printf(\"%d\\n\", *p1); #else     *p1^=*p2^=*p1^=*p2; #endif     printf(\"a=%d,b=%d,*p1=%d,*p2=%d\\n\",a,b,*p1,*p2);      return 0; } 供参考～  if和else都是一样的，else部分的分解版本就是if 0的执行部分；  执行结果： a=1,b=2,*p1=1,*p2=2 a=2,b=1,*p1=2,*p2=1", "referer": "user-0"}]}
{"question": "求助大佬，究竟是哪里出了问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:[quote=引用 2 楼 m0_57436055 的回复:][quote=引用 1 楼 自信男孩的回复:]很明显你编译的不是2.2.c这个源文件吧。上面的编译结果是文件名是中文的那个源文件～ 然后我把运行出来的一长串删了就正常了，这又是为什么呢？[/quote] 你的代码没问题（图片里的），也没有涉及到后面编译提到的问题。所以，这个属于环境（编辑编译）使用问题，不是代码问题。 编译出错的error说明是其他源码编译出来的～[/quote] 喔喔妙啊非常感谢呀！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 m0_57436055 的回复:[quote=引用 1 楼 自信男孩的回复:]很明显你编译的不是2.2.c这个源文件吧。上面的编译结果是文件名是中文的那个源文件～ 然后我把运行出来的一长串删了就正常了，这又是为什么呢？[/quote] 你的代码没问题（图片里的），也没有涉及到后面编译提到的问题。所以，这个属于环境（编辑编译）使用问题，不是代码问题。 编译出错的error说明是其他源码编译出来的～", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:很明显你编译的不是2.2.c这个源文件吧。上面的编译结果是文件名是中文的那个源文件～ 然后我把运行出来的一长串删了就正常了，这又是为什么呢？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "很明显你编译的不是2.2.c这个源文件吧。上面的编译结果是文件名是中文的那个源文件～", "referer": "user-0"}]}
{"question": "为什么会有错误，真心不知道错在哪了？求大佬帮帮忙!", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "三日不练手生，这是一个非常简单的程序，先由我来提供一个版本，再请赵4老湿提供自己的版本。 # include <stdio.h> # include <math.h>  int main (void) {     int fst, lst, cnt = 0, sum = 0;          scanf (\"%d%d\", & fst, & lst);      for (int d = 2; fst <= lst; fst ++, d = 2)         while (fst % d != 0)             if (d ++ > sqrt (fst))             {                 cnt ++, sum += fst;                 break;             }      printf (\"%d %d\\n\", cnt, sum); }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "注意一下，如果输入的是m > n则这个程序一次也不会运行，如果m, n为负数或者其中一个为负数，也不能完全运行吧", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "m如果真的是1，你的代码就每次循环都会掉进if(m==1)分支，就不做正经事了。", "referer": "user-0"}]}
{"question": "问一个c primer plus上的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/scanf-s-scanf-s-l-wscanf-s-wscanf-s-l?view=msvc-160", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "man scanf_s 哦，windows 没有 manual，跳转到 scanf_s 接口直接看参数说明吧", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "书上的是scanf，而你的编译器要求是scanf_s，只是对scanf再次进行了封装，比scanf更安全，因为它限定了缓存长度，可以有效防止越界； 多出的这个参数不能传入4，而需要传入40；", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "scanf() 与 scanf_s() 是有区别的。第10行正确的应该是：scanf_s(\"%s\",name,40) ;  https://blog.csdn.net/weixin_44093867/article/details/97525914?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161889596316780269825965%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161889596316780269825965&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-1-97525914.pc_search_result_no_baidu_js&utm_term=scanf_s%E4%B8%8Escanf%E7%9A%84%E5%8C%BA%E5%88%AB", "referer": "user-0"}]}
{"question": "c语言数字炸弹双人游戏", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：gnum, num都定义两份吧，循环的退出以两人都猜中，并且已经猜中的不用输入（加上判断）可否细说", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：gnum, num都定义两份吧，循环的退出以两人都猜中，并且已经猜中的不用输入（加上判断）可否打代码出来", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "gnum, num都定义两份吧，循环的退出以两人都猜中，并且已经猜中的不用输入（加上判断）", "referer": "user-0"}]}
{"question": "救救我吧？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 6 楼 信仰之跃849 的回复:[quote=引用 5 楼 ZWW975的回复:]pow 第一个参数没有整型的，第一个参数要类型转换下 pow(2.0,n); 然后返回值 怎么返回值？[/quote]你把 2 改成2.0还会报错吗", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 ZWW975的回复:pow 第一个参数没有整型的，第一个参数要类型转换下 pow(2.0,n); 然后返回值 怎么返回值？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "pow 第一个参数没有整型的，第一个参数要类型转换下 pow(2.0,n); 然后返回值", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "if (j=1)//应该是=还是==? 没发现这个有问题吗？         #include <math.h>         double pow(double x, double y);        float powf(float x, float y);        long double powl(long double x, long double y);         Link with -lm.     Feature Test Macro Requirements for glibc (see feature_test_macros(7)):         powf(), powl():            _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L                || /* Since glibc 2.19: */ _DEFAULT_SOURCE                || /* Glibc versions <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "double pow( double x, double y ); float powf( float x, float y ); long double powl( long double x, long double y ); define pow(X, Y) // Requires C11 or higher  double pow( double x, int y );  // C++ only float pow( float x, float y );  // C++ only float pow( float x, int y );  // C++ only long double pow( long double x, long double y );  // C++ only long double pow( long double x, int y );  // C++ only", "referer": "user-0"}]}
{"question": "c语言fprintf函数文件内是乱码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 qq_53455956 的回复: 还是乱码啊！！！ 为什么呢？？？？？ 因为你的head节点的name是随机值呀，你没给head节点的name输入或修改任何内容呀。你看看你的写文件是不是第一个写的是head节点的name?", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "还是乱码啊！！！ 为什么呢？？？？？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "name 只有10个字节，字符串最后一个字节需要是结束符 '\\0' 你是不是输入了超过10个字节，或者正好10个字节的内容了？ 考虑用 scanf_s 替换 scanf  另外 chance 这个临时字符串没用  赵4老师说的也对", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "new是保留字", "referer": "user-0"}]}
{"question": "文件问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不是读写函数出错，而是读出来的内容出错。因为以文本形式写进去的，以二进制形式去读，可能会出现问题，", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复：不要把 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仍继续读;读写的内容当字节看待 弄混了谢谢赵四老师耐心解答[face]monkey2:002.png[/face]", "referer": "user-0"}, {"cid": "4", "user": "user-3", "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": "5", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复：所有文件的内容都只是一系列二进制字节。那这里说的文件中有\\r和\\n指的是在哪里，它这里的打开一个文件是指的我们鼠标双击的这种打开吗，这个是不是要学些底层知识才能弄明白啊，我不是cs的，现在只学了c语言，是不是应该再看些其它相关的书", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "所有文件的内容都只是一系列二进制字节。", "referer": "user-0"}]}
{"question": "来位义夫解释下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这是递归呢，停止递归是遇到c=='*'", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出", "referer": "user-0"}]}
{"question": "冒泡排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "冒泡排序，代码第24行需修改下，for(j=0; j<m-i; j++) 这句，修改为：for(j=0;j<m-i-1;j++)", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:ch长度是1，用%s很明显越界呢。这个问题你之前就提出来过吧，给你的回复越界问题没解决？ C语言的str列数是可变的，这个不支持的，支持固定长度的数组； 哦哦哦，我看到啦，终于找到了，感谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "建议楼主贴代码，大家方便。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "ch长度是1，用%s很明显越界呢。这个问题你之前就提出来过吧，给你的回复越界问题没解决？ C语言的str列数是可变的，这个不支持的，支持固定长度的数组；", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "看优先级，++和-的优先级x++ - 1，++（后增）的优先级比-的优先级高，所以x++现结合，作为一个整体，所以减1之后再算++  https://blog.csdn.net/xtlisk/article/details/40116813", "referer": "user-0"}]}
{"question": "关于C语言宏定义", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "报什么错误？在代码里又是如何使用s, area呢？这些是关键，不能说单单的宏定义会报错或不报错。重点是如何用的，宏定义就是等价替换，放在代码里看看是否符合语法规则～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你用的是全角分号吧", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 11 楼 qzjhjxj 的回复:[quote=引用 10 楼 Dream1018 lin 的回复:][quote=引用 8 楼 真相重于对错 的回复:]宏就是文本替换，你那个肯定不对。 相当于 printf(\"...\",xxxxxx ;); 所以说所有的宏定义最后边都不需要 \" ; \" 对吗？ 可是为什么在某些情况下又可以呢？ 比如说： [/quote]这个相当于执行一次空语句，再多加几个也没感觉t = div(x,y);;;;;;[/quote] 怎么会对？“;”代表的语句的结束，但是你前面是调用printf函数，函数调用时，函数名后面的括号一定要匹配，所以肯定不对啊", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 11 楼 qzjhjxj 的回复:[quote=引用 10 楼 Dream1018 lin 的回复:][quote=引用 8 楼 真相重于对错 的回复:]宏就是文本替换，你那个肯定不对。 相当于 printf(\"...\",xxxxxx ;); 所以说所有的宏定义最后边都不需要 \" ; \" 对吗？ 可是为什么在某些情况下又可以呢？ 比如说： [/quote]这个相当于执行一次空语句，再多加几个也没感觉t = div(x,y);;;;;;[/quote] 明白了。谢谢大佬", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "用do {……} while(0)括住宏，解决分号结束问题。", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "引用 10 楼 Dream1018 lin 的回复:[quote=引用 8 楼 真相重于对错 的回复:]宏就是文本替换，你那个肯定不对。 相当于 printf(\"...\",xxxxxx ;); 所以说所有的宏定义最后边都不需要 \" ; \" 对吗？ 可是为什么在某些情况下又可以呢？ 比如说： [/quote]这个相当于执行一次空语句，再多加几个也没感觉t = div(x,y);;;;;;", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 8 楼 真相重于对错 的回复:宏就是文本替换，你那个肯定不对。 相当于 printf(\"...\",xxxxxx ;); 所以说所有的宏定义最后边都不需要 \" ; \" 对吗？ 可是为什么在某些情况下又可以呢？ 比如说：", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "肯定不行呢，看看楼上这位大咖已经给你等价替换出来了。  引用 8 楼 真相重于对错 的回复:宏就是文本替换，你那个肯定不对。 相当于 printf(\"...\",xxxxxx ;);", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "宏就是文本替换，你那个肯定不对。 相当于 printf(\"...\",xxxxxx ;);", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "我感觉会不会是连续声明两个宏定义，所以两者之间不能有 \" ; \"  ？  当只有一个宏定义的时候，“ ; ”便可有可无？ 不太明白为什么。。。求大神空降回答。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 早打大打打核战争 的回复:你用的是全角分号吧用的是半角符号", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:报什么错误？在代码里又是如何使用s, area呢？这些是关键，不能说单单的宏定义会报错或不报错。重点是如何用的，宏定义就是等价替换，放在代码里看看是否符合语法规则～ 你看一下，就是这样报错，其他的情况都没问题。", "referer": "user-0"}, {"cid": "14", "user": "user-7", "content": "如果s(a,b,c) 在后面代码中直接参与运算，则不加分号，比如 s(a,b,c) +123； //这个里s不能有加号  直接调用，不参与运算则可以加，建议不要加了 s(a,b,c)", "referer": "user-0"}, {"cid": "15", "user": "user-5", "content": "VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898", "referer": "user-0"}]}
{"question": "【C语言求助】静态链表执行赋值语句时暂停运行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <math.h> #include <stdlib.h> struct node {     int num;     struct node *next; }node;  int main(void) {     //struct node num,* head, * p=head;     struct node num, *head, *tail, *p;     //int ordinal=1,remain=13;      //开辟13个节点     //在节点里存入数据num：1~13      //if(p!=NULL) printf(\"Not NULL...\\n\");     //printf(\"%d \",p->num);     head = NULL;     for(int i=0;i<13;i++)     {         p = (struct node *)malloc(sizeof(struct node));         if (!p)             exit(0);         if (!head)             head = p;         else             tail->next = p;         p->num=i+1;         printf(\"%d \",p->num);         tail = p;         //p=p->next;     }      p->next = NULL;      p = head;     while (p) {         printf(\"%d \",p->num);         p = p->next;     }     printf(\"\\n\");      return 0; } 供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "暂停运行是指什么？参考楼主的代码修改，生成带头节点的13个节点的链表，同时往里存入1-13，供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> struct node {     int num;     struct node *next; }node; void main() {     struct node num,* head, * p,*q;     //int ordinal=1,remain=13;     //开辟13个节点     //在节点里存入数据num：1~13     head = (struct node *)malloc(sizeof(struct node));     head->next = NULL;     q = head;     if(q!=NULL) printf(\"Not NULL...\\n\");     //printf(\"%d \",p->num);     for(int i=0;i<13;i++)     {         p = (struct node *)malloc(sizeof(struct node));         p->num=i+1;         p->next=NULL;         q->next=p;         q=p;         printf(\"i=%d,%d\\n\",i,p->num);         //p=p->next;     }     q=head->next;     while(q){           printf(\"%d\\n\",q->num);           q=q->next;     }     //p=NULL;     system(\"pause\"); }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "head是野指针", "referer": "user-0"}]}
{"question": "？？？实在不懂了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "首先，我说的是“看的C书至少都有20年以上的历史了”，引号中的文字意思很清楚。这是个语文的问题。 其次，我说的是标准指定了main函数的语法形式，至少有两种，我只是使用了其中之一，我没说别的。我不知道我的局限性是从何说起的。 最后，关于变长数组，我说的是 int n = 5, a [n]; 这种。而且，这个声明在C语言里是合法的。我也不是指用malloc分配的动态空间数组。 我看的C书不多，严格来说一本都没看过，因为很多书看了不如不看。甚至我连C语言之父的经典著作都没看过。所以，看的C书可能还不如你多。这是实话。唯一的例外是C99，C11，C18的标准文档。但标准文档中库的部分我也没有完全通读。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 11 楼 均陵鼠侠 的回复:[quote=引用 8 楼 自信男孩 的回复:]函数声明需要加分号;因为声明也是一条语句～ 有警告，exit函数调用要引入stdlib.h头文件。另外，exit(0)有参数～ 至少在C语言里，声明和语句是严格区分的。声明有声明的语法，语句有语句的组成。因为都有分号所以声明和语句是一回事，这是很奇怪的定义。 我发现这个论坛里的人，看的C书至少都有20年以上的历史了，甚至还在说C语言没有变长数组。如果工作中还用得上C语言，该补的课还是要补的。[/quote]  C语言于1972年11月问世，1978年美国电话电报公司（AT&T）贝尔实验室正式发布C语言，1983年由美国国家标准局（American National Standards Institute，简称ANSI）开始制定C语言标准，于1989年12月完成，并在1990年春天发布，称之为ANSI C，有时也被称为 C89 或 C90  另外，真没你看书历史长，我从接触C语言书本，才有10年左右，但是看的时间也就几年吧。你说的是看书20多年，还是C语言出书20多年，没看你描述清楚～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 10 楼 均陵鼠侠 的回复:[quote=引用 2 楼 user-5 的回复:]main()只能有一个，而且它也不需要声明。 只是说main函数的定义只能有一个，函数定义实际上也是函数声明。所以main函数不需要声明的说法是错误的。 函数可以声明多次，但是带有函数体的函数声明只能有一次，main函数也是这样。比如：  int main (void); int main (void) {     exit (0); } 这是没有任何问题的。 函数main 和其它函数只有一个地方是不同的：对它的调用是在运行库中，所以，要求运行库中的调用形式（这是你没办法改变的）必须和你声明的形式匹配。这就是为什么标准指定了函数main的声明形式。[/quote]  那么这样函数声明，也有这样的吧 int main(int argc, char *argv[]);你说的main函数声明也有局限性～", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 11 楼 均陵鼠侠 的回复:[quote=引用 8 楼 自信男孩 的回复:]函数声明需要加分号;因为声明也是一条语句～ 有警告，exit函数调用要引入stdlib.h头文件。另外，exit(0)有参数～ 至少在C语言里，声明和语句是严格区分的。声明有声明的语法，语句有语句的组成。因为都有分号所以声明和语句是一回事，这是很奇怪的定义。 我发现这个论坛里的人，看的C书至少都有20年以上的历史了，甚至还在说C语言没有变长数组。如果工作中还用得上C语言，该补的课还是要补的。[/quote]  你的理解变长数组是这样的吗？int n, a[n];我说的变长数组是指这样的。int a[0]; a = (int *)malloc(xxxx *sizeof(int));这样的定义可不是我说的变长数组。 所以，你的理解认为是我的理解，这种说法站不住脚。 描述有语句语境，有背景，没看到你提到背景，环境，只是在这讨论理论。那么你看书如果多的话，应该引用一下课本上（或者）书本上的文字，当然这些文字也有时效性，看完书本还不行，还得看编译器的版本，老旧版本的语法检查规则也有差异。 所以，你在这里教训别人，不如引入例子更有说服力，你说呢？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 8 楼 自信男孩 的回复:函数声明需要加分号;因为声明也是一条语句～ 有警告，exit函数调用要引入stdlib.h头文件。另外，exit(0)有参数～ 至少在C语言里，声明和语句是严格区分的。声明有声明的语法，语句有语句的组成。因为都有分号所以声明和语句是一回事，这是很奇怪的定义。 我发现这个论坛里的人，看的C书至少都有20年以上的历史了，甚至还在说C语言没有变长数组。如果工作中还用得上C语言，该补的课还是要补的。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 2 楼 user-5 的回复:main()只能有一个，而且它也不需要声明。 只是说main函数的定义只能有一个，函数定义实际上也是函数声明。所以main函数不需要声明的说法是错误的。 函数可以声明多次，但是带有函数体的函数声明只能有一次，main函数也是这样。比如：  int main (void); int main (void) {     exit (0); } 这是没有任何问题的。 函数main 和其它函数只有一个地方是不同的：对它的调用是在运行库中，所以，要求运行库中的调用形式（这是你没办法改变的）必须和你声明的形式匹配。这就是为什么标准指定了函数main的声明形式。", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "函数声明需要加分号;因为声明也是一条语句～ 有警告，exit函数调用要引入stdlib.h头文件。另外，exit(0)有参数～", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "建议行22的主函数改成int类型 有时候你需要通过主函数的返回值是否为0来判断代码有没有错误的", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "引用 5 楼 change_2 的回复:[quote=引用 2 楼 user-5的回复:]main()只能有一个，而且它也不需要声明。 谢谢你，大佬，你是对的[/quote]成了吗？  引用 5 楼 change_2 的回复:[quote=引用 2 楼 user-5的回复:]main()只能有一个，而且它也不需要声明。 谢谢你，大佬，你是对的[/quote]可以了吗?", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 2 楼 user-5的回复:main()只能有一个，而且它也不需要声明。 谢谢你，大佬，你是对的", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 2 楼 user-5的回复:main()只能有一个，而且它也不需要声明。 第36行的exit（0）那里就是红色的", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 2 楼 user-5的回复:main()只能有一个，而且它也不需要声明。 哦，但是第一张图片是没有加main的，它那里的错误是为什么呢", "referer": "user-0"}, {"cid": "15", "user": "user-5", "content": "main()只能有一个，而且它也不需要声明。", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "第4行的main()是多余的", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你倒是发个清晰点的照片啊。", "referer": "user-0"}]}
{"question": "为什么这里是错的？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "添加选项-std=c99", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "把int i;放在for之前试试； 编译已经给于提示了，C99标准支持你这种写法～ 要么改成for循环前定义i,要么添加循环-std=c99", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "C90并不允许在for后面的圆括号里声明循环变量。 删掉int并在函数体开头写int i;可以满足一切C编译器的喜好。", "referer": "user-0"}]}
{"question": "多项式求和", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "多项式的式子呢？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "[face]monkey2:019.png[/face]", "referer": "user-0"}]}
{"question": "在查询数据库时遇到的一个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用try语句捕获该捕获的异常。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "dddddd", "referer": "user-0"}]}
{"question": "为什么我输入的入栈元素只有最后一根能出栈？不应该是出栈六个不一样的吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考：#include<stdio.h> #include<stdlib.h>  #define STACK_INIT_SIZE 100 #define STACKINCREMNT   10 #define OVERFLOW        0 #define ERROR           0 #define OK              1  typedef struct {      int *top ;      int *base;      int stacksize; }SqStack;  int InitStack(SqStack &L) {      L.base=(int*)malloc(10*sizeof(int));      if(!L.base)  exit(OVERFLOW);      L.top=L.base;      L.stacksize=10;      return OK; } int GetTop(SqStack L,int &e) {      if(L.base==L.top)return  ERROR;      e=*(L.top-1);      return OK; } int Push(SqStack &L,int e) //int Push(SqStack L,int e) {      if(L.top-L.base>=L.stacksize){         L.base=(int*)realloc(L.base,(L.stacksize+STACKINCREMNT) * sizeof(int));         L.top=L.base+L.stacksize;         L.stacksize=L.stacksize+STACKINCREMNT;      }      *(L.top++) = e;      return OK; } int Pop(SqStack &L,int &e) //int Pop(SqStack L,int &e) {      if(L.top != L.base)         e=*(--L.top); //e=*(L.top--)      return OK;       //e; }  int main() {      int i,n,m;      SqStack L;      InitStack (L);      for(i=0;i<6;i++){          scanf(\"%d\",&n);          Push(L,n);      }      for(m=0;m<6;m++){          Pop(L,n);          printf(\"%d\\n\",n);      }            return 0; } 谢谢了，已经解决了，没有取地址", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考：#include<stdio.h> #include<stdlib.h>  #define STACK_INIT_SIZE 100 #define STACKINCREMNT   10 #define OVERFLOW        0 #define ERROR           0 #define OK              1  typedef struct {      int *top ;      int *base;      int stacksize; }SqStack;  int InitStack(SqStack &L) {      L.base=(int*)malloc(10*sizeof(int));      if(!L.base)  exit(OVERFLOW);      L.top=L.base;      L.stacksize=10;      return OK; } int GetTop(SqStack L,int &e) {      if(L.base==L.top)return  ERROR;      e=*(L.top-1);      return OK; } int Push(SqStack &L,int e) //int Push(SqStack L,int e) {      if(L.top-L.base>=L.stacksize){         L.base=(int*)realloc(L.base,(L.stacksize+STACKINCREMNT) * sizeof(int));         L.top=L.base+L.stacksize;         L.stacksize=L.stacksize+STACKINCREMNT;      }      *(L.top++) = e;      return OK; } int Pop(SqStack &L,int &e) //int Pop(SqStack L,int &e) {      if(L.top != L.base)         e=*(--L.top); //e=*(L.top--)      return OK;       //e; }  int main() {      int i,n,m;      SqStack L;      InitStack (L);      for(i=0;i<6;i++){          scanf(\"%d\",&n);          Push(L,n);      }      for(m=0;m<6;m++){          Pop(L,n);          printf(\"%d\\n\",n);      }            return 0; }", "referer": "user-0"}]}
{"question": "求大佬救救孩子", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "救不了了。。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "你这，我看的都不敢学了", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "引用 11 楼 user-13 的回复：抽空写了个，感觉输出时的序号有点想头，供参考：#include<stdio.h> #define STUDENTS 10 //按题目要求<10个学生  void  input(); int   sum(int m,int e,int c); void  sort(); void  print();  typedef struct{ //自定义结构体类型 \tint   numcode; \tint   math; \tint   english; \tint   chinese;     int   sum;     int   avg; }STUDENT;  STUDENT student[STUDENTS];//定义10个学生数组 int stu_num;              //学生人数  void main() {       input(); //输入       sort();  //排序,从大到小       print(); //输出       //system(\"pause\"); }  void input() {      printf(\"Input students number:\");      scanf(\"%d\",&stu_num);      if(stu_num >= STUDENTS){         printf(\"Please input 1-9.\\n\");         exit(0);      }      for(int i = 0; i < stu_num; i++){         scanf(\"%d %d %d %d\", &student[i].numcode,&student[i].math,                              &student[i].english,&student[i].chinese);         student[i].sum = sum(student[i].math,student[i].english,student[i].chinese);         student[i].avg = student[i].sum/3;      } }  int sum(int m,int e,int c) {      return m+e+c; }  void sort() {       STUDENT temp;       for (int i = 0; i < stu_num ;i++){          for (int k = 0; k < stu_num - 1 -i ;k++){            if(student[k].sum < student[k+1].sum ) {                   temp        = student[k];                   student [k] = student[k+1];                   student[k+1]= temp;            }          }       } }  void print() {      int j=0;      for(int i = 0; i < stu_num; i++){ //打印输出        printf(\"%4d   %10d   %5d   %5d   %5d\\n\",            i==0?(j=i+1):(student[i].sum == student[i-1].sum?(j):(j=i+1)),            student[i].numcode,student[i].math,student[i].english,student[i].chinese);       }  }  //Input students number:8 //39060405 78 82 69 //39060412 95 85 91 //39060413 95 86 90 //39060415 98 88 85 //39060419 75 89 88 //39060421 89 88 75 //39060425 85 78 93 //39060427 87 92 88 //   1     39060412      95      85      91 //   1     39060413      95      86      90 //   1     39060415      98      88      85 //   4     39060427      87      92      88 //   5     39060425      85      78      93 //   6     39060419      75      89      88 //   6     39060421      89      88      75 //   8     39060405      78      82      69 //请按任意键继续. . .不错", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "#include \"stdio.h\" #include \"stdlib.h\" /**  * 学生成绩结构体  */ typedef struct student_grade{     char no[10]; //学号     int mathGrade; //数学成绩     int enGrade;//英语成绩     int chGrade;//语文成绩     int total;//总分     int avg; //平均分     int rank; //排名 }StudentGrade;  /**  * 学生列表  */ typedef struct student_list{     StudentGrade * arr[10]; //数组 最大10个     int n;//学生数量 小于10 }StudentList;  /**  * 创建 学生  * @return  */ static StudentGrade * createStudentGrade();  /**  * 释放内存  * @param grade  */ static void freeStudentGrade(StudentGrade* grade);  /**  * 创建列表  * @return  */ static StudentList * createStudentList(int n);  /**  * 释放内存  * @param studentList  */ static void freeStudentList(StudentList* studentList);   /**  * 排序  * @param studentList  */ static void sortStudentList(StudentList* studentList);  /**  * 打印学生成绩列表  * @param studentList  */ static void printStudentList(StudentList* studentList);   /**  * 获取输入数字  * @param min 最小值  * @param max 最大值  * @return  */ static int getNumFromInput(int min, int max);  /**  * 输入学生成绩  * @param grade  */ static void inputStudentGrade(StudentGrade* grade);  /**  * 程序入口  * @return  */ int main(){     //输入学生人数 1-9     printf(\"please input the number of students:\\n\");     int n = getNumFromInput(1, 9);     int i;     //创建列表     StudentList * studentList = createStudentList(n);     for(i = 0; i < n; i++){         printf(\"please input the no.%d student's grade\\n\", i+1);         //输入成绩         inputStudentGrade(studentList->arr[i]);     }     //排名     sortStudentList(studentList);     //打印     printStudentList(studentList);     freeStudentList(studentList);     return 0; }  /**  * 创建  * @return  */ static StudentGrade * createStudentGrade(){     return (StudentGrade*)calloc(1, sizeof (StudentGrade)); }  /**  * 释放内存  * @param grade  */ static void freeStudentGrade(StudentGrade* grade){     free(grade); } /**  * 创建列表  * @return  */ static StudentList * createStudentList(int n){     //分片内存     StudentList * list = calloc(1, sizeof (StudentList));     if(n > 10){         printf(\"list size must less than 10\\n\");         exit(1);     }     list->n = n;     for(int i = 0; i < n; i++){         //创建学生成绩对象         list->arr[i] = createStudentGrade();     }     return list; } /**  * 排序  * @param studentList  */ static void sortStudentList(StudentList* studentList){     StudentGrade * temp;     //冒泡排序     for(int i = 0; i < studentList->n; i++){         for(int j = 0; j < studentList->n - i -1; j++){             if(studentList->arr[j]->total < studentList->arr[j+1]->total){                 temp = studentList->arr[j];                 studentList->arr[j] = studentList->arr[j+1];                 studentList->arr[j+1] = temp;             }         }     }     //设置排名     int rank = 1;     studentList->arr[0]->rank = rank++;     for(int i = 1; i < studentList->n; i++){         if(studentList->arr[i]->total == studentList->arr[i-1]->total){             rank--;         }         studentList->arr[i]->rank = rank++;     } }  /**  * 释放内存  * @param studentList  */ static void freeStudentList(StudentList* studentList){     for(int i = 0; i < studentList->n; i++){         //释放学生对象 内存         freeStudentGrade(studentList->arr[i]);     }     //释放列表内存     free(studentList); } /**  * 获取输入数字  * @param min 最小值  * @param max 最大值  * @return  */ static int getNumFromInput(int min, int max){     int n;     int i;     while (1){         i =  scanf(\"%d\", &n);         if(i == 1 && getchar() == '\\n'){             if(n > max || n < min){                 printf(\"the number should be %d-%d!\\n\", min, max);                 continue;             }             break;         }else {             printf(\"please input a number!\\n\");         }         while(1)//清空缓存区         {             char c = getchar();             if(c == '\\n')                 break;         }      }     return n; }  /**  * 输入学生成绩，格式: 学号 数学 英语 语文  * @param grade  */ static void inputStudentGrade(StudentGrade* grade){     scanf(\"%s %d %d %d\", grade->no, &grade->mathGrade, &grade->enGrade,&grade->chGrade);     grade->total = grade->mathGrade + grade->enGrade + grade->chGrade;     grade->avg = grade->total/3;     printf(\"no:%s, math:%d, en:%d, ch:%d, total:%d, avg:%d\\n\", grade->no, grade->mathGrade,            grade->enGrade, grade->chGrade, grade->total, grade->avg); } /**  * 打印学生成绩列表  * @param studentList  */ static void printStudentList(StudentList* studentList){     printf(\"rank result:\\n\");     printf(\"%4s%10s%5s%5s%5s%10s%5s\\n\", \"rank\",\"no\", \"math\",\"en\", \"ch\",\"total\", \"avg\");     for(int i = 0;i < studentList->n; i++){         printf(\"%4d%10s%5d%5d%5d%10d%5d\\n\",                studentList->arr[i]->rank,                studentList->arr[i]->no,                studentList->arr[i]->mathGrade,                studentList->arr[i]->enGrade,                studentList->arr[i]->chGrade,                studentList->arr[i]->total,                studentList->arr[i]->avg);     } }", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "我的回复收到了吗？怎么感觉被吞了", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "6666666,我也不会哦", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "大兄弟啊，你还是不适合编程呢", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 7 楼 自信男孩的回复:[quote=引用 6 楼 change_2 的回复:][quote=引用 5 楼 change_2的回复:][quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 change_2 的回复:][quote=引用 2 楼 自信男孩的回复:]做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～ 是的，是一条代码也不会写，专业不需要这个，只学一学期，网上找的是错的[/quote] 是错的描述，意思是不满足你的要求吧，还是网上的代码本身就有问题？ 我想不会每个代码都是自身有问题的吧[/quote] 编译运行的时候出错了，运行不了[/quote] 就是这个论坛的代码，编译运行时错误[/quote] 编译和运行的错误是两个独立的错误，先确定是编译出错，还是运行出错。另外，代码也得贴出来呀～[/quote] 这个代码提示编译错误，还有我想把里面关于姓名的东西给删掉，怎么删？", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 7 楼 自信男孩的回复:[quote=引用 6 楼 change_2 的回复:][quote=引用 5 楼 change_2的回复:][quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 change_2 的回复:][quote=引用 2 楼 自信男孩的回复:]做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～ 是的，是一条代码也不会写，专业不需要这个，只学一学期，网上找的是错的[/quote] 是错的描述，意思是不满足你的要求吧，还是网上的代码本身就有问题？ 我想不会每个代码都是自身有问题的吧[/quote] 编译运行的时候出错了，运行不了[/quote] 就是这个论坛的代码，编译运行时错误[/quote] 编译和运行的错误是两个独立的错误，先确定是编译出错，还是运行出错。另外，代码也得贴出来呀～[/quote] #include <stdio.h> #include <stdlib.h> #include <string.h> #define N 10  typedef struct Students {     int id;     char name[10];     int math;     int en;     int ch;  }STU;  STU stu[N];  void sortInfo(STU stu[], int n); void swapInfo(STU *p, STU *q);  int main() {     int n = 10, m = 0, w = 1;          scanf(\"%d\", &n);         if (n>9||n<1) {             printf(\"Please input 1-9.\");             return 0;             }      for (int i = 0; i<n; i++) {         scanf(\"%d%s%d%d%d\", &stu[i].id, &stu[i].name, &stu[i].math, &stu[i].en, &stu[i].ch);      }     sortInfo(stu, n);     for (int i = 0; i < n; i++) {          if (i >0) {             if ((stu[i].en + stu[i].ch + stu[i].math) == (stu[i - 1].en + stu[i - 1].ch + stu[i - 1].math)) {                 m++;                 printf(\"%4d\", w - m);             }             else {                 printf(\"%4d\", w);                 m = 0;             }         }         else {             printf(\"%d\", w);         }         printf(\"%10d%10s%5d%5d%5d\\n\", stu[i].id, stu[i].name, stu[i].math, stu[i].en, stu[i].ch);          w++;     }     return 0; }  void sortInfo(STU stu[], int n) {     int i, j;     for (i = 0; i < n - 1; i++) {         for (j = 0; j < n - 1 - i; j++) {             int a = stu[j].en + stu[j].ch + stu[j].math, b = stu[j + 1].en + stu[j + 1].ch + stu[j + 1].math;             if (a<b) {                 swapInfo(&stu[j], &stu[j + 1]);             }             else if ((a == b) && (stu[j].id >stu[j + 1].id)) {                 swapInfo(&stu[j], &stu[j + 1]);             }         }     }  } void swapInfo(STU *p, STU *q) {     STU trmp;     trmp = *p; *p = *q; *q = trmp; }", "referer": "user-0"}, {"cid": "12", "user": "user-10", "content": "6666666,我也不会哦", "referer": "user-0"}, {"cid": "13", "user": "user-11", "content": "引用 6 楼 change_2 的回复:[quote=引用 5 楼 change_2的回复:][quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 change_2 的回复:][quote=引用 2 楼 自信男孩的回复:]做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～ 是的，是一条代码也不会写，专业不需要这个，只学一学期，网上找的是错的[/quote] 是错的描述，意思是不满足你的要求吧，还是网上的代码本身就有问题？ 我想不会每个代码都是自身有问题的吧[/quote] 编译运行的时候出错了，运行不了[/quote] 就是这个论坛的代码，编译运行时错误[/quote] 编译和运行的错误是两个独立的错误，先确定是编译出错，还是运行出错。另外，代码也得贴出来呀～", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 5 楼 change_2的回复:[quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 change_2 的回复:][quote=引用 2 楼 自信男孩的回复:]做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～ 是的，是一条代码也不会写，专业不需要这个，只学一学期，网上找的是错的[/quote] 是错的描述，意思是不满足你的要求吧，还是网上的代码本身就有问题？ 我想不会每个代码都是自身有问题的吧[/quote] 编译运行的时候出错了，运行不了[/quote] 就是这个论坛的代码，编译运行时错误", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:[quote=引用 3 楼 change_2 的回复:][quote=引用 2 楼 自信男孩的回复:]做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～ 是的，是一条代码也不会写，专业不需要这个，只学一学期，网上找的是错的[/quote] 是错的描述，意思是不满足你的要求吧，还是网上的代码本身就有问题？ 我想不会每个代码都是自身有问题的吧[/quote] 编译运行的时候出错了，运行不了", "referer": "user-0"}, {"cid": "16", "user": "user-11", "content": "引用 3 楼 change_2 的回复:[quote=引用 2 楼 自信男孩的回复:]做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～ 是的，是一条代码也不会写，专业不需要这个，只学一学期，网上找的是错的[/quote] 是错的描述，意思是不满足你的要求吧，还是网上的代码本身就有问题？ 我想不会每个代码都是自身有问题的吧", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～ 是的，是一条代码也不会写，专业不需要这个，只学一学期，网上找的是错的", "referer": "user-0"}, {"cid": "18", "user": "user-11", "content": "做不出来，是一条代码都写不出来吗？现在哭好像没啥用，学习的时候着急，应该学的就会很认真了。  先自己写写吧，或者参考一下网上的代码，自己改改。什么都不做，就要调试好的，不现实～", "referer": "user-0"}, {"cid": "19", "user": "user-12", "content": "这个不是很难", "referer": "user-0"}, {"cid": "20", "user": "user-13", "content": "把上面的代码复制，点左上角红圈的地方就可以复制，然后再粘贴到你的编译器里。", "referer": "user-0"}]}
{"question": "段错误:您的程序发生段错误，可能是数组越界，堆栈溢出（比如，递归调用层数太多）等情况引起", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "ListNode* ReverseList(ListNode* pHead) {     if (!pHead)    //判断头结点是否为NULL         return NULL;          ListNode* q = NULL;         ListNode* g = NULL;         q = pHead->next;         pHead->next = NULL;         while(q!=NULL){             g = q->next;             q->next = pHead;             pHead = q;             q = g;         }        return pHead;     } }; 供参考   翻转基本上没什么问题（进入参数先判断一下是否为空链表），建议查一下传入该函数的参数是否正常（传入的链表是否正常）；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}]}
{"question": "如何安装第三方库？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考：#include <stdio.h>  int main() {    int i,tmp,rmd,sum;    for(i=100; i<=999; i++){        tmp=i;        sum=0;        while(tmp>0){              rmd=tmp%10;              sum+=rmd*rmd*rmd;              tmp/=10;        }        if(sum==i){          printf(\"%d\\n\",i);        }    }    return 0; }", "referer": "user-0"}]}
{"question": "C语言 关于日期和星期 大佬救救我", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修正8#楼的错误，供参考：#include <stdio.h>  int  get_Week(int y,int m,int d); int  isLeap(int y); int  GetDaysOfMonth(int y, int m); void CountDaysOfCoincide(int *cdofc,int y,int m,int s_d=1,int e_d=0);  int main() {     int i,y,m,year,month,day,year1,month1,day1;     int cdofc[8]; //([0]:总数，[1~7]:周一 ~ 周日)      while (1){            for(i=0;i<8;i++) cdofc[i]=0;            if(scanf(\"%d%d%d\",&year,&month,&day)==EOF)break; //ctrl+Z 结束输入            scanf(\"%d%d%d\",&year1,&month1,&day1);            if((day > GetDaysOfMonth(year,month)) ||(day1 > GetDaysOfMonth(year1,month1))||                          day < 1 || day1<1 || month>12 || month1> 12 || month<1 || month1<1)                printf(\"Invalid date,input again!\\n\");            else{                if(year==year1 && month==month1)   //同年同月                    CountDaysOfCoincide(cdofc,year,month,day,day1-1);                else{                    CountDaysOfCoincide(cdofc,year,month,day);                    for(y=year,m=month+1,m>12?(m=1,y++):m;y<=year1 ;m++,m>12?(m=1,y++):m){                        if(y==year1 && m==month1)break;                        CountDaysOfCoincide(cdofc,y,m);                    }                    if(day1!=1)                         CountDaysOfCoincide(cdofc,year1,month1,1,day1-1);                }                for(i=1;i<8;i++)cdofc[0]+=cdofc[i];                printf(\"%d %d %d %d %d %d %d %d\\n\",cdofc[0],cdofc[1],cdofc[2],cdofc[3],                                                   cdofc[4],cdofc[5],cdofc[6],cdofc[7]);            }     }     system(\"pause\");     return 0; }  int get_Week(int y,int m,int d) {     int week = 0;     if(m==1 || m == 2){        m += 12;y--;     }     week=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;     return week; }  int isLeap(int y) {     if((y%4==0 && y%100!=0)||(y%400==0))         return 1;     else         return 0; }  int GetDaysOfMonth(int y, int m) {     int daysOfMonth[12] = {31,28,31,30,31,30,31,31,30,31,30,31};     if(isLeap(y) && m == 2) return daysOfMonth[m-1]+1;     return daysOfMonth[m-1]; }  void CountDaysOfCoincide(int *cdofc,int y,int m,int s_d,int e_d)//月的吻合日天数 {     int week = get_Week(y,m,s_d)+1;     int days;     if(e_d == 0)days = GetDaysOfMonth(y,m);     else        days = e_d;     int i    = s_d;     while(i <= days){           if(week == i%10) cdofc[week]++;           week = (week + 1) % 7;           if(week == 0) week =7;           i++;     } }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "觉得终止年月日的控制（不含），一段时间范围内的控制，才是真麻烦，大家批评指正，供参考：#include <stdio.h>  int  get_Week(int y,int m,int d); int  isLeap(int y); int  GetDaysOfMonth(int y, int m); void CountDaysOfCoincide(int *cdofc,int y,int m,int d=1);  int main() {     int i,y,m,year,month,day,year1,month1,day1;     int cdofc[8]; //([0]:总数，[1~7]:周一 ~ 周日)      while (1){            for(i=0;i<8;i++) cdofc[i]=0;            if(scanf(\"%d%d%d\",&year,&month,&day)==EOF)break; //ctrl+Z 结束输入            scanf(\"%d%d%d\",&year1,&month1,&day1);            if((day > GetDaysOfMonth(year,month)) ||(day1 > GetDaysOfMonth(year1,month1))||                          day < 1 || day1<1 || month>12 || month1> 12 || month<1 || month1<1)                printf(\"Invalid date,input again!\\n\");            else{                if(year==year1 && month==month1)   //同年同月                    CountDaysOfCoincide(cdofc,year,month,day);                else{                    CountDaysOfCoincide(cdofc,year,month,day);                    for(y=year,m=month+1; y<=year1 ;m++,m>12?(m=1,y++):m){                        if(y==year1 && m==month1)break;                        CountDaysOfCoincide(cdofc,y,m);                    }                    if(month1!=1 && day1!=1)                        CountDaysOfCoincide(cdofc,year1,month1);                }                for(i=1;i<8;i++)cdofc[0]+=cdofc[i];                printf(\"%d %d %d %d %d %d %d %d\\n\",cdofc[0],cdofc[1],cdofc[2],cdofc[3],                                                   cdofc[4],cdofc[5],cdofc[6],cdofc[7]);            }     }     system(\"pause\");     return 0; }  int get_Week(int y,int m,int d) {     int week = 0;     if(m==1 || m == 2){        m += 12;y--;     }     week=(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;     return week; }  int isLeap(int y) {     if((y%4==0 && y%100!=0)||(y%400==0))         return 1;     else         return 0; }  int GetDaysOfMonth(int y, int m) {     int daysOfMonth[12] = {31,28,31,30,31,30,31,31,30,31,30,31};     if(isLeap(y) && m == 2) return daysOfMonth[m-1]+1;     return daysOfMonth[m-1]; }  void CountDaysOfCoincide(int *cdofc,int y,int m,int d)//月的吻合日天数 {     int days = GetDaysOfMonth(y,m);     int week = get_Week(y,m,d)+1;     int i    = d;     while(i <= days){           if(week == i%10) cdofc[week]++;           week = (week + 1) % 7;           if(week == 0) week =7;           i++;     } }  //2021 2 1 //2021 3 31 //14 2 2 2 2 2 2 2 //^Z //请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "90009同学闷头鼓捣小代码，不注意听讲，又退步了~", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "这题 唯一的难点是 知道一个日期怎么确定是周几 这个其实有固定的数学公式可以计算 比如 蔡勒公式 你查查这种公式然后套进去  就完事了", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 4 楼 智者知已应修善业 的回复: 2022-3-2 是周三  你又错了哦", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "C和C++完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "能否给个明确的代码", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "可参自适应函数", "referer": "user-0"}]}
{"question": "求助，请问这个函数哪里有问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "LoadLibrary根据什么判断DLL已加载？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我成了“有人”；还好没成“等”。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 18 楼 六道佩恩 的回复:你们都说判断DLL是根据全路径的 我可没有这么说。上面有人贴的链接里其实说的很清楚了，在正常搜索DLL之前，就有特例：    1、应用程序自己使用了DLL redirection（.loacl文件）或者使用了manifest文件控制dll载入目录 2、应用程序已经载入了一个同名dll模块，不论它的路径在哪，都不会再继续搜索dll（载入是指已在程序的虚拟空间中） 3、dll是已知dll，或者任何已知dll的依赖dll（所谓已知dll在注册表中列出：HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\KnownDLLs.）   当不满足上面的条件时，应用程序才会按照标准搜索顺序搜索dll：    搜索顺序分两种，取决于安全搜索模式是否开启（默认开启，可通过注册表关闭或通过调用 SetDllDirectory关闭）。 如果安全搜索模式开启，则顺序如下： 1、应用程序所在目录 2、系统目录.  3、16位系统目录. 4、Windows目录. 5、当前目录. 6、环境变量PATH指定的目录  如果安全搜索模式关闭，则顺序如下： 1、应用程序所在目录 2、当前目录. 3、系统目录.  4、16位系统目录. 5、Windows目录. 6、环境变量PATH指定的目录  另外还有高级搜索模式，通过使用LOAD_WITH_ALTERED_SEARCH_PATH调用 LoadLibraryEx开启，具体自己去看上面其他人发的那个链接吧。   注意！上面的规则都是以一个应用程序实例的视角来说的，不用应用程序实例是互不影响的，所以你说的： 引用 18 楼 六道佩恩 的回复:其实最开始的问题主要是想知道，当物理内存中已经有一个同名DLL时，此时加载该名称的DLL是重新找还是直接映射到虚拟内存。 这个问题的答案，对你想知道的结果来说，没有任何意义。不管系统是否会重复载入同一个dll到物理内存，都能满足上面所说的一个应用程序实例看到的规则。 说白了，就是因为你不知道已知DLL（known DLL）的概念，导致你想的太多了。。  最后给你捋一下,对于同一个应用程序实例来说！！！ 引用 18 楼 六道佩恩 的回复:你们都说判断DLL是根据全路径的 错！！ 只判断名字！！ 引用 18 楼 六道佩恩 的回复:是官方的DLL有特殊性？ 对！！known DLL", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 18 楼 六道佩恩 的回复:只不过，刚刚的gdi32.dll的测试并不完全符合这一行为。 Certain operating system-supplied DLLs get special treatment. These are called known DLLs. They are just like any other DLL except that the operating system always looks for them in the same directory in order to load them. Inside the registry is the following key:  HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\KnownDLLs", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "Process Monitor 实时监视文件系统、注册表、进程、线程和 DLL 活动。 http://www.microsoft.com/china/technet/sysinternals/utilities/processmonitor.mspx", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "Process Explorer 找出进程打开了哪些文件、注册表项和其他对象，已加载哪些 DLL 等信息。这个功能异常强大的实用工具甚至可以显示每个进程的所有者。http://www.microsoft.com/china/technet/sysinternals/utilities/ProcessExplorer.mspx", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 21 楼 Intel0011 的回复:  我真是羞愧，没有好好看文档，原来都写了的  真的非常感谢！", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "写了啥？我都看完了还是一脸懵。_mervyn解释了单个exe实例只会加载同一个dll一次，多个不同exe到底是怎么判断某个dll是否加载的呢(既然全路径都不行)？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 22 楼 _mervyn 的回复:  非常感谢！！！ 麻烦您了！！！", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "山，就在那里 如果你的目标是征服高山，那就做好准备，上 但如果你的目标是征服大海，那就没必要和每座路过的山较真儿", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "嗯，我其实是打酱油的。 我的懒人哲学一直认为，不打算写操作系统的猿，就应该信任操作系统。 也就是相信系统能做到它承诺做到的那些事，然后去快乐地做我们自己的事。  操作系统里面应该有很多类似于C语言里面的所谓“未定义行为”的自行发挥的部分，闭源系统可能不希望猿们深入它的实现细节，也许它会在下一个版本替换实现细节，只留下一致性接口。  快乐来自适可而止，请相信我。 当然，天花板也来自“适可”而止，所以请不要相信我。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 17 楼 _mervyn 的回复:所以，所谓的LoadLibrary判断dll是否已加载，针对的是虚拟地址。 这点不能搞混。  感谢您来问答  前面关于LoadLibrary那个，是我将调用LoadLibrary后直到它返回期间的行为统称为LoadLibrary的行为，其实应该也可以这样看吧，总得有代码去判断。 我说的这个判断是指对于已经加载到物理内存（加载后到未从物理内存释放期间，包含了换出到硬盘）后，如果已经加载到物理内存，判断到这一行为后，直接将其映射到进程的虚拟空间，而不是再去加载  你们都说判断DLL是根据全路径的，但我测试过程中发现一些奇怪的事  首先我要确定加载目录先于system32，除了通过微软的文档，也将两个同名不同内容的DLL放到system32和程序同目录，根据DllMain的输出可以确定，优先加载的是程序所在目录的DLL  确定了这点后，将程序所在目录的DLL命名为gdi32.dll，写如下代码  \tHMODULE h0 = GetModuleHandleA( \"gdi32.dll\" ); \tprintf(\"h0=%p\\n\", h0 ); \tHMODULE h1 = LoadLibrary( \"gdi32.dll\" ); \tprintf(\"h=%p\\n\", h1 );  前两行通过输出可以肯定没有加载gdi32.dll，第三行加载gdi32.dll的时候，没有输出预先设置在DllMain中的字符串，说明此时加载的是system32下的gdi32.dll，而不是程序所在目录自定义的gdi32.dll。（为确保自己的gdi32.dll有正确的输出行为，加载时指定.\\\\gdi32.dll，能得到预期的结果）  这里就有问题了，它并没有按我期望的加载当前目录的DLL 我推测是内存中已经加载过gdi32.dll了，因为出现同名DLL，所以直接映射过来了，这个行为看起来还是根据文件名来的  但又做了测试，结果又不同 程序A加载A.dll不退出，程序B和它是不同文件夹，它也加载一个不同内容的A.dll，根据输出来看，最终加载的是程序B同目录的A.dll 程序A的A.dll仍在内存中，说明这里又没完全根据名称来，而是确实做了搜索工作的  这么说的话，是官方的DLL有特殊性？    其实最开始的问题主要是想知道，当物理内存中已经有一个同名DLL时，此时加载该名称的DLL是重新找还是直接映射到虚拟内存。 现在根据你们的解惑，算上完整路径的话，当找到的DLL和物理内存中的DLL的完整路径相同（即同一文件），那么直接从物理内存中映射过来； 如果找到的DLL和内存中同文件名的DLL（一个或多个）的路径不同，那么还是会将其加载到物理内存，并映射到当前程序的虚拟内存中 是这样的吧？我是这样理解的。  只不过，刚刚的gdi32.dll的测试并不完全符合这一行为。", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "模块名不是可以", "referer": "user-0"}, {"cid": "13", "user": "user-2", "content": "所以，所谓的LoadLibrary判断dll是否已加载，针对的是虚拟地址。 这点不能搞混。", "referer": "user-0"}, {"cid": "14", "user": "user-2", "content": "引用 10 楼 六道佩恩 的回复:这是微软的一段原话 If a DLL with the same module name is already loaded in memory, the system checks only for redirection and a manifest before resolving to the loaded DLL, no matter which directory it is in. The system does not search for the DLL.  按这说的，出现同名的模块，系统不会再搜索第二个的（如果我没理解错的话）  这说的是针对同一个应用程序（exe）来说的。 针对同一个exe运行实例来说，如果它已经加载了一个A.dll，再次加载同名A.dll 是不起作用的，哪怕它们路径不同！  请不要对此有怀疑。 在这种情况下，它就是根据dll名称区别的。  在你确定上述这一点之后，再来看你说的另一种情况： 引用 4 楼 六道佩恩 的回复:比如A程序加载的A.dll在它的当前文件夹 然后B程序也要加载一个A.dll（与之前的A.dll不一样，只是恰好名字一样），这个dll也在B程序的当前文件夹，你看，这就跟搜索顺序无关了对吧 接着，B加载A.dll的时候，系统已经将一个A.dll加载到物理内存了，那么面对B程序要加载当前文件夹的A.dll，是加载还是不加载？ 加载吧，内存里已经有一个同名的DLL了，映射过来就可以了 不加载吧，可两个DLL明明不一样，B程序希望加载的可用的DLL，但系统没给它加载 是这么个问题 首先，你既然问出了“LoadLibrary根据什么判断DLL已加载” 这个问题，就说明你从某处得知LoadLibrary会判断dll是否已加载。 而这点一般情况下说的都是针对一个exe的单个运行实例来说的。我不知道你对这点是否有理解错误才提出的这个多个exe运行实例的例子（包括同名exe的多个运行实例）。 我先假设你是理解错误了，如果你是明确从某处得知的“多个exe实例或同名exe的多个运行实例加载dll也会判断是否已加载过”这个信息的。请不要听我接下来说的，并请告诉我你从哪里获取的信息。 因为关于这一点我也不是很明确，所以接下来说的是以我的经验常识推断的：  我认为多个进程间加载dll肯定是毫无影响的。这里我说的加载是指 将dll映射至进程自身的虚拟地址。 因为事实就是如此（A.exe和B.exe一定能够得到正确的A.dll），所以从事实反推，通过一个dll文件的全路径来判断是否需要将其从硬盘装进物理内存肯定是可以办到的，而只判断名称显然是不行的。 而且我认为“判断该dll是否已经装进在物理内存里了” 这件事情跟LoadLibrary没有关系，这应该是系统 ”内存管理“ 功能相关的知识，在需要的时候装入内存，在不需要的时候换出到硬盘。  另外说一句，一个dll的文件内容是否在实际的物理内存里，不仅仅依靠是否调用过LoadLibrary就能确定的，如果你LoadLibrary之后经常不用甚至完全不用该dll的内容，它很有可能被系统换出到硬盘甚至只把一部分换出到硬盘，把位置留给更需要的内容。", "referer": "user-0"}, {"cid": "15", "user": "user-7", "content": "和dll的名称没关系", "referer": "user-0"}, {"cid": "16", "user": "user-8", "content": "牛逼，大佬们厉害", "referer": "user-0"}, {"cid": "17", "user": "user-1", "content": "Dynamic-Link Library Search Order https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order", "referer": "user-0"}, {"cid": "18", "user": "user-3", "content": "引用 10 楼 六道佩恩 的回复:[quote=引用 6 楼 Intel0011 的回复:] 你忽略了一点，虽然两个的名称都是A.dll，但两者的全路径不同呀，系统还是能区分的  你的意思是，路径也作为了辨识DLL的一环吗？  这是微软的一段原话，你那个链接里的 If a DLL with the same module name is already loaded in memory, the system checks only for redirection and a manifest before resolving to the loaded DLL, no matter which directory it is in. The system does not search for the DLL.  按这说的，出现同名的模块，系统不会再搜索第二个的（如果我没理解错的话）[/quote] 路径也作为了辨识DLL的一环吗？--->那是当然的，如果有manifest文件的话，又会使用manifest文件中指定的版本，所以说比较复杂", "referer": "user-0"}, {"cid": "19", "user": "user-9", "content": "A程序与程序B不在同一个文件夹，那和A与B的当前路径就不一样，那么各自加载的当前路径下的dll全路径就不一样，所以dll就不一样。 A程序与程序B在同一个文件夹，那和A与B的当前路径就一样，那么各自加载的当前路径下的dll全路径就一样，所以dll就一样。 另外说一句： 1: 每个程序的当前路径好像是可以修改的. 2: 系统中给每个程序维护了一个dll加载链表，如果手动修改此链表，导致其它需要的行为。", "referer": "user-0"}, {"cid": "20", "user": "user-5", "content": "在这个问题上我完全是主观臆断的，想当然。", "referer": "user-0"}, {"cid": "21", "user": "user-3", "content": "引用 4 楼 六道佩恩 的回复:[quote=引用 3 楼 Intel0011 的回复:][quote=引用 楼主 六道佩恩 的回复:]是根据名称吗？ 如果程序1已加载过A.dll，此时程序2也需要加载一个A.dll，但两个DLL完全不同，那么LoadLibrary会认为这是两个相同DLL而直接将之前的DLL映射过来，还是会判定出两个DLL的不同而重新加载？ 这个涉及到DLL的搜索路径问题，比较复杂，请参阅 https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order [/quote]  搜索顺序我知道呀，我说的是另外的一个问题 比如A程序加载的A.dll在它的当前文件夹 然后B程序也要加载一个A.dll（与之前的A.dll不一样，只是恰好名字一样），这个dll也在B程序的当前文件夹，你看，这就跟搜索顺序无关了对吧 接着，B加载A.dll的时候，系统已经将一个A.dll加载到物理内存了，那么面对B程序要加载当前文件夹的A.dll，是加载还是不加载？ 加载吧，内存里已经有一个同名的DLL了，映射过来就可以了 不加载吧，可两个DLL明明不一样，B程序希望加载的可用的DLL，但系统没给它加载 是这么个问题[/quote] 你忽略了一点，虽然两个的名称都是A.dll，但两者的全路径不同呀，系统还是能区分的", "referer": "user-0"}]}
{"question": "数据结构小白请教各位大佬一个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h>  #define TRUE 1 #define FALSE 0 #define OK  1 #define ERROR 0 #define INFEASIBLE  -1 #define OVERFLOW   -2 //#define NULL ((void *)0)  typedef int Status; typedef int ElemType;  typedef struct LNode {     ElemType data;     struct LNode  *next; }LNode,*LinkList;  typedef  LNode *LinkList; void CreateList_L(LinkList *L, int n); void MergeList_L(LinkList La, LinkList Lb, LinkList *Lc); void OutputList(LinkList L);  void  CreateList_L(LinkList *L, int n) {     int i;     LinkList p;     *L = (LinkList)malloc(sizeof(LNode));     (*L)->next = NULL;     for (i = 0; i < n; ++i) {         p = (LinkList)malloc(sizeof(LNode));         scanf(\"%d\",&p->data);         p->next = (*L)->next;         (*L)->next = p;     } }//CreateList_L void MergeList_L(LinkList La, LinkList Lb, LinkList *Lc) {     LinkList pa, pb, pc;     pa = La->next; pb = Lb->next;     *Lc = pc = La;     while(pa&&pb)         if (pa->data<=pb->data) {             pc->next = pa; pc = pa; pa = pa->next;         }         else { pc->next = pb, pc = pb, pb = pb->next; }     pc->next = pa ? pa : pb;     free(Lb); }//MergeList_L void OutputList(LinkList L) {     LinkList q;     q=L->next;     while(q){         printf(\"%d\",q->data);         q=q->next;     } }//OutputList_L int main() {     LinkList L1,L2,L3;     printf(\"Please enter the element of L1:\\n\");     CreateList_L(&L1, 4);     printf(\"Please enter the element of L2:\\n\");     CreateList_L(&L2, 4);     printf(\"The LinkList L1 is:\\n\");     OutputList(L1);     printf(\"The LinkList L2 is:\\n\");     OutputList(L2);     MergeList_L(L1, L2, &L3);     printf(\"The LinkList L3 is:\\n\");     OutputList(L3);     return 0; } 供参考～  试一下这个版本，然后对比一下这两个代码的区别，找出自己的问题；  另外，重点学习一下参数传递，传入参数、传出参数等等；", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我的单链表可以输入但无法输出，语法没有错误，请各位大佬帮忙看一看", "referer": "user-0"}]}
{"question": "问问大佬，这个咋弄啊，C语言设计，球球救救孩子吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "关于网络编程定时器使用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以添加心跳机制，即client每隔5秒发一个心跳包，包的大小可以随意定义，只要server能识别这是一个心跳包即可，服务器（也需要一个定时器）定时去检查上次收到心跳包的时间和现在做差，大于5秒则直接关闭连接～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "跟你用的网络模型有关，如果使用了select或者epoll，直接用它们自带的定时器就可以，如果时间长短不合适，可以加个倍数关系，比如select 1秒阻塞时间，那就返回5次再清理旧的链接，判断是否是旧链接也很简单，就看select的结果就可以了 如果采用定时器，那就得自己实现一个了，比较麻烦", "referer": "user-0"}]}
{"question": "求助，c语言简单问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Segmentation fault (core dumped)指段错误，一般指非法地址访问，就是访问到不可以读写的内存位置，这是系统从安全角度，保证系统正常运行所必须的～  比如一个系统才能访问的地址，一个自定义程序去访问（比如读写）这个地址上的内容，那么就可能导致系统异常，因此不允许其访问～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 forever74的回复:是啊，那里不能单引号。 哦，好的，谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 forever74的回复:是啊，那里不能单引号。 哦，好的，谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "是啊，那里不能单引号。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 forever74的回复:Error CFFFF: 楼主眼花看错了。 是说单引号是错误的使用方法吗", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "是说单引号是错误的使用方法吗", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "Error CFFFF: 楼主眼花看错了。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "不过引号里面的内容不是单个字符，就不要用单引号吧。虽然PHP里面单引号可以替代双引号，但是C/C++这类严谨的语言用不得", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "fopen()用法，供参考：https://blog.csdn.net/weixin_33878457/article/details/85712854?utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control&dist_request_id=1331978.858.16185879177551633&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control Segmentation fault (core dumped)的错误，这句话意思就是段错误（核心转储），Core Dump 是操作系统在进程收到某些信号而终止运行时，将此时进程地址空间的内容以及有关进程状态的其他信息写出的一个磁盘文件。在这里出现这问题，按你的描述就是操作文件时出现无法解析的字符，所以上面给了fopen()用法链接供参考。", "referer": "user-0"}]}
{"question": "请问一下这个程序怎么运行不了，出现的错误是什么意思，应该怎么改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf中的score缺少&和[],或者直接这样：  scanf(\"%d\", score + i);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这个函数的声明和实现，两边不一样呢，在声明的地方中间少了's'，红圈标出。", "referer": "user-0"}]}
{"question": "if条件中使用取反出现问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include<stdio.h>  int main() {     unsigned char data1,data2; //unsigned char 的取值范围为0~255     unsigned char temp;     data1=0x01;     data2=0xfe; //254     temp = ~data2;     //这里隐含强制转换，无符号数                        //注意，计算机存储的都是数的补码，无论是正数还是负数     //if(data1 == ~data2)// ~data2 按位取反，在内存中形式为 -255,-255 != 1;并不是我们想像的0x01.     if(data1 == temp)    //这里temp=0x01        printf(\"temp1和temp2想等\\n\");     else        printf(\"temp1和temp2不相等\\n\");      printf(\"data2:0x%x,temp:0x%x\\n\",data2,temp);     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 qzjhjxj 的回复:供参考：#include<stdio.h>  int main() {     unsigned char data1,data2; //unsigned char 的取值范围为0~255     unsigned char temp;     data1=0x01;     data2=0xfe; //254     temp = ~data2;     //这里隐含强制转换，无符号数                        //注意，计算机存储的都是数的补码，无论是正数还是负数     //if(data1 == ~data2)// ~data2 按位取反，在内存中形式为 -255,-255 != 1;并不是我们想像的0x01.     if(data1 == temp)    //这里temp=0x01        printf(\"temp1和temp2想等\\n\");     else        printf(\"temp1和temp2不相等\\n\");      printf(\"data2:0x%x,temp:0x%x\\n\",data2,temp);     system(\"pause\");     return 0; }  感谢大佬热心的回答  哈哈", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 真相重于对错 的回复:[quote=引用 3 楼 dajkhsdawe 的回复:][quote=引用 2 楼 真相重于对错 的回复:]~ 操作符的结果是int，自动扩至32位。并不是你想的还是unsigned char. unsigned char最高位按符号位处理，扩展到结果高位，除符号位外，其余按位反转。 0xfe 按位取反后的实际是 0xffffff01。这个结果就是-255. 你的判断这么写就可以了  if(data1==(unsigned char)~data2)  取反会发生强制类型转换吗[/quote] 不是强制类型转换，专业名词叫整形提升。   引用 3 楼 dajkhsdawe 的回复:[quote=引用 2 楼 真相重于对错 的回复:]~ 操作符的结果是int，自动扩至32位。并不是你想的还是unsigned char. unsigned char最高位按符号位处理，扩展到结果高位，除符号位外，其余按位反转。 0xfe 按位取反后的实际是 0xffffff01。这个结果就是-255. 你的判断这么写就可以了  if(data1==(unsigned char)~data2)  取反会发生强制类型转换吗[/quote] 如果你有疑虑请去查c/c++标准。这个是王八的屁股-规定。[/quote]   哈哈  原来如此    感谢感谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 3 楼 dajkhsdawe 的回复:[quote=引用 2 楼 真相重于对错 的回复:]~ 操作符的结果是int，自动扩至32位。并不是你想的还是unsigned char. unsigned char最高位按符号位处理，扩展到结果高位，除符号位外，其余按位反转。 0xfe 按位取反后的实际是 0xffffff01。这个结果就是-255. 你的判断这么写就可以了  if(data1==(unsigned char)~data2)  取反会发生强制类型转换吗[/quote] 不是强制类型转换，专业名词叫整形提升。   引用 3 楼 dajkhsdawe 的回复:[quote=引用 2 楼 真相重于对错 的回复:]~ 操作符的结果是int，自动扩至32位。并不是你想的还是unsigned char. unsigned char最高位按符号位处理，扩展到结果高位，除符号位外，其余按位反转。 0xfe 按位取反后的实际是 0xffffff01。这个结果就是-255. 你的判断这么写就可以了  if(data1==(unsigned char)~data2)  取反会发生强制类型转换吗[/quote] 如果你有疑虑请去查c/c++标准。这个是王八的屁股-规定。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 真相重于对错 的回复:~ 操作符的结果是int，自动扩至32位。并不是你想的还是unsigned char. unsigned char最高位按符号位处理，扩展到结果高位，除符号位外，其余按位反转。 0xfe 按位取反后的实际是 0xffffff01。这个结果就是-255. 你的判断这么写就可以了  if(data1==(unsigned char)~data2)  取反会发生强制类型转换吗", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "~ 操作符的结果是int，自动扩至32位。并不是你想的还是unsigned char. unsigned char最高位按符号位处理，扩展到结果高位，除符号位外，其余按位反转。 0xfe 按位取反后的实际是 0xffffff01。这个结果就是-255. 你的判断这么写就可以了  if(data1==(unsigned char)~data2)", "referer": "user-0"}]}
{"question": "小白提问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++ 完整教程：https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++ 算法完整教程：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你输入了两个字符，'N'和'\\n' 因此输出两个字符，'n'（'N'+32）和'*'（'\\n'+32）", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "'\\n'也是会在下次的scanf中被c接收的。  查一下*的字符的ascii值：42正好匹配；", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "\\n的码值是10，加上32以后就是42", "referer": "user-0"}]}
{"question": "一道C语言编程题目，代码看不明白，请大家帮忙看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：https://www.cnblogs.com/polebug/p/3502565.html", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:恩，可以用的。  //#include<bits/stdc++.h> #include <stdio.h> #include <stdlib.h>  //using namespace std;  char s[50];  int main(){     int d1,d2,d3;     int cnt=0;     char op;     //while(gets(s)){     while(scanf(\"%d%c%d=%d\", &d1, &op, &d2, &d3) == 4){         //d3=1000;         //sscanf(s,\"%d%c%d=%d\",&d1,&op,&d2,&d3);         if(d1+d2==d3&&op=='+')         {             cnt++;         }         if(d1-d2==d3&&op=='-')         {             cnt++;         }     }     printf(\"%d\\n\",cnt);     return 0; } 供参考～   建议查一下sscanf函数实现；可以看成scanf从s中读取值匹配%d和%c 谢谢你的回答，但是wa哦", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "恩，可以用的。  //#include<bits/stdc++.h> #include <stdio.h> #include <stdlib.h>  //using namespace std;  char s[50];  int main(){     int d1,d2,d3;     int cnt=0;     char op;     //while(gets(s)){     while(scanf(\"%d%c%d=%d\", &d1, &op, &d2, &d3) == 4){         //d3=1000;         //sscanf(s,\"%d%c%d=%d\",&d1,&op,&d2,&d3);         if(d1+d2==d3&&op=='+')         {             cnt++;         }         if(d1-d2==d3&&op=='-')         {             cnt++;         }     }     printf(\"%d\\n\",cnt);     return 0; } 供参考～   建议查一下sscanf函数实现；可以看成scanf从s中读取值匹配%d和%c", "referer": "user-0"}]}
{"question": "为什么这里不要加&和【】", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-4 的回复：别的格式符对应变量加&是为了取地址，而数组名本身就是地址，加方括号就不是地址了，加&就画蛇添足了。多谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 自信男孩 的回复：scanf对应的a的位置要求的是地址，而数组a的名字就是数组的首地址，因此不需要加&  楼主定义的a是int类型数组，而用%s输入，类型不匹配吧，虽然不影响程序运行～，根据楼主的程序逻辑，应该将a定义成char类型的数组；   另外，c=c的操作没意义，建议删除；多谢🙏", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 家有萌宝V 的回复：其实楼上已经回答的很清楚了。 int a [100] = {1,2,3,,,,,,,,,,100} 这里， a的值就是指向这一百个数的数组(栈)的指针。那么&a就是这个数组名的地址。你要表达的是通过键盘输入正数，并将整数存入到这个数组中。 那么 scanf参数接受的肯定不是数组名的地址&a， 而是数组的地址，也就是a，希望回答能帮到你。好的，多谢🙏", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "其实楼上已经回答的很清楚了。 int a [100] = {1,2,3,,,,,,,,,,100} 这里， a的值就是指向这一百个数的数组(栈)的指针。那么&a就是这个数组名的地址。你要表达的是通过键盘输入正数，并将整数存入到这个数组中。 那么 scanf参数接受的肯定不是数组名的地址&a， 而是数组的地址，也就是a，希望回答能帮到你。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "scanf对应的a的位置要求的是地址，而数组a的名字就是数组的首地址，因此不需要加&  楼主定义的a是int类型数组，而用%s输入，类型不匹配吧，虽然不影响程序运行～，根据楼主的程序逻辑，应该将a定义成char类型的数组；   另外，c=c的操作没意义，建议删除；", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-4 的回复：别的格式符对应变量加&是为了取地址，而数组名本身就是地址，加方括号就不是地址了，加&就画蛇添足了。那[]呢", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "scanf(\"%s\",a)是输入一个字符串，不是一个字符，由于字符数组名已经代表数组存放的字符串的首地址，所以不用加取地址运算符&，后面也不用方括号[]指出数组元素都下标。望采纳", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "别的格式符对应变量加&是为了取地址，而数组名本身就是地址，加方括号就不是地址了，加&就画蛇添足了。", "referer": "user-0"}]}
{"question": "求助帖", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修正楼上：printf(\"d=%.4f\\n\",d); printf(\"c=%.4f\\n\",c); printf(\"s=%.4f\\n\",s);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考：#include \"stdio.h\" #define pi 3.14159 int main( ) {     float r,d,c,s;     scanf(\"%f\",&r);//scanf(\"%.4lf\",&r);     if(r<0 || r>10000) return -1;     d=2*r;     c=2*pi*r;     s=pi*r*r;     printf(\"d=%.4lf\\n\",d);     printf(\"c=%.4lf\\n\",c);     printf(\"s=%.4lf\\n\",s);          return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> #include <math.h>  #define PI 3.14159  #define MAX_SIZE    10000  int main(void) {     float r,d,c,s;     //scanf(\"%.4lf\",&r);     scanf(\"%f\",&r);      if (r < 0 || (r > MAX_SIZE && fabs(r - MAX_SIZE) > 1e-6))         return -1;      d = 2 * r;     c = 2 * PI * r;     s = PI * r * r;      printf(\"d=%.4lf\\n\",d);     printf(\"c=%.4lf\\n\",c);     printf(\"s=%.4lf\\n\",s);      return 0; } 供参考～", "referer": "user-0"}]}
{"question": "c语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不一定执行，因为越界访问是未定义行为～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不一定  其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "拍照的时间，写个test也可以试验出来了", "referer": "user-0"}]}
{"question": "写了一个用fwrite写入文件流的DLL，但是引用DLL时参数传不进去", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//dllmain.c  /* Replace \"dll.h\" with the name of your header */ #include \"dll.h\" #include <windows.h> #include <stdio.h>  DLLIMPORT void sendData(const char *jsondata,int len) { \tprintf(\"1\\n\"); \tFILE *f; \tprintf(\"2\\n\");     f = fopen( \"d:\\\\json.txt\" , \"wb\" );     printf(\"3\\n\");     fwrite(jsondata, len , 1, f );     printf(\"4\\n\");     //fflush(f);     fclose(f); }    BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved) { \tswitch(fdwReason) \t{ \t\tcase DLL_PROCESS_ATTACH: \t\t{ \t\t\tbreak; \t\t} \t\tcase DLL_PROCESS_DETACH: \t\t{ \t\t\tbreak; \t\t} \t\tcase DLL_THREAD_ATTACH: \t\t{ \t\t\tbreak; \t\t} \t\tcase DLL_THREAD_DETACH: \t\t{ \t\t\tbreak; \t\t} \t}  \t/* Return TRUE on success, FALSE on\tfailure\t*/ \treturn TRUE; }  //dll.h  #ifndef _DLL_H_ #define _DLL_H_  #if BUILDING_DLL #define DLLIMPORT __declspec(dllexport) #else #define DLLIMPORT __declspec(dllimport) #endif  DLLIMPORT void sendData(const char *jsondata,int len);  #endif  //调用  #include <stdio.h> #include <stdlib.h> #include <windows.h> /* run this program using the console pauser or add your own getch, system(\"pause\") or input loop */  int main(int argc, char *argv[]) { \ttypedef\tvoid (*FUNT)(const char*,int); \tHMODULE\thMod = LoadLibrary(\"createdll.dll\"); \tif(hMod\t!= NULL) \t{ \t\tprintf(\"%s\\n\",\"success!!!\"); \t\tFUNT Data =\t(FUNT)GetProcAddress(hMod,\"sendData\"); \t\tData(\"123\",3); \t} \telse \t\tprintf(\"%s\\n\",\"failed!!!\");  \t    \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢赵四老师帮我解决那个DLL中fwrite的问题，我有几个疑问1、为什么要加const，虽然我知道这是声明只读。2、const char *和const char [ ]，在我感觉下是相同的，但是用了后者就不行了。3、为什么fwrite中的len要在外面声明，我直接给他固定值的话文本后面会乱码。若赵四老师有空的话希望能帮我解答，或者推荐我这个新手看看什么学习资料比较好，再次感谢", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "太感谢赵四老师了，牛！", "referer": "user-0"}]}
{"question": "这段在Dev C++上没问题但是在Visual C++上过不了编译", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "关于文件打开那段，这么写，供参考：fp1=fopen(\"record.txt\",\"a\");//如果不存在record.txt就创建一个  if (fp1==NULL)         {               printf(\"文件打开失败!\\n\");               exit(0);              //fp2=fopen(\"record.txt\",\"w\");             //fclose(fp2);         }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这一段作为一个函数，在vc6上正常编译运行的。最好把错误信息或者代码贴上来", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "从这个例子上看，懵懂时期的初学者严格遵循ANSI/C90利大于弊。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "对void save(struct student *head) 、struct student *load(void)、main()函数里做了修改，供参考：//这是全代码 #include <string.h> #include <stdio.h> #include <malloc.h> #include <stdlib.h>//包含system函数头文件 #define LEN sizeof(struct student) struct student {         char num[20]; \t\t//ID号码         char name[100]; \t\t//联系人姓名         char phone[20]; \t\t//联系人电话号码         char home[100]; \t\t//联系人通讯地址         char birthday[20]; \t\t//联系人生日         struct student *next; };  void face(void) //功能选择面板 {         printf(\"********************************************************************\");         printf(\"\\t\\t\\t\\t☆★☆★☆★  ~_~  ~_~  ~_~  ☆★☆★☆★\\n\");         printf(\"\\n\\t\\t\\t☆★欢迎使用<查找联系人>☆★\");         printf(\"\\n\\n\\t☆★选择你需要操作的功能:☆★(若添加联系方式，建议完善联系人信息)★☆\\n\");         printf(\"\\n\");         printf(\"\\t\\t\\t1.【增加联系人信息〗\\n\");         printf(\"\\t\\t\\t2.〖显示<查找联系人>中所有记录】\\n\");         printf(\"\\t\\t\\t3.【删除需要删除的信息〗\\n\");         printf(\"\\t\\t\\t4.〖以名字查询所需的信息】\\n\");         printf(\"\\t\\t\\t5.【保存<查找联系人>中的所有记录到指定文件中〗\\n\");         printf(\"\\t\\t\\t6.〖退出不保存!!】\\n\");         printf(\"\\n\");         printf(\"\\t☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★\");         printf(\"\\n\\n********************************************************************\\n\\n\"); } void print(struct student *head) {         struct student *p;         p=head;         system(\"CLS\"); \t\t//调用DOS命令CLS能够清屏         printf(\"*************************************************************\\n\");         printf(\"==================== → 联系人信息记录表 ← ===================\\n\");         printf(\"*************************************************************\\n\");         if(head!=NULL)                 do                 {                         printf(\"联系人ID号码:%s\\n\",p->num);                         printf(\"联系人姓名:%s\\n\",p->name);                         printf(\"联系人电话号码:%s\\n\",p->phone);                         printf(\"联系人地址:%s\\n\",p->home);                         printf(\"联系人生日:%s\\n\",p->birthday);                         printf(\"********************************************************\\n\");                         p=p->next;                 } \t\t\t\twhile(p!=NULL);         else         {             printf(\"抱歉!!无法找到该联系人!!\\n\\n\");             printf(\"=============================================================\\n\");         } } //增添电子通讯录中的内容，即创建连表过程 struct student *append(struct student *head) {         struct student *p0=NULL,*p1,*p2; \t\t//p0为要插入的新节点         p1=head;         p2=head;         system(\"CLS\");         printf(\"\\n\\n***********************************************************\\n\");         printf(\"\\t\\t你能在此目录下创建并添加联系人信息\");         printf(\"\\n***********************************************************\\n\");         p0=(struct student *)malloc(LEN);         printf(\"请输入联系人ID号码:\");         gets(p0->num);         printf(\"请输入联系人姓名:\");         gets(p0->name);         printf(\"请输入联系人电话号码:\");         gets(p0->phone);         printf(\"请输入联系人地址:\");         gets(p0->home);         printf(\"请输入联系人生日:\");         gets(p0->birthday);                  if(head==NULL) //对插入的节点排序，按姓名的拼音顺序         {            head=p0;            p0->next=NULL;         }         else         {            while((strcmp(p0->name,p1->name)>0)&&(p1->next!=NULL))            {                p2=p1;                p1=p1->next;            }            if((strcmp(p0->name,p1->name))<=0)            {               if(head==p1)                  head=p0;               else                  p2->next=p0;               p0->next=p1;            }            else            {               p1->next=p0;               p0->next=NULL;            }            printf(\"成功添加联系人信息!!\");            printf(\"\\n************************************************************\\n\");            printf(\"\\n\\n\");         }         return(head);        }  //查找联系人的维护（删除），通过输入联系人ID号码删除联系人数据 struct student *del(struct student *head) {         struct student *p1,*p2;         char num[12];         system(\"CLS\");         printf(\"\\n\\n************************************************************\\n\");         printf(\"================= → 联系人信息记录删除功能 ← ===============\\n\");         printf(\"************************************************************\\n\");         printf(\"输入要删除的联系人ID号码:\");         gets(num);          p1=head;         if (head==NULL)                 {             \t\tprintf(\"抱歉!!无法找到该联系人!!\\n\");                         printf(\"\\n*******************************************************\\n\");                     return(head);                 }         while(p1!=NULL)         {                 if(strcmp(p1->num,num)==0)                 {                         if(p1==head)                         head=p1->next;                         else p2->next=p1->next;                         free(p1);                         printf(\"删除成功!!\\n\");                         return(head);                 }                 p2=p1;                 p1=p1->next;         }         printf(\"对不起!!没有要删除的联系人纪录!!\\n\");         return(head); }  //电子通讯录的查找，关键字为用户姓名； void search(struct student *head) {         struct student *p1,*p2;         char name[20];         p1=head;         p2=p1;         system(\"CLS\");         printf(\"\\n**************************************************************\\n\");                 printf(\"================ → 联系人信息记录查询功能 ← ==================\\n\");         printf(\"**************************************************************\\n\");         printf(\"输入要查找联系人的姓名:\");         gets(name);         while(p1!=NULL)         {                 if(strcmp(p1->name,name)==0)                 {                        printf(\"联系人ID号码:\");                                 puts(p1->num);                         printf(\"联系人姓名:\");                                puts(p1->name);                         printf(\"联系人电话号码:\");                                 puts(p1->phone);                        printf(\"联系人地址:\");                                 puts(p1->home);                        printf(\"联系人生日:\");                                puts(p1->birthday);                       printf(\"\\n=============================================================\\n\");                                         break;                 }                 p2=p1;                 p1=p1->next;         }         if(p1==NULL)                 printf(\"对不起!!没有该联系人的纪录!!\\n\");  } //电子通讯录的记录存盘操作，使用文件指针； void save(struct student *head) {         FILE *fp,*fp1;         struct student *p;         p=head;                 fp1=fopen(\"record.txt\",\"w\");         //fp1=fopen(\"record1.txt\",\"w\");         //fprintf(fp1,\"=============== → 用户信息记录表 ← =================\\n\");          while(p!=NULL)         {                 //首先把数据保存在record.txt中，这是提供给load函数用的数据                 //fprintf(fp,\" %s %s %s %s %s %s\",p->num,p->name,p->phone,p->email,p->home,p->birthday);                 //然后把数据保存在record1.txt中，这是能提供直接查询看的，有比较友好的画面                 //fprintf(fp1,\"====================================================\\n\");                 fprintf(fp1,\"%s\\n\",p->num);//联系人ID号码:                 fprintf(fp1,\"%s\\n\",p->name);//联系人姓名:                 fprintf(fp1,\"%s\\n\",p->phone);//联系人电话：                 fprintf(fp1,\"%s\\n\",p->home); //联系人家庭地址:                 fprintf(fp1,\"%s\\n\",p->birthday);//联系人出生日期:                 p=p->next;         }               //fprintf(fp1,\"*************************************************************\\n\");         fclose(fp1);         fclose(fp);         printf(\"\\n\\n成功储存，你能在record1.txt找到相应信息\\n\");         printf(\"**************************************************************\\n\");         printf(\"PRESS ANY KEY TO EXIT.\\n\\n\");         getchar();         exit(1); } //电子通讯录的记录读盘操作，使用文件指针； struct student *load(void) {         FILE *fp;         struct student *head=NULL,*p1=NULL,*p2=NULL;         char   c;         int    i;         fp=fopen(\"record.txt\",\"a+\");         if(fp==NULL){            printf(\"Open File fail!\\n\");            exit(0);         }         while(1)//for(i=1;(c=fgetc(fp))!=-1;i++)         {                 p1=(struct student *)malloc(LEN);                 if(fscanf(fp,\"%s\\n\",p1->num)!=1) break;                 fscanf(fp,\"%s\\n\",p1->name);                 fscanf(fp,\"%s\\n\",p1->phone);                 fscanf(fp,\"%s\\n\",p1->home);                 fscanf(fp,\"%s\\n\",p1->birthday);//p1->email                 p1->next = NULL;                 if(head==NULL){  //if(i==1)                    head=p1;                    p2=p1;                 }                 else{                    p2->next=p1;                    p2=p1;                 }         }         //if(p1==NULL){         //   fclose(fp);         //   return(head);         //}         //p2->next=NULL;         fclose(fp);         return(head); }  main() {         struct student *head=NULL;         //FILE *fp1,*fp2;         int c; \t\t//功能选择需要的号码         system(\"cls\");         system(\"color  2f\");         system(\"cls\");         //if ((fp1=fopen(\"record.txt\",\"r\"))==NULL)         //{         //        printf(\"error\\n\");                //exit(0);                //fp2=fopen(\"record.txt\",\"w\"); \t\t\t//如果不存在record.txt就创建一个               //fclose(fp2);         //}         head=load();         while(1)         {                 face();                 printf(\"选择你需要操作的功能号码:\");                 scanf(\"%d\",&c);                 getchar();                 switch(c)                 {                        case 1:head=append(head);break;                        case 2:print(head);break;                        case 3:head=del(head);break;                        case 4:search(head);break;                        case 5:save(head);break;                        case 6:exit(0);break;                      default :printf(\"Enter error!!\\n\");                 }                 //printf(\"*****************\\n\");                 printf(\"◇◆请按ENTER返回功能操作菜单◇◆\\n\");                 //printf(\"*****************\\n\");                 getchar();                 system(\"CLS\");         } } //指定控制台输出的颜色属性// //颜色属性由两个十六进制数字指定 -- 第一个为背景，第二个则为// //前景。每个数字可以为以下任何值之一://  //0 = 黑色 8 = 灰色// //1 = 蓝色 9 = 淡蓝色// //2 = 绿色 A = 淡绿色// //3 = 湖蓝色 B = 淡浅绿色// //4 = 红色 C = 淡红色// //5 = 紫色 D = 淡紫色// //6 = 黄色 E = 淡黄色// //7 = 白色 F = 亮白色//", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "if ((fp1=fopen(\"record.txt\",\"r\"))==NULL)          {                fp2=fopen(\"record.txt\",\"w\");             //如果不存在record.txt就创建一个               fclose(fp2);         } 如果打开失败，为什么还要调用fclose呢，打开失败直接返回          FILE *fp1,*fp2;         int c;     struct student *head=NULL;         //功能选择需要的号码         system(\"cls\");         system(\"color  2f\");         system(\"cls\");          //struct student *head=NULL;         if ((fp1=fopen(\"record.txt\",\"r\"))==NULL)          {                fp2=fopen(\"record.txt\",\"w\");             //如果不存在record.txt就创建一个               fclose(fp2);         }         head=load(); 在定义时，把head的位置放在system函数之前。Dev C++编译没问题，而Visual C++有问题，可能是编译器版本的原因，应该是Visual C++版本比较老吧～", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "试试在最开始加上 #include \"stdafx.h\"", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "//这是全代码 #include <string.h> #include <stdio.h> #include <malloc.h> #include <stdlib.h>//包含system函数头文件 #define LEN sizeof(struct student) struct student {         char num[20]; \t\t//ID号码         char name[100]; \t\t//联系人姓名         char phone[20]; \t\t//联系人电话号码         char home[100]; \t\t//联系人通讯地址         char birthday[20]; \t\t//联系人生日         struct student *next; }; void face(void) //功能选择面板 {         printf(\"********************************************************************\");         printf(\"\\t\\t\\t\\t☆★☆★☆★  ~_~  ~_~  ~_~  ☆★☆★☆★\\n\");         printf(\"\\n\\t\\t\\t☆★欢迎使用<查找联系人>☆★\");         printf(\"\\n\\n\\t☆★选择你需要操作的功能:☆★(若添加联系方式，建议完善联系人信息)★☆\\n\");      printf(\"\\n\");         printf(\"\\t\\t\\t1.【增加联系人信息〗\\n\");     printf(\"\\t\\t\\t2.〖显示<查找联系人>中所有记录】\\n\");         printf(\"\\t\\t\\t3.【删除需要删除的信息〗\\n\");         printf(\"\\t\\t\\t4.〖以名字查询所需的信息】\\n\");         printf(\"\\t\\t\\t5.【保存<查找联系人>中的所有记录到指定文件中〗\\n\");         printf(\"\\t\\t\\t6.〖退出不保存!!】\\n\");      printf(\"\\n\");         printf(\"\\t☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★\");       printf(\"\\n\\n********************************************************************\\n\\n\"); } void print(struct student *head) {         struct student *p;         p=head;         system(\"CLS\"); \t\t//调用DOS命令CLS能够清屏         printf(\"*************************************************************\\n\");         printf(\"==================== → 联系人信息记录表 ← ===================\\n\");         printf(\"*************************************************************\\n\");         if(head!=NULL)                 do                 {                         printf(\"联系人ID号码:%s\\n\",p->num);                         printf(\"联系人姓名:%s\\n\",p->name);                         printf(\"联系人电话号码:%s\\n\",p->phone);                         printf(\"联系人地址:%s\\n\",p->home);                         printf(\"联系人生日:%s\\n\",p->birthday);                         printf(\"********************************************************\\n\");                         p=p->next;                 } \t\t\t\twhile(p!=NULL);         else         {             printf(\"抱歉!!无法找到该联系人!!\\n\\n\");             printf(\"=============================================================\\n\");         } } //增添电子通讯录中的内容，即创建连表过程 struct student *append(struct student *head) {         struct student *p0=NULL,*p1,*p2; \t\t//p0为要插入的新节点         p1=head;         p2=head;         system(\"CLS\");         printf(\"\\n\\n***********************************************************\\n\");         printf(\"\\t\\t你能在此目录下创建并添加联系人信息\");         printf(\"\\n***********************************************************\\n\");                 p0=(struct student *)malloc(LEN);       printf(\"请输入联系人ID号码:\");                         gets(p0->num);                 printf(\"请输入联系人姓名:\");                         gets(p0->name);                 printf(\"请输入联系人电话号码:\");                         gets(p0->phone);                 printf(\"请输入联系人地址:\");                         gets(p0->home);                 printf(\"请输入联系人生日:\");                         gets(p0->birthday);             //对插入的节点排序，按姓名的拼音顺序                 if(head==NULL)                 { \t\t\t\thead=p0;p0->next=NULL; \t\t\t\t}                 else                 {                         while((strcmp(p0->name,p1->name)>0)&&(p1->next!=NULL))                                 { \t\t\t\t\t\t\t\t\tp2=p1;p1=p1->next; \t\t\t\t\t\t\t\t}                         if((strcmp(p0->name,p1->name))<=0)                         {                                 if(head==p1)                                         head=p0;                                 else                                         p2->next=p0;                                 p0->next=p1;                         }                         else                                 { \t\t\t\t\t\t\t\t\tp1->next=p0;p0->next=NULL; \t\t\t\t\t\t\t\t}                  printf(\"成功添加联系人信息!!\");                 printf(\"\\n************************************************************\\n\");                 printf(\"\\n\\n\");                  }         return(head);        }  //查找联系人的维护（删除），通过输入联系人ID号码删除联系人数据 struct student *del(struct student *head) {         struct student *p1,*p2;         char num[12];         system(\"CLS\");         printf(\"\\n\\n************************************************************\\n\");         printf(\"================= → 联系人信息记录删除功能 ← ===============\\n\");         printf(\"************************************************************\\n\");         printf(\"输入要删除的联系人ID号码:\");         gets(num);          p1=head;         if (head==NULL)                 {             \t\tprintf(\"抱歉!!无法找到该联系人!!\\n\");                         printf(\"\\n*******************************************************\\n\");                     return(head);                 }         while(p1!=NULL)         {                 if(strcmp(p1->num,num)==0)                 {                         if(p1==head)                         head=p1->next;                         else p2->next=p1->next;                         free(p1);                         printf(\"删除成功!!\\n\");                         return(head);                 }                 p2=p1;                 p1=p1->next;         }         printf(\"对不起!!没有要删除的联系人纪录!!\\n\");         return(head); }  //电子通讯录的查找，关键字为用户姓名； void search(struct student *head) {           struct student *p1,*p2;         char name[20];         p1=head;         p2=p1;         system(\"CLS\");         printf(\"\\n**************************************************************\\n\");                 printf(\"================ → 联系人信息记录查询功能 ← ==================\\n\");         printf(\"**************************************************************\\n\");         printf(\"输入要查找联系人的姓名:\");         gets(name);         while(p1!=NULL)         {                 if(strcmp(p1->name,name)==0)                 {                        printf(\"联系人ID号码:\");                                 puts(p1->num);                         printf(\"联系人姓名:\");                                puts(p1->name);                         printf(\"联系人电话号码:\");                                 puts(p1->phone);                        printf(\"联系人地址:\");                                 puts(p1->home);                        printf(\"联系人生日:\");                                puts(p1->birthday);                       printf(\"\\n=============================================================\\n\");                                         break;                 }                 p2=p1;                 p1=p1->next;         }         if(p1==NULL)                 printf(\"对不起!!没有该联系人的纪录!!\\n\");          } //电子通讯录的记录存盘操作，使用文件指针； void save(struct student *head) {         FILE *fp,*fp1;         struct student *p;         p=head;                 fp=fopen(\"record.txt\",\"w\");         fp1=fopen(\"record1.txt\",\"w\");         fprintf(fp1,\"=============== → 用户信息记录表 ← =================\\n\");                  while(p!=NULL)         {                 //首先把数据保存在record.txt中，这是提供给load函数用的数据                 //fprintf(fp,\" %s %s %s %s %s %s\",p->num,p->name,p->phone,p->email,p->home,p->birthday);                 //然后把数据保存在record1.txt中，这是能提供直接查询看的，有比较友好的画面                 fprintf(fp1,\"====================================================\\n\");                 fprintf(fp1,\"联系人ID号码:%s\\n\",p->num);                 fprintf(fp1,\"联系人姓名:%s\\n\",p->name);                 fprintf(fp1,\"联系人电话:%s\\n\",p->phone);                 fprintf(fp1,\"联系人家庭地址:%s\\n\",p->home);                 fprintf(fp1,\"联系人出生日期:%s\\n\",p->birthday);                 p=p->next;         }         fprintf(fp1,\"*************************************************************\\n\");         fclose(fp1);         fclose(fp);         printf(\"\\n\\n成功储存，你能在record1.txt找到相应信息\\n\");         printf(\"**************************************************************\\n\");         printf(\"PRESS ANY KEY TO EXIT.\\n\\n\");         getchar();         exit(1); } //电子通讯录的记录读盘操作，使用文件指针； struct student *load(void) {         FILE *fp;         struct student *head=NULL,*p1=NULL,*p2=NULL;         char c;         int i;         fp=fopen(\"record.txt\",\"r\");         for(i=1;(c=fgetc(fp))!=-1;i++)         {                 p1=(struct student *)malloc(LEN);                 //fscanf(fp,\"%s %s %s %s %s %s\",p1->num,p1->name,p1->phone,p1->email,p1->home,p1->birthday);                 if(i==1)                 { \t\t\t\t head=p1;p2=p1; \t\t\t\t}                 else                 { \t\t\t\t  p2->next=p1;p2=p1; \t\t\t\t}         }         if(p1==NULL)         { \t    \tfclose(fp);return(head); \t\t}         p2->next=NULL;         fclose(fp);         return(head); }  main() {         FILE *fp1,*fp2;         int c; \t\t//功能选择需要的号码         system(\"cls\");         system(\"color  2f\");         system(\"cls\");          struct student *head=NULL;         if ((fp1=fopen(\"record.txt\",\"r\"))==NULL)          {                fp2=fopen(\"record.txt\",\"w\"); \t\t\t//如果不存在record.txt就创建一个               fclose(fp2);         }         head=load();         while(1)         {                 face();                 printf(\"选择你需要操作的功能号码:\");                 scanf(\"%d\",&c);                 getchar();                 switch(c)                 {                 case 1:head=append(head);break;               case 2:print(head);break;                 case 3:head=del(head);break;                 case 4:search(head);break;               case 5:save(head);break;                case 6:exit(0);break;                 default :printf(\"Enter error!!\\n\");                         }                 //printf(\"*****************\\n\");                 printf(\"◇◆请按ENTER返回功能操作菜单◇◆\\n\");                 //printf(\"*****************\\n\");                 getchar();                 system(\"CLS\");         }  } //指定控制台输出的颜色属性// //颜色属性由两个十六进制数字指定 -- 第一个为背景，第二个则为// //前景。每个数字可以为以下任何值之一://  //0 = 黑色 8 = 灰色// //1 = 蓝色 9 = 淡蓝色// //2 = 绿色 A = 淡绿色// //3 = 湖蓝色 B = 淡浅绿色// //4 = 红色 C = 淡红色// //5 = 紫色 D = 淡紫色// //6 = 黄色 E = 淡黄色// //7 = 白色 F = 亮白色//", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 2 楼 浪客 的回复:这一段作为一个函数，在vc6上正常编译运行的。最好把错误信息或者代码贴上来", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:这代码不全，没头没尾呀？ 我只贴了主程序，全部的太长了，只有这一段出现了错误", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "这代码不全，没头没尾呀？", "referer": "user-0"}]}
{"question": "冒泡排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 哇咔咔biu 的回复:[quote=引用 2 楼 自信男孩的回复:]首先对ch的scanf是越界访问问题，结果是未定义的。另外str是可变数组，C语言不支持这种定义～ 那请问我可以怎么改呀，我改了几次还是不行[/quote] 首先ch定义为8字节长度，后面的对ch的操作都不需要修改了； 第二定义好二维数组（长度确定），而不是用可变数组；", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:首先对ch的scanf是越界访问问题，结果是未定义的。另外str是可变数组，C语言不支持这种定义～ 那请问我可以怎么改呀，我改了几次还是不行", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "首先对ch的scanf是越界访问问题，结果是未定义的。另外str是可变数组，C语言不支持这种定义～", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "第24行改为：for(j=0;j<m-i-1;j++)", "referer": "user-0"}]}
{"question": "出现value 3221225477 求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "ccf ISBN不能拿满分", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include<stdio.h> int main() {         char a[15]={0};         int i,sum=0,j=1;         scanf(\"%s\",&a) ;         for(i=0; i<11; i++) {             if(a[i]>='0' && a[i]<='9') {                sum+=(a[i]-'0')*j;                j++;             }         }         if((sum%11==(a[12]-'0'))||(a[12] == 'X')){                     printf(\"Right\\n\");         } else {                     if(sum%11!=10)                         a[12]=sum%11+'0';                     else                         a[12]='X';                     printf(\"%s\\n\",a);         }                  return 0; }", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "c语言，输入一个文件（不一定是当前文件夹），如何在同一目录下输出一个文件其文件名为原文件名加上前缀", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://blog.csdn.net/a_ran/article/details/41551955", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "学习一下readdir和rename这两个函数～", "referer": "user-0"}]}
{"question": "c语言求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可参", "referer": "user-0"}]}
{"question": "OpenMP程序的编译和运行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "在python里用def构建函数的时候能不能调用math库啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "import math def myfunc():     print(math.sin(30*math.pi/180))", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "当然可以  你定义的函数里可以调用math库中的函数", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-4的回复:不知道你啥意思，def是定义函数的，是在自己函数里面调用math库里的函数？ 对对对，就是不知道能不能这样写", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "对对对，就是不知道能不能这样写", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "不知道你啥意思，def是定义函数的，是在自己函数里面调用math库里的函数？", "referer": "user-0"}]}
{"question": "python的一个作业，不知道哪有问题，这张学的是构建函数和函数调用等等", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "python中range(a,b)表示从a到b-1", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "可以这么调用，但你的循环变量控制有问题  # -*- coding: UTF-8 -*- import math n = 10 sum = 0 for i in range(1, n+1): \tsum += math.factorial(i) print sum", "referer": "user-0"}]}
{"question": "有没有大佬知道这是为啥，树生成不出来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：#include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*T)->data = data;         //生成根结点         CreateBiTree(&(*T)->lchild);//构造左子树         CreateBiTree(&(*T)->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf(\"%c \",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf(\"%c \",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(&T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}]}
{"question": "刚学c语言求大佬帮忙解答.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "基本的结构体使用题目，自己先试着写写吧，不出错，怎么知道结构体不能这么用呢？！", "referer": "user-0"}]}
{"question": "C语言中关于int与long int", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://zh.cppreference.com/w/c/language/arithmetic_types", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "C语言标准规定了一些类型  然后规定了这些类型的最小范围而没有规定精确范围  所以不同平台上的实现不一样  标准制定者跟编译器实现者分离  是导致类问题的根本原因 因为使用C的平台太多了 不同平台有不同平台的需求 所以标准必须要综合各方面利益（俗称和稀泥）", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "所以才有了 int8,int16,int32,int64类型。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "int和long的长度是看编译器的，int至少2字节，long不短于int，你说两者相等只能说你的编译器是这样实现的；  对于64位编译器，int是32bit长度，而long int是64bit长度（在64Ubuntu系统下测试）。  你如果用过turbo C，就能知道int表示的范围比long小的；", "referer": "user-0"}]}
{"question": "matlab关于音频读取分帧输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "项目中有多个.h文件和.c文件怎么生成DLL", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看本网页下面CSDN自动推荐的链接。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可以先学习一下动态库的生成", "referer": "user-0"}]}
{"question": "求大佬帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "ddddddd", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include<stdio.h> #include <math.h> #include <ctype.h>  int main() {     int n;     int i = 1, sum = 1;     double e = 1, tmp;;      scanf(\"%d\", &n);      if (n > 16)         n = 16;     if (n < 1) {         printf(\"%.2lf\\n\", 1.0);         return 0;     }     do {         sum *= i;         tmp = 1.0/sum;         e += tmp;         printf(\"i = %d, sum = %d\\n\", i, sum);         i++;     } while (fabs(tmp) > 1e-6 && i < n);      printf(\"%.2lf\\n\", e);     return 0; } 供参考～", "referer": "user-0"}]}
{"question": "请问这道c语言题咋写？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "函数传入参数后，实际发生了变化", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C/c++编译完哪有什么变量名", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "s1 s2都是struct st的对象，怎么会里面的名字不一样呢？而且如果形参跟实参类型不同，是编译不过去的啊", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "还得看一下在调用function_2之前是不是对s1进行了修改或覆盖  参数传递之前，即调用function_2之前，打印一下s1的内容，然后在function_2函数内打印一下形参内容，对比一下再看看", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "是其他原因导致的。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 7 楼 自信男孩 的回复:[quote=引用 5 楼 Roi_ 的回复:][quote=引用 3 楼 flying_music 的回复:]s1 s2都是struct st的对象，怎么会里面的名字不一样呢？而且如果形参跟实参类型不同，是编译不过去的啊  s1 s2都是struct st的对象，但是s1.name 和 s2.name是不一样的。形参、实参类型是匹配的，编译也通过了。[/quote]  描述不能代替代码，把涉及到的完整代码发一下吧[/quote]  谢谢大家提供的思路，问题解决了，刚刚在编译机上重新编译替换了。个人粗心导致编译后的代码没有及时替换，导致GDB调试的时候显示的是新代码，实际运行的是旧代码。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 5 楼 Roi_ 的回复:[quote=引用 3 楼 flying_music 的回复:]s1 s2都是struct st的对象，怎么会里面的名字不一样呢？而且如果形参跟实参类型不同，是编译不过去的啊  s1 s2都是struct st的对象，但是s1.name 和 s2.name是不一样的。形参、实参类型是匹配的，编译也通过了。[/quote]  描述不能代替代码，把涉及到的完整代码发一下吧", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "把你的准确信息贴出来，具体代码，具体错误贴图。不合逻辑必有妖。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 3 楼 flying_music 的回复:s1 s2都是struct st的对象，怎么会里面的名字不一样呢？而且如果形参跟实参类型不同，是编译不过去的啊  s1 s2都是struct st的对象，但是s1.name 和 s2.name是不一样的。形参、实参类型是匹配的，编译也通过了。", "referer": "user-0"}]}
{"question": "如何理解下面这段话，兄弟们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "考虑一下：printf(\"%s\\n\",\"abcdef\"+1); 它的输出是 bcdef 这说明什么？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "比如： const char *str = \"helloworld\";   //这个赋值（=）表达式的值就是字符串常量的地址赋值给str", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "有没有例子啊，兄弟们", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "printf(\"%d\",a);//输出的是地址 用%p打印地址； ，这个地址的名字叫做a，这样描述是不对的，而是a是一个指针，把\"helloworld\"字符串的地址放到a变量了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "比如 char *a=\"helloworld\"; printf(\"%s\",a);//输出helloworld printf(\"%d\",a);//输出的是地址 意思是为helloworld这个字符串指定了一个地址，这个地址的名字叫做a(实际是一串数字，a只是个别名)，另外地址是字符串第一个字符h的地址", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:比如： const char *str = \"helloworld\";   //这个赋值（=）表达式的值就是字符串常量的地址赋值给str 比如 char *a=\"helloworld\"; printf(\"%s\",a);//输出helloworld printf(\"%d\",a);//输出的是地址 意思是为helloworld这个字符串指定了一个地址，这个地址的名字叫做a(实际是一串数字，a只是个别名)，另外地址是字符串第一个字符h的地址", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:比如： const char *str = \"helloworld\";   //这个赋值（=）表达式的值就是字符串常量的地址赋值给str 了解了，谢谢兄弟", "referer": "user-0"}]}
{"question": "请问一下 我想将一个数组按从大到小的顺序排序，并输出它应该怎么写（用指针的方法）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主用的就是指针呢，在reswap函数里，parr是指针，不是数组的～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include <stdio.h> #define N 40  void reswap(int *parr,int n);  int main() {     int score[N],n,i;     printf(\"The number of student:\");     scanf(\"%d\",&n);      printf(\"Input %d student's score:\",n);     for(i=0;i<n;i++)     {         scanf(\"%d\",&score[i]);     }      reswap(score,n);          return 0; }  void reswap(int *parr,int n) {     int i,j,temp;     for(i=0;i<n-1;i++)     {         for(j=i+1;j<n;j++)         {             if(*(parr+i) < *(parr+j))//从大到小             {                 temp     = *(parr+i);                 *(parr+i)= *(parr+j);                 *(parr+j)= temp;             }         }     }     for(i=0;i<n;i++)     {         printf(\"%d \",*(parr+i));     }     printf(\"\\n\"); }", "referer": "user-0"}]}
{"question": "小白问题，困扰好久了 有大佬能帮忙分析一下嘛", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "打开《数据结构》 教科书，翻到 图 章节，自习吧。这都要讲好几节课的~~~", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "简单地说，每个getchar()的执行，就要读入一个字符，并且就地比较，并不保存。 这种行为在东北话里叫做熊瞎子劈（第三声）苞米，劈一根丢一根。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include<stdio.h> #include <ctype.h>  int main() {     //char ch;     int ch;     int count=0;     int i;     while((ch = getchar())!=EOF)     {         if (ch == '\\n')             break; #if 1         if(ch >= 'A'&&ch<='Z')         {             count++;         }         else if(ch>='a'&&ch<='z')         {             count++;         } #else         if (isalpha(ch))             count++; #endif         //i=count;     }     //printf(\"%d\",i);     printf(\"%d\\n\", count);      return 0; } 供参考～", "referer": "user-0"}]}
{"question": "打印机驱动开发", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "c++可以做吧，还是c", "referer": "user-0"}]}
{"question": "请问下面程序的功能", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "拿着代码问功能，这样的毕竟很少。看代码逻辑不复杂，是不是自己的问题呢？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0"}]}
{"question": "求下列选择题答案！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "这个数组元素a[i][j]的行数不应该是（i+1）吗？？ 因为行数是从0开始的呀", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "正如楼上几位朋友所说，这个题选“B”  对于二维数组，请参考《C++中的二维数组1》 《C++的二维数组2》 希望能够帮到您！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "m列，那么就是i *m，即i行的个数，+j说明是第j个数。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "将m=3，i=1,j=1带入题目中各式，掰手指头数一下。  1 2 3 4 5 6  答案因该是B", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "特殊值法，把i j都想成0，前面肯定有0个元素", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "一定要六个字，选B", "referer": "user-0"}]}
{"question": "关于while((getchar())!='\\n')吃掉回车的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "输入缓冲区是关联到进程的，所以你的程序从上到下，用的都是同一个输入缓冲区。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "第二个while不一定会执行一次键盘输入（最终的还是键盘输入的），为什么说不一定呢，比如你输入的是ab然后回车，那么内循环的while接收的是b；如果是输入的a回车，那么内循环getchar()接收的是'\\n'。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。  在每个最后不带\\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0"}]}
{"question": "C#如何读取文件的指定行，并且对改行进行编辑，之后保存文件？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。http://bbs.csdn.net/topics/391975224", "referer": "user-0"}]}
{"question": "【C语言求助】n个人围成一圈1~3循环报数，不断剔除报到3的人，找出剩下的人的序号", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "再多用用，就熟练了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:供参考：void main() {     int people[1000],n_5;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n_5);      for(int i=0;i<n_5;i++)     {         people[i]=i+1;     }      int *p_5=people;     int remain=n_5,num_off=0;     while(remain>1)//剩下的人数大于1     {         p_5 = people; //这里相当于把数组首尾相连         while((p_5)<=(people+n_5-1))//判断是否到了数组尾，到尾部跳出重新一轮         {                           //这里循环都是一个n的长度              if(*p_5!=0)//判断有没有出圈，如果已经出圈了就跳过，进入p_5++下一位数据判断             {                num_off++;//没出圈的才计数值加1                 if( num_off==3)                 {                   printf(\"此为报到3的数：*p_5=%d num_off=%d\\n\",*p_5,num_off);//便于观察过程                   *p_5=0;                   remain--;//总人数减一                   num_off=0;//从0开始重新计数                 }             }                      //printf(\"*p_5=%d num_off=%d\\n\",*p_5,num_off);//便于观察过程             p_5++; //数组下一个数据         }     }      p_5 = people; //此时要让p_5指针回到数组的首部位置      while(*p_5==0)//找到最后不是0的位置             p_5++;     printf(\"The number of remained one is:%d \\n\",*p_5);      } 谢谢！while循环太难搞了🤒", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:仅供参考：//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf(\"Input n m(1000>=n>=m>=1):\");         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf(\"%3d \",i);                 if (0==t%10) printf(\"\\n\");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf(\"Press any key ...\");     getch(); }  好的，谢谢！", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-4的回复:建议自己调试一下，调试能力跟编码能力同样重要，甚至更重要 知道的，谢谢！这个已经是调了好多遍了，还是不行😭", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "供参考：void main() {     int people[1000],n_5;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n_5);      for(int i=0;i<n_5;i++)     {         people[i]=i+1;     }      int *p_5=people;     int remain=n_5,num_off=0;     while(remain>1)//剩下的人数大于1     {         p_5 = people; //这里相当于把数组首尾相连         while((p_5)<=(people+n_5-1))//判断是否到了数组尾，到尾部跳出重新一轮         {                           //这里循环都是一个n的长度              if(*p_5!=0)//判断有没有出圈，如果已经出圈了就跳过，进入p_5++下一位数据判断             {                num_off++;//没出圈的才计数值加1                 if( num_off==3)                 {                   printf(\"此为报到3的数：*p_5=%d num_off=%d\\n\",*p_5,num_off);//便于观察过程                   *p_5=0;                   remain--;//总人数减一                   num_off=0;//从0开始重新计数                 }             }                      //printf(\"*p_5=%d num_off=%d\\n\",*p_5,num_off);//便于观察过程             p_5++; //数组下一个数据         }     }      p_5 = people; //此时要让p_5指针回到数组的首部位置      while(*p_5==0)//找到最后不是0的位置             p_5++;     printf(\"The number of remained one is:%d \\n\",*p_5);      }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "仅供参考：//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf(\"Input n m(1000>=n>=m>=1):\");         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf(\"%3d \",i);                 if (0==t%10) printf(\"\\n\");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf(\"Press any key ...\");     getch(); }", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "建议自己调试一下，调试能力跟编码能力同样重要，甚至更重要", "referer": "user-0"}]}
{"question": "【C语言求助】为什么这个代码会进入死循环？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "放在while(*p!=0)循环里面，循环条件是*p!=0，也就是只有*p=0时才能退出，在循环体里这个条件始终是满足的，最后p++跑出数组的范围了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:供参考：#include<stdio.h>  void main() {      int people[1000],n;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n);     //给n个人按顺序编号      for(int i=0;i<n;i++)     {         people[i]=i+1;     }          int *p=people;     int remain=n,num_off=1; //num_off是循环过程中该人在1~3中报的数     while(remain>1) //剩下的人数大于1     {         p=people;                  while(p!=(people+n-1))//剩下的人不是编号最后一个         {            //printf(\"p=%d\\n\",*p);                          while(*p!=0)             {                  if(num_off!=3)                 {                      num_off++;                     //p++;                 }                 else if(num_off==3)                 {                      *p=0;  //如果报数为3则剔除该人，用赋值0来达到此效果                     remain--; //剔除后剩余人数减1                     //p++;                     num_off=1; //报数开始新的一轮 1 2 3 1 2 3.。。                 }             }             p++;         }     }     printf(\"打印此段话说明循环结束\");      } 还有就是，为什么把p＋＋；跟while(*p！＝5)并列以后，while会循环3次？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "楼主的代码每次都从头开始数数，与常见的不同啊。请楼主确认一下，题目确实是这样的？", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "注意下数组不要越界，因此再输入n之后要对n的值进行判断，处理。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:仔细分析楼主的代码，里面用while(*p!=0)来判断*P==0这里是错误的，*p表示的是数组里某一位的值，这里应用if，逻辑判断设计问题，修正如下，供参考：#include<stdio.h>  void main() {      int people[1000],n;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n);     //给n个人按顺序编号      for(int i=0;i<n;i++)     {         people[i]=i+1;     }          int *p=people;     int remain=n,num_off=1; //num_off是循环过程中该人在1~3中报的数     while(remain>1) //剩下的人数大于1     {         p=people;                  while(p!=(people+n-1))//剩下的人不是编号最后一个         {            //printf(\"p=%d\\n\",*p);              if(*p!=0 )  //while(*p!=0)             {                      //if(num_off!=3)                      num_off++;                  //  p++;             }                 //else                 if(num_off==3)                 {                      *p=0;  //如果报数为3则剔除该人，用赋值0来达到此效果                     remain--; //剔除后剩余人数减1                     //p++;                     num_off=1; //报数开始新的一轮 1 2 3 1 2 3.。。                  }             //}             p++;         }     }     printf(\"打印此段话说明循环结束\");      } 好，我再看看，谢谢", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "仔细分析楼主的代码，里面用while(*p!=0)来判断*P==0这里是错误的，*p表示的是数组里某一位的值，这里应用if，逻辑判断设计问题，修正如下，供参考：#include<stdio.h>  void main() {      int people[1000],n;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n);     //给n个人按顺序编号      for(int i=0;i<n;i++)     {         people[i]=i+1;     }          int *p=people;     int remain=n,num_off=1; //num_off是循环过程中该人在1~3中报的数     while(remain>1) //剩下的人数大于1     {         p=people;                  while(p!=(people+n-1))//剩下的人不是编号最后一个         {            //printf(\"p=%d\\n\",*p);              if(*p!=0 )  //while(*p!=0)             {                      //if(num_off!=3)                      num_off++;                  //  p++;             }                 //else                 if(num_off==3)                 {                      *p=0;  //如果报数为3则剔除该人，用赋值0来达到此效果                     remain--; //剔除后剩余人数减1                     //p++;                     num_off=1; //报数开始新的一轮 1 2 3 1 2 3.。。                  }             //}             p++;         }     }     printf(\"打印此段话说明循环结束\");      }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:仔细分析楼主的代码，里面用while(*p!=0)来判断*P==0这里是错误的，*p表示的是数组里某一位的值，这里应用if，逻辑判断设计问题，修正如下，供参考：#include<stdio.h>  void main() {      int people[1000],n;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n);     //给n个人按顺序编号      for(int i=0;i<n;i++)     {         people[i]=i+1;     }          int *p=people;     int remain=n,num_off=1; //num_off是循环过程中该人在1~3中报的数     while(remain>1) //剩下的人数大于1     {         p=people;                  while(p!=(people+n-1))//剩下的人不是编号最后一个         {            //printf(\"p=%d\\n\",*p);              if(*p!=0 )  //while(*p!=0)             {                      //if(num_off!=3)                      num_off++;                  //  p++;             }                 //else                 if(num_off==3)                 {                      *p=0;  //如果报数为3则剔除该人，用赋值0来达到此效果                     remain--; //剔除后剩余人数减1                     //p++;                     num_off=1; //报数开始新的一轮 1 2 3 1 2 3.。。                  }             //}             p++;         }     }     printf(\"打印此段话说明循环结束\");      } 我又开了一个帖子，里面是完整的代码，麻烦帮忙看看", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 7 楼 自信男孩的回复:注意下数组不要越界，因此再输入n之后要对n的值进行判断，处理。 我又开了一个帖子，里面是完整的代码，麻烦帮忙看看", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 8 楼 forever74的回复:楼主的代码每次都从头开始数数，与常见的不同啊。请楼主确认一下，题目确实是这样的？ 我又开了一个帖子，里面是完整的代码，麻烦帮忙看看", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:供参考：#include<stdio.h>  void main() {      int people[1000],n;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n);     //给n个人按顺序编号      for(int i=0;i<n;i++)     {         people[i]=i+1;     }          int *p=people;     int remain=n,num_off=1; //num_off是循环过程中该人在1~3中报的数     while(remain>1) //剩下的人数大于1     {         p=people;                  while(p!=(people+n-1))//剩下的人不是编号最后一个         {            //printf(\"p=%d\\n\",*p);                          while(*p!=0)             {                  if(num_off!=3)                 {                      num_off++;                     //p++;                 }                 else if(num_off==3)                 {                      *p=0;  //如果报数为3则剔除该人，用赋值0来达到此效果                     remain--; //剔除后剩余人数减1                     //p++;                     num_off=1; //报数开始新的一轮 1 2 3 1 2 3.。。                 }             }             p++;         }     }     printf(\"打印此段话说明循环结束\");      } 请问为什么p＋＋；放在while循环里面会无限循环啊？难道说while里面的p＋＋；影响不了while循环条件里的*p的值吗？", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "供参考：#include<stdio.h>  void main() {      int people[1000],n;     printf(\"Please enter the number of people:\\n\");     scanf(\"%d\",&n);     //给n个人按顺序编号      for(int i=0;i<n;i++)     {         people[i]=i+1;     }          int *p=people;     int remain=n,num_off=1; //num_off是循环过程中该人在1~3中报的数     while(remain>1) //剩下的人数大于1     {         p=people;                  while(p!=(people+n-1))//剩下的人不是编号最后一个         {            //printf(\"p=%d\\n\",*p);                          while(*p!=0)             {                  if(num_off!=3)                 {                      num_off++;                     //p++;                 }                 else if(num_off==3)                 {                      *p=0;  //如果报数为3则剔除该人，用赋值0来达到此效果                     remain--; //剔除后剩余人数减1                     //p++;                     num_off=1; //报数开始新的一轮 1 2 3 1 2 3.。。                 }             }             p++;         }     }     printf(\"打印此段话说明循环结束\");      }", "referer": "user-0"}]}
{"question": "C语言疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "试着用memset进行初始化为同一个字符或整数；  其实这些推测或疑问，你都可以自己试一下的。比如第一个是不是都初始化为'\\0'，那你初始化后，用一个循环可以打出来的～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "1. 自己去试一下不就知道了 2. 可以都设置为0，不能随便设置，就像int a[10] = {0}; 3.  普通的二维数组int a[10][10] 形参可以写int a[10][10] 或 int a[][10] 或 int (*a)[10]，实参是a 4. '\\0'是其ASCII码值 跟数字0没关系", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}]}
{"question": "按回车不执行一直换行，为什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "while(~scanf(\"%d\",&a)) 改成这样：  while(scanf(\"%d\",&a)==1) 或者  while(scanf(\"%d\",&a)) 试试", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 1 楼 user-3 的回复:供参考：#include<stdio.h> int main(){     int a;     int cnt=-2;     int n[100]={0};     while(~scanf(\"%d\",&a)){   //Ctrl+Z 结束输入         for(int i=2;i<=a;i++){             n[i]=i;         }         for(int j=2;j<=a;j++){             for(int k=2;k<j;k++){                 if(n[j]%k==0){                     n[j]=0;                 }             }         }     }     for(int i=0;i<=a;i++){         if(n[i]==0){             cnt++;             continue;         }         else {             printf(\"%d \",n[i]);         }     }     printf(\"\\n\");     printf(\"%d\\n\",cnt);         return 0; }  //~是按位取反 //scanf的返回值是输入值的个数 //如果没有输入值就是返回-1 //while(~scanf(\"%d\", &n))就是当没有输入的时候退出循环 //和while(scanf(\"%d\",&n)!=EOF)一个意思 //知识1：只有-1取反（~-1）是0 //知识2：scanf读入到EOF时返回-1 //注：一般这种用法在oj（确保数据正确）上使用，平常基本用不到  //scanf的返回值是输入匹配对象的个数，%d如果输入的是非数字，那么即使是输入了，返回的也是0，因为字母与%d不匹配", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "供参考：#include<stdio.h> int main(){     int a;     int cnt=-2;     int n[100]={0};     while(~scanf(\"%d\",&a)){   //Ctrl+Z 结束输入         for(int i=2;i<=a;i++){             n[i]=i;         }         for(int j=2;j<=a;j++){             for(int k=2;k<j;k++){                 if(n[j]%k==0){                     n[j]=0;                 }             }         }     }     for(int i=0;i<=a;i++){         if(n[i]==0){             cnt++;             continue;         }         else {             printf(\"%d \",n[i]);         }     }     printf(\"\\n\");     printf(\"%d\\n\",cnt);         return 0; }  //~是按位取反 //scanf的返回值是输入值的个数 //如果没有输入值就是返回-1 //while(~scanf(\"%d\", &n))就是当没有输入的时候退出循环 //和while(scanf(\"%d\",&n)!=EOF)一个意思 //知识1：只有-1取反（~-1）是0 //知识2：scanf读入到EOF时返回-1 //注：一般这种用法在oj（确保数据正确）上使用，平常基本用不到", "referer": "user-0"}]}
{"question": "一道C语言编程题目，想了好久了，老是WA，请大家帮忙看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 6 楼 早打大打打核战争 的回复:虽然你结帖了，#1的代码实际是错的~ 相当错 那天急着吃饭就走了 今天才又看到", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 早打大打打核战争的回复:虽然你结帖了，#1的代码实际是错的~ 哦哦，不过我没怎么看，我ac了就结帖了，还是很谢谢哦", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "虽然你结帖了，#1的代码实际是错的~", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "供参考：  #include <stdio.h> int main() { \tint ncase, nline, maxx, sumx; \tint line[20]; \tscanf(\"%d\", &ncase); \twhile (ncase--) \t{ \t\tint i; \t\tmaxx = 0; \t\tsumx = 0; \t\tfor (i = 0; i < 20; i++)line[i] = 0; \t\tscanf(\"%d\", &nline); \t\twhile (getchar() != '\\n'); \t\ti = 0; \t\twhile (i < 2*nline) \t\t{ \t\t\tswitch (getchar()) \t\t\t{ \t\t\tcase 'X': \t\t\t\tline[i%nline]++; \t\t\t\tbreak; \t\t\tcase '\\n': \t\t\t\ti++; \t\t\t} \t\t} \t\tfor (i = 0; i < nline; i++) \t\t{ \t\t\tsumx += line[i]; \t\t\tif (line[i] > maxx)maxx = line[i]; \t\t} \t\tprintf(\"%d\\n\", maxx*nline - sumx); \t} \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "我知道了，第一次发帖，谢谢你们的帮助", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 3 楼 因为天气好 的回复:嗯嗯，但是我还是不知道自己的代码错哪了，样例可以过 楼主的代码，问题出在进入第二轮测试时，第一轮的统计的 max1[100]   max2[100]  sum  sat这些值都没有复位归零。供参考：#include<stdio.h> #include<string.h> char s[1001]; int main() {     int k,n,i,j,sta=0;     int sum=0;     int max1[100];     int max2[100];     int max;     scanf(\"%d\",&k);     while(k--)     {         scanf(\"%d\",&n);         getchar();          sum=0;sta=0;    //这些值需要复位归零         for(i=0;i<100;i++){max1[i]=0;max2[i]=0;}          for(i=0;i<n;i++)         {             gets(s);             for(j=0;s[j]!='\\0';j++)             {   if(s[j]==' ')                 {                     sta++;//统计左边零件本身的空格                 }             }             sum=sum+strlen(s);             max1[i]=strlen(s);         }         for(i=0;i<n;i++)         {             gets(s);             for(j=0;s[j]!='X';j++)             {                 ;             }             int temp=j;                 for(;s[j]!='\\0';j++)             {   if(s[j]==' ')                 {                     sta++;//统计右边零件本身的空格                 }                              }             sum=sum+j-temp;//j-temp为右边零件长度             max2[i]=j-temp;         }         max=0;         for(i=0;i<n;i++)//求出平凑出来的最长的一行的值             if((max1[i]+max2[i])>max)                 max=max1[i]+max2[i];         sum=n*max-sum;         printf(\"%d\\n\",sum+sta);     }          return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "嗯嗯，但是我还是不知道自己的代码错哪了，样例可以过", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "把这样的左右两个零件紧密地拼在一起！", "referer": "user-0"}]}
{"question": "请教泰勒公式求sinx C语言，实在不知错哪了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 芒光淀 的回复:[quote=引用 1 楼 user-2的回复:]供参考，误差较大：//sin x = x - x^3/3! + x^5/5! - x^7/7! + ... + (-1)n-1x2n-1/(2n-1)!  #include <stdio.h>  int main(void)  {     int i,j,num=0;//x     double n=1,sum=0,x;                       //scanf(\"%d\",x);     scanf(\"%lf\",&x); //x是弧度，所以数据类型应为double     for(i=1;n>=1e-5;i+=2)     {         n=1;         for(j=i;j>0;j--)             n *= ( double)x/j;         if(num%2==0)         {            sum+=n;            //num++;         }         else         {            sum-=n;            //num++;         }         num++;     }     printf(\"%lf %d\",sum,num+1);     return 0;  } 好像还是不对[/quote] 咋不对了？没问题呀，看截图：", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考，误差较大：//sin x = x - x^3/3! + x^5/5! - x^7/7! + ... + (-1)n-1x2n-1/(2n-1)!  #include <stdio.h>  int main(void)  {     int i,j,num=0;//x     double n=1,sum=0,x;                       //scanf(\"%d\",x);     scanf(\"%lf\",&x); //x是弧度，所以数据类型应为double     for(i=1;n>=1e-5;i+=2)     {         n=1;         for(j=i;j>0;j--)             n *= ( double)x/j;         if(num%2==0)         {            sum+=n;            //num++;         }         else         {            sum-=n;            //num++;         }         num++;     }     printf(\"%lf %d\",sum,num+1);     return 0;  } 好像还是不对", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考，误差较大：//sin x = x - x^3/3! + x^5/5! - x^7/7! + ... + (-1)n-1x2n-1/(2n-1)!  #include <stdio.h>  int main(void)  {     int i,j,num=0;//x     double n=1,sum=0,x;                       //scanf(\"%d\",x);     scanf(\"%lf\",&x); //x是弧度，所以数据类型应为double     for(i=1;n>=1e-5;i+=2)     {         n=1;         for(j=i;j>0;j--)             n *= ( double)x/j;         if(num%2==0)         {            sum+=n;            //num++;         }         else         {            sum-=n;            //num++;         }         num++;     }     printf(\"%lf %d\",sum,num+1);     return 0;  }", "referer": "user-0"}]}
{"question": "球球大佬解决 C语言结构体的一个问题，初学C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改如下，问题见注释，供参考：#include<stdio.h> #include<stdlib.h> #define N 100  struct fract{        int   fenzi;        int   fenmu;        float shuzhi; };  void shuzhi_paixu(struct fract *fracccc,int n)//从这里开始编译不通过？？？？？？很迷惑 {     fract temp;     for(int i=0;i<n;i++)  // for(int i=0;i<n-1;i++)     {         for(int j=0;j<n-1-i;j++)         {             if(fracccc[j].shuzhi>fracccc[j+1].shuzhi)             {                 temp=fracccc[j+1];                 fracccc[j+1]=fracccc[j];                 fracccc[j]=temp;             }         }     }     printf(\"\\n\");     printf(\"根据数值排序的情况:\\n\");     for(int i=0;i<n;i++)         printf(\"%d/%d \",fracccc[i].fenzi,fracccc[i].fenmu);// printf(\"%d/%d \",fracccc[i],fracccc[i+1]); } static long F(int n)//递归调用 {     if(n==1||n==2)         {return 1;}     else {         return 2*F(n-1)+F(n-2);     } }  int main() {   int m,x;      struct fract frac[N];   //,*pfrac;     printf(\"请输入数字\\n\");     scanf(\"%d\",&x);     m=x;     for(int i=0;i<m;i++){       frac[i].fenzi=F(i+1);   // frac[i].fenmu=F(i+1);       frac[i].fenmu=F(i+2);   //frac[i].fenzi=F(i+2);       //frac[i].shuzhi=(float)F(i+1)/F(i+2);       frac[i].shuzhi=(float)frac[i].fenzi/frac[i].fenmu;// 整数/整数 = 0，强制类型转换下     }     for(int i=0;i<m;i++)         printf(\"%d/%d \",frac[i].fenzi,frac[i].fenmu);// printf(\"%d/%d \",frac[i].fenmu,frac[i].fenzi);                             //pfrac=frac;     shuzhi_paixu(frac,m);          return 0; }   //请输入数字 //5 //1/1 1/3 3/7 7/17 17/41 //根据数值排序的情况: //1/3 7/17 17/41 3/7 1/1 请按任意键继续. . .", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "void shuzhi_paixu(struct fract *fracccc,int n)//从这里开始编译不通过？？？？？？很迷惑", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "void shuzhi_paixu(struct fract *fracccc,int n)  main函数最后加 return 0;", "referer": "user-0"}]}
{"question": "为什么运行后输入数字没有反应，不能将两个数组合并？求指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 qzjhjxj 的回复:代码错误修正，增加了打印输出函数，逻辑没整明白，供参考：#include<stdio.h> #include<stdlib.h>  #define MAXSIZE 10  typedef struct LNode {     int data;     int cur; }LNode,SLinkList[MAXSIZE];  void InitSpace(SLinkList &L) {     int i;     for(i=0;i<MAXSIZE-1;i++){         L[i].cur=i+1;         L[i].data=0;     }     L[MAXSIZE-1].cur=0;     L[MAXSIZE-1].data=0; }  int Malloc (SLinkList &L) {     int i;     i=L[0].cur;     if(L[0].cur)        L[0].cur=L[i].cur;     return i; }  void Free(SLinkList &L,int k) {     L[k].cur=L[0].cur;     L[0].cur=k; }  void Different(SLinkList &L) {     //InitSpace(L);     int S;     S=Malloc(L);     int r;     r=Malloc(L);     r=S;     int m=4,n=6,i,j;     for(i=0;i<m;i++)  //这里输入m次     {        j=Malloc(L);        //scanf(\"%d\",L[j].data);        scanf(\"%d\",&L[j].data);        L[r].cur=i;        r=j;     }     L[r].cur=0;     for (i=0;i<n;i++)  //这里循环n次     {        int b;        //scanf(\"%d\",b);        scanf(\"%d\",&b);        S=b;  //b=S;        int k=L[S].cur;        while(k!=L[r].cur&&L[k].data!=b)        {            int p=k;            k=L[k].cur;        }        if(k==L[r].cur){           j=Malloc(L);           L[j].cur=b;           L[j].cur=L[r].cur;           L[r].cur=i;        }        else        {           int p;           L[p].cur=L[k].cur;           Free (L,k);           if(r==k)              r=p;        }     } }  void print(SLinkList &L) {     int i;     for(i=0;i<MAXSIZE;i++)         printf(\"%d %d \\n\",L[i].data,L[i].cur); }  int main () {     SLinkList L ;          InitSpace(L);     print(L);      Different(L);     print(L);          return 0; }  int p;           L[p].cur=L[k].cur; 这样操作，很大可能会出错，因为数组越界了呀，p是一个随机值", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "代码错误修正，增加了打印输出函数，逻辑没整明白，供参考：#include<stdio.h> #include<stdlib.h>  #define MAXSIZE 10  typedef struct LNode {     int data;     int cur; }LNode,SLinkList[MAXSIZE];  void InitSpace(SLinkList &L) {     int i;     for(i=0;i<MAXSIZE-1;i++){         L[i].cur=i+1;         L[i].data=0;     }     L[MAXSIZE-1].cur=0;     L[MAXSIZE-1].data=0; }  int Malloc (SLinkList &L) {     int i;     i=L[0].cur;     if(L[0].cur)        L[0].cur=L[i].cur;     return i; }  void Free(SLinkList &L,int k) {     L[k].cur=L[0].cur;     L[0].cur=k; }  void Different(SLinkList &L) {     //InitSpace(L);     int S;     S=Malloc(L);     int r;     r=Malloc(L);     r=S;     int m=4,n=6,i,j;     for(i=0;i<m;i++)  //这里输入m次     {        j=Malloc(L);        //scanf(\"%d\",L[j].data);        scanf(\"%d\",&L[j].data);        L[r].cur=i;        r=j;     }     L[r].cur=0;     for (i=0;i<n;i++)  //这里循环n次     {        int b;        //scanf(\"%d\",b);        scanf(\"%d\",&b);        S=b;  //b=S;        int k=L[S].cur;        while(k!=L[r].cur&&L[k].data!=b)        {            int p=k;            k=L[k].cur;        }        if(k==L[r].cur){           j=Malloc(L);           L[j].cur=b;           L[j].cur=L[r].cur;           L[r].cur=i;        }        else        {           int p;           L[p].cur=L[k].cur;           Free (L,k);           if(r==k)              r=p;        }     } }  void print(SLinkList &L) {     int i;     for(i=0;i<MAXSIZE;i++)         printf(\"%d %d \\n\",L[i].data,L[i].cur); }  int main () {     SLinkList L ;          InitSpace(L);     print(L);      Different(L);     print(L);          return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "for (i=0;i<n;i++)  {  int b;  scanf(\"%d\",b);  ---------- 比如这一段，为何把int b;放循环里？ 另外应该是 scanf(\"%d\",&b);  还有你没有任何打印输出，你怎么知道运行成功了没有，多加几个打印语句，打印一下中间值和最后结果吧。", "referer": "user-0"}]}
{"question": "SPI通信实验-关于主函数数组const定义相关疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "各位大佬帮我看看，谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这是源码程序，具体内容如上", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "具体原因，没有具体代码，无法说清。 加了const 代表你不能直接修改TEXT_Buffer 的内容", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "供参考：https://blog.csdn.net/qq_36958104/article/details/89764410?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161801542616780264060131%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161801542616780264060131&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29_name-1-89764410.first_rank_v2_pc_rank_v29&utm_term=const", "referer": "user-0"}]}
{"question": "秋梨膏 大佬看看 为什么串口收不到数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "在主程序中我用串口助手进行调试过程中串口的数据一直为0", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "是我忘记开中断了，智障了，有个新问题问大佬们，我用串口助手发送1，然后SBUF接收到的是12544请问是什么原因呢", "referer": "user-0"}]}
{"question": "MSVC 环境如何使用复数？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "用不了, 自己处理复数运算", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我是 windows 平台下 mingw 编译 成dll 是没问题的", "referer": "user-0"}]}
{"question": "这个怎么设计", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "个人觉得SDK纯API方式编写Windows程序已经过时了，效率太低，了解一下原理就可以了，主要是消息机制。  图形用户界面（GUI）编程可以学习C++ Builder，架构先进（和C#一样拖控件），入门比较容易。  　　C++ Builder是真正的可视化的开发工具。C++ Builder可以用鼠标拖拉控件加上设置属性轻松的“设计”出一个程序的图形用户界面，利用可视的组件/控件像“搭积木”一样，以“所见即所得”的方式搭建应用程序的界面，这也是C++ Builder这个名字中Builder的概念。这样，只需要用C++语言编写业务逻辑代码，类似于DOS下文本界面编程，只要专注于实现业务逻辑功能就可以了，代码非常简洁。数据的输入和表现，都在图形用户界面，非常直观、易用。这就是RAD开发（Rapid Application Development，快速应用程序开发）。  书籍推荐： 《C++Builder 6程序设计教程（第二版）》 （陆卫忠，刘文亮　等编著 /2011-04-01 /科学出版社）（当当网） 《C++Builder 6编程实例精解》（赵明现），PDF，是数字版的，非扫描版的，里面还有一个俄罗斯方块游戏的完整实现。 《精彩C++Builder 6程序设计》（台湾 吴逸贤），里面有10几个简单小游戏的实现，可以自己看懂以后再重写，才是自己掌握的。 《C++ Builder 5高级编程实例精解》（刘滨 编著）都是较大的实用的程序。  C++ Builder 6.0几个示例程序项目源代码下载：       C++ Builder第一个程序（模拟聊天室）v1.11 C++ Builder模拟数字双时钟示例（未完成）v0.2.1 C++ Builder纸牌游戏Demo v0.05 C++ Builder不规则图像透明贴图（位图的透明显示）三种方法及简单动画v1.3 C++ Builder写的《ZEC 四则运算练习程序》 海底海星情景v0.9.2 C++ Builder简单电话簿Demo例子v1.11", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "定义一个字符串数组，根据输入的字符-'a'获得牌色", "referer": "user-0"}]}
{"question": "结果是对的，但运行后总是说段错误，真不知道是哪里的原因，哪位大佬帮帮忙，感谢!", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢，要是没有你们我又得卡死在这了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>   #include<string.h>   int main(int argc,char* argv[])  {       int i,len,n,k;     char str[1001] ;         scanf(\"%d%s\",&n,str);     len=strlen(str);     k=n%len; //>=len的移动是重复的     /*题目所要求的移动是一种循环移动，如果把字符串首尾相连的话，就是起点位置的移动，可以直接循环输出*/     for (i=len-k;i<len+len-k;++i) \t{ \t\tprintf(\"%c\",str[i-(i>=len)*len]); //printf(\"%c\",str[i%len]);              } \tprintf(\"\\n\");       return 0 ;  }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "楼主的解法是可行的，只是效率低了点，数据输入是有些问题，主要是这一句while((a[j]=getchar())!=' ')键盘输入一般以回车结束应改为while((a[j]=getchar())!='\\n')另外上机测试大部分是自动化脚本运行，数据从文件通过管道输入，输入结束多数是 eof ,这时要有对eof的检测，否则，会出问题，另外一点，对题目的理解，n 是非负整数，自然包括0,楼主忽略了对n=0的处理。 以下代码供参考  #include <stdio.h>  #include <stdlib.h>   int main(int argc,char* argv[])  {  int i,len,n,k; char arr[1000] ;  scanf(\"%d\",&n);  i=0; while((isspace(arr[i]=getchar())!=0));//忽略一个或多个空白符，取得第一个有效字符 ++i; while(((arr[i]=getchar())!='\\n')&&(arr[i]!=EOF)){++i;} //键盘输入用回车结束，数据从文件通过管道输入大部分以EOF结束 len=i;  k=n%len; //>=len的移动是重复的     /*题目所要求的移动是一种循环移动，如果把字符串首尾相连的话，就是起点位置的移动，可以直接循环输出*/     for (i=len-k;i<len+len-k;++i)     {         printf(\"%c\",arr[i-(i>=len)*len]); //printf(\"%c\",arr[i%len]);               }     printf(\"\\n\");     return 0 ;  }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "楼主的解法是可行的，只是没契合这题的要求而已，这题要求你用8#方法。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 8 楼 jianyue---的回复: #include <stdio.h>   #include<string.h>   int main(int argc,char* argv[])  {       int i,len,n,k;     char str[1001] ;         scanf(\"%d%s\",&n,str);     len=strlen(str);     k=n%len; //>=len的移动是重复的     /*题目所要求的移动是一种循环移动，如果把字符串首尾相连的话，就是起点位置的移动，可以直接循环输出*/     for (i=len-k;i<len+len-k;++i) \t{ \t\tprintf(\"%c\",str[i-(i>=len)*len]); //printf(\"%c\",str[i%len]);              } \tprintf(\"\\n\");       return 0 ;  }  额，能解释下我那个解法为什么不行吗？或者能行的能告诉我怎么修改吗？我挺", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 8 楼 jianyue---的回复: #include <stdio.h>   #include<string.h>   int main(int argc,char* argv[])  {       int i,len,n,k;     char str[1001] ;         scanf(\"%d%s\",&n,str);     len=strlen(str);     k=n%len; //>=len的移动是重复的     /*题目所要求的移动是一种循环移动，如果把字符串首尾相连的话，就是起点位置的移动，可以直接循环输出*/     for (i=len-k;i<len+len-k;++i) \t{ \t\tprintf(\"%c\",str[i-(i>=len)*len]); //printf(\"%c\",str[i%len]);              } \tprintf(\"\\n\");       return 0 ;  }  额，能解释下我那个解法为什么不行吗？或者能行的能告诉我怎么修改吗？我挺想知道自己错在了哪?", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "#include <stdio.h>   #include<string.h>   int main(int argc,char* argv[])  {     int i,len,n,k;   char str[1001],s[1001] ;   {             scanf(\"%d%s\",&n,str); \tlen=strlen(str); \tk=n%len; //>=len的移动是重复的 \t/*题目所要求的移动是一种循环移动，如果把字符串首尾相连的话，就是起点位置的移动，作为字符串，以k为分界前后对换即可实现*/ \tstrncpy(s,str+len-k,k); \tstrncpy(s+k,str,len-k); \ts[len]='\\0' ;         printf(\"%s\\n\",s);    }   return 0 ;  }", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "改这样试试：#include<stdio.h> #include<string.h> int main() {     int i,len,n,m;     char a[1001],w;     scanf(\"%d\",&n);     getchar();     gets(a);     len = strlen(a);     for(i=1;i<=n;i++){         for(m=len-1,w=a[m];m>0;m--){             a[m] = a[m-1];         }         a[m]=w;     }     puts(a);         return 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "什么样的错误提示？", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 3 楼 user-3的回复:修正楼上的，第22行增加printf(\"\\n\"); :#include<stdio.h>  int main() {     int i,j,n,m;     char a[1024],w;     j=0;     scanf(\"%d\",&n);     getchar();     while((a[j]=getchar())!='\\n'){           j++;     }     for(i=1;i<=n;i++){         for(m=j-1,w=a[m];m>0;m--){             a[m] = a[m-1];         }         a[m]=w;     }     for(i=0;i<j;i++){         printf(\"%c\",a[i]);     }     printf(\"\\n\");          return 0; } 额，好像不行，心态崩了，好难啊", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "修正楼上的，第22行增加printf(\"\\n\"); :#include<stdio.h>  int main() {     int i,j,n,m;     char a[1024],w;     j=0;     scanf(\"%d\",&n);     getchar();     while((a[j]=getchar())!='\\n'){           j++;     }     for(i=1;i<=n;i++){         for(m=j-1,w=a[m];m>0;m--){             a[m] = a[m-1];         }         a[m]=w;     }     for(i=0;i<j;i++){         printf(\"%c\",a[i]);     }     printf(\"\\n\");          return 0; }", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "修改如下，供参考：#include<stdio.h>  int main() {     int i,j,n,m;     char a[1024],w;     j=0;     scanf(\"%d\",&n);     getchar();     while((a[j]=getchar())!='\\n'){           j++;     }     for(i=1;i<=n;i++){         for(m=j-1,w=a[m];m>0;m--){             a[m] = a[m-1];         }         a[m]=w;     }     for(i=0;i<j;i++){         printf(\"%c\",a[i]);     }          return 0; }", "referer": "user-0"}, {"cid": "14", "user": "user-3", "content": "第一眼看去，输入应该改这样： while((a[j]=getchar())!='\\n'){           j++;     }", "referer": "user-0"}]}
{"question": "求大佬指教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "foo就当成一个变量，只不过这个变量接收的实参需要是一个相同类型的函数名，即该函数是：返回值是void，参数是void *的函数；  LPrint函数正好是这样的类型，既可以作为实参，在调用TraverseLQueue是，作为第一个参数传进去。  TraverseLQueue(xxx, LPrint); //这样调用，xxx是第一个参数，根据实际情况传入对应的参数；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "(*foo)是函数指针，用函数名就可以了。LPrint 是打印的意思，打印输出函数。", "referer": "user-0"}]}
{"question": "运行错误73%求解！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include <ctype.h>  int main() {     char st[1000];     int digit[10],i,num,place;     while(scanf(\"%s\",st)!=EOF)     {         for(i=0;i<10;i++)         {             digit[i]=0;         }         i=0;num=0;place=0;         while(st[i]!='\\0')         {             /*             switch(st[i]-'0')             {                 case 0:a[0]=a[0]+1;break;                 case 1:a[1]=a[1]+1;break;                 case 2:a[2]=a[2]+1;break;                 case 3:a[3]=a[3]+1;break;                 case 4:a[4]=a[4]+1;break;                 case 5:a[5]=a[5]+1;break;                 case 6:a[6]=a[6]+1;break;                 case 7:a[7]=a[7]+1;break;                 case 8:a[8]=a[8]+1;break;                 case 9:a[9]=a[9]+1;break;             }             */             if (isdigit(st[i]))                 digit[st[i] -'0']++;             i++;         }         num = digit[0];         //for(i=0;i<10;i++)         for(i=1;i<10;i++)         {             //if(num>=a[i+1])             if(num < digit[i])             {                 num = digit[i];                 place = i;                 //num=num;                 //place=place;             }             /*             else             {                 num=a[i+1];                 place=i+1;             }             */         }         printf(\"%d\\n\",place);     }     return 0; } 供参考～  楼主的操作越界访问：  for(i=0;i<10;i++)         {             if(num>=a[i+1])    //i+1，当i=9时，i+1等于10，数组越界了             {num=num;place=place;}             else             {num=a[i+1];place=i+1;}         }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include <stdio.h>  int main() {     char s;     int  a[10]={0},i,num=-1,place=-1;     while(scanf(\"%c\",&s)!= EOF){   //Ctrl+Z 结束输入           switch (s){                      case  ' ':continue;                      case '\\n':                                for(i=0;i<10;i++){                                    if(num < a[i]){                                       num = a[i];                                        place = i;                                    }                                }                                printf(\"%d\\n\",place);                                for(i=0;i<10;i++)a[i]=0;                                num=-1;                                  place=-1;                                break;                        default:a[s-'0']++;          }     }          return 0; }", "referer": "user-0"}]}
{"question": "C语言把收到的十六进制数转成对应的10进制", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:#include <stdio.h> char buf[]={0x12,0x22,0x33,0x44,0x22,0xff,0x21,0x31,0x41,0x01,0x12,0x13,0x00,0x00,0x13,0x00,0x23, 0x01,0x00,0x00,0x00, 0x02,0x00,0x00,0x00, 0x03,0x00,0x00,0x00, 0x04,0x00,0x00,0x00, 0x05,0x00,0x00,0x00, 0x00,0x11,0x00,0x64,0x00,0x64,0x00,0x64,0x00,0x64,0x02,0x00,0x00,0x00,0x01,0x00,0xc1,0x2d,0x23,0xdb,0xa9,0x12}; int a,b,c,d,e; int main() {     a=*(int *)(&buf[17   ]);     b=*(int *)(&buf[17+ 4]);     c=*(int *)(&buf[17+ 8]);     d=*(int *)(&buf[17+12]);     e=*(int *)(&buf[17+16]);     printf(\"a,b,c,d,e:%d,%d,%d,%d,%d\\n\",a,b,c,d,e);     return 0; } //a,b,c,d,e:1,2,3,4,5 // 赵4老师就是这么棒，给了个思路，感谢。不对，这是把代码都给我了。哈哈哈哈", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "了解一下这两个函数：       long int strtol(const char *nptr, char **endptr, int base);         long long int strtoll(const char *nptr, char **endptr, int base);", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> char buf[]={0x12,0x22,0x33,0x44,0x22,0xff,0x21,0x31,0x41,0x01,0x12,0x13,0x00,0x00,0x13,0x00,0x23, 0x00,0x00,0x00,0x01, 0x00,0x00,0x00,0x02, 0x00,0x00,0x00,0x03, 0x00,0x00,0x00,0x04, 0x00,0x00,0x00,0x05, 0x00,0x11,0x00,0x64,0x00,0x64,0x00,0x64,0x00,0x64,0x02,0x00,0x00,0x00,0x01,0x00,0xc1,0x2d,0x23,0xdb,0xa9,0x12}; int a,b,c,d,e; char *p; int main() {     p=(char *)&a;for (int i=0;i<4;i++) p[i]=buf[17   +3-i];     p=(char *)&b;for (int i=0;i<4;i++) p[i]=buf[17+ 4+3-i];     p=(char *)&c;for (int i=0;i<4;i++) p[i]=buf[17+ 8+3-i];     p=(char *)&d;for (int i=0;i<4;i++) p[i]=buf[17+12+3-i];     p=(char *)&e;for (int i=0;i<4;i++) p[i]=buf[17+16+3-i];     printf(\"a,b,c,d,e:%d,%d,%d,%d,%d\\n\",a,b,c,d,e);     return 0; } //a,b,c,d,e:1,2,3,4,5 //", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "#include <stdio.h> char buf[]={0x12,0x22,0x33,0x44,0x22,0xff,0x21,0x31,0x41,0x01,0x12,0x13,0x00,0x00,0x13,0x00,0x23, 0x01,0x00,0x00,0x00, 0x02,0x00,0x00,0x00, 0x03,0x00,0x00,0x00, 0x04,0x00,0x00,0x00, 0x05,0x00,0x00,0x00, 0x00,0x11,0x00,0x64,0x00,0x64,0x00,0x64,0x00,0x64,0x02,0x00,0x00,0x00,0x01,0x00,0xc1,0x2d,0x23,0xdb,0xa9,0x12}; int a,b,c,d,e; int main() {     a=*(int *)(&buf[17   ]);     b=*(int *)(&buf[17+ 4]);     c=*(int *)(&buf[17+ 8]);     d=*(int *)(&buf[17+12]);     e=*(int *)(&buf[17+16]);     printf(\"a,b,c,d,e:%d,%d,%d,%d,%d\\n\",a,b,c,d,e);     return 0; } //a,b,c,d,e:1,2,3,4,5 //", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "首先，十六进制和十进制，对于单片机来说，都是一堆的01，例如十六进制的 temp = 0x0a，如果你想作为十进制进行计算，不需要转，直接用就好了，即 temp + 10 ==> 0x0a+10 ==20；对于你说的标颜色的那部分，意思是说真实数据是32位的，那么你就需要将这四个字节按照大小端的模式，拼接成一个32位的数据就可以了", "referer": "user-0"}]}
{"question": "小白题目有大佬讲讲吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "弱弱的问一下 这些任务是在哪里找的啊", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 xiao_yan_1的回复:弱弱的问一下 这些任务是在哪里找的啊 导入了课程应该也有题目", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "你去传智播客，我这是老师布置的作业", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-3的回复:供参考：#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h>  int multiTable(int x) {     int i=0,j=0;     /*----------------------begin-----------------------*/       for(j=1;j<=x;j++){          for(i=1;i<=j;i++)              printf(\"%d*%d=%2d  \",i,j,i*j);          printf(\"\\n\");      }      /*----------------------end-------------------------*/ }  int main() {     int n=0;     printf(\"请输入乘法表需要打印的行数:\");     /*-----------------------begin---------------------*/      scanf(\"%d\",&n);     if(n<0) return -1;      /*-----------------------end-----------------------*/     multiTable(n);          return 0; } 谢谢大佬", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "供参考：#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h>  int multiTable(int x) {     int i=0,j=0;     /*----------------------begin-----------------------*/       for(j=1;j<=x;j++){          for(i=1;i<=j;i++)              printf(\"%d*%d=%2d  \",i,j,i*j);          printf(\"\\n\");      }      /*----------------------end-------------------------*/ }  int main() {     int n=0;     printf(\"请输入乘法表需要打印的行数:\");     /*-----------------------begin---------------------*/      scanf(\"%d\",&n);     if(n<0) return -1;      /*-----------------------end-----------------------*/     multiTable(n);          return 0; }", "referer": "user-0"}]}
{"question": "为什么这个程序会生成LIB文件而不是exe", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你建立工程的时候，是不是选择编译成静态库了？", "referer": "user-0"}]}
{"question": "求助！for循环改while循环", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://ask.csdn.net/questions/7565396", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "正像楼上几个朋友所说的，i++的位置应该在for循环之外。 请参考《C++中for循环语句简析》 希望能够帮到您！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "for (A;B;C) D; //等价于 {  A;  while (1) {   if (!(B)) break;   D;   C;  } }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "for(j=i+1;j<=n;j++)                  {                          if(factorsum(j)==i&&m==j){                         printf(\"%d<-->%d\\n\",i,j);}                         }                         i++;----------------这个放for循环外面吧                 }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "每个数求因子太费时间了，好像也没有好办法，和for while 循环应该没什么关系，供参考：#include <stdio.h>  int factorsum(int x){     int a=2,sum=1;     while(a<=x/2){          if(x%a==0)             sum=sum+a;          a++;     }     return sum; }  int main(){     int n,i=2,m;     scanf(\"%d\",&n);     while(i<=n) {           m=factorsum(i);           if(factorsum(m)==i && i<m)                  printf(\"%d<-->%d\\n\",i,m);           i++;     }     return 0； }", "referer": "user-0"}]}
{"question": "非对称的镜像处理", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "啥叫非对称镜像？", "referer": "user-0"}]}
{"question": "C刚入门代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修正楼上第8行，多了nprintf(\"请输入一个大于等于3的正整数：\"); 求1*2*3*4*5 ,还可以这么写： //求1*2*3*4*5 ：  #include<stdio.h> int main(){ \tint t =1; //乘数     int i =5; //被乘数 \twhile(t *= i,i--,i>0);     printf(\"%d\",t); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考：//给出一个大于或等于3的正整数，判断它是不是一个素数：  #include<stdio.h> int main(){      int prime(int x); \tint n,i; \tprintf(\"请输入一个大于等于3的正整数：\",n);     while(scanf(\"%d\",&n) && n < 3){           printf(\"请重新输入大于等于3的正整数！\\n\");     } \ti = prime(n); \tif(i == 1){ \t\tprintf(\"%d是素数\\n\",n); \t}else{ \t\tprintf(\"%d不是素数\\n\",n); \t}          \treturn 0; }  int prime(int x){ \tint y; \tif(x <= 3) return x > 1;     for(y = 2;y < x-1;++y)         if(x % y == 0)             return 0;     return 1; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不错啊", "referer": "user-0"}]}
{"question": "关于树的问题有一点不明白，想问一下各位大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你乱了吧，怎么答案说“后根遍历对应二叉树的中序遍历”你觉得对，后面你又觉得“后根遍历就是后续遍历”，那问题不就是后根遍历到底对应中序遍历还是对应后续遍历吗？这个问题你应该知道吧。。。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "“先根遍历对应二叉树的先序遍历，后根遍历对应二叉树的中序遍历”这个是针对树跟对应的转换后的二叉树而说的，这点很关键 答案分析应该有问题，虽然先序跟中序能确定一棵二叉树，但这棵二叉树并不能唯一对应一棵树，因为树转二叉树是唯一的，反过来则不是 你理解的也有点儿问题，一棵树本来就是二叉树，但根据数转二叉树的规则转换后，并不是原来的二叉树（否则上面的规则就不对了） 这个题的答案应该是可以确定，严格证明要用归纳法，一般分析如下：之所以二叉树的先序遍历和后序遍历不能唯一确定一棵二叉树，是由于存在度为1的节点，也就是只有一个子节点，它在左在右对应的先序和后续遍历顺序一样但二叉树不一样，但是树没有左右的概念，只要是子节点确定了，那这个树就确定了，在左在右都是一棵树 大概就是这样吧", "referer": "user-0"}]}
{"question": "python", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 ctrigger的回复:“姓名”做key是不行的，如果同名怎么办？ 建议把“姓名”改成学号。保证key唯一。。 这是老师自己编的题 存在不足  感谢指正", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "student = {} ave = 0.0 for i in range(10):     name = input(\"请输入第%d个学生姓名：\"%(i+1))     val1,val2 = eval(input(\"请输入第%d个学生两门课程的成绩,用逗号分开：\"%(i+1)))     ave = (val1 + val2)/2     student[name] = ave  print(student)", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "“姓名”做key是不行的，如果同名怎么办？ 建议把“姓名”改成学号。保证key唯一。。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-4的回复:作业都不自己做 那我总得会做吧???服气了", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "作业都不自己做", "referer": "user-0"}]}
{"question": "c语言输入两个数判断在第几象限", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:scanf里的东西跟你输入的要完全一致（里面有逗号 你也得输入一个逗号） 你可以把x y的值输出看一下，看输入对了没 另外你这背景也太秀了吧，我瞎了 谢谢 解决了 果然是scanf的问题 背景确实有点花", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2的回复:scanf里的东西跟你输入的要完全一致（里面有逗号 你也得输入一个逗号） 你可以把x y的值输出看一下，看输入对了没 另外你这背景也太秀了吧，我瞎了 谢谢 解决了 果然是scanf的问题 背景确实有点花", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢 解决了 果然是scanf的问题 背景确实有点花😂", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "scanf里的东西跟你输入的要完全一致（里面有逗号 你也得输入一个逗号） 你可以把x y的值输出看一下，看输入对了没 另外你这背景也太秀了吧，我瞎了", "referer": "user-0"}]}
{"question": "有没有关于MINGW里所有静态库的介绍？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "学会使用man命令", "referer": "user-0"}]}
{"question": "C语言关int和char并列的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不多做解释了，看图，其他改进以后看博客。从二进制起任意进制转十进制终极代码，求数组长度循环外，处理O(N)即可包含数据无效检查进制无效检查功能，免去求乘方循环。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "而且O(N)即可无需那么多次循环，当然求长度的循环不计在内。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "不但要检查字符还需检查进制", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "你这么歧视十六进制数字F，F知道么？", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "#include<stdio.h> #include<string.h> #include<math.h>  //void check(char *b[20]) void check(char b[20]) {     int n,i,flag=0;     n=strlen(b);     for( i=0;i<n;i++)//判断输入是否正确     {         if((b[i]>='0'&&b[i]<='9')||(b[i]>='A'&&b[i]<='E'))             flag++;         else         {printf(\"请检查，第%d个数开始有错误\\n\",i+1);             //return 0;             return;         }         if(flag==n)             printf(\"数字输入正确\\n\") ;     } } //int turn(char *c[20],int *cccc[20]) int turn(char c[20],int cccc[20]) {     int s=0,m,k, sum = 0;     while(c[s]!='\\0')     {         if((c[s]>='A')&&c[s]<='Z')         {             cccc[s]=c[s]-'A'+10;             s++;             continue;         }         cccc[s]=c[s]-'0';         s++;     }     for(m=0;m<s;m++)         cccc[s-m-1]=cccc[s-m-1]*pow(16,m);     for(k=0;k<s;k++)         sum+=cccc[k];     printf(\"%d\",sum); } int main() {     char a[20];     int m=0,n=0,h=0,aaaa[20];     gets(a);     turn(a,aaaa); } 供参考～  代码编译不通过，做了修改；试试，有问题再问吧", "referer": "user-0"}]}
{"question": "调度原理求最小化滞后时间算法实现", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "程序编译没问题，停止运行是为啥呀。。各位大神求教求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "文件打开失败，会报错，所以//exit(0), 其他问题见注释，供参考：#include<stdlib.h> #include<stdio.h> #include <math.h> #include<malloc.h> #include<string.h>  #define R 61 #define S 61 #define N 195 #define dt 0.04 #define PI 3.141593  //void fft(double sr[61][195][61],double sx[61][195][61],int m0,int inv); void fft(float ***sr,float ***sx,int m0,int inv); float ***create_3_array(int m,int n,int t);  int main() {     int r,s,n,k,nfft;     float w,t;     float ***p,***p_re,***p_im;//***p0,***p0_re,***p0_im,***m,***m_re,***m_im;     FILE *fp1,*fp2;      p  = create_3_array(R,N,S);//(r,n,s);     p_re=create_3_array(R,N,S);//(r,n,s);     p_im=create_3_array(R,N,S);//(r,n,s);      //这些没用到     //p0=create_3_array(R,N,S);//(r,n,s);     //p0_re=create_3_array(R,N,S);//(r,n,s);     //p0_im=create_3_array(R,N,S);//(r,n,s);     //m=create_3_array(R,N,S);//(r,n,s);     //m_re=create_3_array(R,N,S);//(r,n,s);     //m_im=create_3_array(R,N,S);//(r,n,s);      /*读数据到p[][][]*/    fp1=fopen(\"shot_fullwave_new44_use-6_new_sun.dat\", \"rb\");    if (fp1 == NULL)    {       printf(\"Open failed\\n\");       //exit(0);    }    else    for(r=0;r<=R; r++)//for(s=0;s<=S; s++)    {        for(n=0;n<=N;n++)//for(r=0;r<=R;r++)        {           for(s=0;s<=S; s++)//for(n=0;n<=N;n++)           {              fread(&p[r][n][s],sizeof(float),1,fp1);           }        }        putchar('\\n');    }    fclose(fp1);     /*计算fft次数*/    k=log(N)/log(2);    if(N>pow(2,k))       k=k+1;    nfft=pow(2,k);    printf(\"nfft=%d k=%d\\n\",nfft,k);     /*为p_re、p_im赋初值*/    for(r=0;r<=R;r++)//for(s=0;s<=S; s++)    {        for(n=0;n<=N;n++)//for(r=0;r<=R;r++)        {            for(s=0;s<=S; s++)//for(n=0;n<=N;n++)            {                p_re[r][n][s]=p[r][n][s];                p_im[r][n][s]=0.0;            }        }    }              /*对p_re、p_im对时间维度做fft、ifft*/    fft(p_re,p_im,k,1);    fft(p_re,p_im,k,-1);             /*读入数据*/    fp2=fopen(\"output_m.dat\",\"wb\");    if(fp2==NULL)        printf(\"NULL2\");    else    {        for(r=0;r<R;r++)//for(s=0;s<S;s++)        {            for(n=0;n<N;n++)//for(r=0;r<R;r++)            {                for(s=0;s<S;s++)//for(n=0;n<N;n++)                    fwrite(&p[r][n][s],sizeof(float),1,fp2);            }                    //这里保存的是  p[r][n][s]  ？？？？？        }     }     system(\"pause\");     return 0; }   /*fft ifft*/ void fft(float ***sr,float ***sx,int m0,int inv) {     int r,s,i,j,lm,li,k,lmx,np,lix,mm2;     double t1,t2,c,f,cv,st,ct;     if(m0<0)        return;     lmx=1;     for(i=1;i<=m0-1;++i)//for(i=1;i<=m0;++i)数组越界         lmx+=lmx;     cv=2.0*PI/(double)lmx;     ct=cos(cv);     st=-inv*sin(cv);     np=lmx;     mm2=m0-2;     for(s=0;s<S;s++)     {         for(r=0;r<R;r++)         {             for(i=1;i<=mm2;++i)             {                 lix=lmx;                 lmx/=2;                 c=ct;                 f=st;                 for(li=0;li<np;li+=lix)                 {                    j=li;                    k=j+lmx;                    t1=sr[r][j][s]-sr[r][k][s];                    t2=sx[r][j][s]-sx[r][k][s];                    sr[r][j][s]+=sr[r][k][s];                    sx[r][j][s]+=sx[r][k][s];                    sr[r][k][s]=t1;                    sx[r][k][s]=t2;                    ++j;                    ++k;                    t1=sr[r][j][s]-sr[r][k][s];                    t2=sx[r][j][s]-sx[r][k][s];                    sr[r][j][s]+=sr[r][k][s];                    sx[r][j][s]+=sx[r][k][s];                    sr[r][k][s]=c*t1-f*t2;                    sx[r][k][s]=f*t1+c*t2;                 }                 for(lm=2;lm<lmx;++lm)                 {                     cv=c;                     c=ct*c-st*f;                     f=st*cv+ct*f;                     for(li=0;li<np;li+=lix)                     {                        j=li+lm;                        k=lmx+j;                        t1=sr[r][j][s]-sr[r][k][s];                        t2=sx[r][j][s]-sx[r][k][s];                        sr[r][j][s]+=sr[r][k][s];                        sx[r][j][s]+=sx[r][k][s];                        sr[r][k][s]=c*t1-f*t2;                        sx[r][k][s]=f*t1+c*t2;                       }                 }                 cv=ct;                 ct=2.0*ct*ct-1.0;                 st=2.0*st*cv;             }             if(m0>=2)               for(li=0;li<np;li+=4)               {                   j=li;                   k=j+2;                   t1=sr[r][j][s]-sr[r][k][s];                   t2=sx[r][j][s]-sx[r][k][s];                   sr[r][j][s]+=sr[r][k][s];                   sx[r][j][s]+=sx[r][k][s];                   sr[r][k][s]=t1;                   sx[r][k][s]=t2;                   ++j;                   ++k;                   t1=sr[r][j][s]-sr[r][k][s];                   t2=sx[r][j][s]-sx[r][k][s];                   sr[r][j][s]+=sr[r][k][s];                   sx[r][j][s]+=sx[r][k][s];                   sr[r][k][s]=inv*t2;                   sx[r][k][s]=-inv*t1;               }               for(li=0;li<np;li+=2)               {                   j=li;                   k=j+1;                   t1=sr[r][j][s]-sr[r][k][s];                   t2=sx[r][j][s]-sx[r][k][s];                   sr[r][j][s]+=sr[r][k][s];                   sx[r][j][s]+=sx[r][k][s];                   sr[r][k][s]=t1;                   sx[r][k][s]=t2;               }             lmx=np/2;             j=0;             for(i=1;i<np;++i)             {                 k=lmx;                 while(k<=j)                 {                    j-=k;                    k/=2;                 }                 j+=k;                 if(i<j)                 {                    t1=sr[r][j][s];                    sr[r][j][s]=sr[r][i][s];                    sr[r][i][s]=t1;                    t1=sx[r][i][s];                    sx[r][j][s]=sx[r][i][s];                    sx[r][i][s]=t1;                 }             }             if(inv!=-1)                  return;             t1=1.0/np;             for(i=0;i<np;++i)             {                 sr[r][i][s]*=t1;                sx[r][i][s]*=t1;             }         }     }  }  float ***create_3_array(int m,int n,int t) {    float***array=NULL;    int i,j;    array=(float***)malloc(sizeof(float**)*(m+1));    for(i=0;i<=m;i++)    {       array[i]=(float**)malloc(sizeof(float*)*(n+1));       for(j=0;j<=n;j++)           array[i][j]=(float*)malloc(sizeof(float)*(t+1));    }    return array; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int main() {     int r,s,n,k,nfft;     float w,t;     float ***p,***p_re,***p_im,***p0,***p0_re,***p0_im,***m,***m_re,***m_im;     FILE *fp1,*fp2;     void fft(double sr[61][195][61],double sx[61][195][61],int m0,int inv);     float***create_3_array(int m,int n,int t);     p=create_3_array(r,n,s);     p_re=create_3_array(r,n,s);     p_im=create_3_array(r,n,s);     p0=create_3_array(r,n,s);     p0_re=create_3_array(r,n,s);     p0_im=create_3_array(r,n,s);     m=create_3_array(r,n,s);     m_re=create_3_array(r,n,s);     m_im=create_3_array(r,n,s);       /*读数据到p[][][]*/     //if (fp1=fopen(\"shot_fullwave_new44_use-6_new_sun.dat\", \"rb\")==NULL)     if ((fp1=fopen(\"shot_fullwave_new44_use-6_new_sun.dat\", \"rb\"))==NULL)     {         printf(\"Open failed\\n\");         exit(0);     }     //else     int i, j;     p = (float ***)malloc(sizeof(float **) * (S+1));     for (i = 0; i <= S; i++) {         p[i] = (float **)malloc(sizeof(float *) * (R+1));         for (j = 0; j <= R; j++) {             p[i][j] = (float *)malloc(sizeof(float) * N);         }     }     for(s=0;s<=S; s++)     {         for(r=0;r<=R;r++)         {             for(n=0;n<=N;n++)             {                 fread(&p[r][n][s],sizeof(float),1,fp1);             }         }         putchar('\\n');     }     fclose(fp1);     /*计算fft次数*/     k=log(N)/log(2);     if(N>pow(2,k))         k=k+1;     nfft=pow(2,k);     printf(\"nfft=%d k=%d\\n\",nfft,k);     /*为p_re、p_im赋初值*/     for(s=0;s<=S; s++)     {         for(r=0;r<=R;r++)         {             for(n=0;n<=N;n++)             {                 p_re[r][n][s]=p[r][n][s];                 p_im[r][n][s]=0.0;             }         }     }     /*对p_re、p_im对时间维度做fft、ifft*/     fft(p_re,p_im,k,1);     fft(p_re,p_im,k,-1);     /*读入数据*/     fp2=fopen(\"output_m.dat\",\"wb\");     if(fp2==NULL)         printf(\"NULL2\");     else     {         for(s=0;s<S;s++)         {             for(r=0;r<R;r++)             {                 for(n=0;n<N;n++)                     fwrite(&p[r][n][s],sizeof(float),1,fp2);             }         }     }     return 0;  } 供参考～  打开文件有问题，会导致异常，使用野指针也会导致异常，运行之后如果还出现问题，建议继续查查；", "referer": "user-0"}]}
{"question": "C/C++中，函数非正常退出之后会做什么（像exit（1））", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://zh.cppreference.com/w/c/program/exit", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 楼主 weixin_56922977 的回复:是重新再运行一次这个函数直到正常退出吗？  还是回到前面出错的函数，直到电脑按程序正常执行后正常退出；还是跳过这个非正常退出的函数函数（貌似不太可能）。  来自数据结构的线性表 emm 给我整懵逼了，没太懂。 能具体吗?", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "函数非正常退出有两种，一种是exit，另一种是return;exit退出说明是异常比较重要（非常重要），以至于需要退出整个程序（exit是退出进程）；另一种是比较不重要，那么就return返回； 第一种exit系统会回收程序（所有的函数，变量比如全局变量堆上的空间等等）的资源；return是系统会回收函数栈的资源；这两个回收的范围不一样；", "referer": "user-0"}]}
{"question": "求求帮忙看看C语言的题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf=>cin printf=>cout", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "void sum_even(void) {     int num, cnt = 0, sum = 0;       while (scanf(\"%d\", &num) && num) {         if (num > 0) {             cnt++;             sum += cnt;         }     }      printf(\"sum = %d\\n\", sum); } 供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "int a=0,aa=0,aaa=0; while(1) { cin>>a; if(!a)break; if(!(a%2))++aa,aaa+=a; } cout<<aaa<<ends<<aa<<endl;", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 智者知已应修善业的回复: int a=0,aa=0,aaa=0; while(1) { cin>>a; if(!a)break; if(!(a%2))++aa,aaa+=a; } cout<<aaa<<ends<<aa<<endl;  谢谢谢谢，搞出来了，麻烦了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 7 楼 自信男孩的回复:[quote=引用 4 楼 木沁沁 的回复:][quote=引用 2 楼 自信男孩的回复:]void sum_even(void) {     int num, cnt = 0, sum = 0;       while (scanf(\"%d\", &num) && num) {         if (num > 0) {             cnt++;             sum += cnt;         }     }      printf(\"sum = %d\\n\", sum); } 供参考～ 不行诶，运行不出来[/quote]  不出来是什么第二个不对吗？ 在这个基础上改改，自己有手有大脑的，自己不能改改吗？  [/quote] 不好意思，真的一点都不懂，麻烦了。现在两个题都搞好了，没事了。还是谢谢你啦。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "int a=0,aa=0,aaa=0;                  while(1) {                  std::cin>>a;                  if(!a)break;                  if(a>0)++aa,aaa+=a; }                  std::cout<<aaa<<ends<<aa<<endl;", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "int a=0,aa=0,aaa=0; while(1) { std::cin>>a; if(!a)break; if(!(a%2))++aa,aaa+=a; } std::cout<<aaa<<ends<<aa<<endl;                                                                                                                                                                                                                                   cin>>a;==scanf(\"%d\", &a) cout<<aaa<<ends<<aa<<endl;==printf(\"%d %d\\n\", aaa,aa);", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "引用 4 楼 木沁沁 的回复:[quote=引用 2 楼 自信男孩的回复:]void sum_even(void) {     int num, cnt = 0, sum = 0;       while (scanf(\"%d\", &num) && num) {         if (num > 0) {             cnt++;             sum += cnt;         }     }      printf(\"sum = %d\\n\", sum); } 供参考～ 不行诶，运行不出来[/quote]  不出来是什么第二个不对吗？ 在这个基础上改改，自己有手有大脑的，自己不能改改吗？", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "供参考：#include<stdio.h>  int main() {     int ecnt=0,esum=0,n,pcnt=0,psum=0;     while(scanf(\"%d\",&n)==1 && n!=0){          if(n%2==0){    //偶数             ecnt++;             esum += n;          }          if(n>0){      //正数             pcnt++;             psum += n;          }      }     printf(\"ecnt=%d,esum=%d\\n\",ecnt,esum);//偶数的累加项数及和     printf(\"pcnt=%d,psum=%d\\n\",pcnt,psum);//正数的累加项数及和          return 0; }", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 1 楼 智者知已应修善业的回复: int a=0,aa=0,aaa=0; while(1) { cin>>a; if(!a)break; if(!(a%2))++aa,aaa+=a; } cout<<aaa<<ends<<aa<<endl;  整不出来诶😣", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:void sum_even(void) {     int num, cnt = 0, sum = 0;       while (scanf(\"%d\", &num) && num) {         if (num > 0) {             cnt++;             sum += cnt;         }     }      printf(\"sum = %d\\n\", sum); } 供参考～ 不行诶，运行不出来😣", "referer": "user-0"}]}
{"question": "C语言分析(关于指针，大神帮看看)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "原型： char * gets ( char * str ); 功能：通过标准输入（stdin）读入字符并存储到C类型的字符串，当检测到换行符或者文件结束符时停止读入。换行符和文件结束符不读入字符串中。'\\0'自动添加到字符串的最后。  int puts(const char *string) 功能 puts()函数用来向标准输出设备屏幕输出字符串并换行。具体是把字符串输出到屏幕上，将‘\\0’转换为回车换行。 调用方式是：puts(str)。其中str是字符串数组名或者字符串指针。实际上，数组名就是指针。 1、puts()只能输出字符串，不能输出数值或者进行格式转换，即不能要求输出格式增加空格、换行（指的是输出内容的中间进行换行）等要求； 2、可以将字符串直接写入puts()。如：puts(\"hello world\"); 3、puts()和 printf的用法一样,puts()函数的作用与语句“printf(\"%s\\n\",s);的作用相同。注意：puts在输出字 符串后会自动输出一个回车符。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "应该会默认用'\\0'替换掉'\\n'这句有问题吧，不是替换，而是'\\n'不会加入到你提供的缓存里～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "深入学习，脑洞大开是非常幸福的事情", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "呃 我还有几个问题： 1、定义了字符数组后例如  char b[1024];   如果不对其进行初始化，那么它的各元素的值是随机值还是 '\\0' ? 2、gets() 在对一个字符串赋值之后是不是会默认在该字符串末位加上 '\\0' ? 3、puts() 打印结束的标志是什么？  望大佬们在百忙之中能够解答一下小弟的疑惑。。。@qzjhjxj @自信男孩", "referer": "user-0"}]}
{"question": "求各位大佬帮忙看一下，while和for语句都分别怎么写，谢谢大佬！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "要么自己先写写，要么网上搜搜吧，这些问题都有解答的～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "作业还是自己做一遍吧小老弟", "referer": "user-0"}]}
{"question": "求指导，C程序运行openssl里面的函数没反应", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已解决，使用MSYS2对openssl库进行编译，生成libssl.a和libcrypto.a", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "在return 0;前面加一个getc();试试？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 user-1 的回复:引用 3 楼 qq_31101781 的回复:[quote=引用 1 楼 user-1 的回复:]在return 0;前面加一个getc();试试？还是不行，一跑进Openssl的函数就不行了，SHA1和SHA256都试过，我用powershell看一进SHA1( )函数，就挂死了 如果是函数跑挂了，那可能是环境问题，就不好处理了。。。[/quote]是的，就是找不到问题出在哪里，我安装openssl的时候都是按着网上的教程，安装perl，nasm，vs2017，nmake，nmake test，nmake install来生成库文件的。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 3 楼 qq_31101781 的回复:引用 1 楼 user-1 的回复:在return 0;前面加一个getc();试试？还是不行，一跑进Openssl的函数就不行了，SHA1和SHA256都试过，我用powershell看一进SHA1( )函数，就挂死了 如果是函数跑挂了，那可能是环境问题，就不好处理了。。。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-1 的回复:在return 0;前面加一个getc();试试？还是不行，一跑进Openssl的函数就不行了，SHA1和SHA256都试过，我用powershell看一进SHA1( )函数，就挂死了", "referer": "user-0"}]}
{"question": "手机适用c语言APP", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个现在网上搜一下就有吧，怀念初中用功能机瞎学c语言的时候", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不是啦因为个人一些原因是用不了电脑的 只有手机  所以问一问", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "c4droid", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "目前没听说过，弱弱的问一下，在手机上编译运行可以，编辑也在手机上？你是多么不愿意使用电脑呢，可能不方便在盖着被子的情况下写代码～", "referer": "user-0"}]}
{"question": "想了挺久实在没办法了，希望大佬帮帮忙！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:因为输入n之后的回车符号正好放在a[0]位置。解决办法是在输入n的scanf后面加一条getchar()试试 谢谢！确实是这样", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "因为输入n之后的回车符号正好放在a[0]位置。解决办法是在输入n的scanf后面加一条getchar()试试", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 赵4老师 的回复：输入 1,2 后面跟回车键可是无法输入[face]monkey2:019.png[/face]", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 9 楼 qzjhjxj 的回复：供参考：https://blog.csdn.net/qq_41852789/article/details/112322996?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-2.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-2.control https://blog.csdn.net/qq_20679687/article/details/105549146?ops_request_misc=&request_id=&biz_id=102&utm_term=vs%20code%E4%B8%AD%20%20printf()%E5%87%BD%E6%95%B0%E6%97%A0%E8%BE%93%E5%87%BA&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-105549146.pc_search_result_no_baidu_js https://blog.csdn.net/LaineGates/article/details/88219585?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control好的，谢谢了[face]monkey2:036.png[/face]", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考：https://blog.csdn.net/qq_41852789/article/details/112322996?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-2.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-2.control https://blog.csdn.net/qq_20679687/article/details/105549146?ops_request_misc=&request_id=&biz_id=102&utm_term=vs%20code%E4%B8%AD%20%20printf()%E5%87%BD%E6%95%B0%E6%97%A0%E8%BE%93%E5%87%BA&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-105549146.pc_search_result_no_baidu_js https://blog.csdn.net/LaineGates/article/details/88219585?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "输入 1,2 后面跟回车键", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 4 楼 qzjhjxj 的回复：第8、第9行之间，插入fflush (stdout);rewind (stdin);加了，但是我还是无法输入两个数去比较大小", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复：楼主的问题是环境使用问题，还是结果未达到预期的问题？ 如果是前者，建议找一下编译器（或工具）使用教程～环境应该没有什么问题，我都是按照网上来的", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "第8、第9行之间，插入fflush (stdout);rewind (stdin);", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "楼主的问题是环境使用问题，还是结果未达到预期的问题？ 如果是前者，建议找一下编译器（或工具）使用教程～", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复：在scanf前加一句 fflush(stdout);这样在输出那里显示了请输入a和b，但是我无法输入数据", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "在scanf前加一句 fflush(stdout);", "referer": "user-0"}]}
{"question": "第一行C语言代码，最大值，求和", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#define MAX3(x, y, z) (MAX(MAX(x, y), z))", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "可以不错，加油  #define MAX(x, y) (x > y ? x : y)", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "挺欢乐啊，哈哈", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "敬请批评改正", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "求最大值：x和y的最大值：printf(\"max = %d\\n\", x > y ? x:y);", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "", "referer": "user-0"}]}
{"question": "C语言构建顺序索引链接存储结构的索引表", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你好，请问你现在有这个题的答案了吗，可以发一下吗", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你好，你现在有答案了吗，第四步怎么完成", "referer": "user-1"}, {"cid": "3", "user": "user-3", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "struct param {     type data;     struct param *next; };  struct param array[10];", "referer": "user-0"}]}
{"question": "请教 c 语言什么方法可以向文件写入任意个数空格（可变的）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "void fun(int test) {     while (test--)         system(\"echo \\\" \\\" >> ./test.log\"); }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "void fun(int test) {      char *buffer = (char*)malloc(test);      memset(buffer,0,' ');      fwrite(buffer,test,1,fp);      free(buffer); }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "用循环fputc不就可以随意写入空格了吗？ fprintf也是可以的～", "referer": "user-0"}]}
{"question": "为什么scanf放在while(1)外面会出现死循环，放在里面就不会。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "因为你的循环条件是 1 ，永远为 true，scanf 又在循环外面，导致你没有机会重新输入 c 来更新 c 的值 而 scanf 放在循环里，由于 scanf 本来是阻塞等待输入，因此每一次循环你都可以重新输入 c ，这样你就有机会来退出循环，比如输入 #", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "把 scanf(\"%c\",&c);放在while(1){......}外面，只读取键盘输入一次，如果这一次机会if(c=='#')break;没把握住，当然死循环了,while(1)是永远为真。当把 scanf(\"%c\",&c);放到while(1){}内时，就会不停的去读键盘输入，然后if(c=='#')break;判断，就有无限次机会了退出了。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "不一定呢，如果一开始就输入#就break出循环，不会出现无线循环了。 如果一开始不是输入#，那么while没有break的条件，因此会死循环～", "referer": "user-0"}]}
{"question": "小白求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 4 楼 给我高高飞起来 的回复:[quote=引用 3 楼 qzjhjxj的回复:]按你写的就可以啊，供参考：typedef int ElemType;        //数据元素的类型为整数  typedef struct LNode{      ElemType   data;       //数据域      struct LNode  *next;   //指针域 }LNode,*LinkList;           // LinkList为指向结构体LNode的指针类型   void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)//函数定义 {      LinkList p;      p=LC; }  //我自身定义LinkList p; //我要怎么样才能使p=LC;  int main() {    LinkList La = (LinkList)malloc(sizeof(LNode));    LinkList Lb = (LinkList)malloc(sizeof(LNode));    LinkList Lc = (LinkList)malloc(sizeof(LNode));    MergeList_L(La,Lb,Lc);    system(\"pause\"); } 朋友，我那个LC是取地址（你可以看到是&LC），然后p是LinkList的变量 ，应该是定义指针变量*p，可是LinkList本身又是指针变量，定义p为指针变量我就不知道怎么引用结构体里的成分了，所以我想问怎么才能让p=LC[/quote] 供参考：typedef int ElemType;        //数据元素的类型为整数 typedef struct LNode{      ElemType   data;       //数据域      struct LNode  *next;   //指针域 }LNode,*LinkList;           // LinkList为指向结构体LNode的指针类型   void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)//函数头这样定义 {      LinkList p=LC;      p->data=20;      p->next=NULL; }  int main() {     LinkList La = (LinkList)malloc(sizeof(LNode));    LinkList Lb = (LinkList)malloc(sizeof(LNode));    LinkList Lc = (LinkList)malloc(sizeof(LNode));     MergeList_L(La,Lb,Lc);     LinkList p=Lc;    while(p){        printf(\"%d\",p->data);        p=p->next;    }    system(\"pause\"); }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:按你写的就可以啊，供参考：typedef int ElemType;        //数据元素的类型为整数  typedef struct LNode{      ElemType   data;       //数据域      struct LNode  *next;   //指针域 }LNode,*LinkList;           // LinkList为指向结构体LNode的指针类型   void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)//函数定义 {      LinkList p;      p=LC; }  //我自身定义LinkList p; //我要怎么样才能使p=LC;  int main() {    LinkList La = (LinkList)malloc(sizeof(LNode));    LinkList Lb = (LinkList)malloc(sizeof(LNode));    LinkList Lc = (LinkList)malloc(sizeof(LNode));    MergeList_L(La,Lb,Lc);    system(\"pause\"); } 朋友，我那个LC是取地址（你可以看到是&LC），然后p是LinkList的变量 ，应该是定义指针变量*p，可是LinkList本身又是指针变量，定义p为指针变量我就不知道怎么引用结构体里的成分了，所以我想问怎么才能让p=LC", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "按你写的就可以啊，供参考：typedef int ElemType;        //数据元素的类型为整数  typedef struct LNode{      ElemType   data;       //数据域      struct LNode  *next;   //指针域 }LNode,*LinkList;           // LinkList为指向结构体LNode的指针类型   void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)//函数定义 {      LinkList p;      p=LC; }  //我自身定义LinkList p; //我要怎么样才能使p=LC;  int main() {    LinkList La = (LinkList)malloc(sizeof(LNode));    LinkList Lb = (LinkList)malloc(sizeof(LNode));    LinkList Lc = (LinkList)malloc(sizeof(LNode));    MergeList_L(La,Lb,Lc);    system(\"pause\"); }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:先把链表的创建，链表的遍历写出来吧。  链表合并试着写写 好的，谢谢", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "先把链表的创建，链表的遍历写出来吧。  链表合并试着写写", "referer": "user-0"}]}
{"question": "自学数据结构 求高人指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:看这个函数，循环是找到最小值的位置，L.data[pos] = L.data[L.length-1];这句用的比较巧，用最后一个元素覆盖最小值的位置；  这样做不会丢失原队列数据，但是会改变顺序；如果不考虑顺序，这样的做法还是挺好的。 谢谢大佬", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:Del_Min()   ListDelet(&L,i,&e) 这些都是自定义的函数名称，函数的名称、形参、返回值等不同，表示函数实现的功能作用不相同，Del_Min（）函数实现的功能是删除顺序表一个值最小的元素， ListDelet(&L,i,&e)函数可能实现的功能是删除顺序表中值为e的元素。虽然这两函数实现的具体的功能有差别，但大的功能就是删除某一个元素，所以为了方便记忆及识别，在它们的名称中都出现了del的字样，这样从名称中我们就可以大致判断这个函数所实现的功能，这也是编写代码过程中普遍采用的方式。当然，自定义的函数的名称理论上可以任意编写，只要所取字符不是系统的关键字符，但这样做的意义不大，写个毫无规律的名称，过一段时间，自己都忘了，想拿来用下，怎么也找不到呢。 谢谢大佬", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "看这个函数，循环是找到最小值的位置，L.data[pos] = L.data[L.length-1];这句用的比较巧，用最后一个元素覆盖最小值的位置；  这样做不会丢失原队列数据，但是会改变顺序；如果不考虑顺序，这样的做法还是挺好的。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "Del_Min()   ListDelet(&L,i,&e) 这些都是自定义的函数名称，函数的名称、形参、返回值等不同，表示函数实现的功能作用不相同，Del_Min（）函数实现的功能是删除顺序表一个值最小的元素， ListDelet(&L,i,&e)函数可能实现的功能是删除顺序表中值为e的元素。虽然这两函数实现的具体的功能有差别，但大的功能就是删除某一个元素，所以为了方便记忆及识别，在它们的名称中都出现了del的字样，这样从名称中我们就可以大致判断这个函数所实现的功能，这也是编写代码过程中普遍采用的方式。当然，自定义的函数的名称理论上可以任意编写，只要所取字符不是系统的关键字符，但这样做的意义不大，写个毫无规律的名称，过一段时间，自己都忘了，想拿来用下，怎么也找不到呢。", "referer": "user-0"}]}
{"question": "求大佬指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 Dream1018 lin 的回复:[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h>  int main() {     int i=0;     //char a[5];     char a[16];     a[i]=getchar();     while(a[i]!='\\n')     {         i++;         if (i > 5) {             printf(\"Too big!\\n\");             return 0;         }         a[i]=getchar();     }     printf(\"%d\\n\",i);     for(int j=0; j<i-1; j++)     {         printf(\"%d \",a[j]-48);     }     printf(\"%d\\n\",a[i-1]-48);     for(int j=i-1; j>=0; j--)     {         printf(\"%d\",a[j]-48);     } } 供参考～  数组长度为5不合适，因为也得给'\\n'留一个空间的，因为你把'\\n'放在了a[i]中。我的修改用了16，个人建议数组长度定义为2^n的空间； 试了一下，可以了，谢谢！可以解释一下为什么要数组长度要定义为2^n吗？[/quote] 因为涉及到内存分配的原理，还有页，表之类的信息，等你深入的了解内存的分配原理就知道了。现在先这么做吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  int main() {     int i=0;     //char a[5];     char a[16];     a[i]=getchar();     while(a[i]!='\\n')     {         i++;         if (i > 5) {             printf(\"Too big!\\n\");             return 0;         }         a[i]=getchar();     }     printf(\"%d\\n\",i);     for(int j=0; j<i-1; j++)     {         printf(\"%d \",a[j]-48);     }     printf(\"%d\\n\",a[i-1]-48);     for(int j=i-1; j>=0; j--)     {         printf(\"%d\",a[j]-48);     } } 供参考～  数组长度为5不合适，因为也得给'\\n'留一个空间的，因为你把'\\n'放在了a[i]中。我的修改用了16，个人建议数组长度定义为2^n的空间； 试了一下，可以了，谢谢！可以解释一下为什么要数组长度要定义为2^n吗？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  int main() {     int i=0;     //char a[5];     char a[16];     a[i]=getchar();     while(a[i]!='\\n')     {         i++;         if (i > 5) {             printf(\"Too big!\\n\");             return 0;         }         a[i]=getchar();     }     printf(\"%d\\n\",i);     for(int j=0; j<i-1; j++)     {         printf(\"%d \",a[j]-48);     }     printf(\"%d\\n\",a[i-1]-48);     for(int j=i-1; j>=0; j--)     {         printf(\"%d\",a[j]-48);     } } 供参考～  数组长度为5不合适，因为也得给'\\n'留一个空间的，因为你把'\\n'放在了a[i]中。我的修改用了16，个人建议数组长度定义为2^n的空间；", "referer": "user-0"}]}
{"question": "新手求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 weixin_56991544 的回复:也就是中间值的时候都是用的int的类型？ 有一个类型隐式提升，可以查一下～ 比如~i会自动将i的类型提升到int类型～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "也就是中间值的时候都是用的int的类型？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这中间都掺杂着类型转换，比如i = ~i;首先~i取反会类型提升到int，所以~i的结果是-251（最高位为符号位int类型）； i = ~i;把-251赋值给i会有类型int转成unsigned char（最终转成unsigned char）。", "referer": "user-0"}]}
{"question": "pintia上浙大的链表题目，求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <stdio.h> #include <stdlib.h>  struct ListNode {     int data;     struct ListNode *next; };  struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L );  void printlist( struct ListNode *L ) {      struct ListNode *p = L;      while (p) {            printf(\"%d \", p->data);            p = p->next;      }      printf(\"\\n\"); }  int main() {     struct ListNode *L, *Odd;     L = readlist();     Odd = getodd(&L);     printlist(Odd);     printlist(L);          return 0; } struct ListNode *readlist() { \tint num; \tstruct ListNode *p,*head,*tail; \thead=tail=NULL; \twhile(scanf(\"%d\",&num)){                 if(num==-1)break;                 p=(struct ListNode *)malloc(sizeof(struct ListNode));                 p->data=num;                 p->next=NULL;                 if(head==NULL){                      head=p;                      tail=p;                 }else{                      tail->next=p;                      tail=p;                 }     }     return head; }  struct ListNode *getodd( struct ListNode **L )//L是头指针的地址 *L即为头指针 { \tstruct ListNode *head=NULL,*tail=NULL,*p2=NULL,*p1=NULL;     p1=*L;                                //此时的head是奇数链的头指针 \twhile(p1){               if(p1->data%2!=0){                    if(p1==*L){                       *L=p2=p1->next;                    }else{                       p2->next=p1->next;                    }                    if(head==NULL){ //建立新的奇数链                       head=p1;                       tail=p1;                    }else{                       tail->next=p1;                       tail=p1;                    }               }else{                    p2=p1;               }               p1=p1->next;     }     if(head!=NULL)tail->next=NULL;     if(*L  !=NULL)p2->next=NULL;     return head; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h>  struct ListNode {     int data;     struct ListNode *next; };  struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L );  void printlist( struct ListNode *L ) {     struct ListNode *p = L;      while (p) {         printf(\"%d \", p->data);         p = p->next;     }     printf(\"\\n\"); }  int main() {     struct ListNode *L, *Odd;     L = readlist();     Odd = getodd(&L);     printlist(Odd);     printlist(L);      return 0; } struct ListNode *readlist() {     int num;     struct ListNode *p,*head,*tail;     head=tail=NULL;      while(scanf(\"%d\",&num)){         if(num==-1)             break;         p=(struct ListNode *)malloc(sizeof(struct ListNode));         p->data=num;         p->next=NULL;         if(head==NULL)             head=p;         else             tail->next=p;         tail=p;     }      return head; } struct ListNode *getodd( struct ListNode **L )//L是头指针的地址 *L即为头指针 {  #if 1     struct ListNode *podd_head = NULL, *p, *q, *tail;      p = q = *L;      while (p) {         if (p->data % 2) {             if (!podd_head)                 podd_head = p;              else                 tail->next = p;             tail = p;              if (p == *L) {                 *L = (*L)->next;                 p = q = *L;             } else {                 q->next = p->next;                 p = p->next;             }         } else {             q = p;             p = p->next;         }     }      tail->next = NULL;      return podd_head; #else     struct ListNode *p=NULL,*head=NULL,*tail=NULL,*p2=NULL,*p1=NULL;//此时的head是奇数链的头指针     p1=*L;     while(p1){         if(p1->data%2){             if(head==NULL)                 head=p1;             else                 tail->next=p1;             tail=p1;             //建立新的奇数链             if(p1==*L)                 *L=p1->next;             else                 p2->next=p1->next;         }         else{             p2=p1;             p1=p1->next;         }     }     return head; #endif  }  供参考～", "referer": "user-0"}]}
{"question": "该程序编译没问题，输出有错误，求教！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <stdio.h>  int  intput(int *p); void enter(int *p,int a);  int  main() {     int s[100],k;//k代表输入数的个数     k=intput(s);     enter(s,k);     system(\"pause\"); }  int intput(int *p) //int input(int *p) 函数名少了‘t' {     int a=0;     do       {        scanf(\"%d\",p++);        a++;            //需要对a设个上限值     }while(*(p-1)>0); //while(*p<0);     return a; } void enter(int *p,int a) {     for(int i=0;i<a;i++)// for(int i=0;i<=a;i++)         printf(\"%d  \",*(p+i)); }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//#include \"stdio.h\" #include <stdio.h>  int input(int *p, int len); void enter(int *p,int a);  //void main() int main(void) {     int s[100],k;//k代表输入数的个数     //k=intput(s, 100);     k=input(s, 100);     enter(s,k); } int input(int *p, int len) {     int a=0;     do     {         //scanf(\"%d\", p+1);         scanf(\"%d\", p+a);         a++;         if (a >= len)             break;     //} while(*p < 0);     } while(*(p+a-1) > 0);      return a; } void enter(int *p,int a) {     for(int i=0;i<=a;i++)         printf(\"%d  \",*(p+i)); } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "intput => input", "referer": "user-0"}]}
{"question": "求大神解答一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没说解答什么呢；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "题目有啥要求？出现啥问题？？说清楚一点吧。", "referer": "user-0"}]}
{"question": "有大佬能给个这题的代码吗，我是刚学的小白，这题属实是不会弄了，谢谢了谢谢了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include<stdio.h> #include<math.h>  int main() {     int    i=1;     double temp=1,sum=1,x;     scanf(\"%lf\",&x);     while(fabs(temp)>=1e-6)     {           temp = temp*x/i;           sum += temp;           temp = -temp;           i++;     }     printf(\"%lf\\n\",sum);          return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这有难度么？为什么自己不动手写一下呢？？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "网上搜搜吧，可以看一下别人怎么写的，也能看到别人的讲解～", "referer": "user-0"}]}
{"question": "为什么我的单链表只能打印第一个位置的，后面调用的不显示？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h>  typedef struct LNode {     int data;     struct LNode *next; }LNode,*LinkList;  int InitList(LinkList &L) {     L=(LinkList)malloc(sizeof(LNode));     if(L==NULL)         return false;     L->next=NULL;      return true; }  //store //int chucun (LinkList L,int a[],int i) int chucun (LinkList L,int a[], int len) {     int i = 0;     LinkList s;      while(i < len)     {         s = (LinkList)malloc(sizeof(LNode));         if (!s)             return -1;          s->data = a[i];         s->next = L->next;         L->next = s;          /*s->next=NULL;          L->data=a[i];         s->next  =L->next;         L->next=s;s->data=L->data;         */         i++;     }      return 0; } LinkList charu(LNode * L, int pos, int c) {     LinkList p;     int j=0,i=2;     p=L;     while(j < pos - 1 && p->next)     {         p=p->next;++j;     }     LinkList s;     s=(LinkList)malloc(sizeof(LNode));     s->data=c;     s->next=p->next;     p->next=s;      //return L->next;     return L; } int shanchu  (LinkList L, int i) {     LinkList p,s;     int j=0;     p=L;     //while(!(p->next)&&j<i-1){     while((p->next)&&j<i-1){         p=p->next,j++;     }     if (p->next == NULL)         return -1;      s = p->next;     p->next=s->next;     free(s);     s=NULL;      return 0; }  void printlist(LinkList L) {     LinkList temp = L->next;      printf(\"链表中的值为\\n\");     while(temp) {         printf(\"%d\\n\",temp->data);         temp=temp->next;     } }  //int main() int main(void) {     LinkList L;     InitList(L);     int a[]={11,22,33,44,66};     int i=0;     int c=55;     chucun(L, a, sizeof(a)/sizeof(a[0]));     printf(\"打印储存的链表\\n\");     printlist(L);     charu (L, 2, c);     printf(\"打印插入的链表\\n\");     printlist(L);     shanchu  (L ,5);     printf(\"打印删除后的链表\\n\");     printlist(L);      return 0; }  供参考～ 找到错误了，谢谢大佬", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h>  typedef struct LNode {     int data;     struct LNode *next; }LNode,*LinkList;  int InitList(LinkList &L) {     L=(LinkList)malloc(sizeof(LNode));     if(L==NULL)         return false;     L->next=NULL;      return true; }  //store //int chucun (LinkList L,int a[],int i) int chucun (LinkList L,int a[], int len) {     int i = 0;     LinkList s;      while(i < len)     {         s = (LinkList)malloc(sizeof(LNode));         if (!s)             return -1;          s->data = a[i];         s->next = L->next;         L->next = s;          /*s->next=NULL;          L->data=a[i];         s->next  =L->next;         L->next=s;s->data=L->data;         */         i++;     }      return 0; } LinkList charu(LNode * L, int pos, int c) {     LinkList p;     int j=0,i=2;     p=L;     while(j < pos - 1 && p->next)     {         p=p->next;++j;     }     LinkList s;     s=(LinkList)malloc(sizeof(LNode));     s->data=c;     s->next=p->next;     p->next=s;      //return L->next;     return L; } int shanchu  (LinkList L, int i) {     LinkList p,s;     int j=0;     p=L;     //while(!(p->next)&&j<i-1){     while((p->next)&&j<i-1){         p=p->next,j++;     }     if (p->next == NULL)         return -1;      s = p->next;     p->next=s->next;     free(s);     s=NULL;      return 0; }  void printlist(LinkList L) {     LinkList temp = L->next;      printf(\"链表中的值为\\n\");     while(temp) {         printf(\"%d\\n\",temp->data);         temp=temp->next;     } }  //int main() int main(void) {     LinkList L;     InitList(L);     int a[]={11,22,33,44,66};     int i=0;     int c=55;     chucun(L, a, sizeof(a)/sizeof(a[0]));     printf(\"打印储存的链表\\n\");     printlist(L);     charu (L, 2, c);     printf(\"打印插入的链表\\n\");     printlist(L);     shanchu  (L ,5);     printf(\"打印删除后的链表\\n\");     printlist(L);      return 0; }  供参考～", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "完全可以这么写呢，但是你的代码不全，上面这么写，下面肯定也是从i=1开始的，所以要改都改了才行～  另外，N的输入值需要判断一下，不能大于99(100-1）因为从1开始，i <= N-1", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "确实从1开始才符合这题，但从0也是合理", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "有的人喜欢把手机放进左边口袋，有的人喜欢放右边，你要是喜欢并且方便，拿在手里也可以。  从这个片段中看不出理由， he or she seems like to do so.", "referer": "user-0"}]}
{"question": "关于C语言scanf的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 6 楼 Dream1018 lin 的回复:[quote=引用 1 楼 qzjhjxj 的回复:]供参考：#include <stdio.h>  int main() {       int a[100],i=0,j;       while ((scanf(\"%d\",&a[i++])==1)&&((getchar())!='\\n'));      //方法一：以回车作为结束符，最后回车前面不能有空格       //while (scanf(\"%d\",&a[i])==1 && a[i]!=0){i++;}      //方法二：以0或其他数字作为结束符，结束输入       for (j=0;j<i;j++)           printf(\"%d \",a[j]);            return 0; } 您好，我有点不太理解这样做的含义，我尝试把代码进行如下修改： int main() {      int a[100],i=0,j;     char m;     while ((scanf(\"%d\",&a[i++])==1)&&((m=getchar())!='\\n'))     {         printf(\"%d,%c\\n\",a[i-1],m);     }     for (j=0; j<i; j++)         printf(\"%d \",a[j]);      return 0; } 输入为：1 2 3 4 5(回车) 输出为： 1, 2, 3, 4,    (注意，5是没有被输出的) 1 2 3 4 5  我有疑问的点在于scanf与getchar()是同时工作的?还是说有先把数读给scanf，再读给getchar()? 我的假设是scanf每次进行输出的同时,会将读取到的数字同时作为字符的形式传给getchar(), 然后将每次getchar()读取到的字符给打印出来，但是却没有结果，对这里的getchar()的工作方式不太理解， 尤其是最后边'5,'并没有被打印出来，这又是为什么？还请指点。[/quote] 将上面的写法换种表达，方便对while（）的理解，两个函数的详细用法可以参考网上的资料，以下供参考：#include <stdio.h> int main() {      int a[100],i=0,j;     char m;     while (1)     {         if(scanf(\"%d\",&a[i++])!=1) break;         printf(\"a[%d]=%d\\n\",i-1,a[i-1]);         if((m=getchar()) == '\\n')  break;     }     for (j=0; j<i; j++)         printf(\"%d \",a[j]);          return 0; }  //用scanf输入数值类型（int、float、double等） //空格、回车、Tab键不会中断输入，scanf从第一个非空格/回车数值开始录入，即不管中间有多少空格有多少回车， //都不会中断scanf的录入，除非到达scanf中规定的录入数量或遇到非数值类型时scanf(\"%d\",&a[i++])!=1条件成立。  //getchar //getchar()主要用来接收单个字符，不管是空格或者回车都可以接收。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 qzjhjxj 的回复:供参考：#include <stdio.h>  int main() {       int a[100],i=0,j;       while ((scanf(\"%d\",&a[i++])==1)&&((getchar())!='\\n'));      //方法一：以回车作为结束符，最后回车前面不能有空格       //while (scanf(\"%d\",&a[i])==1 && a[i]!=0){i++;}      //方法二：以0或其他数字作为结束符，结束输入       for (j=0;j<i;j++)           printf(\"%d \",a[j]);            return 0; } 您好，我有点不太理解这样做的含义，我尝试把代码进行如下修改： int main() {      int a[100],i=0,j;     char m;     while ((scanf(\"%d\",&a[i++])==1)&&((m=getchar())!='\\n'))     {         printf(\"%d,%c\\n\",a[i-1],m);     }     for (j=0; j<i; j++)         printf(\"%d \",a[j]);      return 0; } 输入为：1 2 3 4 5(回车) 输出为： 1, 2, 3, 4,    (注意，5是没有被输出的) 1 2 3 4 5  我有疑问的点在于scanf与getchar()是同时工作的?还是说有先把数读给scanf，再读给getchar()? 我的假设是scanf每次进行输出的同时,会将读取到的数字同时作为字符的形式传给getchar(), 然后将每次getchar()读取到的字符给打印出来，但是却没有结果，对这里的getchar()的工作方式不太理解， 尤其是最后边'5,'并没有被打印出来，这又是为什么？还请指点。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 1 楼 qzjhjxj 的回复:供参考：#include <stdio.h>  int main() {       int a[100],i=0,j;       while ((scanf(\"%d\",&a[i++])==1)&&((getchar())!='\\n'));      //方法一：以回车作为结束符，最后回车前面不能有空格       //while (scanf(\"%d\",&a[i])==1 && a[i]!=0){i++;}      //方法二：以0或其他数字作为结束符，结束输入       for (j=0;j<i;j++)           printf(\"%d \",a[j]);            return 0; } 注意考虑一下数组越界～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "EOF确实是以ctrl+z（Windows）或ctrl+d（Linux）输入的。  int  i=0; while(scanf(\"%d\",a[i])!=EOF) {     i++; } 这样是可以的，但是不能无限输入呢，因为i要注意不要越界呢。所以可以加一下限制条件：   int  i=0; while(i < MAX_ARRAY_SIZE && scanf(\"%d\",a[i])!=EOF)    //MAX_ARRAY_SIZE自己定义长度，这个是数组的长度 {     i++; } 供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢，想问一下，程序每次从输入中读取时scanf和getchar是同时进行的吗，意思是：  引用 2 楼 自信男孩 的回复:EOF确实是以ctrl+z（Windows）或ctrl+d（Linux）输入的。  int  i=0; while(scanf(\"%d\",a[i])!=EOF) {     i++; } 这样是可以的，但是不能无限输入呢，因为i要注意不要越界呢。所以可以加一下限制条件：   int  i=0; while(i < MAX_ARRAY_SIZE && scanf(\"%d\",a[i])!=EOF)    //MAX_ARRAY_SIZE自己定义长度，这个是数组的长度 {     i++; } 供参考～ 谢谢！", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "供参考：#include <stdio.h>  int main() {       int a[100],i=0,j;       while ((scanf(\"%d\",&a[i++])==1)&&((getchar())!='\\n'));      //方法一：以回车作为结束符，最后回车前面不能有空格       //while (scanf(\"%d\",&a[i])==1 && a[i]!=0){i++;}      //方法二：以0或其他数字作为结束符，结束输入       for (j=0;j<i;j++)           printf(\"%d \",a[j]);            return 0; }", "referer": "user-0"}]}
{"question": "简单问题有人能全答对吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不同编译器，不同内核系统，硬件不同，答案也不同，问题很简单。你把整个底层问个遍 吧 引用 楼主 m0_56094393 的回复:Int类型中最多可以表示多少个不重复的自然数?多少个不重复的整数?int类型最大数在计算机中的ascii码是?最小数在计算机中的ascii码是多少?", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "看一下int类型占几个字节（跟系统、编译器有关系），另外，看一下int的表示范围～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "楼主应该问一下上帝：C语言int类型应该占几个字节？", "referer": "user-0"}]}
{"question": "球球大佬看一下哪里有问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "注意溢出问题，注意unsigned int表示的范围；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "1. 外层for循环里面n=1,n<=9是固定循环9次，按照要求应该是给定的n次才对啊 2. 内层for循环应该带上x=x*10+a，这样才可以达到例如2222的这种要求把 就像3楼大佬给的代码那样", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "输入，输出C=>C++  scanf(\"%d\",&a);=>cin printf(\"n=?\\n\");=>cout", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "仅供参考 #include <stdio.h>  int Mult10(int n) {     int sum=10;     int m;     if(n==0)return 1;     for(m=1;m<n;m++)sum=sum*10;     return sum; }  int main() {     int a,n,sn,x=0;     int i,j;     printf(\"a=?\\n\");     scanf(\"%d\",&a);     printf(\"n=?\\n\");     scanf(\"%d\",&n);     sn=0;     for(i=0;i<n;i++)     {         for(j=0;j<=i;j++)             x+=a*Mult10(j);         sn+=x;         x=0;     }     printf(\"sn=%d\\n\",sn);     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "内嵌循环x=0；何意？", "referer": "user-0"}]}
{"question": "有没有大佬告诉我为什么运行不出正确答案呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改如下,供参考：#include<stdio.h> #include<math.h> int main() {    double pi=0.5,term=0.0,n,j=1.0;    int    i=1;      do{         //for(i=1;i>0;i=i+2)         j=j*i/(i+1);         n=1.0/(i+2)*pow(0.5,i+2);         term=j*n;         pi=pi+term;         i+=2;     }while(fabs(term)>=1e-6);     pi=6*pi;     printf(\"pi=%10.8f\\n\",pi);          return 0; }", "referer": "user-0"}]}
{"question": "求大神解答，关于回文数，吸血鬼数，高位数加法。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "求素数与判断质数这个解决  大数加法要看使用哪种形式，char数组？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "等于反转后的数就是回文数。大数加法把输入部分写出来看看，不同的思路有不同的解法。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 智者知已应修善业的回复:回文这个解决 啊……这个看不太懂……没学过栈……", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 智者知已应修善业的回复:求素数与判断质数这个解决  大数加法要看使用哪种形式，char数组？ 谢谢！太及时啦!嗯嗯！就是数组的!", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "回文这个解决", "referer": "user-0"}]}
{"question": "请问这段代码有什么问题么？。为什么没有输出？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>   //long long int array[1000]= {0}; long long int array[1000];  //全局变量编译器默认会给初始化为0  int main() {     long long int N;     scanf(\"%lld\",&N);      printf(\"%lld\\n\", N);     if (N > 1000)         N = 1000 -1;     for(long long int i=0; i<=N; i++)     {         for(long long int m=N; m>0; m--)         {             //if(m%i==0)             if(i != 0 && m%i==0)                 array[m]++;         }     }     for(long long int i=0; i<=N; i++)     {         //printf(\"%d\\n\",array[i]);         printf(\"%lld\\n\",array[i]);     }     return 0; }  供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>   //long long int array[1000]= {0}; long long int array[1000];  //全局变量编译器默认会给初始化为0  int main() {     long long int N;     scanf(\"%lld\",&N);      printf(\"%lld\\n\", N);     if (N > 1000)         N = 1000 -1;     for(long long int i=0; i<=N; i++)     {         for(long long int m=N; m>0; m--)         {             //if(m%i==0)             if(i != 0 && m%i==0)                 array[m]++;         }     }     for(long long int i=0; i<=N; i++)     {         //printf(\"%d\\n\",array[i]);         printf(\"%lld\\n\",array[i]);     }     return 0; }  供参考～ 谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "if(m%i==0)你 i 从0开始，这里除数为0 异常了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "供参考：https://blog.csdn.net/citywanderer2005/article/details/613039?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161762552616780269884273%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161762552616780269884273&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-8-613039.pc_search_result_cache&utm_term=%E5%9C%A8%E4%B8%BB%E5%87%BD%E6%95%B0%E5%A4%96%E5%92%8C%E4%B8%BB%E5%87%BD%E6%95%B0%E5%86%85%E5%AE%9A%E4%B9%89%E7%9A%84%E6%95%B0%E7%BB%84%E5%85%B6%E6%9C%80%E5%A4%A7%E5%8F%AF%E5%AE%B9%E7%BA%B3%E5%85%83%E7%B4%A0%E4%B8%AA%E6%95%B0%E5%88%86%E5%88%AB%E6%98%AF%E5%A4%9A%E5%B0%91%E5%91%80%EF%BC%9F", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-3 的回复:问题多了，没明白楼主的代码想实现什么，供参考：#include <stdio.h> #include <stdlib.h> long int array[1000]= {0};//这里数组容量是1000,下标0-999 int main() {     long int N;     scanf(\"%lld\",&N);      //这里如果N 是11位数     for(long int i=1; i<=N; i++) //for( int i=0; i<=N; i++)     {         for(long int m=N; m>=0; m--)//相应的for()里的整形变量和N要同类型，有赋值m=N         {             if(m%i==0)   //第一个for()循环里i不能从0开始，这里出现 m%0                array[m]++;//这里数组下标就越界了，因为m=N=11位数         }     }     for(long int i=0; i<=N; i++)     {         printf(\"%d\\n\",array[i]);     }          return 0; } 感谢回答，想再请问一下，在主函数外和主函数内定义的数组其最大可容纳元素个数分别是多少呀？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "问题多了，没明白楼主的代码想实现什么，供参考：#include <stdio.h> #include <stdlib.h> long int array[1000]= {0};//这里数组容量是1000,下标0-999 int main() {     long int N;     scanf(\"%lld\",&N);      //这里如果N 是11位数     for(long int i=1; i<=N; i++) //for( int i=0; i<=N; i++)     {         for(long int m=N; m>=0; m--)//相应的for()里的整形变量和N要同类型，有赋值m=N         {             if(m%i==0)   //第一个for()循环里i不能从0开始，这里出现 m%0                array[m]++;//这里数组下标就越界了，因为m=N=11位数         }     }     for(long int i=0; i<=N; i++)     {         printf(\"%d\\n\",array[i]);     }          return 0; }", "referer": "user-0"}]}
{"question": "c语言unsigned？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1/3改成1.0f/3目的是将表达式的计算由unsigned int类型转换为float类型。否则1/3得的值为0；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "整型相除结果为整型，1/3结果为0", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "1改成1.0f", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "f1改下：f1=1*1.0/3*c*d*N;", "referer": "user-0"}]}
{"question": "有大神可以帮我看看这段代码错在哪里了吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "一个分号引发的惨案", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:第15行if()语句最后多了‘；’号。 对对对，我真的瞎，这都没发现", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "第15行if()语句最后多了‘；’号。", "referer": "user-0"}]}
{"question": "求助，为什么一直不是回文数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> int main() {     int a,b,c,d,e,f;      printf(\"输入一个五位数整数:\");     //scanf(\"d\",&a);     scanf(\"%d\",&a); #if 0     b=a/10000;      /*万位数*/     c=a%10000/1000;   /*千位数*/     d=a%1000/100; /*百位数*/     e=a%100/10; /*十位数*/     f=a%10;   /*个位数*/     if (b==f&&c==e)         printf(\"该数是回文数\");     else         printf(\"该数不是回文数\"); #endif      if (a <= 9999 || a > 99999)         return -1;     b = a /10000;     f = a % 10;     if (b != f) {         printf(\"该数不是回文数\");         return -1;     }      c = a % 10000 / 1000;     e = a % 100 / 10;      if (c != e) {         printf(\"该数不是回文数\");         return -1;     }     printf(\"该数是回文数\");      return 0;  } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include <stdio.h> int main() {     int a,b,c,d,e,f;     printf(\"输入一个五位数整数:\");     scanf(\"%d\",&a);   //scanf(\"d\",&a);     b=a/10000;        /*万位数*/      c=a/1000%10;     /*千位数*/ //c=a%10000/1000; /*千位数*/      d=a/100%10;      //d=a%1000/100;  /*百位数*/      e=a/10%10;       //e=a%100/10;/*十位数*/     f=a%10;         /*个位数*/     if (b==f&&c==e)         printf(\"该数是回文数\\n\");     else         printf(\"该数不是回文数\\n\");          return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "可参 可参", "referer": "user-0"}]}
{"question": "为什么它运行不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "‘//.......’表示它的后面所跟的内容只起说明作用，不会被编译进代码里。//scanf(\"%d%d%d\\n\",&a,&b,&c);这句是你提供的代码里的内容。 整体修改如下，供参考：#include<stdio.h> #include<math.h> void main() {     int a,b,c;     double area,s;     printf(\"请输入三角形的三条边a,b,c:\\n\");     scanf(\"%d%d%d\",&a,&b,&c);//标注--错误在这句：scanf(\"%d%d%d\\n\",&a,&b,&c);     if(a+b>c&&a+c>b&&b+c>a)      {         s=(a+b+c)*0.5;         area=sqrt(s*(s-a)*(s-b)*(s-c));         printf(\"%.2f\\n\",area);         if(a*a==b*b+c*c||b*b==a*a+c*c||c*c==a*a+b*b)               printf(\"此三角形为直角三角形\\n\");         else if(a==b||a==c||b==c)               printf(\"此三角形为等腰三角形\\n\");         else if((a==b)&&(b==c))               printf(\"此三角形为等边三角形\\n\");         else               printf(\"此三角形为一般三角形\\n\");      }     else         printf(\"不能构成三角形\\n\");      }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "等边三角形会被认为是等腰三角形", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "完善下，供参考：#include<stdio.h> #include<math.h> void main() {     int a,b,c;     double area,s;     printf(\"请输入三角形的三条边a,b,c:\\n\");     scanf(\"%d%d%d\",&a,&b,&c);     if(a+b>c&&a+c>b&&b+c>a)      {         s=(a+b+c)*0.5;         area=sqrt(s*(s-a)*(s-b)*(s-c));         printf(\"%.2f\\n\",area);         if(a*a==b*b+c*c||b*b==a*a+c*c||c*c==a*a+b*b)               printf(\"此三角形为直角三角形\\n\");         else if(((a==b||a==c) && b!=c)||((b==c||b==a)&& a!=c))               printf(\"此三角形为等腰三角形\\n\");         else if((a==b)&&(b==c)&&(a==c))               printf(\"此三角形为等边三角形\\n\");         else               printf(\"此三角形为一般三角形\\n\");      }     else         printf(\"不能构成三角形\\n\");      }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "而且加了那个\\n并没有用，依旧运行不了", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "为啥前面要加斜杠", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "这句有错误：scanf(\"%d%d%d\",&a,&b,&c);//scanf(\"%d%d%d\\n\",&a,&b,&c);", "referer": "user-0"}]}
{"question": "函数传参是通过寄存器还是栈？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "大部分都是用的栈吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "调用约定 https://docs.microsoft.com/zh-cn/cpp/cpp/calling-conventions?view=vs-2017", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "以前调试过一次 x86 平台 用栈 x64 前几个参数 是用通用寄存器", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 13 楼 六道佩恩的回复:[quote=引用 6 楼 真相重于对错 的回复:]1、用栈和用寄存器都可以达到传递参数的目的 2、c/c++只规定了语言部分，并没有规定实现部分。 3、__stdcall....这些只是微软 ,gun c/c++的厂家的自己实现。这些不是c/c++的标准的关键词。 4、如果用到寄存器，却发生中断，也没有问题，因为中断首先就要保存寄存器，中断结束后恢复寄存器。 5、我用vs看基本还是用栈。  gcc我看64位用的寄存器，32位用的栈。 我知道这不是语言的部分，但问题是，既然GCC自己规定了，为什么64位的时候它自己又不遵守了？[/quote] 我对gcc不是很熟，你既然说是gcc规定。不知道你是从官方文档里得到的还是道听途说呢？ https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Function-Attributes.html", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "可以不用push,直接操作栈寄存器就可以了，pop也是类似", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "什么时候发现的？会不会与python有关？", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "无怪代码越跑越快，程序越来越大。", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "xxxxxxxxxxxxxxxxxx", "referer": "user-0"}, {"cid": "9", "user": "user-6", "content": "支持一个\"><xxxxx>", "referer": "user-0"}, {"cid": "10", "user": "user-7", "content": "gcc在windows下也使用的win64 ABI，win64 ABI中只有一种调用约定，fastcall，没有cdecl、 stdcall、pascal这些。源码中虽然可以写_-cdecl、 __stdcall之类的修饰，但是在win64编译器中不起作用，只是出于源码兼容的考虑允许这么写，实际被忽略了。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 7 楼 Intel0011 的回复:[quote=引用 楼主 六道佩恩 的回复:]调试查看汇编是通过寄存器传的  但《程序员的自我修养》的“调用惯例”却只说了用栈，没有提用寄存器  连标了__cdecl的库函数，调用时都是通过寄存器的，为什么？不应该是通过栈吗？ x86上函数参数是压栈传递的，但使用时需要从栈上取出放入寄存器中，或用寄存器作为指针指向栈上的数据， 并没有使用寄存器传递参数，但不绝对，C++就使用了ecx传递了对象的this指针  x64中函数参数传递发生了改变 借PC处理器架构由x86向x64过渡之机，MS清理了Windows x64平台上的函数调用约定， 由原来的数种包括stdcall、thiscall、fastcall、cdecl、pascal等，统一为一种新的fastcall调用方式。 这种调用方式得益于x64平台寄存器数量的增加。 　　 Windows x64平台fastcall调用约定的主要特性如下： 00. 前四个整型或指针类型参数由RCX、RDX、R8、R9依次传递，前四个浮点类型参数由XMM0、XMM1、XMM2、XMM3依次传递。 01. 调用函数为前四个参数在调用栈上保留相应的空间，称作shadow space或spill slot。       即使被调用方没有或小于4个参数，调用函数仍然保留那么多的栈空间，这有助于在某些特殊情况下简化调用约定。 02. 除前四个参数以外的任何其他参数通过栈来传递，从右至左依次入栈。 03. 由调用函数负责清理调用栈。[这是不同于x86下fastcall的地方，x86下的fastcall由被调用者清理栈] 04. 小于等于64位的整型或指针类型返回值由RAX传递。 05. 浮点返回值由XMM0传递。 06. 更大的返回值(比如结构体)，由调用方在栈上分配空间，并由RCX持有该空间的指针并传递给被调用函数，       因此整型参数使用的寄存器依次右移一格，实际只可以利用3个寄存器，其余参数入栈。函数调用结束后，RAX返回该空间的指针。 07. 除RCX,RDX,R8,R9以外，RAX、R10、R11、XMM0~XMM5也是易变化的(volatile)寄存器。 08. RBX, RBP, RDI, RSI, R12, R13, R14, R15和XMM6~XMM15寄存器则必须在使用时进行保护。 09. 在寄存器中，所有参数都是右对齐的。小于64位的参数并不进行高位零扩展，也就是高位是无法预测的垃圾数据。  The calling convention for C++ is very similar: the this pointer is passed as an implicit first parameter.  The next three parameters are passed in registers, while the rest are passed on the stack.  x64 provides a new rip-relative addressing mode. Instructions that refer to a single constant address are encoded as offsets from rip.  For example, the mov rax, [addr] instruction moves 8 bytes beginning at addr + rip to rax.  Linux、BSD和Mac OS X系统中的应用程序，会优先使用RDI、RSI、RDX、RCX、R8、R9这6个寄存器传递函数所需的前6个参数，然后使用数据栈传递其余的参数。 [/quote]  老哥你太稳了，不仅释疑，还这么细节，懂起了，等我再凑点分", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 6 楼 真相重于对错 的回复:1、用栈和用寄存器都可以达到传递参数的目的 2、c/c++只规定了语言部分，并没有规定实现部分。 3、__stdcall....这些只是微软 ,gun c/c++的厂家的自己实现。这些不是c/c++的标准的关键词。 4、如果用到寄存器，却发生中断，也没有问题，因为中断首先就要保存寄存器，中断结束后恢复寄存器。 5、我用vs看基本还是用栈。  gcc我看64位用的寄存器，32位用的栈。 我知道这不是语言的部分，但问题是，既然GCC自己规定了，为什么64位的时候它自己又不遵守了？", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 11 楼 突触 的回复:[quote=引用 4 楼 六道佩恩 的回复:][quote=引用 1 楼 突触 的回复:]大部分的调用约定都是用栈的，fastcall 会用寄存器不过参数多的话，也会用栈。  虽然寄存器运算快，但寄存器的数量是有限的，且大部分寄存器都有其特定的用途，当参数占用了寄存器，如果不通过内存空间存储的话，就没办法进行复杂的运算了。。。。。  看汇编，实际还是用的寄存器，没按调用约定来[/quote]  你说的是__cdecl 调用使用了寄存器传参吗       如果是64位的话会出现这种情况。 但32位 我没有遇到过这种情况你可以发张图片看看嘛  [/quote]  putchar的声明：  int __cdecl putchar(int _Ch);   代码：  \tint a='A'; \tputchar( a );   64位编译后的汇编：     0x000000000040153d <+13>:\tmov    DWORD PTR [rbp-0x4],0x41    0x0000000000401544 <+20>:\tmov    eax,DWORD PTR [rbp-0x4]    0x0000000000401547 <+23>:\tmov    ecx,eax    0x0000000000401549 <+25>:\tcall   0x402af8 <putchar>   32位：     0x0040150e <+14>:\tmov    DWORD PTR [esp+0x1c],0x41    0x00401516 <+22>:\tmov    eax,DWORD PTR [esp+0x1c]    0x0040151a <+26>:\tmov    DWORD PTR [esp],eax    0x0040151d <+29>:\tcall   0x4025f8 <putchar>  哦，这么看，32位确实用栈了（是吧？），不过为啥没用push？  看了下自定义的函数，32位的确实也用栈了，64位的则没有用栈", "referer": "user-0"}, {"cid": "14", "user": "user-2", "content": "看一下微软的新调用约定", "referer": "user-0"}, {"cid": "15", "user": "user-8", "content": "引用 楼主 六道佩恩 的回复:调试查看汇编是通过寄存器传的  但《程序员的自我修养》的“调用惯例”却只说了用栈，没有提用寄存器  连标了__cdecl的库函数，调用时都是通过寄存器的，为什么？不应该是通过栈吗？ x86上函数参数是压栈传递的，但使用时需要从栈上取出放入寄存器中，或用寄存器作为指针指向栈上的数据， 并没有使用寄存器传递参数，但不绝对，C++就使用了ecx传递了对象的this指针  x64中函数参数传递发生了改变 借PC处理器架构由x86向x64过渡之机，MS清理了Windows x64平台上的函数调用约定， 由原来的数种包括stdcall、thiscall、fastcall、cdecl、pascal等，统一为一种新的fastcall调用方式。 这种调用方式得益于x64平台寄存器数量的增加。 　　 Windows x64平台fastcall调用约定的主要特性如下： 00. 前四个整型或指针类型参数由RCX、RDX、R8、R9依次传递，前四个浮点类型参数由XMM0、XMM1、XMM2、XMM3依次传递。 01. 调用函数为前四个参数在调用栈上保留相应的空间，称作shadow space或spill slot。       即使被调用方没有或小于4个参数，调用函数仍然保留那么多的栈空间，这有助于在某些特殊情况下简化调用约定。 02. 除前四个参数以外的任何其他参数通过栈来传递，从右至左依次入栈。 03. 由调用函数负责清理调用栈。[这是不同于x86下fastcall的地方，x86下的fastcall由被调用者清理栈] 04. 小于等于64位的整型或指针类型返回值由RAX传递。 05. 浮点返回值由XMM0传递。 06. 更大的返回值(比如结构体)，由调用方在栈上分配空间，并由RCX持有该空间的指针并传递给被调用函数，       因此整型参数使用的寄存器依次右移一格，实际只可以利用3个寄存器，其余参数入栈。函数调用结束后，RAX返回该空间的指针。 07. 除RCX,RDX,R8,R9以外，RAX、R10、R11、XMM0~XMM5也是易变化的(volatile)寄存器。 08. RBX, RBP, RDI, RSI, R12, R13, R14, R15和XMM6~XMM15寄存器则必须在使用时进行保护。 09. 在寄存器中，所有参数都是右对齐的。小于64位的参数并不进行高位零扩展，也就是高位是无法预测的垃圾数据。  The calling convention for C++ is very similar: the this pointer is passed as an implicit first parameter.  The next three parameters are passed in registers, while the rest are passed on the stack.  x64 provides a new rip-relative addressing mode. Instructions that refer to a single constant address are encoded as offsets from rip.  For example, the mov rax, [addr] instruction moves 8 bytes beginning at addr + rip to rax.  Linux、BSD和Mac OS X系统中的应用程序，会优先使用RDI、RSI、RDX、RCX、R8、R9这6个寄存器传递函数所需的前6个参数，然后使用数据栈传递其余的参数。", "referer": "user-0"}, {"cid": "16", "user": "user-9", "content": "引用 4 楼 六道佩恩 的回复:[quote=引用 1 楼 突触 的回复:]大部分的调用约定都是用栈的，fastcall 会用寄存器不过参数多的话，也会用栈。  虽然寄存器运算快，但寄存器的数量是有限的，且大部分寄存器都有其特定的用途，当参数占用了寄存器，如果不通过内存空间存储的话，就没办法进行复杂的运算了。。。。。  看汇编，实际还是用的寄存器，没按调用约定来[/quote]  你说的是__cdecl 调用使用了寄存器传参吗       如果是64位的话会出现这种情况。 但32位 我没有遇到过这种情况你可以发张图片看看嘛", "referer": "user-0"}, {"cid": "17", "user": "user-4", "content": "1、用栈和用寄存器都可以达到传递参数的目的 2、c/c++只规定了语言部分，并没有规定实现部分。 3、__stdcall....这些只是微软 ,gun c/c++的厂家的自己实现。这些不是c/c++的标准的关键词。 4、如果用到寄存器，却发生中断，也没有问题，因为中断首先就要保存寄存器，中断结束后恢复寄存器。 5、我用vs看基本还是用栈。", "referer": "user-0"}, {"cid": "18", "user": "user-7", "content": "cdecl调用约定肯定是通过栈传参的", "referer": "user-0"}, {"cid": "19", "user": "user-7", "content": "cdecl调用约定肯定格式通过栈传参的。如果“连标了__cdecl的库函数，调用时都是通过寄存器的”,要么是inline了，要么你看错了", "referer": "user-0"}, {"cid": "20", "user": "user-0", "content": "引用 3 楼 forever74 的回复:x64里面通用寄存器比原来多了，够用了，不用白不用啊。  苹果M1又掀开了新的历史，以后的硬件会越来越个性，我们会越来越理解语言规范里留白的魅力。  用寄存器遇上中断咋办？用栈的话好歹是保存到内存的  主要是，它是标了__cdecl这类使用栈的调用约定的呀，如果不用的话，就不应该标呀，不至于编译器都改了，库的调用约定的实现也该了，但标称的__cdecl却不去掉或者更换？这不合理啊  32位和64位版都用的寄存器，不知道是不是检测了CPU型号才这样做的", "referer": "user-0"}]}
{"question": "【C语言求助】用指针实现数字从小到大输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 user-2的回复:q 这里记录的是数组的首地址，在for()循环里，p是往后走的，每循环一次p++一次，当第一轮内循环结束后，p就走到了数组的尾部地址了，我们需要它回到数组的首地址，然后重新开始新一轮的比较，以此类推。后面的输出语句前p=q，也是同样的道理。 嗷，原来是这样 谢谢啦！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "q 这里记录的是数组的首地址，在for()循环里，p是往后走的，每循环一次p++一次，当第一轮内循环结束后，p就走到了数组的尾部地址了，我们需要它回到数组的首地址，然后重新开始新一轮的比较，以此类推。后面的输出语句前p=q，也是同样的道理。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "搞错了，是p＝q", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考：#include <stdio.h> #include <math.h> void min_print(int *p,int n)//输入进来的是数组的储存地址 {     int tmp,i,j,*q=p; //------------------------------------------------ //  把数组的值从小到大赋给指针指向的值      for(i=0;i<n;i++)     {         p=q;         for(j=0;j<n-i-1;j++)//for(j=0;j<n-i;j++)         {             if(*p >= *(p+1))             {                 tmp=*p;                 *p=*(p+1);                 *(p+1)=tmp;                 //p++;             }                 //else if(*p<*(p+1))                 //{             p++;                 //}         }     }   // printf(\"%d %d %d %d %d\\n\",*p,*(p+1),*(p+2),*(p+3),*(p+4)); //------------------------------------------------     p=q;     for(i=0;i<n;i++)     {         printf(\"%d \",*p);         p++;     } } //------------------------------------------------ void main() {     //输入数字的数目     int n;     printf(\"Please enter the number of digits:\\n\");     scanf(\"%d\",&n);     //输入数组     int arr[n];       printf(\"Please enter %d numbers:\\n\",n);     for(int i=0;i<n;i++)     {         scanf(\"%d\",&arr[i]);     }     getchar();       //把数组的地址给p     int *p;     p=arr;     //     //printf(\"*(p+1)=%d\\n\",*(p+2));     min_print(p,n);      system(\"pause\"); }   //Please enter the number of digits: //5 //Please enter 5 numbers: //6 2 7 5 0 //0 2 5 6 7 请按任意键继续. . . 谢谢！ 请问为什么要有q＝p呢？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "供参考：#include <stdio.h> #include <math.h> void min_print(int *p,int n)//输入进来的是数组的储存地址 {     int tmp,i,j,*q=p; //------------------------------------------------ //  把数组的值从小到大赋给指针指向的值      for(i=0;i<n;i++)     {         p=q;         for(j=0;j<n-i-1;j++)//for(j=0;j<n-i;j++)         {             if(*p >= *(p+1))             {                 tmp=*p;                 *p=*(p+1);                 *(p+1)=tmp;                 //p++;             }                 //else if(*p<*(p+1))                 //{             p++;                 //}         }     }   // printf(\"%d %d %d %d %d\\n\",*p,*(p+1),*(p+2),*(p+3),*(p+4)); //------------------------------------------------     p=q;     for(i=0;i<n;i++)     {         printf(\"%d \",*p);         p++;     } } //------------------------------------------------ void main() {     //输入数字的数目     int n;     printf(\"Please enter the number of digits:\\n\");     scanf(\"%d\",&n);     //输入数组     int arr[n];       printf(\"Please enter %d numbers:\\n\",n);     for(int i=0;i<n;i++)     {         scanf(\"%d\",&arr[i]);     }     getchar();       //把数组的地址给p     int *p;     p=arr;     //     //printf(\"*(p+1)=%d\\n\",*(p+2));     min_print(p,n);      system(\"pause\"); }   //Please enter the number of digits: //5 //Please enter 5 numbers: //6 2 7 5 0 //0 2 5 6 7 请按任意键继续. . .", "referer": "user-0"}]}
{"question": "【求助】代码引发异常:读取访问权限冲突", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用//运行结果：   //input list a: //input number & scores of student: //if number is 0,stop inputing. //1,60 //4,80 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //3,90 //6,70 //0 //There are 4 records: //1 60 //3 90 //4 80 //6 70 //请按任意键继续. . .  某些测试数据没有排序", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "试验了下，结果如下，供参考：//链表a 和 链表b 应该都是顺序链表，不存在楼主输入倒序的问题，下面是两次运行的例子，第二次的存在问题.  //第一次输入：  //input list a: //input number & scores of student: //if number is 0,stop inputing. //3,78 //7,88 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //1,98 //5,76 //0 //There are 4 records: //1 98 //3 78 //5 76 //7 88 //请按任意键继续. . .   //第二次输入：  //input list a: //input number & scores of student: //if number is 0,stop inputing. //5,66 //9,88 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //1,76 //2,85 //0 //运行到这里就出错了。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 6 楼 Alonzo_11 的回复:那该怎么办呢 能自行解决吗 @user-1 建议先从分析清楚函数struct student* insert(struct student* ah, struct student* bh)里的判断逻辑开始，然后就你发现的问题，想想问题出在哪儿，试着去修改下，改错了也没关系，再把代码复制粘贴回去就是了，加油", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "那该怎么办呢 能自行解决吗 @user-1", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 4 楼 Alonzo_11 的回复:引用//运行结果：   //input list a: //input number & scores of student: //if number is 0,stop inputing. //1,60 //4,80 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //3,90 //6,70 //0 //There are 4 records: //1 60 //3 90 //4 80 //6 70 //请按任意键继续. . .  某些测试数据没有排序 对的，这个函数struct student* insert(struct student* ah, struct student* bh)，存在漏洞，有待完善，加油", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "改了没大问题了，可以运行，小细节上有待完善。供参考：//#include <bits/stdc++.h> #include <iostream.h> using namespace std; #define LEN sizeof(struct student)  struct  student {     long num;     int score;     struct student* next; };  struct student lista, listb; int n, sum = 0;  int main() {     struct student* creat(void);     struct student* insert(struct student*, struct student*);     void print(struct student*);     struct student* ahead, * bhead, * abh;     printf(\"input list a:\\n\");     ahead = creat();     sum = sum + n;     printf(\"input list b:\\n\");     bhead = creat();     sum = sum + n;     abh = insert(ahead, bhead);     print(abh);      system(\"pause\");     return 0; }  struct student* creat(void) {     struct student* p1, * p2, * head;     n = 0;     p1 = p2 = (struct student*)malloc(LEN);     printf(\"input number & scores of student:\\n\");     printf(\"if number is 0,stop inputing.\\n\");     scanf(\"%ld,%d\", &p1->num, &p1->score);//这里的输入格式是带','号的，英文半角     head = NULL;     while (p1->num != 0)     {         n = n + 1;         if (n == 1)             head = p2; //head = p1;         else             p2->next = p1;         p2 = p1;         p1 = (struct student*)malloc(LEN);         scanf(\"%ld,%d\", &p1->num, &p1->score);//这里的输入格式是带','号的，英文半角     }     p2->next = NULL;     return(head); }  struct student* insert(struct student* ah, struct student* bh) {     struct student* pa1, * pa2, * pb1, * pb2;     pa2 = pa1 = ah;     pb2 = pb1 = bh;     do     {         while ((pb1->num > pa1->num) && (pa1->next != NULL))  //!= nullptr))         {             pa2 = pa1;             pa1 = pa1->next;         }         if (pb1->num <= pa1->num)         {             if (ah == pa1)                 ah = pb1;             else                 pa2->next = pb1;             pb1 = pb1->next;             pb2->next = pa1;             pa2 = pb2;             pb2 = pb1;         }     } while ((pa1->next != NULL) || (pa1 == NULL && pb1 != NULL));     if ((pb1 != NULL) && (pb1->num > pa1->num) && (pa1->next == NULL))         pa1->next = pb1;     return(ah); }  void print(struct student* head) {     struct student* p;     printf(\"There are %d records:  \\n\", sum);     p = head;     if (p != NULL)         do         {             printf(\"%ld %d\\n\", p->num, p->score);             p = p->next;         } while (p != NULL); }   //运行结果：  //input list a: //input number & scores of student: //if number is 0,stop inputing. //1,60 //4,80 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //3,90 //6,70 //0 //There are 4 records: //1 60 //3 90 //4 80 //6 70 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "改了还是一样的情况o", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "while ((pb1->num > pa1->num) && (pa1->next != nullptr))改为：while ((pb1->num > pa1->num) && (pa1->next != NULL ))", "referer": "user-0"}]}
{"question": "大佬们帮忙看下哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h>  #define OVERLOW -2 #define ERROR 0 #define OK 1  typedef int Status; typedef float QElemType;  typedef struct QLNode{     QElemType data;     struct QLNode *next; }QLNode, *QueuePtr; typedef struct {     QueuePtr front;     QueuePtr rear; }LinkQueue;  //创建空队列 Status InitQueue(LinkQueue &Q) {     /*     Q.front = Q.rear = (QueuePtr)malloc(sizeof(QLNode));     if(!Q.front)     {         exit(OVERLOW);     }      //Q.front = NULL;     Q.front->next = NULL;     */     Q.front = Q.rear = NULL;     return OK; } Status ClearQueue(LinkQueue &Q); //销毁队列 Status DestoryQueue(LinkQueue &Q) {     ClearQueue(Q);     /*     while(Q.front)     {         Q.rear = Q.front->next;         free(Q.rear);         Q.front = Q.rear;     }     */     return OK; } //插入元素e为Q的新的队尾元素 Status EnQueue(LinkQueue &Q, QElemType e) {     QueuePtr p;     printf(\"请输入e的值\\n\");     scanf(\"%f\", &e);     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     p->data = e;     p->next = NULL;      if (Q.rear == NULL) {         Q.rear = Q.front = p;     } else {         Q.rear->next = p;         Q.rear = p;     }     /*     p->data = e;     p->next =NULL;     Q.rear->next = p;     Q.rear = p;     */     return OK; } //删除Q的对头元素，用e带回 Status DeQueue(LinkQueue &Q, QElemType &e) {     QueuePtr p;      if (Q.front == NULL)         return ERROR;      if (Q.front == Q.rear) {         e = Q.front->data;         p = Q.front;         Q.front = Q.rear = NULL;         free(p);         return OK;     }     e = Q.front->data;     p = Q.front;      Q.front = Q.front->next;     free(p);     return OK;      /*     QueuePtr p;     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     if(Q.front == Q.rear)     {         return ERROR;     }     p = Q.front->next;     e = p->data;     Q.front->next = p->next;     if (p == Q.rear) //当删除最后一个元素时，尾指针可能没有指向     {         Q.rear = Q.front;     }     free(p);     */     return OK; } //清空队列 Status ClearQueue(LinkQueue &Q) {     QueuePtr p, q;      p = Q.front;      while (p) {         q = p->next;         free(p);         p = q;     }     Q.front = Q.rear = NULL;      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     while(!Q.rear)     {         p = Q.front->next;         Q.front->next = p->next;         free(p);     }     Q.rear = Q.front;     */     return OK; } //计算队列的长度 Status QueueLength(LinkQueue Q) {     QueuePtr p;     int i = 0;      p = Q.front;      while (p) {         i++;         p = p->next;     }      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     Status i = 1;     p = Q.front->next;     while(p != Q.rear)     {         p = p->next;         i++;     }     */     return i; } //用e返回Q的头部元素 Status GetHead(LinkQueue Q, QElemType &e) {     if (!Q.front)         return ERROR;      e = Q.front->data;     /*     if(Q.front == Q.rear)     {         return ERROR;     }     e = Q.front->next->data;     */     return OK; }  //显示队列 Status VisitQueue(LinkQueue Q) {     QueuePtr p;      p = Q.front;      while (p) {         printf(\"%.1f \", p->data);         p = p->next;     }     printf(\"\\n\");      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     p = Q.front->next;     while(p != Q.rear->next)     {         printf(\"%f\", p->data);         p = p->next;     }     */     return 0; } int main() {     LinkQueue Q;     QElemType e;     Status flag;     int len;     while(1)     {         printf(\"****************************\\n\");         printf(\"********队列操作系统********\\n\");         printf(\"1.创建空队列                \\n\");         printf(\"2.插入元素e为Q的新的队尾元素\\n\");         printf(\"3.删除Q的对头元素，用e带回  \\n\");         printf(\"4.清空队列                  \\n\");         printf(\"5.计算队列的长度            \\n\");         printf(\"6.用e返回Q的头部元素        \\n\");         printf(\"7.显示队列                  \\n\");         printf(\"8.销毁队列                  \\n\");         printf(\"请选择功能序号：\\n\");         scanf(\"%d\", &flag);         switch(flag)         {             case 1: InitQueue(Q);                     break;             case 2: EnQueue(Q, e);                     break;             case 3: DeQueue(Q, e);                     break;             case 4: ClearQueue(Q);                     break;             case 5: len = QueueLength(Q);                     printf(\"Queue's length: %d\\n\", len);                     break;             case 6: GetHead(Q, e);                     printf(\"head data: %.1f\\n\", e);                     break;             case 7: VisitQueue(Q);                     break;             case 8: DestoryQueue(Q);                     break;         }//switch     }//while     return OK; }  供参考～  除了代码问题之外，架构设计的也有点问题，初始化队列，不应该放在选择项里，而是放在进入循环之前的操作； 清除队列和销毁队列其实是一个意思～ 谢谢，我是大一学生，术语懂得不多，谢大佬指点", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h>  #define OVERLOW -2 #define ERROR 0 #define OK 1  typedef int Status; typedef float QElemType;  typedef struct QLNode{     QElemType data;     struct QLNode *next; }QLNode, *QueuePtr; typedef struct {     QueuePtr front;     QueuePtr rear; }LinkQueue;  //创建空队列 Status InitQueue(LinkQueue &Q) {     /*     Q.front = Q.rear = (QueuePtr)malloc(sizeof(QLNode));     if(!Q.front)     {         exit(OVERLOW);     }      //Q.front = NULL;     Q.front->next = NULL;     */     Q.front = Q.rear = NULL;     return OK; } Status ClearQueue(LinkQueue &Q); //销毁队列 Status DestoryQueue(LinkQueue &Q) {     ClearQueue(Q);     /*     while(Q.front)     {         Q.rear = Q.front->next;         free(Q.rear);         Q.front = Q.rear;     }     */     return OK; } //插入元素e为Q的新的队尾元素 Status EnQueue(LinkQueue &Q, QElemType e) {     QueuePtr p;     printf(\"请输入e的值\\n\");     scanf(\"%f\", &e);     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     p->data = e;     p->next = NULL;      if (Q.rear == NULL) {         Q.rear = Q.front = p;     } else {         Q.rear->next = p;         Q.rear = p;     }     /*     p->data = e;     p->next =NULL;     Q.rear->next = p;     Q.rear = p;     */     return OK; } //删除Q的对头元素，用e带回 Status DeQueue(LinkQueue &Q, QElemType &e) {     QueuePtr p;      if (Q.front == NULL)         return ERROR;      if (Q.front == Q.rear) {         e = Q.front->data;         p = Q.front;         Q.front = Q.rear = NULL;         free(p);         return OK;     }     e = Q.front->data;     p = Q.front;      Q.front = Q.front->next;     free(p);     return OK;      /*     QueuePtr p;     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     if(Q.front == Q.rear)     {         return ERROR;     }     p = Q.front->next;     e = p->data;     Q.front->next = p->next;     if (p == Q.rear) //当删除最后一个元素时，尾指针可能没有指向     {         Q.rear = Q.front;     }     free(p);     */     return OK; } //清空队列 Status ClearQueue(LinkQueue &Q) {     QueuePtr p, q;      p = Q.front;      while (p) {         q = p->next;         free(p);         p = q;     }     Q.front = Q.rear = NULL;      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     while(!Q.rear)     {         p = Q.front->next;         Q.front->next = p->next;         free(p);     }     Q.rear = Q.front;     */     return OK; } //计算队列的长度 Status QueueLength(LinkQueue Q) {     QueuePtr p;     int i = 0;      p = Q.front;      while (p) {         i++;         p = p->next;     }      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     Status i = 1;     p = Q.front->next;     while(p != Q.rear)     {         p = p->next;         i++;     }     */     return i; } //用e返回Q的头部元素 Status GetHead(LinkQueue Q, QElemType &e) {     if (!Q.front)         return ERROR;      e = Q.front->data;     /*     if(Q.front == Q.rear)     {         return ERROR;     }     e = Q.front->next->data;     */     return OK; }  //显示队列 Status VisitQueue(LinkQueue Q) {     QueuePtr p;      p = Q.front;      while (p) {         printf(\"%.1f \", p->data);         p = p->next;     }     printf(\"\\n\");      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     p = Q.front->next;     while(p != Q.rear->next)     {         printf(\"%f\", p->data);         p = p->next;     }     */     return 0; } int main() {     LinkQueue Q;     QElemType e;     Status flag;     int len;     while(1)     {         printf(\"****************************\\n\");         printf(\"********队列操作系统********\\n\");         printf(\"1.创建空队列                \\n\");         printf(\"2.插入元素e为Q的新的队尾元素\\n\");         printf(\"3.删除Q的对头元素，用e带回  \\n\");         printf(\"4.清空队列                  \\n\");         printf(\"5.计算队列的长度            \\n\");         printf(\"6.用e返回Q的头部元素        \\n\");         printf(\"7.显示队列                  \\n\");         printf(\"8.销毁队列                  \\n\");         printf(\"请选择功能序号：\\n\");         scanf(\"%d\", &flag);         switch(flag)         {             case 1: InitQueue(Q);                     break;             case 2: EnQueue(Q, e);                     break;             case 3: DeQueue(Q, e);                     break;             case 4: ClearQueue(Q);                     break;             case 5: len = QueueLength(Q);                     printf(\"Queue's length: %d\\n\", len);                     break;             case 6: GetHead(Q, e);                     printf(\"head data: %.1f\\n\", e);                     break;             case 7: VisitQueue(Q);                     break;             case 8: DestoryQueue(Q);                     break;         }//switch     }//while     return OK; }  供参考～  除了代码问题之外，架构设计的也有点问题，初始化队列，不应该放在选择项里，而是放在进入循环之前的操作； 清除队列和销毁队列其实是一个意思～", "referer": "user-0"}]}
{"question": "C语言求余弦函数的近似值中精度高不可直接计算阶乘的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "再供参考：#include <iostream> #include <string> using namespace std; inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string SUB_INT(string str1,string str2); string ADD_INT(string str1,string str2) {//高精度加法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         if (str2[0]=='-') {             sign=-1;             str=ADD_INT(str1.erase(0,1),str2.erase(0,1));         } else {             str=SUB_INT(str2,str1.erase(0,1));         }     } else {         if (str2[0]=='-') {             str=SUB_INT(str1,str2.erase(0,1));         } else { //把两个整数对齐，短整数前面加0补齐             string::size_type L1,L2;             int i;             L1=str1.size();             L2=str2.size();             if (L1<L2) {                 for (i=1;i<=L2-L1;i++) str1=\"0\"+str1;             } else {                 for (i=1;i<=L1-L2;i++) str2=\"0\"+str2;             }             int int1=0,int2=0; //int2 记录进位             for (i=str1.size()-1;i>=0;i--) {                 int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;                 int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;                 str=char(int1+'0')+str;             }             if (int2!=0) str=char(int2+'0')+str;         }     }     //运算后处理符号位     if ((sign==-1)&&(str[0]!='0')) str=\"-\"+str;     return str; } string SUB_INT(string str1,string str2) {//高精度减法     int sign=1; //sign 为符号位     string str;     int i,j;     if (str2[0]=='-') {         str=ADD_INT(str1,str2.erase(0,1));     } else {         int res=compare(str1,str2);         if (res==0) return \"0\";         if (res<0) {             sign=-1;             string temp =str1;             str1=str2;             str2=temp;         }         string::size_type tempint;         tempint=str1.size()-str2.size();         for (i=str2.size()-1;i>=0;i--) {             if (str1[i+tempint]<str2[i]) {                 j=1;                 while (1) {//zhao4zhong1添加                     if (str1[i+tempint-j]=='0') {                         str1[i+tempint-j]='9';                         j++;                     } else {                         str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);                         break;                     }                 }                 str=char(str1[i+tempint]-str2[i]+':')+str;             } else {                 str=char(str1[i+tempint]-str2[i]+'0')+str;             }         }         for (i=tempint-1;i>=0;i--) str=str1[i]+str;     }     //去除结果中多余的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str=\"0\";     if ((sign==-1) && (str[0]!='0')) str =\"-\"+str;     return str; } string MUL_INT(string str1,string str2) {//高精度乘法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         sign*=-1;         str1 =str1.erase(0,1);     }     if (str2[0]=='-') {         sign*=-1;         str2 =str2.erase(0,1);     }     int i,j;     string::size_type L1,L2;     L1=str1.size();     L2=str2.size();     for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式         string tempstr;         int int1=0,int2=0,int3=int(str2[i])-'0';         if (int3!=0) {             for (j=1;j<=(int)(L2-1-i);j++) tempstr=\"0\"+tempstr;             for (j=L1-1;j>=0;j--) {                 int1=(int3*(int(str1[j])-'0')+int2)%10;                 int2=(int3*(int(str1[j])-'0')+int2)/10;                 tempstr=char(int1+'0')+tempstr;             }             if (int2!=0) tempstr=char(int2+'0')+tempstr;         }         str=ADD_INT(str,tempstr);     }     //去除结果中的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str=\"0\";     if ((sign==-1) && (str[0]!='0')) str=\"-\"+str;     return str; } string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数     string quotient,residue; //定义商和余数     int sign1=1,sign2=1;     if (str2 == \"0\") {  //判断除数是否为0         quotient= \"ERROR!\";         residue = \"ERROR!\";         if (flag==1) return quotient;         else         return residue ;     }     if (str1==\"0\") { //判断被除数是否为0         quotient=\"0\";         residue =\"0\";     }     if (str1[0]=='-') {         str1   = str1.erase(0,1);         sign1 *= -1;         sign2  = -1;     }     if (str2[0]=='-') {         str2   = str2.erase(0,1);         sign1 *= -1;     }     int res=compare(str1,str2);     if (res<0) {         quotient=\"0\";         residue =str1;     } else if (res == 0) {         quotient=\"1\";         residue =\"0\";     } else {         string::size_type L1,L2;         L1=str1.size();         L2=str2.size();         string tempstr;         tempstr.append(str1,0,L2-1);         for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式             tempstr=tempstr+str1[i];             tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加             if (tempstr.empty()) tempstr=\"0\";//zhao4zhong1添加             for (char ch='9';ch>='0';ch--) { //试商                 string str;                 str=str+ch;                 if (compare(MUL_INT(str2,str),tempstr)<=0) {                     quotient=quotient+ch;                     tempstr =SUB_INT(tempstr,MUL_INT(str2,str));                     break;                 }             }         }         residue=tempstr;     }     //去除结果中的前导0     quotient.erase(0,quotient.find_first_not_of('0'));     if (quotient.empty()) quotient=\"0\";     if ((sign1==-1)&&(quotient[0]!='0')) quotient=\"-\"+quotient;     if ((sign2==-1)&&(residue [0]!='0')) residue =\"-\"+residue ;     if (flag==1) return quotient;     else         return residue ; } string DIV_INT(string str1,string str2) {//高精度除法,返回商     return DIVIDE_INT(str1,str2,1); } string MOD_INT(string str1,string str2) {//高精度除法,返回余数     return DIVIDE_INT(str1,str2,0); } int main() {     char ch;     string s1,s2,res;      while (cin>>s1>>ch>>s2) {         switch (ch) {             case '+':res=ADD_INT(s1,s2);break;             case '-':res=SUB_INT(s1,s2);break;             case '*':res=MUL_INT(s1,s2);break;             case '/':res=DIV_INT(s1,s2);break;             case '%':res=MOD_INT(s1,s2);break;             default :                   break;         }         cout<<res<<endl;     }     return(0); }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "仅供参考：#include <iostream> #include <string> #include <algorithm> using namespace std; inline int COMPARE(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string PLUS(string number1,string number2) {     int i;     int length1 = number1.size();     int length2 = number2.size();      string result=\"\";      reverse(number1.begin(), number1.end());     reverse(number2.begin(), number2.end());      for(i = 0; i < length1 && i < length2; i++) {         char c = (char)(number1[i] + number2[i] - 48);         result = result + c;     }      while(i < length1) {         result = result + number1[i];         ++i;     }      while(i < length2) {         result = result + number2[i];         ++i;     }      int carry = 0;     for(i = 0; i < (int)result.size(); ++i) {         int value = result[i] - 48 + carry;         result[i] = (char)(value % 10 + 48);         carry = value / 10;     }      if(carry !=0 ) {         result = result + (char)(carry + 48);     }      for(i = result.size() - 1; i >= 0; i--) {         if(result[i] != '0') break;     }      result = result.substr(0, i + 1);      reverse(result.begin(), result.end());     if(result.length() == 0) result = \"0\";     return result; } string MULTIPLY(string number1, string number2) {     int i, j;     int *iresult;     int length1 = number1.size();     int length2 = number2.size();     string result = \"\";      reverse(number1.begin(), number1.end());     reverse(number2.begin(), number2.end());      iresult = (int*)malloc(sizeof(int) * (length1 + length2 + 1));     memset(iresult, 0, sizeof(int) * (length1 + length2 + 1));      for(i = 0; i < length1; i++) {         for(j = 0; j < length2; j++) {             iresult[i+j] += ((number1[i] - 48) * (number2[j] - 48));         }     }      int carry = 0;     for(i = 0; i < length1 + length2; i++) {         int value = iresult[i] + carry;         iresult[i] = value % 10;         carry = value / 10;     }      for(i = length1 + length2 - 1; i >= 0; i--) {         if(iresult[i] != 0)break;     }      for(; i >= 0; i--) {         result = result + (char)(iresult[i]+48);     }      free(iresult);      if(result == \"\") result = \"0\";     return result; } string factorial(string n) {     string temp = \"1\";     string i;     for(i = \"1\"; COMPARE(i, n) <= 0; i = PLUS(i, \"1\")) {         temp = MULTIPLY(temp, i);     }     return temp; } int main(void) {     cout << factorial(\"100\") << endl;     return 0; } //93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 //", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "求阶乘函数里，int n 类型不对，改double型，int型最大值为：2147483647。当精度取0.01 时，n*fact(n-1)=12! , 0.001时14！，0.0001时16！，当13!的时候已经超出n的范围，", "referer": "user-0"}]}
{"question": "麻烦哪位大神和我说说下面给我的警告是啥意思？为啥我感觉用着也没问题呀？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "声明了全局静态数组a[]，却没有给出大小，程序不出错是你的运气。如果你声明了其它静态变量，由于a[]没有给出大小，在scanf向a放入输入字符串的时候，会覆盖其它静态变量，程序必然出错！概念要清晰！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 forever74 的回复:1、作为一维数组名，a和&a表示的地址值相同是必然的，不是偶然。但更重要的是它们还有区别，位于白马背上的不一定都是猴子的师傅。 2、字符串，是特定的语法概念，其实体结构，开始于某个首地址，结束于码值为0的字符。用首地址表示，同时其语法意义也多半是其首地址。可以放进字符数组这个容器，也可以不放。 字符数组是每个元素占用1字节的数组，可以用来存放字符串也可以用来存放不是字符串的东西。 3、见上，%s引用首地址，打印字符串。碰巧该字符串放在字符数组里，看着好像打印字符数组了。 谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 6 楼 user-3 的回复:在CSDN论坛里搜下\"字符数组和字符串的区别和联系\". scanf()函数用法，参考下：https://blog.csdn.net/luxuejuncarl/article/details/1576513   谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "1、作为一维数组名，a和&a表示的地址值相同是必然的，不是偶然。但更重要的是它们还有区别，位于白马背上的不一定都是猴子的师傅。 2、字符串，是特定的语法概念，其实体结构，开始于某个首地址，结束于码值为0的字符。用首地址表示，同时其语法意义也多半是其首地址。可以放进字符数组这个容器，也可以不放。 字符数组是每个元素占用1字节的数组，可以用来存放字符串也可以用来存放不是字符串的东西。 3、见上，%s引用首地址，打印字符串。碰巧该字符串放在字符数组里，看着好像打印字符数组了。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "在CSDN论坛里搜下\"字符数组和字符串的区别和联系\". scanf()函数用法，参考下：https://blog.csdn.net/luxuejuncarl/article/details/1576513", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 forever74的回复:其一，scanf里面第二个参数应该是a，而不是&a。没表现出问题是因为它俩的“值”都是同样的地址值。但是它们的类型不同，乱用是一个很粗浅的错误。 其二，a没有给出长度，未初始化的数组又不给出长度，这应该是个error才对。 兄台我还有三个问题： 1、&a 和a地址值相同是不是一种偶然？ 2、字符数组和字符串有何区别？ 3、以%s格式地址是字符数组首地址，居然能打印出整个字符数组，这是神马情况？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 user-3的回复:给数组a指定一个长度，如char a[32]. 必须要指定长度吗", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "这两个问题都不能忽视，不要因为没看出后果就不以为然。 此处省略因措辞严厉而引起读者不适的一百五十字。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "其一，scanf里面第二个参数应该是a，而不是&a。没表现出问题是因为它俩的“值”都是同样的地址值。但是它们的类型不同，乱用是一个很粗浅的错误。 其二，a没有给出长度，未初始化的数组又不给出长度，这应该是个error才对。", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "给数组a指定一个长度，如char a[32].", "referer": "user-0"}]}
{"question": "大佬们求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h>  int main() {     int a=3,b=7,c=5;      //switch(a>0)     switch(a)     {         //case 1:swith(b<0)         case 1:switch(b)                {                    case 1:printf(\"@\");break;                    case 2:printf(\"!\");break;                }                break;   //add break         //case 0:switch(c==5)         case 0:switch(c)                {                    case 0:printf(\"*\");break;                    case 1:printf(\"#\");break;                    case 2:printf(\"$\");break;                }                break;//add break         default:                printf(\"&\");     }     printf(\"\\n\");      return 0; }  供参考～  switch注意拼写，别少了c字母  switch()括号里的是一个整型数表达式，不是判断表达式；  如果用a >0，那么下面的case用两个就好了case 0, case 1因为只有两种结果。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "case 1:swith(b<0)这句，switch,供参考：#include<stdio.h> int main() {    int a=3,b=7,c=5;    switch(a>0)    {            case 1:switch(b<0) //case 1:swith(b<0)                  {                    case 1:printf(\"@\");break;                    case 2:printf(\"!\");break;                  }            //break; 这里是否缺了break            case 0:switch(c==5)                 {                    case 0:printf(\"*\");break;                    case 1:printf(\"#\");break;                    case 2:printf(\"$\");break;                 }            //break; 这里是否缺了break            default:printf(\"&\");    }    printf(\"\\n\");        return 0; }  //#& //请按任意键继续. . .", "referer": "user-0"}]}
{"question": "求助： C程序 延迟中途如何响应按键？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://blog.csdn.net/fbysss/article/details/2412485 参考这个博客，只要 getch 不阻塞，你就可以sleep 后判断时间，来决定要不要继续循环了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 4 楼 proof1 的回复:[quote=引用 2 楼 forever74 的回复:]变通嘛，不要延迟5分钟，做延迟1秒的，然后做个变量计数，转300次再刷字符串。 在300次中，读取键盘状态并相应处理？[/quote] 还是这个循环，你原来怎么处理按键，之后自然还是怎么处理。 仅仅是缩短延迟时间，增加一个计数变量，多一两个if", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不是中断处理的吗？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 forever74 的回复:变通嘛，不要延迟5分钟，做延迟1秒的，然后做个变量计数，转300次再刷字符串。 在300次中，读取键盘状态并相应处理？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "弃用sleep() ， delay()  循环获取时间，比较时间，同时读取按键状态？", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "变通嘛，不要延迟5分钟，做延迟1秒的，然后做个变量计数，转300次再刷字符串。", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "开个定时器计算没有按键按下的时间咯，如有按键按下，那时间重新计算，如果累计5Min没有按键按下更改显示咯", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "为什么不用系统 API，监听案件事件？", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "参考：while (1){  　  sleep(1秒)  计数器+1     读按键 随时响应按键（有按键就退出） 　　if (计数器＝300)  { 　　　　清除字符串 　　　　更改屏幕坐标 　　　　显示字符串 　　　　计数器＝0 　　} }", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "------------------------------- while (结束标志)  { 　　显示字符串 　　for (i=1; i<=300; i++) 　　　　if  (没有按键)  　　　　　　sleep(1秒) 　　　　else 　　　　　　置结束标志 　　清除字符串 　　更改屏幕坐标 } -------------------------------  ？？？ 有些冗长。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 6 楼 forever74 的回复:还是这个循环，你原来怎么处理按键，之后自然还是怎么处理。 仅仅是缩短延迟时间，增加一个计数变量，多一两个if  ------------------------------- while (没有按键)  { 　　sleep(1秒) 　　计数器+1 　　if  (计数器＝300)  { 　　　　清除字符串 　　　　更改屏幕坐标 　　　　显示字符串 　　　　计数器＝0 　　} } -------------------------------  是这样？", "referer": "user-0"}]}
{"question": "来个大佬帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <iostream> //#include \"Linklist.h\"  #include <iostream> #include <stdio.h>  using namespace std;  #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0  #ifndef EOF #define EOF -1 #endif  #define MAXSiZE 100  typedef int Elemtype; typedef int Status;  //结点 typedef struct Lnode {     Elemtype date;     struct Lnode* next; }Lnode, * Link;   //控制结构 typedef struct link {     Link head, tail;     int len;     int isnotInit; }link;   //初始化 Status Init_Linklist(link& L) {     L.head = L.tail = new Lnode[1];     if (!L.head) { return ERROR; }     //头结点数据域不存数据     L.head->next = NULL;     L.len = 0;     L.isnotInit = 1;      return OK; }  //插入 Status Insert_Linklist(link& L, int i, Elemtype e) {     int j;     Link p, q;     q = p = L.head;     if (L.isnotInit != 1) { return ERROR; }     if (i<1 || i>L.len + 1) { return ERROR; }     if (i != L.len + 1)     {         for (j = 1; j < i; j++) { p = p->next; }//for(j=0;j<i-1;j++),第i-1个结点         q = new Lnode[1];         q->date = e;         q->next = p->next;         p->next = q;         L.tail = q; //Update tail     }     if (i == L.len + 1) {         q = new Lnode[1];         q->date = e;         q->next = L.tail->next;         L.tail->next = q;         L.tail = q;     }//插入在链尾     L.len++;      return OK; }  //删除 Status Delete_Linklist(link& L, int i, Elemtype& e) {     int j;     Link p, q;     p = L.head;     if (L.isnotInit != 1) { return ERROR; }     //if (i < 1 || i < L.len) { return ERROR; }     if (i < 1 || i > L.len) { return ERROR; }      for (j = 1; j < i; j++)         p = p->next;     q = p->next;     e = q->date;     p->next = q->next;     free(q);     /*     if (i != L.len)     {         for (j = 1; j < i; j++) { p = p->next; }         q = p->next;         e = q->date;//保存结点数据         p->next = q->next;         delete[] q;     }     if (i == L.len) {         L.tail = p;     }     */     L.len--;     return OK; }  //按值查找 #if(1) int Locate_Linklist(link L, Elemtype e) {     int i = 1;     if (L.isnotInit != 1) { return ERROR; }     Lnode* p = L.head->next;//第一个结点     while (p != NULL && p->date != e)     {         p = p->next;         i++;     }     //if (p->date == e){return i;}     if (p && p->date == e){return i;}     else     {         cout << \"The key is not fine!\" << endl;         return -1;//NULL;     }      return -1; } #endif  #if(0) Lnode* Locate_Linklist(link L, Elemtype key) {     Lnode* p = L.head->next;     while (p != NULL && p->date == key) { p = p->next; }     if (p->date == key) { return p; }     else     {         cout << \"The key is not fine\" << endl;         return NULL;     } } #endif  Status Get_Linklist(link& L, int a, Elemtype& key) {     if (L.isnotInit != 1) { return ERROR; }      Lnode* p = L.head->next;     while (p != NULL && p->date == a) { p = p->next; }     //if (p->date == key) { key = a; }     if (p && p->date == a) { key = a; return OK;}     else     {         cout << \"The key is not fine\" << endl;         return -1;//NULL;     }      return -1; }  //位置查找 Status Seek_Linklist(link L, int i, Elemtype e) {     if (L.isnotInit != 1) { return ERROR; }     Lnode* p = L.head->next;     //for (int j = 0; j < i - 1; j++) {p = p->next;}     for (int j = 0; j < i - 1 && p; j++) {p = p->next;}     if (!p)         return ERROR;      e = p->date;     return e; }  //位置改值 Status Change_Linklist(link& L, int i, Elemtype& e) {     int j;     if (L.isnotInit != 1) { return ERROR; }     Lnode* p = L.head;     if (i<1 || i>L.len) { return ERROR; }     for (j = 0; j < i - 1; j++) { p = p->next; }     p->date = e;     return OK; }  void Traver_Linklist(link L) {     Lnode* p;     if (!L.head)         return;      p = L.head->next;     while (p)     {         cout << p->date << \"\\t\";         p = p->next;     }     cout<<endl; }  int main() {     int l;     link L;     Elemtype e;     //cout << Init_Linklist(L) << endl;     Init_Linklist(L);      for (int i = 0; i < 10; i++)     {         cin >> e;         Insert_Linklist(L, 1, e);     }     Traver_Linklist(L);     cout << endl;      int n1;     cout << \"删除第几个位置:\" << \" \";     cin >> n1;     Delete_Linklist(L, n1, e);     Traver_Linklist(L);     cout << endl;      int n2;     cin >> e;     n2 = Locate_Linklist(L, e);     Traver_Linklist(L);     cout <<n2<< endl;      int n3;     cin>>n3;     Get_Linklist(L, n3, e);     Traver_Linklist(L);     cout <<e<< endl;      int n4, a;     cin >> e;     a = Seek_Linklist(L, n4, e);     Traver_Linklist(L);     cout << endl;      int n5;     cin >> e>>n5;     Change_Linklist(L, n5, e);     Traver_Linklist(L);     cout << endl;      return 0; } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "改什么呢？要改成什么样子？", "referer": "user-0"}]}
{"question": "comparison between pointer and integer这个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "i +=strlen(remain_text[index][0]);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "remain_tex这个是怎么定义的？建议提供更多信息吧  remain_tex的类型是不是是int类型？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "题目所述疑似不是这行的问题， 而这行正确与否取决于数组的定义。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "i +=strlen (remain _text [index]);", "referer": "user-0"}]}
{"question": "求一个C语言字符串中运算符相关的题的解法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "或者就像第一句一样加std::cout试看是否还有问题？另外注意看认真看，最后一个else;是有冒号的。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "可把前面的输出全部取消，最后输出替换为C语言的，不该连输入输出都不会！  https://z3.ax1x.com/2021/04/05/cQGMjK.png", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这个前面的代码是什么，就直接建立工程给的初始代码吗，我看的时候中间倒数第二个else总是报错，而且cout<<  <<ends;的时候也是报错 引用 3 楼 智者知已应修善业 的回复:[img=https://img-bbs.csdn.net/upload/202104/03/1617442385_516357.png\" alt=\"\" />   引用 7 楼 智者知已应修善业 的回复:花括号自己添加应该会，输入输出自己也该会。ends用“ ”替代。   https://z3.ax1x.com/2021/04/05/cQGMjK.png", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "花括号自己添加应该会，输入输出自己也该会。ends用“ ”替代。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "发出你的代码看看 引用 4 楼 binv 的回复:这个前面的代码是什么，就直接建立工程给的初始代码吗，我看的时候中间倒数第二个else总是报错，而且cout<<  <<ends;的时候也是报错", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "这个前面的代码是什么，就直接建立工程给的初始代码吗，我看的时候中间倒数第二个else总是报错，而且cout<<  <<ends;的时候也是报错 引用 3 楼 智者知已应修善业 的回复:[img=https://img-bbs.csdn.net/upload/202104/03/1617442385_516357.png\" alt=\"\" />", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "这个前面的代码是什么，就直接建立工程给的初始代码吗，我看的时候中间倒数第二个else总是报错，而且cout<<  <<ends;的时候也是报错", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "前四位，前三位啥意思？", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "先自己写写吧，不懂得再提出来呗。这个应该不难～", "referer": "user-0"}]}
{"question": "求代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "求一个矩阵快速比较阙值转换成二值化的 算法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "void photo_get() { \tint num = 0; \tfor(num = 0;num < MT9V03X_H;num++) \t{ \t\tmemcpy(dis_image[num],mt9v03x_image[num],MT9V03X_W);//原始数据为mt9v03x_image  结果memcpy  复制到dis_image \t}\t } //以下是大津法  计算得到dis_image 图片的阙值 阙值输出为  threshold  uint8 threshold = 0;  void my_adapt_threshold(uint8 *image, uint16 col, uint16 row)   {    #define GrayScale 256     uint16 width = col;     uint16 height = row;     int pixelCount[GrayScale];     float pixelPro[GrayScale];     int i, j, pixelSum = width * height/4;     uint8* data = image;  //?????????     for (i = 0; i < GrayScale; i++)     {         pixelCount[i] = 0;         pixelPro[i] = 0;     }          uint32 gray_sum=0;           for (i = 0; i < height; i+=2)     {         for (j = 0; j < width; j+=2)         {             pixelCount[(int)data[i * width + j]]++;               gray_sum+=(int)data[i * width + j];                }     }                                     for (i = 0; i < GrayScale; i++)     {         pixelPro[i] = (float)pixelCount[i] / pixelSum;              }           float w0, w1, u0tmp, u1tmp, u0, u1, u, deltaTmp, deltaMax = 0;                             w0 = w1 = u0tmp = u1tmp = u0 = u1 = u = deltaTmp = 0;         for (j = 0; j < GrayScale; j++)                  {                              w0 += pixelPro[j];                   u0tmp += j * pixelPro[j];                              w1=1-w0;                u1tmp=gray_sum/pixelSum-u0tmp;                          u0 = u0tmp / w0;                               u1 = u1tmp / w1;                              u = u0tmp + u1tmp;                             deltaTmp = w0 * pow((u0 - u), 2) + w1 * pow((u1 - u), 2);                 if (deltaTmp > deltaMax)                 {                     deltaMax = deltaTmp;                     threshold = j;                 }                 if (deltaTmp < deltaMax)                 {                 break;                 }                     } //  for(i = 0; i < threshold; i++) //\t{ //\t\tBin_Array[i] = 0; //\t} //\tfor(i = threshold; i < 256; i++) //\t{ //\t\tBin_Array[i] = 1; //\t} }", "referer": "user-0"}]}
{"question": "求助，C语言编程题，代码运行不了。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:供参考：#include <stdio.h> int main() {     int n;     int time=0;     scanf(\"%d\",&n);     for(;;)     {         if(n==2 || n==3)//if(n==2&&n==3)         {             time++;             printf(\"%d\",time);             break;         }         else         {             if(n%3==0)             {                 time++;                 n=n/3;             }             else             {                 time++;                 n=((n-(n%3))/3)+(n%3);             }         }     }     return 0; } 谢谢！我这属于低级错误。。。。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考：#include <stdio.h> int main() {     int n;     int time=0;     scanf(\"%d\",&n);     for(;;)     {         if(n==2 || n==3)//if(n==2&&n==3)         {             time++;             printf(\"%d\",time);             break;         }         else         {             if(n%3==0)             {                 time++;                 n=n/3;             }             else             {                 time++;                 n=((n-(n%3))/3)+(n%3);             }         }     }     return 0; }", "referer": "user-0"}]}
{"question": "为什么执行不到else的内容，即使输入else控制的条件，也会执行if后的语句呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:scanf(\"%d,&n\");改为scanf(\"%d\",&n); scanf(\"%d\",b);改为scanf(\"%d\",&b);  printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  谢谢大佬！感谢感谢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "建议楼主检查一下while， if的条件，条件都是=赋值语句，不是判断语句呢。  scanf第二个参数是（变量）地址，而不是变量值。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "判断用==运算符。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "scanf(\"%d,&n\");改为scanf(\"%d\",&n); scanf(\"%d\",b);改为scanf(\"%d\",&b);  printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。", "referer": "user-0"}]}
{"question": "c语言，这哪里打错了，刚学还不懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼上都说拉，我就不说拉，水个帖子", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "给你写的代码，头文件引入有问题，你对比一下之前的程序，头文件是不是有不一样的地方？ 建议要学会看编译警告和错误，学会看懂他们", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "昨天休息了，就改2行代码就行了，在聊天工具输入代码 会有 乱码  引用 楼主 Congratulation395 的回复:c语言问题，不知道怎么改", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "鼠标双击报错的提示行，光标会自动定位到出错的源代码行。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "第一行包含的头文件 #incldue <stdio.h> 把内容的< 改为<   > 改为> 你是到复制的吧 ，< : < 小于号   > :  > 大于号；这是html 页面的转义字符", "referer": "user-0"}]}
{"question": "C语言  经典题型 完数的判断", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个肯定不是VC6", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "可参", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "可能是 dev-c吧。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "看界面是大学微机教室里的VC6.0啊", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "每次执行完i没有对sum初始化，这样每次的执行都是上次基础上继续给sum增加值。 建议在第一层循环for，第一句执行sum = 0;", "referer": "user-0"}]}
{"question": "C语言实现全排列", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}]}
{"question": "好心人帮忙看下这段代码为什么会出现runtime error，感激不尽！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #define y 114514  int main() {     long long int n,c,c1, a[1000],sum=0;//,j=0;     int i, j;      scanf(\"%lld%lld\",&n,&c);     c=c%y;     if (n > 1000)         n = 1000-1;     for (i=0; i<=n; i++) {         c1=1;         scanf(\"%lld\",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf(\"%lld\\n\",sum);     } else {         printf(\"0\\n\");     }      return 0; } 供参考～  没看出无限循环的代码，但是程序有可能越界，因为n的值输入若大于999就会越界。a最大是1000", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复：#include <stdio.h> #define y 114514 int main() {     static long long int a[1000];     long long int n,c,c1,sum=0,j=0;     int i;     scanf(\"%lld%lld\",&n,&c);     c=c%y;     for (i=0; i<=n; i++) {         c1=1;         scanf(\"%lld\",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf(\"%lld\\n\",sum);     } else {         printf(\"0\\n\");     }     return 0; } 您看下私信", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复：#include <stdio.h> #define y 114514  int main() {     long long int n,c,c1, a[1000],sum=0;//,j=0;     int i, j;      scanf(\"%lld%lld\",&n,&c);     c=c%y;     if (n > 1000)         n = 1000-1;     for (i=0; i<=n; i++) {         c1=1;         scanf(\"%lld\",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf(\"%lld\\n\",sum);     } else {         printf(\"0\\n\");     }      return 0; } 供参考～  没看出无限循环的代码，但是程序有可能越界，因为n的值输入若大于999就会越界。a最大是1000谢谢啦", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复：#include <stdio.h> #define y 114514 int main() {     static long long int a[1000];     long long int n,c,c1,sum=0,j=0;     int i;     scanf(\"%lld%lld\",&n,&c);     c=c%y;     for (i=0; i<=n; i++) {         c1=1;         scanf(\"%lld\",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf(\"%lld\\n\",sum);     } else {         printf(\"0\\n\");     }     return 0; } 谢谢啦", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "#include <stdio.h> #define y 114514 int main() {     static long long int a[1000];     long long int n,c,c1,sum=0,j=0;     int i;     scanf(\"%lld%lld\",&n,&c);     c=c%y;     for (i=0; i<=n; i++) {         c1=1;         scanf(\"%lld\",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf(\"%lld\\n\",sum);     } else {         printf(\"0\\n\");     }     return 0; }", "referer": "user-0"}]}
{"question": "【C语言求助】递归中不加return跟加return的区别？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf(\"hw 7.17\\n\");     int n;     printf(\"Please enter an interger:\\n\");     scanf(\"%d\",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 如果按你写的加return的话，输入483，只会输出4，所以我想知道是怎么执行的", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf(\"hw 7.17\\n\");     int n;     printf(\"Please enter an interger:\\n\");     scanf(\"%d\",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 这样是怎么执行的？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf(\"hw 7.17\\n\");     int n;     printf(\"Please enter an interger:\\n\");     scanf(\"%d\",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 那如果是return加在trans(n)的前面呢？就是 return trans(n)；", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf(\"hw 7.17\\n\");     int n;     printf(\"Please enter an interger:\\n\");     scanf(\"%d\",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "return 后，下面的语句就不执行了", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "看了一下老哥，码龄21年，你是真的编程了20年吗", "referer": "user-4"}, {"cid": "9", "user": "user-4", "content": "return 以后本次递归不执行，难道 不对吗？", "referer": "user-5"}, {"cid": "10", "user": "user-5", "content": "对啊  这不是语言机制吗 我平时很少遇到编程二十几年的人 ，所以好奇的问了一下，不是质疑你说的对不对的问题 ；", "referer": "user-4"}, {"cid": "11", "user": "user-6", "content": "有个问题，你这个功能实现在 vs2019 实现不了 整型 转字符串，  引用 楼主 飞禽走兽卍一2b 的回复:#include <stdio.h> #include <math.h> #include <stdlib.h> /*       函数目的：将输入的整数转换为字符型 */ void trans(int n) {          if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }           putchar(n%10+'0'); }  void main() {  printf(\"hw 7.17\\n\");     int n;     printf(\"Please enter an interger:\\n\");     scanf(\"%d\",&n);     if(n>0)     {      trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   }  请问这是怎么回事？最好能具体讲讲执行过程，谢谢！", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "不好意思楼主，我在vs 2019测试了 ，不论 加不加return 返回的值 都是同一个， return的作用，函数是void 类型 可以省略，如果函数的 返回类型 是Int 或 其他类型 ，需要添加return 返回值 ，我认为可能编译器的问题吧，我的测试结果都一样。  测试： 输入 483 输出 483  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <math.h> #include <stdlib.h> /*       函数目的：将输入的整数转换为字符型 */ void trans(int n) {      if ((n / 10) != 0)     {         trans(n / 10);//输入483，不加return输出483，加return输出4     }      putchar(n % 10 + '0');    // return; }  void main() {     printf(\"hw 7.17\\n\");     int n;     printf(\"Please enter an interger:\\n\");     scanf(\"%d\", &n);     if (n > 0)     {          trans(n);     }     if (n < 0)     {         putchar('-');          int abs_n = abs(n);         trans(abs_n);     }   }", "referer": "user-0"}, {"cid": "13", "user": "user-4", "content": "void trans(int n) {         if((n/10)!=0)         {             return  trans(n/10);         }         putchar(n%10+'0'); } 首先你要理解递归。按照你的执行流程，trans （483）将调用 trns(48),再调用 trns(4) 进入到trans(4)，因为 上边的if不满足条件执行 putchar 打印4 退出了trans(4) 返回到 trans（48）  然后立刻退出trans(48) 返回到 trans(483) ,再退出trans(483) 返回到main() ,加了return 后 putchar 这句话将得不到运行所以打印不出来。", "referer": "user-0"}, {"cid": "14", "user": "user-2", "content": "引用 6 楼 飞禽走兽卍一2b 的回复:[quote=引用 3 楼 自信男孩的回复:]不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf(\"hw 7.17\\n\");     int n;     printf(\"Please enter an interger:\\n\");     scanf(\"%d\",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 如果按你写的加return的话，输入483，只会输出4，所以我想知道是怎么执行的[/quote] 你确定执行了我的代码了吗？如果不确定，那就粘贴我的代码到编译器，然后编译执行一下～  如果只是分析得出你的结论，所以还需要执行一下比较好。  我发的代码基本上很少没经过自测的～", "referer": "user-0"}]}
{"question": "37个人围城一圈，编上号码（1~37），第一个人从1数起，数到5的人被淘汰，接下来的人继续数，最后剩下的人为赢家", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fflush()也可用于标准输入（stdin）和标准输出（stdout），用来清空标准输入输出缓冲区 这句fflush(stdin);在windows下的某些编译器可能有效，不等于其他编译器也一定有效；受限于某些编译器～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "rewind(stdin)清除标准输入的按键缓冲区", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "头文件：#include<stdio.h>   定义函数：int fflush(FILE * stream); 函数说明：fflush()会强迫将缓冲区内的数据写回参数stream指定的文件中，如果参数stream为NULL，fflush()会将所有打开的文件数据更新。 返回值：成功返回0，失败返回EOF，错误代码存于errno中。 fflush()也可用于标准输入（stdin）和标准输出（stdout），用来清空标准输入输出缓冲区。 stdin是standard input的缩写，即标准输入，一般是指键盘；标准输入缓冲区即是用来暂存从键盘输入的内容的缓冲区。stdout是standard output 的缩写，即标准输出，一般是指显示器；标准输出缓冲区即是用来暂存将要显示的内容的缓冲区。     清空标准输出缓冲区， 刷新输出缓冲区，即将缓冲区的东西输出到屏幕上  如果圆括号里是已写打开的文件的指针，则将输出缓冲区的内容写入该指针指向的文件，否则清除输出缓冲区。 这里的stdout是系统定义的标准输出文件指针，默认情况下指屏幕，那就是把缓冲区的内容写到屏幕上。 可是从代码中看不出缓冲区会有什么内容，所以它实际上没有起什么作用", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf(\"Input n m(1000>=n>=m>=1):\");         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf(\"%3d \",i);                 if (0==t%10) printf(\"\\n\");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf(\"Press any key ...\");     getch(); }", "referer": "user-0"}]}
{"question": "C++ 数组中元素的相邻元素地址只差为1", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "When two pointers to members of the same array object are subtracted, the difference is divided by the size of a member. The result represents the difference of the subscripts of the two array members.The size of the result is implementation-defined, and its type (a signed integral type) is ptrdiff_t defined in the <stddef.h> header. As with any other arithmetic overflow, if the result does not fit in the space provided, the behavior is undefined. If two pointers that do not point to members of the same array object are subtracted, the behavior is undefined. However, if P points either to a member of an array object or one past the last member of an array object, and Q points to the last member of the same array object, the expression (Q+1) - P has the same value as (Q-P) + 1, even though Q+1 does not point to a member of the array object.  当同一个数组的两个成员的指针相减时，其差值为：地址值的差，再除以一个数组成员的size。这个结果代表了两个指针对应元素的下标之差。    所以大家才遇到了上图中所遇到的问题。这是C语言标准所规定的。  本回答引用  [  https://blog.csdn.net/michaelhan3/article/details/74011258  ]", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <iostream> #include <vector> using namespace std;  int main() {     vector<double>K;     K.resize(5);     int a = &K[1] - &K[0];     int b = &K[2] - &K[0];     int c = &K[3] - &K[2];      cout << a << '\\t' << b << '\\t' << c << endl;      double k[10];      printf(\"%lu\\n\", (k+2) - (k+1));     printf(\"%lu\\n\", &k[2] - &k[1]); } 供参考  这样举例子是否能够很好的理解你的问题；  k+2等价&k[2], k+1等价&k[1]; 然后&k[2] - &k[1] == （k+2) - (k+1)==1", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "可想而知， 既然指针运算+整数1的时候，指向下一个同类型元素， 那自然，它的逆运算就是楼主写的，两个同型元素求地址差，得到的是整数，语义是下标差。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:因为K[1]....这些都是double &K[...]这些代表是double* 所以 &K[1]-&K[0] 是1,这个1代表的是一个double的长度感谢指导", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "C/C++指针+-数值运算，转换成相差元素的个数", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "因为K[1]....这些都是double &K[...]这些代表是double* 所以 &K[1]-&K[0] 是1,这个1代表的是一个double的长度", "referer": "user-0"}]}
{"question": "C语言实现数学组合问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}]}
{"question": "C语言字符串连接", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> int main (void) {      char *a,*p;      gets(a);      gets(p);      puts(a);      puts (p);      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "char ch; int i=0;  cha r* p = a; while(ch=*p++)    arr[i++] = ch;  p = b; while(ch=*p++)    arr[i++] = ch;  arr[i] = '\\0';", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include <stdio.h>  #define N 20 char arr[N] = {0};  int main() {     char a[]=\"acegikm\";     char b[]=\"bdfhjnpq\";     int i = 0;     for(i = 0;i < sizeof(a)-1;i++)         arr[i] = a[i];     for(i = 0;i < sizeof(b);i++)         arr[i+7] = b[i]; #if 0     for(i = 0;i < sizeof(a) + sizeof(b) - 1;i++)         printf(\"%c\\n\",arr[i]); #else      puts(arr); #endif } 供参考～", "referer": "user-0"}]}
{"question": "C语言标准函数库思维导图", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这笔记做得不错，哈哈。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "你们课业有点重啊，今天全是你的帖子", "referer": "user-0"}]}
{"question": "汉罗塔问C语言递归", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "挺好的啊。。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "做笔记？可以考虑使用印象或有道笔记～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "", "referer": "user-0"}]}
{"question": "已触发了一个断点问题怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h>  #define true 1 #define false 0  int InvertSequence(int m) {     int c,d,e=0;     if (m > 0 && m < 10) {         //printf(\"%d\", m);         return m;     }     else if (m >= 10 && m <= 99)     {         c= m / 10;         d = m - 10 * c;         //printf(\"%d%d\", d, c);          return d * 10 + c;     }     else if (m >= 100 && m < 1000)     {         c= m / 100;         d= (m - 100 * c) / 10;         e= m - 100 * c - 10 * d;         //printf(\"%d%d%d\", e,d , c);         return e * 100 + d * 10 + c;     }      return m; } int loop(int x) {     if (x == InvertSequence(x))         return true;     else         return false; } int main() {     int a=0;     int i = 0;     int b = 0;     int p, q = 0;     //scanf(\"%d%d\", a, b);     scanf(\"%d%d\", &a, &b);      for (i = a; i <= b; i++)     {         //p = InvertSequence(i);         //q = loop(p);         q = loop(i);         if (q == true)         {             //printf(\"%d\\n\", p);             printf(\"%d\\n\", i);         }     }     system(\"pause\"); } 供参考～  猜测楼主的功能，不一定对。建议楼主补充一下需求～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int InvertSequence(int m)没有返回值", "referer": "user-0"}]}
{"question": "求助，用c语言打出以下字符和字母", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?view=msvc-160", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "印度人口5200万？！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "注意输出的位宽，比如%10d, 以及小数点%.2lf，以及%20s等等这些", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "你需要注意的是printf左对齐和右对齐  1.左对齐 printf(“%d\\n”,101010); 默认为左对齐。  printf(“%-10d\\n”,101010); “-”表示左对齐，在数字宽度前面加上“-”号即可。 说明：数字宽度为10，如果要打印的位数小于10，则在后面补足空格；如果要打印的位数大于10，则打印所有的数字，不会截断。  2.右对齐 printf(“%10d”,101010); 在%和d之间加上数字宽度，就可以右对齐。 说明：数字宽度为10，如果要打印的位数小于10，左边补足空格；如果要打印的位数大于10，则打印所有的数字，不会截断。", "referer": "user-0"}]}
{"question": "线性表的基本操作的顺序表示及实现", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：https://blog.csdn.net/bzhxuexi/article/details/19088667?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161762532616780265418035%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161762532616780265418035&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-3-19088667.pc_search_result_cache&utm_term=c%E8%AF%AD%E8%A8%80%E5%BD%A2%E5%8F%82%E9%BB%98%E8%AE%A4%E5%80%BC", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "//以下三个函数最后一个形参可以不用，这里偷懒，均设了个初值 //Status GetELem(SqList L, int i, int e=0); //Status PriorElem(SqList L, int cur_e, int pri_e=0); //Status NextElem(SqList L, int cur_e, int Nex_e=0);第一个问题，这三个函数均是三个形参的设计，功能是找到元素本身及前驱和后驱元素，均有返回值，返回值可以通过函数名返回，并不需要返回到形参，所以只要有前两个形参就能达到我们的目的了。第二个问题，将这三个函数的最后一个形参在声明的时候都初始化了一个值，我们在后面调用这些函数时，可以两个参数的调用  ai = GetELem(La, i)，也可以三个参数的调用  ai = GetELem(La, i，e)，这是C第几版的规定我已经忘了，这极大方便了我们函数的编写和灵活的函数调用，你可以网上搜索下相关的资料。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:修改如下，供参考：//以下三个函数最后一个形参可以不用，这里偷懒，均设了个初值 //Status GetELem(SqList L, int i, int e=0); //Status PriorElem(SqList L, int cur_e, int pri_e=0); //Status NextElem(SqList L, int cur_e, int Nex_e=0); //file:xc.h  //#ifndef x_h //#define x_h #include<stdio.h> #include<stdlib.h>  #define MAXSIZE 20 //存储空间初始分配量 #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2  typedef int ElemType; typedef int Status; typedef struct {     ElemType* elem;//数组存储数据元素,最大值为MAXSIZE     int listsize;     int len;//线性表当前长度 }SqList; void CreateList(SqList* L, ElemType a[5], int n);//应该是先声明所构造的线性表操作或者说线性表相关函数 Status InitList(SqList* L); Status DestroyList(SqList* L); Status ClearList(SqList* L); Status ListEmpty(SqList L); Status ListLength(SqList L); Status GetELem(SqList L, int i, int e=0); Status LocateList(SqList L, int e); Status PriorElem(SqList L, int cur_e, int pri_e=0); Status NextElem(SqList L, int cur_e, int Nex_e=0); Status ListInsert(SqList* L, int i, int e); Status ListDelete(SqList* L, int i, int e); Status TravelList(SqList L); //#endif  //file:2.c  //#include \"xc.h\" //#include\"xc.c\" void MergeList(SqList La, SqList Lb, SqList* Lc) {     int i, j, k, La_len, Lb_len, ai, bj;     i = j = 0;     k = 0;     La_len = La.len;     Lb_len = Lb.len;     while (i < La_len && j < Lb_len)     {         ai = GetELem(La, i);         bj = GetELem(Lb, j);         if (ai <= bj)         {             ListInsert(Lc, k++, ai);//ListInsert(&Lc, k++, ai);             ++i;         }         else         {             ListInsert(Lc, k++, bj);//ListInsert(&Lc, k++, bj);             ++j;         }     }     while (i < La_len)     {         ai = GetELem(La, i++);         ListInsert(Lc, k++, ai); //ListInsert(&Lc, k++, ai);     }     while (j < Lb_len)     {         bj = GetELem(Lb, j++);         ListInsert(Lc, k++, bj);//ListInsert(&Lc, k++, bj);     } } int main() {     int la[5] = { 1,3,5,7,9 };     int lb[5] = { 2,3,6,8,10 };     int i, m, n, k;     int a = 10;     i = 3;     SqList La, Lb, Lc;     InitList(&La);     InitList(&Lb);     InitList(&Lc);     CreateList(&La, la, 5);     CreateList(&Lb, lb, 5);     printf(\"下面展现已创立的线性表 La Lb\\n\\n\");     printf(\"线性表La：\\n\");     TravelList(La);     printf(\"\\n线性表Lb：\\n\");     TravelList(Lb);     printf(\"\\n下面合并线性表La和Lb成为Lc:\\n\");     MergeList(La, Lb, &Lc);     TravelList(Lc);     printf(\"下面销毁线性表Lc\\n销毁后线性表为空\\n\");     DestroyList(&Lc);     TravelList(Lc);     printf(\"下面判断线性表是否为空：%d（1为是，0为否）\\n\", ListEmpty(Lc));     printf(\"\\n下面展现已有线性表La的长度为：%d\\n\", ListLength(La));     printf(\"\\n有线性表La中第3个元素为：%d\\n\",GetELem(La, i - 1));     printf(\"\\n下面置空线性表Lb\\n则置空后Lb为：\\n\");     ClearList(&Lb);     TravelList(Lb);     printf(\"下面判断线性表是否为空：%d（1为是，0为否）\\n\", ListEmpty(Lb));     printf(\"\\n下面寻找线性表La中第三个元素，以及第三个元素的前驱和后继\\n\");     m = GetELem(La, i - 1);     n = PriorElem(La, i - 1);     k = NextElem(La, i - 1);     printf(\"第三个元素为：%d\\n第三个元素的前驱为：%d\\n第三个元素的后继为：%d\\n\\n\", m, n, k);     printf(\"下面我们往La表中插入一个元素\\n\");     printf(\"假使往第三个位置插入元素a=10\\n\");     a = 10;     ListInsert(&La, i, a);     printf(\"插入后线性表La为：\\n\");     TravelList(La);     printf(\"\\n我们删除线性表La中的第3个元素后得到La为：\\n\");     ListDelete(&La, i, a);     TravelList(La);     printf(\"\\n下面查找线性表中是否有值为3的元素:\\n\");     LocateList(La, i);          return 0; }    //file:xc.c  //#include \"xc.h\" void CreateList(SqList* L, ElemType a[100], int n)//应该是先声明所构造的线性表操作或者说线性表相关函数 {     int i;     for (i = 0; i < n; i++)     {         *(L->elem + i) = a[i];     }     L->len = n; } Status InitList(SqList* L) {     L->elem = (ElemType*)malloc(MAXSIZE * sizeof(ElemType));     if (!L->elem) exit(OVERFLOW);//错误退出     L->len = 0;     L->listsize = MAXSIZE;     return OK; } Status DestroyList(SqList* L) {     free(L->elem);     L->elem = NULL;     L->len = 0;     L->listsize = 0;     return OK; } Status ClearList(SqList* L) {     L->len = 0;     return OK; } Status ListEmpty(SqList L) {     if (L.len == 0)         return TURE;     else         return FALSE; } Status ListLength(SqList L) {     return L.len; }  Status GetELem(SqList L, int i, int e) {     if (i < L.len)     {         e = L.elem[i];         return e;     }     else     {         return FALSE;     } } Status LocateList(SqList L, int e) {     int i;     for (i = 0; i < L.len; i++)     {         if (L.elem[i] == e)         {             printf(\"值为%d的元素是表中第%d个元素\\n\", e, i + 1);             return i;         }     } } Status PriorElem(SqList L, int cur_e, int pri_e) {      if (cur_e + 1 == 0)     {         return FALSE;     }     if (cur_e + 1 != 0 && cur_e < L.len)     {         pri_e = L.elem[cur_e - 1];         return  pri_e;     } } Status NextElem(SqList L, int cur_e, int Nex_e) {     if (cur_e == L.len)     {         return FALSE;     }     if (cur_e != L.len && cur_e > 0)     {         Nex_e = L.elem[cur_e + 1];         return Nex_e;     }  } Status ListInsert(SqList* L, int i, int e) {     int* p, * q;     p = L->elem + i;     q = L->elem + L->len;     for (; q >= p-1 ; q--)         *(q + 1) = *q;     * p = e;   //*(--p) = e; //插入元素     L->len++;     return TURE; } Status ListDelete(SqList* L, int i, int e) {     int* p, * q;     if (i<1 || i>L->len)     {         return FALSE;     }     //if (i > 1 && i < L->len)     {         p = L->elem + i - 1;         q = L->elem + L->len - 1;         for (; p <= q; p++)             *p = *(p + 1);         L->len--;         return TURE;     } } Status TravelList(SqList L) {     int i;     int* p = L.elem;     for (i = 0; i < L.len; i++, p++)     {         printf(\"第%d个元素为：%d\\n\", i, *p);     }     return TURE; }  //下面展现已创立的线性表 La Lb  //线性表La： //第0个元素为：1 //第1个元素为：3 //第2个元素为：5 //第3个元素为：7 //第4个元素为：9  //线性表Lb： //第0个元素为：2 //第1个元素为：3 //第2个元素为：6 //第3个元素为：8 //第4个元素为：10  //下面合并线性表La和Lb成为Lc: //第0个元素为：1 //第1个元素为：2 //第2个元素为：3 //第3个元素为：3 //第4个元素为：5 //第5个元素为：6 //第6个元素为：7 //第7个元素为：8 //第8个元素为：9 //第9个元素为：10 //下面销毁线性表Lc //销毁后线性表为空 //下面判断线性表是否为空：1（1为是，0为否）  //下面展现已有线性表La的长度为：5  //有线性表La中第3个元素为：5  //下面置空线性表Lb //则置空后Lb为： //下面判断线性表是否为空：1（1为是，0为否）  //下面寻找线性表La中第三个元素，以及第三个元素的前驱和后继 //第三个元素为：5 //第三个元素的前驱为：3 //第三个元素的后继为：7  //下面我们往La表中插入一个元素 //假使往第三个位置插入元素a=10 //插入后线性表La为： //第0个元素为：1 //第1个元素为：3 //第2个元素为：5 //第3个元素为：10 //第4个元素为：7 //第5个元素为：9  //我们删除线性表La中的第3个元素后得到La为： //第0个元素为：1 //第1个元素为：3 //第2个元素为：10 //第3个元素为：7 //第4个元素为：9  //下面查找线性表中是否有值为3的元素: //值为3的元素是表中第2个元素 //请按任意键继续. . . 首先非常感谢你的回答 有两个疑惑，在Getelem函数，PriorELem函数，NextElem函数的调用就应该传递三个参数吧？最后我选择修改为保留三个参数，调用 过程传递三个参数，成功将其运行，但是全部代码看下来 为何要将其修改如此       ai = GetELem(La, i);         bj = GetELem(Lb, j)呢？可否解释一下，非常非常感谢！", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "修改如下，供参考：//以下三个函数最后一个形参可以不用，这里偷懒，均设了个初值 //Status GetELem(SqList L, int i, int e=0); //Status PriorElem(SqList L, int cur_e, int pri_e=0); //Status NextElem(SqList L, int cur_e, int Nex_e=0); //file:xc.h  //#ifndef x_h //#define x_h #include<stdio.h> #include<stdlib.h>  #define MAXSIZE 20 //存储空间初始分配量 #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2  typedef int ElemType; typedef int Status; typedef struct {     ElemType* elem;//数组存储数据元素,最大值为MAXSIZE     int listsize;     int len;//线性表当前长度 }SqList; void CreateList(SqList* L, ElemType a[5], int n);//应该是先声明所构造的线性表操作或者说线性表相关函数 Status InitList(SqList* L); Status DestroyList(SqList* L); Status ClearList(SqList* L); Status ListEmpty(SqList L); Status ListLength(SqList L); Status GetELem(SqList L, int i, int e=0); Status LocateList(SqList L, int e); Status PriorElem(SqList L, int cur_e, int pri_e=0); Status NextElem(SqList L, int cur_e, int Nex_e=0); Status ListInsert(SqList* L, int i, int e); Status ListDelete(SqList* L, int i, int e); Status TravelList(SqList L); //#endif  //file:2.c  //#include \"xc.h\" //#include\"xc.c\" void MergeList(SqList La, SqList Lb, SqList* Lc) {     int i, j, k, La_len, Lb_len, ai, bj;     i = j = 0;     k = 0;     La_len = La.len;     Lb_len = Lb.len;     while (i < La_len && j < Lb_len)     {         ai = GetELem(La, i);         bj = GetELem(Lb, j);         if (ai <= bj)         {             ListInsert(Lc, k++, ai);//ListInsert(&Lc, k++, ai);             ++i;         }         else         {             ListInsert(Lc, k++, bj);//ListInsert(&Lc, k++, bj);             ++j;         }     }     while (i < La_len)     {         ai = GetELem(La, i++);         ListInsert(Lc, k++, ai); //ListInsert(&Lc, k++, ai);     }     while (j < Lb_len)     {         bj = GetELem(Lb, j++);         ListInsert(Lc, k++, bj);//ListInsert(&Lc, k++, bj);     } } int main() {     int la[5] = { 1,3,5,7,9 };     int lb[5] = { 2,3,6,8,10 };     int i, m, n, k;     int a = 10;     i = 3;     SqList La, Lb, Lc;     InitList(&La);     InitList(&Lb);     InitList(&Lc);     CreateList(&La, la, 5);     CreateList(&Lb, lb, 5);     printf(\"下面展现已创立的线性表 La Lb\\n\\n\");     printf(\"线性表La：\\n\");     TravelList(La);     printf(\"\\n线性表Lb：\\n\");     TravelList(Lb);     printf(\"\\n下面合并线性表La和Lb成为Lc:\\n\");     MergeList(La, Lb, &Lc);     TravelList(Lc);     printf(\"下面销毁线性表Lc\\n销毁后线性表为空\\n\");     DestroyList(&Lc);     TravelList(Lc);     printf(\"下面判断线性表是否为空：%d（1为是，0为否）\\n\", ListEmpty(Lc));     printf(\"\\n下面展现已有线性表La的长度为：%d\\n\", ListLength(La));     printf(\"\\n有线性表La中第3个元素为：%d\\n\",GetELem(La, i - 1));     printf(\"\\n下面置空线性表Lb\\n则置空后Lb为：\\n\");     ClearList(&Lb);     TravelList(Lb);     printf(\"下面判断线性表是否为空：%d（1为是，0为否）\\n\", ListEmpty(Lb));     printf(\"\\n下面寻找线性表La中第三个元素，以及第三个元素的前驱和后继\\n\");     m = GetELem(La, i - 1);     n = PriorElem(La, i - 1);     k = NextElem(La, i - 1);     printf(\"第三个元素为：%d\\n第三个元素的前驱为：%d\\n第三个元素的后继为：%d\\n\\n\", m, n, k);     printf(\"下面我们往La表中插入一个元素\\n\");     printf(\"假使往第三个位置插入元素a=10\\n\");     a = 10;     ListInsert(&La, i, a);     printf(\"插入后线性表La为：\\n\");     TravelList(La);     printf(\"\\n我们删除线性表La中的第3个元素后得到La为：\\n\");     ListDelete(&La, i, a);     TravelList(La);     printf(\"\\n下面查找线性表中是否有值为3的元素:\\n\");     LocateList(La, i);          return 0; }    //file:xc.c  //#include \"xc.h\" void CreateList(SqList* L, ElemType a[100], int n)//应该是先声明所构造的线性表操作或者说线性表相关函数 {     int i;     for (i = 0; i < n; i++)     {         *(L->elem + i) = a[i];     }     L->len = n; } Status InitList(SqList* L) {     L->elem = (ElemType*)malloc(MAXSIZE * sizeof(ElemType));     if (!L->elem) exit(OVERFLOW);//错误退出     L->len = 0;     L->listsize = MAXSIZE;     return OK; } Status DestroyList(SqList* L) {     free(L->elem);     L->elem = NULL;     L->len = 0;     L->listsize = 0;     return OK; } Status ClearList(SqList* L) {     L->len = 0;     return OK; } Status ListEmpty(SqList L) {     if (L.len == 0)         return TURE;     else         return FALSE; } Status ListLength(SqList L) {     return L.len; }  Status GetELem(SqList L, int i, int e) {     if (i < L.len)     {         e = L.elem[i];         return e;     }     else     {         return FALSE;     } } Status LocateList(SqList L, int e) {     int i;     for (i = 0; i < L.len; i++)     {         if (L.elem[i] == e)         {             printf(\"值为%d的元素是表中第%d个元素\\n\", e, i + 1);             return i;         }     } } Status PriorElem(SqList L, int cur_e, int pri_e) {      if (cur_e + 1 == 0)     {         return FALSE;     }     if (cur_e + 1 != 0 && cur_e < L.len)     {         pri_e = L.elem[cur_e - 1];         return  pri_e;     } } Status NextElem(SqList L, int cur_e, int Nex_e) {     if (cur_e == L.len)     {         return FALSE;     }     if (cur_e != L.len && cur_e > 0)     {         Nex_e = L.elem[cur_e + 1];         return Nex_e;     }  } Status ListInsert(SqList* L, int i, int e) {     int* p, * q;     p = L->elem + i;     q = L->elem + L->len;     for (; q >= p-1 ; q--)         *(q + 1) = *q;     * p = e;   //*(--p) = e; //插入元素     L->len++;     return TURE; } Status ListDelete(SqList* L, int i, int e) {     int* p, * q;     if (i<1 || i>L->len)     {         return FALSE;     }     //if (i > 1 && i < L->len)     {         p = L->elem + i - 1;         q = L->elem + L->len - 1;         for (; p <= q; p++)             *p = *(p + 1);         L->len--;         return TURE;     } } Status TravelList(SqList L) {     int i;     int* p = L.elem;     for (i = 0; i < L.len; i++, p++)     {         printf(\"第%d个元素为：%d\\n\", i, *p);     }     return TURE; }  //下面展现已创立的线性表 La Lb  //线性表La： //第0个元素为：1 //第1个元素为：3 //第2个元素为：5 //第3个元素为：7 //第4个元素为：9  //线性表Lb： //第0个元素为：2 //第1个元素为：3 //第2个元素为：6 //第3个元素为：8 //第4个元素为：10  //下面合并线性表La和Lb成为Lc: //第0个元素为：1 //第1个元素为：2 //第2个元素为：3 //第3个元素为：3 //第4个元素为：5 //第5个元素为：6 //第6个元素为：7 //第7个元素为：8 //第8个元素为：9 //第9个元素为：10 //下面销毁线性表Lc //销毁后线性表为空 //下面判断线性表是否为空：1（1为是，0为否）  //下面展现已有线性表La的长度为：5  //有线性表La中第3个元素为：5  //下面置空线性表Lb //则置空后Lb为： //下面判断线性表是否为空：1（1为是，0为否）  //下面寻找线性表La中第三个元素，以及第三个元素的前驱和后继 //第三个元素为：5 //第三个元素的前驱为：3 //第三个元素的后继为：7  //下面我们往La表中插入一个元素 //假使往第三个位置插入元素a=10 //插入后线性表La为： //第0个元素为：1 //第1个元素为：3 //第2个元素为：5 //第3个元素为：10 //第4个元素为：7 //第5个元素为：9  //我们删除线性表La中的第3个元素后得到La为： //第0个元素为：1 //第1个元素为：3 //第2个元素为：10 //第3个元素为：7 //第4个元素为：9  //下面查找线性表中是否有值为3的元素: //值为3的元素是表中第2个元素 //请按任意键继续. . .", "referer": "user-0"}]}
{"question": "CCF201909-1，运行错误，有大佬帮忙看看吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 qzjhjxj 的回复:供参考：#include<iostream> #include<math.h> using namespace std; struct tree{        int pick;        int sum; }; struct SUM{        int b; };  struct SUM su[100000];//定义全局变量  int main() {     int n,m,a=0;      int max=0;     int c=0;      cin>>n>>m;      tree tr[m];     //struct tree *tr = new struct tree [m];      //struct SUM su[100000];      for(int i=0;i<n;i++){         cin>>tr[i].sum;         for(int j=0;j<m;j++){             cin>>tr[j].pick;             tr[j].pick=abs(tr[j].pick);             tr[i].sum=tr[i].sum-tr[j].pick;             su[i].b=su[i].b+tr[j].pick;         }         c=c+tr[i].sum;         if(su[i].b>su[max].b){              max=i;         }else if(su[i].b==su[max].b&&i<max){             max=i;        }     }     cout<<c<<\" \"<<max+1<<\" \"<<su[max].b;     //delete []tr;      } 需要考虑到m!=n 且m < n否则会出现越界问题。因为m是tr变量的长度，但是下面循环是用n做比较的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include<iostream> #include<math.h> using namespace std; struct tree{        int pick;        int sum; }; struct SUM{        int b; };  struct SUM su[100000];//定义全局变量  int main() {     int n,m,a=0;      int max=0;     int c=0;      cin>>n>>m;      tree tr[m];     //struct tree *tr = new struct tree [m];      //struct SUM su[100000];      for(int i=0;i<n;i++){         cin>>tr[i].sum;         for(int j=0;j<m;j++){             cin>>tr[j].pick;             tr[j].pick=abs(tr[j].pick);             tr[i].sum=tr[i].sum-tr[j].pick;             su[i].b=su[i].b+tr[j].pick;         }         c=c+tr[i].sum;         if(su[i].b>su[max].b){              max=i;         }else if(su[i].b==su[max].b&&i<max){             max=i;        }     }     cout<<c<<\" \"<<max+1<<\" \"<<su[max].b;     //delete []tr;      }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 focuslight的回复:什么错误阿，贴出来吧， 我运行这代码没报错阿 我也不知道，但是交上去就是80分了，显示运行错误", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "什么错误阿，贴出来吧， 我运行这代码没报错阿", "referer": "user-0"}]}
{"question": "迪杰斯拉求最短路径", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "数字塔，小白想问问c有类似用法么，就是一下子输出字符的几倍，不用for循环输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "自己实现一个函数，函数在需要的地方调用这个函数", "referer": "user-0"}]}
{"question": "【C语言求助】函数部分：矩阵转置输出奇怪的数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 forever74的回复:主函数里调用时实参写的不对。 PrintArray(array);  //PrintArray(array[3][3]); 不好意思，可以了，谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 forever74的回复:主函数里调用时实参写的不对。 PrintArray(array);  //PrintArray(array[3][3]); 还是不行呀。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-4的回复:打印函数里，printf ()里arr [i+1 ][j+1]数组下标越界了，直接就是i j 还是不行呀。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "上面第一个for里面缺个分号，不可能通过编译，相信是复制时操作马虎造成的。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "主函数里调用时实参写的不对。 PrintArray(array);  //PrintArray(array[3][3]);", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "楼上说的对，为什么要i+1,j+1呢", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "打印函数里，printf ()里arr [i+1 ][j+1]数组下标越界了，直接就是i j", "referer": "user-0"}]}
{"question": "miracl大数库编写Paillier同态加密，powmod函数导致计算结果越界怎么解决呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "有解决方案了吗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qq_42039327 的回复:有解决方案了吗 已解决，是大数库使用不正确的问题，先初始化大数mirvar(0),再进行赋值", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "C语言段错误，如何解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "str第i个值，存在以下可能  1. i越界 2. str[i]为NULL 3. str[i]为野指针   PS：建议以后添加代码发帖", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "内存泄露  int index = *str[i]; //err 编译器 会 保留第一次的数据内容，等你第二次调用，你已经解引用 ，把内存数据弄没了，也就是指针指向为NULL空，等你第二次指针指向，当然是内存泄露了，所以这样写是错的 根据需求，你在改一下吧", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "没看懂楼主的需求。建议楼主发一下执行实例。就是楼主的代码怎么测试。  另外，把需求也描述一下～", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "嗯，string作为类型可不是C语言风格，另外楼主还试探着把*敲着玩，这俩习惯不好哦。 这个程序作为经验，可以让楼主进一步理解指针，地址和值 了。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "... str[i] 不是 string 对象吗？解引用是干啥？还赋值给 int，你这题目是想要干啥？", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "for (int i = 0, len = strlen(*str); i < len; i++)", "referer": "user-0"}]}
{"question": "要将时间复杂度控制在O(N)以内！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 44 楼 SleekStone 的回复:[quote=引用 43 楼 是疗伤烧肉粽~ 的回复:][quote=引用 37 楼 SleekStone 的回复:][quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]就是pResult = new int[N];这句过不了[/quote]用这个试试：int* fun(int *d, int N) {     int *pResult = 0;        if (0 != d && 0 < N)     {         int nTemp[101] = { 0 };         for (int i = 0; i < N; i++)         {             ++nTemp[d[i]];         }            int nTotalCount = 0;         for (int i = 100; i > -1; i--)         {             int nCurrent = nTemp[i];             nTemp[i] = nTotalCount;             nTotalCount += nCurrent;             if (nTotalCount == N)             {                 break;             }         }            pResult = (int*)malloc(sizeof(int) * N);         for (int i = 0; i < N; i++)         {             pResult[i] = nTemp[d[i]];         }     }        return pResult; }[/quote]行了，都过了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 28 楼 是疗伤烧肉粽~ 的回复:[quote=引用 24 楼 早打大打打核战争 的回复:][quote=引用 17 楼 是疗伤烧肉粽~ 的回复:]还是运行超时了，要O(N)才行 [quote=引用 15 楼 早打大打打核战争 的回复:]稍微优化一下：  #include <stdio.h> #include <stdlib.h>  int *fun(int *d, int N) {   int b[2][101] = {0};   int *r = (int *)malloc(sizeof(int) * N);    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }  int main() {   int n, *buf, *buf2;    scanf(\"%d\", &n);   buf = (int *)malloc(sizeof(int) * n);   for (int i = 0; i < n; i++) scanf(\"%d\", &buf[i]);   buf2 = fun(buf, n);   for (int i = 0; i < n; i++)     printf(\"%c%d\", i ? ',' : '{', buf2[i]);   printf(\"}\\n\");   free(buf), free(buf2);    return 0; } [/quote]  这个就是O(N)的，而且在O(N)算法中也属于比较优化的，如果还超时，应该是他卡内存分配和I/O时间了，可以改成静态分配（OJ程序是判断不出来动态申请还是静态分配的~） [/quote]能不能简单说一下思路，这代码我看不太懂，谢谢[/quote]  这三行：   for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]]; 第一行统计0~100分每个得分的人数，第三行把超过每个得分的人数写回数组，不必多说。 第二行，因为题目假定分数在0~100，所以超过100的肯定没有，就不计算了（已经预置为0）。超过99的显然就是100分的人数，超过98的就是99+100的人数... 于是得到递推公式：超过x分的人数就是x+1分的人数加上超过x+1的人数（好像是废话啊），从99逆推到0就得到超过每个得分的人数", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "评估角度：一个算法通常有最理想情况、平均情况、最糟糕情况，我们一般只考虑最糟糕情况 f(n)：一个算法运行的精确次数，如上面的例子，数据集合的大小为n, 则f(n) = 3n + 3 O(f(n))：精确次数===>渐进次数，因为我们通常考虑n趋于无穷大的情况，具体的规则如下： 当f(n)为常数时，如f(n) = 10，则O(f(n)) = O(10) = O(1) 当f(n)为多项式时，只取最高阶项，如f(n) = 2 n 2 + n + 3 2n^2 + n + 32n  2  +n+3，则O(f(n)) = O(2 n 2 2n^22n  2  ) 当f(n)有乘常数，则去除常数，如f(n) = 2 n 2 2n^22n  2  ，则O(f(n)) = O(n 2 n^2n  2  ) 什么是时间复杂度：一个算法运行所需要的时间，但不同的服务器所需的时间不同，通常采用一个算法运行的渐进次数来表示，即T(n)，n是数据集合的大小，表示公式为T(n) = O(f(n)) ———————————————— 版权声明：本文为CSDN博主「Bulut0907」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/yy8623977/article/details/109813724", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "好厉害的样子", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 27 楼 是疗伤烧肉粽~ 的回复:nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]我想知道这种算法能通过测试不，试一下告诉我结果", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 27 楼 是疗伤烧肉粽~ 的回复:nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "引用 43 楼 是疗伤烧肉粽~ 的回复:[quote=引用 37 楼 SleekStone 的回复:][quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]就是pResult = new int[N];这句过不了[/quote]用这个试试：int* fun(int *d, int N) {     int *pResult = 0;        if (0 != d && 0 < N)     {         int nTemp[101] = { 0 };         for (int i = 0; i < N; i++)         {             ++nTemp[d[i]];         }            int nTotalCount = 0;         for (int i = 100; i > -1; i--)         {             int nCurrent = nTemp[i];             nTemp[i] = nTotalCount;             nTotalCount += nCurrent;             if (nTotalCount == N)             {                 break;             }         }            pResult = (int*)malloc(sizeof(int) * N);         for (int i = 0; i < N; i++)         {             pResult[i] = nTemp[d[i]];         }     }        return pResult; }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 37 楼 SleekStone 的回复:[quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]就是pResult = new int[N];这句过不了", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "引用 35 楼 是疗伤烧肉粽~ 的回复:[quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]int* fun(int *d, int N) {     int *pResult = 0;       if (0 != d && 0 < N)     {         int nTemp[101] = { 0 };         for (int i = 0; i < N; i++)         {             ++nTemp[d[i]];         }           int nTotalCount = 0;         for (int i = 100; i > -1; i--)         {             int nCurrent = nTemp[i];             nTemp[i] = nTotalCount;             nTotalCount += nCurrent;             if (nTotalCount == N)             {                 break;             }         }           pResult = (int*)malloc(sizeof(int) * N);         for (int i = 0; i < N; i++)         {             pResult[i] = nTemp[d[i]];         }     }       return pResult; }", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "引用 40 楼 forever74 的回复:[quote=引用 37 楼 SleekStone 的回复:]怎么可能，nullptr的地方都用0替换，不应该编不过啊  new是++范儿。[/quote]啊.....好吧...", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "引用 37 楼 SleekStone 的回复:怎么可能，nullptr的地方都用0替换，不应该编不过啊  new是++范儿。", "referer": "user-0"}, {"cid": "12", "user": "user-1", "content": "new是c++运算符，需要改成malloc，你可能没注意到楼主发的是c语言版", "referer": "user-0"}, {"cid": "13", "user": "user-6", "content": "引用 37 楼 SleekStone 的回复:[quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]  还有 new 呢...  多少为这楼主感到可惜", "referer": "user-0"}, {"cid": "14", "user": "user-4", "content": "引用 35 楼 是疗伤烧肉粽~ 的回复:[quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 33 楼 早打大打打核战争 的回复:[quote=引用 28 楼 是疗伤烧肉粽~ 的回复:][quote=引用 24 楼 早打大打打核战争 的回复:][quote=引用 17 楼 是疗伤烧肉粽~ 的回复:]还是运行超时了，要O(N)才行 [quote=引用 15 楼 早打大打打核战争 的回复:]稍微优化一下：  #include <stdio.h> #include <stdlib.h>  int *fun(int *d, int N) {   int b[2][101] = {0};   int *r = (int *)malloc(sizeof(int) * N);    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }  int main() {   int n, *buf, *buf2;    scanf(\"%d\", &n);   buf = (int *)malloc(sizeof(int) * n);   for (int i = 0; i < n; i++) scanf(\"%d\", &buf[i]);   buf2 = fun(buf, n);   for (int i = 0; i < n; i++)     printf(\"%c%d\", i ? ',' : '{', buf2[i]);   printf(\"}\\n\");   free(buf), free(buf2);    return 0; } [/quote]  这个就是O(N)的，而且在O(N)算法中也属于比较优化的，如果还超时，应该是他卡内存分配和I/O时间了，可以改成静态分配（OJ程序是判断不出来动态申请还是静态分配的~） [/quote]能不能简单说一下思路，这代码我看不太懂，谢谢[/quote]  这三行：   for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]]; 第一行统计0~100分每个得分的人数，第三行把超过每个得分的人数写回数组，不必多说。 第二行，因为题目假定分数在0~100，所以超过100的肯定没有，就不计算了（已经预置为0）。超过99的显然就是100分的人数，超过98的就是99+100的人数... 于是得到递推公式：超过x分的人数就是x+1分的人数加上超过x+1的人数（好像是废话啊），从99逆推到0就得到超过每个得分的人数 [/quote]懂了，谢谢，代码过了", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 30 楼 SleekStone 的回复:[quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了", "referer": "user-0"}, {"cid": "17", "user": "user-1", "content": "引用 26 楼 是疗伤烧肉粽~ 的回复:引用 25 楼 早打大打打核战争 的回复:另，他的OJ是要提交整个程序还是只要一个函数？只要一个函数  改成静态分配：  int *fun(int *d, int N) {   int b[2][101] = {0};   //int *r = (int *)malloc(sizeof(int) * N);   static int r[1048576];    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }", "referer": "user-0"}, {"cid": "18", "user": "user-4", "content": "int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "引用 24 楼 早打大打打核战争 的回复:[quote=引用 17 楼 是疗伤烧肉粽~ 的回复:]还是运行超时了，要O(N)才行 [quote=引用 15 楼 早打大打打核战争 的回复:]稍微优化一下：  #include <stdio.h> #include <stdlib.h>  int *fun(int *d, int N) {   int b[2][101] = {0};   int *r = (int *)malloc(sizeof(int) * N);    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }  int main() {   int n, *buf, *buf2;    scanf(\"%d\", &n);   buf = (int *)malloc(sizeof(int) * n);   for (int i = 0; i < n; i++) scanf(\"%d\", &buf[i]);   buf2 = fun(buf, n);   for (int i = 0; i < n; i++)     printf(\"%c%d\", i ? ',' : '{', buf2[i]);   printf(\"}\\n\");   free(buf), free(buf2);    return 0; } [/quote]  这个就是O(N)的，而且在O(N)算法中也属于比较优化的，如果还超时，应该是他卡内存分配和I/O时间了，可以改成静态分配（OJ程序是判断不出来动态申请还是静态分配的~） [/quote]能不能简单说一下思路，这代码我看不太懂，谢谢", "referer": "user-0"}, {"cid": "20", "user": "user-0", "content": "nullptr是什么？怎么没定义就冒出来？？？ 引用 23 楼 SleekStone 的回复:int* fun(int *d, int N) { \tint *pResult = nullptr;  \tif (nullptr != d && 0 < N) \t{ \t\tint nTemp[101] = { 0 }; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\t++nTemp[d[i]]; \t\t}  \t\tint nTotalCount = 0; \t\tfor (int i = 100; i > -1; i--) \t\t{ \t\t\tint nCurrent = nTemp[i]; \t\t\tnTemp[i] = nTotalCount; \t\t\tnTotalCount += nCurrent; \t\t\tif (nTotalCount == N) \t\t\t{ \t\t\t\tbreak; \t\t\t} \t\t}  \t\tpResult = new int[N]; \t\tfor (int i = 0; i < N; i++) \t\t{ \t\t\tpResult[i] = nTemp[d[i]]; \t\t} \t}  \treturn pResult; }", "referer": "user-0"}]}
{"question": "形参为地址上存储的值即20,30，为什么实参的地址值可以传递过去啊？求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你是把地址传过去，然后交换的是两个地址空间对应的值呀", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。  调用约定 https://docs.microsoft.com/zh-cn/cpp/cpp/calling-conventions?view=vs-2017", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "悟了：在void swap(int *pa,int *pb)中 *pa,*pb是定义其为指针变量； 而在t=*pa,*pb=*pa,*pa=t中 *pa,*pb是指指针指向地址中存储的值。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "C语言是值传递", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "你不是传的地址过去吗？参数是指针呀", "referer": "user-0"}]}
{"question": "为什么会出现这种结果？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h>  typedef int datatype; typedef struct node {     datatype data;     struct node *next; }linklist;  void creatlist1(linklist *head,int n) {     linklist *p,*s;     int i;      head->next=NULL;     s=head;     for(i=0;i<n;i++)     {         p=(linklist*)malloc(sizeof(linklist));         scanf(\"%d\",&p->data);         s->next=p;         s=p;     }      s->next = NULL; //last node's next pointer NULL } void displaylist(linklist *head) {     linklist *p;     //int i=0;     p=head->next;     if(p==NULL)     {         printf(\"这是个空指针\\n\");         return; //exit from displylist     }     while(p)     {          printf(\"%d \",p->data);         p=p->next;     } } int main() {     linklist *head;     head=(linklist*)malloc(sizeof(linklist));     creatlist1(head,5);   //创建一个链式列表     displaylist(head);    //输出列表中的元素     return 0; }  供参考～  原因是创建链表的时候没有对最后一个节点做处理，即最后一个节点的next指针应该指向NULL displaylist出现无限循环就是因为没有找到NULL", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "正如楼上朋友说的，代码产生问题的主要原因在于displaylist()函数的 while (p) \t{ \t\tprintf(\"%d \", p->data); \t\tp = p->next; \t} 在遍历链表的时候，最后一个元素时，理论上p->next应该指向空指针，但是由于createlist1()函数的for循环中分配内存时，并没有对p->next值进行显式地赋空指针值，导致最后一个元素的p->next不是空指针而是一个随机值，在我调试的VS2015中，这个值是0xcdcdcdcd。这样就导致在displaylist()函数的while()语句中会访问0xcdcdcdcd，而这个地址是不能访问的，就会直接报错。 解决的方法就是在createlist1()函数的for循环中 p = (linklist*)malloc(sizeof(linklist)); \t\tp->next = nullptr;", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "p=(linklist*)malloc(sizeof(linklist)); p->next=NULL", "referer": "user-0"}]}
{"question": "小白数据结构的求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：//头文件 /*************************************************************     顺序表的实现  头文件 **************************************************************/  #include <stdio.h> #include <stdlib.h> //#include \"Seqlist.h\"  #define  MAXSIZE 100//最大长度  typedef int ElemType;  typedef  struct {   ElemType  *elem; //指向数据元素的起始地址   int  length;     //线性表的当前长度  }SqList;  //declaration of functions:  // 顺序表的初始化，即构造一个空的顺序表 void SL_Initiate(SqList &L);  // 释放顺序表 void SL_Free(SqList &L);  // 判断顺序表是否空 bool SL_IsEmpty(SqList L);  // 判断顺序表是否满 bool SL_IsFull(SqList L);  // 输入n个数据元素，创建一个顺序表L void SL_Create(SqList &L,int n);  // 输出整个顺序表 void SL_Print(SqList L);  // 获取顺序表L的第i个元素赋给e，i的有效范围[1,L.length]。 void SL_GetAt(SqList L, int i, ElemType &e);  // 在顺序表L中查找第一个值为x的元素， // 找到则返回该元素在表中的位置，否则返回0。 int SL_FindValue(SqList L, ElemType x);  // 在顺序表的第i个位置插入新元素e, 即在元素L.elem[i-1]之前插入 //i的有效范围[1,L.length+1] void SL_InsAt(SqList &L, int i, ElemType e);  // 删除顺序表L的第i个元素 //i的有效范围[1,L->length] void SL_DelAt(SqList &L, int i);  // 删除第一个值为x的元素 void SL_DelValue(SqList &L, ElemType x);    /*************************************************************     顺序表的实现之增删功能 实现文件     更新于2020年4月13日     **************************************************************/   void SL_Initiate(SqList &L) // 顺序表的初始化，即构造一个空的顺序表 {     L.elem = (ElemType*)malloc(sizeof(ElemType)*MAXSIZE);     L.length=0; }  void SL_Free(SqList &L) // 释放顺序表 {     free(L.elem); }  bool SL_IsEmpty(SqList L) // 判断顺序表是否空 {     return L.length==0; }  bool SL_IsFull(SqList L) // 判断顺序表是否满 {     return L.length==MAXSIZE; }  void SL_Create(SqList &L,int n) // 输入n个数据元素，创建一个顺序表L {     int i;     L.length=n;     for(i=0; i<n; i++)        scanf(\"%d\", &L.elem[i]); }  void SL_Print(SqList L) // 输出整个顺序表 {     if (L.length==0)     {        printf(\"The slist is empty.\\n\");        return ;     }      for (int i=0; i<L.length; i++)          printf(\"%d  \", L.elem[i]);     printf(\"\\n\"); }  void SL_InsAt(SqList &L, int i, ElemType e) // 在顺序表的第i个位置插入新元素e, 即在元素L.elem[i-1]之前插入 // i的有效范围[1,L.length+1] {     // 请在这里补充代码，完成本关任务     /********** Begin *********/     SqList *a;     a=&L;     if(i<0 || i>MAXSIZE) return;     int j,k=99;      for(j=L.length;j>i-1;j--)//for(j=MAXSIZE;j>i-1;j--)     {        a->elem[j]=a->elem[j-1];                              //k--;     }     a->elem[i-1]=e;      L.length ++;      /********** End **********/ }  void SL_DelAt(SqList &L, int i) // 删除顺序表L的第i个元素 //i的有效范围[1,L.length] {     // 请在这里补充代码，完成本关任务     /********** Begin *********/     SqList *a;     a=&L;     if(i<0 || i>MAXSIZE) return;     int k=i,j;     for(j=i-1;j<L.length;j++)  //for(j=i-1;j<99;j++)     {         a->elem[j]=a->elem[j+1];                                //k++;     }     L.length--;     /********** End **********/ }  void SL_DelValue(SqList &L, ElemType x) // 删除第一个值为x的元素 {     // 请在这里补充代码，完成本关任务     /********** Begin *********/     SqList *a=&L;     int i,j;     for(i=0;i<L.length;i++)//for(i=0;i<MAXSIZE;i++)     {         if(a->elem[i]==x)         {          for(j=i;j<L.length;j++) //for(j=i;j<99;j++)               a->elem[j]=a->elem[j+1];          L.length--;          return ;         }     }     return;      /********** End **********/ }  //主函数  //#include <stdio.h> //#include <stdlib.h> //#include \"Seqlist.h\" //#include \"Seqlist.cpp\"  int main() {     SqList L;     int n,i,x;      SL_Initiate(L);      printf(\"输入元素的个数及值\\n\");     scanf(\"%d\", &n);//输入元素的个数     SL_Create(L, n);     SL_Print(L);      printf(\"输入待插入的位置和待插入元素的值\\n\");     scanf(\"%d%d\", &i,&x);//输入待插入的位置和待插入元素的值     SL_InsAt(L, i, x);     SL_Print(L);      printf(\"输入待删除元素的位置\\n\");     scanf(\"%d\", &i);//输入待删除元素的位置     SL_DelAt(L, i);     SL_Print(L);      printf(\"输入待删除元素的值\");     scanf(\"%d\", &x);//输入待删除元素的值     SL_DelValue(L, x);     SL_Print(L);      //SL_Print(L);     SL_Free(L);      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "为什么小弟运行程序以后程序最后会多出一个0 当我输入这串数据它就多出一个0 6 5 9 11 31 9 88 2 10 7 9", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "头文件 /*************************************************************     顺序表的实现  头文件 **************************************************************/  #define  MAXSIZE 100     //最大长度 typedef int ElemType;  typedef  struct {   ElemType  *elem;     //指向数据元素的起始地址   int  length;          //线性表的当前长度                                                        }SqList;  //declaration of functions:  // 顺序表的初始化，即构造一个空的顺序表 void SL_Initiate(SqList &L);  // 释放顺序表 void SL_Free(SqList &L);  // 判断顺序表是否空 bool SL_IsEmpty(SqList L);  // 判断顺序表是否满 bool SL_IsFull(SqList L);  // 输入n个数据元素，创建一个顺序表L void SL_Create(SqList &L,int n);  // 输出整个顺序表 void SL_Print(SqList L);  // 获取顺序表L的第i个元素赋给e，i的有效范围[1,L.length]。 void SL_GetAt(SqList L, int i, ElemType &e);  // 在顺序表L中查找第一个值为x的元素， // 找到则返回该元素在表中的位置，否则返回0。 int SL_FindValue(SqList L, ElemType x);  // 在顺序表的第i个位置插入新元素e, 即在元素L.elem[i-1]之前插入 //i的有效范围[1,L.length+1] void SL_InsAt(SqList &L, int i, ElemType e);  // 删除顺序表L的第i个元素 //i的有效范围[1,L->length] void SL_DelAt(SqList &L, int i);  // 删除第一个值为x的元素 void SL_DelValue(SqList &L, ElemType x);", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "主函数  #include <stdio.h> #include <stdlib.h> #include \"Seqlist.h\" //#include \"Seqlist.cpp\"  int main() { \tSqList L;int n,i,x;  \tSL_Initiate(L);  \tscanf(\"%d\", &n);//输入元素的个数 \tSL_Create(L, n);  \tscanf(\"%d%d\", &i,&x);//输入待插入的位置和待插入元素的值 \tSL_InsAt(L, i, x); \t \tscanf(\"%d\", &i);//输入待删除元素的位置 \tSL_DelAt(L, i);  \tscanf(\"%d\", &x);//输入待删除元素的值 \tSL_DelValue(L, x);  \tSL_Print(L);\t \tSL_Free(L); }", "referer": "user-0"}]}
{"question": "c语言打印日历", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "还可以先定义一个二维字符数组，先“定位”输出到这个数组中，最后输出这个数组到屏幕或打印机。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "定位不是标准C语言的一部分 所以如果是C语言初学者 这个题目一定不打算让你定位 而是想办法从左上依次输出到右下 中间适当加空格 以达到看起来定位的效果", "referer": "user-0"}]}
{"question": "C语言中什么时候用%d和%f", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "嗯，你说得很对， 不过printf(\"b=%.2f\",b);可以保留两位小数，这样应该更正确", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "输出时，%f可用于float，也可用于double 输入时，%f用于float，%lf用于double", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "%d和%f 既用来指明输出的格式，也用来指明对应的实参是什么类型。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "C语言新手，刚入门，写个博客记录下学习，不足之处，欢迎大家指正，不吝赐教！！", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "这是广告帖吗？内存里都是二进制数据，用%d输出是一个值，用%f输出是一个值。结果虽然不一样，但是内存了的二进制不变，因为浮点数和整型数表示的方法不一样，即对于相同的二进制数，不同的符号，比如%d和%f，它的解析方法不一样，因此结果是不一样的。", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "好。。自问自答啊。。。", "referer": "user-0"}]}
{"question": "Cyv'y求助！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "x y 嘛，天生就是当坐标的样子", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "因为我还是个学生，所以电脑现在不在身边，主要是想做个坐标，按w就y++，s就y--那种，你这个应该可以解决吧", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 user-2的回复:按现有内容理解：  char *s[2][2]={\"火车站\",\"机场\",\"万达广场\",\"立交桥下\"}; ... printf(\"你来到了%s\\n\",s[x][y]);  大约就这个意思，参考一下。 明天实验一下，觉得有希望了。。。 终于解决了！", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 user-2的回复:按现有内容理解：  char *s[2][2]={\"火车站\",\"机场\",\"万达广场\",\"立交桥下\"}; ... printf(\"你来到了%s\\n\",s[x][y]);  大约就这个意思，参考一下。 感谢，差不多就是这样，我没有想到。。。 这个坐标方法很好！谢谢！", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "按现有内容理解：  char *s[2][2]={\"火车站\",\"机场\",\"万达广场\",\"立交桥下\"}; ... printf(\"你来到了%s\\n\",s[x][y]);  大约就这个意思，参考一下。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "不太理解你确切的意思，有完整一些的代码表达么？", "referer": "user-0"}]}
{"question": "目标文件（.a或.obj）之间的链接算静态链接吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请问楼主这个问题解决啦吗，大家的回复对你有帮助吗？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "bucuo                             不错", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "准确的说，静态链接这个概念发生在可执行链接之前。静态链接是库链接，是编译时的操作。可执行链接是把目标文件接入系统执行方案的操作。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "自己动手搜索了一下，没有找到static link，static-link的字典式解释。（当然，这不等于它不存在。） 所以一边喝茶，一边捋一捋我主观理解的“静态链接”的由来。  起初，没有操作系统，没有高级语言，没有文件系统，自然是在物理地址上编程，没有链接。 那么链接/link应该出现在有了文件系统/操作系统/汇编语言的时代，用来在分模块的程序设计中主要表达两个意思：模块间符号解析和调用地址绑定（重定位）。 这个词出现初期，还没有库，只有分别编译/汇编的模块。后来出现了库，链接扩展了它的含义也处理库里的模块。  随着操作系统的进化，忽然有一天（浪漫说法）出现了动态链接，也就是运行时模块间符号解析与模块调用的地址绑定，链接再次扩展其含义以接受动态。 从这时起，为了与新技术进行区别，传统生成可执行文件前的链接方式就都被称为静态链接。  这就是我为什么那样认为，因为这个词本来就是作为新定义的动态链接概念的补集而出现的，而不是独立定义的，所以没有留下缝隙（既不动态也不静态的链接行为）。  我一直强调主观性，心虚。 各位老师如果也是归纳式理解，我们就各说各的好了；如果有权威解释，欢迎指出我的错误，我改。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "那应该称呼为什么？", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "补丁：#6的“两行以上”是“这句话上方两行距离提到的”的意思，敲的时候欠考虑了，易生歧义。", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "我一直觉得， 静态链接库 是 供静态链接过程使用的库 的意思， 并没有“甩开我就都不算静态链接”的语义 。", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "看来这个问题变成语文问题了 可以先约定一下确切的词汇语义和讨论范畴。  个人仍然认为，我们在讨论C语言， 立足于主函数和主函数所在的文件， 那么其他处于另外文件的函数， 只要是在运行以前，确切地说是生成可执行文件以前， 招招手呼叫一下，就从其他目标文件飘过来一个函数的二进制代码， 拼装到我的产品内， 这个过程就都算静态链接。 链接，说的就是两行以上的拼装过程，当然还有各种细节， 静态，强调的是运行前，代码进入可执行文件， 和代码的来源并没有什么必然联系。  欢迎咬文嚼字批判我。", "referer": "user-0"}, {"cid": "10", "user": "user-7", "content": "静态链接是专指库文件的链接方式，所以不能说 .o 也是静态链接。 .o 通过 ar 打包成了 .a，链接的时候 .a 也会解包成 .o，再使用链接 .o 的方式链接", "referer": "user-0"}, {"cid": "11", "user": "user-8", "content": "不算", "referer": "user-0"}, {"cid": "12", "user": "user-5", "content": "没办法，自学的局限性，归纳式理解术语确实理解不精确。 一直主观认为链接是个动词，静态和动态是它的修饰，但不妨碍作为词组的静态链接和动态链接都是作为动词描述一个过程的。 静态链接描述的是生成过程中，复制目标代码进入可执行文件并进一步处理重定位等细节的过程，终止于出错或可执行文件生成。 而与之相对的动态链接用于描述可执行文件载入内存准备运行的时候和内存中的不属于这个可执行文件的二进制代码对接协调的过程。（这里的术语又不专业了）  所以请教一下静态链接这个词的比较精确的字典式定义出自哪里？求指点。", "referer": "user-0"}, {"cid": "13", "user": "user-8", "content": ".o组合为.a/.lib或.so/.dll或.out/.exe发生在生成时，此时应该没有静态/动态link一说。 非要说对某个函数的调用是静态链接还是动态链接，得看下面运行时对函数实际调用得情况：  当.out/.exe被运行后，调用的函数只要来自.out/.exe文件内，该函数就是静态链接；反之，不是来自.out/.exe文件内，而是来自外部.so./.dll就是动态链接。  个人理解，不喜勿喷。", "referer": "user-0"}, {"cid": "14", "user": "user-7", "content": "引用 22 楼 forever74 的回复:那么NorZ老师认为，静态链接和动态链接这两个术语只用于描述对库的引用，我们这里讨论的项目里两个源文件之间的普通链接过程和这两个术语无关。 我们的分歧确实是语文问题，不在于实质。  那么赵4老师，您给出的参考资料的52页上这段话描述的是两个源文件的链接过程，这段的末尾指出作者认为这个属于静态链接啊，您为什么据此认为不算呢？   你要是把随意使用专业术语，当作是语文问题...那也是你的语文理解不到位 包括你引用的这本书的内容。注意看最后一句话，前面的句号，最后一句只是表述前面的描述是“静态链接的最基本的过程”，并没有说前面的描述就是静态链接。", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 21 楼 flying_music 的回复:[quote=引用 3 楼 六道佩恩 的回复:][quote=引用 1 楼 flying_music 的回复:]目标文件之间只能算是打包吧，只是物理的组合，并没有重定位等一系列操作，所以一般不叫\"链接\"  你说的是目标文件组合成静态库吗？（可能是我没懂起你说的）  目标文件之间的函数调用、全局变量访问这些不是会有重定位吗？[/quote] 重定位只会发生在生成可执行文件时，多个库组成一个库就只是打包，“打包”“链接”“静态链接”“动态链接”这些都是比较专业的词，最好不要乱用，虽然基本也能明白[/quote]  我说的不一直都是目标文件链接成exe吗？", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "那么NorZ老师认为，静态链接和动态链接这两个术语只用于描述对库的引用，我们这里讨论的项目里两个源文件之间的普通链接过程和这两个术语无关。 我们的分歧确实是语文问题，不在于实质。  那么赵4老师，您给出的参考资料的52页上这段话描述的是两个源文件的链接过程，这段的末尾指出作者认为这个属于静态链接啊，您为什么据此认为不算呢？", "referer": "user-0"}, {"cid": "17", "user": "user-9", "content": "引用 3 楼 六道佩恩 的回复:[quote=引用 1 楼 flying_music 的回复:]目标文件之间只能算是打包吧，只是物理的组合，并没有重定位等一系列操作，所以一般不叫\"链接\"  你说的是目标文件组合成静态库吗？（可能是我没懂起你说的）  目标文件之间的函数调用、全局变量访问这些不是会有重定位吗？[/quote] 重定位只会发生在生成可执行文件时，多个库组成一个库就只是打包，“打包”“链接”“静态链接”“动态链接”这些都是比较专业的词，最好不要乱用，虽然基本也能明白", "referer": "user-0"}, {"cid": "18", "user": "user-10", "content": "库(.lib、a等等)是目标文件(.obj、.o之类)的合集，链接是以目标文件为单位的，链接单独的目标文件也是可以的", "referer": "user-0"}, {"cid": "19", "user": "user-7", "content": "引用 18 楼 forever74 的回复:所以精确一些描述， 在链接/连接这个范畴/全集下， 1、静态链接无疑是个子集，动态链接也是，那么静态链接子集和动态链接子集的并集（我们这里不讨论交集）有没有非空补集？有的话叫做什么？ 2、main.o和fun.o的链接，main.obj和fun.obj的链接，在这个语境里完全是同义，它在静态链接子集里，还是在补集里？  我完全没有引经据典，全凭不知来源的记忆和主观理解，认为， 1、不存在这个补集 2、所以它只能落进静态链接圈  静态链接和动态链接，只是链接库文件的方式。 从来没有.o 文件的动态和静态链接之说。 .o 文件的链接过程就大概就叫做链接 linking 吧，和库文件的链接过程是不同", "referer": "user-0"}, {"cid": "20", "user": "user-5", "content": "所以精确一些描述， 在链接/连接这个范畴/全集下， 1、静态链接无疑是个子集，动态链接也是，那么静态链接子集和动态链接子集的并集（我们这里不讨论交集）有没有非空补集？有的话叫做什么？ 2、main.o和fun.o的链接，main.obj和fun.obj的链接，在这个语境里完全是同义，它在静态链接子集里，还是在补集里？  我完全没有引经据典，全凭不知来源的记忆和主观理解，认为， 1、不存在这个补集 2、所以它只能落进静态链接圈", "referer": "user-0"}]}
{"question": "求求大佬们帮帮忙啊(´-ω-`)！这个题目该怎么编程啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "要在链式列表中某位置插入一个元素，然后写了下面这个函数来查找该位置的前一个位置并用指针指向它，最后传回该指针，但是感觉这个函数有点问题，求大神们帮我看看，怎么改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：linklist * find(linklist *head,int i) {     linklist *p;     if (i==0)return head;//如果表头，返回头结点     p=head;     int j=0;     while(p!=NULL && j<i-1)      {          j++;          p=p->next;      }     if(!p) return NULL:     return p; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "linklist * find(linklist *head,int i) {     linklist *p;     p=head;     int j=1;     while(p!=NULL&&j<=i)     {         j++;         p=p->next;     }     if(!p) {         printf(\"p=NULL\");         return NULL;     }     //else     return p;  } 供参考～  如果没找到应该是返回NULL", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可以这么算，但没意义 str[i]-'0'的意思是str[i]是一个'0'到'9'的字符，str[i]-'0'这样可以计算出其数值，比如'2'-'0'正好等于2 str[i]-'a'时，str[i]应该是一个字母对应的字符，比如str[i]-'a'+'A'可以把一个小写字母转成大写字母 上面用到的特性，其实是ASCII中，0-9 a-z A-Z是连续编码的，但0跟a的编码没啥关系，所以不同性质的两个字符相减是没意义的", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "只要在序列中都是可以计算的,没发现问题.", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 楼主 m0_45257832 的回复:str[i]-'0' 为什么不会对'a'运算， 'a'-'0'=49，为什么不会这样算  并没有什么机制在阻止这个运算，这样算是完全可以地", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "char a[] = \"a\"; cout << a[0] - '0';", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "仅供参考： #include <stdio.h> #include <string.h> FILE *f; char buffer[4096]; int r,a; void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,\"%08x -\",i+addr);             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);             sprintf(binstr,\"%s  \",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf(\"%s\\n\",binstr);         } else {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,\"%s   \",binstr);         }         sprintf(binstr,\"%s  \",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf(\"%s\\n\",binstr);     } } int main(int argc,char **argv) {     if (argc<2) {         fprintf(stderr,\"Usage: %s filename.ext\\n\",argv[0]);         return 2;     }     f=fopen(argv[1],\"rb\");     if (NULL==f) {         fprintf(stderr,\"Can not open file [%s]!\\n\",argv[1]);         return 1;     }     a=0;     while (1) {         r=fread(buffer,1,4096,f);         HexDump(buffer,r,a);         a+=r;         if (r<4096) break;     }     fclose(f);     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "'a'的ASCII对应的十进制是65即0x61，而'0'~'9'对应的是0x30~0x39  一般对于'0'-'9'字符是与'0'比较和做差 一般是'A'-'Z'与'A'比较和做差  同理'a'-'z'与'a'", "referer": "user-0"}]}
{"question": "为什么出不来结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf(\"%d\", &p->data); 空格问题～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "scanf(\"%d \",&(p->data));这句里面\"%d   \" 后面多了空格符，应该这样：scanf(\"%d\",&(p->data));", "referer": "user-0"}]}
{"question": "stm32 两个串口在某个时间点需要同时处理任务，请问怎么处理？等三个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "了解一下有限状态自动机。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "请问有大佬帮忙看看吗0.0", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:了解一下有限状态自动机。  感谢您 这就去看看", "referer": "user-0"}]}
{"question": "codeblocks 环境错误问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}]}
{"question": "水仙花数在一定范围内输出。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "根据楼主的代码，应该是返回的返回值有问题。楼主的逻辑里，z++是在循环里一定会执行的，因为它在for的大循环里，每次都执行到；第二cn函数有返回非0的可能吗？没有，因为最后还是return 0；z只要执行for循环，就一定会执行z++，即使for循环一次不执行，那么最终也会执行return 0；所以，非0从哪里来呢？   int cnt (int n , int m) {      int sum, tmp, i;      int cnt = 0;       if (m > n)          swap(&m, &n);       for (i = m ; i < n; i++) {          tmp = i;          sum = 0;          while (tmp) {              rem = tmp % 10;              sum += pow(rem, 3);   //or rem * rem * rem;              tmp /= 10;          }          if (sum == i) {              printf(\"%d is narcissus number!\\n\", i);              cnt++;          }      }       return cnt; } static int swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }    供参考代码，可以试一下。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int cn()函数修改，供对照：int cn(int n,int m) {     int hun,ten,ind,a,flog=1,z=0;     for(a=n;a<=m;a++)      {        hun = a/100;        ten = a/10%10;        ind = a%10;        if(a == hun*hun*hun + ten*ten*ten + ind*ind*ind)          {            printf(\"%d \",a);            z++;          }      }      if(z==0) flog = 0;      return flog;  }", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 8 楼 user-3的回复:就你的问题（因为题目没写分号，我也不写） j=!c&&i++ 来说，它是 j=(   (!c) && (i++)  ) 的意思，而不是 (j=!c) && (i++)  或者 j=(!c && i)++ 或者别的 这是运算符优先级的作用----注意，我们一直没有开始算呢，讨论的是怎么正确理解那个式子  真的要算结果了，其实优先级分析就退休了。上面第四行告诉我们， 它是个赋值语句，先求右侧表达式的值，然后送给j  ----注意，我们首先关注的是这里面优先级最低的赋值运算符啊  上一行里的“先”“然后”描述的是执行次序，但这是由赋值运算符的语义决定的，和优先级完全没有关系 然后我们才注意到要被求值的是个逻辑与运算，这是我们马上反应，左边若为假，右边被忽略----这是逻辑与的语义决定的  至此兴尽，return to sleep; printf（\"thanks +++++\"）；", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "就你的问题（因为题目没写分号，我也不写） j=!c&&i++ 来说，它是 j=(   (!c) && (i++)  ) 的意思，而不是 (j=!c) && (i++)  或者 j=(!c && i)++ 或者别的 这是运算符优先级的作用----注意，我们一直没有开始算呢，讨论的是怎么正确理解那个式子  真的要算结果了，其实优先级分析就退休了。上面第四行告诉我们， 它是个赋值语句，先求右侧表达式的值，然后送给j  ----注意，我们首先关注的是这里面优先级最低的赋值运算符啊  上一行里的“先”“然后”描述的是执行次序，但这是由赋值运算符的语义决定的，和优先级完全没有关系 然后我们才注意到要被求值的是个逻辑与运算，这是我们马上反应，左边若为假，右边被忽略----这是逻辑与的语义决定的  至此兴尽，return to sleep;", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 6 楼 user-3的回复:优先级跟运算次序没有决定性关系，要从小学数学的思维习惯摆脱出来。 运算符优先级其实是个小学语文的概念。  应该听过 下雨天留客天留我不留 这个梗吧？ 在恰当的位置加逗号是语文风格 把应该结合在一起的东西括起来是C风格 不用括起来也优先黏糊在一起，这就叫优先级高 这就是为什么int *a[3]是个数组而int (*a)[3]是个指针，优先级是干这个用的。 谢谢您！我明白了 十分感谢", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "优先级跟运算次序没有决定性关系，要从小学数学的思维习惯摆脱出来。 运算符优先级其实是个小学语文的概念。  应该听过 下雨天留客天留我不留 这个梗吧？ 在恰当的位置加逗号是语文风格 把应该结合在一起的东西括起来是C风格 不用括起来也优先黏糊在一起，这就叫优先级高 这就是为什么int *a[3]是个数组而int (*a)[3]是个指针，优先级是干这个用的。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "运算符的优先级那是讨论结合性用的，用在编译期间。 而运算顺序，只有 &&   ||    ?:     ,    这四个运算符存在确定的顺序，并且前两个有可能，第三个一定会忽略一部分子表达式的求值。这是运行期概念。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 2 楼 user-3的回复:哦，至于这个题目，那是短路效应造成的。 写完这题，我突然就不懂运算的优先级了", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 2 楼 user-3的回复:哦，至于这个题目，那是短路效应造成的。 请问有&&运算符的话就直接从左到右计算吗？", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "哦，至于这个题目，那是短路效应造成的。", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "莫非你忘了 ++写在i后面了？", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "从网上找一下判断闰年的逻辑，自定义一个函数，然后用一个循环，穷举法就是循环遍历m--n之间的每一个年份，再用判断闰年的函数即可。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "课后作业？自己百度一下吧，不难", "referer": "user-0"}]}
{"question": "问大佬们一个简单的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "括号里是一个整体，中间是逗号，则取最后一个逗号后面的赋值给c", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "逗号表达式，结果是最后那个值，也就是2", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  //C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}]}
{"question": "循环队列入队出队（数据结构c语言）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 ┍Æ ζざ 的回复:[quote=引用 楼主 ┍Æ ζざ的回复:]怎么写啊，各位大佬  我写了，不对[/quote] 贴代码吧，贴图片也不全呢，怎么知道哪里有问题。帮你也是无从下手～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 10 楼 ┍Æ ζざ的回复:[quote=引用 9 楼 自信男孩的回复:][quote=引用 8 楼 ┍Æ ζざ 的回复:]感谢！麻烦帮我看看  我的代码发给你了，你自己看看。如果r, m超过2^31-1的话，可能会有问题  这也是我代码的一个小bug [/quote] 我没有看到代码啊！[/quote] 看到了，谢谢你", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 9 楼 自信男孩的回复:[quote=引用 8 楼 ┍Æ ζざ 的回复:]感谢！麻烦帮我看看  我的代码发给你了，你自己看看。如果r, m超过2^31-1的话，可能会有问题  这也是我代码的一个小bug [/quote] 我没有看到代码啊！", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 8 楼 ┍Æ ζざ 的回复:感谢！麻烦帮我看看  我的代码发给你了，你自己看看。如果r, m超过2^31-1的话，可能会有问题  这也是我代码的一个小bug", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "感谢！麻烦帮我看看", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "那个是函数题。我的代码如下： void EnQueue_seq(SeqQueue squeue, DataType x) {      SeqQueue *p;     p = (SeqQueue*)malloc(sizeof(SeqQueue));     if((p->r+1)%Max==p->f)         return 0;     p->r = x;     p->r = (p->r+1)%Max;     return 1;   } void DeQueue_seq(SeqQueue squeue) {     SeqQueue *p;     SeqQueue *q;     p = (SeqQueue*)malloc(sizeof(SeqQueue));     if(p->f==p->r)         return 0;     q = p->f;     p->f = (p->f+1)%Max;     return 1; } DataType FrontQueue_seq(SeqQueue squeue) {     SeqQueue *p;     int data[100];     p = (SeqQueue*)malloc(sizeof(SeqQueue));     if(!p)     {         printf(\"It is empty queue!\");     }    return p->f;     if((p->r+1)%Max==p->f)         printf(\"It is FULL Queue!It is FULL Queue!p->f\");      }", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "你是写了不对？还是没写？函数体是@@这样算是不对？  #include <stdio.h> #include <stdlib.h>  typedef char DataType; struct Queue {     int Max;     int f;     int r;     DataType *elem; }; typedef struct Queue *SeqQueue;  SeqQueue SetNullQueue_seq(int m) {     SeqQueue squeue;     squeue = (SeqQueue)malloc(sizeof(struct Queue));     if (squeue == NULL)     {         printf(\"Alloc failure\\n\");         return NULL;     }     squeue->elem = (char*)malloc(sizeof(DataType)*m);     if (squeue->elem != NULL)     {         squeue->Max = m;         squeue->f = 0;         squeue->r = 0;         return squeue;     }      //add this     free(squeue);     return NULL; }  int IsNullQueue_seq(SeqQueue squeue) {     return (squeue->f == squeue->r); } void EnQueue_seq(SeqQueue squeue, DataType x) {     int pos, len;     if (squeue->f  < squeue->r)         return;     pos = squeue->f;     len = squeue->Max;      printf(\"%s--> r:%d, w:%d\\n\", __func__, squeue->r, squeue->f);     squeue->elem[pos%len] = x;     if (squeue->f + 1 < 0)         squeue->f = 0;     squeue->f += 1;  } void DeQueue_seq(SeqQueue squeue) {     int pos, len;     if (squeue->r >= squeue->f)         return;      pos = squeue->r;     len = squeue->Max;     DataType ch;      printf(\"%s--> r:%d, w:%d\\n\", __func__, squeue->r, squeue->f);     ch = squeue->elem[pos%len];     if (squeue->r + 1 < 0)         squeue->r = 0;     squeue->r += 1;     printf(\"%c\\n\", ch);     //@@ } DataType FrontQueue_seq(SeqQueue squeue) {     DataType ch;     int pos, len;      pos = squeue->r;     len = squeue->Max;     ch = squeue->elem[pos%len];      return ch;     //@@ }  int main() {     char ch;     SeqQueue queueA = SetNullQueue_seq(5);     ch = getchar();     while (ch != '#')     {         EnQueue_seq(queueA, ch);         ch = getchar();     }     DeQueue_seq(queueA);     printf(\"%c\" ,FrontQueue_seq(queueA));      /*     DeQueue_seq(queueA);     DeQueue_seq(queueA);     DeQueue_seq(queueA);      printf(\"%c\" ,FrontQueue_seq(queueA));     ch = getchar();     ch = getchar();     EnQueue_seq(queueA, ch);     DeQueue_seq(queueA);     printf(\"%c\" ,FrontQueue_seq(queueA));     */     return 0; }", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:[quote=引用 2 楼 ┍Æ ζざ 的回复:][quote=引用 楼主 ┍Æ ζざ的回复:]怎么写啊，各位大佬  我写了，不对[/quote] 贴代码吧，贴图片也不全呢，怎么知道哪里有问题。帮你也是无从下手～[/quote] 本题要求实现队列的顺序存储表示，包括入队、出队和取队头操作 函数接口定义： void EnQueue_seq(SeqQueue squeue, DataType x)  ; void DeQueue_seq(SeqQueue squeue)  ; DataType FrontQueue_seq(SeqQueue squeue) ; 其中，squeue 是操作的队列，x是入队的元素 裁判测试程序样例：  #include <stdio.h> #include <stdlib.h> typedef char DataType; struct Queue {     int Max;       int f;        int r;       DataType *elem;  }; typedef struct Queue *SeqQueue;  SeqQueue SetNullQueue_seq(int m)  {     SeqQueue squeue;     squeue = (SeqQueue)malloc(sizeof(struct Queue));     if (squeue == NULL)     {         printf(\"Alloc failure\\n\");         return NULL;     }     squeue->elem = (char*)malloc(sizeof(DataType)*m);     if (squeue->elem != NULL)     {         squeue->Max = m;         squeue->f = 0;         squeue->r = 0;         return squeue;     } }  int IsNullQueue_seq(SeqQueue squeue)  {     return (squeue->f == squeue->r); } void EnQueue_seq(SeqQueue squeue, DataType x)   {     @@ } void DeQueue_seq(SeqQueue squeue)   {     @@ } DataType FrontQueue_seq(SeqQueue squeue)  {     @@ }  int main() {     char ch;     SeqQueue queueA = SetNullQueue_seq(5);     ch = getchar();     while (ch != '#')     {         EnQueue_seq(queueA, ch);         ch = getchar();     }     DeQueue_seq(queueA);     printf(\"%c\" ,FrontQueue_seq(queueA));     return 0; } 输入样例： ABCD# 输出样例： B 输入样例： A# 输出样例： It is empty queue! 输入样例： ABCDEF# 输出样例： It is FULL Queue!It is FULL Queue!B", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:[quote=引用 2 楼 ┍Æ ζざ 的回复:][quote=引用 楼主 ┍Æ ζざ的回复:]怎么写啊，各位大佬  我写了，不对[/quote] 贴代码吧，贴图片也不全呢，怎么知道哪里有问题。帮你也是无从下手～[/quote] 本题要求实现队列的顺序存储表示，包括入队、出队和取队头操作 函数接口定义： void EnQueue_seq(SeqQueue squeue, DataType x)  ; void DeQueue_seq(SeqQueue squeue)  ; DataType FrontQueue_seq(SeqQueue squeue) ; 其中，squeue 是操作的队列，x是入队的元素 裁判测试程序样例：  #include <stdio.h> #include <stdlib.h> typedef char DataType; struct Queue {     int Max;       int f;        int r;       DataType *elem;  }; typedef struct Queue *SeqQueue;  SeqQueue SetNullQueue_seq(int m)  {     SeqQueue squeue;     squeue = (SeqQueue)malloc(sizeof(struct Queue));     if (squeue == NULL)     {         printf(\"Alloc failure\\n\");         return NULL;     }     squeue->elem = (char*)malloc(sizeof(DataType)*m);     if (squeue->elem != NULL)     {         squeue->Max = m;         squeue->f = 0;         squeue->r = 0;         return squeue;     } }  int IsNullQueue_seq(SeqQueue squeue)  {     return (squeue->f == squeue->r); } void EnQueue_seq(SeqQueue squeue, DataType x)   {     @@ } void DeQueue_seq(SeqQueue squeue)   {     @@ } DataType FrontQueue_seq(SeqQueue squeue)  {     @@ }  int main() {     char ch;     SeqQueue queueA = SetNullQueue_seq(5);     ch = getchar();     while (ch != '#')     {         EnQueue_seq(queueA, ch);         ch = getchar();     }     DeQueue_seq(queueA);     printf(\"%c\" ,FrontQueue_seq(queueA));     return 0; } 输入样例： ABCD# 输出样例： B 输入样例： A# 输出样例： It is empty queue! 输入样例： ABCDEF# 输出样例： It is FULL Queue!It is FULL Queue!B", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 楼主 ┍Æ ζざ的回复:怎么写啊，各位大佬  我写了，不对", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "先按照自己思路写写吧", "referer": "user-0"}]}
{"question": "C语言求助 指针输出val = 0000000000000001", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "BTW: 这里的指针变量们其实起到的仍然是非指针普通变量的作用。因为它们没有被解引用。 所以楼主还需要额外注意一下，为了避免总线错误，指针变量实际上是不能随意赋值的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "因为val是将(int *)1传给了fun函数里的a（局部变量），这两个变量是相互独立的，除了传值，没有其他关系；  所以fun函数不会把(int *)3带出来； 所以val还是main函数里初始化的(int *)1；结果自然是这个了。  可以试试这样void fun(int** a) {     *a = (int *)3; } 调用  fun(&val);  再输出来的结果应该就不是这个了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "%p 就是按32位或64位，16进制输出。你在程序里修改指针的地址，出了函数依然是原来的地址", "referer": "user-0"}]}
{"question": "c语言用if怎么写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先自己写写吧，首先是不是奇数，if (n % 2)如果是奇数对2取余得到肯定是非0 是不是5位数，if (n / 10000)如果是肯定商是非0；否则商为0呢；同理判断2位数，1位数还是4位数。  这些似乎都是小学的数学问题～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>  #define MAX_NUM     100000 int main(void) {     int n;     int ret;      printf(\"Please input a number: \");     while ((ret = scanf(\"%d\", &n)) != 1 && n >= MAX_NUM)         printf(\"Input err!\\n\");      if (n % 2) {         printf(\"%d is an odd number!\\n\", n);         if (n % 3 == 0)             printf(\"%d is a multiple of 3!\\n\", n);         else             printf(\"%d is not a multiple of 3!\\n\", n);     } else {         if (n / 10000)             printf(\"五\");         else if (n / 1000)             printf(\"四\");         else if (n / 100)             printf(\"三\");         else if (n / 10)             printf(\"二\");         else             printf(\"一\");         printf(\"位数.\\n\");     }      return 0; } 供参考  可以按照要求把打印改改～", "referer": "user-0"}]}
{"question": "这个怎么写？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主富二代吗，不好好学习", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "没看出楼主指的是那个问题？具体问题都懒得描述了，那你学习上是不是书都懒得看了。  这么懒，大学还怎么进行下去？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "这种过于基础的，还是作为训练吧，否则以后...就没有以后了。", "referer": "user-0"}]}
{"question": "一阶抛物型方程经典问题，求问如何用c语言或c++解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<iostream> using namespace std;  int main() { \tdouble x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xx, PI; \tPI = 3.1415926; x0 = 0; x1 = sin(0.1 * PI); \tx2 = sin(0.2 * PI); x3 = sin(0.3 * PI); x4 = sin(0.4 * PI); \tx5 = sin(0.5 * PI); x6 = sin(0.6 * PI); x7 = sin(0.7 * PI); \tx8 = sin(0.8 * PI); x9 = sin(0.9 * PI); xx = 0; \tdouble y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, yy; \ty0 = 0; yy = 0; \tint i; \tfor (i = 1; i <= 5; i++) { \t\ty1 = 0.8 * x0 + 0.1 * (x1 + x2); \t\ty2 = 0.8 * x1 + 0.1 * (x2 + x3); \t\ty3 = 0.8 * x2 + 0.1 * (x3 + x4); \t\ty4 = 0.8 * x3 + 0.1 * (x4 + x5); \t\ty5 = 0.8 * x4 + 0.1 * (x5 + x6); \t\ty6 = 0.8 * x5 + 0.1 * (x6 + x7); \t\ty7 = 0.8 * x6 + 0.1 * (x7 + x8); \t\ty8 = 0.8 * x7 + 0.1 * (x8 + x9); \t\ty9 = 0.8 * x8 + 0.1 * (x9 + xx); \t\tx1 = y1; x2 = y2; x3 = y3; x4 = y4; \t\tx5 = y5; x6 = y6; x7 = y7; x8 = y8; \t\tx9 = y9; \t} \tdouble a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa; \ta0 = 0; aa = 0; a1 = pow(2.718281828459, -PI * PI / 40) * 0.1; \ta2 = pow(2.718281828459, -PI * PI / 40) * 0.2; a3 = pow(2.718281828459, -PI * PI / 40) * 0.3; \ta4 = pow(2.718281828459, -PI * PI / 40) * 0.1; a5 = pow(2.718281828459, -PI * PI / 40) * 0.1; \ta6 = pow(2.718281828459, -PI * PI / 40) * 0.1; a7 = pow(2.718281828459, -PI * PI / 40) * 0.1; \ta8 = pow(2.718281828459, -PI * PI / 40) * 0.1; a9 = pow(2.718281828459, -PI * PI / 40) * 0.1; \tcout << \"差分方法结果 实际结果\" << endl; \tcout << x0 << \"             \"<< a0 << endl; cout << x1 << \"  \" << a1 << endl; cout << x2 << \"  \" << a2 << endl; \tcout << x3 << \"  \" << a3 << endl; cout << x4 << \"  \" << a4 << endl; cout << x5 << \"  \" << a5 << endl; \tcout << x6 << \"  \" << a6 << endl; cout << x7 << \"  \" << a7 << endl; cout << x8 << \"  \" << a8 << endl; \tcout << x9 << \"  \" << a9 << endl; cout << xx << \"             \" << aa << endl; \treturn 0; } 龙哥，把代码改一改，只要不相似就好了。", "referer": "user-0"}]}
{"question": "新手刚学，请大佬们赐教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "会了，多谢各位🙏", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "今年大二，刚开始学编程，有时候看着头疼，", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "能帮我改改吗，[face]monkey2:025.png[/face]，就想输入任意温度求出电阻值", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "错了错了，你只是要输入t。应该改为scanf(\"%f\", &t);", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "供参考，楼主漏说话了：#include<stdio.h> int main() {     float R,t;     scanf(\"%f\",&t);     R = 10+30*t+t*t;     printf(\"R=%f\\nt=%f\\n\",R,t);          return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "有点迷惑的代码？      float R, t;     scanf(\"%f %f\", &R, &t);     R = 10 + 30 * t + t * t;     printf(\"R = %f\\nt = %f\\n\",R, t);  提供参考 第一眼很迷惑，再看一眼，你应该是把scanf和printf函数用错了", "referer": "user-0"}]}
{"question": "【C语言求助】幼儿园计算器 2.0（一位正整数±乘除）相关问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-2的回复:问题：参与运算的只能一位数。式子中不能连乘或连除（如：1+2*3*4）。供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {        printf(\"hw 附加题\\n\");        int i,j=0,result,sz,tmp=0,m;        char t[2];                           //增加字符数组t        printf(\"请输入参与计算数字的个数：\\n\");        scanf(\"%d\",&sz);        int size=2*sz-1; //size是所有字符的长度，后面用于控制循环条件         getchar();   //吸收回车~        printf(\"请输入算式：\\n\");        char a[1000],c[1000],d[1000],n[1000]; //a[1000] 为原始字符，n[1000]用于记录a[]里的数字部分                                              //c[1000]记录a中乘除运算后的字符（就是说a与c的区别在于c里没有乘除）                                              //d[1000]为c转成整型的数组        int tmp1,tmp2;                //这两个临时变量是整型        gets(a);        //记录a中数字（a-->n)        for(int i=0;i<size;i++)        {             if(a[i]!='\\n')             {                 if(a[i]<='9'&&a[i]>='0')                 {                     sscanf(&a[i],\"%d\",&n[i]);                      printf(\"n[%d]=%d \",i,n[i]);                 }             }             else break;         }        //记录乘除，并将乘除项算出来        for(i=0;i<size;i++)        {             if(a[i]!='\\n')             {                 if(a[i]=='*')                 {                     m=i-(2*tmp+1);  // m=i-(2*tmp+1)是在乘除后生成的新的数的排列序数。如1-2*3   *号位于i=4，进行运算后变成1-6， // 数字6位于i'=3  ==  m=i-(2*tmp+1)=4-(2*0+1)=3 完美印证计算公式~ //tmp是当前乘除号以前的乘除号的数目                     tmp1=n[i-1]*n[i+1]; //如tmp1=2*3                     //printf(\"tmp1=%d\\n\",tmp1);                     sprintf(t,\"%d\",tmp1); //把整型tmp1转化为字符                     c[m] = t[0];                     //printf(\"c[%d]=%c\",m,c[m]);                     tmp++;  //每乘除一次，tmp自增一                     i++;    //i自增一次                 }                 else if(a[i]=='/')                 {                     m=i-(2*tmp+1);                     tmp2=n[i-1]/n[i+1];//没考虑不能整除的情况                     sprintf(t,\"%d\",tmp2);                     c[m] = t[0];                     tmp++;                     i++;                 }                 else                 {                     m=i-2*tmp; //在当前不是乘除号的情况下，算出当前字符的序数                     c[m]=a[i]; //非乘除时直接赋给c                 }             }             else break;        }        //输出c[m]，以便观察        for(i=0;i<m+1;i++)//for(m=0;m<size;m++)        {            printf(\"c[%d]=%c\\n\",i,c[i]);        }        //system(\"pause\");        for(m=0;m<size;m++) //记录c中数字（c——>d)        {             if(c[m]!='\\n')             {                 if(c[m]<='9'&&c[m]>='0')                 {                     sscanf(&c[m],\"%d\",&d[m]);                     printf(\"c[%d]=%c \",m,c[m]);                     printf(\"d[%d]=%d \",m,d[m]);                  }             }             else break;          }         result=d[0];         printf(\"result0=%d\\n\",result);          //以下为加减计算部分         for(m=0;m<size-2*tmp;m++)  //size-2*tmp为进行乘除后的总字符数         {           if(c[m]!='\\n')           {             if(c[m]=='-')               {                   printf(\"d[%d]=%d \",m+1,d[m+1]);                   result-=d[m+1];               }               else if(c[m]=='+')               {                   result+=d[m+1];               }           }           else break;        }        printf(\"result=%d\",result);          }  //hw 附加题 //请输入参与计算数字的个数： //6 //请输入算式： //1+2*3+1*5+4 //n[0]=1 n[2]=2 n[4]=3 n[6]=1 n[8]=5 n[10]=4 c[0]=1 //c[1]=+ //c[2]=6 //c[3]=+ //c[4]=5 //c[5]=+ //c[6]=4 //c[0]=1 d[0]=1 c[2]=6 d[2]=6 c[4]=5 d[4]=5 c[6]=4 d[6]=4 result0=1 //result=16请按任意键继续. . . 哇⊙∀⊙！谢谢！ 之后细看", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "问题：参与运算的只能一位数。式子中不能连乘或连除（如：1+2*3*4）。供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {        printf(\"hw 附加题\\n\");        int i,j=0,result,sz,tmp=0,m;        char t[2];                           //增加字符数组t        printf(\"请输入参与计算数字的个数：\\n\");        scanf(\"%d\",&sz);        int size=2*sz-1; //size是所有字符的长度，后面用于控制循环条件         getchar();   //吸收回车~        printf(\"请输入算式：\\n\");        char a[1000],c[1000],d[1000],n[1000]; //a[1000] 为原始字符，n[1000]用于记录a[]里的数字部分                                              //c[1000]记录a中乘除运算后的字符（就是说a与c的区别在于c里没有乘除）                                              //d[1000]为c转成整型的数组        int tmp1,tmp2;                //这两个临时变量是整型        gets(a);        //记录a中数字（a-->n)        for(int i=0;i<size;i++)        {             if(a[i]!='\\n')             {                 if(a[i]<='9'&&a[i]>='0')                 {                     sscanf(&a[i],\"%d\",&n[i]);                      printf(\"n[%d]=%d \",i,n[i]);                 }             }             else break;         }        //记录乘除，并将乘除项算出来        for(i=0;i<size;i++)        {             if(a[i]!='\\n')             {                 if(a[i]=='*')                 {                     m=i-(2*tmp+1);  // m=i-(2*tmp+1)是在乘除后生成的新的数的排列序数。如1-2*3   *号位于i=4，进行运算后变成1-6， // 数字6位于i'=3  ==  m=i-(2*tmp+1)=4-(2*0+1)=3 完美印证计算公式~ //tmp是当前乘除号以前的乘除号的数目                     tmp1=n[i-1]*n[i+1]; //如tmp1=2*3                     //printf(\"tmp1=%d\\n\",tmp1);                     sprintf(t,\"%d\",tmp1); //把整型tmp1转化为字符                     c[m] = t[0];                     //printf(\"c[%d]=%c\",m,c[m]);                     tmp++;  //每乘除一次，tmp自增一                     i++;    //i自增一次                 }                 else if(a[i]=='/')                 {                     m=i-(2*tmp+1);                     tmp2=n[i-1]/n[i+1];//没考虑不能整除的情况                     sprintf(t,\"%d\",tmp2);                     c[m] = t[0];                     tmp++;                     i++;                 }                 else                 {                     m=i-2*tmp; //在当前不是乘除号的情况下，算出当前字符的序数                     c[m]=a[i]; //非乘除时直接赋给c                 }             }             else break;        }        //输出c[m]，以便观察        for(i=0;i<m+1;i++)//for(m=0;m<size;m++)        {            printf(\"c[%d]=%c\\n\",i,c[i]);        }        //system(\"pause\");        for(m=0;m<size;m++) //记录c中数字（c——>d)        {             if(c[m]!='\\n')             {                 if(c[m]<='9'&&c[m]>='0')                 {                     sscanf(&c[m],\"%d\",&d[m]);                     printf(\"c[%d]=%c \",m,c[m]);                     printf(\"d[%d]=%d \",m,d[m]);                  }             }             else break;          }         result=d[0];         printf(\"result0=%d\\n\",result);          //以下为加减计算部分         for(m=0;m<size-2*tmp;m++)  //size-2*tmp为进行乘除后的总字符数         {           if(c[m]!='\\n')           {             if(c[m]=='-')               {                   printf(\"d[%d]=%d \",m+1,d[m+1]);                   result-=d[m+1];               }               else if(c[m]=='+')               {                   result+=d[m+1];               }           }           else break;        }        printf(\"result=%d\",result);          }  //hw 附加题 //请输入参与计算数字的个数： //6 //请输入算式： //1+2*3+1*5+4 //n[0]=1 n[2]=2 n[4]=3 n[6]=1 n[8]=5 n[10]=4 c[0]=1 //c[1]=+ //c[2]=6 //c[3]=+ //c[4]=5 //c[5]=+ //c[6]=4 //c[0]=1 d[0]=1 c[2]=6 d[2]=6 c[4]=5 d[4]=5 c[6]=4 d[6]=4 result0=1 //result=16请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "麻烦帮忙看看。。。", "referer": "user-0"}]}
{"question": "求指点！VC++的几道题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不明白，看不懂是个什么鬼？看不懂什么？如果代码看不懂是基础问题～  求平均数：代码里看到s变量，很明显没有定义，double/float s;首先需要定义，然后循环次数i <= 10，因为i从1开始；  s /= 10;求平均值的；  7.头文件,题目6已经给了，如果这个也不懂，其实下一个问题问一下自己，懂什么？学这个编程做啥？  第二个空，通过输出的是n，很明显要把结果赋值给n；在比较n和c,很明显将小的赋值给n；即n = c; 8. break；退出循环；m是最小，n是最大；  努努力，或许结果会不一样～", "referer": "user-0"}]}
{"question": "关于位移运算，下面这段话是什么意思，感谢指教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "找理由的话，一旦移位超过w位，按照正常移法就应该全是0了，所以不如直接赋值0更干脆。 所以设计者们大概认为用户不会做这种无聊的事，于是他们决定让这些操作“有聊”一些？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 forever74 的回复:log2(32)的值是5 这句话的意思是，对于移位运算符的右操作数来说，起作用的是低端的5个二进制位。 也就是把32啊，36啊，40啊这些东西都先切掉第6位以及左边的内容再用，也就是先&0x1f 也就是等价于先%32  图片里也说了，C语言规范不规定这个，所以对C程序来说，不能依赖这个“规律”。  感谢。还有一个问题请教一下。 c语言的规范，既然没说对“大数”还是“小数”起作用，那应该是不分大数和小数啊。  比如，某游乐园说自己的门票是 10 块钱，“并没有分别说小孩、成人、老人收多少钱”。 那这个价格应该是所有群体都生效啊。  是不是在实现编译器时，大的位移量有什么难言之隐？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "log2(32)的值是5 这句话的意思是，对于移位运算符的右操作数来说，起作用的是低端的5个二进制位。 也就是把32啊，36啊，40啊这些东西都先切掉第6位以及左边的内容再用，也就是先&0x1f 也就是等价于先%32  图片里也说了，C语言规范不规定这个，所以对C程序来说，不能依赖这个“规律”。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "移动的位数，是这个数对求余  例如<<32 则是移动0 因为32%32=0； >>36 则36%32 等于=4； 40下同", "referer": "user-0"}]}
{"question": "【C语言求助】幼儿园计算器(1位数加减)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 飞禽走兽卍一2b 的回复:快被整疯了，虽然这已经是最简单的计算器了研究和计算机对话的方式，让它听你的，加油！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {         //{  //这里多了‘{’        printf(\"hw 附加题\\n\");        int i,j=0,result,sz;        printf(\"请输入参与计算数字的个数：\\n\");        scanf(\"%d\",&sz);    /*sz是计算数字个数，控制一下循环条件，防止后面出现多余的奇怪的项*/        getchar();  //吸收回车        printf(\"请输入算式：\\n\");        char *a = new char[2*sz-1],*n = new char[2*sz-1],tmp;//char a[2*sz-1],n[2*sz-1],tmp;        gets(a);                                             //动态的char[]      //这一段是将字符转化为整型       for(int i=0;i<2*sz-1;i++)           {               if(a[i]!='\\n')  //遇回车结束，然并卵               {                   if(a[i]<='9'&&a[i]>='0')                   {                       n[i]=a[i]-'0';                      printf(\"n[%d]=%d \",i,n[i]);                    }               }               else break;            }       result=n[0];                                        // printf(\"result0=%d\",result);                                        //下面这段就是计算加减       for(i=0;i<2*sz-1;i++)        {                       if(a[i]!='\\n')           {                if(a[i]=='-')//if(a[i]='45')//这里是‘== ’ //减号的ASCII码为45               {                   printf(\"n[%d]=%d \",i+1,n[i+1]);                   result-=n[i+1];               }               else if(a[i]=='+')//else if(a[i]='43') 这里是‘==’ //加号               {                   result+=n[i+1];               }           }           else break;        }        printf(\"result=%d\",result);        delete []a;delete []n;         } 那个*a  *n 我们好像还没学", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {         //{  //这里多了‘{’        printf(\"hw 附加题\\n\");        int i,j=0,result,sz;        printf(\"请输入参与计算数字的个数：\\n\");        scanf(\"%d\",&sz);    /*sz是计算数字个数，控制一下循环条件，防止后面出现多余的奇怪的项*/        getchar();  //吸收回车        printf(\"请输入算式：\\n\");        char *a = new char[2*sz-1],*n = new char[2*sz-1],tmp;//char a[2*sz-1],n[2*sz-1],tmp;        gets(a);                                             //动态的char[]      //这一段是将字符转化为整型       for(int i=0;i<2*sz-1;i++)           {               if(a[i]!='\\n')  //遇回车结束，然并卵               {                   if(a[i]<='9'&&a[i]>='0')                   {                       n[i]=a[i]-'0';                      printf(\"n[%d]=%d \",i,n[i]);                    }               }               else break;            }       result=n[0];                                        // printf(\"result0=%d\",result);                                        //下面这段就是计算加减       for(i=0;i<2*sz-1;i++)        {                       if(a[i]!='\\n')           {                if(a[i]=='-')//if(a[i]='45')//这里是‘== ’ //减号的ASCII码为45               {                   printf(\"n[%d]=%d \",i+1,n[i+1]);                   result-=n[i+1];               }               else if(a[i]=='+')//else if(a[i]='43') 这里是‘==’ //加号               {                   result+=n[i+1];               }           }           else break;        }        printf(\"result=%d\",result);        delete []a;delete []n;         } 好好好，我慢慢看", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "快被整疯了，虽然这已经是最简单的计算器了", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {         //{  //这里多了‘{’        printf(\"hw 附加题\\n\");        int i,j=0,result,sz;        printf(\"请输入参与计算数字的个数：\\n\");        scanf(\"%d\",&sz);    /*sz是计算数字个数，控制一下循环条件，防止后面出现多余的奇怪的项*/        getchar();  //吸收回车        printf(\"请输入算式：\\n\");        char *a = new char[2*sz-1],*n = new char[2*sz-1],tmp;//char a[2*sz-1],n[2*sz-1],tmp;        gets(a);                                             //动态的char[]      //这一段是将字符转化为整型       for(int i=0;i<2*sz-1;i++)           {               if(a[i]!='\\n')  //遇回车结束，然并卵               {                   if(a[i]<='9'&&a[i]>='0')                   {                       n[i]=a[i]-'0';                      printf(\"n[%d]=%d \",i,n[i]);                    }               }               else break;            }       result=n[0];                                        // printf(\"result0=%d\",result);                                        //下面这段就是计算加减       for(i=0;i<2*sz-1;i++)        {                       if(a[i]!='\\n')           {                if(a[i]=='-')//if(a[i]='45')//这里是‘== ’ //减号的ASCII码为45               {                   printf(\"n[%d]=%d \",i+1,n[i+1]);                   result-=n[i+1];               }               else if(a[i]=='+')//else if(a[i]='43') 这里是‘==’ //加号               {                   result+=n[i+1];               }           }           else break;        }        printf(\"result=%d\",result);        delete []a;delete []n;         }", "referer": "user-0"}]}
{"question": "求求帮忙看一下C语言的编程题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 朕守山河的回复:忘记加注释，就是将小时转化分钟，然后相减得相差分钟，再格式化转化为小时 了解啦，蟹蟹😀", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 赵4老师的回复:#include <stdio.h> int main() {     char ln[80];     int H1,M1,H2,M2;     int d;      while (1) {         rewind(stdin);         fgets(ln,80,stdin);         if (4==sscanf(ln,\"%2d:%2d %2d:%2d\",&H1,&M1,&H2,&M2)) {             if (0<=H1 && H1<=23              && 0<=M1 && M1<=59              && 0<=H2 && H2<=23              && 0<=M2 && M2<=59) break;         }         printf(\"H1:M1 H2:M2 format error. Input again\\n\");     }     d=H2*60+M2-(H1*60+M1);     printf(\"%d:%02d\\n\",d/60,d%60);     return 0; } //输入10:30 11:45 //输出1:15   对的对的，蟹蟹蟹蟹😁", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "printf(\"%d:%02d\\n\",d/60,(d%60>0)?(d%60):-(d%60));", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h> int main() {     char ln[80];     int H1,M1,H2,M2;     int d;      while (1) {         rewind(stdin);         fgets(ln,80,stdin);         if (4==sscanf(ln,\"%2d:%2d %2d:%2d\",&H1,&M1,&H2,&M2)) {             if (0<=H1 && H1<=23              && 0<=M1 && M1<=59              && 0<=H2 && H2<=23              && 0<=M2 && M2<=59) break;         }         printf(\"H1:M1 H2:M2 format error. Input again\\n\");     }     d=H2*60+M2-(H1*60+M1);     printf(\"%d:%02d\\n\",d/60,d%60);     return 0; } //输入10:30 11:45 //输出1:15", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "忘记加注释，就是将小时转化分钟，然后相减得相差分钟，再格式化转化为小时", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "你要的纯C #include <stdio.h>  int analysisHourAndMin(char* pTime); void main() { \tchar preTime[] = \"10:30\"; \tchar nexTime[] = \"11:45\";  \tint nPreTime = analysisHourAndMin(preTime); \tint nNextTime = analysisHourAndMin(nexTime);  \tint nCurTime = nNextTime - nPreTime; \tprintf(\"%d: %d\", nCurTime / 60, nCurTime % 60); \t }  int analysisHourAndMin(char* pTime) { \tint nHour = (pTime[0] - '0') * 10 + (pTime[1] - '0'); \tint nMin = (pTime[3] - '0') * 10 + (pTime[4] - '0'); \treturn nHour * 60 + nMin; }", "referer": "user-0"}]}
{"question": "【C语言求助】一位数计算器(个人)中的一部分", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复:#include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> //无用 void main() {       // {        printf(\"hw 附加题\\n\");        int i,j=0,n[1000];         char a[1000],tmp[2];        gets(a);     //输入字符串如：1-2        for(int k=0;;k++)            {                if(a[k]<='9'&&a[k]>='0') //如果字符为数字                {                    tmp[0]=a[k];tmp[1]= '\\0';                    printf(\"tmp=%s\\n\",tmp);                    sscanf(tmp,\"%d\",&n[j]);  //将字符转化为整型                     printf(\"n[%d]=%d \",j,n[j]);                }                else if(a[k]=='\\n')  //遇到回车结束                {                    break;                }            }         } 说实话，没太看懂。。。tmp定义是做什么的啊？我原来的代码里tmp好像没啥用。。。  还有就是，你的蓝色背景的代码是怎么贴上去的啊？  哦，最最重要的还是我发的另一个帖子。。快被整疯了，麻烦看一下", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复:#include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> //无用 void main() {       // {        printf(\"hw 附加题\\n\");        int i,j=0,n[1000];         char a[1000],tmp[2];        gets(a);     //输入字符串如：1-2        for(int k=0;;k++)            {                if(a[k]<='9'&&a[k]>='0') //如果字符为数字                {                    tmp[0]=a[k];tmp[1]= '\\0';                    printf(\"tmp=%s\\n\",tmp);                    sscanf(tmp,\"%d\",&n[j]);  //将字符转化为整型                     printf(\"n[%d]=%d \",j,n[j]);                }                else if(a[k]=='\\n')  //遇到回车结束                {                    break;                }            }         } 谢谢！ 我还有一个帖子，麻烦看看吧X﹏X", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> //无用 void main() {       // {        printf(\"hw 附加题\\n\");        int i,j=0,n[1000];         char a[1000],tmp[2];        gets(a);     //输入字符串如：1-2        for(int k=0;;k++)            {                if(a[k]<='9'&&a[k]>='0') //如果字符为数字                {                    tmp[0]=a[k];tmp[1]= '\\0';                    printf(\"tmp=%s\\n\",tmp);                    sscanf(tmp,\"%d\",&n[j]);  //将字符转化为整型                     printf(\"n[%d]=%d \",j,n[j]);                }                else if(a[k]=='\\n')  //遇到回车结束                {                    break;                }            }         }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:这句改为： sscanf(&a[k],\"%d\",&n[j]);  //将字符转化为整型 发了发了，帖子", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:这句改为： sscanf(&a[k],\"%d\",&n[j]);  //将字符转化为整型 转化的问题，我用另一种方法解决了，结果又碰到另一个bug。超级奇怪，麻烦看一下", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "这句改为： sscanf(&a[k],\"%d\",&n[j]);  //将字符转化为整型", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 user-3的回复:你的sscanf读的是a啊，也就是从头读起。 那我怎么样才能把a[i]一一对应的转化为n[i]？", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "你的sscanf读的是a啊，也就是从头读起。", "referer": "user-0"}]}
{"question": "c语言指针复杂定义", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 4 楼 脚味 的回复:[quote=引用 2 楼 自信男孩 的回复：]char *func（int **p 这个是函数变量；  可以用a[0] = func;这样赋值；也可以a[0] = &func;  调用可以用a[0](p); 例子如下：  #include <stdio.h>  char *func(int **a);  int main(void) {     int **p = NULL;     char *(*a[3])(int **);      //两种写法一样的     //a[0] = func;     a[0] = &func;      a[0](p);      return 0; }  char *func(int **a) {     printf(\"%p\\n\", a);      printf(\"helloworld!\\n\");     return NULL; }  因为func函数名就是地址名，加不加&都是可以的。不是很懂，char *func （int **a）意思是这个函数参数是int 二级指针，返回的是char类型指针对吗？ [/quote]  函数名前面的是返回值类型，char * func(int **a);char *是返回值类型；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 5 楼 真相重于对错 的回复：#include <stdio.h> char* f1(int**){     printf(\"%s\", __FUNCTION__);     return nullptr; } char* f2(int**){     printf(\"%s\", __FUNCTION__);     return nullptr; } char* f3(int** ){     printf(\"%s\", __FUNCTION__);      return nullptr; } char* (*a[3])(int** p) {f1,f2,f3};  int main(){     a[0](nullptr);     a[1](nullptr);     a[2](nullptr);          }老师可以不传入空参数吗？来个稍微复杂的", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "是不是char *func（int **p）这个函数接受一个类型是int的二级指针然后返回一个值是char类型的指针，这样理解对吗", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "#include <stdio.h> char* f1(int**){     printf(\"%s\", __FUNCTION__);     return nullptr; } char* f2(int**){     printf(\"%s\", __FUNCTION__);     return nullptr; } char* f3(int** ){     printf(\"%s\", __FUNCTION__);      return nullptr; } char* (*a[3])(int** p) {f1,f2,f3};  int main(){     a[0](nullptr);     a[1](nullptr);     a[2](nullptr);          }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复：char *func（int **p 这个是函数变量；  可以用a[0] = func;这样赋值；也可以a[0] = &func;  调用可以用a[0](p); 例子如下：  #include <stdio.h>  char *func(int **a);  int main(void) {     int **p = NULL;     char *(*a[3])(int **);      //两种写法一样的     //a[0] = func;     a[0] = &func;      a[0](p);      return 0; }  char *func(int **a) {     printf(\"%p\\n\", a);      printf(\"helloworld!\\n\");     return NULL; }  因为func函数名就是地址名，加不加&都是可以的。不是很懂，char *func （int **a）意思是这个函数参数是int 二级指针，返回的是char类型指针对吗？", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复：char *(*a[3])(int **p) 代表是一个3个元素的数组，其中的元素类型是 char* func(int**)  这就是一个函数，这个函数的返回值是char* 参数是int**意思是数组里面三个元素都是返回类型是char 指针的函数这个函数的参数是int的二级指针。对吗？老师", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "char *func（int **p 这个是函数变量；  可以用a[0] = func;这样赋值；也可以a[0] = &func;  调用可以用a[0](p); 例子如下：  #include <stdio.h>  char *func(int **a);  int main(void) {     int **p = NULL;     char *(*a[3])(int **);      //两种写法一样的     //a[0] = func;     a[0] = &func;      a[0](p);      return 0; }  char *func(int **a) {     printf(\"%p\\n\", a);      printf(\"helloworld!\\n\");     return NULL; }  因为func函数名就是地址名，加不加&都是可以的。", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "char *(*a[3])(int **p) 代表是一个3个元素的数组，其中的元素类型是 char* func(int**)  这就是一个函数，这个函数的返回值是char* 参数是int**", "referer": "user-0"}]}
{"question": "请问一下 为什么会不断输入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1.scanf()读数据碰到空白符就停止输入。 2.scanf()忽略缓冲区中先导的空白符。 3.当参数为%c的时候，返回缓冲区中第一个字符，包括空白符。 也就是说，在这行代码\"scanf(\"%d\\n\");中要让缓冲区读两次，才能停止scanf();，第一次缓冲区读入%d后碰到回车，程序停止等待读入\\n，由于忽略先导的空白符，程序一直在等待，直到遇到一个非空白符才继续读入。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "去掉scanf中的\\n，否则无法结束输入～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "输入成绩的个数，scanf (“%d \\n”,&n);里面多了\\n。", "referer": "user-0"}]}
{"question": "C语言，程序错误怎么改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "编译出错，还是运行出错？总得有一个错误内容吧～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "提问要把出错信息带着一起贴，别让人猜。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "要是用个新点的IDE，通过变色你早就发现了。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "明显缺半边双引号", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "仿佛能猜到是什么问题，你把return 1.0;和resule *= n--;这两句话分别用个大括号括起来试试呢", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "这个我换了个", "referer": "user-0"}]}
{"question": "一个菱形画不出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主代码，只输出菱形上半部，见注释：#include \"stdio.h\" int main() {   int i;   int j;   int k;   for(i=1;i<=4;i++)    {     for(j=3;j>=i;j--)    //{ 这里多了‘{’       {          printf(\" \");       }     for(k=1;k<=2*i-1;k++) //for(k=1;k<2*i-1;k++) 中间 k<2*i-1少了‘=’号       {          printf(\"*\");       }     printf(\"\\n\");        //} 这里多了‘}’    }      for(i=3;i>=1;i--)    //增加下半部    {     for(j=3;j>=i;j--)       {          printf(\" \");       }     for(k=1;k<=2*i-1;k++)       {          printf(\"*\");       }     printf(\"\\n\");    }    getchar();    return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 sweetswing 的回复:[quote=引用 1 楼 赵4老师 的回复:]学会单步调试 这个软件不带调试功能[/quote] 不带调试你可以在想调试的地方插入比如 printf(\"i,j,k:%d,%d,%d\\n\",i,j,k);getchar(); 调试。 按一次回车，执行一步。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:学会单步调试 这个软件不带调试功能", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "学会单步调试", "referer": "user-0"}]}
{"question": "结构体问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。 谢啦兄弟，差不多懂了", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 focuslight的回复:没有你这种写法的，像是结构体初始化又不规范。带函数的结构体，实际上就是 class. 只不过它的函数 都属 public. 你可以在主函数内建一个 它的 对象。用 对象的成员成员函数调用。struct stu a;      a.fun(1); 谢啦兄弟，差不多懂了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-5的回复:供参考：#include <stdio.h>  struct stu{        int fun (int a)        {            printf(\"i am fun!\\n\");        } };  int main() {      struct stu a;      a.fun(1);       } 谢啦兄弟，差不多懂了", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 6 楼 NorZ 的回复:[quote=引用 5 楼 自信男孩 的回复:][quote=引用 4 楼 NorZ 的回复:][quote=引用 3 楼 自信男孩 的回复:]没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...[/quote]  #include <stdio.h>   struct stu{        int fun (int a)        {            printf(\"i am fun!\\n\");        } };   int main() {      struct stu a;      a.fun(1);        }  这个是编译过去的，并且还正常运行。你说的不支持，是不支持什么内容？不支持这么定义结构体？[/quote]   楼主的代码[/quote] 楼主代码是语法问题，楼主的问题是结构体。这是两个问题好不好。我回答的是结构体问题～", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 5 楼 自信男孩 的回复:[quote=引用 4 楼 NorZ 的回复:][quote=引用 3 楼 自信男孩 的回复:]没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...[/quote]  #include <stdio.h>   struct stu{        int fun (int a)        {            printf(\"i am fun!\\n\");        } };   int main() {      struct stu a;      a.fun(1);        }  这个是编译过去的，并且还正常运行。你说的不支持，是不支持什么内容？不支持这么定义结构体？[/quote]   楼主的代码", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 4 楼 NorZ 的回复:[quote=引用 3 楼 自信男孩 的回复:]没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...[/quote]  #include <stdio.h>   struct stu{        int fun (int a)        {            printf(\"i am fun!\\n\");        } };   int main() {      struct stu a;      a.fun(1);        }  这个是编译过去的，并且还正常运行。你说的不支持，是不支持什么内容？不支持这么定义结构体？", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 3 楼 自信男孩 的回复:没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "没有你这种写法的，像是结构体初始化又不规范。带函数的结构体，实际上就是 class. 只不过它的函数 都属 public. 你可以在主函数内建一个 它的 对象。用 对象的成员成员函数调用。struct stu a;      a.fun(1);", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "供参考：#include <stdio.h>  struct stu{        int fun (int a)        {            printf(\"i am fun!\\n\");        } };  int main() {      struct stu a;      a.fun(1);       }", "referer": "user-0"}]}
{"question": "上位机串口通讯的问题，怎么区分我收到的数据？求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你可以按500ms周期来发送 周期1 查询第一个，收到的数据无论是什么都放在第一个文本框 周期2 查询第二个，放到第二个文本框  这样从全局上看，还是一秒一个周期 需要客户端配合在500ms内可以回复", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "根据单片机返回的数据格式，进行解析", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "每秒发送一次 命令查电流 和 命令查电压 ？如果是这样你为了更准确需要定义返回格式来区别，   还是间隔一秒发一次命令（两个命令是轮询模式）  这个模式你可以依据你命令来判断回复，是可以的", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "要相信对面 你先查的是啥，对面先发的就是啥。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 focuslight 的回复:你需要和单片机程序定个通讯协议吧，在数据前加上标识 单片机的程序不用改，那个已经有上位机软件了，我只是要重做一个。", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "你需要和单片机程序定个通讯协议吧，在数据前加上标识", "referer": "user-0"}]}
{"question": "c++新人求教为什么程序报错 如何修改程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没有提供Circle的有参构造函数", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include <iostream> using namespace std; class Circle {     private:            double r;     public:            void Show()             {                cout<<\"面积=\"<<3.14*r*r<<endl;             }            Circle()//computer()//类构造函数名和类名是一样的             {                r=10;             }            Circle(double a)//computer(double a)             {               r=a;             } };  int main()   {      double r1;      cin>>r1;    Circle a,b(r1);      a.Show();      b.Show();     return 0; }", "referer": "user-0"}]}
{"question": "关于学生成绩管理系统排序问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主，这个链表是表头插入法，插入的最后一个节点就是表头，所以排序也是从最后一个开始的，而不是k=p->pNext 开始，修改如下见标注，供参考：#include<stdio.h> #include<conio.h> #include<stdlib.h> #include<string.h>  //定义一个学生的信息 typedef struct _Student {   int total;      //总成绩 }Student;  //定义一个节点 typedef struct _Node {    Student stu;//学生    struct _Node* pNext; }Node;  Node*g_pHead=NULL;             //头结点  void Menu();//菜单界面函数 void Input_m();//成绩录入函数 void Print();//成绩显示函数 void Save();//成绩保存函数 void Order();//成绩排序函数 void Modify();//成绩修改函数 void Sta();//声明成绩统计函数  int main() {     int a;     while(1){  //while循环使程序持续运行              Menu();              scanf(\"%d\",&a);              switch(a)//**用户进行选择**//                    {                       case 1:                            Input_m(); //成绩录入                            break;                       case 2:                            Print();//成绩显示                            break;                       case 4:                            Order();//成绩排序                            break;                       case 7:                           printf(\"您已成功退出系统，欢迎下次使用！\\n\");                           return 0;                      default:                           printf(\"无效选择，请重新输入\\n\");                           system(\"pause\");                           system(\"cls\");                           break;              }     }     return 0; }  void Menu()//菜单界面函数  {         printf(\"\\t\\t\\t欢迎使用学生班级成绩管理系统！\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t          主菜单                   ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t\\t1.成绩录入                 ==\\n\");         printf(\"\\t\\t==\\t\\t2.成绩显示                 ==\\n\");         printf(\"\\t\\t==\\t\\t4.成绩排序                 ==\\n\");         printf(\"\\t\\t==\\t\\t7.系统退出                 ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t===========请选择相应的功能列表==============\\n\");      } void Input_m()//成绩录入函数 {     Node* pNewNode =(Node*)malloc(sizeof(Node));//创建一个新节点     pNewNode->pNext=NULL;     if(g_pHead==NULL)       {         g_pHead=pNewNode;       }     else       {         pNewNode->pNext=g_pHead;         g_pHead=pNewNode;       }     printf(\"请输入学生的总成绩：\\n\");     scanf(\"%d\",&pNewNode->stu.total);     printf(\"学生成绩录入成功！\\n\");     system(\"pause\");      //暂停执行     system(\"cls\");        //清屏 }  void Print()//成绩显示函数  {     system(\"cls\");     printf(\"                     学生成绩表                         \\n\");     printf(\"========================================================\\n\");     printf(\"总成绩\\n\");      //遍历链表，一次打印出学生的成绩     Node* p=g_pHead;     while(p!=NULL)      {         printf(\"%d \\n\",p->stu.total);         p=p->pNext;//指向下一个，少了这个会无限循环      }     system(\"pause\"); }  int trival(Node*g_pHead) {     Node* p=g_pHead;     int i=0;     Node* w;     w = p;             //w=p->pNext ;  //这句修改     while(w!=NULL)     {       w=w->pNext ;       i++;     }     return i; }  void Order()//总成绩排序函数 {     Node* p=g_pHead;     Node* k,*q;     int n,i,j;     Student temp;     n=trival(g_pHead);                    //这句修改     for(i=0,k=p ;i<n-1;i++,k=k->pNext )   //for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )       {         for(j=i+1,q=k->pNext; j<n ; q=q->pNext ,j++)           {               if(k->stu.total> q->stu.total )                 {                    temp=k->stu ;                    k->stu =q->stu ;                    q->stu =temp;                 }           }       }     printf(\"总成绩由低到高依次排序为：\\n\");     while(p!=NULL){          printf(\"%d\\n\",p->stu.total);          p=p->pNext;     }     system(\"pause\");     system(\"cls\"); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 user-1 的回复:我算知道毛病了，我改的是： 楼主改的：   我改的： 楼主改的：  两条语句，楼主一句未改？ 哦哦哦，对不起对不起，我看错了，能像你那样子运行了，问题已经解决了，谢谢你！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "第114行 ：w=p; 第 130行：for(i=0,k=p; i<n-1; i++,k=k->pNext)", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "我算知道毛病了，我改的是： 楼主改的：   我改的： 楼主改的：  两条语句，楼主一句未改？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "这是按楼主的步骤，按改过的代码运行（ w =p->pNext; //w=p->pNext ;  //这句修改（已改）   for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )   //for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )（已改）），执行的结果，已经没有楼主讲的问题了：//按楼主讲的步骤： //录入第一个数：                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 1 学生成绩录入成功！ 请按任意键继续. . .   //录入第二个数：                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 2 学生成绩录入成功！ 请按任意键继续. . .   //录入第三个数：                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 3 学生成绩录入成功！ 请按任意键继续. . .   //然后执行排序；                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为：  //这里也正常 1 2 3 请按任意键继续. . .  //选择 2.成绩显示  看看排序     这里没有乱序                       学生成绩表 ======================================================== 总成绩 1 2 3 请按任意键继续. . .    //继续再输入一个新的成绩                       学生成绩表 ======================================================== 总成绩 1 2 3 请按任意键继续. . .                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 10 学生成绩录入成功！ 请按任意键继续. . .    //再执行排序 //【前面三个成绩就可以正常排序了，但是第四个录进来的成绩就没有 】？？？？？？？？ //【也就是说每次排序最后一个录入的成绩总是不能参与到排序过程中。】？？？？？？？                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为：//这里四个数 1 2 3 10 请按任意键继续. . .    //到这里再多加一步，选择 2.成绩显示 ，第四个也在                     学生成绩表 ======================================================== 总成绩 1 2 3 10 请按任意键继续. . .", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 user-1 的回复:不存在了。表头插入法，就是每次输入一个数据时，在没有排序的情况下，最后这个输入的数据是排在第一位的，也就是倒序（这个倒序是指和输入的顺序相反，先入后出）的，最早输入的显示在最后一个。//这里随便输入三个数字，然后选择2 成绩显示：                       学生成绩表 ======================================================== 总成绩 6 0 3 请按任意键继续. . .  //这里是选择 4 成绩排序                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为： 0 3 6 请按任意键继续. . .  //这里是先选择 1.成绩录入 ，增加一个数10，然后选择2.成绩显示 ，10是最后加入的数字，在没有排序的时候 //它就是第一个，它就是表头。                       学生成绩表 ======================================================== 总成绩 10 0 3 6 请按任意键继续. . .   //这里是选择  4.成绩排序 。如果这时后接下去选择2.成绩显示，它就是显示已经排序好的排列了。                      学生成绩表 ======================================================== 总成绩 10 0 3 6 请按任意键继续. . .                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为： 0 3 6 10 请按任意键继续. . .  啊这。。。是修改了那两处对吧？我是按你标的来改的呀。 #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<string.h>   //定义一个学生的信息 typedef struct _Student {   int total;      //总成绩 }Student;   //定义一个节点 typedef struct _Node {    Student stu;//学生    struct _Node* pNext; }Node;   Node*g_pHead=NULL;             //头结点   void Menu();//菜单界面函数 void Input_m();//成绩录入函数 void Print();//成绩显示函数 void Save();//成绩保存函数 void Order();//成绩排序函数 void Modify();//成绩修改函数 void Sta();//声明成绩统计函数   int main() {     int a;     while(1){  //while循环使程序持续运行              Menu();              scanf(\"%d\",&a);              switch(a)//**用户进行选择**//                    {                       case 1:                            Input_m(); //成绩录入                            break;                       case 2:                            Print();//成绩显示                            break;                       case 4:                            Order();//成绩排序                            break;                       case 7:                           printf(\"您已成功退出系统，欢迎下次使用！\\n\");                           return 0;                      default:                           printf(\"无效选择，请重新输入\\n\");                           system(\"pause\");                           system(\"cls\");                           break;              }     }     return 0; }   void Menu()//菜单界面函数  {         printf(\"\\t\\t\\t欢迎使用学生班级成绩管理系统！\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t          主菜单                   ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t\\t1.成绩录入                 ==\\n\");         printf(\"\\t\\t==\\t\\t2.成绩显示                 ==\\n\");         printf(\"\\t\\t==\\t\\t4.成绩排序                 ==\\n\");         printf(\"\\t\\t==\\t\\t7.系统退出                 ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t===========请选择相应的功能列表==============\\n\");       } void Input_m()//成绩录入函数 {     Node* pNewNode =(Node*)malloc(sizeof(Node));//创建一个新节点     pNewNode->pNext=NULL;     if(g_pHead==NULL)       {         g_pHead=pNewNode;       }     else       {         pNewNode->pNext=g_pHead;         g_pHead=pNewNode;       }     printf(\"请输入学生的总成绩：\\n\");     scanf(\"%d\",&pNewNode->stu.total);     printf(\"学生成绩录入成功！\\n\");     system(\"pause\");      //暂停执行     system(\"cls\");        //清屏 }   void Print()//成绩显示函数  {     system(\"cls\");     printf(\"                     学生成绩表                         \\n\");     printf(\"========================================================\\n\");     printf(\"总成绩\\n\");      //遍历链表，一次打印出学生的成绩     Node* p=g_pHead;     while(p!=NULL)      {         printf(\"%d \\n\",p->stu.total);         p=p->pNext;//指向下一个，少了这个会无限循环      }     system(\"pause\"); }   int trival(Node*g_pHead) {     Node* p=g_pHead;     int i=0;     Node* w;     w =p->pNext;             //w=p->pNext ;  //这句修改（已改）     while(w!=NULL)     {       w=w->pNext ;       i++;     }     return i; }   void Order()//总成绩排序函数 {     Node* p=g_pHead;     Node* k,*q;     int n,i,j;     Student temp;     n=trival(g_pHead);                    //这句修改     for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )   //for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )（已改）       {         for(j=i+1,q=k->pNext; j<n ; j++,q=q->pNext ,j++)           {               if(k->stu.total> q->stu.total )                 {                    temp=k->stu ;                    k->stu =q->stu ;                    q->stu =temp;                 }           }       }     printf(\"总成绩由低到高依次排序为：\\n\");     while(p!=NULL){          printf(\"%d\\n\",p->stu.total);          p=p->pNext;     }     system(\"pause\");     system(\"cls\"); }", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "上面的描述不规范，应该这么说，表头插入法，每次插入一个新节点时，都是把这个新节点作为头节点，所以头节点head始终指向最后录入的数据节点。你可以实验下，比如输入三个数，1 2 3 ，输入完后，选择2.成绩显示，它就是显示 3 2 1。你的代码里有没有文件保存和打开并读入文件的功能，如果有，你就会发现一个问题，当你这次保存时顺序是 1 2 3退出程序后，下次重新运行代码，文件载入时它显示的就是3 2 1.", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "不存在了。表头插入法，就是每次输入一个数据时，在没有排序的情况下，最后这个输入的数据是排在第一位的，也就是倒序（这个倒序是指和输入的顺序相反，先入后出）的，最早输入的显示在最后一个。//这里随便输入三个数字，然后选择2 成绩显示：                       学生成绩表 ======================================================== 总成绩 6 0 3 请按任意键继续. . .  //这里是选择 4 成绩排序                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为： 0 3 6 请按任意键继续. . .  //这里是先选择 1.成绩录入 ，增加一个数10，然后选择2.成绩显示 ，10是最后加入的数字，在没有排序的时候 //它就是第一个，它就是表头。                       学生成绩表 ======================================================== 总成绩 10 0 3 6 请按任意键继续. . .   //这里是选择  4.成绩排序 。如果这时后接下去选择2.成绩显示，它就是显示已经排序好的排列了。                      学生成绩表 ======================================================== 总成绩 10 0 3 6 请按任意键继续. . .                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为： 0 3 6 10 请按任意键继续. . .", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 user-1 的回复:楼主，这个链表是表头插入法，插入的最后一个节点就是表头，所以排序也是从最后一个开始的，而不是k=p->pNext 开始，修改如下见标注，供参考：#include<stdio.h> #include<conio.h> #include<stdlib.h> #include<string.h>  //定义一个学生的信息 typedef struct _Student {   int total;      //总成绩 }Student;  //定义一个节点 typedef struct _Node {    Student stu;//学生    struct _Node* pNext; }Node;  Node*g_pHead=NULL;             //头结点  void Menu();//菜单界面函数 void Input_m();//成绩录入函数 void Print();//成绩显示函数 void Save();//成绩保存函数 void Order();//成绩排序函数 void Modify();//成绩修改函数 void Sta();//声明成绩统计函数  int main() {     int a;     while(1){  //while循环使程序持续运行              Menu();              scanf(\"%d\",&a);              switch(a)//**用户进行选择**//                    {                       case 1:                            Input_m(); //成绩录入                            break;                       case 2:                            Print();//成绩显示                            break;                       case 4:                            Order();//成绩排序                            break;                       case 7:                           printf(\"您已成功退出系统，欢迎下次使用！\\n\");                           return 0;                      default:                           printf(\"无效选择，请重新输入\\n\");                           system(\"pause\");                           system(\"cls\");                           break;              }     }     return 0; }  void Menu()//菜单界面函数  {         printf(\"\\t\\t\\t欢迎使用学生班级成绩管理系统！\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t          主菜单                   ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t\\t1.成绩录入                 ==\\n\");         printf(\"\\t\\t==\\t\\t2.成绩显示                 ==\\n\");         printf(\"\\t\\t==\\t\\t4.成绩排序                 ==\\n\");         printf(\"\\t\\t==\\t\\t7.系统退出                 ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t===========请选择相应的功能列表==============\\n\");      } void Input_m()//成绩录入函数 {     Node* pNewNode =(Node*)malloc(sizeof(Node));//创建一个新节点     pNewNode->pNext=NULL;     if(g_pHead==NULL)       {         g_pHead=pNewNode;       }     else       {         pNewNode->pNext=g_pHead;         g_pHead=pNewNode;       }     printf(\"请输入学生的总成绩：\\n\");     scanf(\"%d\",&pNewNode->stu.total);     printf(\"学生成绩录入成功！\\n\");     system(\"pause\");      //暂停执行     system(\"cls\");        //清屏 }  void Print()//成绩显示函数  {     system(\"cls\");     printf(\"                     学生成绩表                         \\n\");     printf(\"========================================================\\n\");     printf(\"总成绩\\n\");      //遍历链表，一次打印出学生的成绩     Node* p=g_pHead;     while(p!=NULL)      {         printf(\"%d \\n\",p->stu.total);         p=p->pNext;//指向下一个，少了这个会无限循环      }     system(\"pause\"); }  int trival(Node*g_pHead) {     Node* p=g_pHead;     int i=0;     Node* w;     w = p;             //w=p->pNext ;  //这句修改     while(w!=NULL)     {       w=w->pNext ;       i++;     }     return i; }  void Order()//总成绩排序函数 {     Node* p=g_pHead;     Node* k,*q;     int n,i,j;     Student temp;     n=trival(g_pHead);                    //这句修改     for(i=0,k=p ;i<n-1;i++,k=k->pNext )   //for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )       {         for(j=i+1,q=k->pNext; j<n ; q=q->pNext ,j++)           {               if(k->stu.total> q->stu.total )                 {                    temp=k->stu ;                    k->stu =q->stu ;                    q->stu =temp;                 }           }       }     printf(\"总成绩由低到高依次排序为：\\n\");     while(p!=NULL){          printf(\"%d\\n\",p->stu.total);          p=p->pNext;     }     system(\"pause\");     system(\"cls\"); }  按这个改完执行程序后原来的问题还是在的呀", "referer": "user-0"}]}
{"question": "关于栈和队列", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "S和Q都是指向NULL的指针，NULL是不可以读写的，所以S->top这样的操作是对S的写操作，会出现多错误；  建议将S和Q先指向一个可以正常读写的位置，这个位置可以是栈上的，也可以是堆上的(malloc/free, new/delete）。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你描述了班长的特征和权限，但你还没有任命任何一个学生做班长。 这时候你就想让班长履行职责了，于是就出错了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "S是类型定义，没有实例化，内存中这样其实还没有实际给分配出空间，不可以给赋值 temp_s=new SeqStack; temp_s->top=0;", "referer": "user-0"}]}
{"question": "【C语言】请帮忙看一下这段代码，谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-2 的回复：可改作： return p+n-1;谢谢您的指导", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "可改作： return p+n-1;", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "第一，你的solve函数return p;而在执行中p没有变过，*solve(nnn)都是p[0]，所以递归那部分不能成立。 第二，这个数列只有前四十多项能用32位整数表示，就算递归弄对了，后面大部分也都是溢出以后没有用的数值了。", "referer": "user-0"}]}
{"question": "【C语言】请帮忙看一下代码！谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "一年了。再看当年那么稚嫩的代码，还真是感叹", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-1 的回复：这里的scanf()改为：scanf(\"%d\",&a[i][j]);谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "这里的scanf()改为：scanf(\"%d\",&a[i][j]);", "referer": "user-0"}]}
{"question": "数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <string.h> int main() {     char buf[]=\"123+321\";     int num[6];     sscanf(buf,\"%1d%1d%1d+%1d%1d%1d\",&num[0],&num[1],&num[2],&num[3],&num[4],&num[5]);     for (int i=0;i<6;i++) printf(\"%d \",num[i]);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "就在串口UART中断处理函数，解析一下字符串，放入数组即可。", "referer": "user-0"}]}
{"question": "小白提问：C++提示interrupted by signal 11: sigsegv", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "哇原来如此！谢谢你！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "越界了 if (range [arr[i]] != -1) { //这句话，因为i最大为6，而arr最多有效元素是6个，所以arr[6]是无效元素，因此越界", "referer": "user-0"}]}
{"question": "c语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "有人吗有人吗", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这个文件的格式，存放的是当前时间，打开文件用fopen(\"time1.txt\",\"r\");fscanf()读入文件的信息，然后输入所需时间scanf(\"%d\",&time); 然后该加就加，不是就算出到达时间了。", "referer": "user-0"}]}
{"question": "这段代码的含义", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 自信男孩 的回复:[quote=引用 2 楼 Star-Sum 的回复:][quote=引用 1 楼 forever74的回复:]你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？[/quote] 未定义说明没有把peekb函数加入进来，没找到定义的地方。这函数不是你写的吗？或者代码没有全部导入到编译器里？[/quote]  应该是TC的一个非标库函数，读硬件寄存器什么的。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这种一看就是和硬件打交道的函数，都是不讲理的。 你得到帮助里去看它的说明，那里边应该有解释哪一位是干什么的。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "哦，那么问题在于编译。 那么编译还有什么错误？我历来主张盯住第一条错误修改，后面的错误回头可能自己就消失了。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 2 楼 Star-Sum 的回复:[quote=引用 1 楼 forever74的回复:]你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？[/quote] 未定义说明没有把peekb函数加入进来，没找到定义的地方。这函数不是你写的吗？或者代码没有全部导入到编译器里？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 forever74的回复:你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "你调用的函数peekb就是做这个用的，读它的说明即可。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 6 楼 forever74 的回复:[quote=引用 3 楼 自信男孩 的回复:][quote=引用 2 楼 Star-Sum 的回复:][quote=引用 1 楼 forever74的回复:]你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？[/quote] 未定义说明没有把peekb函数加入进来，没找到定义的地方。这函数不是你写的吗？或者代码没有全部导入到编译器里？[/quote]  应该是TC的一个非标库函数，读硬件寄存器什么的。[/quote] 那就是头文件的问题了，没引入头文件？", "referer": "user-0"}]}
{"question": "C语言基础题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主代码没问题，简化下，供参考：#include<stdio.h>  int m_sum(int x) {     int t = 0;     while(x){           t += x % 10;           x /= 10;     }     return t; }   int m_cnt_9(int x) {     int  cnt=0;     while (x){          if((x%10) == 9) cnt++;          x /= 10;     }     return cnt; }  int m_fi(int x)//有几个9： {     int i;     int t = 0;     for(i = 1; i < x ;i++){         t += m_cnt_9(i);     }     return t; }   int m_pow(int x) {     x = x * x * x;     return x; }  int m_narcissistic(int y)//水仙花数：（153=1*1*1+5*5*5+3*3*3） {     int b = y, t = 0;     while(y){           t += m_pow(y % 10);           y /= 10;     }     if(t == b){        return 1;     }else{        return 0;     } }  int main() {     int i,x=1000,y=123;      printf(\"%d\\n\",m_sum(y));//位数和      printf(\"%d\\n\",m_fi(x)); //1-1000间9的个数      for(i = 100; i < 1000; i++){  //水仙花数         if (m_narcissistic(i) == 1){             printf(\"%d \", i);         }     }     printf(\"\\n\");          return 0; }", "referer": "user-0"}]}
{"question": "MFC项目加速键使用不了小键盘的减号", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我去,visual studio风格的MFC项目在用数字键盘的减号做加速键时由Insert键响应怎么回事不知道, 但找到解决的办法了, 在项目的类中增加HACCEL m_haccel变量,加载加速键到变量, 再添加PreTranslateMessage函数, 在函数内加代码 if (m_haccel != NULL) { \tTranslateAccelerator(this->m_hWnd, m_haccel, pMsg); } 翻译消息前,翻译一下加速键,问题就解决了!  初步怀疑是visual studio类型的MFC项目中的类关于加速键的默认Translate功能环节有BUG,自己在之前translateaccelerator一下就好了", "referer": "user-0"}]}
{"question": "请问一个关于syslog中时间记录的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我们使用的操作系统相当有弹性，我的意思是，它们不适合做那种时间精密型操作。 因为缓存的存在，写入个文件还有可能被拖后几秒呢。  所以长期运行的软件系统里几秒这种等级的时间误差很难去较真儿。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "原来不是程序问题啊 系统管理员表示一般这种情况不是一段时间没记，而是“那段时间”消失了  一个系统的实时钟随着系统的繁忙程度的提高倾向于偏慢，对表进程拨快时钟的时候看起来就会“消失”一段时间 ntpd或者chronyd之类的进程隔三岔五地修正一下系统时间，你可以对照一下它们的log", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "", "referer": "user-0"}]}
{"question": "同一线程下两个read读取一个串口", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "串口数据我记得有中断的，你要不每个函数都用 select 试试？读不到数据就阻塞，等有新数据了，就读，读完，等下一个函数再 select？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "一个线程read 你把读到的数据放 到两个list里，然后分别两个线程 处理 不同的list就可以了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 7 楼 enthrone的回复:在一个线程里面已经读到数据了。为什么还要再读一边呢？复制不香吗？ 正是因为复制之后对我的程序来说不可靠，所以才来问的，因为在之前公司是用的我说的方法，但是当时没有学那个库函数，难受", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "正是因为复制之后对我的程序来说不可靠，所以才来问的，因为在之前公司是用的我说的方法，但是当时没有学那个库函数，难受", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "在一个线程里面已经读到数据了。为什么还要再读一边呢？复制不香吗？", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "想读取同样的数据？一波数据读两遍？ 恐怕不行。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 4 楼 user-5的回复:读光了数据，一时半会儿没东西可读也很正常啊。 所以我想知道有没有什么方法让两个read都能读取到……", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "读光了数据，一时半会儿没东西可读也很正常啊。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 2 楼 user-5的回复:读呗，还能有啥问题咋的？ 主要是，第一个read读取完之后，为什么第二个read去读取的时候返回值是－1，也就是没东西可读，还有就是这个串口我在读的同时也给里面用write写入数据", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "读呗，还能有啥问题咋的？", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "求大佬指点一二，多谢了！！！", "referer": "user-0"}]}
{"question": "关于声卡采集并显示波形的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://www.mathworks.com/help/audio/ref/audiodevicereader-system-object.html", "referer": "user-0"}]}
{"question": "数据结构", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "多谢大佬解答", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "还有个6也不见了？感觉在这几个地方有问题：判断条件'<'就可以了，'<='下标越界了。", "referer": "user-0"}]}
{"question": "C语言数组解决问题，刚学", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：//产品销售记录包括 产品代码 名称 单价 数量 金额 等信息 //1）编写input函数 输入10个产品销售记录的如上信息 //2）编写sum函数 计算金额 = 单价 * 数量 //3）编写sort函数 按金额从大到小排序  #include<stdio.h> #define PRODUCTS 10 //按题目要求10个产品  void  input(); float sum(float a,int n); void  sort();   typedef struct{ //自定义结构体类型 \tint   code; \tchar  name[21]; \tfloat price; \tint   quantity; }PRODUCT;  PRODUCT products[PRODUCTS];//定义10个产品记录的数组  void main() {       input(); //输入       sort();  //排序,从大到小       for(int i = 0; i < PRODUCTS; i++){ //打印输出        printf(\"code = %d | quantity = %d | price = %.2f | name = %s | sum = %.2f\\n\",              products[i].code,products[i].quantity,products[i].price,products[i].name,              sum(products[i].price,products[i].quantity));       }        }  void input(){      printf(\"Enter example:code,quantity,price,name(30)\\n\");      for(int i = 0; i < PRODUCTS; i++){         scanf(\"%d %d %f %s\", &products[i].code,&products[i].quantity,                                    &products[i].price,products[i].name); \t} }  float sum(float a,int n) {      return a * n; }  void sort(){       PRODUCT temp;       for (int i = 0; i <PRODUCTS -1 ;i++){          for (int k = 0; k < PRODUCTS - 1 -i ;k++){            if((products[k].price * products[k].quantity)<                                   (products[k+1].price * products[k+1].quantity))            {                  temp          = products[k];                  products[k]   = products[k+1];                  products[k+1] = temp;            }          }       } }   //Enter example:code,quantity,price,name(30) //11 20 2.00 aa //22 30 1.00 bb //33 10 3.00 cc //code = 11 | quantity = 20 | price = 2.00 | name = aa | sum = 40.00 //code = 22 | quantity = 30 | price = 1.00 | name = bb | sum = 30.00 //code = 33 | quantity = 10 | price = 3.00 | name = cc | sum = 30.00 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你的代码呢？只看到编译error，没看到代码呢，这怎么帮？你的意思按照你的要求写一个？！", "referer": "user-0"}]}
{"question": "求四舍五入函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  #include <math.h>  double Round(double x, int d) {      double dRetval;      double dMod = 0.0000001;      if (x<0.0) dMod=-0.0000001;      dRetval=x;      dRetval+=(5.0/pow(10.0,d+1.0));      dRetval*=pow(10.0,d);      dRetval=floor(dRetval+dMod);      dRetval/=pow(10.0,d);      return dRetval;  }  int main(void)  {      int n;      double x;      scanf(\"%lf%d\",&x,&n);      printf(\"%g\\n\",Round(x,n));        return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 18 楼 finalfantasy_xu 的回复:网上不是到处都是？我搜过了，没有，不一样的，这个比较难", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "网上不是到处都是？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> #include <math.h> double Round(double x, int d) {     double dRetval;     double dMod = 0.0000001;     if (x<0.0) dMod=-0.0000001;     dRetval=x;     dRetval+=(5.0/pow(10.0,d+1.0));     dRetval*=pow(10.0,d);     dRetval=floor(dRetval+dMod);     dRetval/=pow(10.0,d);     return dRetval; } int main(void) {     int n;     double x;     scanf(\"%lf%d\",&x,&n);     printf(\"%g\\n\",Round(x,n));      return 0; } //输入123.456 2 //输出123.46", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 14 楼 是疗伤烧肉粽~ 的回复:[quote=引用 12 楼 赵4老师 的回复:]//Round(1.234,2) = 1.23 //Round(1.234,0) = 1.0 //Round(123.4,-1) = 120.0 double Round(double dVal, short iPlaces) {     double dRetval;     double dMod = 0.0000001;     if (dVal<0.0) dMod=-0.0000001;     dRetval=dVal;     dRetval+=(5.0/pow(10.0,iPlaces+1.0));     dRetval*=pow(10.0,iPlaces);     dRetval=floor(dRetval+dMod);     dRetval/=pow(10.0,iPlaces);     return(dRetval); }  double round(double dVal, short iPlaces) //iPlaces>=0 {     unsigned char s[20];     double dRetval;      sprintf(s,\"%.*lf\",iPlaces,dVal);     sscanf(s,\"%lf\",&dRetval);     return (dRetval); } 编译错误[/quote] 自己将sprintf改为sprintf_s,scanf改为scanf_s", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 11 楼 NorZ 的回复:[quote=引用 6 楼 是疗伤烧肉粽~ 的回复:][quote=引用 5 楼 qzjhjxj 的回复:]供参考：# include <math.h> #define DoubleCompare(a,b)((fabs(a-b)< 1E-10) ? 0 : 1)  double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     if ( DoubleCompare(x,1E-10) > 0 )         return (int)((x*m)+0.5)/(1.0*m);     else         return (int)((x*m)-0.5)/(1.0*m);//负数 }这个不太行，在PTA有两个测试点没过，就过了一个[/quote]  因为他最后返回的时候强转了 int ...你给改成 double 应该就行[/quote]改了之后一个测试点都过不了", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 12 楼 赵4老师 的回复://Round(1.234,2) = 1.23 //Round(1.234,0) = 1.0 //Round(123.4,-1) = 120.0 double Round(double dVal, short iPlaces) {     double dRetval;     double dMod = 0.0000001;     if (dVal<0.0) dMod=-0.0000001;     dRetval=dVal;     dRetval+=(5.0/pow(10.0,iPlaces+1.0));     dRetval*=pow(10.0,iPlaces);     dRetval=floor(dRetval+dMod);     dRetval/=pow(10.0,iPlaces);     return(dRetval); }  double round(double dVal, short iPlaces) //iPlaces>=0 {     unsigned char s[20];     double dRetval;      sprintf(s,\"%.*lf\",iPlaces,dVal);     sscanf(s,\"%lf\",&dRetval);     return (dRetval); } 编译错误", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 9 楼 NorZ 的回复:[quote=引用 8 楼 NorZ 的回复:][quote=引用 5 楼 qzjhjxj 的回复:]供参考：# include <math.h> #define DoubleCompare(a,b)((fabs(a-b)< 1E-10) ? 0 : 1)  double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     if ( DoubleCompare(x,1E-10) > 0 )         return (int)((x*m)+0.5)/(1.0*m);     else         return (int)((x*m)-0.5)/(1.0*m);//负数 }  像这种输入的 double 数值，直接和 0 比较来判断正负就行，你这样写的话，都引入 math 库了，也就可以直接用 math 库的 round 函数来四舍五入 x*m ，那也没有判断正负的必要了[/quote]   # include <math.h> double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     return (double)(round(x*m)/(1.0*m)); } [/quote]谢了，但还有一个测试点运行超时", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "你的需求可能需要写asm 代码，幂计算需要协处理器可能比较慢。难点在于二进制小数位的判断，需要使用数表（事先计算好二进制对应的进位项位数，阈值，进位后的值）。否则就需要使用bcd码像处理字符那样逐位操作。", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "//Round(1.234,2) = 1.23 //Round(1.234,0) = 1.0 //Round(123.4,-1) = 120.0 double Round(double dVal, short iPlaces) {     double dRetval;     double dMod = 0.0000001;     if (dVal<0.0) dMod=-0.0000001;     dRetval=dVal;     dRetval+=(5.0/pow(10.0,iPlaces+1.0));     dRetval*=pow(10.0,iPlaces);     dRetval=floor(dRetval+dMod);     dRetval/=pow(10.0,iPlaces);     return(dRetval); }  double round(double dVal, short iPlaces) //iPlaces>=0 {     unsigned char s[20];     double dRetval;      sprintf(s,\"%.*lf\",iPlaces,dVal);     sscanf(s,\"%lf\",&dRetval);     return (dRetval); }", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "引用 6 楼 是疗伤烧肉粽~ 的回复:[quote=引用 5 楼 qzjhjxj 的回复:]供参考：# include <math.h> #define DoubleCompare(a,b)((fabs(a-b)< 1E-10) ? 0 : 1)  double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     if ( DoubleCompare(x,1E-10) > 0 )         return (int)((x*m)+0.5)/(1.0*m);     else         return (int)((x*m)-0.5)/(1.0*m);//负数 }这个不太行，在PTA有两个测试点没过，就过了一个[/quote]  因为他最后返回的时候强转了 int ...你给改成 double 应该就行", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "就你题目上的例子: 123.4562 123.46  让123.4562 * 100    也就是  12345.62  这时候也就可以用哪个方法，四舍五入就是12346 然后12346   / 100    也就是 123.46了  也就是 123.4562 * 10^n  四舍五入 然后 / 10^n（n为保留的位数）", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "引用 8 楼 NorZ 的回复:[quote=引用 5 楼 qzjhjxj 的回复:]供参考：# include <math.h> #define DoubleCompare(a,b)((fabs(a-b)< 1E-10) ? 0 : 1)  double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     if ( DoubleCompare(x,1E-10) > 0 )         return (int)((x*m)+0.5)/(1.0*m);     else         return (int)((x*m)-0.5)/(1.0*m);//负数 }  像这种输入的 double 数值，直接和 0 比较来判断正负就行，你这样写的话，都引入 math 库了，也就可以直接用 math 库的 round 函数来四舍五入 x*m ，那也没有判断正负的必要了[/quote]   # include <math.h> double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     return (double)(round(x*m)/(1.0*m)); }", "referer": "user-0"}, {"cid": "14", "user": "user-5", "content": "引用 5 楼 qzjhjxj 的回复:供参考：# include <math.h> #define DoubleCompare(a,b)((fabs(a-b)< 1E-10) ? 0 : 1)  double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     if ( DoubleCompare(x,1E-10) > 0 )         return (int)((x*m)+0.5)/(1.0*m);     else         return (int)((x*m)-0.5)/(1.0*m);//负数 }  像这种输入的 double 数值，直接和 0 比较来判断正负就行，你这样写的话，都引入 math 库了，也就可以直接用 math 库的 round 函数来四舍五入 x*m ，那也没有判断正负的必要了", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 2 楼 突触 的回复:浮点型转整型时，是去掉小数部分(也可以称为向零求正) 如:    (int)1.6 -> 1 (int)1.3 -> 1 当浮点型为正数时加上0.5    (int)(1.6+0.5)  = (int)2.1 -> 2 (int)(1.3+0.5)  = (int)1.8 -> 1 不做理论证明直接说结论   当浮点型为正数时，浮点型+0.5 在转为整型就相当于四舍五入  当浮点型为负数的时候就需要    -0.5  具体代码  #include <STDIO.H>  int Fun_To(float n) { \tfloat a=0.5f; \tint sign= *(int*)&n & 0x80000000;  //取正号或负号 \t\t\t\t\t\t\t\t\t   // 0x3F000000  是浮点型的0.5 这里直接用16进制表示了 \tint h= 0x3F000000 | sign;\t\t   // 根据符号转为  -0.5或 +0.5 \treturn n + *(float*)&h;            // 浮点型加 +/- 0.5 }  int main(int argc, char* argv[]) { \t \tprintf(\"%d\\n\",Fun_To(-3.6));  \treturn 0; }  你这个只能一个小数点才能，多个小数就不行了", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 5 楼 qzjhjxj 的回复:供参考：# include <math.h> #define DoubleCompare(a,b)((fabs(a-b)< 1E-10) ? 0 : 1)  double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     if ( DoubleCompare(x,1E-10) > 0 )         return (int)((x*m)+0.5)/(1.0*m);     else         return (int)((x*m)-0.5)/(1.0*m);//负数 }这个不太行，在PTA有两个测试点没过，就过了一个", "referer": "user-0"}, {"cid": "17", "user": "user-7", "content": "供参考：# include <math.h> #define DoubleCompare(a,b)((fabs(a-b)< 1E-10) ? 0 : 1)  double Round(double x, int n) {     int   m=1;     while (n--)m*=10;     if ( DoubleCompare(x,1E-10) > 0 )         return (int)((x*m)+0.5)/(1.0*m);     else         return (int)((x*m)-0.5)/(1.0*m);//负数 }", "referer": "user-0"}, {"cid": "18", "user": "user-6", "content": "等级  勋章Blank\t 抱歉 没有仔细看题目   如果你愿意的话 ， 还是可以用上面的方法 用浮点型 乘以 10^n， 四舍五入后 在除以10^n", "referer": "user-0"}, {"cid": "19", "user": "user-6", "content": "浮点型转整型时，是去掉小数部分(也可以称为向零求正) 如:    (int)1.6 -> 1 (int)1.3 -> 1 当浮点型为正数时加上0.5    (int)(1.6+0.5)  = (int)2.1 -> 2 (int)(1.3+0.5)  = (int)1.8 -> 1 不做理论证明直接说结论   当浮点型为正数时，浮点型+0.5 在转为整型就相当于四舍五入  当浮点型为负数的时候就需要    -0.5  具体代码  #include <STDIO.H>  int Fun_To(float n) { \tfloat a=0.5f; \tint sign= *(int*)&n & 0x80000000;  //取正号或负号 \t\t\t\t\t\t\t\t\t   // 0x3F000000  是浮点型的0.5 这里直接用16进制表示了 \tint h= 0x3F000000 | sign;\t\t   // 根据符号转为  -0.5或 +0.5 \treturn n + *(float*)&h;            // 浮点型加 +/- 0.5 }  int main(int argc, char* argv[]) { \t \tprintf(\"%d\\n\",Fun_To(-3.6));  \treturn 0; }", "referer": "user-0"}, {"cid": "20", "user": "user-8", "content": "这个对吗 我咋运行不了 下面给我来个这 id returned 1 exit status 请问这该怎么办", "referer": "user-0"}]}
{"question": "求助malloc创建字符串并赋值！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 1 楼 user-4 的回复: printf(\"%s\\n\", a);   没有以'\\0'结束呢，这不算是一个字符串呢；", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "而且缺少结束符", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "c 语言字符串要以 '\\0' 结束。 以下代码供参考  #include <stdio.h> #include <stdlib.h> #define N 5 int main() {     char *a = (char*)malloc((N+1) * sizeof(char));    int i;     for( i=0; i<N;i++)     {         *(a+i) = '1';     }    *(a+i) = '\\0';     printf(\"%s\\n\", a);    return 0 ; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "printf(\"%s\\n\", a);", "referer": "user-0"}]}
{"question": "C语言指针问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "指针当参数只能修改它指向的内存地址里面的东西，而不能修改指针的指向。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "main函数的s和fun函数里的s是两个独立的变量。所以main里的s在经过fun函数之后是没有变化的，还是指向a的。  因为实参s把a的地址传给fun函数的形参s，然后形参没有对a做任何操作；只是形参s又指向了calloc申请的空间，并且把a，b数据内容相加给了s（形参），那么这个s和main函数里的s什么关系呢？calloc申请的空间需要手动释放～  如果fun第三参数传递的是double **s，实参是&s，那么main里的s指向的calloc申请的空间，*s是相加之和", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "在fun()函数体内，*s 所指向的是 s = (double *)calloc(1,sizeof(double))所生成的空间，并没按我们所想的那样，指向a[]数组的空间。", "referer": "user-0"}]}
{"question": "vscode 中文乱码怎办？编写c", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "现在的电脑硬件都牛，直接用visual stdio吧，省事不少。 再说，真正做项目，估计很少人用vscode吧。。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "右下角选择编码格式", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "贴代码。。。。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "乱码这种东西，就像天上的浮云一样。 乱着乱着自己就散了。 你要是一时半会儿搞不定源文件编码，那就只用它来写新代码好了。 新写的又不乱。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "这种问题还是自己百度吧。。。", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "看一下字符串是不是没有'\\0'结束，还要看一下是不是越界了", "referer": "user-0"}]}
{"question": "求助 怎末简化这个程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢老师，", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> #define  MAX_people  30 char names     [MAX_people][50]; int  sex       [MAX_people]; int  time      [MAX_people]; int  num       [MAX_people]; int  temp_num  [MAX_people]; char temp_names[MAX_people][50]; int  temp_time [MAX_people]; int  temp_sex  [MAX_people]; int  sort      [MAX_people]; int i, j; void people_scanf(int n) {     for (i = 0; i<n; ++i) {         printf(\"\\n请输入第%d个顾客的信息:\\n\", i + 1);         printf(\"\\n身份证号:\"); scanf(\"%d\", &num[i]);         printf(\"\\n姓名:\");     scanf(\"%s\", names[i]);         printf(\"\\n性别:\");     scanf(\"%d\", &sex[i]);         printf(\"\\n入住时间:\"); scanf(\"%d\", &time[i]);     } } void people_printf(int n) {     printf(\"\\n身份证号\\t姓名\\t入住时间\\t性别\\n\");     printf(\"-------------------------------------------------------\\n\");     for (i = 0; i<n; ++i) {         printf(\"%d\\t%s\\t%d\\t%d\\n\", num[i], names[i], sex[i], time[i]);     }     printf(\"-------------------------------------------------------\\n\"); } int people_find_num(int n) {     int nums;     int result;      printf(\"请输入待查找的顾客身份证号:\");     scanf(\"%d\",&nums);     result= -1;     for (i = 0; i<n; ++i) {         if (nums == num[i]) {             result = i;             break;         }     }     if (result == -1) {         printf(\"没有该顾客信息!\\n\");         return 0;     } else {         printf(\"\\n身份证号\\t姓名\\t入住时间\\t性别\\n\");         printf(\"%d\\t%s\\t%d\\t%d\\t\", num[result], names[result], time[result], sex[result]);         printf(\"打印出查找结果!\\n\");     }     return 1; } int people_find_name(int n) {     char name[200];     int result;      printf(\"请输入待查找的顾客姓名:\");     scanf(\"%s\", name);     result = -1;     for (i = 0; i<n; ++i) {         if (strcmp(name, names[i]) == 0) {             result = i;             break;         }     }     if (result == -1) {         printf(\"没有该顾客信息!\\n\");         return 0;     } else {         printf(\"\\n身份证号\\t姓名\\t入住时间\\t性别\\n\");         printf(\"%d\\t%s\\t%d\\t%d\\t\", num[result], names[result], time[result], sex[result]);         printf(\"已完成查找!\\n\");     }     return 1; } int people_alter_name(int n) {     char name[50];     int result;      printf(\"请输入待修改的顾客姓名:\");     scanf(\"%s\",name);     result= -1;     for (i = 0; i<n; ++i) {         if (strcmp(name,names[i])==0) {             result = i;             break;         }     }     if (result == -1) {         printf(\"没有该顾客信息!\\n\");         return 0;     } else {         printf(\"请重新输入该顾客信息：\\n\");         printf(\"身份证号：\"); scanf(\"%d\",&num[result]);         printf(\"姓名：\");     scanf(\"%s\",names[result]);         printf(\"入住时间：\"); scanf(\"%d\",&time[result]);         printf(\"性别：\");     scanf(\"%d\",&sex[result]);     }     return 1; } int people_delete_name(int n) {     char name[50];     int result;      printf(\"请输入待删除的顾客姓名:\");     scanf(\"%s\",name);     result= -1;     for (i = 0; i<n; ++i) {         if (strcmp(name,names[i])==0) {             result = i;             break;         }     }     if (result == -1) {         printf(\"没有该顾客信息!\\n\");         return 0;     } else {         for(i=result; i<n-1; ++i) {             num[i] = num[i+1];             strcpy(names[i],names[i+1]);             time[i] = time[i+1];             sex[i] = sex[i+1];         }     }     return 1; } int main() {     int choice,n;     while (1) {         printf(\"*************************************\\n\"                \"欢迎使用酒店信息管理系统\\n\"                \"[1] 输入所有顾客信息\\n\"                \"[2] 按姓名查找某个顾客信息\\n\"                \"[3] 按姓名修改某个顾客信息\\n\"                \"[4] 按姓名删除某个顾客信息\\n\"                \"[0] 退出程序\\n\"                \"请输入您的选择（0 - 4）:\");         rewind(stdin);         scanf(\"%d\",&choice);         printf(\"**************************************)\\n\");         if (0==choice) {             printf(\"程序结束，谢谢使用!\\n\");             break;         }         switch (choice) {         case 1:             printf(\"请输入录入的顾客信息数： \");             scanf(\"%d\",&n);             people_scanf(n);             break;         case 2:             people_find_name(n);             break;         case 3:             people_alter_name(n);             break;         case 4:             people_delete_name(n);             n--;             break;         default:             printf(\"您输入的菜单有误。请重新输入！\\n\");         }     }     return 0; }", "referer": "user-0"}]}
{"question": "怎样实现从网上下载的NTRU源代码？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:带Makefile，  Linux： make Windows： nmake git clone https://github.com/jschanck/ntru.git cd ref-ntruhrss701 && make cd ../avx2-ntruhrss701 && make，老师，我在执行这些步骤时，第二步第三步，出现了make错误126，127。为什么啊", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "带Makefile，  Linux： make Windows： nmake", "referer": "user-0"}]}
{"question": "求助：C语言strcat函数疑惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "char s1[20]=... char s2[20]=... char s3[20]=... 即可。 必要时再扩大。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "因为你没有给它们分配足够的空间。 都挤在一起的时候，s2的脚趾头不小心碰到s1的鼻孔也可以理解的。", "referer": "user-0"}]}
{"question": "数组解决问题，求大佬帮忙，急急急！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 7 楼 m0_56240570 的回复:[quote=引用 5 楼 自信男孩的回复:]贴源码吧，数组其实就是一段连续的内存；用malloc/calloc等申请的空间一样可以作为数组使用。 刚学，不太懂怎么写，可以具体一点吗？[/quote] 先自己试着写写，这样的例子我想书本上也是有的。给你写好，调好，那么你能学到什么？稍微修改一下需求，一样还是不会，自己要试着练练～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "重新排版下，数组数量设为题目要求的10个：//产品销售记录包括 产品代码 名称 单价 数量 金额 等信息 //1）编写input函数 输入10个产品销售记录的如上信息 //2）编写sum函数 计算金额 = 单价 * 数量 //3）编写sort函数 按金额从大到小排序  #include<stdio.h> #define PRODUCTS 10 //按题目要求10个产品  void  input(); float sum(float a,int n); void  sort();   typedef struct{ //自定义结构体类型 \tint   code; \tchar  name[21]; \tfloat price; \tint   quantity; }PRODUCT;  PRODUCT products[PRODUCTS];//定义10个产品记录的数组  void main() {       input(); //输入       sort();  //排序,从大到小       for(int i = 0; i < PRODUCTS; i++){ //打印输出        printf(\"code = %d | quantity = %d | price = %.2f | name = %s | sum = %.2f\\n\",              products[i].code,products[i].quantity,products[i].price,products[i].name,              sum(products[i].price,products[i].quantity));       }        }  void input(){      printf(\"Enter example:code,quantity,price,name(30)\\n\");      for(int i = 0; i < PRODUCTS; i++){         scanf(\"%d %d %f %s\", &products[i].code,&products[i].quantity,                                    &products[i].price,products[i].name); \t} }  float sum(float a,int n) {      return a * n; }  void sort(){       PRODUCT temp;       for (int i = 0; i <PRODUCTS -1 ;i++){          for (int k = 0; k < PRODUCTS - 1 -i ;k++){            if((products[k].price * products[k].quantity)<                                   (products[k+1].price * products[k+1].quantity))            {                  temp          = products[k];                  products[k]   = products[k+1];                  products[k+1] = temp;            }          }       } }   //Enter example:code,quantity,price,name(30) //11 20 2.00 aa //22 30 1.00 bb //33 10 3.00 cc //code = 11 | quantity = 20 | price = 2.00 | name = aa | sum = 40.00 //code = 22 | quantity = 30 | price = 1.00 | name = bb | sum = 30.00 //code = 33 | quantity = 10 | price = 3.00 | name = cc | sum = 30.00 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "改好，供参考：//产品销售记录包括 产品代码 名称 单价 数量 金额 等信息 //1）编写input函数 输入10个产品销售记录的如上信息 //2）编写sum函数 计算金额 = 单价 * 数量 //3）编写sort函数 按金额从大到小排序  #include<stdio.h> #define PRODUCTS 3  void input(); float sum(float a,int n); void sort();   typedef struct{ //自定义结构体类型 \tint code; \tchar name[21]; \tfloat price; \tint quantity; }PRODUCT;  PRODUCT products[PRODUCTS];  void main() { \tinput(); //输入 \tsort();  //排序,从大到小         for(int i = 0; i < PRODUCTS; i++){ //打印输出            printf(\"code = %d | quantity = %d | price = %.2f | name = %s | sum = %.2f\\n\",products[i].code,            products[i].quantity,products[i].price,products[i].name,sum(products[i].price,products[i].quantity)); \t}         system(\"pause\"); }  void input(){         printf(\"Enter example:code,quantity,price,name(30)\\n\"); \tfor(int i = 0; i < PRODUCTS; i++){ \t\tscanf(\"%d %d %f %s\", &products[i].code,&products[i].quantity,                                          &products[i].price,products[i].name); \t} }  float sum(float a,int n) { \treturn a * n; }  void sort(){ \tPRODUCT temp; \tfor (int i = 0; i <PRODUCTS -1 ;i++){             for (int k = 0; k < PRODUCTS - 1 -i ;k++){                  if( (products[k].price * products[k].quantity) < products[k+1].price * products[k+1].quantity){ \t\t\t\ttemp          = products[k]; \t\t\t\tproducts[k]   = products[k+1]; \t\t\t\tproducts[k+1] = temp; \t\t\t} \t\t} \t} }   //Enter example:code,quantity,price,name(30) //11 20 2.00 aa //22 30 1.00 bb //33 10 3.00 cc //code = 11 | quantity = 20 | price = 2.00 | name = aa | sum = 40.00 //code = 22 | quantity = 30 | price = 1.00 | name = bb | sum = 30.00 //code = 33 | quantity = 10 | price = 3.00 | name = cc | sum = 30.00 //请按任意键继续. . .：", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 5 楼 自信男孩的回复:贴源码吧，数组其实就是一段连续的内存；用malloc/calloc等申请的空间一样可以作为数组使用。 刚学，不太懂怎么写，可以具体一点吗？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 user-3的回复:是数组呀，结构体数组products[PRODUCTS]：#define PRODUCTS 3//数组的大小，这里预设为3  //函数原型 void input(); float sum(); void sort(); \t //自定义结构体类型 typedef struct{ \tint code;    //产品代码 \tchar name[21];//产品名称 \tfloat price;   //产品价格 \tint quantity; //产品数量 }PRODUCT;  PRODUCT products[PRODUCTS],*p_product = products;//这里定义了一个结构体数组products[3],一个指向数组的指针p_product   后边是指针，需要用数组写", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "贴源码吧，数组其实就是一段连续的内存；用malloc/calloc等申请的空间一样可以作为数组使用。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 3 楼 user-3的回复:是数组呀，结构体数组products[PRODUCTS]：#define PRODUCTS 3//数组的大小，这里预设为3  //函数原型 void input(); float sum(); void sort(); \t //自定义结构体类型 typedef struct{ \tint code;    //产品代码 \tchar name[21];//产品名称 \tfloat price;   //产品价格 \tint quantity; //产品数量 }PRODUCT;  PRODUCT products[PRODUCTS],*p_product = products;//这里定义了一个结构体数组products[3],一个指向数组的指针p_product   下面是指针啊，后边怎么写啊", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "是数组呀，结构体数组products[PRODUCTS]：#define PRODUCTS 3//数组的大小，这里预设为3  //函数原型 void input(); float sum(); void sort(); \t //自定义结构体类型 typedef struct{ \tint code;    //产品代码 \tchar name[21];//产品名称 \tfloat price;   //产品价格 \tint quantity; //产品数量 }PRODUCT;  PRODUCT products[PRODUCTS],*p_product = products;//这里定义了一个结构体数组products[3],一个指向数组的指针p_product", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 1 楼 user-3的回复:供参考：https://blog.csdn.net/weixin_43933620/article/details/99826947?ops_request_misc=&request_id=&biz_id=102&utm_term=%E4%BA%A7%E5%93%81%E9%94%80%E5%94%AE%E8%AE%B0%E5%BD%95&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-99826947.first_rank_v2_pc_rank_v29 需要数组解决", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "供参考：https://blog.csdn.net/weixin_43933620/article/details/99826947?ops_request_misc=&request_id=&biz_id=102&utm_term=%E4%BA%A7%E5%93%81%E9%94%80%E5%94%AE%E8%AE%B0%E5%BD%95&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-99826947.first_rank_v2_pc_rank_v29", "referer": "user-0"}]}
{"question": "C语言malloc与结构体调用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 8 楼 真相重于对错的回复:printf(\"\\n%d\\n\", ZA1->data);//这里还没有给data赋值，就要打印它，会出错 ZA1->data = ZA; 谢谢回复，已解决", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 赵4老师的回复:#include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct MyString {     unsigned char* data;     int size; } MyString;  char* ConvertStringAsHex(MyString*);  //将字符串转换为16进制数串 char* ConvertStringAsHex(MyString* s) {     char* result = (char*)malloc(sizeof(char) * (s->size * 2 + 1));     for (int i = 0; i < s->size; i++) {         sprintf(&result[i * 2], \"%02X\", s->data[i]);     }     result[s->size * 2] = '\\0';     return result; }  int main() {     char *ID = \"aaabbb\";     char *ENTLA = \"123\";     unsigned char *ZA = (unsigned char*)malloc(sizeof(unsigned char)*strlen(ENTLA) + strlen(ID) + 1);     memcpy(ZA, ENTLA,strlen(ENTLA));     memcpy(ZA+strlen(ENTLA), ID, strlen(ID));     ZA[strlen(ENTLA) + strlen(ID)] = '\\0';     printf(\"ZA:[%s]\\n\",ZA);     MyString *ZA1 = (MyString*)malloc(sizeof(MyString));     ZA1->size = strlen((char *)ZA);     printf(\"strlen(ENTLA) + strlen(ID):%d\\n\", strlen(ENTLA) + strlen(ID));     ZA1->data = ZA;     printf(\"ZA1->data:[%s]\\n\",ZA1->data);     char *ZAstring = ConvertStringAsHex(ZA1);     printf(\"ZAstring:[%s]\\n\", ZAstring);     free(ZAstring);     free(ZA1);     free(ZA);     printf(\"End\\n\");     return 0; } //ZA:[123aaabbb] //strlen(ENTLA) + strlen(ID):9 //ZA1->data:[123aaabbb] //ZAstring:[313233616161626262] //End //  谢谢您，可算是懂了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "printf(\"\\n%d\\n\", ZA1->data);//这里还没有给data赋值，就要打印它，会出错 ZA1->data = ZA;", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct MyString {     unsigned char* data;     int size; } MyString;  char* ConvertStringAsHex(MyString*);  //将字符串转换为16进制数串 char* ConvertStringAsHex(MyString* s) {     char* result = (char*)malloc(sizeof(char) * (s->size * 2 + 1));     for (int i = 0; i < s->size; i++) {         sprintf(&result[i * 2], \"%02X\", s->data[i]);     }     result[s->size * 2] = '\\0';     return result; }  int main() {     char *ID = \"aaabbb\";     char *ENTLA = \"123\";     unsigned char *ZA = (unsigned char*)malloc(sizeof(unsigned char)*strlen(ENTLA) + strlen(ID) + 1);     memcpy(ZA, ENTLA,strlen(ENTLA));     memcpy(ZA+strlen(ENTLA), ID, strlen(ID));     ZA[strlen(ENTLA) + strlen(ID)] = '\\0';     printf(\"ZA:[%s]\\n\",ZA);     MyString *ZA1 = (MyString*)malloc(sizeof(MyString));     ZA1->size = strlen((char *)ZA);     printf(\"strlen(ENTLA) + strlen(ID):%d\\n\", strlen(ENTLA) + strlen(ID));     ZA1->data = ZA;     printf(\"ZA1->data:[%s]\\n\",ZA1->data);     char *ZAstring = ConvertStringAsHex(ZA1);     printf(\"ZAstring:[%s]\\n\", ZAstring);     free(ZAstring);     free(ZA1);     free(ZA);     printf(\"End\\n\");     return 0; } //ZA:[123aaabbb] //strlen(ENTLA) + strlen(ID):9 //ZA1->data:[123aaabbb] //ZAstring:[313233616161626262] //End //", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 真相重于对错的回复:贴代码，不要贴图 代码贴评论区了，拜托指点", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "这是源代码 #ifndef MYSTRING_H #define MYSTRING_H  typedef struct MyString { \tunsigned char* data; \tint size; }MyString;  char* ConvertStringAsHex(MyString*);  #endif  #include<stdio.h> #include<stdlib.h> #include \"MyString.h\"  //将字符串转换为16进制数串 char* ConvertStringAsHex(MyString* s) { \tchar* result = (char*)malloc(sizeof(char) * (s->size * 2 + 1)); \tfor (int i = 0; i < s->size; i++) { \t\tsprintf_s(&result[i * 2], \"%02X\", s->data[i]); \t} \tresult[s->size * 2] = '\\0'; \treturn result; }   void main() { char *ID = \"aaabbb\"; char *ENTLA = \"123\"; unsigned char *ZA = (unsigned char*)malloc(sizeof(unsigned char)*strlen(ENTLA) + strlen(ID) + 1); memcpy(ZA, ENTLA,strlen(ENTLA)); memcpy(ZA+strlen(ENTLA), ID, strlen(ID)); ZA[strlen(ENTLA) + strlen(ID)] = '\\0'; printf(\"\\n%s\",ZA); Mystring *ZA1 = (Mystring*)malloc(sizeof(Mystring)); ZA1-> = strlen(ZA); printf(\"\\n%d\\n\", strlen(ENTLA) + strlen(ID)); printf(\"\\n%d\\n\", ZA1->data); ZA1->data = ZA; printf(\"%s\\n\",ZA1->data); char *ZAstring = ConvertStringAsHex(ZA1); printf(\"%s\\n\", ZAstring); free(ZA1->data); free(ZA1); free(ZA); }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:没有printf输出语句，当然没有输出结果。 在 free(ZA1->data); 前加一句 printf(\"%s\\n\",ZAstring); 抱歉，截图误导了，添加过printf，运行不出来", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "贴代码，不要贴图", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 楼主 weixin_45710571的回复:求助， 调用结构体后为什么无法输出ZAstring字符串结果？编译通过的     抱歉，截图误导了，添加过printf，运行不出来", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "没有printf输出语句，当然没有输出结果。 在 free(ZA1->data); 前加一句 printf(\"%s\\n\",ZAstring);", "referer": "user-0"}]}
{"question": "C语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "查阅函数原型，是为了对照它强制转换一下实参类型，以消除你问题里的警告。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 forever74的回复:FindWindow是个Win32 API，声明为  WINUSERAPI HWND WINAPI FindWindowA(     _In_opt_ LPCSTR lpClassName,     _In_opt_ LPCSTR lpWindowName); WINUSERAPI HWND WINAPI FindWindowW(     _In_opt_ LPCWSTR lpClassName,     _In_opt_ LPCWSTR lpWindowName);  FindWindow不是个函数吗", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 forever74的回复:FindWindow是个Win32 API，声明为  WINUSERAPI HWND WINAPI FindWindowA(     _In_opt_ LPCSTR lpClassName,     _In_opt_ LPCSTR lpWindowName); WINUSERAPI HWND WINAPI FindWindowW(     _In_opt_ LPCWSTR lpClassName,     _In_opt_ LPCWSTR lpWindowName);  意思是，这个还需要提前声明吗？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "FindWindow是个Win32 API，声明为  WINUSERAPI HWND WINAPI FindWindowA(     _In_opt_ LPCSTR lpClassName,     _In_opt_ LPCSTR lpWindowName); WINUSERAPI HWND WINAPI FindWindowW(     _In_opt_ LPCWSTR lpClassName,     _In_opt_ LPCWSTR lpWindowName);", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "FindWindow代码呢？  贴图片比较方便，但是也需要把相关的代码都拍下来的，要么直接发源码，如果不保密的", "referer": "user-0"}]}
{"question": "拜托帮忙看一下代码的问题！谢谢！（急！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h>  typedef int ElemType; typedef struct LNode {     ElemType data;     //struct Lnode *next;     struct LNode *next; }LNode,*LinkList;  //void CreateList_L(LinkList L) void CreateList_L(LinkList *L) {     *L=(LinkList)malloc(sizeof(LNode));     (*L)->next=NULL;     int i;     LinkList p,q;     p = *L;     char c;     //for(;;i++)     for(;;)     {         while(p->next)             p = p->next;         q=(LinkList)malloc(sizeof(LNode));         scanf(\"%d\",&q->data);         printf(\"%d\\n\", q->data);         p->next=q;         q->next=NULL;         //if(c=getchar()=='\\n')break;         if((c=getchar())=='\\n') //少一个括号             break;     } } int main() {     LinkList LA,LB,LC;     CreateList_L(&LA);     CreateList_L(&LB);     LC=(LinkList)malloc(sizeof(LNode));     LC->next=NULL;      LinkList p=LA,q=LB,l1,l2;     //for(p=LA;p->next!=NULL;p=p->next)     for(p=LA->next;p !=NULL;p=p->next)     {         //for(q=LB;q->next!=NULL;q=q->next)         for(q=LB->next;q!=NULL;q=q->next)         {             if((q->data)==(p->data))             {                 l2=LC;                 while(l2->next)                     l2=l2->next;                 l1=(LinkList)malloc(sizeof(LNode));                 //l1=l2;                 l1->data=q->data;                 l2->next=l1;                 l1->next=NULL;                 l2 = l1;             }         }     }      p=LA;     LinkList u=LA;     while(p->next)     {         u=p;         p=p->next;         free(u);     }     q=LB;     u=LB;     while(q->next)     {         u=q;         q=q->next;         free(u);     }      l2=LC->next;     //while(l2->next)     while(l2)     {         /*         if(l2->next==NULL)printf(\"%d\\n\",l2->data);         else printf(\"%d \",l2->data);         */         printf(\"%d \",l2->data);         l2=l2->next;     }     putchar(10);     return 0; }  供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "一个参数指针，函数里只能通过修改他指向的内容，而不能修改他的指向。", "referer": "user-0"}]}
{"question": "大佬求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2 的回复：供参考：#include<stdio.h> #include<math.h> int isPrime(int n); int main() {     int n,m,sum=0;     scanf(\"%d\",&n);     while (n--){           scanf(\"%d\",&m);           if (isPrime(m)) sum += m;     }     printf(\"%d\",sum);          return 0; }  int isPrime(int n) {     if (n <= 3) {         return n > 1;     }     int sqr = (int)sqrt(n);     for (int i = 2; i <= sqr; i++) {         if(n % i == 0) {             return 0;         }     }     return 1; }感谢大佬[face]monkey2:003.png[/face]", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考：#include<stdio.h> #include<math.h> int isPrime(int n); int main() {     int n,m,sum=0;     scanf(\"%d\",&n);     while (n--){           scanf(\"%d\",&m);           if (isPrime(m)) sum += m;     }     printf(\"%d\",sum);          return 0; }  int isPrime(int n) {     if (n <= 3) {         return n > 1;     }     int sqr = (int)sqrt(n);     for (int i = 2; i <= sqr; i++) {         if(n % i == 0) {             return 0;         }     }     return 1; }", "referer": "user-0"}]}
{"question": "这样为啥不对啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "贴源码吧，方便调试～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主的代码只是把p的地址赋值给了q，这样q还是一个孤零零的节点。并没有插入到链表中  如果楼主要插入到链表中，需要定义另外一个节点pre，即要插入节点的前一个节点，q->next = p; pre->next = q;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 4 楼 user-5 的回复:插入函数，供参考：struct ListNode *insert(pp head,int x){      pp p,pr,q;      q=(pp)malloc(sizeof(qq));      q->data = x;      pr=head;      p=head->next;      while(p){            if(p->data >= x) {               if(p->data == x) break;               else{                    q->next = pr->next;//找到了p，插在p的前面一个节点。                    pr->next = q;                    break;               }            }            pr = p;            p  = p->next;      }      return head; } 如果插入的点在head之前呢，这个没有考虑 另外，head一定是有效的吗？可能是NULL不？所以需要多加一些判断～   q->next = pr->next;//找到了p，插在p的前面一个节点。     //上面这句可以改一下，改成如下：    //q->next = p; //这样会比较好理解了～否则后面的注释容易对你的q->next = pr->next产生误解～                    pr->next = q;                    break;", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "嗯，作弊的方式是把新节点q放在p的后面，然后悄悄交换它俩的data", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "插入函数，供参考：struct ListNode *insert(pp head,int x){      pp p,pr,q;      q=(pp)malloc(sizeof(qq));      q->data = x;      pr=head;      p=head->next;      while(p){            if(p->data >= x) {               if(p->data == x) break;               else{                    q->next = pr->next;//找到了p，插在p的前面一个节点。                    pr->next = q;                    break;               }            }            pr = p;            p  = p->next;      }      return head; }", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "这里不对吧，q=(pp)malloc(sizeof(pp));", "referer": "user-0"}]}
{"question": "有没有大佬教教我AVX512指令集", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "set和shuffle能一样吗？", "referer": "user-0"}]}
{"question": "位运算符／二进制／十六进制", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的编译器的技术路线是发现你使用有符号的整数进行右移的时候，就决定维持符号位不变。 符号位原来是1，所以左边移位进来的就全是1了。", "referer": "user-0"}]}
{"question": "乌班图20.04系统下，安装成功matlab2015，但是启动时总是报错：段错误（核心已转储））", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主解决了 ，我也有同样的问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 niuiic 的回复:如果是matlab2020，那就是少了一个库。2015也有可能是这个问题。具体哪个我忘了，博客也删了，到matlab论坛看一下吧，当初的回复还在。我安装的是matlab2015", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-4 的回复:不确切，猜测：安装过程结束之前有没有让你执行某个脚本进行初始化的？或者让你自行修改点什么？这个没有，安装完成之后，进行激活，激活成功之后，执行matlab就会报错，", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "如果是matlab2020，那就是少了一个库。2015也有可能是这个问题。具体哪个我忘了，博客也删了，到matlab论坛看一下吧，当初的回复还在。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "继续猜：sudo  ?", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "不确切，猜测：安装过程结束之前有没有让你执行某个脚本进行初始化的？或者让你自行修改点什么？", "referer": "user-0"}]}
{"question": "请问各位大佬，不定长数据域协议帧解析问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 forever74 的回复:就是各种转换指针类型嘛， frame是指针，管1个字节，frame+4也是。 把它强制转换为uint8_t *[4]类型也就是指针变量data的类型，就是为了让它变成管4个字节的指针类型，用来给data指针赋值。  下面那个类似，多了一个解引用也就是取目标，但是没有特意考虑字节序，如果字节序不对，就不能这样写。  非常感谢您花费时间讲解 我再去消化研究一下", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 user-2 的回复:2字节的数据帧长度要注意高低字节序，一般要用socket函数互相转换： htons()、ntohs()  虽然这个问题里不涉及区分大端小端 还是非常感谢您让我知道了这两个函数 挺实用的 谢谢！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "本来等着你说处理全帧的不如边接收边处理来得效率高呢。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "就是各种转换指针类型嘛， frame是指针，管1个字节，frame+4也是。 把它强制转换为uint8_t *[4]类型也就是指针变量data的类型，就是为了让它变成管4个字节的指针类型，用来给data指针赋值。  下面那个类似，多了一个解引用也就是取目标，但是没有特意考虑字节序，如果字节序不对，就不能这样写。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 forever74 的回复:uint8_t * frame=...; //带头的全帧首地址 uint8_t (*data)[4]=(uint8_t *[4])(frame+4); short int len=(*(short int *)(frame+2)-4)/4; //假设帧长度包括头不包括尾校验 int i; for(i=0;i<len;i++) {     do_someting_on data[i]; }  您好，本人接触编程时间不长，请问这串代码怎么理解呢 谢谢 (uint8_t *[4])(frame+4);  就是(uint8_t *[4])这样的表达方式没有见过  以及(*(short int *)(frame+2)-4)", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "2字节的数据帧长度要注意高低字节序，一般要用socket函数互相转换： htons()、ntohs()", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "谢谢您的思路", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "uint8_t * frame=...; //带头的全帧首地址 uint8_t (*data)[4]=(uint8_t *[4])(frame+4); short int len=(*(short int *)(frame+2)-4)/4; //假设帧长度包括头不包括尾校验 int i; for(i=0;i<len;i++) {     do_someting_on data[i]; }", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "|start | Command | Data                      | CRC  |  |0xAA  | 0xDD       |   需要解析的部分    |         |  ---------------------------------------------------- 意思是 怎么把frame_datafield[]这个数组里的元素 按4个一组 4个一组 分别提取出来", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "你那儿有数据帧长度啊，所以你问的实际上是什么？", "referer": "user-0"}]}
{"question": "openresty TCP代理，动态分配监听的端口供客户端连接", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "不知道为什么运行不出结果？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include<stdlib.h>  #define Maxize 20  typedef int datatype; typedef struct list {     datatype data[Maxize];     int length;  }squenlist;  void crealist(squenlist *b1,int a[],int n) {     int i,j=0;     for(i=0;i<n;i++)     {         b1->data[i]=a[j];         j++;     }     //b1->length=j+1;     b1->length=j;   //最后一次的j已经加1了，所以不用再加1了，否则就超出有效数据的大小了 } void displaylist(squenlist *b1) {     int i=0;     for(i=0;i<b1->length;i++)     {         printf(\"%d \",b1->data[i]);     }     printf(\"\\n\"); } int main() {     int a[5]={10,20,30,40,50},n;     n=5;     //squenlist *b1;     squenlist b1;     crealist(&b1,a,n);     displaylist(&b1);     return 0; } 供参考～ *b1是野指针 使用野指针了，所以没有输出。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include <stdio.h> #include<stdlib.h> #define Maxize 20 typedef int datatype; typedef struct list {     datatype data[Maxize];     int length;  }squenlist;  void crealist(squenlist *b1,int a[],int n) {     int i,j=0;     for(i=0;i<n;i++)     {        b1->data[i] = a[j];        j++;     }     b1->length=j;//b1->length=j+1; }  void displaylist(squenlist *b1) {     int i=0;     for(i=0;i<b1->length;i++)     {       printf(\"%d \",b1->data[i]);     }     printf(\"\\n\"); }  int main() {     int a[5]={10,20,30,40,50},n;     n=5;     squenlist *b1 = (squenlist *)malloc(sizeof(squenlist));//b1必须给它申请一片天呢     crealist(b1,a,n);     displaylist(b1);          return 0; }", "referer": "user-0"}]}
{"question": "请问一下这句代码什么意思 感激不尽", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "bit7..bit0   hexbyte 01100000 0x60 00011111 0x1F  如果LunarCalendarTable[year-1901]中的值对应二进制位bit6,bit5对应值为1 给Spring_NY赋值为LunarCalendarTable[year-1901]中的值对应二进制位bit4～bit0对应值-1 ……", "referer": "user-0"}]}
{"question": "华科。视频播放。课设 老代码无法运行 求大佬帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "见你的另一帖", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "easyx ？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 4 楼 赵4老师 的回复:在DosBox下使用 你说的对， 其实我只是找借口不想多干活。 咦，我这样坦白真的好么？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "在DosBox下使用", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "没有环境没法测试。但可以肯定的是这个代码原本就没有好用过。  TC的图形库得用TC编译，关键注意几个： TC是16位环境，int=short是16位的，long才是32位的。文件里读入4字节写入int变量一定会越界出错的，而DOS对越界是纵容的。 搞清楚你准备用的图形文件的格式是否和代码描述的一致，会不会文件格式太新或者颜色深度太大什么的。 TC图形库的initgraph的第三个参数是个文件名字符串，这个文件是TC自带的图形驱动，原始名字似乎不是这个来着，确定一下文件在不在你说的位置，内容对不对，名字为啥改了。  想想穿越秦汉隋唐自建工业体系的难度，耐心吧。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:easyx ？ 不可以 dos 环境不支持", "referer": "user-0"}]}
{"question": "TurboC2.0下16色bmp显示", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "DosBox中测试楼主的代码是可以的，需要注意的是，显示的bmp需要16色，大小不超过64KB", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "在DosBox中使用TC ？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "easyx ？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-4的回复:Turbo C，这么老的IDE，谁想帮你都难。 最好用大众化的IDE，好交流，有问题也容易搜索解决。。 学校逼迫，不然谁会用这种东西", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "Turbo C，这么老的IDE，谁想帮你都难。 最好用大众化的IDE，好交流，有问题也容易搜索解决。。", "referer": "user-0"}]}
{"question": "DOS系统下用turboC2.0实现256色bmp图片显示", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个显示不了256色图，16色的可以", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 赵4老师的回复:easyx ? 没有用easyx", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "在DosBox中使用TC ？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "easyx ?", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-4的回复:16位编程环境最基本的意思是int是16位的。 你的iw  ih 都只有2字节空间，你读进来4字节是要越界的。 图像长宽都错了的情况下，其他不正常现象恐怕就正常了  所以，我承认只看了几行，下面没看。 您这个我没听懂，我换了long也不行", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "ih和iw不是int类型吗", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "16位编程环境最基本的意思是int是16位的。 你的iw  ih 都只有2字节空间，你读进来4字节是要越界的。 图像长宽都错了的情况下，其他不正常现象恐怕就正常了  所以，我承认只看了几行，下面没看。", "referer": "user-0"}]}
{"question": "差个成绩排序和成绩统计功能，有大佬懂的嘛？弄了一下午实在是不会用链表排序。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 自信男孩 的回复:[quote=引用 4 楼 weixin_51970786 的回复:][quote=引用 3 楼 weixin_51970786 的回复:][quote=引用 2 楼 自信男孩 的回复:][quote=引用 1 楼 自信男孩 的回复:]static int score_cmp(int s1, int s2) {     if (s1 > s2)         return 1;     else if (s1 == s2)         return 0;     else         return -1; }  void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt) {     struct _Student stu;     Node *p, *q;     int flag = 0;     if (!phead)         return;      p = q = phead;      for (;p;p = p->pNext)         for (;q;q = q->pNext) {             flag = 0;             switch (opt) {                 case 1:                 if (pcmp(p->stu.math, q->stu.math) > 0)                     flag = 1;                 break;                  case 2:                 if (pcmp(p->stu.english, q->stu.english) > 0)                     flag = 1;                 break;                  case 3:                 if (pcmp(p->stu.c, q->stu.c) > 0)                     flag = 1;                 break;                  case 4:                 if (pcmp(p->stu.pe, q->stu.pe) > 0)                     flag = 1;                 break;                  case 5:                 if (pcmp(p->stu.total, q->stu.total) > 0)                     flag = 1;                 break;             }              if (flag) {                 stu = p->stu;                 p->stu = q->stu;                 q->stu = stu;             }         } }  void Order()//成绩排序函数 {     struct _Student stu[N];     int b,i,j;     system(\"cls\");     printf(\"请选择你想要排序的科目:1.数学  2.英语  3.C语言  4.体育  5.总成绩\\n\");     scanf(\"%d\",&b);      bubble_sort(g_pHead, score_cmp, b);     } 排序逻辑，供参考～  没测试，建议用这个代码试一下，之前写过类似的，测试过没问题。先试试吧，这个有问题可以继续提问～[/quote]         请问如果排序完要按顺序输入该怎么写[/quote]打错了，是输出该怎么写[/quote]  那就是链表遍历的操作，如果不会网上搜搜。其实很简单  Node *p = g_head;  while(p) {     printf(\"%s %dxxxxx\", p->stu.name,xxxx);     p = p->pNext; }  自己完善一下，封装成函数就好了 [/quote] #include<stdio.h> #include<conio.h> #include<stdlib.h> #define M 100  #define N 1000 //定义一个学生的信息 typedef struct _Student { \tchar name[20];  //姓名 \tint studid;//学号 \tint math;       //数学成绩 \tint english;    //英语成绩 \tint c;          //C语言成绩 \tint pe;         //体育成绩 \tint total;      //总成绩 }Student; //定义一个节点 typedef struct _Node {    Student stu;//学生     struct _Node* pNext; }Node; Node*g_pHead=NULL;             //头结点  char password[20]=\"4396\";            //管理员密码 void Menu();//声明菜单界面函数  void Input();//声明成绩录入函数  void Print();//声明成绩显示函数  void Save();//声明成绩保存函数 void Order();//声明成绩排序函数  void Modify();//声明成绩修改函数 void Sta();//声明成绩统计函数  void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt); int main(){ \tint a;  \twhile(1){  //while循环使程序持续运行  \tMenu(); \tscanf(\"%d\",&a); \tswitch(a)//**用户进行选择**// { case 1: \tInput(); //成绩录入  \tbreak; case 2: \tPrint();//成绩显示  \tbreak; case 3: \tSave();//成绩保存  \tbreak; case 4: \tOrder();//成绩排序  \tbreak; case 5: \tModify();//成绩修改  \tbreak; case 6: \tprintf(\"成绩统计\\n\"); \tbreak; case 7: \tprintf(\"您已成功退出系统，欢迎下次使用！\\n\"); \treturn 0; default: \tprintf(\"无效选择，请重新输入\\n\"); \tbreak;  } }\t \treturn 0; }  void Menu()//菜单界面函数  {\t         printf(\"\\t\\t\\t欢迎使用学生班级成绩管理系统！\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t          主菜单                   ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t==\\t\\t1.成绩录入                 ==\\n\");         printf(\"\\t\\t==\\t\\t2.成绩显示                 ==\\n\");         printf(\"\\t\\t==\\t\\t3.成绩保存                 ==\\n\");         printf(\"\\t\\t==\\t\\t4.成绩排序                 ==\\n\");         printf(\"\\t\\t==\\t\\t5.成绩修改                 ==\\n\");         printf(\"\\t\\t==\\t\\t6.成绩统计                 ==\\n\");         printf(\"\\t\\t==\\t\\t7.系统退出                 ==\\n\");         printf(\"\\t\\t=============================================\\n\");         printf(\"\\t\\t===========请选择相应的功能列表==============\\n\");      } void Input()//成绩录入函数 { \tNode* pNewNode =(Node*)malloc(sizeof(Node));//创建一个新节点  \tpNewNode->pNext=NULL; \tif(g_pHead==NULL) \t{ \t\tg_pHead=pNewNode; \t} \telse \t{ \t\tpNewNode->pNext=g_pHead; \t\tg_pHead=pNewNode; \t} \tprintf(\"请输入学生的姓名：\\n\"); \tscanf(\"%s\",pNewNode->stu.name); \tprintf(\"请输入学生的学号：\\n\"); \tscanf(\"%d\",&pNewNode->stu.studid); \tprintf(\"请输入学生的数学成绩：\\n\"); \tscanf(\"%d\",&pNewNode->stu.math); \tprintf(\"请输入学生的英语成绩：\\n\"); \tscanf(\"%d\",&pNewNode->stu.english); \tprintf(\"请输入学生的C语言成绩：\\n\"); \tscanf(\"%d\",&pNewNode->stu.c); \tprintf(\"请输入学生的体育成绩：\\n\"); \tscanf(\"%d\",&pNewNode->stu.pe); pNewNode->stu.total=pNewNode->stu.math+pNewNode->stu.english+pNewNode->stu.c+pNewNode->stu.pe; //总成绩  \tprintf(\"学生成绩录入成功！\\n\"); \tsystem(\"pause\");      //暂停执行 \tsystem(\"cls\");        //清屏 \t \t \t \t \t }  void Print()//成绩显示函数  { \tsystem(\"cls\"); \tprintf(\"                     学生成绩表                         \\n\"); \tprintf(\"========================================================\\n\"); \tprintf(\"姓名\\t学号\\t数学\\t英语\\tC语言\\t  体育\\t  总成绩\\n\"); \t//遍历链表，一次打印出学生的成绩 \tNode* p=g_pHead; \twhile(p!=NULL) \t{ \t\t \t\tprintf(\"%s      %d    %d    %d    %d     %d    %d\\n\", \t\tp->stu.name,p->stu.studid,p->stu.math,p->stu.english,p->stu.c,p->stu.pe,p->stu.total); \t\tp=p->pNext;//指向下一个，少了这个会无限循环  \t }  \tsystem(\"pause\"); } void Save()//成绩保存函数 {   //打开文件  \tFILE* fp=fopen(\"StuInformation.data\",\"w\"); \tif(fp==NULL) \t{ \t\tprintf(\"文件打开失败.\\n\"); \t\treturn; \t} \t//再次遍历链表，保存学生的成绩 \tNode* p=g_pHead; \twhile(p!=NULL) \t{ \t  fwrite(&p->stu,1,sizeof(Student),fp); \t  p=p->pNext; \t}  \t//关闭文件 \tfclose(fp); \tprintf(\"\\n学生成绩保存成功！\");      system(\"cls\"); \tsystem(\"fause\");//'fause' 不是内部或外部命令，也不是可运行的程序或批处理文件??\t  }  static int score_cmp(int s1, int s2) {     if (s1 > s2)         return 1;     else if (s1 == s2)         return 0;     else         return -1; }   void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt) {     struct _Student stu;     Node *p, *q;     int flag = 0;     if (!phead)         return;       p = q = phead;       for (;p;p = p->pNext)         for (;q;q = q->pNext) {             flag = 0;             switch (opt) {                 case 1:                 if (pcmp(p->stu.math, q->stu.math) > 0)                     flag = 1;                 break;                   case 2:                 if (pcmp(p->stu.english, q->stu.english) > 0)                     flag = 1;                 break;                   case 3:                 if (pcmp(p->stu.c, q->stu.c) > 0)                     flag = 1;                 break;                   case 4:                 if (pcmp(p->stu.pe, q->stu.pe) > 0)                     flag = 1;                 break;                   case 5:                 if (pcmp(p->stu.total, q->stu.total) > 0)                     flag = 1;                 break;             }               if (flag) {                 stu = p->stu;                 p->stu = q->stu;                 q->stu = stu;             }         } }   void Order()//成绩排序函数 {     struct _Student stu[N];     int b,i,j;     system(\"cls\");     printf(\"请选择你想要排序的科目:1.数学  2.英语  3.C语言  4.体育  5.总成绩\\n\");     scanf(\"%d\",&b);       bubble_sort(g_pHead, score_cmp, b);\t     Node *p =g_pHead;  while(p) {     printf(\"%d\\n\", p->stu.total);     p = p->pNext; } }    void Modify()//成绩修改函数   {   \tint studid,c;   \tchar d[20];   \tprintf(\"请输入管理员密码：\");   \tscanf(\"%s\",d);   \tif(strcmp(password,d)==0)   \t{   \t\tprintf(\"管理员登陆成功.\\n\");   \t\tprintf(\"请输入学生的学号:\\n\");    \tscanf(\"%d\",&studid);   \tNode* p=g_pHead;   \twhile(p!=NULL)   \t{   \t\tif(p->stu.studid==studid)   \t\t{   \t\t\tprintf(\"请输入要修改成绩的科目：1.数学  2.英语  3.C语言  4.体育\\n\");   \t\t\tscanf(\"%d\",&c);   \t\t\tprintf(\"请输入你要改的分数：\\n\");   \t\t\tswitch(c) \t\t\t  { \t\t\t  \tcase 1: \t\t\t\tscanf(\"%d\",&p->stu.math); \t\t\t\tbreak; \t\t\t\tcase 2: \t\t\t\tscanf(\"%d\",&p->stu.english); \t\t\t\tbreak;\t\t\t \t\t\t\tcase 3: \t\t\t\tscanf(\"%d\",&p->stu.c); \t\t\t\tbreak;\t\t\t\t\t\t\t\t \t\t\t\tcase 4: \t\t\t\tscanf(\"%d\",&p->stu.math); \t\t\t\tbreak;\t\t\t \t\t\t  } \t\t\t  system(\"cls\"); \t\t\t  printf(\"成绩修改成功\\n\"); \t\t\t  system(\"pause\");  \t\t\t  break;      \t\t\t   \t\t\t \t\t  } \t\t  p=p->pNext;   \t\t \t  } \t  if(p==NULL) \t  { \t  \tprintf(\"没有找到该学生的信息.\\n\"); \t  \tsystem(\"pause\"); \t\tsystem(\"cls\"); \t  }   \t \t  } \twhile(strcmp(password,d)!=0) \t  { \t  \tsystem(\"cls\"); \t    printf(\"密码错误,返回主菜单\\n\"); \t    system(\"pause\"); \t    break;  \t }   \t    } 这是我已经改了的，为什么运行后打印出来的总分数还是乱序的？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 4 楼 weixin_51970786 的回复:[quote=引用 3 楼 weixin_51970786 的回复:][quote=引用 2 楼 自信男孩 的回复:][quote=引用 1 楼 自信男孩 的回复:]static int score_cmp(int s1, int s2) {     if (s1 > s2)         return 1;     else if (s1 == s2)         return 0;     else         return -1; }  void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt) {     struct _Student stu;     Node *p, *q;     int flag = 0;     if (!phead)         return;      p = q = phead;      for (;p;p = p->pNext)         for (;q;q = q->pNext) {             flag = 0;             switch (opt) {                 case 1:                 if (pcmp(p->stu.math, q->stu.math) > 0)                     flag = 1;                 break;                  case 2:                 if (pcmp(p->stu.english, q->stu.english) > 0)                     flag = 1;                 break;                  case 3:                 if (pcmp(p->stu.c, q->stu.c) > 0)                     flag = 1;                 break;                  case 4:                 if (pcmp(p->stu.pe, q->stu.pe) > 0)                     flag = 1;                 break;                  case 5:                 if (pcmp(p->stu.total, q->stu.total) > 0)                     flag = 1;                 break;             }              if (flag) {                 stu = p->stu;                 p->stu = q->stu;                 q->stu = stu;             }         } }  void Order()//成绩排序函数 {     struct _Student stu[N];     int b,i,j;     system(\"cls\");     printf(\"请选择你想要排序的科目:1.数学  2.英语  3.C语言  4.体育  5.总成绩\\n\");     scanf(\"%d\",&b);      bubble_sort(g_pHead, score_cmp, b);     /*     switch(b)     {         case 1:for(i=0;i<=M;i++)//数学成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].math>stu[i].math)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                         }                      }                }                for(;j<=M;j--)                {                    printf(\"%d\",stu[j].math);                }                break;         case 2:for(i=0;i<=M;i++)//英语成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].english>stu[i].english)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 3:for(i=0;i<=M;i++)//C语言成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].c>stu[i].c)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 4:for(i=0;i<=M;i++)//体育成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].pe>stu[i].pe)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                }                break;         case 5:for(i=0;i<=M;i++)//总成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].total>stu[i].total)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                  }                break;         default: printf(\"无效操作，请重新输入.\");     } */ } 排序逻辑，供参考～  没测试，建议用这个代码试一下，之前写过类似的，测试过没问题。先试试吧，这个有问题可以继续提问～[/quote]         请问如果排序完要按顺序输入该怎么写[/quote]打错了，是输出该怎么写[/quote]  那就是链表遍历的操作，如果不会网上搜搜。其实很简单  Node *p = g_head;  while(p) {     printf(\"%s %dxxxxx\", p->stu.name,xxxx);     p = p->pNext; }  自己完善一下，封装成函数就好了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 weixin_51970786 的回复:[quote=引用 2 楼 自信男孩 的回复:][quote=引用 1 楼 自信男孩 的回复:]static int score_cmp(int s1, int s2) {     if (s1 > s2)         return 1;     else if (s1 == s2)         return 0;     else         return -1; }  void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt) {     struct _Student stu;     Node *p, *q;     int flag = 0;     if (!phead)         return;      p = q = phead;      for (;p;p = p->pNext)         for (;q;q = q->pNext) {             flag = 0;             switch (opt) {                 case 1:                 if (pcmp(p->stu.math, q->stu.math) > 0)                     flag = 1;                 break;                  case 2:                 if (pcmp(p->stu.english, q->stu.english) > 0)                     flag = 1;                 break;                  case 3:                 if (pcmp(p->stu.c, q->stu.c) > 0)                     flag = 1;                 break;                  case 4:                 if (pcmp(p->stu.pe, q->stu.pe) > 0)                     flag = 1;                 break;                  case 5:                 if (pcmp(p->stu.total, q->stu.total) > 0)                     flag = 1;                 break;             }              if (flag) {                 stu = p->stu;                 p->stu = q->stu;                 q->stu = stu;             }         } }  void Order()//成绩排序函数 {     struct _Student stu[N];     int b,i,j;     system(\"cls\");     printf(\"请选择你想要排序的科目:1.数学  2.英语  3.C语言  4.体育  5.总成绩\\n\");     scanf(\"%d\",&b);      bubble_sort(g_pHead, score_cmp, b);     /*     switch(b)     {         case 1:for(i=0;i<=M;i++)//数学成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].math>stu[i].math)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                         }                      }                }                for(;j<=M;j--)                {                    printf(\"%d\",stu[j].math);                }                break;         case 2:for(i=0;i<=M;i++)//英语成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].english>stu[i].english)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 3:for(i=0;i<=M;i++)//C语言成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].c>stu[i].c)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 4:for(i=0;i<=M;i++)//体育成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].pe>stu[i].pe)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                }                break;         case 5:for(i=0;i<=M;i++)//总成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].total>stu[i].total)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                  }                break;         default: printf(\"无效操作，请重新输入.\");     } */ } 排序逻辑，供参考～  没测试，建议用这个代码试一下，之前写过类似的，测试过没问题。先试试吧，这个有问题可以继续提问～[/quote]         请问如果排序完要按顺序输入该怎么写[/quote]打错了，是输出该怎么写", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:[quote=引用 1 楼 自信男孩 的回复:]static int score_cmp(int s1, int s2) {     if (s1 > s2)         return 1;     else if (s1 == s2)         return 0;     else         return -1; }  void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt) {     struct _Student stu;     Node *p, *q;     int flag = 0;     if (!phead)         return;      p = q = phead;      for (;p;p = p->pNext)         for (;q;q = q->pNext) {             flag = 0;             switch (opt) {                 case 1:                 if (pcmp(p->stu.math, q->stu.math) > 0)                     flag = 1;                 break;                  case 2:                 if (pcmp(p->stu.english, q->stu.english) > 0)                     flag = 1;                 break;                  case 3:                 if (pcmp(p->stu.c, q->stu.c) > 0)                     flag = 1;                 break;                  case 4:                 if (pcmp(p->stu.pe, q->stu.pe) > 0)                     flag = 1;                 break;                  case 5:                 if (pcmp(p->stu.total, q->stu.total) > 0)                     flag = 1;                 break;             }              if (flag) {                 stu = p->stu;                 p->stu = q->stu;                 q->stu = stu;             }         } }  void Order()//成绩排序函数 {     struct _Student stu[N];     int b,i,j;     system(\"cls\");     printf(\"请选择你想要排序的科目:1.数学  2.英语  3.C语言  4.体育  5.总成绩\\n\");     scanf(\"%d\",&b);      bubble_sort(g_pHead, score_cmp, b);     /*     switch(b)     {         case 1:for(i=0;i<=M;i++)//数学成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].math>stu[i].math)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                         }                      }                }                for(;j<=M;j--)                {                    printf(\"%d\",stu[j].math);                }                break;         case 2:for(i=0;i<=M;i++)//英语成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].english>stu[i].english)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 3:for(i=0;i<=M;i++)//C语言成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].c>stu[i].c)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 4:for(i=0;i<=M;i++)//体育成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].pe>stu[i].pe)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                }                break;         case 5:for(i=0;i<=M;i++)//总成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].total>stu[i].total)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                  }                break;         default: printf(\"无效操作，请重新输入.\");     } */ } 排序逻辑，供参考～  没测试，建议用这个代码试一下，之前写过类似的，测试过没问题。先试试吧，这个有问题可以继续提问～[/quote]         请问如果排序完要按顺序输入该怎么写", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 1 楼 自信男孩 的回复:static int score_cmp(int s1, int s2) {     if (s1 > s2)         return 1;     else if (s1 == s2)         return 0;     else         return -1; }  void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt) {     struct _Student stu;     Node *p, *q;     int flag = 0;     if (!phead)         return;      p = q = phead;      for (;p;p = p->pNext)         for (;q;q = q->pNext) {             flag = 0;             switch (opt) {                 case 1:                 if (pcmp(p->stu.math, q->stu.math) > 0)                     flag = 1;                 break;                  case 2:                 if (pcmp(p->stu.english, q->stu.english) > 0)                     flag = 1;                 break;                  case 3:                 if (pcmp(p->stu.c, q->stu.c) > 0)                     flag = 1;                 break;                  case 4:                 if (pcmp(p->stu.pe, q->stu.pe) > 0)                     flag = 1;                 break;                  case 5:                 if (pcmp(p->stu.total, q->stu.total) > 0)                     flag = 1;                 break;             }              if (flag) {                 stu = p->stu;                 p->stu = q->stu;                 q->stu = stu;             }         } }  void Order()//成绩排序函数 {     struct _Student stu[N];     int b,i,j;     system(\"cls\");     printf(\"请选择你想要排序的科目:1.数学  2.英语  3.C语言  4.体育  5.总成绩\\n\");     scanf(\"%d\",&b);      bubble_sort(g_pHead, score_cmp, b);     /*     switch(b)     {         case 1:for(i=0;i<=M;i++)//数学成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].math>stu[i].math)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                         }                      }                }                for(;j<=M;j--)                {                    printf(\"%d\",stu[j].math);                }                break;         case 2:for(i=0;i<=M;i++)//英语成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].english>stu[i].english)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 3:for(i=0;i<=M;i++)//C语言成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].c>stu[i].c)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 4:for(i=0;i<=M;i++)//体育成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].pe>stu[i].pe)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                }                break;         case 5:for(i=0;i<=M;i++)//总成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].total>stu[i].total)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                  }                break;         default: printf(\"无效操作，请重新输入.\");     } */ } 排序逻辑，供参考～  没测试，建议用这个代码试一下，之前写过类似的，测试过没问题。先试试吧，这个有问题可以继续提问～", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "static int score_cmp(int s1, int s2) {     if (s1 > s2)         return 1;     else if (s1 == s2)         return 0;     else         return -1; }  void bubble_sort(Node *phead, int (*pcmp)(int, int), int opt) {     struct _Student stu;     Node *p, *q;     int flag = 0;     if (!phead)         return;      p = q = phead;      for (;p;p = p->pNext)         for (;q;q = q->pNext) {             flag = 0;             switch (opt) {                 case 1:                 if (pcmp(p->stu.math, q->stu.math) > 0)                     flag = 1;                 break;                  case 2:                 if (pcmp(p->stu.english, q->stu.english) > 0)                     flag = 1;                 break;                  case 3:                 if (pcmp(p->stu.c, q->stu.c) > 0)                     flag = 1;                 break;                  case 4:                 if (pcmp(p->stu.pe, q->stu.pe) > 0)                     flag = 1;                 break;                  case 5:                 if (pcmp(p->stu.total, q->stu.total) > 0)                     flag = 1;                 break;             }              if (flag) {                 stu = p->stu;                 p->stu = q->stu;                 q->stu = stu;             }         } }  void Order()//成绩排序函数 {     struct _Student stu[N];     int b,i,j;     system(\"cls\");     printf(\"请选择你想要排序的科目:1.数学  2.英语  3.C语言  4.体育  5.总成绩\\n\");     scanf(\"%d\",&b);      bubble_sort(g_pHead, score_cmp, b);     /*     switch(b)     {         case 1:for(i=0;i<=M;i++)//数学成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].math>stu[i].math)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                         }                      }                }                for(;j<=M;j--)                {                    printf(\"%d\",stu[j].math);                }                break;         case 2:for(i=0;i<=M;i++)//英语成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].english>stu[i].english)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 3:for(i=0;i<=M;i++)//C语言成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].c>stu[i].c)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                    }                 }                break;         case 4:for(i=0;i<=M;i++)//体育成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].pe>stu[i].pe)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                }                break;         case 5:for(i=0;i<=M;i++)//总成绩排序                {                    for(j=i+1;j<=M;j++)                    {                        if(stu[j].total>stu[i].total)                        {                            x=stu[j];                            stu[j]=stu[i];                            stu[i]=x;                        }                     }                  }                break;         default: printf(\"无效操作，请重新输入.\");     } */ } 排序逻辑，供参考～", "referer": "user-0"}]}
{"question": "C语言排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "for循环的第二个是j = 9;这个写的比较固定的，这个应该和n有关系的一个数。 另外，当j=9时，j+1不就是10了，Temp[10]是不是越界了？下表最大是不是应该为9，没看到你的数组长度，所以只能猜测", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "看着眼睛疼。直接上代码多好。。谁有空给你慢慢敲。。。", "referer": "user-0"}]}
{"question": "MIPS问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "clock()函数一直都是最大值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//printf(\"%d\",duration ); printf(\"%lf\\n\",duration );  duration定义成double类型，然后%lf输出。 楼主的结果是0，因为不了解double和int类型数据在内存的存放是不一样的。建议楼主了解一下～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "https://fanyi.baidu.com/#en/zh/Return%20Value%0A%0Aclock%20returns%20the%20number%20of%20clock%20ticks%20of%20elapsed%20processor%20time.%20The%20returned%20value%20is%20the%20product%20of%20the%20amount%20of%20time%20that%20has%20elapsed%20since%20the%20start%20of%20a%20process%20and%20the%20value%20of%20the%20CLOCKS_PER_SEC%20constant.%20If%20the%20amount%20of%20elapsed%20time%20is%20unavailable%2C%20the%20function%20returns%20%E2%80%931%2C%20cast%20as%20a%20clock_t.", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "clock函数我看了，但是我直接main函数里就直接调用了clock，然后一执行，显示对应的clock_t的参数就是0xffffff，下面是对应的程序； int main(void) { clock_t start,end; start=clock(); sleep(500); end=clcok();  duration = (double)(end- start) / CLOCKS_PER_SEC; printf(\"%d\",duration ); } 结果显示的是0 ；然后分步执行，查看对应的参数，start和end都是最大值0xffffff，", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "clock Calculates the processor time used by the calling process.  clock_t clock( void );  Routine Required Header Compatibility  clock <time.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  clock returns the number of clock ticks of elapsed processor time. The returned value is the product of the amount of time that has elapsed since the start of a process and the value of the CLOCKS_PER_SEC constant. If the amount of elapsed time is unavailable, the function returns –1, cast as a clock_t.  Remarks  The clock function tells how much processor time the calling process has used. The time in seconds is approximated by dividing the clock return value by the value of the CLOCKS_PER_SEC constant. In other words, clock returns the number of processor timer ticks that have elapsed. A timer tick is approximately equal to 1/CLOCKS_PER_SEC second. In versions of Microsoft C before 6.0, the CLOCKS_PER_SEC constant was called CLK_TCK.  Example   /* CLOCK.C: This example prompts for how long  * the program is to run and then continuously  * displays the elapsed time for that period.  */  #include <stdio.h> #include <stdlib.h> #include <time.h>  void sleep( clock_t wait );  void main( void ) {    long    i = 600000L;    clock_t start, finish;    double  duration;     /* Delay for a specified time. */    printf( \"Delay for three seconds\\n\" );    sleep( (clock_t)3 * CLOCKS_PER_SEC );    printf( \"Done!\\n\" );     /* Measure the duration of an event. */    printf( \"Time to do %ld empty loops is \", i );    start = clock();    while( i-- )        ;    finish = clock();    duration = (double)(finish - start) / CLOCKS_PER_SEC;    printf( \"%2.1f seconds\\n\", duration ); }  /* Pauses for a specified number of milliseconds. */ void sleep( clock_t wait ) {    clock_t goal;    goal = wait + clock();    while( goal > clock() )       ; }   Output  Delay for three seconds Done! Time to do 600000 empty loops is 0.1 seconds     Time Management Routines  See Also   difftime, time", "referer": "user-0"}]}
{"question": "球球各位大神看看吧！为什么while(p21)里面的循环执行不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "解决了！谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "修正5#楼的错误，change()函数还是实现修改功能的，我忘了修改后是没保存的，见代码：#include <stdio.h> #include <stdlib.h> #include <string.h>  struct message {     char   name[10];//用户     char   use[50];//用途     double income;//收入     double spend;//支出     char   time[10];//使用时间     double sum;//余额     struct message *next; };  struct message *Findfile(struct message *head1)//将文件信息存到链表中 {     struct message *head;     FILE *fp1;     struct message *p1,*p2;      if((fp1=fopen(\"money.in\",\"r\"))==NULL){         printf(\"cannot open file\\n\");         return 0;     }     if (head1 == NULL){         head1=(struct message* )malloc(sizeof(struct message));//生成头节点         head = head1;         head1->next=NULL;     }else{         for(head=head1;head->next!=NULL;head=head->next);//找到节点尾部     }     p2 = head;     while(1){         p1=(struct message* )malloc(sizeof(struct message));         if(fscanf(fp1,\"%s %s %lf %lf %s %lf\\n\",p1->name,p1->use,&p1->income,                                              &p1->spend,p1->time,&p1->sum)!=6)break;         p1->next=NULL;                        //从文件里读入信息的各参数顺序和结构体里定义的顺序一样         if(head==NULL) head->next=p1;         //文件保存时也必须是按此顺序排列。         else p2->next=p1;         p2=p1;     }     fclose(fp1);     return head1; }  void Correct(struct message *head3) {     struct message *p31=head3,*p32=p31->next;     while(p31&&p32)     {         p32->sum=(p31->sum)+(p32->income)-(p32->spend);         p31=p31->next;         p32=p31->next;     } }  void Change(struct message *head2)  //修改 {     int k=0,choice;     struct message *p21,*p22=head2,*p23,*p24=head2;     p21=head2;     char name[10];     printf(\"请输入要修改的人的名字：\");     scanf(\"%s\",name);     while(p21)     {         if(strcmp(p21->name,name)==0)         {             k++;             printf(\"[%d] %s %.2f %.2f %.2f %s %s\\n\",k,p21->name,                      p21->income,p21->spend,p21->sum,p21->use,p21->time);         }         p21=p21->next;     }     if(k!=0)     {         printf(\"选择要修改的账户信息的序号：\");         scanf(\"%d\",&k);         while(k)         {             if(strcmp(p22->name,name)==0)             {                 k--;                 p23=p22;                 p22=p22->next;             }             else             {                 p23=p22;                 p22=p22->next;             }         }         printf(\"选择要修改的账户信息的项目序号(1:姓名,2:收入金额,3:支出金额,4:用途,5:使用时间)：\");         scanf(\"%d\",&choice);         //while(choice) //这里的while造成死循环,这里是想实现多项目多次的修改吗 ？         //{         switch(choice)             {             case 1:                 {                     printf(\"请输入更正后的姓名：\");                     scanf(\"%s\",p23->name);                     printf(\"修改成功\\n\");                     break;                 }             case 2:                 {                     printf(\"请输入更正后的收入金额：\");                     scanf(\"%lf\",&p23->income);                     printf(\"修改成功\\n\");                     break;                 }             case 3:                 {                     printf(\"请输入更正后的支出金额：\");                     scanf(\"%lf\",&p23->spend);                     printf(\"修改成功\\n\");                     break;                 }             case 4:                 {                     printf(\"请输入更正后的用途：\");                     scanf(\"%s\",p23->use);                     printf(\"修改成功\\n\");                     break;                 }             case 5:                 {                     printf(\"请输入更正后的使用时间：\");                     scanf(\"%s\",p23->time);                     printf(\"修改成功\\n\");                     break;                 }             case 0:break;             default:                    printf(\"请输入正确的序号：\");                    break;             }         if(choice==2||choice==3)         {            if(p24==p23)            {               p24->sum=p23->income-p23->spend;            }            else              {                while(p24->next!=p23)                 {                   p24=p24->next;                 }                Correct(p24);              }          }         //}     }     else     {         printf(\"查无此人！\");     } }  int main() {    struct message *head=NULL,*p;    head = Findfile(head);     for(p = head->next;p!= NULL; p=p->next)    //这里加两句，输出看看文件读入的情况，调试好可以删除        printf(\"%s %s %f %f %s %f\\n\",p->name,p->use,p->income,p->spend,p->time,p->sum);            int power=1;    if(power)    {        Change(head);    }     for(p = head->next;p!= NULL; p=p->next)            printf(\"%s %s %f %f %s %f\\n\",p->name,p->use,p->income,p->spend,p->time,p->sum);     system(\"pause\");    return 0; }    //1111 gz 300.000000 100.000000 20210316 200.000000 //1122 gz 300.000000 100.000000 20210316 200.000000 //1133 gz 300.000000 100.000000 20210316 200.000000 //1144 gz 300.000000 100.000000 20210316 200.000000 //请输入要修改的人的名字：1111 //[1] 1111 300.00 100.00 200.00 gz 20210316 //选择要修改的账户信息的序号：1 //选择要修改的账户信息的项目序号(1:姓名,2:收入金额,3:支出金额,4:用途,5:使用时间)：1 //请输入更正后的姓名：5555 //修改成功 //5555 gz 300.000000 100.000000 20210316 200.000000 //1122 gz 300.000000 100.000000 20210316 200.000000 //1133 gz 300.000000 100.000000 20210316 200.000000 //1144 gz 300.000000 100.000000 20210316 200.000000 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "调通代码，但修改函数Change（）的功能没实现目标呢，似乎楼主考虑得太复杂了，其他问题见代码，供参考：#include <stdio.h> #include <stdlib.h> #include <string.h>  struct message {     char   name[10];//用户     char   use[50];//用途     double income;//收入     double spend;//支出     char   time[10];//使用时间     double sum;//余额     struct message *next; };  struct message *Findfile(struct message *head1)//将文件信息存到链表中 {     struct message *head;     FILE *fp1;     struct message *p1,*p2;      if((fp1=fopen(\"money.in\",\"r\"))==NULL){         printf(\"cannot open file\\n\");         return 0;     }     if (head1 == NULL){         head1=(struct message* )malloc(sizeof(struct message));//生成头节点         head = head1;         head1->next=NULL;     }else{         for(head=head1;head->next!=NULL;head=head->next);//找到节点尾部     }     p2 = head;     while(1){         p1=(struct message* )malloc(sizeof(struct message));         if(fscanf(fp1,\"%s %s %lf %lf %s %lf\\n\",p1->name,p1->use,&p1->income,                                              &p1->spend,p1->time,&p1->sum)!=6)break;         p1->next=NULL;                        //从文件里读入信息的各参数顺序和结构体里定义的顺序一样         if(head==NULL) head->next=p1;         //文件保存时也必须是按此顺序排列。         else p2->next=p1;         p2=p1;     }     fclose(fp1);     return head1; }  void Correct(struct message *head3) {     struct message *p31=head3,*p32=p31->next;     while(p31&&p32)     {         p32->sum=(p31->sum)+(p32->income)-(p32->spend);         p31=p31->next;         p32=p31->next;     } }  void Change(struct message *head2)  //修改 {     int k=0,choice;     struct message *p21,*p22=head2,*p23,*p24=head2;     p21=head2;     char name[10];     printf(\"请输入要修改的人的名字：\");     scanf(\"%s\",name);     while(p21)     {         if(strcmp(p21->name,name)==0)         {             k++;             printf(\"[%d] %s %.2f %.2f %.2f %s %s\\n\",k,p21->name,                      p21->income,p21->spend,p21->sum,p21->use,p21->time);         }         p21=p21->next;     }     if(k!=0)     {         printf(\"选择要修改的账户信息的序号：\");         scanf(\"%d\",&k);         while(k)                       //这段的算法没成功，就是不能实现下面的对信息的修改定位         {             if(strcmp(p22->name,name)==0)             {                 k--;                 p23=p22;                 p22=p22->next;             }             else             {                 p23=p22;                 p22=p22->next;             }         }         printf(\"选择要修改的账户信息的项目序号(1:姓名,2:收入金额,3:支出金额,4:用途,5:使用时间)：\");         scanf(\"%d\",&choice);         //while(choice) //这里的while多余了，造成死循环         //{         switch(choice)             {             case 1:                 {                     printf(\"请输入更正后的姓名：\");                     scanf(\"%s\",p23->name);                     printf(\"修改成功\");                     break;                 }             case 2:                 {                     printf(\"请输入更正后的收入金额：\");                     scanf(\"%lf\",&p23->income);                     printf(\"修改成功\");                     break;                 }             case 3:                 {                     printf(\"请输入更正后的支出金额：\");                     scanf(\"%lf\",&p23->spend);                     printf(\"修改成功\");                     break;                 }             case 4:                 {                     printf(\"请输入更正后的用途：\");                     scanf(\"%s\",p23->use);                     printf(\"修改成功\");                     break;                 }             case 5:                 {                     printf(\"请输入更正后的使用时间：\");                     scanf(\"%s\",p23->time);                     printf(\"修改成功\");                     break;                 }             case 0:break;             default:                    printf(\"请输入正确的序号：\");                    break;             }         if(choice==2||choice==3)         //这段的算法和上面同样问题         {            if(p24==p23)            {               p24->sum=p23->income-p23->spend;            }            else              {                while(p24->next!=p23)                 {                   p24=p24->next;                 }                Correct(p24);              }          }         //}     }     else     {         printf(\"查无此人！\");     } }  int main() {    struct message *head=NULL,*p;    head = Findfile(head);     for(p = head->next;p!= NULL; p=p->next)    //这里加两句，输出看看文件读入的情况，调试好可以删除        printf(\"%s %s %f %f %s %f\\n\",p->name,p->use,p->income,p->spend,p->time,p->sum);            int power=1;    if(power)    {        Change(head);    }    system(\"pause\");    return 0; }  //下面是试运行的结果：  //1111 gz 300.000000 100.000000 20210316 200.000000 //1122 gz 300.000000 100.000000 20210316 200.000000 //1133 gz 300.000000 100.000000 20210316 200.000000 //1144 gz 300.000000 100.000000 20210316 200.000000 //请输入要修改的人的名字：1111 //[1] 1111 300.00 100.00 200.00 gz 20210316 //选择要修改的账户信息的序号：1 //选择要修改的账户信息的项目序号(1:姓名,2:收入金额,3:支出金额,4:用途,5:使用时间)：1 //请输入更正后的姓名：2211 //修改成功请按任意键继续. . .  这里运行时虽然显示修改成功，但再次读入时没有变化", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>  struct message {     char name[10];//用户     char use[50];//用途     double income;//收入     double spend;//支出     char time[10];//使用时间     double sum;//余额     struct message *next; };  struct message *Findfile(struct message *head1)//将文件信息存到链表中 {     struct message *head=NULL;     FILE *fp1;     //char c;     int c;     struct message *p1,*p2;     char name[10];//用户     char use[50];//用途     double income;//收入     double spend;//支出     char time[10];//使用时间     double sum;//余额      if((fp1=fopen(\"money.in\",\"r\"))==NULL)     {         printf(\"cannot open file\\n\");         return 0;     }     //while((c=fgetc(fp1))!=EOF)     while((c=fgetc(fp1))!=EOF)  //c表示不了EOF,因此要用int定义c     {         fseek(fp1,-1,SEEK_CUR);    //这儿的操作似乎没有意义～         p1=(struct message* )malloc(sizeof(struct message));         fscanf(fp1,\"%s%lf%lf%lf%s%s\\n\",name,&income,&spend,&sum,use,time);         strcpy(p1->name,name);         strcpy(p1->use,use);         p1->income=income;         p1->spend=spend;         strcpy(p1->time,time);         p1->sum=sum;         p1->next=NULL;         if(head==NULL)             head=p1;         else             p2->next=p1;         p2=p1;     }      fclose(fp1);     return head1; } void Correct(struct message *head3) {     struct message *p31=head3,*p32=p31->next;     while(p31&&p32)     {         p32->sum=(p31->sum)+(p32->income)-(p32->spend);         p31=p31->next;         p32=p31->next;     } } void Change(struct message *head2) {     int k=0,choice;     struct message *p21,*p22=head2,*p23,*p24=head2;     p21=head2;     char name[10];     printf(\"请输入要修改的人的名字：\");     scanf(\"%s\",name);     while(p21)     {         if(strcmp(p21->name,name)==0)         {             k++;             printf(\"[%d] %s %.2f %.2f %.2f %s %s\\n\",k,p21->name,p21->income,p21->spend,p21->sum,p21->use,p21->time);             break;//这儿是不是应该跳出         }         p21=p21->next;     }     if(k!=0)     {         printf(\"选择要修改的账户信息的序号：\");         scanf(\"%d\",&k);         while(k)         {             //if(strcmp(p22->name,name)==0) //比较有什么意义？if和else执行了基本上相同的逻辑除了k--             if(strcmp(p22->name,name)==0) //比较有什么意义？if和else执行了基本上相同的逻辑除了k--             {                 k--;                 p23=p22;                 p22=p22->next;             }             else             {                 p23=p22;                 p22=p22->next;             }         }         printf(\"选择要修改的账户信息的项目序号：\");         scanf(\"%d\",&choice);         while(choice)         {             switch(choice)             {                 case 1:                     {                         printf(\"请输入更正后的姓名：\");                         scanf(\"%s\",p23->name);    //此时的p23是否为你要找的节点，我看不一定，可能是NULL                         printf(\"修改成功\");                         break;                     }                 case 2:                     {                         printf(\"请输入更正后的收入金额：\");                         scanf(\"%lf\",&p23->income);                         printf(\"修改成功\");                         break;                     }                 case 3:                     {                         printf(\"请输入更正后的支出金额：\");                         scanf(\"%lf\",&p23->spend);                         printf(\"修改成功\");                         break;                     }                 case 4:                     {                         printf(\"请输入更正后的用途：\");                         scanf(\"%s\",p23->use);                         printf(\"修改成功\");                         break;                     }                 case 5:                     {                         printf(\"请输入更正后的使用时间：\");                         scanf(\"%s\",p23->time);                         printf(\"修改成功\");                         break;                     }                 case 0:break;                 default:                        printf(\"请输入正确的序号：\");                        break;              }             if(choice==2||choice==3)             {                 if(p24==p23)                 {                     p24->sum=p23->income-p23->spend;                 }                 else                 {                     while(p24->next!=p23)                     {                         p24=p24->next;                     }                     Correct(p24);                 }              }         }     }     else     {         printf(\"查无此人！\");     } } int main() {     struct message *head=NULL;     head=Findfile(head);     int power=1;     if(power)     {         Change(head);     }     return 0;  }  问题比较多，楼主的问题只是其中一个。建议楼主在Findfile函数执行完把创建的链表打印出来，确保进入Change函数里的链表是正常的。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "修正#2楼的，第43，44行之间插入一行：fclose(fp1);（得把打开的文件关闭了）", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "供参考：#include <stdio.h> #include <stdlib.h> #include <string.h>  struct message {     char name[10];//用户     char use[50];//用途     double income;//收入     double spend;//支出     char time[10];//使用时间     double sum;//余额     struct message *next; };  struct message *Findfile(struct message *head1)//将文件信息存到链表中 {     struct message *head;     FILE *fp1;     struct message *p1,*p2;      if((fp1=fopen(\"money.in\",\"r\"))==NULL)     {         printf(\"cannot open file\\n\");         return 0;     }     if (head1 == NULL){         head1=(struct message* )malloc(sizeof(struct message));//生成头节点         head = head1;         head1->next=NULL;     }else{         for(head=head1;head->next!=NULL;head=head->next);//找到节点尾部     }     p2 = head;     while(1){         p1=(struct message* )malloc(sizeof(struct message));         if(fscanf(fp1,\"%s%lf%lf%lf%s%s\\n\",p1->name,&p1->income,                      &p1->spend,&p1->sum,p1->use,p1->time)!=6)break;         p1->next=NULL;         if(head==NULL) head->next=p1;         else p2->next=p1;         p2=p1;     }     return head1; }  void Correct(struct message *head3) {     struct message *p31=head3,*p32=p31->next;     while(p31&&p32)     {         p32->sum=(p31->sum)+(p32->income)-(p32->spend);         p31=p31->next;         p32=p31->next;     } }  void Change(struct message *head2) {     int k=0,choice;     struct message *p21,*p22=head2,*p23,*p24=head2;     p21=head2;     char name[10];     printf(\"请输入要修改的人的名字：\");     scanf(\"%s\",name);     while(p21)     {         if(strcmp(p21->name,name)==0)         {             k++;             printf(\"[%d] %s %.2f %.2f %.2f %s %s\\n\",k,p21->name,                      p21->income,p21->spend,p21->sum,p21->use,p21->time);         }         p21=p21->next;     }     if(k!=0)     {         printf(\"选择要修改的账户信息的序号：\");         scanf(\"%d\",&k);         while(k)         {             if(strcmp(p22->name,name)==0)             {                 k--;                 p23=p22;                 p22=p22->next;             }             else             {                 p23=p22;                 p22=p22->next;             }         }         printf(\"选择要修改的账户信息的项目序号：\");         scanf(\"%d\",&choice);         while(choice)         {             switch(choice)             {             case 1:                 {                     printf(\"请输入更正后的姓名：\");                     scanf(\"%s\",p23->name);                     printf(\"修改成功\");                     break;                 }             case 2:                 {                     printf(\"请输入更正后的收入金额：\");                     scanf(\"%lf\",&p23->income);                     printf(\"修改成功\");                     break;                 }             case 3:                 {                     printf(\"请输入更正后的支出金额：\");                     scanf(\"%lf\",&p23->spend);                     printf(\"修改成功\");                     break;                 }             case 4:                 {                     printf(\"请输入更正后的用途：\");                     scanf(\"%s\",p23->use);                     printf(\"修改成功\");                     break;                 }             case 5:                 {                     printf(\"请输入更正后的使用时间：\");                     scanf(\"%s\",p23->time);                     printf(\"修改成功\");                     break;                 }             case 0:break;             default:             printf(\"请输入正确的序号：\");             break;              }             if(choice==2||choice==3)             {                 if(p24==p23)                 {                     p24->sum=p23->income-p23->spend;                 }                 else                 {                     while(p24->next!=p23)                     {                         p24=p24->next;                     }                     Correct(p24);                 }              }         }     }     else     {         printf(\"查无此人！\");     } }  int main() {    struct message *head=NULL;    head = Findfile(head);    int power=1;    if(power)    {        Change(head);    }    return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}]}
{"question": "用C语言数组最大值最小值碰到的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "min 和 max的初始值都需要指定一个。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "目标是消灭数组，直接求值   max    min  函数直接求值", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "min = max = a[0];是比较简单的初始话方法", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "最好的办法是将第一个数据赋值给max和min，这样最保险。否则当你输入的值都是负值的时候，你如果将max=min=0，结果也会有问题吧", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "哈哈，比较，总要有个初始值嘛。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 15 楼 智者知已应修善业的回复:学习编程能让人变得静思与反复推敲。 好的谢谢 懂了懂了", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "min的值是0，已经是非负数的最小值了。  int min = 100;", "referer": "user-0"}, {"cid": "10", "user": "user-9", "content": "学习编程能让人变得静思与反复推敲。", "referer": "user-0"}, {"cid": "11", "user": "user-9", "content": "就提问来说,数据类型是int应当知道有最大和最小的直接可以赋值INT_MIN,INT_MAX  引用 12 楼 Adorika 的回复:[quote=引用 5 楼 智者知已应修善业的回复:]通常最大值初始化为最小，最小值初始化为最大即可。 那应该怎么写呢[/quote]", "referer": "user-0"}, {"cid": "12", "user": "user-10", "content": "引用 11 楼 Adorika 的回复:[quote=引用 3 楼 真相重于对错的回复:]因为你所有的数字都大于0，所以无法比较出来 做最大值最小值咋可能不大于零呢[/quote] 举个例子你就清楚了 比如你输入 1，2，3，4，5 所有值都比0大，那么这些值和0比较都大， 因此 if(min>a[i]) {  。。。。。 }//这个判断语句块永远不会执行。 循环结束后，min还是0", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 5 楼 智者知已应修善业的回复:通常最大值初始化为最小，最小值初始化为最大即可。 那应该怎么写呢", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 3 楼 真相重于对错的回复:因为你所有的数字都大于0，所以无法比较出来 做最大值最小值咋可能不大于零呢", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:#include <stdio.h> #define N 30 int main() {     int a[N], min, max,  i, sum , avg;     printf(\"请输入%d名学生的成绩\\n\",N);     for (i=0; i < N; i++) {         while (1) {             printf(\"第%d名学生的成绩：\",i+1);             fflush(stdout);             rewind(sstdin);             if (1==scanf_s(\"%d\", &a[i]) {                 if (0<=a[i] && a[i]<=100) break;             }             printf(\"输入格式错误！请重新输入\\n\",N);         }     }     sum=0;     min=max=a[0];     for (i = 1; i < N; i++) {         sum += a[i];         if (a[i]<min) min = a[i];         if (a[i]>max) max = a[i];     }     avg = sum / N;     printf(\"最大值=%d\\n\", max);     printf(\"最小值=%d\\n\", min);     printf(\"平均值=%d\\n\", avg);     return 0; }  大佬 但是我们现在不用写这么 详细 感谢分享 十分有用", "referer": "user-0"}, {"cid": "16", "user": "user-11", "content": "min = max = a[0]; 这句加上，初始化最大值和最小值。 要么就是按照楼上所说，把最大值定义成int能表示的最大正整数，min定义成int的最小值； 但是int在不同编译器里会有所不同，比如16位编译器和32位，64编译器里标识的位数不同；所以，还得考虑这个。 因此，min = max = a[0];是比较简单的初始话方法", "referer": "user-0"}, {"cid": "17", "user": "user-9", "content": "我这样说才能令有所领悟，授之以渔。", "referer": "user-0"}, {"cid": "18", "user": "user-12", "content": "引用 5 楼 智者知已应修善业 的回复:通常最大值初始化为最小，最小值初始化为最大即可。 此法不保险，且麻烦（对不同数值类型而言）。 个人意见，至少有一个数据的话，还是把最大值和最小值都初始化为第0个数据比较保险。", "referer": "user-0"}, {"cid": "19", "user": "user-13", "content": "楼主可以这样运行下代码，看看max min avg输出什么，找找感觉：#define N 30 int main() {    int a[N], min, max, i, sum = 0, avg = 0;    /*printf(\"请输入30名学生的成绩：\");    for (i=0; i < N; i++)    {      scanf_s(\"%d\", &a[i]);    }    for (i = 0; i < N; i++)   {      sum += a[i];      if (min > a[i])      {        min = a[i];      }      if (max < a[i])      {       max = a[i];      }    }    avg = sum / N; */    printf(\"最大值=%d\\n\", max);    printf(\"最小值=%d\\n\", min);    printf(\"平均值=%d\\n\", avg);    system(\"pause\");    return 0; } 最大值最小值比较大小，都是有限范围内的，值的大小也是相对的，是某一个范围内的大小，大小值肯定在特定区域内的一个，然后去比较。比如说去比较一个幼儿园小朋友的身高，如果设置初值：max=成人的身高，最后这个max还能找得到吗？", "referer": "user-0"}, {"cid": "20", "user": "user-9", "content": "通常最大值初始化为最小，最小值初始化为最大即可。", "referer": "user-0"}]}
{"question": "c语言malloc与sprintf函数调用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:x存放的是字符串，'0'对应0x30, '1'对应0x31依次向后0x39对应'9' 嗯嗯，懂了耶", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "x存放的是字符串，'0'对应0x30, '1'对应0x31依次向后0x39对应'9'", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 user-2的回复:y[0]里面保存的是数值0 但是被sprintf写入x[0]里面的就是字符0了 下面再用%x格式输出字符0 当然看到的就是它的十六进制表现形式30了 谢谢呐，懂了懂了", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "y[0]里面保存的是数值0 但是被sprintf写入x[0]里面的就是字符0了 下面再用%x格式输出字符0 当然看到的就是它的十六进制表现形式30了", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "不管是sprintf还是printf，不管内部是什么类型的东西，输出后的形式都是字符序列。 瞧，我连字符串都不说，因为字符串也是内部说法，不适用于输出以后的形式。  有个神似但是形不够似的比方， 不管你银行账号里的金额有多精彩，你要是用取款机来输出它，你得到的只能是一系列的百元钞票。", "referer": "user-0"}]}
{"question": "在单链表的特定位置插入一个值，如何完成，之前有人给过代码，不过没看懂，希望有大佬发详细注解的代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1.创建一个节点，指向插入位置前的节点 2.把插入位置后面的节点指向刚才创建的节点", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "https://mp.csdn.net/editor/html/104839822", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "建议自己先写写，如果不明白原理，建议从书上获取～自己啃啃书，实践一下吧～", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}]}
{"question": "判断输入的整数是否为素数！！请问哪里有错a,求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int nu(int a) {     int i;     for(i=2;i<a;i++)         if(a%i==0)              return 0;     return 1;  }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int nu(int a) {     int i;     if (a < 2)         return 0;     for(i=2;i<sqrt(a)+1;i++)         if(a%i==0)              return 0;     return 1;    } 提高效率～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 qzjhjxj 的回复:int nu(int a) {     int i;     for(i=2;i<a;i++)         if(a%i==0)              return 0;     return 1;  } 根据这个逻辑，1的返回值是1；0的返回值是1，即是素数  int nu(int a) {     int i;     if (a < 2)         return 0;     for(i=2;i<a;i++)         if(a%i==0)              return 0;     return 1;   }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "i自2起方为正道。", "referer": "user-0"}]}
{"question": "c语言如何判断是引用还是取地址？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 16 楼 赵4老师的回复:仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]  感谢，学到了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "也不知你是不是故意的混淆概念， 首先引用是C++概念，不是C语言。 其次如果你提到的这些函数的形式全部都是函数原型或者函数实现的话，那么参数列表里全部都是形参的declaration，只会出现引用符号。 而相对应的，函数调用的括号里面全部都是实参,实参求值是个动作，如果出现&就应该是取地址。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "简单点来讲     引用是一种变量类型，所以是变量声明的时候在变量前面加&，取地址符可以当成运算符号所以是跟着已经声明的变量。  变量声明可以简单认为是 变量类型+变量名称； int var； 你举的例子  函数里面参数  就可以看作是声明。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "在声明时前缀&A表示A的引用，在运算时前缀&A表示取A的地址 在声明时前缀*A表示指向A的指针，在运算时*A表示取指向A的内容", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "也就相当于void max（int &a）？ 也就是后面说的三中情况全是取地址，而非引用？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 8 楼 突触的回复:嗯            是引用 是否也等同于 void max（int &a）？ 也就是这种形式是地址传递，而不是引用", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 8 楼 突触的回复:嗯            是引用 如果外界定义过a[]， 那这个函数void max（int a[]）算地址传递？ 也就相当于void max（int *a）？", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "套用四老师的风格 不分析词性就没入门儿，不善用各种修辞格的代码是没有灵魂的。 在远方还有诗等着你呢。", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "嗯            是引用", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "一个declaration里面除了identifier以外都可以视作形容词，identifier本身是名词。 同理，赋值也好，函数调用也好，都是广义动词。", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 3 楼 突触的回复:判断 &+变量 是引用还是取地址    当声明变量的时候使用&   这里的&是引用    例子： int b=0; int &a = b;   当已经声明的变量前面加&  这里的&是取地址 例子： int b=0; int *a = &b; 应该算引用对吗？", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 3 楼 突触的回复:判断 &+变量 是引用还是取地址    当声明变量的时候使用&   这里的&是引用    例子： int b=0; int &a = b;   当已经声明的变量前面加&  这里的&是取地址 例子： int b=0; int *a = &b; 这样的话算引用还是取地址？", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 3 楼 突触的回复:判断 &+变量 是引用还是取地址    当声明变量的时候使用&   这里的&是引用    例子： int b=0; int &a = b;   当已经声明的变量前面加&  这里的&是取地址 例子： int b=0; int *a = &b; 比如我一个函数void max（int &a，int &b）", "referer": "user-0"}, {"cid": "16", "user": "user-3", "content": "判断 &+变量 是引用还是取地址    当声明变量的时候使用&   这里的&是引用    例子： int b=0; int &a = b;   当已经声明的变量前面加&  这里的&是取地址 例子： int b=0; int *a = &b;", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "引用 1 楼 forever74的回复:引用是个形容词，而取地址是个动词，及物的。 我不是问英语啊，就是&这个符号什么情况是取地址，什么时候是引用（也就是取别名）", "referer": "user-0"}, {"cid": "18", "user": "user-2", "content": "引用是个形容词，而取地址是个动词，及物的。", "referer": "user-0"}]}
{"question": "函数pi是否满足pi/2=1+1/3+1/3*2/5+1/3*2/5*3/7+....  求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "是的，还需要点补充，严谨一点", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "不满足；1/3 * 2/5这个乘法没有体现出来呢～另外，t的值需要做一个限定，不能是1,2这样的值。  网上搜一下吧，看看别人的逻辑，自己参考一下～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "肯定不行吧，你把 n = 2，带进去看不就行了么 n = 2 的情况下，算式要求是 1/3 * 2/5 你这个循环里边只在 sum 上加了一个 2/5 而已，以此类推，后面的每一项都不符合了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "我觉得，按程序的本意，t应该是pi的计算精度吧。作为double传入，不宜作为循环条件的判定吧。", "referer": "user-0"}]}
{"question": "请判断下列函数pi是否满足pi/2=1+1/3+1/3*2/5+1/3*2/5*3/7+...  求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：//π/2=1+1/3+（1*2）/（3*5）+（1*2*3）/（3*5*7）+.......+（1*2...*n）/（3*5....*（2n+1））  #include \"stdio.h\" double pi(double t) {     double sum=1,m=1,s=1;     int n;     for(n=1;m>=t;n++)//for(n=1;n<=t;n++)这里n不会小于t,只会越走越大，n是项数      {               //m的值越来越小了，          m=m*n/(2*n+1);//n=1,m=1/3  //n=2,m=(1/3)*(2/5) ........          //s=s*m          sum=sum+m;  //n=1,sum = 1+ (1/3) //n=2,sum = 1+(1/3)+(1/3)*(2/5).......      }     return (sum*2); }", "referer": "user-0"}]}
{"question": "是一个刚上c语言编程设计的小白", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "请问一下各种合法外挂的学习方向", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 6 楼 早打大打打核战争 的回复:[quote=引用 5 楼 赵4老师 的回复:][quote=引用 4 楼 早打大打打核战争 的回复:]老赵以前一直吹AutoHotkey来着~ 我现在也可以继续吹AutoHotkey[/quote]  再给楼主科普一次~  [/quote] https://www.autohotkey.com/", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 5 楼 赵4老师 的回复:[quote=引用 4 楼 早打大打打核战争 的回复:]老赵以前一直吹AutoHotkey来着~ 我现在也可以继续吹AutoHotkey[/quote]  再给楼主科普一次~", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 4 楼 早打大打打核战争 的回复:老赵以前一直吹AutoHotkey来着~ 我现在也可以继续吹AutoHotkey", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "老赵以前一直吹AutoHotkey来着~", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "Windows Automation是一款基于Windows平台的桌面自动化软件， 用于自动执行所有重复性任务。 能自动启动和使用应用程序， 如自动填写数据、自动操作各种软件。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "windows API", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "windows下都有鼠标键盘函数可以实现移动点击等效果", "referer": "user-0"}]}
{"question": "为啥返回最大子列啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "数据结构遇到的相关问题求解答，在此拜谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议贴全代码，但从照片看不明白你想要的，主要是代码部分还被遮住～  逻辑上应该是每次遇到一个和e相等的，就用后面的覆盖当前的。", "referer": "user-0"}]}
{"question": "数据结构相关问题请各路大神速来解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码信息不全呢，怀疑是给elem申请的动态空间，这样是可以按照数组的形式去赋值的。 所以，查一下初始化的函数里是不是有对elem申请了空间。  如果没申请还可以这样赋值，那么即使可行那也是随机的，因为野指针的使用是未定义行为～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}]}
{"question": "为啥出现了负数？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "躲过了初一，没躲过十五 使用16位环境要格外小心", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include \"stdio.h\" int main(){     int i;     unsigned long long arr[40];     arr[0]=1;     arr[1]=1;     for(i=2;i<40;i++){          arr[i] = arr[i-1] + arr[i-2];         //printf(\"%d\\t\",arr[i]);         printf(\"%llu\\t\", arr[i]);     }     putchar(10);      getchar();      return 0; } 负数，应该是溢出的缘故，因为long int最高位是符号位，计算得到的值超出了long int表示的正整数范围；  另外，long int输出应该是%ld不是%d", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "我这显示正常：#include \"stdio.h\" #include <conio.h>//getch()函数头文件 int main(){      int i;      int arr[40];      arr[0]=1;      arr[1]=1;      for(i=2;i<40;i++){          arr[i]=arr[i-1]+arr[i-2];         printf(\"%d  \",arr[i]);     }       getch();      return 0;  }  //2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181  6765  10946  17711 //28657  46368  75025  121393  196418  317811  514229  832040  1346269  2178309  3524578  5702887 //9227465  14930352  24157817  39088169  63245986  102334155", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include \"stdio.h\" int main(){     int i;     long int arr[40];     arr[0]=1;     arr[1]=1;     for(i=2;i<40;i++){          arr[i]=arr[i-1]+arr[i-2];         printf(\"%ld\\t\",arr[i]);     }     getchar();     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "可以 调试一下看看，就可以发现问题，看什么时候变成负数了，看代码本身，好像没有问题", "referer": "user-0"}]}
{"question": "想要更强 又毫无方向", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "组长，反观现在，你很强了！！加油！！！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "年轻就是资本啊小老弟，别想太多，跟着自己的节奏走就行", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "首先，也是最难的，正确评估自己 然后确定一个靠谱的远期目标 接着就是向目标前进了 不要奔跑，慢慢走起，不停下就行 前进途中身边触手可及的全部都是基础 不要怕基础太杂 大部分不需要系统深入地学习 但要了解。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "谢谢您了 会注重基础的 ，但是 基础？ 啥叫基础？ 烦躁是很烦躁的 ，真的还是谢谢你", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "鸡汤多了也无感了，不如自己多尝试。即使前期很耗时间去解决几个甚至是一个问题，那也是进步。楼主心里应该还是很急躁的～，不如先静下心来，点滴积累，点滴升华。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "扎根基础，一步一个脚印，不要浮躁，基础牢固了，学习新的东西会更快些～", "referer": "user-0"}]}
{"question": "链表中使用冒泡排序首行无法参与的解决办法。（交换节点）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "只交换数据部分应该比较好处理。 链表节点交换，比较难处理。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "这就是为什么有些数据结构教材喜欢头结点而不是头指针。", "referer": "user-0"}]}
{"question": "猴子选大王·C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<bits/stdc++.h> using namespace std;  const int N = 1000000 + 10; queue<int> q; int x[N]; int n, m;  int main(){ \tcin >> n; \t \tfor (int i = 1; i <= n; ++i) { \t\tq.push(i); \t\tscanf(\"%d\", &x[i]); \t} \t \twhile (q.size() - 1){\t \t\tint b = x[q.front()]; \t\tfor (int i = 1; i <= b - 1; ++i) { \t\t\tq.push(q.front()); \t\t\tq.pop(); \t\t} \t//\tcout << q.front() << \" \"; \t\tq.pop(); \t} \t \tcout << q.front() << endl; \treturn 0; }  自己在一本通上面做的", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "n大于2吗？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "...你这个退出之后从哪一只猴子开始数 1 ？", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "仅供参考：//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf(\"Input n m(1000>=n>=m>=1):\");         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf(\"%3d \",i);                 if (0==t%10) printf(\"\\n\");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf(\"Press any key ...\");     getch(); }", "referer": "user-0"}]}
{"question": "C语言：如何将16进制形式的字符串，转化为相同的16进制的整型。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "long int strtol(const char *nptr, char **endptr, int base);         long long int strtoll(const char *nptr, char **endptr, int base); 了解一下这两个函数～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "问题已解决，可以满足需求", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2 的回复:仅供参考： #include <stdio.h>  int main(void) { \tchar *str = \"0x123\"; \tint data; \tsscanf(str, \"%x\", &data); \tprintf(\"%#x\\n\", data); \t \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "仅供参考： #include <stdio.h>  int main(void) { \tchar *str = \"0x123\"; \tint data; \tsscanf(str, \"%x\", &data); \tprintf(\"%#x\\n\", data); \t \treturn 0; }", "referer": "user-0"}]}
{"question": "求大神carry！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h>   void bubble_sort(int *arr, int len); int main() {      int n, *arr, i;      scanf(\"%d\", &n);      arr = (int *)malloc(sizeof(int) * (n));     if (!arr)         return -1;      for (i = 0; i < n; i++)         scanf(\"%d\", &arr[i]);      bubble_sort(arr, n);      for (i = 0; i < n; i += 1)         printf(\"%d \", arr[i]);     putchar(10);      /*        for (i = 1; i < n+1; i += 2)        printf(\"%d \", arr[i]);        putchar(10);        for (i = 2; i < n+1; i += 2)        printf(\"%d \", arr[i]);        putchar(10);        */      return 0; }  void bubble_sort(int *arr, int len) {     int i, j;     int tmp;      for (i = 0; i < len; i++) {         for (j = 0; j < len-1; j++) {             if (arr[j] > arr[j+1]) {                 tmp = arr[j];                 arr[j] = arr[j+1];                 arr[j+1] = tmp;             }         }     } } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "方案一，使用变长数组，需要编译器支持C99  #include \"stdio.h\" #include \"stdlib.h\" #include \"time.h\" int main( void ) { \tint num=0,i=0; \tprintf(\"输入数组长度：\"); \tscanf( \"%d\", &num  ); \tint arr[num]; \tsrand( time(0) ); \tfor( i=0 ; i<num ; i++ ) \t{ \t\tarr[i] = rand()%100; \t\tprintf(\"%d \", arr[i] ); \t}  \treturn 0; }   方案二，申请内存，C90亦可  #include \"stdio.h\" #include \"stdlib.h\" #include \"time.h\" int main( void ) { \tint num=0,i=0; \tprintf(\"输入数组长度：\"); \tscanf( \"%d\", &num  ); \tint* arr = calloc( num, sizeof(int) );; \tsrand( time(0) ); \tfor( i=0 ; i<num ; i++ ) \t{ \t\tarr[i] = rand()%100; \t\tprintf(\"%d \", arr[i] ); \t}  \treturn 0; }", "referer": "user-0"}]}
{"question": "关于链接动态库的一个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 Intel0011 的回复:[quote=引用 4 楼 六道佩恩 的回复:][quote=引用 1 楼 user-2 的回复:]https://www.cnblogs.com/johngu/p/7877939.html  这个“隐式链接”不是链接静态库吗？[/quote] lib有两种 一种是静态库，里面包含功能函数 另一种是导入库，里面包含DLL中函数的信息，供链接器去寻找调用的函数 这两种库的后缀都是lib，但功能和内容不一样  [/quote]  抱歉哈，上次有事就把这茬给忘了，非常感谢老哥，我把分都加上", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 4 楼 六道佩恩 的回复:[quote=引用 1 楼 user-2 的回复:]https://www.cnblogs.com/johngu/p/7877939.html  这个“隐式链接”不是链接静态库吗？[/quote] lib有两种 一种是静态库，里面包含功能函数 另一种是导入库，里面包含DLL中函数的信息，供链接器去寻找调用的函数 这两种库的后缀都是lib，但功能和内容不一样 ---------------------------------------------- Windows中，动态库包括xx.dll和xx.lib两部分。静态库包含yy.lib。  此处有两种lib，一种称为动态库的导入库xx.lib。一种称为静态库yy.lib，如何来进行区分呢。 第一看大小，导入库一般都很小，大的也只有几K，而静态库则很大，小则几M，大则几十M。 第二就要能过命令的方式来查看了。命令行使用方式如下： -------------------------------------------------------- 1、用dumpbin /exports xxx.lib查看导出的函数接口，如果有导出的话就是动态库的lib文件，如果看不到导出函数就是静态库。 -------------------------------------------------------- 2、使用lib.exe来查看 如果该Demo.lib是静态库，输出如下： lib /list Demo.lib  Microsoft (R) Library Manager Version 8.00.50727.42 Copyright (C) Microsoft Corporation. All rights reserved.  .\\Debug\\Demo.obj .\\Debug\\Person.obj .\\Debug\\stdafx.obj .\\Debug\\Demo.res  如果该Demo.lib是导入库，输出如下： lib /list Demo.lib  Microsoft (R) Library Manager Version 8.00.50727.42 Copyright (C) Microsoft Corporation.  All rights reserved.  Demo.dll Demo.dll Demo.dll Demo.dll Demo.dll", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "如果lib是静态库 就是静态链接（不需要DLL），如果是动态库，系统就在装载时会加载对应的DLL", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2 的回复:https://www.cnblogs.com/johngu/p/7877939.html  这个“隐式链接”不是链接静态库吗？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 Intel0011 的回复:VC也可以使用链接选项指定 或在源码中指定，这属于隐式调用 #pragma comment(lib, \"XXX.lib\") 代码中手写LoadLibrary是属于显式调用 这不是静态库吗？", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "VC也可以使用链接选项指定 或在源码中指定，这属于隐式调用 #pragma comment(lib, \"XXX.lib\") 代码中手写LoadLibrary是属于显式调用", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "https://www.cnblogs.com/johngu/p/7877939.html", "referer": "user-0"}]}
{"question": "急求大佬帮忙，c语言做了个简单的网吧管理系统，现在出问题不知道怎么改了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：//#include\"Mylist.h\" //run this program using the console pauser or add your own getch, system(\"pause\") or input loop    #include<stdio.h> #include<stdlib.h>   struct VIP {     char name[20]; //会员姓名     int  idN,VIPN,PN,integral,time,CN; //身份证号码，会员号，电话号码，会员积分，上机时间，机子编号 };  struct Node {     //int data;     struct VIP data;     struct Node* next; };  //创建表 struct Node* createList() {     struct Node* headNode = (struct Node*)malloc(sizeof(struct Node));     headNode->next = NULL;     return headNode; }   //创建结点 struct Node* createNode()//(struct VIP data) {     struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));     //newNode->data = data;     newNode->next = NULL;     return newNode; }  //插入结点 void insertNodeByHead(struct Node* headNode,struct VIP data) {     struct Node* newNode = createNode();//(data);     newNode->data  = data;  //表头法     newNode->next  = headNode->next;     headNode->next = newNode; }  struct Node* list = createList();  //查找功能 struct Node* searchInfoByData(struct Node* headNode,int VIPN) {     struct Node* pMove = headNode->next;     if(pMove == NULL)          return NULL;     for (;pMove != NULL;pMove = pMove->next)         if (pMove->data.VIPN == VIPN)             return pMove;     return NULL; }  //指定位置删除 void deleteAppoinNode(struct Node* headNode,int VIPN) {     struct Node* posNode ,* posFrontNode ;          for(posNode = headNode,posFrontNode = NULL;         posNode != NULL && posNode->data.VIPN != VIPN;         posFrontNode = posNode,posNode = posNode->next);      if(posNode == NULL)     //未找到       {         printf(\"未找到指定位置信息，无法删除！\\n\");         return;       }     if(posFrontNode == NULL)//第一个节点       {         headNode = headNode->next;       }     else       {         posFrontNode->next = posNode->next;       }     free(posNode); }  //文件读操作 void readInfoFromFile(struct Node* headNode, char *fileName) {           FILE *fp;      struct VIP data;      fp = fopen(fileName, \"r+\");//1.打开      if (fp == NULL)       {          printf(\"\\n*********新的网吧管理系统*************\\n\");          return;       }                                 //2.读文件      while(fscanf(fp,\"%s %d %d %d %d %d %d\\n\",data.name,&data.idN,&data.VIPN,&data.PN,                                                    &data.integral,&data.time,&data.CN)==7)       {         insertNodeByHead(headNode, data);       }      fclose(fp) ; //3.关闭文件 } //文件写操作 void writeInfoToFile(struct Node* headNode,char *FileName) {     FILE *fp;     fp = fopen(FileName,\"w+\");     if (fp == NULL)       {          printf(\"不能打开文件！\\n\");          return;       }     struct Node* pMove = headNode->next;     while(pMove)      {         fprintf(fp,\"%s %d %d %d %d %d %d\\n\",pMove->data.name,pMove->data.idN,pMove->data.VIPN,                              pMove->data.PN,pMove->data.integral,pMove->data.time,pMove->data.CN);         pMove = pMove->next;      }     fclose(fp); }   //打印链表  void printflist(struct Node* headNode) {     struct Node*pMove = headNode->next;     printf(\"会员姓名\\t\\t身份证号码\\t\\t会员号\\t\\t电话号码\\t\\t会员积分\\t\\t上机时间\\t\\t机子编号\\n\");     while (pMove)      {         printf(\"%-20s\\t%-18d\\t%-18d\\t%-18d\\t%-12d\\t%-12d\\t%-12d\\n\",pMove->data.name,pMove->data.idN,                pMove->data.VIPN,pMove->data.PN,pMove->data.integral,pMove->data.time,pMove->data.CN);         pMove = pMove->next;      }     printf(\"\\n\"); }  void menu() {     printf(\"----------网吧管理系统---------\\n\");     printf(\"\\t1.添加会员信息\\t\\n\");     printf(\"\\t2.浏览会员信息\\t\\n\");     printf(\"\\t3.删除会员信息\\t\\n\");     printf(\"\\t4.添加上网信息\\t\\n\");     printf(\"\\t5.删除上网信息\\t\\n\");     printf(\"\\t6.查找会员信息\\t\\n\");     printf(\"\\t0.退出管理系统\\t\\n\");     printf(\"-------------------------------\\n\"); }  void keyDown() {     int choice = 0;     struct VIP data;     struct Node * searchID ;     printf(\"请输入你的选择：\");     fflush(stdout);     rewind(stdin);     scanf(\"%d\",&choice);     switch(choice)                  {                  case 1:                         printf(\"--------添加会员信息---------\\n\");                         printf(\"请输入会员姓名,身份证号码，会员号，电话号码，会员积分:\");                         fflush(stdout);           //清空缓冲区                         rewind(stdin);                         scanf(\"%s%d%d%d%d\",data.name,&data.idN,&data.VIPN,&data.PN,&data.integral);                         data.time =0; data.CN =0;                         insertNodeByHead(list,data);                         break;                  case 2:                         printf(\"--------浏览会员信息---------\\n\");                         printflist(list);                         break;                  case 3:                         printf(\"--------删除会员信息---------\\n\");                         printf(\"请输入删除的会员号;\");                         fflush(stdout);                         rewind(stdin);                         scanf(\"%d\",&data.VIPN) ;                         deleteAppoinNode(list,data.VIPN);                         break;                  case 4:                         printf(\"--------添加上网信息---------\\n\");                         printf(\"请输入会员号:\");                         fflush(stdout);                         rewind(stdin);                         scanf(\"%d\",&data.VIPN);                         searchID = searchInfoByData(list, data.VIPN);                         if(searchID != NULL){                             printf(\"请输入上机时间，机子编号:\");                             fflush(stdout);                             rewind(stdin);                             scanf(\"%d%d\",&data.time,&data.CN);                             searchID->data.time = data.time;                             searchID->data.CN   = data.CN;                         }else                             printf(\"未找到相关信息！\\n\");                         break;                  case 5:                         printf(\"--------删除上网信息---------\\n\");                         printf(\"请输入会员号:\");                         fflush(stdout);                         rewind(stdin);                         scanf(\"%d\",&data.VIPN);                         searchID = searchInfoByData(list, data.VIPN);                         if(searchID != NULL){                             searchID->data.time = 0;                             searchID->data.CN   = 0;                             printf(\"%d号会员上网信息删除成功！\",data.VIPN);                         }else                             printf(\"未找到会员号为：%d的相关信息！\\n\",data.VIPN);                         break;                  case 6:                         printf(\"--------查找会员信息---------\\n\");                         printf(\"请输入要查找的会员号:\");                         fflush(stdout);                         rewind(stdin);                         scanf(\"%d\", &data.VIPN);                         searchID =  searchInfoByData(list, data.VIPN);                         if (searchID == NULL)                                                   {                               printf(\"未找到相关信息！\\n\");                            }                         else                            {                               printf(\"会员姓名\\t\\t身份证号码\\t\\t会员号\\t\\t电话号码\\t\\t\"                                                       \"会员积分\\t\\t上机时间\\t\\t机子编号\\n\");                               printf(\"%-20s\\t%-18d\\t%-18d\\t%-18d\\t%-12d\\t%-12d\\t%-12d\\n\",                                      searchID->data.name,searchID->data.idN,searchID->data.VIPN,                                      searchID->data.PN,searchID->data.integral,searchID->data.time,                                      searchID->data.CN);                            }                         break;                  case 0:                         printf(\"正常退出！\\n\");                         writeInfoToFile(list,\"1.txt\");                         exit(0);                         break;                  default :                         printf(\"选择错误，重新输入\\n\");                         break;     }     //writeInfoToFile(list, \"1.txt\"); }   int main(int argc, char *argv[]) {     system(\"title 网吧管理系统\");//设置cmd窗口标题     system(\"mode con cols=200 lines=50\");//窗口宽度高度      readInfoFromFile(list, \"1.txt\");     while(1)      {         menu();         keyDown();         system(\"pause\");         system(\"cls\");      }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 往事如烟0819 的回复:代码实现了什么功能，发生了什么问题，也不说。 这么多代码，哪有那么多时间看呀。 咋看呀 我的问题，现在已经解决了 ，谢谢大家", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "快来人啊！！！！", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 3 楼 往事如烟0819 的回复:代码实现了什么功能，发生了什么问题，也不说。 这么多代码，哪有那么多时间看呀。 咋看呀 正解。。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "代码实现了什么功能，发生了什么问题，也不说。 这么多代码，哪有那么多时间看呀。 咋看呀", "referer": "user-0"}]}
{"question": "英文本文件的处理（小白求助）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "需用C语言程序写我不会呀", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "K&R C，修改一下即可。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "文本文件处理  https://blog.csdn.net/zhanghaiyang9999/article/details/107032563", "referer": "user-0"}]}
{"question": "为什么我的冒泡排序不起作用。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "void sort(int x[], int n) {   int i,j,t;   for(i=0; x && i<n-1; i++)   {     for(j=i+1; j<n; j++)     {       if(x[i] > x[j])       {         t=x[i]; x[i]=x[j]; x[j]=t;       }     }   } }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "路过围观，学习", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "https://blog.csdn.net/zhanghaiyang9999/article/details/107102728  C语言基础排序算法-冒泡排序", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "引用 2 楼 qq_53643374 的回复:[quote=引用 1 楼 自信男孩的回复:]select_sort函数里操作的是局部变量a数组，不是用的x，因此排序的是局部数据a排序了，没有对x开始的内存排序，x指向即main函数里的a数组。  另外，冒泡bubble_sort建议改一下函数名；  select_sort是选择排序。 改了提高代码的可读性～ 那要怎么改那[/quote]  把select_sort函数里的a用x替换；  另外，去掉a[20]的定义吧。用到的数组。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:select_sort函数里操作的是局部变量a数组，不是用的x，因此排序的是局部数据a排序了，没有对x开始的内存排序，x指向即main函数里的a数组。  另外，冒泡bubble_sort建议改一下函数名；  select_sort是选择排序。 改了提高代码的可读性～ 那要怎么改那", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "select_sort函数里操作的是局部变量a数组，不是用的x，因此排序的是局部数据a排序了，没有对x开始的内存排序，x指向即main函数里的a数组。  另外，冒泡bubble_sort建议改一下函数名；  select_sort是选择排序。 改了提高代码的可读性～", "referer": "user-0"}]}
{"question": "C中将字符串转uint8", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "uint8_t n;     const  char* str = \"0xff\";     sscanf(str, \"%hhx\", &n);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不用转，因为char和uint8都是1个字节的长度。如果说要转的话，可能是类型强制转换了，但是这样不会改变内存里的内容。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "比如说 char *a ＝\"0xff\" 怎么转成uint8_t类型？", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "请上代码来说明问题。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 10 楼 prprrrr 的回复:[quote=引用 9 楼 自信男孩的回复:][quote=引用 2 楼 prprrrr 的回复:]比如说 char *a ＝\"0xff\" 怎么转成uint8_t类型？ 当然char *a  = \"0xff\";和uint8_t *b = \"0xff\";是一样的。  同理char a[] = \"0xff\"和uint8_t b[] = \"0xff\";内存是一样的（即数组a和数组b中的内容是一样的）[/quote] 相当于写了一个uint8的指针指向了\"0xff\"吗[/quote] 对", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "所以说不上代码的话，楼主你的原始说法容易造成误解哦。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 7 楼 prprrrr的回复:[quote=引用 4 楼 真相重于对错的回复:]uint8_t n;     const  char* str = \"0xff\";     sscanf(str, \"%hhx\", &n); 我这就去试试[/quote] 太好了可以，谢谢", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 9 楼 自信男孩的回复:[quote=引用 2 楼 prprrrr 的回复:]比如说 char *a ＝\"0xff\" 怎么转成uint8_t类型？ 当然char *a  = \"0xff\";和uint8_t *b = \"0xff\";是一样的。  同理char a[] = \"0xff\"和uint8_t b[] = \"0xff\";内存是一样的（即数组a和数组b中的内容是一样的）[/quote] 相当于写了一个uint8的指针指向了\"0xff\"吗", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "引用 2 楼 prprrrr 的回复:比如说 char *a ＝\"0xff\" 怎么转成uint8_t类型？ 当然char *a  = \"0xff\";和uint8_t *b = \"0xff\";是一样的。  同理char a[] = \"0xff\"和uint8_t b[] = \"0xff\";内存是一样的（即数组a和数组b中的内容是一样的）", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "引用 2 楼 prprrrr 的回复:比如说 char *a ＝\"0xff\" 怎么转成uint8_t类型？  这不一样呢，a是指向的字符串，0xff和\"0xff\"是不一样的。  我说的一样是这样的:char a = 0xff; uint8_t b = a;或者uint8_t b = 0xff;此时的a和b是一样的在内存里。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 4 楼 真相重于对错的回复:uint8_t n;     const  char* str = \"0xff\";     sscanf(str, \"%hhx\", &n); 我这就去试试", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:不用转，因为char和uint8都是1个字节的长度。如果说要转的话，可能是类型强制转换了，但是这样不会改变内存里的内容。 噢，那就直接强转就可以了吧", "referer": "user-0"}, {"cid": "14", "user": "user-5", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。", "referer": "user-0"}]}
{"question": "～a|a为什么是-1", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 it_xiangqiang的回复:C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html 哇塞，谢谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "~a&a为什么是0", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 5 楼 突触的回复:a=1  0000 0000 0000 0001  ~a  1111 1111 1111 1110  a | ~a  1111 1111 1111 1111 明白了，谢谢", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "a=1  0000 0000 0000 0001  ~a  1111 1111 1111 1110  a | ~a  1111 1111 1111 1111", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 楼主 weixin_51397022的回复:～a|a为什么是-1 a=1，～a是-2，二进制应该是最高位和第二低位是1吧，1是最低位是1，那两个按位与运算，应该是-3吧", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "因为二者的位模式都是二进制全1 好巧啊。", "referer": "user-0"}]}
{"question": "终端的输出怎么保存到日志文件", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "./可执行文件 >>~/mylog1.txt 或 ./脚本文件.sh >>~/mylog1.txt", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "写一个日志类，直接写文件写进去不就得了", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不是串口，是ssh连上去的。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 10 楼 user-5 的回复:./MRAPP 2>&1 | tee -i -a ./log.txt 这样？好像问题不在这个2>&1   我看很多打印都没能正常打印出来   printf的都没打出来，像这种： (sensor/imx307.c 688): stEVAttr.s32EV=0 stEVAttr.u32Grad=1 (sensor/imx307.c 424): isp_antiflicker = 1 (sensor/imx307.c 719): gainlimit = 3 (sen  打印到这就卡在缓冲区了？ 显然下面应该还有打印才对啊", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 11 楼 forever74 的回复:也就是跳出系统来记录。 在系统内记录的总有一部分缓冲区上的内容在死机时尚未写盘，这个很正常吧。用tee 的话，正常运行，有很多都是卡在了缓存区的，都没能记录下来", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 9 楼 forever74 的回复:如果是pts系的终端，你让连接用的那个软件直接记录就好了。 我用SecureCRT，随便记。机器装好的，转高温箱测试，接不了串口线哦", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "也就是跳出系统来记录。 在系统内记录的总有一部分缓冲区上的内容在死机时尚未写盘，这个很正常吧。", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "./MRAPP 2>&1 | tee -i -a ./log.txt 这样？", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "如果是pts系的终端，你让连接用的那个软件直接记录就好了。 我用SecureCRT，随便记。", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "参考本网页下面CSDN自动生成的链接。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 5 楼 赵4老师 的回复:加出错打印： >>~/mylog1.txt 2>>~/mylog1.txt 驱动打印是啥东东？程序崩的时候打印的些东西吧，比如下面的打印： / #  / # (uvccom/st_uvc.c 1032):  ----- Isoc UVC_EVENT_STREAMOFF -----       -->1         @RxDET 3        -->2         @Ux 3              -->3 [APP WRN][dev:/dev/video0]: _UVC_QBuf[281]: Unable to queue buffer: No such device (19).    -->4 [APP WRN][dev:/dev/video0]: _UVC_QBuf[281]: Unable to queue buffer: No such device (19).    -->5 [APP WRN][dev:/dev/video0]: _UVC_QBuf[281]: Unable to queue buffer: No such device (19).    -->6 [APP WRN][dev:/dev/video0]: _UVC_QBuf[281]: Unable to queue buffer: No such device (19).    -->7 UVC: 3 buffers free.                                            -->8 UVC: Stop video stream Successfully.                -->9 (sigmastar/tsk_uvc.c 744):  UVC_StopCapture   -->10  1、8、9、10是我自己应用程序加的打印，2、3应该是驱动加的打印，4、5、6、7应该是原厂SDK加的打印，我想要的是，有没有什么操作或者指令，把这些打印全部保存到文件里面，以便机器跑死的时候我知道它的log？ 另外，我测试了下tee，./MRAPP | tee -i -a ./log.txt 好像还行，但是日志保存不完全，最后都会丢一段，不知道怎么回事", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "你说的驱动进程是谁启动的？只要是在终端启动的都可以将输出重定向到文件里啊", "referer": "user-0"}, {"cid": "14", "user": "user-2", "content": "加出错打印： >>~/mylog1.txt 2>>~/mylog1.txt 驱动打印是啥东东？", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 1 楼 xian0-666 的回复:写一个日志类，直接写文件写进去不就得了可否具体点啊", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:./可执行文件 >>~/mylog1.txt 或 ./脚本文件.sh >>~/mylog1.txt 你这个追加只是追加的该文件/脚本执行打印的东西，我要的是我机器全部的终端输出，包括驱动打印，以及出错打印", "referer": "user-0"}]}
{"question": "请问有人知道为什么利用freetype生成的贝塞尔曲线来形成的汉字是倒置的吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "const FT_Fixed multiplier = 65536L; FT_Matrix matrix; matrix.xx = 1L * multiplier; matrix.xy = 0L * multiplier; matrix.yx = 0L * multiplier; matrix.yy = -1L * multiplier; FT_GlyphSlot slot = face->glyph; FT_Outline &outline = slot->outline; FT_Outline_Transform(&outline, &matrix); 复制代码 将matrix.yy的值变成负的就好了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 赵4老师 的回复:int moveto(const FT_Vector* to, void* user){      printf(\"M %d %d\\n\", to->x, 100-to->y);     return 0; }  int lineto(const FT_Vector* to, void* user){      printf(\"L %d %d\\n\", to->x, 100-to->y);     return 0 ; }  int  conicto(const FT_Vector* control, const FT_Vector* to,void* user){      printf(\"Q %d %d %d %d\\n\", control->x, 100-control->y, to->x, 100-to->y);     return 0; }  int  cubicto(const FT_Vector* control1,const FT_Vector* control2, const FT_Vector* to,void* user){      printf(\"C %d %d %d %d %d %d\\n\", control1->x, 100-control1->y, control2->x, 100-control2->y ,to->x, 100-to->y);     return 0; }   该方法无效，不过我已解决了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "int moveto(const FT_Vector* to, void* user){      printf(\"M %d %d\\n\", to->x, 100-to->y);     return 0; }  int lineto(const FT_Vector* to, void* user){      printf(\"L %d %d\\n\", to->x, 100-to->y);     return 0 ; }  int  conicto(const FT_Vector* control, const FT_Vector* to,void* user){      printf(\"Q %d %d %d %d\\n\", control->x, 100-control->y, to->x, 100-to->y);     return 0; }  int  cubicto(const FT_Vector* control1,const FT_Vector* control2, const FT_Vector* to,void* user){      printf(\"C %d %d %d %d %d %d\\n\", control1->x, 100-control1->y, control2->x, 100-control2->y ,to->x, 100-to->y);     return 0; }", "referer": "user-0"}]}
{"question": "字符文件处理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "请教一个OJ题，大佬请看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include <stdio.h> int main() {     int n;     scanf(\"%d\",&n);     //int a[n+10]; //数组的定义非法，会报错。     //int o[n];     //int ji[n];     int i;     int j;     int k,l=2;     if(n%2==0)l=0;     //k=l=0;      int *a = new int[n];//动态数组     memset(a,0,sizeof(int)*n);//数组初始化      for (i=0;i<n;i++){     //输入数据          scanf(\"%d\",&a[i]);     }      for (i=0;i<n;i+=2){   //下标奇数位排序，升序          for (j=0;j<n-i-2;j+=2){               if (a[j]>a[j+2]){                        k = a[j];                     a[j] = a[j+2];                    a[j+2]= k;               }          }     }     for (i=1;i<n;i+=2){     //下标偶数位排序，降序          for (j=1;j<n-i-l;j+=2){                 if (a[j]<a[j+2]){                        k = a[j];                     a[j] = a[j+2];                    a[j+2]= k;               }          }     }     for (i=0;i<n;i++){        //输出          printf(\"%d%c\",a[i],i<n-1?' ':'\\n');     }      delete []a;          return 0;      /*while(scanf(\"%d\",&a[i])!=EOF)          {            if(a[i]==0)              {                 break;              }            if((i+1)%2==0)              {                o[k]=a[i];                k++;              }            if((i+1)%2!=0)              {                ji[l]=a[i];                l++;              }            i++;          }     int g;     for(i=0;i<k;i++)        {         for(j=i;j<k;j++)            {              g=o[i];              if(g<o[j])                {                  o[i]=o[j];                  o[j]=g;                }            }        }     int g1;     for(i=0;i<l;i++)        {          for(j=i;j<l;j++)             {               g1=ji[i];               if(g1>ji[i])                 {                   ji[i]=ji[j];                   ji[j]=g1;                 }             }        }     int u=l;     int p=0;     while(j>0&&k>0)        {           printf(\"%d %d \",ji[p],o[p]);           p++;           j--;           k--;        }     if(n%2!=0)        {           printf(\"%d\",ji[u-1]);        } */ }  //8 //2 6 7 1 3 8 9 4 //2 8 3 6 7 4 9 1 //请按任意键继续. . .  //7 //1 2 3 4 5 6 7 //1 6 3 4 5 2 7 //请按任意键继续. . .  //6 //1 2 3 4 5 6 //1 6 3 4 5 2 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 qzjhjxj 的回复：供参考：#include <stdio.h> int main() {     int n;     scanf(\"%d\",&n);     //int a[n+10]; //数组的定义非法，会报错。     //int o[n];     //int ji[n];     int i;     int j;     int k,l=2;     if(n%2==0)l=0;     //k=l=0;      int *a = new int[n];//动态数组     memset(a,0,sizeof(int)*n);//数组初始化      for (i=0;i<n;i++){     //输入数据          scanf(\"%d\",&a[i]);     }      for (i=0;i<n;i+=2){   //下标奇数位排序，升序          for (j=0;j<n-i-2;j+=2){               if (a[j]>a[j+2]){                        k = a[j];                     a[j] = a[j+2];                    a[j+2]= k;               }          }     }     for (i=1;i<n;i+=2){     //下标偶数位排序，降序          for (j=1;j<n-i-l;j+=2){                 if (a[j]<a[j+2]){                        k = a[j];                     a[j] = a[j+2];                    a[j+2]= k;               }          }     }     for (i=0;i<n;i++){        //输出          printf(\"%d%c\",a[i],i<n-1?' ':'\\n');     }      delete []a;          return 0;      /*while(scanf(\"%d\",&a[i])!=EOF)          {            if(a[i]==0)              {                 break;              }            if((i+1)%2==0)              {                o[k]=a[i];                k++;              }            if((i+1)%2!=0)              {                ji[l]=a[i];                l++;              }            i++;          }     int g;     for(i=0;i<k;i++)        {         for(j=i;j<k;j++)            {              g=o[i];              if(g<o[j])                {                  o[i]=o[j];                  o[j]=g;                }            }        }     int g1;     for(i=0;i<l;i++)        {          for(j=i;j<l;j++)             {               g1=ji[i];               if(g1>ji[i])                 {                   ji[i]=ji[j];                   ji[j]=g1;                 }             }        }     int u=l;     int p=0;     while(j>0&&k>0)        {           printf(\"%d %d \",ji[p],o[p]);           p++;           j--;           k--;        }     if(n%2!=0)        {           printf(\"%d\",ji[u-1]);        } */ }  //8 //2 6 7 1 3 8 9 4 //2 8 3 6 7 4 9 1 //请按任意键继续. . .  //7 //1 2 3 4 5 6 7 //1 6 3 4 5 2 7 //请按任意键继续. . .  //6 //1 2 3 4 5 6 //1 6 3 4 5 2 //请按任意键继续. . .谢谢指教", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "我的VS2017 Community前些天明明允许像楼主那样定义数组的，可是今天不知道为啥就说不行了，必须得用常量云云。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "#include <stdio.h> #include <stdlib.h>   void bubble_sort(int *arr, int len); int main() {  #if 1     int n, *arr, i;      scanf(\"%d\", &n);      arr = (int *)malloc(sizeof(int) * (n + 1));     if (!arr)         return -1;      for (i = 1; i < n+1; i++)         scanf(\"%d\", &arr[i]);      bubble_sort(arr+1, n);      for (i = 1; i < n+1; i += 1)         printf(\"%d \", arr[i]);     putchar(10);      for (i = 1; i < n+1; i += 2)         printf(\"%d \", arr[i]);     putchar(10);     for (i = 2; i < n+1; i += 2)         printf(\"%d \", arr[i]);     putchar(10);   #else     int n;     scanf(\"%d\",&n);     int a[n+10];     int i=0;     int j;     int o[n];     int ji[n];     int k,l;     k=l=0;     while(scanf(\"%d\",&a[i])!=EOF)     {         if(a[i]==0)         {             break;         }         if((i+1)%2==0)         {             o[k]=a[i];             k++;         }         if((i+1)%2!=0)         {             ji[l]=a[i];             l++;         }         i++;     }     int g;     for(i=0;i<k;i++)     {         for(j=i;j<k;j++)         {             g=o[i];             if(g<o[j])             {                 o[i]=o[j];                 o[j]=g;             }         }     }     int g1;     for(i=0;i<l;i++)     {         for(j=i;j<l;j++)         {             g1=ji[i];             if(g1>ji[i])             {                 ji[i]=ji[j];                 ji[j]=g1;             }         }     }     int u=l;     int p=0;     while(j>0&&k>0)     {         printf(\"%d %d \",ji[p],o[p]);         p++;         j--;         k--;     }     if(n%2!=0)     {         printf(\"%d\",ji[u-1]);     } #endif     return 0; }  void bubble_sort(int *arr, int len) {     int i, j;     int even_flag, odd_flag ,tmp;      for (i = 0; i < len; i++) {         for (j = 0; j < len; j++) {             if (j + 2 < len) {                 if (j % 2 == 0 && arr[j] > arr[j+2])                     odd_flag = 1;                 if (j % 2 == 1 && arr[j] < arr[j+2])                     even_flag = 1;                  if (odd_flag || even_flag) {                     tmp = arr[j];                     arr[j] = arr[j+2];                     arr[j+2] = tmp;                     odd_flag = even_flag = 0;                 }             }         }     } } 供参考～", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "#include <assert.h> #include <stdio.h> #include <stdlib.h>  static int cmp1(const void *p1, const void *p2) {     int *v1;     int *v2;      v1 = (int *)p1;     v2 = (int *)p2;     return (*v1) - (*v2); }  int cmp2(const void *p1, const void *p2) {     int *v1;     int *v2;      v1 = (int *)p1;     v2 = (int *)p2;     return (*v2) - (*v1); }  int main(void) {     int   i;     int   n;     int   a;     int   n1;     int   n2;     int   a1[500];     int   a2[500];      for (;;) {         assert(1 == scanf(\"%d\", &n));         if (0 == n)             break;          n1 = 0;         n2 = 0;         for (i = 1; i <= n; i++) {             assert(1 == scanf(\"%d\", &a));             if (i % 2 == 1) {                 /* 下标为奇数 */                 a1[n1++] = a;             } else {                 /* 下标为偶数 */                 a2[n2++] = a;             }         }          qsort(a1, n1, sizeof(int), cmp1);         qsort(a2, n2, sizeof(int), cmp2);          printf(\"%d\", a1[0]);         n1 = 1;         n2 = 0;         for (i = 2; i <= n; i++) {             if (i % 2 == 1) {                 printf(\" %d\", a1[n1++]);             } else {                 printf(\" %d\", a2[n2++]);             }         }         printf(\"\\n\");     }      return 0; }", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include <stdio.h> #include <conio.h> //getch()函数头文件 void main() {     float A,B,C,S;      printf(\"输入A和B：\");      scanf(\"%f %f\",&A,&B);//scanf(\"%f,%f\",&A,&B); 输入格式还是取消','号更方便      C = A + A + B + B;      S = A * B;      printf(\"周长为:%f,面积为:%f\",C,S);      getch();  }  //输入A和B：1.2 2.3 //周长为:7.000000,面积为:2.760000", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:这两句前后不搭的，scanf(\"%f,%f\",&A,&B); 修改之后显示:\tLNK2005\t_main 已经在ConsoleApplication1.obj中定义（第一行） \tLNK1169\t找到一个或多个多重定义的符号（第一行）", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这两句前后不搭的，scanf(\"%f,%f\",&A,&B);", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 一颗白面馒头的回复:提醒你不安全了嘛，所以把scanf函数改为scnaf_s函数 可是我加了以后依然不可以", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "提醒你不安全了嘛，所以把scanf函数改为scnaf_s函数", "referer": "user-0"}]}
{"question": "请问大佬在哪输入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "虽然它叫输出，但是你要看输出，还是切到终端去吧", "referer": "user-0"}]}
{"question": "关于CRC16_MODBUS校验问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "CMscomm1.put_Output  引用 4 楼 it_xiangqiang 的回复:希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html感谢  这是让我从头开始学习呀", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "https://www.baidu.com/s?wd=crc16%E7%AE%97%E6%B3%95%E5%8E%9F%E7%90%86", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "还有人知道些其他的吗", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "校验是为了发现数据传输错误，为什么用CRC16，因为简单、快速、易于硬件实现，以太网、PCIe底层都使用CRC16用于检验数据传输的正确性", "referer": "user-0"}]}
{"question": "Linux VSCode调试c语言出现“无法加载源”问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可能需要在launch.json中加入            \"sourceFileMap\": {                \"src\": \"${workspaceFolder}/src\"            },", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我也出现了相同的问题，现在解决了吗", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这帖子都快一年了哈哈哈哈哈哈，解决了解决了", "referer": "user-2"}, {"cid": "4", "user": "user-2", "content": "怎么解决的，大佬求教。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "怎么解决的啊 这问题", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "眼不见为净。", "referer": "user-0"}]}
{"question": "用指针判断大小，为什出不来结果？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个代码的精神内核相当于： 宿舍老二（乙）身高没有老大（甲）的高。 后来发现老二的年龄弄错了，实际上他年龄更大，所以他才是老大，原来的老大应该是老二。 这和身高没啥关系呀。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "if(*p1<*p2) {      p3=p1;    p1=p2;       p2=p3; }  这个swap（交换）只是交换了局部变量p1, p2里面的值（地址值），并没有把交换调用函数里的p1, p2指向的内存内容；", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "深入学学指针和引用，以及函数作用域和返回值", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "供参考：#include<stdio.h> void adjust1(int *p1,int *p2)//指针p1 p2作用域在本函数内，所以改变他们的值，                             //并不能传回给math1 math2,所以是无效的。 {     int *p3;     if( *p1 < *p2)     {         p3 = p1;         p1 = p2;         p2 = p3;     } }  void adjust2(int *p1,int *p2)//对指针所指向的值操作是有效的 {     int p3;     if(*p1<*p2)     {          p3 = *p1;         *p1 = *p2;         *p2 = p3;     } }  int main() {    int a1,a2,*math1,*math2;    math1=&a1;    math2=&a2;    scanf(\"%d %d\",&a1,&a2);//scanf(\"%d%d\\n\",&a1,&a2);这里多了'\\n'        adjust1(math1,math2);    printf(\"adjust1:%d %d\\n\",*math1,*math2);     adjust2(math1,math2);    printf(\"adjust2:%d %d\\n\",*math1,*math2);        return 0; }", "referer": "user-0"}]}
{"question": "找出二维数组中的最大值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include <stdio.h>  #define N 100  int main() {     int a[N][N],n1,n2,i,j,max,t;     scanf(\"%d%d\",&n1,&n2);            //输入数组的行和列     if (n1 > N)         n1 = N;     if (n2 > N)         n2 = N;     for(i=0;i<n1;i++)                 //输入数组         for(j=0;j<n2;j++)             scanf(\"%d\",&a[i][j]);      max=a[0][0];     for(i=0;i<n1;i++)                 //找出数组中最大的数         for(j=0;j<n2;j++)             if(max<a[i][j])             {                 max = a[i][j];                 /*                 t=a[i][j];                 a[i][j]=max;                 max=t;                 */             }     printf(\"%d\\n\",max);               //输出数组中最大的数 } 供参考～ 多谢，这位大佬助我改正！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>  #define N 100  int main() {     int a[N][N],n1,n2,i,j,max,t;     scanf(\"%d%d\",&n1,&n2);            //输入数组的行和列     if (n1 > N)         n1 = N;     if (n2 > N)         n2 = N;     for(i=0;i<n1;i++)                 //输入数组         for(j=0;j<n2;j++)             scanf(\"%d\",&a[i][j]);      max=a[0][0];     for(i=0;i<n1;i++)                 //找出数组中最大的数         for(j=0;j<n2;j++)             if(max<a[i][j])             {                 max = a[i][j];                 /*                 t=a[i][j];                 a[i][j]=max;                 max=t;                 */             }     printf(\"%d\\n\",max);               //输出数组中最大的数 } 供参考～", "referer": "user-0"}]}
{"question": "求大神解决一道C语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <assert.h> #include <stdio.h> #include <stdlib.h> #include <string.h>  int main(void) {     int i, n;     int j, m;     char s[100 + 1];     /*      *         ---      .  ---   ---  .   .  ---    ---   ---   ---   ---      *        |   |     |     |     | |   | |      |         | |   | |   |      *        |   |     |  ---   ---   ---   ---    ---      .  ---   ---      *        |   |     | |         |     |     |  |   |     | |   |     |      *         ---      '  ---   ---      '  ---    ---      '  ---   ---      *      *        ----- ----- ----- ----- -----  ----- ----- ----- ----- -----      */     int h[] = { 2,    0,    3,    3,    1,     3,    3,    1,    3,    3};     int v[] = { 4,    2,    2,    2,    3,     2,    3,    2,    4,    4};     int hs, vs;      assert(1 == scanf(\"%d\", &n));     assert(n > 0);      for (i = 0; i < n; i++) {         assert(1 == scanf(\"%s\", s));         m = strlen(s);         if (0 == m)             continue;         hs = 0;         vs = 0;         for (j = 0; j < m; j++) {             hs += h[s[j] - '0'];             vs += v[s[j] - '0'];         }         printf(\"%d %d\\n\", hs, vs);     }      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "样例不给7，7的数码管字体有争议啊。", "referer": "user-0"}]}
{"question": "怎么用C程序读取文本文件，并把原始文件打印在屏幕上？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "open -> read -> 处理 -> write", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "fopen(); fread()", "referer": "user-0"}]}
{"question": "求问这个结果是怎么得出的？能讲解一下吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "出题者的意图是考察小端字节序。 然而相差1字节的两个指针要强制转换类型，我怀疑至少有一个要产生总线对齐错误啊。", "referer": "user-0"}]}
{"question": "为什么结果是这样？？？求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include \"stdio.h\" void main() {     printf(\"******************************\\n\");     printf(\"       1---------ADD(+)       \\n\");     printf(\"       2---------SUB(-)       \\n\");     printf(\"       3---------MUL(*)       \\n\");     printf(\"       4---------DIV(/)       \\n\");     printf(\"******************************\\n\");      }  //****************************** //       1---------ADD(+) //       2---------SUB(-) //       3---------MUL(*) //       4---------DIV(/) //****************************** //请按任意键继续. .", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你都\\n回车了，又加空格不是有毒吗", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "printf(\"******************************\\n\"            \"       1---------ADD(+)       \\n\"            \"       2---------SUB(-)       \\n\"            \"       3---------MUL(*)       \\n\"            \"       4---------DIV(/)       \\n\"            \"******************************\\n\");", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "前一个\\n后面那些空格理所当然地被挤到下一行开头了。", "referer": "user-0"}]}
{"question": "HELP", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "最好还是自己写，迟早的事", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 2 楼 qzjhjxj 的回复:供参考：#include<stdio.h> #include <math.h>  int is_prime(int n);  int main() {     int i,cnt =0,sum=0;     for (i=1000;i<=9999;i++){         if (is_prime(i)) {             cnt++;             sum += i;             printf(\"%-6d%c\", i,cnt%10 ? ' ':'\\n');         }     }     printf(\"\\ncount=%d,sum=%d\",cnt,sum);          return 0; }  int is_prime(int n) {     int i;     if (n <= 1)         return 0;     for (i = 2; i <= sqrt(n); i++) {         if (n % i == 0)             return 0;     }     return 1; }我一点都不赞成给这样的贴子回帖。发这种贴子的多半时学生，这么轻易的告诉他们答案岂不是害了他们。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "供参考：#include<stdio.h> #include <math.h>  int is_prime(int n);  int main() {     int i,cnt =0,sum=0;     for (i=1000;i<=9999;i++){         if (is_prime(i)) {             cnt++;             sum += i;             printf(\"%-6d%c\", i,cnt%10 ? ' ':'\\n');         }     }     printf(\"\\ncount=%d,sum=%d\",cnt,sum);          return 0; }  int is_prime(int n) {     int i;     if (n <= 1)         return 0;     for (i = 2; i <= sqrt(n); i++) {         if (n % i == 0)             return 0;     }     return 1; }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "网上很多例子，自己下载下来试试，改一改。总得自己动动手吧", "referer": "user-0"}]}
{"question": "help", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不建议当伸手党呢～", "referer": "user-0"}]}
{"question": "C语言求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "娃，好好学习，论坛里面时答疑解惑的，没人帮你做题。", "referer": "user-0"}]}
{"question": "VS2019 debug assertion failed 问题怎么解决？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fputs(\"Done displaying.\",stdout);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "阿 太粗心了，多谢大佬!", "referer": "user-0"}]}
{"question": "vc 问题，为什么输出这样的结果？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "如果你是要用冒泡排序，可以写成 for (l = 0; l < 5; l++)     {         for (n = 0; n < 5 - l - 1; n++)         {             if (a[n] > a[n + 1])             {                 k = a[n];                 a[n] = a[n + 1];                 a[n + 1] = k;             }         }     }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这是冒泡排序吗？看的我一愣一愣的", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "a[n+1]下标越界", "referer": "user-0"}]}
{"question": "纯小白，请问大佬在VScode上配置c语言环境时出现这种情况怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把F5扣下来", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 4 楼 weideha 的回复:我摁F5运行就会自动跳到调试控制台，有什么办法点F5时不会跳到调试控制台吗 你把左边的调试控制台，鼠标左键按住“调试控制台”几个字，然后拖动它到屏幕下面，然后就能看到一排好几个tap，切到“输出”窗口", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我摁F5运行就会自动跳到调试控制台，有什么办法点F5时不会跳到调试控制台吗", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "没什么问题，你没有断点，程序执行完毕，退出状态为0表示程序正常退出。你要是想看输出，应该把调试控制台那儿切到终端窗口", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "遇到啥问题了？看起来是好的呀", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "大佬们帮个忙吧", "referer": "user-0"}]}
{"question": "想走嵌入式方向，大佬有建议吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "嵌入式前景好，因为和硬件结合紧密，所以你嵌入式学到的技术都是实打实的，包括程序和电路方面", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "听你们这样说前景不好呀", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "对学生来说，如何学一门知识往往都是简单的问题，真正的问题在于大方向的把握。 所以，建议你看看来自己学校招聘的单位，然后考虑要不要考研，再考虑要不要报辅导班", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "嵌入式方向可以进一步分硬件方向和软件方向。 硬件方向：看数据手册，设计电路等等。 软件方向：和PC没本质区别。 如果是小项目，纯裸机程序。硬件电路和裸机驱动，也可能一个人搞定。。", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "嵌入式内地发展缓慢，建议去深圳，嵌入式门槛高，得有过硬水平", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "浏览一下本网页下面CSDN自动生成的博文。", "referer": "user-0"}]}
{"question": "C语言：二进制数转换为十进制数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "多谢，楼客们！！！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "如果不调用现成函数要自己写的话就要写函数式的，本示例适用任意进制。    十六进制的话：fa += x * 乘方(16, c++)；", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "仅供参考：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,\"%032s\",b);     printf(\"i=%d,bs=%s\\n\",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,\"%08s\",h);     printf(\"i=%d,hs=%s\\n\",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,\"00000400\");     sscanf(hs,\"%x\",&i);     printf(\"hs=%s,i=%d\\n\",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,\"00000000000000000000010000000000\");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,\"%08s\",h);     printf(\"bs=%s,hs=%s\\n\",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,\"00000000000000000000010000000000\");     i=strtol(bs,&e,2);     printf(\"bs=%s,i=%d\\n\",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,\"00000400\");     sscanf(hs,\"%x\",&i);     ltoa(i,b,2);     sprintf(bs,\"%032s\",b);     printf(\"hs=%s,bs=%s\\n\",hs,bs); // ASC\\GBK字符串转十六进制串     strcpy(s,\"a汉\");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,\"%02X\",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,\"chs\");     printf(\"s=%s,hs=%s\\n\",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,\"61BABA\");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,\"%2x\",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf(\"hs=%s,s=%s\\n\",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "当输入超过5位时，计算出错，修改如下，供参考：#include <stdio.h> void main() {     int n,twn,ten=0,v=1;//权值     int a,b,c,d,e;     scanf(\"%d%d\",&n,&twn);     b=twn;     while(n--){           a = b % 10;           ten += a*v;           v *= 2;           b /= 10;     }    /*if(n>4)     {         a=twn/10000;         b=twn%10000/1000;            c=twn%1000/100;         d=twn%100/10;         e=twn%10;         ten=a*16+b*8+c*4+d*2+e;        }     else if(n>3)     {         a=twn/1000;         b=twn%1000/100;         c=twn%100/10;         d=twn%10;         ten=a*8+b*4+c*2+d;           }     else if(n>2)     {         a=twn/100;         b=twn%100/10;         c=twn%10;         ten=a*4+b*2+c;     }     else if(n>1)     {         a=twn/10;         b=twn%10;         ten=a*2+b;     }     else if(n>0)     {         ten=twn;     }*/     printf(\"二进制序列(%d)的值为:%d\\n\",twn,ten);      }", "referer": "user-0"}]}
{"question": "C语言系统问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这是没有打开项目，打开项目就可以了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "啊这，因为这是写c++的IDE，所以不能打开c语言系统", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "鼠标点击左边SHIXUN，展开项目，找到源代码，双击。", "referer": "user-0"}]}
{"question": "【C语言求助】嵌套循环问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 forever74的回复:我瞎猜的：  楼主之前的考虑是数学的思维， 令 变量temp为另外三个变量的立方和 然后下文每次提到temp的时候它都根据依赖的自变量的当前值自动重新计算temp的最新结果  是这样的考虑催生了0楼的代码。 确实。我很多时候都是手比脑子动的快，对于这种执行顺序的问题就很少动脑子。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "我瞎猜的：  楼主之前的考虑是数学的思维， 令 变量temp为另外三个变量的立方和 然后下文每次提到temp的时候它都根据依赖的自变量的当前值自动重新计算temp的最新结果  是这样的考虑催生了0楼的代码。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "嗯，还是得说，初学者学习程序设计的门槛之一  你首先得抛弃学习程序设计之前的“自动”观念 temp=pow......; 这样的赋值语句只会在轮到它执行的时候执行一次，刷新变量temp的值 它不会因为你写了上述语句，就在上述语句右侧变量有变化的时候“自动”更新左边变量的值  各位大佬，上述几行怎样表达才能更简洁更明确？望不吝赐教。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:修改楼主的，供参考：#include <stdio.h> #include <math.h> void main() {             printf(\"hw 5.8\\n\");             //temp=pow(bai,3)+pow(shi,3)+pow(ge,3); //这里temp bai shi ge 变量都还没定义             for(double bai=1,shi=0,ge=0;(100*bai+10*shi+ge)<=999;bai++)//这里虽然定义了，数据类型不对呢，int型就可以了             {                                                        //百位数的循环                 //int temp=pow(bai,3)+pow(shi,3)+pow(ge,3);//这句放在这里，shi ge 位数变化捕捉不到                  for(shi=0,ge=0;shi<=9;shi++)//十位数的循环                 {                     for(ge=0;ge<=9;ge++) //个位数的循环                     {                         int temp=pow(bai,3)+pow(shi,3)+pow(ge,3);                         if((100*bai+10*shi+ge)==temp)                         {                             //printf(\"%d%d%d\\n\",bai,shi,ge); 既然前面定义的是double型，输出不能用%d                             printf(\"%.0f%.0f%.0f\\n\",bai,shi,ge);                         }                        //else printf(\"条件不满足  %d%d%d%d\",bai,shi,ge,temp);                        //这句是只要不满足就输出一条，题目没要求呢,而且输出用 %d 也不对                     }                     ge=0;                 }                 shi=0,ge=0;            }             } 谢谢！前几天事情比较多，没来得及回复", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "修改楼主的，供参考：#include <stdio.h> #include <math.h> void main() {             printf(\"hw 5.8\\n\");             //temp=pow(bai,3)+pow(shi,3)+pow(ge,3); //这里temp bai shi ge 变量都还没定义             for(double bai=1,shi=0,ge=0;(100*bai+10*shi+ge)<=999;bai++)//这里虽然定义了，数据类型不对呢，int型就可以了             {                                                        //百位数的循环                 //int temp=pow(bai,3)+pow(shi,3)+pow(ge,3);//这句放在这里，shi ge 位数变化捕捉不到                  for(shi=0,ge=0;shi<=9;shi++)//十位数的循环                 {                     for(ge=0;ge<=9;ge++) //个位数的循环                     {                         int temp=pow(bai,3)+pow(shi,3)+pow(ge,3);                         if((100*bai+10*shi+ge)==temp)                         {                             //printf(\"%d%d%d\\n\",bai,shi,ge); 既然前面定义的是double型，输出不能用%d                             printf(\"%.0f%.0f%.0f\\n\",bai,shi,ge);                         }                        //else printf(\"条件不满足  %d%d%d%d\",bai,shi,ge,temp);                        //这句是只要不满足就输出一条，题目没要求呢,而且输出用 %d 也不对                     }                     ge=0;                 }                 shi=0,ge=0;            }             }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "楼主想复杂了，这个例子，供参考：#include <stdio.h>  int main(void) {     int sum,temp,i,n;     for (i = 100;i < 1000; ++i){          temp= i;          sum = 0;          while(temp){    //temp到0时跳出循环               n = temp%10;//每次取得一位数值，如153，分别取3 5 1               sum += n*n*n;//每位数值的立方和               temp/= 10;          }          if (i == sum){  //如立方和sum 与原数 i相同，即为水仙花数              printf(\"%d\\n\",i);          }     }          return 0; }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:楼主想复杂了，这个例子，供参考：#include <stdio.h>  int main(void) {     int sum,temp,i,n;     for (i = 100;i < 1000; ++i){          temp= i;          sum = 0;          while(temp){    //temp到0时跳出循环               n = temp%10;//每次取得一位数值，如153，分别取3 5 1               sum += n*n*n;//每位数值的立方和               temp/= 10;          }          if (i == sum){  //如立方和sum 与原数 i相同，即为水仙花数              printf(\"%d\\n\",i);          }     }          return 0; } 嗷，原来还能这样啊。 但我还是想知道我原来那个错在哪。。。", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "其他问题，对比代码找一下原因～", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "#include <stdio.h> #include <math.h>  //void main() int main(void) {     printf(\"hw 5.8\\n\");     int temp;     //temp = pow(bai,3)+pow(shi,3)+pow(ge,3);     //for(double bai=1,shi=0,ge=0; (100*bai + 10 * shi+ge)<=999;bai++)   //百位数的循环     for(int bai=1,shi=0,ge=0; (100*bai + 10 * shi + ge) <= 999; bai++)   //百位数的循环     {          //int temp=pow(bai,3)+pow(shi,3)+pow(ge,3);         for(shi=0,ge=0;shi<=9;shi++)  //十位数的循环         {             for(ge = 0; ge<=9;ge++)           //个位数的循环             {                 temp=pow(bai,3)+pow(shi,3)+pow(ge,3);                 if((100*bai+10*shi+ge)==temp)                     printf(\"%d%d%d\\n\",bai,shi,ge);                 //else                   //  printf(\"条件不满足  %d %d%d%d\",bai,shi,ge,temp);              }             ge=0;          }         shi=0,ge=0;     }      return 0; } 供参考～  注意temp计算的位置要做调整，放在最内层循环；另外，去掉else的打印，因为100~999之内只有几个是水仙花，因此大部分不是水仙花，因此无用的打印会影响到你想要的打印～", "referer": "user-0"}]}
{"question": "VC   error C2660: 'ge' : function does not take 3 parameters", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:#include <stdio.h> #include <math.h>  //void main() int main(void) {     double ge(double, double, double);     double a,b,c,d;     a=2;     b=5;     c=2;     ge(a,b,c); }  double ge(double a,double b,double c) {     double m;     m=(-b+sqrt(b*b-4*a*c))/2*a;     return(m); } 供参考～  函数声明有问题，楼主的声明更像调用，但是又加上了返回值，又不是函数调用。函数声明要确定参数，即使没有参数，建议用void。如果有参数，至少填上参数类型，参数名可以不用～ 好的👌了解了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qzjhjxj的回复:问题见注释，供参考:#include\"stdio.h\" #include\"math.h\" void main() {     double ge(double a,double b,double c);//函数声明必须函数实现写法一致     double a,b,c,d;     a=2;     b=5;     c=2;     d=ge(a,b,c);     //函数返回赋值给d     printf(\"%f\\n\",d);//输出看结果      }  double ge(double a,double b,double c)//函数实现 {     double m;     m=(-b+sqrt(b*b-4*a*c))/2*a;     return(m); } okok谢谢大佬", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 墨梅无痕的回复:void main() { double ge(); double a,b,c,d; …………  红色的这句是啥用意？ 我的声明有问题，get it", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "#include <stdio.h> #include <math.h>  //void main() int main(void) {     double ge(double, double, double);     double a,b,c,d;     a=2;     b=5;     c=2;     ge(a,b,c); }  double ge(double a,double b,double c) {     double m;     m=(-b+sqrt(b*b-4*a*c))/2*a;     return(m); } 供参考～  函数声明有问题，楼主的声明更像调用，但是又加上了返回值，又不是函数调用。函数声明要确定参数，即使没有参数，建议用void。如果有参数，至少填上参数类型，参数名可以不用～", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "double get（）。声明是没有参数的，后面调用的时候给了三个参数。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "问题见注释，供参考:#include\"stdio.h\" #include\"math.h\" void main() {     double ge(double a,double b,double c);//函数声明必须函数实现写法一致     double a,b,c,d;     a=2;     b=5;     c=2;     d=ge(a,b,c);     //函数返回赋值给d     printf(\"%f\\n\",d);//输出看结果      }  double ge(double a,double b,double c)//函数实现 {     double m;     m=(-b+sqrt(b*b-4*a*c))/2*a;     return(m); }", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "void main() { double ge(); double a,b,c,d; …………  红色的这句是啥用意？", "referer": "user-0"}]}
{"question": "求解：第一句话的含义并且如何实现，怎么判断数据类型", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 mymtom的回复: /* 输出 */ /*           20 : 00010100           40 : 0000000000101000          100 : 00000000000000000000000001100100         -100 : 11111111111111111111111110011100 */  不是直接输出答案啊用程序算出答案", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "/* 输出 */ /*           20 : 00010100           40 : 0000000000101000          100 : 00000000000000000000000001100100         -100 : 11111111111111111111111110011100 */", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include <stdio.h>  char * bits(char type, int value, char *buf) {     unsigned int bit;     unsigned int u;     int len;     int i;      if ('c' == type) {         bit = 0x80;         len = 8;     } else if ('s' == type) {         bit = 0x8000;         len = 16;     } else if ('i' == type) {         bit = 0x80000000;         len = 32;     }      u = (unsigned int)value;     for (i = 0; i < len; i++) {         if (u & bit) {             buf[i] = '1';         } else {             buf[i] = '0';         }         bit >>= 1;     }      buf[len] = '\\0';      return buf; }  int main(int argc, char *argv[]) {     char buf[32 + 1];      char  c =  20;     short s =  40;     int   i = 100;     printf(\"%12d : %s\\n\", c, bits('c', c, buf));     printf(\"%12d : %s\\n\", s, bits('s', s, buf));     printf(\"%12d : %s\\n\", i, bits('i', i, buf));     i = -100;     printf(\"%12d : %s\\n\", i, bits('i', i, buf));      return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "仅供参考：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,\"%032s\",b);     printf(\"i=%d,bs=%s\\n\",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,\"%08s\",h);     printf(\"i=%d,hs=%s\\n\",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,\"00000400\");     sscanf(hs,\"%x\",&i);     printf(\"hs=%s,i=%d\\n\",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,\"00000000000000000000010000000000\");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,\"%08s\",h);     printf(\"bs=%s,hs=%s\\n\",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,\"00000000000000000000010000000000\");     i=strtol(bs,&e,2);     printf(\"bs=%s,i=%d\\n\",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,\"00000400\");     sscanf(hs,\"%x\",&i);     ltoa(i,b,2);     sprintf(bs,\"%032s\",b);     printf(\"hs=%s,bs=%s\\n\",hs,bs); // ASC\\GBK字符串转十六进制串     strcpy(s,\"a汉\");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,\"%02X\",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,\"chs\");     printf(\"s=%s,hs=%s\\n\",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,\"61BABA\");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,\"%2x\",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf(\"hs=%s,s=%s\\n\",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "不过题目说了“编写C程序……”，那就用if或switch判断具体数据类型吧。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:C++模板了解一下。 c++刚上了一节课😅我去了解一下", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "C++模板了解一下。", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "分别写三个函数各做各的就行，不用你自己写代码判断类型，都由人脑判断，然后去调用各自的处理函数。 库里还有abs和fabs这种呢，没啥丢人的。", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "引用 8 楼 m0_52291497 的回复:[quote=引用 7 楼 mymtom的回复:] /* 输出 */ /*           20 : 00010100           40 : 0000000000101000          100 : 00000000000000000000000001100100         -100 : 11111111111111111111111110011100 */  不是直接输出答案啊用程序算出答案[/quote] 6楼是程序，这里是6楼的程序的输出", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "审题！审题！审题！", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "都是比我厉害的大佬，有些代码还没学过，有的学了", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "引用 12 楼 user-6 的回复:感觉这题出的有问题，明明加了内存中存储的字样，却只给出了大端示例，但一般平时用的机器，小端居多。2种都给你吧。 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef unsigned char UChar; int main() { \tint a; \tscanf(\"%d\",&a); \t//按照实际内存序  \tUChar* pa=(UChar*)&a; \tfor(int i=0;i<sizeof(a);i++) \t{ \t\tUChar s = *pa; \t\tfor(int i=7;i>=0;i--) \t\t\tprintf(\"%d\",(s>>i)&1); \t\tpa++; \t} \tprintf(\"\\n\"); \t//按照题目示例的意思  \tchar binS[33]; \tltoa(a,binS,2); \tfor(int i=0;i<32-strlen(binS);i++) \t\tprintf(\"%c\",'0'); \tprintf(\"%s\",binS);\t \treturn 0; } 大小端就扯远了！重点是2进制数，所以能显示从高位低位就可以了", "referer": "user-0"}, {"cid": "14", "user": "user-6", "content": "感觉这题出的有问题，明明加了内存中存储的字样，却只给出了大端示例，但一般平时用的机器，小端居多。2种都给你吧。 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef unsigned char UChar; int main() { \tint a; \tscanf(\"%d\",&a); \t//按照实际内存序  \tUChar* pa=(UChar*)&a; \tfor(int i=0;i<sizeof(a);i++) \t{ \t\tUChar s = *pa; \t\tfor(int i=7;i>=0;i--) \t\t\tprintf(\"%d\",(s>>i)&1); \t\tpa++; \t} \tprintf(\"\\n\"); \t//按照题目示例的意思  \tchar binS[33]; \tltoa(a,binS,2); \tfor(int i=0;i<32-strlen(binS);i++) \t\tprintf(\"%c\",'0'); \tprintf(\"%s\",binS);\t \treturn 0; }", "referer": "user-0"}, {"cid": "15", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h> int main() {     int i;     char b[33];     char ln[80];     char c;      while (1) {         rewind(stdin);         fgets(ln,80,stdin);         if (ln[0]=='\\n') break;         if (2==sscanf(ln,\"c=%d%c\",&i,&c) && c=='\\n' && -128<=c && c<=127) {             ltoa(i,b,2);             printf(\"%0*s\\n\", 8,b);         } else         if (2==sscanf(ln,\"s=%d%c\",&i,&c) && c=='\\n' && -32768 && c<=32767) {             ltoa(i,b,2);             printf(\"%0*s\\n\",16,b);         } else         if (2==sscanf(ln,\"i=%d%c\",&i,&c) && c=='\\n'                      ) {             ltoa(i,b,2);             printf(\"%0*s\\n\",32,b);         } else         if (2==sscanf(ln,\"j=%d%c\",&i,&c) && c=='\\n'                      ) {             ltoa(i,b,2);             printf(\"%0*s\\n\",32,b);         } else {             printf(\"Format Error!\\n\");         }     }      return 0; } //输入c=20 //输出00010100 //输入s=40 //输出0000000000101000 //输入i=100 //输出00000000000000000000000001100100 //输入j=-100 //输出11111111111111111111111110011100 //输入回车 //退出程序", "referer": "user-0"}]}
{"question": "C语言中指针", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "m=1; n=2; r = &m; p=r; q=&n; 初始态是这样的，我帮你翻译下吧： p=p+1=r+1；到此结束，由于指针前没加解引用，因此这里是地址加1，此时p的值已经不是m的地址了。相当&m的地址基值，再加4个字节 再继续下去，其实p是个局部变量，对他再怎么改，也不会影响main函数的值，除非加上解引用，就是*  再看*q=*q+1，分2部分，一个看前面左值，一个看后面右值 *q=*(&n)=n ，于是得到*q为n   //*和&互为逆运算 *q+1=*(&n)+1=n+1 ，于是得到*q+1 为n+1 于是：*q=*q+1就相当于：n=n+1", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "因为p = p +1是地址值加1，不是地址值指向的内容加1. 与此不同的*q = *q + 1;就是q指向的内容加1.", "referer": "user-0"}]}
{"question": "请问一下这个指针数组为什么一定要有大小才能运行出来啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 8 楼 lin5161678 的回复:引用 2 楼 paena 的回复:这样写：int** p = &test2;不行 好吧，前面我随手打了，sorry。 #include<stdio.h> int main() { \tint test2[9]={1,2,3,4,5,6,7,8,9}; \tint* p = test2; \tint** p1 = &p;  \tfor(int i=0;i<9;i++) \t\tprintf(\"%d\\n\",*(*p1+i)); \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 2 楼 paena 的回复:这样写：int** p = &test2;不行", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "&test2就基本上看成是二维数组了。因为test2是一维数组。  所以int (*p)[9] = &test2；后面的9是指该指针指向的是长度是9的数组。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 1 楼 forever74 的回复:因为它就不是个指针数组 它是个指针，要正确赋值，必须类型兼容。 这是一个数组指针；数组指针和指针数组还是有区别的，要看谁修饰谁，数组指针，是数组修饰指针，最终的名字是指针，指针数组，是指针修饰数组，最终是数组，数组元素都是指针。", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "事实上面对负责一些的编译器，这个程序如果改为int **p是会引出warning的，而程序员不应该只满足于消灭编译error。 那样的写法在后续操作中会出乱子的。", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "这是数组指针，指向数组的指针。", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "引用 楼主 qq_53317242的回复:这里（*p）【】里面必须要填上9才能运行出来，不填或者填更大都不可以，请问这是为什么啊？ 参见《C++程序设计精要教程》类型等价性证明。取test2的地址，相当于用一个指针指向test2, 而test2的定义int test2[9]=int (test2)[9]，故取test2的地址对应的类型为int(&test2)[9]=int(*)[9]，该类型应和被赋值的变量p的类型相同，即p应该定义为int (*)[9]类型，定义形式应为int (*p)[9]。设Q的类型为(*)，则p的类型int(*)[9]=int Q[9]，且因一维数组[9]可视为单重指针*，则int Q[9]=int *Q=int *(*)。鉴于两个*的优先级相同，且结合性为自右至左，故去掉( )并不影响运算顺序，即int *(*)=int **, 因此p的类型int (*)[9]=int**类型，故p也可以定义为int **p。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "这样写：int** p = &test2;", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "因为它就不是个指针数组 它是个指针，要正确赋值，必须类型兼容。", "referer": "user-0"}]}
{"question": "洛谷新手村程序练习题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主的代码，第一图和第二图差了输出的语句printf(\"%d\", m); ，第二图当然没输出了，逻辑上没有错， for (j = 0; j < n-1; j++) 这里，应该是 for (j = 0; j < n; j++) 。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include<stdio.h> #define MAX_SIZE 100 int main() { \tint n,num; \tint array[MAX_SIZE]; \tchar isused[MAX_SIZE]; \tscanf(\"%d\",&n); \tfor(int i=0;i<n;i++) \t\tscanf(\"%d\",&array[i]),isused[i]=0; \tnum=0; \tfor(int i=0;i<n-1;i++) \t\tfor(int j=i+1;j<n;j++) \t\t\tfor(int k=0;k<n;k++) \t\t\t\tif(isused[k]== 0 && array[k] == array[i]+array[j]) \t\t\t\t\tnum++, isused[k] = 1; \tprintf(\"%d\",num); \treturn 0;\t }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include <stdio.h> #include <stdlib.h>  int main() {     int i, j, k, n;     int *arr, m = 0;      scanf(\"%d\", &n);       arr = (int *)malloc(sizeof(int) * n);     if (!arr)         return -1;      for (i = 0; i < n; i++)         scanf(\"%d\", &arr[i]);      for (i = 0; i < n; i++) {         for (j = 0; j < n; j++) {             if (i == j)                 continue;             for (k = j+1; k < n; k++) {                 if (k == i || k == j)                     continue;                 if (arr[i] == arr[j] + arr[k]) {                     printf(\"%d = %d + %d\\n\", arr[i], arr[k], arr[j]);                     m++;                 }             }         }     }     printf(\"%d\\n\", m);     free(arr);      return 0; } 供参考～  试试这个版本～", "referer": "user-0"}]}
{"question": "请问哪里出错了,字符都是英文状态，实在找不到了，求教！！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这么简单个程序，找不到就重新打一遍", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "printf(\"字符个数为：%d\"，d);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "对啊，就是我早先说的那个逗号是中文的。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "最后一个printf中，d前面那个，改为,就行了", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "多次验证没有字符大小写错误 求解！！！", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 forever74 的回复:来，把文本复制过来。  #include\"stdio.h\" int nu()//求统计输入字符的个数 { int a; for(a=0;getchar()!='@';a++); return a; } main() { int d; d=nu(); printf(\"字符个数为：%d\"，d); }", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "貌似：你printf函数左括号是不是大一点。是不是有一边括号用中午输入法输入了。重新输入一遍试试。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "另外，把出错信息那个扁窗口向上滚动一下看看还藏着什么。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "供参考：#include <stdio.h> int nu() {    int a;    for(a=0;(getchar())!='@';a++);//注意这里的变化getchar()!='@'    return a; }  int main() {    int d;    d = nu();    printf(\"字符个数为:%d\",d);//注意这行的符号及' )'       return 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "来，把文本复制过来。", "referer": "user-0"}]}
{"question": "C语言 结构", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:加在str是没问题，p->str++确实是str加1，指向了向后偏移一个字节的空间，但是p是野指针呢，野指针操作str是未定义的。但是编译器是不会检查到这里的。 这个题目感觉有一定的问题。强说是语法错误还是有点牵强。但是野指针问题确实在前。 好的，谢谢！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "加在str是没问题，p->str++确实是str加1，指向了向后偏移一个字节的空间，但是p是野指针呢，野指针操作str是未定义的。但是编译器是不会检查到这里的。 这个题目感觉有一定的问题。强说是语法错误还是有点牵强。但是野指针问题确实在前。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "答案错了呗，我是选A的。", "referer": "user-0"}]}
{"question": "数据储存到文件为什么乱码？求大佬解答。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修正楼上第51行fscanf(fp,\"%s %s %s %s %s %s\",p1->number,p1->name,p1->sex,p1->age,p1->speciaity,p1->Class);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主说的乱码，主要是最后的保存链表信息到文件并释放内存空间void Saveandfree()函数和文件信打开void Open()函数写入和读出的格式不同，对这两函数修改如下，问题见注释，供参考：//保存链表信息到文件并释放内存空间 void Saveandfree() {      TEL  *p=NULL;      FILE *fp;      char *Book=\"books.txt\";      if (head==NULL){          printf(\"\\n记录为空！\\n\");          return;      }      else p=head->next;      if ((fp=fopen(Book,\"wb+\"))==NULL){          printf(\"\\n打不开文件!\\n\");          return;      }      while (p!=NULL){                     //保存信息            //fwrite(p,1,sizeof(TEL),fp); //这个写法是把结构体第7项 p->Telephone *next;也写入文件了                                          //所谓的乱码就是这部分的内容。            fprintf(fp,\"%s %s %s %s %s %s \",p->number,p->name,p->sex,p->age,p->speciaity,p->Class);            p=p->next;      }      printf(\"保存完毕!\");      fclose(fp);      //*****释放链表空间*****      for(;head->next!=NULL;){          p=head->next;          head->next=head->next->next;          free(p);      }      free(head); }  //文件信息输出到链表 void Open() {      FILE *fp;      TEL  *p1=NULL,*p2=NULL,*temp=NULL;      if ((fp=fopen(\"books.txt\",\"rb+\"))==NULL){         printf(\"\\n****************这是一个新的学生信息管理系统******************\\n\");         return;      }      head=(TEL *)malloc(sizeof(TEL));      head->next=NULL;      temp=p2=head;      while (! feof(fp)){         //循环读取            p1=(TEL *)malloc(sizeof(TEL));            temp=p2;            p2->next=p1;            p2=p1;            //fread(p1,sizeof(TEL),1,fp); //对应的读出文件信息的方法也不一样            fscanf(fp,\"%s %s %s %s %s %s\",&p1->number,&p1->name,&p1->sex,&p1->age,&p1->speciaity,&p1->Class);      }      temp->next=NULL;      fclose(fp);               //关闭文件 }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "因为保存文件选的是wb也就是二进制文件，所以看上去是乱码", "referer": "user-0"}]}
{"question": "C语言指针部分", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-5的回复:n的地址固然不会变，但是n的值变了呀。 谢谢，明白了。。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 gouyanfen的回复:这个代码怎么看都是8吧 n=m; (*p)++; n不是改变了吗？ A00000:n的地址(值为A0000C) . . . A0000C:m起始地址 值1 A00010:                  值8  函数传入了n的址址 A00000 *p值类型为int 读取内容为A0000C 然后++ 结果为 A00010 存入到A00000 n的存放在址没变，指向变了 最后结果  地址:A00000: 存放内容 A00010 指向结果为8 谢谢我明白了", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "因为n的地址向后偏移的一个元素的长度，因此n指向了m[1]的位置，因此是8；  注意(*p) ++即n++;因为*p和n指向的位置是相同的，且类型一样；", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "n=m           //指针指向数组m的首地址（m[0]的地址） testf(&n)    //指针移动到m[1]的地址", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "这个代码怎么看都是8吧 n=m; (*p)++; n不是改变了吗？ A00000:n的地址(值为A0000C) . . . A0000C:m起始地址 值1 A00010:                  值8  函数传入了n的址址 A00000 *p值类型为int 读取内容为A0000C 然后++ 结果为 A00010 存入到A00000 n的存放在址没变，指向变了 最后结果  地址:A00000: 存放内容 A00010 指向结果为8", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "n的地址固然不会变，但是n的值变了呀。", "referer": "user-0"}]}
{"question": "gcc搜索路径的字符串是记录在哪里的？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "印象里应该是父进程修改自己的环境或新建环境变量加入自己的环境，然后调用子进程并把自己的环境遗传给它。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "我个人对环境变量并无深入学习。对于如何查看特定进程的环境变量我一无所知。 但是我知道环境变量并不都是全局的，另开一个进程查看环境变量应该不能看到特定进程的全部环境变量。 例如 早期动态网页的接口CGI就是靠环境变量工作的，如果环境变量都是全局的，那CGI就乱套了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "一、双引号和尖括号引用头文件的区别 对于双引号和尖括号包含的头文件的搜索方式有细微差别， 前者的搜索路径选择先后为：使用#include的文件所在的当前路径，-I指定的路径，环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径，内定路径； 而后者就只有三种，依次是-I指定的路径，环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径，内定路径。  着重介绍后者的那三种选择： ●-I参数指定的路径； ●环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径； ●内定路径。 前两种可由我们自己指定哪些路径，第三种是gcc内置的，用户改变不了。  二、-I参数指定的路径 -I参数的用法为gcc <filename> -I <pathname_1> -I <pathname_2>，-I后边只能紧跟一个路径名，想要手动指定几个头文件搜索路径，就得写几个-I。 gcc hello.c -I ~/mydir1 -I ~/mydir2  三、环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径 gcc在搜索完-I参数指定路径后，便会查看环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径， 这两个环境变量都是路径的集合，我们可以手动往这两个环境变量里添加路径。  以C_INCLUDE_PATH为例，添加路径有两种方法，如果该新增路径只是临时需要，则可以在命令行输入 echo C_INCLUDE_PATH=$C_INCLUDE_PATH:<pathname> 如果是长期需要，则应在~/.bashrc或/etc/profile添加export C_INCLUDE_PATH=$C_INCLUDE_PATH:<pathname> 然后保存并退出文件，在命令行中执行命令source ~/.bashrc或source /etc/profile。  四、内定路径 第三种的内定路径无法更改，但可以查看，如何查看呢？ 可先随便写一个C文件，然后在命令行执行命令gcc <filename> -v 以显示整个编译过程。显示内容有一行是#include <...> search starts here:， mingw64(gcc-10.2.0)\\bin\\../lib/gcc/x86_64-w64-mingw32/10.2.0/include mingw64(gcc-10.2.0)\\bin\\../lib/gcc/x86_64-w64-mingw32/10.2.0/include-fixed mingw64(gcc-10.2.0)\\bin\\../lib/gcc/x86_64-w64-mingw32/10.2.0/../../../../x86_64-w64-mingw32/include", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "环境变量C_INCLUDE_PATH、CPLUS_INCLUDE_PATH是指linux内的环境变量吗？Windows MINGW环境应该是没有的吧？--->这个可以自己添加设置Windows的环境变量，我在用MinGW-w64配置C++ Boost库时使用过，是有效的", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 11 楼 Intel0011 的回复:一、双引号和尖括号引用头文件的区别 对于双引号和尖括号包含的头文件的搜索方式有细微差别， 前者的搜索路径选择先后为：使用#include的文件所在的当前路径，-I指定的路径，环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径，内定路径； 而后者就只有三种，依次是-I指定的路径，环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径，内定路径。  着重介绍后者的那三种选择： ●-I参数指定的路径； ●环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径； ●内定路径。 前两种可由我们自己指定哪些路径，第三种是gcc内置的，用户改变不了。  二、-I参数指定的路径 -I参数的用法为gcc <filename> -I <pathname_1> -I <pathname_2>，-I后边只能紧跟一个路径名，想要手动指定几个头文件搜索路径，就得写几个-I。 gcc hello.c -I ~/mydir1 -I ~/mydir2  三、环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径 gcc在搜索完-I参数指定路径后，便会查看环境变量C_INCLUDE_PATH或CPLUS_INCLUDE_PATH包含的路径， 这两个环境变量都是路径的集合，我们可以手动往这两个环境变量里添加路径。  以C_INCLUDE_PATH为例，添加路径有两种方法，如果该新增路径只是临时需要，则可以在命令行输入 echo C_INCLUDE_PATH=$C_INCLUDE_PATH:<pathname> 如果是长期需要，则应在~/.bashrc或/etc/profile添加export C_INCLUDE_PATH=$C_INCLUDE_PATH:<pathname> 然后保存并退出文件，在命令行中执行命令source ~/.bashrc或source /etc/profile。  四、内定路径 第三种的内定路径无法更改，但可以查看，如何查看呢？ 可先随便写一个C文件，然后在命令行执行命令gcc <filename> -v 以显示整个编译过程。显示内容有一行是#include <...> search starts here:， mingw64(gcc-10.2.0)\\bin\\../lib/gcc/x86_64-w64-mingw32/10.2.0/include mingw64(gcc-10.2.0)\\bin\\../lib/gcc/x86_64-w64-mingw32/10.2.0/include-fixed mingw64(gcc-10.2.0)\\bin\\../lib/gcc/x86_64-w64-mingw32/10.2.0/../../../../x86_64-w64-mingw32/include   还是老哥你给力  环境变量C_INCLUDE_PATH、CPLUS_INCLUDE_PATH是指linux内的环境变量吗？Windows MINGW环境应该是没有的吧？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "应该是命令行吧", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "搜索的头文件和库路径是由配置决定的。windows下也有配置的地方。  Linux下也是有配置系统的路径，比如/usr/include/   #头文件 /lib/   #库  建议搜一下头文件和库配置路径的地方～", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 3 楼 forever74 的回复:当然了，环境变量也是有来源的，脚本或注册表都有可能。 但是修改过来源以后往往需要重启系统才好看到环境变量的改变。 你确定是在Windows环境吗？", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 user-7 的回复:环境变量 C_INCLIDE_PATH MINGW，Windows环境，我没找到该环境变量", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "下载mingw的源码看一下就知道了", "referer": "user-0"}, {"cid": "11", "user": "user-6", "content": "供参考：https://blog.csdn.net/qinglinsan/article/details/11478091 http://www.360doc.com/content/16/0928/00/7991404_594388737.shtml", "referer": "user-0"}, {"cid": "12", "user": "user-1", "content": "当然了，环境变量也是有来源的，脚本或注册表都有可能。 但是修改过来源以后往往需要重启系统才好看到环境变量的改变。", "referer": "user-0"}, {"cid": "13", "user": "user-1", "content": "环境变量了解一下？", "referer": "user-0"}, {"cid": "14", "user": "user-7", "content": "环境变量 C_INCLIDE_PATH", "referer": "user-0"}]}
{"question": "请问错误在哪里，求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "出现中文的右括号了吧  建议注意下括号的中英文。  另外， main的返回值类型加一下，根据你的编译器来定，可以用void，也可以用int，根据你的编译器来定吧～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "看编译窗口的错误提示，error 那行告诉你错哪了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你那行的 ) 是否是中文字符？ 猜的", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "你的printf后面括号里中间部位的逗号太胖了，大概率是中文的。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 2 楼 focuslight 的回复:你那行的 ) 是否是中文字符？ 猜的  如果括号是中文的，那么VC6这么老的编译器就不会认识它，只会用十六进制内码来表示它。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 4 楼 user-3 的回复:[quote=引用 3 楼 自信男孩 的回复:][quote=引用 2 楼 user-3 的回复:]输入输出更可靠点，修改楼上的：#include <stdio.h>  int main() {     int  a, b, c;     char ch[2]={'Y'};      while(ch[0]=='Y'|| ch[0]=='y'){           while (1){                       //输入                 printf(\"输入三角形的三条边(正整数)：\");                 fflush(stdout);                 rewind(stdin);                 if (scanf(\"%d%d%d\", &a,&b,&c) != 3 || a < 0 || b < 0 || c < 0){                     printf(\"\\n输入错误!\\n\");                     continue;                 }else                 if (a+b<=c || a+c<=b || b+c<=a){ //判断是否可构成三角形,任意两边之和大于第三边                     printf(\"\\n输入的边长无法构成三角形!\\n\");                     continue;                 }else                     break;           }           if (a == b || a == c || b == c){//判断三角形类型              if (a==b && b==c && a==c){                 printf(\"\\n输入的边长为等边三角形\\n\");              }else{                 printf(\"\\n输入的边长为等腰三角形\\n\");              }           }           else              if (a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a){                 printf(\"\\n输入的边长为直角三角形\\n\");              }else{                 printf(\"\\n输入的边长为任意三角形\\n\");              }           printf(\"\\n是否继续判断其它三角形的类型[Y/N]?\");           fflush(stdout);           rewind(stdin);           scanf(\"%s\",ch);     }          return 0; } 输入0之后，只要有一个0是不是就应该不满足条件。没考虑到输入0的case吧[/quote] 0还是排除在外的，这里if (a+b<=c || a+c<=b || b+c<=a){ //判断是否可构成三角形,任意两边之和大于第三边[/quote]   if (scanf(\"%d%d%d\", &a,&b,&c) != 3 || a < 0 || b < 0 || c < 0){ 放在这里判断会更好些～   if (scanf(\"%d%d%d\", &a,&b,&c) != 3 || a <= 0 || b <= 0 || c <= 0){", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 3 楼 自信男孩 的回复:[quote=引用 2 楼 user-3 的回复:]输入输出更可靠点，修改楼上的：#include <stdio.h>  int main() {     int  a, b, c;     char ch[2]={'Y'};      while(ch[0]=='Y'|| ch[0]=='y'){           while (1){                       //输入                 printf(\"输入三角形的三条边(正整数)：\");                 fflush(stdout);                 rewind(stdin);                 if (scanf(\"%d%d%d\", &a,&b,&c) != 3 || a < 0 || b < 0 || c < 0){                     printf(\"\\n输入错误!\\n\");                     continue;                 }else                 if (a+b<=c || a+c<=b || b+c<=a){ //判断是否可构成三角形,任意两边之和大于第三边                     printf(\"\\n输入的边长无法构成三角形!\\n\");                     continue;                 }else                     break;           }           if (a == b || a == c || b == c){//判断三角形类型              if (a==b && b==c && a==c){                 printf(\"\\n输入的边长为等边三角形\\n\");              }else{                 printf(\"\\n输入的边长为等腰三角形\\n\");              }           }           else              if (a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a){                 printf(\"\\n输入的边长为直角三角形\\n\");              }else{                 printf(\"\\n输入的边长为任意三角形\\n\");              }           printf(\"\\n是否继续判断其它三角形的类型[Y/N]?\");           fflush(stdout);           rewind(stdin);           scanf(\"%s\",ch);     }          return 0; } 输入0之后，只要有一个0是不是就应该不满足条件。没考虑到输入0的case吧[/quote] 0还是排除在外的，这里if (a+b<=c || a+c<=b || b+c<=a){ //判断是否可构成三角形,任意两边之和大于第三边", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 2 楼 user-3 的回复:输入输出更可靠点，修改楼上的：#include <stdio.h>  int main() {     int  a, b, c;     char ch[2]={'Y'};      while(ch[0]=='Y'|| ch[0]=='y'){           while (1){                       //输入                 printf(\"输入三角形的三条边(正整数)：\");                 fflush(stdout);                 rewind(stdin);                 if (scanf(\"%d%d%d\", &a,&b,&c) != 3 || a < 0 || b < 0 || c < 0){                     printf(\"\\n输入错误!\\n\");                     continue;                 }else                 if (a+b<=c || a+c<=b || b+c<=a){ //判断是否可构成三角形,任意两边之和大于第三边                     printf(\"\\n输入的边长无法构成三角形!\\n\");                     continue;                 }else                     break;           }           if (a == b || a == c || b == c){//判断三角形类型              if (a==b && b==c && a==c){                 printf(\"\\n输入的边长为等边三角形\\n\");              }else{                 printf(\"\\n输入的边长为等腰三角形\\n\");              }           }           else              if (a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a){                 printf(\"\\n输入的边长为直角三角形\\n\");              }else{                 printf(\"\\n输入的边长为任意三角形\\n\");              }           printf(\"\\n是否继续判断其它三角形的类型[Y/N]?\");           fflush(stdout);           rewind(stdin);           scanf(\"%s\",ch);     }          return 0; } 输入0之后，只要有一个0是不是就应该不满足条件。没考虑到输入0的case吧", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "输入输出更可靠点，修改楼上的：#include <stdio.h>  int main() {     int  a, b, c;     char ch[2]={'Y'};      while(ch[0]=='Y'|| ch[0]=='y'){           while (1){                       //输入                 printf(\"输入三角形的三条边(正整数)：\");                 fflush(stdout);                 rewind(stdin);                 if (scanf(\"%d%d%d\", &a,&b,&c) != 3 || a < 0 || b < 0 || c < 0){                     printf(\"\\n输入错误!\\n\");                     continue;                 }else                 if (a+b<=c || a+c<=b || b+c<=a){ //判断是否可构成三角形,任意两边之和大于第三边                     printf(\"\\n输入的边长无法构成三角形!\\n\");                     continue;                 }else                     break;           }           if (a == b || a == c || b == c){//判断三角形类型              if (a==b && b==c && a==c){                 printf(\"\\n输入的边长为等边三角形\\n\");              }else{                 printf(\"\\n输入的边长为等腰三角形\\n\");              }           }           else              if (a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a){                 printf(\"\\n输入的边长为直角三角形\\n\");              }else{                 printf(\"\\n输入的边长为任意三角形\\n\");              }           printf(\"\\n是否继续判断其它三角形的类型[Y/N]?\");           fflush(stdout);           rewind(stdin);           scanf(\"%s\",ch);     }          return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "供参考：#include <stdio.h>  int main() {     int  a, b, c;     char s='Y';      while(s=='Y'|| s=='y'){           while (1){                       //输入                 printf(\"输入三角形的三条边(正整数)：\");                 if (scanf(\"%d%d%d\", &a,&b,&c) != 3 || a < 0 || b < 0 || c < 0){                     while ((getchar())!='\\n');                     printf(\"\\n输入错误!\\n\");                     continue;                 }else                 if (a+b<=c || a+c<=b || b+c<=a){ //判断是否可构成三角形,任意两边之和大于第三边                     printf(\"\\n输入的边长无法构成三角形!\\n\");                     continue;                 }else                     break;           }           if (a == b || a == c || b == c){//判断三角形类型              if (a==b && b==c && a==c){                 printf(\"\\n输入的边长为等边三角形\\n\");              }else{                 printf(\"\\n输入的边长为等腰三角形\\n\");              }           }           else              if (a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a){                 printf(\"\\n输入的边长为直角三角形\\n\");              }else{                 printf(\"\\n输入的边长为任意三角形\\n\");              }           printf(\"\\n是否继续判断其它三角形的类型[Y/N]?\");           getchar();           scanf(\"%c\",&s);     }          return 0; }", "referer": "user-0"}]}
{"question": "【C语言求助】", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h>   #define FILE_NAME_LEN    32 #define MAX_KEY_NUM     26 enum { \tENCRYPT_DATA = 1, \tDECRYPT_DATA, \tFORCE_DECRYPT_DATA,     EXIT_PROCESS };   /*加密函数，把字符向右循环移位n*/ char encrypt(char ch, int n) {     while(ch >= 'A' && ch <= 'Z') {         return ('A'+(ch-'A'+n)%26);     }     while(ch >= 'a' && ch <= 'z') {         return ('a'+(ch-'a'+n)%26);     }     return ch; }  /*菜单，1.加密，2.解密，3.暴力破解，密码只能是数字*/ static void menu(void) {     printf(\"\\n=========================================================\");     printf(\"\\n1.Encrypt the file\");     printf(\"\\n2.Decrypt the file\");     printf(\"\\n3.Force decrypt file\");     printf(\"\\n4.Quit\\n\");     printf(\"=========================================================\\n\");      return; }  static int get_opt(void) {     int option, ret;      printf(\"Please input your choice: \");     ret = scanf(\"%d\", &option);     while (ret != 1) {         printf(\"Please input your choice: \");         ret = scanf(\"%d\", &option);     }      return option; }  /* Open a file, then return file decription. */ static FILE *open_file(const char *filename, const char *openmode) { \tFILE *fp = NULL;  \tfp = fopen(filename, openmode); \tif(!fp) {        \tprintf(\"Can not open the outfile: %s, %s!\\n\", filename, strerror(errno)); \t\texit(0);     }  \treturn fp; }  /* Copy data from source file to destination file. */ int copy_data(FILE *src_fp, FILE *dst_fp, int key) { \tint data, cnt = 0;  \twhile(!feof(src_fp)) {\t/* 加密 */         data = encrypt(fgetc(src_fp), key);         if (data != EOF) {             putchar(data);             fputc(data, dst_fp); \t\t    cnt++;         } \t}   \treturn cnt; }  int main(int argc, const char *argv[]) {     char src_file[FILE_NAME_LEN];     char dst_file[FILE_NAME_LEN];     FILE *src_fp, *dst_fp;     int option, key, ret;     int total_num, i;      while (1) {         menu();         option = get_opt();         if (option == EXIT_PROCESS) {             printf(\"Goodbye!\\n\");             break;         }         printf(\"Please input src file: \");         scanf(\"%s\", src_file);         src_fp = open_file(src_file, \"r\");         if (!src_fp)             return 1;         printf(\"Please input dst file: \");         scanf(\"%s\", dst_file);         dst_fp = open_file(dst_file, \"w\");         if (!dst_fp) {             fclose(src_fp);             return 1;         }         if (option != FORCE_DECRYPT_DATA) {             printf(\"Please input the key: \");             ret = scanf(\"%d\", &key);             while (ret != 1) {                 printf(\"Please input the key: \");                 ret = scanf(\"%d\", &key);             }         }         switch (option) {         case ENCRYPT_DATA:             total_num = copy_data(src_fp, dst_fp, key);             printf(\"Encrypt %d character(s)\\n\", total_num); \t        fclose(src_fp); \t        fclose(dst_fp);             break;          case DECRYPT_DATA:             key = 26 - key;             total_num = copy_data(src_fp, dst_fp, key);             printf(\"Encrypt %d character(s)\\n\", total_num); \t        fclose(src_fp); \t        fclose(dst_fp);             break;          case FORCE_DECRYPT_DATA:             for (i = 1; i < MAX_KEY_NUM; i++) {                 fseek(src_fp, 0l, SEEK_SET);                 fseek(dst_fp, 0l, SEEK_SET);                 total_num = copy_data(src_fp, dst_fp, 26-i);                 printf(\"Current encrypt's key is %d\\n\", i);                 printf(\"Encrypt %d character(s)\\n\", total_num);                 printf(\"Press 'Q' to quit and other key to continue......\\n\");                 option = getchar();                 if (option == 'Q' || option == 'q') {                     break;                 }             } \t        fclose(src_fp); \t        fclose(dst_fp);             break;         }         printf(\"\\nEncrypt is over!\\n\");      }     return 0; }  供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "再读密码循环前，再加个getchar()，把前面的回车读掉，用getchar()都要注意这个问题。  引用 楼主 飞禽走兽卍一2b 的回复:（本代码目的是将输入的字符换成后面第四个字母，China——>Glmre，前面那段代码是并列执行的，便于让各位看到结果的差异，即口Glmre）  问题描述： 当独立执行第二段代码时输出：Glmre 当和第一段代码并列执行时输出：口Glmr   #include <math.h> #include <stdio.h> int main(void) {     //以下为并列的代码，不是主要问题    {                   printf(\"hw 3.2\\n\");            float way,temp;             printf(\"请输入金额：\\n\");             scanf(\"%f\",&temp);            printf(\"请输入存款方式(1-5)：\\n\");                         scanf(\"%f\",&way);              if(way==1)                  {                   temp*=(1+5*0.03);                  printf(\"result= %f \\n\\n\",temp);            }            else if(way==2)          {                 temp*=(1+2*0.021);                                                 temp*=(1+3*0.0275);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==3)           {                   temp*=(1+3*0.0275);                                       temp*=(1+2*0.021);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {                temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }    //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;    getchar(); //这里要加个getchar()把前面的回车读掉，才是你这个问题的根本原因          for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();   //将输入的字符赋给变量        }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                              //c[5]='\\0';           这里越界了，但不是根本问题             putchar(c[i]);         }                 putchar('\\n');      }  } 请大家帮忙看看是哪的问题，谢谢！", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 5 楼 飞禽走兽卍一2b 的回复:[quote=引用 3 楼 自信男孩的回复:]#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h>   #define FILE_NAME_LEN    32 #define MAX_KEY_NUM     26 enum { \tENCRYPT_DATA = 1, \tDECRYPT_DATA, \tFORCE_DECRYPT_DATA,     EXIT_PROCESS };   /*加密函数，把字符向右循环移位n*/ char encrypt(char ch, int n) {     while(ch >= 'A' && ch <= 'Z') {         return ('A'+(ch-'A'+n)%26);     }     while(ch >= 'a' && ch <= 'z') {         return ('a'+(ch-'a'+n)%26);     }     return ch; }  /*菜单，1.加密，2.解密，3.暴力破解，密码只能是数字*/ static void menu(void) {     printf(\"\\n=========================================================\");     printf(\"\\n1.Encrypt the file\");     printf(\"\\n2.Decrypt the file\");     printf(\"\\n3.Force decrypt file\");     printf(\"\\n4.Quit\\n\");     printf(\"=========================================================\\n\");      return; }  static int get_opt(void) {     int option, ret;      printf(\"Please input your choice: \");     ret = scanf(\"%d\", &option);     while (ret != 1) {         printf(\"Please input your choice: \");         ret = scanf(\"%d\", &option);     }      return option; }  /* Open a file, then return file decription. */ static FILE *open_file(const char *filename, const char *openmode) { \tFILE *fp = NULL;  \tfp = fopen(filename, openmode); \tif(!fp) {        \tprintf(\"Can not open the outfile: %s, %s!\\n\", filename, strerror(errno)); \t\texit(0);     }  \treturn fp; }  /* Copy data from source file to destination file. */ int copy_data(FILE *src_fp, FILE *dst_fp, int key) { \tint data, cnt = 0;  \twhile(!feof(src_fp)) {\t/* 加密 */         data = encrypt(fgetc(src_fp), key);         if (data != EOF) {             putchar(data);             fputc(data, dst_fp); \t\t    cnt++;         } \t}   \treturn cnt; }  int main(int argc, const char *argv[]) {     char src_file[FILE_NAME_LEN];     char dst_file[FILE_NAME_LEN];     FILE *src_fp, *dst_fp;     int option, key, ret;     int total_num, i;      while (1) {         menu();         option = get_opt();         if (option == EXIT_PROCESS) {             printf(\"Goodbye!\\n\");             break;         }         printf(\"Please input src file: \");         scanf(\"%s\", src_file);         src_fp = open_file(src_file, \"r\");         if (!src_fp)             return 1;         printf(\"Please input dst file: \");         scanf(\"%s\", dst_file);         dst_fp = open_file(dst_file, \"w\");         if (!dst_fp) {             fclose(src_fp);             return 1;         }         if (option != FORCE_DECRYPT_DATA) {             printf(\"Please input the key: \");             ret = scanf(\"%d\", &key);             while (ret != 1) {                 printf(\"Please input the key: \");                 ret = scanf(\"%d\", &key);             }         }         switch (option) {         case ENCRYPT_DATA:             total_num = copy_data(src_fp, dst_fp, key);             printf(\"Encrypt %d character(s)\\n\", total_num); \t        fclose(src_fp); \t        fclose(dst_fp);             break;          case DECRYPT_DATA:             key = 26 - key;             total_num = copy_data(src_fp, dst_fp, key);             printf(\"Encrypt %d character(s)\\n\", total_num); \t        fclose(src_fp); \t        fclose(dst_fp);             break;          case FORCE_DECRYPT_DATA:             for (i = 1; i < MAX_KEY_NUM; i++) {                 fseek(src_fp, 0l, SEEK_SET);                 fseek(dst_fp, 0l, SEEK_SET);                 total_num = copy_data(src_fp, dst_fp, 26-i);                 printf(\"Current encrypt's key is %d\\n\", i);                 printf(\"Encrypt %d character(s)\\n\", total_num);                 printf(\"Press 'Q' to quit and other key to continue......\\n\");                 option = getchar();                 if (option == 'Q' || option == 'q') {                     break;                 }             } \t        fclose(src_fp); \t        fclose(dst_fp);             break;         }         printf(\"\\nEncrypt is over!\\n\");      }     return 0; }  供参考～ 看不懂不过还是谢谢啦！[/quote]  只看加密和解密部分吧，其他的不用考虑～", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h>   #define FILE_NAME_LEN    32 #define MAX_KEY_NUM     26 enum { \tENCRYPT_DATA = 1, \tDECRYPT_DATA, \tFORCE_DECRYPT_DATA,     EXIT_PROCESS };   /*加密函数，把字符向右循环移位n*/ char encrypt(char ch, int n) {     while(ch >= 'A' && ch <= 'Z') {         return ('A'+(ch-'A'+n)%26);     }     while(ch >= 'a' && ch <= 'z') {         return ('a'+(ch-'a'+n)%26);     }     return ch; }  /*菜单，1.加密，2.解密，3.暴力破解，密码只能是数字*/ static void menu(void) {     printf(\"\\n=========================================================\");     printf(\"\\n1.Encrypt the file\");     printf(\"\\n2.Decrypt the file\");     printf(\"\\n3.Force decrypt file\");     printf(\"\\n4.Quit\\n\");     printf(\"=========================================================\\n\");      return; }  static int get_opt(void) {     int option, ret;      printf(\"Please input your choice: \");     ret = scanf(\"%d\", &option);     while (ret != 1) {         printf(\"Please input your choice: \");         ret = scanf(\"%d\", &option);     }      return option; }  /* Open a file, then return file decription. */ static FILE *open_file(const char *filename, const char *openmode) { \tFILE *fp = NULL;  \tfp = fopen(filename, openmode); \tif(!fp) {        \tprintf(\"Can not open the outfile: %s, %s!\\n\", filename, strerror(errno)); \t\texit(0);     }  \treturn fp; }  /* Copy data from source file to destination file. */ int copy_data(FILE *src_fp, FILE *dst_fp, int key) { \tint data, cnt = 0;  \twhile(!feof(src_fp)) {\t/* 加密 */         data = encrypt(fgetc(src_fp), key);         if (data != EOF) {             putchar(data);             fputc(data, dst_fp); \t\t    cnt++;         } \t}   \treturn cnt; }  int main(int argc, const char *argv[]) {     char src_file[FILE_NAME_LEN];     char dst_file[FILE_NAME_LEN];     FILE *src_fp, *dst_fp;     int option, key, ret;     int total_num, i;      while (1) {         menu();         option = get_opt();         if (option == EXIT_PROCESS) {             printf(\"Goodbye!\\n\");             break;         }         printf(\"Please input src file: \");         scanf(\"%s\", src_file);         src_fp = open_file(src_file, \"r\");         if (!src_fp)             return 1;         printf(\"Please input dst file: \");         scanf(\"%s\", dst_file);         dst_fp = open_file(dst_file, \"w\");         if (!dst_fp) {             fclose(src_fp);             return 1;         }         if (option != FORCE_DECRYPT_DATA) {             printf(\"Please input the key: \");             ret = scanf(\"%d\", &key);             while (ret != 1) {                 printf(\"Please input the key: \");                 ret = scanf(\"%d\", &key);             }         }         switch (option) {         case ENCRYPT_DATA:             total_num = copy_data(src_fp, dst_fp, key);             printf(\"Encrypt %d character(s)\\n\", total_num); \t        fclose(src_fp); \t        fclose(dst_fp);             break;          case DECRYPT_DATA:             key = 26 - key;             total_num = copy_data(src_fp, dst_fp, key);             printf(\"Encrypt %d character(s)\\n\", total_num); \t        fclose(src_fp); \t        fclose(dst_fp);             break;          case FORCE_DECRYPT_DATA:             for (i = 1; i < MAX_KEY_NUM; i++) {                 fseek(src_fp, 0l, SEEK_SET);                 fseek(dst_fp, 0l, SEEK_SET);                 total_num = copy_data(src_fp, dst_fp, 26-i);                 printf(\"Current encrypt's key is %d\\n\", i);                 printf(\"Encrypt %d character(s)\\n\", total_num);                 printf(\"Press 'Q' to quit and other key to continue......\\n\");                 option = getchar();                 if (option == 'Q' || option == 'q') {                     break;                 }             } \t        fclose(src_fp); \t        fclose(dst_fp);             break;         }         printf(\"\\nEncrypt is over!\\n\");      }     return 0; }  供参考～ 看不懂不过还是谢谢啦！", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 paena的回复:再读密码循环前，再加个getchar()，把前面的回车读掉，用getchar()都要注意这个问题。  [quote=引用 楼主 飞禽走兽卍一2b 的回复:]（本代码目的是将输入的字符换成后面第四个字母，China——>Glmre，前面那段代码是并列执行的，便于让各位看到结果的差异，即口Glmre）  问题描述： 当独立执行第二段代码时输出：Glmre 当和第一段代码并列执行时输出：口Glmr   #include <math.h> #include <stdio.h> int main(void) {     //以下为并列的代码，不是主要问题    {                   printf(\"hw 3.2\\n\");            float way,temp;             printf(\"请输入金额：\\n\");             scanf(\"%f\",&temp);            printf(\"请输入存款方式(1-5)：\\n\");                         scanf(\"%f\",&way);              if(way==1)                  {                   temp*=(1+5*0.03);                  printf(\"result= %f \\n\\n\",temp);            }            else if(way==2)          {                 temp*=(1+2*0.021);                                                 temp*=(1+3*0.0275);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==3)           {                   temp*=(1+3*0.0275);                                       temp*=(1+2*0.021);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {                temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }    //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;    getchar(); //这里要加个getchar()把前面的回车读掉，才是你这个问题的根本原因          for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();   //将输入的字符赋给变量        }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                              //c[5]='\\0';           这里越界了，但不是根本问题             putchar(c[i]);         }                 putchar('\\n');      }  } 请大家帮忙看看是哪的问题，谢谢！   [/quote] 谢谢！现在知道了", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "引用 楼主 飞禽走兽卍一2b 的回复:（本代码目的是将输入的字符换成后面第四个字母，China——>Glmre，前面那段代码是并列执行的，便于让各位看到结果的差异，即口Glmre）  问题描述： 当独立执行第二段代码时输出：Glmre 当和第一段代码并列执行时输出：口Glmr   #include <math.h> #include <stdio.h> int main(void) {     //以下为并列的代码，不是主要问题    {                   printf(\"hw 3.2\\n\");            float way,temp;             printf(\"请输入金额：\\n\");             scanf(\"%f\",&temp);            printf(\"请输入存款方式(1-5)：\\n\");                         scanf(\"%f\",&way);              if(way==1)                  {                   temp*=(1+5*0.03);                  printf(\"result= %f \\n\\n\",temp);            }            else if(way==2)          {                 temp*=(1+2*0.021);                                                 temp*=(1+3*0.0275);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==3)           {                   temp*=(1+3*0.0275);                                       temp*=(1+2*0.021);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {                temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }    //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;                 for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();   //将输入的字符赋给变量        }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                              c[5]='\\0'; 这里对数组越界操作，这句也是多余的，删除就好了                     putchar(c[i]);         }                 putchar('\\n');      }  } 请大家帮忙看看是哪的问题，谢谢！", "referer": "user-0"}]}
{"question": "队列操作问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "大佬们都好厉害，小弟前来学习学习，大家共同一起进步！！！！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 9 楼 Zhi Zhao 的回复:但是这个是循环队列，数组的容量并没有增加   #include<stdio.h> #include<stdlib.h>  typedef int ElementType; typedef struct {     ElementType *array;     int front;     int rear;     int capacity;   // 队列总容量 }SeqQueue;  // 循环队列的创建 SeqQueue *createQueue(int capacity) {     SeqQueue *q;     q=(SeqQueue *)malloc(sizeof(SeqQueue));      q->front=q->rear=0;     q->capacity=capacity;     q->array=(ElementType *)malloc(sizeof(ElementType)*capacity);      return q; }  // 入队 int push(SeqQueue *q,ElementType x) {     if( (q->rear+1) % q->capacity == q->front){         q->array[q->rear]=x;         q->rear=(q->rear+1) % q->capacity;         return 0;     }       // 队列已满     printf(\"+++%d\\n\", x);     q->array[q->rear]=x;     q->rear=(q->rear+1) % q->capacity;      return 1; }  // 出队 int pop(SeqQueue *q,ElementType *x) {     if(q->rear == (q->front + 1) % q->capacity)     // 队列为空     {         *x = q->array[q->front];         q->front=(q->front+1) % q->capacity;         return 0;     }     *x = q->array[q->front];     q->front=(q->front+1) % q->capacity;      return 1; }  int main() {     int b,i,N;     SeqQueue *p;      printf(\"请输入数组的大小：\\n\");     scanf(\"%d\",&N);     printf(\"\\n\");     p=createQueue(N);      printf(\"请输入数字：\\n\");     for(i=0;i<N;i++)     {         scanf(\"%d\",&b);         push(p,b);     }     printf(\"front = %d,rear= %d\\n\", p->front, p->rear);     while(pop(p,&b))     {         printf(\"%d \",b);     }     printf(\"%d\\n\", b);     return 0; }  供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "假设数组的容量为4(下标0-3)，因为队列下标的问题，所以这句    if( (q->rear+1) % q->capacity == q->front) // 队列已满         return 0;的判断必须是+1的，所以当队列下标到3的时候，正确的判断是队列未满的，但这里的判断是队列已满的条件了。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "但是这个是循环队列，数组的容量并没有增加", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "见注释，供参考：#include<stdio.h> #include<stdlib.h>  typedef int ElementType;  typedef struct {     ElementType *array;     int         front;     int         rear;     int         capacity;   // 队列总容量 }SeqQueue;  // 循环队列的创建 SeqQueue *createQueue(int capacity) {     SeqQueue *q;     q=(SeqQueue *)malloc(sizeof(SeqQueue));      q->front=q->rear=0;     q->capacity=capacity+1; //这里要和入队，出队时的+1同步     q->array=(ElementType *)malloc(sizeof(ElementType)*capacity);     return q; }  // 入队 int push(SeqQueue *q,ElementType x) {     if( (q->rear+1) % q->capacity == q->front) // 队列已满         return 0;     q->array[q->rear]=x;     q->rear=(q->rear+1) % q->capacity;     return 1; }  // 出队 int pop(SeqQueue *q,ElementType *x) {     if (q->rear==q->front)     // 队列为空        return 0;     *x=q->array[q->front];     q->front=(q->front+1) % q->capacity;     return 1; }  int main() {     int b,i,N;     SeqQueue *p;      printf(\"请输入数组的大小：\\n\");     scanf(\"%d\",&N);     printf(\"\\n\");     p=createQueue(N);      printf(\"请输入数字：\\n\");     for (i=0;i<N;i++)         {            scanf(\"%d\",&b);            push(p,b);         }     while(pop(p,&b))        {           printf(\"%d \",b);        }     printf(\"\\n\");          return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "#include<stdio.h> #include<stdlib.h>  typedef int ElementType; typedef struct { \tElementType *array; \tint front; \tint rear; \tint capacity;   // 队列总容量 }SeqQueue;  // 循环队列的创建 SeqQueue *createQueue(int capacity) { \tSeqQueue *q; \tq=(SeqQueue *)malloc(sizeof(SeqQueue));  \tq->front=q->rear=0; \tq->capacity=capacity; \tq->array=(ElementType *)malloc(sizeof(ElementType)*capacity);  \treturn q; }  // 入队 int push(SeqQueue *q,ElementType x) { \tif( (q->rear+1) % q->capacity == q->front)       // 队列已满 \t\treturn 0; \tq->array[q->rear]=x; \tq->rear=(q->rear+1) % q->capacity;  \treturn 1; }  // 出队 int pop(SeqQueue *q,ElementType *x) { \tif(q->rear==q->front)     // 队列为空 \t\treturn 0; \t*x=q->array[q->front]; \tq->front=(q->front+1) % q->capacity;  \treturn 1; }  int main() { \tint b,i,N; \tSeqQueue *p;  \tprintf(\"请输入数组的大小：\\n\"); \tscanf(\"%d\",&N); \tprintf(\"\\n\"); \tp=createQueue(N);  \tprintf(\"请输入数字：\\n\"); \tfor(i=0;i<N;i++) \t{ \t\tscanf(\"%d\",&b); \t\tpush(p,b); \t} \twhile(pop(p,&b)) \t{ \t\tprintf(\"%d \",b); \t} \tprintf(\"\\n\"); \treturn 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "到pop(SeqQueue* Q, int* e)这个函数里面找问题，估计边界判断错了。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "代码不全不能准确定位到问题所在～", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "阅，再接再厉，再创辉煌。", "referer": "user-0"}]}
{"question": "C语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include<algorithm> #include<cstdio> #include <math.h>  using namespace std;  int is_prime(int n); static void swap(int *a, int *b);  int main() {     int i = 2, j = 0;     int left, right, cnt = 0;      scanf(\"%d%d\", &left, &right);      if (left > right)         swap(&left, &right);     while (1) {         if (is_prime(i)) {             cnt++;             if (left <= cnt && cnt <= right) {                 j++;                 printf(\"%d%c\", i, j% 10 ? ' ':'\\n');             }             if (cnt > right)                 break;         }         i++;     }     putchar(10);      /*        int left,right,t=0,order=1,j=0;        bool re=false;        int ss[10001];        ss[0]=2;        scanf(\"%d%d\",&left,&right);        if(!left){        left=1;        }        for(int i=2;order<right;i++)        {        for( j=2;j<=sqrt(i);j++){        if(i%j==0)        {        re=false;        break;        }        }        if(re){        ss[order++]=i;        }        re=true;        }        left-=1;        right-=1;        while(left<=right){        t++;        if(t%10==0||left==right){        t=0;        }         printf(\"%d%c\",ss[left++],t?'*':'\\0');         if(t==0)printf(\"\\n\");     }     */     return 0; }  int is_prime(int n) {     int i;      if (n <= 1)         return 0;      for (i = 2; i <= sqrt(n); i++) {         if (n % i == 0)             return 0;     }      return 1; }  static void swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }  供参考～  没用数组，只用了循环～", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:#include <algorithm> #include <cstdio> #include <math.h> using namespace std; int main(){     int left,right,t=0,order=1,j=0;     bool re=false;     int ss[10001];     ss[0]=2;     scanf(\"%d%d\",&left,&right);     if (!left) {         left=1;     }     for (int i=2;order<right;i++) {         for (j=2;j<=sqrt(i);j++) {             if (i%j==0) {                 re=false;                 break;             }         }         if (re) {             ss[order++]=i;         }         re=true;     }     left-=1;     right-=1;     while (left<=right) {         t++;         if (t%10==0 || left==right ) {             t=0;         }         if (t==0) {             printf(\"%d\\n\",ss[left++]);         } else {             printf(\"%d \",ss[left++]);         }     }     return 0; } 你好我试了你的通过了，我能问问我的代码和你的有什么区别吗，感觉没有区别最后面", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 棉猴 的回复:代码没问题啊", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 棉猴 的回复:代码没问题啊 但是会有2个测试点过不了", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "代码没问题啊", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "#include <algorithm> #include <cstdio> #include <math.h> using namespace std; int main(){     int left,right,t=0,order=1,j=0;     bool re=false;     int ss[10001];     ss[0]=2;     scanf(\"%d%d\",&left,&right);     if (!left) {         left=1;     }     for (int i=2;order<right;i++) {         for (j=2;j<=sqrt(i);j++) {             if (i%j==0) {                 re=false;                 break;             }         }         if (re) {             ss[order++]=i;         }         re=true;     }     left-=1;     right-=1;     while (left<=right) {         t++;         if (t%10==0 || left==right ) {             t=0;         }         if (t==0) {             printf(\"%d\\n\",ss[left++]);         } else {             printf(\"%d \",ss[left++]);         }     }     return 0; }", "referer": "user-0"}]}
{"question": "【C语言求助】和其他代码并列执行此代码时输出空心方框", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：//问题描述： //当独立执行此段代码时输出：Glmre //当和其他代码并列执行时输出：口Glmr  #include <math.h> #include <stdio.h> int main(void) {      printf(\"hw 3.6\\n\");      printf(\"请输入五位数密码：\\n\");      char c[5];       //这里c[5],下标为c[0]---c[4]      int i;      for(i=0;i<5;i++)       //for(i=0;i<6;i++)          {         c[i]=getchar();           }      for(i=0;i<5;i++)     //for(i=0;i<6;i++)       {         c[i]=c[i]+4;                                //c[5]='\\0'; //结束 总共5位的数组，c[5]下标越界了，没有放'\\0'结束符的位置了,这是字符数组，                                       //没必要有结束标志。         putchar(c[i]);       }      putchar('\\n');            return 0; }  //hw 3.6 //请输入五位数密码： //China                  （5位） //Glmre                   (5位） //请按任意键继续. . .", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "代码里有输入金额、存款方式等，象我们敲完3.4，接下去就敲一个回车，这个回车其实也被读入的，这就是多余的字符。你可以百度下scanf()和getchar()等几个函数的详细用法，了解下输入输出时的一些细节的东西。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 9 楼 user-2的回复:供参考：#include <math.h> #include <stdio.h> int main(void) {  //以下为并列的代码，不是主要问题    {           printf(\"hw 3.2\\n\");           float way,temp;           printf(\"请输入金额：\\n\");           scanf(\"%f\",&temp);           printf(\"请输入存款方式(1-5)：\\n\");           scanf(\"%f\",&way);           if(way==1)           {                 temp*=(1+5*0.03);                 printf(\"result= %f \\n\\n\",temp);           }           else if(way==2)          {               temp*=(1+2*0.021);               temp*=(1+3*0.0275);               printf(\"result= %f \\n\\n\",temp);          }          else if(way==3)         {               temp*=(1+3*0.0275);               temp*=(1+2*0.021);               printf(\"result= %f \\n\\n\",temp);         }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {               temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }      getchar();//这里加一句，吸收前面输入过程中留在缓冲区多余的字符。  //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;                 for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();      //将输入的字符赋给变量     }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                                                   //c[5]='\\0';          putchar(c[i]);     }                 putchar('\\n');     }     system(\"pause\");     return 0; }    //hw 3.2 //请输入金额： //3.4 //请输入存款方式(1-5)： //5 //result=3.459997  //hw 3.6 //请输入五位数密码： //China //Glmre //请按任意键继续. . . 哇⊙∀⊙！太棒了！ 请问这里“留在前面缓冲区的字符”是什么？从哪里来的？ 谢谢！", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "供参考：#include <math.h> #include <stdio.h> int main(void) {  //以下为并列的代码，不是主要问题    {           printf(\"hw 3.2\\n\");           float way,temp;           printf(\"请输入金额：\\n\");           scanf(\"%f\",&temp);           printf(\"请输入存款方式(1-5)：\\n\");           scanf(\"%f\",&way);           if(way==1)           {                 temp*=(1+5*0.03);                 printf(\"result= %f \\n\\n\",temp);           }           else if(way==2)          {               temp*=(1+2*0.021);               temp*=(1+3*0.0275);               printf(\"result= %f \\n\\n\",temp);          }          else if(way==3)         {               temp*=(1+3*0.0275);               temp*=(1+2*0.021);               printf(\"result= %f \\n\\n\",temp);         }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {               temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }      getchar();//这里加一句，吸收前面输入过程中留在缓冲区多余的字符。  //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;                 for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();      //将输入的字符赋给变量     }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                                                   //c[5]='\\0';          putchar(c[i]);     }                 putchar('\\n');     }     system(\"pause\");     return 0; }    //hw 3.2 //请输入金额： //3.4 //请输入存款方式(1-5)： //5 //result=3.459997  //hw 3.6 //请输入五位数密码： //China //Glmre //请按任意键继续. . .", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 7 楼 user-2的回复:错误用红字标出：引用飞禽走兽卍一2b 等级 \t #include <math.h> #include <stdio.h> int main(void) {     //以下为并列的代码，不是主要问题    {                   printf(\"hw 3.2\\n\");            float way,temp;             printf(\"请输入金额：\\n\");             scanf(\"%f\",&temp);            printf(\"请输入存款方式(1-5)：\\n\");                         scanf(\"%f\",&way);              if(way==1)                  {                   temp*=(1+5*0.03);                  printf(\"result= %f \\n\\n\",temp);            }            else if(way==2)          {                 temp*=(1+2*0.021);                                                 temp*=(1+3*0.0275);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==3)           {                   temp*=(1+3*0.0275);                                       temp*=(1+2*0.021);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {                temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }    //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;                 for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();   //将输入的字符赋给变量        }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                              c[5]='\\0'; //这里多了对c[5]数组的操作，而且下标为5，下标越界。                      putchar(c[i]);         }                 putchar('\\n');      }  } 还是不行。。。X﹏X 输出结果是 口Glmr", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "错误用红字标出：引用飞禽走兽卍一2b 等级 \t #include <math.h> #include <stdio.h> int main(void) {     //以下为并列的代码，不是主要问题    {                   printf(\"hw 3.2\\n\");            float way,temp;             printf(\"请输入金额：\\n\");             scanf(\"%f\",&temp);            printf(\"请输入存款方式(1-5)：\\n\");                         scanf(\"%f\",&way);              if(way==1)                  {                   temp*=(1+5*0.03);                  printf(\"result= %f \\n\\n\",temp);            }            else if(way==2)          {                 temp*=(1+2*0.021);                                                 temp*=(1+3*0.0275);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==3)           {                   temp*=(1+3*0.0275);                                       temp*=(1+2*0.021);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {                temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }    //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;                 for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();   //将输入的字符赋给变量        }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                              c[5]='\\0'; //这里多了对c[5]数组的操作，而且下标为5，下标越界。                      putchar(c[i]);         }                 putchar('\\n');      }  }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 4 楼 user-2的回复:当和其他代码并列执行？把代码补全贴上来看看。这里对c[5]数组的操作，下标0-4，或者你不能按字符串的形式输出。 放在评论区里了", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "#include <math.h> #include <stdio.h> int main(void) {     //以下为并列的代码，不是主要问题    {                   printf(\"hw 3.2\\n\");            float way,temp;             printf(\"请输入金额：\\n\");             scanf(\"%f\",&temp);            printf(\"请输入存款方式(1-5)：\\n\");                         scanf(\"%f\",&way);              if(way==1)                  {                   temp*=(1+5*0.03);                  printf(\"result= %f \\n\\n\",temp);            }            else if(way==2)          {                 temp*=(1+2*0.021);                                                 temp*=(1+3*0.0275);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==3)           {                   temp*=(1+3*0.0275);                                       temp*=(1+2*0.021);                printf(\"result= %f \\n\\n\",temp);          }           else if(way==4)         {                  temp*=pow(1.015,5);                printf(\"result= %f \\n\\n\",temp);         }          else         {                temp*=pow(1+0.0035/4,20);                               printf(\"result=%f \\n\\n\",temp);          }       }    //以下为提问的代码     {          printf(\"hw 3.6\\n\");                 printf(\"请输入五位数密码：\\n\");                 char c[5];          int i;                 for(i=0;i<5;i++)      //for循环输入多个字符        {                   c[i]=getchar();   //将输入的字符赋给变量        }               for(i=0;i<5;i++)         {                     c[i]=c[i]+4;         //将输入的字符换成后面第四个                              c[5]='\\0';                       putchar(c[i]);         }                 putchar('\\n');      }  }", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "当和其他代码并列执行？把代码补全贴上来看看。这里对c[5]数组的操作，下标0-4，或者你不能按字符串的形式输出。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考：//问题描述： //当独立执行此段代码时输出：Glmre //当和其他代码并列执行时输出：口Glmr  #include <math.h> #include <stdio.h> int main(void) {      printf(\"hw 3.6\\n\");      printf(\"请输入五位数密码：\\n\");      char c[5];       //这里c[5],下标为c[0]---c[4]      int i;      for(i=0;i<5;i++)       //for(i=0;i<6;i++)          {         c[i]=getchar();           }      for(i=0;i<5;i++)     //for(i=0;i<6;i++)       {         c[i]=c[i]+4;                                //c[5]='\\0'; //结束 总共5位的数组，c[5]下标越界了，没有放'\\0'结束符的位置了,这是字符数组，                                       //没必要有结束标志。         putchar(c[i]);       }      putchar('\\n');            return 0; }  //hw 3.6 //请输入五位数密码： //China                  （5位） //Glmre                   (5位） //请按任意键继续. . . 还是输出了口Glmre", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 user-2的回复:供参考：//问题描述： //当独立执行此段代码时输出：Glmre //当和其他代码并列执行时输出：口Glmr  #include <math.h> #include <stdio.h> int main(void) {      printf(\"hw 3.6\\n\");      printf(\"请输入五位数密码：\\n\");      char c[5];       //这里c[5],下标为c[0]---c[4]      int i;      for(i=0;i<5;i++)       //for(i=0;i<6;i++)          {         c[i]=getchar();           }      for(i=0;i<5;i++)     //for(i=0;i<6;i++)       {         c[i]=c[i]+4;                                //c[5]='\\0'; //结束 总共5位的数组，c[5]下标越界了，没有放'\\0'结束符的位置了,这是字符数组，                                       //没必要有结束标志。         putchar(c[i]);       }      putchar('\\n');            return 0; }  //hw 3.6 //请输入五位数密码： //China                  （5位） //Glmre                   (5位） //请按任意键继续. . . 还是不行啊。。。", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 11 楼 user-2的回复:代码里有输入金额、存款方式等，象我们敲完3.4，接下去就敲一个回车，这个回车其实也被读入的，这就是多余的字符。你可以百度下scanf()和getchar()等几个函数的详细用法，了解下输入输出时的一些细节的东西。 好的，谢谢！ (晚上早点睡哦)", "referer": "user-0"}]}
{"question": "软考的一道直接插入排序题有答案和解析但是看不懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2 的回复：#include <stdio.h>  typedef struct node { \tchar data; \tstruct node* next; } NODE;  void print_list(char c, NODE* list) { \tprintf(\"%c: \", c); \twhile (list) { \t\tprintf(\"[%d]->\", list->data); \t\tlist = list->next; \t} \tprintf(\"NULL\\n\"); }  NODE* insert_sort(NODE* h) { \tNODE *t, *s, *u = NULL, *v; \ts = h->next; \th->next = NULL; \tprint_list('s', s); \tprint_list('h', h); \tprintf(\"\\n\"); \twhile (s != NULL) { \t\tfor (t = s, v = h; v != NULL && v->data < t->data; u = v, v = v->next) { \t\t\t; \t\t} \t\ts = s->next; \t\tif (v == h) { \t\t\th = t; \t\t} else { \t\t\tu->next = t; \t\t} \t\tt->next = v; \t\tprint_list('s', s); \t\tprint_list('h', h); \t\tprint_list('t', t); \t\tprint_list('v', v); \t\tprint_list('u', u); \t\tprintf(\"\\n\"); \t} \treturn h; }  NODE* insert(NODE* LIST, int n) { \tNODE* node = (NODE*)malloc(sizeof(NODE)); \tnode->data = n; \tnode->next = NULL; \tif (LIST) { \t\tnode->next = LIST; \t} \tLIST = node; \treturn LIST; }  int main() { \tNODE* list; \tlist = NULL; \tlist = insert(list, 1); \tlist = insert(list, 5); \tlist = insert(list, 4); \tlist = insert(list, 2); \tlist = insert(list, 3); \t\t \tprintf(\"LIST\"); \tprint_list(' ', list); \tprintf(\"\\n\\n\");  \tlist = insert_sort(list);  \tprintf(\"LIST\"); \tprint_list(' ', list); \tprintf(\"\\n\\n\");  \treturn 0; }  输出结果为： LIST : [3]->[2]->[4]->[5]->[1]->NULL   s: [2]->[4]->[5]->[1]->NULL h: [3]->NULL  s: [4]->[5]->[1]->NULL h: [2]->[3]->NULL t: [2]->[3]->NULL v: [3]->NULL u: NULL  s: [5]->[1]->NULL h: [2]->[3]->[4]->NULL t: [4]->NULL v: NULL u: [3]->[4]->NULL  s: [1]->NULL h: [2]->[3]->[4]->[5]->NULL t: [5]->NULL v: NULL u: [4]->[5]->NULL  s: NULL h: [1]->[2]->[3]->[4]->[5]->NULL t: [1]->[2]->[3]->[4]->[5]->NULL v: [2]->[3]->[4]->[5]->NULL u: [4]->[5]->NULL  LIST : [1]->[2]->[3]->[4]->[5]->NULL  这题因为印刷排版和变量短名极不友好，我这里给你详细解析insert_sort函数里的逻辑。  首先传入一个NODE* h，加上临时指针 t s u v，这些指针既是链表的首元素，也可以是整个链表。  程序的19 20行 \ts = h->next; \th->next = NULL; 这两句，实际上把传入的h链表一分为二成为两个链表。 h作为一个有序链表，保留原来的第一个元素。s为无序链表。从第二个元素到最后，此时输出为： s: [2]->[4]->[5]->[1]->NULL h: [3]->NULL  往下走，24行 while (s != NULL) 这个循环的逻辑是遍历s里每一个NODE，比对h找到相应的位置插入。  25行 for (t = s, v = h; v != NULL && v->data < t->data; u = v, v = v->next) 书上有个分号，其实是空的，只执行for里的循环。 t指向s的第一个元素，这个指针不会移动。v指向h，会在比较大小的时候后移。 u在v移动时，会指向移动前的位置。换言之，u和v之间，要插入的位置。 至于插入哪一个，当然是t指向的那一个。  往下走，29行 if (v == h) 如果v指针没移动过，在h的头部插入t。 否则，在u和v之间插入t。  循环处理完s链表，s置空，h完成排序，返回。我靠大神！我慢慢来看", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>  typedef struct node { \tchar data; \tstruct node* next; } NODE;  void print_list(char c, NODE* list) { \tprintf(\"%c: \", c); \twhile (list) { \t\tprintf(\"[%d]->\", list->data); \t\tlist = list->next; \t} \tprintf(\"NULL\\n\"); }  NODE* insert_sort(NODE* h) { \tNODE *t, *s, *u = NULL, *v; \ts = h->next; \th->next = NULL; \tprint_list('s', s); \tprint_list('h', h); \tprintf(\"\\n\"); \twhile (s != NULL) { \t\tfor (t = s, v = h; v != NULL && v->data < t->data; u = v, v = v->next) { \t\t\t; \t\t} \t\ts = s->next; \t\tif (v == h) { \t\t\th = t; \t\t} else { \t\t\tu->next = t; \t\t} \t\tt->next = v; \t\tprint_list('s', s); \t\tprint_list('h', h); \t\tprint_list('t', t); \t\tprint_list('v', v); \t\tprint_list('u', u); \t\tprintf(\"\\n\"); \t} \treturn h; }  NODE* insert(NODE* LIST, int n) { \tNODE* node = (NODE*)malloc(sizeof(NODE)); \tnode->data = n; \tnode->next = NULL; \tif (LIST) { \t\tnode->next = LIST; \t} \tLIST = node; \treturn LIST; }  int main() { \tNODE* list; \tlist = NULL; \tlist = insert(list, 1); \tlist = insert(list, 5); \tlist = insert(list, 4); \tlist = insert(list, 2); \tlist = insert(list, 3); \t\t \tprintf(\"LIST\"); \tprint_list(' ', list); \tprintf(\"\\n\\n\");  \tlist = insert_sort(list);  \tprintf(\"LIST\"); \tprint_list(' ', list); \tprintf(\"\\n\\n\");  \treturn 0; }  输出结果为： LIST : [3]->[2]->[4]->[5]->[1]->NULL   s: [2]->[4]->[5]->[1]->NULL h: [3]->NULL  s: [4]->[5]->[1]->NULL h: [2]->[3]->NULL t: [2]->[3]->NULL v: [3]->NULL u: NULL  s: [5]->[1]->NULL h: [2]->[3]->[4]->NULL t: [4]->NULL v: NULL u: [3]->[4]->NULL  s: [1]->NULL h: [2]->[3]->[4]->[5]->NULL t: [5]->NULL v: NULL u: [4]->[5]->NULL  s: NULL h: [1]->[2]->[3]->[4]->[5]->NULL t: [1]->[2]->[3]->[4]->[5]->NULL v: [2]->[3]->[4]->[5]->NULL u: [4]->[5]->NULL  LIST : [1]->[2]->[3]->[4]->[5]->NULL  这题因为印刷排版和变量短名极不友好，我这里给你详细解析insert_sort函数里的逻辑。  首先传入一个NODE* h，加上临时指针 t s u v，这些指针既是链表的首元素，也可以是整个链表。  程序的19 20行 \ts = h->next; \th->next = NULL; 这两句，实际上把传入的h链表一分为二成为两个链表。 h作为一个有序链表，保留原来的第一个元素。s为无序链表。从第二个元素到最后，此时输出为： s: [2]->[4]->[5]->[1]->NULL h: [3]->NULL  往下走，24行 while (s != NULL) 这个循环的逻辑是遍历s里每一个NODE，比对h找到相应的位置插入。  25行 for (t = s, v = h; v != NULL && v->data < t->data; u = v, v = v->next) 书上有个分号，其实是空的，只执行for里的循环。 t指向s的第一个元素，这个指针不会移动。v指向h，会在比较大小的时候后移。 u在v移动时，会指向移动前的位置。换言之，u和v之间，要插入的位置。 至于插入哪一个，当然是t指向的那一个。  往下走，29行 if (v == h) 如果v指针没移动过，在h的头部插入t。 否则，在u和v之间插入t。  循环处理完s链表，s置空，h完成排序，返回。", "referer": "user-0"}]}
{"question": "使用fprintf函数录入文件无法空格和换行是怎么回事", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "好了，不要再猜了，可能性太多。 例如，如果他写入的是个.html文件，双击打开后本来就应该是这样子的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "写文件时，与你打开文件时的方式相关，FILE *fp = fopen(\"filename\",\"a\")： r 打开只读文件，该文件必须存在。 r+ 打开可读写的文件，该文件必须存在。 w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。 w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。 a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。 a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "https://blog.csdn.net/weixin_44586473/article/details/90482476?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161499563416780357220048%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161499563416780357220048&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-1-90482476.pc_search_result_no_baidu_js&utm_term=devc%2B%2B+%E4%BD%BF%E7%94%A8fprintf%E5%87%BD%E6%95%B0%E5%BD%95%E5%85%A5%E6%96%87%E4%BB%B6%E6%97%A0%E6%B3%95%E7%A9%BA%E6%A0%BC%E5%92%8C%E6%8D%A2%E8%A1%8C", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 5 楼 ㌀㍿936 的回复:[quote=引用 1 楼 user-3 的回复:]供参考：{     fprintf(fp,\"%s  %d\\n\",pMove->data.name,pMove->data.price);     pMove = pMove->next; } 我用的是dev c++ 与开发环境有没有关系？ [/quote]这段代码去试过了吗?和你用的dev c++与开发环境无关的。  参考：https://blog.csdn.net/shiroidea/article/details/113697496?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_utm_term-0&spm=1001.2101.3001.4242", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-3 的回复:供参考：{     fprintf(fp,\"%s  %d\\n\",pMove->data.name,pMove->data.price);     pMove = pMove->next; } 我用的是dev c++ 与开发环境有没有关系？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 user-3 的回复:供参考：{     fprintf(fp,\"%s  %d\\n\",pMove->data.name,pMove->data.price);     pMove = pMove->next; } 没用啊。。。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "fopen在哪？", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "供参考：{     fprintf(fp,\"%s  %d\\n\",pMove->data.name,pMove->data.price);     pMove = pMove->next; }", "referer": "user-0"}]}
{"question": "指针指地址时，比如int型指针，但内存单元是1个字节，那这个int指针指的地址是4个字节中的第一个嘛？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "如果你所谓“第一个”是指地址值最小的那个字节。那么你说对了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "可以这么理解，但是要注意大小端吧", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "始终要用4个字节，如果指向的类型是一个字节，则指向连续的四个字节，因此，可能导致程序运行不正确或者崩溃", "referer": "user-0"}]}
{"question": "求解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int i=0x12345678； //假定 &i的值为0x006FFC1C 在内存中按地址从小到大排列： 大端存储 0x006FFC1C：12 0x006FFC1D：34 0x006FFC1E：56 0x006FFC1F：78 小端存储 0x006FFC1C：78 0x006FFC1D：56 0x006FFC1E：34 0x006FFC1F：12", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int类型指针指向的是4字节（32位系统）的首地址，你的第一个是指第一个字节吧，可以这么理解。但是注意考虑大小端问题，第一个自己的位置可能不一样～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "int i = 1; \tint* pi = &i;   从上图可以看到，int的指针pi的值是0x6FFC1C，而这个地址中保存的是一个字节，即0x01", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "啥叫第一个？ 如果意思是地址值最小的那个，那么这个int指针指的地址是4个字节中的第一个。", "referer": "user-0"}]}
{"question": "储存文件后为什么会乱码？求大佬解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include<stdio.h> #include<string.h> #include<stdlib.h>  struct Telephone{       char   number[20];       char   name[20];       char   sex[20];       char   age[20];       char   speciaity[20];       char   Class[20];       struct Telephone *next; };  typedef struct Telephone TEL; TEL *head=NULL;  void showmenu(); //菜单 void Appenditem();//添加学生信息 void print();  //浏览所有学生信息 void Finditem1(); //查找学生信息 （按学号） void Finditem2(); //查找学生信息 （按姓名） void Removeitem();//删除学生信息 void Saveandfree();//保存到文件 void Open();//打开文件   int main(int argc, char* argv[]) {      char ch;      Open();   //打开文件      while(1){            showmenu(); //显示菜单            scanf(\" %c\",&ch);            switch(ch){                  case '1':Appenditem(); //添加学生信息                           break;                  case '2':print();      //浏览所有学生信息                           break;                  case '3':Finditem1();  //查找学生信息1.按学号                           break;                  case '4':Finditem2();  //查找学生信息2.按姓名                           break;                  case '5':Removeitem(); //删除学生信息信息                           print();      //输出删除后的结果                           break;                  case '0':Saveandfree();//保存并释放内存                           exit(0);      //退出系统                           break;                  default:                           printf(\"选择错误!\");                           break;            }      } }  //菜单 void showmenu() {      printf(\"\\n*****************欢迎使用学生信息管理系统*****************\\n\");      printf(\"\\n*****************根据主菜单提示选择所想要的操作*****************\\n\");      printf(\"\\t1.添加学生信息\\n\");      printf(\"\\t2.浏览所有学生信息\\n\");      printf(\"\\t3.按学号查询学生信息\\n\");      printf(\"\\t4.按姓名查询学生信息\\n\");      printf(\"\\t5.删除学生信息\\n\");      printf(\"\\t0.保存并退出系统！\\n\");      printf(\"*************************************************\\n\");      printf(\"\\t请选择：\\n\"); }  //添加学生信息 void Appenditem() {      TEL *p1=NULL,*p2=NULL;      p1=(TEL *)malloc(sizeof(TEL));//申请结点      printf(\"输入学号:\\n\");        //添加信息      scanf(\"%s\",p1->number);      printf(\"输入姓名：\\n\");      scanf(\"%s\",p1->name);      printf(\"输入性别：\\n\");      scanf(\"%s\",p1->sex);      printf(\"输入年龄：\\n\");      scanf(\"%s\",p1->age);      printf(\"输入专业：\\n\");      scanf(\"%s\",p1->speciaity);      printf(\"输入班级：\\n\");      scanf(\"%s\",p1->Class);      p1->next=NULL;               //保存到链表      if (head==NULL) {         head=(TEL *)malloc(sizeof(TEL));//申请空间         head->next=p1;      } else {         for (p2=head;p2->next!=NULL;p2=p2->next); //找到结点尾         p2->next=p1;      }      printf(\"此信息已添加！\"); }  //浏览所有学生信息 void print() {      TEL *p=NULL;      if (head==NULL){         printf(\"此学生信息管理系统中无记录，请输入记录后在使用本功能！\\n\");         return;      }      printf(\"**************学生信息管理系统*********************\\n\");      //输出信息  printf(\"学号\\t姓名\\t性别\\t年龄\\t专业\\t班级\\n\");      for(p=head->next;p!=NULL;p=p->next)          printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->number,p->name,p->sex,p->age,p->speciaity,p->Class); }  //查找学生信息1.按学号 void Finditem1() {      TEL *p;      char findname[20];      printf(\"请输入要查找的学号：\\n\");      scanf(\"%s\",findname);      printf(\"**************学生信息管理系统*********************\\n\");      printf(\"学号\\t姓名\\t性别\\t年龄\\t专业\\t班级\\n\");      for (p=head->next;p!=NULL;p=p->next) {          if(strcmp(p->number,findname)==0)             printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->number,p->name,p->sex,p->age,p->speciaity,p->Class);      } }  //查找学生信息2.按姓名 void Finditem2() {      TEL *p;      char name[20];      printf(\"请输入要查找的姓名：\\n\");      scanf(\"%s\",name);      printf(\"**************学生信息管理系统*********************\\n\");      printf(\"学号\\t姓名\\t性别\\t年龄\\t专业\\t班级\\n\");      for(p=head->next;p!=NULL;p=p->next) {         if(strcmp(p->name,name)==0)            printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->number,p->name,p->sex,p->age,p->speciaity,p->Class);      } }  //删除学生的信息 void Removeitem() {      char findname[20];            //先查找 后删除      TEL *p = head->next, *pr = head->next;      printf(\"请输入要删除的学号：\\n\");      scanf(\" %s\",&findname);      if (head->next == NULL){          printf(\"无此节点!\\n\");          return;      }      while ((strcmp(p->name,findname)!=0 )&& p->next != NULL){          pr =p;          p =p->next;      }      if (strcmp(findname, p->name)==0){ //输出删除信息          printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->next->number,p->next->name,p->next->sex,                                            p->next->age,p->speciaity,p->Class);          if (p == head->next)              head->next = p->next;          else              pr->next = p->next;          free(p);      }      printf(\"此信息已删除！\"); }  //保存链表信息到文件并释放内存空间 void Saveandfree() {      TEL  *p=NULL;      FILE *fp;      char *Book=\"books.txt\";      if (head==NULL){          printf(\"\\n记录为空！\\n\");          return;      }      else p=head->next;      if ((fp=fopen(Book,\"wb+\"))==NULL){          printf(\"\\n打不开文件!\\n\");          return;      }      while (p!=NULL){                     //保存信息            //fwrite(p,sizeof(TEL),1,fp); //这个写法是把结构体第7项 p->Telephone *next;也写入文件了，                                          //所谓的乱码就是这部分的内容。            fprintf(fp,\"%s %s %s %s %s %s \",p->number,p->name,p->sex,p->age,p->speciaity,p->Class);            p=p->next;      }      printf(\"保存完毕!\");      fclose(fp);      //*****释放链表空间*****      for(;head->next!=NULL;){          p=head->next;          head->next=head->next->next;          free(p);      }      free(head); }  //文件信息输出到链表 void Open() {      FILE *fp;      TEL  *p1=NULL,*p2=NULL,*temp=NULL;      if ((fp=fopen(\"books.txt\",\"rb+\"))==NULL){         printf(\"\\n****************这是一个新的学生信息管理系统******************\\n\");         return;      }      head=(TEL *)malloc(sizeof(TEL));      head->next=NULL;      temp=p2=head;      while (! feof(fp)){         //循环读取            p1=(TEL *)malloc(sizeof(TEL));            temp=p2;            p2->next=p1;            p2=p1;            //fread(p1,sizeof(TEL),1,fp); //对应的读入文件的方法也不一样            fscanf(fp,\"%s %s %s %s %s %s\",p1->number,p1->name,p1->sex,p1->age,p1->speciaity,p1->Class);      }      temp->next=NULL;      fclose(fp);               //关闭文件 }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "是不是因为保存的字符串没有使用 null-terminated string 的原因，试试在每个要保存的字符串后加个'\\n'。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include<stdio.h> #include<string.h> #include<stdlib.h>  struct Telephone{      char number[20];      char name[20];      char sex[20];      char age[20];      char speciaity[20];      char Class[20];           struct Telephone *next; };  typedef struct Telephone TEL;  TEL *head=NULL;  void showmenu();                  //菜单 void Appenditem();                //添加学生信息 void print();                     //浏览所有学生信息 void Finditem1();                 //查找学生信息 （按学号） void Finditem2();                 //查找学生信息 （按姓名） void Removeitem();                //删除学生信息     void Saveandfree();               //保存到文件 void Open();                      //打开文件 void main() {      char ch;      Open();                       //打开文件      while(1) {           showmenu();               //显示菜单           scanf(\" %c\",&ch);           switch(ch)  {               case '1':                 Appenditem();    //添加学生信息                    break;               case '2':                 print();         //浏览所有学生信息                    break;               case '3':                 Finditem1();     //查找学生信息1.按学号                    break;               case '4':                 Finditem2();     //查找学生信息2.按姓名                    break;               case '5':                 Removeitem();    //删除学生信息信息                    print();         //输出删除后的结果                    break;               case '0':                 Saveandfree();   //保存并释放内存                    exit(0);         //退出系统                    break;               default:                    printf(\"选择错误!\");                    break;           }      } }  //菜单 void showmenu() {      printf(\"\\n*****************欢迎使用学生信息管理系统*****************\\n\");      printf(\"\\n*****************根据主菜单提示选择所想要的操作*****************\\n\");       printf(\"\\t1.添加学生信息\\n\");       printf(\"\\t2.浏览所有学生信息\\n\");       printf(\"\\t3.按学号查询学生信息\\n\");       printf(\"\\t4.按姓名查询学生信息\\n\");       printf(\"\\t5.删除学生信息\\n\");       printf(\"\\t0.保存并退出系统！\\n\"); printf(\"*************************************************\\n\");      printf(\"\\t请选择：\\n\"); }      //添加学生信息 void Appenditem() {      TEL *p1=NULL,*p2=NULL;           p1=(TEL *)malloc(sizeof(TEL));                     //申请结点      printf(\"输入学号:\\n\");                             //添加信息      scanf(\"%s\",p1->number);      printf(\"输入姓名：\\n\");      scanf(\"%s\",p1->name);      printf(\"输入性别：\\n\");      canf(\"%s\",p1->sex);      printf(\"输入年龄：\\n\");      scanf(\"%s\",p1->age);      printf(\"输入专业：\\n\");      scanf(\"%s\",p1->speciaity);      printf(\"输入班级：\\n\");      scanf(\"%s\",p1->Class);      p1->next=NULL;                                     //保存到链表           if(head==NULL) {           head=(TEL *)malloc(sizeof(TEL));               //申请空间           head->next=p1;      } else {           for(p2=head;p2->next!=NULL;p2=p2->next);       //找到结点尾           p2->next=p1;      }      printf(\"此信息已添加！\"); }  //浏览所有学生信息 void print() {      TEL *p=NULL;      if(head==NULL) {           printf(\"此学生信息管理系统中无记录，请输入记录后在使用本功能！\\n\");           return;      }      printf(\"**************学生信息管理系统*********************\\n\"); //输出信息       printf(\"学号\\t姓名\\t性别\\t年龄\\t专业\\t班级\\n\");      for(p=head->next;p!=NULL;p=p->next)           printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->number,p->name,p->sex,p->age,p->speciaity,p->Class);   }       //查找学生信息1.按学号 void Finditem1() {      TEL *p;      char findname[20];           printf(\"请输入要查找的学号：\\n\");      scanf(\"%s\",findname);      printf(\"**************学生信息管理系统*********************\\n\");        printf(\"学号\\t姓名\\t性别\\t年龄\\t专业\\t班级\\n\");             for(p=head->next;p!=NULL;p=p->next) {            if(strcmp(p->number,findname)==0)                printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->number,p->name,p->sex,p->age,p->speciaity,p->Class);        } }  //查找学生信息2.按姓名 void Finditem2() {      TEL *p;      char name[20];      printf(\"请输入要查找的姓名：\\n\");      scanf(\"%s\",name);      printf(\"**************学生信息管理系统*********************\\n\");        printf(\"学号\\t姓名\\t性别\\t年龄\\t专业\\t班级\\n\");      for(p=head->next;p!=NULL;p=p->next) {           if(strcmp(p->name,name)==0)               printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->number,p->name,p->sex,p->age,p->speciaity,p->Class);       } }       //删除学生的信息 void Removeitem() {      char findname[20];                                     //先查找 后删除      TEL *p = head->next, *pr = head->next;           printf(\"请输入要删除的学号：\\n\");      scanf(\" %s\",&findname);       if (head->next == NULL) {            printf(\"无此节点!\\n\");            return;       }            while ((strcmp(p->name,findname)!=0 )&& p->next != NULL)   {             pr =p;             p =p->next;        }       if (strcmp(findname, p->name)==0)                    //输出删除信息        {              printf(\"%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n\",p->next->number,p->next->name,\\                   p->next->sex,p->next->age,p->speciaity,p->Class);               if (p == head->next)                         head->next = p->next;               else                   pr->next = p->next;                            free(p);              }        printf(\"此信息已删除！\");   }  //保存链表信息到文件并释放内存空间 void Saveandfree() {      TEL *p=NULL;      FILE *fp;      char *Book=\"books.txt\";      if(head==NULL) {           printf(\"\\n记录为空！\\n\");           return;      }      else           p=head->next;                if((fp=fopen(Book,\"wb+\"))==NULL)   {             printf(\"\\n打不开文件!\\n\");             return;        }            while(p!=NULL)                              //保存信息        {             fwrite(p,sizeof(TEL),1,fp);             p=p->next;        }            printf(\"保存完毕!\");       fclose(fp);     //*****释放链表空间*****       for(;head->next!=NULL;)  {            p=head->next;            head->next=head->next->next;             free(p);       }       free(head); }  //文件信息输出到链表 void Open() {      FILE *fp;      TEL *p1=NULL,*p2=NULL,*temp=NULL;           if((fp=fopen(\"books.txt\",\"rb+\"))==NULL)  {            printf(\"\\n****************这是一个新的学生信息管理系统******************\\n\");            return;       }           head=(TEL *)malloc(sizeof(TEL));      head->next=NULL;      temp=p2=head;           while(! feof(fp))                            //循环读取       {            p1=(TEL *)malloc(sizeof(TEL));            temp=p2;            p2->next=p1;            p2=p1;            fread(p1,sizeof(TEL),1,fp);       }           temp->next=NULL;      fclose(fp);                                   //关闭文件 }", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "为什么都喜欢这么发代码呢？自己看着代码好看懂逻辑吗？～", "referer": "user-0"}]}
{"question": "用51单片机来显示555计时器组成的多谐振荡器的频率。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "查查计时器频率设置", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": ".........................................................", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "标准做法，用T0计时，时间到了就去数一下T1的脉冲计数嘛。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "引用 14 楼 user-6 的回复:NE555 的输出3Q 接的是 P3.5 T1（计时器1外部输入），可是程序貌似怎么操作T0呢？这个没错，T1对555的方波计数，然后利用T0中断将计数值输出，然后置位重新开始。问题应该12#所说为正解。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "NE555 的输出3Q 接的是 P3.5 T1（计时器1外部输入），可是程序貌似怎么操作T0呢？", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "中断函数修改，供参考：void timer0 () interrupt 1 {      TR0 = 0;      TR1 = 0;      TH0 = (65535-45872)/256;      TL0 = (65535-45872)%256;      bb  = TH1;      cc  = TL1;      TL1 = 0;      TH1 = 0;      TR0 = 1;      TR1 = 1; }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 10 楼 qzjhjxj的回复:protues仿真软件里，单片机、晶振的工作频率都和代码里写的一样不，要设置一致才准确。 初始值和中断那里都改了，proteus里单片机的晶振频率是12mhz,可还是不行。", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "protues仿真软件里，单片机、晶振的工作频率都和代码里写的一样不，要设置一致才准确。", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "这里的初始值和中断函数里的都一起改了吗？", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "还是不行，没有变化", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复:中断函数修改，供参考：void timer0 () interrupt 1 {      TR0 = 0;      TR1 = 0;      TH0 = (65535-45872)/256;      TL0 = (65535-45872)%256;      bb  = TH1;      cc  = TL1;      TL1 = 0;      TH1 = 0;      TR0 = 1;      TR1 = 1; } 好的，我试试，谢谢。", "referer": "user-0"}, {"cid": "13", "user": "user-4", "content": "换上pF级电容才能这么玩。", "referer": "user-0"}, {"cid": "14", "user": "user-4", "content": "一不留神就忽略了数量级。 你的电阻电容搞辣么大，频率搞得太低了。 不要忘了你只数了50毫秒脉冲然后乘了20来的。 一个9Hz的信号源你指望它在50毫秒内数到什么？ 数到什么都算误差。", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:定时器计算机器周期晶振如是:11.0592MHz，那么机器周期为12*(1/11059200)=1.09μm。若T=50ms那么N=50000/1.09=45872.代码里中断初值TH0和TL0的值是否准确？第43行TR1=0;//中断使能 ，这行是否要移到第41行前面。 移到41行前还是不行。", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "TMOD=0x51;定时器T0工作在定时50ms模式，50ms中断一次，执行中断函数里的语句。T1工作在计数模式,TH1存放由555产生的方波数高8位，TL1存放方波数的低8位，然后到中断里将值传给bb 和cc 。TR1=1，启动计数器T1工作，TR1=0，计数器T1停止工作。", "referer": "user-0"}, {"cid": "17", "user": "user-5", "content": "定时器计算机器周期晶振如是:11.0592MHz，那么机器周期为12*(1/11059200)=1.09μm。若T=50ms那么N=50000/1.09=45872.代码里中断初值TH0和TL0的值是否准确？第43行TR1=0;//中断使能 ，这行是否要移到第41行前面。", "referer": "user-0"}, {"cid": "18", "user": "user-0", "content": "引用 1 楼 forever74的回复:39行应该是interrupt 0吧？ 改成interrupt 0就都显示F000了", "referer": "user-0"}, {"cid": "19", "user": "user-4", "content": "39行应该是interrupt 0吧？", "referer": "user-0"}]}
{"question": "大佬赶紧进来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这是伪代码，什么编译器也编译不过去", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "编译器不能看出来吧，C语言的编译器可以用C的，也可以用C++的。 具体是那种软件更看不出来了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "我就说大学学编程应该先教 编译器/IDE以及开发环境搭建 吧，就应该去社会找在职工程师来讲课 你这个代码，一看就是C代码...", "referer": "user-0"}]}
{"question": "如何用for循环删除字符串后面星星", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "贴出你的代码～找到星星，直接用'\\0'覆盖，如果后面的非星星继续要，则后面的往前覆盖～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <string.h> int main() {     char s[]=\"abc*d**\";     int i,L;     L=strlen(s);     for (i=L-1;i>=0;i--) {         if (s[i]=='*') s[i]=0;         else break;     }     printf(\"s:[%s]\\n\",s);//s:[abc*d]     return 0; }", "referer": "user-0"}]}
{"question": "那个大佬给看一下，哪里不对了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "补充修正错误：#include<stdio.h> #include<string.h> #include<math.h> #define MAX 1000  typedef struct man{    char name[10];    char sex[10];     int age;    //少了年龄     int plone_Num;     int add_Num;     int bangong_Num;     int E_mail; //E_mail;更适合用字符数组 }list;  typedef struct men{     //struct man list[MAX];       list list[MAX];       int  count; }men; //struct men book; men book;  int find(men *p, char*name) {     int i = 0;     for (; i <= (p->count); i++)         {            if (strcmp(p->list[i].name, name) == 0)                {                  return i;                }         }     return -1; }  void main() {     void a(men *p);     void b(men *p);     void c(men *p);     void d(men *p);     void e(men *p);     void f(men *p);     book.count=0;     int  n=1;     while(n!=7){           printf(\"\\n-----------菜单-----------\\n\");           printf(\"****************************\\n\");           printf(\"1：----------添加-----------\\n\");           printf(\"2：----------删除-----------\\n\");           printf(\"3：----------查询-----------\\n\");           printf(\"4：----------修改-----------\\n\");           printf(\"5：----------显示.txt-------\\n\");           printf(\"6：----------清空-----------\\n\");           printf(\"7：--------退出系统---------\\n\");           printf(\"输入选项代码:\");           fflush(stdout);           rewind(stdin);           scanf(\"%d\",&n);           switch(n){                    case 1:a(&book);break;                    case 2:b(&book);break;                    case 3:c(&book);break;                    case 4:d(&book);break;                    case 5:e(&book);break;                    case 6:f(&book);break;                    case 7:printf(\"\\n*******************谢谢使用！*******************\\n\");                           break;                           //break;           }           //getchar();     }      }  void a(men *p)  //添加 {     if ((p->count) > MAX)        {          printf(\"通讯录已满！！！\");        }     else{          printf(\"姓名 性别 年龄 手机 住宅电话 办公电话 E_mail\\n\");          scanf(\"%s %s %d %d %d %d %d\", p->list[p->count].name, p->list[p->count].sex,&p->list[p->count].age,                                    &p->list[p->count].plone_Num,&p->list[p->count].add_Num,                                    &p->list[p->count].bangong_Num,&p->list[p->count].E_mail);     }     p->count++;     //book.count = 0; }  void b(men *p)   //删除 {     char name[10] = { 0 };     int  ret;     printf(\"请输入要删除的联系人：\");     fflush(stdout);     rewind(stdin);     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1)        {          printf(\"该联系人不存在！！！\");        }     else { int j = ret;         for (; j < p->count; j++)             {               p->list[j] = p->list[j + 1];             }         printf(\"已删除！！！\\n\");     }     p->count--;     //book.count = 0; }  void c(men *p) //查找 {     char name[10] = { 0 };      int ret;     printf(\"请输入要查询的联系人：\");     fflush(stdout);     rewind(stdin);     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1)        {          printf(\"该联系人不存在！！！\\n\");        }     else {          printf(\"姓名：%s\\n\", p->list[ret].name);          printf(\"性别：%s\\n\", p->list[ret].sex);          printf(\"年龄：%d\\n\", p->list[ret].age);          printf(\"电话：%d\\n\", p->list[ret].plone_Num);          printf(\"住宅电话：%d\\n\", p->list[ret].add_Num);          printf(\"工作电话：%d\\n\", p->list[ret].bangong_Num);          printf(\"E-mail：%d\\n\", p->list[ret].E_mail);     }    //book.count = 0; }  void d(men *p)  //修改 {     char name[10] = { 0 };     int  ret;     printf(\"请输入要修改的联系人：\");     fflush(stdout);     rewind(stdin);     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1)        {          printf(\"该联系人不存在！！！\\n\");        }     else {          printf(\"姓名 性别 年龄 手机 住宅电话 办公电话 E_mail\\n\");          scanf(\"%s %s %d %d %d %d %d\",p->list[ret].name, p->list[ret].sex,&p->list[ret].age,                                    &p->list[ret].plone_Num,&p->list[ret].add_Num,                                    &p->list[ret].bangong_Num,&p->list[ret].E_mail);     }    //book.count = 0; }  void e(men *p) //显示 {     int i = 0;     for (; i < p->count; i++)         {           printf(\"姓名：%s\\n\", p->list[i].name);           printf(\"性别：%s\\n\", p->list[i].sex);           printf(\"年龄：%d\\n\", p->list[i].age);           printf(\"电话：%d\\n\", p->list[i].plone_Num);           printf(\"住宅电话：%d\\n\", p->list[i].add_Num);           printf(\"工作电话：%d\\n\", p->list[i].bangong_Num);           printf(\"E-mail：%d\\n\", p->list[i].E_mail);         }     //book.count = 0; }  void f(men *p)  //清空 {     p->count = 0;     //book.count = 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "修正楼上，第132行和133行间插入一行：printf(\"年龄：%d\\n\", p->list[ret].age); 第169行和170行间插入一行：printf(\"年龄：%d\\n\", p->list[i].age);", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "实现功能，供参考：#include<stdio.h> #include<string.h> #include<math.h> #define MAX 1000  typedef struct man{    char name[10];    char sex[10];     int age;    //少了年龄     int plone_Num;     int add_Num;     int bangong_Num;     int E_mail; //E_mail更适合用字符型数组 }list;  typedef struct men{     //struct man list[MAX];       list list[MAX];       int  count; }men; //struct men book; men book;  int find(men *p, char*name) {     int i = 0;     for (; i <= (p->count); i++)         {            if (strcmp(p->list[i].name, name) == 0)                {                  return i;                }         }     return -1; }  void main() {     void a(men *p);     void b(men *p);     void c(men *p);     void d(men *p);     void e(men *p);     void f(men *p);     book.count=0;     int  n=1;     while(n!=7){           printf(\"\\n-----------菜单-----------\\n\");           printf(\"****************************\\n\");           printf(\"1：----------添加-----------\\n\");           printf(\"2：----------删除-----------\\n\");           printf(\"3：----------查询-----------\\n\");           printf(\"4：----------修改-----------\\n\");           printf(\"5：----------显示.txt-------\\n\");           printf(\"6：----------清空-----------\\n\");           printf(\"7：--------退出系统---------\\n\");           printf(\"输入选项代码:\");           fflush(stdin);           rewind(stdout);           scanf(\"%d\",&n);           switch(n){                    case 1:a(&book);break;                    case 2:b(&book);break;                    case 3:c(&book);break;                    case 4:d(&book);break;                    case 5:e(&book);break;                    case 6:f(&book);break;                    case 7:printf(\"\\n*******************谢谢使用！*******************\\n\");                           break;                           //break;           }           //getchar();     }      }  void a(men *p)  //添加 {     if ((p->count) > MAX)        {          printf(\"通讯录已满！！！\");        }     else{          printf(\"姓名 性别 年龄 手机 住宅电话 办公电话 E_mail\\n\");          scanf(\"%s %s %d %d %d %d %d\", p->list[p->count].name, p->list[p->count].sex,&p->list[p->count].age,                                    &p->list[p->count].plone_Num,&p->list[p->count].add_Num,                                    &p->list[p->count].bangong_Num,&p->list[p->count].E_mail);     }     p->count++;     //book.count = 0; }  void b(men *p)   //删除 {     char name[10] = { 0 };     int  ret;     printf(\"请输入要删除的联系人：\");     fflush(stdin);     rewind(stdout);     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1)        {          printf(\"该联系人不存在！！！\");        }     else { int j = ret;         for (; j < p->count; j++)             {               p->list[j] = p->list[j + 1];             }         printf(\"已删除！！！\\n\");     }     p->count--;     //book.count = 0; }  void c(men *p) //查找 {     char name[10] = { 0 };      int ret;     printf(\"请输入要查询的联系人：\");     fflush(stdin);     rewind(stdout);     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1)        {          printf(\"该联系人不存在！！！\\n\");        }     else {          printf(\"姓名：%s\\n\", p->list[ret].name);          printf(\"性别：%s\\n\", p->list[ret].sex);          printf(\"电话：%d\\n\", p->list[ret].plone_Num);          printf(\"住宅电话：%d\\n\", p->list[ret].add_Num);          printf(\"工作电话：%d\\n\", p->list[ret].bangong_Num);          printf(\"E-mail：%d\\n\", p->list[ret].E_mail);     }    //book.count = 0; }  void d(men *p)  //修改 {     char name[10] = { 0 };     int  ret;     printf(\"请输入要修改的联系人：\");     fflush(stdin);     rewind(stdout);     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1)        {          printf(\"该联系人不存在！！！\\n\");        }     else {          printf(\"姓名 性别 年龄 手机 住宅电话 办公电话 E_mail\\n\");          scanf(\"%s %s %d %d %d %d %d\",p->list[ret].name, p->list[ret].sex,&p->list[ret].age,                                    &p->list[ret].plone_Num,&p->list[ret].add_Num,                                    &p->list[ret].bangong_Num,&p->list[ret].E_mail);     }    //book.count = 0; }  void e(men *p) //显示 {     int i = 0;     for (; i < p->count; i++)         {           printf(\"姓名：%s\\n\", p->list[i].name);           printf(\"性别：%s\\n\", p->list[i].sex);           printf(\"电话：%d\\n\", p->list[i].plone_Num);           printf(\"住宅电话：%d\\n\", p->list[i].add_Num);           printf(\"工作电话：%d\\n\", p->list[i].bangong_Num);           printf(\"E-mail：%d\\n\", p->list[i].E_mail);         }     //book.count = 0; }  void f(men *p)  //清空 {     p->count = 0;     //book.count = 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "仅帮整理格式和消除编译错误： #include<stdio.h> #include<string.h> #include<math.h> #define MAX 1000 typedef struct man {     char name[10];     char sex[10];     int plone_Num;     int add_Num;     int bangong_Num;     int   E_mail; } list; typedef struct men {     struct man list[MAX];     int count; } men; void a(men *p); void b(men *p); void c(men *p); void d(men *p); void e(men *p); void e(men *p); struct men book; int find(men *p, char*name)  {     int i = 0;     for (;i <= (p->count);i++) {         if (strcmp(p->list[i].name, name) == 0) {             return i;         }     }     return -1; } int main() {     int n=0;     while(n!=7) {         printf(\"\\t-----------菜单-----------\\n\");         printf(\"****************************\\n\");         printf(\"1：----------添加-----------\\n\");         printf(\"2：----------删除-----------\\n\");         printf(\"3：----------查询-----------\\n\");         printf(\"4：----------修改-----------\\n\");         printf(\"5：----------显示.txt-------\\n\");         printf(\"6：----------清空-----------\\n\");         printf(\"7：--------退出系统---------\\n\");         printf(\"输入选项代码:\");         scanf(\"%d\",&n);         switch(n) {         case 1:a(&book);             break;         case 2:b(&book);             break;         case 3:c(&book);             break;         case 4:d(&book);             break;         case 5:e(&book);             break;         case 6:e(&book);             break;         case 7:printf(\"\\n*******************谢谢使用！*******************\\n\");             break;             break;         }     }     getchar();     return 0; } void a(men *p)  //添加 {     if ((p->count) > MAX) {         printf(\"通讯录已满！！！\");     } else {         printf(\"姓名 性别 年龄 手机 住宅电话 办公电话 E_mail\\n\");         scanf(\"%s %s %d %d %d %d\",             p->list[p->count].name,             p->list[p->count].sex,            &p->list[p->count].plone_Num,            &p->list[p->count].add_Num,            &p->list[p->count].bangong_Num,            &p->list[p->count].E_mail);     }     p->count++;     book.count = 0; } void b(men *p)   //删除 {     char name[10] = {                         0 }                     ;     int ret;     printf(\"请输入要删除的联系人：\");     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1) {         printf(\"该联系人不存在！！！\");     } else {         int j = ret;         for (;j < p->count;j++) {             p->list[j] = p->list[j + 1];         }         printf(\"已删除！！！\\n\");     }     p->count--;     book.count = 0; } void c(men *p) //查找 {     char name[10] = {                         0 }                     ;     int ret;     printf(\"请输入要查询的联系人：\");     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1) {         printf(\"该联系人不存在！！！\\n\");     } else {         printf(\"姓名：%s\\n\", p->list[ret].name);         printf(\"性别：%s\\n\", p->list[ret].sex);         printf(\"电话：%d\\n\", p->list[ret].plone_Num);         printf(\"住宅电话：%d\\n\", p->list[ret].add_Num);         printf(\"工作电话：%d\\n\", p->list[ret].bangong_Num);         printf(\"E-mail：%d\\n\", p->list[ret].E_mail);     }     book.count = 0; } void d(men *p)  //修改 {     char name[10] = {                         0 }                     ;     int ret;     printf(\"请输入要修改的联系人：\");     scanf(\"%s\", &name);     ret = find(p, name);     if (ret == -1) {         printf(\"该联系人不存在！！！\\n\");     } else {         printf(\"姓名 性别 年龄 手机 住宅电话 办公电话 E_mail\\n\");         scanf(\"%s %s %d %d %d %d\",             p->list[ret].name,             p->list[ret].sex,            &p->list[ret].plone_Num,            &p->list[ret].add_Num,            &p->list[ret].bangong_Num,            &p->list[ret].E_mail);     }     book.count = 0; } void e(men *p) //显示 {     int i = 0;     for (;i < p->count;i++) {         printf(\"姓名：%s\\n\", p->list[i].name);         printf(\"性别：%s\\n\", p->list[i].sex);         printf(\"电话：%d\\n\", p->list[i].plone_Num);         printf(\"住宅电话：%d\\n\", p->list[i].add_Num);         printf(\"工作电话：%d\\n\", p->list[i].bangong_Num);         printf(\"E-mail：%d\\n\", p->list[i].E_mail);     }     book.count = 0; } void f(men *p)  //清空 {     p->count = 0;     book.count = 0; }", "referer": "user-0"}]}
{"question": "子函数循环问题(KMP算法)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:原因见注释，供参考：#include <stdio.h> #include <string.h> #include <math.h> void getnext(char t[],int next[]) {     int j,k;     j=0;     k=-1;     next[0] = -1;     int d=strlen(t);//这里转换为有符号数     while(j < d-1){          if (k == -1||t[j] == t[k]){              j++;              k++;              next[j]=k;          }          else{             k=next[k];          }     } }  void KMPIndex(char t[],char s[],int next[]) {     int i,j;     i=0,j=0;     while(i<(int)(strlen(s)) && j<(int)(strlen(t))){ //问题所在                                     //strlen返回的是一个无符号整形数，不能和有符号数直接做运算比较          if(j == -1 || s[i]==t[j]){            i++;            j++;          }          else{            j=next[j];          }     }     if(j>=(int)strlen(t)){        printf(\"%d\",i-(int)strlen(t));     }     else printf(\"ERROR\"); }  int main() {     char t[101],s[1001];     int next[100];     scanf(\"%s %s\",s,t);     getnext(t,next);     KMPIndex(t,s,next);          return 0; } 感谢解答，这点困扰了我一天了啊。我刚刚查了一下，不是说无符号数没法和这个数进行比较，而是说无符号数和有符号数进行比较时，会默认转成无符号数，再进行比较。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "原因见注释，供参考：#include <stdio.h> #include <string.h> #include <math.h> void getnext(char t[],int next[]) {     int j,k;     j=0;     k=-1;     next[0] = -1;     int d=strlen(t);//这里转换为有符号数     while(j < d-1){          if (k == -1||t[j] == t[k]){              j++;              k++;              next[j]=k;          }          else{             k=next[k];          }     } }  void KMPIndex(char t[],char s[],int next[]) {     int i,j;     i=0,j=0;     while(i<(int)(strlen(s)) && j<(int)(strlen(t))){ //问题所在                                     //strlen返回的是一个无符号整形数，不能和有符号数直接做运算比较          if(j == -1 || s[i]==t[j]){            i++;            j++;          }          else{            j=next[j];          }     }     if(j>=(int)strlen(t)){        printf(\"%d\",i-(int)strlen(t));     }     else printf(\"ERROR\"); }  int main() {     char t[101],s[1001];     int next[100];     scanf(\"%s %s\",s,t);     getnext(t,next);     KMPIndex(t,s,next);          return 0; }", "referer": "user-0"}]}
{"question": "乱码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 互联网并非法外之地 的回复:引用 2 楼 赵4老师 的回复：static char w_content[64];可以说一下原理么 加static让w_content保存在全局数据区而非堆栈中。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 sevancheng 的回复：char w_content[64]; 是栈上的内存，  注释的部分是再堆上分配的内存，注意，你的内存没释放哦释放的话是释放调用后的那个char*吗，还是怎么释放", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复：static char w_content[64];可以说一下原理么", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "static char w_content[64];", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "char w_content[64]; 是栈上的内存，  注释的部分是再堆上分配的内存，注意，你的内存没释放哦", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "w_content是局部变量，返回局部变量的操作是未定义的。局部变量的作用域是其所在的函数，从定义开始到函数调用结束而结束，这是其生命周期。 因此，加static是改变其生命周期，让其声明周期变成程序结束而结束（从定义开始）；用堆上的空间，理由是其空间有用户（写代码的人）自己申请，自己决定什么时候释放，即生命周期是灵活的，但是如果程序退出，堆上的空间会被系统回收，释放。", "referer": "user-0"}]}
{"question": "C语言播放音频错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#pragma comment(lib,\"winmm.lib\") #include <stdio.h> #include <stdlib.h> #include <windows.h> #include <mmsystem.h> //首页 void firstpage() {     printf(\"欢迎进入贪吃蛇\\n\");     printf(\"w a s d 控制贪吃蛇移动方向\\n\");     printf(\"空格键进入游戏\\n\"); } //音乐 void myplaysound() {     PlaySound(\"D:\\\\邓紫棋 - 喜欢你\",NULL,SND_FILENAME|SND_ASYNC); }  int main() {     firstpage();     myplaysound();     system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": "求大佬给改一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h> #include<malloc.h> #define _CRT_SECURE_NO_WARNINGS struct commodity {     int num;     char name[20];     char price[3];     int storage; }; struct Node {     //int data;     struct commodity data;     struct Node* next; } Node; struct Node* list; struct Node* createlist() {     struct Node* headNode=(struct Node*)malloc(sizeof(struct Node));     headNode->next =NULL;     return headNode; } //创造节点 struct Node* createNode(struct commodity data) {     struct Node* newNode=(struct Node*)malloc(sizeof(struct Node));     newNode->data =data;     newNode->next =NULL;     return newNode; } //插入 void insertNodeByHead(struct Node* headNode, struct commodity data) {     struct Node* newNode = createNode(data);     newNode->next = headNode->next;     headNode->next = newNode; } //查找 struct Node*findByName(struct Node* headNode, char * name) {     struct Node* pMove = headNode->next;     while (pMove) {         if (!strcmp(pMove->data.name,name)) {             return pMove;         }         //没有往下走pMove = pMove->next;     }     return NULL; } //删除 void deleteNodeByName(struct Node* headNode, char * name) {     //找到指定位置那个结点，以及制定位置前面那个结点//要有两个相邻的指针     struct Node* p = headNode;     struct Node* q = headNode->next;     if (q == NULL) {         printf(\"么有(没有)可用信息,无法删除 \");     } else {         while (strcmp(q->data.name,name)) {             p = q;             q = p->next;             if (q == NULL) {                 printf(\"未找到制定位置，无法删除 \");                 return;             }         }         p->next = q->next;         free(q);     } } //删除 void deleteNodeByNum(struct Node* headNode, int num) {     //找到指定位置那个结点，以及制定位置前面那个结点//要有两个相邻的指针     struct Node* p = headNode;     struct Node* q = headNode->next;     if (q == NULL) {         printf(\"么有(没有)可用信息,无法删除 \");     } else {         while (q->data.num!=num) {             p = q;             q = p->next;             if (q == NULL) {                 printf(\"未找到制定位置，无法删除 \");                 return;             }         }         p->next = q->next;         free(q);     } } //打印 void printList(struct Node*headNode) {     struct Node* pMove = headNode->next;     printf(\"商品代码 商品名称 商品单价 商品库存量\");     while (pMove) {         printf(\"%d %s %s %d \", pMove->data.num, pMove->data.name, pMove->data.price, pMove->data.storage);         pMove = pMove->next;     }     printf(\" \"); } void menu() {     printf(\" \");     printf(\" 0.退出系统 \");     printf(\" 1.录入信息 \");     printf(\" 2.显示信息 \");     printf(\" 3.删除信息 \");     printf(\" 4.查找信息 \");     printf(\" 5.保存到文件 \"); } void menuOfDelete() {     printf(\" 1.按照商品名称删除 \");     printf(\" 2.按照商品代码删除 \"); } void keyDownOfDelete() {     int choice;     char name[20];     int num;     scanf(\"%d\", &choice);     switch (choice) {     case 1://1.按照商品名称删除         printf(\"请输入要删除的商品名称:\");         scanf(\"%s\", name);         deleteNodeByName(list, name);         break;     case 2://2.按照商品代码删除         printf(\"请输入要删除的商品代码:\");         scanf(\"%d\", &num);         deleteNodeByNum(list, num);         break;     default:printf(\"输入错误,无法删除 \");     } } //保存到文件 void saveInfoToFile(struct Node* list, char *filePath, char *mode) {     struct Node* pMove = list->next;     FILE *fp =fopen(filePath, mode);     while (pMove) {         fprintf(fp, \"%d %s %s %d \", pMove->data.num, pMove->data.name, pMove->data.price, pMove->data.storage);         pMove = pMove->next;     }     fclose(fp); } //读文件 void readInfoFromFile(struct Node* list, char *filePath, char *mode) {     struct commodity data;     FILE *fp =fopen(filePath, mode);     while (fscanf(fp, \"%d %s %s %d \", &data.num, data.name, data.price, &data.storage) !=EOF) {         insertNodeByHead(list, data);     }     fclose(fp); } //交互 void keyDown() {     int choice;     struct commodity comInfo;     char temp= ' ';     choice=getchar();     switch (choice) {     case 0:         system(\"pause\");         exit(0);         break;     case 1://1.录入信息         while (1) {             printf(\"请输入商品代号，商品名称，商品价格，商品库存量：\");             fflush(stdin);             scanf(\"%d%s%s%d\", &comInfo.num, comInfo.name, comInfo.price, &comInfo.storage);             //链表的插入             insertNodeByHead(list, comInfo);             printf(\"是否继续？(N)\");             fflush(stdin);             temp = getchar();             if (temp == 'N' ||temp== 'n')break;         }         break;     case 2://2.显示信息         printList(list);         break;     case 3://3.删除信息         menuOfDelete();         keyDownOfDelete();         break;     case 4://4.查找信息         printf(\"请输入要查找的商品名称：\");         scanf(\"%s\", comInfo.name);         if (findByName(list, comInfo.name) != NULL) {             printf(\"%d %s %s %d \", findByName(list, comInfo.name)->data.num,findByName(list, comInfo.name)->data.name, findByName(list, comInfo.name)->data.price,findByName(list, comInfo.name)->data.storage);         } else {             printf(\"未找到相关信息! \");         }         break;     case 5://5.保存到文件         saveInfoToFile(list,\"1.txt\", \"w\");         break;     default:         printf(\"输入错误,重新输入 \");         break;     } } int main() {     list=createlist();     readInfoFromFile(list, \"1.txt\", \"r\");     while (1) {         menu();         keyDown();         system(\"pause\");         system(\"cls\");     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "先把代码格式弄好吧，你这养的代码风格很独特，你自己就这么写代码的吗？", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "加油奥利给👙👙", "referer": "user-0"}]}
{"question": "求大佬给改改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h> #include<malloc.h> #define _CRT_SECURE_NO_WARNINGS struct commodity {     int num;     char name[20];     char price[3];     int storage; }; struct Node {     //int data;     struct commodity data;     struct Node* next; } Node; struct Node* list; struct Node* createlist() {     struct Node* headNode=(struct Node*)malloc(sizeof(struct Node));     headNode->next =NULL;     return headNode; } //创造节点 struct Node* createNode(struct commodity data) {     struct Node* newNode=(struct Node*)malloc(sizeof(struct Node));     newNode->data =data;     newNode->next =NULL;     return newNode; } //插入 void insertNodeByHead(struct Node* headNode, struct commodity data) {     struct Node* newNode = createNode(data);     newNode->next = headNode->next;     headNode->next = newNode; } //查找 struct Node*findByName(struct Node* headNode, char * name) {     struct Node* pMove = headNode->next;     while (pMove) {         if (!strcmp(pMove->data.name,name)) {             return pMove;         }         //没有往下走pMove = pMove->next;     }     return NULL; } //删除 void deleteNodeByName(struct Node* headNode, char * name) {     //找到指定位置那个结点，以及制定位置前面那个结点//要有两个相邻的指针     struct Node* p = headNode;     struct Node* q = headNode->next;     if (q == NULL) {         printf(\"么有(没有)可用信息,无法删除 \");     } else {         while (strcmp(q->data.name,name)) {             p = q;             q = p->next;             if (q == NULL) {                 printf(\"未找到制定位置，无法删除 \");                 return;             }         }         p->next = q->next;         free(q);     } } //删除 void deleteNodeByNum(struct Node* headNode, int num) {     //找到指定位置那个结点，以及制定位置前面那个结点//要有两个相邻的指针     struct Node* p = headNode;     struct Node* q = headNode->next;     if (q == NULL) {         printf(\"么有(没有)可用信息,无法删除 \");     } else {         while (q->data.num!=num) {             p = q;             q = p->next;             if (q == NULL) {                 printf(\"未找到制定位置，无法删除 \");                 return;             }         }         p->next = q->next;         free(q);     } } //打印 void printList(struct Node*headNode) {     struct Node* pMove = headNode->next;     printf(\"商品代码 商品名称 商品单价 商品库存量\");     while (pMove) {         printf(\"%d %s %s %d \", pMove->data.num, pMove->data.name, pMove->data.price, pMove->data.storage);         pMove = pMove->next;     }     printf(\" \"); } void menu() {     printf(\" \");     printf(\" 0.退出系统 \");     printf(\" 1.录入信息 \");     printf(\" 2.显示信息 \");     printf(\" 3.删除信息 \");     printf(\" 4.查找信息 \");     printf(\" 5.保存到文件 \"); } void menuOfDelete() {     printf(\" 1.按照商品名称删除 \");     printf(\" 2.按照商品代码删除 \"); } void keyDownOfDelete() {     int choice;     char name[20];     int num;     scanf(\"%d\", &choice);     switch (choice) {     case 1://1.按照商品名称删除         printf(\"请输入要删除的商品名称:\");         scanf(\"%s\", name);         deleteNodeByName(list, name);         break;     case 2://2.按照商品代码删除         printf(\"请输入要删除的商品代码:\");         scanf(\"%d\", &num);         deleteNodeByNum(list, num);         break;     default:printf(\"输入错误,无法删除 \");     } } //保存到文件 void saveInfoToFile(struct Node* list, char *filePath, char *mode) {     struct Node* pMove = list->next;     FILE *fp =fopen(filePath, mode);     while (pMove) {         fprintf(fp, \"%d %s %s %d \", pMove->data.num, pMove->data.name, pMove->data.price, pMove->data.storage);         pMove = pMove->next;     }     fclose(fp); } //读文件 void readInfoFromFile(struct Node* list, char *filePath, char *mode) {     struct commodity data;     FILE *fp =fopen(filePath, mode);     while (fscanf(fp, \"%d %s %s %d \", &data.num, data.name, data.price, &data.storage) !=EOF) {         insertNodeByHead(list, data);     }     fclose(fp); } //交互 void keyDown() {     int choice;     struct commodity comInfo;     char temp= ' ';     choice=getchar();     switch (choice) {     case 0:         system(\"pause\");         exit(0);         break;     case 1://1.录入信息         while (1) {             printf(\"请输入商品代号，商品名称，商品价格，商品库存量：\");             fflush(stdin);             scanf(\"%d%s%s%d\", &comInfo.num, comInfo.name, comInfo.price, &comInfo.storage);             //链表的插入             insertNodeByHead(list, comInfo);             printf(\"是否继续？(N)\");             fflush(stdin);             temp = getchar();             if (temp == 'N' ||temp== 'n')break;         }         break;     case 2://2.显示信息         printList(list);         break;     case 3://3.删除信息         menuOfDelete();         keyDownOfDelete();         break;     case 4://4.查找信息         printf(\"请输入要查找的商品名称：\");         scanf(\"%s\", comInfo.name);         if (findByName(list, comInfo.name) != NULL) {             printf(\"%d %s %s %d \", findByName(list, comInfo.name)->data.num,findByName(list, comInfo.name)->data.name, findByName(list, comInfo.name)->data.price,findByName(list, comInfo.name)->data.storage);         } else {             printf(\"未找到相关信息! \");         }         break;     case 5://5.保存到文件         saveInfoToFile(list,\"1.txt\", \"w\");         break;     default:         printf(\"输入错误,重新输入 \");         break;     } } int main() {     list=createlist();     readInfoFromFile(list, \"1.txt\", \"r\");     while (1) {         menu();         keyDown();         system(\"pause\");         system(\"cls\");     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "建议先弄好代码，注意换行。问题应该比较好解决，代码不长", "referer": "user-0"}]}
{"question": "【咨询贴】C语言 输出10个数中最大数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 qzjhjxj的回复:供参考：#include <stdio.h> int main(void) {       int a[5];       printf(\"请输入5个数字:\\n\");       for(int i=0;i<5;i++)//for(int i=1;i<=5;i++)        {           scanf(\"%d\",&a[i]);        }       int i,temp=a[0];       for(i=1;i<5;i++) //for(i=2;i<=6;i++)        {            if(temp < a[i])            {                        //printf(\"%d > %d \\n\",a[i-1],a[i]);                   temp=a[i];//找到大数，并记录到temp里                         // a[i]=temp;             }        }       printf(\"max= %d  \",temp);//printf(\"max= %d  \",a[i]);              return 0; } 谢谢啦！问题已解决。就是i可能会小于0", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考：#include <stdio.h> int main(void) {       int a[5];       printf(\"请输入5个数字:\\n\");       for(int i=0;i<5;i++)//for(int i=1;i<=5;i++)        {           scanf(\"%d\",&a[i]);        }       int i,temp=a[0];       for(i=1;i<5;i++) //for(i=2;i<=6;i++)        {            if(temp < a[i])            {                        //printf(\"%d > %d \\n\",a[i-1],a[i]);                   temp=a[i];//找到大数，并记录到temp里                         // a[i]=temp;             }        }       printf(\"max= %d  \",temp);//printf(\"max= %d  \",a[i]);              return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "好的，谢谢！这常识我会好好记住的。 不过改动了一下，又遇到一个问题，就是当输入的数值里既有正数又有负数时，结果输出max＝0 可以再解答一下吗？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:改为i <6,就正确了。 原来是这样啊！ 不过改动了一下，又遇到一个问题，就是当输入的数值里既有正数又有负数时，结果输出max＝0 可以再解答一下吗？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "原来是这样啊！ 不过改动了一下，又遇到一个问题，就是当输入的数值里既有正数又有负数时，结果输出max＝0 可以再解答一下吗？", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "作为常识，C语言数组下标从0开始 定义为int a[5]的数组，其合法元素是 a[0]  a[1]  a[2]  a[3]  a[4]", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "改为i <6,就正确了。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "for (i =2;i <=6;i++)这里，i =6 的时候，数组a[6]下标越界了，a[6]的值是随机的，刚好凑上6了。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "谁来帮帮我", "referer": "user-0"}]}
{"question": "怎么搞才能让计算的精度提高了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#pragma warning(disable:4996) /*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console) 功能： 目前提供了10多个常用数学函数: ⑴正弦sin ⑵余弦cos ⑶正切tan ⑷开平方sqrt ⑸反正弦arcsin ⑹反余弦arccos ⑺反正切arctan ⑻常用对数lg ⑼自然对数ln ⑽ｅ指数exp ⑾乘幂函数^ ⑿向上取整ceil ⒀向下取整floor ⒁四舍五入取整round ⒂取符号sign ⒃取绝对值abs 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率Pi键入字母时不区分大小写,以方便使用。 16进制整数以0x或0X开头。 ----------------------------------------*/ #include <iostream> #include <iomanip> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <stdio.h> #include <string.h> #include <windows.h> using namespace std; const char Tab = 0x9; const int  DIGIT = 1; const int MAXLEN = 16384; char s[MAXLEN], *endss; int pcs = 15; double sign(double dVal) {          if (dVal>0.0) return  1.0;     else if (dVal<0.0) return -1.0;     else               return  0.0; } double round(double dVal, short iPlaces) {//iPlaces>=0     char s[30];     double dRetval;      sprintf(s, \"%.*lf\", iPlaces, dVal);     sscanf(s, \"%lf\", &dRetval);     return (dRetval); } double fun(double x, char op[], int *iop) {     while (op[*iop - 1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>         switch (op[*iop - 1]) {         case  7: x = sin(x);    (*iop)--; break;         case  8: x = cos(x);    (*iop)--; break;         case  9: x = tan(x);    (*iop)--; break;         case 10: x = sqrt(x);   (*iop)--; break;         case 11: x = asin(x);   (*iop)--; break;         case 12: x = acos(x);   (*iop)--; break;         case 13: x = atan(x);   (*iop)--; break;         case 14: x = log10(x);  (*iop)--; break;         case 15: x = log(x);    (*iop)--; break;         case 16: x = exp(x);    (*iop)--; break;         case 17: x = ceil(x);   (*iop)--; break;         case 18: x = floor(x);  (*iop)--; break;         case 19: x = round(x,0);(*iop)--; break;         case 20: x = sign(x);   (*iop)--; break;         case 21: x = fabs(x);   (*iop)--; break;         }     return x; } double calc(char *expr, char **addr) {     static int deep; //递归深度     static char *fname[] = { \"sin\",\"cos\",\"tan\",\"sqrt\",\"arcsin\",\"arccos\",\"arctan\",\"lg\",\"ln\",\"exp\",\"ceil\",\"floor\",\"round\",\"sign\",\"abs\",NULL };     double ST[10] = { 0.0 }; //数字栈     char op[10] = { '+' }; //运算符栈     char c, *rexp, *pp, *pf;     int ist = 1, iop = 1, last, i, n;     __int64 i64;      if (!deep) {         pp = pf = expr;         do {             c = *pp++;             if (c != ' '&& c != Tab)                 *pf++ = c;         } while (c != '\\0');     }     pp = expr;     if ((c = *pp) == '-' || c == '+') {         op[0] = c;         pp++;     }     last = !DIGIT;     while ((c = *pp) != '\\0') {         if (c == '(') {//左圆括弧             deep++;             ST[ist++] = calc(++pp, addr);             deep--;             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             pp = *addr;             last = DIGIT;             if (*pp == '(' || isalpha(*pp) && strnicmp(pp, \"Pi\", 2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }         else if (c == ')') {//右圆括弧             pp++;             break;         }         else if (isalpha(c)) {             if (!strnicmp(pp, \"Pi\", 2)) {                 if (last == DIGIT) {                     wcout <<    L\"π左侧遇）\" << endl; exit(1);                 }                 ST[ist++] = 3.14159265358979323846264338328;                 ST[ist - 1] = fun(ST[ist - 1], op, &iop);                 pp += 2;                 last = DIGIT;                 if (!strnicmp(pp, \"Pi\", 2)) {                     wcout <<    L\"两个π相连\" << endl; exit(2);                 }                 if (*pp == '(') {                     wcout <<    L\"π右侧遇（\" << endl; exit(3);                 }             }             else {                 for (i = 0; (pf = fname[i]) != NULL; i++)                     if (!strnicmp(pp, pf, strlen(pf))) break;                 if (pf != NULL) {                     op[iop++] = 07 + i;                     pp += strlen(pf);                 }                 else {                     wcout <<    L\"陌生函数名\" << endl; exit(4);                 }             }         }         else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '^') {             char cc;             if (last != DIGIT) {                 wcout <<    L\"运算符粘连\" << endl; exit(5);             }             pp++;             if (c == '+' || c == '-') {                 do {                     cc = op[--iop];                     --ist;                     switch (cc) {                     case '+':  ST[ist - 1] += ST[ist]; break;                     case '-':  ST[ist - 1] -= ST[ist]; break;                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 } while (iop);                 op[iop++] = c;             }             else if (c == '*' || c == '/' || c == '%') {             operate:        cc = op[iop - 1];                 if (cc == '+' || cc == '-') {                     op[iop++] = c;                 }                 else {                     --ist;                     op[iop - 1] = c;                     switch (cc) {                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 }             }             else {                 cc = op[iop - 1];                 if (cc == '^') {                     wcout <<    L\"乘幂符连用\" << endl; exit(6);                 }                 op[iop++] = c;             }             last = !DIGIT;         }         else {             if (last == DIGIT) {                 wcout <<    L\"两数字粘连\" << endl; exit(7);             }             if (pp[0] == '0' && (pp[1] == 'x' || pp[1] == 'X')) {                 sscanf(pp + 2, \"%I64x%n\", &i64, &n);                 rexp = pp + 2 + n;                 ST[ist++] = (double)i64;             }             else ST[ist++] = strtod(pp, &rexp);             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             if (pp == rexp) {                 wcout <<    L\"非法字符\" << endl; exit(8);             }             pp = rexp;             last = DIGIT;             if (*pp == '(' || isalpha(*pp)) {                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }     }     *addr = pp;     if (iop >= ist) {         wcout <<    L\"表达式有误\" << endl; exit(9);     }     while (iop) {         --ist;         switch (op[--iop]) {         case '+':  ST[ist - 1] += ST[ist]; break;         case '-':  ST[ist - 1] -= ST[ist]; break;         case '*':  ST[ist - 1] *= ST[ist]; break;         case '/':  ST[ist - 1] /= ST[ist]; break;         case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;         case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;         }     }     return ST[0]; } int main(int argc, char **argv) {     int a;      wcout.imbue(locale(\"chs\"));     if (argc<2) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         wcout <<    L\"计算函数表达式的值。\" << endl << L\"支持(),+,-,*,/,%,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs\" << endl;         while (1) {             wcout <<    L\"请输入表达式：\";             fgets(s,16384,stdin);             if ('\\n' == s[strlen(s)-1]) s[strlen(s) - 1] = 0;             if (s[0] == 0) break;//             cout << s << \"=\";             cout << setprecision(15) << calc(s, &endss) << endl;         }     }     else if (argc == 2 && 0 == strcmp(argv[1], \"/?\")) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         wcout <<    L\"计算由≥1个命令行参数给出的函数表达式的值。\\n\"             \"最后一个参数是.0～.15表示将计算结果保留小数0～15位\\n\"             \"最后一个参数是x表示将计算结果以16进制正整数格式输出\\n\"             \"支持(),+,-,*,/,%,^^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs\\n\"             \"16进制整数以0x或0X开头\\n\";     }     else {         strncpy(s, argv[1], MAXLEN - 1); s[MAXLEN - 1] = 0;         if (argc>2) {             for (a = 2; a<argc - 1; a++) strncat(s, argv[a], MAXLEN - 1);//将空格间隔的各参数连接到s             if (1 == sscanf(argv[a], \".%d\", &pcs) && 0 <= pcs && pcs <= 15) {//最后一个参数是.0～.15表示将计算结果保留小数0～15位                 printf(\"%.*lf\\n\", pcs, calc(s, &endss));             }             else if (argv[a][0] == 'x' || argv[a][0] == 'X') {//最后一个参数是x表示将计算结果以16进制正整数格式输出                 printf(\"0x%016I64x\\n\", (__int64)calc(s, &endss));             }             else {                 strncat(s, argv[a], MAXLEN - 1);                 printf(\"%.15lg\\n\", calc(s, &endss));             }         }         else {             printf(\"%.15lg\\n\", calc(s, &endss));         }     }     return 0; }", "referer": "user-0"}]}
{"question": "求大佬解救", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h> #include<malloc.h> #define _CRT_SECURE_NO_WARNINGS struct commodity {     int num;     char name[20];     char price[3];     int storage; }; struct Node {     //int data;     struct commodity data;     struct Node* next; } Node; struct Node* list; struct Node* createlist() {     struct Node* headNode=(struct Node*)malloc(sizeof(struct Node));     headNode->next =NULL;     return headNode; } //创造节点 struct Node* createNode(struct commodity data) {     struct Node* newNode=(struct Node*)malloc(sizeof(struct Node));     newNode->data =data;     newNode->next =NULL;     return newNode; } //插入 void insertNodeByHead(struct Node* headNode, struct commodity data) {     struct Node* newNode = createNode(data);     newNode->next = headNode->next;     headNode->next = newNode; } //查找 struct Node*findByName(struct Node* headNode, char * name) {     struct Node* pMove = headNode->next;     while (pMove) {         if (!strcmp(pMove->data.name,name)) {             return pMove;         }         //没有往下走pMove = pMove->next;     }     return NULL; } //删除 void deleteNodeByName(struct Node* headNode, char * name) {     //找到指定位置那个结点，以及制定位置前面那个结点//要有两个相邻的指针     struct Node* p = headNode;     struct Node* q = headNode->next;     if (q == NULL) {         printf(\"么有(没有)可用信息,无法删除 \");     } else {         while (strcmp(q->data.name,name)) {             p = q;             q = p->next;             if (q == NULL) {                 printf(\"未找到制定位置，无法删除 \");                 return;             }         }         p->next = q->next;         free(q);     } } //删除 void deleteNodeByNum(struct Node* headNode, int num) {     //找到指定位置那个结点，以及制定位置前面那个结点//要有两个相邻的指针     struct Node* p = headNode;     struct Node* q = headNode->next;     if (q == NULL) {         printf(\"么有(没有)可用信息,无法删除 \");     } else {         while (q->data.num!=num) {             p = q;             q = p->next;             if (q == NULL) {                 printf(\"未找到制定位置，无法删除 \");                 return;             }         }         p->next = q->next;         free(q);     } } //打印 void printList(struct Node*headNode) {     struct Node* pMove = headNode->next;     printf(\"商品代码 商品名称 商品单价 商品库存量\");     while (pMove) {         printf(\"%d %s %s %d \", pMove->data.num, pMove->data.name, pMove->data.price, pMove->data.storage);         pMove = pMove->next;     }     printf(\" \"); } void menu() {     printf(\" \");     printf(\" 0.退出系统 \");     printf(\" 1.录入信息 \");     printf(\" 2.显示信息 \");     printf(\" 3.删除信息 \");     printf(\" 4.查找信息 \");     printf(\" 5.保存到文件 \"); } void menuOfDelete() {     printf(\" 1.按照商品名称删除 \");     printf(\" 2.按照商品代码删除 \"); } void keyDownOfDelete() {     int choice;     char name[20];     int num;     scanf(\"%d\", &choice);     switch (choice) {     case 1://1.按照商品名称删除         printf(\"请输入要删除的商品名称:\");         scanf(\"%s\", name);         deleteNodeByName(list, name);         break;     case 2://2.按照商品代码删除         printf(\"请输入要删除的商品代码:\");         scanf(\"%d\", &num);         deleteNodeByNum(list, num);         break;     default:printf(\"输入错误,无法删除 \");     } } //保存到文件 void saveInfoToFile(struct Node* list, char *filePath, char *mode) {     struct Node* pMove = list->next;     FILE *fp =fopen(filePath, mode);     while (pMove) {         fprintf(fp, \"%d %s %s %d \", pMove->data.num, pMove->data.name, pMove->data.price, pMove->data.storage);         pMove = pMove->next;     }     fclose(fp); } //读文件 void readInfoFromFile(struct Node* list, char *filePath, char *mode) {     struct commodity data;     FILE *fp =fopen(filePath, mode);     while (fscanf(fp, \"%d %s %s %d \", &data.num, data.name, data.price, &data.storage) !=EOF) {         insertNodeByHead(list, data);     }     fclose(fp); } //交互 void keyDown() {     int choice;     struct commodity comInfo;     char temp= ' ';     choice=getchar();     switch (choice) {     case 0:         system(\"pause\");         exit(0);         break;     case 1://1.录入信息         while (1) {             printf(\"请输入商品代号，商品名称，商品价格，商品库存量：\");             fflush(stdin);             scanf(\"%d%s%s%d\", &comInfo.num, comInfo.name, comInfo.price, &comInfo.storage);             //链表的插入             insertNodeByHead(list, comInfo);             printf(\"是否继续？(N)\");             fflush(stdin);             temp = getchar();             if (temp == 'N' ||temp== 'n')break;         }         break;     case 2://2.显示信息         printList(list);         break;     case 3://3.删除信息         menuOfDelete();         keyDownOfDelete();         break;     case 4://4.查找信息         printf(\"请输入要查找的商品名称：\");         scanf(\"%s\", comInfo.name);         if (findByName(list, comInfo.name) != NULL) {             printf(\"%d %s %s %d \", findByName(list, comInfo.name)->data.num,findByName(list, comInfo.name)->data.name, findByName(list, comInfo.name)->data.price,findByName(list, comInfo.name)->data.storage);         } else {             printf(\"未找到相关信息! \");         }         break;     case 5://5.保存到文件         saveInfoToFile(list,\"1.txt\", \"w\");         break;     default:         printf(\"输入错误,重新输入 \");         break;     } } int main() {     list=createlist();     readInfoFromFile(list, \"1.txt\", \"r\");     while (1) {         menu();         keyDown();         system(\"pause\");         system(\"cls\");     }     return 0; }", "referer": "user-0"}]}
{"question": "想请问这个哪里有错误，求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢啦", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "”开学第一天“——就挂了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "审核延迟浪费我一根面条。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "括号位置不当 while((c=getchar))!='@')", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "while ((c=getchar ())!=‘@‘);括号括正确。", "referer": "user-0"}]}
{"question": "课题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <string.h> int main() {     char *s[2][3]={         {\"000\",\"01111\",\"02\"        },         {\"10\" ,\"111\"  ,\"1222222222\"},     };     int r,c,L[3],w;     for (c=0;c<3;c++) {         for (r=0;r<2;r++) {             if (r==0) L[c]=strlen(s[r][c]);             else {                 w=strlen(s[r][c]);                 if (w>L[c]) L[c]=w;             }         }     }     for (r=0;r<2;r++) {         for (c=0;c<3;c++) {             if (c!=0) printf(\"|\");             printf(\"%*s\",L[c],s[r][c]);         }         printf(\"|\\n\");     }     printf(\"\\n\");      for (r=0;r<2;r++) {         for (c=0;c<3;c++) {             if (c!=0) printf(\"|\");             printf(\"%*s\",-L[c],s[r][c]);         }         printf(\"|\\n\");     }     printf(\"\\n\");     return 0; } //000|01111|        02| // 10|  111|1222222222| // //000|01111|02        | //10 |111  |1222222222| // //", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "设定字符串长度，比如\"%20s\"字符串20字节长度，试试～", "referer": "user-0"}]}
{"question": "如何获得字库中的所有符号或文字", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "......................................................", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "学习一下了！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "仅供参考：#pragma comment(lib,\"gdi32\") #include <windows.h> #include <stdio.h>  int main() {     const DWORD uWidth = 18 + 17 * 256, uHeight = 18 + 17 * 128;      PBITMAPINFO pbmi = (PBITMAPINFO) LocalAlloc (LPTR, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2);     pbmi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);     pbmi->bmiHeader.biWidth = uWidth;     pbmi->bmiHeader.biHeight = uHeight;     pbmi->bmiHeader.biPlanes = 1;     pbmi->bmiHeader.biBitCount = 1;     pbmi->bmiHeader.biSizeImage = ((uWidth + 31) & ~31) / 8 * uHeight;     pbmi->bmiColors[0].rgbBlue = 0;     pbmi->bmiColors[0].rgbGreen = 0;     pbmi->bmiColors[0].rgbRed = 0;     pbmi->bmiColors[1].rgbBlue = 255;     pbmi->bmiColors[1].rgbGreen = 255;     pbmi->bmiColors[1].rgbRed = 255;      HDC hDC = CreateCompatibleDC (0);     void * pvBits;     HBITMAP hBitmap = CreateDIBSection (hDC, pbmi, 0, &pvBits, NULL, 0);     SelectObject (hDC, hBitmap);     HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \"宋体\"); //  HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, SHIFTJIS_CHARSET, 0, 0, 0, 0, \"宋体\");     SelectObject (hDC, hFont);     BitBlt (hDC, 0, 0, uWidth, uHeight, NULL, 0, 0, WHITENESS);      char c[4];     int i, j;     for (i = 128; i < 256; i++) {         sprintf (c, \"%02X\", i);         TextOut (hDC, 1, (i - 127) * 17 + 1, c, 2);     }     for (j = 0; j < 256; j++) {         sprintf (c, \"%02X\", j);         TextOut (hDC, (j + 1)* 17 + 1, 1, c, 2);     }     for (i = 128; i < 256; i++) {         for (j = 0; j < 256; j++) {             c[0] = (char) i;             c[1] = (char) j;             TextOut (hDC, (j + 1) * 17 + 1, (i - 127) * 17 + 1, c, 2);         }     }     for (i = 0; i < 130; i++) {         MoveToEx (hDC, 0, i * 17, NULL);         LineTo (hDC, uWidth, i * 17);     }     for (j = 0; j < 258; j++) {         MoveToEx (hDC, j * 17, 0, NULL);         LineTo (hDC, j * 17, uHeight);     }      BITMAPFILEHEADER bmfh;     bmfh.bfType = *(PWORD) \"BM\";     bmfh.bfReserved1 = 0;     bmfh.bfReserved2 = 0;     bmfh.bfOffBits = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2;     bmfh.bfSize = bmfh.bfOffBits + pbmi->bmiHeader.biSizeImage;      HANDLE hFile = CreateFile (\"goal.bmp\", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);     if (hFile != INVALID_HANDLE_VALUE) {         DWORD dwWritten;         WriteFile (hFile, &bmfh, sizeof (BITMAPFILEHEADER), &dwWritten, NULL);         WriteFile (hFile, pbmi, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2, &dwWritten, NULL);         WriteFile (hFile, pvBits, pbmi->bmiHeader.biSizeImage, &dwWritten, NULL);          CloseHandle (hFile);     }      DeleteObject (hFont);     DeleteObject (hBitmap);     DeleteDC (hDC);     LocalFree (pbmi);      return 0; }   趁CSDN的程序猿表情还没戒烟，我赶紧多抽两口！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "编码的意思就是你输入的字的内码，编码空间就是内码的取值范围。 结合你编程环境的实际情况，写个循环就好。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 4 楼 forever74 的回复:最笨最简单的办法，循环穷举编码空间，找不到的跳过。编码空间怎么弄，能否详细说下吗", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "最笨最简单的办法，循环穷举编码空间，找不到的跳过。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "我可以通过freetype输入自定义的文字，然后生成bmp图片，但是我不想输入自定义的字，想直接获得字体文件中的字，然后再将所有文字显示到一张图片中", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 user-6 的回复:https://tchayen.github.io/posts/ttf-file-parsing看了下，都是JavaScript，看不太懂，而且我这边也只能用C", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 8 楼 早打大打打核战争 的回复:GetFontUnicodeRanges这个函数可以，我去找找用法。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 6 楼 forever74 的回复:编码的意思就是你输入的字的内码，编码空间就是内码的取值范围。 结合你编程环境的实际情况，写个循环就好。好的，谢谢", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "WCRANGE [This is preliminary documentation and subject to change.]   The WCRANGE structure specifies a range of Unicode characters.  typedef struct tagWCRANGE {     WCHAR  wcLow;     USHORT cGlyphs; } WCRANGE, *PWCRANGE,FAR *LPWCRANGE;   Members wcLow  Low Unicode code point in the range of supported Unicode code points.  cGlyphs  Number of supported Unicode code points in this range.  QuickInfo   Windows NT: Requires version 5.0 or later.   Windows: Requires Windows 98 or later.   Windows CE: Unsupported.   Header: Declared in wingdi.h.  See Also Fonts and Text Overview, Font and Text Structures, GLYPHSET", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "GetFontUnicodeRanges [This is preliminary documentation and subject to change.]   The GetFontUnicodeRanges function returns information about which Unicode characters are supported by a font. The information is returned as a GLYPHSET structure.  WINGDIAPI DWORD WINAPI GetFontUnicodeRanges(   HDC hdc,         // handle to the device context   LPGLYPHSET lpgs  // pointer to the glyph set structure );   Parameters hdc  Handle to the device context.  lpgs  Pointer to a buffer to contain the GLYPHSET structure. If this parameter is NULL, the function returns a pointer to the GLYPHSET structure for the current font.  Return Values If the function succeeds, it returns a pointer to the font's GLYPHSET structure for the current device context.   If the function fails, it returns zero.  QuickInfo   Windows NT: Requires version 5.0 or later.   Windows: Unsupported.   Windows CE: Unsupported.   Header: Declared in wingdi.h.   Import Library: Use gdi32.lib.  See Also Fonts and Text Overview, Font and Text Functions, GLYPHSET    GLYPHSET [This is preliminary documentation and subject to change.]   The GLYPHSET structure contains information about a range of Unicode code points.  typedef struct tagGLYPHSET {     DWORD    cbThis;     DWORD    flAccel;     DWORD    cGlyphsSupported;     DWORD    cRanges;     WCRANGE  ranges[1]; } GLYPHSET, *PGLYPHSET, FAR *LPGLYPHSET;   Members cbThis  Size, in bytes, of this structure.  flAccel  Flags describing the maximum size of the glyph indices. This member can be the following value: Value Meaning  GS_8BIT_INDICES Treat glyph indices as 8-bit wide values. Otherwise, they are 16-bit wide values.    cGlyphsSupported  Total number of Unicode code points supported in the font.  cRanges  Total number of Unicode ranges in ranges.  ranges  Array of Unicode ranges that are supported in the font.  QuickInfo   Windows NT: Requires version 5.0 or later.   Windows: Requires Windows 98 or later.   Windows CE: Unsupported.   Header: Declared in wingdi.h.  See Also Fonts and Text Overview, Font and Text Structures, GetFontUnicodeRanges, WCRANGE", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "GetFontUnicodeRanges", "referer": "user-0"}, {"cid": "14", "user": "user-6", "content": "https://tchayen.github.io/posts/ttf-file-parsing", "referer": "user-0"}]}
{"question": "C语言extern的一个小问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "当标识符具有文件作用域时，extern才是可选的。第二个a不具备文件作用域，所以在使用extern对a进行声明时会自动引用具有文件作用域的变量a(在文是第一个a)。回帖是为了下次忘了能更好的理解", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "就近原则吧，把extern int a;这句注释掉，应该输出的是13；", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "全局变量在外部使用声明时，extern关键字是必须的，如果变量没有extern修饰且没有显式的初始化，同样成为变量的定义，因此此时必须加extern，而编译器在此标记存储空间在执行时加载内并初始化为0。而局部变量的声明不能有extern的修饰，且局部变量在运行时才在堆栈部分分配内存。你这加extern表示a为全局变量，当然为12", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "extern extern declarator      // used when variable or function has external linkage  extern string-literal declarator      // used when linkage conventions of another                           // language are being used for the declarator  extern string-literal { declarator-list }   // used when linkage conventions of another                          // language are being used for the declarators  The extern keyword declares a variable or function and specifies that it has external linkage (its name is visible from files other than the one in which it's defined). When modifying a variable, extern specifies that the variable has static duration (it is allocated when the program begins and deallocated when the program ends). The variable or function may be defined in another source file, or later in the same file. In C++, when used with a string, extern specifies that the linkage conventions of another language are being used for the declarator(s).  Declarations of variables and functions at file scope are external by default.  In C++, string-literal is the name of a language. The language specifier \"C++\" is the default. \"C\" is the only other language specifier currently supported by Microsoft C/C++. This allows you to use functions or variables defined in a C module.  All of the standard include files use the extern \"C\" syntax to allow the run-time library functions to be used in C++ programs.  For more information, see auto, register, static, const, and volatile.  Example  The following example declares the functions printf, getchar, and putchar with “C” linkage:  // Example of the extern keyword extern \"C\" int printf( const char *, ... );  extern \"C\" {    int getchar( void );    int putchar( int ); }", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "供参考：#include <stdio.h>  int a=12 ;//全局变量是有默认值的,可以在函数外定义并初始化。           // a=12;//不能进行赋值操作。 int main(void) {      int a = 13;//局部变量没有默认值                //局部变量会在函数内部屏蔽全局变量的影响。即当局部变量与全局变量同名时，                //在局部变量的作用范围之内，全局变量不起作用。局部变量优先原则。     {       extern int a;//想引用该外部变量，则应该在引用之前用关键字extern对该变量                   //作“外部变量声明”。表示该变量是一个已经定义的外部变量。有了此声明，                   //就可以从“声明”处起，合法地使用该外部变量。       printf(\"%d\\n\",a);//12     }     printf(\"%d\\n\",a); //13     system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": " C语言模块化开发，深入多文件编程至尊贴 ——将课本扔掉，变成会赚钱的程序员吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改如下，供参考：#include<stdio.h> #include<string.h> #include<stdlib.h> #include<windows.h>  typedef struct add {     char name[10]; //姓名     char home[5];  //籍贯     char phone[20];//电话     char zip[10];  //邮编     char email[20];//电子邮箱     add *next; }add;  add *head=NULL;   void input(); void inputdata(); void lokkdata();//查看数据函数 void find();//通过姓名查询数据 void update();//修改 void deleted();//删除数据   int main() {   int m,i=1;   while(i){         printf(\"---------通讯录管理系统菜单---------\\n\");         printf(\"1   显示数据 \\n\");         printf(\"2   输入数据\\n\");         printf(\"3   查询信息\\n\");          printf(\"4   修改数据\\n\");         printf(\"5   删除数据\\n\");         printf(\"6   退出系统\\n\");         scanf(\"%d\",&m);         switch(m){                case 1:lokkdata();break;                case 2:inputdata();break;                case 3:find();break;                case 4:update();break;                case 5:deleted();break;//删除数据                case 6://exit(0);                default:i=0;break;         }         system(\"pause\");         system(\"cls\");   }   return 0; }  void input() {     add *p=NULL;     printf(\"姓名:%s\\t\", p->name);     printf(\"籍贯:%s\\t\", p->home);     printf(\"电话号码:%s\\t\",p->phone);     printf(\"邮编:%s\\t\", p->zip);     printf(\"电子邮箱:%s\\n\", p->email); }  void inputdata() {     add *h=NULL,*h_prv=NULL,*p=NULL;     if (head == NULL){         head=(add *)malloc(sizeof(add));//生成头节点         h_prv=h=head;         head->next=NULL;     }else{         for(h_prv=h=head;h->next!=NULL;h_prv = h,h=h->next);//找到节点尾部     }     printf(\"        输入数据\\n\");     while(1){           printf(\"\\n在姓名处输入ok代表输入数据结束\\n\\n\");           p=(add*)malloc(sizeof(add));//分配一个节点空间           printf(\"姓名:\");           scanf (\"%s\",p->name);           if (strcmp(p->name,\"ok\")==0){               printf(\"\\n输入完毕\\n\");               h = h_prv;      //退回上一节点               h->next = NULL;               free(p);               break;           }           printf(\"籍贯:\");           scanf(\"%s\",p->home);           printf(\"电话号码:\");           scanf(\"%s\",p->phone);           printf(\"邮编:\");           scanf(\"%s\",p->zip);           printf(\"电子邮箱:\");           scanf(\"%s\",p->email);           h->next = p;           h       = p;           h_prv   = h;  //记录上一节点     } }  void lokkdata()//查看数据函数 {   add *p = NULL;   if (head==NULL){       printf(\"此信息管理系统中无记录，请输入记录后再使用本功能！\\n\");       return;   }   printf(\"显示数据\\n\\n\");   for (p=head->next;p!=NULL;p=p->next){       printf(\"姓名:%s\\n\",p->name);       printf(\"籍贯:%s\\n\",p->home);       printf(\"电话号码:%s\\n\",p->phone);       printf(\"邮编:%s\\n\",p->zip);       printf(\"电子邮箱:%s\\n\\n\",p->email);   } }   void find()//通过姓名查询数据 {     add *p=NULL;     char name[10];     int b=0;     if (head==NULL){         printf(\"此信息管理系统中无记录，请输入记录后再使用本功能！\\n\");         return;     }     printf(\"      查看数据 \\n\");     printf(\"请输入你想查找人的姓名\\n\");     scanf (\"%s\",name);     for (p=head->next;p!=NULL;p=p->next){         if (strcmp(name,p->name)==0){             printf(\"\\n你要找的数据\\n\");             printf(\"姓名:%s\\n\",p->name);             printf(\"籍贯:%s\\n\",p->home);             printf(\"电话号码:%s\\n\",p->phone);             printf(\"邮编:%s\\n\",p->zip);             printf(\"电子邮箱:%s\\n\\n\",p->email);             b=1;             break;         }     }     if(b==0){         printf(\"你要查找联系人不存在\\n\");     } }  void update()//修改    {      add *p=NULL;      char name[10];      int b=0,i=0;      if (head==NULL){          printf(\"此信息管理系统中无记录，请输入记录后再使用本功能！\\n\");          return;      }      printf(\"修改数据\\n\");      printf(\"\\n请输入将要修改人的姓名:\");      scanf(\"%s\",name);      for (p=head->next;p!=NULL;p=p->next){          if (strcmp(name,p->name)==0){              printf(\"该同学的基本信息\\n\");              printf(\"姓名:%s\\n\",p->name);              printf(\"籍贯:%s\\n\",p->home);              printf(\"电话号码:%s\\n\",p->phone);              printf(\"邮编:%s\\n\",p->zip);              printf(\"电子邮箱:%s\\n\",p->email);              printf(\"请选择要修改的信息:\");              printf(\"1:姓名,2:籍贯,3:电话号码,4:邮编,5:电子邮箱\\n\");              printf(\"\\n您的选择是(1-5)号:\");              scanf(\"%d\",&i);              printf(\"请输入修改之后的内容\\n\");              switch(i){                        case 1:printf(\"姓名:\");                               scanf(\"%s\",p->name);                               break;                        case 2:printf(\"籍贯:\");                               scanf(\"%s\",p->home);                               break;                        case 3:printf(\"电话号码:\");                               scanf(\"%s\",p->phone);                               break;                        case 4:printf(\"邮编:\");                               scanf(\"%s\",p->zip);                               break;                        case 5:printf(\"电子邮箱:\");                               scanf(\"%s\",p->email);                               break;              }              printf(\"\\n修改成功!\\n\");              b=1;              break;          }      }      if(b==0){          printf(\"没有找到该人的资料!\\n\");      } }    void deleted()//删除数据 {         if (head==NULL){            printf(\"此信息管理系统中无记录，请输入记录后再使用本功能！\\n\");            return;         }         add *p=head->next,*pr=head->next;         char name[10];  //想要删除的人的姓名         if (head->next==NULL){             printf(\"内存空空神马都没有!\\n\");             printf(\"======================================================================\\n\");             return;         }         printf(\"删除数据\\n\");         printf(\"----------------------------------------------------------------------\\n\");         printf(\"请输入要删除的姓名:\");         scanf(\"%s\",name);          while ((strcmp(p->name,name)!=0 )&& p->next != NULL){              pr =p;              p =p->next;         }          if(strcmp(name,p->name)==0){             if(p == head->next) head->next = p->next;             else                pr->next   = p->next;             free(p);             printf(\"删除成功!\\n\");             printf(\"======================================================================\\n\");         }         else{            printf(\"此人不存在!\\n\");            printf(\"======================================================================\\n\");         } }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:贴源码吧，方便给你调试～  #include<stdio.h>  #include<string.h>  #include<stdlib.h>  #include<windows.h>   typedef struct add   {  char name[10];     char home[5];     char zip[10];     char phone[20];     char email[20];     add *next;  }add ;   void* inputdata(); int main() {  int m;   printf(\"---------通讯录管理系统菜单---------\\n\");   printf(\"1   显示数据 \\n\");      printf(\"2   输入数据\\n\");         printf(\"3   查询信息\\n\");                  printf(\"4   修改数据\\n\");         printf(\"5   删除数据\\n\");         printf(\"6   返回主菜单\\n\");         scanf(\"%d\",&m);         switch(m)         {         // case 1:input();break;          case 2:inputdata();break;   }   return 0;                } void input( add*p)  {  printf(\"姓名:%s\\t\", p->name);     printf(\"籍贯:%s\\t\", p->home);     printf(\"电话号码:%s\\t\", p->phone);     printf(\"邮编:%s\\t\", p->zip);     printf(\"电子邮箱:%s\\n\", p->email); }; void* inputdata() {   add *head;  add *p, *p1;  int i=1;  p=(add*)malloc(sizeof(add));//分配一个add所在大小空间，赋值给p   if(p!=NULL)  {    head=p1;    printf(\"1  输入数据\\n\");    printf(\"在姓名出输入ok代表输入数据结束\\n\");    while(i)    {      printf(\"姓名:\");      scanf (\"%s\",&p->name);      if(strcmp(p->name,\"ok\")==0)     {        printf(\"\\n输入完毕\\n\");        i=0;        p1->next=NULL;        //head(p);        p1=p;   }     else      {      printf(\"姓名\");      scanf(\"%s\",&p->name);      printf(\"籍贯\");      scanf(\"%s\",&p->home);      printf(\"电话号码\");      scanf(\"%s\",&p->phone);      printf(\"邮编\");      scanf(\"%s\",&p->zip);      printf(\"电子邮箱\");      scanf(\"%s\",&p->email);      p1=p;      p=(add*)malloc(sizeof(add));      if(p!=NULL)      {       p1->next=p;//p1的下一个数据体p    }    }    }     return(p->next);  }   } add *lokkdata(add*p)//查看数据函数 {   printf(\"显示数据\\n\");   while(p!=NULL)   {     printf(\"姓名:%s\\n\",&p->name);         printf(\"籍贯:%s\\n\",&p->home);     printf(\"电话号码:%s\\n\",&p->phone);     printf(\"邮编:%s\\n\",&p->zip);     printf(\"电子邮箱:%s\\n\",&p->email);     p=p->next;   }    return p; }     find(add*p1)//通过姓名查询数据   {    char name[10];    int b=0;    printf(\"查看数据\\n\");     printf(\"请输入你想查找人的姓名\\n\");     scanf (\"%s\",name);  while(p1!=NULL)    {      if(strcmp(name,p1->name)==0)    {     printf(\"你要找的数据\\n\");     printf(\"姓名:%s\\n\",&p1->name);         printf(\"籍贯:%s\\n\",&p1->home);     printf(\"电话号码:%s\\n\",&p1->phone);     printf(\"邮编:%s\\n\",&p1->zip);     printf(\"电子邮箱:%s\\n\",&p1->email);     b=1;      }    p1=p1->next;    }                         if(b==0)             {         printf(\"你要查找联系人不存在\\n\");   }     }      update(add*p1)//修改    {       char name[10];      int b=0,i;      printf(\"修改数据\\n\");      printf(\"请输入将要修改人的姓名:\");      scanf(\"%s\",name);      while(p1!=NULL)      {          if(strcmp(name,p1->name)==0)          {              printf(\"该同学的基本信息\\n\");              printf(\"姓名:%s\\n\",&p1->name);              printf(\"籍贯:%s\\n\",&p1->home);          printf(\"电话号码:%s\\n\",&p1->phone);          printf(\"邮编:%s\\n\",&p1->zip);          printf(\"电子邮箱:%s\\n\",&p1->email);           printf(\"请选择要修改的信息\\n\");              printf(\"手机号\\n\");              printf(\"\\n您的选择是:手机号\");              scanf(\"%d\",&i);              printf(\"请输入修改之后的内容\\n\");              switch(i)                              {              case 1:printf(\"姓名:\");                  scanf(\"%s\",&p1->name);                  break;              case 2:printf(\"籍贯:\");                  scanf(\"%s\",p1->home);                  break;              case3 :printf(\"电话号码:\");                  scanf(\"%s\",&p1->phone);                  break;              case 4:printf(\"邮编:\");                  scanf(\"%s\",&p1->zip);                  break;              case 5:printf(\"电子邮箱:\");         scanf(\"%s\",&p1->email);                  break;                  }              printf(\"\\n修改成功!\\n\");                            b=1;          }          p1=p1->next;           }             if(b==0)           {          printf(\"没有找到该人的资料!\\n\");      }  }       void deleted()          //删除数据     {  add *head;         add *p,*p1;        char name[10];  //想要删除的人的姓名         printf(\"删除数据\\n\");         printf(\"----------------------------------------------------------------------\\n\");         printf(\"请输入要删除的姓名:\");         scanf(\"%s\",name);         p=head;         if(head==NULL)         {         printf(\"内存空空神马都没有!\\n\");        printf(\"======================================================================\\n\");         return;       }         if(strcmp(name,p1->name)==0)        {         head=p->next;        printf(\"删除成功!\\n\");        printf(\"======================================================================\\n\");        return;         }        while(p!=NULL&&(strcmp(name,p1->name)!=0))        {         p1=p;        p=p->next;        }         if(p==NULL)         {         printf(\"此人不存在!\\n\");         printf(\"======================================================================\\n\");         return;         }         if(p->next!=NULL)         {         p=p->next;         p1->next=p;         printf(\"删除成功!\\n\");         printf(\"======================================================================\\n\");         return;         }         else         {         p1->next=NULL;         printf(\"删除成功!\\n\");         printf(\"======================================================================\\n\");         return;         }     }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 5 楼 chxchxkkk的回复:1.c不支持 add *next这种写法，要写全 struct add *next; 2.input函数中没有给 p分配内存空间，主函数中也没有 3.有发截图的功夫，最好还是把源码贴出来，还能复制粘贴帮着调试一下，没人愿意照着截图敲代码 不好意思，不好意思。我把源码发给你", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "#include<stdio.h>  #include<string.h>  #include<stdlib.h>  #include<windows.h>   typedef struct add   {  char name[10];     char home[5];     char zip[10];     char phone[20];     char email[20];     add *next;  }add ;   void* inputdata(); int main() {  int m;   printf(\"---------通讯录管理系统菜单---------\\n\");   printf(\"1   显示数据 \\n\");      printf(\"2   输入数据\\n\");         printf(\"3   查询信息\\n\");                  printf(\"4   修改数据\\n\");         printf(\"5   删除数据\\n\");         printf(\"6   返回主菜单\\n\");         scanf(\"%d\",&m);         switch(m)         {         // case 1:input();break;          case 2:inputdata();break;   }   return 0;                } void input( add*p)  {  printf(\"姓名:%s\\t\", p->name);     printf(\"籍贯:%s\\t\", p->home);     printf(\"电话号码:%s\\t\", p->phone);     printf(\"邮编:%s\\t\", p->zip);     printf(\"电子邮箱:%s\\n\", p->email); }; void* inputdata() {   add *head;  add *p, *p1;  int i=1;  p=(add*)malloc(sizeof(add));//分配一个add所在大小空间，赋值给p   if(p!=NULL)  {    head=p1;    printf(\"1  输入数据\\n\");    printf(\"在姓名出输入ok代表输入数据结束\\n\");    while(i)    {      printf(\"姓名:\");      scanf (\"%s\",&p->name);      if(strcmp(p->name,\"ok\")==0)     {        printf(\"\\n输入完毕\\n\");        i=0;        p1->next=NULL;        //head(p);        p1=p;   }     else      {      printf(\"姓名\");      scanf(\"%s\",&p->name);      printf(\"籍贯\");      scanf(\"%s\",&p->home);      printf(\"电话号码\");      scanf(\"%s\",&p->phone);      printf(\"邮编\");      scanf(\"%s\",&p->zip);      printf(\"电子邮箱\");      scanf(\"%s\",&p->email);      p1=p;      p=(add*)malloc(sizeof(add));      if(p!=NULL)      {       p1->next=p;//p1的下一个数据体p    }    }    }     return(p->next);  }   } add *lokkdata(add*p)//查看数据函数 {   printf(\"显示数据\\n\");   while(p!=NULL)   {     printf(\"姓名:%s\\n\",&p->name);         printf(\"籍贯:%s\\n\",&p->home);     printf(\"电话号码:%s\\n\",&p->phone);     printf(\"邮编:%s\\n\",&p->zip);     printf(\"电子邮箱:%s\\n\",&p->email);     p=p->next;   }    return p; }     find(add*p1)//通过姓名查询数据   {    char name[10];    int b=0;    printf(\"查看数据\\n\");     printf(\"请输入你想查找人的姓名\\n\");     scanf (\"%s\",name);  while(p1!=NULL)    {      if(strcmp(name,p1->name)==0)    {     printf(\"你要找的数据\\n\");     printf(\"姓名:%s\\n\",&p1->name);         printf(\"籍贯:%s\\n\",&p1->home);     printf(\"电话号码:%s\\n\",&p1->phone);     printf(\"邮编:%s\\n\",&p1->zip);     printf(\"电子邮箱:%s\\n\",&p1->email);     b=1;      }    p1=p1->next;    }                         if(b==0)             {         printf(\"你要查找联系人不存在\\n\");   }     }      update(add*p1)//修改    {       char name[10];      int b=0,i;      printf(\"修改数据\\n\");      printf(\"请输入将要修改人的姓名:\");      scanf(\"%s\",name);      while(p1!=NULL)      {          if(strcmp(name,p1->name)==0)          {              printf(\"该同学的基本信息\\n\");              printf(\"姓名:%s\\n\",&p1->name);              printf(\"籍贯:%s\\n\",&p1->home);          printf(\"电话号码:%s\\n\",&p1->phone);          printf(\"邮编:%s\\n\",&p1->zip);          printf(\"电子邮箱:%s\\n\",&p1->email);           printf(\"请选择要修改的信息\\n\");              printf(\"手机号\\n\");              printf(\"\\n您的选择是:手机号\");              scanf(\"%d\",&i);              printf(\"请输入修改之后的内容\\n\");              switch(i)                              {              case 1:printf(\"姓名:\");                  scanf(\"%s\",&p1->name);                  break;              case 2:printf(\"籍贯:\");                  scanf(\"%s\",p1->home);                  break;              case3 :printf(\"电话号码:\");                  scanf(\"%s\",&p1->phone);                  break;              case 4:printf(\"邮编:\");                  scanf(\"%s\",&p1->zip);                  break;              case 5:printf(\"电子邮箱:\");         scanf(\"%s\",&p1->email);                  break;                  }              printf(\"\\n修改成功!\\n\");                            b=1;          }          p1=p1->next;           }             if(b==0)           {          printf(\"没有找到该人的资料!\\n\");      }  }       void deleted()          //删除数据     {  add *head;         add *p,*p1;        char name[10];  //想要删除的人的姓名         printf(\"删除数据\\n\");         printf(\"----------------------------------------------------------------------\\n\");         printf(\"请输入要删除的姓名:\");         scanf(\"%s\",name);         p=head;         if(head==NULL)         {         printf(\"内存空空神马都没有!\\n\");        printf(\"======================================================================\\n\");         return;       }         if(strcmp(name,p1->name)==0)        {         head=p->next;        printf(\"删除成功!\\n\");        printf(\"======================================================================\\n\");        return;         }        while(p!=NULL&&(strcmp(name,p1->name)!=0))        {         p1=p;        p=p->next;        }         if(p==NULL)         {         printf(\"此人不存在!\\n\");         printf(\"======================================================================\\n\");         return;         }         if(p->next!=NULL)         {         p=p->next;         p1->next=p;         printf(\"删除成功!\\n\");         printf(\"======================================================================\\n\");         return;         }         else         {         p1->next=NULL;         printf(\"删除成功!\\n\");         printf(\"======================================================================\\n\");         return;         }     }", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "1.c不支持 add *next这种写法，要写全 struct add *next; 2.input函数中没有给 p分配内存空间，主函数中也没有 3.有发截图的功夫，最好还是把源码贴出来，还能复制粘贴帮着调试一下，没人愿意照着截图敲代码", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "find()函数未声明，怎么调用呢？在14行只声明了一个inputdata()函数。 建议把代码贴上来。", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "find()没定义", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "贴源码吧，方便给你调试～", "referer": "user-0"}]}
{"question": "利用函数调用编写输入n个数，输出最大值和最小值的程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "写在主函数内移出去到定义的函数内即可,不过就是写了个定义的函数体而已. 如主函数内写:N=0最大=最大值函数最小=最小值函数输入=0WHILE(N)CIN>>输入,最大<输入?最大=输入:0,最小>输入?最小=输入:0,--N;COUT<<最大<<ENDS<<最小; 再写一个函数体:输出最大小数据(){把之上代码剪贴这里即可}，再在主函数内调用这个写好了的函数即可。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h>  void get_max_min_val(int n, int *max, int *min);  int main(void) {     int n;     int max = 0, min = 0;      scanf(\"%d\", &n);      get_max_min_val(n, &max, &min);      printf(\"max=%d, min = %d\\n\", max, min);      return 0; }  void get_max_min_val(int n, int *max, int *min) {     int i;     int tmp;      for (i = 0; i < n; i++) {         scanf(\"%d\", &tmp);         if (i == 0) {             *max = *min = tmp;             continue;         }         if (*max < tmp)             *max = tmp;         if (*min > tmp)             *min = tmp;     } }   供参考～  问题不难，建议自己多尝试一些，给你代码也建议自己试着写写，比如输入的先放到数组里，然后定义两个函数，分别算出最大值和最小值", "referer": "user-0"}]}
{"question": "求大佬帮我看看这一段代码为什么不能跑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h>  int cube(int n){     return n*n*n; }  int main(void) {     int sum,temp,i;     for(i = 100;i < 1000; ++i){         temp = i;         sum = 0;         //while(i){         while(temp){             //sum += cube(i%10);             sum += cube(temp%10);             //i /= 10;             temp /= 10;         }         //if(temp == sum){         if(i == sum){             //printf(\"%d\\n\",temp);             printf(\"%d\\n\", i);         }         //sum = 0;     }      return 0; } 供参考～  问题是在外层是for循环变量是i，所以在while中就不能对i进行写操作了，否则改变了i的值，外层的循环i也跟着变化了，有可能是无限循环了。  另外，第一次使用sum时没有初始化。要么定义时，int sum = 0;这样sum = 0;放在后面就没问题了。当然也可以按照代码里操作", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "while ()循环体里，把i 全改为temp.", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "最后的sum =0;删除了", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "temp =i;后面再加一句sum =0;", "referer": "user-0"}]}
{"question": "求大佬解答？这个程序在Devc++上运行显示id returned 1 exit status", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "参考：https://didispace-wx.blog.csdn.net/article/details/110358437", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "用visual stdio 2019输入include显示灰色，是怎么回事呢", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "嗯嗯，好的我试试", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 5 楼 weixin_43058440 的回复:请问您用的这个是什么软件，各类的颜色和我的软件不一样我用的c++builder.其它可参照6#楼。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 5 楼 weixin_43058440 的回复:请问您用的这个是什么软件，各类的颜色和我的软件不一样 你指的是2楼的回复吗？呃，这是CSDN自带的代码编辑器格式。推荐一款好用的IDE:visual studio 2019", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "引用 2 楼 user-4 的回复:getchar 如何输入 EOF 呀？是上一个调试终端没关闭的原因？ 算了，都隔了一天了，估计今天重启之后就可以用了 (1)遇到getcahr函数执行时，要输入第一个字符时就直接输入Ctrl+D； (2)在前面输入的字符为换行符时， 接着输入Ctrl+D； (3)在前面有字符输入且不为换行符时，要连着输入两次Ctrl+D，这时第二次输入的Ctrl+D起到文件结束符的功能，至于第一次的 Ctrl+D作为行结束符 其实，这三种情况都可以总结为只有在getchar()提示新的一次输入时， 直接输入Ctrl+D才相当于文件结束符。 https://www.cnblogs.com/cunlau/articles/3823660.html", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "getchar 如何输入 EOF 呀？是上一个调试终端没关闭的原因？ 算了，都隔了一天了，估计今天重启之后就可以用了", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "请问您用的这个是什么软件，各类的颜色和我的软件不一样", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "谢谢你，解决啦，格式比我的美观多了", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "#include<stdio.h>  int main(){     int c;     int nd=0,nb=0,nl=0,nc=0,nn=0;     while((c=getchar())!=EOF){ //这里缺'{'          switch (c) {                 case' ':                         ++nb;                         break;                 case'1':                 case'2':                 case'3':                 case'4':                 case'5':                 case'6':                 case'7':                 case'8':                 case'9':                 case'0':                         ++nd;                         break;                 case'\\n':                         ++nl;                         break;                 case'{':                 case'}':                         ++nc;                         break;                 default:                         ++nn;                         break;          }     } //这里缺'}'     printf(\"spaces: %d,lines: %d,digits: %d\",nb,nl,nd);     printf(\"{ and }：%d,others: %d\\n\",nc,nn);          return 0; }", "referer": "user-0"}]}
{"question": "下列十六进制数据 变长的，该如何解析拆开这些数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  int main(int argc, char *argv[]) {     FILE *fp;     char  ch;     int   stage;     int   len;     int   i;     char buf[] = {         0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,         0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,         0x03, 0x02, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00     };      fp = fmemopen(buf, sizeof(buf), \"r\");     stage = 0;     while ((ch = fgetc(fp)) >= 0) {         switch (stage) {         case 0:             printf(\"cmd: %02x\\n\", (unsigned char)ch);             stage++;             break;         case 1:             printf(\"len: %02x\\n\", (unsigned char)ch);             len = ch;             stage++;             break;         case 2:             printf(\"val: %02x\",   (unsigned char)ch);             for (i = 1; i < len * 3; i++) {                 ch = fgetc(fp);                 if (i % 3 == 0) {                     printf(\",\");                 }                 printf(\" %02x\", (unsigned char)ch);             }             printf(\"\\n\");             stage = 0;             break;         default:             break;         }     }     return 0; }  /* output: cmd: 01 len: 04 val: 00 00 00, 00 00 03, 00 00 00, 00 00 05 cmd: 02 len: 03 val: 00 00 00, 00 00 00, 00 00 08 cmd: 03 len: 02 val: 00 00 08, 00 00 00 */", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢赵四老师", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "有限状态自动机 #include <stdio.h> unsigned char b[55]={ 0x01,0x04,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x05,0x02,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x03,0x02,0x00,0x00,0x08,0x00,0x00,0x00, 0x01,0x04,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x05,0x03,0x02,0x00,0x00,0x08,0x00,0x00,0x00}; unsigned char c; int i; int s; int bi; int pi; int pn; int p; int main() {     s=0;     i=0;     while (1) {         if (i>=55) break;         c=b[i];         if (s==0) {             if (c==0x01) {                 printf(\"cmd 01\\n\");                 s=1;             } else if (c==0x02) {                 printf(\"cmd 02\\n\");                 s=1;             } else if (c==0x03) {                 printf(\"cmd 03\\n\");                 s=1;             } else {                 printf(\"Invalid cmd %02X at %d\\n\",c,i);                 break;             }         } else if (s==1) {             pn=(int)c;             printf(\"pn:%d\\n\",pn);             bi=0;             pi=0;             s=2;         } else {//s==2             if (bi==0) {                 p=0x10000*(int)c;                 bi++;             } else if (bi==1) {                 p=p+0x100*(int)c;                 bi++;             } else if (bi==2) {                 p=p+(int)c;                 pi++;                 printf(\"p%d:%d\\n\",pi,p);                 if (pi>=pn) {                     s=0;                 } else {                     bi=0;                 }             }         }         i++;     }     return 0; } //cmd 01 //pn:4 //p1:0 //p2:3 //p3:0 //p4:5 //cmd 02 //pn:3 //p1:0 //p2:0 //p3:8 //cmd 03 //pn:2 //p1:8 //p2:0 //cmd 01 //pn:4 //p1:0 //p2:3 //p3:0 //p4:5 //cmd 03 //pn:2 //p1:8 //p2:0 //", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "尾码大致如此 struct s{  ch tag;  int len;  char* data; } while(！文件结尾) //begin s s1; read(s1.tag); if(tag==1||tag==2||tag==3) {   read(s1.len);   read(s1.data,s1.len); } //end;", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "还是这个尴尬局面： 你要是能把问题描述清楚，那么你自己也就解决了。 既然你描述不清，那别人也不知道问题是什么，更谈不到解决。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "谢谢了，结构体肯定用的   01 04 00 00 00 00 00 03 00 00 00 00 00 05 02 03 00 00 00 00 00 00 00 00 08 03 02 00 00 08 00 00 00     01 02 03 可能都存在，也可能存在一个或者2个，这个判断如何判断，还有存在的话， 命令后面数值个数也是不固定的，也会变化，这个怎么判断好。谢谢", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "现在我的主要疑问是", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "如果是确定的长度和确定的位置，可以考虑创建结构体，然后把这些数值（应该是放在一个缓存里的吧，并且缓存是char or unsigned char)强制转换成结构体变量，然后根据变化的值来定后面要读取多少个字节～", "referer": "user-0"}]}
{"question": "求大佬帮我看看这段代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "建议提供更多的代码，完整的代码吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考，见标注：int lengthOfLongestSubstring(char * s) {     int len = strlen(s);     if (len<2) return len;     int max = 1;     int hash[128] = {-1};     for (int i=0, j=0; j<len; j++){         if (hash[s[j]] != -1){      //if (has[s[j]] != -1){             i = fmax(i, hash[s[j]]+1);         }         hash[s[j]] = j;         max = fmax(max, j-i+1);     }     return max; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 8 楼 qzjhjxj的回复:因为一条基本语法规则：数组初始化列表中的元素个数小于指定的数组长度时，不足的元素补以默认值。默认值只能设为0，且只有在初始化时，才能设为0。如果不明确指出初始化列表，那么基本类型是不会被初始化的（除全局变量和静态变量外），所有的内存都是“脏的”。 非常感谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "因为一条基本语法规则：数组初始化列表中的元素个数小于指定的数组长度时，不足的元素补以默认值。默认值只能设为0，且只有在初始化时，才能设为0。如果不明确指出初始化列表，那么基本类型是不会被初始化的（除全局变量和静态变量外），所有的内存都是“脏的”。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "hash[128]{0}", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 5 楼 棉猴的回复:就像上面朋友说的 int hash[128] = {-1}; hash数组的第一个元素是-1，后面所有的元素都是0。 改成下面的代码试试 int hash[128]; \tfor (int i = 0; i < 128; ++i) \t{ \t\thash[i] = -1; \t} 改了，确实通过了，但是为什么int hash[128] = {0}可以把所有元素初始化为0，而把0改成-1却不能全部初始化为-1呢", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 4 楼 user-5的回复:数组初始化的问题 int hash[128] = {-1}; //这是不完全初始化，除了用0初始化可以保证正确，其他不保证，也就是有可能只有第一个元素是-1，以后的元素都是0 为什么只有0才可以呢", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "就像上面朋友说的 int hash[128] = {-1}; hash数组的第一个元素是-1，后面所有的元素都是0。 改成下面的代码试试 int hash[128]; \tfor (int i = 0; i < 128; ++i) \t{ \t\thash[i] = -1; \t}", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "数组初始化的问题 int hash[128] = {-1}; //这是不完全初始化，除了用0初始化可以保证正确，其他不保证，也就是有可能只有第一个元素是-1，以后的元素都是0", "referer": "user-0"}]}
{"question": "C开发分类", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "在软件开发领域，“C开发分类” 与 在生物进化领域，“DNA分类” 类似。 我觉得。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "C语言都是一样的，当然要看遵循什么标准：C89， C99等； 不同的系统下，编辑和编译器可能不一样；根据要开发和使用的系统来决定是使用那些工具吧～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不管什么分类，语法都是一样的（相对于同一编译器而言），有可能用到的一些类库不同而已 开发工具嘛，当然各式各样，但不管用哪一种，应该都可以（当然，应该选择针对不同的平台，至于开发工具自带make file之类的编译命令，应该都大同小异）", "referer": "user-0"}]}
{"question": "请问有人知道FreeType库可以修复损毁的字体文件吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:换个不收费的样子长差不多的字体可能更省事。不是，是个需求，看有没有可能将损毁的字体文件恢复，我用freetype看了下这个字体的属性，发现这个字体文件连字符表什么都没有", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "换个不收费的样子长差不多的字体可能更省事。", "referer": "user-0"}]}
{"question": "关于++符号的求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先赋值再加，否则++是在前面", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先赋值，然后分别加加。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "简单理解： 先 *p1 = *p2；  后 p1 + 1,p2 + 1", "referer": "user-0"}]}
{"question": "borlandc++", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-4的回复:你是说bc3.1?  对的我太难了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "cppfans.com有个完整例子，复杂了一点。如果想二三十行代码的，差不多是玩具级别的。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "现在的视频比较复杂，需要先安装解码器，然后调用它来实现，至于语言反而不是那么重要了", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "你是说bc3.1?", "referer": "user-0"}]}
{"question": "c语言输入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢大佬回复", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "在输入缓冲区放着呢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "多输入的字符仍然留在输入缓冲区里等待你后续的输入语句。 然后随程序结束而失效。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "scanf(\"%c%c\",&a,&b);这个输入的是单个字符，你输这么多，它装不下的。", "referer": "user-0"}]}
{"question": "C语言问题求助！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:#include <stdio.h> #include <string.h>  int main() {     char str[81],ch, len;     int row=0,j=0;      while((ch=getchar())!='\\n' && j < 81) {    //防止越界         str[j]=ch;         j++;     }     str[j] = 0; //add '\\0' into tail     len = j;     j=0;     char str2[81][81];     //int sum=strlen(str);    //上面已经能知道长度了，所以这里不要用sum调用strlen，减少循环～     for(int i=0;i<len;i++){         if(str[i]!=' '){             str2[row][j++]=str[i];         }         else{             str2[row++][j]='\\0';             j=0;         }     }     for(;row>=0;row--){         printf(\"%s\",str2[row]);         if(row!=0){             printf(\" \");         }     }     return 0; }感谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3 的回复:你的str没有结束符，也没有末尾空格，因此最后一个单词可能出问题。确实是这样感谢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 qzjhjxj 的回复:楼主的修改如下，供参考：#include <stdio.h> #include <string.h>  int main() {     char str[81],ch;     int  row=0,j=0;     while((ch=getchar())!='\\n'){          str[j]=ch;          j++;     }     str[j] = '\\0';//加入结束标志     j=0;     char str2[81][81];     int  sum=strlen(str);     for(int i=0;i<=sum;i++){ //for(int i=0;i<sum;i++){        if(str[i]!=' '&& str[i]!='\\0'){//if(str[i]!=' '){          str2[row][j++]=str[i];       //str[]尾部单词没有空格，是结束符'\\0'        }        else{          str2[row++][j]='\\0';//最后肯定执行这句了，row++多加一次的          j=0;        }     }     for(row--;row>=0;row--){ //row--退回一格，for(;row>=0;row--){         printf(\"%s\",str2[row]);         if(row!=0){            printf(\" \");         }     }          return 0; }  //this is a good idea //idea good a is this请按任意键继续. . .感谢", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "楼主的修改如下，供参考：#include <stdio.h> #include <string.h>  int main() {     char str[81],ch;     int  row=0,j=0;     while((ch=getchar())!='\\n'){          str[j]=ch;          j++;     }     str[j] = '\\0';//加入结束标志     j=0;     char str2[81][81];     int  sum=strlen(str);     for(int i=0;i<=sum;i++){ //for(int i=0;i<sum;i++){        if(str[i]!=' '&& str[i]!='\\0'){//if(str[i]!=' '){          str2[row][j++]=str[i];       //str[]尾部单词没有空格，是结束符'\\0'        }        else{          str2[row++][j]='\\0';//最后肯定执行这句了，row++多加一次的          j=0;        }     }     for(row--;row>=0;row--){ //row--退回一格，for(;row>=0;row--){         printf(\"%s\",str2[row]);         if(row!=0){            printf(\" \");         }     }          return 0; }  //this is a good idea //idea good a is this请按任意键继续. . .", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h> #include <string.h>  int main() {     char str[81],ch, len;     int row=0,j=0;      while((ch=getchar())!='\\n' && j < 81) {    //防止越界         str[j]=ch;         j++;     }     str[j] = 0; //add '\\0' into tail     len = j;     j=0;     char str2[81][81];     //int sum=strlen(str);    //上面已经能知道长度了，所以这里不要用sum调用strlen，减少循环～     for(int i=0;i<len;i++){         if(str[i]!=' '){             str2[row][j++]=str[i];         }         else{             str2[row++][j]='\\0';             j=0;         }     }     for(;row>=0;row--){         printf(\"%s\",str2[row]);         if(row!=0){             printf(\" \");         }     }     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "用指针写，更顺手点，供参考：#include <stdio.h> #include <string.h>  int main() {     char str[81],str1[81];     char *p,*q,*s;     int  flag=0;     gets(str);     p=str;     s=str1;     while(*p)p++;//指针到str的尾部     p--;     while(p >= str){//逆序          flag++;          if(*p==' '|| p==str){            q=p;            if(q != str){//str第一个单词前面没有空格              q++;              flag--;            }            while(flag--)*s++ = *q++;//单词拷贝，str最后一个搬到str1第一个            *s++ = ' ';            flag=0;          }          p--;     }     *s='\\0';     puts(str1);          return 0; }  //this is a good idea //idea good a is this //请按任意键继续. . .", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "你的str没有结束符，也没有末尾空格，因此最后一个单词可能出问题。", "referer": "user-0"}]}
{"question": "请问下面的动态数据代码有什么问题吗？(vargrind报错)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-3 的回复:for(int j=0;j<2;j++){         i=dynamic_arr_add(i,j);   最终还是大意了，确实是这个问题。。。 对于栈空间的内存，下意识认为函数内和函数外互相影响，结果导致这种问题。  实际程序中，遇到写入几个数据就变成随机数的问题，原因如下 malloc(sizeof(int)) 虽然sizeof(int) == 4,但是申请的内存实际上是32大小，当我realloc(sizeof(int)*2)的时候，因为后面是之前malloc的32大小的内存，所以只需要修改索引，不需要把新的内存拷贝到别的位置。  但是当realloc(sizeof(int)*8)的时候，realloc就会拷贝内存，并且释放原来的内存，然后，后面再malloc的时候，会把这里释放的内存用掉。就会出现随机数  破案了。谢谢您", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "正如楼上的描述，  dynamic_arr_add(i,j);每次更新后的i没有在下次的调用该函数时传入。因此每次就应该更新一下i；如果不想用返回值，建议可以把第一个传入参数写成传入传出参数，这样，每次的修改也可以更新到i；并在下次的传入最新的i；", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "int len = i[0];     // 长度应当包含记录位 改成 int len = *i;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "for(int j=0;j<2;j++){         i=dynamic_arr_add(i,j);", "referer": "user-0"}]}
{"question": "for循环中if语句的一个诡异的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "回过头看，编译器优化掉一些分支很正常，你要是实在闹心可以先试试 -O0 或者在两个if中间printf一下，那就不算无用分支了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 13 楼 无名D小兵 的回复:[quote=引用 10 楼 真相重于对错 的回复:] if (a == 0)//这句话执行了         {             //if(x*10<-2147483648 || x*10>2147483647 || x*10+nums[j]<-2147483648 || x*10+nums[j]>2147483647)             if (x * 10 > 2147483647 || x * 10 + nums[j] > 2147483647)//这句判断永为假                 //return 0;                 return 0;//因此这句话不会得到执行的机会         } 自己打断点，或者加入输出语句，或者单步执行，就应该清楚了 有做，就是单步执行过程中跳过了这一条语句才奇怪的。[/quote]          if (a == 0)         {             printf(\"a==0\\n\");//这里加一句输出不就清楚了？             //if(x*10<-2147483648 || x*10>2147483647 || x*10+nums[j]<-2147483648 || x*10+nums[j]>2147483647)             if (x * 10 > 2147483647 || x * 10 + nums[j] > 2147483647)                 //return 0;                 return 0;         }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 10 楼 真相重于对错 的回复:if (a == 0)//这句话执行了         {             //if(x*10<-2147483648 || x*10>2147483647 || x*10+nums[j]<-2147483648 || x*10+nums[j]>2147483647)             if (x * 10 > 2147483647 || x * 10 + nums[j] > 2147483647)//这句判断永为假                 //return 0;                 return 0;//因此这句话不会得到执行的机会         } 自己打断点，或者加入输出语句，或者单步执行，就应该清楚了 有做，就是单步执行过程中跳过了这一条语句才奇怪的。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "难道gcc有这么聪明，懂得删除无用分支？ 好吧，真的有这么聪明的编译器。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 9 楼 forever74 的回复:[quote=引用 8 楼 无名D小兵 的回复:][quote=引用 3 楼 真相重于对错 的回复:]a=num[0],也就是0，后边也没有修改过a ,所以下边a==1，本程序不会执行。  我好奇的是，连a是否等于0都没有判断[/quote] 何以见得呢？[/quote] 用GDB调试时发现的", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 15 楼 forever74 的回复:回过头看，编译器优化掉一些分支很正常，你要是实在闹心可以先试试 -O0 或者在两个if中间printf一下，那就不算无用分支了。 好的，谢谢。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "a=num[0],也就是0，后边也没有修改过a ,所以下边a==1，本程序不会执行。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "上边有误，应永远为假", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "x * 10 > 2147483647 || x * 10 + nums[j] > 2147483647 这样的语句永远为真，因为int 永远不会大于INT32_MAX ,如果计算结果大于了INT32_MAX,则会回卷。", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "if (a == 0)//这句话执行了         {             //if(x*10<-2147483648 || x*10>2147483647 || x*10+nums[j]<-2147483648 || x*10+nums[j]>2147483647)             if (x * 10 > 2147483647 || x * 10 + nums[j] > 2147483647)//这句判断永为假                 //return 0;                 return 0;//因此这句话不会得到执行的机会         } 自己打断点，或者加入输出语句，或者单步执行，就应该清楚了", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "引用 8 楼 无名D小兵 的回复:[quote=引用 3 楼 真相重于对错 的回复:]a=num[0],也就是0，后边也没有修改过a ,所以下边a==1，本程序不会执行。  我好奇的是，连a是否等于0都没有判断[/quote] 何以见得呢？", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 3 楼 真相重于对错 的回复:a=num[0],也就是0，后边也没有修改过a ,所以下边a==1，本程序不会执行。  我好奇的是，连a是否等于0都没有判断", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "或者以字符串的形式判断", "referer": "user-0"}, {"cid": "14", "user": "user-3", "content": "输入的时候，如果超出int的范围，会回卷。你可以用long long类型，如果没超出范围，再转为int", "referer": "user-0"}, {"cid": "15", "user": "user-1", "content": "计算机的数学不是人类数学，它只是一个粗糙的近似。 这就是现行的计算机体系结构不能诞生真正的人工智能的哲学层面的理由。", "referer": "user-0"}, {"cid": "16", "user": "user-1", "content": "这有啥诡异的，就好象 你取得了自己所在位置的地球经纬度，然后写了个if 说如果在东经180度的东边，或者在西经180度的西边，或者北纬90度北边，或者南纬90度南边，那就输出个出错信息。 这不就是废话么？自然的就废掉了。 道理一样一样的。", "referer": "user-0"}]}
{"question": "求助如何统计字符数组中某个字符串出现的次数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "struct strcnt {     char *str;     int   cnt; };  int count(int n, const char **s, struct strcnt *cnt) {     int i, j;     int m;      m = 0;     for (i = 0; i < n; i++) {         for (j = 0; j < m; j++) {             if (0 == strcmp(s[i], cnt[j].str))                 break;         }         if (j < m) {             /* s[i] in cnt */             cnt[j].cnt++;         } else {             /* s[i] not in cnt */             m++;             cnt[j].cnt = 1;             cnt[j].str = strdup(s[i]);         }     }     return m; }  int main(void) {          const char *s[] = {\"pasmin123\", \"pas123456\",\"pasmin@123\",\"pasrftyuiop\",                        \"pasrftyuiop\",\"as3456\",   \"pas3456\",   \"pasmin123\",                        \"pasmin@123\", \"pas456\",   \"pas3456\"};     struct strcnt *cnt;     int j;     int m, n;      n = sizeof(s) / sizeof(s[0]);     cnt = calloc(n, sizeof(struct strcnt));     m = count(n, s, cnt);      for (j = 0; j < m; j++) {         printf(\"%-16s : %4d\\n\", cnt[j].str, cnt[j].cnt);     }      return 0; }  /* output: pasmin123        :    2 pas123456        :    1 pasmin@123       :    2 pasrftyuiop      :    2 as3456           :    1 pas3456          :    2 pas456           :    1 */", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>  struct str_info {     char *str;     int cnt;     struct str_info *next; };   static struct str_info *create_node(const char *str, int len) {     struct str_info *p;      p = (struct str_info *)malloc(sizeof(struct str_info));     if (!p) {         fprintf(stderr, \"malloc error!\\n\");         exit(0);     }     p->str = (char *)malloc(len + 1);     if (!p->str) {         fprintf(stderr, \"malloc error!\\n\");         exit(0);     }     strcpy(p->str, str);     p->next = NULL;      return p; }  void insert_node(struct str_info **pphead, const char *str, int len) {     struct str_info *p = *pphead, *q;      if (*pphead == NULL) {         *pphead = create_node(str, len);         (*pphead)->cnt = 1;         return;     }      q = p;     while (p) {         if (strcmp(p->str, str) == 0) {             p->cnt++;             break;         }         q = p;         p = p->next;     }     if (!p) {         q->next = create_node(str, len);         q->next->cnt = 1;         return;     } }  void print_nodes(struct str_info *phead) {     struct str_info *p;      p = phead;      while (p) {         printf(\"%s appears %d s!\\n\", p->str, p->cnt);         p = p->next;     } }  int main(void) {     char str[128];     int len;     struct str_info *phead = NULL;      while (fgets(str, sizeof(str), stdin)) {         len = strlen(str);         if (str[len-1] == '\\n')             str[len-1] = 0;         insert_node(&phead, str, len-1);     }      print_nodes(phead);      return 0; }  供参考  链表实现；注意最后输入之后不输入了，用ctrl+d（linux),ctrl+z（windows）结束输入字符串", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "3#楼的这句有漏洞：        for (int j = 0; j <= len; j ++){应改为：for (int j = 0; j <= len-1; j ++){", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "俺也仿照整一个纯C的：  #include <stdio.h> #include <string.h> #define N 11 int main() { \tchar str[N][15] = { \"pasmin123\",  \"pas123456\",\"pasmin@123\",\"pasrftyuiop\", \t\t\t\t\t  \"pasrftyuiop\",\"as3456\",   \"pas3456\",   \"pasmin123\", \t\t\t\t\t  \"pasmin@123\", \"pas456\",   \"pas3456\" }; \tint n = 0, i, j; \tstruct temp { char* p; int count; } T[N] = { {NULL,0} }; \tfor (i = 0; i < N; i++) \t{ \t\tfor (j = 0; j <n; j++)  \t\t{ \t\t\tif (strcmp(str[i],T[j].p) == 0)  \t\t\t{ \t\t\t\tT[j].count ++; \t\t\t\tbreak; \t\t\t} \t\t} \t\tif (j == n) \t\t{ \t\t\tT[n].p = str[i]; \t\t\tT[n++].count++; \t\t} \t} \tfor (int i = 0; i < n; i++)  \t\tprintf(\"%-15s:%d\\n\", T[i].p, T[i].count); \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "补楼上：//pasmin123      :2 //pas123456      :1 //pasmin@123     :2 //pasrftyuiop    :2 //as3456         :1 //pas3456        :2 //pas456         :1 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "供参考：#include <stdio.h> #include <string.h>  int main() {     char str[][15] = {\"pasmin123\",  \"pas123456\",\"pasmin@123\",\"pasrftyuiop\",                       \"pasrftyuiop\",\"as3456\",   \"pas3456\",   \"pasmin123\",                       \"pasmin@123\", \"pas456\",   \"pas3456\"};      int len = sizeof(str)/sizeof(char[15]);     int *num = new int[len],*flag = new int[len];     memset(num,0,sizeof(int)*len);     memset(flag,0,sizeof(int)*len);      for(int i = 0; i < len; i ++){         for (int j = 0; j <= len; j ++){             if((flag[j]==0)&&(strncmp(str[j], str[i],                 strlen(str[j])>strlen(str[i])?strlen(str[j]):strlen(str[i]))==0)){                 num[i] ++;                 flag[j] = 1;//flag标记已经计数过的字符串             }         }     }     for(int i=0;i<len;i++){        if(num[i] != 0) //重复的只输出一次           printf(\"%-15s:%d\\n\",str[i],num[i]);     }     delete []num;     delete []flag;          return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "char *str=\"pasmin123\"; long count[128];  char *p=str; while(*p)   {       count[*p]++;       p++; }  a的ASCII码为97 所以统计完成后a的重复数就是count[97]", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "规模不大就一个一个比较就行， 规模大了就hash一下。  关键词：规模", "referer": "user-0"}]}
{"question": "C语言新手求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "做完第四题，供参考：//题目要求是实现下面6个功能，我现在能写出的代码能实现前两个功能，和老师沟通过后，我代码存在的问题应该 //是没能把文件中信息存储在结构体中，我在代码中使用了strncpy_s函数，想把信息复制到结构体items中，但是后面 //的功能实现不了，已经卡在这里好久了，还是没有进步，能看看错在哪了吗？ //（1）对日志文件进行列表读取和写入； //（2）计算日志文件中GET类型请求方式的占比； //（3）对访问状态码进行分析与统计，计算所有访问状态码的比率； //（4）分析访问最多的客户IP地址，并统计其访问次数； //（5）分析常用密码，并统计密码使用次数； //（6）用户输入时间段，查找该时间段内访问记录并输出到文件中   #include<stdio.h> #include<string.h>  struct record       //结构体 {     char method[255];  //[GET POST]     char ip[255];      //[233.102.79.50]     char protocol[255];//[HTTP/1.1]     char time[255];    //[2021-01-18 08:57:44]     char add[255];     //[http://39.99.254.200:8810]     char port[255];    //[/admin/login.jsp]     char page[255];    //[passwd=admin123&&password=123456]     char status[255];  //[403]     char exploer_info[255];//[Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko] };  struct record rec[2048];//文件有2048行  int main(void) {      char line[1024];     int  i=0,n=0,k,j,max,j_pos,j_pos1,pos[9],pos1[9];      FILE *fp;     fp=fopen(\"access.log\",\"r+\");//打开文件     if(!fp){         printf(\"false\\n\");         return -1;     }     else{         printf(\"open file successful!\\n\");     }     while((fgets(line,1024,fp))!=NULL){          j_pos=0,j_pos1=0;          for(j=0;j<strlen(line);j++){             if(line[j]=='[') {pos[j_pos]=j;  j_pos++;} //'[' 位置标记             if(line[j]==']') {pos1[j_pos1]=j;j_pos1++;}//']' 位置标记          }          strncpy(rec[i].method,      (line+pos[0]+1),pos1[0]-pos[0]-1);          strncpy(rec[i].ip,          (line+pos[1]+1),pos1[1]-pos[1]-1);          strncpy(rec[i].protocol,    (line+pos[2]+1),pos1[2]-pos[2]-1);          strncpy(rec[i].time,        (line+pos[3]+1),pos1[3]-pos[3]-1);          strncpy(rec[i].add,         (line+pos[4]+1),pos1[4]-pos[4]-1);          strncpy(rec[i].page,        (line+pos[5]+1),pos1[5]-pos[5]-1);          strncpy(rec[i].port,        (line+pos[6]+1),pos1[6]-pos[6]-1);          strncpy(rec[i].status,      (line+pos[7]+1),pos1[7]-pos[7]-1);          strncpy(rec[i].exploer_info,(line+pos[8]+1),pos1[8]-pos[8]-1);          i++;     }     fclose(fp);//关闭文件      int *a = new int[i],*b = new int[i];// 统计数组申请     memset(a,0,sizeof(int)*i);  //数组初始化     memset(b,0,sizeof(int)*i);     for(j=0;j<i;j++){       if(strcmp(rec[j].method,\"GET\")==0)n++;//GET请求统计 第二题       for(k=0;k<i;k++){           if(strcmp(rec[j].status,rec[k].status)==0) b[j]++;//状态码进行分析统计 第三题           if(strcmp(rec[j].ip,rec[k].ip)==0) a[j]++;  //分析统计访问最多的客户IP地址 第四题       }     }     printf(\"输出GET请求所占比例:%6.3f\\n\",1.0*n/i);//输出GET请求所占百分比;     max = a[0];k=0;     for(j=0;j<i;j++){         printf(\"rec[%d].status=%s:%6.3f\\n\",j,rec[j].status,b[j]*1.0/i);//输出所有访问状态码的比率         if(max<a[j]) {max = a[j];k=j;} // 找到访问最多的客户IP地址次数 第四题     }     printf(\"访问最多的客户IP地址:%s,共访问:%d次\\n\",rec[k].ip,a[k]);//输出访问最多的客户IP地址及次数 第四题      delete [] a; //释放数组     delete [] b;        //下面这段输出看看读入到rec[i]中的内容是否达预期目标,等程序调试完毕，这段可以删除： //例子开始：     for(j=0;j<i;j++)      {        printf(\"\\n%s     %s     %s    %s    %s    %s     %s    %s     %s   \\n\",        rec[j].method,rec[j].ip,    rec[j].protocol,        rec[j].time,  rec[j].add,   rec[j].page,        rec[j].port,  rec[j].status,rec[j].exploer_info);      } //例子结束          return 0; }  //open file successful! //输出GET请求所占比例: 0.818 //rec[0].status=200: 0.909 //rec[1].status=200: 0.909 //rec[2].status=200: 0.909 //rec[3].status=412: 0.091 //rec[4].status=200: 0.909 //rec[5].status=200: 0.909 //rec[6].status=200: 0.909 //rec[7].status=200: 0.909 //rec[8].status=200: 0.909 //rec[9].status=200: 0.909 //rec[10].status=200: 0.909 //访问最多的客户IP地址:233.102.79.50,共访问:11次  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //POST     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         412     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //POST     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko //请按任意键继续. . .", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "只剩第6题，供参考：//题目要求是实现下面6个功能，我现在能写出的代码能实现前两个功能，和老师沟通过后，我代码存在的问题应该 //是没能把文件中信息存储在结构体中，我在代码中使用了strncpy_s函数，想把信息复制到结构体items中，但是后面 //的功能实现不了，已经卡在这里好久了，还是没有进步，能看看错在哪了吗？ //（1）对日志文件进行列表读取和写入； //（2）计算日志文件中GET类型请求方式的占比； //（3）对访问状态码进行分析与统计，计算所有访问状态码的比率； //（4）分析访问最多的客户IP地址，并统计其访问次数； //（5）分析常用密码，并统计密码使用次数； //（6）用户输入时间段，查找该时间段内访问记录并输出到文件中   #include<stdio.h> #include<string.h>  struct record       //结构体 {     char method[255];  //[GET POST]     char ip[255];      //[233.102.79.50]     char protocol[255];//[HTTP/1.1]     char time[255];    //[2021-01-18 08:57:44]     char add[255];     //[http://39.99.254.200:8810]     char page[255];    //[/admin/login.jsp]     char port[255];    //[passwd=admin123&&password=123456]     char status[255];  //[403]     char exploer_info[255];//[Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko] };  struct record rec[2048];//文件有2048行  int main(void) {      char line[1024];     int  i=0,j,j_pos,j_pos1,pos[9],pos1[9];      FILE *fp;     fp=fopen(\"access.log\",\"r+\");//打开文件     if(!fp){         printf(\"false\\n\");         return -1;     }     else{         printf(\"open file successful!\\n\");     }     while((fgets(line,1024,fp))!=NULL){          j_pos=0,j_pos1=0;          for(j=0;j<strlen(line);j++){             if(line[j]=='[') {pos[j_pos]=j;  j_pos++;} //'[' 位置标记             if(line[j]==']') {pos1[j_pos1]=j;j_pos1++;}//']' 位置标记          }          strncpy(rec[i].method,      (line+pos[0]+1),pos1[0]-pos[0]-1);          strncpy(rec[i].ip,          (line+pos[1]+1),pos1[1]-pos[1]-1);          strncpy(rec[i].protocol,    (line+pos[2]+1),pos1[2]-pos[2]-1);          strncpy(rec[i].time,        (line+pos[3]+1),pos1[3]-pos[3]-1);          strncpy(rec[i].add,         (line+pos[4]+1),pos1[4]-pos[4]-1);          strncpy(rec[i].page,        (line+pos[5]+1),pos1[5]-pos[5]-1);          strncpy(rec[i].port,        (line+pos[6]+1),pos1[6]-pos[6]-1);          strncpy(rec[i].status,      (line+pos[7]+1),pos1[7]-pos[7]-1);          strncpy(rec[i].exploer_info,(line+pos[8]+1),pos1[8]-pos[8]-1);          i++;     }     fclose(fp);//关闭文件      char buf[255],bufk[255];     int n=0,m=0,k,q,max_ip,max_pw;     int *a = new int[i],*b = new int[i],*p = new int[i];//统计数组     memset(a,0,sizeof(int)*i);  //数组初始化     memset(b,0,sizeof(int)*i);     memset(p,0,sizeof(int)*i);     for(j=0;j<i;j++){       if(strcmp(rec[j].method,\"GET\")==0)n++;//GET请求统计    第2题       if(strlen(rec[j].port)>0)m++;         //统计使用密码登录的次数 第5题       sscanf(rec[j].port,\"%*[^&&]&&%[^\\n]\",buf); //取密码字符段       for(k=0;k<i;k++){                                                                                                            if(strcmp(rec[j].status,rec[k].status)==0) b[j]++;//状态码进行分析统计 第3题           if(strcmp(rec[j].ip,    rec[k].ip)==0)     a[j]++;//分析统计访问最多的客户IP地址 第4题           sscanf(rec[k].port,\"%*[^&&]&&%[^\\n]\",bufk);           if(strcmp(buf,bufk)==0&&(strlen(rec[j].port)>0)&&(strlen(rec[k].port)>0))p[j]++;// 分析常用密码  第5题       }     }     printf(\"GET请求所占比例:%6.3f\\n\",1.0*n/i);//输出GET请求所占百分比; 第2题     max_ip = a[0];max_pw = p[0];k=0;q=0;     for(j=0;j<i;j++){         printf(\"rec[%d].status=%s:%6.3f\\n\",j,rec[j].status,b[j]*1.0/i);//输出所有访问状态码的比率 第3题         if(max_ip<a[j]) {max_ip=a[j];k=j;}    // 找到访问最多次数的客户IP 第4题         if(max_pw<p[j]) {max_pw=p[j];q=j;}    // 找到使用次数最多的密码   第5题     }     printf(\"访问最多的客户IP地址:%s,共访问:%d次.\\n\",rec[k].ip,a[k]);//输出访问最多的客户IP地址及次数 第4题     sscanf(rec[q].port,\"%*[^&&]&&%[^\\n]\",buf);     printf(\"常用密码:%s,被用了%d次.在%d次登录中，%d次用密码登录.\\n\",buf,max_pw,i,m); //rec[q].port 第5题     delete [] a;delete [] b;delete [] p;     //释放数组   //下面这段输出看看读入到rec[i]中的内容是否达预期目标,等程序调试完毕，这段可以删除，也可改成第6题的代码 //例子开始：     for(j=0;j<i;j++)      {        printf(\"\\n%s     %s     %s    %s    %s    %s     %s    %s     %s   \\n\",        rec[j].method,rec[j].ip,    rec[j].protocol,        rec[j].time,  rec[j].add,   rec[j].page,        rec[j].port,  rec[j].status,rec[j].exploer_info);      } //结束          return 0; }  //open file successful! //GET请求所占比例: 0.818 //rec[0].status=200: 0.909 //rec[1].status=200: 0.909 //rec[2].status=200: 0.909 //rec[3].status=412: 0.091 //rec[4].status=200: 0.909 //rec[5].status=200: 0.909 //rec[6].status=200: 0.909 //rec[7].status=200: 0.909 //rec[8].status=200: 0.909 //rec[9].status=200: 0.909 //rec[10].status=200: 0.909 //访问最多的客户IP地址:233.102.79.50,共访问:9次. //常用密码:password=123456,被用了6次.在11次登录中，8次用密码登录.  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123455    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //POST     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         412     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123466    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.51     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //POST     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.80.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko //请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这是调试成功的把文件信息转存到结构体中的代码，并做了第二题。看了楼主上面的代码，感觉还是概念没搞清，建议仔细研究下面的代码，搞懂了，其余几题再往里加功能，无非就是对数组数据的统计分析，供参考：//题目要求是实现下面6个功能，我现在能写出的代码能实现前两个功能，和老师沟通过后，我代码存在的问题应该 //是没能把文件中信息存储在结构体中，我在代码中使用了strncpy_s函数，想把信息复制到结构体items中，但是后面 //的功能实现不了，已经卡在这里好久了，还是没有进步，能看看错在哪了吗？ //（1）对日志文件进行列表读取和写入； //（2）计算日志文件中GET类型请求方式的占比； //（3）对访问状态码进行分析与统计，计算所有访问状态码的比率； //（4）分析访问最多的客户IP地址，并统计其访问次数； //（5）分析常用密码，并统计密码使用次数； //（6）用户输入时间段，查找该时间段内访问记录并输出到文件中   #include<stdio.h> #include<string.h>  struct record       //结构体 {     char method[255];  //[GET POST]     char ip[255];      //[ip]     char protocol[255];//[HTTP/1.1]     char time[255];    //[2021-01-18 08:57:44]     char add[255];     //[http://39.99.254.200:8810]     char port[255];    //[/admin/login.jsp]     char page[255];    //[passwd=admin123&&password=123456]     char status[255];  //[403]     char exploer_info[255];//[Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko] };  struct record rec[2048];//文件有2048行  int main(void) {      char line[1024];     int  i=0,n=0,j,j_pos,j_pos1,pos[9],pos1[9];      FILE *fp;     fp=fopen(\"access.log\",\"r+\");//打开文件     if(!fp){         printf(\"false\\n\");         return -1;     }     else{         printf(\"open file successful!\\n\");     }     while((fgets(line,1024,fp))!=NULL){          j_pos=0,j_pos1=0;          for(j=0;j<strlen(line);j++){             if(line[j]=='[') {pos[j_pos]=j;  j_pos++;} //'[' 位置标记             if(line[j]==']') {pos1[j_pos1]=j;j_pos1++;}//']' 位置标记          }          strncpy(rec[i].method,      (line+pos[0]+1),pos1[0]-pos[0]-1);          strncpy(rec[i].ip,          (line+pos[1]+1),pos1[1]-pos[1]-1);          strncpy(rec[i].protocol,    (line+pos[2]+1),pos1[2]-pos[2]-1);          strncpy(rec[i].time,        (line+pos[3]+1),pos1[3]-pos[3]-1);          strncpy(rec[i].add,         (line+pos[4]+1),pos1[4]-pos[4]-1);          strncpy(rec[i].page,        (line+pos[5]+1),pos1[5]-pos[5]-1);          strncpy(rec[i].port,        (line+pos[6]+1),pos1[6]-pos[6]-1);          strncpy(rec[i].status,      (line+pos[7]+1),pos1[7]-pos[7]-1);          strncpy(rec[i].exploer_info,(line+pos[8]+1),pos1[8]-pos[8]-1);          i++; //文件行数     }     fclose(fp);//关闭文件       for(j=0;j<i;j++){       if(strcmp(rec[j].method,\"GET\")==0)n++;//GET请求统计 第二题     }     printf(\"输出GET请求所占比例：%f\\n\",1.0*n/i);//输出日志文件内容并统计计数,输出所占百分比;        //下面这段输出看看读入到rec[i]中的内容是否达预期目标,等程序调试完毕，这段可以删除： //例子开始：     for(j=0;j<i;j++)      {        printf(\"\\n%s     %s     %s    %s    %s    %s     %s    %s     %s   \\n\",        rec[j].method,rec[j].ip,    rec[j].protocol,        rec[j].time,  rec[j].add,   rec[j].page,        rec[j].port,  rec[j].status,rec[j].exploer_info);      } //结束          return 0; }  //open file successful! //输出GET请求所占比例：0.818182  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //POST     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         412     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp         200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //POST     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko  //GET     233.102.79.50     HTTP/1.1    2021-01-18 08:57:44    http://39.99.254.200:8810    /admin/login.jsp     passwd=admin123&&password=123456    200     Mozilla/5.0 (Windows NT 10.0: WOW64: Trident/7.0: rv:11.0) like Gecko //请按任意键继续. . .", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "课设就自己加油吧", "referer": "user-0"}]}
{"question": "文件信息有很多，怎么存到结构体里呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "内容很多，建议分类，并且找到信息类型一样的，并在结构体里定义对应的元素，根据信息量的条数来定结构体变量的大小或结构体数组的大小", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen(\"data.txt\",\"r\");     if (NULL==f) {         printf(\"Can not open file data.txt!\\n\");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,\"NAME: %31[^\\n]\",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,\"DIMENSION: %d\",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,\"DATA\\n\")) st=3;         } else if (st==3) {             if (3==sscanf(ln,\"%d%d%d\",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf(\"s.NAME=[%s]\\n\",s.NAME);     printf(\"s.DIMENSION=%d\\n\",s.DIMENSION);     for (i=0;i<n;i++) {         printf(\"s.DATA[%d].NO,X,Y=%d,%d,%d\\n\",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "早些年有个syslog-ng是用来日志入库的，近几年流行啥就不知道了，没有跟踪。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "看到楼主仍然坚持嵌套定义结构体（这是个编译错误），就没兴趣继续看下去了。  一般地说，要在结构体数组和文件之间互动，还是使用二进制文件方便一些。  对于楼主面临的分析日志，由于文件长度不定，另外全部读入内存也没有算法上的必要，因此建议还是用我的风格，读一行统计一行，扔掉，读下一行。 这样一来，用不用结构体不是关键，或者说结构体就多余了。  最后，如果是工作需要，那么建议找个开源软件代替syslog，日志入库，你要分析什么的可以上SQL，很香的。", "referer": "user-0"}]}
{"question": "C语言学习路线图", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 5 楼 ctrigger 的回复:[quote=引用 4 楼 赵4老师 的回复:]计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 基本赞同。不过个人感觉：DOS命令 ==》SHELL，更靠谱一点。[/quote] 不写“DOS命令”，怎么凡尔赛文学地显摆我学DOS命令时，Linux还没诞生，Unix或FreeBSD啥的还没进入中国呢？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 4 楼 赵4老师 的回复:计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 基本赞同。不过个人感觉：DOS命令 ==》SHELL，更靠谱一点。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "30%靠就记忆，70%靠百度", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "看了下基本都是从看书和从事方向的方法，都很对 说下从编程技巧方面的方法，可以多尝试去看下算法题并用C语言实现，会有很好的效果", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 7 楼 早打大打打核战争 的回复:我听说过80年代中科院已经引进xenix（sco unix的PC修改版），只能说当时还没进入西电~  可惜我当年没资格进中科院啊！", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "我听说过80年代中科院已经引进xenix（sco unix的PC修改版），只能说当时还没进入西电~", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "建议从读书，或者观看视频进行学习，因为这样学习会更加系统。 选择经典数据《C程序设计语言》、《C和指针》、《C陷阱与缺陷》，先从基础书开始，到进阶，如果刚开始有看不懂的，可以浏览一下跳过，后面再回头看的。 C语言学习后，如果走嵌入式路线，就需要学习单片机编程，了解汇编，计算机基础等。单片机比较方便是STM32起步，资源比较多。后续是单片机跑实时系统freeRTOS系统之类的。接着是linux系统了，linux也分为驱动开发，系统移植，应用开发几块。 如果走的是纯软路线，就需要学习C++或者C#了，这时候也有是linux系统还是windows系统分，总之需要先规划好，必须系统学习，博客之类只能作为辅助学习用。", "referer": "user-0"}, {"cid": "10", "user": "user-8", "content": "谢谢提供思路。能进一步细化吗", "referer": "user-0"}]}
{"question": "double类型用scanf函数时格式符%f和%lf不一样结果？有没有懂得解释一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf: %f - float,  %lf - double printf 在 C89 里 %f， float 类型会自动转为 double, C89里面是没有 %lf 的。  https://en.cppreference.com/w/c/io/fscanf https://en.cppreference.com/w/c/io/fprintf", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "%f是float单精度，%lf是double双精度的，所以计算结果不同", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "double就是要使用 %lf的   float使用 %f 不要纠结为什么。  想想double使用 %d能对吗？ 你现在的问题就  类似  “ double类型变量，使用scanf函数时格式符%d，为什么错误了？”  没有为什么，就是用错了", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "#include <stdio.h> int main() {     float   f=1.234567f;     double lf=1.234567890123456;     printf(\"%f ,%.15lf\\n\",f,lf);//1.234567 ,1.234567890123456     printf(\"%f ,%.15f \\n\",f,lf);//1.234567 ,1.234567890123456     printf(\"%lf,%.15lf\\n\",f,lf);//1.234567,1.234567890123456      char s[]=\"1.234567890123456\";     f =0.0f;sscanf(s,\"%f\" ,& f); printf(\"%f    \\n\", f);//1.234568     lf=0.0 ;sscanf(s,\"%lf\",&lf); printf(\"%.15lf\\n\",lf);//1.234567890123456     lf=0.0f;sscanf(s,\"%f\" ,&lf); printf(\"%.15lf\\n\",lf);//0.000000000000000     f =0.0 ;sscanf(s,\"%lf\",& f); printf(\"%f    \\n\", f);//70.175720      return 0; } //根据以上运行结果可得：printf时，%lf和%f可以混用，scanf时不行。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "https://blog.csdn.net/weixin_44997886/article/details/102812153 参考", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "你定义的double，scanf就得用lf，浮点数本就很麻烦，看堆栈调试", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "虽然都是浮点数，%f代表单精度浮点型数据（float），%lf代表双精度浮点型数据（double），怎么可能一样呢。单精度浮点数有效数字保证6位，部分7位，双精度浮点数有效数字保证15位，部分16位。单精度浮点的表示范围：-3.40E+38 ~ +3.40E+38，双精度浮点的表示范围：-1.79E+308 ~ +1.79E+308", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "既然测试了，验证了，那说明别人说的可能局限于编译器，要么就是别人说的有问题～", "referer": "user-0"}, {"cid": "10", "user": "user-7", "content": "double输入的是8字节的，float是4字节的。输出用%f没问题，可能是类型提升了。", "referer": "user-0"}]}
{"question": "请问一下 我想要得到一个数组中的最高分对应的下标值，在我这个函数的基础上要怎么改呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "再定义一个用于存储最大值下表的变量，比如max_idx，初始化为0（因为x = score[0]);再更新x的时候，同时给max_idx赋值对应的i;", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：int LinSearch(int score[],int n) {     int i,x,max=0;     x = score[0];     for(i=1;i<n;i++)     {        if(score[i]>x)        {           x   = score[i];           max = i;        }     }     printf(\"最高分：%d\\n\",x);     return max; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "返回x 的值就行了 如果你还需要返回对应的值 可以返回一个结构，或者用指针传入保存下标的变量 int LinSearch(int score[],int n,int * ret_index) { //原来的代码  *ret_index=x; return i; }", "referer": "user-0"}]}
{"question": "请问一下 这个程序是输出一组数组中互换最高分和最低分之后的数组，可是我这样写输出的还是原来输入的数组的顺序，请问要怎么改呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 1 楼 user-3 的回复:供参考：void MaPrintScore(int score[],int n) {     int i,term,a=score[0],b=score[0],max=0,min=0;     for(i=0;i<n;i++)     {         if(score[i]>a)         {            a   = score[i];            max = i;         }         if(score[i]<b)         {            b   = score[i];            min = i;         }     }     term       = score[max];     score[max] = score[min];     score[min] = term; }    static void swap(int *a, int *b);  void MaPrintScore(int score[],int n) {     //int i,term,a=score[0],b=score[0],max=0,min=0;     int i, /*term,*/ max, min, max_i, min_i;      max = min = score[0];     max_i = min_i = 0;  //_i equal index     //for(i=0;i<n;i++)     for(i=1;i<n;i++)     {         if(score[i] > max)         {            max   = score[i];            max_i = i;         }         if(score[i] < min)         {            min   = score[i];            min_i = i;         }     }     if (max_i != min_i)         swap(&score[max_i], &score[min_i]);     /*     term       = score[max_i];     score[max_i] = score[min_i];     score[min_i] = term;     */ }  static void swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }  供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：void MaPrintScore(int score[],int n) {     int i,term,a=score[0],b=score[0],max=0,min=0;     for(i=0;i<n;i++)     {         if(score[i]>a)         {            a   = score[i];            max = i;         }         if(score[i]<b)         {            b   = score[i];            min = i;         }     }     term       = score[max];     score[max] = score[min];     score[min] = term; }", "referer": "user-0"}]}
{"question": "结构体的内存存放是不是与编译器有关？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位大佬，明白了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "打印地址，建议用%p，不建议用%lld，因为16进制看地址比较方便，第二个是%d是有符号数，而地址是无符号类型的数据。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "结构体对齐并不是简单的相加，具体规范百度", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "内存对齐啊，64位应该是按8字节对齐的 vs的话可以用#pragma pack (4) ，修改它 gcc 这个语句是否管用，我没试过。 gcc好像可以用__attribute__ ((aligned (n)))，我没有gcc，没法试", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "https://blog.csdn.net/liran2019/article/details/106759881?ops_request_misc=&request_id=&biz_id=102&utm_term=%E7%BB%93%E6%9E%84%E4%BD%93%E5%AF%B9%E9%BD%90%E5%8E%9F%E5%88%99&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-7-106759881.pc_search_result_hbase_insert", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "结构体对齐的原因，参考：https://blog.csdn.net/qianghaohao/article/details/51011418?ops_request_misc=&request_id=&biz_id=102&utm_term=%E7%BB%93%E6%9E%84%E4%BD%93%E5%AF%B9%E9%BD%90%E5%8E%9F%E5%88%99&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-8-51011418.pc_search_result_hbase_insert", "referer": "user-0"}]}
{"question": "c语言 指针题，大神求解！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 12 楼 xian0-666的回复:[quote=引用 11 楼 weixin_45544561 的回复:][quote=引用 3 楼 xian0-666的回复:]*(a+i)表示第i个元素，*(*(a+i))就表示第i个元素的地址了。a[p-a]看着怪怪的但是应该没有问题为a【0】 额额，c项没有问题的。[/quote]  我知道语法是没有问题的，但是这样用也太多此一举了[/quote] 嗯，是有一点。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 11 楼 weixin_45544561 的回复:[quote=引用 3 楼 xian0-666的回复:]*(a+i)表示第i个元素，*(*(a+i))就表示第i个元素的地址了。a[p-a]看着怪怪的但是应该没有问题为a【0】 额额，c项没有问题的。[/quote]  我知道语法是没有问题的，但是这样用也太多此一举了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 xian0-666的回复:*(a+i)表示第i个元素，*(*(a+i))就表示第i个元素的地址了。a[p-a]看着怪怪的但是应该没有问题为a【0】 额额，c项没有问题的。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "感觉找到了", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 gouyanfen的回复:选B *是读取地址的值 B中 *(a+i)就己经取得了正确的值了，最外括号的*再读取a[i]的值的地址 C选项中 a[p-a]是可以的但是怎么和i没有关系，怎么能知道要取第i个索引的值呢? 是你输入错了吗 a[p-a+i]? 我发现，没有int* p=a这句 d选项也可以引用。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 gouyanfen的回复:选B *是读取地址的值 B中 *(a+i)就己经取得了正确的值了，最外括号的*再读取a[i]的值的地址 C选项中 a[p-a]是可以的但是怎么和i没有关系，怎么能知道要取第i个索引的值呢? 是你输入错了吗 a[p-a+i]? 嗯嗯，懂了懂了！谢谢！", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 6 楼 weixin_45544561 的回复:[quote=引用 1 楼 gouyanfen的回复:]选B *是读取地址的值 B中 *(a+i)就己经取得了正确的值了，最外括号的*再读取a[i]的值的地址 C选项中 a[p-a]是可以的但是怎么和i没有关系，怎么能知道要取第i个索引的值呢? 是你输入错了吗 a[p-a+i]? B项可以改为：*(&(*(a+i)))吗？[/quote]当然可以的", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 gouyanfen的回复:选B *是读取地址的值 B中 *(a+i)就己经取得了正确的值了，最外括号的*再读取a[i]的值的地址 C选项中 a[p-a]是可以的但是怎么和i没有关系，怎么能知道要取第i个索引的值呢? 是你输入错了吗 a[p-a+i]? B项可以改为：*(&(*(a+i)))吗？", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 2 楼 qzjhjxj的回复:选B A. p[i]              等价于  a[i] B. *(*(a+i))      *(a+i)) 等价于 a[i]  ,再对a[i] 取值 *a[i] 就错误了 C. a[p-a]         p=a ,p-a=0,a[p-a] = a[0]=0，是能取到数组a中的元素的 D. *(&a[i])      &是取地址符，等价于 *（a+i），是正确的 懂了，懂了。原来这样！谢谢！", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "额，原来是这样。懂了，懂了。谢谢！", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "*(a+i)表示第i个元素，*(*(a+i))就表示第i个元素的地址了。a[p-a]看着怪怪的但是应该没有问题为a【0】", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "选B A. p[i]              等价于  a[i] B. *(*(a+i))      *(a+i)) 等价于 a[i]  ,再对a[i] 取值 *a[i] 就错误了 C. a[p-a]         p=a ,p-a=0,a[p-a] = a[0]=0，是能取到数组a中的元素的 D. *(&a[i])      &是取地址符，等价于 *（a+i），是正确的", "referer": "user-0"}, {"cid": "14", "user": "user-4", "content": "选B *是读取地址的值 B中 *(a+i)就己经取得了正确的值了，最外括号的*再读取a[i]的值的地址 C选项中 a[p-a]是可以的但是怎么和i没有关系，怎么能知道要取第i个索引的值呢? 是你输入错了吗 a[p-a+i]?", "referer": "user-0"}, {"cid": "15", "user": "user-5", "content": "A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}]}
{"question": "运行结果不对，也不能调试，能帮我看看怎么回事吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-3的回复:先改错，能通过了编译再说。 不要非法嵌套定义结构体。 你的status既然改成了int，就不要再套用strncpy处理它。否则就改回字符数组。 嗯嗯，谢谢指点", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:    //printf(\"%d\",1.0*arr[i]++/i);     printf(\"%lf\",1.0*arr[i]++/i); 对于浮点数值，用%d输出是有问题的。 好的，已经改过来了，谢谢啦", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "//printf(\"%d\",1.0*arr[i]++/i);     printf(\"%lf\",1.0*arr[i]++/i); 对于浮点数值，用%d输出是有问题的。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "先改错，能通过了编译再说。 不要非法嵌套定义结构体。 你的status既然改成了int，就不要再套用strncpy处理它。否则就改回字符数组。", "referer": "user-0"}]}
{"question": "c语言怎样做一个二手商品买卖系统。求大佬解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "做网站的话还是c#或者java吧", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "系统有简单有复杂，就看你想做怎样的界面了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 user-3的回复:[quote=引用 1 楼 user-3 的回复:]这种系统适合做成一个网站，显然C语言不是最佳选择！ 另外百度一下可以发现确实有别人做的，有的虽然不能免费下载但是可以观看，也有C语言的版本，但是作业还是自己完成的好[/quote] 大佬救救孩子", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 user-3的回复:[quote=引用 1 楼 user-3 的回复:]这种系统适合做成一个网站，显然C语言不是最佳选择！ 另外百度一下可以发现确实有别人做的，有的虽然不能免费下载但是可以观看，也有C语言的版本，但是作业还是自己完成的好[/quote] 😲就是卡在充值这里好久了，实在没辙了😭😭", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 1 楼 user-3 的回复:这种系统适合做成一个网站，显然C语言不是最佳选择！ 另外百度一下可以发现确实有别人做的，有的虽然不能免费下载但是可以观看，也有C语言的版本，但是作业还是自己完成的好", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "这种系统适合做成一个网站，显然C语言不是最佳选择！", "referer": "user-0"}]}
{"question": "请问一下 为什么左边的for循环可以输出正确的count，而换成右边的嵌套式循环就错了，两者的意思不是一样的嘛？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "首先，循环不是想嵌套就嵌套的，嵌套执行和执行两次结果完全不同；其次，你的嵌套循环都用的同一个变量i，肯定会出错", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "两层循环用同一个变量，那么当外层循环i=0时，内层循环的i就已经i == n了，所以外层循环只会执行一次。但是score[i] > aver这句的i已经是i == n了，所以是越界访问了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "就像楼上说的，你用两个相同的循环变量的意义不明白。如果你硬要都用i，那么最外层循环只循环一次，i就不满足条件了。 如果是笔误，（比如换成j）就循环而言，是不一样的。左边循环2n次，右边循环n*n次。s最终值是求和的n倍", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "同一个i，同一个值。 你不觉得有点乱么？", "referer": "user-0"}]}
{"question": "大家帮我看看我这深搜的方法有没有错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "题目是小于20，我用21不会越界的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 m0_55067373 的回复:找到问题了，是障碍物的设定有问题，下标应该不会越界，因为我只往右和往下搜索，而且超过这个范围就会return 问题是x,y输入不能保证不大于21", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "找到问题了，是障碍物的设定有问题，下标应该不会越界，因为我只往右和往下搜索，而且超过这个范围就会return", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "下标有机会越界； 你输入的y用得有点少。", "referer": "user-0"}]}
{"question": "代码优化", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "要那样输出的话可以参考这个：  #include <stdio.h> #include <math.h> int factorsum(int n, int* fac)  //除了计算因子和，还在数组fac里给出因子列表，以-1表示结束 { \tint i, sum = 1, k, *p = fac + 1, half[40], j = 0; \tif (n == 1)return 0; \tfor (i = 2; i <= (int)(sqrt(n) + 0.001); i++)  //从2到根号n测试 \t{ \t\tif (n%i == 0)  //每次整除产生两个因子 \t\t{ \t\t\tsum += (*p++ = i); //小的那个直接升序记入数组 \t\t\tif (i < (k=n/i))  //除非 i==k 这次只产生1个因子 \t\t\t\tsum += (half[j++] = k);  //大的那个降序另存 \t\t} \t} \twhile (--j >= 0) //把较大的一半因子逆序抄过去 \t{ \t\t*p++ = half[j]; \t} \t*p = -1;  //表示结束 \treturn sum; } void PrintPN(int m, int n) { \tint i, fac[70] = { 1 }; \tfor (i = m; i <= n; i++) \t{ \t\tif (i == factorsum(i, fac)) \t\t{ \t\t\tint *p = fac + 1; \t\t\tprintf(\"%d=1\", i); \t\t\twhile (*p > 0) \t\t\t{ \t\t\t\tprintf(\"+%d\", *p++); \t\t\t} \t\t\tprintf(\"\\n\"); \t\t} \t} } int main() { \tint m, n; \tscanf(\"%d%d\", &m, &n); \tPrintPN(m, n); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "判断是否为完数的函数再优化一点点：int factorsum( int n)//判断是否为完数 {     int k=2,s=1;     while(k <= n/2){          if(n%k==0)s+=k;          k++;     }     if(s==n && n!=1) return 1;     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h>  int factorsum( int number ); void PrintPN( int m, int n );  static void swap(int *a, int *b); static void print_perfect(int m, int n);  int main() {     int m, n;      scanf(\"%d %d\", &m, &n);      if (m > n) {         swap(&m, &n);     }      print_perfect(m, n);     /*     if ( factorsum(m) == m ) printf(\"%d is a perfect number\\n\", m);     if ( factorsum(n) == n ) printf(\"%d is a perfect number\\n\", n);     PrintPN(m, n);     */     return 0; }  static void swap(int *a, int *b) {     int tmp;      tmp = *a;     *a = *b;     *b = tmp; }  static void print_perfect(int m, int n) {     int i;      for (i = m; i < n; i++) {         if (i == 1)             continue;         if (factorsum(i)) {             printf(\"%d is a perfect number!\\n\", i);         }     } }   int factorsum( int number )  //判断是否为完数 {     int i;     int sum = 1;       for (i = 2; i < number / 2 + 1; i++) {         if (number % i == 0)             sum += i;     }     if (sum == number)         return 1;      return 0;     /*     int i,j;     int m = 1;     int n,num = 0;     int a[100] = {0};     a[0] = 1;     if(number == 0)         return -1;     if(number == 1)         return 1;     for(i = 2; i < number; i ++ )     {         for(j = i + 1; j < number; j ++)         {             if(i * j == number)             {                 a[m] = i;                 m ++;                 a[m] = j;                 m ++;             }          }     }     for(n = 0; n < 100; n ++)     {         if(a[n] == 0)             break;         num = num + a[n];     }     if(num == number)         return num;     else         return 0;     */ }  void PrintPN( int m, int n )   //找出m到n之间的完数 {     int q;     int i,j;     int num = 0;      for(int k = m; k <= n; k++)     {         if(factorsum(k) == k)         {             num = 1;             int p = 1;             int a[100] = {0};             a[0] = 1;             for(i = 2; i < k; i ++ )             {                 for(j = i + 1; j < k; j ++)                 {                     if(i * j == k)                     {                         a[p] = i;                         p ++;                         a[p] = j;                         p ++;                      }                 }             }             //排序             int b;             for(b = 0; a[b] != 0; b++)             {                 for(int c = b + 1; a[c] != 0; c ++)                 {                     if(a[b] > a[c])                     {                         int key;                         key = a[b];                         a[b] = a[c];                         a[c] = key;                     }                  }              }             printf(\"%d = \",k);             for( q = 0; q < 100; q ++)             {                 if(a[q] == 0)                 {                     printf(\"\\n\");                     break;                 }                 if(q == 0)                     printf(\"%d\",a[q]);                 else                     printf(\" + %d\",a[q]);              }         }     }     if(num == 0)         printf(\"No perfect number\\n\");  } 供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "修正楼上第10行：for(int i=m;i<=n;i++){", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "楼主考虑的太复杂了，供参考：#include <stdio.h> int factorsum( int n );//判断是否为完数  int main() {     int m, n;     scanf(\"%d %d\", &m, &n);     if(m<=0 || n>10000) return -1;      for(int i=m;i<n;i++){        if(factorsum(i))printf(\"%d is a perfect number\\n\", i);     }          return 0; }   int factorsum( int n) {     int k=1,s=0;     while(k <= n/2){          if(n%k==0) s+=k;          k++;     }     if(s==n) return 1;     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "随便搜个对正整数分解因数的代码", "referer": "user-0"}]}
{"question": "同样一份.c文件，我在Linux上编译成.a文件执行正常，在windows编译成.exe文件，执行前面正常，后面无结果输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "是不是程序处理的数据文件有格式上的问题？明显左侧的Windows端有个 WARNING ： END OF DATA IN FILE。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "调试，看看到具体哪一部，结果不一致。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "嗯，收到，确实挺奇怪。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "左侧为windows端，后面的文件无数据写入，右侧为ubuntu，程序执行正常", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "windows打开文件默认文本模式，linux打开文件默认二进制模式。  不要把 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"}]}
{"question": "求大佬帮忙看一下错在哪里了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "心急吃不了热豆腐，写代码，你得一步一步来，先实现主要的功能并验证，然后再加入进一步的功能，调试也是一样的。你把提供的代码编译运行下，看看能不能实现把文件中的内容搬到结构体数组中，如果能再往里加你想要的功能，如不能你得找出错误并修正它直到让它听你的：#include<stdio.h> #include<string.h>  struct record       //结构体 {     char method[255];     char ip[255];     char protocol[255];     char time[255];     char add[255];     char port[255];     char page[255];     char status[255];     char exploer_info[255]; };  int main(void) {     FILE *fp;     fp=fopen(\"access.log\",\"r+\");//打开文件     if(!fp)       {         printf(\"false\\n\");         return -1;//直接返回       }     else{         printf(\"true\\n\");     }//判断文件是否成功打开      char line[2048];     int  i=0,x,j,j_pos,j_pos1;//int  lines=0; //这个变量没用到     int  pos[9],pos1[9];     char s='[', s1=']';      struct record rec[4096];//预设文件有4096行      while((fgets(line,2048,fp))!=NULL)       {          x=strlen(line);          j_pos=0,j_pos1=0;          for(j=0;j<x;j++)           {             if(line[j]==s)//'['  开始位置               {                 pos[j_pos]=j;                 j_pos++;               }             if(line[j]==s1)//']' 结束位置               {                 pos1[j_pos1]=j;                 j_pos1++;               }           }          //strncpy_s(char * str2, int size2, char * str1, int size1);//这里char * str1, int size1 两个值楼主自己调试          strncpy_s(rec[i].method,      sizeof(rec[i].method),      line+pos[0]+1,pos1[0]-pos[0]-1);          strncpy_s(rec[i].ip,          sizeof(rec[i].ip),          line+pos[1]+1,pos1[1]-pos[1]-1);          strncpy_s(rec[i].protocol,    sizeof(rec[i].protocol),    line+pos[2]+1,pos1[2]-pos[2]-1);          strncpy_s(rec[i].time,        sizeof(rec[i].time),        line+pos[3]+1,pos1[3]-pos[3]-1);          strncpy_s(rec[i].add,         sizeof(rec[i].add),         line+pos[4]+1,pos1[4]-pos[4]-1);          strncpy_s(rec[i].page,        sizeof(rec[i].page),        line+pos[5]+1,pos1[5]-pos[5]-1);          strncpy_s(rec[i].port,        sizeof(rec[i].port),        line+pos[6]+1,pos1[6]-pos[6]-1);          strncpy_s(rec[i].status,      sizeof(rec[i].status),      line+pos[7]+1,pos1[7]-pos[7]-1);          strncpy_s(rec[i].exploer_info,sizeof(rec[i].exploer_info),line+pos[8]+1,pos1[8]-pos[8]-1);          i++;       }     fclose(fp);//关闭文件      //全部读入rec[i]数组中，接下去处理的代码加入。     //举个例子：下面这段输出看看读入到rec[i]中的内容：     for(j=0;j<i;j++)      {        printf(\"%s %s %s %s %s %s %s %s %s\\n\",        rec[j].method,rec[j].ip,    rec[j].protocol,        rec[j].time,  rec[j].add,   rec[j].page,        rec[j].port,  rec[j].status,rec[j].exploer_info);      }      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:引用while(fgets(line,2048,fp)!=NULL)  {   puts(line);   n++;   if(strncmp(line,\"[GET]\",5)==0)   {    m++;   }//比较两字符串，相等时strncmp函数值返回0,计数   }  while((fgets(line,2048,fp))!=NULL)  {   x=strlen(line); 这里连着两个while{}循环体，第一个while循环结束，文件指针已经指向文件结束了，第二个while不会进入了。 嗷嗷，谢谢谢谢，我知道了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用int fclose(FILE *fp);//关闭文件 这也不是正确的关闭文件语句。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用while(fgets(line,2048,fp)!=NULL)  {   puts(line);   n++;   if(strncmp(line,\"[GET]\",5)==0)   {    m++;   }//比较两字符串，相等时strncmp函数值返回0,计数   }  while((fgets(line,2048,fp))!=NULL)  {   x=strlen(line); 这里连着两个while{}循环体，第一个while循环结束，文件指针已经指向文件结束了，第二个while不会进入了。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:因为IDE不支持strncpy_s（）函数，所以我没法看运行结果，文字说明见注释，供参考：#include<stdio.h> #include<string.h>  struct record       //结构体 {     char method[255];     char ip[255];     char protocol[255];     char time[255];     char add[255];     char port[255];     char page[255];     char status[255];     char exploer_info[255]; };  int main(void) {     FILE *fp;     fp=fopen(\"access.log\",\"r+\");//打开文件     if(!fp)       {         printf(\"false\\n\");         return -1;//直接返回       }     else{         printf(\"true\\n\");     }//判断文件是否成功打开      char line[2048];     int  i=0,x,j,j_pos,j_pos1;//int  lines=0; //这个变量没用到     int  pos[9],pos1[9];     char s='[', s1=']';      struct record rec[4096];//预设文件有4096行      while((fgets(line,2048,fp))!=NULL)       {          x=strlen(line);          j_pos=0,j_pos1=0;          for(j=0;j<x;j++)           {             if(line[j]==s)//'['  开始位置               {                 pos[j_pos]=j;                 j_pos++;               }             if(line[j]==s1)//']' 结束位置               {                 pos1[j_pos1]=j;                 j_pos1++;               }           }          //strncpy_s(char * str2, int size2, char * str1, int size1);//这里char * str1, int size1 两个值楼主自己调试          strncpy_s(rec[i].method,sizeof(rec[i].method),line+pos[0]+1,pos1[0]-pos[0]-1);          strncpy_s(rec[i].ip,sizeof(rec[i].ip),line+pos[1]+1,pos1[1]-pos[1]-1);          strncpy_s(rec[i].protocol,sizeof(rec[i].protocol),line+pos[2]+1,pos1[2]-pos[2]-1);          strncpy_s(rec[i].time,sizeof(rec[i].time),line+pos[3]+1,pos1[3]-pos[3]-1);          strncpy_s(rec[i].add,sizeof(rec[i].add),line+pos[4]+1,pos1[4]-pos[4]-1);          strncpy_s(rec[i].page,sizeof(rec[i].page),line+pos[5]+1,pos1[5]-pos[5]-1);          strncpy_s(rec[i].port,sizeof(rec[i].port),line+pos[6]+1,pos1[6]-pos[6]-1);          strncpy_s(rec[i].status,sizeof(rec[i].status),line+pos[7]+1,pos1[7]-pos[7]-1);          strncpy_s(rec[i].exploer_info,sizeof(rec[i].exploer_info),line+pos[8]+1,pos1[8]-pos[8]-1);          i++;          //if(line[strlen(line)-1]=='\\n')          //{          //lines++;          //}       }     fclose(fp);//关闭文件      //全部读入rec[i]数组中，接下去处理的代码加入           return 0; } 我改了一下，但是运行结果是空白，而且不允许调试，将struct record rec[4096]一句和strncpy函数注释掉之后能运行，但是这样子是不是结构体就没用上，这是为什么啊？ #include<stdio.h> #include<string.h> struct record//record为结构体名   {   char method[255];   char ip[255];   char protocol[255];   char time[255];   char add[255];   char port[255];   char page[255];   int status;   char exploer_info[255];   struct prams   {    char key[255];    char value[255];   };   int prams_cnt;  };//定义结构体  int main(void) {    //struct record rec;  FILE *fp;  fp=fopen(\"access.log\",\"r+\");//打开文件   if(!fp)  {   printf(\"false\\n\");   return -1;//直接返回   }   else{   printf(\"true\\n\");  }//判断文件是否成功打开  char line[2048];   int i=0,x,j,j_pos,j_pos1;  int lines=0;  int pos[9],pos1[9];  char s='[';  char s1=']';  struct record rec[4096];//定义结构体变量   printf(\"日志分析：\\n\");  int n=0,m=0;  while(fgets(line,2048,fp)!=NULL)  {   puts(line);   n++;   if(strncmp(line,\"[GET]\",5)==0)   {    m++;   }//比较两字符串，相等时strncmp函数值返回0,计数   }  while((fgets(line,2048,fp))!=NULL)  {   x=strlen(line);   j_pos=0,j_pos1=0;   for(j=0;j<x;j++)   {    if(line[j]==s)//此处为'['开始的位置     {     pos[j_pos]=j;     j_pos++;    }    if(line[j]==s1)//']'结束的位置     {     pos1[j_pos1]=j;     j_pos1++;    }   }  }   //strncpy_s函数的使用strncpy_s(char *str2,int size2,char *str1,int size1);   strncpy_s(rec[i].method,sizeof(rec[i].method),line+pos[0]+1,pos1[0]-pos[0]-1);   strncpy_s(rec[i].ip,sizeof(rec[i].ip),line+pos[1]+1,pos1[1]-pos[1]-1);  strncpy_s(rec[i].protocol,sizeof(rec[i].protocol),line+pos[2]+1,pos1[2]-pos[2]-1);  strncpy_s(rec[i].time,sizeof(rec[i].time),line+pos[3]+1,pos1[3]-pos[3]-1);  strncpy_s(rec[i].add,sizeof(rec[i].add),line+pos[4]+1,pos1[4]-pos[4]-1);  strncpy_s(rec[i].page,sizeof(rec[i].page),line+pos[5]+1,pos1[5]-pos[5]-1);  strncpy_s(rec[i].port,sizeof(rec[i].port),line+pos[6]+1,pos1[6]-pos[6]-1);  strncpy_s(rec[i].status,sizeof(rec[i].status),line+pos[7]+1,pos1[7]-pos[7]-1);  strncpy_s(rec[i].exploer_info,sizeof(rec[i].exploer_info),line+pos[8]+1,pos1[8]-pos[8]-1);  printf(\"输出GET请求所占比例：%f\\n\",1.0*m/n); int fclose(FILE *fp);//关闭文件  \treturn 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "因为IDE不支持strncpy_s（）函数，所以我没法看运行结果，文字说明见注释，供参考：#include<stdio.h> #include<string.h>  struct record       //结构体 {     char method[255];     char ip[255];     char protocol[255];     char time[255];     char add[255];     char port[255];     char page[255];     char status[255];     char exploer_info[255]; };  int main(void) {     FILE *fp;     fp=fopen(\"access.log\",\"r+\");//打开文件     if(!fp)       {         printf(\"false\\n\");         return -1;//直接返回       }     else{         printf(\"true\\n\");     }//判断文件是否成功打开      char line[2048];     int  i=0,x,j,j_pos,j_pos1;//int  lines=0; //这个变量没用到     int  pos[9],pos1[9];     char s='[', s1=']';      struct record rec[4096];//预设文件有4096行      while((fgets(line,2048,fp))!=NULL)       {          x=strlen(line);          j_pos=0,j_pos1=0;          for(j=0;j<x;j++)           {             if(line[j]==s)//'['  开始位置               {                 pos[j_pos]=j;                 j_pos++;               }             if(line[j]==s1)//']' 结束位置               {                 pos1[j_pos1]=j;                 j_pos1++;               }           }          //strncpy_s(char * str2, int size2, char * str1, int size1);//这里char * str1, int size1 两个值楼主自己调试          strncpy_s(rec[i].method,sizeof(rec[i].method),line+pos[0]+1,pos1[0]-pos[0]-1);          strncpy_s(rec[i].ip,sizeof(rec[i].ip),line+pos[1]+1,pos1[1]-pos[1]-1);          strncpy_s(rec[i].protocol,sizeof(rec[i].protocol),line+pos[2]+1,pos1[2]-pos[2]-1);          strncpy_s(rec[i].time,sizeof(rec[i].time),line+pos[3]+1,pos1[3]-pos[3]-1);          strncpy_s(rec[i].add,sizeof(rec[i].add),line+pos[4]+1,pos1[4]-pos[4]-1);          strncpy_s(rec[i].page,sizeof(rec[i].page),line+pos[5]+1,pos1[5]-pos[5]-1);          strncpy_s(rec[i].port,sizeof(rec[i].port),line+pos[6]+1,pos1[6]-pos[6]-1);          strncpy_s(rec[i].status,sizeof(rec[i].status),line+pos[7]+1,pos1[7]-pos[7]-1);          strncpy_s(rec[i].exploer_info,sizeof(rec[i].exploer_info),line+pos[8]+1,pos1[8]-pos[8]-1);          i++;          //if(line[strlen(line)-1]=='\\n')          //{          //lines++;          //}       }     fclose(fp);//关闭文件      //全部读入rec[i]数组中，接下去处理的代码加入           return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:struct record 这个结构体声明在哪里？没有看到呢。 生命后也是报错，并且会新增错误，原错误还存在", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "struct record 这个结构体声明在哪里？没有看到呢。", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C语言能自定义变量的地址？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "把需求再描述清晰一些，更详细一些。", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "？？？？？ 楼上厉害了，远程遥视？？？？", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "在书上楷体字那部分。", "referer": "user-0"}]}
{"question": "一个汉字占2字节，最多65535个，但汉字有9万多了，怎么办？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "目前，双字节字符表正在向四字节字符表过渡，这有点像从IPv4到IPv6的过渡。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 7 楼 早打大打打核战争的回复:[quote=引用 6 楼 qq_16774199 的回复:][quote=引用 3 楼 早打大打打核战争 的回复:]最新的unicode 13.0已经包括143859个字符，unicode的雄心是囊括人类创造的所有文字和·符号，包括甲骨文、金文、楔形文字、玛雅文字等等，我估计最后连原始人创作的岩画也得搞进去~ 143859个字符也不够啊，简体+繁体就可能已经不够了，其它语言的文字全加上绝对不够用。[/quote]  这只是目前收录的字符数量，编码空间足够用，UTF-16支持一百多万个编码（0~10FFFF），而UCS-4使用31位编码（最高位固定为0），能支持超过21亿个字符，用到人类灭亡也填不满 [/quote] 错，如果允许私人或公司字符，一下就用完了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 楼主 qq_16774199 的回复:最近开始学汇编，知道2个字节可以产生65535种变化，虽然常用汉字几千个，但全部汉字有9万多个。 每个年代的设计都与其现状相适应。 所以咱没道理用20世纪80年代的观念来分析如今的问题。 每个汉字占2字节的观念早就过时了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "http://unicode.org", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "仅供参考： #pragma comment(lib,\"user32\") #pragma comment(lib,\"gdi32\") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> extern \"C\" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t wc[2];      system(\"color F0\");     system(\"cls\");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(48,0,0,0,0,0,0,0,GB2312_CHARSET ,0,0,0,0,\"宋体-方正超大字符集\");     SelectObject(hdc,hfont);     wc[0]=0xD854u;     wc[1]=0xDC00u;     TextOutW(hdc,10,10,wc,2);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system(\"color 07\");     system(\"cls\");     ShowTheCursor();     return 0; } #if 0 代理项或代理项对是一对共同表示单个字符的 16 位 Unicode 编码值。需要记住的关键一点是： 代理项对实际上是 32 位单个字符，不能再假定一个 16 位 Unicode 编码值正好映射到一个字符。  使用代理项对 代理项对的第一个值是高代理项，包含介于 U+D800 到 U+DBFF 范围内的 16 位代码值。 该对的第二个值是低代理项，包含介于 U+DC00 到 U+DFFF 范围内的值。通过使用代理项对， 16 位 Unicode 编码系统可以对已由 Unicode 标准定义的一百多万个其他字符 (220) 进行寻址。  在传递给 XmlTextWriter 方法的任何字符串中都可以使用代理项字符。不过，代理项字符在编写的 XML 中应该有效。例如，万维网联合会 (W3C) 建议不允许在元素或属性的名称中使用代理项字符。 如果字符串包含无效的代理项对，则引发异常。  另外，可以使用 WriteSurrogateCharEntity 写出与代理项对相对应的字符实体。字符实体以十六 进制格式写出，并用以下公式生成：  (highChar -0xD800) * 0x400 + (lowChar -0xDC00) + 0x10000  如果字符串包含无效的代理项对，则引发异常。下面的示例显示将代理项对作为输入的 WriteSurrogateCharEntity 方法。  C#复制  // The following line writes 𐀀. WriteSurrogateCharEntity ('\\uDC00', '\\uD800'); 下面的示例生成一个代理项对文件，将其加载到 XmlReader 中，并用新的文件名保存文件。 然后，原始文件和新文件被加载回应用程序的 XML 文档对象模型 (DOM) 结构中以进行比较。  C#复制  char lowChar, highChar; char [] charArray = new char[10]; FileStream targetFile = new FileStream(\"SurrogatePair.xml\",       FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  lowChar = Convert.ToChar(0xDC00); highChar = Convert.ToChar(0xD800); XmlTextWriter tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDC01); highChar = Convert.ToChar(0xD801); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDFFF); highChar = Convert.ToChar(0xDBFF); tw.WriteSurrogateCharEntity(lowChar, highChar);  // Add 10 random surrogate pairs. // As Unicode, the high bytes are in lower // memory; for example, word 6A21 as 21 6A. // The high or low is in the logical sense. Random random = new Random(); for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       charArray[i] = highChar;       charArray[++i] = lowChar; } tw.WriteChars(charArray, 0, charArray.Length);  for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       tw.WriteSurrogateCharEntity(lowChar, highChar); }  tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  XmlTextReader r = new XmlTextReader(\"SurrogatePair.xml\");  r.Read(); r.MoveToFirstAttribute(); targetFile = new FileStream(\"SurrogatePairFromReader.xml\",        FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteString(r.Value); tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  // Load both result files into the DOM and compare. XmlDocument doc1 = new XmlDocument(); XmlDocument doc2 = new XmlDocument(); doc1.Load(\"SurrogatePair.xml\"); doc2.Load(\"SurrogatePairFromReader.xml\"); if (doc1.InnerXml != doc2.InnerXml) {       Console.WriteLine(\"Surrogate Pair test case failed\"); } 在使用 WriteChars 方法（一次写出一个缓冲区的数据）写出时，输入中的代理项对可能 会在一个缓冲区内被意外拆分。由于代理项值是定义完善的，如果 WriteChars 遇到来自 较低范围或者较高范围的 Unicode 值，它将该值标识为代理项对的一半。当遇到  WriteChars 将导致从拆分代理项对的缓冲区写入的情况时，将引发异常。使用   IsHighSurrogate 方法检查缓冲区是否以高代理项字符结束。如果缓冲区中的最后一个   字符不是高代理项，可以将该缓冲区传递给 WriteChars 方法。  请参见 概念 使用 XmlTextWriter 创建格式正确的 XML XmlTextWriter 的 XML 输出格式设置 XmlTextWriter 的命名空间功能  #endif", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "目前windows字库仍然停留在unicode 3.x的水平，大约38000多个字符，据微软的人说，他们增加一个字的成本是200多美元，所以没兴趣搞", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "引用 6 楼 qq_16774199 的回复:[quote=引用 3 楼 早打大打打核战争 的回复:]最新的unicode 13.0已经包括143859个字符，unicode的雄心是囊括人类创造的所有文字和·符号，包括甲骨文、金文、楔形文字、玛雅文字等等，我估计最后连原始人创作的岩画也得搞进去~ 143859个字符也不够啊，简体+繁体就可能已经不够了，其它语言的文字全加上绝对不够用。[/quote]  这只是目前收录的字符数量，编码空间足够用，UTF-16支持一百多万个编码（0~10FFFF），而UCS-4使用31位编码（最高位固定为0），能支持超过21亿个字符，用到人类灭亡也填不满", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 3 楼 早打大打打核战争 的回复:最新的unicode 13.0已经包括143859个字符，unicode的雄心是囊括人类创造的所有文字和·符号，包括甲骨文、金文、楔形文字、玛雅文字等等，我估计最后连原始人创作的岩画也得搞进去~ 143859个字符也不够啊，简体+繁体就可能已经不够了，其它语言的文字全加上绝对不够用。", "referer": "user-0"}, {"cid": "9", "user": "user-6", "content": "引用 3 楼 早打大打打核战争 的回复:最新的unicode 13.0已经包括143859个字符，unicode的雄心是囊括人类创造的所有文字和·符号，包括甲骨文、金文、楔形文字、玛雅文字等等，我估计最后连原始人创作的岩画也得搞进去~ 查了一下，这里面已经有93000多的汉字了！涨知识了", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "引用 3 楼 早打大打打核战争 的回复:最新的unicode 13.0已经包括143859个字符，unicode的雄心是囊括人类创造的所有文字和·符号，包括甲骨文、金文、楔形文字、玛雅文字等等，我估计最后连原始人创作的岩画也得搞进去~NB！", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "最新的unicode 13.0已经包括143859个字符，unicode的雄心是囊括人类创造的所有文字和·符号，包括甲骨文、金文、楔形文字、玛雅文字等等，我估计最后连原始人创作的岩画也得搞进去~", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "1、你不能指望哪个字符集能把所有的字收全了，就算收全了，也会有新的字产生！实际上和英语不一样，新的字和词的产生，往往就会有新的字符产生。实际上早期有所谓的造字程序（当然是因为当时主要用途是字处理，用于交换的时候很少），但是现在信息交换成为主要用途了，所以就不能自己造字了，必须让标准、权威的部门来做这种事情！ 2、Unicode支持的字符上限是65536个或者2字节，这种说法也是有问题的，实际上也有3、4字节的版本，所以9万本身不是问题", "referer": "user-0"}, {"cid": "13", "user": "user-7", "content": "所以就出现多字节字符，并出现了字符集和编码（字符集规定收录多少字符，编码规定每个字符的编码值），比如GBK，BIG5，UTF8等等", "referer": "user-0"}]}
{"question": "格式符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 赵4老师的回复:#include <stdio.h> int main() {     char cs1[4],cs2[4];     int i;      for (i=0;i<4;i++) {         cs1[i]=0;         cs2[i]=0;     }      scanf(\"%4c%4c\",&cs1[0],&cs2[0]);      for (i=0;i<4;i++) {         printf(\"%02X \",cs1[i]);     }     printf(\"\\n\");      for (i=0;i<4;i++) {         printf(\"%02X \",cs2[i]);     }     printf(\"\\n\");      return 0; } //输入：A三个空格B三个空格回车 //输出 //41 20 20 20 //42 20 20 20 //  可见题3.51中的代码会导致c1和c2变量对应字节后面的三个字节被空格的ascii码即0x20覆盖，属于危险代码。 现在的书都这么奇怪了吗？前提错了还出题？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "scanf Width Specification width is a positive decimal integer controlling the maximum number of characters to be read from stdin. No more than width characters are converted and stored at the corresponding argument. Fewer than width characters may be read if a white-space character (space, tab, or newline) or a character that cannot be converted according to the given format occurs before width is reached.  The optional prefixes h, l, I64, and L indicate the “size” of the argument (long or short, single-byte character or wide character, depending upon the type character that they modify). These format-specification characters are used with type characters in scanf or wscanf functions to specify interpretation of arguments as shown in the Table R.7. The type prefixes h, l, I64, and L are Microsoft extensions and are not ANSI-compatible. The type characters and their meanings are described in Table R.8.  Table R.7   Size Prefixes for scanf and wscanf Format-Type Specifiers  To Specify Use Prefix With Type Specifier  double l e, E, f, g, or G  long int l d, i, o, x, or X  long unsigned int l u  short int h d, i, o, x, or X  short unsigned int h u  __int64 I64 d, i, o, u, x, or X  Single-byte character with scanf h c or C  Single-byte character with wscanf h c or C  Wide character with scanf l c or C  Wide character with wscanf l c, or C  Single-byte – character string with scanf h s or S  Single-byte – character string with wscanf h s or S  Wide-character string with scanf l s or S  Wide-character string with wscanf l s or S    Following are examples of the use of h and l with scanffunctions and wscanf functions:  scanf( \"%ls\", &x );    // Read a wide-character string wscanf( \"%lC\", &x );    // Read a single-byte character  To read strings not delimited by space characters, a set of characters in brackets ([ ]) can be substituted for the s (string) type character. The corresponding input field is read up to the first character that does not appear in the bracketed character set. If the first character in the set is a caret (^), the effect is reversed: The input field is read up to the first character that does appear in the rest of the character set.  Note that %[a-z] and %[z-a] are interpreted as equivalent to %[abcde...z]. This is a common scanf function extension, but note that the ANSI standard does not require it.  To store a string without storing a terminating null character ('\\0'), use the specification %nc where n is a decimal integer. In this case, the c type character indicates that the argument is a pointer to a character array. The next n characters are read from the input stream into the specified location, and no null character ('\\0') is appended. If n is not specified, its default value is 1.  The scanf function scans each input field, character by character. It may stop reading a particular input field before it reaches a space character for a variety of reasons:   The specified width has been reached.   The next character cannot be converted as specified.   The next character conflicts with a character in the control string that it is supposed to match.    The next character fails to appear in a given character set.  For whatever reason, when the scanf function stops reading an input field, the next input field is considered to begin at the first unread character. The conflicting character, if there is one, is considered unread and is the first character of the next input field or the first character in subsequent read operations on stdin.", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> int main() {     char cs1[4],cs2[4];     int i;      for (i=0;i<4;i++) {         cs1[i]=0;         cs2[i]=0;     }      scanf(\"%4c%4c\",&cs1[0],&cs2[0]);      for (i=0;i<4;i++) {         printf(\"%02X \",cs1[i]);     }     printf(\"\\n\");      for (i=0;i<4;i++) {         printf(\"%02X \",cs2[i]);     }     printf(\"\\n\");      return 0; } //输入：A三个空格B三个空格回车 //输出 //41 20 20 20 //42 20 20 20 //  可见题3.51中的代码会导致c1和c2变量对应字节后面的三个字节被空格的ascii码即0x20覆盖，属于危险代码。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "因为%4c中的4表示占4个字符，楼主可以输入到编译器，然后执行一下，如果不这样输入那么输出是c1, c2是什么，可以试试～", "referer": "user-0"}]}
{"question": "程序报错，改不对了，能帮我看看怎么改吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen(\"data.txt\",\"r\");     if (NULL==f) {         printf(\"Can not open file data.txt!\\n\");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,\"NAME: %31[^\\n]\",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,\"DIMENSION: %d\",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,\"DATA\\n\")) st=3;         } else if (st==3) {             if (3==sscanf(ln,\"%d%d%d\",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf(\"s.NAME=[%s]\\n\",s.NAME);     printf(\"s.DIMENSION=%d\\n\",s.DIMENSION);     for (i=0;i<n;i++) {         printf(\"s.DATA[%d].NO,X,Y=%d,%d,%d\\n\",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 user-3的回复:我觉得楼主的思维似乎受魔法流影响较大。 是否以为你定义了一堆数组，日志文件里的信息就会“自动”进入那些数组？  数组/变量名都是给人类看的，机器并不理解那些名字的含义，也不会“自动”填充那些数组。 咱还是回到现实科技侧，先落实一下语义，学习一下字符串拆分吧？  BTW: 其实学习一下Python，在引入适当的库的前提下，能够更好地兼容楼主的需求。 嗯嗯，谢谢，我知道了，我确实基础不好，谢谢指点", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 SSyeah 的回复:[quote=引用 1 楼 自信男孩的回复:]        for(i=0;i<line;i++)         {                 arr[line[i],status]++;                 vis[line[i],status]=1;         }         in 这个如何理解？ line是数组名，i < line是做什么， line[i]，status这个作为下标还有逗号，那么status是数组名呢，  这样的代码不符合语法规则，自然会提示编译错误。 我把line改正为line[i]后，程序的warning没有了，但是后面的status不知道该怎么改了[/quote] 怎么改，要看你要实现什么，status是用于做什么的，再说上面也没对status赋值呢", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:        for(i=0;i<line;i++)         {                 arr[line[i],status]++;                 vis[line[i],status]=1;         }         in 这个如何理解？ line是数组名，i < line是做什么， line[i]，status这个作为下标还有逗号，那么status是数组名呢，  这样的代码不符合语法规则，自然会提示编译错误。 我把line改正为line[i]后，程序的warning没有了，但是后面的status不知道该怎么改了", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "for(i=0;i<line;i++)         {                 arr[line[i],status]++;                 vis[line[i],status]=1;         }         in 这个如何理解？ line是数组名，i < line是做什么， line[i]，status这个作为下标还有逗号，那么status是数组名呢，  这样的代码不符合语法规则，自然会提示编译错误。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "我觉得楼主的思维似乎受魔法流影响较大。 是否以为你定义了一堆数组，日志文件里的信息就会“自动”进入那些数组？  数组/变量名都是给人类看的，机器并不理解那些名字的含义，也不会“自动”填充那些数组。 咱还是回到现实科技侧，先落实一下语义，学习一下字符串拆分吧？  BTW: 其实学习一下Python，在引入适当的库的前提下，能够更好地兼容楼主的需求。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:[quote=引用 2 楼 SSyeah 的回复:][quote=引用 1 楼 自信男孩的回复:]        for(i=0;i<line;i++)         {                 arr[line[i],status]++;                 vis[line[i],status]=1;         }         in 这个如何理解？ line是数组名，i < line是做什么， line[i]，status这个作为下标还有逗号，那么status是数组名呢，  这样的代码不符合语法规则，自然会提示编译错误。 我把line改正为line[i]后，程序的warning没有了，但是后面的status不知道该怎么改了[/quote] 怎么改，要看你要实现什么，status是用于做什么的，再说上面也没对status赋值呢[/quote] #include<stdio.h> #include<string.h> int main(void) { \tFILE *fp; \tfp=fopen(\"access.log\",\"r+\");//打开文件  \tif(!fp) \t{ \t\tprintf(\"false\\n\"); \t\treturn -1;//直接返回  \t} \telse{ \t\tprintf(\"true\\n\"); \t}//判断文件是否成功打开  \tchar line[2048];//定义和初始化字符串  \tint n=0,m=0; \tchar method[255]={}; \tchar ip[255]={}; \tchar protocol[255]={}; \tchar time[255]={}; \tchar add[255]={}; \tchar port[255]={}; \tchar page[255]={}; \tint status; \tchar exploer_info[255]={}; \tchar key[255]={}; \tchar value[255]={}; \tchar prams_cnt[255]={};//对字符串进行定义和初始化  \tstruct record \t{ \t\tchar method[255]; \t\tchar ip[255]; \t\tchar protocol[255]; \t\tchar time[255]; \t\tchar add[255]; \t\tchar port[255]; \t\tchar page[255]; \t\tint status; \t\tchar exploer_info[255]; \t\tstruct prams \t\t{ \t\t\tchar key[255]; \t\t\tchar value[255]; \t\t}; \t\tchar prams_cnt[255]; \t};//将字符串存入结构体中  \t  \twhile(fgets(line,2048,fp)!=NULL) \t{ \t\tputs(line); \t\tn++; \t\tif(strncmp(line,\"[GET]\",5)==0) \t\t{ \t\t\tm++; \t\t}//比较两字符串，相等时strncmp函数值返回0,计数  \t}//输出日志文件内容并统计计数  \tprintf(\"%f\\n\",1.0*m/n);//输出所占百分比 \tchar arr[1000]={0}; \tchar vis[1000]={0}; \tint i; \tfor(i=0;i<line[i];i++) \t{ \t\tarr[line[i],status]++; \t\tvis[line[i],status]=1; \t}  \t \tprintf(\"%d\",1.0*arr[i]++/i); \tint fclose(FILE *fp);//关闭文件  \treturn 0; } 改后的程序是这样的，更改status类型为整数后就没有报错了，但是运行结果还是不对，调试发现没有进入for循环，i一直是0， 想要实现的功能是计算日志文件中的所有访问状态码的比率，所以这里用的status，但是可能不对，找不到问题出在哪了", "referer": "user-0"}]}
{"question": "请问一下 这个程序是输出学生不及格的人数，但是为什么得不到正确的答案", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "for(i=0;i<n && i < N;i++)    //加上i < N，防止数组越界～     {        scanf(\"%d\",&a[i]);//scanf(\"%d\",a[i]);输入成绩                          //break;//这句多余     } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "参考对照： #include <stdio.h> #define N 40 int Func(int a[],int n); int main() {     int n,i,a[N],ret;      scanf(\"%d\",&n);       //输入学生人数      for(i=0;i<n;i++)     {        scanf(\"%d\",&a[i]);//scanf(\"%d\",a[i]);输入成绩                          //break;//这句多余     }     ret = Func(a,n);     printf(\"%d\",ret);     return 0; }  int Func(int a[],int n) {     int i,count=0; //m     for(i=0;i<n;i++)     {                   //m = a[i];//这句可以不用        if(a[i]<60)//if(m<60)        {           count++;        }     }     return count; }   //8 //75 87 54 36 92 64 52 53 //4请按任意键继续. . .", "referer": "user-0"}]}
{"question": "Miller_Rabin算法中的二次探测定理的一些疑惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "说错了 是为什么给了小于p的正整数的范围也行啊", "referer": "user-0"}]}
{"question": "c如何输出中文", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://blog.csdn.net/yoursly/article/details/95588323  按这里方式修改一下吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "改一下编码方式就好了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 2 楼 虚延 的回复:引用 1 楼 自信男孩 的回复：编码问题，建议看一下字符编码。字符编码怎么设置啊，我之前在mac上都可以直接输出中文的 看一下配置部分，找到设置编码的地方。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "供参考：#include <stdio.h> #include <locale.h> int main() {     wchar_t name[100];     setlocale(LC_ALL,\"chs\");     wscanf(L\"%s\",name);     wprintf(L\"\\\"%s\\\"\\n\",name);     return 0;  }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：编码问题，建议看一下字符编码。字符编码怎么设置啊，我之前在mac上都可以直接输出中文的", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "编码问题，建议看一下字符编码。", "referer": "user-0"}]}
{"question": "请教各位大神，C语言到底怎么才能学好", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "去网上找找翁恺老师的课，还有就是多练习叭", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "C语言教程（附带C语言100例）http://download.csdn.net/detail/zhao4zhong1/8830817", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 4 楼 拾年_ 的回复:[quote=引用 3 楼 早打大打打核战争的回复:]学好C语言比玩转F1赛车容易多了，但是“C语言到底怎么才能学好”这个问题的难度和“到底怎么才能当上F1车手”的难度一样，简单说就是问题太大，无法回答，回答也只能是概念性的，没有可操作性~ 唉，说白了只要肯下功夫，我就是想走捷径，看来还得靠自己[/quote]  我感觉你很有悟性，应该很容易学好，C语言是很简单的语言，复杂之处在于灵活运用", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 早打大打打核战争的回复:学好C语言比玩转F1赛车容易多了，但是“C语言到底怎么才能学好”这个问题的难度和“到底怎么才能当上F1车手”的难度一样，简单说就是问题太大，无法回答，回答也只能是概念性的，没有可操作性~ 唉，说白了只要肯下功夫，我就是想走捷径，看来还得靠自己😓", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "学好C语言比玩转F1赛车容易多了，但是“C语言到底怎么才能学好”这个问题的难度和“到底怎么才能当上F1车手”的难度一样，简单说就是问题太大，无法回答，回答也只能是概念性的，没有可操作性~", "referer": "user-0"}]}
{"question": "请问大神 这第一列前面的空格多了怎么办，同是还要保证后面每列之间有两空格", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不知道楼主的杨辉三角形n的数据规模与约定，暂定n<10 的. 每行最后一列之后允许跟空格吗，如果可以，第25行改为下面这样就行了 printf(\"%-2d  \",a[i][j]); 如果每行最后一列之后不能有空格，那第25行改printf(\"%-2d%s\",a[i][j],(j<i)?\"  \":\"\");", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不想改很多，就用判断一下每一行是不是第一个元素，如果是，就不用%2d而改成%d，否则就用%2d", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "printf的格式控制很灵活的：printf(\"%*d\", !!(j - 1) + 1, a[i][j]);", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "特事特办嘛 printf(j==1?\"%1d\":\"%2d\",a[i][j]);", "referer": "user-0"}]}
{"question": "在C中使用中文，本地化全攻略", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 5 楼 赵4老师 的回复:刚好打酱油路过  酱油呢，也丢了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "刚好打酱油路过", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 1 楼 赵4老师 的回复:  你这是回娘家？一只鸡、一只鸭，还有胖娃娃都丢了？", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "仅供参考：#pragma comment(lib,\"user32\") #pragma comment(lib,\"gdi32\") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> extern \"C\" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t wc[2];      system(\"color F0\");     system(\"cls\");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(48,0,0,0,0,0,0,0,GB2312_CHARSET ,0,0,0,0,\"宋体-方正超大字符集\");     SelectObject(hdc,hfont);     wc[0]=0xD854u;     wc[1]=0xDC00u;     TextOutW(hdc,10,10,wc,2);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system(\"color 07\");     system(\"cls\");     ShowTheCursor();     return 0; } #if 0 代理项或代理项对是一对共同表示单个字符的 16 位 Unicode 编码值。需要记住的关键一点是： 代理项对实际上是 32 位单个字符，不能再假定一个 16 位 Unicode 编码值正好映射到一个字符。  使用代理项对 代理项对的第一个值是高代理项，包含介于 U+D800 到 U+DBFF 范围内的 16 位代码值。 该对的第二个值是低代理项，包含介于 U+DC00 到 U+DFFF 范围内的值。通过使用代理项对， 16 位 Unicode 编码系统可以对已由 Unicode 标准定义的一百多万个其他字符 (220) 进行寻址。  在传递给 XmlTextWriter 方法的任何字符串中都可以使用代理项字符。不过，代理项字符在编写的 XML 中应该有效。例如，万维网联合会 (W3C) 建议不允许在元素或属性的名称中使用代理项字符。 如果字符串包含无效的代理项对，则引发异常。  另外，可以使用 WriteSurrogateCharEntity 写出与代理项对相对应的字符实体。字符实体以十六 进制格式写出，并用以下公式生成：  (highChar -0xD800) * 0x400 + (lowChar -0xDC00) + 0x10000  如果字符串包含无效的代理项对，则引发异常。下面的示例显示将代理项对作为输入的 WriteSurrogateCharEntity 方法。  C#复制  // The following line writes 𐀀. WriteSurrogateCharEntity ('\\uDC00', '\\uD800'); 下面的示例生成一个代理项对文件，将其加载到 XmlReader 中，并用新的文件名保存文件。 然后，原始文件和新文件被加载回应用程序的 XML 文档对象模型 (DOM) 结构中以进行比较。  C#复制  char lowChar, highChar; char [] charArray = new char[10]; FileStream targetFile = new FileStream(\"SurrogatePair.xml\",       FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  lowChar = Convert.ToChar(0xDC00); highChar = Convert.ToChar(0xD800); XmlTextWriter tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDC01); highChar = Convert.ToChar(0xD801); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDFFF); highChar = Convert.ToChar(0xDBFF); tw.WriteSurrogateCharEntity(lowChar, highChar);  // Add 10 random surrogate pairs. // As Unicode, the high bytes are in lower // memory; for example, word 6A21 as 21 6A. // The high or low is in the logical sense. Random random = new Random(); for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       charArray[i] = highChar;       charArray[++i] = lowChar; } tw.WriteChars(charArray, 0, charArray.Length);  for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       tw.WriteSurrogateCharEntity(lowChar, highChar); }  tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  XmlTextReader r = new XmlTextReader(\"SurrogatePair.xml\");  r.Read(); r.MoveToFirstAttribute(); targetFile = new FileStream(\"SurrogatePairFromReader.xml\",        FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteString(r.Value); tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  // Load both result files into the DOM and compare. XmlDocument doc1 = new XmlDocument(); XmlDocument doc2 = new XmlDocument(); doc1.Load(\"SurrogatePair.xml\"); doc2.Load(\"SurrogatePairFromReader.xml\"); if (doc1.InnerXml != doc2.InnerXml) {       Console.WriteLine(\"Surrogate Pair test case failed\"); } 在使用 WriteChars 方法（一次写出一个缓冲区的数据）写出时，输入中的代理项对可能 会在一个缓冲区内被意外拆分。由于代理项值是定义完善的，如果 WriteChars 遇到来自 较低范围或者较高范围的 Unicode 值，它将该值标识为代理项对的一半。当遇到  WriteChars 将导致从拆分代理项对的缓冲区写入的情况时，将引发异常。使用   IsHighSurrogate 方法检查缓冲区是否以高代理项字符结束。如果缓冲区中的最后一个   字符不是高代理项，可以将该缓冲区传递给 WriteChars 方法。  请参见 概念 使用 XmlTextWriter 创建格式正确的 XML XmlTextWriter 的 XML 输出格式设置 XmlTextWriter 的命名空间功能  #endif", "referer": "user-0"}]}
{"question": "c语言数组问题求教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学习学习使我快乐", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:[code=c]#include<stdio.h> #include<string.h>  int main() {   #if 1     char buf[100];     int num, cnt;     int i, j;       scanf(\"%d\", &num);      while (getchar() != '\\n')         ;      for (i = 0; i < num; i++) {         fgets(buf, sizeof(buf), stdin);          cnt = 0;         for (j = 0; buf[j] != '\\n' && buf[j]; j++) {             if (buf[j] == 'P' && cnt == 0)                 cnt++;             if (buf[j] == 'A' && cnt == 1)                 cnt++;             if (buf[j] == 'T' && cnt == 2)                 break;         }         if (cnt >= 2)             printf(\"YES\\n\");         else             printf(\"NO\\n\");     }  #else     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n')         ;  //来清除scanf缓存中的垃圾数据     int i=0;//count表示A分别在几个位置 的数量     char pri[num][3];     for(i=0;i<num;i++)     {         int pos=0,count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }         if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){             strcpy(pri[i],\"YES\");         }         else  {             strcpy(pri[i],\"NO\");         }         if(c!='\\n')             while(getchar()!='\\n');   //来清除getchar缓存中的垃圾数据     }     for(int j=0;j<num;j++){         printf(\"%s\\n\",pri[j]);     } #endif     return 0; }  [quote=引用 6 楼 weixin_45544561 的回复:][quote=引用 楼主 想学精编程的人的回复:]//1003 我要通过！ (20分)  pta上的一道题   #include<stdio.h> #include<string.h> int main() {     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n');  //来清除scanf缓存中的垃圾数据     int i=0;//count表示A分别在几个位置 的数量     char pri[num][3];     for(i=0;i<num;i++)     {         int pos=0,count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }                 if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){         strcpy(pri[i],\"YES\");             }         else  {         strcpy(pri[i],\"NO\");         }           if(c!='\\n')             while(getchar()!='\\n');   //来清除getchar缓存中的垃圾数据     }         for(int j=0;j<num;j++){     printf(\"%s\\n\",pri[j]);     }     return 0; }  我在输出是出現问题    前4ge输出应该只有一个YES,不知道为什么会这么多 你好，楼主。我也爱好c语言。不过是初学者。我想问下，你提到的PTA是什么？是一个能做题的学习网站吗？还是什么呀？能告诉我吗？[/quote]你直接搜就行，可以做题的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "小白路过，学习了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 楼主 想学精编程的人的回复://1003 我要通过！ (20分)  pta上的一道题   #include<stdio.h> #include<string.h> int main() {     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n');  //来清除scanf缓存中的垃圾数据     int i=0;//count表示A分别在几个位置 的数量     char pri[num][3];     for(i=0;i<num;i++)     {         int pos=0,count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }                 if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){         strcpy(pri[i],\"YES\");             }         else  {         strcpy(pri[i],\"NO\");         }           if(c!='\\n')             while(getchar()!='\\n');   //来清除getchar缓存中的垃圾数据     }         for(int j=0;j<num;j++){     printf(\"%s\\n\",pri[j]);     }     return 0; }  我在输出是出現问题    前4ge输出应该只有一个YES,不知道为什么会这么多 你好，楼主。我也爱好c语言。不过是初学者。我想问下，你提到的PTA是什么？是一个能做题的学习网站吗？还是什么呀？能告诉我吗？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 4 楼 qzjhjxj的回复:[quote=引用 3 楼 想学精编程的人 的回复:][quote=引用 1 楼 qzjhjxj 的回复:]修改如下，供参考：#include<stdio.h> #include<string.h>  int main() {     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n');     int i=0;     char pri[11][4];//char pri[num][3];这个数组设置错误导致     for(i=0;i<num;i++)     {         int pos=0,count[3]={0};//count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }         if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){         strcpy(pri[i],\"YES\");             }         else  {         strcpy(pri[i],\"NO\");         }           if(c!='\\n')             while(getchar()!='\\n');     }     for(int j=0;j<num;j++){     printf(\"%s\\n\",pri[j]);     }          return 0; }  //8 //PAT //PAAT //AAPATAA //AAPAATAAAA //xPATx //PT //Whatever //APAAATAA //YES //YES //YES //YES //NO //NO //NO //NO //请按任意键继续. . .我发现把这里//char pri[num][3];这个数组设置错误导致//里面的3改成4就能成功了，请问能解答一下原因吗[/quote] \"YES\" \"NO\"都是字符串，系统在保存时，自动会在串尾加上结束标志'\\0',所以字符串\"YES\\0\"的长度是4，\"NO\\0\"  的长度为3。当把字符串数组char pri[num][3]长度设置为3时，保存时串尾结束标志就丢了，字符数组就是这样的：  pri[num][3]={\"YES\",\"YES\",\"YES\",\"YES\",\"NO\\0\",\"NO\\0\",\"NO\\0\",\"NO\\0\"},当执行 printf(\"%s\\n\",pri[j]);的时候，  输出字符串时以'\\0'作为结束标志，所以pri[0][3]= \"YESYESYESYESNO\"，pri[1][3]=\"YESYESYESNO\"，...。正确的  pri[num][4]={\"YES\\0\",\"YES\\0\",\"YES\\0\",\"YES\\0\",\"NO\\0\",\"NO\\0\",\"NO\\0\",\"NO\\0\"},输出时自然就对了。[/quote] 牛逼懂了谢谢", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 3 楼 想学精编程的人 的回复:[quote=引用 1 楼 qzjhjxj 的回复:]修改如下，供参考：#include<stdio.h> #include<string.h>  int main() {     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n');     int i=0;     char pri[11][4];//char pri[num][3];这个数组设置错误导致     for(i=0;i<num;i++)     {         int pos=0,count[3]={0};//count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }         if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){         strcpy(pri[i],\"YES\");             }         else  {         strcpy(pri[i],\"NO\");         }           if(c!='\\n')             while(getchar()!='\\n');     }     for(int j=0;j<num;j++){     printf(\"%s\\n\",pri[j]);     }          return 0; }  //8 //PAT //PAAT //AAPATAA //AAPAATAAAA //xPATx //PT //Whatever //APAAATAA //YES //YES //YES //YES //NO //NO //NO //NO //请按任意键继续. . .我发现把这里//char pri[num][3];这个数组设置错误导致//里面的3改成4就能成功了，请问能解答一下原因吗[/quote] \"YES\" \"NO\"都是字符串，系统在保存时，自动会在串尾加上结束标志'\\0',所以字符串\"YES\\0\"的长度是4，\"NO\\0\"  的长度为3。当把字符串数组char pri[num][3]长度设置为3时，保存时串尾结束标志就丢了，字符数组就是这样的：  pri[num][3]={\"YES\",\"YES\",\"YES\",\"YES\",\"NO\\0\",\"NO\\0\",\"NO\\0\",\"NO\\0\"},当执行 printf(\"%s\\n\",pri[j]);的时候，  输出字符串时以'\\0'作为结束标志，所以pri[0][3]= \"YESYESYESYESNO\"，pri[1][3]=\"YESYESYESNO\"，...。正确的  pri[num][4]={\"YES\\0\",\"YES\\0\",\"YES\\0\",\"YES\\0\",\"NO\\0\",\"NO\\0\",\"NO\\0\",\"NO\\0\"},输出时自然就对了。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 qzjhjxj 的回复:修改如下，供参考：#include<stdio.h> #include<string.h>  int main() {     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n');     int i=0;     char pri[11][4];//char pri[num][3];这个数组设置错误导致     for(i=0;i<num;i++)     {         int pos=0,count[3]={0};//count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }         if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){         strcpy(pri[i],\"YES\");             }         else  {         strcpy(pri[i],\"NO\");         }           if(c!='\\n')             while(getchar()!='\\n');     }     for(int j=0;j<num;j++){     printf(\"%s\\n\",pri[j]);     }          return 0; }  //8 //PAT //PAAT //AAPATAA //AAPAATAAAA //xPATx //PT //Whatever //APAAATAA //YES //YES //YES //YES //NO //NO //NO //NO //请按任意键继续. . .我发现把这里//char pri[num][3];这个数组设置错误导致//里面的3改成4就能成功了，请问能解答一下原因吗", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "#include<stdio.h> #include<string.h>  int main() {   #if 1     char buf[100];     int num, cnt;     int i, j;       scanf(\"%d\", &num);      while (getchar() != '\\n')         ;      for (i = 0; i < num; i++) {         fgets(buf, sizeof(buf), stdin);          cnt = 0;         for (j = 0; buf[j] != '\\n' && buf[j]; j++) {             if (buf[j] == 'P' && cnt == 0)                 cnt++;             if (buf[j] == 'A' && cnt == 1)                 cnt++;             if (buf[j] == 'T' && cnt == 2)                 break;         }         if (cnt >= 2)             printf(\"YES\\n\");         else             printf(\"NO\\n\");     }  #else     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n')         ;  //来清除scanf缓存中的垃圾数据     int i=0;//count表示A分别在几个位置 的数量     char pri[num][3];     for(i=0;i<num;i++)     {         int pos=0,count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }         if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){             strcpy(pri[i],\"YES\");         }         else  {             strcpy(pri[i],\"NO\");         }         if(c!='\\n')             while(getchar()!='\\n');   //来清除getchar缓存中的垃圾数据     }     for(int j=0;j<num;j++){         printf(\"%s\\n\",pri[j]);     } #endif     return 0; } 供参考～", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "修改如下，供参考：#include<stdio.h> #include<string.h>  int main() {     char c;     int num;     scanf(\"%d\", &num);     while(getchar() != '\\n');     int i=0;     char pri[11][4];//char pri[num][3];这个数组设置错误导致     for(i=0;i<num;i++)     {         int pos=0,count[3]={0};//count[3]={0,0,0};//,count[3]={0,0,0}不能放上面         while((c=getchar())!='\\n'){             if(c=='A') count[pos]++;             else if(c=='P'&&pos==0) pos=1;             else if(c=='T'&&pos==1) pos=2;             else break;         }         if(c=='\\n'&&pos==2&&count[1]&&count[2]==count[1]*count[0]){         strcpy(pri[i],\"YES\");             }         else  {         strcpy(pri[i],\"NO\");         }           if(c!='\\n')             while(getchar()!='\\n');     }     for(int j=0;j<num;j++){     printf(\"%s\\n\",pri[j]);     }          return 0; }  //8 //PAT //PAAT //AAPATAA //AAPAATAAAA //xPATx //PT //Whatever //APAAATAA //YES //YES //YES //YES //NO //NO //NO //NO //请按任意键继续. . .", "referer": "user-0"}]}
{"question": "兄弟们，求解·", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "for (A;B;C) D; //等价于 {  A;  while (1) {   if (!(B)) break;   D;   C;  } }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "当k=4，i = 1时，注释掉的代码是k < 5-i；即这条语句判断是假，不会执行，后面的i = 2, i = 3 ...都不会执行，这样，这个循环就成冗余代码，不会被执行了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "供参考：#include <stdio.h> int main() {     int i,j,k;     for(i=1;i<=4;i++)      {       for(j=0;j<i-1;j++)        {         printf(\" \");        }       //for(k=0;k<5-i;k++)//这句是k=0开始，执行k<5-i次 printf(\" *\")，k++;                           //i=1时，k=0 < 5-i=5-1=4,条件满足，执行 printf(\" *\")，k++；                           //i=2时，k=0 < 5-i=5-2=3,条件满足，执行 printf(\" *\")，k++；                           //i=3时，。。。。。。        for(k=5-i;k>0;k--) //倒过来应该是这样写才对，k=5-i开始，执行5-i>0次printf(\" *\"),k--;        //for(k=4;k<5-i;k--)//为什么将上面的for(k=0;k<5-i;k++)换成我注释的就不对啊，求解？        {                  //当i=1时，条件是k=4开始，k=4 < 5-i=5-1=4,条件不满足，直接就跳出循环了         printf(\" *\");     //当i=2时，k=4 < 5-i=5-2,仍然条件不满足，跳出循环        }                  //i=3时，。。。。。。       printf(\"\\n\");      }     system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": "为啥我这个代码输入数字点回车就还是没有输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "好的好的，谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "输入结束的条件是-1，所以你得输入-1才会退出循环。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你的第一个循环赋值不如直接初始化的时候赋值，第二个循环仔细看的话可以发现只有输入scanf，而你输出的printf函数则是在第三个循环里，第二个循环没有跳出来就无法进入第三个循环，自然没有输出", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "...你的那个循环本来就没有输出呀", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "无语中 你自己写的输入-1才结束嘛。", "referer": "user-0"}]}
{"question": "带指针的函数，怎么传参数，刚学c语言，很迷", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "要求用指针就去掉方括号嘛。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 user-3的回复:楼主，这个chen()函数具体功能不清楚，按图修改，供参考：#include <stdio.h>  int chen(int b[],int n,int m);//函数声明 //或：int chen(int *b,int n,int m);  int main() {     int c,b;     while(~scanf(\"%d\",&c))     {        scanf(\"%d\",&b);        //int a[c];        int *a = new int[c];//动态数组        printf(\"%d\\n\",chen(a,c,b));     }          return 0;  }  int chen(int b[],int n,int m)//函数实现 //或：int chen(int *b,int n,int m); {     int sum=0;     for(int i=0;i<m;i++)     {        b[i] = i+1;     } } 我明天会试试的", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "要求要用指针", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "说的就是去掉星啊，原型比函数头就是多余一个星，画蛇为啥要添足呢？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "楼主，这个chen()函数具体功能不清楚，按图修改，供参考：#include <stdio.h>  int chen(int b[],int n,int m);//函数声明 //或：int chen(int *b,int n,int m);  int main() {     int c,b;     while(~scanf(\"%d\",&c))     {        scanf(\"%d\",&b);        //int a[c];        int *a = new int[c];//动态数组        printf(\"%d\\n\",chen(a,c,b));     }          return 0;  }  int chen(int b[],int n,int m)//函数实现 //或：int chen(int *b,int n,int m); {     int sum=0;     for(int i=0;i<m;i++)     {        b[i] = i+1;     } }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "加分加了，还是报错了，去掉星号，不用指针也对，字符串指针我会用，这个数组型指针有毒感觉", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "参考这页往下拉：", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "原型写的不对，复制函数头加个分号就好。 b需要个int类型的数组名，所以你红的那行调用是正确的，错的是上面。", "referer": "user-0"}]}
{"question": "C语言函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "哈哈，我也曾中招过", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "输出，%3.0f 瞎了。。。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "哦哦 我晓得了", "referer": "user-0"}]}
{"question": "把文件中的特定数据传入至数组中以待后续使用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen(\"data.txt\",\"r\");     if (NULL==f) {         printf(\"Can not open file data.txt!\\n\");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,\"NAME: %31[^\\n]\",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,\"DIMENSION: %d\",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,\"DATA\\n\")) st=3;         } else if (st==3) {             if (3==sscanf(ln,\"%d%d%d\",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf(\"s.NAME=[%s]\\n\",s.NAME);     printf(\"s.DIMENSION=%d\\n\",s.DIMENSION);     for (i=0;i<n;i++) {         printf(\"s.DATA[%d].NO,X,Y=%d,%d,%d\\n\",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "原始文件是手机上的传感器的数据，然后由于每次测量时间不等，行数是未知的，没有空行，但是每行并没有完全填满，预期期望是把原始数据文件中ACCE、Gyro、Magn以及GNSS开头的后续的一些数据分别读取到对应的数组中去，其中acce、gyro、magn都是n行（因为样本数未知）6列的数组；gnss是n行10列的数组，以便后续调取使用。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "记得你问过这个问题，看来你还是不会提问题。 你不能去看医生只说不舒服。 你得充分说清你的情况和需求，包括但不限于： 你的数据文件预计有多少行/行数未知？ 有没有/为什么有空行？ 为什么有些行看起来该分行却没分？实际文件会不会这样？ 预期的合理的行是什么格式？ 合理的行应有几个字段？ 字段是否由分号分隔？ 你预期读完以后放进什么数组？类型？维度？大小？", "referer": "user-0"}]}
{"question": "找大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "程序不能输出，还显示warning，求大佬帮忙看一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:#include<stdio.h> #include<string.h>  int main(void) {     FILE *fp;     fp=fopen(\"access.log\",\"r+\");     if(!fp){         printf(\"false\\n\");         return -1;//直接返回     }     else{         printf(\"true\\n\");     }      char method[255]={};     char ip[255]={};     char protocol[255]={};     char time[255]={};     char add[255]={};     char port[255]={};     char page[255]={};     char status[255]={};     char exploer_info[255]={};     char key[255]={};     char value[255]={};     char prams_cnt[255]={};//对字符串进行定义和初始化      struct record     {         char method[255];         char ip[255];         char protocol[255];         char time[255];         char add[255];         char port[255];         char page[255];         char status[255];         char exploer_info[255];         struct prams         {             char key[255];             char value[255];         };         char prams_cnt[255];     };//将字符串存入结构体中     while(getc(fp)!=EOF)     {         /*   //可能出现内存溢出         fgets(method,1000,fp);         fgets(ip,1000,fp);         fgets(protocol,1000,fp);         fgets(time,1000,fp);         fgets(add,1000,fp);         fgets(port,1000,fp);         fgets(page,1000,fp);         fgets(status,1000,fp);         fgets(exploer_info,1000,fp);         fgets(key,1000,fp);         fgets(value,1000,fp);         fgets(prams_cnt,1000,fp);         */         fgets(method, sizeof(method),fp);         fgets(ip, sizeof(ip),fp);         fgets(protocol,sizeof(protocol),fp);         fgets(time, sizeof(time),fp);         fgets(add, sizeof(add),fp);         fgets(port, sizeof(port),fp);         fgets(page, sizeof(page),fp);         fgets(status, sizeof(status), fp);         fgets(exploer_info, sizeof(exploer_info), fp);         fgets(key, sizeof(key), fp);         fgets(value, sizeof(value), fp);         fgets(prams_cnt, sizeof(prams_cnt), fp);         printf(\"%s\",method);         printf(\"%s\",ip);         printf(\"%s\",protocol);         printf(\"%s\",time);         printf(\"%s\",add);         printf(\"%s\",port);         printf(\"%s\",page);         printf(\"%s\",status);         printf(\"%s\",exploer_info);         printf(\"%s\",key);         printf(\"%s\",value);//将日志文件输出     }//;     int i=0,n=0;     /*     for(i=0;i<1000;i++)     {         //if (method[i]=\"[GET]\")         if (strcmp(method, \"[GET]\") == 0)         {             n++;         }     };     */     if (strcmp(method, \"[GET]\") == 0)     {         n++;     }     double pro=0.0;     pro=1.0*i/n;     printf(\"%f\",pro);      int fclose(FILE *fp);     return 0; }  供参考～ 我明白啦，谢谢谢谢！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 forever74的回复:要做这点事定义那么多乱七八糟的东西干啥，抓一行，比较前5个字符，循环。  #include<stdio.h> #include<string.h>  int main(void) { \tchar line[2048]; \tFILE *fp; \tint n=0, m=0; \tfp = fopen(\"access.log\", \"r\"); \tif (!fp) { \t\tprintf(\"false\\n\"); \t\treturn -1;//直接返回 \t} \twhile (fgets(line,2048,fp) != NULL) \t{ \t\t//puts(line); //需要的话去掉行首的双斜线输出 \t\tn++; \t\tif (strncmp(line, \"[GET]\", 5) == 0)m++; \t} \tprintf(\"%.4lf\", 1.0*m/n);  \tfclose(fp); \treturn 0; }  谢谢谢谢，非常感谢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 qzjhjxj的回复:if (method[i]=\"[GET]\")这句是要判断method[i]==\"[GET]\"吗？字符串应该这样判断：#include<string.h> //头文件 if(strcmp(method[i],\"[GET]\")==0) 好哒，明白啦，谢谢谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "if (method[i]=\"[GET]\")这句是要判断method[i]==\"[GET]\"吗？字符串应该这样判断：#include<string.h> //头文件 if(strcmp(method[i],\"[GET]\")==0)", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "事实上楼主的代码里每个fgets都抓进来一整行，而不是你自己设想的一个字段，因此该代码缺少正确的前提。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "要做这点事定义那么多乱七八糟的东西干啥，抓一行，比较前5个字符，循环。  #include<stdio.h> #include<string.h>  int main(void) { \tchar line[2048]; \tFILE *fp; \tint n=0, m=0; \tfp = fopen(\"access.log\", \"r\"); \tif (!fp) { \t\tprintf(\"false\\n\"); \t\treturn -1;//直接返回 \t} \twhile (fgets(line,2048,fp) != NULL) \t{ \t\t//puts(line); //需要的话去掉行首的双斜线输出 \t\tn++; \t\tif (strncmp(line, \"[GET]\", 5) == 0)m++; \t} \tprintf(\"%.4lf\", 1.0*m/n);  \tfclose(fp); \treturn 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "#include<stdio.h> #include<string.h>  int main(void) {     FILE *fp;     fp=fopen(\"access.log\",\"r+\");     if(!fp){         printf(\"false\\n\");         return -1;//直接返回     }     else{         printf(\"true\\n\");     }      char method[255]={};     char ip[255]={};     char protocol[255]={};     char time[255]={};     char add[255]={};     char port[255]={};     char page[255]={};     char status[255]={};     char exploer_info[255]={};     char key[255]={};     char value[255]={};     char prams_cnt[255]={};//对字符串进行定义和初始化      struct record     {         char method[255];         char ip[255];         char protocol[255];         char time[255];         char add[255];         char port[255];         char page[255];         char status[255];         char exploer_info[255];         struct prams         {             char key[255];             char value[255];         };         char prams_cnt[255];     };//将字符串存入结构体中     while(getc(fp)!=EOF)     {         /*   //可能出现内存溢出         fgets(method,1000,fp);         fgets(ip,1000,fp);         fgets(protocol,1000,fp);         fgets(time,1000,fp);         fgets(add,1000,fp);         fgets(port,1000,fp);         fgets(page,1000,fp);         fgets(status,1000,fp);         fgets(exploer_info,1000,fp);         fgets(key,1000,fp);         fgets(value,1000,fp);         fgets(prams_cnt,1000,fp);         */         fgets(method, sizeof(method),fp);         fgets(ip, sizeof(ip),fp);         fgets(protocol,sizeof(protocol),fp);         fgets(time, sizeof(time),fp);         fgets(add, sizeof(add),fp);         fgets(port, sizeof(port),fp);         fgets(page, sizeof(page),fp);         fgets(status, sizeof(status), fp);         fgets(exploer_info, sizeof(exploer_info), fp);         fgets(key, sizeof(key), fp);         fgets(value, sizeof(value), fp);         fgets(prams_cnt, sizeof(prams_cnt), fp);         printf(\"%s\",method);         printf(\"%s\",ip);         printf(\"%s\",protocol);         printf(\"%s\",time);         printf(\"%s\",add);         printf(\"%s\",port);         printf(\"%s\",page);         printf(\"%s\",status);         printf(\"%s\",exploer_info);         printf(\"%s\",key);         printf(\"%s\",value);//将日志文件输出     }//;     int i=0,n=0;     /*     for(i=0;i<1000;i++)     {         //if (method[i]=\"[GET]\")         if (strcmp(method, \"[GET]\") == 0)         {             n++;         }     };     */     if (strcmp(method, \"[GET]\") == 0)     {         n++;     }     double pro=0.0;     pro=1.0*i/n;     printf(\"%f\",pro);      int fclose(FILE *fp);     return 0; }  供参考～", "referer": "user-0"}]}
{"question": "C语言整数浮点数转换小问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个恐怕和printf的%f 格式有关，好像默认小数6位， 我看就是 1.5", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这里涉及到浮点型与整数型何时进行转换的问题。 式子a= a_10/10;   a为浮点型，a_10为整数型      为了方便讲，把式子变成   a = a_10/10 + 3;  这时就出现问题了   是该把a_10直接转为浮点型然后进行 除10 加 3 的运算，(整数除法运算不保留余数，这是与浮点型运算的区别，这个会影响到最后结果) 还是a_10/10 运算完后 转为浮点型然后加3， 或者说a_10/10 + 3   全部运算完后在转呢。  实际上编译器是根据给的数字 10  或 10.0   ， 3  或3.0进行运算区分 整数与整数运算 a_10/10 ，a_10/10 + 3 还是按照整数运算方式进行 整数与浮点运算a_10/10.0   就会先把 a_10 转为浮点型在 与10.0运算。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include <stdio.h> int main() {     float a=1.5;     printf(\"first  a=%f\\n\",a);//原来的     int   a_10;     a_10 = (int)(a*10);     printf(\"a_10=%d\\n\",a_10);     a    = a_10/10.0;     printf(\"second a=%f\\n\",a);//现在的      return 0; }  //first  a=1.500000 //a_10=15 //second a=1.500000 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "所以你得表达清楚，你关心的到底是值还是格式？", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "人家系统输出了5个0，你自己在正文敲了8个0，可见你自己也认为末尾多几个少几个0没关系。", "referer": "user-0"}]}
{"question": "我是新手，哪位大神能告诉我这啥意思，谢谢啦。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 qq_52473673 的回复:[quote=引用 1 楼 forever74的回复:]scanf_s(\"%s\",name,39); 为啥后面要带个39呀。[/quote] 40，或者用sizeof(name)。不建议用39，用39是考虑最后的'\\0'，其实不需要关心scanf_s会考虑把'\\0'加到缓存的末尾或者是有效字符的后面一个字节。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "参考：https://blog.csdn.net/Gnewocean/article/details/83793744?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-7.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-7.control", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 10 楼 qq_52473673的回复:[quote=引用 8 楼 qq_52473673的回复:][quote=引用 6 楼 qzjhjxj的回复:]供参考：#include<stdio.h> #define PARISE \"you are a extraordinary being.\" int main() {     char name[40];     printf(\"what is your name?\");     scanf_s(\"%s\",name,40);     printf(\"Hello,%s. %s\\n\",name,PARISE);          return 0; } 参考百度：https://www.zhihu.com/question/64044016 不行呀，报错说40是未声明的标识符。[/quote] 不好意思，刚才我弄错了。已经可以了，谢谢。[/quote] 再次劳烦您一下，为什么要在后面加个40呢？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 8 楼 qq_52473673的回复:[quote=引用 6 楼 qzjhjxj的回复:]供参考：#include<stdio.h> #define PARISE \"you are a extraordinary being.\" int main() {     char name[40];     printf(\"what is your name?\");     scanf_s(\"%s\",name,40);     printf(\"Hello,%s. %s\\n\",name,PARISE);          return 0; } 参考百度：https://www.zhihu.com/question/64044016 不行呀，报错说40是未声明的标识符。[/quote] 不好意思，刚才我弄错了。已经可以了，谢谢。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "scanf_s(\"%s\",&name,39);", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复:供参考：#include<stdio.h> #define PARISE \"you are a extraordinary being.\" int main() {     char name[40];     printf(\"what is your name?\");     scanf_s(\"%s\",name,40);     printf(\"Hello,%s. %s\\n\",name,PARISE);          return 0; } 参考百度：https://www.zhihu.com/question/64044016 不行呀，报错说40是未声明的标识符。", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "scanf_s(\"%s\",[color=#0000FF]&name[/color],39); //必须是变量地址，", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "供参考：#include<stdio.h> #define PARISE \"you are a extraordinary being.\" int main() {     char name[40];     printf(\"what is your name?\");     scanf_s(\"%s\",name,40);     printf(\"Hello,%s. %s\\n\",name,PARISE);          return 0; } 参考百度：https://www.zhihu.com/question/64044016", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 4 楼 forever74的回复:scanf_s的其他用法和scanf一致，但是， 每个%s或%c格式符需要对应后面2个参数，第二个是长度限制。 但我按你上面那样打还是不行呀。", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "scanf_s的其他用法和scanf一致，但是， 每个%s或%c格式符需要对应后面2个参数，第二个是长度限制。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 forever74的回复:scanf_s(\"%s\",name,39); 好像也不行哟", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 1 楼 forever74的回复:scanf_s(\"%s\",name,39); 为啥后面要带个39呀。", "referer": "user-0"}, {"cid": "14", "user": "user-5", "content": "scanf_s(\"%s\",name,39);", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 14 楼 qq_34124780的回复:scanf()不是要用&符号来取地址接收吗？scanf_s应该也需要吧。。。 这个是name数组，不需要那个", "referer": "user-0"}, {"cid": "16", "user": "user-6", "content": "scanf()不是要用&符号来取地址接收吗？scanf_s应该也需要吧。。。", "referer": "user-0"}]}
{"question": "请问大神 为什么是这个结果，错哪了（答案是5）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改如下，供参考：#include <stdio.h>  int Gcd(int x,int y);//函数声明  int main() {         int a,b;         int ret;         scanf(\"%d %d\",&a,&b);          ret = Gcd(a,b); //函数调用          printf(\"%d\",ret);                  return 0; }  int Gcd(int x,int y)//函数实现 {        int r;        r=x%y;        while(r!=0)        {           x=y;           y=r;           r=x%y;        }        return y; }   //50 15 //5请按任意键继续. . .", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "ret没有初始化。 编写的函数也没有用呀。，看不出这段程序的作用", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "你写了个函数却没有调用它", "referer": "user-0"}]}
{"question": "求数据结构算法演示系统DSDemo", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同求感谢:1584468697@qq.com", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "发你邮箱：yueduchu@yeah.net", "referer": "user-0"}]}
{"question": "c语言作业，大神求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 weixin_45544561的回复:[quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 weixin_45544561 的回复:][quote=引用 1 楼 自信男孩的回复:]scanf的返回值不等1（注意scanf中只有一个%d，因此等于1是正常的输入），说明输入的不匹配%d，那么scanf(\"%*s\");就是用于接收输入缓存里的不匹配%d的内容，这样保证输入缓存里没有内容，下次的scanf就会接收新输入的，如果没有这句，那么输入缓存的内容还是会和%d匹配，不匹配，继续返回0，这样就成了无限循环～ 额，好像跟那个getchar()接收回车一样。 但while那里还是不明白，如果我输入days为5，那么5！=1为真（逻辑值即非零），为什么不进入循环？[/quote] 是返回值，返回值要么是0或EOF，要么是输入的匹配的个数[/quote] 懂了懂了，厉害[/quote] 怎么发不出消息", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:[quote=引用 3 楼 weixin_45544561 的回复:][quote=引用 1 楼 自信男孩的回复:]scanf的返回值不等1（注意scanf中只有一个%d，因此等于1是正常的输入），说明输入的不匹配%d，那么scanf(\"%*s\");就是用于接收输入缓存里的不匹配%d的内容，这样保证输入缓存里没有内容，下次的scanf就会接收新输入的，如果没有这句，那么输入缓存的内容还是会和%d匹配，不匹配，继续返回0，这样就成了无限循环～ 额，好像跟那个getchar()接收回车一样。 但while那里还是不明白，如果我输入days为5，那么5！=1为真（逻辑值即非零），为什么不进入循环？[/quote] 是返回值，返回值要么是0或EOF，要么是输入的匹配的个数[/quote] 懂了懂了，厉害", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 3 楼 weixin_45544561 的回复:[quote=引用 1 楼 自信男孩的回复:]scanf的返回值不等1（注意scanf中只有一个%d，因此等于1是正常的输入），说明输入的不匹配%d，那么scanf(\"%*s\");就是用于接收输入缓存里的不匹配%d的内容，这样保证输入缓存里没有内容，下次的scanf就会接收新输入的，如果没有这句，那么输入缓存的内容还是会和%d匹配，不匹配，继续返回0，这样就成了无限循环～ 额，好像跟那个getchar()接收回车一样。 但while那里还是不明白，如果我输入days为5，那么5！=1为真（逻辑值即非零），为什么不进入循环？[/quote] 是返回值，返回值要么是0或EOF，要么是输入的匹配的个数", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:scanf的返回值不等1（注意scanf中只有一个%d，因此等于1是正常的输入），说明输入的不匹配%d，那么scanf(\"%*s\");就是用于接收输入缓存里的不匹配%d的内容，这样保证输入缓存里没有内容，下次的scanf就会接收新输入的，如果没有这句，那么输入缓存的内容还是会和%d匹配，不匹配，继续返回0，这样就成了无限循环～ 额，好像跟那个getchar()接收回车一样。 但while那里还是不明白，如果我输入days为5，那么5！=1为真（逻辑值即非零），为什么不进入循环？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:scanf的返回值不等1（注意scanf中只有一个%d，因此等于1是正常的输入），说明输入的不匹配%d，那么scanf(\"%*s\");就是用于接收输入缓存里的不匹配%d的内容，这样保证输入缓存里没有内容，下次的scanf就会接收新输入的，如果没有这句，那么输入缓存的内容还是会和%d匹配，不匹配，继续返回0，这样就成了无限循环～ 好像跟那个getchar()接收回车键一样。懂了一些。但while里面的条件，如果开始我输入为5，即days为5，5!=1为真(即非零。)为什么不进入循环？", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "scanf的返回值不等1（注意scanf中只有一个%d，因此等于1是正常的输入），说明输入的不匹配%d，那么scanf(\"%*s\");就是用于接收输入缓存里的不匹配%d的内容，这样保证输入缓存里没有内容，下次的scanf就会接收新输入的，如果没有这句，那么输入缓存的内容还是会和%d匹配，不匹配，继续返回0，这样就成了无限循环～", "referer": "user-0"}]}
{"question": "c语言不定参数出错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 10 楼 yyang0514 的回复:[quote=引用 5 楼 自信男孩 的回复:][quote=引用 3 楼 yyang0514 的回复:][quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h>  int print(const char *format, ...) {     va_list args;     const char *args1;     va_start(args, format);      //printf(\"%s.....\", format);     while(1)     {         args1 = va_arg(args,const char *);         if (args1 == NULL)             break;         printf(\"%s.....\",args1);         /*            if(strlen(args1))            printf(\"%s.....\",args1);            else            break;            */     }     va_end(args);     printf(\"\\n\");     return 0; } int main() {     print(\"aaaaa\", \"22222\", \"333333\", NULL);     //print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");     return 0; } 供参考～  缺少结束标识 有没有办法在有调用时，不用输入结束符呢。[/quote] 那可以试试用参数个数，即输入一个确定参数用于标识参数的个数[/quote] 非常感谢你的帮助。 请问为什么调用有4个参数，又不要加结束符的时候，输出又是正确的。 print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");[/quote] 这种情况应该是随机的吧，当遇到第5个（越界了）正好是strlen(第5个）长度小于等于0.  越界访问操作是未定义的，结果不确定的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 自信男孩 的回复:[quote=引用 3 楼 yyang0514 的回复:][quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h>  int print(const char *format, ...) {     va_list args;     const char *args1;     va_start(args, format);      //printf(\"%s.....\", format);     while(1)     {         args1 = va_arg(args,const char *);         if (args1 == NULL)             break;         printf(\"%s.....\",args1);         /*            if(strlen(args1))            printf(\"%s.....\",args1);            else            break;            */     }     va_end(args);     printf(\"\\n\");     return 0; } int main() {     print(\"aaaaa\", \"22222\", \"333333\", NULL);     //print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");     return 0; } 供参考～  缺少结束标识 有没有办法在有调用时，不用输入结束符呢。[/quote] 那可以试试用参数个数，即输入一个确定参数用于标识参数的个数[/quote] 非常感谢你的帮助。 请问为什么调用有4个参数，又不要加结束符的时候，输出又是正确的。 print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 7 楼 赵4老师 的回复:无论在编译期还是运行时，我既不事先告诉你总数，也不告诉你用于标记结束参数计数的结束符，实际到底有几个参数，你猜猜看？  请问什么调用有4个参数，又不要加结束符的时候，输出又是正确的。 print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "要实现智能的可变参数函数，必须依赖编译器支持，否则做不到。即便printf、scanf之类的函数也不是真正智能，实际传入的参数数量和类型完全可以和格式化串中的不一样，它也不知道，还在傻干呢~", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "无论在编译期还是运行时，我既不事先告诉你总数，也不告诉你用于标记结束参数计数的结束符，实际到底有几个参数，你猜猜看？", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "供参考： 可变参数在编程中要注意的问题：因 为va_start, va_arg, va_end等定义成宏,所以它显得很愚蠢, 可变参数的类型和个数完全在该函数中由程序代码控制,它并不能智能地识别不同参数的个数和类型. 有人会问:那么printf中不是实现了智能识别参数吗?那是因为函数 printf是从固定参数format字符串来分析出参数的类型,再调用va_arg 的来获取可变参数的.也就是说,你想实现智能识别可变参数的话是要通过在自己的程序里作判断来实现的. 例如，在C的经典教材《the c programming language》的7.3节中就给出了一个printf的可能实现方式. 在实际应用的代码中，程序员必须自己考虑确定参数数目的办法，如： ⑴在固定参数中设标志-- printf函数就是用这个办法。 ⑵在预先设定一个特殊的结束标记，就是说多输入一个可变参数，调用时要将最后一个可变参数的值设置成这个特殊的值，在函数体中根据这个值判断是否达到参数的结尾。 无论采用哪种办法，程序员都应该在文档中告诉调用者自己的约定。 例子，供参考：//下面是一个简单的printf函数的实现，参考了<The C programming language>7.3节中的例子，从固定 //参数format字符串来分析出参数的个数,再调用va_arg 的来获取可变参数.  //如果参数的类型不同呢？因为不同的数据类型占用的字节数可能是不一样的（如double型为8个字符， //short int型为2个），所以很难事先确定应该移动多少个字节！ //但是办法还是有的，这就是使用指针了，无论什么类型的指针，都是占用4个字节，所以，可以把所有 //的传入参数都设置为指针，这样一来，就可以通过移动固定的4个字节来实现遍历可变参数的目的了。  #include <stdio.h> #include <stdlib.h>  void myprintf(char* fmt, ...)//一个简单的类似于printf的实现，参数必须都是int 类型 {     char* pArg=NULL;      //等价于va_list     char c;     pArg = (char *)&fmt;  //对参数取地址     pArg += sizeof(fmt);  //等价于va_start,取得第一个参数地址     do{         c =*fmt;         if (c != '%'){             putchar(c);   //照原样输出字符         }         else{             switch(*++fmt){ //按格式字符输出数据                 case 'd':                         printf(\"%d\",*((int*)pArg));                         break;                 case 'x':                         printf(\"%#x\",*((int*)pArg));                         break;                 default:                         break;             }             pArg += sizeof(int);//等价于va_arg，下一个参数地址         }         ++fmt;     }while(*fmt != '\\0');     pArg = NULL;               //等价于va_end     return; } int main(int argc, char* argv[]) {     int i = 13000;     int j = 13500;     myprintf(\"test1:i=%d\\n\",i,j);     myprintf(\"test2:i=%d;%x;j=%d;\\n\",i,0x57cd,j);      system(\"pause\");     return 0; }  //test1:i=13000 //test2:i=13000;0x57cd;j=13500; //请按任意键继续. . .", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "引用 3 楼 yyang0514 的回复:[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h>  int print(const char *format, ...) {     va_list args;     const char *args1;     va_start(args, format);      //printf(\"%s.....\", format);     while(1)     {         args1 = va_arg(args,const char *);         if (args1 == NULL)             break;         printf(\"%s.....\",args1);         /*            if(strlen(args1))            printf(\"%s.....\",args1);            else            break;            */     }     va_end(args);     printf(\"\\n\");     return 0; } int main() {     print(\"aaaaa\", \"22222\", \"333333\", NULL);     //print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");     return 0; } 供参考～  缺少结束标识 有没有办法在有调用时，不用输入结束符呢。[/quote] 那可以试试用参数个数，即输入一个确定参数用于标识参数的个数", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "https://blog.csdn.net/fishe_r/article/details/894559 https://docs.microsoft.com/zh-cn/cpp/cpp/calling-conventions?view=vs-2017", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h>  int print(const char *format, ...) {     va_list args;     const char *args1;     va_start(args, format);      //printf(\"%s.....\", format);     while(1)     {         args1 = va_arg(args,const char *);         if (args1 == NULL)             break;         printf(\"%s.....\",args1);         /*            if(strlen(args1))            printf(\"%s.....\",args1);            else            break;            */     }     va_end(args);     printf(\"\\n\");     return 0; } int main() {     print(\"aaaaa\", \"22222\", \"333333\", NULL);     //print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");     return 0; } 供参考～  缺少结束标识 有没有办法在有调用时，不用输入结束符呢。", "referer": "user-0"}, {"cid": "11", "user": "user-4", "content": "主函数：int main() { \t print(\"aaaaa\", \"22222\", \"333333\",\"\");//长度为0的字符串 \t print(\"bbbbb\", \"44444\", \"5555555\", \"666666\",\"\"); \t return 0; }", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h>  int print(const char *format, ...) {     va_list args;     const char *args1;     va_start(args, format);      //printf(\"%s.....\", format);     while(1)     {         args1 = va_arg(args,const char *);         if (args1 == NULL)             break;         printf(\"%s.....\",args1);         /*            if(strlen(args1))            printf(\"%s.....\",args1);            else            break;            */     }     va_end(args);     printf(\"\\n\");     return 0; } int main() {     print(\"aaaaa\", \"22222\", \"333333\", NULL);     //print(\"bbbbb\", \"44444\", \"5555555\", \"666666\");     return 0; } 供参考～  缺少结束标识", "referer": "user-0"}]}
{"question": "蓝桥杯c++练习系统提交总是显示运行错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用一维数组就可以，要点在于杨辉三角形是左右对称的，可以用第n层的前半部分计算出第n+1层的后半部分，再逆序复制到前半部分就完成了:  #include <stdio.h>  int main() {   for (int n; ~scanf(\"%d\", &n) && n > 0 && n < 35;)     for (int i = 1, j, m[35] = {0, 1}; i <= n; i++)     {       for (j = i; j > i / 2; j--) m[j] = m[i - j] + m[i - j + 1];       for (j = 2; j <= i / 2; j++) m[j] = m[i - j + 1];       for (j = 1; j <= i; j++) printf(\"%d \", m[j]);       puts(\"\");     }    return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "//杨辉三角 #include <iostream> using namespace std;   int main() {     int n, **p;     cin >> n;     if(n<1) return 0;     if(n>34) n = 34;     p = new int* [n];     for(int i=0; i<n; i++){         p[i] = new int[2*n];    //二维数组申请完毕     }     for(int i=0; i<n; i++){         p[i][0] = 1;         p[i][i] = 1;     }     for(int i=2; i<n; i++){         for(int j=1; j<i; j++){             p[i][j] = p[i-1][j-1] + p[i-1][j];         }     }     //for(int i=0; i<=n; i++){  //越界 i < n     for(int i=0; i<n; i++){         for(int j=0; j<=i; j++){             cout << p[i][j]<<\" \";         }         cout << endl;     }      for (int i = 0; i < n; i++)         delete p[i];     delete p;     return 0; } 供参考～  问题是越界访问了。详见上面的代码；另外，建议加上释放delete空间的操作～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "修改如下，供参考：//杨辉三角 #include <iostream> using namespace std;  int main() { \tint n, **p; \tcin >> n; \tif(n<1) return 0; \tif(n>34) n = 34; \tp = new int* [n]; \tfor(int i=0; i<n; i++){ \t\tp[i] = new int[2*n];    //二维数组申请完毕 \t} \tfor(int i=0; i<n; i++){ \t\tp[i][0] = 1; \t\tp[i][i] = 1; \t} \tfor(int i=2; i<n; i++){ \t\tfor(int j=1; j<i; j++){ \t\t\tp[i][j] = p[i-1][j-1] + p[i-1][j]; \t\t} \t} \tfor(int i=0; i<n; i++){   //for(int i=0; i<=n; i++){ 这句错误，数组越界 \t\tfor(int j=0; j<=i; j++){ \t\t\tcout << p[i][j]<<\" \"; \t\t} \t\tcout << endl; \t} \treturn 0; }  //10 //1 //1 1 //1 2 1 //1 3 3 1 //1 4 6 4 1 //1 5 10 10 5 1 //1 6 15 20 15 6 1 //1 7 21 35 35 21 7 1 //1 8 28 56 70 56 28 8 1 //1 9 36 84 126 126 84 36 9 1 //请按任意键继续. . .", "referer": "user-0"}]}
{"question": "关于gets()函数的返回值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考： //百度百科对fgets函数的解释 //fgtes函数原型是:char *fgets(char *buf, int bufsize, FILE *stream); //从文件结构体指针stream中读取数据，每次读取一行。读取的数据保存在buf指向的字符数组中， //每次最多读取bufsize-1个字符（第bufsize个字符赋'\\0'），如果文件中的该行，不足bufsize个字符， //则读完该行就结束。如若该行（包括最后一个换行符）的字符数超过bufsize-1，则fgets只返回一个 //不完整的行，但是，缓冲区总是以NULL字符结尾，对fgets的下一次调用会继续读该行。函数成功将返回buf， //失败或读到文件结尾返回NULL。因此我们不能直接通过fgets的返回值来判断函数是否是出错而终止的，应该 //借助feof函数或者ferror函数来判断。  //参考：https://my.oschina.net/u/3979769/blog/2208662 //下面这种用法，是安全的判断文件读取结束或者出错的好方式，切忌不能使用while(!feof(fp))， //还有对于fgets的第二个参数是最大能读取文件字符的个数，一般最大的长度是1024字节。 //while(fgets(..., stream)){          /* ... */ //}  //if(ferror(stream)){          /* ... */ //}  //stream：文件指针，如果读键盘输入的字符串，固定写为stdin //（1）如果键盘输入的字符个数少于bufsize-1个，函数会将回车录走，输出是将回车打印出来； //（2）如果键盘输入的字符大于bufsize-1个，函数录走bufsize-1个字符后，剩下的字符留在数据缓冲区，下次 //直接读取缓冲区内容，不会等键盘输入而跳过输入，导致输入失败。  //返回值 //1.成功，则返回第一个参数buf； //2.在读字符时遇到eof，则eof指示器被设置，如果还没读入任何字符就遇到这种情况，则buf保持原来的内容，返回NULL； //3.如果发生读入错误，error指示器被设置，返回NULL，buf的值可能被改变。  //如何处理掉换行符？ //遍历字符串，遇到换行符，并将其替换成空字符。遇到空字符，就丢弃输入行剩余的字符。  //为什么要丢弃过长输入行中的余下字符？ //输入行中多出来的字符会被留在缓冲区中，成为下一次读取语句的输入。  //读取整行输入并用空字符代替换行符，或者读取部分输入，并丢弃其余部分 char * s_gets(char *st,int n) { \tchar *ret_val; \tint i=0; \tret_val = fgets(st,n,stdin); \tif(ret_val!=NULL) \t{ \t\twhile(st[i]!='\\n' && st[i]!='\\0') \t\t\ti++;  \t\tif(st[i]=='\\n') \t\t\tst[i]='\\0'; \t\telse \t\t\twhile(getchar()!='\\n') \t\t\t\tcontinue; \t} \treturn ret_val; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "fgets() returns s on success, and NULL on error or when end of file occurs while no characters have been read.  输入EOF就可以返回NULL，输入EOF的方式请详见楼上的回复！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "windows <enter> <ctrl+z> <enter>  linux <ctrl+d>", "referer": "user-0"}]}
{"question": "大一学生，学c语言，这个题我。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "#include<stdio.h>void pai(int a[],int n);int main(){\tint a[1000],b[1000],yin;\tint c[500];\tint m;\tscanf(\"%d\",&m);\tfor(int j=0;j<m;j++)\t{\t\tint n,i;\t\tscanf(\"%d\",&n);\t\tfor(i=0;i<n;i++)\t\t{\t\t\tscanf(\"%d\",&a[i]);\t\t}\t\tfor(i=0;i<n;i++)\t\t{\t\t\tscanf(\"%d\",&b[i]);\t\t}\t\tpai(a,n);  \t\tpai(b,n);\t\tint fast1=0,slow1=n-1,fast2=0,slow2=n-1;\t\tint win=0,lose=0;\t\tfor(i=0;i<n;i++)      \t\t{\t\t\tif(a[fast1]>b[fast2])    \t\t\t{\t\t\t\twin++;\t\t\t\tfast1++;\t\t\t\tfast2++;\t\t\t}\t\t\telse if(a[slow1]>b[slow2])  \t\t\t{\t\t\t\twin++;\t\t\t\tslow1--;\t\t\t\tslow2--;\t\t\t}\t\t\telse\t\t\t{\t\t\t\tif(a[slow1]<b[fast2])\t\t\t\t{\t\t\t\t\tlose++;\t\t\t\t\tslow1--;\t\t\t\t\tfast2++;\t\t\t\t}\t\t\t}\t\tyin=(win-lose)*200;\t}\tc[j]=yin;}    for(int k=0;k<m;k++)    {    \tprintf(\"%d\\n\",c[k]);\t}\treturn 0;}void pai(int a[],int n){\tint i,j,temp;\tfor(i=0;i<n-1;i++)\t{\t\tfor(j=i+1;j<n;j++)\t\t{\t\t\tif(a[j]>a[i])\t\t\t{\t\t\t\ttemp=a[j];\t\t\t\ta[j]=a[i];\t\t\t\ta[i]=temp;\t\t\t}\t\t}\t}}嗯 写对了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这题可以用贪心算法来，首先我们只要尽可能多让田忌的马比齐王的马快， 同时要保证刚刚好田忌的马比齐王的马快，同时要保证这匹马是田忌所有比齐王快的马中的速度最小的那匹马， 所以我们可以先给齐王和田忌的马都由小到大排好序，将田忌的马的速度遍历，如果田忌马比齐王马快，记好这匹马，然后 双方的马同时后移就好。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "对比2个数据都大于即可", "referer": "user-0"}]}
{"question": "请问显示insert为找不到标识符是什么情况", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<malloc.h> #define MAX_SIZE 10 typedef struct {     int* data;     int length;     int Maxsize; }SqeList;  void Insert(SqeList& L);  int main() {     SqeList L;     Insert(L);     return 0; } void Insert(SqeList& L) {     L.data = (int*)malloc(MAX_SIZE * sizeof(int));     L.length = 0;     //L.Maxsize = 10;     L.Maxsize = MAX_SIZE; } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "调用的函数在main函数之后的话需要声明，之前则不用", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "函数声明要在前，修改如下，供参考：#include<stdio.h> #include<malloc.h> #define a 10 typedef struct {    int* data;    int length;    int Maxsize; }SqeList;  void Insert(SqeList& L);//函数声明在前  int main() {    SqeList L;    Insert(L);//调用在后    return 0; }  void Insert(SqeList& L) {    L.data = (int*)malloc(a * sizeof(int));    L.length = 0;    L.Maxsize = 10; }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "函数写在主函数之后，都必须先生命函数原型。", "referer": "user-0"}]}
{"question": "主函数中的代码问题：字符输入超过4个就处于无限输入状态", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢大家，从一个简单的问题把以前学的C语言捡起来一些了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "题主的问题给的条件不是很完整，下面我会假设题主的问题在进行解答: 1.这个程序的目的应该是输入一个数字N作为字符长度。 2.之后通过for循环让数组A接受字符。  先讲程序出现的第一个问题 char A[]={'\\0'}; 这样定义的数组会根据字符的长度来分配数组长度 所以该段代码相当于 char A[0] = '\\0';    (因为'\\0' 长度为1) 要实现上面的代码应该给数组分配足够的空间   设置char A[255] = {0}  或者 使用new(这个可以分配任意空间)   就不会出现上面问题。  最后讲讲程序为什么会出现 ’ 输入超过4个就处于无限输入状态 ‘    的问题   编译器会根据变量的顺序来分配空间 所以变量在内存中的形式大概是 A     00 00 00 00   (char类型  4字节    这里虽然为char类型但编译器还是会分配4个字节  ，这个不做深究)  N    00 00 00 00    (int 类型  4字节) i      00 00 00 00    (int 类型  4字节)  讲这个的目的是让你知道，&A[4]  取第5个字节时 实际上是对应N的空间  会改变N的大小 (可以调试或者printf  打印N看看) 所以会导致无限循环，。。。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主，数组A只有1个字符的长度，当你输入N>1的时候，数组就越界了，那个>1空间的内容就不可控了，碰运气了。修改如下，供参考：#include<stdio.h> int main() {    int i,N;    char *A;    //char A[]={'\\0'}; //这句定义的只是一个字符长度    printf(\"请输入字符的数量：\\n\");    scanf(\"%d\",&N);    getchar();    A = new char[N];//动态字符数组    printf(\"请输入:\\n\");    for(i=0;i<N;i++)     {       scanf(\"%c\",&A[i]);       printf(\"A[%d]=%c\\n\",i,A[i]);//输出 看看是否正确     }    printf(\"输入完成\\n\");    delete []A;    return 0; }  //请输入字符的数量： //15 //请输入: //Happy New Year! //A[0]=H //A[1]=a //A[2]=p //A[3]=p //A[4]=y //A[5]= //A[6]=N //A[7]=e //A[8]=w //A[9]= //A[10]=Y //A[11]=e //A[12]=a //A[13]=r //A[14]=! //输入完成 //请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "一个简单道理：没被发现错误不等于没有错误。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "打一个稍有冒犯但是恰当的比方： 你要是偷了3次东西还没被抓住，你是否认为那是因为3小于等于4呢？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-3的回复:从错误出发得到正确的概率无穷小，得到错误就很正常了。 数组A只有1个字符的长度，所以错了。 但是输入的字符数小于等于4个就可以", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "从错误出发得到正确的概率无穷小，得到错误就很正常了。 数组A只有1个字符的长度，所以错了。", "referer": "user-0"}]}
{"question": "求指导", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3的回复:你这个照片上的干涉条纹看得我脑壳疼，就不能复制文本发上来吗？  问题大概出在i++上面，因为#define是直接替换的，所以第二张图里的SQ(i++)会被替换成(i++)*(i++), 就多加了一次。 对不起  下次就直接复制粘贴", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "//调用函数时： //1   i=1 -> while(i<=5) -> printf(\"SQ=%d\\n\",SQ(i++)); 1*1 =`1,i(i++) = 2; //4   i=2 -> while(i<=5) -> printf(\"SQ=%d\\n\",SQ(i++)); 2*2 = 4,i(i++) = 3; //9   i=3 -> while(i<=5) -> printf(\"SQ=%d\\n\",SQ(i++)); 3*3 = 9,i(i++) = 4; //16  i=4 -> while(i<=5) -> printf(\"SQ=%d\\n\",SQ(i++)); 4*4 =16,i(i++) = 5; //25  i=5 -> while(i<=5) -> printf(\"SQ=%d\\n\",SQ(i++)); 5*5 =25,i(i++) = 6; //请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考：//带参数的宏定义和函数之间有一定类似之处，但本质上有区别: //1.函数调用时，先求出实参表达式的值，然后代入形参，而使用带参数的宏只是进行字符替换。 //2.函数调用是在程序运行时处理的，为形参分配临时的内存单元。而宏置换则是在预处理阶段进行的，在置换时并不分配内存单元， //不进行值的传递处理，也没有“返回值”的概念。 //3.对函数中的实参和形参都要定义类型，二者的类型要求一致，如不一致，应进行类型转换。而宏不存在类型问题，宏名无类型， //它的参数也无类型，只是一个符号代表，置换时，代入指定的字符串即可。定义宏时，字符串可以是任何类型的数据。 //4.调用函数只可得到一个返回值，而用宏可以设法得到几个结果。 //5.使用宏次数多时，宏展开后源程序变长，因为每展开一次都使程序增长，而函数调用不会使源程序变长。 //6.宏替换不占运行时间，只占预处理时间。而函数调用则占运行时间(分配单元、保留现场、值传递、返回)。  #include<stdio.h> #define SQ(y) ((y)*(y))  //带参数的宏定义:带参数的宏定义不是进行简单的字符串替换，还要进行参数替换 //#define  S(r)  PI*r*r //area=S(a+b);  → area=PI * a+b * a+b; //#define  S(r)  PI*(r)*(r) //area=S(a+b);  → area=PI*(a+b)*(a+b);  int main() {     int i=1;     while(i<=5){         printf(\"%d\\n\",SQ(i++));         //这句替换为:         //printf(\"%d\\n\",((i++)*(i++)));     }     return 0; }  //2      i=1 -> while(i<=5) -> printf(\"%d\\n\",((i++)*(i++))); 1 * (i++)2 =2,  i(i++)=3; //12     i=3 -> while(i<=5) -> printf(\"%d\\n\",((i++)*(i++))); 3 * (i++)4 =12, i(i++)=5; //30     i=5 -> while(i<=5) -> printf(\"%d\\n\",((i++)*(i++))); 5 * (i++)6 =30, i(i++)=6; //请按任意键继续. . .", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "你这个照片上的干涉条纹看得我脑壳疼，就不能复制文本发上来吗？  问题大概出在i++上面，因为#define是直接替换的，所以第二张图里的SQ(i++)会被替换成(i++)*(i++), 就多加了一次。", "referer": "user-0"}]}
{"question": "C语言中的match函数在哪个头文件里？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "新手路过学习。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Match函数是Excel中使用较为广泛的一个函数。其主要作用是：在“范围”单元格中搜索特定的项，然后返回该项在此区域中的相对位置。 通俗的将：MATCH函数返回指定值在数组中的位置，如果在数组中没有找到该值则返回…", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "baidu c++ 正则表达式", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "这个需要自己", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 智者知已应修善业的回复:math.h一般见于C、C++程序设计，#include <math.h> 是包含math头文件的意思， .h是头文件的扩展名（header file），这一句声明了本程序要用到标准库中的 math.h文件。math.h头文件中声明了常用的一些数学运算，比如乘方，开方运算等等。 我要的是match", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "math.h一般见于C、C++程序设计，#include <math.h> 是包含math头文件的意思， .h是头文件的扩展名（header file），这一句声明了本程序要用到标准库中的 math.h文件。math.h头文件中声明了常用的一些数学运算，比如乘方，开方运算等等。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "C语言没有这个函数 好了 下一题", "referer": "user-0"}]}
{"question": "求助，C中怎么把字符串用其ASCII hex形式打印出来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 qzjhjxj 的回复：综合上面1# 2# 3# 楼的，供参考：//C中怎么把字符串用其ASCII hex形式打印出来  //比如char string[]=“{Temeprature=25.61,Humidity=15.62}”，用printf(\"%02X\",string)输出出来是407A40， //其一，输出不完全，其二并不是{Temeprature=25.61,Humidity=15.62}的ASCII hex形式，{Temeprature=25.61,Humidity=15.62} //全部按ASCII hex转换应该是0x7b 0x54 0x65 0x6d 0x65 0x70 0x72 0x61 0x74 0x75 0x72 0x65 0x3d 0x32 0x35 0x2e 0x36 0x31 // 0x2c 0x48 0x75 0x6d 0x69 0x64 0x69 0x74 0x79 0x31 0x35 0x2e 0x36 0x32 0x7d， //目前在网上找到的历例程，对于{}、，，.这样的符号都没法转换，请问各位有能将字符串以其hex形式打印出来的例程吗？谢谢  #include <stdio.h> #include <string.h>  int main() {    char  string[]=\"{Temeprature=25.61,Humidity=15.62}\";    char *p=string;    while(*p)printf(\"0x%02x \",*p++);//指针    printf(\"\\n\");    for(int len=0;len <sizeof(string); len++)//string 是数组，要传值使用string[下标]。      {        printf(\"0x%02X \",string[len]);      }    return 0; }  //输出： //0x7b 0x54 0x65 0x6d 0x65 0x70 0x72 0x61 0x74 0x75 0x72 0x65 0x3d 0x32 0x35 0x2e 0x36 0x31 0x2c 0x48 0x75 0x6d 0x69 0x64 0x69 0x74 0x79 0x3d 0x31 0x35 0x2e 0x36 0x32 0x7d //0x7B 0x54 0x65 0x6D 0x65 0x70 0x72 0x61 0x74 0x75 0x72 0x65 0x3D 0x32 0x35 0x2E 0x36 0x31 0x2C 0x48 0x75 0x6D 0x69 0x64 0x69 0x74 0x79 0x3D 0x31 0x35 0x2E 0x36 0x32 0x7D 0x00 请按任意键继续. . .非常感谢您。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 突触 的回复：你基础不是很牢。。  string 是数组，如果不带下标作为参数时，类似于指针    传递的是元素的首地址。 要传值使用string[下标]。  在讲讲printf     里面的 \"%02X\"       \"%s\"         \"%d\"     分别会把参数以不同的形式读取(作为指针，或直接是数据)    其中\"%02X\" ，\"%d\" 是数据形式读取， \"%s\" 是作为指针形式。   要实现的话可能就需要循环。 改正:  \tchar string[]= \"{Temeprature=25.61,Humidity=15.62}\"; \t\t \tfor(int len=0;len <sizeof(string); len++) \t{ \t\tprintf(\"0x%02X \",string[len]); \t}非常感谢。在下确实刚刚接触编程", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "综合上面1# 2# 3# 楼的，供参考：//C中怎么把字符串用其ASCII hex形式打印出来  //比如char string[]=“{Temeprature=25.61,Humidity=15.62}”，用printf(\"%02X\",string)输出出来是407A40， //其一，输出不完全，其二并不是{Temeprature=25.61,Humidity=15.62}的ASCII hex形式，{Temeprature=25.61,Humidity=15.62} //全部按ASCII hex转换应该是0x7b 0x54 0x65 0x6d 0x65 0x70 0x72 0x61 0x74 0x75 0x72 0x65 0x3d 0x32 0x35 0x2e 0x36 0x31 // 0x2c 0x48 0x75 0x6d 0x69 0x64 0x69 0x74 0x79 0x31 0x35 0x2e 0x36 0x32 0x7d， //目前在网上找到的历例程，对于{}、，，.这样的符号都没法转换，请问各位有能将字符串以其hex形式打印出来的例程吗？谢谢  #include <stdio.h> #include <string.h>  int main() {    char  string[]=\"{Temeprature=25.61,Humidity=15.62}\";    char *p=string;    while(*p)printf(\"0x%02x \",*p++);//指针    printf(\"\\n\");    for(int len=0;len <sizeof(string); len++)//string 是数组，要传值使用string[下标]。      {        printf(\"0x%02X \",string[len]);      }    return 0; }  //输出： //0x7b 0x54 0x65 0x6d 0x65 0x70 0x72 0x61 0x74 0x75 0x72 0x65 0x3d 0x32 0x35 0x2e 0x36 0x31 0x2c 0x48 0x75 0x6d 0x69 0x64 0x69 0x74 0x79 0x3d 0x31 0x35 0x2e 0x36 0x32 0x7d //0x7B 0x54 0x65 0x6D 0x65 0x70 0x72 0x61 0x74 0x75 0x72 0x65 0x3D 0x32 0x35 0x2E 0x36 0x31 0x2C 0x48 0x75 0x6D 0x69 0x64 0x69 0x74 0x79 0x3D 0x31 0x35 0x2E 0x36 0x32 0x7D 0x00 请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你基础不是很牢。。  string 是数组，如果不带下标作为参数时，类似于指针    传递的是元素的首地址。 要传值使用string[下标]。  在讲讲printf     里面的 \"%02X\"       \"%s\"         \"%d\"     分别会把参数以不同的形式读取(作为指针，或直接是数据)    其中\"%02X\" ，\"%d\" 是数据形式读取， \"%s\" 是作为指针形式。   要实现的话可能就需要循环。 改正:  \tchar string[]= \"{Temeprature=25.61,Humidity=15.62}\"; \t\t \tfor(int len=0;len <sizeof(string); len++) \t{ \t\tprintf(\"0x%02X \",string[len]); \t}", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "char *p=string; while(*p)printf(\"0x%02x \",*p++);", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "循环一个一个字符地打印", "referer": "user-0"}]}
{"question": "为什么我这代码还是超时", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "学习学习，C没碰过、、", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "如此说来这就是水题，卡I/O时间而已，C用getline/gets应该也可以过：  #include <stdio.h>  char buf[1048576]; int i, j, n[4] = {0};  int main() {   gets(buf);   for (i = 0; buf[i];) n[buf[i++] & 3]++;   for (i = 1, j = 0; i <= 4; i++) while(n[i & 3]--) buf[j++] = i + 96;   puts(buf);    return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "也就是说像我在17，18楼说的那样， 17 开大缓冲区，整行一次输入即可。 18 系统不会鉴定什么O，都是逗你玩的。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "学习一下，问题应该出现在排序算法上", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "试试这个能不能过#include <stdio.h> #include <stdlib.h>  int cmp(const void *a, const void *b) {     return *(char *)a - *(char *)b; }  int main() {    char ch[1024];    gets(ch);    qsort(ch,strlen(ch),sizeof(char),cmp);    puts(ch);       return 0; }  //abaaccbdbdbdabbabcbcabdcabdcbadbcabdcbadbcbadbcabdcabaaccbdbdbdabbabcbcabdcabdcbadbcabdcbadbcbadbcabdc //aaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccdddddddddddddddddddd //请按任意键继续. .", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "引用 26 楼 m0_55067373 的回复:[quote=引用 22 楼 Chivas_/Regal 的回复:]#include<bits/stdc++.h> using namespace std; int main () {     string s;     cin>>s;     sort(s.begin(),s.end());     cout<<s; }  过了，我看到学校其他成功通过的都是用的c++,c语言提交的都失败了[/quote] 其实如果用一下快排流程的话也可以用C过，我这个sort就是为了方便也懒得打快排了。。。。。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 22 楼 Chivas_/Regal 的回复:#include<bits/stdc++.h> using namespace std; int main () {     string s;     cin>>s;     sort(s.begin(),s.end());     cout<<s; }  过了，我看到学校其他成功通过的都是用的c++,c语言提交的都失败了", "referer": "user-0"}, {"cid": "10", "user": "user-9", "content": "unistd.h time(nullptr)现在时间，结束时-开始时，算下时间有帮助", "referer": "user-0"}, {"cid": "11", "user": "user-9", "content": "两下时间。。", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "sort的时间复杂度是O(n*logn)", "referer": "user-0"}, {"cid": "13", "user": "user-8", "content": "#include<bits/stdc++.h> using namespace std; int main () {     string s;     cin>>s;     sort(s.begin(),s.end());     cout<<s; }", "referer": "user-0"}, {"cid": "14", "user": "user-10", "content": "test: 'abaaccbdbdbdabbabcbcabdcabdcbadbcabdcbadbcbadbcabdc'.split('').sort((a, b) => a.charCodeAt(0)-b.charCodeAt(0)).join('') res: \"aaaaaaaaaaaabbbbbbbbbbbbbbbbbbcccccccccccdddddddddd\"", "referer": "user-0"}, {"cid": "15", "user": "user-11", "content": "算法的问题了", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "至于O(n)还是O(1)的，我不认为一个OJ真的能识别得出来，何况大O本来就是个模糊概念。", "referer": "user-0"}, {"cid": "17", "user": "user-5", "content": "还有两种可能。 一是行长度确有上限，可以一次一行弄进来在内存里分析，比一次又一次输入快得多。 二是系统输入不止一行却不肯明说，我们处理一行就歇了，当然会超时。", "referer": "user-0"}, {"cid": "18", "user": "user-3", "content": "那就是算法的问题了，必须找到更高效的算法", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "引用 14 楼 早打大打打核战争 的回复:再简化一些：  #include <stdio.h>  int main() {   int n[4] = {0};    for (char c; (c = getchar()) != 10;) n[c & 3]++;   for (int i = 1; i <= 4; i++) while(n[i & 3]--) putchar(i + 96);   puts(\"\");    return 0; }   还是超时。。。", "referer": "user-0"}, {"cid": "20", "user": "user-3", "content": "再简化一些：  #include <stdio.h>  int main() {   int n[4] = {0};    for (char c; (c = getchar()) != 10;) n[c & 3]++;   for (int i = 1; i <= 4; i++) while(n[i & 3]--) putchar(i + 96);   puts(\"\");    return 0; }", "referer": "user-0"}]}
{"question": "求助，结构体写入出现了错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "还有，不能那样初始化FileData，还是老老实实strcpy吧。 说到这里，应该通不过编译才对，谈何运行啊，费解。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "补充： 形参里引用字符串都不规范，字符串形参char*类型就可以了，后面的方括号都去掉。 另外对形参字符串sizeof没啥用，还是strlen+1吧。  读文件的函数里居然先读一个字符，然后再读结构体。啃过一口的苹果还拿来卖，你是乔布斯啊？ 读字符和读结构体之间需要rewind或者fseek回去才行。  主函数里的 scanf_s(\"%s\",FileName,29);", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "代码太长，大概溜了一眼。 首先，MagicNumber[4]的长度为4，FDW1={“SOT\\n” 这样的方式赋值造成数组越界（字符串多个\\0字符）； 其次，二进制写入文件，文件内容都是二进制，本来就看不到“嘿嘿嘿，测试运行”这样的字符串 第三，FDR1.MagicNumber != “SOT\\n” 这样的比较是错的（这是地址比较），字符串比较要用strcmp。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "\"嘿嘿嘿，测试运行'，这句话不知道为什么没有被写入", "referer": "user-0"}]}
{"question": "链栈问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "p = S; free(p); 不就是free(S)了么", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h> #include <stdbool.h>  //#define Stack_ElemType int typedef  int Stack_ElemType;// int typedef struct StackNode {     struct StackNode* next;     Stack_ElemType data; }StackNode,*LinkStack;  //链栈初始化 // 返回的是链栈的首地址 //StackNode* initStack(LinkStack S) { StackNode* initStack(LinkStack *S) {     *S = (LinkStack)malloc(sizeof(StackNode));     if (*S == NULL) {         printf(\"内存分配不成功！\\n\");         return 0;     }//;     (*S)->next = NULL;     return *S; } //; //创建链栈 StackNode* CreatStack(LinkStack S) {     StackNode* p;     int j = 1;     Stack_ElemType t = 0;     while (j) {         printf(\"请输入栈顶元素,输入-1时结束创建\\n \");         //scanf_s(\"%d\", &t);         scanf(\"%d\", &t);         if (t == -1) {             break;         }         p = (LinkStack)malloc(sizeof(StackNode));         if (p == NULL) {  // 动态分配空间后要进行判断否则会有警告             printf(\"内存分配不成功！\\n\");             //return 0;             return S;         }//;         p->data = t;         p->next = S;         S = p;     }//;      return S; } // 链栈的压栈 void pushStack(LinkStack &S, Stack_ElemType e) {     StackNode* p;     p = (LinkStack)malloc(sizeof(StackNode));     if (p == NULL) {  // 动态分配空间后要进行判断否则会有警告         printf(\"内存分配不成功！\\n\");         return;     }     p->data = e;     p->next = S;     printf(\"%d\\n\", p->data);     S = p;// 现在栈顶为刚压栈的p的结点  }; StackNode* popStack(LinkStack S, Stack_ElemType* e) {     StackNode *p;     if (S == NULL) {         //return 0;         return NULL;     }     *e = S->data;     p = S;     S = S->next;     free(p);     return S; }//;  Stack_ElemType StackLenth(StackNode S) {     int i = 1;     StackNode* p;     p = S.next;     while (p) {         p = p->next;         i++;     }//;     return i; }  int main(void) {     StackNode* S;     S = NULL;     Stack_ElemType j = 0;     S = initStack(&S);     S = CreatStack(S);      //for (int i = 0; i < 5; i++) {     for (int i = 0; S; i++) {         S = popStack(S, &j);         if (S)             printf(\"%d\\n\", j);     }//;     S = popStack(S, &j);     if (S)         printf(\"%d\\n\", j);     return 0; }   供参考～  多处出现了多余的分号;其他问题，供参考～", "referer": "user-0"}]}
{"question": "结构体里的动态数组输入问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 真相重于对错的回复:initlist里面的 num是main里面的副本，在那个函数里的任何操作对于main 里面的num无效 嗯嗯，我把这个给忘记了。谢谢谢谢谢谢~", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 7 楼 qzjhjxj的回复:[quote=引用 4 楼 weixin_53443263 的回复:][quote=引用 3 楼 qzjhjxj的回复:]修改如下，供参考：#include <stdio.h> #include <stdlib.h> #define max_size 100 typedef struct {     int length;     int *arr; }sqlist;  int initlist_sq(sqlist &num) //int initlist_sq(sqlist num) {     num.arr=(int*)malloc(sizeof(int)*(max_size));     if(!num.arr)        exit(EXIT_FAILURE);     num.length=0;     return 0; }  int main() {     sqlist num;     int i,n,flag;     flag=initlist_sq(num);     if(flag) printf(\"allocation failed\\n\");     else     printf(\"successful\\n\");      scanf(\"%d\",&num.length);     for(i=0;i<num.length;i++)         scanf(\"%d\",&num.arr[i]);          return 0;  } 你就只是加了个&吧。加了之后连编译都不通过了，而且我们定义的num也不是指向结构体的指针变量吧。[/quote] 我这里是运行通过的，没出现你说的编译问题： 这个初始化int initlist_sq(sqlist num)函数里的num和main()函数里的num是两个不同内存空间，不通过地址让他们产生联系，光值没用啊。[/quote] 我刚刚查了一下，发现你这个参数列表中加的取地址运算符是C++语法的，我这个是C语言的，所以没法直接，我刚刚换成指针就成功了。真心感谢你！", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "initlist里面的 num是main里面的副本，在那个函数里的任何操作对于main 里面的num无效", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 4 楼 weixin_53443263 的回复:[quote=引用 3 楼 qzjhjxj的回复:]修改如下，供参考：#include <stdio.h> #include <stdlib.h> #define max_size 100 typedef struct {     int length;     int *arr; }sqlist;  int initlist_sq(sqlist &num) //int initlist_sq(sqlist num) {     num.arr=(int*)malloc(sizeof(int)*(max_size));     if(!num.arr)        exit(EXIT_FAILURE);     num.length=0;     return 0; }  int main() {     sqlist num;     int i,n,flag;     flag=initlist_sq(num);     if(flag) printf(\"allocation failed\\n\");     else     printf(\"successful\\n\");      scanf(\"%d\",&num.length);     for(i=0;i<num.length;i++)         scanf(\"%d\",&num.arr[i]);          return 0;  } 你就只是加了个&吧。加了之后连编译都不通过了，而且我们定义的num也不是指向结构体的指针变量吧。[/quote] 我这里是运行通过的，没出现你说的编译问题： 这个初始化int initlist_sq(sqlist num)函数里的num和main()函数里的num是两个不同内存空间，不通过地址让他们产生联系，光值没用啊。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 真相重于对错的回复:你的这个内存泄露了 我去网上查了一下内存泄露是指我没用free，不过现在这个不是输入不了的原因吧", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 user-4的回复:没问题，就等着你输入 ，多按几次回车 不行的，到那里就直接跳出了", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:修改如下，供参考：#include <stdio.h> #include <stdlib.h> #define max_size 100 typedef struct {     int length;     int *arr; }sqlist;  int initlist_sq(sqlist &num) //int initlist_sq(sqlist num) {     num.arr=(int*)malloc(sizeof(int)*(max_size));     if(!num.arr)        exit(EXIT_FAILURE);     num.length=0;     return 0; }  int main() {     sqlist num;     int i,n,flag;     flag=initlist_sq(num);     if(flag) printf(\"allocation failed\\n\");     else     printf(\"successful\\n\");      scanf(\"%d\",&num.length);     for(i=0;i<num.length;i++)         scanf(\"%d\",&num.arr[i]);          return 0;  } 你就只是加了个&吧。加了之后连编译都不通过了，而且我们定义的num也不是指向结构体的指针变量吧。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "修改如下，供参考：#include <stdio.h> #include <stdlib.h> #define max_size 100 typedef struct {     int length;     int *arr; }sqlist;  int initlist_sq(sqlist &num) //int initlist_sq(sqlist num) {     num.arr=(int*)malloc(sizeof(int)*(max_size));     if(!num.arr)        exit(EXIT_FAILURE);     num.length=0;     return 0; }  int main() {     sqlist num;     int i,n,flag;     flag=initlist_sq(num);     if(flag) printf(\"allocation failed\\n\");     else     printf(\"successful\\n\");      scanf(\"%d\",&num.length);     for(i=0;i<num.length;i++)         scanf(\"%d\",&num.arr[i]);          return 0;  }", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "没问题，就等着你输入 ，多按几次回车", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "你的这个内存泄露了", "referer": "user-0"}]}
{"question": "求一元二次方程的根", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 楼主 是疗伤烧肉粽~的回复:本题目要求一元二次方程ax^2＋bx＋c＝0的根，结果保留2位小数。 输入格式: 输入在一行中给出3个浮点系数a、b、c，中间用空格分开。 输出格式: 根据系数情况，输出不同结果： 1)如果方程有两个不相等的实数根，则每行输出一个根，先大后小； 2)如果方程有两个不相等复数根，则每行按照格式“实部+虚部i”输出一个根，先输出虚部为正的，后输出虚部为负的； 3)如果方程只有一个根，则直接输出此根； 4)如果系数都为0，则输出\"Zero Equation\"； 5)如果a和b为0，c不为0，则输出\"Not An Equation\"。 #include<stdio.h> #include<math.h> int main(){     double a,b,c,da,s,t;     scanf(\"%lf%lf%lf\",&a,&b,&c);     da=b*b-4*a*c;     if(a==0&&b==0&&c==0)     \tprintf(\"Zero Equation\");\t     else if(a==0&&b==0&&c!=0)     \tprintf(\"Not An Equation\");     else if(da==0)     \tprintf(\"%.2lf\",-b/2/a);\t     else if(a==0)     \tprintf(\"%.2lf\",-c/b); \telse if(da>0)     \tprintf(\"%.2lf\\n%.2lf\",(-b+sqrt(da))/2/a,(-b-sqrt(da))/2/a);\t     else if(da<0){             \ts=-b/(2*a);      \t    t=sqrt(-da)/(2*a);       \tprintf(\"%.2lf+%.2lfi\\n%.2lf-%.2lfi\",s,t,s,t); \t} } 在PTA上有一个测试点(方程有纯虚根)没过，帮忙看看要怎么改 你好，我是一名c语言初学者。我想问一下，你提到的PTA是什么？是一个学习网站吗？还是什么？上面能做题？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "新手飘过学习，读代码，脑袋都大了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "system (“pause “)暂停的意思，方便我们看清结果，这句前面加//可以屏蔽了。 0.0前面的格式是.2lf ，是浮点型啊，0是整型。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "详细解析请参考公众号推文  #include <stdio.h> #include <stdlib.h> #include <math.h>    int main() { double a,b,c,d; printf(\"输入方程的系数a,b,c：\"); scanf(\"%lf%lf%lf\",&a,&b,&c);  if(0==a) {  if(0==b) {   if(0!=c) {         printf(\"不能构成等式\\n\");   } else {          printf(\"这是恒等式0=0\\n\");   }  } else {       printf(\"这是一元一次方程，根为：%lf\\n\",-c/b);  } } else {         d=b*b-4*a*c;//判别式  if(0==d) {       printf(\"两个相等的根，x1=x2=%lf\\n\",-b/(2*a));  } else if(d>0) {   printf(\"两个不相等的根，x1=%lf, x2=%lf\\n\",(-b+sqrt(d))/(2*a),(-b-sqrt(d))/(2*a));  } else {   printf(\"两个虚根,x1=%lf+%lfi,x2=%lf-%lfi\\n\",-b/(2*a),sqrt(-d)/(2*a),-b/(2*a),sqrt(-d)/(2*a));  } }   system(\"pause\"); return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-5 的回复:当da小于0时，如果b = 0，方程实部为零，所有只用显式虚部就行了。  else if(da<0){                 if (b != 0) \t\t{ \t\t\ts=-b/(2*a);              \tt=sqrt(-da)/(2*a);           \tprintf(\"%.2lf+%.2lfi\\n%.2lf-%.2lfi\",s,t,s,t);     \t}     \telse     \t{     \t\tt = sqrt(c/a);     \t\tprintf(\"%.2lfi\\n-%.2lfi\",t,t); \t\t}     } 不对啊，还是过不了", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 qzjhjxj 的回复:供参考：#include<stdio.h> #include<math.h> int main() {         double a,b,c,da;         scanf(\"%lf %lf %lf\",&a,&b,&c);         da = b*b-4*a*c;         if(a!=0){            if(da>0){              printf(\"%.2lf\\n\",(-b+sqrt(da))/(a*2));              printf(\"%.2lf\\n\",(-b-sqrt(da))/(a*2));            }            else if(da < 0){                    if(b!=0){                       printf(\"%.2lf%+.2lfi\\n\",(-b)*1.0/(2*a),sqrt(-da)/(2*a));                       printf(\"%.2lf%+.2lfi\\n\",(-b)*1.0/(2*a),-sqrt(-da)/(2*a));                    }else{                       printf(\"%.2lf%+.2lfi\\n\",0.0,sqrt(-da)*1.0/(2*a));                       printf(\"%.2lf%+.2lfi\\n\",0.0,-sqrt(-da)*1.0/(2*a));                    }            }            else{                    printf(\"%.2lf\\n\",-b*1.0/(2*a));            }         }         else if(a==0&&b==0&&c==0){                 printf(\"Zero Equation\\n\");         }         else if(a==0&&b==0&&c!=0){                 printf(\"Not An Equation\\n\");         }         else if(a==0&&b!=0&&c!=0)                 printf(\"%.2lf\\n\",(-c*1.0)/b);         system(\"pause\");         return 0; } printf(\"%.2lf%+.2lfi\\n\",0.0,sqrt(-da)*1.0/(2*a)); printf(\"%.2lf%+.2lfi\\n\",0.0,-sqrt(-da)*1.0/(2*a)); 为什么这里是0.0才可以，而0不行？？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 3 楼 qzjhjxj 的回复:供参考：#include<stdio.h> #include<math.h> int main() {         double a,b,c,da;         scanf(\"%lf %lf %lf\",&a,&b,&c);         da = b*b-4*a*c;         if(a!=0){            if(da>0){              printf(\"%.2lf\\n\",(-b+sqrt(da))/(a*2));              printf(\"%.2lf\\n\",(-b-sqrt(da))/(a*2));            }            else if(da < 0){                    if(b!=0){                       printf(\"%.2lf%+.2lfi\\n\",(-b)*1.0/(2*a),sqrt(-da)/(2*a));                       printf(\"%.2lf%+.2lfi\\n\",(-b)*1.0/(2*a),-sqrt(-da)/(2*a));                    }else{                       printf(\"%.2lf%+.2lfi\\n\",0.0,sqrt(-da)*1.0/(2*a));                       printf(\"%.2lf%+.2lfi\\n\",0.0,-sqrt(-da)*1.0/(2*a));                    }            }            else{                    printf(\"%.2lf\\n\",-b*1.0/(2*a));            }         }         else if(a==0&&b==0&&c==0){                 printf(\"Zero Equation\\n\");         }         else if(a==0&&b==0&&c!=0){                 printf(\"Not An Equation\\n\");         }         else if(a==0&&b!=0&&c!=0)                 printf(\"%.2lf\\n\",(-c*1.0)/b);         system(\"pause\");         return 0; } system(\"pause\");这句啥意思？？", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "当da小于0时，如果b = 0，方程实部为零，所有只用显式虚部就行了。  else if(da<0){                 if (b != 0) \t\t{ \t\t\ts=-b/(2*a);              \tt=sqrt(-da)/(2*a);           \tprintf(\"%.2lf+%.2lfi\\n%.2lf-%.2lfi\",s,t,s,t);     \t}     \telse     \t{     \t\tt = sqrt(c/a);     \t\tprintf(\"%.2lfi\\n-%.2lfi\",t,t); \t\t}     }", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "供参考：#include<stdio.h> #include<math.h> int main() {         double a,b,c,da;         scanf(\"%lf %lf %lf\",&a,&b,&c);         da = b*b-4*a*c;         if(a!=0){            if(da>0){              printf(\"%.2lf\\n\",(-b+sqrt(da))/(a*2));              printf(\"%.2lf\\n\",(-b-sqrt(da))/(a*2));            }            else if(da < 0){                    if(b!=0){                       printf(\"%.2lf%+.2lfi\\n\",(-b)*1.0/(2*a),sqrt(-da)/(2*a));                       printf(\"%.2lf%+.2lfi\\n\",(-b)*1.0/(2*a),-sqrt(-da)/(2*a));                    }else{                       printf(\"%.2lf%+.2lfi\\n\",0.0,sqrt(-da)*1.0/(2*a));                       printf(\"%.2lf%+.2lfi\\n\",0.0,-sqrt(-da)*1.0/(2*a));                    }            }            else{                    printf(\"%.2lf\\n\",-b*1.0/(2*a));            }         }         else if(a==0&&b==0&&c==0){                 printf(\"Zero Equation\\n\");         }         else if(a==0&&b==0&&c!=0){                 printf(\"Not An Equation\\n\");         }         else if(a==0&&b!=0&&c!=0)                 printf(\"%.2lf\\n\",(-c*1.0)/b);         system(\"pause\");         return 0; }", "referer": "user-0"}]}
{"question": "小白请教！！关于二叉树的建立问题（Run-Time Check Failure #2 - Stack around the variable 'tre）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "懂了是我在对树结点的线索进行初始化的时候，传的是一个一级指针的地址，而函数的接收同样是一个一级指针导致出错！", "referer": "user-0"}]}
{"question": "单片机89c52  C语言编写秒表遇到K2暂停键时不时失效，求大佬看下代码有什么问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "如果概率比较高，在前后加个打印调试下看看", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "按代码的逻辑看，按键受影响的有2处，主函数和中断，所以有可能在极短时间内调用了2次，所以会产生是不是地现象，因此，需要处理好这2处的逻辑关系。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "当然也可能短了，对于主函数中调用来说，同时中断可以影响主函数调用，因此，现象就是时不时地受到影响的结果。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "难道不需要消抖么？", "referer": "user-0"}]}
{"question": "VS Code debug模式无法找到 对应的exe，但是 路径下面是有已编出来的二进制文件。具体配置如下。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "fgets函数使用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢😀😀😀😀", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-4的回复:fgets不会返回EOF，因为这个函数是char *类型。 当出错或遇到文件结束，它返回NULL。 感谢感谢😀😀😀😀", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 qybao的回复:fgets的返回值是char* 所以 != EOF 改为 != NULL 谢谢啦😀😀😀😀", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "参考：https://www.cnblogs.com/coder-jhm1314/articles/4561006.html", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "fgets的返回值是char* 所以 != EOF 改为 != NULL", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "fgets不会返回EOF，因为这个函数是char *类型。 当出错或遇到文件结束，它返回NULL。", "referer": "user-0"}]}
{"question": "oj题目，为什么ac不过", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include<stdio.h> #define MAX 1000//最大输入个数  int bubbleSort(int *A,int len)//排序 {    int i,j,t;    for(i = 0;i < len-1;i++)    {       for(j = 0;j < len-i-1;j++)       {          if(A[j] > A[j+1])          {             t = A[j+1];             A[j+1] = A[j];             A[j] = t;          }       }    } }  int bingji(int *A,int *B,int lenA,int lenB)//并集 {    int i,j;    int flag,index = lenB;    int *buffer = (int *)malloc(sizeof(int) * (lenA+lenB));    for(i = 0;i< lenA+lenB;i++)//初始化buffer空间。    {       buffer[i] = -1;    }    for(i = 0;i < lenB;i++)    {       buffer[i] = B[i];    }    for(i = 0;i < lenA;i++)    {       flag = 1;       for(j = 0;j < lenB;j++)       {          if(A[i] == B[j])          {             flag = 0;          }       }       if(flag)       {          buffer[index] = A[i];          index++;       }    }    bubbleSort(buffer,lenA+lenB);//排序    for(i = 0;i < lenA+lenB;i++)    {       if(buffer[i] != -1)       printf(\"%d \",buffer[i]);    }    printf(\"\\n\");    free(buffer); }  int jiaoji(int *A,int *B,int lenA,int lenB)//交集 {    int i,j;    int flag,index = 0,len = lenA > lenB ? lenA:lenB;    int *buffer = (int *)malloc(sizeof(int) * len);    for(i = 0;i < lenA;i++)    {       flag = 0;       for(j = 0;j < lenB;j++)       {          if(A[i] == B[j])             flag = 1;       }       for(j = 0;j < index;j++)       {          if(A[i] == buffer[j])             flag = 0;       }       if(flag)       {          buffer[index] = A[i];          index++;       }    }    bubbleSort(buffer,index);//排序    for(i = 0;i< index;i++)       printf(\"%d \",buffer[i]);    printf(\"\\n\");    free(buffer); }  int yuji(int *A,int *B,int lenA,int lenB)//余集 {    int i,j;    int flag,index = 0;    int *buffer = (int *)malloc(sizeof(int) * lenA);    for(i = 0;i < lenA;i++)    {       flag = 1;       for(j = 0;j < lenB;j++)       {          if(A[i] == B[j])             flag = 0;       }       if(flag)       {          buffer[index] = A[i];          index++;       }    }    bubbleSort(buffer,index);//排序    for(i = 0;i < index;i++)       printf(\"%d \",buffer[i]);    printf(\"\\n\");    free(buffer); }  int main() {    int a[MAX],b[MAX];//集合    int i = 0,m = 0,n = 0;    scanf(\"%d\",&n);    for(i = 0;i < n;i++)       scanf(\"%d\",&a[i]);     scanf(\"%d\",&m);    for(i = 0;i < m;i++)       scanf(\"%d\",&b[i]);    printf(\"\\n\");     jiaoji(a,b,n,m);//交集    bingji(a,b,n,m);//并集    yuji(a,b,n,m);//余集        return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "我是说题目本身自相矛盾，你怎么写代码有可能是白费力气。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-3 的回复:样例输出与题目要求不符，pass 输出一致啊，不信你自己运行一下看看", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "样例输出与题目要求不符，pass", "referer": "user-0"}]}
{"question": "我想把文件里的内容读取出来并且存到结构体中，在写完第一个程序的时候，运行结果如第一个所示，第二个程序运行结果如第二个图所示，看起来是文件中的内容没能读取出来。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:程序2具有相同的问题，建议改一下～ 谢谢谢谢，已经改好了，非常感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "程序2具有相同的问题，建议改一下～", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include<stdio.h> #include<string.h> #include<stdlib.h>  int main(void) {     FILE *fp;     fp=fopen(\"access.log\",\"r+\");     if(!fp){         printf(\"false\");         return -1;    //直接返回     }     else{         printf(\"true\");     }     char method[255];     char ip[255];     char protocol[255];     char time[255];     char add[255];     int port;     char page[255];     int status;     char exploer_info[255];     char key;     char value;      //while(port=getc(fp)!=EOF)     while((port=getc(fp))!=EOF)     {         putchar(port);         struct record         {             char method[255];             char ip[255];             char protocol[255];             char time[255];             char add[255];             char port;             char page[255];             char status;             char exploer_info[255];             struct prams             {                 char key[255];                 char value[255];             };             char prams_cnt;         };         fgets(method,100,fp);     }     printf(\"%s\",method);     int fclose(FILE *fp);     return 0; } 程序1有问题；详见注释掉的那句；", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:你的代码很难受。。。首先所有变量没有初始化（尤其是数组），然后函数内部定义结构体很诡异。首先把基本的初始化搞好之后，才有必要检查逻辑。 好的，谢谢指点", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "你的代码很难受。。。首先所有变量没有初始化（尤其是数组），然后函数内部定义结构体很诡异。首先把基本的初始化搞好之后，才有必要检查逻辑。", "referer": "user-0"}]}
{"question": "OJ上时间超限，请大佬帮看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "简化路灯状态反转操作，其他没看出毛病： while(q--)         {             scanf(\"%d %d %d %d\",&x1,&y1,&x2,&y2);             for(i=x1;i<=x2;i++)             {                 for(j=y1;j<=y2;j++)                 {                     //if(a[i][j]==1)                     //    a[i][j]=0;                     //else if(a[i][j]==0)                     //    a[i][j]=1;                     a[i][j] = !a[i][j];  //取反                 }             }         }", "referer": "user-0"}]}
{"question": "正学C语言，想找一个编程软件，有好的推荐吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "vs2010，体积很小，，不错的选择", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "在用Dev-C++", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "Dev C++ 简洁好用", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "用了这么多，Vs2019社区版还是很棒的。如果是linux下，geany也很好", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "建议vs和dev都装上  vs有关键字补全，报错也比较高级  dev适合写一些短点的小程序，比较方便", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "我觉得vs不错。其他的没试过。", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "用vc2019吧，免费版，功能强大，调试方便", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "作为入门，我觉得CodeBlocks挺好用的。", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "Dev-C++ 是最容易上手的，而且是免费的", "referer": "user-0"}, {"cid": "10", "user": "user-10", "content": "vc2010express", "referer": "user-0"}, {"cid": "11", "user": "user-11", "content": "dev c++ vs2019这些都可以", "referer": "user-0"}]}
{"question": "学校的这道oj题为什么通过不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <math.h>  unsigned int get_odd_bit(unsigned int n, int bit_len); int main() { #if 0     unsigned int x,n;     int i,y;     char s[50];     scanf(\"%u\",&x);     i=0;     while(x>0)     {         s[i++] = x%2 +'0';         x=x/2;     }     s[i]='\\0';     puts(s);     y = i-1;     for(i=y;i>=0;i--) if((i+1)%2==0) s[i]='0';     puts(s);     for(i=y,n=0;i>=0;i--) n+=pow(2.0,y-i)*(s[i]-'0');     printf(\"%u\\n\",n); #else     unsigned int x;      scanf(\"%u\", &x);      x = get_odd_bit(x, 32);      printf(\"%u\\n\", x); #endif     return 0; }   unsigned int get_odd_bit(unsigned int n, int bit_len) {     unsigned int s = 0;     int i;      for (i = 0; i < bit_len; i++) {         if (i % 2)             s += ((n >> i) & 1u) ? (1u << i) : 0;     }      return s; }  供参考 楼主的代码是没问题的，但是不符合题目要求。因为题目要求自定义函数实现，楼主把逻辑都写在main函数里。 建议楼主把自己的逻辑用一个自定义函数来实现试试。以上是自己用自定义函数来实现的，参考一下", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "需要这么复杂吗？ 用&运算就好了呀？二进制1010就是16进制a 所以 y = x & 0xaaaaaaaa 就可以了", "referer": "user-0"}]}
{"question": "初学C语言的小白求助各位大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码楼上有，传送两个及以上的值就要用到指针", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "代码我就不发了，楼上的就可以了 我就只说说错误的地方吧 第一点：就是while上面那个scanf语句是多余的。 第二点：你调用的函数类型是void型，主函数的t,s,k不会随之发生改变，可以改为有返回型的函数或者用指针", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "代码我就不发了，楼上的就可以了 我就只说说错误的地方吧 第一点：就是while上面那个scanf语句是多余的。 第二点：你调用的函数类型是void型，主函数的t,s,k不会随之发生改变，可以改为有返回型的函数或者用指针", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "这个问题的详细分析，请参考公众号推文 #include<stdio.h> void Temperature(double t,double *s, double *k); int main(void) { \tdouble t,s,k;  \tprintf(\"请输入华氏温度：\"); \t//scanf(\"%lf\",&t); \twhile(scanf(\"%lf\",&t)==1) \t{ \t\tTemperature(t,&s,&k); \t\tprintf(\"华氏温度:%.2f\\n摄氏温度:%.2f\\n开氏温度:%.2f\",t,s,k); \t }  \t   printf(\"结束\");    \treturn 0; } void Temperature(double t,double *s, double *k) { \t*s=5.0/9.0*(t-32.0); \t*k=*s+273.16; }", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "供参考：#include<stdio.h> float Temperature(float t);//void Temperature(float t); 空函数当然什么都不返回了 int main(void) {     float t;     printf(\"请输入华氏温度（小数为零不可省略）：\");//scanf(\"%f\",&t);     while(scanf(\"%f\",&t)!=EOF){ //用 Ctrl + z 结束输入        printf(\"华氏温度:%.2f\\n摄氏温度:%.2f\\n开氏温度:%.2f\",t,Temperature(t),Temperature(t)+273.16);     }     printf(\"结束\");      return 0; }  float Temperature(float t)//void Temperature(float t) {    float s;//k;    s=5.0/9.0*(t-32.0);    //k=s+273.16; //函数只能返回一个值，所以返回摄氏温度值。    return s; }", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "#include<stdio.h> void Temperature(float t, float *s, float *k); int main(void) {     float t,s,k;      printf(\"请输入华氏温度（小数为零不可省略）：\");     //scanf(\"%f\",&t);   //去掉这次的输入，否则需要输入两次～     while(scanf(\"%f\",&t)==1)   //这里还有一个scanf呢，用一个吧，建议保留这个～     {         Temperature(t, &s, &k);         printf(\"华氏温度:%.2f\\n摄氏温度:%.2f\\n开氏温度:%.2f\",t,s,k);     }     printf(\"结束\");      return 0; } void Temperature(float t, float *s, float *k) {     //float s,k;      *s=5.0/9.0*(t-32.0);     *k=*s+273.16; }  供参考～", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "while(scanf(\"%f\",&t)==1)，你认为while（）中仅仅是一个判断吗，就像通常的判断一样if（xxx函数==0） return-1；xxx函数依然执行啊", "referer": "user-0"}]}
{"question": "[求助！]关于coverity工具", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if  （a>b）这样比较的是两个地址值，即那个地址大，那个地址小的问题。", "referer": "user-0"}]}
{"question": "萌新想问一下各位，这个C语言实现比较大小为什么不能实现呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位，解决问题了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "if (a>b>c || a > c > a) 改成：  if ((a > b && b > c) || (a > c && c > a)) 另外一个if也这么改，试试～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "a>b>c 编译器会按顺序进行表达式运算，a>b  成立就返回1  ，不成立就返回0。  之后返回的结果(1或0) 会与c比较   。所以这里跟我们的逻辑不一样。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "由于运算法则的原因，关系运算不能连着写。 可以写成 a>b && a>c 这种形式。", "referer": "user-0"}]}
{"question": "为什么会出现写入访问权限冲突。 tail 是 nullptr？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-2的回复:if (heado = NULL)             heado = ptr2;         else             tail->next = ptr2; 这里错了，应该为if (heado == NULL) 自己看了半个小时没看出来竟然犯了这么低级的错误，谢谢哈", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "struct ListNode* reverse(struct ListNode* head) {     struct ListNode* ptr1, * ptr2, * heado = NULL, * tail = NULL;     int a[100], index = 0;     for (ptr1 = head; ptr1 != NULL; ptr1 = ptr1->next)         a[index++] = ptr1->data;     for (int i = index - 1; i >= 0; i--)     {         ptr2 = (struct ListNode*)malloc(sizeof(struct ListNode));         ptr2->data = a[i];         ptr2->next = NULL;         //if (heado = NULL)         if (heado == NULL)             heado = ptr2;         else             tail->next = ptr2;         tail = ptr2;     }     return heado; } 供参考～  =不是比较==是比较", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "if (heado = NULL)             heado = ptr2;         else             tail->next = ptr2; 这里错了，应该为if (heado == NULL)", "referer": "user-0"}]}
{"question": "#pragma 和interrupt", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#pragma interrupt( )表示中断服务子程序", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你需要看对应编译器的说明", "referer": "user-0"}]}
{"question": "求助，DEVC++运行不了这个程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你是不是写成for(int i=0;i<10;i++)了，这是C99的，所有编译不了。 要在外面定义变量才可以", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不要写 for(int i=0;i<10;i++) 写成 int i; ... for(i=0;i<10;i++) 就好", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "linux下使用gcc/g++编译器另外加上vim编辑器；", "referer": "user-0"}]}
{"question": "【求助】 java 改写成 c", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for example int main() {     char s[256], *p;     int n;     fgets(s, 256, stdin);     scanf(“%d”, &n);     p = strtok(s, “ “);     while(p != NULL) {         n--;         if(n==0) break;         p = strtok(p, “ “);     }     print(“%s\\n”, s);     printf(“extracword: “);     if(p!=NULL) printf(“%s\\n”, p);     else printf(“nothing\\n”);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "例如输入 my name is jack 2 提出第二个单词在这里是name 输出应该是 my name is jack  extracWord: name", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "如不用strtok呢 使用fgets（）改写java code能否实现呢？", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "比如 char *s; int n; while((s=gets()) != NULL) { //这里相当于hasNextLine     sscanf(s, “%d”, &n);//这里相当于nextInt     printf(“%d”, n); }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "建议楼主描述一下需求，根据需求去用C实现～", "referer": "user-0"}]}
{"question": "C语言题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "a[0]是2，剩下399个都是0", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "int a[Y]={2}的意思是数组里面每个元素都是2吗", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "一个数有很多位，它要乘以2 积的个位=原数的个位×2的结果取个位 积的十位=（原数的十位×2的结果+原数的个位×2的结果的十位）的结果取个位 积的百位=（原数的百位×2的结果+原数的十位×2的结果的十位）的结果取个位 循环吧  以上描述中提到的位是十进制下的单独一个数位，提到的×2的结果可能是1位数也可能是2位数，结果的十位就是进位的意思 你自己随便写个竖式计算，然后记住每个数字都是单独的变量（数组元素），然后描述计算过程，就是这样了", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 7 楼 forever74 的回复:超大数计算超高精度计算基本就都是这么写的，网上一搜一大堆，就是硬模拟竖式计算嘛。不光是乘2，更重要的是四则和各种其他运算。当然这个代码不够精致，还有一些无用功在里面。请问，我还是有些搞不懂硬模拟竖式计算是怎么模拟计算的？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "#include <stdio.h> #define X 1000 #define Y 400 int Fun() { \tint a[Y] = { 2 }, b[Y]; //原本有个2 \tint sum = 0; \tint i, j, m, n; \tfor (i = 1; i < X; ++i) { //这个循环999次，每次乘2 \t\tfor (j = 0; j < Y; ++j) //把上次结果保存起来作为下次的运算数 \t\t\tb[j] = a[j]; \t\tfor (n = 0; n < Y; ++n) //这个就是a=b*2 \t\t\tif (n == 0) \t\t\t\ta[n] = 2 * b[n] % 10;  //最低位也就是个位不用考虑进位，因为没人给它进 \t\t\telse  \t\t\t\ta[n]=(2*b[n]+2*b[n-1]/10)%10; //其他位就得考虑进位了，a[1]是十位，a[2]是百位，依次类推 \t} \tfor (m = 0; m < Y; m++) //按要求累加各数位 \t\tsum += a[m]; \treturn sum; } int main(void) { \tprintf(\"%d\\n\", Fun()); \treturn 0; }  输出 1366", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "老哥要不可以从第一个循环开始到结束详细注释一下吗 就把我当成一个新手解释一下 这个确实是看不懂", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "按照10进制从低到高一位一位算，考虑到低位进上来的进位就行。如果你说的是填空的这句话的话。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "超大数计算超高精度计算基本就都是这么写的，网上一搜一大堆，就是硬模拟竖式计算嘛。不光是乘2，更重要的是四则和各种其他运算。当然这个代码不够精致，还有一些无用功在里面。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "你好 可以解释一下思路吗 就是怎么想出来要这么写的", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "就是计算2的1000次方的值，因为它太大，所以需要用数组元素表示它的各位数字。计算的时候参考手写竖式的计算过程。", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "a[n]=(2*b[n]+2*b[n-1]/10)%10", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "可以的话顺便解释一下这个代码 不带清楚这个想要干嘛", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "要求： 2^15 = 32768 ，其各位之和为 3 + 2 + 7 + 6 + 8 = 26。  求2^1000各位数字之和。其中^表示次方，如：2^5表示2的5次方。  下面程序计算并输出结果，请完成缺少的语句。要求参赛选手在弄清给定代码的基础上填写缺失的部分，使得程序逻辑正确、完整。所填写的代码不多于一条语句（即不能出现分号）。", "referer": "user-0"}, {"cid": "15", "user": "user-2", "content": "说清楚要求，不要让人猜。", "referer": "user-0"}]}
{"question": "STM32", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "就是调用函数返回的值赋值给了start和differ", "referer": "user-0"}]}
{"question": "c，c#，c++，等等的听说了很多，但只学了c，有没有来科普一下的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "建议先学C语言，后续一通百通。以后专业不管是走I T编程还是电子技术编程，都可发展。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "直接C#、、、", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "建议学golang，被称为互联网的c语言", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "先学的c++,然后看了看c，c++虽然包括c，但是他们的思想不一样，c++是面向对象的，然后运行的话c好像更快一点", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "学会了c,再学其它的，就很简单了", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "学到了，看来我还有很长路要走", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "建议学习C++Primer Plus", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "不，是： |-------- |您在这| |-------- | C -> C++ \\                   > java! C# --------/", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "C -> C++   ->  C++++(C#)  看出来了吗", "referer": "user-0"}, {"cid": "10", "user": "user-10", "content": "建议直接学c++", "referer": "user-0"}, {"cid": "11", "user": "user-11", "content": "C先学，会带给你写代码的逻辑性，严谨性，然后直接学习c#。", "referer": "user-0"}, {"cid": "12", "user": "user-12", "content": "小白路过，学习了。", "referer": "user-0"}, {"cid": "13", "user": "user-13", "content": "一般讲，早初的时候，C语言常常与Unix系统有关。也有人说，C语言是为了开发Unix系统而研发的。但是，C语言是完全独立的设计，其系统设计甚至比Unix更加庞大复杂。C语言的经典教材，我国比较公认的是早初清华大学谭浩强教授的版本。最经典的C语言例程就是传说中的HelloWorld。一般来说，C语言的特点是精巧缜密，这是大多数懂得C语言的人都会承认的。 C++是诞生于C语言论坛的：在人们热衷于讨论和赞美C语言的时代，一些非常深刻的人在C语言论坛提出了对象和流的概念，之后讨论了有十年，最后终于有人为这两个概念做出了代码实现，于是C++诞生了。至于命名，是源于类似后来命名大熊猫的方法——服从民意。关于面向对象技术和流技术，在早初就有许多争议，大多数人知道的结论是：没有函数精妙。主要问题是：效率低下，适应力较低。但是C++还是诞生了，源于一些人的坚持。最早的C++定义，就是在C语言基础上加入对象技术和流技术。通常认为，整个1980's是属于C++语言的，虽然当时Basic语言更加流行。C++语言的经典版本：Borland公司的TurboC2.0，BorlandC++3.1，BorlandC++Builder4.5，Microsoft公司的VisualC++6.0。 C#是微软.net战略的产物，诞生于Sun公司强大的Java攻势之下，基本上是与Java、Javascript同时代的理论争吵（思考）的产物。", "referer": "user-0"}, {"cid": "14", "user": "user-14", "content": "首先，c++之父认为应该是++c，而不是c++ 其次，c++的确包括c。更多的是面向对象，泛型编程，模板元编程等", "referer": "user-0"}, {"cid": "15", "user": "user-15", "content": "简单地科普一下：先从取名来说吧，++在C语言中表示增加1的意思，所以，C++在功能上比C语言有所增加。在C++功能的基础上，C#又比C++的功能有所增加，因为#是由两个++构成的。具体参见《C++程序设计精要教程》。", "referer": "user-0"}, {"cid": "16", "user": "user-16", "content": "没学过听别人描述很难有深刻理解的，就跟没见过大象的人描述大象一样，另外只学C找到工作，尤其好工作是比较困难的，需要学历加持", "referer": "user-0"}, {"cid": "17", "user": "user-17", "content": "c++可以看作c的超集（c相当于c++的子集） c#不属于c/c++系列，和java类似，编译后是虚拟机指令，需要虚拟机来运行", "referer": "user-0"}, {"cid": "18", "user": "user-18", "content": "个人理解：c++是基于c，但是面向对象，两者可以说是同源，C#新一些，特性不同，使用的地方也不同，c#优化了内存，但是是否是真的“优化”当然仁者见仁。c++几乎完全兼容c，他对指针的特殊操作可以说是非常独特的，优点缺点都在他，也给了他对底层操作的独特优势。而感觉c#更像java", "referer": "user-0"}, {"cid": "19", "user": "user-19", "content": "C是面向过程的编程，而c#和c++更多的是面向对象的编程；", "referer": "user-0"}]}
{"question": "【求助】C语言实现单链表头插法出现了错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "哎呀，编译器提示：参数类型不匹配！ 作为C程序员，我太难了：足足有十年，我一个函数没通过。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 26 楼 AFei2019 的回复:wow，老哥，好巧，你的帖子都上热门了 是真的特别感谢大佬们的答疑解惑", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "wow，老哥，好巧，你的帖子都上热门了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "//答案： a) int a; b) int *a; c) int **a; d) int a[10]; e) int *a[10]; f) int (*a)[10]; g) int (*a)(int);  h) int (*a[10])(int);", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "应该先明白指针是什么  给你出道题：  用变量a给出下面的定义  a) 一个整型数 b)一个指向整型数的指针 c)一个指向指针的的指针，它指向的指针是指向一个整型数 d)一个有10个整型数的数组 e) 一个有10个指针的数组，该指针是指向一个整型数的 f) 一个指向有10个整型数数组的指针 g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数 h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "haodehlsalieuuosf", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "可能软件出了问题", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "新人求积分，", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "引用 10 楼 柘月十七 的回复:[quote=引用 3 楼 突触 的回复:]    CreateList_H(L,2);  这里出了问题   这里传递的是形参     用指针就行了   CreateList_H(&L,2); 想了半天没弄明白它这里传递指针的逻辑过程是什么，能讲讲嘛？谢谢[/quote] 参数传递如果传一重指针，则是传入参数，如果传二重指针，就是传入传出参数。因为create函数也要带出head指针，即需要传出，并且除了参数带会新head指针外，，无法通过return返回，因为函数是void返回值。  以下两种定义都是可以的：  LinkList  CreateList_H(LinkList L,int n)   //形参LinkList类型的指针变量（用于指向新开辟储存单元），逆序储存n个元素值 {     int i;    //元素数量计数      L = (LinkList)malloc(sizeof(LNode));   //为头结点开辟储存空间     L->next = NULL;  //含头结点的空链表      for(i=0;i<n;i++)    //循环输入元素     {         ElemType e;         LNode *p=(LinkList)malloc(sizeof(LNode));   //为新结点开辟空间并令指针指向该地址         printf(\"请输入1个链表元素:\");         scanf(\"%d\",&e);    //向新结点数据域输入数据         p->data = e;         printf(\"保存完成~\\n\");         p->next = L->next;       //头结点指针域的值（即新结点后继结点地址）赋给新结点指针域进行连接         L->next = p;    //指针域指针连接顺序不可颠倒   新结点地址赋值给头结点指针域进行连接     }      return L; }  void  CreateList_H(LinkList *L,int n)   //形参LinkList类型的指针变量（用于指向新开辟储存单元），逆序储存n个元素值 {     int i;    //元素数量计数      *L = (LinkList)malloc(sizeof(LNode));   //为头结点开辟储存空间     (*L)->next = NULL;  //含头结点的空链表      for(i=0;i<n;i++)    //循环输入元素     {         ElemType e;         LNode *p=(LinkList)malloc(sizeof(LNode));   //为新结点开辟空间并令指针指向该地址         printf(\"请输入1个链表元素:\");         scanf(\"%d\",&e);    //向新结点数据域输入数据         p->data = e;         printf(\"保存完成~\\n\");         p->next = (*L)->next;       //头结点指针域的值（即新结点后继结点地址）赋给新结点指针域进行连接         (*L)->next = p;    //指针域指针连接顺序不可颠倒   新结点地址赋值给头结点指针域进行连接     } }", "referer": "user-0"}, {"cid": "10", "user": "user-8", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "11", "user": "user-9", "content": "首先你要明白指针和非指针变量的区别，指针是指向一个地址的，比如定义一个int * a. 那么a是一个指针变量，如果你要给a赋值，a = b,但是前提b是一个同类型指针变量，此时代表a和b指向同一个地址，如果你要取地址里的值，就需要用*。*a = 20。所以你函数里的形参如果是个指针变量，那你外部传入的实参也需要是一个同类型指针变量。CreateList_H(LinkList *L,int n)  ，第一个形参是LinkList *L，所以你传入的要么是一个LinkList *K,此时调用方式写成CreateList_H(K,1) ,要么你传入的是LinkList  K，此时调用方式CreateList_H(&K,1)", "referer": "user-0"}, {"cid": "12", "user": "user-10", "content": "/*头插法（前插法）  */ void CreateList_H(LinkList * PL, int n)   //形参LinkList类型的指针变量（用于指向新开辟储存单元），逆序储存n个元素值 {\t \tLinkList  L = *PL; \tL = (LinkList)malloc(sizeof(LNode));   //为头结点开辟储存空间 \t*PL = L; \tL->next = NULL;  //含头结点的空链表 \tint i;    //元素数量计数  \tfor (i = 0; i < n; i++)    //循环输入元素 \t{ \t\tElemType e; \t\tLNode *p = (LinkList)malloc(sizeof(LNode));   //为新结点开辟空间并令指针指向该地址 \t\tprintf(\"请输入1个链表元素:\"); \t\tscanf(\"%d\", &e);    //向新结点数据域输入数据 \t\tp->data = e; \t\tprintf(\"保存完成~\\n\"); \t\tp->next = L->next;       //头结点指针域的值（即新结点后继结点地址）赋给新结点指针域进行连接 \t\tL->next = p;    //指针域指针连接顺序不可颠倒   新结点地址赋值给头结点指针域进行连接 \t} }", "referer": "user-0"}, {"cid": "13", "user": "user-11", "content": "抱歉  我没有仔细看    你错的太多了", "referer": "user-0"}, {"cid": "14", "user": "user-11", "content": "CreateList_H(L,2);  这里出了问题   这里传递的是形参     用指针就行了   CreateList_H(&L,2);", "referer": "user-0"}, {"cid": "15", "user": "user-10", "content": "能讲讲你的思路吗 我按照你的思路给你改", "referer": "user-0"}, {"cid": "16", "user": "user-12", "content": "楼主的C语言指针有待加强，建议看看谭浩强的C语言。 修改如下，仅供参考： #include <stdio.h> #include <stdlib.h>   #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0   typedef int Status; typedef int ElemType;   //单链表的存储结构 typedef struct LNode {     ElemType data;     struct LNode *next;  //next指向自身类型struct LNode *的指针 }LNode,*LinkList;    //LinkList为指向结构体LNode的指针类型   int ListEmpty(LinkList L) {     printf(\"\\n正在检查.......\\n\");     if(L->next) return FALSE;   //非空 0     return TRUE;   //空 1 }   /*头插法（前插法）  */ void CreateList_H(LinkList *L,int n)   //形参LinkList类型的指针变量（用于指向新开辟储存单元），逆序储存n个元素值 {     *L = (LinkList)malloc(sizeof(LNode));   //为头结点开辟储存空间     (*L)->next = NULL;  //含头结点的空链表     int i;    //元素数量计数           for(i=0;i<n;i++)    //循环输入元素     {         ElemType e;         LNode *p=(LinkList)malloc(sizeof(LNode));   //为新结点开辟空间并令指针指向该地址         printf(\"请输入1个链表元素:\");         scanf(\"%d\",&e);    //向新结点数据域输入数据         p->data = e;         printf(\"保存完成~\\n\");         p->next = (*L)->next;       //头结点指针域的值（即新结点后继结点地址）赋给新结点指针域进行连接         (*L)->next = p;    //指针域指针连接顺序不可颠倒   新结点地址赋值给头结点指针域进行连接     } }   //链表遍历  void print(LinkList L)  {     LNode *p;     p=L->next;     if(p == NULL) printf(\"链表为空~\");     while(p != NULL)     {         printf(\"%d \",p->data);         p = p->next;     } }   int main() {     int status;     LinkList L;     CreateList_H(&L,2);     print(L);     status = ListEmpty(L);     printf(\"%d\\n\",status);     return 0; }", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "引用 16 楼 user-12 的回复:C语言的指针，如同汇编语言中的间接寻址。 好好看书吧，要不然C语言老师都可能哭晕在厕所。 本来很简单的问题，被折腾这样，估计把自己都折腾糊涂了。  呜呜呜~ 自学呢~", "referer": "user-0"}, {"cid": "18", "user": "user-12", "content": "C语言的指针，如同汇编语言中的间接寻址。 好好看书吧，要不然C语言老师都可能哭晕在厕所。 本来很简单的问题，被折腾这样，估计把自己都折腾糊涂了。", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "引用 13 楼 github_37127447 的回复:[quote=引用 9 楼 柘月十七 的回复:][quote=引用 6 楼 github_37127447 的回复:]/*头插法（前插法）  */ void CreateList_H(LinkList * PL, int n)   //形参LinkList类型的指针变量（用于指向新开辟储存单元），逆序储存n个元素值 {\t \tLinkList  L = *PL; \tL = (LinkList)malloc(sizeof(LNode));   //为头结点开辟储存空间 \t*PL = L; \tL->next = NULL;  //含头结点的空链表 \tint i;    //元素数量计数  \tfor (i = 0; i < n; i++)    //循环输入元素 \t{ \t\tElemType e; \t\tLNode *p = (LinkList)malloc(sizeof(LNode));   //为新结点开辟空间并令指针指向该地址 \t\tprintf(\"请输入1个链表元素:\"); \t\tscanf(\"%d\", &e);    //向新结点数据域输入数据 \t\tp->data = e; \t\tprintf(\"保存完成~\\n\"); \t\tp->next = L->next;       //头结点指针域的值（即新结点后继结点地址）赋给新结点指针域进行连接 \t\tL->next = p;    //指针域指针连接顺序不可颠倒   新结点地址赋值给头结点指针域进行连接 \t} } CreateList_H(LinkList *L,int n)，这，可以讲讲为什么传递进去的二重指针吗[/quote]  就这个代码片段而言 当你传递的一重指针的话 因为是值传递 所以 形参L 和你 原来的L是值一致。也就是他们所指向的内存块是一致的。 比如 调用L 地址是 0x12 值是  0x20（也就是指向了0x20这个起始地址）。然后形参L 地址 是0x14 值也是（0x20）.然后当再函数内部malloc 时 相当于是把形参L 的值改成了 0x30 也就是 此时形参L 地址0x14 值0x30（也就是指向了0x30这个起始地址） .此时你对形参L的操作本质都是再操作 0x30 这块内存。但是由于你原来调用的L值依然是0x20。所以结果是错误的。[/quote]   太感谢了 通过自己的理解，把大致的过程写了一遍，是这样嘛？", "referer": "user-0"}, {"cid": "20", "user": "user-10", "content": "引用 9 楼 柘月十七 的回复:[quote=引用 6 楼 github_37127447 的回复:]/*头插法（前插法）  */ void CreateList_H(LinkList * PL, int n)   //形参LinkList类型的指针变量（用于指向新开辟储存单元），逆序储存n个元素值 {\t \tLinkList  L = *PL; \tL = (LinkList)malloc(sizeof(LNode));   //为头结点开辟储存空间 \t*PL = L; \tL->next = NULL;  //含头结点的空链表 \tint i;    //元素数量计数  \tfor (i = 0; i < n; i++)    //循环输入元素 \t{ \t\tElemType e; \t\tLNode *p = (LinkList)malloc(sizeof(LNode));   //为新结点开辟空间并令指针指向该地址 \t\tprintf(\"请输入1个链表元素:\"); \t\tscanf(\"%d\", &e);    //向新结点数据域输入数据 \t\tp->data = e; \t\tprintf(\"保存完成~\\n\"); \t\tp->next = L->next;       //头结点指针域的值（即新结点后继结点地址）赋给新结点指针域进行连接 \t\tL->next = p;    //指针域指针连接顺序不可颠倒   新结点地址赋值给头结点指针域进行连接 \t} } CreateList_H(LinkList *L,int n)，这，可以讲讲为什么传递进去的二重指针吗[/quote]  就这个代码片段而言 当你传递的一重指针的话 因为是值传递 所以 形参L 和你 原来的L是值一致。也就是他们所指向的内存块是一致的。 比如 调用L 地址是 0x12 值是  0x20（也就是指向了0x20这个起始地址）。然后形参L 地址 是0x14 值也是（0x20）.然后当再函数内部malloc 时 相当于是把形参L 的值改成了 0x30 也就是 此时形参L 地址0x14 值0x30（也就是指向了0x30这个起始地址） .此时你对形参L的操作本质都是再操作 0x30 这块内存。但是由于你原来调用的L值依然是0x20。所以结果是错误的。", "referer": "user-0"}]}
{"question": "一个简答的链表问题 关于在结构体中的指针弄得很乱", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int main() {     char c,a[100];     int i=0,j,k;     LNode *head,*node;     head=(LNode *)malloc(sizeof(LNode));     //head=NULL;     head->next = NULL;     while((c=getchar())!='\\n')     {         a[i]=c;         i++;     }      for(j=0;j<i;j++)     {         node=(LNode *)malloc(sizeof(LNode));         node->val=a[j];         node->next = head;         head=node;     }     //while(head->next!=NULL)     while(head!=NULL)     {         cout<<head->val;         head=head->next;     }     return 0; } 供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "C和C++交织在一起，看着不累么？ 如：head=(LNode *)malloc(sizeof(LNode)); 要是C，要强制类型转换干啥？而且出错不容易发现。head=malloc(sizeof(LNode));貌似更好，不必画蛇添足。 要是C++，直接new就行了，直接调用构造函数，多好。。", "referer": "user-0"}]}
{"question": "c语言结构体   疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "typedef是定义别名，比如typedef struct node NODE;那么NODE就是struct node的别名，NODE定义的变量等价struct node定义的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "typedef就是一个别名", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "是的 只不过你这个例子中的成员类型不一样，一个有const，一个没有，不过这个跟typedef本身没关系", "referer": "user-0"}]}
{"question": "C语言小白，请问下这语句中if (ch < '0' || ch>'9') 为什么ch 输入0 或9  if 判断它仍为假？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "<=    >=", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 楼主 unclekingfish 的回复: int main() { \tint ch = 0; \twhile ((ch = getchar()) != EOF) \t{ \t\tif (ch < '0' || ch>'9') \t\tcontinue; \t\tputchar(ch); \t} \treturn 0; }   求大佬解惑，为什么这段代码输入0或者9  还是可以输出0或者9 因为‘0’不是小于‘0’且不是大于‘9’ ‘9’不是小于‘0’且不是大于‘9’ 因此为假", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "因为'0'和0，'9'和9不是一回事", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 1 楼 是疗伤烧肉粽~的回复:[quote=引用 楼主 unclekingfish的回复:] int main() { \tint ch = 0; \twhile ((ch = getchar()) != EOF) \t{ \t\tif (ch < '0' || ch>'9') \t\tcontinue; \t\tputchar(ch); \t} \treturn 0; }   求大佬解惑，为什么这段代码输入0或者9  还是可以输出0或者9 if语句括号里面错了 应该是if(ch>='0'||ch<='9')[/quote] 刚打错了，把楼上的回答的||改为&&", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 楼主 unclekingfish的回复: int main() { \tint ch = 0; \twhile ((ch = getchar()) != EOF) \t{ \t\tif (ch < '0' || ch>'9') \t\tcontinue; \t\tputchar(ch); \t} \treturn 0; }   求大佬解惑，为什么这段代码输入0或者9  还是可以输出0或者9 if语句括号里面错了 应该是if(ch>='0'||ch<='9')", "referer": "user-0"}]}
{"question": "来位大佬，学校的OJ题目ac不过", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "有没有可能是要开longlong", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 21 楼 智者知已应修善业 的回复:这个提示答案错误是否跟最后输出带换行符有关？似乎以前有类似的提问。 试过了已经，不是换行符的问题", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "所以才想知道正确答案是什么，感觉我的没什么问题，却说答案错误", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "这个提示答案错误是否跟最后输出带换行符有关？似乎以前有类似的提问。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "不是说有一份通过了？             对的，就是我们学校的学生提交的200多份只通过了一份，我都差不多提交十份了，都没通过。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 17 楼 forever74 的回复:[quote=引用 14 楼 智者知已应修善业 的回复:]从截图看有几个错误，逻辑错误，运算错误，超时，等，说明算法逻辑没理清。 超时可以由计数量过多引发，运算错误由算法逻辑不清楚引发，继而引发其他问题。 简单的求约数这是基本的数学知识，用从头计算到尾显然没把数学知识用上的缘故。 看一张图看看能否有所觉悟。 那张图应该是网站对所有用户提交该题的总结，而不是针对这个程序的。[/quote] 对的，就是我们学校的学生提交的200多份只通过了一份，我都差不多提交十份了，都没通过。", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "引用 14 楼 智者知已应修善业 的回复:从截图看有几个错误，逻辑错误，运算错误，超时，等，说明算法逻辑没理清。 超时可以由计数量过多引发，运算错误由算法逻辑不清楚引发，继而引发其他问题。 简单的求约数这是基本的数学知识，用从头计算到尾显然没把数学知识用上的缘故。 看一张图看看能否有所觉悟。 那张图应该是网站对所有用户提交该题的总结，而不是针对这个程序的。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "假如说那张提示那么多错误一定就是贴出代码引发的，那么就只有一个解释从1开始逐一求约数的逻辑不符题意了，数学知识可推得约数与商是可互换的即求出一个约数实际上就是2个约数，因此，不需要从1求到数本身，比如36这个数求有几个约数只要循环求到6即可得9个约数就出来了，因此循环量大大减小从而时间也减少。而且数越大求的次数与数本身的比例就越大即循环量越少时间就越少。 再看一张图，可以看出求的次数与数本身的比例关系，720这个数只要循环求到30次即可，720/30=24，上面的36/6=6。", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "怀疑你使用的电脑有病毒存在，看运行题目的页面存在不该出现的字符。", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "图", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "从截图看有几个错误，逻辑错误，运算错误，超时，等，说明算法逻辑没理清。 超时可以由计数量过多引发，运算错误由算法逻辑不清楚引发，继而引发其他问题。 简单的求约数这是基本的数学知识，用从头计算到尾显然没把数学知识用上的缘故。 看一张图看看能否有所觉悟。", "referer": "user-0"}, {"cid": "13", "user": "user-4", "content": "把你最后的代码展示一下吧。捎带说一下是上述哪种错法。", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "我这道题都试了很多次，网上也找了这个问题的其他的答案，也过不了", "referer": "user-0"}, {"cid": "15", "user": "user-5", "content": "做题的网站不用main函数吧  把main函数删了", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 10 楼 智者知已应修善业 的回复:for(i=1,count=0;i<=x;i++)从1算到X效率自然打折 题目是从a到b，这里的a就是1", "referer": "user-0"}, {"cid": "17", "user": "user-4", "content": "引用 10 楼 智者知已应修善业 的回复:for(i=1,count=0;i<=x;i++)从1算到X效率自然打折 尽管努力一下可以快一些，但是现在他是WA呀，主要矛盾不是超时啊。 我承认技穷了。", "referer": "user-0"}, {"cid": "18", "user": "user-3", "content": "for(i=1,count=0;i<=x;i++)从1算到X效率自然打折", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "有些题目有，有些没有，不过不是这个问题，我试过了", "referer": "user-0"}, {"cid": "20", "user": "user-4", "content": "同一个OJ上的其他题目对输入输出的举例有这种显式的\\n么？ 这个东西不常见。", "referer": "user-0"}]}
{"question": "洛谷题求解，二分查找", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "实际上还可以再稍微继续优化一点，“如果大于m，把多出来的量分摊到每棵树，加到h上继续迭代”可以改成只分摊到高度大于当前h的那些树，这样可以更快迭代出结果，但是需要增加一个变量记录当前高于h的树总量，每次迭代要计算一次，懒得写，直接用n替代了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 9 楼 普渡&众生 的回复:[quote=引用 6 楼 早打大打打核战争的回复:]这题二分查找并不高明，因为题目中有足够的信息一开始就逼近正确答案：  #include <stdio.h>  int h, n, m, t[1000000]; long long s;  int main() {   scanf(\"%d%d\", &n, &m);   for (int i = 0; i < n && ~scanf(\"%d\", &t[i]);) s += t[i++];   h = (s - m) / n;   for (int i; s > m;)   {     for (i = s = 0; i < n; i++) s += t[i] <= h ? 0 : t[i] - h;     s <= m ? h -= s < m : h +=(s - m) / n ? (s - m) / n : 1;   }   printf(\"%d\\n\", h);    return 0; }  可以讲讲思路吗，麻烦了[/quote]  s一开始是所有树的总高度，所以h = (s - m) / n; 是估计的砍树平均高度（实际高度不会比这个低），然后每次迭代s为h高度上砍掉的总长度，如果恰好是需要量m就结束计算，如果大于m，把多出来的量分摊到每棵树，加到h上继续迭代，如果小于m，说明上次迭代h加多了，把h-1就是正确答案", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "二分查找要先把每个数从大到小或小到大排列", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "二分查找 就是把数组一直分成两份，直到找到目标", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 6 楼 早打大打打核战争的回复:这题二分查找并不高明，因为题目中有足够的信息一开始就逼近正确答案：  #include <stdio.h>  int h, n, m, t[1000000]; long long s;  int main() {   scanf(\"%d%d\", &n, &m);   for (int i = 0; i < n && ~scanf(\"%d\", &t[i]);) s += t[i++];   h = (s - m) / n;   for (int i; s > m;)   {     for (i = s = 0; i < n; i++) s += t[i] <= h ? 0 : t[i] - h;     s <= m ? h -= s < m : h +=(s - m) / n ? (s - m) / n : 1;   }   printf(\"%d\\n\", h);    return 0; }  可以讲讲思路吗，麻烦了", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 5 楼 智者知已应修善业的回复:4 8 20 15 10 17 4 9 20 15 10 17 有可能输入的值获取不到，因此，写了各小于接近的方案，小数部分就不写了。由此衍生出获取最接近算法。   可以请您发一下代码吗", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "另，90009同学大过年的还在闷头鼓捣小代码啊，虽然精神可嘉，但是代码质量不敢恭维~~~", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "这题二分查找并不高明，因为题目中有足够的信息一开始就逼近正确答案：  #include <stdio.h>  int h, n, m, t[1000000]; long long s;  int main() {   scanf(\"%d%d\", &n, &m);   for (int i = 0; i < n && ~scanf(\"%d\", &t[i]);) s += t[i++];   h = (s - m) / n;   for (int i; s > m;)   {     for (i = s = 0; i < n; i++) s += t[i] <= h ? 0 : t[i] - h;     s <= m ? h -= s < m : h +=(s - m) / n ? (s - m) / n : 1;   }   printf(\"%d\\n\", h);    return 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "4 8 20 15 10 17 4 9 20 15 10 17 有可能输入的值获取不到，因此，写了各小于接近的方案，小数部分就不写了。由此衍生出获取最接近算法。", "referer": "user-0"}, {"cid": "11", "user": "user-4", "content": "这个题目出得真逗，似乎得到树木的树冠不是得到树木的树干，更像是修篱笆！ 假如说输入4 10 20 15 10 17，那么锯片设定为14，4 7 20 15 10 17则锯片设定15，这样的题目不存在二分法查找，只能说预设可以使用最高度的1/2开始逐步求。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:这个二分查找不是从trees中二分，而是高度的二分。即找到最大高度，那么leftt是从0开始到最大高度这不就是已经是顺序的吗？ 还有while循环体内为什么要s=0呢", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:这个二分查找不是从trees中二分，而是高度的二分。即找到最大高度，那么leftt是从0开始到最大高度这不就是已经是顺序的吗？ 噢噢原来是这个意思，那为什么最后return要leftt-1呢？为什么while的条件是letff＜=longest呢？ 里面有很多细节不是很懂。比如它缩减区间", "referer": "user-0"}, {"cid": "14", "user": "user-5", "content": "这个二分查找不是从trees中二分，而是高度的二分。即找到最大高度，那么leftt是从0开始到最大高度这不就是已经是顺序的吗？", "referer": "user-0"}]}
{"question": "【求助】函数指针和结构体", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://www.baidu.com/s?wd=keilc51%20%E7%BB%93%E6%9E%84%E4%BD%93%E5%AF%B9%E9%BD%90", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 赵4老师 的回复:应确保 结构体对齐 和 函数指针到底是32位还是64位  您好，我用的keilc51的软件，结构体内容我整个打印出来。发现数据并没有对齐，然而我没设置取消对齐。函数指针总共是3个字节，是参数的字节总和。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "多谢各位了  问题找到了 是编译的问题", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "应确保 结构体对齐 和 函数指针到底是32位还是64位", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "指针太多，不说请调用链，一不小心哪个就是野指针了。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "莫名其妙变化这种事，疑似返回auto局部变量地址造成的。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "说清楚，什么叫另外两个，啥叫正常。 分别说清变量名，原值，变成什么了。 另外初始化时用到的uart2Buff是个什么东西，在哪定义的。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "贴一下比较完整的代码看看", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "有可能的问题点或者测试思路，也希望能提供一下", "referer": "user-0"}]}
{"question": "C语言文件使用方式", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "简单的方法是直接试试", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "学习了，会者不难，难者不会。好复杂", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "自己敲代码实践一下就知道了", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 赵4老师的回复:不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 好的 谢谢赵老师", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 6 楼 lin5161678的回复:看书是第一步  你不能止步在第一步然后什么都不做  写代码试试就全明白了 好的好的谢谢", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "最终建议楼主写个程序验证一下就知道了。", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "我觉得应该增加一个写法，比如我又想自动创建新文件，又想不清除原文件内容，又不想只是追加在后面，就比较麻烦", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "看书是第一步  你不能止步在第一步然后什么都不做  写代码试试就全明白了", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "根据我的经验a是可以创建的", "referer": "user-0"}, {"cid": "11", "user": "user-8", "content": "fopen, _wfopen Open a file.  FILE *fopen( const char *filename, const char *mode );  FILE *_wfopen( const wchar_t *filename, const wchar_t *mode );  Function Required Header Compatibility  fopen <stdio.h> ANSI, Win 95, Win NT  _wfopen <stdio.h> or <wchar.h> Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    The c, n, and t mode options are Microsoft extensions for fopen and _fdopen and should not be used where ANSI portability is desired.  Return Value  Each of these functions returns a pointer to the open file. A null pointer value indicates an error.   Parameters  filename  Filename  mode  Type of access permitted  Remarks  The fopen function opens the file specified by filename. _wfopen is a wide-character version of fopen; the arguments to _wfopen are wide-character strings. _wfopen and fopen behave identically otherwise.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tfopen fopen fopen _wfopen    The character string mode specifies the type of access requested for the file, as follows:  \"r\"  Opens for reading. If the file does not exist or cannot be found, the fopen call fails.  \"w\"  Opens an empty file for writing. If the given file exists, its contents are destroyed.  \"a\"  Opens for writing at the end of the file (appending) without removing the EOF marker before writing new data to the file; creates the file first if it doesn’t exist.  \"r+\"  Opens for both reading and writing. (The file must exist.)  \"w+\"  Opens an empty file for both reading and writing. If the given file exists, its contents are destroyed.  \"a+\"  Opens for reading and appending; the appending operation includes the removal of the EOF marker before new data is written to the file and the EOF marker is restored after writing is complete; creates the file first if it doesn’t exist.  When a file is opened with the \"a\" or \"a+\" access type, all write operations occur at the end of the file. The file pointer can be repositioned using fseek or rewind, but is always moved back to the end of the file before any write operation is carried out. Thus, existing data cannot be overwritten.  The \"a\" mode does not remove the EOF marker before appending to the file. After appending has occurred, the MS-DOS TYPE command only shows data up to the original EOF marker and not any data appended to the file. The \"a+\" mode does remove the EOF marker before appending to the file. After appending, the MS-DOS TYPE command shows all data in the file. The \"a+\" mode is required for appending to a stream file that is terminated with the CTRL+Z EOF marker.  When the \"r+\", \"w+\", or \"a+\" access type is specified, both reading and writing are allowed (the file is said to be open for “update”). However, when you switch between reading and writing, there must be an intervening fflush, fsetpos, fseek, or rewind operation. The current position can be specified for the fsetpos or fseek operation, if desired.  In addition to the above values, the following characters can be included in mode to specify the translation mode for newline characters:  t  Open in text (translated) mode. In this mode, CTRL+Z is interpreted as an end-of-file character on input. In files opened for reading/writing with \"a+\", fopen checks for a CTRL+Z at the end of the file and removes it, if possible. This is done because using fseek and ftell to move within a file that ends with a CTRL+Z, may cause fseek to behave improperly near the end of the file.   Also, in text mode, carriage return–linefeed combinations are translated into single linefeeds on input, and linefeed characters are translated to carriage return–linefeed combinations on output. When a Unicode stream-I/O function operates in text mode (the default), the source or destination stream is assumed to be a sequence of multibyte characters. Therefore, the Unicode stream-input functions convert multibyte characters to wide characters (as if by a call to the mbtowc function). For the same reason, the Unicode stream-output functions convert wide characters to multibyte characters (as if by a call to the wctomb function).  b  Open in binary (untranslated) mode; translations involving carriage-return and linefeed characters are suppressed.   If t or b is not given in mode, the default translation mode is defined by the global variable _fmode. If t or b is prefixed to the argument, the function fails and returns NULL.   For more information about using text and binary modes in Unicode and multibyte stream-I/O, see Text and Binary Mode File I/O and Unicode Stream I/O in Text and Binary Modes.  c  Enable the commit flag for the associated filename so that the contents of the file buffer are written directly to disk if either fflush or _flushall is called.  n  Reset the commit flag for the associated filename to “no-commit.” This is the default. It also overrides the global commit flag if you link your program with COMMODE.OBJ. The global commit flag default is “no-commit” unless you explicitly link your program with COMMODE.OBJ.  Valid characters for the mode string used in fopen and _fdopen correspond to oflag arguments used in _open and _sopen, as follows.  Characters in mode String Equivalent oflag Value for _open/_sopen   a _O_WRONLY | _O_APPEND (usually _O_WRONLY | _O_CREAT | _O_APPEND)  a+ _O_RDWR | _O_APPEND (usually _O_RDWR | _O_APPEND | _O_CREAT )  r _O_RDONLY  r+ _O_RDWR  w _O_WRONLY (usually _O_WRONLY | _O_CREAT | _O_TRUNC)  w+ _O_RDWR (usually _O_RDWR | _O_CREAT | _O_TRUNC)  b _O_BINARY  t _O_TEXT  c None  n None    Example  /* FOPEN.C: This program opens files named \"data\"  * and \"data2\".It  uses fclose to close \"data\" and  * _fcloseall to close all remaining files.  */  #include <stdio.h>  FILE *stream, *stream2;  void main( void ) {    int numclosed;     /* Open for read (will fail if file \"data\" does not exist) */    if( (stream  = fopen( \"data\", \"r\" )) == NULL )       printf( \"The file 'data' was not opened\\n\" );    else       printf( \"The file 'data' was opened\\n\" );     /* Open for write */    if( (stream2 = fopen( \"data2\", \"w+\" )) == NULL )       printf( \"The file 'data2' was not opened\\n\" );    else       printf( \"The file 'data2' was opened\\n\" );     /* Close stream */    if( fclose( stream ) )       printf( \"The file 'data' was not closed\\n\" );     /* All other files are closed: */    numclosed = _fcloseall( );    printf( \"Number of files closed by _fcloseall: %u\\n\", numclosed ); }   Output  The file 'data' was opened The file 'data2' was opened Number of files closed by _fcloseall: 1   Stream I/O Routines  See Also   fclose, _fdopen, ferror, _fileno, freopen, _open, _setmode", "referer": "user-0"}, {"cid": "12", "user": "user-8", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "13", "user": "user-9", "content": "有可能有几个原因 1. 作者笔误 2. 成文所参考的API版本不同  最简单的方法，就是 man fopen", "referer": "user-0"}, {"cid": "14", "user": "user-10", "content": "当然英文是对的, 拿不准看标准 https://pubs.opengroup.org/onlinepubs/9699919799/toc.htm", "referer": "user-0"}]}
{"question": "树是啥？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "一种植物，绿色的，很高大", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "当我是三岁小孩啊！我说的当然是数据结构里的树", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 7 楼 真相重于对错 的回复: 切换到吹水模式： 楼主这一问，颇有“恶乎定？”的神采， 我们必须用孟子的方式来回答：", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "不是c语言的知识，是数据结构里面的知识", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "是数据结构的一种", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "树就是树呗，有树枝和树叶", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "先从二叉树了解起，当然，c语言中文网有一切你想知道的，推荐你去看看哦", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "树，就像你家谱一样。 最上面是你，第二层是你的儿子，第三层是你的孙子。。。", "referer": "user-0"}, {"cid": "10", "user": "user-9", "content": "数据结构中的一种非线性结构。", "referer": "user-0"}, {"cid": "11", "user": "user-10", "content": "", "referer": "user-0"}, {"cid": "12", "user": "user-11", "content": "引用 5 楼 xian0-666 的回复:树就是树呗，有树枝和树叶 关键还有连理枝！", "referer": "user-0"}]}
{"question": "zedgraphcontrol坐标系里怎么获取鼠标坐标？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不懂，可能需要自己换算", "referer": "user-0"}]}
{"question": "请问大神 为啥输出的结果啥也没有", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "改成for(i = 1; i <= 101; i += 2)就好了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 6 楼 qq_53918454 的回复:[quote=引用 3 楼 一颗白面馒头的回复:]你是要求所有小于101的奇数的和？可以改成for(i = 0; i <= 101; i += 2) 请问一下 i+=2 是什么意思呀[/quote] 额。。。。等价于i = i + 2。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 一颗白面馒头的回复:你是要求所有小于101的奇数的和？可以改成for(i = 0; i <= 101; i += 2) 请问一下 i+=2 是什么意思呀", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "调试调试调试", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "死循环了！", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "你是要求所有小于101的奇数的和？可以改成for(i = 0; i <= 101; i += 2)", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "i = (2 * i) - 1。i一开始等于1， 执行这句话后还是等于1，死循环了", "referer": "user-0"}, {"cid": "9", "user": "user-6", "content": "死循环了，跳不出for循环，自然是不会执行printf了。  i = 1；满足i <= 101，然后sum  = sum + i; 紧接着第二次，i = (2 * i) -1 ; 即i = (2 * 1) - 1 = 1;这个时候是不是回到第一步了， 这样i一直是1，不会超过101，自然不会跳出循环了。", "referer": "user-0"}]}
{"question": "请问大神", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：1.   &x 2.   -term*x*x/((n+1)*(n+2)) 3.   count++ 4.   fabs(term)>=1e-5", "referer": "user-0"}]}
{"question": "请大神帮忙看一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第11行错了，应该是==。 =表示赋值，==表示等于，意思不一样", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "等于在逻辑判断里是2个=！请注意第11行！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include <ctype.h>         int isalnum(int c);        int isalpha(int c);        int isascii(int c);        int isblank(int c);        int iscntrl(int c);        int isdigit(int c);        int isgraph(int c);        int islower(int c);        int isprint(int c);        int ispunct(int c);        int isspace(int c);        int isupper(int c);        int isxdigit(int c);   The values returned are nonzero if the character c falls into the tested class, and a zero value if not.  供参考～ 库函数，匹配返回非0.", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "这句有误，ch == ' ' || ch == '\\n'", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "ch== 用==号，而不是=号", "referer": "user-0"}]}
{"question": "指针生命周期问题，为什么main函数在调用twoSum后，在twoSum中数组的地址可以返回给main，不是应该被释放么？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 xian0-666 的回复:你没搞清楚问题所在，只知道销毁，函数完成后，所指向的内存空间也随之被释放掉，所以函数终止意味着局部变量的引用将指向不再有效的内存区域，但是如果函数的局部变量作返回值时，会生成一个局部变量的拷贝用作返回值，之后局部变量会被系统回收，所以函数不能返回局部变量的地址，因为系统回收后，如果还返回局部变量的地址的话，指针所指向的内容毫无意义。  如：int a = 100; int *p = &a; cout << \"p的地址= \" << p << endl; return p; 这样访问地址是不正确的，危险的，因为已经释放掉了，但是因为可能这个区域还没来得及被其他使用覆盖，所以有可能还能访问以前的值，但是这种使用是错误的。 static char p[] = \"this is test0\\n\";    return p; char *p = \"this is test1\\n\";    return p;  要是这两种，test0保存在静态存储区，test1保存在只读常量区，不在通常所说的栈内存中，所以返回这个地址不会被回收，会正常返回原来的值。  总结：在主函数调用子函数时，首先程序会跳转到子函数的地址处，在子函数执行到最后return返回值时，系统会把需要返回的值存入寄存器中，然后经过“}”，子函数正式结束，在这个过程中，如果子函数有形参和局部变量，系统会为它们分配栈内存空间，等到函数运行完毕后，系统将会自动释放在栈内存中给局部变量分配的内存中的数据。所以说单纯的返回值不会有问题，但是如果要返回地址就会有问题。 至于释放，释放又不会把里面的值给修改了，那也太花精力了，只是那个值是不可控的，可能已经被修改了而已 顶，说的很棒", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "返回给main是一个地址，但是这个地址已经没有意义了，因为数组在函数调用完就结束了，自动释放了。函数栈twoSum都释放了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "你没搞清楚问题所在，只知道销毁，函数完成后，所指向的内存空间也随之被释放掉，所以函数终止意味着局部变量的引用将指向不再有效的内存区域，但是如果函数的局部变量作返回值时，会生成一个局部变量的拷贝用作返回值，之后局部变量会被系统回收，所以函数不能返回局部变量的地址，因为系统回收后，如果还返回局部变量的地址的话，指针所指向的内容毫无意义。  如：int a = 100; int *p = &a; cout << \"p的地址= \" << p << endl; return p; 这样访问地址是不正确的，危险的，因为已经释放掉了，但是因为可能这个区域还没来得及被其他使用覆盖，所以有可能还能访问以前的值，但是这种使用是错误的。 static char p[] = \"this is test0\\n\";    return p; char *p = \"this is test1\\n\";    return p;  要是这两种，test0保存在静态存储区，test1保存在只读常量区，不在通常所说的栈内存中，所以返回这个地址不会被回收，会正常返回原来的值。  总结：在主函数调用子函数时，首先程序会跳转到子函数的地址处，在子函数执行到最后return返回值时，系统会把需要返回的值存入寄存器中，然后经过“}”，子函数正式结束，在这个过程中，如果子函数有形参和局部变量，系统会为它们分配栈内存空间，等到函数运行完毕后，系统将会自动释放在栈内存中给局部变量分配的内存中的数据。所以说单纯的返回值不会有问题，但是如果要返回地址就会有问题。 至于释放，释放又不会把里面的值给修改了，那也太花精力了，只是那个值是不可控的，可能已经被修改了而已", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "你的理解是不准确的，如果你知道局部变量在栈里面，如果你自己了解什么是栈并实现过栈这样的数据结构。 那么，因为局部变量在栈中，向函数中传递参数直接push ,销毁数据呢，只要pop.局部变量的定义呢，只要把栈顶指针移动位置，就可以了 这些说的是基本技术背景。如果你了解这一些。 那么，push pop做了什么呢，push 不过是把数据复制到栈中，并把栈往上移动一个位置（实际x86机器，栈是往下走的，栈底在高位，压栈则是把栈顶指针向下移动），pop呢其实除了把栈顶指针（sp寄存器）加1外什么都不做。仔细想一下就应该知道。清空栈的操作就是把栈顶指针指向栈底。就可以。那么原来在内存中的数据，该在哪里还在哪里。不过是它们在栈顶指针的下部，如果再一次调用函数，把那个内存的单元直接拿过来用就是了。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 真相重于对错的回复:你认为怎么才算销毁？ main函数访问返回的地址，访问不到值。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 4 楼 xian0-666的回复:你没搞清楚问题所在，只知道销毁，函数完成后，所指向的内存空间也随之被释放掉，所以函数终止意味着局部变量的引用将指向不再有效的内存区域，但是如果函数的局部变量作返回值时，会生成一个局部变量的拷贝用作返回值，之后局部变量会被系统回收，所以函数不能返回局部变量的地址，因为系统回收后，如果还返回局部变量的地址的话，指针所指向的内容毫无意义。  如：int a = 100; int *p = &a; cout << \"p的地址= \" << p << endl; return p; 这样访问地址是不正确的，危险的，因为已经释放掉了，但是因为可能这个区域还没来得及被其他使用覆盖，所以有可能还能访问以前的值，但是这种使用是错误的。 static char p[] = \"this is test0\\n\";    return p; char *p = \"this is test1\\n\";    return p;  要是这两种，test0保存在静态存储区，test1保存在只读常量区，不在通常所说的栈内存中，所以返回这个地址不会被回收，会正常返回原来的值。  总结：在主函数调用子函数时，首先程序会跳转到子函数的地址处，在子函数执行到最后return返回值时，系统会把需要返回的值存入寄存器中，然后经过“}”，子函数正式结束，在这个过程中，如果子函数有形参和局部变量，系统会为它们分配栈内存空间，等到函数运行完毕后，系统将会自动释放在栈内存中给局部变量分配的内存中的数据。所以说单纯的返回值不会有问题，但是如果要返回地址就会有问题。 至于释放，释放又不会把里面的值给修改了，那也太花精力了，只是那个值是不可控的，可能已经被修改了而已 get 到点了", "referer": "user-0"}, {"cid": "9", "user": "user-6", "content": "诚然，返回一个地址，然后马上销毁该地址上的对象，有些吃饱了撑的，但仅此而已。 显示一个地址就是显示一个数字而已，只有你企图通过该地址访问已销毁对象时，后果才是未定义的。", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "你认为怎么才算销毁？", "referer": "user-0"}]}
{"question": "链表中出现段错误，这该怎么改呀", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h>  struct link {     int data;     struct link *next; };  struct link *AppendNode(struct link *head,int data); void DisplyNode(struct link *head); void DeleteMemory(struct link *head); struct link * DeleteNode(struct link *head,int data); struct link *InsertNode(struct link *head, int nodeData);  int main() {     char    c;     int data = 0;     struct link *head = NULL;      /* 链表头指针 */     while (1)     {         scanf(\"%d\",&data);         if (data==-1)             break;          head = AppendNode(head,data);/* 向head为头指针的链表末尾添加节点 */     }     DisplyNode(head);        /* 显示当前链表中的各节点信息 */     scanf(\"%d\",&data);     head = InsertNode(head,data);     DisplyNode(head);        /* 显示当前链表中的各节点信息 */     DeleteMemory(head);           /* 释放所有动态分配的内存 */     return 0; } struct link *AppendNode(struct link *head,int data) {     struct link *p=(struct link *)malloc(sizeof(struct link));     p->data=data;     p->next= NULL;     struct link *r=head; #if 0    //头重脚轻，改成如下形式     if(r)     {         while(r->next)             r=r->next;         r->next=p;     }     else         head=p; #else     if (!r) {         head = p;         return head;     }      while (r->next)         r = r->next;     r->next = p; #endif     return head; }  void DisplyNode(struct link *head) {     struct link *p;     p=head;      while (p) {         if (p == head) {             printf(\"%d\",p->data);             p = p->next;             continue;         }         printf(\"->%d\",p->data);         p=p->next;     }     /*     if(p)     {         printf(\"%d\",p->data);         p = p->next;     }     while(p!=NULL)     {         printf(\"->%d\",p->data);         p=p->next;     }     */     printf(\"\\n\"); } struct link * DeleteNode(struct link *head,int data) {     struct link *p,*q,*r;     p=q=head;      while(p!=NULL)     {         if(p->data==data)         {             if(p==head)             {                 head=p->next;                 r=p;                 p=q=head;             }             else             {                 q->next=p->next;                 r=p;                 p=q->next;             }             r->next=NULL;             free(r);         }         else         {             q=p;             p=p->next;         }     }      return head; }  void DeleteMemory(struct link *head) {     struct link *p,*q;     for(p=head;p;p=q)     {         q=p->next;         free(p);     } }  struct link *InsertNode(struct link *head, int data) {     struct link *p,*q;     int i=0,t;     q=head;     p=(struct link *)malloc(sizeof(struct link));     p->data=data;     p->next=NULL;       while(q)     {         if(p->data==0)         {             p->next=q->next;             q->next=p;             t=p->data;             p->data=q->data;             q->data=t;             i++;             return head;         }         if(p->data <= q->data)         {             p->next=q->next;             q->next=p;             t=p->data;             p->data=q->data;             q->data=t;             i++;             break;         }         else         {             q=q->next;         }     }     //if(i==0)     if(q==NULL)     {         q = head;         if (q == NULL) {             head = p;             return head;         }          while(q->next)             q=q->next;         q->next=p;         p->next=NULL;     }     return head; } 供参考～  InsertNode函数有问题，当要插入的data是链表中最大的时候，需要注意的是q需要初始化一下，否则在上面的while循环的时候q已经是NULL了， 另外，head也可能是NULL。因此需要特殊处理～  建议用上面的代码测试多种情况，比如中间插入，头插，尾插都测试一下  其他问题代码里都做了修改～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "最后一个函数是在链表中添加一个新节点", "referer": "user-0"}]}
{"question": "c语言bp神经网络 希望有大佬来纠错一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "试试赵老师的调试大法", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "激活函数用的是2/(1-e^-x)-1", "referer": "user-0"}]}
{"question": "大佬求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "结构体名书写有问题，注意下大小写～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "m_link的类型头文件没有包含进来", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "LinkList和Linklist不是一回事", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "(m_link->nHead).next=NULL; ......", "referer": "user-0"}]}
{"question": "大佬求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "应该是不识别Linklist，注意list的首字母是大写；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "结构体 LinkList 申请内存时 Linklist  list大小写不一致  另外，mLinksize和m_Linksize 也不一致", "referer": "user-0"}]}
{"question": "<简单数论-斐波那契>为什么运行是对的，提交上去系统总报错，求指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位问题已经找到了，正如#1所说我没有考虑N=1和N=2时的情况 把num和i初始值置0就过了 这题用int确实就可以满足题目了， #6#9的代码比我的更细节全面， 谢谢各位的回答 for(sum=0,i=0;i<4000;i++) \t\t{ \t\t\tif(num[i]>n) \t\t\t\tbreak; \t\t\tif(num[i]%2==0) \t\t\t\tsum+=num[i]; \t\t}", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "其实仔细研究下题目，没这么复杂，int型也足够了，修正#6楼的，如下，供参考：#include <stdio.h>  int main() {    int n[23],t,i=0,a,b,sum,k;     scanf(\"%d\",&t);    if(t<1 || t>23) t = 1;     while(t--){        scanf(\"%d\",&n[i]);        if(n[i]<1 || n[i]>4000000)n[i]=1;        i++;    }    t=0;    while(i--){         a=0,b=1,sum=0,k=0;         while((k=(a+b)) <= n[t]){               if(k%2==0) sum += k;               a = b;               b = k;         }         printf(\"%d\\n\",sum);         t++;    }    //system(\"pause\");    return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "尽管没有经验，但是我一直听说某些有性格的编译器会捕捉有符号整数的溢出，进行一些有性格的处理，因为标准说那是未定义行为嘛。 你写代码自己测试的编译器可能和我的编译器一样，无视这些溢出，毕竟是未定义行为嘛，无视也行。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "4000000以下的Fibonacci数列只有32项，累加到int应该也不会溢出。 疑似你的数列生成部分，溢出太多次了，引起系统不满了？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "题目的要求是成组输入，成组输出，修改如下，供参考：#include <stdio.h>  int main() {    int n[23],t,num[4000],i=0,sum,j=0;    num[0]=1;num[1]=2;    for(i=2;i<4000;i++){       num[i] = num[i-1]+num[i-2];    }    scanf(\"%d\",&t);    if(t<1 || t>23) t = 1;    while(t--){        scanf(\"%d\",&n[j++]);    }    t=0;    while(j--){         for(sum=0,i=0;i<4000 && num[i]<=n[t];i++)            {              if(num[i]%2==0) sum += num[i];            }         printf(\"%d\\n\",sum);         t++;    }   return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "%d 和 %lld 是一回事吗？", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "int 和 long long int 是一回事吗？", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "你看一下你的n支持多少？它的这个n支持4000000，你的支持40000，不满足条件吧 另外，你的测试只是用要求里提示的，没有考虑边界测试用例吧", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "这里的条件不对，修改如下，供参考： while(t--){        scanf(\"%d\",&n);        for(sum=0,i=0;i<4000 && num[i]<=n;i++)        {            if(num[i]%2==0) sum += num[i];        }        printf(\"%d\",sum);   }", "referer": "user-0"}]}
{"question": "我看了半天也不知道我哪错了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 xian0-666 的回复:C语言确实没有字符串变量类型，所以跟printf有什么关系？printf只是标准格式化输出，又不会改变变量的值，只是打印出来方便你看的，不管什么类型的变量，你都可以%d,%s,等等，只是有可能打印出来的值你看不懂而已，跟这个变量没有任何关系 哦，多谢指点", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C语言确实没有字符串变量类型，所以跟printf有什么关系？printf只是标准格式化输出，又不会改变变量的值，只是打印出来方便你看的，不管什么类型的变量，你都可以%d,%s,等等，只是有可能打印出来的值你看不懂而已，跟这个变量没有任何关系", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include \"stdio.h\" #include \"string.h\" int main() {     char a[5][81] = {'0'},temp[100] = {'0'};     int i ,j;     for( i = 0 ; i <= 4 ; i++ )         //gets(a[i]);         scanf(\"%s\", a[i]);     for( i = 0 ; i <= 3 ; i++ )         for( j = 0 ; j <= 3-i ; j++ )             if( strcmp( a[j] , a[j+1] ) > 0 )             {                 strcpy(temp,a[j]);                 strcpy(a[j],a[j+1]);                 strcpy(a[j+1],temp);             }     printf(\"After sorted:\\n\");     for( i = 0 ; i <= 4 ; i++ )     {         printf(\"%s\\n\", a[i]);     }     return 0; } 供参考  gets是读取一行，如果按照楼主的测试用例测试，这样输入了一行，而不是5行；  scanf是以空格可以区分不同的字符串的。所以，可以改成scanf %s C语言里面不是没有字符串变量类型的吗？那第九行是不是错了？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 xian0-666 的回复:gets不能用空格隔开 骚得死奈", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "gets不能用空格隔开", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "#include \"stdio.h\" #include \"string.h\" int main() {     char a[5][81] = {'0'},temp[100] = {'0'};     int i ,j;     for( i = 0 ; i <= 4 ; i++ )         scanf(\"%80s\",a[i]);     for( i = 0 ; i <= 3 ; i++ )         for( j = 0 ; j <= 3-i ; j++ )             if( strcmp( a[j] , a[j+1] ) > 0 )             {                 strcpy(temp,a[j]);                 strcpy(a[j],a[j+1]);                 strcpy(a[j+1],temp);             }     printf(\"After sorted:\\n\");     for( i = 0 ; i <= 4 ; i++ )     {         printf(\"%s\\n\", a[i]);     }     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "#include \"stdio.h\" #include \"string.h\" int main() {     char a[5][81] = {'0'},temp[100] = {'0'};     int i ,j;     for( i = 0 ; i <= 4 ; i++ )         //gets(a[i]);         scanf(\"%s\", a[i]);     for( i = 0 ; i <= 3 ; i++ )         for( j = 0 ; j <= 3-i ; j++ )             if( strcmp( a[j] , a[j+1] ) > 0 )             {                 strcpy(temp,a[j]);                 strcpy(a[j],a[j+1]);                 strcpy(a[j+1],temp);             }     printf(\"After sorted:\\n\");     for( i = 0 ; i <= 4 ; i++ )     {         printf(\"%s\\n\", a[i]);     }     return 0; } 供参考  gets是读取一行，如果按照楼主的测试用例测试，这样输入了一行，而不是5行；  scanf是以空格可以区分不同的字符串的。所以，可以改成scanf %s", "referer": "user-0"}]}
{"question": "请问mac怎么用c写游戏，没有windows.h", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "?", "referer": "user-1"}, {"cid": "3", "user": "user-3", "content": "xcode 吧，毕竟原厂推荐的，oc/swift", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:用C写，直接调用系统API，简单，直接，粗暴，高效。 答非所问啊啊", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "用C写，直接调用系统API，简单，直接，粗暴，高效。", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "推荐使用C++Builder", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 5 楼 forever74 的回复：就算在Windows下，windows.h也不足以支撑游戏开发啊。写简单的贪吃蛇而已", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "就算在Windows下，windows.h也不足以支撑游戏开发啊。", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "可以用qt啊，windows的东西，mac上没法用 https://blog.csdn.net/libaineu2004/article/details/46234079", "referer": "user-0"}]}
{"question": "    while(~scanf(\"%d%d\", &a, &b))printf(\"%d\\n\",a+b);", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "while(~scanf())是作为读取文件时判断文件是否在某刻终止输入的一种输入模式，在自调试时Windows的ctrl+z就是输入停止符。跟输入单个字符串时空格停止和输入一行字符串时计算机模拟出来一个'\\0'结束一样", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "~是按位取反 scanf的返回值是输入值的个数 如果没有输入值就是返回-1 -1按位取反结果是0 while(~scanf(\"%d%d\", &a,&b))就是当没有输入的时候退出循环", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "他这个写法并不好，应该： while(scanf(\"%d%d\", &a, &b) == 2) printf(\"%d\\n\",a+b);", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "#include<stdio.h> int main() {     int a,b;     while(scanf(\"%d%d\", &a, &b) == 2)printf(\"%d\\n\",a+b);     return 0; }  scanf是返回正确输入的项目个数，比如两个%d，那么如果都输入正确返回2，正确一个，比如输入1 a，则返回1。如果两个都错误，则返回0。或者EOF，输入了EOF（LINUX ctrl + d, windows ： ctrl + z） 因此用~是不合适的。", "referer": "user-0"}]}
{"question": "zedgraphcontrol控件中禁用横向纵向放大后，怎么设置出现橡皮筋框选呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}]}
{"question": "c语言中自增自减可以用于数字，还可以用于字母的自增减，还有什么呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 14 楼 lin5161678 的回复:[quote=引用 13 楼 zd845101500 的回复:]只要本质是数值的东西都可以试试 本质这个词别随便说出口 能不能++只和值类别(是不是可修改左值) 和 表达式类型 有关系 [/quote]所以我说的是试试", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 13 楼 zd845101500 的回复:只要本质是数值的东西都可以试试 本质这个词别随便说出口 能不能++只和值类别(是不是可修改左值) 和 表达式类型 有关系", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "只要本质是数值的东西都可以试试", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "因为char在C语言里面可以当作int处理，在ASCII码里A-Z对应65-90，a-z对应97-122 你可以试试 char c = 'a' printf(\"%d\", c)", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "还有指针的自增自减，表示移动到下一个地址", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "谢邀。 标准中是这样规定的：  6.5.2.4 Postfix increment and decrement operators Constraints 1 The operand of the postfix increment or decrement operator shall have atomic, qualified, or unqualified real or pointer type, and shall be a modifiable lvalue.  简单地说，操作数应当是原子的、限定或者无限定的实数或者指针类型，而且必须是可修改的左值。", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "只要是整型数都是可以，数字是整型，字符也是整型（char自动提升为int类型）", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "iterator", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "自增/自减运算符是使对象的值增加/减少 1 的一元运算符。  它们能拥有后缀形式：  expr ++\t\t expr --\t\t 还有前缀形式：  ++ expr\t\t -- expr\t\t  前缀和后缀自增或自减的运算数 expr 必须为整数类型（包含 _Bool 和枚举）、实浮点类型或指针类型的可修改左值。它能为 cvr 限定、无限定或为原子。", "referer": "user-0"}, {"cid": "10", "user": "user-9", "content": "主要用在循环里，对变量或者指针加加减减，其他地方不咋用", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "引用 8 楼 github_37127447 的回复:只要你想 你把所有类都 实现个 ++操作符重载就行了看标题 C语言", "referer": "user-0"}, {"cid": "12", "user": "user-10", "content": "只要你想 你把所有类都 实现个 ++操作符重载就行了", "referer": "user-0"}, {"cid": "13", "user": "user-2", "content": "引用 5 楼 自信男孩 的回复:只要是整型数都是可以，数字是整型，字符也是整型（char自动提升为int类型）浮点类型和指针类型也可以自增 char在自增不会做类型提升 char也是整型是对的 但不是int", "referer": "user-0"}, {"cid": "14", "user": "user-2", "content": "标量类型都可以", "referer": "user-0"}, {"cid": "15", "user": "user-11", "content": "穷举法作为算法则可，作为学习方法就不妥了。 眼中所见，貌似该举的都举了。 然而一旦你转过前方拐角，眼中又是一片新的天地。  ++  -- 的操作数至少还有指针。", "referer": "user-0"}]}
{"question": "zedGraph控件里画框，中间拉线过程怎么实现？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：///////////////////////////////////////////////////////////////////////////// // CTrackerView message handlers  void CTrackerView::OnLButtonDown(UINT nFlags, CPoint point) { \tCTrackerDoc* pDoc =\tGetDocument(); \tCRect rectSave; \tpDoc->m_tracker.GetTrueRect(rectSave); \tif (pDoc->m_tracker.HitTest(point) < 0) \t{ \t\t// just\tto demonstrate CRectTracker::TrackRubberBand \t\tCRectTracker tracker; \t\tif (tracker.TrackRubberBand(this, point, pDoc->m_bAllowInvert)) \t\t{ \t\t\tMessageBeep(0);\t// beep\tindicates TRUE  \t\t\t// see if rubber band intersects with the doc's tracker \t\t\tCRect rectT; \t\t\ttracker.m_rect.NormalizeRect();\t// so intersect\trect works \t\t\tif (rectT.IntersectRect(tracker.m_rect,\tpDoc->m_tracker.m_rect)) \t\t\t{ \t\t\t\t// if so, put resize handles on\tit (ie.\tselect it) \t\t\t\tif (pDoc->m_tracker.m_nStyle & CRectTracker::resizeInside) \t\t\t\t{ \t\t\t\t\t// swap\tfrom resize\tinside to resize outside for effect \t\t\t\t\tpDoc->m_tracker.m_nStyle &=\t~CRectTracker::resizeInside; \t\t\t\t\tpDoc->m_tracker.m_nStyle |=\tCRectTracker::resizeOutside; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\t// just\tuse\tinside resize handles on first time \t\t\t\t\tpDoc->m_tracker.m_nStyle &=\t~CRectTracker::resizeOutside; \t\t\t\t\tpDoc->m_tracker.m_nStyle |=\tCRectTracker::resizeInside; \t\t\t\t} \t\t\t\tpDoc->SetModifiedFlag(); \t\t\t\tpDoc->UpdateAllViews(NULL, (LPARAM)(LPCRECT)rectSave); \t\t\t\tpDoc->UpdateAllViews(NULL); \t\t\t} \t\t} \t} \telse if\t(pDoc->m_tracker.Track(this, point,\tpDoc->m_bAllowInvert)) \t{ \t\t// normal tracking action, when\ttracker\tis \"hit\" \t\tpDoc->SetModifiedFlag(); \t\tpDoc->UpdateAllViews(NULL, (LPARAM)(LPCRECT)rectSave); \t\tpDoc->UpdateAllViews(NULL); \t} \tCView::OnLButtonDown(nFlags, point); }   CRectTracker::TrackRubberBand BOOL TrackRubberBand( CWnd* pWnd, CPoint point, BOOL bAllowInvert = TRUE );  Return Value  Nonzero if the mouse has moved and the rectangle is not empty; otherwise 0.  Parameters  pWnd  The window object that contains the rectangle.  point  Device coordinates of the current mouse position relative to the client area.  bAllowInvert  If TRUE, the rectangle can be inverted along the x-axis or y-axis; otherwise FALSE.  Remarks  Call this function to do rubber-band selection. It is usually called from inside the function of your application that handles the WM_LBUTTONDOWN message (typically OnLButtonDown).  This function will capture the mouse until the user releases the left mouse button, presses the ESC key, or presses the right mouse button. As the user moves the mouse cursor, the feedback is updated by calling DrawTrackerRect and OnChangedRect.  Tracking is performed with a rubber-band-type selection from the lower-right handle. If inverting is allowed, the rectangle can be sized by dragging either up and to the left or down and to the right.  CRectTracker Overview |  Class Members |  Hierarchy Chart  See Also   CRectTracker::DrawTrackerRect, CRectTracker::OnChangedRect, CRectTracker::CRectTracker", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 赵4老师的回复:仅供参考：///////////////////////////////////////////////////////////////////////////// // CTrackerView message handlers  void CTrackerView::OnLButtonDown(UINT nFlags, CPoint point) { \tCTrackerDoc* pDoc =\tGetDocument(); \tCRect rectSave; \tpDoc->m_tracker.GetTrueRect(rectSave); \tif (pDoc->m_tracker.HitTest(point) < 0) \t{ \t\t// just\tto demonstrate CRectTracker::TrackRubberBand \t\tCRectTracker tracker; \t\tif (tracker.TrackRubberBand(this, point, pDoc->m_bAllowInvert)) \t\t{ \t\t\tMessageBeep(0);\t// beep\tindicates TRUE  \t\t\t// see if rubber band intersects with the doc's tracker \t\t\tCRect rectT; \t\t\ttracker.m_rect.NormalizeRect();\t// so intersect\trect works \t\t\tif (rectT.IntersectRect(tracker.m_rect,\tpDoc->m_tracker.m_rect)) \t\t\t{ \t\t\t\t// if so, put resize handles on\tit (ie.\tselect it) \t\t\t\tif (pDoc->m_tracker.m_nStyle & CRectTracker::resizeInside) \t\t\t\t{ \t\t\t\t\t// swap\tfrom resize\tinside to resize outside for effect \t\t\t\t\tpDoc->m_tracker.m_nStyle &=\t~CRectTracker::resizeInside; \t\t\t\t\tpDoc->m_tracker.m_nStyle |=\tCRectTracker::resizeOutside; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\t// just\tuse\tinside resize handles on first time \t\t\t\t\tpDoc->m_tracker.m_nStyle &=\t~CRectTracker::resizeOutside; \t\t\t\t\tpDoc->m_tracker.m_nStyle |=\tCRectTracker::resizeInside; \t\t\t\t} \t\t\t\tpDoc->SetModifiedFlag(); \t\t\t\tpDoc->UpdateAllViews(NULL, (LPARAM)(LPCRECT)rectSave); \t\t\t\tpDoc->UpdateAllViews(NULL); \t\t\t} \t\t} \t} \telse if\t(pDoc->m_tracker.Track(this, point,\tpDoc->m_bAllowInvert)) \t{ \t\t// normal tracking action, when\ttracker\tis \"hit\" \t\tpDoc->SetModifiedFlag(); \t\tpDoc->UpdateAllViews(NULL, (LPARAM)(LPCRECT)rectSave); \t\tpDoc->UpdateAllViews(NULL); \t} \tCView::OnLButtonDown(nFlags, point); }   CRectTracker::TrackRubberBand BOOL TrackRubberBand( CWnd* pWnd, CPoint point, BOOL bAllowInvert = TRUE );  Return Value  Nonzero if the mouse has moved and the rectangle is not empty; otherwise 0.  Parameters  pWnd  The window object that contains the rectangle.  point  Device coordinates of the current mouse position relative to the client area.  bAllowInvert  If TRUE, the rectangle can be inverted along the x-axis or y-axis; otherwise FALSE.  Remarks  Call this function to do rubber-band selection. It is usually called from inside the function of your application that handles the WM_LBUTTONDOWN message (typically OnLButtonDown).  This function will capture the mouse until the user releases the left mouse button, presses the ESC key, or presses the right mouse button. As the user moves the mouse cursor, the feedback is updated by calling DrawTrackerRect and OnChangedRect.  Tracking is performed with a rubber-band-type selection from the lower-right handle. If inverting is allowed, the rectangle can be sized by dragging either up and to the left or down and to the right.  CRectTracker Overview |  Class Members |  Hierarchy Chart  See Also   CRectTracker::DrawTrackerRect, CRectTracker::OnChangedRect, CRectTracker::CRectTracker 谢谢您，非常详细的讲解不过还是没搞懂，我用了一个非常巧妙的办法，在mouseupevent事件下添加鼠标选中放大为false，这样借用了IsEnableZoom的选中过程", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:TRACKER 示例：阐释各种 CRectTracker 样式和选项 https://docs.microsoft.com/zh-cn/previous-versions/visualstudio/visual-studio-2008/ms177537(v=vs.90) 看不懂啊老师，我这例子可不可以简单加段代码实现呢？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "TRACKER 示例：阐释各种 CRectTracker 样式和选项 https://docs.microsoft.com/zh-cn/previous-versions/visualstudio/visual-studio-2008/ms177537(v=vs.90)", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "小白求教，根据已有代码怎么实现画框过程？还有鼠标坐标怎么绑zedGraph创建的坐标系", "referer": "user-0"}]}
{"question": "for循环", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "少一个++!", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "因为你在m还等于8的时候先在小括号里面加了一下，又在循环内部加了一下，变成了10，再判断出m不小于9，所以此时m为10", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "for(语句1;语句2;语句3)  语句4 执行顺序是：语句1(执行一次)，后重复循环语句2、语句4、语句3。 你只要记得语句3是最后执行的就行", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "快进到m=8的时候，m=8时，满足循环条件，执行循环体内容，此时m=9，循环体语句结束后执行for循环中第三个表达式m++，此时m=10，重新进入判断，此时不满足循环条件，跳出循环 了解一下循环步骤其实很好做，一般来说 for 循环有以下步骤 ①初始化循环变量，这步仅执行一次 ②是否满足循环条件，满足执行③，不满足直接跳出循环 ③执行循环体 ④执行第三个表达式后，跳转到②", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "for (A;B;C) D; //等价于 {  A;  while (1) {   if (!(B)) break;   D;   C;  } }", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "#include <stdio.h>   int main() {     int m;      for( m=0; m<9; m++ ){         m++;         printf(\"m = %d\\n\", m);     }     printf(\"m = %d\\n\", m);     return 0; } 当m=8时，满足条件，因此执行循环体（此时循环执行后m=9)，然后再执行m++(for中的），判断10 ！< 9退出循环；  需要熟悉循环的三条语句的执行过程～", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "for( m=0; m<9; m++ )如果只有这个for循环，那么m=8时还是成立的m++，则m=9，但是此时进行已经进入循环了，而循环内m还要++，则m=10", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "没逮到得9的机会，它也很无奈。", "referer": "user-0"}, {"cid": "10", "user": "user-10", "content": "因为在循环体内有m++,所以m值按0 ，2 ，4，6，8变化，当到8时，8<9条件满足的，所以再执行m++,m++二次，此时再判断10<9不成立，跳出for循环。 for(表达式1;表达式2;表达式3) { 循环体 } for循环的执行顺序： （1）执行for后表达式1； （2）执行表达式2，若表达式2的值为真（或非0），则执行for内循环体，然后执行（3）；否则，则循环结束，执行（5） （3）执行表达式3 （4）返回继续执行（2） （5）循环结束，执行for语句的循环体下面的语句", "referer": "user-0"}]}
{"question": "在线求助  大佬帮忙看看   C语言2000以内非质数代码怎么写啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "非质数就是判断不是质数,用个判断质数函数判断即可.", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "easy啊 const int num = 2000;  int _tmain(int argc, _TCHAR* argv[]) {\t \tint i,j; \tint k; \tfor( i = 1; i <= num; i ++) \t{ \t\tk = 0; \t\tfor(j = 2; j < i; j ++) \t\t{ \t\t\tif(i % j == 0) \t\t\t{ \t\t\t\tk = 1; \t\t\t\tbreak; \t\t\t} \t\t} \t\tif(k == 1) \t\t{ \t\t\tprintf(\"%d\\t\",i); \t\t} \t} \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include <stdio.h> int Prime[14]={2,3,5,7,11,13,17,19,23,29,31,37,41,43}; int isPrime(int v) {     int i;     if (v<47) {         for (i=0;i<14;i++) if (v==Prime[i]) break;         if (i<14) return 1; else return 0;     } else {         for (i=0;i<14;i++) if (v%Prime[i]==0) break;         if (i<14) return 0; else return 1;     } } int main() {     int i,j;      j=0;     for (int i=0;i<=2000;i++) {         if (!isPrime(i)) {             if (j%8==7) printf(\"%d\\n\",i);             else         printf(\"%d \",i);             j++;         }     }     return 0; } //0 1 4 6 8 9 10 12 //14 15 16 18 20 21 22 24 //25 26 27 28 30 32 33 34 //35 36 38 39 40 42 44 45 //46 48 49 50 51 52 54 55 //56 57 58 60 62 63 64 65 //66 68 69 70 72 74 75 76 //77 78 80 81 82 84 85 86 //87 88 90 91 92 93 94 95 //96 98 99 100 102 104 105 106 //…… //1978 1980 1981 1982 1983 1984 1985 1986 //1988 1989 1990 1991 1992 1994 1995 1996 //1998 2000 //", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "引用 1 楼 我当时害怕极了QAQ 的回复:#include<stdio.h> int fun(int m) { \tint a=0; \tint i=0; \tfor(i=2;i<m;i++) \t{ \t\tif(m%i==0) \t\t{ \t\t\ta++; \t\t} \t} \tif(a==0) \treturn 1; \telse \treturn 0; } int main() { \tint i; \tfor(i=2;i<=2000;i++) \t{ \t\tif(fun(i)==1) \t\t{ \t\t\tprintf(\"%d\\n\",i); \t\t} \t} \t \treturn 0; }  刚好有现成的  没看题，非质数  for(i=1;i<=2000;i++)     {         if(fun(i)==0)         {             printf(\"%d\\n\",i);         }     }", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "#include<stdio.h> int fun(int m) { \tint a=0; \tint i=0; \tfor(i=2;i<m;i++) \t{ \t\tif(m%i==0) \t\t{ \t\t\ta++; \t\t} \t} \tif(a==0) \treturn 1; \telse \treturn 0; } int main() { \tint i; \tfor(i=2;i<=2000;i++) \t{ \t\tif(fun(i)==1) \t\t{ \t\t\tprintf(\"%d\\n\",i); \t\t} \t} \t \treturn 0; }  刚好有现成的", "referer": "user-0"}]}
{"question": "c语言学习中递归的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "啊来晚了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "关于递归的例子，可以看看这个案例，点击这里 #include<stdio.h> int  fact(int n,int a,int b) {     if(n==1 || n==2)      return 1;      else       return (a*fact(n-1,a,b)+b*fact(n-2,a,b))%7; } int main() {     int a,b,n;     scanf(\"%d%d%d\",&a,&b,&n);     printf(\"%d\\n\",fact(n,a,b));   return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "兄弟们我会了，谢谢大家", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "第一个level4是#1打的。第二个level4是#2打印的。后面的3 2 1都是#2打印的", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "想明白了谢谢大家", "referer": "user-0"}]}
{"question": "排序问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 qq_41998411 的回复:希尔 ①选择和冒泡每趟必定有一个数到最终位置上的 ②如果是快速的话这里面没有一个数左边全比自己小的同时右边全比自己大 ③增量=3 试试看  嗯，知道了，谢谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "希尔 ①选择和冒泡每趟必定有一个数到最终位置上的 ②如果是快速的话这里面没有一个数左边全比自己小的同时右边全比自己大 ③增量=3 试试看", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 宇来风满楼 的回复:希尔吧，排除法  一趟怎么希出来呢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "选择排序的话，应该只有收尾两个交换，现在看中间的也有交换，因此不是选择排序； 冒泡排序，是每个都交换，但是19没有到第一个位置，所以不是冒泡； 快排和希尔的排序，需要分析一下，", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "希尔吧，排除法", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "各种排序算法动画演示http://www.webhek.com/misc/comparison-sort/", "referer": "user-0"}]}
{"question": "指向字符串的指针变量", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "\"123453245\" 这个其实是const char [字符长度]，是个字面值，不能直接用char* 去绑定，而是要用const char* 绑定。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "看老的资料,用新的工具,是要考虑一下,随意下定论不宜,知识应该是有传承的.", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "编译器太古老了，换新编译器，直接编译出错。话说做视频的都不运行下程序的吗还是他们用的VC6在跑？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "其它且不论,说指针有问题,没发现,要仔细检查自己写得是否有问题.", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "不请自来。  闲来无事，既然看到了这个话题，就来说一说。这实际上涉及字符数组、字符串和字面串这三者的关系，厘清了，自然就明白了。  首先，字面串和字符数组是C语言里的东西，而字符串则是C标准库的内容，严格来说并不是C语言的一部分。  什么是字符串？字符串是一个字符的序列，以第一个遇到的空字符终止。什么是字面串？字面串就是“字面意义上的字符串”，是我们写在程序中的、用来代表字符串的文本，毕竟它还需要由编译器来识别并生成字符串，所以才叫“字面串”，比如 \"xyz\"。相反，字符串是位于可执行程序或者内存里的字符序列，而且以第一个遇到的空字符终止。那么，什么是字符数组呢？它首先是一个数组。然后，它的元素类型是char、wchar_t、char16_t或者char32_t。  可以肯定，字符串也是字符数组，这很好理解。但是反过来，字符数组并不一定是字符串，因为字符数组中未必包含空字符 ，这样它就无法形成一个字符串。  要构造一个字符数组，方法有很多。典型地，字面串就可以自动生成字符数组。按规定，在程序翻译期间，字面串用于生成一个具有静态存储期的字符数组，而且自动添加一个空字符。这样一个数组是没有名字的，C语言只规定了这个数组的生存期是静态的，也就是，从程序启动时就存在，程序结束时才销毁，但并没有说别的。C语言只是保证，根据字面串的书写形式，它的元素类型可以是 char、wchar_t、char16_t或者char32_t。所以，认为 \"xyz\" 是 const char 类型的数组，是错误的。  用字面串生成的静态数组位于哪里呢？不一定，这取决于系统架构。在有些简单的机器上，不存在内存保护机制，也没有分页机制，比如运行在 8086 处理器上的MS-DOS系统。在这种机器上，用字面串生成的静态数组当然是可读可写的。但是在现代的很多机器上，内存有保护机制，也引入了分页，可执行映像比以前更复杂，用字面串生成的静态数组可能被安排在只读的内存区域，这就不可写了。  标准化之后的C语言考虑了这些因素，因此规定，如果程序企图去修改这样一个（从字面串生成的）数组，这种行为是未定义的。对于我们来说，不要强调你所认识的机器架构，也不要拿你的汇编知识来加强这种认识，更不要武断地说这个字符数组一定是不可写入的，毕竟这是C语言。  用字面串可以生成字符串，但这两者不见得是等价的，因为一个字面串可以生成多个字符串。比如对于字面串 \"abc\\0xyz\\0\"，这个字面串生成了一个静态数组，而这个数组包含了三个字符串：字符串abc、xyz，以及最后的空串 \\0 （这最后一个\\0是在生成字符数组时自动添加的）。最后，我们用一个例子来结束这次探讨。  # include <stdio.h>  int main (void) {     char a [] = \"abc\\0xyz\\0\";     char * p = \"he\\0she\\0\";      printf (p);     printf (p + 3);     printf (p + 7); } 在第一个声明中，字面串 \"abc\\0xyz\\0\" 用于在程序翻译期间生成一个具有静态存储期的匿名数组，并用这个数组的内容初始化数组 a ；在第二个声明中，字面串 \"he\\0she\\0\" 用于在程序翻译期间生成一个具有静态存储期的匿名数组。作为变量 p 的初始化器（Initializer），数组类型的表达式自动转换为指向数组首元素的指针，并用于初始化变量 p 。  然后，在变量 p 指向的地方（它指向数组的首元素），依次有三个字符串。这三个 printf 依次打印这些字符串。最后打印的是空串，所以什么内容也没有。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "#pragma comment(linker,\"/SECTION:.rdata,RW\") //加这句可以让常量区可写，后果自负！", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:strcpy(p+3, s+9);这句会出现段错误，因为p指向的字符串是只读的，而这句会对它写； 其他的输出语句都没问题，因为都不会对p指向的字符串进行写操作；  要想让这句strcpy(p+3, s+9)执行没问题，需要对p定义成字符数组。不过需要注意额是由于有copy和strcat，建议把字符数组的长度定义更长一些， 防止越界。 明白了明白了 谢谢", "referer": "user-0"}, {"cid": "10", "user": "user-7", "content": "strcpy(p+3, s+9);这句会出现段错误，因为p指向的字符串是只读的，而这句会对它写； 其他的输出语句都没问题，因为都不会对p指向的字符串进行写操作；  要想让这句strcpy(p+3, s+9)执行没问题，需要对p定义成字符数组。不过需要注意额是由于有copy和strcat，建议把字符数组的长度定义更长一些， 防止越界。", "referer": "user-0"}, {"cid": "11", "user": "user-8", "content": "是的，可以说老师讲的不对。 按照原文，strcpy那行企图修改字符串字面量的行为是未定义行为。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "我改成了char p［20］=\"1234567\"；才对 上面文字说明打错了。在这里更正一下", "referer": "user-0"}]}
{"question": "在线求助，用C语言做界面", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "百度一下GTK，或许适合。。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "使用easyx库", "referer": "user-0"}]}
{"question": "在采用补码运算的32位机器上，求值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "另外，2147483648似乎没什么机会“正好是0”。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "右边一样被提升为unsigned 而32位unsigned int的最大值是4294967295", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "补码没有负0.你理解错了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "并没有限定int类型，我觉得这样有争议，如果是int类型，在2个操作数中，其中1个为无符号，那么会隐式转为无符号数计算，但是-2147483647-1U值为2147483648，整形最大值2147483647，那么2147483648不正好是INT类型的0吗？0<2147483647的答案为真，如果不是INT类型呢，又何解？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "类型提升规则，int和unsigned int混合运算之前，都提升为unsigned int", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "#include <stdio.h> int main() {     if (-2147483647-1U < 2147483647) printf(\"Yes\\n\");     else printf(\"No\\n\");     return 0; } //No //", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "？", "referer": "user-0"}]}
{"question": "c 如何将一个string里二进制的数字变成对应的ASCII", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//比如我有一个char str[]=\"01001000011001010110110001101100011011110\"; // 和                char word[1000] // 用于储存2进制的数字 //如何分别将str的 01001000 01100101 01101100 01101100 01101111 0 分别存入 word[0], word[1], word[2], word[3], 和 word[4]. 然后printf(\"%s\",word)的时候可以直接打出\"Hello\". // //ASCII: //01001000 --> H //01100101 --> e //01101100 --> l //01101100 --> l //01101111 --> o // #include <stdio.h> #include <stdlib.h> #include <string.h> int main() {     char str[]=\"0100100001100101011011000110110001101111\";     char word[1000];     char bs[9];     char *s;     char *e;     s=str;     for (int i=0;i<5;i++) {         sprintf(bs,\"%.8s\",s+8*i);         word[i]=(char)strtol(bs,&e,2);     }     word[5]=0;     printf(\"%s\",word);//Hello     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "const char* p = \"0100100001100101011011000110110001101111\";     char* dest = new char[strlen(p) / 8+1]{0};     for (int i = 0; i < strlen(p); i += 8) {         char strbyte[9]{ 0 };         memcpy(strbyte, p+i, sizeof(char)*8);         dest[i / 8] = strtol(strbyte, 0, 2);            }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不小心多敲了一个l，毕竟我等看见你的Hello，手里就去敲world了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "char word[1000]={0}; int i,j; for(i=0;i<strlen(str)/8;i++) for(j=0;j<8;j++) { world[i]|=(str[8*i+j]-'0')<<(7-j); }  大约就酱紫。", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "i % 2这个东西，要理解的话，一个表达式如果后面没有加i % 2 == xxx，则可以看做成立，即i % 2 成立可以表示为i % 2 ==1 ，即i除以2取的余数==1", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 7 楼 是疗伤烧肉粽~ 的回复:if（i%2）相当于 if（i%2!=0） 也就是当i%2不等于0时执行if（i%2）也就是奇数时执行，偶数时执行else", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "if（i%2）相当于 if（i%2!=0） 也就是当i%2不等于0时执行", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "翻译一下，就是if（i是奇数）。 因为，%是求余数运算，当i是奇数时，I%2=1，偶数时为0", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "if(i%2)中，表达式 i%2 的结果为整数i对2求余后的结果，结果只有零值(当i为偶数时)和非零值(当i为奇数时)。结果为零（代表假）时，if语句的判断条件为假，所以不执行if后面的语句，而是执行else后面的语句；结果为非零值（代表真）时，if语句的判断条件为真，执行if后面的语句，而不执行else后面的语句。", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "7%-5 =  2", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "7%5  =  2 -7%5 = -2 7%-2 =  2 -7%-5= -2", "referer": "user-0"}, {"cid": "10", "user": "user-8", "content": "如i=4;那么i%2就等于0 if（i%2）一般用来判断那个数的奇偶性，i%2==0就说明是偶数，==1就说明i是奇数", "referer": "user-0"}, {"cid": "11", "user": "user-8", "content": "i对2求余,就是数学里的余数,比如i=3;那么i%2就等于1.", "referer": "user-0"}]}
{"question": "c#双击设计器生成的代码怎么删除", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 智者知已应修善业的回复:通常编程软件都有后退按钮后退一下即可 zedgraphcontrol坐标系里怎么获取鼠标坐标？利用mousedown事件鼠标左键获取的是zedgraph的控件坐标，而不是我自定义的坐标系，鼠标在控件中的坐标请问怎么转换到自定义坐标系里？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "通常编程软件都有后退按钮后退一下即可", "referer": "user-0"}]}
{"question": "请看下列程序，有关i++什么时候执行？请教大神，详解。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这句：引用for(k=0;k<2*i-1;k++)有问题的，应该是 for(k=0;k<2*i+1;k++)", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "修改如下，供参考：#include<stdio.h>  main() {     int N,i,j,k;     printf(\"请输入整数N作为金字塔层数：\\n\");     scanf(\"%d\",&N);     printf(\"\\n\");     printf(\"输出金字塔如下：\\n\");     for(i=0;i<=N;i++)  //执行for语句，在这里i++后，如果定义sum=0，sum=sum+i的话，sum仍然=0        {          printf(\"i=%d\",i);  //这里输出看看i的值          for(j=0;j<N-i;j++) //但是在这里i=0              printf(\" \");          for(k=0;k<2*i-1;k++)              printf(\"*\");          printf(\"\\n\");        }      return 0; } 楼主结合上面的代码，再看看下面的运行结果图： 如果输入1，结果如下，一定是从0开始的：", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "在for循环里  for(a;b;c)                     {循环体} 执行顺序：b为真，执行循环体，再执行c。    假如金字塔层数为N=1，那么执行第一次循环for（j=0;j<N-i;j++)时，N-i=0,应该是跳出来了。   但是循环还行执行，这个i++在for循环里是怎样执行的，什么时候执行，会有什么结果啊？痛苦纠结。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "懂了，谢谢。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "但是上面的程序一样可以正确的输出结果，程序是对的，就是i的值开始是0， 但是i++本来是在循环体之后执行的，但是上面程序如果N=1的话，i++就在循环体之前就执行了。 实在不解。。求解", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "修改，供参考：#include<stdio.h>  main() {     int N,i,j,k;     printf(\"请输入整数N作为金字塔层数：\\n\");     scanf(\"%d\",&N);     printf(\"\\n\");     printf(\"输出金字塔如下：\\n\");     for(i=0;i<N;i++)        //for(i=0;i<=N;i++)        {          printf(\"i=%d\",i);          for(j=0;j<N-i;j++)              printf(\" \");          for(k=0;k<2*i+1;k++)//for(k=0;k<2*i-1；k++)              printf(\"*\");          printf(\"\\n\");        }         return 0; }", "referer": "user-0"}]}
{"question": "请教大神们，有没有高效的方法，过滤DMA中100个word中零或者一", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "buffer_4[100]中每个字的最高位组成新字？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "所以建议你以16位为处理基准，>=16位了，就把低16位保存然后移出去，偶数次的时候再把两个16位拼起来保存。 这样有高16位缓冲，不会丢数据。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我的本意是，每32位后，把结果封装成一个字存起来。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "void sample_2(void) {     UINT8 last_bit=0,current_bit=0;     UINT8 cnt=0,pos=0,j;     UINT32 temp,result=0;     UINT16 i=0;     for (i=0;i<100;i++) {                  temp = buffer_4[i];          for (j=0;j<32;j++) {                          current_bit = temp & 0x01;                      if (current_bit ^ last_bit) {                  if ((cnt >= 7) && (cnt <= 12)) {           //00                     if (last_bit)                         result |= (3 << pos);                     pos += 2;                 } else if ((cnt >= 2) && (cnt <= 6)) {     //0                     if (last_bit)                         result |= (1 << pos);                     pos++;                 }                  cnt = 0;                              }                          last_bit = current_bit;             cnt++;             temp >>= 1;              if (pos >= 32) {                 pos = 0;                 printf(\"word:%X\\n\",result);                 result = 0;             }         }       } } 当前采用该方法，速度还不够快。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "正面的，从算法角度看，你的数据从头到尾撸了一遍，O(n)的，已经很难优化了。 反面的，你的代码似乎和上方设定不一致啊，我是说连续位的数量。 另外，输出的result，两次之间不够连续啊，如果上次的有了31位，这次再来2位，那就33位了，会丢弃1位啊。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "DMA是原封不动地搬运数据的，不存在“过滤”的问题。 过滤，可以在启动DMA之前，或者DMA完成后进行。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "上个Verilog？反正你既然搞DMA就不在乎上块芯片", "referer": "user-0"}]}
{"question": "7-1 求奇数的平均数 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include#includeusing namespace std;int main(){    int n;    cin>>n;    int m[n],i(0);    float a,s(0.0),b(0.0);    for(i=0;i<n;i++)        cin>>m[i];    for(i=0;i<n;i++)    {        if(m[i]%2!=0)       {          s+=m[i];          b++;       }    }    a=s/b;    cout<<fixed<<setprecision(3)<<a<<endl;    return 0;}", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这是c++", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "修正楼上，样例无错误的，正确。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "样例有错误。供参考：#include <stdio.h>  int main(int argc, char* argv[]) {         int n,sum=0,i=0,d;         scanf(\"%d\",&n);         if(n>50) n=50;         while(n--){              scanf(\"%d\",&d);              if(d & 1 ==1){//通过位运算判断                 sum += d;                 i++;              }         }         printf(\"%.3f\",(float)sum/(float)i);                  return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "自己也有写出来 不对呀", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "目测样例有误？C语言算不出来，任何语言都不行的。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "先拿到 输入的数据 然后 判定 数值 %2 是否等1 来去确定是否是奇数，是则累加。然后求平均。  代码就不给你写了。刚开始写代码 还是要自己写的。", "referer": "user-0"}]}
{"question": "该程序中，在第一个for语句里i=101，但在第二个for语句里从i=3开始循环,这是为什么？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你也没有说这个程序是干什么用的", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "找本C语言教程，看看for循环语法吧。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "第一个for是为了实现1+5+9+...101   A 第二个for是为了实现3+7+11...99     B A-B = 1+2+2+2...2(25个2)=1+2*25=51", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "for循环语句的语法格式：  for(表达式1;表达式2;表达式3) { 循环体 }  for循环的执行顺序： （1）执行for后表达式1； （2）执行表达式2，若表达式2的值为真（或非0），则执行for内循环体，然后执行（3）；否则，则循环结束，执行（5） （3）执行表达式3 （4）返回继续执行（2） （5）循环结束，执行for语句的循环体下面的语句", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "for(i=3;……", "referer": "user-0"}]}
{"question": "c语言写算术平均滤波法疑问，GetAD()和Delay()函数怎么写？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <windows.h> #define N 4000 unsigned char data[N]; unsigned char get_ad(int init) {     static unsigned int j=0;     unsigned char d;     if (init) j=0;     d=data[j];     j++;     if (j>=N) j=0;     return d; } void delay() { //  Sleep(15); } char filter() {     unsigned int sum = 0;     unsigned int i;      get_ad(1);     for (i=0;i<N;i++)   {         sum += get_ad(0);         delay();     }     return(char)(sum/N); } int main() {     unsigned int i;     char c;      for (i=0;i<N;i++) data[i]=(unsigned char)(i%256);     c=filter();     printf(\"%d\\n\",c);//125      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <windows.h> #define N 4000 unsigned char data[N]; unsigned char get_ad() {     static unsigned int j=0;     return data[j++]; } void delay() { //  Sleep(15); } char filter() {     unsigned int sum = 0;     unsigned int i;      for (i=0;i<N;i++)   {         sum += get_ad();         delay();     }     return(char)(sum/N); } int main() {     unsigned int i;     char c;      for (i=0;i<N;i++) data[i]=(unsigned char)(i%256);     c=filter();     printf(\"%d\\n\",c);//125      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include <stdio.h> #include <windows.h> #define N 12 unsigned int data[N]; unsigned int get_ad() {     static unsigned char j=0;     return data[j++]; } void delay() {     Sleep(50); } char filter() {     unsigned int sum = 0;     unsigned char i;      for (i=0;i<N;i++)   {         sum += get_ad();         delay();     }     return(char)(sum/N); } int main() {     unsigned char i;     char c;      for (i=0;i<N;i++) data[i]=i;     c=filter();     printf(\"%d\\n\",c);//5      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 顾染尘 的回复:补充一下  获取的是dat文件的波形图/** 对波形图进行滤波处理 fileSrcName：是一个.dat文件 */ int SrcLPFName(char* fileSrcName) { \tFILE* fileSrc=NULL; \tFILE* fileSrcLPF=NULL;    \tchar fileSrcLPFName[_MAX_PATH] = {0}; \tsprintf(fileSrcLPFName,\"%s_LPF_1_.dat\",fileSrcName);   \tfileSrc = fopen(fileSrcName,\"r+b\");  //打开原文件 \tfileSrcLPF = fopen(fileSrcLPFName,\"a+b\");  //打开原文件  滤波后文件  \tif(fileSrc==NULL || fileSrcLPF==NULL) \t{ \t\tif(!fileSrc) fclose(fileSrc); \t\tif(!fileSrcLPF) fclose(fileSrcLPF); \t\tprintf(\"open file error!!\\n\"); \t\treturn FILE_ERROR; \t} \tunsigned char i_data[4000] = {0};\t \tunsigned char l_data[4000] = {0}; \tint readNum = 0; \tint cnt = 0;  \twhile(!feof(fileSrc))//((d = fgetc(fileSrc)) != EOF)   \t{//liuchang  feof 判断文件是否为空 \t\tmemset(i_data,0,sizeof(unsigned char)*4000); \t\tmemset(l_data,0,sizeof(unsigned char)*4000); \t\t//这里应该是滤波器的调用 \t} \tfclose(fileSrc); \tfclose(fileSrcLPF); \tprintf(\"LPF文件生成\\n\"); }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "补充一下  获取的是dat文件的波形图", "referer": "user-0"}]}
{"question": "正在考试中，求大佬江湖救急！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你作弊，分数会为0！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "最后一句漏了：scanf(\"%d\",&flag);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "考试还可以上网供参考：for(i=0;i<5;i++)  scanf(\"%s\",temp);  if(strcmp(temp,add[i])==0))//输入的省份地区与已经录入的数据进行比对，找到if条件成立  demand(risk(num[i]));//risk()函数为查询风险等级数据，demand()函数根据risk()函数返回的风险等级，输出打印查询的该省份的返乡条件", "referer": "user-0"}]}
{"question": "我写了一段代码想打开文本并把不同的信息解析到对应的字符串里，但是运行出来的结果不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen(\"data.txt\",\"r\");     if (NULL==f) {         printf(\"Can not open file data.txt!\\n\");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,\"NAME: %31[^\\n]\",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,\"DIMENSION: %d\",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,\"DATA\\n\")) st=3;         } else if (st==3) {             if (3==sscanf(ln,\"%d%d%d\",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf(\"s.NAME=[%s]\\n\",s.NAME);     printf(\"s.DIMENSION=%d\\n\",s.DIMENSION);     for (i=0;i<n;i++) {         printf(\"s.DATA[%d].NO,X,Y=%d,%d,%d\\n\",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主其实挺有想法的，他想把刚输入的数据组织成结构体，奈何机器不理解。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "乱码。是编码问题么？", "referer": "user-0"}]}
{"question": "程序报错求解！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 qq_51563431 的回复:？  引用 3 楼 user-2 的回复:交换？那么你需要三个strcpy  strncpy(char * dest,const char * src,int size); 建议你看下这个函数  c语言的 字符串操作 不支持 operate = 的", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "？  引用 3 楼 user-2 的回复:交换？那么你需要三个strcpy", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "交换？那么你需要三个strcpy", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2 的回复:数组不能赋值 你要复制字符串需要strcpy 不是复制 是交换", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "数组不能赋值 你要复制字符串需要strcpy", "referer": "user-0"}]}
{"question": "复合字面量有没有通俗的理解？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "如下这段代码，是否就是一段无名无姓的复合字面量，生成以后只有天知道它在哪里，就像扔进大海的漂流瓶。是这么回事吧？  int main() {         (int[2][2]) {                 {10, 20},                 {30, 40}         };         return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "简单的理解就是，临时的匿名对象 struct A {     int a; }; int main(int argc, const char * argv[]) {     A a = {5};//该匿名对象的内存格式和左边的数据类型一致     A b = (struct A){5};//这个和上面是等效的     printf(\"%d\\n\", a.a);     printf(\"%d\\n\", b.a);     //printf(\"%p\\n\", &((struct A){5}));//这里会提示(struct A){5}是个临时对象          int c = 6; //这个是普通字面量（这个是常量）     int d = (int){6};//这个是复合字面量，这个和上面的普通字面量等效（也就是效果一样，所以单个int一样可以用，只是复合字面量是个临时的对象而已）     printf(\"%d\\n\", c);     printf(\"%d\\n\", d); }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "C标准里面 除了VLA以外的任何完整对象类型都可以做复合字面量  int完全符合要求", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 6 楼 qq_16774199 的回复:[quote=引用 4 楼 lin5161678 的回复:]复合字面量 不只是数组  结构体也行 单个int也行 创建一个无名对象 这个理解没问题 限定数组是多余的想法  单个int大概不能叫复合，单个与复合是反义词。[/quote] 这是C语言术语 不是语文的阅读理解 就算是语文的阅读理解 你的做法也是属于望文生义好吗 单个int不行? 为什么不行  你看过标准规定吗 你自己实际写代码测试过吗 什么都不做 张口就不行? 口语编程 还是脑补编程?", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "结构体，联合体，数组（不同类型的数组）", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "#2的代码只有VC++能编译通过，而且必须作为C代码编译。C++Builder、GCC、intel C++都编译不了。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "VS2019 能编译啊。。。。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "引用 5 楼 qq_16774199 的回复:[quote=引用 2 楼 UIUI 的回复:]根据你的题目，我 发现一个好神奇的。 int main()  {    (int [3]) { 7,8,9 };   printf(\"%d\\t\", *$S1);   printf(\"%d\\t\", *$S1+1);   printf(\"%d\\t\", *$S1+2);         return 0; } ///// 7 8 9 //// 怎么有这么奇怪的东西？ 你们试试TC能不能编译。。 是不是只能VS能编译。  你这些$S1是什么东西？还没等到编译，Clion IDE就红字报错了。[/quote]编译器扩展 俗称方言 无关紧要的东西 不用管", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 4 楼 lin5161678 的回复:复合字面量 不只是数组  结构体也行 单个int也行 创建一个无名对象 这个理解没问题 限定数组是多余的想法  单个int大概不能叫复合，单个与复合是反义词。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 2 楼 UIUI 的回复:根据你的题目，我 发现一个好神奇的。 int main()  {    (int [3]) { 7,8,9 };   printf(\"%d\\t\", *$S1);   printf(\"%d\\t\", *$S1+1);   printf(\"%d\\t\", *$S1+2);         return 0; } ///// 7 8 9 //// 怎么有这么奇怪的东西？ 你们试试TC能不能编译。。 是不是只能VS能编译。  你这些$S1是什么东西？还没等到编译，Clion IDE就红字报错了。", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "复合字面量 不只是数组  结构体也行 单个int也行 创建一个无名对象 这个理解没问题 限定数组是多余的想法", "referer": "user-0"}, {"cid": "12", "user": "user-6", "content": "不一定是数组，也可以是结构体，甚至结构体数组。", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "根据你的题目，我 发现一个好神奇的。 int main()  {    (int [3]) { 7,8,9 };   printf(\"%d\\t\", *$S1);   printf(\"%d\\t\", *$S1+1);   printf(\"%d\\t\", *$S1+2);         return 0; } ///// 7 8 9 //// 怎么有这么奇怪的东西？ 你们试试TC能不能编译。。 是不是只能VS能编译。", "referer": "user-0"}, {"cid": "14", "user": "user-2", "content": "引用 13 楼 qybao 的回复:简单的理解就是，临时的匿名对象 struct A {     int a; }; int main(int argc, const char * argv[]) {     A a = {5};//该匿名对象的内存格式和左边的数据类型一致     A b = (struct A){5};//这个和上面是等效的     printf(\"%d\\n\", a.a);     printf(\"%d\\n\", b.a);     //printf(\"%p\\n\", &((struct A){5}));//这里会提示(struct A){5}是个临时对象          int c = 6; //这个是普通字面量（这个是常量）     int d = (int){6};//这个是复合字面量，这个和上面的普通字面量等效（也就是效果一样，所以单个int一样可以用，只是复合字面量是个临时的对象而已）     printf(\"%d\\n\", c);     printf(\"%d\\n\", d); }不是临时的  你们总能添加一些错误的东西上去 就是匿名对象 没了 就这么多 不是临时的 也不限定是数组  没有其他乱七八糟的前缀  简简单单 匿名对象 可以吗", "referer": "user-0"}]}
{"question": "有序数列插入一个数 查错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先输入完，然后双重循环冒泡排序", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include <stdio.h>  #define N 51  int main() {                        //int N;     int num[N];     int a;     int i,m,n,t;                                //int * ptr_n = &n;     scanf(\"%d\",&n);     if(n<0 || n>50)n=50;      for(i = 0; i < n; i++)     {         scanf(\"%d\",&num[i]);     }     scanf(\"%d\",&a);                               //*ptr_n = n + 1;     for(i = 0; i < n ; i++)     {         if(a < num[i])        //&& a < num[i + 1])         {             m = i ;          //m = i+1;             break;         }     }     if(i==n)m=n;     for(i = (n + 1); i > m; i--)     {         t = num[i];         num[i] = num[i - 1];         num[i - 1] = t;     }     num[m] = a;     for(i = 0; i < (n + 1); i ++)     {         printf(\"%4d\",num[i]);//printf(\"%d\\t\",*(ptr_n + i));     }     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "编译器告诉你的问题，照着改了先。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 3 楼 qzjhjxj 的回复:供参考：#include <stdio.h>  #define N 51  int main() {                        //int N;     int num[N];     int a;     int i,m,n,t;                                //int * ptr_n = &n;     scanf(\"%d\",&n);     if(n<0 || n>50)n=50;      for(i = 0; i < n; i++)     {         scanf(\"%d\",&num[i]);     }     scanf(\"%d\",&a);                               //*ptr_n = n + 1;     for(i = 0; i < n ; i++)     {         if(a < num[i])        //&& a < num[i + 1])         {             m = i ;          //m = i+1;             break;         }     }     if(i==n)m=n;     for(i = (n + 1); i > m; i--)     {         t = num[i];         num[i] = num[i - 1];         num[i - 1] = t;     }     num[m] = a;     for(i = 0; i < (n + 1); i ++)     {         printf(\"%4d\",num[i]);//printf(\"%d\\t\",*(ptr_n + i));     }     system(\"pause\");     return 0; }  你的代码有点问题，缺少一个case吧，即最后输入的都比前面的大的时候，会有问题，似乎没测试吧  在移动位置的时候下表为n的位置还没填充数据吧，   #include <stdio.h>  #define N 6  int main() {     //int N;     int num[N];     int a;     int i,m,n,t;     //int * ptr_n = &n;     scanf(\"%d\",&n);     if(n<0 || n>= N)         n = N-1;      for(i = 0; i < n; i++)     {         scanf(\"%d\",&num[i]);     }     scanf(\"%d\",&a);     //*ptr_n = n + 1;     for(i = 0; i < n ; i++)     {         if(a < num[i])        //&& a < num[i + 1])         {             m = i ;          //m = i+1;             break;         }     }     if(i==n)         m=n;      //for(i = (n + 1); i > m; i--)     for(i = n; i > m; i--)     {         t = num[i];         num[i] = num[i - 1];         num[i - 1] = t;     }     num[m] = a;     for(i = 0; i < (n + 1); i ++)     {         printf(\"%4d\",num[i]);//printf(\"%d\\t\",*(ptr_n + i));     }     //system(\"pause\");     return 0; }  供参考～", "referer": "user-0"}]}
{"question": "统计一行文本的单词个数     到底哪错了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h>int main(){    int i,count=0;    char str[100000];    i=0;    while((str[i]=getchar())!='\\n')    {        i++;    }    str[i]='\\0';    for (i = 0; str[i]!='\\0'; i++)    {        if(str[i]==' ')        {            count==0;        }         if (str[i]==' '&& str[i + 1]!=' ')        {            count++;        }    }    if(str[0]!=' ')        count++;    if(str[i]=='\\0'&&str[i-1]==' ')        count--; printf(\"%d\",count);  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2 的回复:按照题目的意图，Let's 是1个单词； 209. 是1个单词。 是我想复杂了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "按照题目的意图，Let's 是1个单词； 209. 是1个单词。", "referer": "user-0"}]}
{"question": "回文数（题目没给结束循环的标志，在PTA运行超时，怎么办？？？）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//加个const变量呗 const int MAXNum = 10;  //一个数据最多多长 const int MAXNo = 3;\t//最多多少个数据  char* huiwen(int m) { \tchar a[MAXNum] = {0};\t \tint j;\t \tchar n; \titoa(m,a,10); \tfor(j = 1; a[j] != 0; j++) \t{ \t}  \tfor(int i = 0; i < j/2; i++) \t{ \t\tn = a[i]; \t\ta[i] = a[j-1]; \t\ta[j-1] = n; \t} \treturn a; } int _tmain(int argc, _TCHAR* argv[]) { \tint i[MAXNo] = {0}; \tprintf(\"请输入回文：\\n\"); \tfor(int j = 0; j < MAXNo; j++) \t{ \t\tscanf(\"%d\",&i[j]); \t} \tprintf(\"输出：\\n\"); \tfor(int j = 0; j < MAXNo; j++) \t{ \t\tchar c_r[MAXNum]; \t\tstrcpy(c_r,huiwen(i[j])); \t\tatoi(c_r); \t\tif(i[j] == atoi(c_r)) \t\t{ \t\t\tprintf(\"YES\\n\"); \t\t} \t\telse \t\t{ \t\t\tprintf(\"NO\\n\"); \t\t} \t} \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1位数算不算回文数？ 两位一样的两位数算不算回文数？ 输入最长多少位？ 有0开头吗？ ……", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "用ctrl + z 结束输入，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     char str[100][20];     char *p,*q;     int  flag,i=0,cnt;     while((cnt=scanf(\"%s\",str[i]))!=EOF)i++;// Ctrl+z 结束输入     for(int j=0;j<i;j++){        flag = 1;        p=str[j];        q=str[j];        while(*q != '\\0')             q++;        q--;        while(p<q){             if((*p != *q))               {                 flag = 0;                 break;               }             p++;             q--;        }        if(flag == 1)           printf(\"Yes\\n\");        else           printf(\"No\\n\");     }      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "有没有哪位大佬给下代码", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 6 楼 是疗伤烧肉粽~ 的回复：[quote=引用 5 楼 Chivas_/Regal的回复:]C语言可用while(~scanf(\"%d\",&a))进行输入，C++可使用while(cin>>a)然后在while循环内进行对输入数的分析即可 那样就是无限循环了[/quote]ctrl+z依然是结束标志。这个是跟eof一样的效果", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 5 楼 Chivas_/Regal的回复:C语言可用while(~scanf(\"%d\",&a))进行输入，C++可使用while(cin>>a)然后在while循环内进行对输入数的分析即可 那样就是无限循环了", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "C语言可用while(~scanf(\"%d\",&a))进行输入，C++可使用while(cin>>a)然后在while循环内进行对输入数的分析即可", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "OJ的惯例是由文件提供测试输入，因此文件结束就是输入结束。 另外，输出行末尾缺少\\n就有可能不真的立即输出，也会导致超时。", "referer": "user-0"}]}
{"question": "float与double", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "double输出用%lf float用%f", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437 另外请打开float.h文件逐字阅读一遍", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "看看你的源代码", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "只能说你对“正确”这个词的理解与工程师们的理解有一定的区别。", "referer": "user-0"}]}
{"question": "Matlab 累加求和形式的函数，展开为各项相加的形式。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "实在找不到响应的板块，想用c实现了也行。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这里是C，迷路了么？？？", "referer": "user-0"}]}
{"question": "VS上有 __attribute__((unused)) 的替代方案吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 早打大打打核战争 的回复:这个应该用C++17的标准语法： [[maybe_unused]] sorry。。。看早了。。。已经结帖了。。。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这个应该用C++17的标准语法： [[maybe_unused]]", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "UNREFERENCED_PARAMETER(hPrevInstance);", "referer": "user-0"}]}
{"question": "请教大佬，题目：输入一个字母，如果是大写，转换成小写，并输出小写的ASCLL码值，反之，转换成大写，并输出ASCLL码值；若输出的字符并不是字母，则直接输出本身", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "大佬？你把变量ch用单引号圈起来判断是啥操作？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "仅供参考： #include <stdio.h>  int main(void) {     int ch;     printf(\"输入一个字母\");     ch = getchar();     if (ch >= 'a' && ch <= 'z') ch -= 32;     else if (ch >= 'A' && ch <= 'Z') ch += 32;     printf(\"%c\\n\", ch);     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "'ch'这样的表达式，我相信编译器也会提示错误的，除非你的编译器检查不严。''中间只会有一个字符，大于1个字符，应该用\"\"。   #include <stdio.h> #include <ctype.h>  int main(int argc, char* argv[]) {         //char ch;         int ch;         printf(\"输入一个字母\");         ch = getchar();          if (islower(ch))              printf(\"%c,%d\\n\", ch-32,ch-32);         else if (isupper(ch))              printf(\"%c,%d\\n\", ch+32,ch+32);         else              printf(\"%c\\n\",ch);  #if 0         if('a' <= ch && ch <= 'z')           {              ch = ch - 32;              printf(\"%c,%d\\n\",ch,ch);         }         else         if('A' <= ch && ch <= ' Z')           {              ch = ch + 32;              printf(\"%c,%d\\n\",ch,ch);         }         else              printf(\"%c\\n\",ch); #endif         return 0; } 供参考～  ch建议定义为int类型～", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "代码太多了看不懂#include \"stdafx.h\" #include <stdio.h>   int main(int argc, char* argv[]) { \tprintf(\"输入一个字母\"); \tchar ch = getchar(); \tif(ch>='a'&&ch<='z') ch-=32; \telse if(ch>='A'&&ch<='Z') ch+=32; \tprintf(\"%c\\n\\n\",ch); \treturn 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "ch 不用加' ' 逻辑判断重复了，代码修改如下，供参考：#include <stdio.h>  int main(int argc, char* argv[]) {         char ch;         printf(\"输入一个字母\");         ch = getchar();         if('a' <= ch && ch <= 'z')           {              ch = ch - 32;              printf(\"%c,%d\\n\",ch,ch);         }         else         if('A' <= ch && ch <= ' Z')           {              ch = ch + 32;              printf(\"%c,%d\\n\",ch,ch);         }         else              printf(\"%c\\n\",ch);                  return 0; }", "referer": "user-0"}]}
{"question": "C语言有参函数调用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "跟函数传参的顺序有关，楼主的编译器参数入栈顺序是从右向左，因此a入栈时还没有调用alert函数，因此还没有被修改；  第二个程序，那是先调用后入栈，因此是改变之后的～  “调用者函数把被调函数所需要的参数按照与被调函数的形参顺序相反的顺序压入栈中,即:从右向左依次把被调函数所需要的参数压入栈”  注意下参数压栈（入栈）顺序～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:不是没改变，是调用printf的时候还没改变，C语言函数调用是从右往左入栈的，调用printf的时候先把a原来的值输出了，再调用的alter，你在printf之后再输出一次就变了 哦哦 我明白了 大意了 大意了 谢谢老铁", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不是没改变，是调用printf的时候还没改变，C语言函数调用是从右往左入栈的，调用printf的时候先把a原来的值输出了，再调用的alter，你在printf之后再输出一次就变了", "referer": "user-0"}]}
{"question": "请教如何将 0x00  0x0F  0xAE 0xF9     按如下图规则 转化成时间 ，c语言代码如何写？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> struct DATE {     unsigned int DayOfMonth  : 5;     unsigned int Month       : 4;     unsigned int Year        :12;     unsigned int Spares      :11; } *pD; struct TIME {     unsigned int Milliseconds:10;     unsigned int Seconds     : 6;     unsigned int Minutes     : 6;     unsigned int Hours       : 5;     unsigned int Spares      : 5; } *pT; unsigned char s[8]={0x00,0x0F,0xAE,0xF9,0x04,0x6D,0x00,0x00}; unsigned char d[8];  int main() {     for (int i=0;i<8;i++) d[i]=s[8-1-i];      pD=(struct DATE *)&d[4];     printf(\"%04u-%02u-%02u\\n\",         pD->Year        ,         pD->Month       ,         pD->DayOfMonth  );      pT=(struct TIME *)&d[0];     printf(\"%02u:%02u:%02u.%03u\\n\",         pT->Hours       ,         pT->Minutes     ,         pT->Seconds     ,         pT->Milliseconds);      return 0; } //2007-07-25 //17:45:00.000 //", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> struct DATE {     unsigned int DayOfMonth  : 5;//bit04～bit00     unsigned int Month       : 4;//bit08～bit05     unsigned int Year        :12;//bit20～bit09     unsigned int Spares      :11;//bit31～bit21 } *pD; struct TIME {     unsigned int Milliseconds:10;//bit09～bit00     unsigned int Seconds     : 6;//bit15～bit10     unsigned int Minutes     : 6;//bit21～bit16     unsigned int Hours       : 5;//bit26～bit22     unsigned int Spares      : 5;//bit31～bit27 } *pT; unsigned char s[8]={0x00,0x0F,0xAE,0xF9,0x04,0x6D,0x00,0x00}; // bbbbbbbb bbbbbbbb bbbbbbbb bbbbbbbb // iiiiiiii iiiiiiii iiiiiiii iiiiiiii // tttttttt tttttttt tttttttt tttttttt // 33222222 22221111 11111100 00000000 // 10987654 32109876 54321098 76543210 // :::::::: :::::::: :::::::: :::::::: // //             YYYYY YYYYYYYM MMMDDDDD // 00000000 00001111 10101110 11111001  0x00,0x0F,0xAE,0xF9 //                      2007    7   25 // //      hhh hhmmmmmm ssssssii iiiiiiii // 00000100 01101011 00000000 00000000  0x04,0x6D,0x00,0x00 //          17    45     00        000 unsigned char d[8]; int main() {     for (int i=0;i<4;i++) {         d[  i]=s[  4-1-i];         d[4+i]=s[4+4-1-i];     }      pD=(struct DATE *)&d[0];     printf(\"%04u-%02u-%02u\\n\",         pD->Year        ,         pD->Month       ,         pD->DayOfMonth  );      pT=(struct TIME *)&d[4];     printf(\"%02u:%02u:%02u.%03u\\n\",         pT->Hours       ,         pT->Minutes     ,         pT->Seconds     ,         pT->Milliseconds);     return 0; } //2007-07-25 //17:45:00.000 //", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "特别感谢  特别感谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include <stdio.h> #include <string.h>  struct date_info {     unsigned int day:5;     unsigned int month:4;     unsigned int year:12;     unsigned int reverse:11; };  int main(void) {     unsigned int hex = 0x000FAEF9;  #if 0     int day = hex & (0x00ffu >> 3);     int month = (hex >> 5) & (0x00ffu >> 4);     int year = (hex >> 9) & (0x00ffffff);      printf(\"%d.%d.%d\\n\", year, month, day); #else     struct date_info date;       memcpy(&date, &hex, sizeof(hex));     printf(\"%lu\\n\", sizeof(date));     printf(\"%u\\n\", date.reverse);     printf(\"%d.%d.%d\\n\", date.year, date.month, date.day);  #endif     return 0; }  供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h>   int main(void) {     unsigned int hex = 0x000FAEF9;      int day = hex & (0x00ffu >> 3);     int month = (hex >> 5) & (0x00ffu >> 4);     int year = (hex >> 9) & (0x00ffffff);      printf(\"%d.%d.%d\\n\", year, month, day);      return 0; } 供参考～", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "我自己找的办法。不知道各位 还有没有更好的计算办法  test1.cpp  #include <stdio.h>  #include <stdlib.h> #include <errno.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <string.h>  #include <sys/time.h> #include <math.h>  int main()  {      char a[17];     strcpy(a, \"011111010111\");        int len, i, sum = 0, m, j;      len = strlen(a);      if (len <= 16)      {          for (i = 0; i < len; i++)          {              m = 1;              if (a[i] == '1')              {                  for (j = 1; j <= len - i - 1; j++)                      m *= 2;                  sum += m;             }         }          printf(\"data=%d\\n\", sum);     }      return 0; }   data=2007", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "#include <stdio.h> typedef struct { \tunsigned day : 5; \tunsigned month : 4; \tunsigned year : 12; \tunsigned unuse : 11; }SDATE; typedef union { \tunsigned udate; \tSDATE sdate; }DATE; unsigned c2le(unsigned char *ch) { \tunsigned ur = 0; \tint i; \tfor (i = 0; i < 4; i++) \t{ \t\tur <<= 8; \t\tur += ch[i]; \t} \treturn ur; } int main() { \tDATE T; \tunsigned char Date[4] = {0x00,0x0f,0xae,0xf9}; \tT.udate = c2le(Date); \tprintf(\"%4u-%02u-%02u\\n\", T.sdate.year, T.sdate.month, T.sdate.day); \treturn 0; }  参考一哈。", "referer": "user-0"}]}
{"question": "数组名看起来像个指针，但它好像还包含了某种其它东西？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "使用C语言，灵魂是指针。 但学习C语言，核心是类型。 想学好C语言必须正确深刻地理解类型，对，就是变量和函数的类型。  你的array是什么类型，难道编译器不知道么？不，它肯定比你我更清楚，也更重视这一点。 有了正确的类型，那它能进行什么运算就水到渠成了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "int main() {         int array[2][3][3] = {                 {                         {1, 3, 4},                         {2, 8, 6},                         {5, 9, 0}                 },                 {                         { 10, 30, 40 },                         { 20, 80, 60 },                         { 50, 90, 0 }                 }         };         printf(\"array[0][0][0] = %d\\n\", array[0][0][0]);         printf(\"***array = %d\\n\", ***array);         printf(\"&array[0][0][0] = %p\\n\", &array[0][0][0]);         printf(\"&array = %p\\n\", &array); }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "建议楼主通读Tiny C Compiler源代码。  尽管我也没读过。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "语言 》编译器 》机器码 你说编译器作为中间的翻译者，它能不知道 语言 给它的是什么东西吗？ 语言第一步给 编译器 投入了一个硬币 然后第二步要 编译器 处理的是纸币 你说 编译器 知不知道第一步和第二步的两种币种不对？", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "真没有包含，是编译干的。", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "数组名是个地址，像个指针，这是语义。 array的类型是int[2][3][3]，这是语法。  语言么，语义和语法不可偏废，也不能互相替代。", "referer": "user-0"}]}
{"question": "输入几个数，利用指针来排序的这道例题【求助】", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 user-2 的回复：引用大佬，我想问问，就是\"\"PP=P\"和if(pp!=p)这两个是跟着第一个循环执行的吗？，执行了四次  但是不可能只执行四次啊，因为你要比较的话，我举个例子：输入5，4，3，2，1  第一层循环：p指针指向5 5要先和4比较，5比4大，所以5和4值互换，变成了 4，5，3，2，1（第一层循环还没结束）  第一层循环：p指针指向5 5要先和4比较，5比4大，所以5和4地址互换，这时候for(q=p+1;q<a+5;q++)这层循环都没结束，所以继续和后续的符合条件数字的地址互换，等for(q=p+1;q<a+5;q++)这层循环结束，pp指向的是数字1的地址,然后回到第一层的循环，即执行到第二个if(pp!=p)的判断，此时条件满足将把4和1的值进行互换，然后进入第一层循环的第二次循环。int main() {     int a[5],*p,*pp,*q,t;     int i=0,j=0,k=0;     printf(\"input numbers:\\n\");//假设a[5]首地址为0，则p=a;等同于p=0;     for(p=a;p<a+5;p++){        scanf(\"%d,\",p);     }      for(p=a;p<a+4;p++){      //p<a+4 防止数组下标越界。         i++;         pp=p;         for(q=p+1;q<a+5;q++){            j++;            if(*pp>*q)        //这个if属于for(q=p+1;q<a+5;q++)循环               pp=q;         }         k++;         if(pp!=p){          //这个if属于for(p=a;p<a+4;p++)循环            t=*p;            *p=*pp;            *pp=t;         }         printf(\"%d\\n\",*p);//这里加一句,可以看下每次内循环后，数组的数据。     }     {printf(\"\\n\");}     for(p=a;p<a+5;p++){         printf(\"%d\\t\",*p);     }      printf(\"\\n\\n③pp+p 语句被执行%d次\\n\\n③if(*pp>*q) 语句被执行%d次\\n\\n③if(pp!=p) 语句被执行%d次\\n\",i,j,k);     system(\"pause\");     return 0; }  卧槽，牛笔，懂了，谢谢大哥", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  int main() {     int a[5],*p,*pp,*q,t;      printf(\"input numbers:\\n\");     for(p=a;p<a+5;p++){         scanf(\"%d,\",p);     }      pp = a;     for (p = a; p < pp+5; p++) {         for (q = p+1; q < pp + 5; q++) {             if (*p > *q) {                 t = *p;                 *p = *q;                 *q = t;             }         }     }       /*     for(p=a;p<a+4;p++){         pp=p;         for(q=p+1;q<a+5;q++)             if(*pp>*q)                 pp=q;         if(pp!=p){             t=*p;             *p=*pp;             *pp=t;         }      }     */     //{printf(\"\\n\");}     for(p=a;p<a+5;p++){         printf(\"%d\\t\",*p);     }      return 0; } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用此时条件满足将把4和1的值进行互换，这句错误 ，修改如下：此时条件满足将把5和1的值进行互换，", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用大佬，我想问问，就是\"\"PP=P\"和if(pp!=p)这两个是跟着第一个循环执行的吗？，执行了四次  但是不可能只执行四次啊，因为你要比较的话，我举个例子：输入5，4，3，2，1  第一层循环：p指针指向5 5要先和4比较，5比4大，所以5和4值互换，变成了 4，5，3，2，1（第一层循环还没结束）  第一层循环：p指针指向5 5要先和4比较，5比4大，所以5和4地址互换，这时候for(q=p+1;q<a+5;q++)这层循环都没结束，所以继续和后续的符合条件数字的地址互换，等for(q=p+1;q<a+5;q++)这层循环结束，pp指向的是数字1的地址,然后回到第一层的循环，即执行到第二个if(pp!=p)的判断，此时条件满足将把4和1的值进行互换，然后进入第一层循环的第二次循环。int main() {     int a[5],*p,*pp,*q,t;     int i=0,j=0,k=0;     printf(\"input numbers:\\n\");//假设a[5]首地址为0，则p=a;等同于p=0;     for(p=a;p<a+5;p++){        scanf(\"%d,\",p);     }      for(p=a;p<a+4;p++){      //p<a+4 防止数组下标越界。         i++;         pp=p;         for(q=p+1;q<a+5;q++){            j++;            if(*pp>*q)        //这个if属于for(q=p+1;q<a+5;q++)循环               pp=q;         }         k++;         if(pp!=p){          //这个if属于for(p=a;p<a+4;p++)循环            t=*p;            *p=*pp;            *pp=t;         }         printf(\"%d\\n\",*p);//这里加一句,可以看下每次内循环后，数组的数据。     }     {printf(\"\\n\");}     for(p=a;p<a+5;p++){         printf(\"%d\\t\",*p);     }      printf(\"\\n\\n③pp+p 语句被执行%d次\\n\\n③if(*pp>*q) 语句被执行%d次\\n\\n③if(pp!=p) 语句被执行%d次\\n\",i,j,k);     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-2 的回复:供参考：int main() {     int a[5],*p,*pp,*q,t;     int i=0,j=0,k=0;     printf(\"input numbers:\\n\");//假设a[5]首地址为0，则p=a;等同于p=0;     for(p=a;p<a+5;p++){        scanf(\"%d,\",p);     }      for(p=a;p<a+4;p++){      //p<a+4 防止数组下标越界。         i++;         pp=p;         for(q=p+1;q<a+5;q++){            j++;            if(*pp>*q)        //这个if属于for(q=p+1;q<a+5;q++)循环               pp=q;         }         k++;         if(pp!=p){          //这个if属于for(p=a;p<a+4;p++)循环            t=*p;            *p=*pp;            *pp=t;         }     }     {printf(\"\\n\");}     for(p=a;p<a+5;p++){         printf(\"%d\\t\",*p);     }      printf(\"\\n\\n③pp+p 语句被执行%d次\\n\\n③if(*pp>*q) 语句被执行%d次\\n\\n③if(pp!=p) 语句被执行%d次\\n\",i,j,k);     system(\"pause\");     return 0; }   //①为什么第一个循环是for(p=a;p<a+4;p++)而不是for(p=a;p<a+5;p++)? //  为了防止下标越界，当p<a+4=3时，下一个for(q=p+1;q<a+5;q++)循环是 p+1=4，数组a[5]=a[0]....a[4].  //④我如果把两个if都放进第二个循环中，那这个程序是否还能正确输出？如果不能又是什么原因 //  肯定不能正确输出，可以自己调试输出看看。循环里要干的工作步骤各不相同，逻辑关系不同，混在一起就乱了。  //input numbers: //3 1 5 2 4  //1       2       3       4       5  //③pp+p 语句被执行4次  //③if(*pp>*q) 语句被执行10次  //③if(pp!=p) 语句被执行4次   大佬，我想问问，就是\"\"PP=P\"和if(pp!=p)这两个是跟着第一个循环执行的吗？，执行了四次  但是不可能只执行四次啊，因为你要比较的话，我举个例子：输入5，4，3，2，1  第一层循环：p指针指向5 5要先和4比较，5比4大，所以5和4值互换，变成了 4，5，3，2，1（第一层循环还没结束） 4再和3比较，所以4也要和3值互换，但是第二个if中的语句已经被使用过了，所以无法互换了呀  所以难道第二个if不是执行10次吗？应该讲第二个if放入第二层循环中才合理？这地方不太懂。。求大佬讲讲", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "供参考：int main() {     int a[5],*p,*pp,*q,t;     int i=0,j=0,k=0;     printf(\"input numbers:\\n\");//假设a[5]首地址为0，则p=a;等同于p=0;     for(p=a;p<a+5;p++){        scanf(\"%d,\",p);     }      for(p=a;p<a+4;p++){      //p<a+4 防止数组下标越界。         i++;         pp=p;         for(q=p+1;q<a+5;q++){            j++;            if(*pp>*q)        //这个if属于for(q=p+1;q<a+5;q++)循环               pp=q;         }         k++;         if(pp!=p){          //这个if属于for(p=a;p<a+4;p++)循环            t=*p;            *p=*pp;            *pp=t;         }     }     {printf(\"\\n\");}     for(p=a;p<a+5;p++){         printf(\"%d\\t\",*p);     }      printf(\"\\n\\n③pp+p 语句被执行%d次\\n\\n③if(*pp>*q) 语句被执行%d次\\n\\n③if(pp!=p) 语句被执行%d次\\n\",i,j,k);     system(\"pause\");     return 0; }   //①为什么第一个循环是for(p=a;p<a+4;p++)而不是for(p=a;p<a+5;p++)? //  为了防止下标越界，当p<a+4=3时，下一个for(q=p+1;q<a+5;q++)循环是 p+1=4，数组a[5]=a[0]....a[4].  //④我如果把两个if都放进第二个循环中，那这个程序是否还能正确输出？如果不能又是什么原因 //  肯定不能正确输出，可以自己调试输出看看。循环里要干的工作步骤各不相同，逻辑关系不同，混在一起就乱了。  //input numbers: //3 1 5 2 4  //1       2       3       4       5  //③pp+p 语句被执行4次  //③if(*pp>*q) 语句被执行10次  //③if(pp!=p) 语句被执行4次", "referer": "user-0"}]}
{"question": "break只能用于循环语句中？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "switch case中也会用到； break和continue是一样的，但是功能是相反的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "switch也可以", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "switch", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "switch选择结构也行", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "break除了用于循环语句 还有switch中的case 然后就没了", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "do.....while循环也可以用。", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "也可以用在switch语句中。", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "经典的switch是当然可以的", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "switch case中也会用到； break和continue是一样的，但是功能是相反的。", "referer": "user-0"}, {"cid": "10", "user": "user-10", "content": "switch 也行", "referer": "user-0"}, {"cid": "11", "user": "user-11", "content": "外加switch", "referer": "user-0"}, {"cid": "12", "user": "user-12", "content": "还可以switch ,case中啊", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "谢谢谢谢谢谢可以支持一下我的博客嘛", "referer": "user-0"}]}
{"question": "求助，ARM使用UDP，通过交换机后，可以ping通，但是接收不到数据。求指点，感谢感谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:ping是有去有回的，即ping request和reply；如果ping能通，那么通路是通的，同理UDP也应该是通的。感谢感谢，对，就是这样。问题已经解决了。首先我这里有4个交换机，其中三台都可以接收数据，最多关掉防火墙之后，也能收到数据。但是其中有一台交换机，是不行的。后来我改了ARM中的代码，ARM中如果数据发送OK，就继续发；数据发送失败就关闭socket。所以就出现了上面的问题，可以ping通，但是没有数据。只有这一台交换机是这样，别的都不用改程序就可以通信。最后感谢感谢！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:换个端口再试试？感谢感谢，换了没有用，是程序悄悄关闭了socket。问题已经解决了。首先我这里有4个交换机，其中三台都可以接收数据，最多关掉防火墙之后，也能收到数据。但是其中有一台交换机，是不行的。后来我改了ARM中的代码，ARM中如果数据发送OK，就继续发；数据发送失败就关闭socket。所以就出现了上面的问题，可以ping通，但是没有数据。只有这一台交换机是这样，别的都不用改程序就可以通信。最后感谢感谢！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 forever74 的回复:问题在于他没有交代他有没有完整的协议栈，还是自己用代码写成的UDP头。 底下有没有ARP都是个问题。 ping不同，它不那么依赖ARP，设备对于icmp都相当亲切和蔼，所以还真不说明问题。感谢感谢，确实不确定性太大。问题已经解决了。首先我这里有4个交换机，其中三台都可以接收数据，最多关掉防火墙之后，也能收到数据。但是其中有一台交换机，是不行的。后来我改了ARM中的代码，ARM中如果数据发送OK，就继续发；数据发送失败就关闭socket。所以就出现了上面的问题，可以ping通，但是没有数据。只有这一台交换机是这样，别的都不用改程序就可以通信。最后感谢感谢！", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "问题在于他没有交代他有没有完整的协议栈，还是自己用代码写成的UDP头。 底下有没有ARP都是个问题。 ping不同，它不那么依赖ARP，设备对于icmp都相当亲切和蔼，所以还真不说明问题。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "接收不到数据，你怎么知道ping通？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "ping是有去有回的，即ping request和reply；如果ping能通，那么通路是通的，同理UDP也应该是通的。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "换个端口再试试？", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "已知条件不足，可能性太多。", "referer": "user-0"}]}
{"question": "Silk语言 - 中国自己的开源编程语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 ctrigger的回复:个人感觉：Silk语法貌似是C与Python的混血，看上去眼熟，很亲切啊。 对的！就是像Python一样的动态语言，但是用了C的语法，C程序员很容易接受，安装包里很多例子都是C转过来的，欢迎下载使用。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "个人感觉：Silk语法貌似是C与Python的混血，看上去眼熟，很亲切啊。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "楼主应该联系CSDN管理员，专门新建一个Silk版块，推广推广，或许有意想不到的收获。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。  做个可能不太恰当的比喻： 人想让狗帮忙逮只兔子，可是人说话狗听不懂，于是人发明了一种介乎人言和狗语之间的语言，即口令。 人想让电脑帮忙做计算，可是人话电脑听不懂，于是人发明了一种介乎人言和汇编机器码之间的语言，即C语言。 人对狗的口令得让人容易学、也得让狗容易懂。 C语言同样得让人容易学、也得让电脑容易懂。 相比之下C++、Java就是人学得费劲、电脑也经常闹不懂。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "关注一下有空看看", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "高级语言的进步主要就是语法糖了，基础架构早在六七十年代就做完了", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 3 楼 qq_31972627的回复:[quote=引用 2 楼 赵4老师的回复:]语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。  做个可能不太恰当的比喻： 人想让狗帮忙逮只兔子，可是人说话狗听不懂，于是人发明了一种介乎人言和狗语之间的语言，即口令。 人想让电脑帮忙做计算，可是人话电脑听不懂，于是人发明了一种介乎人言和汇编机器码之间的语言，即C语言。 人对狗的口令得让人容易学、也得让狗容易懂。 C语言同样得让人容易学、也得让电脑容易懂。 相比之下C++、Java就是人学得费劲、电脑也经常闹不懂。 谢谢回复！也许正如你说的，有了这么多语言，再开发一门新语言是浪费时间，就算是个人爱好吧，用自己开发的语言写程序的感觉是旁人无法体会的，哈哈。[/quote] 期待你创造出编译调试差错真香无敌的新编程语言！", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。  做个可能不太恰当的比喻： 人想让狗帮忙逮只兔子，可是人说话狗听不懂，于是人发明了一种介乎人言和狗语之间的语言，即口令。 人想让电脑帮忙做计算，可是人话电脑听不懂，于是人发明了一种介乎人言和汇编机器码之间的语言，即C语言。 人对狗的口令得让人容易学、也得让狗容易懂。 C语言同样得让人容易学、也得让电脑容易懂。 相比之下C++、Java就是人学得费劲、电脑也经常闹不懂。 谢谢回复！也许正如你说的，有了这么多语言，再开发一门新语言是浪费时间，就算是个人爱好吧，用自己开发的语言写程序的感觉是旁人无法体会的，哈哈。", "referer": "user-0"}]}
{"question": "【C语言】实现杨辉三角", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #define MAXN 10 unsigned __int64 y[MAXN][MAXN]; int i,j; char s[60]; void main() {     printf(\"%30s\\n\",\"1  \");     printf(\"%33s\\n\",\"1     1  \");     y[1][0]=1ui64;y[1][1]=1ui64;     for (i=2;i<MAXN;i++) {         y[i][0]=1ui64;sprintf(s,\"1  \");         for (j=1;j<=i-1;j++) {             y[i][j]=y[i-1][j-1]+y[i-1][j];             sprintf(s,\"%s   %-3I64u\",s,y[i][j]);         }         y[i][i]=1ui64;sprintf(s,\"%s   1  \",s);         printf(\"%*s\\n\",30+i*3,s);     } } //                           1 //                        1     1 //                     1     2     1 //                  1     3     3     1 //               1     4     6     4     1 //            1     5     10    10    5     1 //         1     6     15    20    15    6     1 //      1     7     21    35    35    21    7     1 //   1     8     28    56    70    56    28    8     1 //1     9     36    84    126   126   84    36    9     1  //按如下格式打印杨辉三角形的前MAXN行。 //  1 //  1 1 //  1 2 1 //  1 3 3 1 //  1 4 6 4 1 //  1 5 10 10 5 1 #include <stdio.h> #define MAXN 68 unsigned __int64 y[MAXN][MAXN]; int i,j; void main() {     printf(\"1\\n\");     printf(\"1 1\\n\");     y[1][0]=1ui64;y[1][1]=1ui64;     for (i=2;i<MAXN;i++) {         y[i][0]=1ui64;printf(\"1 \");         for (j=1;j<=i-1;j++) {             y[i][j]=y[i-1][j-1]+y[i-1][j];             printf(\"%I64u \",y[i][j]);         }         y[i][i]=1ui64;printf(\"1\\n\");     } } //1 //1 1 //1 2 1 //1 3 3 1 //1 4 6 4 1 //1 5 10 10 5 1 //1 6 15 20 15 6 1 //1 7 21 35 35 21 7 1 //1 8 28 56 70 56 28 8 1 //1 9 36 84 126 126 84 36 9 1 //... //1 67 2211 47905 766480 9657648 99795696 869648208 6522361560 42757703560 247994680648 1285063345176 5996962277488 25371763481680 97862516286480 345780890878896 1123787895356412 3371363686069236 9364899127970100 24151581961607100 57963796707857040 129728497393775280 271250494550621040 530707489338171600 972963730453314600 1673497616379701112 2703342303382594104 4105075349580976232 5864393356544251760 7886597962249166160 9989690752182277136 11923179284862717872 13413576695470557606 14226520737620288370 14226520737620288370 13413576695470557606 11923179284862717872 9989690752182277136 7886597962249166160 5864393356544251760 4105075349580976232 2703342303382594104 1673497616379701112 972963730453314600 530707489338171600 271250494550621040 129728497393775280 57963796707857040 24151581961607100 9364899127970100 3371363686069236 1123787895356412 345780890878896 97862516286480 25371763481680 5996962277488 1285063345176 247994680648 42757703560 6522361560 869648208 99795696 9657648 766480 47905 2211 67 1", "referer": "user-0"}]}
{"question": " 查找指定字符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 27 楼 maggielve 的回复:[quote=引用 26 楼 xiaoyin35的回复:][quote=引用 25 楼 maggielve 的回复:][quote=引用 22 楼 xiaoyin35的回复:][quote=引用 21 楼 xiaoyin35 的回复:]听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？ 简单!上代码！  #include <iostream> using namespace std; int main() {     char c, a[110];     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < strlen(a); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }   我要来狠的就直接上string多痛快(STL string)   #include <iostream> using namespace std; int main() {     char c;     string a;     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < a.length(); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }  这爽！作者，你看，哪个测试点没过来叫我！[/quote] 你用c++写的吗？我学的是c,而且没学位运算符[/quote]  string才是C++ STL里的，我是C++er，略会一点C。[/quote] 我是C  er,c++有的地方看不懂[/quote] 多学学，C++对学C、Java都有好处", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 22 楼 xiaoyin35的回复:[quote=引用 21 楼 xiaoyin35 的回复:]听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？ 简单!上代码！  #include <iostream> using namespace std; int main() {     char c, a[110];     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < strlen(a); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }   我要来狠的就直接上string多痛快(STL string)   #include <iostream> using namespace std; int main() {     char c;     string a;     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < a.length(); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }  这爽！作者，你看，哪个测试点没过来叫我！[/quote] 你用c++写的吗？我学的是c,而且没学位运算符", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 26 楼 xiaoyin35的回复:[quote=引用 25 楼 maggielve 的回复:][quote=引用 22 楼 xiaoyin35的回复:][quote=引用 21 楼 xiaoyin35 的回复:]听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？ 简单!上代码！  #include <iostream> using namespace std; int main() {     char c, a[110];     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < strlen(a); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }   我要来狠的就直接上string多痛快(STL string)   #include <iostream> using namespace std; int main() {     char c;     string a;     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < a.length(); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }  这爽！作者，你看，哪个测试点没过来叫我！[/quote] 你用c++写的吗？我学的是c,而且没学位运算符[/quote]  string才是C++ STL里的，我是C++er，略会一点C。[/quote] 我是C  er,c++有的地方看不懂", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 25 楼 maggielve 的回复:[quote=引用 22 楼 xiaoyin35的回复:][quote=引用 21 楼 xiaoyin35 的回复:]听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？ 简单!上代码！  #include <iostream> using namespace std; int main() {     char c, a[110];     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < strlen(a); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }   我要来狠的就直接上string多痛快(STL string)   #include <iostream> using namespace std; int main() {     char c;     string a;     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < a.length(); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }  这爽！作者，你看，哪个测试点没过来叫我！[/quote] 你用c++写的吗？我学的是c,而且没学位运算符[/quote]  string才是C++ STL里的，我是C++er，略会一点C。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 23 楼 maggielve 的回复:[quote=引用 21 楼 xiaoyin35的回复:]听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？ 刚学c语言没多久，抱歉哈，没听过[/quote]  去网上搜搜", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 21 楼 xiaoyin35的回复:听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？ 刚学c语言没多久，抱歉哈，没听过", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用 21 楼 xiaoyin35 的回复:听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？ 简单!上代码！  #include <iostream> using namespace std; int main() {     char c, a[110];     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < strlen(a); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }   我要来狠的就直接上string多痛快(STL string)   #include <iostream> using namespace std; int main() {     char c;     string a;     bool flag = 1; //找没找到？没找到     cin >> c;//这才是cin的正道     getline(cin, a); //怕空格？iostream用getline！     for (int i = 0; i < a.length(); i++)     {         if (a[i] == c)         {             flag = 0; //找到啦             cout << \"index = \" << i << endl; //现在就输出不好？         }     }     if (flag) //都扫完了还没找到？     {          cout << \"Not Found\" << endl; //对不住了小兄弟     }     return 0; }  这爽！作者，你看，哪个测试点没过来叫我！", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "听起来很难啊~我个蒻菊都看出来了？是不是有啥限制？比如必须用scanf,printf,gets,puts这种？ 没听说过iostream吗？", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "等等！让我多看看", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 19 楼 尚乐大哥的回复:对于这个问题，在公众号上面做了详细讲解，可以参考一下，文章点这里 多谢，这又是哪位大哥专门做了篇文章？多谢了", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "对于这个问题，在公众号上面做了详细讲解，可以参考一下，文章点这里", "referer": "user-0"}, {"cid": "12", "user": "user-4", "content": "To read strings not delimited by space characters, a set of characters in brackets ([ ]) can be substituted for the s (string) type character. The corresponding input field is read up to the first character that does not appear in the bracketed character set. If the first character in the set is a caret (^), the effect is reversed: The input field is read up to the first character that does appear in the rest of the character set.  Note that %[a-z] and %[z-a] are interpreted as equivalent to %[abcde...z]. This is a common scanf function extension, but note that the ANSI standard does not require it.  附上文对应的百度自动翻译结果： 要读取不由空格字符分隔的字符串，可以用括号（[]）中的一组字符替换s（字符串）类型的字符。相应的输入字段被读取到括号内字符集中没有出现的第一个字符。如果集合中的第一个字符是插入符号（^），则效果相反：输入字段将被读取到字符集中其他字符中出现的第一个字符。 注意，%[a-z]和%[z-a]被解释为等同于%[abcde…z]。这是一个常见的scanf函数扩展，但请注意，ANSI标准不需要它。", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "修改如下：#include \"stdio.h\" #include \"string.h\"  int main() { \tchar s[2],c,a[81]; \tint flag = -1,i; \tscanf(\"%[^\\n]\",s);  //scanf(\"%c\\n\",&c);     c=s[0];     getchar();          //gets(a);     scanf(\"%[^\\n]\",a);  //scanf(\"%s\",a);//scanf(\"%s\",&a);为啥换成%s就错了呢？错了一个测试点 \tfor( i = 0 ; i<strlen(a) ; i++ )               if(c == a[i])flag = i; \tif(flag == -1) \t\tprintf(\"Not Found\"); \telse \t\tprintf(\"index = %d\",flag);  \treturn 0; }", "referer": "user-0"}, {"cid": "14", "user": "user-6", "content": "然后见空格就停的%s就不适用了。", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 7 楼 forever74的回复:题目说的非空字符串，可没说字符串内不含空格啊。 然后呢？？？", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "引用 13 楼 maggielve 的回复:[quote=引用 10 楼 qzjhjxj的回复:]修改如下：#include \"stdio.h\" #include \"string.h\"  int main() { \tchar s[2],c,a[81]; \tint flag = -1,i; \tscanf(\"%[^\\n]\",s);  //scanf(\"%c\\n\",&c);     c=s[0];     getchar();          //gets(a);     scanf(\"%[^\\n]\",a);  //scanf(\"%s\",a);//scanf(\"%s\",&a);为啥换成%s就错了呢？错了一个测试点 \tfor( i = 0 ; i<strlen(a) ; i++ )               if(c == a[i])flag = i; \tif(flag == -1) \t\tprintf(\"Not Found\"); \telse \t\tprintf(\"index = %d\",flag);  \treturn 0; } 高端操作，[^\\n]，这个我还没学呢[/quote]  加油", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "引用 10 楼 qzjhjxj的回复:修改如下：#include \"stdio.h\" #include \"string.h\"  int main() { \tchar s[2],c,a[81]; \tint flag = -1,i; \tscanf(\"%[^\\n]\",s);  //scanf(\"%c\\n\",&c);     c=s[0];     getchar();          //gets(a);     scanf(\"%[^\\n]\",a);  //scanf(\"%s\",a);//scanf(\"%s\",&a);为啥换成%s就错了呢？错了一个测试点 \tfor( i = 0 ; i<strlen(a) ; i++ )               if(c == a[i])flag = i; \tif(flag == -1) \t\tprintf(\"Not Found\"); \telse \t\tprintf(\"index = %d\",flag);  \treturn 0; } 高端操作，[^\\n]，这个我还没学呢", "referer": "user-0"}, {"cid": "18", "user": "user-6", "content": "另外，题目说要找最大下标，所以建议逆向循环，一旦找到就立刻break，极端情况下貌似能提高效率一点点。", "referer": "user-0"}, {"cid": "19", "user": "user-4", "content": "#include <stdio.h> int main() {     char s[2],c,a[81];     int flag,i;     scanf(\"%1[^\\n]\",s);  //scanf(\"%c\\n\",&c);     c=s[0];     rewind(stdin);     scanf(\"%80[^\\n]\",a);     flag=-1;     i=0;     while (1) {         if (0==a[i]) break;         if (c==a[i]) flag = i;         i++;     }     if (-1==flag)         printf(\"Not Found\\n\");     else         printf(\"index = %d\\n\",flag);      return 0; }", "referer": "user-0"}, {"cid": "20", "user": "user-7", "content": "#include \"stdio.h\" #include \"string.h\"   int main() {     char c,a[81];     int flag = -1,i;     scanf(\"%c\\n\",&c);      scanf(\"%[^\\n]\",a);     for( i = 0 ; i<strlen(a) ; i++ )               if(c == a[i])flag = i;     if(flag == -1)         printf(\"Not Found\");     else         printf(\"index = %d\",flag);       return 0; }", "referer": "user-0"}]}
{"question": "键盘松开时_kbhit的值能重置吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 赵4老师的回复:GetAsyncKeyState The GetAsyncKeyState function determines whether a key is up or down at the time the function is called, and whether the key was pressed after a previous call to GetAsyncKeyState.   SHORT GetAsyncKeyState(   int vKey   // virtual-key code );   Parameters vKey  Specifies one of 256 possible virtual-key codes. For more information, see Virtual-Key Codes.  Windows NT: You can use left- and right-distinguishing constants to specify certain keys. See the Remarks section for further information.   Return Values If the function succeeds, the return value specifies whether the key was pressed since the last call to GetAsyncKeyState, and whether the key is currently up or down. If the most significant bit is set, the key is down, and if the least significant bit is set, the key was pressed after the previous call to GetAsyncKeyState. The return value is zero if a window in another thread or process currently has the keyboard focus.   Windows 95: Windows 95 does not support the left- and right-distinguishing constants. If you call GetAsyncKeyState with these constants, the return value is zero.   Remarks The GetAsyncKeyState function works with mouse buttons. However, it checks on the state of the physical mouse buttons, not on the logical mouse buttons that the physical buttons are mapped to. For example, the call GetAsyncKeyState(VK_LBUTTON) always returns the state of the left physical mouse button, regardless of whether it is mapped to the left or right logical mouse button. You can determine the system's current mapping of physical mouse buttons to logical mouse buttons by calling   GetSystemMetrics(SM_SWAPBUTTON)    which returns TRUE if the mouse buttons have been swapped.  You can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the vKey parameter. This gives the state of the shift, ctrl, or alt keys without distinguishing between left and right.   Windows NT: You can use the following virtual-key code constants as values for vKey to distinguish between the left and right instances of those keys.   Code Meaning  VK_LSHIFT VK_RSHIFT  VK_LCONTROL VK_RCONTROL  VK_LMENU VK_RMENU    These left- and right-distinguishing constants are only available when you call the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions.   Windows CE: The GetAsyncKeyState function supports the left and right virtual key constants, so you can determine whether the left key or the right key was pressed. These constants are VK_LCONTROL, VK_RCONTROL, VK_LMENU, VK_RMENU, VK_LSHIFT, and VK_RSHIFT.  The least significant bit of the return value is not valid in Windows CE, and should be ignored.  GetAsyncKeyState will return the current key state even if a window in another thread or process currently has the keyboard focus.   You can also use the VK_LBUTTON virtual-key code constant to determine the state of the stylus tip, (up/down), on the touch-screen.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winuser.h.   Import Library: Use user32.lib.  See Also Keyboard Input Overview, Keyboard Input Functions, GetKeyboardState, GetKeyState,GetSystemMetrics, MapVirtualKey, SetKeyboardState 谢谢！用GetAsyncKeyState解决了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "_kbhit和_getch属于conio.h，是跳过stdin的或者说是并行于stdin旁边的，因此对stdin的操作对它们没有作用。 但是conio.h系列受限于控制台对早年DOS环境的模拟。卡顿云云是由于键盘的BIOS驱动程序或者windows底层对BIOS功能的模拟，为了防止正常打字键帽抬起不利索造成重复输入，刻意制造的至少250ms不响应，也就是说这个短期不响应和缓冲区神马的没有关系，当然也无法通过清缓冲的思路解决。  正确使用windows API才能压榨系统的功能和性能，见楼上。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "GetAsyncKeyState The GetAsyncKeyState function determines whether a key is up or down at the time the function is called, and whether the key was pressed after a previous call to GetAsyncKeyState.   SHORT GetAsyncKeyState(   int vKey   // virtual-key code );   Parameters vKey  Specifies one of 256 possible virtual-key codes. For more information, see Virtual-Key Codes.  Windows NT: You can use left- and right-distinguishing constants to specify certain keys. See the Remarks section for further information.   Return Values If the function succeeds, the return value specifies whether the key was pressed since the last call to GetAsyncKeyState, and whether the key is currently up or down. If the most significant bit is set, the key is down, and if the least significant bit is set, the key was pressed after the previous call to GetAsyncKeyState. The return value is zero if a window in another thread or process currently has the keyboard focus.   Windows 95: Windows 95 does not support the left- and right-distinguishing constants. If you call GetAsyncKeyState with these constants, the return value is zero.   Remarks The GetAsyncKeyState function works with mouse buttons. However, it checks on the state of the physical mouse buttons, not on the logical mouse buttons that the physical buttons are mapped to. For example, the call GetAsyncKeyState(VK_LBUTTON) always returns the state of the left physical mouse button, regardless of whether it is mapped to the left or right logical mouse button. You can determine the system's current mapping of physical mouse buttons to logical mouse buttons by calling   GetSystemMetrics(SM_SWAPBUTTON)    which returns TRUE if the mouse buttons have been swapped.  You can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the vKey parameter. This gives the state of the shift, ctrl, or alt keys without distinguishing between left and right.   Windows NT: You can use the following virtual-key code constants as values for vKey to distinguish between the left and right instances of those keys.   Code Meaning  VK_LSHIFT VK_RSHIFT  VK_LCONTROL VK_RCONTROL  VK_LMENU VK_RMENU    These left- and right-distinguishing constants are only available when you call the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions.   Windows CE: The GetAsyncKeyState function supports the left and right virtual key constants, so you can determine whether the left key or the right key was pressed. These constants are VK_LCONTROL, VK_RCONTROL, VK_LMENU, VK_RMENU, VK_LSHIFT, and VK_RSHIFT.  The least significant bit of the return value is not valid in Windows CE, and should be ignored.  GetAsyncKeyState will return the current key state even if a window in another thread or process currently has the keyboard focus.   You can also use the VK_LBUTTON virtual-key code constant to determine the state of the stylus tip, (up/down), on the touch-screen.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winuser.h.   Import Library: Use user32.lib.  See Also Keyboard Input Overview, Keyboard Input Functions, GetKeyboardState, GetKeyState,GetSystemMetrics, MapVirtualKey, SetKeyboardState", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include <conio.h> #include <windows.h> int main() {     int a,k;     while (1) {           a=_kbhit();           if (a!=0) {                 cprintf(\"1\");                 k=getch();                 if (0==k || 0xE0==k) k=k<<8|getch();                 if (27==k) break; //按Esc键退出           } else {                 cprintf(\"0\");           }           Sleep(20);     }     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "想用_getch()清除键盘缓冲，这样子_kbhitd的值就重置为0了，我用GetKeyState, _kbhit下的语句就会反复执行。 我的目的是想实现静止的时候放一套动画，移动的时候放另一套动画，_kbhit不重置的话静止的时候就会播放移动的动画。现在不用_kbhit换一个思路算是解决问题了，如果能学到松键检测的话更好", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "你都GetKeyState了，还要_getch干啥？不解。  另外无论是GetKeyState还是_getch都不会和stdin打交道，所以你处理stdin没有效果。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "int a; while(1) {   a = _kbhit();   if (a != 0)   {     printf(\"1\");     _getch();   }   else     printf(\"0\"); }  加了个_getch(),实现是实现了，但是我在做游戏人物的移动，移动模块我用的是GetKeyState，但加上_getch()后，按住键盘人物会先动一下，卡一下，然后才一直移动。试着把_getch()换成rewind(stdin)或者fflush(stdin)来清除键盘缓冲，但是都没有效果，有其他清除键盘缓冲的方法吗", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "这样子松开后就一直输出1，a的值没有重置，我想松开键盘之后还是输出0", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "int a; while(1) {   a = _kbhit();   if (a != 0)   {     printf(\"1\");   }   else     printf(\"0\"); }  这样不就可以看到松开的后果了？", "referer": "user-0"}]}
{"question": "十只队伍9轮循环用C语言怎么做，求大佬指导指导", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "去查查竞赛规则，有对阵表的。直接拿来用就可以了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "lz，如果让你写个从10个队伍中抽2个队伍做组合（不能重复），一共有多少种组合，会写吗？你的9个轮询赛其实和这个组合的意思是一样的，因为每个队可以和其他9个队做组合。最简单直观的做法就是2个for循环 int i, j; for (i=0; i<10; i++) { //第一层for就是10个队伍循环     for (j=i+1; j<10; j++) { //第二层for就是在第一层的基础上，取出所有的第一层当前索引之后的元素做组合         printf(\"%d vs %d\\n\", i+1, j+1);     } }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "对对对   没想明白怎么生成这个循环。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你罗列出45场比赛以后就需要思考新的问题： 哪5场可以同时进行？ 你接下来得把45场分成9天，每天5场的队伍不重复。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 7 楼 qybao的回复:[quote=引用 6 楼 qq_51563431 的回复:]大佬，我太废了，不会写不能重复这个组合 不会重复，那会写重复的组合吗？ 再重复的基础上，再去考虑怎么判断去掉重复，那也是一个思路 所以你应该学会整理一下思路，然后一次次尝试  比如，两个for循环先把所有的重复的组合找出来，然后考虑一下，有什么特点，1 vs 2 和 2 vs 1 是等效的，那么可不可把 12 和 21 记录下来，如果其中一个存在，那就不组合了（因为说明已经组合过了）  int i, j; int chk[100] = {0}; //记录编号组合过的数组（组合两个对的编号转换为 编号1*10+编号2和编号2*10+编号1，也就是 1 vs 2 变成 12 和 21） for (i = 0; i < 10; i++) {   for (j = 0; j < 10; j++) {     if (j == i) //如果编号相同，那就不处理（因为自己不能跟自己比，也就是不存在 1 vs 1），继续下一轮循环       continue;     if (chk[i * 10 + j] == 1) //编号转换为 编号1*10+编号2，看看该编号是否存在，如果存在就跳过，继续下一轮循环       continue;     chk[i * 10 + j] = 1; //记录该组合已经出现过 编号1*10+编号2     chk[j * 10 + i] = 1; //记录该组合已经出现过 编号2*10+编号1     printf(\"%d vs %d\\n\", i + 1, j + 1);   } }[/quote] 大佬 谢谢了", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 6 楼 qq_51563431 的回复:大佬，我太废了，不会写不能重复这个组合 不会重复，那会写重复的组合吗？ 再重复的基础上，再去考虑怎么判断去掉重复，那也是一个思路 所以你应该学会整理一下思路，然后一次次尝试  比如，两个for循环先把所有的重复的组合找出来，然后考虑一下，有什么特点，1 vs 2 和 2 vs 1 是等效的，那么可不可把 12 和 21 记录下来，如果其中一个存在，那就不组合了（因为说明已经组合过了）  int i, j; int chk[100] = {0}; //记录编号组合过的数组（组合两个对的编号转换为 编号1*10+编号2和编号2*10+编号1，也就是 1 vs 2 变成 12 和 21） for (i = 0; i < 10; i++) {   for (j = 0; j < 10; j++) {     if (j == i) //如果编号相同，那就不处理（因为自己不能跟自己比，也就是不存在 1 vs 1），继续下一轮循环       continue;     if (chk[i * 10 + j] == 1) //编号转换为 编号1*10+编号2，看看该编号是否存在，如果存在就跳过，继续下一轮循环       continue;     chk[i * 10 + j] = 1; //记录该组合已经出现过 编号1*10+编号2     chk[j * 10 + i] = 1; //记录该组合已经出现过 编号2*10+编号1     printf(\"%d vs %d\\n\", i + 1, j + 1);   } }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "大佬，我太废了，不会写不能重复这个组合   引用 5 楼 qybao 的回复:lz，如果让你写个从10个队伍中抽2个队伍做组合（不能重复），一共有多少种组合，会写吗？你的9个轮询赛其实和这个组合的意思是一样的，因为每个队可以和其他9个队做组合。最简单直观的做法就是2个for循环 int i, j; for (i=0; i<10; i++) { //第一层for就是10个队伍循环     for (j=i+1; j<10; j++) { //第二层for就是在第一层的基础上，取出所有的第一层当前索引之后的元素做组合         printf(\"%d vs %d\\n\", i+1, j+1);     } }", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "#include <stdio.h> #define N 10 int main() { \tint a[N+1]; \tint i, j; \tfor (i = 0; i < N; i++) \t\ta[i] = i + 1; \tfor (i = 0; i < N-1; i++) { \t\tprintf(\"第%d轮：\\n\", i + 1); \t\tfor (j = 0; j < N/2; j++) { \t\t\tprintf(\"%4d-%-4d\", a[j], a[9 - j]); \t\t} \t\tprintf(\"\\n-------------------------------------------\\n\"); \t\tfor (j = N-1; j > 0; j--) { \t\t\ta[j + 1] = a[j]; \t\t} \t\ta[1] = a[N]; \t} \treturn 0; }  供参考。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "看画圈部位应该是头疼循环赛吧？", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "哪儿不会？不会生成循环赛？还是不会积分？", "referer": "user-0"}]}
{"question": " 幸运彩票 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 26 楼 maggielve 的回复:[quote=引用 25 楼 qq_1457346882的回复:][quote=引用 21 楼 maggielve 的回复:][quote=引用 20 楼 qq_1457346882 的回复:][quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include \"stdio.h\" int main() { \tchar a[100][6]; \tint n,i,j,sum1 = 0, sum2 = 0; \tscanf(\"%d\",&n); \tfor( i = 0 ; i < n ; i++ ) \t\tscanf(\"%s\",&a[i]); \tfor( i = 0 ; i < n ; i++ ) \t{ \t\tsum1 = 0, sum2 = 0; \t\tfor( j = 0 ; j < 6 ; j++ ) \t\t{ \t\t\tif( j <= 2 ) \t\t\t\tsum1 += a[i][j]-'0'; \t\t\telse \t\t\t\tsum2 += a[i][j]-'0'; \t\t} \t\tif( sum1 == sum2 ) \t\t\tprintf(\"You are lucky!\\n\"); \t\telse \t\t\tprintf(\"Wish you good luck.\\n\"); \t} \t\t \t\t \t\t \t\t \t\t \treturn 0; } [/quote] 所以你这个表情拿来什么意思呢？你没做处理？[/quote] 我这段代码是对的[/quote] sum1 += a[i][j]-'0'; 那你这还不是经过了处理？把字符换成了数字，我服了", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "强.。。。。。。。。。。。。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 23 楼 maggielve 的回复:[quote=引用 22 楼 weixin_54938528的回复:]很好，对我很有帮助，感谢！ 你码龄才两天够强了[/quote]  啥意思??????????????", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 25 楼 qq_1457346882的回复:[quote=引用 21 楼 maggielve 的回复:][quote=引用 20 楼 qq_1457346882 的回复:][quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include \"stdio.h\" int main() { \tchar a[100][6]; \tint n,i,j,sum1 = 0, sum2 = 0; \tscanf(\"%d\",&n); \tfor( i = 0 ; i < n ; i++ ) \t\tscanf(\"%s\",&a[i]); \tfor( i = 0 ; i < n ; i++ ) \t{ \t\tsum1 = 0, sum2 = 0; \t\tfor( j = 0 ; j < 6 ; j++ ) \t\t{ \t\t\tif( j <= 2 ) \t\t\t\tsum1 += a[i][j]-'0'; \t\t\telse \t\t\t\tsum2 += a[i][j]-'0'; \t\t} \t\tif( sum1 == sum2 ) \t\t\tprintf(\"You are lucky!\\n\"); \t\telse \t\t\tprintf(\"Wish you good luck.\\n\"); \t} \t\t \t\t \t\t \t\t \t\t \treturn 0; } [/quote] 所以你这个表情拿来什么意思呢？你没做处理？[/quote] 我这段代码是对的", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "引用 21 楼 maggielve 的回复:[quote=引用 20 楼 qq_1457346882 的回复:][quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include \"stdio.h\" int main() { \tchar a[100][6]; \tint n,i,j,sum1 = 0, sum2 = 0; \tscanf(\"%d\",&n); \tfor( i = 0 ; i < n ; i++ ) \t\tscanf(\"%s\",&a[i]); \tfor( i = 0 ; i < n ; i++ ) \t{ \t\tsum1 = 0, sum2 = 0; \t\tfor( j = 0 ; j < 6 ; j++ ) \t\t{ \t\t\tif( j <= 2 ) \t\t\t\tsum1 += a[i][j]-'0'; \t\t\telse \t\t\t\tsum2 += a[i][j]-'0'; \t\t} \t\tif( sum1 == sum2 ) \t\t\tprintf(\"You are lucky!\\n\"); \t\telse \t\t\tprintf(\"Wish you good luck.\\n\"); \t} \t\t \t\t \t\t \t\t \t\t \treturn 0; } [/quote] 所以你这个表情拿来什么意思呢？你没做处理？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 9 楼 lin5161678的回复:[quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf(\"%1d\",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 18 楼 自信男孩的回复:对于不同，你有么有好好分析？不同，不对就直接问，你自己的思考呢？ 额，我肯定是思考过后不会才问的", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "对于不同，你有么有好好分析？不同，不对就直接问，你自己的思考呢？", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "引用 4 楼 maggielve 的回复:[quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf(\"%1d\",&a[i]); 那也不对啊？[/quote]你不会 不是我不对", "referer": "user-0"}, {"cid": "11", "user": "user-7", "content": "这个可以非常简单吧：  #include <stdio.h>  int main() {   int a, b, c, d, e, f;    for (scanf(\"%d\", &a); scanf(\"%1d%1d%1d%1d%1d%1d\", &a, &b, &c, &d, &e, &f) == 6;)     a + b + c == d + e + f ? puts(\"You are lucky!\") : puts(\"Wish you good luck.\");    return 0; }", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 12 楼 lin5161678的回复:[quote=引用 10 楼 maggielve 的回复:][quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf(\"%1d\",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说[/quote] 咱俩的代码不一样，我只是在我的代码上又加了个1，而你这段代码是可以的", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 13 楼 自信男孩的回复:[quote=引用 12 楼 lin5161678 的回复:][quote=引用 10 楼 maggielve 的回复:][quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf(\"%1d\",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说[/quote] 楼主是自己不懂，就怪别人，别人会的他不会就是别人的错。所以，不要跟他计较这些。 楼主没有虚心学习的态度，只有挑刺和不承认自己的差距的问题～[/quote] 我按照别人说的改了下代码，然后测试有错误，我就说了下有错误，怎么了？我怎么就挑刺了，我怎么就怪别人了？你不要无中生有好不好？", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 11 楼 qq_1457346882的回复:整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 22 楼 weixin_54938528的回复:很好，对我很有帮助，感谢！ 你码龄才两天够强了👍", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "引用 12 楼 lin5161678 的回复:[quote=引用 10 楼 maggielve 的回复:][quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf(\"%1d\",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说[/quote] 楼主是自己不懂，就怪别人，别人会的他不会就是别人的错。所以，不要跟他计较这些。 楼主没有虚心学习的态度，只有挑刺和不承认自己的差距的问题～", "referer": "user-0"}, {"cid": "17", "user": "user-6", "content": "引用 10 楼 maggielve 的回复:[quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf(\"%1d\",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说", "referer": "user-0"}, {"cid": "18", "user": "user-4", "content": "很好，对我很有帮助，感谢！", "referer": "user-0"}, {"cid": "19", "user": "user-1", "content": "整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  引用 5 楼 maggielve 的回复:[quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?", "referer": "user-0"}, {"cid": "20", "user": "user-0", "content": "引用 20 楼 qq_1457346882 的回复:[quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include \"stdio.h\" int main() { \tchar a[100][6]; \tint n,i,j,sum1 = 0, sum2 = 0; \tscanf(\"%d\",&n); \tfor( i = 0 ; i < n ; i++ ) \t\tscanf(\"%s\",&a[i]); \tfor( i = 0 ; i < n ; i++ ) \t{ \t\tsum1 = 0, sum2 = 0; \t\tfor( j = 0 ; j < 6 ; j++ ) \t\t{ \t\t\tif( j <= 2 ) \t\t\t\tsum1 += a[i][j]-'0'; \t\t\telse \t\t\t\tsum2 += a[i][j]-'0'; \t\t} \t\tif( sum1 == sum2 ) \t\t\tprintf(\"You are lucky!\\n\"); \t\telse \t\t\tprintf(\"Wish you good luck.\\n\"); \t} \t\t \t\t \t\t \t\t \t\t \treturn 0; }", "referer": "user-0"}]}
{"question": "c语言新手请教——实现字符串连接", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "懂了，谢了各位。要想输出字符串，需要自己手动添加'\\0'。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考：int main() {////***连接字符串     char str1[50],str2[20];     int i,j;     printf(\"输入第一个字符串(不含空格)：\\n\");     scanf(\"%s\",str1);     printf(\"输入第二个字符串(不含空格)：\\n\");     scanf(\"%s\",str2);     i=j=0;     while(str1[i])i++;                     //while(str1[i]!='\\0') {i=i+1;}     while(str2[j])     {               str1[i++] = str2[j++];  //str1[i+1] =str2[j];                                                  //printf(\"连接后的字符串1：%s\\n\",str1);                                                  //i=i+1;                                                  //j=j+1;     }     str1[i] = '\\0';  //strcat(str1,str2);     printf(\"\\n连接后的字符串1：%s\\n\",str1);         return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "因为你'\\0'还存在，没有被修掉", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "差点儿被你绕昏了，0后面就不算字符串的内容了啊！", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "楼上说了 。还有数组初始化时要清零 ，操作不要溢出", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "#include <stdio.h>  #define DEBUG  int main() {////***连接字符串     char str1[50],str2[20];     int i,j;     printf(\"输入第一个字符串(不含空格)：\\n\");     scanf(\"%s\",str1);     printf(\"输入第二个字符串(不含空格)：\\n\");     scanf(\"%s\",str2);     i=j=0;     while(str1[i]!='\\0') {i=i+1;}     while(str2[j]!='\\0')     {               //str1[i+1] =str2[j];               str1[i] =str2[j]; #ifdef DEBUG               str1[i+1] = 0;                printf(\"连接后的字符串1：%s\\n\",str1); #endif               i=i+1;               j=j+1;     }     str1[i] = 0; //equal '\\0' //    strcat(str1,str2);     printf(\"\\n连接后的字符串1：%s\\n\",str1);     return 0; }  供参考～  在第一个字符串的末尾，即'\\0'的位置存放第二个字符串的第一个字符，而不是第一个字符串'\\0'的下一个位置存放第二个字符串的第一个字符  另外，字符串都是一个'\\0'结束，因此要%s输出，需要添加'\\0'", "referer": "user-0"}]}
{"question": "C语言实现打印出心形，初学者的表白神器。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "一个建议：循环变量用整型。因为浮点数会有微小的误差，可能导致循环次数跟预想的不同。 比如  for (int i=0; i<21; i++) {     double y = 2.5 - i * 0.2;     .... }", "referer": "user-0"}]}
{"question": "看看大家的解题方法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "#include<stdio.h> #include<stdlib.h>  typedef struct Node { \tint data; \tstruct Node *next; }node; typedef struct Node *LinkList;  /*=============================================================== CreateLinkList函数功能： 创建链表L, 并将给定数组a, 以及数组中元素个数n，尾部插入法建立循环链表 ===================================================================*/ LinkList createlist(LinkList *L,int n,int a[]) { \tLinkList p,r; \tint i;  \t(*L)=(LinkList)malloc(sizeof(node));  // 建立头结点 \tr=*L;  \tfor(i=0;i<n;i++) \t{ \t\tp=(LinkList)malloc(sizeof(node));   // 生成新结点 \t\tp->data=a[i]; \t\tr->next=p; \t\tr=p; \t} \tr->next=(*L)->next; \tfree(*L); \treturn r->next; }  int main() { \tint A[]={0}; \tint i,j,N,m; \tLinkList pi,p,temp;  \tprintf(\"请输入链表元素的个数：\"); \tscanf(\"%d\",&N); \tfor(i=0;i<N;i++) \t{ \t\tscanf(\"%d\",&A[i]); \t} \tp=createlist(&pi,N,A); \tm=p->data; \twhile(p!=p->next) \t{ \t\tfor(j=1;j<(m-1);j++) \t\t{ \t\t\tp=p->next; \t\t} \t\tm=p->next->data; \t\tprintf(\"%d->\",m); \t\ttemp=p->next; \t\tp->next=temp->next; \t\tfree(temp); \t\tp=p->next; \t} \tprintf(\"%d\\n\",p->data);  \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这不是约瑟夫环吗？90%是一样的，不一样的地方是这个数数的值是变化的。 先写出一个约瑟夫环的代码，再考虑把这个数数的值变化加进去就好了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 1 楼 forever74 的回复:难怪高考语文总是受重视，原来有人出题都不好好表达。 所有人全部出列还写什么代码，散了吧，所有人都撤了，没啥好看的了。  对头。有挑战性的，应该分出loser和winner。。这样才有意义。。。", "referer": "user-0"}]}
{"question": "C语言输出有误，多输出了乱码，求助！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 8 楼 阿麦的回复:先把数组 a 初值设置为 \\0 就可以。 但是更好的习惯是注意防患内存溢出：字符串以 \\0 结尾，且不能超出定义长度  void alter(char a[]) {     int i;     int len = strlen(a);     if (len > 19)     {         len = 19;         a[19] = '\\0';     }     for(i=len; i>=0; i--)     {         a[2*i+1]=a[i];         a[2*i]=' ';        }     puts(a); }  华东师大的大佬！！！ 谢谢谢谢 学到了学到了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "for循环从4开始吧，因为需要考虑到'\\0'，字符串需要以'\\0'结束。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "先把数组 a 初值设置为 \\0 就可以。 但是更好的习惯是注意防患内存溢出：字符串以 \\0 结尾，且不能超出定义长度  void alter(char a[]) {     int i;     int len = strlen(a);     if (len > 19)     {         len = 19;         a[19] = '\\0';     }     for(i=len; i>=0; i--)     {         a[2*i+1]=a[i];         a[2*i]=' ';        }     puts(a); }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 云中屋的回复:没有结束符就一直往下打印直到遇到结束符，下面是一种修改方式的代码，供参考。   #include<stdio.h> void alter(char a[]) {     int i;     for(i=3;i>=0;i--)     {         a[2*i+1]=a[i];         a[2*i]=' ';        }     a[2*4] = '\\0'; //在最后增加一个结束符      puts(a);       } int main() {     char a[40];     printf(\"输入一个四位数：\\n\");     scanf(\"%s\",&a);     alter(a);     return 0; }  OK 我明白了 谢谢谢谢", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-5的回复:你没处理结束符，多一个就行。 for(i=4;i>=0;i--) 谢谢大佬 十分感谢", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "没有结束符就一直往下打印直到遇到结束符，下面是一种修改方式的代码，供参考。   #include<stdio.h> void alter(char a[]) {     int i;     for(i=3;i>=0;i--)     {         a[2*i+1]=a[i];         a[2*i]=' ';        }     a[2*4] = '\\0'; //在最后增加一个结束符      puts(a);       } int main() {     char a[40];     printf(\"输入一个四位数：\\n\");     scanf(\"%s\",&a);     alter(a);     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "少了个'\\0'", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "你没处理结束符，多一个就行。 for(i=4;i>=0;i--)", "referer": "user-0"}]}
{"question": "请教大神 这两者的区别", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第一张图应该这样#include <stdio.h> int main() {     int  score;     char grade;     printf(\"Please input score:\");     scanf(\"%d\",&score);     if(score<0 || score>100){         printf(\"Input error!\\n\");         return 0；      }     else if(score >= 90)        grade = 'A';     else if(score >= 80)        grade = 'B';     else if(score >= 70)        grade = 'C';     else if(score >= 60)        grade = 'D';     else        grade = 'E';     printf(\"grade:%c\\n\",grade);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 7 楼 maggielve 的回复:[quote=引用 4 楼 是疗伤烧肉粽~ 的回复:]第一张图的代码是错的，在第一个if的printf后加上return 0就对了。记得要加大括号。 第二张图是对的。 两张图没什么区别，看你喜欢用哪个 没错啊？选择结构，执行一次就不往下执行了 [/quote]。。。。你自己去运行一下就知道哪里错了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "第一图修改，供参考：#include <stdio.h> int main() {     int  score;     char grade;     printf(\"Please input score:\");     scanf(\"%d\",&score);     if(score<0 || score>100)        grade = 'F';//printf(\"Input error!\\n\");     else if(score >= 90)        grade = 'A';     else if(score >= 80)        grade = 'B';     else if(score >= 70)        grade = 'C';     else if(score >= 60)        grade = 'D';     else        grade = 'E';      if(grade == 'F')        printf(\"Input error!\\n\");     else        printf(\"grade:%c\\n\",grade);        return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 4 楼 是疗伤烧肉粽~ 的回复:第一张图的代码是错的，在第一个if的printf后加上return 0就对了。记得要加大括号。 第二张图是对的。 两张图没什么区别，看你喜欢用哪个 没错啊？选择结构，执行一次就不往下执行了", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "差不多，第一张图<0 || > 100，printf之后要ruturn -1，不然程序不会退出", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "第一张图的代码是错的，在第一个if的printf后加上return 0就对了。记得要加大括号。 第二张图是对的。 两张图没什么区别，看你喜欢用哪个", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "把ruturn 0去掉就可以了", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "可以在第一个else下放置{}，范围到return 0前面", "referer": "user-0"}, {"cid": "10", "user": "user-8", "content": "运行一下不就明白了？", "referer": "user-0"}, {"cid": "11", "user": "user-9", "content": "grade没有初始化，如果<0 || > 100，最后输出的greade是一个随机值。   两张图片的区别应该是有没有在return 0前加printf吧", "referer": "user-0"}]}
{"question": "疑问，枚举类型变量该怎么赋值？大神求解！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 早打大打打核战争的回复:tomorrow = (Weekday)((int)today + 1); 高手厉害，的确是我格式有问题。编译成功了！谢谢！！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:参考：https://blog.csdn.net/zhanghong056/article/details/76697195?utm_medium=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase&depth_1-utm_source=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase 嗯，大概懂了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "tomorrow = (Weekday)((int)today + 1);", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "参考：https://blog.csdn.net/zhanghong056/article/details/76697195?utm_medium=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase&depth_1-utm_source=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "好的，原来这样。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "不可以的。那个相当于一个#define的定义。", "referer": "user-0"}]}
{"question": "C语言全局变量问题，大佬救命", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 user-2的回复:全局位置的 int a; 分配空间建立全局变量并初始化为0，并慷慨地允许其他文件使用这个变量。 static int a; 分配空间建立全局变量并初始化为0，并禁止其他文件分享该变量。  extern int a; 这个出现在“其他文件”里面，并不分配空间建立变量，而是把上面第一行那个变量介绍到本文件来发挥作用。 谢谢 老铁 我懂了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "全局变量就是全局变量，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”其他文件可使用extern来引用同一个变量。static是静态存储的意思。在开头声明该文件可用。在代码块中使用只能在代码块中可见，和代码块中栈的变量区别是，栈中声明的变量会清理，比如while里声明的int变量一个循环后会被重新创建，而static的变量值不变，而且不会消除，重新创建。程序存在static变量存在。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "全局位置的 int a; 分配空间建立全局变量并初始化为0，并慷慨地允许其他文件使用这个变量。 static int a; 分配空间建立全局变量并初始化为0，并禁止其他文件分享该变量。  extern int a; 这个出现在“其他文件”里面，并不分配空间建立变量，而是把上面第一行那个变量介绍到本文件来发挥作用。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "全局变量默认情况下和static还有extern都不同。 所以全局变量没有默认存储类别。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "之前有看到默认是static 感到不太确定", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "有人吗 我晕了", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢指导，谢谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主的方法:#include\"stdio.h\" int main() {     float grade[][4]={60,70,80,90,56,89,67,88,34,78,90,66};//存放成绩     float *search(float(*pointer)[4]);     float *p;     int i,j;     for(i=0;i<3;i++)        {          p=search(grade+i);          if(p==*(grade+i)){             printf(\"No.%d\",i+1);//输出学号             for(j=0;j<4;j++)                printf(\"%6.2f\",*(p+j));// 输出满足条件的学生的成绩             printf(\"\\n\");          }        }     // system(\"pause\");     return 0; }   float *search(float(*pointer)[4])  {     float *pt;     int i;     pt=NULL;     for(i=0;i<4;i++)        if(*(*pointer+i)<60)pt=*pointer;     return pt; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "供参考：#include\"stdio.h\"  int main(int argc, char* argv[]) {     float grade[][4]={60,70,80,90,56,89,67,88,34,78,90,66};//存放成绩     float *search(float(*pointer)[4]);     float *p;     int i,j;     for(i=0;i<3;i++)        {           p=search(grade+i);           if(p){              //if(p==*(grade+i)){              printf(\"No.%d \",i+1);//输出学号              for(j=0;j<4;j++)                 printf(\"%6.2f\",*(*(grade+i)+j));// 输出满足条件的学生的成绩              printf(\"\\n\");           }        }      //system(\"pause\");     return 0; }   float *search(float(*pointer)[4]) {     float *pt;     int i;     pt=NULL;     for(i=0;i<4;i++)        if(*(*pointer+i)<60) pt=(*pointer+i);     return pt; }", "referer": "user-0"}]}
{"question": "浮点数减法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复:", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 user-2 的回复:减法运算用补码就是加法运算 X-Y=X+(-Y)=X[补]+(-Y)[补] 所以(-Y)[补]不对  嗯嗯，明白了，谢谢大佬", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "减法运算用补码就是加法运算 X-Y=X+(-Y)=X[补]+(-Y)[补] 所以(-Y)[补]不对", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "找到错误了", "referer": "user-0"}]}
{"question": "c#从数据库得到点的坐标大小，在zedgraphcontrol分别显示", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1.打开数据库； 2.读一行数据，并显示； 3.重复第2条，直至结束 4.Game over", "referer": "user-0"}]}
{"question": "IAR在函数中已经声明了外部变量 但是却提示错误Undefined external \"arr\" referred in lvbo ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考:https://bbs.csdn.net/topics/398903802", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "说明编译器确实没找到它。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "或者说你的工程/项目引用文件不全，不是源代码写法的事。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "编译的时候不会出这个错误，连接的时候你得确保把相关的目标文件都连接进来。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "我是定义在.c文件里的 .c文件可以引用吗？", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "你得把extern unsigned long arr[5];这个外部数组的.c .h文件导入进来，不然不知道上哪找。", "referer": "user-0"}]}
{"question": "输出1000以内的素数，每行10个。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "。。。。。你在教我做事？？？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "认真学习！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "成就感对菜鸟和大神是公平的。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "#include <stdio.h> #include <stdlib.h> #include <math.h>  int prime(int n) {     int i, flag = 1;      if (abs(n) < 2)         return 0;      for(i=2;i<n;i++)   //for (i = 2; i < sqrt(n)+1; i++) 优化，降低时间复杂度         if (n % i == 0)         {             flag = 0;             break;         }     return(flag); } int main(void) {     int a, n = 0;      for (a = 2;a <= 1000;a++)     {         if (prime(a) == 1)         {             printf(\"%5d\", a);             n++;             if (n % 10 == 0)                 printf(\"\\n\");         }     } } 供参考～", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "牢记1000以内素数的重要性，请看电影《cube》", "referer": "user-0"}, {"cid": "8", "user": "user-8", "content": "没问题，楼主这是在教大家解题方法吗", "referer": "user-0"}, {"cid": "9", "user": "user-9", "content": "阅，再接再厉。", "referer": "user-0"}]}
{"question": "请教大神", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%d%*[^0-9-]%d\", &a, &b);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf(\"%d%*c%d\", &a, &b); 仅限单个字符作为分隔符。", "referer": "user-0"}]}
{"question": "C语言如果没有学过指针，这个代码还能简化吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "while (xy[x - 1][y - 1] != 8 || x > 3 || x < 1 || y>3 || y < 1);//检查  这句有问题，应该先判断越界", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "那个字符串可以定义成二维数组，就不带星了，抱歉顺手写成指针了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "另外，我个人痛恨goto，请原谅。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "在你的思路上去重复，我没有验证过： #include <stdio.h> #define DRAW printf(\"  1 2 3\\n\\n1 %d|%d|%d\\n  -----\\n2 %d|%d|%d\\n  -----\\n3 %d|%d|%d\\n\", xy[0][0], xy[0][1], xy[0][2], xy[1][0], xy[1][1], xy[1][2], xy[2][0], xy[2][1], xy[2][2]) //排出井字棋 //能短点就短点  int main() { \tint x, y; \tint xy[3][3] = { \t\t{8,8,8}, \t\t{8,8,8}, \t\t{8,8,8}, \t}; \tint i = 2; \tchar * player[2] = { \"反方\",\"正方\" }; \tint k=1;     //这个和上一行是新加的，用来表示双方 \tDRAW; \tfor (; i == 2; k=1-k) {      // 有变动 \t\tconst int SIZE = 3; \t\tint t, j; \t\tint hz, hf, lz, lf, zdjz, zdjf, fdjz, fdjf; //定义行，列，对角线的正反方计数变量  \t\thz = hf = lz = lf = zdjz = zdjf = fdjz = fdjf = 0;//初始化变量   \t\t//输入   \t\tdo { \t\t\tprintf(\"%s，请在8的区域输入：\",player[k]);  // 有变动 \t\t\tscanf(\"%d，%d\", &x, &y); // 有风险 ，两个格式符之间的逗号，是中文的 \t\t} while (xy[x - 1][y - 1] != 8 || x > 3 || x < 1 || y>3 || y < 1);//检查  \t\txy[x - 1][y - 1] = k; // 有变动 \t\tDRAW;  \t\t//循环判断  \t\tfor (t = 0; t < SIZE; t++) { \t\t\thz = lz = 0; \t\t\tfor (j = 0; j < SIZE; j++) { \t\t\t\t//检查行  \t\t\t\tif (xy[t][j] == k ) { // 有变动 \t\t\t\t\thz++; \t\t\t\t} \t\t\t\tif (hz == 3) { \t\t\t\t\ti = k; // 有变动 \t\t\t\t\tbreak; // 有变动 \t\t\t\t} \t\t\t\t//检查列  \t\t\t\tif (xy[j][t] == k ) { // 有变动 \t\t\t\t\tlz++; \t\t\t\t} \t\t\t\tif (lz == 3) { \t\t\t\t\ti = k; // 有变动 \t\t\t\t\tbreak; // 有变动 \t\t\t\t} \t\t\t} \t\t\tif (i != 2)break; // 有变动 \t\t\t//检查正对角线 \t\t\tif (xy[t][t] == k ) { // 有变动 \t\t\t\tzdjz++; \t\t\t} \t\t\tif (zdjz == 3) { \t\t\t\ti = k; // 有变动 \t\t\t\tbreak; // 有变动 \t\t\t} \t\t\t//检查反对角线  \t\t\tif (xy[t][SIZE - t - 1] == k) { // 有变动 \t\t\t\tfdjz++; \t\t\t} \t\t\tif (fdjz == 3) { \t\t\t\ti = k; // 有变动 \t\t\t\tbreak; // 有变动 \t\t\t} \t\t} \t\t//        printf(\"hz:%d,lz:%d,zdjz:%d,fdjz:%d\\n\\n\",hz,lz,zdjz,fdjz); \t} \t// 有变动 \t//if (i == 1) { \t//\tprintf(\"正方胜利\"); \t//} \t//else { \t//\tprintf(\"反方胜利\"); \t//} \tprintf(\"%s胜利\",player[i]);  \treturn 0; } 短一些也算简化吧？ 进一步 by yourself !", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "可是不知道怎么优化了。。。。。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "这个说的是流程上的简化，以后还可以琢磨算法上的简化。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "有重复，自然就可以简化。", "referer": "user-0"}]}
{"question": "为什么这个代码无法读取10.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 5 楼 文武双缺 的回复:][quote=引用 3 楼 自信男孩 的回复:]if (ch=='\\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\\n'一样。 %d只会匹配数字，其他字符是不匹配的，即接收不到'\\n'。当然也不会存在。 一楼说的就是问题的答案！ 你输入10，然后回车，ch就接收到10这个数了（%d匹配数10，回车符后续会被丢掉），就会进入“if (ch=='\\n')”了。（‘\\n’的数值也是10） 补充一点： 你代码中(如下)的odd和even作为除数是不能等于‘0’的，使用前要做好判断，否则也会出问题的。 printf(\"Odd number is %d,and which average is %d.\\nEven average is %d, and which average is %d\",         odd, sum_odd / odd, even, sum_even / even);[/quote] “%d匹配数10，回车符后续会被丢掉” 回车符不是被丢掉吧，回车符还在输入缓存里，不信的话可以在scanf_s之后加一个getchar();可以将回车符接收到，并打出来看看是不是回车符  回车的目的是将输入缓存的数据刷到内存里，但是'\\n'还是在的[/quote] 你说的没错，我这么说是为了方便你理解。 有兴趣的话，你可以继续深入研究下去，这里不是终点。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 5 楼 文武双缺 的回复:[quote=引用 3 楼 自信男孩 的回复:]if (ch=='\\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\\n'一样。  %d只会匹配数字，其他字符是不匹配的，即接收不到'\\n'。当然也不会存在。 一楼说的就是问题的答案！ 你输入10，然后回车，ch就接收到10这个数了（%d匹配数10，回车符后续会被丢掉），就会进入“if (ch=='\\n')”了。（‘\\n’的数值也是10） 补充一点： 你代码中(如下)的odd和even作为除数是不能等于‘0’的，使用前要做好判断，否则也会出问题的。 printf(\"Odd number is %d,and which average is %d.\\nEven average is %d, and which average is %d\",         odd, sum_odd / odd, even, sum_even / even);[/quote]  “%d匹配数10，回车符后续会被丢掉” 回车符不是被丢掉吧，回车符还在输入缓存里，不信的话可以在scanf_s之后加一个getchar();可以将回车符接收到，并打出来看看是不是回车符  回车的目的是将输入缓存的数据刷到内存里，但是'\\n'还是在的", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 3 楼 自信男孩 的回复:if (ch=='\\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\\n'一样。  %d只会匹配数字，其他字符是不匹配的，即接收不到'\\n'。当然也不会存在。 一楼说的就是问题的答案！ 你输入10，然后回车，ch就接收到10这个数了（%d匹配数10，回车符后续会被丢掉），就会进入“if (ch=='\\n')”了。（‘\\n’的数值也是10） 补充一点： 你代码中(如下)的odd和even作为除数是不能等于‘0’的，使用前要做好判断，否则也会出问题的。 printf(\"Odd number is %d,and which average is %d.\\nEven average is %d, and which average is %d\",         odd, sum_odd / odd, even, sum_even / even);", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "if (ch=='\\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\\n'一样。  %d只会匹配数字，其他字符是不匹配的，即接收不到'\\n'。当然也不会存在。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "楼上说的对，'\\n'的ASCII值就是10，可以把'\\n'改成'\\0'，'\\0'的ASCII值是0。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "因为'\\n'就是10，你输入的10被那个if截住了。", "referer": "user-0"}]}
{"question": "数组如何传值给一个函数？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 11 楼 qybao的回复:自己复制，出了性能问题是程序员自己负责，编译器复制，出了性能问题要找编译器公司吗？你作为编译器开发商，你会主动去惹这些麻烦吗？编译器应该帮用户优化而不是给用户带来隐患问题。所以，编译器不提供自动复制，想复制就自己主动复制，出了性能问题自己负责。 可能我不了解编译器原理。函数里自动帮我复制数组就怕出问题，那用户自己复制数组编译器就不会出问题？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 12 楼 qq_16774199 的回复：[quote=引用 11 楼 qybao的回复:]自己复制，出了性能问题是程序员自己负责，编译器复制，出了性能问题要找编译器公司吗？你作为编译器开发商，你会主动去惹这些麻烦吗？编译器应该帮用户优化而不是给用户带来隐患问题。所以，编译器不提供自动复制，想复制就自己主动复制，出了性能问题自己负责。 可能我不了解编译器原理。函数里自动帮我复制数组就怕出问题，那用户自己复制数组编译器就不会出问题？[/quote]不是说了吗？用户用了复制出问题和用户没用复制你却给主动别人带来问题，这是不同级别严重性。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你有选择语言的自由，你也有自己设计语言的自由。 但学习语言首先就不得不接受它。 所以你的思路已经跑偏了，摆正位置先。 否则下一步要质疑的就是硬件了：干嘛不搞十进制？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 8 楼 qybao的回复:Java也是这样的，你试试就知道了。在函数内改变数组元素，看看函数外变不变 既然普通变量可以传值传址，为什么语法上不给数组传值的写法呢？至于用不用那是程序员的事，自己复制一个数组那开销还不是少不了。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "你这是要反人类行动吗？ 为什么数组需要转成指针？为啥不先去好好思考这个问题。 假设你这个数组有1亿个元素，如果是按值传递，光是参数拷贝1亿个数据估计就要花好一段时间，而且还占用内存（原来的数组已经很占内存了，再复制一个数组就更占用内存，调几次函数内存就要枯竭了）。好的编译器不应该自动给程序带来类似这样的性能隐患。正是为了解决这些问题，编译器才采用传地址的方式来传数组，一是省时间，不需要元素拷贝，而是省空间，参数只占用一个指针大小的空间。如果用户自己需要新的数组，就自己手动去声明一个数组，然后用内存拷贝方式自己去复制。这样，性能问题完全交由用户自己去控制，而不是编译器自动给用户制造麻烦。", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "Java也是这样的，你试试就知道了。在函数内改变数组元素，看看函数外变不变", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 6 楼 qybao 的回复:你这是要反人类行动吗？ 为什么数组需要转成指针？为啥不先去好好思考这个问题。 假设你这个数组有1亿个元素，如果是按值传递，光是参数拷贝1亿个数据估计就要花好一段时间，而且还占用内存（原来的数组已经很占内存了，再复制一个数组就更占用内存，调几次函数内存就要枯竭了）。好的编译器不应该自动给程序带来类似这样的性能隐患。正是为了解决这些问题，编译器才采用传地址的方式来传数组，一是省时间，不需要元素拷贝，而是省空间，参数只占用一个指针大小的空间。如果用户自己需要新的数组，就自己手动去声明一个数组，然后用内存拷贝方式自己去复制。这样，性能问题完全交由用户自己去控制，而不是编译器自动给用户制造麻烦。  请问java也是这样的做法吗？", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "自己复制，出了性能问题是程序员自己负责，编译器复制，出了性能问题要找编译器公司吗？你作为编译器开发商，你会主动去惹这些麻烦吗？编译器应该帮用户优化而不是给用户带来隐患问题。所以，编译器不提供自动复制，想复制就自己主动复制，出了性能问题自己负责。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "因为C语言的设计者希望一方面简化编译器的复杂度，另一方面给C猿以足够的自由。  你真的需要副本的话完全可以在上级（调用者）函数里自己处理，memcpy搞定即可。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 3 楼 forever74的回复:局限是结构体中的数组大小必须是常量。 为什么这么麻烦，如果是普通变量就很容易，传值传址一个*号的事情。", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "局限是结构体中的数组大小必须是常量。", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "可以把数组整体放进结构体，传递结构体类型的参数。", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "数组参数加个const应该可以实现你的要求。", "referer": "user-0"}]}
{"question": "求大佬讲解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位大佬", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 qybao 的回复:[quote=引用 5 楼 我当时害怕极了QAQ 的回复:]  老师，我晕了  8位整形范围不是-128到127吗  -100咋溢出了呢 溢出应该是不以表示范围来判断的，正因为它溢出，所以才保证了它的值还在范围里 比如 0x7FFFFFFF(4位int的最大值) + １ = 0x80000000 (变为负数) 这个负数也在 0x80000000到0x7FFFFFFF的范围里，那它算不算溢出？ [/quote]   明白了，应该用和的补码判断溢出  我直接算原码的和了  就是没有判断溢出。。。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "四楼的四老师已经生动证明了，溢出和出错是两回事。溢出并不必然伴随着出错。  回想你八岁的时候，溢出了一颗牙齿，太正常了。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 5 楼 我当时害怕极了QAQ 的回复:老师，我晕了  8位整形范围不是-128到127吗  -100咋溢出了呢 溢出应该是不以表示范围来判断的，正因为它溢出，所以才保证了它的值还在范围里 比如 0x7FFFFFFF(4位int的最大值) + １ = 0x80000000 (变为负数) 这个负数也在 0x80000000到0x7FFFFFFF的范围里，那它算不算溢出？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "溢出是针对有符号数的，无符号数是进位/借位", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "题目有点问题，没有明确是有符号还是无符号的", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复:x表示-16 y表示-72 z=4*x+y/2  =4*(-16)+(-72)/2  =-100   4*x=1100 0000 //符号位是1，说明是负数，保留符号位，左移2位（低位补0）表示-64 y/2=1101 1100 //符号位是1，保留符号位，右移1位（高位补1）表示-36 相加结果，1 1001 1100虽然有溢出，但取其低8位，1001 1100 表示-100，结果正确。  老师，我晕了  8位整形范围不是-128到127吗  -100咋溢出了呢", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "x表示-16 y表示-72 z=4*x+y/2  =4*(-16)+(-72)/2  =-100   4*x=1100 0000 //符号位是1，说明是负数，保留符号位，左移2位（低位补0）表示-64 y/2=1101 1100 //符号位是1，保留符号位，右移1位（高位补1）表示-36 相加结果，1 1001 1100虽然有溢出，但取其低8位，1001 1100 表示-100，结果正确。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 qybao 的回复:4*x=1100 0000 //符号位是1，说明是负数，保留符号位，左移2位（低位补0） y/2=1101 1100 //符号位是1，保留符号位，右移1位（高位补1） 相加结果，11001 1100，说明溢出了，其实只需要看两个操作数的符号位紧接着的1位是不是都是1，就能判断是否会溢出了  大佬，y/2我算的不一样  不应该是由（y补）先算y = 11001000  y/2 = 10100100吗", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "要看它的整型长度多少，如果只有1字节的话，肯定溢出了", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "4*x=1100 0000 //符号位是1，说明是负数，保留符号位，左移2位（低位补0） y/2=1101 1100 //符号位是1，保留符号位，右移1位（高位补1） 相加结果，11001 1100，说明溢出了，其实只需要看两个操作数的符号位紧接着的1位是不是都是1，就能判断是否会溢出了", "referer": "user-0"}]}
{"question": "揭开内存的秘密，让一切真相大白", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "文章第一句就是从设计概念上讲，这就排除了例外，寄存器是可以储存数据，但从设计目的来看是为了加快数据储存而不是用来保存数据，要说例外有的计算机连内存都没有，只有寄存器，cpu直接向硬件发送指令。不过你回复的内容可以作为本文内容的补充，幸苦了！想不到我的帖子引出了论坛中比我更老的程序员。  内存对齐算法其实很复杂，与cpu步长、平台、编译器都有关系，具体细节我没有写出来，既然你提出来了，我就来补充一下。每个平台上的特定编译器都有自己的内存对齐方案，以Win32平台下的微软C编译器为例，策略如下： 1)结构体变量的首地址是其最长基本类型成员的整数倍。 编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能是该基本数据类型的整倍的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为对齐模数。 2)结构体每个成员相对于结构体首地址的偏移量都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节。 为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。 3)结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要，编译器会在最末一个成员之后加上填充字节。  备注： a、结构体总大小是包括填充字节，最后一个成员满足上面两条以外，还必须满足第三条，否则就必须在最后填充几个字节以达到本条要求。 b、如果结构体内存在长度大于处理器位数的元素，那么就以处理器的倍数为对齐单位；否则，如果结构体内的元素的长度都小于处理器的倍数的时候，便以结构体里面最长的数据元素为对齐单位。 4) 结构体内类型相同的连续元素将在连续的空间内，和数组一样。  我们还可以为编译器设置编译参数来影响对齐策略，程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变对齐系数，其中的n就是上面讲的默认对齐系数。取值规则为： 1、结构的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。 2、结构体的整体对齐规则：在数据成员完成各自对齐之后，结构体本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。  概括来说内存对齐策略是综合数据类型、cpu步长还有编译器参数三方面得出的结果，其实了解内存对齐对写C代码没有很大的帮助，只对写编译器的人有帮助，《C++程序设计精要教程》是一本好书，但也没讲的那么细，详情可以查阅相关编译原理的书籍。最后文章若还有疏漏之处，欢迎补充。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 楼主 jaj2003的回复:C语言是面向底层的语言，虽然语法和概念都很少，但却蕴含着丰富的底层知识，如果你在使用C语言时觉得语法你都会，却总是遇到这样那样的问题，并且为此一直迷惑不解，那么你欠缺的就是藏在语言下面的底层知识。要知道所有底层语言都是围绕内存工作的，因此搞懂内存是一个好的开始，本贴虽然不能为你解答所有的问题，但可以为你指引一个正确的方向。点击 https://blog.csdn.net/jaj2003/article/details/112993815 可以看到完成的内容，因为太长所以只能放入博客中。进入之前先掂量下自己的水平，因为看完只会有两种结果，对于有编程功底追寻语言背后真相的人，这篇帖子也许能让你获得重生，如果是小白来看热闹的，只会更快的将你劝退。本人花了很多时间整理，并且尽量写的通俗易懂，望珍惜。 作者辛苦了，写的很不错，道出了一般情形。但凡事皆有例外：（1）关于Cpu不能存取数据，或换句话说，内存不是Cpu的一部分，例外便是我国自主设计生产的DJS 130计算机，它采用部分内存作为寄存器，而寄存器是Cpu的一部分，所以Cpu也是可以存取数据的。（2）关于栈的操作，写的是X8086体系结构，事实有的计算机根本没有栈，根本设有push和pop指令。如IBM SYS 390系列机，它的栈是通过内存模拟的，想多大有多大，且运行中能自动检测是否溢出，且可以自动增长。(3) 即使是X8086体系也有不同之处，栈的大小在程序运行时可以设置，当然也可以在编译通过编译参数设置。例如borland编译器曾提供一个外部变量，用于在运行时设置栈的大小，格式为extern int _stklen=栈大小，这也是一种特殊的变量定义而非变量说明，其引入C++的理由正是由于有上述类似需求存在，变量定义要素参见《C++程序设计精要教程》。(4)函数参数并非全部自右向左入栈，这只是大部分编译器的做法，事实上C国际标准自己都说，入栈顺序由编译器自行决定，所以在写程序时不提倡写f(x++,x++)之类的函数调用，由于参数入栈顺序不同导致结果不同，造成程序可移植性问题；这也导致C++编译规定，函数参数默认值的表达式不得包含同一参数表的参数，具体原因参见《C++程序设计精要教程》。（5）关于内存对齐按步长对齐不妥，确切地说是按数据成员的类型对齐，关于更复杂内存布局如包含虚函数和虚基类的情况参见《C++程序设计精要教程》。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "辛苦了，有空看看当复习也不错。", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "文字没看 实例代码扫了两眼 发现不少错误 #include <stdio.h> int main() { \tchar *str = (char*) 0X000007FFF2E5FE2C4; //使用数值表示一个明确的地址 \tstr=\"abc\"; \treturn 0; } 对于支持64bit整型常量的编译环境来说  这段代码不存在会报错的地方 指针指向不合法的内存就不合法吧 你不比较不解引用 没什么关系  然后就是代码里面所有输入unsigned int类型的代码都写错 scanf(\"%ud\",&len) 应该用 %u 而不是%ud 没有%ud 这个控制符 你这里是运气好d后面没有输入项所以没看出问题 你写一个 %ud%ud 就知道错了", "referer": "user-0"}]}
{"question": "初学C语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "刚刚开始学 跟着网课上走  了解的不太多", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "太谢谢了！好人一生平安", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "if(d!=g)后面的逻辑都不对，改成以下即可 if(d==g) { //如果奇偶相同就累加即可     n = n + h; }  h = h * 2; //h和a一起变化即可，不需要m控制  另外，int a = (a-c)/10; 改成 a = (a-c)/10; //不需要重新声明a m变量不需要，可以去掉", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "C语言课不该出这种题，算法吗？也不象，让学生掌握什么？", "referer": "user-0"}]}
{"question": "求教大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在ch2=getchar()之前加一句getchar()处理就好 因为输入a回车时，回车符残留在输入缓存里，所以加一句getchar()清空该回车符即可", "referer": "user-0"}]}
{"question": "请教 遍历list 为什么我得到的值  char * 类型的 不正确呢，整形等是正确的，这里该怎么写，谢谢了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "free(tmpQElemPcm.Pcm_data);//释放                 tmpQElemPcm.Pcm_data释放我应该写在什么位置", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢楼上两位指导", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "list_pcm.push_back(tmpQElemPcm);//list保存了tmpQElemPcm的引用 free(tmpQElemPcm.Pcm_data);//释放tmpQElemPcm的Pcm_data也就等于释放了list_pcm保存的tmpQElemPcm的引用的Pcm_data 所以 memcpy(s_outBuf, (*lit).Pcm_data, (*lit).bufflehead);//这里的(*lit).Pcm_data的内存因为已经在上面释放掉了，所以Pcm_data实际为野指针，它的内存信息是不确定的", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你急匆匆就把内容内存给free掉了， 下面怎么好意思再用呢？  人家内存应该跟你说，离婚了就别再来找我。", "referer": "user-0"}]}
{"question": "各位大佬求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen(\"mike\"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, \"mike\");     FILE* fp = fopen(\"selfSu.txt\", \"wb\");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen(\"selfSu.txt\", \"rb\");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf(\"姓名：%s\\t编号：%d\\t名字长度：%d\\n\", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～ 引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen(\"mike\"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, \"mike\");     FILE* fp = fopen(\"selfSu.txt\", \"wb\");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen(\"selfSu.txt\", \"rb\");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf(\"姓名：%s\\t编号：%d\\t名字长度：%d\\n\", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～ 引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen(\"mike\"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, \"mike\");     FILE* fp = fopen(\"selfSu.txt\", \"wb\");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen(\"selfSu.txt\", \"rb\");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf(\"姓名：%s\\t编号：%d\\t名字长度：%d\\n\", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～   谢谢~", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "哦，名字也没有写进去。 题目需要你另外写名字，不能光写结构体。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "显然你缺少了malloc，所以名字没地方放。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen(\"mike\"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, \"mike\");     FILE* fp = fopen(\"selfSu.txt\", \"wb\");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen(\"selfSu.txt\", \"rb\");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf(\"姓名：%s\\t编号：%d\\t名字长度：%d\\n\", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～ 楼主这么定义结构体和读取很容易导致内存溢出～在main函数里释放了。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen(\"mike\"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, \"mike\");     FILE* fp = fopen(\"selfSu.txt\", \"wb\");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen(\"selfSu.txt\", \"rb\");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf(\"姓名：%s\\t编号：%d\\t名字长度：%d\\n\", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～", "referer": "user-0"}]}
{"question": "新手，错误提示none of the 2 overloads can convert parameter 1 from type 'float'是怎么回事ne", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "还 缺少头文件 敲错函数名 多余的返回值 两个差分函数的参数应为double数组 (int)那些行都是多余的 等", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 forever74 的回复:我不信，你看着办。谢谢啦", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 7 楼 真相重于对错 的回复:函数的声明和定义与函数的调用不一致。比如 dchafen(lx[50], ca[50]); //调用 float dchafen(int t[], int v[])；//声明 参数是 数组，而你传给他一个整数，如何能够不出错？ 建议把c的语法学好 引用 7 楼 真相重于对错 的回复:函数的声明和定义与函数的调用不一致。比如 dchafen(lx[50], ca[50]); //调用 float dchafen(int t[], int v[])；//声明 参数是 数组，而你传给他一个整数，如何能够不出错？ 建议把c的语法学好这个是后面修改过的，谢谢提醒", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "函数的声明和定义与函数的调用不一致。比如 dchafen(lx[50], ca[50]); //调用 float dchafen(int t[], int v[])；//声明 参数是 数组，而你传给他一个整数，如何能够不出错？ 建议把c的语法学好", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "我不信，你看着办。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 4 楼 forever74 的回复:还是不行是肯定的，问题是还出这个错误？嗯，还是这个问题", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "还是不行是肯定的，问题是还出这个错误？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 forever74 的回复:把所有的float都换成double就不会出这个错误了。还是不行，是不是我的函数结构有问题呀", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "还是不行，是不是我这个函数结构有问题呀", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "把所有的float都换成double就不会出这个错误了。", "referer": "user-0"}]}
{"question": "请问为啥上面调用的是位置，下面掉用的是该函数呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "就是关于L的调用，L是一个线性表的数据结构的变量", "referer": "user-0"}]}
{"question": "【C语言】新手求教一些关于指针的问题，两指针变量相等的相关问题，求教大佬们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "指针就是地址，地址就是指针；指针变量是一个变量，它保存了基本类型变量的地址。 如果指针变量p保存了变量a的地址，那么称作p指向了a，*p 就是变量a。 如果p是一个指针变量，*p 表示了以 p 的内容为地址的变量，就是p指向的变量。 举例如下：                     int a ;  //定义int类型变量                     int *p = &a;   //变量 p 是一个 int* 类型的一级指针变量，&是取地址符，p保存了a 的地址                     cout << *p <<endl; //输出 p 指向变量的值，即输出a的值                     cout <<  p << endl; //输出 p 的值，即输出变量a在内存中的地址                     int **q;  //定义二级指针变量                     q = &p; // 二级指针变量q保存了一级指针变量p的地址                     cout << q <<endl; //输出指针变量p在内存中的地址                     cout <<  *q << endl; //输出q指向变量的值，即变量p的值，即a的地址                     cout <<  **q << endl; //可以这样理解  cout<<*(*q), 等价于 cout <<*p， 即输出a的值", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1 如果想让两个指针变量指向的地址相同，用q=p；如果想让两个指针变量指向的地址不同但地址存储的值相同，用*q=*p；为什么去掉q=&b会出错？因为指针变量要初始化指向一个有效的地址才能使用，所以没有q=&b，q就是个野指针 2 q=p，是让两个指针变量指向的同一个地址；*q=*p是让两个指针本来指向的地址的值相同。①p指向a的地址，q指向b的地址，*q=*p是让两个地址的值相同，所以b地址的值也变成了20；②b为啥变了？参考① 3 int *t = (int*)p是定义一个int*类型的指针变量t，并把p指向的地址转换为int*类型后赋给t；*(int*)p是把p指向的地址转换为int*，然后取出改地址的值，这样得到的值就是一个int类型", "referer": "user-0"}]}
{"question": "SQL中如何把A表的字段数据更新到B表的字段", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该去到SQL论坛问吧。", "referer": "user-0"}]}
{"question": "求各位数字之后和反序数的代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 智者知已应修善业的回复:可以一气呵成的为何要写2个? 可能看起来简洁", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "可以一气呵成的为何要写2个?", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "//2 反序数 #include<stdio.h> int main() {     int n=0,res=0;     scanf(\"%d\",&n);          while(n){          res = res*10 + n%10;          n /= 10;     }     printf(\"%d\",res);      return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "反序数 int main() {     int n=0, res=0;     scanf(“%d”, &n);     for(; n>0; n/=10)          res = res*10 + n%10;     printf(“%d”, res);     return 0; }", "referer": "user-0"}]}
{"question": "c语言中结构体数组后加一个点一个变量是为什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议查一下结构体变量如何访问其元素，同事也看一下结构体指针变量如何访问结构体元素；  这是基本的语法知识，建议翻翻书或者网上搜一下", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型。number是成员变量，作用是数组的一个成员info[i]，可以用调用多个属性变量", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "参考：https://blog.csdn.net/yanggangclcsdn/article/details/49718131?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-13.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-13.control", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "啥叫结构体？", "referer": "user-0"}]}
{"question": "求助代码的含义", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "理解和讨论之前请先学会如何观察！   VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898", "referer": "user-0"}]}
{"question": "While 语句的一点问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 楼主 玖歌star 的回复:while ((txt[next++=getchar())! ='\\n'可以用大括号吗？谢谢先把语法错误改了 然后重新组织一下问题 你的[ 没有对应的]", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 楼主 玖歌star 的回复:while ((txt[next++=getchar())! ='\\n'可以用大括号吗？谢谢 写得也不合格式也不合逻辑!如果next是数值型怎么能赋值字符型?比较表达式也不对怎么能放在括号外?", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "用大括号，没明白楼主的意思，想要实现什么？在()中很少见到用{}大括号的", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}]}
{"question": "寻找250", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 forever74的回复:题目指出，输入不知道多少个绝对值不超过1000的整数，因此上述代码均不符合题意，因为一旦第1024个才符合要求那就都无法完成任务。 1024？？？啥意思？？？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 自信男孩的回复:[quote=引用 5 楼 maggielve 的回复:][quote=引用 2 楼 自信男孩的回复:]#include <stdio.h>  int main() {     int a[1000];     char buf[1024];     //int i = 1;      fgets(buf, sizeof(buf), stdin);       int i = 0, pos = 0, k = 0;     while (buf[i]) {         if (buf[i] == '\\n' || buf[i] == 0 || buf[i] == ' ') {             if (buf[i]  == '\\n' || buf[i] == 0)                 break;             sscanf(buf+pos, \"%d\", &a[k]);             printf(\"%d\\n\", a[k]);             k++;             pos = i+1;         }         i++;     }     buf[i] = 0;     sscanf(buf+pos, \"%d\", &a[k]);     k++;      /*     while( getchar() != '\\n' )     {         scanf(\"%d\",&a[i]);         i++;     }     */     for( int i = 0 ; i < k; i++ )         if( a[i] == 250 )         {             //printf(\"%d\",i);             printf(\"%d\",i+1);             break;         }     return 0; }  供参考～  这次我应该又把简单问题复杂度话了～  我严重怀疑你是在我面前装逼，我都看不懂你的代码写的是什么？[/quote]  既然看不懂，就当我没回复过，以后你的帖子我就bypass   #include<stdio.h> int main() {     int a,i;     i=0;     while(1)     {         scanf(\"%d\",&a);         if(a==250)\tbreak;         i++;     }     printf(\"%d\\n\",i+1);     return 0; }  网上的，比较简单。但是楼主比较懒～[/quote] 额，你用c语言基础知识写代码就行，我连指针还没学呢！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 5 楼 maggielve 的回复:[quote=引用 2 楼 自信男孩的回复:]#include <stdio.h>  int main() {     int a[1000];     char buf[1024];     //int i = 1;      fgets(buf, sizeof(buf), stdin);       int i = 0, pos = 0, k = 0;     while (buf[i]) {         if (buf[i] == '\\n' || buf[i] == 0 || buf[i] == ' ') {             if (buf[i]  == '\\n' || buf[i] == 0)                 break;             sscanf(buf+pos, \"%d\", &a[k]);             printf(\"%d\\n\", a[k]);             k++;             pos = i+1;         }         i++;     }     buf[i] = 0;     sscanf(buf+pos, \"%d\", &a[k]);     k++;      /*     while( getchar() != '\\n' )     {         scanf(\"%d\",&a[i]);         i++;     }     */     for( int i = 0 ; i < k; i++ )         if( a[i] == 250 )         {             //printf(\"%d\",i);             printf(\"%d\",i+1);             break;         }     return 0; }  供参考～  这次我应该又把简单问题复杂度话了～  我严重怀疑你是在我面前装逼，我都看不懂你的代码写的是什么？[/quote]  既然看不懂，就当我没回复过，以后你的帖子我就bypass   #include<stdio.h> int main() {     int a,i;     i=0;     while(1)     {         scanf(\"%d\",&a);         if(a==250)\tbreak;         i++;     }     printf(\"%d\\n\",i+1);     return 0; }  网上的，比较简单。但是楼主比较懒～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "题目指出，输入不知道多少个绝对值不超过1000的整数，因此上述代码均不符合题意，因为一旦第1024个才符合要求那就都无法完成任务。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 djmjxm的回复:为什么a[0]不符值呢 444，666，250，-590，     520是第三个数", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:#include <stdio.h>  int main() {     int a[1000];     char buf[1024];     //int i = 1;      fgets(buf, sizeof(buf), stdin);       int i = 0, pos = 0, k = 0;     while (buf[i]) {         if (buf[i] == '\\n' || buf[i] == 0 || buf[i] == ' ') {             if (buf[i]  == '\\n' || buf[i] == 0)                 break;             sscanf(buf+pos, \"%d\", &a[k]);             printf(\"%d\\n\", a[k]);             k++;             pos = i+1;         }         i++;     }     buf[i] = 0;     sscanf(buf+pos, \"%d\", &a[k]);     k++;      /*     while( getchar() != '\\n' )     {         scanf(\"%d\",&a[i]);         i++;     }     */     for( int i = 0 ; i < k; i++ )         if( a[i] == 250 )         {             //printf(\"%d\",i);             printf(\"%d\",i+1);             break;         }     return 0; }  供参考～  这次我应该又把简单问题复杂度话了～  我严重怀疑你是在我面前装逼，我都看不懂你的代码写的是什么？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "哈哈哈，你不要笑我了，好不好？", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "为什么a[0]不符值呢", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "#include <stdio.h>  int main() {     int a[1000];     char buf[1024];     //int i = 1;      fgets(buf, sizeof(buf), stdin);       int i = 0, pos = 0, k = 0;     while (buf[i]) {         if (buf[i] == '\\n' || buf[i] == 0 || buf[i] == ' ') {             if (buf[i]  == '\\n' || buf[i] == 0)                 break;             sscanf(buf+pos, \"%d\", &a[k]);             printf(\"%d\\n\", a[k]);             k++;             pos = i+1;         }         i++;     }     buf[i] = 0;     sscanf(buf+pos, \"%d\", &a[k]);     k++;      /*     while( getchar() != '\\n' )     {         scanf(\"%d\",&a[i]);         i++;     }     */     for( int i = 0 ; i < k; i++ )         if( a[i] == 250 )         {             //printf(\"%d\",i);             printf(\"%d\",i+1);             break;         }     return 0; }  供参考～  这次我应该又把简单问题复杂度话了～", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "供参考：#include \"stdio.h\" int main() { \tint a[1000]; \tint i = 1，j; \twhile( getchar() != '\\n' ) \t{ \t\tscanf(\"%d\",&a[i]); \t\ti++; \t} \tfor( j = 1;j<i; j++ ) \t\tif( a[j] == 250 ) \t\t{ \t\t\tprintf(\"%d\",j); \t\t\tbreak;\t \t\t}  \treturn 0; }", "referer": "user-0"}]}
{"question": "新手实在是想不通为啥总会重定义", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:头文件上加一句 #pragma once  试试 换成#pragma once就好了，谢谢！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qq_33487700 的回复:将  #ifndef #define  #endif  换为 #pragma once 换成#pragma once就可以了，谢谢！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 forever74 的回复:[quote=引用 楼主 return_master 的回复:]我所有的头文件都用#ifndef/#define/#endif处理过了，但还是重定义。 如图，这个Bits64是我定义的联合体，只在这里定义过一次，其他地方都没出现过，为啥还是会重定义  你敲出来的内容准确度存疑。 图片上有个struct calsses就疑似错误。  所以建议你检查一下你的#ifndef后面的内容和#define后面是否真的一致。[/quote] 大佬眼力真好", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 楼主 return_master 的回复:我所有的头文件都用#ifndef/#define/#endif处理过了，但还是重定义。 如图，这个Bits64是我定义的联合体，只在这里定义过一次，其他地方都没出现过，为啥还是会重定义  你敲出来的内容准确度存疑。 图片上有个struct calsses就疑似错误。  所以建议你检查一下你的#ifndef后面的内容和#define后面是否真的一致。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "将  #ifndef #define  #endif  换为 #pragma once", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "头文件上加一句 #pragma once  试试", "referer": "user-0"}]}
{"question": "打印*菱形", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可参", "referer": "user-0"}]}
{"question": "持续写文件到ssd，会造成写入速度变慢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同意3楼和8楼", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "还有一个毛病就是你这种频繁写入的工作条件下，SSD的寿命比常规机械硬盘短得多。  所以如果数据量真的大，长久保存的还是用常规硬盘，追求性能的还是用RAMDISK。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 6 楼 baidu_35309186 的回复:引用 3 楼 早打大打打核战争 的回复:现在的SSD普遍使用TLC甚至QLC，芯片的实际写入性能是很低的（比机械硬盘还低），厂商吹嘘的性能指标实际是靠里面的SLC缓存带起来的，所以持续写入大量数据掉速是很正常的用的是kioxia的nvme ssd，我写demo把一个100M的文件重复写到里面去都不行，所以这是硬盘问题？无解了？  如果条件允许的话，你可以把SSD上的数据备份出来，然后作为数据盘（而不是系统盘）接到电脑上，格式化，用大文件将其写满，看总共用时，就能计算出它的实际写入性能了。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 早打大打打核战争 的回复:现在的SSD普遍使用TLC甚至QLC，芯片的实际写入性能是很低的（比机械硬盘还低），厂商吹嘘的性能指标实际是靠里面的SLC缓存带起来的，所以持续写入大量数据掉速是很正常的用的是kioxia的nvme ssd，我写demo把一个100M的文件重复写到里面去都不行，所以这是硬盘问题？无解了？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:fopen第二个参数里有b吗？有的", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 3 楼 早打大打打核战争 的回复:现在的SSD普遍使用TLC甚至QLC，芯片的实际写入性能是很低的（比机械硬盘还低），厂商吹嘘的性能指标实际是靠里面的SLC缓存带起来的，所以持续写入大量数据掉速是很正常的 学到了", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "现在的SSD普遍使用TLC甚至QLC，芯片的实际写入性能是很低的（比机械硬盘还低），厂商吹嘘的性能指标实际是靠里面的SLC缓存带起来的，所以持续写入大量数据掉速是很正常的", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "fopen第二个参数里有b吗？", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "在同一个文件夹下，不要存放太多的文件！我们每次创建一个文件FATFS系统都要进行扫描有没有这个文件，没有就创建，随着新建文件的增多会导致扫描的时间变长，导致文件建立效率降低，时间变长。当然也可能有其他原因", "referer": "user-0"}]}
{"question": "看到一个结构体的练习，不太明白输出结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为++a[i].s[3]寻址发生了错误，去掉就可以 正常输出了 #include<stdio.h> struct s1 { \t char* s; \tint i; \tstruct s1* sip;  }; int main() { \tstatic s1 a[] = { { const_cast < char*>(\"abcd\"),1,a + 1},{const_cast <char*>(\"efgh\"),2,a + 2},{const_cast <char*>(\"ijk1\"),3,a} }; \tint i; \tfor (int i=0;i<2;i++) \t{ \t\tprintf(\"%d\\n\", --a[i].i); \t\tprintf(\"%c\\n\", a[i].s[3]); \t} \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先了解了a[i].i和a[i].s[3]是输出什么，然后明白了这个，就好理解前面加++还是--了。  自增和自减，分为前置和后置，优先级不一样，可以网上搜一下，学习一下；总要自己动手学吧，不能只会了这个问题，以后遇到稍微修改的问题不会了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "供参考：#include<stdio.h> struct s1 {    char* s;     int  i;   struct s1* sip; };  int main() {     static s1 a[] = { { const_cast < char*>(\"abcd\"),1,a + 1},{const_cast <char*>(\"efgh\"),2,a + 2},{const_cast <char*>(\"ijk1\"),3,a} };     int i;     for (int i=0;i<2;i++)       {          printf(\"%d\\n\", --a[i].i);          printf(\"%c\\n\", ++a[i].s[3]);       }      return 0; }  //输出：对值的操作，不存在寻址的问题 //0   i=0: --a[i].i        a[0].i = 1         --a[0].i = 0 //e   i=0: ++a[i].s[3]     a[0].s[3] = 'd'   ++a[0].s[3] = 'e'  //1   i=1: --a[i].i        a[1].i = 2        --a[1].i = 1 //i   i=1: ++a[i].s[3]     a[1].s[3] = 'h'   ++a[1].s[3] = 'i'", "referer": "user-0"}]}
{"question": "求教 是哪里出问题了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1 的回复：看不懂日语，只能从语法错误修改下，供参考：#include<stdio.h> #include<stdlib.h> #include<time.h>  int main(void) {     int retry = 0;     int card;        //这里已经定义了card     srand(time(NULL));     card = rand() % 13 + 1;//int card = rand() % 13 + 1;     printf(\"card = %d\\n\", card);          if (card > 21){         switch (card) {                if (card == 1) {  //这里这条件永远不会满足                printf(\"あなたの勝ち\\n\");                break;                }                else {                      printf(\"あなたの負け\\n\");                      break;                }         }     }     printf(\"もう一度カードを引くか確認\\n\");     printf(\"retryを入力してください。\\n\");      scanf(\"%d\", &retry);//scanf_s(\"%d\", &retry);     switch (retry){            if (retry == 0) {                break;            }     }while(retry);//while (card);//?这里就死循环了      return 0; }我私信你了 老哥", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "看不懂日语，只能从语法错误修改下，供参考：#include<stdio.h> #include<stdlib.h> #include<time.h>  int main(void) {     int retry = 0;     int card;        //这里已经定义了card     srand(time(NULL));     card = rand() % 13 + 1;//int card = rand() % 13 + 1;     printf(\"card = %d\\n\", card);          if (card > 21){         switch (card) {                if (card == 1) {  //这里这条件永远不会满足                printf(\"あなたの勝ち\\n\");                break;                }                else {                      printf(\"あなたの負け\\n\");                      break;                }         }     }     printf(\"もう一度カードを引くか確認\\n\");     printf(\"retryを入力してください。\\n\");      scanf(\"%d\", &retry);//scanf_s(\"%d\", &retry);     switch (retry){            if (retry == 0) {                break;            }     }while(retry);//while (card);//?这里就死循环了      return 0; }", "referer": "user-0"}]}
{"question": "十进制小数的整数部分，肯定能转成二进制，这个也没错把？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 qybao 的回复:整数部分，单纯的转换为二进制是可以的，但加上小数部分，再结合浮点数的内存存储，那就未必了，因为有精度限制。 谢谢，我问的是，小数的整数部分，应该能转成十进制的吧？也即是整数部分和十进制能一一对应起来？ 仅仅是小数部分不同？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "整数部分，单纯的转换为二进制是可以的，但加上小数部分，再结合浮点数的内存存储，那就未必了，因为有精度限制。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "浮点数是有精度的，并不一定能精确地转成二进制。例如： int main(void) { \tfloat a = 123456789.0f; \tstd::cout << std::fixed << a << std::endl; } 打印结果是：123456792.000000 你看，整数部分转换后的结果就不对了。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "恩，没错，是可以用二进制表示的。确切的说都可以用二进制表示和存储的。因为计算机只认识二进制0和1，不认别的，所以说计算机认识并计算的都是可以用0和1标识的。", "referer": "user-0"}]}
{"question": "请教二进制小数肯定能转成十进制小数，这个没错把？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 oracleperl 的回复:[quote=引用 2 楼 qybao 的回复:]是没错，但是计算机未必能精确把十进制小数表示出来。  我说的是二进制小数，肯定能转成十进制小数，这个没错把？ 比如 .11就是十进制的0.75 .10就是十进制的0.5 .01就是十进制的0.25[/quote] 这个是没错，但转成十进制小数后，它并没有脱离计算机，它并没有实质的脱离计算机中二进制的记录方式，它仍然是保存在计算机中的，这就和保存它的标准、存储方式相关，就会存在误差，建议楼主参考这篇博文：https://www.jianshu.com/p/8ee02e9bb57d", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qybao 的回复:是没错，但是计算机未必能精确把十进制小数表示出来。  我说的是二进制小数，肯定能转成十进制小数，这个没错把？ 比如 .11就是十进制的0.75 .10就是十进制的0.5 .01就是十进制的0.25", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "二进制小数肯定能转成十进制小数，这个没错； 但用32位或64位保存的二进制小数，不一定都能表示成包含15位有效数字的十进制小数。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "不考虑 无限循环小数 无限不循环小数之类的情况 是的", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "是没错，但是计算机未必能精确把十进制小数表示出来。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 4 楼 qzjhjxj 的回复:[quote=引用 3 楼 oracleperl 的回复:][quote=引用 2 楼 qybao 的回复:]是没错，但是计算机未必能精确把十进制小数表示出来。  我说的是二进制小数，肯定能转成十进制小数，这个没错把？ 比如 .11就是十进制的0.75 .10就是十进制的0.5 .01就是十进制的0.25[/quote] 这个是没错，但转成十进制小数后，它并没有脱离计算机，它并没有实质的脱离计算机中二进制的记录方式，它仍然是保存在计算机中的，这就和保存它的标准、存储方式相关，就会存在误差，建议楼主参考这篇博文：https://www.jianshu.com/p/8ee02e9bb57d[/quote] 谢谢老师： 二进制的0.125  0.5 0.75转成十进制小数，怎么会有误差呢？用0和1都能表示的啊 你的这篇文章，图片不能显示的", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "理论上是没错的。我想你的为不在这里，而在二进制口算的是多少，但是实际上对应的十进制不是。  建议楼主查一下浮点数在内存里的表示。网上是有的，建议好好查查，仔细看一些别人文章的介绍，书本上也是有的，浮点数的表示比较复杂，不能按照 整型数的去理解～", "referer": "user-0"}]}
{"question": "各位大佬，vscode不能识别头文件，如何设置才会识别呢？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考下这几篇文章：https://blog.csdn.net/weixin_36224284/article/details/111814538?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-2&spm=1001.2101.3001.4242  https://blog.csdn.net/weixin_39553753/article/details/111732093?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-3&spm=1001.2101.3001.4242", "referer": "user-0"}]}
{"question": "请教如何保证两个十进制的float数值相加相减等，肯定能得到正确的结果？谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 oracleperl 的回复:[quote=引用 1 楼 早打大打打核战争 的回复:]你得先定义“正确”，比如精确到小数点后多少位 比如两位？如何做到？[/quote]  最简单的方法，使用定点小数运算，比如需要精确到小数点后两位，可以把浮点数放大1000倍，转化为整数再运算，最终结果再转化回去就可以了。早期计算机是不支持浮点运算的，涉及到小数的计算，通常都会使用定点小数格式，因为这种格式以整数方式存储小数，隐含有一个固定的小数点位置，所以称之为定点小数。现代的一些软件，为了保证小数运算的精度，比如VB、.net、Delphi中的currency类型，仍然使用定点小数格式。 另一个方法，使用intel DFP，十进制浮点库，这个库实现了IEEE754-2008定义的十进制浮点类型运算，可以免费使用：https://software.intel.com/content/www/us/en/develop/articles/intel-decimal-floating-point-math-library.html", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "实际应用中的定点小数，比如VB、.net、Delphi中的currency类型，是放大10000倍存储为整数，固定四位小数，可以保证三位小数的运算精度，参考：https://docs.microsoft.com/en-us/office/vba/language/reference/user-interface-help/currency-data-type", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 7 楼 oracleperl 的回复:[quote=引用 6 楼 早打大打打核战争 的回复:]定点小数存储为整数，不遵循IEEE754的标准，比如12345.6789，固定四位小数，存储为整数123456789 嗯，我可以理解，小数也当作整数 但是比如工资系统，两位小数，乘以100存储为整数，但是最终还是要除以100的啊，这么一除，不就有不对了？[/quote]  你要精确到小数点后两位，就要存储三位小数", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 早打大打打核战争 的回复:定点小数存储为整数，不遵循IEEE754的标准，比如12345.6789，固定四位小数，存储为整数123456789 嗯，我可以理解，小数也当作整数 但是比如工资系统，两位小数，乘以100存储为整数，但是最终还是要除以100的啊，这么一除，不就有不对了？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "定点小数存储为整数，不遵循IEEE754的标准，比如12345.6789，固定四位小数，存储为整数123456789", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 4 楼 早打大打打核战争 的回复:[quote=引用 2 楼 oracleperl 的回复:][quote=引用 1 楼 早打大打打核战争 的回复:]你得先定义“正确”，比如精确到小数点后多少位 比如两位？如何做到？[/quote]  最简单的方法，使用定点小数运算，比如需要精确到小数点后两位，可以把浮点数放大1000倍，转化为整数再运算，最终结果再转化回去就可以了。早期计算机是不支持浮点运算的，涉及到小数的计算，通常都会使用定点小数格式，因为这种格式以整数方式存储小数，隐含有一个固定的小数点位置，所以称之为定点小数。现代的一些软件，为了保证小数运算的精度，比如VB、.net、Delphi中的currency类型，仍然使用定点小数格式。 另一个方法，使用intel DFP，十进制浮点库，这个库实现了IEEE754-2008定义的十进制浮点类型运算，可以免费使用：https://software.intel.com/content/www/us/en/develop/articles/intel-decimal-floating-point-math-library.html [/quote] 谢谢，我先把原理学习清楚，目前知道了，根据IEEE754标准 1. 只有以5结尾的小数，才能二进制和十进制互转，不会有精度问题 2. 二进制小数肯定可以分毫不差转成十进制，但是十进制小数只有以5结尾的小数才能分毫不差转成二进制  另外对于你说的定点数，我不是很理解，再怎么顶点，不也是小数吗？难道不遵循IEEE754的标准吗？ 谢谢", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "浮点数都是有精度的，别说保证运算后的结果“正确”了。你就是单定义一个float变量，它的值都不一定“正确”。 int main(void) { \tfloat a = 123456789.0f; \tstd::cout << std::fixed << a << std::endl; } 这段代码运行一下试试看。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 早打大打打核战争 的回复:你得先定义“正确”，比如精确到小数点后多少位 比如两位？如何做到？", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "你得先定义“正确”，比如精确到小数点后多少位", "referer": "user-0"}]}
{"question": "请教，变量名储存在哪里？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 qq_16774199 的回复:[quote=引用 4 楼 user-3的回复:]a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1 你好。这是逼着我学汇编呢[/quote] 看来你快开窍了。  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 赵4老师 的回复:[quote=引用 5 楼 qq_16774199 的回复:][quote=引用 4 楼 user-3的回复:]a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1 你好。这是逼着我学汇编呢[/quote] 看来你快开窍了。 [/quote]  我已经把java基础知识过了一遍，最近又把学习C语言的事抱起来，原因就是想弄懂内存的事。 仅仅为了弄懂内存去学汇编，时间成本太高。坐飞机两千公里到兰州，就为了吃正宗的兰州拉面，多数人是不会。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 7 楼 赵4老师 的回复:[quote=引用 5 楼 qq_16774199 的回复:][quote=引用 4 楼 user-3的回复:]a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1 你好。这是逼着我学汇编呢[/quote] 看来你快开窍了。  [/quote]  你说得都很有道理，不想学汇编的原因是，它也要花费时间，每个人时间都很宝贵。 另外，用汇编把内存学明白了，可是它对写好安卓APP有帮助吗？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "局部变量储存在函数栈里。   全局变量和静态变量存放在数据段  还有堆，是动态申请的空间存放在堆上～", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 4 楼 user-3的回复:a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1 你好。这是逼着我学汇编呢", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "obj文件也应该算", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "纠正楼上 pdf文件  →  pdb文件", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "变量名存在于 源代码 编译器 pdf文件 …… 中", "referer": "user-0"}]}
{"question": "请问float值是如何表示的？(1 bit)  指数(8 bits)  尾数(23 bits) 小数点在哪里？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 10 楼 qybao 的回复:那是人类存储的思维，但计算机的思维不一样，计算机就变成1.0*10^-2，存1.0和指数-2，明白了吗？如果是0.05就是5.0*10^-2，也就是整数部分必须大于0，这是计算机的规则（除非你发明另一种不按规则出牌的计算机）。 上面举的例子是10进制的，如果是2进制，只有0和1，按照整数大于0的规则就注定了整数只能是1，所以尾数的第一位肯定是1就是这么来的。 我要保存一个0.00 何来1?", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "看错了，你是说存0.00，我还以为是0.01 0是特殊值，浮点数有单独的定义 也就是说计算机的浮点存储，有针对0专门做了相应的规则 具体可以参考下 https://zh.wikipedia.org/wiki/IEEE_754", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 11 楼 oracleperl 的回复:我要保存一个0.00 何来1? 你要谁来保存，你自己保存可以用0.01，但是计算机帮你保存就不是这样了，就会转成符合计算机的格式来保存 就好想你要保存一个汉子“问”，你认为计算是直接保存“问”这个字吗？如果是这样，那就不会有不同国家的编码问题了。 所以，你想存，和计算机能存，是两码是，就好比人家做不了的是，你还能逼着人家做吗？你要想让人家做好，你就要遵守人家的规则，否则人家就是给你做错。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "浮点数的0只有符号位是0或者1，其余全0", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 5 楼 qybao 的回复:[quote=引用 4 楼 oracleperl 的回复:] “浮点数存储格式” 举个例子？ 我只知道浮点数float 32bits构成 ，如下： 符号(1 bit)  指数(8 bits)  尾数(23 bits)  实在不知道小数点在哪，也不知道指数(8 bits)是如何表示的，每一位分别啥意思 参考一下吧 https://www.jianshu.com/p/8ee02e9bb57d [/quote] 谢谢，图不能显示", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "那是人类存储的思维，但计算机的思维不一样，计算机就变成1.0*10^-2，存1.0和指数-2，明白了吗？如果是0.05就是5.0*10^-2，也就是整数部分必须大于0，这是计算机的规则（除非你发明另一种不按规则出牌的计算机）。 上面举的例子是10进制的，如果是2进制，只有0和1，按照整数大于0的规则就注定了整数只能是1，所以尾数的第一位肯定是1就是这么来的。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 8 楼 qybao 的回复:看了一些资料， 所有的浮点数，都是1.XXXXXX * 2的N次方的形式 而浮点数的小数位数，是指数的值决定的？ =》不是，因为这是二进制形式，要转成10进制才知道小数位数  大致好像是这样，但是没完全看懂，好像有四种规则，位数的第一位肯定是1？这些我都不理解。 《深入理解计算机系统》的有关于这方面的说明，但是没有例子，文字也很难懂，看不懂。 =》尾数第一位是1，这是默认规则，因为不允许0.xxxx以0开头的小数的方式（类似于十进制的科学计数法，整数大于0小于10），因为二进制只有0和1，又因为规定第一位不能位0，所以第一位只能是1，为了省存储空间，就可以把第一位省略掉（因为第一位必然是1）  没看懂，那我存储小数 0.01，难道第一位不是0吗？", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "看了一些资料， 所有的浮点数，都是1.XXXXXX * 2的N次方的形式 而浮点数的小数位数，是指数的值决定的？ =》不是，因为这是二进制形式，要转成10进制才知道小数位数  大致好像是这样，但是没完全看懂，好像有四种规则，位数的第一位肯定是1？这些我都不理解。 《深入理解计算机系统》的有关于这方面的说明，但是没有例子，文字也很难懂，看不懂。 =》尾数第一位是1，这是默认规则，因为不允许0.xxxx以0开头的小数的方式（类似于十进制的科学计数法，整数大于0小于10），因为二进制只有0和1，又因为规定第一位不能位0，所以第一位只能是1，为了省存储空间，就可以把第一位省略掉（因为第一位必然是1）", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "看了一些资料， 所有的浮点数，都是1.XXXXXX * 2的N次方的形式 而浮点数的小数位数，是指数的值决定的？  大致好像是这样，但是没完全看懂，好像有四种规则，位数的第一位肯定是1？这些我都不理解。 《深入理解计算机系统》的有关于这方面的说明，但是没有例子，文字也很难懂，看不懂。", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "引用 4 楼 oracleperl 的回复:“浮点数存储格式” 举个例子？ 我只知道浮点数float 32bits构成 ，如下： 符号(1 bit)  指数(8 bits)  尾数(23 bits)  实在不知道小数点在哪，也不知道指数(8 bits)是如何表示的，每一位分别啥意思 参考一下吧 https://www.jianshu.com/p/8ee02e9bb57d", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 2 楼 qybao 的回复:按照浮点数存储格式把数算出来就知道小数点在哪了 “浮点数存储格式” 举个例子？ 我只知道浮点数float 32bits构成 ，如下： 符号(1 bit)  指数(8 bits)  尾数(23 bits)  实在不知道小数点在哪，也不知道指数(8 bits)是如何表示的，每一位分别啥意思", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:浮点数格式 http://bbs.csdn.net/topics/390676437 看不懂", "referer": "user-0"}, {"cid": "13", "user": "user-1", "content": "按照浮点数存储格式把数算出来就知道小数点在哪了", "referer": "user-0"}, {"cid": "14", "user": "user-3", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0"}]}
{"question": "请教这句代码的意思", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼上正解！同时满足不是字符Y和字符N的情况下才执行 WEONG", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "判断ch是否为'y'和'n'，即如果不是'y'同时不是'n'，则执行WRONG();函数", "referer": "user-0"}]}
{"question": "谁先倒", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考下这篇博客：https://blog.csdn.net/21aspnet/article/details/174326", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "为什么加上\\n，就不对了呢？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "第12行多打了  \\n   scanf(\"%d %d %d %d\",&a[i],&b[i],&c[i],&d[i]);", "referer": "user-0"}]}
{"question": "在校内oj系统中，老是出现Presentation Error,有懂的哥帮忙看下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 10 楼 h2plus0 的回复:这道题可能是不是要处理一种特殊情况， 就是当最大值的idx是0的时候，那时交换要判断一下 ，分别处理  。。。。 temp = a[0];     a[0] = a[min];     a[min] = temp;  // ----------------------------------- 加上这段     if(max==0) {     \tmax = min;     } //----------------------------------      temp = a[n - 1];     a[n - 1] = a[max];     a[max] = temp; 。。。。。。。牛逼！ 这回通过了，谢了哥！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这道题可能是不是要处理一种特殊情况， 就是当最大值的idx是0的时候，那时交换要判断一下 ，分别处理  。。。。 temp = a[0];     a[0] = a[min];     a[min] = temp;  // ----------------------------------- 加上这段     if(max==0) {     \tmax = min;     } //----------------------------------      temp = a[n - 1];     a[n - 1] = a[max];     a[max] = temp; 。。。。。。。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 7 楼 自信男孩 的回复:#include <stdio.h> #include<stdlib.h>    int main() {     int n, j = 1;     int max, min, temp;     int *a = NULL;      scanf(\"%d\", &n);     //int *a = (int *)malloc(sizeof(int)*n);     a = (int *)malloc(sizeof(int)*n);     for (int i = 0; i < n; i++) {         scanf(\"%d\", &a[i]);     }     min = max = 0;     while (j < n) {         if (a[j] > a[max])             max = j;         if (a[j] < a[min])             min = j;         j++;     }     temp = a[0];     a[0] = a[min];     a[min] = temp;     temp = a[n - 1];     a[n - 1] = a[max];     a[max] = temp;     for (j = 0; j< n - 1; j++)         printf(\"%d \", a[j]);     printf(\"%d\\n\", a[n - 1]);   //这里/n我加没加也都是通过不了     free(a);     return 0; } 再试一下，怀疑你提交的服务器的编译问题，编译不通过；不会吧，要是最后输出不做最后一个元素特殊处理，就都是元素+空格的话题是PE错误，就应该大致都是对的。之前有个问题我也是PE错误，就是最后空格多出来一个，不过这题就邪门了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 user-3 的回复:这样改下，再试试：#include <stdio.h> #include<stdlib.h>  int main() { \tint n,j; \tint max,min,temp; \tscanf(\"%d\", &n); \tint *a = (int *)malloc(sizeof(int)*n); \tfor ( j = 0; j < n; j++) { \t\tscanf(\"%d\", &a[j]); \t} \tmin=max =0;         j=1; \twhile (j < n) { \t\tif (a[j] > a[max]) \t\t\tmax = j; \t\tif (a[j] < a[min]) \t\t\tmin = j; \t\tj++; \t} \ttemp = a[0]; \ta[0] = a[min]; \ta[min] = temp; \ttemp = a[n - 1]; \ta[n - 1] = a[max]; \ta[max] = temp;  \tfor ( j = 0; j < n ; j++){             if(j==0) \t\tprintf(\"%d\", a[j]);             else printf(\" %d\", a[j]);         }         free(a); \treturn 0; }不行还是通不过", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h> #include<stdlib.h>    int main() {     int n, j = 1;     int max, min, temp;     int *a = NULL;      scanf(\"%d\", &n);     //int *a = (int *)malloc(sizeof(int)*n);     a = (int *)malloc(sizeof(int)*n);     for (int i = 0; i < n; i++) {         scanf(\"%d\", &a[i]);     }     min = max = 0;     while (j < n) {         if (a[j] > a[max])             max = j;         if (a[j] < a[min])             min = j;         j++;     }     temp = a[0];     a[0] = a[min];     a[min] = temp;     temp = a[n - 1];     a[n - 1] = a[max];     a[max] = temp;     for (j = 0; j< n - 1; j++)         printf(\"%d \", a[j]);     printf(\"%d\\n\", a[n - 1]);   //这里/n我加没加也都是通过不了     free(a);     return 0; } 再试一下，怀疑你提交的服务器的编译问题，编译不通过；", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "这样改下，再试试：#include <stdio.h> #include<stdlib.h>  int main() { \tint n,j; \tint max,min,temp; \tscanf(\"%d\", &n); \tint *a = (int *)malloc(sizeof(int)*n); \tfor ( j = 0; j < n; j++) { \t\tscanf(\"%d\", &a[j]); \t} \tmin=max =0;         j=1; \twhile (j < n) { \t\tif (a[j] > a[max]) \t\t\tmax = j; \t\tif (a[j] < a[min]) \t\t\tmin = j; \t\tj++; \t} \ttemp = a[0]; \ta[0] = a[min]; \ta[min] = temp; \ttemp = a[n - 1]; \ta[n - 1] = a[max]; \ta[max] = temp;  \tfor ( j = 0; j < n ; j++){             if(j==0) \t\tprintf(\"%d\", a[j]);             else printf(\" %d\", a[j]);         }         free(a); \treturn 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 3 楼 user-3 的回复:上面多打了z，修改： for(int i = 0;i < n; i++)             printf(\"%d%c\",a[i],(i<n-1)?' ':'\\n');  还是不行，通过不了，我快吐了", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:代码没问题，注意在最后加一句free(a);//释放空间  有问题的地方可能是你的编译器或者服务器上的编译器是C语言的，像 for (int i = 0; i < n-1; i++)这样的在for循环里面定义局部变量的，一般的C语言编译器不支持，是C++的特性。  鉴于上面已经定义了j，后面的循环都可以用j作为循环变量。不行啊哥！还是Wrong Answer#include <stdio.h> #include<stdlib.h>   int main() { \tint n, j = 1; \tint max, min, temp; \tscanf(\"%d\", &n); \tint *a = (int *)malloc(sizeof(int)*n); \tfor (int i = 0; i < n; i++) { \t\tscanf(\"%d\", &a[i]); \t} \tmin = max = 0; \twhile (j < n) { \t\tif (a[j] > a[max]) \t\t\tmax = j; \t\tif (a[j] < a[min]) \t\t\tmin = j; \t\tj++; \t} \ttemp = a[0]; \ta[0] = a[min]; \ta[min] = temp; \ttemp = a[n - 1]; \ta[n - 1] = a[max]; \ta[max] = temp; \tfor (j = 0; j< n - 1; j++) \t\tprintf(\"%d \", a[j]); \tprintf(\"%d\\n\", a[n - 1]);   //这里/n我加没加也都是通过不了 \tfree(a); \treturn 0; }", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "上面多打了z，修改： for(int i = 0;i < n; i++)             printf(\"%d%c\",a[i],(i<n-1)?' ':'\\n');", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "最后输出修改试试：for(int i = 0;i < n; i++)             printf(\"%d%c\",a[i],(i<n-1)?'z':'\\n');", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "代码没问题，注意在最后加一句free(a);//释放空间  有问题的地方可能是你的编译器或者服务器上的编译器是C语言的，像 for (int i = 0; i < n-1; i++)这样的在for循环里面定义局部变量的，一般的C语言编译器不支持，是C++的特性。  鉴于上面已经定义了j，后面的循环都可以用j作为循环变量。", "referer": "user-0"}]}
{"question": "如何把一个变量和一个指针连起来？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <malloc.h> int main() {     int **point;     int *pb;     int a=1,c=3;     point = (int**)malloc(3 * sizeof(int*));     point[0] = &a;     pb=(int *)malloc(1*sizeof(int));     *pb=2;     point[1] = pb;     point[2] = &c;     printf(\"%d, %d, %d\\n\", *point[0], *point[1], *point[2]);//1, 2, 3     free(pb);     free(point);     return 0; }  A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这样point实际变成了一个一维数组，如果要与a连接，只能 *(point+0)=a=1;或者point[0]=a=1;", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "本来应该是point=&a就可以了，但是你又给point动态分配内存了，改了point指向，后面就没法正确释放point的内存了。", "referer": "user-0"}]}
{"question": "关于宏定义问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "老赵你应该先看帖，楼主开篇都说了“如果改变输出到文件再加载进来太麻烦了”，他的要求是输出存到变量中，尽可能简单", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "本来输出到控制台的数据，我想保存到内存变量中如std::string，但现在大量的printf,puts，改代码太麻烦了，我想找一个简便的方法", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "恩，放到一个环形缓存里？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 5 楼 早打大打打核战争 的回复:[quote=引用 4 楼 赵4老师 的回复:]管道重定向可以满足你的需求。  这样太繁琐了，我那样写输出s到文件或者显示即可，其他不需要做任何修改 [/quote] 我是说在执行你原来程序的bat或sh脚本中添加命令行参数比如 1>>mem 2>>mem 其中mem是你自己写的从标准输入读，写到你想放的内存中的一小段程序。  这样做的话，你原来程序连一个字都不用动。  明白吗？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 4 楼 赵4老师 的回复:管道重定向可以满足你的需求。  这样太繁琐了，我那样写输出s到文件或者显示即可，其他不需要做任何修改", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "管道重定向可以满足你的需求。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "只需要在第一个putc之前定义： std::string s; #define putc(c, f) s.insert(s.end(), c) 然后putc输出就到s中了", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "2楼的代码是错的 没参考价值 别学  \treturn ((年 > 400 ? --年 -= 年 / 400 * 400 : 年) ? 365 * 年 + ((年 / 4) - (年 / 100) + (年 / 400)) : 0); 这句话属于自作聪明  --年 -= 年 / 400 * 400 是UB 糟糕的做法  不同编译环境对这个表达式的处理不同", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用计算月的日期试看", "referer": "user-0"}]}
{"question": "illegal use of this type as an expression，下面的代码没问题，就是编译不通过", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "非常感谢，这个问题我搞了很久没解决，现在可以了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "https://blog.csdn.net/fzubbsc/article/details/29354959    #include<stdio.h> #include <stdlib.h> #define N 5  typedef int ElementType;  typedef struct Node {     ElementType data;     struct Node *next; }Node; typedef struct Node* LinkList;  /*===============================================================   CreateLinkList函数功能：   创建链表L, 并将给定数组a, 以及数组中元素个数n，头插入法建立链表   ===================================================================*/ void createlist(LinkList *L,int n,int a[]) {     LinkList p;     int i;      (*L)=(LinkList)malloc(sizeof(Node));  // 建立头结点     (*L)->next=NULL;   // 建立空的单链表(*L)      for(i=0;i<n;i++)     {         p=(LinkList)malloc(sizeof(Node));  // 生成新结点         p->data=a[i];         p->next=(*L)->next;         (*L)->next=p;     } }  /*===============================================================   Outputlist函数功能：   依次输出链表L中的每个数据   ===================================================================*/ void Outputlist(LinkList L) {     LinkList p;     p=L->next;    // 使p指向单链表的第一个结点     printf(\"数组a中的元素为：\");     while(p!=NULL)     {         printf(\"%d \",p->data);         p=p->next;     } }   int main() {     int A[N];     int i;     LinkList pi;    //定义放在这里试试       for(i=0;i<N;i++)     {         scanf(\"%d\",&A[i]);     }      //LinkList q;      createlist(&pi,N,A);     Outputlist(pi);      return 0; }  供参考～", "referer": "user-0"}]}
{"question": "求救", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Pv Ps 两个值传入是否正常？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "if(TIM_GetITStatus(TIM4,TIM_IT_Update)==SET)  {\t \tstatic  u8 tsec;  \tc10ms++; \tif(tsec++>=10) \t\t{ \ttsec=0; \t\tEncoder_TIM=ABS(32768-TIM3 -> CNT);    printf(\" %d \",  Encoder_TIM/30); \t\t\tprintf(\" %3.1f\", pwm   ); \t\t\t      TIM3 -> CNT=32768; \t     \t}\t\tTIM_ClearITPendingBit(TIM4, TIM_IT_Update );  \t }  }这呢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "c10ms=0;了以后就一直跳过这个最大的if了。 除非另有代码修改它。", "referer": "user-0"}]}
{"question": "C语言小白求助！这道题c为什么等于0不等于1？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:还是那个短路取值的问题，建议楼主学习一下||和&&； 谢谢指导我现在明白了！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "++a的结果是1，条件成立，所以||后面的处理被忽略", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "还是那个短路取值的问题，建议楼主学习一下||和&&；", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你的成绩： 免试给满分 或者 （试卷及格 并且 实验及格）  难道你还关注一下实验步骤？ 或许你爱学习，你会，但计算机不会。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "从左向右执行，++a，先加后判断，a已经等于1了，又因为是||符号，后面的就不执行了，所以c也是0", "referer": "user-0"}]}
{"question": "7-76 然后是几点 (20分) ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 9 楼 user-3的回复:这种还是把时间化成0点起分钟数，加减分钟数，再化回去比较简单。 还可以吧，我的代码不算太复杂，", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 user-3的回复:[quote=引用 6 楼 maggielve 的回复:][quote=引用 4 楼 user-3的回复:]好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间[/quote]  喏， 1010，十点十分 -110= -1小时，-50分钟 该是是820啊，哪里不是同一天了？[/quote] 就算这样，我的代码也对啊？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 10 楼 maggielve 的回复:[quote=引用 8 楼 user-3的回复:][quote=引用 6 楼 maggielve 的回复:][quote=引用 4 楼 user-3的回复:]好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间[/quote]  喏， 1010，十点十分 -110= -1小时，-50分钟 该是是820啊，哪里不是同一天了？[/quote] 就算这样，我的代码也对啊？[/quote] 楼主的代码还是有问题的，不然不会三个测试点只通过了一个。 输入2359  001 ,应该得到 000 或2400 ，楼主的代码结果是2360 。 输入900   -1 ，应该是859 ，楼主的代码结果是899。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "还是你厉害[face]monkey2.gif[/face]", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 5 楼 maggielve 的回复:[quote=引用 3 楼 自信男孩的回复:]#include <stdio.h> #include <stdlib.h>  int main() {     int num1, num2, sign = 0;     scanf(\"%d %d\",&num1,&num2);      int h = num1/100;     int m = num1%100;      if (num2 < 0) {         sign = 1;         num2 = abs(num2);     }     int h1 = num2/60;     //int m1 = num2 - h1*60;     int m1 = num2 % 60;       if (sign) {         if (m - m1 < 0) {             m = m + 60 - m1;             h1 += 1;         } else {             m -= m1;         }          if (h - h1 < 0)             h = h + 24 - h1;         else             h = h - h1;     } else {         if (m + m1 > 60) {             h =  (h + h1 + 1) % 24;             m = (m + m1) % 60;         } else {             m = (m + m1) % 60;             h = (h + h1) % 24;         }     }      if( h*100+m >= 0 && h*100+m < 100 )         printf(\"%03d\",h*100+m);     else         printf(\"%d\",h*100+m);       /*     h += h1;     m += m1;     if( m > 60 )     {         h++;         m -= 60;     }     if( h*100+m >= 0 && h*100+m < 100 )         printf(\"%03d\",h*100+m);     else         printf(\"%d\",h*100+m);     */     return 0; } 供参考～ 你又成功的把这一道简单题给弄麻烦了[/quote]  看来我不止一次把简单问题搞复杂了。我记性不好，要不一一罗列一下，至少大于2个吧", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "这种还是把时间化成0点起分钟数，加减分钟数，再化回去比较简单。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "引用 6 楼 maggielve 的回复:[quote=引用 4 楼 user-3的回复:]好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间[/quote]  喏， 1010，十点十分 -110= -1小时，-50分钟 该是是820啊，哪里不是同一天了？", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "供参考：#include \"stdio.h\" int main(int argc, char* argv[]) {  \tint num1, num2; \tscanf(\"%d %d\",&num1,&num2); \t \tint h  = num1/100; \tint m  = num1%100; \tint h1 = num2/60; \tint m1 = num2%60;    //num2 - h1*60;  \th += h1; \tm += m1;         if(m<0){                 h--;                 m += 60;         } \tif( m > 59 ){        //if( m > 60 ) \t\th++; \t\tm -= 60; \t}         if(h<0)  h += 24;   //超过一天的处理         if(h>=24)h -= 24; \tif( h*100+m >= 0 && h*100+m < 100 ) \t\tprintf(\"%03d\",h*100+m); \telse \t\tprintf(\"%d\",h*100+m);  \treturn 0; }", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 4 楼 user-3的回复:好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:#include <stdio.h> #include <stdlib.h>  int main() {     int num1, num2, sign = 0;     scanf(\"%d %d\",&num1,&num2);      int h = num1/100;     int m = num1%100;      if (num2 < 0) {         sign = 1;         num2 = abs(num2);     }     int h1 = num2/60;     //int m1 = num2 - h1*60;     int m1 = num2 % 60;       if (sign) {         if (m - m1 < 0) {             m = m + 60 - m1;             h1 += 1;         } else {             m -= m1;         }          if (h - h1 < 0)             h = h + 24 - h1;         else             h = h - h1;     } else {         if (m + m1 > 60) {             h =  (h + h1 + 1) % 24;             m = (m + m1) % 60;         } else {             m = (m + m1) % 60;             h = (h + h1) % 24;         }     }      if( h*100+m >= 0 && h*100+m < 100 )         printf(\"%03d\",h*100+m);     else         printf(\"%d\",h*100+m);       /*     h += h1;     m += m1;     if( m > 60 )     {         h++;         m -= 60;     }     if( h*100+m >= 0 && h*100+m < 100 )         printf(\"%03d\",h*100+m);     else         printf(\"%d\",h*100+m);     */     return 0; } 供参考～ 你又成功的把这一道简单题给弄麻烦了", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h>  int main() {     int num1, num2, sign = 0;     scanf(\"%d %d\",&num1,&num2);      int h = num1/100;     int m = num1%100;      if (num2 < 0) {         sign = 1;         num2 = abs(num2);     }     int h1 = num2/60;     //int m1 = num2 - h1*60;     int m1 = num2 % 60;       if (sign) {         if (m - m1 < 0) {             m = m + 60 - m1;             h1 += 1;         } else {             m -= m1;         }          if (h - h1 < 0)             h = h + 24 - h1;         else             h = h - h1;     } else {         if (m + m1 > 60) {             h =  (h + h1 + 1) % 24;             m = (m + m1) % 60;         } else {             m = (m + m1) % 60;             h = (h + h1) % 24;         }     }      if( h*100+m >= 0 && h*100+m < 100 )         printf(\"%03d\",h*100+m);     else         printf(\"%d\",h*100+m);       /*     h += h1;     m += m1;     if( m > 60 )     {         h++;         m -= 60;     }     if( h*100+m >= 0 && h*100+m < 100 )         printf(\"%03d\",h*100+m);     else         printf(\"%d\",h*100+m);     */     return 0; } 供参考～", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "我考虑了啊？", "referer": "user-0"}, {"cid": "14", "user": "user-3", "content": "题目里说，流逝的分钟数有可能是负值，楼主你似乎没有考虑。", "referer": "user-0"}]}
{"question": "C语言小白求助！请问这道题怎么理解？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "c的结果是真假，0为假，1为真。  注意||，如果||左边的表达式为真，||后面的表达式不会执行；因此叫做短路取值；  所以b = 2不会执行，所以b=5不变。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我们知道，把整数理解为逻辑值时，非零为真，零为假； 反之把逻辑值用作整数时，真值为1，假值为0； 逻辑运算符 && 和 || 在左操作数能确定运算结果时会短路跳过右操作数。", "referer": "user-0"}]}
{"question": "求帮助，初学C语言输入三个数没反应，输入十个数时，直接结束", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学习了，小白路过", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "main前面要有int scanf里面不要有\\n", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "重发一遍：…… #include <stdio.h>  int main(void) { int a, b, n;  printf(\"输入三个数：\\n\"); scanf(\"%d %d %d\", &a, &b, &n); if(n >= 0) {      if(a > b)      printf(\"%d\", a); } else printf(\"%d\", b);  return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "1、旧版本的C语言写法是main()，现在新规范写法是int main(void)，不过可能在老编译器上无法运行。 2、scanf()里面不要加\\n。在scanf()里面加\\n意思不是代表回车，而是表示忽略所有的空白符(制表 空格 回车)。你加了\\n，所以回车的时候会被忽略，不能进入下一个语句。 改后版本： #include <stdio.h>  int main(void) { \tint a, b, n;  \tprintf(\"输入三个数：\\n\"); \tscanf(\"%d %d %d\\n\", &a, &b, &n); \tif(n >= 0) \t{     \t\tif(a > b) \t    \tprintf(\"%d\", a); \t} \telse \tprintf(\"%d\", b);  return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "int   main（）", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "if(n >= 0)      if(a > b)      printf(\"%d\", a);      else      printf(\"%d\", b); 直接这样就行了，不应该在第一个if后面加{}", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "scanf(\"%d%d%d\", …)试试看。", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "#include <stdio.h> int main ( ) {     int a,b,n;     printf(\"输入三个数\\n\");     //scanf(\"%d %d %d\\n\",&a,&b,&n);     scanf(\"%d %d %d\",&a, &b, &n);     if (n>=0)     {         if(a>b)             printf(\"%d\",a);         else             printf(\"%d\", b);     }      return 0; }  供参考～", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "挺不错的啊挺不错的啊", "referer": "user-0"}]}
{"question": "数据结构（c语言）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:f1函数是创建一个节点，赋值一个string给在node，并连接到list中。 如果v给的是一个null，则返回失败。 谢谢啦(((*°▽°*)八(*°▽°*)))♪", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "f1函数是创建一个节点，赋值一个string给在node，并连接到list中。 如果v给的是一个null，则返回失败。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 楼主 喝着奶茶敲实验的回复:啊怎么写哇 第一问   函数 f1（）是做什么的？ 第二问 什么可能的情况使代码运行失败？", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "MSDN上提到，scanf()函数的返回值 Returns the number of fields successfully converted and assigned; A return value of 0 indicates that no fields were assigned. 意思大概就是当通过scanf()函数成功读取数据后，该函数的返回值是读取数据的变量的个数；如果未能成功读取数据，则该函数的返回值是0。 所以，要结束while()虚幻，只需要输入非数字即可。VS2015 C++环境调试  当输入2按下回车后，scanf()函数返回值是1，所以会运行while中的语句；之后输入a按下回车，此时scanf()函数返回值是0，结束while循环，执行之后的代码，完成输出。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\\t'); or newline ('\\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 5 楼 forever74 的回复:代码里%d后面有空格，你输入的时候2和回车中间也该加空格。跟空格没关系，格式化输入会自动将空格忽略，只有非空格字符才会严格按转换批示字符串匹配。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你代写得有问题，本来就不应该有输出的。你一直输入数字然后回车，程序会一直在while(scanf(\"%d\",&a)==1)中循环的，除非你输入非法的字符才会结束循环。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "供参考：https://blog.csdn.net/21aspnet/article/details/174326 建议改为如下形式：while(scanf(\"%d\",&a),a){//输入0时结束输入", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "代码里%d后面有空格，你输入的时候2和回车中间也该加空格。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：回车符是将输入缓存的内容刷到内存，如果输入缓存里没有内容，那么如何刷到内存？程序在下面，我输入的是2 加回车但是没输出", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "#include<iostream> #include<cstdio> using namespace std; long long a,s,i,w; int main() { \twhile(scanf(\"%d \",&a)==1) { \t\ts+=a; \t\ti++; \t} \tw=1; \tfor(int j=1; j<i; j++) \t\tw*=2; \tcout<<s*w;  \t    return 0; }", "referer": "user-0"}, {"cid": "9", "user": "user-6", "content": "回车符是将输入缓存的内容刷到内存，如果输入缓存里没有内容，那么如何刷到内存？", "referer": "user-0"}]}
{"question": "求助 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "只有一个if呀 还有else和for咋搞", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> void menu() {     printf(\"********************************************************\\n\");     printf(\"**********************加減乗除電卓**********************\\n\");     printf(\"*選択した計算方法 1~4 を入力し、Enterを押してください。*\\n\");     printf(\" 1.+ \\n\");     printf(\" 2.- \\n\");     printf(\" 3.* \\n\");     printf(\" 4./ \\n\");     printf(\"********************************************************\\n\"); } int main(void) {     int i = 0;     int j = 0;     int num = 0;     int select = 0;     do     {         menu();         //scanf_s(\"%d\", &select);         scanf(\"%d\", &select);         printf(\"1つ数字を入力し、Enterを押してください。2回繰り返すことが必要です。\");          //scanf_s(\"%d%d\", &i, &j);         scanf(\"%d%d\", &i, &j);         switch (select)         {             case 1:                 printf(\"%d+%d=%d\\n\", i, j, num = i + j);                 break;             case 2:                 printf(\"%d-%d=%d\\n\", i, j, num = i - j);                 break;             case 3:                 printf(\"%d*%d=%d\\n\", i, j, num = i * j);                 break;             case 4:                 if (j == 0) {                     printf(\"Input error!\\n\");                     break;                 }                  printf(\"%d/%d=%d\\n\", i, j, num = i / j);                 break;             default:                 printf(\"入力ミスは、再入力してください。\");                 break;         }     } while (select);     return 0; } 供参考～  注意当做除法时，j ！= 0", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不必要全都要用到(最近老打错别字什么的，心好累)", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "if~else和switch都是选择分支结构，for和while都是循环结构，break这里用应该是退出循环。你应该是要写一个四则运算的程序吧？两种结构里面选其中之一任意搭配就可以了吧，不必要全年都要用到", "referer": "user-0"}]}
{"question": "请教为什么printf(\"result is=%f\\n\",1234567.1);返回的是1234567.125 ？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "换成%.1f就是输出一位小数了。同理%.3f就是输出3位小数", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": ".125就是八分之一。说明浮点指数截断后，最后一个阶是二的负三次幂。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "……人家跟你说得清清楚楚，你在这里质疑计算机有什么用？  不得不说在我看来你在钻牛角尖。明明自己去学习并实践一下浮点数的十进制如何转二进制就能明白的，建议再去研究一下计算机组成原理，真的明白原理后，我想你的计算机无用论会不攻自破。  另外，我想说计算机不是万能的，他能帮我们提高效率，但是你如果真的想得到特别特别准确，甚至说绝对准确的数据是不可能的。而且现实生活中也不是需要绝对准确的数据，对数据的要求都是在一个可接受的误差范围内，这也是学计算机要学习数值计算方法的原因。绝大多数情况下，我们需要的是满足误差范围的数据。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "这种应该算误差吧，要保留1位小数的话用％.1f", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "有效位数超出了", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "这个是编译器的问题", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "简短截说 10进制小数就是用1/10,1/100,1/1000，……分 2进制小数就是用1/2,1/4,1/8,……分 N进制小数就是用1/N,1/(N*N),1/(N*N*N),……分 所以如果限制最小的用来分的阶数（也就是小数点后最多多少位），M进制小数和N进制小数对有些数两者都能精确表示，对有些数两者只有其一能精确表示，对有些数，两者都不能精确表示。 如果不限制最小的用来分的阶数（也就是小数点后最多多少位，也就是允许使用无限位，不一定非得是循环小数），那M进制小数和N进制小数都能精确表示任何有理数。", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "引用 52 楼 oracleperl 的回复:引用 赵老师好 请教下 1. 如果是整数，二进制和十进制互转没有问题对吧？ 2.二进制转十进制也是可以精确转的对吧？，比如如下演算    二进制0.1111= 1*(1/2)+1*(1/4)+(1/8)+1/16= 7/8 3. 十进制小数转二进制就不一定能精确转了对吧？似乎是二进制没法记录10进制的所有值    或者说二进制的数值是十进制数值的子集？我这样理解对吧？   但我还没搞明白十进制转二进制的原理 1.对 2.不对 3.对。半对（二进制没法记录10进制的所有值，10进制也没法记录二进制的所有值，二进制的数值和十进制数值之间谁都不是谁的子集）。错。 N（正整数N≥2）进制的小数比如  N=2，2进制： 10.11 W1=1,W0=0,W-1=1,W-2=1其中-1,-2是下标， 对应数值为W1*N^1+W0*N^0+W-1*N^-1+W-2*N^-2其中^表示指数  N=3，3进制： 20.11 W1=2,W0=0,W-1=1,W-2=1其中-1,-2是下标， 对应数值为W1*N^1+W0*N^0+W-1*N^-1+W-2*N^-2其中^表示指数  N=10，10进制： 90.11 W1=9,W0=0,W-1=1,W-2=1其中-1,-2是下标， 对应数值为W1*N^1+W0*N^0+W-1*N^-1+W-2*N^-2其中^表示指数  显然： N=3,3进制 0.1 W0=0,W-1=1,对应数值为W0*N^0+W-1*N^-1即0*3^0+1*3^-1=0.33333333333333无限循环，无法用长度有限的10进制表示 同理，对有些长度有限的10进制小数，无法用长度有限的2进制表示", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "引用 46 楼 oracleperl 的回复:[quote=引用 45 楼 青蛙工作室 的回复:]严重怀疑楼主是来钓鱼提升CSDN的活跃度的，这么一个基础的问题纠缠了5页，而且看楼主的ID，oracle、perl，3年码龄，根本就不像一个刚接触计算机的小白。各位热心的CSDNer，可以散了。 对你来说是基础的，对别人来说未必是基础的 [/quote]  那你倒是解释一下你的ID，oracle perl，这是一个不懂电脑的小白能想到的？而且在CSDN已有3年，3年啊，哪怕新生儿都上幼儿园了。", "referer": "user-0"}, {"cid": "10", "user": "user-9", "content": "%f改为%.1f", "referer": "user-0"}, {"cid": "11", "user": "user-10", "content": "好厉害👍，真心都大神！", "referer": "user-0"}, {"cid": "12", "user": "user-11", "content": "厉害了，不知道是咋回事", "referer": "user-0"}, {"cid": "13", "user": "user-12", "content": "不管你怎么输入，都不会输出0.125那么大的精度偏差。 出现精度偏差的原因是因为计算机存储的是二进制，当你定义一个数值之后，计算机会自动转换成二进制对象，对于整数部分处理起来比较简单，二进制 可以表示出可表示范围内的所有整数，但是小数点以下部分就比较难了。比如0.5可以用2的负1次方。即.1；0.25比如0.5可以用2的负2次方，即.01；0.75比如0.5可以用2的负1次方+可以用2的负2次方，即.11。（这里只是表述一个小数，实际上小数点也会被转换成一个二进制，即一个double或者long型对象，会有相应位数表示正负和小数点的位置。），因此小数部分的表达公式是，进制数乘以该位置的负指数次之后。例如一个二进制.101=1*2^-1+0*2^-2+1*2^-3。 如果你数学足够好，你就会发现，二进制可以表示成唯一的一个十进制数，但是并不是所有十进制数都可以用二进制表示出来，但是可以不断地去用二进制进行逼近。因此在精度范围内，两者输出是一致的。但是如果超过了精度范围，你就会发现两者出现不一致。这个误差是由于设计程序语言设计之初就导致的误差，是系统误差。因此我们在进行一个高精度计算时（或者在进行金融相关的计算与数据存储时候），并不会使用int、long、double这些数据类型，而是使用BigDecimal。", "referer": "user-0"}, {"cid": "14", "user": "user-13", "content": "引用 32 楼 oracleperl 的回复:[quote=引用 22 楼 lin5161678 的回复:][quote=引用 13 楼 oracleperl 的回复:] i请教这句\"作为常识，大多数十进制有限位小数不能精确转换为二进制。“ 该怎么理解？ 因为 十进制不是2的次幂 所以 有的十进制小数无法用二进制精确表示 如果是 八进制小数 十六进制小数 那么 取值范围之内 就都能精确的用二进制表示[/quote] 说不通啊，举个例子？ 我现在想打印给float赋值123.99 然后就错了？理由是十进制没法转成二进制？ 那么计算机还有什么用？我们还敢写程序吗？比如工资计算程序，就算错了？ [/quote] 工资本来也不是按浮点处理的，  引用 47 楼 oracleperl 的回复:[quote=引用 44 楼 zlzfc 的回复:]printf(\"result is=%.2f\\n\", 123456.99f); 就可以了 谢谢。这样我知道可以，但我不知道为什么那样是错的 我看了书《深入理解计算机系统》，说只有2的N次方的进制之间的转换才能确保一致 书上说 float32位，尾数24位，假设4个bits表示一个十进制数字，难道6个4位不能表示123.99吗？ [/quote] 你把123.99转为2进制表示就知道了", "referer": "user-0"}, {"cid": "15", "user": "user-14", "content": "引用 47 楼 oracleperl 的回复:[quote=引用 44 楼 zlzfc 的回复:]printf(\"result is=%.2f\\n\", 123456.99f); 就可以了 谢谢。这样我知道可以，但我不知道为什么那样是错的 我看了书《深入理解计算机系统》，说只有2的N次方的进制之间的转换才能确保一致 书上说 float32位，尾数24位，假设4个bits表示一个十进制数字，难道6个4位不能表示123.99吗？ [/quote]不停说话是没用的 这东西能实践  0.2611 十进制 转换为二进制小数 写出来  转换过程 转换结果都\"写\"出来 自己实际操作一次 就什么都明白了 来吧干活", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 44 楼 zlzfc 的回复:printf(\"result is=%.2f\\n\", 123456.99f); 就可以了 谢谢。这样我知道可以，但我不知道为什么那样是错的 我看了书《深入理解计算机系统》，说只有2的N次方的进制之间的转换才能确保一致 书上说 float32位，尾数24位，假设4个bits表示一个十进制数字，难道6个4位不能表示123.99吗？", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "引用 45 楼 青蛙工作室 的回复:严重怀疑楼主是来钓鱼提升CSDN的活跃度的，这么一个基础的问题纠缠了5页，而且看楼主的ID，oracle、perl，3年码龄，根本就不像一个刚接触计算机的小白。各位热心的CSDNer，可以散了。 对你来说是基础的，对别人来说未必是基础的", "referer": "user-0"}, {"cid": "18", "user": "user-8", "content": "严重怀疑楼主是来钓鱼提升CSDN的活跃度的，这么一个基础的问题纠缠了5页，而且看楼主的ID，oracle、perl，3年码龄，根本就不像一个刚接触计算机的小白。各位热心的CSDNer，可以散了。", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "引用 赵老师好 请教下 1. 如果是整数，二进制和十进制互转没有问题对吧？ 2.二进制转十进制也是可以精确转的对吧？，比如如下演算    二进制0.1111= 1*(1/2)+1*(1/4)+(1/8)+1/16= 7/8 3. 十进制小数转二进制就不一定能精确转了对吧？似乎是二进制没法记录10进制的所有值    或者说二进制的数值是十进制数值的子集？我这样理解对吧？   但我还没搞明白十进制转二进制的原理", "referer": "user-0"}, {"cid": "20", "user": "user-15", "content": "引用 25 楼 oracleperl 的回复:[quote=引用 21 楼 真相重于对错 的回复:][quote=引用 20 楼 oracleperl 的回复:][quote=引用 17 楼 真相重于对错 的回复:]从数学的角度讲，数是无限的，而计算机只能表示有限的数，就算整形也受到位数的限制，内存的容量不管多大，也有尽头。而数是无限的。因此计算机无法表示所有的数。这个并不是计算机无用。。 谢谢赵老师，这个我能理解 但是为什么printf(\"result is=%f\\n\",123.99f); 这么小的一个十进制数，printf不能返回正确的值？ 难道这个123.99转二进制也会转错？这是我不理解的。 [/quote] 你要了解为什么会转错，那么先要了解，计算机中如何存储整数，进而了解计算机中如何存储小数。了解这些就没有疑惑，不了解这些，别人也没法讲清楚。[/quote] 大神，别人没法讲清楚的事，包括书籍，C标准文档，都是“别人” 那么我如何了解清楚呢？[/quote]  这个梗不错，有开心麻花的范儿。", "referer": "user-0"}]}
{"question": "求大佬，不会写了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include<stdio.h>  #define N 30  struct students {      int num;     //学号     char name[20];//姓名   // int gender;  //性别 男M，女F     char gender;  //性别 男M，女F      int age;     //年龄    float score;   //成绩    float grade;   //操评 };  int main() {   struct students stu[N];//stu[30]      int i;    float qualified=0;//合格    float qualifiedf=0;//合格率     for(i=0;i<N;i++) //for(i=0;i<30;i++)       {        //scanf(\"%d %c %d %d %d %d\",          scanf(\"%d %s %c %d %f %f\",          &stu[i].num,stu[i].name,&stu[i].gender,&stu[i].age,&stu[i].score,&stu[i].grade);       //&stu[i].num,&stu[i].name,&stu[i].gender,&stu[i].age,&stu[i].score,&stu[i].grade);       }    for(i=0;i<N;i++)       {      //if(stu[i].score>60 && stu[i].gender=='M')        if(stu[i].score>=60 && stu[i].gender=='M')           qualified=qualified+1;       }  //qualifiedf=qualified/30;    qualifiedf=qualified/N;    printf(\"qualifiedf=%.2f\\n\",qualifiedf);     int count=0;    for(i=0;i<N;i++)       {        if(stu[i].age<18 && stu[i].gender=='F')// 小于18女生总数           count++;       }    printf(\"count=%d\\n\", count);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "小于18女生总数： int count=0; for(i=0;i<30;i++) {     if(stu[i].age<18 && stu[i].gender=='F')         count++; } printf(\"%d\\n\", count);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "&stu[i].name 这个不太对吧，用stu[i].name或者&stu[i].name[0]", "referer": "user-0"}]}
{"question": "C语言 贪吃蛇邮箱控制台报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请参考《VS2015贪吃蛇代码分析（10-1）》 希望能够帮到您！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "#include<stdio.h> #include<Windows.h> #include<conio.h>  #define MAP_WIDTH 60 //平均宽度 #define MAP_HEIGHT 20 //平均高度  struct snake { \t//x坐标 \tint x;  \t//y坐标 \tint y;  \t//@或者* \tchar ch; }; //结构体数组：代表蛇 struct snake g_snake[MAP_WIDTH*MAP_HEIGHT]; //蛇实际的长度 int g_snake_length = 5; void  SetPos(int  x, int  y) {  \tCOORD  point = { x ,  y }; //光标要设置的位置x,y \tHANDLE  HOutput = GetStdHandle(STD_OUTPUT_HANDLE); //使用GetStdHandle(STD_OUTPUT_HANDLE)来获取标准输出的句柄 \tSetConsoleCursorPosition(HOutput, point); //设置光标位置 }  void DrawSnake() { \tint i = 0; \tfor (i = 0; i < g_snake_length; i++) \t{ \t\t//设置坐标到（0,0）位置 \t\tSetPos(g_snake[i].x, g_snake[i].y);  \t\t//绘制贪吃蛇**** \t\tprintf(\"%c\", g_snake[i].ch); \t}   }  void HideCorsor()  {  \tHANDLE fd = GetStdHandle(STD_OUTPUT_HANDLE);  \tCONSOLE_CURSOR_INFO cinfo;  \tcinfo.bVisible = 0;  \tcinfo.dwSize = 1;  \tif (SetConsoleCursorInfo(fd, &cinfo))  \t\tprintf(\"执行成功\\n\");  \telse  \t\tprintf(\"执行失败\\n\");  \t  } int main() { \t//隐藏光标 \tHideCorsor(); \tint i, j; \t//[0,21) \tfor (j = 0; j < MAP_HEIGHT + 1; j++) \t{ \t\tif (j == MAP_HEIGHT) \t\t{ \t\t\t//绘制一行 \t\t\tfor (i = 0; i < MAP_WIDTH; i++) \t\t\t{ \t\t\t\tprintf(\"-\"); \t\t\t} \t\t\tprintf(\"\\n\");  \t\t} \t\telse \t\t{   //绘制空行 \t\t\tfor (i = 0; i < MAP_WIDTH; i++) \t\t\t{ \t\t\t\tprintf(\" \"); \t\t\t} \t\t\tprintf(\"|\"); \t\t\tprintf(\"\\n\"); \t\t}  \t} \tg_snake_length = 5;  \tg_snake[0].x = 0; \tg_snake[0].y = 0; \tg_snake[0].ch = '*';  \tg_snake[1].x = 1; \tg_snake[1].y = 0; \tg_snake[1].ch = '*';  \tg_snake[2].x = 2; \tg_snake[2].y = 0; \tg_snake[2].ch = '*';  \tg_snake[3].x = 3; \tg_snake[3].y = 0; \tg_snake[3].ch = '*';  \tg_snake[4].x = 4; \tg_snake[4].y = 0; \tg_snake[4].ch = '@';  \t//绘制贪吃蛇**** \tDrawSnake();  \twhile (1) \t{ \t\tint tail_x = g_snake[0].x; \t\tint tail_y = g_snake[0].y; \t\t//向右移动一格 \t\t//（0,0），（1,0），（2,0），（3,0），（4,0)@ \t\t//         （1,0），（2,0），（3,0），（4,0）,(5,0)@  \t\t//[0,5) \t\tfor (i = 0; i < g_snake_length - 1; i++) \t\t{ \t\t\tg_snake[i].x = g_snake[i + 1].x; \t\t\tg_snake[i].y = g_snake[i + 1].y; \t\t} \t\tint key = _getch(); \t\tswitch (key) \t\t{ \t\tcase 'w'://上 \t\t\tprintf(\"上\"); \t\t\tg_snake[g_snake_length - 1].y -= 1; \t\t\tbreak;  \t\tcase 'a'://左 \t\t\tprintf(\"左\"); \t\t\tg_snake[g_snake_length - 1].x -= 1; \t\t\tbreak;  \t\tcase 's'://下 \t\t\tprintf(\"下\"); \t\t\tg_snake[g_snake_length - 1].y += 1; \t\t\tbreak;  \t\tcase 'd'://右 \t\t\tprintf(\"右\"); \t\t\tg_snake[g_snake_length - 1].x += 1; \t\t\tbreak; \t\t} \t\t//清除尾坐标 \t\tSetPos(tail_x, tail_y); \t\tputchar(' ');   \t\t//绘制贪吃蛇**** \t\tDrawSnake();   \t}     \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "出现乱码还能有别的原因 出现上下左右只能是你就这样写的", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "没代码，不知道你是怎么写的", "referer": "user-0"}]}
{"question": "TM1620数码管驱动", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引脚定义呢？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "板子可以确定是好的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不亮也有可能是电路的问题，哪里虚焊了，烧掉了，没通电，共阴的当成共阳了之类的。", "referer": "user-0"}]}
{"question": "vs2019使用MessageBox函数不弹出对话框", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 logωon 的回复:我刚接触C++。。请问这个vs2019视图是哪个啊？ 名字带View的是视图", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你这是文档-视图项目，必须在视图上点左键哟！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "一上来就MFC，有基础了吗", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我刚接触C++。。请问这个vs2019视图是哪个啊？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 1 楼 user-4 的回复:既没有双冒号，也没有足够的参数，还能编译成功，说明不是在调用API，那你只能自己调试了。  哈哈，楼主这是在调戏编译器的节奏。想骗过编译器。结果也被编译器骗了。。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "既没有双冒号，也没有足够的参数，还能编译成功，说明不是在调用API，那你只能自己调试了。", "referer": "user-0"}]}
{"question": "数据结构：两个顺序表取并集，请问代码哪里不对？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "ompiling... Sqlist_Operate.c F:\\数据结构与算法\\顺序表\\Sqlist_Operate.c(126) : error C2275: 'ElementType' : illegal use of this type as an expression         F:\\数据结构与算法\\顺序表\\Sqlist_Operate.c(7) : see declaration of 'ElementType' F:\\数据结构与算法\\顺序表\\Sqlist_Operate.c(126) : error C2146: syntax error : missing ';' before identifier 'e' F:\\数据结构与算法\\顺序表\\Sqlist_Operate.c(126) : error C2065: 'e' : undeclared identifier 执行 cl.exe 时出错.  Sqlist_Operate.obj - 1 error(s), 0 warning(s)", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>  #define SIZE 100  //typedef int ElementType typedef int ElementType; typedef struct {     ElementType *array;   // 存放元素的数组     int length;  // 当前长度     int capacity;  // 数组容量 }SqList;  // 顺序表的创建 SqList *createList(int capacity) {     SqList *L;      L=(SqList*)malloc(sizeof(SqList));     L->length=0;     //L->capacity=SIZE;     L->capacity=capacity;     L->array=(ElementType*)malloc(capacity*sizeof(ElementType));      return L; }  // 获得顺序表的元素 int GetElement(SqList *L,int i,ElementType *e) {     if(i<1||i>L->length){         return 0;     }     *e=L->array[i-1];     return 1; }  // 顺序表的查找 int find(SqList *L,ElementType e) {     int i;      i=L->length-1;     while(i>=0&&L->array[i]!=e){         i--;     }      if (i >= 0)         return i;     else         return 0; }  // 顺序表的插入 int insertlist(SqList *L,int i,ElementType e) {     int k;      if(L->length>=L->capacity)   // 1.判断顺序表的存储空间是否满     {         return 0;     }     if(i<1||i>L->length+1)     // 2.判断插入位置i是否合法     {         return 0;     }     for(k=L->length-1;k>=i-1;k--)     {         L->array[k+1]=L->array[k];    // 3.从最后一个元素开始向后移动     }     L->array[i-1]=e;      // 4.在第i个位置插入元素     L->length++;         // 5.表长度加1      return 1; }  // 顺序表的删除 int deletelist(SqList *L,int i,ElementType *e) {     int k;      if(i<1||i>L->length)    // 1.判断删除位置i是否合法     {         return 0;     }     *e=L->array[i-1];    // 删除的第i个元素     for(k=i;k<L->length;k++)     {         L->array[k-1]=L->array[k];    // 2. 从i+1个元素开始向前移动     }     L->length--;     return 1; }  // 顺序表的长度 int listlength(SqList *L) {     return L->length; }  //按尾部插入法生成初始数据 void Addlist(SqList *L) {     int value;     printf(\"请输入内容，-1结束\\n\");     scanf(\"%d\",&value);     while(value!=-1)     {         insertlist(L,L->length+1,value);         scanf(\"%d\",&value);     } }  //输出数据 void Outputlist(SqList *L) {     int i;     for(i=0;i<L->length;i++)     {         printf(\"%d \",L->array[i]);     }     printf(\"\\n\"); }  // 顺序表的合并：取并集 int mergelist(SqList *L1,SqList *L2) {     int L1_Len,L2_Len;     int i;      //L1_Len=listlength(*L1);     L1_Len=listlength(L1);     L2_Len=listlength(L2);      ElementType e;     for(i=1;i<=L2_Len;i++)     {         GetElement(L2,i,&e);         //if(!find(*L1,e))     // 在表L1中没找到该元素，则将该元素插入表L1中         if(!find(L1,e))     // 在表L1中没找到该元素，则将该元素插入表L1中         {             printf(\"hellowrold!\\n\");             //insertlist(L1,++L1_Len,e);             insertlist(L1,L1->length+1,e);         }     }  }  int main() {     SqList *LA,*LB;     ElementType e;      //SqList *LA=createList(capacity);     //SqList *LB=createList(capacity);     LA=createList(SIZE);     LB=createList(SIZE);      printf(\"尾部插入法生成初始数据：\\n\");      //Addlist(&LA);     Addlist(LA);     printf(\"LA表中元素为：\");     //Outputlist(&LA);     Outputlist(LA);      //Addlist(&LB);     Addlist(LB);     printf(\"LB表中元素为：\");     //Outputlist(&LB);     Outputlist(LB);      //mergelist(&LA,&LB);     mergelist(LA, LB);     printf(\"LA和LB取并集后的元素为：\");     //Outputlist(&LA);     Outputlist(LA);      return 0; }  供参考  语法错误太多，基本上几条语句就对应一个编译error；  解决语法错误是最基本的编程能力，还需要多努力呀", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "错误6和错误7是看的小甲鱼视频里面写的", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "MATLAB用惯了，有几年没用C语言了，这次学习数据结构，有些跟着书上敲，疏忽了一些问题，对指针不熟。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "Addlist(&LA); printf(\"LA表中元素为：\"); Outputlist(&LA);  Addlist(&LB); printf(\"LB表中元素为：\"); Outputlist(&LB);  mergelist(&LA,&LB); printf(\"LA和LB取并集后的元素为：\"); Outputlist(&LA);  这些函数调用全部写错了，LA和LB本身就是指针了，再取地址&LA明显是错误的。 修改如下后能正确运行  int main() {     SqList *LA, *LB;     ElementType e;      LA = createList(10);     LB = createList(10);      printf(\"尾部插入法生成初始数据：\\n\");      Addlist(LA);     printf(\"LA表中元素为：\");     Outputlist(LA);      Addlist(LB);     printf(\"LB表中元素为：\");     Outputlist(LB);      mergelist(LA, LB);     printf(\"LA和LB取并集后的元素为：\");     Outputlist(LA);      return 0; }   楼主对变量的声明和定义、指针等概念掌握的很不清晰", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "错误： 1、typedef int ElementType  //这里少了个 ；号  typedef int ElementType; 2、L = (SqList*)malloc(sizeof(SqList));  //L没有声明   SqList *L = (SqList*)malloc(sizeof(SqList));  3、i = L->length - 1; //i 没有声明  int i = L->length - 1; 4、for (k = L->length - 1; k >= i - 1; k--)  //k没有声明  for (int k = L->length - 1; k >= i - 1; k--) 5、for (k = i; k < L->length; k++)  //错误同上 for (int k = i; k < L->length; k++) 6、L1_Len = listlength(*L1);  //形参是指针，实参是取值，形参和实参不符 L1_Len = listlength(L1); 7、 if (!find(*L1, e))     // 在表L1中没找到该元素，则将该元素插入表L1中    //错误同上  if (!find(L1, e))      8、     SqList *LA, *LB;                                 //这里已经声明了     ElementType e;      SqList *LA = createList(capacity);    //这里的SqList *LA就重复了     LA = createList(capacity);  这里的capacity没有定义，不知道是什么，随便输入个int值如LA = createList(10);      SqList *LB = createList(capacity);                                                    LB = createList(10);  以上修改后编译通过", "referer": "user-0"}]}
{"question": "为什么我这个printf（“%c“,a【i】.data）输出不了啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX_SIZE 1024 typedef struct {     char data;     int weight;     int parent;     int lchild;     int rchild; } Huffnode,*Hufftree; typedef struct stack {     int top;     int elem[MAX_SIZE]; } Stack; void Initstack(Stack *s) {     s->top=-1; } void push(Stack *s,int e) {     s->top++;     s->elem[s->top]=e; } int pop(Stack *s) {     return s->elem[s->top--]; } bool isempty(Stack *s) {     if(s->top==-1)         return true;     else         return false; } void GetHuffmamCode(Hufftree a,int n) {     int i,j,s1,s2,max,c,p;     Stack s;     char ch;     Initstack(&s);     printf(\"输入字符集：\");fflush(stdout);     rewind(stdin);     for(i=1;i<=n;i++) {         scanf(\"%c\",&a[i].data);     }     for(i=1;i<=n;i++) {         printf(\"a[%d].data:%c\\n\",i,a[i].data);     }     printf(\"\\n\");     printf(\"输入权值：\");fflush(stdout);     rewind(stdin);     for(i=1;i<=n;i++) {         scanf(\"%d\",&a[i].weight);     }     for(i=1;i<=n;i++) {         printf(\"a[%d].weight:%d\\n\",i,a[i].weight);     }     printf(\"\\n\");     int m=2*n-1;     for(i=1;i<=n;i++) {         a[i].parent=0;         a[i].rchild=0;         a[i].lchild=0;     }     for(i=n+1;i<=m;i++) {         a[i].data=NULL;         a[i].weight=0;         a[i].parent=0;         a[i].lchild=0;         a[i].rchild=0;     }     for(i=n+1;i<=m;i++) {         max=65535;         for(j=1;j<=i-1;j++) {             if(a[j].parent==0&&a[j].weight<=max) {                 s1=j;                 max=a[j].weight;             }         }         a[s1].parent=i;         max=65535;         for(j=1;j<=i-1;j++) {             if(a[j].parent==0&&a[j].weight<=max) {                 s2=j;                 max=a[j].weight;             }         }         a[s2].parent=i;         a[i].weight=a[s1].weight+a[s2].weight;         a[i].lchild=s1;         a[i].rchild=s2;     }     for(i=1;i<=n;i++) {         c=i;         p=a[i].parent;         while(p!=0) {             if(a[p].lchild==c)                 push(&s,0);             else                 push(&s,1);             c=p;             p=a[p].parent;         }         printf(\"i:%d\\n\",i);         printf(\"%c\\n\",a[i].data);         while(!isempty(&s))             printf(\"%d\",pop(&s));         printf(\"\\n\");     } } int main() {     Hufftree a;     int n;     int m;     printf(\"输入字符个数：\");     scanf(\"%d\",&n); //  m=2*n-1;     m=3*n;     a=(Hufftree)malloc(sizeof(Huffnode)*m);     GetHuffmamCode(a,n);     return 0; } //输入字符个数：3 //输入字符集：abc //a[1].data:a //a[2].data:b //a[3].data:c // //输入权值：10 20 30 //a[1].weight:10 //a[2].weight:20 //a[3].weight:30 // //i:1 //a //00 //i:2 //b //01 //i:3 //c //1 //", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "对于%c的输入，需要注意上次输入的'\\n'可能被接收。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "printf(\"%c\\n\",a[i].data);前面随便打印输出一行字符串，看看程序走到这个输出语句了吗", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "太长没太仔细看 你的a，数组下标应该从0到m-1，但你的处理却是从1到m，造成内存越界了吧？", "referer": "user-0"}]}
{"question": "SHFileOperation函数会把文件拷贝成文件夹？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考下：https://blog.csdn.net/ghevinn/article/details/8707552?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "没人回复啊怎么", "referer": "user-0"}]}
{"question": "关于c语言中位操作的疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "写入前使用掩码，例如：  uint8_t mask = 0xFE;//小端存储的机器中第一个bit位有写保护 uint8_t a = 0xFF;//被保护数据 uint8_t b = 0x02;//待写入数据 uint8_t c =( b & mask) | (a & (~mask)) ;  memcpy(&a,&c,sizeof(uint8_t));", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C++可以用类来实现，C只能自己小心处理。", "referer": "user-0"}]}
{"question": "学习C语言时遇到的两个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主的代码：", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "total -= 1", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "result=result-x 等价 result-=x", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:1、result-=1 2、尽量使算法不需要保留原始输入数据，比如求和，可以将每个输入的数据累加到一个变量，然后计数即可；如果必须保留，可以先分配一定长度，当不够时，再重新分配更大长度，把原有数据复制过去，realloc()就是干这个的。或者也可以使用链表。 是因为一开始定义的result=1的缘故吗？请问如果用-=的话可以怎么改一下？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "1、result-=1 2、尽量使算法不需要保留原始输入数据，比如求和，可以将每个输入的数据累加到一个变量，然后计数即可；如果必须保留，可以先分配一定长度，当不够时，再重新分配更大长度，把原有数据复制过去，realloc()就是干这个的。或者也可以使用链表。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "哦哦 明白了！原来是我一直概念没搞清啊", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用 7 楼 啊6吧 的回复:[quote=引用 5 楼 qzjhjxj的回复:]楼主的代码： 那请问为啥total=total-1就能输出正确的结果呢？[/quote] total -= total;/*这句分开写法：*/total = total - total = 0; total -= 1；/*这句分开写法   ：*/total = total - 1;执行顺序为：total-1，total =total,就是变量total先减1运算，再赋值。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 5 楼 qzjhjxj的回复:楼主的代码： 那请问为啥total=total-1就能输出正确的结果呢？", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "只有想不到，没有做不到。 修改main，这个简单，自己写个编译器即可。 如果觉得C语法反人类，还可以修改C语法，创建新编程语言。。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "首先这个事没啥意义。 其次个人觉得最简方式是宏定义，你可以把定义藏进头文件足够了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "百度吧。这个我记得编译链接过程中，会占用这个默认名称。", "referer": "user-0"}]}
{"question": "C++", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int a[10]={0},b,i=0;     scanf(\"%d\",&b);     while(b){           a[i++] = b%10;           printf(\"%d\",a[i-1]);           b /= 10;          }     printf(\"\\n\");      return 0; } int main(void) { \tchar buf[11], *p=buf; \tscanf(\"%10s\", buf); \twhile(*p)p++;         while(p-- != buf) printf(\"%c\",*p); \tprintf(\"\\n\");    \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 3 楼 weixin_51991747 的回复:while(*p)p++;    while(p-- != buf) printf(\"%c\",*p);是什么意思？？？  如:原数为4563，假设首地址为buf=0，while(*p)p++;这句就是p 从0开始一直走到4563的结尾处，也就是p=4;  while(p-- != buf) printf(\"%c\",*p);这句就是p=4开始往回倒，一直倒回到p==buf=0的位置，倒着输出呀。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "while(*p)p++;    while(p-- != buf) printf(\"%c\",*p);是什么意思？？？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "把每位数取出来再加起来", "referer": "user-0"}]}
{"question": "这个层序遍历输出不了，有大佬帮忙看看吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：#include <iostream> #include <stack> #include <queue> #include <locale.h> using namespace std; typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int CreateBiTree(BiTree &T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         T = NULL;     } else {         T = (BiTree)malloc(sizeof(BiTNode));         T->data = data;         //生成根结点         CreateBiTree(T->lchild);//构造左子树         CreateBiTree(T->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈             stack.pop();             p = p->rchild;          //访问右子树         }     } } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈，访问根节点             printf(\"%c \",p->data);             stack.pop();             p = p->rchild;          //访问右子树         }     } }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     stack<BiTreePost> stack;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack.push(BT);             p = p->lchild;         }         while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点             BT = stack.top();             stack.pop();//退栈             printf(\"%c \",BT->biTree->data);         }         if (!stack.empty()) {//遍历右子树             BT = stack.top();             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     } }  void LevelOrder(BiTree T) {//层次遍历     if (T == NULL) return;     BiTree p = T;     queue<BiTree> queue;//队列     queue.push(p);//根节点入队     while (!queue.empty()) {    //队列不空循环         p = queue.front();      //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         queue.pop();            //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue.push(p->lchild);         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue.push(p->rchild);         }     } } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}]}
{"question": "自闭中", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "最后一个words不要*号", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 向阳森 的回复:[quote=引用 1 楼 赵4老师的回复:]13:   char words[]=\"... 16:   cnline((char *)words, i, j); 能详细讲一下原因吗！谢谢[/quote] 你的函数形参和调用函数输入的实参类型不匹配，要改成一样的类型", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:13:   char words[]=\"... 16:   cnline((char *)words, i, j); 能详细讲一下原因吗！谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "chline(*words, i, j); 参数去掉*，否则类型不匹配。应为实参是char，形参是char *", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "13:   char words[]=\"... 16:   cnline((char *)words, i, j);", "referer": "user-0"}]}
{"question": "C语言小白求助！为什么①不能选B，②不能选A?", "poster": "user-0", "comments": [{"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-2", "content": "考虑权限问题 带+都不选 考虑文本模式对文件数据有特殊处理 不带b都不选 1. A 不带b B 带+ C OK D 带+ 选C 2. A 带+ B 带+ C 不带b D OK  结论 答案是 CD", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "从打开文件后的操作上来看，fp1只是做了读操作，其他没有。从安全角度上讲old.data文件的打开方式应该是只读的，r+是可以读写的，添加写权限不安全；  但是B也没问题。  第二个空，道理也是一样的。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "感觉答案只是从严谨的角度定的吧，你的想法也没问题", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "因为题目不是你出的。", "referer": "user-0"}]}
{"question": "C语言小白求助！这里的stdin是什么意思？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:标准输入的意思。 谢谢回答！！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "标准输入的意思。", "referer": "user-0"}]}
{"question": "请问输出超限怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 user-1的回复:勉强一点试试 while(scanf(...)==2) 吧 嗯好，非常感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "勉强一点试试 while(scanf(...)==2) 吧", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "样例输入为 no 370 371", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "为啥都喜欢把关键部位藏起来呢？样例输出呢？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "有人来吗，求大佬告知", "referer": "user-0"}]}
{"question": "挑战全球各种Code Editors！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "TSEPro11_Setup.exe 百万军中取上将首级如探囊取物， 千万行里改关键源码在弹指瞬间。 功能超强的程序编辑器！ https://blog.csdn.net/zhao4zhong1/article/details/126596717", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "试试还能发帖么", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "还没结帖，赶紧蹭一蹭", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "有要分的", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "厉害 厉害", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "不错，不错！", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "是我没说清楚，能编辑多大的文件，是单个文件大小，多个文件的总量意义不大。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 7 楼 早打大打打核战争 的回复:一百万行printf？ 这个名副其实的“一百万行printf”也是我利用此神器的几个键盘宏生成的。 顺便可用于打脸那些以代码行数论程序员工作量的外行领导。", "referer": "user-0"}, {"cid": "10", "user": "user-7", "content": "一百万行printf？", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 5 楼 早打大打打核战争 的回复:是我没说清楚，能编辑多大的文件，是单个文件大小，多个文件的总量意义不大。 单个文件也毫无压力：", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 3 楼 早打大打打核战争 的回复:能编辑多大的文件，一百万行代码行不行？ 你以为不行吗？  以上是打开opencv+contrib所有源代码后的局部截图", "referer": "user-0"}, {"cid": "13", "user": "user-7", "content": "能编辑多大的文件，一百万行代码行不行？", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "", "referer": "user-0"}]}
{"question": "这串代码有什么错误嘛？我想让一串数字输入到文件里面，然后将文件中的数字再读取出来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "找了好多资料都找不到相关内容", "referer": "user-0"}]}
{"question": "请教到底什么是函数原型，谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我们都知道C语言提倡在调用之前通过包含头文件等手段先提供函数原型，我们照办。 凡是违反这个原则的，在C猿看来都是大逆不道。  所以我仍然表示我无法提供你所需要的函数原型的精确定义。从而无法正面回答你的问题。5楼所述都是侧面功能性描述。 从而我也仍然认为你的纠结是钻牛角尖。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 4 楼 oracleperl 的回复:[quote=引用 3 楼 自信男孩 的回复:]    函数声明可以省略形参名，但是函数定义的首部必须写出所有形参名并给出其对应的数据类型。     函数原型的主要目的为声明函数返回值类型以及函数的期望接受的参数的个数、参数类型和参数顺序     如果程序中没有某个函数的函数原型（没有说明），编译系统就会用第一次出现的这个函数（函数定义或函数调用）构造函数原型         在缺省下编译系统默认函数返回值为int         而对函数参数类型不做任何假设     常见错误         和函数原型不匹配的函数调用会导致语法错误         函数原型和函数定义不一致，也会产生错误         C语言环境下，如果函数不进行声明就使用，可能会发生错误，因为默认将返回值做为int类型来处理，所以，最好是在使用之前对函数进行声明。    感觉楼主还是比较懒的，网上的信息还是比较多的，为什么不亲自找找并总结一下。如果看一个帖子的说明还怀疑，看2个可能可以做个对照，看多个的时候可以总结一下那个更靠谱的定义。  最后还真别钻牛角尖，没用的。 网上的信息未必是对的，很多文字逻辑混乱 另外，这个不存在钻牛角尖一说，概念是要搞清楚的。 [/quote]  所以，你需要判断和总结。从网上查资料还是比较快的，如果去查专门的文献或书籍，我想你没这么快。网上的表述可能加上了很多人自己的见解在里面，并且可能讲解的更通俗易懂，更多时候还会有例子。一个概念，可能描述的不见得你就能理解。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "总结，在调用点上方让编译器两眼一抹黑的就叫没有原型，无论你在下面写得多么完善。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "反过来说，出现在调用点下方/其他文件里的函数定义不起原型作用，因此不认为是原型。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "好吧，惯着你。前提是编译器和你一样从头开始流式阅读源文件。 C意义下所谓原型prototype，它是干啥的呢？ 用于在函数被调用之前通知编译/连接器，这个函数有几个参数，每个参数是什么类型的，以及捎带着预期的返回值是什么类型的。 为啥要通知是另一个问题。  于是，凡是起这个作用的，出现在函数被调用的行的上方的函数声明/函数定义都可以被编译/连接器理解为是prototype。  通常我们写那个声明的目的是为了解放函数定义的位置， 所以，在一个程序中如果你能保证函数定义和函数调用出现在同一个源文件，并且定义总在调用上方出现，那就完全不必出现函数声明。 所以所以，在通常的语境下，我们称头文件里的函数声明，以及源文件里位于靠近文件头方向的函数声明为 函数原型。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:函数声明可以省略形参名，但是函数定义的首部必须写出所有形参名并给出其对应的数据类型。     函数原型的主要目的为声明函数返回值类型以及函数的期望接受的参数的个数、参数类型和参数顺序     如果程序中没有某个函数的函数原型（没有说明），编译系统就会用第一次出现的这个函数（函数定义或函数调用）构造函数原型         在缺省下编译系统默认函数返回值为int         而对函数参数类型不做任何假设     常见错误         和函数原型不匹配的函数调用会导致语法错误         函数原型和函数定义不一致，也会产生错误         C语言环境下，如果函数不进行声明就使用，可能会发生错误，因为默认将返回值做为int类型来处理，所以，最好是在使用之前对函数进行声明。    感觉楼主还是比较懒的，网上的信息还是比较多的，为什么不亲自找找并总结一下。如果看一个帖子的说明还怀疑，看2个可能可以做个对照，看多个的时候可以总结一下那个更靠谱的定义。  最后还真别钻牛角尖，没用的。 网上的信息未必是对的，很多文字逻辑混乱 另外，这个不存在钻牛角尖一说，概念是要搞清楚的。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "函数声明可以省略形参名，但是函数定义的首部必须写出所有形参名并给出其对应的数据类型。     函数原型的主要目的为声明函数返回值类型以及函数的期望接受的参数的个数、参数类型和参数顺序     如果程序中没有某个函数的函数原型（没有说明），编译系统就会用第一次出现的这个函数（函数定义或函数调用）构造函数原型         在缺省下编译系统默认函数返回值为int         而对函数参数类型不做任何假设     常见错误         和函数原型不匹配的函数调用会导致语法错误         函数原型和函数定义不一致，也会产生错误         C语言环境下，如果函数不进行声明就使用，可能会发生错误，因为默认将返回值做为int类型来处理，所以，最好是在使用之前对函数进行声明。    感觉楼主还是比较懒的，网上的信息还是比较多的，为什么不亲自找找并总结一下。如果看一个帖子的说明还怀疑，看2个可能可以做个对照，看多个的时候可以总结一下那个更靠谱的定义。  最后还真别钻牛角尖，没用的。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "https://zhidao.baidu.com/question/1964441885008271820.html", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "int f(int x);   这个可以看做声明  int f(int x)  //这一行可以看做实现 return 100; }", "referer": "user-0"}]}
{"question": "请问 我怎么写这个装进unsigned char tx_Setbuffer[1024]; 里数据，写法不会", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 2004v2004 的回复:strcpy(tx_Setbuffer+8, \"Versio\"); //字符串用strcpy拷贝的方式  我这里这个不对呢 不对是指什么？是程序运行出错，还是运行后赋值后结果不对？ 如果是报错，改成 strcpy((char*)(tx_Setbuffer+8), \"Versio\"); 或用内存拷贝的方式 memcpy(tx_Setbuffer+8, \"Versio\", strlen(\"Versio\")); 再不行就循环一个一个赋值 如果是结果不对，那就看你希望的结果是什么了，上面的做法只是单纯的把\"Versio\"的每个字符存入tx_Setbuffer+8开始的内存中", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "strcpy(tx_Setbuffer+8, \"Versio\"); //字符串用strcpy拷贝的方式  我这里这个不对呢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "memcpy(tx_Setbuffer + 8, \"Versio\", 8);        用这个是OK的 谢谢了", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "for example tx_Setbuffer[6] =(unsinged char)strtol(\"32\", NULL, 16); //字符串转成数字类型 strcpy(tx_Setbuffer+8, \"Versio\"); //字符串用strcpy拷贝的方式 tx_Setbuffer[17]=((unsinged char))strtol(\"1\", NULL, 0); //字符串转成数字类型", "referer": "user-0"}]}
{"question": "C语言小白求助！请问这道题c为什么错了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢解答！！！", "referer": "user-0"}, {"cid": "2", "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": "3", "user": "user-1", "content": "我还说fprintf也可以，谁要跟我抬杠，我就甩这几行代码给他： #include <stdio.h> int main() {     int i=0x12345678;     FILE *f=fopen(\"data.bin\",\"wb\");     fprintf(f,\"%c%c%c%c\",(char)(i>>24),(char)(i>>16&0xFF),(char)(i>>8&0xFF),(char)(i&0xFF));     fclose(f);     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "fwrite可以是可以；但不能拦着fputc也可以： int fputc( int c, FILE *stream );", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "纠正 ACD都行  AD需要一点技巧而已", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "出题人自己不清醒而已  AC都行 A需要一些技巧而已", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "C fwrite()函数", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "【可把整数以二进制形式存放到文件中】这里的二进制形式指的是什么？ 如果是比如5，以101写入文件的话，那就是A，用fprintf的格式打印可以实现 C能实现的是字节方式存储，但是存储内容本身是16进制", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "B是读，A和D是字符形式；所以选C，如果C错，那就有问题了吧，那就是答案错误～   https://wenku.baidu.com/view/f4332ec509a1284ac850ad02de80d4d8d15a01b6.html", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "fwrite啊，以二进制的形式\"wb\"打开文件", "referer": "user-0"}]}
{"question": "C语言新手问题：怎么在函数之间传一个可变长数组？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  struct array {     int n;     int *arr; };  static struct array *func1(); static int func2(struct array *);  struct array *func1() { #if 0     struct array *p1;     struct array p1_t;     int i , n;      n = 16; // assume n will change based on user input     p1 = &p1_t;     p1->n = n;     p1->arr = (int *)malloc(sizeof(int) * n);     for (i = 1 ; i <= n ; i++) p1->arr[i - 1] = i;     return p1;    //返回的是p1_t的地址，这个地址是局部变量的地址，根据局部变量的生命周期是本函数内，因此返回的p1无效，还导致内存泄露，因为malloc的没释放。 #else     struct array *p1;     int n, i;      p1 = (struct array *)malloc(sizeof(struct array));     if (!p1)         exit(0);      n = 16;     p1->n = n;     p1->arr = (int *)malloc(sizeof(int) * n);     if (!p1->arr) {         free(p1);         exit(0);     }     for (i = 1; i<= n; i++)         p1->arr[i-1] = i;      return p1;  #endif }  int func2(struct array *p2) {     int i , n;      n = p2->n;     for (i = 1 ; i <= n ; i++)         p2->arr[i - 1] = n + 1 - i;      return 1; }  int main() {     struct array *p;     int i , n;      p = func1();     n = p->n;     for (i = 1 ; i <= n ; i++)         printf(\"%d, \" , p->arr[i - 1]);     printf(\"after func1.\\n\");     func2(p);     for (i = 1 ; i <= n ; i++)         printf(\"%d, \" , p->arr[i - 1]);     printf(\"after func2.\\n\");      free(p->arr);     free(p);      return 1; } 供参考～  谢谢，您的代码风格很好，向您学习！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "我寻思着你这也不是可变数组而是链表啊，你可以找找怎么写链表的看看", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h>  struct array {     int n;     int *arr; };  static struct array *func1(); static int func2(struct array *);  struct array *func1() { #if 0     struct array *p1;     struct array p1_t;     int i , n;      n = 16; // assume n will change based on user input     p1 = &p1_t;     p1->n = n;     p1->arr = (int *)malloc(sizeof(int) * n);     for (i = 1 ; i <= n ; i++) p1->arr[i - 1] = i;     return p1;    //返回的是p1_t的地址，这个地址是局部变量的地址，根据局部变量的生命周期是本函数内，因此返回的p1无效，还导致内存泄露，因为malloc的没释放。 #else     struct array *p1;     int n, i;      p1 = (struct array *)malloc(sizeof(struct array));     if (!p1)         exit(0);      n = 16;     p1->n = n;     p1->arr = (int *)malloc(sizeof(int) * n);     if (!p1->arr) {         free(p1);         exit(0);     }     for (i = 1; i<= n; i++)         p1->arr[i-1] = i;      return p1;  #endif }  int func2(struct array *p2) {     int i , n;      n = p2->n;     for (i = 1 ; i <= n ; i++)         p2->arr[i - 1] = n + 1 - i;      return 1; }  int main() {     struct array *p;     int i , n;      p = func1();     n = p->n;     for (i = 1 ; i <= n ; i++)         printf(\"%d, \" , p->arr[i - 1]);     printf(\"after func1.\\n\");     func2(p);     for (i = 1 ; i <= n ; i++)         printf(\"%d, \" , p->arr[i - 1]);     printf(\"after func2.\\n\");      free(p->arr);     free(p);      return 1; } 供参考～", "referer": "user-0"}]}
{"question": "不得了了，赵4老柿的编码风格太神啦！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> char a[]={'c','h'}; char b[]=\"啊\"; int main() {     int i,n;     char buf[9+1];//给\"0xXX 0xXX\"留的空间      sprintf(buf,\"0x%02X 0x%02X\",(unsigned char)a[0],(unsigned char)a[1]);     printf(\"[%s]\\n\",buf);//[0x63 0x68]      sprintf(buf,\"0x%02X 0x%02X\",(unsigned char)b[0],(unsigned char)b[1]);     printf(\"[%s]\\n\",buf);//[0xB0 0xA1]      sprintf(buf,\"0x%02X 0x%02X\",a[0],a[1]);     printf(\"[%s]\\n\",buf);//[0x63 0x68]      sprintf(buf,\"0x%02X 0x%02X\",b[0],b[1]);     printf(\"[%s]\\n\",buf);//运气好了输出[0xFFFFFFB0 0xFFFFFFA1]；运气不好buf越界，程序异常退出！      return 0; }  不放一挂鞭，不够热闹哈！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "我特别喜欢“快活的气氛”这个字眼。 疫情下，全球郁闷的氛围中，缺的不就是“快活的气氛”嘛！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "赵4老师在哪开直播的", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "可不是咋滴，上面只是个比喻，真实的经过是这样的：那天我发现赵老湿写了一个小程序： char a [] = \"cp\"; printf (\"0x%02X\", (unsigned char) a [0]); 程序大致是上面这样。我跟赵老湿说，赵老湿啊赵老湿，你就显示'c'和'p'的字符编码，就不要强转成(unsigned char)了吧，脱kz放p，看着别扭。赵老湿不肯。楼内网友一连声地说赵老湿对，我是错的，“挺赵老湿！””站赵老湿“！赵老湿看大家都支持他，脸上泛起了红光，用食指在碗里醮了酒，在桌子上把程序改了一下： char a [] = \"啊\"; 然后对我说，看，在这种情况下，转成 unsigned char 不就有用了么！ 我刚准备跟赵老湿说，那你要是改成 L\"啊\"、u\"啊\"或者U\"啊\"，怎么办呢？楼内又是一阵骚动，“挺赵老湿”！”站赵老湿！“。赵老湿激动起来，口里喃喃地说什么“long long固长，short固短”之类的，店里又充满了快活的气氛。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "哈哈，这是和赵4老师顶上了", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "就算你写一个 #include <iostream> #include <string> using namespace std; inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string SUB_INT(string str1,string str2); string ADD_INT(string str1,string str2) {//高精度加法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         if (str2[0]=='-') {             sign=-1;             str=ADD_INT(str1.erase(0,1),str2.erase(0,1));         } else {             str=SUB_INT(str2,str1.erase(0,1));         }     } else {         if (str2[0]=='-') {             str=SUB_INT(str1,str2.erase(0,1));         } else { //把两个整数对齐，短整数前面加0补齐             string::size_type L1,L2;             int i;             L1=str1.size();             L2=str2.size();             if (L1<L2) {                 for (i=1;i<=L2-L1;i++) str1=\"0\"+str1;             } else {                 for (i=1;i<=L1-L2;i++) str2=\"0\"+str2;             }             int int1=0,int2=0; //int2 记录进位             for (i=str1.size()-1;i>=0;i--) {                 int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;                 int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;                 str=char(int1+'0')+str;             }             if (int2!=0) str=char(int2+'0')+str;         }     }     //运算后处理符号位     if ((sign==-1)&&(str[0]!='0')) str=\"-\"+str;     return str; } string SUB_INT(string str1,string str2) {//高精度减法     int sign=1; //sign 为符号位     string str;     int i,j;     if (str2[0]=='-') {         str=ADD_INT(str1,str2.erase(0,1));     } else {         int res=compare(str1,str2);         if (res==0) return \"0\";         if (res<0) {             sign=-1;             string temp =str1;             str1=str2;             str2=temp;         }         string::size_type tempint;         tempint=str1.size()-str2.size();         for (i=str2.size()-1;i>=0;i--) {             if (str1[i+tempint]<str2[i]) {                 j=1;                 while (1) {//zhao4zhong1添加                     if (str1[i+tempint-j]=='0') {                         str1[i+tempint-j]='9';                         j++;                     } else {                         str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);                         break;                     }                 }                 str=char(str1[i+tempint]-str2[i]+':')+str;             } else {                 str=char(str1[i+tempint]-str2[i]+'0')+str;             }         }         for (i=tempint-1;i>=0;i--) str=str1[i]+str;     }     //去除结果中多余的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str=\"0\";     if ((sign==-1) && (str[0]!='0')) str =\"-\"+str;     return str; } string MUL_INT(string str1,string str2) {//高精度乘法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         sign*=-1;         str1 =str1.erase(0,1);     }     if (str2[0]=='-') {         sign*=-1;         str2 =str2.erase(0,1);     }     int i,j;     string::size_type L1,L2;     L1=str1.size();     L2=str2.size();     for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式         string tempstr;         int int1=0,int2=0,int3=int(str2[i])-'0';         if (int3!=0) {             for (j=1;j<=(int)(L2-1-i);j++) tempstr=\"0\"+tempstr;             for (j=L1-1;j>=0;j--) {                 int1=(int3*(int(str1[j])-'0')+int2)%10;                 int2=(int3*(int(str1[j])-'0')+int2)/10;                 tempstr=char(int1+'0')+tempstr;             }             if (int2!=0) tempstr=char(int2+'0')+tempstr;         }         str=ADD_INT(str,tempstr);     }     //去除结果中的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str=\"0\";     if ((sign==-1) && (str[0]!='0')) str=\"-\"+str;     return str; } string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数     string quotient,residue; //定义商和余数     int sign1=1,sign2=1;     if (str2 == \"0\") {  //判断除数是否为0         quotient= \"ERROR!\";         residue = \"ERROR!\";         if (flag==1) return quotient;         else         return residue ;     }     if (str1==\"0\") { //判断被除数是否为0         quotient=\"0\";         residue =\"0\";     }     if (str1[0]=='-') {         str1   = str1.erase(0,1);         sign1 *= -1;         sign2  = -1;     }     if (str2[0]=='-') {         str2   = str2.erase(0,1);         sign1 *= -1;     }     int res=compare(str1,str2);     if (res<0) {         quotient=\"0\";         residue =str1;     } else if (res == 0) {         quotient=\"1\";         residue =\"0\";     } else {         string::size_type L1,L2;         L1=str1.size();         L2=str2.size();         string tempstr;         tempstr.append(str1,0,L2-1);         for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式             tempstr=tempstr+str1[i];             tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加             if (tempstr.empty()) tempstr=\"0\";//zhao4zhong1添加             for (char ch='9';ch>='0';ch--) { //试商                 string str;                 str=str+ch;                 if (compare(MUL_INT(str2,str),tempstr)<=0) {                     quotient=quotient+ch;                     tempstr =SUB_INT(tempstr,MUL_INT(str2,str));                     break;                 }             }         }         residue=tempstr;     }     //去除结果中的前导0     quotient.erase(0,quotient.find_first_not_of('0'));     if (quotient.empty()) quotient=\"0\";     if ((sign1==-1)&&(quotient[0]!='0')) quotient=\"-\"+quotient;     if ((sign2==-1)&&(residue [0]!='0')) residue =\"-\"+residue ;     if (flag==1) return quotient;     else         return residue ; } string DIV_INT(string str1,string str2) {//高精度除法,返回商     return DIVIDE_INT(str1,str2,1); } string MOD_INT(string str1,string str2) {//高精度除法,返回余数     return DIVIDE_INT(str1,str2,0); } int main() {     char ch;     string s1,s2,res;      while (cin>>s1>>ch>>s2) {         switch (ch) {             case '+':res=ADD_INT(s1,s2);break;             case '-':res=SUB_INT(s1,s2);break;             case '*':res=MUL_INT(s1,s2);break;             case '/':res=DIV_INT(s1,s2);break;             case '%':res=MOD_INT(s1,s2);break;             default :                   break;         }         cout<<res<<endl;     }     return(0); }  他赵老湿也会说那 万一输入一个1亿亿亿亿亿亿亿亿位的数呢？ 万一输入罗马数字呢？ 万一输入中文大写数字呢？ 万一不是数呢？", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "经一事，长一智! 习惯这东西，不好改", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "引用 10 楼 均陵鼠侠 的回复:赵老湿能不能改一下程序，让数组a能同时应付和保存char，wchar_t，char16_t和char32_t类型的编码？这事要是做成了，也是大功一件。  [quote=引用 8 楼 赵4老师 的回复:]我特别喜欢“快活的气氛”这个字眼。 疫情下，全球郁闷的氛围中，缺的不就是“快活的气氛”嘛！ [/quote] 那你还是饶了我这把老骨头吧。  字符串那些事儿：BSTR-LPSTR-LPWSTR-CString-VARIANT-COleVariant-_variant_t-CComBSTR-_bstr_t.txt http://blog.csdn.net/pizi0475/archive/2010/03/04/5346708.aspx  人生路， 美梦似路长 路里风霜， 风霜扑面干", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "楼主真正搞笑的只有告诉老赵(unsigned int)a[i]更正确这一句，其他所有的“插科打诨”都是为了掩盖这一句，把你的喜剧天赋发挥得淋漓尽致～～～", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "赵老湿能不能改一下程序，让数组a能同时应付和保存char，wchar_t，char16_t和char32_t类型的编码？这事要是做成了，也是大功一件。  引用 8 楼 赵4老师 的回复:我特别喜欢“快活的气氛”这个字眼。 疫情下，全球郁闷的氛围中，缺的不就是“快活的气氛”嘛！", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "CSDN的人气越来越不济了，自己顶一顶。 我就说赵老湿，你就演示一个5加7等于12，何必弄一个long long signed，搞一个int还省力气，你也不嫌累。赵老湿哪肯啊，当时就改了一下程序，说你看， this_is_a_var_a = 12394572389446723543; 这不就有用了吗？赵老湿的神武一下子让大家佩服得不行不行的，楼里都说我不对，夸赵老湿你well done，干得漂亮，就应该这样！不声明成long long数字就容易被截断出现错误。看了大家的发言，越老湿一下子神气起来，酒店里充满了快活的空气。", "referer": "user-0"}]}
{"question": "请教，没有指定形参的函数，为啥可以传参？谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 23 楼 早打大打打核战争 的回复:跟“编译器的漏洞”没关系，C的函数原型f()等于f(...)，而C++的f()等于f(void)，这是C和C++的重要区别之一 谢谢大神", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "跟“编译器的漏洞”没关系，C的函数原型f()等于f(...)，而C++的f()等于f(void)，这是C和C++的重要区别之一", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "有的编译器没检查，有的会检查，这么用肯定是不对的，所以可以理解为编译器的漏洞，不要这么用就可以了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 20 楼 oracleperl 的回复:[quote=引用 9 楼 5250 的回复:]没有参数  默认是可以传递参数的  除非参数为void 谢谢大神， 那最多可以传几个参数呢？ 谢谢[/quote]  内存角度来看，函数的参数是要入栈的，栈区大小决定了参数的个数。一般C语言程序运行时默认1M的栈空间，以int类型的参数来看，1M=1024KB=1024*1024字节，32位系统中int类型占4个字节，所以理论上一个函数最多有262144个int类型的参数。实际中要远远小于这个数，因为应用程序中的局部变量都需要占用栈空间。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 9 楼 5250 的回复:没有参数  默认是可以传递参数的  除非参数为void 谢谢大神， 那最多可以传几个参数呢？ 谢谢", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "https://zh.cppreference.com/w/c/language/operator_other#.E5.87.BD.E6.95.B0.E8.B0.83.E7.94.A8", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "调用约定 https://docs.microsoft.com/zh-cn/cpp/cpp/calling-conventions?view=vs-2017", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "引用 7 楼 赵4老师 的回复:不看编译器源代码，不看每句C/C++语句对应的汇编指令，你永远是“隔靴搔痒”。   __cdecl   :C和C++缺省调用方式      例子：        void   Input(   int   &m,int   &n);         /*相当于void   __cdecl   Input(int   &m,int   &n);*/      以下是相应的汇编代码：    00401068   lea   eax,[ebp-8]   ;取[ebp-8]地址(ebp-8),存到eax       0040106B   push   eax   ;然后压栈       0040106C   lea   ecx,[ebp-4]   ;取[ebp-4]地址(ebp-4),存到ecx         0040106F   push   ecx   ;然后压栈       00401070   call   @ILT+5(Input)   (0040100a);然后调用Input函数       00401075   add   esp,8   ;恢复栈       从以上调用Input函数的过程可以看出：在调用此函数之前，首先压栈ebp-8,然后压栈ebp-4,然后调用函数Input,最后Input函数调用结束后，利用esp+8恢复栈。由此可见，在C语言调用中默认的函数修饰_cdecl，由主调用函数进行参数压栈并且恢复堆栈。 https://blog.csdn.net/My_heart_/article/details/51520363 https://blog.csdn.net/luoweifu/article/details/52425733    能看明白吗?总之在_cdecl 调用方式中,由调用者来维护参数.如果被调用的函数没有使用任何参数,不对栈进行读取和操作.那么传递任何东西是无所谓的.但是其他调用约定就不行了.具体我没有实验,大体就是这么个事儿", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "引用 14 楼 oracleperl 的回复:[quote=引用 9 楼 5250 的回复:]没有参数  默认是可以传递参数的  除非参数为void  f2 () { return 20; }  f1 (void) { return 20; }  int main() { printf(\"result is=%d\\n\",f2(100)); //不会出错 printf(\"result is=%d\\n\",f1(100)); //出错 return 0; }  谢谢大神，类似 f() 那么可以I传几个参数，参数的类型是什么? [/quote]  自己写一个简单的程序看一下不就行了  几个参数 参数的类型你就试试呗", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  你尤其要迷信你手头的这款编译器。毕竟县官不如现管。", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "这样的写法可以传几个参数？每个参数的类型都是int？我查阅了一些书籍，没找到相关说明 int f() { return 0; }", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 9 楼 5250 的回复:没有参数  默认是可以传递参数的  除非参数为void  f2 () { return 20; }  f1 (void) { return 20; }  int main() { printf(\"result is=%d\\n\",f2(100)); //不会出错 printf(\"result is=%d\\n\",f1(100)); //出错 return 0; }  谢谢大神，类似 f() 那么可以I传几个参数，参数的类型是什么?", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "引用 8 楼 oracleperl 的回复:[quote=引用 7 楼 赵4老师 的回复:]不看编译器源代码，不看每句C/C++语句对应的汇编指令，你永远是“隔靴搔痒”。 谢谢赵老师提醒， 您说的编译器源码，C/C++语句对应的汇编指令，我在哪里看到？ 感谢赵老师[/quote] 编译器源代码：初级Tiny C Compiler；终极gcc/g++ C/C++语句对应的汇编指令：Windows VS20xx，调试时打开汇编指令窗口；Linux g++，gdb调试时，layout asm", "referer": "user-0"}, {"cid": "14", "user": "user-4", "content": "老编译器的毛病。。。。。。", "referer": "user-0"}, {"cid": "15", "user": "user-3", "content": "没有参数  默认是可以传递参数的  除非参数为void  f2 () { return 20; }  f1 (void) { return 20; }  int main() { printf(\"result is=%d\\n\",f2(100)); //不会出错 printf(\"result is=%d\\n\",f1(100)); //出错 return 0; }", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 7 楼 赵4老师 的回复:不看编译器源代码，不看每句C/C++语句对应的汇编指令，你永远是“隔靴搔痒”。 谢谢赵老师提醒， 您说的编译器源码，C/C++语句对应的汇编指令，我在哪里看到？ 感谢赵老师", "referer": "user-0"}, {"cid": "17", "user": "user-5", "content": "不看编译器源代码，不看每句C/C++语句对应的汇编指令，你永远是“隔靴搔痒”。", "referer": "user-0"}, {"cid": "18", "user": "user-0", "content": "引用 5 楼 自信男孩 的回复:[quote=引用 3 楼 oracleperl 的回复:][quote=引用 1 楼 自信男孩 的回复:]c.c:3:1: warning: return type defaults to ‘int’ [-Wimplicit-int]  f2 ()  ^~   走的默认。如果楼主要明白诸如此类问题，可以读一下C标准，了解编译器编译的语法检查规则～ 请教下什么默认？有书籍，文档说明吗？比如C标准？ 哪里可以看到？ 感谢[/quote]  感谢大神 默认的意思就是如果没有定义或者声明，按照int来处理～[/quote] 有书籍或者官方文档说明吗？ 我看到K&R C那本书上说，不指定函数返回类型，那么默认int 但是对函数的参数，假设是 F() 没有说有几个参数，也没说默认是恩么类型 谢谢", "referer": "user-0"}, {"cid": "19", "user": "user-3", "content": "引用 12 楼 oracleperl 的回复:[quote=引用 9 楼 5250 的回复:]没有参数  默认是可以传递参数的  除非参数为void  f2 () { return 20; }  f1 (void) { return 20; }  int main() { printf(\"result is=%d\\n\",f2(100)); //不会出错 printf(\"result is=%d\\n\",f1(100)); //出错 return 0; }  可以I传几个参数？参数的数据类型是什么？ 我仔细阅读了《C和指针》英文版，感觉对函数那一章的陈述，前言不搭后语，没有把概念说清楚 对于没有参数的函数，那本书上是说“假定是正确的”  对于什么是函数原型，更是没有说清楚。。 貌似 int f(int a);  这一行肯定就是函数原型 那么 如下代码的int f(int a) 算不算函数原型呢？ int f(int a) { return 1; } [/quote]  对于无参函数来说，参数是不确定的  你可以给它设置多个参数，多个类型 只要能在栈上放下 理论上都没有错误 但是不建议这样做 不安全。 int f(int a);//这里只是申明了函数，函数的原型即函数的定义   定义的函数要和函数的申明一致 int f(int a) { return 1; } 这个就是函数的原型了   关于函数的申明和定义参考下面链接 https://blog.csdn.net/xingzhe22222/article/details/98870457", "referer": "user-0"}, {"cid": "20", "user": "user-0", "content": "引用 9 楼 5250 的回复:没有参数  默认是可以传递参数的  除非参数为void  f2 () { return 20; }  f1 (void) { return 20; }  int main() { printf(\"result is=%d\\n\",f2(100)); //不会出错 printf(\"result is=%d\\n\",f1(100)); //出错 return 0; }  可以I传几个参数？参数的数据类型是什么？ 我仔细阅读了《C和指针》英文版，感觉对函数那一章的陈述，前言不搭后语，没有把概念说清楚 对于没有参数的函数，那本书上是说“假定是正确的”  对于什么是函数原型，更是没有说清楚。。 貌似 int f(int a); 这一行肯定就是函数原型 那么 如下代码的int f(int a) 算不算函数原型呢？ int f(int a) { return 1; }", "referer": "user-0"}]}
{"question": "新手c语言求解，新手比较穷，没积分", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-1的回复: 第162行多打了，修改如下：\twhile (scanf(\"%f\", &x) != 1 ) 老哥，谢谢了又是你", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "第162行多打了，修改如下：\twhile (scanf(\"%f\", &x) != 1 )", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "修改如下，供参考：#include <stdio.h> int main() { \tchar ch,c, s[2]; \tint m, n,l,i,a; \tfloat x, y,z; \tprintf(\"Enter the operation of your choice:\"); \tprintf(\"\\na.  add         s.subtract\\n\"); \tprintf(\"m.  multiply       d.divide\\n\"); \tprintf(\"q.quit\\n\"); \tscanf_s(\"%s\", s,2); \tch = s[0]; \trewind(stdin); \twhile (ch != 'q') \t{ \t\tswitch (ch) \t\t{ \t\t\tcase 'a': \t\t\t{  printf(\"Enter  first number:\\n\"); \t\t\twhile (scanf_s(\"%f\", &x) != 1) \t\t\t{ \t\t\t\t//char   c ;                                 while ((c = getchar())!='\\n')                                        putchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t\t} \t\t\t\tfor (i = 10,m=0,l=1;l != 0;i *= 10) \t\t\t\t{ \t\t\t\ta = (int)(x * i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\t m++; \t\t\t \t\t\t\t} \t\t\t\tprintf(\"Enter second number:\\n\"); \t\t\t\twhile (scanf_s(\"%f\", &y) != 1) \t\t\t\t{ \t\t\t\t\t//c = 0; \t\t\t\twhile ((c=getchar()) != '\\n') \t\t\t\t\tputchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t\t} \t\t\t\tfor (i = 10, n = 0,l=1;l != 0;i *= 10) \t\t\t\t{ \t\t\t\ta = (int)(x * i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\tn++;  \t\t\t\t} \t\t\t\tz = x + y; \t\t\t\tif (m == 0 && n == 0) \t\t\t\tprintf(\"%.*f+%.*f=%.*f\\n\", m, x,m, y,m, z); \t\t\t\telse \t\t\t\t{ \t\t\t\t\tif (m > n)  \t\t\t\t\t\tprintf(\"%.*f+%.*f=%.*f\\n\", m, x,m, y,m, z); \t\t\t\t\telse \t\t\t\t\t\tprintf(\"%.*f+%.*f=%.*f\\n\", n, x,n, y,n, z); \t\t\t\t} \t\t\t\t  \t\t\t\tbreak; \t\t\t} \t\t\tcase 's': \t\t\t{  printf(\"Enter  first number:\\n\"); \t\t\twhile (scanf_s(\"%f\", &x) != 1) \t\t\t{ \t\t\t\t //char  c = 0; \t\t\t\twhile ((c=getchar()) != '\\n') \t\t\t\t\tputchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t} \t\t\tfor (i = 10, m = 0,l=1;l != 0;i *= 10) \t\t\t{ \t\t\t\ta = (int)(x *i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\tm++;  \t\t\t} \t\t\tprintf(\"Enter second number:\\n\"); \t\t\twhile (scanf_s(\"%f\", &y) != 1) \t\t\t{ \t\t\t\t //char  c = 0; \t\t\t\twhile ((c=getchar()) != '\\n') \t\t\t\t\tputchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t} \t\t\tfor (i = 10, n = 0,l=1;l != 0;i *= 10) \t\t\t{ \t\t\t\ta = (int)(x * i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\tn++;  \t\t\t} \t\t\tz = x - y; \t\t\tif (m == 0 && n == 0) \t\t\t\tprintf(\"%.*f-%.*f=%.*f\\n\", 0, x,0, y, 0,z); \t\t\telse \t\t\t{ \t\t\t\tif (m > n)  \t\t\t\t\tprintf(\"%.*f-%.*f=%.*f\\n\", m, x, m, y, m, z); \t\t\t\telse \t\t\t\t\tprintf(\"%.*f-%.*f=%.*f\\n\", n, x, n, y, n, z); \t\t\t}  \t\t\tbreak; \t\t\t} \t\t\tcase 'm': \t\t\t{  printf(\"Enter  first number:\\n\"); \t\t\twhile (scanf_s(\"%f\", &x) != 1) \t\t\t{                                 //char c = 0; \t\t\t\twhile ((c=getchar()) != '\\n') \t\t\t\t\tputchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t} \t\t\tfor (i = 10, m = 0,l=1;l != 0;i *= 10) \t\t\t{ \t\t\t\ta = (int)(x * i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\tm++;  \t\t\t} \t\t\tprintf(\"Enter second number:\\n\"); \t\t\twhile (scanf_s(\"%f\", &y) != 1) \t\t\t{ \t\t\t\t // char c = 0; \t\t\t\twhile ((c=getchar()) != '\\n') \t\t\t\t\tputchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t} \t\t\tfor (i = 10, n = 0,l=1;l != 0;i *= 10) \t\t\t{ \t\t\t\ta = (int)(x * i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\tn++;  \t\t\t} \t\t\tz = x * y; \t\t\tif (m == 0 && n == 0) \t\t\t\tprintf(\"%.*f*%.*f=%.*f\\n\", 0, x,0, y,0, z); \t\t\telse \t\t\t{ \t\t\t\tif (m > n)  \t\t\t\t\tprintf(\"%.*f*%.*f=%.*f\\n\", m, x, m, y, m, z); \t\t\t\telse \t\t\t\t\tprintf(\"%.*f*%.*f=%.*f\\n\", n, x, n, y, n, z); \t\t\t}  \t\t\tbreak; \t\t\t} \t\t\tcase 'd': \t\t\t{  printf(\"Enter  first number:\\n\"); \t\t\twhile (scanf_s(\"%f\", &x) != 1) != 1) \t\t\t{ \t\t\t\t//char c = 0; \t\t\t\twhile ((c = getchar()) != '\\n') \t\t\t\t\tputchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t} \t\t\tfor (i = 10, m = 0, l = 1;l != 0;i *= 10) \t\t\t{ \t\t\t\ta = (int)(x * i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\tm++;  \t\t\t} \t\t\tprintf(\"Enter second number:\\n\"); \t\t\twhile (scanf_s(\"%f\", &y) != 1 && !((y > -0.0000001) && (y < 0.0000001))) \t\t\t{ \t\t\t\t//char c = 0; \t\t\t\twhile ((c = getchar()) != '\\n') \t\t\t\t\tputchar(c); \t\t\t\tprintf(\" is not a number ,the correct number such as -1 ,3 or 25,please enter again\\n\"); \t\t\t\tif ((y > -0.0000001) && (y < 0.0000001)) \t\t\t\t{ \t\t\t\t\tprintf(\"the divisor can not be 0. please enter again\\n\"); \t\t\t\t\tcontinue; \t\t\t\t} \t\t\t} \t\t\tfor (i = 10, n = 0, l = 1;l != 0;i *= 10) \t\t\t{ \t\t\t\ta = (int)(x * i); \t\t\t\tl = a % 10; \t\t\t\tif (l != 0) \t\t\t\t\tn++; \t\t\t} \t\t\tz = x / y; \t\t\tif (m == 0 && n== 0) \t\t\t\tprintf(\"%.*f/%.*f=%.*f\\n\", 0, x,0, y,0, z); \t\t\telse \t\t\t{ \t\t\t\tif (m > n)  \t\t\t\t\tprintf(\"%.*f/%.*f=%.*f\\n\", m, x, m, y, m, z); \t\t\t\telse \t\t\t\t\tprintf(\"%.*f/%.*f=%.*f\\n\", n, x, n, y, n, z); \t\t\t}  \t\t\tbreak; \t\t\t}  \t\t\tcase 'q': break; \t\t\tdefault : \t\t\t{ \t\t\t\tprintf(\"Enter the operation of your choice:\"); \t\t\t\tprintf(\"\\na.  add         s.subtract\\n\"); \t\t\t\tprintf(\"m.  multiply       d.divide\\n\"); \t\t\t\tprintf(\"q.quit\\n\"); \t\t\t\tscanf_s(\"%s\", s, 2); \t\t\t\tch = s[0]; \t\t\t\tcontinue; \t\t\t}  \t\t} \t\tprintf(\"Enter the operation of your choice:\"); \t\tprintf(\"\\na.  add         s.subtract\\n\"); \t\tprintf(\"m.  multiply       d.divide\\n\"); \t\tprintf(\"q.quit\\n\"); \t\tscanf_s(\"%s\", s, 2); \t\tch = s[0]; \t} \treturn 0; }", "referer": "user-0"}]}
{"question": "如何用C语言读取一个TXT文件里的特定数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//方案一,逻辑简单粗暴 BOOL CheckStr(char *src,char *comp) { \tif(NULL==src)  return FALSE; //原串未分配 \tif(NULL==comp) return FALSE; //比较串未分配 \tif(*src<0x20)  return FALSE; //原串空串 \tif(*comp<0x20) return FALSE; //比较串空串 \tchar *p1=src,*p2=src; \tchar *p3=comp,*p4=comp; \twhile(1)  \t{ \t\tif(*(p4+1)<0x20) break;    //比较串串尾 \t\tif(*p2<0x20) return FALSE; //原串比比较串还短 \t\tp4++; \t\tp2++; \t} \twhile(1) \t{ \t\tif(*p2<0x20) return FALSE; //原串扫描完成,没有匹配上串 \t\tchar *pa=p1; \t\tchar *pb=p3; \t\twhile(1) \t\t{ \t\t\tif(*pa!=*pb) break; \t\t\tif(pb==p4) return TRUE; //匹配成功 \t\t\tpa++; \t\t\tpb++; \t\t} \t\tp1++; \t\tp2++; \t} \treturn FALSE; //这里其实永远不会被执行了 }  应用 if(CheckStr(buf,\"ACCE\\0\")) { \tprintf(\"文本行%s里包含的串ACCE\\n\"); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我是要把MATLAB转成C语言，然后在板子上跑，不是单纯的提取数据", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你用EXCEL不香么 先用冒号，分成不同的列。 然后按关键字排序 也行吧", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢您的参考，我现在做的是要把MATLAB程序转成C程序，在MATLAB文件里他是把ACCE、GYRO、MAGN以及GNSS后面的数据一条一条的放在了矩阵里，那在C语言里我想就是放在二维数组里，我想做到就是读文件相对应的数据放在数组里，后续用的时候可以直接提取相对应的数组。因为是刚接触，所以不太会改你的这个参考，您能针对我的情况写个大概的参考嘛，万分感谢~", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen(\"data.txt\",\"r\");     if (NULL==f) {         printf(\"Can not open file data.txt!\\n\");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,\"NAME: %31[^\\n]\",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,\"DIMENSION: %d\",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,\"DATA\\n\")) st=3;         } else if (st==3) {             if (3==sscanf(ln,\"%d%d%d\",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf(\"s.NAME=[%s]\\n\",s.NAME);     printf(\"s.DIMENSION=%d\\n\",s.DIMENSION);     for (i=0;i<n;i++) {         printf(\"s.DATA[%d].NO,X,Y=%d,%d,%d\\n\",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "一行一行的读取，然后比较，比如可以比较关键字，找到ACCE", "referer": "user-0"}]}
{"question": "新手求助，，，谢谢 程序编译不了，求能帮忙找到错误，程序较大，另一点以发回复", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <conio.h> #include <stdio.h> #include <string.h> #include <stdlib.h> const int N=1000; typedef struct { \tchar name[10]; \tchar num[10]; \tfloat c; } stu; void menu() { \tsystem(\"cls\");  //清屏 \tprintf(\"\\n\\n\\n\\n\\t\\t\\t*********   c语言成绩记录薄   ***********\\n\"); \tprintf(\"\\t\\t\\t|==========================================|\\n\"); \tprintf(\"\\t\\t\\t|*************1.  录入信息  ***************|\\n\"); \tprintf(\"\\t\\t\\t|*************2.  查询成绩  ***************|\\n\"); \tprintf(\"\\t\\t\\t|*************3.  修改信息  ***************|\\n\"); \tprintf(\"\\t\\t\\t|*************4.  添加学生  ***************|\\n\"); \tprintf(\"\\t\\t\\t|*************5.  删除成绩  ***************|\\n\"); \tprintf(\"\\t\\t\\t|*************6.  显示成绩  ***************|\\n\"); \tprintf(\"\\t\\t\\t|*************7.    统计    ***************|\\n\"); \tprintf(\"\\t\\t\\t|*************0.    退出    ***************|\\n\"); \tprintf(\"\\t\\t\\t|==========================================|\\n\"); \tprintf(\"\\t\\t\\t|******************************************|\\n\"); \tprintf(\"\\n\\n\\t\\t\\t      请选择相应的功能<输入编号>:\"); } //录入信息 void input() { \tFILE *fp; \tstu\txs;\t\t\t\t\t\t\t\t\t  /*定义一个结构体变量来装从文件中读出来的数据*/ \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"wb\"))==NULL) { \t\tprintf(\"\\nopen file error\"); \t\tgetchar(); \t\texit(1); \t\tprintf(\"\\n录入格式: 姓名 学号 C语言 \\n\"); \t\tprintf(\"当输入姓名为 end 结束录入\\n\"); \t\twhile(1) { \t\t\tscanf(\"%s\",xs.name); \t\t\tif(strcmp(xs.name,\"end\")==0) break;   //判断姓名是否为LAST，用字符串判断 \t\t\tscanf(\"%s%f\",&xs.num,&xs.c); \t\t\tfprintf(fp,\"%s%s%f\",xs.name,xs.num,xs.c);        //将成绩信息写入文件 \t\t} \t\tfclose(fp); \t} } //姓名定义 void xingming() { \tFILE *fp; \tstu\txs; \tchar nam[10]; \tprintf(\"\\n请输入需要查询的学生姓名: \"); \tscanf(\"%s\",nam); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t} \twhile(!feof(fp))\t\t\t\t\t\t   //判断文件是否到达末尾，即读取文件失败时 \t{ \t\tfread(&xs,sizeof(stu),1,fp); \t\tif(strcmp(xs.name,nam)==0)//按姓名查询时判断输入的姓名是否存在，会循环从数据中找取 \t\t{ \t\t\tprintf(\" 学生的信息如下:\\n\"); \t\t\tprintf(\"\\n%10s %6s %6s\\n\",\"姓名\",\"学号\",\"C语言\"); \t\t\tprintf(\"%10s %6s %6.2f\\n\",xs.name,xs.num,xs.c); \t\t\tbreak; \t\t} \t} \tif(feof(fp)) { \t\tprintf(\"ERROR，查找失败!!!\"); /*学生不存在*/ \t\tfclose(fp); \t} } //学号定义 void xuehao() { \tFILE *fp; \tstu\txs; \tint\tnum; \tprintf(\"\\n请输入需要查询的学生学号: \"); \tscanf(\"%d\",&num); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb\"))==NULL) { \t\tprintf(\"can't open the file\");exit(0); \t} \twhile(!feof(fp)) { \t\tfread(&xs,sizeof(stu),1,fp); \t\tchar numstr[10];sprintf(numstr,\"%d\",num); \t\tif(0==strcmp(xs.num,numstr))/*按学号查询时判断输入的学号是否存在，会循环从数据中找取*/ \t\t{ \t\t\tprintf(\" 学生的信息如下:\\n\"); \t\t\tprintf(\"\\n%10s %6s %6s\\n\",\"姓名\",\"学号\",\"C语言\"); \t\t\tprintf(\"%10s %6s %6.2f\\n\",xs.name,xs.num,xs.c); \t\t\tbreak; \t\t} \t} \tif(feof(fp)) \t\tprintf(\"ERROR，查找失败!!!\"); \tfclose(fp); } //查询 void search() { \tchar ch1; \tsystem(\"cls\"); \tprintf(\"请选择何种方式查询<编号>:\\n\"); \tprintf(\"1->姓名，2->学号:\"); \tch1=getchar();\t\t\t\t/*用字符接收*/ \tswitch(ch1)\t\t\t\t\t/*判断*/ \t{ \tcase '1':xingming();break; \tcase '2':xuehao();break; \t} \tgetch();\t\t\t\t\t   /*让屏幕停留同时按任意键返回*/ } //修改:输入学生的姓名,查找该学生，若找到则修改该生的成绩信息，并显示修改前后的结果; void modify1() {  \tstu\txs; \tFILE *fp; \tchar name[10]; \tprintf(\"\\n请输入要修改的学生姓名: \"); \tscanf(\"%s\",name); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb+\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t} \twhile(!feof(fp)) { \t\tfread(&xs,sizeof(stu),1,fp); \t\tif(strcmp(xs.name,name)==0)\t\t\t\t\t\t /*判断输入要修改的姓名是否存在*/ \t\t{ \t\t\tprintf(\" 修改前学生的信息:\\n\"); \t\t\tprintf(\"\\n%10s %6s %6s\\n\",\"姓名\",\"学号\",\"C语言\"); \t\t\tprintf(\"%10s %6s %6.2f\\n\",xs.name,xs.num,xs.c); \t\t\tprintf(\"\\n请输入 C语言成绩 :\"); \t\t\tscanf(\"%f\",&xs.c); \t\t\tbreak; \t\t} \t} \tif(!feof(fp)) { \t\tprintf(\" \\n 修改后的学生的信息如下:\\n\"); \t\tprintf(\"\\n%10s %6s %6s\\n\",\"姓名\",\"学号\",\"C语言\"); \t\tprintf(\"%10s %6s %6.2f\\n\",xs.name,xs.num,xs.c); \t\tfseek(fp,-sizeof(stu),1);\t//负号表示后退，1表示文件当前位置 \t\tfprintf(fp,\"%s%s%f\",xs.name,xs.num,xs.c);  //再重新写入，同时把之前的要修改的覆盖掉 \t} else \t\tprintf(\"\\nERROR，学生不存在，修改失败!!\"); \tfclose(fp); \tgetch(); } //修改:输入学生的学号,查找该学生，若找到则修改该生的成绩信息，并显示修改前后的结果; void modify2() { \tstu\txs; \tFILE *fp; \tint\tnum; \tprintf(\"\\n请输入要修改的学生学号: \"); \tscanf(\"%d\",&num); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb+\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t}  \twhile(!feof(fp)) { \t\tfread(&xs,sizeof(stu),1,fp); \t\tchar numstr[10];sprintf(numstr,\"%d\",num); \t\tif(0==strcmp(xs.num,numstr))/*按学号查询时判断输入的学号是否存在，会循环从数据中找取*/ \t\t{ \t\t\tprintf(\" 修改前学生的信息如下:\\n\"); \t\t\tprintf(\"\\n%10s %6s %6s\\n\",\"姓名\",\"学号\",\"C语言\"); \t\t\tprintf(\"%10s %6s %6.2f\\n\",xs.name,xs.num,xs.c); \t\t\tprintf(\"\\n请输入C语言\"); \t\t\tscanf(\"%f\",&xs.c); \t\t\tbreak; \t\t} \t} \tif(!feof(fp)) { \t\tprintf(\" \\n 修改后的学生的信息如下:\\n\"); \t\tprintf(\"\\n%10s %6s %6s\\n\",\"姓名\",\"学号\",\"C语言\"); \t\tprintf(\"%10s %6s %6.2f\\n\",xs.name,xs.num,xs.c); \t\tfseek(fp,-sizeof(stu),1); \t\tfwrite(&xs,sizeof(stu),1,fp); \t} else \t\tprintf(\"\\nERROR，学生不存在，修改失败!!\"); \tgetch(); \tfclose(fp);  } //选择修改方式 void modiway() { \tchar ch1; \tsystem(\"cls\"); \tprintf(\"请输入按何种方式修改<编号>:\\n\"); \tprintf(\"1->姓名，2->学号:\"); \tch1=getchar();\t\t /*用字符接收*/ \tswitch(ch1)\t\t\t /*判断*/ \t{ \tcase '1':modify1();break; \tcase '2':modify2();break; \t}  \tgetch();/*让屏幕停留同时按任意键返回*/ } //插入:输入学生的平时的各项成绩，插入到指定位置;当指定的位置超出范围时，将其插入到全班的最后，并显示插入成功后的结果 void insert() { \tint\ti=0,j,k,lenth; \tFILE *fp; \tstu\ts,xs[N]; \tsystem(\"cls\"); \tprintf(\"\\n请输入添加的学生的姓名:\"); \tscanf(\"%s\",&s.name); \tprintf(\"\\n学生的学号:\");scanf(\"%s\",s.num); \tprintf(\"\\n学生的成绩：C语言:\");scanf(\"%f\",&s.c); \tprintf(\"\\n请输入插入到第几行:\");scanf(\"%d\",&k); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t} \twhile(!feof(fp)) { \t\tfread(&xs[i],sizeof(stu),1,fp);/*把数据读入到结构体数组中*/ \t\tif(feof(fp)) break; \t\ti++; \t} \tfclose(fp); \tlenth=i;\t\t\t\t\t\t\t//记录此时lenth最大 \tif(k<lenth && k>=0)\t\t\t\t\t/*k的位置要位于数组范围之内*/ \t{ \t\tfor(j=lenth-1;j>=k;j--) \t\t\txs[j+1]=xs[j];\t\t\t\t /*一开始j是最大的，往后移一个这样移动避免数据被覆盖*/ \t\txs[k]=s;\t\t\t\t\t /*将输入的学生信息加入这个k位置*/ \t\tlenth++;\t\t\t\t   //增加一个学生空间，否则会少一个数据 \t\tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"wb\"))==NULL) { \t\t\tprintf(\"不能建立文件!!\\n\");exit(0); \t\t} \t\tfor(i=0;i<lenth;i++) \t\t\tfwrite(&xs[i],sizeof(stu),1,fp);  //存入数据 \t} else/*不再数组范围之内*/ \t{ \t\tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"ab\"))==NULL) { \t\t\tprintf(\"不能建立文件!!\\n\");exit(0); \t\t} \t\tfwrite(&s,sizeof(stu),1,fp); \t} \tfclose(fp); } //显示 void print() { \tFILE *fp; \tstu\ts; \tsystem(\"cls\"); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t} \tprintf(\"\\n%10s %s %6s\\n\",\"姓名\",\"学号\",\"C语言\"); \twhile(!feof(fp)) { \t\tfread(&s,sizeof(stu),1,fp);\t //从文件中读取成绩信息 \t\tif(feof(fp)) break;\t\t  //判断是否文件尾 \t\tprintf(\"%10s %s %6.2f\\n\",s.name,s.num,s.c); \t} \tfclose(fp); \tgetch(); } //删除:输入学生姓名，若该学生存在，则删除，并显示删除后余下的学生成绩信息  void delete1() {  \tstu\txs[N]; \tFILE *fp; \tchar name[10]; \tint\ti=0,len,k=-1/*k<0是为后面if判断用的*/; \tsystem(\"cls\"); \tprintf(\"\\n请输入要删除的学生姓名: \");scanf(\"%s\",name); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb+\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t} \twhile(!feof(fp)) { \t\tfread(&xs[i],sizeof(stu),1,fp); \t\tif(feof(fp)) break; \t\tif(strcmp(xs[i].name,name)==0) k=i; \t\ti++; \t} \tfclose(fp);  \t//以下是删除后重新写文件  \tlen=i;/*结构体数组上限*/ \tif(k>=0)/*k>0说明找到删除学生位置*/ \t{ \t\tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"wb+\"))==NULL) { \t\t\tprintf(\"can't open the file!\\n\");exit(0); \t\t} \t\tfor(i=0;i<len;i++) { \t\t\tif(i==k) continue;/*从这个位置开始写入*/ \t\t\tfwrite(&xs[i],sizeof(stu),1,fp); \t\t} \t\tfclose(fp); \t} else { \t\tprintf(\"ERROR,删除失败!!!\\n\");getch(); \t} /*失败后重新返回菜单*/ \tprint(); } //删除:输入学生学号，若该学生存在，则删除，并显示删除后余下的学生成绩信息  void delete2() { \tstu\txs[N]; \tFILE *fp; \tint\tnum; \tint\ti=0,len,k=-1/*k<0是为后面if判断用的*/; \tsystem(\"cls\"); \tprintf(\"\\n请输入要删除的学生学号: \"); \tscanf(\"%d\",&num); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb+\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t} \tchar numstr[10];sprintf(numstr,\"%d\",num); \twhile(!feof(fp)) { \t\tfread(&xs[i],sizeof(stu),1,fp); \t\tif(feof(fp)) break; \t\tif(0==strcmp(xs[i].num,numstr))/*按学号查询时判断输入的学号是否存在，会循环从数据中找取*/ \t\t\tk=i; \t\ti++; \t} \tfclose(fp); \t//以下是删除后重新写文件  \tlen=i;/*结构体数组上限*/ \tif(k>=0)/*k>0说明找到删除学生位置*/ \t{ \t\tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"wb+\"))==NULL) { \t\t\tprintf(\"can't openfile!\\n\");exit(0); \t\t} \t\tfor(i=0;i<len;i++) { \t\t\tif(i==k) continue;/*从这个位置开始写入*/ \t\t\tfwrite(&xs[i],sizeof(stu),1,fp); \t\t} \t\tfclose(fp); \t} else { \t\tprintf(\"ERROR,删除失败!!!\\n\");getch(); \t} /*失败后重新返回菜单*/ \tprint(); } //删除  void deleteway() { \tchar ch1; \tsystem(\"cls\"); \tprintf(\"请输入按何种方式删除:\\n\"); \tprintf(\"1->姓名，2->学号:\"); \tch1=getchar();/*用字符接收*/ \tswitch(ch1)/*判断*/ \t{ \tcase '1':delete1();break; \tcase '2':delete2();break; \t} \tgetch();/*让屏幕停留同时按任意键返回*/ } //统计C语言成绩情况  void count() { \tint\ti=0,j=0,k=0,l=0,m=0,n,p,q,r,t,u;   //j,k,m,l分别是指各个分数段，n,p,q,r也是 \tFILE *fp; \tstu\ts[N], *p1[N],*p2[N],*p3[N],*p4[N];/*用指针数组*/ \tsystem(\"cls\"); \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"rb\"))==NULL) { \t\tprintf(\"can't open the file!\\n\");exit(0); \t} \twhile(!feof(fp)) { \t\tfread(&s[i++],sizeof(stu),1,fp);/*读入数据*/ \t\tif(feof(fp)) break;\t //到文件末尾中断程序 \t} \tt=i;i=0;\t\t   //t 指最大 \tfor(u=0;u<t;u++)/*以下每个指针数组用于指向各分数段的学生信息*/ \t{ \t\tif(s[i].c<60) { \t\t\tp1[j++]=&s[i++];continue; \t\t}\t\t\t\t\t\t\t\t\t  /*每个学生信息只能位于一个分数段*/ \t\tif(s[i].c>=60 && s[i].c<80)\t{ \t\t\tp2[k++]=&s[i++];continue; \t\t} \t\tif(s[i].c>=80 && s[i].c<90)\t{ \t\t\tp3[l++]=&s[i++];continue; \t\t} \t\tif(s[i].c>=90) { \t\t\tp4[m++]=&s[i++];continue; \t\t} \t} \tprintf(\"     不及格:姓名 学号 C语言\\n\"); \tfor(n=0;n<j-1;n++) { \t\tprintf(\"%14s %4s %6.2f\\n\",p1[n]->name,p1[n]->num,p1[n]->c);      //逐个显示个分数段信息，显示上面指针的内容 \t} \tprintf(\" 60-79分之间:姓名 学号 C语言\\n\"); \tfor(p=0;p<k;p++) { \t\tprintf(\"%16s %4s %6.2f\\n\",p2[p]->name,p2[p]->num,p2[p]->c); \t} \tprintf(\" 80-89分之间:姓名 学号 C语言\\n\"); \tfor(q=0;q<l;q++) { \t\tprintf(\"%16s %4s %6.2f\\n\",p3[q]->name,p3[q]->num,p3[q]->c); \t} \tprintf(\"90以上:姓名 学号 C语言\\n\"); \tfor(r=0;r<m;r++) { \t\tprintf(\"%12s %4s %6.2f\\n\",p4[r]->name,p4[r]->num,p4[r]->c); \t} \tfclose(fp); \tgetch(); } int\tmain() { \tFILE *fp; \tif((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"wb\"))==NULL) \t{ \t\tprintf(\"\\nopen file error\"); \t\tgetchar(); \t\texit(1); \t} \tchar ch; \twhile(1) \t{ \t\tmenu();// 显示菜单 \t\tch=getch();//选择菜单 \t\tif(ch=='0') \t\tbreak; \t\tswitch(ch)//判断功能项 \t\t{ \t\t\tcase '1':input();break; \t\t\tcase '2':search();break; \t\t\tcase '3':modiway();break; \t\t\tcase '4':insert();break; \t\t\tcase '5':deleteway();break; \t\t\tcase '6':print();break; \t\t\tcase '7':count();break; \t\t} \t} \tprintf(\"\\n\\n\\n\\t\\t\\t\\tWelcome to use,Goodbye!\\02!\\n\"); \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "出错信息呢？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "很疑惑，自己写的代码怎么会编译不过去呢？还一下子写这么多，不应该的。  有些函数会要求对应的库函数，需要include对应的头文件。  如果是从别处拷贝的代码，建议了解一下代码的编译运行环境，比如编译器等等。然后再修改成自己编译器识别的函数。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "盯住第一条出错信息，思考，改之，然后再编译。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "\"%14s %4s %6.2f\\n\",p1[n]->name,p1[n]->num,p1[n]->c);      //逐个显示个分数段信息，显示上面指针的内容 \t}     printf(\" 60-79分之间:姓名 学号 C语言\\n\");     for(p=0;p<k;p++) \t{         printf(\"%16s %4s %6.2f\\n\",p2[p]->name,p2[p]->num,p2[p]->c); \t}     printf(\" 80-89分之间:姓名 学号 C语言\\n\");     for(q=0;q<l;q++) \t{         printf(\"%16s %4s %6.2f\\n\",p3[q]->name,p3[q]->num,p3[q]->c); \t}     printf(\"90以上:姓名 学号 C语言\\n\");     for(r=0;r<m;r++) \t{         printf(\"%12s %4s %6.2f\\n\",p4[r]->name,p4[r]->num,p4[r]->c); \t}     fclose(fp);     getch(); } int main() { FILE *fp; if((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"wb\"))==NULL) { printf(\"\\nopen file error\"); getchar(); exit(1); } char ch;     while(1) \t{       menu();// 显示菜单       ch=getch();//选择菜单       if(ch=='0')  \t\t  break;       switch(ch)//判断功能项 \t  {       case '1':input();break;       case '2':search();break;       case '3':modiway();break;       case '4':insert();break; \t  case '5':deleteway();break;       case '6':print();break; \t  case '7':count();break; \t  } \t}  \tprintf(\"\\n\\n\\n\\t\\t\\t\\tWelcome to use,Goodbye!\\02!\\n\"); \treturn ; }", "referer": "user-0"}]}
{"question": "水仙花数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 weixin_54530767 的回复:[quote=引用 1 楼 自信男孩的回复:]先求出水仙花，然后对10取余。从低位到高位，最后留出前两位就好了吧 请问可以给一下求出水仙花后的代码吗，谢谢大佬了[/quote] 你先把求水仙花的代码发出来吧，我在你的基础上做一下修改", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：int main() {    int m,n,sum;    for(int i=100;i<1000;i++){       m = i;       sum=0;       while(m){           n=m%10;           m/=10;           sum += n*n*n;       }       if(sum == i)printf(\"i=%d,%d,%d\\n\",i,i/100,i/10%10);    }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include <stdio.h> #include <math.h>  int check_narcissus (int num, char *digit, int len) {     int tmp = num;     int sum = 0, i = 0;      while (tmp) {         sum += pow(tmp % 10, 3);         digit[i%len] = tmp % 10 + '0';         tmp /= 10;         i++;     }     if (sum == num)         return 1;      return 0; }  int main() { #if 0     int i;     char digit[3] = {0};      for (i = 100; i < 1000000; i++) {         if (check_narcissus(i, digit, 2))             printf(\"%d is narcissus number, %s!\\n\", i, digit);     }  #else     int data,hun,ten,digit,count=0;      for(data=100;data<1000;data++)     {         hun = data/100  % 10;         //ten=(data-data-hun*100);         ten = (data / 10) % 10;         digit = data%10;         //if(data==hun*hun*hun+ten*ten*ten*digit*digit*digit)         if(data==hun*hun*hun+ten*ten*ten+digit*digit*digit)             printf(\"%d, two bit: %d\\n\", data, data / 10);     }  #endif      return 0; } 供参考～  既然知道水仙数是一个三位数，求前两位不很容易吗？直接除10就能得到了，也不用我这么麻烦。  楼主的求水仙数有问题。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include<stdio.h> int main() {    int data,hun,ten,digit,count=0;    for(data=100;data<1000;data++)       {         hun=data/100;         ten=data/10%10;       //ten=(data-data-hun*100);         digit=data%10;       //if(data==hun*hun*hun+ten*ten*ten*digit*digit*digit)         if(data==hun*hun*hun+ten*ten*ten+digit*digit*digit)           {             count++;             if(count<=2) printf(\"%d\\n\",data);           }       }     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 8 楼 自信男孩的回复:[quote=引用 4 楼 weixin_54530767 的回复:][quote=引用 1 楼 自信男孩的回复:]先求出水仙花，然后对10取余。从低位到高位，最后留出前两位就好了吧 请问可以给一下求出水仙花后的代码吗，谢谢大佬了[/quote] 你先把求水仙花的代码发出来吧，我在你的基础上做一下修改[/quote] #include<stdio.h> int main() { int data,hun,ten,digit,count=0; for(data=100;data<1000;data++) { hun=data/100; ten=(data-data-hun*100); digit=data%10; if(data==hun*hun*hun+ten*ten*ten*digit*digit*digit) printf(\"%d\",data); } return 0; }  然后后面怎么计数输出2个水仙花数我就不会了。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "while (m != 0)//求m各位数字并求它们立方和             {                 o = m % 10;                 m = m / 10;                 sum = sum + o * o * o;             }                           if (sum == m)//当立方和=本身即输出", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "直接输出a/10就好了么。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:先求出水仙花，然后对10取余。从低位到高位，最后留出前两位就好了吧 请问可以给一下求出水仙花后的代码吗，谢谢大佬了", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "咦？我2楼的写法从前好用啊，为啥现在不好用了？ 哪位大佬释疑？", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "printf(\"%d\\b\\n\",a); 了解一下？", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "先求出水仙花，然后对10取余。从低位到高位，最后留出前两位就好了吧", "referer": "user-0"}]}
{"question": "结构体无法赋值问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "这里我输入了两班这个目的地的但是只出了一班，已输入编号就直接卡住了，也不知道怎么办好。 下午就要交作业了，要崩溃了，老师讲这里都没细讲都是自己学。都很懵", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 2 楼 wu5_chen 的回复:]那请问p0怎么初始化，我这些很多都是从老师给的那个例案抽出来了，然后这里又没学好  然后大佬能解释一下这段while(p0 && p0->next!=NULL&&strcmp(hb_city,p0->hb_city)!=0)是什么意思吗逻辑不是很懂为什么你要加p0&& 因为确保p0不为NULL，如果p0为NULL，主要是针对第一次循环而言的。[/quote] 现在我在订票那里卡住了他订票那不会显示出所有的订单，只有一条订单，然后一输入完乘坐航班编号就直接崩了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 2 楼 wu5_chen 的回复:那请问p0怎么初始化，我这些很多都是从老师给的那个例案抽出来了，然后这里又没学好  然后大佬能解释一下这段while(p0 && p0->next!=NULL&&strcmp(hb_city,p0->hb_city)!=0)是什么意思吗逻辑不是很懂为什么你要加p0&& 因为确保p0不为NULL，如果p0为NULL，主要是针对第一次循环而言的。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "typedef struct hangban {     char hb_num[20];     char hb_time[20];     char hb_city[20];     int hb_price;     int hb_discount;     int hb_seat;     struct hangban *next;//hangnban改为hangban     int n; }HB;", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "#include<stdio.h> #include <string.h> #include <stdlib.h> #include<conio.h> #define Max 100  typedef struct hangban { \tchar hb_num[20]; \tchar hb_time[20]; \tchar hb_city[20]; \tint hb_price; \tint hb_discount; \tint hb_seat; \tstruct hangnban *next; \tint n; }HB;  typedef struct kehu { \tchar kh_name[20]; \tchar kh_id[20]; \tchar kh_plane_num[20]; \tchar kh_plane_time[20]; \tint  kh_seat_num; \tstruct kehu *next; }KH;  HB *p_hb; KH *p_kh; int n=0; void Wecome(); void Admin(); void Login(); int Menu(); void Menu_select(); void Init(); void New_flight(); void query(); void booking(); void refund_ticket(); void Save(); void Save_hb(); void Save_kh(); void Load(); void Load_hb(); void Load_kh();    void Wecome()  //登录界面 { \tsystem(\"cls\"); \tprintf(\"\\n\\n\\n\\t\\t================================================\\n\"); \tprintf(\"\\t\\t==                                            ==\\n\"); \tprintf(\"\\t\\t==                                            ==\\n\"); \tprintf(\"\\t\\t==            欢迎使用飞机订票系统:           ==\\n\"); \tprintf(\"\\t\\t==      Welcome to the air booking system     ==\\n\"); \tprintf(\"\\t\\t==                                            ==\\n\"); \tprintf(\"\\t\\t==                                            ==\\n\"); \tprintf(\"\\t\\t================================================\\n\"); \tprintf(\"\\t\\t按任意键进入系统..........\\n\"); \tgetch(); \tsystem(\"cls\"); }  void Admin()  //管理员系统 { \tchar yn[2]; \tprintf(\"是否进入管理员系统?(Y/N):\\n\"); \tprintf(\"Do you want to enter the administrator system?(Y/N):\"); \tscanf(\"%s\",yn); \tif((strcmp(yn,\"Y\")==0)||(strcmp(yn,\"y\")==0)) \t{ \t\tsystem(\"cls\"); \t\tLogin(); \t}else \t{ \t\tsystem(\"cls\"); \t\tMenu(); \t} }  void Login()  //管理员登陆 { \tchar admin[12],mima[12]; \tchar yn[2];  \tprintf(\"管理员登录模块...\\n\"); \tprintf(\"Administrator login module...\\n\"); \tprintf(\"请输入管理员用户名:\\n\"); \tprintf(\"Please enter the administrator user name:\"); \tscanf(\"%s\",admin); \tprintf(\"请输入管理员密码:\\n\"); \tprintf(\"Please enter the administrator password:\"); \tscanf(\"%s\",mima); \tif((strcmp(admin,\"123\"))==0&&(strcmp(mima,\"123\"))==0) \t{ \t\tprintf(\"用户名密码正确!!!请按任意键继续...\\n\"); \t\tprintf(\"User name and password are correct! Please press any key to continue\\n\"); \t\tgetch(); \t\tsystem(\"cls\"); \t\tNew_flight(); \t} \telse \t{ \t\tprintf(\"用户名密码错误!!!是否继续输入用户名密码(Y/N):\\n\"); \t\tprintf(\"User name and password error! Do you want to continue to enter user name and password (Y / N):\"); \t\tscanf(\"%s\",yn); \t\tif((strcmp(yn,\"Y\")==0)||(strcmp(yn,\"y\")==0)) \t\t{ \t\t\tsystem(\"cls\"); \t\t\tLogin(); \t\t} \t\telse \t\t{ \t\t\tprintf(\"请按任意键返回界面!!!\"); \t\t\tprintf(\"Please press any key to return to the interface!!!\"); \t\t\tgetch(); \t\t\tsystem(\"cls\"); \t\t\tWecome(); \t\t\tMenu(); \t\t} \t} }  void Init() //初始化 { \tHB *p; \tp=(HB *)malloc(sizeof(HB)); \tp_hb=p;  \tprintf(\"航班信息初始化开始\\n\"); \tprintf(\"航班编号:\\n\"); \tscanf(\"%s\",p->hb_num); \tprintf(\"航班起降时间:\\n\"); \tscanf(\"%s\",p->hb_time); \tprintf(\"航班目的地城市:\\n\"); \tscanf(\"%s\",p->hb_city); \tprintf(\"机票价格:\\n\"); \tscanf(\"%d\",&p->hb_price); \tprintf(\"机票享受折扣:\\n\"); \tscanf(\"%d\",&p->hb_discount); \tprintf(\"航班座位数:\\n\"); \tscanf(\"%d\",&p->hb_seat);   \tp->next=NULL; \tp->n=++n; \tprintf(\"\\n航班信息初始化完成!!!请按任意键继续...\"); \tgetch(); \tsystem(\"cls\"); }  int Menu()  //菜单 { \tint dm; \tprintf(\"\\n\\n\\n\\t\\t================================================\\n\"); \tprintf(\"\\t\\t==                                            ==\\n\"); \tprintf(\"\\t\\t==           1------录入                      ==\\n\"); \tprintf(\"\\t\\t==           2------查询                      ==\\n\"); \tprintf(\"\\t\\t==           3------订票                      ==\\n\"); \tprintf(\"\\t\\t==           4------退票                      ==\\n\"); \tprintf(\"\\t\\t==           5------退出                      ==\\n\"); \tprintf(\"\\t\\t==                                            ==\\n\"); \tprintf(\"\\t\\t================================================\\n\"); \tprintf(\"请输入相应编号:\"); \tfor(;;) \t{  \t\tscanf(\"%d\",&dm); \t\tif(dm<1||dm>5) \t\t{ \t\t\tprintf(\"\\t\\t编号错误!!!请重新输入:!!!\"); \t\t} \t\telse \t\t\tbreak; \t} \treturn dm;   }  void Menu_select()  //菜单选择 { \tfor(;;) \t{ \t\tswitch(Menu()) \t\t{ \t\tcase 5: \t\t\tsystem(\"cls\"); \t\t\tSave();\t \t\t\tprintf(\"\\n\\n\\n\\t\\t================================================\\n\"); \t\t\tprintf(\"\\t\\t==                                            ==\\n\"); \t\t\tprintf(\"\\t\\t==              文件保存成功!!!               ==\\n\"); \t\t\tprintf(\"\\t\\t==            欢迎下次使用本系统!!!           ==\\n\"); \t\t\tprintf(\"\\t\\t==                                            ==\\n\"); \t\t\tprintf(\"\\t\\t================================================\\n\"); \t\t\tgetch(); \t\t\texit(0); \t\tcase 1:Admin();break; \t\tcase 2:query();break; \t\tcase 3:booking();break; \t\t//case 4:refund_ticket();break; \t\tdefault:printf(\"\\n错误!!!\"); \t\t \t\texit(0); \t\t} \t} }  void New_flight() //录入新航班 { \tHB *p,*p0,*p1; \tp=p1=p_hb; \tprintf(\"新航班录入模块...\\n\"); \tprintf(\"请输入您要录入的新航班信息\\n\"); \tp0=(HB *)malloc(sizeof(HB));  S: \tprintf(\"航班编号:\\n\"); \tscanf(\"%s\",p0->hb_num); \t \twhile(strcmp(p0->hb_num,p1->hb_num)!=0&&p1->next!=NULL) \t\tp1=p1->next;  \tif(strcmp(p0->hb_num,p1->hb_num)==0) \t{ \t\tprintf(\"该航班编号已存在!!!请重新输入:\"); \t\tgoto S; \t\tsystem(\"cls\"); \t} \telse \t{ \t\tprintf(\"航班起降时间:\\n\"); \t\tscanf(\"%s\",p0->hb_time); \t\tprintf(\"航班目的地城市:\\n\"); \t\tscanf(\"%s\",p0->hb_city); \t\tprintf(\"机票价格:\\n\"); \t\tscanf(\"%d\",&p0->hb_price); \t\tprintf(\"机票享受折扣:\\n\"); \t\tscanf(\"%d\",&p0->hb_discount); \t\tprintf(\"航班座位数:\\n\"); \t\tscanf(\"%d\",&p0->hb_seat); \t\t \t\twhile(p->next)  \t\t\tp=p->next; \t\t\t \t\tif(p_hb==NULL)  \t\t\tp_hb=p0;   /*此处分两种情况,链表中没有数据,head直接指向p0处*/ \t\t\t \t\telse  \t\t\tp->next=p0; \t  \t\tp0->next=NULL; \t    p0->n=++n; \t} \tprintf(\"\\n新航班已录入完毕!!!请按任意键继续...\"); \tgetch(); \tsystem(\"cls\"); \tWecome();  }  void query()  //查询 { \tHB *p; \tint i,x; \tchar city[20],num[20]; \tp=p_hb;   \tprintf(\"\\n\\n\\n\\t\\t======================================================\\n\"); \tprintf(\"\\t\\t==            查询系统:                             ==\\n\"); \tprintf(\"\\t\\t==           1------客户ID查询                      ==\\n\"); \tprintf(\"\\t\\t==           2------目的地查询                      ==\\n\"); \tprintf(\"\\t\\t==           3------返回界面                        ==\\n\"); \tprintf(\"\\t\\t==                                                  ==\\n\"); \tprintf(\"\\t\\t==                                                  ==\\n\"); \tprintf(\"\\t\\t==                                                  ==\\n\"); \tprintf(\"\\t\\t======================================================\\n\"); \tprintf(\"请输入编号(1-3):\"); \tscanf(\"%d\",&x); \tswitch(x) \t{ \tcase 1:printf(\"请输入您的客户ID:\"); \t\tscanf(\"%s\",&num); \t\tprintf(\"您输入客户ID已订票的航班如下:\\n\"); \tcase 2:printf(\"请输入您的目的地:\"); \tscanf(\"%s\",&city); \tprintf(\"您输入的目的地现有航班如下:\\n\"); \tprintf(\"航班编号\\t起降时间\\t目的地城市\\t机票价格\\t机票折扣\\t航班座位\\n\");  \tfor(i=0;i<p->n;i++) \t{ \t\tif(strcmp(city,p->hb_city)==0) \t\t{ \t\t\tprintf(\"%s\\t%s\\t%s\\t%d\\t%d\\t%d\\n\",p->hb_num,p->hb_time,p->hb_city,p->hb_price,p->hb_discount,p->hb_seat); \t\t\tp=p->next;  \t\t} \t} \tprintf(\"航班信息打印完毕!按任意键继续下一步操作...\"); \tgetch(); \tsystem(\"cls\"); \tMenu(); \tcase 3:getch(); \t\tsystem(\"cls\"); \t\tMenu(); \t \t} }  void booking()  //订票 {     HB *p0; KH *p1,*p2,*p3;     int i;     char hb_city[20],hb_time[20];     p1=p3=p_kh;     p2=(KH *)malloc(sizeof(KH)); \tp0=p_hb;    I:     printf(\"订票系统...\\n\");     printf(\"请输入您的客户ID:\\n\");     scanf(\"%s\",p2->kh_id);     //while(strcmp(p2->kh_id,p3->kh_id)!=0&&p3->next!=NULL)   //如果p3本身就是NULL怎么办？     while(p3 && strcmp(p2->kh_id,p3->kh_id)!=0&&p3->next!=NULL)   //如果p3本身就是NULL怎么办？         p3=p3->next;     if(p3 && strcmp(p2->kh_id,p3->kh_id)==0)     {         printf(\"该客户ID已存在!!!请勿进行多次订票\");         goto I;         system(\"cls\");     }         printf(\"请输入您的名字:\\n\");         scanf(\"%s\",p2->kh_name);     printf(\"请输入您要前往的目的地:\\n\");     scanf(\"%s\", hb_city);        while(p0 && p0->next!=NULL&&strcmp(hb_city,p0->hb_city)!=0)         p0=p0->next;     if(p0 && p0->next!=NULL&&(strcmp(hb_city,p0->hb_city)!=0))     {         printf(\"没有前往该目的地的航班!!!\");         printf(\"请按任意键返回\\n\");     }else     {         printf(\"您输入的目的地现有航班如下:\\n\");         printf(\"航班编号\\t起降时间\\t目的地城市\\t机票价格\\t机票折扣\\t航班座位\\n\");           for(i=0;i<p0->n;i++)         {             if(strcmp(p0->hb_city,hb_city)==0)             {                 printf(\"%s\\t%s\\t%s\\t%d\\t%d\\t%d\\n\",p0->hb_num,p0->hb_time,p0->hb_city,p0->hb_price,p0->hb_discount,p0->hb_seat);                 p0=p0->next;             }         } \t\tprintf(\"请输入您要乘坐的航班编号:\"); \t\tscanf(\"%s\",p2->kh_plane_num); \t\twhile(p0 && p0->next!=NULL&&strcmp(p2->kh_plane_num,p0->hb_num)!=0) \t\t\tp0=p0->next;  \t\tfor(i=0;i<p0->n;i++) \t\t{ \t\t\tif(strcmp(p2->kh_plane_num,p0->hb_num)==0) \t\t\t{ \t\t\t\tstrcpy(p2->kh_plane_num,p0->hb_num); \t\t\t\tstrcpy(p2->kh_plane_time,p0->hb_time); \t\t\t\tp2->kh_seat_num++; \t\t\t\t \t\t\t} \t\t}     }   } void Save() { \tSave_hb(); \tSave_kh(); }  void Save_hb() { \tFILE *fh_hb; \tHB *t,*t0; \tt=p_hb; \tif((fh_hb=fopen(\"hangban.txt\",\"wb\"))==NULL) \t{ \t\tprintf(\"\\n文件保存失败!\\n请重启本系统...\"); \t\texit(0); \t} \twhile(t!=NULL) \t{ \t\tif(fwrite(t,sizeof(HB),1,fh_hb)!=1)  //写入文件 \t\t{ \t\t\tprintf(\"\\n写入文件失败!\\n请重启本系统...\\n\"); \t\t\tt0=t; \t\t\tt=t->next; \t\t\tfree(t0);  //释放所有结点 \t\t} \t} }  void Save_kh() { \tFILE *fh_kh; \tKH *t,*t0; \tt=p_kh; \tif((fh_kh=fopen(\"kehu.txt\",\"wb\"))==NULL) \t{ \t\tprintf(\"\\n文件保存失败!\\n请重启本系统...\"); \t\texit(0); \t} \twhile(t!=NULL) \t{ \t\tif(fwrite(t,sizeof(KH),1,fh_kh)!=1)  //写入文件 \t\t{ \t\t\tprintf(\"\\n写入文件失败!\\n请重启本系统...\\n\"); \t\t\tt0=t; \t\t\tt=t->next; \t\t\tfree(t0); \t\t} \t} }  void Load() { \tLoad_hb(); \tLoad_kh(); }  void Load_hb() { \tHB *p1,*p2,*p3; \tFILE *fh; \tfh=fopen(\"hangban.txt\",\"rb\"); \tp1=(HB *)malloc(sizeof(HB)); \tfread(p1,sizeof(HB),1,fh); \tp_hb=p3=p2=p1; \twhile(! feof(fh)) \t{ \t\tp1=(HB *)malloc(sizeof(HB)); \t\tfread(p1,sizeof(HB),1,fh); \t\tp2->next=p1; \t\tp3=p2; \t\tp2=p1; \t} \tp3->next=NULL; \tfree(p1); \tfclose(fh);  //关闭文件 }  void Load_kh() { \tKH *p1,*p2,*p3; \tFILE *fh; \tfh=fopen(\"kehu.txt\",\"rb\"); \tp1=(HB *)malloc(sizeof(HB)); \tfread(p1,sizeof(HB),1,fh); \tp_kh=p3=p2=p1; \twhile(! feof(fh)) \t{ \t\tp1=(KH *)malloc(sizeof(KH)); \t\tfread(p1,sizeof(KH),1,fh); \t\tp2->next=p1; \t\tp3=p2; \t\tp2=p1; \t} \tp3->next=NULL; \tfree(p1); \tfclose(fh); }  int main() { \tFILE *fh_hb,*fh_kh; \tWecome(); \tif((fh_hb=fopen(\"hangban.txt\",\"rb\"))==NULL||(fh_kh=fopen(\"kehu.txt\",\"rb\"))==NULL) \t{ \t\tInit(); \t}else \t\tLoad();  \tMenu_select(); }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "那请问p0怎么初始化，我这些很多都是从老师给的那个例案抽出来了，然后这里又没学好  然后大佬能解释一下这段while(p0 && p0->next!=NULL&&strcmp(hb_city,p0->hb_city)!=0)是什么意思吗逻辑不是很懂为什么你要加p0&&", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "typedef struct hangban {     char hb_num[20];     char hb_time[20];     char hb_city[20];     int hb_price;     int hb_discount;     int hb_seat;     //struct hb *next;     struct hangban *next;     int n; }HB;  typedef struct kehu {     char kh_name[20];     char kh_id[20];     char kh_plane_num[20];     char kh_plane_time[20];     int  kh_seat_num;     //struct kh *next;     struct kehu *next; }KH; 修改结构体定义  void booking()  //订票 {     HB *p0; KH *p1,*p2,*p3;     int i;     char hb_city[20],hb_time[20];     p1=p3=p_kh;     p2=(KH *)malloc(sizeof(KH));  I:     printf(\"订票系统...\\n\");     printf(\"请输入您的客户ID:\\n\");     scanf(\"%s\",p2->kh_id);     //while(strcmp(p2->kh_id,p3->kh_id)!=0&&p3->next!=NULL)   //如果p3本身就是NULL怎么办？     while(p3 && strcmp(p2->kh_id,p3->kh_id)!=0&&p3->next!=NULL)   //如果p3本身就是NULL怎么办？         p3=p3->next;     if(p3 && strcmp(p2->kh_id,p3->kh_id)==0)     {         printf(\"该客户ID已存在!!!请勿进行多次订票\");         goto I;         system(\"cls\");     }     else     {         printf(\"请输入您的名字:\\n\");         scanf(\"%s\",p1->kh_name);     }     printf(\"请输入您要前往的目的地:\\n\");     //scanf(\"%s\",&hb_city);     scanf(\"%s\", hb_city);     p0 = p_hb;   //需要初始化p0     //while(p0->next!=NULL&&strcmp(hb_city,p0->hb_city)!=0)   //p0没有初始化，是一个野指针     while(p0 && p0->next!=NULL&&strcmp(hb_city,p0->hb_city)!=0)   //p0没有初始化，是一个野指针         p0=p0->next;     if(p0 && p0->next!=NULL&&(strcmp(hb_city,p0->hb_city)!=0))     {         printf(\"没有前往该目的地的航班!!!\");         printf(\"请按任意键返回\\n\");     }else     {         printf(\"您输入的目的地现有航班如下:\\n\");         printf(\"航班编号\\t起降时间\\t目的地城市\\t机票价格\\t机票折扣\\t航班座位\\n\");          for(i=0;i<p0->n;i++)         {             if(strcmp(p0->hb_city,hb_city)==0)             {                 printf(\"%s\\t%s\\t%s\\t%d\\t%d\\t%d\\n\",p0->hb_num,p0->hb_time,p0->hb_city,p0->hb_price,p0->hb_discount,p0->hb_seat);                 p0=p0->next;             }         }     }  }  函数的修改  供参考～", "referer": "user-0"}]}
{"question": "GDB脚本问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "对gdb没有或暂时不会用的显示自定义数据及其自定义数据值功能，我都是自己写一小段程序完成对应功能辅助调试的。  不要依赖调试器输出复杂数据结构！而要将复杂数据结构的整个内容在处理它的每一步使用一小段代码按自己很容易理解的格式输出，非常有助于调试！或者可以说是“基础设施”  参考： 数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "gcc内嵌汇编语法？这跟gdb脚本有什么关系？能为我讲解一下吗，我是新手不是很懂", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "https://www.baidu.com/s?wd=gcc%E5%86%85%E5%B5%8C%E6%B1%87%E7%BC%96%E8%AF%AD%E6%B3%95", "referer": "user-0"}]}
{"question": "请教原型的概念，谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第一，我不是大神。 第二，我的启蒙教材也是K&R系语法，而且不是你这个这么经典。我只不过走过弯路在总结教训。我后来观念的改正是零零碎碎的，不是整体读哪本书来的。所以没法推荐教材。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 forever74 的回复:现代C语言和K&R C的关系，就像汉语普通话和北京腔的关系。  您要全盘照搬啊？那以后...瞧好儿吧您内～ 大神，那我该看哪本书呢？推荐下?", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "现代C语言和K&R C的关系，就像汉语普通话和北京腔的关系。  您要全盘照搬啊？那以后...瞧好儿吧您内～", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "看在你读书认真的面子上，建议首先更换信息源/教材，然后学会辩证分析。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "第二种没怎么看打过这样定义函数了，这个应该是比较老C语言标准版本支持的吧，现在的不清楚是否支持。第二种和第一种是一样的吧，只是写法不一样而已。  第三种，也不建议这样写，虽然没有定义a的类型，编译器会默认按照int处理。  不同的编译器（新旧）可能编译结果不一样，有些可能编译没问题，有些会报错。  但是和楼主要讨论的似乎没关系。三个函数都是函数定义。", "referer": "user-0"}]}
{"question": "请教函数传入float型，为啥返回的值不对？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "double f (double a)", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 赵4老师 的回复:[quote=引用 7 楼 oracleperl 的回复:][quote=引用 6 楼 赵4老师 的回复:]double f (double a) 谢谢赵老师，我想请教下，我那样写错在哪里？编译并没报错。[/quote] 编译不报错是因为要兼容旧的语法规定，参数不声明类型，就默认int[/quote] 谢谢赵老师，关于参数不指定类型，默认是int的说法，我查阅了几本书，K&R 《C程序设计语言》英文版《C和指针》，谭浩强老师的《C程序设计》 都没做说明，或许我没看到，是否有“官方文档”或者这基本书籍上有相关说明  另外，如果一个函数 没有指定返回类型，那么默认返回类型是int，这个K&R 《C程序设计语言》里有明确说明  谢谢赵老师", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主的程序，在g++，gcc下编译均不能通过。提示a没有类型。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 7 楼 oracleperl 的回复:[quote=引用 6 楼 赵4老师 的回复:]double f (double a) 谢谢赵老师，我想请教下，我那样写错在哪里？编译并没报错。[/quote] 编译不报错是因为要兼容旧的语法规定，参数不声明类型，就默认int", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 6 楼 赵4老师 的回复:double f (double a) 谢谢赵老师，我想请教下，我那样写错在哪里？编译并没报错。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "你的思路仍然有问题。  比如说，我是说假如 有本家长手册，上面写着：可以吓唬孩子说再不听话就打断他的腿，但是你不能真的打断他的腿。 这句话被孩子看到了，作为正常孩子，难道还去测试一下，故意不听话会不会被亲爹打断腿？  我的意思是，咱学习是为了写正确的代码，没必要急于研究每一种错误的写法为什么错，是怎么错的。 一方面还有大把的算法啊什么的天空等着咱去征服； 另一方面随着学习逐步前进，有些事“等你长大了自然就明白了”。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 3 楼 forever74 的回复:稍稍思考一下，猿s和编译器从某个恰当的角度看，是处于对立状态的。 K&R当年的那段描述是在建议编译器应该如何迁就懒惰的猿s，其实那话儿根本就不是写给猿s的，也不该作为猿s偷懒的借口。  你都下决心学C语言了，难道你还承认自己懒惰，偏偏懒得写一个类型名？ 一头合格的C猿，压根不会考虑偷那点小懒。 不是偷懒，是想搞明白为什么。。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "稍稍思考一下，猿s和编译器从某个恰当的角度看，是处于对立状态的。 K&R当年的那段描述是在建议编译器应该如何迁就懒惰的猿s，其实那话儿根本就不是写给猿s的，也不该作为猿s偷懒的借口。  你都下决心学C语言了，难道你还承认自己懒惰，偏偏懒得写一个类型名？ 一头合格的C猿，压根不会考虑偷那点小懒。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "为你超强的方向感鼓掌。  现代的我们读经典的时候也要辩证，也要批判地继承嘛。  读K&R更多的是感受其中的艺术气息--BTW,翻译过程很难保证这一点，建议原文。 而不是当作教材。", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "make c cc     c.c   -o c c.c: In function ‘f’: c.c:4:8: warning: type of ‘a’ defaults to ‘int’ [-Wimplicit-int]  double f (a)  这是编译过程和结果；make按照C语言的语法编译的，G++不支持楼主的这种方法。通过编译结果可以确定，形参a当成int处理。  结果是result is=1.000000   看到楼主最近在纠结“函数原型”这个名词，看书不建议钻牛角尖，编程还是要注重实践，有些名词，定义不明白，可以先放放，后面的学习和实践中会慢慢解决你之前的疑问，另外，实践也要去指导理论，将两者相结合来学习吧", "referer": "user-0"}]}
{"question": "静电场分析", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "请问这个该怎么写呢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C语言写操作系统都没问题，你还用得着怀疑它？？？", "referer": "user-0"}]}
{"question": "dalao们帮忙看看这个链表哪里有问题orz~", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<string.h> #include<stdlib.h> #define N 5 typedef struct stuNode {     char ID[15];     char name[10];     char sex[4];     char grade[5];     char major[20];     struct stuNode *next; }stuNode, * stuNodeP; stuNodeP headStu; #define LEN sizeof(stuNode) stuNodeP Create_StuList(int n) {     int i;     stuNodeP headStu;     stuNodeP p0, p1;     headStu = p0 = (stuNode *)malloc(LEN);     for (i = 1; i <= n; i++)     {         p1 = (stuNode *)malloc(LEN);         printf(\"请输入学生的学号，姓名，性别，班级，专业：\\n\");         scanf(\"%s%s%s%s%s\",p1->ID,p1->name,p1->sex,p1->grade,p1->major);         p0->next = p1;         p0 = p1;     }     p1->next = NULL;     return headStu; } stuNodeP delete_StuList(stuNodeP headStu, char delID[15]) {     stuNodeP lp=0, p=0;      lp = headStu;     p = lp->next;      puts(delID);     while (p && strcmp(p->ID, delID) != 0) {         //puts(p->ID);         lp = p;         p = p->next;     }     if (!p) {         printf(\"没有查找到该名学生，无法删除！\\n\");         return headStu;     }     lp->next = p->next;     free(p);      /*     while ((strcmp(p->ID, delID) != 0) && (p->next != NULL))     {         lp = p;         p = p->next;     }     if (strcmp(p->ID, delID) == 0)     {         lp->next = p->next;         free(p);     }     else         printf(\"没有查找到该名学生，无法删除！\\n\");     */     return headStu; }  /* 添加有序，但是创建链表的时候并没有按照有序操作的，所以这里不能保证一直有意义*/ stuNodeP add(stuNodeP headStu, char newID[15]) {     stuNodeP p = headStu, q = headStu->next;     stuNodeP newstuNode;       newstuNode = (stuNode *)malloc(sizeof(LEN));     strcpy(newstuNode->ID, newID);     printf(\"请输入学生的学号，姓名，性别，班级，专业：\");     scanf(\"%s%s%s%s%s\",newstuNode->ID, newstuNode->name, newstuNode->sex, newstuNode->grade, newstuNode->major);      while (q && strcmp(q->ID, newID) < 0) {         p = p->next;         q = q->next;     }      if (!q) {         p->next = newstuNode;         newstuNode->next = NULL;         return headStu;     }      newstuNode->next = q;     p->next = newstuNode;      /*     //while((strcmp(q->ID, newID) < 0) && (q->next != NULL));   //多一个分号     while((strcmp(q->ID, newID) < 0) && (q->next != NULL))     {         p = p->next;         q = q->next;     }     newstuNode = (stuNode *)malloc(sizeof(LEN));     strcpy(newstuNode->ID, newID);     printf(\"请输入学生的学号，姓名，性别，班级，专业：\");     scanf(\"%s%s%s%s%s\",newstuNode->ID, newstuNode->name, newstuNode->sex, newstuNode->grade, newstuNode->major);     if (strcmp(q->ID, newID) < 0)         p = q;     newstuNode->next = p->next;     p->next = newstuNode;     */     return headStu; } void show(stuNodeP headStu) {     int num=0;     stuNode *p;     p = headStu->next;     while (p != NULL)     {         printf(\"%d:%s,%s,%s,%s,%s\\n\",++num, p->ID, p->name, p->sex, p->grade, p->major);         p = p->next;     } } int main() {     stuNodeP head;     char ID[15];     head = Create_StuList(N);     show(head);     printf(\"请输入要删除学生的学号信息：\\n\");     //scanf(\"%s\", &ID);     scanf(\"%s\", ID);     //head = delete_StuList(headStu, ID);     head = delete_StuList(head, ID);     show(head);     //head = add(headStu,ID);     head = add(head,ID);     show(head);     return 0; } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢老师了~", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "有个报错， 引发了异常: 读取访问权限冲突。 **lp** 是 nullptr。", "referer": "user-0"}]}
{"question": "新手求助 我这个程序是编制一个C语言成绩记录簿，每个学生信息包括：学号、姓名、C语言成绩。由于字数限制，程序不完整的地方评论接", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "求求各位了，救救宝宝吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "}     printf(\" 60-79分之间:姓名 学号 C语言\\n\");     for(p=0;p<k;p++) \t{         printf(\"%16s %4d %6.2f\\n\",p2[p]->name,p2[p]->num,p2[p]->c); \t}     printf(\" 80-89分之间:姓名 学号 C语言\\n\");     for(q=0;q<l;q++) \t{         printf(\"%16s %4d %6.2f\\n\",p3[q]->name,p3[q]->num,p3[q]->c); \t}     printf(\"90以上:姓名 学号 C语言\\n\");     for(r=0;r<m;r++) \t{         printf(\"%12s %4d %6.2f\\n\",p4[r]->name,p4[r]->num,p4[r]->c); \t}     fclose(fp);     getch(); } int main() { FILE *fp; if((fp=fopen(\"d:\\\\作业\\\\C语言成绩记录簿\\\\c语言txt\",\"wb\"))==NULL) { printf(\"\\nopen file error\"); getchar(); exit(1); } char ch;     while(1) \t{       menu();// 显示菜单       ch=getch();//选择菜单       if(ch=='0')  \t\t  break;       switch(ch)//判断功能项 \t  {       case '1':input();break;       case '2':search();break;       case '3':modiway();break;       case '4':insert();break; \t  case '5':deleteway();break;       case '6':print();break; \t  case '7':count();break; \t  } \t}  \tprintf(\"\\n\\n\\n\\t\\t\\t\\tWelcome to use,Goodbye!\\02!\\n\"); \treturn ; }", "referer": "user-0"}]}
{"question": "请教为啥说“函数调用的参数是表达式”？谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "表达式是个含义很广的概念。  说一台全自动的...的洗衣机是个equipment也对吧？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议楼主确定一下表达式的定义。找一下表达式的定义。  F（10）这里的10按照什么类型，char, unsigned char， int， unsigned int都能表示10这个数，那么它是int，因为默认是按照int处理的。那么这是第一步，第二步还要看函数F的形参，它是什么类型，如果是char，那么如果这个实参是129，那么可能就会被截断。  这就是“把参数传递给函数时也可能进行类型转换”这句话的理解～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "比如定义函数void Func(int x)，只接受int类型的变量，但是调用时传入Func(10+0.2)，会将10+0.2的结果（double类型）自动转换成int类型。 这里10+0.2其实就是表达式，所以说“函数调用的参数是表达式”没有问题。  这句话的重点应该是“在把参数传递给函数时也可能进行类型转换”，重点理解这句就对了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "10 你想说立即数吧? 那立即数也是表达式没毛病", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl", "referer": "user-0"}]}
{"question": "将结构体数据录入文件中出现问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-3的回复:直接贴代码不好吗，报错信息是啥，波浪线的提示是什么，是不是没有包含相应的头文件？ 没有报错，程序可以运行，但输入后的数据存不到打开的文件中", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3的回复:直接贴代码不好吗，报错信息是啥，波浪线的提示是什么，是不是没有包含相应的头文件？ 不知道怎么贴😂😂", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 2 楼 qzjhjxj 的回复:供参考：#include <stdio.h> #include <stdlib.h>  typedef struct staffmessages{         long worknum;         char name[10];         int  award;//基本工资         int  award1;//职务工资         int  award2;//岗位津贴         int  award3;//特殊津贴         int  award4;//工资 }STA;  int printdata(STA sta1[]) {     int i=1,a=0;     for(;;){        printf(\"请输入工号:\");        fflush(stdout);        rewind(stdin);        scanf(\"%ld\",&sta1[a].worknum);//scanf_s(\"%ld\",&sta1[a].worknum);        printf(\"请输入姓名:\");        fflush(stdout);        rewind(stdin);        scanf(\"%s\",sta1[a].name);//scanf_s(\"\",sta1[a].name,sizoef(sta1.[a].name));        printf(\"请输入基本工资:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award);//scanf_s(\"%d\",&sta1[a].award);        printf(\"请输入职务工资:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award1);//scsnf_s(\"%d\",&sta1[a].award1);        printf(\"请输入岗位津贴:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award2);//scanf_s(\"%d\",&sta12[a].award2);        printf(\"请输入特殊津贴:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award3);//scanf_s(\"%d\",&sta1[a].award3);         sta1[a].award4=sta1[a].award + sta1[a].award1 + sta1[a].award2 + sta1[a].award3;        printf(\"工资:%d\\n\",sta1[a].award4);        a++;        printf(\"是否继续录入(如是则输入1，否则输入0):\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&i);//scanf_s(\"%d\",&i);        if(i==0) break;     }     return a; }  void writetofile(STA sta1[],int a) {     FILE *fp;     int i;     fp=fopen(\"cb.txt\",\"w\");     if(fp == NULL){//if(fopen_s(&fa,\"cb.txt\",\"w\")==NULL){        printf(\"Failure to open text\");        exit(0);     }     for(i=0;i<a;i++){       fprintf(fp,\"%10ld%8s%5d%5d%5d%5d%5d\",       sta1[i].worknum,sta1[i].name,sta1[i].award,sta1[i].award1,sta1[i].award2,sta1[i].award2,sta1[i].award3,sta1[i].award4);     }     fclose(fp); }  int main(void) {    //FILE *fp;    STA sta[100];    int b;    b=printdata(sta);    writetofile(sta,b);     return 0; } vs里不支持scanf吧。  另外：fflush(stdout);这个是做什么？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考：#include <stdio.h> #include <stdlib.h>  typedef struct staffmessages{         long worknum;         char name[10];         int  award;//基本工资         int  award1;//职务工资         int  award2;//岗位津贴         int  award3;//特殊津贴         int  award4;//工资 }STA;  int printdata(STA sta1[]) {     int i=1,a=0;     for(;;){        printf(\"请输入工号:\");        fflush(stdout);        rewind(stdin);        scanf(\"%ld\",&sta1[a].worknum);//scanf_s(\"%ld\",&sta1[a].worknum);        printf(\"请输入姓名:\");        fflush(stdout);        rewind(stdin);        scanf(\"%s\",sta1[a].name);//scanf_s(\"\",sta1[a].name,sizoef(sta1.[a].name));        printf(\"请输入基本工资:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award);//scanf_s(\"%d\",&sta1[a].award);        printf(\"请输入职务工资:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award1);//scsnf_s(\"%d\",&sta1[a].award1);        printf(\"请输入岗位津贴:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award2);//scanf_s(\"%d\",&sta12[a].award2);        printf(\"请输入特殊津贴:\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&sta1[a].award3);//scanf_s(\"%d\",&sta1[a].award3);         sta1[a].award4=sta1[a].award + sta1[a].award1 + sta1[a].award2 + sta1[a].award3;        printf(\"工资:%d\\n\",sta1[a].award4);        a++;        printf(\"是否继续录入(如是则输入1，否则输入0):\");        fflush(stdout);        rewind(stdin);        scanf(\"%d\",&i);//scanf_s(\"%d\",&i);        if(i==0) break;     }     return a; }  void writetofile(STA sta1[],int a) {     FILE *fp;     int i;     fp=fopen(\"cb.txt\",\"w\");     if(fp == NULL){//if(fopen_s(&fa,\"cb.txt\",\"w\")==NULL){        printf(\"Failure to open text\");        exit(0);     }     for(i=0;i<a;i++){       fprintf(fp,\"%10ld%8s%5d%5d%5d%5d%5d\",       sta1[i].worknum,sta1[i].name,sta1[i].award,sta1[i].award1,sta1[i].award2,sta1[i].award2,sta1[i].award3,sta1[i].award4);     }     fclose(fp); }  int main(void) {    //FILE *fp;    STA sta[100];    int b;    b=printdata(sta);    writetofile(sta,b);     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "直接贴代码不好吗，报错信息是啥，波浪线的提示是什么，是不是没有包含相应的头文件？", "referer": "user-0"}]}
{"question": "小白求大佬带", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "蹭分，供参考：#include<stdio.h> int main() {     int n,k,i;     int a[100]={0};     scanf(\"%d %d\",&n,&k);     for(i=0;i<n;i++)       scanf(\"%d\",&a[i]);      for(i=0;i<n;i++)       if(a[i]>k) printf(\"%d \",a[i]);     printf(\"\\n\");      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 1 楼 qzjhjxj 的回复:蹭分，供参考：#include<stdio.h> int main() {     int n,k,i;     int a[100]={0};     scanf(\"%d %d\",&n,&k);     for(i=0;i<n;i++)       scanf(\"%d\",&a[i]);      for(i=0;i<n;i++)       if(a[i]>k) printf(\"%d \",a[i]);     printf(\"\\n\");      return 0; } 如果先确定某个数是多少，那么没必要用用数组了，直接根据输入的数据比较，大于的直接输出。  另外，如果n>100呢，是否需要考虑是否越界呢，所以如果先确定某个数的值，不建议用数组了，用了反而给自己找了麻烦，因为需要确定n是否大于你定义的数组长度。", "referer": "user-0"}]}
{"question": "C语言编写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "struct StudentInfo {     int number; // 学号     char name[20]; // 姓名     char gender; // 性别     int age; // 年龄     int grade; // 年级     int consume; // 年消费     char phone[12]; // 联系电话 }Stu[10]; 结构体数组定义好了，加油！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "有没有兄弟能帮我", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "用C语言写第十题", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "看题目要求主要用到结构体数组、文件、排序这些知识点，建议自己按模块写代码，遇到出错的地方不会解决再来求助，让别人从头给你写代码，虽然不难，但估计没人愿意写。", "referer": "user-0"}]}
{"question": "请教C的函数，什么是“有函数原型”，什么是“没有函数原型”？谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "ISO/IEC 9899:2018, p28.： 6.2.1 Scopes of identifiers A function prototype is a declaration of a function that declares the types of its parameters.", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 6 楼 oracleperl 的回复:[quote=引用 3 楼 均陵鼠侠 的回复:] 因为函数有原型声明，所以在调用时，编译器可以知道传入的参数应该如何转换。  谢谢大神，请教下：  如下称作没有有函数原型？ float f (a, b) {     return a * b; }  float f (a, b) int a,b; {     return a * b; }  如下称作有函数原型？ float f (int a, int b) {     return a * b; }  那么 float f (a, b) int a,b; {     return a * b; } 和 float f (int a, int b) {     return a * b; } 有区别吗？不都是定义了形参的类型为int了吗？ [/quote]  这方面的问题还是得紧扣定义。 “带有参数类型声明的函数声明叫做函数原型（prototype）” 不管是有函数体的函数声明，还是无函数体的函数声明，只要声明了参数的类型，就是函数原型。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 均陵鼠侠 的回复:因为函数有原型声明，所以在调用时，编译器可以知道传入的参数应该如何转换。  谢谢大神，请教下：  如下称作没有有函数原型？ float f (a, b) {     return a * b; }  float f (a, b) int a,b; {     return a * b; }  如下称作有函数原型？ float f (int a, int b) {     return a * b; }  那么 float f (a, b) int a,b; {     return a * b; } 和 float f (int a, int b) {     return a * b; } 有区别吗？不都是定义了形参的类型为int了吗？", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "If the expression that denotes the called function has a type that does not include a prototype, the integer promotions are performed on each argument, and arguments that have type float are promoted to double. These are called the default argument promotions.", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "在C语言标准化之前，函数的声明是这样的，即使它实际上带有参数：  # include <stdio.h>  float f  ();            //K&R 的传统函数声明  int main () {     printf (\"%.2f\\n\", f (2, 3));    //2和3按照它们本来的类型int传入，而不是转换为float传入，所以计算结果是错误的。     return 0; }  float f (a, b) float a, b; {     return a * b; }   显然，因为传统的函数声明里没有参数声明，函数调用时不知道参数如何传进去。只能按照默认，char和short转换为int，float转换为double。 标准化的C语言引入了函数原型，即，要求函数的声明中必须有参数类型的说明： # include <stdio.h>  float f  (float, float);            //标准化之后的原型声明，带有参数类型。  int main () {     printf (\"%.2f\\n\", f (2, 3));           //2和3从int转换为float之后传入，所以计算结果是正确的。     return 0; }  float f (float a, float b)                 //标准化之后的函数定义 {     return a * b; }   因为函数有原型声明，所以在调用时，编译器可以知道传入的参数应该如何转换。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "倒是没听说过“没有函数原型”的描述，没这个词吧。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "函数原型可以理解为函数定义，函数定义时会定义参数的类型，char 和short转int，是因为int的范围比char short的范围大，有时候会自动转换；  没有函数原型，那就是没有定义了。", "referer": "user-0"}]}
{"question": "请教哪里有标准C的官方文档，我想整体全面学习标准C的所有函数，谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://www.iso.org/standard/74528.html", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 均陵鼠侠 的回复:叽叽喳喳，答非所问，成何体统！ C标准是要收费的。C99的标准网上可以搜到，很多；C11最后提交的讨论草案是N1570，搜索N1570.pdf或者直接搜索C11；C18的可以搜索ansi 的C18，这个是ANSI的正版文档。 谢谢。 c18 搜不到，有官网吗？如果是付费下载，我可以付费的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "互喷，而且只有互喷，才是我们事业进步的动力和法宝，才能使我们IT人永葆青春！", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "只有互喷，才能增加CSDN C/C++论坛的热度。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "不，“屁话篓子”对你更精确一点。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "引用 16 楼 赵4老师 的回复:[quote=引用 15 楼 均陵鼠侠 的回复:][quote=引用 14 楼 赵4老师 的回复:]不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  迷信CPU？有些CPU是有缺陷的； 迷信编译器？有些编译器是有BUG的； 迷信调试器？有些调试器会莫名其妙崩掉； 迷信运行结果？未定义的行为在不同的机器上有不同的结果，我该信哪一个呢？ 就在昨天，我听说你迷信的某些CPU被Linux剔除了。[/quote] 送你一个雅号——“杠精”[/quote]   我也送你一个雅号：屁话大王。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "引用 15 楼 均陵鼠侠 的回复:[quote=引用 14 楼 赵4老师 的回复:]不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  迷信CPU？有些CPU是有缺陷的； 迷信编译器？有些编译器是有BUG的； 迷信调试器？有些调试器会莫名其妙崩掉； 迷信运行结果？未定义的行为在不同的机器上有不同的结果，我该信哪一个呢？ 就在昨天，我听说你迷信的某些CPU被Linux剔除了。[/quote] 送你一个雅号——“杠精”", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "引用 14 楼 赵4老师 的回复:不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  迷信CPU？有些CPU是有缺陷的； 迷信编译器？有些编译器是有BUG的； 迷信调试器？有些调试器会莫名其妙崩掉； 迷信运行结果？未定义的行为在不同的机器上有不同的结果，我该信哪一个呢？ 就在昨天，我听说你迷信的某些CPU被Linux剔除了。", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "说到过时，  由于标准的向后兼容性，除了一些安全问题造成的特例以外，越老的标准写出来的代码其实就（在不同编译器和系统）越通用。 请注意我说的是标准，不是希望保留历史上遗留下来的糟粕级代码写法。  举个例子，如果你有很ANSI的习惯，在语句块开头集中声明局部变量，然后再开始写执行类语句，那么你就无需在这个问题上担心编译器种类和版本。", "referer": "user-0"}, {"cid": "11", "user": "user-4", "content": "https://zh.cppreference.com/w/c/header 楼上网站的数据太老 早就过时了", "referer": "user-0"}, {"cid": "12", "user": "user-5", "content": "https://www.runoob.com/cprogramming/c-standard-library.html", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "计算机学术讨论组 312811740 这个群里有C标准文档。C18和C11差别不大，C18主要是对C11做了技术修正和澄清，没有加入什么新特性。当然，C18和C11还是有些问题的，比如原子类型和原子操作的表述还是有问题。下一个版本应该能解决。说到库函数，顺便说一下，C11删除了gets函数。", "referer": "user-0"}, {"cid": "14", "user": "user-3", "content": "引用 9 楼 oracleperl 的回复:[quote=引用 8 楼 均陵鼠侠 的回复:][quote=引用 5 楼 赵4老师 的回复:]MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO  微软公司和C语言基本上是没啥关系了。从C99开始，就和C语言新标准分道扬鏣了。C++之类的，才是微软的亲儿子。[/quote] C程序，不都是可以用VS2010编译的吗？咋会没关系呢？[/quote]  VS2010支持的是C++吧，你该不会觉得它是C编译器吧。不过你可以试试下面的程序它能不能编译过去：  int main (void) {     printf (_Generic (666, int : (char []) {\"int!\"}, default : \"Unknown.\"));     quick_exit (0); }", "referer": "user-0"}, {"cid": "15", "user": "user-3", "content": "引用 10 楼 oracleperl 的回复:[quote=引用 6 楼 均陵鼠侠 的回复:]叽叽喳喳，答非所问，成何体统！ C标准是要收费的。C99的标准网上可以搜到，很多；C11最后提交的讨论草案是N1570，搜索N1570.pdf或者直接搜索C11；C18的可以搜索ansi 的C18，这个是ANSI的正版文档。 请教，要收费的是啥意思啊？想看这个标准要付费吗？[/quote]  ISO/IEC 的标准文档，是需要花钱购买的，即使是PDF文件。折合人民币1500块吧。但是网上有草案，跟正式文档差不太多，可以参考。标准文档的后面就是C标准库，包含了所有标准库函数。标准里有的函数才是标准库函数，你从网上查的函数，如果是标准里没有的，就是野函数。", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 6 楼 均陵鼠侠 的回复:叽叽喳喳，答非所问，成何体统！ C标准是要收费的。C99的标准网上可以搜到，很多；C11最后提交的讨论草案是N1570，搜索N1570.pdf或者直接搜索C11；C18的可以搜索ansi 的C18，这个是ANSI的正版文档。 请教，要收费的是啥意思啊？想看这个标准要付费吗？", "referer": "user-0"}, {"cid": "17", "user": "user-0", "content": "引用 8 楼 均陵鼠侠 的回复:[quote=引用 5 楼 赵4老师 的回复:]MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO  微软公司和C语言基本上是没啥关系了。从C99开始，就和C语言新标准分道扬鏣了。C++之类的，才是微软的亲儿子。[/quote] C程序，不都是可以用VS2010编译的吗？咋会没关系呢？", "referer": "user-0"}, {"cid": "18", "user": "user-3", "content": "引用 5 楼 赵4老师 的回复:MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO  微软公司和C语言基本上是没啥关系了。从C99开始，就和C语言新标准分道扬鏣了。C++之类的，才是微软的亲儿子。", "referer": "user-0"}, {"cid": "19", "user": "user-3", "content": "叽叽喳喳，答非所问，成何体统！ C标准是要收费的。C99的标准网上可以搜到，很多；C11最后提交的讨论草案是N1570，搜索N1570.pdf或者直接搜索C11；C18的可以搜索ansi 的C18，这个是ANSI的正版文档。", "referer": "user-0"}, {"cid": "20", "user": "user-2", "content": "MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl", "referer": "user-0"}]}
{"question": "为啥switch语句输入什么都是执行default", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 qzjhjxj的回复: 第二个在发帖之前改过了，不过手机上还没改，不过第一个确实没发现，vc也没报错，现在改过来程序对了，万分感谢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "void keyDown() {     int userkey;     struct student tempData;     //scanf(\"%d,&userkey\");     scanf(\"%d\", &userkey);     if (userkey < 0 || userkey > 5) {         return;     }     userkey += '0';      switch(userkey)     {         case '0':             printf(\"\\t\\t0.【退出系统】\\n\");             system(\"pause\");             exit(0);         case '1':             printf(\"\\t\\t1.【插入信息】\\n\");             printf(\"请输入学生的学号，姓名，项目，奖励。\");             scanf(\"%d%s%s%d\",tempData.num,tempData.name,tempData.preject,tempData.reward);             struct Node* list;   insertNodeByHead(list,tempData);             saveinfotofile(\"student.txt\",list);             break;         case '2':             printf(\"\\t\\t2.【浏览信息】\\n\");             printlist(list);             break;         case '3':             printf(\"\\t\\t3.【删除信息】\\n\");             printf(\"请输入要删除的学生的姓名:\");             scanf(\"%s\",tempData.name);             deleteNodeByAppoinName(list,tempData.name);             saveinfotofile(\"student.txt\",list);             break;         case '4':             printf(\"\\t\\t4.【修改信息】\\n\");             printf(\"请输入要修改学生的学号:\");             scanf(\"%s\",tempData.num);             if(searchNodeByAppoinNum(list,tempData.num)==NULL)                 printf(\"未找到相关信息\");              else             {                 struct Node* curNode=searchNodeByAppoinNum(list,tempData.num);                 printf(\"请输入新的学生奖励信息：学号，姓名，项目，奖励\");                 scanf(\"%d%s%s%d\",curNode->data.num,curNode->data.name,curNode->data.preject,curNode->data.reward);                 saveinfotofile(\"student.txt\",list);             }             break;         case '5':             printf(\"\\t\\t5.【查找信息】\\n\");             printf(\"请输入要查找学生的学号：\");             scanf(\"%s\",tempData.num);             if(searchNodeByAppoinNum(list,tempData.num)==NULL)                 printf(\"未找到相关信息\");             else                 printNode(searchNodeByAppoinNum(list,tempData.num));         default :             printf(\"输入错误请重新输入\\n\");     } }  供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "计算机中，‘0’！=0，一个是字符，一个是数字，不同的ascii值。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "把每一句case语句后面'0'的单引号去掉。case 0:", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 chxchxkkk的回复:把每一句case语句后面'0'的单引号去掉。case 0: 试过了，没用，", "referer": "user-0"}]}
{"question": "请教 2.1*3 这里的2.1是float型还是double型？谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 9 楼 赵4老师 的回复: 谢谢赵老师", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-4 的回复:2.1为double 2.1f为float 引用 7 楼 均陵鼠侠 的回复:我不敢保证国内的大学教授是否见过或者看过C标准。路子不是一般的“野”。 谢谢，现在好像有C18了，哪里可以C标准的完整文档呢？ 谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "我不敢保证国内的大学教授是否见过或者看过C标准。路子不是一般的“野”。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "C Integer Constants An “integer constant” is a decimal (base 10), octal (base 8), or hexadecimal (base 16) number that represents an integral value. Use integer constants to represent integer values that cannot be changed.  Syntax  integer-constant :  decimal-constant integer-suffix opt octal-constant integer-suffix opt hexadecimal-constant integer-suffix opt  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffix opt long-suffix unsigned-suffix opt   unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  Integer constants are positive unless they are preceded by a minus sign (–). The minus sign is interpreted as the unary arithmetic negation operator. (See Unary Arithmetic Operators in Chapter 4 for information about this operator.)  If an integer constant begins with the letters 0x or 0X, it is hexadecimal. If it begins with the digit 0, it is octal. Otherwise, it is assumed to be decimal.   The following lines are equivalent:  0x1C   /* = Hexadecimal representation for decimal 28 */ 034    /* = Octal representation for decimal 28 */  No white-space characters can separate the digits of an integer constant. These examples show valid decimal, octal, and hexadecimal constants.   /* Decimal Constants */ 10 132 32179  /* Octal Constants */ 012 0204 076663  /* Hexadecimal Constants */ 0xa or 0xA 0x84 0x7dB3 or 0X7DB3", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "常量当然也有类型： C Floating-Point Constants A “floating-point constant” is a decimal number that represents a signed real number. The representation of a signed real number includes an integer portion, a fractional portion, and an exponent. Use floating-point constants to represent floating-point values that cannot be changed.   Syntax  floating-point-constant :  fractional-constant exponent-part opt floating-suffix opt digit-sequence exponent-part floating-suffix opt  fractional-constant :  digit-sequence opt . digit-sequence digit-sequence .  exponent-part :  e sign opt digit-sequence E sign opt digit-sequence  sign : one of  +  –  digit-sequence :  digit digit-sequence digit  floating-suffix : one of  f  l  F  L  You can omit either the digits before the decimal point (the integer portion of the value) or the digits after the decimal point (the fractional portion), but not both. You can leave out the decimal point only if you include an exponent. No white-space characters can separate the digits or characters of the constant.   The following examples illustrate some forms of floating-point constants and expressions:  15.75 1.575E1   /* = 15.75   */ 1575e-2   /* = 15.75   */ -2.5e-3   /* = -0.0025 */ 25E-4     /* =  0.0025 */  Floating-point constants are positive unless they are preceded by a minus sign (–). In this case, the minus sign is treated as a unary arithmetic negation operator. Floating-point constants have type float, double, long, or long double.  A floating-point constant without an f, F, l, or L suffix has type double. If the letter f or F is the suffix, the constant has type float. If suffixed by the letter l or L, it has type long double. For example:     100L  /* Has type long double  */ 100F  /* Has type float        */ 100D  /* Has type double       */  Note that the Microsoft C compiler maps long double to type double. See Storage of Basic Types in Chapter 3 for information about type double, float, and long.  You can omit the integer portion of the floating-point constant, as shown in the following examples. The number .75 can be expressed in many ways, including the following:  .0075e2 0.075e1 .075e1 75e-2", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "2.1 ×3默认是按照double（高一级的精度）来处理的。除非指定，比如2.1f * 3这是按照float类型来计算的。", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "2.1为double 2.1f为float", "referer": "user-0"}]}
{"question": "请教下，powf()和powl() 函数有啥用？谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "处理的范围不一样，可以找一下这些函数的原型，可以看到函数的形参和返回值类型；         #include <math.h>         double pow(double x, double y);        float powf(float x, float y);        long double powl(long double x, long double y);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "对于c++标准来说计算精度不一样，pow针对double,powf 参数是long double 在vs下 double = long double 都是64位 在gcc 64位下long double 128位 c++标准里面long double 是80位", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "遗留下来的函数吧，原来C是没有函数重载的，并不支持同名不同参的函数，所以很多旧的C语言代码就大量使用这种把参数类型加到函数名的方式对函数归类，比如你给的这两个函数，powf中f代指pow float，powl代指 pow long float（double）", "referer": "user-0"}]}
{"question": "c语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 弓人水的回复:1、c=getchar()          // getchar() 得到 1，赋值给c后c = '1' 2、getchar()!='#'      // getchar() 得到 2，不等于'#'条件成立，进入循环体 3、putchar(c)           // 控制台打印c：1 4、进入第二次循环，赋值语句是for的第三个表达式 5、c=getchar()        // getchar() 得到 3，赋值给c后c = '3' 6、getchar()!='#'      // getchar() 得到 4，不等于'#'条件成立，进入循环体 7、putchar(c)           // 控制台打印c：3 8、进入第三次循环，赋值语句是for的第三个表达式 9、c=getchar()        // getchar() 得到 5，赋值给c后c = '5' 10、getchar()!='#'      // getchar() 得到 #，不等于'#'条件不成立了，退出循环体 11、退出main，控制台打印结果：13 感谢感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "1、c=getchar()          // getchar() 得到 1，赋值给c后c = '1' 2、getchar()!='#'      // getchar() 得到 2，不等于'#'条件成立，进入循环体 3、putchar(c)           // 控制台打印c：1 4、进入第二次循环，赋值语句是for的第三个表达式 5、c=getchar()        // getchar() 得到 3，赋值给c后c = '3' 6、getchar()!='#'      // getchar() 得到 4，不等于'#'条件成立，进入循环体 7、putchar(c)           // 控制台打印c：3 8、进入第三次循环，赋值语句是for的第三个表达式 9、c=getchar()        // getchar() 得到 5，赋值给c后c = '5' 10、getchar()!='#'      // getchar() 得到 #，不等于'#'条件不成立了，退出循环体 11、退出main，控制台打印结果：13", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "第一个是'1'，赋值给c，判断又有一个getchar();因此是'2'  != '#'，输出'1'，c = getchar();继续是'3',赋值给c；判断'4' != '#'  输出'3'，'5'赋值给c，'#' != '#'为假，退出，综上所述，输出应该是'1' '3'，即13", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "for语句3个表达式第一个是赋初值第二个是判断第三个是循环执行", "referer": "user-0"}]}
{"question": "C语言的几道特别简单的题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "几道特别简单的题，就不要发上来了。 浪费CSDN资源，浪费网友时间。 地地道道的损人不利己。", "referer": "user-0"}]}
{"question": "哪位大神帮我看一下？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fflush(stdin);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "我5楼说的不算哈，当时貌似走神中。 咋没人直我的罗锅捏？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "//请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "借鉴论坛赵老师的经验总结： 在每个最后不带\\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin);", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 forever74 的回复:第一次它得到的是前一个scanf后面剩下在缓冲区里的回车。请问怎么解决这个问题啊，我是个新手", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "第一次它得到的是前一个scanf后面剩下在缓冲区里的回车。", "referer": "user-0"}]}
{"question": "求一个字符串处理的程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 merry_via 的回复:有个strtok函数了解下 strtok已经被我升级了： #include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else                     return string; } void main() {     strcpy(string,\"A \\tstring\\t\\tof ,,tokens\\n\\nand some  more tokens, \");     strcpy(seps1,\",\\n\");strcpy(seps2,\" \\t\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234| LIYI|China | 010 |201110260000|OK\");     strcpy(seps1,\"|\");strcpy(seps2,\" \");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234|LIYI||010|201110260000|OK\");     strcpy(seps1,\"\");strcpy(seps2,\"|\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"1234|LIYI||010|201110260000|OK\");     strcpy(seps1,\"|\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",a\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\"a,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",a,,b\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,a,,b,,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,\");     strcpy(seps1,\",\");strcpy(seps2,\"\");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,\",,,\");     strcpy(seps1,\",\");strcpy(seps2,\" \");     printf(\"\\n[%s]\\nTokens:\\n\",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(\" <%s>\",token);         token=zzstrtok(NULL,seps1,seps2);     } } // //[A      string          of ,,tokens // //and some  more tokens, ] //Tokens: // <A> <string> <of> <> <tokens> <> <and> <some> <more> <tokens> <> //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234> <LIYI> <China> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <> <010> <201110260000> <OK> //[a] //Tokens: // <a> //[a,b] //Tokens: // <a> <b> //[a,,b] //Tokens: // <a> <> <b> //[,a] //Tokens: // <> <a> //[a,] //Tokens: // <a> <> //[,a,,b] //Tokens: // <> <a> <> <b> //[,,a,,b,,] //Tokens: // <> <> <a> <> <b> <> <> //[,] //Tokens: // <> <> //[,,] //Tokens: // <> <> <> //[,,,] //Tokens: // <> <> <> <>", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "单次分割会啊，但多次就不知道怎么写了，C语言学的不是太好哎，还请赐教！！！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "多次调用分割函数即可.", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "有个strtok函数了解下", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "另供参考：#include <stdio.h> char s[]=\"123 ab 4\"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,\"%d%n\",&v,&n);         printf(\"k,v,n=%d,%d,%d\\n\",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf(\"skip char[%c]\\n\",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf(\"End.\\n\"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "大佬我来了！ //有效信息格式为：<013|B2|C3|D4|E5|F6C><A1B2C3D4> //其中013|B2|C3|D4|E5| 使用 符号分割出来的前两位字母或数字及其组合构成密钥如下 //（ 0x01,0xB2,0xC3,0xD4,0xE5,0xF6 ），<A1B2C3D4>截取待用！！！！用C语言该怎么实现， //有没有大佬帮忙解决一下！！！小弟，跪谢！！！ #include <stdio.h> unsigned char key[6]; int buf[6]; char tail[11]; char *s=\"<013|B2|C3|D4|E5|F6C><A1B2C3D4>\"; int i; int main() {     sscanf(s,\"<%2X%*c|%2X|%2X|%2X|%2X|%2X%*c%*c%10s\",         &buf[0],         &buf[1],         &buf[2],         &buf[3],         &buf[4],         &buf[5],         tail);     for (i=0;i<6;i++) key[i]=(unsigned char)buf[i];     for (i=0;i<6;i++) printf(\"0x%02X \",key[i]);     printf(\"\\n%s\\n\",tail);     return 0; } //0x01 0xB2 0xC3 0xD4 0xE5 0xF6 //<A1B2C3D4> //", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "严格说p=a[0]是语法错误的，如果严格进行语法检查的话: 赋值语句两边的类型表达式应相等或相容。p=a是可证相等的：a的类型=int [m][n]=int([m])[n]，由于一维数组[m]可视为单重指针*，故上式=int(*)[n]=p的类型。而p=a[0]的正当写法应为p=&a[0]，两边的类型才是等价的，关于类型解析和等价性证明参见《C++程序设计精要教程》。要入C语言之门，必须掌握类型表达式的解析、运算和等价性证明，80%的错误都与此有关。此外，大部分编译器不支持多维动态数组： 直接用m，n二维动态是不允许的，只允许第一维动态。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "坚持你的理解，不能那样赋值。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "理解和讨论之前，请先学会如何观察！ 仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]", "referer": "user-0"}]}
{"question": "请问如何把上次生成发生错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "下方有很多连接，其中有很多说这个的，你这么久都不去发现？", "referer": "user-0"}]}
{"question": "c语言初学者有个关于地址的小小疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "说不能的，你们得好好思考一下了。 int a = 0x65666768, b, c; b = * (char *) & a; c = *( (char *) & a + 1); printf (\"%c,%c\\n\", b, c);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不行，程序语法不正确。语法正确与否，重点在于类型解析，参见类型解析大法《C++程序设计精要教程》。先看int *p=2001; *p=2; 这是语法正确的。从类型运算的角度看，*p相当于*(int*)因p的类型为int*，而*2001相当于*（int）故是错的。解决办法是引入强制类型转换: *(int *)2001=2; 这样就无语法错误了，但运行不一定成功，要看地址是否在你的程序内存范围内，否则就可能被操作系统的页面保护机制干掉了。如果不会类型解析，永远难入C语言之门。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "不行，程序语法不正确。语法正确与否，重点在于类型解析，参见类型解析大法《C++程序设计精要教程》。先看int *p=2001; *p=2; 这是语法正确的。从类型运算的角度看，*p相当于*(int*)因p的类型为int*，而*2001相当于*（int）故是错的。解决办法是引入强制类型转换: *(int *)2001=2; 这样就无语法错误了，但运行不一定成功，要看地址是否在你的程序内存范围内，否则就可能被操作系统的页面保护机制干掉了。如果不会类型解析，永远难入C语言之门。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 楼主 TOTOBEFREE的回复:假如一个int型的变量占四个字节，比如首地址是2000，那下一个变量的首地址就是2004了，而对它取地址取到的是首地址也就是2000，如果我把一个整数型变量赋值为2001，或者2002反正就是还是在第一个变量的储存单元，这样能不能访问到那个变量呢？ 就是*2001能不能访问的首地址是2000的变量 这样的语句肯定不行，int *p=2001; *p=2; 这样的赋值是可以的。让我们从类型表达式的角度看：*p的类型运算就是*（int *），其中int * 就是p的类型。而*2001从类型表达式的角度看为*(int)，如此你便知道为何不可以了。强制类型转换可以达到这一目的: *(int *)2001=2; 这样的语句就没有语法错误了，但执行时可能有问题，关键在于这个地址是否在你的程序内存范围之内。对于你的运行环境如unix和windows来说，操作系统是有内存页面保护功能的，如地址在另一个程序内存范围之内，你的程序进程就可能被杀死。一个程序语法正确与否关键在于类型解析，如何分析类型参考类型解析大法巜C++程序设计精要教程》。", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "应该和硬件有关系。貌似有点硬件必须要求字节对齐，也就是说不能给不对齐的地址赋值，如：2000可以，但2001非法。", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "不能 说了首地址就要首地址，而且另外还有对齐问题。", "referer": "user-0"}]}
{"question": "有大佬能分行解释一下这个单词统计的代码吗？for循环里看不懂呜呜", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主的标注修改如下：#include<stdio.h> #include<string.h>  int main(int argc, char* argv[]) {     char m[100],word[9];     int i,j,ans,counts=0,flag;      gets(m);      //字符串     gets(word);   //需查找的单词      for(i=0;i<strlen(m);i++){  //循环的范围是一个字符串的长度          for(j=i;j<strlen(m);j++){             flag=j;              //单词位置下标             if(m[j]==' ') break;//遇到空格，一个单词的结束位置                                 //跳出for(j=i;j<strlen(m);j++）循环             //if(flag<j)             //    flag=strlen(m);         }         ans=1;                   //单词对比置位         for(j=i;j<flag;j++){     //i是单词开始位置，flag为单词结束位置             if(m[j]!=word[j-i]){ //将m[j]开始的单词与word[j-i]的单词作比较，j++ <->j-i                ans=0;            //如果不同，则ans置0                break;            //跳出循环             }         }         if(strlen(word) != flag-i) ans=0;//判断m[]字符串中出现如 abc ，而word[]=abcd，上一步判断是能通过的。         if(ans==1) counts++;  //以上条件满足，计数加1         i=flag;            //将一个单词的结尾位置给i，直接进入下一个单词的分析。     }     printf(\"%s %d\",word,counts);      return 0; }  指针的写法，按题目用函数，如下供参考：#include <stdio.h>  int count_SubStr(char *src,char *sub);  int main(int argc, char* argv[]) {     char *src = new char[100],*sub = new char[10];     int c;      gets(src);     gets(sub);      c = count_SubStr(src,sub);      printf(\"%s  %d\\n\",sub,c);      return 0; }  int count_SubStr(char *src,char *sub) {     char *p,*pos,*t;     int  c=0,flag,charlen=strlen(sub);      p=src;     while(*p != '\\0')     {          flag=0;          while(*p != ' ' && *p != '\\0'){               p++;               flag++;          }          if(charlen == flag){               t = p;               while(flag--) t--;               flag = 0;               pos = sub;               while(*t == *pos  && *pos != '\\0'){t++;pos++;flag++;}               if(charlen == flag) c++;          }          p++;     }     return c; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 ⌬⌬⌬⌬⌬的回复:标题 单词统计  描述 输入字符串string[N]（N≤100），各个单词以空格隔开，单词长度小于等于8，输入单词word[M]（M≤8），在string中查找出相同的单词并统计该单词出现的次数信息，输出单词和出现次数的信息， 数据之间空一格空格。主函数输入字符串和待统计单词，编写函数count()实现统计和信息输出。  时间限制 1\t 内存限制 10000\t 类别 1  输入说明 输入一行字符以空格隔开各个单词，输入要统计的单词。  输出说明 格式输出：输出单词及其出现的次数信息，数据之间空一格。  输入样例 dog cat dog dog the abc dog hahe dog  输出样例 dog 4  提示 采用重循环结构实现计算过程，输出数据之间空一格。 这是题目以及测试数据，拜托了谢谢大佬！", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "标题 单词统计  描述 输入字符串string[N]（N≤100），各个单词以空格隔开，单词长度小于等于8，输入单词word[M]（M≤8），在string中查找出相同的单词并统计该单词出现的次数信息，输出单词和出现次数的信息， 数据之间空一格空格。主函数输入字符串和待统计单词，编写函数count()实现统计和信息输出。  时间限制 1\t 内存限制 10000\t 类别 1  输入说明 输入一行字符以空格隔开各个单词，输入要统计的单词。  输出说明 格式输出：输出单词及其出现的次数信息，数据之间空一格。  输入样例 dog cat dog dog the abc dog hahe dog  输出样例 dog 4  提示 采用重循环结构实现计算过程，输出数据之间空一格。", "referer": "user-0"}]}
{"question": "有无符号强转换问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "dev 也是0", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 16 楼 真相重于对错的回复:jsrun.net 两边输出不一样，这应该是编译器问题吧", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 14 楼 我曾是最年轻的男孩 的回复:[quote=引用 10 楼 真相重于对错的回复:] 你这个网址发我看看[/quote] 不仅是那个网站，你用vs也一样是0", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "jsrun.net", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "依我看，不看对应汇编指令，永远无法彻底弄懂。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 10 楼 真相重于对错的回复: 你这个网址发我看看", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "这是编译环境问题吗", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "就算编译器马马虎虎不提这个，运算符运算之前强行提升级别较低的运算数不也是常规操作么？", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "这句话在我的VS2017上产生一个error", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "printf(\"%u\\n\",(  char )~5==4294967290) 这句话明明输出0，不是1 (char)~5==4294967290 这是一个比较表达式，结果是false ，打印出来时0", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 5 楼 forever74的回复:对头，我就是这个意思。 printf(\"%u\\n\",(  char )~5==4294967290);//这里输出1，不是已经强转换为char了吗，为什么还相等，这里已经发生了扩展了？", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 5 楼 forever74的回复:对头，我就是这个意思。 不是强转换为char类型了吗", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 5 楼 forever74的回复:对头，我就是这个意思。 可是，这里为什么就已经相等了 printf(\"%u\\n\",(  char )~5==4294967290);//输出1", "referer": "user-0"}, {"cid": "15", "user": "user-3", "content": "对头，我就是这个意思。", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 3 楼 forever74的回复:所以， 第一步求值，像楼主注释里写的那样。 第二步入栈扩展（到32位的整数倍），无符号的前面加0，有符号的前面加的所有位都复制符号位。 第三步按照格式符的要求对接收到的扩展后内容进行解释，输出。 所以第二步如果是个有符号的负数，前面扩展的位置全部位都是1？", "referer": "user-0"}, {"cid": "17", "user": "user-3", "content": "所以， 第一步求值，像楼主注释里写的那样。 第二步入栈扩展（到32位的整数倍），无符号的前面加0，有符号的前面加的所有位都复制符号位。 第三步按照格式符的要求对接收到的扩展后内容进行解释，输出。", "referer": "user-0"}, {"cid": "18", "user": "user-4", "content": "是printf里面的格式字符惹得祸。第一个250好理解。用unsigned char 强制类型转换后11111010就是250，不需要再看补码，因为就是无符号类型。 第二个是%u的原因，换成%d就是-6了。同二楼。", "referer": "user-0"}, {"cid": "19", "user": "user-3", "content": "这个问题不是强制转换出了问题，而是当你把那些单字节当作实参送给printf的时候，编译器对它进行了扩展（变得更长），理由很多，我没细看过。", "referer": "user-0"}, {"cid": "20", "user": "user-3", "content": "楼主你关注的点已经歪了，你企图用一个错误的方式验证一开始的问题，然后在错误本身的引领下越走越远。 回来吧，不要忘了初心。", "referer": "user-0"}]}
{"question": "c语言编程新手问题，第七章”基本类型“习题，麻烦各位大佬看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "%.1d ?? 马虎", "referer": "user-0"}]}
{"question": "各位大佬请问:之前不小心把vs2019的发生生成错误...", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "重新开个项目呗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 赵4老师 的回复:感谢大佬", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:vs不支持scanf吧，是不是应该用scanf_s呢？！另外去掉scanf中的\\n是支持的,只要在文件开头加上一个 #define _CRT_SECURE_NO_DEPRECATE", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "我比较好奇为啥要把这个东西找回来？", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "vs2019号称“宇宙第一IDE”，但编写纯C不一定是最合适的。还不如用gcc，tiny-c。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "vs不支持scanf吧，是不是应该用scanf_s呢？！另外去掉scanf中的\\n", "referer": "user-0"}]}
{"question": "c语言编程新手问题，第七章”基本类型“习题，麻烦各位大佬看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "嗯，你把非法输入引起的异常拿来说事儿那就过分了。 请输入正常数据。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-2 的回复:供参考：int main() {     long long m=1,n=1,product;      for(;m>0;){             //需另设一变量，退出循环的条件         printf(\"Enter a positive integer:\");         scanf(\"%11d\",&m);          product=1;          //这个值在这里初始化         for(n=m;n>=1;n--){             product *= n;         }         printf(\"Factorial:%11d\\n\",product);     }      return 0; } 我用你的程序试了一下，循环的次数多了之后，会出现正文中图四的情况。而且还会出现下图，23可以算阶乘，22却不可以。  我把程序改成下图，循环的次数多了之后，也是会出现图四的情况。  请问怎么回事呢？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考：int main() {     long long m=1,n=1,product;      for(;m>0;){             //需另设一变量，退出循环的条件         printf(\"Enter a positive integer:\");         scanf(\"%11d\",&m);          product=1;          //这个值在这里初始化         for(n=m;n>=1;n--){             product *= n;         }         printf(\"Factorial:%11d\\n\",product);     }      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "重新算之前你的product没有重新赋值啊。", "referer": "user-0"}]}
{"question": "关于c语言的结构体问题。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> //结构体要在int main之前定义 struct student { \tint num; \tchar name[20]; \tint score; }a[2]; int main() { \tprintf(\"Please input the students infornation:\\n\"); \tfor (int i = 0; i < 2; i++) \t\tscanf(\"%d%s%d\", &a[i].num, a[i].name, &a[i].score);//字符串不用地址,\"\"内的，去掉 \tprintf(\"The higher student score is:\"); \tif (a[0].score > a[1].score) \t\tprintf(\"%d %s %d\", a[0].num, a[0].name, a[0].score); \telse \t\tif (a[0].score < a[1].score) \t\t\tprintf(\"%d %s %d\", a[1].num, a[1].name, a[1].score); \t//else printf(\"They get the same score\"); \treturn 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 forever74的回复:[quote=引用 2 楼 m0_54393423 的回复:]请问为什么我在scanf_s那里用逗号格式（就是scanf_s（\"%d,%s,%d\"）这里）的运行结果在监控时输入后会把所有的if条件给跳过，直接进行最后的printf而在scanf不用逗号时没有出现这种情况 这跟带不带_s没关系， 关键在于里面的%s格式符会从缓冲区当前位置一直get到白空格为止，它可不理你的逗号，也不认为逗号是分隔符。 这样一来排在它后面的%d也就是score就没捞着东西吃，饿着肚子委委屈屈地“编造”一个离谱的数据给你。[/quote] 理解了，谢谢大佬", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 7 楼 forever74的回复:[quote=引用 2 楼 m0_54393423 的回复:]请问为什么我在scanf_s那里用逗号格式（就是scanf_s（\"%d,%s,%d\"）这里）的运行结果在监控时输入后会把所有的if条件给跳过，直接进行最后的printf而在scanf不用逗号时没有出现这种情况 这跟带不带_s没关系， 关键在于里面的%s格式符会从缓冲区当前位置一直get到白空格为止，它可不理你的逗号，也不认为逗号是分隔符。 这样一来排在它后面的%d也就是score就没捞着东西吃，饿着肚子委委屈屈地“编造”一个离谱的数据给你。[/quote] 👍👍👍", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 2 楼 m0_54393423 的回复:请问为什么我在scanf_s那里用逗号格式（就是scanf_s（\"%d,%s,%d\"）这里）的运行结果在监控时输入后会把所有的if条件给跳过，直接进行最后的printf而在scanf不用逗号时没有出现这种情况 这跟带不带_s没关系， 关键在于里面的%s格式符会从缓冲区当前位置一直get到白空格为止，它可不理你的逗号，也不认为逗号是分隔符。 这样一来排在它后面的%d也就是score就没捞着东西吃，饿着肚子委委屈屈地“编造”一个离谱的数据给你。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "把scanf_s()输入的顺序改一下 scanf_s(\"%d,%d,%s\", &a[i].num, &a[i].score,&a[i].name, 20); VS2015 C++环境调试  或者干脆不用scanf_s()改用scanf()，请参考 《VS2015中使用scanf()不报错的设置方法》 希望能够帮到您！", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "请问为什么我在scanf_s这里用逗号格式（就是scanf_s（\"%d,%s,%d\"））在运行时它会直接忽略所有的if条件然后执行最后的printf（\"They get the same score\"）（如我发的图所示）；在监视时它a数组的score成员都有问题，而其它成员没有问题，为什么会这样啊请问，有劳了谢谢谢谢", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 user-4的回复:修改如下，供参考：#include<stdio.h>   int main() {    struct student    {      int  num;      char name[20];      int  score;    }a[2];     printf(\"Please input the students infornation:\\n\");    for(int i=0;i<2;i++)        scanf_s(\"%d %s %d\", &a[i].num, a[i].name,19, &a[i].score);    //\"%d,%s,%d\" 输入格式空格更方便//&a[i].name,20这个&可以不用     printf(\"The higher student score is:\");    if (a[0].score > a[1].score)        printf(\"%d %s %d\\n\", a[0].num, a[0].name, a[0].score);    else       //if (a[0].score < a[1].score)//这里if多用了          printf(\"%d %s %d\\n\",a[1].num, a[1].name, a[1].score);    //else printf(\"They get the same score\");     return 0; } 监视时scanf进行后a［0］.score,a［1］.score都不是正常值", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "请问为什么我在scanf_s那里用逗号格式（就是scanf_s（\"%d,%s,%d\"）这里）的运行结果在监控时输入后会把所有的if条件给跳过，直接进行最后的printf而在scanf不用逗号时没有出现这种情况", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "修改如下，供参考：#include<stdio.h>   int main() {    struct student    {      int  num;      char name[20];      int  score;    }a[2];     printf(\"Please input the students infornation:\\n\");    for(int i=0;i<2;i++)        scanf_s(\"%d %s %d\", &a[i].num, a[i].name,19, &a[i].score);    //\"%d,%s,%d\" 输入格式空格更方便//&a[i].name,20这个&可以不用     printf(\"The higher student score is:\");    if (a[0].score > a[1].score)        printf(\"%d %s %d\\n\", a[0].num, a[0].name, a[0].score);    else       //if (a[0].score < a[1].score)//这里if多用了          printf(\"%d %s %d\\n\",a[1].num, a[1].name, a[1].score);    //else printf(\"They get the same score\");     return 0; }", "referer": "user-0"}]}
{"question": "求解一直在线，如果对秒给解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "要么网上搜一下，然后改一改，要么自己先试试写写", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "定义一个结构体，用结构体数组解决。", "referer": "user-0"}]}
{"question": "救救孩子吧，这c语言题目，使用vs2013", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1 的回复：太简单了+0结帖率 = 懒得答[face]monkey2:019.png[/face]", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "太简单了+0结帖率 = 懒得答", "referer": "user-0"}]}
{"question": "C语言   成绩录入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已经写完了，谢谢大家", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这样的题用结构体数组或链表都可以做，最好自己按模块写，出错的地方再让大家纠错。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "用结构体方便点吧", "referer": "user-0"}]}
{"question": "c中指向指针的指针的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1 的回复:把 printf(“%c”, *p); 改成 printf(“%c”, (*p==0?c:*p)); 因为*p=0不是一个可以显示的字符，所以当*p==0是就打印c变量，因为c变量的值就是‘!’ 不是这个问题，是代码的逻辑上有问题，已经自己解决了，不过还是多谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把 printf(“%c”, *p); 改成 printf(“%c”, (*p==0?c:*p)); 因为*p=0不是一个可以显示的字符，所以当*p==0是就打印c变量，因为c变量的值就是‘!’", "referer": "user-0"}]}
{"question": "为什么文件里的内容没有改变？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<string.h>  //#include<windows.h> #include<stdlib.h> //#include<conio.h>  struct yonghu//用户信息 {     int zhanghao;//账号     char name[7];//用户名     char id[20];//用户身份证     char password[10];//用户密码 }users[500];  void revise();//修改信息  int main() {      revise();      return 0; }  void revise() {     int i;     int zhanghao2, ret;     char name2[7],password2[10],id2[20];     char name3[7];     printf(\"请输入要修改的用户名：\\n\");     scanf(\"%s\",name3);     printf(\"请输入修改的账号：\\n\");     scanf(\"%d\",&zhanghao2);     printf(\"请输入修改的用户名：\\n\");     scanf(\"%s\",name2);     printf(\"请输入修改的身份证：\\n\");     scanf(\"%s\",id2);     printf(\"请输入修改的密码：\\n\");     scanf(\"%s\",password2);      FILE *fp;     fp=fopen(\"用户信息.txt\",\"r+\");     if(fp==NULL)     {         printf(\"error file can't be open!\\n\");         exit(0);     }       for(i=0;;i++)     {         ret = fscanf(fp,\"%d %s %s %s\",&users[i].zhanghao,users[i].name,users[i].id,users[i].password);         if (ret < 4)             break;         //if(strcmp(users[i].name,name3[7])==0)         if(strcmp(users[i].name,name3)==0)         {             //         printf(\"2\");             users[i].zhanghao=zhanghao2;             //strcpy(users[i].name,name2[7]);             strcpy(users[i].name,name2);             //strcpy(users[i].id,id2[20]);             strcpy(users[i].id,id2);             //strcpy(users[i].password,password2[10]);             strcpy(users[i].password,password2);              //break;    //跳出循环，否则死循环了（如果不加ret和判断） 这句不用了             //fprintf(fp,\"%d %s %s %s\",users[i].zhanghao,users[i].name,users[i].id,users[i].password);         }     }      //rewind(fp);    //用这句或者下句都可以     fseek(fp, 0, SEEK_SET);     for (i = i -1; i >= 0; i--)             fprintf(fp,\"%d %s %s %s\",users[i].zhanghao,users[i].name,users[i].id,users[i].password);      fclose(fp);     printf(\"修改成功！\"); } 供参考～", "referer": "user-0"}]}
{"question": "想输出直接排序，选择排序，堆排序，快速排序的前五行排序结果，选择和直接插入可以了，剩下两个有大神帮忙么？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "网上先搜一下吧，代码和说明（算法介绍）都有了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "参考这个？ 各种排序算法动画演示http://www.webhek.com/misc/comparison-sort/", "referer": "user-0"}]}
{"question": "c语言程序设计", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "struct 里放一个总分和合格的成员，输入的时候一并算出来保存上，统计和排序的时候就参照这2个的值。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "出差不方便，大概写了下，你参考参考。  struct stu {     char name[10];     char id[20];     float zhengzhi;     float shuxue;     float zongfen;     int tongguo; };  typedef struct stu Stu;  void input(Stu *stu,size_t n) {          for(size_t i=0;i<n;i++)     {         scanf(\"%s\\n\",stu->name);         scanf(\"%f%f\",&stu->zhengzhi,&stu->shuxue);                  stu->zongfen=stu->zhengzhi+stu->shuxue;         stu->tongguo=stu->zongfen > 310 && (stu->zhengzhi >=40 && stu->shuxue>=40);         stu++;     }      }  void print(Stu *stu,size_t n) {     for(size_t i=0;i<n;i++)     {         printf(\"%s %s %.1f %.1f %.1f %s\\n\",stu->name,stu->id,stu->zhengzhi,stu->shuxue,stu->zongfen,(stu->tongguo)?\"通过\":\"不通过\");         stu++;     }      }  int main() {          Stu stu[3]={0};     input(stu,3);     print(stu,3);  \t \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 一颗白面馒头的回复:看你id是个楚夏党？所以课程设计还是自己做好一点网上这种系统设计的也很多，大体都是差不多的 帮帮我吧", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 4 楼 浪客的回复:struct 里放一个总分和合格的成员，输入的时候一并算出来保存上，统计和排序的时候就参照这2个的值。 具体怎么弄，搞不来", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 浪客的回复:一个struct数组搞定 那个统计的怎么弄？", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "一个struct数组搞定", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "看你id是个楚夏党？所以课程设计还是自己做好一点网上这种系统设计的也很多，大体都是差不多的", "referer": "user-0"}]}
{"question": "c语言不解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 9 楼 向阳森 的回复:[quote=引用 8 楼 赵4老师的回复:]可惜我原来发在#4楼的重复踩过无数次同一个坑的宝贵经验，被版主认为是灌水删掉了。 好在#7识货，实际试用效果展示了一小下。  emmm，我是新手，我也是刚弄CSDN，还不懂[/quote] 楼主的代码之所以出现问题，是因为在几个连续的输入输出间对缓冲区多余字符没处理好，建议去搜下scanf()printf()的详细用法，再结合上面的代码去感觉下。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 赵4老师的回复:可惜我原来发在#4楼的重复踩过无数次同一个坑的宝贵经验，被版主认为是灌水删掉了。 好在#7识货，实际试用效果展示了一小下。  emmm，我是新手，我也是刚弄CSDN，还不懂", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "可惜我原来发在#4楼的重复踩过无数次同一个坑的宝贵经验，被版主认为是灌水删掉了。 好在#7识货，实际试用效果展示了一小下。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 4 楼 赵4老师 的回复:在每个最后不带\\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。 按赵老师的经验修改如下，供参考：#include <stdio.h> #define beet 2.05 #define artichokes 1.15 #define carrot   1.09   int main() { \tint i,k=0;         char s[2]; \tdouble total_price_goods, discount=0, freight_packingExpense, total_order_cost, beet_pound=0, artichokes_pound=0, carrot_pound=0; \tdouble total_price_beet, total_price_artichokes, total_price_carrots, a, b, c,total_pound; \tchar ch; \tprintf(\"ABC邮购杂货店订货系统\\n\"); \tprintf(\"a)洋蓟        b）甜菜          c）胡萝卜       q)退出\\n\");  \twhile (1) \t{ \t\tif (k != 1) \t\t\t{printf(\"请输入你要购买货物的编号:\");                         fflush(stdout);} \t\telse \t\t\tk = 0;                         rewind(stdin); \t\t\tscanf(\"%1s\",s);//scanf_s(\"%c\",&ch,1);                         ch = s[0]; \t\t\tswitch (ch) \t\t\t{ \t\t\tcase 'a': \t\t\t\tprintf(\"请输入购买洋蓟的磅数：\");                                 fflush(stdout);                                 rewind(stdin); \t\t\t\tscanf(\"%lf\", &a);//scanf_s(\"%lf\", &a); \t\t\t\tartichokes_pound += a; \t\t\t\tbreak; \t\t\tcase 'b': \t\t\t\tprintf(\"请输入购买甜菜的磅数：\");                                 fflush(stdout);                                 rewind(stdin); \t\t\t\tscanf(\"%lf\", &b);//scanf_s(\"%lf\", &b); \t\t\t\tbeet_pound += b; \t\t\t\tbreak; \t\t\tcase 'c': \t\t\t\tprintf(\"请输入购买胡萝卜的磅数：\");                                 fflush(stdout);                                 rewind(stdin); \t\t\t\tscanf(\"%lf\", &c);//scanf_s(\"%lf\", &c); \t\t\t\tcarrot_pound += c; \t\t\t\tbreak; \t\t\tcase  'q': \t\t\t\tbreak; \t\t\tdefault : \t\t\t\tprintf(\"请输入正确的编号：\\n\"); \t\t\t\tk = 1; \t\t\t\t//continue; \t\t\t} \t\t\tif (ch == 'q')  \t\t\t\tbreak; \t    } \t\ttotal_price_artichokes = artichokes_pound * artichokes; \t\ttotal_price_beet = beet * beet_pound; \t\ttotal_price_carrots = carrot_pound * carrot; \t\ttotal_price_goods = total_price_artichokes + total_price_beet + total_price_carrots; \t\tif (total_price_goods >= 100) \t\t\tdiscount = total_price_goods * 0.05; \t\ttotal_pound = beet_pound + artichokes_pound + carrot_pound; \t\tif (total_pound ==0) \t\t\tfreight_packingExpense = 0; \t\telse \t\t  if (total_pound <= 5) \t\t\tfreight_packingExpense = 6.5; \t\t  else if (total_pound <= 20) \t\t\tfreight_packingExpense = 14; \t\t  else \t\t\tfreight_packingExpense = 14 + (total_pound - 20) * 0.5; \t\ttotal_order_cost = total_price_goods + freight_packingExpense - discount; \t\tfor (i = 1;i <= 37;i++) \t\t\tprintf(\"*\"); \t\tprintf(\"订单\"); \t\tfor (i = 1;i < 37;i++) \t\t\tprintf(\"*\"); \t\tprintf(\"\\n\"); \t\tprintf(\"物品种类     物品售价     订购重量（单位：磅）     物品费用\\n\"); \t\tprintf(\" a洋蓟        %.2f         %.2f                     %.2f            \\n \",artichokes,artichokes_pound,total_price_artichokes); \t\tprintf(\" b甜菜        %.2f         %.2f                     %.2f             \\n\", beet, beet_pound, total_price_beet); \t\tprintf(\" c胡萝卜      %.2f         %.2f                     %.2f             \\n\", carrot, carrot_pound, total_price_carrots); \t\tprintf(\"订单总费用：%.2f     折扣%.2f       运费和包装费%.2f       费用总额：%.2f        \\n \",total_price_goods,discount,freight_packingExpense,total_order_cost);  \t\t\tfor (i = 1;i < 80;i++) \t\t\tprintf(\"*\"); \t\tprintf(\"\\n\");  \t\treturn 0; } 运行效果：", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 5 楼 向阳森 的回复:[quote=引用 2 楼 一颗白面馒头的回复:]没有手动调试，scanf_s(\"%c\",&ch,1);这句话第二次获取的输入应该是你输入时候的回车。建议打断点调试一下 还没学到打断点[/quote] 可以学着调试代码。因为你输入一个字符过后，你还敲了一个回车。这也是一个字符。所以第二次scanf_s的时候可能就是读取了回车这个字符。具体没调试也不敢肯定，但是既然又scanf_s了一次，你ch的值肯定是变了的", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 一颗白面馒头的回复:没有手动调试，scanf_s(\"%c\",&ch,1);这句话第二次获取的输入应该是你输入时候的回车。建议打断点调试一下 还没学到打断点", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 一颗白面馒头的回复:其实这个问题理一下逻辑就出来了。从你输入10开始吧。 这时候的switch结构已经退出，然后if (ch == 'q')这句话不成立，所以while循环没有退出。又开始循环。因为你的k的值没有变过，所以执行了printf(\"请输入你要购买货物的编号:\");这句话。scanf_s(\"%c\",&ch,1);接下来这句话又获取了一个输入，此时ch的值肯定不是a, b, c了，所以进入了default：执行了printf(\"请输入正确的编号：\\n\");这句话。最后你输入了d，又是default的情况。 为什么此时的值肯定不是a.b.c", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "在用%c获取有效输入之前，需要先仔细地把输入缓冲区打扫干净。一般用 while(getchar()!='\\n'); 就行。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "没有手动调试，scanf_s(\"%c\",&ch,1);这句话第二次获取的输入应该是你输入时候的回车。建议打断点调试一下", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "其实这个问题理一下逻辑就出来了。从你输入10开始吧。 这时候的switch结构已经退出，然后if (ch == 'q')这句话不成立，所以while循环没有退出。又开始循环。因为你的k的值没有变过，所以执行了printf(\"请输入你要购买货物的编号:\");这句话。scanf_s(\"%c\",&ch,1);接下来这句话又获取了一个输入，此时ch的值肯定不是a, b, c了，所以进入了default：执行了printf(\"请输入正确的编号：\\n\");这句话。最后你输入了d，又是default的情况。", "referer": "user-0"}]}
{"question": "为什么文件里的内容没有修改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fp=fopen(\"用户信息.txt\",\"a\");这 是读文件，写文件要用fp=fopen(\"用户信息.txt\",\"w\");", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "既然楼主急于落实文件访问，那其他错误就不提了。 文件打开必须要检测是否失败，另外 文件是不能读了就写的 即使你的打开方式带加号 读操作写操作之间也必须有定位操作，对于文本，就rewind吧 也就是说，如果你不想两次打开 那就得带加号打开 全读完 rewind 全写完 关闭 综上，酱紫。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 浪客的回复:for只运行1次后break出来了。 fprintf里name2[7]和后面的几个数组不对，应该用数组名。把[7]删了。 谢谢，可是改了之后文件里的内容还是没改", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "for只运行1次后break出来了。 fprintf里name2[7]和后面的几个数组不对，应该用数组名。把[7]删了。", "referer": "user-0"}]}
{"question": "C语言进行遥感图像分类", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考本页下面红色字体链接。", "referer": "user-0"}]}
{"question": "求帮助！！利用C语言实现   商店销售管理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 楼主 风吹南边来 的回复:求帮助  可私信详聊 感谢大佬们救救孩子 功能： （1）屏幕上出现一个界面，让售货员输入商品编号或者商品名称，可 以进货，进货后商品库存同时增加。顾客买走商品后，售货员输入商品 编号或者商品名称，可以生成销售清单，统计本次销售总的价钱，同时 库存数量相应减少。完成前面的基本功能后，还可以完成增加新的商品 或删除不需要的商品的功能，以及每天销售统计功能等。 （2）保存：将相关数据写入磁盘文件，便于存、取操作。 要求： （1）用 C 语言实现程序设计； （2）利用结构体和链表进行相关信息处理； （3）系统的各个功能模块要求用函数的形式实现； （4）界面友好（良好的人机交互），程序要有注释。 代码呢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 3 楼 user-2 的回复:[quote=引用 2 楼 qq_1457346882 的回复:][quote=引用 楼主 风吹南边来 的回复:]求帮助  可私信详聊 感谢大佬们救救孩子 功能： （1）屏幕上出现一个界面，让售货员输入商品编号或者商品名称，可 以进货，进货后商品库存同时增加。顾客买走商品后，售货员输入商品 编号或者商品名称，可以生成销售清单，统计本次销售总的价钱，同时 库存数量相应减少。完成前面的基本功能后，还可以完成增加新的商品 或删除不需要的商品的功能，以及每天销售统计功能等。 （2）保存：将相关数据写入磁盘文件，便于存、取操作。 要求： （1）用 C 语言实现程序设计； （2）利用结构体和链表进行相关信息处理； （3）系统的各个功能模块要求用函数的形式实现； （4）界面友好（良好的人机交互），程序要有注释。 代码呢[/quote]  代码要你写啊，哈哈哈[/quote] 那怕是疯了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 qq_1457346882 的回复:[quote=引用 楼主 风吹南边来 的回复:]求帮助  可私信详聊 感谢大佬们救救孩子 功能： （1）屏幕上出现一个界面，让售货员输入商品编号或者商品名称，可 以进货，进货后商品库存同时增加。顾客买走商品后，售货员输入商品 编号或者商品名称，可以生成销售清单，统计本次销售总的价钱，同时 库存数量相应减少。完成前面的基本功能后，还可以完成增加新的商品 或删除不需要的商品的功能，以及每天销售统计功能等。 （2）保存：将相关数据写入磁盘文件，便于存、取操作。 要求： （1）用 C 语言实现程序设计； （2）利用结构体和链表进行相关信息处理； （3）系统的各个功能模块要求用函数的形式实现； （4）界面友好（良好的人机交互），程序要有注释。 代码呢[/quote]  代码要你写啊，哈哈哈", "referer": "user-0"}]}
{"question": "这个填空怎么做啊 我老是运行不出来", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 10 楼 早打大打打核战争 的回复:老赵的经典台词，老师也不能代替啥啥的那句还不上来~  老师头疼的不是学生不知道，而是他们不知道自己不知道。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "老赵的经典台词，老师也不能代替啥啥的那句还不上来~", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "不急，慢慢来。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> int PositiveNum(int a[], int n) {     int i,count=0;     for (i=0;i<n;i++)     {         if (a[i]>0) count++;     }     return count; } int main() {     int b[10]={1,0,2,3,4,-1,-2,-3,-4,0};     printf(\"%d\\n\",PositiveNum(b,10)); //4     return 0; }  大饼中间挖个洞，套脖子上，还不行；还得帮转，帮嚼，帮咽，帮消化，帮拉，帮活，……", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:①=0 ②count++ ③count 我早就试过了 运行不出来", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 2 楼 m0_53759618 的回复:[quote=引用 1 楼 赵4老师的回复:]①=0 ②count++ ③count 不是这个 试过了[/quote] 眼睛瞪大一点，就对了。。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "楼上正解。。。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:①=0 ②count++ ③count 不是这个 试过了", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "①=0 ②count++ ③count", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 7 楼 立 夏的回复:[quote=引用 6 楼 赵4老师 的回复:]#include <stdio.h> int PositiveNum(int a[], int n) {     int i,count=0;     for (i=0;i<n;i++)     {         if (a[i]>0) count++;     }     return count; } int main() {     int b[10]={1,0,2,3,4,-1,-2,-3,-4,0};     printf(\"%d\\n\",PositiveNum(b,10)); //4     return 0; }  大饼中间挖个洞，套脖子上，还不行；还得帮转，帮嚼，帮咽，帮消化，帮拉，帮活，…… 可太C了，赵四老师都把答案说了，可这个提问者，给了答案都不会有用，诶....编程水平不是一般的低[/quote] 我才开始学啊....", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "引用 6 楼 赵4老师 的回复:#include <stdio.h> int PositiveNum(int a[], int n) {     int i,count=0;     for (i=0;i<n;i++)     {         if (a[i]>0) count++;     }     return count; } int main() {     int b[10]={1,0,2,3,4,-1,-2,-3,-4,0};     printf(\"%d\\n\",PositiveNum(b,10)); //4     return 0; }  大饼中间挖个洞，套脖子上，还不行；还得帮转，帮嚼，帮咽，帮消化，帮拉，帮活，…… 可太C了，赵四老师都把答案说了，可这个提问者，给了答案都不会有用，诶....编程水平不是一般的低", "referer": "user-0"}]}
{"question": "求大佬帮忙指点一二", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第9、13、36行，定义的数组student[]大小不一样？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "内层for循环变量是j却写了i++", "referer": "user-0"}]}
{"question": "怎么做这个求告知，哭唧唧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if flag == '学号' 这不是C语言的语法吧  先把代码格式，排版调试好了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "声明一个结构体，成员包括姓名、手机号等，然后用结构体数组来实现上述各模块的功能", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "# include<stdio.h>int a[];\t\t//定义一个二位数组用来存储通讯录void shixian();void shixian(){\t# 实现显示通讯录的功能\tfor (i=1; i<=len(a); ++i)    {        printf(a[i])\t\t}\t\t}void chaxun(){\t# 实现查询通讯录的功能\tflag = scanf('请选择查询的类型：')\tif flag == '学号'：\t\txuehao = int(input('请输入您要查询的学号：'))\t\tfor i in len(a):\t\t\tif xuehao == a[i][1]:\t\t\t\tprintf(a[i])}void tianjia(){\tname = scanf('请输入姓名')\tstudenter = scanf('请输入学号')\tnumber = scanf('请输入电话')\ta.insert([name,studenter, number])}\tvoid mian(){\tprintf('程序开始，根据需求输入，例如，显示通讯录，则输入显示。')\twhile True(){\tflag = input('请输入您的需求')\ta = false\t\t\tswitch(flag){\t\t\tcase flag == '显示'：\t\t\t\txianshi();\t\t\t\tbreak;\t\t\tcase flag == '添加':\t\t\t\tchaxun();\t\t\t\tbreak;\t\t\tcase flag == '退出';\t\t\t\ta = true\t\t\t}\tif a{\t\tbreak;\t}\t\t\t}\t}", "referer": "user-0"}]}
{"question": "c语言编程新手问题，麻烦各位大佬看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "其实你把while循环改一下就理解了 while (getchar() != '\\n'); 改成以下 while(1) { //无条件循环     if (getchar()=='\\n') break; //每次循环接收一个输入，输入如果是回车就退出循环 } 这两个while是等效的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 楼主 xyfffz 的回复:这个程序的要求是每24次平方后暂停，录入回车键后继续。我看不懂这个空循环。请问运行到19行时，当输入的不是回车，不就执行空语句吗，执行完空语句不是还得继续for循环吗，照这样说就与要求不符了呀？ 你没理解while循环，如果输入的不是回车，那么getchar() != '\\n'就会一直成立，就会一直重复while循环（循环空语句什么都不处理，但循环没有结束，会继续循环），直到你输入回车，getchar() != '\\n'不成立才会退出while循环，接着才会重新继续for循环", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你是不是对while有什么误解？还以为是if呢？", "referer": "user-0"}]}
{"question": "两数之和（C语言）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "完全正确，没语法问题。不知道要实现什么功能，谁也帮不了你。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第一个判断改成 if(nums[i] + nums[j] == target)。 输入的 int nums[] 应该要是排好序的数组。 其他好像没啥问题，楼主你看下还有什么问题。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "测试一下0+0=？", "referer": "user-0"}]}
{"question": "c语言程序新手问题，麻烦各位大佬看看", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 forever74的回复:这个调用姿势不对。 printf(\"\\n该数组和为%d\",sum(a, n)); 然后把其上那行取消即可。 谢谢╰(*´︶`*)╯", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这个调用姿势不对。 printf(\"\\n该数组和为%d\",sum(a, n)); 然后把其上那行取消即可。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>   int main() {     int sum(int *p,int n);     int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 5};     int n = 10;     //sum(a, n);     printf(\"\\n该数组和为%d\",sum(a, n)); }  int sum(int*p, int n) {     int i;     int sum = 0;     for (i = 0; i < n; i++,p++)         sum += *p;     return sum; }  供参考～  或者用一个变量接收sum的返回值，然后在下面打印该变量～", "referer": "user-0"}]}
{"question": "c语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "最后2句改一下 a[0][m + 1] = max;后面加上下面这句 a[0][sum2+1]='\\0'; //字符串结束符被覆盖，要加上   取a[1]中的最大字符，放到a[0]中最小字符所在m后面，a[0]从m后开始依次往后移一位。 MynameisAmyxzxca MynameisJanesdcx 前是a[0]，后面是a[1]，a[1]最大是y，a[0]最小是A，y插入到A后面了。 程序除了那个'\\0'字符外没问题的。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主想做什么？没看懂代码～", "referer": "user-0"}]}
{"question": "一个无法理解的free错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "继续，尽管destroy里面的unit也同样不讲究，但用来free却没有额外错误。 然而，凭什么每个结构体四个指针三个malloc，却又四个free呢？多出来的free肯定要出错。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include \"stdio.h\" #include \"stdlib.h\" #include \"string.h\"  /*** 单元格矩阵长宽均有多少个单元**/ int mMatrixLength = 0; /* 每个单元格的长宽 */ float mMapUnitLength = 0.2; /*地图数据结构 */ struct mapUnit {     float *texCoor;    //控制在框内怎么填充图片     float *vertices;   //顶点，x,y,z,x,y,z     char *filePath;    //当前加载的图块的filePath     char *pixels;      //图块像素     char drawFinished; //加载的图块变更后，标记是否已加载对应像素到结点 };  typedef struct mapUnit MapUnit; //图块矩阵(二维指针) MapUnit *mMapUnitMatrix;  void init(){     //创建地图(有问题，偶发性闪退)     mMatrixLength = 4; //原坐标移动到左上角，所以画面长宽变成了2f。加1是为了横向纵向都多一行不可见缓冲边     mMapUnitMatrix = (MapUnit*) malloc(sizeof(MapUnit) * mMatrixLength * mMatrixLength);     int i;     for (i = 0; i < mMatrixLength * mMatrixLength; i++)     { #if 0         //MapUnit unit = mMapUnitMatrix[i];         unit.texCoor = (float *)malloc(sizeof(float) * 12); //赋值统一的TexCoor         unit.vertices = (float *)malloc(sizeof(float) * 18); //赋值每个图块单元一个符合自己位置的坐标         unit.drawFinished = 0; //每个新建的图块都是没完成像素填充的         unit.pixels = (char *)malloc(36); #else         MapUnit *unit = mMapUnitMatrix + i;         unit->texCoor = (float *)malloc(sizeof(float) * 12); //赋值统一的TexCoor         unit->vertices = (float *)malloc(sizeof(float) * 18); //赋值每个图块单元一个符合自己位置的坐标         unit->drawFinished = 0; //每个新建的图块都是没完成像素填充的         unit->pixels = (char *)malloc(36); #endif     }     printf(\"init\\n\"); }  void destroy(){     printf(\"destroy:%llu\\n\", mMapUnitMatrix);     int i;     for (i = 0; i < mMatrixLength * mMatrixLength; i++)     {         MapUnit unit = mMapUnitMatrix[i];         free(unit.pixels);         unit.pixels = NULL;         free(unit.vertices);         unit.vertices = NULL;         free(unit.texCoor);         unit.texCoor = NULL;         free(unit.filePath);     }     free(mMapUnitMatrix);     mMapUnitMatrix = NULL; }  MapUnit getUnit(int x, int y) {     return mMapUnitMatrix[y * mMatrixLength + x]; }   int main() {     while(1)     {         init();         destroy();         // init();         // destroy();     }     return 0; } 供参考～  给没有malloc的结构体成员释放空间会出现这种问题。  注意unit是结构体，在malloc的时候，如果用结构体变量而不用结构体指针申请空间，申请的空间只会是结构体变量的，而不是原有的。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "为啥要搞个unit呢？这东西是蛇足，并引起了大部分的错误。 你的init里面的大量对unit的成员的赋值和你那16个结构体一点关系都没有。 也就是说init结束的时候你那16个结构体里面的64个指针仍然是野指针。", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "OJ啊，那么主要的问题在于你没有阅读必要的说明。甚至题目也不完整，完整的题目是包括输入输出格式和例子的。 大多数OJ要求严格的输出格式，而你没有表达题目对输出格式的要求，大概率是没有关注。 多数OJ要求主函数向操作系统返回0以表达自己是正常结束，而你的主函数没有。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "因为你是要求整除，而直接相除结果会不对 例如  计算机中 3/2=1 而不是1.5", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "电脑判断机制啊。解决上面的问题，我写的代码提交时给我的结果是答案错误。       给你两个数组，从第一个数组中选择一个数x，从第二个数组中选择一个数y，问你有多少种方案使得y/x的值为k 输入第一行一个整数T，接下来有T组测试数据 对于每一组测试数据，第一行输入两个数n和k 接下来输入n个数，代表第一个数组的值 接下来输入n个数，代表第二个数组的值 1<=T<=10,1<=n<=1000,1<=k<=10000,1<=a[i],b[i]<=1000000    这就是问题。。。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "是啊，为什么呢？ 关键在于，什么叫错了？ 谁说错了？ 怎么说的？ 说的什么？ 没有足够的信息，一个什么也不干的程序也可以说是正确的程序： int main(){}", "referer": "user-0"}]}
{"question": "我觉得两个都差不多为什么第一个错了1.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "好乱，到底哪个是你写的哦。草草看了一下，scanf(\"%s %s %d %d\\n\",&stu[i].num,&stu[i].name,&stu[i].s,&stu[i].c);这句话不应该加\\n，num和name前面不加&符号", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你把return 0;写在循环里面了。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 楼主 qq_53415956的回复:#include<stdio.h> int main() { \tint n; \tdouble a[15]; \tscanf(\"%d\",&n); \tfor(int i=0;i<n;i++) \t{ \t\tscanf(\"%lf\",&a[i]); \t} \tfor(int i=0;i<n-1;i++) \t{ \t\tfor(int j=0;j<n-1-i;j++) \t\t{ \t\t\tif(a[j]>a[j+1]){ \t\t\t\tdouble tmp=a[j]; \t\t\t\ta[j]=a[j+1]; \t\t\t\ta[j+1]=tmp; \t\t\t} \t\t}\t \t} \tfor(int i=n-1;i>=0;i--) \t\t{ \t\t\tif(i==n-1) \t\t\t{ \t\t\t\tprintf(\"%.2lf\",a[i]); \t\t\t \t\t\t\t} \t\t\telse{printf(\"% .2lf\",a[i]); \t\t\t} \t\t} \treturn 0; } 2 #include<stdio.h>        struct student     {         char num[13];         char name[20];         int s;         int c;     }stu[11]; int main() {     int n; \tint cnt=0;     scanf(\"%d\",&n);     for(int i=0;i<n;i++)     {         scanf(\"%s %s %d %d\\n\",&stu[i].num,&stu[i].name,&stu[i].s,&stu[i].c); \t\tif (stu[i].c>=60){ \t\tcnt++; \t}     } \tprintf(\"%d\\n\",cnt); \tfor(int i=0;i<n;i++) \t{ \t\tif(stu[i].c>=60) \t\tprintf(\"%s %s\\n\",stu[i].num,stu[i].name); \t}                return 0; } 题目：  #include<stdio.h> struct student { \tchar num[13]; \tchar name[20]; \tint g; \tint c; }stu[11]; int main() { \tint n,i,x=0;     scanf(\"%d\",&n); \tfor(i=0;i<n;i++) \t{ \t\tscanf(\"%s %s %d %d\",&stu[i].num,&stu[i].name,&stu[i].g,&stu[i].c); \t\tif(stu[i].c>=60) \t\t{ \t\t\tx++; \t\t} \t} \tprintf(\"%d\\n\",x); \tfor(i=0;i<n;i++) \t{ \t\tif(stu[i].c>=60) \t\t{ \t\t\tprintf(\"%s %s\\n\",stu[i].num,stu[i].name); \t\t} \t\treturn 0; \t} } 这是我写的，我的不对，第二个对，我不知道为什么", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 楼主 qq_53415956的回复:#include<stdio.h> int main() { \tint n; \tdouble a[15]; \tscanf(\"%d\",&n); \tfor(int i=0;i<n;i++) \t{ \t\tscanf(\"%lf\",&a[i]); \t} \tfor(int i=0;i<n-1;i++) \t{ \t\tfor(int j=0;j<n-1-i;j++) \t\t{ \t\t\tif(a[j]>a[j+1]){ \t\t\t\tdouble tmp=a[j]; \t\t\t\ta[j]=a[j+1]; \t\t\t\ta[j+1]=tmp; \t\t\t} \t\t}\t \t} \tfor(int i=n-1;i>=0;i--) \t\t{ \t\t\tif(i==n-1) \t\t\t{ \t\t\t\tprintf(\"%.2lf\",a[i]); \t\t\t \t\t\t\t} \t\t\telse{printf(\"% .2lf\",a[i]); \t\t\t} \t\t} \treturn 0; } 2 #include<stdio.h>        struct student     {         char num[13];         char name[20];         int s;         int c;     }stu[11]; int main() {     int n; \tint cnt=0;     scanf(\"%d\",&n);     for(int i=0;i<n;i++)     {         scanf(\"%s %s %d %d\\n\",&stu[i].num,&stu[i].name,&stu[i].s,&stu[i].c); \t\tif (stu[i].c>=60){ \t\tcnt++; \t}     } \tprintf(\"%d\\n\",cnt); \tfor(int i=0;i<n;i++) \t{ \t\tif(stu[i].c>=60) \t\tprintf(\"%s %s\\n\",stu[i].num,stu[i].name); \t}                return 0; } 题目：  第一个弄错了", "referer": "user-0"}]}
{"question": "萌新求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢各位指点！成功了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "int main() {     int a,b,sum=0;     scanf(\"%d %d\",&a,&b);     for(int i=a+1;i<b;i++)        sum += i;     printf(\"%d\\n\",sum);      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "for (i = a+1; i < b; i++)     sum+= i;   供参考～  for循环的第一个表达式是初始化，不是比较和判断～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "for (i = a + 1; i < b; ++i)", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "for (i = a; i < b; ++i)", "referer": "user-0"}]}
{"question": "为什么devc++调试的结果和运行的结果不一致", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主解决了吗", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <assert.h> void sort(int *a, int left, int right); void merge(int *a, int left, int center, int right);  int main() {     int n, i;      scanf(\"%d\", &n);     int *number;      number = (int *)malloc(sizeof(int) * n);     if (!number)         return -1;      for(i=0;i<n;i++)         scanf(\"%d\", &number[i]);     sort(number, 0, n-1);     //printf(\"%d\", number[0]);     //for(i=1;i<n;i++)     for(i=0;i<n;i++)         printf(\" %d\", number[i]);      free(number);     return 0; }  void sort(int *a, int left, int right) {     if(left>=right)return;     int center;     center=(left+right)/2;     sort(a, left, center);     sort(a, center+1, right);     merge(a, left, center, right); } void merge(int *a, int left, int center, int right) {     int i, j, k, n;     k=0;     i=left;     j=center+1;     n=right-left+1;     //int re[n];     int *re;      re = (int *)malloc(sizeof(int) * n);     if (!re)         exit(0);      while(1){         if(a[i]<a[j]){             assert(k<n);             re[k++]=a[i++];             if(i>=center+1)break;         }else {             assert(k<n);             re[k++]=a[j++];             if(j>=right+1)break;         }     }     if(i>=center+1){         for(;j<right+1 ;j++) {             assert(k<n);             re[k++]=a[j];         }     }else{         for(;i<center+1;i++) {             assert(k<n);             re[k++]=a[i];         }     }     for(i=0,j=left;i<n;){         assert(i<n);         a[j++]=re[i++];     }      free(re); }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢回复，我用您的代码测试了下，会出现同样的问题。也就是说，如果我直接运行程序的话没有问题，但如果我在您发的程序的第42行设置了一个断点， 再点击下一步的时候， 这个k的值并不是0， k有时会等于1， 有时等于2， 也有时会正常等于0。当k并没有等于0的时候， 后续的k++也并不会让k每次加一， k会无规律往上增长， 甚至有时我并没有点击下一步（我只是盯着屏幕看， 没有进行任何操作）， k值也会往上增长。。。这种情况就会输出错误的结果， 或者程序崩溃。。您可以再42行设置断点试一下， 不会只有我出现这种情况吧。 重点说明，程序可以正常运行， 只有当某处设置了断点后就会出现奇怪的状况。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h>  void sort(int *a, int left, int right); void merge(int *a, int left, int center, int right);  int main() {     int n, i;      scanf(\"%d\", &n);     int *number;      number = (int *)malloc(sizeof(int) * n);     if (!number)         return -1;      for(i=0;i<n;i++)         scanf(\"%d\", &number[i]);     sort(number, 0, n-1);     //printf(\"%d\", number[0]);     //for(i=1;i<n;i++)     for(i=0;i<n;i++)         printf(\" %d\", number[i]);      free(number);     return 0; }  void sort(int *a, int left, int right) {     if(left==right)return;     int center;     center=(left+right)/2;     sort(a, left, center);     sort(a, center+1, right);     merge(a, left, center, right); } void merge(int *a, int left, int center, int right) {     int i, j, k;     k=0; i=left; j=center+1;     int n=right-left+1;     //int re[n];     int *re;      re = (int *)malloc(sizeof(int) * n);     if (!re)         exit(0);      while(1){         if(a[i]<a[j]){             re[k++]=a[i++];             if(i==center+1)break;         }else {             re[k++]=a[j++];             if(j==right+1)break;         }     }     if(i==center+1){         for(;j<right+1;j++)re[k++]=a[j];     }else{         for(;i<center+1;i++)re[k++]=a[i];     }     for(i=0,j=left;i<n;){         a[j++]=re[i++];     }      free(re); } 供参考～   测试了暂未发现问题～楼主可以多测测试试～", "referer": "user-0"}]}
{"question": "这是为什么呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:参数名字惹的祸吧，fa的地址赋值给了fb函数指针，fb的地址赋值给了形参fa的函数指针。所以形参fa(x) - fb(x) == 27 - 9 对的，眼瞎了我，希望晚上考试我可以眼睛明亮👀", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "参数名字惹的祸吧，fa的地址赋值给了fb函数指针，fb的地址赋值给了形参fa的函数指针。所以形参fa(x) - fb(x) == 27 - 9", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "参数名字惹的祸吧，fa的地址赋值给了fb函数指针，fb的地址赋值给了形参fa的函数指针。所以形参fa(x) - fb(x) == 27 - 9", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "我是来接分的", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 楼主 Infinity G的回复: 我懂了我懂了，但是我删不了帖子", "referer": "user-0"}]}
{"question": "fseek为什么总时只移到末尾而不偏移？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "另一个需要注意的是 修改位置之后 写入操作不是插入是覆盖 原先内容  123 # 写入位置在#前面 写入w 结果是 123 w 而不是 123 w#", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "和文件打开方式有关  如果是 打开模式带a 则只能在结尾添加数据 fseek对写入位置无效  只能修改读取位置  你不能正确定位问题 应该把代码完整的发出来  你的问题在fopen 而你只发了fseek", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "我的回复被版主屡次误认为是灌水删除了，我再最后一次回复，货卖识家：  不要把 fopen(\"...\",\"...\");fscanf,fprintf,fgets,fgetc,fclose //读时把\\r\\n替换成\\n，写时把\\n替换成\\r\\n;读到\\x1a就设置EOF;读写的内容当字符看待 和 fopen(\"...\",\"...b\");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\\x1a仍继续读;读写的内容当字节看待 弄混了  综上所述，fseek只能在fopen时带b时使用！", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "每次看见这样没诚意的提问，总是想到看腿识鸟的梗，然后就没兴趣了。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "不要把 fopen(\"...\",\"...\");fscanf,fprintf,fgets,fgetc,fclose //读时把\\r\\n替换成\\n，写时把\\n替换成\\r\\n;读到\\x1a就设置EOF;读写的内容当字符看待 和 fopen(\"...\",\"...b\");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\\x1a仍继续读;读写的内容当字节看待 弄混了  fopen时不带b 就不要fseek", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 9 楼 Minikinfish的回复:调用fseek，设置完文件指针，再fwrite写文件 书上说写正负都可以呀，而且可以负确实是向头方向移动字节。如果用fwrite可能不确定字符数比较麻烦", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "调用fseek，设置完文件指针，再fwrite写文件", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "引用 7 楼 脚踏实地丨仰望星空 的回复:[quote=引用 4 楼 Minikinfish的回复:]  SEEK_CUR  Current position of file pointer.  SEEK_END  End of file.  SEEK_SET  Beginning of file. 大佬，能否指点一下，看的不是很懂[/quote]   int fseek(     FILE *stream,    long offset,    int origin  );  SEEK_CUR  当前位置，偏移offset个字节 SEEK_END 文件末尾位置，偏移offset个字节（offset<=0） SEEK_SET 文件开始位置，偏移offset个字节（offset>=0）", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 4 楼 Minikinfish的回复:请看第三个参数  The fseek and _fseeki64 functions moves the file pointer (if any) associated with stream to a new location that is offset bytes from origin . The next operation on the stream takes place at the new location. On a stream open for update, the next operation can be either a read or a write. The argument origin must be one of the following constants, defined in STDIO.H:  SEEK_CUR  Current position of file pointer.  SEEK_END  End of file.  SEEK_SET  Beginning of file.  You can use fseek and _fseeki64 to reposition the pointer anywhere in a file. The pointer can also be positioned beyond the end of the file. fseek and _fseeki64clears the end-of-file indicator and negates the effect of any prior ungetc calls against stream.  When a file is opened for appending data, the current file position is determined by the last I/O operation, not by where the next write would occur. If no I/O operation has yet occurred on a file opened for appending, the file position is the start of the file. 大佬，能否指点一下，看的不是很懂", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 5 楼 脚踏实地丨仰望星空的回复:[quote=引用 3 楼 forever74的回复:]文件原来啥样 你想弄成啥样 你的代码啥样 文件变成啥样  从仅有的信息上看，一切都很正常，是你的预期或者说对文件操作的理解不对。 原来没有+wanan的部分，然后输入是+wanan那部分[/quote] 你好，我就是只打算插入到末尾#之前的，但插到后面了，就是这个问题", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 3 楼 forever74的回复:文件原来啥样 你想弄成啥样 你的代码啥样 文件变成啥样  从仅有的信息上看，一切都很正常，是你的预期或者说对文件操作的理解不对。 原来没有+wanan的部分，然后输入是+wanan那部分", "referer": "user-0"}, {"cid": "12", "user": "user-4", "content": "请看第三个参数  The fseek and _fseeki64 functions moves the file pointer (if any) associated with stream to a new location that is offset bytes from origin . The next operation on the stream takes place at the new location. On a stream open for update, the next operation can be either a read or a write. The argument origin must be one of the following constants, defined in STDIO.H:  SEEK_CUR  Current position of file pointer.  SEEK_END  End of file.  SEEK_SET  Beginning of file.  You can use fseek and _fseeki64 to reposition the pointer anywhere in a file. The pointer can also be positioned beyond the end of the file. fseek and _fseeki64clears the end-of-file indicator and negates the effect of any prior ungetc calls against stream.  When a file is opened for appending data, the current file position is determined by the last I/O operation, not by where the next write would occur. If no I/O operation has yet occurred on a file opened for appending, the file position is the start of the file.", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "文件原来啥样 你想弄成啥样 你的代码啥样 文件变成啥样  从仅有的信息上看，一切都很正常，是你的预期或者说对文件操作的理解不对。", "referer": "user-0"}, {"cid": "14", "user": "user-5", "content": "这个写只能先修改内存里，然后重新刷写文件（磁盘orflash)。不能在文件里直接插入～", "referer": "user-0"}, {"cid": "15", "user": "user-2", "content": "不要把 fopen(\"...\",\"...\");fscanf,fprintf,fgets,fgetc,fclose //读时把\\r\\n替换成\\n，写时把\\n替换成\\r\\n;读到\\x1a就设置EOF;读写的内容当字符看待 和 fopen(\"...\",\"...b\");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\\x1a仍继续读;读写的内容当字节看待 弄混了", "referer": "user-0"}]}
{"question": "题目如图，求教：为什么输出答案不对，我自己执行代码可以得出第一行案例答案，后两个有问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改如下，供参考：#include <stdio.h>   int main()   {       int flag[50]={0};     int m,n,num,i=0,index=0, k=0;      scanf(\"%d%d\",&m,&n);     if(n>m) n=m-1;      num=m;     while(num>n){         if(flag[i]==0){            index++;            if(index%2==1){                flag[i]=1;                k++;            }         }         i++;         if(i==m){i=0;index=0;}         num=m-k;     }     for(i=0;i<m;i++){        if(flag[i]==0)           printf(\"%d,\",i+1);     }     printf(\"\\n\");         return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "error C4700: 使用了未初始化的局部变量“num”", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "难道没抱错?至少变量num未初始化就使用会提示 int num,index=0,k=0; i=0; while(num>n)", "referer": "user-0"}]}
{"question": "教学信息管理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "。。。。。。", "referer": "user-0"}]}
{"question": "关于清空输入行左边的空白字符的思路是什么呀？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #define MAXLEN 80 char *get_first_word(char *s) {     static char t[MAXLEN];     char c;     int i,j,st;      i=0;     j=0;     st=0;     while (1) {         if (i>=MAXLEN-1) break;         c=s[i];         if (c==0) break;         if (st==0) {             if (!(c==' ' || c=='\\t' || c=='\\n')) {                 t[j]=c;                 j++;                 st=1;             }         } else {//st==1             if (!(c==' ' || c=='\\t' || c=='\\n')) {                 t[j]=c;                 j++;             } else break;         }         i++;     }     t[j]=0;       return (char*)t; } int main() {     char ln[MAXLEN];      fgets(ln,MAXLEN,stdin);     printf(\"[%s]\\n\",ln);     printf(\"[%s]\\n\",get_first_word(ln));     return 0; } // 输入： //          word abc // 输出： // [        word abc // ] // [word] //", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf就行，天生爱跳过左空白的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢大神", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "找到第一个有效字符，然后memcpy即可。", "referer": "user-0"}]}
{"question": "这怎么搞啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "VS2015 C++环境调试 变量a在内存中数据是", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "出题人默认的小端模式吧", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这题操蛋。不确定大小端，答案只有上帝知道。。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不说是什么CPU，真是～呀。 假设是x86，属于小端体系，int型的4个字节里按地址从低到高依次存放0x78   0x56   0x34   0x12 所以pc+2里面保存的是0x34 。", "referer": "user-0"}]}
{"question": "有大佬知道这两个报错怎么解决吗，附上c文件和.h文件", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "没定义main函数？！这个源文件里没看到你定义的main函数呢", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "初学C吧。 要理解这个代码，首先要弄清楚，指针变量与普通变量的区别：前者是告诉编译器，存储的值是一个地址值；后者则是数值。 所以对于指针变量p,  *p++ 和(*p)++是有区别。 函数里面，搞两个指针，一个指向头，一个指向尾。 按地址比较，然后交互数值大小。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "s1=w 指针指向字符串的首地址（也就是s1指向‘1’这个字符的地址） s2=w+n-1 指针指向字符串最后一个字符的地址（也就是s2指向‘7’这个字符的地址） while(s1<s2)当s1指向的地址小于s2指向的地址则一直循环 t=*s1;*s1=*s2;*s2=t;就是交换s1和s2地址的字符，也就是‘1’变成了‘7’，‘7’变成了‘1’ s1++就是s1指向的地址递增，也就是s1指向‘2’所在的地址 s2--就是s2指向的地址递减，也就是s2指向‘6’所在的地址 这样，下一轮while循环就会交换‘2’和‘6’，再下一轮就交换‘3’和‘5’，再下一轮，s1指向‘4’，s2也指向‘4’，不满足while，循环结束 所以最终字符串变为“7654321”", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "fun函数实现字符串转置", "referer": "user-0"}]}
{"question": "请大家帮忙看看，这个程序哪里出了问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void Update(int count)       {int i,num,flag=1;        printf(\"请输入要修改的姓名的编号：\");        scanf(\"%d\",&num);        for(i=0;i<count&&flag;i++)        if(guest[i].num==num)        {           printf(\"请输入人数：\");           scanf(\"%d\",&guest[i].sum);           printf(\"请输入用餐时间：\");           scanf(\"%s\",guest[i].time);           flag=0;         }         else              printf(\"\\n没有查询到可以修改的数据！\\n\");       } 把else语句从for循环里删除。因为每循环一次只要没找到，就会else一次", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "逻辑有点小问题。比如说，当你在查询一个编号时，如果这个编号是后面插入的，那么它和前面插入的不相等，就会输出错误提示；但是随着循环进行下去，找到了相等的编号时，函数功能又能够正常执行。 所以说，判断一个编号是否存在，是需要将已有的编号全部遍历完之后才能得出的结论，而不是每个编号都进行错误提示。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "几个函数逻辑判断有误，#include<stdio.h> #include<string.h>  #define MaxSize 20  struct guest_info{    char name[10];     int sum;    char time[10];     int num; }guest[MaxSize];  void Insert(int *count); void Search(int count); void Update(int count); void Delete(int *count); void Show(int count); void Exit(void);   int main() {        int i;        int count=0;        do          {printf(\"\\n\");           printf(\"1----点餐(Insert)\\n\");           printf(\"2----查询(Search)\\n\");           printf(\"3----修改订餐信息(Update)\\n\");           printf(\"4----删除订单(Delete)\\n\");           printf(\"5----显示订餐信息(Show)\\n\");           printf(\"6----退出(Exit)\\n\");           scanf(\"%d\",&i);           switch(i)                   {case 1:Insert(&count);                           break;                    case 2:Search(count);                           break;                    case 3:Update(count);                           break;                    case 4:Delete(&count);                           break;                    case 5:Show(count);                           break;                    case 6:Exit( );                           break;                   default:printf(\"错误选择！请重选\");           }         }while (i!=6);// (i!=8)             return 0; }    void Insert(int * count)  {        int i,in_num;        if(* count==MaxSize)           {printf(\"空间已满！\");return ;}        printf(\"请输入编号：\");        scanf(\"%d\",&in_num);        for(i=0;i<* count;i++)           if(guest[i].num==in_num)              {printf(\"已有相同编号,请重新操作。\\n\");return ; }        guest[i].num=in_num;        printf(\"请输入姓名：\");        scanf(\"%s\",guest[i].name);        printf(\"请输入用餐人数：\");        scanf(\"%d\",&guest[i].sum);        printf(\"请输入用餐时间：\");        scanf(\"%s\",guest[i].time);        (* count)++;  }   void Search(int count)  {       int i,num,flag=1;       printf(\"请输入要查询的编号：\");       scanf(\"%d\",&num);       for(i=0;i<count&&flag;i++)          if(guest[i].num==num)             {               printf(\"\\n姓名：%s\\n\",guest[i].name);               printf(\"用餐人数：%d\\n\",guest[i].sum);               printf(\"用餐时间：%s\\n\",guest[i].time);               flag=0;             }           //else       if(flag) printf(\"\\n没有查询到相关信息\\n\");  }   void Update(int count)  {       int i,num,flag=1;       printf(\"请输入要修改的编号：\");//printf(\"请输入要修改的姓名的编号：\");       scanf(\"%d\",&num);       for(i=0;i<count&&flag;i++)        if(guest[i].num==num)          {           printf(\"请输入人数：\");           scanf(\"%d\",&guest[i].sum);           printf(\"请输入用餐时间：\");           scanf(\"%s\",guest[i].time);           flag=0;          }        //else       if(flag) printf(\"\\n没有查询到可以修改的数据！\\n\");  } void Delete(int * count) {        int i,j,num,flag=1;        printf(\"请输入要删除的编号：\");//printf(\"请输入要删除的姓名的编号：\");        scanf(\"%d\",&num);        for(i=0;i<* count&&flag;i++)           //{             if(guest[i].num==num)               {                 for(j=i;j<* count-1;j++)                     guest[j]=guest[j+1];                 flag=0;                 (* count)--;               }         //else         if(flag) printf(\"\\n没有查询到可以删除的数据！\\n\");        //} }  void Show(int count) {      int i;      printf(\"\\n\");      printf(\"编号    姓名     人数    用餐时间\\n\");      for(i=0;i<count;i++)        {          printf(\"%4d\",guest[i].num);          printf(\"%8s\",guest[i].name);          printf(\"%9d\",guest[i].sum);          printf(\"%12s\\n\",guest[i].time);        } }  void Exit(void)     {       printf(\"已退出，欢迎下次使用。\\n\");     }修改如下，供参考：", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "可参", "referer": "user-0"}]}
{"question": "求大佬看看 用VC6.0一直没有输出有bug", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printfNode 函数中的 printf 里面，是不是少个pMove->data.kind,", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "调试也不行 会显示acess violence", "referer": "user-0"}]}
{"question": "C语言头文件.h目录下有两句typedef void SeqList 和typedef SeqListNode是什么意思？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "给void起了不同的别名。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "给void起了个别名，分别是SeqList和SeqListNode.", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "void == SeqList == SeqListNode", "referer": "user-0"}]}
{"question": "关于设计俄罗斯方块", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "版主基本归纳清楚了", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先想清楚方块下落的逻辑。比如说： （1）判断能否继续下落；（2）判断是否到底部；（3）下落一行之后判断该行是否填满；。。。 把你需要做的事想清楚后很多功能要怎么实现就很明确了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "UI + 算法", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-3的回复:char *a[] = { ... }; print(a[n-1]); 嗯嗯，谢谢你了!", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 赵4老师的回复:if (1==scanf(\"%d\", &mon) && 1<=mon && mon<=12) {  printf(\"%s\\n\", month[mon-1]); } else {  printf(\"Input error!\\n\");  return -1; } return 0;   嘿嘿，谢谢老师！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:#include <stdio.h>  int main(void) {     int mon;      const char *month[] = {         \"January\", \"February\", \"March\", \"April\",         \"May\", \"June\", \"July\", \"August\",         \"September\", \"October\", \"November\", \"December\"};     scanf(\"%d\", &mon);      if (mon > 12) {         printf(\"Input error!\\n\");         return -1;     }      printf(\"%s\\n\", month[mon-1]);      return 0; } 供参考～ 好的，谢谢了～", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "if (1==scanf(\"%d\", &mon) && 1<=mon && mon<=12) {  printf(\"%s\\n\", month[mon-1]); } else {  printf(\"Input error!\\n\");  return -1; } return 0;", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h>  int main(void) {     int mon;      const char *month[] = {         \"January\", \"February\", \"March\", \"April\",         \"May\", \"June\", \"July\", \"August\",         \"September\", \"October\", \"November\", \"December\"};     scanf(\"%d\", &mon);      if (mon > 12) {         printf(\"Input error!\\n\");         return -1;     }      printf(\"%s\\n\", month[mon-1]);      return 0; } 供参考～", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "char *a[] = { ... }; print(a[n-1]);", "referer": "user-0"}]}
{"question": "C语言，为什么选B而不是选D？求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这题需要理解指针的概念。 这里的s，定义时实际上是int *s，也就是说定义了一个int型指针。 而数组本质上也是指针，指向该数组的起始地址。 所以说 s = x + 3 指向的是x[3]的地址。 而s[2] 实际上相当于 *(s+2)，也就相当于 *(x+5)，指向的是x[5]，所以值为 x[5] = 0。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "s = &x[3];那么&s[2] == &x[3+2]", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "s=x+3;就是x[3], s[2]则是x[5] 就是0", "referer": "user-0"}]}
{"question": "c语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "32号和64号口红涂上去效果不同，这不是很正常吗？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "研究他们是怎么存储的，占多少位，OK。", "referer": "user-0"}]}
{"question": "哥哥们，帮帮我", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 qq_53663635 的回复:[quote=引用 1 楼 陈仲甫的回复:]。。这是作业吧 你可以一开始显示一个1、2、3之类的文字菜单 预先把所有成绩数据加载到链表； _getch()可以获得用户的一次选择，并且不回显； 查找可以从链表头扫描到尾，挨个比较； 这是最笨的办法，但能满足作业要求 有没有代码提供的，我们没有学链表，但是有作业了[/quote]  typedef struct _MyNode { \tint iMyNodeDat;\t\t\t// 这个是你自己节点的数据 \tMyNode* lpNextNode;\t\t// 你也同时包括下一个节点的指针，像链条一样，所以叫链表，最后一个元素他的lpNextNode为NULL } MyNode;   MyNode* FindVal(int iLookFor, MyNode* lpHead) { \tfor (MyNode* lpNode = lpHead; NULL != lpNode; lpNode = lpNode->lpNextNode) \t{ \t\tif (iLookFor == lpNode->iMyNodeDat) \t\t{ \t\t\treturn lpNode; \t\t} \t}  \treturn NULL; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 陈仲甫的回复:。。这是作业吧 你可以一开始显示一个1、2、3之类的文字菜单 预先把所有成绩数据加载到链表； _getch()可以获得用户的一次选择，并且不回显； 查找可以从链表头扫描到尾，挨个比较； 这是最笨的办法，但能满足作业要求 有没有代码提供的，我们没有学链表，但是有作业了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "。。这是作业吧 你可以一开始显示一个1、2、3之类的文字菜单 预先把所有成绩数据加载到链表； _getch()可以获得用户的一次选择，并且不回显； 查找可以从链表头扫描到尾，挨个比较； 这是最笨的办法，但能满足作业要求", "referer": "user-0"}]}
{"question": "c语言初学者并集问题，可能写复杂了。不知道为什么出现图中的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void delate(int a[]) {     int j,i;     for(i=9;i>0;i--)        if(a[i]==0)          for(j=i;j<10-1;j++)             a[j]=a[j+1]; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "出错信息很明确，你的源代码的18行引起无效内存引用，也就是数组访问越界。", "referer": "user-0"}]}
{"question": "求解 急拜托拜托", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "网上一大堆，仅供参考： #include <stdio.h>  int fib(int n) { \tif(n < 2) return n; \telse return fib(n-1) + fib(n-2); }  int main(void) { \tint i; \tfor(i=0; i<20; i++) \t{ \t\tprintf(\"%d%c\", fib(i), i%4 == 3 ? '\\n' : '\\t'); \t} \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": ".....................这种百度一下一大堆啊~", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "可参", "referer": "user-0"}]}
{"question": "大家看一下我哪里有问题，谢谢！ 利用函数编程：从键盘输入一个由大小写字母组成的字符串，统计与第一个字母相同的字母有几个。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "粗心了，懂了，谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "区分大小写的话直接比较即可无需写那么啰嗦，不区分大小写的话也很简单减去一个差值即可。取下标0循环一遍依次与各位比较即可。 如if(s1[0]==s1[i] || s1[0] == s1[i]-32 || s1[0] == s1[i] + 32) 另外for(i=0;i!='\\0';i++)i是数字怎么可能与字符比较？", "referer": "user-0"}]}
{"question": "一个值的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "难道是编译器的问题 。。。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "很多初学者老是把截断当成误差，其实它是错误。 浮点数赋值给整型的时候不是四舍五入，是截断的。 赋值前先加上0.5才是对自己负责。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "修改如下，供参考：#include<stdio.h> int main() {     int a,n;     scanf(\"%d %d\",&a,&n);     int i,sum=0,t=0;      for(i=0;i<n;i++){         t = t*10 + 1;      //t=t+pow(10,i);         printf(\"t=%d\\n\",t);         sum+=a*t;         printf(\"s = %d\\n\", sum);     }     printf(\"s = %d\\n\", sum);      return 0; } 两种方式结果相同：", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:不是A，而是a。 好的，谢谢😜", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "不是A，而是a。", "referer": "user-0"}]}
{"question": "求大佬帮忙看看。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "使用fread，fwrite,fseek通过块读写和定位实现。", "referer": "user-0"}]}
{"question": "C/C++ 有关二维数组的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "sum+=(*a)[i]改成 sum+=a[i]或sum+=*(a+i)", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "必须得错啊，谁让你得罪人", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "仅供参考：#include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <typeinfo.h> int main() {     int sa[3][4];     int **db;     int j,k;      for (j=0;j<3;j++) {         for (k=0;k<4;k++) {             sa[j][k]=j*10+k;         }     }      for (j=0;j<3;j++) {         for (k=0;k<4;k++) {             printf(\" %3d\",sa[j][k]);         }         printf(\"\\n\");     }      printf(\"typeid(sa[0]   ).name() is %s\\n\",typeid(sa[0]   ).name());     printf(\"typeid(sa      ).name() is %s\\n\",typeid(sa      ).name());     printf(\"\\n\");      db=(int **)malloc(3*sizeof(int *));     if (NULL==db) return 1;     for (j=0;j<3;j++) {         db[j]=(int *)malloc(4*sizeof(int));         if (NULL==db[j]) return 1;     }     for (j=0;j<3;j++) {         for (k=0;k<4;k++) {             db[j][k]=j*10+k;         }     }      for (j=0;j<3;j++) {         for (k=0;k<4;k++) {             printf(\" %3d\",db[j][k]);         }         printf(\"\\n\");     }      printf(\"typeid(db[0]   ).name() is %s\\n\",typeid(db[0]   ).name());     printf(\"typeid(db      ).name() is %s\\n\",typeid(db      ).name());     printf(\"\\n\");      for (j=0;j<3;j++) {         free(db[j]);     }     free(db);      return 0; } //   0   1   2   3 //  10  11  12  13 //  20  21  22  23 //typeid(sa[0]   ).name() is int [4] //typeid(sa      ).name() is int [3][4] // //   0   1   2   3 //  10  11  12  13 //  20  21  22  23 //typeid(db[0]   ).name() is int * //typeid(db      ).name() is int * * // //", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "以下描述仅作阐述，无意批评。这种误解我当初也干过： 主函数里做实参的部分由于其作用就是求值，就算是语法不严谨什么的都不影响结果，因为实参传递给形参的仅仅是值，没有类型信息。当然，这个值是个地址。  然而函数里面由于形参列表的声明，会把传递过来的内容解读做int **类型，所以循环里面的(*a)会被解读为int*类型，也就是地址。但是*a是1呀（这里才是int**类型和int(*)[4]类型的本质区别），于是去访问地址1了。集 段错误和总线错误 于一体，估计哪个操作系统也忍受不了这个。", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "此问题的关键在于sizeof(void *)是否等于sizeof(int),若是结果碰巧会对，即编译结果是不是32位即Ⅹ86模式。", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "形参应该用int *a即一重指针。实参用&sum[0][0]", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "谢谢各位大佬，我悟了", "referer": "user-0"}, {"cid": "9", "user": "user-8", "content": "引用 5 楼 SSY6p 的回复:我想把这个二维数组当成一个一维数组访问，为什么不行嘞 怎么不行？完全可以，可以参考我上面的回复。 数组在内存中只是一块地址连续的空间，怎么解析完全由你自己决定。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "我想把这个二维数组当成一个一维数组访问，为什么不行嘞", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "sum才是int(*)[4]类型， &sum是int(*)[3][4]类型了，一旦+1会加出去48字节那种。", "referer": "user-0"}, {"cid": "12", "user": "user-8", "content": "仅供参考： #include <stdio.h>  int sun(int *a, int size) { \tint i, sum = 0; \tfor(i=0; i<size; i++) sum += a[i]; \treturn sum; }  int main(void) { \tint sum[3][4] = {1,1,1,1,1,1,1,1,1,1,1,1}; \tprintf(\"%d\\n\", sun((int *)sum, 12)); \treturn 0; }", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "因为指针和数组终究是不一样的。 你的*a会被理解为取目标，而实际上它继承的数组地址，因而没有“目标”。  两个双星的地方用单星，然后sum+=a[i];即可。", "referer": "user-0"}, {"cid": "14", "user": "user-9", "content": "&sum是int (*)[4]类型，也就是数组指针（指向长度为4的数组的指针）。和int**不是同一个类型。", "referer": "user-0"}]}
{"question": "我要吐槽这个大坑！！！关于12864汉字显示问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 楼主 xiao_bai_cai_555的回复:（首先声明，我只是为了吐槽，解决方法从网名“林一捆”的大佬那里看来的）     由于keil本身的固有bug，keil编译器会忽略0xFD值的字符串，导致汉字内码以0xFD结尾的汉字和紧跟着后面的汉字全部显示为乱码，因为它把0xFD丢掉了，导致后面的一大串全是错的。     我也写了一个显示汉字的程序，自己怎么改都是显示乱码，我找了一个对的程序，照着人家的一行行的对，偏偏没注意到定义字符串那，因为神tm会想到是那的问题！可以说是绞尽脑汁了     历时1天，到我写这篇文章前，我终于找到了哪有错（显示不出来后面就加\\xfd试试），然后搜到了答案QAQ。 从网上买的qc12864b，使用说明像屎一样，看了一遍又一遍，对于我这个小白来说真的太艰难了！  最后展示一下我的改错吧，没错，就是那个“积”字。    我是不是发错地方了，吐槽也要积分 123456", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "借楼主帖子，也吐槽一下，keil收费，蛋疼。虽有破解，但不一定安全。 arm公司太小气了，应该学习ibm公司，收购eclipse，直接开源免费用，爽。 注：楼主可以试试gcc，开源免费，放心用，弄个交叉编译看看效果，哈哈~~~~", "referer": "user-0"}]}
{"question": "结构体数组中字符串的输入输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果用指针的话，得分配内存，而且得用strcpy拷贝内容给它", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "原来这样啊", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主定义的是一个字符，不是字符串。修改如下：struct std_infor {       char std_name[20]; };  struct std_infor student[51];  int main() {    void infor_in();    infor_in();    for(int i=0;i<51;i++)        printf(\"%s\\n\",student[i].std_name);        return 0; }  void infor_in() {    printf(\"请输入学生姓名\\n\");    for(int i=0;i<51;i++)       scanf(\"%s\",&student[i].std_name); }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "#include <stdio.h> #include <stdlib.h> struct std_infor {     char *std_name;     }; struct std_infor student[51]; int main() { \tvoid infor_in(); \tinfor_in();  \t } void infor_in() {\t    \t printf(\"请输入学生姓名\\n\");       scanf(\"%s\", &student[0].std_name);       printf(\"%s\", student[0].std_name);   } //会有异常，无法输出", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "可以发一下源码  我试试", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "应该没问题呀  你的报错是什么", "referer": "user-0"}]}
{"question": "蓝桥杯练习", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "啊，没注意到long b[n]={0}这个地方，确实是C99不允许VLA初始化的问题。不过这只是为了简化编译器复杂度做的语言限制，不是说技术上做不到，既然long b[n];是可以的，显然编译器生成了代码在运行时根据n的大小分配数组空间，那么它也完全可以根据n的大小初始化数组，至于初始化数据超过n怎么办，要么截断（最安全），要么不考虑安全性只管填充（C库的一些函数就是这么二，缓冲区溢出的源头在此）。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "有点明白了！感谢大佬！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "初始化，又称赋初值，英文initialize，和赋值完全不是一码事。 C语言规定它是编译期动作。 而C99的变长数组要到运行期才能确定它有多大，反过来说就是编译期不知道它有多大，因此编译期无法初始化。  这就是为什么全局数组，static局部数组都不能变长，就因为它们在编译期有默认的初始化动作。 顺理成章的，有初始化动作的普通局部数组也就不能变长了。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "自己写循环赋值，或者memset都行啊。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 forever74的回复:出错信息很明确，只要你不对数组b进行初始化就行。 可变长数组的定义是运行期的事，初始化是编译期的事，这样写代码就好像光棍哥要预定一件婚纱～ 但是我数组b不初始化，我下边还要用它怎么办？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "不是这样哦。 如果不支持C99，那么不应该出这样的出错信息。 事实上变长数组不能初始化正是C99说的。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "楼上正解。编译时应该添加：-std=c99", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "它的编译器不支持C99，或者默认没有启用", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "出错信息很明确，只要你不对数组b进行初始化就行。 可变长数组的定义是运行期的事，初始化是编译期的事，这样写代码就好像光棍哥要预定一件婚纱～", "referer": "user-0"}]}
{"question": " 大家帮我看看为什么我这个程序“try again？Y or N”会出现2次？我用的ipad编译器", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 forever74 的回复:你的getchar第一次抓到的是之前留在缓冲区里的换行符，所以循环空转了一次。  另外，不要把getchar 和scanf混淆，它一般不会返回1的。 有道理，说的很对！，谢谢，不过前面已经给了我正确答案了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2 的回复:楼主的逻辑设计太繁琐了，可以考虑简化下。程序修改如下，供参考：#include <stdio.h> #define STEP1 17850 #define STEP2 23900 #define STEP3 29750 #define STEP4 14875  int main(int argc, char* argv[]) {     float salary;     float tax;       int kind;       int step;      char ch;       int break1;     while(1)          {            printf(\"Please sected your kind:1，单身；2，户主；3，已婚，共有；4已婚，离异\\n\");            if(scanf(\"%d\",&kind)!=1)              {                printf(\"Please enter a correct number!\\n\");                continue;              }         //};  这里多了‘；’号            if(kind>=5)              {                printf(\"Please enter a correct number(1-4):\\n\");                continue;              }            if(kind<0)  break;            else              {                switch(kind)                  {                    case(1):step=STEP1;break;                    case(2):step=STEP2;break;                    case(3):step=STEP3;break;                    case(4):step=STEP4;break;                  }                while(1)                  {                    printf(\"Please enter your salarys in this year:\\n\");                    if(scanf(\"%f\",&salary)!=1)  continue;                    else if(salary<=0) tax=0;                         else if(salary<step) tax=salary*0.15;                              else                                 tax=step*0.15+(salary-step)*0.28;                    break;                  }                printf(\"you tax is $%.2f.\\n\",tax);              }            while(1)             {               printf(\"try again ?Y or N\\n\");               getchar();  //吃掉缓冲区多余字符               ch=getchar();               //if((ch=getchar())==1&&ch!='Y'&&ch!='y'&&ch!='N'&&ch!='n')continue;               if(ch=='Y'||ch=='y')                 {                   break1=1; break;                 }               else if(ch=='N'||ch=='n')                 {                   break1=0; break;                   }             }            if(!break1) break;          }     printf(\"Done!\\n\");      return 0; } 太赞了，完全正确，谢谢！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "你的getchar第一次抓到的是之前留在缓冲区里的换行符，所以循环空转了一次。  另外，不要把getchar 和scanf混淆，它一般不会返回1的。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "楼主的逻辑设计太繁琐了，可以考虑简化下。程序修改如下，供参考：#include <stdio.h> #define STEP1 17850 #define STEP2 23900 #define STEP3 29750 #define STEP4 14875  int main(int argc, char* argv[]) {     float salary;     float tax;       int kind;       int step;      char ch;       int break1;     while(1)          {            printf(\"Please sected your kind:1，单身；2，户主；3，已婚，共有；4已婚，离异\\n\");            if(scanf(\"%d\",&kind)!=1)              {                printf(\"Please enter a correct number!\\n\");                continue;              }         //};  这里多了‘；’号            if(kind>=5)              {                printf(\"Please enter a correct number(1-4):\\n\");                continue;              }            if(kind<0)  break;            else              {                switch(kind)                  {                    case(1):step=STEP1;break;                    case(2):step=STEP2;break;                    case(3):step=STEP3;break;                    case(4):step=STEP4;break;                  }                while(1)                  {                    printf(\"Please enter your salarys in this year:\\n\");                    if(scanf(\"%f\",&salary)!=1)  continue;                    else if(salary<=0) tax=0;                         else if(salary<step) tax=salary*0.15;                              else                                 tax=step*0.15+(salary-step)*0.28;                    break;                  }                printf(\"you tax is $%.2f.\\n\",tax);              }            while(1)             {               printf(\"try again ?Y or N\\n\");               getchar();  //吃掉缓冲区多余字符               ch=getchar();               //if((ch=getchar())==1&&ch!='Y'&&ch!='y'&&ch!='N'&&ch!='n')continue;               if(ch=='Y'||ch=='y')                 {                   break1=1; break;                 }               else if(ch=='N'||ch=='n')                 {                   break1=0; break;                   }             }            if(!break1) break;          }     printf(\"Done!\\n\");      return 0; }", "referer": "user-0"}]}
{"question": "Linux下setlocale( LC_ALL , \"zh_CN.GBK\" ) 设置失败", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "TO: forever74 楼上精辟啊，赞一个。 顺便show一下我的Fedora 33：", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "喝茶的时候想想，操作系统这个东西，只有在它还是源代码的时候，那些内核程序员有资格对它动手动脚。  一旦它运行起来，尽管如今它还没有智能，但是它有自己的规矩，我等写应用程序的猿只能在它规定的框架下做事，偶尔请求它帮个忙。 在它那一亩三分地儿，它就是天道。  好在我们活在系统外，不爽的时候可以给它断电，格式化，重装。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "LANG=zh_CN.GB2312", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "BTW,在这个设置成功完成以后，接着都用w系的库函数，就再也不要用printf啦puts啦这些函数了，因为它们会捣乱的。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "你似乎对这个函数的作用有些误解，以为你想设置什么就设置什么。 其实不是这样的。 这个函数设置的其实是程序员预期的将来这个程序要运行的环境的本地字符集。 也就是说，如果你预期你这个代码编译以后要运行在windows 7 8 10上，那你才能那样写。 当然，这需要编译器和库系统的支持，配合一大堆交叉编译配置，你才能才linux上编译链接出.exe来。  所以，如果你的代码要在你执行编译的机器上运行，你就看看环境变量LANG是啥，你就只能设成啥，更好的办法是两个双引号中间啥也不敲。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "是 无法改为GBK 是  以上答案都是我瞎猜的。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "好吧，又错了，我之前的回复是今天的，不是昨天。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "好吧，抱歉我没说清楚。 setlocale函数能设置什么取决于你系统上都安装了哪些locale，安装问题去找安装程序解决，安装了哪些用locale -a查询。 但是每个进程都可以调用setlocale设置自身的外在编码属性。 我们用linux的时候，因为我们讨论的是编译和运行，那么这个时候我们的代码编译出来的可执行文件它的环境就是调用执行它的那个进程。这个进程多半（但不是一定）是个bash，我们代码里的setlocale得是安装好的才能执行，同时得是和环境设置相同/兼容的才能显示出正确的文字，这就是昨天我说“只能”的意思。因为我们很多时候不拥有修改环境的权限，所以只能迁就环境。 但是对于bash来说，你可以通过修改环境变量来让它重新setlocale，export LC_ALL=zh_CN.GBK 就可以让bash去搞GBK了，然后在这个bash里你的程序也GBK的话就能正常显示文字了。 --------------------------------------------- 我们的障碍在于源代码文件本身默认需要UTF8编码，这是gcc的需要，要折腾gcc是另外的话题。 这样一个非UTF8的bash可以正常运行和它相同setlocale的可执行程序，但是在cat源代码的时候反而会乱码了。  综上，我们一般的思路是，因为gcc默认需要UTF8的源代码，所以我们得在UTF8的环境下写源码，所以我们运行UTF8的shell，而要在UTF8的shell里运行我们的程序并正常显示字符，我们的程序里需要setlocale成UTF8。 --------------------------------------------- 当然，如果一个程序是个服务器程序，它的执行过程中根本不在本机显示字符，那就是另一回事了。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "sudo apt-get -y install language-pack-zh-hans", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "Linux内核使用UTF-32，API层使用UTF-8，不支持UTF-16和MBCS（除非程序自己处理编码），Linux中的宽字符wchar_t是UTF-32编码，与windows中的UTF-16不同", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "好像可以另行安装对中文的支持。搜一下", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 4 楼 ctrigger 的回复:LANG=zh_CN.GB2312 这个是某个配置文件里的设置还是setlocale的设置？GB2312、GBK、GB18030我都试过了（setlocale），都是失败", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:是 无法改为GBK 是  以上答案都是我瞎猜的。 编码环境那个，我是指locale命令列出来的结果的那个，有办法让它变为zh_CN.GBK吗？", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 6 楼 ctrigger 的回复:TO: forever74 楼上精辟啊，赞一个。 顺便show一下我的Fedora 33：  为什么你的支持gbk等编码，我的zh_CN只有UTF-8？", "referer": "user-0"}]}
{"question": "请问我加了除法，为什么运行里面没有除法的题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "%3是得不到3的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "b=1+rand()%9;//避免0作分母", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "%4", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "有人吗？？？？", "referer": "user-0"}]}
{"question": "C语言中，关于float与double使用造成不同结果的原因？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "是说什么少了0.000001吗？我的编译器是多了0.000001，数据其实是以二进制存储的，double有8字节，但float只有4字节，就会造成误差（0.000001）", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "没出任何问题，你发现了一个float和double精度不同的很好的栗子，表扬一哈。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "第一次while循环,(a=1)<(b=2)是true(=1)<(c=2)，循环条件成立，所以交换a和b，且c递减变为1 第二次while循环,(a=2)<(b=1)是false(=0)<(c=1)，循环条件还是成立，所以交换a和b，且c递减变为0", "referer": "user-0"}]}
{"question": "大佬们有人能讲一下这个啥原理吗，我看不懂。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "简单地说， 循环几次，就输出几个空格占位置，然后再干正事儿。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这有啥原理呢，先打印空格，再打印图案呗", "referer": "user-0"}]}
{"question": "运行超时问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以这样试试：  #include <stdio.h> int a[100000], b[100000]; int main() { \tint n,i; \tscanf(\"%d\", &n); \tfor (i = 0; i < n; i++) \t{ \t\tscanf(\"%d\", a + i); \t\tb[a[i]]++; \t} \tfor (i = 0; i < n; i++) \t{ \t\tif (b[a[i]] == 1) \t\t{ \t\t\tprintf(\"%d\\n\", a[i]); \t\t\treturn 0; \t\t} \t} \tprintf(\"None\\n\"); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "尽量不要在C代码里面混入C++语法嘛。 况且这个并不解决超时问题。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int n,flag=1;      scanf(\"%d\",&n);      int *a = new int[n];     int *b = new int[n];     memset(a,0,sizeof(int)*n);     memset(b,0,sizeof(int)*n);      for(int i=0;i<n;i++)         scanf(\"%d\",&a[i]);      for(int i=0;i<n;i++){        for(int j=0;j<n;j++)            if(a[i] == a[j])             b[i]++;     }      for(int i=0;i<n;i++)         if(b[i]==1){           printf(\"%d\\n\",a[i]);           flag=0;           break;         }      if(flag) printf(\"None\\n\");      delete []a;     delete []b;      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "超时就是太慢了嘛，想办法提高效率。  好好挖掘一下数组的作用，降低循环次数，不要有二重循环。", "referer": "user-0"}]}
{"question": "请问位大佬,如何开启开启发生生成错误，是否继续并运行上次的成功生成", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "解决了吗，我也遇到了同样的问题，呜呜┭┮﹏┭┮", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用计算机，用浏览器访问本贴 https://bbs.csdn.net/topics/398725415 然后往下边看，更下边。", "referer": "user-0"}]}
{"question": "萌新求问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "多谢了，hxd", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "修改如下，供参考：#include<stdio.h> #include<math.h>  int main(int argc, char* argv[]) { \tint x1,y1,x2,y2,k=0; \tdouble lenght[10];         while( scanf(\"%d %d %d %d\",&x1,&y1,&x2,&y2) != EOF)//Ctrl+Z 结束输入         {            lenght[k] = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));            k++;         }         for(int i=0;i<k;i++)             printf(\"%.2f\\n\",lenght[i]);                 return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不对啊，还要输入多组数据啊，就是这里不会了", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "供参考：#include<stdio.h> #include<math.h>  int main(int argc, char* argv[]) { \tint x1,y1,x2,y2; \tdouble lenght;  \tscanf(\"%d %d %d %d\",&x1,&y1,&x2,&y2); \tlenght = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));          printf(\"%.2f\\n\",lenght);          return 0; }", "referer": "user-0"}]}
{"question": "救救孩子吧  我是真的不会了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:什么地方出错了呢？ 文件为空的话", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "if（n==1）后面的运行不出来但是忘记为空的话后面又可以", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "什么地方出错了呢？", "referer": "user-0"}]}
{"question": "请问fatal error LNK1104: cannot open file \"Debug/作业.exe\"怎么回事", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不能打开是因为它开着呢，你得先关上它才能有机会打开。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不要用中文。。。。", "referer": "user-0"}]}
{"question": "strtok_r使用报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你要是光说“报错”，那我就只能说“改正呗”。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "赞同。楼主正解。。", "referer": "user-0"}]}
{"question": "C语言链表问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h>  typedef struct Node* PtrToNode; typedef int ElementType; //typedef struct Node{  //后面没有别名所以去掉typedef struct Node{     ElementType Data;     PtrToNode Next; };  typedef PtrToNode List;  List createList() {     List head = (PtrToNode)malloc(sizeof(struct Node));     if (!head)         exit(0);     head->Data = 0;     head->Next = NULL;     printf(\"头节点信息：\\n\");     //printf(\"list=%3d\\n\",head);     printf(\"list=%p\\n\",head);     printf(\"list->Data=%3d\\n\",head->Data);     //printf(\"list->Next=%3d\\n\",head->Next);     printf(\"list->Next=%p\\n\",head->Next);      return head; }  PtrToNode createNode(int Data) {     PtrToNode Node = (PtrToNode)malloc(sizeof(struct Node));     if (!Node)         exit(0);     Node->Data = Data;     Node->Next = NULL;      return Node; }  void printList(List head) {     PtrToNode cursor = head->Next;     while(cursor) {         printf(\"结点信息：\\n\");         //printf(\"cursor=%3d\\n\",cursor);         printf(\"cursor=%p\\n\",cursor);         printf(\"cursor->Data=%3d\\n\",cursor->Data);         //printf(\"cursor->Next=%3d\\n\",cursor->Next);         printf(\"cursor->Next=%p\\n\",cursor->Next);         cursor = cursor->Next;         printf(\"\\n\");     } }  void insertNode(List head,int data) {     PtrToNode newNode = createNode(data);     newNode->Next = head->Next;     head->Next = newNode;      printf(\"insert ok!\\n\"); }  PtrToNode findNode(List head, int x) {     PtrToNode cursor = head->Next;      //while(cursor->Next!=NULL) {    //如果cursor为NULL，那么cursor->Next操作就会出现段错误     while(cursor){         if(x==cursor->Data) {             return cursor;         }else{             cursor = cursor->Next;         }     }      return NULL;    //注意返回NULL }  int delNode(List head,int x) {     PtrToNode cursor = head->Next;     PtrToNode cursorFront = head;       if (!cursor) {         printf(\"list is empty!\\n\");         return -1;     }      while (cursor) {         if (cursor->Data == x) {    //删除所有的等于x的节点             cursorFront->Next = cursor->Next;             free(cursor);             cursor = cursorFront->Next;             continue;         }          cursor = cursor->Next;         cursorFront = cursorFront->Next;     }     /*     if(cursor==NULL){         printf(\"list is empty!\\n\");     }else{         while(cursor->Data != x){             cursorFront = cursor;             cursor = cursorFront->Next;             if(cursor==NULL){                 printf(\"not found element,delete failed!\\n\");                 return 0;             }         }         cursorFront->Next = cursor->Next;         free(cursor);     }     */      return 0; }  int main() {     List list = createList();     PtrToNode node;      if (!list) {         printf(\"create failed!\\n\");         return -1;     }      //if(list){         printf(\"create ok!\\n\\n\");         for(int i=1;i<=5;i++){             insertNode(list, i*10);         }         //int x = (int)findNode(list, 40);         node = findNode(list, 40);         //printf(\"\\nquery ok！\\nlocation is:%3d\\n\\n\",x);         printf(\"\\nquery ok！\\nlocation is:%p\\n\\n\", node);         delNode(list, 20);         printList(list);     //}else{      //   printf(\"create failed!\\n\");     //}      system(\"pause\");     return 0; } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "newNode->Next = head->Next; 一般要先判断一下head是否为NULL，然后 head->Next=newNode; newNode->Next=NULL; head=newNode;", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "分析代码的基操，要用动态的发展的眼光看问题。 那个NULL是结束标记，后来insert的每个结点都是从那里复制来的结束标记，没有它就没有结束标记，当然不结束了。 至于你看见的输出信息，那是没有后续结点的那个时刻输出的。  很多人大学毕业了回头一看户口本上写着自己的文化程度小学，那就是因为户口本是小学时候办的，很正常。", "referer": "user-0"}]}
{"question": "pta第一个总是过不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼上说的对，对于后0的处理也很简单判断m是否大于1输出0就是。 不然就是使用数组最简单。 发现帖主未使用数组,可能是考虑节省空间,或练习不使用任何形式的数组包含递归,当然也是可以实现的,为此补充一下,以及使用数组时只要写一个循环语句即可:", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主你的代码如果遇到非零的但是末尾有零的输入就会很尴尬了。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "写的过于啰嗦简单点直接点:", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "修改如下，供参考：#include<stdio.h> int main(int argc, char* argv[]) {     long n,j,a,b;// i,     scanf(\"%d\",&n);     if(n==0) printf(\"%d\",n);     a=b=n;     j=1;     while(b>9){         b=b/10;         j *= 10;     }     for(;j>0;j/=10){        b = a/j;        a = n%j;        printf(\"%d \",b);     }      return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "#include <stdio.h>  void show_digit(long num);  int main(void) {      long n;      scanf(\"%ld\", &n);      show_digit(n);      return 0; }  void show_digit(long num) {     if (num == 0)         return;      show_digit(num / 10);     printf(\"%ld \", num % 10); } 供参考～", "referer": "user-0"}]}
{"question": "自动发邮件的脚本", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Linux系统，直接用mail发即可。 引用mail -s \"sendmail demo\" admin@csdn.net<file.txt 再弄个shell脚本，自由发挥即可。  windows有没有类似的批处理，不清楚。等楼下补充吧。。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Windows下安装vmware，再在vmware中安装Ubuntu，再在Ubuntu中使用mail", "referer": "user-0"}]}
{"question": "数据结构——算术表达式，程序运行结果有点问题，逻辑上不知道哪里写错了，比较急在线等！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "调试是程序员必会的技能。", "referer": "user-0"}]}
{"question": "求指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主说答案错了指的是？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "是这样的吗？  #include <iostream> #include <cmath>   double fsin(double x) { \treturn sin(x); }  double fcos(double x) { \treturn cos(x); }  double fexp(double x) { \treturn exp(x); }  double cum(int n,double a,double b,double ( *fncallback)(double)) { \tint i = 0; \tdouble dh = 0; \tdouble dm = 0; \tdouble ds = 0; \tdouble dx = 0;  \tdh = (fabs(a - b)) / n; \tdx = a;  \tfor(i = 0;i < n;i++) \t{ \t\tds = fncallback(dx) * dh + ds; \t\tdx += dh; \t}  \treturn ds; }  int main(int argc,char *argv[],char *envp[]) { \tint inum = 0;  \tdouble da1 = 0; \tdouble da2 = 0; \tdouble da3 = 0;  \tdouble db1 = 0; \tdouble db2 = 0; \tdouble db3 = 0;  \tprintf(\"input [n]: \"); \tscanf(\"%d\", &inum);  \tprintf(\"\\nto sin:\\ninput [a b]: \"); \tscanf(\"%lf %lf\",&da1,&db1); \tprintf(\"result: %f\\n\", cum(inum,da1,db1,fsin));  \tprintf(\"\\nto cos:\\ninput [a b]: \"); \tscanf(\"%lf %lf\",&da2,&db2); \tprintf(\"result: %f\\n\", cum(inum,da2,db2,fcos));  \tprintf(\"\\nto exponentiation:\\ninput [a b]: \"); \tscanf(\"%lf %lf\",&da3,&db3); \tprintf(\"result: %f\\n\", cum(inum,da3,db3,fexp));  \tflushall(); \tprintf(\"\\npress 'enter' key to quit.\\n\"); \tgetchar(); \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "另外还有13条警告，也一起吧。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "图片不清晰，看着也不连贯，为什么不直接贴源码呢？", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "'\\x64' == 6 × 16 + 4 = 100, 97+3 = 100 等价'a'+3='d'", "referer": "user-0"}]}
{"question": "不符合规范,各位大佬动动脑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 mswpp 的回复:其实我判断了的 你判断了，我没看到呢，贴源码吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "其实我判断了的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "fpWrite 用之前要有if(fpWrite!=NULL）的判断", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "问题发生在被你切掉的部分。  我怀疑你混用了高级低级两套IO造成出错。", "referer": "user-0"}]}
{"question": "有5个学生，每个学生的数据包括学号、姓名、三门课的成在此基础上编写求max函数，求平均成绩最高分的学生的数据，编写函数average求总平均分，并在主函数中调用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<string.h>  struct student{     char studid[12];     char name[12];     int sub1;     int sub2;     int sub3; }data[5];  int main() {     void input(struct student data[5]);     void print(struct student data[5]);     void max(struct student data[5]);     void average(struct student data[5]);     input(data);     printf(\"学号  姓名  科目一  科目二  科目三\\n\");     print(data);      max(data);     average(data);      return 0; }  void input(struct student data[]) {     int i;     printf(\"请输入相关的学生信息:\\n\");     for(i=0;i<5;i++){         scanf(\"%s\",data[i].studid);         scanf(\"%s\",data[i].name);         scanf(\"%d\",&data[i].sub1);         scanf(\"%d\",&data[i].sub2);         scanf(\"%d\",&data[i].sub3);     } } void print(struct student data[]) {     int i;      for(i=0;i<5;i++){         printf(\"%s %s %d %d %d\",data[i].name,data[i].studid,data[i].sub1,data[i].sub2,data[i].sub3);         printf(\"\\n\");     }  } void max(struct student data[]) {     int i=0, idx;     int a[5] = {0};     int max = 0;     max = a[0];     for(i=0;i<5;i++){         a[i]=(data[i].sub1+data[i].sub2+data[i].sub3)/3;         //if(strcmp(a[i],a[i+1])<0)         //if(a[i] < a[i+1])         if(max < a[i]) {             max = a[i];             idx = i;         }     }     printf(\"%d\\n\",max);     printf(\"%s %s %d % d %d\\n\",             data[idx].name, data[idx].studid,             data[idx].sub1, data[idx].sub2,             data[idx].sub3); }  void average(struct student data[]) {     int i=0;     int all=0;     //int a[5];     int average=0;     for(i=0;i<5;i++){         //a[i]=(data[i].sub1+data[i].sub2+data[i].sub3);         //all += a[i];         all +=(data[i].sub1+data[i].sub2+data[i].sub3);         //all += a[i];     }     average = all/5;     printf(\"%d\\n\", average); } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include<stdio.h>  struct student{ char   studid[12]; char   name[12]; int    sub1; int    sub2; int    sub3; }data[5];   int main(int argc, char* argv[]) {       void input(struct student data[5]);      void print(struct student data[5]);      void max(struct student data[5]);      void average(struct student data[5]);      input(data);      //printf(\"学号 姓名 科目一 科目二 科目三\\n\");      max(data);      average(data);       print(data);       return 0; }  void input(struct student data[]) {      int i;      printf(\"\\n请输入五个学生信息:\\n\");      printf(\"学号 姓名 科一 科二 科三\\n\");      for(i=0;i<5;i++){         scanf(\"%s\",data[i].studid);         scanf(\"%s\",data[i].name);         scanf(\"%d\",&data[i].sub1);         scanf(\"%d\",&data[i].sub2);         scanf(\"%d\",&data[i].sub3);      } }  void print(struct student data[]) {      int i;      printf(\"\\n学号 姓名 科目一 科目二 科目三\\n\");      for(i=0;i<5;i++){         printf(\" %s   %s   %d    %d    %d\",         data[i].studid,data[i].name,data[i].sub1,data[i].sub2,data[i].sub3);         printf(\"\\n\");      } }  void max(struct student data[]) {      int i,j;      int a[5]={0};      int max=0;            for(i=0;i<5;i++)          a[i]=(data[i].sub1+data[i].sub2+data[i].sub3)/3;            max=a[0];   //if(strcmp(a[i],a[i+1])<0)      for(i=0;i<5;i++)          if(max < a[i]){                max=a[i];                j=i;          }      printf(\"\\nmax:%s   %s   %d    %d    %d   maxavg=%d\\n\",      data[j].studid,data[j].name,data[j].sub1,data[j].sub2,data[j].sub3,max); }  void average(struct student data[]) {      int i=0;      int all=0;      int a[5]={0};      int average=0;      for(i=0;i<5;i++){          a[i]=(data[i].sub1+data[i].sub2+data[i].sub3)/3;          all+=a[i];      }      average=all/5;      printf(\"\\naverage=%d\\n\",average); }", "referer": "user-0"}]}
{"question": "C语言试题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "打印函数修改下：void print(int *p,int m,int n) {    for(int i=0;i<m;i++)       for(int j=0;j<n;j++)          printf(\"%d%c\",*(p+i*n+j),(j<n-1?' ':'\\n')); }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考：#include<stdio.h> #define M 2 #define N 4  void sort_mid(int *p,int m,int n);  void print(int *p,int m,int n);  int main(int argc,char* argv[]) {    int a[M][N]={1,3,5,7,2,4,6,8};     //调整前    //print(a[0],M,N);     sort_mid(a[0],M,N);     //调整后    print(a[0],M,N);     return 0; }  void sort_mid(int *p,int m,int n) {    int *a = new int [M*N];    int k=0,mid,t;    for(int i=0;i<m;i++)       for(int j=0;j<n;j++)          a[k++] = p[i*n+j];                                for(int i=0;i<k-1;i++){ //计算数组中位数       for(int j=0;j<k-i-1;j++){ \t\tif(a[j]>a[j+1]){                      t     = a[j];                      a[j]  = a[j+1];                      a[j+1]= t; \t\t}         }    }    if(k%2==0)         mid=(a[k/2]+a[k/2-1])/2;    else         mid=a[(k-1)/2];     for(int i=0;i<m;i++)//将数组中位数与数组第一元素交换位置       for(int j=0;j<n;j++)          if(mid == p[i*n+j]){             t        = p[i*n+j];             p[i*n+j] = p[0];             p[0]     = t ;          }    delete []a; }  void print(int *p,int m,int n) {    for(int i=0;i<m;i++)       for(int j=0;j<n;j++)          printf(\"%d%c\",*(p+i*4+j),(j<n-1?' ':'\\n')); }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "可参", "referer": "user-0"}]}
{"question": "开源社区", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://bbs.csdn.net/topics/394221449  乱查的", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "百度搜相关关键字。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "学习一哈转义字符么，很简单的。", "referer": "user-0"}]}
{"question": "谁能告诉我第三题问什么输出的是三，求大佬回答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为a > b > c为假，为啥为假，a > b为真，则结果为1 > c为假，1 > 3为假；执行else if。 c-1 >= d为真，则为1,1==1为真，因此打印printf，即d +1=3", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "a>b>c 计算a>b这部分的时候根据真假得到的结果是1或者0 接下来就是1>c或者0>c的计算  其他关系运算符连用的情况以此类推。", "referer": "user-0"}]}
{"question": "分块查找问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据表有一维、二维、三维 分块的方法有二叉树、四叉树、八叉树", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:2^X >= 4000 ?  好像不是，是下面说的这种查找，问题是根号下4000=63.xxxx，不知道是63还是64，之后每块应该多少个数据，63*64=4032  https://blog.csdn.net/drive_/article/details/83182654", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "2^X >= 4000 ?", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "匪夷所思的是，叫做del的函数貌似处理链表的居然没有调用free？", "referer": "user-0"}]}
{"question": "这个代码为什么不能生效啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主的代码修改如下，还是有问题：#include <stdio.h> char num[8];   //int num[8]; int main() {     int a;     int b;     int c;     printf(\"Are you sure?(Any number to continue)\");     while (scanf(\"%d\", &c)==1)       {         getchar();         printf(\"Enter num\\n\");         for (a = 0; a < 8; a++)//(a = 0; a == 7; a++)             {               num[a] = getchar();             }         for (b = 7; b >= 0; b--) //(b = 7; b == 0; b--)             {               printf(\"%c\", num[b]);             }         getchar();         printf(\"Are you sure?(Any number to continue)\");       }      return 0; } 需要逆序输出，2#楼代码修改如下：#include <stdio.h> char num[8];//int num[8];  int main() {     int a;     int b;     int c;     printf(\"Are you sure?(Any number to continue)\");     while (~scanf(\"%d\",&c))//while (scanf(\"%d\", &c)==1)       {          if(c < 1) break;          getchar();          a=0;          printf(\"Enter num:\\n\");           while((num[a] = getchar()) != '\\n' && a<8)a++;           num[a] = '\\0';           //printf(\"%s\\n\", num);          for (b = 7; b >= 0; b--)             {               printf(\"%c\", num[b]);             }          getchar();          printf(\"Are you sure?(Any number to continue)\");                 }      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "去搜下getchar()函数的用法。修改如下，供参考：#include <stdio.h>  char num[8];//int num[8];  int main() {     int a;     int b;     int c;     printf(\"Are you sure?(Any number to continue)\");     while (~scanf(\"%d\",&c))//while (scanf(\"%d\", &c)==1)       {          if(c < 1) break;          getchar();          a=0;          printf(\"Enter num:\\n\");          //for(a = 0; a == 7 ; a++);          //{          while((num[a] = getchar()) != '\\n' && a<8)a++;           num[a] = '\\0';           //}          //for (b = 7; b == 0; b--);          // {           printf(\"%s\\n\", num);//printf(\"%d\", num[b]);          // }          printf(\"Are you sure?(Any number to continue)\");          getchar();       }        return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "for行尾有多余的分号", "referer": "user-0"}]}
{"question": "a+=a-=a*=a;", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:如果能避免写这样的表达式，建议不写，实际程序开发中不建议写这样的表达式，给自己添加麻烦还为难别人（别人要看你的代码，看着头大） 我也不想，这考试考这题", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "我承认错误并作出检讨。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "https://blog.csdn.net/Minikinfish/article/details/107520644", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "关于C,C++表达式求值顺序 http://blog.csdn.net/fefe82/article/details/37833767，http://bbs.csdn.net/topics/370153775", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "运算符优先级别 https://blog.csdn.net/Minikinfish/article/details/107520644", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "如果能避免写这样的表达式，建议不写，实际程序开发中不建议写这样的表达式，给自己添加麻烦还为难别人（别人要看你的代码，看着头大）", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "C语言中 a+=a-=a*=a 是未定义行为", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "把赋值语句还原回来看看就知道了 a=(a+(a=(a-(a=a*5))))", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "从结果看，这个编译器的结果既不是固定取5也不是每次都用最新的值。出这种题的老师就是脑残。", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "它们作为赋值系的运算符，统一是倒数第二优先级，从右向左结合。", "referer": "user-0"}]}
{"question": "C语言课程设计学生管理系统实验报告求", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 1 楼 lserious 的回复:有么有人帮帮忙 这个作业不小呢，需求比较明确。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://blog.csdn.net/user-2/article/details/38044239", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "有么有人帮帮忙", "referer": "user-0"}]}
{"question": "为什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 Infinity G 的回复:[quote=引用 1 楼 自信男孩的回复:]因为h=0不满足执行条件，循环一次也没执行。  h=0即假，假循环不执行，把h=1试试～ 真的诶，那平时用for循环的时候，比如啊 for（i=0；；i++） 这个如果换成int型为什么就可了呢 [/quote] 因为中间的表达式为空，即等价while (1)了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你撞电线杆子是因为你忘了戴眼镜，不是因为你穿了红衬衫。  循环行为的区别在于循环控制条件不同，不是因为数据类型。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:因为h=0不满足执行条件，循环一次也没执行。  h=0即假，假循环不执行，把h=1试试～ 真的诶，那平时用for循环的时候，比如啊 for（i=0；；i++） 这个如果换成int型为什么就可了呢", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "因为h=0不满足执行条件，循环一次也没执行。  h=0即假，假循环不执行，把h=1试试～", "referer": "user-0"}]}
{"question": "学生管理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://blog.csdn.net/user-1/article/details/38044239", "referer": "user-0"}]}
{"question": "sizeof", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 user-5的回复:还不给我分？我擦.... ‘w’是字符常量，' w'是多字符常量，注意你的那个sizeof(' w')单引号里第一个是空格，第二个是w，也就是说你的sizeof里的不是字符常量，而是多字符常量，多字符常量会被转成int类型，详见#2楼我的回复 维基百科:Multi-character constants (e.g. 'xy') are valid, although rarely useful — they let one store several characters in an integer (e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a 64-bit one). Since the order in which the characters are packed into one int is not specified, portable use of multi-character constants is difficult.  如果我说得能让你明白，请给我分.... 我不知道咋给分啊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "IDE中，鼠标右键点不明白的符号 size_of，在弹出的菜单中选转到定义。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "多字符常量，和trigraph一样，属于标准里面为了面子而保留，而时至今日已经没啥用，多数编译器默认舍弃（有些额外打开开关可以用）的东西。  历史的车辙尽管有时提供经验教训，但这道辙更多的效果是扭了脚。  让我们逐渐淡忘它（们）吧，阿门。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 3 楼 Infinity G 的回复:[quote=引用 1 楼 自信男孩的回复:]'w'是int类型，类型隐式提升了。你可以看一下getchar()函数原型的返回值类型都是int类型。 那么现在的’w’相当于是ASCII码是吗[/quote] 恩，'w'是ASCII", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 5 楼 user-5 的回复:还不给我分？我擦.... ‘w’是字符常量，' w'是多字符常量，注意你的那个sizeof(' w')单引号里第一个是空格，第二个是w，也就是说你的sizeof里的不是字符常量，而是多字符常量，多字符常量会被转成int类型，详见#2楼我的回复 维基百科:Multi-character constants (e.g. 'xy') are valid, although rarely useful — they let one store several characters in an integer (e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a 64-bit one). Since the order in which the characters are packed into one int is not specified, portable use of multi-character constants is difficult.  如果我说得能让你明白，请给我分....  楼主的问题是搞了个全角（或者其他，反正有点胖）单引号，他没有探讨多字符常量的意图。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "int size = strlen(' w'); 此时编译器报错，报错信息为 无法将参数 1 从“int”转换为“const char *” 说明此时编译器将' w'看成了int。 对于strlen和sizeof的区别，请参考《C++中strlen与sizeof处理字符数组和字符指针》，希望能够帮到您！", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "还不给我分？我擦.... ‘w’是字符常量，' w'是多字符常量，注意你的那个sizeof(' w')单引号里第一个是空格，第二个是w，也就是说你的sizeof里的不是字符常量，而是多字符常量，多字符常量会被转成int类型，详见#2楼我的回复 维基百科:Multi-character constants (e.g. 'xy') are valid, although rarely useful — they let one store several characters in an integer (e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a 64-bit one). Since the order in which the characters are packed into one int is not specified, portable use of multi-character constants is difficult.  如果我说得能让你明白，请给我分....", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "引用 13 楼 Infinity G 的回复:[quote=引用 12 楼 user-5的回复:][quote=引用 11 楼 Infinity G 的回复:][quote=引用 5 楼 user-5的回复:]还不给我分？我擦.... ‘w’是字符常量，' w'是多字符常量，注意你的那个sizeof(' w')单引号里第一个是空格，第二个是w，也就是说你的sizeof里的不是字符常量，而是多字符常量，多字符常量会被转成int类型，详见#2楼我的回复 维基百科:Multi-character constants (e.g. 'xy') are valid, although rarely useful — they let one store several characters in an integer (e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a 64-bit one). Since the order in which the characters are packed into one int is not specified, portable use of multi-character constants is difficult.  如果我说得能让你明白，请给我分.... 我不知道咋给分啊[/quote] 好吧...年轻人你不讲武德...耗子尾汁[/quote] 我最近才在这个软件上发帖的，我不太会。。[/quote] 没事儿...  会的话给大家结一下   不会就算了", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 12 楼 user-5的回复:[quote=引用 11 楼 Infinity G 的回复:][quote=引用 5 楼 user-5的回复:]还不给我分？我擦.... ‘w’是字符常量，' w'是多字符常量，注意你的那个sizeof(' w')单引号里第一个是空格，第二个是w，也就是说你的sizeof里的不是字符常量，而是多字符常量，多字符常量会被转成int类型，详见#2楼我的回复 维基百科:Multi-character constants (e.g. 'xy') are valid, although rarely useful — they let one store several characters in an integer (e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a 64-bit one). Since the order in which the characters are packed into one int is not specified, portable use of multi-character constants is difficult.  如果我说得能让你明白，请给我分.... 我不知道咋给分啊[/quote] 好吧...年轻人你不讲武德...耗子尾汁[/quote] 我最近才在这个软件上发帖的，我不太会。。", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "引用 11 楼 Infinity G 的回复:[quote=引用 5 楼 user-5的回复:]还不给我分？我擦.... ‘w’是字符常量，' w'是多字符常量，注意你的那个sizeof(' w')单引号里第一个是空格，第二个是w，也就是说你的sizeof里的不是字符常量，而是多字符常量，多字符常量会被转成int类型，详见#2楼我的回复 维基百科:Multi-character constants (e.g. 'xy') are valid, although rarely useful — they let one store several characters in an integer (e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a 64-bit one). Since the order in which the characters are packed into one int is not specified, portable use of multi-character constants is difficult.  如果我说得能让你明白，请给我分.... 我不知道咋给分啊[/quote] 好吧...年轻人你不讲武德...耗子尾汁", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "你的引号急需减肥，否则误导性太大。  'w'什么时候都相当于ASCII码。郭靖他妈妈一直叫李萍，不分场合。  C语言而不是C++，历史上一直都说字符常量（注意我没有说型）是int型的，有好多理由但是这里空间比较窄，写不下。 让我们记住这一点即可。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:'w'是int类型，类型隐式提升了。你可以看一下getchar()函数原型的返回值类型都是int类型。 那么现在的’w’相当于是ASCII码是吗", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "std::cout << typeid(' w').name() << std::endl; std::cout << typeid('w').name() << std::endl; 运行结果：", "referer": "user-0"}, {"cid": "14", "user": "user-3", "content": "'w'是int类型，类型隐式提升了。你可以看一下getchar()函数原型的返回值类型都是int类型。", "referer": "user-0"}]}
{"question": "帮帮孩子吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "当处理最后一个节点时,m为最后一个节点  p=m也是最后一个节点 但是下面的循环里， p=p->next p此时为Null了 下面去访问p->next就错了", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1.遍历链表的条件一般是 m!=NULL，下面的p也是一样。 2.删除结点的那个循环语句里写的不对 2.删除结点一般都有个释放删除的结点的内存空间的语句，free()", "referer": "user-0"}]}
{"question": "for循环语句中那个（）里面为什么只有一个；？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼上赵4老师说的比较经典，for语句中的三个表达式（初始化表达式；条件表达式；循环表达式 ）是可以被省略的，括号里的两个分号是不可以被省略的，否则编译器会认为有语法错误。学习了~(^.^)~", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "The C for Statement The for statement lets you repeat a statement or compound statement a specified number of times. The body of a for statement is executed zero or more times until an optional condition becomes false. You can use optional expressions within the for statement to initialize and change values during the for statement’s execution.    Syntax  iteration-statement :  for ( init-expression opt ; cond-expression opt ; loop-expression opt ) statement   Execution of a for statement proceeds as follows:   The init-expression, if any, is evaluated. This specifies the initialization for the loop. There is no restriction on the type of init-expression.   The cond-expression, if any, is evaluated. This expression must have arithmetic or pointer type. It is evaluated before each iteration. Three results are possible: If cond-expression is true (nonzero), statement is executed; then loop-expression, if any, is evaluated. The loop-expression is evaluated after each iteration. There is no restriction on its type. Side effects will execute in order. The process then begins again with the evaluation of cond-expression.   If cond-expression is omitted, cond-expression is considered true, and execution proceeds exactly as described in the previous paragraph. A for statement without a cond-expression argument terminates only when a break or return statement within the statement body is executed, or when a goto (to a labeled statement outside the for statement body) is executed.   If cond-expression is false (0), execution of the for statement terminates and control passes to the next statement in the program.  A for statement also terminates when a break, goto, or return statement within the statement body is executed. A continue statement in a for loop causes loop-expression to be evaluated. When a break statement is executed inside a for loop, loop-expression is not evaluated or executed. This statement  for( ;; );  is the customary way to produce an infinite loop which can only be exited with a break, goto, or return statement.   This example illustrates the for statement:   for ( i = space = tab = 0; i < MAX; i++ )  {     if ( line[i] == ' ' )         space++;     if ( line[i] == '\\t' )      {         tab++;         line[i] = ' ';     } }  This example counts space (' ') and tab ('\\t') characters in the array of characters named line and replaces each tab character with a space. First i, space, and tab are initialized to 0. Then i is compared with the constant MAX; if i is less than MAX, the statement body is executed. Depending on the value of line[i], the body of one or neither of the if statements is executed. Then i is incremented and tested against MAX; the statement body is executed repeatedly as long as i is less than MAX.", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "for循环的3个表达式可以写0-3个，也就是说，3个表达式都可以省略，如果全部省略，相当于while(true)的效果", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不是有两个吗？怎么是一个呢？ for(;*sp!='\\0';sp++){ 你的代码，你再数一下几个;分号", "referer": "user-0"}]}
{"question": "c语言 的函数问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "http://c.biancheng.net/view/498.html。一起学习？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "Finding prime numbers - Kenneth Haugland  Different schemas for finding prime numbers explained with code http://www.codeproject.com/Articles/429694/Finding-prime-numbers", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "去我博客找素数表", "referer": "user-0"}]}
{"question": "萌新求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "成功了，感谢指点", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "r和h没毛病，把v定义成float或者double类型试试？", "referer": "user-0"}]}
{"question": "问一个 指向函数的指针 问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢大佬，明白了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你反汇编一下会看到，你的图上f的那个地址是函数f内部开头的地址， 而图上的p实际上也就是你的程序输出，那里是一个函数调用列表的表项，只有一条跳转指令，跳转到上述实际函数地址去。  某种意义上这就是封装这个词的的表现形式之一。", "referer": "user-0"}]}
{"question": "用c语言编写一门学生信息管理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看本网页下面红色字体对应的多个链接。", "referer": "user-0"}]}
{"question": "【C语言】内部编译器错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "那我建议把你的代码复制到正常的helloworld的项目的编辑界面覆盖那个短短的代码，再编译试试。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "hello world倒是可以成功运行......  那这种情况一般是哪里有问题呢？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "这种错误不是代码引起的，是硬件、系统、VS安装或项目配置问题。 建议以同样环境写个helloworld来确认环境正确性。", "referer": "user-0"}]}
{"question": "数据结构——二叉排序树的创建查找插入，程序在创建树过程不运行，求帮忙看看代码哪里有问题！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  #pragma warning( disable:4996)  typedef struct BSTNode { \tint data; \tBSTNode *lchild, *rchild; };    void InsertBST(BSTNode **T, int e) //插入  { \tbool x = false; \tif (!(*T)) \t{ \t\t*T = (BSTNode*)malloc(sizeof(BSTNode)); \t\t(*T)->data = e; \t\t(*T)->lchild = NULL; \t\t(*T)->rchild = NULL; \t\tx = true; \t} \tif ((*T)->data == e) \t{ \t\tif (x == true) \t\t\tprintf(\"%d插入成功\\n\",e); \t\telse \t\t\tprintf(\"插入值重复\\n\"); \t} \telse if ((*T)->data > e) \t\tInsertBST(&((*T)->lchild), e); \t \telse \t\tInsertBST(&((*T)->rchild), e);  }  BSTNode* CreatBST(BSTNode *T, int num[], int n) //创建  { \tT= (BSTNode*)malloc(sizeof(BSTNode)); \tT->data = num[0]; \tT->lchild = NULL; \tT->rchild = NULL; \tfor (int i = 1; i < n; i++) \t{ \t\tInsertBST(&T, num[i]);  //创建过程即插入结点过程 \t} \treturn T; }  void SearchBST(BSTNode *T, int key) //递归查找  { \tBSTNode *p = T; \tif (p) \t{ \t\tif (key == p->data) \t\t{ \t\t\tprintf(\"查找成功！\\n\"); \t\t} \t\telse if (key < p->data&&p->lchild) \t\t\tSearchBST(p->lchild, key); \t\telse if (key > p->data&&p->rchild) \t\t\tSearchBST(p->rchild, key); \t\telse printf(\"关键字不存在！\\n\"); \t} } int main() { \tBSTNode *T = NULL; \tint num[50], a=0, i = 0, j, key; \tprintf(\"下面请按要求输入创建二叉排序树\\n\"); \tdo { \t\tprintf(\"请输入一个数字（-1退出循环）：\\n\"); \t\tscanf(\"%d\", &num[i]); \t\ta = num[i]; \t\ti++; \t} while (a != (-1)); \tT = CreatBST(T, num, i-1);  \t \tprintf(\"请输入插入数字：\\n\"); //插入  \tscanf(\"%d\", &a); \tInsertBST(&T, a); \t \t \tprintf(\"请输入查找关键数字：\\n\"); //查找  \tscanf(\"%d\", &key); \tSearchBST(T, key); \treturn 0; }  做了一些改动，总体上没太大变化", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 我当时害怕极了QAQ的回复:感觉你写的很奇怪，应该是指针的问题  具体代码没看，对指针做了一些改动  仅供参考  #include <stdio.h> #include <stdlib.h>  #pragma warning( disable:4996) #define OK 1 #define False -1 typedef struct BSTNode { \tint data; \tstruct BSTNode *lchild, *rchild; };  int InsertBST(BSTNode *T, int e) //插入  { \tif (T == NULL) return False; \tBSTNode *p = NULL, *q = NULL; \tq = T; \tp = (BSTNode*)malloc(sizeof(BSTNode)); \t(p)->data = e; \t(p)->lchild = (p)->rchild = NULL; \tif (e == (q)->data) return 0; \tif (e < (q)->data) InsertBST(q->lchild, e); \tif (e > (q)->data) InsertBST(q->rchild, e); \treturn OK; }  int CreatBST(BSTNode *T, int num[], int n) //创建  { \tint i = 1; \t(T) = (BSTNode*)malloc(sizeof(BSTNode)); \t(T)->data = num[i]; \t(T)->lchild = (T)->rchild = NULL; \tfor (i = 2; i <= n; i++) \t\tInsertBST(T, num[i]);  //创建过程即插入结点过程  \treturn OK; }  int SearchBST(BSTNode *T, int key) //递归查找  { \tBSTNode *p = T; \tif (p) \t{ \t\tif (key == p->data) \t\t{ \t\t\tprintf(\"查找成功！\\n\"); \t\t\treturn OK; \t\t} \t\telse if (key < p->data&&p->lchild) \t\t\tSearchBST(p->lchild, key); \t\telse if (key > p->data&&p->rchild) \t\t\tSearchBST(p->rchild, key); \t\telse printf(\"关键字不存在！\\n\"); \t} } int main() { \tBSTNode T; \tint num[50], n = 0, a, i = 1, j, key; \tprintf(\"下面请按要求输入创建二叉排序树\\n\"); \tdo { \t\tprintf(\"请输入一个数字（-1退出循环）：\\n\"); \t\tscanf(\"%d\", &num[i]); \t\ta = num[i]; \t\ti++; \t\tn++; \t} while (a != (-1)); \tn--; \tif (CreatBST(&T, num, n)); printf(\"创建成功！\\n\"); //创建   \tprintf(\"请输入插入数字：\\n\"); //插入  \tscanf(\"%d\", &a); \tj = InsertBST(&T, a); \tif (j == 1) printf(\"\\n插入成功！\\n\"); \telse if (j == 0) printf(\"数据已存在！无需插入！\\n\"); \telse printf(\"树空！插入失败！\\n\");  \tprintf(\"请输入查找关键数字：\\n\"); //查找  \tscanf(\"%d\", &key); \tSearchBST(&T, key);  } 我用的是二级指针，用了您改的指针，现在创建树成功了，但是查找关键字函数有点bug，存在的关键字查找不出来，你能再帮我看看代码吗？非常感谢！！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "InsertBST的时候，p和q没有建立联系。 改成：    if (e < (q)->data) {           q->lchild=p;           InsertBST(p, e);    }     if (e > (q)->data) {        q->rchild=p;         InsertBST(p, e);    }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "感觉你写的很奇怪，应该是指针的问题  具体代码没看，对指针做了一些改动  仅供参考  #include <stdio.h> #include <stdlib.h>  #pragma warning( disable:4996) #define OK 1 #define False -1 typedef struct BSTNode { \tint data; \tstruct BSTNode *lchild, *rchild; };  int InsertBST(BSTNode *T, int e) //插入  { \tif (T == NULL) return False; \tBSTNode *p = NULL, *q = NULL; \tq = T; \tp = (BSTNode*)malloc(sizeof(BSTNode)); \t(p)->data = e; \t(p)->lchild = (p)->rchild = NULL; \tif (e == (q)->data) return 0; \tif (e < (q)->data) InsertBST(q->lchild, e); \tif (e > (q)->data) InsertBST(q->rchild, e); \treturn OK; }  int CreatBST(BSTNode *T, int num[], int n) //创建  { \tint i = 1; \t(T) = (BSTNode*)malloc(sizeof(BSTNode)); \t(T)->data = num[i]; \t(T)->lchild = (T)->rchild = NULL; \tfor (i = 2; i <= n; i++) \t\tInsertBST(T, num[i]);  //创建过程即插入结点过程  \treturn OK; }  int SearchBST(BSTNode *T, int key) //递归查找  { \tBSTNode *p = T; \tif (p) \t{ \t\tif (key == p->data) \t\t{ \t\t\tprintf(\"查找成功！\\n\"); \t\t\treturn OK; \t\t} \t\telse if (key < p->data&&p->lchild) \t\t\tSearchBST(p->lchild, key); \t\telse if (key > p->data&&p->rchild) \t\t\tSearchBST(p->rchild, key); \t\telse printf(\"关键字不存在！\\n\"); \t} } int main() { \tBSTNode T; \tint num[50], n = 0, a, i = 1, j, key; \tprintf(\"下面请按要求输入创建二叉排序树\\n\"); \tdo { \t\tprintf(\"请输入一个数字（-1退出循环）：\\n\"); \t\tscanf(\"%d\", &num[i]); \t\ta = num[i]; \t\ti++; \t\tn++; \t} while (a != (-1)); \tn--; \tif (CreatBST(&T, num, n)); printf(\"创建成功！\\n\"); //创建   \tprintf(\"请输入插入数字：\\n\"); //插入  \tscanf(\"%d\", &a); \tj = InsertBST(&T, a); \tif (j == 1) printf(\"\\n插入成功！\\n\"); \telse if (j == 0) printf(\"数据已存在！无需插入！\\n\"); \telse printf(\"树空！插入失败！\\n\");  \tprintf(\"请输入查找关键数字：\\n\"); //查找  \tscanf(\"%d\", &key); \tSearchBST(&T, key);  }", "referer": "user-0"}]}
{"question": "大一小白怎么进阶，学c", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-2的回复:1  系统学习各种算法 2  多读题  分析 这种题 是什么类型 3  多写  一种类型 的解题思路多写几次 可以，明白了😊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633 A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "1  系统学习各种算法 2  多读题  分析 这种题 是什么类型 3  多写  一种类型 的解题思路多写几次", "referer": "user-0"}]}
{"question": "求大佬看看这个怎么做", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h>  int game(int *p, int n, int m) { \tint i, c, t; \tc = t = 0; \tfor(i = 0; i < n; i++) p[i] = i + 1; \t \ti = 0; \twhile(t < n-1) \t{ \t\tif(p[i]) c++; \t\tif(c == m) \t\t{ \t\t\tp[i] = 0; \t\t\tt++; \t\t\tc = 0; \t\t} \t\ti = (i + 1) % n; \t} \t \tfor(i = 0; i < n; i++) \t{ \t\tif(p[i]) break; \t} \t \treturn p[i]; }   int main(void) { \tint n; \tint arr[100];  \tfor(n = 2; n <= 100; n++) \t{ \t\tif(game(arr, n, 5) == game(arr, n, 8)) \t\t{ \t\t\tprintf(\"Monkey Count:\\t%d\\t\", n); \t\t\tprintf(\"Winner ID:\\t%d\\n\", game(arr, n, 5)); \t\t} \t} \treturn 0; }", "referer": "user-0"}]}
{"question": "大佬知道这个用c语言怎么写吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//为什么printf（“”%c“”,a[i].data）输出不了 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX_SIZE 1024 typedef struct {     char data;     int weight;     int parent;     int lchild;     int rchild; } Huffnode,*Hufftree; typedef struct stack {     int top;     int elem[MAX_SIZE]; } Stack; void Initstack(Stack *s) {     s->top=-1; } void push(Stack *s,int e) {     s->top++;     s->elem[s->top]=e; } int pop(Stack *s) {     return s->elem[s->top--]; } bool isempty(Stack *s) {     if(s->top==-1)         return true;     else         return false; } void GetHuffmamCode(Hufftree a,int n) {     int i,j,s1,s2,max,c,p;     Stack s;     char ch;     Initstack(&s);     printf(\"输入字符集：\");fflush(stdout);     rewind(stdin);     for(i=1;i<=n;i++) {         scanf(\"%c\",&a[i].data);     }     for(i=1;i<=n;i++) {         printf(\"a[%d].data:%c\\n\",i,a[i].data);     }     printf(\"\\n\");     printf(\"输入权值：\");fflush(stdout);     rewind(stdin);     for(i=1;i<=n;i++) {         scanf(\"%d\",&a[i].weight);     }     for(i=1;i<=n;i++) {         printf(\"a[%d].weight:%d\\n\",i,a[i].weight);     }     printf(\"\\n\");     int m=2*n-1;     for(i=1;i<=n;i++) {         a[i].parent=0;         a[i].rchild=0;         a[i].lchild=0;     }     for(i=n+1;i<=m;i++) {         a[i].data=NULL;         a[i].weight=0;         a[i].parent=0;         a[i].lchild=0;         a[i].rchild=0;     }     for(i=n+1;i<=m;i++) {         max=65535;         for(j=1;j<=i-1;j++) {             if(a[j].parent==0&&a[j].weight<=max) {                 s1=j;                 max=a[j].weight;             }         }         a[s1].parent=i;         max=65535;         for(j=1;j<=i-1;j++) {             if(a[j].parent==0&&a[j].weight<=max) {                 s2=j;                 max=a[j].weight;             }         }         a[s2].parent=i;         a[i].weight=a[s1].weight+a[s2].weight;         a[i].lchild=s1;         a[i].rchild=s2;     }     for(i=1;i<=n;i++) {         c=i;         p=a[i].parent;         while(p!=0) {             if(a[p].lchild==c)                 push(&s,0);             else                 push(&s,1);             c=p;             p=a[p].parent;         }         printf(\"i:%d\\n\",i);         printf(\"%c\\n\",a[i].data);         while(!isempty(&s))             printf(\"%d\",pop(&s));         printf(\"\\n\");     } } int main() {     Hufftree a;     int n;     int m;     printf(\"输入字符个数：\");     scanf(\"%d\",&n); //  m=2*n-1;     m=3*n;     a=(Hufftree)malloc(sizeof(Huffnode)*m);     GetHuffmamCode(a,n);     return 0; } //输入字符个数：3 //输入字符集：abc //a[1].data:a //a[2].data:b //a[3].data:c // //输入权值：10 20 30 //a[1].weight:10 //a[2].weight:20 //a[3].weight:30 // //i:1 //a //00 //i:2 //b //01 //i:3 //c //1 //", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:仅供参考：#include <stdio.h> #include <stdlib.h> #include <conio.h> unsigned int iv,i; unsigned char BCD[5];//定长10位BCD码 unsigned char sv[11]; void main() {     iv=123456789;//最大10位无符号正整数     //INT2BCD     sprintf(sv,\"%010u\",iv);     for (i=0;i<10;i+=2) {         BCD[i/2]=(sv[i]<<4)|(sv[i+1]&0x0F);     }     printf(\"BCD=%02x%02x%02x%02x%02x\\n\",BCD[0],BCD[1],BCD[2],BCD[3],BCD[4]);     //BCD2INT     for (i=0;i<10;i+=2) {         sv[i]='0'|(BCD[i/2]>>4);         sv[i+1]='0'|(BCD[i/2]&0x0F);     }     sscanf(sv,\"%010u\",&iv);     printf(\"iv=%010u\\n\",iv);     getch(); }  可以请你帮我看看为什么printf（“”%c“”,a[i].data）输出不了吗 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX_SIZE 1024 typedef struct{ char data; int weight; int parent; int lchild; int rchild; }Huffnode,*Hufftree; typedef struct stack{ int top; int elem[MAX_SIZE]; }Stack; void Initstack(Stack *s) { s->top=-1; } void push(Stack *s,int e) { s->top++; s->elem[s->top]=e; } int pop(Stack *s) { return s->elem[s->top--]; } bool isempty(Stack *s) { if(s->top==-1) return true; else return false; } void GetHuffmamCode(Hufftree a,int n) { int i,j,s1,s2,max,c,p; Stack s; char ch; Initstack(&s); printf(\"输入字符集：\"); for(i=1;i<=n;i++) { scanf(\"%c\",&a[i].data); scanf(\"%c\",&ch); } printf(\"输入权值：\"); for(i=1;i<=n;i++) { scanf(\"%d\",&a[i].weight); scanf(\"%c\",&ch); } int m=2*n-1; for(i=1;i<=n;i++) { a[i].parent=0; a[i].rchild=0; a[i].lchild=0; } for(i=n+1;i<=m;i++) { a[i].data=NULL; a[i].weight=0; a[i].parent=0; a[i].lchild=0; a[i].rchild=0; } for(i=n+1;i<=m;i++) { max=65535; for(j=1;j<=i-1;j++) { if(a[j].parent==0&&a[j].weight<=max) { s1=j; max=a[j].weight; } } a[s1].parent=i; max=65535; for(j=1;j<=i-1;j++) { if(a[j].parent==0&&a[j].weight<=max) { s2=j; max=a[j].weight; } } a[s2].parent=i; a[i].weight=a[s1].weight+a[s2].weight; a[i].lchild=s1; a[i].rchild=s2; } for(i=1;i<=n;i++) { c=i; p=a[i].parent; while(p!=0) { if(a[p].lchild==c) push(&s,0); else push(&s,1); c=p; p=a[p].parent; } printf(\"%c\\n\",a[i].data); while(!isempty(&s)) printf(\"%d\",pop(&s)); printf(\"\\n\"); } } int main() { Hufftree a; int n; int m; printf(\"输入字符个数：\"); scanf(\"%d\",&n); m=2*n-1; a=(Hufftree)malloc(sizeof(Huffnode)*m); GetHuffmamCode(a,n); return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "仅供参考：#include <stdio.h> #include <stdlib.h> #include <conio.h> unsigned int iv,i; unsigned char BCD[5];//定长10位BCD码 unsigned char sv[11]; void main() {     iv=123456789;//最大10位无符号正整数     //INT2BCD     sprintf(sv,\"%010u\",iv);     for (i=0;i<10;i+=2) {         BCD[i/2]=(sv[i]<<4)|(sv[i+1]&0x0F);     }     printf(\"BCD=%02x%02x%02x%02x%02x\\n\",BCD[0],BCD[1],BCD[2],BCD[3],BCD[4]);     //BCD2INT     for (i=0;i<10;i+=2) {         sv[i]='0'|(BCD[i/2]>>4);         sv[i+1]='0'|(BCD[i/2]&0x0F);     }     sscanf(sv,\"%010u\",&iv);     printf(\"iv=%010u\\n\",iv);     getch(); }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "先确定大小端。接下来就是指针操作。。", "referer": "user-0"}]}
{"question": "菜鸟求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢各位的指教", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "小数位，是1位还是0位", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "精度（.precision） 精度格式符以“.”开头，后跟十进制整数。 (1)对于整型（d,i,o,u,x,X）,precision表示输出的最小的数字个数，不足补前导零，超过不截断。 (2)对于浮点型（a, A, e, E, f ），precision表示小数点后数值位数，默认为六位，不足补后置0，超过则截断。 (3)对于类型说明符g或G，表示可输出的最大有效数字。 (4)对于字符串（s），precision表示最大可输出字符数，不足正常输出，超过则截断。 precision不显示指定，则默认为0。  1、printf(\"%.8d\\n\",1000);//不足指定宽度补前导0，效果等同于%08d      输出：00001000 2、printf(\"%.8f\\n\",1000.123456789);//超过精度，截断      输出：1000.12345679 3、printf(\"%.8f\\n\",1000.123456);\t//不足精度，补后置0      1000.12345600", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "懂了,受教了!", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "http://c.biancheng.net/view/1793.html", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "只看到%lf与%f的区别,%.1f和%.0f的意思还是不清楚,求教!", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "任何一本教材讲格式输出的章节都会说明这个。", "referer": "user-0"}]}
{"question": "有大佬能逐行解释一下代码吗？完全看不懂呜呜", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 qzjhjxj的回复:a[i]表示二维数组每行首地址 嗯知道了谢谢！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "a[i]表示二维数组每行首地址", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "请问一下，针对这个代码，对于二维数组a[i][j]，输出a[i]的意思就是输出这个二维数组的这一行吗？就是说二维数组可以写成一维数组？？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "非常感谢哦！", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "#include<stdio.h> #include<string.h> int main(int argc, char* argv[]) {     char s[100],a[10][10],b[10];     int i,j,k,len,flag;      gets(s);                //输入一字符串：good morning teacther     len=strlen(s);          //取得字符串的长度值      j=0;k=0;flag=0;         //初始化     for(i=0;i<len+1;i++)   //注意i<len+1        if(s[i]>='a'&&s[i]<='z'||s[i]>='A'&&s[i]<='Z')//判断是否是字母，是就是单词，一个一个字符去判断           {             a[k][j]=s[i];        //把每个单词的每个字符记录到a[0][1]...a[0][10],一个单词一行.             j++;                 //good     a[0][0-10]             flag=1;              //morning  a[1][0-10]           }                      //teacther a[2][0-10]        else if(flag==0) //如果不是字母，判断是否是单词的头部                   continue;             else            //否则就是尾部                 {                    a[k][j]='\\0'; //每个单词的结束符                    k++;          //进入下一个单词准备                    j=0;          //a[k][0]                    flag=0;       //标志复位                 }     /*上面这段代码执行完，数组a中的结果：a[10][10]={\"good\\0\",                                                     \"morning\\0\",                                                     \"teacther\\0\"                                                                 }     */      for(i=0;i<k;i++) //输出字符串中的单词，一个单词一行         puts(a[i]);  //a[0][0]..... good                      //a[1][0]      morning                      //a[2][0]      teacther      strcpy(b,a[0]); //把a[0]数组中第一个单词拷贝到数组b中，作为比较单词长度的初始值     for(i=1;i<k;i++)         if(strlen(a[i])>strlen(b))//与数组a中其他单词比较长度            strcpy(b,a[i]); // 找到最长单词，放入b数组中      puts(b); //输出最长的单词   teacther      return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "你知道这是什么语言，你知道啥是头文件，你知道哪个是主函数，你知道哪个是数组，甚至你都知道数组有多大。 瞧，你不是“完全”看不懂，你已经懂好多了。 说谎的不是好孩纸。  所以， 要么你说清楚具体哪里不懂； 要么你回去看那些能看懂的，然后合起书，靠自己把那些看懂了的用自己的方式写出来，调试运行到满意。然后再回来看这个。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "不是引文字母， 是英文字母", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "#include<stdio.h> #include<string.h> void main() { char s[100],a[10][10],b[10]; int i,j,k,len,flag; gets(s);//输入字符串 len=strlen(s); //取字符串长度 j=0;k=0;flag=0; for(i=0;i<len+1;i++)   //逐个字符处理输入字符串 if(s[i]>='a'&&s[i]<='z'||s[i]>='A'&&s[i]<='Z') //凡是引文字母，即认为此字符为单词一部分 { a[k][j]=s[i];   //单词的字符逐个存入二维数组a, 一共10个单词，每单词长不超过10个字符， 所以a[10][10] j++; flag=1;    //不是单词结尾 } else if(flag==0) //继续取下一个单词 continue; else  //一个单词结束保存 { a[k][j]='\\0';  k++; j=0; flag=0;   } for(i=0;i<k;i++) puts(a[i]);   //输出得到的每个单词  strcpy(b,a[0]);//求最长单词 for(i=1;i<k;i++) //遍历每个单词 if(strlen(a[i])>strlen(b))  //每个单词和b里保存单词比较长度 strcpy(b,a[i]); //如果比b里单词长， 取代b里单词 puts(b);  //输出最长单词 }", "referer": "user-0"}]}
{"question": "我怎么把串口接到的数据， 2个字节16位二进制数（有符号）的直接转化成十进制数值显示出来，主要这个部分不会写，不知道怎么写。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "像楼主你自己写的那样先调整字节序，然后在调过序的数组上像二楼那样强转即可。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "像楼主你自己写的那样先调整字节序，然后在调过序的数组上像二楼那样强转即可。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "从你的示例数据看，负数是用补码表示的，所以没问题。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "to movsd  ,请问你这个  正负 都是可以的是吧", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "它这个就是定点小数格式，固定7位小数的浮点数放大128倍转化为16位整数存储", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "printf(\"%f\\n\",*(short *)(buf)/128.0f);", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "union FIXVALUE { \tstruct \t{ \t\tuint8_t lowPart; \t\tuint8_t highPart; \t}; \tshort value; };  union FIXVALUE fv; fv.lowPart=buf[0]; fv.highPart=buf[1]; printf(\"%f\\n\",fv.value/128.0f);", "referer": "user-0"}]}
{"question": "蓝桥杯 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "好的好的 十分感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "没有库，直接去官网下载一个就行。keil5只是IDE，都不带库的。", "referer": "user-0"}]}
{"question": "这个题目不会做，大家能帮忙吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <stdio.h> #define N 30  void average(int *p,int n); void max( int *p,int n); void sort(int *p,int n);  int main(int argc, char* argv[]) {     int t[N]={0};      printf(\"Input %d day temperature:\",N);     for(int i=0;i<N;i++)         scanf(\"%d\",&t[i]);      average(t,N);     max(t,N);     sort(t,N);      return 0; }   void average(int *p,int n) {     int sum=0;     for(int i=0;i<n;i++)         sum += p[i];     printf(\"average=%d\\n\",sum/n); }  void max(int *p,int n) {     int max = p[0],h=0;     for(int i=0;i<n;i++)        if(max<p[i]){max = p[i];h = i;}     printf(\"hight temperature:%d, is %d day.\\n\",max,h+1);  }  void sort(int *p,int n) {     int t,temp;     for(int i=0;i<n;i++){         for(int j=t=i;j<n;j++){             if(p[t]>p[j]){                    t = j;             }         }         if(t != i){            temp = p[t];            p[t] = p[i];            p[i] = temp;         }         printf(\"%d%c\",p[i],(i<n-1?' ':'\\n'));     }  }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 jaj2003的回复:提示一下吧. 第一个算函数平均值就是总数/30  第二个函数就是数组的遍历  第三个函数就是数组排序，方法很多，可以冒泡排序，插入排序，堆排序，随便网上找个复制代码就行 但是要调用就不会", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "提示一下吧. 第一个算函数平均值就是总数/30  第二个函数就是数组的遍历  第三个函数就是数组排序，方法很多，可以冒泡排序，插入排序，堆排序，随便网上找个复制代码就行", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "不过你们刚学函数，就让你们排序是不是要求高了点", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 jaj2003的回复:这种最基本的题目都不会，证明还是一个小白啊 对呀，我是小白，你能帮帮我吗，如果这里不适合我，能告诉我那些软件会适合我，就是基础问题，问了会有人帮忙，不会嫌弃我是小白", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "这种最基本的题目都不会，证明还是一个小白啊", "referer": "user-0"}]}
{"question": "求数据结构 C语言 舞伴配对问题程序代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：//舞会上，男士们（m人）和女士们（n人, n<m）进入舞厅时，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。 //男队中未配对者等待下一轮舞曲。现要求写一算法模拟上述舞伴配对问题。在第t首曲子时，第x个女生和第几个男生配对跳舞？ #include <stdio.h> #include <string.h> #define MAX 26 int m,n,t,x,y,i,j,k; char md[MAX]; char nd[MAX]; char c; void main() {     while (1) {         printf(\"Input n m(1<=n<m<=%d):\",MAX);         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&n,&m)) {             if (1<=n && n<m && m<=MAX) break;         }     }     while (1) {         printf(\"Input t x(1<=t<=%d 1<=x<=%d):\",MAX,n);         fflush(stdout);         rewind(stdin);         if (2==scanf(\"%d%d\",&t,&x)) {             if (1<=t && t<=MAX && 1<=x && x<=n) break;         }     }     for (i=0;i<m;i++) md[i]='A'+i;     for (i=0;i<n;i++) nd[i]='a'+i;     k=0;     for (i=0;i<t;i++) {         printf(\"%2d: \",i+1);         for (j=0;j<n;j++) {             c=' ';             if (i==t-1 && j==x-1) {c='*';y=k+1;}             printf(\"%c%c%c\",md[k],nd[j],c);             k=(k+1)%m;         }         printf(\"\\n\");     }     printf(\"%d\\n\",y);  }", "referer": "user-0"}]}
{"question": "十字路口红绿灯问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学长能给个答案吗", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "工大计科的学长？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "woc工大人？", "referer": "user-2"}, {"cid": "4", "user": "user-4", "content": "位段/位域结构体，了解一下？", "referer": "user-0"}]}
{"question": "一个关于字库的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 forever74 的回复:或者说操作系统的字体驱动在安装字体的时候就默默地记录了谁家有生僻字，准备好这种时候顶上去用。 也就是说是程序的判断，而不是字库本身有什么映射之类的，是吧？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "我猜是这样，毕竟不同的字库之间理论上是平级，各自独立安装的话，互相不了解才对，就像刚入学的同学。 但是操作系统的字库驱动就像导员一样，他看过大家的档案啊。  另外，我的树莓派上没有宋体，于是默认缺字就找楷体。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 赵4老师 的回复:使用宋体方正超大字库？ #pragma comment(lib,\"user32\") #pragma comment(lib,\"gdi32\") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> extern \"C\" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t wc[2];      system(\"color F0\");     system(\"cls\");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(48,0,0,0,0,0,0,0,GB2312_CHARSET ,0,0,0,0,\"宋体-方正超大字符集\");     SelectObject(hdc,hfont);     wc[0]=0xD854u;     wc[1]=0xDC00u;     TextOutW(hdc,10,10,wc,2);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system(\"color 07\");     system(\"cls\");     ShowTheCursor();     return 0; } #if 0 代理项或代理项对是一对共同表示单个字符的 16 位 Unicode 编码值。需要记住的关键一点是： 代理项对实际上是 32 位单个字符，不能再假定一个 16 位 Unicode 编码值正好映射到一个字符。  使用代理项对 代理项对的第一个值是高代理项，包含介于 U+D800 到 U+DBFF 范围内的 16 位代码值。 该对的第二个值是低代理项，包含介于 U+DC00 到 U+DFFF 范围内的值。通过使用代理项对， 16 位 Unicode 编码系统可以对已由 Unicode 标准定义的一百多万个其他字符 (220) 进行寻址。  在传递给 XmlTextWriter 方法的任何字符串中都可以使用代理项字符。不过，代理项字符在编写的 XML 中应该有效。例如，万维网联合会 (W3C) 建议不允许在元素或属性的名称中使用代理项字符。 如果字符串包含无效的代理项对，则引发异常。  另外，可以使用 WriteSurrogateCharEntity 写出与代理项对相对应的字符实体。字符实体以十六 进制格式写出，并用以下公式生成：  (highChar -0xD800) * 0x400 + (lowChar -0xDC00) + 0x10000  如果字符串包含无效的代理项对，则引发异常。下面的示例显示将代理项对作为输入的 WriteSurrogateCharEntity 方法。  C#复制  // The following line writes 𐀀. WriteSurrogateCharEntity ('\\uDC00', '\\uD800'); 下面的示例生成一个代理项对文件，将其加载到 XmlReader 中，并用新的文件名保存文件。 然后，原始文件和新文件被加载回应用程序的 XML 文档对象模型 (DOM) 结构中以进行比较。  C#复制  char lowChar, highChar; char [] charArray = new char[10]; FileStream targetFile = new FileStream(\"SurrogatePair.xml\",       FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  lowChar = Convert.ToChar(0xDC00); highChar = Convert.ToChar(0xD800); XmlTextWriter tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDC01); highChar = Convert.ToChar(0xD801); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDFFF); highChar = Convert.ToChar(0xDBFF); tw.WriteSurrogateCharEntity(lowChar, highChar);  // Add 10 random surrogate pairs. // As Unicode, the high bytes are in lower // memory; for example, word 6A21 as 21 6A. // The high or low is in the logical sense. Random random = new Random(); for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       charArray[i] = highChar;       charArray[++i] = lowChar; } tw.WriteChars(charArray, 0, charArray.Length);  for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       tw.WriteSurrogateCharEntity(lowChar, highChar); }  tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  XmlTextReader r = new XmlTextReader(\"SurrogatePair.xml\");  r.Read(); r.MoveToFirstAttribute(); targetFile = new FileStream(\"SurrogatePairFromReader.xml\",        FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteString(r.Value); tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  // Load both result files into the DOM and compare. XmlDocument doc1 = new XmlDocument(); XmlDocument doc2 = new XmlDocument(); doc1.Load(\"SurrogatePair.xml\"); doc2.Load(\"SurrogatePairFromReader.xml\"); if (doc1.InnerXml != doc2.InnerXml) {       Console.WriteLine(\"Surrogate Pair test case failed\"); } 在使用 WriteChars 方法（一次写出一个缓冲区的数据）写出时，输入中的代理项对可能 会在一个缓冲区内被意外拆分。由于代理项值是定义完善的，如果 WriteChars 遇到来自 较低范围或者较高范围的 Unicode 值，它将该值标识为代理项对的一半。当遇到  WriteChars 将导致从拆分代理项对的缓冲区写入的情况时，将引发异常。使用   IsHighSurrogate 方法检查缓冲区是否以高代理项字符结束。如果缓冲区中的最后一个   字符不是高代理项，可以将该缓冲区传递给 WriteChars 方法。  请参见 概念 使用 XmlTextWriter 创建格式正确的 XML XmlTextWriter 的 XML 输出格式设置 XmlTextWriter 的命名空间功能  #endif", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "或者说操作系统的字体驱动在安装字体的时候就默默地记录了谁家有生僻字，准备好这种时候顶上去用。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "使用宋体方正超大字库？", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "尽管不了解具体代码，但是实践表明在windows上，别的字体的字库缺字的时候，一般都是用宋体补上的。 我猜应该是宋体字库最全，然后操作系统就把它作为兜底选项吧。", "referer": "user-0"}]}
{"question": "求大佬解答下大一学生的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "或者说你得清楚，p，q，还有next这些东西都是指针，都是地址，结点的地址。 代码中就没有常规的结构体变量，也就是你说的“结点”。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你细看代码，p和q是在同一行声明的，类型一样，都是指针。 链表这种东西，它的结点是动态申请出来的，没有通常意义上的变量名，只能用指针指着它来使用。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-3的回复:q是指向一块新开辟内存空间的指针哦，你对链表的概念还没领会透彻。 在图书馆翻阅书籍已经弄懂了，谢谢回答", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "q是指向一块新开辟内存空间的指针哦，你对链表的概念还没领会透彻。", "referer": "user-0"}]}
{"question": "c语言基础如梦", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include \"stdio.h\" #include \"math.h\" int main(int argc, char* argv[]) {     int a[100][10],i,j,N,M,sum=0,str=0,l,q;      float b[100]={0},c[10]={0},p=0,f,s=0,k;      scanf(\"%d%d\",&N,&M);      for(i=0;i<N;i++)         for(j=0;j<M;j++)             scanf(\"%d\",&a[i][j]); //输入学生成绩      for(i=0;i<N;i++)     {         sum=0;         for(j=0;j<M;j++)    //for(j=0;j<M;i++)         {             sum += a[i][j];         }         b[i] = float(sum)/float(M);  //平均成绩         printf(\"%.1f \",b[i]);     }     printf(\"\\n\");          for(j=0;j<M;j++)     {         str=0;         for(i=0;i<N;i++)         {                          //scanf(\"%d\",a[i][j]);             str+=a[i][j];         }         c[j] = float(str)/float(N);         printf(\"%.1f \",c[j]);     }     printf(\"\\n\");          k=float(a[0][0]);     for(i=0;i<N;i++)//for(i=1;i<M;i++)     {         for(j=0;j<M;j++)//for(j=0;j<N;j++)         {             if(a[i][j]>k)             {                 k=float(a[i][j]);                 l=i;                 q=j;             }         }     }     printf(\"%.1f %d %d\",k,l+1,q+1);//printf(\"%.1f %d %d\",k,l,q);                                 //break;     printf(\"\\n\");      for(i=0;i<N;i++)     {         s=s+b[i]*4;     }     f=s/float(N*M);     for(i=0;i<N;i++)     {         p = p+pow(b[i]-f,2);     }     p=p/float(N);     printf(\"%.1f\\n\",p);          return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 user-2的回复:调试吧，看看执行到哪行的时候弹出的段错误。 不会调试", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "调试吧，看看执行到哪行的时候弹出的段错误。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 user-2的回复:子曾经曰过，要规避段错误，就得从心所欲不逾矩。 你是猴子派来的逗比吗？，大佬别装萌新了，帮我看看具体哪错了？怎么改？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "子曾经曰过，要规避段错误，就得从心所欲不逾矩。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "段错误就是越界嘛。  或者野指针，哦，不指针啊，那这句不算。", "referer": "user-0"}]}
{"question": "键入数组值，却显示乱码，为什么？？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "乱码在哪里？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "或许是断点断着呢 或许是没敲回车 或许是此m非彼m 或许是显示的一个代码，运行的另一个代码 或许是我没吃早饭造成的", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "第二张图错了，应该是这张。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "图二是我给m数组赋的值，图一是我逐语句调试中的自动窗口监视的内容，我给m数组赋值123456789之后，监视的窗口显示的是“？？”（红色的部分）", "referer": "user-0"}]}
{"question": "C程序。救救孩子。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 user-2 的回复:嗯，我要是自己写，我也用宽字符，舒服。 但是这是我以前亲自感受过char数组的复杂麻烦的。 不感受一下印象不深啊。 用char数组至少还分gbk和utf8两种编码，麻烦。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "嗯，我要是自己写，我也用宽字符，舒服。 但是这是我以前亲自感受过char数组的复杂麻烦的。 不感受一下印象不深啊。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "操作汉字不用wchar_t用char数组太复杂且容易出错", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "抄我的作业。不懂就在百度搜，边搜边理解学习。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "抄我的作业。不懂就在百度搜，边搜边理解学习。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 6 楼 赵4老师的回复:[quote=引用 5 楼 user-2 的回复:]嗯，我要是自己写，我也用宽字符，舒服。 但是这是我以前亲自感受过char数组的复杂麻烦的。 不感受一下印象不深啊。 用char数组至少还分gbk和utf8两种编码，麻烦。[/quote] 老师我搞定了！谢谢您哦。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "你可以不必像四老师写得那么到位，你可以自己测试一下在你自己的平台上每个汉字的编码占用几个字节，然后自己写一个char数组版本的。", "referer": "user-0"}]}
{"question": "请问我这个代码哪错了，为什么输出的不对?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "a[i]=b[i][j]这里a[i]要改成a[j].因为你现在计算的是j行的就低值.另外不知道你的行列是由i还是j表示,如果j是行.那你要改成a[j]=b[j][i]", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "把代码贴出来让大家参考修改不好吗", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:*下面的第一行的循环后面缺少一个大括号呢，这个大括号要把紧接着第二个循环内也要扩在里面。根据自己的需求，看一下是否需要这么改 我加了但还是不对", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "*下面的第一行的循环后面缺少一个大括号呢，这个大括号要把紧接着第二个循环内也要扩在里面。根据自己的需求，看一下是否需要这么改", "referer": "user-0"}]}
{"question": "节点的知识", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 赵4老师的回复:数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633 谢谢老师，明白了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "先理清指针和链表", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "楼主的意思就是尾插法创建链表吧；   xxx *create_link() {     xxx *tail, *head;      head = (xxx *)malloc(sizeof(xxx));     if (!head)         exit(0);     tail  = head;      while ()     {         p = (xxx *)malloc(sizeof(xxx));         scanf(xxx);         tail->next = p;         tail = p;     }     tail->next = NULL;      return head; } 供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "你得先理清指针和结点的关系， 另外，这些概念来自哪里，哪里的旁边就有你需要的内容，以及其它。", "referer": "user-0"}]}
{"question": "PAT 1025 反转链表 (25分)用C语言实现，请帮忙找找问题在哪里", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 8 楼 forever74 的回复:毕竟题目只规定了K不大于N，没说K是0咋办。  要不你排除一下？毕竟做过分母的。题目说K和N都是正整数，所以不是这个问题哦，现在发现哪里错了，是没有对多余的数据进行排除，输入数据里有可能有不存在于链表中的杂数据。还是谢谢你啦", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 赵4老师 的回复:[quote=引用 6 楼 isunnyday 的回复:][quote=引用 5 楼 forever74的回复:]你的截图中的两个带圈的i难道没有透露一些信息？ 没有哦，点进去只说与答案不符，没有说哪里有误，也没有告诉我们测试数据具体是什么[/quote] 无非是在一些边界条件下你没满足呗。 比如： 空链表 只有一个节点的链表 99999个节点的链表 10​0000个节点的链表 …… [/quote]  引用 7 楼 赵4老师 的回复:[quote=引用 6 楼 isunnyday 的回复:][quote=引用 5 楼 forever74的回复:]你的截图中的两个带圈的i难道没有透露一些信息？ 没有哦，点进去只说与答案不符，没有说哪里有误，也没有告诉我们测试数据具体是什么[/quote] 无非是在一些边界条件下你没满足呗。 比如： 空链表 只有一个节点的链表 99999个节点的链表 10​0000个节点的链表 …… [/quote]现在知道哪里错了，没有对非链表的数据进行排除，输入数据里有可能存在多余的数据", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 forever74的回复:你的截图中的两个带圈的i难道没有透露一些信息？ 没有哦，点进去只说与答案不符，没有说哪里有误，也没有告诉我们测试数据具体是什么", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "你的截图中的两个带圈的i难道没有透露一些信息？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "有人看看么", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "毕竟题目只规定了K不大于N，没说K是0咋办。  要不你排除一下？毕竟做过分母的。", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 6 楼 isunnyday 的回复:[quote=引用 5 楼 forever74的回复:]你的截图中的两个带圈的i难道没有透露一些信息？ 没有哦，点进去只说与答案不符，没有说哪里有误，也没有告诉我们测试数据具体是什么[/quote] 无非是在一些边界条件下你没满足呗。 比如： 空链表 只有一个节点的链表 99999个节点的链表 10​0000个节点的链表 ……", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633非常感谢教我用单链表排序的方法，我也去看看。另外，这个题目我是用结构体数组做的，能否帮忙检查上面的代码，谢谢呀", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}]}
{"question": "二维数组  c语言解决问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int a[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};     int i, j, sum = 0;     for (i = 0; i < 3; i++)     {         for (j = 0; j < 4; j++)         {             if (a[i][j] % 2 == 0)             {                 sum += a[i][j];                 printf(\"%d, %d\\n\", i , j);             }         }     }     printf(\"%d\\n\", sum);", "referer": "user-0"}]}
{"question": "能给解释解释ch2为什么是D吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "那%c是输出字母吗？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "ch2='A'+'6'-'3';      //  = 'A'+ 3个位置     = ABCD", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "常用字符的ASCII码是要求记忆的。具体来说，大写、小写字母及数字都是连续的，所以这题一看就明白了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "格式化输出的原因，ch1是%d输出，是67吧，在字符映射表里面就是C，ch2是%c输出，所以就直接输出D了", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "把ASCII码取出来，做对应的相加减，再对应回去，就能理解了，注意十进制和十六进制的转换", "referer": "user-0"}]}
{"question": "C语言中关于转换说明的疑惑", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 forever74的回复:[quote=引用 4 楼 西厢赏月 的回复:] 有没有%luo、%lux，%huo、%hux这几种形式？  Try it first, and throw your conclusion.[/quote] Thank you.", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 4 楼 西厢赏月 的回复:[quote=引用 2 楼 赵4老师的回复:]//八进制、十六进制无符号短整型和长整型转换 #include <stdio.h> int main() {     unsigned short int usi;     unsigned long  int uli;      usi=0xFFFFu;     printf(\"%ho,%hx,%hu\\n\",usi,usi,usi);//177777,ffff,65535     uli=0xFFFFFFFFl;     printf(\"%o,%x,%u\\n\",uli,uli,uli);//37777777777,ffffffff,4294967295     return 0; }  有没有%luo、%lux，%huo、%hux这几种形式？[/quote] https://docs.microsoft.com/en-us/cpp/c-runtime-library/format-specification-syntax-printf-and-wprintf-functions?redirectedfrom=MSDN&view=msvc-160", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 4 楼 西厢赏月 的回复:有没有%luo、%lux，%huo、%hux这几种形式？  Try it first, and throw your conclusion.", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 赵4老师的回复://八进制、十六进制无符号短整型和长整型转换 #include <stdio.h> int main() {     unsigned short int usi;     unsigned long  int uli;      usi=0xFFFFu;     printf(\"%ho,%hx,%hu\\n\",usi,usi,usi);//177777,ffff,65535     uli=0xFFFFFFFFl;     printf(\"%o,%x,%u\\n\",uli,uli,uli);//37777777777,ffffffff,4294967295     return 0; }  有没有%luo、%lux，%huo、%hux这几种形式？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "C Integer Constants An “integer constant” is a decimal (base 10), octal (base 8), or hexadecimal (base 16) number that represents an integral value. Use integer constants to represent integer values that cannot be changed.  Syntax  integer-constant :  decimal-constant integer-suffix opt octal-constant integer-suffix opt hexadecimal-constant integer-suffix opt  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffix opt long-suffix unsigned-suffix opt   unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  Integer constants are positive unless they are preceded by a minus sign (–). The minus sign is interpreted as the unary arithmetic negation operator. (See Unary Arithmetic Operators in Chapter 4 for information about this operator.)  If an integer constant begins with the letters 0x or 0X, it is hexadecimal. If it begins with the digit 0, it is octal. Otherwise, it is assumed to be decimal.   The following lines are equivalent:  0x1C   /* = Hexadecimal representation for decimal 28 */ 034    /* = Octal representation for decimal 28 */  No white-space characters can separate the digits of an integer constant. These examples show valid decimal, octal, and hexadecimal constants.   /* Decimal Constants */ 10 132 32179  /* Octal Constants */ 012 0204 076663  /* Hexadecimal Constants */ 0xa or 0xA 0x84 0x7dB3 or 0X7DB3", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "//八进制、十六进制无符号短整型和长整型转换 #include <stdio.h> int main() {     unsigned short int usi;     unsigned long  int uli;      usi=0xFFFFu;     printf(\"%ho,%hx,%hu\\n\",usi,usi,usi);//177777,ffff,65535     uli=0xFFFFFFFFl;     printf(\"%o,%x,%u\\n\",uli,uli,uli);//37777777777,ffffffff,4294967295     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "你这个问题问的本身就有问题（不管什么进制，内存都是二进制） int a=0377; //八进制，但是它到底还是个int int b=0x00ff; //16进制，但是它到底还是个int usigned int c = 255; //10进制，无符号int long long int d = 255; //10进制，有符号长整型 a和b你想怎么转换？都是int，值也一样。除非你转成字符串来表示，否则只是内存高低位截断的问题。", "referer": "user-0"}]}
{"question": "为什么少了注释的那句输出时就出错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 Aa_1z 的回复:[quote=引用 2 楼 xws245925587的回复:]假设你的水壶只能倒5杯水，你现在倒完了，你不加点水，怎么继续倒啊 为什么要重复申请啊，每次输入都要申请一次，我又没释放这个p[/quote]  瞧，关键在于提问，你早说了这句话，大家就知道了你不晓得什么是链表，才好针对性地回答。 先了解一下链表，了解了以后就知道，这些都是套路，不走这些套路的就不是链表了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你申请了一个内存节点,然后把它插入链表,然后把它改改又插入...最后所有节点都是同一个内存,所以数据全部相同.不用想也知道错了.", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 xws245925587的回复:假设你的水壶只能倒5杯水，你现在倒完了，你不加点水，怎么继续倒啊 为什么要重复申请啊，每次输入都要申请一次，我又没释放这个p", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 2 楼 xws245925587 的回复:假设你的水壶只能倒5杯水，你现在倒完了，你不加点水，怎么继续倒啊 这相当于你要创建一个新的链表出来，你不得给他分配下内存呀", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "假设你的水壶只能倒5杯水，你现在倒完了，你不加点水，怎么继续倒啊", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "出什么错误？  创建链表，先申请节点，后插入链表中。", "referer": "user-0"}]}
{"question": "各位大佬大哥进来瞧瞧，帮小弟看一下作业呗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "嗯，书中才有黄金屋，大哥可没有。  左移1位就是乘2，左移n位就是乘2的n次方，左移n-1位就是乘2的n-1次方。 所以分子是2的n次方减1，分母是2的n-1次方。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-1的回复:printf(\"%d/%d\\n\",(1<<n)-1,1<<n-1); 我小白白一枚  (1<<n)-1,1<<n-1)这啥高端操作。。是左移吗？麻烦大哥解释一下", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "(1<<n)-1,1<<n-1  这是啥高端操作，是 我小白白一个", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "printf(\"%d/%d\\n\",(1<<n)-1,1<<n-1);", "referer": "user-0"}]}
{"question": "这个错误应该怎样修改", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "另外你那两个for根本不是在排序。 排序的话，内层的循环条件一定会引用外层的循环变量。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我是不是还需要写一个#include <memcopy.h>", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "字符串的赋值，需要借助strcmp/memcpy，不能直接赋值。看一下你的name是不是直接赋值了  没看到你的结构体定义，可能还有其他类型是char []类型，是不是也直接赋值了？！", "referer": "user-0"}]}
{"question": "visual的c++配置", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢赵4老师", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "安装gcc", "referer": "user-0"}]}
{"question": "三门问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "求大神帮解一下吧", "referer": "user-0"}]}
{"question": "求助 同一个代码无法运行两次", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-2 的回复:就看while后边的分号，它刚才也不应该好使。 瞎了瞎了  谢谢!", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  typedef struct node {     int value;     struct node* next; }node;  int main(void) {      node* head = (node*)malloc(sizeof(node));     node* begin = head;     scanf_s(\"%d\", &begin->value);     //while (begin->value != 0);     while (begin->value != 0)     {         begin->next = (node*)malloc(sizeof(node));         begin = begin->next;         scanf_s(\"%d\", &begin->value);     }     begin->next = NULL;     begin = head;     while (begin != NULL) {         printf(\"%d\", begin->value);         begin = begin->next;     }     return 0; } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "就看while后边的分号，它刚才也不应该好使。", "referer": "user-0"}]}
{"question": "C语言求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 forever74的回复:你的i和输入的字母有啥关系？ for行末尾带分号意欲何为？ getchar竟然放在for上方，是一次就够的意思么？ 我那个i就是为了那个c+=25-2*i，其他两个的确错了啊，谢谢好人，", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 智者知已应修善业的回复:2i是什么？2*i 改过来了，谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "你的i和输入的字母有啥关系？ for行末尾带分号意欲何为？ getchar竟然放在for上方，是一次就够的意思么？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "2i是什么？2*i", "referer": "user-0"}]}
{"question": "大佬求解   出错了  但我不知道为啥错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢  我参考你的建议  已经解决我的问题了   谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "函数是void类型的返回值，因此不能用L去接收函数的返回值。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h>  #define sizemax   50  //void SeqList_creat(SeqList *&L,int array[],int n); //void SeqList_Bulle(SeqList *&L,int n); //void SeqList_output(SeqList *&L,int n); typedef struct {     int date[sizemax];     int length; }SeqList;  void SeqList_creat(SeqList *&L,int array[],int n); void SeqList_Bulle(SeqList *&L,int n); void SeqList_output(SeqList *&L,int n);  int main(){     SeqList *L=NULL;     int a[]={3,7,2,10,1};     //int n=5;     int n=sizeof(a)/sizeof(a[0]);     if (n > sizemax)         n = sizemax;     //L=SeqList_creat(L,a[],n);   //这行错了 但我不知道啥原因   [Error] expected primary-expression before ']'     SeqList_creat(L, a, n);   //这行错了 但我不知道啥原因   [Error] expected primary-expression before ']'     printf(\"排序前：\\n\");     SeqList_output(L,n);      return 0; }  void SeqList_creat(SeqList *&L,int array[],int n) {     int i=0;      L=(SeqList*)malloc(sizeof(SeqList));     for(i=0;i<n;i++)     {         L->date[i] = array[i];     }     L->length=n; }  void SeqList_Bulle(SeqList *&L,int n) {     int i,j,temp=0;     for(i=0;i<n-1;i++)         for(j=0;j<n-i-1;j++)         {             if(L->date[j]<L->date[j+1])             {                 temp=L->date[j];                 L->date[j]=L->date[j+1];                 L->date[j+1]=temp;             }         }  }  void SeqList_output(SeqList *&L,int n) {     int i;     printf(\"this list:\\n\");     for(i=0;i<n;i++)     {         printf(\"%d \",L->date[i]);     }     putchar(10); } 供参考～  数组名是数组的首地址；", "referer": "user-0"}]}
{"question": "求求大神给我解答一下该怎么用回溯实现，脑回路卡死了想不出来！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <vector> #include <iostream>  void BackTrackSubArrays(std::vector<char> &vecTemp, size_t &nCount, size_t nTotal, size_t nBegin, const std::vector<char> &vecArray) {     if (vecTemp.size() == nTotal)     {         ++nCount;         return;     }      for (size_t i = nBegin; i < vecArray.size(); i++)     {         vecTemp.push_back(vecArray[i]);         BackTrackSubArrays(vecTemp, nCount, nTotal, i + 1, vecArray);         vecTemp.pop_back();     } }  void SubArrays(const std::vector<char> &vecArray) {     std::vector<char> vecTemp;     vecTemp.reserve(vecArray.size());     size_t nCount = 0;     for (size_t i = 0; i <= vecArray.size(); i++)     {         BackTrackSubArrays(vecTemp, nCount, i, 0, vecArray);         std::cout << \"长度为\" << i << \"的子集有：\" << nCount << \"个\" << std::endl;         nCount = 0;     } }  int main() {     SubArrays({ 'A','D','F','Z','K','L','O' }); //此处用到c++11的初始化语法，如果编译器不支持c++11，请自己构造std::vector<char>输入     return 0; } //长度为0的子集有：1个 //长度为1的子集有：7个 //长度为2的子集有：21个 //长度为3的子集有：35个 //长度为4的子集有：35个 //长度为5的子集有：21个 //长度为6的子集有：7个 //长度为7的子集有：1个 //", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <vector> #include <iostream>  void BackTrackSubArrays(std::vector<char> &vecTemp, size_t &nCount, size_t nTotal, size_t nBegin, const std::vector<char> &vecArray) { \tif (vecTemp.size() == nTotal) \t{ \t\t++nCount; \t\treturn; \t}  \tfor (size_t i = nBegin; i < vecArray.size(); i++) \t{ \t\tvecTemp.push_back(vecArray[i]); \t\tBackTrackSubArrays(vecTemp, nCount, nTotal, i + 1, vecArray); \t\tvecTemp.pop_back(); \t} }  void SubArrays(const std::vector<char> &vecArray) { \tstd::vector<char> vecTemp; \tvecTemp.reserve(vecArray.size()); \tsize_t nCount = 0; \tfor (size_t i = 0; i <= vecArray.size(); i++) \t{ \t\tBackTrackSubArrays(vecTemp, nCount, i, 0, vecArray); \t\tstd::cout << \"长度为\" << i << \"的子集有:\" << nCount << \"个\" << std::endl; \t\tnCount = 0; \t} }  int main() { \tSubArrays({ 'A','D','F','Z','K','L','O' }); //此处用到c++11的初始化语法，如果编译器不支持c++11，请自己构造std::vector<char>输入 \tsystem(\"pause\"); \treturn 0; }", "referer": "user-0"}]}
{"question": "萌新路过", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 再也不想做leader了！的回复:[quote=引用 1 楼 赵4老师的回复:]https://www.baidu.com/s?wd=DevC%E4%B8%8A%E5%86%99%E7%9A%84%E6%B8%B8%E6%88%8F%E5%8F%AF%E4%BB%A5%E5%9C%A8%E9%87%8C%E9%9D%A2%E6%B7%BB%E5%8A%A0%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90 人有多大胆，地有多大产。 填百度搜索框时，你敢啥都填，百度就敢啥都搜。  试了之后不行啊[/quote] 照搜索结果中一条试不行的话，就照下一条不一样的再试，直到行为止。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:https://www.baidu.com/s?wd=DevC%E4%B8%8A%E5%86%99%E7%9A%84%E6%B8%B8%E6%88%8F%E5%8F%AF%E4%BB%A5%E5%9C%A8%E9%87%8C%E9%9D%A2%E6%B7%BB%E5%8A%A0%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90 人有多大胆，地有多大产。 填百度搜索框时，你敢啥都填，百度就敢啥都搜。  试了之后不行啊", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "https://www.baidu.com/s?wd=DevC%E4%B8%8A%E5%86%99%E7%9A%84%E6%B8%B8%E6%88%8F%E5%8F%AF%E4%BB%A5%E5%9C%A8%E9%87%8C%E9%9D%A2%E6%B7%BB%E5%8A%A0%E8%83%8C%E6%99%AF%E9%9F%B3%E4%B9%90 人有多大胆，地有多大产。 填百度搜索框时，你敢啥都填，百度就敢啥都搜。", "referer": "user-0"}]}
{"question": "选择排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "分享别人的一个程序", "referer": "user-0"}]}
{"question": "关于指针的循环 小问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请参考《C++数组地址偏移》 希望能够帮到您！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 6 楼 赵4老师 的回复:[quote=引用 5 楼 ctrigger 的回复:][quote=引用 4 楼 赵4老师 的回复:][quote=引用 3 楼 ctrigger 的回复:]两段代码的for循环都没结束标志，都是错的。 你觉得*p1不是结束标志？[/quote] 我说的是题主，不是说你的。你回答是正确的。[/quote] 题主的问题不是出在没结束标志，而是没显式初始化第5个元素后面第6个元素对应的内存中的值，即使不声明第6个元素，程序越界去读第6个元素以及后面各元素时，照样会读第6个元素以及后面各元素对应的内存中的值，至于什么时候能碰到恰巧有0值，那就不一定了。[/quote] 不好意思，给分点错人了 sry", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "多谢各位解惑，总是忘记指针溢出，谢谢。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 3 楼 ctrigger 的回复:两段代码的for循环都没结束标志，都是错的。 你觉得*p1不是结束标志？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "两段代码的for循环都没结束标志，都是错的。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "#include <stdio.h> int main() {      int a1[6] = {1,2,3,4,5,0};     int* p1 = a1;     for (; *p1; p1++) {         printf(\"%d, 0x%p\\n\", *p1, p1);     }       char a2[6] = {'1','2','3','4','5','\\0'};     char* p2 = a2;     for (; *p2; p2++) {         printf(\"%c, 0x%p\\n\", *p2, p2);     }      return 0; } //1, 0x0135FBE4 //2, 0x0135FBE8 //3, 0x0135FBEC //4, 0x0135FBF0 //5, 0x0135FBF4 //1, 0x0135FBFC //2, 0x0135FBFD //3, 0x0135FBFE //4, 0x0135FBFF //5, 0x0135FC00 //  其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "第一段代码输出只是巧合 你已经越界了 两段代码都是错的 都没有0结尾  循环检查0没意义", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "这不是小问题，溢出从来就不会是小问题哦。 对于用 *p 作为结束条件的，要让最后一个值为 0，以便结束循环 可以这样做： 第一个 int a[6] = {1,2,3,4,5,0} 第二个 char a[6] = {'1', '2', '3', '4', '5', '\\0'}  还有，建议养成好习惯，指针用完后，给它赋值NULL 就是在代码最后加上一行 p = NULL    这样可以在很大程度是避免形成“野指针”", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "引用 5 楼 ctrigger 的回复:[quote=引用 4 楼 赵4老师 的回复:][quote=引用 3 楼 ctrigger 的回复:]两段代码的for循环都没结束标志，都是错的。 你觉得*p1不是结束标志？[/quote] 我说的是题主，不是说你的。你回答是正确的。[/quote] 题主的问题不是出在没结束标志，而是没显式初始化第5个元素后面第6个元素对应的内存中的值，即使不声明第6个元素，程序越界去读第6个元素以及后面各元素时，照样会读第6个元素以及后面各元素对应的内存中的值，至于什么时候能碰到恰巧有0值，那就不一定了。", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "引用 4 楼 赵4老师 的回复:[quote=引用 3 楼 ctrigger 的回复:]两段代码的for循环都没结束标志，都是错的。 你觉得*p1不是结束标志？[/quote] 我说的是题主，不是说你的。你回答是正确的。", "referer": "user-0"}]}
{"question": "用指针修改数组某一列", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你没有发现跟书上比起来你的括号有点窄么？ 没有把*括进来，就是事故原因。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主的第二个循环用p=&a[0]是做什么？", "referer": "user-0"}]}
{"question": "C语言程序:学生成绩管理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:主要用到的是结构体、数组、排序这些知识点，你看菜单选项对应调用的函数就知道用到哪些知识点了 谢谢你哟，", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "主要用到的是结构体、数组、排序这些知识点，你看菜单选项对应调用的函数就知道用到哪些知识点了", "referer": "user-0"}]}
{"question": "求大神指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf(\"3.成绩查询。\\n);这里少了个双引号 printf(\"3.成绩查询。\\n\");", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "界面简单啊  void Menu() {     printf(\"------ 学生成绩管理系统 ------\\n\");     printf(\"1.成绩录入。\\n\");     printf(\"2.成绩输出。\\n\");     printf(\"3.成绩查询。\\n);     printf(\"4.退出\\n\");     printf(\"输入选项：\"); }  在main函数中加入：  int main() {     int choice;     Menu();     scanf(\"%d\", &choice);     switch(choice)     {         case 1:             //调用相应的函数             break;        case 2:             //调用相应的函数             break;         case 3:              //调用相应的函数             break;         case 4:             exit(0);             break;         default:             printf(\"输入选项错误，重新输入\");             break;        } }  自己参照修改吧", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-1的回复:刚好有些闲时间，顺手写了下，供参考  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #define N 100  typedef struct student {     int ID;     char name[20];     double score; }Student;  //录入信息 void InputStudent(Student *stu, int n) {     int i;     for (i = 0; i < n; i++)     {         printf(\"输入第%d个学生的信息：\\n\", i + 1);         scanf(\"%d%s%lf\", &stu[i].ID, stu[i].name, &stu[i].score);     } }  //计算总分 double TotalSocre(Student *stu, int n) {     double sum = 0.0;     int i;     for (i = 0; i < n; i++)     {         sum += stu[i].score;     }     return sum; }  //输出 void PrintStudent(Student *stu, int n) {     int i;     printf(\"学号\\t姓名\\t成绩\\n\");     for (i = 0; i < n; i++)     {         printf(\"%d\\t%s\\t%.2f\\n\", stu[i].ID, stu[i].name, stu[i].score);     } }  //排序 void SortStudent(Student *stu, int n) {     int i, j;     Student tmp = { 0 };     for (i = 0; i < n; i++)     {         for (j = 0; j < n - i - 1; j++)         {             if (stu[j].score < stu[j + 1].score)             {                 tmp = stu[j];                 stu[j] = stu[j + 1];                 stu[j + 1] = tmp;             }         }     } }  //按学号查询 void QueryScore(Student *stu, int n) {     int i, tmp;     printf(\"输入要查询的学号：\\n\");     scanf(\"%d\", &tmp);     for (i = 0; i < n; i++)     {         if (stu[i].ID == tmp)         {             printf(\"学号\\t姓名\\t成绩\\n\");             printf(\"%d\\t%s\\t%.2f\\n\", stu[i].ID, stu[i].name, stu[i].score);             return;         }     }     printf(\"学号为%d的学生不存在！\\n\", tmp); }  int main() {     int n;     double sum, avge;     Student s[N] = { 0 };      printf(\"输入学生人数：\\n\");     scanf(\"%d\", &n);     InputStudent(s, n);     sum = TotalSocre(s, n);     avge = sum / n;      printf(\"\\n--------------------\\n\");     PrintStudent(s, n);     printf(\"\\n--------------------\\n\");          printf(\"总分：%.2f  平均分：%.2f\\n\", sum, avge);      printf(\"\\n--------------------\\n\");     SortStudent(s, n);     PrintStudent(s, n);     printf(\"\\n--------------------\\n\");      QueryScore(s, n);  \tsystem(\"pause\"); \treturn 0; }  大佬大佬，，要求有用户界面能帮我写写吗求求了", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "刚好有些闲时间，顺手写了下，供参考  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #define N 100  typedef struct student {     int ID;     char name[20];     double score; }Student;  //录入信息 void InputStudent(Student *stu, int n) {     int i;     for (i = 0; i < n; i++)     {         printf(\"输入第%d个学生的信息：\\n\", i + 1);         scanf(\"%d%s%lf\", &stu[i].ID, stu[i].name, &stu[i].score);     } }  //计算总分 double TotalSocre(Student *stu, int n) {     double sum = 0.0;     int i;     for (i = 0; i < n; i++)     {         sum += stu[i].score;     }     return sum; }  //输出 void PrintStudent(Student *stu, int n) {     int i;     printf(\"学号\\t姓名\\t成绩\\n\");     for (i = 0; i < n; i++)     {         printf(\"%d\\t%s\\t%.2f\\n\", stu[i].ID, stu[i].name, stu[i].score);     } }  //排序 void SortStudent(Student *stu, int n) {     int i, j;     Student tmp = { 0 };     for (i = 0; i < n; i++)     {         for (j = 0; j < n - i - 1; j++)         {             if (stu[j].score < stu[j + 1].score)             {                 tmp = stu[j];                 stu[j] = stu[j + 1];                 stu[j + 1] = tmp;             }         }     } }  //按学号查询 void QueryScore(Student *stu, int n) {     int i, tmp;     printf(\"输入要查询的学号：\\n\");     scanf(\"%d\", &tmp);     for (i = 0; i < n; i++)     {         if (stu[i].ID == tmp)         {             printf(\"学号\\t姓名\\t成绩\\n\");             printf(\"%d\\t%s\\t%.2f\\n\", stu[i].ID, stu[i].name, stu[i].score);             return;         }     }     printf(\"学号为%d的学生不存在！\\n\", tmp); }  int main() {     int n;     double sum, avge;     Student s[N] = { 0 };      printf(\"输入学生人数：\\n\");     scanf(\"%d\", &n);     InputStudent(s, n);     sum = TotalSocre(s, n);     avge = sum / n;      printf(\"\\n--------------------\\n\");     PrintStudent(s, n);     printf(\"\\n--------------------\\n\");          printf(\"总分：%.2f  平均分：%.2f\\n\", sum, avge);      printf(\"\\n--------------------\\n\");     SortStudent(s, n);     PrintStudent(s, n);     printf(\"\\n--------------------\\n\");      QueryScore(s, n);  \tsystem(\"pause\"); \treturn 0; }", "referer": "user-0"}]}
{"question": "C，求大佬教教！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "且不说题干中“再加上”怎么理解； 单说浮点数不能用==进行比较，这是一个常识性的不该犯的错误。  哪怕用 int r=sqrt(n); if(r*r==n)... 之类的也行啊。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我是参考一楼写的小学生代码 #include<stdio.h> #include<math.h> #define N  999999 int main(){ \tint a; \tint i=0; \tfor(i=0;i<N;i++) \t{ \t\t\tdouble m=sqrt(i+100); \t        double n=sqrt(i+168);         \tif(m==(int)m)              if(n==(int)n) \t            printf(\"%d\\n\",i);\t  \t} \t \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 1 楼 user-3 的回复:供参考  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <math.h>  int isSquare(int n) {     double c = sqrt(n);     if (c == (int)c)         return 1;     else         return 0; }  int main() {     int i, n=9999;     for (i = 0; i < n; i++)     {         if (isSquare(i + 100) && isSquare(i + 168))             printf(\"%d\\n\", i);     }          \tsystem(\"pause\"); \treturn 0; }     太棒了   解决了我思考的问题    if（c==（int）c）", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "供参考  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <math.h>  int isSquare(int n) {     double c = sqrt(n);     if (c == (int)c)         return 1;     else         return 0; }  int main() {     int i, n=9999;     for (i = 0; i < n; i++)     {         if (isSquare(i + 100) && isSquare(i + 168))             printf(\"%d\\n\", i);     }          \tsystem(\"pause\"); \treturn 0; }", "referer": "user-0"}]}
{"question": "C语言怎么打开、读和写文件", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "为什么要选择C盘根目录这么敏感的地方呢？ 疑似权限不够。 找个别的盘符写着玩嘛。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 weixin_52907368 的回复:[quote=引用 1 楼 自信男孩的回复:]把scanf放到fopen和判断fp之后呢，另外scanf也有问题，改成这样： scanf(\"%s\", c); 试试吧，  打开文件失败可能跟scanf有关系，先调换位置，测试一下，再改一下scanf测试一下。 已经把scanf写到fp的判断之后了，但是直接就出来create file failed了，直接结束程序[/quote] 改scanf呢？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "把谭浩强的书上的例子抄一遍，全会了。。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:把scanf放到fopen和判断fp之后呢，另外scanf也有问题，改成这样： scanf(\"%s\", c); 试试吧，  打开文件失败可能跟scanf有关系，先调换位置，测试一下，再改一下scanf测试一下。 已经把scanf写到fp的判断之后了，但是直接就出来create file failed了，直接结束程序", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "把scanf放到fopen和判断fp之后呢，另外scanf也有问题，改成这样： scanf(\"%s\", c); 试试吧，  打开文件失败可能跟scanf有关系，先调换位置，测试一下，再改一下scanf测试一下。", "referer": "user-0"}]}
{"question": "一道难题，求帮助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:作业还是自己完成好啊 但是是真不会呀，还要用四种方法。头都大了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "作业还是自己完成好啊", "referer": "user-0"}]}
{"question": "c语言中不使用全局变量？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "传参，或者通过函数返回值得到。比如定义一个接口函数，用于获取模块内部的全局变量或者静态全局变量；", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "模块内部的全局变量内部定义，内部使用，用来实现该模块功能的中间值吧。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不好意思，忘记说了，用的stm32 单片机，ram有限，使用的lwoop框架，技术负责人说这样用的目的是方便他统一申请内存，不希望有全局变量或静态变量在编译的时候占用内存空间。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "static 修饰的全局变量就是被限制在本文件的。", "referer": "user-0"}]}
{"question": "c语言程序设计跪求大佬用c语言写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1 的回复：仅供参考： #include <stdio.h> #include <stdlib.h> #include <string.h>  int my_cmp(const void *a, const void *b) { \tchar str1[10], str2[10]; \tsprintf(str1, \"%d\", *(int *)a); \tsprintf(str2, \"%d\", *(int *)b); \treturn strcmp(str1, str2); }  int main(void) { \tFILE *fp; \tint a[20], n, i; \t \t/* 输入n的值 */ \tscanf(\"%d\", &n); \tif(n > 20) \t{ \t\tprintf(\"输入n <= 20\\n\"); \t\treturn 1; \t} \t/* 输入n个整数 */ \tfor(i = 0; i < n; i++) \t{ \t\tscanf(\"%d\", &a[i]); \t} \t/* 快速排序 */ \tqsort(a, n, sizeof(int), my_cmp); \t/* 打开文件 */ \tfp = fopen(\"result.txt\", \"w\"); \tif(fp == NULL) \t{ \t\tprintf(\"打开文件失败\\n\"); \t\treturn 1; \t} \t/* 输出结果 */ \tfor(i = 0; i < n; i++) \t{ \t\tfprintf(fp, \"%d\", a[i]); \t} \t/* 关闭文件 */ \tfclose(fp); \t \treturn 0; } 大一新生表示看的不是很懂[face]monkey2:019.png[/face][face]monkey2:019.png[/face]", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "仅供参考： #include <stdio.h> #include <stdlib.h> #include <string.h>  int my_cmp(const void *a, const void *b) { \tchar str1[10], str2[10]; \tsprintf(str1, \"%d\", *(int *)a); \tsprintf(str2, \"%d\", *(int *)b); \treturn strcmp(str1, str2); }  int main(void) { \tFILE *fp; \tint a[20], n, i; \t \t/* 输入n的值 */ \tscanf(\"%d\", &n); \tif(n > 20) \t{ \t\tprintf(\"输入n <= 20\\n\"); \t\treturn 1; \t} \t/* 输入n个整数 */ \tfor(i = 0; i < n; i++) \t{ \t\tscanf(\"%d\", &a[i]); \t} \t/* 快速排序 */ \tqsort(a, n, sizeof(int), my_cmp); \t/* 打开文件 */ \tfp = fopen(\"result.txt\", \"w\"); \tif(fp == NULL) \t{ \t\tprintf(\"打开文件失败\\n\"); \t\treturn 1; \t} \t/* 输出结果 */ \tfor(i = 0; i < n; i++) \t{ \t\tfprintf(fp, \"%d\", a[i]); \t} \t/* 关闭文件 */ \tfclose(fp); \t \treturn 0; }", "referer": "user-0"}]}
{"question": "计算边长是1到20时的正方形的周长，直到周长大于50为止", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不会输出的，只会在外面循环", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不会输出，写在外面c=80", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "如果if语句写到for循环外面，for循环执行完，c = 4 * 20 = 80;这时c<=50不成立，当然没有输出了啊", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "大佬们救救孩子吧", "referer": "user-0"}]}
{"question": "结构体", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Cast direct:  user = *(struct config_type *)buf;", "referer": "user-0"}]}
{"question": "vs code无法搜索中文的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首选项->设置   搜索file.encoding  将语言设置成工作区主要语言即可。类似楼主这样的可以设置成GB 2312 即可。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "遇到了，目前还不知道怎么解决，烦。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "搜索默认使用的应该是utf-8，你的编辑是gb2312  \"files.autoGuessEncoding\"应该对应的是后者  前面的可以查下怎么改，改不了的话可以把所有文件改成utf-8编码（点一下右下角的gb2312，保存为utf-8）", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "能指导一下吗？你这话讲的跟没讲一样唉😔", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A", "referer": "user-0"}]}
{"question": "有没有类似memcpy的功能但是是复制数组指定位置开始的n个长度数据到另一个数组的方法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 MOVELASER 的回复:[quote=引用 1 楼 user-3 的回复:]你说的不就是memcpy吗  那就用memcpy完事了 memcpy只能拷贝起始位置开始吧，我需要非起始位置[/quote]谁说非起始位置，指针移动不就行了，memcpy(a , b+1);//从b+1字节开始拷贝", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 4 楼 MOVELASER 的回复:引用 2 楼 yiyefangzhou24 的回复:strcpy((char *) , (char *));您好，非字符数组强制转换然后，strncpy", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "int a[10]; int b[4]; memcpy((void *)&b[0],(void *)&a[3],4*sizeof(int));//将a[3],a[4],a[5],a[6]分别赋值给b[0],b[1],b[2],b[3]", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 3 楼 MOVELASER 的回复:[quote=引用 1 楼 user-3 的回复:]你说的不就是memcpy吗  那就用memcpy完事了 memcpy只能拷贝起始位置开始吧，我需要非起始位置[/quote]memcpy(desc, src+10, 20);", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 yiyefangzhou24 的回复:strcpy((char *) , (char *));您好，非字符数组", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-3 的回复:你说的不就是memcpy吗  那就用memcpy完事了 memcpy只能拷贝起始位置开始吧，我需要非起始位置", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "strcpy((char *) , (char *));", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "你说的不就是memcpy吗  那就用memcpy完事了", "referer": "user-0"}]}
{"question": "c语言输出问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "分了三次scnaf，多半有你输入格式的问题", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 user-2的回复:[quote=引用 2 楼 sytth 的回复:]帮我输入结果一下，我一直输出0.0 想让别人帮你一个字母一个字母敲？？？[/quote] 分了三次scanf，弄好了，", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 sytth 的回复:帮我输入结果一下，我一直输出0.0 想让别人帮你一个字母一个字母敲？？？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "帮我输入结果一下，我一直输出0.0", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "1.sum没有初始化，建议float sum = 0.0; 2.scanf输入的时候，去掉q->name前面的&符号 3.sum/=5;还是建议改成sum/=5.0", "referer": "user-0"}]}
{"question": "结构体，链表输出不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include <stdlib.h> #include<malloc.h>  struct Employee {     int num;     float pay;     struct Employee* next; };  struct Employee* creat() {     struct Employee* head, * p1, * p2;     int n=0;     p1 = p2 = (struct Employee*)malloc(sizeof(struct Employee));     if (!p1)         exit(0);     head = NULL;     //scanf(\"%d%f\", &p1->num, &p2->pay);     scanf(\"%d%f\", &p1->num, &p1->pay);     while (p1->num != 0)     {         n = n + 1;         if (n == 1)             head = p1;         else             p2->next = p1;         p2 = p1;         p1 = (struct Employee*)malloc(sizeof(struct Employee));         if (!p1)             exit(0);         //scanf(\"%d%f\", &p1->num, &p2->pay);         scanf(\"%d%f\", &p1->num, &p1->pay);     }     p2->next = NULL;     free(p1);   //最后一个p1没有链入链表里，释放掉;      return(head);              //返回链表中第一个节点得起始地址 } void list(struct Employee* head) {     struct Employee* p;     p = head;     printf(\"The linked list:\\n\");     if(head!=NULL)         do         {             printf(\"%d,%.2f\\n\", p->num, p->pay);             p = p->next;         } while (p != NULL); }  int main() {     struct Employee* head;     head = creat();     list(head);     return 0; } 供参考～  对比一下，找一下自己的问题～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 楼主 AruNi° ഒ 的回复:如图，为什么第一行没有了，却把0 0也输出来了？？？  #include<stdio.h> #include<malloc.h> struct Employee { \tint num; \tfloat pay; \tstruct Employee* next; }; struct Employee* creat() { \tstruct Employee* head, * p1, * p2; \tint n=0; \tp1 = p2 = (struct Employee*)malloc(sizeof(struct Employee)); \thead = NULL; \tscanf(\"%d%f\", &p1->num, &p2->pay); \twhile (p1->num != 0) \t{ \t\tn = n + 1; \t\tif (n == 1) \t\t\thead = p1; \t\telse \t\t\tp2->next = p1; \t\tp2 = p1; \t\tp1 = (struct Employee*)malloc(sizeof(struct Employee)); \t\tscanf(\"%d%f\", &p1->num, &p2->pay); \t} \tp2->next = NULL; \treturn(head);              //返回链表中第一个节点得起始地址 } void list(struct Employee* head) { \tstruct Employee* p; \tp = head; \tprintf(\"The linked list:\\n\"); \tif(head!=NULL) \t\tdo  \t\t{ \t\t\tprintf(\"%d,%.2f\\n\", p->num, p->pay); \t\t\tp = p->next; \t\t} while (p != NULL); } int main() { \tstruct Employee* head; \thead = creat(); \tlist(head); \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:贴源码吧～不建议贴图片～ 好的👌🏻", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-3的回复:遍历链表为咐用do...while呢 一般都是这样：  while(p->next != NULL) {     printf(\"%d, %f\", p->num, p->pay);     p=p->next; }  问题出在哪啊？像你这样改了也不对，直接没有第一个职工的工资了。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "贴源码吧～不建议贴图片～", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "遍历链表为咐用do...while呢 一般都是这样：  while(p->next != NULL) {     printf(\"%d, %f\", p->num, p->pay);     p=p->next; }", "referer": "user-0"}]}
{"question": "c语言编程设计1项目，编程萌新，急求，谢谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "不介意私聊解决项目，萌新求助，急需谢谢", "referer": "user-0"}]}
{"question": "圈叉棋设计，替换字符出现问题（大佬救命）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 曲九合的回复:问一下，这个是手机c语言编译器吧，软件叫什么名字啊？在哪里可以下载到？谢谢 C语言编译器IDE，在手机的应用市场里就有", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 曲九合的回复:问一下，这个是手机c语言编译器吧，软件叫什么名字啊？在哪里可以下载到？谢谢 全称为 C语言编译器IDE  ，华为手机应用市场里就有的", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "问一下，这个是手机c语言编译器吧，软件叫什么名字啊？在哪里可以下载到？谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 user-2的回复:   a[i][j]='O';//79; 谢谢大佬，我就是缓冲字符这一块出了问题", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "a[i][j]='O';//79;", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "供参考：#include <stdio.h> int main(int argc, char* argv[]) {     //char a[3][3]={49,50,51,52,53,54,55,56,57},n;     char a[3][3]={'1','2','3','4','5','6','7','8','9'},n;//这样定义是否更清晰     int x,m,i,j;     m=2;     for(x=0;x<10;x++)     {         m++;         printf(\" %c  :  %c   : %c\\n\",a[0][0],a[0][1],a[0][2]);         printf(\"--- + --- + ---\\n\");         printf(\" %c  :  %c   : %c\\n\",a[1][0],a[1][1],a[1][2]);         printf(\"--- + --- + ---\\n\");         printf(\" %c  :  %c   : %c\\n\",a[2][0],a[2][1],a[2][2]);         printf(\"--- + --- + ---\\n\");         printf(\"1-9代表九宫格中的位置，请输入1-9落子\\n\");         scanf(\"%c\",&n);         getchar(); //吃掉缓冲区多余字符         for(i=0;i<3;i++)         {             for(j=0;j<3;j++)             {                 if(a[i][j]==n && m%2==0)                 {                     a[i][j]='X'; //88；这样定义是否更清晰                 }                 if(a[i][j]==n && m%2!=0)                 {                     a[i][j]='0';//79;                 }                 else                 {                     continue;                 }             }         }     }     return 0; }", "referer": "user-0"}]}
{"question": "问题：\ns[j++]=a[i];与s[++j]=a[i];的区别", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "++j 是先加再用j的值 j++ 是先用j的值再加1", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主理解正确，答案选A。A答案的执行顺序就是s[j]=s[i];j+1; 。如果是s[++j]=a[i]，执行顺序是j+1;s[j]=s[i]; 。规则就这么定的。", "referer": "user-0"}]}
{"question": "各位大佬，帮忙看看呗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢你，谢谢你", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "第三题  #include <stdio.h>  int CheckPhoneNum(char *num) {     char *p = num;     int len = 0;     while (*(p++) != '\\0')     {         len++;     }     for (int i = len - 1; i > len - 5; i--)     {         if (num[i] >= '0' && num[i] <= '9')         {             continue;         }         else         {             return 1;         }     }     if (num[len - 5] != '-')     {         printf(\"num[%d] is not -\\n\",len-5);         return 1;     }     for (int i = len - 6; i > len - 9; i--)     {         if (num[i] >= '0' && num[i] <= '9')         {             continue;         }         else         {             printf(\"前缀num[%d] %d is not number\\n\",i,num[i]);             return 1;         }     }     if (num[len - 8] == '0')     {         printf(\"num[%d] is not -\\n\",len-5);         return 1;     }     int sum = 0;     for (int i = 0; i < len - 9; i++)     {         sum += num[i] - '0';     }     if (sum == 0)     {         if (num[len - 9] == '-')         {             printf(\"num[%d] is -\\n\",len-9);             return 1;         }     }     else     {         if (num[len - 9] != '-')         {             printf(\"num[%d] is not -\\n\",len-5);             return 1;         }     }     return 0; }  int main(void) {     char num[15];     scanf(\"%s\", num);     if (CheckPhoneNum(num) == 0)     {         printf(\"%s符合规定\\n\", num);     }     else     {         printf(\"%s不符合规定\\n\", num);     }      return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "第二题 #include <stdio.h> int judge(int a[], int n, int *cd) {     if (n < 3)         return -1;     int i, j, tmp;     for (i = 0; i < n; i++)     {         for (j = i + 1; j < n; j++)         {             if (a[i] > a[j])             {                 tmp = a[i];                 a[i] = a[j];                 a[j] = tmp;             }         }     }     *cd = a[1] - a[0];     for (i = 0; i < n - 1; i++)     {         if (*cd != (a[i + 1] - a[i]))         {             *cd = 0;             return 1;         }     }     return 0; }  int main(void) {     int a[50] = {0};     int n, cd;     scanf(\"%d\", &n);     for (int i = 0; i < n; i++)     {         scanf(\"%d\", &a[i]);     }     if (judge(a, n, &cd) == 0)     {         printf(\"%d\", cd);     }     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "第一题  #include <stdio.h> int isprime(int n) {     int i;     if (n < 2)         return 0;     for (i = 2; i < n; i++)     {         if (n % 2 == 0)         {             return 0;         }     }     return 1; }  int resolve(int n) {     int i;     for (i = 2; i < n; i++)     {         if (isprime(i) && isprime(n - i))         {             return i;         }     }     return 0; }  int main(void) {     int n, m;     int res;     scanf(\"%d %d\", &n, &m);     for (int i = n; i <= m; i++)     {         res = resolve(i);         if (res != 0)         {             printf(\"%d=%d+%d\\n\", i, res, i - res);         }     }     return 0; }", "referer": "user-0"}]}
{"question": "怎么搞定字符串变量之间的比较大小，赋值问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 weixin_52907368 的回复:[quote=引用 1 楼 user-2的回复:]visit是什么类型？ 从while(visit[j]!=‘\\0’)可以判断visit是个char数组，那么visit[j]就是char类型，所以不符合strcmp的参数类型 因为你的代码不全，不知道你想干啥，单纯为了修改代码 strcmp(x,visit[j])可以改成strcmp(x,&visit[j])//visit[j]是char类型&visit[j]就是char*类型，才符号strcmp的参数类型 visit[j]=x可以改成strcpy(&visit[j], x)//要用字符串拷贝的方式 谢谢，明白了，我就是想知道这个strcmp和strcpy怎么用[/quote]  网上有很多这样的例子，建议楼主先看一下这两个函数的原型，以便了解应该传什么参数进去", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:visit是什么类型？ 从while(visit[j]!=‘\\0’)可以判断visit是个char数组，那么visit[j]就是char类型，所以不符合strcmp的参数类型 因为你的代码不全，不知道你想干啥，单纯为了修改代码 strcmp(x,visit[j])可以改成strcmp(x,&visit[j])//visit[j]是char类型&visit[j]就是char*类型，才符号strcmp的参数类型 visit[j]=x可以改成strcpy(&visit[j], x)//要用字符串拷贝的方式 谢谢，明白了，我就是想知道这个strcmp和strcpy怎么用", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "visit是什么类型？ 从while(visit[j]!=‘\\0’)可以判断visit是个char数组，那么visit[j]就是char类型，所以不符合strcmp的参数类型 因为你的代码不全，不知道你想干啥，单纯为了修改代码 strcmp(x,visit[j])可以改成strcmp(x,&visit[j])//visit[j]是char类型&visit[j]就是char*类型，才符号strcmp的参数类型 visit[j]=x可以改成strcpy(&visit[j], x)//要用字符串拷贝的方式", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "strcmp(&x, &visit[i]) 这样试试～", "referer": "user-0"}]}
{"question": "小白求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 12 楼 forever74的回复:其实你编译时的最后一条警告C6279已经指出了这个问题，可是你忽略了。 其实我是有看到的，只不过不知道是括号的形式错了，总之感谢大佬的指正", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "str2=new char[i+4];  if(!fp1) {   printf(...);   return; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "其实你编译时的最后一条警告C6279已经指出了这个问题，可是你忽略了。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 9 楼 forever74的回复:你写的是圆括号啊老大 new char(i+4)是申请1个字节的空间并用 i+4的值进行初始化的意思 对不起，看到了，已经改正了，谢谢大佬，我太傻了，基本格式都打错了", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 9 楼 forever74的回复:你写的是圆括号啊老大 new char(i+4)是申请1个字节的空间并用 i+4的值进行初始化的意思 那要如何解决呢，大佬，这个难题困扰我很久了", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "你写的是圆括号啊老大 new char(i+4)是申请1个字节的空间并用 i+4的值进行初始化的意思", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 6 楼 forever74的回复:我说的是编译警告， 你说的是运行时弹出的对话框啊。  那不是好像，就是你使用的内存范围超出了new申请的 造成的。 你关注过那个方括号了么？ 我试着申请了更大内存，依然会报错", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "确实关注了，但仍不知如何解决", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "我说的是编译警告， 你说的是运行时弹出的对话框啊。  那不是好像，就是你使用的内存范围超出了new申请的 造成的。 你关注过那个方括号了么？", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 1 楼 forever74的回复:str2=new char[i+4];  if(!fp1) {   printf(...);   return; } 好像是动态分配内存出了问题", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:当文件打开失败后，就不要考虑向后继续执行了。 我加了返回值，还是报错，运行不出来，好像是动态分配内存的问题", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 forever74的回复:str2=new char[i+4];  if(!fp1) {   printf(...);   return; } 我加上了返回值，但是还是会报错", "referer": "user-0"}, {"cid": "13", "user": "user-2", "content": "当文件打开失败后，就不要考虑向后继续执行了。", "referer": "user-0"}]}
{"question": "严蔚敏 数据结构 算法4.2 有个地方不明白呀 为什么是S1[0]?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "从楼主画红线的位置可以感觉到， 当时楼主忐忑的心情，不安地猜测着，一个字符串为什么会与两个整数相加呢？  下雨天留客天留我不留？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "s[0]存放的是他的长度  引用 3 楼 C2S2D2Nshishabi 的回复:引用 1 楼 真相重于对错 的回复:S1[0]是第一个串的长度，T的第1个字符到第S[0]个字符，被赋予了S1的数据，所以T[S1[0]+S[2]] 放置S2的数据还是有点不明白，T的第1个字符到第S[0]个字符，被赋予了S1的数据，所以T[S1[0]+S[2]] 放置S2的数据，如果这么说的话，为什么前面还要加个S1[0]呀，S1[0]不是放在了第一个串长的后面了吗？不应该是先1...S1[0]，再S1[0]吗？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "很久没见过这么奇葩的脑洞了。 用C的风格说，这里的..是优先级最低的省略号，两边的加号都比它的优先级高，你得先去理解两边的加号，然后把各自的和作为省略号的上下限，OK？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:S1[0]是第一个串的长度，T的第1个字符到第S[0]个字符，被赋予了S1的数据，所以T[S1[0]+S[2]] 放置S2的数据还是有点不明白，T的第1个字符到第S[0]个字符，被赋予了S1的数据，所以T[S1[0]+S[2]] 放置S2的数据，如果这么说的话，为什么前面还要加个S1[0]呀，S1[0]不是放在了第一个串长的后面了吗？不应该是先1...S1[0]，再S1[0]吗？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "比如S1 = 3\"ABC\"  S2=4\"1234\" 那么红线上一句话执行完后 T=？\"ABC\" 然后从S1[0]+1 开始 ，也就是4到 S[0]+S2[0] ,也就是7，这4个位置，放置”1234“", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "S1[0]是第一个串的长度，T的第1个字符到第S[0]个字符，被赋予了S1的数据，所以T[S1[0]+S[2]] 放置S2的数据", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "-先考虑--b == d++  因为前置--所以b的值为8（9-1） d的++为后置，所以对比的时候d还是8 所以成立 当比较完后d自增变成9  然后9赋值给a 然后再次自增变成10", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "后缀++是先使用再变量自增1 --b计算得8，d++先使用d，所以8==8成立，然后d变为9，因为8==8成立，所以执行a=d++，先使用d，所以a=9，然后d变为10，所以最终a是9", "referer": "user-0"}]}
{"question": "萌新求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "while循环出大问题啦。\tint n, i = 1, sum = 0; \tscanf(\"%d\", &n); \twhile (i <= n) \t{ \t\tif (n % i == 0) \t\t{ \t\t\tsum = sum + 1; \t\t} \t\ti++; \t} \tprintf(\"%d\\n\", sum); 仅供参考", "referer": "user-0"}]}
{"question": "看看为啥不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "大约是你执行输入函数的时候输入的格式不对，所以那些scanf都失败了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "不知道哪里错了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "第28行输出中 printf(\"%d %s %s %d %d\\n\",          cla[i].num, cla[i].name, cla[i].teacher, cla[i].term, cla[i].person);，老师的名字是字符串输出，所以结构体里应该改为：struct Class{        int   num;        char  name[10];        char  teacher[10];//老师名字是字符串        int   term;        int   person; };", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "teacher应该定义成字符数组吧，看到input函数里用的是%s，如果还用字符，那么这儿的%s就会导致越界，因为%s要接收字符，至少要2个字符，因为'\\0'也占一个字符。  同样的道理print里用%s输出了teacher  所以，建议楼主把teacher定义成字符数组，比如char teacher[32];  定义数组长度建议定义成2的n次幂的大小，这个n根据你的预判数组长度决定。", "referer": "user-0"}]}
{"question": "大神求解，刚入门就遇到这。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "只用逆波兰式，表达式求值方便。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "百度搜“表达式树 先序 中序  后序”", "referer": "user-0"}]}
{"question": "大锅们，请问为什总是vs提醒我第一个else应输入一个语句，可是下面不是有吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "下面这句多了‘：’号引用if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "它上方的if行末尾多余分号， 死记硬背之。", "referer": "user-0"}]}
{"question": "衣食父母们，来了来了！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "x=m*i+a=n*j+b n*j=m*i+(a-b); j=(m*i+(a-b))/n; 循环i，找到(m*i+(a-b))%n==0即可，如果i超出int范围（变成负数）说明无解", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "就是想看看你们有没有更简洁的方法", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不知道你在说啥", "referer": "user-0"}]}
{"question": "数据结构--关于用队列实现形如a+b@b+a#字符序列的检验，程序进行要要检验一步就不运行了，求帮忙看看代码哪里有问题！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include <stdio.h> #include <stdlib.h>  #define MAXQSIZE 100 #define ERROR 0 #define OK 1  typedef struct{     char *base;     int front;     int rear; }SqQueue;  void InitQueue(SqQueue *Q) //建立顺序队列 {     Q->base=(char*)malloc(MAXQSIZE*sizeof(char));     if(!Q->base)         exit(1);     Q->front = Q->rear = 0; }  int EnQueue(SqQueue *Q,char e) {     if((Q->rear+1)%MAXQSIZE==Q->front) return ERROR; //队列满条件     Q->base[Q->rear]=e;     Q->rear=(Q->rear+1)%MAXQSIZE;     return OK; }  int DeQueue(SqQueue *Q,char *e)  //从队列头删除一个元素 {     if(Q->front==Q->rear)         return ERROR; //队列空条件     *e=Q->base[Q->front];     Q->front=(Q->front+1)%MAXQSIZE;     return OK; }  int DeQueue_rear(SqQueue *Q,char *e) //从队列尾删除一个元素 {     if(Q->front == Q->rear)         return ERROR; //队列空     //*e=Q->base[Q->rear];     *e=Q->base[Q->rear-1];     Q->rear=(Q->rear-1)%MAXQSIZE;      return OK; }  int GetHead(SqQueue Q,char *e) {     if(Q.front==Q.rear)         return ERROR; //队列空     *e=Q.base[Q.front];     return OK; }  int QueueLength(SqQueue *Q) {     return (Q->rear-Q->front+MAXQSIZE)%MAXQSIZE; }  int CheckSymmetry(SqQueue *Q,char ch[]) {     InitQueue(Q);     int i=0;     //char *e,*c;     char e, c;     while(ch[i]!='@')  //@前字符入队列     {         EnQueue(Q,ch[i]);         i++;     }     i++;     while(ch[i]!='#')  //@后#前字符入队列     {         EnQueue(Q,ch[i]);         i++;     }     while(QueueLength(Q)!=0)     {         if(!DeQueue(Q, &c))             return ERROR;//取队头元素         if(!DeQueue_rear(Q, &e))             return ERROR;//取队尾元素         printf(\"%c:%c\\n\", c, e);         if(c != e)             return 0;     }     if(Q->front==Q->rear)         return 1; //队列为空，成功对称      return 0; }  int main(void) {     SqQueue Q;     //Q=(SqQueue*)malloc(sizeof(*Q));     //if(!Q) exit(1);     int i=0;     char ch[100]={'0'}, c;     do{         printf(\"请输入一个字符(形如a+b@b+a#的序列)：\\n\");         scanf(\"%c\",&c);         getchar();         ch[i]=c;         i++;     }while(c != '#');     if(CheckSymmetry(&Q,ch))         printf(\"是中心对称序列\\n\");     else         printf(\"不是中心对称序列\\n\"); } 供参考～ 非常感谢！！但是有个疑问，在检验匹配的函数里，char *e,*c,为什么不可以呢，传指针进入DeQueue 函数，然后把指针的值赋为要弹出的队列值，这样为什么不可以呢？？希望可以解释一下非常感谢！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  #define MAXQSIZE 100 #define ERROR 0 #define OK 1  typedef struct{     char *base;     int front;     int rear; }SqQueue;  void InitQueue(SqQueue *Q) //建立顺序队列 {     Q->base=(char*)malloc(MAXQSIZE*sizeof(char));     if(!Q->base)         exit(1);     Q->front = Q->rear = 0; }  int EnQueue(SqQueue *Q,char e) {     if((Q->rear+1)%MAXQSIZE==Q->front) return ERROR; //队列满条件     Q->base[Q->rear]=e;     Q->rear=(Q->rear+1)%MAXQSIZE;     return OK; }  int DeQueue(SqQueue *Q,char *e)  //从队列头删除一个元素 {     if(Q->front==Q->rear)         return ERROR; //队列空条件     *e=Q->base[Q->front];     Q->front=(Q->front+1)%MAXQSIZE;     return OK; }  int DeQueue_rear(SqQueue *Q,char *e) //从队列尾删除一个元素 {     if(Q->front == Q->rear)         return ERROR; //队列空     //*e=Q->base[Q->rear];     *e=Q->base[Q->rear-1];     Q->rear=(Q->rear-1)%MAXQSIZE;      return OK; }  int GetHead(SqQueue Q,char *e) {     if(Q.front==Q.rear)         return ERROR; //队列空     *e=Q.base[Q.front];     return OK; }  int QueueLength(SqQueue *Q) {     return (Q->rear-Q->front+MAXQSIZE)%MAXQSIZE; }  int CheckSymmetry(SqQueue *Q,char ch[]) {     InitQueue(Q);     int i=0;     //char *e,*c;     char e, c;     while(ch[i]!='@')  //@前字符入队列     {         EnQueue(Q,ch[i]);         i++;     }     i++;     while(ch[i]!='#')  //@后#前字符入队列     {         EnQueue(Q,ch[i]);         i++;     }     while(QueueLength(Q)!=0)     {         if(!DeQueue(Q, &c))             return ERROR;//取队头元素         if(!DeQueue_rear(Q, &e))             return ERROR;//取队尾元素         printf(\"%c:%c\\n\", c, e);         if(c != e)             return 0;     }     if(Q->front==Q->rear)         return 1; //队列为空，成功对称      return 0; }  int main(void) {     SqQueue Q;     //Q=(SqQueue*)malloc(sizeof(*Q));     //if(!Q) exit(1);     int i=0;     char ch[100]={'0'}, c;     do{         printf(\"请输入一个字符(形如a+b@b+a#的序列)：\\n\");         scanf(\"%c\",&c);         getchar();         ch[i]=c;         i++;     }while(c != '#');     if(CheckSymmetry(&Q,ch))         printf(\"是中心对称序列\\n\");     else         printf(\"不是中心对称序列\\n\"); } 供参考～", "referer": "user-0"}]}
{"question": "数据结构--关于单链表的一些操作，程序运行一半停止，不知道哪里有问题，求助！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼  的回复:[quote=引用 2 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList_L(linklist *L,int n); void ListTraverse(linklist L,int n); void ListInsert(linklist L,int i,int e,int n);  //n为链表中结点个数 ,i为第i个元素前插入，e是新结点的值 void ListDelete(linklist L,int i,int *node,int n);  //n为链表中结点个数 ,i为删除结点的位置，e用来返回删除结点的值 void visit(linklist p);  int main() {     linklist L;     int n,i=5,e=999,*node;      printf(\"请输入你想建立单链表的结点个数：\\n\");     scanf(\"%d\",&n);      CreatList_L(&L,n);   //逆序建立单链表,并将单链表的头地址赋给指针s     ListTraverse(L,n);  //遍历单链表     ListInsert(L,i,e,n);  //插入     ListDelete(L,i,node,n);  //删除  }  void CreatList_L(linklist *L,int n)  //逆序建立 {     printf(\"-----逆序建立------\\n\");     linklist p;     int i;     *L=(Lnode*)malloc(sizeof(Lnode)); //建立带头结点的单链表     //L->next==NULL;     (*L)->next = NULL;     for(i=n;i>0;i--)     {         p=(Lnode*)malloc(sizeof(Lnode));         printf(\"please enter a number:\\n\");         scanf(\"%d\",&p->data);         p->next=(*L)->next;         (*L)->next=p;     }  }  void ListTraverse(linklist L,int n) //遍历单链表 {     printf(\"\\n\\n-------遍历--------\\n\");     int i;     linklist p;     p=L->next;     for(i=0;i<n;i++)     {         visit(p);         p=p->next;     } }  void visit(linklist p) //输出 {     printf(\"%d  \",p->data); }  void ListInsert(linklist L,int i,int e,int n) //第5个元素前插入元素 {     printf(\"\\n\\n-----插入元素------\\n\");     linklist p,q;     p=L;     //e=999;     //i=5;     int j=0;     while((p->next)&&j<i-1) //寻找第i-1个结点位置     {           p=p->next;         j++;      }     if(p->next==NULL)  //插入位置不合理     {         printf(\"ERROR!插入位置不合理！\");         exit(0);     }     q=(Lnode*)malloc(sizeof(Lnode));  //建立新结点     q->data=e;     q->next=p->next;  //连入链表     p->next=q;     printf(\"\\n插入成功！\\n\");     printf(\"\\n新链表为:\");     p=L;     for(i=0;i<n+1;i++)     {         p=p->next;         visit(p);     } }  void ListDelete(linklist L,int i,int *node,int n)  //删除第i个元素 {     printf(\"\\n\\n-----删除元素------\\n\");     linklist p,q;     p=L;     //i=5;     int j=0;     while(p->next&&j<i-1) //寻找删除结点的上个结点地址     {         p=p->next;         j++;     }     if(p->next==NULL)  //删除位置不合理     {         printf(\"ERROR!删除位置不合理！\");         exit(0);     }     q=p->next;  //删除结点     p->next=q->next;     *node=q->data;     free(q);  //释放结点     printf(\"\\n删除成功！\\n\");     printf(\"\\n新链表为:\");     p=L;     for(i=0;i<n-1;i++)     {         p=p->next;         visit(p);     } }  供参考～  为什么创建单链表时一定要用二级指针呢？？这点一直不太明白，一级指针传入的不也是地址吗？？ 希望可以讲解一下！非常感谢！！！[/quote]  参数传递是值传递，你把main函数的指针传进去，对这个指针做修改了吗？传二重指针，就可以对这个main函数里的指针进行修改。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList_L(linklist *L,int n); void ListTraverse(linklist L,int n); void ListInsert(linklist L,int i,int e,int n);  //n为链表中结点个数 ,i为第i个元素前插入，e是新结点的值 void ListDelete(linklist L,int i,int *node,int n);  //n为链表中结点个数 ,i为删除结点的位置，e用来返回删除结点的值 void visit(linklist p);  int main() {     linklist L;     int n,i=5,e=999,*node;      printf(\"请输入你想建立单链表的结点个数：\\n\");     scanf(\"%d\",&n);      CreatList_L(&L,n);   //逆序建立单链表,并将单链表的头地址赋给指针s     ListTraverse(L,n);  //遍历单链表     ListInsert(L,i,e,n);  //插入     ListDelete(L,i,node,n);  //删除  }  void CreatList_L(linklist *L,int n)  //逆序建立 {     printf(\"-----逆序建立------\\n\");     linklist p;     int i;     *L=(Lnode*)malloc(sizeof(Lnode)); //建立带头结点的单链表     //L->next==NULL;     (*L)->next = NULL;     for(i=n;i>0;i--)     {         p=(Lnode*)malloc(sizeof(Lnode));         printf(\"please enter a number:\\n\");         scanf(\"%d\",&p->data);         p->next=(*L)->next;         (*L)->next=p;     }  }  void ListTraverse(linklist L,int n) //遍历单链表 {     printf(\"\\n\\n-------遍历--------\\n\");     int i;     linklist p;     p=L->next;     for(i=0;i<n;i++)     {         visit(p);         p=p->next;     } }  void visit(linklist p) //输出 {     printf(\"%d  \",p->data); }  void ListInsert(linklist L,int i,int e,int n) //第5个元素前插入元素 {     printf(\"\\n\\n-----插入元素------\\n\");     linklist p,q;     p=L;     //e=999;     //i=5;     int j=0;     while((p->next)&&j<i-1) //寻找第i-1个结点位置     {           p=p->next;         j++;      }     if(p->next==NULL)  //插入位置不合理     {         printf(\"ERROR!插入位置不合理！\");         exit(0);     }     q=(Lnode*)malloc(sizeof(Lnode));  //建立新结点     q->data=e;     q->next=p->next;  //连入链表     p->next=q;     printf(\"\\n插入成功！\\n\");     printf(\"\\n新链表为:\");     p=L;     for(i=0;i<n+1;i++)     {         p=p->next;         visit(p);     } }  void ListDelete(linklist L,int i,int *node,int n)  //删除第i个元素 {     printf(\"\\n\\n-----删除元素------\\n\");     linklist p,q;     p=L;     //i=5;     int j=0;     while(p->next&&j<i-1) //寻找删除结点的上个结点地址     {         p=p->next;         j++;     }     if(p->next==NULL)  //删除位置不合理     {         printf(\"ERROR!删除位置不合理！\");         exit(0);     }     q=p->next;  //删除结点     p->next=q->next;     *node=q->data;     free(q);  //释放结点     printf(\"\\n删除成功！\\n\");     printf(\"\\n新链表为:\");     p=L;     for(i=0;i<n-1;i++)     {         p=p->next;         visit(p);     } }  供参考～  为什么创建单链表时一定要用二级指针呢？？这点一直不太明白，一级指针传入的不也是地址吗？？ 希望可以讲解一下！非常感谢！！！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList_L(linklist *L,int n); void ListTraverse(linklist L,int n); void ListInsert(linklist L,int i,int e,int n);  //n为链表中结点个数 ,i为第i个元素前插入，e是新结点的值 void ListDelete(linklist L,int i,int *node,int n);  //n为链表中结点个数 ,i为删除结点的位置，e用来返回删除结点的值 void visit(linklist p);  int main() {     linklist L;     int n,i=5,e=999,*node;      printf(\"请输入你想建立单链表的结点个数：\\n\");     scanf(\"%d\",&n);      CreatList_L(&L,n);   //逆序建立单链表,并将单链表的头地址赋给指针s     ListTraverse(L,n);  //遍历单链表     ListInsert(L,i,e,n);  //插入     ListDelete(L,i,node,n);  //删除  }  void CreatList_L(linklist *L,int n)  //逆序建立 {     printf(\"-----逆序建立------\\n\");     linklist p;     int i;     *L=(Lnode*)malloc(sizeof(Lnode)); //建立带头结点的单链表     //L->next==NULL;     (*L)->next = NULL;     for(i=n;i>0;i--)     {         p=(Lnode*)malloc(sizeof(Lnode));         printf(\"please enter a number:\\n\");         scanf(\"%d\",&p->data);         p->next=(*L)->next;         (*L)->next=p;     }  }  void ListTraverse(linklist L,int n) //遍历单链表 {     printf(\"\\n\\n-------遍历--------\\n\");     int i;     linklist p;     p=L->next;     for(i=0;i<n;i++)     {         visit(p);         p=p->next;     } }  void visit(linklist p) //输出 {     printf(\"%d  \",p->data); }  void ListInsert(linklist L,int i,int e,int n) //第5个元素前插入元素 {     printf(\"\\n\\n-----插入元素------\\n\");     linklist p,q;     p=L;     //e=999;     //i=5;     int j=0;     while((p->next)&&j<i-1) //寻找第i-1个结点位置     {           p=p->next;         j++;      }     if(p->next==NULL)  //插入位置不合理     {         printf(\"ERROR!插入位置不合理！\");         exit(0);     }     q=(Lnode*)malloc(sizeof(Lnode));  //建立新结点     q->data=e;     q->next=p->next;  //连入链表     p->next=q;     printf(\"\\n插入成功！\\n\");     printf(\"\\n新链表为:\");     p=L;     for(i=0;i<n+1;i++)     {         p=p->next;         visit(p);     } }  void ListDelete(linklist L,int i,int *node,int n)  //删除第i个元素 {     printf(\"\\n\\n-----删除元素------\\n\");     linklist p,q;     p=L;     //i=5;     int j=0;     while(p->next&&j<i-1) //寻找删除结点的上个结点地址     {         p=p->next;         j++;     }     if(p->next==NULL)  //删除位置不合理     {         printf(\"ERROR!删除位置不合理！\");         exit(0);     }     q=p->next;  //删除结点     p->next=q->next;     *node=q->data;     free(q);  //释放结点     printf(\"\\n删除成功！\\n\");     printf(\"\\n新链表为:\");     p=L;     for(i=0;i<n-1;i++)     {         p=p->next;         visit(p);     } }  供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "可在VS里面下断点，单步调试。", "referer": "user-0"}]}
{"question": "数据结构-关于删除一递增序列中符合条件的元素，程序运行一半不动了，不知道哪里出了问题，求助！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼  的回复:[quote=引用 3 楼 自信男孩 的回复:][quote=引用 2 楼  的回复:][quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList(linklist *L,int num[])  //创建链表 {     (*L)=(linklist)malloc(sizeof(Lnode)); //建立带头结点的单链表     if(!(*L))         exit(1);     (*L)->next=NULL;      int i=0;     linklist p,q = *L;      while(num[i]!=-1)  //数据时以-1为结束标志     {         p=(Lnode*)malloc(sizeof(Lnode));         p->data=num[i];         q->next=p;         p->next=NULL;         q=p;         i++;     } }  void chushu(linklist L) {     linklist r=L;     r=r->next;     while(r!=NULL)     {         printf(\"%d  \",r->data);         r=r->next;     } } int ListDelete_L(linklist L,int mink,int maxk) //删除满足条件的结点 {     linklist p,q;     p = L->next;     q = L;     if(!p) {         printf(\"ERROR!链表为空！\");         exit(0);     } #if 1     while (p) {         if (p->data > mink && p->data < maxk) {             q->next = p->next;             free(p);             p = q->next;          } else {             q = p;             p = p->next;         }     } #else     while(p!=NULL)     {         if((p->data)>mink&&p->data<maxk)  //data值大于mink小于maxk，进行删除         {             q->next=p->next;             free(p);             p=q->next;         }         else         {             q=p;             p=p->next;             //break;         }      } #endif      return 1; }  int main() {     int num[12]={0,2,3,6,13,21,33,37,45,66,99,-1};     int i;     printf(\"原序列：\");     for(i=0;i<11;i++)         printf(\"%d \",num[i]);     int mink=0,maxk=0;     printf(\"\\n请输入删除元素下界mink：\\n\");     scanf(\"%d,\",&mink);     printf(\"请输入删除元素上界maxk：\\n\");     scanf(\"%d,\",&maxk);     linklist L;     CreatList(&L,num);     ListDelete_L(L,mink,maxk);     linklist p=L;     p=p->next;     printf(\"现序列：\");     while(p!=NULL)     {         printf(\"%d  \",p->data);         p=p->next;     } } 供参考～ 请问加的if else 是什么意思呢？还有把while循环再多加一遍？？ 希望解释一下！谢谢！！[/quote]  不是，而是根据我的理解去写这个逻辑，发现和你的差不多，就差一个break[/quote]  但是break不是结束本次循环的作用吗？？为什么差一个break错这么多啊， 现在想想觉得有没有break，这个循环运行不应该是一样的吗？？有点想不通了又。[/quote]  break是跳出循环，不是“结束本次循环”还有几个循环，不就是一层循环吗？怎么还有本次循环？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:[quote=引用 2 楼  的回复:][quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList(linklist *L,int num[])  //创建链表 {     (*L)=(linklist)malloc(sizeof(Lnode)); //建立带头结点的单链表     if(!(*L))         exit(1);     (*L)->next=NULL;      int i=0;     linklist p,q = *L;      while(num[i]!=-1)  //数据时以-1为结束标志     {         p=(Lnode*)malloc(sizeof(Lnode));         p->data=num[i];         q->next=p;         p->next=NULL;         q=p;         i++;     } }  void chushu(linklist L) {     linklist r=L;     r=r->next;     while(r!=NULL)     {         printf(\"%d  \",r->data);         r=r->next;     } } int ListDelete_L(linklist L,int mink,int maxk) //删除满足条件的结点 {     linklist p,q;     p = L->next;     q = L;     if(!p) {         printf(\"ERROR!链表为空！\");         exit(0);     } #if 1     while (p) {         if (p->data > mink && p->data < maxk) {             q->next = p->next;             free(p);             p = q->next;          } else {             q = p;             p = p->next;         }     } #else     while(p!=NULL)     {         if((p->data)>mink&&p->data<maxk)  //data值大于mink小于maxk，进行删除         {             q->next=p->next;             free(p);             p=q->next;         }         else         {             q=p;             p=p->next;             //break;         }      } #endif      return 1; }  int main() {     int num[12]={0,2,3,6,13,21,33,37,45,66,99,-1};     int i;     printf(\"原序列：\");     for(i=0;i<11;i++)         printf(\"%d \",num[i]);     int mink=0,maxk=0;     printf(\"\\n请输入删除元素下界mink：\\n\");     scanf(\"%d,\",&mink);     printf(\"请输入删除元素上界maxk：\\n\");     scanf(\"%d,\",&maxk);     linklist L;     CreatList(&L,num);     ListDelete_L(L,mink,maxk);     linklist p=L;     p=p->next;     printf(\"现序列：\");     while(p!=NULL)     {         printf(\"%d  \",p->data);         p=p->next;     } } 供参考～ 请问加的if else 是什么意思呢？还有把while循环再多加一遍？？ 希望解释一下！谢谢！！[/quote]  不是，而是根据我的理解去写这个逻辑，发现和你的差不多，就差一个break[/quote]  但是break不是结束本次循环的作用吗？？为什么差一个break错这么多啊， 现在想想觉得有没有break，这个循环运行不应该是一样的吗？？有点想不通了又。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:[quote=引用 2 楼  的回复:][quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList(linklist *L,int num[])  //创建链表 {     (*L)=(linklist)malloc(sizeof(Lnode)); //建立带头结点的单链表     if(!(*L))         exit(1);     (*L)->next=NULL;      int i=0;     linklist p,q = *L;      while(num[i]!=-1)  //数据时以-1为结束标志     {         p=(Lnode*)malloc(sizeof(Lnode));         p->data=num[i];         q->next=p;         p->next=NULL;         q=p;         i++;     } }  void chushu(linklist L) {     linklist r=L;     r=r->next;     while(r!=NULL)     {         printf(\"%d  \",r->data);         r=r->next;     } } int ListDelete_L(linklist L,int mink,int maxk) //删除满足条件的结点 {     linklist p,q;     p = L->next;     q = L;     if(!p) {         printf(\"ERROR!链表为空！\");         exit(0);     } #if 1     while (p) {         if (p->data > mink && p->data < maxk) {             q->next = p->next;             free(p);             p = q->next;          } else {             q = p;             p = p->next;         }     } #else     while(p!=NULL)     {         if((p->data)>mink&&p->data<maxk)  //data值大于mink小于maxk，进行删除         {             q->next=p->next;             free(p);             p=q->next;         }         else         {             q=p;             p=p->next;             //break;         }      } #endif      return 1; }  int main() {     int num[12]={0,2,3,6,13,21,33,37,45,66,99,-1};     int i;     printf(\"原序列：\");     for(i=0;i<11;i++)         printf(\"%d \",num[i]);     int mink=0,maxk=0;     printf(\"\\n请输入删除元素下界mink：\\n\");     scanf(\"%d,\",&mink);     printf(\"请输入删除元素上界maxk：\\n\");     scanf(\"%d,\",&maxk);     linklist L;     CreatList(&L,num);     ListDelete_L(L,mink,maxk);     linklist p=L;     p=p->next;     printf(\"现序列：\");     while(p!=NULL)     {         printf(\"%d  \",p->data);         p=p->next;     } } 供参考～ 请问加的if else 是什么意思呢？还有把while循环再多加一遍？？ 希望解释一下！谢谢！！[/quote]  不是，而是根据我的理解去写这个逻辑，发现和你的差不多，就差一个break[/quote] 确实是break的问题哈，删了之后正常了。非常感谢！！！！", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 2 楼  的回复:[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList(linklist *L,int num[])  //创建链表 {     (*L)=(linklist)malloc(sizeof(Lnode)); //建立带头结点的单链表     if(!(*L))         exit(1);     (*L)->next=NULL;      int i=0;     linklist p,q = *L;      while(num[i]!=-1)  //数据时以-1为结束标志     {         p=(Lnode*)malloc(sizeof(Lnode));         p->data=num[i];         q->next=p;         p->next=NULL;         q=p;         i++;     } }  void chushu(linklist L) {     linklist r=L;     r=r->next;     while(r!=NULL)     {         printf(\"%d  \",r->data);         r=r->next;     } } int ListDelete_L(linklist L,int mink,int maxk) //删除满足条件的结点 {     linklist p,q;     p = L->next;     q = L;     if(!p) {         printf(\"ERROR!链表为空！\");         exit(0);     } #if 1     while (p) {         if (p->data > mink && p->data < maxk) {             q->next = p->next;             free(p);             p = q->next;          } else {             q = p;             p = p->next;         }     } #else     while(p!=NULL)     {         if((p->data)>mink&&p->data<maxk)  //data值大于mink小于maxk，进行删除         {             q->next=p->next;             free(p);             p=q->next;         }         else         {             q=p;             p=p->next;             //break;         }      } #endif      return 1; }  int main() {     int num[12]={0,2,3,6,13,21,33,37,45,66,99,-1};     int i;     printf(\"原序列：\");     for(i=0;i<11;i++)         printf(\"%d \",num[i]);     int mink=0,maxk=0;     printf(\"\\n请输入删除元素下界mink：\\n\");     scanf(\"%d,\",&mink);     printf(\"请输入删除元素上界maxk：\\n\");     scanf(\"%d,\",&maxk);     linklist L;     CreatList(&L,num);     ListDelete_L(L,mink,maxk);     linklist p=L;     p=p->next;     printf(\"现序列：\");     while(p!=NULL)     {         printf(\"%d  \",p->data);         p=p->next;     } } 供参考～ 请问加的if else 是什么意思呢？还有把while循环再多加一遍？？ 希望解释一下！谢谢！！[/quote]  不是，而是根据我的理解去写这个逻辑，发现和你的差不多，就差一个break", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList(linklist *L,int num[])  //创建链表 {     (*L)=(linklist)malloc(sizeof(Lnode)); //建立带头结点的单链表     if(!(*L))         exit(1);     (*L)->next=NULL;      int i=0;     linklist p,q = *L;      while(num[i]!=-1)  //数据时以-1为结束标志     {         p=(Lnode*)malloc(sizeof(Lnode));         p->data=num[i];         q->next=p;         p->next=NULL;         q=p;         i++;     } }  void chushu(linklist L) {     linklist r=L;     r=r->next;     while(r!=NULL)     {         printf(\"%d  \",r->data);         r=r->next;     } } int ListDelete_L(linklist L,int mink,int maxk) //删除满足条件的结点 {     linklist p,q;     p = L->next;     q = L;     if(!p) {         printf(\"ERROR!链表为空！\");         exit(0);     } #if 1     while (p) {         if (p->data > mink && p->data < maxk) {             q->next = p->next;             free(p);             p = q->next;          } else {             q = p;             p = p->next;         }     } #else     while(p!=NULL)     {         if((p->data)>mink&&p->data<maxk)  //data值大于mink小于maxk，进行删除         {             q->next=p->next;             free(p);             p=q->next;         }         else         {             q=p;             p=p->next;             //break;         }      } #endif      return 1; }  int main() {     int num[12]={0,2,3,6,13,21,33,37,45,66,99,-1};     int i;     printf(\"原序列：\");     for(i=0;i<11;i++)         printf(\"%d \",num[i]);     int mink=0,maxk=0;     printf(\"\\n请输入删除元素下界mink：\\n\");     scanf(\"%d,\",&mink);     printf(\"请输入删除元素上界maxk：\\n\");     scanf(\"%d,\",&maxk);     linklist L;     CreatList(&L,num);     ListDelete_L(L,mink,maxk);     linklist p=L;     p=p->next;     printf(\"现序列：\");     while(p!=NULL)     {         printf(\"%d  \",p->data);         p=p->next;     } } 供参考～ 请问加的if else 是什么意思呢？还有把while循环再多加一遍？？ 希望解释一下！谢谢！！", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  typedef struct Lnode  //定义单链表存储结构 {     int data;     struct Lnode *next; }Lnode, *linklist;  void CreatList(linklist *L,int num[])  //创建链表 {     (*L)=(linklist)malloc(sizeof(Lnode)); //建立带头结点的单链表     if(!(*L))         exit(1);     (*L)->next=NULL;      int i=0;     linklist p,q = *L;      while(num[i]!=-1)  //数据时以-1为结束标志     {         p=(Lnode*)malloc(sizeof(Lnode));         p->data=num[i];         q->next=p;         p->next=NULL;         q=p;         i++;     } }  void chushu(linklist L) {     linklist r=L;     r=r->next;     while(r!=NULL)     {         printf(\"%d  \",r->data);         r=r->next;     } } int ListDelete_L(linklist L,int mink,int maxk) //删除满足条件的结点 {     linklist p,q;     p = L->next;     q = L;     if(!p) {         printf(\"ERROR!链表为空！\");         exit(0);     } #if 1     while (p) {         if (p->data > mink && p->data < maxk) {             q->next = p->next;             free(p);             p = q->next;          } else {             q = p;             p = p->next;         }     } #else     while(p!=NULL)     {         if((p->data)>mink&&p->data<maxk)  //data值大于mink小于maxk，进行删除         {             q->next=p->next;             free(p);             p=q->next;         }         else         {             q=p;             p=p->next;             //break;         }      } #endif      return 1; }  int main() {     int num[12]={0,2,3,6,13,21,33,37,45,66,99,-1};     int i;     printf(\"原序列：\");     for(i=0;i<11;i++)         printf(\"%d \",num[i]);     int mink=0,maxk=0;     printf(\"\\n请输入删除元素下界mink：\\n\");     scanf(\"%d,\",&mink);     printf(\"请输入删除元素上界maxk：\\n\");     scanf(\"%d,\",&maxk);     linklist L;     CreatList(&L,num);     ListDelete_L(L,mink,maxk);     linklist p=L;     p=p->next;     printf(\"现序列：\");     while(p!=NULL)     {         printf(\"%d  \",p->data);         p=p->next;     } } 供参考～", "referer": "user-0"}]}
{"question": "c语言节点插入和删除", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}]}
{"question": "小白求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "纯粹因为就那么不超过10行代码，索性给你写了。 建议这种问题LZ还是自己先写一下，有问题再问。 int f(int a, int b) {     return a>b ? 1 : (a<b ? -1 : 0); } int main() {     int a, b;     scanf(\"%d%d\", &a, &b);     printf(\"%d\", f(a, b));     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "void func(int a, int b) {     if (a > b)         printf(\"1\\n\");     else if(a < b)         printf(\"-1\\n\");     else         printf(\"0\"); }", "referer": "user-0"}]}
{"question": "C语言余数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 ctrigger 的回复:[quote=引用 4 楼 mswpp 的回复:]因为你的有错呀，哈哈哈哈 眼睛瞪大一点，都是对的。[/quote]我说的不是你的，哈哈哈哈", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 4 楼 mswpp 的回复:因为你的有错呀，哈哈哈哈 眼睛瞪大一点，都是对的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "因为你的有错呀，哈哈哈哈", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "简单粗暴，仅供参考：#include <stdio.h>   int main(void) {     unsigned int a, b, m, n, x;     scanf(\"%d%d%d%d\", &m, &n, &a, &b);          x = 1;     while(x)     {         if ((x % m == a) && (x % n == b))         {             printf(\"有解：x=%u\", x);             return 0;         }         x++;     }          printf(\"无解\");          return 1; }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "不是告诉你思路了吗？ x=m*i+a=n*j+b 推出 n*j=m*i+(a-b) 推出 j=(m*i+(a-b))/n 因为 i 和 j 是整数，所以(m*i+(a-b))必须能被n整除才能保证 j 是整数 所以，i从0一直循环到整数的最大值，看看能否有满足条件的 i，找到 i 就是有解，否则就是无解  int mian() {     int a,b,m,n,i;     scanf(\"%d%d%d%d\", &m, &n, &a, &b);     for (i=0; ; i++) {         if (i<0) {             printf(\"无解\");             break; //i越界变成负数说明无解         }         else if ((m*i+a-b)%n == 0) {             printf(\"有解：x=%d\", m*i+a);             break;         }     }     return 0; }", "referer": "user-0"}]}
{"question": "用*号打印实型心形图案", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <conio.h> #include <stdlib.h> int main() {     system(\"chcp 437\");     cprintf(\"\\3\\3\\3\\3\\3\\3\\3\\3\\3\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "写的好！ 接下来考虑写短一些吧。", "referer": "user-0"}]}
{"question": "PAT 1020 月饼 (25分) 用C语言实现，请帮忙找找问题在哪里", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 user-1的回复:for(j=i+1;... 确实是这里错了，我之前看了好久都没有看出来，当局者迷呀，改后就全部运行成功了，非常感谢^_^", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "for(j=i+1;...", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-1的回复:排序的两个for就写的不对，仔细一下。 检查了几遍，也没有发现哪里错了呢，帮忙看下哦，谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "排序的两个for就写的不对，仔细一下。", "referer": "user-0"}]}
{"question": "C语言文件操作代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 m0_46788383 的回复:[quote=引用 1 楼 自信男孩的回复:]自己先写写吧，不是很难的需求～ 是真的不会写唉[/quote] 那就找找原因，为什么写不出来。一句都写不出来，还是懒得去写。起码框架之类的，对的写不出来，错误的也能写出来吧  不尝试怎么知道，尝试了写不对这是两码事", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:自己先写写吧，不是很难的需求～ 是真的不会写唉", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "自己先写写吧，不是很难的需求～", "referer": "user-0"}]}
{"question": "求大神解决 为什么我的vs2019写的C语言代码打开文件后在屏幕或者记事本显示都是一排方框", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "写代码，给你几点建议 1. 一定要做错误检查，不要怕麻烦。 err,  err1的返回值 都正确么  2. 代码一定要简单易懂。 ( (ch = getc(fp) != '#')   --->>>( ( ch = getc(fp) )  != '#' )  3. 要学会写调试代码，确定故障发生的原因。 例如， 发生错误时， 是文件打开错误， 还是读取字符的错误，还是文件写入的错误  4.感觉想乱码，看看官网的函数使用方法吧。 你输入文件的内容是英文还是中文，估计是中文吧， 先用英文试试，如果好用。在试试中文。 怎么感觉putc 函数的问题。 VC的函数不熟。 ]https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-s-wfopen-s?view=msvc-160", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 往事如烟0819 的回复：写代码，给你几点建议 1. 一定要做错误检查，不要怕麻烦。 err,  err1的返回值 都正确么  2. 代码一定要简单易懂。 ( (ch = getc(fp) != '#')   --->>>( ( ch = getc(fp) )  != '#' )  3. 要学会写调试代码，确定故障发生的原因。 例如， 发生错误时， 是文件打开错误， 还是读取字符的错误，还是文件写入的错误  4.感觉想乱码，看看官网的函数使用方法吧。 你输入文件的内容是英文还是中文，估计是中文吧， 先用英文试试，如果好用。在试试中文。 怎么感觉putc 函数的问题。 VC的函数不熟。 ]https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-s-wfopen-s?view=msvc-160我改好了 多谢提点  向你学习大佬 你给的建议很nice", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "我也是这个问题，你解决了吗？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 往事如烟0819 的回复：写代码，给你几点建议 1. 一定要做错误检查，不要怕麻烦。 err,  err1的返回值 都正确么  2. 代码一定要简单易懂。 ( (ch = getc(fp) != '#')   --->>>( ( ch = getc(fp) )  != '#' )  3. 要学会写调试代码，确定故障发生的原因。 例如， 发生错误时， 是文件打开错误， 还是读取字符的错误，还是文件写入的错误  4.感觉想乱码，看看官网的函数使用方法吧。 你输入文件的内容是英文还是中文，估计是中文吧， 先用英文试试，如果好用。在试试中文。 怎么感觉putc 函数的问题。 VC的函数不熟。 ]https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-s-wfopen-s?view=msvc-160大佬我这个运行没啥问题 就是生成的txt文件用记事本打开时显示是一串方框 我把输出流转到屏幕显示也是一串方框  这是为啥啊 求解", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 往事如烟0819 的回复：写代码，给你几点建议 1. 一定要做错误检查，不要怕麻烦。 err,  err1的返回值 都正确么  2. 代码一定要简单易懂。 ( (ch = getc(fp) != '#')   --->>>( ( ch = getc(fp) )  != '#' )  3. 要学会写调试代码，确定故障发生的原因。 例如， 发生错误时， 是文件打开错误， 还是读取字符的错误，还是文件写入的错误  4.感觉想乱码，看看官网的函数使用方法吧。 你输入文件的内容是英文还是中文，估计是中文吧， 先用英文试试，如果好用。在试试中文。 怎么感觉putc 函数的问题。 VC的函数不熟。 ]https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-s-wfopen-s?view=msvc-160大佬 这个运行上都没有问题 最后也直接生成了写入的txt文件 就是文件里的英文语句显示出来是一串方框", "referer": "user-0"}]}
{"question": "问题（指针基础）：字符串复制函数返回复制后字符串首地址值,无法打印该字符串", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢楼上的各位，问题解决了！！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "1. s3 指向的地址空间 h3[100], 没有被初始化。  重点  局部变量，数组， 必须在使用前，进行初始化。 原因 局部变量的初始值不定, 很危险。(从栈空间分配， 其值为上次别人剩下的值)", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include<stdio.h> char *strcopy(char *t,const char *s) {     char *temp = t;     while(*temp++=*s++);//temp s 中记录的地址值是在增加变化     return t; //返回的地址值是字符串首地址不变的  }  int main(int argc, char* argv[]) {      char h1[100],h2[100],h3[100];     char *s1,*s2,*s3;     s1=h1;     s2=h2;     s3=h3; // 这里 s3 -> h3[100]的地址     scanf(\"%s\",s2);     s3=strcopy(s1,s2);//这里 s3 -> s1的地址，即h1[100]的地址。     printf(\"%s\\n\",s3);     return 0;  } //程序执行完，h1[100]和h2[100]的内容一致，h3[100]并没有变化。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "楼主，程序修改下，是否更容易让你理解，指针只是记录地址的一个变量。#include<stdio.h> char *strcopy(char *t,const char *s) {     char *temp = t;     while(*temp++=*s++);     return t;  }  int main(int argc, char* argv[]) {      char h1[100],h2[100],h3[100];     char *s1,*s2,*s3;     s1=h1;     s2=h2;     s3=h3;     scanf(\"%s\",s2);     s3=strcopy(s1,s2);     printf(\"%s\\n\",s3);     return 0;  }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "是啊，你return的那个t已经漂移了好远。  很契合 刻舟求剑 哦。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "char *strcopy(char *t,const char *s) {     while(*t++=*s++);     return t;//这里的t已经指向了传进来数据的尾部了  }", "referer": "user-0"}]}
{"question": " 请教一下前辈们这里类型转换的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢各位老师，冬至快乐", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "为了不引起对齐错误也就是总线错误，要么费心计算需要多少填充字节，要么像这样粗鲁地转换成32位或64位（依系统而定）。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "栈这种东西我们喜欢比喻为子弹夹。 照你的想法，弹夹里面可以7.62mm和5mm还有12mm的混合还不出啥问题？  尽管指针尤其是void指针可以以字节为单位移动，但是混压不同尺寸的数据很容易引起总线错误啊。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "去掉你认为多余的转换，看编译是否报错，编译如果不报错的话，用-2147483648,2147483647,0,-1,1作为数据，运行测试一下看结果是否如你所愿。", "referer": "user-0"}]}
{"question": "free指针时报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果你不想再申请内存空间 那就没有必要malloc和free。 你直接用fvalue的地址空间就好 。 对吧；", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请时刻牢记free和malloc一定是成对出现的，没有用malloc，就不要用free", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "你是想要把f_value的内容赋值给fp(malloc分配的空间吧) int main(int argc, char **argv) { \tfloat f_value[] = { 1,2,3,4,5 }; \tfloat *fp=NULL; \t \tfp = (float *)malloc(30 * sizeof(float)); \tif ( fp != NULL ) \t{ \t\tmemcpy(fp, &f_value[0],  sizeof( f_value) ); \t} \telse \t{ \t\t/* Error process......\t*/ \t} \t \tfree(fp); \treturn 0; \t }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "感谢！。。。f_value如果是传参怎么办？ int Dll_Start(float *f_value) { \t \tfloat *fp = NULL; \t//fp = (float *)malloc(30 * sizeof(float)); \tfp = f_value;  \tfree(fp); \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "那不能先free再赋值么?", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "f_value改成动态数组，也用malloc申请内存就可以 数组内存是固定的，在栈里，函数结束栈退出后会自动被回收，所以你自己不能free栈里的内存。 动态分配内存是在堆上的，跟栈没关系，栈退出也不会自动回收，所以才需要自己去free。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "free只能释放malloc开辟的内存，f_value是栈变量，不用free", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "fp=f_value不是不可以，那你就没必要free了。 理由上面已经说过了，f_value是栈内存，栈退出会自动回收，不能自己free。 也就是说你的dll_start函数内部不需要管理free，因为dll_start不知道参数的指针是指向栈内存还是堆内存，所以没必要去强制free。free应该由内存申请的者去自己控制，dll_start不需要越俎代庖。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 5 楼 往事如烟0819 的回复:你是想要把f_value的内容赋值给fp(malloc分配的空间吧) int main(int argc, char **argv) { \tfloat f_value[] = { 1,2,3,4,5 }; \tfloat *fp=NULL; \t \tfp = (float *)malloc(30 * sizeof(float)); \tif ( fp != NULL ) \t{ \t\tmemcpy(fp, &f_value[0],  sizeof( f_value) ); \t} \telse \t{ \t\t/* Error process......\t*/ \t} \t \tfree(fp); \treturn 0; \t }  感谢。。。这里只能用memcpy？？我尝试过，这个有点慢，实际应用中，我的数据量有点大，就没有直接fp = f_value;的办法吗？", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 6 楼 chxchxkkk 的回复:请时刻牢记free和malloc一定是成对出现的，没有用malloc，就不要用free 谢谢，我知道，我的意思是即使用了malloc，也会报错。这里。", "referer": "user-0"}]}
{"question": "有没有人能够看一下我这段代码出现了什么问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1 的回复:修改如下，供参考：void account(int a) {     printf(\"\\nname 用户\\n\");     printf(\"please input the account:\\n\");     char ch[] = { 'l','o','g','i','n','_','v','i','s','i','o','n','1','.','0','.','3' };     char b[17];     int i = 0;     int t = 0;     while (i < 17 && t == 0)     {         scanf_s(\"%c\", &b[i]);         if (b[i] == '\\n')         {             t = 1;         }         i++;     }     i = 0;     t = -1;     while (i < 17)     {         if (ch[i] == b[i])         {            i++;         }         else         {            t++;            i = 0;            //account(t);            break;         }     }      if (i != 17)         account(t);     else         password(1); } 运行出来是正确的，谢谢啦", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我看一下，再编译一次，看有没有问题，谢谢啦。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "修改如下，供参考：void account(int a) {     printf(\"\\nname 用户\\n\");     printf(\"please input the account:\\n\");     char ch[] = { 'l','o','g','i','n','_','v','i','s','i','o','n','1','.','0','.','3' };     char b[17];     int i = 0;     int t = 0;     while (i < 17 && t == 0)     {         scanf_s(\"%c\", &b[i]);         if (b[i] == '\\n')         {             t = 1;         }         i++;     }     i = 0;     t = -1;     while (i < 17)     {         if (ch[i] == b[i])         {            i++;         }         else         {            t++;            i = 0;            //account(t);            break;         }     }      if (i != 17)         account(t);     else         password(1); }", "referer": "user-0"}]}
{"question": "有没有大佬用proteus7", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 楼主 weixin_53802790的回复:最近在做计算机大作业。想做一个病床呼叫系统，用proteus7的atmega16。有没有大佬能帮忙支个招。 八个开关分别控制八个数码管为病床，开关闭合会控制相应的数码管显示数字，同时蜂鸣器会发出警报。第九个开关闭合会使所有数码管清零，同时警报声消失。有没有大佬有思路，能不能教教我，求求了，不想挂科", "referer": "user-0"}]}
{"question": "c#汉字转成拼音后如何把声母韵母分开", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "声母数量又不多，穷举之。", "referer": "user-0"}]}
{"question": "在窗口运行不显示！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:把 for(i=0; i=n/2; i++) //不能用=，就算用也应该是== 改成 for(i=0; i<=n/2; i++) //要用<= 是的哈，没注意看。。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把 for(i=0; i=n/2; i++) //不能用=，就算用也应该是== 改成 for(i=0; i<=n/2; i++) //要用<=", "referer": "user-0"}]}
{"question": "求大神帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你这是找打手的节奏呀", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 楼主 一只鸿鹄的回复:用c语言数据结构做一个哈夫曼编译器，要求输入权值，然后对数字进行编译。 要求功能是初始化建立哈弗曼树，编码，译码，退出系统，功能越多越好，这个是最基本的，求大神们帮忙。谢谢。", "referer": "user-0"}]}
{"question": "关于结构体数组，交换顺序问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把struct row *temp; 改成 struct row temp;  把 temp=(p+k); (p+k)=(p+i); (p+i)=temp; 改成 temp=*(p+k); *(p+k)=*(p+i); *(p+i)=temp;  问题原因 (p+k)=(p+i);相当于 &r[k]=&r[i]; r是实参main函数的数组变量， &r[k]是个固定的地址（因为数组的地址是固定的），所以不能改变数组元素的地址，但是可以改变 r[k]，也就是*(p+k)，也就是可以改变数组元素的值。注意其中的区别。", "referer": "user-0"}]}
{"question": "在编译器中运行的结果是对的，但在noi里显示超时，怎么回事？怎么解决？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 赵4老师的回复:#include <stdio.h> int main() {     int n,a,x=1;     scanf(\"%d\",&n);     if(n==1)         printf(\"2\\n\");     else {         while (1) {             if (n-1<=0) break;             x+=2;             a=x;             while (1) {                 if (n-1<=0) break;                 a--;                 if(x%a==0)                     break;                 else {                     if(a==2) {                         n--;                         break;                     } else                         continue;                 }             }         }         printf(\"%d\\n\",x);     }     return 0; }  可以问一下，为什么要这样改吗", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include <stdio.h> int main() {     int n,a,x=1;     scanf(\"%d\",&n);     if(n==1)         printf(\"2\\n\");     else {         while (1) {             if (n-1<=0) break;             x+=2;             a=x;             while (1) {                 if (n-1<=0) break;                 a--;                 if(x%a==0)                     break;                 else {                     if(a==2) {                         n--;                         break;                     } else                         continue;                 }             }         }         printf(\"%d\\n\",x);     }     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:无代码没么回答 #include <stdio.h> int main() { int n,a,x=1; scanf(\"%d\",&n); if(n==1) printf(\"2\"); else { while(n-1>0) { x+=2; a=x; while(n-1>0) { a--; if(x%a==0) break; else { if(a==2) { n--; break; } else continue; } } }     printf(\"%d\",x); } return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "无代码没么回答", "referer": "user-0"}]}
{"question": "请问，怎么将输入的整型值转换为字符串输出呢？ 老师还说，不许用if，只许用一次循环", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "snprintf试试", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int main() {     int i, n;     char s[16];     scanf(“%d”, &n);     s[15]=‘\\0’;     for (i=14; n>1; i--, n/=10) {         s[i]=‘0’+(n%10);     }     s[i]=‘0’+n;     printf(“%s”, s+i);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "连一次循环都不用： chat b[64]; sprintf(b,\"%d\",123456); 在b中存放的就是", "referer": "user-0"}]}
{"question": "二进制算法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "类似汇编这玩意： 加法：每次加法，考虑一下进位就行。 减法：转为加法做。 乘法：转为上述方法及移位操作。 除法：转为上述方法。即使除不尽，也可以得到商和余数。", "referer": "user-0"}]}
{"question": "请教下C语言使用regex库正则筛选连续数字/字母的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢，C++的是可以了。我自己研究下C有没有办法吧。看看有没有办法解决第二个问题。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "再供参考：#include <iostream> #include <string> #include <regex> using namespace std; int main() {     string s(\"we12312332qwwww  d1246Xdes\");     cout << s << endl;     cout << \"----\" << endl;     regex e(\"[0-9]{4}\");     smatch m;     while (regex_search (s,m,e)) {         cout << m.str() << endl;         s = m.suffix().str();     }     return 0; } //we12312332qwwww  d1246Xdes //---- //1231 //2332 //1246 //  正则表达式速查 正则表达式举例 正则表达式学习 (4页A4纸)http://download.csdn.net/detail/zhao4zhong1/1808549", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:仅供参考：#include <iostream> #include <string> #include <regex> using namespace std; int main() {     string s(\"deabc\\ndeab\\ndefabc\");     cout << s << endl;     cout << \"----\" << endl;     regex e(\"abc$\");     smatch m;     while (regex_search (s,m,e)) {         cout << m.str() << endl;         s = m.suffix().str();     }     return 0; } //deabc //deab //defabc //---- //abc //abc //  引用 2 楼 赵4老师 的回复:仅供参考：#include <iostream> #include <string> #include <regex> using namespace std; int main() {     string s(\"deabc\\ndeab\\ndefabc\");     cout << s << endl;     cout << \"----\" << endl;     regex e(\"abc$\");     smatch m;     while (regex_search (s,m,e)) {         cout << m.str() << endl;         s = m.suffix().str();     }     return 0; } //deabc //deab //defabc //---- //abc //abc //   谢谢回复，不过我需要用C语言实现，没法直接用regex库，是额外导入的。还有就是我按照您的代码替换了文本和正则表达式，结果和我之前差不多，第一串数字是一整串出来的。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "仅供参考：#include <iostream> #include <string> #include <regex> using namespace std; int main() {     string s(\"deabc\\ndeab\\ndefabc\");     cout << s << endl;     cout << \"----\" << endl;     regex e(\"abc$\");     smatch m;     while (regex_search (s,m,e)) {         cout << m.str() << endl;         s = m.suffix().str();     }     return 0; } //deabc //deab //defabc //---- //abc //abc //", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "没人会吗。。。", "referer": "user-0"}]}
{"question": "C指针", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "棒棒哒哒哒哒", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//对于字符串“abcdefghijklmn”，读入两个数字，比如begin、num，假定begin为1，num为5， //则动态申请内存，存放子串“bcdef”，最后输出该子串。 //简化起见，假定begin、num都在有效范围内。设计main函数, 同时要展示出字符串和动态内存的地址 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <malloc.h> int main() {     char *s=\"abcdefghijklmn\";     int begin,num;     char *p;      scanf(\"%d%d\",&begin,&num);     p=(char *)malloc(num+1);     if (NULL==p) {         printf(\"Can not malloc(%d bytes)!\\n\",num+1);         return 1;     }     strncpy(p,s+begin,num);     p[num]=0;     printf(\"%s\\n\",p);     printf(\"0x%p\\n\",p);     free(p);      return 0; } //输入 //1 5 //输出 //bcdef //0x012DDC38 //", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "char* func(char* str,int begin,int num) {    char* result = (char*)malloc(sizeof(char)*(num+1));    memcpy(result,str+begin,sizeof(char)*num);    result[num]='\\0'; return result; }", "referer": "user-0"}]}
{"question": "各位大佬，C语言，帮忙看看呗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "类似，只要把输出条件修改为>1即可，再加判断输入是否合法。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include<stdio.h>  int main(int argc, char* argv[]) {       int n,i,flag=1;       int a[10]={0};         scanf(\"%d\",&n);        if(n>9999999 || n<=0) {           printf(\"Invalid input\");           return 1;        }         while(n!=0)           {             a[n%10]++;             n /= 10;           }        for(i=0;i<10;i++)            if(a[i]>1){               flag = 0;               printf(\" %d\",i);            }        if(flag) printf(\"No repeated number.\\n\");        return 0; }", "referer": "user-0"}]}
{"question": "输入若干个字符，统计各英文字母出现的次数。（字母区分大小写字母）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> int main(int argc, char* argv[]) {     char c[100];     int a[26]={0},A[26]={0},flag=0,i=0;     gets(c);     while( c[i] != '\\0'){                       //while((c = getchar()) != '\\n'){           if(c[i] >= 'a' && c[i] <= 'z')               {a[c[i]-'a']++;flag=1;}          //a[0]对应保存小写字母出现的次数           if(c[i] >= 'A' && c[i] <= 'Z')               {A[c[i]-'A']++;flag=1;}          //A[0]对应保存大写字母出现的次数           i++;     }     for(int i=0;i<26;i++)         if(a[i] != 0)          printf(\"%c->%d\\n\",'a'+i,a[i]);     for(int i=0;i<26;i++)        if(A[i] != 0)          printf(\"%c->%d\\n\",'A'+i,A[i]);     if(!flag) printf(\"No letter!\");       return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考：#include <stdio.h> int main(int argc, char* argv[]) {     char c;     int a[26]={0},A[26]={0};      while((c = getchar()) != '\\n'){           if(c >= 'a' && c <= 'z') a[c-'a']++;//a[0]对应保存小写字母出现的次数           if(c >= 'A' && c <= 'Z') A[c-'A']++;//A[0]对应保存大写字母出现的次数     }     for(int i=0;i<26;i++)         if(a[i] != 0)          printf(\"%c->%d\\n\",'a'+i,a[i]);     for(int i=0;i<26;i++)        if(A[i] != 0)          printf(\"%c->%d\\n\",'A'+i,A[i]); }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 ctrigger的回复:#include <stdio.h>  int is_alpha(int c) { \treturn ((c > 'a' && c < 'z') || (c > 'A' && c < 'Z')); }  int main(void) { \tint c, i, size; \tint result[128] = { 0 }; \tsize = 100; \t \twhile(size-- && ((c = getchar()) != '\\n')) \t{ \t\tif(is_alpha(c)) result[c]++; \t} \t \tfor(i = 0; i < 128; i++) \t{ \t\tif(is_alpha(i) && result[i]) \t\t{ \t\t\tprintf(\"%c -> %d\\n\", i, result[i]); \t\t} \t} \treturn 0; }  抱歉，我还是看不懂", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考： #include <stdio.h> #include <ctype.h>  int main(void) { \tchar buf[101]; \tint result[128] = { 0 }, i = 0; \tfgets(buf, sizeof(buf), stdin); \twhile(buf[i]) \t{ \t\tif(isalpha(buf[i])) result[buf[i]]++; \t\ti++; \t} \tfor(i = 0; i < 128; i++) \t{ \t\tif(isalpha(i) && result[i]) \t\t{ \t\t\tprintf(\"%c -> %d\\n\", i, result[i]); \t\t} \t} \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "#include <stdio.h>  int is_alpha(int c) { \treturn ((c > 'a' && c < 'z') || (c > 'A' && c < 'Z')); }  int main(void) { \tint c, i, size; \tint result[128] = { 0 }; \tsize = 100; \t \twhile(size-- && ((c = getchar()) != '\\n')) \t{ \t\tif(is_alpha(c)) result[c]++; \t} \t \tfor(i = 0; i < 128; i++) \t{ \t\tif(is_alpha(i) && result[i]) \t\t{ \t\t\tprintf(\"%c -> %d\\n\", i, result[i]); \t\t} \t} \treturn 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "类似，全部输出即可，只是数组要创建2倍以区分大小写，对于大小写对应序进行处理即可实现。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:供参考： #include <stdio.h> #include <ctype.h>  int main(void) { \tchar buf[101]; \tint result[128] = { 0 }, i = 0; \tfgets(buf, sizeof(buf), stdin); \twhile(buf[i]) \t{ \t\tif(isalpha(buf[i])) result[buf[i]]++; \t\ti++; \t} \tfor(i = 0; i < 128; i++) \t{ \t\tif(isalpha(i) && result[i]) \t\t{ \t\t\tprintf(\"%c -> %d\\n\", i, result[i]); \t\t} \t} \treturn 0; }  我还没学到ctype", "referer": "user-0"}]}
{"question": "麻烦大佬帮忙看一下这个题我该怎么做", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "你的是对的！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "运行出来不对，是一串数字。printf要是在for循环里边那就是不停地输出数字", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 楼主 恶魔妈妈买面膜1的回复:#include<stdio.h>  int main() {     int a=1,b=1,c=1,i,j,k;     for(a; a<10; a++)     {         for(b; b<10; b++)         {   for(c; c<10; c++)                 if(100*a+10*b+c+100*c+10*b+a==1333&&a>0)                     i=a;             j=b;             c=k;         }     }       printf(\"a=%d，b=%d，c=%d\",i,j,k); } 你可以试试这个 #include <stdio.h> void main() { \tint a,b,c; \tfor(a=1;a<10;a++) \t{ \t\tfor(b=1;b<10;b++) \t\t{ \t\t\tfor(c=1;c<10;c++) \t\t\t{ \t\t\t\tif(a*100+b*10+c+c*100+b*10+a==1333) \t\t\t\t\tprintf(\"%d,%d,%d \",a,b,c); \t\t\t} \t\t} \t} }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "供参考  void test() {     int a, b, c;     for (a = 0; a < 10; a++)     {         for (b = 0; b < 10; b++)         {             for (c = 0; c < 10; c++)             {                 if (100 * a + 10 * b + c + 100 * c + b * 10 + a == 1333 )                     printf(\"a=%d, b=%d,c=%d\\n\", a, b, c);             }         }     } }", "referer": "user-0"}]}
{"question": "请教一个简单算法。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  int a,b;  int main() { \tprintf(\"请输入20-120中任意一个值：\"); \tscanf_s(\"%d\", &a);         b = ((a - 20) / 100.0 + 0.002) * 255;          //b = ((a - 20) + 0.2) * (255 / 100.0); \tprintf(\"%d\\n\", b); \tsystem(\"pause\"); \treturn 0; } b是整数型，自动就把小数点后面的去掉了，前面加的0.002*255就相当于四舍五入了 { double a=1.6; int b=a+0.5,c=a; } 输出结果是b为2，c为1；", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "麻烦把b也四舍五入一下，怎么写？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "b=((a-20)/100.0+0.001)*255;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "是这个意思吗？   int fun(int n) {     return (int)((n-20)*255.0/(120-20)+0.5); } int main( ) {     int i;     for(i=20; i<=120; i++) {         printf(\"%d:%d\\n\", i, fun(i));     }     return 0; }", "referer": "user-0"}]}
{"question": "已知两个升序数组，将它们合并成一个升序数组并输出。例如：数组array1={3,6,13,35,54}，数组array2={14,19,26,32}， 合并为新", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 ctrigger的回复:标准归并排序，高效，复杂度是0（n）。 唉， 听不懂你说的是什么意思？可以帮我敲一下，让我看看吗？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "标准归并排序，高效，复杂度是0（n）。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 智者知已应修善业的回复:用归并排序或插入排序即可可参 代码怎么敲？不会我", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "用归并排序或插入排序即可可参", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "d++是先得出结果再自增的，++d是先自增再得结果。", "referer": "user-0"}]}
{"question": "c语言求助 求10*10第n对角线的和", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 俺是阿丰的回复:很像今年下半年的蓝桥杯的题 现在有答案了 你可以参考 谢谢一开始我没理解清题目的意思，现在搞明白了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "很像今年下半年的蓝桥杯的题 现在有答案了 你可以参考", "referer": "user-0"}]}
{"question": "输入年份和月份，计算这一年这个月有多少天。（查错）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "闰年判断条件有问题，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int year = 0,month = 0;     int days[]={31,28,31,30,31,30,31,31,30,31,30,31};     int day;     while(scanf(\"%d %d\",&year,&month) != EOF)     {          if((year %4 ==0 && year % 100 !=0) || year % 400 ==0)         //if(year % 4 == 0 || (year % 4 == 0 && year % 100 != 0))    //某年为闰年         {             if(month != 2){                 day = days[month - 1];                 printf(\"%d\",day);             }             else{                 day = 29;                 printf(\"%d\",day);             }         }         else        //某年为平年         {             day = days[month - 1];             printf(\"%d\",day);         }     }    // system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h>  int main() {     int year = 0,month = 0;     int days[]={31,28,31,30,31,30,31,31,30,31,30,31};     int day;     while(scanf(\"%d %d\", &year,&month) != EOF)     {         //if(year % 4 == 0 || (year % 4 == 0 && year % 100 != 0))    //某年为闰年         if(year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))    //某年为闰年         {             if (month != 2) {                 day = days[month - 1];                 printf(\"%d\",day);             }             else {                 day = 29;                 printf(\"%d\",day);             }         }         else        //某年为平年         {             day = days[month - 1];             printf(\"%d\",day);         }     }     return 0; } 供参考～", "referer": "user-0"}]}
{"question": "请大神解救下C言语题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "对不起，是我天真了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "结构体存储学生信息，然后用链表链起来  遍历不及格学生写入文件  按行读文件，再组装下输出  最重要的：代码要自己写", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 1 楼 bluefishLTJ 的回复:有没有大哥帮帮忙 自己先试试，不尝试什么也不知道，什么也学不到。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "好好做作业.", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "有没有大哥帮帮忙", "referer": "user-0"}]}
{"question": "7-2 房屋分拆 (20分", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "18=9，9；9=4，5；9=4，5；5=2，3；4=2，2；2=1，1；2=1，1；18，9，9，5，4，2，2=49", "referer": "user-0"}]}
{"question": "\\(^o^)/@_@各位哥哥姐姐们，关于指针的类型转换及运算的问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "函数返回值是个地址，那么你截取了该地址的低8位。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "首先，指针的值就是地址，地址就是的无符号int类型 char c=‘a'; //c是字符，可以转成int void* p=(void*)(unsigned int)c; 把c转成无符号int（上面说了，其实就是地址），再把地址转成指针p 那么这样转出来的p怎么还原回c 那自然就是 char cc =(char)(unsigned int)p 把p指针转成地址（无符号int），再把int转成char就可以了", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "但语义上制造空的死循环就没啥价值了。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "语法肯定是合的，制造死循环嘛，等价于while(1);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "合法，表示一个无限空循环", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:合法，表示一个无限空循环 把括号外面的分号去掉可以吗", "referer": "user-0"}]}
{"question": "重积分求代码，怎样更简单？？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "为啥是两个分号啊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "for example int main( ) {     int i;     for(i=1; ; i++) {         if ((9*i+6)%7==1) {             printf(\"%d\\n\", 9*i+6);             break; //找到就退出循环         }         if (9*i+6<0) break; // 防止死循环，越界就证明无解     }     if(9*i+6<0) {         printf(\"无解\\n\");     }     return 0; }", "referer": "user-0"}]}
{"question": "输入n科成绩（浮点数表示），统计其中的最高分，最低分以及平均分。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "再精炼点，少用几个for:#include <stdio.h> int main(int argc, char* argv[]) {     int n;     int i;//循环变量     float max;         //max = -1;     float min ;        //min = 101;     float score[5] = {0};//score[5] = {};初始化为0     float avg = 0;                       //scanf(\"%d\",&n);  这句没什么用，放这里输入n，但没用到n     for(i = 0; i < 5; i++)     {          scanf(\"%f\",&score[i]);//scanf(\"%f\",score);     }      min=max=score[0];//max min 初始化放在这里     for(i = 0; i < 5;i++)     {         if(max < score[i])         {             max = score[i];         }                             //}                            //for(i = 0; i < 5 ;i++)                            // {         if(min > score[i])         {             min = score[i];         }                          //}                         // for(i = 0; i < 5; i++)                         //{         avg += score[i];     }     printf(\"max=%.2f  min=%.2f   avg=%.2f\\n\",max,min,avg/5);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "修改如下，供参考，希望能帮到你：#include <stdio.h> int main(int argc, char* argv[]) {     int n;     int i;//循环变量     float max;         //max = -1;     float min ;        //min = 101;     float score[5] = {0};//score[5] = {};初始化为0     float avg = 0;                       //scanf(\"%d\",&n);  这句没什么用，放这里输入n，但没用到n     for(i = 0; i < 5; i++)     {          scanf(\"%f\",&score[i]);//scanf(\"%f\",score);     }      min=max=score[0];//max min 初始化放在这里     for(i = 0; i < 5;i++)     {         if(max < score[i])         {             max = score[i];         }                             //}                            //for(i = 0; i < 5 ;i++)                            // {         if(min > score[i])         {             min = score[i];         }     }     for(i = 0; i < 5; i++)     {         avg += score[i];     }     printf(\"max=%.2f  min=%.2f   avg=%.2f\\n\",max,min,avg/5);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "把scanf(“%f”, score)改成 scanf(“%f”, &score[i])", "referer": "user-0"}]}
{"question": "请教一下大佬这个位置为什么报错呀？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改如下，void sort1(int p[], int left, int right)这个函数只排除语法错误，逻辑没调试，供参考：#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> void reverse(int p[],int left,int right)//使数据颠倒顺序 {     int temp;     while (left < right)       {          temp     = p[left];          p[left]  = p[right];          p[right] = temp;          left++;     //right++; left++;       } }  void sort1(int p[], int left, int right)//将一组正...正负...负的数顺序换位 {     int i=0;     reverse(p, left, right);//reverse(*p, left, right);     while (p[i] < 0) { i++;}     reverse(p, left, i - 2);//reverse(*p, left, i - 2);     reverse(p, i - 1, right);//reverse(*p, i - 1, right); }  void CompletelySort(int* p, int left, int right)//将整个数组排为负数在前，正数在后且不改变原来顺序的数组 {     int j;// i=0     while (left < (right-1)/2) //while (left < right)       {         j=0;         while(p[left]<0){left++;}           //while (p[left++] > 0) { ; }                                            //left = left - 1;         j = left;                          //j += left;         while(p[j]>0 && j < right-1){j++;} //(p[j++] < 0) { ; }         reverse(p, left, j);            //reverse(*p, left, j - 2);         left++;       } }  int main(int argc, char* argv[]) {     int a[] = {1,2,-3,4,-6,-7,9,-10,7,22,-78};     int right = sizeof(a)/sizeof(int);      //sizeof(a)/sizeof(int)-1;     for (int i = 0; i < right; i++)        {          printf(\"%d  \", a[i]);        }     printf(\"\\n\");     CompletelySort(a, 0, right);     for (int i = 0; i < right;i++)       {         printf(\"%d  \",a[i]);//printf(\"\\n%d   \",a[i]);       }     printf(\"\\n\");     //system(\"pause\");     return 0; } 运行：", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "right--; left++;", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "大概溜一眼代码，感觉问题不少 reverse函数while循环应该是right--，left++，否则就死循环了 reverse函数调用函数地方reverse(*p,left,right)要改成reverse(p,left,right)，注意参数*p和p的区别 剩下一就没细看了", "referer": "user-0"}]}
{"question": "这个幻方的程序为什么⊙∀⊙？错了，新手求教π_π", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:没发现什么问题啊，楼主想实现什么效果呢？#include <stdio.h> #include <stdlib.h> int main(int argc, char* argv[]) {     int a[39][39]={0},i,j,n,k,c,b;     k=0;     scanf(\"%d\",&n);      for(i=0;i<n;i++)       for(j=0;j<n;j++)       {         k++;         if(k==1)             a[0][(n-1)/2]=k;         else           {             for(i=0;i<n;i++)                for(j=0;j<n;j++)                   if(a[i][j]==k-1)                    {                      c=i;                      b=j;                   }                  if(c==0&&b!=n-1)                     a[n-1][b+1]=k;                  else if(c!=0&&b==n-1)                            a[c-1][0]=k;                      else if(c==0&&b==n-1)                               a[c+1][b]=k;                           else                              {                               if(a[c-1][b+1]==0)                                   a[c-1][b+1]=k;                               else                                   a[c+1][b]=k;                              }           }       }     for(i=0;i<n;i++)         for(j=0;j<n;j++)         {             if(j!=n-1)                 printf(\"%d \",a[i][j]);             else                 printf(\"%d\\n\",a[i][n-1]);         }     return 0; } 那个输出好像是错的", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "那个输出好像是错误的", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "没发现什么问题啊，楼主想实现什么效果呢？#include <stdio.h> #include <stdlib.h> int main(int argc, char* argv[]) {     int a[39][39]={0},i,j,n,k,c,b;     k=0;     scanf(\"%d\",&n);      for(i=0;i<n;i++)       for(j=0;j<n;j++)       {         k++;         if(k==1)             a[0][(n-1)/2]=k;         else           {             for(i=0;i<n;i++)                for(j=0;j<n;j++)                   if(a[i][j]==k-1)                    {                      c=i;                      b=j;                   }                  if(c==0&&b!=n-1)                     a[n-1][b+1]=k;                  else if(c!=0&&b==n-1)                            a[c-1][0]=k;                      else if(c==0&&b==n-1)                               a[c+1][b]=k;                           else                              {                               if(a[c-1][b+1]==0)                                   a[c-1][b+1]=k;                               else                                   a[c+1][b]=k;                              }           }       }     for(i=0;i<n;i++)         for(j=0;j<n;j++)         {             if(j!=n-1)                 printf(\"%d \",a[i][j]);             else                 printf(\"%d\\n\",a[i][n-1]);         }     return 0; }", "referer": "user-0"}]}
{"question": "有人接单写个简单的c语言代码吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "百度这种示例代码一堆", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "就是读文件呗，到处都是教程", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "直接把需求发出来不行？", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "某度不就行了", "referer": "user-0"}]}
{"question": "C语言编译过程出现这种问题是怎么回事啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "重新编译前务必关掉运行窗口", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码呢？没看到你完整的代码呢？", "referer": "user-0"}]}
{"question": "大一C语言作业问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <stdio.h> int main(int argc, char* argv[]) {     char *s = new char[100],*t = new char[10],*str = new char[10],*temp = new char[100];     char *p,*q,*pos;      gets(s);     gets(t);     gets(str);      p=s;     q=temp;     while(*p != '\\0')     {          pos = str;          if(*p == *t){             while(*p == *t && *t != '\\0'){               p++;               t++;             }             while(*pos != '\\0'){                *q++ = *pos++;             }          }          *q = *p;          q++;          p++;     }     *q = '\\0';      strcpy(s,temp);     printf(\"%s\\n\",s);      system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": "求大佬帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "打印的东西最好是返回值  int process (int x, int y, int (*f)(int, int)) {     return f(x, y); }  //main改成 printf(\"max=%d\", process(a,b,max)); printf(\"\\nmin=%d\", process(a,b,min)); printf(\"\\nadd=%d\", process(a,b,add));", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "process函数，用一个f就可以了。m = f(x, y); p,q做啥呢？ 根据process传进来不同的函数名，f执行不同的函数体。因此p,q没必要，再说用了p,q这两个函数的返回值做啥用了？    void process (int x, int y, int (*f)(int, int)) {     int w = f(x, y);    printf(\"%d\\n\", w); } 这个函数执行几条语句就可以了，试试～", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "x<y<z 由于x<y是假的，结果为0，整个表达式变成 0<z 这个是真的，结果为1  另一个类似。", "referer": "user-0"}]}
{"question": "简易计算器", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "大道至简计算器：#pragma warning(disable:4996) /*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console) 功能： 目前提供了10多个常用数学函数: ⑴正弦sin ⑵余弦cos ⑶正切tan ⑷开平方sqrt ⑸反正弦arcsin ⑹反余弦arccos ⑺反正切arctan ⑻常用对数lg ⑼自然对数ln ⑽ｅ指数exp ⑾乘幂函数^ ⑿向上取整ceil ⒀向下取整floor ⒁四舍五入取整round ⒂取符号sign ⒃取绝对值abs 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率Pi键入字母时不区分大小写,以方便使用。 16进制整数以0x或0X开头。 ----------------------------------------*/ #include <iostream> #include <iomanip> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <stdio.h> #include <string.h> #include <windows.h> using namespace std; const char Tab = 0x9; const int  DIGIT = 1; const int MAXLEN = 16384; char s[MAXLEN], *endss; int pcs = 15; double sign(double dVal) {          if (dVal>0.0) return  1.0;     else if (dVal<0.0) return -1.0;     else               return  0.0; } double round(double dVal, short iPlaces) {//iPlaces>=0     char s[30];     double dRetval;      sprintf(s, \"%.*lf\", iPlaces, dVal);     sscanf(s, \"%lf\", &dRetval);     return (dRetval); } double fun(double x, char op[], int *iop) {     while (op[*iop - 1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>         switch (op[*iop - 1]) {         case  7: x = sin(x);    (*iop)--; break;         case  8: x = cos(x);    (*iop)--; break;         case  9: x = tan(x);    (*iop)--; break;         case 10: x = sqrt(x);   (*iop)--; break;         case 11: x = asin(x);   (*iop)--; break;         case 12: x = acos(x);   (*iop)--; break;         case 13: x = atan(x);   (*iop)--; break;         case 14: x = log10(x);  (*iop)--; break;         case 15: x = log(x);    (*iop)--; break;         case 16: x = exp(x);    (*iop)--; break;         case 17: x = ceil(x);   (*iop)--; break;         case 18: x = floor(x);  (*iop)--; break;         case 19: x = round(x,0);(*iop)--; break;         case 20: x = sign(x);   (*iop)--; break;         case 21: x = fabs(x);   (*iop)--; break;         }     return x; } double calc(char *expr, char **addr) {     static int deep; //递归深度     static char *fname[] = { \"sin\",\"cos\",\"tan\",\"sqrt\",\"arcsin\",\"arccos\",\"arctan\",\"lg\",\"ln\",\"exp\",\"ceil\",\"floor\",\"round\",\"sign\",\"abs\",NULL };     double ST[10] = { 0.0 }; //数字栈     char op[10] = { '+' }; //运算符栈     char c, *rexp, *pp, *pf;     int ist = 1, iop = 1, last, i, n;     __int64 i64;      if (!deep) {         pp = pf = expr;         do {             c = *pp++;             if (c != ' '&& c != Tab)                 *pf++ = c;         } while (c != '\\0');     }     pp = expr;     if ((c = *pp) == '-' || c == '+') {         op[0] = c;         pp++;     }     last = !DIGIT;     while ((c = *pp) != '\\0') {         if (c == '(') {//左圆括弧             deep++;             ST[ist++] = calc(++pp, addr);             deep--;             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             pp = *addr;             last = DIGIT;             if (*pp == '(' || isalpha(*pp) && strnicmp(pp, \"Pi\", 2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }         else if (c == ')') {//右圆括弧             pp++;             break;         }         else if (isalpha(c)) {             if (!strnicmp(pp, \"Pi\", 2)) {                 if (last == DIGIT) {                     wcout <<    L\"π左侧遇）\" << endl; exit(1);                 }                 ST[ist++] = 3.14159265358979323846264338328;                 ST[ist - 1] = fun(ST[ist - 1], op, &iop);                 pp += 2;                 last = DIGIT;                 if (!strnicmp(pp, \"Pi\", 2)) {                     wcout <<    L\"两个π相连\" << endl; exit(2);                 }                 if (*pp == '(') {                     wcout <<    L\"π右侧遇（\" << endl; exit(3);                 }             }             else {                 for (i = 0; (pf = fname[i]) != NULL; i++)                     if (!strnicmp(pp, pf, strlen(pf))) break;                 if (pf != NULL) {                     op[iop++] = 07 + i;                     pp += strlen(pf);                 }                 else {                     wcout <<    L\"陌生函数名\" << endl; exit(4);                 }             }         }         else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '^') {             char cc;             if (last != DIGIT) {                 wcout <<    L\"运算符粘连\" << endl; exit(5);             }             pp++;             if (c == '+' || c == '-') {                 do {                     cc = op[--iop];                     --ist;                     switch (cc) {                     case '+':  ST[ist - 1] += ST[ist]; break;                     case '-':  ST[ist - 1] -= ST[ist]; break;                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 } while (iop);                 op[iop++] = c;             }             else if (c == '*' || c == '/' || c == '%') {             operate:        cc = op[iop - 1];                 if (cc == '+' || cc == '-') {                     op[iop++] = c;                 }                 else {                     --ist;                     op[iop - 1] = c;                     switch (cc) {                     case '*':  ST[ist - 1] *= ST[ist]; break;                     case '/':  ST[ist - 1] /= ST[ist]; break;                     case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;                     case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;                     }                 }             }             else {                 cc = op[iop - 1];                 if (cc == '^') {                     wcout <<    L\"乘幂符连用\" << endl; exit(6);                 }                 op[iop++] = c;             }             last = !DIGIT;         }         else {             if (last == DIGIT) {                 wcout <<    L\"两数字粘连\" << endl; exit(7);             }             if (pp[0] == '0' && (pp[1] == 'x' || pp[1] == 'X')) {                 sscanf(pp + 2, \"%I64x%n\", &i64, &n);                 rexp = pp + 2 + n;                 ST[ist++] = (double)i64;             }             else ST[ist++] = strtod(pp, &rexp);             ST[ist - 1] = fun(ST[ist - 1], op, &iop);             if (pp == rexp) {                 wcout <<    L\"非法字符\" << endl; exit(8);             }             pp = rexp;             last = DIGIT;             if (*pp == '(' || isalpha(*pp)) {                 op[iop++] = '*';                 last = !DIGIT;                 c = op[--iop];                 goto operate;             }         }     }     *addr = pp;     if (iop >= ist) {         wcout <<    L\"表达式有误\" << endl; exit(9);     }     while (iop) {         --ist;         switch (op[--iop]) {         case '+':  ST[ist - 1] += ST[ist]; break;         case '-':  ST[ist - 1] -= ST[ist]; break;         case '*':  ST[ist - 1] *= ST[ist]; break;         case '/':  ST[ist - 1] /= ST[ist]; break;         case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break;         case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break;         }     }     return ST[0]; } int main(int argc, char **argv) {     int a;      wcout.imbue(locale(\"chs\"));     if (argc<2) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         wcout <<    L\"计算函数表达式的值。\" << endl << L\"支持(),+,-,*,/,%,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs\" << endl;         while (1) {             wcout <<    L\"请输入表达式：\";             fgets(s,16384,stdin);             if ('\\n' == s[strlen(s)-1]) s[strlen(s) - 1] = 0;             if (s[0] == 0) break;//             cout << s << \"=\";             cout << setprecision(15) << calc(s, &endss) << endl;         }     }     else if (argc == 2 && 0 == strcmp(argv[1], \"/?\")) {         //if (GetConsoleOutputCP() != 936) system(\"chcp 936>NUL\");//中文代码页         wcout <<    L\"计算由≥1个命令行参数给出的函数表达式的值。\\n\"             \"最后一个参数是.0～.15表示将计算结果保留小数0～15位\\n\"             \"最后一个参数是x表示将计算结果以16进制正整数格式输出\\n\"             \"支持(),+,-,*,/,%,^^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round,sign,abs\\n\"             \"16进制整数以0x或0X开头\\n\";     }     else {         strncpy(s, argv[1], MAXLEN - 1); s[MAXLEN - 1] = 0;         if (argc>2) {             for (a = 2; a<argc - 1; a++) strncat(s, argv[a], MAXLEN - 1);//将空格间隔的各参数连接到s             if (1 == sscanf(argv[a], \".%d\", &pcs) && 0 <= pcs && pcs <= 15) {//最后一个参数是.0～.15表示将计算结果保留小数0～15位                 printf(\"%.*lf\\n\", pcs, calc(s, &endss));             }             else if (argv[a][0] == 'x' || argv[a][0] == 'X') {//最后一个参数是x表示将计算结果以16进制正整数格式输出                 printf(\"0x%016I64x\\n\", (__int64)calc(s, &endss));             }             else {                 strncat(s, argv[a], MAXLEN - 1);                 printf(\"%.15lg\\n\", calc(s, &endss));             }         }         else {             printf(\"%.15lg\\n\", calc(s, &endss));         }     }     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "除法运算注意除数不能为0", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "挺好的，厉害。。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for example  int isPrimeNum(int num) { //判断是否是质数，是返回1，不是返回0     int i;     if (num<2) return 0;     else if (num==2) return 1;     else if (num%2==0) return 0;          for(i=3; i<=num/2; i++) {         if (num%i==0) return 0;     }     return 1; }  int main( ) {     int n, i;     scanf(\"%d\", &n);     if (n<2) return 1;     if (isPrimeNum(n)) { //         printf(\"%d本身是质数，没有质因子。\", n);         return 0;     }     while (!isPrimeNum(n)) { //如果不是质数则一直循环         for(i=2;;i++) {             if (n%i==0) {                 printf(\"%d \", i);                 n /= i;                 break;             }         }     }     printf(\"%d\", n);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这类动手题，最好自己写。有问题再问，效果比较好。 Show一个，仅供参考： #include <stdio.h>  void func(int n) { \tint i, j, flag; \t \tfor(i = 2; i <= n; i++) \t{ \t\tflag = 1; \t\t \t\tfor(j = 2; j <= i / 2; j++) \t\t{ \t\t\tif(n % j == 0) \t\t\t{ \t\t\t\tflag = 0; \t\t\t\tbreak; \t\t\t} \t\t} \t\t \t\tif(flag == 1 && n % i == 0) \t\t{ \t\t\tprintf(\"%d\\t\", i); \t\t\tfunc(n / i); \t\t\tbreak; \t\t} \t} }  int main(void) { \tint n; \tscanf(\"%d\", &n); \t \tfunc(n); \tprintf(\"\\n\"); \t \treturn 0; }", "referer": "user-0"}]}
{"question": "关于C语言内存的一个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "strlen计算依据是判断字符串出现第一个0的位置，  i 是整型32位，char 是8位，赋值时会把整型的高24位舍弃，取第八位，负数用补码表示，-1是0xfffffffff.-2是0xfffffffe,依次到了循环第255次时，低8位正好是00，所以strlen为255", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "因为第一个值为0的a[i],i=0,1,2,...出现在a[255]的位置。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "strlen是寻找第一个值为0的元素的下标。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "因为在255的位置出现了0即'\\0'，strlen是遇到'\\0'返回的", "referer": "user-0"}]}
{"question": "教务管理系统编写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:先总结一下需要那些功能，然后设计一下整个架构，以及把功能细化成一个个的函数～ 准备从班级信息管理，教师信息管理，学生信息管理，课程信息管理，成绩信息管理这几个方向写，", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "先总结一下需要那些功能，然后设计一下整个架构，以及把功能细化成一个个的函数～", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两种方法，供参考：#include <stdio.h> #include <math.h>  bool isPerSqr(int num);//方法1 bool isSqr(int n);//方法2  int main(int argc, char* argv[]) {     int n;     scanf(\"%d\",&n);     if(n < 101 || n > 999) return 1;      for(int i=101;i<=n;i++){         if(isPerSqr(i))             printf(\"[F1].%-4d \",i);         if(isSqr(i))             printf(\"[F2].%-4d \\n\",i);     }     system(\"pause\");     return 0; }  //方法一:不使用sqrt bool isPerSqr(int num) {         int n=num;         for(int i=1; n>0; i+=2){             n -= i;         }         if(n == 0){            int a = num%10;            int b = num/10%10;            int c = num/100;            if(a==b || a==c || b==c) return 1;         }       return 0; }  //方法二:使用sqrt。 bool isSqr(int n) {       int d = (int)(sqrt(n) + 0.5);  //四舍五入求整       if(n == d*d){            int a = n%10;            int b = n/10%10;            int c = n/100;            if(a==b || a==c || b==c) return 1;         }       return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考：#include <stdio.h>  int func(int n) { \tint i, r, a, b, c; \t \tr = 0; \ta = n / 100; \tb = n % 100 / 10; \tc = n % 10; \t \tif(a == b || b == c || c == a) \t{ \t\tfor(i = 10; i <= n/2; i++) \t\t{ \t\t\tif(i * i == n) \t\t\t{ \t\t\t\tr = 1; \t\t\t\tbreak; \t\t\t} \t\t} \t} \t \treturn r; }  int main(void) { \tint n, i; \t \tscanf(\"%d\", &n); \t \tif(n < 101 || n > 999) \t{ \t\tprintf(\"输出有误\\n\"); \t\treturn 1; \t} \t \tfor(i = 101; i <= n; i++) \t{ \t\tif(func(i) == 1) printf(\"%d\\t\", i); \t}  \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "建议自己先试试写吧～", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码是这个： int main(int a,char ** str) { \tint x=2,y=12,z=6; \twhile(x!=y) \t{ \t  x++;z++;y--; \t} \tprintf(\"Q1:z=%d\\n----------\\n\",z);  \tx=2;y=12;z=6; \twhile(x=y) \t{ \t  printf(\"x=%d y=%d z=%d\\n\",x,y,z); \t  x++;z++;y--; \t}  \tprintf(\"Q2:z=%d\\n\",z);  }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "Q1:z=11 ---------- x=12 y=12 z=6 x=11 y=11 z=7 x=10 y=10 z=8 x=9 y=9 z=9 x=8 y=8 z=10 x=7 y=7 z=11 x=6 y=6 z=12 x=5 y=5 z=13 x=4 y=4 z=14 x=3 y=3 z=15 x=2 y=2 z=16 x=1 y=1 z=17 Q2:z=18", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "int main(int a,char ** str) { \tint x=2,y=12,z=6; \twhile(x!=y) \t{ \t  x++;z++;y--; \t} \tprintf(\"z=%d\\n\",z);  \tx=2;y=12;z=6; \twhile(x=y) \t{ \t  x++;z++;y--; \t} \tprintf(\"z=%d\\n\",z);  }   结果：", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "一个等号是赋值，执行到得0为止。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "因为判断的是x = y;表达式，这个表达式为假时退出循环，而假即为0，就是y=0时就是循环的退出条件。所以是y=12循环12次，即z += 12;即18  注意x = y这里是赋值，最终y决定while循环退出～", "referer": "user-0"}]}
{"question": "C和win32的宽字符是否就是UTF-16？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 Intel0011 的回复:1、目前使用4个字节来编码字符足以，Unicode的总量约在110万个字符，现在使用的也就20万左右（不记得在哪看过，不知对否），常用的用两字节存储，不常用的用4字节 2、如你所说，VC10编译器，wchar_t的编码方式是UTF-16LE，GCC下没测试 3、gcc -finput-charset=GBK -fexec-charset=GBK XXX.c  半个月了都，我总算是搞明白了，我把成果跟你说下吧，如果你知道的话，就顺便指个错吧，否则就当查漏补缺吧 关于chs那个，我通过修改系统的设置，然后再查看当前环境名称就得到了，中文简体是Chinese (Simplified)_China.936，语言部分简写可以简写chs、chi等，繁体是Chinese (Traditional)，可简写cht  gcc参数那个，gcc的默认参数（Windows）应该是代码文件-finput-charset=UTF-8，窄字符串-fexec-charset=UTF-8，宽字符串-fwide-exec-charset=UTF16LE，标注的代码文件的编码和窄字符串的编码相同，所以窄字符串没有转码，宽字符串则从UTF-8转到UTF-16LE，但是实际写代码用的GBK（dev），所以汉字的值在UTF-8里就成了错误值，gcc停止编译，-finput-charset=GBK让告诉gcc代码是GBK，于是gcc窄宽字符串分别从GBK->UTF-8、GBK->UTF-16LE。  然后就是printf等函数，会根据控制台的编码来转码，但是需要知道源码和目标编码，它默认的源码是ASCII，超出ASCII的部分应该是无法或没有转码，因此窄字符串的输出是直接给原值 system(\"chcp 54936\"); char str[10]={ 0x81, 0x39, 0xEF, 0x31 }; printf(\"%s\", str ); 这个也没经过转码，该GB18030的编码给了用GB18030的控制台，于是正确显示 而平时控制台的编码是GBK，所以窄字符串从GBK转到UTF-8后，用不会转换的printf输出，然后就乱码了，这时system(\"chcp 65001\")调到一致的UTF-8就可以避免乱码  如果是让printf等函数正常跟随控制台转码，就用setlocale设置，它会设置窄字符串的编码和宽字符串的编码（源），Windows上setlocale一般设不了UTF-8，如果设GBK，就表示printf要将作为源的GBK窄字符串转码到控制台的目标编码，以及UTF-16LE的宽字符串转码到控制台，之前经gcc转码，宽字符串已经是UTF-16LE，但窄字符串是UTF-8，所以用-fexec-charset=GBK让它再转码到GBK，printf函数就能正常转码了，这时修改控制台编码也不会乱码了（除非控制台的编码没有该字符）  之前查好久楞是没怎么明白setlocale的意思，现在想来应该是指示exe中字符串的编码，但表面上设置的是窄编码，实际还隐含设置了宽编码，以及printf输出还有转码功能，没想到这些", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 Intel0011 的回复:1、目前使用4个字节来编码字符足以，Unicode的总量约在110万个字符，现在使用的也就20万左右（不记得在哪看过，不知对否），常用的用两字节存储，不常用的用4字节 2、如你所说，VC10编译器，wchar_t的编码方式是UTF-16LE，GCC下没测试 3、gcc -finput-charset=GBK -fexec-charset=GBK XXX.c  又遇到了一些问题你看看了解吗  一个比较简单的问题是，你知道setlocale的\"chs\"是哪来的吗？微软官网给的是zh_CN，没看到chs  关于gcc -finput-charset=GBK的这个一直没想通，网上说gcc默认UTF-8的代码，但是我GBK的代码文件依然正常编译输出，我猜测是它没有处理，直接把这些字节值编译了，函数最后把这些字节值给了控制台，控制台根据得到的字节值正确显示。而宽字符串L字面量，需要gcc编译时转换为UTF-16LE（发现是编译到汇编码这一步翻译的），这时我用-finput-charset=GBK 告诉它代码是GBK的，于是他正确转换了，但问题也来了，原本的窄字符串由于这个参数输出变成乱码了，显然gcc处理了这个字符串，查看汇编码，它转成了UTF-8，会什么会这样？？之前明明没处理的。还是说，正因为知道了都是GBK，所以它要转换？ -fexec-charset=GBK这个我应该理解了，它应该是又把UTF-8转成了GBK，然后程序给控制台GBK值，于是控制台正确显示。  如果按照前面的理解，那setlocale是不是就成了设置最终目标转码方案的了（-fexec-charset生成到exe的，setlocale指定exe到控制台的编码）？毕竟窄字符串原样给控制台，而宽字符串字面量先从参数告知的GBK转为UTF-16，后又从UTF-16转为setlocale设置的GBK，发给控制台，于是正确显示，但问题也来了，既然告知了代码的编码，以及目标的编码，为啥普通字符串却乱码了？是我对setlocale的理解有误吗？  我用system(\"chcp 54936\") 设置控制台显示编码为GB18030，setlocale( LC_ALL, \"zh_CN.54936\" ) 也设置了GB18030，-fexec-charset=GB18030参数也指定转换目标，但是L宽字符串没有显示出来。此时我用指定字节的方式指定一个GB18030的字符输出： char str[10]={ 0x81, 0x39, 0xEF, 0x31 }; printf(\"%s\", str ); 能正确输出该汉字 然后修改setlocale( LC_ALL, \"chs\" ) ，该汉字乱码了，但是宽字符串却输出了 这又是一个疑惑的地方，\"chs\" 按理说是Chinese Simplified，不应该等同于\"zh_CN.936\"吗？可是设置setlocale( LC_ALL, \"zh_CN.936\" ) ，却依然像之前那样，该汉字正确输出，宽字符串无输出  不知道是哪里理解错了 代码的编码——gcc转换——exe里的字节值——函数根据环境的输出——在控制台上的显示", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 7 楼 Intel0011 的回复:1、目前使用4个字节来编码字符足以，Unicode的总量约在110万个字符，现在使用的也就20万左右（不记得在哪看过，不知对否），常用的用两字节存储，不常用的用4字节 2、如你所说，VC10编译器，wchar_t的编码方式是UTF-16LE，GCC下没测试 3、gcc -finput-charset=GBK -fexec-charset=GBK XXX.c  感谢！感谢！", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 6 楼 六道佩恩 的回复:谢谢你回答这么多 不过看了后我反而有些新的问题了  UTF-16这个编码方式是不是只能保存一百万左右的字符量？以后超出是不是还得用6字节？这个编码方式我感觉还是多字节的那一套，前导字在某个范围时，联合第二个字一起作为一个UNICODE字符，它为什么不将第二个字的使用范围扩大？这么做是不是有什么考量？比如容错？  这句话是不是有问题：“VC10编译器，wchar_t的编码方式是UTF-16BE，而在GCC下是UTF-32BE” Windows上不都是小端序LE吗？而且这个GCC是不是也要看平台？比如Windows平台的GCC测出的是2字节。  网上看到这样一句话：UTF-32编码被提出来了，它的编码值与UCS-4相同，只不过其编码空间被限定在了0~0x10FFFF之间 意思是UTF-32也只保存百万左右的字符数？超过百万也要变长？  我GCC编码宽字符串遇到一个问题，-finput-charset=GBK可以让宽字符串被正确编译和输出，但是普通的字符串却乱码了，你知道是什么原因吗？当前的编写环境是GBK（dev下），setlocale是setlocale( LC_ALL, \"chs\"); 1、目前使用4个字节来编码字符足以，Unicode的总量约在110万个字符，现在使用的也就20万左右（不记得在哪看过，不知对否），常用的用两字节存储，不常用的用4字节 2、如你所说，VC10编译器，wchar_t的编码方式是UTF-16LE，GCC下没测试 3、gcc -finput-charset=GBK -fexec-charset=GBK XXX.c", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 5 楼 Intel0011 的回复:首先，UTF-16并不是固定2字节，UCS-2是固定2字节 Windows平台下默认的Unicode编码为Little Endian的UTF-16 C语言中的wchar_t类型的宽度取决于C实现，在有的平台上它是16位的，而在另一些平台上它是32位的，所以，C11引入了两种更加明确的类型：char16_t和char32_t。 它们是在头文件<uchar.h>中定义的，它们都是无符号整数类型，前者的宽度保证是16个比特，后者的宽度保证是32个比特。 因此，宽字符既可以用wchar_t类型表示，也可以用char16_t或char32_t类型表示。 如果宽字符是用wchar_t类型表示的，则它的编码方式取决于C实现； 如果宽字符是用char16_t类型表示的，且C实现预定义了值为1的宏__STD_UTF_16__，则宽字符的编码方式是UTF-16，如果未定义这个宏，则宽字符的实际编码方式取决于C实现。 如果宽字符是用char32_t类型表示的，且C实现预定义了值为1的宏__STD_UTF_32__，则宽字符的编码方式是UTF-32，如果未定义这个宏，则宽字符的实际编码方式取决于C实现。 VC10编译器，wchar_t的编码方式是UTF-16BE，而在GCC下是UTF-32BE。 wchar_t的目的是编码并存储所有字符集，编码方式和存储空间大小和语言无关，只和编译器有关，因此说wchar_t的编码方式是Unicode是错的。  1990年就公布了第一套编码方法UCS-2，使用2个字节表示已经有码点的字符。 (那个时候只有一个平面，就是基本平面，所以2个字节就够用了) 但俩个字节并不足以正真地\"一统江湖\"(a fixed-width 2-byte encoding could not encode enough characters to be truly universal)， 于是UTF-16诞生了，与UCS-2一样，它使用两个字节为全世界最常用的63K字符编码，不同的是，它使用4个字节对不常用的字符进行编码。UTF-16属于变长编码。  UTF-16编码迟至1996年7月才公布，明确宣布是UCS-2的超集，即基本平面字符沿用UCS-2编码，辅助平面字符定义了4个字节的表示方法。 两者的关系简单说，就是UTF-16取代了UCS-2，或者说UCS-2整合进了UTF-16。所以，现在只有UTF-16，没有UCS-2。  UTF-16 UFT-16比较奇葩，它使用2个或者4个字节来存储。 BMP平面(也就是前面说的基本多文种平面)中的每一个码点都直接与一个UTF-16的码元一一映射。 由于BMP几乎包括了所有常见字符，UTF-16一般需要UTF-32大约一半的空间。至于其它平面里很少使用的码点都是用两个16位的码元来编码的。  对于Unicode编号范围在0~FFFF之间的字符，UTF-16使用两个字节存储，并且直接存储Unicode编号，不用进行编码转换，这跟UTF-32非常类似。 对于Unicode编号范围在10000~10FFFF之间的字符，UTF-16使用四个字节存储， 具体来说就是：将字符编号的所有比特位分成两部分，较高的一些比特位用一个值介于D800~DBFF之间的双字节存储， 较低的一些比特位(剩下的比特位)用一个值介于DC00~DFFF之间的双字节存储。 如果你不理解什么意思，请看下面的表格：  Unicode 编号范围(十六进制)      具体的Unicode编号(二进制)    UTF-16编码                                                 编码后的字节数 0000 0000 ~ 0000 FFFF\t         xxxxxxxx xxxxxxxx\t               xxxxxxxx xxxxxxxx\t                                     2 0001 0000 ~ 0010 FFFF\t         yyyy yyyy yyxx xxxx xxxx      110110yy yyyyyyyy 110111xx xxxxxxxx \t 4 位于D800~0xDBFF之间的Unicode编码是特别为四字节的UTF-16编码预留的，所以不应该在这个范围内指定任何字符。 如果你真的去查看Unicode字符集，会发现这个区间内确实没有收录任何字符。 UTF-16要求在制定Unicode字符集时必须考虑到编码问题，所以真正的Unicode字符集也不是随意编排字符的。  UTF-16并不是一个完美的选择，它存在几个方面的问题： 1. UTF-16能表示的字符数有6万多，看起来很多，但是实际上目前Unicode5.0收录的字符已经达到99024个字符，早已超过UTF-16的存储范围；     这直接导致UTF-16地位颇为尴尬——如果谁还在想着只要使用UTF-16就可以高枕无忧的话，恐怕要失望了。---> 这里实际上说的是UCS-2 2. UTF-16存在大小端字节序问题，这个问题在进行信息交换时特别突出——如果字节序未协商好，将导致乱码；     如果协商好，但是双方一个采用大端一个采用小端，则必然有一方要进行大小端转换，性能损失不可避免     (大小端问题其实不像看起来那么简单，有时会涉及硬件、操作系统、上层软件多个层次，可能会进行多次转换) 3. 另外，容错性低有时候也是一大问题——局部的字节错误，特别是丢失或增加可能导致所有后续字符全部错乱，     错乱后要想恢复，可能很简单，也可能会非常困难。(这一点在日常生活里大家感觉似乎无关紧要，但是在很多特殊环境下却是巨大的缺陷)  目前支撑我们继续使用UTF-16的理由主要是考虑到它是双字节的，在计算字符串长度、执行索引操作时速度很快。 当然这些优点UTF-32都具有，但很多人毕竟还是觉得UTF-32太占空间了。  谢谢你回答这么多 不过看了后我反而有些新的问题了  UTF-16这个编码方式是不是只能保存一百万左右的字符量？以后超出是不是还得用6字节？这个编码方式我感觉还是多字节的那一套，前导字在某个范围时，联合第二个字一起作为一个UNICODE字符，它为什么不将第二个字的使用范围扩大？这么做是不是有什么考量？比如容错？  这句话是不是有问题：“VC10编译器，wchar_t的编码方式是UTF-16BE，而在GCC下是UTF-32BE” Windows上不都是小端序LE吗？而且这个GCC是不是也要看平台？比如Windows平台的GCC测出的是2字节。  网上看到这样一句话：UTF-32编码被提出来了，它的编码值与UCS-4相同，只不过其编码空间被限定在了0~0x10FFFF之间 意思是UTF-32也只保存百万左右的字符数？超过百万也要变长？  我GCC编码宽字符串遇到一个问题，-finput-charset=GBK可以让宽字符串被正确编译和输出，但是普通的字符串却乱码了，你知道是什么原因吗？当前的编写环境是GBK（dev下），setlocale是setlocale( LC_ALL, \"chs\");", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "在目前的windows语境下，是。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用 楼主 六道佩恩 的回复:UTF-8、多字节编码都是8位编码，UTF-32又是4字节，固定2字节一个字符的只想到了UTF-16和UCS-2，但UCS-2的字符集又不全，是不是说，C和win32的宽字符是否就是UTF-16？ 首先，UTF-16并不是固定2字节，UCS-2是固定2字节 Windows平台下默认的Unicode编码为Little Endian的UTF-16 C语言中的wchar_t类型的宽度取决于C实现，在有的平台上它是16位的，而在另一些平台上它是32位的，所以，C11引入了两种更加明确的类型：char16_t和char32_t。 它们是在头文件<uchar.h>中定义的，它们都是无符号整数类型，前者的宽度保证是16个比特，后者的宽度保证是32个比特。 因此，宽字符既可以用wchar_t类型表示，也可以用char16_t或char32_t类型表示。 如果宽字符是用wchar_t类型表示的，则它的编码方式取决于C实现； 如果宽字符是用char16_t类型表示的，且C实现预定义了值为1的宏__STD_UTF_16__，则宽字符的编码方式是UTF-16，如果未定义这个宏，则宽字符的实际编码方式取决于C实现。 如果宽字符是用char32_t类型表示的，且C实现预定义了值为1的宏__STD_UTF_32__，则宽字符的编码方式是UTF-32，如果未定义这个宏，则宽字符的实际编码方式取决于C实现。 VC10编译器，wchar_t的编码方式是UTF-16BE，而在GCC下是UTF-32BE。 wchar_t的目的是编码并存储所有字符集，编码方式和存储空间大小和语言无关，只和编译器有关，因此说wchar_t的编码方式是Unicode是错的。  1990年就公布了第一套编码方法UCS-2，使用2个字节表示已经有码点的字符。 (那个时候只有一个平面，就是基本平面，所以2个字节就够用了) 但俩个字节并不足以正真地\"一统江湖\"(a fixed-width 2-byte encoding could not encode enough characters to be truly universal)， 于是UTF-16诞生了，与UCS-2一样，它使用两个字节为全世界最常用的63K字符编码，不同的是，它使用4个字节对不常用的字符进行编码。UTF-16属于变长编码。  UTF-16编码迟至1996年7月才公布，明确宣布是UCS-2的超集，即基本平面字符沿用UCS-2编码，辅助平面字符定义了4个字节的表示方法。 两者的关系简单说，就是UTF-16取代了UCS-2，或者说UCS-2整合进了UTF-16。所以，现在只有UTF-16，没有UCS-2。  UTF-16 UFT-16比较奇葩，它使用2个或者4个字节来存储。 BMP平面(也就是前面说的基本多文种平面)中的每一个码点都直接与一个UTF-16的码元一一映射。 由于BMP几乎包括了所有常见字符，UTF-16一般需要UTF-32大约一半的空间。至于其它平面里很少使用的码点都是用两个16位的码元来编码的。  对于Unicode编号范围在0~FFFF之间的字符，UTF-16使用两个字节存储，并且直接存储Unicode编号，不用进行编码转换，这跟UTF-32非常类似。 对于Unicode编号范围在10000~10FFFF之间的字符，UTF-16使用四个字节存储， 具体来说就是：将字符编号的所有比特位分成两部分，较高的一些比特位用一个值介于D800~DBFF之间的双字节存储， 较低的一些比特位(剩下的比特位)用一个值介于DC00~DFFF之间的双字节存储。 如果你不理解什么意思，请看下面的表格：  Unicode 编号范围(十六进制)      具体的Unicode编号(二进制)    UTF-16编码                                                 编码后的字节数 0000 0000 ~ 0000 FFFF\t         xxxxxxxx xxxxxxxx\t               xxxxxxxx xxxxxxxx\t                                     2 0001 0000 ~ 0010 FFFF\t         yyyy yyyy yyxx xxxx xxxx      110110yy yyyyyyyy 110111xx xxxxxxxx \t 4 位于D800~0xDBFF之间的Unicode编码是特别为四字节的UTF-16编码预留的，所以不应该在这个范围内指定任何字符。 如果你真的去查看Unicode字符集，会发现这个区间内确实没有收录任何字符。 UTF-16要求在制定Unicode字符集时必须考虑到编码问题，所以真正的Unicode字符集也不是随意编排字符的。  UTF-16并不是一个完美的选择，它存在几个方面的问题： 1. UTF-16能表示的字符数有6万多，看起来很多，但是实际上目前Unicode5.0收录的字符已经达到99024个字符，早已超过UTF-16的存储范围；     这直接导致UTF-16地位颇为尴尬——如果谁还在想着只要使用UTF-16就可以高枕无忧的话，恐怕要失望了。---> 这里实际上说的是UCS-2 2. UTF-16存在大小端字节序问题，这个问题在进行信息交换时特别突出——如果字节序未协商好，将导致乱码；     如果协商好，但是双方一个采用大端一个采用小端，则必然有一方要进行大小端转换，性能损失不可避免     (大小端问题其实不像看起来那么简单，有时会涉及硬件、操作系统、上层软件多个层次，可能会进行多次转换) 3. 另外，容错性低有时候也是一大问题——局部的字节错误，特别是丢失或增加可能导致所有后续字符全部错乱，     错乱后要想恢复，可能很简单，也可能会非常困难。(这一点在日常生活里大家感觉似乎无关紧要，但是在很多特殊环境下却是巨大的缺陷)  目前支撑我们继续使用UTF-16的理由主要是考虑到它是双字节的，在计算字符串长度、执行索引操作时速度很快。 当然这些优点UTF-32都具有，但很多人毕竟还是觉得UTF-32太占空间了。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "仅供参考：#pragma comment(lib,\"user32\") #pragma comment(lib,\"gdi32\") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> extern \"C\" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t wc[2];      system(\"color F0\");     system(\"cls\");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(48,0,0,0,0,0,0,0,GB2312_CHARSET ,0,0,0,0,\"宋体-方正超大字符集\");     SelectObject(hdc,hfont);     wc[0]=0xD854u;     wc[1]=0xDC00u;     TextOutW(hdc,10,10,wc,2);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system(\"color 07\");     system(\"cls\");     ShowTheCursor();     return 0; } #if 0 代理项或代理项对是一对共同表示单个字符的 16 位 Unicode 编码值。需要记住的关键一点是： 代理项对实际上是 32 位单个字符，不能再假定一个 16 位 Unicode 编码值正好映射到一个字符。  使用代理项对 代理项对的第一个值是高代理项，包含介于 U+D800 到 U+DBFF 范围内的 16 位代码值。 该对的第二个值是低代理项，包含介于 U+DC00 到 U+DFFF 范围内的值。通过使用代理项对， 16 位 Unicode 编码系统可以对已由 Unicode 标准定义的一百多万个其他字符 (220) 进行寻址。  在传递给 XmlTextWriter 方法的任何字符串中都可以使用代理项字符。不过，代理项字符在编写的 XML 中应该有效。例如，万维网联合会 (W3C) 建议不允许在元素或属性的名称中使用代理项字符。 如果字符串包含无效的代理项对，则引发异常。  另外，可以使用 WriteSurrogateCharEntity 写出与代理项对相对应的字符实体。字符实体以十六 进制格式写出，并用以下公式生成：  (highChar -0xD800) * 0x400 + (lowChar -0xDC00) + 0x10000  如果字符串包含无效的代理项对，则引发异常。下面的示例显示将代理项对作为输入的 WriteSurrogateCharEntity 方法。  C#复制  // The following line writes 𐀀. WriteSurrogateCharEntity ('\\uDC00', '\\uD800'); 下面的示例生成一个代理项对文件，将其加载到 XmlReader 中，并用新的文件名保存文件。 然后，原始文件和新文件被加载回应用程序的 XML 文档对象模型 (DOM) 结构中以进行比较。  C#复制  char lowChar, highChar; char [] charArray = new char[10]; FileStream targetFile = new FileStream(\"SurrogatePair.xml\",       FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  lowChar = Convert.ToChar(0xDC00); highChar = Convert.ToChar(0xD800); XmlTextWriter tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDC01); highChar = Convert.ToChar(0xD801); tw.WriteSurrogateCharEntity(lowChar, highChar); lowChar = Convert.ToChar(0xDFFF); highChar = Convert.ToChar(0xDBFF); tw.WriteSurrogateCharEntity(lowChar, highChar);  // Add 10 random surrogate pairs. // As Unicode, the high bytes are in lower // memory; for example, word 6A21 as 21 6A. // The high or low is in the logical sense. Random random = new Random(); for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       charArray[i] = highChar;       charArray[++i] = lowChar; } tw.WriteChars(charArray, 0, charArray.Length);  for (int i = 0; i < 10; ++i) {       lowChar = Convert.ToChar(random.Next(0xDC00, 0xE000));       highChar = Convert.ToChar(random.Next(0xD800, 0xDC00));       tw.WriteSurrogateCharEntity(lowChar, highChar); }  tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  XmlTextReader r = new XmlTextReader(\"SurrogatePair.xml\");  r.Read(); r.MoveToFirstAttribute(); targetFile = new FileStream(\"SurrogatePairFromReader.xml\",        FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);  tw = new XmlTextWriter(targetFile, null); tw.Formatting = Formatting.Indented; tw.WriteStartElement(\"root\"); tw.WriteStartAttribute(\"test\", null); tw.WriteString(r.Value); tw.WriteEndAttribute(); tw.WriteEndElement(); tw.Flush(); tw.Close();  // Load both result files into the DOM and compare. XmlDocument doc1 = new XmlDocument(); XmlDocument doc2 = new XmlDocument(); doc1.Load(\"SurrogatePair.xml\"); doc2.Load(\"SurrogatePairFromReader.xml\"); if (doc1.InnerXml != doc2.InnerXml) {       Console.WriteLine(\"Surrogate Pair test case failed\"); } 在使用 WriteChars 方法（一次写出一个缓冲区的数据）写出时，输入中的代理项对可能 会在一个缓冲区内被意外拆分。由于代理项值是定义完善的，如果 WriteChars 遇到来自 较低范围或者较高范围的 Unicode 值，它将该值标识为代理项对的一半。当遇到  WriteChars 将导致从拆分代理项对的缓冲区写入的情况时，将引发异常。使用   IsHighSurrogate 方法检查缓冲区是否以高代理项字符结束。如果缓冲区中的最后一个   字符不是高代理项，可以将该缓冲区传递给 WriteChars 方法。  请参见 概念 使用 XmlTextWriter 创建格式正确的 XML XmlTextWriter 的 XML 输出格式设置 XmlTextWriter 的命名空间功能  #endif", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "C标准不太熟悉 对win32来说 可以认为WCHAR就是指utf16  印象中 实际上它定义的是“至少”两字节的字符 但实际用的时候 涉及到API什么的都是用的utf16  utf32 utf16 utf8也已经都有单独的类型 char8_t char16_t char32_t 你如果怕弄混乱可以明确指定这些类型 但使用API的时候免不了经常跟WCHAR也就是实际上存放utf16的字符串转换来转换去 其实还不如直接都用L\"\"好了", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "宽字符多宽是系统依赖的，在windows上是UTF-16编码，在Linux/Unix上是UTF-32编码，你输出一下sizeof(wchar_t)就知道了", "referer": "user-0"}]}
{"question": "小白菜求问，这是哪里错了，哭", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 自信男孩的回复:改一下函数名，long是C语言用于定义变量的特殊字符，不能被用于其他 嗯嗯，谢谢。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "改一下函数名，long是C语言用于定义变量的特殊字符，不能被用于其他", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "懂了懂了，谢谢，", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 2 楼 qq_52114598 的回复:嗷, 不行吗  不行噢  而且你那个len没有申明", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "嗷, 不行吗", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "C语言long是关键字，你用做函数名？？？", "referer": "user-0"}]}
{"question": "猜数游戏", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "菜单选择怎么写呢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "循环每次先进一个选择函数，然后用户输入1或者2或者字符串什么的你自己写这个函数，接着根据用户输入if判断调用电脑猜的函数还是用户猜的函数", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "写成两个函数，写个菜单选项，用if-else或switch语句实现", "referer": "user-0"}]}
{"question": "菜鸟求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if(arr[i]%2!=0) 改成 if(arr[j]%2!=0)", "referer": "user-0"}]}
{"question": "萌新求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "求助，有大佬帮忙再看下吗？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "改了还是不对，能再看看问题在哪里吗？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢各位的指点", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "#include <stdio.h> int main(int argc, char* argv[]) {     float sum=0,m=1;     int n,i;     printf(\"请输入项数:\");     scanf(\"%d\",&n);     if(n<3) return 1;     for(i=2;i<=n;i++)     {       sum += 1.0/m;       m=3*i-2;     }     printf(\"%f\\n\",sum);     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 6 楼 ABBALILY 的回复:大佬能明示下把循环变量i的定义放哪吗？把for去掉直接写int i=1;i<=n;i++吗？ int i; for (i = 1; i <= n; i++) 这样就好，其实有些编译器支持你这种写法的，但是dev好像就不行", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "大佬能明示下把循环变量i的定义放哪吗？把for去掉直接写int i=1;i<=n;i++吗？", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "把循环变量的i定义放在前面，因为你的编译版本不支持在循环体里定义for (int i=0;这种形式", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "修改如下，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     float sum=0,m=1;     int n;     printf(\"请输入项数:\");     scanf(\"%d\",&n);     if(n<3) return 1;     for(int i=2;i<=n;i++)     {       sum += 1.0/m;       m=3*i-2;     }     printf(\"%f\\n\",sum);     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "m+=3改成 m=3*i-2", "referer": "user-0"}]}
{"question": "字符数组输出问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为b+1不等于b[1]，*(b+1)等价b[1] b+1是值下表1的元素的地址。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "b指向字符数组首地址即&b[0],b+1指向第2个字符的地址，即r,而%s输出r为首地址的一串字符。楼上的回答是正解。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "请参考《C++中printf()函数的用法10-2》 希望能够帮到您！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "因为你用的%s输出的，改成%c输出就是r了", "referer": "user-0"}]}
{"question": "菜鸟遇难，寻找大佬！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 qzjhjxj的回复:供参考：#include <stdio.h> #include <windows.h>  #define map_mode \"■\" #define width  30 #define height 15  void creatmap (); void Pos(int x,int y);  int main(int argc, char* argv[]) {     system(\"mode con cols=100 lines=30\");//设置控制台屏幕的大小     creatmap ();     system(\"pause\");     return 0; }  void Pos(int x,int y) {     COORD pos = {x,y};     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);     SetConsoleCursorPosition(hOut,pos); }  void creatmap() {     for(int i=0;i<=width;i+=2){         Pos(i,0);         printf(map_mode);         Pos(i,height);         printf(map_mode);     }     for(int i=0;i<height;i++){         Pos(0,i);         printf(map_mode);         Pos(width,i);         printf(map_mode);     } } respect", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:需要这么复杂吗？二维数组不就可以了吗? 谢谢，你的建议！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "供参考：#include <stdio.h> #include <windows.h>  #define map_mode \"■\" #define width  30 #define height 15  void creatmap (); void Pos(int x,int y);  int main(int argc, char* argv[]) {     system(\"mode con cols=100 lines=30\");//设置控制台屏幕的大小     creatmap ();     system(\"pause\");     return 0; }  void Pos(int x,int y) {     COORD pos = {x,y};     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);     SetConsoleCursorPosition(hOut,pos); }  void creatmap() {     for(int i=0;i<=width;i+=2){         Pos(i,0);         printf(map_mode);         Pos(i,height);         printf(map_mode);     }     for(int i=0;i<height;i++){         Pos(0,i);         printf(map_mode);         Pos(width,i);         printf(map_mode);     } }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "需要这么复杂吗？二维数组不就可以了吗?", "referer": "user-0"}]}
{"question": "大佬们，我没看明白这个函数的递归是咋会事。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "顺便说一下，字写得很好", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "没仔细看，好象是菲波那契数列？ 这种递归是必须这样的写法，不管如何写都达不到你想象的完美语法规定的", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "就是递归求阶乘 另外，这是显示的手写体，不是真的手写", "referer": "user-0"}]}
{"question": "无法返回表头", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> struct per    /*定义结构体类型*/ {     long int num;     char name[20];     char tel[12];     char mail[30];     char add[50];      long int mnum;     char id[18];     struct per *next; }; struct per *jianli();                       /*声明建立通信录函数*/ void shuchu(struct per *head);              /*声明输出通信录函数*/ struct per *tianjia(struct per *head);      /*声明添加联系人函数*/ struct per *shanchu(struct per *head);      /*声明删除联系人函数*/ struct per *chazhao(struct per *head);      /*声明查找联系人函数*/ struct per *head=NULL; int main() {   /*主函数*/     int select;     printf(\"\\n\\t***************** 欢迎进入个人通信录管理系统 ******************\\n\");     /*主控菜单*/     printf(\"\\n\\t ----------------->>   1: 建 立 通 信 录   <<-----------------\");     printf(\"\\n\\t ----------------->>   2: 输 出 通 信 录   <<-----------------\");     printf(\"\\n\\t ----------------->>   3: 添 加 联 系 人   <<-----------------\");     printf(\"\\n\\t ----------------->>   4: 删 除 联 系 人   <<-----------------\");     printf(\"\\n\\t ----------------->>   5: 查 找 联 系 人   <<-----------------\");     printf(\"\\n\\t ----------------->>   0: 退 出 系 统      <<-----------------\\n\");      printf(\"\\n\\t***************************************************************\\n\");     printf(\"\\n\\t请选择（0---5）：\");fflush(stdout);     rewind(stdin);scanf(\"%d\",&select);     printf(\"\\n\");     switch(select) {         /*对应模块函数*/     case 1:         head=jianli();         break;     case 2:         shuchu(head);         break;     case 3:         head=tianjia(head);         break;     case 4:         head=shanchu(head);         break;     case 5:         head=chazhao(head);         break;     case 0:         break;     default:         printf(\"您的输入有误，请重新输入（0---5）：\\n\");      }     while(select!=0); }   /*建立通信录函数*/ struct per *jianli() {      /*创建链表，并返回表头指针*/     struct per *head;       /*表头*/     struct per *p1;         /*新建节点*/     struct per *p2;         /*表尾节点*/     long int num1;     char name1[20];     char tel1[12];     char mail1[30];     char add1[50];     long int mnum1;     char id1[18];     head=NULL;              /*无任何节点，表头指向空*/      while(1) {         printf(\"请输入联系人编号、姓名、电话、身份证号、邮箱、地址及邮编（用空格分隔，用0结束）\\n\");         rewind(stdin);scanf(\"%d\",&num1);         if (num1==0) break;/*假设num=0表示输入结束*/         scanf(\" %s %s %s %s %s %d\",name1,tel1,id1,mail1,add1,&mnum1);     /*读入第一个联系人的信息*/         p1=(struct per *)malloc(sizeof(struct per));      /*新建一个节点*/         p1->num=num1;                                     /*存入联系人的信息*/         strcpy(p1->name,name1);         strcpy(p1->tel,tel1);         strcpy(p1->id,id1);         strcpy(p1->mail,mail1);         strcpy(p1->add,add1);         p1->mnum=mnum1;         p1->next=NULL;                /*将next域置为空，表示尾节点*/         if(head==NULL)             head=p1;                  /*第一个新建节点是表头*/         else             p2->next=p1;              /*原表尾的下一个节点是新节点*/         p2=p1;                        /*新建节点成为表尾*/     }     return head;              /*返回表头指针*/ } /*输出通信录函数*/ void shuchu(struct per *head) {     struct per *p;     int n=0;                           /*统计节点数，即联系人数*/     printf(\"\\n\\t*******************通*******信*******录*******************\\n\");     printf(\"\\n%-5s%-12s%-12s%-19s%-17s%-9s%-7s\\n\",\"编号\",\"姓名\",\"电话号码\",\"身份证号\",\"邮箱\",\"地址\",\"邮编\");     if(head!=NULL) {         for(p=head; p!=NULL; p=p->next) {     /*如果到达尾节点退出循环，否则继续*/             printf(\"%-5d%-12s%-12s%-19s%-17s%-9s%-7d\\n\",p->num,p->name,p->tel,p->id,p->mail,p->add,p->mnum);             n++;         }         printf(\"联系人总数：%d\\n\\n\",n);     } else         printf(\"\\n对不起，该通信录中没有任何联系人!\\n\\n\"); } /*添加联系人函数*/ struct per*tianjia(struct per*head) {     struct per*p;     struct per*p1;     struct per*p2;     p2=head;     p=(struct per*)malloc(sizeof(struct per));              /*新建节点p*/     printf(\"请输入要添加的联系人的编号、姓名、电话、身份证号、邮箱、地址、邮编:\\n\");     rewind(stdin);scanf(\"%d %s %s %s %s %s %d\",&p->num,p->name,p->tel,p->id,p->mail,p->add,&p->mnum);     printf(\"成功添加联系人%s !\\n\",p->name);     if(head==NULL)  {         head=p;         p->next=NULL;     }  else {         while((p->num>p2->num)&&(p2->next!=NULL)) {   /*查找添加位置*/             p1=p2;             p2=p2->next;         }         if(p->num<=p2->num) {  /*从小到大排列，添加至表内*/             if(p2==head) {                 head=p;                 p->next=p2;             } else    {                 p1->next=p;                 p->next=p2;             }         } else {               /*添加至表尾*/             p2->next=p;             p->next=NULL;         }     }     return(head); } /*删除联系人函数*/ struct per *shanchu(struct per *head) {     struct per *p2;     struct per *p1;     int num1,n;     printf(\"请输入要删除的联系人编号：\");fflush(stdout);     /*根据输入信息查找联系人*/     rewind(stdin);scanf(\"%d\",&num1);     if(head==NULL)  {         printf(\"\\n通讯录为空\\n\\n\");         return(head);     }     p2=head;     while(num1 != p2-> num && p2->next !=NULL)  {         p1=p2;         p2=p2->next;     }     if(num1==p2->num)  {         printf(\"\\n成功查询到该联系人！\\n\");         printf(\"\\n%-5s%-12s%-12s%-19s%-17s%-9s%-7s\\n\",\"编号\",\"姓名\",\"电话号码\",\"身份证号\",\"邮箱\",\"地址\",\"邮编\");         printf(\"%-5d%-12s%-12s%-19s%-17s%-9s%-7d\",p2->num,p2->name,p2->tel,p2->id,p2->mail,p2->add,p2->mnum);         printf(\"\\n确定删除？  1确定   0取消 \");fflush(stdout);         rewind(stdin);scanf(\"%d\",&n);         switch(n)   {         case 1:   {                 if(p2==head)                     head=p2->next;                 else                     p1->next=p2->next;                 free(p2);                 printf(\"\\n成功删除编号为%ld的联系人！\\n\\n\",num1);             }             break;         case 0:             printf(\"\\n您取消了删除任务，联系人未被删除！\\n\");             break;         }     } else         printf(\"\\n对不起，该通信录中没有任何联系人!\\n\\n\");     return(head); } /*查找函数*/ struct per *chazhao(struct per *head) {     struct per*p2;     char id1[20];     printf(\" 请输入要查找的联系人身份证号：\\n\");     rewind(stdin);scanf(\"%s\",id1);     if(head==NULL)  {         printf(\"\\n通讯录为空\\n\\n\");         return(head);     }     p2=head;     while (p2)  {         if(strcmp(p2->id,id1)==0) {             printf(\"\\n成功查询到该联系人！\\n\");             printf(\"\\n%-5s%-12s%-12s%-19s%-17s%-9s%-7s\\n\",\"编号\",\"姓名\",\"电话号码\",\"身份证号\",\"邮箱\",\"地址\",\"邮编\");             printf(\"%-5d%-12s%-12s%-19s%-17s%-9s%-7d\\n\",p2->num,p2->name,p2->tel,p2->id,                    p2->mail,p2->add,p2->mnum);             break;         }         p2=p2->next;     }     if(!p2)         printf(\"\\n对不起，该通信录没有该联系人!\\n\\n\");     return (head); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "dddddddddd", "referer": "user-0"}]}
{"question": "C语言解析二进制文件，去掉标签位，读取标签后两位数值，写出文件", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 ctrigger的回复:[quote=引用 5 楼 赵4老师 的回复:]给钱就有。 哈哈，这个没必要吧。 不怕麻烦，自己慢慢折腾解包就行。 实在不行，可以参考TCP/IP解包源码。[/quote] 可以帮忙写下代码吗？有偿", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 5 楼 赵4老师 的回复:给钱就有。 哈哈，这个没必要吧。 不怕麻烦，自己慢慢折腾解包就行。 实在不行，可以参考TCP/IP解包源码。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "给钱就有。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 3 楼 我是宁野野 的回复:通讯协议应该是这样的：头+数据长度+数据正文+校验 例如：AA 44 05 01 02 03 04 05 EA 这里我假设的一条数据，协议如下： 数据头：AA 44 数据长度： 05 数据正文： 01 02 03 04 05 校验：EA 现在我有一个这样的txt文件，想把里面的数据正文解析出来，请问有代码 吗？  根据协议格式，定义一个结构体，对号入座，接下来就是memcpy了。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "通讯协议应该是这样的：头+数据长度+数据正文+校验 例如：AA 44 05 01 02 03 04 05 EA 这里我假设的一条数据，协议如下： 数据头：AA 44 数据长度： 05 数据正文： 01 02 03 04 05 校验：EA 现在我有一个这样的txt文件，想把里面的数据正文解析出来，请问有代码 吗？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "#include <stdio.h> #include <string.h> int main() {     unsigned char s[24]={         0xAA,0xAA,0x04,0x80,0x02,0x12,0x34,0x99,         0xAA,0xAA,0x04,0x80,0x02,0x56,0x78,0x99,         0xAA,0xAA,0x04,0x80,0x02,0x12,0x34,0x99,     };     unsigned char m[5]={0xAA,0xAA,0x04,0x80,0x02};     unsigned char d[6];     unsigned char *ps,*pd;      ps=s;     pd=d;     while (1) {         if (0==memcmp(ps,m,5)) {             pd[0]=ps[5];             pd[1]=ps[6];             ps+=8;             pd+=2;             if (ps-s>=24 || pd-d>=6) break;         } else break;     }     for (int i=0;i<6;i++) printf(\"0x%02X \",d[i]);     return 0; } //0x12 0x34 0x56 0x78 0x12 0x34", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "真懒。这都是固定模式，按照协议直接对号入座就行。。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这问题太难了，什么语言都不好使，当然包括C语言。 目前人类才找到50几个Perfect number。 如果你能找到60个，菲尔兹奖就有希望了。。。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 chxchxkkk的回复:供参考  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h>  int main(void) {     char buff[80];       memset(buff, 0, 80);          while (1)     {         int i = 0;         gets_s(buff, 80);          if (strcmp(buff, \"End of file\") == 0)             break;          while (buff[i] != '\\0')         {             if (buff[i] >= 'a'&&buff[i] <= 'z')             {                 buff[i] = buff[i] - 32;             }             i++;         }         printf(\"%s\\n\", buff);               }          system(\"pause\");     return 0; }  如何实现多行输入，有点看不懂", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "要答案的话哪里都可以搜到吧", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "供参考  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h>  int main(void) {     char buff[80];       memset(buff, 0, 80);          while (1)     {         int i = 0;         gets_s(buff, 80);          if (strcmp(buff, \"End of file\") == 0)             break;          while (buff[i] != '\\0')         {             if (buff[i] >= 'a'&&buff[i] <= 'z')             {                 buff[i] = buff[i] - 32;             }             i++;         }         printf(\"%s\\n\", buff);               }          system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "网上有很多例子呢，整个不难吧。", "referer": "user-0"}]}
{"question": "两道作业 我做出来了 但是老师要求用指针解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "指针相当于目录 ，如果说abc三个地点进行遍历，下标是a-b，a-b-c，指针就是a-b，b-c", "referer": "user-0"}]}
{"question": "计算机大一期末c语言课程设计题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先定义一个教师的结构体，包括工号、姓名、工资等信息。 然后用结构体数组或链表完成上述各模块。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我用devc＋＋写的", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "把每个小块都写成一个函数，有意思，我也试着写一下", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "先定义一个二维数组，查找，输出所有，", "referer": "user-0"}]}
{"question": "写两个函数，分别求两个整数的最大公约数和最小公倍数，用主函数调用这两个函数，并输出结果。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "非常感谢 我试着按这个思路来", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "我也没完全理解题意，不一定符合要求。仅供参考： #include <stdio.h>  void gcd(int *a, int *b, int *r) { \tif(*b == 0) *r = *a; \telse \t{ \t\tint t = *a; \t\t*a = *b; \t\t*b = t % *b; \t\tgcd(a, b, r); \t} }  int main(void) { \t/* a，b是输入值，r是最大公约数 */ \tint a, b, m, n, r; \t \ta = 12; \tb = 16; \t \tm = a; \tn = b; \tgcd(&m, &n, &r); \t \tprintf(\"%d\\t%d\\n\", r, a*b/r);  \treturn 0; }", "referer": "user-0"}]}
{"question": "求解，不会做", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//输入一个字符串，字符串里全是小写字母比如 char  a[20]=\"bcadfgih\" //对其中的小写字母进行从小到大排序（a最小z最大） 以上面为例 a[20]变为\"abcdfghi\" //（使用排序算法） //再输入一一个字符 比如char b='e'，插入拍完序的a[20]中，插入规则是插入比b小和比b大的字符中， //比如上面的 a[20]=\"abcdefghi\" #include <stdio.h> #include <string.h> int main() {     char a[20],b;     int i,j,N;      fgets(a,19,stdin);     N=strlen(a);     if ('\\n'==a[N-1]) {a[N-1]=0;N--;}     printf(\"%s\\n\",a);      for (i=0;i<N-1;i++) {         for (j=i+1;j<N;j++) {             if (a[i]>a[j]) {                 b=a[i];a[i]=a[j];a[j]=b;             }         }     }     printf(\"%s\\n\",a);      rewind(stdin);     b=getchar();     for (i=0;i<N;i++) {         if (b<a[i]) {             for (j=N;j>=i;j--) a[j+1]=a[j];             a[i]=b;             break;         }     }     printf(\"%s\\n\",a);      return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "基本实现功能，没有优化。  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h>  #define N 20  //排序 void cSort(char a[], int n) {     int i, j;     char tmp;     for (i = 0; i < n - 1; i++)     {         for (j = 0; j < n - i - 1; j++)         {             if (a[j] > a[j + 1])             {                 tmp = a[j];                 a[j] = a[j + 1];                 a[j + 1] = tmp;             }         }     }     }  //插入 void cInsert(char a[], int n, char b) {     int i, index = 0;     for (i = 0; i < n; i++)     {         if (a[i] > b)         {             index = i;             break;         }                    }      for (i = n; i >= index; i--)     {         a[i] = a[i-1];     }     a[index] = b;    }  int main(void) {     char a[N] = { 0 }, t;     printf(\"输入一个字符串(小写字母):\\n\");     scanf(\"%s\", a);     int n = strlen(a);     if (n <= N - 1)     {         cSort(a, n);             }     else     {         printf(\"字符串越界！\\n\");         exit(1);     }     printf(\"排序后字符串：\\n%s\\n\", a);          getchar();      if (n < N - 1)     {         printf(\"输入要插入的字符：\\n\");         scanf(\"%c\", &t);         cInsert(a, n, t);     }     else     {         printf(\"字符串已达上限，不能插入字符。\\n\");                    }         printf(\"%s\\n\", a);      system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "排序和插入操作。不是很难的问题，建议楼主自己先试试，遇到问题再提出来吧", "referer": "user-0"}]}
{"question": "c语言，求指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 forever74的回复:BTW： 要养成写代码用标准格式的习惯。 你这样想，我的代码二十块钱一行，花括号不独立占一行那就损失大了。  嘿嘿 刚开始学，还没养成习惯😂", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复: #include<stdio.h> typedef struct{     int year, month,day; }Date;  void sum(Date *p) {     int md[]={31,28,31,30,31,30,31,31,30,31,30};     int i,total=0;     for(i=0;i<p->month-1;i++)         total += md[i];     total+=p->day;     //if((p->year%400==0||p->year%4==0&&p->year%100==0)&&p->month>2)     if((p->year%400==0||(p->year%4==0&&p->year%100!=0))&&p->month>2)         total++;     printf(\"%d\",total); } int main() {     Date d ;     Date *p = &d   ;     scanf(\"%d-%d-%d\",&d.year,&d.month,&d.day);     sum(p);      return 0; } 供参考～  楼主没有调用sum函数，因此没有输出  其他问题详见上面的代码 我还以为用Date  d 的时候就调用了，谢谢大佬了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "BTW： 要养成写代码用标准格式的习惯。 你这样想，我的代码二十块钱一行，花括号不独立占一行那就损失大了。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include<stdio.h> typedef struct{     int year, month,day; }Date;  void sum(Date *p) {     int md[]={31,28,31,30,31,30,31,31,30,31,30};     int i,total=0;     for(i=0;i<p->month-1;i++)         total += md[i];     total+=p->day;     //if((p->year%400==0||p->year%4==0&&p->year%100==0)&&p->month>2)     if((p->year%400==0||(p->year%4==0&&p->year%100!=0))&&p->month>2)         total++;     printf(\"%d\",total); } int main() {     Date d ;     Date *p = &d   ;     scanf(\"%d-%d-%d\",&d.year,&d.month,&d.day);     sum(p);      return 0; } 供参考～  楼主没有调用sum函数，因此没有输出  其他问题详见上面的代码", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "PPT下半截估计就是说这个的，都特意切掉了还贴啥呀？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "const unsigned char fonts[10][5] = {         { 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0         { 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1         { 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2         { 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3         { 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4         { 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5         { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6         { 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7         { 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8         { 0x06, 0x49, 0x49, 0x29, 0x1E } }; // 9      /* scanf printf */", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "需求看不全，多贴几张图～", "referer": "user-0"}]}
{"question": "求助！！！c语言指针", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 6 楼 weixin_52705034 的回复:[quote=引用 3 楼 forever74的回复:]另外，你的转置函数转了2次，又转回去了。 没，我第二个循环是等于i，只转了一次[/quote] 抱歉，看错了，光盯着3了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "main函数里，最后的输出有问题，for循环变量用的是j，而循环体却用i，此时的i已经是3，所以输出是越界了。输出自然是随机值", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 forever74的回复:另外，你的转置函数转了2次，又转回去了。 没，我第二个循环是等于i，只转了一次", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "没，我第二个循环是等于i", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 forever74的回复:你输出的时候循环变量j，引用的下标却是i，脱节了。 感谢感谢，确实原来是这么错的", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "另外，你的转置函数转了2次，又转回去了。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "你输出的时候循环变量j，引用的下标却是i，脱节了。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "函数，内部，定义实现函数，应该不可以吧", "referer": "user-0"}]}
{"question": "数组中字符串长度异常", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我一般这样形容这种做法： 相当于你偷了一次东西没有被抓到。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数组越界操作是未定义行为，未定义行为是可能没问题。不建议操作越界的数据。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "用for语句来吧，可能越界了都给你打出来了", "referer": "user-0"}]}
{"question": "链表求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢你的帮助", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "r->Next == NLLL; //要用==？ 在循环里直接对L修改（遍历）是否合适？  可以改成如下：  s = L; while (s->Next) {     s = s->Next; }", "referer": "user-0"}]}
{"question": "linux下建立两条长链", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:一个epoll就解决了么？同时监控读写即可。 其实PThread线程效率貌似挺高的，和epoll基本差不多。。 epoll只是创建长链和监听，数据会在接收后放入队列", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "一个epoll就解决了么？同时监控读写即可。 其实PThread线程效率貌似挺高的，和epoll基本差不多。。", "referer": "user-0"}]}
{"question": "帮忙分析一下一个简单的问题.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用b = NULL:最后：号错了，是‘；‘号，修改下。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> int main(int argc, char* argv[]) {    //int a[ ] = { 0 };      int a[10] = { 0 };//固定长度的数组及初始化为 0      int m;     scanf(\"%d\", &m);      int *b = new int[m];   //第一种动态长度数组     int *c = (int *)malloc(sizeof(int) * m);//第二种动态长度数组      memset(b,-1,m*sizeof(b));//初始化数组b为 -1      memset(c,0,m*sizeof(c));//初始化数组c为 0      //for (int i = 0; i < m; i++)//用循环初始化数组     //  {     //    b[i]=c[i]=0;     //  }      for (int i = 0; i < m; i++)//当m>10时，a[10]以后显示的就是不确定值,越界了       {         printf(\"a[%d]=%-15d\\tb[%d]=%-15d\\tc[%d]=%-15d\\n\",i,a[i],i,b[i],i,c[i]);       }     system(\"pause\");     delete [] b;   //动态释放     b = NULL:     free (c);     c = NULL;     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "注释反了。。把 int a[10] = {0} 注释去掉即可。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把define 的s展开就好了，展开就知道结果是多少和为什么是这个了。  s(a-b-c) ===== a-b-c*a-b-c 因为a-b-c是x，等价替换就可以了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "宏定义只是简单的替换，所以s(a - b - c)等于10 - 6 - 3 * 10 - 6 - 3 = -35", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "网上对于这样的代码和需求还是挺多的，建议自己动手查查，测试试试～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：#include <iostream.h> #include <stdio.h> int gys(int x,int y) //辗转相除法 公约数 {     int a;     if(x<y)  //将大的数排在前面     {         a=x;         x=y;         y=a;     }     while(x%y!=0)      {         a=x%y;         x=y;            y=a;       }     return y;  }  int gbs(int x,int y)  //公倍数 {     int result=(x*y)/(gys(x,y));     return result; }  int main(int argc, char* argv[]) {     int x,y;     cout<<\"请输入两个正整数：\";     cin>>x>>y;        cout<<\"最大公约数为:\" <<gys(x,y)<<endl;     cout<<\"最小公倍数为:\" <<gbs(x,y)<<endl;        system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": " 一个学习小组有n（n≤50）学生，每个学生有学号和考试成绩2个信息。编写程序实现以下功能：", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你可以看看c++的map", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考，你抄一遍，加深印象：#include <stdio.h> #define M 50 #define N 2 int main(int argc, char* argv[]) {     int stu[M][N];      for(int i=0 ;i<M;i++){        printf(\"请输入第%d个学生学号和成绩：\",i+1);        for(int j=0;j<N;j++){            scanf(\"%d\",&stu[i][j]);        }     }      for(int i=0 ;i<M;i++){        printf(\"第%d个学生学号和成绩：\",i+1);        for(int j=0;j<N;j++){            printf(\"%5d%c\",stu[i][j],((j==1)? '\\n':' '));        }     }      int i,temp;     printf(\"请输入要查询的学号：\");     scanf(\"%d\",&temp);     for(i=0;i<M;i++){        if(*stu[i] == temp) break;        continue;     }     if(i==M) printf(\"无此学生！\\n\");     else       printf(\"学号:%d  成绩:%d\\n\",stu[i][0],stu[i][1]);      system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": "使用链表建立一个后入先出的栈，将输入的一串字符反序输出。 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "创建链表，头插法即可。仅供参考： #include <list> #include <iostream> using namespace std;  int main(void) { \tchar c; \tlist<char> lst;  \twhile (cin >> c) \t{ \t\tif (c == '#') break; \t\tlst.push_front(c); \t}  \tfor (char c : lst) cout << c;  \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可以先实现一个链表，链表的创建采用头插法，可以创建一个带有哨兵的链表；每次新的节点都插在哨兵节点的后面。这样遍历从哨兵后的第一个节点开始，这样可以实现后入先出。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "链式栈，供参考  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #define Empty 0  //栈空 #define Avail 1  //栈可用  typedef char ElemType;  typedef struct SNode {     ElemType data;     struct SNode *next; }StackNode;  typedef struct LStack {     StackNode *top;  //栈顶指针     StackNode *bot;  //栈底指针     int length;      //栈长度   }LinkStack;  LinkStack InitStack(LinkStack pStack); LinkStack Push(LinkStack pStack, ElemType c); void Pop(LinkStack pStack); int StackEmpty(LinkStack pStack); LinkStack ClearStack(LinkStack pStack); void DisplayStack(LinkStack pStack);  int main(void) {     LinkStack p;     char ch;     p.length = 0;     p = InitStack(p);      printf(\"输入字符，以#结束\\n\");     scanf(\"%c\", &ch);      while (ch != '#')     {         p = Push(p, ch);                 scanf(\"%c\", &ch);     }      DisplayStack(p);      ClearStack(p);     system(\"pause\");     return 0; }  //入栈 LinkStack Push(LinkStack pStack, ElemType c) {         StackNode *temp;     temp = (StackNode*)malloc(sizeof(StackNode));     if (temp == NULL)     {         printf(\"内存分配失败！\\n\");         return pStack;     }      if (StackEmpty(pStack) == Empty)      //如果栈为空     {         pStack.top = pStack.bot = temp;   //栈顶、栈底指针都指向新建结点         temp->next = NULL;                 pStack.top->data = c;         pStack.length++;         return pStack;     }     else                                  //栈不为空     {         temp->next = pStack.top;          //新建结点指向原来的栈顶          pStack.top = temp;                //栈顶指针指向新建结点                pStack.top->data = c;         pStack.length++;         return pStack;     } }  //出栈 void Pop(LinkStack pStack) {     StackNode *Second;     if (StackEmpty(pStack) == Empty)     {         printf(\"栈为空！\\n\");         return pStack;     }      if (pStack.top == pStack.bot)        //如果是最后一个元素     {         printf(\"%c\\n\", pStack.top->data);         free(pStack.top);         pStack.top = pStack.bot = NULL;   //栈顶、栈底指针都置为空         pStack.length--;             }      printf(\"%c\", pStack.top->data);     Second = pStack.top->next;     free(pStack.top);     pStack.top = Second;     pStack.length--;     }  //判断栈是否为空 int StackEmpty(LinkStack pStack) {     if (pStack.top == NULL && pStack.bot == NULL)     {         return Empty;     }     else         return Avail; }  //遍历栈 void DisplayStack(LinkStack pStack) {     if (StackEmpty(pStack) == Empty)     {         printf(\"栈为空！\\n\");         return;     }      while (pStack.top != NULL)     {         printf(\"%c\", pStack.top->data);         pStack.top = pStack.top->next;     }     printf(\"\\n\"); }  //清空栈 LinkStack ClearStack(LinkStack pStack) {     StackNode *del;     while (pStack.top != NULL)     {         del = pStack.top->next;         free(pStack.top);         pStack.top = del;     }     return pStack; }  //初始化 LinkStack InitStack(LinkStack pStack) {     pStack.top = pStack.bot = NULL;     pStack.length = 0;      return pStack; }", "referer": "user-0"}]}
{"question": "数据结构—顺序表元素的逆置。代码编译没问题，但是程序不运行。请指教！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include <stdio.h> #include <stdlib.h>  #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10  typedef struct{     char *elem;     int length;     int listsize; }Sqlist;  void InitList_Sq(Sqlist *L)  //构造一个空线性表 {     L->elem = (char*)malloc(LIST_INIT_SIZE*sizeof(char));     if(!L->elem)     {         printf(\"ERROR!\");         exit(1);     }     L->length=0;     L->listsize=LIST_INIT_SIZE; }  void inversion(Sqlist *L) {     char *p,*q,t=0;     p=L->elem;     q=L->elem+L->length-1;     while(p<q)     {         t=*p;         *p=*q;         *q=t;     } } int main() {     Sqlist *L;     int i=0;     char c;      L = (Sqlist *)malloc(sizeof(*L));     if (!L)         exit(0);      InitList_Sq(L);     do{         printf(\"请输入一个字母（'/'退出循环）：\\n\");         scanf(\"%c\",&c);         if((L->length+1)>L->listsize) //顺序表已满，重新分配空间         {             L->elem=(char*)realloc(L->elem,(LIST_INIT_SIZE+LISTINCREMENT)*sizeof(char));             if(!L->elem)             {                 printf(\"ERROR!\");                 exit(1);             }             L->length=i;             L->listsize=LIST_INIT_SIZE+LISTINCREMENT;         }         if((c>='a'&&c<='z')||(c>='A'&&c<='Z')||c=='/')         {             *(L->elem+i)=c;             i++;             L->length=i;         }         else printf(\"输入错误！请输入字母！\\n\");      }while(c!='/');      if(L->length==0) printf(\"\\n未输入元素，无法逆置\");     else if(L->length==1) printf(\"\\n只有一个元素%c，无法逆置\",*(L->elem));     else{         inversion(L);         printf(\"元素逆置为：\\n\");         for(i=0;i<L->length;i++)             printf(\"%c \",*(L->elem+i));     } } 供参考～ 感谢！程序可以运行出来了，但是不太理解为什么InitList (L)前要这样先赋地址，而且sizeof (*L)为什么是*L呢？InitList后L的地址是不是又是另外一个新地址呢？？希望可以解答一下！谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:输入字符时，增加一个getchar()函数：    do{         printf(\"请输入一个字母（'/'退出循环）：\\n\");         scanf(\"%c\",&c);         getchar();      //吃掉多余字符         if((L->length+1)>L->listsize) //顺序表已满，重新分配空间 这个真是帮了我大忙了！！好几个程序都有相似的错误 ，但是想知道什么情况下需要用getchar（）来吃掉多余的字符啊，之前没这样用的时候没出现过这样的问题，自从写数据结构实验的题，总是出现这个问题。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢！程序可以运行出来了，但是不太理解为什么InitList (L)前要这样先赋地址，而且sizeof (*L)为什么是*L呢？InitList后L的地址是不是又是另外一个新地址呢？？希望可以解答一下！谢谢！！", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "偷鸡 放到数组逆序输出[face]", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "输入字符时，增加一个getchar()函数：    do{         printf(\"请输入一个字母（'/'退出循环）：\\n\");         scanf(\"%c\",&c);         getchar();      //吃掉多余字符         if((L->length+1)>L->listsize) //顺序表已满，重新分配空间", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "楼主，逆置函数还是有问题，修改如下，供参考：void inversion(Sqlist *L) {     char *p,*q,t=0;     p=L->elem;     q=L->elem + L->length-1-1;//末尾'/’不逆置     while(p<q)     {         t=*p;         *p=*q;         *q=t;         p++; //指针移动         q--;     } }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h>  #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10  typedef struct{     char *elem;     int length;     int listsize; }Sqlist;  void InitList_Sq(Sqlist *L)  //构造一个空线性表 {     L->elem = (char*)malloc(LIST_INIT_SIZE*sizeof(char));     if(!L->elem)     {         printf(\"ERROR!\");         exit(1);     }     L->length=0;     L->listsize=LIST_INIT_SIZE; }  void inversion(Sqlist *L) {     char *p,*q,t=0;     p=L->elem;     q=L->elem+L->length-1;     while(p<q)     {         t=*p;         *p=*q;         *q=t;     } } int main() {     Sqlist *L;     int i=0;     char c;      L = (Sqlist *)malloc(sizeof(*L));     if (!L)         exit(0);      InitList_Sq(L);     do{         printf(\"请输入一个字母（'/'退出循环）：\\n\");         scanf(\"%c\",&c);         if((L->length+1)>L->listsize) //顺序表已满，重新分配空间         {             L->elem=(char*)realloc(L->elem,(LIST_INIT_SIZE+LISTINCREMENT)*sizeof(char));             if(!L->elem)             {                 printf(\"ERROR!\");                 exit(1);             }             L->length=i;             L->listsize=LIST_INIT_SIZE+LISTINCREMENT;         }         if((c>='a'&&c<='z')||(c>='A'&&c<='Z')||c=='/')         {             *(L->elem+i)=c;             i++;             L->length=i;         }         else printf(\"输入错误！请输入字母！\\n\");      }while(c!='/');      if(L->length==0) printf(\"\\n未输入元素，无法逆置\");     else if(L->length==1) printf(\"\\n只有一个元素%c，无法逆置\",*(L->elem));     else{         inversion(L);         printf(\"元素逆置为：\\n\");         for(i=0;i<L->length;i++)             printf(\"%c \",*(L->elem+i));     } } 供参考～", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "倒序循环字符串a", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-5的回复:从字符串a的最后一个字符的下标到第个字符的下标。 超级感谢你昂", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这是用于遍历字符串的吧，没看到循环体，不好具体确定。从for循环上看是从字符串的末尾向前循环的。  strlen(a)是字符串的长度，也是'\\0'的下标，然后减1，正好是有效字符串的最后一个字符的下标", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "char a[] = \"123456789\"; \tint i; \tfor (i = strlen(a) - 1; i >= 0; i--) \t{ \t\tprintf(\"%c\", a[i]); \t} 输出的结果为", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 楼主 qq_52593311的回复:for(i=strlen(a)-1;i>=0;i--) 求大佬解释一下这个循环是什么意思 strlen是一个字符串函数——它用来计算字符串的长度 那么这个循环就是从数组最后一个下标开始到第一个下标，相当于abcd  一>  dcba", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "从字符串a的最后一个字符的下标到第个字符的下标。", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请将图片用markdown整理成具体代码片段。 你的帖子看着真累。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "个人认为是一样的。a[0]和p类型是一样的。  #include <stdio.h>   int main(void) {     int a[3][4], cnt = 0;     int i, j;     int *p;        for (i = 0; i < 3; i++)         for (j = 0; j < 4; j++)             a[i][j] = ++cnt;      p = a[0];     printf(\"%p, %p\\n\", p + 5, a[0] + 5);     printf(\"%d, %d\\n\", p[5] , *(a[0] + 5));      return 0; } 供参考～  可以看到两个地址和对应的值都是一样的。 内存是线性的，即使是二维数组也是线性存放的。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "把二维数组按一维排成一行后第i+1个元素地址 和 你的 第0行第i+1个元素地址是一个意思 但是你有没有想过，i 可以大于一行的个数，当 i 大于一行的个数时，如果还说成是第0行是不是就不合适了（因为已经超出第0行了）。所以说 按一维转成一行后 就更合适一些。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "参见《C++程序设计精要教程》的类型解析，p+i中的i不一定代表一个元素。如果a是二维数组int a[10][20],而定义int (*p)[20]; p=a[0];则p+i为第i*20个元素。关键看你的数组a的定义。你的问题不全不清楚，无法回答。", "referer": "user-0"}]}
{"question": "C语言—顺序元素的逆置，循环部分出了点问题，求帮助！！详细在下面说明。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 qzjhjxj的回复:元素的逆置函数void inversion(char a[],int length)算法有问题，把最后的‘/'符号逆序了，这个楼主自己修改下，其余修改如下,供参考：#include <stdio.h>  void inversion(char a[],int length); //void inversion();函数声明错误  int main(int argc, char* argv[]) {     char a[100]={'0'};     char c;     int i=0,length=0; \tdo \t{  \t   printf(\"\\nplease enter a letter(if want to exit,enter'/'):\");            scanf(\"%c\",&c);            getchar();   //吃掉缓冲区多余字符 \t   if(c>='a' && c<='z' || c>='A' && c<='Z' || c=='/') \t   { \t\t  a[i]=c; \t\t  i++; \t   } \t   else \t   { \t      printf(\"\\nError! please enter a 'letter'!\"); \t   }          }while(c!='/'&&i<100);      if(a[0]=='/')           printf(\"\\n未输入元素，无法逆置\");     else if(a[1]=='/')           printf(\"\\n只有一个元素%c，无法逆置\",a[0]);          else           { \t   length=i;            inversion(a,length);            printf(\"元素逆置为：\\n\");            for(i=0;i<length;i++)                    printf(\"%c \",a[i]);          }     system(\"pause\");     return 0; }   void inversion(char a[],int length) { \tint p,q; \tchar t; \tp=0; q=length-1; \twhile(p<q) \t{ \t   t=a[p]; \t   a[p]=a[q]; \t   a[q]=t; \t   p++; \t   q--;     } } 非常感谢您指出了关键的错误！！程序改好啦！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "非常感谢您指出了关键的错误！！程序改好啦！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:注意一下每次输入之后的'\\n'换行符，下次的匹配就优先匹配'\\n'了，所以提示Error!了。  解决办法是，如果输入是一次一个的输入，可以在scanf后面加一个getchar();用于 接收'\\n'  对于%d不会有这种问题，%c比较特殊 知道了！！非常感谢！！", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "元素的逆置函数void inversion(char a[],int length)算法有问题，把最后的‘/'符号逆序了，这个楼主自己修改下，其余修改如下,供参考：#include <stdio.h>  void inversion(char a[],int length); //void inversion();函数声明错误  int main(int argc, char* argv[]) {     char a[100]={'0'};     char c;     int i=0,length=0; \tdo \t{  \t   printf(\"\\nplease enter a letter(if want to exit,enter'/'):\");            scanf(\"%c\",&c);            getchar();   //吃掉缓冲区多余字符 \t   if(c>='a' && c<='z' || c>='A' && c<='Z' || c=='/') \t   { \t\t  a[i]=c; \t\t  i++; \t   } \t   else \t   { \t      printf(\"\\nError! please enter a 'letter'!\"); \t   }          }while(c!='/'&&i<100);      if(a[0]=='/')           printf(\"\\n未输入元素，无法逆置\");     else if(a[1]=='/')           printf(\"\\n只有一个元素%c，无法逆置\",a[0]);          else           { \t   length=i;            inversion(a,length);            printf(\"元素逆置为：\\n\");            for(i=0;i<length;i++)                    printf(\"%c \",a[i]);          }     system(\"pause\");     return 0; }   void inversion(char a[],int length) { \tint p,q; \tchar t; \tp=0; q=length-1; \twhile(p<q) \t{ \t   t=a[p]; \t   a[p]=a[q]; \t   a[q]=t; \t   p++; \t   q--;     } }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "注意一下每次输入之后的'\\n'换行符，下次的匹配就优先匹配'\\n'了，所以提示Error!了。  解决办法是，如果输入是一次一个的输入，可以在scanf后面加一个getchar();用于 接收'\\n'  对于%d不会有这种问题，%c比较特殊", "referer": "user-0"}]}
{"question": "数据结构—用栈实现括号匹配检验。代码不知道哪里出错了，求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define ERROR -1 typedef struct{       //定义顺序栈的存储结构     char *base;     char *top;     int stacksize; }SqStack;   void InitStack(SqStack *s) //建空栈 {     s->base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));     if(!s->base)         exit(1);     s->top=s->base;     s->stacksize=STACK_INIT_SIZE; }  int GetTop(SqStack *s,char *e) {     if(s->top==s->base) return ERROR;     *e=*(s->top-1);     return 1; }  void push(SqStack *s,char e) {     if((s->top-s->base)>=s->stacksize)  //栈已满，重新分配存储空间     {         s->base=(char*)realloc(s->base,(STACK_INIT_SIZE+STACKINCREMENT)*sizeof(char));         if(!s->base) exit(1);         s->top=s->base+s->stacksize;         s->stacksize+=STACKINCREMENT;     }     *s->top++=e; }  int pop(SqStack *s,char *e) {     if(s->top==s->base) return 0;     *e=*--s->top;     return 1; }  int StackEmpty(SqStack *s) {     if(s->top==s->base) return 1;  //栈空，返回值为1     else return 0; }  int BracketsMatch(SqStack *s,char b[]) {     InitStack(s);     int i=0;     //char *e;     char e;     while(b[i]!='#')     {         switch (b[i])         {             case '(': push(s,b[i]); break;             case '{': push(s,b[i]); break;             case '[': push(s,b[i]); break;             case ')':                       if(StackEmpty(s))  return 0;                       //pop(s, e);                       pop(s, &e);                       if(e != b[i]) return 0;                       break;             case ']':                       if(StackEmpty(s))  return 0;                       //pop(s, e);                       pop(s, &e);                       if(e!=b[i]) return 0;                       break;             case '}':                       if(StackEmpty(s))  return 0;                       //pop(s,e);                       pop(s, &e);                       if(e!=b[i]) return 0;                       break;         }         ++i;     }     if(StackEmpty(s)) return 1; //栈空，则匹配     else return 0;              //否则，不匹配 }  int main() {     SqStack *s;     char b[100],a;     int i=0,j;     do{         printf(\"请输入一个括号(#为结束字符)：\\n\");         scanf(\"%c\", &b[i]);         getchar();    //for'\\n'         a=b[i];         i++;     }while(a!='#');      s = (SqStack *)malloc(sizeof(*s));     if (!s)         exit(0);     j=BracketsMatch(s,b);     if(j==1) printf(\"括号匹配！\\n\");     else printf(\"括号不匹配！\\n\");     return 0; } 供参考～  s为没有申请空间，就直接使用结果是未定义的。其他的问题供参考  现在循环语句变成一次输出一遍，一次输出两遍，不知道是为什么 我的其他程序加了getchar()后就好了，但是这个不知道怎么回事？？ 您能帮我再看看吗？？谢谢谢谢！！！   还有就是您最后说的S没有申请空间，直接使用结果是未定义的，是什么意思啊？ 原谅我没太明白。就是GetTop(SqStack S)这类函数因为是读取不进行操作，所以参数一般是定义为S而不是*S， （我的理解），然后程序里SqStack *S，还有InitStack(S）中S都是以指针形式定义的，所以如果在函数中调用 GetTop函数，这个参数我不知道该怎么写，所以我把程序中函数GetTop(SqStack *S）定义为指针了，所以想问一下， 如果GetTop仍定义为GetTop(SqStack S），在函数中应该怎么调用呢，主要是参数怎么写呢？？ 谢谢谢谢！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define ERROR -1 typedef struct{       //定义顺序栈的存储结构     char *base;     char *top;     int stacksize; }SqStack;  void InitStack(SqStack *s) //建空栈 {     s->base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));     if(!s->base)         exit(1);     s->top=s->base;     s->stacksize=STACK_INIT_SIZE; }  int GetTop(SqStack *s,char *e) {     if(s->top==s->base) return ERROR;     *e=*(s->top-1);     return 1; }  void push(SqStack *s,char e) {     if((s->top-s->base)>=s->stacksize)  //栈已满，重新分配存储空间     {         s->base=(char*)realloc(s->base,(STACK_INIT_SIZE+STACKINCREMENT)*sizeof(char));         if(!s->base) exit(1);         s->top=s->base+s->stacksize;         s->stacksize+=STACKINCREMENT;     }     *s->top++=e; }  int pop(SqStack *s,char *e) {     if(s->top==s->base) return 0;     *e=*--s->top;     return 1; }  int StackEmpty(SqStack *s) {     if(s->top==s->base) return 1;  //栈空，返回值为1     else return 0; }  int BracketsMatch(SqStack *s,char b[]) {     InitStack(s);     int i=0;     //char *e;     char e;     while(b[i]!='#')     {         switch (b[i])         {             case '(': push(s,b[i]); break;             case '{': push(s,b[i]); break;             case '[': push(s,b[i]); break;             case ')':                       if(StackEmpty(s))  return 0;                       //pop(s, e);                       pop(s, &e);                       if(e != b[i]) return 0;                       break;             case ']':                       if(StackEmpty(s))  return 0;                       //pop(s, e);                       pop(s, &e);                       if(e!=b[i]) return 0;                       break;             case '}':                       if(StackEmpty(s))  return 0;                       //pop(s,e);                       pop(s, &e);                       if(e!=b[i]) return 0;                       break;         }         ++i;     }     if(StackEmpty(s)) return 1; //栈空，则匹配     else return 0;              //否则，不匹配 }  int main() {     SqStack *s;     char b[100],a;     int i=0,j;     do{         printf(\"请输入一个括号(#为结束字符)：\\n\");         scanf(\"%c\", &b[i]);         getchar();    //for'\\n'         a=b[i];         i++;     }while(a!='#');      s = (SqStack *)malloc(sizeof(*s));     if (!s)         exit(0);     j=BracketsMatch(s,b);     if(j==1) printf(\"括号匹配！\\n\");     else printf(\"括号不匹配！\\n\");     return 0; } 供参考～  s为没有申请空间，就直接使用结果是未定义的。其他的问题供参考", "referer": "user-0"}]}
{"question": "求助，为什么数组大小在主函数和子函数里不一样？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "形参a不是main函数的a了，这里是一个指针，是一个数组指针。因此对于指针的长度都是固定的。  建议楼主增加一个参数，用于接收列数。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数组作为参数的时候，会退化为指针，所以在子函数中用sizeof得到的是指针的大小", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "指针变量大小看是多少位系统", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "测试字符串所占空间大小，值为字符个数加一 测试变量，那就是变量所占空间大小 测试指针变量就是四个字节 测试类型，那就是类型对应空间大小 测试数组名，就是测试数组所占空间大小", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "在函数access里，sizeof得到的是指针尺寸，数组大小需要另外参数传进来，设数组为全局数组也可以传进来，或把数组封装在结构变量里传进来。", "referer": "user-0"}]}
{"question": "C语言已知两个数组：int x[4] = { 1,1,1,1}; int h[6] = {6,5,4,3,2,1}。对这两个数组做以下运算", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <stdio.h> void conv(int *p,int *q,int n);  int main(int argc, char* argv[]) {     int x[4]={1,1,1,1},h[6]={6,5,4,3,2,1};     int n;     printf(\"Input N:\");     scanf(\"%d\",&n);      conv(x,h,n);      system(\"pause\");     return 0; }  void conv(int *p,int *q,int n) {     int y=0,m=3;     for(int i=0;i<=m;i++){        if( n-i<0 || n-i>5){             y += p[i] * 0;             continue;        }        y += p[i]*q[n-i];     }     printf(\"%d\\n\",y); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "新手初学C语言，希望大神能够写详细一点", "referer": "user-0"}]}
{"question": "请问这个怎么办", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 qq_52046937 的回复:[quote=引用 1 楼 赵4老师的回复:]换国内镜像。 MINGW已经下载安装好了，就是过程中一直有报错，不知道有没有影响[/quote] 一直报错的话，用着用着肯定会有问题的。不如安装的时候就解决", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:换国内镜像。 MINGW已经下载安装好了，就是过程中一直有报错，不知道有没有影响", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "换国内镜像。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 7 楼 qq_52046937 的回复:[quote=引用 6 楼 一颗白面馒头的回复:][quote=引用 5 楼 qq_52046937 的回复:][quote=引用 4 楼 赵4老师的回复:]https://www.jianshu.com/p/96031565dafb 谢谢啦，其实我就是想在vs code上写C，想配置下环境，不知道咋整[/quote] 额。。。我前不久才配置了一个[/quote] 请问有没有教程啊，，简单点的，，大一菜鸟[/quote] https://www.zhihu.com/question/30315894。这个可参考，我就是按照这个配置的，有点麻烦，但是步骤挺详细的", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 6 楼 一颗白面馒头的回复:[quote=引用 5 楼 qq_52046937 的回复:][quote=引用 4 楼 赵4老师的回复:]https://www.jianshu.com/p/96031565dafb 谢谢啦，其实我就是想在vs code上写C，想配置下环境，不知道咋整[/quote] 额。。。我前不久才配置了一个[/quote] 请问有没有教程啊，，简单点的，，大一菜鸟🐤", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "引用 5 楼 qq_52046937 的回复:[quote=引用 4 楼 赵4老师的回复:]https://www.jianshu.com/p/96031565dafb 谢谢啦，其实我就是想在vs code上写C，想配置下环境，不知道咋整[/quote] 额。。。我前不久才配置了一个", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 4 楼 赵4老师的回复:https://www.jianshu.com/p/96031565dafb 谢谢啦，其实我就是想在vs code上写C，想配置下环境，不知道咋整", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "https://www.jianshu.com/p/96031565dafb", "referer": "user-0"}]}
{"question": "关于指针的问题想问一下各位大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢dalao", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "第58行  for(i=0;i<k;i++)  printf(\"%3d\",goodstudent[i]);//for(i=0;i<4;i++)printf(\"%3d\",goodstudent[i]);", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "修改如下，供参考：#include<stdio.h>  void aver(int (*p)[5]); void fail(int (*p)[5],int *pn,int x); void good(int (*p)[5],int *pn,int x);  void aver(int (*p)[5])  //求第一门课的平均分 {   int i,j,sum=0;   for(i=0,j=0;i<20;i++)   {     if(i%5==0)sum+=(*(*p+i)+j);   }   sum=sum/4;   printf(\"第一门课程的平均分为：%d\\n\",sum); }   void fail(int (*p)[5],int *pn,int x)  //找两门课不及格的学生，并输出学号、成绩 {   int i,j,flag;   for(i=0;i<x;i++,pn++)   {     flag=0;     for(j=0;j<5;j++)     {       if(*(*(p+i)+j)<60)flag+=1;     }     if(flag>=2)     {       printf(\"No.%d 不及格,他的全部成绩为：\\n\",*pn);       for(j=0;j<5;j++)printf(\"%5d\",*(*(p+i)+j));       printf(\"\\n\");     }   } }   void good(int (*p)[5],int *pn,int x)//找出平均成绩在90以上或全成绩在85以上的学生 {   int i,j,k=0,flag,sum,goodstudent[5];   //增加一个变量k   printf(\"成绩优秀学生的学号为：\");   for(i=0;i<x;i++,pn++)   {     sum=0;     flag=0;     for(j=0;j<5;j++)      {       sum += *(*(p+i)+j);      //sum+=(*(*p+i)+j);这里好像出了问题，循环一次就多加了数字                                          //printf(\"\\nsumA=%d\\n\",sum);       if(*(*(p+i)+j)>85) flag += 1;      }     if(flag==5 || sum/5>=90)  goodstudent[k++]= *pn;                                       //else                                      //  if(sum/4>90) goodstudent[i]=*pn;                                     // printf(\"sumB=%d\",sum);   }   for(i=0;i<k;i++)  printf(\"%3d\",goodstudent[i]); }   int main() {    int i,j,score[4][5],num[4];    int *pnum,(*pscore)[5];     printf(\"请输入学号:\\n\");    for(i=0;i<4;i++)scanf(\"%d\",&num[i]);     pnum=&num[0];    for(i=0;i<4;i++,pnum++)      {        printf(\"请输入%d号学生的成绩：\",*pnum);        for(j=0;j<5;j++)           {             scanf(\"%d\",&score[i][j]);           }        getchar();      }    for(i=0;i<4;i++)     {       for(j=0;j<5;j++)        {          if(score[i][j]>100||score[i][j]<0)printf(\"第%d行数据有误！\\n\",i+1);        }     }     pscore=score;    aver(pscore); //第一门课平均分     pnum=&num[0];    pscore=score;    fail(pscore,pnum,4);//两门课不及格的学生     pscore=score;    pnum=&num[0];    good(pscore,pnum,4);//优秀学生     printf(\"\\n\");    system(\"pause\");    return 0; }", "referer": "user-0"}]}
{"question": "看看这道题吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-3的回复:嗯，C写反了，D是对的 额，谢谢你了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 一颗白面馒头的回复:c是反了，第一句a指向c，a的next就是c了，b已经找不回来了，第二句a的next就是c，c再指向自己？ 额额，你说的是对的，互相交流", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:个人的看法和楼主一样的。如果C把这两条语句调换一下，即先执行q->next = p->next;在执行：p->next = &c;这样是没问题的。 所以D选项是正确的。 对的，我也这么认为，谢谢了", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "个人的看法和楼主一样的。如果C把这两条语句调换一下，即先执行q->next = p->next;在执行：p->next = &c;这样是没问题的。 所以D选项是正确的。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "c是反了，第一句a指向c，a的next就是c了，b已经找不回来了，第二句a的next就是c，c再指向自己？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "谢谢楼主，治好了多年的颈椎问题", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "嗯，C写反了，D是对的", "referer": "user-0"}]}
{"question": "校园oj题疑问", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 ctrigger 的回复：while(ch=getchar()!='\\n')  改为下面的，试试看：  引用while((ch=getchar())!='\\n')谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qzjhjxj 的回复：输入的是字符串，不是单个字符，修改如下，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int vowel(char ch);     int x,sum=0,i=0;     char ch[80];     gets(ch);     while (ch[i]!='\\0'){         if(vowel(ch[i]))            sum += 1;         i++;     }     printf(\"%d\",sum);     system(\"pause\");     return 0; }  int vowel(char ch) {    if(ch=='A'||ch=='a'||ch=='E'||ch=='e'||ch=='i'||ch=='I'||ch=='o'||ch=='O')       return 1;    return 0; }谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：改成这样： while ((ch = getchar())  != '\\n')  如果用 while (ch = getchar()  != '\\n') 这样ch是true和false谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "这屏幕碳烤的？", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "while(ch=getchar()!='\\n')  改为下面的，试试看：  引用while((ch=getchar())!='\\n')", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "输入的是字符串，不是单个字符，修改如下，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int vowel(char ch);     int x,sum=0,i=0;     char ch[80];     gets(ch);     while (ch[i]!='\\0'){         if(vowel(ch[i]))            sum += 1;         i++;     }     printf(\"%d\",sum);     system(\"pause\");     return 0; }  int vowel(char ch) {    if(ch=='A'||ch=='a'||ch=='E'||ch=='e'||ch=='i'||ch=='I'||ch=='o'||ch=='O')       return 1;    return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "改成这样： while ((ch = getchar())  != '\\n')  如果用 while (ch = getchar()  != '\\n') 这样ch是true和false", "referer": "user-0"}]}
{"question": "有人知道这要怎么做吗?大一学c语言不太懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 weixin_53514129 的回复:[quote=引用 1 楼 user-3的回复:]a^(1<<(k-1)) 为什么是这样打?[/quote] 简单的位操作，没理解么？我show个完整代吧。#include <stdio.h>   int main(void) { \tunsigned int a, k; \tscanf(\"%x%d\", &a, &k); \ta ^= (1<<k-1);\t \tprintf(\"%x\\n\", a); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3的回复:a^(1<<(k-1)) 为什么是这样打?", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <iostream>  using namespace std;   int main(void) {     unsigned int a, k;      cin>>hex>>a>>dec>>k;      //cout<<hex<<a<<endl;     //cout<<dec<<k<<endl;     k -= 1;     cout<<sizeof(a) * 8<<endl;     if (k >= sizeof(a) * 8)         cout<<hex<<a<<endl;      //cout<<hex<<~(1u<<k)<<endl;     a ^= (1u << k);      cout<<hex<<a<<endl;      return 0; }  供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "a^(1<<(k-1))", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 5 楼 weixin_53514129 的回复:[quote=引用 4 楼 ctrigger的回复:][quote=引用 3 楼 weixin_53514129 的回复:][quote=引用 1 楼 user-3的回复:]a^(1<<(k-1)) 为什么是这样打?[/quote] 简单的位操作，没理解么？我show个完整代吧。#include <stdio.h>   int main(void) { \tunsigned int a, k; \tscanf(\"%x%d\", &a, &k); \ta ^= (1<<k-1);\t \tprintf(\"%x\\n\", a); \treturn 0; }[/quote] 我是弄不懂1<<(k-1)代表什么[/quote]  C语言位运算，如同汇编语言的左移指令。。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 4 楼 ctrigger的回复:[quote=引用 3 楼 weixin_53514129 的回复:][quote=引用 1 楼 user-3的回复:]a^(1<<(k-1)) 为什么是这样打?[/quote] 简单的位操作，没理解么？我show个完整代吧。#include <stdio.h>   int main(void) { \tunsigned int a, k; \tscanf(\"%x%d\", &a, &k); \ta ^= (1<<k-1);\t \tprintf(\"%x\\n\", a); \treturn 0; }[/quote] 我是弄不懂1<<(k-1)代表什么", "referer": "user-0"}]}
{"question": "C语言求助！！！！help！！！！！SOS！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主可以用输入的特殊值来判断是否要继续输入，比如'\\n'，'0'等等；", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢大家(*°∀°)=3", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "文件结尾，EOF即可。 while((c=getchar()) != EOF) ...", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "某些问题如果能描述清楚那就差不多解决了。 解决不了正是因为说不清楚问题是什么。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "没太明白你的意思，你两次while循环是要相同的信息还是不同的信息？ 如果要相同的信息，直接复制第一次读入的信息就好了 如果是继续往后读入（也就是不同信息），那你就重新再做一次while不就好了吗？如果你的输入来自于文件，那就fseek偏移一下第一次读入的长度就可以了", "referer": "user-0"}]}
{"question": "C语言指针问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "建议楼主对于p+2的打印用%p，因为%p是专门对指针打印地址用的。  这个程序就是指针和数组的使用，主要是指针的使用，指针偏移和对应的元素值。  建议多加一些打印，结合地址和元素值熟悉指针的了解。另外，如果想更详细的了解，建议int *p和char *q, 交叉使用。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 楼主 AruNi° ഒ的回复:刚学到c语言，遇到这道题有点懵，有没有大佬帮我分析分析的？越详细越好，非常感谢！！！ 已经解决了！", "referer": "user-0"}]}
{"question": "请教一下C中如何模拟按下鼠标按键", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Linux系统，鼠标对应的设备文件目录：/dev/input/下。直接open就行，接下来就是读写操作了。 Windows系统，不清楚，等楼下补充吧。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "向指定的窗口发送鼠标点击的消息", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "SendInput、mouse_event", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "windows 有 API，查一下，控制鼠标移动点击都可以的", "referer": "user-0"}]}
{"question": "C Primer Plus 第六版_C语言基本数据类型&第45页.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先，请注意书上说的是“常量”，所以char型变量不会自动变成int型。 32位系统上常量'B'的内存为模式是 00000000 00000000 00000000 01000010 这样32位， 赋值给一个char变量的时候舍弃前24位，把低8位送过去。 为了迁就这种设定，你会发现getchar等字符处理函数是int类型的。 这部分是需要普及的。 ======================================================== 其次， 需要指出的是，K&R时代这样的设计本来是打算用来兼容多字节字符比如汉字的，但后期对非ASCII字符的处理走上了另外的（好几条）路，因此后半部分的描述在现在的编译器上不一定允许，也许是产生warning，所以不必深究。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "'FATE' 没见过这样的表示，这是非法的，编译器是编译不过去的。  char是int的子集，用int定义char类型的变量是类型提升，没什么问题。  可以注意下getchar()库函数的返回值：  int getchar(void);  都是int类型，为什么呢，一部分是类型提升，一部分是EOF，这个是int类型，不是char类型。所以为了和EOF比较，会用int类型的变量接收getchar()的返回值。", "referer": "user-0"}]}
{"question": "有大佬知道这那错了吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "二层循环少一个大括号吧，应该把k = pow(10, j-1);和sn = sn+a*k;扩到二层循环里吧。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "另外内层的for缺少花括号", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "pow是浮点，赋值给整数会产生截断误差。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "C++代码，仅供参考：#include <fstream> using namespace std;  int fn(int a, int n) { \tif (n == 1) return a; \telse return a * (10 * fn(1, n - 1) + n); }  int main(void) { \tint a, n; \tifstream fin(\"SC3_6C.in\"); \tofstream fout(\"SC3_6C.out\");  \tfin >> a >> n; \tfout << fn(a, n);  \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "靠，看来我眼睛有问题啊。看到这么鲜艳的图片，眼睛特别难受。", "referer": "user-0"}]}
{"question": "那位大佬知道这个怎么写吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <math.h>  int is_prime(int n) {     int i, size;      if (n < 2)         return 0;     size = (int)sqrt(n);      for (i = 2; i < size; i++)         if (n % i == 0)             return 0;      return 1; }  static void swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }  int check_revesible_prime(int n) {     int tmp;      if (n < 10)         return 1;      tmp = 0;     while (n) {         tmp = (n % 10) + tmp * 10;         n /= 10;     }      if (is_prime(tmp))         return 1;      return 0; }  int main(void) {     int m, n;     int i, cnt = 0;      scanf(\"%d%d\", &m, &n);     if (m > n)         swap(&m, &n);      for (i = m; i <= n; i++) {         if (is_prime(i)) {             if (check_revesible_prime(i)) {                 printf(\"%d \", i);                 cnt++;             }         if (cnt % 8 == 0)             putchar(10);         }      }     putchar(10);      return 0; } 供参考～  伸手要代码不是好习惯和解决问题的办法。还是希望楼主自己试试写写，起码判断素数的逻辑自己能写写或者起码网上找找学习一下，什么都不干你自己想想能学到什么？有时间还是用功学学，不然大学里你自己能学到什么程度？", "referer": "user-0"}]}
{"question": "大佬们，我没明白，为什么要定义area，不定义这个函数这个程序不也能运行吗？（C语言，求矩形面积）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>     /*文件包含，标准输入输出函数*/ int area(int a, int b) /*用户定义的函数*/ {     int s;     /*定义s为整型变量*/     s = a * b; /*求a与b的乘积*/     return s;  /*返回s的值*/ } void main() /*主函数*/ {     int x, y;                                       /*定义x,y为整型变量*/     scanf(\"%d%d\", &x, &y);                          /*获取x,y的值*/     printf(\"\\nx=%d,y%d\", x, y);                     /*输出x,y的值*/     int z;                                          /*定义z为整型变量*/     z = area(x, y);                                 /*调用函数*/     printf(\"\\nThe area of the rectangle is:%d\", z); /*输出z的值*/ }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:不用也是可以的，把s = a *b;放在main函数是一样的。  但对于模块化，建议用自定义，这样可能可以提到代码的可读性已经清晰度  建议楼主贴代码前，先把格式调好了，另外注释不是越多越好，而是关键地方加注释即可。注释多了反而其副作用，使代码看着臃肿～ 谢谢大佬解答", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "单行注释//", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "不用也是可以的，把s = a *b;放在main函数是一样的。  但对于模块化，建议用自定义，这样可能可以提到代码的可读性已经清晰度  建议楼主贴代码前，先把格式调好了，另外注释不是越多越好，而是关键地方加注释即可。注释多了反而其副作用，使代码看着臃肿～", "referer": "user-0"}]}
{"question": "C语言动态数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:[quote=引用 2 楼 linuxusr 的回复:] //diff -memcpy(elem, da->root + da->len - 1, da->size); +memcpy(elem, da->root + --da->len, da->size);  建议用第一个吧，不建议用第二个。  首先+ --连着不利于代码阅读，当然可以考虑加括号； 其次，--具有副作用，因为此处虽然有da->len-1的意思，同时，还会修改da->len的值，这里要看要不要有这一步了，个人感觉没有这一步。[/quote]  感谢回复。  这一行是在remove函数里，因为删除一行后，实际的元素个数也要减一。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 linuxusr 的回复: //diff -memcpy(elem, da->root + da->len - 1, da->size); +memcpy(elem, da->root + --da->len, da->size);  建议用第一个吧，不建议用第二个。  首先+ --连着不利于代码阅读，当然可以考虑加括号； 其次，--具有副作用，因为此处虽然有da->len-1的意思，同时，还会修改da->len的值，这里要看要不要有这一步了，个人感觉没有这一步。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "//diff -memcpy(elem, da->root + da->len - 1, da->size); +memcpy(elem, da->root + --da->len, da->size);", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "挺好的，点赞。希望楼主继续努力，进一步完善完善。。", "referer": "user-0"}]}
{"question": "运行窗口没有Press any key to continue!", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 AruNi° ഒ 的回复:[quote=引用 2 楼 自信男孩的回复:]运行时间长的问题，因为楼主用的是递归，递归函数虽然代码很少，但是运行起来比较耗时，尤其这个n越大，越耗时。可以试着比较一下n为一个小值和一个大值时，运行时间的差别 哦哦，这样啊，那怎么才能又用递归又弹出那个呢[/quote] 我的意思，这个n如果很大，那你就耐心等一会看看有没有输出。另外，Fib(i)不要多次使用，直接用其返回值，然后再比较和输出，比较用其返回值，输出用其返回值。这样似乎可以减少递归的次数吧", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！ 表示有点看不懂你说的，", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:运行时间长的问题，因为楼主用的是递归，递归函数虽然代码很少，但是运行起来比较耗时，尤其这个n越大，越耗时。可以试着比较一下n为一个小值和一个大值时，运行时间的差别 哦哦，这样啊，那怎么才能又用递归又弹出那个呢", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！ 大一，刚学。。。。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "运行时间长的问题，因为楼主用的是递归，递归函数虽然代码很少，但是运行起来比较耗时，尤其这个n越大，越耗时。可以试着比较一下n为一个小值和一个大值时，运行时间的差别", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！", "referer": "user-0"}]}
{"question": "求助！怎么使用c语言获取excel文件的行和列数后缀为.xls ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "#include<stdio.h> #include \"stdlib.h\" #include <Windows.h> #include <math.h> #include <atlstr.h>  int main() {  \tFILE *fp; \tint i,j ;     int da[5][4] = {0} ;     fp=fopen(\"C:/Users/yf/Documents/Visual Studio 2010/Projects/R/R/a.xls\",\"r\");     // fp指针指向文件头部     for(i = 0 ;i < 5 ; i++){         for(j = 0 ;j < 4 ; j++)         { \t\t\tfscanf(fp,\"%d\",&da[i][j]); \t\t\tfseek(fp, 1, SEEK_CUR);   //fp指针从当前位置向后移动 \t\t\t \t\t} \t} \tchar FsFileData[1000] = {0};  //存储每行的字符串 \tmemset(FsFileData, 0, sizeof(char)*1000); \tfseek(fp, 0, SEEK_SET);   //初始化 \tint count=0; \twhile(!feof(fp)) \t{ \t\t \t\tchar * ret_val; \t\tchar * find; \t\tret_val = fgets(FsFileData, 1000, fp);  \t\tprintf( \"ret_val: %s  \\n\", ret_val ); \t\tcount++; \t} \tprintf( \"count: %d  \\n\", count ); \tfclose(fp);  \tsystem(\"PAUSE\"); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": ".xls是专有协议，可以用Aspose API，或者第三方库，来解析这种文件。  如果能用.csv文本格式代替，会更加方便一些。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "仅供参考：// Copyright (C) 1992-1998 Microsoft Corporation // All rights reserved. // // This source code is only intended as a supplement to the // Microsoft Visual C++ Language  Reference and related // electronic documentation provided with Microsoft Visual C++. // See these sources for detailed information regarding the // Microsoft Visual C++ product.  // NOTE: This example will only work with Excel8 in Office97 // Compile with cl /GX comexcel.cpp // TO DO: Edit the #import paths //#pragma message (\"Make sure you go to Tools.Options.Directories and add the paths to mso97.dll and vbeext1.olb.  Mso97.dll will usually be in c:\\\\\\\"Program Files\\\"\\\\\\\"Microsoft Office\\\"\\\\Office, and vbeext1.olb will be in c:\\\\\\\"Program Files\\\"\\\\\\\"Common Files\\\"\\\\\\\"Microsoft Shared\\\"\\\\VBA\") #import \"C:\\\\Program Files\\\\Common Files\\\\Microsoft Shared\\\\Office11\\\\mso.dll\" no_namespace rename(\"DocumentProperties\", \"DocumentPropertiesXL\") #import \"C:\\\\Program Files\\\\Common Files\\\\Microsoft Shared\\\\VBA\\VBA6\\\\VBE6EXT.OLB\" no_namespace #import \"C:\\\\Program Files\\\\Microsoft Office\\\\OFFICE11\\\\excel.exe\" rename(\"DialogBox\", \"DialogBoxXL\") rename(\"RGB\", \"RBGXL\") rename(\"DocumentProperties\", \"DocumentPropertiesXL\") no_dual_interfaces  #pragma warning (disable:4192 4146)  #include <stdio.h> #include <tchar.h>  void dump_com_error(_com_error &e) {     _tprintf(_T(\"Oops - hit an error!\\n\"));     _tprintf(_T(\"\\a\\tCode = %08lx\\n\"), e.Error());     _tprintf(_T(\"\\a\\tCode meaning = %s\\n\"), e.ErrorMessage());     _bstr_t bstrSource(e.Source());     _bstr_t bstrDescription(e.Description());     _tprintf(_T(\"\\a\\tSource = %s\\n\"), (LPCTSTR) bstrSource);     _tprintf(_T(\"\\a\\tDescription = %s\\n\"), (LPCTSTR) bstrDescription); }  // If this is placed in the scope of the smart pointers, they must be // explicitly Release(d) before CoUninitialize() is called.  If any reference // count is non-zero, a protection fault will occur. struct StartOle {     StartOle() { CoInitialize(NULL); }     ~StartOle() { CoUninitialize(); } } _inst_StartOle;  void main() {     using namespace Excel;      _ApplicationPtr pXL;      try     {       pXL.CreateInstance(L\"Excel.Application\");        pXL->Visible = VARIANT_TRUE;        WorkbooksPtr pBooks = pXL->Workbooks;       _WorkbookPtr pBook  = pBooks->Add((long)xlWorksheet);       _WorksheetPtr pSheet = pXL->ActiveSheet;        RangePtr pRange;       pRange = pSheet->Range[\"A21\"];       pRange->Value2 = 75L;       //pRange->NumberFormatLocal = \"@\";        _CommandBarsPtr pCmdbars = pXL->CommandBars;       int iCmdbars = pCmdbars->GetCount();        Sleep(1000);       pRange = pSheet->Range[\"20:20\"];       pRange->Insert( (long)Excel::xlDown );       pRange->Merge();        Sleep(1000);        pBook->Saved = VARIANT_TRUE;       pXL->Quit();     }     catch(_com_error &e)     {       dump_com_error(e);        pXL->Quit();     } }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "fgets按行读取，然后根据'\\t截取，最后遇到'\\n'或'\\0'则为结束，这样通过一行就可以知道有几列，然后用fgets直到读到文件末尾，可以知道行数", "referer": "user-0"}]}
{"question": "一运行就提示停止工作", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//这样写，上下对照，就不会%d和变量个数不对应了： scanf(\"%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\"        &a,&b,&c,&d,&e,&f,&g,&h,&i,&j,&k,&l,&m,&n,&o,&p);  printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错（最新的编译器会出错）。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "写这样的代码，不如用循环呢。用循环可以避免太多的%d和对应的参数。参数多是不是容易漏了？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "scanf()函数有16个%d，只有15个对应的变量", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "你瞅，你仔细瞅，起码有俩错误。", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "这行", "referer": "user-0"}]}
{"question": "给定唯一变量，重新生成唯一随机数的方法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "最简单的方法就是，长数对2的16次方取模即可 这样，长数不变，取模的结果肯定也不变，而且长数确定，模肯定也确定", "referer": "user-0"}]}
{"question": "C语言 利用指针数组排序 要求输出排序结果和排序前的位置", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int a[10],*pa[10];     int *temp;     printf(\"Input tan number:\");     for(int i=0;i<10;i++){              scanf(\"%d\",&a[i]);              pa[i] = &a[i];     }      for(int i=0;i<10;i++){         for(int j=0;j<10-1;j++){             if(*pa[j]>*pa[j+1]){                temp = pa[j];                pa[j] = pa[j+1];                pa[j+1] = temp;             }         }     }       for(int i=0;i<10;i++){         printf(\"%4d\",*pa[i]);       }     printf(\"\\n\");     for(int i=0;i<10;i++){         printf(\"%4d\",pa[i]-a);     }     printf(\"\\n\");      system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考： #include <stdio.h> #include <stdlib.h>  int my_cmp(const void *a, const void *b) { \tint *p = *(int **)a; \tint *q = *(int **)b; \treturn *p - *q; }  int main(void) { \tint *pa[10], i; \t \t// 数组初始化 \tfor(i=0; i<10; i++) \t{ \t\tpa[i] = (int *)malloc(sizeof(int)); \t\tscanf(\"%d\", pa[i]); \t} \t \t// 快速排序 \tqsort(pa, 10, sizeof(int *), my_cmp); \t \t// 输出排序结果 \tfor(i=0; i<10; i++) \t{ \t\tprintf(\"%d%c\", *pa[i], i!=9 ? '\\t' : '\\n'); \t} \t \t// 善后处理，销毁 \tfor(i=0; i<10; i++) \t{ \t\tfree(pa[i]); \t} \t \treturn 0; }", "referer": "user-0"}]}
{"question": "c语言的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "fp得到的是true or false，不是fopen的返回值，修改如下： if ((fp = fopen(\"xxx\", \"r\")) == NULL) {     printf(\"%s\", strerror(errno));     return -1;   //打开失败直接返回，防止后面的继续使用fp }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "牛，都还没有分配空间就使用了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "出错信息说，指针user没有目标，所以不能用。", "referer": "user-0"}]}
{"question": "ANSI编码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "源码面前，了无秘密。 参考Windows源代码片段。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 21 楼 六道佩恩 的回复:[quote=引用 19 楼 早打大打打核战争 的回复:]1. ANSI也可以把其他国家/地区制定的标准定义为自己的标准，如同中国的很多GB实际是ISO或者其他国家标准的翻版，典型如KN95和N95的标准一样。  2. IBM、微软的代码页支持的字符集多于ANSI定义的字符集，如果系统默认的是个OEM代码页，那么就不是ANSI字符集，严格来说也就不算是使用ANSI编码。但是“ANSI字符集”也经常泛指非unicode字符集，尤其是在欧美之外的地区，所以并没有那么严格的划分。  3. \"A版函数按理说还是能处理该代码页的字符串吧\"，是可以的，A版函数实际是调用了MultiByteToWideChar，把某个代码页的字符串转换为unicode字符串，然后调用对应的W版函数，参考该函数文档中的注释：https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-multibytetowidechar： Note  The ANSI code pages can be different on different computers, or can be changed for a single computer, leading to data corruption. For the most consistent results, applications should use Unicode, such as UTF-8 or UTF-16, instead of a specific code page, unless legacy standards or data formats prevent the use of Unicode. If using Unicode is not possible, applications should tag the data stream with the appropriate encoding name when protocols allow it. HTML and XML files allow tagging, but text files do not. 微软实际上也是使用ANSI来代表非unicode  非常感谢，这是很明确的答复，总算是知道了！  请容我再问两个额外的相关的问题可以吗？  第一个问题是，ANSI代码页真的是ANSI指定的吗？毕竟没看到微软这样说，但说了“Windows代码页称呼为ANSI代码页”，知乎上也有个人说“Windows把自己的code page称作ANSI”，这些说法感觉像是微软自己指定的。  第二个问题，Windows在内核翻新为UNICODE编码后，应该就是在这个时候创建了A版和W版函数吧？那么对于在这之前的程序，是调用的无后缀版函数吧，那么对于翻新为UNICODE的新的Windows，这些程序当时是不是都乱码了？如果不是，是怎么实现不乱码的？是不是这些程序的函数跳转的地址和A版是一样，这样就实现兼容了？[/quote]  一、是微软自己指定的（早期有一部分是IBM定义的，IBM也参与了DOS和16位windows的开发），ANSI并没有定义“代码页”这种东西 二、A版和W版函数在非unicode内核的win 9x中就有了，与基于NT内核的系统相反，win9x中的W版函数转化为A版函数调用。无后缀版字符串函数只存在于16位windows中，win32中运行win16程序是使用独立的win16子系统，所以不会乱码。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#pragma comment(lib,\"user32\") #pragma comment(lib,\"gdi32\") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> wchar_t a2w[256]={ 0x0020,0x263a,0x263b,0x2665,0x2666,0x2663,0x2660,0x2022, 0x25d8,0x25cb,0x25d9,0x2642,0x2640,0x266a,0x266b,0x263c, 0x25ba,0x25c4,0x2195,0x203c,0x00b6,0x00a7,0x25ac,0x21a8, 0x2191,0x2193,0x2192,0x2190,0x221f,0x2194,0x25b2,0x25bc, 0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027, 0x0028,0x0029,0x002a,0x002b,0x002c,0x002d,0x002e,0x002f, 0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037, 0x0038,0x0039,0x003a,0x003b,0x003c,0x003d,0x003e,0x003f, 0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047, 0x0048,0x0049,0x004a,0x004b,0x004c,0x004d,0x004e,0x004f, 0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057, 0x0058,0x0059,0x005a,0x005b,0x005c,0x005d,0x005e,0x005f, 0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067, 0x0068,0x0069,0x006a,0x006b,0x006c,0x006d,0x006e,0x006f, 0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077, 0x0078,0x0079,0x007a,0x007b,0x007c,0x007d,0x007e,0x2302, 0x00c7,0x00fc,0x00e9,0x00e2,0x00e4,0x00e0,0x00e5,0x00e7, 0x00ea,0x00eb,0x00e8,0x00ef,0x00ee,0x00ec,0x00c4,0x00c5, 0x00e9,0x00e6,0x00c6,0x00f4,0x00f6,0x00f2,0x00fb,0x00f9, 0x00ff,0x00d6,0x00dc,0x00a2,0x00a3,0x00a5,0x20a7,0x0192, 0x00e1,0x00ed,0x00f3,0x00fa,0x00f1,0x00d1,0x00aa,0x00ba, 0x00bf,0x2310,0x00ac,0x00bd,0x00bc,0x00a1,0x00ab,0x00bb, 0x2591,0x2592,0x2593,0x2502,0x2524,0x2561,0x2562,0x2556, 0x2555,0x2563,0x2551,0x2557,0x255d,0x255c,0x255b,0x2510, 0x2514,0x2534,0x252c,0x251c,0x2500,0x253c,0x255e,0x255f, 0x255a,0x2554,0x2569,0x2566,0x2560,0x2550,0x256c,0x2567, 0x2568,0x2564,0x2565,0x2559,0x2558,0x2552,0x2553,0x256b, 0x256a,0x2518,0x250c,0x2588,0x2584,0x258c,0x2590,0x2580, 0x03b1,0x00df,0x0393,0x03c0,0x03a3,0x03c3,0x00b5,0x03c4, 0x03a6,0x0398,0x03a9,0x03b4,0x221e,0x03c6,0x03b5,0x2229, 0x2261,0x00b1,0x2265,0x2264,0x2320,0x2321,0x00f7,0x2248, 0x00b0,0x2219,0x00b7,0x221a,0x207f,0x00b2,0x25a0,0x00ff, }; extern \"C\" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t ws[256];     unsigned char s[256];     int i;       system(\"color F0\");     system(\"cls\");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(16,  0, 0, 0, 0, 0, 0, 0, 0           , 0, 0, 0, 0, \"Lucida Console\");     SelectObject(hdc,hfont);     TextOutW(hdc,10,10,L\"你好\",2);     for (i=0;i<256;i++) s[i]=i;     for (i=0;i<256;i++) ws[i]=a2w[s[i]];     TextOutW(hdc,10, 40,ws    ,32);     TextOutW(hdc,10, 80,ws+ 32,32);     TextOutW(hdc,10,120,ws+ 64,32);     TextOutW(hdc,10,160,ws+ 96,32);     TextOutW(hdc,10,200,ws+128,32);     TextOutW(hdc,10,240,ws+160,32);     TextOutW(hdc,10,280,ws+192,32);     TextOutW(hdc,10,320,ws+224,32);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system(\"color 07\");     system(\"cls\");     ShowTheCursor();     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "#include <conio.h> #include <stdlib.h> int main() {     int i;      system(\"chcp 437 >NUL\");     for (i=0;i<256;i++) {         if (i==0x08 || i==0x09 || i==0x0A || i==0x0D)             cprintf(\" \");         else             cprintf(\"%c\",i);         if (i%32==31) cprintf(\"\\r\\n\");     }     return 0; }  在Win10 cmd窗口中运行以上代码 属性，字体选“点阵字体”和“Courier New”的截图：", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "全都是历史遗留问题。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 19 楼 早打大打打核战争 的回复:1. ANSI也可以把其他国家/地区制定的标准定义为自己的标准，如同中国的很多GB实际是ISO或者其他国家标准的翻版，典型如KN95和N95的标准一样。  2. IBM、微软的代码页支持的字符集多于ANSI定义的字符集，如果系统默认的是个OEM代码页，那么就不是ANSI字符集，严格来说也就不算是使用ANSI编码。但是“ANSI字符集”也经常泛指非unicode字符集，尤其是在欧美之外的地区，所以并没有那么严格的划分。  3. \"A版函数按理说还是能处理该代码页的字符串吧\"，是可以的，A版函数实际是调用了MultiByteToWideChar，把某个代码页的字符串转换为unicode字符串，然后调用对应的W版函数，参考该函数文档中的注释：https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-multibytetowidechar： Note  The ANSI code pages can be different on different computers, or can be changed for a single computer, leading to data corruption. For the most consistent results, applications should use Unicode, such as UTF-8 or UTF-16, instead of a specific code page, unless legacy standards or data formats prevent the use of Unicode. If using Unicode is not possible, applications should tag the data stream with the appropriate encoding name when protocols allow it. HTML and XML files allow tagging, but text files do not. 微软实际上也是使用ANSI来代表非unicode  非常感谢，这是很明确的答复，总算是知道了！  请容我再问两个额外的相关的问题可以吗？  第一个问题是，ANSI代码页真的是ANSI指定的吗？毕竟没看到微软这样说，但说了“Windows代码页称呼为ANSI代码页”，知乎上也有个人说“Windows把自己的code page称作ANSI”，这些说法感觉像是微软自己指定的。  第二个问题，Windows在内核翻新为UNICODE编码后，应该就是在这个时候创建了A版和W版函数吧？那么对于在这之前的程序，是调用的无后缀版函数吧，那么对于翻新为UNICODE的新的Windows，这些程序当时是不是都乱码了？如果不是，是怎么实现不乱码的？是不是这些程序的函数跳转的地址和A版是一样，这样就实现兼容了？", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "说是一物即不中。  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "1. ANSI也可以把其他国家/地区制定的标准定义为自己的标准，如同中国的很多GB实际是ISO或者其他国家标准的翻版，典型如KN95和N95的标准一样。  2. IBM、微软的代码页支持的字符集多于ANSI定义的字符集，如果系统默认的是个OEM代码页，那么就不是ANSI字符集，严格来说也就不算是使用ANSI编码。但是“ANSI字符集”也经常泛指非unicode字符集，尤其是在欧美之外的地区，所以并没有那么严格的划分。  3. \"A版函数按理说还是能处理该代码页的字符串吧\"，是可以的，A版函数实际是调用了MultiByteToWideChar，把某个代码页的字符串转换为unicode字符串，然后调用对应的W版函数，参考该函数文档中的注释：https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-multibytetowidechar： Note  The ANSI code pages can be different on different computers, or can be changed for a single computer, leading to data corruption. For the most consistent results, applications should use Unicode, such as UTF-8 or UTF-16, instead of a specific code page, unless legacy standards or data formats prevent the use of Unicode. If using Unicode is not possible, applications should tag the data stream with the appropriate encoding name when protocols allow it. HTML and XML files allow tagging, but text files do not. 微软实际上也是使用ANSI来代表非unicode", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 5 楼 早打大打打核战争 的回复:ASCII编码是ANSI编码的前身，是ASA（美国标准化协会）制定的，后来ASA改名为ANSI（美国国家标准化委员会）。 严格意义上，ASCII是7位编码，后来才出现所谓扩展ASCII编码，是8位的。但是扩展ASCII并没有得到广泛使用，使用最多的是IBM的OEM字符集编码，只有前128个字符是和ASCII兼容的，后128个符号虽然也经常被称之为扩展ASCII码，但是和ANSI的扩展编码并不一致。 ANSI编码是8位编码，但是每个编码代表的字符可以不固定，在不同字符集下可以代表不同的字符，也可以连续多个编码代表一个字符（称之为DBCS或者MBCS，是对单字节字符编码做的扩展，本质上仍然是单字节字符编码），这样可以在不改变单字节字符编码的基础上支持更大的字符集。但是ANSI并没有对各字符集名称和代号做明确定义，计算机中常用的是IBM和微软定义的代码页，比如936代表GB2312字符集，1252代表拉丁1（这个就是狭义的ANSI编码），65001代表UTF-8。 IBM、OEM代码页是否算是ANSI代码页？看了微软文档后再回过头来看，才发现你提到了这个很关键的细节 微软文档说“Windows代码页”通常称为“ ANSI代码页”，而它又罗列出了IBM、OEM、ANSI代码页，那么IBM、OEM是不是不算是Windows代码页？ 微软文档又说“ A”版本处理基于Windows代码页的文本，那么如果Windows设置代码页为IBM、OEM代码页，那岂不是ANSI版函数处理ANSI编码之外的编码字符串？  您好像没有正面回答ANSI编码是否包括单字节的编码，这个很关键，因为我已经看到很多不同的说法，不知道哪个是对的，有说“双字节”的（百度百科），有说囊括ASCII的（和百度百科矛盾）", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 8 楼 user-4 的回复:字符集和编码不是一个概念，不能混淆。 SBCS（窄字节字符集），MBCS（多字节字符集），DBCS（宽字节字符集）都是字符集。ANSI是一种本地化编码，根据它的编码规则可以知道它包含SCBS和MBCS字符集（也就是这些字符集在ANSI编码下都有对应的编码值）。 iso-8859-1也是一种编码，原则上它只包含SBCS字符集，但是它的扩展协议也支持MBCS字符集（就是把多字节拆成单字节来保存，需要时再组合还原）。比如‘中’的GB2312编码为0xd6d0，但是在ios-8859-1编码下可拆为0xd6，0xd0两个字节保存。 到这里看出点什么了吗？同一个字符，在不同编码下有不同值。所以应该不存在的SBCS属于ANSI编码吗这样的问题，而是SBCS在ANSI编码下是什么值的问题。  lz可以好好看看以下帖子（尤其是1.2节的ANSI编码字符串的解释和1.3节字符集和编码的解释） https://blog.csdn.net/leonwei/article/details/10431921  再看看各种编码的规定 https://blog.csdn.net/u014157109/article/details/99878548  额，我那个单字节字符集是在描述那个扩展ASCII是单字节编码，也就是单字节字符集的范围，虽然不知道有没有超过1字节的编码被称为扩展ASCII的。 我问的也不是“SBCS属于ANSI编码吗”这个问题呀，我问的是“扩展ASCII属于ANSI编码吗”，SBCS是用来描述扩展ASCII的。  这几天查阅了很多资料，其他的感觉差不多了，唯独ANSI始终有点问题，因为不同的文章，解释总是有点不一样，就连微软的文档，也感觉有点歧义。 这个第一个链接拷贝的百度百科的  “‘中’的GB2312编码为0xd6d0，但是在ios-8859-1编码下可拆为0xd6，0xd0”这句话虽然来自第二个链接，但我感觉有问题吧，前后表示的都不是同一个字符，只是字节值而已，和编码没有关系吧。  第二个链接我看到这样一句话：“Windows在美国ANSI码表示ASCII码”，这就和百度百科的解释矛盾了，百度百科说的是双字节编码，而且和ASCII并列的，现在第一个问题甚至变成了“ASCII和扩展ASCII算不算ANSI编码”  我没找到ios-8859-1的超过1字节的扩展，有的话可以发下吗？其实在看到“Windows在美国ANSI码表示ASCII码”这句话后，ios-8859-1应该不那么重要了，我主要是看ANSI编码是否是指代任何国家的当地编码，包括单字节的编码，因为百度百科说要两字节的  微软文档里也有一些不解的地方（https://docs.microsoft.com/en-us/windows/win32/intl/code-pages），说的是“Windows代码页”通常称为“ ANSI代码页”，可是在代码页标识符页面里https://docs.microsoft.com/en-us/windows/win32/intl/code-page-identifiers，微软标明了ANSI代码页，这只是一部分，还有OEM代码页和IBM代码页，到底是这些所有代码页都是ANSI代码页，还是仅标了ANSI的？如果是后者的话，那么“ANSI编码指当地的编码”这句话是不是就有点问题了？ 如果ANSI编码指Windows的当前代码页（微软文档说的，“ A”版本处理基于Windows代码页的文本），而Windows又设置了OEM代码页或IBM代码页，那么该代码页是否又算是ANSI编码？  ANSI编码这个问题困扰了我好几天了，我始终没有找到我想要的答案——准确的ANSI编码的定义，因为各处找到的定义又总有不全面或矛盾的地方。 真的很感谢你们宝贵的回答，但是和我的问题始终有些小偏差，可能是我描述的问题，所以我尽量再描述详尽点，以及我的疑惑", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 11 楼 早打大打打核战争 的回复:我说了，“ANSI编码是8位编码”，当然包括单字节的编码，而且严格意义上，ANSI编码就是单字节编码。基于ANSI编码设计出来的双字节字符集（DBCS）、多字节字符集（MBCS）本质上仍然属于单字节编码，只是把单字节编码做了转义处理，允许连续的两个或多个单字节编码表达超出8位编码范围的字符。 ANSI没有定义代码页，它只是定义了若干种字符集，这些字符集都是基于单字节编码设计的。由于单字节编码的限制，不同字符集的字符和编码之间没有一一映射关系，同一个编码在不同字符集中可能代表不同的符号，同一符号在不同字符集中的编码也可能不同（比如GB2312中也有一套中文的A..Z、a..z，但是编码和英文字母是不一样的）。所以IBM、微软之类厂商才搞出了代码页的设计，代码页的目的是让支持多语种的系统知道当前使用的是什么字符集，从而能把字符编码显示为正确的字符。代码页的设计只是在非unicode系统中支持大字符集的一种折中方案，虽然可以支持远多于256个字符，但是不同字符集不能共存，一切换代码页，同一个字符串显示出来可能就变了。  谢谢，ANSI包括单字节的编码这一点我知道了，谢谢  （话说，这些字符集和编码不是各个地方自己设计的吗？）  但是，后面是您还是没正面回答呀  ANSI编码==ANSI代码页吗？ ANSI编码==本地编码（当前代码页）？  这两个显然不是都成立了，因为Windows中还集成了OEM、IBM代码页，如果系统默认的是个OEM代码页，怎么算？ A版函数按理说还是能处理该代码页的字符串吧？只是这种编码是不是就不能称为ANSI编码了？即便这就是当地的编码？  还是说，当地的编码只可能是ANSI的代码页，OEM、IBM代码页都是附加的？", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "老赵说的是狭义ANSI字符集，ANSI Latin-1（也就是windows 1252、ISO 8859-1），广义的ANSI字符集包括ANSI定义的所有字符集，参考：https://docs.microsoft.com/en-us/host-integration-server/core/ansi-oem-code-page-support-snanls-1", "referer": "user-0"}, {"cid": "13", "user": "user-1", "content": "ANSI 是个人计算机使用得最普遍的字符集。由于 ANSI 标准使用单一字节表示每个字符，因此最多只能有 256 个字符和标点符号代码。虽然对英语来说已经足够了，但不能完全支持其它语言。", "referer": "user-0"}, {"cid": "14", "user": "user-3", "content": "引用 楼主 六道佩恩 的回复:两个问题： 1. 单字节字符集的扩展ASCII，属于ANSI编码吗？ 2. ANSI编码的定义？百度百科上有说“使用多个字节来代表一个字符的各种汉字延伸编码方式”（https://baike.baidu.com/item/ANSI/10401940#viewPageContent），但在词条“标准编码格式”中（https://baike.baidu.com/item/%E6%A0%87%E5%87%86%E7%BC%96%E7%A0%81%E6%A0%BC%E5%BC%8F/20868617?fr=aladdin），ANSI编码有提到ISO-8859-2，这个标准貌似只有一个字节呀，而且这里也在ASNI一栏中提到“一个 UNICODE 字符可能转化成一个字节或多个字节”，所以，ANSI编码是否包含有1字节的编码？与单字节字符集有什么区别？ 又见字符编码  ANSI编码不是ASCII编码  关于ANSI编码需要知道以下几点： 这玩意只在Windows中存在。 ANSI编码并不是指某一种特定的编码，而是跟地区相关的。比如：中国默认就是GBK；美国默认就是ASCII。  其实ANSI并不是某一种特定的字符编码，而是在不同的系统中，ANSI表示不同的编码。你的美国同事Bob的系统中ANSI编码其实是ASCII编码（ASCII编码不能表示汉字，所以汉字为乱码），而你的系统中（“汉字”正常显示）ANSI编码其实是GBK编码，而韩文系统中（“한국어”正常显示）ANSI编码其实是EUC-KR编码。  https://www.cnblogs.com/malecrab/p/5300486.html", "referer": "user-0"}, {"cid": "15", "user": "user-2", "content": "我说了，“ANSI编码是8位编码”，当然包括单字节的编码，而且严格意义上，ANSI编码就是单字节编码。基于ANSI编码设计出来的双字节字符集（DBCS）、多字节字符集（MBCS）本质上仍然属于单字节编码，只是把单字节编码做了转义处理，允许连续的两个或多个单字节编码表达超出8位编码范围的字符。 ANSI没有定义代码页，它只是定义了若干种字符集，这些字符集都是基于单字节编码设计的。由于单字节编码的限制，不同字符集的字符和编码之间没有一一映射关系，同一个编码在不同字符集中可能代表不同的符号，同一符号在不同字符集中的编码也可能不同（比如GB2312中也有一套中文的A..Z、a..z，但是编码和英文字母是不一样的）。所以IBM、微软之类厂商才搞出了代码页的设计，代码页的目的是让支持多语种的系统知道当前使用的是什么字符集，从而能把字符编码显示为正确的字符。代码页的设计只是在非unicode系统中支持大字符集的一种折中方案，虽然可以支持远多于256个字符，但是不同字符集不能共存，一切换代码页，同一个字符串显示出来可能就变了。", "referer": "user-0"}, {"cid": "16", "user": "user-4", "content": "补充说明一下 单字节字符集的扩展ASCII在不同的编码下的编码“值”相同（也就是编码字符集相同），但是在不同的编码下保存的字节长度不同，比如在ANSI编码下是占一个字节，但是在Unicode编码下占两个字节（高字节为0或低字节为0）。所以不能笼统的说它必然属于哪种编码。", "referer": "user-0"}, {"cid": "17", "user": "user-4", "content": "首先，要知道编码和文字字符集是两个概念（这里的文字字符集指的是单纯的文字字符的集合，不是指在某种编码下的字符的编码“值”的集合（前者姑且叫文字字符集，后者姑且叫编码字符集），否则容易混淆不清），它们即有联系又有区别。（我觉得lz主要就是没弄清这些概念和区别，对于相同的文字字符集，不同编码对字符定义的编码“值”不一样，也就是编码字符集不一样） 问题1 ANSI是一种编码（不是文字字符集），这种编码规定，如果是英文拉丁文等单字节字符集的字符，就用1个字节来保存，如果是汉字等双字符集的字符就用2个字节保存。每个双节字符国家的文字不一样，所以每个国家对文字字符定义的ANSI值不一样，这就造成可能对同一个文字字符可能ANSI值不一样。比如“中”，中国（台湾），日本都有这个字，但是GB2112，BIG5，JIS编码（这类称编码字符集）下该“中”字符的ANSI编码“值”不同（换个角度来说，GB2112编码字符集（这里的字符集指编码“值”的集合而不是上面说的文字字符集合）里没有定义BIG5或JIS的“中”，所以BIG5或JIS的“中”在GB2112编码下是乱码）。这里要先捋清楚编码，文字字符集和编码字符集的关系。 所以问题1的回答是，单字节字符集的扩展ASCII是个文字字符集，不能单纯地说它是什么编码，所以它未必属于ANSI编码，也能是Unicode编码  问题2 ANSI编码是否包含1字节的编码？ 包含，因为ANSI编码支持单字节字符和双字节字符。 与单字节字符集有什么区别 区别就是单字节字符集只是个文字字符集，它可以有不同的编码，比如是Unicode或UTF8编码，那么这个单字节字符集就不属于ANSI编码。", "referer": "user-0"}, {"cid": "18", "user": "user-4", "content": "字符集和编码不是一个概念，不能混淆。 SBCS（窄字节字符集），MBCS（多字节字符集），DBCS（宽字节字符集）都是字符集。ANSI是一种本地化编码，根据它的编码规则可以知道它包含SCBS和MBCS字符集（也就是这些字符集在ANSI编码下都有对应的编码值）。 iso-8859-1也是一种编码，原则上它只包含SBCS字符集，但是它的扩展协议也支持MBCS字符集（就是把多字节拆成单字节来保存，需要时再组合还原）。比如‘中’的GB2312编码为0xd6d0，但是在ios-8859-1编码下可拆为0xd6，0xd0两个字节保存。 到这里看出点什么了吗？同一个字符，在不同编码下有不同值。所以应该不存在的SBCS属于ANSI编码吗这样的问题，而是SBCS在ANSI编码下是什么值的问题。  lz可以好好看看以下帖子（尤其是1.2节的ANSI编码字符串的解释和1.3节字符集和编码的解释） https://blog.csdn.net/leonwei/article/details/10431921  再看看各种编码的规定 https://blog.csdn.net/u014157109/article/details/99878548", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "引用 5 楼 早打大打打核战争 的回复:ASCII编码是ANSI编码的前身，是ASA（美国标准化协会）制定的，后来ASA改名为ANSI（美国国家标准化委员会）。 严格意义上，ASCII是7位编码，后来才出现所谓扩展ASCII编码，是8位的。但是扩展ASCII并没有得到广泛使用，使用最多的是IBM的OEM字符集编码，只有前128个字符是和ASCII兼容的，后128个符号虽然也经常被称之为扩展ASCII码，但是和ANSI的扩展编码并不一致。 ANSI编码是8位编码，但是每个编码代表的字符可以不固定，在不同字符集下可以代表不同的字符，也可以连续多个编码代表一个字符（称之为DBCS或者MBCS，是对单字节字符编码做的扩展，本质上仍然是单字节字符编码），这样可以在不改变单字节字符编码的基础上支持更大的字符集。但是ANSI并没有对各字符集名称和代号做明确定义，计算机中常用的是IBM和微软定义的代码页，比如936代表GB2312字符集，1252代表拉丁1（这个就是狭义的ANSI编码），65001代表UTF-8。 SBCS是否可以是ANSI编码？百度百科说是两字节，那么MBCS是否可以是ANSI编码？ 对于百度百科上，将ISO-8859-2划分到ANSI编码，该如何理解？", "referer": "user-0"}, {"cid": "20", "user": "user-0", "content": "引用 4 楼 user-4 的回复:补充说明一下 单字节字符集的扩展ASCII在不同的编码下的编码“值”相同（也就是编码字符集相同），但是在不同的编码下保存的字节长度不同，比如在ANSI编码下是占一个字节，但是在Unicode编码下占两个字节（高字节为0或低字节为0）。所以不能笼统的说它必然属于哪种编码。 可能是我的表达有误，我的意思是，扩展ASCII编码，就是欧洲使用的那种，字符也不多，在0xFF以内（单字节字符集），这种的编码算ANSI编码吗？我之所以提出这个问题，是因为在词条“标准编码格式”中，它在单字节编码一栏提到了ISO-8859-1标准，这个标准编码范围在0xFF以内，根据它对ANSI编码的描述“这些使用 2 个字节来代表一个字符的各种汉字延伸编码方式，称为ANSI 编码”，以及它和ANSI各划分为一栏，也就是它不属于ANSI编码，可是在ANSI编码一栏，还提到了ISO-8859-2，这个标准貌似也是单字节编码，为什么又属于ANSI编码了？  另外一个问题是，它这里说ANSI编码是两字节的，那么使用4字节的GB10830是否又能划分到ANSI编码？", "referer": "user-0"}]}
{"question": "C语言 bmp文件压缩(5M压缩500K左右，10ms内完成)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如果还是不了解，用霍夫曼编码吧，难度较我的方法更大，但网上示例很多", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 4 楼 litchee1988 的回复:[quote=引用 2 楼 六道佩恩 的回复:]我以前写过一个简单的压缩算法，试过画面较单一的BMP图片，可以压缩的几百甚至几十KB，和7z、ZIP相差不大，但对于画面复杂的，就恐怕没什么效果了（7z、zip效果也不是很好）。 这个算法很简单，就是检测连续重复的部分压缩为 重复的次数+重复的单份，先检测1字节重复的，然后遍历第二遍检测两字节重复的，如此循环，随便你检测到什么程度。至于时间能否控制在10ms以内，不清楚。如果BMP是24位的，你直接检测3字节重复的话，应该能控制在10ms以内吧（毕竟这已经是非常简单的压缩算法了，，且仅需一次遍历，如果这都达不到10ms，不知道还有什么算法可以）。  有没有相关代码供我参考一下呢？[/quote] 抱歉，代码不提供，而且整体思路我觉得我已经讲得挺明白了，就是不断的多字节的对比。比如一个int数组，每个数都是99，有1万个，那么你只需保存10000和99即可，检查该int重复多少次这没问题吧？一个int占4字节，这不就相当于检测了4字节重复了吗？任意字节的可用memcpy。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 六道佩恩 的回复:我以前写过一个简单的压缩算法，试过画面较单一的BMP图片，可以压缩的几百甚至几十KB，和7z、ZIP相差不大，但对于画面复杂的，就恐怕没什么效果了（7z、zip效果也不是很好）。 这个算法很简单，就是检测连续重复的部分压缩为 重复的次数+重复的单份，先检测1字节重复的，然后遍历第二遍检测两字节重复的，如此循环，随便你检测到什么程度。至于时间能否控制在10ms以内，不清楚。如果BMP是24位的，你直接检测3字节重复的话，应该能控制在10ms以内吧（毕竟这已经是非常简单的压缩算法了，，且仅需一次遍历，如果这都达不到10ms，不知道还有什么算法可以）。  有没有相关代码供我参考一下呢？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2 的回复:设置压缩参数，使用速度最快的方式，但，结果是，压缩比很低  请问如何设置压缩参数呢？我早Gzip的deflate方法中没看到可是设置压缩参数的地方呀？LZMA也没有看到过", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "我以前写过一个简单的压缩算法，试过画面较单一的BMP图片，可以压缩的几百甚至几十KB，和7z、ZIP相差不大，但对于画面复杂的，就恐怕没什么效果了（7z、zip效果也不是很好）。 这个算法很简单，就是检测连续重复的部分压缩为 重复的次数+重复的单份，先检测1字节重复的，然后遍历第二遍检测两字节重复的，如此循环，随便你检测到什么程度。至于时间能否控制在10ms以内，不清楚。如果BMP是24位的，你直接检测3字节重复的话，应该能控制在10ms以内吧（毕竟这已经是非常简单的压缩算法了，，且仅需一次遍历，如果这都达不到10ms，不知道还有什么算法可以）。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "设置压缩参数，使用速度最快的方式，但，结果是，压缩比很低", "referer": "user-0"}]}
{"question": "函数实现交换", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：#include <stdio.h> #define SWAP(a,b) do ((&(a))!=(&(b)))?((a)^=(b)^=(a)^=(b)):((a)=(a)); while (0) char   *p1=\"1\" ,*p2=\"2\" ; char    c1=1   , c2=2   ; short   s1=1   , s2=2   ; int     i1=1   , i2=2   ; __int64 I1=1i64, I2=2i64; float   f1=1.0f, f2=2.0f; double  d1=1.0 , d2=2.0 ; void main() {     SWAP((int)p1,(int)p2);                printf(\"char *     %5s,   %5s\\n\",p1,p2);     SWAP(c1,c2);                          printf(\"char       %5d,   %5d\\n\",c1,c2);     SWAP(s1,s2);                          printf(\"short      %5d,   %5d\\n\",s1,s2);     SWAP(i1,i2);                          printf(\"int        %5d,   %5d\\n\",i1,i2);     SWAP(I1,I2);                          printf(\"__int64 %5I64d,%5I64d\\n\",I1,I2);     SWAP(*(int     *)&f1,*(int     *)&f2);printf(\"float      %5g,   %5g\\n\",f1,f2);     SWAP(*(__int64 *)&d1,*(__int64 *)&d2);printf(\"double    %5lg,  %5lg\\n\",d1,d2);      SWAP(c1,c1);     printf(\"%d\\n\",c1); } //char *         2,       1 //char           2,       1 //short          2,       1 //int            2,       1 //__int64     2,    1 //float          2,       1 //double        2,      1 //2", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 forever74 的回复:你是main，我是swap 你左口袋装200美刀，右口袋装200人民币， 我仿照你的口袋装了我的口袋， 然后我交换了自己的两个口袋， ----这和你有什么关系？ 有关系，如果实参不传给形参，形参怎么知道是200？而不是其他的值，没关系，不调用传值，形参怎么知道交换的是什么值？不调用函数怎么会交换？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不是没有执行，而是执行的是swap函数里的局部变量，交换的是swap里的两个参数值，没有修改main函数里的两个值。所以感觉是没有执行。  解决办法是传要交换的两个变量的地址，在swap函数里交换引用到的值，就是交换main函数里的两个变量的值了。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "函数实参和形参的关系问题， 请参考《C++中函数参数类型为指针的指针》 希望能够帮到您！", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "你是main，我是swap 你左口袋装200美刀，右口袋装200人民币， 我仿照你的口袋装了我的口袋， 然后我交换了自己的两个口袋， ----这和你有什么关系？", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "C语言之传值的，需要传地址才有效果。仅供参考： #include  <stdio.h> void  Swap(int *x, int *y); int main(void) {     int  a, b;     printf(\"Please enter a,b:\");     scanf_s(\"%d %d\", &a, &b);     printf(\"Before swap: a = %d, b = %d\\n\", a, b);     Swap(&a, &b);     printf(\"After swap: a = %d, b = %d\\n\", a, b);     return 0; } void Swap(int *x, int *y) {     int temp;     temp = *x;     *x = *y;     *y = temp; }", "referer": "user-0"}]}
{"question": "求助括号配对问题（用stack），main.c有一部分代码不会写，请求高手指导", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void Test(void) { \tchar buf[512]; \tchar stack[512];  \tbool run = true; \twhile (run) \t{ \t\tbuf[0] = 0;  \t\twhile (buf[0] == 0) \t\t{ \t\t\tgets_s(buf, 512); \t\t}  \t\tint stackLen = 0; \t\tstack[0] = 0;  \t\tbool result = true; \t\tchar* pch = buf; \t\twhile (*pch != 0) \t\t{ \t\t\tif (*pch == '(' \t\t\t\t|| *pch == '[' \t\t\t\t|| *pch == '{') \t\t\t{ \t\t\t\tstack[stackLen++] = *pch; \t\t\t} \t\t\telse if (*pch == ')') \t\t\t{ \t\t\t\tif (stackLen > 0 && stack[stackLen - 1] == '(') \t\t\t\t{ \t\t\t\t\tstack[--stackLen] = 0; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tresult = false; \t\t\t\t\tbreak; \t\t\t\t} \t\t\t} \t\t\telse if (*pch == ']') \t\t\t{ \t\t\t\tif (stackLen > 0 && stack[stackLen - 1] == '[') \t\t\t\t{ \t\t\t\t\tstack[--stackLen] = 0; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tresult = false; \t\t\t\t\tbreak; \t\t\t\t} \t\t\t} \t\t\telse if (*pch == '}') \t\t\t{ \t\t\t\tif (stackLen > 0 && stack[stackLen - 1] == '{') \t\t\t\t{ \t\t\t\t\tstack[--stackLen] = 0; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tresult = false; \t\t\t\t\tbreak; \t\t\t\t} \t\t\t} \t\t\telse \t\t\t{ \t\t\t\tresult = false; \t\t\t\tbreak; \t\t\t}  \t\t\t++pch; \t\t}  \t\tresult &= stackLen == 0;  \t\tprintf(result ? \"yes\\r\\n\" : \"no\\r\\n\");  \t\tprintf(\"继续测试吗？输入y/n：\");  \t\tchar input = 0; \t\tscanf_s(\"%c\", &input, sizeof(char)); \t\trun = input == 'y'; \t} }", "referer": "user-0"}]}
{"question": "求助如何用C语言编写一个求解定积分的程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "定积分定义分割、取点、近似、求和、取极限。确实比较烦，但是牛顿-莱布尼茨公式用起来很方便的，用不着程序。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "根据定积分定义，不要怕麻烦，自己写就行。", "referer": "user-0"}]}
{"question": "萌新求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "正解。。。。。。。。。。。。。。。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议用%p输出一下地址，p+1应该是偏移3 * sizeof(int)的字节数 *(p+1)是p[1]，即第二行的首地址", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "打印第9行修改下：printf(\"9 *(b+2)+2 = %d, %d\\n\\n\",*(b+2)+2,*(*(b+2)+2));", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "这段代码上机运行下，你很快就明白了。int main(int argc, char* argv[]) {     int b[3][4] = {{1,3,5,7},                          {9,11,13,15},                          {17,19,21,23}     };      printf(\"1 b[2][1] =  %d\\n\\n\",b[2][1]);     printf(\"2 b[1] = %d, %d\\n\\n\",b[1],*b[1]);     printf(\"3 b = %d, %d\\n\\n\",b,**b);     printf(\"4 b+1 = %d, %d\\n\\n\",b+1,**(b+1));     printf(\"5 *b+1 = %d, %d\\n\\n\",*b+1,*(*b+1));     printf(\"6 *(b+1) = %d, %d\\n\\n\",*(b+1),*(*(b+1)));     printf(\"7 b[2]+1 = %d, %d\\n\\n\",b[2]+1,*(b[2]+1));     printf(\"8 *(b+1)+1 = %d, %d\\n\\n\",*(b+1)+1,*(*(b+1)+1));     printf(\"9 *(*(b+2)+2) = %d, %d\\n\\n\",*(b+2)+2,*(*(b+2)+2));     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "p+1表示次行（即s[1]行）首地址 ×(p+1)表示s[1][0]元素的地址  这俩货的值一致，含义不同。", "referer": "user-0"}]}
{"question": "C语言 回调函数接口的两个问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "对于函数指针的相关内容，请参考 《C++中的函数指针1》 《C++中的函数指针2》 希望能够帮到您！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:请问 void* (*函数)是什么意思 和 指针函数 void （*函数）有什么区别？  这两个都是函数指针，第一个返回值是void*，第二个返回值是  它丫的没有返回值  函数调用有三种方式 __cdecl 默认方式 __stdcall winAPI函数都是这个方式 __fastcall 至于三者区别，自己网上找找  https://www.cnblogs.com/yenyuloong/p/9626658.html 牛逼 大神 谢了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "请问 void* (*函数)是什么意思 和 指针函数 void （*函数）有什么区别？  这两个都是函数指针，第一个返回值是void*，第二个返回值是  它丫的没有返回值  函数调用有三种方式 __cdecl 默认方式 __stdcall winAPI函数都是这个方式 __fastcall 至于三者区别，自己网上找找  https://www.cnblogs.com/yenyuloong/p/9626658.html", "referer": "user-0"}]}
{"question": "哪位大神帮忙简化一下这个代码啊，千恩万谢！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "啥叫本事？ //想要实现循环语句来实现每天，每月，每年的累积数 if(\\\\local\\$Day==1) {     if(\\\\local\\$Hour==1  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H1 =\\\\local\\FT;}     if(\\\\local\\$Hour==2  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H2 =\\\\local\\FT;}     if(\\\\local\\$Hour==3  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H3 =\\\\local\\FT;}     if(\\\\local\\$Hour==4  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H4 =\\\\local\\FT;}     if(\\\\local\\$Hour==5  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H5 =\\\\local\\FT;}     if(\\\\local\\$Hour==6  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H6 =\\\\local\\FT;}     if(\\\\local\\$Hour==7  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H7 =\\\\local\\FT;}     if(\\\\local\\$Hour==8  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H8 =\\\\local\\FT;}     if(\\\\local\\$Hour==9  &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H9 =\\\\local\\FT;}     if(\\\\local\\$Hour==10 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H10=\\\\local\\FT;}     if(\\\\local\\$Hour==11 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H11=\\\\local\\FT;}     if(\\\\local\\$Hour==12 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H12=\\\\local\\FT;}     if(\\\\local\\$Hour==13 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H13=\\\\local\\FT;}     if(\\\\local\\$Hour==14 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H14=\\\\local\\FT;}     if(\\\\local\\$Hour==15 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H15=\\\\local\\FT;}     if(\\\\local\\$Hour==16 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H16=\\\\local\\FT;}     if(\\\\local\\$Hour==17 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H17=\\\\local\\FT;}     if(\\\\local\\$Hour==18 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H18=\\\\local\\FT;}     if(\\\\local\\$Hour==19 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H19=\\\\local\\FT;}     if(\\\\local\\$Hour==20 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H20=\\\\local\\FT;}     if(\\\\local\\$Hour==21 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H21=\\\\local\\FT;}     if(\\\\local\\$Hour==22 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H22=\\\\local\\FT;}     if(\\\\local\\$Hour==23 &&  \\\\local\\$Minute==1 ) {\\\\local\\hour.H23=\\\\local\\FT;}     if(\\\\local\\$Hour==23 &&  \\\\local\\$Minute==59) {\\\\local\\hour.H0 =\\\\local\\FT;         \\\\local\\day.D1=(           \\\\local\\hour.H1 +           \\\\local\\hour.H2 +           \\\\local\\hour.H3 +           \\\\local\\hour.H4 +           \\\\local\\hour.H5 +           \\\\local\\hour.H6 +           \\\\local\\hour.H7 +           \\\\local\\hour.H8 +           \\\\local\\hour.H9 +           \\\\local\\hour.H10+           \\\\local\\hour.H11+           \\\\local\\hour.H12+           \\\\local\\hour.H13+           \\\\local\\hour.H14+           \\\\local\\hour.H15+           \\\\local\\hour.H16+           \\\\local\\hour.H17+           \\\\local\\hour.H18+           \\\\local\\hour.H19+           \\\\local\\hour.H20+           \\\\local\\hour.H21+           \\\\local\\hour.H22+           \\\\local\\hour.H23+           \\\\local\\hour.H0         );     } }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用个指针数组,例如 p[23]，元素分别指向 \\\\local\\hour.H0 ~ \\\\local\\hour.H23， if (\\\\local\\$Minute==1)  {  *p[\\\\local\\$Hour ] = \\\\local\\FT;  }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "看来你也没啥本事", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "靠。你这小子没事。。在闭门造语言哇。。。牛。。。。太牛了。。。。。", "referer": "user-0"}]}
{"question": "用DEV C++和VS 2019 编译同样的代码输出结果不一样！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你要是坚持用的话，可以把所有中间过程都表达为double，不使用int，避免截断误差循环累积。  仅仅在最后输出前把结果+0.5再取整以四舍五入。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 11 楼 forever74的回复:除非必要，这种问题不要使用浮点数，pow库函数是浮点值。不同的编译器引用不同的库。  你以为double的精度足够，但是须知以浮点规范来说0.999999999999999也是整数1的足够精度的近似，但是一旦赋值给整型，它就等同于0了。 但是这个算出来是都整数哇，应该不影响吧", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "除非必要，这种问题不要使用浮点数，pow库函数是浮点值。不同的编译器引用不同的库。  你以为double的精度足够，但是须知以浮点规范来说0.999999999999999也是整数1的足够精度的近似，但是一旦赋值给整型，它就等同于0了。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 8 楼 ctrigger的回复:[quote=引用 7 楼 AruNi° ഒ 的回复:][quote=引用 1 楼 ctrigger的回复:]结果应该是确定的。 不一样，说明代码有问题，需要修改。。 你也不说要完成什么功能，谁也帮不了你。。。 题目已发，帮忙看看吧[/quote]  第5楼，我写的，仅供参考。[/quote] 大佬，你那个递归函数怎么想到的啊？求思路！", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "大佬，你那个递归函数怎么想出来的啊？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 7 楼 AruNi° ഒ 的回复:[quote=引用 1 楼 ctrigger的回复:]结果应该是确定的。 不一样，说明代码有问题，需要修改。。 你也不说要完成什么功能，谁也帮不了你。。。 题目已发，帮忙看看吧[/quote]  第5楼，我写的，仅供参考。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 ctrigger的回复:结果应该是确定的。 不一样，说明代码有问题，需要修改。。 你也不说要完成什么功能，谁也帮不了你。。。 题目已发，帮忙看看吧", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 3 楼 user-3的回复:修改如下，供参考：#include<stdio.h> #include<math.h> int fn(int a,int n);//函数声明 int main(int argc, char* argv[]) {     int a,n,sum;     int i;     sum=0;     scanf(\"%d %d\",&a,&n); //输入a，n      for(i=1;i<=n;i++){         sum+=fn(a,i);//循环 完成累加     }     printf(\"Sum=%d\",sum);     system(\"pause\");     return 0;  }  int fn(int a,int n) {     int result=0;     for(int i=0;i<n;i++){          result += a*pow(10,i);//pow(2,3)表示2的3次     }     return result; } 第四行是什么意思啊？", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "Show一个，仅供参考： #include <stdio.h>  int fn(int a, int n) { \tif(n == 1) return a; \telse return a * (10 * fn(1, n-1) + n); }  int main(void) { \tint a, n; \tscanf(\"%d %d\",&a, &n); \tprintf(\"Sum=%d\", fn(a, n)); \treturn 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "前面这个是楼主的代码，是正确的。这个是修改的，另一种写法，供参考：#include<stdio.h>  int fn(int a,int n);//函数声明 int main(int argc, char* argv[]) {     int a,n,sum;     int i;     sum=0;     scanf(\"%d %d\",&a,&n); //输入a，n      for(i=1;i<=n;i++){         sum+=fn(a,i);//循环 完成累加     }     printf(\"Sum=%d\\n\",sum);      system(\"pause\");     return 0;  }  int fn(int a,int n) {     int result=0;     for(int i=0;i<n;i++){          //result += a*pow(10,i);//pow(2,3)表示2的3次          result = result * 10 + a;     }     return result; }", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "修改如下，供参考：#include<stdio.h> #include<math.h> int fn(int a,int n);//函数声明 int main(int argc, char* argv[]) {     int a,n,sum;     int i;     sum=0;     scanf(\"%d %d\",&a,&n); //输入a，n      for(i=1;i<=n;i++){         sum+=fn(a,i);//循环 完成累加     }     printf(\"Sum=%d\",sum);     system(\"pause\");     return 0;  }  int fn(int a,int n) {     int result=0;     for(int i=0;i<n;i++){          result += a*pow(10,i);//pow(2,3)表示2的3次     }     return result; }", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "题目是这个。", "referer": "user-0"}, {"cid": "13", "user": "user-2", "content": "结果应该是确定的。 不一样，说明代码有问题，需要修改。。 你也不说要完成什么功能，谁也帮不了你。。。", "referer": "user-0"}]}
{"question": "优秀的人们快来看看，超级简单的问题！！！！但是我不会。。。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码？错误提示？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这问题简单啊。既然标识符未定义，直接定义一次吧。。你如果不放心，还可以再定义一次，绝对保险。。。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "哪有未定义的标识符？", "referer": "user-0"}]}
{"question": "新手报道，求关注，每天分享c语言作业", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "bool IsPrime(int n) {     if (n == 1)         return false;       if (n == 2         || n == 3         || n == 5         || n == 7)     {         return true;     }       if (n % 2 == 0)         return false;       if (n % 3 == 0)         return false;       if (n % 5 == 0)         return false;       if (n % 7 == 0)         return false;       double dn = sqrt(n);     int cnt = (int)dn;     for (int i = 11; i <= cnt; i += 2)  // 继续优化 i += 2     {         if (n % i == 0)             return false;     }       return true; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 1 楼 自信男孩 的回复:题目描述：  一个素数，依次从低位去掉一位，二位，……，若所得的各数仍都是素数，则称超级素数。  例如：7331是个4位超级素数，因为7，73，733，7331均为素数. 试求1000~n之内(1000<n<9999)： (1)超级素数的个数 (2)所有超级素数之和 (3)最大的超级素数。   bool IsPrime(int n) { \tif (n == 1) \t\treturn false;  \tif (n == 2 \t\t|| n == 3 \t\t|| n == 5 \t\t|| n == 7) \t{ \t\treturn true; \t}  \tif (n % 2 == 0) \t\treturn false;  \tif (n % 3 == 0) \t\treturn false;  \tif (n % 5 == 0) \t\treturn false;  \tif (n % 7 == 0) \t\treturn false;  \tdouble dn = sqrt(n); \tint cnt = (int)dn; \tfor (int i = 11; i <= cnt; ++i)  // 优化一下，从11开始 \t{ \t\tif (n % i == 0) \t\t\treturn false; \t}  \treturn true; }  void Test(void) { \tint n = 0; \tprintf(\"请输入n(1000<n<9999)：\"); \tscanf_s(\"%d\", &n); \tif (n <= 1000 || 9999 <= n) \t{ \t\tprintf(\"输入错误！\"); \t\treturn; \t}  \tint count = 0; \tint sum = 0; \tint max = 0; \tfor (int i = 2001; i <= n; ++i) \t{ \t\tint test = i; \t\tif (IsPrime(test)) \t\t{ \t\t\ttest /= 10; \t\t\tif (IsPrime(test)) \t\t\t{ \t\t\t\ttest /= 10; \t\t\t\tif (IsPrime(test)) \t\t\t\t{ \t\t\t\t\ttest /= 10; \t\t\t\t\tif (IsPrime(test)) \t\t\t\t\t{ \t\t\t\t\t\t++count; \t\t\t\t\t\tsum += i; \t\t\t\t\t\tmax = i; \t\t\t\t\t\tprintf(\"%d\\r\\n\", i); \t\t\t\t\t} \t\t\t\t} \t\t\t} \t\t} \t}  \tprintf(\"(1)超级素数的个数：%d\\r\\n(2)所有超级素数之和：%d\\r\\n(3)最大的超级素数：%d\\r\\n\", count, sum, max); }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "bool IsPrime(int n) { \tif (n == 1) \t\treturn false;  \tif (n == 2 \t\t|| n == 3 \t\t|| n == 5 \t\t|| n == 7) \t{ \t\treturn true; \t}  \tif (n % 2 == 0) \t\treturn false;  \tif (n % 3 == 0) \t\treturn false;  \tif (n % 5 == 0) \t\treturn false;  \tif (n % 7 == 0) \t\treturn false;  \tdouble dn = sqrt(n); \tint cnt = (int)dn; \tfor (int i = 2; i <= cnt; ++i) \t{ \t\tif (n % i == 0) \t\t\treturn false; \t}  \treturn true; }  void Test(void) { \tint n = 0; \tprintf(\"请输入n(1000<n<9999)：\"); \tscanf_s(\"%d\", &n); \tif (n <= 1000 || 9999 <= n) \t{ \t\tprintf(\"输入错误！\"); \t\treturn; \t}  \tint count = 0; \tint sum = 0; \tint max = 0; \tfor (int i = 2001; i <= n; ++i) \t{ \t\tint test = i; \t\tif (IsPrime(test)) \t\t{ \t\t\ttest /= 10; \t\t\tif (IsPrime(test)) \t\t\t{ \t\t\t\ttest /= 10; \t\t\t\tif (IsPrime(test)) \t\t\t\t{ \t\t\t\t\ttest /= 10; \t\t\t\t\tif (IsPrime(test)) \t\t\t\t\t{ \t\t\t\t\t\t++count; \t\t\t\t\t\tsum += i; \t\t\t\t\t\tmax = i; \t\t\t\t\t\tprintf(\"%d\\r\\n\", i); \t\t\t\t\t} \t\t\t\t} \t\t\t} \t\t} \t}  \tprintf(\"(1)超级素数的个数：%d\\r\\n(2)所有超级素数之和：%d\\r\\n(3)最大的超级素数：%d\\r\\n\", count, sum, max); }   请输入n(1000<n<9999)：8000 2333 2339 2393 2399 2939 3119 3137 3733 3739 3793 3797 5939 7193 7331 7333 7393 (1)超级素数的个数：16 (2)所有超级素数之和：68910 (3)最大的超级素数：7393 请按任意键继续. . .", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "题目描述：  一个素数，依次从低位去掉一位，二位，……，若所得的各数仍都是素数，则称超级素数。  例如：7331是个4位超级素数，因为7，73，733，7331均为素数. 试求1000~n之内(1000<n<9999)： (1)超级素数的个数 (2)所有超级素数之和 (3)最大的超级素数。", "referer": "user-0"}]}
{"question": "使用链表实现 图书管理系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "代码不全，问题不明确～", "referer": "user-0"}]}
{"question": "送分", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我知道了，粘贴在Code之间就可以了，谢谢！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用先把源文件截屏成图片再上传吗？但我看别人上传的代码是能在网页上选中复制的。又好象不是图片 2020-12-09 14:35:33#2得分 0 第一张图是怎么上传代码，这个位置选择语言的类型 第二张图是怎么上传图片。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "先把源文件截屏成图片再上传吗？但我看别人上传的代码是能在网页上选中复制的。又好象不是图片", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "", "referer": "user-0"}]}
{"question": "输入一个数按从大到小的规则插入已排好序的数组中（数组从大到小排序）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  //void main() int main() {     int i, j;     int a[6]={1,3,5,7,9}, n;      printf(\"请输入插入数组中的数:\");     scanf(\"%d\",&n); #if 1     for (i = 0; i < 5; i++)         if (n < a[i])             break;      for (j = 5; j > i ; j--) {         a[j] = a[j-1];     }     a[i] = n; #else      for(i=4;i>=0;i--)                         //从a[4]开始往前和n比叫较     {         if(n<a[i])                            //符合条件将a[i]后移         {             a[i+1]=a[i];             if(i==0)                     //若输入的数小于数组中最小的数，将a[0]赋值为n                 a[0]=n;         }         else         {             a[i+1]=n;                     //此时n介于数组最大最小数之间，a[i]<n,a[i+1]是空出来的，赋值n             break;         }     } #endif     for(i=0;i<6;i++)         printf(\"%4d\",a[i]); } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "是代码展示还是不啥问题？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "", "referer": "user-0"}]}
{"question": "谁可帮我解决这优美的语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:输出只看printf就好了，看了printf发现不看上面的代码也是可以的。最终的结果跟上面的定义和计算都没关系；  输出是%d输出，后面对应的是一个7.3浮点数（解析成double类型），前三个选项都没意义。B和C肯定不对，因为%d不会输出浮点数； A和D可能有一个对，但是3怎么来，也看不出来。  这个要熟悉一下，对于浮点数和整型数在内存里的表示是不一样的，结果是0。并且7.3默认是double类型 要更详细的分析这个问题，需要把7.3在内存里的表示，然后这个数再按照整型数输出来就知道为啥是0了。 真专业", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "输出只看printf就好了，看了printf发现不看上面的代码也是可以的。最终的结果跟上面的定义和计算都没关系；  输出是%d输出，后面对应的是一个7.3浮点数（解析成double类型），前三个选项都没意义。B和C肯定不对，因为%d不会输出浮点数； A和D可能有一个对，但是3怎么来，也看不出来。  这个要熟悉一下，对于浮点数和整型数在内存里的表示是不一样的，结果是0。并且7.3默认是double类型 要更详细的分析这个问题，需要把7.3在内存里的表示，然后这个数再按照整型数输出来就知道为啥是0了。", "referer": "user-0"}]}
{"question": "（C语言）编程实现，将1-1000间的所有超级素数显示出来。超级素数是各个位的数字都是素数，且本身也为素数的数。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "简单一点：  #include <stdio.h>  int main() {   int i, j, k, p[168] = {2, 3, 5, 7};    for (i = 11, k = 4; j = 1, i < 1000; i += 2)   {     while (j < k && p[j] < 32) if (!(i % p[j++])) break;     if (j == k || i % p[j - 1]) p[k++] = i;   }    for (i = 0; j = p[i] / 100, k = p[i] % 100 / 10, i < 168; i++)     if (p[i] < 9 || ((p[i] % 10 == 3 || p[i] % 10 == 7) &&                        (!j || j == 2 || j == 3 || j == 5 || j == 7) &&                         (k == 2 || k == 3 || k == 5 || k == 7)))       printf(\"%d\\n\", p[i]);    return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int main() {         int n[]={0,2,3,5,7};         int i,j,k,t;         for(i=0;i<5;i++)                 for(j=(i?1:0);j<5;j++)                         for(k=1;k<5;k++)                                 if(IsPrimeLT1k(t=100*n[i]+10*n[j]+n[k]))                                         printf(\"%d\\n\",t);         return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "在限定范围的情况下，要追求快可以离线制表，O(1)： int IsPrimeLT1k(int a) {         static unsigned int x[]={2693408940,673221152,34112136,2147625122,                 547359240,2150113416,2148008098,134382120,169910402,579338272,                 671221760,2283831426,33693728,142770216,2148049410,545785984,                 536873472,168304648,2189559810,8391200,2629770,537397282,                 545292320,35684488,537395234,681576960,2317353088,9052160,                 8423424,34087426,2156005504,673316896 };         return x[a/32]&(1<<(a%32)); }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用坛子里怎么都跟素数干上了，下面是我上午刚写的函数 #5楼 算法是最节约时间的", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 4 楼 user-6 的回复:上面代码，漏掉一个质数2。进一步修正如下： #include <stdio.h> #include <math.h>   int is_prime(int num);   int main(void) {     int i, tmp;          for (i = 1; i < 1000; i++) {         tmp = i;         if (is_prime(tmp)) {             while (is_prime(tmp % 10)) tmp /= 10;             if (tmp == 0) printf(\"%d \", i);         }     }       return 0; }   int is_prime(int num) {     int i, size;       if (num < 2) return 0;       size = (int)sqrt(num);     for (i = 2; i < size + 1; i++)         if (num % i == 0) return 0;       return 1; } 对于小于10的素数是不是也要进入while循环？", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "坛子里怎么都跟素数干上了，下面是我上午刚写的函数   bool IsPrime(int n) { \tif (n == 1) \t\treturn false;  \tif (n == 2 \t\t|| n == 3 \t\t|| n == 5 \t\t|| n == 7) \t{ \t\treturn true; \t}  \tif (n % 2 == 0) \t\treturn false;  \tif (n % 3 == 0) \t\treturn false;  \tif (n % 5 == 0) \t\treturn false;  \tif (n % 7 == 0) \t\treturn false;  \tdouble dn = sqrt(n); \tint cnt = (int)dn; \tfor (int i = 11; i <= cnt; i += 2) \t{ \t\tif (n % i == 0) \t\t\treturn false; \t}  \treturn true; }", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "上面代码，漏掉一个质数2。进一步修正如下： #include <stdio.h> #include <math.h>   int is_prime(int num);   int main(void) {     int i, tmp;          for (i = 1; i < 1000; i++) {         tmp = i;         if (is_prime(tmp)) {             while (is_prime(tmp % 10)) tmp /= 10;             if (tmp == 0) printf(\"%d \", i);         }     }       return 0; }   int is_prime(int num) {     int i, size;       if (num < 2) return 0;       size = (int)sqrt(num);     for (i = 2; i < size + 1; i++)         if (num % i == 0) return 0;       return 1; }", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "把2楼的main函数简化一下，如下，供参考： #include <stdio.h> #include <math.h>   int is_prime(int num);   int main(void) {     int i, tmp;          for (i = 1; i < 1000; i += 2) {         tmp = i;         if (is_prime(tmp)) {             while (is_prime(tmp % 10)) tmp /= 10;             if (tmp == 0) printf(\"%d \", i);         }     }       return 0; }   int is_prime(int num) {     int i, size;       if (num < 2) return 0;       size = (int)sqrt(num);     for (i = 2; i < size + 1; i++)         if (num % i == 0) return 0;       return 1; }", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "#include <stdio.h> #include <math.h>  int is_prime(int num);  int main(void) {      int i;     int tmp;      for (i = 1; i < 1000; i += 2) {         //printf(\"i = %d\\n\", i);         tmp = i;         if (is_prime(tmp)) {             if (tmp < 10) {                 printf(\"%d \", i);                 continue;             }             while (tmp) {                 if (is_prime(tmp % 10)) {                     tmp /= 10;                     continue;                 }                 break;             }             if (tmp == 0)                 printf(\"%d \", i);         }     }      return 0;  }  int is_prime(int num) {     int i;      if (num < 2)         return 0;      int size = (int)sqrt(num);     for (i = 2; i < size + 1; i++)         if (num % i == 0)             return 0;      return 1; }  供参考～", "referer": "user-0"}]}
{"question": "结构体排序， 每次按不同元素排列，使用同一个函数，这个语句与参数怎么写？谢谢了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主，这个是否符合你的要求，供参考：#include <stdio.h> #include <string.h> #include<algorithm.h> #include <iostream.h> struct student {     char name[20];     char tel [12]; };  int c;//控制排序规则   void outPut(student ss[]);  int compare(const student a, const student b) { \tif (c == 0)//按照姓名升序排序 \t{           return strcmp(a.name,b.name)<0;//strcmp是用来比较两个char型字符串的字典序大小  string.h头文件下 \t} \telse if (c == 1)//按照电话降序排序 \t{           return strcmp(a.tel,b.tel)>0; \t} }   int main(int argc, char* argv[]) {     student contacts[10] = { {\"LiLei\"    ,\"13678941562\"},                              {\"WangHao\"  ,\"15046523182\"},                              {\"WangDi\"   ,\"13598741863\"},                              {\"OuyangDan\",\"13875469871\"},                              {\"HanLi\"    ,\"13647152364\"},                              {\"Zhengchao\",\"15098563214\"},                              {\"Futong\"   ,\"13213254698\"},                              {\"FangYang\" ,\"15978632132\"},                              {\"BaiHao\"   ,\"15432145698\"},                              {\"Cenyu\"    ,\"15896566532\"} };      printf(\"姓名按增序排列:\\n\");     c =0;     sort(contacts,contacts+10,compare);     outPut(contacts);                      printf(\"电话号码按降序排列：\\n\");     c =1;     sort(contacts, contacts + 10,compare);     outPut(contacts);          system(\"pause\");     return 0;      }  void outPut(struct student ss[]) {     int i;     printf(\"          ------通讯录-------\\n\");     printf(\"          姓名\\t\\t\\电话\\t\\t\\n\");     for (i = 0; i < 10; i++)         printf(\"%20s\\t\\%12s\\t\\n\",ss[i].name,ss[i].tel);     printf(\"\\n\"); }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "如百度到别人写的  stu.cpp : Defines the entry point for the console application.   // #include \"stdafx.h\" //------------------------------------------指针排序-------------------------------------------------------------------------------   #include<stdio.h> #include<stdlib.h> #include<string.h>   #define N 3   //学生结构体 struct student{ \tlong stuNum; //学号 \tchar name[20];//姓名 \tchar idCard[18];//身份证 \tfloat score[3];//三门成绩 };   //根据学生姓名排序 void name_sort(student *stu,int n) { \tstudent temp; \tfor(int i=0;i<n-1;i++) \t{ \t\tfor(int j=0;j<n-1-i;j++) \t\t{ \t\t\tif(strcmp(stu[j].name,stu[j+1].name)>0) \t\t\t{ \t\t\t\ttemp =stu[j+1]; \t\t\t\tstu[j+1]=stu[j]; \t\t\t\tstu[j]=temp;   \t\t\t} \t\t} \t}   \tprintf(\"\\n\"); \tprintf(\"*根据学生姓名排序后的学生情况:\\n\\n\");   \tfor(int i=0;i<N;i++) \t{ \t\tprintf(\"第 %d 个学生信息:\\n学号：%ld\\t姓名：%s\\t身份证：%s\\t语文：%.2f\\t数学:%.2f\\t英语：%.2f\\n\\n\",i+1,stu[i].stuNum,stu[i].name,stu[i].idCard,stu[i].score[0],stu[i].score[1],stu[i].score[2]);   \t} } //根据身份证进行排序 void idCard_sort(student *stu,int n) { \tstudent temp; \tfor(int i=0;i<n-1;i++) \t{ \t\tfor(int j=0;j<n-1-i;j++) \t\t{ \t\t\tif(strcmp(stu[j].idCard,stu[j+1].idCard)>0) \t\t\t{ \t\t\t\ttemp =stu[j+1]; \t\t\t\tstu[j+1]=stu[j]; \t\t\t\tstu[j]=temp;   \t\t\t} \t\t} \t}     \tprintf(\"\\n\"); \tprintf(\"*根据学生身份证排序后的学生情况:\\n\\n\");   \tfor(int i=0;i<N;i++) \t{ \t\tprintf(\"第 %d 个学生信息:\\n学号：%ld\\t姓名：%s\\t身份证：%s\\t语文：%.2f\\t数学:%.2f\\t英语：%.2f\\n\\n\",i+1,stu[i].stuNum,stu[i].name,stu[i].idCard,stu[i].score[0],stu[i].score[1],stu[i].score[2]);   \t}     }   //根据学号进行排序   void stuNum_sort(student *stu,int n) { \t \tstudent temp; \tfor(int i=0;i<n-1;i++) \t{ \t\tfor(int j=0;j<n-1-i;j++) \t\t{ \t\t\tif(stu[j].stuNum>stu[j+1].stuNum) \t\t\t{ \t\t\t\ttemp =stu[j+1]; \t\t\t\tstu[j+1]=stu[j]; \t\t\t\tstu[j]=temp;   \t\t\t} \t\t} \t}     \tprintf(\"\\n\"); \tprintf(\"*根据学生学号排序后的学生情况:\\n\\n\");   \tfor(int i=0;i<N;i++) \t{ \t\tprintf(\"第 %d 个学生信息:\\n学号：%ld\\t姓名：%s\\t身份证：%s\\t语文：%.2f\\t数学:%.2f\\t英语：%.2f\\n\\n\",i+1,stu[i].stuNum,stu[i].name,stu[i].idCard,stu[i].score[0],stu[i].score[1],stu[i].score[2]); \t\t \t}     }   //main函数   int main() {   \tstruct student stu[N],*pStu;   \t//控制台屏幕变为蓝色背景 \tsystem(\"color 1f\");   \tprintf(\"请依次输入学生的学号，姓名，身份证，三门成绩(空格分开)\\n\"); \tfor(int i=0;i<N;i++) \t{ \t\tprintf(\"输入第 %d 个学生的信息\\n\",i+1); \t\tscanf(\"%ld%s%s%f%f%f\",&stu[i].stuNum,stu[i].name,stu[i].idCard,&stu[i].score[0],&stu[i].score[1],&stu[i].score[2]); \t\t \t} \t \tpStu=stu;       \t//清屏 \tsystem(\"cls\");     \tprintf(\"\\n*** 输入1 按照学生学号排序 ***\\n*** 输入2 按照学生姓名排序 ***\\n*** 输入3 按照学生身份证排序 ***\\n*** 输入0 退出 ***\\n\\n\");   \tprintf(\"请输入:\"); \tint t; \tscanf(\"%d\",&t);   \t//循环 \tdo{ \t\t//根据用户输入的值选择排序的字段 \t\tswitch (t) \t\t{ \t\tcase 1: \t\t\tstuNum_sort(pStu,N);//学号排序 \t\t\tbreak; \t\tcase 2: \t\t\tname_sort(pStu,N);//姓名排序 \t\t\tbreak;   \t\tcase 3: \t\t\tidCard_sort(pStu,N);//身份证排序 \t\t\tbreak;   \t\tdefault: \t\t\tname_sort(pStu,N); \t\t}     \t\tprintf(\"\\n请输入:\"); \t\tscanf(\"%d\",&t);   \t}while(t!=0);   \treturn 1; }             //------------------没有指针--------------------------------------------------------------------------------------------------   // //#include<stdio.h> //#include<stdlib.h> //#include<string.h> // //#define N 5 // 学生结构体 //struct student{ //\tlong stuNum; //学号 //\tchar name[20];//姓名 //\tchar idCard[18];//身份证 //\tfloat score[3];//三门成绩 //}; // // 根据学生姓名排序 //void name_sort(student stu[],int n) //{ //\tstudent temp; //\tfor(int i=0;i<n-1;i++) //\t{ //\t\tfor(int j=0;j<n-1-i;j++) //\t\t{ //\t\t\tif(strcmp(stu[j].name,stu[j+1].name)>0) //\t\t\t{ //\t\t\t\ttemp =stu[j+1]; //\t\t\t\tstu[j+1]=stu[j]; //\t\t\t\tstu[j]=temp; // //\t\t\t} //\t\t} //\t} // // //\tprintf(\"\\n\"); //\tprintf(\"*根据学生姓名排序后的学生情况:\\n\\n\"); //\t //\tfor(int i=0;i<N;i++) //\t{ //\t\tprintf(\"第 %d 个学生信息:\\n学号：%ld\\t姓名：%s\\t身份证：%s\\t语文：%.2f\\t数学:%.2f\\t英语：%.2f\\n\\n\",i+1,stu[i].stuNum,stu[i].name,stu[i].idCard,stu[i].score[0],stu[i].score[1],stu[i].score[2]); //\t\t //\t} // // //} 根据身份证进行排序 //void idCard_sort(student stu[],int n) //{ //\tstudent temp; //\tfor(int i=0;i<n-1;i++) //\t{ //\t\tfor(int j=0;j<n-1-i;j++) //\t\t{ //\t\t\tif(strcmp(stu[j].idCard,stu[j+1].idCard)>0) //\t\t\t{ //\t\t\t\ttemp =stu[j+1]; //\t\t\t\tstu[j+1]=stu[j]; //\t\t\t\tstu[j]=temp; // //\t\t\t} //\t\t} //\t} // // //\tprintf(\"\\n\"); //\tprintf(\"*根据学生身份证排序后的学生情况:\\n\\n\"); // //\tfor(int i=0;i<N;i++) //\t{ //\t\tprintf(\"第 %d 个学生信息:\\n学号：%ld\\t姓名：%s\\t身份证：%s\\t语文：%.2f\\t数学:%.2f\\t英语：%.2f\\n\\n\",i+1,stu[i].stuNum,stu[i].name,stu[i].idCard,stu[i].score[0],stu[i].score[1],stu[i].score[2]); // //\t} // // //} // 根据学号进行排序 // //void stuNum_sort(student stu[],int n) //{ //\tstudent temp; // //\tfor(int i=0;i<n-1;i++) //\t{ //\t\tfor(int j=0;j<n-1-i;j++) //\t\t{ //\t\t\tif(stu[j].stuNum>stu[j+1].stuNum) //\t\t\t{ //\t\t\t\ttemp =stu[j+1]; //\t\t\t\tstu[j+1]=stu[j]; //\t\t\t\tstu[j]=temp; // //\t\t\t} //\t\t} //\t} // // //\tprintf(\"\\n\"); //\tprintf(\"*根据学生学号排序后的学生情况:\\n\\n\"); // //\tfor(int i=0;i<N;i++) //\t{ //\t\tprintf(\"第 %d 个学生信息:\\n学号：%ld\\t姓名：%s\\t身份证：%s\\t语文：%.2f\\t数学:%.2f\\t英语：%.2f\\n\\n\",i+1,stu[i].stuNum,stu[i].name,stu[i].idCard,stu[i].score[0],stu[i].score[1],stu[i].score[2]); // //\t} // // //} // main函数 // //int main() //{ // //\tstruct student stu[N]; //\t //\t//控制台屏幕变为蓝色背景 //\tsystem(\"color 1f\"); // //\tprintf(\"请依次输入学生的学号，姓名，身份证，三门成绩(空格分开)\\n\"); //\tfor(int i=0;i<N;i++) //\t{ //\t\tprintf(\"输入第 %d 个学生的信息\\n\",i+1); //\t\tscanf(\"%ld%s%s%f%f%f\",&stu[i].stuNum,stu[i].name,stu[i].idCard,&stu[i].score[0],&stu[i].score[1],&stu[i].score[2]); // //\t} // //\t//清屏 //\tsystem(\"cls\"); //\t //\t //\t//printf(\"*你所输入的学生信息情况:\\n\"); //\t//for(i=0;i<N;i++) //\t//{ //\t//\tprintf(\"第 %d 个学生信息:\\n学号：%ld\\t姓名：%s\\t身份证：%s\\t语文：%.2f\\t数学:%.2f\\t英语：%.2f\\n\",i+1,stu[i].stuNum,stu[i].name,stu[i].idCard,stu[i].score[0],stu[i].score[1],stu[i].score[2]); //\t// //\t//} //\t // //\tprintf(\"\\n*** 输入1 按照学生学号排序 ***\\n*** 输入2 按照学生姓名排序 ***\\n*** 输入3 按照学生身份证排序 ***\\n*** 输入0 退出 ***\\n\\n\"); //\t //\tprintf(\"请输入:\"); //\tint t; //\tscanf(\"%d\",&t); //\t //\t//循环 //\tdo{ //\t\t//根据用户输入的值选择排序的字段 //\t\tswitch (t) //\t\t{ //\t\tcase 1: //\t\t\t\tstuNum_sort(stu,N);//学号排序 //\t\t\t\tbreak; //\t\tcase 2: //\t\t\t\tname_sort(stu,N);//姓名排序 //\t\t\t\tbreak; //\t\t\t\t //\t\tcase 3: //\t\t\t\tidCard_sort(stu,N);//身份证排序 //\t\t\t\tbreak; //\t\t\t //\t\tdefault: //\t\t\tname_sort(stu,N); //\t\t} // // //\t\tprintf(\"\\n请输入:\"); //\t\tscanf(\"%d\",&t); // //\t}while(t!=0); // // //\treturn 1; //}      再次说明下 ，，我不想 \tstuNum_sort(pStu,N);//学号排序 \t\t\t \t\t\tname_sort(pStu,N);//姓名排序 \t\t\t \t\t\tidCard_sort(pStu,N);//身份证排序  这三个分开写，意思写成一个函数即可", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include \"stdio.h\" #include \"string.h\" struct student {     char name[20];     char tel[12]; }; //void sort(student ss[]); void sort(struct student ss[], int (*cmp)(const student *, const student *)); void outPut(student ss[]);   static int cmp_as_name(const student *a1, const student *b1); static int cmp_as_tel(const student *a1, const student *b1); int main() {     student contacts[10] = { {\"LiLei\",\"13678941562\"},         {\"WangHao\",\"15046523182\"},         {\"WangDi\",\"13598741863\"},         {\"OuyangDan\",\"13875469871\"},         {\"HanLi\",\"13647152364\"},         {\"Zhengchao\",\"15098563214\"},         {\"Futong\",\"13213254698\"},         {\"FangYang\",\"15978632132\"},         {\"BaiHao\",\"15432145698\"},         {\"Cenyu\",\"15896566532\"} };     sort(contacts, cmp_as_name);     outPut(contacts);     sort(contacts, cmp_as_tel);     outPut(contacts);     return 0; }  static int cmp_as_name(const student *a1, const student *b1) {     return strcmp(a1->name, b1->name); }  static int cmp_as_tel(const student *a1, const student *b1) {     return strcmp(a1->tel, b1->tel); }  //void sort(struct student ss[]) void sort(struct student ss[], int (*cmp)(const student *, const student *)) {     int i,j;     student temp;     for (i = 0; i < 10 - 1; ++i)         for (j = i + 1; j < 10; ++j)         {             //if (ss[i].name[0] >= ss[j].name[0]) {             if (cmp(&ss[i], &ss[j]) > 0) {                 temp = ss[i];                 ss[i] = ss[j];                 ss[j] = temp;             }         } }   void outPut(struct student ss[]) {     int i;     printf(\"------通讯录-------\\n\");     printf(\"姓名\\t\\t电话\\t\\n\");     for (i = 0; i < 10; i++)         printf(\"%s\\t\\t%s\\t\\n\",ss[i].name,ss[i].tel);     printf(\"\\n\"); }   供参考~  用函数指针吧", "referer": "user-0"}]}
{"question": "直接插入排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%d \",&r[i]); 这是一个结构体呢？直接对结构体赋值怎么理解？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "错误的地方：#include<stdio.h> #define list_size 20  typedef int keytype; typedef int othertype;  typedef struct{         keytype   key;         othertype other_data; }recordtype;  void inssort(recordtype r[],int length) //排序操作算法有问题 //对记录数组r做直接插入排序，length为数组中待排序记录的数目 {     int i,j;     for(i=2;i<=length;i++)       {         r[0]=r[i];         j=i-1;         while(r[0].key<r[j].key)           {             r[j+1]=r[j];             j=j-1;          }       r[j+1]=r[0];     } }  int main(int argc, char* argv[]) {     int length=3,i;         // length的值没有     recordtype r[list_size]; // r应是结构体的数组，不是变量定义                               //输入     for (i = 0; i < length; i++)        {           scanf(\"%d\",&r[i]);//r 是变量的话，这里就错了        }     printf(\"\\n\");      inssort(r,length);                             //输出     for (i = 0; i < length; i++) {         printf(\"%d\", r[i]);     }     printf(\"\\n\");     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:r[j+1]=r[j];//这里把r[j+1]的值覆盖了，也就是r[j+1]的值丢失了 而且，r[0]是用来辅助的吗？r[0]=r[i]也会造成r[0]丢失。 看你这个插入排序其实就是选择排序的做法，你可以参考一下选择排序怎么做的 这是直接插入排序啊", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "r[j+1]=r[j];//这里把r[j+1]的值覆盖了，也就是r[j+1]的值丢失了 而且，r[0]是用来辅助的吗？r[0]=r[i]也会造成r[0]丢失。 看你这个插入排序其实就是选择排序的做法，你可以参考一下选择排序怎么做的", "referer": "user-0"}]}
{"question": "新手求助指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "修改后成功了，谢谢大神指点！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "scanf对于F应该用%lf，注意%后面是l（小写字母）不是数字1，另外，是小写的f，不是大写F;  改之后再试试～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "好的，我等会试下。请教，26行那里是不是应该是C大于40？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你输入80看看结果", "referer": "user-0"}]}
{"question": "tooptips控件是如何捕获到鼠标消息的？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "CWnd::SetCapture CWnd::GetCapture HWND WINAPI SetCapture(HWND hWnd); HWND WINAPI GetCapture(void); BOOL WINAPI ReleaseCapture(void);", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-1 的回复:CWnd::SetCapture CWnd::GetCapture HWND WINAPI SetCapture(HWND hWnd); HWND WINAPI GetCapture(void); BOOL WINAPI ReleaseCapture(void); 应该不是SetCapture吧 如果tooltip一直SetCapture，那么其他窗口连正常的点击都做不到了。。。 根据TTF_SUBCLASS的描述，应该是子类化。。。", "referer": "user-0"}]}
{"question": "大一指针 求助大佬帮助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两个函数也可以改的稍简略点：void aver1(int **p,int n1,int m1);//学生平均成绩 void aver2(int **q,int n1,int m1);//课程平均成绩  void aver1(int **p,int n1,int m1) {     int i,j;     int sum;     float aver;     for(i=0;i<n1;i++)       {          aver= 0;          sum = 0;          for(j=0;j<m1;j++)            {              sum += *(*(p+i)+j);            }          aver =((float)sum)/((float)m1);          printf(\"第%d个学生的平均成绩为%.2f分\\n\",i+1,aver);      }     printf(\"\\n\"); }  void aver2(int **q,int n1,int m1) {     int i,j;     int sum;     float aver;     for(j=0;j<m1;j++)        {           aver= 0;           sum = 0;           for(i=0;i<n1;i++)             {                sum += *(*(q+i)+j);             }           aver =((float)sum)/((float)n1);           printf(\"第%d个课程的平均成绩为%.2f分\\n\",j+1,aver);        } }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include \"stdafx.h\" #include <stdio.h> #include <stdlib.h> void aver1(int **p, int *n1, int *m1);//学生平均成绩，*p改为**p---------------- void aver2(int **q, int *n1, int *m1);//课程平均成绩 ,*q改为**q------------------ int main() {\t \tint n, m, *n1, *m1;//n代表行，m代表列  \tprintf(\"请输入学生个数和课程门数：\"); \tscanf(\"%d %d\", &n, &m); \tn1 = &n; m1 = &m; \t//int a[n][m];        //-----以下代码为动态分配二维数组----------- \tint** a = new int*[n]; \tfor (int i = 0; i < n; i++) \t{ \t\ta[i] = new int[m]; \t}  \tint i, j; \tfor (i = 0; i<n; i++) \t{ \t\tprintf(\"请输入第%d个学生的成绩：\", i + 1); \t\tfor (j = 0; j<m; j++) \t\t{ \t\t\tscanf(\"%d\", &a[i][j]); \t\t} \t} \tint **p, **q;//------改为指针的指针------- \tp = a;//----修改----- \tq = a;//-----修改---- \taver1(p, n1, m1); \taver2(q, n1, m1);  //-------以下代码为释放二维数组---------- \tfor (i = 0; i < n; ++i) \t{ \t\tdelete[] a[i]; \t} \tdelete[] a; \treturn 0; } void aver1(int **p, int *n1, int *m1) { \tint i, j; \tint sum[50] = { 0 };//------数组初始化------ \tfloat aver1; \tfor (i = 0; i<*n1; i++) \t{ \t\tfor (j = 0; j<*m1; j++) \t\t{ \t\t\tsum[i] += *((*(p + i) + j));//------修改------- \t\t\taver1 = ((float)sum[i]) / ((float)*m1); \t\t} \t\tprintf(\"第%d个学生的平均成绩为%.2f分\\n\", i + 1, aver1); \t} \tprintf(\"\\n\"); } void aver2(int **q, int *n1, int *m1) { \tint i, j; \tint sum[50] = { 0 };//------数组初始化------ \tfloat aver2; \tfor (j = 0; j<*m1; j++) \t{ \t\tsum[0] = 0; \t\tfor (i = 0; i<*n1; i++) \t\t{ \t\t\tsum[j] += *((*(q + i) + j));//------------修改------- \t\t\taver2 = ((float)sum[j]) / ((float)*n1); \t\t} \t\tprintf(\"第%d个课程的平均成绩为%.2f分\\n\", j + 1, aver2); \t} }  VS2015 C++环境调试  请参考《C++中动态分配多维数组》 《C++中的指针数组与数组指针》 希望能够帮到您！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h>  /* run this program using the console pauser or add your own getch, system(\"pause\") or input loop */ void aver1(int **p, int *n1, int *m1); //学生平均成绩 void aver2(int **q, int *n1, int *m1); //课程平均成绩 int main(int argc, char *argv[]) {     int n, m, *n1, *m1; //n代表行，m代表列     printf(\"请输入学生个数和课程门数：\");     scanf(\"%d %d\", &n, &m);     n1 = &n;     m1 = &m;     int i, j;     int **a = (int*)malloc(sizeof(int)*n);     for(i=0;i<m;i++){         a[i] = (int*)malloc(sizeof(int)*m);     }     for (i = 0; i < n; i++)     {         printf(\"请输入第%d个学生的成绩：\", i + 1);         for (j = 0; j < m; j++)         {             scanf(\"%d\", &a[i][j]);         }     }     aver1(a, n1, m1);     aver2(a, n1, m1);     return 0; } void aver1(int **p, int *n1, int *m1) {     int i, j;     int sum[50]={0};     float aver1;     for (i = 0; i < *n1; i++)     {         for (j = 0; j < *m1; j++)         {             //sum[i] += *(p + i) + j;             sum[i] += *(*(p + i) + j);         }         aver1 = ((float)sum[i]) / ((float)*m1);         printf(\"第%d个学生的平均成绩为%.2f分\\n\", i + 1, aver1);     }     printf(\"\\n\"); } void aver2(int **q, int *n1, int *m1) {     int i, j;     int sum[50]={0};     float aver2;     for (j = 0; j < *m1; j++)     {         for (i = 0; i < *n1; i++)         {             //sum[j] += *(q + i) + j;             sum[j] += *(*(q + i) + j);         }         aver2 = ((float)sum[j]) / ((float)*n1);         printf(\"第%d个课程的平均成绩为%.2f分\\n\", j + 1, aver2);     } }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include <stdio.h> #include <stdlib.h>  /* run this program using the console pauser or add your own getch, system(\"pause\") or input loop */ void aver1(int **p,int *n1,int *m1);//学生平均成绩 void aver2(int **q,int *n1,int *m1);//课程平均成绩  int main(int argc, char *argv[]) {     int n,m,*n1,*m1;//n代表行，m代表列     int i, j;     int **a;     printf(\"请输入学生个数和课程门数：\");     scanf(\"%d %d\",&n,&m);      a = (int **)malloc(sizeof(int *) * n);     if (!a)         return -1;      for (i = 0; i < n; i++) {         a[i] = (int *)malloc(sizeof(int) *m);         if (!a[i])             return -1;     }     n1=&n;m1=&m;     //int a[n][m];     //int i,j;     for(i=0;i<n;i++)     {         printf(\"请输入第%d个学生的成绩：\",i+1);         for(j=0;j<m;j++)         {             scanf(\"%d\",&a[i][j]);         }     }     int *p,*q;     p=&a[0][0];     q=&a[0][0];     aver1(a,n1,m1);     aver2(a,n1,m1);     return 0; } void aver1(int **p,int *n1,int *m1) {     int i,j;     //int sum[50];     int sum;     float aver1;     for(i=0;i<*n1;i++)     {         sum=0;         for(j=0;j<*m1;j++)         {             //sum += *(p+i)+j;             sum += p[i][j];             aver1 = sum * 1.0/(*m1);         }         printf(\"第%d个学生的平均成绩为%.2f分\\n\",i+1,aver1);     }     printf(\"\\n\"); } void aver2(int **q,int *n1,int *m1) {     int i,j;     //int sum[50];     int sum;     float aver2;     for(j=0;j<*m1;j++)     {         //sum[0]=0;         sum = 0;         for(i=0;i<*n1;i++)         {             //sum[j] += *(q+i)+j;             sum += q[i][j];             //aver2=((float)sum[j])/((float)*n1);             aver2 = sum * 1.0/(*n1);         }         printf(\"第%d个课程的平均成绩为%.2f分\\n\",j+1,aver2);     }     for (i = 0; i < n; i++)         free(a[i]);     free(a); } 供参考～  注意n,m不确定大小，a的数组不能确定，因此可以考虑用动态申请空间（定义数组是静态申请空间）", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 丿烟花易冷的回复:编写一个函数，统计n个学生m门课程，每个学生的平均分和每门课程的平均分。在主函数中输入5个学生4门课程的成绩，调用函数，输出每个学生的平均成绩和每门课程的平均成绩。要求，不允许使用全局变量和全局数组。 这是需求。。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "编写一个函数，统计n个学生m门课程，每个学生的平均分和每门课程的平均分。在主函数中输入5个学生4门课程的成绩，调用函数，输出每个学生的平均成绩和每门课程的平均成绩。要求，不允许使用全局变量和全局数组。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "#include <stdio.h> #include <stdlib.h>  /* run this program using the console pauser or add your own getch, system(\"pause\") or input loop */ void aver1(int *p,int *n1,int *m1);//学生平均成绩 void aver2(int *q,int *n1,int *m1);//课程平均成绩  int main(int argc, char *argv[]) { \tint n,m,*n1,*m1;//n代表行，m代表列  \tprintf(\"请输入学生个数和课程门数：\"); \tscanf(\"%d %d\",&n,&m); \tn1=&n;m1=&m; \tint a[n][m]; \tint i,j; \tfor(i=0;i<n;i++) \t{ \t\tprintf(\"请输入第%d个学生的成绩：\",i+1); \t\tfor(j=0;j<m;j++) \t\t{ \t\t\tscanf(\"%d\",&a[i][j]); \t\t} \t} \tint *p,*q; \tp=&a[0][0]; \tq=&a[0][0]; \taver1(p,n1,m1); \taver2(q,n1,m1); \treturn 0; } void aver1(int *p,int *n1,int *m1) { \tint i,j; \tint sum[50]; \tfloat aver1;     for(i=0;i<*n1;i++)     {     \tsum[0]=0;     \tfor(j=0;j<*m1;j++)     \t{     \t\tsum[i]+=*(p+i)+j;     \t\taver1=((float)sum[i])/((float)*m1); \t\t}     \tprintf(\"第%d个学生的平均成绩为%.2f分\\n\",i+1,aver1); \t} \tprintf(\"\\n\");  }  void aver2(int *q,int *n1,int *m1) { \tint i,j; \tint sum[50]; \tfloat aver2;     for(j=0;j<*m1;j++)     {     \tsum[0]=0;     \tfor(i=0;i<*n1;i++)     \t{     \t\tsum[j]+=*(q+i)+j;     \t\taver2=((float)sum[j])/((float)*n1); \t\t}     \tprintf(\"第%d个课程的平均成绩为%.2f分\\n\",j+1,aver2); \t} }", "referer": "user-0"}]}
{"question": "求蜂考离散数学5小时视频", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "需要私聊", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "同求同求。。。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "同求，，，，", "referer": "user-0"}]}
{"question": "救救孩子", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 1 楼 六道佩恩 的回复:在大括号前加一个显示转换——(person)，如果不支持，在工具——编译选项，编译或链接命令中，添加开启C99或C11标准，如-std=c11  对，复合字面值C99开始支持了。        x[0] = (struct person){\"Alice\", 18};  //or, 指定成员初始化 x[0] = (struct person){.name=\"Alice\", .num=18};", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "供参考：typedef struct Person{         int  num;         char name[20];         int  sex;         char group;         int  score1;         int  score2;         int  score3; }person;   int main(int argc, char* argv[]) {         person x[3] = {           {1,\"Alice\",0,'A',90,77,95},           {2,\"Tony\" ,1,'B',92,78,93},           {3,\"Tom\"  ,1,'C',87,90,78}         };         int i;         for(i=0;i<3;i++)             printf(\"%d %s %d %c %d %d %d\\n\",x[i].num,x[i].name,x[i].sex,x[i].group,x[i].score1,x[i].score2,x[i].score3);         system(\"pause\");         return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "我的映像中赋值不能这样写，初始化的时候才可以这样用吧。 写成  person x[3]={{...},{...},{...}}; ...是x[0],x[1],x[2]的内容。这样试试看", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "赋值有问题，这样的赋值一般是在初始化的时候，否则需要一个结构体成员一个结构体成员的赋值；  person x[3] = { {}, {}, {}}; 把三个成员的初始化放在一起；  要么就是  x[0].num  = 1; strcpy(x[0].name, \"Alice\"); ... 下面的一样", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "person x[3] = { {xx,xx,xx,xx},                          {xx,xx,xx,xx},                          {xx,xx,xx,xx}, }; 可以这样初始化", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "在大括号前加一个显示转换——(person)，如果不支持，在工具——编译选项，编译或链接命令中，添加开启C99或C11标准，如-std=c11", "referer": "user-0"}]}
{"question": "c语言 bmp文件压缩解压缩", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 ctrigger 的回复:[quote=引用 2 楼 litchee1988 的回复:]关键是我找了几个，压缩效果均不佳，所以我再问的 大牛们的效果都不佳？还是你自己没弄好？？[/quote]  引用 3 楼 赵4老师 的回复:[quote=引用 2 楼 litchee1988 的回复:]关键是我找了几个，压缩效果均不佳，所以我再问的 压缩效果要好，干脆转jpg或png[/quote]  关键就是不让转成别的格式处理呀，就是bmp格式的", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我查了几个，说是对bmp压缩效率一般，所以我就想问问有没有人处理过这种的", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 2 楼 litchee1988 的回复:关键是我找了几个，压缩效果均不佳，所以我再问的 大牛们的效果都不佳？还是你自己没弄好？？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 2 楼 litchee1988 的回复:关键是我找了几个，压缩效果均不佳，所以我再问的 压缩效果要好，干脆转jpg或png", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "关键是我找了几个，压缩效果均不佳，所以我再问的", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "找个开源的图像处理库，把这部分代码挖出来不就行了么？", "referer": "user-0"}]}
{"question": "关于条件运算符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "@user-3，你对的，应该是这个return( a>b ? (a>c? a:c) ：(b>c? b:c))，我的理解出错了，非常感谢二位！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "temp有没初始化没关系，我可以初下的，这里有二个三目运算，是右结合的，所以先从最右的那个开始算，下标越界啥界？不是己注释掉了嘛，怎么没高人啊？？？？？？？？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "需要弄明白三目运算符的逻辑关系；这个三目运算符是结果里还有三目运算符；  另外，楼主没发现数组有越界访问的行为吗？  数组最大是3，那么n-4这样的下表不已经是越界了吗？越界行为是未定义的，结果是未定义的。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "temp还没初始化就使用了,条件运算符就是if实现,根据左边式子真假来选择执行分支.", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用return( a>b ? (a>c? a:c) ：(b>c? b:c)) 你这个还是有问题，第2个表达式结果一定是a?第3个表达式结果一定是b?我觉得你的式子逻辑有问题，还有我的对，但就不知哪里出错了 你是想偏了，公式里第一步如果a>b条件成立，是不是就进入到 表达式1=(a>c? a:c) 这里去执行了，这里面又是一个条件判断表达式a>c? a:c，如果a>c成立则返回a,如果不成立是不就回c了，怎么会是始终是a呢。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "三元表达式多条件判断： 语法： 条件表达式 ？表达式1 ：表达式2 条件表达式是判断的条件，判断结果为bool型，为true时调用表达式1，为false时调用表达式2。 跟后面括不括号没什么关系啊。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "return( a>b ? (a>c? a:c) ：(b>c? b:c)) 你这个还是有问题，第2个表达式结果一定是a?第3个表达式结果一定是b?我觉得你的式子逻辑有问题，还有我的对，但就不知哪里出错了", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "简化下，就是这公式：return( a>b ? (a>c? a:c) ：(b>c? b:c))", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "我只是想知道那个return里的表达式错在哪里，希望高手进来解释一下。谢谢！！！", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "//return(a[n-3]>temp?a[n-3]:(temp=a[n-1]>a[n-2]?a[n-1]:a[n-2]));//一开始tmpe没赋值，先执行判断a[n-3]>temp就出错了。 return(a[n-3]>a[n-2]?a[n-3]:(a[n-2]>a[n-1]?a[n-2]:a[n-1])); 为什么会“先执行判断a[n-3]>temp”，后面有个小括号，应该先算小括号里的啊，怎么会先判断a[n-3]>temp呢？", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "return(a[n-3]>a[n-2]?a[n-3]:(a[n-2]>a[n-1]?a[n-2]:a[n-1])); 你这条语句有问题，你怎么知道右边的条件运算表达式运算的结果一定是a[n-2]呢？也有可能是a[n-1]，二者都有可能的啊", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "前面还是有漏洞的，修改如下，供参考：#include<stdio.h> int max(int a[],int n) { int temp; //return(a[n-4]>temp?a[n-4]:(temp=a[n-3]>temp?a[n-3]:(temp=a[n-1]>a[n-2]?a[n-1]:a[n-2])));  //return(a[n-3]>temp?a[n-3]:(temp=a[n-1]>a[n-2]?a[n-1]:a[n-2]));//一开始tmpe没赋值，先执行判断a[n-3]>temp就出错了。 return(a[n-3]>a[n-2]?(a[n-3]>a[n-1]?a[n-3]:a[n-1]):(a[n-2]>a[n-1]?a[n-2]:a[n-1])); //printf(\"%d,%d\\n\",temp,temp1); //return temp; }  int main(int argc, char* argv[]) {     int m[3],n=0;     printf(\"请输入3个整数！\\n\");     while(n<3){         scanf(\"%d\",&m[n++]);     }    printf(\"最大数为：%d\\n\",max(m,3));    system(\"pause\");    return 0; }", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "问题见标注处,供参考：#include<stdio.h> int max(int a[],int n) { int temp; //return(a[n-4]>temp?a[n-4]:(temp=a[n-3]>temp?a[n-3]:(temp=a[n-1]>a[n-2]?a[n-1]:a[n-2])));  //return(a[n-3]>temp?a[n-3]:(temp=a[n-1]>a[n-2]?a[n-1]:a[n-2]));//一开始tmpe没赋值，先执行判断a[n-3]>temp就出错了。 return(a[n-3]>a[n-2]?a[n-3]:(a[n-2]>a[n-1]?a[n-2]:a[n-1]));  //printf(\"%d,%d\\n\",temp,temp1); //return temp; }  int main(int argc, char* argv[]) {     int m[3],n=0;     printf(\"请输入3个整数！\\n\");     while(n<3){         scanf(\"%d\",&m[n++]);     }    printf(\"最大数为：%d\\n\",max(m,3));    system(\"pause\");    return 0; }", "referer": "user-0"}]}
{"question": "离散数学实验求解，基础题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int vote(int a, int b, int c, int d, int e) {   return (a && b &&c) || (a && b &&d) ||          (a && b &&e) || (a && c &&d) ||          (a && c &&e) || (a && d &&e) ||          (b && c &&d) || (b && c &&e) ||          (b && d &&e) || (c && d &&e); }", "referer": "user-0"}]}
{"question": "求助 怎么链表插入不运行和求表长为0 但不报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <malloc.h> #include <stdlib.h>  typedef struct Node{     int data;  //数据域     struct Node *next;  //指针域 }node, *PNODE;  //函数声明 PNODE create_list(); void show_list(PNODE); bool empty_list(PNODE); void length_list(PNODE); bool insert_list(PNODE,int,int);  int main() {     PNODE L = NULL;  //     L = create_list();  //创建非循环单链表，把链表头节点地址赋给head  动态内存分配     show_list(L);     empty_list(L);     insert_list(L,3,5);     show_list(L);     length_list(L);     return 0; }  PNODE create_list()  //创建函数 {     int len,val,i;     PNODE phead =(PNODE)malloc(sizeof(node));     if (phead == NULL)     {         printf(\"内存分配失败\");         exit(-1);     }     PNODE p=phead;     p->next = NULL;     printf(\"请输入链表个数：\");     scanf(\"%d\",&len);     for(i=0;i<len;i++)     {         printf(\"第%d个结点的值为:\",i+1);         scanf(\"%d\",&val);         PNODE pnew =(PNODE)malloc(sizeof(node));         if (pnew == NULL)         {             printf(\"内存分配失败\");             exit(-1);         }         pnew->data = val;         p->next = pnew;         pnew->next = NULL;         p = pnew;     }     return phead; }  void show_list(PNODE phead)   //遍历输出 {     PNODE p = phead->next;     while(p != NULL)     {         printf(\"%d \",p->data);         p = p->next;     }     printf(\"\\n\"); }  bool empty_list(PNODE phead)   //判断链表是否为空 {     //if(phead->next=NULL)     if(phead->next==NULL)         return true;     else         return false; }  void length_list(PNODE phead) {     int i=0;     PNODE p = phead->next;     while(p !=NULL)     {         i++;         p=p->next;     }     printf(\"链表长度为 %d\",i); }  bool insert_list(PNODE phead,int n,int m)   //插入第n个元素m {     int i = 0;     PNODE p = phead,s;     if(n < 1)         return false;     while(i < n-1 && p!= 0)     {         i++;         p = p-> next;     }     //if(p = NULL)     if(p == NULL)         return false;     else{         s=(PNODE)malloc(sizeof(node));         s->data=m;         s->next=p->next;         p->next=s;         return true;     } } 供参考～", "referer": "user-0"}]}
{"question": "C程序hungman游戏", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这种吗？", "referer": "user-0"}]}
{"question": "C语言UI设计关于声明ID的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 ooolinux的回复:个人觉得SDK纯API方式编写Windows程序已经过时了，效率太低，了解一下原理就可以了，主要是消息机制。  图形用户界面（GUI）编程可以学习C++ Builder，架构先进（和C#一样拖控件），入门比较容易。  　　C++ Builder是真正的可视化的开发工具。C++ Builder可以用鼠标拖拉控件加上设置属性轻松的“设计”出一个程序的图形用户界面，利用可视的组件/控件像“搭积木”一样，以“所见即所得”的方式搭建应用程序的界面，这也是C++ Builder这个名字中Builder的概念。这样，只需要用C++语言编写业务逻辑代码，类似于DOS下文本界面编程，只要专注于实现业务逻辑功能就可以了，代码非常简洁。数据的输入和表现，都在图形用户界面，非常直观、易用。这就是RAD开发（Rapid Application Development，快速应用程序开发）。  书籍推荐： 《C++Builder 6程序设计教程（第二版）》 （陆卫忠，刘文亮　等编著 /2011-04-01 /科学出版社）（当当网） 《C++Builder 6编程实例精解》（赵明现），PDF，是数字版的，非扫描版的，里面还有一个俄罗斯方块游戏的完整实现。 《精彩C++Builder 6程序设计》（台湾 吴逸贤），里面有10几个简单小游戏的实现，可以自己看懂以后再重写，才是自己掌握的。 《C++ Builder 5高级编程实例精解》（刘滨 编著）都是较大的实用的程序。  C++ Builder 6.0几个示例程序项目源代码下载：       C++ Builder第一个程序（模拟聊天室）v1.11 C++ Builder模拟数字双时钟示例（未完成）v0.2.1 C++ Builder纸牌游戏Demo v0.03 C++ Builder不规则图像透明贴图（位图的透明显示）三种方法及简单动画v1.3 C++ Builder写的《ZEC 四则运算练习程序》 海底海星情景v0.9.2 C++ Builder简单电话簿Demo例子v1.11 多谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "那个是打字错误，你的代码里和我从你那复制下来那行都是错的，重新更正就好。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "3楼正解  引用 3 楼 forever74 的回复:#include \"resource.h\"   DialogBox(hinstCurrent,MAKEINRESOURSE(IDD_DIALOG1),NULL,(DLGPROC)WndProc);", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 forever74的回复:#include \"resource.h\"   DialogBox(hinstCurrent,MAKEINRESOURSE(IDD_DIALOG1),NULL,(DLGPROC)WndProc); 多谢大佬 原来差在没包含resource头文件 不过还有一个错误是 MAKEINRESOURCE标识符无法识别？ 不过它是啥？ 求教", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "个人觉得SDK纯API方式编写Windows程序已经过时了，效率太低，了解一下原理就可以了，主要是消息机制。  图形用户界面（GUI）编程可以学习C++ Builder，架构先进（和C#一样拖控件），入门比较容易。  　　C++ Builder是真正的可视化的开发工具。C++ Builder可以用鼠标拖拉控件加上设置属性轻松的“设计”出一个程序的图形用户界面，利用可视的组件/控件像“搭积木”一样，以“所见即所得”的方式搭建应用程序的界面，这也是C++ Builder这个名字中Builder的概念。这样，只需要用C++语言编写业务逻辑代码，类似于DOS下文本界面编程，只要专注于实现业务逻辑功能就可以了，代码非常简洁。数据的输入和表现，都在图形用户界面，非常直观、易用。这就是RAD开发（Rapid Application Development，快速应用程序开发）。  书籍推荐： 《C++Builder 6程序设计教程（第二版）》 （陆卫忠，刘文亮　等编著 /2011-04-01 /科学出版社）（当当网） 《C++Builder 6编程实例精解》（赵明现），PDF，是数字版的，非扫描版的，里面还有一个俄罗斯方块游戏的完整实现。 《精彩C++Builder 6程序设计》（台湾 吴逸贤），里面有10几个简单小游戏的实现，可以自己看懂以后再重写，才是自己掌握的。 《C++ Builder 5高级编程实例精解》（刘滨 编著）都是较大的实用的程序。  C++ Builder 6.0几个示例程序项目源代码下载：       C++ Builder第一个程序（模拟聊天室）v1.11 C++ Builder模拟数字双时钟示例（未完成）v0.2.1 C++ Builder纸牌游戏Demo v0.03 C++ Builder不规则图像透明贴图（位图的透明显示）三种方法及简单动画v1.3 C++ Builder写的《ZEC 四则运算练习程序》 海底海星情景v0.9.2 C++ Builder简单电话簿Demo例子v1.11", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "重新建一个MFC项目吧，还来得快些", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "用记事本打开.rc文件，对照.h和.cpp文件中的各ID修改为一致。", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "#include \"resource.h\"   DialogBox(hinstCurrent,MAKEINRESOURSE(IDD_DIALOG1),NULL,(DLGPROC)WndProc);", "referer": "user-0"}]}
{"question": "C语言求cos的值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 棉猴的回复:正像楼上朋友所说的，题目要求是“保持到最后一项的绝对值小于10-6”，也就是说，当小于10-6时，是要加入到算式里的，不能直接break #include <stdlib.h> #include <math.h>  int main() {\t \tdouble x, a, c, b = 1, y = 1; \tint i; \tscanf(\"%lf\", &x); \tfor (i = 1; i > 0; i++) \t{ \t\ta = pow(x, i); \t\tb *= i; \t\tif (i % 2 == 0) \t\t{ \t\t\tc = a / b; \t\t} \t\telse \t\t{ \t\t\tcontinue; \t\t} \t\t  \t\tif (i % 4 != 0 || i == 2) \t\t{ \t\t\tc = 0 - (a / b); \t\t\ty += c; \t\t} \t\telse \t\t{ \t\t\ty += (a / b); \t\t}  \t\tif (fabs(a / b) < pow(10, -6)) \t\t{ \t\t\tbreak; \t\t} \t} \tprintf(\"%lf\\n\", y); \treturn 0; } VS2015 C++环境  好的👌🏻，感谢感谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 user-2的回复:你还没明白我的意思 最后一项 比如 a/b < 10∧-6，这 a/b 要加还是不加？题目要求是加（保持到最后一项的绝对值小于10∧-6） 但是你的程序 a/b < 10∧-6 就已经 break，后续的加没法处理，所以漏了一项。正确的做法应该把  if(fabs(a/b) < 10∧-6) break 放在for 循环的最后，也就是 y+=执行完后才break 哦哦好的，谢谢哈", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "正像楼上朋友所说的，题目要求是“保持到最后一项的绝对值小于10-6”，也就是说，当小于10-6时，是要加入到算式里的，不能直接break #include <stdlib.h> #include <math.h>  int main() {\t \tdouble x, a, c, b = 1, y = 1; \tint i; \tscanf(\"%lf\", &x); \tfor (i = 1; i > 0; i++) \t{ \t\ta = pow(x, i); \t\tb *= i; \t\tif (i % 2 == 0) \t\t{ \t\t\tc = a / b; \t\t} \t\telse \t\t{ \t\t\tcontinue; \t\t} \t\t  \t\tif (i % 4 != 0 || i == 2) \t\t{ \t\t\tc = 0 - (a / b); \t\t\ty += c; \t\t} \t\telse \t\t{ \t\t\ty += (a / b); \t\t}  \t\tif (fabs(a / b) < pow(10, -6)) \t\t{ \t\t\tbreak; \t\t} \t} \tprintf(\"%lf\\n\", y); \treturn 0; } VS2015 C++环境", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你还没明白我的意思 最后一项 比如 a/b < 10∧-6，这 a/b 要加还是不加？题目要求是加（保持到最后一项的绝对值小于10∧-6） 但是你的程序 a/b < 10∧-6 就已经 break，后续的加没法处理，所以漏了一项。正确的做法应该把  if(fabs(a/b) < 10∧-6) break 放在for 循环的最后，也就是 y+=执行完后才break", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-2的回复:少加了最后一项，因为最后一项满足if就break了，所以最后一项没加上 可是题目说小于10∧-6，如果改成＜＝，运行其他值的时候不会有误差吗？？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "少加了最后一项，因为最后一项满足if就break了，所以最后一项没加上", "referer": "user-0"}]}
{"question": "这个链表创建函数哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "思路：C++，创建要给结点类，一个链表类。用结点构造函数创建结点，再插入链表类即可。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "感觉不伦不类的，看着眼晕。C++，就要class，用成员函数create即可。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "把代码复制粘贴过来不好吗，非得c语句和c++混合用吗？要不单用c要不单用c++，一会cin，一会printf，重新写过吧", "referer": "user-0"}]}
{"question": "用指针法在一维有序数组中插入数据，要求在其中插入任意一个整数后数列依然有序。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先要先找到对应的位置，然后将该位置和之后的数据都想后移动一个元素的偏移，最后把要插入的数据放入该位置。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "凡事说起来容易，做起来难： 有序？从小到大还是从大到小？ 数组？静态数组还是动态数组？静态数组的话，最多几个元素？动态数组的话，malloc？new？vector？ 空数组？申请空间失败咋办？ 小心使得万年船。 百度搜“树上七只鸟 程序员”", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "用指针依次访问数组数据，当要插入的数据大于当前的数且小于后一个数，将之后所有的数据后移 插入要插入的值", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "最原始的办法： 先定义一个同类型的指针，判断原指针当前值不为NULL时，与待插入的数据比较，若比待插入的数据大，则先赋值 待插入的数，然后再依次 将余下的数复制到新的指针里，数据依然有序；", "referer": "user-0"}]}
{"question": "求助大佬们，我的部分删除模块实在是写不出，要求再代码开头的注释中", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "#include<stdio.h>//密码，新建，浏览，删除原有数据，删除一条数据，查找，添加 #include<conio.h> #include<stdlib.h> #include<string.h> #define M 20  struct conect//结构体 { \tchar name[11]; \tchar telnum[12];//电话号码 \tchar address[100];//地址 \tint f;//标签 }; int N=0;//总人数的全局变量 int n; int num;//总人数 struct conect c[10];//结构体数量 struct conect cc;  int main(void) { \tvoid input(),expl(),meun(), password(), save(),read(),serch(), dele(),dele_all(); \tvoid dele_menu(),newsave(); \tvoid dele_save();//部分删除函数  \tint choice; \t \t//password(); \tsystem(\"pause\"); \tsystem(\"cls\"); \twhile (1) \t{ \t\tmeun(); \t\tprintf(\"\\t\\t\\t\\t\\t\\t\"); \t\tscanf(\"%d\", &choice); \t\tswitch (choice) \t\t{ \t\tcase 1:input();break; \t\tcase 2:expl();break; \t\tcase 3:save();break; \t\tcase 4:read();break; \t\tcase 5:serch();break; \t\tcase 6:dele_menu();break; \t\tcase 7:newsave();break; \t\tcase 0:exit(0); \t\t} \t\tprintf(\"\\n\"); \t\tsystem(\"pause\");//暂停函数  \t\tsystem(\"cls\");//清屏函数  \t\t \t}  } void input()//输入数据函数 { \tint i; \tprintf(\"\\t\\t\\t\\t\\t\\t输入人数:\"); \tscanf(\"%d\", &num); \tn = N; \tfor (i = N;i < num+n;i++,N++) \t{ \t\tprintf(\"\\t\\t\\t\\t\\t\\t姓名：\"); \t\tscanf(\"%s\", c[i].name); \t\tprintf(\"\\t\\t\\t\\t\\t\\t电话：\"); \t\tscanf(\"%s\", c[i].telnum); \t\tprintf(\"\\t\\t\\t\\t\\t\\t地址：\"); \t\trewind(stdin); \t\tgets(c[i].address); \t\tprintf(\"\\t\\t\\t\\t\\t\\t标签：\"); \t\tscanf(\"%d\", &c[i].f); \t\tprintf(\"\\n\"); \t\tN++; \t} } void expl()//浏览输入为保存信息（时效性） { \tint i; \tprintf(\"%12s%12s%30s%10s\\n\", \"姓名\", \"电话\", \"地址\", \"标签\"); \tfor (i = 0;i < num+N ;i++) \t{ \t\tprintf(\"%12s%12s%30s\", c[i].name, c[i].telnum, c[i].address); \t\tswitch (c[i].f) \t\t{ \t\tcase 1:printf(\"      亲戚\\n\");break; \t\tcase 2:printf(\"      同事\\n\");break; \t\tcase 3:printf(\"      朋友\\n\");break; \t\t} \t} } void meun() { \tprintf(\"\\t\\t\\t\\t\\t\\t1.录入联系人\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t2.浏览通讯录\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t3.保存联系人\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t4.读取文件\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t5.查找联系人\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t6.删除联系人\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t7.新建文件\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t0.退出\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t请输入1-2\\n\"); \t } void dele_menu() { \tint a; \tprintf(\"\\t\\t\\t\\t\\t\\t1.删除未保存联系人\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t2.删除已保存联系人\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t3.删除全部联系人\\n\"); \tscanf(\"%d\",&a); \tswitch (a) \t{ \tcase 1:dele();break; \tcase 2:dele_save();break; \tcase 3:dele_all();break; \tdefault: \t\tbreak; \t}  } void password()  { \tchar password[10] = \"123456\";//正确密码 \tchar ps[10];//定义一个新数组用与正确答案做对比 \tint i,j;   \tprintf(\"\\n\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t================================\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t         用户登录系统\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t================================\\n\"); \tprintf(\"\\n\\n\"); \tfor (j = 0;j < 4;j++) \t{ \t\ti = 0; \t\tprintf(\"\\t\\t\\t\\t\\t\\t请输入密码.\\n\"); \t\tprintf(\"\\t\\t\\t\\t\\t\\t密码:\");     \twhile ((ps[i] = getch()) != 13)//用于替换*号，且回车结束输入判断 \t\t{ \t\t\tif (ps[i] == '\\b')//（\\b）退格符，在此用于发挥删除功能 \t\t\t{ \t\t\t\tprintf(\"\\b \\b\");//起删除功能 \t\t\t\ti--;//向后减少一位将光标提前 \t\t\t} \t\t\telse \t\t\t{ \t\t\t\tprintf(\"*\"); \t\t\t\ti++; \t\t\t} \t\t\t \t\t} \t\tps[i] = '\\0'; \t\tprintf(\"\\n\"); \t\tif (strcmp(password, ps) == 0) \t\t{ \t\t\tprintf(\"\\n\\n\"); \t\t\tprintf(\"\\t\\t\\t\\t\\t\\t================================\\n\"); \t\t\tprintf(\"\\t\\t\\t\\t\\t\\t           欢迎用户！           \\n\"); \t\t\tprintf(\"\\t\\t\\t\\t\\t\\t================================\\n\"); \t\t\tprintf(\"\\n\\n\"); \t\t\tbreak; \t\t} \t\telse \t\t{ \t\t\tprintf(\"\\t\\t\\t\\t\\t\\tNO!\\n\"); \t\t\tif (3 - j == 0) \t\t\t{ \t\t\t\tprintf(\"\\t\\t\\t\\t\\t\\t全部错误自动退出！\"); \t\t\t\texit(0); \t\t\t} \t\t\tprintf(\"\\t\\t\\t\\t\\t\\t还有%d次机会！\\n\", 3 - j); \t\t}  \t} }  void save()//内容储存函数 { \tFILE* fp; \tint* a; \tint i;  \tfp = fopen(\"conect.dat\",\"wb\");//建立一个文件并且打开写入类容 \tfor (i = 0;i < N;i++) \t{ \t\tfwrite(&c[i],sizeof(struct conect),1,fp);//写入文件块 \t}  \tfclose(fp);//关闭文件 \tprintf(\"保存成功\\n\"); } void read()//类容读取函数 { \tFILE *fp;//指针变量的定义 \tint i;  \tfp = fopen(\"conect.dat\", \"ab+\");//建立一个文件并且打开写入类容 \tprintf(\"%12s%12s%30s%10s\\n\", \"姓名\", \"电话\", \"地址\", \"标签\"); \twhile(1) \t{ \t\tfread(&cc, sizeof(struct conect), 1, fp);//读取文件块 \t\tif (feof(fp))//file end of 结束标志 \t\t{ \t\t\tbreak; \t\t} \t\tprintf(\"%12s%12s%30s\", cc.name, cc.telnum, cc.address); \t\tswitch (cc.f) \t\t{ \t\tcase 1:printf(\"      亲戚\\n\");break; \t\tcase 2:printf(\"      同事\\n\");break; \t\tcase 3:printf(\"      朋友\\n\");break; \t\t} \t} \tfclose(fp);//关闭文件   } void serch()//查询函数 { \tint i; \tint flag = 0; \tchar t_name[M]; \tFILE* fp;  \tfp = fopen(\"conect.dat\", \"ab+\");//打开原文件 \tprintf(\"\\n\\t\\t\\t\\t\\t\\t--------------------------------------\\n\"); \tprintf(\"\\t\\t\\t\\t\\t\\t输入你要查询的姓名=\"); \tscanf(\"%s\", t_name); \tprintf(\"\\n\"); \tprintf(\"\\n\"); \tprintf(\"\\n\"); \tprintf(\"%12s%12s%30s%10s\\n\", \"姓名\", \"电话\", \"地址\", \"标签\"); \twhile (1) \t{ \t\tfread(&cc, sizeof(struct conect), 1, fp);//读取文件块 \t\tif (feof(fp))//file end of 结束标志 \t\t{ \t\t\tbreak; \t\t} \t\tprintf(\"%12s%12s%30s\", cc.name, cc.telnum, cc.address); \t\tswitch (cc.f) \t\t{ \t\tcase 1:printf(\"      亲戚\\n\");break; \t\tcase 2:printf(\"      同事\\n\");break; \t\tcase 3:printf(\"      朋友\\n\");break; \t\t} \t} \tfclose(fp);//关闭文件 } void dele()//删除未保存时效数据函数 { \tint m, j,i; \tint h = 0; \tint flag = 0; \tchar t_name[M]; \tprintf(\"\\t\\t\\t\\t\\t\\t输入姓名=\"); \tscanf(\"%s\", t_name); \tprintf(\"\\n\"); \tprintf(\"\\n\"); \tfor (i = 0;i < num;i++) \t{  \t\tif (strcmp(t_name, c[i].name) == 0) \t\t{ \t\t\tprintf(\"\\t\\t\\t\\t\\t\\t-----------------------------------\\n\"); \t\t\tprintf(\"\\t\\t\\t\\t\\t         查找成功,是否删除？\\n\\n\"); \t\t\tprintf(\"\\t\\t\\t\\t\\t\\t1.删除                      \"); \t\t\tprintf(\"2.退出\\n\"); \t\t\tprintf(\"\\t\\t\\t\\t\\t\\t-----------------------------------\\n\"); \t\t\tflag = 1; \t\t\tbreak; \t\t} \t\th++; \t} \tif (flag == 0) \t{ \t\tprintf(\"\\t\\t\\t\\t\\t\\t无可查找对象\"); \t\treturn; \t} \tprintf(\"\\t\\t\\t\\t\\t\\t请输入：\"); \tscanf(\"%d\", &m); \tif (m == 1) \t{ \t\tfor (j = h;j < num;j++) \t\t{ \t\t\tc[i] = c[i + 1]; \t\t} \t\tprintf(\"\\n\"); \t\tprintf(\"\\t\\t\\t\\t\\t\\t删除成功!!\\n\"); \t\tnum--; \t} }  void dele_save()//部分删除函数功能：输入联系人姓名查找相应数据然后删除数据（联系人已保存至文件） { \t }  void dele_all() { \tFILE* fp; \tint ret, a; \tchar filename[] = \"conect.dat\";//将文件名赋值给一个字符串  \tfp = fopen(\"filename\", \"rb+\");//打开文件以二进制文件读取的方式 \tret = remove(filename);//将删除函数赋值给一个整形，方便if语句判断返回值 \tif (ret == 0)//当返回值为-1时报错，当返回值为时执行删除 \t{ \t\tprintf(\"文件删除成功\"); \t\t \t} \telse \t{ \t\tprintf(\"错误：不能删除该文件\");//一般来说可以用perror(\"remove\");打印错误原因，但结果为英文 \t}  \t }  void newsave() { \tint i; \tchar filename[100];//定义一个字符数组储存文件名 \tFILE* fp;  \tprintf(\"请输入你要自定义的文件夹\"); \tscanf(\"%s\", filename);//输入一个文件名 \tfp = fopen(filename, \"ab\");//创建一个新的二进制文件 \tfor (i = 0;i <= N;i++) \t{ \t\tfwrite(&c[i], sizeof(struct conect), 1, fp);//可以用循环写入文件 \t} \tfclose(fp);//关闭文件 \tprintf(\"保存成功!\\n\");  }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "建议楼主贴全代码吧", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 user-2的回复:不能用链表那就是数组了，数组删除是找到要删除的元素的下标，然后把它之后的元素逐一前移一个位置，再保存到文件中即可。 谢谢你  我解决了  因为要用文件所以不能用数组，我现在用的是把要删除和不删除的分别放到两个空文件里面，然后用remove删除其中要删除数据的那个文件，用rename重命名另一个文件。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "不能用链表那就是数组了，数组删除是找到要删除的元素的下标，然后把它之后的元素逐一前移一个位置，再保存到文件中即可。", "referer": "user-0"}]}
{"question": "C#程序设计基础上的一道程序设计题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "搞错了搞错了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "可怜的孩子，你迷路了吧？这里是C。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "界面➕电脑下棋的AI算法。", "referer": "user-0"}]}
{"question": "vs2012 开始执行不调试 变成这种白色", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "chcp 936 chcp 65001", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "其他的是没有问题的", "referer": "user-0"}]}
{"question": "直接插入排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h>  #define list_size 20  typedef int keytype; typedef int othertype;  typedef struct {     keytype key;     othertype other_data; }recordtype;  void display(recordtype r[],int length) {     for (int i = 0; i < length; i++) {         printf(\"%d \", r[i].key);     }     printf(\"\\n\"); }  void inssort(recordtype r[],int length)     //对记录数组r做直接插入排序，length为数组中待排序记录的数目 {     int i,j;     for(i=2;i<=length;i++)     {         r[0]=r[i];         j=i-1;         while(r[0].key<r[j].key)         {             r[j+1]=r[j];             j=j-1;         }         r[j+1]=r[0];     } }   //void main() int main(void) {     recordtype r[list_size];         return 0; } 供参考～", "referer": "user-0"}]}
{"question": "求助。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "哈哈哈，没图没代码", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "看哪里呢？", "referer": "user-0"}]}
{"question": "有5个学生，每个学生包括学号、姓名、三门课的成绩。从键盘输入5个学生数据，1）打印出每门课程的总平均分；2）要求按照总分由高到低的顺序打印出学生的数据（包括学号", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "定义个结构体 先自己写这试试  不行了再问", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先自己尝试写写，动动手。或者从网上搜一搜，总之，自己要先动手动脑试试。", "referer": "user-0"}]}
{"question": "C＋＋ 程序题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "有2481215个，仅供参考：#include <stdio.h>  int greatest_common_divisor(int a, int b) { \tif(b == 0) return a; \telse greatest_common_divisor(b, a%b); }  int main(void) { \tint n1, n2, t, count = 0; \tfor(n1 = 1; n1 <= 2020; n1++) \t{ \t\tfor(n2 = 1; n2 <= 2020; n2++) \t\t{ \t\t\tt = greatest_common_divisor(n1, n2); \t\t\tif(t == 1) \t\t\t{ \t\t\t\tprintf(\"%d:\\t分子：%d\\t分母：%d\\n\", ++count, n1, n2); \t\t\t} \t\t} \t} \treturn 0; }", "referer": "user-0"}]}
{"question": "C语言读取文件操作后影响结构体变量数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 Ice丨shine 的回复:[quote=引用 1 楼 user-1的回复:]Huffman编码，严蔚敏老师的数据结构上讲得很很清楚。 我知道是这个，我只是想问为什么读取文件前后两次tree的值会发生变化[/quote]  算法你已经知道了，还有问题，那就是C语言问题了。看看K&R C。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-1的回复:Huffman编码，严蔚敏老师的数据结构上讲得很很清楚。 我知道是这个，我只是想问为什么读取文件前后两次tree的值会发生变化", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "Huffman编码，严蔚敏老师的数据结构上讲得很很清楚。", "referer": "user-0"}]}
{"question": "关于数据结构和抽象数据类型的理解问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 8 楼 百 五 花 大 绑的回复:随便找本 数据结构与算法的书前言 就会讲很多相关的知识   I.e Data Structures Using C, 2nd edition 觉得老师讲的重逻辑上的理解，讲思路，很多东西不自己去查去看就不知道为什么", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 8 楼 百 五 花 大 绑的回复:随便找本 数据结构与算法的书前言 就会讲很多相关的知识   I.e Data Structures Using C, 2nd edition 目前在学严蔚敏的数据结构。小白级别，请见谅！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "随便找本 数据结构与算法的书前言 就会讲很多相关的知识   I.e Data Structures Using C, 2nd edition", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "最后自己差不多想明白了", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "不好意思我们还没有学封装这些知识，能否再详细讲解一下呢？还有上面最初提到的三个问题可否解答一下呢？（最近复习感觉总卡在这个点，理解不透彻）感激不尽！！！", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "需要复杂的结构来配合算法，struct 都是链表之类的基础，可以理解为封装", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:typedef是起别名，建议楼主在网上搜一下typedef以及其用法。  如果对数据结构和结构体有异议，建议自己写代码测试一下，理论联系实际，用实践去指导理论 关于typedef,还有我以上的问题我都搜索过了，但没有我想要的答案，数据结构的具体代码实现我觉得我这些问题搞不清楚，没办法写代码，写出来的也是没有真正理解的。所以您可否针对我所说的三个具体问题来解答一下呢？感激不尽！！", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 百 五 花 大 绑的回复: typedef struct     {         Selemtype *base;         Selemtype *top;         int stacksize;     } SqStack;  SqStack * pSqStack = NULL;   struct     {         Selemtype *base;         Selemtype *top;         int stacksize;     } SqStack;  struct SqStack * pSqStack = NULL;   typedef 是有作用的 其实疑惑点不在是不是使用typedef来简化struct类名，而是为什么有struct这样一个整体的存储结构定义。", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "typedef是起别名，建议楼主在网上搜一下typedef以及其用法。  如果对数据结构和结构体有异议，建议自己写代码测试一下，理论联系实际，用实践去指导理论", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "typedef struct     {         Selemtype *base;         Selemtype *top;         int stacksize;     } SqStack;  SqStack * pSqStack = NULL;   struct     {         Selemtype *base;         Selemtype *top;         int stacksize;     } SqStack;  struct SqStack * pSqStack = NULL;   typedef 是有作用的", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 百 五 花 大 绑的回复:第一个就是读入用户回车前的输入，存到a[]里面 好的，谢谢😜", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "第一个就是读入用户回车前的输入，存到a[]里面", "referer": "user-0"}]}
{"question": "VC++6.0编译没有错误，但是无法运行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看一下fscanf.c的第54行，VC++6.0挺好的，我的最爱，没有之一", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fscanf.c文件看下54行是什么内容？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "好像是想读文件，但是读到的是空     看看要读的文件存在吗？ 内容是不是空", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "VC++6.0，太老了，早该淘汰了。你还用它，自找麻烦吧。 VC++6.0 IDE，C99就不支持，现在是C11，C18了。你还想古董支持？？？", "referer": "user-0"}]}
{"question": "机器数采用补码规格化，求机器数字长16位的计算机表示数的范围", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "这个是计算机组成原理的题  那个数 是这个意思  阶符 阶数 数符 尾码", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "仅供参考：", "referer": "user-0"}]}
{"question": "为什么结果在自定义函数中正常，返回到主函数输出异常？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主返回的其实是anw的地址，虽然返回的是ans，但是ans指向了anw。问题就在这里，anw是什么变量，局部变量，函数f调用结束后anw就被释放了，所以返回anw的地址没有意义。  修改的办法是改变anw的属性，进而改变该变量的生命周期。在anw前加一个static，这样该变量的生命周期就是从定义开始直到程序退出一直有效。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if ( n == 0 )//递归出口     {         *anw = { '1' };         ans = anw;         return ans;     }  典型的指针错误。 ans指向局部变量anw然后返回。 anw在函数结束后不再有效，所以返回后打印结果就不对了。", "referer": "user-0"}]}
{"question": "C语言怎么实现对输入的严谨检查", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：//输入两个整数 #include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,\"%d%n\",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf(\"%d,%d\\n\",a,b);     return 0; }  #include <stdio.h> char s[]=\"123 ab 4\"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,\"%d%n\",&v,&n);         printf(\"k,v,n=%d,%d,%d\\n\",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf(\"skip char[%c]\\n\",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf(\"End.\\n\"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请参考《C++控制台程序判断输入的数字》 希望能够帮到您！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "使用getchar()，一个一个的分析，发现不合法，就提示， 如果合法，自己拼接数字，字符串，等等。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "用正则表达式试试，数字时\\d", "referer": "user-0"}]}
{"question": "关于利用C语言为快递公司设计快递投递路线的优化程序（求帮助感谢）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学习一下OSPF就好，一样一样地。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 Ricentch·J·Satoware 的回复:引用 2 楼 早打大打打核战争 的回复:每个城市都可能有包裹投递到其他城市？每个中转点可以暂存？可以杂凑？那太复杂了，是NP问题，要取得最优解非常困难，只能穷举。应该没有那么复杂，就很直接的优化路线问题，大佬简单点想就行叭 大佬有思路吗", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 早打大打打核战争 的回复:每个城市都可能有包裹投递到其他城市？每个中转点可以暂存？可以杂凑？那太复杂了，是NP问题，要取得最优解非常困难，只能穷举。应该没有那么复杂，就很直接的优化路线问题，大佬简单点想就行叭", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这么貌似不容易，需要好好研究图论和算法。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "每个城市都可能有包裹投递到其他城市？每个中转点可以暂存？可以杂凑？那太复杂了，是NP问题，要取得最优解非常困难，只能穷举。", "referer": "user-0"}]}
{"question": "C语言中编译时自动赋初值0或空字符'\\0'的变量有哪些？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "自动赋值不放心，还是自己复制靠谱。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 ctrigger的回复:[quote=引用 5 楼 AruNi° ഒ 的回复:][quote=引用 3 楼 user-2的回复:]还是自己赋值比较好，没必要去纠结哪些变量是自动赋值的 关键是做选择题或者填空题的时候要知道。[/quote]  编译器不一样，结果可能就不一样。 纠结这个有啥意义呢？？？[/quote] 好的吧！！！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 5 楼 AruNi° ഒ 的回复:[quote=引用 3 楼 user-2的回复:]还是自己赋值比较好，没必要去纠结哪些变量是自动赋值的 关键是做选择题或者填空题的时候要知道。[/quote]  编译器不一样，结果可能就不一样。 纠结这个有啥意义呢？？？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 user-2的回复:还是自己赋值比较好，没必要去纠结哪些变量是自动赋值的 关键是做选择题或者填空题的时候要知道。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 user-2的回复:还是自己赋值比较好，没必要去纠结哪些变量是自动赋值的 关键是有时候做选择题或者填空题会遇到，", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "还是自己赋值比较好，没必要去纠结哪些变量是自动赋值的", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 ctrigger的回复:自动赋值不放心，还是自己复制靠谱。 有时候做题会遇到没有赋值的", "referer": "user-0"}]}
{"question": "求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 user-1的回复:把第5行这句改下，不要中间的‘，’号，再输入试下：scanf(\"%d %d\",&a,&b);，输入时两个数字间空格就可以了。 请问为什么加逗号就不可以了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 m0_52586836的回复:[quote=引用 3 楼 user-1的回复:]把第5行这句改下，不要中间的‘，’号，再输入试下：scanf(\"%d %d\",&a,&b);，输入时两个数字间空格就可以了。 还是和之前一样[/quote] 抱歉，可以了，刚刚看错了", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 user-1的回复:把第5行这句改下，不要中间的‘，’号，再输入试下：scanf(\"%d %d\",&a,&b);，输入时两个数字间空格就可以了。 还是和之前一样", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "把第5行这句改下，不要中间的‘，’号，再输入试下：scanf(\"%d %d\",&a,&b);，输入时两个数字间空格就可以了。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-1的回复:第5行 scanf(\"%d,%d\",&a,&b);，你输入的时候两个数字之间是有‘，’号的，例如：2，3  ，你是不把这个‘，’号漏掉了。 没有漏，而且不管我输什么数字进去自定义函数的值总是取a而不是a+b", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "第5行 scanf(\"%d,%d\",&a,&b);，你输入的时候两个数字之间是有‘，’号的，例如：2，3  ，你是不把这个‘，’号漏掉了。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用引用 3 楼 user-1的回复: 把第5行这句改下，不要中间的‘，’号，再输入试下： C/C++ code ? 1 scanf(\"%d %d\",&a,&b); ，输入时两个数字间空格就可以了。  请问为什么加逗号就不可以了不是说加逗号不可以，这里有全角和半角之分，如果你在scanf(\"%d，%d\",&a,&b);加的是全角的逗号，那你在输入时必须也是全角状态的逗号。如果scanf(\"%d,%d\",&a,&b);加入的是半角的逗号，那在输入时必须是半角的逗号。问题在于全角和半角你很难分清的情况下，所以建议你干脆把逗号取消，改变下输入格式试试喽。逗号的全角和半角之分，是因为全角状态是两个字节来存储一个逗号，半角状态是一个字节存储一个逗号，如果在输入的时候对不上，电脑就不认识了。", "referer": "user-0"}]}
{"question": "C语言小白，请求大神指点，为什么运行不了，怎么改一下（用了while，稍有繁琐）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第6行 m=factorize(x);这句调用函数是错的，void factorize(int x)定义为空函数没有返回值。第6行改为：factorize(x);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码也不贴上了，谁有空给你一个一个字母敲进去。 代码完成什么功能也没说，只有天知道你想干什么。", "referer": "user-0"}]}
{"question": "下面程序为什么错啊?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可能这个and（）函数名字定义发生了冲突，改名处理下。", "referer": "user-0"}]}
{"question": "删除数字", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "delete是关键字，不能定义成函数。引用int delete(int d,int a[]) { int j; for(j=0;a[j]==d;j++) { } return j;  }这个函数，for里面至少要有个‘；’。修改如下，供参考：#include<stdio.h> int delete_my(int d,int a[],int n);  int main(int argc, char* argv[]) {     int a[6]={3,2,1,4,5,6};     int d,i,pos;     printf(\"请输入您要删除的数\\n\");     scanf(\"%d\",&d);      pos=delete_my(d,a,6);     if(pos<=5){        for(i=pos;i<5;i++)           {            a[i]=a[i+1];           }        pos=6-1;     }     for(i=0;i<pos;i++)        {          printf(\"%4d\",a[i]);        }     system(\"pause\");     return 0; }  int delete_my(int d,int a[],int n) {     int j;     for(j=0;j<n;j++){         if(a[j] == d ) break;     }     return j;  }", "referer": "user-0"}]}
{"question": "windows下数的表示到底是怎么一回事？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "问题最后出在了声明数据类型上nowData1应该声明为unsigned char否则返回的数据解析后会出现第7位的值变为0", "referer": "user-0"}]}
{"question": "视觉追踪，可以选用stm32单片机和yolo平台实现，只会c语言，哪个更容易实现", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "两个不一样的东西，怎么比较呢？ stm32，只是st公司的微处理器，是硬件。目前来说貌似性能有效，视觉算法跑不起来。 yolo，只是个对象检测算法，详细情况需要研究Redmon大神的论文。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "兄弟 你弄了吗", "referer": "user-0"}]}
{"question": "求大神帮忙康康", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:if(fp==NULL) { printf(\"错误\");  } 这个地方已经打开失败了，还要继续往下执行吗？后面怎么再用这个fp？  if(fp==NULL) { printf(\"错误\");  return; } 有道理，感谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 赵4老师的回复:books[N+1]越界了吧。 这是结构体变量，我定了5000个", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "if(fp==NULL) { printf(\"错误\");  } 这个地方已经打开失败了，还要继续往下执行吗？后面怎么再用这个fp？  if(fp==NULL) { printf(\"错误\");  return; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "books[N+1]越界了吧。", "referer": "user-0"}]}
{"question": "二叉树的最近公共祖先", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "哪里不理解？我觉得思路挺清晰的。 首先，查找共同祖先就要涉及到树的遍历，那么就先找出遍历的主干代码，就是以下代码，记为A代码 while((cur || top>0) && ancestor != root) {     while(cut) {//把左节点都压栈直到左节点为null         stack[top++] = cut;          cur = cur->left;     }     cur = stack[--top]; //把最后乳栈的左节点出栈     cur = cur->right; //遍历出栈节点的右节点（这里如果右节点存在接下来就会进入while(cur)遍历右节点的左子树 }  如果不明白为什么是遍历，就拿你的例子来套入看看 首先whlie(cur)会把3，5，6入栈 然后6出栈，6没有右节点，所以下一轮while(cur)被跳过 然后5出栈，5有右节点2，所以下一轮while(cur)，2和7入栈 然后7出栈，7没有右节点，所以下一轮while(cur)被跳过 然后2出栈，2有右节点44所以下一轮while(cur)，4入栈 等等，依次类推  好了，上面找到遍历的主干了，接下来要知道遍历是为了什么？是为了找共同祖先，怎么找？先来看以下代码，记为B代码 if(cur= == p || cur == q) {     if(ancestor) break; //当两个pq节点都找到就会进入这里     ancestor = cur; //否则只找到p或q其中一个     ancestorDepth = top; //会走里记录ancestor和深度 } 不难发现，这段代码是控制在遍历的过程中找到了p和q两个节点就退出循环结束遍历，说明走到这里就是找到祖先节点了。然而这里明明是找到p和q，跟祖先没关系啊。别急，再来看以下代码，记为C代码 //首先从A代码知道，top越小就越是祖先节点（因为是父节点先入栈再左子节点入栈），从B代码知道找到p或q任意一个节点ancestorDepth才开始有值 if(top < ancestorDepth) { //所以进入这里说明cur是p或q其中一个的祖先节点     ancestor = cur;     ancestorDepth = top; } 再结合B代码就知道进入if(ancestor)break;时，ancestor是q或p其中一个的祖先节点，从该祖先节点也能找到p或q另外一个节点，说明ancestor就是p和q的共同祖先", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "哪里不理解？我觉得思路挺清晰的。 首先，查找共同祖先就要涉及到树的遍历，那么就先找出遍历的主干代码，就是以下代码，记为A代码 while((cur || top>0) && ancestor != root) {     while(cut) {//把左节点都压栈直到左节点为null         stack[top++] = cut;          cur = cur->left;     }     cur = stack[--top]; //把最后乳栈的左节点出栈     cur = cur->right; //遍历出栈节点的右节点（这里如果右节点存在接下来就会进入while(cur)遍历右节点的左子树 }  如果不明白为什么是遍历，就拿你的例子来套入看看 首先whlie(cur)会把3，5，6入栈 然后6出栈，6没有右节点，所以下一轮while(cur)被跳过 然后5出栈，5有右节点2，所以下一轮while(cur)，2和7入栈 然后7出栈，7没有右节点，所以下一轮while(cur)被跳过 然后2出栈，2有右节点44所以下一轮while(cur)，4入栈 等等，依次类推  好了，上面找到遍历的主干了，接下来要知道遍历是为了什么？是为了找共同祖先，怎么找？先来看以下代码，记为B代码 if(cur= == p || cur == q) {     if(ancestor) break; //当两个pq节点都找到就会进入这里     ancestor = cur; //否则只找到p或q其中一个     ancestorDepth = top; //会走里记录ancestor和深度 } 不难发现，这段代码是控制在遍历的过程中找到了p和q两个节点就退出循环结束遍历，说明走到这里就是找到祖先节点了。然而这里明明是找到p和q，跟祖先没关系啊。别急，再来看以下代码，记为C代码 //首先从A代码知道，top越小就越是祖先节点（因为是父节点先入栈再左子节点入栈），从B代码知道找到p或q任意一个节点ancestorDepth才开始有值 if(top < ancestorDepth) { //所以进入这里说明cur是p或q其中一个的祖先节点     ancestor = cur;     ancestorDepth = top; } 再结合B代码就知道进入if(ancestor)break;时，ancestor是q或p其中一个的祖先节点，从该祖先节点也能找到p或q另外一个节点，说明ancestor就是p和q的共同祖先", "referer": "user-0"}]}
{"question": "请问一下窗口的坐标", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "窗口是二维平面的，用x和y就能表示坐标。 如果是三维立体空间，就用x，y，z表示坐标。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这是自己定义的结构体，用来保存坐标，所以x，y就能代表坐标  比如  A=坐标 那么A就能直接代表坐标，这不是很容易理解吗？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "C语言没函数重载，是不是C++？？？", "referer": "user-0"}]}
{"question": "嵌入式编写程序（c )", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这样的题不算难，用数组啥的，加些判断，应该自己尝试去写。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "额，这是嵌入式老师的留堂作业。大佬能不能指点一下", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这个和嵌入式有啥关系呢？", "referer": "user-0"}]}
{"question": "C和指针 第六章课后习题 编程题第三题 答案为什么是这样的啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复：[quote=引用 2 楼 IsTanbuL_Night 的回复:][quote=引用 1 楼 user-2 的回复：] for结束，last_char == '\\0 ' last_char--，指向最后一个字符。哦哦 因为for 循环后面有个分号 所以 直接执行完这个语句 对吧[/quote] for后面是有分号的，last_char--不是循环体内的语句[/quote]好的 谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 IsTanbuL_Night 的回复:[quote=引用 1 楼 user-2 的回复：] for结束，last_char == '\\0 ' last_char--，指向最后一个字符。哦哦 因为for 循环后面有个分号 所以 直接执行完这个语句 对吧[/quote] for后面是有分号的，last_char--不是循环体内的语句", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2 的回复：for结束，last_char == '\\0 ' last_char--，指向最后一个字符。哦哦 因为for 循环后面有个分号 所以 直接执行完这个语句 对吧", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "for结束，last_char == '\\0 ' last_char--，指向最后一个字符。", "referer": "user-0"}]}
{"question": "设计函数，根据ASCII码求二维字符数组的最大值和最小值。 要求：用全局变量Max和Min来存储要求的最大值和最小值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "确实不难，这个可以自己做做看", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你好懒哦。。这也没难度，都不想动手？？？", "referer": "user-0"}]}
{"question": "求大佬帮忙修改一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "要弄清左值和右值的区别， 左值代表一个变量，右值一般是一个表达式。表达式是不能进行赋值的，要想弄请结构体指针和结构体变量的区别，先弄请什么是指针，结构体指针就是使用一个变量去指向一个结构体的指针，就像放风筝一样，内存比喻为整个天空，风筝就是你那个结构体，指针就是风筝线，我们要控制风筝，使用风筝线就能控制结构体的各种变量。加油，c的路程还有很远", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "user[i].balance = user[i].balance+ l;   你干什么呢  不是你那么赋值呀 ，你差点把我弄糊涂了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "一个是结构体变量，一个是结构体指针。区别就是一个变量名，一个是变量地址。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "struct users *user是结构体指针", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "还有为什么左值显示无法修改，谢谢各位大佬", "referer": "user-0"}]}
{"question": "为什么同样的代码  在vc一直显示错误  换到DC就没有问题呢  这个代码也没有错误的吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复:换这个VC6 VC6EN https://pan.baidu.com/s/1_t4HPLJZCdiIaJKecguK_A好的谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "换这个VC6 VC6EN https://pan.baidu.com/s/1_t4HPLJZCdiIaJKecguK_A", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "vc++6.0的", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "确认一下环境问题，包括编译器版本等", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "没问题，代码符合C最新标准。", "referer": "user-0"}]}
{"question": "报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "文件名和路径别带空格。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "文件名不要有空格", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "hello world中间加个下划线都不至于会报错。。。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我又懂了", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "文件名不能有空格吧，否则认为是两个文件", "referer": "user-0"}]}
{"question": "求大佬帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "这样有啥问题吗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "int input(char ar2[][21]) { int i; for(i=0;i<10;i++) { scanf(\"%s\",&ar2[i]); if(strcmp(ar2[i],\"*END*\")==0) {break;} } return i; }  void paixu(char ar2[][21], int n) { int i; char ch[40]; if(n==0) {printf(\"NO WORD\");} for(i=0;i<n-1;i++) { strcmp(ar2[i],ar2[i+1]); if(strcmp(ar2[i],ar2[i+1])>=0) { strcpy(ch,ar2[i]); strcpy(ar2[i],ar2[i+1]); strcpy(ar2[i+1],ch); } }  } void printArr(char ar2[][21], int n) { char ch=' '; int i; for(i=0;i<n;i++) { if(i==n-1) { \tch='\\n'; } printf(\"%s%c\",ar2[i],ch); } }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "int input(char ar2[][21]) { int i; for(i=0;i<10;i++) { scanf(\"%c\",&ar2[i]); if(strcmp(ar2[i],\"*END*\")==0) {break;} } return i; } 这样输入有问题吗", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "抱歉。上面基本实现功能。但不符合楼主要求。忽略吧。。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "仅供参考： #include <stdio.h> #include <string.h> #include <stdlib.h>  int my_cmp(const void *a, const void *b) { \tchar *p = *(char **)a; \tchar *q = *(char **)b; \treturn strcmp(p, q); }  int main(void) { \tchar word[21], *arr[10]; \tint i, size = 0; \t \twhile(1) \t{ \t\tscanf(\"%s\", word); \t\tif(strcmp(word, \"END\") == 0) break; \t\tarr[size] = malloc(strlen(word) + 1); \t\tstrcpy(arr[size], word); \t\tsize++; \t\tif(size == 10) break; \t} \t \tqsort(arr, size, sizeof(char *), my_cmp); \t \tfor(i=0; i<size; i++) \t{ \t\tprintf(\"%s\\t\", arr[i]); \t\tfree(arr[i]); \t} \t \treturn 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "排序和输出都是有问题的。自己先调试一下吧", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "#define MAX_COL_SIZE        21 int input(char ar2[][MAX_COL_SIZE]) {     int i=0;     //while(i<10&&ar2!='*END*')     while(i<10&&strcmp(ar2[i], \"END\"))     {         //gets(ar2);         fgets(ar2[i], MAX_COL_SIZE, stdin);         i++;     }      return i; } 字符串比较要用库函数，否则就是用循环，一个字符一个字符的比较。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "int input(char ar2[][21]) { int i=0; while(i<10&&ar2!='*END*') { gets(ar2); i++; } return i; }  void paixu(char ar2[][21], int n) { int i,j,t; for(i=0;i<n-1;i++) { for(j=i+1;j<n-1;j++) { if(ar2[j+1][0]<=ar2[j][0]) { t=ar2[j][0]; ar2[j][0]=ar2[j+1][0]; ar2[j+1][0]=t; }  }\t }  }   void printArr(char ar2[][21], int n) { int i; char ch=' '; for(i=0;i<n;i++) { \tif(i==(n-1)) \t{ch='\\n';} \tprintf(\"%d%c\",ar2[i][21],ch); } return ar2; } 错了", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "自己先写写，用scanf %s或fgets，要不就是getchar()循环", "referer": "user-0"}]}
{"question": "为什么我的代码在vs和devc++的运行结果不一致？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "上面漏了对1排除，重新修改：int isPrime( int n) {      if(n<2) return 0;      for(int div = 2;div <= sqrt(n);div++)         if( n%div == 0)           return 0 ;      return 1 ; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主素数判断函数有问题引用int isPrime(int n) { int i,div; for(div = 2;div <= sqrt(n);div++){ if(n%div == 0){ break; return 0; } if(div == n) return 1; } 修改如下，供参考：int isPrime( int n) {      for(int div = 2;div <= sqrt(n);div++)         if( n%div == 0)           return 0 ;      return 1 ; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "结果不一样，说明你代码有歧义，必须修改。。。", "referer": "user-0"}]}
{"question": "关于C语言的字符串常量的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以访问。  如果想修改pStr，可以这样定义，char pStr[] =｛\"Hello World\"｝；", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#pragma comment(linker,\"/SECTION:.rdata,RW\") //加这句可以让常量区可写，后果自负！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "字符串常量是可以读的，但只是只读，不能写。 即pStr[1] = '1';这样是不可以的。 所以，访问每个字符都是没问题的", "referer": "user-0"}]}
{"question": "大一新生小白求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 12 楼 qq_51774708的回复:[quote=引用 10 楼 5250的回复:][quote=引用 9 楼 qq_51774708 的回复:][quote=引用 6 楼 5250的回复:][quote=引用 4 楼 qq_51774708 的回复:][quote=引用 2 楼 5250的回复:]大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好 感觉丝毫没有头绪[/quote]  啥时候要 我看有空帮你写一下吧[/quote] 下周一[/quote]  留一个邮箱吧[/quote] 135083159@qq.com[/quote] 代码发给你了哦  昨天加你qq的那个", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我再去琢磨琢磨书", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 10 楼 5250的回复:[quote=引用 9 楼 qq_51774708 的回复:][quote=引用 6 楼 5250的回复:][quote=引用 4 楼 qq_51774708 的回复:][quote=引用 2 楼 5250的回复:]大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好 感觉丝毫没有头绪[/quote]  啥时候要 我看有空帮你写一下吧[/quote] 下周一[/quote]  留一个邮箱吧[/quote] 135083159@qq.com", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "用c++语言写的话应该不难，不过主要是增删查改四个功能，对着课程设计模仿下。", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 9 楼 qq_51774708 的回复:[quote=引用 6 楼 5250的回复:][quote=引用 4 楼 qq_51774708 的回复:][quote=引用 2 楼 5250的回复:]大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好 感觉丝毫没有头绪[/quote]  啥时候要 我看有空帮你写一下吧[/quote] 下周一[/quote]  留一个邮箱吧", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 6 楼 5250的回复:[quote=引用 4 楼 qq_51774708 的回复:][quote=引用 2 楼 5250的回复:]大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好 感觉丝毫没有头绪[/quote]  啥时候要 我看有空帮你写一下吧[/quote] 下周一", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 5 楼 limeilu110的回复:恩！这个题目我收了！回去练练手！ hhhh好的", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 6 楼 5250的回复:[quote=引用 4 楼 qq_51774708 的回复:][quote=引用 2 楼 5250的回复:]大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好 感觉丝毫没有头绪[/quote]  啥时候要 我看有空帮你写一下吧[/quote] 太感谢了，下周一交大概", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "引用 4 楼 qq_51774708 的回复:[quote=引用 2 楼 5250的回复:]大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好 感觉丝毫没有头绪[/quote]  啥时候要 我看有空帮你写一下吧", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "恩！这个题目我收了！回去练练手！", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好", "referer": "user-0"}, {"cid": "12", "user": "user-4", "content": "练手的好机会啊。。 数据存在文件里，读写文件即可。 数据存在数据库里，访问数据库即可。", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 2 楼 5250的回复:大一就要做这个嘛？这个用到的其实就是结构体/数组  以及查找/排序这些 你可以先写一些  有不懂的再问  效果好 感觉丝毫没有头绪", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 1 楼 user-4的回复:练手的好机会啊。。 数据存在文件里，读写文件即可。 数据存在数据库里，访问数据库即可。 啊这，完全听不懂在说什么", "referer": "user-0"}]}
{"question": "为什么输入n之后直接输出了一大堆乱的数字", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\\t'); or newline ('\\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.  格式规范字段：scanf和wscanf函数 格式规范的格式如下： %[*][width][{h | l | I64 | l}]类型 format参数指定输入的解释，可以包含以下一个或多个： 空白字符：空白（“”）；制表符（'\\t'）；或换行符（'\\n'）。空白字符导致scanf读取（但不存储）输入中直到下一个非空白字符的所有连续空白字符。格式中的一个空白字符与输入中的任意数字（包括0）和空格字符的组合相匹配。 非空白字符，百分比符号（%）除外。非空白字符导致scanf读取但不存储匹配的非空白字符。如果stdin中的下一个字符不匹配，scanf终止。 格式规范，由百分号（%）引入。格式规范导致scanf读取输入中的字符并将其转换为指定类型的值。该值被分配给参数列表中的参数。 格式从左到右读取。格式规范之外的字符应与stdin中的字符序列相匹配；stdin中的匹配字符将被扫描但不会存储。如果stdin中的某个字符与格式规范冲突，scanf将终止，并且该字符将保留在stdin中，就像它没有被读取一样。 当遇到第一个格式规范时，第一个输入字段的值将根据该规范进行转换，并存储在第一个参数指定的位置。第二个格式规范将转换第二个输入字段并将其存储在第二个参数中，依此类推，直至格式字符串的末尾。 输入字段定义为所有字符，直到第一个空白字符（空格、制表符或换行符），或直到第一个字符无法根据格式规范转换，或直到达到字段宽度（如果指定）。如果给定规范的参数太多，将计算额外的参数，但会忽略这些参数。如果格式规范没有足够的参数，那么结果是不可预测的。 格式规范的每个字段都是表示特定格式选项的单个字符或数字。出现在最后一个可选格式字段之后的类型字符决定输入字段是被解释为字符、字符串还是数字。 最简单的格式规范只包含百分号和类型字符（例如%s）。如果百分号（%）后跟一个没有意义的字符作为格式控制字符，则该字符和后面的字符（直到下一个百分号）被视为普通字符序列，即必须与输入匹配的字符序列。例如，要指定要输入的百分号字符，请使用%%。 在百分号后面的星号（*）将禁止指定下一个输入字段，该字段被解释为指定类型的字段。字段已扫描但未存储。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考： #include<stdio.h>  int main() {     int t;     scanf(\"%d\",&t);     for(int i=0; i<t; i++)     {         int n;         char s[100];         scanf(\"%s\",s);         scanf(\"%d\",&n);         for(int p=0; p<n; p++)         {             int a,b,c; \t    //scanf(\"[%d:%d:%d]\",&a,&b,&c); \t    char buf[1024]; \t    scanf(\"%s\", buf); \t    sscanf(buf, \"[%d:%d:%d]\",&a,&b,&c);             printf(\"%d %d %d\",a,b,c);         }     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 7 楼 Aa_1z 的回复:[quote=引用 6 楼 5250的回复:]   scanf(\"[%d:%d:%d]\",&a,&b,&c);改一下 scanf(\"%d:%d:%d\",&a,&b,&c); 可是我想写成[1:3:4]这种形式，不知道怎么改[/quote]  这样改吧  将[]当作一个字符就行了     int a, b, c;     char d,e;     scanf(\"%c%d:%d:%d%c\", &d,&a, &b, &c,&e);", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 5250的回复:scanf(\"[%d:%d:%d]\",&a,&b,&c);改一下 scanf(\"%d:%d:%d\",&a,&b,&c); 可是我想写成[1:3:4]这种形式，不知道怎么改", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "scanf(\"[%d:%d:%d]\",&a,&b,&c);改一下 scanf(\"%d:%d:%d\",&a,&b,&c);", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 这是一个正经昵称的回复:输入字符串，用char类型存储，用%s打印。为什么是看起来乱的数字的话，学一下char和int存储的区别，再学一下字符串是怎么存储的，还有地址跟数据。 #include<stdio.h>  int main() {     int t;     scanf(\"%d\",&t);     for(int i=0; i<t; i++)     {         int n;         char s[100];         scanf(\"%s\",s);         scanf(\"%d\",&n);         /*这里错了         for(int p=0; p<n; p++)         {             int a,b,c;             scanf(\"[%d:%d:%d]\",&a,&b,&c);             printf(\"%d %d %d\",a,b,c);             printf(\"\\n\");         }         */     }     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 2 楼 Aa_1z 的回复:[quote=引用 1 楼 ctrigger的回复:]随便找一本C语言书，只看第一章即可。 ？第一章是引言[/quote]  用C语言标准库规定的格式，不能自创。你自创的，C语言不认识。", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "输入字符串，用char类型存储，用%s打印。为什么是看起来乱的数字的话，学一下char和int存储的区别，再学一下字符串是怎么存储的，还有地址跟数据。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 ctrigger的回复:随便找一本C语言书，只看第一章即可。 ？第一章是引言", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "随便找一本C语言书，只看第一章即可。", "referer": "user-0"}]}
{"question": "prim算法，代码系统无纠错，但无法运行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "严重性\t代码\t说明\t项目\t文件\t行\t禁止显示状态  警告\tC6282\t运算符不正确: 在 Boolean 上下文中执行了常量赋值。应考虑改用“==”。\tProject60\ttest\\C_Prog.c\t38\t 警告\tC6282\t运算符不正确: 在 Boolean 上下文中执行了常量赋值。应考虑改用“==”。\tProject60\ttest\\C_Prog.c\t40\t 警告\tC6001\t使用未初始化的内存“G”。\tProject60\ttest\\C_Prog.c\t57\t    能运行才怪.", "referer": "user-0"}]}
{"question": "求这个程序的代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "m=2,n=2时，参考下图：", "referer": "user-0"}]}
{"question": "从键盘任意两个数字，计算这两个数的最大公约数和最小公倍数并输出。 求助求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "报错的原因是在求最大公约数后，i的值变为0，之后 c=c/i； 就会报错。 修改方法 \tfor(i=b;i>0;i--) \t{ \t\tif(a%i==0&&b%i==0) \t\t{//-------添加-------------- \t\t\tprintf(\"最大公约数:%d\\n\",i); \t\t\tbreak;//------在得到最大公约数后，结束for循环---------- \t\t}//-----------添加-------------------- \t} VC++6.0 C++环境调试  VC++6.0是我的最爱，没有之一", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改如下，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int a,b,c,i,y;     printf(\"请输入两个数\\n\");     scanf(\"%d %d\",&a,&b);     if(a<b)      {       c=a; //这里是\";\"号，不是\",\"号       a=b;       b=c;      }    for(i=1;i<=b;i++)     {      if(a%i==0 && b%i==0) y=i;//增加一个变量y,记录公约数     }    printf(\"最大公约数:%d\\n\",y);    c=a*b;    c=c/y;    printf(\"最小公倍数:%d\\n\",c);    return 0; }", "referer": "user-0"}]}
{"question": "请问%d后面括号里是什么意思？（大一c初学者）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "后面的表达式用括号括起来，说明是一个整体，可以成为语句块。  因为只有一个%d，所以需要用括号括起来，因为在括号里有一个逗号呢。 括号里的表达式遵循逗号表达式的运算～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "括号里是个逗号表达式，返回右侧表达式的值", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "逗号表达式~~~~", "referer": "user-0"}]}
{"question": "String函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:a，b，\\n是换行符，,\\012是八进制数，是一个字符，,\\\\是一个字符，代表反斜杠\\，\\\"是一个字符，代表双引号。其中\\是转义字符的标志。 谢谢老哥！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "a，b，\\n是换行符，,\\012是八进制数，是一个字符，,\\\\是一个字符，代表反斜杠\\，\\\"是一个字符，代表双引号。其中\\是转义字符的标志。", "referer": "user-0"}]}
{"question": "大佬，给点思路", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看前面的规律是加的意思，最后一句是打错了吧，这题就是瞎搞", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-1的回复:看前面的规律是加的意思，最后一句是打错了吧，这题就是瞎搞 相加提交不对，答案还能得出0", "referer": "user-0"}]}
{"question": "来个大佬帮我解释一下这个程序，我看不懂", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个程序看起来是个最大堆排序", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 1 楼 user-3 的回复:引用Situation array[65536]; 这么大数组，也不怕栈溢出么？ 用malloc动态开辟堆空间，不好么？？ 你仔细看看，他定义的是全局（静态）数组，而且因为没有初始值，占用bss节，也不增加可执行文件大小。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用Situation array[65536]; 这么大数组，也不怕栈溢出么？ 用malloc动态开辟堆空间，不好么？？", "referer": "user-0"}]}
{"question": "如何通过初始载入数据的方式定义全局变量", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 楼主 xyj8035 的回复:目前我定义了 #define ROWS 20 int data[ROWS];  现在希望ROWS的值我在程序初始化时通过数据库载入值，这个可以实现吗，或者有什么好的办法实现类似功能？ 可以，从数据库指定和通过终端输入数组长度没什么区别。  但是，建议楼主先把数组定义成长度为0的，其实就是定义一个指针，然后从数据库里读取到值之后通过动态申请空间的方式确定内存；  动态申请空间malloc/free, new/delete", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "创建数据库对象 用数据库对象建立数据库连接 创建记录集对象 在记录集对象上执行select语句提取数值对应字段的20行对应的20个值保存到data数组中 销毁记录集对象 断开数据库连接 销毁数据库对象", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "那就是动态创建了int* pnArray = new int[XXXX];", "referer": "user-0"}]}
{"question": "输入一英文字符串(字符串长度限制在200个字符以内)，单词间仅用一个或多个空格间隔（即没有标点符号），编写程序将此字符串中第1个最长的单词输出。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 qq_1457346882的回复:len = strlen(a);     for (i = 0; i <= len;i++){         if(a[i]=='\\0')             break; 已经判断了字符串长度循环就不用加判断是否结束，到了那个长度会自己结束的，只要<len就好了 if(j>maxlen){                 maxlen = j;                 maxst = i-j;                 j = 0;                 a[i] = '\\0'; 这里j=0要拿出来，判断j>才执行，那如果ｊ不大于呢，执行到下一个单词继续累加嘛，那你这个j的值是不是就不准确了 j作为单词长度的计数变量，要保证每个单词开始的时候j为０才行 明白了，谢谢大佬。昨天没想到这种情况", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "len = strlen(a);     for (i = 0; i <= len;i++){         if(a[i]=='\\0')             break; 已经判断了字符串长度循环就不用加判断是否结束，到了那个长度会自己结束的，只要<len就好了 if(j>maxlen){                 maxlen = j;                 maxst = i-j;                 j = 0;                 a[i] = '\\0'; 这里j=0要拿出来，判断j>才执行，那如果ｊ不大于呢，执行到下一个单词继续累加嘛，那你这个j的值是不是就不准确了 j作为单词长度的计数变量，要保证每个单词开始的时候j为０才行", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主，发现一个漏洞，当字符串中最后一个单词组最长时，上面的算法统计有问题，修改如下，供参考：#include <stdio.h> #include <string.h> int main(int argc, char* argv[]) {     char a[200];     int i=0, j=0, len, maxlen =-1, maxst;     gets(a);     len = strlen(a);     for (i=0;i<len;i++)     {        while(a[i]!=' ' && a[i] != '\\0')//当最后一个单词串最长。           {             j++;             i++;           }        if(j>maxlen)            {               maxlen = j;               maxst = i-j;               a[i] = '\\0';            }        j = 0;     }     puts(&a[maxst]);     printf(\"%d\\n\", maxlen);     return 0; }", "referer": "user-0"}]}
{"question": "请问Win10中怎么用cmd命令重新动态分配ip地址？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 yyxgs 的回复:[quote=引用 3 楼 赵4老师 的回复:]if \"%1\"==\"l\" goto l if \"%1\"==\"w\" goto w echo 网络地址切换批处理 echo    setip l     ——切换到本地连接 echo    setip w     ——切换到无线网络连接 goto e  :l echo 从无线网络的静态ip切换到有线网络的静态ip： netsh interface ip set address 无线网络连接 dhcp netsh interface ip set dns 无线网络连接 dhcp netsh interface ip set address 本地连接 static 192.168.1.111 255.255.252.0 192.168.2.1 1 netsh interface ip set dns 本地连接 static 202.106.196.115 goto e  :w echo 从有线网络的静态ip切换到无限网络的静态ip： netsh interface ip set address 本地连接 dhcp netsh interface ip set dns 本地连接 dhcp netsh interface ip set address 无线网络连接 static 192.168.1.5 255.255.255.0 192.168.1.1 1 netsh interface ip set dns 无线网络连接 static 211.97.168.129 goto e  :e   感谢，我没看懂这个....是保存为.bat后运行吗？[/quote] 根据你的实际情况，修改里面的 \"无线网络连接\",\"本地连接\",以及调用netsh命令实现的功能（可在cmd中netsh /?,netsh int /?查看联机帮助） 然后保存为setip.bat", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 6 楼 yyxgs 的回复:[quote=引用 2 楼 ctrigger 的回复:]不用动态获取，自己指定不就OK了？  请问有这样的cmd命令吗[/quote] 建议搜一下dos命令，用于配置IP地址的，看一下ipconfig命令吧，然后可以写一个脚本，想换的时候手动换就可以了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 7 楼 5250 的回复:[quote=引用 4 楼 yyxgs 的回复:][quote=引用 1 楼 5250 的回复:]netsh int ipv4 reset  大佬您能解释一下这个命令的功能是什么吗？运行后怎么样，我刚试了一次，好像没啥变化[/quote]  这个是为了恢复ipv4的地址  如果你的电脑之前设置的自动获取ip的话 如果某个时间ip不可用 用这个命令会重新获取ip[/quote]  引用 4 楼 yyxgs 的回复:[quote=引用 1 楼 5250 的回复:]netsh int ipv4 reset  大佬您能解释一下这个命令的功能是什么吗？运行后怎么样，我刚试了一次，好像没啥变化[/quote]  如果你想问的是用cmd自己设置更改ip的话  参照一下这个 https://www.cnblogs.com/bingxing/p/6346849.html", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 4 楼 yyxgs 的回复:[quote=引用 1 楼 5250 的回复:]netsh int ipv4 reset  大佬您能解释一下这个命令的功能是什么吗？运行后怎么样，我刚试了一次，好像没啥变化[/quote]  这个是为了恢复ipv4的地址  如果你的电脑之前设置的自动获取ip的话 如果某个时间ip不可用 用这个命令会重新获取ip", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 ctrigger 的回复:不用动态获取，自己指定不就OK了？  请问有这样的cmd命令吗", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 赵4老师 的回复:if \"%1\"==\"l\" goto l if \"%1\"==\"w\" goto w echo 网络地址切换批处理 echo    setip l     ——切换到本地连接 echo    setip w     ——切换到无线网络连接 goto e  :l echo 从无线网络的静态ip切换到有线网络的静态ip： netsh interface ip set address 无线网络连接 dhcp netsh interface ip set dns 无线网络连接 dhcp netsh interface ip set address 本地连接 static 192.168.1.111 255.255.252.0 192.168.2.1 1 netsh interface ip set dns 本地连接 static 202.106.196.115 goto e  :w echo 从有线网络的静态ip切换到无限网络的静态ip： netsh interface ip set address 本地连接 dhcp netsh interface ip set dns 本地连接 dhcp netsh interface ip set address 无线网络连接 static 192.168.1.5 255.255.255.0 192.168.1.1 1 netsh interface ip set dns 无线网络连接 static 211.97.168.129 goto e  :e   感谢，我没看懂这个....是保存为.bat后运行吗？", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 5250 的回复:netsh int ipv4 reset  大佬您能解释一下这个命令的功能是什么吗？运行后怎么样，我刚试了一次，好像没啥变化", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "if \"%1\"==\"l\" goto l if \"%1\"==\"w\" goto w echo 网络地址切换批处理 echo    setip l     ——切换到本地连接 echo    setip w     ——切换到无线网络连接 goto e  :l echo 从无线网络的静态ip切换到有线网络的静态ip： netsh interface ip set address 无线网络连接 dhcp netsh interface ip set dns 无线网络连接 dhcp netsh interface ip set address 本地连接 static 192.168.1.111 255.255.252.0 192.168.2.1 1 netsh interface ip set dns 本地连接 static 202.106.196.115 goto e  :w echo 从有线网络的静态ip切换到无限网络的静态ip： netsh interface ip set address 本地连接 dhcp netsh interface ip set dns 本地连接 dhcp netsh interface ip set address 无线网络连接 static 192.168.1.5 255.255.255.0 192.168.1.1 1 netsh interface ip set dns 无线网络连接 static 211.97.168.129 goto e  :e", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "不用动态获取，自己指定不就OK了？", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "netsh int ipv4 reset", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "ipconfig /release  --- 释放ip搜索 ipconfig /renew  --- 重新获得", "referer": "user-0"}]}
{"question": "约瑟夫算法问题，请教一下大佬们该怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢两位大佬的回答！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 8 楼 mll97 的回复:[quote=引用 6 楼 自信男孩 的回复:][quote=引用 5 楼 mll97 的回复:][quote=引用 3 楼 user-2 的回复:][quote=引用 1 楼 mll97 的回复:]整了一下午也没整明白，感觉整不出来饭都不香了  把你这个函数贴出来看看 ds_traverse(C);[/quote]谢谢大佬，已经解决了，就是有无哨兵的问题，但是不知道为什么有哨兵会导致程序报错。[/quote] 因为哨兵可能也被计算（数数的时候）[/quote]上午下午一直在上课，没能及时查看信息，不好意思啊。请问哨兵是不是不能被删，我调试的时候发现是数了一阵，哨兵被删除了之后，再次经过哨兵原有的位置的时候就报错了，是指针找不到链表的起始地址然后就报错了吗？[/quote] 不把哨兵算进来，那么遇到哨兵不计算，那么就不会删除，最后应该剩两个节点才对，一个哨兵，一个最后一个节点；  为了简单，这个题目不要用哨兵了，反而用了会更麻烦，效率更低。  哨兵的作用是找头结点方便，但是对于这个问题不需要找头结点，因为是一个循环的链表", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 5 楼 mll97 的回复:[quote=引用 3 楼 user-2 的回复:][quote=引用 1 楼 mll97 的回复:]整了一下午也没整明白，感觉整不出来饭都不香了  把你这个函数贴出来看看 ds_traverse(C);[/quote]谢谢大佬，已经解决了，就是有无哨兵的问题，但是不知道为什么有哨兵会导致程序报错。[/quote] 因为哨兵可能也被计算（数数的时候）", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 user-2 的回复:[quote=引用 1 楼 mll97 的回复:]整了一下午也没整明白，感觉整不出来饭都不香了  把你这个函数贴出来看看 ds_traverse(C);[/quote]谢谢大佬，已经解决了，就是有无哨兵的问题，但是不知道为什么有哨兵会导致程序报错。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:[quote=引用 1 楼 mll97 的回复:]整了一下午也没整明白，感觉整不出来饭都不香了 链表不要用带哨兵的单向循环链表了，直接用无哨兵的 [/quote]你好，请问下为什么用了有哨兵的就会报错，能解释一下吗？谢谢", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 1 楼 mll97 的回复:整了一下午也没整明白，感觉整不出来饭都不香了  把你这个函数贴出来看看 ds_traverse(C);", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 5 楼 mll97 的回复:][quote=引用 3 楼 user-2 的回复:][quote=引用 1 楼 mll97 的回复:]整了一下午也没整明白，感觉整不出来饭都不香了  把你这个函数贴出来看看 ds_traverse(C);[/quote]谢谢大佬，已经解决了，就是有无哨兵的问题，但是不知道为什么有哨兵会导致程序报错。[/quote] 因为哨兵可能也被计算（数数的时候）[/quote]上午下午一直在上课，没能及时查看信息，不好意思啊。请问哨兵是不是不能被删，我调试的时候发现是数了一阵，哨兵被删除了之后，再次经过哨兵原有的位置的时候就报错了，是指针找不到链表的起始地址然后就报错了吗？", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "引用 1 楼 mll97 的回复:整了一下午也没整明白，感觉整不出来饭都不香了 链表不要用带哨兵的单向循环链表了，直接用无哨兵的", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "整了一下午也没整明白，感觉整不出来饭都不香了", "referer": "user-0"}]}
{"question": "ASCII码大于128的字节，怎么发送到串口中", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "0101010101101001010100101101010001 内存中内容如上,你用cha*来翻译是一种结果,你用ascII来翻译是另一个结果,但内存数据就是这个东西,不多也不少", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 赵4老师的回复:强转为char* 类型的，这些ASCII码大于128的字节,不会变值。  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息…… 但是在qt里，它提示我不能这样赋值，我用char类型的变量接一个0xf1，提示类型不匹配", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "强转为char* 类型的，这些ASCII码大于128的字节,不会变值。  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 4 楼 遥_望 的回复:[quote=引用 3 楼 赵4老师的回复:]强转为char* 类型的，这些ASCII码大于128的字节,不会变值。  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息…… 但是在qt里，它提示我不能这样赋值，我用char类型的变量接一个0xf1，提示类型不匹配[/quote] qt里面可以直接赋值的，不过需要做一个强制类型转换 unsigned char ch=(char)0xf1;", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "char c=(char)0xf1;", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "一个字节有8位，可以存0-255，大于128没关系，直接发送即可。 如果大于255，就要发多个字节，需要考虑大小端问题。", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "直接把大于128的小于255的放到buf里就可以了，虽然buf是char *类型，但是赋值给buf之后，其值是不变的，不会把大于128的值戒掉。  内存里的空间是不分char 还是unsigned char，甚至是int, long, double的。内存只是存放0101的内容，只有输出时按照对应的格式输出。", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "你发送什么就会接收到什么，跟大于不大于128没关系。大于128只是不是可显示字符而已。", "referer": "user-0"}]}
{"question": "顺序查找，折半查找", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "l.length=length是什么意思啊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h>  #define list_size 20 typedef int keytype; typedef int othertype;  typedef struct {     othertype key;     keytype other_data; }recordtype; typedef struct {     recordtype r[list_size+1];     int length; }recordlist; //顺序查找，设监视哨 int seqsearch(recordlist l,keytype k) {     int i;     l.r[0].key=k;     i=l.length;     while(i > 0 && l.r[i].key!=k)         i--;     return i; } //顺序查找，不设监视哨 int SeqSearch(recordlist l,keytype k) {     int i;     i=l.length;     while(i>=1&&l.r[i].key!=k)         i--;     if(i>=1)         return i;     else         return 0; } //折半查找 int rinsrch(recordlist l,keytype k) {     int mid;     int low=0;     int high=l.length;     while(low<=high)     {         mid=(low+high)/2;         if(k==l.r[mid].key)             return mid;         else if(k<l.r[mid].key)             high=mid-1;         else             low=mid+1;     }     return 0; } int main() {     recordlist l;     int q,p,t,loc,len,i,length;     //创建     printf(\"请输入表中元素个数：\");     scanf(\"%d\",&len);     if (len < list_size)         length=len;     else         length = list_size;     printf(\"输入顺序表的元素：\");     for(i=1;i<=length;i++)     {         scanf(\"%d\", &l.r[i].key);     }     l.length = length;     //查找     printf(\"请输入要查找的元素：\");      scanf(\"%d\",&loc);       q=seqsearch(l,loc);     //if (p!= 0)     if (q != 0)         printf(\"元素下标1为：%d\\n\", q);     else         printf(\"该元素不存在！\\n\");     p=SeqSearch(l,loc);     if (p!= 0)         printf(\"元素下标2为：%d\\n\", q);     else         printf(\"该元素不存在！\\n\");     t=rinsrch(l,loc);     if (t!=0)         printf(\"元素下标3为：%d\\n\",t);     else         printf(\"该元素不存在！\\n\");      return 0; }  供参考～  错误的地方不少，l的length没有赋值，scanf对谁赋值？数组越界访问等等 建议对比代码找一下自己的问题～", "referer": "user-0"}]}
{"question": "数据结构课程设计", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h>  struct data{ \tint a; \tint b; \tint v; };  int main(void) { \tint i, j, k, value, c=0; \tstruct data d[100], t; \t \tfor(i=0; i<10; i++) \t{ \t\tfor(j=0; j<20; j++) \t\t{ \t\t\tvalue = 2 * i * i + j * j;\t \t\t\tt.a = i; \t\t\tt.b = j; \t\t\tt.v = value; \t\t\t \t\t\tif(c < 100) \t\t\t{ \t\t\t\td[c] = t; \t\t\t\tc++; \t\t\t} \t\t\telse if(d[99].v < value) break; \t\t\telse d[99] = t; \t\t\tfor(k=c-2; k>=0 && d[k].v>value; k--) \t\t\t{ \t\t\t\td[k+1] = d[k]; \t\t\t} \t\t\t \t\t\td[k+1] = t; \t\t} \t} \t \tfor(c=0; c<100; c++) \t{ \t\tprintf(\"%d:\\t%d\\t%d\\t%d\\n\", c, d[c].a, d[c].b, d[c].v); \t} \t \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "可以用插入排序的方法一边遍历a，b递增的 f 的结果，一边保存最小的100个值 int main( ) {     int a, b, f[3][100], t, i, j;     for (i=0; i<100; i++) f[2][i]=3*100*100;     for (a=0; a<10; a++) {         for (b=0; b<15; b++) {             t = 2*a*a+b*b;             for (i=0; t>f[2][i]&&i<100; i++); //插入排序查找插入位置             if (i<100) {                 for (j=99; j>i; j--) {                     f[0][j]=f[0][j-1];                     f[1][j]=f[1][j-1];                     f[2][j]=f[2][j-1];                 }                 f[0][i] = a;                 f[1][i] = b;                 f[2][i] = t;             }         }     }     for (i=0; i<100; i++) {         printf(\"f(%d,%d)=%d\\n\", f[0][i], f[1][i], f[2][i]);     }          return 0; }", "referer": "user-0"}]}
{"question": "为什么输出值为35.00000不是35", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢，试了一下是对的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你这是打印浮点数，默认打印小数点后6位 如果不想打印小数，改成 printf(\"the converted value is %.0f\", d); //打印0位小数点", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "因为楼主用的是%f输出，所以会有有效位数。 可以用%.0f输出试试，应该就是35了。", "referer": "user-0"}]}
{"question": "如何辨别逻辑结构和物理结构", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "听说话物理地址和逻辑地址，数据结构还分物理结构和逻辑结构?", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我个人认为逻辑结构是抽象的，例如树，图，链表。而没有具体到什么什么链表，什么什么树。 而物理结构则是具体到一种结构，犹如单链表，二叉树", "referer": "user-0"}]}
{"question": "数组指针和指针数组的区别", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个可以认为是一个语文的问题：  数组指针：数组修饰指针，即结果是指针，那么这个指针的修饰数组，即该指针指向一个数组； 指针数组：指针修饰数组，即结果是数组，那么这个数组的修饰指针，即该数组的内容（元素）都是指针。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf(\"typeid(x).name() is %s\\n\",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "数组指针是指向一个数组的指针，本质是一个指针。指针数组是元素为指针的一个数组，本质是一个数组", "referer": "user-0"}]}
{"question": "c语言编写函数int divide(char *ss，int *a)，其功能是：从左到右依次扫描字符串ss，将串中连续出现的数字串转换成整数，并将其依次保存到a", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "修改如下：#include <iostream.h> #include <string.h> int divide(char *ss,int *a) {     int j,n=0,i,k;     char temp[100];     for (i=0;ss[i]!='\\0';i++)     {         j = 0;         k = 0;         while (ss[i] >= '0' && ss[i] <= '9')         {             if(k==0 && i!=0 && ss[i-1]=='-') //负数处理              {                                            temp[j] = ss[i-1];               j++;               k++;              }             temp[j] = ss[i];             j++;             i++;         }         if (j!=0)         {             temp[j] = '\\0';             *a = atoi(temp);             a++;             n++;             i--;         }          }    return n; }  int  getSum(int *a,int  n) {    int sum=0,i;    for(i=0;i<n;i++)         sum += a[i];    return  sum; }  int main(int argc, char* argv[]) {     char ss[100];     int  n,sum=0,a[100];     gets(ss);     n = divide(ss, a);     sum = getSum(a,n);     cout<<\"sum = \"<<sum<<endl;      system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "if (k ==0&&i!=0&& ss[i-1]==‘-‘)", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "还是有漏洞，4#楼说的有道理，这句判断再封一道：if (k==0&&ssi!=0&&ss[i-1])", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 3 楼 qzjhjxj 的回复:前一种对负数处理有漏洞，修改如下，供参考：#include <iostream.h> #include <string.h> int divide(char *ss,int *a) {     int j,n=0,i,k;     char temp[100];     for (i=0;ss[i]!='\\0';i++)     {         j = 0;         k = 0;         while (ss[i] >= '0' && ss[i] <= '9')         {             if(k==0 && ss[i-1]=='-') //负数处理              {               temp[j] = ss[i-1];               j++;               k++;              }             temp[j] = ss[i];             j++;             i++;         }         if (j!=0)         {             temp[j] = '\\0';             *a = atoi(temp);             a++;             n++;             i--;         }          }    return n; }  int  getSum(int *a,int  n) {    int sum=0,i;    for(i=0;i<n;i++)         sum += a[i];    return  sum; }  int main(int argc, char* argv[]) {     char ss[100];     int  n,sum=0,a[100];     gets(ss);     n = divide(ss, a);     sum = getSum(a,n);     cout<<\"sum = \"<<sum<<endl;      system(\"pause\");     return 0; } 在判断负数时，即判断'-'时，如果i是0，那么ss[i-1]会怎么样？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "前一种对负数处理有漏洞，修改如下，供参考：#include <iostream.h> #include <string.h> int divide(char *ss,int *a) {     int j,n=0,i,k;     char temp[100];     for (i=0;ss[i]!='\\0';i++)     {         j = 0;         k = 0;         while (ss[i] >= '0' && ss[i] <= '9')         {             if(k==0 && ss[i-1]=='-') //负数处理              {               temp[j] = ss[i-1];               j++;               k++;              }             temp[j] = ss[i];             j++;             i++;         }         if (j!=0)         {             temp[j] = '\\0';             *a = atoi(temp);             a++;             n++;             i--;         }          }    return n; }  int  getSum(int *a,int  n) {    int sum=0,i;    for(i=0;i<n;i++)         sum += a[i];    return  sum; }  int main(int argc, char* argv[]) {     char ss[100];     int  n,sum=0,a[100];     gets(ss);     n = divide(ss, a);     sum = getSum(a,n);     cout<<\"sum = \"<<sum<<endl;      system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "#include  <stdio.h> #include  <stdlib.h> #include  <ctype.h>  int  divide(char  *ss,int  *a); int  getSum(int  *a,int  n);  int  main() {     char  ss[100];     int  a[100],n,sum;     fgets(ss, 100, stdin);     n  =  divide(ss,a);     sum  =  getSum(a,n);     printf(\"%d\\n\",sum);      return  0; }  int  divide(char  *ss,int  *a) {     char *p = ss;     int num = -1, i, sign;      sign = 1;     i = 0;     while (*p) {         while (*p && isdigit(*p)) {             if (num < 0) {                 if (p-ss >= 1 && *(p-1) == '-')                     sign *= -1;                 num = 0;             }             num = (num * 10) + *p - '0';             p++;         }         if (num >= 0) {             a[i++] = num *sign;             num = -1;             sign = 1;         }         if (*p == '\\0')             break;         p++;     }      return i; } int  getSum(int  *a,int  n) {     int  sum  =  0,i;     for(i=0;i<n;i++){         sum  =  sum+a[i];     }     return  sum; } 供参考～", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "供参考：#include <iostream.h> #include <string.h> int divide(char *ss,int *a) {     int j,n=0,i,k;     char temp[100];     for (i=0;ss[i]!='\\0';i++)     {         j = 0;         while (ss[i] >= '0' && ss[i] <= '9' || ss[i] == '-')         {             temp[j] = ss[i];             j++;             i++;         }         if (j!=0)         {             temp[j] = '\\0';             *a = atoi(temp);             a++;             n++;             i--;         }          }    return n; }  int  getSum(int *a,int  n) {    int sum=0,i;    for(i=0;i<n;i++)         sum += a[i];    return  sum; }  int main(int argc, char* argv[]) {     char ss[100];     int  n,sum=0,a[100];     gets(ss);     cout<<endl;     n = divide(ss, a);     sum = getSum(a,n);     cout<<\"sum = \"<<sum<<endl;     system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": "各位大佬，我用的自定义函数总是有问题，又找不出错在哪儿了，求帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 qzjhjxj 的回复：楼主，忍不住要吐槽下这个书写风格，修改如下，但没看懂你的思想：#include<time.h> #include<stdlib.h> #include<stdio.h> int Computer(int n); int Rnd(void); //这个函数没声明  int main(int argc, char* argv[]) {   int x,y,m;   printf(\"Input 1 or 1,2:\");   scanf(\"%d\",&x);   y=Computer(x);   for(m=x;m<=30;m++)    {       printf(\"\\nInput it continuing:\");       scanf(\"%d\",&x);    //\"}\" 这个不放这里吧？       if(Computer(y)==30)        {          printf(\"You lose!\\n\");        }       else          printf(\"You win!\\n\");     }   system(\"pause\");   return 0; } //--------------------------------------------------------------------------- int Computer(int n)   //这个函数里 n,e,r都没用吗？ {    int e,r;/*r为随机数*/    r=Rnd();    if((e+1)%3==1)      {        printf(\"%d\\n\",e+1);      }    else      if((e+1)%3==2)       {         printf(\"%d,%d\\n\",e+1,e+2);       }       else         if((e+1)%3==0&&r%2==0)           {             printf(\"%d\\n\",e+1);           }          else           if((e+1)%3==0&&r%2==1)//\";\" 这里分号多打了             {               printf(\"%d,%d\\n\",e+1,e+2);             }    return e; }  int Rnd() {   srand(time(NULL));   return rand()%2; }谢谢 谢谢，我之后仔细想过了，思路确实有问题，书写风格是我复制粘贴，过来了，他自动把格式打乱了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：#include<time.h> #include<stdlib.h> #include<stdio.h>  int Computer(int n); int Rnd(void); int main() {     int x,y,m;     printf(\"Input 1 or 1,2:\");     scanf(\"%d\",&x);     y=Computer(x);     for(m=x;m<=30;m++) {         printf(\"Input it continuing:\");         scanf(\"%d\",&x);     }     if(Computer(y)==30) {         printf(\"You lose!\\n\");     } else         printf(\"You win!\\n\");      return 0; } int Computer(int n) {     int e,r;/*r为随机数*/     r = Rnd();     if((e+1)%3==1) {         printf(\"%d\",e+1);     } else if((e+1)%3==2) {         printf(\"%d\\n,%d\",e+1,e+2);     } else if((e+1)%3==0&&r%2==0) {         printf(\"%d\",e+1);     //} else if((e+1)%3==0&&r%2==1); {     } else if((e+1)%3==0&&r%2==1) {         printf(\"%d\\n,%d\",e+1,e+2);     }     return e; }  int Rnd() {     srand(time(NULL));     return rand()%2; } 供参考～  多一个分号～谢谢，我是大一新生，刚接触c语言，不明白的地方弄清楚了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "楼主，忍不住要吐槽下这个书写风格，修改如下，但没看懂你的思想：#include<time.h> #include<stdlib.h> #include<stdio.h> int Computer(int n); int Rnd(void); //这个函数没声明  int main(int argc, char* argv[]) {   int x,y,m;   printf(\"Input 1 or 1,2:\");   scanf(\"%d\",&x);   y=Computer(x);   for(m=x;m<=30;m++)    {       printf(\"\\nInput it continuing:\");       scanf(\"%d\",&x);    //\"}\" 这个不放这里吧？       if(Computer(y)==30)        {          printf(\"You lose!\\n\");        }       else          printf(\"You win!\\n\");     }   system(\"pause\");   return 0; } //--------------------------------------------------------------------------- int Computer(int n)   //这个函数里 n,e,r都没用吗？ {    int e,r;/*r为随机数*/    r=Rnd();    if((e+1)%3==1)      {        printf(\"%d\\n\",e+1);      }    else      if((e+1)%3==2)       {         printf(\"%d,%d\\n\",e+1,e+2);       }       else         if((e+1)%3==0&&r%2==0)           {             printf(\"%d\\n\",e+1);           }          else           if((e+1)%3==0&&r%2==1)//\";\" 这里分号多打了             {               printf(\"%d,%d\\n\",e+1,e+2);             }    return e; }  int Rnd() {   srand(time(NULL));   return rand()%2; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include<time.h> #include<stdlib.h> #include<stdio.h>  int Computer(int n); int Rnd(void); int main() {     int x,y,m;     printf(\"Input 1 or 1,2:\");     scanf(\"%d\",&x);     y=Computer(x);     for(m=x;m<=30;m++) {         printf(\"Input it continuing:\");         scanf(\"%d\",&x);     }     if(Computer(y)==30) {         printf(\"You lose!\\n\");     } else         printf(\"You win!\\n\");      return 0; } int Computer(int n) {     int e,r;/*r为随机数*/     r = Rnd();     if((e+1)%3==1) {         printf(\"%d\",e+1);     } else if((e+1)%3==2) {         printf(\"%d\\n,%d\",e+1,e+2);     } else if((e+1)%3==0&&r%2==0) {         printf(\"%d\",e+1);     //} else if((e+1)%3==0&&r%2==1); {     } else if((e+1)%3==0&&r%2==1) {         printf(\"%d\\n,%d\",e+1,e+2);     }     return e; }  int Rnd() {     srand(time(NULL));     return rand()%2; } 供参考～  多一个分号～", "referer": "user-0"}]}
{"question": "关于结构指针做实参的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 我保证不学啦 的回复:[quote=引用 1 楼 自信男孩的回复:]因为这个参数是要求一个传入传出参数，如果仅仅是一个传入参数，是不需要传其地址的。如果想把P申请的空间链到rear之后，就需要传rear的地址，这样能把对rear的修改带出Attach函数，就是为了保证Attach修改的是调用函数里的rear，而不是Attach函数里的形参。 如果传的是结构指针，就只能把改这一块链表区域的值传出去。如果传结构指针的地址，就可以改指链表头结点的指针使它指向别的任意地址这个操作给传递出去 请问是这个意思吗？[/quote] 不论是什么样的指针，不论这个结构体有多大，传结构体指针只会传sizeof(long)指针大小的给形参，形参也只能接收这么大小。 所以，指针大小是固定的。sizeof(long)大小", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:因为这个参数是要求一个传入传出参数，如果仅仅是一个传入参数，是不需要传其地址的。如果想把P申请的空间链到rear之后，就需要传rear的地址，这样能把对rear的修改带出Attach函数，就是为了保证Attach修改的是调用函数里的rear，而不是Attach函数里的形参。 如果传的是结构指针，就只能把改这一块链表区域的值传出去。如果传结构指针的地址，就可以改指链表头结点的指针使它指向别的任意地址这个操作给传递出去 请问是这个意思吗？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这种属于常见问题。lz只要明白传实参的值（结构体普通参数）和传实参的地址（指针参数）的区别，那应该就能理解。 如果是传值，函数内修改参数是不影响函数外的实参的（因为形參是实参的拷贝，属于不同的函数栈的内存空间，二者除了值相同没有任何联系），这应该是最基本的基础知识了吧？那么要修改函数外的实参怎么办？那就是用指针传实参的地址（这样形參和实参指向的地址相同，存在联系，就可以改变其中一个影响另一个）。 所以，你要在Attach里修改pRear使得函数外rear实参也受影响，那就要传rear的地址（也就是要用指针类型或者用引用类型）", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "因为这个参数是要求一个传入传出参数，如果仅仅是一个传入参数，是不需要传其地址的。如果想把P申请的空间链到rear之后，就需要传rear的地址，这样能把对rear的修改带出Attach函数，就是为了保证Attach修改的是调用函数里的rear，而不是Attach函数里的形参。", "referer": "user-0"}]}
{"question": "新手求各位大佬教我实现这个程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "思路明了： 直接while(true)来读取，if判断读入数字是否符合要求，符合要求就调用sqrt函数，不符合要求就显示错误信息然后直接continue语句。 读取Y/y那里的话，如果读入的是Y或y就直接break语句就好。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "谭浩强老先生的书，看一下吧，效果不错的。", "referer": "user-0"}]}
{"question": "C语言：高精加高精减——大佬请进", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "测试一下0+0", "referer": "user-0"}]}
{"question": "关于选择排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "按地址传递的话，这个了解不是很深入 不过我看着最后一张图的swap应该是没问题的（自己上机试了一下用地址传递参数交换数组元素） 目前觉得如果真的是按最后一张图的做法做也没结果的话…… 你看看关于函数selection_sort的调用有没有问题？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "别的暂且不说，你swap函数是按值传递，执行了以后是没效果的。 swap得按地址传递或者按引用传递（推荐）。 把第二行改成  void swap(int &a,int &b) 试试？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "第一张swap是参数值传递的方式，最后一张是传地址的方式，值传递和传地址的不同，翻书了解一下", "referer": "user-0"}]}
{"question": "【求助】C语言小白因为网课要求要编写2个小程序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int n = 0, d = INT_MIN, x = INT_MAX, j = 0, g = 0; \twhile (g++<20)cin >> n, (n>d ? d = n : 0), (x > n ? x = n : 0), j += n; \tcout << d << \"大\" << x << \"小\" << j / 20 << \"均\";  \tcin >> x; n = x; j = g = 0; \twhile (n) \t{ \t\twhile (j++<n)cout << ends; --n, j = 0; \t\twhile (g++ < x)cout << \"*\"; cout << endl; g = 0; \t}", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼上的答案对于新手来说太复杂，还是简单地用个数组来计算吧", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "int n=0,d=INT_MIN,x=INT_MIX,j=0,g=0; while(g++<20)cin>>n,(n>d?d=n:0),(x>n?x=n:0)j+=n: cout<<d<<\"大\"<<x<<\"小\"<<j/20<<\"均\";", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "第一题：#include<stdio.h> int main() {     int a,d;     int i[20]={22,2,3,4,99,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};     int xiao=i[0],da=i[0];     for(a=1;a<=19;a++)      {        if(xiao>i[a])           xiao=i[a];            }     for(a=1;a<=19;a++)     {        if(da<i[a])        da=i[a];     }          printf(\"最大值为:%d,最小值:%d\\n\",da,xiao);           return 0; } 第二题： #include<stdio.h> int main() {     int h=4;     for(int i=0;i<4;i++)     {        for(int j=i;j<4;j++)        {           printf(\" \");                   }        printf(\"****\\n\");     }                return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "#include<stdio.h> int main() {     int a,d;     int i[20]={22,2,3,4,99,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};     int xiao=i[0],da=i[0];     for(a=1;a<=19;a++)      {        if(xiao>i[a])           xiao=i[a];            }     for(a=1;a<=19;a++)     {        if(da<i[a])        da=i[a];     }          printf(\"最大值为:%d,最小值:%d\\n\",da,xiao);           return 0; }", "referer": "user-0"}]}
{"question": "使用if else输出结果不对。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 9 楼 qzjhjxj的回复:修改如下，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int s[10] = {8,10,23,37,41,55,68,72,89,95};     int i,n,t=0;     scanf(\"%d\",&n);     if(n == s[4])              t = 4+1;     if(n < s[4])        for(i = 3;i >= 0;i--)           if(n == s[i])              t=i+1;     if(n > s[4])        for(i = 5;i < 10;i++)           if(n == s[i])              t=i+1;     if(t != 0)        printf(\"sta=%3d\\n\",t);     else        printf(\"No such number!\\n\");     return 0; } 谢谢谢谢！！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 9 楼 qzjhjxj的回复:修改如下，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int s[10] = {8,10,23,37,41,55,68,72,89,95};     int i,n,t=0;     scanf(\"%d\",&n);     if(n == s[4])              t = 4+1;     if(n < s[4])        for(i = 3;i >= 0;i--)           if(n == s[i])              t=i+1;     if(n > s[4])        for(i = 5;i < 10;i++)           if(n == s[i])              t=i+1;     if(t != 0)        printf(\"sta=%3d\\n\",t);     else        printf(\"No such number!\\n\");     return 0; } 谢谢谢谢！！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "修改如下，供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int s[10] = {8,10,23,37,41,55,68,72,89,95};     int i,n,t=0;     scanf(\"%d\",&n);     if(n == s[4])              t = 4+1;     if(n < s[4])        for(i = 3;i >= 0;i--)           if(n == s[i])              t=i+1;     if(n > s[4])        for(i = 5;i < 10;i++)           if(n == s[i])              t=i+1;     if(t != 0)        printf(\"sta=%3d\\n\",t);     else        printf(\"No such number!\\n\");     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:s[4]=41,当n=65 时，从第7行的if 语句开始判断，执行到第18行的if 语句才是满足条件的，就开始执行第19行的for 语句的内容，那里打印输出的条件是n =s[i],显然是没有满足条件的，所以程序就什么都不干就return 0了。最后那个else 是和第18行if 是一对的，当18行的if 条件不满足的时候，24行的else 才会执行到。再多一句，第13行的if 里，i<4的条件是多余的，因为是i- -。 怎么修改呢那应该怎么修改呢", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 qzjhjxj的回复:s[4]=41,当n=65 时，从第7行的if 语句开始判断，执行到第18行的if 语句才是满足条件的，就开始执行第19行的for 语句的内容，那里打印输出的条件是n =s[i],显然是没有满足条件的，所以程序就什么都不干就return 0了。最后那个else 是和第18行if 是一对的，当18行的if 条件不满足的时候，24行的else 才会执行到。再多一句，第13行的if 里，i<4的条件是多余的，因为是i- -。 那怎么解决呀", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "输入65的时候走到了18行的分支中 和for循环中条件不满足 不输出数字  24行的else分支只有再18行不满足时进入  18行满足了  自然不会输出no such number了", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "else if(n<s[4]) {       for(i=3;k<4 && i>=0;i--)           {                    ...           }  }", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "s[4]=41,当n=65 时，从第7行的if 语句开始判断，执行到第18行的if 语句才是满足条件的，就开始执行第19行的for 语句的内容，那里打印输出的条件是n =s[i],显然是没有满足条件的，所以程序就什么都不干就return 0了。最后那个else 是和第18行if 是一对的，当18行的if 条件不满足的时候，24行的else 才会执行到。再多一句，第13行的if 里，i<4的条件是多余的，因为是i- -。", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "括号使用不规范", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "s[4]=41 输入65会进入else if(n>s[4])这个分支 在这个分支里，满足if(n==s[i])的数据不存在，所以没有任何输出", "referer": "user-0"}]}
{"question": "小白求问表达式的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "int (*run)(struct A*) = 0; 去看一下函数指针相关的语法吧  函数名也可以当作指针来看  这句话其实就是一个（函数）指针的初始化而已 和普通的int *p=null 同意义", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3 的回复:run是个函数指针，函数的参数是A结构体指针，返回是为int。run指针初始化为指向0地址  知道了，谢谢啊", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼上正解。不过int (*run)(struct A*) = NULL貌似更好。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "run是个函数指针，函数的参数是A结构体指针，返回是为int。run指针初始化为指向0地址", "referer": "user-0"}]}
{"question": "小白问大神们关于结构体嵌套的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 qybao 的回复:p=(struct A*)malloc(sizeof(struct A)); 这样分配的内存，B也分配了。因为B不是指针，不用单独分配 另，结构体嵌套结构体，如果想自己分配内存，最好不要匿名结构体。可以用typedef声明结构体类型，再在结构体内部使用该声明好的类型 这是别人C语言编写的源码里的内容，不知道怎么改成C++的。  decoder->sync = malloc(sizeof(*decoder->sync));", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 ctrigger 的回复:直接用struct A* p = (struct A*)malloc(sizeof(struct A));就可以了。不过你定义的结构体有点问题，需要修改一下，仅供参考：  #include <stdio.h> #include <stdlib.h>  struct A {     int x, y, z;      struct B     {         int w;         char c;     } b; };  int main(void) {     struct A* p = (struct A*)malloc(sizeof(struct A));     p->x = p->y = p->z = 1000;     p->b.w = 2000;     p->b.c = 'A';     return 0; }   我是在别人的源码里看到的，但源码是C语言的，我想改成C++就必须要我指定类型，否则通不过。我试了好多种办法都不行 decoder->sync = malloc(sizeof(*decoder->sync));", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "struct A *p = (struct A*)malloc(sizeof(struct A))", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "p=(struct A*)malloc(sizeof(struct A)); 这样分配的内存，B也分配了。因为B不是指针，不用单独分配 另，结构体嵌套结构体，如果想自己分配内存，最好不要匿名结构体。可以用typedef声明结构体类型，再在结构体内部使用该声明好的类型", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "直接用struct A* p = (struct A*)malloc(sizeof(struct A));就可以了。不过你定义的结构体有点问题，需要修改一下，仅供参考：  #include <stdio.h> #include <stdlib.h>  struct A {     int x, y, z;      struct B     {         int w;         char c;     } b; };  int main(void) {     struct A* p = (struct A*)malloc(sizeof(struct A));     p->x = p->y = p->z = 1000;     p->b.w = 2000;     p->b.c = 'A';     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "typedef struct {}A; A *p;", "referer": "user-0"}]}
{"question": "为啥我的链表输出不对啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h>  typedef struct _node{     int value;     struct _node *previous;     struct _node *next; }Node;  int main(void) {     Node *head=NULL;     Node *tail=NULL;     int j=1;     for(int number;scanf(\"%d\",&number)==1&&number!=-1;){         Node *Last=head;         if(j==1){             head=(Node *)malloc(sizeof (Node));             head->value=number;             head->next=NULL;             head->previous=NULL;             j++;             //break;             continue;         }         else{             //for(;Last;Last=Last->next);             for(;Last->next;Last=Last->next)                 ;             Node *p=(Node *)malloc(sizeof (Node));             Last->next=p;             p->value=number;             p->next=NULL;             p->previous=Last;             tail=p;         }     }     for(Node *i=head;i;i=i->next){         printf( \"%d\\t\", i->value );     }     for(Node *k=tail;k;k=k->previous){         printf( \"%d\\t\", k->value );     }     return 0; }   供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "20行的break删除。 23行的 for(;Last;Last=Last->next); ===> for(;Last->next;Last=Last->next);", "referer": "user-0"}]}
{"question": "求大佬解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为p1和p2都是指针，返回的是指针变量的值，指针变量的值就是它指向的字符串的地址（首地址）； 如果加上&，那就是返回指针变量的地址，因为p1, p2都是局部变量，函数调用结束就会被释放，因此返回指针变量的地址没有意义。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1。因为p1,p2就是地址呀   为什么要用&p1  这个是地址的地址了   你对指针这一块儿可能还没搞懂 int a = 0; a是变量 &a是a的地址，int *p=a  p就是a的地址了  等同于p = &a。所以p1，p2直接返回即可  2。printf输出字符串 直接写变量名就行 *p1是字符串的地址了  你要输出的只是字符串而已", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "char *p1   ---------- p1指针变量，里面存储的就是地址值。那个函数返回指针变量值（地址值），所以写的是指针变量名", "referer": "user-0"}]}
{"question": "数据结构课程设计散列表实现通讯录查找系统", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "自动动手，自力更生，艰苦奋斗。多好啊。。", "referer": "user-0"}]}
{"question": "C语言删除二叉树子树代码。是哪里有问题啊？哭了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:逻辑有问题。应该分成2个函数递归。。一个函数是递归查找，找到符合条件结点。一个函数是递归删除。 感谢感谢感谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 5 楼 真相重于对错的回复:如果用c写的话 大概如下 void del(int** x) {    free(*x);    *x=NULL; } int* p=(int*)malloc... del(&p)； 感谢感谢感谢", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "如果用c写的话 大概如下 void del(int** x) {    free(*x);    *x=NULL; } int* p=(int*)malloc... del(&p)；", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "而且你只是把那个变量赋值为NULL，它所指向的内存依然被使用着，所以是错误的 应该 void del(int* &x) {    delete x;    x=NULL; } int* p=new int(10); del(p)；", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "理解一下 void del(int *x) {    x=NULL; } int* p=new int(10); del(p)； 之后这个p变没变成NULL????", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "逻辑有问题。应该分成2个函数递归。。一个函数是递归查找，找到符合条件结点。一个函数是递归删除。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "delete函数中t->name那里，这里需要个循环去找到d吧，直接t->name是不是有点问题，", "referer": "user-0"}]}
{"question": "求解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先运行a[i] = i,之后运行i++", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "i先赋值再自增，数组中分别为0123", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "答案不应该为2应该为3", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "2楼和3楼说的都没问题，就是没有回答楼主的问题", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "太牛叉了。你能写这种代码玩编译器，当心编译器把你玩死了。", "referer": "user-0"}]}
{"question": "win32 MCI播放音视频格式问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 赵4老师 的回复:安装“QQ影音” 我用的potplayer不行吗 是因为QQ影音安装驱动还是？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "安装“QQ影音”", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 3 楼 六道佩恩 的回复:[quote=引用 1 楼 Intel0011 的回复:]mid、wav、avi 你可以试试装个全一点的音频解码器，看看能播放吗 感觉有库的支持应该可以 你的环境里，MCI支持多少格式？ 都是open然后play就能正常播放的吗？[/quote] 我的环境里也不是什么格式都能播放，没装解码器", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 3 楼 六道佩恩 的回复:[quote=引用 1 楼 Intel0011 的回复:]mid、wav、avi 你可以试试装个全一点的音频解码器，看看能播放吗 感觉有库的支持应该可以 你的环境里，MCI支持多少格式？ 都是open然后play就能正常播放的吗？[/quote] 我的环境里也不是什么格式都能播放，没装解码器", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 Intel0011 的回复:mid、wav、avi 你可以试试装个全一点的音频解码器，看看能播放吗 感觉有库的支持应该可以 你的环境里，MCI支持多少格式？ 都是open然后play就能正常播放的吗？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "下载编解码器：http://www.mediaplayercodecpack.com/", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "mid、wav、avi 你可以试试装个全一点的音频解码器，看看能播放吗 感觉有库的支持应该可以", "referer": "user-0"}]}
{"question": "关于C语言realloc函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 西门炊雪的回复:都可以，习惯问题 好的，明白了，谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3的回复:不需要，malloc/realloc，调用成功，返回有效指针；调用失败返回NULL。前面再加上=NULL，没实际意义。 好的，明白了，谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "这是按照变量先声明，后定义的顺序；其实也可以声明的时候就定义。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "都可以，习惯问题", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "不需要，malloc/realloc，调用成功，返回有效指针；调用失败返回NULL。前面再加上=NULL，没实际意义。", "referer": "user-0"}]}
{"question": "用C语言编写“有这样的日期吗”，麻烦各位大佬帮我看看哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主的代码可以编译呀。只不过我将第一个输入变量值写固定了；        int y,m,d,i,n=2;     //scanf(\"%d\",&n);     for(i=0;i<n;i++)     {         printf(\"input:y,m,d\\n\");         scanf(\"%d %d %d\",&y,&m,&d);        //.........     }  //以下为运行结果 input:y,m,d 2000 2 29 yes input:y,m,d 2001 2 29 no", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//#include<stdio.h>; #include<stdio.h>  int main() {     int y,m,d,i,n;      scanf(\"%d\",&n);     for(i=0;i<n;i++) {         scanf(\"%d %d %d\",&y,&m,&d);         if(m==2){             if((y%4==0&&y%100!=0)||y%400==0) {                 if(d<=29)                     printf(\"yes\\n\");                 else                     printf(\"no\\n\");             }             else {                 if(d<=28)                     printf(\"yes\");                 else                     printf(\"no\\n\");             }         }         else if(m==1||m==3||m==5||m==7||m==8||m==10||m==12) {             if(d<=31)                 printf(\"yes\\n\");             else                 printf(\"no\\n\");         }         else if(((m==4||m==6||m==9||m==11))&&d<=30)             printf(\"yes\\n\");         else printf(\"no\\n\");     }     return 0; } 供参考～  楼主的问题是？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "第1行后面的分号，没必要；   程序不能编译？还是运行结果有误？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "if((y%4==0&&y%100!=0)||y%400==0)中!=不对吧，这应该是==吧  else if(((m==4||m==6||m==9||m==11))&&d<=30)      printf(\"yes\\n\");       else printf(\"no\\n\");     } 这里有|m==11))&&d<=30)这样的表达吗? else if(m==1||m==3||m==5||m==7||m==8||m==10||m==12){ if(d<=31) printf(\"yes\\n\"); else printf(\"no\\n\"); 你像这处写也许会好点 我也是初学者，说的不一定对啊", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "这是我之前写的一个求某个日期是某年的第几天的代码，里面就有判断日期是否存在，你可以借鉴一下； #include<stdio.h> int b[13]={0,31,28,31,30,31,30,31,31,30,31,30,31}; int f(int x,int y,int z) { \tif(x%4==0||y>2) \t\tif(x%100!=0||x%400==0) \t\t\tz+=1; \t\tfor(;y>1;) \t\t{ \t\t\ty-=1; \t\t\tz+=b[y]; \t\t} \t\treturn z; }; int main() { \tint x,y,z,n=0; \tfor(;n==0;) \t{ \t\tn=1; \t\tprintf(\"请输入你要计算的日期:(例如 2020 11 02)\\n\"); \t\tscanf(\"%d%d%d\",&x,&y,&z); \t\tif(y==2) \t\t{ \t\t\tif((x%4!=0||x%100==0) && (z<1 || z>28) ) \t\t    n=0;} \t\telse \t\t{ \t\t\tif(z<1 || z>b[y]) \t\t\t\tn=0; \t\t} \t\tif(n==0) \t\t\tprintf(\"输入的日期有误。\\n\\n\"); \t} \tprintf(\"%d年%d月%d日是今年的第%d天。\\n\",x,y,z,f(x,y,z));  \treturn 0; }", "referer": "user-0"}]}
{"question": "c语言选择排序的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h> int main(void) {     int j, i, tmp;     int a[5] = { 5,4,7,1,8 };     for (j = 0; j < 4; j++)     {         int min = j;         for (i = j + 1; i < 4; i++)         {             if (a[i] < a[min]) min = i;         }         if(min != j)         {             tmp = a[min];             a[min] = a[j];             a[j] = tmp;         }     }     for (j = 0; j < 4; j++)     {         printf(\"%d \", a[j]);     } }", "referer": "user-0"}]}
{"question": "C语言的题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h> #include <ctype.h> #include <stdlib.h>  #define LEN 10001  int main(void) { \tchar buf[LEN], *p; \t \tfgets(buf, LEN, stdin); \tp = buf; \t \twhile(*p) \t{ \t\tif(isalpha(*p)) printf(\"%c\", 'A'+'z'-*p); \t\telse printf(\"%c\", *p); \t\tp++; \t}      \treturn 0; }", "referer": "user-0"}]}
{"question": "求解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "有没有大佬帮解答一下，刚开始学c。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "程序运行没问题，结果也是对的，但是没有返回值0", "referer": "user-0"}]}
{"question": "求大佬帮忙修改一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "要用数组的话，第9行}后面得写成users[10];这样", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "user 只是定义为结构体变量，程序里user[i]是哪来的?", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "第9行，};user ; 这句，｝和user 之间多了“；”号", "referer": "user-0"}]}
{"question": "c语言问题求解: 过滤数组里三的倍数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 user-1 的回复:void filter(int* a, int* n, bool(*f)(int)) { \tfor (int i = 0; i < *n; ++i) \t{ \t\tif (!f(a[i])) \t\t{ \t\t\tif ((i + 1) >= *n) { break; }  \t\t\tmemmove_s(&a[i], (*n - i) * sizeof(int), &a[i + 1], (*n - i - 1) * sizeof(int));  \t\t\t--i; \t\t\t*n -= 1; \t\t} \t} } 请问如果不用memmove_s用malloc之类的话可以吗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢谢谢谢谢🙏", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "void filter(int* a, int* n, bool(*f)(int)) { \tfor (int i = 0; i < *n; ++i) \t{ \t\tif (!f(a[i])) \t\t{ \t\t\tif ((i + 1) >= *n) { break; }  \t\t\tmemmove_s(&a[i], (*n - i) * sizeof(int), &a[i + 1], (*n - i - 1) * sizeof(int));  \t\t\t--i; \t\t\t*n -= 1; \t\t} \t} }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "太感谢了！我还想问一下这样print出来的话是0 63 42 21，如果想从小到大顺序排列该怎么办呢？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "void filter(int* a, int* n, bool (*f)(int)) { \tfor (int i = 0; i < *n; ++i) \t{ \t\tif (!f(a[i])) \t\t{ \t\t\ta[i] = a[i] ^ a[*n - 1]; \t\t\ta[*n - 1] = a[i] ^ a[*n - 1]; \t\t\ta[i] = a[i] ^ a[*n - 1];  \t\t\t--i; \t\t\t*n -= 1; \t\t} \t} }", "referer": "user-0"}]}
{"question": "求大神教教我", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这种问题，用C语言不方便，还是python好用。 numpy要怎么切片就怎么切片，比较适合这问题。", "referer": "user-0"}]}
{"question": "普通的二维数组，输入与输出不符，求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h>  int main(void) {     int N,M,i,j,k,q,z;     int *a;// 每个区域容纳人数     int **p;// 每个人对每个区域的满意     int s=0,max;//  s是满意度和,max是满意度最大值     scanf(\"%d%d\",&N,&M);//N是区域数 M是人数      a = (int *)malloc(sizeof(int) * N);     if (!a)         return -1;      p = (int **)malloc(sizeof(int *)* M);     if (!p)         return -1;      for (i = 0; i < M; i++) {         p[i] = (int *)malloc(sizeof(int) * N);         if (!p[i])             return -1;     }     for(i=0; i<M; i++)         for(j=0;j<N;j++)             //scanf(\"%d\",(*p+i)+j);             scanf(\"%d\", *(p+i)+j);      for(i=0;i<M;i++)         for(j=0;j<N;j++)             //printf(\"%d \",*((*p+i)+j));             printf(\"%d \",*(*(p+i)+j));     /*     a=(int *)malloc(sizeof(int)*N);     p=(int **)malloc(sizeof(int)*M);     p[0]=(int *)malloc(sizeof(int)*N*M);     for(i=0;i<M;i++)         for(j=0;j<N;j++)             scanf(\"%d\",(*p+i)+j);     for(i=0;i<M;i++)         for(j=0;j<N;j++)             printf(\"%d \",*((*p+i)+j));     */     free(a);     for (i = 0; i < M; i++)         free(p[i]);     free(p);     //free(p[0]);     return 0; } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢谢谢！！！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "仅供参考： #include <stdio.h>   #include <stdlib.h>    int main(void) {     int **p, m, n, i, j;          /* 输入二维数组行与列 */     scanf(\"%d%d\", &m, &n);          /* 开辟二维数组空间 */     p = malloc(sizeof(int *) * m);     for (i = 0; i < m; i++)         p[i] = malloc(sizeof(int) * n);      /* 输入二维数组，初始化 */     for (i = 0; i < m; i++)     {         for (j = 0; j < n; j++)         {             scanf(\"%d\", &p[i][j]);         }     }      /* 打印二维数组 */     for (i = 0; i < m; i++)     {         for (j = 0; j < n; j++)         {             printf(\"%d \", p[i][j]);         }     }     printf(\"\\n\");      /* 释放二维数组空间 */     for (i = 0; i < m; i++)         free(p[i]);     free(p);          return 0; }   运行结果： E:\\Workspace>tcc -run demo.c 3 3 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "p=(int **)malloc(sizeof(int)*M); 这里是不是应该是  p=(int **)malloc(sizeof(int *)*M);", "referer": "user-0"}]}
{"question": "字符串处理相关问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1 的回复:C标准库中有：strncat，头文件：string.h谢谢啊，这个函数不太符合我的要求，因为没办法摘取中间的某个片段，最后还是自己写函数实现的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C标准库中有：strncat，头文件：string.h", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把你的需求再详细一些吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int a, b, c; scanf(\"[%d:%d:%d]\",  &a, &b, &c);", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "这是一个题目的一部分，你运行一下，输完n之后就直接输出了一大堆乱的数字", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "[%d:%d:%d] 注意输入的格式是需要有[]还需要在[]中有:冒号，也要注意冒号的中英文。即scanf中的冒号是中文，输入的内容用的冒号也需要是中文的，反之用是英文就应该输入英文的。  scanf(\"%s\",s); 输入这个是干什么的？下面没有对s使用呢？  引用 3 楼 Aa_1z 的回复:[quote=引用 2 楼 自信男孩的回复:]把你的需求再详细一些吧 #include<stdio.h>  int main() {     int t;     scanf(\"%d\",&t);     for(int i=0; i<t; i++)     {         int n;char s[100];         scanf(\"%s\",s);         scanf(\"%d\",&n);         for(int p=0; p<n; p++)         {             int a,b,c;             scanf(\"[%d:%d:%d]\",&a,&b,&c);             printf(\"%d %d %d\",a,b,c);         }     }     return 0; } 这样就不行，输出的a,b,c不对[/quote]", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:把你的需求再详细一些吧 #include<stdio.h>  int main() {     int t;     scanf(\"%d\",&t);     for(int i=0; i<t; i++)     {         int n;char s[100];         scanf(\"%s\",s);         scanf(\"%d\",&n);         for(int p=0; p<n; p++)         {             int a,b,c;             scanf(\"[%d:%d:%d]\",&a,&b,&c);             printf(\"%d %d %d\",a,b,c);         }     }     return 0; } 这样就不行，输出的a,b,c不对", "referer": "user-0"}]}
{"question": "文件流写字符进去txt文件，只有一个字符但是读出来有4095个？为什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "就像楼上朋友说的，写文件就用“w”读文件就用“r”，这样应该就没问题了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "fputc 是把内容写入缓存区，并不是一定写入文件，fseek后才会真正写入文件。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "其实，楼主只要把代码中的fputc('z', fp)，改成：fputs(\"z\", fp)，再调用fseek(stream, 0, SEEK_SET); 指针复位，count就是1了。 C标准库实现，捉摸不透。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "FILE* fp = NULL;     fp = fopen(\"d:\\\\aaa.txt\", \"w+\");     int a = 0;     int count = 0;     fputc('z', fp);     fclose(fp);     fp = fopen(\"d:\\\\aaa.txt\", \"r+\");     while ((a = fgetc(fp)) != EOF)         count++;     fclose(fp);     printf(\"%d\", count);这样就变成1了", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "应该是4k个。你写要给字符'z'，当前指针后移了一位。后面给你填充了4k-1个空占位字符。 如果在用while循环前面调用：fseek(stream, 0, SEEK_SET); 指针复位，count就是4k了。  感觉这就是c标准库无比恶心的地方。还是直接用open read write好，简单，直接，粗暴。。。", "referer": "user-0"}]}
{"question": "C语言竞赛题怎么解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void out(const char *const strs, char *out)  {     逐个字符遍历strs         如果当前字符是元音字符             保存到out数组     遍历结束      输出 }  自己写", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 user-2的回复:这也没难度，自己写多好？太懒了吧。 不是懒，我是没学过这里的内容……", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "show一个吧，仅供参考： #include <stdio.h> #include <string.h>  int yes_or_no(int c) { \tint result = 0;\t \tif(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') result = 1;\t \telse if(c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U') result = 1; \treturn result; }  int main(void) { \tchar buf[1001]; \tchar *p; \t \twhile(fgets(buf, sizeof(buf), stdin)) \t{ \t\tif(strcmp(buf, \"end\\n\") == 0 || strcmp(buf, \"end\\r\\n\") == 0) break; \t\t \t\tp = buf; \t\twhile(*p != '\\0') \t\t{ \t\t\tif(yes_or_no(*p) == 1) printf(\"%c\", *p); \t\t\tp++; \t\t} \t\tprintf(\"\\n\"); \t} \t \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "这也没难度，自己写多好？太懒了吧。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "没有人吗？？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 7 楼 m0_46868677 的回复:老哥谢谢你，请问一下那个while（fgets）里面那句的stdin是啥意思，还有里面的sizeof的作用是啥  stdin： 文件指针，表示标准输入。 sizeof：计算字符数组buf的大小。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 4 楼 user-2的回复:show一个吧，仅供参考： #include <stdio.h> #include <string.h>  int yes_or_no(int c) { \tint result = 0;\t \tif(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') result = 1;\t \telse if(c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U') result = 1; \treturn result; }  int main(void) { \tchar buf[1001]; \tchar *p; \t \twhile(fgets(buf, sizeof(buf), stdin)) \t{ \t\tif(strcmp(buf, \"end\\n\") == 0 || strcmp(buf, \"end\\r\\n\") == 0) break; \t\t \t\tp = buf; \t\twhile(*p != '\\0') \t\t{ \t\t\tif(yes_or_no(*p) == 1) printf(\"%c\", *p); \t\t\tp++; \t\t} \t\tprintf(\"\\n\"); \t} \t \treturn 0; } 老哥谢谢你，请问一下那个while（fgets）里面那句的stdin是啥意思，还有里面的sizeof的作用是啥", "referer": "user-0"}]}
{"question": "C语言数组问题：取两段整数的交集并排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请问一下最后正确的代码是什么样子的", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "仅供参考，还需要补充去重复数据功能。。 #include<stdio.h> int main() {     int a[100], b[100], c[100];     int i, j, t, n, o, len = 0;          scanf(\"%d\", &n);     for (i = 0; i < n; i++)     {         scanf(\"%d\", &a[i]);     }      scanf(\"%d\", &t);     for (i = 0; i < t; i++)     {         scanf(\"%d\", &b[i]);     }          for (i = 0; i < n; i++) {         for (j = 0; j < t; j++)             if (a[i] == b[j]) { c[len++] = a[i]; break; }             else continue;     }     for (i = 0; i < len - 1; i++) {         for (j = 0; j < len - 1 - i; j++)         {             if (c[j] < c[j + 1])             {                 t = c[j];                 c[j] = c[j + 1];                 c[j + 1] = t;             }         }     }          /* 去除重复数据，需要在此处补上 */          if (len == 0) {         printf(\"No Answer\");     }     else for (i = 0; i < len; i++)     {         printf(\"%d \", c[i]);     }      return 0; }", "referer": "user-0"}]}
{"question": "救救孩子吧！！  .exe' has exited with code 0 (0x0).   不知道哪块出了错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "不是这个错误，是有空地址，但不知道在哪", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主的程序没有输出呢，调用POP的地方呢？ 程序属于正常退出了吧", "referer": "user-0"}]}
{"question": "用c语言解题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 Milo Tuan 的回复:有个地方我还是不太理解，为什么那里是(result == 63)呀？ 位运算，结果是63，即0x3F。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:仅供参考： #include <stdio.h>  int main(void) { \tint num, result, foot1, foot2; \t \tfor(num = 50; num < 250; num++) \t{ \t\tfoot1 = 2*num; \t\tfoot2 = 4*num; \t\t \t\tresult = 0; \t\tresult |= (1 << (foot1 % 10)); \t\tresult |= (1 << (foot1 % 100 / 10)); \t\tresult |= (1 << (foot1 / 100)); \t\t \t\tresult |= (1 << (foot2 % 10)); \t\tresult |= (1 << (foot2 % 100 / 10)); \t\tresult |= (1 << (foot2 / 100));\t\t \t\t \t\tif(result == 63) \t\t{ \t\t\tprintf(\"鸡数:\\t%d脚数:\\t%d\\n\", num, 2*num); \t\t\tprintf(\"兔数:\\t%d脚数:\\t%d\\n\", num, 4*num); \t\t} \t} \t \treturn 0; }  运行结果： E:\\Workspace>tcc -run demo.c 鸡数:   76脚数: 152 兔数:   76脚数: 304 有个地方我还是不太理解，为什么那里是(result == 63)呀？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:仅供参考： #include <stdio.h>  int main(void) { \tint num, result, foot1, foot2; \t \tfor(num = 50; num < 250; num++) \t{ \t\tfoot1 = 2*num; \t\tfoot2 = 4*num; \t\t \t\tresult = 0; \t\tresult |= (1 << (foot1 % 10)); \t\tresult |= (1 << (foot1 % 100 / 10)); \t\tresult |= (1 << (foot1 / 100)); \t\t \t\tresult |= (1 << (foot2 % 10)); \t\tresult |= (1 << (foot2 % 100 / 10)); \t\tresult |= (1 << (foot2 / 100));\t\t \t\t \t\tif(result == 63) \t\t{ \t\t\tprintf(\"鸡数:\\t%d脚数:\\t%d\\n\", num, 2*num); \t\t\tprintf(\"兔数:\\t%d脚数:\\t%d\\n\", num, 4*num); \t\t} \t} \t \treturn 0; }  运行结果： E:\\Workspace>tcc -run demo.c 鸡数:   76脚数: 152 兔数:   76脚数: 304 啊谢谢谢谢谢谢！", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "仅供参考： #include <stdio.h>  int main(void) { \tint num, result, foot1, foot2; \t \tfor(num = 50; num < 250; num++) \t{ \t\tfoot1 = 2*num; \t\tfoot2 = 4*num; \t\t \t\tresult = 0; \t\tresult |= (1 << (foot1 % 10)); \t\tresult |= (1 << (foot1 % 100 / 10)); \t\tresult |= (1 << (foot1 / 100)); \t\t \t\tresult |= (1 << (foot2 % 10)); \t\tresult |= (1 << (foot2 % 100 / 10)); \t\tresult |= (1 << (foot2 / 100));\t\t \t\t \t\tif(result == 63) \t\t{ \t\t\tprintf(\"鸡数:\\t%d脚数:\\t%d\\n\", num, 2*num); \t\t\tprintf(\"兔数:\\t%d脚数:\\t%d\\n\", num, 4*num); \t\t} \t} \t \treturn 0; }  运行结果： E:\\Workspace>tcc -run demo.c 鸡数:   76脚数: 152 兔数:   76脚数: 304", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "建议从网上搜一下吧，这样的题目很普遍了，遇到的人也很多。", "referer": "user-0"}]}
{"question": "求大佬这个怎么写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢啦不过我是刚入门，这些似乎还没学", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "int find_substr_first_pos(const char *str, const char *substr) {     const char *pstr = str;     int i = 0, pos = -1;      while (pstr[i]) {         if (strncmp(pstr+i, substr, strlen(substr)) == 0) {             pos = i;             break;         }     }      return pos; } 供参考～  没有测试，建议楼主调用一下并测试一下吧", "referer": "user-0"}]}
{"question": "刚开始学C语言，努力学习中", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "ok了大哥，我知道是哪里的问题了  多谢你了帮我找出了那么大的错误！！！谢谢！！！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "#include<stdio.h> #include<math.h> int main() {     double eps,S=0;     int a=1,j;     scanf(\"%lf\",&eps);     for(j=1;;j+=3)     {         S+=a*1.0/j;         a=(-1)*a;         if(1/j<=eps) break;     }     printf(\"sum = %.6f\",S);     return 0; } (那大哥我后面改成这样了，pta上显示依旧有很大的错误，你能帮我找找吗，我找了很久了）再次感谢大哥的回答", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "S没有初始化，另外，S也不应该是double类型，S%2取余操作针对浮点数有这样的运算吗？我听说过整型数有取余操作", "referer": "user-0"}]}
{"question": "小白求助（关于自定义函数）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "#include <stdio.h> int i, n = 0, a[5]; int min(int a[5], int n, int i) {     for (int j = i + 1; j < 5; j++)         if (a[i] > a[j])         {             int min = a[i];             a[i] = a[j];             a[j] = min;         }         return a[5]; } int sort(int a[5], int i) {     int min(int a[5], int, int);     for (i = n; i < 5; i++)     {         return min(a, n, i);     } } int main() {     printf(\"enter 5 integers:\");     scanf(\"%d %d %d %d %d\", &a[0], &a[1], &a[2], &a[3], &a[4]);     printf(\"sorted numbers are:\");     for (i = 0; i < 5; i++)     {         printf(\"%d \", sort(a, i));     }     printf(\"\\n\");     return 0; } 以上是原代码 感觉挺多地方有错。。。然后n是用来控制排序函数的开始值的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 啊6吧 的回复:[quote=引用 1 楼 自信男孩的回复:]sort函数调用的时候传参有问题，min函数也是一样的；  另外，sort函数里的处理越界了。  建议楼主把代码贴出来～ 图片里的就是源代码呀[/quote] 那你的问题就是这样导致的呀，只看我最后一句，没看前面的内容吗？我的意思，你直接提出代码还能帮你在代码上修改一下，不贴代码，只发照片，给你改不了代码。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "1、C++有个min的宏定义，函数不能命名min 2、min函数没有返回值 3、sort函数最后没有返回值 ('sort': not all control paths return a value) 4、sort函数调用min函数，第一个参数传错了。return min(a, n, i); 5、main函数中调用sort函数，第一个参数传错了。sort(a, i); 6、没看懂n有啥用", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:sort函数调用的时候传参有问题，min函数也是一样的；  另外，sort函数里的处理越界了。  建议楼主把代码贴出来～ 图片里的就是源代码呀", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "sort函数调用的时候传参有问题，min函数也是一样的；  另外，sort函数里的处理越界了。  建议楼主把代码贴出来～", "referer": "user-0"}]}
{"question": "这个关于矩阵的程序怎么写？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void MatrixAdd(int* a, int* b, int* r, int len) { \tfor (int i = 0; i < len; ++i) \t{ \t\tr[i] = a[i] + b[i]; \t} }  void MatrixSub(int* a, int* b, int* r, int len) { \tfor (int i = 0; i < len; ++i) \t{ \t\tr[i] = a[i] - b[i]; \t} }  void MatrixDisplay(int* m, int row, int col) { \tfor (int i = 0; i < row; ++i) \t{ \t\tfor (int j = 0; j < col; ++j) \t\t{ \t\t\tprintf(\"%d\\t\", m[i * col + j]); \t\t}  \t\tprintf(\"\\r\\n\"); \t}  \tprintf(\"\\r\\n\"); }  void MatrixTest(void) { \tsrand(GetTickCount());  \tint row = 0; \tint col = 0;  \tprintf(\"键盘输入矩阵行数、列数(m n格式)：\\r\\n\"); \tscanf_s(\"%d %d\", &row, &col);  \tint len = row * col;  \tint* a = new int[len]; \tint* b = new int[len]; \tfor (int i = 0; i < len; ++i) \t{ \t\ta[i] = rand() % 100; \t\tb[i] = rand() % 100; \t}  \tprintf(\"矩阵a=\\r\\n\"); \tMatrixDisplay(a, row, col);  \tprintf(\"矩阵b=\\r\\n\"); \tMatrixDisplay(b, row, col);  \tint* r = new int[len];  \tprintf(\"矩阵a+b=\\r\\n\"); \tMatrixAdd(a, b, r, len); \tMatrixDisplay(r, row, col);  \tprintf(\"矩阵a-b=\\r\\n\"); \tMatrixSub(a, b, r, len); \tMatrixDisplay(r, row, col);  \tdelete[] a; \tdelete[] b; \tdelete[] r; }", "referer": "user-0"}]}
{"question": "用函数调用的方式，求1个一维浮点型数组的最大值，最小值，和（提示：定义三个函数，每个函数都必须有返回参数）。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考：#include <iostream.h> #define N 10 double arrayMax(double *arr, int n) {     int i;     double tmp;     tmp = arr[0];     for(i=0;i<n;i++)     {         if (tmp<arr[i])             tmp = arr[i];     }     return tmp; }  double arrayMin(double *arr, int n) {     int i;     double tmp;     tmp = arr[0];     for(i=0;i<n;i++)     {         if (tmp>arr[i])             tmp = arr[i];     }     return tmp; } double arraySum(double *arr,int n) {     int i;     double sum=0;     for(i=0;i<n;i++)     {        sum += arr[i];     }     return sum; }  int main() {    double array[N];    int i;     for ( i = 0 ; i < N ; i ++ )     {      if ( i % 2 )  array[ i ] = i * i ;       else array[ i ] = 100 - ( i / 2 ) * ( i / 2 ) ;     }    for ( i = 0 ; i < N ; i ++ )        cout << array[ i ]<<\"\\t\" ;        cout << endl ;    cout<<\"Max in Array is \"<< arrayMax(array,N)<<endl;   cout<<\"Min in Array is \"<< arrayMin(array,N)<<endl;   cout<<\"Sum of Array is \"<< arraySum(array,N)<<endl;   system(\"pause\");   return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "最大值： double arrayMax(double *arr, int n) {     int i;     double tmp;     tmp = arr[0]     for(i=0,i<n;=++)     {         if (tmp<arr[i])             tmp = arr[i];     }     return tmp; }   double arrayMin(double *arr, int n); double arraySum(double *arr,int n);", "referer": "user-0"}]}
{"question": "求大佬帮助，人工智能题（希望用c或者MATLAB编写）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "采用牛顿迭代法，仅供参考： #include <math.h> #include <stdio.h>  int main(void) { \t/* 牛顿迭代法求解方案 */ \tint count = 0; \tdouble x, x1 = 0.1, x2; \t \t/* f1:一阶导数 f2:二阶导数 */ \tdouble f1, f2; \t \twhile(1) \t{ \t\tf1 = (x1-1)*(exp(x1)/pow(x1,2) - 1.0/exp(x1)); \t\tf2 = (pow(x1,3)*exp(x1) + 2)/pow(x1,3) - (2-x1)/exp(x1); \t\tx2 = x1 - f1/f2; \t\tif(fabs(x2 - x1) < 0.000001) break; \t\t \t\tprintf(\"%d\\tx1:%lf\\tx2:%lf\\tf1:%lf\\tf2:%lf\\n\", ++count, x1, x2, f1, f2); \t\tx1 = x2; \t} \tx = (x1 + x2)/2; \tprintf(\"x:\\t%lf\\nmin:\\t%lf\\n\", x, exp(x)/x + x/exp(x)); \t \treturn 0; }   运行结果： E:\\Workspace>tcc -run demo.c 1       x1:0.100000     x2:0.132903     f1:-98.651029   f2:2998.280809 2       x1:0.132903     x2:0.176237     f1:-55.309482   f2:1276.337719 3       x1:0.176237     x2:0.232854     f1:-30.942794   f2:546.532813 4       x1:0.232854     x2:0.305883     f1:-17.250485   f2:236.214183 5       x1:0.305883     x2:0.398202     f1:-9.561980    f2:103.575430 6       x1:0.398202     x2:0.511206     f1:-5.247612    f2:46.437333 7       x1:0.511206     x2:0.642233     f1:-2.825354    f2:21.563150 8       x1:0.642233     x2:0.779870     f1:-1.460443    f2:10.610806 9       x1:0.779870     x2:0.899293     f1:-0.688534    f2:5.765524 10      x1:0.899293     x2:0.971386     f1:-0.265094    f2:3.677113 11      x1:0.971386     x2:0.995409     f1:-0.069275    f2:2.883612 12      x1:0.995409     x2:0.999469     f1:-0.010840    f2:2.670432 13      x1:0.999469     x2:0.999943     f1:-0.001250    f2:2.636518 14      x1:0.999943     x2:0.999994     f1:-0.000135    f2:2.632595 15      x1:0.999994     x2:0.999999     f1:-0.000014    f2:2.632171 x:      1.000000 min:    3.086161", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "“精度达到小数点后6位”，这个应该是f(x)的吧？上面是对x的，可能理解有误。 修正一下代码： #include <math.h> #include <stdio.h>  int main(void) { \t/* 牛顿迭代法求解方案 */ \tint count = 0; \tdouble x, x1, x2; \t \t/* f01 f02:原函数 f1:一阶导数 f2:二阶导数 */ \tdouble f01, f02, f1, f2; \tx1 = 0.1; \tf01 = exp(x1)/x1 + x1/exp(x1); \t \twhile(1) \t{ \t\tf1 = (x1-1)*(exp(x1)/pow(x1,2) - 1.0/exp(x1)); \t\tf2 = (pow(x1,3)*exp(x1) + 2)/pow(x1,3) - (2-x1)/exp(x1); \t\tx2 = x1 - f1/f2; \t\tf02 = exp(x2)/x2 + x2/exp(x2); \t\tprintf(\"%d\\tx1:%lf\\tx2:%lf\\tf1:%lf\\tf2:%lf\\n\", ++count, x1, x2, f1, f2); \t\tif(fabs(f02 - f01) < 0.000001) break; \t\tx1 = x2; \t\tf01 = f02; \t} \tx = (x1 + x2)/2; \tprintf(\"x:\\t%lf\\nmin:\\t%lf\\n\", x, exp(x)/x + x/exp(x)); \t \treturn 0; }   运行结果：E:\\Workspace>tcc -run demo.c 1       x1:0.100000     x2:0.132903     f1:-98.651029   f2:2998.280809 2       x1:0.132903     x2:0.176237     f1:-55.309482   f2:1276.337719 3       x1:0.176237     x2:0.232854     f1:-30.942794   f2:546.532813 4       x1:0.232854     x2:0.305883     f1:-17.250485   f2:236.214183 5       x1:0.305883     x2:0.398202     f1:-9.561980    f2:103.575430 6       x1:0.398202     x2:0.511206     f1:-5.247612    f2:46.437333 7       x1:0.511206     x2:0.642233     f1:-2.825354    f2:21.563150 8       x1:0.642233     x2:0.779870     f1:-1.460443    f2:10.610806 9       x1:0.779870     x2:0.899293     f1:-0.688534    f2:5.765524 10      x1:0.899293     x2:0.971386     f1:-0.265094    f2:3.677113 11      x1:0.971386     x2:0.995409     f1:-0.069275    f2:2.883612 12      x1:0.995409     x2:0.999469     f1:-0.010840    f2:2.670432 13      x1:0.999469     x2:0.999943     f1:-0.001250    f2:2.636518 x:      0.999706 min:    3.086161", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢大佬！我参考参考", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 8 楼 ctrigger的回复:[quote=引用 6 楼 user-2 的回复:] f(x)的最小值为3.086266  貌似精度不够。 当x=1时，f(1) = 3.0861612696304875569558112415141[/quote] 按照他的要求输出6位", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 6 楼 user-2 的回复: f(x)的最小值为3.086266  貌似精度不够。 当x=1时，f(1) = 3.0861612696304875569558112415141", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "%% 用遗传算法求函数f(x)=exp(x)/x+x/exp(x)在区间[0,5]上的最小值，要求精度达到小数点后6位 clc; clear; close all; tic; %%遗传参数设置 NUMPOP=100;%初始种群大小 % irange_l=-1; %问题解区间 % irange_r=2; irange_l=0; %问题解区间 irange_r=5; LENGTH=22; %二进制编码长度 ITERATION = 10000;%迭代次数 CROSSOVERRATE = 0.7;%杂交率 SELECTRATE = 0.5;%选择率 VARIATIONRATE = 0.001;%变异率  %初始化种群 pop=m_InitPop(NUMPOP,irange_l,irange_r); pop_save=pop; %绘制初始种群分布 x=linspace(0,5,1000); y=m_Fx(x); plot(x,y); hold on for i=1:size(pop,2)     plot(pop(i),m_Fx(pop(i)),'ro'); end hold off title('初始种群');  %开始迭代 for time=1:ITERATION     %计算初始种群的适应度     fitness=m_Fitness(pop);     %选择     pop=m_Select(fitness,pop,SELECTRATE);     %编码     binpop=m_Coding(pop,LENGTH,irange_l);     %交叉     kidsPop = crossover(binpop,NUMPOP,CROSSOVERRATE);     %变异     kidsPop = Variation(kidsPop,VARIATIONRATE);     %解码     kidsPop=m_Incoding(kidsPop,irange_l);     %更新种群     pop=[pop kidsPop]; end figure x=linspace(0,5,1000); y=m_Fx(x); plot(x,y); hold on for i=1:size(pop,2)     plot(pop(i),m_Fx(pop(i)),'ro'); end hold off title('终止种群'); fprintf('%.6f\\n',max(m_Fx(pop))); toc;", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "f(x)的最小值为3.086266", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "明天我写好MATLAB程序给你", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "Google的深度学习库：TensorFlow", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "人工智能题，就用人工智能方法，梯度下降法。 比如Google无比时髦的深度学习开源库，就有自动求导功能，用梯度下降法即可。", "referer": "user-0"}]}
{"question": "大佬们能不能帮我康康我的代码哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "而且，输入 3 0 0 0时，输出结果应该为 3: 0 但是代码的结果却是 0: 0 1 2 3 4 5 6 7 8 9 因为没有进入while(x>0)，所以a[0]没有被累加", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "n输入0的时候，结果会输出 0: 0 1 2 3 4 5 6 7 8 9 这个结果符合不符合题目要求，如果不符合，要去掉这个结果（程序加个判断n大于0才继续做处理）", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "修改如下，供参考：#include<stdio.h> int main(int argc, char* argv[]) {       int n,i,x,max=0;       int a[10]={0};         scanf(\"%d\",&n);        if(n==0) return 1;//如果n=0就退出         for(i=0;i<n;i++)         {           scanf(\"%d\",&x);           if(x==0)   //这里加入对‘0’的计数            {              a[0]++;            }           else            {              while(x!=0)//这里判断条件改成'x!=0'              {                a[x%10]++;                x /= 10;              }            }         }        for(i=0;i<10;i++)           if(a[i]>max)                max=a[i];        printf(\"%d:\",max);         for(i=0;i<10;i++)           if(max==a[i])               printf(\" %d\",i);        printf(\"\\n\");       return 0; }", "referer": "user-0"}]}
{"question": "请帮忙翻译下面代码，谢谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "前面6行给数组赋值，初始化数组。 最后一行调用函数，最后一个参数传数组地址。 貌似这个函数调用只传了数组首地址，没传数组大小啊。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "确实是没头没尾的代码， filter过滤器 signal信号 mem内存(应该是内存缓冲区)", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "\"//\"后面的内容是注释语句", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "这没头没尾的代码，仅看代码是 给sos数组第1到第6个元素进行了赋值，然后调用了一个函数，其中sos数组地址作为最后一个参数", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "顶一下，来个人回复下", "referer": "user-0"}]}
{"question": "请问这个输入行数n，输出n行杨辉三角错在哪了？求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf（“%d”，&n）这句未尾缺“；”号 printf (“杨辉三角\\n”）；这句缺\\n  if (n <=0)printf (“数据录入不正确”）；应该移到while ()语句前。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "错误： 1. scanf后面没； 2. return 0; 语句缩进不对", "referer": "user-0"}]}
{"question": "qtwebengine ninja: build stopped: subcommand failed.", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我在银河麒麟系统arm64下编译qt5.51.0也遇到ninja: build stopped: subcommand failed.该咋解决呢？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "解决没？", "referer": "user-1"}, {"cid": "3", "user": "user-0", "content": "没什么好办法，把整个系统的qt上提了一个版本，重新编译就好了", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "没用啊", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "什么叫提上了一个版本？", "referer": "user-2"}]}
{"question": "使用C语言用函数调用的方式，求1个一维浮点型数组的最大值，最小值，和（提示：定义三个函数，每个函数都必须有返回参数）。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h>  void func(double *a, int n, double *max, double *min, double *sum) { \tint i; \t*max = *min = *sum = a[0]; \tfor(i=1; i<n; i++) \t{ \t\tif(*max < a[i]) *max = a[i]; \t\tif(*min > a[i]) *min = a[i]; \t\t*sum = *sum + a[i]; \t} }  int main(void) { \tdouble a[10] = {0.1,1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.0}; \tdouble max, min, sum; \tfunc(a, 10, &max, &min, &sum); \tprintf(\"MAX:\\t%.2lf\\nMIN:\\t%.2lf\\nSUM:\\t%.2lf\\n\", max, min, sum); \t \treturn 0; }", "referer": "user-0"}]}
{"question": "调用函数出现问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "想了半天没想到是这里出错了。。谢谢大家", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "原因楼上已经说了； for(i=1;score[i-1]>=0;i++) 改一下 for(i=1;i < n && score[i]>=0;i++) 防止越界～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "for(i =1;i <=n-1;n ++)这句把n ++了，i 始终是1，死循环里出不来了。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "LIST函数中的循环：for (i = 1; i <= n - 1; n++) n++ ==> i++", "referer": "user-0"}]}
{"question": "求教用c语言解析HTTP报文（请求报文，响应报文）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请教，你后来是怎么处理的啊？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "看博客效果不一定好，最权威的就是RFC。 HTTP 1.1 RFC 2616 再结合抓包工具，如fiddler。有耐心，慢慢折腾即可。。", "referer": "user-0"}]}
{"question": "windows 下 串口当作文件来操作时，fread()读不到内容", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "cnt = fread(buff,1,sizeof(buff),fp);             if (cnt)             {                 printf(\"data:%s\\n\",buff);             } 用read()可以,fread()不行。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "应换read", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "printf(\"data:\\t\\n\",buff2); 你看看你这写的是个啥？", "referer": "user-0"}]}
{"question": "求指导，数据分析", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "已删除的字数 ---------------- X 100% == ？？？  删除前总字数  接下来逐个文件扫描，处理即可。", "referer": "user-0"}]}
{"question": "如何用c语言统计一个文件夹中所有的txt文件的字数总和", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "glob的作用是获取txt文件的名字; 正则表达式用于求取字数;", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "情况很复杂，文件夹中可能还包括文件夹，可能有多层文件夹，需要递归处理。perl/python中用glob处理，如果必须用C语言，你需要实现glob和正则表达式功能。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "开始 - opendir - readdir - (.txt文件，处理，非.txt，跳过，目录，递归。）- 结束", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "目录的打开，readdir和文件的打开读取关闭等等操作，建议楼主找一下这些系统调用函数～", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "文本都是英文，题目如下 老师给出了一部分c代码，我们对文件夹中的txt进行了停用词删除，现在就想知道如何计算出文件夹中112个txt文件由于停用词的删除，文件中字数的百分比减少是多少？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 5 楼 真相重于对错 的回复:这个问题有个难点，就是字符的判断，如果都是英文，或者都是中文，好处理，如果中英文混编，需要根据txt编码处理 对，就是这样的，需要判断编码。  比如中文：UTF-8，3个字节。GBK，2个字节。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "这个问题有个难点，就是字符的判断，如果都是英文，或者都是中文，好处理，如果中英文混编，需要根据txt编码处理", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "引用 3 楼 proorck2019 的回复:glob的作用是获取txt文件的名字; 正则表达式用于求取字数; 杀鸡焉用牛刀", "referer": "user-0"}]}
{"question": "C语言：关于getche被跳过的疑问，请大佬教教我吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "是的是的，谢谢各位，我刚才改好了，也通过了，这真是好弱智的问题 麻烦各位大佬啦", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "ch[i-1][0]!='\\0' 这个判断，当i为0时，i-1已经是-1，已经是越界了。越界访问结果是未定义的，楼主的ch[-1][0]可能正好是0，所以输入的循环没有执行～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "1、for(i=0;ch[i-1][0]!='\\0';i++) 数组越界  ch[i-1][0] => ch[-1][0] 2、ch[i][j - 1] = ch[i][j] = 0; 此处也会越界 变量 j 有可能等于0 3、ch[i][j - 1] = ch[i][j] = 0; 最后一个字符被清掉 4、运行结果不对  123 +2  24请按任意键继续. . .", "referer": "user-0"}]}
{"question": "竞赛题怎么解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 qzjhjxj的回复:供参考：#include <math.h> #include <stdio.h> #define N 50 #define M 2  int main(int argc, char* argv[]) {    int i,j,h,n;    float max=0;     float score[N][M]={0},a_space[N]={0};     printf(\"请输入运动员人数：\");     while(1)    {      scanf(\"%d\",&n);      if(n==0) break;       for(i=0;i<n;i++)         for(j=0;j<M;j++)           scanf(\"%f\",&score[i][j]);       for(i=0;i<n;i++)        {          for(j=0;j<M;j++)             a_space[i] += score[i][j]*score[i][j];          a_space[i] = sqrt(a_space[i]);        }       max=a_space[0];      for(i=0;i<n;i++)        {            if(max<a_space[i])            {              max=a_space[i];              h  = i+1 ;            }        }      printf(\"冠军是 NO.%d 号，成绩=%f\\n\",h,max);    }    return 0; } 我自己写出来了，不过还是很感谢你", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-3的回复:擦，写错了，应该是max清零   while(1) {     max = 0;     scanf(\"%d\", &n);     // 之后的代码与你相同 }  老哥，我刚发布的时候就解决了，max直接在循环里面定义就好了不过还是谢谢哈", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "依题意，这句该定义：#define N 100", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "供参考：#include <math.h> #include <stdio.h> #define N 50 #define M 2  int main(int argc, char* argv[]) {    int i,j,h,n;    float max=0;     float score[N][M]={0},a_space[N]={0};     printf(\"请输入运动员人数：\");     while(1)    {      scanf(\"%d\",&n);      if(n==0) break;       for(i=0;i<n;i++)         for(j=0;j<M;j++)           scanf(\"%f\",&score[i][j]);       for(i=0;i<n;i++)        {          for(j=0;j<M;j++)             a_space[i] += score[i][j]*score[i][j];          a_space[i] = sqrt(a_space[i]);        }       max=a_space[0];      for(i=0;i<n;i++)        {            if(max<a_space[i])            {              max=a_space[i];              h  = i+1 ;            }        }      printf(\"冠军是 NO.%d 号，成绩=%f\\n\",h,max);    }    return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "在for循环前或循环后对max清零操作都是没问题的。如果不清零，那么上次计算得到的max可能会影响到下一组的结果～", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "擦，写错了，应该是max清零   while(1) {     max = 0;     scanf(\"%d\", &n);     // 之后的代码与你相同 }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "每次输入之前，需要把sum清零，  while(1) {     sum = 0;     scanf(\"%d\", &n);     // 之后的代码与你相同 }", "referer": "user-0"}]}
{"question": "C语言上手就废( •̥́ ˍ •̀ू )嘤嘤嘤~", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "visual studio IDE： #include <stdio.h> #include <stdlib.h>  int main() { \tchar rs2[1024], rs8[1024], rs16[1024]; \tint data; \tscanf_s(\"%d\", &data);  \tif (data < 0 || data > 255) \t{ \t\tprintf(\"输入有误\\n\"); \t\treturn 1; \t}  \t_itoa_s(data, rs2, 2); \t_itoa_s(data, rs8, 8); \t_itoa_s(data, rs16, 16);  \tprintf(\"二进制：%s\\n八进制：%s\\n十六进：%s\\n\", rs2, rs8, rs16);  \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "仅供参考： #include <stdio.h> #include <stdlib.h>  int main(void) { \tchar rs2[1024], rs8[1024], rs16[1024]; \tint data, d; \tscanf(\"%d\", &data); \t \tif(data < 0 || data > 255) \t{ \t\tprintf(\"输入有误\\n\"); \t\treturn 1; \t} \t \titoa(data, rs2, 2); \titoa(data, rs8, 8); \titoa(data, rs16, 16); \t \tprintf(\"二进制：%s\\n八进制：%s\\n十六进：%s\\n\", rs2, rs8, rs16);  \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "strtol函数，用这个试试～", "referer": "user-0"}]}
{"question": "三维数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第二种形式从未见过，可能是python中有类似写法。C语言是一门古老的语言，应该并不支持新的写法。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "a[2][3][4]：这个是C标准语法。 a[2,3,4]：   这个在C语言中没见过。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "《C++Primer第5版中文版》中提到： 当一个数组的元素仍是数组时，通常使用两个维度来定义它：一个维度表示数组本身大小，另外一个维度表示其元素（也是数组）的大小。 所以， float a[2][3][4]; 表示数组a中有2个元素，每个元素的大小是[3][4]", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "c/c++里应该没有float a[2,3,4]这样的", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "第二种错误", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "标准语法应该只支持float a[2][3][4]吧 扩展语法就看编译器支持不支持了", "referer": "user-0"}, {"cid": "7", "user": "user-7", "content": "不是Python，是Pascal，Pascal中a[2][3][4]、a[2][3,4]、a[2,3][4]、a[2,3,4]等价", "referer": "user-0"}]}
{"question": "小白求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这种测试程序会把代码运行多次，每次输入不同的值，并判断输出是否正确。对于某些测试用例，你的代码不能通过。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "int mask[256]{ 0 }; int main() { \tchar src[10000], patten[10000], dest[10000]; \tgets_s(src); \tgets_s(patten); \tint k = 0; \tfor (int i = 0; i < strlen(patten); i++) \t{ \t\tmask[patten[i]]++; \t} \tfor (int j  = 0; j < strlen(src); j++) \t{ \t\tif (mask[src[j]] == 0) \t\t{ \t\t\tdest[k] = src[j]; \t\t\tk++; \t\t} \t} \tdest[k] = '\\0'; \tprintf(\"%s\", dest); }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "楼主，第一种方法在for（）循环中的判断条件有问题：引用for(i=0;i!='\\n';i++){ temp=1; for(j=0;j!='\\n';j++){ 按第一种方法修改如下,供参考：#include <stdio.h> #define N 10001  int main(int argc, char* argv[]) {     int i,j,temp;     char a[N],b[N];      gets(a);     gets(b);     for(i=0;a[i]!='\\0';i++)       {         temp=1;         for(j=0;b[j]!='\\0';j++)           {             if(a[i]==b[j])              {                temp=0;                break;              }           }         if(temp==1)         {           printf(\"%c\",a[i]);         }      }     printf(\"\\n\");     system(\"pause\");     return 0; }", "referer": "user-0"}]}
{"question": "求大佬看看这一题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "01 02    \t10        \t20        这四个位置的数相加，完事了", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修正一下： #include <stdio.h>  int main() { \tint a[4][4] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; \tint sum = 0; \tint i, j; \t \tfor(i=0; i<3; i++) \t{ \t\tfor(j=0; j<3; j++) \t\t{ \t\t\tif(i != j && i+j != 3) \t\t\t{ \t\t\t\tsum = sum + a[i][j]; \t\t\t} \t\t} \t} \t \tprintf(\"%d\\n\", sum);  \treturn 0; }", "referer": "user-0"}]}
{"question": "求大佬看看这一题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谁能帮忙看看这个题  5、对于字符串“abcdefghijklmn”，读入两个数字，比如begin、num，假定begin为1，num为5，则动态申请内存，存放子串“bcdef”，最后输出该子串。简化起见，假定begin、num都在有效范围内。设计main函数, 同时要展示出字符串和动态内存的地址。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "01 02    \t10        \t20        这四个位置的数相加，完事了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "上面错了，修正一下： #include <stdio.h>  int main() { \tint a[4][4] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; \tint sum = 0; \tint i, j; \t \tfor(i=0; i<3; i++) \t{ \t\tfor(j=0; j<3; j++) \t\t{ \t\t\tif(i != j && i+j != 3) \t\t\t{ \t\t\t\tsum = sum + a[i][j]; \t\t\t} \t\t} \t} \t \tprintf(\"%d\\n\", sum);  \treturn 0; }", "referer": "user-0"}]}
{"question": "求解错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该是{}不配对，少了一个。把代码格式化一起缩进对齐看看哪一块少了}", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "代码不是猜出来的，需要看完整代码～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "player2move=2 少个;", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "D:\\未命名3.cpp\tIn function 'int main()': 8\t2\tD:\\未命名3.cpp\t[Error] expected ';' before 'if' 19\t1\tD:\\未命名3.cpp\t[Error] expected '}' at end of input", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "看到了，英文单词写错了 Youer  -> your", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "这啥意思，编译不过吗？只有一半的代码，没法看哪里错了", "referer": "user-0"}]}
{"question": "求大佬解答！这个输入0.02，为什么不出来运行结果？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "明白了，谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 3 楼 尘溪 的回复:可是加了 flag*1.0/(i + 3)之后还是运行不出来结果，输入0.02回车之后，光标一直闪，没有运行出结果。 你这代码逻辑有问题。参考我的代码，修改。。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "可是加了 flag*1.0/(i + 3)之后还是运行不出来结果，输入0.02回车之后，光标一直闪，没有运行出结果。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "flag*1.0/(i + 3) 确保该运算是浮点类型的运算，不加则按照整型的除法来运算，得到的是整型值", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "仅供参考： #include <stdio.h> #include <math.h>  int main() { \tdouble t, eps, i = 1, sum = 1; \tint flag = 1; \tscanf(\"%lf\", &eps); \tdo \t{ \t\ti = i + 3; \t\tflag = -flag; \t\tt = 1.0 * flag / i; \t\tsum = sum + t;  \t} while (fabs(t) > eps); \tprintf(\"sum = %.6lf\", sum);  \treturn 0; }", "referer": "user-0"}]}
{"question": "双向循环链表，功能扩充", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：//不带表头结点的循环双向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next;     struct NODE *prev; } *head,*p,*q,*s,*p1,*p2,*q1,**ta; int i,k,n,t,m,v,N=10; int main() {     setlocale(LC_ALL,\"chs\");     srand(time(NULL));      head=NULL;      printf(\"创建%d个节点的循环双向链表:\",N);//创建N个节点的循环双向链表     p=head;     for (i=0;i<N;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) exit(1);         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         q->prev=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             q->prev=p;             p=q;         }     }     p->next=head;     head->prev=p;      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf(\"\\n\");             break;         }         printf(\"%02d(=)\",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(\" !\\n\");break;}         s=s->next;         if (s==head) {             printf(\" Loop\\n\");             break;         }     }      k=3;     v=5;     printf(\"将值为%d的结点插入到循环双向链表的第%d个结点前:\",v,k);//将值为v的结点插入到循环双向链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=v;             q->next=head;             q->prev=head->prev;             head->prev->next=q;             head->prev=q;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=v;                 q->next=p->next;                 q->prev=p;                 p->next->prev=q;                 p->next=q;                 break;             }         }         p=p->next;         if (p==head) break;     }      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf(\"\\n\");             break;         }         printf(\"%02d(=)\",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(\" !\\n\");break;}         s=s->next;         if (s==head) {             printf(\" Loop\\n\");             break;         }     }      k=5;     printf(\"删除第%d个节点:\",k);//删除第k个节点     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=head;             head=head->next;             head->prev=q->prev;             q->prev->next=head;             if (q==head) head=NULL;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 p->next=q->next;                 q->next->prev=p;                 free(q);                 break;             }         }         p=p->next;         if (p==head) break;     }      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf(\"\\n\");             break;         }         printf(\"%02d(=)\",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(\" !\\n\");break;}         s=s->next;         if (s==head) {             printf(\" Loop\\n\");             break;         }     }      printf(\"从小到大排序:\");//从小到大排序     for (p=head;p!=NULL;) {         p1=p->prev;         for (q=p->next,q1=p;q!=NULL;) {             if (p->data > q->data) {                  //交换data //              printf(\"swap %02d %02d\\n\",p->data,q->data); //              t=p->data;p->data=q->data;q->data=t;                  //或者                  //交换prev和next //              printf(\"swap %02d %02d\\n\",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         head->prev=p1;                         p1->next=q;                         p->next=q->next;                         p->prev=q;                         q->next->prev=p;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         head->prev=p1;                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         p->next->prev=p;                         p->prev=q1;                         q->next->prev=p;                         q->next=p2;                         p2->prev=q;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         p->prev=q;                         q->next->prev=p;                         q->next=p;                         q->prev=p1;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         p->prev=q->prev;                         q->next->prev=p;                         q->next=p2;                         q->prev=p1;                         p2->prev=q;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个循环双向链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf(\"\\n\"); //                      break; //                  } //                  printf(\"%02d(=)\",s->data); //                  if (NULL!=s->next && s->next->prev!=s) {printf(\" !\\n\");break;} //                  s=s->next; //                  if (s==head) { //                      printf(\" Loop\\n\"); //                      break; //                  } //              } //              printf(\"head,p,q:%02d %02d %02d\\n\",head->data,p->data,q->data); //              getchar();             }             q1=q;q=q->next;             if (q==head) break;         }         p=p->next;         if (p->next==head) break;     }      //输出整个循环双向链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf(\"\\n\");             break;         }         printf(\"%02d(=)\",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(\" !\\n\");break;}         n++;         s=s->next;         if (s==head) {             printf(\" Loop\\n\");             break;         }     }      printf(\"将整个链表逆序:\");//将整个链表逆序     if (n>=2) {         p=head;         while (1) {             q=p->prev;p->prev=p->next;p->next=q;             p=p->next;             if (p==head) break;         }     }      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf(\"\\n\");             break;         }         printf(\"%02d(=)\",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(\" !\\n\");break;}         s=s->next;         if (s==head) {             printf(\" Loop\\n\");             break;         }     }      m=4;     n=6;     printf(\"将循环双向链表中前%d个结点和后%d个结点进行互换:\",m,n);//将循环双向链表中前m个结点和后n个结点进行互换,m+n为链表总长     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m==k) {             q=p;             break;         }         p=p->next;         if (p==head) break;     }     head=q->next;      //输出整个循环双向链表     s=head;     while (1) {         if (NULL==s) {             printf(\"\\n\");             break;         }         printf(\"%02d(=)\",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(\" !\\n\");break;}         s=s->next;         if (s==head) {             printf(\" Loop\\n\");             break;         }     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;         if (p==head) {             break;         }     }      return 0; } //创建10个节点的循环双向链表:12(=)46(=)31(=)63(=)25(=)91(=)39(=)02(=)92(=)68(=) Loop //将值为5的结点插入到循环双向链表的第3个结点前:12(=)46(=)05(=)31(=)63(=)25(=)91(=)39(=)02(=)92(=)68(=) Loop //删除第5个节点:12(=)46(=)05(=)31(=)25(=)91(=)39(=)02(=)92(=)68(=) Loop //从小到大排序:02(=)05(=)12(=)25(=)31(=)39(=)46(=)68(=)91(=)92(=) Loop //将整个链表逆序:92(=)91(=)68(=)46(=)39(=)31(=)25(=)12(=)05(=)02(=) Loop //将循环双向链表中前4个结点和后6个结点进行互换:39(=)31(=)25(=)12(=)05(=)02(=)92(=)91(=)68(=)46(=) Loop //", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "简洁，明了。。", "referer": "user-0"}]}
{"question": "二维数组求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#3第一段代码，m和n搞反了，纠正后：//题目（输入m,n,o，接着输入m*n个数，其中0<m,n<30，存为m*n二维数组中查找o，输出第一次出现o的位置。 //如果找不到，输出not found）大佬们看一下，我想在二维数组里输入一串数该怎么改啊，m和n也是参数啊， //这样数组里怎么写才能输入进去数字啊，还有怎么输出第一次的位置呢？？？？求解求解，大一笨蛋要死了 #include<stdio.h> int main() {     int m,n,o;     int x,y;     int *cz;      scanf(\"%d%d%d\",&m,&n,&o);     if (!(0<m && m<30 && 0<n && n<30)) return 1;     cz=new int[m*n];     for (y = 0; y < m; y++) {         for (x = 0; x < n; x++) {             scanf(\"%d\",&cz[y*n+x]);         }     }     for (y = 0; y < m; y++) {         for (x = 0; x < n; x++) {             if (o == cz[y*n+x]) {                 printf(\"(%d,%d)\\n\",x,y);                 break;             }         }         if (x<n) break;     }     if (y>=m) printf(\"not found\\n\");     delete[] cz;      return 0; } //input: //2 3 9 //11 12 13 //21 22 23 //output: //not found // //input: //2 3 13 //11 12 13 //21 13 23 //output: //(2,0) //", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼上用最大30x30的数组也行。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "//题目（输入m,n,o，接着输入m*n个数，其中0<m,n<30，存为m*n二维数组中查找o，输出第一次出现o的位置。 //如果找不到，输出not found）大佬们看一下，我想在二维数组里输入一串数该怎么改啊，m和n也是参数啊， //这样数组里怎么写才能输入进去数字啊，还有怎么输出第一次的位置呢？？？？求解求解，大一笨蛋要死了 #include<stdio.h> int main() {     int m,n,o;     int x,y;     int *cz;      scanf(\"%d%d%d\",&m,&n,&o);     if (!(0<m && m<30 && 0<n && n<30)) return 1;     cz=new int[m*n];     for (y = 0; y < n; y++) {         for (x = 0; x < m; x++) {             scanf(\"%d\",&cz[y*m+x]);         }     }     for (y = 0; y < n; y++) {         for (x = 0; x < m; x++) {             if (o == cz[y*m+x]) {                 printf(\"(%d,%d)\\n\",x,y);                 break;             }         }         if (x<m) break;     }     if (y>=n) printf(\"not found\\n\");     delete[] cz;      return 0; } //input: //2 3 9 //11 12 13 //21 22 23 //output: //not found // //input: //2 3 13 //11 12 13 //21 13 23 //output: //(0,1) //  非要用真正的二维数组的话，参考下面： #include <stdio.h> #include <stdlib.h> int **newarr2d(int rows,int cols) {     int **p,i;      p=new int *[rows];     if (NULL==p) exit(1);     for (i=0;i<rows;i++) {         p[i]=new int[cols];         if (NULL==p[i]) exit(1);     }     return p; } void deletearr2d(int **p,int rows) {     int i;      for (i=0;i<rows;i++) {         delete[] p[i];     }     delete[] p; } int main() {     int **arr2d,i,j,r,c;      r=4;     c=5;     //在堆中开辟一个4×5的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(\" %2d\",arr2d[i][j]);         }         printf(\"\\n\");     }     deletearr2d(arr2d,r);      r=6;     c=3;     //在堆中开辟一个6×3的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(\" %2d\",arr2d[i][j]);         }         printf(\"\\n\");     }     deletearr2d(arr2d,r);      return 0; } //  0  1  2  3  4 //  5  6  7  8  9 // 10 11 12 13 14 // 15 16 17 18 19 //  0  1  2 //  3  4  5 //  6  7  8 //  9 10 11 // 12 13 14 // 15 16 17 //", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "#include<stdio.h>  #define ROW     30 #define COL     30  int main() {     int m,n,o;     int i,j;     int cz[ROW][COL];     scanf(\"%d %d %d\",&m,&n,&o);     if (m > ROW)         m = ROW;     if (n > COL)         n = COL;      for (i = 0; i < m; i++)     //遍历     {         for (j = 0; j < n; j++)         {             scanf(\"%d\", &cz[i][j]);         }     }     for (i = 0; i < m; i++)     //遍历     {         for (j = 0; j < n; j++)         {             if (o == cz[i][j]) {                 printf(\"%d,%d\",i,j);                 break;             }         }         if (j < n)             break;     }     if (i >= m)         printf(\"not found!\\n\");      return 0; } 供参考～", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "int cz[m][n] 是不可以的，既然 0<m,n<30，那就 int cz[30][30]", "referer": "user-0"}]}
{"question": "构造出哈夫曼树了求哈夫曼编码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://blog.csdn.net/mdjros/article/details/97140637", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:严蔚敏老师的数据结构(C语言版)之P146，很详细介绍，一看就懂的。 有没有链接有没有链接可以用", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "严蔚敏老师的数据结构(C语言版)之P146，很详细介绍，一看就懂的。", "referer": "user-0"}]}
{"question": "Linux经典书籍推荐", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "还有大神回复吗", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "《Linux环境下C编程》，《C prime plus》， 《C++ prime plus》", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "UNIX环境高级编程 —— UNIX/Linux系统编程圣经 UNIX网络编程 TCP/IP详解 Linux内核设计与实现 深入理解Linux内核 Linux设备驱动程序", "referer": "user-0"}]}
{"question": "小白求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "有点糊涂，但是我看到了两个i++，和一句m=m", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "自己的代码最好加上注释，或者讲下自己的思路，这样友好一些。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h>  int main() {     static char str[10001];     int len, i;     unsigned long long sum ;      while (scanf(\"%s\", str) != EOF) {         sum = 0;         len = strlen(str);         for (i = 0; i < len; i++)             if (str[i] != '0')                 sum += (unsigned long long)pow(2, len - i - 1) * (str[i] - '0');         //printf(\"%llu\\n\", sum);         if (sum % 3 == 0)             printf(\"YES\\n\");         else             printf(\"No\\n\");      } #if 0     char a[10001];     while(scanf(\"%s\",a) != EOF)     {         int i=0,yusu=0,m;         while(a[i]!='\\0')         {             m=yusu*10+(a[i]-'0');             if(m<11)             {                 i++;                 if(a[i]=='\\0')                     m=m;                 else                     m=m*10+(a[i]-'0');             }             yusu=m%11;             i++;         }         if(yusu==0)             printf(\"YES\\n\");         else             printf(\"NO\\n\");     } #endif } 优化一下，供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h>  int main() {     static char str[10001];     int len, i;     unsigned long long sum ;      while (scanf(\"%s\", str) != EOF) {         sum = 0;         len = strlen(str);         for (i = 0; i < len; i++)             sum += (unsigned long long)pow(2, len - i - 1) * (str[i] - '0');         //printf(\"%llu\\n\", sum);         if (sum % 3 == 0)             printf(\"YES\\n\");         else             printf(\"No\\n\");      } #if 0     char a[10001];     while(scanf(\"%s\",a) != EOF)     {         int i=0,yusu=0,m;         while(a[i]!='\\0')         {             m=yusu*10+(a[i]-'0');             if(m<11)             {                 i++;                 if(a[i]=='\\0')                     m=m;                 else                     m=m*10+(a[i]-'0');             }             yusu=m%11;             i++;         }         if(yusu==0)             printf(\"YES\\n\");         else             printf(\"NO\\n\");     } #endif } 供参考～", "referer": "user-0"}]}
{"question": "求助：1580-鸭梨大冒险——不知道错在哪里，求大佬指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已解决，原因:平台问题，改正方法:将所有数据均定义成double型 最后输出%.0f", "referer": "user-0"}]}
{"question": "萌新不知道错哪了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #define N 90 double fuxc(double x, int n) { \tint i; \tdouble f[N],s; \tif (n == 0) \t{ \t\ts = 1; \t} \tif (n == 1) \t{ \t\ts = x; \t} \tif(n>1) \t{ \t\tf[0] = 1; \t\tf[1] = x; \t\tfor(i=2;i<=n;i++) \t\t{ \t\t\tf[i]=(2.0*i-1)/i*x*f[i-1]-(i-1)/i*f[i-2]; \t\t} \t\ts = f[n]; \t} \treturn s; }  int main() { \tdouble x,z; \tint n; \tscanf(\"%lf %d\", &x,&n); \tz=fuxc(x, n); \tprintf(\"%.2lf\", z); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "楼主应该是想写递归的算法，修改如下，供参考：#include<stdio.h> double fuxc(double x,int n) {     double s;     if(n==0)         return 1;     else if(n==1)             return x;          else             {               s=((2*n-1)*x* fuxc(x,n-1) -(n-1)* fuxc(x,n-2))/n*1.0;               return s;             } }   int main(int argc, char* argv[]) {     double x,z;     int n;     scanf(\"%lf %d\", &x, &n);     z = fuxc(x, n);     printf(\"%.2lf\\n\", z);     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "你给出勒让德多项式的定义", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "f[0]=0; 改成 f[0]=1; 否则 i*f[i-2]就发生除以0错误了", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "没语法错误，肯定是逻辑错误。 你也没贴出来多项式是什么样子的，谁能帮你？？？", "referer": "user-0"}]}
{"question": "求助 C语言中如何利用数组计算两个坐标之间的距离", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "主函数怎么写啊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <math.h>  double calculateDistance(double x1, double y1, double x2, double y2) {     return sqrt(       (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)        ) }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "很简单嘛，哪里不会？", "referer": "user-0"}]}
{"question": "为什么文件无法打开呀？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 qq_46029678 的回复:[quote=引用 4 楼 自信男孩 的回复:][quote=引用 3 楼 qq_46029678 的回复:][quote=引用 1 楼 自信男孩 的回复:]  if((fp=fopen(\"Fname\", \"r\"))==NULL){  /*打开数据文件*/ 这句有问题，改成：   if((fp=fopen(Fname, \"r\"))==NULL){  /*打开数据文件*/  你写的代码，是要打开文件名为Fname的文件，不是你输入的文件名，因为变量Fname存放的就是文件路径的字符串；但是还是不行，实际上我直接复制了文件路径，然后出现了Debug Assertion Failed，大佬麻烦你再看看，谢谢[/quote] 那你打印一下Fname是多少？是不是你输入的路径呢？在打开之前打印一下[/quote] 我晓得，真正的问题是，我插入函数EnQueue里面的free（p）出了问题，好像是多次释放指针造成的，但是我不晓得为啥子多次释放了，我感觉就每次使用，然后用完了就释放了呀[/quote] 你的问题是打开文件，没仔细看你的其他问题～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 自信男孩 的回复:[quote=引用 3 楼 qq_46029678 的回复:][quote=引用 1 楼 自信男孩 的回复:]  if((fp=fopen(\"Fname\", \"r\"))==NULL){  /*打开数据文件*/ 这句有问题，改成：   if((fp=fopen(Fname, \"r\"))==NULL){  /*打开数据文件*/  你写的代码，是要打开文件名为Fname的文件，不是你输入的文件名，因为变量Fname存放的就是文件路径的字符串；但是还是不行，实际上我直接复制了文件路径，然后出现了Debug Assertion Failed，大佬麻烦你再看看，谢谢[/quote] 那你打印一下Fname是多少？是不是你输入的路径呢？在打开之前打印一下[/quote] 我晓得，真正的问题是，我插入函数EnQueue里面的free（p）出了问题，好像是多次释放指针造成的，但是我不晓得为啥子多次释放了，我感觉就每次使用，然后用完了就释放了呀", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 3 楼 qq_46029678 的回复:[quote=引用 1 楼 自信男孩 的回复:]  if((fp=fopen(\"Fname\", \"r\"))==NULL){  /*打开数据文件*/ 这句有问题，改成：   if((fp=fopen(Fname, \"r\"))==NULL){  /*打开数据文件*/  你写的代码，是要打开文件名为Fname的文件，不是你输入的文件名，因为变量Fname存放的就是文件路径的字符串；但是还是不行，实际上我直接复制了文件路径，然后出现了Debug Assertion Failed，大佬麻烦你再看看，谢谢[/quote] 那你打印一下Fname是多少？是不是你输入的路径呢？在打开之前打印一下", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "if((fp=fopen(\"Fname\", \"r\"))==NULL){  /*打开数据文件*/ 这句有问题，改成：   if((fp=fopen(Fname, \"r\"))==NULL){  /*打开数据文件*/  你写的代码，是要打开文件名为Fname的文件，不是你输入的文件名，因为变量Fname存放的就是文件路径的字符串；", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:  if((fp=fopen(\"Fname\", \"r\"))==NULL){  /*打开数据文件*/ 这句有问题，改成：   if((fp=fopen(Fname, \"r\"))==NULL){  /*打开数据文件*/  你写的代码，是要打开文件名为Fname的文件，不是你输入的文件名，因为变量Fname存放的就是文件路径的字符串；但是还是不行，实际上我直接复制了文件路径，然后出现了Debug Assertion Failed，大佬麻烦你再看看，谢谢", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "但是还是不行，实际上我直接复制了文件路径，然后出现了Debug Assertion Failed，大佬麻烦你再看看，谢谢", "referer": "user-0"}]}
{"question": "各位大佬，我想知道我这个折半法查找序数哪儿错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢大佬(*°∀°)=3", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 宇来风满楼的回复:看不懂报错的吗 没有报错，只是运行的答案不正确", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "仅供参考： #include <stdio.h>  int main(void) { \tint a[15] = {14,13,12,11,10,9,8,7,6,5,4,3,2,1,0}; \tint x, mid, left = 0, right = 14; \t \tprintf(\"请输入一个数字：\"); \tscanf(\"%d\", &x); \t \twhile(left <= right) \t{ \t\tmid = (left + right)/2; \t\t \t\tif(a[mid] == x) break; \t\telse if(a[mid] > x) left = mid + 1; \t\telse right = mid - 1; \t} \t \tif(left <= right) printf(\"x在数组中第%d个元素\\n\", mid); \telse printf(\"%d不在数组中\\n\", x); \t \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "看不懂报错的吗", "referer": "user-0"}]}
{"question": "求大佬帮我看看这道题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "已经排序好的，等于根节点，直接返回。 小于根节点，搜索左子树；大于根节点，搜索右子树。", "referer": "user-0"}]}
{"question": "数据结构中引用和指针的区别", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用必须赋初值，且不能改变，而指针可以。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "而且引用这个概念就是编译期，也就是说是语言层面的  引用 6 楼 ctrigger 的回复:[quote=引用 5 楼 真相重于对错 的回复:]引用和指针不能完全互换。否则c++不会引入这个多余的盲肠 举个例子 class A{   public:     A& operator=(const A& rh);     A operator+(const A& rh); } A a,b,c,d,e; 如果用指针，怎么写出   a=b=c=d+e;  “C++中引用的本质，通过反汇编手段揭示了引用的底层实现机与指针实质是一样的。” 也就说明引用的底层实现用的就是指针。你觉得指针行不行呢？？？[/quote] 如果不考虑语言，只考虑最后编译的结果的，当然可以，但是那样，为何我们要发明高级语言，不直接用汇编，甚至用01呢。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 6 楼 ctrigger 的回复:[quote=引用 5 楼 真相重于对错 的回复:]引用和指针不能完全互换。否则c++不会引入这个多余的盲肠 举个例子 class A{   public:     A& operator=(const A& rh);     A operator+(const A& rh); } A a,b,c,d,e; 如果用指针，怎么写出   a=b=c=d+e;  “C++中引用的本质，通过反汇编手段揭示了引用的底层实现机与指针实质是一样的。” 也就说明引用的底层实现用的就是指针。你觉得指针行不行呢？？？[/quote] 我说的是语言，建议了解一下c++的重载操作符。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "没有c/c++,汇编一样编程，没有汇编，扎纸带一样编程，不要太纠结这个", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "没有引用，只有指针的时候 也能编程，不要太纠结这个", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "引用 5 楼 真相重于对错 的回复:引用和指针不能完全互换。否则c++不会引入这个多余的盲肠 举个例子 class A{   public:     A& operator=(const A& rh);     A operator+(const A& rh); } A a,b,c,d,e; 如果用指针，怎么写出   a=b=c=d+e;  “C++中引用的本质，通过反汇编手段揭示了引用的底层实现机与指针实质是一样的。” 也就说明引用的底层实现用的就是指针。你觉得指针行不行呢？？？", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用和指针不能完全互换。否则c++不会引入这个多余的盲肠 举个例子 class A{   public:     A& operator=(const A& rh);     A operator+(const A& rh); } A a,b,c,d,e; 如果用指针，怎么写出   a=b=c=d+e;", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "引用 3 楼 Minikinfish 的回复:引用比指针快 是不是说反了啊？？？ 引用的底层实现也是靠指针。指针直接暴力，当然更高效益一点。", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "引用比指针快", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "楼上分析很棒。。 我个人觉得还是用指针醒目，看起来更自然一点。", "referer": "user-0"}, {"cid": "11", "user": "user-6", "content": "能用引用的地方，都可以用指针。用指针的地方也可以用引用。 不过，引用是C++独特的（相对于C语言），C语言不支持这种语法。所以，你的讨论应该是在C++的范围内。  引用是丰富了指针的功能，可以用另一种形式来表达指针的作用。个人观点，供参考。 建议楼主详细的了解引用的定义，指针的定义以及在传递参数的区别与相同点，以及在内存中是否占用内存，占用多大内存等等这些信息", "referer": "user-0"}]}
{"question": "Lua语言如何随机取文本内容", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "宿主语言中实现，给lua提供接口", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "用C/C++吧，很多人会告诉你的。", "referer": "user-0"}]}
{"question": "可能与static相关的一个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 7 楼 Daydream_realize 的回复:[quote=引用 4 楼 自信男孩 的回复:]这个问题跟有没有static没有关系，建议楼主试一下把ch改成unsigned int ch;再测试任何情况：1）加static和不加；2）加int i = 0;和不加int i = 0;（注释掉）；  个人认为（测试一样）是一样的，不会出现全是1的问题。  原因是%x是对unsigned int而言的，如果用unsigned char去接收这个输入的值，那么势必会越界呢，并且ch和len很近，所以越界先覆盖的就是len变量；  为了解决这个问题，把ch定义为unsigned int比较妥当，因为这样不会出现越界问题，也不会出现不可判定的问题。  当然，加不加int i = 0;和static的问题都是这个引起的。  unsigned int char ch;就是原来的代码，但是原来代码在赋值的时候又加了一个强制类型转换(unsigned char)ch，所以我很奇怪为什么不直接用unsigned char ch，才做了这些试验。 不太明白你说的势必会越界的问题，char有8bit位，%1x只有4bit位，怎么会越界呢？[/quote]  注意%x，先不要考虑前面的1,只是这个就要求是unsigned int，你的编译器不给你提示吗？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "我前边已说了，你错误的使用了这函数，由于不同编译器的处理不一定相同，因此出现什么样的情况都是可能的。如果想具体了解为什么建议去学一下汇编。就好比闯红灯，你是使用错误的在马路上通行方式，那么被撞，或者不被撞都是可能的。  引用 14 楼 Daydream_realize 的回复:那么另一个问题来了，详见帖子最后一图， 当我把第二个变量定义语句： static unsigned char input[300]; 的static去掉，改为： unsigned char input[300]; 程序又能正常运行了，这是为什么呢？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "应该是跟您的编译器有关系，VS2015 C++环境 int main() { \tint i = 0; \tstatic unsigned char input[300]; \tint len = 0; \tunsigned char ch;  \twhile (scanf(\"%1x\", &ch) == 1) { \t\tinput[len++] = ch; \t\tprintf(\"%d \", len); \t} \treturn 959; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "一个c/c++程序变量分别存储在栈，堆，以及全局数据区。不同的编译器做法并不一定完全一致。 比如你这个问题，其实是涉及到站  引用 12 楼 Daydream_realize 的回复:[quote=引用 9 楼 真相重于对错 的回复:]%1x 不代表只输入一个字节宽度，而代表只接受输入的第一个字符.但是它把输入变量当作一个整形来处理，而不是一个字符型。 做个简单例子就是 unsigned char ch[4]={0xff,0xff,0xff,0xff}; scanf(\"%1x\",ch[0]); ======= 你输入3的时候，他会把后面的数据冲掉，ch变成{0x3,0x0,0x0,0x0}; 这样说来，scanf是一个特别危险的函数了吗？ 万一scanf(\"%d\", ch);   ，而ch是一个char类型，那么程序甚至可能出现段错误？这也太危险了吧，那scanf这种函数就不应该存在啊！[/quote] scanf本来就是有漏洞啊现在一般都用scanf_s来避免出现问题，c语言对于计算机控制比较强大，就好比让一个小朋友拿把刀，因为容易把自己伤了，于是就不让刀出现？你的问题不是因为scanf危险而造成的，而是你错误的使用了scanf。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "那么另一个问题来了，详见帖子最后一图， 当我把第二个变量定义语句： static unsigned char input[300]; 的static去掉，改为： unsigned char input[300]; 程序又能正常运行了，这是为什么呢？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 11 楼 自信男孩 的回复:[quote=引用 7 楼 Daydream_realize 的回复:][quote=引用 4 楼 自信男孩 的回复:]这个问题跟有没有static没有关系，建议楼主试一下把ch改成unsigned int ch;再测试任何情况：1）加static和不加；2）加int i = 0;和不加int i = 0;（注释掉）；  个人认为（测试一样）是一样的，不会出现全是1的问题。  原因是%x是对unsigned int而言的，如果用unsigned char去接收这个输入的值，那么势必会越界呢，并且ch和len很近，所以越界先覆盖的就是len变量；  为了解决这个问题，把ch定义为unsigned int比较妥当，因为这样不会出现越界问题，也不会出现不可判定的问题。  当然，加不加int i = 0;和static的问题都是这个引起的。  unsigned int char ch;就是原来的代码，但是原来代码在赋值的时候又加了一个强制类型转换(unsigned char)ch，所以我很奇怪为什么不直接用unsigned char ch，才做了这些试验。 不太明白你说的势必会越界的问题，char有8bit位，%1x只有4bit位，怎么会越界呢？[/quote]  注意%x，先不要考虑前面的1,只是这个就要求是unsigned int，你的编译器不给你提示吗？[/quote] 编译器没有提示。 这样说来，scanf是一个特别危险的函数了吗？ 万一scanf(\"%d\", ch);   ，而ch是一个char类型，那么程序甚至可能出现段错误？这也太危险了吧，那scanf这种函数就不应该存在啊！", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 9 楼 真相重于对错 的回复:%1x 不代表只输入一个字节宽度，而代表只接受输入的第一个字符.但是它把输入变量当作一个整形来处理，而不是一个字符型。 做个简单例子就是 unsigned char ch[4]={0xff,0xff,0xff,0xff}; scanf(\"%1x\",ch[0]); ======= 你输入3的时候，他会把后面的数据冲掉，ch变成{0x3,0x0,0x0,0x0}; 这样说来，scanf是一个特别危险的函数了吗？ 万一scanf(\"%d\", ch);   ，而ch是一个char类型，那么程序甚至可能出现段错误？这也太危险了吧，那scanf这种函数就不应该存在啊！", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "%1x 不代表只输入一个字节宽度，而代表只接受输入的第一个字符.但是它把输入变量当作一个整形来处理，而不是一个字符型。 做个简单例子就是 unsigned char ch[4]={0xff,0xff,0xff,0xff}; scanf(\"%1x\",ch[0]); ======= 你输入3的时候，他会把后面的数据冲掉，ch变成{0x3,0x0,0x0,0x0};", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 2 楼 Minikinfish 的回复:是的啥编译器？scanf 的%x格式，默认输入是int*参数，楼主传的是char*，怀疑内存被改坏了 gcc编译的", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 4 楼 自信男孩 的回复:这个问题跟有没有static没有关系，建议楼主试一下把ch改成unsigned int ch;再测试任何情况：1）加static和不加；2）加int i = 0;和不加int i = 0;（注释掉）；  个人认为（测试一样）是一样的，不会出现全是1的问题。  原因是%x是对unsigned int而言的，如果用unsigned char去接收这个输入的值，那么势必会越界呢，并且ch和len很近，所以越界先覆盖的就是len变量；  为了解决这个问题，把ch定义为unsigned int比较妥当，因为这样不会出现越界问题，也不会出现不可判定的问题。  当然，加不加int i = 0;和static的问题都是这个引起的。  unsigned int char ch;就是原来的代码，但是原来代码在赋值的时候又加了一个强制类型转换(unsigned char)ch，所以我很奇怪为什么不直接用unsigned char ch，才做了这些试验。 不太明白你说的势必会越界的问题，char有8bit位，%1x只有4bit位，怎么会越界呢？", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 5 楼 真相重于对错 的回复:你的ch是char,却按int输入（%1x)，出现什么样的情况都是可能 ch占1个字节，即8位。 输入（%1x)，表示读取输入流中的1位数据，并当做16进制的数字，存储在ch的低4位上。 不会出现你说的情况。", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "你的ch是char,却按int输入（%1x)，出现什么样的情况都是可能", "referer": "user-0"}, {"cid": "13", "user": "user-1", "content": "这个问题跟有没有static没有关系，建议楼主试一下把ch改成unsigned int ch;再测试任何情况：1）加static和不加；2）加int i = 0;和不加int i = 0;（注释掉）；  个人认为（测试一样）是一样的，不会出现全是1的问题。  原因是%x是对unsigned int而言的，如果用unsigned char去接收这个输入的值，那么势必会越界呢，并且ch和len很近，所以越界先覆盖的就是len变量；  为了解决这个问题，把ch定义为unsigned int比较妥当，因为这样不会出现越界问题，也不会出现不可判定的问题。  当然，加不加int i = 0;和static的问题都是这个引起的。", "referer": "user-0"}, {"cid": "14", "user": "user-4", "content": "或者clean以下，rebuild all", "referer": "user-0"}, {"cid": "15", "user": "user-4", "content": "是的啥编译器？scanf 的%x格式，默认输入是int*参数，楼主传的是char*，怀疑内存被改坏了", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "https://blog.csdn.net/u011499425/article/details/52751636", "referer": "user-0"}]}
{"question": "诸位大佬帮忙看看，这个1是哪里冒出来的？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf(\"发放的奖金数为: %f万元\\n\",bonus);  => printf(\"发放的奖金数为: %.2f万元\\n\",bonus);", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "浮点数表示问题，是近似值。", "referer": "user-0"}]}
{"question": "sockt http问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "自已动手学习学习", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你是要实现HTTP请求？首先了解一下OSI7层网络协议。  socket工作在传输层，你要收发并解析HTTP包，要自己写封包和解包。  window有现成的API函数可以直接使用HTTP请求，CInternetSession，或者使用libcurl，也非常好用。", "referer": "user-0"}]}
{"question": "数据结构与算法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数据结构 清华严蔚敏老师的书不错，适合入门。 算法导论，第三版，经典中的经典。", "referer": "user-0"}]}
{"question": "求大佬帮我看看这道二叉树问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "isSubtree(s->left, t) //这里的递归没有判断s->left是不是null（null的情况是可能存在的），所以要在isSubtree里面做判断 isSubtree(s->right, t) //同理，这里也如此 如果改成 return isequal(s, t) || (s->left && isSubtree(s->left, t)) || (s->right && isSubtree(s->right, t)) 那么isSubtree函数内就不需要判断了 但是，从函数的设计来看，在isSubtree函数内判断s是合理的，因为用户在调用isSubtree，不一定会判断参数是否为null，所以函数内部要尽量保证能容错程序不崩溃。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if (!s) return false;  == 这是判断示例2的情况。。", "referer": "user-0"}]}
{"question": "新手求问，C语言中多个不加大括号的if语句连续使用该如何理解？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 8 楼 qzjhjxj 的回复：int main(int argc, char* argv[]) {     int i=1,j=3,k=5,m=4;     do{         if(i%j==0)            if(i%k==0)               if(i%m==0)//这三个if语句，等价于：if(i%j==0 && i%k==0 && i%m==0)                {                 printf(\"%d\\n\",i);                 break;                }         i++;        }while(i!=0);     system(\"pause\");     return 0; }谢谢大佬，明白了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "int main(int argc, char* argv[]) {     int i=1,j=3,k=5,m=4;     do{         if(i%j==0)            if(i%k==0)               if(i%m==0)//这三个if语句，等价于：if(i%j==0 && i%k==0 && i%m==0)                {                 printf(\"%d\\n\",i);                 break;                }         i++;        }while(i!=0);     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "把第二个程序稍加修改，楼主去试验下，就明白了：int main(int argc, char* argv[]) {     int i=1,j=3,k=5,m=4;     do{         if(i%j==0)            if(i%k==0)               if(i%m==0)                {                 printf(\"%d\\n\",i);                 break;                }         i++;        }while(i!=0);     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "1的意思是if的条件成立，就执行一条if语句，所以最后那个大括号属于第三条（第三层）if语句的执行部分 2 i++不是if的执行语句，上面的情况和1类似 是if为true，则执行一个if语句，然后如果这第二层if为真，则执行下一条语句（或是下一个大括号内的所有语句）， 所以这两重if语句走到大括号结束就完了。判断方法就是if（xxx）之后只管一条语句，不用大括号的话 if （xx） s1;          // if到这儿就完了 s2;", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "第一题：这个语句是属于if语句中的，如果要执行，必须是前面三个if条件全满足才会执行到。 第二题：i++；不属于if语句中的。c是以“；”号表示一条语句的结束，所以前面两个if之间没有结束符号，就表示这是同一条并列语句。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "从问题2的结果可以看出要所有的if语句满足条件才执行输出i，所以i一直累加到15,15可以整除j和k。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "这个i++不是if语句中的， 那个大括号里面的是两个if语句的作用域, 看大括号啊， 其实第一个if语句最好也加上大括号，或者改写两个if语句为一个与的判断", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "C语言中语句是以分号;或者大括号{}结束，所以问题1中的语句不属于if语句中。问题2中的i最终结果是15", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "不属于。这语言等价的结构是这样的： #include<stdio.h> void main() { \tint i = 1, j = 3, k = 5; \tdo { \t\tif (i % j == 0) \t\t{ \t\t\tif (i % k == 0) { \t\t\t\tprintf(\"%d\\n\", i); \t\t\t\tbreak; \t\t\t} \t\t} \t\ti++; \t} while (i != 0); }", "referer": "user-0"}]}
{"question": "希望大神给讲解一下这道题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第一个for（i=0;i<10;i++）            scanf(\"%d\",&a[i]);  它的作用域就在scanf(\"%d\",&a[i]);这句就结束了，循环十次，完成十个数值输入。 第四个for（i=0；i<10;i++）                          printf(\"%d\",a[i]); 它的作用域就在 printf(\"%d\",a[i]);这句，循环十次，完成打印输出十次。以上两个都是一次循环就结束了，没有内外之分。 第二和第三个for()循环才是组合循环，第二个for是外循环，第三个for是第二个for的内循环,和第一、第四没有任何关联。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 user-2的回复:[quote=引用 2 楼 m0_51795044 的回复:][quote=引用 1 楼 user-2的回复:]标准的冒泡排序算法。 每一次循环外层，一个最大数沉底。循环结束，排序完成。。。 那些for里面都是啥意思啊[/quote]  内层循环，每次沉底一个最大值。 外层循环，跑完结束，排序完成。[/quote] 第一个和第四个for是外层循环，第二个和第三个是内层循环？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 m0_51795044 的回复:[quote=引用 1 楼 user-2的回复:]标准的冒泡排序算法。 每一次循环外层，一个最大数沉底。循环结束，排序完成。。。 那些for里面都是啥意思啊[/quote]  内层循环，每次沉底一个最大值。 外层循环，跑完结束，排序完成。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:标准的冒泡排序算法。 每一次循环外层，一个最大数沉底。循环结束，排序完成。。。 那些for里面都是啥意思啊", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "标准的冒泡排序算法。 每一次循环外层，一个最大数沉底。循环结束，排序完成。。。", "referer": "user-0"}]}
{"question": "有没有大佬能解答一下啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "整数字面量被自动编译为int，就好像浮点数字面量都被自动编译为double一样。 一般的32位/64位编译器的sizeof(int)是4（就是整形占4个字节32位），所以sizeof(int)+3=4+3=7", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:这种题，纯属扯蛋的。没人定义int类型就一定是4位。  等于7的理解：sizeof 2 + 3；== sizeof（int) + 3 == 4 + 3 == 7 感谢！感谢！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这种题，纯属扯蛋的。没人定义int类型就一定是4位。  等于7的理解：sizeof 2 + 3；== sizeof（int) + 3 == 4 + 3 == 7", "referer": "user-0"}]}
{"question": "字符串逆序输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<string.h> int main(int argc, char* argv[]) {     /*********Begin*********/     char s[100]=\"\\0\",x;     int i,n;     scanf(\"%s\",&s);     n=strlen(s)-1;     for(i=0;i<=n/2;i++)//或者按楼上所说，循环条件改成：i<=n/2      {          x=s[i];          s[i]=s[n-i];          s[n-i]=x;      }    printf(\"%s\\n\",s);    system(\"pause\");    return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "修改如下，供参考：#include<stdio.h> #include<string.h> int main(int argc, char* argv[]) {     /*********Begin*********/     char s[100]=\"\\0\",x;     int i,b,n;     scanf(\"%s\",&s);     n=strlen(s)-1;     for(i=0;i<n-i;i++)      {          x=s[i];          s[i]=s[n-i];          s[n-i]=x;      }    printf(\"%s\\n\",s);    system(\"pause\");    return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "用两个指针来输出也是一种方法", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你赋值给x的值就是正序的，后面x又赋值给了字符串s，所以输出的还是正序的", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "另建议你把s定义成char型指针,再用malloc给它个空间会更好一些", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "求助", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "改完之后就可以运行了,帮你测试过了", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "for(i=0;i<=n;i++)   ==  》 for(i=0;i<=n/2;i++)", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "i  <= n  改成i <= n/2 因为如果是n的话倒序之后又改回去了", "referer": "user-0"}]}
{"question": "各位大佬，实在是做不出来，求各位大佬指导", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 user-1的回复:无比暴力，仅供参考： #include <stdio.h> #define MAXLEN 1024  int handler(int data[], int status[], int n, int len) {     int value1, value2, ret, i;      if (n < len-1)     {         status[n] = 0;         ret = handler(data, status, n + 1, len);         if (ret) return ret;          status[n] = 1;         ret = handler(data, status, n + 1, len);         if (ret) return ret;     }      status[n] = 0;     value1 = value2 = 0;     for (i = 0; i < len; i++)     {         if (status[i] == 0) value1 = value1 + data[i];         else value2 = value2 + data[i];     }     if (value1 == value2) return value1;      status[n] = 1;     value1 = value2 = 0;     for (i = 0; i < len; i++)     {         if (status[i] == 0) value1 = value1 + data[i];         else value2 = value2 + data[i];     }     if (value1 == value2) return value1;      return 0; }  int main(void) {     int data[MAXLEN], status[MAXLEN];     int d, ret, len = 0;      while(1)     {         scanf(\"%d\", &d);         if (d == -1) break;         data[len++] = d;     }      ret = handler(data, status, 0, len);      if (ret > 0) printf(\"Yes\\n%d\\n\", ret);     else printf(\"No\\n\");      return 0; }  谢谢你，谢谢你😊", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-1的回复:无比暴力，仅供参考： #include <stdio.h> #define MAXLEN 1024  int handler(int data[], int status[], int n, int len) {     int value1, value2, ret, i;      if (n < len-1)     {         status[n] = 0;         ret = handler(data, status, n + 1, len);         if (ret) return ret;          status[n] = 1;         ret = handler(data, status, n + 1, len);         if (ret) return ret;     }      status[n] = 0;     value1 = value2 = 0;     for (i = 0; i < len; i++)     {         if (status[i] == 0) value1 = value1 + data[i];         else value2 = value2 + data[i];     }     if (value1 == value2) return value1;      status[n] = 1;     value1 = value2 = 0;     for (i = 0; i < len; i++)     {         if (status[i] == 0) value1 = value1 + data[i];         else value2 = value2 + data[i];     }     if (value1 == value2) return value1;      return 0; }  int main(void) {     int data[MAXLEN], status[MAXLEN];     int d, ret, len = 0;      while(1)     {         scanf(\"%d\", &d);         if (d == -1) break;         data[len++] = d;     }      ret = handler(data, status, 0, len);      if (ret > 0) printf(\"Yes\\n%d\\n\", ret);     else printf(\"No\\n\");      return 0; }  谢谢你，谢谢你", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "无比暴力，仅供参考： #include <stdio.h> #define MAXLEN 1024  int handler(int data[], int status[], int n, int len) {     int value1, value2, ret, i;      if (n < len-1)     {         status[n] = 0;         ret = handler(data, status, n + 1, len);         if (ret) return ret;          status[n] = 1;         ret = handler(data, status, n + 1, len);         if (ret) return ret;     }      status[n] = 0;     value1 = value2 = 0;     for (i = 0; i < len; i++)     {         if (status[i] == 0) value1 = value1 + data[i];         else value2 = value2 + data[i];     }     if (value1 == value2) return value1;      status[n] = 1;     value1 = value2 = 0;     for (i = 0; i < len; i++)     {         if (status[i] == 0) value1 = value1 + data[i];         else value2 = value2 + data[i];     }     if (value1 == value2) return value1;      return 0; }  int main(void) {     int data[MAXLEN], status[MAXLEN];     int d, ret, len = 0;      while(1)     {         scanf(\"%d\", &d);         if (d == -1) break;         data[len++] = d;     }      ret = handler(data, status, 0, len);      if (ret > 0) printf(\"Yes\\n%d\\n\", ret);     else printf(\"No\\n\");      return 0; }", "referer": "user-0"}]}
{"question": "求大神帮忙看看问题在哪？这题是将一个偶数拆成两个质数之和", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢你啊，我大一刚开始学c语言，新手小白啥都不懂，犯一些蠢蠢的错误。。。。。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "依楼主思路，修改如下：#include <stdio.h> #include <math.h> int prime(int n) {     int i;     for(i=2;i<=sqrt(n);i++)         if(n%i==0) return 0;     return 1; }  int main(int argc, char* argv[]) {    int a,b,c,d,n;    printf(\"请输入一个偶数(n>3):\");    scanf(\"%d\",&n);    if(n<3 || n%2!=0)         {           printf(\"该值不符合输入要求.\\n\");           //return 0;         }    else         {           for(a=2;a<=n/2;a++)            {              b=n-a;              c=prime(a);              d=prime(b);              if(c==1&&d==1)                 printf(\"%d=%d+%d\\n\",n,a,b);            }         }    system(\"pause\");    return 0; }", "referer": "user-0"}]}
{"question": "穿的插入删除", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include<stdlib.h> #include <string.h>  #define MAXSIZE 40  //结构体 typedef struct {     char ch[MAXSIZE];     int len; }sstring;  //插入 int strinsert(sstring *s,int pos,sstring t) {     int i;      printf(\"请输入你想要插入的位置:\");     scanf(\"%d\",&pos);      if(pos<0||pos>s->len)         return (0);      //if(s->len + t.len<=MAXSIZE){     if(s->len + t.len <= MAXSIZE-1){   //'\\0' is 1         for(i=s->len+t.len-1; i>=t.len+pos; i--){             s->ch[i] = s->ch[i-t.len];         }         for(i=0;i<t.len;i++) {             s->ch[i+pos]=t.ch[i];         }         s->len=s->len+t.len;         s->ch[s->len] = 0;    //for '\\0'     }     else if(pos+t.len<=MAXSIZE-1){         for(i=MAXSIZE-1;i>t.len+pos-1;i--)         {             s->ch[i]=s->ch[i-t.len];         }         for(i=0;i<t.len;i++)         {             s->ch[i]=s->ch[i-t.len];         }         s->len=MAXSIZE-1;         s->ch[s->len] = 0;     }     else     {         for(i=0;i<MAXSIZE-pos-1;i++)             s->ch[i+pos]=t.ch[i];         s->len=MAXSIZE-1;         s->ch[s->len] = 0;     }     return (1); } //删除 int strdelete(sstring *s,int pos,int len) {     int i;     printf(\"请输入你想要删除的位置:\");     scanf(\"%d\",&pos);     printf(\"请输入你想要删除的长度:\");     scanf(\"%d\",&len);     if(pos<0||pos>(s->len-len))     {         printf(\"删除的位置不合理!\");         return (0);     }     for(i=pos+len;i<s->len;i++)         s->ch[i-len]=s->ch[i];     s->len=s->len-len;     s->ch[s->len] = 0;     return (1); }  //void main() int main() {     sstring s,t;     int pos=0,len=0;     //主串     printf(\"请输入主串s\\n\");     scanf(\"%s\",s.ch);     s.len = strlen(s.ch);   //缺少更新len     printf(\"\\n\");     //子串     printf(\"请输入子串t\\n\");     scanf(\"%s\",t.ch);     t.len = strlen(t.ch);   //缺少更新len     printf(\"\\n\");     //插入     strinsert(&s,pos,t);     //printf(\"%s\",s);     printf(\"%s\",s.ch);     //删除     strdelete(&s,pos,len);     //printf(\"%s\",s);     printf(\"%s\",s.ch); } 供参考～", "referer": "user-0"}]}
{"question": "#C语言#递归", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "20的时候，算了 2^20遍，很快能够完成。 50的时候，要算 2^50遍，这个太多了，不是不行，是要等很久，甚至有可能内存爆掉  把 sum[n] = num(n-1) * n 改成 sum[n] = sum[n-1]*n，应该就可以了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "应该是时间复杂度太高了，递归50次的话耗时比20次多太多", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用现在的编译器太牛了，优化能力超乎想象。这种尾递归，编译器很好优化，非常块，不存在所谓的递归缺点。楼上说的没错，楼主的问题是递归的算法有问题，额外增加了一些不必要的开销。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 6 楼 glory@胖奇奇 的回复:应该是时间复杂度太高了，递归50次的话耗时比20次多太多  我用这个递归10000，都很快的，用时0.001秒。没任何问题。 #include <stdio.h>   int num(int n) {     if(n==0)     {         return 0;     }     else     {         return n + num(n-1);     } }   int main(void) {     int n = 10000;     printf(\"sum(%d) = %d\\n\", n, num(n));           return 0; }   运行结果如下： [root@localhost Workspace]# gcc -o demo demo.c [root@localhost Workspace]# time ./demo sum(10000) = 50005000  real\t0m0.001s user\t0m0.001s sys\t0m0.000s", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "引用 4 楼 qzjhjxj 的回复:没什么错误，执行递归算法，特别是递归执行层数多的时候，结果极其的慢，而且递归层数达到一定的值，需要增加额外的堆栈处理，就有可能出现内存溢出的情况，这是递归算法的缺点。 现在的编译器太牛了，优化能力超乎想象。这种尾递归，编译器很好优化，非常块，不存在所谓的递归缺点。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "没什么错误，执行递归算法，特别是递归执行层数多的时候，结果极其的慢，而且递归层数达到一定的值，需要增加额外的堆栈处理，就有可能出现内存溢出的情况，这是递归算法的缺点。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "仅供参考： #include <stdio.h>  int num(int n) { \tif(n==0) \t{ \t\treturn 0; \t} \telse \t{ \t\treturn n + num(n-1); \t} }  int main(void) { \tprintf(\"%d\", num(20)); \t \treturn 0; }", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 的回复:一定要用递归 要计算从一加到n", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "一定要用递归", "referer": "user-0"}]}
{"question": "指针的值为何为0？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "一楼的解释是有可能的和有道理的，建议楼主不用过分在意这个，对于指针的初始化，即char *ptr = NULL;", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主打印的是ptr指向的内容，如果没有初始化，它是随机的值，即指向的内容不确定。楼主的0其实是一个特殊的位置0地址位置即(void *)0。 另外，打印地址的格式应该用%p或%x", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这个要看编译器环境，未指定具体数值的野指针", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "可能是随机值吧。我用gcc 9.2，结果是16。  E:\\Workspace>gcc --version gcc (tdm64-1) 9.2.0 Copyright (C) 2019 Free Software Foundation, Inc. This is free software; see the source for copying conditions.  There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   E:\\Workspace>>demo ptr = 16  E:\\Workspace>>demo ptr = 16  E:\\Workspace>>demo ptr = 16", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "试了一下 centos8.2、g++ 8.3上 未初始化的指针确实被自动置空，应该是gcc做的一个保护机制吧 win下是没有这么做的（但vc2019 debug版就会在编译报错C4700， 并且强行关闭之后，debug版仍会弹出运行时错误，可以说两个平台都做了足够保护）", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "52，你第一行的;号打成中文符号了", "referer": "user-0"}]}
{"question": "单链表的就地逆置", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "H1=NULL ==>H1变成空链表 -- 以后每次循环一次，插入一个节点。 H1=q ==> H1始终是链表的头部。", "referer": "user-0"}]}
{"question": "c语言求救：输出的时候少一个数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "sum+=(int)round(pow(a[j],n));  加个round四舍五入再取整试试  好像是因为精度误差", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你把数组a[10]=｛0｝；赋初值再试试。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-4 的回复：没错啊，你的运行结果是什么少第一个数", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "可以这样改下，看看问题在哪：int hhh(int n) {     long a[10]={0}, i, j, x, y, t, sum;     x=pow(10, n-1);     y=pow(10, n);     //printf(\"X=%d,Y=%d\\n\",x,y);       for(i=x;i<y;i++)     {         printf(\"i=%d\\n\",i);//这里加一句打印出i         t=i;         sum=0;         for(j=0;j<n;j++)         {             a[j]=t%10;             t=t/10;         }         for(j=0;j<n;j++)         {             sum+=pow(a[j],n);             printf(\"sum+第(%d)次=%d\\n\",j,sum);//这里看看sum的值             system(\"pause\");  //这里暂停下看的清楚         }         if(sum==i)         {             printf(\"%ld \\t\",sum);         }     } }  实际效果，如下图：", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 9 楼 qzjhjxj 的回复:引用printf(\"x=d%,y=%d\\\",x,y);//这里增加看看x y 的值。或者干脆 x=150,y=155赋值，看看下面能不能输出153.这句打错了，应该这样的：printf(\"X=%d,Y=%d\\n\",x,y); 还是不可以，就153输出不了，把y=999之后，还是153出不来，只输出其他三个。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "引用printf(\"x=d%,y=%d\\\",x,y);//这里增加看看x y 的值。或者干脆 x=150,y=155赋值，看看下面能不能输出153.这句打错了，应该这样的：printf(\"X=%d,Y=%d\\n\",x,y);", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "你可以把int hhh(int n)函数单独拿出来，在你的机器上单独调试下，int hhh(int n) {     long a[10], i, j, x, y, t, sum;     x=pow(10, n-1);     y=pow(10, n);     printf(\"x=d%,y=%d\\\",x,y);//这里增加看看x y 的值。或者干脆 x=150,y=155赋值，看看下面能不能输出153.     for(i=x;i<y;i++)     {         t=i;         sum=0;//把sum赋初值放在这里         for(j=0;j<n;j++)         {             a[j]=t%10;             t=t/10;         }         for(j=0;j<n;j++)         {             sum+=pow(a[j],n);         }         if(sum==i)         {             printf(\"%ld \\t\",sum);// “%ld\\t\"在间加入一空格.         }     } }", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 6 楼 qzjhjxj 的回复：你把数组a[10]=｛0｝；赋初值再试试。还是不行", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "我刚刚在另一个电脑上运行了一下，是正确的， 但是在我的电脑上就是少一个数字", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "我的还是少一个数。。。不知道为什么。。。", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "没看到你的运行结果，我试运行了下，没有问题： 把int hhh()函数稍改了下：int hhh(int n) {     long a[10], i, j, x, y, t, sum;     x=pow(10, n-1);     y=pow(10, n);     for(i=x;i<y;i++)     {         t=i;         sum=0;//把sum赋初值放在这里         for(j=0;j<n;j++)         {             a[j]=t%10;             t=t/10;         }         for(j=0;j<n;j++)         {             sum+=pow(a[j],n);         }         if(sum==i)         {             printf(\"%ld \\t\",sum);// “%ld\\t\"在间加入一空格.         }     } }", "referer": "user-0"}, {"cid": "13", "user": "user-4", "content": "没错啊，你的运行结果是什么", "referer": "user-0"}]}
{"question": "用c对文件指定内容进行扫描提取特定内容  求帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 ctrigger的回复:[quote=引用 5 楼 yxj3515001663 的回复:][quote=引用 4 楼 ctrigger的回复:][quote=引用 3 楼 yxj3515001663 的回复:]我有个问题，为什么我c语言打程序的时候声明结构体struct dirent里面没有d_type啊  man文档中的定义： struct dirent {     ino_t          d_ino;       /* inode number */     off_t          d_off;       /* offset to the next dirent */     unsigned short d_reclen;    /* length of this record */     unsigned char  d_type;      /* type of file; not supported                                    by all file system types */     char           d_name[256]; /* filename */ };[/quote] 这不是系统定义的结构体吗[/quote]  d_type 注释中，就是有些文件系统不支持。我的windows和fedora系统都有。[/quote] 要是不支持的话就用不了吗？还是说可以定义使用", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 ctrigger的回复:[quote=引用 5 楼 yxj3515001663 的回复:][quote=引用 4 楼 ctrigger的回复:][quote=引用 3 楼 yxj3515001663 的回复:]我有个问题，为什么我c语言打程序的时候声明结构体struct dirent里面没有d_type啊  man文档中的定义： struct dirent {     ino_t          d_ino;       /* inode number */     off_t          d_off;       /* offset to the next dirent */     unsigned short d_reclen;    /* length of this record */     unsigned char  d_type;      /* type of file; not supported                                    by all file system types */     char           d_name[256]; /* filename */ };[/quote] 这不是系统定义的结构体吗[/quote]  d_type 注释中，就是有些文件系统不支持。我的windows和fedora系统都有。[/quote] 不支持的话就没办法使用了吗", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 5 楼 yxj3515001663 的回复:[quote=引用 4 楼 ctrigger的回复:][quote=引用 3 楼 yxj3515001663 的回复:]我有个问题，为什么我c语言打程序的时候声明结构体struct dirent里面没有d_type啊  man文档中的定义： struct dirent {     ino_t          d_ino;       /* inode number */     off_t          d_off;       /* offset to the next dirent */     unsigned short d_reclen;    /* length of this record */     unsigned char  d_type;      /* type of file; not supported                                    by all file system types */     char           d_name[256]; /* filename */ };[/quote] 这不是系统定义的结构体吗[/quote]  d_type 注释中，就是有些文件系统不支持。我的windows和fedora系统都有。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 4 楼 ctrigger的回复:[quote=引用 3 楼 yxj3515001663 的回复:]我有个问题，为什么我c语言打程序的时候声明结构体struct dirent里面没有d_type啊  man文档中的定义： struct dirent {     ino_t          d_ino;       /* inode number */     off_t          d_off;       /* offset to the next dirent */     unsigned short d_reclen;    /* length of this record */     unsigned char  d_type;      /* type of file; not supported                                    by all file system types */     char           d_name[256]; /* filename */ };[/quote] 这不是系统定义的结构体吗", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 3 楼 yxj3515001663 的回复:我有个问题，为什么我c语言打程序的时候声明结构体struct dirent里面没有d_type啊  man文档中的定义： struct dirent {     ino_t          d_ino;       /* inode number */     off_t          d_off;       /* offset to the next dirent */     unsigned short d_reclen;    /* length of this record */     unsigned char  d_type;      /* type of file; not supported                                    by all file system types */     char           d_name[256]; /* filename */ };", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:解决思路，仅供参考： 1. opendir 2. 循环readdir     a. 普通文件，比较文件名，扫描指定字符串 strstr函数。     c. 其他类型文件，忽略，continue。     b. 目录，递归opendir。 3. 结束 我有个问题，为什么我c语言打程序的时候声明结构体struct dirent里面没有d_type啊", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "解决思路，仅供参考： 1. opendir 2. 循环readdir     a. 普通文件，比较文件名，扫描指定字符串 strstr函数。     c. 其他类型文件，忽略，continue。     b. 目录，递归opendir。 3. 结束", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "首先要确定能访问这个文件，如果文件被程序互斥性打开，那后来的程序是打不开这个文件的。", "referer": "user-0"}]}
{"question": "如何创建richedit控件？（dev，用CreateWindow）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 Intel0011 的回复:[quote=引用 4 楼 六道佩恩 的回复:] 怪了，确实创建成功了。 不应该呀，我把动态库换成链接静态库，就没成功，不应该呀，它这个一定要用动态库吗？ 这个没深究，应该是要DLL，使用DLL的话，操作系统易于升级RichEdit，而程序不变就可以使用新的版本[/quote]  你了解win32的MCI吗？关于它支持的格式的问题，它是只支持那么几种格式？还是随驱动程序而定？ https://bbs.csdn.net/topics/398377944", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 4 楼 六道佩恩 的回复:怪了，确实创建成功了。 不应该呀，我把动态库换成链接静态库，就没成功，不应该呀，它这个一定要用动态库吗？ 这个没深究，应该是要DLL，使用DLL的话，操作系统易于升级RichEdit，而程序不变就可以使用新的版本", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 Intel0011 的回复:[quote=引用 楼主 六道佩恩 的回复:]创建失败，原因未知，用过MSFTEDIT_CLASS，仍然失败 RichEdit相对其他的控件来说，比较大，所以MS单独封装为一个DLL，使用时需要单独导入[/quote]  怪了，确实创建成功了。 不应该呀，我把动态库换成链接静态库，就没成功，不应该呀，它这个一定要用动态库吗？", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 楼主 六道佩恩 的回复:创建失败，原因未知，用过MSFTEDIT_CLASS，仍然失败 RichEdit相对其他的控件来说，比较大，所以MS单独封装为一个DLL，使用时需要单独导入", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "InitCommonControls  In order to use common controls on a dialog box, you need to call InitCommonControlsEx or AFXInitCommonControls before you create the dialog box.", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "VC下的例子 主要是RichEdit控件比较大的控件，而且是有不同版本的 需要先载入 hRichEditDll = LoadLibrary(_T(\"RICHED20\")); 才能使用 //* #define UNICODE #define _UNICODE //*/ #include <Windows.h> #include <tchar.h> #include <commctrl.h>  #pragma comment(lib, \"gdi32\") #pragma comment(lib, \"user32\") #pragma comment(lib, \"comctl32\")  #pragma comment(linker, \"/subsystem:windows\")  LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);  static HMODULE hRichEditDll = NULL; static HWND hRichEdit;  int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR szCmdLine, int iCmdShow) {    static TCHAR szAppName[] = TEXT(\"HelloWin\");    HWND         hwnd;    MSG          msg;    WNDCLASS     wndclass;    HDC          hdc;           RtlZeroMemory(&wndclass, sizeof(wndclass));    wndclass.style         = CS_HREDRAW | CS_VREDRAW;    wndclass.lpfnWndProc   = WndProc;    wndclass.hInstance     = hInstance;    wndclass.hIcon         = LoadIcon(NULL, TEXT(\"#32512\"));    wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);    wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);    wndclass.lpszMenuName  = NULL;    wndclass.lpszClassName = szAppName;     if (!RegisterClass(&wndclass))    {       MessageBox(NULL, TEXT(\"This program requires Windows NT series!\"), szAppName, MB_ICONERROR);       return -1;    }        InitCommonControls();    hRichEditDll = LoadLibrary(_T(\"RICHED20\"));              hwnd = CreateWindowEx(WS_EX_APPWINDOW,         // A tool window does not appear in the task bar or in the window that appears when the user presses ALT+TAB.                          szAppName,                  // window class name                          TEXT(\"The Hello Program\"),  // window caption                          WS_OVERLAPPEDWINDOW,        // window style                          100,//CW_USEDEFAULT,              // initial x position                          200,//CW_USEDEFAULT,              // initial y position                          320,//CW_USEDEFAULT,              // initial x size                          320,//CW_USEDEFAULT,              // initial y size                          NULL,                       // parent window handle                          NULL,                       // window menu handle                          hInstance,                  // program instance handle                          NULL);                      // creation parameters     hdc = GetDC(hwnd);    SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));     ShowWindow(hwnd, SW_SHOW);    UpdateWindow(hwnd);        {       BOOL bRet;       while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0)       {          if (bRet == -1)          {             MessageBox(NULL, TEXT(\"GetMessage Error.\"), TEXT(\"Message\"), MB_ICONERROR);             return -1;          }          else          {             TranslateMessage(&msg);             DispatchMessage(&msg);          }       }    }        SelectObject(hdc, GetStockObject(SYSTEM_FONT));    ReleaseDC(hwnd, hdc);        FreeLibrary(hRichEditDll);    hRichEditDll = NULL;     UnregisterClass(szAppName, hInstance);    return msg.wParam; }  LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {    HDC         hdc;    PAINTSTRUCT ps;    RECT        rect;        switch (message)    {       case WM_CREATE:          #ifdef UNICODE          #define RICHEDIT L\"RichEdit20W\"          #else          #define RICHEDIT  \"RichEdit20A\"          #endif          hRichEdit = CreateWindowEx(WS_EX_CLIENTEDGE, RICHEDIT, TEXT(\"\"),                                      WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL | ES_MULTILINE | ES_NOHIDESEL,                                     0, 0, 100, 100, hwnd, (HMENU)10, ((LPCREATESTRUCTA)lParam)->hInstance, NULL);                    return 0;       case WM_PAINT:          hdc = BeginPaint(hwnd, &ps);          GetClientRect(hwnd, &rect);          DrawText(ps.hdc, TEXT(\"Hello, Windows!\"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);                 EndPaint(hwnd, &ps);          return 0;       case WM_DESTROY:          PostQuitMessage(0);          return 0;    }    return DefWindowProc(hwnd, message, wParam, lParam); }", "referer": "user-0"}]}
{"question": "char类型的指针大小为4，为什么加1只加1呢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 lotte198666的回复:[quote=引用 2 楼 真相重于对错 的回复:]T* p; p=p+1; 意思是把p移动一个sizeof(T)位置 如果char** p 无论p=p+1,还是p++, p往后移动一个sizeof(char*) 也就是移动4个字节（32位），8个字节（64位系统） char类型指针大小是4   p=p+1不应该是加4吗怎么是加1呢[/quote] 加sizeof T不是加sizeof T*", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "pc+1就是加一个字节（地址偏于一个字节） pc++才会加4个字节（地址前进一个指针单位） 这是有区别的，否则想地址偏移1个字节就没法实现了", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 真相重于对错 的回复:T* p; p=p+1; 意思是把p移动一个sizeof(T)位置 如果char** p 无论p=p+1,还是p++, p往后移动一个sizeof(char*) 也就是移动4个字节（32位），8个字节（64位系统） char类型指针大小是4   p=p+1不应该是加4吗怎么是加1呢", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "char类型指针大小是4   p=p+1不应该是加4吗怎么是加1呢", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "char类型指针大小是4加我1不是加4吗", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "T* p; p=p+1; 意思是把p移动一个sizeof(T)位置 如果char** p 无论p=p+1,还是p++, p往后移动一个sizeof(char*) 也就是移动4个字节（32位），8个字节（64位系统）", "referer": "user-0"}]}
{"question": "新手求问，C语言中n++<=2中是n++还是n最终与2比较？会和优先级有冲突吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "https://blog.csdn.net/Minikinfish/article/details/107520644", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "n++是先运算再++。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "++n：是先加1后运算； n++：是先运算后加1；", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "n++<=2是个表达式，n++是求出表达式的值以后n才自增，所以<=的时候用的是n来比较", "referer": "user-0"}]}
{"question": "这个简单C程序的第二个scanf为什么不起作用？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "起作用了，第二个scanf接收的是'\\n'，%c匹配'\\n'，这个上一个输入之后留在输入缓存里的'\\n'", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你想要的效果应该是下面的这个吧    int main() {     int a;     char z;     scanf(\"%d\",&a);     printf(\"%d\\n\",a);     //printf(\"b\");     //z=getchar();     fflush(stdin);     scanf(\"%c\",&z);     printf(\"%c\",z);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "第一个scanf你把输入值赋给了a,然后打印字符b怎么可能会有结果的啊 无论你输入的是什么,打印的都是字符b啊,第二个scanf也一样,中间还没清空缓冲区", "referer": "user-0"}]}
{"question": "C语言代码，输入n1 n2 m  三个数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "大神，多谢，我看看我的哪里出问题惹", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "void Test(void) { \tint n1 = 0; \tint n2 = 0;  \tint m = 0;  \tscanf_s(\"%d\", &n1); \tscanf_s(\"%d\", &n2); \tscanf_s(\"%d\", &m);  \tif (m <= 1 || 9 <= m || n2 <= n1) \t{ \t\tprintf(\"err\\r\\n\"); \t\treturn; \t}  \tfor (int i = n1, j = 0; i < n2 + 1; ++i, ++j) \t{ \t\tif (i % m == 0) \t\t{ \t\t\tprintf(\"_ \"); \t\t} \t\telse \t\t{ \t\t\tint bit = 0; \t\t\tint num = i; \t\t\twhile (num != 0) \t\t\t{ \t\t\t\tbit = num % 10; \t\t\t\tnum /= 10;  \t\t\t\tif (bit == m) \t\t\t\t\tbreak; \t\t\t}  \t\t\tif (bit == m) \t\t\t\tprintf(\"_ \"); \t\t\telse \t\t\t\tprintf(\"%d \", i); \t\t}  \t\tif ((j + 1) % 10 == 0) \t\t\tprintf(\"\\r\\n\"); \t}  \tprintf(\"\\r\\n\"); }  12 210 5 12 13 14 _ 16 17 18 19 _ 21 22 23 24 _ 26 27 28 29 _ 31 32 33 34 _ 36 37 38 39 _ 41 42 43 44 _ 46 47 48 49 _ _ _ _ _ _ _ _ _ _ _ 61 62 63 64 _ 66 67 68 69 _ 71 72 73 74 _ 76 77 78 79 _ 81 82 83 84 _ 86 87 88 89 _ 91 92 93 94 _ 96 97 98 99 _ 101 102 103 104 _ 106 107 108 109 _ 111 112 113 114 _ 116 117 118 119 _ 121 122 123 124 _ 126 127 128 129 _ 131 132 133 134 _ 136 137 138 139 _ 141 142 143 144 _ 146 147 148 149 _ _ _ _ _ _ _ _ _ _ _ 161 162 163 164 _ 166 167 168 169 _ 171 172 173 174 _ 176 177 178 179 _ 181 182 183 184 _ 186 187 188 189 _ 191 192 193 194 _ 196 197 198 199 _ 201 202 203 204 _ 206 207 208 209 _ 请按任意键继续. . .", "referer": "user-0"}]}
{"question": "C语言小项目出了点问题,求各位大佬指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "这里不是指向了这个定义出来的数组了吗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "购买完后,再次打印出来,商品的部分没有出错啊,是玩家的金币出现了问题", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "Prop props[];  //道具数组  问题在这里，Init的时候没有对其申请空间不赋值，这里的props是一个指针，在Init里被赋值为NULL，没有指向什么内容。", "referer": "user-0"}]}
{"question": "请问这个报错怎么解决", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "至少得有个typedef int ElemType;这样的语句吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "想到了第一次学数据结构的自己，书上的是伪代码，直接拿过来编译是不行的。ElemType代表元素类型，是一个统称，具体的可以写成int char float等等，Status也是统称", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "第7行 ElemType 是用来说明的，使用的时候要换成具体类型，比如int char等等。还有*=elem把=去掉。 第11行字符打错了I换成小写i", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "Status未定义，ElemType未定义。楼主没有定义怎么可以直接使用呢?拷贝别人的代码吗？那也拷全了。", "referer": "user-0"}]}
{"question": "一根29cm长的尺子，只允许在它上面刻7个刻度。若要用它能量出1~ 29cm的各种整长度，刻度应如何选择？ ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "2楼写得挺好的，就是暴力，思路很清晰啊，怒赞", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这道题我始终觉得有bug，如果说是截成7段，那可能ls都满足，但题目只要求划刻度，要是这样，我觉得划个1就够了 1=1 2=1+1 3=1+1+1 。。。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "如果是截成7段，那确实没段只能用一次，如果是划刻度，就没这个限制了，因为每次都是用同一把尺子先量一个刻度，再量一个刻度，这样的话，同一个刻度重复使用没问题。 如果是截段，那也没规定每次测量只用几段，所以任何一种能组合出1-10的组合就能满足需求 比如 1 3 5 10 10 （如果非要7段，把后两个10调成两段即可） 1=1 2=3-1 3=3 4=3+1 5=5 6=5+1 7=5+3-1 8=5+3 9=5+3+1 10=10 11=10+1 12=10+3-1 13=10+3 14=10+3+1 15=10+5 16=10+5+1 17=10+5+3-1 18=10+5+3 19=10+5+3+1 20=10+10 。。。 29=10+10+5+3+1  所以觉得本题有bug，题目需求不严谨", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 4 楼 qybao 的回复:这道题我始终觉得有bug，如果说是截成7段，那可能ls都满足，但题目只要求划刻度，要是这样，我觉得划个1就够了 1=1 2=1+1 3=1+1+1 。。。 应该是只允许一次，其实按二进制位考虑即可，比29大且最小的2的n次幂是32 ，2^5 所以用1，2，4，8，16，29既可以量出所有的长度  1=1(b)=1 2=10(b)=2； 3=11(b)=2+1; 4=100(b)=4; 5=101(b)=4+1 6=110(b)=4+2 7=111(b)=1+2+4; 8=1000(b)=8; 9=1001(b)=8+1 10=1010(b)=8+2 11=1011(b)=8+2+1； 12=1100(b)=8+4 13=1101(b)=8+4+1 14=1110(b)=8+4+2 ..... 27=11011(b)=16+8+2+1 28=11100(b)=16+8+4; 29=11101(b)=29or16+8+4+1;", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "仅供参考。代码如下： #include <stdio.h>  int main(void) { \tint flag, mark[9]; \tint a, b, c, d, e, f, g; \tint i, j; \tint count = 0; \t \tmark[0] = 0; \tmark[8] = 29; \t \tfor(a=1; a<23; a++) \t{ \t\tmark[1] = a; \t\tfor(b=a+1; b<24; b++) \t\t{ \t\t\tmark[2] = b; \t\t\tfor(c=b+1; c<25; c++) \t\t\t{ \t\t\t\tmark[3] = c; \t\t\t\tfor(d=c+1; d<26; d++) \t\t\t\t{ \t\t\t\t\tmark[4] = d; \t\t\t\t\tfor(e=d+1; e<27; e++) \t\t\t\t\t{ \t\t\t\t\t\tmark[5] = e; \t\t\t\t\t\tfor(f=e+1; f<28; f++) \t\t\t\t\t\t{ \t\t\t\t\t\t\tmark[6] = f; \t\t\t\t\t\t\tfor(g=f+1; g<29; g++) \t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\tmark[7] = g; \t\t\t\t\t\t\t\t \t\t\t\t\t\t\t\tflag = 1; \t\t\t\t\t\t\t\t \t\t\t\t\t\t\t\tfor(i=0; i<8; i++) \t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\tfor(j=i+1; j<9; j++) \t\t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\t\tflag |= (1 << (mark[j] - mark[i])); \t\t\t\t\t\t\t\t\t} \t\t\t\t\t\t\t\t} \t\t\t\t\t\t\t\t \t\t\t\t\t\t\t\tif(flag == 0x3fffffff) \t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\tprintf(\"NO.%d:\\t%d\\t%d\\t%d\\t%d\\t%d\\t%d\\t%d\\t\\n\", ++count, a, b, c, d, e, f, g); \t\t\t\t\t\t\t\t} \t\t\t\t\t\t\t} \t\t\t\t\t\t} \t\t\t\t\t} \t\t\t\t} \t\t\t} \t\t} \t} \t \treturn 0; }   运行结果如下： E:\\Workspace>tcc -run demo.c NO.1:   1       2       14      18      21      24      27 NO.2:   1       3       6       13      20      24      28 NO.3:   1       4       10      16      22      24      27 NO.4:   1       5       9       16      23      26      28 NO.5:   2       5       7       13      19      25      28 NO.6:   2       5       8       11      15      27      28", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 1 1 1                                  1          1       1       1       1    1   // 一根29cm长的尺子，只允许在它上面刻7个刻度。若要用它能量出1~29cm的各种整长度，刻度应如何选择？ void RulerResult(void) { \tstruct \t{ \t\tbool test; \t\tint maxID; \t\tint minID; \t} \tresult[29];  \tint mark[9]; \tmark[0] = 0; \tmark[8] = 29;  \tfor (int a = 1; a < 23; ++a) \t{ \t\tfor (int b = a + 1; b < 24; ++b) \t\t{ \t\t\tfor (int c = b + 1; c < 25; ++c) \t\t\t{ \t\t\t\tfor (int d = c + 1; d < 26; ++d) \t\t\t\t{ \t\t\t\t\tfor (int e = d + 1; e < 27; ++e) \t\t\t\t\t{ \t\t\t\t\t\tfor (int f = e + 1; f < 28; ++f) \t\t\t\t\t\t{ \t\t\t\t\t\t\tfor (int g = f + 1; g < 29; ++g) \t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\tmark[1] = a; \t\t\t\t\t\t\t\tmark[2] = b; \t\t\t\t\t\t\t\tmark[3] = c; \t\t\t\t\t\t\t\tmark[4] = d; \t\t\t\t\t\t\t\tmark[5] = e; \t\t\t\t\t\t\t\tmark[6] = f; \t\t\t\t\t\t\t\tmark[7] = g;  \t\t\t\t\t\t\t\tmemset(result, false, sizeof(result));  \t\t\t\t\t\t\t\tfor (int i = 0; i < 8; ++i) \t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\tfor (int j = i + 1; j < 9; ++j) \t\t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\t\tint id = mark[j] - mark[i] - 1; \t\t\t\t\t\t\t\t\t\tresult[id].test = true; \t\t\t\t\t\t\t\t\t\tresult[id].maxID = mark[j]; \t\t\t\t\t\t\t\t\t\tresult[id].minID = mark[i]; \t\t\t\t\t\t\t\t\t} \t\t\t\t\t\t\t\t}  \t\t\t\t\t\t\t\tbool allTest = true; \t\t\t\t\t\t\t\tfor (int i = 0; i < 29; ++i) \t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\tif (result[i].test) \t\t\t\t\t\t\t\t\t\tcontinue;  \t\t\t\t\t\t\t\t\tallTest = false; \t\t\t\t\t\t\t\t\tbreak; \t\t\t\t\t\t\t\t}  \t\t\t\t\t\t\t\tif (allTest) \t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\tfor (int i = 0; i < 9; ++i) \t\t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\t\tprintf(\"%d \", mark[i]); \t\t\t\t\t\t\t\t\t}  \t\t\t\t\t\t\t\t\tprintf(\"\\r\\n\");  \t\t\t\t\t\t\t\t\tfor (int i = 0; i < 29; ++i) \t\t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\t\tprintf(\"%d = %d - %d\\r\\n\", i + 1, result[i].maxID, result[i].minID); \t\t\t\t\t\t\t\t\t}  \t\t\t\t\t\t\t\t\treturn; \t\t\t\t\t\t\t\t} \t\t\t\t\t\t\t} \t\t\t\t\t\t} \t\t\t\t\t} \t\t\t\t} \t\t\t} \t\t} \t} }   0 1 2 14 18 21 24 27 29 1 = 2 - 1 2 = 29 - 27 3 = 27 - 24 4 = 18 - 14 5 = 29 - 24 6 = 27 - 21 7 = 21 - 14 8 = 29 - 21 9 = 27 - 18 10 = 24 - 14 11 = 29 - 18 12 = 14 - 2 13 = 27 - 14 14 = 14 - 0 15 = 29 - 14 16 = 18 - 2 17 = 18 - 1 18 = 18 - 0 19 = 21 - 2 20 = 21 - 1 21 = 21 - 0 22 = 24 - 2 23 = 24 - 1 24 = 24 - 0 25 = 27 - 2 26 = 27 - 1 27 = 29 - 2 28 = 29 - 1 29 = 29 - 0 请按任意键继续. . .", "referer": "user-0"}]}
{"question": "[求助]clion 无法debug", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "解决了吗请问，能告知一下怎么解决的吗", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "请问最后怎么解决的？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 2 楼 Ricardo_PAO 的回复:之前用PYcharm，挺喜欢这个公司出的东西的，然后用的clion。vs太大了  其实，VS只有一个缺点太大。其他都是优点。现在的电脑配置越来越牛，vs大一点也算不上缺点了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "这点我要反驳，它除了大还非要装C盘，我就看不惯它非要住C盘这点，其他都还好", "referer": "user-3"}, {"cid": "5", "user": "user-0", "content": "之前用PYcharm，挺喜欢这个公司出的东西的，然后用的clion。vs太大了", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "visual studio 2019，号称宇宙第一IDE，功能强大，调试方便。", "referer": "user-0"}]}
{"question": "[求助]关于稍复杂计算器", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第二次输入时，menu函数里面way得到的值应该是个'\\n'回车，所以就不正确了。", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这种题目，就自己做了，没必要发出来。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "作业自己做", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 2 楼 四斋的回复:输入天数用7求余，然后用if语句打印各个星期试试 或者直接打印结果", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "输入天数用7求余，然后用if语句打印各个星期试试", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "#include <stdio.h>  int main(void) { \tprintf(\"%d\\n\", 2019%7); }", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  int main(void) {     int i = 0;     int father_age, son_age;      father_age = 40;     son_age = 6;     while (1) {         father_age = 40 + i;         son_age = 6 + i;          if (father_age / son_age == 2 && father_age % son_age == 0) {             printf(\"%d, %d\\n\", father_age, son_age);             break;         }         i++;     }      printf(\"%d\\n\", i); #if 0     for(i=1; i<40; i++)     {         p = 40 +i;         s = 6 +i;          if(p == 2*s)         {             printf(\"Years:\\t%d\\n\", i);         }     } #endif } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "运行结果，28年。仅供参考。  #include <stdio.h>  int main(void) { \tint i, p, s; \t \tfor(i=1; i<40; i++) \t{ \t\tp = 40 + i; \t\ts = 6 + i; \t\t \t\tif(p == 2*s) \t\t{ \t\t\tprintf(\"Years:\\t%d\\n\", i); \t\t\tbreak; \t\t} \t} }", "referer": "user-0"}]}
{"question": "socket 编程，何向客户端传送图片文件？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "okay, I got it.  #define byte char Thanks.", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 火花20180731的回复:socket并不在乎你传递得内容是啥，因为对于计算机而言，所有的数据都是二进制流，使用char类型仅仅是因为内存读写的最小单位是字节，而sizeof(char)为1字节。 也就是说，图片文件、视频文件都是以byte为最小单位？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 7 楼 火花20180731 的回复:socket并不在乎你传递得内容是啥，因为对于计算机而言，所有的数据都是二进制流，使用char类型仅仅是因为内存读写的最小单位是字节，而sizeof(char)为1字节。 是的。都是二进制，而我们所谓说的各种类型是为了我们的方便，计算机不认识这些，只认识0101的二进制数", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "如果是linux系统的话，sendfile函数效率很高。  #include <sys/sendfile.h> ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "socket并不在乎你传递得内容是啥，因为对于计算机而言，所有的数据都是二进制流，使用char类型仅仅是因为内存读写的最小单位是字节，而sizeof(char)为1字节。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "socket并不在乎你传递得内容是啥，因为对于计算机而言，所有的数据都是二进制流，使用char类型仅仅是因为内存读写的最小单位是字节，而sizeof(char)为1字节。", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "数据以二进制传递，不管字面意思。传文件你只管传数据就可以，文件表达了什么你不用解析。 一个char表示一个数值，就像‘@’编码是0x40，传到另一端也是0x40，对方是按照char来解释还是按照数值来解释你不必操心，你只负责传递正确的值就可以了。", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "二进制读取文件，放入buf，然后发送。char类型可以的。", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "引用 2 楼 陳錄生 的回复:好像这篇文章跟你说的方式一样，但是用char 字符似乎不合理，应该定义什么变量？     char buffer[BUF_SIZE] = {0};  //缓冲区     int nCount;     while( (nCount = fread(buffer, 1, BUF_SIZE, fp)) > 0 ){         send(clntSock, buffer, nCount, 0);     } 用u8 buffer[BUF_SIZE];也行  合不合理为什么不试试呢？别人怎么说不如自己亲自试试～", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "好像这篇文章跟你说的方式一样，但是用char 字符似乎不合理，应该定义什么变量？     char buffer[BUF_SIZE] = {0};  //缓冲区     int nCount;     while( (nCount = fread(buffer, 1, BUF_SIZE, fp)) > 0 ){         send(clntSock, buffer, nCount, 0);     }", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "按照正常的传输文件即可，发送端打开文件，读取文件，最后发送数据到对端； 接收端把数据接收之后写入文件，接收完关闭文件。  视频和图片都可以采用这个方式", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 ctrigger 的回复:仅供参考。代码如下： #include <stdio.h>  int main(void) { \tint i, j; \t \tfor(i=1; i<=500; i++) \t{ \t\t/* 连续数为奇数 */ \t\tif(i%2 == 1) \t\t{ \t\t\tif(500%i != 0) continue; \t\t\t \t\t\tprintf(\"%d:\\t\", i); \t\t\tfor(j=500/i - i/2; j<=500/i + i/2; j++) \t\t\t{ \t\t\t\tprintf(\"%5d\", j); \t\t\t} \t\t} \t\t/* 连续数为奇数 */ \t\telse \t\t{ \t\t\tif(500%i != i/2) continue;  \t\t\tprintf(\"%d:\\t\", i); \t\t\tfor(j=500/i - (i-1)/2; j<=500/i + i/2; j++) \t\t\t{ \t\t\t\tprintf(\"%5d\", j); \t\t\t} \t\t} \t\tprintf(\"\\n\"); \t} }   运行结果 1:        500 5:         98   99  100  101  102 8:         59   60   61   62   63   64   65   66 25:         8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32 40:        -7   -6   -5   -4   -3   -2   -1    0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32 125:      -58  -57  -56  -55  -54  -53  -52  -51  -50  -49  -48  -47  -46  -45  -44  -43  -42  -41  -40  -39  -38  -37  -36  -35  -34  -33  -32  -31  -30  -29  -28  -27  -26  -25  -24  -23  -22  -21  -20  -19  -18  -17  -16  -15  -14  -13  -12  -11  -10   -9   -8   -7   -6   -5   -4   -3   -2   -1    0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40   41   42   43   44   45   46   47   48   49   50   51   52   53   54   55   56   57   58   59   60   61   62   63   64   65   66 200:      -97  -96  -95  -94  -93  -92  -91  -90  -89  -88  -87  -86  -85  -84  -83  -82  -81  -80  -79  -78  -77  -76  -75  -74  -73  -72  -71  -70  -69  -68  -67  -66  -65  -64  -63  -62  -61  -60  -59  -58  -57  -56  -55  -54  -53  -52  -51  -50  -49  -48  -47  -46  -45  -44  -43  -42  -41  -40  -39  -38  -37  -36  -35  -34  -33  -32  -31  -30  -29  -28  -27  -26  -25  -24  -23  -22  -21  -20  -19  -18  -17  -16  -15  -14  -13  -12  -11  -10   -9   -8   -7   -6   -5   -4   -3   -2   -1    0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40   41   42   43   44   45   46   47   48   49   50   51   52   53   54   55   56   57   58   59   60   61   62   63   64   65   66   67   68   69   70   71   72   73   74   75   76   77   78   79   80   81   82   83   84   85   86   87   88   89   90   91   92   93   94   95   96   97   98   99  100  101  102  如果一个整数不算连续数的话，我写的这个代码第7行的循环应该从2开始。 for(i=1; i<=500; i++) ——》for(i=2; i<=500; i++)", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "和为500，那么第一个数必须比250小  for (int first = 0; first < 250; first++) { ... } 然后对每个 first连续加，直到 >= 500 最后，判断和是不是500。 如果是，你成功了 如果不是，下一个first 这段代码就自己写吧  勤快些，有好处。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 楼主 weixin_52516354 的回复:编写程序，找出连续整数之和是500的所有整数序列。 没有什么限制，这样太多了啊", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你好懒哦......", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "仅供参考。代码如下： #include <stdio.h>  int main(void) { \tint i, j; \t \tfor(i=1; i<=500; i++) \t{ \t\t/* 连续数为奇数 */ \t\tif(i%2 == 1) \t\t{ \t\t\tif(500%i != 0) continue; \t\t\t \t\t\tprintf(\"%d:\\t\", i); \t\t\tfor(j=500/i - i/2; j<=500/i + i/2; j++) \t\t\t{ \t\t\t\tprintf(\"%5d\", j); \t\t\t} \t\t} \t\t/* 连续数为奇数 */ \t\telse \t\t{ \t\t\tif(500%i != i/2) continue;  \t\t\tprintf(\"%d:\\t\", i); \t\t\tfor(j=500/i - (i-1)/2; j<=500/i + i/2; j++) \t\t\t{ \t\t\t\tprintf(\"%5d\", j); \t\t\t} \t\t} \t\tprintf(\"\\n\"); \t} }   运行结果 1:        500 5:         98   99  100  101  102 8:         59   60   61   62   63   64   65   66 25:         8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32 40:        -7   -6   -5   -4   -3   -2   -1    0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32 125:      -58  -57  -56  -55  -54  -53  -52  -51  -50  -49  -48  -47  -46  -45  -44  -43  -42  -41  -40  -39  -38  -37  -36  -35  -34  -33  -32  -31  -30  -29  -28  -27  -26  -25  -24  -23  -22  -21  -20  -19  -18  -17  -16  -15  -14  -13  -12  -11  -10   -9   -8   -7   -6   -5   -4   -3   -2   -1    0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40   41   42   43   44   45   46   47   48   49   50   51   52   53   54   55   56   57   58   59   60   61   62   63   64   65   66 200:      -97  -96  -95  -94  -93  -92  -91  -90  -89  -88  -87  -86  -85  -84  -83  -82  -81  -80  -79  -78  -77  -76  -75  -74  -73  -72  -71  -70  -69  -68  -67  -66  -65  -64  -63  -62  -61  -60  -59  -58  -57  -56  -55  -54  -53  -52  -51  -50  -49  -48  -47  -46  -45  -44  -43  -42  -41  -40  -39  -38  -37  -36  -35  -34  -33  -32  -31  -30  -29  -28  -27  -26  -25  -24  -23  -22  -21  -20  -19  -18  -17  -16  -15  -14  -13  -12  -11  -10   -9   -8   -7   -6   -5   -4   -3   -2   -1    0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40   41   42   43   44   45   46   47   48   49   50   51   52   53   54   55   56   57   58   59   60   61   62   63   64   65   66   67   68   69   70   71   72   73   74   75   76   77   78   79   80   81   82   83   84   85   86   87   88   89   90   91   92   93   94   95   96   97   98   99  100  101  102", "referer": "user-0"}]}
{"question": "C语言问题求解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我自己做的也是感觉这四个选项全对，应该是题的问题了，感谢大佬们的解答", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "全对  出题人水平太低 没搞懂if而已 习惯就好了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主可以再提供更多信息，所谓的错误的if语句是什么错误；这些选项都没什么问题。 可以再细化一下这个错误的标准。 A是赋值不是比较，但是赋值之后就和D是一样的了。C也是一样，A是赋值，C是做差之后和D一样：判断一个值是否为真", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "A\\B\\C\\D四项全对，都符合C语言语法，没毛病。。。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "算数运算表达式 赋值运算表达式 逻辑运算表达式 都是表达式的一种，都可以当做if的条件", "referer": "user-0"}]}
{"question": "为什么有一个是错的，大佬帮帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if(pattern[n]=='\\0') { flag_1=1; index=k;//这里加一句 break; }  printf(\"%s\",string+(index+1));这一句把index+1改成index 试试看对不对", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h>  char string[1000000],pattern[1000000];  int main() {     int n;     int i, j, k;  #if  1     scanf(\"%s\",string);     scanf(\"%d\",&n);      i = 0;     while (i < n) {          scanf(\"%s\", pattern);          j = 0;         while (string[j]) {             if (string[j] == pattern[0]) {                 for (k = 0; string[j+k] && pattern[k]; k++)                     if (string[j+k] != pattern[k])                         break;                 if (pattern[k] == 0 && string[j+k] != 0) {                     puts(string+j);                     break;                 }                 if (string[j+k] == 0) {                     printf(\"Not found!\\n\");                     break;                 }             }             j++;         }         if (string[j] == 0)             printf(\"Not found!\\n\");         i++;     } #else     char string[1000000],pattern[1000000];     int n;     scanf(\"%s\",string);     scanf(\"%d\",&n);     for(int i=0; i<n; i++)     {         int m=0,n=0,index=0,flag=0,flag_1=0;         scanf(\"%s\",pattern);         while(string[m]!='\\0')         {             if(string[m]==pattern[0])             {                 for(int k=m+1,n=1;; k++,n++)                 {                     if(string[k]=='\\0'&&pattern[n]!='\\0')                     {                         flag=1;                         break;                     }                     if(pattern[n]=='\\0')                     {                         flag_1=1;                         break;                     }                     if(string[k]==pattern[n])                         index=k;                     else                         break;                 }             }             m++;             if(flag||flag_1)                 break;         }         if(flag_1)         {             printf(\"%s\",pattern);             printf(\"%s\",string+(index+1));             printf(\"\\n\");         }         else             printf(\"Not Found\\n\");     } #endif     return 0; }  供参考～", "referer": "user-0"}]}
{"question": "请问字符串数组用scanf写入时提示访问冲突是什么原因？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 自信男孩 的回复: scanf_s(\"%s\", str, 6);  scanf_s和scanf的区别建议楼主搜一下，然后学习一下吧 haode!!", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "scanf_s(\"%s\", str, 6);  scanf_s和scanf的区别建议楼主搜一下，然后学习一下吧", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用printf(\"%s\", str[cnt]);这句输出因改为： printf(\"%c\", str[cnt]);", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:scanf_s(\"%5s\",str,6); https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/scanf-s-scanf-s-l-wscanf-s-wscanf-s-l?view=msvc-160&viewFallbackFrom=vs-2019 非常感谢！", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "scanf_s(\"%5s\",str,6); https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/scanf-s-scanf-s-l-wscanf-s-wscanf-s-l?view=msvc-160&viewFallbackFrom=vs-2019", "referer": "user-0"}]}
{"question": "为什么输出结果第一个不可以是1，2，3", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1,2,3 1,2,4 1,2,5 1,3,2 1,3,4 1,3,5 1,4,2 1,4,3 1,4,5 1,5,2 1,5,3 1,5,4 2,3,4 2,3,5 2,4,3 2,4,5 2,5,3 2,5,4 3,2,4 3,2,5 3,4,2 3,4,5 3,5,2 3,5,4 4,2,3 4,2,5 4,3,2 4,3,5 4,5,2 4,5,3  这是输出结果～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "虽然你的代码不太规范，但第一个肯定是1，2，3。。", "referer": "user-0"}]}
{"question": "\"POINTF*\"类型的实参与“IB_POINT*”的形参不兼容", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "同样的MFC工程，在自己电脑上编译运行都是ok的。换了台电脑，就显示很多未定义标识符，而且错误大多都是来自系统头文件。这台电脑一开始没装C++，难道是我没装完整?稍微对比了一下，也没发现那个是缺少的啊。电脑重启了一遍，也还是这样。    能不能帮帮忙，顺带也把这个问题也解决了啊。感谢各位了。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "类型不匹配，传递指针，如果类型不一样，那么这个指针控制的内存区域是不一样的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 赵4老师 的回复:IB_POINT ibps1[9],ibps2[9]; for (int i=0;i<9;i++) {  ibps1[i].dX=pDlg->PixlPoint[i].x;  ibps1[i].dY=pDlg->PixlPoint[i].y;  ibps2[i].dX=pDlg->PhyPoint[i].x;  ibps2[i].dY=pDlg->PhyPoint[i].y; } 将第哦啊用函数中的参数 pDlg->PixlPoint替换为ibps1， pDlg->PhyPoint替换为ibps2     谢谢，我刚刚自己解决了。方法差不多就是您这样的。直接将一开始定义的POINTF修改为IB_POINT。就直接可以了。   后续稍做修改就跑通了。打断点也确实看到数据流通也没有问题。  不过还是谢谢你了哈。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "IB_POINT ibps1[9],ibps2[9]; for (int i=0;i<9;i++) {  ibps1[i].dX=pDlg->PixlPoint[i].x;  ibps1[i].dY=pDlg->PixlPoint[i].y;  ibps2[i].dX=pDlg->PhyPoint[i].x;  ibps2[i].dY=pDlg->PhyPoint[i].y; } 将第哦啊用函数中的参数 pDlg->PixlPoint替换为ibps1， pDlg->PhyPoint替换为ibps2", "referer": "user-0"}]}
{"question": "字符转换", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这一句 for(m=0;m<l;m++) { if(a[m]==a[i]) break;} 和这一句 if(a[i]!=a[m]) break; 有冲突，前一句a[m]==a[i]后跳出执行第二句，a[m]==a[i]，也就是第二句条件始终不会成立; 所以a[i]=97+k会一直循环到最后，也就是'z'。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你的代码要干什么？", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:因为在第二个for循环里，一直在97+k，最后把97+25赋值给了a[i]。相当于执行了a[i] = 97+k;26次，a[i]只保存最后一次的修改，最后一次的修改就是97+25  这句下面的代码都是冗余的，没有意义的；  如果将第三个for循环外的 if (a[m] != a[i])     break; 改成： f (a[m] == a[i])     break; 还能提前退出第二个for的循环，而a[i] = 97+k;这个k可能是0~25之间的某个数； 我知道问题了，for语句的m是局部变量 怎么把它变成全局啊", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我的想法是如果第一个break执行，第二个break就不会执行；如果第一个break不执行，第二个break就执行。感觉没毛病诶", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "因为在第二个for循环里，一直在97+k，最后把97+25赋值给了a[i]。相当于执行了a[i] = 97+k;26次，a[i]只保存最后一次的修改，最后一次的修改就是97+25  这句下面的代码都是冗余的，没有意义的；  如果将第三个for循环外的 if (a[m] != a[i])     break; 改成： f (a[m] == a[i])     break; 还能提前退出第二个for的循环，而a[i] = 97+k;这个k可能是0~25之间的某个数；", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 9 楼  的回复:[quote=引用 8 楼 的回复:]问一下for语句用了break后它的变量会怎么样？ 比如for(i=0;i<100;i++)  中途用了break 跳出循环后i是多少 #include<stdio.h> #include<string.h> int main() {     char english[2][20]={\"red\",\"white\"};     char chinese[2][20]={\"红色\",\"白色\"};     char a[20];     int i;     scanf(\"%s\",a);     for(i=0;i<2;i++)     {         if(strcmp(a,english[i])==0)         break;         if(strcmp(a,chinese[i])==0)         break;            }     if(i<2)     {     printf(\"%s   \",english[i]);     printf(\"%s\\n\",chinese[i]);     }     if(i=2)     printf(\"not found\"); }  为什么无论如何都会输出not found[/quote]   if(i=2) 这样的表达式怎么都会输出if后面的语句。因为这个是恒成立的。i=2，2是真。应该是i == 2吧，要细心一些哦～", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "if(i=2) 改成if(i==2)", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "引用 8 楼 的回复:问一下for语句用了break后它的变量会怎么样？ 比如for(i=0;i<100;i++)  中途用了break 跳出循环后i是多少 break之前的值，不会再自增", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 8 楼 的回复:问一下for语句用了break后它的变量会怎么样？ 比如for(i=0;i<100;i++)  中途用了break 跳出循环后i是多少 #include<stdio.h> #include<string.h> int main() {     char english[2][20]={\"red\",\"white\"};     char chinese[2][20]={\"红色\",\"白色\"};     char a[20];     int i;     scanf(\"%s\",a);     for(i=0;i<2;i++)     {         if(strcmp(a,english[i])==0)         break;         if(strcmp(a,chinese[i])==0)         break;            }     if(i<2)     {     printf(\"%s   \",english[i]);     printf(\"%s\\n\",chinese[i]);     }     if(i=2)     printf(\"not found\"); }  为什么无论如何都会输出not found", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "问一下for语句用了break后它的变量会怎么样？ 比如for(i=0;i<100;i++)  中途用了break 跳出循环后i是多少", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "没明白想要把‘?’换成什么， 试试把这一句 if(a[m]==a[i]) break; 改成 if((a[m]==a[i])&&(m!=i)) break; 你想要的结果是不是这个样子", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "引用 3 楼  的回复:我的想法是如果第一个break执行，第二个break就不会执行；如果第一个break不执行，第二个break就执行。感觉没毛病诶 外面再用m可能已经越界了。f (m < l && a[m] == a[i])     break;  确保m小于l，否则越界～", "referer": "user-0"}]}
{"question": "如何定义一个函数指针数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你再想想函数指针怎么定义的？ int func(int,int); int (*ptr//函数指针名)(int,int); ptr=&func; 所以[] 必须放到ptr后面", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "(int (*)(int,int)) a[10] 这个为什么错的，因为 (int (*)(int,int))  他不是类型而是一个定义一个类型的指针", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "C++11 方便多了 int func(int ,int); decltype(func)* a[1]{func};", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 1 楼 自信男孩 的回复:typedef int (*pfunc)(int, int); pfunc a[10]; 这样试试；  或者  int (*a[10])(int, int); 这样定义也是可以的。  以上都是定义指针数组。 定义函数指针数组～", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "typedef int (*pfunc)(int, int); pfunc a[10]; 这样试试；  或者  int (*a[10])(int, int); 这样定义也是可以的。  以上都是定义指针数组。", "referer": "user-0"}]}
{"question": "数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不难的题目吧，为啥不自己先尝试着写写呢？", "referer": "user-0"}]}
{"question": "求大佬帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 qybao的回复:动态申请内存 for example  int main( ) {     int n, i, *a;     printf(\"请输入n:\");     scanf(\"%d\", &n);     a = (int*)malloc(sizeof(int)*n);     printf(\"请输入n个变量的值:\");     for (i=0; i<n; i++) {         scanf(\"%d\", &a[i]);     }     //计算处理，LZ自己加吧          //打印结果     for (i=0; i<n; i++) {         printf(\"a[%d]=%d \", i, a[i]);     }          free(a);     return 0; } 多谢大佬！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:做什么计算？ 就是四则运算那种", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "动态申请内存 for example  int main( ) {     int n, i, *a;     printf(\"请输入n:\");     scanf(\"%d\", &n);     a = (int*)malloc(sizeof(int)*n);     printf(\"请输入n个变量的值:\");     for (i=0; i<n; i++) {         scanf(\"%d\", &a[i]);     }     //计算处理，LZ自己加吧          //打印结果     for (i=0; i<n; i++) {         printf(\"a[%d]=%d \", i, a[i]);     }          free(a);     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "做什么计算？", "referer": "user-0"}]}
{"question": "为什么我的电脑上system函数用不了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 4 楼 赵4老师的回复:现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！ 能详细点吗，管理员窗口我只用过cd改mysql目录进行登录≥﹏≤", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:确定跟system有关吗？注释掉试试？ 没看出跟system这句有关系呢，不是有提示\"按任意键关闭此窗口...\"这句吗？这句不是针对system的吗？ 我在学校机房是没问题的，自己电脑就不行了", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:确定跟system有关吗？注释掉试试？ 没看出跟system这句有关系呢，不是有提示\"按任意键关闭此窗口...\"这句吗？这句不是针对system的吗？ 首先第一个system是修改背景板和字体颜色，就已经没有生效了，其次第二个system是冻结屏幕，出现的提示是“请按任意键继续”也没有出现", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "mysql也有system命令", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "确定跟system有关吗？注释掉试试？ 没看出跟system这句有关系呢，不是有提示\"按任意键关闭此窗口...\"这句吗？这句不是针对system的吗？", "referer": "user-0"}]}
{"question": "c语言小白问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h>  int main(void) {     int x, y;     int a=2,b=4,c=6;     y= ((x=a+b), (b+c));     printf(\"y=%d，x=%d\\n\",y, x) ;      return 0; } 楼主这个值是y=10，但是对比一下你的表达式有什么不一样？  举个例子：  int x = 5, y; 请问x？y?  这样的表达式你可能比较理解，因为是对x初始化为5，y没有初始化；  你可能是理解为逗号表达式，但是楼主的y = (x=a+b), (b+c);y后面的表达式是一个整体吗？和上面的代码是不是相差一个()呢？", "referer": "user-0"}]}
{"question": "求教萌新，萌新依旧不知道自己错在了哪里，代码可以正常运行，但输出结果错误，全为-1", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 forlorn pedestrian 的回复:[quote=引用 4 楼 自信男孩的回复:][quote=引用 2 楼 forlorn pedestrian 的回复:][quote=引用 1 楼 自信男孩的回复:]#include<stdio.h>  //double fac(int m, int n) double fac(long int m, long int n) {     int i, j, k, l, q, t;     double s;      s = 0;     l = 1;     q = 1;     t = 1;      for (i = 1;i <= m;i++) {         l = l * i;     }     for (j = 1;j <= n;j++) {         q = q * j;     }     for (k = 1;k <= (m - n);k++) {         t = t * k;     }     s = l*1.0 / q / k;   //保证这个运算是double类型的      return s; } int main() {     long int m, n;     //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n);      if (m < n && m>0 && n > 0) {         printf(\"0\");         return 0;     }     if (m == n && m > 0 && n > 0) {         printf(\"1\");         return 0;     }      if (m > n && m > 0 && n > 0) {         printf(\"%lf\", fac(m, n));         return 0;     }     else         printf(\"-1\");     return 0; } 供参考～      //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n); 对比一下问题  注意事项： s = l*1.0 / q / k;   //保证这个运算是double类型的   //double fac(int m, int n) double fac(long int m, long int n) 可是我依然运行不对，结果全是-1,所以我想问问我哪错了[/quote] 那把你的测试用例发一下，就是你的测试数据～[/quote] 2 2 4 3[/quote]  请再用我的代码测试一下？我的测试结果是这样的： 2 2 1 4 3 2.000000", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:[quote=引用 2 楼 forlorn pedestrian 的回复:][quote=引用 1 楼 自信男孩的回复:]#include<stdio.h>  //double fac(int m, int n) double fac(long int m, long int n) {     int i, j, k, l, q, t;     double s;      s = 0;     l = 1;     q = 1;     t = 1;      for (i = 1;i <= m;i++) {         l = l * i;     }     for (j = 1;j <= n;j++) {         q = q * j;     }     for (k = 1;k <= (m - n);k++) {         t = t * k;     }     s = l*1.0 / q / k;   //保证这个运算是double类型的      return s; } int main() {     long int m, n;     //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n);      if (m < n && m>0 && n > 0) {         printf(\"0\");         return 0;     }     if (m == n && m > 0 && n > 0) {         printf(\"1\");         return 0;     }      if (m > n && m > 0 && n > 0) {         printf(\"%lf\", fac(m, n));         return 0;     }     else         printf(\"-1\");     return 0; } 供参考～      //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n); 对比一下问题  注意事项： s = l*1.0 / q / k;   //保证这个运算是double类型的   //double fac(int m, int n) double fac(long int m, long int n) 可是我依然运行不对，结果全是-1,所以我想问问我哪错了[/quote] 那把你的测试用例发一下，就是你的测试数据～[/quote] 2 2 4 3", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 2 楼 forlorn pedestrian 的回复:[quote=引用 1 楼 自信男孩的回复:]#include<stdio.h>  //double fac(int m, int n) double fac(long int m, long int n) {     int i, j, k, l, q, t;     double s;      s = 0;     l = 1;     q = 1;     t = 1;      for (i = 1;i <= m;i++) {         l = l * i;     }     for (j = 1;j <= n;j++) {         q = q * j;     }     for (k = 1;k <= (m - n);k++) {         t = t * k;     }     s = l*1.0 / q / k;   //保证这个运算是double类型的      return s; } int main() {     long int m, n;     //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n);      if (m < n && m>0 && n > 0) {         printf(\"0\");         return 0;     }     if (m == n && m > 0 && n > 0) {         printf(\"1\");         return 0;     }      if (m > n && m > 0 && n > 0) {         printf(\"%lf\", fac(m, n));         return 0;     }     else         printf(\"-1\");     return 0; } 供参考～      //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n); 对比一下问题  注意事项： s = l*1.0 / q / k;   //保证这个运算是double类型的   //double fac(int m, int n) double fac(long int m, long int n) 可是我依然运行不对，结果全是-1,所以我想问问我哪错了[/quote] 那把你的测试用例发一下，就是你的测试数据～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "楼主主函数的逻辑判断有问题，修改如下：int main(int argc, char* argv[]) {     long int m, n;     //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n);      if(m>0 && n > 0)      {        if (m < n)           {             printf(\"0\\n\");             //return 0;  //这句多余           }        if (m == n )           {             printf(\"1\\n\");             //return 0;  //这句多余           }        if (m > n )           {             printf(\"%lf\\n\", fac(m, n));             //return 0;  //这句多余           }      }     else        printf(\"-1\\n\");     system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include<stdio.h>  //double fac(int m, int n) double fac(long int m, long int n) {     int i, j, k, l, q, t;     double s;      s = 0;     l = 1;     q = 1;     t = 1;      for (i = 1;i <= m;i++) {         l = l * i;     }     for (j = 1;j <= n;j++) {         q = q * j;     }     for (k = 1;k <= (m - n);k++) {         t = t * k;     }     s = l*1.0 / q / k;   //保证这个运算是double类型的      return s; } int main() {     long int m, n;     //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n);      if (m < n && m>0 && n > 0) {         printf(\"0\");         return 0;     }     if (m == n && m > 0 && n > 0) {         printf(\"1\");         return 0;     }      if (m > n && m > 0 && n > 0) {         printf(\"%lf\", fac(m, n));         return 0;     }     else         printf(\"-1\");     return 0; } 供参考～      //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n); 对比一下问题  注意事项： s = l*1.0 / q / k;   //保证这个运算是double类型的   //double fac(int m, int n) double fac(long int m, long int n) 可是我依然运行不对，结果全是-1,所以我想问问我哪错了", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "#include<stdio.h>  //double fac(int m, int n) double fac(long int m, long int n) {     int i, j, k, l, q, t;     double s;      s = 0;     l = 1;     q = 1;     t = 1;      for (i = 1;i <= m;i++) {         l = l * i;     }     for (j = 1;j <= n;j++) {         q = q * j;     }     for (k = 1;k <= (m - n);k++) {         t = t * k;     }     s = l*1.0 / q / k;   //保证这个运算是double类型的      return s; } int main() {     long int m, n;     //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n);      if (m < n && m>0 && n > 0) {         printf(\"0\");         return 0;     }     if (m == n && m > 0 && n > 0) {         printf(\"1\");         return 0;     }      if (m > n && m > 0 && n > 0) {         printf(\"%lf\", fac(m, n));         return 0;     }     else         printf(\"-1\");     return 0; } 供参考～      //scanf_s(\"ld ld\", &m, &n);     scanf_s(\"%ld %ld\", &m, &n); 对比一下问题  注意事项： s = l*1.0 / q / k;   //保证这个运算是double类型的   //double fac(int m, int n) double fac(long int m, long int n)", "referer": "user-0"}]}
{"question": "求指点顺序栈的出栈入栈操作", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <malloc.h>  #define maxsize 100  typedef struct node {     int stack[maxsize];     int top; }Seqstack;  Seqstack *initstack(Seqstack *s) {     s=(Seqstack *)malloc(sizeof(Seqstack));     if(!s) {         printf(\"空间不足\\n\");         return NULL;     }     else {    s->top=-1;         return s;     } } Seqstack *push(Seqstack *s,int x) {     if(s->top==maxsize-1)     {         printf(\"栈已满\\n\");         return NULL;   }     else   {         s->top++;         s->stack[s->top]=x;         return s;     } }  int pop(Seqstack *s) {   if(s->top==-1)     {         printf(\"栈空\\n\");         //return NULL;    //为啥要返回NULL？         return -1;     }     else         s->top--;     return s->stack[s->top+1]; } void display(Seqstack *s) {     int i = 0;      if(s->top==-1)     {         printf(\"栈空\\n\");     }     else {         while(i < s->top)         {             //s->top--;             printf(\"%d->\",s->stack[i]);             i++;         }     } }  //void main() int main() {   Seqstack *s,*p;     int i;     int a[6]={3,5,7,2,9,16};     s=initstack(s);     printf(\"入栈:\");     for(i=0;i<6;i++)         s = push(s,a[i]);     display(s);     printf(\"\\n出栈:\");     while(s->top!=-1)         printf(\"%4d\", pop(s));     printf(\"\\n\"); } 供参考～  原因是在display函数，这个函数已经修改了top值，导致在出栈时top已经是-1了，所以没有出栈的数据了。 所以，在display函数里不要修改top的值，只是做一下遍历即可～", "referer": "user-0"}]}
{"question": "ip address类型怎么定义?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "u32（unsigned int）也可以存放IP地址。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "socket.h里面不是有吗？直接用啊 如果不用socket，ipv4，不过是32位整形，直接unsigned int 就可以啊", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "看你的需要了，可以是字符串，也可以用无符号整数，也可以用结构", "referer": "user-0"}]}
{"question": "求助大佬解题，C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 1 楼 user-2 的回复:SHOW一个吧，看看符合要求不？  #include <string.h> #include <stdio.h> #include <ctype.h>  #define LEN 31   /* 去掉左空格 */ char *left_trim(char *str) {     char *beginp = str;     char *tmp = str;     while(isspace(*beginp)) beginp++;     while((*tmp++ = *beginp++));       return str; }  /* 去掉右空格 */ char *right_trim(char *str) {     char *endp;     size_t len = strlen(str);       if(len == 0) return str;       endp = str + strlen(str) - 1;     while(isspace(*endp)) endp--;     *(endp + 1) = '\\0';       return str; }  /* 去掉空格 */ char *trim(char *str) {     str = left_trim(str);     str = right_trim(str);       return str; }   int main(void) {     char buf[LEN];     char result[LEN+2];          /* 循环读入字符串，并处理。 */     while(fgets(buf, LEN, stdin))     {         /* 去掉换行符 */         if(buf[strlen(buf)-1] == '\\n')         {             buf[strlen(buf)-1] = '\\0';         } \t         /* 输出结果 */         printf(\"[%s]\\n\", buf);         printf(\"[%s]\\n\", trim(buf));     }              return 0; }   换行符有可能不会加入到buf中，所以需要注意一下～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "SHOW一个吧，看看符合要求不？  #include <string.h> #include <stdio.h> #include <ctype.h>  #define LEN 31   /* 去掉左空格 */ char *left_trim(char *str) {     char *beginp = str;     char *tmp = str;     while(isspace(*beginp)) beginp++;     while((*tmp++ = *beginp++));       return str; }  /* 去掉右空格 */ char *right_trim(char *str) {     char *endp;     size_t len = strlen(str);       if(len == 0) return str;       endp = str + strlen(str) - 1;     while(isspace(*endp)) endp--;     *(endp + 1) = '\\0';       return str; }  /* 去掉空格 */ char *trim(char *str) {     str = left_trim(str);     str = right_trim(str);       return str; }   int main(void) {     char buf[LEN];     char result[LEN+2];          /* 循环读入字符串，并处理。 */     while(fgets(buf, LEN, stdin))     {         /* 去掉换行符 */         if(buf[strlen(buf)-1] == '\\n')         {             buf[strlen(buf)-1] = '\\0';         } \t         /* 输出结果 */         printf(\"[%s]\\n\", buf);         printf(\"[%s]\\n\", trim(buf));     }              return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 10 楼 晨星永恒 的回复:[quote=引用 9 楼 自信男孩 的回复:]#include <stdio.h> #include <string.h>  #define MAX_STR_SIZE    31  char *del_front_tail_spaces(char *str, int len) {     int pos = len-1, i;      //deal with tail     while (str[pos] == ' ')         pos--;     str[pos+1] = 0;      //deal with front     pos = 0;     while (str[pos] == ' ')         pos++;     for (i = 0; str[pos+i]; i++)    //move data replace spaces         str[i] = str[pos+i];     str[i] = 0;      return str; }  int main(void) {     char str[MAX_STR_SIZE];     int len;      fgets(str, MAX_STR_SIZE, stdin);      len = strlen(str);     if (len < MAX_STR_SIZE - 1) {         str[len-1] = 0;   //'\\0' replace '\\n'         len--;     }       printf(\"[%s]\\n\", str);      del_front_tail_spaces(str, len);      printf(\"[%s]\\n\", str);     return 0; } 供参考～ 大佬，你这个是第一二个正确，第三个错误[/quote]  找一下对应的测试用例～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "我改了一下，把前面3个函数变成1个函数，看看是不是函数调用问题，嵌套太大，影响效率了。。  #include <string.h> #include <stdio.h>   #define LEN 31    /* 去掉空格 */ char *trim(char *str) {     char *beginp, *endp, *tmp;     size_t len = strlen(str);      if(len == 0) return str;        endp = str + strlen(str) - 1;     while(*endp == ' ') endp--;     *(endp + 1) = '\\0';          beginp = tmp = str;         while(*beginp == ' ') beginp++;     while((*tmp++ = *beginp++));          return str; }    int main(void) {     char buf[LEN];           /* 循环读入字符串，并处理。 */     if(fgets(buf, LEN, stdin))     {         /* 去掉换行符 */         if(buf[strlen(buf)-1] == '\\n')         {             buf[strlen(buf)-1] = '\\0';         }               /* 输出结果 */         printf(\"[%s]\\n\", buf);         printf(\"[%s]\\n\", trim(buf));     }               return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "#include<stdio.h> #include<string.h> int main() {     char a[100];     int i=0,b;     gets(a);     printf(\"[%s]\\n\",a);     while(1)     {if(a[0]==' ')     {         for(i=0;i<strlen(a);i++)             a[i]=a[i+1];     }      else          break;     }      b=strlen(a)-1;     while(1)      {          if(a[b]==' ')          {              a[b]=0;              b--;          }         else             break;      }     printf(\"[%s]\",a);          return 0; } 我这种是最后一个正确，前两个错误", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 9 楼 自信男孩 的回复:#include <stdio.h> #include <string.h>  #define MAX_STR_SIZE    31  char *del_front_tail_spaces(char *str, int len) {     int pos = len-1, i;      //deal with tail     while (str[pos] == ' ')         pos--;     str[pos+1] = 0;      //deal with front     pos = 0;     while (str[pos] == ' ')         pos++;     for (i = 0; str[pos+i]; i++)    //move data replace spaces         str[i] = str[pos+i];     str[i] = 0;      return str; }  int main(void) {     char str[MAX_STR_SIZE];     int len;      fgets(str, MAX_STR_SIZE, stdin);      len = strlen(str);     if (len < MAX_STR_SIZE - 1) {         str[len-1] = 0;   //'\\0' replace '\\n'         len--;     }       printf(\"[%s]\\n\", str);      del_front_tail_spaces(str, len);      printf(\"[%s]\\n\", str);     return 0; } 供参考～ 大佬，你这个是第一二个正确，第三个错误", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "#include <stdio.h> #include <string.h>  #define MAX_STR_SIZE    31  char *del_front_tail_spaces(char *str, int len) {     int pos = len-1, i;      //deal with tail     while (str[pos] == ' ')         pos--;     str[pos+1] = 0;      //deal with front     pos = 0;     while (str[pos] == ' ')         pos++;     for (i = 0; str[pos+i]; i++)    //move data replace spaces         str[i] = str[pos+i];     str[i] = 0;      return str; }  int main(void) {     char str[MAX_STR_SIZE];     int len;      fgets(str, MAX_STR_SIZE, stdin);      len = strlen(str);     if (len < MAX_STR_SIZE - 1) {         str[len-1] = 0;   //'\\0' replace '\\n'         len--;     }       printf(\"[%s]\\n\", str);      del_front_tail_spaces(str, len);      printf(\"[%s]\\n\", str);     return 0; } 供参考～", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 7 楼 user-2的回复:[quote=引用 4 楼 晨星永恒 的回复:]大佬，感觉还是有点问题，三项判断，最后一项正确  我个人理解题目只有2个要求：1、去掉首尾空客；2、不超过30个字符。 可能是我语文不好，可能还有暗含潜规则，我没看出来。[/quote] 我感觉也是这，但他就是说错误，也想不出这个题能有什么特殊情况了", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "引用 4 楼 晨星永恒 的回复:大佬，感觉还是有点问题，三项判断，最后一项正确  我个人理解题目只有2个要求：1、去掉首尾空客；2、不超过30个字符。 可能是我语文不好，可能还有暗含潜规则，我没看出来。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:[quote=引用 1 楼 user-2 的回复:]SHOW一个吧，看看符合要求不？  #include <string.h> #include <stdio.h> #include <ctype.h>  #define LEN 31   /* 去掉左空格 */ char *left_trim(char *str) {     char *beginp = str;     char *tmp = str;     while(isspace(*beginp)) beginp++;     while((*tmp++ = *beginp++));       return str; }  /* 去掉右空格 */ char *right_trim(char *str) {     char *endp;     size_t len = strlen(str);       if(len == 0) return str;       endp = str + strlen(str) - 1;     while(isspace(*endp)) endp--;     *(endp + 1) = '\\0';       return str; }  /* 去掉空格 */ char *trim(char *str) {     str = left_trim(str);     str = right_trim(str);       return str; }   int main(void) {     char buf[LEN];     char result[LEN+2];          /* 循环读入字符串，并处理。 */     while(fgets(buf, LEN, stdin))     {         /* 去掉换行符 */         if(buf[strlen(buf)-1] == '\\n')         {             buf[strlen(buf)-1] = '\\0';         } \t         /* 输出结果 */         printf(\"[%s]\\n\", buf);         printf(\"[%s]\\n\", trim(buf));     }              return 0; }   换行符有可能不会加入到buf中，所以需要注意一下～[/quote] 不太懂", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 user-2的回复:SHOW一个吧，看看符合要求不？  #include <string.h> #include <stdio.h> #include <ctype.h>  #define LEN 31   /* 去掉左空格 */ char *left_trim(char *str) {     char *beginp = str;     char *tmp = str;     while(isspace(*beginp)) beginp++;     while((*tmp++ = *beginp++));       return str; }  /* 去掉右空格 */ char *right_trim(char *str) {     char *endp;     size_t len = strlen(str);       if(len == 0) return str;       endp = str + strlen(str) - 1;     while(isspace(*endp)) endp--;     *(endp + 1) = '\\0';       return str; }  /* 去掉空格 */ char *trim(char *str) {     str = left_trim(str);     str = right_trim(str);       return str; }   int main(void) {     char buf[LEN];     char result[LEN+2];          /* 循环读入字符串，并处理。 */     while(fgets(buf, LEN, stdin))     {         /* 去掉换行符 */         if(buf[strlen(buf)-1] == '\\n')         {             buf[strlen(buf)-1] = '\\0';         } \t         /* 输出结果 */         printf(\"[%s]\\n\", buf);         printf(\"[%s]\\n\", trim(buf));     }              return 0; }  大佬，感觉还是有点问题，三项判断，最后一项正确", "referer": "user-0"}]}
{"question": "新手求助 数据结构 二叉树", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "已自行修改，成功运行👌", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "C与C++大杂烩，乱成一锅粥，谁看谁难受。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你这叫新手，你好像在侮辱人", "referer": "user-0"}]}
{"question": "PTA入门练习请教  整除光棍 /shuffling machine/黑洞数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "大家可以不要管那个完数 今晚我脑子太乱了 明早起来再看一下 谢谢啦  然后里面肯定有很多错误 各位就不要客气  就直接指出吧  ，， （已经被小伙伴打击习惯了 哈哈哈 多么辛酸）   谢谢啦 各位晚安 （睡不了美容觉 保命觉也得睡啊，避免英年早逝）", "referer": "user-0"}]}
{"question": "#C语言基础", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if(a[i]=='?') {    a[i]='!'; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 阿麦的回复:不能。strcmp(const char*, const char*)，参数是字符指针  a[i]类型不对  如果要这样判断，可以用  a[i] == '?' 那怎么把a[i]替换成别的字符呢？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不能。strcmp(const char*, const char*)，参数是字符指针  a[i]类型不对  如果要这样判断，可以用  a[i] == '?'", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我傻了，用了双引号", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "cannot convert from 'char[2]' to 'char' 不行啊", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 棉猴的回复: if(a[i]=='?') {    a[i]='!'; }  cannot convert from 'char[2]' to 'char' 不行啊", "referer": "user-0"}]}
{"question": "c语言vc2010可以运行的程序为什么Dev不可以运行", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 轻语2000的回复:你看你的报错提示啊“bianli” was not declared bianli那是之前的一个函数，我把他给删掉了，没删之前就有错误，说要return int", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "建议楼主把代码贴全，并把问题的内容贴全。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "小错误要注意", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你看你的报错提示啊“bianli” was not declared", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "因为你这代码不规范，vc2010太老了，新标准支持不到位。 最好用vs2019，或者Embarcadero_Dev-Cpp_6.1（gcc9.2）", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "原因很清楚了，严格来说， int func() {} 必须返回一个 int。如果没有返回值，定义成 void func() {}  引用 5 楼 m0_51316636 的回复:[quote=引用 2 楼 轻语2000的回复:]你看你的报错提示啊“bianli” was not declared bianli那是之前的一个函数，我把他给删掉了，没删之前就有错误，说要return int[/quote]", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 5 楼 m0_51316636的回复:[quote=引用 2 楼 轻语2000的回复:]你看你的报错提示啊“bianli” was not declared bianli那是之前的一个函数，我把他给删掉了，没删之前就有错误，说要return int[/quote] 所以说嘛，应该把代码贴完整，不然要误会", "referer": "user-0"}]}
{"question": "小白在c语言中遇到的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "1.0/3首先结果是一个浮点数(double），如果用%d输出，由于浮点数和整型数在内存里的表示是不一样的。同样是1和1.0f对于不同的类型（浮点数和整型数），虽然都是4字节，但是可以看一下对应的16进制是不一样的。      printf(\"%x\\n\", 1.0f);     printf(\"%x\\n\", 1); 这是结果： cff6c8 1", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "/是整数除，以%d输出，浮点除还是用%f吧", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "1.0/3是double类型，在内存中的值是  转换成int是1431655765 double类型的格式，请参考《C++浮点型变量的存储方式》 希望能够帮到您！", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "有趣。不知道是不是所有编译器都是这个结果。 不过，还是按照规矩来比较好，用 %f。 有时候，不规范或错误的事做多了，会变成习惯的。", "referer": "user-0"}]}
{"question": "键盘焦点，这是什么情况？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "BOOL WINAPI GetGUIThreadInfo(   _In_     DWORD idThread,   _Inout_  LPGUITHREADINFO lpgui );  BOOL WINAPI GetGUIThreadInfo(   _In_     DWORD idThread,   _Inout_  LPGUITHREADINFO lpgui );        Parameters idThread [in]  Type: DWORD  The identifier for the thread for which information is to be retrieved. To retrieve this value, use the GetWindowThreadProcessId function. If this parameter is NULL, the function returns information for the foreground thread.  lpgui [in, out]  Type: LPGUITHREADINFO  A pointer to a GUITHREADINFO structure that receives information describing the thread. Note that you must set the cbSize member to sizeof(GUITHREADINFO) before calling this function.  Return value Type:   Type: BOOL   If the function succeeds, the return value is nonzero.  If the function fails, the return value is zero. To get extended error information, call GetLastError.  Remarks This function succeeds even if the active window is not owned by the calling process. If the specified thread does not exist or have an input queue, the function will fail.  This function is useful for retrieving out-of-context information about a thread. The information retrieved is the same as if an application retrieved the information about itself.  For an edit control, the returned rcCaret rectangle contains the caret plus information on text direction and padding. Thus, it may not give the correct position of the cursor. The Sans Serif font uses four characters for the cursor:", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "多线程日志参考下面：//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef _MSC_VER     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]=\"MyLog1.log\"; char logfilename2[]=\"MyLog2.log\"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef _MSC_VER void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,\"%03d\",tb.millitm);     printf(\"%s %s.%s %s\",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,\"a\");     if (NULL!=flog) {         fprintf(flog,\"%s %s.%s %s\",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX; CRITICAL_SECTION cs_BBB; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,\"%03d %04x -\",cn,i);             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);             sprintf(binstr,\"%s  \",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log(\"%s\\n\",binstr);         } else {             sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,\"%s   \",binstr);         }         sprintf(binstr,\"%s  \",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log(\"%s\\n\",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log(\"%03d thdB              thread begin...\\n\",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log(\"%03d recv %d bytes\\n\",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log(\"%03d %d==wc>3600!\\n\",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log(\"%03d thdA              thread begin...\\n\",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log(\"%03d sending %d bytes\\n\",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log(\"%03d sent %d bytes\\n\",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log(\"%03d %d==wc>3600!\\n\",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int main() { #ifdef _MSC_VER     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX);     InitializeCriticalSection(&cs_BBB); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log(\"Start===========================================================\\n\");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef _MSC_VER     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log(\"%d=pthread_create %d error!\\n\",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log(\"%d=pthread_create %d error!\\n\",rc,threadsN-1); #endif      if (!access(\"No_Loop\",0)) {         remove(\"No_Loop\");         if (!access(\"No_Loop\",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access(\"No_Loop\",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log(\"End=============================================================\\n\"); #ifdef _MSC_VER     DeleteCriticalSection(&cs_BBB);     DeleteCriticalSection(&cs_HEX);     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 8 楼 早打大打打核战争 的回复:你检查一下SetActiveWindow成功了没有 的确是设置失败（返回NULL），可是这个跟WM_ACTIVATE有关系吗？ 刚刚我把SetActiveWindow(hwnd); 注释了，保留SetForegroundWindow ( hwnd2 );，结果是这样的：    在我并没有设置激活的情况下，消息依然显示是先失去激活，之后又激活，但这时输入的字符都在记事本那里，这边窗口应该是失去激活的。 我也顺便确认了下，WM_ACTIVATE是非队列消息，那么应该就不存在因延迟而混乱的情况。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你检查一下SetActiveWindow成功了没有", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复:估计是多道程序（包括多进程、多线程、……）输出日志信息时没有加锁。 引用 6 楼 早打大打打核战争 的回复:输出log时加上时间就能看出来了 你们说的日志、log是啥？？windows 日志吗？ 对于不同进程即便顺序混乱，但对于单个程序来说，不可能也不应该混乱吧？它这不是一个一个消息逐步处理的吗？顺序乱了的话，岂不就异常了？", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:帮结帖+蹭分 问题都还没解决呢", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 4 楼 赵4老师 的回复:估计是多道程序（包括多进程、多线程、……）输出日志信息时没有加锁。 从而导致看上去日志信息的顺序和实际程序输出日志的顺序不完全一致。 我猜。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "估计是多道程序（包括多进程、多线程、……）输出日志信息时没有加锁。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "输出log时加上时间就能看出来了", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "帮结帖+蹭分", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "问题应该是找到了，GetActiveWindow和GetFocus都是只能获取当前线程相关的。  现在应该只剩一个问题，WM_ACTIVATE应该是先激活（1）再失去激活（0），但这里收到的消息顺序是相反的，而且实际的效果是先激活了，再由于调用了SetForegroundWindow而失去激活，先1再0才对呀", "referer": "user-0"}]}
{"question": "弱弱的猿C语言遇到大问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "推荐是看书，还是按看视频，本人看书感觉有点乏味", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 ctrigger 的回复:[quote=引用 2 楼 namedashadiao 的回复:]数据结构和算法有推荐的学习途径吗？ 大学不学数据结构和算法么？啥情况？？ 严蔚敏老师的数据结构不错，适合入门。[/quote] 不是不学，大二学，想提前学", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "写是最好的练习", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 2 楼 namedashadiao 的回复:数据结构和算法有推荐的学习途径吗？ 大学不学数据结构和算法么？啥情况？？ 严蔚敏老师的数据结构不错，适合入门。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "数据结构和算法有推荐的学习途径吗？", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "学完数据结构与算法再蓝桥吧", "referer": "user-0"}]}
{"question": "技术小白刚开始学c，能有大佬帮忙看下哪里有问题吗，谢谢大佬们了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢大佬！不过还想问问我原来的为什么运行出来的结果很奇怪", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<string.h>  char s1[500],s2[20]; char substr[20];  void findshort(char str[]) {     int len, i, sub_len = 0;       len = strlen(str);      for (i = 0; str[i]; i++) {         if (sub_len == 0 && (str[i] == ' ' || str[i] == '\\n'))             continue;         if (str[i] == ' ' || str[i] == '\\n') {             if (sub_len < len && sub_len != 0) {                 len = sub_len;                 memcpy(substr, &str[i-sub_len], sub_len);                 substr[sub_len] = 0;             }             sub_len = 0;         } else if (str[i] != '\\n') {             sub_len++;         }     }  #if 0     int c,i,j,min;     c=strlen(s);     min=0;     j=0;     for(i=0;i<c;i++)     {          if (s[i]>=((s[i]>='a'&&s[i]<='z')||(s[i]>='A'&&s[i]<='Z')))             j++;         else         {             if (min<j)                 for(int n=0;n<j;n++)                     s2[n]=s[i-j+n];             j=0;         }     } #endif }  int main() {     fgets(s1, 500, stdin);     findshort(s1);     printf(\"%s\\n\", substr);     return 0; } 供参考～", "referer": "user-0"}]}
{"question": "关于EOF", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把while(scanf(\"%d %d \",&a,&b)!=EOF) 改成 while(scanf(\"%d%d \",&a,&b)!=0) 然后输入非数字退出循环。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不行不行，我用VC还是结束不了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "linux: ctrl+d windows: ctrl+z 试试～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "Linux是 ctrl + D windows 是ctrl + z", "referer": "user-0"}]}
{"question": "关于c语言数组的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用if(i％5=0) printf(\"\\n\");这句有误，应该为if(i％5==0)", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议看看动态规划，你这个明显是有重叠子问题，这是状态转移方程，这个跟数组没冲突。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "[i]表示的是地址门牌号为i f[i]表示的是那第i个门牌号里住了几个人", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "他的地址不变，也就是存放的空间不变，而不是他里面存放的东西不能变。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "计算斐波那契数列 1,1,2,3,5,....", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "不是呀  数组元素你可以修改的  f[i]=f[i-1]+f[i-2]就是从数组的第三个元素开始 元素的值是前两个元素的和", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "一般来说，数组元素赋初值后是可以改变的。f［i］=f[i-2]+f［i-1］，这句话的意思就是从第三个元素开始，后面的每个元素等于前两个元素之和", "referer": "user-0"}]}
{"question": "这道数据结构是不是题有问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "同问楼主解决了吗", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "各位大佬写出来的把可能的中序排列写一下就行，这样比较简单，但是我觉得没有这课树我画出最接近的树前序序列为abcdfeg", "referer": "user-0"}]}
{"question": "波形图怎么求幅度？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如何过滤掉毛刺和抖动？？如何判断第一个波形，第一个波形的波幅要不要纳入计算？？？最后一个波形如何判断，如何处理？？题主是这还是一个比较规则的波形，现实采样的波形必定有毛刺，有些波形比如脉搏还会有抖动（就是上升过程中到部分人的都会中途抖一下）。请不要以纯数学的角度来考虑问题。。。我抖没百度到解决方法，估计波幅算法都是属于每个公司的核心资产。。。。", "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-1", "content": "那就太简单了，最简单的方法就是找出最大最小值即可。复杂一点找出两个拐点就可以。。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 3 楼 顾染尘 的回复:[quote=引用 2 楼 ctrigger 的回复:]扫描点，找Y最大值，最小值。 （最大值-最小值）/ 2。。。 我理解就是峰值减去谷值除以2，对的吗？（我还以为幅度是要求角度或者是斜率）感谢！[/quote]  对，就是这样的。 方程应该类似这样的：y = Asin(ωx + φ)，复制是A。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 ctrigger 的回复:扫描点，找Y最大值，最小值。 （最大值-最小值）/ 2。。。 我理解就是峰值减去谷值除以2，对的吗？（我还以为幅度是要求角度或者是斜率）感谢！", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "扫描点，找Y最大值，最小值。 （最大值-最小值）/ 2。。。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "從圖形求幅度？掃描每個點的坐標不就出來了嗎", "referer": "user-0"}]}
{"question": "初学者关于随机数统计结果的的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void gen_random(int upper_bound) {         int i;          srand(time(NULL);    //生成一个种子～         for(i=0;i<N;i++)                 a[i]=rand()%upper_bound; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "可以的，蟹蟹。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "伪随机数。设置一个seed吧。 看看这样是否可行。  #include <stdlib.h> #include <time.h> #define N 100000  int a[N]; void gen_random(int upper_bound) {         int i; \t \tsrand((unsigned int)time(NULL)); \t         for(i=0;i<N;i++)                 a[i]=rand()%upper_bound; } int howmany(int value) {         int count=0,i;         for (i=0;i<N;i++)                 if(a[i]==value)                         ++count;         return count; } int main(void) {         int i;         gen_random(10);         printf(\"value\\thow many\\n\");         for(i=0;i<10;i++)                 printf(\"%d\\t%d\\n\",i,howmany(i));         return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "https://bbs.csdn.net/topics/390659274", "referer": "user-0"}]}
{"question": "switch语句中数值导出运用下面编程", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "switch(s) {       case 1:printf(\"d=%d\\n\",d=a+b-c);break;       case 2:printf(\"d=%d\\n\",d=a+c-b);break;       case 3:printf(\"d=%d\\n\",d=b+c-a);break;       case 4:printf(\"d=%d\\n\",d=0);break;       case 5:printf(\"d=%d\\n\",d=c-b+a);break;       case 6:printf(\"d=%d\\n\",d=a-b+c);break;       case 7:printf(\"d=%d\\n\",d=b-a+c);break;       case 8:printf(\"d=%d\\n\",d=a+b);break;       case 9:printf(\"d=%d\\n\",d=a+c);break;       case 10:printf(\"d=%d\\n\",d=b+c);break;   default:printf(\"enter data error!\\n\");     }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "", "referer": "user-0"}]}
{"question": "vscode编译头文件问题“undefined reference.....”", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "许多年过去了，赵4老师还是如此的独领风骚", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "靠猜是猜不出来或猜不全的。建议楼主贴全代码和对应的编译提示～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这是链接错误。  需要在链接选项中添加依赖的库文件。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "上贴中红字应改为 “/link /LIBPATH:附加依赖库.lib所在目录\"， “/link 附加依赖库.lib\" //zhao4zhong1添加(^_^)", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "https://code.visualstudio.com/docs/cpp/config-msvc From the main menu, choose Terminal > Configure Default Build Task. In the dropdown, which will display a tasks dropdown listing various predefined build tasks for C++ compilers. Choose cl.exe build active file, which will build the file that is currently displayed (active) in the editor.  Tasks C++ build dropdown  This will create a tasks.json file in a .vscode folder and open it in the editor.  Your new tasks.json file should look similar to the JSON below:  {   \"version\": \"2.0.0\",   \"tasks\": [     {       \"type\": \"shell\",       \"label\": \"cl.exe build active file\",       \"command\": \"cl.exe\",       \"args\": [         \"/Zi\",         \"/EHsc\",         \"/Fe:\",         \"${fileDirname}\\\\${fileBasenameNoExtension}.exe\",         \"${file}\",       “/link /LIBPATH:附加依赖库.lib所在目录\"，       “/link /IMPLIB:附加依赖库.lib\" //zhao4zhong1添加(^_^)       ],       \"problemMatcher\": [\"$msCompile\"],       \"group\": {         \"kind\": \"build\",         \"isDefault\": true       }     }   ] } The command setting specifies the program to run; in this case that is \"cl.exe\". The args array specifies the command-line arguments that will be passed to cl.exe. These arguments must be specified in the order expected by the compiler. This task tells the C++ compiler to take the active file (${file}), compile it, and create an executable file (/Fe: switch) in the current directory (${fileDirname}) with the same name as the active file but with the .exe extension (${fileBasenameNoExtension}.exe), resulting in helloworld.exe for our example.", "referer": "user-0"}]}
{"question": "c语言指针问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "他们在这两个例子中都是指针向后移一位是吗", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "应该说某种情况下，p++和p+1是一样的，*(p+1)是取值", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "p++是指针 *(p+1)是指针指向的值 p++和p+1也要看前后文才能确定是不是一样 *(p+1)和*(p++)在不同的前后文指向的值可能一样也可能不一样", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "不一样的。p++是p+1赋值给p，而*(p+1)是p+1的地址，但是不会赋值给p，即这两个的区别：p++和p+1是否修改p上是不一样的。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "p++指针位置后移一位，再用*p取值取的就是下一个位置的值 （p+1）是取后一位指针，指针p指向的值*p还是原来位置的值", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "我想问一下在指针里面他们有什么不同，我看例子两个作用好像都是一样的，都是指针指向的对象向又偏移一个单位", "referer": "user-0"}]}
{"question": "数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这样的题不难，最好自己写。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "写个吧，你看看行不行？ #include <stdio.h> #define LEN 10  int main(void) { \tint a[LEN], n, i; \tint maxpos, minpos, sum; \t \t/* 输入n值 */ \tprintf(\"input n:\\n\"); \tscanf(\"%d\", &n); \t \t/* 输入n个数组值 */ \tprintf(\"input n numbers:\\n\"); \tfor(i=0; i<n; i++) \t{ \t\tscanf(\"%d\", &a[i]); \t} \t \t/* 初始化 */ \tmaxpos = minpos = 0; \tsum = a[0]; \t \t/* 扫描数组，找最大值、最小值位置，并计算和 */ \tfor(i=1; i<n; i++) \t{ \t\tsum = sum + a[i]; \t\tif(a[i] > a[maxpos]) maxpos = i; \t\tif(a[i] < a[minpos]) minpos = i; \t} \t \t/* 输出结果 */ \tprintf(\"max_value:\\t%d\\tmin_value:\\t%d\\n\", a[maxpos], a[minpos]); \tprintf(\"max_positon:\\t%d\\tmin_positon:\\t%d\\n\", maxpos, minpos); \tprintf(\"average_value:\\t%.2f\\n\", 1.0*sum/n);  \treturn 0; }", "referer": "user-0"}]}
{"question": "accept() 报错 “bad file descriptor\"， 请问是什么原因？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 user-1的回复:[quote=引用 2 楼 陳錄生 的回复:]It works, why? 我的电脑fedora 33，也正常工作。  我觉得应该是“bzero(&s_addr, sizeof(s_addr));”已经赋值0了。即使后面不执行if语句，效果是一样的。[/quote] freebsd handbook是if( INADDR_ANY),而且之前没有报错，太搞了。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 陳錄生 的回复:It works, why? 我的电脑fedora 33，也正常工作。  我觉得应该是“bzero(&s_addr, sizeof(s_addr));”已经赋值0了。即使后面不执行if语句，效果是一样的。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "It works, why?", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用if(INADDR_ANY)         s_addr.sin_addr.s_addr = htonl(INADDR_ANY);   INADDR_ANY的值就是0，是不是写反了？？？", "referer": "user-0"}]}
{"question": "accept函数的addr参数是客户端address还是服务器的addres?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "一般来说，服务器端调用accept函数，addr就是客户端地址信息。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个是对端的地址，对端socket的地址：       The  argument  addr is a pointer to a sockaddr structure.  This structure is filled in with the address of the peer socket", "referer": "user-0"}]}
{"question": "C语言数据结构问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#define后面的分号去掉，因为define是等价替换，替换之后在malloc的括号里就会出现;分号；", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#define最后的分号';'去掉试试", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "S.base = (StackData*)malloc(STACK_INIT_SIZE * sizeof(StackData)); 就这一句，一直报错。。。", "referer": "user-0"}]}
{"question": "组合框控件（combobox）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "那确实是包含WS_CHILD风格，可能是为了避免出现任务栏窗口", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 19 楼 早打大打打核战争 的回复:54808041是十六进制还是十进制  十六进制", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "54808041是十六进制还是十进制", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 14 楼 六道佩恩 的回复:1. 顶级窗口的父窗口真的是桌面窗口吗？毕竟GetParent得到的是NULL，凭借对桌面窗口调用GetWindow函数得到第一个顶层窗口的句柄这一点应该也无法说明所有顶级窗口的父窗口是桌面窗口吧？主要是我一直也没看到微软文档说过顶级窗口的父窗口是桌面窗口，不过就“SetParent指定父窗口为NULL时设置桌面窗口为父窗口”，测试结果是设置后GetWindow仍然得到NULL，应该算佐证了“顶级窗口的父窗口真的是桌面窗口”吧。  先说点其他的。。。 因为我又去看了下msdn上GetParent的说明，发现GetParent有了更详细的说明，微软确实一直在更新啊。 以前的版本（vs2008）： If the window is a child window, the return value is a handle to the parent window. If the window is a top-level window, the return value is a handle to the owner window. If the window is a top-level unowned window or if the function fails, the return value is NULL  微软说了，这个函数可以获取owner窗口，但我实际测试时不行，我以前一直疑惑为什么这个函数获取不到我想要的owner窗口，直到我今天看到最新说明。。。  最新说明： If the window is a child window, the return value is a handle to the parent window. If the window is a top-level window with the WS_POPUP style, the return value is a handle to the owner window.  只有带了WS_POPUP风格后，对其GetParent，才能获取其owner  原来，我以前的窗口虽然不带WS_CHILD，但恰好也没有带WS_POPUP风格，而是WS_OVERLAPPED风格（0x00000000）。所以不行。 而且最新的说明还指明了这个函数返回NULL的情况：  This function typically fails for one of the following reasons:  1、The window is a top-level window that is unowned or does not have the WS_POPUP style. 2、The owner window has WS_POPUP style.  这又能看到另一个条件：owner 窗口还不能带WS_POPUP风格（当然也不能带WS_CHILD,必须是WS_OVERLAPPED）  当然，前面都说的是使用GetParent去获取owner的条件，言外之意是，即使获取失败，也并不代表它没有owner。 所以想要健壮的获取owner 窗口，还是用GW_OWNER 调用GetWindow比较好。 这在GetParent的Remark一节中，微软也是这么建议的，在Remark中，我还看到了微软建议的获取真正父窗口该用的函数！  To obtain a window's owner window, instead of using GetParent, use GetWindow with the GW_OWNER flag. To obtain the parent window and not the owner, instead of using GetParent, use GetAncestor with the GA_PARENT flag.  那么终于可以说回正题了，我说了那么多，其实就是想引出GetAncestor这个函数。。微软建议使用GA_PARENT调用GetAncestor来获取窗口的真正父窗口。我也实际测试了，确实可以：使用这个函数后，所有top-level窗口的父窗口确实都是桌面！ 我想这些应该就可以解答你的疑惑了。 但其实我觉得吧，没必要太纠结。毕竟在windows下开发，微软说什么就是什么。。。  引用 14 楼 六道佩恩 的回复:2. 我测试了下，只有子窗口获取父窗口时，才会显示桌面窗口的句柄。这个列表框为什么一定要设置为WS_CHILD？同为桌面窗口的子窗口的话，顶级窗口不行吗？  没太听懂你说的。你是不是说反了。  我说的明明是：下拉列表框必须是top-level的啊。。。因为它很可能需要超出它自己app的主窗口的范围。所以它只能是桌面的子窗口。  而它自己app的主窗口一般就只是它的owner。  引用 14 楼 六道佩恩 的回复:3. 你的4.1我觉得有个地方说错了，“当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态”，可见与否不是看WS_VISIBLE吗，我测过了，拥有者窗口最小化后，拥有的窗口隐藏后，它已经没有WS_VISIBLE样式了，IsWindowVisible也返回0，这应该算是影响了其可见状态吧？  你说的对，可能我以前的印象有误， 我现在看了下，owner窗口有WS_MINIMIZE后（最小化），owned窗口就会被隐藏。而不是取决于owner的WS_VISIBLE。所以窗口C还是不会自动隐藏，因为窗口B只是隐藏了，而没有WS_MINIMIZE（最小化）。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 17 楼 user-2 的回复:[quote=引用 16 楼 六道佩恩 的回复:] 我是这样想的，它这样的设计是不是还牵涉到什么原因而使得这个列表框需要一个WS_CHILD  其他的先不讨论，你说的这个我先确定下： 你确定你这个下拉列表框带WS_CHILD？？  不会吧。。。创建桌面的child window 这种做法我自己还真没做过。。。 [/quote]  你对比下样式，WS_CHILD是0x40 00 00 00", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 16 楼 六道佩恩 的回复:我是这样想的，它这样的设计是不是还牵涉到什么原因而使得这个列表框需要一个WS_CHILD  其他的先不讨论，你说的这个我先确定下： 你确定你这个下拉列表框带WS_CHILD？？  不会吧。。。创建桌面的child window 这种做法我自己还真没做过。。。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "原来如此，总算能石锤顶级窗口的父窗口是桌面了 我又试了下IsChild，这个没效果，估计是跟GetParent配套的   引用 15 楼 user-2 的回复:[quote=引用 14 楼 六道佩恩 的回复:] 2. 我测试了下，只有子窗口获取父窗口时，才会显示桌面窗口的句柄。这个列表框为什么一定要设置为WS_CHILD？同为桌面窗口的子窗口的话，顶级窗口不行吗？  没太听懂你说的。你是不是说反了。  我说的明明是：下拉列表框必须是top-level的啊。。。因为它很可能需要超出它自己app的主窗口的范围。所以它只能是桌面的子窗口。  而它自己app的主窗口一般就只是它的owner。  [/quote] 关于这个，我的意思是，列表框的实现，它是创建为以桌面为父窗口的子窗口。然后作为子窗口处于Z序顶端，我的问题是，它为什么不实现为一个TOPMOST的顶级窗口呢，这样的效果感觉应该是一样的？我是这样想的，它这样的设计是不是还牵涉到什么原因而使得这个列表框需要一个WS_CHILD，毕竟我考虑的是由自己来实现类似效果的层面。如果没什么特别原因，那就当我没说", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 8 楼 早打大打打核战争 的回复:实现很简单，就和组合框的下拉列表框一个套路就可以了，SetParent(LISTBOX_HWND, NULL); 然后显示的时候用SetWindowPos设置HWND_TOP标志把LISTBOX置顶即可 关键是移动窗口呢？窗口的Z序变化呢？", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "引用 10 楼 六道佩恩 的回复:不过有个问题，它为什么要设为桌面窗口的子窗口？设为顶级窗口不行吗？ 所有顶层窗口（我更愿意称“顶层“窗口为“弹出式”窗口）的父窗口都是桌面。  windows系统中的窗口之间的关系很容易理解错误，个人认为主要原因就在于它有两类窗口（带WS_CHILD风格和不带WS_CHILD风格），却用了同一套窗口之间父子关系建立的API（CreateWindow创建时指定父窗口、SetParent创建后修改父窗口等等）。  所以，你在调用任何有关父子关系的API时，要始终清楚你操作的窗口对象是“弹出式”窗口，还是“子”（带WS_CHILD风格）窗口（我更愿意称“子“窗口为“嵌入式”窗口）。 1.1、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）也为“弹出式”窗口时，这个所谓的“父窗口”，在这时其实是指“拥有者”窗口（owner），窗口A的真正父窗口是桌面。  1.2、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）为“嵌入式”窗口时，系统将找到容纳该“嵌入式”窗口的“弹出式”窗口，以该“弹出式”窗口作为owner窗口。  1.3、Owner窗口一旦指定不能更改。通过GetWindow函数（指定GW_OWNER标志）可获取owner窗口的句柄（如果存在的话）。  1.4、当CreateWindow创建“嵌入式”窗口B时，必须指定一个父窗口（hWndParent参数），父窗口类型不限。“嵌入式”窗口也可以作为其父窗口。   2.1、当调用SetParent修改“弹出式”窗口A的所谓“父窗口”（hWndNewParent）时，窗口A自动变为“嵌入式”窗口（也印证了1.3条所述），且程序员需要手动修正窗口A的风格（加上WS_CHILD,去掉WS_POPUP），否则窗口可能会表现不正常。  2.2、当调用SetParent修改“嵌入式”窗口B的父窗口（hWndNewParent）时，父窗口类型不限（参照1.4）。   拥有父子关系的窗口表现： 3.1、子窗口只能显示在它的父窗口的客户区中，超出父窗口客户区的部分将被裁减掉；父窗口被隐藏时，它的所有子窗口也被隐藏；最小化父窗口不影响子窗口的可见状态，子窗口会随着父窗口被最小化，但是它的WS_VISIBLE属性不变。父窗口被销毁的时候，它的所有子窗口都会被销毁。 由此可见，下拉列表框 必须不能 是程序主窗口的子窗口！ 因为它的显示区域很可能需要超出主窗口客户区！  3.2、桌面窗口与所有顶层窗口（“弹出式”窗口）也是父/子关系，但又有其特殊性：对桌面窗口调用GetWindow函数（指定GW_CHILD标志）可得到第一个顶层窗口的句柄，但对某一个顶层窗口调用GetParent却会返回NULL，不会返回桌面窗口的句柄。  额外说下 拥有/被拥有（owner-owned）关系的窗口表现： 4.1、顶层窗口（“弹出式”窗口）之间可以存在owner-owned关系。owner-owned关系对窗口可见性的影响为：owned窗口永远显示在owner窗口的前面；当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态。（根据这一点，如果窗口A 拥有窗口B,窗口B拥有窗口C,则当窗口A最小化的时候，窗口B被隐藏，但是窗口 C还是可见的）；当owner窗口被销毁的时候，它所拥有的窗口都会被销毁。", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "1. 所有顶级窗口都是桌面窗口的子窗口， 组合框的下拉列表框这样设计，就是为了能够不改变它所在的窗口Z序的情况下，让列表框能显示在置顶窗口之前，如果把它设计为所在窗口的子窗口，那么必须把列表框的父窗口置顶，列表框才能显示在置顶窗口之前  2. 组合框的下拉列表框能像你说的那样“当窗口移动时，列表框跟着动”吗，能“当窗口Z序变化时，列表框也跟着变化”吗（这个其实可以做到，只要设置为TOPMOST即可，但是没有必要），不能，因为它的设计是列表框显示之后，只要在它之外有鼠标点击或者按键事件，列表框就自动隐藏，所以避免了跟随所在窗口移动、动态改变Z序之类的操作", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 12 楼 user-2 的回复:[quote=引用 10 楼 六道佩恩 的回复:] 不过有个问题，它为什么要设为桌面窗口的子窗口？设为顶级窗口不行吗？ 所有顶层窗口（我更愿意称“顶层“窗口为“弹出式”窗口）的父窗口都是桌面。  windows系统中的窗口之间的关系很容易理解错误，个人认为主要原因就在于它有两类窗口（带WS_CHILD风格和不带WS_CHILD风格），却用了同一套窗口之间父子关系建立的API（CreateWindow创建时指定父窗口、SetParent创建后修改父窗口等等）。  所以，你在调用任何有关父子关系的API时，要始终清楚你操作的窗口对象是“弹出式”窗口，还是“子”（带WS_CHILD风格）窗口（我更愿意称“子“窗口为“嵌入式”窗口）。 1.1、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）也为“弹出式”窗口时，这个所谓的“父窗口”，在这时其实是指“拥有者”窗口（owner），窗口A的真正父窗口是桌面。  1.2、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）为“嵌入式”窗口时，系统将找到容纳该“嵌入式”窗口的“弹出式”窗口，以该“弹出式”窗口作为owner窗口。  1.3、Owner窗口一旦指定不能更改。通过GetWindow函数（指定GW_OWNER标志）可获取owner窗口的句柄（如果存在的话）。  1.4、当CreateWindow创建“嵌入式”窗口B时，必须指定一个父窗口（hWndParent参数），父窗口类型不限。“嵌入式”窗口也可以作为其父窗口。   2.1、当调用SetParent修改“弹出式”窗口A的所谓“父窗口”（hWndNewParent）时，窗口A自动变为“嵌入式”窗口（也印证了1.3条所述），且程序员需要手动修正窗口A的风格（加上WS_CHILD,去掉WS_POPUP），否则窗口可能会表现不正常。  2.2、当调用SetParent修改“嵌入式”窗口B的父窗口（hWndNewParent）时，父窗口类型不限（参照1.4）。   拥有父子关系的窗口表现： 3.1、子窗口只能显示在它的父窗口的客户区中，超出父窗口客户区的部分将被裁减掉；父窗口被隐藏时，它的所有子窗口也被隐藏；最小化父窗口不影响子窗口的可见状态，子窗口会随着父窗口被最小化，但是它的WS_VISIBLE属性不变。父窗口被销毁的时候，它的所有子窗口都会被销毁。 由此可见，下拉列表框 必须不能 是程序主窗口的子窗口！ 因为它的显示区域很可能需要超出主窗口客户区！  3.2、桌面窗口与所有顶层窗口（“弹出式”窗口）也是父/子关系，但又有其特殊性：对桌面窗口调用GetWindow函数（指定GW_CHILD标志）可得到第一个顶层窗口的句柄，但对某一个顶层窗口调用GetParent却会返回NULL，不会返回桌面窗口的句柄。  额外说下 拥有/被拥有（owner-owned）关系的窗口表现： 4.1、顶层窗口（“弹出式”窗口）之间可以存在owner-owned关系。owner-owned关系对窗口可见性的影响为：owned窗口永远显示在owner窗口的前面；当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态。（根据这一点，如果窗口A 拥有窗口B,窗口B拥有窗口C,则当窗口A最小化的时候，窗口B被隐藏，但是窗口 C还是可见的）；当owner窗口被销毁的时候，它所拥有的窗口都会被销毁。 [/quote] 又见大佬你了  感谢你把这些完整地说了一遍，修正了我一些理解上的缺失  但是我还是有几个疑问： 1. 顶级窗口的父窗口真的是桌面窗口吗？毕竟GetParent得到的是NULL，凭借对桌面窗口调用GetWindow函数得到第一个顶层窗口的句柄这一点应该也无法说明所有顶级窗口的父窗口是桌面窗口吧？主要是我一直也没看到微软文档说过顶级窗口的父窗口是桌面窗口，不过就“SetParent指定父窗口为NULL时设置桌面窗口为父窗口”，测试结果是设置后GetWindow仍然得到NULL，应该算佐证了“顶级窗口的父窗口真的是桌面窗口”吧。 2. 我测试了下，只有子窗口获取父窗口时，才会显示桌面窗口的句柄。这个列表框为什么一定要设置为WS_CHILD？同为桌面窗口的子窗口的话，顶级窗口不行吗？ 3. 你的4.1我觉得有个地方说错了，“当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态”，可见与否不是看WS_VISIBLE吗，我测过了，拥有者窗口最小化后，拥有的窗口隐藏后，它已经没有WS_VISIBLE样式了，IsWindowVisible也返回0，这应该算是影响了其可见状态吧？", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 11 楼 早打大打打核战争 的回复:1. 所有顶级窗口都是桌面窗口的子窗口， 组合框的下拉列表框这样设计，就是为了能够不改变它所在的窗口Z序的情况下，让列表框能显示在置顶窗口之前，如果把它设计为所在窗口的子窗口，那么必须把列表框的父窗口置顶，列表框才能显示在置顶窗口之前  2. 组合框的下拉列表框能像你说的那样“当窗口移动时，列表框跟着动”吗，能“当窗口Z序变化时，列表框也跟着变化”吗（这个其实可以做到，只要设置为TOPMOST即可，但是没有必要），不能，因为它的设计是列表框显示之后，只要在它之外有鼠标点击或者按键事件，列表框就自动隐藏，所以避免了跟随所在窗口移动、动态改变Z序之类的操作 为什么你们都说顶级窗口是桌面窗口的子窗口？获取顶级窗口父窗口的句柄是NULL呀 还有就是，你还没说将列表框设计为顶级窗口这个方案，这个方案看起来应该也是可行的呀", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 9 楼 六道佩恩 的回复:[quote=引用 8 楼 早打大打打核战争 的回复:]实现很简单，就和组合框的下拉列表框一个套路就可以了，SetParent(LISTBOX_HWND, NULL); 然后显示的时候用SetWindowPos设置HWND_TOP标志把LISTBOX置顶即可 关键是移动窗口呢？窗口的Z序变化呢？[/quote] 我测试了一下，当窗口移动时，列表框没有跟着动，当窗口Z序变化时，列表框也没有跟着变化，看来没我想的那么好。 不过有个问题，它为什么要设为桌面窗口的子窗口？设为顶级窗口不行吗？", "referer": "user-0"}, {"cid": "14", "user": "user-1", "content": "实现很简单，就和组合框的下拉列表框一个套路就可以了，SetParent(LISTBOX_HWND, NULL); 然后显示的时候用SetWindowPos设置HWND_TOP标志把LISTBOX置顶即可", "referer": "user-0"}, {"cid": "15", "user": "user-1", "content": "组合框中的那个LISTBOX的父窗口确实是桌面窗口，所以会有这种效果：  估计这么设计的原因就是为了让它能够在不改变顶级窗口位置关系的情况下完整显示出来", "referer": "user-0"}, {"cid": "16", "user": "user-0", "content": "引用 6 楼 早打大打打核战争 的回复:组合框中的那个LISTBOX的父窗口确实是桌面窗口，所以会有这种效果：  估计这么设计的原因就是为了让它能够在不改变顶级窗口位置关系的情况下完整显示出来  那么这种效果是我们自己无法实现的是吗？", "referer": "user-0"}, {"cid": "17", "user": "user-1", "content": "可以突破父窗口的范围有什么奇怪，只要建立的窗口风格不是child，比如overlapped、popup之类的，都可以突破父窗口的范围 至于列表框其父窗口是桌面窗口这个还有待确认", "referer": "user-0"}, {"cid": "18", "user": "user-0", "content": "引用 4 楼 早打大打打核战争 的回复:可以突破父窗口的范围有什么奇怪，只要建立的窗口风格不是child，比如overlapped、popup之类的，都可以突破父窗口的范围 至于列表框其父窗口是桌面窗口这个还有待确认        你看看这些证据够不够，前三张是根据鼠标位置获取窗口句柄和相关信息，后四张是spy++的，用来佐证这里的获得的确是父窗口而不是拥有者窗口，鼠标用来提示获取的是哪个窗口 这里明显能看到，这里的组合框就是大窗口的子窗口，但它的列表框已经超出了组合框的父窗口了；还有就是，这里列表框的父窗口句柄对比GetDeskWindow获得的桌面窗口句柄，是一样的，它的父窗口是桌面窗口", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "引用 1 楼 zgl7903 的回复:https://docs.microsoft.com/en-us/cpp/mfc/reference/ccombobox-class?view=msvc-160#remarks 组合框由与静态控件或编辑控件组合在一起的列表框组成 引用 2 楼 早打大打打核战争 的回复:顾名思义，名字都叫“组合框”啊，就是EDIT和LISTBOX组合呀~~~  你们没get到我的问题啊  组合框的列表框可以突破它（组合框）本身的窗口范围，甚至可以突破父窗口的范围，查该列表框发现其父窗口是桌面窗口  我的问题在于，它是怎么实现的（指该组合框的列表框）？如果由我们自己来实现的话，有办法实现吗？", "referer": "user-0"}, {"cid": "20", "user": "user-1", "content": "顾名思义，名字都叫“组合框”啊，就是EDIT和LISTBOX组合呀~~~", "referer": "user-0"}]}
{"question": "二次方程的根", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if(delta=0) 改成if(delta==0)", "referer": "user-0"}]}
{"question": "想问一下for循环中的一些问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "中间i，表示i==0时退出for循环。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "中间那个变量忘记删了，只看n，i就行了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "for循环结构：for(初始化变量；结束条件；每次执行操作) （具体的名词忘了） 所以i/=10每次除以10，中间的i是一个逻辑运算，i==0的时候退出", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:中间i，表示i==0时退出for循环。 哦哦哦  懂了 谢谢", "referer": "user-0"}]}
{"question": "non-class type'char[20]' 这个怎么改啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看你的char[20] 你是不是想定义一个字符串一维数组； 如果是你应该给你想要定义的字符串取一个名字像str；所以你可以这样写char str[20]; 如过你仅仅是想要定义一个字符的话你可以这样写char a;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "char是数据类型，要这么写 char s[20]才行", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:贴出代码看看 谢谢你啊，我已经改好了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "贴出代码看看", "referer": "user-0"}]}
{"question": "为啥出错啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "对弈变量的大小写，另外，引入头文件时也要注意大小写；从编译提示上应该没有正确引入头文件。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 4 楼 棉猴的回复:不是students，是student这个结构 结构写在student.h里面，在主函数(student_system.c)里又写了#include \"student.h\"。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不是students，是student这个结构", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 2 楼 棉猴的回复: 从出错提示上看，应该是你的结构struct student没有定义完整。也就是说，在调用average()函数时，student可能只有声明没有定义 我在主函数那里声明了struct student students[50];", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "从出错提示上看，应该是你的结构struct student没有定义完整。也就是说，在调用average()函数时，student可能只有声明没有定义", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "Count的C是小写", "referer": "user-0"}]}
{"question": "C++怎么输出两个个字符串相加，求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "char str[100] = { 0 }; \tchar *x = \"abc\"; \tchar *y = \"def\"; \tstrcpy(str, x); \tstrcpy(str + strlen(x), y); \tprintf(\"z=%s\", str);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你是在用c++（而不是c），所以你的直觉是对的，我们当然可以写 z= a+b; #include <iostream> void foo()  { \tstd::string a(\"c++:\"); \tstd::string b(\"z=a+b\"); \tstd::string z = a + b; \tstd::cout << z.c_str() << std::endl; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "C++版： #include <iostream> using namespace std;  int main(void) { \tstring x = \"abc\"; \tstring y = \"def\"; \tstring z; \t \tz = x + y; \tcout << \"z = \" << z << endl; \t \treturn 0; }  C版： #include <stdio.h>  int main(void) { \tchar str[100]; \tchar *x = \"abc\"; \tchar *y = \"def\"; \tchar *z = str; \t \twhile(*x) *z++ = *x++; \twhile(*y) *z++ = *y++; \t \tz = str; \tprintf(\"z = %s\\n\", z); \t \treturn 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "可以通过strlen（）函数和for循环将两个字符串数组组合起来，将组合后的字符串输出便可以实现所谓的字符串相加了", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "改成 z=str; strcpy(z, a); strcat(z, b); printf(“z=%s”, z);", "referer": "user-0"}]}
{"question": "C语言学习过程中的问题讨论", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 ctrigger的回复:先看书入门，再写代码巩固和提高。别无他法。。 高手自律，自学习惯，太多人不能坚持，遇到点问题直接放弃", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "先看书入门，再写代码巩固和提高。别无他法。。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:建议针对具体问题来讨论～ 这个论坛的主要目的是为了给初学者提供一个讨论的地方，比如来看我视频教程的同学遇到问题，就可以在这里讨论 这里是我的视频教程 欢迎大家积极参与，所以没有设置具体的讨论问题，可能做得还不够完善，谢谢您的建议！", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "建议针对具体问题来讨论～", "referer": "user-0"}]}
{"question": "STM32编程", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在stm32f10.h中首行添加这两段代码：#ifndef __stm32f10x_h#define __stm32f10x_h 末行添加这一行代码：#endif /__stm32f10x_h/", "referer": "user-0"}]}
{"question": "第七行的3是什么意思啊!搞不明白", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 Spectre Ghost 的回复:这是位运算呀 2*1=2 3左移两位然后取反", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这是位运算呀", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "a&=~(3<<2*1)   a=a&(~(3<<2*1)) 3(0000 0000 0000 0011)左移两位就是12(0000 0000 0000 1100)，取反(1111 1111 1111 0011)，再按位与就是把低3、4位置0，其余保留。", "referer": "user-0"}]}
{"question": "C语言 求大佬帮忙！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 ctrigger 的回复:用IF语句： int hahaha(int x, int y, int a, int b) {     int result = -1;          int ad = b - a*x;     int aa = y - x;          if(ad % aa == 0) result = ad / aa;      return result;     }感谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "用IF语句： int hahaha(int x, int y, int a, int b) {     int result = -1;          int ad = b - a*x;     int aa = y - x;          if(ad % aa == 0) result = ad / aa;      return result;     }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 阿麦 的回复:这是数学题啊  int hahaha(int x, int y, int a, int b) {     int ad = b - a*x;     int aa = y - x;      return ad % aa == 0 ? ad / aa : -1; } 如果if 怎么写呢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 1 楼 阿麦 的回复:这是数学题啊  int hahaha(int x, int y, int a, int b) {     int ad = b - a*x;     int aa = y - x;      return ad % aa == 0 ? ad / aa : -1; } 感觉和鸡兔同笼的问题有那么一点点相似", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "这是数学题啊  int hahaha(int x, int y, int a, int b) {     int ad = b - a*x;     int aa = y - x;      return ad % aa == 0 ? ad / aa : -1; }", "referer": "user-0"}]}
{"question": "请问这个问题出在哪里 谢谢大佬们", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "这个是题目", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 2 楼 一颗白面馒头 的回复:]n没有初始化？你输入的数都没有按照你的想法保存在a数组里 对，主要问题在这里。  下面的循环也有问题，i >= 0这不就是一个死循环了吗？ 整个程序都感觉很奇怪～ [/quote] 哈哈哈，吃了炫迈的for循环？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 一颗白面馒头 的回复:n没有初始化？你输入的数都没有按照你的想法保存在a数组里 对，主要问题在这里。  下面的循环也有问题，i >= 0这不就是一个死循环了吗？ 整个程序都感觉很奇怪～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "有人说在 \"%d\"前加一个空格，即 \" %d\"，不知道灵不灵 另外： 第一、n 没有赋初值，危险，这样 n 可能会是任何值，导致 core dump 第二、for(int i=0; i>=0; i++) 这个循环不会结束的，会运行到天荒地老", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "n没有初始化？你输入的数都没有按照你的想法保存在a数组里", "referer": "user-0"}]}
{"question": "求教，这个连等式该如何理解？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:根据链式队列的特点：先进先出，从头出，从尾进的特点，因此入队跟队尾有关系，C和D都跟队头有关，因此不会选。  p->next  = rear->next;是把rear的next（一般是NULL）赋值给p->next；一般是NULL，但是不清楚链表创建，所以这样写p->next  = rear->next;比较保险； rear = rear->next = p;先从右向左计算，p赋值给rear->next;然后rear->next赋值给rear，因此最后是把p放到队尾，并且让rear指向p； 哇，谢谢大神，讲的非常清楚。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "根据链式队列的特点：先进先出，从头出，从尾进的特点，因此入队跟队尾有关系，C和D都跟队头有关，因此不会选。  p->next  = rear->next;是把rear的next（一般是NULL）赋值给p->next；一般是NULL，但是不清楚链表创建，所以这样写p->next  = rear->next;比较保险； rear = rear->next = p;先从右向左计算，p赋值给rear->next;然后rear->next赋值给rear，因此最后是把p放到队尾，并且让rear指向p；", "referer": "user-0"}]}
{"question": "c语言指针与结构体", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 8 楼 棉猴的回复:printf()函数的%d和%s打印内容时要求的参数格式不同，%d打印时，后面直接跟变量名，而%s打印时需要跟变量地址。所以  int *a = &b; printf(\"%d\\n\", *a);//------*a是指针指向的内容------- char *pa = arr; printf(\"%s\", pa);//---------pa是指针----------  所以您说的打印pc指向的内容时，因为pc本身就是指针，所以不需要加* 好的，明白了，非常感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "printf()函数的%d和%s打印内容时要求的参数格式不同，%d打印时，后面直接跟变量名，而%s打印时需要跟变量地址。所以  int *a = &b; printf(\"%d\\n\", *a);//------*a是指针指向的内容------- char *pa = arr; printf(\"%s\", pa);//---------pa是指针----------  所以您说的打印pc指向的内容时，因为pc本身就是指针，所以不需要加*", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 6 楼 棉猴的回复:\t printf(\"%s\\n\", t.pc);//--------打印t.pc指向的内容------------ printf(\"%p\\n\", t.pc);//--------打印t.pc本身的内容------------  VS2015 C++环境调试结果  其中，0x004ffb94就是t.pc本身的内容，0x004ffb94这个地址上的内容是\"hello bit\\n\"  对于printf()函数的%p的详细用法，请参考 《C++中printf()函数的用法10-6》 希望能够帮到您！ 第二个打印地址懂了，但是第一个还是有点懵比如说int *a;int b=3;a=&b;打印*a就是就意味着打印b里面的值吗？相比那个题目*pc不是意味打印arr数组里面的值吗", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "printf(\"%s\\n\", t.pc);//--------打印t.pc指向的内容------------ printf(\"%p\\n\", t.pc);//--------打印t.pc本身的内容------------  VS2015 C++环境调试结果  其中，0x004ffb94就是t.pc本身的内容，0x004ffb94这个地址上的内容是\"hello bit\\n\"  对于printf()函数的%p的详细用法，请参考 《C++中printf()函数的用法10-6》 希望能够帮到您！", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 3 楼 qybao的回复:没有t.*pc，只有*t.pc //pc才是成员，char *pc只是说成员pc是个char*类型，并不是说成员是*pc，类型是char。好好理解一下区别。 我理解的是*p解析arr首元素地址，等于arr里面存放的变量", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 3 楼 qybao的回复:没有t.*pc，只有*t.pc //pc才是成员，char *pc只是说成员pc是个char*类型，并不是说成员是*pc，类型是char。好好理解一下区别。 你如果是打印pc地址应该是什么呢", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "没有t.*pc，只有*t.pc //pc才是成员，char *pc只是说成员pc是个char*类型，并不是说成员是*pc，类型是char。好好理解一下区别。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "t. *pc要求pc是实例成员指针类型char *S::pc;参见《C++程序设计精要教程》各种指针混合的用法P131,P298: 包括C普通指针，实例成员指针，静态成员指针以及基于类模板的各种指针等。", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "引用char *pc  == (char *)(pc) char *pc  !=  (char)(* pc) 括号仅用于帮助理解。", "referer": "user-0"}]}
{"question": "小B的任务", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "去年11月21日的代码 #include<stdio.h> #include<string.h> int main() {     int T,n,s,sum=0,res=0,d;     scanf(\"%d%d\",&T,&n);     d=n;     int a[n+5],b[n+5],i=1,j;     while(d>0)     {         scanf(\"%d %d\",&a[i],&b[i]);         //printf(\"%d %d\\n\",a[i],b[i]);         i++;         d--;     }     for(i=1;i<n;i++)     {         for(j=i+1;j<=n;j++)         {             if(a[i]>a[j])             {                 s=a[i];                 a[i]=a[j];                 a[j]=s;                                  s=b[i];                 b[i]=b[j];                 b[j]=s;             }         }     }     for(i=1;i<=n;i++)     {         for(j=1;j<=b[i];j++)         {             sum=sum+a[i];              res++;             if(sum>=T)             {                 goto out;                              }         }     }     out:         printf(\"%d\\n\",res);     return 0; }", "referer": "user-0"}]}
{"question": "二进制数直接转float转不了，请问一下问题出在哪里？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "前面的回答少写了个解引用，printf(\"%f\\n\",*(float*)&f.a); 另外看了下，发现你对浮点型的结构有误解  #include \"stdio.h\" int main( void ) { \tint a=0x3FC00000; \tprintf(\"%f\", *(float*)&a );  \treturn 0; }   另外，可变参数那里，具体会因编译器而有所不同，转8字节这个，gcc是这样的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把b的类型换成8字节的long long，然后你赋值的这个浮点二进制改为64位结构的。 原因是对于可变参数的处理，整型转8字节，浮点型转double，你这里它认为的是整型，所以按仅填了4字节，而%f要读8字节。、 第二种方法就是让编译器认为你传的是4字节float类型，帮你自动转，方法是，printf(\"%f\\n\",(float*)&f.a);", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "1.125转换成二进制是1.001，指数是0，而而指数位的起始值是127，所以指数值是0111 1111，符号位是0，尾数位是001 0000 0000 0000 0000 0000，所以合在一起的值是0011 1111 1001 0000 0000 0000 0000 0000，而变量使用主机字节序存储（大头big-endian），即低地址保存数值的低位，高地址保存数值的高位，所以1.125对应的二进制值是0x0000903f float f1 = 0.0f; \tint i1 = 0x3f900000;//---------注意，i1是主机字节序------- \tCopyMemory(&f1, &i1, sizeof(i1));//----f1的值变为1.125----------  请参考《C++浮点型变量的存储方式》 希望能够帮到您！", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "你算的不对 1.0125 ，转为2进制是1.0000001100110011...... 指数是1，尾数是0000001100110011..... 符号位0，指数是0。 16进制就是3f81999a", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "我用的系统是centos7", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "现在可以转了，但是问题是数据不对，  #include<stdio.h>   2 #include<stdlib.h>   3 union Ui{   4     float a;   5     int b;   6 }ui;   7    8 int main(){   9     union Ui f;  10    f.b=0x3d000009;  11     printf(\"%f\\n\",f.a);  12     return 0;  13 } ~     0x3d000009对应二进制的话 0为符号位 指数为为0x7c     表示的值应该是0x7c-0x7f=-3 尾数位为0x09 二进制为1001 二进制的小数为为三位则小数位的10进制应该为0.125其整数位的十进制为1 结果应该为 1.0125 实际给的值却是 0.031250 二进制为 00001 为什么会这样呢？", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "union U {  float f;  int d; } u; u.d=-0x3d800005; printf(\"%f\\n\",u.f);", "referer": "user-0"}]}
{"question": "为何未停在'='？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 9 楼 自信男孩的回复:[quote=引用 6 楼 陳錄生 的回复:][quote=引用 4 楼 NorZ的回复:][quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote]  ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？[/quote] 也没看到pkey指向buf的操作呢[/quote] FREEBSD CC", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 6 楼 陳錄生 的回复:[quote=引用 4 楼 NorZ的回复:][quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote]  ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？[/quote] 也没看到pkey指向buf的操作呢", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "pkey是野指针，没看到它指向可以正常读写的内存区域，也没有malloc呢。怎么可以使用呢？ 即使能够用，但不能保证一直能用～  还有pkey即使指向了可以读写的内存，那么遇到'='没有加'\\0'，%s输出的时候会继续向后输出，直到遇到'\\0'", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 6 楼 陳錄生 的回复:[quote=引用 4 楼 NorZ的回复:][quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote]  ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？[/quote]  关键你并没有这样的赋值操作呀...你不如循环结束后给 pkey[pos] 赋值 '\\0' 再打印看看，或者循环结束后打印 pos 的值，才能确定是不是没有被 != '=' 卡住", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 4 楼 NorZ的回复:[quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote]  ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "本身代码的逻辑上，没有什么问题，pkey多赋值了一个空格，影响不大，就是为啥能执行，我很好奇", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "引用 3 楼 陳錄生 的回复:[quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote]  ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 NorZ的回复:你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "你这个程序居然能跑起来。。。内存越界了啊，一个指针不能存东西的，要么定义成char数组，要么用malloc动态分配", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？", "referer": "user-0"}]}
{"question": "求助C语言的feof", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "Thanks", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 赵4老师的回复:不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。  这代码看了头晕。Thanks all the same.", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "修改一下，这样看看行不行？  #include <stdio.h>  int main(void) { \tFILE *fp; \tchar buf[BUFSIZ]; \t \tif((fp = fopen(__FILE__, \"r\")) == NULL) \t{ \t\tperror(\"fopen\"); \t\treturn 1; \t} \t \twhile(!feof(fp) && fgets(buf, BUFSIZ, fp)) \t{ \t\tprintf(\"%s\", buf); \t} \t \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "先判断返回值再打印，再while判断 feof", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "判断一下fgets返回值，读到EOF时会返回NULL，然后break出循环就好了～", "referer": "user-0"}]}
{"question": "求助，switch ... case 语句用法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "逗号分隔还是要写每个case的，case范围扩展可以只写区间两端，case 'a'...'z' 代表26个case，还是非常有用的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "GCC的case范围扩展，从Pascal学来的，GCC和clang/llvm都支持", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复:语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。说得对，算了，不纠结了", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "C/C++不支持switch case的这种写法。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "哎呀，我还没用过 'a'...'z' 这种写法 真的可以吗", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "逗号分隔是可以的，不能用..., vs2019警告但还是可以编译的", "referer": "user-0"}, {"cid": "8", "user": "user-6", "content": "你选的语言不是c/c++吧？", "referer": "user-0"}, {"cid": "9", "user": "user-7", "content": "直接用if...else 判断ASCII码范围", "referer": "user-0"}, {"cid": "10", "user": "user-8", "content": "写全了吗，写全了的话就是少了个结尾的花括号", "referer": "user-0"}]}
{"question": "大佬们求问哪里出了问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "看到缩进格式全无的代码，顿时毛骨悚然。。。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:标点符号没有进入这个if((str[i]>='a'&&str[i]<='z') || (str[i]>='A'&&str[i]<='Z') || (str[i]>='0'&&str[i]<='9')||(str[i]==32))，所以标点符号没有被做任何处理。 应该怎么修改呢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "标点符号没有进入这个if((str[i]>='a'&&str[i]<='z') || (str[i]>='A'&&str[i]<='Z') || (str[i]>='0'&&str[i]<='9')||(str[i]==32))，所以标点符号没有被做任何处理。", "referer": "user-0"}]}
{"question": "这个该怎么改啊，求大佬带", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%s %d\", &str[10], &a); 改成 scanf(\"%s %d\", str, &a); //str数组名就是字符串首地址， &str[10]是下标为10的元素的地址，数组越界（数组下标只到9） strcmp(str[10], \"triange\") 改成 strcmp(str, \"triange\"); //str[10]是一个元素（只有1个字符，不是字符串，字符串用数组名就可以了）", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:scanf中对于str有问题  scanf(\"%s%d\", str, &a);  strcmp的第一个参数应该是str而不是str[10]  楼主需要复习一下数组，数组名，数组首地址等等，已经函数调用的参数的类型 现在通过啦，太感谢了*⸜( •ᴗ• )⸝*❤️", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "scanf中对于str有问题  scanf(\"%s%d\", str, &a);  strcmp的第一个参数应该是str而不是str[10]  楼主需要复习一下数组，数组名，数组首地址等等，已经函数调用的参数的类型", "referer": "user-0"}]}
{"question": "求助again  ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include <math.h>  #define N 10 #define M 10   int is_prime(int n) {     int i, tm;      if (n < 2)         return 0;      tm = sqrt(n);     for (i = 2; i <= tm; i++)         if (n % i == 0)             return 0;      return 1; }  void sort(int *arr, int size) {     int i, j;     int tmp;      for (i = 0; i < size; i++)         for (j = 0; j < size - i -1; j++)             if (arr[j] > arr[j+1]) {                 tmp = arr[j];                 arr[j] = arr[j+1];                 arr[j+1] = tmp;             } }  void show(int *arr, int size) {     int i;      for (i = 0; i < size; i++)         printf(\"%d \", arr[i]);     putchar(10); }  int main () {     int cnt, len, tmp;     int array[N];     int i, j, k;       scanf(\"%d\", &cnt);      for (i = 0; i < cnt; i++) {         scanf(\"%d\", &len);         if (len > N)             len = N;         k = 0;         for (j = 0; j < len; j++) {             scanf(\"%d\", &tmp);             if (is_prime(tmp))                 array[k++] = tmp;         }         sort(array, k);         show(array, k);     }  #if 0     int a[M][N],b[M][N],s[M],n,i,j;     int c=0;     scanf(\"%d\",&n);     for(i=0;i<n;i++)       {scanf(\"%d\",&a[i][0]);         for(j=1;j<=a[i][0];j++)             {scanf(\"%d\",&a[i][j]);              if (prime(a[i][j]))                  {b[i][c]=a[i][j];                  c++;                  }             }          s[i]=c;          c=0;       }     for(i=0;i<n;i++)         px(b[i],s[i]);     for(i=0;i<n;i++)         {for(j=0;j<s[i];j++)             printf(\"%-2d\",b[i][j]);         printf(\"\\n\");} #endif     return 0; }  #if  0 int prime( int p ) {     int i,f;     if(p<=1)         f=0;     else        {f=1;       for(i=2;i<p;i++){          if(p%i==0)             f=0;}        }     return f; } void px(int a[],int n) {     int i,j,k,t;     for(i=0;i<n-1;i++)          for(j=0;j<n-i-1;j++)             if(a[j]>a[j+1])             {               t=a[j];               a[j]=a[j+1];               a[j+1]=t;             }  } #endif 供参考～  题目要求是输入的整数是<= 10，没说是输入的n（楼主定义的）也是10，如果n是大于10的，会出现数组越界，出现段错误；", "referer": "user-0"}]}
{"question": "VS2019中数据结构线性表status未定义标识符应该怎么解决？求大神指点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:注意单词的大小写，status确实没有定义，楼主应该用Status？  从代码上看，完全可以typedef int Status; 试试，主要看一下OK是什么？ 解决了，三克油", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "解决了，三克油", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "注意单词的大小写，status确实没有定义，楼主应该用Status？  从代码上看，完全可以typedef int Status; 试试，主要看一下OK是什么？", "referer": "user-0"}]}
{"question": "C语言一道题没报错为啥运行不出结果？？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我直接打印一下a，你看这样觉得合理嘛，0*0*0", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 limeilu110的回复:如果！整段程序运行下来没有跟预期要输出的值相匹配的结果！！！那这段程序什么都不做也可以理解啊！       建议跟踪一下个个环节的变量值变化！！！看程序有没有按设计的运行！！ 我刚运行了下，也追踪了其中两个变量～～i,a的变化！运行过程中变量在按程序的设计走！但是没有匹配的结果！所以程序感觉上什么都没有做！！！！没有匹配的结果！！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "如果！整段程序运行下来没有跟预期要输出的值相匹配的结果！！！那这段程序什么都不做也可以理解啊！       建议跟踪一下个个环节的变量值变化！！！看程序有没有按设计的运行！！", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "那是因为printf所在if判断条件不满足，建议楼主把i++到if (i == xxx) {}之后，即while循环内的最后位置。  改一下位置再试试。", "referer": "user-0"}]}
{"question": "如何将此小程序从递归改成循环?", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "float proc(float f1, float f2, char m) {\t \tswitch (m) \t{ \tcase '+': \t\treturn f1 + f2; \t\tbreak; \tcase '-': \t\treturn f1 - f2; \t\tbreak; \tcase '*': \t\treturn f1 * f2; \t\tbreak; \tcase '/': \t\treturn f1 / f2; \t\tbreak;  \tdefault: \t\tabort(); \t\tbreak; \t} }  float fun2(const char ch[100]) { \tfloat f[100];\t\t// 参数 \tint ifCnt = 0;\t\t// 参数个数  \tchar m[100] = { 0 }; // 方法 \tint imCnt = 0;  \tchar ch2[100]; \tif (!ch || !ch[0]) \t\tabort();\t \tstrncpy_s(ch2, 100, ch, 100);  \tint iBegin = 0, iEnd = 0; \tint i = 0; \tfor (; (i < 100) && (ch2[i] != '\\0'); ++i) \t{ \t\tswitch (ch2[i]) \t\t{ \t\tcase '*': \t\tcase '/': \t\tcase '+': \t\tcase '-': \t\t\tif (i == 0) \t\t\t\tabort();  \t\t\tiEnd = i;\t \t\t\tm[imCnt++] = ch2[iEnd]; \t\t\tch2[iEnd] = '\\0'; \t\t\tf[ifCnt++] = atof(&ch2[iBegin]); \t\t\tiBegin = iEnd + 1; \t\t\tbreak;  \t\tcase '0': \t\tcase '1': \t\tcase '2': \t\tcase '3': \t\tcase '4': \t\tcase '5': \t\tcase '6': \t\tcase '7': \t\tcase '8': \t\tcase '9': \t\tcase '.': \t\t\tbreak;  \t\tdefault: \t\t\tabort(); \t\t} \t}  \tf[ifCnt++] = atof(&ch2[iBegin]);  \t{ \t\tfloat fResult = f[0]; \t\tint ifCur = 1; \t\tfor (i = 0; i < imCnt; ++ifCur) \t\t{ \t\t\tfResult = proc(fResult, f[ifCur], m[i++]); \t\t}  \t\treturn fResult; \t} }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "float proc(float f1, float f2, char m) {\t \tswitch (m) \t{ \tcase '+': \t\treturn f1 + f2; \t\tbreak; \tcase '-': \t\treturn f1 - f2; \t\tbreak; \tcase '*': \t\treturn f1 * f2; \t\tbreak; \tcase '/': \t\treturn f1 / f2; \t\tbreak;  \tdefault: \t\tabort(); \t\tbreak; \t} }  float fun2(const char ch[100]) { \tfloat f[100];\t\t// 参数 \tint ifCnt = 0;\t\t// 参数个数  \tchar m[100] = { 0 }; // 方法 \tint imCnt = 0;  \tchar ch2[100]; \tif (!ch || !ch[0]) \t\tabort();\t \tstrncpy_s(ch2, 100, ch, 100);  \tint iBegin = 0, iEnd = 0; \tint i = 0; \tfor (; (i < 100) && (ch2[i] != '\\0'); ++i) \t{ \t\tswitch (ch2[i]) \t\t{ \t\tcase '*': \t\tcase '/': \t\tcase '+': \t\tcase '-': \t\t\tif (i == 0) \t\t\t\tabort();  \t\t\tiEnd = i;\t \t\t\tm[imCnt++] = ch2[iEnd]; \t\t\tch2[iEnd] = '\\0'; \t\t\tf[ifCnt++] = atof(&ch2[iBegin]); \t\t\tiBegin = iEnd + 1; \t\t\tbreak;  \t\tcase '0': \t\tcase '1': \t\tcase '2': \t\tcase '3': \t\tcase '4': \t\tcase '5': \t\tcase '6': \t\tcase '7': \t\tcase '8': \t\tcase '9': \t\tcase '.': \t\t\tbreak;  \t\tdefault: \t\t\tabort(); \t\t} \t}  \tf[ifCnt++] = atof(&ch2[iBegin]);  \t{ \t\tfloat fResult = f[0]; \t\tint ifCur = 1; \t\tfor (i = 0; i < imCnt; ++ifCur) \t\t{ \t\t\tfResult = proc(fResult, f[ifCur], m[i++]); \t\t}  \t\treturn fResult; \t} }", "referer": "user-0"}]}
{"question": "有大佬知道为什么do while循环里重复定义结构指针是可以的呢，还有给结构指正赋NUll是怎么回事，有啥好处", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢，我另写了一个循环，还真是这样", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "在循环结构里虽然看着是循环定义，其实编译器只会定义一次，因为在do ... while是一个代码块，这部分的last只会定义一次。后面的直接使用上次定义的。  用NULL的好处是，作为链表结束的标记，因为链表是next指向下一个，什么时候到达末尾了?NULL是一种方法。  楼主的代码少一个大括号，匹配if (number != -1)的   #include<stdio.h> #include<stdlib.h>  typedef struct _node{     int value;     struct _node *next; }Node;  int main(int argc,char const *argv[]) {     Node *head=NULL;     int number;     do {         scanf(\"%d\",&number);         if(number!=-1){             Node *p=(Node *)malloc(sizeof(Node));             p->value=number;             p->next=NULL;             Node *last=head;             if(last){                 while(last->next){                     last=last->next                 }                 last->next=p;             }             else {                 head=p;             }         }     }while(number!=-1);      return 0; } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "那为什么 int *p=a； int *p=b； 不行呢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "在循环里不断给新结点分配内存，指针p是移动的，不存在重复定义。给指针赋值NULL是初始化，不然可能变成野指针，不知道指向哪儿了。", "referer": "user-0"}]}
{"question": "初学乍练，这几句程序什么意思？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "好的，多谢提示。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "建议楼主找一下你的代码工程，应该有地方用typedef了V_U32和V_UCHAR  其实可以这么理解：V_U32就是unsigned int，V_UCHAR是unsigned char。  最好找一下定义的地方。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "请帮忙解释一下，V_U32  blockse;   V_UCHAR *ramaddr 这两句的V_U32和V_UCHAR是什么东西，为什么这么用？", "referer": "user-0"}]}
{"question": "win10系统 c-free5.0无法运行  怎么都不行 是路径出问题了吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "现在的电脑配置都无比强悍，建议用最大众化的IDE。比如 VISUAL STUDIO 2019，号称宇宙第一IDE，编程和调试都很方便。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "建议dev-c++：https://sourceforge.net/projects/embarcadero-devcpp/ 或者：https://www.filehorse.com/download-dev-c/", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "没使用过这个工具 建议不如换一个啊 VS只用序列号就可以激活 如果想要占用空间少的 可以CodeBlocks 或CodeLite 这两款我试过 确定没问题的", "referer": "user-0"}]}
{"question": "大佬们萌新实在整不明白这俩个咋打了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢大佬。。。。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "改成 scanf(“%s”, s); for(i=0; i<80&&s[i]!=‘\\0’; i++) {//要用循环     if((s[i]>=‘a’&&s[i]<=‘z’) || (s[i]>=‘A’&&s[i]<=‘Z’) || (s[i]>=‘0’&&s[i]<=‘9’))         printf(“%c”, s[i]); }", "referer": "user-0"}]}
{"question": "指向指针的指针问题，在线等，问题见二楼", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你要想想，进入for(; *last; last=&(*last)->next); 退出循环的条件是什么？是*last不成立，也就是*last==null，那么*last什么时候会==null？那不就是*last=Node1.next才是null吗（因为Node1不是null）？所以(*last->next)=malloc是错的，因为*last已经是null了，*last->next本身就是错的（相当于null->next），所以，*last=malloc才是正确的。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "不明白为啥要用二级指针，只有一个主函数完全没有必要这样。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "第一次进入for( ; *last; last=&(*last)->next );由于last指向head，head指向NULL，所以不执行for循环，后面的语句让head指向了第一个节点Node1；第二次进入for( ; *last; last=&(*last)->next )循环时*last也就是head是指向Node1的，所以会让last指向最新一节Node1。下面把Node2联接到Node1上，不应该是 (*last-next） = (Node *)malloc( sizeof(Node) )吗?", "referer": "user-0"}]}
{"question": "VS2019使用strlen()函数时，为啥后面多了乱码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 user-2 的回复:字符串要有结束符'\\0'，否则就会一直输入内存信息直到遇到字符串结束符 所以 puts(flag); outflag[strlen(flag)] = '\\0'; //这里追加设定字符串结束符 puts(outflag);  另外，flag[i] ^ 1 有可能导致运算结果是非显示字符，这样outflag显示的内容也不一定能看得到  楼主申请的空间少一个'\\0'的位置，所以，outflag[strlen(flag)] = '\\0';这样操作会导致内存越界操作～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "字符串要有结束符'\\0'，否则就会一直输入内存信息直到遇到字符串结束符 所以 puts(flag); outflag[strlen(flag)] = '\\0'; //这里追加设定字符串结束符 puts(outflag);  另外，flag[i] ^ 1 有可能导致运算结果是非显示字符，这样outflag显示的内容也不一定能看得到", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>  int main() {     /*const char* flag;       char* outflag;       flag = \"ZmxhZ3tzaG91a2FrdX0=\";       outflag = (char*)malloc(BASE64_DECODE_OUT_SIZE(strlen(flag)));       base64_decode(flag, strlen(flag), outflag);       puts(outflag);       free(outflag);       return 0;*/     int i;     char* flag;     flag = \"ZmxhZ3t9CgoK\";     char* outflag = (char*)malloc(strlen(flag) + 1);     for (i = 0; i < strlen(flag); i++)     {         outflag[i] = flag[i] ^ 1;     }     outflag[i] = 0;   //add '\\0'     puts(flag);     puts(outflag);     free(outflag);     return 0; }  供参考～  注意'\\0'，出现乱码，对于字符串而言，大部分都是因为'\\0'导致（没在对应的字符串结尾加上'\\0'导致）", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf_s替换scanf，注意这两者的区别，详细的请查阅scanf_s的使用", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "也可以输入# pragma warning (disable : 4996)消除此类警告", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "Embarcadero Dev-Cpp比较友好，使用更方便。 最新版：Embarcadero_Dev-Cpp_6.1_TDM-GCC_9.2_Setup.exe", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "请看提示  大概的意思是“scanf函数已经不安全了，请使用scanf_s()函数代替scanf()函数” 如果您觉得使用scanf_s()函数不方便，还是习惯使用scanf()函数，请参考 《VS2015中使用scanf()不报错的设置方法》 希望能够帮到您！", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "提示你scanf函数不安全，改为用 scanf_s函数", "referer": "user-0"}]}
{"question": "代码有误，样例只有第一个输出正确，不知错误在哪，求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 8 楼 forlorn pedestrian的回复:引用[quote]\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗 我觉得，你把第三项和第1，2项的关系表达式写一下，就明白了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "公式，是你算第n项，仅仅算n项，带进去n才有效。 这个算法是，先算第0和第1项，然后根据0，1项，算出第2项。。。然后根据第1，2项，算出第3项。。。依次类推 算出第n项。。。 那么，算第2项时，公式里n=2，是不是就没毛病了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 8 楼 forlorn pedestrian的回复:引用[quote]\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗 算第n项的时候，代n进去没错。 但你这个算法是，先算第0项和第一项，然后算第二项，依次类推，算出第n项。。 算第三项的表达式时，公式里n=3 算第四项时，公式里n=4", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 11 楼 自信男孩的回复:[quote=引用 2 楼 weixin_46056697 的回复:]我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了 你改一下试试？问题没看到重点，建议自己试试～[/quote] 确实，我的错，没注意", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 2 楼 weixin_46056697 的回复:我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了 你改一下试试？问题没看到重点，建议自己试试～", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 9 楼 自信男孩 的回复:#include<stdio.h>  int main() {     //float x, /*n,*/ c, a, b;     double x, /*n,*/ c, a, b;     int n, i;      //scanf_s(\"%f%d\", &x, &n);     scanf(\"%lf%d\", &x, &n);     if (n == 0) {         c = 1;         printf(\"%.2lf\", c);         return 0;     }     if (n == 1) {         c = x;         printf(\"%.2lf\", c);         return 0;     }     a = 1.0;     b = x;     for (i = 2; i <= n; i++) {         //c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a;         c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a;         a = b;         b = c;     }     printf(\"%.2lf\", c);     return 0;  } 供参考～ 把scanf改成scanf_s吧", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "#include<stdio.h>  int main() {     //float x, /*n,*/ c, a, b;     double x, /*n,*/ c, a, b;     int n, i;      //scanf_s(\"%f%d\", &x, &n);     scanf(\"%lf%d\", &x, &n);     if (n == 0) {         c = 1;         printf(\"%.2lf\", c);         return 0;     }     if (n == 1) {         c = x;         printf(\"%.2lf\", c);         return 0;     }     a = 1.0;     b = x;     for (i = 2; i <= n; i++) {         //c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a;         c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a;         a = b;         b = c;     }     printf(\"%.2lf\", c);     return 0;  } 供参考～", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用[quote]\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "1.a,b赋初值不应该在for循环里，否则a,b一直被赋初值，你的递归就无效了； 2.不应该带n去算，因为计算P2时，n=2,计算P3时，n=3....所以带进去i比较合适 3.如果带进去i,那么浮点数运算i应该也为浮点数，否则运算不出正确结果", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "#include<stdio.h> int main() { \tfloat i; \tfloat x, c, a,b; \tint n; \tscanf_s(\"%f%d\", &x, &n); \ta = 1; \tb = x; \tif (n == 0) \t\tc = 1; \telse if (n == 1) \t\tc = x; \telse \t\tfor (i = 2; i <= n; i++) { \t\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; \t\t\ta = b; \t\t\tb = c; \t\t} \tprintf(\"%.2f\", c); \treturn 0; }", "referer": "user-0"}, {"cid": "11", "user": "user-4", "content": "用嵌套吧 float polya(float n, float x) { \tfloat sum; \tif (n == 0) \t\tsum = 1; \telse if (n == 1) \t\tsum = x; \telse if (n>1) \t\tsum = ((2 * n - 1)*x*polya(n - 1, x) - (n - 1)*polya(n - 2, x)) / n; \treturn sum; } int main() { \tfloat x, n, c, a, b; \tint i; \tscanf_s(\"%f%f\", &x, &n); \tc = polya(n, x); \tprintf(\"%.2f\", c); \treturn 0; }", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了", "referer": "user-0"}, {"cid": "13", "user": "user-1", "content": "for循环错了，虽然你计算c后，给a，b赋值，但下一次循环后，a,b还是1和x", "referer": "user-0"}]}
{"question": "C语言（非C++，基础C）  结构体数组的成员指针的赋值 问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 7 楼 自信男孩的回复:c1为分配空间，是一个野指针，直接scanf可能会出现段错误。 c2是一个char普通变量，用%s会导致越界，因为%s会考虑加上'\\0'，输入了M/F之后再把'\\0'放哪里。 啊啊啊，确实，仔细一想确实都是错误，感谢大神指点（我还是太弱了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "c1为分配空间，是一个野指针，直接scanf可能会出现段错误。 c2是一个char普通变量，用%s会导致越界，因为%s会考虑加上'\\0'，输入了M/F之后再把'\\0'放哪里。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 3 楼 user-3 的回复:[quote=引用 1 楼 一颗白面馒头的回复:]scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）[/quote] 有这个感觉，这里面指针用的好乱", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 user-3的回复:[quote=引用 1 楼 一颗白面馒头的回复:]scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）[/quote] 其实这个题老师是让用C++编的，但是标准C里面没有对字符串直接声明的数据类型，之前对name的定义是数组，但是因为是先确定数组的大小，我就改成了指针类型", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 一颗白面馒头的回复:scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 上完课回去试试", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 1 楼 一颗白面馒头的回复:scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "建议重新看看指针的知识（感觉你这些指针定义 赋值啥的很乱很乱）", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1);", "referer": "user-0"}]}
{"question": "字符串计算单词个数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "源代码如下：  #include <stdio.h> #include <ctype.h> #include <string.h>  int is_upper(char *p) { \twhile(*p) \t{ \t\tif(islower(*p)) return 0; \t\tp++; \t} \treturn 1; }  int main(void) { \tchar str[] = \"FORBES The CEO of Boloco's Social Media Strategy\"; \tchar *p; \tint count = 0; \t \tp = strtok(str, \" \"); \t \twhile(p != NULL) \t{ \t\tif(is_upper(p)) \t\t{ \t\t\tcount++; \t\t\tprintf(\"%d:\\t%s\\n\", count, p); \t\t} \t\tp = strtok(NULL, \" \"); \t} \t \treturn 0;\t }   运行结果如下： 引用1:      FORBES 2:      CEO", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 火柴先生 的回复:引用 1 楼 自信男孩 的回复:先确定单词，然后遍历单词，判断是否有小写字符。我认为最后判断应该是：是否全为大写字符 我的描述不是这样吗？先确定单词，就是在每个单词后面的第一个空格用'\\0'填充，然后再遍历这个单词是不是全大写，这样应该没问题吧。 对于加不加'\\0'都没关系，因为知道单词的开头，知道单词的结尾，做差就知道单词的长度了～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 5 楼 sdhexu 的回复:好人做到底，给你完善一下代码吧：   // 状态机 三种状态 public enum MachineState { \tSTART, \tUPPER_WORDS, \tNOTUPPER_WORDS }  // 判断一个字符是否为空白 private bool IsSpace( char c ) { \treturn ( c == ' ' || c == '\\t' || c == '\\r' || c == '\\n' ); }  // 判断一个字符是否为单词的分隔符，可以视情况将其他标点符号加入 private bool IsSeparator( char c ) { \treturn IsSpace(c) || ( c == ',' || c == '.' ); }  // 判断所有字母为大写的单词个数 public int GetUpperWordsCount( string p ) { \tMachineState state = MachineState.START; \tint count = 0; \tforeach( char c in p ) \t{ \t\tswitch( state ) \t\t{ \t\t\tcase MachineState.START: \t\t\t\tif( c >= 'A' && c <='Z' )  // 如果第一个字符为大写，状态改变 \t\t\t\t\tstate = MachineState.UPPER_WORDS; \t\t\t\telse if( IsSpace( c ))     // 如果是空白，保持开始状态 \t\t\t\t\tbreak; \t\t\t\telse                       // 其他情况，小写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS;  \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.UPPER_WORDS: \t\t\t\tif( IsSeparator( c ))   // 如果遇到单词分隔，计数并改状态 \t\t\t\t{ \t\t\t\t\t++count; \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\telse if( c>='A' && c <= 'Z' ) // 如果还是大写，保持状态 \t\t\t\t\tbreak; \t\t\t\telse   // 其他情况（单词有不是大写的字符），进入非大写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS; \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.NOTUPPER_WORDS: \t\t\t    if( IsSeparator( c ))   // 直到遇到分隔符，否则都是非大写状态 \t\t\t\t{ \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\tbreak;          } \t} } 今天看了下代码，发现您忽视了是要输出全为大写字母的单词的情况，如果考虑输出，还能否在一次遍历的情况下完成，这看起来很难。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 sdhexu的回复:词法分析器，有穷自动状态机，是编译原理中的知识，它的好处是，连续多个空白符，很容易处理，不会影响计算结果。只遍历一遍字符，效率很高。。理解困难的话，画一个状态图，就容易理解了。   效率的确高，这是我C语言考试最后一道编程题里面的一部分内容，明天再好好看看您的代码，十分感谢！之前也上过编译原理的课，可以看出自己的确学艺不精，要好好努力！", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "词法分析器，有穷自动状态机，是编译原理中的知识，它的好处是，连续多个空白符，很容易处理，不会影响计算结果。只遍历一遍字符，效率很高。。理解困难的话，画一个状态图，就容易理解了。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "好人做到底，给你完善一下代码吧：   // 状态机 三种状态 public enum MachineState { \tSTART, \tUPPER_WORDS, \tNOTUPPER_WORDS }  // 判断一个字符是否为空白 private bool IsSpace( char c ) { \treturn ( c == ' ' || c == '\\t' || c == '\\r' || c == '\\n' ); }  // 判断一个字符是否为单词的分隔符，可以视情况将其他标点符号加入 private bool IsSeparator( char c ) { \treturn IsSpace(c) || ( c == ',' || c == '.' ); }  // 判断所有字母为大写的单词个数 public int GetUpperWordsCount( string p ) { \tMachineState state = MachineState.START; \tint count = 0; \tforeach( char c in p ) \t{ \t\tswitch( state ) \t\t{ \t\t\tcase MachineState.START: \t\t\t\tif( c >= 'A' && c <='Z' )  // 如果第一个字符为大写，状态改变 \t\t\t\t\tstate = MachineState.UPPER_WORDS; \t\t\t\telse if( IsSpace( c ))     // 如果是空白，保持开始状态 \t\t\t\t\tbreak; \t\t\t\telse                       // 其他情况，小写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS;  \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.UPPER_WORDS: \t\t\t\tif( IsSeparator( c ))   // 如果遇到单词分隔，计数并改状态 \t\t\t\t{ \t\t\t\t\t++count; \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\telse if( c>='A' && c <= 'Z' ) // 如果还是大写，保持状态 \t\t\t\t\tbreak; \t\t\t\telse   // 其他情况（单词有不是大写的字符），进入非大写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS; \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.NOTUPPER_WORDS: \t\t\t    if( IsSeparator( c ))   // 直到遇到分隔符，否则都是非大写状态 \t\t\t\t{ \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\tbreak;          } \t} }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "很简单的词法分析器，有穷自动状态机。。效率是最高的，没有之一。   public enum MachineState {           START,           UPPER_WORDS, }  public int GetUpperWordsCount( string p ) {          MachineState state = MachineState.START;          int count = 0;          foreach( char c in p )          {                 switch( state )                 {                       case MatchineState.START:                             if( c >= 'A' && c <='Z' )                                   state = MachineState.UPPER_WORDS;                             break;                        case MatchineState.UPPER_WORDS:                              if( c == ' ' || c == '\\t' || c == '\\r' || c == '\\n' || c == ',' || c == '.' )                              {                                    ++count;                                    state = MatchineState.START;                              }                              else if( c>='A' && c <= 'Z' )                                     break;                              else                                    state = MatchineState.START;                             break;                 }          } }", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "我也认为应该先确定单词，在检查单词是否全部为大写。", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:先确定单词，然后遍历单词，判断是否有小写字符。我认为最后判断应该是：是否全为大写字符", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "先确定单词，然后遍历单词，判断是否有小写字符。", "referer": "user-0"}]}
{"question": "在vscode上运行正常但在pta上显示段cuo'wu", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 weaker1209 的回复:可以给我用动态数组检查鞍点的完整代码让我跑一下吗，不是很理解 你自己先研究一下判断鞍点的函数，根据形参，要什么参数传入什么参数就可以了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "可以给我用动态数组检查鞍点的完整代码让我跑一下吗，不是很理解", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "int n, *max, *min, **a;     cin>>n;      if (n < 1 || n > 6) {         cout<<\"Input error!\"<<endl;         return -1;     }     max = new int [n];     min = new int [n];      a = new int *[n];     for (int i = 0; i < n; i++)         a[i] = new int [n];      for (int i = 0; i < n; i++)         for (int j = 0; j < n; j++)             cin>>a[i][j];   用动态数组  检查鞍点的方法：  void check_saddle_point(int (*point)[2], int (*array)[COL], int row, int col) {     int i, j, k, cnt = 0;     int row_idx, col_idx;     int max_row, min_col;      for (i = 0; i < row; i++) {         max_row = array[i][0];         col_idx = 0;         /* find max value in row */         for (j = 1; j < COL; j++)             if (max_row < array[i][j]) {                 max_row = array[i][j];                 col_idx = j;             }          /* Find min value in col */         min_col = array[i][col_idx];         row_idx = i;         for (k = 0; k < row; k++)             if (min_col > array[k][col_idx]) {                 min_col = array[k][col_idx];                 row_idx = k;             }         /* Check the condition*/         if (row_idx == i && min_col == max_row) {             point[cnt][0] = row_idx;             point[cnt][1] = col_idx;             cnt++;         }      } }", "referer": "user-0"}]}
{"question": "C 中 fopen的文件名使用char数组的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0.  因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我自己回复一下我自己吧，我已经debug出问题所在了  主要是我的txt文本是windows写的，传到Linux系统，然后换行符是\\r\\n，造成去掉最后一个\\n后仍有一个\\r去占据字符的长度，所以造成bug。  抱歉，浪费巨佬的时间了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "问题出在你没放代码的地方 readvariable() 里面，因为 ./data/0.txt 后面是 \\r\\n ,在win下正常去掉 \\r\\n 正常，在Linux下只去了 \\n ,导致你的字符串为 ./data/0.txt\\r", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 2 楼 calmuse 的回复:[quote=引用 1 楼 自信男孩 的回复:]strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0.  因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。 非常感谢，是我记错了strcmp的函数功能，的确两个不相等，大佬，我能再多问一下吗？ 我用strlen看了一下，\"./data/0.txt\"的长度是12，而我从文本中读取出来的data_name是13，因为data_name最后我加了一个\\0 我不明白的是，我看书上都说字符串最后会用\\0作为结尾，为什么我在Linux上跑，\"./data/0.txt\"的长度就是12，不是13[/quote] strlen函数是不计算'\\0'的，如果不同系统下不一样的，建议楼主看一下行结束符是不是不一样。把字符串打印出来看看有什么区别～", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0.  因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。 非常感谢，是我记错了strcmp的函数功能，的确两个不相等，大佬，我能再多问一下吗？ 我用strlen看了一下，\"./data/0.txt\"的长度是12，而我从文本中读取出来的data_name是13，因为data_name最后我加了一个\\0 我不明白的是，我看书上都说字符串最后会用\\0作为结尾，为什么我在Linux上跑，\"./data/0.txt\"的长度就是12，不是13", "referer": "user-0"}]}
{"question": "c语言数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "total是整数不能用%.2f输出的，但是total/5.0是按照浮点数除法计算的，因此得到的是浮点数。所以用%.2f输出是没问题的～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "printf()函数当输出的是浮点数时，[.precision]中的precision表示输出的小数的位数。.2f表示输出的浮点数包含2位小数。对于printf()函数的详细使用方法，请参考《C++中printf()函数的用法10-9》 希望能够帮到您！", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "用.2f是因为total/5.0，注意是5.0", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "输出的是total/5.0的值（平均数），5.0是浮点数，结果也会转成浮点数，保留2位小数", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "total是整数，total/5.0，就是双精度浮点数，%.2f意思保留两位小数输出", "referer": "user-0"}]}
{"question": "想求1到10的阶乘之和但运行程序老是得不到我要的结果，麻烦各位帮忙看一下问题出在哪了，现在烦恼着，谢谢大家了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "~~~~~仅供参考", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "# include<stdio.h> int main(void) { \tint  i,j,con=0; \tfor(i=1;i<=10;i++) \t{ \t\tint sum=1; \t\tfor(j=1;j<=i;j++) \t\t{ \t\t\tsum=sum*j; \t\t} \t\tprintf(\"%d\\n\",sum); \t\tcon=con+sum; \t} \tprintf(\"%d\\n\",con); \treturn 0;  }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h>  int main(int argc, char* argv[]) {    int a,b,c,d=0;    for(a=1; a<=10; a++)     {       c=1;       for(b=1; b<=a; b++)            c = c * b;//用c来计算阶乘       d+=c; //用d来计算和     }   printf(\"%d\\n\",d);   system(\"pause\");   return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include<stdio.h> int main() {     int a,b, k;     unsigned long c = 0;      for(a=1;a<=10;a++)     {         k = a;         for(b=1;k>0;k--)         {  b*=k;          }         c=c+b;     }     printf(\"%lu\\n\",c);     return 0; } 供参考～  二层循环里对a进行的修改～", "referer": "user-0"}]}
{"question": "c语言写的程序，能编译运行，但是确无法在屏幕上显示结果", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "哦哦，懂了，谢啦", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 Am0_0mA 的回复:感谢！把x初始化和EOF改成'\\n'后能输出结果了。 不过我不是很懂为啥缺少EOF输入。C程序设计语言这本书里面讲EOF是getchar函数在没有输入时返回的一个特殊值。当读取到文本流最后，已经没有下一个字符时，getchar函数不就应该返回EOF了嘛。为什么还要手动输入EOF作为结束符呢。 对EOF是文件末尾的标识符，所以你需要输入EOF，'\\n'是行结束符，不是文件末尾～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "感谢！把x初始化和EOF改成'\\n'后能输出结果了。 不过我不是很懂为啥缺少EOF输入。C程序设计语言这本书里面讲EOF是getchar函数在没有输入时返回的一个特殊值。当读取到文本流最后，已经没有下一个字符时，getchar函数不就应该返回EOF了嘛。为什么还要手动输入EOF作为结束符呢。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "x没有初始化，另外，EOF输入linux 用ctrl+d，Windows下用ctrl+z试试 楼主是缺少输入EOF，或者楼主缺少'\\n'。  建议楼主把EOF改成'\\n'试试～", "referer": "user-0"}]}
{"question": "linux c下 const 用法问题。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "会修改，不是给予提示。因为const修饰的是xyz数组，不能通过xyz数组去修改，但是其他的变量（指针）是可以修改的，不受限制。const修饰的并不是只读的内存。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "给你段代码，跑一下就知道了  int main() {     const int a[] = {1, 2};     int *p = (int*)a;     //a[0]=2;     *p = 2;     printf(\"%d\\n\", a[0]);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "修改啊，const 只是编译器级的不可修改，实际内存读写权限是系统相关的", "referer": "user-0"}]}
{"question": "反猜数游戏编程怎么做", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:这个比较难，有时间我尝试下 我印象中：猜数字游戏，中的数字，是不重复的。 这是作业马上要交了，我死定了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "这个比较难，有时间我尝试下 我印象中：猜数字游戏，中的数字，是不重复的。", "referer": "user-0"}]}
{"question": "CommandDatatable[0]代表什么？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "一个字节8位，可以表示0到0xff,具体什么意思，要看他的程序要求啊", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据 还有就是编译时一直显示到达不了break，也没有死循环", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据 这个数组为什么是5个字节？0xFF是什么意思？初始化的意思吗？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 7 楼 自信男孩 的回复:[quote=引用 6 楼 47897566 的回复:][quote=引用 5 楼 自信男孩 的回复:]CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？[/quote] 判断数据用的吧，比如协议数据按照什么格式，对端收到之后可以根据初始[0]值是否符合协议要求～[/quote] 明白了，感谢", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "你得看 CommandDatatable 数据哪里读出来的啊，这代码能看出啥？？", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用 6 楼 47897566 的回复:[quote=引用 5 楼 自信男孩 的回复:]CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？[/quote] 判断数据用的吧，比如协议数据按照什么格式，对端收到之后可以根据初始[0]值是否符合协议要求～", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 5 楼 自信男孩 的回复:CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据", "referer": "user-0"}]}
{"question": "求解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第二行，int main（）后面多了“；”号。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "main()后面不要加分号；", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "main(); //这里多了个分号，把它去掉", "referer": "user-0"}]}
{"question": "输出指定月份的天数，敲出代码输出结果有误，但我不知道错哪了，求指导", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 楼主 forlorn pedestrian的回复:题目内容：输入年、月，输出这个月一共有多少天  输入：两个整数    输出： 对应月份天数  样例1：输入 2018 2    输出 28 #include<stdio.h> int main() { \tint a, b, c, d; \tscanf(\"%d%d\", &a, &b); \tif ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0)){ \t\tif (b == 2) \t\t\tc = 29; \t\tif (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) \t\t\tc = 31; \t\tif (b = 4 || b == 6 || b == 9 || b == 11) \t\t\tc = 30; \t} \telse if (b == 2); \t\tc = 30;\t \t\t if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) \t\t\tc = 31; \t\telse if (b = 4 || b == 6 || b == 9 || b == 11)  \t\t\tc = 30; \t\telse\tprintf(\"%d\", c); \t\treturn 0; } a % 100 == 0改成a％100！＝0；  if (b = 4 || b == 6 || b == 9 || b == 11)中b＝＝4；   else if (b == 2); c = 30;\t 这里c＝28；  else\tprintf(\"%d\", c); 这里的else去掉", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "//样例1：输入 2018 2    输出 28 #include<stdio.h> int main() {  #ifdef IF_ELSE     int a, b, c, d;     scanf(\"%d%d\", &a, &b);     //if ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0)){     if (((a % 4 == 0) && (a % 100 != 0)) || (a % 400 == 0)){         if (b == 2)             c = 29;         if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12)             c = 31;         if (b = 4 || b == 6 || b == 9 || b == 11)             c = 30;     }     //else if (b == 2);     else if (b == 2)     c = 30;     if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12)         c = 31;     else if (b = 4 || b == 6 || b == 9 || b == 11)         c = 30;     else         printf(\"%d\", c);  #else     int year, month, days = 0;     int leap = 0;      scanf(\"%d%d\", &year, &month);      if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))         leap = 1;      switch (month) {         case 1:         case 3:         case 5:         case 7:         case 8:         case 10:         case 12:             days = 31;             break;          case 2:             days = 28 + leap;             break;          case 4:         case 6:         case 9:         case 11:             days = 30;             break;          default:             printf(\"Not support!\\n\");             break;     }      printf(\"%d\", days); #endif     return 0; } 供参考`  有两个问题：闰年判断和if后面多一个分号；  另外，这个问题用switch case比较好一些，供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用if ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0))闰年判断这句有误，a%100 !=0。这句引用if (b = 4 || b == 6 || b == 9 || b == 11)有误，b==4。整体逻辑判断错了，修改如下：#include <stdio.h>  int main(int argc, char* argv[]) {     int a=0, b=0, c=0;     printf(\"请输入年月：\");     scanf(\"%d %d\", &a, &b);     if (b == 2)       { if ((a % 4 == 0 && a % 100 != 0) || (a % 400 == 0))             {c = 29;}         else             {c = 28;}       }      else        if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12)            { c = 31;}        else          if (b == 4 || b == 6 || b == 9 || b == 11)            { c = 30;}       printf(\"%d年%d月有%d天\\n\",a,b,c);      system(\"pause\");      return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "else if(b==2); //这里多了个分号 而且紧接着的c=30应该改成c=28  另外，else printf(“%d”, c) 前面的else去掉", "referer": "user-0"}]}
{"question": "C语言中变量何时分配空间？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 24 楼 funnywhere 的回复:[quote=引用 23 楼 lin5161678的回复:][quote=引用 22 楼 funnywhere的回复:][quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案[/quote] 那就不叫答案吧，因为我看到一篇介绍gcc如何进行内存分配的文章，可以说找到正确的解释了。[/quote] 局部变量分配汇编指令 Intel 是 sub esp，xxx，ARM处理器是 sub     sp, sp, #xxx ，不管什么编译器，就这种方法，还正确答案，别逗", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 28 楼 火花20180731 的回复:可执行文件相当于一个内存模板，系统会按照这个内存模板起一个进程，按模板中的内容为进程分配内存(给一个空闲的虚拟的地址区间，可与物理内存建立映射)，并填充初始数据。第一次进程运行结束后，占用的内存被释放，用过的地址区间再次空闲。第二次进程运行再次从这个空闲地址开始分配，所以两次地址打印相同。现代操作系统都是虚拟内存，进程间内存是互不相干的，跟第几次运行都没关系，即时同时运行也一样", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 29 楼 funnywhere 的回复:[quote=引用 26 楼 赵4老师的回复:]理解和讨论之前请先学会如何观察！  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 确实很有道理。[/quote] 老赵的话，十年前就是复制粘贴的，水了一辈子了。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "如果你的代码中没有使用某个变量，通常会被编译器优化掉（取决于编译器优化级别），如果你只读使用，编译器会将其优化为常量嵌入到代码中（立即数），只有你对它进行了写操作或者取地址，编译器才会为它实际分配空间", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 23 楼 lin5161678的回复:[quote=引用 22 楼 funnywhere的回复:][quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案[/quote] 那就不叫答案吧，因为我看到一篇介绍gcc如何进行内存分配的文章，可以说找到正确的解释了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 26 楼 赵4老师的回复:理解和讨论之前请先学会如何观察！  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 确实很有道理。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "可执行文件相当于一个内存模板，系统会按照这个内存模板起一个进程，按模板中的内容为进程分配内存(给一个空闲的虚拟的地址区间，可与物理内存建立映射)，并填充初始数据。第一次进程运行结束后，占用的内存被释放，用过的地址区间再次空闲。第二次进程运行再次从这个空闲地址开始分配，所以两次地址打印相同。", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "以前的老赵又回来了～～～", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "理解和讨论之前请先学会如何观察！  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "引用 22 楼 funnywhere的回复:[quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案", "referer": "user-0"}, {"cid": "11", "user": "user-6", "content": "只單獨輸出a或b，是不是意味著這時候另一個變量在整個程序生命期中沒有用到？比如：  #include <stdio.h> #include <stdlib.h> int main() {     int b ;     int a ;     printf(\"%x\\n\",&a);  //只输出a的地址，本人机器上为61FE1C     system(\"pause\");     return 0; }  這段程序中，b只在定義時出現一次。  這就是你要明白的其中一點：編譯器有優化功能，它掃描了整個程序發現b其實可以不要，於是就很可能被省略掉了。 那麽這個時候，不管你輸出的是a還是b，它的地址分配都是一樣的，即屬於該程序的變量空間只有一個整數。", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 21 楼 lin5161678的回复:[quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了", "referer": "user-0"}, {"cid": "13", "user": "user-5", "content": "引用 20 楼 funnywhere 的回复:并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "引用 19 楼 老马何以识途的回复:只單獨輸出a或b，是不是意味著這時候另一個變量在整個程序生命期中沒有用到？比如：  #include <stdio.h> #include <stdlib.h> int main() {     int b ;     int a ;     printf(\"%x\\n\",&a);  //只输出a的地址，本人机器上为61FE1C     system(\"pause\");     return 0; }  這段程序中，b只在定義時出現一次。  這就是你要明白的其中一點：編譯器有優化功能，它掃描了整個程序發現b其實可以不要，於是就很可能被省略掉了。 那麽這個時候，不管你輸出的是a還是b，它的地址分配都是一樣的，即屬於該程序的變量空間只有一個整數。 并没有优化掉，都在的。", "referer": "user-0"}, {"cid": "15", "user": "user-0", "content": "引用 13 楼 眼里有光～的回复:函数内部的变量是局部变量，比如你int a,b，这种非静态局部变量是放在栈上的，栈区是操作系统来管理的，程序在运行的时候操作系统自动为局部变量分配空间，局部变量出了作用域以后，操作系统自动回收这部分空间，也就是说不需要由程序员自己去申请和释放这块内存。  你上面出现的情况，每次运行单输出a和b的地址有时是一样的，这是正常情况，程序本次运行操作系统可能将这个地址分配给a，下次运行操作系统将这个地址分配给b，操作系统怎么分配栈区地址其实根本不用程序员操心。   感觉跟操作系统关系不大。感觉是gcc编译器的某种策略，换成msvc就没有这个现象。", "referer": "user-0"}, {"cid": "16", "user": "user-7", "content": "函数内部的变量是局部变量，比如你int a,b，这种非静态局部变量是放在栈上的，栈区是操作系统来管理的，程序在运行的时候操作系统自动为局部变量分配空间，局部变量出了作用域以后，操作系统自动回收这部分空间，也就是说不需要由程序员自己去申请和释放这块内存。  你上面出现的情况，每次运行单输出a和b的地址有时是一样的，这是正常情况，程序本次运行操作系统可能将这个地址分配给a，下次运行操作系统将这个地址分配给b，操作系统怎么分配栈区地址其实根本不用程序员操心。", "referer": "user-0"}, {"cid": "17", "user": "user-8", "content": "短时间内一样的地址巧合而已。", "referer": "user-0"}, {"cid": "18", "user": "user-0", "content": "引用 7 楼 qybao 的回复:[quote=引用 6 楼 funnywhere 的回复:] 你再给a也赋个值10000，你会发现如果只单独输出a或b的地址，也是一样的。 你把你的代码和运行结果贴出来看看 #include <stdio.h> #include <stdlib.h> int main() {     int b = 10000;     int a = 10000;     printf(\"%X\\n\",&b);   //你确定轮流注释这两句打印语句运行出来的结果一样？a，b同时被使用，编译优化不会舍弃任何一个，内存地址肯定不同     //printf(\"%X\\n\",&a);  //估计你代码哪里有问题，要不就是进程加载时不是重复使用原来的内存（这很正常）     system(\"pause\");     return 0; }[/quote]", "referer": "user-0"}, {"cid": "19", "user": "user-0", "content": "轮流注释地址就是一样的啊。试了好多种方案都不知道怎么解释。要不我就不会发帖问了。", "referer": "user-0"}, {"cid": "20", "user": "user-9", "content": "程序加载到内存时才会分配内存，但是编译器会指定偏移量。比如数组会指定长度～", "referer": "user-0"}]}
{"question": "求大神解答", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "a未定义，maxxx函数接收的数组是不是不是a而是其他呢？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "哦哦  明白了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "i<a j<b c[i][j] 这里的a，b，c在哪里定义的？", "referer": "user-0"}]}
{"question": "为什么是按学号输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我已经找到问题了，谢谢你们啦", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "就这些代码的话，第一个for连着第二个for循环那里就是给学号从大到小排序了，这可能就是他按学号输出的原因", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "但从这些代码里看不出为什么来。提供更多的代码吧，另外，直接贴代码，不建议贴图片～", "referer": "user-0"}]}
{"question": "萌新求助！关于浮点数的输出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "%.20lf指定了输出小数多少位？  https://blog.csdn.net/thanklife/article/details/53033071?utm_medium=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-1.nonecase&depth_1-utm_source=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-1.nonecase", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "是呀 浮点数输出根据精度不同 是会这样的  一般浮点数都是小数点后6位确保的 再后面的值就不一定是正确的了", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "printf(\"%6.2f\".floatNum)：保留两位小数 说明：%6.2f 表明待打印的数（floatNum）至少占6个字符宽度（包括两位小数和一个小数点），且小数点后面有2位小数，小数点占一位，所以整数部分至少占3位。注意：这里的6是待打印的数至少占据的字符宽度，包括两位小数（如果小数不够两位用0补位，例如100.1打印出来为100.10）和一个小数点，所以整数部分至少占3个字符宽度。  1.单精度实数的有效位数一般为7位，输出6位小数，超出有效位数输出就是错误的。 2.双精度数有效位数一般为16位，输出6位小数，超出有效位数可能截断或错误值。 3.关于保留小数点后有效位数四舍五入，原则保留0位小数的时候，只要小数点后第一位>=5，就可以进位，但是保留1位或者2位等等，保留小数的后一位要>5才可以进位，否则就舍去。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-4 的回复:printf(\"%6.2f\".floatNum)：保留两位小数 说明：%6.2f 表明待打印的数（floatNum）至少占6个字符宽度（包括两位小数和一个小数点），且小数点后面有2位小数，小数点占一位，所以整数部分至少占3位。注意：这里的6是待打印的数至少占据的字符宽度，包括两位小数（如果小数不够两位用0补位，例如100.1打印出来为100.10）和一个小数点，所以整数部分至少占3个字符宽度。  1.单精度实数的有效位数一般为7位，输出6位小数，超出有效位数输出就是错误的。 2.双精度数有效位数一般为16位，输出6位小数，超出有效位数可能截断或错误值。 3.关于保留小数点后有效位数四舍五入，原则保留0位小数的时候，只要小数点后第一位>=5，就可以进位，但是保留1位或者2位等等，保留小数的后一位要>5才可以进位，否则就舍去。感谢😁", "referer": "user-0"}]}
{"question": "在linux 中用open操作文件，用O_EXCL创建一个不存在的文件直接报错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "O_EXCL 表示如果要创建的文件已存在，则出错，同时返回 -1，并且修改 errno 的值。", "referer": "user-0"}]}
{"question": "按要求输出 数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "题目要求输入都结束后结果一起输出，你这是输入一个就输出一个，和要求不符合。应该把结果都保存到数组里，最后一起输出", "referer": "user-0"}]}
{"question": "小白求问 关于用union共用体构造混合数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "100个元素你都当做int就可以了（以占用空间最大的数据类型为主），int本来就可以存char，所以20个元素存int，20个存char完全没问题。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 qybao 的回复:union就是成员共享一块内存空间 比如 union {     int a;     char b; } 有a，b两个成员，但是因为空间是共享的，int的空间最大（4个字节），所以以它为准，a成员使用4个字节，b成员使用一个字节，b存在于a里面。如下图， 整个union的空间为@@@@ a @@@@ b @ 也就是a的第一个字节和b的内存空间重合 如果赋值b=1，内存变为 a 1@@@ b 1 如果赋值a=1，内存变为 a 0001 b 0 可见改变a可能会影响b（因为内存共有），同理改变b也可能会影响a 对比一下struct struct {     int a;     char b; } a和b是不共享空间的，所以整个结构体的空间是int的4个字节+char的1个字节=5个字节（先不考虑内存对齐，如果考虑对齐就是8个字节），内存分布如下图 整个struct的空间为@@@@@ a @@@@ b ？？？？@ ？表示不使用这些空间，也就是a和b没有重合的内存空间，a使用前4个字节，b使用后1个字节 如果赋值b=1，内存变为 a @@@@ b ？？？？1 如果赋值a=1，内存变为 a 0001 b ????1 可见改变a不影响b（因为a和b的内存独立），同理改变b也不影响a  所以union就是为了让成员共享一块内存空间，改变一个成员，其他成员也可能发生变化  所以 问题1，100个元素是union类型，每个元素可以存int或char，用户自己选择 比如 array[0].a=1;//存int array[1].b=‘a’;//存char  问题2 两个成员指a和b，a和b共享同一块内存  问题3 数据存储最小单元是字节（char），任何多字节的类型（其实就相当于char数组)都可以存字符串，只不过内存存储的值不同而已。 比如 int a; strcpy((char*)&a, “ab”); //int存字符串 printf(“%s”, &a); //打印字符串 所以你的array存字符串也没问题，只要控制好不内存越界就可以  问题4 你是怎么赋值的，上面说了，成员是共享内存空间的，给一个成员赋值可能会影响另外的成员，估计是你赋值不对。 那请问一下这100个数组元素的内存是针对元素分配的吗？就比如我可以放20个int类20个char类 这样可以吗？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "不可以自选，对于联合体，联合体的长度是有元素中占用空间最大的决定，比如第一个联合体有一个int，一个char，这两个元素共用一个内存，那就是int类型的长度，因为sizeof(int) > sizeof(char)", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "union就是成员共享一块内存空间 比如 union {     int a;     char b; } 有a，b两个成员，但是因为空间是共享的，int的空间最大（4个字节），所以以它为准，a成员使用4个字节，b成员使用一个字节，b存在于a里面。如下图， 整个union的空间为@@@@ a @@@@ b @ 也就是a的第一个字节和b的内存空间重合 如果赋值b=1，内存变为 a 1@@@ b 1 如果赋值a=1，内存变为 a 0001 b 0 可见改变a可能会影响b（因为内存共有），同理改变b也可能会影响a 对比一下struct struct {     int a;     char b; } a和b是不共享空间的，所以整个结构体的空间是int的4个字节+char的1个字节=5个字节（先不考虑内存对齐，如果考虑对齐就是8个字节），内存分布如下图 整个struct的空间为@@@@@ a @@@@ b ？？？？@ ？表示不使用这些空间，也就是a和b没有重合的内存空间，a使用前4个字节，b使用后1个字节 如果赋值b=1，内存变为 a @@@@ b ？？？？1 如果赋值a=1，内存变为 a 0001 b ????1 可见改变a不影响b（因为a和b的内存独立），同理改变b也不影响a  所以union就是为了让成员共享一块内存空间，改变一个成员，其他成员也可能发生变化  所以 问题1，100个元素是union类型，每个元素可以存int或char，用户自己选择 比如 array[0].a=1;//存int array[1].b=‘a’;//存char  问题2 两个成员指a和b，a和b共享同一块内存  问题3 数据存储最小单元是字节（char），任何多字节的类型（其实就相当于char数组)都可以存字符串，只不过内存存储的值不同而已。 比如 int a; strcpy((char*)&a, “ab”); //int存字符串 printf(“%s”, &a); //打印字符串 所以你的array存字符串也没问题，只要控制好不内存越界就可以  问题4 你是怎么赋值的，上面说了，成员是共享内存空间的，给一个成员赋值可能会影响另外的成员，估计是你赋值不对。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "你怎么写的？？？", "referer": "user-0"}]}
{"question": "有大佬知道这个报错怎么改吗，感谢", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "问题不少 1 变量和结构体同名  student student[number]  2 c不支持用常量定义数组的长度 student student[number]  可以把number变成宏或用动态数组  3 student_average函数没有返回值  4 student_printf函数多了个f，和函数定义不一样", "referer": "user-0"}]}
{"question": "回文陷阱", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<math.h>  long long int back(long long int n);  int main(void) {     int i;     long long int n,b;     scanf(\"%lld\",&n);     if(n==back(n))         printf(\"HW\\n\");     else     {         for(i=1;i<=10;i++)         {              b=back(n);             n=n+b;             if(n==back(n))             {                 printf(\"%d %lld\\n\", i, n);                 break;             }         }         if(i>10)             printf(\"NONE\\n\");     }      return 0; } long long int back(long long int n) {     //long long int len,i,d,s=0;     long long int s=0;     int len, i, d;     len=log10(n)+1;     printf(\"len = %d\\n\", len);     for(i=1;i<=len;i++)     {         d=n%10;         s=s*10+d;         n=n/10;     }     return s; } 供参考～  back参数和返回值有点问题，其他暂未发现问题～", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 3 楼 user-2 的回复:for(i=1;i<=10;i++) {  b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t } if(i>10) printf(\"NONE\\n\"); 在你这个循环里i永远小于10，也就下面的if永远不会成立，建议改成如下代码（仅供参考） for(i=1;;i++) {  b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t if(i>10) { printf(\"NONE\\n\"); break; } }   楼主这部分没问题，注意i <= 10当i> 10时就是退出循环了。  引用 4 楼 user-2 的回复:补充一下，形参和实参还是不要同名要好一些（虽然这个函数里没什么问题）  被你的一句话给误解了。楼主的没问题。因为for循环是提前退出还是执行完退出的问题。  你如果认为楼主的有问题，建议自己再梳理一下逻辑～", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "if(i>10)             printf(\"NONE\\n\"); 这儿改成i >= 10", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢各位仁兄回复。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "补充一下，形参和实参还是不要同名要好一些（虽然这个函数里没什么问题）", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "for(i=1;i<=10;i++) {  b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t } if(i>10) printf(\"NONE\\n\"); 在你这个循环里i永远小于10，也就下面的if永远不会成立，建议改成如下代码（仅供参考） for(i=1;;i++) {  b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t if(i>10) { printf(\"NONE\\n\"); break; } }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "望各位仁兄，帮帮忙。提交时总是验证为答案错误，不知何因。", "referer": "user-0"}]}
{"question": "c语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "因为你的while判断条件是x，而你在循环里并没有修改x的值，x>0一直满足，跳不出循环。应该在循环里加个修改x的语句，比如--i;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 呆萌霍比特人的傻大脚板的回复:因为第一个scanf在循环体外,只执行一次.如果不写这行,那么while就没有存在的必要,反正你就算一次, 好的谢谢。。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:因为while循环没有终止的条件啊，它会一直一直循环下去 好的谢谢。。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "因为第一个scanf在循环体外,只执行一次.如果不写这行,那么while就没有存在的必要,反正你就算一次,", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "因为while循环没有终止的条件啊，它会一直一直循环下去", "referer": "user-0"}]}
{"question": "easyx is only for C++", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 楼主 诗岑 的回复:编译器VS2019 一直给我报这个错 是版本不兼容吗？ 可能你建立的是C语言工程，EasyX只支持C++ 你将源文件的后缀改为.cpp试试", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "还是不行", "referer": "user-1"}, {"cid": "3", "user": "user-2", "content": "我也是一样的问题，下面还是说easyX is only for C++", "referer": "user-2"}]}
{"question": "code blocks上算例题都是对的，但提交OJ时说我的例题都错了，试了好久，大佬帮帮吧", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "做出来了，", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-1的回复:显然没考虑到int越界或越界处理不对 比如 a+b>0，可能a，b都是负数，相加结果超出-2^31变成正数。lz用a=2^31，b=-3 试试就知道了 我做出来了，谢谢。我不仅int越界了，fabs（）函数也用错了，改成了abs（）就对了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "显然没考虑到int越界或越界处理不对 比如 a+b>0，可能a，b都是负数，相加结果超出-2^31变成正数。lz用a=2^31，b=-3 试试就知道了", "referer": "user-0"}]}
{"question": "指针与函数搞得我头昏脑胀     求解错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "结构体的date长度没指定 把 int date[] 改成 int date[N]", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "报错的展示出来", "referer": "user-0"}]}
{"question": "关于NAND FLASH控制器的寄存器。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "如果我的SoC里没有这些寄存器，是不是也可以自己定义，然后使用啊？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "除非你SoC不支持NandFlash，否则肯定有这些寄存器，上面你列的这些寄存器都是NFlash标准的，接口又不是GPIO可以模拟的，必须要通过控制器完成。 看下SoC spec文档，如果支持，那么肯定有，可能名称不一定完全一样。", "referer": "user-0"}]}
{"question": "大佬帮帮，oj上提示输出超限，codeblock上是正常的", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "把n改成unsigned long或unsigned long long试试", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:int类型（整数类型）的范围为-2^31 ~ 2^31-1，即-2147483648~2147483647 题目要求输入数字是<2^32 对于2^31~2^32-1的数字 你的程序是不是无法判断啦 谢谢，我做出来了。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "int类型（整数类型）的范围为-2^31 ~ 2^31-1，即-2147483648~2147483647 题目要求输入数字是<2^32 对于2^31~2^32-1的数字 你的程序是不是无法判断啦", "referer": "user-0"}]}
{"question": "向函数传递数据结构 小白求问！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位 弄懂啦！感谢对小白的帮助~", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "函数传数组时用数组的名字就可以了，用name[30]这样是传数组元素（下标为30的元素），所以意思不一样", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "..... strcpy(char *dst , char *src)，你要传入地址进去  例如strcpy(stu[i].name , stu[j].name)", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "把for语句里name后面的[30]去了再试试", "referer": "user-0"}]}
{"question": "C语言：编写一个函数，输出整数m的全部素数因子。（m=120,素数因子为：2，2，2，3，5）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 火柴先生 的回复:[quote=引用 2 楼 yqy1234hf 的回复:]这个是不可能绕过素数判断的   自己写循环  被除数/最小素数A/最小素数B/...最小素数N    看看能否除尽    如果不能就把素数表长度减少一位  然后增大最后一个素数 判断是否能除尽    去穷尽所有的素数对就可以了您可以看一下三楼的回复[/quote] 嗯嗯  我题目理解错了   你这个应该就是求素数因子   简单的说就是能整除某个数的队列中的质数?  我理解的对吗？", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 user-2 的回复: void AllFactor(int nInput) { \tprintf(\"%d的全素数因子：\", nInput);  \tfor (int i = 2; i <= nInput; ++i) \t{ \t\tif (nInput % i == 0) \t\t{ \t\t\tprintf(\"\\t%d\", i); \t\t\tnInput /= i--; \t\t} \t} } 谢谢这应该就是我想看到的代码，我所担心的会不会在这个过程中输出非素数因子，在循环过程中其实不可能出现的，因为如果出现非素数，那么他一定可以在次数更低的循环中找到它对应的素数因子并输出，是不是这样?", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 yqy1234hf 的回复:这个是不可能绕过素数判断的   自己写循环  被除数/最小素数A/最小素数B/...最小素数N    看看能否除尽    如果不能就把素数表长度减少一位  然后增大最后一个素数 判断是否能除尽    去穷尽所有的素数对就可以了您可以看一下三楼的回复", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "void AllFactor(int nInput) { \tprintf(\"%d的全素数因子：\", nInput);  \tfor (int i = 2; i <= nInput; ++i) \t{ \t\tif (nInput % i == 0) \t\t{ \t\t\tprintf(\"\\t%d\", i); \t\t\tnInput /= i--; \t\t} \t} }", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "这个是不可能绕过素数判断的   自己写循环  被除数/最小素数A/最小素数B/...最小素数N    看看能否除尽    如果不能就把素数表长度减少一位  然后增大最后一个素数 判断是否能除尽    去穷尽所有的素数对就可以了", "referer": "user-0"}]}
{"question": "不能读入,请大佬分析一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "晕啦,malloc没打上去,怎么看都没看你出问题", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "p = (struct node*)(sizeof(struct node));  p->a = b;//此处为啥不能读入  这个是什么语法？ 是要malloc吗", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "if (t->next == NULL || t->next->a > b) \t\t{ \t\t\t// p = (struct node*)(sizeof(struct node)); \t\t\tp = (struct node*)malloc(sizeof(struct node));  \t\t\tp->a = b;//此处为啥不能读入 \t\t\tp->next = t->next; \t\t\tt->next = p; \t\t\tbreak;  \t\t}", "referer": "user-0"}]}
{"question": "各位大佬，帮忙看看！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void ChongDongDeHua1(void) { \tint nInit = 1; \tint nNum[3] = { 0, 0, 0 };  \tprintf(\"输入小时数：\");  \tint nHour = 0; \tscanf_s(\"%d\", &nHour);  \tfor (int i = 0; i < nHour; ++i) \t{ \t\tif (i == 0) \t\t{ \t\t\tnNum[i] = nInit; \t\t} \t\telse \t\t{ \t\t\tnNum[2] += nNum[1]; \t\t\tnNum[1] = nNum[0]; \t\t\tnNum[0] = nNum[2]; \t\t} \t}  \tint nTotal = nNum[0] + nNum[1] + nNum[2];  \tprintf(\"输出病毒数：%d\\r\\n\", nTotal); }  void ChongDongDeHua2(void) { \tint nSampleMax = 20; \tprintf(\"最多%d个小朋友\\r\\n\", nSampleMax);  \tint* pSample = new int[nSampleMax];  \tint nInput = 0; \tint nTotal = 0; \tint nSampleCount = 0; \t \twhile (true) \t{ \t\tscanf_s(\"%d\", &nInput);  \t\tif (nInput == -1) \t\t\tbreak;  \t\tif (nSampleCount >= nSampleMax) \t\t{ \t\t\tdelete[] pSample; \t\t\tprintf(\"输入错误，最多%d个小朋友\\r\\n\", nSampleMax); \t\t\treturn; \t\t}  \t\tpSample[nSampleCount++] = nInput; \t\tnTotal += nInput; \t}   \tif (nTotal % 2 == 0) \t{ \t\tint nLoopCount = nSampleCount / 2; \t\tint* pID = new int[nLoopCount];  \t\tfor (int i = 0; i < nLoopCount; ++i) \t\t{ \t\t\tint nSelect = i + 1; \t\t\tint nAddID = 0;  \t\t\tpID[nAddID] = 0;  \t\t\twhile (pID[0] + nSelect <= nSampleCount) \t\t\t{ \t\t\t\tint nPreAddID = nAddID; \t\t\t\twhile (nAddID + 1 < nSelect && pID[nAddID] + 1 < nSampleCount) \t\t\t\t{ \t\t\t\t\tpID[nAddID + 1] = pID[nAddID] + 1; \t\t\t\t\t++nAddID; \t\t\t\t}  \t\t\t\tif (nAddID + 1 < nSelect) \t\t\t\t{ \t\t\t\t\tnAddID = nPreAddID; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tint nSubTotal = 0; \t\t\t\t\tfor (int j = 0; j < nSelect; ++j) \t\t\t\t\t{ \t\t\t\t\t\tnSubTotal += pSample[pID[j]]; \t\t\t\t\t}  \t\t\t\t\tfor (int j = pID[nAddID]; j < nSampleCount; ++j) \t\t\t\t\t{ \t\t\t\t\t\tnSubTotal -= pSample[pID[nAddID]]; \t\t\t\t\t\tpID[nAddID] = j; \t\t\t\t\t\tnSubTotal += pSample[pID[nAddID]]; \t\t\t\t\t\t \t\t\t\t\t\tif (nSubTotal == nTotal / 2) \t\t\t\t\t\t{ \t\t\t\t\t\t\tprintf(\"能否均分：Yes\\r\\n\");  \t\t\t\t\t\t\tprintf(\"组合结果：\"); \t\t\t\t\t\t\tfor (int k = 0; k < nSelect; ++k) \t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\tprintf(\"%d \", pSample[pID[k]]); \t\t\t\t\t\t\t}  \t\t\t\t\t\t\tprintf(\"\\r\\n\");  \t\t\t\t\t\t\tdelete[] pSample; \t\t\t\t\t\t\tdelete[] pID; \t\t\t\t\t\t\t \t\t\t\t\t\t\treturn; \t\t\t\t\t\t} \t\t\t\t\t} \t\t\t\t}  \t\t\t\tif (nAddID == 0) \t\t\t\t\t++pID[nAddID]; \t\t\t\telse \t\t\t\t\t++pID[--nAddID]; \t\t\t} \t\t} \t}  \tdelete[] pSample;  \tprintf(\"能否均分：No\\r\\n\"); }", "referer": "user-0"}]}
{"question": "dev c++ 数据结构编译运行caption问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:bool ListDelete(SqList *&L,int i,ElemType &e) {     int j;     if(i<1 ||i>L->length)         return false;     i--;     e=L->data[i];     //for(j=i;L->length-1;j++) {     for(j=i; j < L->length-1;j++) {         L->data[j] = L->data[j+1];     }     L->length--;     return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧大佬知道怎么解决么", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:bool ListDelete(SqList *&L,int i,ElemType &e) {     int j;     if(i<1 ||i>L->length)         return false;     i--;     e=L->data[i];     //for(j=i;L->length-1;j++) {     for(j=i; j < L->length-1;j++) {         L->data[j] = L->data[j+1];     }     L->length--;     return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧修改后还是报错", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "bool ListDelete(SqList *&L,int i,ElemType &e) {     int j;     if(i<1 ||i>L->length)         return false;     i--;     e=L->data[i];     //for(j=i;L->length-1;j++) {     for(j=i; j < L->length-1;j++) {         L->data[j] = L->data[j+1];     }     L->length--;     return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "#include\"sqlist.cpp\"  int main()  {  \tSqList *L;  \tElemType e;  \tprintf(\"顺序表的基本运算如下：\\n\");  \tprintf(\"(1)初始化顺序表L\\n\");  \tInitList(L);  \tprintf(\"(2)依次插入a,b,c,d,e元素\\n\");  \tListInsert(L,1,'a');  \tListInsert(L,2,'b');  \tListInsert(L,3,'c');  \tListInsert(L,4,'d');  \tListInsert(L,5,'e');  \tprintf(\"(3)输出顺序表L：\");DispList(L);  \tprintf(\"(4)顺序表L长度：%d\\n\",ListLength(L));  \tprintf(\"(5)顺序表L为%s\\n\",(ListEmpty(L)?\"空\":\"非空\"));  \tGetElem(L,3,e);  \tprintf(\"(6)顺序表L的第3个元素：%c\\n\",e);  \tprintf(\"(7)元素a的位置：%d\\n\",LocateElem(L,'a'));  \tprintf(\"(8)在第4个元素位置上插入f元素\\n\");  \tListInsert(L,4,'f');  \tprintf(\"(9)输出顺序表L:\");DispList(L);  \tprintf(\"(10)删除L的第3个元素\\n\");  \tListDelete(L,3,e);  \tprintf(\"(11)输出顺序表L:\");DispList(L);  \tprintf(\"(12)释放顺序表L\\n\");  \tDestroyList(L);  \treturn 1;  }", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "你的函数调用在哪里，main函数在哪里？", "referer": "user-0"}]}
{"question": "C语言题目", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "应该是吧，能帮忙写一下吗？", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "绕，没看懂什么意思。 是不是表达要用字符数组排序，用数组下标查找", "referer": "user-0"}]}
{"question": "请问用clang-format格式化代码时，如何设置取消数组自动合成一行的格式", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这个配置参数起作用BinPackArguments: true", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "找到答案了，用// clang-format off关闭就好了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "搜astyle", "referer": "user-0"}]}
{"question": "最近碰到一个特别搞人心态的事情，是关于C语言连续输入两个字符串的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <string.h> const int TXTLEN=8; int main(){     char text[TXTLEN+1], key[TXTLEN+1];     rewind(stdin);     printf(\"Please input key(%d bytes):\",TXTLEN);     fgets(key,TXTLEN+1,stdin);     if ('\\n'==key[strlen(key)-1]) key[strlen(key)-1]=0;     printf(\"%s\\n\",key);     rewind(stdin);     printf(\"Please input text(%d bytes):\",TXTLEN);     fgets(text,TXTLEN+1,stdin);     if ('\\n'==text[strlen(text)-1]) text[strlen(text)-1]=0;     printf(\"%s\\n\",text);     printf(\"(%s)%d,(%s)%d\\n\", key, strlen(key),text, strlen(text));     return 0; } //Please input key(8 bytes):123456789 //12345678 //Please input text(8 bytes):123456789 //12345678 //(12345678)8,(12345678)8 //", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 1 楼 自信男孩 的回复:亲测没问题呢，结构都是8；  楼主的代码没有定义TXTLEN的长度，可能在别处定义了，没有发出来。如果这个TXTLEN定义8，那么是可能是16的。 自测时用的TXTLEN是32", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "亲测没问题呢，结构都是8；  楼主的代码没有定义TXTLEN的长度，可能在别处定义了，没有发出来。如果这个TXTLEN定义8，那么是可能是16的。", "referer": "user-0"}]}
{"question": "麻烦各位帮我们看看这个怎么做？萌新实在不会……", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你需要理解，在计算机的大脑里没有1234xx等数字，都是0,1的值。因此只需要通过移位和&操作，就可以把一个十进制（其他进制）对应的二进制的每一位给算出来～", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "用&来做吧，&的效率应该是更快一些～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "是单纯的模2求余数？还是十进制转二进制吗？ 如果是前者，用与运算即可，即和1做&运算 比如 int main() {     int a=5;     printf(“%d模2的余数为%d\\n”, a, a&1); //a和1做&运算即为a模2的余数     return 0; }  如果是前者，十进制转2进制，那就多一步移位运算 比如 void tobinary(int n) {     int a = n&1; //模2求余     if (n>1) {         tobinary(n>>1); //右移1位相当于除以2     }     printf(“%d”, a); //打印二进制 } int main() {     tobinary(5); //打印5的2进制     return 0; }  以上代码都不出现除法和取模，但是都达到同样的效果", "referer": "user-0"}]}
{"question": "关于数组与结构体赋值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "赋值有两种形式，一种是把源变量的内容复制到目的变量，一种是让目的变量的地址等于源变量的地址。理解这两种的区别，你就明白了你的问题", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "数组变量，数组名其实表示的是常量地址，所以b=a；相当于把a的地址赋值给b，但是实际上b的地址也是常量，所以不能赋值 结构体 变量名难道不是表示常量地址吗？不理解", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 宇来风满楼 的回复:能啊,用已定义数组赋值给新数组 #include <stdio.h>  int main() {     char a[]=\"abcdefg\";     char b[10];     b=a;     printf(\"%s\\n\",b);     return 0; } 上面的编译就无法通过； 而下面的才能通过： #include <stdio.h> #include<string.h>  int main() {     char a[]=\"abcdefg\";     char b[10];     for (int i=0;i<strlen(a);i++)         b[i]=a[i];     printf(\"%s\\n\",b);     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "能啊,用已定义数组赋值给新数组", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "能啊,用已定义数组赋值给新数字", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "struct book{ char name[10]; char auther[10]; float value; }; struct book math; math=(stuck book){\"studymath\",\"john\",45.3};", "referer": "user-0"}]}
{"question": "请教 控制台传参数只能输出首个字符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "是字符集的问题，忽略了这个，改成多字符集或者 输出%ws 就可以了。感谢1楼", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主执行的操作是什么，比如./a.out a 5？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你这个TCHAR是不是wchar呀，把%s改成%ws试试", "referer": "user-0"}]}
{"question": "强制类型转换时遇到的数据错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "float值有效位数6位，前6位保证有效，之后不保证。 计算机使用32位，存储float类型有关，IEEE754标准 可以使用64位的double声明，double可以保证15位有效", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "float值有效位数6位，前6位保证有效，只有不保证。 计算机使用32位，存储float类型有关， 可以使用64位的double声明，double可以保证15位有效", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "float有效数字只有6位 请换double", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void AssisTest(void) { \tint nMaxInput = 20;  \tchar* pL2W = new char[nMaxInput + 2]; \tchar* pW2L = new char[nMaxInput + 2]; \tchar* pNum = new char[nMaxInput + 2];  \t*pL2W = 0; \t*pW2L = 0; \t*pNum = 0;  \tint nInput = 0; \tfor (int i = 0; (nInput = getchar()) != 10; ++i) \t{ \t\tif (i >= nMaxInput) \t\t{ \t\t\tprintf(\"总数不超过20个！\\r\\n\"); \t\t\treturn; \t\t}  \t\tif ('a' <= nInput && nInput <= 'z') \t\t{ \t\t\tpL2W[++*pL2W] = nInput - 'a' + 'A'; \t\t} \t\telse if ('A' <= nInput && nInput <= 'Z') \t\t{ \t\t\tpW2L[++*pW2L] = nInput - 'A' + 'a'; \t\t} \t\telse if ('0' <= nInput && nInput <= '9') \t\t{ \t\t\tint nMinID = 0; \t\t\tint nMaxID = *pNum - 1; \t\t\tint nInsertID = nMinID;  \t\t\twhile (nMinID <= nMaxID) \t\t\t{ \t\t\t\tnInsertID = (nMinID + nMaxID) / 2;  \t\t\t\tif (pNum[nInsertID + 1] < nInput && nInsertID == nMinID) \t\t\t\t{ \t\t\t\t\t++nMinID; \t\t\t\t\t++nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] < nInput) \t\t\t\t{ \t\t\t\t\tnMinID = nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] == nInput) \t\t\t\t{ \t\t\t\t\tbreak; \t\t\t\t} \t\t\t\telse if (nMaxID == nInsertID) \t\t\t\t{ \t\t\t\t\t--nMaxID; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tnMaxID = nInsertID; \t\t\t\t} \t\t\t}  \t\t\tfor (int j = *pNum - 1; j >= nInsertID; --j) \t\t\t{ \t\t\t\tpNum[j + 2] = pNum[j + 1]; \t\t\t}  \t\t\t++*pNum; \t\t\tpNum[nInsertID + 1] = nInput; \t\t} \t\telse \t\t{ \t\t\tprintf(\"要求：随机输入数字 大写 小写字母！\\r\\n\"); \t\t\treturn; \t\t} \t}  \tpL2W[*pL2W + 1] = 0; \tpW2L[*pW2L + 1] = 0; \tpNum[*pNum + 1] = 0;  \tprintf(\"小变大：%s\\r\\n\", pL2W + 1); \tprintf(\"大变小：%s\\r\\n\", pW2L + 1); \tprintf(\"数字排序：%s\\r\\n\", pNum + 1);  \tdelete[] pL2W; \tdelete[] pW2L; \tdelete[] pNum; }", "referer": "user-0"}]}
{"question": "C语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void AssisTest(void) { \tint nMaxInput = 20;  \tchar* pL2W = new char[nMaxInput + 2]; \tchar* pW2L = new char[nMaxInput + 2]; \tchar* pNum = new char[nMaxInput + 2];  \t*pL2W = 0; \t*pW2L = 0; \t*pNum = 0;  \tint nInput = 0; \tfor (int i = 0; (nInput = getchar()) != 10; ++i) \t{ \t\tif (i >= nMaxInput) \t\t{ \t\t\tprintf(\"总数不超过20个！\\r\\n\"); \t\t\treturn; \t\t}  \t\tif ('a' <= nInput && nInput <= 'z') \t\t{ \t\t\tpL2W[++*pL2W] = nInput - 'a' + 'A'; \t\t} \t\telse if ('A' <= nInput && nInput <= 'Z') \t\t{ \t\t\tpW2L[++*pW2L] = nInput - 'A' + 'a'; \t\t} \t\telse if ('0' <= nInput && nInput <= '9') \t\t{ \t\t\tint nMinID = 0; \t\t\tint nMaxID = *pNum - 1; \t\t\tint nInsertID = nMinID;  \t\t\twhile (nMinID <= nMaxID) \t\t\t{ \t\t\t\tnInsertID = (nMinID + nMaxID) / 2;  \t\t\t\tif (pNum[nInsertID + 1] < nInput && nInsertID == nMinID) \t\t\t\t{ \t\t\t\t\t++nMinID; \t\t\t\t\t++nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] < nInput) \t\t\t\t{ \t\t\t\t\tnMinID = nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] == nInput) \t\t\t\t{ \t\t\t\t\tbreak; \t\t\t\t} \t\t\t\telse if (nMaxID == nInsertID) \t\t\t\t{ \t\t\t\t\t--nMaxID; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tnMaxID = nInsertID; \t\t\t\t} \t\t\t}  \t\t\tfor (int j = *pNum - 1; j >= nInsertID; --j) \t\t\t{ \t\t\t\tpNum[j + 2] = pNum[j + 1]; \t\t\t}  \t\t\t++*pNum; \t\t\tpNum[nInsertID + 1] = nInput; \t\t} \t\telse \t\t{ \t\t\tprintf(\"要求：随机输入数字 大写 小写字母！\\r\\n\"); \t\t\treturn; \t\t} \t}  \tpL2W[*pL2W + 1] = 0; \tpW2L[*pW2L + 1] = 0; \tpNum[*pNum + 1] = 0;  \tprintf(\"小变大：%s\\r\\n\", pL2W + 1); \tprintf(\"大变小：%s\\r\\n\", pW2L + 1); \tprintf(\"数字排序：%s\\r\\n\", pNum + 1);  \tdelete[] pL2W; \tdelete[] pW2L; \tdelete[] pNum; }", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "字母大小写视为相同吗？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "需求不明确，建议楼主细化一下吧", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "没看懂，你这输入与输出，有啥逻辑关系", "referer": "user-0"}]}
{"question": "这个文本编辑器，各位大佬有没有啥思路？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "结构体啊。。。。", "referer": "user-0"}]}
{"question": "exe触发断点问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Windows： 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  Linux： 进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "大佬们这个出发短点咋个办那", "referer": "user-0"}]}
{"question": "计算星期值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你自己不都说了么，四闰百不闰，四百闰，你把100,200,300,500,600,。。。这些给当成闰年再算，结果肯定有问题啊", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "# include <stdio.h> int main() {     int year,t,s,day;      scanf(\"%d\",&year);      t=(year-1)/4;      s=(year-1)%4;      switch(s)     {         case 0:day=t*(365*3+366);break;         case 1:day=t*(365*3+366)+365;break;         case 2:day=t*(365*3+366)+365*2;break;         case 3:day=t*(365*3+366)+365*3;break;      }     int i;      i=day%7;      switch(i)     {         case 0:printf(\"星期天\\n\");break;         case 1:printf(\"星期一\\n\");break;         case 2:printf(\"星期二\\n\");break;         case 3:printf(\"星期三\\n\");break;         case 4:printf(\"星期四\\n\");break;         case 5:printf(\"星期五\\n\");break;         case 6:printf(\"星期六\\n\");break;     }     return 0; } 供参考～  case 0改成星期天，其他依次修改一下i值对应的星期值就可以了～  case0不就是7%7得0吗？怎么把0改成星期一了呢？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "有测试用例吗？发一下，不知道你说的哪里错是测试出错，还是其他错误？", "referer": "user-0"}]}
{"question": "圆锥体积", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "上面那老哥说的对，V=PI*r*r*h*(1/3); 这句错误，1 和 3 均为整形，两个相除的商也应该是整形，所以 1/3=0 ，应该用 1.0/3 或者 1/3.0", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "V=PI*r*r*h*(1/3);这句有问题   1/3计算机中结果是0  整形相除 改一下 V=PI*r*r*h*(1.0/3);", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "V=PI*r*r*h*(1/3); 这句错误，修改如下： #include<stdio.h> #include<stdlib.h> #define PI 3.14  int main(int argc, char* argv[]) {     int r,h,l;     float S,V;     r=5;     h=12;     l=13;     S=PI*r*l+PI*r*r;      V=PI*r*r*h/3;//这句修改     printf(\"表面积S=%f\\n体积V=%f\\n\",S,V);     system(\"pause\");     return 0;", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "代码没问题啊，或者你把r,h.l换成浮点型试试", "referer": "user-0"}]}
{"question": "scanf()格式说明符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 自信男孩 的回复:都可以连写也可以单写，需要注意的是%c处理起来比较麻烦。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "都可以连写也可以单写，需要注意的是%c处理起来比较麻烦。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\\t'); or newline ('\\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.", "referer": "user-0"}]}
{"question": "8.52的二进制", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "eb和ec刚好差1，反码和补码也是1的关系，计算机存储是补码", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你看错了，前面的是低位，后面是高位， 你没发现你算的是41，08，51，eb; 正好和他的相反吗？至于是ec,eb，不过是浮点的精度问题", "referer": "user-0"}]}
{"question": "请问我这个代码为啥运行不了啊？自己找不到错误，有能力的老哥帮帮忙吧谢谢了。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "学会调试", "referer": "user-0"}]}
{"question": "数组初始化", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 17 楼 qzjhjxj 的回复:引用所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？这里 int a[10] = {1}，后面是大括号{}，就是数组10个元素都被初始化为1，而不是a[0]被初始化为1。如果要a[0]初始化为1，应该是a[10]=1. a[10] = 1;这个操作已经数组越界了，下表最大10-1   建议你自己试试，写几条语句试试，然后再发表看法，或许更有说服力。 一维数组初始化（定义式），不用大括号，你打算用什么来初始化？", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？这里 int a[10] = {1}，后面是大括号{}，就是数组10个元素都被初始化为1，而不是a[0]被初始化为1。如果要a[0]初始化为1，应该是a[10]=1.", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 15 楼 自信男孩 的回复:[quote=引用 11 楼 SleekStone 的回复:][quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 对，自测一下就好了～[/quote]我想说的在14楼，不过刚刚看到外面有个帖子https://bbs.csdn.net/topics/398136483，我觉得那里面5楼的兄弟说得有道理", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "引用 11 楼 SleekStone 的回复:[quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 对，自测一下就好了～", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 12 楼 xian_wwq 的回复:[quote=引用 11 楼 SleekStone 的回复:][quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote]  确实如此，在环境中跑一下，一目了然[/quote]我的意思不是在怀疑这个结果，我是在怀疑这个表述“int a[10]={0}的时候，10个元素都被初始化为0，int a[10]={1},只有a[0]被初始化为了1，其它被初始化为了0”，这种表述我不知道正不正确，我依稀记得我上学的时候老师说的是“int a[10]={x}，只有第一个元素被初始化为了x，其它元素值是由编译器提供实现的，有的编译器会设成0”，如果我记得没错的话，就意味着对于int a[10]={x}，C++标准只规定了a[0]，初始化为x，其它值标准是不做保证的，我刚才去找了找看能不能找到这个标准，可惜我没找到，如果有朋友找到相关的标准了，也希望告知我一下，", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "1. 直接给每个元素赋值 int array[4] = {1,2,3,4}; 2. 给一部分赋值，后面的全部为0 int array[4] = {1,2}; 3. 由赋值参数个数决定数组的个数 int array[] = {1,2}; 4. 数组元素的值是随机分配的 int array[4] = {}; 当初始化参数时，推荐使用 int array[4] = {0};", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "引用 11 楼 SleekStone 的回复:[quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote]  确实如此，在环境中跑一下，一目了然", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 10 楼 自信男孩 的回复:[quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "引用 8 楼 SleekStone 的回复:[quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.", "referer": "user-0"}, {"cid": "10", "user": "user-5", "content": "引用 4 楼 自信男孩的回复:[quote=引用 3 楼 m0_51355118 的回复:]错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样 k是可变的，数组长度是不确定的～[/quote] c99允许这样定义和使用，只是无法初始化，要另外赋值", "referer": "user-0"}, {"cid": "11", "user": "user-3", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "引用 5 楼 user-6 的回复:[quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0不会  有初始化没指定初始化项都会初始化为0[/quote]int a[10] = {1};这样呢？", "referer": "user-0"}, {"cid": "13", "user": "user-1", "content": "引用 1 楼 SleekStone 的回复:int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.", "referer": "user-0"}, {"cid": "14", "user": "user-6", "content": "引用 1 楼 SleekStone 的回复:int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0不会  有初始化没指定初始化项都会初始化为0", "referer": "user-0"}, {"cid": "15", "user": "user-1", "content": "引用 3 楼 m0_51355118 的回复:错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样 k是可变的，数组长度是不确定的～", "referer": "user-0"}, {"cid": "16", "user": "user-5", "content": "错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样", "referer": "user-0"}, {"cid": "17", "user": "user-1", "content": "a数组是不确定大小的，大小由n决定。C语言不支持可变数组。楼主可以用动态申请空间形式申请空间（当做数组用）  a = (int *)malloc(sizeof(int) * k); if (!a)     exit(0); memset(a, 0,  k * sizeof(int));", "referer": "user-0"}, {"cid": "18", "user": "user-3", "content": "int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。", "referer": "user-0"}]}
{"question": "大神求救，这个为什么会报错   没定义 ？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "[quote=引用 3 楼 自信男孩 的回复:]#include<stdio.h> //    int main() int getcount(int n) {     int i,count;     if(n>60)         count++;     return count; } int main() {     int n,count=0;     printf(\"input a numble:\\n\");     scanf(\"%d\",&n);     count=getcount(90);     printf(\"%d\",count);     return 0; }  供参考～  getcount函数里的count是未初始化的，需要注意下～[              谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> //    int main() int getcount(int n) {     int i,count;     if(n>60)         count++;     return count; } int main() {     int n,count=0;     printf(\"input a numble:\\n\");     scanf(\"%d\",&n);     count=getcount(90);     printf(\"%d\",count);     return 0; }  供参考～  getcount函数里的count是未初始化的，需要注意下～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "修改后是这样：#include<stdio.h> int getcount(int n) { int count; if(n>60) count++; return count; } int main() { int n,count=0; printf(\"input a numble:\\n\"); scanf(\"%d\",&n); count=getcount(n); printf(\"%d\",count); return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "int main()//这一行必须取消 int getcount(int n) { int i,count; if(n>60) count++; return count; } int main() { int n,count=0; printf(\"input a numble:\\n\"); scanf(\"%d\",&n); count=getcount(90);//这行调用getcount()函数，应该是count=getcount(n);才正确 printf(\"%d\",count); return 0; }", "referer": "user-0"}]}
{"question": "判断输入括号是否成对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "相等的时候为什么输出为空啊", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "多分号～需要注意下～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 一颗白面馒头的回复:while循环里面的if条件判断后面不加分号 。。。。我去，我忘记把删除语句后面的分号也删了", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "while循环里面的if条件判断后面不加分号", "referer": "user-0"}]}
{"question": "C程序设计语言-练习1-6，问题求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "没有问题，我故意不加括号的，不是为了读取字符，而是为了测试EOF，最终的输出只有1和0", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "个人觉得应该和系统环境以及编译器或者IDE有关，不是每种组合的运行结果都是这样，我的linux+gcc输入ctrl+z就会提示已停止，不会输出0。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "while(ch = getchar() != EOF) 改一下  while((ch = getchar()) != EOF) 因为!=优先级比=高，因此会把判断结果赋值给ch，而不是getchar()的返回值赋值给ch", "referer": "user-0"}]}
{"question": "小白求问，真的很简单", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位的解答 懂了！谢谢各位！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "while循环结束后，p已经指到了数组的最后一个元素地址 而s则表示这个数组第一个元素的首地址 所以这里可以直接用p-s", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "没有代码没有真相", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "这里可以填p-s;并且后面的注释也说明了这一点。 另外，需要注意的是myStrlen函数的s，虽然写的是数组形式，其实是指针，因为编译器已经将其按照指针处理的。  从另一个知识点也能证明这里不是数组，而是指针，根据参数传递是值传递，是实参赋值给形参（可以这么理解），如果形参是数组名，根据数组名不能做左值，因此就矛盾了。  所以，形参数名字写成数组，直接可以理解为指针就好了。", "referer": "user-0"}]}
{"question": "fgets函数相关问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:楼主的程序fgets放在一个while循环里，自然后面的覆盖前面的。改成每次fgets之后都去判断空格，字符，数字等等即可～   建议判断一下fgets的返回值。另外，注意fgets会把回车符号加到缓存里～ 主要是我之前不知道fgets遇到回车就结束了，后来调试发现不对劲，才找到的原因", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主的程序fgets放在一个while循环里，自然后面的覆盖前面的。改成每次fgets之后都去判断空格，字符，数字等等即可～   建议判断一下fgets的返回值。另外，注意fgets会把回车符号加到缓存里～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "已解决，每次读取到回车后fgets都会结束读取，出现这个情况的原因是后来的读取的数据将前面的数据给覆盖了", "referer": "user-0"}]}
{"question": "求助大佬这个用c语言怎么写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> int main(){ \tint n, a, b; \tscanf(\"%d\", &n); \ta = 0; b = n - 1; \tfor(int i = 0; i < n; i ++){ \t\tfor(int j = 0; j < n; j ++){ \t\t\tif(a == j || b == j) \t\t\t\tprintf(\"*\"); \t\t\telse \t\t\t\tprintf(\" \"); \t\t} \t\ta ++; b --; \t\tprintf(\"\\n\"); \t} \treturn 0; }", "referer": "user-0"}]}
{"question": "两个压缩矩阵怎样实现相乘", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "给LZ一段代码参考吧  int** toMatrix(int n, char c) { //对称压缩矩阵转矩阵（沿对角线存储半个恢复回原来的矩阵）     int i, j, k, t, l;     int **a = (int**)malloc(sizeof(int*)*n);     for (int i=0; i<n; i++) {         a[i] = (int*)malloc(sizeof(int)*n);     }     l = n*(n-1)/2 + n;     printf(\"生成矩阵%c, 请输入%d个压缩矩阵中的数：\\n\", c, l);     for (i=0; i<l; i++) {         scanf(\"%d\", &t);         for(j=1; j<=n; j++) {             for (k=1; k<=j; k++) {                 if (j*(j-1)/2+(k-1)==i) {                     a[j-1][k-1] = t;                     a[k-1][j-1] = t;                 }             }         }     }     return a; }  int** multiplyMatrix(int **a, int **b, int n) { //矩阵乘法(必须满足矩阵A的列数和矩阵B的行数相同，本题忽略，都是n*n矩阵)     int i, j, k, s;     int **c = (int**)malloc(sizeof(int*)*n);     for (int i=0; i<n; i++) {         c[i] = (int*)malloc(sizeof(int)*n);     }     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             s = 0;             for (k=0; k<n; k++) {                 s += a[i][k]*b[k][j];             }             c[i][j] = s;         }     }     return c; }  void destoryMatrix(int **a, int n) {     int i;     for (i=0; i<n; i++) {         free(a[i]);     }     free(a); }  int main() {     int n, i, j, **a, **b, **c;     printf(\"请输入阶数n：\\n\");     scanf(\"%d\", &n);     a = toMatrix(n, 'A');     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             printf(\"%5d\", a[i][j]);         }         printf(\"\\n\");     }          b = toMatrix(n, 'B');     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             printf(\"%5d\", b[i][j]);         }         printf(\"\\n\");     }          printf(\"A * B = \\n\");     c = multiplyMatrix(a, b, n);     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             printf(\"%5d\", c[i][j]);         }         printf(\"\\n\");     }          destoryMatrix(a, n);     destoryMatrix(b, n);     destoryMatrix(c, n); }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你这个是压缩矩阵，是沿对角线存储了半个。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 3 楼 zgl7903的回复:理解矩阵乘法 我这知道怎样乘，但就是压缩矩阵不会乘", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "理解矩阵乘法", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 老马何以识途的回复:一維數組就要定位行列了，其實也簡單，A第x行第y列就是A[(x - 1) * n + (y - 1)] 能具体讲一下吗", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "一維數組就要定位行列了，其實也簡單，A第x行第y列就是A[(x - 1) * n + (y - 1)]", "referer": "user-0"}]}
{"question": "求帮助，急，介绍一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的程序块中的','换成';'", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://blog.csdn.net/qq_42302831/article/details/88587052", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "if(a<b)     {         c=a,a=b,b=c;     } 这一步用于保证a >= b；否则执行if内的交换  while(b!=0)     {         c=a%b,a=b,b=c;     } 这一步可以考虑学习一下最大公约数的求值算法～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "d=a,e=b; c=a,a=b,b=c; c=a%b,a=b,b=c; 不知道原题是什么，但我想不会是测试逗号表达式吧，所以认为这几句逗号应该是分号。整理代码如下   #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> int main() {     int a, b, c, d, e;     scanf(\"%d%d\", &a, &b);     d = a;     e = b;     if (a < b)    //交换，如果a小于b,则两数交换     {                 c = a;         a = b;          b = c;             }     while (b != 0)     {                 c = a % b;   //循环求模              a = b;                b = c;             }     printf(\"%d\\n%d\\n\", a, (d*e) / a);     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "这个就是一个求两个数的最小公倍数和最大公因数的代码", "referer": "user-0"}]}
{"question": "有大佬能解释一下吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "A[B] *(A+B) *(B+A) B[A] //以上四行等价  \"abc\"[1] *(\"abc\"+1) *(1+\"abc\") 1[\"abc\"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "printf(\"%c\\n\", *string_p++); printf(\"%c\\n\", string_p[1]); 第一个printf是因为++后后增，因此是先求表达式的值，即(*string_p++)，然后自增string_p指针，指向'8'的地址， 第二个是在第一个基础上的，因此string_p[0]是'8'，string_p[1]即'4'了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这个其实就是指针的使用了  多去看看指针的定义吧 char* string_p = \"48430\";   //此时 指针指向字符串的首地址，也即字符串首个字符的地址  该地址的值是'4'  即此时*string_p=4 printf(\"%c\\n\", *string_p++);  //* 和后置++优先级是一样的，但是他们的结合顺序是自右向左的 所以先执行的的string_p++,string_p指向下一个值得地址，*string_p 取值为4 printf(\"%c\\n\", string_p[1]);   //刚才的string_p自增了 此时string_p指向的'8'  string_p[1]表示之后的第2个字符  也就是4  是8后面的4", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "String_p是一个字符串数组的名称 = 第一个字符的地址，所以*string_p == 4 ,又因为后面有++，所以字符数组指针后移，string_p[0] = 8,所以 string_p[1] = 4", "referer": "user-0"}]}
{"question": "请问大神到地使出了什么问题，为什么c,b输不上。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "输入时，a b c 之间为空格，不用，号", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "确认一下你的输入的逗号和scanf中的逗号是否一致，scanf是格式化输入，因此要按照scanf中第一个参数的格式输入。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你看一下 你输入的是不是中文的逗号", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "应该是逗号问题吧，代码中的是中文逗号，cmd中的是英文逗号，两个不一致导致的，建议别用逗号，用空格代替比较好，不容易出错", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "因为你输入的时候用的逗号是中文的，c语言符号一定要用英文！！", "referer": "user-0"}]}
{"question": "求指点数据结构链栈将一个十进制数转换为二进制数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <malloc.h>  typedef struct node{     int data;     struct node *link; }NODE;  NODE *push(NODE *top, int m) {     NODE *p;//,top;     p=(NODE *)malloc(sizeof(NODE));     p->data =m;     p->link =top;     top=p;     return top; } NODE *pop(NODE *top, int *x) {     NODE *q;     q=top;     top=top->link ;     *x = q->data;     free(q);     return top; } void conversion(int N,int r) {     NODE *top1 = NULL;     int val;     //top1=(NODE *)malloc(sizeof(NODE));     int x=N,y=r;     while(N!=0)     {         top1=push(top1, N%r);         N=N/r;     }     printf(\"\\n十进制数%d所对应的%d进制数是:\",x,y);     while(top1!=NULL)     {         top1=pop(top1, &val);          printf(\"%d\", val);     }     printf(\"\\n\"); }  //void main() int main() {     int n,r;     printf(\"请输入任意一个十进制整数及其所需转换的进制数:\\n\");     scanf(\"%d%d\",&n,&r);     conversion(n,r); } 供参考～  对比代码找一下自己的问题吧～", "referer": "user-0"}]}
{"question": "C语言acm题,怎么做啊？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用scanf(\"%u %u %du\",&x,&y,&z);这句输入有问题吧看，%du多了个d", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "啊这，我们学校内网哥你也进不去啊，题目我都贴全了，我也不知道咋回事", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 2 楼 qq_51501668 的回复:[quote=引用 1 楼 user-2的回复:]你的程序定义了一堆整数， n=b/3;  你确定这句不会有问题？ 你的怎么这么麻烦 别把简单问题想复杂了 供参考  int main(){    int a,b;    while (scanf(\"%d %d\",&a,&b)!=EOF)    {       unsigned int x,y,z;       scanf(\"%u %u %du\",&x,&y,&z);       printf(\"%u\\n\",2*(x+y)+3*z-a-b);    }  }  哥，不对啊，每次都是 Wrong answer on test 4 [/quote]  那就说明acm的test4有特殊的情况 现在没考虑到  你能把acm的网址给我吗  我替你去看看", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 user-2的回复:你的程序定义了一堆整数， n=b/3;  你确定这句不会有问题？ 你的怎么这么麻烦 别把简单问题想复杂了 供参考  int main(){    int a,b;    while (scanf(\"%d %d\",&a,&b)!=EOF)    {       unsigned int x,y,z;       scanf(\"%u %u %du\",&x,&y,&z);       printf(\"%u\\n\",2*(x+y)+3*z-a-b);    }  }  哥，不对啊，每次都是 Wrong answer on test 4", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "过了，谢谢大佬们", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "#include<stdio.h>  int main() {   unsigned long long int a,b,x,y,z,A,B;     scanf(\"%lld%lld\",&a,&b);     scanf(\"%lld%lld%lld\",&x,&y,&z);     if(a>=2*x+y)     A=0;     else     A=2*x+y-a;     if(b>=3*z+y)     B=0;     else     B=3*z+y-b;     printf(\"%lld\",A+B);     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "还有如果一个颜色很多另一个颜色很少还是需要晶体。可能要讨论。", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "引用int main(){    int a,b;    while (scanf(\"%d %d\",&a,&b)!=EOF)    {                  unsigned int x,y,z;                  scanf(\"%u %u %u\",&x,&y,&z);//这是改好的。 //原来的： scanf(\"%u %u %du\",&x,&y,&z);                 printf(\"%u\\n\",2*(x+y)+3*z-a-b);    }  }结果为负，超范围了。unsigned int：32位，0<=X<=4294967295;   long: 32位，-2147483648<=X<=2147483647.", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "a, b如果太大结果不就是负的了？但我改了一下还是不行", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "引用 5 楼 qzjhjxj 的回复:引用scanf(\"%u %u %du\",&x,&y,&z);这句输入有问题吧看，%du多了个d   引用 4 楼 qq_51501668 的回复:啊这，我们学校内网哥你也进不去啊，题目我都贴全了，我也不知道咋回事  那你改一下 不知道是不是范围溢出了 int main(){    int a,b;    while (scanf(\"%d %d\",&a,&b)!=EOF)    {       long long x,y,z;       scanf(\"%lld %lld %lld\",&x,&y,&z);       printf(\"%lld\\n\",2*(x+y)+3*z-a-b);    }  }", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "你的程序定义了一堆整数， n=b/3;  你确定这句不会有问题？ 你的怎么这么麻烦 别把简单问题想复杂了 供参考  int main(){    int a,b;    while (scanf(\"%d %d\",&a,&b)!=EOF)    {       unsigned int x,y,z;       scanf(\"%u %u %du\",&x,&y,&z);       printf(\"%u\\n\",2*(x+y)+3*z-a-b);    }  }", "referer": "user-0"}]}
{"question": "C 语言多进程 vs 多线程性能问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我每次测试10秒，然后结果/10来显示数据， 还有计时问题，我直接使用了系统的时间函数，没有事用tsc来计算。  误差也肯定有，但是应该不会影响整体效果吧。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "使用电脑计时有时误差会很大，因为待测程序段的运行会影响电脑时钟。 将待测程序段循环足够多次，手动掐秒表计时可能更准确。", "referer": "user-0"}]}
{"question": " 程序编译后，出现\"eh.h is only for C++!\"", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 丁劲犇的回复:你文件名是不是.c？另存为cpp即可。 好的，谢谢，已经解决了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你文件名是不是.c？另存为cpp即可。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "你编译的不是这段代码。", "referer": "user-0"}]}
{"question": "急求 这段代码哪里错了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for (mark = MAXSIZE-1; mark >= 0; mark--)     {         if (bigint[mark] == 0) break;     } 楼主的问题出在这里，看一下，MAXSIZE是200，而传进来的bigint有200个吗？ 还有bigint传进来的内容是初始化的bigint1,bigint2, bigint3，第200个元素是几，楼主需要了解一下，不然这个问题不好解决。  int bigint1[MAXSIZE] = {0,0,9,8,7,6,5,4,3,2,1}; 这是初始化，前几个元素赋值了？答案是11个，那么第12个到MAXSIZE后面的数据初始化为几？看样子是没有初始化，其实编译器都给初始化了，为0. 既然这么理解了，那么上面的自定义函数里的处理是不是就有问题了？  不知道这么解释，楼主是否能够明白～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "都没说是什么错...", "referer": "user-0"}]}
{"question": "我想问一下如何在循环中做到输出条件中的最后一个数无多余字符而前面输出的都有空格", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢校友！！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> int main (){ \tint i,a,b,c,d,k=0; \tfor (i=100;i<999;i++){         a=i/100; \t    b=i%100/10; \t    c=i%10; \t    d=a*a*a+b*b*b+c*c*c; \t    if (i==d){ \t    \tk++; \t    \tif (k==1){ \t    \t\tprintf(\"%d\",i); \t    \t} \t    \telse{  \t    \t\tif (k>1) \t    \t\t\tprintf (\" %d\",i); \t    \t}       } \t} \treturn 0; }          //做个计数器就可以了  jlu校友", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h> int main() {     int i,j,k,n;     n=0;     for (i=1;i<10;i++)     for (j=0;j<10;j++)     for (k=0;k<10;k++) {         if (i*i*i+j*j*j+k*k*k==i*100+j*10+k) {             if (n==0) {                 printf(\"%d\",i*100+j*10+k);                 n=1;             } else {                 printf(\" %d\",i*100+j*10+k);             }         }     }     printf(\"\\n\");     return 0; } //153 370 371 407 //", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 宇来风满楼 的回复:空格不是看不见吗，有啥影响 引用 1 楼 宇来风满楼 的回复:空格不是看不见吗，有啥影响 学校作业要求，想刷分就得按要求来", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "算，可这样第一个字符前又有空格了", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "做个计数。当输出第一个的时候输出“%d” 后面全都输出“ %d”", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "指定格式输出，如：“%2d”，自动靠右，最后没空格的，楼主这算不算你说的意思？", "referer": "user-0"}, {"cid": "8", "user": "user-5", "content": "空格不是看不见吗，有啥影响", "referer": "user-0"}]}
{"question": "C语言作业", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "数组长度～[]在定义的时候，中括号里的是数组长度～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 7 楼 weixin_44382508 的回复:数组元素数组打错了   就是这个数组的容量    例如int array[10]   那这个array数组最多有10个元素", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "数组元素数组", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 4 楼 轻语2000的回复:[quote=引用 3 楼 qq_52134323的回复:][quote=引用 1 楼 轻语2000的回复:]这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 数组的容量是看哪个符号里的大小[/quote] 那个容量是你自己根据需求定义的，肯定不一样啊，你看看书[/quote] 好难啊这个题", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "请问你说的需求定义在我发的图里哪个位置", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 3 楼 qq_52134323的回复:[quote=引用 1 楼 轻语2000的回复:]这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 数组的容量是看哪个符号里的大小[/quote] 那个容量是你自己根据需求定义的，肯定不一样啊，你看看书", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 轻语2000的回复:这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 数组的容量是看哪个符号里的大小", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 1 楼 轻语2000的回复:这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 为啥有的时候数字不一样，容量是看字节吗", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。", "referer": "user-0"}]}
{"question": "C++语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "是否是写一个函数将字符数组中的x替换为y ##仅供参考 #include<stdio.h> #include<string.h> void RepChar(char s[],char x,char y) { \tfor(int i=0;i<strlen(s);i++) \t{ \t\tif(s[i]==x) \t\t\ts[i]=y; \t} } int main() { \tchar str[]=\"xycnbyxyx\"; \tRepChar(str,'x','y'); \tprintf(\"%s\\n\",str);\t } /*运行结果： yycnbyyyy */", "referer": "user-0"}]}
{"question": "【C语言】【飞机大战】光标不移动", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 小布的笔记 的回复:编译不成功？？？在我的电脑上是能的。。。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "仅供参考：#include <conio.h> #include <windows.h>  void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); } void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } } void GetWH(int *w,int *h) {     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     CONSOLE_SCREEN_BUFFER_INFO csbi;     if (GetConsoleScreenBufferInfo(hStdOut, &csbi)) {         *w=csbi.srWindow.Right;         *h=csbi.srWindow.Bottom;     } else {         *w=80;         *h=25;     } } void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  int main() {     unsigned short k;     int x,y,w,h;     char d;      SetConsoleOutputCP(437);     ClearConsole();     GetWH(&w,&h);     x=w/2;y=h/2;     HideTheCursor();     ConPrintAt(x,y,\"O\",1);     d='o';     while (1) {         Sleep(50);         if (kbhit()) {             k=getch();             if (27==k) break;//按Esc键退出             if (0==k||0xe0==k) k|=getch()<<8;//非字符键             switch (k) {                 case 0x48e0:case 0x04800://上                     d='u';                     if (y>0) {                         ConPrintAt(x,y,\" \",1);                         y--;                         ConPrintAt(x,y,\"O\",1);                     }                 break;                 case 0x50e0:case 0x05000://下                     d='d';                     if (y<h) {                         ConPrintAt(x,y,\" \",1);                         y++;                         ConPrintAt(x,y,\"O\",1);                     }                 break;                 case 0x4be0:case 0x04b00://左                     d='l';                     if (x>0) {                         ConPrintAt(x,y,\" \",1);                         x--;                         ConPrintAt(x,y,\"O\",1);                     }                 break;                 case 0x4de0:case 0x04d00://右                     d='r';                     if (x<w-1) {                         ConPrintAt(x,y,\" \",1);                         x++;                         ConPrintAt(x,y,\"O\",1);                     }                 break;             } //          cprintf(\"%04x pressed.\\r\\n\",k);         } else {             switch (d) {                 case 'u':                     if (y>0) {                         ConPrintAt(x,y,\" \",1);                         y--;                         ConPrintAt(x,y,\"O\",1);                     }                 break;                 case 'd':                     if (y<h) {                         ConPrintAt(x,y,\" \",1);                         y++;                         ConPrintAt(x,y,\"O\",1);                     }                 break;                 case 'l':                     if (x>0) {                         ConPrintAt(x,y,\" \",1);                         x--;                         ConPrintAt(x,y,\"O\",1);                     }                 break;                 case 'r':                     if (x<w-1) {                         ConPrintAt(x,y,\" \",1);                         x++;                         ConPrintAt(x,y,\"O\",1);                     }                 break;             }         }     }     ClearConsole();     ShowTheCursor();     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "编译不成功？？？", "referer": "user-0"}]}
{"question": "在一个数列的 插入一个数 然后排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 xws245925587 的回复:#include<stdio.h>  #ifndef _count_arry  #define _count_arry(a) (sizeof(a) / sizeof(a[0])) #endif  int main() { \tint a[6] = { 1,7,10,14,16 }; \tint i, j, x, t; \tscanf_s(\"%d\", &x); \ta[5] = x;  \tfor (j = 0; j < _count_arry(a) - 1; j++) \t{ \t\tfor (i = 0; i< _count_arry(a) - 1 - j; i++)           \t\t{ \t\t\tif (a[i]>a[i + 1])   \t\t\t{ \t\t\t\tt = a[i];       \t\t\t\ta[i] = a[i + 1];     \t\t\t\ta[i + 1] = t; \t\t\t} \t\t} \t}   \tfor (i = 0; i < 6; i++) \t{ \t\tprintf(\"%d \", a[i]); \t} \tsystem(\"pause\"); }   for (i = 0; i< _count_arry(a) - 1 - j; i++)          这里为什么要  -1啊 ，我减掉1后   就对了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "_count_arry(a) (sizeof(a) / sizeof(a[0])) 这个有什么作用哦？？ 谢谢啦", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include<stdio.h>  #ifndef _count_arry  #define _count_arry(a) (sizeof(a) / sizeof(a[0])) #endif  int main() { \tint a[6] = { 1,7,10,14,16 }; \tint i, j, x, t; \tscanf_s(\"%d\", &x); \ta[5] = x;  \tfor (j = 0; j < _count_arry(a) - 1; j++) \t{ \t\tfor (i = 0; i< _count_arry(a) - 1 - j; i++) \t\t{ \t\t\tif (a[i]>a[i + 1])   \t\t\t{ \t\t\t\tt = a[i];       \t\t\t\ta[i] = a[i + 1];     \t\t\t\ta[i + 1] = t; \t\t\t} \t\t} \t}   \tfor (i = 0; i < 6; i++) \t{ \t\tprintf(\"%d \", a[i]); \t} \tsystem(\"pause\"); }", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 xws245925587 的回复:#include<stdio.h>  #ifndef _count_arry  #define _count_arry(a) (sizeof(a) / sizeof(a[0])) #endif  int main() { \tint a[6] = { 1,7,10,14,16 }; \tint i, j, x, t; \tscanf_s(\"%d\", &x); \ta[5] = x;  \tfor (j = 0; j < _count_arry(a) - 1; j++) \t{ \t\tfor (i = 0; i< _count_arry(a) - 1 - j; i++) \t\t{ \t\t\tif (a[i]>a[i + 1])   \t\t\t{ \t\t\t\tt = a[i];       \t\t\t\ta[i] = a[i + 1];     \t\t\t\ta[i + 1] = t; \t\t\t} \t\t} \t}   \tfor (i = 0; i < 6; i++) \t{ \t\tprintf(\"%d \", a[i]); \t} \tsystem(\"pause\"); } 谢谢谢谢！！！", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 3 楼 果、失 的回复:[quote=引用 1 楼 xws245925587 的回复:]#include<stdio.h>  #ifndef _count_arry  #define _count_arry(a) (sizeof(a) / sizeof(a[0])) #endif  int main() { \tint a[6] = { 1,7,10,14,16 }; \tint i, j, x, t; \tscanf_s(\"%d\", &x); \ta[5] = x;  \tfor (j = 0; j < _count_arry(a) - 1; j++) \t{ \t\tfor (i = 0; i< _count_arry(a) - 1 - j; i++)           \t\t{ \t\t\tif (a[i]>a[i + 1])   \t\t\t{ \t\t\t\tt = a[i];       \t\t\t\ta[i] = a[i + 1];     \t\t\t\ta[i + 1] = t; \t\t\t} \t\t} \t}   \tfor (i = 0; i < 6; i++) \t{ \t\tprintf(\"%d \", a[i]); \t} \tsystem(\"pause\"); }   for (i = 0; i< _count_arry(a) - 1 - j; i++)          这里为什么要  -1啊 ，我减掉1后   就对了[/quote]因为你要用数组下标，而数组下标是从0开始的，代表数组中的第一个元素，下标值不能超过数组长度的那个数值，比如数组a[10],你的下标最多到a[9]", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 2 楼 果、失 的回复:_count_arry(a) (sizeof(a) / sizeof(a[0])) 这个有什么作用哦？？ 谢谢啦求出数组的长度，类似于字符串函数里面的strlen().", "referer": "user-0"}]}
{"question": "栈实现四则运算求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "typedef char OperandType;//运算类型 你怎么能用char去定义一个answer呢?", "referer": "user-0"}]}
{"question": "大一新生程序小白求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "stdio.h和math.h是不同的头文件，第一个头文件在你使用scanf/printf等这些基本上库函数时需要引入头文件，math.h是数学函数库，比如abs，sqrt等这些数学库时，需要引入这个头文件。 对于main的返回值是int还是void看编译器吧，这个无需纠结～   建议楼主不要纠结这两个问题，等你编写程序多的时候自然会理解和解决这两个问题。比如，math.h什么时候引入，你编写程序时，编译时不引入就会报错，那么你自然要解决编译报错问题，那么最终的解决就会考虑引入这个头文件，因此楼主还是多关注基础的知识点，多写，多调程序吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先安抚你一下，这个东西我保证你后面自然会懂，现在不管都行。然后我具体说一下，这个东西是c的头文件，里面有各种函数，如果你的程序要用他们那你就要把他写出来，这个#include<stdio.h>是一定会用的scanf和pringf这种基础函数都在里面，所以写程序不管三七二十一先写在前面，那个#include<math.h>里面有许多关于数学的函数。打个比方，你要做一个事情，你可以把所有工具先准备好，也就是把各个头文件都写出来摆在那里，就算不用也可以摆出来嘛，没什么影响；你也可以只把要用的工具摆出来，这样代码更简洁。至于那个void main是另外的东西这里就不说了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "这。。建议你先看几本基础入门书籍就不会问这种问题了。 不同的.h头文件包含不同的功能函数，实际需要哪些功能就包含对应的头文件。 main()函数前面的int和void表示的是返回值的类型", "referer": "user-0"}]}
{"question": "c语音网络程序中用  recv函数接受数据会遇到不知道对方发送多长数据的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "加一个头部信息，来确定具体该获得具体多长的消息。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "比较省事的方法就是用一些类似libuv、libev等库，直接在回调函数中处理数据，不需要去关心数据到底啥时候来。 或者用select、epoll等来管理套接字。单独开线程接收也可以。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "用多线程吧，把接受单独放一个线程。或者使用套接字的非阻塞模式", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "在独立的线程中等待。另外，如果是tcp的，最好定义一个数据结构，指定长度。因为tcp的流会连续到来，有可能尾巴上有半个包", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "哪位给个答案", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "业务数据加上个包头，在包头中记录数据长度。 接收数据后先解析数据长度，没有接收足长则继续。否则就退出循环。", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "recv 最后参数 用 MSG_PEEK, 可以窥探是否有数据", "referer": "user-0"}]}
{"question": "C语言问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "确实，二楼说得对，把1换成i，我也刚学到这", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你for语句里面判断条件打错了，形成了一个死循环", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "for (i = 1; 1 <= 10; i++)，这句里应该是\"i<=10;\"才对，楼主输入\" 1 <= 10\"这是数字 1 吧。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "1小于等于10，肯定停不下来啊", "referer": "user-0"}]}
{"question": "写了个二叉树的程序不懂哪里错了，有大佬帮忙看看吗", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：#include <iostream> #include <stack> #include <queue> #include <locale.h> using namespace std; typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int CreateBiTree(BiTree &T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         T = NULL;     } else {         T = (BiTree)malloc(sizeof(BiTNode));         T->data = data;         //生成根结点         CreateBiTree(T->lchild);//构造左子树         CreateBiTree(T->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈             stack.pop();             p = p->rchild;          //访问右子树         }     } } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     stack<BiTree> stack;     BiTree p = T;//p是遍历指针     while (p || !stack.empty()) {   //栈不空或者p不空时循环         if (p != NULL) {             stack.push(p);          //存入栈中             p = p->lchild;          //遍历左子树         } else {             p = stack.top();        //退栈，访问根节点             printf(\"%c \",p->data);             stack.pop();             p = p->rchild;          //访问右子树         }     } }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     stack<BiTreePost> stack;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || !stack.empty()) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack.push(BT);             p = p->lchild;         }         while (!stack.empty() && (stack.top())->tag == 'R') {//左右子树访问完毕访问根节点             BT = stack.top();             stack.pop();//退栈             printf(\"%c \",BT->biTree->data);         }         if (!stack.empty()) {//遍历右子树             BT = stack.top();             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     } }  void LevelOrder(BiTree T) {//层次遍历     if (T == NULL) return;     BiTree p = T;     queue<BiTree> queue;//队列     queue.push(p);//根节点入队     while (!queue.empty()) {    //队列不空循环         p = queue.front();      //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         queue.pop();            //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue.push(p->lchild);         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue.push(p->rchild);         }     } } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 神棍日常坑人的回复:把函数内的星号去掉吧 可以请你帮我看看为什么printf（“”%c“”,a[i].data）输出不了吗 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX_SIZE 1024 typedef struct{ \tchar data; \tint weight; \tint parent; \tint lchild; \tint rchild; }Huffnode,*Hufftree; typedef struct stack{ \tint top; \tint elem[MAX_SIZE]; }Stack; void Initstack(Stack *s) { \ts->top=-1; } void push(Stack *s,int e) { \ts->top++; \ts->elem[s->top]=e; } int pop(Stack *s) { \treturn s->elem[s->top--]; } bool isempty(Stack *s) { \tif(s->top==-1) \t\treturn true; \telse \t\treturn false; } void GetHuffmamCode(Hufftree a,int n) { \tint i,j,s1,s2,max,c,p; \tStack s; \tchar ch; \tInitstack(&s); \tprintf(\"输入字符集：\"); \tfor(i=1;i<=n;i++) \t{ \t\tscanf(\"%c\",&a[i].data); \t\tscanf(\"%c\",&ch); \t} \tprintf(\"输入权值：\"); \tfor(i=1;i<=n;i++) \t{ \t\tscanf(\"%d\",&a[i].weight); \t\tscanf(\"%c\",&ch); \t} \tint m=2*n-1; \tfor(i=1;i<=n;i++) \t{ \t\ta[i].parent=0; \t\ta[i].rchild=0; \t\ta[i].lchild=0; \t} \tfor(i=n+1;i<=m;i++) \t{ \t\ta[i].data=NULL; \t\ta[i].weight=0; \t\ta[i].parent=0; \t\ta[i].lchild=0; \t\ta[i].rchild=0; \t} \tfor(i=n+1;i<=m;i++) \t{ \t\tmax=65535; \t\tfor(j=1;j<=i-1;j++) \t\t{ \t\t\tif(a[j].parent==0&&a[j].weight<=max) \t\t\t{ \t\t\t\ts1=j; \t\t\t\tmax=a[j].weight; \t\t\t} \t\t} \t\ta[s1].parent=i; \t\tmax=65535; \t\tfor(j=1;j<=i-1;j++) \t\t{ \t\t\tif(a[j].parent==0&&a[j].weight<=max) \t\t\t{ \t\t\t\ts2=j; \t\t\t\tmax=a[j].weight; \t\t\t} \t\t} \t\ta[s2].parent=i; \t\ta[i].weight=a[s1].weight+a[s2].weight; \t\ta[i].lchild=s1; \t\ta[i].rchild=s2; \t} \tfor(i=1;i<=n;i++) \t{ \t\tc=i; \t\tp=a[i].parent; \t\twhile(p!=0) \t\t{ \t\t\tif(a[p].lchild==c) \t\t\t\tpush(&s,0); \t\t\telse \t\t\t\tpush(&s,1); \t\t\tc=p; \t\t\tp=a[p].parent; \t\t} \t\tprintf(\"%c\\n\",a[i].data); \t\twhile(!isempty(&s)) \t\t\tprintf(\"%d\",pop(&s)); \t\tprintf(\"\\n\"); \t} } int main() { \tHufftree a; \tint n; \tint m; \tprintf(\"输入字符个数：\"); \tscanf(\"%d\",&n); \tm=2*n-1; \ta=(Hufftree)malloc(sizeof(Huffnode)*m); \tGetHuffmamCode(a,n); \treturn 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "把函数内的星号去掉吧", "referer": "user-0"}]}
{"question": "请大家帮忙给弟弟看一下 初学 找不出错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢谢谢，小白难哭了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<math.h> int main() {     float area, L, v, m;     float r = 1.4;     float M = 3.1415;     area = M * r * r;     L = 2 * M * r;     v = (M * r * r * r)*4 / 3;     m = 2 * M * r * r;     printf(\"所以圆的表面积为；%0.4f\\n周长为：%f\\n\", area, L);     printf(\"所以球的体积为：%0.4f\\n表面积为；%f\\n\",v,m);      return 0; } 都是缺少符号导致，建议看回教材", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "float r=1.4; float M=3.1415这两句前面的float可以省略，直接赋值：r=1.4;M=3.1415;", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "v=(M*r*r*r)4/3;这句改:v=(M*r*r*r)*4/3;", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "float area L v m;这句应该是这样的：float area,L,v,m;几个变量之间要有‘，’号。 L=2Mr；这句应该是这样的：L=2*M*r;必须要有‘*’号。 m=2Mr*r;这句同样的：m=2*M*r;", "referer": "user-0"}]}
{"question": "求解决！急！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "n输入完，加if判断，修改如下： int count,i,n;     double grade,total,average;     total = 0;     count = 0;      printf(\"请输入学生数：\");     scanf (\"%d\",&n);     if(n>=1)    {       printf(\"请输入%d个学生的成绩：\",n);       for (i=1;i<=n;i++)       {         scanf (\"%lf\",&grade);         total = total + grade;         if (grade >= 60)            { count++;}       }       average = total/n;       printf (\"平均成绩average = %.1f\\n\",average);       printf (\"及格人数count = %d\\n\",count);    }    else    { printf(\"学生人数输入错误！\");}        return 0;", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if(n==0)    return 0;", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 user-3的回复:你这写的是什么  这个当n=0的时候好像不行", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 UIUI的回复:你的 count 为什么置 0 ?低于60的时候? 因为count是及格人数orz", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "你的 count 为什么置 0 ?低于60的时候?", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "你这写的是什么", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "#include <stdio.h> #include <iostream.h> //---------------------------------------------------------------------------  #pragma argsused int main(int argc, char* argv[]) {     int count,i,n;     double grade,total,average;     total = 0;     count = 0;      printf(\"请输入学生数：\");     scanf (\"%d\",&n);      printf(\"请输入%d个学生的成绩：\",n);     for (i=1;i<=n;i++)       {         scanf (\"%lf\",&grade);         total = total + grade;         if (grade >= 60)            {              count++;            }        }       average = total/n;       printf (\"平均成绩 = %.1f\\n\",average);       printf (\"及格人数 = %d\\n\",count);        return 0; }", "referer": "user-0"}]}
{"question": "我想问一下我的代码哪里不对了，我也找不出错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//if (a=1){     if (a==1){  供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "感谢讲解，一针见血", "referer": "user-0"}]}
{"question": "如何用C语言读取串口数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "搜“serial库”", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#ifndef _COMM_H_  #define _COMM_H_  #define WM_FOUNDCOMM WM_USER+1  //自定义消息WM_FOUNDCOMM,收到该消息表示串口已经找到 #define WM_READCOMM WM_USER+2   //自定义消息WM_READCOMM,收到该消息缓冲区有数据, 可以读取 extern void FindComm();     //申明为外部函数  extern void OpenComm(int nBaud, int nData, int nStop, int nCal); extern void CloseComm(); extern UINT ThreadFunc(LPVOID pParam); //申明全局线程处理函数  extern CString DisplayCString2Hex(CString Data, bool Blank_allow); extern CString DisplayHex2CString(CString Data); extern int ConvertHexC2String(CString str, CByteArray &senddata); extern bool ComIsOK;     //申明为外部变量  extern HANDLE hCom; extern CString strcomname; #endif  #include \"stdafx.h\"  #include \"commassist.h\"  #include \"commassistDlg.h\"  #include \"comm.h\"  char ConvertHexChar(char ch); HANDLE hCom;   //串口句柄  CString strcomname;  //串口名,如\"COM1\"  bool ComIsOK;   //串口打开状态标识,为真表示已打开,否则未打开  //============自动寻找串口函数=================================  //函数功能:通过扫描注册表来找出当前所有物理串口  //输入参数:无  //返回类型:无  //说    明:若搜索成功,则每搜到一个串口便发送消息通知主对话框,并将串口号以WPARAM传递 void FindComm() { \t//枚举当前系统中的串口  \tLONG result = 0; \tHKEY key = NULL; \tresult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, //需要打开的主键的名称  \t\t\"HARDWARE\\\\DEVICEMAP\\\\SERIALCOMM\", //需要打开的子键的名称, 设备串口 \t\t0,      //保留必须设置为0  \t\tKEY_READ,  //安全访问标记也就是权限  \t\t&key);     //得到的将要打开键的句柄当不再需要句柄 \t//必须调用 RegCloseKey 关闭它  \tif (result) \t{ \t\tAfxMessageBox(\"无法获取串口请确认是否安装并连接串口!\"); return; \t} \tTCHAR portname[250];     //串口名  \tTCHAR data[250]; \tDWORD portnamelen = 0;     //串口名长度  \tDWORD datalen = 0; \tint index = 0; \twhile (1)    //找完COM后跳出  \t{ \t\tportnamelen = 255; \t\tdatalen = 255; \t\tresult = RegEnumValue(key,   //Long一个已打开项的句柄或者指定一个标准项名 \t\t\tindex++,   //Long欲获取值的索引。注意第一个值的索引编号为零 \t\t\tportname,  //String用于装载位于指定索引处值名的一个缓冲区 \t\t\t&portnamelen, //Long用于装载lpValueName缓冲区长度的一个变量。 \t\t\t//一旦返回它会设为实际载入缓冲区的字符数量 \t\t\tNULL,   //Long未用设为零  \t\t\tNULL,   //Long用于装载值的类型代码的变量  \t\t\t(LPBYTE)data, //Byte用于装载值数据的一个缓冲区   \t\t\t&datalen);  //Long用于装载lpData缓冲区长度的一个变量。 \t\t//一旦返回它会设为实际载入缓冲区的字符数量 \t\tif (result)  break; \t\t//发送消息,WM_USER+1为自定义消息,即找到串口的,并将串口号\"COMx\"通过WPARAM参数传送给主对话框窗口 \t\t//::AfxGetMainWnd()->m_hWnd,获得主对话框句柄  \t\t//(WPARAM)(LPCTSTR)data,类型转换   \t\t::SendMessage(::AfxGetMainWnd()->m_hWnd, WM_FOUNDCOMM, (WPARAM)(LPCTSTR)data, 0); \t} \tRegCloseKey(key);      //调用 RegCloseKey 关闭打开键的句柄  } //============自动寻找串口函数结束==================   //==========串口打开函数===========================  //功    能:打开串口,将已打开的串口句柄赋值给hCom,给出串口打开状态ComIsOK,完成串 //输入参数:波特率,数据位,停止位,校验位  //返回类型:无  void OpenComm(int nBaud, int nData, int nStop, int nCal) { \thCom = CreateFile(strcomname,   //串口号  \t\tGENERIC_READ | GENERIC_WRITE,  //允许读或写  \t\t0,         //独占方式  \t\tNULL, \t\tOPEN_EXISTING,      //打开而不是创建  \t\tFILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,//重叠方式,用于异步通信 \t\tNULL);  \tif (hCom == INVALID_HANDLE_VALUE) \t{ \t\tAfxMessageBox(\"打开COM失败串口不存在或已被占用!\"); \t\tComIsOK = false; \t\treturn; \t} \tComIsOK = true; \tSetCommMask(hCom, EV_TXEMPTY | EV_RXCHAR);  //设置事件掩码,暂时没用上 \tSetupComm(hCom, 1024, 1024);  //设置输入缓冲区和输出缓冲区的大小都是1024  \tCOMMTIMEOUTS TimeOuts; \t//设定读超时  \tTimeOuts.ReadIntervalTimeout = MAXDWORD; \tTimeOuts.ReadTotalTimeoutConstant = 0; \tTimeOuts.ReadTotalTimeoutMultiplier = 0; \t//设定写超时  \tTimeOuts.WriteTotalTimeoutConstant = 500; \tTimeOuts.WriteTotalTimeoutMultiplier = 100; \tif (SetCommTimeouts(hCom, &TimeOuts) == false) \t{ \t\tCloseHandle(hCom); \t\tComIsOK = false; \t\treturn; \t} \t//串口属性配置  \tDCB dcb; \tGetCommState(hCom, &dcb); \tdcb.BaudRate = nBaud; //dcb.BaudRate=9600; //波特率为9600  \tdcb.ByteSize = nData; //dcb.ByteSize=8; //每个字节为8位  \tdcb.StopBits = nStop; //dcb.StopBits=ONESTOPBIT;   //1位停止位  \tdcb.Parity = nCal; //dcb.Parity=NOPARITY; //无奇偶检验位  第 18 页 共 39 页    \tSetCommState(hCom, &dcb); \tPurgeComm(hCom, PURGE_TXCLEAR | PURGE_RXCLEAR); \tif (SetCommState(hCom, &dcb) == false) \t{ \t\tCloseHandle(hCom); \t\tComIsOK = false; \t\treturn; \t} \treturn; } //==========串口打开函数结束=====================    //==========串口关闭控制函数=====================  void CloseComm() { \tCloseHandle(hCom); \thCom = NULL; \tComIsOK = false; } //==========串口关闭控制函数结束==================   //==========串口监听线程函数======================  UINT ThreadFunc(LPVOID pParam) { \t// CCommassistDlg* pdlg = (CCommassistDlg*)pParam;  //定义指针指向主对话框  \tCOMSTAT ComStat; \tDWORD dwErrorFlags; \twhile (ComIsOK) \t{ \t\tDWORD dwBytesRead = 100; \t\tClearCommError(hCom, &dwErrorFlags, &ComStat); \t\tdwBytesRead = min(dwBytesRead, (DWORD)ComStat.cbInQue); \t\tif (!dwBytesRead) \t\t{ \t\t\tSleep(10);//continue;//使用continue时打开串口后CPU占用率非常高  \t\t} \t\telse ::SendMessage(::AfxGetMainWnd()->m_hWnd, WM_READCOMM, 1, 0); //发 送消息, 已读到 \t} \treturn 0; } //==========串口监听线程函数结束===============  //=================字符串转16进制显示==========  //字符串转16进制显示的函数  //传入参数Data为字符串  //Blank_allow为空格允许标志,为真则代表允许加入空格  //函数返回为CString的结果sResult  CString DisplayCString2Hex(CString Data, bool Blank_allow) { \tCString sResult; \tCString sTemp; \tint Data_Length; \tData_Length = Data.GetLength(); \tif (Data_Length == 0) return \"\"; \tchar *pchar = new char[Data_Length];  //用了new分配内存空间,要记得释放  \tstrncpy(pchar, Data, Data_Length); \tfor (int i = 0; i<Data_Length; i++) \t{ \t\tsTemp.Format(\"%02X\", pchar[i]); \t\tif (Blank_allow) \t\t{ \t\t\tif (i == Data_Length - 1) sResult = sResult + sTemp; //去掉最后一个空格  \t\t\telse \t\t\t\tsResult = sResult + sTemp + \" \"; \t\t} \t\telse sResult = sResult + sTemp; \t} \tdelete pchar;   //释放内存空间  \treturn sResult; } //===============函数结束============================   //=================16进制转字符串======================  //16进制转字符串,输入16进制的字符串,输出转换为16进制码  //传入参数str为字符串,判断输入是否按照16进制格式输入  int ConvertHexC2String(CString str, CByteArray &senddata) { \t//先判断输入字符串是否2个字符一组  \tint str_Length, iLength; \tint hexdata, l_data; \tchar hstr, lstr; \tchar cTemp; \tstr_Length = str.GetLength(); \tiLength = 0; \tsenddata.SetSize(str_Length / 2);  //预先设置数组长度,不设置时,允许有错  \tchar *ppchar = new char[str_Length]; \tstrncpy(ppchar, str, str_Length); \tfor (int i = 0; i<str_Length;) \t{ \t\tcTemp = ppchar[i]; \t\tif (cTemp == ' ') \t\t{ \t\t\t//iLength--;  \t\t\ti++; \t\t\tcontinue; //如检测到空格则跳过继续下一次循环  \t\t} \t\telse \t\t{ \t\t\thstr = ppchar[i];  //取出字符作为16进制高位  \t\t\ti++; \t\t\tlstr = ppchar[i];  //取出下一个字符作为16进制低位  \t\t\tif (lstr == ' ')   //若取出的低位为空格则不符合16进制2个一组的格式终止循环 \t\t\t{ \t\t\t\tAfxMessageBox(\"请按照16进制每2个字符一组的方式输入\",MB_ICONERROR);  \t\t\t\tbreak; \t\t\t} \t\t\telse \t\t\t{ \t\t\t\thexdata = ConvertHexChar(hstr);  //高位转换为相应的0进制  \t\t\t\tl_data = ConvertHexChar(lstr);  //低位转换为相应的10进制  \t\t\t\tif ((hexdata == -1) || (l_data == -1)) \t\t\t\t{ \t\t\t\t\tAfxMessageBox(\"请按照16进制字符要求输入\", MB_ICONERROR); \t\t\t\t\tbreak; \t\t\t\t} \t\t\t\telse hexdata = hexdata * 16 + l_data; //安装16进制方式高位低位合并   \t\t\t\tsenddata[iLength] = (char)hexdata; //int整型数转换为char字符型并存入数组senddata[] \t\t\t\ti++; //进入下一次循环  \t\t\t\tiLength++; //成功转换一组(2个)字符记录长度加1  \t\t\t} \t\t} \t} \tsenddata.SetSize(iLength); \tdelete ppchar; \treturn iLength; }  //===============函数结束===========================   char ConvertHexChar(char ch) { \t//将一个字符转换为相应的十六进制  \tif ((ch >= '0') && (ch <= '9')) \t\treturn ch - 48;//0x30;  \telse if ((ch >= 'A') && (ch <= 'F')) \t\treturn ch - 'A' + 10; \telse if ((ch >= 'a') && (ch <= 'f')) \t\treturn ch - 'a' + 10; \telse \t\treturn (-1); }   //=================16进制转字符串显示=====================  //16进制转字符串显示的函数  //传入参数Data为16进制的字符串  //函数返回为CString的结果sResult  CString DisplayHex2CString(CString Data) { \tCString sResult; \tCString sTemp; \tint Data_Length; \tData_Length = Data.GetLength(); \tif (Data_Length == 0) return \"\"; \tchar *pchar = new char[Data_Length];  //用了new分配内存空间,要记得释放  \tstrncpy(pchar, Data, Data_Length); \tfor (int i = 0; i<Data_Length; i++) \t{ \t\tsTemp.Format(\"%02X\", pchar[i]); \t\tsResult = sResult + sTemp; \t} \tdelete pchar;   //释放内存空间  \treturn sResult; } //===============函数结束=============================", "referer": "user-0"}]}
{"question": "小白问大家几个问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 UIUI的回复:你定义的数组大小是 n-1 那么, 你循环读入的 最大下标应该为 n-1-1; 你读入n-1 个,当然有问题. 不知道你是什么编译器. 这个 int number[n-1];  怎么也编译能通过..... 确实是这样，对数组大小理解错了，感谢 至于编译器为什么能通过我也不知道", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "你定义的数组大小是 n-1 那么, 你循环读入的 最大下标应该为 n-1-1; 你读入n-1 个,当然有问题. 不知道你是什么编译器. 这个 int number[n-1];  怎么也编译能通过.....", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "第一个for循环后的那个scanf是多余的", "referer": "user-0"}]}
{"question": "输入单词输出单词字母数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "感觉可以考虑用getchar()和while循环，每getchar一次i+1,遇到空格时打印i，然后重置i。（我也是新手，共勉）", "referer": "user-0"}]}
{"question": "我想问一下我错哪了，我没看出来，求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h>  int main() {     /*        题目名称：符合条件自然数         题目描述：编写程序，打印所有小于正整数data且可被11整除的自然数。           输入：从键盘输入一个正整数data         输出：输出所有小于data且可被11整除的自然数，数与数之间以一个空格做间隔，最后一个数后无多余字符。        */      /*     int a,i,c;      scanf(\"%d\", &a);      //for(i=1;i<a-1;i++) {     for(i=1; i < a; i++) {          if (i%11==0)              printf(\"%d\",i);          printf(\" \") ;     }         c=i;         c=c%11;         if (c==0)         printf(\"%d\",c);         else        */     int data, i;      scanf(\"%d\", &data);      for (i = 0; i < data; i++) {         if (i % 11 == 0) {             if (i != 0)                 printf(\" \");             printf(\"%d\", i);         }     }     return 0;  } 供参考～  自然数应该是从0开始的吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "小于正整数a 你的for循环for(i=1;i<a-1;i++){ 却是小于a-1的  举个例子 输入111  最后一个数本来是110  你的循环就少了110了  改一下：for(i=1;i<a;i++){", "referer": "user-0"}]}
{"question": "提领指向不完全类型指针", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢。 感谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "链表的定义有问题  改一下 typedef struct queNode_c{ char data; struct queNode* next;  // struct queNode* last; } queNode;  这种用typedef定义的结构体相当于以下效果： struct queNode_c{ char data; struct queNode* next;  // 此时 queNode还没有定义呢 你用这个  编译器认识这是哪个啊  struct queNode* last; }  typedef queNode_c queNode； 改成以下的： typedef struct queNode_c{ char data; struct queNode_c* next;   struct queNode_c* last; } queNode;", "referer": "user-0"}]}
{"question": "求助求助，急急急，怎么写，大神帮帮忙，求这个程序补充内容", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "示例：// //  // /*  *  栈操作  * */ #include <stdio.h> #include <stdlib.h> #define  N 50 栈大小 //结构体 栈 typedef struct stack {     int top; //栈顶位置     int data[N]; //数据 } STACK; //是否为空 int isEmpty(STACK * stack) {     if(stack->top == -1)     {         return 1;     }     return 0; } //是否已满 int isFull(STACK * stack) {     if(stack->top == N-1)     {         return 1;     }     return 0; }  //设为空 void setEmpty(STACK * stack) {     stack->top = -1; } //压栈 int push(STACK * stack, int data) {     if(isFull(stack))     {         printf(\"栈已满\\n\");         return -1;     }     stack->top += 1;     stack->data[stack->top] = data;  } //弹栈 int pop(STACK * stack) {     if(isEmpty(stack))     {         printf(\"栈已空\");         return -1;     }     int num = stack->data[stack->top];     stack->top -= 1;     //printf(\"top=%d\\n\",stack->top);     return num;  } void test() {     printf(\"栈结构体类型大小:%d\\n\",sizeof(STACK));     printf(\"分配内存，并初始化:\\n\");     STACK * stack = (STACK *)calloc(1,sizeof(STACK)); //calloc分配内存： 元素个数 元素大小     if(stack == NULL)     {         printf(\"内存分配失败\\n\");         return;     }     printf(\"内存分配成功,地址为:%p\\n\",stack);     setEmpty(stack);     //压栈     for(int i = 0; i < N; i++)     {         printf(\"压入数据:%d\\n\",i);         push(stack,i);     }     //弹栈    while (!isEmpty(stack))    {        printf(\"弹栈:%d\\n\",pop(stack));    }     //释放内存     free(stack);  }  int main1(int agc, char * argv[]) {      test();     return 0; }", "referer": "user-0"}]}
{"question": "求助大佬", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这是按你的代码改的，运行如下图： 程序代码：int ss(int x){    int f=1;    if(x<=1) f=0; //小于等于1的数都没有素数    if(x==2) f=1; //数字2只有1和2两个因数，因而必定是素数    for(int i=2;i<x;i++)//从2到x-1都无法被x整除，x是素数         if(x%i==0) f=0;    return f; }  int main(int argc, char* argv[]) {     int M,N,count=0,sum=0;     printf(\"请输入给定区间整数M和N(1≤M≤N≤1000)：\");     scanf(\"%d %d\",&M,&N);     if(M>=1&&M<=N&&N<=1000)         {          for(int j=M;j<=N;j++)            {if(ss(j)==1)                 {count++;                  sum+=j;                  printf(\"   %d   \",j);                  if(count%5==0)                  printf(\"\\n\");                 }            }         printf(\"\\namount=%d sum=%d\",count,sum);        }     else printf(\"输入给定区间整数M和N错误！\");     cin>>M;     return 0;  }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <math.h> int Judge(int i); int main() { \tint m,n; \tint i,j,z = 0; \tint sum = 0; \tprintf(\"请输入区间范围: \"); \tscanf(\"%d %d\",&m,&n); \tfor(i = m;i <= n;i ++) \t{ \t\tj = Judge(i); \t\tif(j == 1) \t\t{ \t\t\tprintf(\"%d \",i); \t\t\tz ++; \t\t\tif(z % 5 == 0) \t\t\t{ \t\t\t\tprintf(\"\\n\"); \t\t\t} \t\t\tsum += i; \t\t} \t } \t printf(\"\\namount = %d sum = %d\",z,sum);  \treturn 0; } int Judge(int b) { \tint i,a; \tif(b == 1) \t{ \t\treturn 0; \t} \ta = (int)sqrt(b);//因为如果一个数可以被别的数整除那那个数和商在开平方的值的两侧，所以求一半就可以了  \tfor(i = 2;i <= a;i ++) \t{ \t\tif(b % i == 0) \t\t{ \t\t\treturn 0; \t\t} \t} \treturn 1; }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include <stdio.h> #include <math.h>  //int ss(int x) int is_prime(int x) {     if (x < 2)         return 0;      //int f = 1;     int i;     for(i=2;i<x;i++)     {         if(x%i==0) {             //f=0;             break;         }     }     if (i < x)         return 0;     else         return 1;      //return f; } int main() {     int M,N,count=0,sum=0;     scanf(\"%d %d\",&M,&N);     if (M < 1 || N < M || N > 1000)         return -1;     //if(M>=1&&M<=N&&N<=1000)     //{         for(int j=M;j<=N;j++)         {             if(is_prime(j)==1)             {                 count++;                 if(count%5==1&&count>1)                     printf(\"\\n\");                 printf(\"%d \",j);                 sum+=j;             }         }         printf(\"\\namount=%d sum=%d\",count,sum);     //}     //else return 0;     return 0; }  供参考～  楼主的素数判断有问题，楼主判断逻辑里1也是素数了。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 6 楼 qzjhjxj 的回复:[quote=引用 5 楼 user-4 的回复:]#include <stdio.h> #include <math.h> int ss(int x) {    int f = 1;    if (x <= 2)         return 0;    for (int i = 2; i < x; i++)    {       if (x % i == 0)          f = 0;    }    return f; } int main() {    int M, N, count = 0, sum = 0;    scanf(\"%d %d\", &M, &N);    if (M >= 1 && M <= N && N <= 1000)    {       for (int j = M; j <= N; j++)       {          if (ss(j))          {             count++;             printf(\"%d \", j);             sum += j;             if (count % 5 == 0)             {                printf(\"\\n\");             }          }       }       printf(\"\\namount=%d sum=%d\", count, sum);    }    else       return 0; } 楼上的第六句把2排除在外了，2是素数。[/quote]  可能我记错了吧", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 5 楼 user-4 的回复:#include <stdio.h> #include <math.h> int ss(int x) {    int f = 1;    if (x <= 2)         return 0;    for (int i = 2; i < x; i++)    {       if (x % i == 0)          f = 0;    }    return f; } int main() {    int M, N, count = 0, sum = 0;    scanf(\"%d %d\", &M, &N);    if (M >= 1 && M <= N && N <= 1000)    {       for (int j = M; j <= N; j++)       {          if (ss(j))          {             count++;             printf(\"%d \", j);             sum += j;             if (count % 5 == 0)             {                printf(\"\\n\");             }          }       }       printf(\"\\namount=%d sum=%d\", count, sum);    }    else       return 0; } 楼上的第六句把2排除在外了，2是素数。", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "#include <stdio.h> #include <math.h> int ss(int x) {    int f = 1;    if (x <= 2)       return 0;    for (int i = 2; i < x; i++)    {       if (x % i == 0)          f = 0;    }    return f; } int main() {    int M, N, count = 0, sum = 0;    scanf(\"%d %d\", &M, &N);    if (M >= 1 && M <= N && N <= 1000)    {       for (int j = M; j <= N; j++)       {          if (ss(j))          {             count++;             printf(\"%d \", j);             sum += j;             if (count % 5 == 0)             {                printf(\"\\n\");             }          }       }       printf(\"\\namount=%d sum=%d\", count, sum);    }    else       return 0; }", "referer": "user-0"}]}
{"question": "为什么会这样，free到底干了什么", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "free是针对malloc/realloc等在堆上申请空间的释放用的。用于标记申请的空间可以再次被申请了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int main() {     int *p;     printf(\"%p %d\\n\",p,*p); //此时p未初始化 称之为野指针  也就是p本身地址未知->00400080  p指向的地址未知->17744     *p = 5;   //p本身的地址未知，那么你可能无法将p指向其他地址 因为此时p本身的地址你可能无权限访问       p=(int *)malloc(sizeof(int));  //此时给p初始化了  p的地址为0x55e5857e22a0     *p=5; //此时你可以将p指针指向其地址了 p =0x55e5857e22a0     *p=5     printf(\"%p %d\\n\",p,*p);       free(p); //free是释放p指向的地址  此时p=0x55e5857e22a0  *p=0     *p=6;  //将p指向另外一个地址 此时p=0x55e5857e22a0  *p=6       printf(\"%p %d\\n\",p,*p);//总结以下：free是释放p指向的地址 p指针本身的地址是不变的 所以如果你要释放一个地址，最好如下写：     free(p);     p = NULL;//只释放地址，本身地址不为null的指针叫迷途指针 在大的程序中很可能会出问题       return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "引用 楼主 学码就是爱好 的回复:但是下面程序释放了申请了内存为什么*P还会被赋值6？ #include <stdio.h> #include<malloc.h> int main() {     int *p;     p=(int *)malloc(sizeof(int));     *p=5;     printf(\"%p %d\\n\",p,*p);      free(p);     *p=6;      printf(\"%p %d\\n\",p,*p);      return 0; }  0x55e5857e22a0 5 0x55e5857e22a0 6 #include <stdio.h> #include <malloc.h> int main(void) {     int *p;     p=(int *)malloc(sizeof(int));     *p=5;     printf(\"%p %d\\n\",p,*p);      free(p); //这句执行后p就成为野指针，p指向的内存被释放，不归你程序所有     *p=6; //这句是非法访问      //如果在这里插入其他函数调用，你再试试     {        p=(int *)malloc(sizeof(int));        *p=5;        free(p);     }      printf(\"%p %d\\n\",p,*p);      return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "释放内存就是设置一个flag，告诉系统这块内存已经不用了，系统可以把这块内存拿给其他程序使用，但是系统不一定马上会把它分配给其它程序（要看其它程序malloc时是否刚好分配到这块内存），一时半会这块内存属于自由状态，所以继续使用该内存可能不会出错，相当于没有申请内存所有权就强行侵占内存使用。所以*p=6就属于这种行为，一时半会可能不会出错。如果该内存被其他程序分配申请使用权了，那*p=6可能就会报内存非法访问错误了。", "referer": "user-0"}]}
{"question": "求大佬帮忙看看新人打的代码哪里有问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "试试把0排除后的结果吧，除了0，其他的我就不知道了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 11 楼 神棍日常坑人的回复:[quote=引用 10 楼 NGUforever 的回复:] 我换了啊 不知道你们有没有啥特别的数据实例没有，代码肯定是没问题的，只是说没有对输入的数据进行判断处理[/quote] 这学校的破oj不给我们下实验数据，我自己用你的代码试了好几组都没问题，我甚至怀疑是不是oj有问题。。。。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 10 楼 NGUforever 的回复:我换了啊 不知道你们有没有啥特别的数据实例没有，代码肯定是没问题的，只是说没有对输入的数据进行判断处理", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 9 楼 神棍日常坑人的回复:[quote=引用 7 楼 NGUforever 的回复:]emmmm，我试了试你的，但是系统说答案错误。。。 把输出的bs和ys交换一下位置，bs代表最小公倍数，ys代表最大公约数  注释等于白写了[/quote] 我换了啊", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 7 楼 NGUforever 的回复:emmmm，我试了试你的，但是系统说答案错误。。。 把输出的bs和ys交换一下位置，bs代表最小公倍数，ys代表最大公约数  注释等于白写了", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "好的，感谢大佬帮忙", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "恳求大佬帮忙吧，就算没找到错给个参考例子也行，如果过了的话我就立马结帖", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "emmmm，我试了试你的，但是系统说答案错误。。。", "referer": "user-0"}, {"cid": "9", "user": "user-1", "content": "引用 楼主 NGUforever 的回复:题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf (\"%d%d\",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf (\"%d %d\\n\",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "写一段给你参考一下吧，也可以用for循环暴力破解，感觉超时可能就是你用的两个while的原因  #include<stdio.h> int main(){ \tint m, n, temp, bs, ys; \tscanf (\"%d %d\", &m, &n); \t//判断 m 、 n 的大小，大的给 m ，小的给 n \tif(m < n){ \t\ttemp = n; \t\tn = m;  \t\tm = temp; \t} \t//将最小公倍 bs 数暂定为 m 与 n 的乘积 \tbs = m * n; \t//使用取余的方法求最大公因数 ys \twhile(1){ \t\tif(m % n == 0) \t\t\tbreak; \t\ttemp = m % n; \t\tm = n; \t\tn = temp; \t}; \tys = n; \t//将 m 与 n 的乘积除以最大公因数 ys 得最小公倍数 bs \tbs /= ys; \tprintf(\"%d %d\\n\", bs, ys); \treturn 0; }", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 4 楼 神棍日常坑人的回复:[quote=引用 3 楼 NGUforever 的回复:][quote=引用 2 楼 神棍日常坑人 的回复:][quote=引用 楼主 NGUforever 的回复:]题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf (\"%d%d\",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf (\"%d %d\\n\",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行[/quote] emmmm,编译器显示会运行while里的东西啊，是我理解错大佬的意思了吗[/quote] 我说反了，是对的，运行超时没看出来，不过你的代码思路确实挺复杂的[/quote] 好吧，谢谢大佬帮忙", "referer": "user-0"}, {"cid": "12", "user": "user-1", "content": "引用 3 楼 NGUforever 的回复:[quote=引用 2 楼 神棍日常坑人 的回复:][quote=引用 楼主 NGUforever 的回复:]题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf (\"%d%d\",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf (\"%d %d\\n\",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行[/quote] emmmm,编译器显示会运行while里的东西啊，是我理解错大佬的意思了吗[/quote] 我说反了，是对的，运行超时没看出来，不过你的代码思路确实挺复杂的", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "引用 2 楼 神棍日常坑人 的回复:[quote=引用 楼主 NGUforever 的回复:]题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf (\"%d%d\",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf (\"%d %d\\n\",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行[/quote] emmmm,编译器显示会运行while里的东西啊，是我理解错大佬的意思了吗", "referer": "user-0"}, {"cid": "14", "user": "user-0", "content": "题目描述 问题描述： 已知整数a、b、c。你的任务是求出区间[a,b]内的整数，满足该数与“该数的所有因数（不包括本身但包括1,1的因数和按0处理）相加之和”的差的绝对值小于等于c的数字。例如27的因数是1、3、9。那么27与27的所有因数和的差为:27-(1+3+9)=14。  输入与输出要求： 输入三个整数a、b、c。a、b代表所求区间范围，满足1<=a<=b<=10000，c代表限制条件，c>=0。输出满足条件的整数，每五个数为一行，整数之间用tab分隔，最后一个数后为换行符。当该区间没有符合条件的整数时，输出“There is no proper number in the interval.”  程序运行效果： Sample 1： 输入：1 10000 0 输出：6          28        496       8128 Sample 2： 输入：2000 5000 4 输出：2048    2144     4030     4096 Sample 3： 输入：900 1000 0 输出：There is no proper number in the interval. 我的代码： #include <stdio.h> #include <math.h> int main () {    int a,b,c,ans,i1,i2,d,e,flag,flag1;    i2=c=d=flag=flag1=1;    i1=2;    e=1;     scanf (\"%d%d%d\",&a,&b,&c);     ans=a;     while (ans<=b)     {         i1=2;         e=1;         if ((ans==1&&b==1)&&(c!=0))                 {ans=ans+1;                 printf (\"1\");                 flag1=0;}         if (ans==1)             ans=ans+2;         while (i1<ans&&flag1==1)         {             if (ans%i1==0)                 {d=ans/i1;                 e=e+d;}             i1=i1+1;         }         if (fabs(e-ans)<=c&&flag1==1)         {             printf (\"%d\\t\",ans);             flag=0;         }         ans=ans+1;     }     if (flag==1&&flag1==1)     {printf (\"There is no proper number in the interval.\");}     printf (\"\\n\");     return 0; } 这一题我每次提交都显示答案错误，哭了，试了好多例子都没问题啊ORZ，如果大佬有空的话可以顺带把这题也解答一下吗，拜托您了", "referer": "user-0"}]}
{"question": "时间超限", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：while ((order = getchar()) == '\\n') ; 改成这样试试 注意while末尾有分号，即getchar()得到的是'\\n'则继续循环，否则退出～我懂了，是因为输入格式是 “数字 数字” 命令：ABCD...但是外面那个循环扫描不到EOF", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复：while ((order = getchar()) == '\\n') ; 改成这样试试 注意while末尾有分号，即getchar()得到的是'\\n'则继续循环，否则退出～在这里order是命令，就是ABCDEF是不同的命令，花括号里是根据不同的命令做出不同的指令，如果加上分号的话，{｝里就没有用了，可能是我没把题目说清楚。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "while ((order = getchar()) == '\\n') ; 改成这样试试 注意while末尾有分号，即getchar()得到的是'\\n'则继续循环，否则退出～", "referer": "user-0"}]}
{"question": "计算机小白想要通过OJ作业", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <math.h>  int main() {     int a, b, c;     int sum = 0;     int count = 0;     int sure = 0;      scanf(\"%d %d %d\", &a, &b, &c);     for(int i = a; i <= b; i++)     {         sum = 0;         for(int k = 1; k < i; k++)         {             if(i % k == 0)             {                 sum = sum + k;             }         }         if(fabs(i - sum)<= c)         {             sure = 1;             count++;             if(count != 0 && (count % 5) == 0)             {                 printf(\"%d\\n\",i);                 count = 0;             }             else             {                 printf(\"%d\\t\",i);             }          }      }     if(sure == 0)         printf(\"There is no proper number in the interval.\\n\");      return 0; } 给个样例给你，你看不懂的话问我就行。", "referer": "user-0"}]}
{"question": "Time Limit Exceeded Length", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h>  //void sort(int s[]) void sort(int s[], int len) {     int t;     //for(int i=0;s[i]!='\\0';i++)     for(int i=0; i < len;i++)         //for(int j=i+1;s[j]!='\\0';j++)         for(int j=i+1; j < len;j++)             if(s[i]<s[j])             {                 t=s[i];                 s[i]=s[j];                 s[j]=t;             } }  int main() {     int n,m;     int a[3005],b[1005];     while(scanf(\"%d %d\",&n,&m)!=EOF)     {         for(int i=0;i<n;i++)             scanf(\"%d\",&a[i]);         int k=0;         for(int i=0;i<n;i++)             for(int j=i+1;j<n;j++){                 b[k]=a[i]+a[j];                 k++;             }         //sort(b);         sort(b, k);         for(int i=0;i<m;i++)             printf(\"%d \",b[i]);         printf(\"\\n\");     } } 供参考～  楼主是不是搞混了，'\\0'是字符串的结束标记，不是int整型数的结束", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "不过还是超时啊", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include<stdio.h>  //void sort(int s[]) void sort(int s[], int len) {     int t;     //for(int i=0;s[i]!='\\0';i++)     for(int i=0; i < len;i++)         //for(int j=i+1;s[j]!='\\0';j++)         for(int j=i+1; j < len;j++)             if(s[i]<s[j])             {                 t=s[i];                 s[i]=s[j];                 s[j]=t;             } }  int main() {     int n,m;     int a[3005],b[1005];     while(scanf(\"%d %d\",&n,&m)!=EOF)     {         for(int i=0;i<n;i++)             scanf(\"%d\",&a[i]);         int k=0;         for(int i=0;i<n;i++)             for(int j=i+1;j<n;j++){                 b[k]=a[i]+a[j];                 k++;             }         //sort(b);         sort(b, k);         for(int i=0;i<m;i++)             printf(\"%d \",b[i]);         printf(\"\\n\");     } } 供参考～  楼主是不是搞混了，'\\0'是字符串的结束标记，不是int整型数的结束 是了 谢谢 昨天我也考虑到了是这个位置出了问题，但最后改来改去的把自己搞懵了", "referer": "user-0"}]}
{"question": "c语言初学者求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我会了，谢谢大家", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把scanf改成scanf_s吧，其他不变；建议楼主从网上搜一下scanf_s的用法，尤其是对%s, %c等需要增加参数～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "微软的编译器现在那么霸道了？竟然是错误而不是警告？ 代码本身没问题，编译器让它有问题 看错误提示是，scanf被认为是不安全的（有内存越界的可能），所以编译器推荐你用scanf_s 其实用scanf_s反而还不利于移植，所以可以define一下_CRT_SECURE_NO_WARNNINGS 宏来忽略该错误提示", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "谢谢了，我试试", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "一般不同编译器99%的语法都是按照标准来的，当然不同编译器之间 也会有略微的不同。就像这个scanf函数，可能在别的编译器没有错误，但是到了微软的编译器里面，必须得用微软提供的“安全”的scanf_s函数才行。不过一般没有什么太大的错误 遇到了看一下错误提示小改一下就行", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 5 楼 user-3的回复:错误提示显示 scanf函数是不安全的 楼主可以试试下面这段代码 应该可以解决你的问题 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h>  int max(int a, int b) { \tif (a > b) return a; \telse return b; }  int main() { \tint x, y,z; \tprintf(\"请输入两个整数：\"); \tscanf(\"%d %d\", &x, &y); \tz = max(x, y); \tprintf(\"max=%d\\n\", z); \treturn 0; } 代码仅供参考 谢谢了，这个我在书上没第一行就成功了，为什么实际操作就有了问题，这是编译器的问题？", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "错误提示显示 scanf函数是不安全的 楼主可以试试下面这段代码 应该可以解决你的问题 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h>  int max(int a, int b) { \tif (a > b) return a; \telse return b; }  int main() { \tint x, y,z; \tprintf(\"请输入两个整数：\"); \tscanf(\"%d %d\", &x, &y); \tz = max(x, y); \tprintf(\"max=%d\\n\", z); \treturn 0; } 代码仅供参考", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:把scanf改成scanf_s吧，其他不变；建议楼主从网上搜一下scanf_s的用法，尤其是对%s, %c等需要增加参数～ 行，我找找谢谢了", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 1 楼 qybao的回复:微软的编译器现在那么霸道了？竟然是错误而不是警告？ 代码本身没问题，编译器让它有问题 看错误提示是，scanf被认为是不安全的（有内存越界的可能），所以编译器推荐你用scanf_s 其实用scanf_s反而还不利于移植，所以可以define一下_CRT_SECURE_NO_WARNNINGS 宏来忽略该错误提示 这个代码加在哪里？我打了scanf_s调试时就成了空白", "referer": "user-0"}]}
{"question": "while和switch", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "少了break", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "对于switch里的case语句后，你需要根据你的意图添加break语句来跳出当前的循环，否则系统就会默认为顺序向下执行", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "楼主的switch中缺少break;如果在每个case后面加一个break;则会输出: fat hat cat 试试加上break;  不加break;则会顺序执行～第一次从0开始一次执行case 1, case 2, default，第二次从case 1执行，执行case 1, case 2, default以此类推～", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "没有break; case语句最后如果有break就跟你想的一样了", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "加break", "referer": "user-0"}, {"cid": "6", "user": "user-6", "content": "case 0:printf_s(\"fat \");break; case 1:printf_s(\"hat \");break; case 2:printf_s(\"cat \");break; default:printf_s(\"oh no!\");break; 你少了break", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "我的理解是 分别打印3行 fat hat cat", "referer": "user-0"}]}
{"question": "将第一个字母变成第26个字母，第i个字母变成第（26-i+1）个字母", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢，问题解决了，谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把最后一个else if删掉 没必要 其他看起来没问题，不要用ASCII值计算用字母代替  容易理解", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "对于大小写，不同的操作这个是正确的。 //大写 b[i] = 26 - (a[i] - 'A') + 'A'; //小写 b[i] = 26 - (a[i] - 'a') + 'a'; 试试～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 楼主 clear1over 的回复:有大佬帮忙看一下这个问题出在哪了吗？ 你这编译不通过吧？ 第二个else if没有构成完整的语句，也就是那后面啥都没接，你可以加个分号，表示空语句。 另外，你代码里最好还是不要直接用90、65等数字，用'Z'、'A'、'z'、'a'，这些字符本质上就是数字，用它用数字效果一样，还不如就用字符", "referer": "user-0"}]}
{"question": "一个小白想要通过OJ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢各位啦！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 2 楼 自信男孩 的回复:[quote=引用 1 楼 5250 的回复:]#include <stdio.h> #include <string.h>  int main() {    char num[10];    memset(num, -1, sizeof(char) * 10);    scanf(\"%s\", num);    for (int i = 0; i < 10; i++)    {       if (num[i] != -1)          printf(\"%c \", num[i]);    }    printf(\"\\n\");    return 0; }  供参考  这个程序，可以这么做： for (int i = 0; i < strlen(num); i++)[/quote]  谢谢", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h>    void print_digit(unsigned long num);  int main(void) {     unsigned long num;      scanf(\"%lu\", &num);       print_digit(num);     putchar(10);      return 0; }  void print_digit(unsigned long num) {     if (num == 0)         return;      print_digit(num / 10);     printf(\"%lu \", num % 10); }  供参考～  可以考虑使用递归函数，如上～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 1 楼 5250 的回复:#include <stdio.h> #include <string.h>  int main() {    char num[10];    memset(num, -1, sizeof(char) * 10);    scanf(\"%s\", num);    for (int i = 0; i < 10; i++)    {       if (num[i] != -1)          printf(\"%c \", num[i]);    }    printf(\"\\n\");    return 0; }  供参考  这个程序，可以这么做： for (int i = 0; i < strlen(num); i++)", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "#include <stdio.h> #include <string.h>  int main() {    char num[10];    memset(num, -1, sizeof(char) * 10);    scanf(\"%s\", num);    for (int i = 0; i < 10; i++)    {       if (num[i] != -1)          printf(\"%c \", num[i]);    }    printf(\"\\n\");    return 0; }  供参考", "referer": "user-0"}]}
{"question": "C语言中关于getchar()的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "在每个最后不带\\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "仅供参考：#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,\"%d%n\",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf(\"%d,%d\\n\",a,b);     return 0; }  #include <stdio.h> char s[]=\"123 ab 4\"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,\"%d%n\",&v,&n);         printf(\"k,v,n=%d,%d,%d\\n\",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf(\"skip char[%c]\\n\",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf(\"End.\\n\"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\\t'); or newline ('\\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "因为printf(\"哈哈哈\");改成 printf(\"哈哈哈\\n\"); scanf(\"%d\",&y); getchar();//用于接收键盘输入数字y之后的从键盘输入的回车符", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "只需一个就可以把，getchar()是为了吃掉scanf()留下的换行符啊........", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "scanf(\"%d\",&y);   后边不跟    //getchar();就会发生段错误.", "referer": "user-0"}]}
{"question": "求大佬看看，", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "看来我没读懂题  谢了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "第一行输出1组成部分数据 第二行输出2组成部分数据 ... 第九行输出9组成的数据 第十行输出0组成的数据 第十一行输出1组成部分数据 第十二行输出2组成的数据 等等，依次类推，这才是i%10的意思 然后就是按金字塔倒着打印  int main() {     int i, j, n;     scanf(“%d”, &n);     for(int i=n; i>0; i--) {         for(j=0; j<n-i; j++) printf(“ “); //打印空格         for(j=0; j<2*i-1; j++) printf(“%d”, (n-i+1)%10); //打印数据         printf(“\\n”); //换行     }     return 0; }", "referer": "user-0"}]}
{"question": "如何按以下规则批量导出文件名到xls", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 赵4老师 的回复:在Excel中数据、自文本、…… 能不能做到只把这些提取到txt？万分感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "在Excel中数据、自文本、……", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "开始、运行、cmd cd /d 你这些文件所在文件夹的全路径比如\"d:\\dwffiles\" dir /b N??_*.dwf >d:\\tmp.txt 然后在Excel中导入d:\\tmp.txt，指定_.作为列间隔字符", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "readdir查一下这个函数，可以拿到这些文件所在的目录，然后得到这个目录下的所有文件，得到文件名之后，然后写到xls中即可～", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 4 楼 稻壳粥的小迷弟 的回复:[quote=引用 3 楼 赵4老师 的回复:]在Excel中数据、自文本、…… 能不能做到只把这些提取到txt？万分感谢 [/quote] 提取到哪里都没问题，都需要打开文件，然后写文件，关闭文件的操作～", "referer": "user-0"}]}
{"question": "ccf显示运行出错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include <stdlib.h>  int main() {     //int n,i,data=0,j,*a,*p,*q;     //a = (int*) malloc (n * sizeof(int));     //scanf(\"%d/n\",&n);     int *arr, n, cnt = 0;     int i, j;     scanf(\"%d\", &n);     arr = (int*) malloc (n * sizeof(int));     if (!arr)         return -1;      for(i=0; i<n; i++) {         scanf(\"%d\",&arr[i]);     }      for (i = 0; i < n; i++) {         for (j = i+1; j < n; j++) {             if (abs(arr[i] - arr[j]) == 1) {                 //printf(\"abs(%d - %d) = 1\\n\", arr[i], arr[j]);                 cnt++;             }         }     }      printf(\"%d\\n\", cnt);  #if 0     p = a;     q = p+1;     for(i=0; i<n; i++) {         scanf(\"%d\",&a[i]);     }      for(i=0; i<n; i++) {         for(j=1; j<n-i; j++) {             if(*p-*q==1||*p-*q==-1) {                 data++;                 break;             }             q++;         }         p++;         q=p+1;     }     printf(\"%d\",data); #endif     return 0; } 供参考～  需要注意的是先scanf还是先malloc？scanf中不要有\\n", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include<stdio.h> #include <stdlib.h>  int main() {     //int n,i,data=0,j,*a,*p,*q;     //a = (int*) malloc (n * sizeof(int));     //scanf(\"%d/n\",&n);     int *arr, n, cnt = 0;     int i, j;     scanf(\"%d\", &n);     arr = (int*) malloc (n * sizeof(int));     if (!arr)         return -1;      for(i=0; i<n; i++) {         scanf(\"%d\",&arr[i]);     }      for (i = 0; i < n; i++) {         for (j = i+1; j < n; j++) {             if (abs(arr[i] - arr[j]) == 1) {                 //printf(\"abs(%d - %d) = 1\\n\", arr[i], arr[j]);                 cnt++;             }         }     }      printf(\"%d\\n\", cnt);  #if 0     p = a;     q = p+1;     for(i=0; i<n; i++) {         scanf(\"%d\",&a[i]);     }      for(i=0; i<n; i++) {         for(j=1; j<n-i; j++) {             if(*p-*q==1||*p-*q==-1) {                 data++;                 break;             }             q++;         }         p++;         q=p+1;     }     printf(\"%d\",data); #endif     return 0; } 供参考～  需要注意的是先scanf还是先malloc？scanf中不要有\\n 嗯嗯，如果只是把scanf放在malloc后面的话，评测结果是错误，不是运行错误，只有把指针操作去掉后才是满分，这是为什么呢", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "嗯嗯，如果只是把scanf放在malloc后面的话，评测结果是错误，不是运行错误，只有把指针操作去掉后才是满分，这是为什么呢", "referer": "user-0"}]}
{"question": "求斐波那契数列N项，求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢！！！！！！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "N<=2时，A没有赋值，所以A是不确定的，要么就在print(“1”)以后return，要么就把print(“1”)改成A=1", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include<stdio.h>  int main(void) {     int N,f1,f2,i,A;     f1=1;     f2=1;     scanf(\"%d\",&N);     if(N<=2) {         printf(\"1\");         return 0;     }     //if(N>2)     //{         for(i=3;i<=N;i++)         {             A=f1+f2;             f1=f2;             f2=A;         }     //}     printf(\"%d\\n\",A%2000000003);      return 0; } 供参考～  因为A没有初始化，输入1或2，会执行最后一个printf语句，由于A 是随机值，所以可能出现133；", "referer": "user-0"}]}
{"question": "丑数判断，输入后没输出，求助！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢！感谢！感谢！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "为什么我看不到你们的回复？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include<stdio.h>  const int arr[] = {2, 3, 5, 7};  int ppp(int a) {     //while(k=1)     //     unsigned int i;     while (1) {         for (i = 0; a && i < sizeof(arr)/sizeof(arr[0]);)             if (a % arr[i] == 0) {                 a /= arr[i];                 i = 0;                 continue;             } else {                 i++;             }         break;     }     if (a != 1)         return 0;     else         return 1;  #if 0     int q=0;     int k=1;     while(k==1)     {         if(a%2==0)         {             a=a/2;             continue;         }         if(a%3==0)         {             a=a/3;             continue;         }         if(a%5==0)         {             a=a/5;             continue;         }         if(a%7==0)         {             a=a/7;             continue;         }         k=0;     }     if(a==1)         q=1;      return q; #endif } int main (void) {     int N,i,a,b,s=0;     scanf(\"%d\",&N);     for(i=1;i<=N;i++)     {         scanf(\"%d\",&a);         b=ppp(a);         if(b==1)             s+=1;     }     printf(\"%d\",s);     return 0; } 供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "有人吗有人吗", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "while(k=1) 这是赋值 你应该写 ==", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "while(k==1) 供参考～  建议楼主对比一下这行代码～", "referer": "user-0"}]}
{"question": "C语言怎么读取串口数据", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "用uart的库", "referer": "user-0"}]}
{"question": "学习C语言用什么IDE？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "geany不错", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "linux + vim+gcc/g++", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "dev-c++这样的，比较小巧", "referer": "user-0"}]}
{"question": "关于C语言的算法，简单", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "第一个程序里/a(y);这个a和()之间需要符号，应该是用*.即乘。其他地方也注意下～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:scanf(\"%lf%d\", &x, &n); 楼主的scanf缺少& 哦哦哦，最后一个忘了没有加，那个还有别的问题", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "scanf(\"%lf%d\", &x, &n); 楼主的scanf缺少&", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我把所有变量都改成double了，我怕什么整除错误", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "那个，scanf_s输入我都改成了%lf", "referer": "user-0"}]}
{"question": "有没有大神会yuv视频播放", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考： https://blog.csdn.net/leixiaohua1020/article/details/40266503  如果看不懂，可以继续看雷神其他的文章", "referer": "user-0"}]}
{"question": "求助c语言数据结构代码问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢哇终于搞明白了这个代码了！ 感谢！！！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h>  typedef struct Node{     int data;     struct Node *pNext; }NODE,*PNODE;  PNODE create_list(int n) {     int i;     int val;       PNODE pHead = (PNODE)malloc(sizeof(NODE));     if (NULL == pHead)     {         printf(\"分配失败, 程序终止!\\n\");         exit(-1);     }     PNODE pTail = pHead;     pTail->pNext = NULL;       for (i=0; i<n; ++i)     {         scanf(\"%d\", &val);          PNODE pNew = (PNODE)malloc(sizeof(NODE));         if (NULL == pNew)         {             printf(\"分配失败, 程序终止!\\n\");             exit(-1);         }          pNew->data = val;         pNew->pNext = NULL;         pTail->pNext = pNew;         pTail = pNew;     }      return pHead; }  void traverse_list(PNODE pHead) {     PNODE p = pHead->pNext;      while(p!=NULL)     {         printf(\"%d \",p->data);         p = p->pNext;      }     printf(\"\\n\");     return; }  void sort(PNODE pHead,int *x) {     int i=1;     //PNODE p = (PNODE)malloc(sizeof(NODE));     PNODE p;     PNODE r = (PNODE)malloc(sizeof(NODE));     if (!r)         exit(0);     r->data = *x;     //r->pNext = NULL;      //p = pHead->pNext;     p = pHead;     //while(p!=NULL&&p->data>=x)     while(p->pNext && p->pNext->data <= *x)     {         i++;         p = p->pNext;     }      r->pNext = p->pNext;     p->pNext = r;     *x = i;  #if 0      r->data = x;     r->pNext = p->pNext;     p->pNext = r;     if(i==1)     {         r->data = x;         r->pNext = p;         pHead->pNext = r;     }     printf(\"%d\",i); #endif }  int main() {     int n,x;     PNODE pHead = NULL;     while(scanf(\"%d\", &n)!=EOF)     {         pHead =create_list(n);         scanf(\"%d\",&x);         if(n==0)         {             //printf(\"%d\", &x);             printf(\"%d\", x);         }         else         {             sort(pHead, &x);             printf(\"%d\\n\", x);             traverse_list(pHead);          }     }      return 0; } 供参考～  楼主判断有问题，  //while(p!=NULL&&p->data>=x)     while(p->pNext && p->pNext->data <= *x) 是>=x还是<=x的问题。  其他问题建议对比代码找一下自己的问题～ 这里的x我用指针，目的是获取位置信息～", "referer": "user-0"}]}
{"question": "这个表达式是啥子意思嘞", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 qybao的回复:因为 满足这个 a<0==b<0 就证明 a 和 b 是符号相同的 之后的如果满足 t<0 != a<0 就证明 t 和 a 是符号不相同的 t=a+b，a 和 b 符号相同，但相加结果的 t 的符号不相同，那说明什么？说明 t 溢出了 明白了，明白了，感谢，", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "因为 满足这个 a<0==b<0 就证明 a 和 b 是符号相同的 之后的如果满足 t<0 != a<0 就证明 t 和 a 是符号不相同的 t=a+b，a 和 b 符号相同，但相加结果的 t 的符号不相同，那说明什么？说明 t 溢出了", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:代码呢？讨论这个问题总要有前提或者问题本身的代码吧～ 表达式是t=a-b；然后这个OF是一个条件码，如果t=a-b发生了有符号的溢出，OF等于1，没有发生有符号的溢出，OF=0；然后它就给出了这么一个逻辑运算来判断究竟有没有溢出，但是这个判断的逻辑运算我实在是搞不懂它的含义", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "代码呢？讨论这个问题总要有前提或者问题本身的代码吧～", "referer": "user-0"}]}
{"question": "不知道那里错了，各位大神指点一下，鹅鹅鹅", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:2x是数学里的表达式，在编程语言里不能这么写，改成2 * x; ，太粗心了呀", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "2x是数学里的表达式，在编程语言里不能这么写，改成2 * x;", "referer": "user-0"}]}
{"question": "按字典顺序对多个字符串排序", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <string.h>  main () {     char *t;     int i,j,n;//,p;     unsigned int arr_len;     //char *s[]={\"pescal\",\"basic\",\"fortran\",\"turbo C\"};     const char *s[]={\"pescal\",\"basic\",\"fortran\",\"turbo C\"};     printf(\"Enter n:\");     scanf (\"%d\",&n); /*输入待排序字符串的个数n*/     arr_len = sizeof(s) / sizeof(s[0]);     if (n > arr_len)         n =  arr_len;     for (i=0;i<n-1;i++) /*用冒泡排序法*/     {         for (j=0;j<n-1-i;j++)         {             if (strcmp (s[j],s[j+1])>0)             {                 t = (char *)s[j];                 s[j] = s[j+1];                 s[j+1] = t;                 //strcpy (t,s[j]);                 //strcpy (s[j],s[j+1]);                 //strcpy (s[j+1],t);             }         }     }     //printf (\"%d\",p);     for (i=0;i<n;i++)     {         printf (\"%s\\n\",s[i]);     }      return 0; } 供参考～  楼主的问题主要是对s指针的理解，楼主定义的是指针数组，即每个元素都是指针，而每个指针都指向了只读数据段上的字符串，而楼主在排序时对只读数据进行了写操作，所以应该会出现多错误～  直接交换指针指向的位置即可～  其他问题详见代码～", "referer": "user-0"}]}
{"question": "利用循环队列模拟缓存，每缓存5组数据一次性读出", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "//2019213020 #include <stdio.h> #include <stdlib.h>  #define MAX_SIZE 6   //每次缓存最大为五组数据  typedef struct {     int queue[MAX_SIZE];     int rear;     int front; }QUEUE,*pQUEUE;  void InitQueue(pQUEUE p); int InQueue(pQUEUE p); void OutQueue(pQUEUE p);  int main() {     QUEUE myQueue;     int ret;     //char choose;      InitQueue(&myQueue);     do{          ret = InQueue(&myQueue);         //getchar();         //printf(\"是否继续（Y/N）\\n\");         //scanf(\" %c\",&choose);                   //感觉这样每次输入判断很麻烦，想可以连续输入数据直到想停止程序在输入     }while(ret >= 0);      return 0; }  //函数功能：初始化队列 void InitQueue(pQUEUE p) {     p->front = 0;     p->rear = 0; }  //函数功能：实现缓存读写功能 int InQueue(pQUEUE p) {     if((p->rear+1)%MAX_SIZE == p->front)     {         printf(\"overflow\\n\");         OutQueue(p);     }     printf(\"Input x:\\n\");     if (scanf(\"%d\",&p->queue[p->rear]) == EOF)         return -1;     p->rear = p->rear%MAX_SIZE+1;      if((p->rear+1)%MAX_SIZE == p->front)   //队满则一次性输出数据，并清空队列     {         printf(\"overflow\\n\");         OutQueue(p);     }     return 0; }  //函数功能：实现缓存输出功能 void OutQueue(pQUEUE p) {     if(p->front == p->rear)                //队空则退出程序     {         printf(\"underflow!\\n\");         exit(-1);     }     while(p->front != p->rear)     {         printf(\"%d\\n\",p->queue[p->front]);         p->front = p->front%MAX_SIZE+1;     }     return ; }  供参考～  楼主可通过输入ctrl+d（linux下）或ctrl+z（windows下）终止输入，结束输入", "referer": "user-0"}]}
{"question": "为什么创建二叉树要用到二级指针？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "swap函数，这个自定义函数在C语言的数据里比较经典了，如果了解和明白了这个，可以很好理解这个为什么用二重指针～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "1 区别就是A不用返回值，也能修改函数外的root指针，而B是在函数设置指针指向并返回函数内的指针  2 因为A要直接修改函数外的root指针，而B不是修改函数外的指针，而是返回一个新指针。这个问题回答过很多次了。 形参只是实参的拷贝，形参本身的内存地址和实参的内存地址不同（在不同的函数栈里），所以在函数内修改形参的内存，不能影响函数外的实参。 什么叫修改形参的内存？直接对形参（变量）赋值就是修改形参（变量）的内存，比如 int a=5；//a的内存信息为5，  a=10；//赋值语句修改了a的内存信息为10 所以B的 root = malloc(sizeof(struct TreeNode)); 就是修改形参的内存，这个root和函数外的实参的内存空间不同，所以修改它并不会对实参的内存造成影响，所以必须把它做为返回值返回去，否则函数外就没法获得这个变化的值。（也就是通过返回值来把变化返回去，让函数外也能获得这个变化） A为什么可以影响函数外的实参？因为A传进来的是实参的地址，而不是实参的值，且函数内没有修改形参的内存（也就是没用直接对形参用赋值语句），而是对形参解引用（也就是找到实参的地址）去赋值。什么叫解引用赋值？*xx=yy就是解引用赋值，即A是用*root = malloc(sizeof(struct TreeNode));来赋值的，*root就是函数外的实参（因为root是实参的地址，*root就是实参），所以A能改变函数外的指针指向新的地址。 要记住，要想在函数内修改函数外的变量，必须满足三个条件 一，形参必须用指针 二，必须是把实参的地址传给形参 三，函数内必须是对形参解引用赋值而不能直接对形参赋值 举个例子  int global_a = 5; void fun1(int a) {a=10;} //不影响函数外的实参 void fun2(int *a) {a=&global_a;} //修改形参的内存，不影响函数外的实参 void fun3(int *a) {*a=10;} //修改形参的解引用的内存，也就是修改实参的内存，影响函数外的实参 int main() {     int a = global_a;     fun1(a);      printf(\"%d\\n\", a); //a不变，为什么？不符合上面三个条件     fun2(&a);     printf(\"%d\\n\", a); //a不变，为什么？不符合上面的条件三     fun3(&a);     printf(\"%d\\n\", a); //a变了，为什么？因为fun2传的是a的地址，且fun2是解引用赋值，如果是fun2 } 对于A来说，函数外的实参root是个指针，根据上面的条件二，要传实参的地址，也就是要传root指针的地址，指针的地址就是二级指针，所以A的形参就是二级指针。  3 理解了2，就知道为什么C是错的了，C就像上面举例的fun2，修改了形参的内存，对实参的内存不造成影响。除非像B一样，把变化返回去，否则函数外无法获得变化。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "醍醐灌顶", "referer": "user-2"}]}
{"question": "泰勒公式求正弦：请问哪里错了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "理解不对吧，不是标准函数和公式计算的误差，是最后一项的误差要小于e 所以  int main() {     double x, e, t, m, p, s=0, f=1;     int n=1, i=2;     scanf(\"%lf%lf\", &x, &e);     m = x;     p = 1;     while ((t=m/p)>=e) { //如果最后一项的精度不小于e则一直循环         s += f*t; //累加总和         n++; //项数增加         m *= (x*x); //分子乘x平方         for(; i<=2*n-1; ++i) p *= i; //分母阶乘         f *= -1; //正负符号变化     }     printf(\"sin(%f)=%f\\n\", x, sin(x)); //标准函数库的结果     printf(\"%d, sin(%f)=%f\\n\", n, x, s); //自己计算的结果     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "#include <stdio.h> #include <math.h> float mypow(float a,int b) {     float result=1;     for (int i=1;i<=b;i++)     {         result*=a;     }    return result; } int fun(int a) {     int result=1;     for (int i=1;i<=a;i++)     {         result*=i;     }     return result; } int main() {      double x,eps,a1=-1;     printf(\"Enter x & eps:\");     scanf(\"%lf%lf\",&x,&eps);     float t=sin(x);     double sum=0;     int n;       for (n=0;fabs(t-sum)<eps;n++)     {         sum+=(mypow(a1,n)*mypow(x,2*n+1))/fun(2*n+1);     }      printf(\"sin(%f)=%f\\n\",x,t);     printf(\"%d,sin(%f)=%f\\n\",n-1,x,sum);  }", "referer": "user-0"}]}
{"question": "如果一个类中 有常数据成员也有静态数据成员 那么他的构造函数怎么写", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "A(A& p):a(p.a) {         b++;     }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "还是说包含常数据对象的类的对象不能赋值给另一个该类的对象，编写复制构造函数是违规的", "referer": "user-0"}]}
{"question": "C语言给小学生乘法测试", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "不需要了，自己写", "referer": "user-0"}]}
{"question": "我的代码错在哪里？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 zdzazcy 的回复:我在这里写一个例子你看一下,读懂就可以了. int main() {     int i;     int n;     double sum = 0;     printf(\"请输入累加的次数:\");     scanf(\"%d\",&n);     for(i = 0;i < n;i++)     {         if(sum == 0)         {             sum = 1;         }         else             sum = sum + 1.0/(2*i+1);     }     printf(\"累加后的数字为:sum = %.6lf\",sum);      return 0; }  浮点数与0比较，需要特殊处理，不能直接和和0比较～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我明白了 前N项我没理解好", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "#include <stdio.h>  int main(void) { \tint n, i; \tdouble sum=0; \tscanf(\"%d\",&n);  \tfor (i = 0; i < n; i++) { \t\tsum += 1.0 /(2 * i + 1); \t} /* \tfor(n;n>0;n=n-2){ \t\tsum=sum+1.0/n; \t} \t*/ \t//printf(\"sum = %.6f\",sum); \tprintf(\"sum = %.6lf\",sum);  }  供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "我在这里写一个例子你看一下,读懂就可以了. int main() {     int i;     int n;     double sum = 0;     printf(\"请输入累加的次数:\");     scanf(\"%d\",&n);     for(i = 0;i < n;i++)     {         if(sum == 0)         {             sum = 1;         }         else             sum = sum + 1.0/(2*i+1);     }     printf(\"累加后的数字为:sum = %.6lf\",sum);      return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "double要用lf%输出 #include<stdio.h> int main() { \tint N; \tdouble sum=0; \tscanf(\"%d\",&N); \tfor(int i=1;i<=N;i++) \t{ \t\tsum+=1.0/(2*i-1); \t} \tprintf(\"%.6lf\\n\",sum); }", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "我刚学到这，等大佬们来说，我也看看有什么问题，学习一下，嘿嘿", "referer": "user-0"}, {"cid": "7", "user": "user-5", "content": "前n项你没理解是什么意思。 比如n是2，也就是前2项，就是1+1/3 n是3，也就是前3项，就是1+1/3+1/5 看到了吗，n是3，最后一项就是1/5，也就是1/(2*n-1)，而你的代码就是，n是3，最后一项却是1/3，所以当然结果不对了，所以改成 for(n; n>0; n--) {     sum=sum+1/(2*n-1); }", "referer": "user-0"}]}
{"question": "C语言处理多组数据问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "供参考 int year,month,day; scanf(\"%d%d%d\",&year,&month,&day); while((year+month+day)!=0) {     ...     scanf(\"%d%d%d\",&year,&month,&day); } 或者 int year,month,day; do {     ...     scanf(\"%d%d%d\",&year,&month,&day); } while((year+month+day)!=0);", "referer": "user-0"}]}
{"question": "数据结构––线性表插入问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h>  #define maxsize 100  typedef struct {     int data[maxsize];     int length; } Sqlist;  //Sqlist L = { {1,2,3,4,6,7,8},8 }; Sqlist L = { {1,2,3,4,6,7,8}, 7 };  int findelem(Sqlist L, int x); void insertelem(Sqlist &L, int x);   int main(void) {     insertelem(L, 5);     int j=0;     //while (j <L.length-1) {     while (j <L.length) {         //printf(\"%d\", L.data[maxsize]);         printf(\"%d \", L.data[j]);         j++;     }     putchar(10);     return 0; }   int findelem(Sqlist L, int x)     //找位置 {     int i;     for (i = 0; i < L.length; ++i)     {         if (x < L.data[i])         {             return i;         }     }      return i; }  void insertelem(Sqlist &L, int x)    //插入 {     int i, p;     p = findelem(L, x);     for (i = L.length - 1; i >= p; --i)         L.data[i + 1] = L.data[i];     L.data[p] = x;     ++L.length; } 供参考～ 初始化长度有问题， 对比代码找一下自己的问题吧", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "修改如下 while(j<L.length) {     printf(“%d”, L.data[j]); //不要打印L.data[maxsize]，因为首先L.data[maxsize]会数组越界，就算要打印最后一个元素也是L.data[maxsize-1]，其次，应该是打印L.data[j]，否则j循环没意义，L.data[maxsize]打印的都是同一个元素。     j++; }", "referer": "user-0"}]}
{"question": "小学生测试之C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "不需要了，自己写了", "referer": "user-0"}]}
{"question": "C语言小学生乘法测试", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "额，好像忘了放图", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "代码在哪儿呢？", "referer": "user-0"}]}
{"question": "c语言中，链栈怎么进行任意节点的交换，不是数据域的值交换，而是整个节点的交换", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这不是挺简单的吗。就是把m前后的节点改为n前后的节点，把n前后的节点改为m前后的节点。 n_pre->next=m; //n的前一个节点的下一个节点指向m tmp=m->next; //临时保存m的下一个节点 m->next=n->next; //m的下一个节点指向n的下一个节点 n->next=tmp; //n的下一个节点指向原来m的下一个节点 m_pre->next=n; //m的前一个节点的下一个节点指向n", "referer": "user-0"}]}
{"question": "C语言循环语句", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以，但是循环里b不变就会一直满足循环条件，造成死循环", "referer": "user-0"}]}
{"question": "为什么这个位域输出不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "usigned占4个，枚举占4个，bool占1个， 所以4+4+4+1=13，按第一个成员unsigned类型对齐（也就是按4个字节对齐），所以13被补齐为16个字节", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-1 的回复:毕竟不是联合体，每个成员都有自己独立的内存空间，位域只是让它们使用部分空间而已，而且位域也会按字节对齐分配空间的，所以hz占2个字节（超过8位不满16位），wordsize占1个字节（不满8位），he占1个字节，ht占1个字节，所以占用2+1+1+1=5字节，由于内存自动对齐（第一个成员为unsigned类型占4个字节，按它对齐），5大于4个字节，不满8个字节，所以补齐为8个字节。 你可以试试打印sizeof(a.hz),sizeof(a.he)等等看看 如果不使用位域 它是16个字节 这16个字节怎么算的啊？ unsign占4个，bool和两个枚举都各占一个 输出是16个", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不应该是13+1+2+1等于17位 三个字节吗", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "毕竟不是联合体，每个成员都有自己独立的内存空间，位域只是让它们使用部分空间而已，而且位域也会按字节对齐分配空间的，所以hz占2个字节（超过8位不满16位），wordsize占1个字节（不满8位），he占1个字节，ht占1个字节，所以占用2+1+1+1=5字节，由于内存自动对齐（第一个成员为unsigned类型占4个字节，按它对齐），5大于4个字节，不满8个字节，所以补齐为8个字节。 你可以试试打印sizeof(a.hz),sizeof(a.he)等等看看", "referer": "user-0"}]}
{"question": "小白 求助~！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:因为楼主没有将b值输入到b的内存里。 注意楼主的scanf中带有,逗号，输入的时候要保持和scanf的格式一致，即该逗号是中文，则输入的时候要输入中文逗号，否则输入英文逗号. 感谢老师指点，你的解答很有帮助~！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "输入两个数字的时候中间加个英文的逗号试试？", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "仅供参考：#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,\"%d%n\",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf(\"%d,%d\\n\",a,b);     return 0; }", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "总体逻辑没有问题，不过一般需要一个return 0；返回值，因为你用的是int作为main函数的返回值。 源码：  #include<stdio.h> int main() {     int a, b, max;     scanf(\"%d,%d\",&a, &b);     if(a>b)         max = a;     else         max = b;     printf(\"max=%d\\n\", max);     return 0； }   不过注意输入的时候是a,b，不是a b，a与b之间是逗号，不是空格。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "因为楼主没有将b值输入到b的内存里。 注意楼主的scanf中带有,逗号，输入的时候要保持和scanf的格式一致，即该逗号是中文，则输入的时候要输入中文逗号，否则输入英文逗号.", "referer": "user-0"}]}
{"question": "机考题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "输出每行的行是啥意思？总行数？还是每行原来的内容？ int a, b, c, ln=0; char buf[64]; memset(buf, 0, sizeof(buf); while(fgets(stdin, buf, 64)!=null) {//如果行数据存在     if(sscanf(buf, “%d%d%d”, &a, &b, &c)==2) {//如果行数据是两个整数         ln++; //就统计符合条件的行     }     printf(“%s”, buf);//打印行数据     memset(buf, 0, sizeof(buf); } printf(“%d”, ln);//符合条件的行总数", "referer": "user-0"}]}
{"question": "想通过链表从文件中读取，之后复制到新文件中，但是程序一闪就退，也无法新建文件", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "if(!feof(fl)) {//进入这个if时     pNew=(users*)malloc(); //首先要做这一步     ... } 为什么？ 你好好想想，进入if(list_number_count==1)是就已经把pNew用了，进入else是不是应该重新给pNew分配内存？什么时候分配，那就是在你的if(!feof(fl))判断文件没有eof的时候分配。 另外，return pHead也最好放在最外面，否则文件不能正常读入时没有返回值，函数没有返回值是危险行为。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢了，我找到这个问题了", "referer": "user-0"}]}
{"question": "小白提问：如何使getchar（）函数返回下一个非空白字符？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请参考《scanf()、gets()和getline()读取输入》 希望能够帮到您！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "if(ch !='\\n'  && ch != '\\t' && ch != ' ') 试试这样 或者  if (!isspace(ch))   //注意加头文件<ctype.h>", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "if(ch！='\\n' && ch!=' ' && ch!='\\t')", "referer": "user-0"}]}
{"question": "错误又来了。。。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 user-1 的回复:[quote=引用 4 楼 我当时害怕极了QAQ 的回复:][quote=引用 3 楼 user-1 的回复:]主要是你判断栈顶元素的时候没有判断栈是否为空，所以就会造成st[top]的top为-1 修改方法一是判断栈顶元素之前判断栈是否为空，比如 if(!s1.empty() && s1.top1()==‘(‘) 修改方法二是top1方法追加一个判断，比如 if(top==-1) return -1; return st[top]; [/quot]  按照方法1和方法2修改了，还是一样的错误。。。  按理说不应该呀，我push的时候已经++top了？  只有匹配的时候才会自减  怎么会变成-1 你debug跟踪一下吧，我这边用你的代码没法再现你的错误 另外，跑你的代码时还发现一个问题，就是以下打印 cout << c[1] << \"  匹配错误\" << endl; 这里应该是c[i] [/quote]  嗯嗯，大佬  问题解决了，不是程序的问题  不知道是编译器的问题还是内存出了什么问题。。。  谢谢帮助", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "[quote=引用 3 楼 user-1 的回复:]主要是你判断栈顶元素的时候没有判断栈是否为空，所以就会造成st[top]的top为-1 修改方法一是判断栈顶元素之前判断栈是否为空，比如 if(!s1.empty() && s1.top1()==‘(‘) 修改方法二是top1方法追加一个判断，比如 if(top==-1) return -1; return st[top]; [/quot]  按照方法1和方法2修改了，还是一样的错误。。。  按理说不应该呀，我push的时候已经++top了？  只有匹配的时候才会自减  怎么会变成-1", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 4 楼 我当时害怕极了QAQ 的回复:[quote=引用 3 楼 user-1 的回复:]主要是你判断栈顶元素的时候没有判断栈是否为空，所以就会造成st[top]的top为-1 修改方法一是判断栈顶元素之前判断栈是否为空，比如 if(!s1.empty() && s1.top1()==‘(‘) 修改方法二是top1方法追加一个判断，比如 if(top==-1) return -1; return st[top]; [/quot]  按照方法1和方法2修改了，还是一样的错误。。。  按理说不应该呀，我push的时候已经++top了？  只有匹配的时候才会自减  怎么会变成-1 你debug跟踪一下吧，我这边用你的代码没法再现你的错误 另外，跑你的代码时还发现一个问题，就是以下打印 cout << c[1] << \"  匹配错误\" << endl; 这里应该是c[i]", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "主要是你判断栈顶元素的时候没有判断栈是否为空，所以就会造成st[top]的top为-1 修改方法一是判断栈顶元素之前判断栈是否为空，比如 if(!s1.empty() && s1.top1()==‘(‘) 修改方法二是top1方法追加一个判断，比如 if(top==-1) return -1; return st[top];", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-1 的回复:看你的用例，应该是只打印第一次不匹配的错误，所以遇到不匹配，打印后就退出循环就好了  void Bracketmatch(const char* c) //括号匹配 {     bool bj=true;     char t;     stack s1(strlen(c)+1);     for (unsigned int i = 0; i < strlen(c); i++)     {         t = c[i];         switch (t)         {         case '(':             s1.push(t);             break;         case '[':             s1.push(t);             break;         case '{':             s1.push(t);             break;         case ')':                           if (s1.top1() == '(')             {                 s1.pop();                 break;             }             else             {                 cout << c[i] << \"  匹配错误\" << endl;                 bj = false;                 break;             }         case ']':             if (s1.top1() == '[')             {                 s1.pop();                 break;             }             else             {                 cout << c[1] << \"  匹配错误\" << endl;                 bj = false;                 break;             }         case '}':             if (s1.top1() == '{')             {                 s1.pop();                 break;             }             else             {                 cout << c[i] << \"  匹配错误\" << endl;                 bj = false;                 break;             }         default:             break;         }         if (!bj) break; //加这一句就好了，只要有错，就不再继续往下查找匹配了     }     if (bj)     {         if (s1.empty())         {             cout << \"匹配正确！\" << endl;         }         else             cout << s1.top1() << \"  匹配错误\" << endl;     } }   还是不对  是不是stack类有问题", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "看你的用例，应该是只打印第一次不匹配的错误，所以遇到不匹配，打印后就退出循环就好了  void Bracketmatch(const char* c) //括号匹配 {     bool bj=true;     char t;     stack s1(strlen(c)+1);     for (unsigned int i = 0; i < strlen(c); i++)     {         t = c[i];         switch (t)         {         case '(':             s1.push(t);             break;         case '[':             s1.push(t);             break;         case '{':             s1.push(t);             break;         case ')':                           if (s1.top1() == '(')             {                 s1.pop();                 break;             }             else             {                 cout << c[i] << \"  匹配错误\" << endl;                 bj = false;                 break;             }         case ']':             if (s1.top1() == '[')             {                 s1.pop();                 break;             }             else             {                 cout << c[1] << \"  匹配错误\" << endl;                 bj = false;                 break;             }         case '}':             if (s1.top1() == '{')             {                 s1.pop();                 break;             }             else             {                 cout << c[i] << \"  匹配错误\" << endl;                 bj = false;                 break;             }         default:             break;         }         if (!bj) break; //加这一句就好了，只要有错，就不再继续往下查找匹配了     }     if (bj)     {         if (s1.empty())         {             cout << \"匹配正确！\" << endl;         }         else             cout << s1.top1() << \"  匹配错误\" << endl;     } }", "referer": "user-0"}]}
{"question": "关于二级指针的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请参考《指向指针的指针》 希望能够帮到您！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个问题类似swap()为什么用指针，而不用变量来实现两个数据交换，道理是一样的～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "簡單說，一級指針用來改變值，二級指針用來改變鏈表。  比如定義了一個指針，把他傳給函數，之前必須分配好内存，函數可以改變該内存區的值； 把他的指針傳給函數，則可以在函數内部分配内存，或指向另一個地方，對於構建鏈表靈活得多。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "因为写代码的人对定义接口毫无规划 胡乱操作", "referer": "user-0"}]}
{"question": "小白做了个学生信息管理系统，但是不知道为什么就是运行的界面不对", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 8 楼 学码就是爱好 的回复:十多年前学过C，最新重新看了一部分，文件和结构体还没系统看，但是我个人理解，这个程序伪代码这样： 首先读取文件，然后根据文件内数据结构的多少（具体实现还没想过是通过历遍还是在文件开头存储结构体数量）申请结构体内存； 将文件内的数据与申请的结构体关联； 然后所有的增加、删除、修改、查询都在结构体链表中进行； 退出程序时，检查是否进行过增加、删除、修改的，如果是 将新的结构体链表存入文件，如果不是直接退出。  另外程序中应该是文件的打开与关闭 ，内存的申请与释放 一一对应。 可能说的不对，请包涵。谢谢大佬！很久没上csdn，今天才看到您的回复，真的很感谢您的指正！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "十多年前学过C，最新重新看了一部分，文件和结构体还没系统看，但是我个人理解，这个程序伪代码这样： 首先读取文件，然后根据文件内数据结构的多少（具体实现还没想过是通过历遍还是在文件开头存储结构体数量）申请结构体内存； 将文件内的数据与申请的结构体关联； 然后所有的增加、删除、修改、查询都在结构体链表中进行； 退出程序时，检查是否进行过增加、删除、修改的，如果是 将新的结构体链表存入文件，如果不是直接退出。  另外程序中应该是文件的打开与关闭 ，内存的申请与释放 一一对应。 可能说的不对，请包涵。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "测试，除了新增与查询的功能正确，修改与删除都不能保存到文件", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "修改代码如下： #include <stdio.h> #include <string.h> #include <malloc.h>  struct stud {     int num;     char name[30];     char classnum[30];     int score[4];     struct stud *next; };  struct stud *head=NULL;  void InsertStud() {     char s[10];     do      {          int tmp;          printf(\"请输入学号：\");          scanf(\"%d\",&tmp);          struct stud *q,*p;          p=head;           while(p!=NULL)            {             if(p->num==tmp)               {                 printf(\"该学生已存在！\\n\");                 return;                }               p=p->next;             }            q=(struct stud*)malloc(sizeof(struct stud));            if(q==NULL)              {                printf(\"申请内存失败\\n\");                return;              }              q->num=tmp;             printf(\"请输入姓名：\");             scanf(\"%s\",q->name);             printf(\"请输入班级：\");             scanf(\"%s\",&q->classnum);             printf(\"请输入四门课的成绩：\");             scanf(\"%d %d %d %d\",&q->score[0],&q->score[1],&q->score[2],&q->score[3]);             q->next=NULL;              p=head;             if(p==NULL)                 {                     head=q;                 }             else                 {                     while(p->next!=NULL)                         {                             p=p->next;                         }                     p->next=q;                 }             printf(\"学生增加成功！\\n\");              printf(\"你还需要继续输入学生信息吗？(no退出)：\");             scanf(\"%s\",s);           }         while(strcmp(s,\"no\")!=0);  }   void DelStud() { int flag=1; int num; printf(\"请输入要删除的学生学号：\\n\"); scanf(\"%d\",&num); struct stud *p,*q; q=p=head; while(p!=NULL&&flag==1) { if(p->num==num) { if(p==head)//删除首节点 { head=p->next; free(p); } else { q->next=p->next; free(p); } flag=0; printf(\"删除学生信息成功！\\n\"); return; } else { q=p; p=p->next; }  } if(flag==1) { printf(\"没有找到可以删除的学生学号！\\n\"); } }   void UpdateStud() { int flag=1; int num; printf(\"请输入要修改的学生的学号：\\n\"); scanf(\"%d\",&num);  struct stud *p; p=head; while(p!=NULL&&flag==1) { if(p->num==num) { printf(\"请输入新学号：\\n\"); scanf(\"%d\",&p->num); printf(\"请输入新姓名：\\n\"); scanf(\"%s\",p->name); printf(\"请输入新班级：\\n\"); scanf(\"%s\",p->classnum); printf(\"请输入新成绩：\\n\"); scanf(\"%d%d%d%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]); flag=0; printf(\"学生信息修改操作成功\\n\"); } else { p=p->next; }  } if(flag==1) { printf(\"没有找到要修改的记录\\n\"); }  } void QueryStud() { int flag=1; int num; printf(\"请输入要查询的学号：\\n\"); scanf(\"%d\",&num);  struct stud *p; p=head; while(p!=NULL&&flag==1) { if(p->num==num) { printf(\"姓名：%s\\n\",p->name); printf(\"学号：%d\\n\",p->num); printf(\"班级：%s\\n\",p->classnum); printf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\\n\",p->score[0],p->score[1],p->score[2],p->score[3]); flag=0; } else { p=p->next; } } if(flag==1) { printf(\"没有查询到要查询的信息！\"); } }  /*void StaticStud() { } */ void SaveStud() { FILE *fp;  fp=fopen(\"stud.dat\",\"ab+\");//打开文件stud.dat //{ //printf(\"文件打开失败\\n\"); //return;//打开失败退出 //} struct stud *p; p=head; while(p!=NULL) { fwrite(p,sizeof(struct stud),1,fp); p=p->next; }  fclose(fp);//关闭文件 printf(\"学生信息保存成功！\\n\"); }  int fileexist(const char *filename) { FILE *fp; if((fp=fopen(filename,\"rb\"))==NULL) return 0; else { fclose(fp); return 1; } } void load() { if(fileexist(\"stud.dat\")==0) return;  FILE *fp; if((fp=fopen(\"stud.dat\",\"rb\"))==NULL) { printf(\"文件打开失败!\\n\"); return; }  struct stud *p,*q; p=head;  while(!feof(fp)) { q=(struct stud *)malloc(sizeof(struct stud)); if(q==NULL) { printf(\"申请内存失败!\\n\"); return; } fread(q,sizeof(struct  stud),1,fp); q->next=NULL; if(head==NULL) // if(P==NULL) { //head=p; head=q; p=q; } else { while(p->next!=NULL) { p=p->next; } p->next=q; }  } fclose(fp);  }  int main() {     int i;     load();     do     {         printf(\"\\n\\n\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t**       欢迎来到学生信息管理系统      **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t** 1、增加学生信息      2、删除学生信息**\\n\");         printf(\"\\t\\t** 3、修改学生信息      4、查询学生信息**\\n\");         printf(\"\\t\\t** 5、基本信息统计      6、保存学生信息**\\n\");         printf(\"\\t\\t** 7、退出                             **\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"请选择操作：\");         scanf(\"%d\",&i);         switch(i)         {             case 1 : InsertStud();break;             case 2 : DelStud();break;             case 3 : UpdateStud();break;             case 4 : QueryStud();break;                      // case 5 : StaticStud();break;             case 6 : SaveStud();break;             case 7 : break;             default : printf(\"选择错误，请重选\");break;         }     }while(i!=7);     return 0; }   做更新 删除 增加的操作 如果不进行6 保存操作 所做的操作实际上都没有保存，再次打开程序读文件 数据没有变化，因此要么在做以上三个动作要么直接接保存动作，要么提示用户保存。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <string.h> #include <malloc.h>  struct stud {     int num;     char name[30];     int classnum;     int score[4];     struct stud *next; };  struct stud *head=NULL;  void InsertStud() {      char s[10];     do     {         int tmp;         printf(\"请输入学号：\\n\");         scanf(\"%d\",&tmp);          struct stud *q,*p;         p=head;          while(p!=NULL)         {             if(p->classnum==tmp)             {                 printf(\"该学生已存在！\\n\");                 return;             }             p=p->next;         }         q=(struct stud*)malloc(sizeof(struct stud));         if(q==NULL)         {             printf(\"申请内存失败\\n\");             return;         }          q->classnum=tmp;         printf(\"请输入姓名：\");         scanf(\"%s\",q->name);         printf(\"请输入学号：\");         scanf(\"%d\",&q->num);         //printf(\"请输入班级：\"); //还要输入班级吗？上面不是已经赋值了吗？         //scanf(\"%s\",&q->classnum);         printf(\"请输入四门课的成绩：\");         scanf(\"%d%d%d%d\",&q->score[0],&q->score[1],&q->score[2],&q->score[3]);         q->next=NULL;          p=head;         if(p==NULL)         {             head=q;         }         else         {             while(p->next!=NULL)             {                 p=p->next;             }             p->next=q;         }         printf(\"学生增加成功！\\n\");          printf(\"你还需要继续输入学生信息吗？(no退出)：\");         scanf(\"%s\",s);     }     while(strcmp(strupr(s),\"NO\")!=0);  }   void DelStud() {     int flag=1;     int num;     printf(\"请输入要删除的学生学号：\\n\");     scanf(\"%d\",&num);     struct stud *p,*q;     p=q=head;     while(p!=NULL&&flag==1)     {         if(p->classnum==num)         {             if(p==head)//删除首节点             {                 head = p->next;                 free(p);             }             else             {                 q->next=p->next;                 free(p);             }             flag=0;             printf(\"删除学生信息成功！\\n\");             return;         }         else         {             q=p;             p=p->next;         }      }     if(flag==1)     {         printf(\"没有找到可以删除的学生学号！\\n\");     } }   void UpdateStud() {     int flag=1;     int num;     printf(\"请输入要修改的学生的学号：\\n\");     scanf(\"%d\",&num);      struct stud *p;     p=head;     while(p!=NULL&&flag==1)     {         if(p->num==num)         {             printf(\"请输入新学号：\\n\");             scanf(\"%d\",&p->num);             printf(\"请输入新姓名：\\n\");             scanf(\"%s\",p->name);             printf(\"请输入新班级：\\n\");             //scanf(\"%s\",p->classnum);             scanf(\"%d\", &p->classnum);             printf(\"请输入新成绩：\\n\");             scanf(\"%d%d%d%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]);             flag=0;             printf(\"学生信息修改操作成功\\n\");         }         else         {             p=p->next;         }      }     if(flag==1)     {         printf(\"没有找到要修改的记录\\n\");     }  } void QueryStud() {     int flag=1;     int num;     struct stud *p;     printf(\"请输入要查询的学号：\\n\");     scanf(\"%d\",&num);     p=head;     while(p!=NULL&&flag==1)     {         if(p->num==num)         {             printf(\"姓名：%s\",p->name);             //printf(\"学号：%d\",&p->num);    //为什么要加&?             printf(\"学号：%d\", p->num);             //printf(\"班级：%s\",p->classnum);             printf(\"班级：%d\",p->classnum);             //printf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]);             printf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\", p->score[0], p->score[1], p->score[2], p->score[3]);             flag=0;         }         else         {             p=p->next;         }     }     if(flag==1)     {         printf(\"没有查询到要查询的信息！\");     } }  /*void StaticStud()   {   }   */ void SaveStud() {     FILE *fp;      if((fp=fopen(\"stud.dat\",\"wb\"))==NULL);//打开文件stud.dat     {         printf(\"文件打开失败\\n\");         return;//打开失败退出     }     struct stud *p;     p=head;     while(p!=NULL)     {         fwrite(p,sizeof(struct stud),1,fp);         p=p->next;     }      fclose(fp);//关闭文件     printf(\"学生信息保存成功！\\n\"); }  //int fileexist(char *filename) int fileexist(const char *filename) {     FILE *fp;     if((fp=fopen(filename,\"rb\"))==NULL)         return 0;     else     {         fclose(fp);         return 1;     } } void load() {     if(fileexist(\"stud.dat\")==0)         return;      FILE *fp;     if((fp=fopen(\"stud.dat\",\"rb\"))==NULL)     {         printf(\"文件打开失败!\\n\");         return;     }      struct stud *p,*q;     p=head;      while(!feof(fp))     {         q=(struct stud *)malloc(sizeof(struct stud));         if(q==NULL)         {             printf(\"申请内存失败!\\n\");             return;         }         fread(q,sizeof(struct  stud),1,fp);         q->next=NULL;          //if(p==NULL)         if(head==NULL)         {             //head=p;             head = q;   //如果把p赋值给head，那么这里是有问题的;             p = q;         }         else         {             while(p->next!=NULL)             {                 p=p->next;             }             p->next=q;         }      }     fclose(fp); }  int main() {     int i;     load();     do     {         printf(\"\\n\\n\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t**       欢迎来到学生信息管理系统      **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t** 1、增加学生信息      2、删除学生信息**\\n\");         printf(\"\\t\\t** 3、修改学生信息      4、查询学生信息**\\n\");         printf(\"\\t\\t** 5、基本信息统计      6、保存学生信息**\\n\");         printf(\"\\t\\t** 7、退出                             **\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"请选择操作：\");         scanf(\"%d\",&i);         switch(i)         {             case 1 : InsertStud();break;             case 2 : DelStud();break;             case 3 : UpdateStud();break;             case 4 : QueryStud();break;                      // case 5 : StaticStud();break;             case 6 : SaveStud();break;             case 7 : break;             default : printf(\"选择错误，请重选\");break;         }     }while(i!=7);     return 0; } 供参考～ 感谢大牛！经过修改以后我的代码如下，但是每当我按6想要保存文件的时候，总是提示文件打开失败，由于我对文件的操作非常的不熟悉，所以不知道到底是什么问题导致这种情况，求解答  #include <stdio.h> #include <string.h> #include <malloc.h> struct stud { \tint num; \tchar name[30]; \tchar classnum[30]; \tint score[4]; \tstruct stud *next; };  struct stud *head=NULL;  void InsertStud() {  \tchar s[10]; \tdo \t{\t \t\tint tmp; \t\tprintf(\"请输入学号：\\n\"); \t    scanf(\"%d\",&tmp);  \t    struct stud *q,*p; \t\tp=head;  \t\twhile(p!=NULL) \t\t{ \t\t\tif(p->num==tmp) \t\t\t{ \t\t\t\tprintf(\"该学生已存在！\\n\"); \t\t\t\treturn; \t\t\t} \t\t\tp=p->next; \t\t} \t\tq=(struct stud*)malloc(sizeof(struct stud)); \t\tif(q==NULL) \t\t{ \t\t\tprintf(\"申请内存失败\\n\"); \t\t\treturn; \t\t}  \t\tq->num=tmp; \t\tprintf(\"请输入姓名：\"); \t\tscanf(\"%s\",q->name); \t\tprintf(\"请输入学号：\"); \t\tscanf(\"%d\",&q->num); \t\tprintf(\"请输入班级：\"); \t\tscanf(\"%s\",&q->classnum); \t\tprintf(\"请输入四门课的成绩：\"); \t\tscanf(\"%d%d%d%d\",&q->score[0],&q->score[1],&q->score[2],&q->score[3]); \t\tq->next=NULL;  \t\tp=head; \t\tif(p==NULL) \t\t{ \t\t\thead=q; \t\t} \t\telse \t\t{ \t\t\twhile(p->next!=NULL) \t\t\t{ \t\t\t\tp=p->next; \t\t\t} \t\t\tp->next=q; \t\t} \t\tprintf(\"学生增加成功！\\n\");  \t\tprintf(\"你还需要继续输入学生信息吗？(no退出)：\"); \t\tscanf(\"%s\",s); \t} \t\twhile(strcmp(strupr(s),\"NO\")!=0);  }   void DelStud() { \tint flag=1; \tint num; \tprintf(\"请输入要删除的学生学号：\\n\"); \tscanf(\"%d\",&num); \tstruct stud *p,*q; \tq=p=head; \twhile(p!=NULL&&flag==1) \t{ \t\tif(p->num==num) \t\t{ \t\t\tif(p==head)//删除首节点 \t\t\t{ \t\t\t\thead=p->next; \t\t\t\tfree(p); \t\t\t} \t\t\telse \t\t\t{ \t\t\t\tq->next=p->next; \t\t\t\tfree(p); \t\t\t} \t\t\tflag=0; \t\t\tprintf(\"删除学生信息成功！\\n\"); \t\t\treturn; \t\t} \t\telse \t\t{ \t\t\tq=p; \t\t\tp=p->next; \t\t}  \t} \tif(flag==1) \t{ \t\tprintf(\"没有找到可以删除的学生学号！\\n\"); \t} }   void UpdateStud() { \tint flag=1; \tint num; \tprintf(\"请输入要修改的学生的学号：\\n\"); \tscanf(\"%d\",&num);  \tstruct stud *p; \tp=head; \twhile(p!=NULL&&flag==1) \t{ \t\tif(p->num==num) \t\t{ \t\t\tprintf(\"请输入新学号：\\n\"); \t\t\tscanf(\"%d\",&p->num); \t\t\tprintf(\"请输入新姓名：\\n\"); \t\t\tscanf(\"%s\",p->name); \t\t\tprintf(\"请输入新班级：\\n\"); \t\t\tscanf(\"%s\",p->classnum); \t\t\tprintf(\"请输入新成绩：\\n\"); \t\t\tscanf(\"%d%d%d%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]); \t\t\tflag=0; \t\t\tprintf(\"学生信息修改操作成功\\n\"); \t\t} \t\telse \t\t{ \t\t\tp=p->next; \t\t}  \t} \tif(flag==1) \t{ \t\tprintf(\"没有找到要修改的记录\\n\"); \t}  } void QueryStud() { \tint flag=1; \tint num; \tprintf(\"请输入要查询的学号：\\n\"); \tscanf(\"%d\",&num);  \tstruct stud *p; \tp=head; \twhile(p!=NULL&&flag==1) \t{ \t\tif(p->num==num) \t\t{ \t\t\tprintf(\"姓名：%s\\n\",p->name); \t\t\tprintf(\"学号：%d\\n\",p->num); \t\t\tprintf(\"班级：%s\\n\",p->classnum); \t\t\tprintf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\\n\",p->score[0],p->score[1],p->score[2],p->score[3]); \t\t\tflag=0; \t\t} \t\telse \t\t{ \t\t\tp=p->next; \t\t} \t} \tif(flag==1) \t{ \t\tprintf(\"没有查询到要查询的信息！\"); \t} }  /*void StaticStud() { } */ void SaveStud() { \tFILE *fp;  \tif((fp=fopen(\"stud.dat\",\"wb\"))==NULL);//打开文件stud.dat \t{ \t\tprintf(\"文件打开失败\\n\"); \t\treturn;//打开失败退出 \t} \tstruct stud *p; \tp=head; \twhile(p!=NULL) \t{ \t\tfwrite(p,sizeof(struct stud),1,fp); \t\tp=p->next; \t}  \tfclose(fp);//关闭文件 \tprintf(\"学生信息保存成功！\\n\"); }  int fileexist(const char *filename) { \tFILE *fp; \tif((fp=fopen(filename,\"rb\"))==NULL) \treturn 0; \telse \t{ \t\tfclose(fp); \t\treturn 1; \t} } void load() { \tif(fileexist(\"stud.dat\")==0) \treturn;  \tFILE *fp; \tif((fp=fopen(\"stud.dat\",\"rb\"))==NULL) \t{ \t\tprintf(\"文件打开失败!\\n\"); \t\treturn; \t}  \tstruct stud *p,*q; \tp=head;  \twhile(!feof(fp)) \t{ \t\tq=(struct stud *)malloc(sizeof(struct stud)); \t\tif(q==NULL) \t\t{ \t\t\tprintf(\"申请内存失败!\\n\"); \t\t\treturn; \t\t} \t\tfread(q,sizeof(struct  stud),1,fp); \t\tq->next=NULL; \t\tif(head==NULL) \t//\tif(P==NULL) \t\t{ \t\t\t//head=p; \t\t\thead=q; \t\t\tp=q; \t\t} \t\telse \t\t{ \t\t\twhile(p->next!=NULL) \t\t\t{ \t\t\t\tp=p->next; \t\t\t} \t\t\tp->next=q; \t\t}  \t} \tfclose(fp);  } 感谢大牛！经过修改以后我的代码如下，但是每当我按6想要保存文件的时候，总是提示文件打开失败，由于我对文件的操作非常的不熟悉，所以不知道到底是什么问题导致这种情况，求解答", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "好厉害哦。。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <string.h> #include <malloc.h>  struct stud {     int num;     char name[30];     int classnum;     int score[4];     struct stud *next; };  struct stud *head=NULL;  void InsertStud() {      char s[10];     do     {         int tmp;         printf(\"请输入学号：\\n\");         scanf(\"%d\",&tmp);          struct stud *q,*p;         p=head;          while(p!=NULL)         {             if(p->classnum==tmp)             {                 printf(\"该学生已存在！\\n\");                 return;             }             p=p->next;         }         q=(struct stud*)malloc(sizeof(struct stud));         if(q==NULL)         {             printf(\"申请内存失败\\n\");             return;         }          q->classnum=tmp;         printf(\"请输入姓名：\");         scanf(\"%s\",q->name);         printf(\"请输入学号：\");         scanf(\"%d\",&q->num);         //printf(\"请输入班级：\"); //还要输入班级吗？上面不是已经赋值了吗？         //scanf(\"%s\",&q->classnum);         printf(\"请输入四门课的成绩：\");         scanf(\"%d%d%d%d\",&q->score[0],&q->score[1],&q->score[2],&q->score[3]);         q->next=NULL;          p=head;         if(p==NULL)         {             head=q;         }         else         {             while(p->next!=NULL)             {                 p=p->next;             }             p->next=q;         }         printf(\"学生增加成功！\\n\");          printf(\"你还需要继续输入学生信息吗？(no退出)：\");         scanf(\"%s\",s);     }     while(strcmp(strupr(s),\"NO\")!=0);  }   void DelStud() {     int flag=1;     int num;     printf(\"请输入要删除的学生学号：\\n\");     scanf(\"%d\",&num);     struct stud *p,*q;     p=q=head;     while(p!=NULL&&flag==1)     {         if(p->classnum==num)         {             if(p==head)//删除首节点             {                 head = p->next;                 free(p);             }             else             {                 q->next=p->next;                 free(p);             }             flag=0;             printf(\"删除学生信息成功！\\n\");             return;         }         else         {             q=p;             p=p->next;         }      }     if(flag==1)     {         printf(\"没有找到可以删除的学生学号！\\n\");     } }   void UpdateStud() {     int flag=1;     int num;     printf(\"请输入要修改的学生的学号：\\n\");     scanf(\"%d\",&num);      struct stud *p;     p=head;     while(p!=NULL&&flag==1)     {         if(p->num==num)         {             printf(\"请输入新学号：\\n\");             scanf(\"%d\",&p->num);             printf(\"请输入新姓名：\\n\");             scanf(\"%s\",p->name);             printf(\"请输入新班级：\\n\");             //scanf(\"%s\",p->classnum);             scanf(\"%d\", &p->classnum);             printf(\"请输入新成绩：\\n\");             scanf(\"%d%d%d%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]);             flag=0;             printf(\"学生信息修改操作成功\\n\");         }         else         {             p=p->next;         }      }     if(flag==1)     {         printf(\"没有找到要修改的记录\\n\");     }  } void QueryStud() {     int flag=1;     int num;     struct stud *p;     printf(\"请输入要查询的学号：\\n\");     scanf(\"%d\",&num);     p=head;     while(p!=NULL&&flag==1)     {         if(p->num==num)         {             printf(\"姓名：%s\",p->name);             //printf(\"学号：%d\",&p->num);    //为什么要加&?             printf(\"学号：%d\", p->num);             //printf(\"班级：%s\",p->classnum);             printf(\"班级：%d\",p->classnum);             //printf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]);             printf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\", p->score[0], p->score[1], p->score[2], p->score[3]);             flag=0;         }         else         {             p=p->next;         }     }     if(flag==1)     {         printf(\"没有查询到要查询的信息！\");     } }  /*void StaticStud()   {   }   */ void SaveStud() {     FILE *fp;      if((fp=fopen(\"stud.dat\",\"wb\"))==NULL);//打开文件stud.dat     {         printf(\"文件打开失败\\n\");         return;//打开失败退出     }     struct stud *p;     p=head;     while(p!=NULL)     {         fwrite(p,sizeof(struct stud),1,fp);         p=p->next;     }      fclose(fp);//关闭文件     printf(\"学生信息保存成功！\\n\"); }  //int fileexist(char *filename) int fileexist(const char *filename) {     FILE *fp;     if((fp=fopen(filename,\"rb\"))==NULL)         return 0;     else     {         fclose(fp);         return 1;     } } void load() {     if(fileexist(\"stud.dat\")==0)         return;      FILE *fp;     if((fp=fopen(\"stud.dat\",\"rb\"))==NULL)     {         printf(\"文件打开失败!\\n\");         return;     }      struct stud *p,*q;     p=head;      while(!feof(fp))     {         q=(struct stud *)malloc(sizeof(struct stud));         if(q==NULL)         {             printf(\"申请内存失败!\\n\");             return;         }         fread(q,sizeof(struct  stud),1,fp);         q->next=NULL;          //if(p==NULL)         if(head==NULL)         {             //head=p;             head = q;   //如果把p赋值给head，那么这里是有问题的;             p = q;         }         else         {             while(p->next!=NULL)             {                 p=p->next;             }             p->next=q;         }      }     fclose(fp); }  int main() {     int i;     load();     do     {         printf(\"\\n\\n\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t**       欢迎来到学生信息管理系统      **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t** 1、增加学生信息      2、删除学生信息**\\n\");         printf(\"\\t\\t** 3、修改学生信息      4、查询学生信息**\\n\");         printf(\"\\t\\t** 5、基本信息统计      6、保存学生信息**\\n\");         printf(\"\\t\\t** 7、退出                             **\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"请选择操作：\");         scanf(\"%d\",&i);         switch(i)         {             case 1 : InsertStud();break;             case 2 : DelStud();break;             case 3 : UpdateStud();break;             case 4 : QueryStud();break;                      // case 5 : StaticStud();break;             case 6 : SaveStud();break;             case 7 : break;             default : printf(\"选择错误，请重选\");break;         }     }while(i!=7);     return 0; } 供参考～大佬多谢！！！", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "楼上很厉害啊", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "#include <stdio.h> #include <string.h> #include <malloc.h>  struct stud {     int num;     char name[30];     int classnum;     int score[4];     struct stud *next; };  struct stud *head=NULL;  void InsertStud() {      char s[10];     do     {         int tmp;         printf(\"请输入学号：\\n\");         scanf(\"%d\",&tmp);          struct stud *q,*p;         p=head;          while(p!=NULL)         {             if(p->classnum==tmp)             {                 printf(\"该学生已存在！\\n\");                 return;             }             p=p->next;         }         q=(struct stud*)malloc(sizeof(struct stud));         if(q==NULL)         {             printf(\"申请内存失败\\n\");             return;         }          q->classnum=tmp;         printf(\"请输入姓名：\");         scanf(\"%s\",q->name);         printf(\"请输入学号：\");         scanf(\"%d\",&q->num);         //printf(\"请输入班级：\"); //还要输入班级吗？上面不是已经赋值了吗？         //scanf(\"%s\",&q->classnum);         printf(\"请输入四门课的成绩：\");         scanf(\"%d%d%d%d\",&q->score[0],&q->score[1],&q->score[2],&q->score[3]);         q->next=NULL;          p=head;         if(p==NULL)         {             head=q;         }         else         {             while(p->next!=NULL)             {                 p=p->next;             }             p->next=q;         }         printf(\"学生增加成功！\\n\");          printf(\"你还需要继续输入学生信息吗？(no退出)：\");         scanf(\"%s\",s);     }     while(strcmp(strupr(s),\"NO\")!=0);  }   void DelStud() {     int flag=1;     int num;     printf(\"请输入要删除的学生学号：\\n\");     scanf(\"%d\",&num);     struct stud *p,*q;     p=q=head;     while(p!=NULL&&flag==1)     {         if(p->classnum==num)         {             if(p==head)//删除首节点             {                 head = p->next;                 free(p);             }             else             {                 q->next=p->next;                 free(p);             }             flag=0;             printf(\"删除学生信息成功！\\n\");             return;         }         else         {             q=p;             p=p->next;         }      }     if(flag==1)     {         printf(\"没有找到可以删除的学生学号！\\n\");     } }   void UpdateStud() {     int flag=1;     int num;     printf(\"请输入要修改的学生的学号：\\n\");     scanf(\"%d\",&num);      struct stud *p;     p=head;     while(p!=NULL&&flag==1)     {         if(p->num==num)         {             printf(\"请输入新学号：\\n\");             scanf(\"%d\",&p->num);             printf(\"请输入新姓名：\\n\");             scanf(\"%s\",p->name);             printf(\"请输入新班级：\\n\");             //scanf(\"%s\",p->classnum);             scanf(\"%d\", &p->classnum);             printf(\"请输入新成绩：\\n\");             scanf(\"%d%d%d%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]);             flag=0;             printf(\"学生信息修改操作成功\\n\");         }         else         {             p=p->next;         }      }     if(flag==1)     {         printf(\"没有找到要修改的记录\\n\");     }  } void QueryStud() {     int flag=1;     int num;     struct stud *p;     printf(\"请输入要查询的学号：\\n\");     scanf(\"%d\",&num);     p=head;     while(p!=NULL&&flag==1)     {         if(p->num==num)         {             printf(\"姓名：%s\",p->name);             //printf(\"学号：%d\",&p->num);    //为什么要加&?             printf(\"学号：%d\", p->num);             //printf(\"班级：%s\",p->classnum);             printf(\"班级：%d\",p->classnum);             //printf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\",&p->score[0],&p->score[1],&p->score[2],&p->score[3]);             printf(\"语文成绩：%d 数学成绩：%d 英语成绩：%d 物理成绩：%d\", p->score[0], p->score[1], p->score[2], p->score[3]);             flag=0;         }         else         {             p=p->next;         }     }     if(flag==1)     {         printf(\"没有查询到要查询的信息！\");     } }  /*void StaticStud()   {   }   */ void SaveStud() {     FILE *fp;      if((fp=fopen(\"stud.dat\",\"wb\"))==NULL);//打开文件stud.dat     {         printf(\"文件打开失败\\n\");         return;//打开失败退出     }     struct stud *p;     p=head;     while(p!=NULL)     {         fwrite(p,sizeof(struct stud),1,fp);         p=p->next;     }      fclose(fp);//关闭文件     printf(\"学生信息保存成功！\\n\"); }  //int fileexist(char *filename) int fileexist(const char *filename) {     FILE *fp;     if((fp=fopen(filename,\"rb\"))==NULL)         return 0;     else     {         fclose(fp);         return 1;     } } void load() {     if(fileexist(\"stud.dat\")==0)         return;      FILE *fp;     if((fp=fopen(\"stud.dat\",\"rb\"))==NULL)     {         printf(\"文件打开失败!\\n\");         return;     }      struct stud *p,*q;     p=head;      while(!feof(fp))     {         q=(struct stud *)malloc(sizeof(struct stud));         if(q==NULL)         {             printf(\"申请内存失败!\\n\");             return;         }         fread(q,sizeof(struct  stud),1,fp);         q->next=NULL;          //if(p==NULL)         if(head==NULL)         {             //head=p;             head = q;   //如果把p赋值给head，那么这里是有问题的;             p = q;         }         else         {             while(p->next!=NULL)             {                 p=p->next;             }             p->next=q;         }      }     fclose(fp); }  int main() {     int i;     load();     do     {         printf(\"\\n\\n\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t**       欢迎来到学生信息管理系统      **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"\\t\\t** 1、增加学生信息      2、删除学生信息**\\n\");         printf(\"\\t\\t** 3、修改学生信息      4、查询学生信息**\\n\");         printf(\"\\t\\t** 5、基本信息统计      6、保存学生信息**\\n\");         printf(\"\\t\\t** 7、退出                             **\\n\");         printf(\"\\t\\t**                                     **\\n\");         printf(\"\\t\\t*****************************************\\n\");         printf(\"请选择操作：\");         scanf(\"%d\",&i);         switch(i)         {             case 1 : InsertStud();break;             case 2 : DelStud();break;             case 3 : UpdateStud();break;             case 4 : QueryStud();break;                      // case 5 : StaticStud();break;             case 6 : SaveStud();break;             case 7 : break;             default : printf(\"选择错误，请重选\");break;         }     }while(i!=7);     return 0; } 供参考～", "referer": "user-0"}]}
{"question": "C语言数据结构小问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "这是C++的操作符，可以搜一下C++的引用～和指针功能类似～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这是c++,&还可以代表引用", "referer": "user-0"}]}
{"question": "关于链表的使用问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h> //#include <stdio.h> //#include <stdlib.h>  typedef int ElementType; typedef struct Node *PtrToNode; struct Node {     ElementType Data;     PtrToNode   Next; }; typedef PtrToNode List; List CreatList(int x[],int n); //int* ReArry(int* x,int len); void ReArry(int* x,int len); //int a[1000005],b[1000005];  #define MAX_SIZE        8  int main() {     List l1,l2;     int *a, *b;     int k1=0,k2=0,n;//,k=0;      a = (int *)malloc(sizeof(int) * MAX_SIZE);     if (!a)         exit(0);      while(1)     {         scanf(\"%d\",&n);         if(n==-1)             break;         a[k1++]=n;         if (k1 % MAX_SIZE == 0) {             a = (int *)realloc(a, sizeof(int) * (k1+MAX_SIZE));             if (!a)                 exit(0);         }      }      b = (int *)malloc(sizeof(int) * MAX_SIZE);     if (!b)         exit(0);      while(1)     {         scanf(\"%d\",&n);         if(n==-1)             break;         b[k2++]=n;          if (k2 % MAX_SIZE == 0) {             b = (int *)realloc(b, sizeof(int) * (k2+MAX_SIZE));             if (!b)                 exit(0);         }     }      ReArry(a,k1);     ReArry(b,k2);     l1 = CreatList(a,k1);     printf(\"=====\\n\");     l2 = CreatList(b,k2);      free(a);     free(b);     return 0; }  List CreatList(int x[],int n) {     List L,p,q;      L = (List)malloc(sizeof(struct Node));     p = L;     for(int i = 0 ; i < n; i ++){         printf(\"ok\");         q = (List)malloc(sizeof(struct Node));         if (!q)             exit(0);         q -> Data = x[i];         p->Next = q;         p = q;     }     p -> Next = NULL;     return L; }  //int* ReArry(int *x,int n) void ReArry(int *x,int n) {     int i,j,t;     for(i=0;i<n-1;i++)     {         for(j=i+1;j<n;j++)         {             if(x[i]>x[j])             {                 t = x[i];                 x[i] = x[j];                 x[j] = t;             }         }     }     //return x; } 供参考～   创建链表的部分有问题； 其他个人不很好的地方一并修改了，可以参考一下；", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 1 楼 真相重于对错 的回复:你使用了没有初始化的对象 List CreatList(int x[],int n){ List L,p,q; L = (List)malloc(sizeof(struct Node));//你只在这里malloc p = L;  for(int i = 0 ; i < n; i ++){ printf(\"ok\"); L -> Data = x[i]; q = L; L = L -> Next;//然而在这里的next并没有malloc } L -> Next = NULL; return p; }  这里应该用循环来给L的每个结点分配内存", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你使用了没有初始化的对象 List CreatList(int x[],int n){ List L,p,q; L = (List)malloc(sizeof(struct Node));//你只在这里malloc p = L;  for(int i = 0 ; i < n; i ++){ printf(\"ok\"); L -> Data = x[i]; q = L; L = L -> Next;//然而在这里的next并没有malloc } L -> Next = NULL; return p; }", "referer": "user-0"}]}
{"question": "单链表的合并", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "//合并两个有序的单链表 linklist mergelinklist(linklist LA,linklist LB)     //将递增有序的单链表LA和LB合并成一个递增有序的单链表LC {     node *pa,*pb, *t;     linklist LC,r;     //r=(linklist)malloc(sizeof(node));//多余       //将LC初始值空表，pa和pb分别指向两个单链表LA,LB中的第一个节点，r初值为LC且r永远指向LC的表尾     pa=LA->next;     pb=LB->next;     LC=LA;     LC->next=NULL;     r=LC;       while (pa && pb) {         if (pa->data == pb->data) {             r->next = pa;             r = pa;             pa = pa->next;              t = pb;             pb = pb->next;             free(t);         }         else if (pa->data < pb->data) {             r->next = pa;             r = pa;             pa = pa->next;         } else {             r->next = pb;             r = pb;             pb = pb->next;         }     }     r->next = NULL;      if (pa)         r->next = pa;     if (pb)         r->next = pb;      //当两个标中均未处理完是，比较选择较小的节点插入到新表LC中     /*     while(pa!=NULL&&pb!=NULL)     {         if(pa->data<=pb->data)         {r->next=pa; r=pa; pa=pa->next;}         else         {r->next=pb; r=pb;pb=pb->next;}     }     if(pa)       //若表L未完，将表LA的后续元素链到新表LC的表尾         r->next=pa;     else         //否则将LB中的后续元素链到新表LC表尾         r->next=pb;         */     free(LB);     return LC; } 修改一下r变量不需要申请空间哦。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<malloc.h>  //单链表的定义 typedef int elemtype; typedef struct node {     elemtype data;     struct node *next; }node,*linklist;  //单链表的初始化 void initlist(linklist *l) {     //l=(linklist)malloc(sizeof(node));     //(l)->next=NULL;     (*l)->next=NULL; } //头插法建立单链表 void createfromhead(linklist l) {     node *s;     char c;     //int flag=1;     //while(flag)     while(1)     {         if ((c = getchar()) == '0')             break;         s=(node*)malloc(sizeof(node));         s->data=c;         s->next=l->next;         l->next=s;         /*         c=getchar();         if(c!='0')         {             s=(node*)malloc(sizeof(node));             s->data=c;             s->next=l->next;             l->next=s;         }         else             flag=0;             */         //getchar(); //接收换行符     } } //合并两个有序的单链表 linklist mergelinklist(linklist LA,linklist LB)     //将递增有序的单链表LA和LB合并成一个递增有序的单链表LC {     node *pa,*pb, *t;     linklist LC,r;     r=(linklist)malloc(sizeof(node));       //将LC初始值空表，pa和pb分别指向两个单链表LA,LB中的第一个节点，r初值为LC且r永远指向LC的表尾     pa=LA->next;     pb=LB->next;     LC=LA;     LC->next=NULL;     r=LC;       while (pa && pb) {         if (pa->data == pb->data) {             r->next = pa;             r = pa;             pa = pa->next;              t = pb;             pb = pb->next;             free(t);         }         else if (pa->data < pb->data) {             r->next = pa;             r = pa;             pa = pa->next;         } else {             r->next = pb;             r = pb;             pb = pb->next;         }     }     r->next = NULL;      if (pa)         r->next = pa;     if (pb)         r->next = pb;      //当两个标中均未处理完是，比较选择较小的节点插入到新表LC中     /*     while(pa!=NULL&&pb!=NULL)     {         if(pa->data<=pb->data)         {r->next=pa; r=pa; pa=pa->next;}         else         {r->next=pb; r=pb;pb=pb->next;}     }     if(pa)       //若表L未完，将表LA的后续元素链到新表LC的表尾         r->next=pa;     else         //否则将LB中的后续元素链到新表LC表尾         r->next=pb;         */     free(LB);     return LC; } void PrintList(linklist l) {     linklist p=l->next;     while(p)     {         printf(\"%c\\n\",p->data);         p=p->next;     } } //void main() int main(void) {     linklist LA,LB,LC;     LA= (linklist)malloc(sizeof(node));     LB= (linklist)malloc(sizeof(node));     //LC= (linklist)malloc(sizeof(node));     initlist(&LA);     initlist(&LB);     initlist(&LC);     createfromhead(LA);     PrintList(LA);     createfromhead(LB);     PrintList(LB);     //mergelinklist(LA,LB);     LC = mergelinklist(LA,LB);     PrintList(LC); }  供参考～  链表操作还需要再多下功夫，对比代码找一下自己的问题吧～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "错误不少，LA已经通过malloc初始化了，再在initlist里面malloc有何用？而且initlist参数是node* ,在initlist里面的malloc根本无法影响外边的LA 而且，你的合并是把两个有序的链表合并，但是createfromhead获得的并不是有序链表，合并必然不对", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "@自信男孩 你的那个代码好像不对这，执行结果的时候输不进去数字", "referer": "user-0"}]}
{"question": "c语言求多个数组的共同元素，并返回共同元素数组", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "参考这个试试https://blog.csdn.net/ParrySMS/article/details/78494882?utm_medium=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase&depth_1-utm_source=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "比较笨的方法就是依次比较，就是拿第一行的元素和第二行的比较，找到第一个相同的元素，然后拿第一个相同的和第三行的元素比较，如果在第三行找到相同的，就在和第四行比较，否则从第一行拿一个新元素和第二行比较，也是找到相同（第二个相同的）和第三行的元素比较，找到相同的和第四行比较，依次操作～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "真心求教，谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 4 楼 Clutch_K 的回复:引用 2 楼 自信男孩 的回复:比较笨的方法就是依次比较，就是拿第一行的元素和第二行的比较，找到第一个相同的元素，然后拿第一个相同的和第三行的元素比较，如果在第三行找到相同的，就在和第四行比较，否则从第一行拿一个新元素和第二行比较，也是找到相同（第二个相同的）和第三行的元素比较，找到相同的和第四行比较，依次操作～这样差不多就是取交集的意思吧，两两比较，最后得到所有行的交集？ 恩，对～", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:比较笨的方法就是依次比较，就是拿第一行的元素和第二行的比较，找到第一个相同的元素，然后拿第一个相同的和第三行的元素比较，如果在第三行找到相同的，就在和第四行比较，否则从第一行拿一个新元素和第二行比较，也是找到相同（第二个相同的）和第三行的元素比较，找到相同的和第四行比较，依次操作～这样差不多就是取交集的意思吧，两两比较，最后得到所有行的交集？", "referer": "user-0"}]}
{"question": "小白求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "for example int main(){     int x1,y1,x2,y2,x,y;     scanf(“%d%d”, &x1,&y1);     scanf(“%d%d”, &x2,&y2);     scanf(“%d%d”, &x,&y);     if(x<x1 ll x>x2 || y<y1 || y>y2)          printf(“OUT”);     else         printf(“IN”);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "顶一下Monash", "referer": "user-0"}]}
{"question": "麻烦大佬帮我看一下哪里错了，十分感谢！(数据结构中的循环链表)", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "😂😂，马虎了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "函数调用不能再加返回值类型了。去掉main函数里CreateListF前的void，开始我还以为是函数声明呢，仔细一看是函数调用～", "referer": "user-0"}]}
{"question": "想做一个链表操作的实验报告，求教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "先自己试着写写，遇到问题再提出来～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "自已先写一个最简单的头插和头删吧，这样对链表有一个基本的理解。", "referer": "user-0"}]}
{"question": "C语言编译错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "应该是在一个工程里出现了多个源文件，且这些源文件里有多个main函数定义，错误提示已经很明确了，multiple definition main", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3的回复:你的工程怎么管理的？提示main函数重复定义了。 栈的十进制转换其他进制.c 和 你贴出来的c文件 是什么关系？在同一个工程？ 还有，Stack.h都有啥了？是不是栈的十进制转换其他进制.c引入了该头文件？  把你的工程管理（或文件夹结构）的图贴出来 新建一个项目就可以了", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "重新新建一个工程试试，感觉是你新建工程的问题。 https://jingyan.baidu.com/article/b7001fe1a894c10e7282ddbe.html", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "你的工程怎么管理的？提示main函数重复定义了。 栈的十进制转换其他进制.c 和 你贴出来的c文件 是什么关系？在同一个工程？ 还有，Stack.h都有啥了？是不是栈的十进制转换其他进制.c引入了该头文件？  把你的工程管理（或文件夹结构）的图贴出来", "referer": "user-0"}]}
{"question": "c语言shu'zu", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 5 楼 m0_46244162 的回复:[quote=引用 1 楼 qybao的回复:]你理解的最后一个元素是指哪个？ 比如数组a[5]，最后一个元素是a[4]没问题，可以赋值，但是a[5]就有问题了，数组越界。数组下标是从0-4一共5个元素 大佬请问这个会有例外的情况吗 比如字符串数组不可以 但是整型数组就可以 例如楼下这个回答说的 [/quote] 没有例外，字符串最后的结束符也是自己保证的，你不设，它就没有结束符。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "只要是在数组内，都可以赋值的。建议楼主贴出代码吧，如果出现错误，很可能是越界导致的。在栈上不建议定义大数组～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 qybao的回复:你理解的最后一个元素是指哪个？ 比如数组a[5]，最后一个元素是a[4]没问题，可以赋值，但是a[5]就有问题了，数组越界。数组下标是从0-4一共5个元素 大佬请问这个会有例外的情况吗 比如字符串数组不可以 但是整型数组就可以 例如楼下这个回答说的", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 qybao的回复:你理解的最后一个元素是指哪个？ 比如数组a[5]，最后一个元素是a[4]没问题，可以赋值，但是a[5]就有问题了，数组越界。数组下标是从0-4一共5个元素 大佬 这个会有例外的情况吗 比如字符串数组不可以 整型数组就可以 会有这种情况？？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 user-3的回复:[quote=引用 楼主 m0_46244162 的回复:]请问c语言数组的最后一个元素不能赋值吗  看情况把 整型数组你可以随便赋值  对于字符数组，你也可以将它当成字符串来看，一般字符串结尾都有一个\\0代表结束 通常字符串或者字符数组 都习惯用指针去操作它  用指针操作字符串有一个重要条件：根据末尾是否为\\0来判断指针是否到达字符串结尾 如果你把字符数组的最后一个元素赋值 那你用指针操作这个字符串的时候 很容易出现数组越界的话题  因为你不知道字符串到底结尾了没有[/quote] 可以随便赋值吗？怎么会报错说破坏了栈堆", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 楼主 m0_46244162 的回复:请问c语言数组的最后一个元素不能赋值吗  看情况把 整型数组你可以随便赋值  对于字符数组，你也可以将它当成字符串来看，一般字符串结尾都有一个\\0代表结束 通常字符串或者字符数组 都习惯用指针去操作它  用指针操作字符串有一个重要条件：根据末尾是否为\\0来判断指针是否到达字符串结尾 如果你把字符数组的最后一个元素赋值 那你用指针操作这个字符串的时候 很容易出现数组越界的话题  因为你不知道字符串到底结尾了没有", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "你理解的最后一个元素是指哪个？ 比如数组a[5]，最后一个元素是a[4]没问题，可以赋值，但是a[5]就有问题了，数组越界。数组下标是从0-4一共5个元素", "referer": "user-0"}]}
{"question": "CCF模拟题用C答题不能用for循环吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 m0_51355118的回复:应该是楼上说的，有些比较老的编译器不支持c99，换个编译器就好了，或者把声明放在前面也可以 但那是CCF的模拟题，只提交代码", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "那就在int 一行加个i int i,r.... for(i=1;…", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "楼主的C编译器吧，C++支持for (int i=0;...这样的定义变量方式，C编译器应该是不支持的。（也可能是编译器支持的C标准比较低，不支持C99导致的）  把int i定义在for循环外应该就可以了～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "for (int i = 1; 这样的局部循环变量需要c99支持，不支持的话需要把int i声明提出去", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "报的什么错？", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "应该是楼上说的，有些比较老的编译器不支持c99，换个编译器就好了，或者把声明放在前面也可以", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 m0_51355118的回复:报的什么错？ 编译错误……", "referer": "user-0"}]}
{"question": "大佬看看我，第一次写数据结构，有输入，没输出，不知道哪里错了", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> typedef struct list {     int data;     struct list *next; }link;  void initlist(link *&l,int a[],int n) {     link *p, *tail;//=l;     l = (link*)malloc(sizeof(link));     tail = p = l;     for(int i=0;i<n;i++)     {         p = (link *)malloc(sizeof(link));         if (!p)             exit(0);         p->data = a[i];         tail->next = p;         tail = p;     }     tail->next = NULL; }  int listempty(link *l) {     //return (l->next==NULL);     return (l->next==NULL); }//判断是否是空表 int listlength(link *l) {     int n=0;     link *p=l;     while(p->next!=NULL)     {         n++;         p=p->next;     }     return (n); }//求线性表的长度 void displist(link *l) {     link *p=l->next;     while(p!=NULL)     {         printf(\"%d\",p->data);         p=p->next;     }     printf(\"\\n\"); }//输出线性表 int main() {     int n;     scanf(\"%d\",&n);     link *l;     //int a[n];     int *a = (int *)malloc(sizeof(int) * n);     for(int i=0;i<n;i++)     {         scanf(\"%d\",&a[i]);     }     initlist(l,a,n);     listempty(l);     printf(\"%d\\n\",listlength(l));     displist(l);     return 0; } 供参考～ 链表创建有问题，建议对比代码找一下自己的问题～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "学会单步调试。", "referer": "user-0"}]}
{"question": "请问为static 指针ar的分配内存是否被释放？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "static没什么必要性，这里有没有不影响正确性。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "刚才查c primer plus 里面讲的比较明确，free 释放可以不是malloc 申请内存是的指针变量，只要free的参数指针是申请时的地址即可。然后做了猜想系统记录了malloc申请的地址及大小信息，刚刚又在网上找到一段话也验证了自己的猜想，“为什么可以正确的释放正确大小的地址，有的编译器会这样操作，malloc会在首地址前8个字节的高4存放page id,低4存放size，free可以从这里取到dao存的大小，依赖编译器的不同实现方法不同，仅供你参考。 ” 另外上面的程序 可以不用static 修饰，也可以正确执行。如果在test中用数组，必须使用static，但是static又不支持变长数组。这时候必须使用指针来分配内存的方式实现。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "程序运行期间不会释放，也就是它指代的地址不会再变了，内容可能会变，但指代的地址不会变", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "楼主用static定义的是arr指针变量，这只是说明指针变量不会随着函数调用结束而释放，应arr变量是在数据段申请的，它的生命周期是从定义开始知道程序退出。但是这和malloc没关系哦。这个指针指向的内容是可以变化的。", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "已经被释放了，你可以输出其内容看一下 #include <stdio.h> #include <malloc.h> int *test(int); int main() {    int *p = NULL;    int *d = NULL;    int b = 5;    printf(\"\\n%d %d\\n\",d,p);    scanf(\"%d\", &b);    d = p = test(b);    for (int i = 0; i < b; i++){       printf(\"%d \", *(p));    }    printf(\"\\n%d %d %d %d\\n\",d,p,*d,*p);    free(d);    printf(\"\\n%d %d %d %d\\n\",d,p,*d,*p);    return 0; }  int *test(int b) {    static int *ar;    ar = (int *)malloc(sizeof(int) * b);    for (int i = 0; i < b; i++)       ar[i] = i;    printf(\"%d %d\\n\",ar,*ar);    return ar; }   结果如下： 0 0 3 42604304 0 0 0 0 42604304 42604304 0 0  42604304 42604304 42603968 42603968", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "引用 楼主 学码就是爱好 的回复:请问为static 指针ar的分配内存是否被释放？ #include <stdio.h> #include <malloc.h> int *test(int); int main() {     int *p=NULL;     int *d=NULL;     int b=5;     scanf(\"%d\",&b);     d=p=test(b);     for(int i=0;i<b;i++)     printf(\"%d \",*p++);     free(d);     return 0; }  int *test(int b) {    static int *ar;    ar=(int *)malloc(sizeof(int)*b);     for(int i=0;i<b;i++)         ar[i]=i;     return ar; }  你在main中的free就是释放，虽然是在test函数中malloc，没毛病", "referer": "user-0"}, {"cid": "7", "user": "user-6", "content": "调试一下, 我觉得是被释放了..因为三个指针都是指向的都是同一个区域.", "referer": "user-0"}, {"cid": "8", "user": "user-7", "content": "会 main的d和test的ar指向同一块内存，释放d就等于释放ar", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 7 楼 自信男孩 的回复:楼主用static定义的是arr指针变量，这只是说明指针变量不会随着函数调用结束而释放，应arr变量是在数据段申请的，它的生命周期是从定义开始知道程序退出。但是这和malloc没关系哦。这个指针指向的内容是可以变化的。 提问时没主意static的必要性，后面我自己跟的帖子已经对相关问题进行了说明，另外关于释放也做了解释，c primer plus 的内容提问时还没看到，后来发现书上描写的很明确。不过还是感谢答疑", "referer": "user-0"}]}
{"question": "VS2017显示触发一个断点，但并没有任何其他提示", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:conver *node = (conver *)malloc(sizeof(node)); 这儿的node指向的内容申请的空间长度是sizeof(conver *);改成这样：  conver *node = (conver *)malloc(sizeof(*node)); 但是不建议这样写，因为不很容易理解，不能一眼看出，可以改成这样  conver *node = (conver *)malloc(sizeof(conver)); 谢谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 user-2的回复:改成 covert *node = (covert*)malloc(sizeof(conver));  node是个指针，sizeof(node)只有4个字节（64位系统是8个字节），convert是个结构体，sizeof(convert)有8+4（或8）=12（或16）个字节。 显然，申请内存空间不足，就可能造成内存非法访问。 那为什么前面的那个main函数里的malloc没有出错呢", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "conver *node = (conver *)malloc(sizeof(node)); 这儿的node指向的内容申请的空间长度是sizeof(conver *);改成这样：  conver *node = (conver *)malloc(sizeof(*node)); 但是不建议这样写，因为不很容易理解，不能一眼看出，可以改成这样  conver *node = (conver *)malloc(sizeof(conver));", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 user-2的回复:[quote=引用 4 楼 MancoCL 的回复:][quote=引用 2 楼 user-2的回复:]改成 covert *node = (covert*)malloc(sizeof(conver));  node是个指针，sizeof(node)只有4个字节（64位系统是8个字节），convert是个结构体，sizeof(convert)有8+4（或8）=12（或16）个字节。 显然，申请内存空间不足，就可能造成内存非法访问。 那为什么前面的那个main函数里的malloc没有出错呢[/quote] 我之所以用了可能这个词，就是说它未必就会运行出错，但一定是危险行为。指针指向的内存空间不够，就好比 数组越界 一样，越界出去的内存操作，会带来什么影响是不确定的，如果越界出去的内存是不允许读写的，就会造成非法访问；即使是可读写的，也会造成该内存的数据破话（不是你自己的东西你却修改了），这样是非常危险的。所以要按照正确的使用大小来分配内存。 [/quote] 明白了，谢谢大佬啊", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 4 楼 MancoCL 的回复:[quote=引用 2 楼 user-2的回复:]改成 covert *node = (covert*)malloc(sizeof(conver));  node是个指针，sizeof(node)只有4个字节（64位系统是8个字节），convert是个结构体，sizeof(convert)有8+4（或8）=12（或16）个字节。 显然，申请内存空间不足，就可能造成内存非法访问。 那为什么前面的那个main函数里的malloc没有出错呢[/quote] 我之所以用了可能这个词，就是说它未必就会运行出错，但一定是危险行为。指针指向的内存空间不够，就好比 数组越界 一样，越界出去的内存操作，会带来什么影响是不确定的，如果越界出去的内存是不允许读写的，就会造成非法访问；即使是可读写的，也会造成该内存的数据破话（不是你自己的东西你却修改了），这样是非常危险的。所以要按照正确的使用大小来分配内存。", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "改成 covert *node = (covert*)malloc(sizeof(conver));  node是个指针，sizeof(node)只有4个字节（64位系统是8个字节），convert是个结构体，sizeof(convert)有8+4（或8）=12（或16）个字节。 显然，申请内存空间不足，就可能造成内存非法访问。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "补充：在点击继续后显示——0x76FAFA1D (ntdll.dll) (数据结构实验二.exe 中)处有未经处理的异常: 0xC0000374: 堆已损坏。 (参数: 0x76FEB960)。", "referer": "user-0"}]}
{"question": "scanf格式字符为%f，但输入为符号时变死循环", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢各位的帮助，我现在对scanf又多了一些理解，现更正代码如下，再也不怕故意输错了 #include <stdio.h>  int main() { \tdouble d1,d2,d3; \tunsigned char op,noError=1;  \twhile(1) \t{ \t\tprintf(\"请输入算式，如3+2等：\");  \t\twhile(scanf(\"%lf%c%lf\",&d1,&op,&d2)!=3) //scanf的返回值为正确获取的数据的个数量 \t\t{ \t\t\tprintf(\"输入错误，请输入包含两个数的算式，如3+2等：\"); \t\t\trewind(stdin);\t//当输错式子时，清空输入缓存，以免死循环 \t\t}  \t\trewind(stdin);\t\t//当故意输入超过两个数的算式时，不清空缓存会导致下一次计算出错  \t\tswitch(op) \t\t{ \t\t\tcase '+':d3=d1+d2;break; \t\t\tcase '-':d3=d1-d2;break; \t\t\tcase '*':d3=d1*d2;break; \t\t\tcase '/':\tif(d2!=0) \t\t\t\t\t\t\t\t\td3=d1/d2; \t\t\t\t\t\t\t\telse \t\t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\t\tprintf(\"除数不能为0！\\n\"); \t\t\t\t\t\t\t\t\tnoError = 0; \t\t\t\t\t\t\t\t} \t\t\t\t\t\t\t\tbreak; \t\t\tdefault :printf(\"输入错误，请重新输入！\");noError = 0; \t\t} \t\tif(noError) \t\t\tprintf(\"%-5.2f%c%-5.2f=%-5.2f\\n\",d1,op,d2,d3);  \t\tnoError = 1; \t}   return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "输入格式校验的水很深！ 我预测AI在10年内都搞不定。 程序员都因此而不会失业。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "再供参考：#include <stdio.h> char s[]=\"123 ab 4\"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,\"%d%n\",&v,&n);         printf(\"k,v,n=%d,%d,%d\\n\",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf(\"skip char[%c]\\n\",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf(\"End.\\n\"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "简单点说意思大概是这样的：scanf 想要一个固定格式的输入， 但是你输入错误了，所以第一次循环的时候，scanf 并没有消耗掉你输入的字符串，那么你输入的错误字符串仍然存在，并且等待被消耗，这个时候你的 while 又开始循环了，也就是你每一次循环，scanf 都在你输入的错误字符串中寻找答案，但是都没有找到， 于是错误的字符串还在输入缓存里，rewind 大概的意思，把输入缓存（实际上是输入流，输入缓存是为了方便你理解，两者差别很大）清空，这样scanf 发现输入缓存中没有东西，它就会等待你的再次输入", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "&op,后面是得加1,", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 赵4老师的回复:#include <stdio.h>  int main() {     double d1,d2,d3;     unsigned char op,noError;      while(1) {         printf(\"请输入算式，如3+2等(Ctrl-C退出)：\");         rewind(stdin);         if (3==scanf_s(\"%lf%c%lf\",&d1,&op,&d2)) {             noError=1;             switch (op) {             case '+':d3=d1+d2;break;             case '-':d3=d1-d2;break;             case '*':d3=d1*d2;break;             case '/':                 if (d2!=0) {                     d3=d1/d2;                 } else {                     printf(\"除数不能为0！\\n\");                     noError=0;                 }             break;             default:                 printf(\"输入错误，请重新输入！\\n\");                 noError=0;             }             if (noError) printf(\"%-5.2lf%c%-5.2lf=%-5.2lf\\n\",d1,op,d2,d3);         } else {             printf(\"输入错误，请重新输入！\\n\");         }     }      return 0; }  看不懂（＃－.－）我是初学者一个我先去百度一下rewind是干啥的", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:scanf_s(\"%lf%c%lf\",&d1,&op, 1, &d2); 缺少一个参数。因为%c需要指定内存大小；  输入的格式需要注意下，因为中间是%c，因此d1和d2之间只能有一个字符，多余一个字符这个结果就不一样了，建议在scanf_s下面打印一天语句把d1, op, d2打出来和你的输入对比一下 我不明白为什么输错后，进入下一次循环时，似乎没有执行scanf语句——输错了也只是这一次错了，在下一次循环时应该是重新等待输入啊", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "#include <stdio.h>  int main() {     double d1,d2,d3;     unsigned char op,noError;      while(1) {         printf(\"请输入算式，如3+2等(Ctrl-C退出)：\");         rewind(stdin);         if (3==scanf_s(\"%lf%c%lf\",&d1,&op,&d2)) {             noError=1;             switch (op) {             case '+':d3=d1+d2;break;             case '-':d3=d1-d2;break;             case '*':d3=d1*d2;break;             case '/':                 if (d2!=0) {                     d3=d1/d2;                 } else {                     printf(\"除数不能为0！\\n\");                     noError=0;                 }             break;             default:                 printf(\"输入错误，请重新输入！\\n\");                 noError=0;             }             if (noError) printf(\"%-5.2lf%c%-5.2lf=%-5.2lf\\n\",d1,op,d2,d3);         } else {             printf(\"输入错误，请重新输入！\\n\");         }     }      return 0; }", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "scanf_s(\"%lf%c%lf\",&d1,&op, 1, &d2); 缺少一个参数。因为%c需要指定内存大小；  输入的格式需要注意下，因为中间是%c，因此d1和d2之间只能有一个字符，多余一个字符这个结果就不一样了，建议在scanf_s下面打印一天语句把d1, op, d2打出来和你的输入对比一下", "referer": "user-0"}]}
{"question": "找不到错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-2 的回复:while (a > 0)     {         a = n;         b = a % m;         a = a / m;         s.push(b);     } n不变  则a不变  则a/m不变  则死循环  则无限push  则越界  则引发异常 引用 3 楼 自信男孩 的回复: while (a > 0)     {         a = n;   //这条语句为什么要在这里赋值，在while外已经赋值了。因为n没有做修改，因此每次a都会被赋值初始值，这样就会导致死循环。         b = a % m;         a = a / m;         s.push(b);     }  糊涂了，谢谢大佬", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "while (a > 0)     {         a = n;   //这条语句为什么要在这里赋值，在while外已经赋值了。因为n没有做修改，因此每次a都会被赋值初始值，这样就会导致死循环。         b = a % m;         a = a / m;         s.push(b);     }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "哦 漏了m不变", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "while (a > 0)     {         a = n;         b = a % m;         a = a / m;         s.push(b);     } n不变  则a不变  则a/m不变  则死循环  则无限push  则越界  则引发异常", "referer": "user-0"}]}
{"question": "本人初学者，两个问题求解答，谢谢。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "#include <stdio.h> int main(int argc,char*argv[]) { \tfloat a,b,c; \tscanf(\"%f %f\",&a,&b); \tb=b*10; \tb=(int)b/50; \tif(a<=3) \t\tc=10+b*1.8;     else \t{ \t\ta=(a-3)*10; \t\ta=(int)a/5; \t\tc=10+b*1.8+a*0.9; \t} \t    printf(\"%.2f\\n\",c); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "引用 7 楼 自信男孩 的回复:[quote=引用 4 楼 千梦一生 的回复:] 要能解答就解答，不能说那么多无用的做啥？不明白的地方，可以做一下引导，不用把自己放在高高在上的位置上，总是俯视别人，先正视一下自己的位置吧[/quote]  引用 5 楼 gezi2333 的回复:看清楚再说好吗？初学者是才开始学习的人的意思，我是希望有人帮我解决问题的，不是要你来骂人的。 实际上我没有骂人，我就是这么想的这么说的。 论坛上这样的人太多了，仍一道题出来就走。布置作业呢？  我说这么多是仍楼主好好想想这个问题。 我没必要俯视谁。  楼主说的初学者意思我也认识到了仅仅是初学的意思。 我只是借学者这个个名词与楼主说说（我个人认为的）他的问题。  授人以渔不如授人以渔。这是一个普遍认可的观点。 ------------------------------------------------------------------ 不过说的话从结果上你确实是引起了两位的不适，那说明我的言论中确实是存在问题。以后应当在言辞说法上多计较、考量一番。 ------------------------------------------------------------------ 楼主回一句。1.我无意侮辱或骂你。2.像你这种帖子不少我过去都不愿回复的。但这次回复了你，其中有无道理你可选择自行参考。 回这楼上一句。我并无高高在上之意。我回头看了一下。那一楼回复中不扣否认参杂了两点：1.是经久以来对这种布置作业的贴的气郁。2.回复的字面意思就是让楼主说说学习上遇到了什么困难，而不是过来布置老师给他布置的作业的。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "帮你解决问题是因为你代码出现了bug,不知道如何解决，然后我们才可以帮你，直接给个题目，这是出题老师？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 4 楼 千梦一生 的回复:既然是学者，那学到了什么？ 如果学习时有困难学不到。 学习上遇到的困难是什么？ 你这是出题老师，不是学者 不要侮辱学者这两个字。 要能解答就解答，不能说那么多无用的做啥？不明白的地方，可以做一下引导，不用把自己放在高高在上的位置上，总是俯视别人，先正视一下自己的位置吧", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "看清楚再说好吗？初学者是才开始学习的人的意思，我是希望有人帮我解决问题的，不是要你来骂人的。", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "既然是学者，那学到了什么？ 如果学习时有困难学不到。 学习上遇到的困难是什么？ 你这是出题老师，不是学者 不要侮辱学者这两个字。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "代码呢？一行代码都没有呢～", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "问题就是将这个题目的要求用c语言写出来，能够满足题目要求", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "然后呢，问题是啥，你这是题目啊", "referer": "user-0"}]}
{"question": "结构体定义", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "请参考《C++中typedef与const、指针》 希望能够帮到您！", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 楼主 肥牛肉^*^ 的回复:typedef struct｛ int a； int b； ｝stu；这样为什么可以定义，struct后面没有结构体名呀，这个和struct｛int a；                                    int b；                                  ｝stu；有什么区别吗 struct后面的是结构体标号，是可以省略的 typedef struct｛ int a； int b； ｝stu；---> stu是结构体类型 stu abc; ---> abc是结构体变量名  struct｛int a；              int b； ｝stu；---> stu是结构体变量名 其类型为 struct｛int a；              int b； ｝;", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "typedef struct｛ int a； int b； ｝stu; //是自定义类型，红色部分是原来的类型（是一个匿名结构体），蓝色部分是新类型（是个类型名字），新类型（名字）等价于原来的（结构体）类型  struct｛ int a； int b； ｝stu; // 是变量声明，红色变量是类型（匿名结构体，也就是没名字的结构），蓝色部分是变量", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "不建议这么定义，结构体不宜阅读～", "referer": "user-0"}]}
{"question": "关于二叉树中序线索化的函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：#include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点     char data;                      //数据     struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树     char data;     scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树     if (data == '#') {         *T = NULL;     } else {         *T = (BiTree)malloc(sizeof(BiTNode)); nn++;         (*T)->data = data;         //生成根结点         CreateBiTree(&(*T)->lchild);//构造左子树         CreateBiTree(&(*T)->rchild);//构造右子树     }     return 0; } void Visit(BiTree T) {//输出     if (T->data != '#') {         printf(\"%c \",T->data);     } } void PreOrder(BiTree T) {//先序遍历     if (T != NULL) {         Visit(T);               //访问根节点         PreOrder(T->lchild);    //访问左子结点         PreOrder(T->rchild);    //访问右子结点     } } void InOrder(BiTree T) {//中序遍历     if (T != NULL) {         InOrder(T->lchild);     //访问左子结点         Visit(T);               //访问根节点         InOrder(T->rchild);     //访问右子结点     } } void PostOrder(BiTree T) {//后序遍历     if (T != NULL) {         PostOrder(T->lchild);   //访问左子结点         PostOrder(T->rchild);   //访问右子结点         Visit(T);               //访问根节点     } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             printf(\"%c \",p->data);  //访问根节点             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             p = p->rchild;          //访问右子树         }     }     free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。     BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree));     int sp=0;     BiTree p = T;//p是遍历指针     while (p || sp) {   //栈不空或者p不空时循环         if (p != NULL) {             stack[sp]=p;sp++;       //存入栈中             p = p->lchild;          //遍历左子树         } else {             sp--;p=stack[sp];       //退栈             printf(\"%c \",p->data);             p = p->rchild;          //访问右子树         }     }     free(stack); }  typedef struct BiTNodePost{     BiTree biTree;     char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归)     BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost));     int sp=0;     BiTree p = T;//p是遍历指针     BiTreePost BT;     while (p != NULL || sp) {//栈不空或者p不空时循环         while (p != NULL) {//遍历左子树             BT = (BiTreePost)malloc(sizeof(BiTNodePost));             BT->biTree = p;             BT->tag = 'L';//访问过左子树             stack[sp]=BT;sp++;       //存入栈中             p = p->lchild;         }         while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点             sp--;BT=stack[sp];        //退栈             printf(\"%c \",BT->biTree->data);             free(BT);         }         if (sp) {//遍历右子树             BT=stack[sp-1];             BT->tag = 'R';//访问过右子树             p = BT->biTree;             p = p->rchild;         }     }     free(stack); } void LevelOrder(BiTree T) {//层次遍历     BiTree p;     BiTree *queue;     int h=0,t=0,n=0;      if (T == NULL) return;     p=T;     queue=(BiTree *)malloc(nn*sizeof(BiTree));     queue[t]=p;t=(t+1)%10;n++;//根节点入队     while (n) {    //队列不空循环         p=queue[h];             //对头元素出队         printf(\"%c \",p->data);  //访问p指向的结点         h=(h+1)%10;n--;         //退出队列         if (p->lchild != NULL) {//左子树不空，将左子树入队             queue[t]=p->lchild;t=(t+1)%10;n++;         }         if (p->rchild != NULL) {//右子树不空，将右子树入队             queue[t]=p->rchild;t=(t+1)%10;n++;         }     }     free(queue); } int main() {     BiTree T;      setlocale(LC_ALL,\"chs\");     CreateBiTree(&T);      printf(\"先序遍历        ：\");PreOrder  (T);printf(\"\\n\");     printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"中序遍历        ：\");InOrder   (T);printf(\"\\n\");     printf(\"中序遍历(非递归)：\");InOrder2  (T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"后序遍历        ：\");PostOrder (T);printf(\"\\n\");     printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\");                                                printf(\"\\n\");     printf(\"层次遍历        ：\");LevelOrder(T);printf(\"\\n\");      return 0; } //ABC##DE#G##F### //先序遍历        ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历        ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历        ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历        ：A B C D E F G //  ///       A ///      / ///     B ///    / \\ ///   C   D ///      / \\ ///     E   F ///      \\ ///       G", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "要判定，我猜。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 楼主 weixin_45906870 的回复:typedef enum{Link, Thread} PointerTag; //Link==0 表示指向左右孩子指针 //Thread==1 表示指向前驱或后继的线索  struct TreeNode{     int data;     struct TreeNode *left, *right;     PointerTag LTag, RTag; };  struct TreeNode *pre; //全局变量  void InThreading(struct TreeNode *p){     if (p){         InThreading(p->left);    //递归左子树线索化         if (!p->left){             p->LTag = Thread;             p->left = pre;         }         if (pre && !pre->right){             pre->RTag = Thread;             pre->right = p;         } //我对这个函数的理解应该是没有问题的，但是我在《大话数据结构》上看到作者把这个函数中的一部分改成下面红色字体的那样，没有加上pre为真这个判定条件，结果搞得我一头雾水。我想问的是，改下下面红色字体那样子的话是对的吗？为什么？在判定pre->right为假之前是否要先判定pre为真？  /*         if (!pre->right){             pre->RTag = Thread;             pre->right = p;         }         */         pre = p;         InThreading(p->right);  //递归右子树线索化     } } 那就看pre是否赋过初始值，如果赋过就没问题 因为后面的 pre = p; 是在 if(p)的前提下（也就是p不为NULL的前提下）赋值的，所以后面的递归不会导致 pre 为NULL", "referer": "user-0"}]}
{"question": "求助，请问我这个为什么没达到想要的目的？（自行输入两个多项式并求和并输出）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> //#include \"List.h\" #include <stdlib.h> #include <math.h> #include <unistd.h>  struct Node; struct PN; typedef struct Node Node; typedef struct PN ElemType; typedef struct Node* Polynomial; typedef struct Node *List;//List L == Node *p; typedef Node* Position; int Is( ElemType a, ElemType b ); int IsEmpty( List L ); int IsLast( Position p, List L ); Position Find( ElemType X, List L ); void Delete( ElemType X, List L); void Insert( ElemType X, List L, Position P ); List InitList(); ElemType InitPN(); Polynomial CreatePolynomial( int n ); Polynomial AddPolynomial( Polynomial Pa, Polynomial Pb); void PrintPN( Polynomial PN );  //程序： //#include <stdio.h> //#include \"List.h\" // struct PN {     double coef;     int expn; };   struct Node {     ElemType data;     //struct LNode *next;     struct Node *next; };  int main() {     Polynomial Pa,Pb,Pc;      Pa = CreatePolynomial( 2 );     PrintPN( Pa );      Pb = CreatePolynomial( 3 );     PrintPN( Pb );      Pc = AddPolynomial( Pa, Pb );     PrintPN(Pc);      return 0; }     int IsEmpty( List L )//测试链表L是否为空表 {     return L -> next == NULL; }  int IsLast( Position p, List L )//此元素是否为表中最后一个元素 {     return p -> next == NULL; }  Position Find( ElemType X, List L ) {     Position P;      for( P = L; P; P = P->next)     {         if(Is( P -> data, X))         {             printf(\"Find it!\");             break;         }     }     //if( P = NULL ) printf(\"Can't Find!\");     if( P == NULL ) printf(\"Can't Find!\");      return P; }  int Is( ElemType a, ElemType b ) {     int bool_val = 0;     if( a.coef == b.coef && a.expn == b.expn )         bool_val = 1;     else         bool_val = 0;      return bool_val; }  void Delete( ElemType X, List L) {     Position P, TmpCell;      P = Find( X, L );      if( P != NULL )     {         TmpCell = P;          P = P->next;          free(TmpCell);     } }  void Insert( ElemType X, List L, Position P ) {     Position TmpCell;      TmpCell = (Position)malloc( sizeof( struct Node ) );      if( TmpCell == NULL )     {         printf( \"Out of Space\" );     }      TmpCell -> next = P -> next;     P -> next = TmpCell; }//要保证TmpCell非NULL  List InitList() {     List L;      L = (List)malloc( sizeof( struct Node ) );      L->data = InitPN();      L->next = NULL;      return L; }  ElemType InitPN() {     ElemType PN;     PN.coef = 0;     PN.expn = 0;      return PN; }  struct PN CreatPN() {     ElemType PN;      printf( \"请输入系数、项数：\");     scanf( \"%lf %d\", &PN.coef, &PN.expn);      return PN; }  Polynomial CreatePolynomial( int n ) {     List L = InitList();     Position P = L;       for( int i = 1; i <= n; i++)     {         Position s = (Position)malloc( sizeof( struct Node ) );          printf( \"请输入系数、项数: \");         scanf(\"%lf %d\", &s -> data.coef, &s -> data.expn);         Position pre = L, q = L -> next;           while( q && q -> data.expn < s -> data.expn)         {             pre = q;             q = q -> next;         }         s -> next = q;         pre -> next = s;      }      return L; }  Polynomial AddPolynomial( Polynomial Pa, Polynomial Pb) { #if 0     Polynomial p1, p2, p3, r;      p1 = Pa->next;     p2 = Pb->next;     p3 = Pa;       while (p1 && p2) {         if (p1->data.expn == p2->data.expn) {             p1->data.coef += p2->data.coef;              if (fabs(p1->data.coef) < 1e-6) { //equal 0                 r = p1;                 p1 = p1->next;                 free(r);                 r = p2;                 p2 = p2->next;                 free(r);             } else {                 r = p1;                 p3->next = r;                 p3 = r;         printf(\"%.1lf\\n\", p3->data.coef);                 p1 = p1->next;                 r = p2;                 p2 = p2->next;                 free(r);             }         } else if (p1->data.expn < p2->data.expn) {             p3->next = p1;             p3 = p1;         printf(\"%.1lf\\n\", p3->data.coef);             p1 = p1->next;         } else {             p3->next = p2;             p3 = p2;         printf(\"%.1lf\\n\", p3->data.coef);             p2 = p2->next;         }          //printf(\"p1: %p, p2: %p, p3: %p\\n\", p1, p2, p3);     }     p3->next = NULL;      if (p1)         p3->next = p1;     if (p2)         p3->next = p2; #else     Position p1 = Pa -> next, p2  = Pb -> next;     Position p3 = Pa;      while( p1 && p2 )     {         if ( p1 -> data.expn == p2 -> data.expn)         {             double sum = p1 -> data.coef + p2 -> data.expn;              //if( sum != 0 )             if( fabs(sum) > 1e-6)             {                 printf(\"sum = %.1lf\\n\", sum);                 p1 -> data.coef = sum;                 p3 -> next = p1;   //加上这句                 p3 = p1;                 p1 = p1->next;                 Position r = p2;                 p2 = p2 -> next;                 free( r );             }             else             {                 Position r1 = p1, r2 = p2;                 p1 = p1 -> next;                 p2 = p2 -> next;                 free( r1 );                 free( r2 );             }          }         else if (p1 -> data.expn < p2 -> data.expn)         {             Position r = p1;             p3->next = r;             p3 = r;             p1 = p1->next;         }         else         {             p3 -> next = p2;             p3 = p2;             p2 = p2 ->next;         }     }     p3->next = NULL;      if (p1)         p3->next = p1;     if (p2)         p3->next = p2;     /*     if( p1 == NULL )     {         p3 -> next = p2;     }     else     {         p3 -> next = p1;     }     */      free( Pb ); #endif     return( Pa ); }  void PrintPN( Polynomial PN ) {     int cnt = 1;     for( Position p = PN->next; p; p = p -> next )     {         //printf(\"%fX^%d + \", PN -> data.coef, PN -> data.expn );         //printf(\"%lfX^%d + \", PN -> data.coef, PN -> data.expn);         printf(\"%.1lfX^%d + \", p-> data.coef, p-> data.expn);         if( cnt % 5 == 0)         {             printf( \"\\n\" );         }         cnt++;     }     putchar(10); } 供参考～  建议找一下自己的问题～", "referer": "user-0"}]}
{"question": "构造线性表过程  有错误改不处  求指教", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "楼主的编译器应该是C，而不是C++，因为&是C++的语法符号，C语言编译器不识别和支持。  可以考虑用指针代替&", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "你这是c语言，还是c++呢？ 如果是c，他没有引用，因此Sqlist& 这句是错误的", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "最好把你的代码贴出来 图片无法判断某些具体内容 比如L.length = 0 我瞅着分号像是中文的", "referer": "user-0"}]}
{"question": "数字可能出现重复了，但我没发现逻辑错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "换个思路，先按元素循环，再查找该元素是否与另外两个不同元素的和相等，就可以避免重复了  int main() {     char testdata[]={\"5 0 5 1 4 2 3\"}, *p=testdata; //用于测试     int n, i, j, k, cnt=0, *a;     //scanf(\"%d\", &n);     n = 7; //用于测试     a = (int*)malloc(sizeof(int)*n);     for(i=0; i<n; i++) { //输入数据         //scanf(\"%d\", &a[i]);         sscanf(p, \"%d\", &a[i]); p=strstr(p, \" \")+1;     }     for(i=0; i<n; i++) { //换一下处理位置，先按元素循环         for (j=0; j<n-1; j++) { //再判断该元素是否与另外两个不同元素的和相等             if(j==i) continue;             for (k=j+1; k<n; k++) {                  if (k==i) continue;                 if (a[j]+a[k]==a[i]) {                     printf(\"%d=%d+%d\\n\", a[i], a[j], a[k]);                     cnt++;                     break;                 }             }             if (k<n) break;         }     }     printf(\"total: %d\\n\", cnt);     free(a);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "有重复是因为上面程序， 在查找数字时， 比如，一个数， 可以有多种满足的数字， 例如： 5 = 2 + 3  也可以时 5 = 1+4 这样 count 会加两次， 但题目只要求计算5是否可以表示， 相当于只要求count+1", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include<stdio.h> #include <stdlib.h> #include<math.h>  int main() {     int n, sum, count=0;//,j,b,i;     int i, j, k;     int *arr;     scanf(\"%d\",&n);      arr = (int *)malloc(sizeof(int) * n);     if (!arr)         return -1;      for(i=0;i < n; i++)         scanf(\"%d\", &arr[i]);       for (i = 0; i < n; i++)         for (j = i+1; j < n; j++) {             sum = arr[i] + arr[j];              for (k = 0; k < n; k++) {                 if (sum == arr[k] && k != i && k != j) {                     printf(\"%d + %d = %d\\n\", arr[i], arr[j], arr[k]);                     count++;                 }             }         }  #if 0     for(i=0;i<n;i++)         for(j=0;j<n;j++)         {             if(j==i)                 continue;              for(b=j+1;b<n;b++)             {                 if(b==i)                     continue;                 if(a[i]==a[j]+a[b])                      count++;                }         } #endif     printf(\"%d\\n\",count);     free(arr);      return 0; } 供参考～", "referer": "user-0"}]}
{"question": "大佬帮忙看一下这个c数据结构单链表", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "问题太多了 main函数中Init_List(t, k); k是int型的 void Init_List(Node &L, Elemtype &n)为什么变成了地址  这个函数中 L->next = NULL; L->next = s;   给空指针赋值？？  void input(Node L) {     Node s, j;     printf(\"单表输入cur值：\\n\");     int x;     L->next = s;     j = s;     while (s != NULL)     {         scanf(\"%d\", &x);         s->cur = x;         j = s->next;          s = j;     }   s未初始化 怎么拿来做判断？  其他的懒得检查了  你再看看自己到底想干什么 搞清楚每个函数你的目的", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h>  typedef int Elemtype;  typedef struct List {     Elemtype cur;     struct List *next; }sqlist, *Node;  void Init_List(Node &L,Elemtype &n) {     Node s,k;     int i;      L = (Node)malloc(sizeof(sqlist));     L->next=NULL;     printf(\"请创表的长度:\\n\");     scanf(\"%d\", &n);      /*     s=(Node)malloc(sizeof(sqlist));     s->next=L->next;     */      k = L;     for(i=0;i<n;i++)     {          s=(Node)malloc(sizeof(sqlist));         k->next=s;         k=s;     }     k->next=NULL; } //Node Insert(Node &L,Node k,Node j) Node merge(Node &L,Node a, Node b) {     Node p, q, s, t;     L=(Node)malloc(sizeof(sqlist));     L->next=NULL;     printf(\"开始进行合并\\n\");      p = a->next;     q = b->next;     s = L;     while (p && q) {         if (p->cur < q->cur) {             s->next = p;             s = p;             p = p->next;         } else if (p->cur > q->cur) {             s->next = q;             s = q;             q = q->next;         } else {             s->next = p;             s = p;             t = q;             q = q->next;             p = p->next;             free(t);         }     }     s->next = NULL;     if (p) {         s->next = p;     }     if (q) {         s->next = q;     }     a->next = NULL;     b->next = NULL;      return L;     /*     L=(Node)malloc(sizeof(sqlist));     L->next=NULL;     printf(\"开始进行合并\\n\");     Node p,q,a,c,h;     k->next=p;     q=p;     j->next=a;     c=a;     if(p->cur>a->cur){L->next=p;p=q->next;q=p;}     else{L->next=a;a=c->next;c=a;}     h=L->next;        while(p!=NULL&&a!=NULL)     {         q=p->next;         c=a->next;         if(p->cur>a->cur){h->next=p;h=p;p=q;q=p->next;}         else{h->next=a;h=a;a=c;c=a->next;}     }     return(L);     */ } void order(Node &L) {     Node p,q,r;     Elemtype tmp;       p = L->next;      printf(\"进行排序：\\n\");     while (p) {         q = p->next;          while (q) {             if (p->cur > q->cur) {                 tmp = p->cur;                 p->cur = q->cur;                 q->cur = tmp;             }             q = q->next;         }         p = p->next;     }  #if 0     printf(\"进行排序：\\n\");     p=L->next;     int t=0;     while(p!=NULL)     {         q=p->next;         r=q->next;         while(q!=NULL)         {             if(p->cur<=q->cur){t=q->cur;q->cur=p->cur;p->cur=t ;}             q=r;             r=q->next;         }          q=p->next;         p=q;     }     printf(\"结束\\n\"); #endif } void distory(Node L) {     Node s;     while(s!=NULL)     { s=L->next;         free(L);         L=s;} } void output(Node L) {     Node s,j;     s=L->next;     j=s;     printf(\"将得到结果：\\n\");      while(s!=NULL){printf(\" %d\\n\",s->cur);s=j->next;j=s;} } void input(Node L) {     Node s;//,j;     int x;      //L->next=s;     s = L->next;     //j=s;     printf(\"单表输入cur值：\\n\");     while(s != NULL)     {         scanf(\"%d\", &x);         s->cur = x;         s = s->next;         //j=s->next;         //s=j;     }     printf(\"输入结束\\n\"); }  //void main() int main() {     Node t,r,h;     printf(\"创建两个表\\n\");     int k;     Init_List(t,k);     Init_List(r,k);     input(t);     input(r);       order(t);     output(t);     order(r);     output(r);      //h=Insert(h,t,r);     h= merge(h,t,r);     printf(\"最后得到\\n\");     output(h);     getchar();     getchar(); }  供参考～", "referer": "user-0"}]}
{"question": "C语言，为什么总是出现40", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 2 楼 user-1的回复:一般这种问题基本都是输入时用了中文逗号，而scanf格式却是英文逗号 谢谢你啊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "一般这种问题基本都是输入时用了中文逗号，而scanf格式却是英文逗号", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "不好意思，已经解决了，谢谢", "referer": "user-0"}]}
{"question": "分椰子", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "不是猴子分桃吗~~~", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 早打大打打核战争 的回复:不是猴子分桃吗~~~??", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "？？？///?//", "referer": "user-0"}]}
{"question": "分别给两个数组输入值，然后打印，但是打印的值有一个不正确，哪位大佬帮忙看下，小弟感激不尽", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "如下： int m, n,  i, j, count=0; //输入 scanf(\"%d\", &m); int c[m]; for (i=0;i<m;i++){ scanf(\"%d\", &c[i]); }  scanf(\"%d\", &n); int d[n]; for (j=0;j<n;j++){ scanf(\"%d\", &d[j]); } 原文中的定义实际上并没有给两个数组指定长度。有些IDE 执行的时候会报错告诉你哪的问题。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把int c[m]和int d[n]放在两个scanf和for之间", "referer": "user-0"}]}
{"question": "C++如何用指针从被调函数向主调函数返回多个值", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void func(int *a,int *b){    *a=10;    *b=20; } int main(){    int d;   int e;   func(&d,&e);   cout<<d<<e<<endl; }", "referer": "user-0"}]}
{"question": "c语言数据结构：josephus环问题求助。", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h>  typedef  struct  Lnode {     int data;     struct  Lnode *next; }joseph;  void  Create_List(joseph *L,int n) {     int i;     joseph *p,*s;      p =s = L;      for(i=2;i<=n;i++){         s=(joseph*)malloc(sizeof(joseph));         s->data =i;         p->next=s;         p=s;     }     p->next = L;  }   void show_list(joseph *phead) {     joseph *p;     if (!phead)         return;     p = phead->next;     printf(\"%d\\t\", phead->data);     while (p != phead) {         printf(\"%d\\t\", p->data);         p = p->next;     }     putchar(10); }  void  Delete_List(joseph *p, joseph *q) {     q-> next = p-> next;     free(p); }   void josephus (joseph *L, const int total, const int s, const int m) {     joseph *p = L, *prev, *del_node;     int cnt = 0, del_val, pos;      while (p && ++cnt != s) {         p = p->next;     }     printf(\"***%d\\\\\\n\", p->data);      //printf(\"helloworld!\\n\");     pos = cnt = 0;     prev = p;     while (1) {         pos++;         if (pos == m) {             del_val = p->next->data;             pos = 1;             del_node = p->next;             printf(\"del: %d\\n\", del_node->data);             p->next = p->next->next;             free(del_node);             cnt++;             if (cnt == total-1) {                 break;             }         }         p = p->next;         printf(\"pos = %d\\n\", pos);         //prev = prev->next;     }      printf(\"%d\\n\", p->data);  #if 0     int length;     length= sizeof(L)-1;      int i,j;     static joseph *p,*q,*Y;      p = L;      for(i=1;i<length;i++){         if(i==1){             for(j=1;j<s-1;j++){                 p=p->next;             }             q=p->next;             p-> next= q-> next;             Y->data = q->data;             Y=Y->next;             free(q);         }else{             for(j=1;j<m;j++){                 p=p->next;             }             q=p->next;             p-> next= q-> next;             Y->data = q->data;             Y=Y->next;             free(q);         }      }      printf(\"\\n\");       printf(\"%4d\\n\",Y->data);     //return L; #endif }   //void main() int main() {     joseph *L=NULL;     int m,n,s;     L = (joseph*)malloc(sizeof(joseph));     L->data=1;     printf (\"请输入人数、约定编号数，出列值：\\n\");     scanf (\"%d%d%d\", &n, &s, &m);     if ((m> 1000) || (n> 1000))         printf (\"输入的人数m，n不合法\\n\");     else if (s>n)         printf (\"输入数据不合法！\\n\");     else     {         n = 5;         Create_List(L, n);         show_list(L);         printf (\"\\n\");         josephus(L, n, s, m);     } } 供参考～", "referer": "user-0"}]}
{"question": "为什么C语言做的通讯录无法保存信息在文本里？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h> #include <errno.h>  typedef struct person  //定义一个结构体 {     char name[10]; //姓名     char addr[30]; //地址     char offphnum[15]; //办公电话     char hmphnum[15]; //家庭电话     char mbphum[15]; //移动电话     struct person * next; }listnode,*listlink; //结构体的别名  struct add_person {     char name[10]; //姓名     char addr[30]; //地址     char offphnum[15]; //办公电话     char hmphnum[15]; //家庭电话     char mbphum[15]; //移动电话 };  listlink readfp() //将文件的信息读出并转存入链表中 {     FILE * fp ; //定义文件指针     struct add_person persons;     listnode * s ;     listlink head = NULL , end = NULL ;     fp = fopen(\"people.txt\" , \"rb\");     if(fp == NULL)     {         printf(\"cannot open file \\n\");         return head;     }     fread(&persons , sizeof(struct add_person) , 1 , fp);     while(!feof(fp)) //判断文件是否结束（文件位置指示器是否到达了文件结尾）     {         s=(listnode*)malloc(sizeof(listnode)); //存入链表中         strcpy(s->name , persons.name) ; //提取数据并复制         strcpy(s->addr , persons.addr) ;         strcpy(s->offphnum , persons.offphnum) ;         strcpy(s->hmphnum , persons.hmphnum) ;         strcpy(s->mbphum , persons.mbphum) ;         s->next = NULL;         if(head==NULL)             head=end=s ;         else         {             end->next=s ;             end=s;         }         fread(&persons , sizeof(struct add_person) , 1 , fp) ;     }     return head; }  void Save(listlink head) //保存信息 {     FILE * fp;     static struct add_person persons;     listlink p1;     fp=fopen(\"people.txt\" , \"wb\");     if (!fp) {         fprintf(stderr, \"%s\\n\", strerror(errno));         return;     }     //for(p1=head ; p1!=NULL ; p1=p1->next);    //多一个分号     for(p1=head ; p1!=NULL ; p1=p1->next)     {         strcpy(persons.name , p1->name);         strcpy(persons.addr , p1->addr);         strcpy(persons.hmphnum , p1->hmphnum);         strcpy(persons.mbphum , p1->mbphum);         strcpy(persons.offphnum , p1->offphnum);         fwrite(&persons , sizeof(struct add_person ) , 1 ,fp);     }     fclose(fp); }  listlink create() //建立通讯录函数 {     listlink s;     listlink head=NULL , end=NULL;     while(1)     {         s=(listlink)malloc(sizeof(listnode));         printf(\"\\n\\n\\tcreate add_book's file \\n\");         printf(\"\\n\\n\\t\\tname:('#' is end)\\n\\t name:\");         scanf(\"%s\" , s->name);         if(strcmp(s->name , \"#\")==0)             break;         printf(\"\\n\\nAddr:\\toffphnum: \\thmphnum: \\tmbphnum:\\n\");         scanf(\"%s %s %s %s\", s->addr , s->offphnum , s->hmphnum , s->mbphum);         s->next=NULL;         if(head==NULL)             head=end=s;         else         {             end->next=s;             end=s;         }     }     free(s);    //last node not be inserted into link     return(head); }  void Show(listlink head) //显示所有信息 {     listnode *p1;     p1=head;     while(p1!=NULL)     {         printf(\"%s\\t\", p1->name);         printf(\"%s\\t\", p1->addr);         printf(\"%s\\t\", p1->offphnum);         printf(\"%s\\t\", p1->hmphnum);         printf(\"%s\\t\\n\", p1->mbphum);         p1=p1->next;     } }  void Delete(listlink *head) //定义一个删除的函数 {     listlink p1 , p2;     char name1[10];     p1=p2=*head;     if(p1==NULL)     {         printf(\"no record\\n\");         return;     }     printf(\"\\n\\n\\tDelete----please input the name\");     scanf(\"%s\" , name1); //输入要删除人的姓名     while(strcmp(p1->name , name1)!=0 && p1->next!=NULL)     {         p2=p1;         p1=p1->next;     }     if(strcmp(p1->name , name1)==0) //根据判断情况做相应处理     {         if(p1==*head) {             //p1=p1->next;             *head = (*head)->next;         }         else             p2->next = p1->next;         free(p1);         return;     }     //else         printf(\"It is not exist in the addr-book!\\n\"); //要删除的记录不存在 }  void Find(listlink head) //查找指定记录信息 {     listlink p1;     char name1[10];     while(1)     {         p1=head;         printf(\"\\n\\n\\tFind----please input the name: ('#' is end)\\n\\t name:\");         scanf(\"%s\", name1); //查找人的姓名         if(strcmp(name1,\"#\")==0)return;         while(strcmp(name1,p1->name)!=0 && p1->next!=NULL)             p1=p1->next;         if(strcmp(name1,p1->name)!=0)             printf(\"\\n\\n\\tIt is not exist in the addr-book!\");         else         {             printf(\"\\tname:%s\",p1->name);             printf(\"\\taddr:%s\",p1->addr);             printf(\"\\tphnum:%s\",p1->offphnum);             printf(\"\\tphnum:%s\",p1->hmphnum);             printf(\"\\tphnum:%s\",p1->mbphum);         }     } }  void Input(listlink head) //向通讯录追加一个人的信息 {     listlink s , end;     s=(listlink)malloc(sizeof(listnode));     do     {         printf(\"\\n\\n\\tInput----please input the sb's meg: \\n\\tname:('#' is end)\\n\\t name:\");         scanf(\"%s\",s->name);         if(strcmp(s->name,\"#\")==0)             return;         end=head;         if(end==NULL)break;         while((strcmp(end->name, s->name)!=0) && end->next!=NULL)             end=end->next;     }while(strcmp(end->name , s->name)==0);     printf(\"\\n\\nAddr:\\toffphnum: \\thmphnum: \\tmbphnum:\\n\");     scanf(\"%s %s %s %s\", s->addr , s->offphnum , s->hmphnum , s->mbphum);     s->next=NULL;     end->next=s; }  void Alter(listlink head) //改变一个人的信息 {     listlink p1;     char name1[10] , phnum1[15] , phnum2[15] , phnum3[15] , add1[30];     printf(\"\\n\\n\\tAlter----Please input the sname:\");     scanf(\"%s\",name1); //输入要修改人的姓名     p1=head;     while(strcmp(name1, p1->name)!=0 && p1->next!=NULL)         p1=p1->next;     if(strcmp(name1, p1->name)!=0)     {         printf(\"\\n\\n\\tIt is not exist in the addr-book!\");         return;     }     else     {         printf(\"\\n\\n\\tPlease input the Alter meg!\"); //输入要修改人的新信息         printf(\"\\n\\n addr: offphnum: hmphnum: mbphnum\\n\");         scanf(\"%s %s %s %s\", add1 , phnum1 , phnum2 , phnum3);         strcpy(p1->name , name1);         strcpy(p1->addr, add1);         strcpy(p1->offphnum , phnum1);         strcpy(p1->hmphnum , phnum2);         strcpy(p1->mbphum , phnum3);     } }  int main() {     listlink head=NULL;     int sel;     head=readfp();     if(head==NULL)         head = create();     do     {         printf(\"\\n WELCOME TO USE Address book\"); //显示提示的信息         printf(\"\\n 1.Show all the meg  2.Delete a piece of meg\");         printf(\"\\n 3.Find a piece of meg 4.Insert a piece of meg\");         printf(\"\\n 5.Alter a piece of meg\");         printf(\"\\n 0.Save and Exit\");         printf(\"\\n Input Your Choice(0-5):\");         scanf(\"%d\",&sel);         switch(sel)         {             case 1: Show(head);                     printf(\"press anykey to return \\n\");                     getchar();                     break;             case 2: Delete(&head);   //用二重指针解决无法删除第一个的问题，内部修改详见函数内部实现                     break;             case 3: Find(head);                     printf(\"press anykey to return \\n\");                     getchar();                     break;             case 4: Input(head);                     break;             case 5: Alter(head);                     break;             case 0: Save(head);                     break;         }     }while(1); }  供参考～  for循环后面不能有分号，除非特殊用途  删除第一个节点，需要传二重指针，建议对比找一下自己的问题～", "referer": "user-0"}]}
{"question": "小白紧急求助 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "char str[] = \"hello a123456\"; int i; for(i = 0;i < strlen(str);i++){   if(str[i] >('a' - 1) && str[i] < ('z' +1) || str[i] >('A' - 1) && str[i] < ('Z' +1)){        str[i] + 'a' - 'A' + 1;   } } //z和Z自己再设置一下，输出就一个for循环，记得加头文件string.h", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "根据字符串bai存储的变量的不同，方法不同，  参考代码： 存储在char数组中（支持C/C++) char str[]=\"hello\" ; int i;for( i=0;str[i];i++ )     printf(\"%c\\n\", str[i] ); //以数组方式引用一个字符str[i]   for( i=0;*(str+i);i++ )     printf(\"%c\\n\", *(str+i) ); //以指针方式引用一个字符", "referer": "user-0"}]}
{"question": "C语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "void printf_chr_exercise(void) { \tchar c = 'a';//get a character \tchar upper_c = toupper(c); \t{ \t\tprintf(\"%c\\n\"\\ \t\t\t\"%c %c %c %c %c %c %c %c\\n\"\\ \t\t\t\" %c %c %c %c %c %c %c %c\\n\"\\ \t\t\t\"%c %c %c %c %c %c %c %c\\n\"\\ \t\t\t\" %c %c %c %c %c %c %c %c\\n\"\\ \t\t\t\"%c %c %c %c %c %c %c %c\\n\"\\ \t\t\t\" %c %c %c %c %c %c %c %c\\n\"\\ \t\t\t\"%c %c %c %c %c %c %c %c\\n\"\\ \t\t\t\" %c %c %c %c %c %c %c %c\\n\",\\ \t\t\tc,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,\\ \t\t\tupper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c,upper_c); \t} }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "小写字母转换为大写字母不会？ 还是 输出不会？", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "更倾向于３ｌ循环打印的，如果我的话会用循环打，看着好看一点", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "#include<stdio.h> int main(){     char c;     scanf(\"%c\", &c);     c += 26;    //将小写转换为大写     //循环输出     for(int i = 0; i < 8; i ++){         for(int j = 0; j < 8; j ++){             if(i % 2 == 1)                 printf(\"%c \", c);             else                 printf(\" %c\", c);         }         print(\"\\n\");     }     return  0; }  一个思路，可以参考", "referer": "user-0"}]}
{"question": "glut.h头文件的调用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "下载并解压freeglut，把头文件放入VC98\\Include\\GL\\下，lib文件放入VC98\\Lib\\下", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "我按照这个，编译还是说那个文件打不开", "referer": "user-0"}]}
{"question": "c语言——转义字符问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "我这边跑过都是正常对齐的，实在不行可以贴代码上来debug下。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "https://blog.csdn.net/CSRAWD/article/details/104860862  这个博客讲的很详细，参考一下吧～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "char s[200]; sprintf(s,\"a[%2d]=%2d\",i,a[i]);//输出到临时字符串变量s中 printf(\"%-20s\",s);//将s左对齐占用20个字符宽度输出", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "对终端来说，\\t仅仅表示将光标向右移到下一个列位置为8*n+1的地方而已。n为非负整数", "referer": "user-0"}]}
{"question": "单链表的插入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 3 楼 weixin_50718000 的回复:@自信男孩，那个你写的第90行为什么要写getchar（）呀，为什么不写那个就执行不出结果来呀 这个用于接收上面输入i之后输入的回车。如果楼主再输入这两个scanf对应的变量时中间不加回车就可以不加那句～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "@自信男孩，那个你写的第90行为什么要写getchar（）呀，为什么不写那个就执行不出结果来呀", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "嗯，好的，我知道了，谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<malloc.h>  #define  ERROR 0 #define  OK    1  //单链表的定义 typedef int elemtype; typedef struct Node { \telemtype data; \tstruct Node *next; }Node,*linklist;  //单链表的初始化 void init_linklist(linklist *l) { \t*l = (linklist)malloc(sizeof(Node)); \t(*l)->next=NULL; } //头插法建立单链表 void createfromhead(linklist l) { \tNode *s; \tchar c; \tint flag=1; \twhile(flag) \t{ \t\tc = getchar(); \t\t//fflush(stdin); \t\tgetchar(); \t\tif(c!='0') \t\t{ \t\t\ts=(Node*)malloc(sizeof(Node)); \t\t\ts->data=c; \t\t\ts->next=l->next; \t\t\tl->next=s; \t\t} \t\telse  \t\t\tflag=0; \t} } //单链表的插入 int inslist(linklist l,int i,elemtype e) \t//在带头结点的单链表l中第i个位置插入值为e的节点 {     \tNode *pre,*s; \tint k; \tif(i<=0) \t\treturn ERROR; \tpre=l;   k=0;//从头开始查找，查找第i-1个节点 \twhile(pre!=NULL&&k<i-1)    //标为查完且未查到第i-1个是重复，找到pre只想第i-1个 \t{   \t\tpre=pre->next; \t\tk=k+1; \t}//查找第i-1个节点 \tif(pre==NULL)//如当前位置pre为空表表示一找完，但还为到第i个，说明插入位置不合理 \t{   \t\tprintf(\"插入位置不合理\"); \t\treturn ERROR; \t} \ts=(Node*)malloc(sizeof(Node));  //申请一个新的节点 \ts->data=e;  //值e放入s的数据与 \ts->next=pre->next;  //修改指针，完成插入 \tpre->next=s; \treturn OK; } //void main() int main() {     \tlinklist l; \tNode *p; \tint i,r,j; \t//建立单链表 \tinit_linklist(&l); \tprintf(\"用头插法建立单链表，请输入链表数据\\n\"); \tcreatefromhead(l); \tp = l->next; \twhile(p!=NULL) \t{     \t\t//printf(\"%c\\n\", *p ); \t\tprintf(\"%c\\n\", p->data ); \t\tp=p->next; \t}  \t//单链表的插入 \tprintf(\"请输入你要插入的位置:\\n\"); \tscanf(\"%d\",&i); \tgetchar(); \tprintf(\"请输入你要插入的数字：\\n\"); \t//scanf(\"%d\",&r); \tscanf(\"%c\",&r); \tif (inslist(l,i,r) == ERROR) { \t\tprintf(\"Insert error!\\n\"); \t\treturn -1; \t} \tprintf(\"结果为:\\n\"); \tp=l->next; \twhile(p!=NULL) \t{     \t\t//printf(\"%c\\n\", *p ); \t\tprintf(\"%c\\n\", p->data ); \t\tp=p->next; \t} } 供参考～  插入算法没什么问题，问题在于main函数里用的r是%d格式的，注意'1'和1是不相等的。 如果按照楼主的写法，可以考虑输入51，这样插入的是'3'，", "referer": "user-0"}]}
{"question": "有关while循环的小问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 Intel0011的回复:[quote=引用 楼主 若水ovo 的回复:]为什么输入数字不退出循环呀 另外，至少执行一次的时候，用do...while更好[/quote] 这个我自己还没看到", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 Intel0011的回复:[quote=引用 楼主 若水ovo 的回复:]为什么输入数字不退出循环呀 另外，至少执行一次的时候，用do...while更好[/quote] 谢谢(*°∀°)=3", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "2也是字符，是输入的'2'。  建议用ctrl+d（LINUX）或ctrl+z（windows）试试", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 楼主 若水ovo 的回复:为什么输入数字不退出循环呀 另外，至少执行一次的时候，用do...while更好", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "数字也是字符啊，alp接收‘2’字符，有什么错？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "cir = scanf(\"%c\", &alp); 当你输入2时，alp为'2'，cir为1，当然继续循环啦", "referer": "user-0"}]}
{"question": "我这编译出来运行不来，出现d returned 1 exit status", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢哈。不过我这个i 就是想要设定变的，为了单独输出 i的每一个数，进入选择。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<math.h> #include<bits/stdc++.h>  int main() {     unsigned int m, n, i, boundary = 2 * (unsigned int)pow(10, 9);     int digits[10] = {0}, tmp;       scanf(\"%u%u\", &m, &n);      if (m > n)         return -1;     if ((m <= 0 || m > boundary)         || (n <= 0 || n > boundary)) {             return -1;     }      for (i = m; i <= n; i++) {         tmp = i;          while (tmp) {             digits[tmp % 10]++;             tmp /= 10;         }     }     for(i=0;i<10;i++)         printf(\"%d \", digits[i]) ;      putchar(10);     return 0;    #if 0      int m,n,i,j,d,c;     int tmp;     scanf(\"%d %d\",&m,&n);     int b[10]={0};      for(i=m;i<=n;i++) {                 tmp = i;                 while (tmp)                 {                     d = tmp%10;                     tmp = tmp/10;                     switch(d)                     {                         case 0:b[0]++;break;                         case 1:b[1]++;break;                         case 2:b[2]++;break;                         case 3:b[3]++;break;                         case 4:b[4]++;break;                         case 5:b[5]++;break;                         case 6:b[6]++;break;                         case 7:b[7]++;break;                         case 8:b[8]++;break;                         case 9:b[9]++;break;                     }                 }     }     for(i=0;i<10;i++)         printf(\"%d: %d\\n\", i, b[i]) ; #if 0         for(j=1;j<=10;j++)         {             if(i<pow(10,j))              {                 tmp = i;                  //for(c=j-1;c>0;c--)                 while (tmp)                 {                     d = tmp%10;                     tmp = tmp/10;                     switch(d)                     {                         case 0:b[0]++;break;                         case 1:b[1]++;break;                         case 2:b[2]++;break;                         case 3:b[3]++;break;                         case 4:b[4]++;break;                         case 5:b[5]++;break;                         case 6:b[6]++;break;                         case 7:b[7]++;break;                         case 8:b[8]++;break;                         case 9:b[9]++;break;                     }                 }             }         }     for(i=0;i<10;i++)         printf(\"%d: %d\\n\", i, b[i]) ;     return 0;  #endif  #endif  }  供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "楼主的i在循环体里被修改了，修改的地方在这里：   d=i%10;    i=i/10; 主要是这句：i = i/10;修改了i，别忘了在最外层循环里i循环标量；", "referer": "user-0"}]}
{"question": "c语言，可以麻烦你告诉我怎么去完成么？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "按图的方式，百度图最短路径算法", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这玩意好点绕啊，计价还是简单的，关键是线路站点的增删，用链表？结构体保存不同的信息，而且涉及到多条线交叉，应该是外部链表存了信息，然后有节点指向内部链表，分开存储，这样的话可能要好几个，一时半会我理不出来，还有怎么得到可行路径也是个问题", "referer": "user-0"}]}
{"question": "如何编写模块来实现将eht0端口上收到的包发送到eth1端口上？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "写一个内核模块，实现eth0和eth1之间相互转发？到eth0上的包直接扔给eth1，eth1上的包直接扔给eth0.", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "假如应用层的数据到了eth0接口，我希望写一个内核模块，将这个报文交由eth1处理，然后转发出去", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "折腾啥，把网线调换一下接口不就行了", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "互相转发的意义不大吧？如果是单独拿得话可以用桥接，桥接之前看得是把几个口的包通过桥放到一个口，然后监听那一个口抓包，就可以抓到所有的，应该是一个道理", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "两张网卡（两个ip）？两个端口？ 你所谓的转发是指程序转发还是让系统自动转发？系统自动转发好像两张网卡可以“桥接”（类似和虚拟机的桥接）；程序转发那实现方式很多，比如在路由转发到不同ip", "referer": "user-0"}, {"cid": "6", "user": "user-4", "content": "楼主的意思是不是指端口之间通信？ 那不就是进程之间通信吗？ 如果是两个网卡之间通信，使用脚本就可以了啊。 端口、eth0和eth1，先了解清楚。", "referer": "user-0"}]}
{"question": "vs的C程序malloc分配的内存为什么会访问不了？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "top->data=NULL;下面的波浪线提示是什么？看上去data像是int型，初始化最好用top->data=0;这样", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "问题已经解决了，实际上是因为这个文件中头文件没有定义initList函数，vs编译也不报错运行出问题！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "但从这些信息看不出什么问题来，（对于top在malloc之后应该判断一下是否申请成功）建议提供更多代码吧～", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "到上面这一步的时候内存已经分配并赋值了，  但就是错了，怎么回事，怎么解决？", "referer": "user-0"}]}
{"question": "不带头节点单链表删除第一个结点出错", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 9 楼 qybao的回复:[quote=引用 6 楼 肥牛肉^*^ 的回复：][quote=引用 2 楼 qybao的回复:][quote=引用 1 楼 qybao 的回复:]  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 补充说明，例子代码的意思就是，p是个指针，刚开开始指向a的地址，change1是在函数内修改参数p指向b的地址，结果无效；change2是在函数内修改参数*p指向b的地址，结果有效，所以想在函数内改变也能影响p，就要把p的地址&p传给函数，函数里用*p=xxx的方式修改。因为p本身是指针，所以它的&p就是二级指针。 [/quote] delete里面用一级指针只是删除i=1这个位置有乱码，删除i为2的位置就可以，如果这样里面的参数没有改变，那为什么删除2这个位置结果就有效呢，[/quote]你没理解我说的，传二级指针是为了修改函数外的头指针，如果删除第二个位置，不需要修改函数外的头指针，所以没问题；而删除第一个位置，因为头指针被释放了，如果不修改函数外的头指针就会出问题（就像你说的问题一样，野指针的东西内容是不确定的，所以就可能出现乱码）。要修改函数外的头指针，那参数只能传函数外的头指针的地址，即&head（明白我举的例子的意思了吗？你觉得&head和head都是地址，但它们等效吗？），所以就是二级指针（head是一级指针，&head就是二级指针）[/quote] 理解了。。。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 6 楼 肥牛肉^*^ 的回复：[quote=引用 2 楼 qybao的回复:][quote=引用 1 楼 qybao 的回复:]  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 补充说明，例子代码的意思就是，p是个指针，刚开开始指向a的地址，change1是在函数内修改参数p指向b的地址，结果无效；change2是在函数内修改参数*p指向b的地址，结果有效，所以想在函数内改变也能影响p，就要把p的地址&p传给函数，函数里用*p=xxx的方式修改。因为p本身是指针，所以它的&p就是二级指针。 [/quote] delete里面用一级指针只是删除i=1这个位置有乱码，删除i为2的位置就可以，如果这样里面的参数没有改变，那为什么删除2这个位置结果就有效呢，[/quote]你没理解我说的，传二级指针是为了修改函数外的头指针，如果删除第二个位置，不需要修改函数外的头指针，所以没问题；而删除第一个位置，因为头指针被释放了，如果不修改函数外的头指针就会出问题（就像你说的问题一样，野指针的东西内容是不确定的，所以就可能出现乱码）。要修改函数外的头指针，那参数只能传函数外的头指针的地址，即&head（明白我举的例子的意思了吗？你觉得&head和head都是地址，但它们等效吗？），所以就是二级指针（head是一级指针，&head就是二级指针）", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 5 楼 肥牛肉^*^ 的回复：[quote=引用 2 楼 qybao的回复:][quote=引用 1 楼 qybao 的回复:]  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 补充说明，例子代码的意思就是，p是个指针，刚开开始指向a的地址，change1是在函数内修改参数p指向b的地址，结果无效；change2是在函数内修改参数*p指向b的地址，结果有效，所以想在函数内改变也能影响p，就要把p的地址&p传给函数，函数里用*p=xxx的方式修改。因为p本身是指针，所以它的&p就是二级指针。 [/quote] 要把p的地址传给函数，但p不就是一个地址了吗，[/quote]你好好理解我给你的例子，p也是个指针，但是传二级指针和一级指针是有区别的，传二级指针是传p自己的地址，传一级指针是传p指向的地址，自己的地址和指向的地址不是一回事。", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 6 楼 肥牛肉^*^ 的回复:[quote=引用 2 楼 qybao的回复:][quote=引用 1 楼 qybao 的回复:]  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 补充说明，例子代码的意思就是，p是个指针，刚开开始指向a的地址，change1是在函数内修改参数p指向b的地址，结果无效；change2是在函数内修改参数*p指向b的地址，结果有效，所以想在函数内改变也能影响p，就要把p的地址&p传给函数，函数里用*p=xxx的方式修改。因为p本身是指针，所以它的&p就是二级指针。 [/quote] delete里面用一级指针只是删除i=1这个位置有乱码，删除i为2的位置就可以，如果这样里面的参数没有改变，那为什么删除2这个位置结果就有效呢，[/quote]  楼主的删除函数传的是一重指针还是二重指针？这个需要明确了，提问题的时候如果不确定讨论起来就不好说了。  传二重指针，删除头结点没问题。原因是二重指针*head = p->next;这句就是相当于修改了main函数里的head节点，更新了main函数里的head指针指向，因为传的是二重指针嘛，如果传一重指针不可以的原因是head = p->next;这里的head是形参的head并不是main函数里的head了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 2 楼 qybao的回复:[quote=引用 1 楼 qybao 的回复:]  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 补充说明，例子代码的意思就是，p是个指针，刚开开始指向a的地址，change1是在函数内修改参数p指向b的地址，结果无效；change2是在函数内修改参数*p指向b的地址，结果有效，所以想在函数内改变也能影响p，就要把p的地址&p传给函数，函数里用*p=xxx的方式修改。因为p本身是指针，所以它的&p就是二级指针。 [/quote] delete里面用一级指针只是删除i=1这个位置有乱码，删除i为2的位置就可以，如果这样里面的参数没有改变，那为什么删除2这个位置结果就有效呢，", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 qybao的回复:[quote=引用 1 楼 qybao 的回复:]  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 补充说明，例子代码的意思就是，p是个指针，刚开开始指向a的地址，change1是在函数内修改参数p指向b的地址，结果无效；change2是在函数内修改参数*p指向b的地址，结果有效，所以想在函数内改变也能影响p，就要把p的地址&p传给函数，函数里用*p=xxx的方式修改。因为p本身是指针，所以它的&p就是二级指针。 [/quote] 要把p的地址传给函数，但p不就是一个地址了吗，", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "引用 1 楼 qybao 的回复:int ListDelete(pSingLink* head, int i, ElemType *x) //这里用二级指针，是因为函数里有 *head=p->next; //这样修改也能改变函数外的head的指向  int ListDelete(pSingLink head, int i, ElemType *x) //如果是一级指针，函数里 head=p->next; //这样修改是不能改变函数外的head的指向  具体原因解释过很多遍了，要想在函数内修改参数也能影响函数外，参数要用指针类型，且函数里不能用 参数=xxx 来修改（这样是修改函数栈的参数的栈内存的信息，这样参数的内存就不再保存原来指针指向的地址信息了，所以就不会影响函数外的变量），而是要用 *参数=xxx 来修改（这样是不修改函数栈的参数的栈内存的信息，而是修改它指向的内存地址的信息，所以会影响函数外的变量）。 你删除第一个元素，要修改头指针，要想在函数内修改也影响函数外的变量，就必须把函数外的变量的地址传给函数，因为函数外的变量是指针类型，传它的地址，就是二级指针，所以ListDelete(pSingLink* head, int i, ElemType *x)  要用二级指针  举个例子，好好理解其中的差别  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 楼主用的好像就是二重指针～", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "#include <stdio.h> #include <malloc.h> #include <stdlib.h>  typedef int ElemType;  typedef struct SLNode {     ElemType data;     struct SLNode *next; }SingLink,*pSingLink;  pSingLink TailCreatList(); void DisPlay(pSingLink L); int ListDelete(pSingLink* head, int i, ElemType *x);  int main(void) {     int i,x;     pSingLink head=NULL;     head=TailCreatList();     DisPlay(head);     printf(\"请输入删除位置:\");     scanf(\"%d\",&i);     if(ListDelete(&head,i,&x)) {         printf(\"删除成功, \");         printf(\"删除的元素是:%d\\n \",x);     } else {         printf(\"删除失败\\n\");     }     DisPlay(head);     return 0; } pSingLink TailCreatList() {     pSingLink head,r;     pSingLink s;     int i,len,x;      head = NULL;     r=head;     printf(\"请输入单链表的长度\");     scanf(\"%d\",&len);     printf(\"请输入单链表中的元素\");     for(i=0;i<len;i++)     {         scanf(\"%d\",&x);         s=(pSingLink)malloc(sizeof(SingLink));         s->data=x;         if(head==NULL)         {             head=s;             r=s;             continue;         }         r->next = s;         r = s;     }     if(r!=NULL)         r->next = NULL;      return head; }  void DisPlay(pSingLink L) {     while(L!=NULL)     {         printf(\"%d \",L->data);         L=L->next;     }     putchar(10);     return; }  int ListDelete(pSingLink* head, int i, ElemType *x) {     pSingLink p,s;     int j;      if (!(*head))    //需要判断头结点         return 0;      j=1;     p = *head;     while(p->next!=NULL&&j<i-1)     {         p=p->next;         j++;     }     if(i==1)     {         *head=p->next;         *x=p->data;         free(p);          return 1;     }     //else if(j!=i-1)     if(j != i-1 || !p->next)    //需要考虑p->next是否为NULL     {         printf(\"位置出错\");         return 0;     }     else     {         s = p->next;         *x=s->data ;         p->next =s->next ;         free(s);     }      return 1; } 供参考～  不是删除头结点出的错，是i的值如果大于链表长度出的段错误；需要考虑p->next是否为NULL；  其他小问题一并修改了，比如如果删除失败，x的值是一个随机值～", "referer": "user-0"}, {"cid": "10", "user": "user-2", "content": "引用 1 楼 qybao 的回复: int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 } 补充说明，例子代码的意思就是，p是个指针，刚开开始指向a的地址，change1是在函数内修改参数p指向b的地址，结果无效；change2是在函数内修改参数*p指向b的地址，结果有效，所以想在函数内改变也能影响p，就要把p的地址&p传给函数，函数里用*p=xxx的方式修改。因为p本身是指针，所以它的&p就是二级指针。", "referer": "user-0"}, {"cid": "11", "user": "user-2", "content": "int ListDelete(pSingLink* head, int i, ElemType *x) //这里用二级指针，是因为函数里有 *head=p->next; //这样修改也能改变函数外的head的指向  int ListDelete(pSingLink head, int i, ElemType *x) //如果是一级指针，函数里 head=p->next; //这样修改是不能改变函数外的head的指向  具体原因解释过很多遍了，要想在函数内修改参数也能影响函数外，参数要用指针类型，且函数里不能用 参数=xxx 来修改（这样是修改函数栈的参数的栈内存的信息，这样参数的内存就不再保存原来指针指向的地址信息了，所以就不会影响函数外的变量），而是要用 *参数=xxx 来修改（这样是不修改函数栈的参数的栈内存的信息，而是修改它指向的内存地址的信息，所以会影响函数外的变量）。 你删除第一个元素，要修改头指针，要想在函数内修改也影响函数外的变量，就必须把函数外的变量的地址传给函数，因为函数外的变量是指针类型，传它的地址，就是二级指针，所以ListDelete(pSingLink* head, int i, ElemType *x)  要用二级指针  举个例子，好好理解其中的差别  int a=5,b=6; void change1(int *p) {p=&b;} void change2(int **p) {*p=&b;} int main() {     int *p = &a; //*p=5     printf(\"%p, %p\\n\", &a, &b); //查看a，b的地址     change1(p);      printf(\"%p, %d\\n\", p, *p); //函数内的修改不影响函数外的p，p还是指向a的地址     change2(&p); //要想在函数修改p也能影响函数外的p，就要传p的地址，p本身是指针，p的地址就是二级指针，所以参数就是二级指针类型     printf(\"%p, %d\\n\", p, *p); //函数内的修改影响函数外的p，p指向b的地址 }", "referer": "user-0"}]}
{"question": "求解创建双链表的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:scanf(\"%d\\n\", &q->data);   改为 scanf(\"%d\", &q->data); 谢谢谢谢谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "scanf(\"%d\\n\", &q->data);   改为 scanf(\"%d\", &q->data);", "referer": "user-0"}]}
{"question": "隐式转换的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "会不会是你认为是UINT8是int类型？如果是编译器帮你转换了int，还会emit出来个error，那么所有的UINT8和UINT16赋值运算都会需要(type)强制转换了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:应该是隐式类型提升了：C语言中比int小的整型（包括short 、unsigned short 、 unsigned char和char）在运算中都要转换成int然后进行运算，至于为什么选择转换为int，应该是从效率上考虑的，因为通常情况下int的长度被定义为机器处理效率最高的长度，比如32位机上，一次处理4个字节效率是最高的，所以虽然short（我机器上占2个字节）更节省内存，但是在运算中的效率，是int更高。所以上面，无论是逻辑运算a>b还是算术运算a+b中a和b都默认转换成了int，所以算术运算的结果也是带符号的。   注意标红的前提条件 后面我把循环条件里的语句改为sum =(UINT16)(sum + data[10+i]); 这样就没问题了，估计就是你所说的原因。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "错误我是照抄的，所以没有我认为这个UINT8是int类型。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "不同的编译器可能对字面量的类型存储不一样，可以参考以下链接 https://zh.wikipedia.org/wiki/字面常量_(C语言) 对于你的代码，i < 39 的 39 编译器都当做是int，所以自动把 i 转成 int 来比较 对于上面链接的，如果 39 转成long，有另一种写法，即 39L（后面带个L表示long）能很容易做到，但是做成UINT16或UINT8好像没有专门的修饰，这种情况只能强行转换了，如 i < (UINT16)39", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "引用 1 楼 自信男孩 的回复:应该是隐式类型提升了：C语言中比int小的整型（包括short 、unsigned short 、 unsigned char和char）在运算中都要转换成int然后进行运算，至于为什么选择转换为int，应该是从效率上考虑的，因为通常情况下int的长度被定义为机器处理效率最高的长度，比如32位机上，一次处理4个字节效率是最高的，所以虽然short（我机器上占2个字节）更节省内存，但是在运算中的效率，是int更高。所以上面，无论是逻辑运算a>b还是算术运算a+b中a和b都默认转换成了int，所以算术运算的结果也是带符号的。   注意标红的前提条件 但是还需要注意一个问题就是转换成int类型的时候，高位补齐的问题。  如果是unsigned的类型转换成int类型，高位补0.  如果是signed的类型转换成int类型，如果原来最高位是1则补1，如果是0则补0。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "应该是隐式类型提升了：C语言中比int小的整型（包括short 、unsigned short 、 unsigned char和char）在运算中都要转换成int然后进行运算，至于为什么选择转换为int，应该是从效率上考虑的，因为通常情况下int的长度被定义为机器处理效率最高的长度，比如32位机上，一次处理4个字节效率是最高的，所以虽然short（我机器上占2个字节）更节省内存，但是在运算中的效率，是int更高。所以上面，无论是逻辑运算a>b还是算术运算a+b中a和b都默认转换成了int，所以算术运算的结果也是带符号的。   注意标红的前提条件", "referer": "user-0"}]}
{"question": "输入整数a,b,c，输出最大值，为什么我这个总是错误", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 8 楼 ly93969 的回复:[quote=引用 1 楼 自信男孩的回复:]测试了没什么问题；  代码有冗余，改一下；  #include<stdio.h>  int main() {     int a,b,c,max;      scanf(\"%d%d%d\", &a,&b,&c);     if (a > c)         max = a;     else         max = c;      if (max < b)         max = b;         //max = max;     //else      //   max = b;     printf(\"%d\\n\", max);     return 0; } 楼主是怎么测试的？  max = a > c ? ((a > b) ? a:b) : ((b > c) ? b:c); 一条语句搞定，不过有点复杂，根据自己的理解选择那种方式～ 我又重新创建了一个空项目，然后就可以运行了 应该是软件出问题了吧，一直显示Debug错误[/quote]  恩，那是环境问题，跟代码没关系～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 ggglivw的回复:对AB取最大，然后用这个结果和C取最大不就搞定了吗？哪里需要这么复杂把自己绕晕 明白了。。。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 2 楼 user-4的回复:哪儿错了？？？？ 我又重新创建了一个空项目，然后就可以运行了☒ 应该是软件出问题了吧，之前一直显示Debug错误", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:测试了没什么问题；  代码有冗余，改一下；  #include<stdio.h>  int main() {     int a,b,c,max;      scanf(\"%d%d%d\", &a,&b,&c);     if (a > c)         max = a;     else         max = c;      if (max < b)         max = b;         //max = max;     //else      //   max = b;     printf(\"%d\\n\", max);     return 0; } 楼主是怎么测试的？  max = a > c ? ((a > b) ? a:b) : ((b > c) ? b:c); 一条语句搞定，不过有点复杂，根据自己的理解选择那种方式～ 我又重新创建了一个空项目，然后就可以运行了 应该是软件出问题了吧，一直显示Debug错误", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "对AB取最大，然后用这个结果和C取最大不就搞定了吗？哪里需要这么复杂把自己绕晕", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "引用 5 楼 qq_51590857 的回复:[quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 qq_51590857 的回复:][quote=引用 楼主 ly93969的回复:]#include<stdio.h> int main() { \tint a,b,c,max; \tscanf(\"%d%d%d\", &a,&b,&c); \tif (a > c) \t\tmax = a; \telse \t\tmax = c; \tif (max > b) \t\tmax = max; \telse \t\tmax = b; \tprintf(\"%d\\n\",max); \treturn 0; } #include<stdio.h> int main() { int a,b,c,max; scanf(\"%d%d%d\", &a,&b,&c); max=a; if (a < b) { if (b < c) max=c; else   max=b; }  printf(\"%d\\n\",max); return 0; }[/quote] 你的代码有问题，如果a > b 且a < c的情况没有考虑～[/quote] #include<stdio.h> int main() { int a,b,c,max; scanf(\"%d%d%d\", &a,&b,&c); max=a; if (a < b) { if (b < c) max=c; else   max=b; }  else if(a<c) max=c； printf(\"%d\\n\",max); return 0; } 这样对吗[/quote] 自己测测吧，程序写出来通过了测试才能说没问题～", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "引用 4 楼 自信男孩的回复:[quote=引用 3 楼 qq_51590857 的回复:][quote=引用 楼主 ly93969的回复:]#include<stdio.h> int main() { \tint a,b,c,max; \tscanf(\"%d%d%d\", &a,&b,&c); \tif (a > c) \t\tmax = a; \telse \t\tmax = c; \tif (max > b) \t\tmax = max; \telse \t\tmax = b; \tprintf(\"%d\\n\",max); \treturn 0; } #include<stdio.h> int main() { int a,b,c,max; scanf(\"%d%d%d\", &a,&b,&c); max=a; if (a < b) { if (b < c) max=c; else   max=b; }  printf(\"%d\\n\",max); return 0; }[/quote] 你的代码有问题，如果a > b 且a < c的情况没有考虑～[/quote] #include<stdio.h> int main() { int a,b,c,max; scanf(\"%d%d%d\", &a,&b,&c); max=a; if (a < b) { if (b < c) max=c; else   max=b; }  else if(a<c) max=c； printf(\"%d\\n\",max); return 0; } 这样对吗", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "引用 3 楼 qq_51590857 的回复:[quote=引用 楼主 ly93969的回复:]#include<stdio.h> int main() { \tint a,b,c,max; \tscanf(\"%d%d%d\", &a,&b,&c); \tif (a > c) \t\tmax = a; \telse \t\tmax = c; \tif (max > b) \t\tmax = max; \telse \t\tmax = b; \tprintf(\"%d\\n\",max); \treturn 0; } #include<stdio.h> int main() { int a,b,c,max; scanf(\"%d%d%d\", &a,&b,&c); max=a; if (a < b) { if (b < c) max=c; else   max=b; }  printf(\"%d\\n\",max); return 0; }[/quote] 你的代码有问题，如果a > b 且a < c的情况没有考虑～", "referer": "user-0"}, {"cid": "9", "user": "user-3", "content": "引用 楼主 ly93969的回复:#include<stdio.h> int main() { \tint a,b,c,max; \tscanf(\"%d%d%d\", &a,&b,&c); \tif (a > c) \t\tmax = a; \telse \t\tmax = c; \tif (max > b) \t\tmax = max; \telse \t\tmax = b; \tprintf(\"%d\\n\",max); \treturn 0; } #include<stdio.h> int main() { int a,b,c,max; scanf(\"%d%d%d\", &a,&b,&c); max=a; if (a < b) { if (b < c) max=c; else   max=b; }  printf(\"%d\\n\",max); return 0; }", "referer": "user-0"}, {"cid": "10", "user": "user-4", "content": "哪儿错了？？？？", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "测试了没什么问题；  代码有冗余，改一下；  #include<stdio.h>  int main() {     int a,b,c,max;      scanf(\"%d%d%d\", &a,&b,&c);     if (a > c)         max = a;     else         max = c;      if (max < b)         max = b;         //max = max;     //else      //   max = b;     printf(\"%d\\n\", max);     return 0; } 楼主是怎么测试的？  max = a > c ? ((a > b) ? a:b) : ((b > c) ? b:c); 一条语句搞定，不过有点复杂，根据自己的理解选择那种方式～", "referer": "user-0"}]}
{"question": "链表求助", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "基本符合要求了，是否有bug未详细测试  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h>  typedef struct node {     int data;     struct node *next; }linknode, *linklist;  //创建链表 linklist createLink() {     linklist pHead = (linknode*)malloc(sizeof(linknode));     if ( pHead == NULL )     {         printf(\"内存分配失败\\n\");         return NULL;     }     pHead->data = 0;     pHead->next = NULL;     return pHead; }  //链表赋值 void AddNode(linklist pHead) {     int a;     linklist pTemp = NULL, pCurr = pHead;     printf(\"输入链表结点的值，-1结束\\n\");     while ( 1 )     {         scanf(\"%d\", &a);         if ( a != -1 )         {             pTemp = (linknode*)malloc(sizeof(linknode));             pTemp->data = a;             pTemp->next = NULL;             pCurr->next = pTemp;             pCurr = pTemp;         }         else         {             break;         }     } }  //输出链表 void printLink(linklist pHead) {     linklist pTemp = pHead->next;     while ( pTemp != NULL )     {         printf(\"%d \", pTemp->data);         pTemp = pTemp->next;     }     printf(\"\\n\"); }  //删除大于x不大于y的结点值 void deletedata(linklist L, int x, int y) {     linklist pOne = L, pTwo = L->next, pTemp = NULL;          //遍历查找符合条件的结点     while ( pTwo != NULL )     {         if ( pTwo->data > x && pTwo->data <= y )         {             if ( pTwo->next != NULL )             {                 pOne->next = pTwo->next;                 pTemp = pTwo;                 free(pTemp);                 pTemp = NULL;                 pTwo = pOne;             }             else             {                 pOne->next = NULL;                 free(pTwo);                                 pTwo = pOne;             }         }         pOne = pTwo;         pTwo = pTwo->next;     } }  int main() {     linklist pHead;     pHead = createLink();     AddNode(pHead);     printLink(pHead);      deletedata(pHead, 60, 70);     printLink(pHead);      system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "先自己写写吧，比如先创建一个带头结点的链表，然后输出链表。这两个函数先写出来，后面再写删除的函数～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "//删除大于x不大于y的结点值 void deletedata(linklist L, int x, int y) {     linklist pOne = L, pTwo = L->next, pTemp = NULL;      //遍历查找符合条件的结点     while ( pTwo != NULL )     {         if ( pTwo->data > x && pTwo->data <= y )         {             pTemp = pTwo;             pOne->next = pTwo->next;             free(pTemp);             pTwo = pOne->next;             continue; #if 0             if ( pTwo->next != NULL )             {                 pOne->next = pTwo->next;                 pTemp = pTwo;                 free(pTemp);                 pTemp = NULL;                 pTwo = pOne;             }             else             {                 pOne->next = NULL;                 free(pTwo);                 pTwo = pOne;             } #endif         }         pOne = pTwo;         pTwo = pTwo->next;     } } 供参考～ 楼上写的没问题，如上是我在他的基础上修改的，可以对比一下～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "最好将main修改为 int main() {      int x,y;  \tlinklist pHead;     pHead = createLink();     AddNode(pHead);     printLink(pHead);  \tscanf(\"%d%d\",&x,&y);//指出x,y的范围     deletedata(pHead, x, y);     printLink(pHead);       system(\"pause\");     return 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "deletedata函数可以简化为如下 void deletedata(linklist L, int x, int y) {     linklist pOne = L, pTwo = L->next, pTemp = NULL;           //遍历查找符合条件的结点     while ( pTwo != NULL )     {         if (pTwo && pTwo->data > x && pTwo->data <= y )         {                 pOne->next = pTwo->next;                 pTemp = pTwo;                 free(pTemp);                 pTemp = NULL;                 pTwo = pOne;         }         pOne = pTwo;         pTwo = pTwo->next;     } }", "referer": "user-0"}]}
{"question": "用Dev_c++敲的程序输出的全是零", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "首先a是整型数，把整型数用%f输出输出0是可能的。  另外，a = 1.0 / 3 * 3;由于a是整型数，1.0/3  *3得到的结果可能是0.999xxxx；这样再转成整型数就是0了。  修改方法：  float a;//定义a为float类型 试试～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 Cardistalive的回复:将第4行代码: int a; 修改成 float a; 这样就将，原先数据类型为整型的数据a，修改成，支持有效数字至少为6位小数的单精度浮点型数据a ,以容纳第5行的计算结果 支持有效数字至少为6位的单精度浮点型数据", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "将第4行代码: int a; 修改成 float a; 这样就将，原先数据类型为整型的数据a，修改成，支持有效数字至少为6位小数的单精度浮点型数据a ,以容纳第5行的计算结果", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "double a；", "referer": "user-0"}]}
{"question": "调试过程中遇到的一个问题,不解..求 解答. ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 4 楼 UIUI 的回复:这个函数是返回了局部变量的地址，是无意义的。因为局部变量在函数调用结束后会自动释放的，不能再次使用了。可以考虑加上static将其变成全局变量；  void* CheckRangeInit(void) { #define MaxArray 50     static int i = 0;     static long temp[MaxArray][2] = { 0 };     if (i < 49)         return (void*)temp[i++];     else         return (void*)-1; }    确实加上 static 就可以了..  找了半天问题, 就是没想到这儿的问题. 谢谢. 奇怪! 为什么原贴中不写打印函数就可以直接用,不会有问题呢.[/quote]  在函数外使用局部变量是未定义行为，结果可能是随机的～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "这个函数是返回了局部变量的地址，是无意义的。因为局部变量在函数调用结束后会自动释放的，不能再次使用了。可以考虑加上static将其变成全局变量；  void* CheckRangeInit(void) { #define MaxArray 50     static int i = 0;     static long temp[MaxArray][2] = { 0 };     if (i < 49)         return (void*)temp[i++];     else         return (void*)-1; }  [/quote]  确实加上 static 就可以了..  找了半天问题, 就是没想到这儿的问题. 谢谢. 奇怪! 为什么原贴中不写打印函数就可以直接用,不会有问题呢.", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "啊平, 用VS2008 上述程序就没有问题.          用VS2019 就有问题......          如何避免.呀...", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "void* CheckRangeInit(void) { #define MaxArray 50     static int i = 0;     long temp[MaxArray][2] = { 0 };     if (i < 49)         return (void*)temp[i++];     else         return (void*)-1; }   这个函数是返回了局部变量的地址，是无意义的。因为局部变量在函数调用结束后会自动释放的，不能再次使用了。可以考虑加上static将其变成全局变量；  void* CheckRangeInit(void) { #define MaxArray 50     static int i = 0;     static long temp[MaxArray][2] = { 0 };     if (i < 49)         return (void*)temp[i++];     else         return (void*)-1; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "如果用 printf_s( printf)  改成 puts(),  句柄里的值也不会发生变化 . 怎么这么奇怪?", "referer": "user-0"}]}
{"question": "求最大公约数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 12 楼 m0_51348310 的回复:[quote=引用 11 楼 绿色盒子的回复:]报错？请贴出报错代码 default. c:1:4:error:stray'\\302'in program int Maxcommomdivisor(int a,int b) default. c:1:5:error:stray'\\240'in program int Maxcommomdivisor(int a,int b) default. c:1:26:error:stray'\\302'in program int Maxcommomdivisor(int a,int b)  default. c:1:27:error:stray'\\240'in program int Maxcommomdivisor(int a,int b)[/quote] 你这个是有非法字符，你可以尝试删除之后手打代码", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 11 楼 绿色盒子的回复:报错？请贴出报错代码 default. c:1:4:error:stray'\\302'in program int Maxcommomdivisor(int a,int b) default. c:1:5:error:stray'\\240'in program int Maxcommomdivisor(int a,int b) default. c:1:26:error:stray'\\302'in program int Maxcommomdivisor(int a,int b)  default. c:1:27:error:stray'\\240'in program int Maxcommomdivisor(int a,int b)", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "报错？请贴出报错代码", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "楼主复制了八楼、九楼的答案。虽然答案很厉害的样子，但运行时都显示错误。楼主只是个初学者啊，看不懂也改不了", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "int Maxcommomdivisor(int a, int b)  {     while(a%b){         int tmp = a;         a = b;         b = tmp%b;     }     return b; }", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "#include <iostream> using namespace std;  int Func(int a, int b) { \tint c = a%b; \tif (c == 0) \t{ \t\treturn b; \t} \telse \t{ \t\ta = b; \t\tb = c; \t\treturn Func(a,b); \t} }  int main() { \tint a, b; \tcout << \"输入两个数：\"; \tcin >> a; \tcin >> b; \tcout << \"接收到数据：\" << a << \"和\" << b << endl; \tcout << \"最大公约数为：\" << Func(a,b);     return 0; }", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "min=(a<b)?a:b;", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "楼主的min变量没初始化就直接使用，会有问题的～", "referer": "user-0"}, {"cid": "9", "user": "user-4", "content": "你想让大家帮你做啥呢", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 6 楼 一根烂笔头的回复:反过来计算，i值就是结果，省一次赋值         for(i=min;i>=1;i--)         {              if(a%i==0&&b%i==0)                break;         }  回六楼： 谢谢你的方法， 不过， 我的老师讲过这种从大到小的方法。 然而， 我需要的是从小到大的方法。", "referer": "user-0"}, {"cid": "11", "user": "user-5", "content": "反过来计算，i值就是结果，省一次赋值         for(i=min;i>=1;i--)         {              if(a%i==0&&b%i==0)                break;         }", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "楼主写了一个程序（错的）。老师发现后，添加了一个变量使程序正确。然后老师要求楼主用另一种方法修正程序。 楼主写的程序： #include<stdio.h> int main() {       int a,b,min,i;       scanf(\"%d,%d\",&a,&b);        min=(a<b)? a:b;        for(i=1;i<=min;i++)         {              if(a%i==0&&b%i==0)                continue;         }        printf(\"输出最大公约数%d\",i-1); } 老师写的程序： #include<stdio.h> int main() {       int a,b,min,x,i;       scanf(\"%d,%d\",&a,&b);        min=(a<b)? a:b;        for(i=1;i<=min;i++)         {              if(a%i==0&&b%i==0)                x=i;         }        printf(\"输出最大公约数%d\",x); }", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "楼主写了一个代码（可惜是错的），如下： #include<stdio.h> int main() {       int a,b,min,i;       scanf(\"%d,%d\",&a,&b);        min=(a<b)? a:b;        for(i=1;i<=min;i++)         {              if(a%i==0&&b%i==0)                continue;         }        printf(\"输出最大公约数%d\",i-1); } 老师发现后改为 #include<stdio.h> int main() {       int a,b,min,x,i;       scanf(\"%d,%d\",&a,&b);        min=(a<b)? a:b;        for(i=1;i<=min;i++)         {              if(a%i==0&&b%i==0)                x=i;         }        printf(\"输出最大公约数%d\",x); } 然后，老师要求我用另一种方法从小到大筛选最大公约数。", "referer": "user-0"}]}
{"question": "求大佬帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-2的回复:for 后面的分号去掉 我昨晚解决了，原来的空格的内循环没效果", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:for 后面的分号去掉 不好使的我试了", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "看逻辑上，可以再优化下 假设你的金子塔有n层，你需要输出n行，每行有两个东西 ：1.前面的空格，2.字母 第一行  前面是（n-1)/2个空格 1个字母  第二行  前面是  (n-2)/2个空格 2个字母  以此类推  第i行 前面输出(n-i)/个空格  i个字母  这样两层循环就可以了", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "for 后面的分号去掉", "referer": "user-0"}]}
{"question": "求求C语言大佬带带萌新", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "你的循环里面 下面那个break多余了，会导致循环只执行以此就退出了，把它去掉", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h>  int main(void) {     int n,even=0,odd=0;     float sumeven=0,sumodd=0;     while(1)     {         scanf(\"%d\",&n);         if(n==0){             break;         }          if(n%2==0)         {             sumeven+=n;             even++;         }         else         {             sumodd+=n;             odd++;         }         //break;     }     printf(\"Number of even:%d;Average of even:%.2f\\n\",even,sumeven/even);     printf(\"Number of odd:%d;Average of odd:%.2f\\n\",odd,sumodd/odd);      return 0; } 供参考～  多一个break；", "referer": "user-0"}]}
{"question": "OJ练习题   C语言求解  输入N后输出1+1/2+1/3+…+1/N的和", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-3的回复:i是int，所以1/i被转成int，i大于1时int结果就是0 所以改成 sum=sum+1.0/i //1.0是double，就算结果就不再是int了 谢谢！！！！！！知道哪里错了就舒服多了！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "1/i；由于i是int类型，因此1/i是按照整型数的除法来计算的，因此得到的是整型的结果，如果改成1.0/i，由于1.0编译器会认为其是double，所以1.0/i是按照浮点数来计算除法，因此得到的是double结果。", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "是个好方法！谢谢", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "逐步学会调试程序，是找到程序问题的关键。 在此题中，可以在循环中增加显示i/1的值的输出语句，观察输出结果，以判断问题出在何处，从而找出解决问题的方法", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 自信男孩的回复:1/i；由于i是int类型，因此1/i是按照整型数的除法来计算的，因此得到的是整型的结果，如果改成1.0/i，由于1.0编译器会认为其是double，所以1.0/i是按照浮点数来计算除法，因此得到的是double结果。 嗯嗯，好的好的👌，谢谢", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "i是int，所以1/i被转成int，i大于1时int结果就是0 所以改成 sum=sum+1.0/i //1.0是double，就算结果就不再是int了", "referer": "user-0"}]}
{"question": "求一个编程技巧...", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "ptHandle 是void*，可以指向很多类型，比如数组（int *)，甚至结构体。所以，void * 可以存储N多东西的。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "主要问题是最后一个函数怎么实现的.", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "不客气！学习愉快~~", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "非常感谢你的回复.   谢谢呀. 真的谢谢.", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> void* CheckRangeInit(void); void  CheckRangeExit(void *); void  CheckRangeSet(void* ptHandle, long ForOffset, long BackOffset, long Target, long Resolution); unsigned short CheckRangeDetect(void* ptHandle, long Current);   int main(void) {     void* test1 = 0;     test1 = CheckRangeInit();  //为每一个变量分配地址.  我猜的.     //实际数值在40 与 70 之单     CheckRangeSet(test1, 10, 20, 50, 360);  //设置 检测检测范围      // test1 当前值为60 在40与70之间, 所以打印. Yes!     if(CheckRangeDetect(test1, 60))         printf(\"Yes!\\n\");     else         printf(\"No!\\n\");      CheckRangeExit(test1);     return 0; } void* CheckRangeInit(void) //为每个变量分配一个地址, 如果是这样, 我可以实现. {     return (void *)malloc(sizeof(long)*4); } void  CheckRangeExit(void * r) {     long * rp = (long *)r;     free(rp); }  //这个函数,我不会实现, /* 参数1是 变量句柄 参数2是 最小, 参数3是 最大 参数4是 基准值 参数5是 最大范围值.只能在范围值内偏移.  */ void  CheckRangeSet(void* ptHandle, long ForOffset, long BackOffset, long Target, long Resolution) {     long * set = (long *) ptHandle;     set[0] = ForOffset;     set[1] = BackOffset;     set[2] = Target;     set[3] = Resolution; } /* 检测 当前值是否在设置的最小最大范围内. 我的主要疑问是这个函数. ptHandle 里面只能存一个数字, 然后,用当前值怎么去和两个数字(最小值,最大值) 比大小呢? */ unsigned short CheckRangeDetect(void* ptHandle, long Current) {     const long * set = (const long *) ptHandle;     return Current >= set[2] - set[0] && Current <=set[2] + set[1]; }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "也不知道我想的对不对，初始化函数中，可能有一个2维数组，返回值一个地址，该地址中指向的地方是一个2维数组，然后，那个设置函数，把最大值与最小值 计算后，存到相应句柄地址的数组中，这样，每一个句柄实际上有两个变量，所以最后一个比较大小的函数直接取出来用就可以。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 丁劲犇 的回复:ptHandle 是void*，可以指向很多类型，比如数组（int *)，甚至结构体。所以，void * 可以存储N多东西的。  void * 这个我明白.我主要是没明白  unsigned short CheckRangeDetect(void* ptHandle, long Current) 主要是这个我没明白, 他是怎么实现只用一个 pthandle 来与当前值对比的.  如果我做这个东西. 我只会一个简单的方法.  void  CheckRangeSet(void* ptHandle, long ForOffset, long BackOffset, long Target, long Resolution) {   } 在这个里面, 计算出,最大值,与最小值, 然后, 存放到 两个全局变量中.. 然后,用 CheckRangeDetect () 这个函数 读入当前值,来与 那两个全局变量作比较.,然后,返回 0 或1.  可是,我看别人的程序的时候, 是没有设置那两个全局变量呀.", "referer": "user-0"}]}
{"question": "关于stdout是行缓冲的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "能把你的程序出来看看吗？谢谢！", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "因为程序退出了，那么行也结束了。stderr是无缓冲的，会直接输出； 楼主的程序，在我的代码里运行的是 World!Hello", "referer": "user-0"}]}
{"question": "关于c语言链表指针的一些问题，希望大神帮我解答，感谢！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 11 楼 qybao的回复:我觉得已经讲的挺清楚了，只是你没好好理解。 free只是设置一个flag告诉系统这块内存不再使用了，系统可以把这块内存让给其他程序使用。但是并不代表立刻有别的程序来占用这块内存，所以这块内存的信息一时半会没有被擦写，还是原来的老信息，所以可能继续访问时还能读出原来的信息。 然而一旦这块内存被系统重新份配给别的程序，别的程序就有可能重新修改了这块内存的信息，那么这块内存的信息就未必符合原来的结构体形式，比如原来老信息是一个int，一个长度为10的char数组，新的信息是一个char，一个int，这样你按原来的结构体形式来读取，结果必然出错，而且新的内存空间没有老的内存空间大，按原来的结构体形式读取还可能造成越界。打个比方，原来某个地址有一块地被你租用，你建了一栋500平米的楼房，后来你free把地退租了，地和楼房被房东收回，此时房东还没把楼拆了，你偷偷溜回来那自然还可以正常使用房子，然而如果房东把它拆了把地分割租给了别的租户，别的租户只建了50平米的平房租，这时你非要闯进人家的平房，并按原来500平米的楼房来使用，那可不就出错了吗？而且，人家平房的租客有可能把门锁了不让你进来，你进不来不就造成非法访问了吗？ 所以，同样是野指针，也分野指针指向的地址是什么情况，楼房还没拆，那就一时半会还能使用，楼房拆了被改建为平房了，那如果平房们没锁你还可以溜进去，只是房子布局不一样了，人家没2楼你非要上2楼，那就会出错，甚至如果平房锁着禁止进入，你就成了非法入侵的窃贼。 所以，你在delete函数里的野指针属于楼房没拆的情况（地址是明确的，只是房东还没来得及拆楼）；在main里的野指针属于没有乱闯入民宅并把民宅当楼房使用的情况（因为没分配过内存，地址是随机的，也就是你随机闯入任何一家民宅）。 能理解吗？ 我理解了，大神别生气，本人比较愚笨，还有一小点儿疑问，，就是 我上面 又重新定义了一个方法void 在 void方法里面定义了一个指针 freeaid 这个时候，这个指针还没有分配内存，这个野指针跟free函数里，已经指向了被释放空间的指针(被释放前不是野指针，释放后就是野指针了)的情况还不太一样。 我在void的方法里面调num参数也是能打印出值的，也没有报错。但是在main里 随便定义一个*stu类型的指针 取他的 num值就会报错(这个经过你的提点我已经知道是咋回事了)   我就是想知道。为啥 同样都是没分配空间的野指针，在主函数就会报错，在void函数里就不会报错   大神关于房子的解答真的很形象，我理解的更透彻了。感谢。。。100分都是你的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "我觉得已经讲的挺清楚了，只是你没好好理解。 free只是设置一个flag告诉系统这块内存不再使用了，系统可以把这块内存让给其他程序使用。但是并不代表立刻有别的程序来占用这块内存，所以这块内存的信息一时半会没有被擦写，还是原来的老信息，所以可能继续访问时还能读出原来的信息。 然而一旦这块内存被系统重新份配给别的程序，别的程序就有可能重新修改了这块内存的信息，那么这块内存的信息就未必符合原来的结构体形式，比如原来老信息是一个int，一个长度为10的char数组，新的信息是一个char，一个int，这样你按原来的结构体形式来读取，结果必然出错，而且新的内存空间没有老的内存空间大，按原来的结构体形式读取还可能造成越界。打个比方，原来某个地址有一块地被你租用，你建了一栋500平米的楼房，后来你free把地退租了，地和楼房被房东收回，此时房东还没把楼拆了，你偷偷溜回来那自然还可以正常使用房子，然而如果房东把它拆了把地分割租给了别的租户，别的租户只建了50平米的平房租，这时你非要闯进人家的平房，并按原来500平米的楼房来使用，那可不就出错了吗？而且，人家平房的租客有可能把门锁了不让你进来，你进不来不就造成非法访问了吗？ 所以，同样是野指针，也分野指针指向的地址是什么情况，楼房还没拆，那就一时半会还能使用，楼房拆了被改建为平房了，那如果平房们没锁你还可以溜进去，只是房子布局不一样了，人家没2楼你非要上2楼，那就会出错，甚至如果平房锁着禁止进入，你就成了非法入侵的窃贼。 所以，你在delete函数里的野指针属于楼房没拆的情况（地址是明确的，只是房东还没来得及拆楼）；在main里的野指针属于没有乱闯入民宅并把民宅当楼房使用的情况（因为没分配过内存，地址是随机的，也就是你随机闯入任何一家民宅）。 能理解吗？", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "我觉得已经讲的挺清楚了，只是你没好好理解。 free只是设置一个flag告诉系统这块内存不再使用了，系统可以把这块内存让给其他程序使用。但是并不代表立刻有别的程序来占用这块内存，所以这块内存的信息一时半会没有被擦写，还是原来的老信息，所以可能继续访问时还能读出原来的信息。 然而一旦这块内存被系统重新份配给别的程序，别的程序就有可能重新修改了这块内存的信息，那么这块内存的信息就未必符合原来的结构体形式，比如原来老信息是一个int，一个长度为10的char数组，新的信息是一个char，一个int，这样你按原来的结构体形式来读取，结果必然出错，而且新的内存空间没有老的内存空间大，按原来的结构体形式读取还可能造成越界。打个比方，原来某个地址有一块地被你租用，你建了一栋500平米的楼房，后来你free把地退租了，地和楼房被房东收回，此时房东还没把楼拆了，你偷偷溜回来那自然还可以正常使用房子，然而如果房东把它拆了把地分割租给了别的租户，别的租户只建了50平米的平房租，这时你非要闯进人家的平房，并按原来500平米的楼房来使用，那可不就出错了吗？而且，人家平房的租客有可能把门锁了不让你进来，你进不来不就造成非法访问了吗？ 所以，同样是野指针，也分野指针指向的地址是什么情况，楼房还没拆，那就一时半会还能使用，楼房拆了被改建为平房了，那如果平房们没锁你还可以溜进去，只是房子布局不一样了，人家没2楼你非要上2楼，那就会出错，甚至如果平房锁着禁止进入，你就成了非法入侵的窃贼。 所以，你在delete函数里的野指针属于楼房没拆的情况（地址是明确的，只是房东还没来得及拆楼）；在main里的野指针属于没有乱闯入民宅并把民宅当楼房使用的情况（因为没分配过内存，地址是随机的，也就是你随机闯入任何一家民宅）。 能理解吗？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 6 楼 qybao的回复:[quote=引用 5 楼 qq_35541626 的回复：]感谢两位大大的答复，我把之前的代码改了一下，现在p_freeAid可以打印 p_free->next->num 的值了。  void free_node(STU **p_head){     STU*p_free;     STU*p_freeAid;     printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid->num);     p_free=*p_head;     if(*p_head==NULL){         printf(\"这个链表为空，无需释放\\n\");     }     else{         while (p_free!=NULL) {             p_freeAid=p_free->next;             if(p_freeAid!=NULL){                 printf(\"p_freeAid0000000的值是：0X%x\\n\",p_free->next->num);             }              printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid);             printf(\"p_free的值是：0X%x\\n\",p_free->next);             int num=p_free->num;             printf(\"%d\\n\",num);             free(p_free);             printf(\"%d\\n\",p_free->num);             p_free=p_freeAid;         }     }     //*p_head=NULL; }   但是又有一些新的问题出现。 int main() {     STU* link_head=NULL;    STU*test_01;    //test();    printf(\"0X%x\\n\",test_01);    //printf(\"0X%x\\n\",test_01->num);     //test_01=NULL;    int num=test_01->num;    printf(\"0X%x\\n\",test_01);     return 0; }  我在主函数 main 里面直接定义了一个 STU格数的test函数，然后直接调test->num.果然出现了，之前那样的段错误提醒。  但是 void test(){     STU*test_02;     printf(\"0X%x\\n\",test_02->num); }  int main() {     STU* link_head=NULL;    STU*test_01;    test();    printf(\"0X%x\\n\",test_01);    //printf(\"0X%x\\n\",test_01->num);     //test_01=NULL;    int num=test_01->num;    printf(\"0X%x\\n\",test_01);     return 0; }  当我在函数 test里面定义了一个STU类型的*test指针，然后调用test函数，这里编译通过，然后值就出来了（虽然是没有意义的值，但是编译通过了），所以我就不太明白，同样都是指空的指针，为什么一个出现了段错误，一个没有。 这也是我一直想不明白的。 就是我在最开始的链表释放函数node_free里面，刚开始定义的指针 *stu p_freeAid 后，马上打印p_freeAid->num 是有值的，但是当我给他赋值，free->next的时候，他就出现了段错误。 所以我的核心问题就是 同样都是野指针，然后我调里面的值，为什么一个直接出现段错误，一个就没有，能打出来值（虽然值没有什么意义。。）  还有一个问题就是我之前的 链表释放函数node_free里面，我已经free过的空间，我再次用 p_free去调里面的值，按理说，这时空间已经被释放，这个时候，p-free就是个野指针，我用debug看，p-free里面的值已经变成了“-16168940”之类的数，我理解就是已经释放掉了，但是我用p-free去调里面的 num 居然可以打印出来值，也没有报段错误，那么我这个free（）函数究竟有没有生效呢？ 这种情况应该怎么解释呢？ 费解....  再次感谢两位大大的解答，谢谢。 既然是野指针，那就说明指针指向的地址是不确定的。你刚释放内存，又继续访问该内存，如果该内存没有被其他程序占用，那你访问它不会出错；如果该内存被其他程序占用了，那就有问题了，如果该内存被其他程序设定不可读写，你非要读写，就会出非法内存访问错误了。[/quote] 你好，非常感谢您的回复，但是我的问题是 我free了之后，为什么访问被free的区域还是有值，我也知道不能访问，但是访问之后为什么有值是我比较纠结的，所以我这个free到底有没有成功?  还有就是 为什么我同样都是野指针，我在函数里面调值就可以调，但是在主函数那里就会报段错误。这两个问题请您再解释一下。 解决完问题我就结帖了。   希望您再回复一下。谢谢。", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 7 楼 赵4老师的回复:数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633 您好，请您再看下我的问题好不，我不是纠结链表怎么做，我是在纠结c语言本身的机制问题，为什么free了还有数值，还有 为什么 同样都是野指针，在函数里定义野指针就不会报段错误，在主方法里定义就会报段错误呢？", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用 5 楼 qq_35541626 的回复：感谢两位大大的答复，我把之前的代码改了一下，现在p_freeAid可以打印 p_free->next->num 的值了。  void free_node(STU **p_head){     STU*p_free;     STU*p_freeAid;     printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid->num);     p_free=*p_head;     if(*p_head==NULL){         printf(\"这个链表为空，无需释放\\n\");     }     else{         while (p_free!=NULL) {             p_freeAid=p_free->next;             if(p_freeAid!=NULL){                 printf(\"p_freeAid0000000的值是：0X%x\\n\",p_free->next->num);             }              printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid);             printf(\"p_free的值是：0X%x\\n\",p_free->next);             int num=p_free->num;             printf(\"%d\\n\",num);             free(p_free);             printf(\"%d\\n\",p_free->num);             p_free=p_freeAid;         }     }     //*p_head=NULL; }   但是又有一些新的问题出现。 int main() {     STU* link_head=NULL;    STU*test_01;    //test();    printf(\"0X%x\\n\",test_01);    //printf(\"0X%x\\n\",test_01->num);     //test_01=NULL;    int num=test_01->num;    printf(\"0X%x\\n\",test_01);     return 0; }  我在主函数 main 里面直接定义了一个 STU格数的test函数，然后直接调test->num.果然出现了，之前那样的段错误提醒。  但是 void test(){     STU*test_02;     printf(\"0X%x\\n\",test_02->num); }  int main() {     STU* link_head=NULL;    STU*test_01;    test();    printf(\"0X%x\\n\",test_01);    //printf(\"0X%x\\n\",test_01->num);     //test_01=NULL;    int num=test_01->num;    printf(\"0X%x\\n\",test_01);     return 0; }  当我在函数 test里面定义了一个STU类型的*test指针，然后调用test函数，这里编译通过，然后值就出来了（虽然是没有意义的值，但是编译通过了），所以我就不太明白，同样都是指空的指针，为什么一个出现了段错误，一个没有。 这也是我一直想不明白的。 就是我在最开始的链表释放函数node_free里面，刚开始定义的指针 *stu p_freeAid 后，马上打印p_freeAid->num 是有值的，但是当我给他赋值，free->next的时候，他就出现了段错误。 所以我的核心问题就是 同样都是野指针，然后我调里面的值，为什么一个直接出现段错误，一个就没有，能打出来值（虽然值没有什么意义。。）  还有一个问题就是我之前的 链表释放函数node_free里面，我已经free过的空间，我再次用 p_free去调里面的值，按理说，这时空间已经被释放，这个时候，p-free就是个野指针，我用debug看，p-free里面的值已经变成了“-16168940”之类的数，我理解就是已经释放掉了，但是我用p-free去调里面的 num 居然可以打印出来值，也没有报段错误，那么我这个free（）函数究竟有没有生效呢？ 这种情况应该怎么解释呢？ 费解....  再次感谢两位大大的解答，谢谢。 既然是野指针，那就说明指针指向的地址是不确定的。你刚释放内存，又继续访问该内存，如果该内存没有被其他程序占用，那你访问它不会出错；如果该内存被其他程序占用了，那就有问题了，如果该内存被其他程序设定不可读写，你非要读写，就会出非法内存访问错误了。", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "p_freeAid=p_free->next; //如果p_free->next是NULL，p_freeAid就是NULL，否则你后面的p_free=p_freeAid是怎么让p_free变为NULL而退出while循环？所以，此时p_freeAid是NULL，打印p_freeAid->num就出错。这和你的showlink可是有区别的，showlink是先打印p_mov->num，然后才p_mov=p_mov->next，所以p_mov为NULL就退出while了不会继续打印p_mov->num，所以showlink不会出错", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "感谢两位大大的答复，我把之前的代码改了一下，现在p_freeAid可以打印 p_free->next->num 的值了。  void free_node(STU **p_head){     STU*p_free;     STU*p_freeAid;     printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid->num);     p_free=*p_head;     if(*p_head==NULL){         printf(\"这个链表为空，无需释放\\n\");     }     else{         while (p_free!=NULL) {             p_freeAid=p_free->next;             if(p_freeAid!=NULL){                 printf(\"p_freeAid0000000的值是：0X%x\\n\",p_free->next->num);             }              printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid);             printf(\"p_free的值是：0X%x\\n\",p_free->next);             int num=p_free->num;             printf(\"%d\\n\",num);             free(p_free);             printf(\"%d\\n\",p_free->num);             p_free=p_freeAid;         }     }     //*p_head=NULL; }   但是又有一些新的问题出现。 int main() {     STU* link_head=NULL;    STU*test_01;    //test();    printf(\"0X%x\\n\",test_01);    //printf(\"0X%x\\n\",test_01->num);     //test_01=NULL;    int num=test_01->num;    printf(\"0X%x\\n\",test_01);     return 0; }  我在主函数 main 里面直接定义了一个 STU格数的test函数，然后直接调test->num.果然出现了，之前那样的段错误提醒。  但是 void test(){     STU*test_02;     printf(\"0X%x\\n\",test_02->num); }  int main() {     STU* link_head=NULL;    STU*test_01;    test();    printf(\"0X%x\\n\",test_01);    //printf(\"0X%x\\n\",test_01->num);     //test_01=NULL;    int num=test_01->num;    printf(\"0X%x\\n\",test_01);     return 0; }  当我在函数 test里面定义了一个STU类型的*test指针，然后调用test函数，这里编译通过，然后值就出来了（虽然是没有意义的值，但是编译通过了），所以我就不太明白，同样都是指空的指针，为什么一个出现了段错误，一个没有。 这也是我一直想不明白的。 就是我在最开始的链表释放函数node_free里面，刚开始定义的指针 *stu p_freeAid 后，马上打印p_freeAid->num 是有值的，但是当我给他赋值，free->next的时候，他就出现了段错误。 所以我的核心问题就是 同样都是野指针，然后我调里面的值，为什么一个直接出现段错误，一个就没有，能打出来值（虽然值没有什么意义。。）  还有一个问题就是我之前的 链表释放函数node_free里面，我已经free过的空间，我再次用 p_free去调里面的值，按理说，这时空间已经被释放，这个时候，p-free就是个野指针，我用debug看，p-free里面的值已经变成了“-16168940”之类的数，我理解就是已经释放掉了，但是我用p-free去调里面的 num 居然可以打印出来值，也没有报段错误，那么我这个free（）函数究竟有没有生效呢？ 这种情况应该怎么解释呢？ 费解....  再次感谢两位大大的解答，谢谢。", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid->num); 这条语句是在哪里打印的，从你的函数里可以知道，这条语句是在定义两个变量后直接打印的，你定义的变量没有初始化呀，没初始化就是野指针，之所以说是可能出现段错误，是因为野指针指向的位置可能是不可以读写的，既然不可以读写，那么必然会出现段错误。   //printf(\"p_freeAid的值是：0X%x\\n\",p_free->next->num); 这条语句是因为不能保证p_free->next指向的内容不是链表的末尾，如果指向了链表末尾，即NULL，那么这条语句打印必然会导致段错误～", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "你好，首先非常感谢您的解答，我初学c，以前用Java模拟过链表，但是好像没c语言要考虑的那么多。关于您的回答我还是有一些疑问。 “printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid->num);这句之前p_freeAid是野指针，这样操作可能导致段错误” 关于这句话，P-freeAid 的指向，我认为明明是指向 p-free->next 的。 而且在执行这行代码的时候，明明在free.next里面还是有值的。所以按照我的理解P-freeAid里面应该是有值的，而且 我debug里面， p-freeAid里面的“num”也是有值的，但是我用 printf函数调的时候，程序就进行不下去，所以就不太理解，所以还是希望您能就这点再给解答一下。  而且之前那个 showLink函数里面，我就把p_head->next的值赋给了p_mov。然后我在打印的时候  就是调用的 p_mov->num,来取值的。 在free函数里面 我用p_freeAid 来接收 p_free->next的值，然后同样想调用 p_freeAid->num 来取值为什么就不行了呢？   费解中。。。。", "referer": "user-0"}, {"cid": "12", "user": "user-3", "content": "在free_node函数里有多处问题， 1. printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid->num);这句之前p_freeAid是野指针，这样操作可能导致段错误； 2.  printf(\"p_freeAid的值是：0X%x\\n\",p_free->next->num);这条打印也可能出现多错误，因为p_free不是NULL，不等于p_free->next不为NULL； 3.  free(p_free);             printf(\"%d\\n\",p_free->num); 在释放之后打印这条语句，结果是未定义的，因为已经释放的空间，其内容具有不确定性，释放的空间不能再次直接使用，需要重新malloc； 4.  //*p_head=NULL;这句不能注释掉，因为头结点已经释放掉了，为了保证后面对头结点的使用不出现问题，这句需要加上（去掉注释）；  void free_node(STU **p_head) {     STU*p_free;     STU*p_freeAid;     //printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid->num);     p_free=*p_head;     if(*p_head==NULL){         printf(\"这个链表为空，无需释放\\n\");         return;     }     //else{     while (p_free!=NULL) {         p_freeAid=p_free->next;         //printf(\"p_freeAid的值是：0X%x\\n\",p_free->next->num);         printf(\"p_freeAid的值是：0X%x\\n\",p_freeAid);         printf(\"p_free的值是：0X%x\\n\",p_free->next);         int num=p_free->num;         printf(\"%d\\n\",num);         free(p_free);         printf(\"%d\\n\",p_free->num);         p_free=p_freeAid;     }     //}     *p_head=NULL; } 代码逻辑可以稍微改一下，去掉else， 另外，打印指针建议用%p", "referer": "user-0"}]}
{"question": "请问这个题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 均陵鼠侠 的回复:[quote=引用 2 楼 我当时害怕极了QAQ 的回复:][quote=引用 1 楼 均陵鼠侠 的回复:]谢邀。 题目不是问CPU如何选择，是问CPU如何用地址线来访问模块板。第（5）回答已经明确了。  嗯，就是那个最高3位，次高3位是怎么得出来的呢？[/quote]  不管地址线几根，从中划出N根线，可以访问的模块板是2^N块，剩余的线访问模块板内的芯片。从剩余部分划出M根线，可访问的芯片数量是2^M。你用这个方法倒推一下。[/quote]  引用 5 楼 qybao 的回复:模板块总数=8=2^3，即用3位即可覆盖模板号代表的地址信息 因为是8位机，芯片只有4位，所以用两片芯片组合成8位，比如A芯片负责高4位，B芯片负责低4位，这样就能从8位换算的结果区分是A芯片B芯片（比如是0-127就是B，128-255就是A），这样32k/4k=8=2^3，用3位也能覆盖芯片号代表的地址信息  懂了懂了，谢谢大神", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "剩下的就是18-3-3=12位，用来区分片内地址", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "模板块总数=8=2^3，即用3位即可覆盖模板号代表的地址信息 因为是8位机，芯片只有4位，所以用两片芯片组合成8位，比如A芯片负责高4位，B芯片负责低4位，这样就能从8位换算的结果区分是A芯片B芯片（比如是0-127就是B，128-255就是A），这样32k/4k=8=2^3，用3位也能覆盖芯片号代表的地址信息", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 3 楼 均陵鼠侠 的回复:[quote=引用 2 楼 我当时害怕极了QAQ 的回复:][quote=引用 1 楼 均陵鼠侠 的回复:]谢邀。 题目不是问CPU如何选择，是问CPU如何用地址线来访问模块板。第（5）回答已经明确了。  嗯，就是那个最高3位，次高3位是怎么得出来的呢？[/quote]  不管地址线几根，从中划出N根线，可以访问的模块板是2^N块，剩余的线访问模块板内的芯片。从剩余部分划出M根线，可访问的芯片数量是2^M。你用这个方法倒推一下。[/quote]  嗯嗯，N=3我懂了，M不会求。。", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "引用 2 楼 我当时害怕极了QAQ 的回复:[quote=引用 1 楼 均陵鼠侠 的回复:]谢邀。 题目不是问CPU如何选择，是问CPU如何用地址线来访问模块板。第（5）回答已经明确了。  嗯，就是那个最高3位，次高3位是怎么得出来的呢？[/quote]  不管地址线几根，从中划出N根线，可以访问的模块板是2^N块，剩余的线访问模块板内的芯片。从剩余部分划出M根线，可访问的芯片数量是2^M。你用这个方法倒推一下。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 均陵鼠侠 的回复:谢邀。 题目不是问CPU如何选择，是问CPU如何用地址线来访问模块板。第（5）回答已经明确了。  嗯，就是那个最高3位，次高3位是怎么得出来的呢？", "referer": "user-0"}, {"cid": "7", "user": "user-2", "content": "谢邀。 题目不是问CPU如何选择，是问CPU如何用地址线来访问模块板。第（5）回答已经明确了。", "referer": "user-0"}]}
{"question": "这么简单怎么不会呢？？？ 啊 我.. 我...不会[face]qq:9.gif[/face]", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "输入会不会 判断奇数偶数会不会 其他会不会 都会 你已经能写出来了 都不会 看书去", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "如果一点不会，那要找一下自己的问题～这个问题确实不难，动手写一下，遇到具体问题再发出来～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "我写出来了，写出来了！ 在此谢谢两位！", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "自己的作业自己做。 你写完代码结果不对可以贴上来。相信有人可以帮你看看", "referer": "user-0"}]}
{"question": "小白想请教一个关于C语言指针的问题，大神可不可以指点一下，用的是VS2019", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 9 楼 lin5161678 的回复:[quote=引用 7 楼 自信男孩 的回复:] 跟出栈顺序是有关系的，当然也跟入栈舒心有关了。  这两个参数那个先出栈，那个表达式就要先计算了。不然，怎么解释楼主的输出呢？ 哪怕是按照入栈理解你的解释也是错的 两个++ 一个操作p 一个操作某个元素的y 也就是说p只操作1次 也就是说没越界  你按照越界理解才是错误的解释  顺便如果入栈顺序能解释 请你解释#4的结果 [/quote] 第二个结构体，我的测试结果是：4,3 不是4,4 可以查一下传参，对于参数是表达式的是传表达式还是传值。参数传递是传值吧，怎么传值呢，必然先计算；所以printf打印之前是先把值计算出来再穿进去了，既然这样跟入参的顺序是有关系的～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 7 楼 自信男孩 的回复:跟出栈顺序是有关系的，当然也跟入栈舒心有关了。  这两个参数那个先出栈，那个表达式就要先计算了。不然，怎么解释楼主的输出呢？ 哪怕是按照入栈理解你的解释也是错的 两个++ 一个操作p 一个操作某个元素的y 也就是说p只操作1次 也就是说没越界  你按照越界理解才是错误的解释  顺便如果入栈顺序能解释 请你解释#4的结果", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 5 楼 lin5161678 的回复:[quote=引用 3 楼 自信男孩的回复:]函数调用，要把参数入栈，一般参数入栈是从左向右依次入栈的，因此出栈就是从右向左了，最后一个参数先出栈，也就是最后一个参数表达式先计算，这样可以解释第一个输出为什么是3,1；后面的一个是1；但是对于3这个输出是随机的，因为p指向的内容已经是越界了～ 这是常见误解 入栈顺序和这个错误无关 这里出现错误是求值无序 而求值顺序和入栈顺序没有必然联系[/quote] 跟出栈顺序是有关系的，当然也跟入栈舒心有关了。  这两个参数那个先出栈，那个表达式就要先计算了。不然，怎么解释楼主的输出呢？", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "----------------------------------------------------再试图分析一波 printf(\"%d,%d\", (++p)->y,++p->y); 从结果上看，标准仅规定了在执行printf第一个语句之前。一定会完成【对p的自增】以及【对p中y的自增】两个副作用 但并没有明确具体时间与具体顺序。 乍一看两个自增副作用是彼此独立的。但实际上是存在相互影响的可能的", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 19 楼 lin5161678 的回复:[quote=引用 18 楼 自信男孩 的回复:] 这个结果跟入栈参数的顺序有关系 没看懂吗  入栈是从右到左 但计算顺序和这个没关系 (++p)->y 他可以计算++p 后面不计算->y 而是求值另一个参数 中间的参数求值完成 再把最后的参数的 ->y处理完 这个求值顺序你说和入栈顺序有关系? 这不是胡扯么  [/quote] 我的想法是入栈顺序决定了计算顺序，你的理论是跟入栈没关系，先计算后入栈（我是赞同的，但是先计算哪个实参的问题，先计算那个实参，会导致p的指向指向那个结构元素问题）", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "引用 21 楼 千梦一生 的回复:不过非要去讨论他是怎么算出这些答案的实属浪费时间。 正常人正常情况不会写出也不会遇到这样的写法。  如同讨论空气。 探讨就有探讨的价值，不是讨论空气。通过探讨希望能注意到更多的问题和知识点～", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "不过非要去讨论他是怎么算出这些答案的实属浪费时间。 正常人正常情况不会写出也不会遇到这样的写法。  如同讨论空气。", "referer": "user-0"}, {"cid": "8", "user": "user-3", "content": "printf(\"%d,%d\", ++p->y,(++p)->y); 这个地方的结果 4，4 只能想到一种顺序可能： <1>【p自增副作用完成】p指向第二个元素 <2>【p.y自增副作用完成】p.y变成4 <3>++p->y这个表达式的值作为参数入栈 <4>p->y这个表达式的值作为参数入栈 <5>call printf  <3><4>操作决定的入栈顺序也许可以交换，不过在这里实际没有区别。 所以<1><2><3><4>可以是（如果不考虑入栈顺序的前提之下）任何顺序进行。 ----------------------------------------------------------------------------------------------------------  这里有个重要的地方在于，一个容易忽略的概念： b = 1; a = ++b;  a获得的是等号右边表达式++b的值：在理论上是属于临时的，为'='操作符而生的临时变量。 而表达式++b的值仅仅是 2。 而 b的自增只保证在分号之前，和上一个分号之后。仍和时候去处理。任何时候，所以虽然是前置自增。但即便是在a赋值完毕之后b才自增完毕也是符合约定的。 ------------------------------------------------------------------------------------------------------------ func(b++); 这种我认为也是同理", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "引用 18 楼 自信男孩 的回复:这个结果跟入栈参数的顺序有关系 没看懂吗  入栈是从右到左 但计算顺序和这个没关系 (++p)->y 他可以计算++p 后面不计算->y 而是求值另一个参数 中间的参数求值完成 再把最后的参数的 ->y处理完 这个求值顺序你说和入栈顺序有关系? 这不是胡扯么", "referer": "user-0"}, {"cid": "10", "user": "user-1", "content": "引用 16 楼 lin5161678 的回复:[quote=引用 13 楼 自信男孩 的回复:] 对于楼主的结果，你的解释是什么？  你可以看到这个是从右到左传递参数的 但是结果是4 4  001C39D0  mov         eax,dword ptr [p]   001C39D3  add         eax,8  这个是++p 001C39D6  mov         dword ptr [p],eax   001C39D9  mov         ecx,dword ptr [p]   001C39DC  mov         edx,dword ptr [ecx+4]   001C39DF  add         edx,1  p存到寄存器eax 后+4是取结构体的y 然后add 1 这一段是计算 ++p->y  看到了么 (++p)->y 编译器可以就算一半 就去算++p->y 回头再计算 最后的参数的->y   并且 直到此刻 全部参数都没开始入栈 入栈顺序和求值毫无关系  都求值完了 再入栈也是完全合理的 [/quote] 我明白了，这个4是3+1得到的。++p->y这个++是对y而言的，不是p的++。  根据从右向左入栈，(++p)->y这个是p指向了第二个元素地址，这样传入的y是3。++p->y，因为p已经指向了第二个结构体元素，因此++p->y是对y的+1，因此得到的是4.  这是我的LInux下的编译和运行结果。所以我们的讨论还是在相同编译器下，不然讨论没有意义。  这个结果跟入栈参数的顺序有关系", "referer": "user-0"}, {"cid": "11", "user": "user-1", "content": "我是在LINUX编译运行的。另外，这个4是怎么回事？不是越界导致的？你的解释这个4是合理的吗？ss数组里没有4这个初始化项呢  引用 16 楼 lin5161678 的回复:[quote=引用 13 楼 自信男孩 的回复:] 对于楼主的结果，你的解释是什么？  你可以看到这个是从右到左传递参数的 但是结果是4 4  001C39D0  mov         eax,dword ptr [p]   001C39D3  add         eax,8  这个是++p 001C39D6  mov         dword ptr [p],eax   001C39D9  mov         ecx,dword ptr [p]   001C39DC  mov         edx,dword ptr [ecx+4]   001C39DF  add         edx,1  p存到寄存器eax 后+4是取结构体的y 然后add 1 这一段是计算 ++p->y  看到了么 (++p)->y 编译器可以就算一半 就去算++p->y 回头再计算 最后的参数的->y   并且 直到此刻 全部参数都没开始入栈 入栈顺序和求值毫无关系  都求值完了 再入栈也是完全合理的 [/quote]", "referer": "user-0"}, {"cid": "12", "user": "user-2", "content": "引用 13 楼 自信男孩 的回复:对于楼主的结果，你的解释是什么？  你可以看到这个是从右到左传递参数的 但是结果是4 4  001C39D0  mov         eax,dword ptr [p]   001C39D3  add         eax,8   这个是++p 001C39D6  mov         dword ptr [p],eax   001C39D9  mov         ecx,dword ptr [p]   001C39DC  mov         edx,dword ptr [ecx+4]   001C39DF  add         edx,1   p存到寄存器eax 后+4是取结构体的y 然后add 1 这一段是计算 ++p->y  看到了么 (++p)->y 编译器可以就算一半 就去算++p->y 回头再计算 最后的参数的->y   并且 直到此刻 全部参数都没开始入栈 入栈顺序和求值毫无关系  都求值完了 再入栈也是完全合理的", "referer": "user-0"}, {"cid": "13", "user": "user-1", "content": "引用 14 楼 lin5161678 的回复:[quote=引用 13 楼 自信男孩 的回复:] 咱们还是基于固定的编译器来谈吧，你的连接打不开。编译器不同，传参的顺序可能不一样，基于相同的编译器来分析比较合适～  对于楼主的结果，你的解释是什么？ 你不把传参顺序和求值顺序混为一谈 你会发现想怎么解释就怎么解释[/quote]  传参顺序解决定了p的指向问题。  你解释一下楼主的结果是什么原因吧～", "referer": "user-0"}, {"cid": "14", "user": "user-2", "content": "引用 13 楼 自信男孩 的回复:咱们还是基于固定的编译器来谈吧，你的连接打不开。编译器不同，传参的顺序可能不一样，基于相同的编译器来分析比较合适～  对于楼主的结果，你的解释是什么？ 你不把传参顺序和求值顺序混为一谈 你会发现想怎么解释就怎么解释", "referer": "user-0"}, {"cid": "15", "user": "user-1", "content": "引用 12 楼 lin5161678 的回复:[quote=引用 10 楼 自信男孩的回复:][quote=引用 9 楼 lin5161678 的回复:][quote=引用 7 楼 自信男孩 的回复:] 跟出栈顺序是有关系的，当然也跟入栈舒心有关了。  这两个参数那个先出栈，那个表达式就要先计算了。不然，怎么解释楼主的输出呢？ 哪怕是按照入栈理解你的解释也是错的 两个++ 一个操作p 一个操作某个元素的y 也就是说p只操作1次 也就是说没越界  你按照越界理解才是错误的解释  顺便如果入栈顺序能解释 请你解释#4的结果 [/quote] 第二个结构体，我的测试结果是：4,3 不是4,4 可以查一下传参，对于参数是表达式的是传表达式还是传值。参数传递是传值吧，怎么传值呢，必然先计算；所以printf打印之前是先把值计算出来再穿进去了，既然这样跟入参的顺序是有关系的～[/quote] https://ideone.com/zADGup 这是一个在线编译器的运行结果 请按照你的理论解释解释[/quote] 咱们还是基于固定的编译器来谈吧，你的连接打不开。编译器不同，传参的顺序可能不一样，基于相同的编译器来分析比较合适～  对于楼主的结果，你的解释是什么？", "referer": "user-0"}, {"cid": "16", "user": "user-2", "content": "引用 10 楼 自信男孩的回复:[quote=引用 9 楼 lin5161678 的回复:][quote=引用 7 楼 自信男孩 的回复:] 跟出栈顺序是有关系的，当然也跟入栈舒心有关了。  这两个参数那个先出栈，那个表达式就要先计算了。不然，怎么解释楼主的输出呢？ 哪怕是按照入栈理解你的解释也是错的 两个++ 一个操作p 一个操作某个元素的y 也就是说p只操作1次 也就是说没越界  你按照越界理解才是错误的解释  顺便如果入栈顺序能解释 请你解释#4的结果 [/quote] 第二个结构体，我的测试结果是：4,3 不是4,4 可以查一下传参，对于参数是表达式的是传表达式还是传值。参数传递是传值吧，怎么传值呢，必然先计算；所以printf打印之前是先把值计算出来再穿进去了，既然这样跟入参的顺序是有关系的～[/quote] https://ideone.com/zADGup 这是一个在线编译器的运行结果 请按照你的理论解释解释", "referer": "user-0"}, {"cid": "17", "user": "user-2", "content": "引用 10 楼 自信男孩的回复:[quote=引用 9 楼 lin5161678 的回复:][quote=引用 7 楼 自信男孩 的回复:] 跟出栈顺序是有关系的，当然也跟入栈舒心有关了。  这两个参数那个先出栈，那个表达式就要先计算了。不然，怎么解释楼主的输出呢？ 哪怕是按照入栈理解你的解释也是错的 两个++ 一个操作p 一个操作某个元素的y 也就是说p只操作1次 也就是说没越界  你按照越界理解才是错误的解释  顺便如果入栈顺序能解释 请你解释#4的结果 [/quote] 第二个结构体，我的测试结果是：4,3 不是4,4 可以查一下传参，对于参数是表达式的是传表达式还是传值。参数传递是传值吧，怎么传值呢，必然先计算；所以printf打印之前是先把值计算出来再穿进去了，既然这样跟入参的顺序是有关系的～[/quote] 你测试结果就是测试结果 其他人测试结果就不算？ 为什么", "referer": "user-0"}, {"cid": "18", "user": "user-1", "content": "函数调用，要把参数入栈，一般参数入栈是从左向右依次入栈的，因此出栈就是从右向左了，最后一个参数先出栈，也就是最后一个参数表达式先计算，这样可以解释第一个输出为什么是3,1；后面的一个是1；但是对于3这个输出是随机的，因为p指向的内容已经是越界了～", "referer": "user-0"}, {"cid": "19", "user": "user-2", "content": "未定义行为 结果没意义 不用讨论结果 更重要的是了解什么是未定义行为并避免写出这样的代码", "referer": "user-0"}, {"cid": "20", "user": "user-2", "content": "引用 3 楼 自信男孩的回复:函数调用，要把参数入栈，一般参数入栈是从左向右依次入栈的，因此出栈就是从右向左了，最后一个参数先出栈，也就是最后一个参数表达式先计算，这样可以解释第一个输出为什么是3,1；后面的一个是1；但是对于3这个输出是随机的，因为p指向的内容已经是越界了～ 这是常见误解 入栈顺序和这个错误无关 这里出现错误是求值无序 而求值顺序和入栈顺序没有必然联系", "referer": "user-0"}]}
{"question": "C语言编程加法运行后无法计算", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "可以采用单步执行的方法，或者在scanf下增加printf(\"%lf,%lf\",a,b)的输出语句，观察a，b的输出值，从而快速找到错误所在。实际上此题在编译时就会给出变量a,b没有使用的警告信息，从这个警告信息就可分析出问题所在", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "scanf的双引号的内容超出了，后面应该跟变量地址，楼主这样写导致scanf确实参数，%lf对应的参数；  \t scanf(\"%lf%lf\", &a, &b); 这样试一下～", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "scanf(\"%lf%lf\",&a,&b);", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "求各位大佬帮我解答一下  跪求", "referer": "user-0"}]}
{"question": "八分法画圆", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "搜Bresenham画圆算法，图形学最基础的东西", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "那咋画圆形呀", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "我只看到你画了8个点", "referer": "user-0"}]}
{"question": "如何生成从0-1亿之间的随机数，尽量不要循环和乘除法", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <time.h> unsigned long ulrand(void) {     return (      (((unsigned long)rand()<<24)&0xFF000000ul)     |(((unsigned long)rand()<<12)&0x00FFF000ul)     |(((unsigned long)rand()    )&0x00000FFFul)); } unsigned __int64 ullrand(void) {     return (      (((unsigned __int64)ulrand())<<32)     | ((unsigned __int64)ulrand())); } int i; unsigned long ul; unsigned __int64 ull; void main() {     srand(time(NULL));     for (i=0;i<10;i++) {         ul=ulrand();         printf(\"%010lu 0x%08x\\n\",ul,ul);     }     for (i=0;i<10;i++) {         ull=ullrand();         printf(\"%020I64u 0x%016I64x\\n\",ull,ull);     } } //3971076432 0xecb1d150 //2433428051 0x910b2a53 //1415415336 0x545d8628 //1312330759 0x4e389407 //1845758378 0x6e0409aa //0008069933 0x007b232d //4202720757 0xfa806df5 //2669855255 0x9f22c217 //0312068736 0x1299ca80 //2084555989 0x7c3fccd5 //03502077880857307931 0x3099e1472040ab1b //16884702393146816355 0xea52835e19b43763 //01877364819396611730 0x1a0dbd5b45f34e92 //07839440151924835771 0x6ccb4948756a05bb //09471412086917299176 0x8371371c820bfbe8 //04411255971577469925 0x3d37edef2f321be5 //13735846279546091130 0xbe9f876a65b7367a //04512980766520059820 0x3ea15418aa9927ac //15821377118299441610 0xdb90d2a9f1bb49ca //15512417228822200185 0xd7472d480398bf79", "referer": "user-0"}]}
{"question": "新手遇到的小问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "函数运用啊", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "main()函数中对max函数进行了声明和调用， 但是你没有定义max函数， 图片中int max(int x,int y)的部分也要打全。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int max(int a,int b);是函数声明，c=max(a,b)是函数调用，这里缺少函数的定义。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "很显然这是代码没打全。。  书上的max函数定义也要打呀  就是下面的int max(int x, int y)的那部分", "referer": "user-0"}, {"cid": "5", "user": "user-5", "content": "max函数的定义在哪里？如果需要用到库函数里的，建议引入math.h", "referer": "user-0"}]}
{"question": "vc++(绿色版)，程序编译没有错误，但是运行只弹出窗口却不能输入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "好的，十分感谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<malloc.h> #include<stdlib.h>    typedef struct Node {     char data;     struct Node *next; }NODE,*PNODE; //NODE等价于struct Node，PNODE等价于struct Node *  PNODE creat_linklist(); //创建单链表 PNODE travel_link( PNODE phead); //遍历单链表  int main() {     PNODE phead=NULL;     //PNODE creat_linklist();     phead = creat_linklist();     //PNODE travel_link( PNODE phead);     travel_link(phead); }    PNODE creat_linklist() {     int len; //用来存放有效节点的个数     int i;     char val;     PNODE pnew;//先定义     PNODE phead=(PNODE)malloc(sizeof(NODE));//向系统申请空间，表示头节点     if(phead==NULL)     {         printf(\"空间分配失败\\n\");         exit(-1);     }     PNODE ptail = phead;//尾指针，开始指向头节点     ptail->next=NULL;     printf(\"请输入要生成的链表节点的个数：len=\");     scanf(\"%d\",&len); //输入len     getchar();    //for '\\n'     for(i=0;i<len;i++)     {         printf(\"请输入第%d个节点的值：\",i+1);         scanf(\"%c\",&val);         getchar();    //for '\\n'         pnew=(PNODE)malloc(sizeof(NODE));         if(pnew==NULL)         {             printf(\"空间分配失败\\n\");             exit(-1);         }         pnew->data=val;         ptail->next=pnew; //将新节点挂到ptail的next域（将新节点的地址传到上一个节点的next域中）         pnew->next=NULL;         ptail=pnew; //尾节点一直指向新元素，因为插入的新节点即为此刻的尾节点      }      return phead; }   PNODE travel_link( PNODE phead) //遍历单链表 {     PNODE p=phead->next; //指向首节点     while(p!=NULL)     {         printf(\"%c\",p->data);         p=p->next;     }     printf(\"\\n\");     return 0; } 供参考～   函数调用有问题～", "referer": "user-0"}]}
{"question": "hitSSE困难：统计字符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <ctype.h> #define BUFFER_SIZE 80 #define COUNT_SIZE 26 int main( ) {     char str[BUFFER_SIZE+1];  //2     int count[COUNT_SIZE]={0}; //2     int i = 0;     gets(str); //2     for(i=0; str[i]!='\\0'; i++)  //1     {         if(islower(str[i])) //2             count[str[i]-'a']++;  //4     }      for(i=0; i<COUNT_SIZE; i++) //1     {         if(count[i]>0) //1         {              printf(\"%c=%d\\n\", i+'a', count[i]); //2         }     } \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <ctype.h>  #define BUFFER_SIZE 80 #define COUNT_SIZE 26  int main(void) {     char str[BUFFER_SIZE+1];  //2     int count[COUNT_SIZE]={0}; //2     int i = 0;     //gets(str); //2     fgets(str, sizeof(str), stdin); //2     //for(i=0; str[i]!='\\0'; i++)  //1     for(i=0; str[i]; i++)  //1     {         //if ((str[i]>='a') && (str[i]<='z')) //2         if (islower(str[i])) //2             count[str[i]-'a']++;  //4     }      for(i=0; i<COUNT_SIZE; i++) //1     {         //if(count[i]>0) //1         if (count[i]) //1         //{             printf(\"%c=%d\\n\", i+'a', count[i]); //2         //}     } } 供参考～", "referer": "user-0"}]}
{"question": "图邻接矩阵删除顶点", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "没有全部代码，说的都是瞎猜", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 肥牛肉^*^ 的回复:如果这样改，v为3，i＜n-1，假设n为4，那这样for就不循环了，那怎样达到删除的效果？ n为4，v为3，v就是最后一个节点，删除最后一个节点，最后一行一列的关系也没必要往前移了，直接舍弃", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-2的回复:代码有问题，像你理解的一样会越界 删除行应该是 for(i=v; i<n-1; i++)//数组删除元素，要把后续的元素往前移  同样的删除列应该是 for(j=v; j<n-1; j++) 如果这样改，v为3，i＜n-1，假设n为4，那这样for就不循环了，那怎样达到删除的效果？", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "代码有问题，像你理解的一样会越界 删除行应该是 for(i=v; i<n-1; i++)//数组删除元素，要把后续的元素往前移  同样的删除列应该是 for(j=v; j<n-1; j++)", "referer": "user-0"}]}
{"question": "大佬求带", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "Grammar of C++ Statements statement:   labeled-statement  expression-statement  compound-statement  selection-statement  iteration-statement  jump-statement  declaration-statement asm-statement try-except-statement try-finally-statement   labeled-statement:   identifier : statement  case constant-expression : statement  default  : statement  expression-statement:   expressionopt ;  compound-statement:   { statement-listopt }  statement-list:   statement  statement-list  statement  selection-statement:   if  (  expression ) statement  if  ( expression  ) statement else statement  switch  ( expression ) statement  iteration-statement:   while  ( expression ) statement  do statement while  ( expression ) ;  for  ( for-init-statement  expressionopt ; expressionopt ) statement  for-init-statement:   expression-statement  declaration-statement  jump-statement:   break  ;  continue  ;  return  expressionopt ;  goto identifier ;  declaration-statement:   declaration  try-except-statement:   __try compound-statement __except ( expression ) compound-statement  try-finally-statement:   __try compound-statement __finally ( expression ) compound-statement", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "语句是以;分号为标准的。变量声明需要是以;号结束，因此可以认为是语句；宏定义不一定，头文件还是以分号作为判断吧", "referer": "user-0"}]}
{"question": "顺序表的基本操作  ；顺序表的实现", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <malloc.h>   #define LIST_INIT_SIZE 100//顺序表存储空间的初始分配量 #define LISTINCREMENT 10//线性表存储空间的分配增量   typedef struct{     int *elem;//存储空间基址     int length;//当前长度     int listsize;//分配存储容量 }SqList;  int InitList_Sq(SqList&L) {     //构造一个空的线性表L     L.elem = (int*)malloc(LIST_INIT_SIZE*sizeof(int));     if (!L.elem)         exit (1);     L.length = 0;     L.listsize = LIST_INIT_SIZE;      return 1; }  int ListInsert_Sq (SqList&L,int i,int e) {     int *newbase;     //在顺序线性表的L中的第i个位置插入新的元素e     if(i<1||i>L.length +1 )         return 0;//i值不合法      if(L.length>=L.listsize ){ //当前储存空间已满，增加分配         newbase=(int*)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(int));         if(!newbase)exit(1);         L.elem  = newbase;         L.listsize += LISTINCREMENT;     }     int *p;     int *q=&(L.elem [i-1]);     for (p=&(L.elem [L.length -1]); p >= q; --p)         *(p+1) = *p;     *q=e;     ++L.length;      return 1; }  int ListDelete_Sq(SqList &L,int i,int &e)//删除第i个位置上的元素,并用e返回 {     if((i<1)||(i>L.length))         return 0;      int *p=&(L.elem[i-1]);     e = *p;     int *q = L.elem+L.length-1;     for (++p;p<=q;++p)         *(p-1)=*p;     --L.length ;     return 1; } int LocateElem_Sq(SqList L,int e,int (*compare)(int,int)) //定位满足compare函数的元素的下标 {     int i=1;     int *p=L.elem;     while(i<=L.length &&!(*compare)(*p++,e)) ++i;     if (i<=L.length) return i;     else return 0; }  int print(SqList L) //遍历打印顺序表中元素 {     for(int i=0;i<L.length ;i++)         printf(\"%d \", L.elem [i]);     printf(\"\\n\");     return 0; }  int main (){      SqList L;//声明一个顺序表     InitList_Sq(L);     //int e[10];     int e;     printf(\"请输入10位数学号:\");      for (int i=0;i<10;i++)     {         //scanf(\"%d\",&e[i]);         scanf(\"%d\",&e); #if 0         L.elem[i] = e;         /*L.elem[i]=i;*/         L.length++; #else         ListInsert_Sq(L, i+1, e); #endif     }     print(L);      ListInsert_Sq (L,L.length+1,8); //在第二个位置插入8     //ListInsert_Sq (L,2,8); //在第二个位置插入8     print(L);      int g;     //ListDelete_Sq(L,2,g); //删除第2个位置上的元素 ，e返回其值     if (ListDelete_Sq(L, L.length,g)) //删除第2个位置上的元素 ，e返回其值         printf(\"%d\\n\", g);     print(L); } 做了部分修改，供参考～", "referer": "user-0"}]}
{"question": "新手请教大家一个问题：用指针方法，在一个一维数组int a[10]的元素中，查找给定的数，若找到则输出该数，若没找到，输出No", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "建议换个程序或者环境，测试运行的时候会报哪里出错，什么错", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "啊，第几次犯这个错误了每次都没找出来，谢谢了，以后会注意的。", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "scanf(\"%d\",b); 加&号  scanf(\"%d\",&b);", "referer": "user-0"}]}
{"question": "数据类型长度与sizeof", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "我自己搞错了。确实是32位的。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "指针就要加倍，你试试", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "c++ 标准规定int 只保证大于等于32位，并没有说一定是64位。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 楼主 无名D小兵的回复:为什么在64位机上，sizeof(int)的值是4而不是8？64位及上int型的长度不是64位吗？ int 长度都是4个字节，64和32位机器一样", "referer": "user-0"}]}
{"question": "利用π4=1−13+15−17+…，编程计算π的近似值，直到最后一项的绝对值小于10−4时为止，输出π的值并统计累加的项数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "谢谢谢谢谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "供参考 #include<stdio.h> int main() {     double a=1,d=1;     int sign=1,count=1;     while(1)     {         a+=2;         sign*=(-1);         d+=1/a*sign;         count++;         if(1/a<0.0001) break;     }     printf(\"pi=%lf\\ncount=%d\\n\",4*d,count);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "a=1001,b=1003退出，但是题目要求最后一项是绝对值小于10-4,所以这个1/a还是要加进结果里面。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "但是计算出来的a最后一项是 997 b最后一项是999 c=1/997-1/999 然后 下一次就是 a+4=1001,b+4=1003  b<0.0001 就退出了呀  后面在弄这些不是多余？", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "for结束后加一句 if(1/a<0.0001) d+=1/a; else d=d+1/a-1/b;", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "最后一项绝对值小于10-4，也就是要计算这一项，函数里面没有计算", "referer": "user-0"}]}
{"question": "求大佬帮我看看这段二叉树Morris后序遍历的代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 weixin_45906870 的回复:改成你的代码后编译没问题，但是运行时编译器会停止工作，但是我不知道问题出在哪  不好意思，因为没调试，有笔误 void postorderTraverse(struct TreeNode *root) {     if (root==NULL) return;     struct TreeNode *p = NULL;     //struct TreeNode *t1 =malloc(sizeof(struct TreeNode)); //没必要用t1     //t1->left = root;     //t1->right = NULL;     //struct TreeNode *t = t1;     struct TreeNode* t = root; //直接t从root开始就可以     while (t){         p = t->left;         //if (t->left){         //if (p->left){         if(p) { //这里笔误了             //p = t->left;             while (p->right!=NULL && p->right!=t){                 p = p->right;             }             if (p->right==NULL){                 p->right = t;                 t = t->left;             }             else{                 //printreverse(t->left, p);                 p->right = NULL; //为了节点逆转的判断，先恢复右节点为NULL                 printreverse(t->left); //再逆向打印                 t = t->right;             }         }         else{             t = t->right;         }     }     //free(t1); }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "给你一个递归和morris遍历的完整代码 其实我觉得morris的后序遍历为了省空间，需要逆向打印（遍历），时间上也多消耗的，以时间换空间，也不见得有多好  struct TreeNode {     int val;     struct TreeNode *left;     struct TreeNode *right; };   struct TreeNode* reverse(struct TreeNode *node) {     struct TreeNode* pre = NULL;     struct TreeNode* next = NULL;     while (node != NULL){         next = node->right;         node->right = pre;         pre = node;         node = next;     }     return pre; }   void printreverse(struct TreeNode *node) {     struct TreeNode* tail =reverse(node);     struct TreeNode* cur = tail;     while (cur != NULL ){         printf(\"%d \", cur->val);         cur =cur->right;     }     reverse(tail); }  void postorderTraverse(struct TreeNode *root) //morris后序 {     if (root==NULL) return;     struct TreeNode *p = NULL;     struct TreeNode* t = root;     while (t){         p = t->left;         if(p) {             while (p->right!=NULL && p->right!=t){                 p = p->right;             }             if (p->right==NULL){                 p->right = t;                 t = t->left;                 continue;             }             else{                 p->right = NULL;                 printreverse(t->left);             }         }         t = t->right;     }     printreverse(root); //最后打印右子树 }  void preorderTraverse(struct TreeNode *root) { //morris前序     if(root == NULL) return;     struct TreeNode* cur = root;     struct TreeNode* right = NULL;     while (cur != NULL){         right = cur->left;         if(right != NULL){             while (right->right != NULL && right->right != cur){                 right = right->right;             }             if(right->right == NULL){                 right->right = cur;                 printf(\"%d \", cur->val);                 cur = cur->left;                 continue;             }else {                 right->right = NULL;             }         }else {             printf(\"%d \", cur->val);         }         cur = cur->right;     } }  void inorderTraverse(struct TreeNode *root) { //morris中序     if(root == NULL) return;     struct TreeNode* cur = root;     struct TreeNode* right = NULL;     while (cur != NULL){         right = cur->left;         if(right != NULL){             while (right->right != NULL && right->right != cur){                 right = right->right;             }             if(right->right == NULL){                 right->right = cur;                 cur = cur->left;                 continue;             }else {                 right->right = NULL;             }         }         printf(\"%d \", cur->val);         cur = cur->right;     } }  void preOrder(struct TreeNode* root) {     if (root==NULL) return;     printf(\"%d \", root->val);     preOrder(root->left);     preOrder(root->right); }  void inOrder(struct TreeNode* root) {     if (root==NULL) return;     inOrder(root->left);     printf(\"%d \", root->val);     inOrder(root->right); }  void postOrder(struct TreeNode* root) {     if (root==NULL) return;     postOrder(root->left);     postOrder(root->right);     printf(\"%d \", root->val); }  void createTree(struct TreeNode** node, int *data, int length, int *index) {     if(data[*index]==-1) {         (*index)++;         return;     }     if(*node==NULL) *node=(struct TreeNode*)malloc(sizeof(struct TreeNode));     (*node)->left = NULL;     (*node)->right = NULL;     (*node)->val = data[(*index)++];     if (*index<length)         createTree(&((*node)->left), data, length, index);     if (*index<length)         createTree(&((*node)->right), data, length, index); }  void destroyTree(struct TreeNode* root) {     if (root==NULL) return;     destroyTree(root->left);     destroyTree(root->right);     free(root); }  int main() {     struct TreeNode *root=NULL;     int data[]={0,1,2,-1,-1,3,-1,-1,4,5,-1,-1,6};     int index=0;     createTree(&root, data, 13, &index);     printf(\"递归前序\\n\");     preOrder(root);     printf(\"\\nmorris前序\\n\");     preorderTraverse(root);     printf(\"\\n递归中序\\n\");     inOrder(root);     printf(\"\\nmorris中序\\n\");     preorderTraverse(root);     printf(\"\\n递归后序\\n\");     postOrder(root);     printf(\"\\nmorris后序\\n\");     postorderTraverse(root);     printf(\"\\n\");     destroyTree(root);     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 1 楼 user-1 的回复：这是morris后序遍历必须的步骤，也就是先遍历到左子树的最右节点，才开始逆向打印。所以逆向打印步骤省不了，优化的地方有限，关键就看逆向打印怎么实现。通常的做法就是先把节点逆转，打印结束后再把节点逆转回来。 如果非要改进，参考以下代码吧  struct TreeNode {     int val;     struct TreeNode *left;     struct TreeNode *right; };  struct TreeNode* reverse(struct TreeNode *node) {     struct TreeNode* pre = NULL;     struct TreeNode* next = NULL;     while (node != NULL){         next = node->right;         node->right = pre;         pre = node;         node = next;     }     return pre; }  void printreverse(struct TreeNode *node) {     struct TreeNode* tail =reverse(node);     struct TreeNode* cur = tail;     while (cur != NULL ){         printf(\"%d\\n\", cur->val);         cur =cur->right;     }     reverse(tail); }  void postorderTraverse(struct TreeNode *root) {     if (root==NULL) return;     struct TreeNode *p = NULL;     //struct TreeNode *t1 =malloc(sizeof(struct TreeNode)); //没必要用t1     //t1->left = root;     //t1->right = NULL;     //struct TreeNode *t = t1;     struct TreeNode* t = root; //直接t从root开始就可以     while (t){         p = t->left;         //if (t->left){         if (p->left){             //p = t->left;             while (p->right!=NULL && p->right!=t){                 p = p->right;             }             if (p->right==NULL){                 p->right = t;                 t = t->left;             }             else{                 //printreverse(t->left, p);                 p->right = NULL; //为了节点逆转的判断，先恢复右节点为NULL                 printreverse(t->left); //再逆向打印                 t = t->right;             }         }         else{             t = t->right;         }     }     //free(t1); }改成你的代码后编译没问题，但是运行时编译器会停止工作，但是我不知道问题出在哪", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "这是morris后序遍历必须的步骤，也就是先遍历到左子树的最右节点，才开始逆向打印。所以逆向打印步骤省不了，优化的地方有限，关键就看逆向打印怎么实现。通常的做法就是先把节点逆转，打印结束后再把节点逆转回来。 如果非要改进，参考以下代码吧  struct TreeNode {     int val;     struct TreeNode *left;     struct TreeNode *right; };  struct TreeNode* reverse(struct TreeNode *node) {     struct TreeNode* pre = NULL;     struct TreeNode* next = NULL;     while (node != NULL){         next = node->right;         node->right = pre;         pre = node;         node = next;     }     return pre; }  void printreverse(struct TreeNode *node) {     struct TreeNode* tail =reverse(node);     struct TreeNode* cur = tail;     while (cur != NULL ){         printf(\"%d\\n\", cur->val);         cur =cur->right;     }     reverse(tail); }  void postorderTraverse(struct TreeNode *root) {     if (root==NULL) return;     struct TreeNode *p = NULL;     //struct TreeNode *t1 =malloc(sizeof(struct TreeNode)); //没必要用t1     //t1->left = root;     //t1->right = NULL;     //struct TreeNode *t = t1;     struct TreeNode* t = root; //直接t从root开始就可以     while (t){         p = t->left;         //if (t->left){         if (p->left){             //p = t->left;             while (p->right!=NULL && p->right!=t){                 p = p->right;             }             if (p->right==NULL){                 p->right = t;                 t = t->left;             }             else{                 //printreverse(t->left, p);                 p->right = NULL; //为了节点逆转的判断，先恢复右节点为NULL                 printreverse(t->left); //再逆向打印                 t = t->right;             }         }         else{             t = t->right;         }     }     //free(t1); }", "referer": "user-0"}]}
{"question": "逻辑运算   有点小问题，", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "scanf(\"%d,%d,%d\",&a,&b,&c); // 给a和b赋值 你的输入格式里面带了逗号，输入也要带逗号  例如输入 3,4,5   m = a > b && a < c;   // 条件运算  如果a=5,b=3,c=6  输出结果应该是m=1  为什么是0 这种格式代码可读性不是很好，虽然高手知道运算符有限顺序，但是项目接手人不一定都是高手 建议m = ((a > b) && (a < c));  这样更明确些", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 明天就会D 的回复:[quote=引用 1 楼 自信男孩 的回复:]输入的格式不对，因为scanf的\"\"中每个输入之间是有,逗号的（注意逗号的中英文要和scanf中的保持一致）。  谢谢，不过，我刚刚又试试了 好像还是不对结果还是 m= 0[/quote] 就是输入带空格的原因啊 你输入5,3,6就可以了", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "int a = 2,b = 4,c = 6,x,y; y = (a+b),(b+c);结果是y=6，但整个逗号表达式的值是10，要想获取这个10，则应该写成 y=（a+b,b+c）;", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "#include<stdio.h> int main() {     int a = 0;int b = 0; int c = 0;  //定义2个变量     int m;  // 定义m变量     scanf(\"%d %d %d\",&a,&b,&c); // 给a和b赋值     m = a > b && a < c;   // 条件运算  如果a=5,b=3,c=6  输出结果应该是m=1  为什么是0     printf(\"m = %d\",m); //  输出 \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 7 楼 5250 的回复:[quote=引用 2 楼 明天就会D 的回复:]#include<stdio.h> int main() {   /* int a = 0,b = 0, c = 0;    int m = 0;    scanf(\"%d,%d,%d\",&a,&b,&c);    m = (a + b),(c * a);    printf(\"m = %d\",m);  */     int a = 2,b = 4,c = 6,x,y;     y = (a+b),(b+c);     printf(\"y = %d,x = %d\\n\",x,y);     return 0; } 运行结果y = 8,x = 6,有点懵，明明按照逗号表达式计算第二表达式为最终结果，a+b=6,b+c=10,为什么运行结果差这么远，，， 希望有路过的朋友，懂的话，帮忙解答一下，谢谢！ 我一个人自学看书，有些点还是理解不了，  逗号表达式需要加括号  即x=(p1,p2,p3) 你的程序改一下  y = （(a+b),(b+c));[/quote] 收到，我理解了，感谢！", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 2 楼 明天就会D 的回复:]#include<stdio.h> int main() {   /* int a = 0,b = 0, c = 0;    int m = 0;    scanf(\"%d,%d,%d\",&a,&b,&c);    m = (a + b),(c * a);    printf(\"m = %d\",m);  */     int a = 2,b = 4,c = 6,x,y;     y = (a+b),(b+c);     printf(\"y = %d,x = %d\\n\",x,yprintf(\"y = %d,x = %d\\n\",x,y);    return 0; } 运行结果y = 8,x = 6,有点懵，明明按照逗号表达式计算第二表达式为最终结果，a+b=6,b+c=10,为什么运行结果差这么远，，， 希望有路过的朋友，懂的话，帮忙解答一下，谢谢！ 我一个人自学看书，有些点还是理解不了，  这样的能对上号吗？能不蒙吗？  printf(\"y = %d,x = %d\\n\",x,y);  y=x的值，x = y的值[/quote]   我粗心大意了，自身本领不过关，结果导致运算结果不一样，感谢您的发现！", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 4 楼 深渊亦是鹏程万里 的回复:y = (a+b),(b+c);这一句逗号运算符左边为一个表达式，右边为一个表达式，y=(a+b)和（b+c）,所以y=6，如果是y = ((a+b),(b+c)); y=10,x由于是临时变量且没有赋初值，x在栈空间中，它的值是内存中的一个垃圾值    谢谢朋友，理解了", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "引用 2 楼 明天就会D 的回复:#include<stdio.h> int main() {   /* int a = 0,b = 0, c = 0;    int m = 0;    scanf(\"%d,%d,%d\",&a,&b,&c);    m = (a + b),(c * a);    printf(\"m = %d\",m);  */     int a = 2,b = 4,c = 6,x,y;     y = (a+b),(b+c);     printf(\"y = %d,x = %d\\n\",x,y);     return 0; } 运行结果y = 8,x = 6,有点懵，明明按照逗号表达式计算第二表达式为最终结果，a+b=6,b+c=10,为什么运行结果差这么远，，， 希望有路过的朋友，懂的话，帮忙解答一下，谢谢！ 我一个人自学看书，有些点还是理解不了，  逗号表达式需要加括号  即x=(p1,p2,p3) 你的程序改一下  y = （(a+b),(b+c));", "referer": "user-0"}, {"cid": "9", "user": "user-5", "content": "引用 2 楼 明天就会D 的回复:#include<stdio.h> int main() {   /* int a = 0,b = 0, c = 0;    int m = 0;    scanf(\"%d,%d,%d\",&a,&b,&c);    m = (a + b),(c * a);    printf(\"m = %d\",m);  */     int a = 2,b = 4,c = 6,x,y;     y = (a+b),(b+c);     printf(\"y = %d,x = %d\\n\",x,yprintf(\"y = %d,x = %d\\n\",x,y);    return 0; } 运行结果y = 8,x = 6,有点懵，明明按照逗号表达式计算第二表达式为最终结果，a+b=6,b+c=10,为什么运行结果差这么远，，， 希望有路过的朋友，懂的话，帮忙解答一下，谢谢！ 我一个人自学看书，有些点还是理解不了，  这样的能对上号吗？能不蒙吗？  printf(\"y = %d,x = %d\\n\",x,y);  y=x的值，x = y的值", "referer": "user-0"}, {"cid": "10", "user": "user-6", "content": "楼主为啥不加上括号呢？？", "referer": "user-0"}, {"cid": "11", "user": "user-6", "content": "y = (a+b),(b+c);这一句逗号运算符左边为一个表达式，右边为一个表达式，y=(a+b)和（b+c）,所以y=6，如果是y = ((a+b),(b+c)); y=10,x由于是临时变量且没有赋初值，x在栈空间中，它的值是内存中的一个垃圾值", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:输入的格式不对，因为scanf的\"\"中每个输入之间是有,逗号的（注意逗号的中英文要和scanf中的保持一致）。  谢谢，不过，我刚刚又试试了 好像还是不对结果还是 m= 0", "referer": "user-0"}, {"cid": "13", "user": "user-0", "content": "#include<stdio.h> int main() {   /* int a = 0,b = 0, c = 0;    int m = 0;    scanf(\"%d,%d,%d\",&a,&b,&c);    m = (a + b),(c * a);    printf(\"m = %d\",m);  */     int a = 2,b = 4,c = 6,x,y;     y = (a+b),(b+c);     printf(\"y = %d,x = %d\\n\",x,y);     return 0; } 运行结果y = 8,x = 6,有点懵，明明按照逗号表达式计算第二表达式为最终结果，a+b=6,b+c=10,为什么运行结果差这么远，，， 希望有路过的朋友，懂的话，帮忙解答一下，谢谢！ 我一个人自学看书，有些点还是理解不了，", "referer": "user-0"}, {"cid": "14", "user": "user-5", "content": "输入的格式不对，因为scanf的\"\"中每个输入之间是有,逗号的（注意逗号的中英文要和scanf中的保持一致）。", "referer": "user-0"}]}
{"question": "自定义函数实现四舍五入", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩的回复:楼主想一下a - (int)a >5怎么大于5呢？这个判断就是一个一直假呢 不是应该大于0.5吗？ main函数里的scanf应该是%f，不是f 确实如此，谢谢你", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "楼主想一下a - (int)a >5怎么大于5呢？这个判断就是一个一直假呢 不是应该大于0.5吗？ main函数里的scanf应该是%f，不是f", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "恩， 你用的是vs2010吗？  可能要把abs换成fabs", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "浮点数不是精确的数字吧， 用==或!=是有可能得不到想要的结果。 试试abs(a) < 0.0001这样", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 user-2 的回复:恩， 你用的是vs2010吗？  可能要把abs换成fabs 谢谢你的回复，是vs2010 我看书上说用集成编程工具学不好c语言，是这么回事么？", "referer": "user-0"}]}
{"question": "链表储存的一元多项式计算器，进行乘法时，有时会超时，有时能运行出结果，原因可能是啥？救救孩子吧  求助！！！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<malloc.h>    typedef struct polynode {     int coef;     int exp;     struct polynode *next; }polynode, *polylist;  polylist poly_create(void) {     polynode *rear, *head, *s;      int c, e;      rear = head = (polynode *)malloc(sizeof(polynode));     scanf(\"%d%d\", &c, &e);      while (c) {         s = (polynode*)malloc(sizeof(polynode));         s->coef = c;         s->exp = e;         rear->next = s;         rear = s;         scanf(\"%d%d\", &c, &e);     }     rear->next=NULL;      return(head); }    static void insert_node(polylist phead, polylist new_node) {     polylist pcur, pprev;      pprev = phead;     pcur = phead->next;      while (pcur && pcur->exp != new_node->exp) {         pprev = pcur;         pcur = pcur->next;     }     if (!pcur) {         pprev->next = new_node;         return;     }      pcur->coef += new_node->coef;     free(new_node);     if (pcur->coef == 0) {         pprev->next = pcur->next;         free(pcur);     } }  polylist multyploy(polylist pa, polylist pb) {     polylist pa_node, pb_node, pc_node, pc;     int coef, exp;       pc = (polynode*)malloc(sizeof(polynode));     if (!pc)         return NULL;      pa_node = pa->next;     pb_node = pb->next;      if (!pa_node || !pb_node) {         pc = pa_node ? pa : pb;     }     while (pa_node) {         while (pb_node) {             coef = pa_node->coef * pb_node->coef;             exp = pa_node->exp + pb_node->exp;              pc_node = (polylist)malloc(sizeof(polynode));             if (!pc_node)                 exit(0);             pc_node->coef = coef;             pc_node->exp = exp;             pc_node->next = NULL;              insert_node(pc, pc_node);             pb_node = pb_node->next;         }         pa_node = pa_node->next;         pb_node = pb->next;     }      return pc; }  void free_polylist(polylist phead) {     polylist pdel, pcur;      pcur = phead;      while (pcur) {         pdel = pcur;         pcur = pcur->next;         free(pdel);     } }  static void show_polylist(polylist phead) {     if (!phead)         return;      polylist pcur = phead->next;      while(pcur) {         printf(\"%d\", pcur->coef);         printf(\"*x^%d\", pcur->exp);         if (pcur->next)             printf(\" + \");         pcur = pcur->next;     }     printf(\"\\n\"); }  int main(void) {     polylist pa, pb, pc;      pa = poly_create();     //show_polylist(pa);     pb = poly_create();     //show_polylist(pb);     pc = multyploy(pa, pb);      show_polylist(pc);      free_polylist(pa);     pa = NULL;     free_polylist(pb);     pb = NULL;     free_polylist(pc);     pc = NULL;      return 0; }  供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "谢谢 才看到", "referer": "user-1"}]}
{"question": "C语言，建立了文件，向文件中输入了数据，但不知道为什么输出时显示不出来？？可以帮忙看看代码哪里有问题吗？？谢谢大神们！！", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 6 楼 自信男孩的回复:[quote=引用 5 楼 up___lqw 的回复:][quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 up___lqw 的回复:][quote=引用 1 楼 自信男孩的回复:]#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码； 我知道啦，fscanf是读取并没有输出，但是我看您后来改的后三个多加了＆是为什么呢？？而第一个name没有加，这点想不太明白，请您指教！（因为我想fprintf的时候都没加）[/quote] fscanf和scanf是一样的，只是fscanf指定了读取内容的文件。scanf如果加,fscanf也是要加&的～[/quote] 知道啦，谢谢！还能再问一个别的问题吗？就是刚开始在创立文件前我先创建了一个空的链表头，链表头和头指针这个为什么可以直接在文件里使用啊？？不需要在打开文件后创建吗？？今天突然发现这个不明白了。万分感谢！！[/quote] 个人认为，链表创建一般是在读文件的时候创建的，而楼主是相当于在写文件的时候创建了（但是没有使用链表），正好这些创建的节点在下面的读文件操作里使用了，也是可以的。[/quote] 可不可以帮我看一下代码呢？感觉传入的函数参数没有用呢，就是调用函数时，在这个函数中沿头结点找对应的节点位置，不知道为什么找不到😢，看了好几遍都不知道问题出在哪里。编译是没有问题的，就是运行出了bug。如果可以的话，我把代码私发给您！！真的太太太感谢啦！！大作业真的蛮重要的！", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 6 楼 自信男孩的回复:[quote=引用 5 楼 up___lqw 的回复:][quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 up___lqw 的回复:][quote=引用 1 楼 自信男孩的回复:]#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码； 我知道啦，fscanf是读取并没有输出，但是我看您后来改的后三个多加了＆是为什么呢？？而第一个name没有加，这点想不太明白，请您指教！（因为我想fprintf的时候都没加）[/quote] fscanf和scanf是一样的，只是fscanf指定了读取内容的文件。scanf如果加,fscanf也是要加&的～[/quote] 知道啦，谢谢！还能再问一个别的问题吗？就是刚开始在创立文件前我先创建了一个空的链表头，链表头和头指针这个为什么可以直接在文件里使用啊？？不需要在打开文件后创建吗？？今天突然发现这个不明白了。万分感谢！！[/quote] 个人认为，链表创建一般是在读文件的时候创建的，而楼主是相当于在写文件的时候创建了（但是没有使用链表），正好这些创建的节点在下面的读文件操作里使用了，也是可以的。[/quote] 好的，太感谢你啦！！抱歉这么久才回复~  其实这个程序是我们要写的大作业的一部分，然后现在我的代码刚刚全部写好，也通过编译了，但是有个地方出了一个bug,已注册的用户找不到信息，我也不知道哪里出了问题。代码行数也有点多，不太方便放到这个上面。如果您有时间，不嫌我麻烦的话，可以把代码私发给您，然后帮我看看吗？？如果可以的话真是太感谢了！！（实在找不到人帮忙看看哪里有问题了）", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "引用 5 楼 up___lqw 的回复:[quote=引用 4 楼 自信男孩的回复:][quote=引用 3 楼 up___lqw 的回复:][quote=引用 1 楼 自信男孩的回复:]#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码； 我知道啦，fscanf是读取并没有输出，但是我看您后来改的后三个多加了＆是为什么呢？？而第一个name没有加，这点想不太明白，请您指教！（因为我想fprintf的时候都没加）[/quote] fscanf和scanf是一样的，只是fscanf指定了读取内容的文件。scanf如果加,fscanf也是要加&的～[/quote] 知道啦，谢谢！还能再问一个别的问题吗？就是刚开始在创立文件前我先创建了一个空的链表头，链表头和头指针这个为什么可以直接在文件里使用啊？？不需要在打开文件后创建吗？？今天突然发现这个不明白了。万分感谢！！[/quote] 个人认为，链表创建一般是在读文件的时候创建的，而楼主是相当于在写文件的时候创建了（但是没有使用链表），正好这些创建的节点在下面的读文件操作里使用了，也是可以的。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 4 楼 自信男孩的回复:[quote=引用 3 楼 up___lqw 的回复:][quote=引用 1 楼 自信男孩的回复:]#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码； 我知道啦，fscanf是读取并没有输出，但是我看您后来改的后三个多加了＆是为什么呢？？而第一个name没有加，这点想不太明白，请您指教！（因为我想fprintf的时候都没加）[/quote] fscanf和scanf是一样的，只是fscanf指定了读取内容的文件。scanf如果加,fscanf也是要加&的～[/quote] 知道啦，谢谢！还能再问一个别的问题吗？就是刚开始在创立文件前我先创建了一个空的链表头，链表头和头指针这个为什么可以直接在文件里使用啊？？不需要在打开文件后创建吗？？今天突然发现这个不明白了。万分感谢！！", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 3 楼 up___lqw 的回复:[quote=引用 1 楼 自信男孩的回复:]#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码； 我知道啦，fscanf是读取并没有输出，但是我看您后来改的后三个多加了＆是为什么呢？？而第一个name没有加，这点想不太明白，请您指教！（因为我想fprintf的时候都没加）[/quote] fscanf和scanf是一样的，只是fscanf指定了读取内容的文件。scanf如果加,fscanf也是要加&的～", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码； 我知道啦，fscanf是读取并没有输出，但是我看您后来改的后三个多加了＆是为什么呢？？而第一个name没有加，这点想不太明白，请您指教！（因为我想fprintf的时候都没加）", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码； fscanf函数不是用来输出的吗？？我看您写的后面输出列表上后三个加上了＆，这是为什么呢？（小白不懂就问），还有我现在在这个后面（关闭文件后）写printf语句，然后也没有输出，怎么回事不知道", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "#include <stdio.h> #include <string.h> #include <stdlib.h>   struct acc_message                 //定义结点的结构 {  char name[12];     int  cardnum;     int  password;     double acc_balance;     struct acc_message *next; };  int main() {     struct acc_message *head;            //创建空链表     head =(struct acc_message *)malloc(sizeof (struct acc_message));     head-> next = NULL ;     struct acc_message *p, *q ;     q = head ;       FILE *fp;                                //建立原有银行客户信息文件     if ((fp = fopen(\"message.txt\",\"wt+\"))==NULL){         //printf(\"Open this file error,press any key exit!/n \");         printf(\"Open this file error,press any key exit!\\n \");         getchar();         exit(0);     }     int i=0;     while(i<5){         p =(struct acc_message*)malloc(sizeof (struct acc_message));    //创建新节点         if (p==NULL)  break;         switch (i)         {             case 0:             //fprintf (fp,\"Jane 62221111 123456 8000/n\",p->name,p->cardnum,p->password,p->acc_balance);             fprintf (fp,\"Jane 62221111 123456 8000\\n\");//, p->name,p->cardnum,p->password,p->acc_balance);             break;             case 1:             fprintf (fp,\"Alan 62221112 123456 500\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 2:             fprintf (fp,\"Mary 62221113 123456 600000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 3:             fprintf (fp,\"Alice 62221114 123456 0\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;             case 4:             fprintf (fp,\"Kivin 62221115 123456 70000\\n\");//,p->name,p->cardnum,p->password,p->acc_balance);             break;         }         q -> next=p;         q=p;         i++;     }     q->next = NULL;     rewind (fp);      struct acc_message *r = head->next;     while (r!=NULL){         //fscanf(fp,\"%s %d %d %d/n\",r->name,r->cardnum,r->password,r->acc_balance);         fscanf(fp,\"%s %d %d %lf\\n\",r->name, &r->cardnum, &r->password, &r->acc_balance);         r=r->next;     }      r = head->next;     while (r) {         fprintf(stdout,\"%s %d %d %lf\\n\", r->name, r->cardnum, r->password, r->acc_balance);         r = r->next;     }     fclose(fp);  }  供参考～  没有任何输出，那么是因为楼主没有输出。  代码的其他问题，详见上面的代码；", "referer": "user-0"}]}
{"question": "epoll水平触发读取数据的问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "顶", "referer": "user-0"}]}
{"question": "利用栈实现任意进制转换的一道题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "既然有ABCDEF，因此不能直接用整形，N可以采用 字符串，大致代码如下  #include<iostream> #include<string> #include <stack> #include<ctype.h> using namespace std; char strmask[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' }; int main() {     int P, Q;     string N;     cin >> P >> Q >> N;     int tmp=0;     size_t slen = N.length();     for(int i=0;i<N.length();i++)     {         char c = N[i];         if (isdigit(c)) {             tmp += (c-'0')*pow(P,slen-i-1);         }         else {             c = toupper(c);             tmp += ((c - 'A') + 10)*pow(P,slen-i-1);         }     }        stack<char> stresult;     while (tmp) {         int n = tmp % Q;         stresult.push(strmask[n]);         tmp = tmp / Q;     }     while (!stresult.empty()) {         cout << stresult.top();         stresult.pop();     }     cout << endl;     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 7 楼 真相重于对错 的回复:你的栈存放是int啊，所以输出要处理一下  嗷嗷我懂了！谢谢前辈！", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "你的栈存放是int啊，所以输出要处理一下", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 5 楼 真相重于对错 的回复:你肯定不对，原题是： 给出一个 P 进制整数 N，求 N 的 Q 进制表示。 其中 0<= N <= 32767 , 2 <= P <= 16, 2 <= Q <= 16。 大于 9 的数字用 A、B、C、D、E、F 表示。 输入 P Q N（用 P 进制表示的） 因为P可能是大于10的进制，那么N就不能直接用int表示，而需要字符串，比如一个十三进制的A5。转换为8进制，你怎么接受N呢？  嗷嗷 前辈我把你的用stl的栈手写了下（因为我C++这块还不太熟悉 才刚学一直用C手写）但是我没还是查出来哪里错 #include<iostream> #include<math.h> #include<string.h> using namespace std;  typedef struct SNode{ \tint data; \tstruct SNode *next; }SNode,*Stack; int InitStack(Stack &s){ \ts=NULL; \treturn 0; } int Empty(Stack s){ \treturn (s==NULL); } int Top(Stack s){ \treturn(s->data); } int Push(Stack &s,int x){ \tStack p; \tp=new SNode; \tp->data=x; \t \tp->next=s; \ts=p; \treturn 0; } int Pop(Stack &s,int &x){ \tif(Empty(s)) return -1; \tStack p=s; \ts=s->next; \tx=p->data; \tdelete p; \treturn x; } int main(){ \tchar strmask[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' }; \tStack s; \tInitStack(s); \tint P,Q; \tchar N[32768]; \tint temp; \tscanf(\"%d %d\",&P,&Q); \tscanf(\"%s\",&N); \tint slen=strlen(N); \tfor(int i=0;N[i]!='\\0';i++){ \t\tchar c=N[i]; \t\tif (isdigit(c)) {//判断是否是数字              temp += (c-'0')*pow(P,slen-i-1); //是数字          }         else {             c = toupper(c); //不是数字，转化为大写英文字母              temp += ((c - 'A') + 10)*pow(P,slen-i-1);         } \t} \t \twhile(temp){ \t\tint n = temp % Q;         Push(s,strmask[n]);         temp = temp / Q; \t} \twhile(!Empty(s)){ \t\tint x=0; \t\tx=Pop(s,x); \t\tprintf(\"%d\",x); \t} \treturn 0; }", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "你肯定不对，原题是： 给出一个 P 进制整数 N，求 N 的 Q 进制表示。 其中 0<= N <= 32767 , 2 <= P <= 16, 2 <= Q <= 16。 大于 9 的数字用 A、B、C、D、E、F 表示。 输入 P Q N（用 P 进制表示的） 因为P可能是大于10的进制，那么N就不能直接用int表示，而需要字符串，比如一个十三进制的A5。转换为8进制，你怎么接受N呢？", "referer": "user-0"}, {"cid": "6", "user": "user-1", "content": "13 8 4A5", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 2 楼 自信男孩 的回复:#include<iostream> #include<math.h>  using namespace std;  typedef struct SNode{     int data;     struct SNode *next; } SNode,*Stack; int InitStack(Stack &s){     s=NULL;     return 0; } int Empty(Stack s){     return (s==NULL); } int Top(Stack s){     return(s->data); } int Push(Stack &s,int x) {     Stack p;     p=new SNode;     p->data=x;      p->next=s;     s = p;      return 0; } int Pop(Stack &s,int &x) {     if(Empty(s)) return -1;     Stack p=s;     s=s->next;     x=p->data;     delete p;     return 1; }  int main() {     Stack s;     InitStack(s);     int N,P,Q;     int m=0,n=0;     scanf(\"%d %d %d\",&P,&Q,&N);     if(P>Q){         while(N>0){             m=N%Q;             Push(s,m);             N=N/Q;         }         while(!Empty(s)){             Pop(s,n);             //printf(\"n = %d\\n\", n);             if (n >= 10) {                 printf(\"%c\", n - 10 + 'A');             } else {                 printf(\"%d\", n);             }         }     }      else if(P<Q){         int i=0,sum=0;         while(N>0){             m=N%10;             sum+=m*(pow(P,i));             i++;             N = N/10;         }          while(sum>0){             m=sum%Q;             Push(s, m);             sum = sum/Q;         }         while(!Empty(s)){             Pop(s,n);             //printf(\"n = %d\\n\", n);             if (n >= 10) {                 printf(\"%c\", n - 10 + 'A');             } else {                 printf(\"%d\", n);             }         }         printf(\"\\n\");     }      else if(P==Q){         printf(\"%d\",N);     }      return 0; } 供参考～    if (n >= 10) {                 printf(\"%c\", n - 10 + 'A');             } else {                 printf(\"%d\", n);             } 判断一下pop的n是否大于10，然后根据输出的值做分支输出～ 前辈我试了下有几个example不能AC啊..是哪里的问题呢 这个是OJ的错误反馈  ========[test9.out]========= Expected\t\t\t\t\t\t      |\tYours 111111111111110\t\t\t\t\t\t      /\t111  ============================== ========[test8.out]========= Expected\t\t\t\t\t\t      |\tYours 32767\t\t\t\t\t\t\t      /\t7  ============================== ========[test4.out]========= Expected\t\t\t\t\t\t      |\tYours 11111\t\t\t\t\t\t\t      /\t100101  ============================== ========[test5.out]========= Expected\t\t\t\t\t\t      |\tYours ABC\t\t\t\t\t\t\t      /\t32767  ============================== ========[test6.out]========= Expected\t\t\t\t\t\t      |\tYours 0\t\t\t\t\t\t\t      |", "referer": "user-0"}, {"cid": "8", "user": "user-2", "content": "#include<iostream> #include<math.h>  using namespace std;  typedef struct SNode{     int data;     struct SNode *next; } SNode,*Stack; int InitStack(Stack &s){     s=NULL;     return 0; } int Empty(Stack s){     return (s==NULL); } int Top(Stack s){     return(s->data); } int Push(Stack &s,int x) {     Stack p;     p=new SNode;     p->data=x;      p->next=s;     s = p;      return 0; } int Pop(Stack &s,int &x) {     if(Empty(s)) return -1;     Stack p=s;     s=s->next;     x=p->data;     delete p;     return 1; }  int main() {     Stack s;     InitStack(s);     int N,P,Q;     int m=0,n=0;     scanf(\"%d %d %d\",&P,&Q,&N);     if(P>Q){         while(N>0){             m=N%Q;             Push(s,m);             N=N/Q;         }         while(!Empty(s)){             Pop(s,n);             //printf(\"n = %d\\n\", n);             if (n >= 10) {                 printf(\"%c\", n - 10 + 'A');             } else {                 printf(\"%d\", n);             }         }     }      else if(P<Q){         int i=0,sum=0;         while(N>0){             m=N%10;             sum+=m*(pow(P,i));             i++;             N = N/10;         }          while(sum>0){             m=sum%Q;             Push(s, m);             sum = sum/Q;         }         while(!Empty(s)){             Pop(s,n);             //printf(\"n = %d\\n\", n);             if (n >= 10) {                 printf(\"%c\", n - 10 + 'A');             } else {                 printf(\"%d\", n);             }         }         printf(\"\\n\");     }      else if(P==Q){         printf(\"%d\",N);     }      return 0; } 供参考～    if (n >= 10) {                 printf(\"%c\", n - 10 + 'A');             } else {                 printf(\"%d\", n);             } 判断一下pop的n是否大于10，然后根据输出的值做分支输出～", "referer": "user-0"}]}
{"question": "c语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,\"%d%n\",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf(\"%d,%d\\n\",a,b);     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "闲来无事，写一个玩玩。 #include <stdio.h> #include <stdlib.h>  int main (void) {     # define N 5     unsigned gusum = 0, inpud [1];      for (unsigned m = 0; m < N; m ++)         scanf (\"%d\", inpud), gusum += * inpud % 10;      printf (\"%u\\n\", gusum); }", "referer": "user-0"}]}
{"question": "我没弄懂其原理，求大佬讲解", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "回调函数，根据栈的原理：先进后出。  回调函数是申请函数栈。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "关于递归 需要搞清楚最核心的一点是 函数结束会返回到函数调用的地方这句话  你在reverse里面调用reverse 在内层的reverse调用完成 返回是返回到reverse里面而不是main里面 这里 main调用reverse 进入reverse 第一件事给c分配地址 假设 1000 然后调用getchar 给地址1000赋值 假设是a 这时候调用了reverse 进入reverse 第一件事给c分配地址 假设 1004 然后调用getchar 给地址1004赋值 假设是b 这时候调用了reverse 进入reverse 第一件事给c分配地址 假设 1008 然后调用getchar 给地址1008赋值 假设是\\n 然后判断地址1008的值是\\n 所以不执行输出  函数结束 释放占用内存 1008 开始返回 返回这时候调用了reverse 后面的代码是 判断1004的值是不是\\n 结果不是\\n输出1004地址的内容 也就是b 函数结束 释放占用内存 1004 开始返回 返回这时候调用了reverse 后面的代码是 判断1000的值是不是\\n 结果不是\\n输出1000地址的内容 也就是a 函数结束 释放占用内存 1000 开始返回 返回这里 main调用reverse ......", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "reverse是个递归函数， 递归函数分析首先找退出条件， void reverse() { char c; if((c=getchar())!='\\n')  ==》这边是退出的条件   reverse();   ==》这边自己掉了自己   if(c!='\\n')      putchar(c);       } 程序是一步步向下执行的，那看一下你这个程序执行顺序： 1.执行main里面的reverse函数，然后从键盘获得一个字符’a'，这个时候字符没有putchar，然后又进入到reverse函数，输入‘b'，这个时候又没有putchar，继续进入reverse函数，这个时候输入’\\n‘ 2.判断是'\\n'，退出，回到你输入’b'的然后调用reverse，程序继续执行，这个时候putchar，再回到你输入a的时候。。。 就是倒着输出的了", "referer": "user-0"}]}
{"question": "如何评价这些代码？（来自一位初学加自学者，就是我了h'h'h）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "具体内容没可看，看了下数量及运用了比较多的循环、条件等结构之类。 初学者的话，如果代码能跑起来，且运行效果观感上没有什么毛病的话。可以给个70~80。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h>  #define H_WAGE1 8.75 #define H_WAGE2 9.33 #define H_WAGE3 10.00 #define H_WAGE4 11.20 #define TIME1 30 #define TIME2 40 #define RATE_T 1.5 #define RATE1 0.15 #define RATE2 0.2 #define RATE3 0.25 #define BREAK1 300 #define BREAK2 450  int main(void) {     float time,total,tax,net,H_WAGE;     int choice;      printf(\"*****************************************************************\\n\");     printf(\"Enter the number corresponding to the desired pay rate or action:\\n\") ;     printf(\"(1)$8.75/hr                          (2)$9.33/hr\\n\");     printf(\"(3)$10.00/hr                         (4)$11.20/hr\\n\");     printf(\"(5)quit\\n\");     printf(\"*****************************************************************\\n\");      while (1) {         printf(\"Enter the choice:\\n\");         scanf(\"%d\",&choice);         //if(choice==1||choice==2||choice==3||choice==4||choice==5)         //{         switch(choice)         {             case 1:                 H_WAGE=H_WAGE1;                 printf(\"Your choice is 1,$8.75/hr.\\n\");                 break;             case 2:                 H_WAGE=H_WAGE2;                 printf(\"Your choice is 2,$9.33/hr.\\n\");                 break;             case 3:                 H_WAGE=H_WAGE3;                 printf(\"Your choice is 3,$10.00/hr.\\n\");                 break;             case 4:                 printf(\"Your choice is 4,$11.20/hr.\\n\");                 H_WAGE=H_WAGE4;                 break;             case 5:                 printf(\"Your choice is 5,to quit.\\n\");                 H_WAGE=0;                 break;              default:                 printf(\"Enter the right number.\\n\");                 break;         }         if (choice <= 5 && choice >= 1)             break;     }     //else     //   printf(\"Enter the right number.\\n\");     while(H_WAGE!=0)     {         printf(\"Please enter the working time per week:\\n\");          while(scanf(\"%f\",&time)==1)         {              if(time>=0)             {                 if(time<=TIME1)                 {                     total=time*H_WAGE;                     tax=total*RATE1;                 }                 else if(time<TIME2)                 {                     total=time*H_WAGE;                     tax=TIME1*H_WAGE*RATE1+(time-TIME1)*H_WAGE*RATE2;                 }                 else                 {                     time=TIME2+(time-TIME2)*RATE_T;                     total=time*H_WAGE;                     if(total<BREAK2)                         tax=TIME1*H_WAGE*RATE1+(time-TIME1)*H_WAGE*RATE2;                     else                         tax=TIME1*H_WAGE*RATE1+(BREAK2-BREAK1)*RATE2+(total-BREAK2)*RATE3;                 }                 net=total-tax;                 printf(\"Time is %.2f hours,total income is %.2f,tax is %.2f,net income is %.2f\\n\"                         ,time,total,tax,net);              }             else                 printf(\"Time cannot be negtive.\\n\") ;             printf(\"Enter time again or q to quit.\\n\");             H_WAGE=0;         }     }     printf(\"Done!\\n\");      return 0; } 上面的回复有误，用这个吧～", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include<stdio.h>  #define H_WAGE1 8.75 #define H_WAGE2 9.33 #define H_WAGE3 10.00 #define H_WAGE4 11.20 #define TIME1 30 #define TIME2 40 #define RATE_T 1.5 #define RATE1 0.15 #define RATE2 0.2 #define RATE3 0.25 #define BREAK1 300 #define BREAK2 450  int main(void) {     float time,total,tax,net,H_WAGE;     int choice;      printf(\"*****************************************************************\\n\");     printf(\"Enter the number corresponding to the desired pay rate or action:\\n\") ;     printf(\"(1)$8.75/hr                          (2)$9.33/hr\\n\");     printf(\"(3)$10.00/hr                         (4)$11.20/hr\\n\");     printf(\"(5)quit\\n\");     printf(\"*****************************************************************\\n\");      while (1) {         printf(\"Enter the choice:\\n\");         scanf(\"%d\",&choice);         //if(choice==1||choice==2||choice==3||choice==4||choice==5)         //{         switch(choice)         {             case 1:                 H_WAGE=H_WAGE1;                 printf(\"Your choice is 1,$8.75/hr.\\n\");                 break;             case 2:                 H_WAGE=H_WAGE2;                 printf(\"Your choice is 2,$9.33/hr.\\n\");                 break;             case 3:                 H_WAGE=H_WAGE3;                 printf(\"Your choice is 3,$10.00/hr.\\n\");                 break;             case 4:                 printf(\"Your choice is 4,$11.20/hr.\\n\");                 H_WAGE=H_WAGE4;                 break;             case 5:                 printf(\"Your choice is 5,to quit.\\n\");                 H_WAGE=0;                 break;              default:                 printf(\"Enter the right number.\\n\");                 break;         }         if (choice <= 5 && choice >= 1)             break;     }     //else     //   printf(\"Enter the right number.\\n\");     //while(H_WAGE!=0)    //H_WAGE初始化了吗？没初始化不能用     while(1)    //H_WAGE初始化了吗？没初始化不能用     {         printf(\"Please enter the working time per week:\\n\");          while(scanf(\"%f\",&time)==1)         {              if(time>=0)             {                 if(time<=TIME1)                 {                     total=time*H_WAGE;                     tax=total*RATE1;                 }                 else if(time<TIME2)                 {                     total=time*H_WAGE;                     tax=TIME1*H_WAGE*RATE1+(time-TIME1)*H_WAGE*RATE2;                 }                 else                 {                     time=TIME2+(time-TIME2)*RATE_T;                     total=time*H_WAGE;                     if(total<BREAK2)                         tax=TIME1*H_WAGE*RATE1+(time-TIME1)*H_WAGE*RATE2;                     else                         tax=TIME1*H_WAGE*RATE1+(BREAK2-BREAK1)*RATE2+(total-BREAK2)*RATE3;                 }                 net=total-tax;                 printf(\"Time is %.2f hours,total income is %.2f,tax is %.2f,net income is %.2f\\n\"                         ,time,total,tax,net);              }             else                 printf(\"Time cannot be negtive.\\n\") ;             printf(\"Enter time again or q to quit.\\n\");             H_WAGE=0;         }         if (H_WAGE == 0)             break;     }     printf(\"Done!\\n\");      return 0; } 供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "初学者要学的第一件事是 代码缩进写好 处理好这件事之前 不用讨论怎么评价代码 不入流", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "第一个if...else语句完全是多余的，switch语句就行了。", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 user-4 的回复:第一个if...else语句完全是多余的，switch语句就行了。多谢指教，我再修改一下", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "多谢指教 ，以后多注意", "referer": "user-0"}]}
{"question": "c语言的问题  详细问题请点开看一下", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "嗯嗯 性质 1：是偶数； 性质 2：大于 4 且不大于 12。 小A 喜欢这两个性质同时成立的数字；Uim 喜欢这至少符合其中一种性质的数字；八尾勇喜欢刚好有符合其中一个性质的数字；正妹喜欢不符合这两个性质的数字。 就是这个问题 谢谢啊", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "把你的具体需求说一下，可以直接给你写一个可以实现的代码（用if else）  单从你的if ... else说明上来看是可以的，需要加大括号。大括号里的if else是一个整体，对于大括号外面的来讲", "referer": "user-0"}]}
{"question": "gcc如何仅链接用到的函数，使程序体积尽量减小？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 6 楼 六道佩恩 的回复:话说你这些是在哪里看到的？ 呵呵，以前做个相似的", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "gcc -Os -fdata-sections -ffunction-sections test.c -o test.exe -Wl,-gc-sections -Wl,-strip-all or gcc -Os -fdata-sections -ffunction-sections -Wl,-gc-sections -Wl,-strip-all test.c -o test.exe", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "GCC链接操作以section作为最小的处理单元，一个section中可以包含很多个function，而一个section中只要有一个function被引用，该section就会被加入链接，最终生成可执行文件。  换句话说就是，在缺省情况下，某个.c程序中的所有function，实际上都会编译成同一个section。那么，只要你的代码中用到这个.c生成的.o的其中任何一个function，系统就会将这整个section进行链接。这就导致，我们在引用外部静态库时，不管你是引用其中一个函数，还是引用全部的函数，你最终编译链接出来的可执行文件都一样大，系统并不会自动根据你所引用的函数个数的多少而动态的调整链接方式。  如果静态库是你自己生成的，采用两个步骤即可： 编译时：使用\"-ffunction-sections\"和\"-fdata-sections\"将每个function/data创建为一个sections，sections名与function/data名保持一致。 链接时：采用\"-Wl, -gc-sections\"，告诉系统去掉那些没用用到的section，则链接器ld不会链接未使用的函数，从而减小可执行文件大小。  如果静态库不是你自己生成的，试试--strip-all(貌似-gc-sections与--gc-sections都可以) gcc -Os -fdata-sections -ffunction-sections test.c -o test.elf -Wl,--gc-sections -Wl,--strip-all", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "引用 5 楼 Intel0011 的回复:gcc -Os -fdata-sections -ffunction-sections test.c -o test.exe -Wl,-gc-sections -Wl,-strip-all or gcc -Os -fdata-sections -ffunction-sections -Wl,-gc-sections -Wl,-strip-all test.c -o test.exe 太牛了你！话说你这些是在哪里看到的？", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 user-2 的回复:--gc-sections，gc前面是两个-，不过不一定能小多少，你ls比较一下 不识别这个参数呀。。。。。 我的gcc是Windows上的（mingw）", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "--gc-sections，gc前面是两个-，不过不一定能小多少，你ls比较一下", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "忘说了，前提是静态库", "referer": "user-0"}]}
{"question": "free函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "free需要和malloc/realloc成对出现，free是针对对上空间的释放，对于没在堆上申请空间的地址是不能释放的，否则可能会出现多错误～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 3 楼 肥牛肉^*^ 的回复：[quote=引用 2 楼 user-5的回复:]malloc <-> free 一定是成对使用的。 Sequence st没有使用malloc，是放在栈上的，不需要自行去free 至于说结构体中包含了指针。那得看这个指针是怎么用的。 如果没有malloc空间，不需要free。 那让结构体里面的指针指向一个指针变量这样可以释放吗，就是int *p   int**a=p可以free（st）吗[/quote]数组和数组元素是两码事 数组不用free，数组元素如果是指针类型，并且申请了内存，就要释放数组元素，也就是释放free(st.a[i])是可以的", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "引用 3 楼 肥牛肉^*^ 的回复:那让结构体里面的指针指向一个指针变量这样可以释放吗，就是int *p   int**a=p可以free（st）吗 你对成对使用这个词是怎么理解的", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "free 只针对堆地址，并不是所有的指针都需要free", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 2 楼 user-5的回复:malloc <-> free 一定是成对使用的。 Sequence st没有使用malloc，是放在栈上的，不需要自行去free 至于说结构体中包含了指针。那得看这个指针是怎么用的。 如果没有malloc空间，不需要free。 那让结构体里面的指针指向一个指针变量这样可以释放吗，就是int *p   int**a=p可以free（st）吗", "referer": "user-0"}, {"cid": "6", "user": "user-5", "content": "malloc <-> free 一定是成对使用的。 Sequence st没有使用malloc，是放在栈上的，不需要自行去free 至于说结构体中包含了指针。那得看这个指针是怎么用的。 如果没有malloc空间，不需要free。", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "没有动态分配就不用free", "referer": "user-0"}]}
{"question": "关于多维指针的使用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "感谢大佬们  我明白了", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "LS都说了，补充一下 2 【triangle是二维指针，是怎么能够进行triangle[i][j]操作？vs是不能运行的，原因在于编译器不知道*triangle的数组长度有多大，没办法找到triangle[i][j]】，如果是这样，你的代码 if (1 == triangleSize)         return triangle[0][0]; //为什么就可以操作？i=0,j=0  所以问题不在于编译器知不知道长度有多少，这个长度是你自己保证的，如果长度没能保证，编译器只会数组越界进行非法操作。所以这些参数的指针的有效性以及数组长度是你自己去保证的，因为编译器不知道运行时就传入什么参数，所以只要你语法对，就可以编译。  3 你的cache[I]都知道malloc分配内存，为何就没有想到triangle_p[i]没分配内存？所以triangle_p[0][0];是非法的。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "C99支持动态数组 Vs出错是因为他对c99标准不完全支持", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "引用 楼主 盛祖吕 的回复:问题如下： 1.题解使用的c语言是标准c吗？为什么能用变量初始化数组长度 2.triangle是二维指针，是怎么能够进行triangle[i][j]操作？vs是不能运行的，原因在于编译器不知道*triangle的数组长度有多大，没办法找到triangle[i][j]，而如下操作是可以的，创建了一个一维指针数组，每一个一维指针都指向一块独立的内存空间  int** cache = (int**)malloc(sizeof(int*) * triangleSize); for (int i = 0; i < triangleSize; i++) { \tcache[i] = (int*)malloc(sizeof(int) * triangleColSize[i]); }  3.针对问题2中的问题，类似于本题的情况，如何才能优雅的实现对一个多维数组使用数组下标来操作。 \tcache[0][0] = triangle_p[0][0];\t\t//此处运行崩溃 1、这个是符合C99标准的语法，用变量初始化数组长度且是局部作用域的数组称为变长数组 2、triangle是二维指针，是怎么能够进行triangle[i][j]操作？这个是二维数组的基本操作，triangle[i]是一维指针，triangle[i][j]就是元素了 3、明显你只对cache的二维分配了空间，没有对triangle_p的二维分配空间就访问当然出错", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 5 楼 盛祖吕 的回复:[quote=引用 3 楼 qybao 的回复:]LS都说了，补充一下 2 【triangle是二维指针，是怎么能够进行triangle[i][j]操作？vs是不能运行的，原因在于编译器不知道*triangle的数组长度有多大，没办法找到triangle[i][j]】，如果是这样，你的代码 if (1 == triangleSize)         return triangle[0][0]; //为什么就可以操作？i=0,j=0  所以问题不在于编译器知不知道长度有多少，这个长度是你自己保证的，如果长度没能保证，编译器只会数组越界进行非法操作。所以这些参数的指针的有效性以及数组长度是你自己去保证的，因为编译器不知道运行时就传入什么参数，所以只要你语法对，就可以编译。  3 你的cache[I]都知道malloc分配内存，为何就没有想到triangle_p[i]没分配内存？所以triangle_p[0][0];是非法的。 不好意思贴错代码了 我之所以会说编译器不知道多少是因为如下例子： int a[2][2] = { {0,1}, {2,3} }; int **b = a; printf(\"%d\\n\", b[1][0]); 这样子运行的时候会崩溃，因为编译器不知道b[0]-b[1]间具体有多大的内存空间，所以必须显式的指定指针的宽度所以得写成以下这样才能正确运行 int a[2][2] = { {0,1}, {2,3} }; int (*b)[2] = a; printf(\"%d\\n\", b[1][0]); 那么问题来了   我的这个题目传入的参数数组的宽度不是定值，也就是说指定指针宽度得是个变值，而vs里又要求指针宽度不能是变量，这就很矛盾了，例如下面这样编译就会报错 int c = 2; int (*b)[c] = a;[/quote]  你没明白我的意思。我上面也说了，编译器不管长度，你不保证长度它就越界非法访问内存，所以这个参数传入是你自己保证的。 人家的题目又没有说main函数会给minimumTotal函数传入一个等长的二维数组（为了回答还去看了一下题目，下次直接贴题目不要链接），你怎么就自以为人家传入函数的参数是等长二维数组呢？ 比如  void printDoublePointer(int **p, int row, int *col) { //谁规定这里的p是等长的二维数组？p本身就是个不等长数组，1维长度row控制，2维长度col控制，很正常     int i, j;     for(i=0; i<row; i++) {         for (j=0; j<col[i]; j++) {             printf(\"%d \", p[i][j]); //这里的I，j是靠你保证的，你传入的参数不对，自然就会造成非法访问         }         printf(\"\\n\");     } }  int main() {     int n=5, i, j;     int **p = (int**)malloc(sizeof(int*)*n);     int *col = (int*)malloc(sizeof(int)*n);     for (i=0; i<n; i++) {         col[i] = i+1;         p[i] = (int*)malloc(sizeof(int)*col[i]);         for (j=0; j<col[i]; j++) {             p[i][j] = j+1;         }     }     printDoublePointer(p, n, col); //人家main函数这样传参数不行吗？谁规定一定用等长二维数组     free(col);     for (i=0; i<n; i++) {         free(p[i]);     }     free(p);     return 0; }", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 8 楼 user-4 的回复:数组不是指针  你用二级指针指向二维数组是错误的行为  属于对指针和数组理解错误 所以oj在调用我的函数进行传参的时候传入的是一个指针数组，而不是直接将一个二维数组传入喽 这样看起来就说的过去了", "referer": "user-0"}, {"cid": "7", "user": "user-4", "content": "数组不是指针  你用二级指针指向二维数组是错误的行为  属于对指针和数组理解错误", "referer": "user-0"}, {"cid": "8", "user": "user-4", "content": "引用 5 楼 盛祖吕 的回复:我之所以会说编译器不知道多少是因为如下例子： int a[2][2] = { {0,1}, {2,3} }; int **b = a; printf(\"%d\\n\", b[1][0]); 这样子运行的时候会崩溃，因为编译器不知道b[0]-b[1]间具体有多大的内存空间 这个崩溃和你说的内容毫无关系 假设 int* 和 int 都是 4个字节 假设 数组a地址是1000 b[1] 就是 *(b+1) b是1000  b+1是1004 1004是 a[0][1]的地址 b[1][0] 相当于 *(int*)a[0][1] 把a[0][1]这个int内容当成地址 并解引用 导致崩溃", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "if (1 == triangleSize)         return triangle[0][0]; //为什么就可以操作？i=0,j=0 这句话没报错是因为用例没运行到", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "引用 3 楼 qybao 的回复:LS都说了，补充一下 2 【triangle是二维指针，是怎么能够进行triangle[i][j]操作？vs是不能运行的，原因在于编译器不知道*triangle的数组长度有多大，没办法找到triangle[i][j]】，如果是这样，你的代码 if (1 == triangleSize)         return triangle[0][0]; //为什么就可以操作？i=0,j=0  所以问题不在于编译器知不知道长度有多少，这个长度是你自己保证的，如果长度没能保证，编译器只会数组越界进行非法操作。所以这些参数的指针的有效性以及数组长度是你自己去保证的，因为编译器不知道运行时就传入什么参数，所以只要你语法对，就可以编译。  3 你的cache[I]都知道malloc分配内存，为何就没有想到triangle_p[i]没分配内存？所以triangle_p[0][0];是非法的。 不好意思贴错代码了 我之所以会说编译器不知道多少是因为如下例子： int a[2][2] = { {0,1}, {2,3} }; int **b = a; printf(\"%d\\n\", b[1][0]); 这样子运行的时候会崩溃，因为编译器不知道b[0]-b[1]间具体有多大的内存空间，所以必须显式的指定指针的宽度所以得写成以下这样才能正确运行 int a[2][2] = { {0,1}, {2,3} }; int (*b)[2] = a; printf(\"%d\\n\", b[1][0]); 那么问题来了   我的这个题目传入的参数数组的宽度不是定值，也就是说指定指针宽度得是个变值，而vs里又要求指针宽度不能是变量，这就很矛盾了，例如下面这样编译就会报错 int c = 2; int (*b)[c] = a;", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "不好意思贴错代码了 上面的是我调试的代码，实际没有triangle_p这个指针  int minimumTotal(int** triangle, int triangleSize, int* triangleColSize) {     int** cache = (int**)malloc(sizeof(int*) * triangleSize);     int res = 99999999999;     if (1 == triangleSize)         return triangle[0][0];     else if (!triangleSize)         return -1;     for (int i = 0; i < triangleSize; i++)     {         cache[i] = (int*)malloc(sizeof(int) * triangleColSize[i]);         memset(cache[i], 0, sizeof(int) * triangleColSize[i]);       }     cache[0][0] = triangle[0][0];        //此处运行崩溃     for (int i = 1; i < triangleSize; i++)     {         for (int j = 0; j < triangleColSize[i]; j++)         {             if (0 == j)             {                 cache[i][0] = cache[i - 1][0] + triangle_p[i][0];             }             else             {                 cache[i][j] = MIN(cache[i - 1][j], cache[i - 1][j - 1]) + triangle_p[i][j];             }         }     }     for (int i = 0; i < triangleColSize[triangleSize - 1]; i++)     {         res = MIN(res, cache[triangleSize - 1][i]);     }     return res; }", "referer": "user-0"}]}
{"question": "C语言错误 : free(): invalid next size (fast): 0x0000000000c34030 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 5 楼 张博约 的回复:1.   指针数组 'ret' 越界了； 2.   calloc分配的内存的大小等于两个参数之积， 第二个参数为0时该接口的行为不明确，具体取决于库的实现； 3.  【建议】 如果要以‘|’为分界符拆分字符串，可以看看strtok 接口。 根据大佬所说，特意去看了下calloc函数的功能，以前的错误理解函数功能以及参数，正确的定义应该为：void *calloc(size_t nmemb, size_t size); 现做修改如下： 1、将上面程序中所有calloc函数的第二参数修改为“sizeof(char *)或者sizeof(char **)”； 2、将上面程序中 ret = (char **)calloc(sizeof(char **), 0); 修改成  ret = (char **)calloc(sizeof(char **) * strLen, sizeof(char **)); 这样即可正常运行了。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 真相重于对错 的回复:而且你的代码有内存泄露 因为ret是二级指针，所以他相当于一个指针数组，其中每个元素都是指针，要释放ret之前，还要释放它所包含每个指针。 按照大佬的说明修改代码，增加了二级指针的内存大小，增加了malloc与free的匹配的程序，现在修改成了下面这样： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h>  int main(int argc, const char **argv) {     char *srcStr = \"1111|22222|100.215|false|00000000|000.003|00100|00122|00133\";     char *srcTmp = srcStr;      char idx = '|';       int strLen = strlen(srcStr);     char *tmp = (char *)calloc(sizeof(char) * (strLen + 1), 0);     char **ret = NULL;      ret = (char **)calloc(sizeof(char **) * 10, 0);      printf(\"line = %d, ret    = %p, malloc = %ld\\n\", __LINE__, ret, sizeof(char **));      int i = 0;     while ((tmp = strchr(srcTmp, idx)) != NULL)     {          ret[i] = malloc(sizeof(char) * (strLen + 1));         memset(ret[i], 0, sizeof(char) * (strLen + 1));         strncpy(ret[i], srcTmp, strlen(srcTmp) - strlen(tmp));         printf(\"line = %d, ret[%d] = %p, malloc = %ld, %s, %ld, %ld\\n\",             __LINE__, i, ret[i], sizeof(char) * (strLen + 1), ret[i],             strlen(srcTmp), strlen(tmp));         srcTmp = tmp + 1;         i++;     }     ret[i] = malloc(sizeof(char) * (strLen + 1));     memset(ret[i], 0, sizeof(char) * (strLen + 1));     strncpy(ret[i], srcTmp, strlen(srcTmp));     printf(\"line = %d, ret[%d] = %p, malloc = %ld, %s\\n\", __LINE__,          i, ret[i], sizeof(char) * (strLen + 1), ret[i]);      for(int j = 0; j < i; j++)     {         free(ret[j]);         printf(\"Line = %d, free(ret[%d] = %p\\n\", __LINE__, j, ret[j] );         ret[j] = NULL;     }     free(tmp);     free(ret);      return 0; }  运行的结果为： $ ./a.out   line = 17, ret    = 0x1c4b030, malloc = 8 line = 26, ret[0] = 0x1c4b460, malloc = 60, 1111, 59, 55 line = 26, ret[1] = 0x1c4b4b0, malloc = 60, 22222, 54, 49 line = 26, ret[2] = 0x1c4b500, malloc = 60, 100.215, 48, 41 line = 26, ret[3] = 0x1c4b550, malloc = 60, false, 40, 35 line = 26, ret[4] = 0x1c4b5a0, malloc = 60, 00000000, 34, 26 line = 26, ret[5] = 0x1c4b5f0, malloc = 60, 000.003, 25, 18 line = 26, ret[6] = 0x1c4b640, malloc = 60, 00100, 17, 12 line = 26, ret[7] = 0x1c4b690, malloc = 60, 00122, 11, 6 line = 34, ret[8] = 0x1c4b6e0, malloc = 60, 00133 Line = 40, free(ret[0] = 0x1c4b460 Line = 40, free(ret[1] = 0x1c4b4b0 Line = 40, free(ret[2] = 0x1c4b500 Line = 40, free(ret[3] = 0x1c4b550 段错误 (核心已转储)", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "1.   指针数组 'ret' 越界了； 2.   calloc分配的内存的大小等于两个参数之积， 第二个参数为0时该接口的行为不明确，具体取决于库的实现； 3.  【建议】 如果要以‘|’为分界符拆分字符串，可以看看strtok 接口。", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "引用 楼主 smartergirl 的回复:本人小白首先向各位大佬们致敬！祝大佬们哪哪都好！ 本人小白在学习C语言指针的时候遇到了一个比较难的问题，目前已经处于无处下爪的阶段，特来向各位大佬请教！ 下面是本人编写的代码，在运行过程中会出现如题错误。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h>  int main(int argc, const char **argv) {     char *srcStr = \"1111|22222|100.215|false|00000000|000.003|00100|00122|00133\";     char *srcTmp = srcStr;     char idx = '|';       int strLen = strlen(srcStr);     char *tmp = (char *)calloc(sizeof(char) * (strLen + 1), 0);     char **ret = NULL;      ret = (char **)calloc(sizeof(char **), 0);      printf(\"line = %d, ret = %p, malloc = %ld\\n\", __LINE__, ret, sizeof(char **));      int i = 0;     while ((tmp = strchr(srcTmp, idx)) != NULL)     {          ret[i] = malloc(sizeof(char) * (strLen + 1));         memset(ret[i], 0, sizeof(char) * (strLen + 1));         strncpy(ret[i], srcTmp, strlen(srcTmp) - strlen(tmp));         printf(\"line = %d, ret[%d] = %p, malloc = %ld, %s, %ld, %ld\\n\",             __LINE__, i, ret[i], sizeof(char) * (strLen + 1), ret[i],             strlen(srcTmp), strlen(tmp));         srcTmp = tmp + 1;         i++;     }     ret[i] = malloc(sizeof(char) * (strLen + 1));     memset(ret[i], 0, sizeof(char) * (strLen + 1));     strncpy(ret[i], srcTmp, strlen(srcTmp));     printf(\"line = %d, ret[%d] = %p, malloc = %ld, %s\\n\", __LINE__,          i, ret[i], sizeof(char) * (strLen + 1), ret[i]);     free(tmp);     free(ret);      return 0; } 使用系统为Ubuntu 16.04 LTS，编译为 gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.10) 下面是错误的提示信息： $ ./a.out  line = 20, ret = 0x1881030, malloc = 8 line = 29, ret[0] = 0x1881460, malloc = 58, 1111, 57, 53 line = 29, ret[1] = 0x18814b0, malloc = 58, 22222, 52, 47 line = 29, ret[2] = 0x1881500, malloc = 58, 100215, 46, 40 line = 29, ret[3] = 0x1881550, malloc = 58, false, 39, 34 line = 29, ret[4] = 0x18815a0, malloc = 58, 00000000, 33, 25 line = 29, ret[5] = 0x18815f0, malloc = 58, 000003, 24, 18 line = 29, ret[6] = 0x1881640, malloc = 58, 00100, 17, 12 line = 29, ret[7] = 0x1881690, malloc = 58, 00122, 11, 6 line = 37, ret[8] = 0x18816e0, malloc = 58, 00133 *** Error in `./a.out': free(): invalid next size (fast): 0x0000000001881030 *** ======= Backtrace: ========= /lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7f0ce19667e5] /lib/x86_64-linux-gnu/libc.so.6(+0x8037a)[0x7f0ce196f37a] /lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7f0ce197353c] ./a.out[0x400a01] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f0ce190f830] ./a.out[0x400659] ======= Memory map: ======== 00400000-00401000 r-xp 00000000 08:07 664382                             /home/songtb/Desktop/debug/a.out 00600000-00601000 r--p 00000000 08:07 664382                             /home/songtb/Desktop/debug/a.out 00601000-00602000 rw-p 00001000 08:07 664382                             /home/songtb/Desktop/debug/a.out 01881000-018a2000 rw-p 00000000 00:00 0                                  [heap] 7f0cdc000000-7f0cdc021000 rw-p 00000000 00:00 0  7f0cdc021000-7f0ce0000000 ---p 00000000 00:00 0  7f0ce16d9000-7f0ce16ef000 r-xp 00000000 08:01 396993                     /lib/x86_64-linux-gnu/libgcc_s.so.1 7f0ce16ef000-7f0ce18ee000 ---p 00016000 08:01 396993                     /lib/x86_64-linux-gnu/libgcc_s.so.1 7f0ce18ee000-7f0ce18ef000 rw-p 00015000 08:01 396993                     /lib/x86_64-linux-gnu/libgcc_s.so.1 7f0ce18ef000-7f0ce1aaf000 r-xp 00000000 08:01 396955                     /lib/x86_64-linux-gnu/libc-2.23.so 7f0ce1aaf000-7f0ce1caf000 ---p 001c0000 08:01 396955                     /lib/x86_64-linux-gnu/libc-2.23.so 7f0ce1caf000-7f0ce1cb3000 r--p 001c0000 08:01 396955                     /lib/x86_64-linux-gnu/libc-2.23.so 7f0ce1cb3000-7f0ce1cb5000 rw-p 001c4000 08:01 396955                     /lib/x86_64-linux-gnu/libc-2.23.so 7f0ce1cb5000-7f0ce1cb9000 rw-p 00000000 00:00 0  7f0ce1cb9000-7f0ce1cdf000 r-xp 00000000 08:01 396927                     /lib/x86_64-linux-gnu/ld-2.23.so 7f0ce1ebc000-7f0ce1ebf000 rw-p 00000000 00:00 0  7f0ce1edd000-7f0ce1ede000 rw-p 00000000 00:00 0  7f0ce1ede000-7f0ce1edf000 r--p 00025000 08:01 396927                     /lib/x86_64-linux-gnu/ld-2.23.so 7f0ce1edf000-7f0ce1ee0000 rw-p 00026000 08:01 396927                     /lib/x86_64-linux-gnu/ld-2.23.so 7f0ce1ee0000-7f0ce1ee1000 rw-p 00000000 00:00 0  7ffe87400000-7ffe87421000 rw-p 00000000 00:00 0                          [stack] 7ffe8751c000-7ffe8751f000 r--p 00000000 00:00 0                          [vvar] 7ffe8751f000-7ffe87521000 r-xp 00000000 00:00 0                          [vdso] ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall] 已放弃 (核心已转储)   小白，积分不多，已经全部上缴了。。。。。  malloc和free成对使用  只看到ret[i] = malloc(sizeof(char) * (strLen + 1)); 没有看到free(ret[i])呀", "referer": "user-0"}, {"cid": "5", "user": "user-3", "content": "而且你的代码有内存泄露 因为ret是二级指针，所以他相当于一个指针数组，其中每个元素都是指针，要释放ret之前，还要释放它所包含每个指针。", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "你这个肯定不对 ret 是一个二级指针，你只alloc了一个元素，然后你又用ret[i]方式写入了好多元素，所以free的时候要出错", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "顺便说一下，在有一些情况下是可以正常运行的。比如这样的情况下： 1、将上面的代码中第10行中` char idx = '|';   ` 修改成  ` char idx = '.';   `，那么就可以正常运行，运行结果为： $ ./a.out  line = 17, ret = 0x1676030, malloc = 8 line = 26, ret[0] = 0x1676460, malloc = 60, 1111|22222|100, 59, 45 line = 26, ret[1] = 0x16764b0, malloc = 60, 215|false|00000000|000, 44, 22 line = 34, ret[2] = 0x1676500, malloc = 60, 003|00100|00122|00133", "referer": "user-0"}]}
{"question": "约瑟夫环（C语言单循环链表实现）", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<string.h>  struct node {     int num;     char name[20];     struct node *next; };  struct node *create_singly_link(int num) {     struct node *head, *prev, *cur;     int i;      head = NULL;     for(i = 0; i < num; i++) {         cur = (struct node *)malloc(sizeof(struct node));         if (!cur) {             printf(\"Malloc error!\");             return NULL;         }         cur->next = NULL;         cur->num = i+1;         snprintf(cur->name, 20-1, \"%c\", 'A'+i);         if (!head) {             head = cur;             prev = cur;         } else {             prev->next = cur;             prev = prev->next;         }     }     prev->next = head;     return head; }  static void test_print(struct node *phead) {     struct node *pcur = phead->next;      printf(\"num = %d\\t name = %s\\n\", phead->num, phead->name);     while (pcur != phead) {         printf(\"num = %2d\\t name = %s\\n\", pcur->num, pcur->name);         pcur = pcur->next;     } }  int output( struct node *head, int start, int step, int total) {     struct node *p, *q;     int count = 0;     int num = 0, i;      q = head;      for(i = 0; i < start; i++)         q = q->next;      while(count < total-1) {         p = q->next;         num++;         if(!(num % step)) {             q->next = p->next;             printf(\"%s\\n\", p->name);             free(p);             count++;         } else {             q = p;         }     }     printf(\"num = %d\\t, name = %s\\n\", q->num, q->name);     free(q);      return 0; } int main(int argc, const char *argv[]) {     int total, step, start;     struct node *head;      printf(\"Please input total test number: \");     scanf(\"%d\", &total);     head = create_singly_link(total);     test_print(head);      printf(\"Please input start position and steps: \");     scanf(\"%d%d\", &start, &step);      output(head, start, step, total);      return 0; } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "使用链表的话，不适合用带有空表头的实现。因为表尾要指向第一个有意义的数据，而且第一个位置也有可能被删除。 表头不含实际数据的话，就有两个指针指向第一个数据，容易操作不方便实现。   主体程序大抵如此：   #include <stdio.h> #include <stdlib.h>  typedef struct Node {     int data;     struct Node *next; } Node;  static void debug_print_list(struct Node *l);  Node* Init(int n) {     int i;     Node *node, *head = NULL, *prev = NULL;      for(i = 0; i < n; i++) {         node = (Node*) malloc(sizeof(Node));         node->data = i;         node->next = NULL;          if (head == NULL) {             head = node;         }          if (prev != NULL) {             prev->next = node;         }         prev = node;     }     prev->next = head;      return head; }  Node *Order(Node *L, int n, int m) {     Node *p = NULL, *q = L;  // p points to previous node, q points to current node     int counter = 0;      while (1) {         if (q->next == q)             break;          counter += 1;         printf(\"[DBEUG]: node %d reports %d\\n\", q->data, counter);         if (counter == m) {             // assert(p != NULL); corner case need to be considered             printf(\"[DEBUG]: Removing node %d\\n\", q->data);             p->next = q->next;             free(q);             q = p->next;              counter = 0;             debug_print_list(q);             continue;         }          p = q;         q = q->next;     }      return q; }  int main() {     Node* L, *result;     int n,m;     n = 9;     m = 3;      L=Init(n);     debug_print_list(L);      result = Order(L, n, m);     printf(\"n=%d, m=%d, final-node=%d\\n\", n, m, result->data);     return 0; }  void debug_print_list(Node *l) {     Node *p = l;      while (1) {         printf(\"%d\", p->data);         if (p->next != l)             printf(\" --> \");         p = p->next;          if (p == l)             break;     };      printf(\"\\n\"); }", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "typedef的一般用法是兩個不同的名字，比如typedef _Node { ... } Node; malloc分配内存後，應該判斷返回是否NULL，否則對其操作可能出錯 Init函數中對首節點的處理也有問題，當n為1時，p->next=q會導致鏈表不是以NULL結尾", "referer": "user-0"}]}
{"question": "函数调用", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:return(arry[i]); 这一句相当于 return array[9],它的作用是什么呢？ 我懂了，谢谢", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-1的回复:return(arry[i]); 这一句相当于 return array[9],它的作用是什么呢？ 可以不用这个吗，我小白，大佬", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "return(arry[i]); 这一句相当于 return array[9],它的作用是什么呢？", "referer": "user-0"}]}
{"question": "中序线索化二叉树算法使用顺序栈", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "StackInitiate函数的代码呢？ 看参数StackInitiate(&st)是二级指针，估计函数内部是动态分配内存（说明顺序栈的大小是动态的）。所以最后要释放内存。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "这个是一个伪代码。 释放的是栈 st的空间，StackInitiate(&st) 和 free(st) 对应。 栈内存储的只是指针，也没有对应的free。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "书写错  下一题", "referer": "user-0"}]}
{"question": "农夫过河问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "类似于i+=1; i+=1; i=i+; ======= m<<=1; 相当于 m=m<<1;", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 真相重于对错的回复:左移一位，相当于乘2 为什么还要加个等号，直接movers＜＜1这样可以吗", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "这是位运算，<<是左移，>>是右移，是对二进制的操作 和一般运算符操作一样，比如+，+1表示加1，变量+=1就是变量+1的结果再赋给变量 同理，<<1表示左移1位，变量<<=1就是变量左移1位的结果再赋给变量 因为是二进制，所以左移1位相当于乘2，右移1位相当于除以2， 比如，移1个字节8位bit来举例，二进制00000001（十进制 1），左移1位变成00000010（十进制 2），高位舍弃低位补0，十进制从1变成2，相当于乘2。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "左移一位，相当于乘2", "referer": "user-0"}]}
{"question": "字符串处理的常用库函数", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "使用  其他   字符串处理库函数 时   在  C源程序 中包含  头文件string.h  楼主的语文是体育老师教的。  老婆给当程序员的老公打电话：下班顺路买十个包子，如果看到卖西瓜的，买一个。当晚老公手捧一个包子进了家门…老婆怒道：你怎么只买一个包子?!老公甚恐，喃喃道：因为我真看到卖西瓜的了。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "就是在使用字符串处理函数时，需要包含头文件string.h，因为这个头文件里包含了字符串处理函数的声明，库函数实现在动态库里（这个不需要关心），只需要引入头文件就好了。", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "你是学语文还是学编程？这句话在文法上其他的字符串处理函数和其他字符串处理的函数都说得通，但是如果你会编程，就不会问这种奇葩的问题。 就好比医学生不会对“变态反应”大惊小怪。", "referer": "user-0"}, {"cid": "4", "user": "user-4", "content": "纠正一下，字符串处理是函数的定语", "referer": "user-0"}, {"cid": "5", "user": "user-4", "content": "这是中文理解的歧义吗？ 其他字符串处理库函数 的正确理解是 其他字符串处理库函数   ，关键词就是其他函数，其他的什么函数呢？字符串处理函数 所以，不是其他字符串，是其他函数，字符串处理是函数的定于。  感觉想再教语文。。。", "referer": "user-0"}]}
{"question": "Strassen算法代码：内存出错，求大佬指点，马上交报告了 ", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 2 楼 Anthony.F.Young 的回复:救救孩子！！！（捞一下寄几）  1.建议free后，直接将指针置为NULL 否则如果重复释放，不好判定。 2. 不要在一行放多个语句，影响定位问题。  在出错的地方下断点看一下。 基本就是空指针或者溢出的问题", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "释放空指针了吧， 怎么分配的内存空间啊， 去分配的地方仔细检查一下吧", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "大佬们帮帮忙呀", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "救救孩子！！！（捞一下寄几）", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "楼主是上海某985大二学渣，算法课让实现矩阵规模非2的幂次下的strassen算法，搞来搞去好像都是内存方面的错误，烦请各位大佬帮我看看哪儿的问题", "referer": "user-0"}]}
{"question": "农夫过河问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "0x开头是16进制，但是&运算没有规定必须用二进制啊，只是运算过程用二进制来运算 比如 int a = 5, b = 3; int c = a & b; //操作数都是10进制，5 是 101， 3 是 011，所以 5&3=101&011=001=1（十进制），运算过程用二进制，操作数没有规定必须用二进制，所以用16进制也没问题，运算过程把16进制转成2进制来运算。 16进制的0x08就是2进制的00001000，10进制是8，所以 location&0x08 和 location&8是一样的（十进制），location&1000就不对了，因为二进制不能直接表示，1000就是10进制的1000。", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "C语言没有你所说的二进制输入，最多可用函数去实现。 C语言本身支持的三种输入是： 1. 十进制。比如20,457； 2. 十六进制，以0x开头。比如0x7a； 3. 八进制，以0开头。比如05,0237", "referer": "user-0"}, {"cid": "3", "user": "user-3", "content": "二进制和十六进制有区别吗？", "referer": "user-0"}]}
{"question": "求大佬帮我看看这两种算法的优劣", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "之所以说是理论上，是从出栈入栈的角度讨论的，实际上栈也是模拟的，root = stack[top--]; 或者直接 root = root->left; （不入栈）都是等效的 所以两个算法的时间复杂度和空间复杂度是一样的。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "理论上算法二优越一些。 因为算法二只有一个父节点入栈，而算法一是左右两个节点都入栈（虽然左节点入栈后马上在下一轮循环出栈，但也是多了一次入栈出栈的操作）", "referer": "user-0"}]}
{"question": "大佬们，这个冒泡排序还有什么问题？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "i是不确定值，栈上的空间不像堆上的空间可以动态指定（申请），栈上的空间需要运行前指定。", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 3 楼 lin5161678的回复:i垃圾值 不能做数组大小 你想用输入做数组大小 得在输入语句后面这数组定义 并且你输入是n 应该用n 而不是i 万分感谢！！！", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 1 楼 user-3的回复:最好是把代码粘上来，截图看着太累。 int a[i]感觉应该是int a[n]，但理论上c语言是不支持这样声明数组的，数组的长度必须是一个确定的常量值。 定义数组长度可以是变量", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "i垃圾值 不能做数组大小 你想用输入做数组大小 得在输入语句后面这数组定义 并且你输入是n 应该用n 而不是i", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 user-3的回复:最好是把代码粘上来，截图看着太累。 int a[i]感觉应该是int a[n]，但理论上c语言是不支持这样声明数组的，数组的长度必须是一个确定的常量值。 虽然改了a【i】，改用malloc后对了，但C99不是支持这样定义吗", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "最好是把代码粘上来，截图看着太累。 int a[i]感觉应该是int a[n]，但理论上c语言是不支持这样声明数组的，数组的长度必须是一个确定的常量值。", "referer": "user-0"}]}
{"question": "C语言|编译过了，但是测试集过不了，应该是文件读出有点问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "现在知道怎末改了吗", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "引用 2 楼 自信男孩 的回复:读写方式不对，读是用二进制，而写是用ascii。所以写入的内容，读出来的不一致。 建议用fscanf/fprintf或fread/fwrite进行读写", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "读写方式不对，读是用二进制，而写是用ascii。所以写入的内容，读出来的不一致。", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "题目呢", "referer": "user-0"}]}
{"question": "算第m个到第n个质数的和，为啥这个for循环程序算出来是错的？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include <stdio.h> /* 1、注意缩进 {} 2、注意t=1和t==1的区别, t==1 3、注意初始化变量 sum=0 4、注意标志变量的刷新赋值 t=1 5、注意变量的初始值 cnt=m 6、注意不同的条件可能会产生副作用 for (x = 2; cnt < n; x++)--for (i = 2; i < x; i++) */ int main() {     int x = 0, m = 0, n = 0, sum = 0, t = 1;     int cnt = 0;     scanf(\"%d %d\", &m, &n);     cnt = m;//从m开始，否则会从0开始的     if (m > 0 && m < n && m <= 200)     {         for (x = 2; cnt < n; x++)//m~n-1之间的质数，不包括n         {             int i = 0;             t = 1;//t=1要在这里重新赋值为1             for (i = 2; i < x; i++)//2会被过滤掉，但是刚好2也是质数             {                 if (x % i == 0)                 {                     t = 0;                     break;                 }             }             if (t == 1)//原来是“t=1”             {                 if (cnt >= m)                 {                     printf(\"%x\\n\",x);                     sum += x;                 }             }             cnt++;//cnt在这里加1         }         printf(\"%d\\n\", sum);     }//注意缩进     return 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "#include <stdio.h> #include <math.h> /* 计算第m个质数到第n个质数之间的和 1、先计算出质数 2、取对应的质数累加求和 */ int prime(int m ,int n) {     int index = 1;     int i = 0, j = 0;     int sum = (m==1?2:0);     for (i = 3;; i++)     {         for (j = 2; j <= sqrt(i); j++)         {             if (i % j == 0)             {                 break;             }         }         if (j > sqrt(i))         {             index++;             if (index >= m && index <= n)             {                 sum += i;             }             if (index >= n)             {                 break;             }         }     }     return sum; } int main() {     int m = 0, n = 0, sum = 0;     scanf(\"%d %d\", &m, &n);     if (m > 0 && m < n && m <= 200)     {         sum=prime(m, n);         printf(\"%d\\n\", sum);     }     return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "参考一下吧  int main() {     int i, x, m, n, cnt=0, sum=0;     scanf(\"%d%d\", &m, &n);     for (x=2; cnt<n; x+=(x==2?1:2)) {         for(i=3; i<=x/2; i+=2) {             if (x%i==0) break;         }         if (i>x/2) {             cnt++;             if (cnt>=m) {                 sum += x;             }         }     }     printf(\"%d\\n\", sum); }", "referer": "user-0"}]}
{"question": "求大佬帮我讲解这段代码", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "所谓 万变不离其宗 链表一般是单节点对单节点的单向关系（当然也有双向关系，就是双向链表） 二叉树就是单节点对双节点的单向关系（所以单向关系就是父节点能找到子节点，但子节点不能找到父节点） 图就是多节点对多节点的多向关系 所以关系越复杂，就越不好理解。（感觉怎么和生活一样）", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "十分感谢，我感觉二叉树代码好长，有点不好理解，但理解过后就发现其实二叉树就是链表，想想前面刚学链表时还挺轻松的，真让我郁闷", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "其实说好理解也好理解，说不好理解也不好理解，前中后序只是打印的地方不同，遍历过程是相同的。 就像上次跟你说的，它的遍历过程就是先找到左子树的最右节点，然后让最右节点的右节点指向父节点，然后父节点的左子树继续遍历，当遍历到最右节点的右节点就会回到父节点（因为之前设置了最右节点的右节点指向父节点），然后恢复最右节点的右节点为NULL，并遍历父节点的右子树。 所以前中后序的差别上只是在于什么时候打印。  后序打印为什么会复杂呢？因为它要遍历到最右节点才开始打印（前序，中序在中间就打印），所以它要遍历到最右节点以后，才开始逆向打印之前的各层的节点。那么怎么逆向打印呢？想想还不简单吗？因为遍历到最右节点时，最右节点的右节点又回到了父节点，拿到父节点，就可以得到原来的父节点的左右节点。 所以addPath就是为了打印这个从最右节点开始逆向遍历的结果。 先顺着打印 res[(*returnSize)++] = root->val;  root = root->right;  再逆向重新排列结果 int t = res[i]; res[i] = res[j]; res[j] = t; 这里的逆序addPath可能用了技巧，只需要对半逆向，具体没太细研究，大体思路就是这样，所以后序需要找到最右才能开始打印，不像前序中序在遍历过程中就能打印，所以它比较繁琐。 这种技巧性的东西，我觉得没有必要研究得太深，意义不大，可能只是一开始惊叹一下这技巧不错，但是不能给其他问题带来什么新的启发，所以大概了解就可以了。", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "大佬们，我发现二叉树的后序遍历的非递归代码相比前序遍历和中序遍历，很不好理解，有什么诀窍吗？", "referer": "user-0"}]}
{"question": "有大神帮忙看看嘛，最后总是输出不了啊", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "仅供参考：//链表实现一元多项式的加法减法乘法 #include <stdio.h> #include <stdlib.h> typedef struct node { \tfloat coef;\t  //系数 \tint\texpn;\t  //指数 \tstruct node\t*next; } PolyNode;\t   //多项式节点\tpolynomial node typedef PolyNode* Polynomial; Polynomial createPolynomial() {  //创建多项式 \tPolyNode *p, *q, *head = (PolyNode *)malloc(sizeof(PolyNode));\t //头节点 \thead->next = NULL; \tfloat coef; \tint\texpn; \tprintf(\"输入该多项式每一项的系数和指数，每项一行，输入0 0结束！\\n\"); \twhile (scanf(\"%f %d\", &coef, &expn) && coef) {   // 默认，按指数递减排列 \t\tif (head->next)\t{ \t\t\tp =\thead; \t\t\twhile (p->next && expn < p->next->expn) \t\t\t\tp =\tp->next; \t\t\tif (p->next) { \t\t\t\tif (expn ==\tp->next->expn) { //有相同指数的直接把系数加到原多项式 \t\t\t\t\tp->next->coef += coef; \t\t\t\t\tif (p->next->coef >\t-0.000001 && p->next->coef < 0.000001) { //若是相加后系数为0，则舍弃该节点 \t\t\t\t\t\tq =\tp->next; \t\t\t\t\t\tp->next\t= q->next; \t\t\t\t\t\tfree(q); \t\t\t\t\t} \t\t\t\t} else { \t\t\t\t\tq =\t(PolyNode*)malloc(sizeof(PolyNode)); \t\t\t\t\tq->coef\t= coef; \t\t\t\t\tq->expn\t= expn; \t\t\t\t\tq->next\t= p->next; \t\t\t\t\tp->next\t= q; \t\t\t\t} \t\t\t} else { \t\t\t\tp->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\t\t\tp =\tp->next; \t\t\t\tp->coef\t= coef; \t\t\t\tp->expn\t= expn; \t\t\t\tp->next\t= NULL; \t\t\t} \t\t} else { \t\t\thead->next = (PolyNode*)malloc(sizeof(PolyNode)); \t\t\thead->next->coef = coef; \t\t\thead->next->expn = expn; \t\t\thead->next->next = NULL; \t\t} \t} \treturn head; } Polynomial multiply(Polynomial poly, float coef, int expn) {  //多项式与指定单项式相乘，该单项式为 coefx^expn \tPolyNode *p, *q, *Poly = (PolyNode*)malloc(sizeof(PolyNode)); \tp =\tPoly; \tq =\tpoly->next; \twhile (q) { \t\tp->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\tp =\tp->next; \t\tp->coef\t= (q->coef*coef); \t\tp->expn\t= (q->expn + expn); \t\tq =\tq->next; \t} \tp->next\t= NULL; \treturn Poly; } void add(Polynomial\tpoly1, Polynomial poly2) {\t//把 poly2 加到\tpoly1 上 \tPolyNode *p, *q, *r; \tr =\tpoly1; \tp =\tpoly1->next;  //指向第一个节点 \tq =\tpoly2->next; \tpoly2->next\t= NULL; \twhile (p &&\tq) { \t\tif (p->expn\t> q->expn) { \t\t\tr->next\t= p; \t\t\tp =\tp->next; \t\t\tr =\tr->next; \t\t} else if (p->expn < q->expn) { \t\t\tr->next\t= q; \t\t\tq =\tq->next; \t\t\tr =\tr->next; \t\t} else { \t\t\tPolyNode *t; \t\t\tp->coef\t+= q->coef; \t\t\tif (!(p->coef >\t-0.000001 && p->coef < 0.000001)) //系数不为0 \t\t\t{ \t\t\t\tr->next\t= p; \t\t\t\tr =\tr->next; \t\t\t\tp =\tp->next; \t\t\t} else { \t\t\t\tt =\tp; \t\t\t\tp =\tp->next; \t\t\t\tfree(t); \t\t\t} \t\t\tt =\tq; \t\t\tq =\tq->next; \t\t\tfree(t); \t\t} \t} \tif (p) \t\tr->next\t= p; \tif (q) \t\tr->next\t= q; } Polynomial polySubtract(Polynomial poly1, Polynomial poly2)\t{  //多项式减法\tpoly1-poly2形成一个新的多项式 \t//把poly2的系数取相反数，形成一个新的多项式 \tPolynomial poly\t= (PolyNode*)malloc(sizeof(PolyNode)); //构造头节点 \tPolyNode *p, *q; \tp =\tpoly; \tq =\tpoly2->next; \twhile (q) { \t\tp->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\tp =\tp->next; \t\tp->coef\t= -(q->coef);  //系数取反 \t\tp->expn\t= q->expn; \t\tq =\tq->next; \t} \tp->next\t= NULL; \tadd(poly, poly1);  //利用加法 \treturn poly; } Polynomial polyAdd(Polynomial poly1, Polynomial\tpoly2) { //多项式相加 poly1+poly2形成一个新的多项式 \tPolynomial poly\t= (PolyNode*)malloc(sizeof(PolyNode));\t//和多项式的头节点 \tpoly->next = NULL; \tPolyNode *p, *q, *r; \tr =\tpoly; \tp =\tpoly1->next; \tq =\tpoly2->next; \twhile (p&&q) { \t\tif (p->expn\t> q->expn) { \t\t\tr->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\t\tr =\tr->next; \t\t\tr->coef\t= p->coef; \t\t\tr->expn\t= p->expn; \t\t\tp =\tp->next; \t\t} else if (p->expn < q->expn) { \t\t\tr->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\t\tr =\tr->next; \t\t\tr->coef\t= q->coef; \t\t\tr->expn\t= q->expn; \t\t\tq =\tq->next; \t\t} else { \t\t\tfloat m\t= p->coef +\tq->coef; \t\t\tif (!(m\t> -0.000001\t&& m < 0.000001)) { \t\t\t\tr->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\t\t\tr =\tr->next; \t\t\t\tr->coef\t= m; \t\t\t\tr->expn\t= p->expn; \t\t\t} \t\t\tq =\tq->next; \t\t\tp =\tp->next; \t\t} \t} \twhile (p) { \t\tr->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\tr =\tr->next; \t\tr->coef\t= p->coef; \t\tr->expn\t= p->expn; \t\tp =\tp->next; \t} \twhile (q) { \t\tr->next\t= (PolyNode*)malloc(sizeof(PolyNode)); \t\tr =\tr->next; \t\tr->coef\t= q->coef; \t\tr->expn\t= q->expn; \t\tq =\tq->next; \t} \tr->next\t= NULL; \treturn poly; } Polynomial polyMultiply(Polynomial poly1, Polynomial poly2)\t{  //多项式相乘 \tPolynomial poly\t= (PolyNode*)malloc(sizeof(PolyNode));\t//创建多项式和的头节点 \tpoly->next = NULL; \tPolyNode *p; \tp =\tpoly2->next; \twhile (p) { \t\tadd(poly, multiply(poly1, p->coef, p->expn)); \t\tp =\tp->next; \t} \treturn poly; } void printPoly(Polynomial poly)\t{  //打印多项式 \tif (poly &&\tpoly->next)\t{ \t\tPolyNode *p\t= poly->next;  //p指向第一个节点 \t\twhile (p->next)\t{ \t\t\tprintf(\"%gx^%d\", p->coef, p->expn); \t\t\tp =\tp->next; \t\t\tif (p && (p->coef >\t0)) \t\t\t\tprintf(\"+\"); \t\t} \t\tif (p->expn\t== 0) \t\t\tprintf(\"%g\", p->coef);   //打印常数项 \t\telse \t\t\tprintf(\"%gx^%d\", p->coef, p->expn); \t\tprintf(\"\\n\"); \t} } void freePoly(Polynomial poly) {  //释放内存 \tif (poly &&\tpoly->next)\t{ \t\tPolyNode *p, *q; \t\tp =\tpoly; \t\twhile (p) { \t\t\tq =\tp->next; \t\t\tfree(p); \t\t\tp =\tq; \t\t} \t} \tpoly = NULL; } int\tmain() { \tprintf(\"用链表实现多项式的加减法\\n\"); \tPolynomial poly1, poly2, poly3; \tprintf(\"创建多项式一\\n\"); \tpoly1 =\tcreatePolynomial(); \tprintf(\"多项式一：\\n\"); \tprintPoly(poly1); \tprintf(\"创建多项式二\\n\"); \tpoly2 =\tcreatePolynomial(); \tprintf(\"多项式二：\\n\"); \tprintPoly(poly2); \tprintf(\"两多项式相加，和为：\\n\"); \tpoly3 =\tpolyAdd(poly1, poly2); \tprintPoly(poly3); \tfreePoly(poly3); \tprintf(\"两个多项式相乘，积为：\\n\"); \tpoly3 =\tpolyMultiply(poly1,\tpoly2); \tprintPoly(poly3); \tfreePoly(poly3); \tprintf(\"两多项式相减，差为：\\n\"); \tpoly3 =\tpolySubtract(poly1,\tpoly2); \tprintPoly(poly3); \tfreePoly(poly1); \tfreePoly(poly2); \tfreePoly(poly3); \tsystem(\"pause\"); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-3的回复:这贴的图片，可能很难一下就看出哪里的问题阿。。。 可以请你帮我看看为什么printf（“”%c“”,a[i].data）输出不了吗 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX_SIZE 1024 typedef struct{ char data; int weight; int parent; int lchild; int rchild; }Huffnode,*Hufftree; typedef struct stack{ int top; int elem[MAX_SIZE]; }Stack; void Initstack(Stack *s) { s->top=-1; } void push(Stack *s,int e) { s->top++; s->elem[s->top]=e; } int pop(Stack *s) { return s->elem[s->top--]; } bool isempty(Stack *s) { if(s->top==-1) return true; else return false; } void GetHuffmamCode(Hufftree a,int n) { int i,j,s1,s2,max,c,p; Stack s; char ch; Initstack(&s); printf(\"输入字符集：\"); for(i=1;i<=n;i++) { scanf(\"%c\",&a[i].data); scanf(\"%c\",&ch); } printf(\"输入权值：\"); for(i=1;i<=n;i++) { scanf(\"%d\",&a[i].weight); scanf(\"%c\",&ch); } int m=2*n-1; for(i=1;i<=n;i++) { a[i].parent=0; a[i].rchild=0; a[i].lchild=0; } for(i=n+1;i<=m;i++) { a[i].data=NULL; a[i].weight=0; a[i].parent=0; a[i].lchild=0; a[i].rchild=0; } for(i=n+1;i<=m;i++) { max=65535; for(j=1;j<=i-1;j++) { if(a[j].parent==0&&a[j].weight<=max) { s1=j; max=a[j].weight; } } a[s1].parent=i; max=65535; for(j=1;j<=i-1;j++) { if(a[j].parent==0&&a[j].weight<=max) { s2=j; max=a[j].weight; } } a[s2].parent=i; a[i].weight=a[s1].weight+a[s2].weight; a[i].lchild=s1; a[i].rchild=s2; } for(i=1;i<=n;i++) { c=i; p=a[i].parent; while(p!=0) { if(a[p].lchild==c) push(&s,0); else push(&s,1); c=p; p=a[p].parent; } printf(\"%c\\n\",a[i].data); while(!isempty(&s)) printf(\"%d\",pop(&s)); printf(\"\\n\"); } } int main() { Hufftree a; int n; int m; printf(\"输入字符个数：\"); scanf(\"%d\",&n); m=2*n-1; a=(Hufftree)malloc(sizeof(Huffnode)*m); GetHuffmamCode(a,n); return 0; }", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h> #include<malloc.h>    typedef struct polynode {     int coef;     int exp;     struct polynode *next; }polynode, *polylist;  polylist poly_create(void) {     polynode *rear, *head, *s;      int c, e;      rear = head = (polynode *)malloc(sizeof(polynode));     scanf(\"%d%d\", &c, &e);      while (c) {         s = (polynode*)malloc(sizeof(polynode));         s->coef = c;         s->exp = e;         rear->next = s;         rear = s;         scanf(\"%d%d\", &c, &e);     }     rear->next=NULL;      return(head); }    static void insert_node(polylist phead, polylist new_node) {     polylist pcur, pprev;      pprev = phead;     pcur = phead->next;      while (pcur && pcur->exp != new_node->exp) {         pprev = pcur;         pcur = pcur->next;     }     if (!pcur) {         pprev->next = new_node;         return;     }      pcur->coef += new_node->coef;     free(new_node);     if (pcur->coef == 0) {         pprev->next = pcur->next;         free(pcur);     } }  polylist multyploy(polylist pa, polylist pb) {     polylist pa_node, pb_node, pc_node, pc;     int coef, exp;       pc = (polynode*)malloc(sizeof(polynode));     if (!pc)         return NULL;      pa_node = pa->next;     pb_node = pb->next;      if (!pa_node || !pb_node) {         pc = pa_node ? pa : pb;     }     while (pa_node) {         while (pb_node) {             coef = pa_node->coef * pb_node->coef;             exp = pa_node->exp + pb_node->exp;              pc_node = (polylist)malloc(sizeof(polynode));             if (!pc_node)                 exit(0);             pc_node->coef = coef;             pc_node->exp = exp;             pc_node->next = NULL;              insert_node(pc, pc_node);             pb_node = pb_node->next;         }         pa_node = pa_node->next;         pb_node = pb->next;     }      return pc; }  void free_polylist(polylist phead) {     polylist pdel, pcur;      pcur = phead;      while (pcur) {         pdel = pcur;         pcur = pcur->next;         free(pdel);     } }  static void show_polylist(polylist phead) {     if (!phead)         return;      polylist pcur = phead->next;      while(pcur) {         printf(\"%d\", pcur->coef);         printf(\"*x^%d\", pcur->exp);         if (pcur->next)             printf(\" + \");         pcur = pcur->next;     }     printf(\"\\n\"); }  int main(void) {     polylist pa, pb, pc;      pa = poly_create();     //show_polylist(pa);     pb = poly_create();     //show_polylist(pb);     pc = multyploy(pa, pb);      show_polylist(pc);      free_polylist(pa);     pa = NULL;     free_polylist(pb);     pb = NULL;     free_polylist(pc);     pc = NULL;      return 0; } 供参考～", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "不管是从大到小， 还是从小到大， 都可以， 其实要处理coef =0 的情况还是有些麻烦的， 比如 一个多项式， p=0x,  需要化简为 p=0,  还是 p=空  关于你的代码，貌似没有必要对第一次循环做特殊处理， 只用2层while 就可以了把, 伪代码是：  while each 式子 of  A {     while each  式子 of B  {          计算 A[i] * B[j] ,                加入到 C 中     } }  while each 式子 of C {      处理coef ==0  }", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 6 楼 user-3的回复:[quote=引用 5 楼 qq_51281859 的回复:] 我上面的代码是，分别给pa，pb链表赋值，幂从小到大，当赋值到因子为零时，结束循环，然后以第一个多项式的第一项和第二个多项式的每一项相乘，构造一个新的链表，然后以第一个多项式的第二项和第二个多项式的每一项相乘，查找第一个大于或等于这个幂的在链表中的位置，如果幂相等，则因数相加，相加如果等于零，则释放掉这个空间，如果查找到的大于这个幂，则将其插入，最后输出，可是我这构造的第一项与每一项相乘的新链表，单独的话可以输出，进行下面插入操作以后就不能输出了，不知道问题出现在哪里。  我的代码和你的基本也差不多，唯一的一点时， 在计算时， 没有处理coef==0 的情况， 问题是， 当计算某个项coef为0时， 后面的多项式又可能会出现这个项， 所以建议最后计算完后才处理coef==0 的式子， 另外一点，在生成 c 多项式时， 最好以插入排序的方式， 根据幂的大小， 由高到低排列， 这样多项式打印时，比较符合习惯。 [/quote] 我这个输入时按从小到大输入会比较方便，就是不懂为什么最后输出不了", "referer": "user-0"}, {"cid": "6", "user": "user-3", "content": "引用 5 楼 qq_51281859 的回复:我上面的代码是，分别给pa，pb链表赋值，幂从小到大，当赋值到因子为零时，结束循环，然后以第一个多项式的第一项和第二个多项式的每一项相乘，构造一个新的链表，然后以第一个多项式的第二项和第二个多项式的每一项相乘，查找第一个大于或等于这个幂的在链表中的位置，如果幂相等，则因数相加，相加如果等于零，则释放掉这个空间，如果查找到的大于这个幂，则将其插入，最后输出，可是我这构造的第一项与每一项相乘的新链表，单独的话可以输出，进行下面插入操作以后就不能输出了，不知道问题出现在哪里。  我的代码和你的基本也差不多，唯一的一点时， 在计算时， 没有处理coef==0 的情况， 问题是， 当计算某个项coef为0时， 后面的多项式又可能会出现这个项， 所以建议最后计算完后才处理coef==0 的式子， 另外一点，在生成 c 多项式时， 最好以插入排序的方式， 根据幂的大小， 由高到低排列， 这样多项式打印时，比较符合习惯。", "referer": "user-0"}, {"cid": "7", "user": "user-0", "content": "引用 4 楼 user-3的回复:试了一下上面的代码， 貌似出现无限循环的情况， 实在有点看不懂上面的代码，  下面改写了一个，还请指正   /**  * 在多项式中查找是否有幂为exp的项，  * 如有，返回指向Polynode指针  * 否则返回NULL  */ Polynode* searchByExp(Polylist p, int exp) { \tPolynode* x = p->next; \twhile(x!=NULL) { \t\tif(x->exp == exp) { \t\t\treturn x; \t\t} \t\tx = x->next; \t} \treturn NULL; }  Polylist multyploy2(Polylist pa, Polylist pb) { \tPolynode *t1,*t2, *t3, *rear,*p;  \tt1=pa->next; \tt2=pb->next;  \trear=p=(Polynode*)malloc(sizeof(Polynode)); \tp->next = NULL;  \twhile(t1!=NULL) { \t\tt2 = pb->next; \t\twhile(t2!=NULL) { \t\t\tt3 = searchByExp(p, t1->exp+t2->exp ); \t\t\tif(t3==NULL) { \t\t\t\t// 生成新的项加入到p \t\t\t\tt3=(Polynode*)malloc(sizeof(Polynode)); \t\t\t\tt3->coef=t1->coef*t2->coef; \t\t\t\tt3->exp = t1->exp + t2->exp; \t\t\t\tt3->next=NULL; \t\t\t\trear->next=t3; \t\t\t\trear=t3; \t\t\t} \t\t\telse { \t\t\t\tt3->coef += (t1->coef*t2->coef); \t\t\t} \t\t\tt2=t2->next; \t\t}  \t\tt1 = t1->next; \t}  \treturn p; }  我上面的代码是，分别给pa，pb链表赋值，幂从小到大，当赋值到因子为零时，结束循环，然后以第一个多项式的第一项和第二个多项式的每一项相乘，构造一个新的链表，然后以第一个多项式的第二项和第二个多项式的每一项相乘，查找第一个大于或等于这个幂的在链表中的位置，如果幂相等，则因数相加，相加如果等于零，则释放掉这个空间，如果查找到的大于这个幂，则将其插入，最后输出，可是我这构造的第一项与每一项相乘的新链表，单独的话可以输出，进行下面插入操作以后就不能输出了，不知道问题出现在哪里。", "referer": "user-0"}, {"cid": "8", "user": "user-0", "content": "引用 8 楼 user-3的回复:不管是从大到小， 还是从小到大， 都可以， 其实要处理coef =0 的情况还是有些麻烦的， 比如 一个多项式， p=0x,  需要化简为 p=0,  还是 p=空  关于你的代码，貌似没有必要对第一次循环做特殊处理， 只用2层while 就可以了把, 伪代码是：  while each 式子 of  A {     while each  式子 of B  {          计算 A[i] * B[j] ,                加入到 C 中     } }  while each 式子 of C {      处理coef ==0  } 已经解决了，我又重新写了一个", "referer": "user-0"}, {"cid": "9", "user": "user-0", "content": "引用 8 楼 user-3的回复:不管是从大到小， 还是从小到大， 都可以， 其实要处理coef =0 的情况还是有些麻烦的， 比如 一个多项式， p=0x,  需要化简为 p=0,  还是 p=空  关于你的代码，貌似没有必要对第一次循环做特殊处理， 只用2层while 就可以了把, 伪代码是：  while each 式子 of  A {     while each  式子 of B  {          计算 A[i] * B[j] ,                加入到 C 中     } }  while each 式子 of C {      处理coef ==0  } 我把中间相乘的函数改了一下，改成先把相乘结果各项存入链表，然后再同类项相加，可是还是无法输出，如果知道为什么无法输出，问题就解决了 Polylist multyploy(Polylist pa, Polylist pb) { \tPolynode *t1,*t2,*t3,*t,*rear,*p,*r; \tint c, e; \tt1=pa->next; \tp=(Polynode*)malloc(sizeof(Polynode)); \trear=p; \twhile(t1) \t{ \t\tt2=pb->next; \t\twhile(t2) \t\t{ \t\t\tt=(Polynode*)malloc(sizeof(Polynode)); \t\t\tt->coef=t1->coef*t2->coef; \t\t\tt->exp=t1->exp+t2->exp; \t\t\tt->next=NULL; \t\t\trear->next=t; \t\t\trear=t; \t\t\tt2=t2->next; \t\t} \t\tt1=t1->next; \t} \tr=p->next; \twhile(r->next) \t{ \t\tt3=r->next; \t\twhile(t3&&t3->exp!=r->exp) \t\t\tt3=t3->next; \t\tif(t3==NULL) \t\t\tcontinue; \t\telse \t\t{ \t\t\tr->coef=r->coef+t3->coef; \t\t\tt=t3->next; \t\t\tt3->next=t->next; \t\t\tfree(t); \t\t} \t\tr=r->next; \t} \t \treturn (p); }", "referer": "user-0"}, {"cid": "10", "user": "user-3", "content": "试了一下上面的代码， 貌似出现无限循环的情况， 实在有点看不懂上面的代码，  下面改写了一个，还请指正   /**  * 在多项式中查找是否有幂为exp的项，  * 如有，返回指向Polynode指针  * 否则返回NULL  */ Polynode* searchByExp(Polylist p, int exp) { \tPolynode* x = p->next; \twhile(x!=NULL) { \t\tif(x->exp == exp) { \t\t\treturn x; \t\t} \t\tx = x->next; \t} \treturn NULL; }  Polylist multyploy2(Polylist pa, Polylist pb) { \tPolynode *t1,*t2, *t3, *rear,*p;  \tt1=pa->next; \tt2=pb->next;  \trear=p=(Polynode*)malloc(sizeof(Polynode)); \tp->next = NULL;  \twhile(t1!=NULL) { \t\tt2 = pb->next; \t\twhile(t2!=NULL) { \t\t\tt3 = searchByExp(p, t1->exp+t2->exp ); \t\t\tif(t3==NULL) { \t\t\t\t// 生成新的项加入到p \t\t\t\tt3=(Polynode*)malloc(sizeof(Polynode)); \t\t\t\tt3->coef=t1->coef*t2->coef; \t\t\t\tt3->exp = t1->exp + t2->exp; \t\t\t\tt3->next=NULL; \t\t\t\trear->next=t3; \t\t\t\trear=t3; \t\t\t} \t\t\telse { \t\t\t\tt3->coef += (t1->coef*t2->coef); \t\t\t} \t\t\tt2=t2->next; \t\t}  \t\tt1 = t1->next; \t}  \treturn p; }", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "引用 1 楼 user-3的回复:这贴的图片，可能很难一下就看出哪里的问题阿。。。 大佬想要啥样的，我实在找不出来问题在哪了", "referer": "user-0"}, {"cid": "12", "user": "user-0", "content": "引用 1 楼 user-3的回复:这贴的图片，可能很难一下就看出哪里的问题阿。。。 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define NULL 0 typedef struct Polynode { \tint coef;  //因子 \tint exp;   //幂 \tstruct Polynode *next; }Polynode , * Polylist;  Polylist polycreate( )  { \tPolynode *rear, *head, *s; \t \tint c, e; \t \trear=head=(Polynode *)malloc(sizeof(Polynode));   \tscanf(\"%d%d\",&c,&e);  \twhile(c!=0)  \t{ \t \t\ts=(Polynode*)malloc(sizeof(Polynode)); \t\ts->coef=c;  \t\ts->exp=e;  \t\trear->next=s;  \t\trear=s;   \t\tscanf(\"%d%d\",&c,&e);  \t} \trear->next=NULL;  \treturn(head); } Polylist multyploy(Polylist pa, Polylist pb) { \tPolynode *t1,*t2,*t3,*t,*rear,*p; \tint c, e; \tt1=pa->next; \tt2=pb->next; \trear=p=(Polynode*)malloc(sizeof(Polynode)); \twhile(t2) \t{ \t\tt3=(Polynode*)malloc(sizeof(Polynode)); \t\tt3->coef=t1->coef*t2->coef; \t\tt3->exp=t1->exp+t2->exp; \t\tt3->next=NULL; \t\trear->next=t3; \t\trear=t3; \t\tt2=t2->next; \t} \tt1=t1->next; \twhile(t1) \t{ \t\tt2=pb->next; \t\trear=p; \t\twhile(t2) \t\t{ \t\t\te=t1->exp+t2->exp; \t\t\tc=t1->coef*t2->coef; \t\t\twhile(rear->next&&rear->next->exp<e) \t\t\t\trear=rear->next; \t\t\tif(rear->next&&rear->next->exp==e) \t\t\t{ \t\t\t\tif(rear->next->coef+c) \t\t\t\t\trear->next->coef+=c; \t\t\t\telse \t\t\t\t{ \t\t\t\t\tt=rear->next; \t\t\t\t\trear->next=t->next; \t\t\t\t\tfree(t); \t\t\t\t\t \t\t\t\t} \t\t\t} \t\t\telse \t\t\t{ \t\t\t\tt=(Polynode*)malloc(sizeof(Polynode)); \t\t\t\tt->coef=c; \t\t\t\tt->exp=e; \t\t\t\tt->next=rear->next; \t\t\t\trear->next=t; \t\t\t\trear=rear->next; \t\t\t} \t\t} \t\tt1=t1->next; \t} \treturn (p); } void print(Polylist p) { \tp = p->next; \twhile(p) \t{ \t\tprintf(\"%d\", p->coef); \t\tprintf(\"*x^%d\",p->exp); \t\tif(p->next!=NULL) \t\t\tprintf(\" + \"); \t\tp = p->next; \t} \tprintf(\"\\n\"); }  void main(int argc, char* argv[]) { \tPolylist pa, pb,pc;   //定义三个表示多项式的链表 \t \tpa = polycreate();  //创建pa链表 \tpb = polycreate();  //创建pb链表 \tpc = multyploy(pa, pb);   //做乘法法，结果保存在pc链表上 \tprint(pc);      //将加法的结果用一个多项式格式显示在输出设备上 }", "referer": "user-0"}, {"cid": "13", "user": "user-3", "content": "这贴的图片，可能很难一下就看出哪里的问题阿。。。", "referer": "user-0"}]}
{"question": "这个冒泡排序到底哪里出错？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-2的回复:你这哪是排序？ ii在循环中一直不变，a[j]一直和ii固定位置的元素a[ii]比较 感谢，我之前以为ii会一直等于i+1，听你回复懂了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 2 楼 focuslight的回复:你那个 int a[i] 怎么没报错啊。 用常量声明数组啊 C99好像可以这样，不用malloc", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "你那个 int a[i] 怎么没报错啊。 用常量声明数组啊", "referer": "user-0"}, {"cid": "4", "user": "user-2", "content": "你这哪是排序？ ii在循环中一直不变，a[j]一直和ii固定位置的元素a[ii]比较", "referer": "user-0"}]}
{"question": "c语言", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "对于实数的比较，一般写法 #define EPS 1e-7 .....  while(fabs(a)-20>=EPS);", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "浮点数的比较不能像整形数那样比较.  https://blog.csdn.net/jk110333/article/details/8902707  供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "谢谢！", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "浮点数的精度原因致使浮点数不一定能准确存储表达一个数，所以不能用这种方式来比较， 可以用 a-20<一个精度范围 这样的方式来代替", "referer": "user-0"}]}
{"question": "这个代码没错吧，链表后面结点的值显示不出来？求大神帮忙", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 3 楼 编程且快乐的回复:这个是我帮你修改的代码（如果觉得可以请结题一下）： struct list *getlink(int b[], int b1) { \tstruct list *s,*h; \tstruct list *head = NULL; \tint i; \tfor ( i = b1-1; i>=0; i--) \t{ \t\th = (struct list *)malloc(sizeof(struct list));\t \t\th->data = b[i]; \t\th->next = NULL; \t\tif (head == NULL){ \t\t\thead = h; \t\t} \t\telse \t\t{ \t\t\ts->next = h; \t\t} \t\ts = h; \t} \treturn head; } 多谢帮忙，改过来了", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:if(h=NULL)  //错误在这一句，改成 if(h == NULL) 就正确了，条件判断写成赋值啦 h=s; 谢谢了，就错在赋值号上", "referer": "user-0"}, {"cid": "3", "user": "user-1", "content": "这个是我帮你修改的代码（如果觉得可以请结题一下）： struct list *getlink(int b[], int b1) { \tstruct list *s,*h; \tstruct list *head = NULL; \tint i; \tfor ( i = b1-1; i>=0; i--) \t{ \t\th = (struct list *)malloc(sizeof(struct list));\t \t\th->data = b[i]; \t\th->next = NULL; \t\tif (head == NULL){ \t\t\thead = h; \t\t} \t\telse \t\t{ \t\t\ts->next = h; \t\t} \t\ts = h; \t} \treturn head; }", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "你这个代码在读取数据的时候错了，这个链表函数struct list* getlink(int b[],int b1);错误，重新写一个就好了，你这个函数只读了一个数据进去，因为你的链表指向不对", "referer": "user-0"}, {"cid": "5", "user": "user-2", "content": "if(h=NULL)  //错误在这一句，改成 if(h == NULL) 就正确了，条件判断写成赋值啦 h=s;", "referer": "user-0"}]}
{"question": "为什么我这个最后输出不出来啊，有人帮忙看下吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<malloc.h>    typedef struct polynode {     int coef;     int exp;     struct polynode *next; }polynode, *polylist;  polylist poly_create(void) {     polynode *rear, *head, *s;      int c, e;      rear = head = (polynode *)malloc(sizeof(polynode));     scanf(\"%d%d\", &c, &e);      while (c) {         s = (polynode*)malloc(sizeof(polynode));         s->coef = c;         s->exp = e;         rear->next = s;         rear = s;         scanf(\"%d%d\", &c, &e);     }     rear->next=NULL;      return(head); }    static void insert_node(polylist phead, polylist new_node) {     polylist pcur, pprev;      pprev = phead;     pcur = phead->next;      while (pcur && pcur->exp != new_node->exp) {         pprev = pcur;         pcur = pcur->next;     }     if (!pcur) {         pprev->next = new_node;         return;     }      pcur->coef += new_node->coef;     free(new_node);     if (pcur->coef == 0) {         pprev->next = pcur->next;         free(pcur);     } }  polylist multyploy(polylist pa, polylist pb) {     polylist pa_node, pb_node, pc_node, pc;     int coef, exp;       pc = (polynode*)malloc(sizeof(polynode));     if (!pc)         return NULL;      pa_node = pa->next;     pb_node = pb->next;      if (!pa_node || !pb_node) {         pc = pa_node ? pa : pb;     }     while (pa_node) {         while (pb_node) {             coef = pa_node->coef * pb_node->coef;             exp = pa_node->exp + pb_node->exp;              pc_node = (polylist)malloc(sizeof(polynode));             if (!pc_node)                 exit(0);             pc_node->coef = coef;             pc_node->exp = exp;             pc_node->next = NULL;              insert_node(pc, pc_node);             pb_node = pb_node->next;         }         pa_node = pa_node->next;         pb_node = pb->next;     }      return pc; }  void free_polylist(polylist phead) {     polylist pdel, pcur;      pcur = phead;      while (pcur) {         pdel = pcur;         pcur = pcur->next;         free(pdel);     } }  static void show_polylist(polylist phead) {     if (!phead)         return;      polylist pcur = phead->next;      while(pcur) {         printf(\"%d\", pcur->coef);         printf(\"*x^%d\", pcur->exp);         if (pcur->next)             printf(\" + \");         pcur = pcur->next;     }     printf(\"\\n\"); }  int main(void) {     polylist pa, pb, pc;      pa = poly_create();     //show_polylist(pa);     pb = poly_create();     //show_polylist(pb);     pc = multyploy(pa, pb);      show_polylist(pc);      free_polylist(pa);     pa = NULL;     free_polylist(pb);     pb = NULL;     free_polylist(pc);     pc = NULL;      return 0; } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "算法太复杂了，刚好有时间，重新实现了一遍。大抵如下：   #include<stdio.h> #include<stdlib.h> #include<malloc.h>  typedef struct Polynode {     int coef;  //因子     int exp;   //幂     struct Polynode *next; } Polynode , *Polylist;  Polylist polycreate( ) {     Polynode *rear, *head, *s;     int c, e;      head = NULL;     rear = NULL;      while (1) {         scanf(\"%d%d\",&c,&e);         if (c == 0)             break;          s = (Polynode *) malloc(sizeof(Polynode));         s->coef = c;         s->exp = e;         s->next = NULL;          if (head == NULL)             head = s;          if (rear != NULL) {             rear->next = s;         }         rear = s;     };      return head; }  Polylist multyploy(Polylist pa, Polylist pb) {     Polynode *n, *n1, *n2, *rslt, *rslt_rear, *new_item;     int coef, exp;      rslt = NULL;     rslt_rear = NULL;      for (n1 = pa; n1 != NULL; n1 = n1->next) {         for (n2 = pb; n2 != NULL; n2 = n2->next) {             coef = n1->coef*n2->coef;             exp = n1->exp + n2->exp;              // Find the right item to add the new result             for (n = rslt; n != NULL; n = n->next) {                 if (n->exp == exp)                     break;                 if (n->exp < exp && n->next != NULL && n->next->exp > exp)                     break;             }              // if item with identified exponent exists in result, just update its coefficient             if (n != NULL && n->exp == exp) {                 n->coef += coef;                 continue;             }              // new item needed             new_item = (Polynode *) malloc(sizeof(Polynode));             new_item->coef = coef;             new_item->exp = exp;             new_item->next = NULL;              // insert the new item, note sort if performed incrementally             if (n == NULL) {                 if (rslt == NULL) {                     rslt = new_item;                     rslt_rear = rslt;                 } else {                     rslt_rear->next = new_item;                     rslt_rear = new_item;                 }             } else {                 new_item->next = n->next;                 n->next = new_item;             }         } // iterate over the second polynominal     } // iterate over the first polynominal      return rslt; }  void print(Polylist p) {     while(p)     {         printf(\"%d\", p->coef);         printf(\"*x^%d\",p->exp);         if(p->next!=NULL)             printf(\" + \");         p = p->next;     }     printf(\"\\n\"); }  void free_poly_list(Polylist head) {     Polynode *n0, *n1;     for (n0 = head; n0 != NULL; n0 = n1) {        n1 = n0->next;        free(n0);     } }  int main(int argc, const char* argv[]) {     Polylist pa, pb,pc;       //定义三个表示多项式的链表      pa = polycreate();        //创建pa链表     pb = polycreate();        //创建pb链表     pc = multyploy(pa, pb);   //做乘法法，结果保存在pc链表上     print(pc);      free_poly_list(pa);     free_poly_list(pb);     free_poly_list(pc);      return 0; }", "referer": "user-0"}]}
{"question": "为什么我这个最后输出不出来啊，有大神帮忙看下吗？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #include<malloc.h>  //#define NULL 0 //#define NULL ((void *)0)  typedef struct Polynode {     int coef;  //因子     int exp;   //幂     struct Polynode *next; }Polynode , *Polylist;  Polylist polycreate( ) {     Polynode *rear, *head, *s;      int c, e;      rear=head=(Polynode *)malloc(sizeof(Polynode));     scanf(\"%d%d\", &c, &e);      while(c) {         s = (Polynode*)malloc(sizeof(Polynode));         s->coef=c;         s->exp=e;         rear->next=s;         rear=s;         scanf(\"%d%d\",&c,&e);     }     rear->next=NULL;      return(head); }    static void insert_node(Polylist phead, Polylist new_node) {     Polylist pcur, pprev;      pprev = phead;     pcur = phead->next;      while (pcur && pcur->exp != new_node->exp) {         pprev = pcur;         pcur = pcur->next;     }     if (!pcur) {         pprev->next = new_node;         return;     }      pcur->coef += new_node->coef;     free(new_node);     if (pcur->coef == 0) {         pprev->next = pcur->next;         free(pcur);     } }  Polylist multyploy(Polylist pa, Polylist pb) {     Polylist pa_node, pb_node, pc_node, pc;     int coef, exp;       pc = (Polynode*)malloc(sizeof(Polynode));     if (!pc)         return NULL;      pa_node = pa->next;     pb_node = pb->next;     while (pa_node) {          while (pb_node) {             coef = pa_node->coef * pb_node->coef;             exp = pa_node->exp + pb_node->exp;              pc_node = (Polylist)malloc(sizeof(Polynode));             if (!pc_node)                 exit(0);             pc_node->coef = coef;             pc_node->exp = exp;             pc_node->next = NULL;              insert_node(pc, pc_node);             pb_node = pb_node->next;         }         pa_node = pa_node->next;         pb_node = pb->next;    //保证pa的节点和pb的每个节点相乘     }      return pc; #if 0     Polynode *t1,*t2,*t3,*t,*rear,*p;     int c, e;     t1=pa->next;     t2=pb->next;     p=(Polynode*)malloc(sizeof(Polynode));     p->next=NULL;     rear=p;     while(t2)     {         t3=(Polynode*)malloc(sizeof(Polynode));         t3->coef=t1->coef*t2->coef;         t3->exp=t1->exp+t2->exp;         t3->next=NULL;         rear->next=t3;         rear=t3;         t2=t2->next;     }     t1=t1->next;     while(t1)     {         t2=pb->next;         rear=p;         while(t2)         {             e=t1->exp+t2->exp;             c=t1->coef*t2->coef;             while(rear->next&&rear->next->exp<e)                 rear=rear->next;             if(rear->next&&rear->next->exp==e)             {                 if(rear->next->coef+c)                     rear->next->coef+=c;                 else                 {                     t=rear->next;                     rear->next=t->next;                     free(t);                  }             }             else             {                 t=(Polynode*)malloc(sizeof(Polynode));                 t->coef=c;                 t->exp=e;                 t->next=rear->next;                 rear->next=t;                 rear=rear->next;             }         }         t1=t1->next;     }     t2=p;     p=p->next;     free(t2);     return p; #endif }  void print(Polylist p) {     p = p->next;     while(p)     {         printf(\"%d\", p->coef);         printf(\"*x^%d\",p->exp);         if(p->next!=NULL)             printf(\" + \");         p = p->next;     }     printf(\"\\n\"); }  //void main(int argc, char* argv[]) int main(int argc, char* argv[]) {     Polylist pa, pb,pc;   //定义三个表示多项式的链表      pa = polycreate();  //创建pa链表     //print(pa);      //将加法的结果用一个多项式格式显示在输出设备上     pb = polycreate();  //创建pb链表     //print(pb);      //将加法的结果用一个多项式格式显示在输出设备上     pc = multyploy(pa, pb);   //做乘法法，结果保存在pc链表上     print(pc);      //将加法的结果用一个多项式格式显示在输出设备上 } 供参考～", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "纯粹是为了这50分  算法太复杂了，刚好有时间，重新实现了一遍。大抵如下：   #include<stdio.h> #include<stdlib.h> #include<malloc.h>  typedef struct Polynode {     int coef;  //因子     int exp;   //幂     struct Polynode *next; } Polynode , *Polylist;  Polylist polycreate( ) {     Polynode *rear, *head, *s;     int c, e;      head = NULL;     rear = NULL;      while (1) {         scanf(\"%d%d\",&c,&e);         if (c == 0)             break;          s = (Polynode *) malloc(sizeof(Polynode));         s->coef = c;         s->exp = e;         s->next = NULL;          if (head == NULL)             head = s;          if (rear != NULL) {             rear->next = s;         }         rear = s;     };      return head; }  Polylist multyploy(Polylist pa, Polylist pb) {     Polynode *n, *n1, *n2, *rslt, *rslt_rear, *new_item;     int coef, exp;      rslt = NULL;     rslt_rear = NULL;      for (n1 = pa; n1 != NULL; n1 = n1->next) {         for (n2 = pb; n2 != NULL; n2 = n2->next) {             coef = n1->coef*n2->coef;             exp = n1->exp + n2->exp;              // Find the right item to add the new result             for (n = rslt; n != NULL; n = n->next) {                 if (n->exp == exp)                     break;                 if (n->exp < exp && n->next != NULL && n->next->exp > exp)                     break;             }              // if item with identified exponent exists in result, just update its coefficient             if (n != NULL && n->exp == exp) {                 n->coef += coef;                 continue;             }              // new item needed             new_item = (Polynode *) malloc(sizeof(Polynode));             new_item->coef = coef;             new_item->exp = exp;             new_item->next = NULL;              // insert the new item, note sort if performed incrementally             if (n == NULL) {                 if (rslt == NULL) {                     rslt = new_item;                     rslt_rear = rslt;                 } else {                     rslt_rear->next = new_item;                     rslt_rear = new_item;                 }             } else {                 new_item->next = n->next;                 n->next = new_item;             }         } // iterate over the second polynominal     } // iterate over the first polynominal      return rslt; }  void print(Polylist p) {     while(p)     {         printf(\"%d\", p->coef);         printf(\"*x^%d\",p->exp);         if(p->next!=NULL)             printf(\" + \");         p = p->next;     }     printf(\"\\n\"); }  void free_poly_list(Polylist head) {     Polynode *n0, *n1;     for (n0 = head; n0 != NULL; n0 = n1) {        n1 = n0->next;        free(n0);     } }  int main(int argc, const char* argv[]) {     Polylist pa, pb,pc;       //定义三个表示多项式的链表      pa = polycreate();        //创建pa链表     pb = polycreate();        //创建pb链表     pc = multyploy(pa, pb);   //做乘法法，结果保存在pc链表上     print(pc);      free_poly_list(pa);     free_poly_list(pb);     free_poly_list(pc);      return 0; }", "referer": "user-0"}]}
{"question": "求助free()问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "懂了，谢谢。", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "问题就在于删除的节点不是自己申请的内存，是指向main函数的z变量，z是不能free的（因为z的内存是程序自动分配的，不是自己申请的），只有自己malloc申请的内存才需要free。", "referer": "user-0"}]}
{"question": "求问前辈们一道问题 B: 栈的操作问题", "poster": "user-0", "comments": [{"cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:其实就是看你对栈的入栈出栈顺利的理解和把握。说白了就是比较输入的数据和栈顶的数据，根据比较结果来打印入栈出栈指令。如果输入数据和栈顶一致，就把栈顶出栈（并打印Q）；如果输入数据大于栈顶元素，就把元素一次入栈（并打印P，这里要注意没有重复入栈，所以判断一下上次入栈的最大值，如果输入数据比上次入栈的最大值小，则说明重复入栈，出错）；如果输入数据小于栈顶数据则错误打印error（因为栈顶再怎么出栈打印，打印结果也和输入数据不相符，所以是错误的）  #define Maxsize 1000 typedef struct{     int data[Maxsize];     int top; }SqStack; void InitStack(SqStack &s){     s.top=-1; } void Push(SqStack &s,int x){     if(s.top==Maxsize-1) return;     s.data[++s.top]=x; } int Pop(SqStack &s){     if(s.top==-1){         return -1;     }     return s.data[s.top--]; } int Peek(SqStack &s) { //加个查看栈顶元素的方法     if (s.top==-1) {         return -1;     }     return s.data[s.top]; }  int main(){     int n, i, j, t, m; //n是每行第一个数，i是n的计数器，j是记录上一次入栈的最大值（以后入栈只能从最大值+1开始），t是栈顶数据，m是每行的输入数据     SqStack s;     char res[2*Maxsize+1]; //res是指令结果字符串     while (scanf(\"%d\", &n)==1 && n>0) { //获取每行第一个数n（n是0或非法输入则结束测试）         memset(res, 0, sizeof(res)); //初始化res         InitStack(s); //初始化栈         for(i=1, j=0; i<=n; i++) { //n循环             scanf(\"%d\", &m); //获取每行的每个数据m             if (strstr(res, \"error\") != NULL) { //如果结果已经出错就跳过该行剩余的输入数据                 continue;             }             t = Peek(s); //获得栈顶数据             if (t==m) { //如果输入数据和栈顶一致，则打印Q，并弹出栈顶元素                 strcat(res, \"Q\");                 Pop(s);             } else if (t<m) { //如果输入数据大于栈顶元素（栈顶为空也包含在里面）                 if (m<j+1) { //如果m小于上次入栈的最大值+1，则出错（因为已经入过栈了，不能重复入栈）                     strcat(res, \" error\");                 } else { //从上次入栈的                     for(t=j+1; t<m; ++t) { //从上次入栈的最大值+1开始依次入栈，并打印P                         strcat(res, \"P\");                         Push(s, t);                     }                     strcat(res, \"PQ\"); //最后一个入栈后又马上出栈了，所以直接打印PQ                     j = m; //记录入栈过的最大值                 }             } else { //如果输入数据小于栈顶元素（那栈顶出栈打印的结果就和输入数据不相符，所以错误）                 strcat(res, \" error\");             }         }         printf(\"%s\\n\", res); //最后打印指令结果     }     return 0; } 前辈能解释下为什么要用栈顶元素和输入数据比较吗？ 或者说该怎么思考到这种方法思路", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "其实就是看你对栈的入栈出栈顺利的理解和把握。说白了就是比较输入的数据和栈顶的数据，根据比较结果来打印入栈出栈指令。如果输入数据和栈顶一致，就把栈顶出栈（并打印Q）；如果输入数据大于栈顶元素，就把元素一次入栈（并打印P，这里要注意没有重复入栈，所以判断一下上次入栈的最大值，如果输入数据比上次入栈的最大值小，则说明重复入栈，出错）；如果输入数据小于栈顶数据则错误打印error（因为栈顶再怎么出栈打印，打印结果也和输入数据不相符，所以是错误的）  #define Maxsize 1000 typedef struct{     int data[Maxsize];     int top; }SqStack; void InitStack(SqStack &s){     s.top=-1; } void Push(SqStack &s,int x){     if(s.top==Maxsize-1) return;     s.data[++s.top]=x; } int Pop(SqStack &s){     if(s.top==-1){         return -1;     }     return s.data[s.top--]; } int Peek(SqStack &s) { //加个查看栈顶元素的方法     if (s.top==-1) {         return -1;     }     return s.data[s.top]; }  int main(){     int n, i, j, t, m; //n是每行第一个数，i是n的计数器，j是记录上一次入栈的最大值（以后入栈只能从最大值+1开始），t是栈顶数据，m是每行的输入数据     SqStack s;     char res[2*Maxsize+1]; //res是指令结果字符串     while (scanf(\"%d\", &n)==1 && n>0) { //获取每行第一个数n（n是0或非法输入则结束测试）         memset(res, 0, sizeof(res)); //初始化res         InitStack(s); //初始化栈         for(i=1, j=0; i<=n; i++) { //n循环             scanf(\"%d\", &m); //获取每行的每个数据m             if (strstr(res, \"error\") != NULL) { //如果结果已经出错就跳过该行剩余的输入数据                 continue;             }             t = Peek(s); //获得栈顶数据             if (t==m) { //如果输入数据和栈顶一致，则打印Q，并弹出栈顶元素                 strcat(res, \"Q\");                 Pop(s);             } else if (t<m) { //如果输入数据大于栈顶元素（栈顶为空也包含在里面）                 if (m<j+1) { //如果m小于上次入栈的最大值+1，则出错（因为已经入过栈了，不能重复入栈）                     strcat(res, \" error\");                 } else { //从上次入栈的                     for(t=j+1; t<m; ++t) { //从上次入栈的最大值+1开始依次入栈，并打印P                         strcat(res, \"P\");                         Push(s, t);                     }                     strcat(res, \"PQ\"); //最后一个入栈后又马上出栈了，所以直接打印PQ                     j = m; //记录入栈过的最大值                 }             } else { //如果输入数据小于栈顶元素（那栈顶出栈打印的结果就和输入数据不相符，所以错误）                 strcat(res, \" error\");             }         }         printf(\"%s\\n\", res); //最后打印指令结果     }     return 0; }", "referer": "user-0"}]}
{"question": "有没有大神看看为什么最后只删除了一个7", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<stdlib.h> #define MAX 20 typedef struct{ \tint n; \tint data[MAX]; }SEQTABLE;  void delitem(SEQTABLE * st,int e) { \tint i,j; \tfor(i=j=0;i<st->n;i++) \t\tif(st->data[i]!=e) \t\t\tst->data[j++]=st->data[i]; \tst->n=j; } int  main() { \tint i; \tSEQTABLE st = {10, {0,5,7,9,8,7,2,6,7,9}}; \tdelitem(&st, 7); \tfor(i =0; i < st.n; i++) \t\tprintf(\"%4d\", st.data[i]); \tprintf(\"\\n\"); \treturn 0; }", "referer": "user-0"}, {"cid": "2", "user": "user-2", "content": "#include<stdio.h> #include<stdlib.h>  #define MAX 20  typedef struct{     int n;     int data[MAX+1]; } SEQTABLE;  void delitem(SEQTABLE * st,int e) {     int i, j;     for(i=1;i<=st->n;i++)     {         if(st->data[i]==e)         {             //for(i;i<st->n;i++)             for(j = i;j < st->n; j++)                 st->data[j] = st->data[j+1];             --st->n;             --i;         }     } } int  main() {     int i;      SEQTABLE st = {9, {0,5,7,9,8,7,2,6,7,9}};     delitem(&st, 7);     for(i = 1; i <= st.n; i++)     {         printf(\"%4d\", st.data[i]);     }     printf(\"\\n\");     return 0; } 供参考～", "referer": "user-0"}, {"cid": "3", "user": "user-0", "content": "引用 4 楼 focuslight的回复:void print(Polylist p) { p = p->next; while(p)   --------------  看看p是否为null P的null空间已经被释放掉了，我改了一下还是输出不出来", "referer": "user-0"}, {"cid": "4", "user": "user-3", "content": "void print(Polylist p) { p = p->next; while(p)   --------------  看看p是否为null", "referer": "user-0"}, {"cid": "5", "user": "user-0", "content": "引用 1 楼 focuslight的回复:要这么写， 你里面的for循环把i走到st->n了， 外围的循环就只走到 第一个7那里就停了  #include<stdio.h> #include<stdlib.h> #define MAX 20 typedef struct{ int n; int data[MAX+1]; } SEQTABLE;  void delitem(SEQTABLE * st,int e) { int i, j; for(i=0;i<=st->n;i++) {     j=i; if(st->data[i]==e) {      for(j;j<st->n;j++) st->data[j]=st->data[j+1]; --st->n; --i; } } } int  main() { int i;  SEQTABLE st = {9, {0,5,7,9,8,7,2,6,7,9}}; delitem(&st, 7); for(i = 0; i <= st.n; i++) { printf(\"%4d\", st.data[i]); } printf(\"\\n\"); return 0; }  谢谢谢谢，懂了", "referer": "user-0"}, {"cid": "6", "user": "user-0", "content": "引用 1 楼 focuslight的回复:要这么写， 你里面的for循环把i走到st->n了， 外围的循环就只走到 第一个7那里就停了  #include<stdio.h> #include<stdlib.h> #define MAX 20 typedef struct{ int n; int data[MAX+1]; } SEQTABLE;  void delitem(SEQTABLE * st,int e) { int i, j; for(i=0;i<=st->n;i++) {     j=i; if(st->data[i]==e) {      for(j;j<st->n;j++) st->data[j]=st->data[j+1]; --st->n; --i; } } } int  main() { int i;  SEQTABLE st = {9, {0,5,7,9,8,7,2,6,7,9}}; delitem(&st, 7); for(i = 0; i <= st.n; i++) { printf(\"%4d\", st.data[i]); } printf(\"\\n\"); return 0; }  可以再问你一个问题吗，我这个程序最后怎么输出不出来啊 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define NULL 0 typedef struct Polynode { int coef;  //因子 int exp;   //幂 struct Polynode *next; }Polynode , * Polylist;  Polylist polycreate( )  { Polynode *rear, *head, *s;  int c, e;  rear=head=(Polynode *)malloc(sizeof(Polynode));   scanf(\"%d%d\",&c,&e);  while(c!=0)  {  s=(Polynode*)malloc(sizeof(Polynode)); s->coef=c;  s->exp=e;  rear->next=s;  rear=s;   scanf(\"%d%d\",&c,&e);  } rear->next=NULL;  return(head); } Polylist multyploy(Polylist pa, Polylist pb) { Polynode *t1,*t2,*t3,*t,*rear,*p; int c, e; t1=pa->next; t2=pb->next; p=(Polynode*)malloc(sizeof(Polynode)); p->next=NULL; rear=p; while(t2) { t3=(Polynode*)malloc(sizeof(Polynode)); t3->coef=t1->coef*t2->coef; t3->exp=t1->exp+t2->exp; t3->next=NULL; rear->next=t3; rear=t3; t2=t2->next; } t1=t1->next; while(t1) { t2=pb->next; rear=p; while(t2) { e=t1->exp+t2->exp; c=t1->coef*t2->coef; while(rear->next&&rear->next->exp<e) rear=rear->next; if(rear->next&&rear->next->exp==e) { if(rear->next->coef+c) rear->next->coef+=c; else { t=rear->next; rear->next=t->next; free(t);  } } else { t=(Polynode*)malloc(sizeof(Polynode)); t->coef=c; t->exp=e; t->next=rear->next; rear->next=t; rear=rear->next; } } t1=t1->next; } t2=p; p=p->next; free(t2); return p; } void print(Polylist p) { p = p->next; while(p) { printf(\"%d\", p->coef); printf(\"*x^%d\",p->exp); if(p->next!=NULL) printf(\" + \"); p = p->next; } printf(\"\\n\"); }  void main(int argc, char* argv[]) { Polylist pa, pb,pc;   //定义三个表示多项式的链表  pa = polycreate();  //创建pa链表 pb = polycreate();  //创建pb链表 pc = multyploy(pa, pb);   //做乘法法，结果保存在pc链表上 print(pc);      //将加法的结果用一个多项式格式显示在输出设备上 }", "referer": "user-0"}, {"cid": "7", "user": "user-3", "content": "要这么写， 你里面的for循环把i走到st->n了， 外围的循环就只走到 第一个7那里就停了  #include<stdio.h> #include<stdlib.h> #define MAX 20 typedef struct{ int n; int data[MAX+1]; } SEQTABLE;  void delitem(SEQTABLE * st,int e) { int i, j; for(i=0;i<=st->n;i++) {     j=i; if(st->data[i]==e) {      for(j;j<st->n;j++) st->data[j]=st->data[j+1]; --st->n; --i; } } } int  main() { int i;  SEQTABLE st = {9, {0,5,7,9,8,7,2,6,7,9}}; delitem(&st, 7); for(i = 0; i <= st.n; i++) { printf(\"%4d\", st.data[i]); } printf(\"\\n\"); return 0; }", "referer": "user-0"}]}
{"question": "c语言为什么printf显示为定义标识符", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "printf( printf（ 不一样", "referer": "user-0"}, {"cid": "2", "user": "user-0", "content": "对的。。。。", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "呵呵，用了中文括号了吧？", "referer": "user-0"}, {"cid": "4", "user": "user-0", "content": "我明白了 printf后面那个括号格式不对", "referer": "user-0"}]}
{"question": "为什么将p=p->next 改为p++会报错？？", "poster": "user-0", "comments": [{"cid": "1", "user": "user-1", "content": "引用 9 楼 均陵鼠侠 的回复:感谢夸奖，哈哈！不过我还是中意我的《C语言非常道》，《标准C语言指南》太辞典化了。 个人感觉不同吧，没觉得《标准C语言指南》太辞典化，比原版标准好读多了 市面上只有你的《标准C语言指南》和Guy L. Steele Jr.的《C语言参考手册(原书第5版)》对原版标准有自己的诠释 有空再拜读你的《C语言非常道》", "referer": "user-0"}, {"cid": "2", "user": "user-1", "content": "[quote=引用 9 楼 均陵鼠侠 的回复: 感谢夸奖，哈哈！不过我还是中意我的《C语言非常道》，《标准C语言指南》太辞典化了。[/quote] 个人感觉不同吧，没觉得《标准C语言指南》太辞典化，比原版标准好读多了 市面上只有你的《标准C语言指南》和Guy L. Steele Jr.的《C语言参考手册(原书第5版)》对原版标准有自己的诠释 有空再拜读你的《C语言非常道》，", "referer": "user-0"}, {"cid": "3", "user": "user-2", "content": "引用 7 楼 Intel0011 的回复:[quote=引用 6 楼 均陵鼠侠 的回复:][quote=引用 5 楼 Intel0011 的回复:][quote=引用 4 楼 Intel0011 的回复:]简单来讲，就是p指向的是结构，是聚合，不是标量，所以p++非法，后缀运算符++要求操作数是标量 更正一下： 后缀运算符++要求操作数是实数类型或是指针类型 结构是聚合类型，所以p++非法 标量还包含了复数类型，而复数类型参与运算符++时，会自动进行实数-复数转换 [/quote]  指针类型是标量。请参照这幅图，确认你对标量的理解是正确的。另外，p是指针，p ++ 是没有问题的。 [/quote] 的确我看错了，p是指针，是标量 P.S.  均陵鼠侠，你的《标准C语言指南》非常赞 [/quote]  感谢夸奖，哈哈！不过我还是中意我的《C语言非常道》，《标准C语言指南》太辞典化了。", "referer": "user-0"}, {"cid": "4", "user": "user-1", "content": "均陵鼠侠，你的《标准C语言指南》的勘误在哪里，你的网站上没发现", "referer": "user-0"}, {"cid": "5", "user": "user-1", "content": "引用 6 楼 均陵鼠侠 的回复:[quote=引用 5 楼 Intel0011 的回复:][quote=引用 4 楼 Intel0011 的回复:]简单来讲，就是p指向的是结构，是聚合，不是标量，所以p++非法，后缀运算符++要求操作数是标量 更正一下： 后缀运算符++要求操作数是实数类型或是指针类型 结构是聚合类型，所以p++非法 标量还包含了复数类型，而复数类型参与运算符++时，会自动进行实数-复数转换 [/quote]  指针类型是标量。请参照这幅图，确认你对标量的理解是正确的。另外，p是指针，p ++ 是没有问题的。 [/quote] 的确我看错了，p是指针，是标量 P.S.  均陵鼠侠，你的《标准C语言指南》非常赞", "referer": "user-0"}, {"cid": "6", "user": "user-2", "content": "引用 5 楼 Intel0011 的回复:[quote=引用 4 楼 Intel0011 的回复:]简单来讲，就是p指向的是结构，是聚合，不是标量，所以p++非法，后缀运算符++要求操作数是标量 更正一下： 后缀运算符++要求操作数是实数类型或是指针类型 结构是聚合类型，所以p++非法 标量还包含了复数类型，而复数类型参与运算符++时，会自动进行实数-复数转换 [/quote]  指针类型是标量。请参照这幅图，确认你对标量的理解是正确的。另外，p是指针，p ++ 是没有问题的。", "referer": "user-0"}, {"cid": "7", "user": "user-1", "content": "引用 4 楼 Intel0011 的回复:简单来讲，就是p指向的是结构，是聚合，不是标量，所以p++非法，后缀运算符++要求操作数是标量 更正一下： 后缀运算符++要求操作数是实数类型或是指针类型 结构是聚合类型，所以p++非法 标量还包含了复数类型，而复数类型参与运算符++时，会自动进行实数-复数转换", "referer": "user-0"}, {"cid": "8", "user": "user-1", "content": "简单来讲，就是p指向的是结构，是聚合，不是标量，所以p++非法，后缀运算符++要求操作数是标量", "referer": "user-0"}, {"cid": "9", "user": "user-2", "content": "谢邀。 其实代码不用全发出来，只发一点点就足够了。 首先，你要明白链表是怎么回事。想象一下，如果把struct student看成家庭，那么，指针变量p的值指向一个家庭 a，家庭的成员next知道另一个家庭 b。这样的话，如果变量p一开始指向家庭a，那么，p = p->next就使得变量p指向家庭 b。这里的关键是，家庭a和b可能不在一起，相距很远，位置不确定，但是它们可以通过家庭的成员next彼此建立关联。 再来看表达式 p ++。如果 p 的类型是 T，那么，p++等价于 p = p + sizeof (T)，或者说，p = p + sizeof p。就是说，在p原来的基础上，再加上p的大小，或者p的类型的大小。显然，p++的结果是指向p后面的内存位置。所以p ++ 要求所有“家庭”必须是连续的、紧邻的。", "referer": "user-0"}, {"cid": "10", "user": "user-0", "content": "#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #define N 3 struct student { \tint num; \tchar name[50]; \tchar sex; \tint age; \tstruct student* next; }; void input(struct student* stu) { \tstruct student* p; \tint i=0; \tfor (p = stu; p < stu + N; p++,i++) \t{ \t\tprintf(\"第%d位:\", i + 1); \t\tscanf(\"%d %s %c %d\", &p->num, p->name, &p->sex, &p->age); \t\ti == N - 1 ? (stu[i].next = NULL) : (stu[i].next = &stu[i + 1]); \t} } void print(struct student *stu) { \tstruct student *p; \tfor (p = stu; p->next!=NULL; p=p->next); \t{ \t\tprintf(\"%d %s %c %d\", p->num, p->name, p->sex, p->age); \t} } struct student* del(struct student* stu,int n) { \tstruct student* p,*head; \tfor (p = stu,head=p; p != NULL;p=p->next) \t{ \t\tif (p->age == n) \t\t{ \t\t\tif (p == head) \t\t\t{ \t\t\t\thead = p->next; \t\t\t} \t\t\telse if (p->next == NULL) \t\t\t{ \t\t\t\t(p - 1)->next = NULL; \t\t\t} \t\t\telse \t\t\t{ \t\t\t\t(p - 1)->next = p + 1; \t\t\t} \t\t} \t} \treturn head; } int main() { \tint n; \tstruct student stu[3]; \tprintf(\"请依次输入 学号 姓名 性别 年龄：\\n\"); \tinput(stu); \tprintf(\"请输入一个年龄：\\n\"); \tscanf(\"%d\", &n); \tprint(del(stu,n)); }", "referer": "user-0"}, {"cid": "11", "user": "user-0", "content": "代码被挡了。。我重新发", "referer": "user-0"}]}