question
stringlengths 2
128
| poster
stringclasses 1
value | comments
list |
|---|---|---|
为啥我c语言 程序 本地可以 传到oj 就出现了运行错误 | user-0 | [
{
"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"
}
] |
为啥我c语言 程序 本地可以 传到oj 就出现了运行错误 | user-0 | [
{
"cid": "1",
"user": "user-0",
"content": "求各位大神解答",
"referer": "user-0"
}
] |
求助！我的字符串输出结果最后一位总是随机多一个符号TAT | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "同学，下面这一行中，m是不是没有初始化值，是不是应该把它的条件改为j<260 ? for (int j = 0; j <= m; j++) { line1[j] = line2[j] = '\\0'; }",
"referer": "user-0"
}
] |
请大佬帮忙看看这个约瑟夫环问题，不知道为什么我这个代码没有输出结果 呜呜 | user-0 | [
{
"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"
}
] |
学C的原动力 | user-0 | [
{
"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"
}
] |
求教（如何理解这段代码？） | user-0 | [
{
"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"
}
] |
同时int两个变量，为什么一个是0而另一个是1？ | user-0 | [
{
"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"
}
] |
求大佬帮助指点，不知道哪里错了 | user-0 | [
{
"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"
}
] |
此道wihle题，为什么我的写法和书上的不一样？ | user-0 | [
{
"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"
}
] |
为什么while里不能用1来表示 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "你就这么无视题意地追求死循环么？必要时可以写死循环，关键是...到必要时了么？",
"referer": "user-0"
}
] |
为什么我输入0后它还是让我继续输入 | user-0 | [
{
"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"
}
] |
这个删去重复数字的代码哪里出问题了 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "同学，同一个数组，你左移一下，右移一下，就会出现空窿，还是原来的数组吗？不就是删除重复的数字吗，为什么要搞的这么复杂呢？在输入的时候，查询一下数组有没有刚输入的数字，有就取消它，让它重新输入就不行了吗？",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "可是我不知道怎么取消它，能给点提示吗",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-1",
"content": "同学，代码如下，所有提示非必要，只是让人容易理解： #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"
}
] |
为什么红字部分和橙色部分位置互换结果不一样 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "scanf接受%d%e%f%lf%u等等数值数据的时候会跳过前置白空格找到合适的数据，读到不能接受的字节为止，然后把不接受的内容留在缓冲区里。然而%c不行，它只抓缓冲区里的第一个字节，不管它是啥。红字在上的时候，刚开始运行，缓冲区是空的，看起来正常。红字换到橙色下方，它就只能收到缓冲区里遗留的空格回车神马的了。除非先清空一下标准输入缓冲区rewind(stdin);",
"referer": "user-0"
}
] |
PTA最后一个测试点过不了，大佬帮我看看哪里错了呜呜呜 | user-0 | [
{
"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"
}
] |
Notepad++中配置C++编译环境问题。MinGW成功安装，但notepad里运行仍有看不懂的问题 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "缺依赖，要么是你没有引对头文件，要么是没有加动态库，具体缺啥得看代码",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "感谢",
"referer": "user-1"
}
] |
阶乘与（-1）的n次方的累加和输出 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "a*=m;",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "谢谢大佬",
"referer": "user-1"
}
] |
我用if else语句，是否有更简洁的写法？ | user-0 | [
{
"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"
}
] |
为什么这个循环输入数组没有输出结果 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "差点怀疑之前学的东西。。。scanf(\"%d \",&a[i]); 多了一个空格。",
"referer": "user-0"
}
] |
关于switch语句的嵌套问题 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "同学，你第2个switch语句的break只能中止当前switch，出来后还是继续执行第1个switch语句的4，6，9，11后面的case！",
"referer": "user-0"
}
] |
定义一个字符数组a，字符数组a中的字符是有序的；另一个字符数组s是无序的。要求将数组s中的字符插入到有序字符数组a中(大佬求解！) | user-0 | [
{
"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<stdio.h> #include<string.h> 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<m;i++){ for(j=0;j<n;j++){ if(arr[j]>brr[i]){ for(k=n;k>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"
}
] |
有老板知道这个用c语言怎么写么 | user-0 | [
{
"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"
}
] |
位置不相交嘛意思，一头雾水？ | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "意思就是不同类型的括号不能有交叉，([)]这种",
"referer": "user-0"
}
] |
总说超出时间限制，请求支援 | user-0 | [
{
"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"
}
] |
C语言中自增自减问题 | user-0 | [
{
"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"
}
] |
求助求助孩子想不懂啊。 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "同学，你传进函数的结构体变量不能是传值啊，要么传指针或引用，否则，传到函数里面是它的复制品，在函数内修改的是复制品，不是你想要的。",
"referer": "user-0"
}
] |
求助，求大神指导！！ | user-0 | [
{
"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"
}
] |
想请问一下这个程序超时应该怎么改？ | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "同学，我看你的代码很费劲，你直接把问题写出来，我们一起学习，可能我写代码比修改你的更快呢",
"referer": "user-0"
}
] |
用指针修改const int为什么打印出来还是原值 | user-0 | [
{
"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"
}
] |
新手照抄为什么都报错啊？求解 | user-0 | [
{
"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->num,p->score); p=p->next; } while(p!=NULL)； return 0； 没有吧，老师你看看",
"referer": "user-4"
}
] |
有没有检测C代码规范的工具？ | user-0 | [
{
"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"
}
] |
get 传参问题，该如何解答。。。。 | user-0 | [
{
"cid": "1",
"user": "user-0",
"content": "如果是data的话，url上面没有参数",
"referer": "user-0"
}
] |
c语言循环结构求输入的数字是几位数。十位数以上的为什么判断不了位数？ 跪求！谢谢！ | user-0 | [
{
"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"
}
] |
C语言读取二进制文件出错 | user-0 | [
{
"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"
}
] |
sprintf赋值255个char型数组 有什么好方法？ | user-0 | [
{
"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"
}
] |
如何用C语言将txt文本中的数据改成如下的格式 | user-0 | [
{
"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"
}
] |
在编辑数据结构线性表的顺序储存结构上出现取消对null指针的引用 咋解决啊大佬们？ | user-0 | [
{
"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"
}
] |
程序设计题——小白求救SOS！ | user-0 | [
{
"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"
}
] |
这代码没错啊，为什么PTA显示部分正确？ | user-0 | [
{
"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"
}
] |
大一新生，讲的递归调用，不知道哪里错了，求大神解答 | user-0 | [
{
"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"
}
] |
排序，从小到大输出n个输入的数字，运行不了 | user-0 | [
{
"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"
}
] |
一个小白对数组的疑问 | user-0 | [
{
"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"
}
] |
大家有没有发现最近的品牌电脑读不出来硬盘序列号了 | user-0 | [
{
"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"
}
] |
第3个for小括号里面是什么意思啊？ | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "逗号间隔的多个表达式",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "i从0开始，条件是i<5，如果满足，那么就做花括号里的，接着i+1，然后再继续判断条件是否成立，成立则做括号里，不成立就跳出了，理解否？",
"referer": "user-0"
}
] |
运用数组逆序输出1到11的数字，求问以下代码运行逻辑？ | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "因为你运行的exe程序不是你这段源代码生成的。",
"referer": "user-0"
}
] |
结构体的地址引用问题 | user-0 | [
{
"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"
}
] |
二叉树建树编译不通过 | user-0 | [
{
"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"
}
] |
visual studio 2019 Windows 10 sdk的应用实例在哪里？ | user-0 | [
{
"cid": "1",
"user": "user-0",
"content": "我的没有。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "",
"referer": "user-0"
}
] |
编译后 sum=sum+a[i]*(x^i);为什么说double和int有无效操作 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "c里这个运算符是逻辑异或，不是指数吧，指数要用 pow() 函数。",
"referer": "user-0"
}
] |
c语言 怎么把输入的字符串输出成若干个单个的字符啊 | user-0 | [
{
"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"
}
] |
浙大的c语言程序设计 page70 例4-1 运行不了 | user-0 | [
{
"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"
}
] |
有关魔方阵，救救孩子吧！ | user-0 | [
{
"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"
}
] |
关于谭浩强书里不同类型数据间的混合运算问题 | user-0 | [
{
"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"
}
] |
延时函数更改值后无变化（延时函数没有延时） | user-0 | [
{
"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"
}
] |
一个开辟动态内存后的小问题（再次修改） | user-0 | [
{
"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"
}
] |
有没有大佬帮我为什么总么算都是一个数 | user-0 | [
{
"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"
}
] |
大佬们解释一下这个代码(●'◡'●) | user-0 | [
{
"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"
}
] |
这个在c语言中的意思是什么啊 | user-0 | [
{
"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"
}
] |
有没有大佬帮我看看这个代码有什么问题啊？（用的VS2019） | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "我看最明显的是这个代码不产生输出，但既然你这样写，想必是有自己的理由的，因此对你来说这个不算是问题。",
"referer": "user-0"
}
] |
linux下用c写多进程服务器端时，对sigaction函数与信号处理的时机有点小问题 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "主函数里的调用一系列库函数的顺序，应遵循你学习到的正确顺序，不能自己发挥。因为涉及到库函数里相应数据结构的正确初始化。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "这样子啊，感谢～",
"referer": "user-1"
}
] |
编写程序：计算y年m1月d1日与同年的m2月d2日之间的天数（m2>m1）,若m2=m1且d2=d1则算1天。 输入：2017，2，27，3，10 输出：12 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "把switch语句放到for(month=0;month<m;month++)这个for循环内，试试。",
"referer": "user-0"
}
] |
以下说明语句哪句是错的 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "Dstutype是typedef定义的类型名",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "谢谢！",
"referer": "user-1"
}
] |
这个表达式10！=9的值是多少 | user-0 | [
{
"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"
}
] |
这个题为什么打印没有输出 | user-0 | [
{
"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"
}
] |
运行结果变量b没有减1 | user-0 | [
{
"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"
}
] |
求教，一直不知道错在哪里了 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "你试的数不够大。",
"referer": "user-0"
}
] |
静态库太麻烦了不同平台不同工程都要重新编译，有没有简单的方式 | user-0 | [
{
"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"
}
] |
这怎么解决啊，求解？？ | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "先声明那个函数，或者把主函数整个拉到下面去。",
"referer": "user-0"
}
] |
为什么会报错[Error] expected declaration specifiers or '...' before numeric constant | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "因为你把函数调用写成了函数声明的格式。去掉主函数里面的两个void",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "我就是声明了一个函数，然后在主函数里面调用这个函数，我这个程序在vss里面可以运行但是到了vec里面就一直说我错",
"referer": "user-1"
}
] |
请问这行代码是什么意思？void (*io_isr_cbfun)(u8 index) = NULL; | user-0 | [
{
"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"
}
] |
C++队列舞会问题触发断点，求解 | user-0 | [
{
"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"
}
] |
求教一道题，请大佬解答 | user-0 | [
{
"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"
}
] |
C++作业求大牛看一下 实在是不会！！ | user-0 | [
{
"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"
}
] |
萌新发现一个问题，求大佬解答 | user-0 | [
{
"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"
}
] |
运行之后不显示顺序表的元素，只显示这是一个空表 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "调试啊，写代码不调试是不行的，代码难免会有异常，不能总是寻求别人，自己也未必能一眼就瞅出问题所在。你这个，主要问题可能是在 ListInsert() 函数开头的判断 i<1 这个似乎应该是 i<0 因为首个元素的序号为 0，这样就总也无法插入数据了。",
"referer": "user-0"
}
] |
请教一下，这个咋解决， 纯新手，完全不懂 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "大约是你在42行重复定义了函数f",
"referer": "user-0"
}
] |
放在pta上全是段错误 求解 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "段错误是理论上可以单步找到的。不调试，无新知。",
"referer": "user-0"
}
] |
请教一下，这个错在哪里了？ | user-0 | [
{
"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"
}
] |
我的问题我的问题求答 | user-0 | [
{
"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"
}
] |
请问c语言中这个错误是怎么回事啊？ | user-0 | [
{
"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"
}
] |
求答，if else问题 | user-0 | [
{
"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"
}
] |
请问这个转化为c语言代码是什么 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "if的条件也要使用()包起来",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "if/else内只有一条语句，直接把then去掉就可以了，如果有多条语句，使用{}包起来即可",
"referer": "user-0"
}
] |
求教学 感谢大佬帮助！！！ | user-0 | [
{
"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"
}
] |
PTA作业求助，感谢大佬 | user-0 | [
{
"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"
}
] |
如何理解for（i=2;i<=m;i++）中i<=m | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "判断一个正整数n是不是素数，只要从2递增判断到小于等于n的平方根的所有素数都不是n的因数，那么n就是素数。",
"referer": "user-0"
}
] |
求助，如何从标准输入中读取指令 | user-0 | [
{
"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"
}
] |
socket传输效率问题 | user-0 | [
{
"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 < 1024; ++i) { // 调用时 for 循环 1024 次，同时1024次函数调用 read(fd, &_1KBData[i], 1); } ```",
"referer": "user-0"
}
] |
问题。。。。。。。。。。 | user-0 | [
{
"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"
}
] |
请问这个代码应该怎么写 | user-0 | [
{
"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"
}
] |
请问这个代码有啥问题（用的VS2019） | user-0 | [
{
"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"
}
] |
关于vj上Time Limit Exceeded问题的请教 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "题目是啥？",
"referer": "user-0"
}
] |
各位大佬求解，为啥我的自反闭包会出现乱码？？？最后一行的两个？？ | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "这里的else语句，没有使用}吧？else{ int i,j;",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "有的",
"referer": "user-1"
}
] |
C语言嵌入式开发去哪里招人？ | user-0 | [
{
"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"
}
] |
关于指向数组的指针作函数参数的问题 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "因为数组名是地址常量，把它传给变量的时候需要类型兼容。score是float [3][4]类型，兼容于指针类型float (*)[4]*score是float [4]类型，兼容于指针类型float *",
"referer": "user-0"
}
] |
puts(words);编译器指出words未初始化，怎么回事？？求解。 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "换编译器吧",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "我也懵了，感觉没问题的",
"referer": "user-1"
}
] |
C语言标准库＜limits.h＞ | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "下一篇建议楼主写float.h",
"referer": "user-0"
}
] |
如何ros_qt中实现终端快捷指令中用Ctrl+c来结束终端指令 | user-0 | [
{
"cid": "1",
"user": "user-1",
"content": "百度搜“python 捕获ctrl+c”",
"referer": "user-0"
}
] |
求求将下面的C语言转成Java语言 | user-0 | [
{
"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"
}
] |
为什么当a重复输入时就会出现奇怪的东西求解 | user-0 | [
{
"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"
}
] |
求助为啥后面会多一个o | user-0 | [
{
"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"
}
] |
这个错在哪怎么改求解答 | user-0 | [
{
"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"
}
] |
Subsets and Splits