Question: 关于C语言的向上取整

按照 你自己的代码，我运行了一次，在我的计算机上是可以运行并计算的。并且采用了两种输入试了一下都是可以正常计算，并且按整数输出。第一次输入 ，，10，2 第二次输入，，7，3 一次输出没有小数，和一次输出有小数都呆以正常取整

这跟C没啥关系吧？如果i/j正好能整除呢？

正好整除向上取整也得加一吧，我是做题用到后者AC了，但是前者WA了，搞不懂i/j+1为什么不行

那一定是我对向上取整有误解，抱歉。


Question: 关于递归调用的理解？？？？？？？

“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出

递归这里我老是肯不动。学习中

你起床后打算吃米饭，于是你开始递归：要吃总得先盛到碗里吧，先调用盛饭函数。锅里居然是空的，先调用做饭函数。然而上次用完后锅还没刷，先调用刷锅函数。注意你的输出，1010是这样产生的：你刷了锅然后淘了米放了水点了火煮好了以后打开锅盖挖一勺到碗里开始......递归做菜

感谢，瞬间懂了


Question: 51单片机函数声明和函数传参的问题。

楼主您的代码段没有表现出和两个问题的联系，这就很难回答了。

您好 就是 能不能把SMG1 传到函数里呢？

首先肯定是能。 但是传进来干嘛？你的函数都不使用它，直接就重新赋值，也就扔掉传进来的值了。

我明白了，他传进来，替换smg，然后又被赋值了，对吧？实际上P0,P1并没有被传进来。我应该做的是吧P0或者P1传进来，而不是把SMG1SMG2传进来。。。是这样理解吗？


Question: {已解决}C Primer Plus初学，请教第四章的一道编程题目

int main() {    char first_name[40];    char last_name[40];    char* p1;    char* p2;    p1 = first_name;    p2 = last_name; printf_s("Please input your first name:\n"); gets(p1); printf_s("Please input your last_name:\n"); gets(p2); printf_s("%s %s", p1, p2); return 0;  }


Question: 指针，，，，，，，

给p赋值，是修改p的指向，并不能修改p的目标里面的内容。尤其需要这样理解的是p="sffd";这句。是在内存另外的位置保存了sffd这样的内容，然后用p指向那里的意思。

感谢


Question: void 类型的指针可以存储任何类型的数据吗

感觉最好声明清楚比较好，否则后面容易混淆 void * p;    int a = 3;    p = &a;    printf("%d", *p);    return 0;

是可以的，但是在你取回原来的类型值时，就需要强转了。比如，你要拿回p指向的值（也就是整型3），就需要这样做：*(int *)p

也就是void 指针可以存储任何类似的数据，但要使用的时候，就要用*(int*)p进行强转后取值吗


Question: 帮我看看编译错哪了？

试一了下，还是在中文下面输入符号的问题引起。

感谢，问题已解决

printf("math = %d, eng = %d, comp = %d, average = %d"，（这个逗号，你用了纯中文符号）87,72,93,（（这个括号，你用了纯中文符号）87+72+93）（这个括号，你用了纯中文符号）/3)；（这个分号，你用了纯中文符号） return 0；（这个分号，你用了纯中文符号） 我不知道你用的是什么IDE，但最好能选择一种在纯中文与英文符号有明显区别的字体。

计算的结果不是整数，跟%d不匹配

......是分号的问题可以直接输出

不能直接在输出函数中直接输入数据进行输出


Question: 关系数据库中范式的简单讲解

数据库中的第一范式是什么意思


Question: 求教：同样的功能，一个main()实现vs几个函数实现，哪种情况效率高？

最明显的一条定律：同样的函数，能用宏定义实现，优先使用宏定义，它比online函数的效率更高。

谢谢指点

啥叫效率？实现同样功能的代码简短叫效率；代码被编译的过程占用的时间短叫效率；代码执行的时候用的总时间短叫效率；代码执行的CPU时间短叫效率；代码执行时占用的存储空间小叫效率；代码执行时的IO次数少也叫效率；......偏偏这些效率往往是互相矛盾的，压下葫芦起来瓢。

谢谢指点

基本没区别。 无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！

谢谢指点


你先说你的理解，为什么你觉得不起作用

p=s+a表示指向c[9]的位置，s=s+b表示指向c[6]的位置，c[6]>c[9],while条件为假，所以没运行

但是你while条件里面的指针没有解引用，比较的其实是地址值呀


Question: typedef的作用。。

typedef typedef type-declaration synonym;  The typedef keyword defines a synonym for the specified type-declaration. The identifier in the type-declaration becomes another name for the type, instead of naming an instance of the type. You cannot use the typedef specifier inside a function definition.  A typedef declaration introduces a name that, within its scope, becomes a synonym for the type given by the decl-specifiers portion of the declaration. In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types — they introduce new names for existing types.  Example  // Example of the typedef keyword typedef unsigned long ulong;  ulong ul;     // Equivalent to "unsigned long ul;"  typedef struct mystructtag {    int   i;    float f;    char  c; } mystruct;  mystruct ms;   // Equivalent to "struct mystructtag ms;"  typedef int (*funcptr)();  // funcptr is synonym for "pointer                            //    to function returning int"  funcptr table[10];   // Equivalent to "int (*table[10])();"   typedef 要定义的类型 类型的别名; typedef int *T;//定义T为int *  T a[20];//声明一个数组a，包含20个元素，元素的类型是T，也就是int *


Question: 有没有大佬说下什么问题

在main()函数之前，加入这行：using namespace std;这样才可以直接使用cout

#include <stdlib.h>std::cout


Question: 关于calloc的问题

1、如果你在函数内要为传进来的指针重新分配空间，要传它的一级地址，也就是指向指针的指针。2、在fun(int *p1,int *p2,int *s)你分配了空间，又将它释放了，这个操作很让人费解！3、直接将fun(int *p1,int *p2,int *s)改为这样就行了：void fun(int *p1,int *p2,int *s) {  *s=*p1+*p2;}

说实话，这个不是calloc什么的问题。而是楼主您对参数传递的理解有问题；也许对变量生存周期的理解也有一定问题？

程序结束前，你已经释放了，就算不释放，你也得不到


Question: 为啥编译后运行不了啊

1、不要直接编译单一的CPP文件，要先创建一个项目，然后，根据你的代码是C还是C++选择对应的项目类型，再创建源代码文件。2、关键词：cuot也打错了，应该是cout3、根据编译器返回的信息，你的Dev-C++没有正确安装好。安装Dev-C++之前一定要将旧版本的完全卸载掉才可以。4、关于如何安装Dev-C++可以参考我在B站的视频：      https://www.bilibili.com/video/BV1eq4y1M7XY?

cuot和cout不是一回事！关于自己是否适合编程的很简单的测试：在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案： A里面有10处以上文字或标点错误B里面没有文字或标点错误并敢为此跟人打赌C里面没有文字或标点错误并且字体和排版完全与原稿一致D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感 A不适合编程（理由：打字准确度偏低、粗心大意）B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念）C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证）D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！） 如果想从A变成B的话，到我的资源 ▼     http://download.csdn.net/detail/zhao4zhong1/4084259  里面下载“适合程序员的键盘练习”

"<<"不是左移符号吗，只能用于二进制中

他写的应该是c++ ，然后输出语句要用<<

疑似安装过程有问题，所以没有编译，而不是编译后如何。

安装过程？

我重新安装了还是这


Question: 有关i++的问题，求请教

C语言中序号是从0开始的。

你的问题跟昨天这位同学一样，可以参考我的回答：      https://bbs.csdn.net/topics/600693833

不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。

如果没有猜错你的问题的话，应该可以这么回答。先使用再++是对于它所在的那个唯一语句来说的，i++在while语句中，而不在下面的循环体中，所以是对于i++来说，先使用是拿去判断真假，之后，判断完了即使用完了，进行++。i++跟你while下面的不管啥玩意都没关系，它只负责while这一个语句。

i%2 == 0 假  跳转


Question: 在C语言中，SUM / M 与 1 / M * SUM 表示的含义不一样吗

注意：◆常量也有类型。1是整型，1.0f是float型，1.0是double型◆按照（）、*/、+-的运算符优先级计算，◆整型除整型只能得到整型而不会自动转为浮点型，比如1/2得到0而不会得到0.5f或0.5

抛开电脑编程中的精度，数据类型，就这个式子，最明显的区别下面这个t = 1 / M * SUM - (sumx / M) * (sumx / M)中M * SUM有可能为0，除数为0是没有意义的！如果你能保证不为0，那就是数据类型的精度差别了。

理由大约是M是某种整数类型而sum不是。


Question: 这个为啥错了，大佬教教我~~

sanf输入的时候不存在顶格（如：5.2f）只有输出的时候才有这种说法。int main() {    int a, b;    float c;    double d;    printf_s("please input int nums:\n");    scanf_s("%d,%d", &a, &b); printf_s("please input float nums:\n"); scanf_s("%f", &c);  printf_s("please input double nums:\n"); scanf_s("%lf", &d);  printf_s("%d,%d,%f,%lf", a, b, c, d); return 0;      }

重新看一下scanf和printf的差别，就明白了。


Question: 怎么提取" "中的字符串？

BTW:楼主您的sscanf操作从buf到buf这个挺不好的，严重建议像四老师举例那样写入另一个数组。

我只是举个例子，代表俩缓存区

char buf[] = "\"192.168.3.201\""; char ip[16]; if (1==sscanf(buf,"\"%15[0-9.]")) printf("ip:[%s]\n",ip);

char buf[] = "\"192.168.3.201\""; char ip[16]; if (1==sscanf(buf,"\"%15[0-9.]",ip)) printf("ip:[%s]\n",ip);

谢谢您的回复 感谢


估计是这个json_object_to_json_string(val)有问题，只能自己单步调试

我找到问题了，谢谢


Question: 为什么我的codeblocks不能反编译？

请问解决了吗 我也遇到了这个问题

需要配置gdb，我猜。

不用试探了，我们没有站在你身后偷看。 所以没有看到你的现场，所以无法回答这个问题。

emmm


Question: 没有对象，只能 New 吗？大揭秘：像写诗一样优雅的生产对象！


Question: 请问为什么都是n,但是输出的值与输入的值不一样?

printf 里面的 n 为什么要加 & 符号？

已经发现了,谢谢


Question: （数据结构）不知道哪里出错了，程序无法执行

参考我现在学习的游戏编程：     https://space.bilibili.com/1901488254  里面有个独立的MyLinkedList（单链表），已实现了增、删、改、查功能，其中还有一个函数是关于冒泡使用链表排序的。我老师写的代码，每一行都有注解，请参考。

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: 是语法错误还是编译器的问题？

C不支持到处定义变量。

C99+就可以了

您好 那么P0 在while里开始处初始化为什么也会报错呀

keil u4 可能不支持C99+

n定义在外面，keil u4 确实会报错不知道咋回事

你的P0 在哪儿定义了？ 是没有定义报警吧? 我试了一下，放哪儿都不会报警。。。

P0 应该是reg52.h里定义的吧  然后我太粗心了 下面应该用LED 但写的P0 可能是因此产生的错误。

就报错而言：放在while 外定义不会有问题。


Question: 求教哇，C语言编程习题

