Mxode/CSDN-C_Language-2013_2023 huggingface dataset:
user-0 提问: 一个小白卑微在线求解，关于C语言中的strcpy

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-0
content: 引用 4 楼 @__Chao - L的回复:啥编译器啊？居然有中文提示？ vs2013，装的时候选择中文，就像他们下面说的一样，也不是都是中文，大多数都是英文

user: user-2
content: 引用 4 楼 @__Chao - L 的回复:啥编译器啊？居然有中文提示？  看不出来，大概vs，不过也不是什么提示都是中文，还是看洋文吧

user: user-3
content: 啥编译器啊？居然有中文提示？

user: user-0
content: 引用 2 楼 寻开心的回复:这种带_s的函数， 对于字符，字符串操作的时候，要指定目标地址的长度， 避免内存溢出 嗯，刚才看到，去试了一下成功了，谢谢

user: user-4
content: 这种带_s的函数， 对于字符，字符串操作的时候，要指定目标地址的长度， 避免内存溢出

user: user-4
content: strcpy_s(ss.p.addr, 5, "yang")
user-0 提问: 大神们，写入位置时发生访问冲突

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html
user-0 提问: C语言abc是浮点型 fabs=b*b-4*a*c fabs(a)<=1e-6为什么不写成a=0 

回复:
user: user-1
content: 浮点数和整数不一样，整数在有效范围内，所有数都可以精确的表达 float只能表达6～7位有效数字， double的13～14位有效数字 任何两个浮点数之间的比较，都要考虑到这个问题，不能直接比较 https://blog.csdn.net/happy__888/article/details/280627

user: user-2
content: 你曲解了近似的意思。事实上，精度的损失就像你计算十进制 1 / 3 一样，结果必须用无限位小数表示，然而这对 double 来说是不可能的(况且 double 用的是二进制，所以分母必须是 2 的 n 次方)，所以就有了损失。类似的开方、指数也一样，不过 C 语言的数学函数往往是用特殊的方法实现的，这保证了数学函数必然有误差。总之，这些导致了浮点数不可以直接和某个值比较，而往往是在某个范围内比较。

user: user-0
content: 没有大神解释下吗？
user-0 提问: 浮点类型float与double的什么区别,请教老师指点一下什么情况？

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 不客气，刚开始我也出过这样的问题，书上印刷傻傻分不清，我也是新手，没事到csdn上逛逛挺有益处的

user: user-0
content: 还真是来，我一直认为是%11111f来，谢谢！~ %f和%lf分别是float类型和double类型用于格式化输入输出时对应的格式符号。 其中： float，单精度浮点型，对应%f. double,双精度浮点型，对应%lf. 在用于输出时: float类型可以使用%lf格式，但不会有任何好处。 double类型如果使用了%f格式可能会导致输出错误。 在用于输入时: double 类型使用了%f格式，会导致输入值错误。 float类型使用double类型不仅会导致输入错误，还可能引起程序崩溃。 所以在输入输出时，一定要区分好double和float，而使用对应的格式符号。

user: user-2
content: 你好像把%lf打成了1f
user-0 提问: 01背包为什么会出现这个结果啊有点懵

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html
user-0 提问: 看一下我结构体代码的问题

回复:
user: user-1
content: VS2013中也提供了scanf_s()。在调用时，必须提供一个数字以表明最多读取多少位字符，以便建立缓冲区接收输入信息，防止越界。这就要求程序在设计过程中就明确输入的长度。

user: user-2
content: vs编译器用_s加强安全性,scanf_s("%s", &product1.color,20);需要加上你需要分配的字符串大小

user: user-0
content: 引用 1 楼 ?Victor.?? 的回复:字符串输入不能加&，把12，14行&去掉试试 依然是同样的问题啊

user: user-2
content: 字符串输入不能加&，把12，14行&去掉试试
user-0 提问: 刚开始学C，这两天在学习寻址，留个笔记；

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-0
content: 引用 1 楼 user-2 的回复:笔记写到博客，论坛是讨论问题的 不好意思，刚混论坛~

user: user-2
content: 笔记写到博客，论坛是讨论问题的
user-0 提问: 数据结构的图遍历，打了又打，我也不知道什么鬼，帮忙找错了，看你们找多少给分

回复:
user: user-0
content: 这是遍历的代码，上面的main函数去掉，加上下面这几段： #define MAX 20 bool visited[MAX]; void (*FuncVisit)(Vertex v);  void visit(Vertex V) { 	printf("顶点%d访问完毕\n",V); }  Vertex FirstAdjVertex(MGraph Graph,Vertex V) { 	if(!Graph->adjmlist[V].firstEdge) 		return -1; 	else 		return Graph->adjmlist[V].firstEdge->jvertex; }  Vertex NextAdjVertex(MGraph Graph,Vertex V,Vertex W) { 	EdgeBox* p; 	for(p=Graph->adjmlist[V].firstEdge;p->data!=W;p=p->ilink)	 	{ 		if(!p->ilink) return -1; 	} 	printf("%d",p->data); 	return p->ilink->data; }  void DFS(MGraph Graph,Vertex V) { 	Vertex W; 	visited[V]=true; 	FuncVisit(V); 	for(W=FirstAdjVertex(Graph,V);W>=0;W=NextAdjVertex(Graph,V,W)) 	{ 		if(!visited[W])	DFS(Graph,W); 	} }  void DFSTraverse(MGraph Graph,void (*Visit)(Vertex v)) { 	Vertex V,W; 	FuncVisit=visit; 	for(V=0;V<Graph->vexnum;V++) 		visited[V]=false; 	for(V=0;V<Graph->vexnum;V++) 		if(!visited[V]) DFS(Graph,V); }    int main() { 	MGraph Graph=BuildGraph(); 	DFSTraverse(Graph,visit);  }

user: user-0
content: 图是邻接多重表，遍历是深度优先遍历
user-0 提问: 踩雷游戏

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-0
content: show_map[i][j]='*';这一步

user: user-0
content: 后边那一步已经改成=，但还是运行不了
user-0 提问: 一道C语言问题，关于函数调用问题 

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 1 形参和实参不一样的 void func（float a）；  // 声明     func（3）； // 调用  2 表达式 printf("%d",  1+2 ); // 1+2就是表达式 实参可以是常量、变量、表达式、函数都行  3和4     形参是在调用的时候，程序在栈中给分配的内存， 形参变量的地址就是这个栈空间    实参是在调用之前就存在的，哪怕是函数的返回值或者常量等也都是得到了最后的数值后， 把数值赋值给形参（栈中的变量）    所以他们不能共享内存，是赋值过去的，并不是同一个地址    哪怕是传递指针， 他们传递是指针的值（不是指针指向的数据） ，依然是赋值关系

user: user-3
content: 第一个，实参和形参类型可以不一致，前提是它们的类型可以发生隐式转换。如形参为long，可以传int,short,char的值。 第二个，void f(int a);使用的时候可以是 f(2+4*6)，参数接受的是一个值，这个值可以有表达式结算所得。 第三个，C++的引用就是实参与形参共用内存，但是C没有这种用法。 第四个，调用函数是程序只会为形参分配内存空间，你传递的实参的内存与函数无关。 以上为个人总结。
user-0 提问: 新手学编程，大佬们帮忙解答一下这个题

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html
user-0 提问: 大一新生，遇到了点问题。

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 还差一点，整数字面量都被编译为整形 即 temp = i/10 先以整形计算i/10为0，再把0转成double 赋给temp 但如果把 i 改成double，i/10就会把10转成double计算得结果0.5
user-0 提问: 一道C语言问题，关于函数调用问题

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 调用函数时，实参可以是表达式是对的，  调用函数时，程序会为实参和形参分配内存空间    这个也应该是对的

user: user-3
content: 调用函数的时候，实参和形参类型可以不一致        形参：int类型 传递unsigned int；  或者int类型，传递char给它； 都可以    表达式肯定是对的  后面两个不对
user-0 提问: 函数返回值问题

回复:
user: user-1
content: char *a1 = a 就是用a1记录a原来指向的地址 while里有a++，a指向的地址变了 返回a1就等于返回a原来指向的地址，因为不能返回a了，a指向的地址已经变了

user: user-2
content: a1和a是一样的，指向的地址是一样的

user: user-0
content: 引用 2 楼 qybao 的回复:char *a1 = a 就是用a1记录a原来指向的地址 while里有a++，a指向的地址变了 返回a1就等于返回a原来指向的地址，因为不能返回a了，a指向的地址已经变了懂了  谢谢
user-0 提问: 数组的使用

回复:
user: user-1
content: scanf(“%f”, &floatI[intI]); 取地址&

