Datasets:

Mxode

/

CSDN-Community-C-Language-3years

like 2

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-0", "content": "我每次测试10秒，然后结果/10来显示数据， 还有计时问题，我直接使用了系统的时间函数，没有事用tsc来计算。 误差也肯定有，但是应该不会影响整体效果吧。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "使用电脑计时有时误差会很大，因为待测程序段的运行会影响电脑时钟。 将待测程序段循环足够多次，手动掐秒表计时可能更准确。", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-1", "content": "typedef char OperandType;//运算类型 你怎么能用char去定义一个answer呢?", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-1", "content": "//if (a=1){ if (a==1){ 供参考～", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "感谢讲解，一针见血", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-1", "content": "感觉可以考虑用getchar()和while循环，每getchar一次i+1,遇到空格时打印i，然后重置i。（我也是新手，共勉）", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-1", "content": "用uart的库", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-1", "content": "参考： https://blog.csdn.net/leixiaohua1020/article/details/40266503 如果看不懂，可以继续看雷神其他的文章", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-0", "content": "不需要了，自己写", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-0", "content": "不需要了，自己写了", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "额，好像忘了放图", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "代码在哪儿呢？", "referer": "user-0" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-1", "content": "可以，但是循环里b不变就会一直满足循环条件，造成死循环", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-1", "content": "这是C++的操作符，可以搜一下C++的引用～和指针功能类似～", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "这是c++,&还可以代表引用", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "cid": "1", "user": "user-0", "content": "😂😂，马虎了", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "函数调用不能再加返回值类型了。去掉main函数里CreateListF前的void，开始我还以为是函数声明呢，仔细一看是函数调用～", "referer": "user-0" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]

[ { "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" } ]