如果用指针的话，比较好理解：int main() {    int a, b, c,num,twosum; char q[40]; char* p; p = q;  printf_s("please,input str num:\n"); gets(p);  printf_s("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); printf_s("输入的三位数是:"); puts(p); printf_s("\n"); a = *(p + 2); b = *(p + 1); c = *p; printf_s("%c,%c,%c", a, b, c); printf_s("\n");  num = a * 100 + b * 10 + c; printf_s("逆数为：%d",num);  printf_s("逆数两倍为：%d", num * 2);   return 0;      }

差个&      scanf("%d", &sum);

看到了，谢谢大佬，已经好了

不用客气


Question: 字符变量与字符常量的比较问题

@AQ_No_Happy 明白了，谢谢。题目(6.14)： test.c #include <stdio.h> #include <Windows.h>   int main(void) {     char ch1, ch2;     int i=0;       while (ch1 = (ch2=getchar()) == 'A')     {         printf("ch1 = %d\n", ch1);         printf("ch2 = %d\n", ch2);         i++;     }       printf("=============================\n");     printf("ch1 = %d\n", ch1);     printf("ch2 = %d\n", ch2);     printf("\'\\n\'=%d\n", '\n');     printf("i = %d\n", i);      system("pause");     return 0; }  结果：

\n 的 ASCII码对应 10

没有搞错，当开始打A的时候，A在缓冲区，当按下回车的时候，第一个getchar()才获取到A这个值 顺利存到ch里 但回车既是确定又是字符，回车'\n'它也跟着进了缓冲区，并且和A一起被释放，A到了程序里 回车（'\n'）也到了程序里，并且被第2个循环的 getchar（）获取，获取后与常量字符A进行比较，结果是0，循环终止，输出0。

其次，从语义上看，似乎不该用while，这里应该是个if吧？

首先，去掉while行末的分号。

这是一道填空题。  **6.14** 若变量已正确定义，在执行以下 `while` 语句时，输入字符 `A` 后，`ch` 的值是______。 ```c     while (ch = getchar() == 'A'); ```


Question: 计算栈内部的元素，栈的空间结构是怎样的


Question: 通过指针函数找出二维数组中不符合要求的元素所在的行，并打印出来。

#include <stdio.h> #include <string.h>  #define printf_s printf  int main() {     float score[][4] = { {60,70,80,90},{56,89,67,88},{34,78,90,66} };     float* search(float(*pointer)[4]);     float* p;     int i;     int j;     for (i = 0; i < 3; i++)     {         p = search(score + i);         if (!p)             continue;         //if (p == *(score + i))         //{             printf_s("第%d个学生成绩有不及格\n", i);             for (j = 0; j < 4; j++)             {                 printf_s("%2.1f ", *(p + j));             }             printf_s("\n");         //}     }        return 0;  }  float* search(float(*pointer)[4]) {     int i;     float * pt;     pt = NULL;     for (i = 0; i < 4; i++)     {         if (*(*pointer + i) < 60) pt = *pointer;     }       return (pt); }   供参考～


Question: 【求解答】switch 的用法

刚才我试着将代码敲到电脑里运行看看时，发现D选项中 case10 : 空格的位置不对，应该是 case 和 常量表达式(10) 之间有一个空格，而 常量表达式(10) 和冒号 : 之间不能加空格，正确的写法应该是 case 10:。看这几个选项太考验眼力👀和细心😯了


Question: c语言难题，好难呀，，，，

我是按循环队列算的。如果不是循环队列，就是count=rear-front;到题中front>rear,怪了。

你好，请问一下 void fun() { char a; a=getchar(); if(a!='c')  fun(); putchar(a); } int main() { fun(); }  当输入‘abc'时，为什么输出的结果不是c呢？？？？？？？

单步调试一下就知道了。

if (rear>=front) count=rear-front; else count=rear+a-front;

怎么别人说是加初始状态的值呀


Question: Visual Studio 2019使用scanf()函数报错的解决方法

收藏了

谢谢！很有帮助！！！

我的博文有很多文章的。


Question: 关于C语言基本数据类型float的困惑

改成 double

精度有限，也就是有效数字位数有限，它只能记住7位呀。当你有100亿入账的时候，你忘记了自己原本还有的两元三角四分，不是很正常么？


Question: 巨难的问题，通俗易懂的讲解一下static 定义的变量是什么意思

就是你在哪个文件里面定义了一个函数为static 那么就只能在这个文件里面引用这个函数。其他的文件想调用这个static函数会编译报错。就这个意思。 对于变量一样的。

static主要就是限定作用域： #include <stdio.h> #include <unistd.h>  static float p = 3.1415;  static int test(void);  int main(int argc, char **argv) { while(1) { test(); sleep(1); } }  static int test(void) { static int time = 0; time ++; printf("test times: %d\n", time); }  1.`p`本身是个全局变量，然后添加`static`，意思就是将这个全局变量只在这个文件中使用，如果其他文件中有相同名字的全局变量，在这个文件也就只用这个变量的值。 2. `test`是个函数，但是添加了`static`表示为只在文件中调用，在生成库文件的时候不会生成这个函数的符号，就是外部不可见。 3. `time`是个局部变量，添加`static`修饰后，那么你就可以将他看作一个全局变量，但是作用域只在这个函数里面，`static int time = 0;`这个语句呢在调用函数的时候也不会运行，所以每次调用test函数，这个变量的值都会继续加一。

局部变量：我们知道，不写static的局部变量默认是auto的（这里是ANSIＣ的auto语义），定义它的块或函数结束的时候，这样的变量会失去定义从而“消失”，如果有机会再来，那会重新产生一个新的变量。——它“转世”了自然没有“前世”的记忆。所以有static的局部变量从现象上看是全局的生命周期，不会随着某块代码或函数的结束而消失，会一直存在直到程序结束。当然其可见性仍然是局部的。 全局变量：前面加static的唯一作用是把这个变量的可见性局限在当前源文件，不准在其他源文件通过extern引用这个变量。

这个讲解真牛呀，瞬间就懂了


Question: tcp服务器怎么判断客户端是否断开连接？或者异常中断？释放线程？

如果TCP链接被对方断开,协议栈会发送挥手包。这时候,你去读取TCP包的时候就会报错。这种情况下,你就可以认为断开,还有一种情况就是中间的路由或者网络出问题了。那么这种情况下你就需要心跳包来检测。

超时，再超时，又超时，失去耐心。不管是显式表达，还是底层释放，统统是这个原理。

心跳包了解一下

谢谢您的回复 已经解决，使用getsockopt检测连接状态即可

比不上用心跳包可靠且自主可控


Question: 在计算机编程中，网络可谓是主心骨之一，扛起了网络互通，连接万物的重任！其互通的关键 “ HTTP 连接 ” 是重中之重！那么征服 “ 三次握手、四次挥手 " ，是踏入计算机编程行业的敲门砖！


Question: 求助求助，求两个数组之间的交集并集和差集

仅供参考： #include <algorithm> #include <iostream> #include <functional> #include <cstring> using namespace std; int main() {     char *Alphabet = "abcdefghijklmnopqrstuvwxyz" ;     char *Vowels   = "aeiou" ;     char *AlphaNum = "0123456789abcdef" ;     char result[45] ;     char *last ;      int lenA  = strlen(Alphabet) ;     int lenV  = strlen(Vowels  ) ;     int lenAN = strlen(AlphaNum) ;      cout << "Alphabet = " << Alphabet << endl ;     cout << "Vowels   = " << Vowels   << endl ;     cout << "AlphaNum = " << AlphaNum << endl ;      cout << "\nusing non-predicate versions" << endl ;      //non-predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result) ;     *last = 0 ;     cout << "set_difference(Alphabet, AlphaNum) =  " << result << endl ;      //non-predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result) ;     *last = 0 ;     cout << "set_intersection(Alphabet, AlphaNum) =  " << result << endl ;      //non-predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result) ;     *last = 0 ;     cout << "set_symmetric_difference(Alphabet, Vowels) =  " << result << endl ;      //non-predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result) ;     *last = 0 ;     cout << "set_union(Alphabet, AlphaNum) =  " << result << endl ;      cout << "\nusing predicate versions" << endl ;      //predicate set_difference     last = set_difference(Alphabet, Alphabet+lenA,                           AlphaNum, AlphaNum+lenAN,                           result  , less<char>()) ;     *last = 0 ;     cout << "set_difference(Alphabet, AlphaNum) =  " << result << endl ;      //predicate set_intersection     last = set_intersection(Alphabet, Alphabet+lenA,                             AlphaNum, AlphaNum+lenAN,                             result  , less<char>()) ;     *last = 0 ;     cout << "set_intersection(Alphabet, AlphaNum) =  " << result << endl ;      //predicate set_symmetric_difference     last = set_symmetric_difference(Alphabet, Alphabet+lenA,                                     Vowels  , Vowels  +lenV,                                     result  , less<char>()) ;     *last = 0 ;     cout << "set_symmetric_difference(Alphabet, Vowels) =  " << result << endl ;      //predicate set_union     last = set_union(Alphabet, Alphabet+lenA,                      AlphaNum, AlphaNum+lenAN,                      result  , less<char>()) ;     *last = 0 ;     cout << "set_union(Alphabet, AlphaNum) =  " << result << endl ;      return 0 ; }

建议直接调用std::set的相应方法


Question: 关于斐波那契查找的算法问题

与二分查找相比，它有任何优点吗？


Question: 问题求教，谢谢，感激不尽

楼主的代码修改如下，问题见注释处： #include <stdio.h>     #include <stdlib.h>     #include <math.h>   int main() {     int x, y, t;     double z;     scanf("%d %d", &x, &y);     t = x;     x = x % 12;   //这里少了24小时制的转换            y = y % 60;     z = 5.5 * y - 30 * x;     if (z < -180)// ; 这里多了 ’; '号         z = 360 + z;     else if (z >= -180 && z <= 0)//这里少了 else ，>=  <=         z = -z;     else if (z > 180)      //这里少了 else         z = 360 - z;     else         z = z;     printf("At %d:%02d the angle is %0.1lf degrees.\n", t, y, z);     return 0; }

感谢分享


Question: TCP协议socket在子线程向缓冲区写数据出现 段错误 (核心已转储) 问题

需要加mutex锁

AnswerThread::AnswerThread(ros::NodeHandle& _nh,TCPClient _client)这里_client只是一个临时对象，    client2 = &_client; 指向它，出了构造函数就无效了


Question: 手撕算法，是面试中必遇的一道坎，迈过去就是康庄大道，不然就是重头再来！拿下这些，你将走向柏油…


Question: 请问学生用什么软件写C语言比较好，谢谢谢谢谢谢

windows 用visual studio 比较方便,如果在Linux上的话用vs code +  GCC

用Visual stdio 2019版本，这个挺好用的！链接： https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Community&rel=16这个是社区版，免费的，完全够用！！！     https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Community&rel=16%E8%BF%99%E4%B8%AA%E6%98%AF%E7%A4%BE%E5%8C%BA%E7%89%88%EF%BC%8C%E5%85%8D%E8%B4%B9%E7%9A%84%EF%BC%8C%E5%AE%8C%E5%85%A8%E5%A4%9F%E7%94%A8%EF%BC%81%EF%BC%81%EF%BC%81

谢谢

业界写C都用sourceinsight, 然后工具链编译运行

Visual C++ 2010 Express简体中文版 ▼     http://pan.baidu.com/s/1bnwRVLt

谢谢

免费的就用dev-c++:      https://github.com/Embarcadero/Dev-Cpp/

谢谢

vs 2013

谢谢

codeblocks比较好一些 而且工具自带有gcc  不需要额外的下载，链接如下：     https://blog.csdn.net/baolibin528/article/details/53709602/

谢谢


Question: scanf 使用上的一些问题

这里有关于scanf()的详解，是另一位博主的     https://bbs.csdn.net/topics/600546032

Format Specification Fields: scanf and wscanf FunctionsA format specification has the following form: %[*] [width] [{h | l | I64 | L}]type The format argument specifies the interpretation of the input and can contain one or more of the following:  White-space characters: blank (' '); tab ('\t'); or newline ('\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input. Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates. Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read. When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string. An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification. Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.  The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%. An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.

#include <stdio.h> #include <string.h>   int main(){     char str1[30] = {0};     char str2[30] = {0};     char str3[30] = {0};     char str4[30] = {0};       printf("first:\n");      scanf("%[a-zA-Z]", str1);            scanf("%s", str2);                   printf("str1 = %s\n", str1);          printf("str2 = %s\n", str2);           printf("\nsecond:\n");     rewind(stdin);     scanf("%[a-zA-Z]", str3);             scanf("%s", str4);              printf("str3 = %s\n", str3);     printf("str4 = %s\n", str4);       return 0; }

那是每次使用 scanf 后都要清除缓冲区吗？为什么我连续使用两个scanf("%s", str1);  scanf("%s", str2); 打印出来都很正常？

代码一样但是环境不同啊。第一次结束之后输入缓冲区里残留着一个换行符，于是它干扰了第二次的输入。

我还是不明白，第一次输入不是被 str2 给接收了吗？为什么会还会留到 str3 接收换行呢？

默认的%s会接受并忽略前置白空格，并在前瞻到后置白空格的时候停下，并不接受它。 而你的正则式显然是另外一个脾气。


Question: 求出n！的值中末尾为0的个数

sum += n/5; // ① n /= 5; // ②

大概是个找规律题。每五次就出现一个0。


Question: 用指针把a字符串数组复制到b字符串数组。

A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价


Question: MSVC如何用命令行编译出64位程序

私信只能发三句，我在这里回你。setvbuf的第二个参数，是给流（stdin/stdout/文件等）的缓冲区（我们叫它buffer）。因为是测试stdin，所以用scanf函数，它的第二个参数是被读入变量的地址（字符数组，因为是数组，直接，写字符数组名，我们叫他string）。这两个量，是两个独立的内存，不应该，把string传入到setvbuf做它的第二个参数。如果，把string作为参数传入到setvbuf中，那么就会出现，你当时提出的问题。你要是还感兴趣，可以看一下，我这个回答。关于setvbuf(stdin，......)的问题？ - 觉渺的回答 - 知乎https://www.zhihu.com/question/54681443/answer/2378633586

仅供参考：C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\amd64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\amd64_arm\cl.exeC:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\amd64_x86\cl.exeC:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\cl.exeC:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\x86_amd64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\x86_arm\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Tools\MSVC\14.16.27023\bin\Hostx64\x64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Tools\MSVC\14.16.27023\bin\Hostx64\x86\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Tools\MSVC\14.16.27023\bin\Hostx86\x64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Tools\MSVC\14.16.27023\bin\Hostx86\x86\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\Hostx64\x64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\Hostx64\x86\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\Hostx86\x64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\Hostx86\x86\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.29.30037\bin\Hostx64\x64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.29.30037\bin\Hostx64\x86\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.29.30037\bin\Hostx86\x64\cl.exeC:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.29.30037\bin\Hostx86\x86\cl.exe

VC++2005就支持64位了，否则xp和vista的64位版本是怎么编译出来的呢VC++的设计是不同版本（x86、x64、ARM、ARM64等等）的编译器独立存在，不是gcc那种一个编译器生成不同平台可执行文件的设计，安装好之后，只需要在命令行运行vcvars32.bat、vcvars64.bat... 就可以使用对应的命令行工具

我用的VC2010学习版，只有vcvars32.bat，没有vcvars64.bat，是安装错了还是？vcvars32.bat运行出来是什么样子，我运行了好像没啥结果

VC2010是不是不支持编译生成64位程序？ 如果是VS2015，参考下面：生成Release|x64"C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe" d:\test\test.sln /rebuild "Release|x64" /out d:\test\c.log或生成Debug|x64"C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe" d:\test\test.sln /rebuild "Debug|x64" /out d:\test\c.log


Question: Ab Test 在互联网产品精细化运营中发挥着重要且出色的作用，通过实验的形式，以数据为依据，科学决策，使产品在市场中保持强劲竞争力！


Question: C语言#define预处理宏定义详细解说

理解和讨论之前，请先学会如何观察！

VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E  ▼     http://bbs.csdn.net/topics/391003898


Question: 应提交哪个文件到码云？

源代码，可执行以及输出文件不提交

建议全部提交。


Question: Linux 中用select 机制实现多个客户端并发在线问题

老赵，你那个select对吗？我觉得有点问题

可以是可以，有点儿蹩脚了先创建监听的fd，和连接fd列表（里面还有记录已经写了多少了），然后循环开始【将监听fd和所有连接fd加入集合，然后开始select，返回后先判断是否有新的连接，如果有就accept，将产生的连接fd加入连接列表，遍历所有连接fd，每个fd写1k数据，如果已经写完了，则关闭这个连接，从连接fd列表里删除】大概是这样吧

大概是这样，不过要同时遍历读写的fd集合才能实现

嗯对是要区分读写，赵老师的框架就可以，改成linux的就行

仅供参考：（尽管是windows下的例子） /******************************************************************************\ * ioctl.c - TCP server * *       This is a part of the Microsoft Source Code Samples. *       Copyright 1996-1997 Microsoft Corporation. *       All rights reserved. *       This source code is only intended as a supplement to *       Microsoft Development Tools and/or WinHelp documentation. *       See these sources for detailed information regarding the *       Microsoft samples programs. \******************************************************************************/    #define WIN32_LEAN_AND_MEAN #include <winsock2.h> #include <stdlib.h> #include <stdio.h> #include <string.h>  #define DEFAULT_PORT 5001  int ReadAndEcho(SOCKET , char *,int ) ; int WriteMessage(SOCKET , char *,int ) ;  void Usage(char *progname) {     fprintf(stderr,"Usage\n%s -e [endpoint] -i [interface]\n",         progname);     fprintf(stderr,"Where:\n");     fprintf(stderr,"\tendpoint is the port to listen on\n");     fprintf(stderr,"\tinterface is the ipaddr (in dotted decimal notation)");     fprintf(stderr," to bind to\n");     fprintf(stderr,"Defaults are 5001 and INADDR_ANY\n");     WSACleanup();     exit(1); } int main(int argc, char **argv) {      char Buffer[128];     char *interface= NULL;     unsigned short port=DEFAULT_PORT;     int    fromlen;     int    i, ioctl_opt =1;     struct sockaddr_in local, from;     WSADATA    wsaData;     SOCKET listen_socket, msgsock;     fd_set readfds,    writefds, exceptfds;      /* Parse arguments */     if (argc >1) {         for(i=1;i <argc;i++) {             if ( (argv[i][0] ==    '-') || (argv[i][0] == '/') ) {                 switch(tolower(argv[i][1]))    {                     case 'i':                         interface =    argv[++i];                         break;                     case 'e':                         port = atoi(argv[++i]);                         break;                     default:                         Usage(argv[0]);                         break;                 }             }             else                 Usage(argv[0]);         }     }          if (WSAStartup(0x202,&wsaData) == SOCKET_ERROR) {         fprintf(stderr,"WSAStartup failed with error %d\n",WSAGetLastError());         WSACleanup();         return -1;     }          if (port == 0){         Usage(argv[0]);     }      //     // The fd sets should be zeroed out before using them to prevent errors.     FD_ZERO(&readfds);     FD_ZERO(&writefds);     FD_ZERO(&exceptfds);     memset(Buffer,0,sizeof(Buffer));      local.sin_family = AF_INET;      //     // bind to specific interface if desired.      local.sin_addr.s_addr = (!interface)?INADDR_ANY:inet_addr(interface);      /*      * Port MUST be in Network Byte Order      */     local.sin_port = htons(port);      listen_socket = socket(AF_INET, SOCK_STREAM,0); // TCP socket     if (listen_socket == INVALID_SOCKET){         fprintf(stderr,"socket() failed with error %d\n",WSAGetLastError());         WSACleanup();         return -1;     }     //     // bind() associates a local address and port combination with the     // socket just created.      if (bind(listen_socket,(struct sockaddr*)&local,sizeof(local) )         == SOCKET_ERROR) {         fprintf(stderr,"bind() failed with error %d\n",WSAGetLastError());         WSACleanup();         return -1;     }      //     // start listening on the socket for incoming connections     //     if (listen(listen_socket,5) == SOCKET_ERROR) {         fprintf(stderr,"listen() failed with error %d\n",WSAGetLastError());         WSACleanup();         return -1;     }     printf("%s: Listening on port %d\n",argv[0],port);      //     // Set the socket to non-blocking mode.     //     if (ioctlsocket(listen_socket,FIONBIO,&ioctl_opt) == SOCKET_ERROR) {         fprintf(stderr,"ioctlsocket failed %d\n",WSAGetLastError());         WSACleanup();         return -1;     }     //     // The structure of    the    loop below is very simple. We only accept one     // connection at a time. As    soon as    another    client connects, we     // disconnect the first    one, and start talking to the new client.     // All this    server does    is to echo the data    received on    the    socket     // back    to the client.     //     // This    is not a very realistic    server,    but    it does    serve to show that     // select()    does not scale very    well on    win32. If we were dealing     // with    more than one client, we would have    to have    a list of sockets     // that    are    in each    fdset to be    able to    check them when    select()     // returns.     //     while(1) {          //         // A socket    in the listen()    state becomes ready    to read    when a         // client connects to it. An accept() will complete    without         // blocking.         // Since select    sets the sockets that are ready    to be read from    or         // written to, we have to include listen_socket    in the fdset each time         // through the loop.         //          FD_SET(listen_socket,&readfds);          i =    select(0,&readfds,&writefds,&exceptfds,NULL);         if (i == SOCKET_ERROR) {             fprintf(stderr,"select failed %d\n",WSAGetLastError());         }         if (i==0){             fprintf(stderr,"Select returned no fds ready\n");         }          if (FD_ISSET(listen_socket,    &readfds)){             //             // close the previous client socket.             // We must also    clear it from the fdset    to prevent select()             // from    failing.             //             closesocket(msgsock);             FD_CLR(msgsock,&readfds);             FD_CLR(msgsock,&writefds);             fromlen    = sizeof(from);             msgsock= accept(listen_socket,(struct sockaddr*)&from,&fromlen);             if (msgsock    == INVALID_SOCKET) {                 fprintf(stderr,"accept failed %d\n",WSAGetLastError());                 WSACleanup();                 return -1;             }             FD_SET(msgsock,&writefds);             FD_SET(msgsock,&readfds);             continue;         }         if (FD_ISSET(msgsock,&readfds) ) {             //             // socket is ready to read,    i.e., there    is data    on the socket.             //             if (ReadAndEcho(msgsock,Buffer,sizeof(Buffer))<0) {                 fprintf(stderr,"terminating connection\n");                 FD_CLR(msgsock,&readfds);                 FD_CLR(msgsock,&writefds);                 closesocket(msgsock);                 continue;             }         }         if (FD_ISSET(msgsock,&writefds)    ){             if (WriteMessage(msgsock,Buffer,sizeof(Buffer))    <=0) {                 fprintf(stderr,"terminating connection\n");                 FD_CLR(msgsock,&readfds);                 FD_CLR(msgsock,&writefds);                 closesocket(msgsock);                 continue;             }         }         FD_SET(msgsock,&writefds);         FD_SET(msgsock,&readfds);     } } int ReadAndEcho(SOCKET insock, char *Buffer,int size) {     int    rc;      rc = recv(insock,Buffer,size,0);      if (rc == SOCKET_ERROR)    {         fprintf(stderr,"recv() failed with error %d\n",WSAGetLastError());           return -1;     }     if (rc ==0)    {         fprintf(stderr,"Connection closed by client\n");         return 0;     }     printf("Received [%s] from client\n",Buffer);     return rc; } int WriteMessage(SOCKET outsock, char *Buffer,int size) {     int    rc;     int    lasterr;      printf("Sending [%s] to client\n",Buffer);     rc = send(outsock,Buffer,size, 0);      if (rc == SOCKET_ERROR)    {       lasterr =    WSAGetLastError();       if (lasterr == WSAEWOULDBLOCK)         return 0;       else {         fprintf(stderr,"send() failed with error %d\n",lasterr);             return -1;       }     }     if (rc ==0)    {         fprintf(stderr,"Connection closed by client\n");     }     return rc; }

谢谢，后来同时使用读写文件描述符集合实现了

多进程同时下载不香吗？

导师给的一个任务，要求用select呢

不起新线程是不可能的cpu是流水线作业，就算多核，也是按顺序执行你的代码代码里规定了流程，cpu就会完全按照你给定的流程来输出结果

是的，但是我可以通过降低阻塞时间来使两个都在输出，比如我下载两个文件，a下载1024byte，b下载1024byte，循环这样，本质上可能不是并发，但从客户端看来是不是在同时下载呢？

哦，是的，这样是可以的，遍历句柄集合，每个发1k，可以的。accept设置为非阻塞模式，每次accept到之后遍历select集合，所有可写的都写1k数据（或者自己做一些管理，想着都烦）,但是对链接状态的管理也挺麻烦，之前好像看过有相关的文章。4老师的代码，你先看看能不能用吧

收到可写信号后新起线程

你好，能否不使用线程做到呢，仅使用i/o复用

对多线程这么排斥？参考一下libevent，muduo等高效的网络通讯框架，直接用就行了


Question: 这是书本上的得用指针输出多维数组各元素的值，简单，但感觉不好理解。逻辑性不强。

#include <stdio.h> #include <stdlib.h> int main() {     int a[3][4] = {         {1, 2, 3, 4},         {5, 6, 7, 8},         {9,10,11,12}};     int* p;     int y,x;     for (y=0;y<3;y++) {         for (x=0;x<4;x++) {             printf("%p ",&a[y][x]);         }         printf("\n");     }     for (p = a[0];p < a[0] + 12; p++) {         printf("%8d ", *p);         if ((p-a[0])%4==3) {             printf("\n");         }     }     system("pause");     return 0;  } //00EFFC48 00EFFC4C 00EFFC50 00EFFC54 //00EFFC58 00EFFC5C 00EFFC60 00EFFC64 //00EFFC68 00EFFC6C 00EFFC70 00EFFC74 //       1        2        3        4 //       5        6        7        8 //       9       10       11       12 //请按任意键继续. . . //   这是zhao4zhong1改写的输出多维数组各元素的地址和用指针输出多维数组各元素的值，简单，且感觉好理解。逻辑性强。


Question: 通过指针变量输出二维数组各元素的值。

这种方法和书上的不一样，我没有按书上的写，看起来没有书上的简单，但是我个人觉得好理解 ，比较有逻辑。


Question: 性能调优之三十六计 —— 「取而代之」Echo/Json 篇


Question: 求大佬解题，代码运行无数据

#include<stdio.h> #include<string.h>  int main(int argc, char **argv) {     char s[100] = { "This is C programming text" };     char t[100] = { "This is a text for C programming" };      int i = 0;     int j = 0;     int count = 0;     int start_count = 0;     int max = 0;      for (i= 0; i <= strlen(s) ; i++)     {         for(j = 0; j <= strlen(t); j++)// 字符串s中单个字符与字符串t中所有字符比较         {             if ((s[i] == t[j]) && (t[j] != ' ') && (i != strlen(s)))// 判断相同字符             {                 count++;// 单词长度计数                 i++;// 单词逐个字母比较移位             }             else             {                 i = count > 0 ? i - count: i;// 将i恢复循环计数                 if (count > max)// 判断是否位最长相同单词                 {                     max = count;// 保存单词长度                     start_count = j -max;// 相同单词在字符串的开始位                 }                 count = 0; // 清空单词长度             }         }     }      // 打印信息     for (i = 0; i < max; i++)     {         printf("%c", t[start_count + i]);     }     printf("\n");     return 0; }

if (s[i] == t[j])        {            count++;            i++;            j++;     if (s[i] == ' ')       {             k = count;              count = 0;              a = i-1;        }   }  在i与j等于8时因为C与a不相等，就无法跳入if里面，那么i，j就不会改变数值了，就会进入死循环

if (s[i] == t[j])        {            count++;            i++;            j++;         if (s[i] == ' ')         {              k = count;               count = 0;               a = i-1;         }     }  这里。。你应该把i，j++给移出来，不然会进入死循环，无法结束，自然就没法打印了

i，和j移到哪里呢？

我移了以后，结果并不对

我也不知道，我移出来，只能得到ming相等，但不是完整单词，我觉得应该不符合你的结果

char str[100] = {0};   //初始化一个字符串数组，长度为1，里面有一个字符char(0)     for (i = 0; i <= max; i++)         str[i] = s[a - max + 1 + i];    //字符串数组的长度能否更改？     str[i] = '\0';     printf("%s", str);     return 0;

#include<stdio.h> #include<string.h>  int main(void *arg) { 	char s[100] = { "This is C programming text" }; 	char t[100] = { "This is a text for C programming" }; 	int i = 0; 	int j = 0; 	int count = 0; 	int start_count = 0; 	int max = 0; 	int k = 0; 	while ((s[i] != '\0') && (t[j] != '\0')) 	{ 		if (s[i] == t[j]) 		{ 			if (s[i] == ' ') 			{ 				k = count; 				count = 0; 			} 			else 			{ 				count++; 			} 		} 		if (k > max) 		{ 			max = k; 			start_count = i - k;// 相同单词在字符串的开始位 		} 		i++; 		j++; 	}  	char str[100] = {0}; 	for (i = 0; i < max; i++) 	{ 		str[i] = s[start_count + i]; 	} 	str[max] = '\0'; 	printf("%s \n", str); 	return 0;		 } // 改成这样应该就可以了，主要是逻辑感觉有点问题。

还是不对运行结果是This

#include<stdio.h> #include<string.h>  int main(void *arg) { 	char s[100] = { "This is C programming text" }; 	char t[100] = { "This is a text for C programming" }; 	 	int i = 0; 	int j = 0; 	int count = 0; 	int start_count = 0; 	int max = 0;  	for (i= 0; i <= strlen(s) ; i++) 	{ 		for(j = 0; j <= strlen(t); j++)// 字符串s中单个字符与字符串t中所有字符比较 		{ 			if ((s[i] == t[j]) && (t[j] != ' ') && (i != strlen(s)))// 判断相同字符 			{ 				count++;// 单词长度计数 				i++;// 单词逐个字母比较移位 			} 			else  			{ 				i = count > 0 ? i - count: i;// 将i恢复循环计数	 				if (count > max)// 判断是否位最长相同单词	 				{ 					max = count;// 保存单词长度 					start_count = j -max;// 相同单词在字符串的开始位 				} 				count = 0; // 清空单词长度 			} 		}	 	} 	 	// 打印信息 	for (i = 0; i < max; i++) 	{ 		printf("%c", t[start_count + i]); 	} 	printf("\n"); 	return 0;		 } // 再试试这个


Question: 求一个简单计算的方式。一列数值，想统计各列的总数，最大值，最小值

可以使用SSE/AVX指令maxps、minps、addps，#include <intrin.h>

能不能详细点，我这个是在开发板上的Linux 的 要通用点的


Question: 大神这个循环看不懂，求解释。http://blog.csdn.net/chenguolinblog/article/details/8991408

千句解释不如一句例子啊！

/* Problem Description 电子科大本部食堂的饭卡有一种很诡异的设计，即在购买之前判断余额。如果购买一个商品之前，卡上的剩余金额大于或等于5元，就一定可以购买成功（即使购买后卡上余额为负），否则无法购买（即使金额足够）。所以大家都希望尽量使卡上的余额最少。 某天，食堂中有n种菜出售，每种菜可购买一次。已知每种菜的价格以及卡上的余额，问最少可使卡上的余额为多少。    Input 多组数据。对于每组数据： 第一行为正整数n，表示菜的数量。n<=1000。 第二行包括n个正整数，表示每种菜的价格。价格不超过50。 第三行包括一个正整数m，表示卡上的余额。m<=1000。  n=0表示数据结束。    Output 对于每组输入,输出一行,包含一个整数，表示卡上可能的最小余额。 */ #include "stdafx.h" #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std;   const int N = 1010; const int MAXN = N*50;   int n , m , sum; int v[N] , dp[MAXN];   int solve(){     memset(dp , 0 , sizeof(dp));						//初始化dp数组，全部赋值为0     sort(v+1 , v+1+n);									//对数组v中的v[1]~v[n]进行排序，也就是对main函数中输入的n个数字进行排序 	for(int i = 1 ; i <= n ; i++)						//输出排序后的v[1]~v[n] 		printf("%d ",v[i]); 	printf("\n");     sum = m-5;											//以下几行需要结合题目以及解题思路理解 														//本题的解题思路是：留最贵的菜最后买，然后选择性购买其它的菜，使饭卡剩余钱数最接近5 														//所以这里的sum就是购买其它菜可以使用的钱数 														// 														// 														//     for(i = 1 ; i < n ; i++){							//从最便宜的菜开始遍历 		printf("i=%d\n",i);								//输出i，也就是第i便宜的菜         for(int j = sum ; j >= v[i] ; j--){				//v[i]就是第i便宜的菜的价格，这个循环从sum开始递减到v[i]，将j称之为剩余的钱数             dp[j] = __max(dp[j] , dp[j-v[i]]+v[i]);		//为dp数组赋值，这里算是算法的关键 														//dp[j]存储的值实际上就是当饭卡里还有j+5的钱数时，j元钱可以在前n-1个菜中消费的最大值 														//通过两层for循环实现对dp数组的赋值 														//举个例子：4种菜，价格分别2、3、5、7，饭卡剩余12元 														/*本程序的输出结果为： 															4 															2 3 5 7 															2 3 5 7 															12 															2 3 5 7 															i=1 															dp[7]=2 dp[6]=2 dp[5]=2 dp[4]=2 dp[3]=2 dp[2]=2 															0 0 2 2 2 2 2 2 															i=2 															dp[7]=5 dp[6]=5 dp[5]=5 dp[4]=3 dp[3]=3 															0 0 2 3 3 5 5 5 															i=3 															dp[7]=7 dp[6]=5 dp[5]=5 															0 0 2 3 3 5 5 7 															-2 														*/ 														//从i=1开始看，v[1]=2，饭卡里有12元，减去5，还有7元可用 														//进入内层for循环，j从7到2，对应的输出dp[7]~dp[2]的值 														//因为只有一个菜，而且一个菜只能买一次，所以dp[7]~dp[2]的值均为这个菜的价格，即v[1] 														//内层循环结束后，外层循环i++，即i=2,v[2]=3,这时表示有两个菜，而且第二个菜的价格比第一个高 														//再次进入内层循环,j从7到3,这时dp[7]~dp[3]会被重赋值 														//首先是dp[7],它的取值是当前dp[7]，也就是2，与dp[7-v[2]]+v[2]的最大值 														//dp[j-v[i]]表示先消费当前最贵的菜v[i]后,剩余的钱能花掉的最大值 														//结合例子来说，就是先花掉v[i]=3后，在前i-1个菜中还能花掉的最大值 														//这里i=2，也就是说7元，花掉3元后，还可以买第一个菜花掉2元，所以dp[7]=5 														//此处可能不理解我们明明有7元，为什么还要计算dp[6], 														//dp[6]~dp[2]都是为后面的i=3、4时计算dp[7]服务的 														//__max(dp[j] , dp[j-v[i]]+v[i])表示剩余j元钱可以花掉的最大值 														//在这两层循环过程中，dp[7]是会变化的，直到循环结束，得出剩余sum=7元时，可以花掉的最大值 			printf("dp[%d]=%d ",j,dp[j]); 		}  		printf("\n");	 		for(int k=0;k<=sum;k++) 			printf("%d ",dp[k]); 		printf("\n");     }     return m-dp[sum]-v[n];								//m是指饭卡里的钱，减去dp[sum],通过上面的计算分析可知(m-dp[sum])>5 														//(m-dp[sum])再减去最贵的菜v[n]，就是饭卡里可以剩余的最小值。 }   int main(){     while(scanf("%d" , &n) && n){					//输入一个数字n，n为0则循环终止，结合题目，n就是饭菜的种类          for(int i = 1 ; i <= n ; i++)				//循环输入n个数字，存储到数组v[1]~v[n],即n种饭菜的价格，这里没有使用v[0]              scanf("%d" , &v[i]); 		 for(i = 1 ; i <= n ; i++)					//打印输入的n个数字 			 printf("%d ",v[i]); 		 printf("\n");          scanf("%d" , &m);							//输入一个数字，结合题目，就是饭卡里剩余的钱          printf("%d\n" , m < 5 ? m : solve());		//如果饭卡里的钱m小于5，不能买任何东西，直接输出m；否则执行solve函数，并打印solve的返回值，这是一个条件表达式     }     return 0; }

引用 4 楼 zhao4zhong1 的回复:千句解释不如一句例子啊！ 很受伤，竟然没给分。

引用 1 楼 lovesmiles 的回复:这是背包问题的 解法。 那个双重循环怎么解释？

这是背包问题的 解法。


Question: 大神这个循环看不懂，求解释。http://blog.csdn.net/chenguolinblog/article/details/8991408

千句解释不如一句例子啊！

这是背包问题的 解法。


Question: 求助：C语言Windows程序设计-编译工具和使用函数

学习一下里面的例子代码：MSDN98_1.ISO  ▼     http://pan.baidu.com/s/1dDF41ix  ,MSDN98_2.ISO  ▼     http://pan.baidu.com/s/1bnGo0Vl

好的，谢谢老师，我会努力学习的~希望下次再上来我就是不一样的我了~ 我昨天发的代码本身就有问题后来问题找出来了。然后我昨天也算是把功能简单弄出来了。 感谢~


Question: 又来求大佬们解题了~~

重启系统，重启大法好

楼主的代码修改，供参考： #include<stdio.h> #include<math.h> //int flag; int present(int x) {      int i,k,flag=0;      k = (int)sqrt((double)x);       if(x <= 1)   return flag;      for (i = 2; i <= k; i++)           if (x % i == 0)           {                 flag = 0;                 break;           }      if (i > k) flag = 1;      return flag; } int main() {      int n, a, b;      int t = 0;      for (n = 10; n < 100; n++)      {          if (present(n) != 0)                              //if (flag == 0)                              //    continue;                              //else          {              t = 0;              a = n;              while(a)              {                  t = t*10 + a%10;                  a /= 10;              }                            //b = n - a * 10;                            //t = b * 10 - a;              if(present(t))                            //if (flag == 1)                  printf("%d是绝对素数\n", n);          }      }      return 0; }

感谢大佬

/tmp/ccGpTL9R.o：在函数‘present’中： 1.c:(.text+0x1c)：对‘sqrt’未定义的引用 collect2: error: ld returned 1 exit status 大佬，为啥会出现这个报错呢

math.h   这个头文件有没有加


Question: 求问大佬代码，到底哪里有问题？

不能用库函数？请考虑使用scanf从控制台输入整数字符串并得到整数变量，或是使用sscanf从字符串指针进行格式行输入。

了解一下 ASCII 码简单来说，char类型 8bits，无符号数范围 0~255ASCII 码把常用的字符转成数值，因此你需要转换才能得到或者你可以简单的写代码看看 char s[11] = "0123456789"; for(int i = 0; i < 5; ++i) {     if (s[i] != '\0') {         printf("%d ", s[i]);     } }

以及 ```c for(int i = 0; i <= 0xFF; ++i) {         printf("%c ", i); ```

懂了，感谢

供参考: #include<stdio.h> int main() {     long int i, num;     char s[10];     gets_s(s,10);     num = 0;     i = 0;     while (s[i] != '\0'){                 num = num * 10 + s[i]-'0';         i++;     }     printf("%d", num);     return 0; }


Question: 这种警告如何处理！！！！！大佬帮帮忙

销毁动态顺序表 的逻辑有问题，在检查一下

用一个临时指针变量接收realloc返回值，判断非空后，再赋值给 sq->data#define INIT_SIZE 10L #define EXPAND_SIZE 5L

这是什么IDE...warning提示都这么智能，解决方法都写出来的吗？

VS


Question: 大佬们，谁能帮帮我看看这行代码是怎么运行的？？？？

单步调试，注意观察left和right的值变化


Question: C语言printf()函数详细解说

.*    以星号代替数值，类似于width中的*，在输出参数列表中指定精度。的示例呢？


Question: 通过extern来改变全局变量的作用域

建议少用全局变量，否则项目大了以后，bug不断


Question: 关于选择排序的问题，不知道错在哪里

找到原因了，少了一段判断语句：if (array[j] < array[k]) 完整个代码如下：#include<stdio.h>int main(){    void sort(int array[], int n);    int i;    int a[10] = { 6,7,4,3,8,9,44,1,2,3 }; /* printf("请输入需要排序的整数：\n"); for (i = 0; i < 10; i++) {     scanf_s("%d", &a[i]);  } */      sort(a, 10); printf("\n"); for (i = 0; i < 10; i++) {     printf_s("%d,", a[i]); }  return 0;  }void sort(int array[], int n){    int i, j, k, t;    for (i = 0; i < n - 1; i++)    {        k = i;        for (j = i + 1; j < n; j++)         {         if(array[j]<array[k])               k = j;         }           t = array[k]; array[k] = array[i]; array[i] = t;      }  }

把段落注释的符号去掉


Question: 关于报scanf返回值被 忽略不能运行的问题

这是因为编译系统 是vs2019，而在2019中已经没有使用scanf了，而是使用scanf_s输出。 改过来就可以了


Question: 一维数组作为函数参数

#include<stdio.h> #pragma warning(disable : 4996) int main() {     float arry(float num[]);     float a[3];     int i;     float aver;     for (i = 0; i < 3; i++)     {         printf("请输入第%d个学生的成绩:",i+1);         scanf("%f", &a[i]);     }     aver = arry(a);     printf("平均成绩是：%5.2f", aver);          return 0; }  float arry(float num[]) {     float sum = 0;     float aver = 0;     int i;     for (i = 1; i < 3; i++)     {         sum = sum + num[i];     }     aver = sum / 3;     return aver; }


Question: 关于 lame pcm转化MP3 音频 发现声音和原始的pcm比较变小了，请高手指点下

lame_set_brate(lame, 32);这个函数不是设置位深度的, 而是设置比特率的, 取值128~320(kbps)

哦，原来是这样啊，我没用过，看着注释里面说得有鼻子有眼的我就信了。

我也不太清楚哦, 百度好像是这样的

降低一下比特率试试？16位就够了。


Question: C语言逻辑运算符(&&和||)的短路求值知识

第一个逻辑与判断第一个表达式为假了，后面的就不会执行

不错，长知识了。

了解短路机制就好了...短路求值这种，debug都不好找问题的写法，最好不要出现在代码里

短路求值是个知识点


Question: 来个大佬指点下，卡了个下午，还是没搞懂

i是你得到的字符串长度啊，返回它用来下面进行比较，不是很舒适么？你得区分表达式和声明，这个printf后面的括号里的是表达式，如果带着方括号，就是在表示单个字符了。

多谢指教，不过还是有点没搞懂，字符串长度不是保存在s[i]里面吗，他返回 i 的话不是只返回了第几行吗？

仔细看了下，是我理解错了，懂了，谢谢大佬

还有printf为啥不加【】啊?这是C语言 字符串基础，longest在这里代表字符串首地址，%s打印算从首地址到结束符的内容。另外longest使用前最好memset,置空。

我现在还写不出这么简洁的程序，这是C程序语言设计里面的一道例题所以说为啥返回 i 啊，还有printf为啥不加【】啊

MAXLINE应设为32767比较保险，因为超过1000太容易了

Hi，这不是你自己写的吗？  循环扫描文件时max在记录最长那行的字符数，longest记录最长的行内容。


Question: 碰到一个指针方面的问题，求解答。

printf("*b = %d\n", *b);   //9975 printf("*b++ = %d\n", *b++);    //== *(b++) 中++优先级高于* 但是b++是后计算 所以是 9975 然后指针+1指向未知空间 printf("(*b)++ = %d\n", (*b)++);  //上一步 *(b++) 已经计算 指向未知空间 乱码 printf("*(b++) = %d\n", *(b++));   //同上乱码  // printf("*b = %d\n", *b);   //9975     // printf("*b++ = %d\n", *b++);    //== *(b++) ++优先级高于* 但是b++是后计算 所以是 9975     printf("(*b)++ = %d\n", (*b)++);  //9975 *b先输出9975 然后 *b = 9976     printf("*(b++) = %d\n", *(b++));   //9976  *b指向值为9976

感谢解答

printf("*b = %d\n", *b);// *b = 取值 9975     printf("*b++ = %d\n",*b++);//先取值：*b = 9975 ,再b地址加1, b++,这条执行完 b就不指向a了      printf("(*b)++ = %d\n", (*b)++);//取值*b , 然后值加 1 ，b 已经不指向a 了，所以就是一个乱值     printf("*(b++) = %d\n", *(b++));//这里和上一条相同，看不懂的一个值

感谢解答。


Question: Creating new notebook in Bad file descriptor (bundled\zeromq\src\epoll.cpp:100)创建文件错误问题

请问你现在输入jupyter notebook能直接跳转到网页吗

请问你现在解决了吗？我也遇到了这个问题

解决了，原来是我的C盘用户名设置成中文导致的，改成英文就好了

请问如何更改？急


Question: 求助 为什么突然出现断点了

The  realloc()  function changes the size of the memory block pointed to by ptr to size bytes.  The contents will be unchanged in the range from the start of the region up to the minimum of the old and new sizes.  If the new size is larger than the old size, the added memory will not be  initialized.   If ptr is NULL, then the call is equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call is equivalent to free(ptr).  Unless ptr is NULL, it must have been returned by an earlier call to malloc(), calloc(),  or  realloc().   If  the area pointed to was moved, a free(ptr) is done.The  realloc()  function  returns a pointer to the newly allocated memory, which is suitably aligned for any built-in type and may be different from ptr, or NULL if the request fails.  If size was equal to 0, either NULL or a pointer suitable to be passed to  free()  is  returned.   If  realloc()  fails, the original block is left untouched; it is not freed or moved. realloc 之后，你应该free的是 p1，而不是 p 了

太感谢了


Question: 求助，找子序列的算法

//用C语言实现：给定SJPDMFLJDDMFLJPDMFJNDMKL序列。查找JPDMFL（六个字符中最多只能有一个不同） #include <stdio.h> #include <string.h> int main() {     char *s="SJPDMFLJDDMFLJPDMFJNDMKL";     char *f="JPDMFL";     int L=strlen(s);     int M=strlen(f);     int i;     int j;     int c;      printf("%s\n",s);     for (i=0;i<L-M;i++) {         c=0;         for (j=0;j<M;j++) {             if (f[j]==s[i+j]) c++;         }         if (c>=M-1) {             for (j=0;j<i;j++) printf(" ");             printf("%s\n",f);         }     }     return 0; } //SJPDMFLJDDMFLJPDMFJNDMKL // JPDMFL //       JPDMFL //             JPDMFL //

感谢大佬，一下就懂了


Question: c语言国家二级练习题库

国家二级c语言真题练习 (^_^)


Question: 小白求解.

因为编译器不知道你前面有strstr(buf, flag) != NULL的判断，怕运行出错，所以给出了警告，既然你前面已经有了判断，就可以忽略这个警告了如果有强迫症，可以按楼上的改一下

改成这样试试：     char* s;     if ((s=strstr(buf, flag)) != NULL) {          fputs(s, out);      }


Question: Docker 服务之间是如何通信的呢？指定服务端口的背后隐藏了哪些秘密？带你揭秘 Docker 网络的神秘面纱！

ss


Question: 自定义函数指针传参，数值传参

看了半天终于发现错误，定义时 /** 将串str中的oldStr替换成newStr */ Status Replace_HeapString(Hstring * str, Hstring oldStr, Hstring newStr);  而调用时 Replace_HeapString(str1, &str5, &str4);  调用错误，改成Replace_HeapString(str1, str5,str4)即可，原定义的参数2和参数3要求的是传入Hstring类型的值，而我错误的传入了它们的地址，该死

#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！ #include <stdio.h> #include <malloc.h> #include <string.h> enum Status {OK,ERROR}; /** 串的堆式顺序存储结构（heap）*/ typedef struct hstring {     char * ch;     int length; }Hstring; int Index_HeapString(Hstring *str,Hstring *findstr,int start) {     int i;     for (i=start-1;i<str->length - findstr->length;i++) {         if (0==strncmp(str->ch+i,findstr->ch,findstr->length)) return i+1;     }     return 0; } /** 将串str中的oldStr替换成newStr */ Status Replace_HeapString(Hstring * str, Hstring oldStr, Hstring newStr) {     int i,index;     if(!str || oldStr.length!=newStr.length)         return ERROR;     index = Index_HeapString(str, &oldStr, 1);     if(index && index <= str->length)     {         for(i = 0; i < newStr.length; i++)         {             str->ch[index - 1 + i] = newStr.ch[i];         }         return OK;     }     return ERROR; } void StrAssign(Hstring *str,const char *val) {     str->ch=(char *)val;     str->length=strlen(val); } void PrintString(Hstring *str) {     printf("%.*s\n",str->length,str->ch); } int main() {     Hstring * str1 = NULL;     Hstring str4;     Hstring str5;     str1 = (Hstring*)malloc(sizeof(Hstring));     //为str1赋值     StrAssign(str1, "helloword");     //为str4赋值     StrAssign(&str4, "eee");     //为str5赋值     StrAssign(&str5, "llo");     //将串str1中的"llo"替换成"eee"     Replace_HeapString(str1, str5, str4);     PrintString(str1); //heeeeword     free(str1);     return 0; }


Question: 求大神帮我看下printf函数有什么问题？

不要迷信书、考题、老师、回帖；要迷信CPU、编译器、调试器、运行结果。并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

供参考：C语言中，char 和 int 的区别？


Question: 求大神帮我看下scanf函数有什么问题？

Aa回车

供参考：scanf （计算机语言函数）


Question: 一个严肃的问题

不要老是加夜班，长发短发都无所谓

脱发不都是肾的错,脾胃不好也会脱发,用白纸贴头上看看是否有很多油可判断.

我自觉出去

短发，天天洗头，保证有效果

多吃枸杞少熬夜

南辕北辙？舍本逐末？舍弃自家宝贝不用，怨天尤人何益！发为血之余。

何为自家宝贝

自家宝贝分2说，1为中华瑰宝中医中药2为自身五脏六腑健康，可笑的是有些论调程序员要打字飞快才算是程序员？未知打字打得飞快能产生几何效益？以至于挖空心思加班加点损伤血气，不知劳逸结合及顾护身心健康，受尽苦难皆属咎由自取。

说实在的，不喜欢严肃，更喜欢严谨，因为中医就是以配伍严谨为特色从慈悲情怀，所谓医者父母心。

半秃的长发，参考banana大师～～～

作为程序猿，想必数学都不错，那么就好说了，每个抽样行为都是独立的，整体的概率对于个体的预测其实并没有什么用。脱了就是脱了，不脱就是不脱。就像彩票一样。


Question: 蓝桥杯汉诺塔问题 求大佬帮忙看看

汉诺塔问题为什么不用递归程序做呢。 #include <stdio.h>  void move(int n, char src, char tmp, char dst){     if(n == 1){         printf("%c -> %c\r\n", src, dst);         return;     }else{         move(n-1,src,dst,tmp);         move(1,src,tmp,dst);         move(n-1,tmp,src,dst);     } }  int main(){          int n = 6;     char src = 'a', tmp = 'b', dst = 'c';          move(n,src,tmp,dst);          return 0; }


Question: 请问各位大佬代码的{}怎么写？

节省空间应该是指减少行数，不是文件大小，因为早期的显示器分辨率低，每屏只能显示25行甚至十几行，所以才有了K&R风格这种无奈的选择

只在C系语言中看到过后一种。目前大多数语言（包括C语言在linux下的主流）格式化工具使用的是第一种。感觉没什么差别。不过部分特殊的编译器可能不认可某一种格式。比如CCS中只有一行的函数会报错，改成第二种写法就没问题，不是bug就是执念。

为了节省空间大可不必，像JS这种需要下载源码到本地运行的脚本语言才需要压缩空间，这种一般都在写好之后把所有代码压缩成一行。

嗯嗯

参考下面自成一派的风格，供大家吐槽和膜拜： //定义下面5种运算顺序： // ((A @   B) @  C)  @ D  = //  (A @   B) @ (C   @ D) = //  (A @  (B  @  C)) @ D  = //   A @ ((B  @  C)  @ D) = //   A @  (B  @ (C   @ D))= //23.99<计算结果<24.01 //其中： //1≤A、B、C、D≤13 //@为“+、-、*、/”之一 //用浮点数计算，循环遍历以上所有情况即可。 #include <stdio.h> #define when break;case int A,B,C,D,N; float r,r1,r2; char op1,op2,op3; char opc[4]={'+','-','*','/'}; void main() {     N=0;     for (A  =1;A  <=13;A  ++) {     for (B  =1;B  <=13;B  ++) {     for (C  =1;C  <=13;C  ++) {     for (D  =1;D  <=13;D  ++) {     for (op1=0;op1<  4;op1++) {     for (op2=0;op2<  4;op2++) {     for (op3=0;op3<  4;op3++) {         // ((A @   B) @  C)  @ D         r=(float)A;         switch (op1) {case 0:r =r +B ;when 1:r =r -B ;when 2:r =r *B ;when 3:                                      r =r /B ;break;}         switch (op2) {case 0:r =r +C ;when 1:r =r -C ;when 2:r =r *C ;when 3:                                      r =r /C ;break;}         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         if (23.99f<r && r<24.01f) {N++;printf("%5d: ((%2d %c   %2d) %c  %2d)  %c %2d  =24\n",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //  (A @   B) @ (C   @ D)         r1=(float)A;         switch (op1) {case 0:r1=r1+B ;when 1:r1=r1-B ;when 2:r1=r1*B ;when 3:                                      r1=r1/B ;break;}         r2=(float)C;         switch (op3) {case 0:r2=r2+D ;when 1:r2=r2-D ;when 2:r2=r2*D ;when 3:                                      r2=r2/D ;break;}         switch (op2) {case 0:r =r1+r2;when 1:r =r1-r2;when 2:r =r1*r2;when 3:if (-0.01f<r2 && r2<0.01f) goto STEP3;r =r1/r2;break;}         if (23.99f<r && r<24.01f) {N++;printf("%5d:  (%2d %c   %2d) %c (%2d   %c %2d) =24\n",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //  (A @  (B  @  C)) @ D     STEP3:         r=(float)B;         switch (op2) {case 0:r =r +C ;when 1:r =r -C ;when 2:r =r *C ;when 3:                                      r =r /C ;break;}         switch (op1) {case 0:r =A +r ;when 1:r =A -r ;when 2:r =A *r ;when 3:if (-0.01f<r  && r <0.01f) goto STEP4;r =A /r ;break;}         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         if (23.99f<r && r<24.01f) {N++;printf("%5d:  (%2d %c  (%2d  %c  %2d)) %c %2d  =24\n",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //   A @ ((B  @  C)  @ D)     STEP4:         r=(float)B;         switch (op2) {case 0:r =r +C ;when 1:r =r -C ;when 2:r =r *C ;when 3:                                      r =r /C ;break;}         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         switch (op1) {case 0:r =A +r ;when 1:r =A -r ;when 2:r =A *r ;when 3:if (-0.01f<r  && r <0.01f) goto STEP5;r =A /r ;break;}         if (23.99f<r && r<24.01f) {N++;printf("%5d:   %2d %c ((%2d  %c  %2d)  %c %2d) =24\n",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}          //   A @  (B  @ (C   @ D))     STEP5:         r=(float)C;         switch (op3) {case 0:r =r +D ;when 1:r =r -D ;when 2:r =r *D ;when 3:                                      r =r /D ;break;}         switch (op2) {case 0:r =B +r ;when 1:r =B -r ;when 2:r =B *r ;when 3:if (-0.01f<r  && r <0.01f) continue  ;r =B /r ;break;}         switch (op1) {case 0:r =A +r ;when 1:r =A -r ;when 2:r =A *r ;when 3:if (-0.01f<r  && r <0.01f) continue  ;r =A /r ;break;}         if (23.99f<r && r<24.01f) {N++;printf("%5d:   %2d %c  (%2d  %c (%2d   %c %2d))=24\n",N,A,opc[op1],B,opc[op2],C,opc[op3],D);}     }//op3     }//op2     }//op1     }//D     }//C     }//B     }//A } //运行结果： //    1: (( 1 +    1) +   1)  *  8  =24 //    2:  ( 1 +  ( 1  +   1)) *  8  =24 //    3:  ( 1 +    1) * ( 1   + 11) =24 // ... ... //53280:  (13 +   13) / (13   / 12) =24 //53281:  (13 -  (13  /  13)) + 12  =24 //53282:   13 - ((13  /  13)  - 12) =24

老湿的新作

不是新作，是老作品，但开了点新花。原帖在这里：https://bbs.csdn.net/topics/380157851?spm=1001.2014.3001.6377

难怪这么眼熟，原来的帖子又看得到了，不错

K&R风格是历史遗留，目前来说属于垃圾～～～

去查了一下，原来还有k&r和ms这么一回事~~~

比用什么风格更重要的是在任何地方，任何时候都坚持用一种风格。比爱哪种美眉更重要的是在任何地方，任何时候都坚持爱一个美眉。

不愧是老湿

这个不用问大佬，你试一下就知道了

以前习惯换行，现在发现另一种节省空间，代码会短很多，现在正在转变

节省的只是表面的空间，对整个代码内存方面没有任何影响，其实这个主要还是取决于你以后工作的地方他的标准，没工作之前你觉得哪个方便就用哪个就是了

这两种你喜欢哪个就用哪个。编译器把源代码也是当作字符流的，并不以行为单位理解源代码。

嗯嗯


Question: 取结构体中数组中的数值

什么原因？

好的，谢谢您，已经找到相关资料啦

敢为题主解决了吗

可以搜索一下总线错误或者对齐错误，学习一下。字数较多，就不贴了。


Question: 根据输入的二叉树后序序列（以单个字符作为一个结点的信息）和中序序列，来构造一棵二叉树，然后输出该树的前序序列，以及该树中所有度为1的结点。

仅供参考： #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

这不是根据先序和中序找后序吗


Question: 有人愿意做Linux嵌入式系统下C/C++的兼职开发吗？

均已私信联系~顺便补充一下，我们研发团队坐标北京。希望开发者前期有时间到北京交流，并且有些项目需要在北京常驻1-2月~

怎么联系？

拿来吧你

怎么联系？

已私信


Question: pta 乙级1025 小白求助

数组长度最大值#define maxsize 100000超限了。


Question: Socket错误

服务器端没有bind 地址信息，也listen端口，设置监听队列，客户端如何connect服务器？ Linux C for TCP服务器参考     int listenfd = socket(AF_INET, SOCK_STREAM, 0);      struct sockaddr_in sin;     bzero(&sin, sizeof(sin));     sin.sin_family = AF_INET;     sin.sin_addr.s_addr = INADDR_ANY; /* 本地所有IP地址 */     sin.sin_port = htons(port);      if (bind(listenfd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {         perror("bind error");         exit(1);     }      if (listen(listenfd, 10) < 0) {         perror("listen error");         exit(1);     }  while (1) {   struct sockaddr_in cliaddr;   socklen_t clilen = sizeof(cliaddr);   int connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen); ... }

SOCKADDR_IN clientAddr  改为 struct sockaddr_in clientAddr;


Question: 使用socket作为图片服务器，直接在HTML中显示图片，该如何操作呢？

按字节拷贝，灵活使用指针


Question: 大佬们 c语言单行文本输入咋搞啊

链接标题谢谢啊  不过可以有可视化的文本输入框 就类似于qt那种控件吗？ 谢谢大佬们

#include <stdio.h> #include <string.h> int main() {   char ln[1024];   fgets(ln,1024,stdin);   if (ln[strlen(ln)-1]=='\n') ln[strlen(ln)-1]=0;   printf("[%s]\n",ln);   return 0; }

char a[1024];    gets_s(a,1024);    puts(a);


Question: 有没有大佬有C语言的练习题，跪求！

有不少刷题网站什么PTA计蒜客一大堆高级一点的leetcode牛客

C语言教程（附带C语言100例）▼

在本网站下载里搜  C语言的练习题  啊


Question: scanf混合输入问题

原来你month输入的是三个英文字母的缩写JAN,FEB,MAR,...，我原以为是01,02,03,... 那你改成 char month[4]; ...-%3[^-]-... 另外，scanf是给char[]用的，cin是给string用的。你要想用scanf输入string,可以先输入到char[],再将char[]转换为string

老师你太强了，等于说用scanf的话必须先规定长度，太猛了老师

我还有个问题就是，数组长度为啥要有4位

要留末尾0的存储空间

供参考： #include<iostream> #include<map> #include<string> using namespace std;  int main() {     int    year=0,day=0;     string month(11,0);//string类的构造函数     scanf("%d-%[^-]-%d",&year,month,&day);     cout<<year<<endl;     cout<<month<<endl;     cout<<day<<endl;     return 0; }

试了一下，这样布星啊哥哥

char month[3]; scanf("%d-%2[^-]-%d",...

谢谢老师！我尝试了可以，但是想用string可以吗？

而且%2会漏掉一个字符，如果去掉2的话会多一个框框，老师这是咋回事

scanf("%d-%[^-]-%d", &year, month, &day);   试试这样，month是string类型，本身就是地址了，因此不需要再加&了。

我试了一下，这样布星，同学


Question: 求求大神帮我看下3个数比大小有什么问题？

供参考： #include<stdio.h> int main() {     int a,b,c;     void sort(int *x,int *y,int *z);     printf("Please enter three numbers:\n");     scanf("%d%d%d",&a,&b,&c);     sort(&a,&b,&c);     printf("%d %d %d\n",a,b,c);     return 0; }  void sort(int *x,int *y,int *z) { int temp;     if(*x<*y)     {     temp=*x;     *x=*y;     *y=temp;     }     if(*x<*z)     {     temp=*x;     *x=*z;     *z=temp;     }     if(*y<*z)     {     temp=*y;     *y=*z;     *z=temp;     } }

请问我的错在哪儿？

sort()函数里，交换位置，不能是对值的操作，对值的操作作用范围就在函数体内，函数运行结束返回主函数后，a b c 的值并没有被改变。必须是对地址的操作才能起作用。

好的，谢谢大神！


Question: 怎么在cmake的配置文件里加入-ldl编译选项


Question: 今天尝鲜CLion 2021.2 ，结果。。。。

改成c++的cout试试？

不会C++，刚接触C，小白一枚

原因：printf使用了缓存buffer 解决方案： fflush(stdout);：强制刷新（建议）setbuf(stdout, NULL);：禁用缓存（不建议）

有其他解决办法吗？每次加一行代码好麻烦啊


Question: 美团酒店点评如何获取orderID？

解决了吗


Question: 有人愿意做嵌入式软件Linux C的兼职开发吗

有   可以加微信聊 630084664

自己顶一下~


Question: 嵌入式linux c 协议栈 坐标北京 有兼职的吗？

都是紧急的么

目前有个紧急的项目 后续项目看情况  需要现场沟通


Question: code blocks 调试器结束，其状态码是1

你用的codeblocks没有调用栈信息吗？我用codelite，按F5开始调试，如果报错就会有调用栈的错误信息，基本上都能定位到报错的一行，除非很诡异的https://codelite.org/,有黑色主题


Question: C语言编译生成的可执行文件自动退出，怎么排查问题呢？

应该写个日志文件，这样才能通过日志文件查找问题。

用codelite，按F5运行如果报错有调用栈直接定位到报错行，

StackWalker

自己加尽量详细的日志


Question: C语言编写的可执行文件怎么添加附加信息？


Question: C语言中的feturn相关问题

错。return语句的作用是结束当前函数的执行，且当前函数如果有返回值的话，return后面要跟返回值。

好的谢谢您，么么哒


Question: 利用红外扫描实现循迹的小车，遇到这种情况的直角转弯，该如何编写程序

传感器的前探测距离肯定不会刚好大于与出头的那点黑胶带的长短。增加一个保存转弯点的转向选择的变量，继续按直线前进，没路了再退回来，再根据前面转弯选项转弯，继续探路，只能这样。三岔口、五岔口、多岔口，都只能挨个探索，不行了退回来。

为什么黑胶带要出头？改为圆角是不是好走一些

老师设的卡

那就问老师。解铃还须系铃人。


Question: 各位大佬大家好,入门小弟有一个不会的程序请大佬,帮忙解答

#include<stdio.h>int main(){  int sum=0;  for(i=1;i<=100;i++)  {    sum+=i;  }  return 0;}

#include<stdio.h>int main(void){    int n, sum;    sum = 0;    n = 100; while (n> 0) {     sum = sum + n;     n--; } printf("1+....+100=%d", sum);  return 0;  }

谢谢

#include<stdio.h>  int main() {     int i,s=0;     for(i=1;i<=100;i++)s+=i;     printf("s(1+2+3+4+5+6.......+100)=%d\n",s);     return 0; }

学习的书上没代码例子？int a=0,aa=1;while(aa<=100)a+=aa++;std::cout<<a<<std::endl;


Question: C语言printf打印指针地址疑惑-运行环境win10 64位系统

实际中一般不这么搞，你只要知道这种情况和具体的编译器有关即可。

关于C,C++表达式求值顺序(转)关于C,C++表达式求值顺序

不同的编译器，不同的结果。 (int *)p + 1  强制类型转换了。


Question: pta的一道题，有点不明白，最后一个测试点发生浮点错误

这个题目是什么？

一个可能是在特定平台上的测试用例中，累成溢出，但是每一步进行公约后可以保证中间结果没有溢出


Question: MacOS平台中，获取执行文件目录路径错误，该如何正确获取路径呢？

char path[256] = { 0 }; getcwd(path, sizeof(path)); strcat(path  , "/a.txt");

a.txt改成./a.txt 看看

试过了，不行


Question: 相同的数据，Int 强转 Byte 竟然出现了不同的结果！这背后到底隐藏了什么秘密 —— 数据大小端存储》, 一起来围观吧 https://blog.csdn.net/qq_34417408/article/details/118877959?utm_so

原来是付费专栏的广告。

付费？不存在的


Question: （已解决）ReadDirectoryChangesW 监听目录 丢失消息的问题

试试每秒创建、拷贝或删除100个文件


Question: 将该文件代码改成 任意两个高次多项式的相加与相减

C++实现任意次元的多项式加法，以及输入输出重载，以及内存管理。Polynominal.h // // Created by Alone on 2021/9/23. //  #ifndef UNTITLED46_POLYNOMINAL_H #define UNTITLED46_POLYNOMINAL_H #include <iostream> //@Node结构体--作为表达式存储的对象 struct Node {     double factor;     int exp;     Node *next;      Node(double x, int y, Node *p = nullptr) : factor(x), exp(y), next(p) {}     //静态方法方便调用     static void swap(Node *a, Node *b) {//仅仅交换数据，不交换指针         std::swap(a->factor, b->factor);         std::swap(a->exp, b->exp);     } }; //@Polynominal类声明 class Polynominal {     Node *head;      friend std::istream &operator>>(std::istream &in, Polynominal &a);      friend std::ostream &operator<<(std::ostream &out, Polynominal &a);      friend std::ostream &handle_one(std::ostream &out, Node &node);  public:     Polynominal &operator+(Polynominal &b);      void Insert(double x, int y);      Polynominal() { //缺省构造         head = new Node(0, -1);//构建一个结点作为头结点，方便头插     }      Polynominal(double x, int y);//带参构造      ~Polynominal(); };  #endif //UNTITLED46_POLYNOMINAL_H  Polynominal.cpp // // Created by Alone on 2021/9/23. //  #include "Polynominal.h" //@Polynominal类定义 //@关键的Insert函数实现 void Polynominal::Insert(double x, int y) {     Node *t = new Node(x, y);     t->next = head->next; //头插法插入     head->next = t;     Node *pre = head;     while (t != nullptr && t->next != nullptr) {//进行偷天换日，把指数大的放在前面         if (t->exp < t->next->exp) {//指数大的放在前面             Node::swap(t, t->next);         } else if (t->exp == t->next->exp) {//指数相等时直接加和得到一个表达式             Node *tmp = t->next;             tmp->factor += t->factor; //相等时，只加上系数即可             delete t;             pre->next = tmp;             t = pre;             break;//这种直接找到相等的就处理完了         } else {             break;//如果比它大位置就已经是正确的了         }         pre = t;         t = t->next;     } } Polynominal::Polynominal(double x, int y) {     head = new Node(0, -1);//构建一个结点作为头结点，方便头插     Insert(x, y); } //@重载'+'运算符：利用Insert成员函数实现两个Polynominal类的相加 Polynominal &Polynominal::operator+(Polynominal &b) {     Node *t2 = b.head->next;     while (t2 != nullptr) {         Insert(t2->factor, t2->exp);         t2 = t2->next;     }     return *this; } //@输入操作重载 std::istream &operator>>(std::istream &in, Polynominal &a) {     double x;     int y;     while (1) {         std::cout << "input a term(coef[double],exp[int]):->Until the end of the input 0 to coef" << std::endl;         in >> x >> y;         if (x == 0)             break;         a.Insert(x, y);     }     std::cout << "The polynomial is established successfully!" << std::endl;     return in; } //@输出操作重载 // --直接重载前，先写一个单个式子处理函数，方便后面处理中间的符号 std::ostream &handle_one(std::ostream &out, Node &node) {     out << node.factor;     switch (node.exp) { //根据指数的不同情况进行打印         case 0:             break;         case 1:             out << "X";             break;         default:             out << "X^" << node.exp;             break;     }     return out; }  std::ostream &operator<<(std::ostream &out, Polynominal &a) {     out << "the polynominal is: ";     Node *t = a.head->next;     if (t == nullptr)         return out << "null";     handle_one(out, *t);     t = t->next;     while (t != nullptr) {         out << "+";         handle_one(out, *t);         t = t->next;     }     out << '\n';     return out; } //@对链表内存的析构 Polynominal::~Polynominal() {     Node *t = head;     while (t != nullptr) {         Node *cur = t;         t = t->next;         delete cur;     } }

看看Insert函数的实现就行，减法和加法是一样的，乘法和除法需要作出较大的改变

仅供参考： //链表实现一元多项式的加法减法乘法 #include <stdio.h> #include <stdlib.h> typedef struct node {     float coef;   //系数     int expn;     //指数     struct node *next; } PolyNode;      //多项式节点 polynomial node typedef PolyNode* Polynomial; Polynomial createPolynomial() {  //创建多项式     PolyNode *p, *q, *head = (PolyNode *)malloc(sizeof(PolyNode));   //头节点     head->next = NULL;     float coef;     int expn;     printf("输入该多项式每一项的系数和指数，每项一行，输入0 0结束！\n");     while (scanf("%f %d", &coef, &expn) && coef) {   // 默认，按指数递减排列         if (head->next) {             p = head;             while (p->next && expn < p->next->expn)                 p = p->next;             if (p->next) {                 if (expn == p->next->expn) { //有相同指数的直接把系数加到原多项式                     p->next->coef += coef;                     if (p->next->coef > -0.000001 && p->next->coef < 0.000001) { //若是相加后系数为0，则舍弃该节点                         q = p->next;                         p->next = q->next;                         free(q);                     }                 } else {                     q = (PolyNode*)malloc(sizeof(PolyNode));                     q->coef = coef;                     q->expn = expn;                     q->next = p->next;                     p->next = q;                 }             } else {                 p->next = (PolyNode*)malloc(sizeof(PolyNode));                 p = p->next;                 p->coef = coef;                 p->expn = expn;                 p->next = NULL;             }         } else {             head->next = (PolyNode*)malloc(sizeof(PolyNode));             head->next->coef = coef;             head->next->expn = expn;             head->next->next = NULL;         }     }     return head; } Polynomial multiply(Polynomial poly, float coef, int expn) {  //多项式与指定单项式相乘，该单项式为 coefx^expn     PolyNode *p, *q, *Poly = (PolyNode*)malloc(sizeof(PolyNode));     p = Poly;     q = poly->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = (q->coef*coef);         p->expn = (q->expn + expn);         q = q->next;     }     p->next = NULL;     return Poly; } void add(Polynomial poly1, Polynomial poly2) {  //把 poly2 加到 poly1 上     PolyNode *p, *q, *r;     r = poly1;     p = poly1->next;  //指向第一个节点     q = poly2->next;     poly2->next = NULL;     while (p && q) {         if (p->expn > q->expn) {             r->next = p;             p = p->next;             r = r->next;         } else if (p->expn < q->expn) {             r->next = q;             q = q->next;             r = r->next;         } else {             PolyNode *t;             p->coef += q->coef;             if (!(p->coef > -0.000001 && p->coef < 0.000001)) //系数不为0             {                 r->next = p;                 r = r->next;                 p = p->next;             } else {                 t = p;                 p = p->next;                 free(t);             }             t = q;             q = q->next;             free(t);         }     }     if (p)         r->next = p;     if (q)         r->next = q; } Polynomial polySubtract(Polynomial poly1, Polynomial poly2) {  //多项式减法 poly1-poly2形成一个新的多项式     //把poly2的系数取相反数，形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode)); //构造头节点     PolyNode *p, *q;     p = poly;     q = poly2->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = -(q->coef);  //系数取反         p->expn = q->expn;         q = q->next;     }     p->next = NULL;     add(poly, poly1);  //利用加法     return poly; } Polynomial polyAdd(Polynomial poly1, Polynomial poly2) { //多项式相加 poly1+poly2形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //和多项式的头节点     poly->next = NULL;     PolyNode *p, *q, *r;     r = poly;     p = poly1->next;     q = poly2->next;     while (p&&q) {         if (p->expn > q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = p->coef;             r->expn = p->expn;             p = p->next;         } else if (p->expn < q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = q->coef;             r->expn = q->expn;             q = q->next;         } else {             float m = p->coef + q->coef;             if (!(m > -0.000001 && m < 0.000001)) {                 r->next = (PolyNode*)malloc(sizeof(PolyNode));                 r = r->next;                 r->coef = m;                 r->expn = p->expn;             }             q = q->next;             p = p->next;         }     }     while (p) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = p->coef;         r->expn = p->expn;         p = p->next;     }     while (q) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = q->coef;         r->expn = q->expn;         q = q->next;     }     r->next = NULL;     return poly; } Polynomial polyMultiply(Polynomial poly1, Polynomial poly2) {  //多项式相乘     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //创建多项式和的头节点     poly->next = NULL;     PolyNode *p;     p = poly2->next;     while (p) {         add(poly, multiply(poly1, p->coef, p->expn));         p = p->next;     }     return poly; } void printPoly(Polynomial poly) {  //打印多项式     if (poly && poly->next) {         PolyNode *p = poly->next;  //p指向第一个节点         while (p->next) {             printf("%gx^%d", p->coef, p->expn);             p = p->next;             if (p && (p->coef > 0))                 printf("+");         }         if (p->expn == 0)             printf("%g", p->coef);   //打印常数项         else             printf("%gx^%d", p->coef, p->expn);         printf("\n");     } else {         printf("0\n");     } } void freePoly(Polynomial poly) {  //释放内存     if (poly && poly->next) {         PolyNode *p, *q;         p = poly;         while (p) {             q = p->next;             free(p);             p = q;         }     }     poly = NULL; } int main() {     printf("用链表实现多项式的加减法\n");     Polynomial poly1, poly2, poly3;     printf("创建多项式一\n");     poly1 = createPolynomial();     printf("多项式一：\n");     printPoly(poly1);     printf("创建多项式二\n");     poly2 = createPolynomial();     printf("多项式二：\n");     printPoly(poly2);     printf("两多项式相加，和为：\n");     poly3 = polyAdd(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两个多项式相乘，积为：\n");     poly3 = polyMultiply(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两多项式相减，差为：\n");     poly3 = polySubtract(poly1, poly2);     printPoly(poly3);     freePoly(poly1);     freePoly(poly2);     freePoly(poly3);     system("pause");     return 0; }


Question: C语言编写的程序，编译生成的可执行程序无法双击运行

在CentOS平台中，可使用desktop文件实现双击执行

一般都是从控制台启动

我都是点右键，选运行


Question: settimeofday 在ubuntu20.04系统中执行总是返回失败，错误码无效的参数

需要root权限？


Question: DEV C++下古怪的二维堆数组

再次对这个问题进行研究,发现是我理解错误.语句:TYPE (Array)[x]=(TYPE ()[Array[x]])malloc(y*z);可以正常使用.语句中的x值是二维数组的第二个下标,而我理解成了第一个下标了.惭愧!

TYPE为unsigned char,z为1


Question: C Primer 第十章 图10.4关于指针递增的图，那地址位数是不是错了？

图的右侧明确了指针ptr1占用0c00  0c01共2个地址，所以它是个2字节指针。鉴定完毕。 但指针本身占几个字节和指针目标占几个字节确实不相关。

但原书上明确说了这是一个int数组

关注一下作者写这个的年代，若是1995年以前提起int大概率都是2字节的。

ptr1虽然是个占用了4字节空间的指针，但*ptr1存储的数据不见得是4字节数据，可能只是2字节short数据，亦可能是8字节double数据。ptr1++之后的ptr1值视其所指向空间的数据类型而定。若是ptr1是short *类型，那么ptr1++之后，就会是从00dc变为00de。

不是吧，指向空间的大小在指针定义的时候应该就是确定好的，不可能根据里面的数据类型改变，那还不乱了套了

“指向空间的大小在指针定义的时候应该就是确定好的”，这句话是没错的，所以我说“ptr1++之后的ptr1值视其所指向空间的数据类型而定”。但是这不等于说指针本身是4个字节就意味着指针指向的空间也是4字节数据类型。你的问题并没有描述ptr1是哪种类型的指针，如果是short类型，那么指针指向的数据就是只有2字节，所以ptr1++之后的结果是新的ptr1只变化了2字节。

16进制中，两个字符是一个字节，一个字符的话，是一个字节。 例如：A是一个字节，AA是一个字节，AAA是两个字节，AAAA是两个字节  AAAA AAAA 四字节

明白了，这是一种简化的地址表示方法，谢谢！


Question: 求帮助，习题7-2 求一批整数中出现最多的个位数字 (20 分)

用0-9的10个数字数组统计是个好方法，统计方面可参https://ask.csdn.net/questions/912419最后遍历一下数组求最大值，再用最大值输出是那些数即可。

换种思路，供参考： #include<stdio.h>  int main() {     int  a[10]={0},n,m,i;     scanf("%d",&n);     while(n){             scanf("%d",&m);             while(m){                     a[m%10]++;                     m /= 10;             }             n--;     }     m = a[0];     for(i=0;i<10;i++)         if(m<a[i]) m=a[i];     printf("%d:",m);     for(i=0;i<10;i++)         if(a[i] == m)            printf(" %d",i);     return 0; }

至少你的a数组不够大。


Question: 我想问一下程序运行后只输出个0

这个函数有问题： bool initlist(linklist l) {     l=(lnode *)malloc(sizeof(lnode));     if(l==NULL){         return false;     }     l->next=NULL;     return true; }  你的本意是初始化链表头节点，为头节点分配空间，但是C/C++语言函数是传值的，在函数内部对形参赋值并不会改变形参的值，所以l=(lnode *)malloc(sizeof(lnode));这条语句并没有真正影响l的值，而是修改了l在栈中的副本。当你调用bool res = initlist(l);试图初始化l时，l的值其实并未被改变。可以改成这样： bool initlist(linklist *l) {     *l=(lnode *)malloc(sizeof(lnode));     if((*l)==NULL){         return false;     }     (*l)->next=NULL;     return true; }  bool oinitlist(linklist *l) {     *l=NULL;     return true; }  然后：bool res = initlist(&l);

没有问题呀。


Question: 怎么打开浏览器，访问指定网页？

firefoxsafari

system是执行命令行的工具，你在命令行怎么敲，在这儿就怎么敲。我的意思是，具体的文件名你不说别人也不知道，你得自己找。


Question: 各位大佬们，这是为啥运行不出结果呢？

要把自己写的代码当作别人写的代码，然后开始读。这样你才能发挥好挑剔的目光这个天赋----我们都是这么干的。

嗯嗯

问题见注释，供参考： #include<stdio.h> int main() {     int i,j,n,sum=1,all=0;     scanf("%d",&n);     for(i=1;i<=n;i++){//for(i=1;1<n;i++){          sum=1;         for(j=1;j<=i;j++){              sum *= j;         }         all+=sum;     }     printf("%d",all);     return 0; }

谢谢


Question: 编程记不住函数怎么办

找一个好的编辑器，有渐进提示的那种。我用的VS就很好用。

在吗，请问之前象棋棋谱的那个问题解决了吗

无他，但手熟尔

那么当你遇到明确需求，不是产品层面的需求，而是代码层面要解决很具体的问题。 举个简单的例子。就是从元素是字符串的二维矩阵中找出匹配的字符串，并返回他在矩阵的坐标。你肯定知道答案。我们假设你不知道答案。你怎么知道是否存在一个函数可以一行代码解决问题？如果存在，怎么找到这样的函数？ 如果你用的是一个比较冷门的语言呢？？？？？？？？？？？？

所以需要熟，基础语言特性和常用库函数都记住了，你自然就知道要用那个

动脑，走心。不要老想着走捷径。难道做厨子就容易了？同样有很多菜谱摆在那需要记住，同样是从点个火都手忙脚乱的状态学起。考驾照也是啊。同样要背科目一啊。

所以你是怎么记住的？

记不住有啥，不是有书，有网络吗。

你用搜索引擎搜索，每次都能立刻找到需要的函数及其使用方法？

不是吗，搜着搜着，就记住了。

要是搜索不到呢？

会百度就行

无论是百度还是404搜索引擎。有时你想要实现的功能不一定容易用简短的语言描述。或者搜出的结果与你想要实现的功能并不匹配

如果很容易就搜出任何问题的确切答案，那人活着还有什么意义？


Question: 正在打人生中的第一个C语言代码，求大佬告知哪里错了，为什么vs code显示出红色字体

这个代码每本书上都有，对照一下就是。

#include <stdio.h> int main() {     printf("hellow world.\n");     return 0; }

感谢

printf 和 return 两条语句后面忘写 ; 分号了

感谢大佬，我去改一下

大佬，我再问一下，我改完之后，他还是失败了，最后，显示：生成已完成，但出现错误，终端进程启动失败（退出代码：-1）    请问这个怎末解决？

return 0;


Question: 求助大佬，思路好像不对，但是又找不出问题

如果有相同的，记录输出第一次出现的子序列,供参考： #include<stdio.h> #include<string.h>  void findGC(char str[],int n) {     int i,j,a=0,len,max_radio=0,count_radio;     len=strlen(str);     //max_radio=0;     for(i=0;i<len;i+=n)     {         count_radio=0;         for(j=i;j<i+n;j++)         {             if(str[j]=='G'||str[j]=='C')                count_radio++;         }         if(count_radio>max_radio)         {             max_radio=count_radio;             a=i;         }     }     for(i=a;i<a+n;i++)        printf("%c",str[i]); } int main() {     char dna[100]={0};     int n;     printf("请输入子序列长度：\n");     scanf("%d",&n);     printf("请输入序列：\n");     getchar();     fgets(dna,sizeof(dna),stdin);     findGC(dna,n);     return 0; }

正确了，大佬，请问在fgets前面加个getchar(），是什么含义呢？作用是什么？

吸收输入缓冲区中残留的字符，和赵老师的rewind (stdin); 类似的作用。

//一个DNA序列由A/C/G/T四个字母的排列组合组成。G和C的比例（定义为GC-Ratio）是序列中G和C两个字母的总的出现次数除以总的字母数目（也就是序列长度）。 //在基因工程中，这个比例非常重要。因为高的GC-Ratio可能是基因的起始点。 //给定一个很长的DNA序列，以及要求的最小子序列长度，研究人员经常会需要在其中找出GC-Ratio最高的子序列。 #include<stdio.h> #include<string.h> #define MAXLEN 100 void findGC(char str[],int n) {     int i,j,a,len,max_radio,count_radio;      len=strlen(str);     max_radio=0;     for (i=0;i<len-n;i++) {         count_radio=0;         for (j=i;j<i+n;j++) {             if (str[j]=='G'||str[j]=='C')                count_radio++;         }         if (count_radio>max_radio) {             max_radio=count_radio;         }     }     printf("GC-Ratio最高的子序列：\n");     for (i=0;i<len-n;i++) {         count_radio=0;         for (j=i;j<i+n;j++) {             if (str[j]=='G'||str[j]=='C')                count_radio++;         }         if (count_radio==max_radio) {             for (j=0;j<i;j++) printf(" ");             for (j=i;j<i+n;j++) printf("%c",str[j]);             printf("\n");         }     } } int main() {     char dna[MAXLEN];     int n;      printf("请输入子序列长度：\n");     scanf("%d",&n);     printf("请输入序列：\n");     rewind(stdin);     fgets(dna,MAXLEN-1,stdin);     if ('\n'==dna[strlen(dna)-1]) dna[strlen(dna)-1]=0;     findGC(dna,n);     return 0; } //请输入子序列长度： //4 //请输入序列： //ACGTACGTACGTACGTACGTACGT //GC-Ratio最高的子序列： //ACGT // CGTA //  GTAC //   TACG //    ACGT //     CGTA //      GTAC //       TACG //        ACGT //         CGTA //          GTAC //           TACG //            ACGT //             CGTA //              GTAC //               TACG //                ACGT //                 CGTA //                  GTAC //                   TACG //

大佬，我运行后还是输入n的值，程序就直接结束了

要么你的回车键坏了，要么你运行的不是我这段代码生成的exe


Question: 怎么在U盘重新加载时关闭程序？


Question: 请问怎么隐藏命令行窗口？

WinExec该函数只提供对16位机子的兼容，这个兼容性太差了吧？

反正我用这个函数从winxp到win10都能用

这个只能在Windows平台用。如果是跨平台的，比如Linux、MacOS，那该如何处理呢？


Question: 在开发HTTP服务器时，文件读取重复，且有乱码


Question: 这个错误怎么解决各位大佬

谢谢老师


Question: 帮我的C语言文字游戏提提建议

兄弟，C语言做图像太难了QWQ

搞个图形界面


Question: 用宏定义出现符号错误如何解决？

能给我个软件吗，我想学C 我的邮箱1225514766qq

能给我个软件吗，我想学c

Visual C++ 2010 Express简体中文版 http://pan.baidu.com/s/1bnwRVLt

#define ROW 3#define COL 3最后没有 ';'号

嗯嗯，解决了，谢谢。


Question: C/C++测试工具--winAMS

可能是

看这界面，应该是用C++Builder写的吧


Question: 64字节大小的二进制文件在16进制下打开显示2行，怎么显示4行？

能给我个软件吗，我想学C 我的邮箱1225514766qq

可以使用Clion，下载地址：https://www.jetbrains.com/clion/

typedef unsigned char uint8_t;//确保uint8_t的定义是一个字节 for(...) {   line.data[i] = ret; //请确保i在for循环中每次加1   }

仅供参考： #include <string.h> FILE *f; char buffer[4096]; int r,a; void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } } int main(int argc,char **argv) {     if (argc<2) {         fprintf(stderr,"Usage: %s filename.ext\n",argv[0]);         return 2;     }     f=fopen(argv[1],"rb");     if (NULL==f) {         fprintf(stderr,"Can not open file [%s]!\n",argv[1]);         return 1;     }     a=0;     while (1) {         r=fread(buffer,1,4096,f);         HexDump(buffer,r,a);         a+=r;         if (r<4096) break;     }     fclose(f);     return 0; }

赵老师，我现在的问题是写入文件格式错误，格式应该是 01 02 03 04..., 但实际写入是 01 00 02 00 03 00 04 00...  ，这该如何解决呢？  写入的核心代码是： strncpy(binarys, line+i, 2);//读取十六进制  binarys[2] = '\0';   uint8_t  ret = convert(binarys);//十六进制转uint8_t  dataLine1.data[i] = ret;  难道是这行代码：  binarys[2] = '\0';  造成的吗？

二进制文件本身没有行的概念。二进制文件是个字节流，您喜欢怎么显示就写代码把它摆成什么姿势好了。

我现在遇到的问题是：同样大小的文件（64字节），使用编辑器在十六进制下，别人的显示是4行，我的显示是两行，导致我保存的文件，别人无法解析。我想知道的是这个该怎么解决呢？写入文件时，该怎么转换？

我对猜测其实没有兴趣。 话又说回来了，我首先猜测的是因为您的显示器比别人的大。

我使用WinHex打开，应该是01 02 03 04....这种格式的，但是实际结果是01 00 02 00 03 00 04 00...


参考opencv\3rdparty\libjpeg-turbo\src\jdcol565.c中的rgb_rgb565_convert_internal函数


Question: 为什么定义了一个指针，printf就不输出了？？

p = new Node;   指针只有在new()之后才向系统申请内存，在内存中这时才存在struct Node结构体的东西，因为你没new()指针，这时指针（32位或64位)指向的是一个随机的野地址。

Node* p = new Node;.....这种才是王道

Node p;p.date = 3;printf("%d\n",p.date);是date还是data？

p没有申请内存，其初值是内存中栈区原来的垃圾随机值，然后你给其date字段赋值3，就会往这个垃圾随机值对应的地址处写3，操作系统发现了这种非法行为，中断当前程序的执行。


Question: 使用C语言如何解析GET（或POST）报文

参考libcurl

链路层网络层传输层的解析可以玩struct，但是到了http这里就玩不转了。该玩正则表达式了。

仅供参考： #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else                     return string; } void main() {     strcpy(string,"A \tstring\t\tof ,,tokens\n\nand some  more tokens, ");     strcpy(seps1,",\n");strcpy(seps2," \t");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234| LIYI|China | 010 |201110260000|OK");     strcpy(seps1,"|");strcpy(seps2," ");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234|LIYI||010|201110260000|OK");     strcpy(seps1,"");strcpy(seps2,"|");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234|LIYI||010|201110260000|OK");     strcpy(seps1,"|");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",a");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",a,,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,a,,b,,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,,");     strcpy(seps1,",");strcpy(seps2," ");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     } } // //[A      string          of ,,tokens // //and some  more tokens, ] //Tokens: // <A> <string> <of> <> <tokens> <> <and> <some> <more> <tokens> <> //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234> <LIYI> <China> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <> <010> <201110260000> <OK> //[a] //Tokens: // <a> //[a,b] //Tokens: // <a> <b> //[a,,b] //Tokens: // <a> <> <b> //[,a] //Tokens: // <> <a> //[a,] //Tokens: // <a> <> //[,a,,b] //Tokens: // <> <a> <> <b> //[,,a,,b,,] //Tokens: // <> <> <a> <> <b> <> <> //[,] //Tokens: // <> <> //[,,] //Tokens: // <> <> <> //[,,,] //Tokens: // <> <> <> <>

strtokstrstrstrncpy……

赵老师，使用strtok时，空行怎么处理呢？


Question: [Error] ld returned 1 exit status和undefined reference to `sa(int)'出现怎么错了？怎么解决的？求哥哥姐姐们指教

修改完善如下，供参考对照： #include<stdio.h> #define N 2 #define M 5  float o[N];  int main() {     void  sa(int [][M]);     void  ia(int [][M]);     void  find(int [][M]);//float find(float);     void  fun();          //float fun();     int   a[N][M],i,j;      printf("请输入所有学生各门课程分数：\n");     for(i=0;i<N;i++)     {         printf("输入学号%d学生的成绩：\n",i+1);         for(j=0;j<M;j++)         {             scanf("%d",&a[i][j]);         }     }     sa(a);  //sa(a[N][M]);     ia(a);  //ia(a[N][M]);     find(a);//find(a[N][M]);     fun();        return 0; }  void sa(int a[][M]) {     int i,j,s;     printf("每个学生的平均成绩依次为：\n");     for(i=0;i<N;i++)     {         for(j=0,s=0;j<M;j++)         {             s+=a[i][j];         }         o[i]=s/M;         printf("%f    ",o[i]);     }     printf("\n"); }  void ia(int a[][M]) {     int i,j;     float s;     printf("每门课的平均成绩为：\n");     for(j=0;j<M;j++)     {         for(i=0,s=0;i<N;i++)         {             s+=a[i][j];         }         printf("%f    ",s/N);     }     printf("\n"); }  void  find(int a[][M]) {     int i,j,m,n;     for(i=0;i<N;i++)     {         for(j=0;j<M-1;j++)         {             if(a[i][j]>a[i][j+1])             {                 m=i;                 n=j;             }             else             {                 m=i;                 n=j+1;             }         }         printf("所有分数中最高的学生为%d，相应的课程为课程%d。\n",m,n);     } }  void fun() {     int i;     float f=0,s=0;     for(i=0;i<N;i++)     {         f+=o[i]*o[i];     }     s=f/N-(f*f)/(N*N);     printf("平均方差为：%f\n",s); }

谢谢哥

把main函数中的     sa(a[N][M]);     ia(a[N][M]);     find(a[N][M]);  改为     sa(a);     ia(a);     find(a);  引用的时候用a[M][N]变成引用a数组的第M行第N列元素了，而sa、ia、find需要的是数组，并非数组元素，所以编译器说你没定义sa(int)、ia(int)、find（int)。

欧克，谢谢您


Question: 禁止显示状态错误	LNK2019	无法解析的外部符号 _string，函数 _main 中引用了该符号

第14行，是否改为：letters = strlen(name);

试试 ```#include <string>   ```


Question: 谭浩强老师第四版学习中遇到了一个问题（chap11链表）

能给我个软件吗，我想学C 我的邮箱1225514766qq

if(i=0)  有了这句，不会只自行一次，而是执行第一次就可能出现段错误了，pf是一个野指针；没有初始化

第21行：if(i=0) 错误，应该是：if(i==0)

感谢感谢，matlab用多了，总是不注意这些


Question: 请问谁有VS2010版的，求发，谢谢！

谢谢

Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt


Question: 求软件，我是新来的请大家多多指教！

能给我个软件吗，我想学C 我的邮箱1225514766qq

Eclipse CDT

linux + vim+gcc/g++

vs2017 vs2019 vscode

谢谢

VScode

谢谢