user: user-2
content: 除了1楼所说的问题。  1.计算最大、最小和平均，1次遍历就完成了   zuigao = floatI[0]; zuidi = floatI[0]; pingjun = floatI[0]; for(intI = 1; intI < 10;intI++) {      if(zuigao < floatI[intI]）      {            zuigao = floatI[intI];       }       if(zuidi > floatI[intI])       {            zuidi = floatI[intI];       }       pingjun += float[intI]; } pingjun /= 10;  2. 变量命名真是别扭

user: user-3
content: 输入写错了，取地址符
user-0 提问: 使用C语言用GTK写了一个linux下的数独程序

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html
user-0 提问: 一道关于数组指针和指针数组的疑问求解

回复:
user: user-1
content: 纠正一下，以大端模式存储，应该是地址从高到低存储，所以1003存0x05，1002存0x06，1001存0x07，1000存0x08，所以答案是0x08，D

user: user-1
content: 指针类型转换以及指针类型的内存信息储存的知识点 指针指向一维数组，指针可以像数组一样操作，也就是test_p[1]和*(test_p+1)是一样的，前者是数组的方式，后者是指针的方式 一个int占4个字节，一个char占1个字节，所以char数组原来的内存空间（8个字节），只够存储2个int，前一个int是前4个字节，即0x01到0x04，第二个int是后4个字节0x05到0x08，test_p[1]就是第二个int，所以1000地址存的是0x05，1001存0x06，1002存0x07，1003存0x08，所以答案应该是0x05
user-0 提问: C语言新手在指针方面遇到的疑惑

回复:
user: user-1
content: 简单的说，b[10]={}这样的方式相当于给下标为10数组元素地址赋值（声明数组时除外），很显然，左边是整形，右边是数组列表，类型不匹配不能赋值。如果b是二维数组，那么b[10]就是下标为10的一维数组，那么就可以赋值。

user: user-2
content: 初始化是在定义的时候初始化，初始化才能一股脑赋值，之后的赋值必须按正常赋值规则来赋值，你的get函数里面b的赋值是正常赋值，所以不能像你期望的那样赋值

user: user-3
content: 你可以这样嘛 void fpp(int* b) { 	struct pp{ int a[10]; }; 	*(pp*)b = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; }

user: user-4
content: 我感觉定义函数时int *get(int *p,int *b,int m)时相当于已经定义了数组，而b[10]={0,0,0.......}相当于赋值，众所周知，数组赋值需要循环，而b[10]={0,0,0.......}相当于给b[10]这一个元素付了10个值，所以不对，不知道这么理解对不对

user: user-5
content: { 0, 0, ... } 这个叫初始化列表，只有在你声明一个对象的时候才能用，例如 int a[] = { 0, 0, 0 }; 其他地方用了会报语法错误。这里用循环的方法或者 memset 清 0 即可。
user-0 提问: C语言释放内存空间

回复:
user: user-0
content: 引用 9 楼 真相重于对错的回复:就算自己设计内存池，我觉得也不应该提供这个功能。建议百度一下动态内存分配算法。 好的，感谢帮助（又要十个字）

user: user-0
content: 引用 8 楼 真相重于对错的回复:另外你可能认为这样做会更省内存。 但实际上并不如此。前面我已经说malloc返回的是一段连续的内存。你应该知道内存碎片的概念。例如你malloc了100k的内存，如果系统中只剩下两块80k，你也会malloc失败。 那么如果允许从中间释放，原来的连续的内存，将非常容易变成碎片。 这倒是，碎片和占着茅坑不拉屎说不上一定哪个好，如果malloc多次，如果他们正好连续，我要free掉一个岂不也是中断了，如果不是连续的，那本身就那样了，从这方面来说，我不过相当于malloc了三段连续的小空间，抽走中间的罢了，我还是想说如果真有这么一个函数，他只是一个工具，能起多大作用，还是得看人怎么用了，如果开了一个大空间却因为一点点数据无法释放显然是得不偿失的，当然这种情况下把剩下的一部分拷贝，释放掉原空间也可以，但这样很可能会波及到前面用的到部分指针，当然这也可以人工避免。所以说了这么久不过是想捡个现成的工具而已，用不用怎么用，见仁见智而已

user: user-1
content: 就算自己设计内存池，我觉得也不应该提供这个功能。建议百度一下动态内存分配算法。

user: user-1
content: 另外你可能认为这样做会更省内存。 但实际上并不如此。前面我已经说malloc返回的是一段连续的内存。你应该知道内存碎片的概念。例如你malloc了100k的内存，如果系统中只剩下两块80k，你也会malloc失败。 那么如果允许从中间释放，原来的连续的内存，将非常容易变成碎片。

user: user-0
content: 引用 6 楼 真相重于对错的回复:[quote=引用 5 楼 與蘤舊縐 的回复:] [quote=引用 4 楼 真相重于对错的回复:]想一下，为什么要这么做，这么做的目的是什么？ 如果这么做可以，带来的后果是什么？ 后果不后果得看这函数具体的限制，还得看你怎么用了，如果足够信任程序员的话就可以给这个权限[/quote] 这不是信不信任程序员的问题。而是系统如何设计的问题。malloc是返回一段内存的首地址，free的参数是一段地址的首地址。那么可以推论堆内存的管理应该是一个表，表的每一项是标记已经用的内存。包括它的地址和长度，如果允许把一段已开的内存中间某段释放掉，那么就要修改整个的表，效率会怎样？而且如果删除中间一段，本来malloc/free只要记住首地址即可，现在还要记住下一段的地址。否则最后无法完全释放。[/quote] 我是觉得还是安全方面的问题比较麻烦，具体实现虽然不知如何才能高效，但至少不必记这么多，或者说记住空间首地址和长度即可，如果搜索起来麻烦，大可设置形参为原地址加起始位置，虽然在程序的不同位置可能无法获取到原指针，但既然是要指定删除的，自然知道起始位置到原指针的距离，原指针可能，如果中断那就是一段变两段，多一组数据，也不至于改了整个表吧，而且一开始判断该地址是否存在应当已经找到该内存在表中的位置不管需不需要再重找，都容易得多，再者要实现这个效果不一定非得改底层，就像一楼说的搞个内存池也行，不过一般的内存池显然是不好使的，最后呢这不过是扩展一个功能，用不用程序员说了算，考虑空间与时间，在必要的情况下未必不可拿时间换空间

user: user-1
content: 引用 5 楼 與蘤舊縐 的回复:[quote=引用 4 楼 真相重于对错的回复:]想一下，为什么要这么做，这么做的目的是什么？ 如果这么做可以，带来的后果是什么？ 后果不后果得看这函数具体的限制，还得看你怎么用了，如果足够信任程序员的话就可以给这个权限[/quote] 这不是信不信任程序员的问题。而是系统如何设计的问题。malloc是返回一段内存的首地址，free的参数是一段地址的首地址。那么可以推论堆内存的管理应该是一个表，表的每一项是标记已经用的内存。包括它的地址和长度，如果允许把一段已开的内存中间某段释放掉，那么就要修改整个的表，效率会怎样？而且如果删除中间一段，本来malloc/free只要记住首地址即可，现在还要记住下一段的地址。否则最后无法完全释放。

user: user-0
content: 引用 4 楼 真相重于对错的回复:想一下，为什么要这么做，这么做的目的是什么？ 如果这么做可以，带来的后果是什么？ 后果不后果得看这函数具体的限制，还得看你怎么用了，如果足够信任程序员的话就可以给这个权限

user: user-1
content: 想一下，为什么要这么做，这么做的目的是什么？ 如果这么做可以，带来的后果是什么？

user: user-0
content: 引用 1 楼 user-2的回复:简单来说：洗洗睡吧。 具体来说：操作系统本身就对用户态内存分配有限制，所有内存页都是操作系统管的，用户态管不着。再加上 C 运行库可能对从系统那获得的内存再做其它管理，最后指针才到用户代码那里，用户代码真的没什么好做的。(不过 C 提供了 realloc，可能可以满足你的部分需求，实在不行就写个内存池自娱自乐好了) 注意/主要   这APP怎么撤不回来

user: user-0
content: 引用 1 楼 user-2的回复:简单来说：洗洗睡吧。 具体来说：操作系统本身就对用户态内存分配有限制，所有内存页都是操作系统管的，用户态管不着。再加上 C 运行库可能对从系统那获得的内存再做其它管理，最后指针才到用户代码那里，用户代码真的没什么好做的。(不过 C 提供了 realloc，可能可以满足你的部分需求，实在不行就写个内存池自娱自乐好了) 注意是想用来释放掉一个指向已申请内存中段的指针指向的之后的内存，realloc也是不行的，自己写是没问题，只是用起来麻烦，图个现成的，看来是没有了

user: user-2
content: 简单来说：洗洗睡吧。 具体来说：操作系统本身就对用户态内存分配有限制，所有内存页都是操作系统管的，用户态管不着。再加上 C 运行库可能对从系统那获得的内存再做其它管理，最后指针才到用户代码那里，用户代码真的没什么好做的。(不过 C 提供了 realloc，可能可以满足你的部分需求，实在不行就写个内存池自娱自乐好了)
user-0 提问: 新手小白，求大神帮忙解释一下下面两个二级c程序！感谢！

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-0
content: 引用 3 楼 user-2的回复:花括号就相当于作用域，在同一对花括号里是同一级别。if后面跟花括号，是因为满足if就会执行花括号里的语句，如果没有花括号，只执行if后面第一条语句。 对于布尔类型来说，0是false，0以外是true，所以if(0)就是if(false)，所以这个if永远不会满足，if(1)就是if(true)，这个条件永远满足 这种都是最基础的知识，随便找本书看看就好了 好的，谢谢您的详细回答

user: user-2
content: 花括号就相当于作用域，在同一对花括号里是同一级别。if后面跟花括号，是因为满足if就会执行花括号里的语句，如果没有花括号，只执行if后面第一条语句。 对于布尔类型来说，0是false，0以外是true，所以if(0)就是if(false)，所以这个if永远不会满足，if(1)就是if(true)，这个条件永远满足 这种都是最基础的知识，随便找本书看看就好了

user: user-0
content: 引用 1 楼 user-2的回复:第一个程序a=5 第二个程序a=3 else总是和自己同一级别的最近的if匹配 第一个程序if0和else同一级别，也和else最近，所以是一对 第二个程序，if0在if1里，else不在if1里，所以if0和else不是同一级别，和else同一级别的只有if1，所以它两是一对 好的👌🏻，谢谢～不太懂if后面括号里的零和一是什么呀？

user: user-2
content: 第一个程序a=5 第二个程序a=3 else总是和自己同一级别的最近的if匹配 第一个程序if0和else同一级别，也和else最近，所以是一对 第二个程序，if0在if1里，else不在if1里，所以if0和else不是同一级别，和else同一级别的只有if1，所以它两是一对
user-0 提问: C语言中指针的提出解决了什么问题

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 让用户可以直观的操作内存

user: user-3
content: 指针是c中最具有特色的东西了， 只有和其他语言对比着才能体会出来它的不同  有了指针，让c费产的灵活，但是也很危险  没法细说，太多了， 应用当中逐步体会吧

user: user-4
content: 仅供参考： http://c-faq.com/ptrs/goodfor.html
user-0 提问: 两字符串中的最大公共字符串个数及公共字符串

回复:
user: user-1
content: 引用 4 楼 m0_46336373 的回复:[quote=引用 3 楼 與蘤舊縐的回复:][quote=引用 2 楼 m0_46336373 的回复:] [quote=引用 1 楼 與蘤舊縐的回复:]abcdef  defgab  公共字符串无非就是一样的字符子串，比如def和ab 那最大公共字符串是啥啊[/quote]  长度最大[/quote] 比如你写的那两串字符串，最大公共字符串是哪个[/quote]  def

user: user-0
content: 引用 3 楼 與蘤舊縐的回复:[quote=引用 2 楼 m0_46336373 的回复:] [quote=引用 1 楼 與蘤舊縐的回复:]abcdef  defgab  公共字符串无非就是一样的字符子串，比如def和ab 那最大公共字符串是啥啊[/quote]  长度最大[/quote] 比如你写的那两串字符串，最大公共字符串是哪个

user: user-0
content: 引用 5 楼 與蘤舊縐的回复:[quote=引用 4 楼 m0_46336373 的回复:] [quote=引用 3 楼 與蘤舊縐的回复:][quote=引用 2 楼 m0_46336373 的回复:] [quote=引用 1 楼 與蘤舊縐的回复:]abcdef  defgab  公共字符串无非就是一样的字符子串，比如def和ab 那最大公共字符串是啥啊[/quote]  长度最大[/quote] 比如你写的那两串字符串，最大公共字符串是哪个[/quote]  def[/quote] 哦哦懂了，谢谢哈

user: user-1
content: 引用 2 楼 m0_46336373 的回复:[quote=引用 1 楼 與蘤舊縐的回复:]abcdef  defgab  公共字符串无非就是一样的字符子串，比如def和ab 那最大公共字符串是啥啊[/quote]  长度最大

user: user-0
content: 引用 1 楼 與蘤舊縐的回复:abcdef  defgab  公共字符串无非就是一样的字符子串，比如def和ab 那最大公共字符串是啥啊

user: user-1
content: abcdef  defgab  公共字符串无非就是一样的字符子串，比如def和ab
user-0 提问: C语言数组

回复:
user: user-1
content: 这只不过是数组的特性，事实上你用例如 a == &a 之类的式子，是无法正常编译通过的，这证明了其实这 4 个的类型以及意义是不同的。

user: user-2
content: 编译期把这些变量都编译成一个偏移地址。变量只是代码层面的，机器码里没有变量，只有地址。
user-0 提问: 请教 (char)k  和 (char *)k 的区别

回复:
user: user-1
content: (char)k是把k转成char类型 (char*)k是把k转成char指针，指针就是个地址，地址其实也就是个无符号整形（对于32位机指针类型占用4个字节，和无符号整形一样）
user-0 提问: 指针变量的运算

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 引用 7 楼 lin5161678 的回复:引用 6 楼 gouyanfen 的回复:[quote=引用 5 楼 lin5161678 的回复:] [quote=引用 1 楼 gouyanfen 的回复:] 因为你的p和q定义的是int *，你定义为void *试试，或者定义为byte *试下。void* 不能相减 void *可以先转为uint直接用uint相减，指针就是个地址的值有什么不能减的。[/quote]你说得很清楚 那是uint相减 void* 是一个地址的值  是一个很不严谨的说法 并且和讨论的问题 没有关系 C里面 减法运算对操作数的类型有规定 这些规定里面void* 这个类型不能相减[/quote] 你严格按照规定操作没有什么问题,void *这个定义实际应用中大部分场景就是为了方便传递各种类型指针的通用类型，实际应用中最后基本都强转为了其它类型。习惯问题，我是随心所欲型，知道自己在做什么就行。当然为你的严谨点赞，这个只是我的个人习惯。

user: user-3
content: 这里指针的加减是以数组中元素为单位进行加减的，而不是以字切为单位进行加减的。

user: user-4
content: 引用 9 楼 gouyanfen 的回复: 实际上 你和我的操作都是一样的 转换为uint 相减 或者转换为 char* 相减 这里的回复主要是针对你回复中讲的 类型定义为void* 相减  这对新手来说 有些误导

user: user-5
content: 指针相减的结果是整数， 但是这个整数的意思，并不是差几个BYTE， 而是差几个指针指向的数据的类型  printf指定%p类型输你的指针地址，你就能看到，指针地址具体是多少了， 他们之间的差距就BYTE

user: user-4
content: 引用 6 楼 gouyanfen 的回复:引用 5 楼 lin5161678 的回复:[quote=引用 1 楼 gouyanfen 的回复:] 因为你的p和q定义的是int *，你定义为void *试试，或者定义为byte *试下。void* 不能相减 void *可以先转为uint直接用uint相减，指针就是个地址的值有什么不能减的。[/quote]你说得很清楚 那是uint相减 void* 是一个地址的值  是一个很不严谨的说法 并且和讨论的问题 没有关系 C里面 减法运算对操作数的类型有规定 这些规定里面void* 这个类型不能相减

user: user-2
content: 引用 5 楼 lin5161678 的回复:引用 1 楼 gouyanfen 的回复:因为你的p和q定义的是int *，你定义为void *试试，或者定义为byte *试下。void* 不能相减 void *可以先转为uint直接用uint相减，指针就是个地址的值有什么不能减的。

user: user-4
content: 引用 1 楼 gouyanfen 的回复:因为你的p和q定义的是int *，你定义为void *试试，或者定义为byte *试下。void* 不能相减

user: user-6
content: 你如果想知道移动了多少个字节，可以转成int后再加减 即 printf(“%d”, (int)q -(int)p);

user: user-7
content: 指针减法是基于数组的下标运算建立的，指向同一个数组的不同元素的指针相减的结果等价于下标差。因而讨论单个元素的大小等是无意义的(除非你要理解汇编)。

user: user-6
content: 你反过来思考就明白了 p = &a[1]; q = p + 2; 这时你觉得q指向数组的哪个元素？是不是指向&a[3]? 也就是指针的加减编译器会自动根据指针的类型来计算，这样能让用户不用关注每种类型占用的字节大小，只是单纯的考虑移动几个单元就可以了，否者用户做指针加减还要考虑每种类型占用的字节（每个系统可能占用的字节也不一样），这样会把编程复杂化，而且也不方便移植。

user: user-2
content: 因为你的p和q定义的是int *，你定义为void *试试，或者定义为byte *试下。
user-0 提问: 在C程序中读取秘密内容的最佳实践

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 引用 3 楼 qybao 的回复:我有一种想法，就是把密钥写成一个返回值的函数，把该函数编译为机器码，然后再你的解密函数里直接调用机器码获得密钥再解密。 机器码调用的例子，可以参考以下帖子 https://blog.csdn.net/bdss58/article/details/83387028 我觉得这样不太好，因为这种代码是需要调用系统 API 获取执行权限的，逆向的时候都是重点关照对象，一旦 API 被调试器 hook，很容易露馅，导致被破解。

user: user-3
content: 我有一种想法，就是把密钥写成一个返回值的函数，把该函数编译为机器码，然后再你的解密函数里直接调用机器码获得密钥再解密。 机器码调用的例子，可以参考以下帖子 https://blog.csdn.net/bdss58/article/details/83387028

user: user-4
content: 引用 楼主 zhongxiangchen 的回复:我有一个程序运行时需要从文件中读取一些保密的内容，如何对这些保密的内容进行加密以及如果在应用程序中安全的存储这些密钥，有什么最佳实践可供参考吗？ 由于保密内容可能较大因此我理解应该使用AES加密保密内容，问题进而演变成如何安全的存储AES密钥。我计划使用RSA私钥加密AES密钥，使用硬编码在应用程序中的RSA公钥来解密AES密钥的密文。这种方式违反了公钥加密私钥解密的原则，但是如果硬编码私钥这会导致更大的问题。 我知道在应用程序中存储密钥没有绝对的安全但总比什么都不做的好，也并不是每个人都有逆向的能力。我了解到还有加密狗这种硬件的方式但是这需要给应用程序额外配置一个硬件并不总是那么方便。 求各位大神支招 从逆向的角度说说你的问题， 1.你的密文存在文件中，那必然会读到到内存中处理，就有两个破解点，一个readfile,第二个读取之后在密文上下内存访问断点，直接就可以找到你对密文处理的部分，进而反推到你的密文来源，并不是什么难事。 这方面你有两个方面处理，第一密文添加混淆内容，第二个逻辑分散处理 2.你用AES算法，那么基本上常用的库，比如openssl里面的加密部分，或者crpyto这些加密之后的汇编码也容易识别的，直接在库的算法入口断点基本就可以确定算法，再逆推参数来源。应对办法：1.用静态链接,2.增加花指令 3.善于利用异常处理改变正常的流程,比如自己制造异常，try{假的加密解密}catch{正常的加密解密部分} 3.就是加壳增加逆向难度，一般的壳就不用试了，只能劝退初学者 4.如果你的程序是C/S结构，是的话办法还可以多点，如果是单机的就只是是技巧性的. 没有绝对安全的加密，只是看逆向成本是否大于收益。

user: user-5
content: 两个问题：  1 密钥的加密存储， 这个弄个大一点儿的数据区， 把密钥简单的可逆加密后， 分散开存储到一堆乱码当中就好了    甚至存储到多个不同文件里面去    密钥的生成，可以根据一些硬件信息来，确保机器码或者用户信息和密钥有唯一的匹配    这种加密算法有很多， 看那类适合用哪一类就好了。核心问题还是生成一个唯一的用户ID，和一个唯一对应的密钥    把密钥弄的长长的， 即便给予明文也不容易推算出关系，伪造密钥难度还是比较大的 2 密钥读取后解密的算法才是重点， 算法被破解加密的手段就统统失效    简单  if （ 验证成功 ） 执行正常代码。else。异常处理；   这种写法，会直接毁掉前面所有的密钥生成成果。    这个部分的解决方案就是把密钥的解密过程分散到多个不同的先后执行的函数当中，和正常的应用代码混合起来    每段代码解密密钥的不同部分， 防止被跟踪可以限定代码的执行时长， 甚至可以用汇编语言实现逆指令流防止被debug    可以检测调用程序的父进程是系统还是debug工具    这里花费的精力越多，破解越难， 响应的代码的维护也越难    因为正常业务的代码也要不断的升级改造， 他们改完了，你在源码的基础上去嵌入自己的加密源码    那种直接在不影响业务正常编码程序上面加壳的方法是可以简化工作难度，但是也降低了破解的难度    让密钥解码出来的数据成为程序正常执行所需的一些重要数据的初始化变量， 财务数据运算的一些常量也未尝不是一个好办法    没有明显的if else 和函数调用判断， 但是它错了， 业务执行就各种意外发生了    从这个角度去想办法，比明文和密钥之间的那些有限算法上，会灵活很多

user: user-0
content: 引用 1 楼 apkipa1 的回复:只要你最终要把加密内容明文保存到内存里，就永远不能防止有心人进行数据窃取。我个人认为，如果你上了(多层)加密，而且保持解密、数据的使用不太明显，那么应该已经能劝退许多不想花太大功夫的人了。(然后再给程序上个壳，效果可能更好)  我也查了很多资料，密钥硬编码到程序中是没有办法保证安全的。这么做能挡住大部分的人其实就已经足够。如果要绝对安全那么要付出的成本就太大了。我之前没做过这样的事情也不知道这样是不是正常的做法。

user: user-2
content: 只要你最终要把加密内容明文保存到内存里，就永远不能防止有心人进行数据窃取。我个人认为，如果你上了(多层)加密，而且保持解密、数据的使用不太明显，那么应该已经能劝退许多不想花太大功夫的人了。(然后再给程序上个壳，效果可能更好)
user-0 提问: C语言新手再次前来求教

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 怀疑是逗号表达式的问题吧，不同的编译器可以执行顺序不一样（从左到右或从右到左）。改成分号试试。

user: user-3
content: 你先分开了赋值，看看问题出在哪里？
user-0 提问: 删除字符串中指定字符

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 控制台在等待你输入要查找的字符吧

user: user-3
content: 是不是delchar写错了，为什么要for循环char值？
user-0 提问: 哪位大佬逐行逐句地解释一下这段代码，我给他磕头了！！

回复:
user: user-1
content: #include <stdio.h> #include <stdlib.h>           int main() { //声明变量     double *ptd;//这是一个双精度小数类型的指针     int max;     int number;     int i = 0;          puts("What is the maximum number of type double entries?");//输出字符串     if (scanf("%d", &max) != 1)//输入数字到max变量     {         puts("Number not correctly entered -- bye.");         exit(EXIT_FAILURE);//退出，和return在main里面同样     }     ptd = (double *) malloc(max * sizeof(double));//分配内存     if (ptd == NULL)     {         puts("Memory allocation failed. Goodbye.");         exit(EXIT_FAILURE);     }          puts("Enter the values (q to quit):");     while (i<max && scanf("%lf", &ptd[i]) == 1)//一直输入         ++i;     printf("Here are your %d entries:\n", number = i);     for (i=0; i<number; i++)     {         printf("%7.2f ", ptd[i]);//输出         if (i%7==6)//i取余7             putchar('\n');//输出单个字符     }     if (i%7 != 0)         putchar('\n');     puts("Done.");     free(ptd);//释放变量占有的内存          return 0; }

user: user-2
content: 输入一个数max ， scanf返回1才表示这个数被正确获得到      if (scanf("%d", &max) != 1) 建立一个动态数组，大小就是max        ptd = (double *) malloc(max * sizeof(double)); 输入max个浮点数       while (i<max && scanf("%lf", &ptd[i]) == 1)    ++i; 七个一行的输出， i%7 从0到6 ， 6的时候表示已经输出了7个，所以在此输出个回车好换行        if (i%7==6)   putchar('\n'); 最后一行不满七个也换行     if (i%7 != 0)         putchar('\n');  释放内存      free(ptd);
user-0 提问: 麻烦一些大神教我这道题。

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 对于常用的编译器来说，整数的字面量，会被编译为整形。打印以下结果就知道了。 double d1 = 1/5; //1和5都被编译为整形，所以结果是0 double d2 = 1.0/5; //因为1.0是浮点型，所以5也被转换为浮点型，所以结果是0.2 printf("%f, %f\n", d1, d2);

user: user-3
content: 5是个整数，打错了

user: user-3
content: 实型常量又称实数或浮点数。在C语言中可以用单精度型和双精度型两种形式表示实型常量，分别用类型名float和double进行定义  .5其实就是0.5，这在C++和C以及其他一些语言，比如python中都是支持的  5显然是个实数，当然你可能会说可以给一个float类型的变量赋值为5，实际上这里是有隐式类型转换的
user-0 提问: 一个简单入门C语言

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 建议在ubuntu下使用code blocks进行开发。

user: user-3
content: 看不到具体情况，黔驴技穷了  要不换个编译器吧，dev、vs、CLion随便选

user: user-0
content: 引用 5 楼 與蘤舊縐的回复:这什么软件，我觉得肯定是没编译成功，程序是没问题的，洋文也没这么菜，他说的是没有生成，我想你总不会没有保存文件吧，这样的话也是服了你了 。。。codeblocks

user: user-3
content: 这什么软件，我觉得肯定是没编译成功，程序是没问题的，洋文也没这么菜，他说的是没有生成，我想你总不会没有保存文件吧，这样的话也是服了你了

user: user-0
content: 引用 3 楼 與蘤舊縐的回复:那你点"是"是什么反应 点了是之后还是有点是 否 和 取消这个窗口

user: user-3
content: 那你点"是"是什么反应

user: user-0
content: 引用 1 楼 與蘤舊縐的回复:没有问题，只是你还没有编译而已，先编译再运行 编译了凑够十个字凑够十个字

user: user-3
content: 没有问题，只是你还没有编译而已，先编译再运行

user: user-4
content: 程序对着呢。运行出来了
user-0 提问: 子函数的编程

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 其实，string.h中就有与之类似的函数：strcat()或strncat()  给出strcat()的实现方法（ my_strcat() ）：  char *my_strcat(char *dest, const char *src){ 	char				*str = dest; 	while(*dest) 		dest++; 	while(*dest++ = *src++); 	return str; }
user-0 提问: 有关排序的一小部分优化

回复:
user: user-0
content: 引用 8 楼 寻开心的回复:这个是二路归并，求的是速度啊 那个释放内存麻烦不到哪儿去了， 结果出来后memmove / memcpy都可以，那个速度相比于算法来说不占时间啊 搞复杂了，效率反而下来，就丧失了归并算法的本意了是不是 不想耗内存，冒个泡就好了，  执行效率和 “麻烦” 你选什么呢？ 找个平衡而已，各种操作都试一下，没事干，就折腾呗

user: user-1
content: 这个是二路归并，求的是速度啊 那个释放内存麻烦不到哪儿去了， 结果出来后memmove / memcpy都可以，那个速度相比于算法来说不占时间啊 搞复杂了，效率反而下来，就丧失了归并算法的本意了是不是 不想耗内存，冒个泡就好了，  执行效率和 “麻烦” 你选什么呢？

user: user-0
content: 引用 5 楼 user-2的回复:你要是觉得移动数组可能耗时，可以改成内存拷贝试试 不用嵌套循环，两个数组一起循环也可以，也就是上面的变形 for(int i=0,j=0; i<len1+len2&&j<len2;) {     if (*(part1+i) > *(part2+j)) {         int t = *(part2+j);         memcpy(part1+i+1, part1+i, len1-i+j); //用内存拷贝的方式往后挪数组元素         j++;     }     i++; } 还有这种招数明天试试

user: user-2
content: 上面的j++前漏了*(part1+i) = t;

user: user-2
content: 你要是觉得移动数组可能耗时，可以改成内存拷贝试试 不用嵌套循环，两个数组一起循环也可以，也就是上面的变形 for(int i=0,j=0; i<len1+len2&&j<len2;) {     if (*(part1+i) > *(part2+j)) {         int t = *(part2+j);         memcpy(part1+i+1, part1+i, len1-i+j); //用内存拷贝的方式往后挪数组元素         j++;     }     i++; }

user: user-0
content: 引用 3 楼 user-2的回复:因为两个都是排好序的，所以在第一个数组的基础上插入第二个数组即可 for (int i=0,j=0; i<len2; i++) //第二个数组循环     for (; j<len1+len2; j++) //第一个数组从上次找到的插入位置循环（也就是j不变）         if (*(part1+j) > *(part2+i)) { //和第一个数组比较，找到插入位置             int t = *(part2+i);             for (int k=len1+len2-1-i; k>j; k--)  //第一个数组往后挪                 *(part1+k) = *(part1+k-1);              *(part1+j) = t; //插入位置变为第二个数组的元素             break;//第二个数组插入完后继续下一个元素         } 插排就是后移数组这很难受，本来想优化归并的，这一堆递归下来这么多插排不太确定和上面的比哪个效率高点，现在看起来想压缩空间有点压过头了，毕竟开一个放一个

user: user-2
content: 因为两个都是排好序的，所以在第一个数组的基础上插入第二个数组即可 for (int i=0,j=0; i<len2; i++) //第二个数组循环     for (; j<len1+len2; j++) //第一个数组从上次找到的插入位置循环（也就是j不变）         if (*(part1+j) > *(part2+i)) { //和第一个数组比较，找到插入位置             int t = *(part2+i);             for (int k=len1+len2-1-i; k>j; k--)  //第一个数组往后挪                 *(part1+k) = *(part1+k-1);              *(part1+j) = t; //插入位置变为第二个数组的元素             break;//第二个数组插入完后继续下一个元素         }

user: user-0
content: 引用 1 楼 user-2 的回复:既然数组内存连续，直接看作一个数组就好了。第一个数组下标越界就会到达第二个数组，所以直接用下标从第一数组的开始循环到两个数组的长度和即可。  这点我当然知道，本来就是一个数组拆分出来的  如果直接把两个数组当一个排序，那我给他拆出来干嘛呢，这就更慢了  我倒是想不依靠第三个数组，直接按那种方式排，但是暂时想到的办法很混乱，程序复杂度飙升

user: user-2
content: 既然数组内存连续，直接看作一个数组就好了。第一个数组下标越界就会到达第二个数组，所以直接用下标从第一数组的开始循环到两个数组的长度和即可。
user-0 提问: C语言实验报告怎么写？

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 实话实说呗，只要你的程序足以让老师满意
user-0 提问: PAT A1051有人知道这个段错误是为什么吗

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-0
content: 已经找到原因了，st.top() == str[checkPointer] && !st.empty()这句调个顺序就行了

user: user-0
content: 感谢回复。我试了改大，还是没用

user: user-2
content: 数组定义的小了
user-0 提问: 绝对值排序

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 输入的话，用getchar读入一行字符，直到遇到换行符停止就可以了 排序的话随便冒泡什么都可以 LZ自己先写吧，有错再把代码贴出来

user: user-3
content: 弄个结构体就行

user: user-4
content: http://www.360doc.com/content/19/0422/17/53299008_830615958.shtml
user-0 提问: 数组赋值

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 可以是可以，但浪费空间，也不符合正常的使用原则，更容易出错，最好不要这么做 加一个={0}就能对不过是将数组初始化了，你的程序中多处用了a[i]与0的关系式，可能是由于未赋初值导致的一些错误，具体未细看
user-0 提问: c语言编程题

回复:
user: user-0
content: 引用 3 楼 user-1的回复:[quote=引用 2 楼 狠狠摔了一跤 的回复:] 我输入的就是整型，但它显示出来就是这些英文 看错了，我还以为你是从文件读取信息 你这个相当于字符流写文件，所以整形都被转成字符了，像这种结构体写文件一般都用二进制，读取也用二进制 fp=fopen("d://stud.txt", "wb") //用二进制写文件  如果非要用文本来写文件，可以用个字符数组buf把结构体都转成字符串后再写 char buf[100] sprintf(buf, "%s %s %s %d", stu[i].num, stu[i].name, stu[i].sex, stu[i].ywscore); //转成字符串再写文本文件 fwrite(buf, sizeof(char)*strlen(buf), 1, fp); [/quote] 我试一下。谢谢你啦.

user: user-1
content: 引用 2 楼 狠狠摔了一跤 的回复:我输入的就是整型，但它显示出来就是这些英文 看错了，我还以为你是从文件读取信息 你这个相当于字符流写文件，所以整形都被转成字符了，像这种结构体写文件一般都用二进制，读取也用二进制 fp=fopen("d://stud.txt", "wb") //用二进制写文件  如果非要用文本来写文件，可以用个字符数组buf把结构体都转成字符串后再写 char buf[100] sprintf(buf, "%s %s %s %d", stu[i].num, stu[i].name, stu[i].sex, stu[i].ywscore); //转成字符串再写文本文件 fwrite(buf, sizeof(char)*strlen(buf), 1, fp);

user: user-0
content: 引用 1 楼 user-1的回复:语文成绩输入格式是整形，但你的文件内容是d，y，y，o，n，跟输入格式的类型不一样，你把这些改成数字试试 我输入的就是整型，但它显示出来就是这些英文

user: user-1
content: 语文成绩输入格式是整形，但你的文件内容是d，y，y，o，n，跟输入格式的类型不一样，你把这些改成数字试试
user-0 提问: malloc函数开辟空间的意义

回复:
user: user-0
content: 懂了懂了懂了懂了谢谢大家

user: user-1
content: malloc是在堆上申请内存空间， 需要需要分配足够的长度 malloc（4）也就4个字节，后面的赋值和操作都越界了。

user: user-2
content: 你这个只是申请了4个字节的内存空间，i指向了这块内存空间，程序没错，是因为这块内存空间后面的内存没有被其他程序占用，所以程序侥幸能运行 正常做法都是用多少内存就申请多少内存 i = (int*)malloc(10*sizeof(int)); //10个int大小的空间

user: user-3
content: 之所以排在后面，是因为你使用的赋值是i[j]，但如果这部分空间被别的进程占用，那么程序就进行不下去了，所以为了安全考虑，必须开辟足够大的空间

user: user-3
content: 输出是个随机数只是侥幸而已，你只开4个int的空间，只能存4个，其他的6个不过是正好排在你开辟的空间的后面，i[j]其实是*(i+j),正好给你取到了，但这样无疑是不安全的
user-0 提问: 建立单向链表
输入打乱顺序
输出按从小到大的顺序

回复:
user: user-1
content: 就冒泡吧 #include <stdio.h> #include <stdlib.h> #include <string.h>   typedef struct ListType { int n; struct ListType * next; } List;  // 创建一个带有头节点的单项链表 List * CreateList(int n, int * v) {     if (n<=0 ) return NULL;     List * pHead = (List*) malloc(sizeof(List));     List *p = pHead;     pHead->n = n;  // 头节点的n，用来记录链表的长度了     while (n--) {         p->next = (List*) malloc(sizeof(List));         p->next->n = *v++;         p = p->next;     };     p->next = NULL;     return pHead; };  void PrintList(List * pList) {     List * p = pList;     while (p->next) {         printf("%d ", p->next->n);         p = p->next;     }     printf("\n"); }  void SortList(List * pList) {     if ( NULL == pList) return ; // 空     if ( pList->n <2 ) return;  // 只有一个或者是没有，排个屁     int x=0;     while ( x < pList->n ) {         List * p = pList->next;         List * pNext = p->next;         while ( p && p->next ) {             if ( p->n > pNext->n) {                 int t = p->n;                 p->n = pNext->n;                 pNext->n = t;             }             p = pNext; pNext=pNext->next;         }         x++;     } } int main() {     int init[] = {3, 8, 4, 7, 6, 2};     List * pList = CreateList(6,init);     PrintList(pList);     SortList(pList);     PrintList(pList);     return 0; }

user: user-0
content: 研究几天也没 有木有别的方法

user: user-2
content: 简单点的办法那就另建一个链表，首先搜索原链表里的数据，最好把数据和位置都记录下来，那么只需要挨个找到原链表的相应结点，复制一份接到新链表上，当然了有了数据直接按从小到大的顺序创建一个新链表更快，实在不行就这么做  正常的操作就直接修改原链表，排序和数组是一样的，你需要额外实现的是结点的交换、数据的查找

user: user-3
content: 建立链表， 头插法插入数据， 冒泡进行排序。
user-0 提问: 请大佬指点

回复:
user: user-0
content: 谢谢

user: user-1
content: 没有，以前的vs在程序结束后都会自动关闭控制台窗口，从vs2019开始就由采用按任意键关闭了

user: user-0

user: user-0
content: 引用 1 楼 與蘤舊縐 的回复:这个框原本好像是下面的一个标签吧，你给他抠出来了？  看看能不能拖回去  或者点一下右上角的倒三角形，看看能不能点出设置来 嗯，又把它摁回去了 还有这个东西，我记得起初没有这么复杂的东西，hello world下面的那些东西有什么影响吗

user: user-1
content: 这个框原本好像是下面的一个标签吧，你给他抠出来了？  看看能不能拖回去  或者点一下右上角的倒三角形，看看能不能点出设置来
user-0 提问: c语言基础问题，char的数组

回复:
user: user-1
content: 二维数组呗 char str[][36] = {"aaa", "bbb", "ccc"};

user: user-0
content: char *  type[] = {"aaa", "bbb", "ccc"};  我一开始也以为是可行的，试了下，不可以。因为“aaa”这些是const char*,不能初始化char*。 const char *  type[] = {"aaa", "bbb", "ccc"}; 这样倒是可以，可就是需要声明为const，后续没法修改了。

user: user-2
content: 参考一下 char *  type[] = {"aaa", "bbb", "ccc"};  //字符指针数组

user: user-3
content: 这么不行滴，你可以在编译器上运行试一下

user: user-2
content: //将数据拷贝到堆上去就可以修改了 #include <stdio.h> #include <string.h>  int main() {     const char *  type[] = {"aaa", "bbb", "ccc"};      char * arr[3];     for(int i=0; i<3; i++)     {         arr[i]=(char *)malloc(sizeof(strlen(type[i])));         strcpy(arr[i],type[i]);     }      for(int i=0; i<3; i++)     {         printf("%s\n",arr[i]);     }      return 0; }

user: user-4
content: “aaa”这种字符串当做指针来时使用的时候， 它就是const char* ，你无法修改的， 分配内存就分配到只读区域里面去了 要想初始化，并且能修改，那么    要么是数组，也就是二维数组那个样子    要么是动态的内存了，问题是动态内存的分配和初始化都是分开的，除非callc这种都初始化成0的  vector那种，相当是存在一个初始化构造函数，在里面实现内存分配和赋值的，只是代码表现上简洁了
user-0 提问: C语言问题：为什么两次的b输出不一样？求解

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-0
content: 引用 3 楼 qybao的回复:这个我也没想明白，怀疑是打印格式的问题。 如果是精度问题，那么一开始精度就丢失了，把丢失精度后的信息保存在b的内存里，之后b的内存没再变化（此时已经不存在精度问题）。所以即使精度丢失，因为b的内存信息没有再发生变化，所以两次打印的都是b的内存信息，而b的内存信息都是一样的，按理打印结果应该一样。如果不一样，只能怀疑是打印格式了，估计是b内存的二进制信息又做了什么转换才打印，导致两次转换结果不一样。 谢谢👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍👍

user: user-2
content: 这个我也没想明白，怀疑是打印格式的问题。 如果是精度问题，那么一开始精度就丢失了，把丢失精度后的信息保存在b的内存里，之后b的内存没再变化（此时已经不存在精度问题）。所以即使精度丢失，因为b的内存信息没有再发生变化，所以两次打印的都是b的内存信息，而b的内存信息都是一样的，按理打印结果应该一样。如果不一样，只能怀疑是打印格式了，估计是b内存的二进制信息又做了什么转换才打印，导致两次转换结果不一样。

user: user-3
content: 精确度的问题吧，改个更高精度的数据类型应该就可以了

user: user-4
content: 定义float而float有效数字（精度）只为7位，也就是说在1234567后面的几位数字已经不准确，把float改成double就好咯
user-0 提问: 问题

回复:
user: user-0
content: 引用 1 楼 user-2的回复:你是不是看错答案了？而且题目应该要求a为小于10的正整数 我的理解 ① 应该是 term=0 ② 应该是 term = term*10 + a; 如果没有小于10的限制条件呢，是不是就变成a的a次方乘以10的n-1的阶乘的次方了呢？

user: user-1
content: 很明显答案错了，楼上答案是对的

user: user-2
content: 你是不是看错答案了？而且题目应该要求a为小于10的正整数 我的理解 ① 应该是 term=0 ② 应该是 term = term*10 + a;

user: user-2
content: 即使没有小于10的限制，你的推导也是不对的，比如a是2，n为2的情况下，你的推导结果就是2^2*10=40，明显不符合题目要求22
user-0 提问: 大佬帮忙看一下

回复:
user: user-0
content: 引用 7 楼 寻开心 的回复: 先去找书，看看字符串，和字符串函数部分去  先补课，  再改代码去 好的，确实忘了好多

user: user-1
content: 先去找书，看看字符串，和字符串函数部分去  先补课，  再改代码去

user: user-0
content: 哦哦，好的，我再改一改

user: user-1
content: if （NULL ！= strchr（cNameTemp， ‘#’））  查找#是否在名字字符串当中出现  输入#作为名字结束，应该是判断cNameTemp[0] 是否是‘#’ 如果是判断名字里面是否有#，就用strchr函数来  字符和字符串整个理解就不到位， 好好看书去      gets_s(cNameTemp);     //添加结点，当输入#时结束     while (cNameTemp[0] != '#')     {     printf("input phonenumber");         gets_s(cNumberTemp);           //申请结点并填入数据         pStrPeoTemp = (struct people*)malloc(sizeof(struct people));         pStrPeoTemp->cName[20] = cNameTemp[20]; // 改   strcpy         pStrPeoTemp->cNumber[12] = cNumberTemp[12];  // strcpy         pStrPeoTemp->pStrNext = 0;         //接入链表         if (!pStrPeoHead)             //接入第一个结点，头指针，尾指针均指向该结点             pStrPeoHead = pStrPeoTail = pStrPeoTemp;         else         {             //接入非第一个结点             pStrPeoTail->pStrNext= pStrPeoTemp;             pStrPeoTail = pStrPeoTemp;         }         printf("input name ");         gets_s(cNameTemp);     }

user: user-1
content: pStrPeoTemp->cName[20] = cNameTemp[20];  pStrPeoTemp->cNumber[12] = cNumberTemp[12]; 这是做什么呢？   字符串赋值，不是这样， 要用strcpy(....) strcpy( pStrPeoTemp->cName, cNameTemp);  后面的相等判断也要用 strcmp(....) if ( strcmp( pStrPeoTemp->cName, cNameTemp)== 0 ) 这个才是两个字符串是否相等

user: user-2
content: if (pStrPeoTemp->cNumber[12] == cNumberTemp[12])你的查找条件有问题，存的是字符串，比较用strcmp

user: user-0
content: 嗯，谢谢，改成cNameTemp[0] != '#'了，可以结束了，但查找时输入姓名却没有打印号码，是为什么呢？

user: user-2
content: while (cNameTemp[20] != '#')你的条件是[20]最后一个字母为#,输入用的是gets_s是串不能保证[20]的值的，你可以换个条件，         printf("input name ");         gets_s(cNameTemp);         printf("input phonenumber");         gets_s(cNumberTemp); 你的是先输入cNmameTemp,不管cNameTemp是不是结束符，都会要求输入下个
user-0 提问: C语言大数加法的一个疑问求解

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 这个注释就已经写的很明白了，是去掉前缀的0，只是处理不对 LS说的是一种情况，但如果输入合法数据 比如输入 s="9"， ss="98"，为了方便说明，把长度110改为5 保存到数组 a={9,0,0,0,0},b={8,9,0,0,0},max=2，max在红字位置 相加结果 c={7,0,1,0,0}; max在红字位置 要去掉前面的0，只需要定位max的位置，然后从max倒序 while(c[max]!=0&&max<数组长度5) max++; 就可以了，因为上面红字位置为'1', 所以while循环成立，max变为3，即蓝色的位置 {'7','0','1',0,0}，然后退出while循环 所以 for(i=max-1;i>=0;i--) 倒序输出（从上面的蓝色位置减1位开始，也就是就max-1开始）就可以得出结果  所以如果s和ss输入前面带0的数据，应该要去掉后再存入a和b才是正确的处理方法

user: user-3
content: 别人写的程序，全靠猜。我猜1：防止输入0003  5 输出 0008；2：判断是否有进位~~不过写的是错的，应该将： while(c[max-1]==0&&max!=1)//去掉前缀0 max--; for(i=max-1;i>=0;i--)  改为： while(c[max]==0&&max!=0)//判断是否有进位，并去掉前缀0 max--; for(i=max;i>=0;i--)
user-0 提问: 大佬这什么情况

回复:
user: user-0
content: 嗯，解决了，记性不太好

user: user-1
content: 引用 3 楼 ?Victor.?? 的回复:所有用到malloc函数都要用这个头文件吗，还是只有vs 这是标准c的头文件库，不光是vc https://zh.cppreference.com/w/c/header

user: user-1
content: 头文件问题 #include <stdlib.h>

user: user-0
content: 所有用到malloc函数都要用这个头文件吗，还是只有vs

user: user-2
content: #include<stdlib.h>

user: user-3
content: #include<malloc.h>
user-0 提问: while(getchar() != '\n')         continue;这个命令怎么理解

回复:
user: user-1
content: 发现上一句表达不准确，更正下， while(getchar() != '\n')用于回收scanf()遗留在输入缓冲里包括回车符在内的遗留数据，免得干扰下一个getchar()这类输入函数的功能

user: user-1
content: while(getchar() != '\n')用于回收scanf()遗留在输入缓冲里的回车符，免得干扰下一个getchar()这类单字符函数功能

user: user-2
content: 相当于清空输入缓存，比如你在scanf的时候输入了 123 xxooxxooxxoo回车 num获得123后，后面的字符还在输入缓存里，如果不清空，会影响后面的s_gets(也就是fgets，它从标准输入读取数据，会得到有脏数据)

user: user-3
content: 你这么写while(getchar() != '\n'){};完全没用呀，你得用变量来接受输入的字符，如果输入的是getchar就不会拿，直接跳出循环了

user: user-4
content: 这个语句我理解的是为了解决用户一次性输入多个数字或者字母的问题，同理这个还可以这样写while(getchar() != '\n'){};
user-0 提问: c语言命令行*

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-0
content: 引用 9 楼 qybao的回复:如果是在命令行输入3*5做成main的启动参数，就属于后者，用单引号或双引号括起来 即 experiment.exe “3*5” 评论不能发图片 我私信你 你回我一下 不然发不了消息

user: user-2
content: vs不是这样，

user: user-3
content: 引用 4 楼 qq_46049078 的回复:那要怎么办 我是小白 写一个简单的计算程序 这个*在命令行里识别不了 我的程序就有问题 谢谢谢谢 你可以试试用单引号或双引号，或者用转义符 experiment.ext '*' //单引号 experiment.ext "*" //双引号 experiment.ext ^* //转义

user: user-3
content: 如果是在命令行输入3*5做成main的启动参数，就属于后者，用单引号或双引号括起来 即 experiment.exe “3*5”

user: user-3
content: 你是在程序中输入还是在程序启动时作为main方法的参数传给程序？ 如果是前者，不需要转义，直接输入*就可以。 如果是后者，需要转义或用单引号双引号括起来。 你最初的问题描述应该属于后者，但你追加的提问却属于前者。最简单明的提问就是直接把你的代码贴出来。

user: user-0
content: 引用 6 楼 qybao的回复:[quote=引用 4 楼 qq_46049078 的回复:] 那要怎么办 我是小白 写一个简单的计算程序 这个*在命令行里识别不了 我的程序就有问题 谢谢谢谢 你可以试试用单引号或双引号，或者用转义符 experiment.ext '*' //单引号 experiment.ext "*" //双引号 experiment.ext ^* //转义[/quote] 好像不太懂，我的意思是比如我在命令行输入3*5，然后程序就要识别那个计算符号是+-*\里的哪个，然后执行哪个函数，这个*号他和我写的程序里面*他不能相等，我怎么办

user: user-0
content: 引用 2 楼 qybao的回复:c是命令行的特殊符号，默认是显示当前文件夹的所有文件 那要怎么办 我是小白 写一个简单的计算程序 这个*在命令行里识别不了 我的程序就有问题 谢谢谢谢

user: user-0
content: 引用 1 楼 user-4的回复:* 在传到 main 之前被系统智能替换为当前目录的文件列表了。 那要怎么办 我是小白 写一个简单的计算程序 这个*在命令行里识别不了 我的程序就有问题 谢谢谢谢

user: user-3
content: c是命令行的特殊符号，默认是显示当前文件夹的所有文件

user: user-4
content: * 在传到 main 之前被系统智能替换为当前目录的文件列表了。
user-0 提问: 求助关于c11的几个问题

回复:
user: user-1
content: gcc 不支持 gets_s 等带 _s 的函数，请另换函数。第二个问题不知道。

user: user-2
content: c的确不支持 gets_s 等带 _s 的函数，得另换函数。第二个问题不知道。

user: user-1
content: 是的，然而这是一个可选组件，所以 gcc 有理由不去实现，事实上它也确实没实现。

user: user-0
content: 引用 1 楼 apkipa1的回复:gcc 不支持 gets_s 等带 _s 的函数，请另换函数。第二个问题不知道。 gets_s()不是C11标准里面的吗？
user-0 提问: VS2017 能不能一次设置，对所有的项目都有效呢？

回复:
user: user-1
content: 我的问题和你一样，我现在解决了，可以看一下这篇文章作参考 https://xcosmic.blog.csdn.net/article/details/107297837 如果你想把你那个属性变成默认的话直接改那个属性管理器user结尾的就行

user: user-2
content: 配置所有管理器，增加你自己的定义选项，同类的程序直接选你定义的，不用DEBUG\release
user-0 提问: 如何解决“TAP-Windows”设备工作一段时间后停止工作的问题?

回复:
user: user-0
content: 补充：         核对写入TAP设备的IP协议数据报都是有效的，这很好论证只需要把后面通过“WriteFile”写入到TAP设备的IP数据报文记录一些，在重启TAP设备之后写入TAP设备；查看运行TAP设备的操作系统主机是否可以处理（一般多为UDP协议数据报测试；TCP协议数据报基本是向外TCP_SYN、不太容易进行这样的测试）。
user-0 提问: 新手小白求助！自学C语言，学到循环语句部分，有个问题想求教！谢谢了！

回复:
user: user-1
content: 这么大，unsigned long long也装不起

user: user-2
content: S 你可以用 unsigned long 变量表示，然后 while 循环的测试表达式把 50 换成小一点的数字试试

user: user-2
content: 因为最后的乘积已经超出了 int 变量所能表示的最大范围

user: user-3
content: double来计算吧 如果要求必须是整数，就弄个长整数的乘法吧 34243224 702511976 248246432 895208185 975118675 053719198 827915654 463488000 000000000 double: 3.424322e+079  #include <stdio.h> #include <string.h> #define MAX 100 int facts[MAX]; int factd(int n) { // 10进制的乘法  	if ( 0==n ) { // 0！ = 1  		facts[0] = 1; 		return 1; 	} 	memset(facts, 0, MAX*sizeof(int)); 	facts[0] = 1;  int len = 1;   	for (int i=1; i<=n; i++) { 		int  extend = 0; 		long long int d; 		for ( int j=0; j<len; j++) { 			long long int a = facts[j]; 			d = a * i * 2 + extend; //a*i+extend就是算阶乘，多个2就是2*4*6这种  			if ( d > 1000000000) {		 				facts[j] = d % 1000000000; 				extend   = d / 1000000000; 			} else 				facts[j] = d, extend=0;  		} 		if ( extend>0) { 			facts[len] = extend; 			len ++; 			extend = 0; 		} 	} 	return len;   }  void printd(int len) { 	printf("len:%d\n", len); 	if (len>1) { 		printf("%d ", facts[len-1]); 		for ( int i=len-2; i>=0; i--)  			printf("%09d ", facts[i]); 	} else 		printf("%d", facts[0]); }  int main() {     int len = factd(50);  //参数50表示， 100*98*96*....*2;     printd(len);     double d=1;      for ( int i=2; i<=100;i+=2) d *= i;      printf("\ndouble: %le\n", d);      return 0; } ———————————————— 版权声明：本文为CSDN博主「寻开心」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/happy__888/article/details/104024922

user: user-4
content: 答案应该是3.52216025511551755696249024065e+79‬

user: user-4
content: 结果数据范围太大，你可以选择 unsigned long long,如果还不行，就用高精度或大整数吧

user: user-5
content: 可能是结果太大无法显示，你试试代码最前面定义一个typedef long long int;看看有没有结果
user-0 提问: 萌新

回复:
user: user-1
content: 引用 5 楼 user-2 的回复:[quote=引用 3 楼 與蘤舊縐 的回复:] 找了半天没一个权威点的文档，C99是C99，C89可不认，这个问题几个月前也有人讨论，那篇帖子找不见了，不管是C还是C++，尽量别这么用吧 最权威的文档难道不应该在官网找吗，虽然只有草案是免费提供的。另外，我觉得现在都 2020 了，还讨论 C89 实在是有点不合时宜。VLA 的话我项目里肯定是不用的，不过一些小程序里会用到，毕竟方便。[/quote]  这样的话也没什么好说的，dev的确支持这种写法，他错的原因也确实像你说的那样，用不用看着办，不过提醒一句，学校的测试系统可能过不了  关于C++的话，它的const是真常量了，现在试一下C++98是可以的，后续版本自然也支持，那么就是偶然事件了

user: user-2
content: 引用 4 楼 與蘤舊縐 的回复:话虽如此，但以前试过并不行，不排除编译器的问题 肯定是可以的，这是由于 C++ 不同于 C，会把 const 对象当常量表达式推导(类似的还有 constexpr)，不过我没学过 C++，不知道这是什么时候引入的特性。另外，VLA 是 C 语言独有的，C++ 不支持。

user: user-2
content: 引用 3 楼 與蘤舊縐 的回复:找了半天没一个权威点的文档，C99是C99，C89可不认，这个问题几个月前也有人讨论，那篇帖子找不见了，不管是C还是C++，尽量别这么用吧 最权威的文档难道不应该在官网找吗，虽然只有草案是免费提供的。另外，我觉得现在都 2020 了，还讨论 C89 实在是有点不合时宜。VLA 的话我项目里肯定是不用的，不过一些小程序里会用到，毕竟方便。

user: user-1
content: 话虽如此，但以前试过并不行，不排除编译器的问题

user: user-1
content: 引用 2 楼 user-2 的回复:[quote=引用 1 楼 與蘤舊縐 的回复:] 不可以使用变量定义数组长度，即使用const修饰的变量也是一样  在C++中你这样的写法可能还可以，不过较新的编译器应该也不允许你这么做，而C语言是不支持的 C 语言是支持的，叫做 VLA，这里的问题是变长数组不能被初始化。[/quote]  找了半天没一个权威点的文档，C99是C99，C89可不认，这个问题几个月前也有人讨论，那篇帖子找不见了，不管是C还是C++，尽量别这么用吧

user: user-2
content: 引用 1 楼 與蘤舊縐 的回复:不可以使用变量定义数组长度，即使用const修饰的变量也是一样  在C++中你这样的写法可能还可以，不过较新的编译器应该也不允许你这么做，而C语言是不支持的 C 语言是支持的，叫做 VLA，这里的问题是变长数组不能被初始化。

user: user-1
content: 不可以使用变量定义数组长度，即使用const修饰的变量也是一样  在C++中你这样的写法可能还可以，不过较新的编译器应该也不允许你这么做，而C语言是不支持的
user-0 提问: C

回复:
user: user-0
content: 引用 4 楼 apkipa1的回复:其实从语法的角度来讲，你说的并不完全正确。编译器在遇到 extern 时，会先去前文查找，例如： int x; void f() {     extern int x; // 这里编译器能找到上层定义的 x，所以不一定需要链接器帮忙 } 但是： extern int x; // 这里向前找不到 x，并且是纯声明，所以是单纯引用外部的 x void f() {     extern int x; // 编译器能找到上层声明的 x，但由于在引用外部的 x，肯定需要链接器帮忙 } 当然，编译器向前查找时是会出现例外情况的(例如遇到函数内定义的 x)，这时候编译器会默认声明一个具有外部链接的 x。 至于你所说的内层覆盖外层，从作用域来说，我认为是对的。 附：如果有可能的话，去 https://zh.cppreference.com/w/c 上看看，你绝对会受益匪浅。 好的，谢谢哥～～～～～～

user: user-1
content: 其实从语法的角度来讲，你说的并不完全正确。编译器在遇到 extern 时，会先去前文查找，例如： int x; void f() {     extern int x; // 这里编译器能找到上层定义的 x，所以不一定需要链接器帮忙 } 但是： extern int x; // 这里向前找不到 x，并且是纯声明，所以是单纯引用外部的 x void f() {     extern int x; // 编译器能找到上层声明的 x，但由于在引用外部的 x，肯定需要链接器帮忙 } 当然，编译器向前查找时是会出现例外情况的(例如遇到函数内定义的 x)，这时候编译器会默认声明一个具有外部链接的 x。 至于你所说的内层覆盖外层，从作用域来说，我认为是对的。 附：如果有可能的话，去 https://zh.cppreference.com/w/c 上看看，你绝对会受益匪浅。

user: user-0
content: extern 声明中的x是个全局变量，在整个程序中，就只有那一个int  x的x是，所以就是它  但找到定义联系起来是链接阶段的事，编译阶段只是 提示引用，放行，不报错（编译器并不知道引用的x实际定义） 但上文的int x行中x有了意思 所以我才说内层覆盖外层 这样理解正确吗？

user: user-0
content: 引用 1 楼 寻开心的回复:你这样写， extern int x和全局的x就是同一个。 int x =3; int main() {     extern int x;     printf("%d", x);     // 这个输出就是3     return 0; }  extern int x; 这是声明， 不是定义， 所以它的作用域，不是在这个位置决定的 extern 的类型，都是全局变量 包含extern声明的作用域在上文不是块作用域吗

user: user-2
content: 你这样写， extern int x和全局的x就是同一个。 int x =3; int main() {     extern int x;     printf("%d", x);     // 这个输出就是3     return 0; }  extern int x; 这是声明， 不是定义， 所以它的作用域，不是在这个位置决定的 extern 的类型，都是全局变量
user-0 提问: c逻辑运算符

回复:
user: user-0
content: 引用 2 楼 初学小菜的回复:最好用数组，数组更方便 老师要求的，要用逻辑运算符与或非

user: user-0
content: 引用 1 楼 如风_Antoni的回复:#include<iostream> using namespace std; int main() { 	int a, b, c; 	cin >> a >> b >> c; 	int max, mid, min; 	max = (a > b) ? a : b; 	max = (c > max) ? c : max; 	min = (a < b) ? a : b; 	min = (c < min) ? c : min; 	mid = a + b + c - max - min; 	cout << min << mid <<  max << endl; 	return 0; } 同理四个数比较也可以，加一个变量就可以 要用逻辑运算符&&||！与或非

user: user-1
content: 最好用数组，数组更方便

user: user-2
content: #include<iostream> using namespace std; int main() { 	int a, b, c; 	cin >> a >> b >> c; 	int max, mid, min; 	max = (a > b) ? a : b; 	max = (c > max) ? c : max; 	min = (a < b) ? a : b; 	min = (c < min) ? c : min; 	mid = a + b + c - max - min; 	cout << min << mid <<  max << endl; 	return 0; } 同理四个数比较也可以，加一个变量就可以
user-0 提问: 如何理解01背包的状态转移方程？

回复:
user: user-1
content: 两个放入的不是同一包 对应的是两种不同的方案 所以要比较 如果<=总质量 则要选择在特定的包中放置该物品 如果>=总质量 则继承上面的在(包枚举中)特定的包

user: user-2
content: 引用 楼主 Jennie Libra 的回复:感觉对这一段代码不是很理解  f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}  “f[i-1][v]代表的就是不将这件物品放入背包，而f[i-1][v-c[i]]+w[i]则是代表将第i件放入背包之后的总价值，比较两者的价值，得出最大的价值存入现在的背包之中。” 可是，一个物体放入背包肯定比不放入时的价值大啊，这有什么比较的必要吗？  不放入该背包就不消耗容量，可能放后续背包后总的价值更大

user: user-3
content: f[i-1][v-c[I]] +.  w[I] 去掉一个    换上另一个

user: user-4
content: 单看这个肯定没必要呀

user: user-4
content: 有一个判断条件你没写，这个是容量作为下标，你得考虑背包是否放满
user-0 提问: 为什么代码运行之后输入a,b之后没有输出啊

回复:
user: user-1
content: 算法有问题，通过追踪运行来找问题。下面这个代码提供参考： #include <math.h> #include <stdio.h>  int IsPrime(int i) {     int j = 2;     int k = sqrt(i);      if (i < 2)         return 0;      while (j <= k)     {         if (0 == i % j)         {             return 0;         }          ++j;     }      return 1; }  void FindPrime(int* primeArray, int count)// = 200) {     for (int i = 0, target = 2; i < count; ++target)     {         if (IsPrime(target))         {             primeArray[i] = target;             ++i;         }     } }  int main(void) {     int primeArray[200] = { 0 };     int m, n, t, sum = 0;     scanf("%d%d", &m, &n);     FindPrime(primeArray, 200);     if (m > n)     {         t = m;         m = n;         n = t;     }      if (n > 200)     {         printf("输入超范围");         return 0;     }      for (; m <= n; ++m)     {         sum += primeArray[m - 1];     }      printf("%d", sum);      return 0; }
user-0 提问: c语言中有类似java中ArrayList和LinkedList的库或者第三方代码用吗？

回复:
user: user-1
content: C需需要是面向过程的语言，没有面向对象那一套，有的只是函数和一堆数据类型，要学c就不要再用java的眼光去审视它，用面向过程的语言，就请先暂时忘记什么叫做面向对象。c语言有标准库，库里面都是函数，如果你想用arraylist这样的，就只能自己写结构体，将相关操作写成一个个函数。

user: user-2
content: 自己写一个链表

user: user-3
content: 评论区人人大牛，人家问你C又没问你C++，在那秀

user: user-4
content: 内核链表了解一下，或者写个用 void* 存数据的

user: user-5
content: c++ 的 boost库了解下

user: user-6
content: 引用 楼主 wow334的回复:java中，  同一类的东西放在一个集合中很方便，比如一群狗 放在一起，一群人放在一起。在c语言中我要怎么把同一类的放在一起？   我现在弄的链表，它只能把同一类的东西放在一起，比如people，等我要把一些book放一起时，又要重新写一条book链表的增删改查，很麻烦啊  但是java中，一个ArrayList 或者 LinkedList，   它只要   ArrayList  peopleList = new ArrayList  ;              ArrayList  bookList = new ArrayList  然后 peopleList 就可以存people , bookList就可以存book，完全不用为了book再写一条新链表。c语言中有类似java中ArrayList和LinkedList的库或者第三方代码用吗？ C++标准库有很多，

user: user-7
content: c语言应该没这种吧

user: user-8
content: 引用 8 楼 寻开心的回复:c也可以啊， 无非把里面的节点的数据类型设置成为void *呗 然后自己想怎么解释就做强制数据转换了 是这个理，我在网上找到过linkedlist,hasmap的c语言版本

user: user-9
content: 1. libcstl https://github.com/activesys/libcstl  2. glib2 https://developer.gnome.org/glib/2.26/glib-Doubly-Linked-Lists.html

user: user-10
content: 直接自己写一个存void指针的list，不就行了，void 指针可以转成其他类型的指针。

user: user-11
content: 应该改用java或者自己写结构然后想用的时候include一下

user: user-12
content: c标准定义在那里， 就是那样了， 在没有新标之前， c提供的就哪些 c++，java的标准里面，已经把template之类的东西都包含在里面， 所以变成了语言的直接支持部分 任何一个编译器自动支持  本质差异就在这儿， 因为只有一个c/c++的标准，  官方只有他， 其他的都不算官方 visual c++自己有一套mfc， 问题是dev c++认吗？  五花八门的编译器，哪一个算是正版官方？ 都不是，都有自己的特点，也有自己的所谓官方工具包，但是都是针对特定的目标的

user: user-13
content: 有啊，去 github 上找一找，一大堆。

user: user-12
content: 不是没有， 以前没有java 和 c++的时候，就是c的天下，软件包多多多的很

user: user-0
content: 谢谢大家！ 我觉得奇怪的是java   c++ 都有官方的， c怎么不弄个类似功能的官方版本呢？

user: user-0
content: 引用 8 楼 寻开心 的回复:c也可以啊， 无非把里面的节点的数据类型设置成为void *呗 然后自己想怎么解释就做强制数据转换了  好的，我用void * 试下， 谢谢！

user: user-14
content: 感觉这些东西都不需要库，从某些开源软件里摘除源码来就可以了。 比如cJson

user: user-15
content: 引用 7 楼 wow334 的回复:[quote=引用 6 楼 user-15 的回复:] array<T,N> (数组容器)  vector<T> (向量容器)  deque<T> (双向队列容器)  list<T> (链表容器)  forward list<T>  都可以用啊 STL基础类就可以  这些是c语言可用使用的吗？  我需要c语言能用的。不是c++的[/quote] 简单的，重封装一下,编译成dll,或lib,纯C代表调用，然后用void *想怎么转都行

user: user-12
content: c也可以啊， 无非把里面的节点的数据类型设置成为void *呗 然后自己想怎么解释就做强制数据转换了

user: user-0
content: 引用 6 楼 user-15 的回复:array<T,N> (数组容器)  vector<T> (向量容器)  deque<T> (双向队列容器)  list<T> (链表容器)  forward list<T>  都可以用啊 STL基础类就可以  这些是c语言可用使用的吗？  我需要c语言能用的。不是c++的
user-0 提问: 拜托帮一下忙哈

回复:
user: user-1
content: 引用 9 楼 牛不才的回复:scanf 这个回车问题，很多刚刚接触C语言的同学都会有疑问，建议去了解一下输入输出流和缓冲区 下面的链接可能有帮助 https://blog.csdn.net/tonglin12138/article/details/85534308 哥哥看下我的帖子，pta刷题只对了一个样例，不知道哪里错了😭

user: user-2
content: scanf 这个回车问题，很多刚刚接触C语言的同学都会有疑问，建议去了解一下输入输出流和缓冲区 下面的链接可能有帮助 https://blog.csdn.net/tonglin12138/article/details/85534308

user: user-2
content: #include<stdio.h> #include<string.h> #include<math.h> int main() { 	int n; 	int l; 	int i, j = 0; 	int m; 	char s[10][8]; 	int x[10][16]; 	scanf("%d\n", &n);//抵消掉回车 	while (n--) { 		gets(s[j]); 		l = strlen(s[j]); 		printf("%d\n", l);//输出这里也加一个回车，好看一下 		j++; 	} 	return 0; }

user: user-0
content: 引用 5 楼 qq_46311368 的回复:[quote=引用 4 楼 m0_46317256的回复:]那我要是想正常输入应该怎么办呢 直接把第一次的不用做正常数据输出吗 要是不想把第一个空间作废有办法改吗 第一次是输入数字，比如   3  然后按回车，计算机实际读入3\n   处理掉的只是这个，对后面的输入输出没有影响[/quote] 嗯嗯 刚刚试了已经好啦呢

user: user-0
content: 引用 2 楼 qq_46311368 的回复:加一个while（getchar（）！=‘n‘） continue； 谢谢 好啦

user: user-1
content: 引用 4 楼 m0_46317256的回复:那我要是想正常输入应该怎么办呢 直接把第一次的不用做正常数据输出吗 要是不想把第一个空间作废有办法改吗 第一次是输入数字，比如   3  然后按回车，计算机实际读入3\n   处理掉的只是这个，对后面的输入输出没有影响

user: user-0
content: 那我要是想正常输入应该怎么办呢 直接把第一次的不用做正常数据输出吗 要是不想把第一个空间作废有办法改吗

user: user-1
content: 引用 2 楼 qq_46311368的回复:加一个while（getchar（）！=‘n‘） continue； 少打个\     \n是换行符

user: user-1
content: 加一个while（getchar（）！=‘n‘） continue；

user: user-1
content: scanf读完后会留下一个换行符，被gets读进去了
user-0 提问: 想知道为什么代码执行后，缓冲区无法关闭

回复:
user: user-1
content: 引用 2 楼 寻开心 的回复：while(k!=1||k!=0){      n*=a;     k--;  }  这个逻辑不对吧， 这个条件永远成立啊，  没有任何数同时==0和==1的！=

user: user-2
content: 引用 5 楼 他们都管我叫郑老师 的回复:[quote=引用 2 楼 寻开心 的回复：]  while(k!=1||k!=0){      n*=a;     k--;  }  这个逻辑不对吧， 这个条件永远成立啊，  没有任何数同时==0和==1的！=[/quote]  正是因为   ！=  所以这个条件才永远是真 如果是1， ！=0满足， ||的结果是真 如果是0， ！=1满足，||的结果还是真 如果其他  上述两个都满足， 结果更是真的不能再真  楼主属于光提问不结帖类型的，本来都不想继续回答了。既然还有人有疑问，就答复一次

user: user-0
content: “||”是或的意思吧

user: user-2
content: 怎么又给你这个光提问不给分的家伙回答问题了，

user: user-2
content: while(k!=1||k!=0){      n*=a;     k--;  }  这个逻辑不对吧， 这个条件永远成立啊，  没有任何数同时==0和==1的

user: user-3
content: 很简单，你的程序死机了。