Question: 刚学C语言，为什么这个代码运行不了呢

intunsigned intlong longunsigned long long统统容纳不下29的阶乘，早就溢出了。

#include <stdio.h> #include <math.h>  int main(void) {     int i = 1;     long long sum = 1; // 使用 long long 类型来存储阶乘结果     int x;      printf("请输入一个非负整数: ");     if (scanf("%d", &x) != 1 || x < 0) {         printf("输入无效，请输入一个非负整数。\n");         return 1; // 返回错误码     }      while (i <= x) {         sum *= i;         i++;     }      printf("%d 的阶乘是 %lld\n", x, sum);     return 0; }


Question: 为什么总是有问题啊！！！

疑似你建立的项目的类型不对，不是控制台应用。


Question: 刚学C语言，为什么这个代码运行不了呢

第三个for的循环控制条件有错，如果此处改正，还是可以输出上面一半的。


Question: Visual Studio 2022中用release版本运行时显示msvcp140.dll报错（C++语言）

这个错误通常是由于缺少Visual C++ Redistributable for Visual Studio导致的。msvcp140.dll是一个动态链接库文件，属于Microsoft Visual Studio 2015 Redistributable包。要解决这个问题，您通常需要重新安装或修复Microsoft Visual C++ Redistributable。 这里有一些可能帮助您解决问题的步骤： 重新安装Visual C++ Redistributable for Visual Studio 2015：您可以从Microsoft官网下载并重新安装Visual C++ Redistributable for Visual Studio 2015。请记得下载和安装适合您系统的x86或x64版本。 修复Visual Studio安装：您也可以尝试修复Visual Studio安装。打开“添加或删除程序”（Add or Remove Programs），找到Visual Studio 2022，点击“修改”（Modify），然后选择“修复”（Repair）。 运行Windows Update：请确保您的Windows操作系统是最新的。运行Windows Update，安装所有推荐的更新和补丁。 检查项目设置：如果在Release模式下出现问题，但在Debug模式下一切正常，请检查项目的设置，确保Release配置的设置是正确的。 关于“找不到xlocale:源链接身份验证失败”，这个错误可能是由于编译器在链接时找不到xlocale库。xlocale通常是在Linux和Unix系统中使用的库，Windows中不包含这个库。如果您的项目是跨平台的，并且在Windows中使用了xlocale，您可能需要找到一个Windows下的替代库或者使用条件编译来避免在Windows中包含xlocale。


Question: 求解两个矩形面积，重叠只算一次，我写的代码我自己测没问题，但网站显示60分，求各位大佬看看哪里有问题

return 0； 应该修改为 return 0;。分号应该放在语句末尾，而不是在中间。函数 founc1 的参数命名不够清晰，可能会导致混淆。应该使用更具描述性的参数名，以便代码的可读性更好。函数 founc1 的算法实现有问题。它的目标是找出两个数中第二大的数，但实际上它只进行了一次比较和交换。正确的方法应该是找出最大的数和第二大的数，然后返回它们的差值。在 main 函数中，需要考虑输入错误的情况。如果输入的坐标信息不满足矩形的要求，应该进行错误处理，而不是直接计算面积。缺少注释和代码说明，难以理解代码的逻辑和目的。添加注释可以提高代码的可维护性和可读性。变量命名不够清晰，可以通过更具描述性的变量名来提高代码的可读性。代码中没有考虑输入数据的合法性，如负数坐标等情况。应该添加适当的输入验证来确保输入数据的有效性。 #include<stdio.h>  // 函数用于找出两个数中第二大的数 int findSecondLargest(int a, int b, int c, int d) {     int arr[4] = {a, b, c, d};          // 对数组进行冒泡排序，找出最大的数和第二大的数     for (int i = 0; i < 3; i++) {         for (int j = 0; j < 3 - i; j++) {             if (arr[j] > arr[j + 1]) {                 int temp = arr[j + 1];                 arr[j + 1] = arr[j];                 arr[j] = temp;             }         }     }          // 返回第二大数和最大数的差值     return arr[2] - arr[3]; }  int main() {     int x11, x12, y11, y12, x21, x22, y21, y22;          // 输入两个矩形的坐标信息     scanf("%d %d %d %d", &x11, &y11, &x12, &y12);     getchar(); // 消耗换行符     scanf("%d %d %d %d", &x21, &y21, &x22, &y22);         // 判断两个矩形是否有重叠     if (x12 < x21 || x11 > x22 || y12 < y21 || y11 > y22) {         int s = (x11 - x12) * (y11 - y12) + (x21 - x22) * (y21 - y22);         printf("%d\n", s);         return 0;     }      // 计算 x 轴和 y 轴上的重叠部分的长度     int overlapX = findSecondLargest(x11, x12, x21, x22);     int overlapY = findSecondLargest(y11, y12, y21, y22);      // 计算重叠部分的面积，然后从总面积中减去     int s = (x11 - x12) * (y11 - y12) + (x21 - x22) * (y21 - y22) - overlapX * overlapY;     printf("%d\n", s);      return 0; }

x11y11x12y12分别是两个矩形左下角的横坐标、纵坐标，右上角的横坐标、纵坐标。


Question: 请问运行后显示这个怎么办？

变成颠佬

颠佬？？？


Question: createprocess失败 代码740

可能不是代码权的事。如果是不重要的代码使用的却是重要的服务，也有可能被拒绝。系统资源是有限的，对于任务的评判是自动化的。彩虹岛应该是个重要项目，感觉需要评审一下相关代码的效率和使用的服务价量，并不是有钱就可以胡来。


Question: 请问这个一直调试不来是怎么了啊，编译选项的都试过啦...还是不可以...大佬求救！！！

先保存文件，指定一个文件名。

哇趣，还真的是啊，谢谢大佬

你说的是什么问题？可以交换


Question: 这个该咋写啊uu们··

#include <stdio.h>  int main() {   int c, n = 0;   char s[10][5] = {"ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu"};    for (; c = getchar(), c != 10 && c != EOF; c > 47 && c < 58 ? n += c - 48 : 0);   n > 99 ? printf("%s %s %s\n", s[n / 100], s[n % 100 / 10], s[n % 10]) :    n >  9 ? printf("%s %s\n", s[n / 10], s[n % 10]) :             printf("%s\n", s[n]);    return 0; }

不行啊兄弟

实测可以

这是已经写的#include<stdio.h>int main() { long long a; int i; int sum = 0; scanf("%lld", &a); do {     i = a % 10;     sum = sum + i;     a = a / 10; } while (a > 0);  int mask = 1; int t = sum;  while (t > 9) {     t /= 10;     mask *= 10; } do {     int b = sum / mask;     if (b == 0)     {         printf("ling");     }     else if (b == 1)     {         printf("yi");     }     else if (b == 2)     {         printf("er");     }     else if (b == 3)     {         printf("san");     }     else if (b == 4)     {         printf("si");     }     else if (b == 5)     {         printf("wu");     }     else if (b == 6)     {         printf("liu");     }     else if (b == 7)     {         printf("qi");     }     else if (b == 8)     {         printf("ba");     }     else if (b == 9)     {         printf("jiu");     }     if (mask > 9) {         printf(" ");     }     sum %= mask;     mask /= 10; } while (mask > 0); return 0;  }

怎么能输入一个这么大的整数啊，就差这一步了


Question: 为什么这里的min一直在下面不会被重新赋值？

？arr1[j] = arr[j+i];这个语句是对的吗？

你写的 x < min 的情况下，min才会被重新赋值，你可以输出x和min看看，有符合 x < min 的情况吗？


Question: map.insert()里面是（value, key）?

很多高级语言都是可以直接map.insert(key,val) c++里面是 map.insert(make_pair(key,val)) 一般来讲，插入可以写成map[key]=val;对于存在的key会更新，对于不存在的key会直接创建 但是查询时最好还是用map.find,map.count，因为用map[key]形式访问一定会创建这个键。

回答的好详细，我懂了，谢谢大佬👍

insert(插入的位置，插入的值)

这是我在力扣上面跟着卡尔刷的一道题，我如果把nums[i]和i调换位置就会报错，这是为啥？


Question: 一个来自小学生的求助

把 = 改为 == 就可以了 = 是赋值的意思不是等于的意思

是的，您说的对，可是我不明白的是，为什么if(a>=2)         printf("Today, I ate %d apples.",a);这个不执行呢，我输入5的时候，这一条不是也应该执行吗

不管你输入的啥，在它上面一条都被赋值成0了。

我用c++结果没问题啊，你可以试试把%d改成%i?

我打错了，您看到的是我修改以后的，我原来是“a=1"和"a=0"


Question: 大一新生，寻求大佬帮助，请问这个代码为什么运行之后只能得到0或1

除了int main，int全换float

牛，Thanks♪(･ω･)ﾉ大佬

用double更好一点


Question: 刚学C语言，为什么这个代码运行不了呢

结果溢出。

有范围咯，用数组int a[30];

溢出了， long int也就20几左右的阶层就上限了，用数组存吧

为什么呢，怎么解决的呢

循环嵌套，一个累加，一个累乘；不会找我要代码

结果溢出。


Question: 刚学C语言，为什么这个代码运行不了呢

第一次见这样写的，建立个数组存起来吧，也就是闰年特殊的时候那个月加一天而已

如果输入0 0 0你的代码会输出啥？

AI回答：https://www.fudai.fun/ 这段代码目前无法运行的原因是由于您的代码中有两个地方存在错误。 首先，在使用scanf函数接收输入时，需要在代码文件开头添加#include<stdlib.h>头文件。 其次，在使用printf函数打印输出时，您没有输出换行符\n，结果会打印在同一行上。 下面是修改后的代码： #include <stdio.h> #include <stdlib.h> #include <math.h>  int main(void) {     int a, b, c, d;     scanf("%d %d %d", &a, &b, &c);      if ((a % 4 == 0 && a % 100 != 0) || a % 400 == 0) {         switch (b) {             case 1: d = c; break;             case 2: d = 31 + c; break;             case 3: d = 31 + 29 + c; break;             case 4: d = 31 + 29 + 31 + c; break;             case 5: d = 31 + 29 + 31 + 30 + c; break;             case 6: d = 31 + 29 + 31 + 30 + 31 + c; break;             case 7: d = 31 + 29 + 31 + 30 + 31 + 30 + c; break;             case 8: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + c; break;             case 9: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + c; break;             case 10: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + c; break;             case 11: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + c; break;             default: d = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + c; break;         }         printf("%d\n", d);     } else {         if (c == 29) {             printf("data error!\n");         } else {             switch (b) {                 case 1: d = c; break;                 case 2: d = 31 + c; break;                 case 3: d = 31 + 28 + c; break;                 case 4: d = 31 + 28 + 31 + c; break;                 case 5: d = 31 + 28 + 31 + 30 + c; break;                 case 6: d = 31 + 28 + 31 + 30 + 31 + c; break;                 case 7: d = 31 + 28 + 31 + 30 + 31  ```c    ```


Question: 请问，为什么卸载不了电脑上的python？

see the log file


Question: 刚学C语言，为什么这个代码运行不了呢

#include<stdio.h>#include<math.h>int main(void){    double a, b, c;    double dt,t,x1,x2;    scanf("%lf %lf %lf", &a, &b, &c);    dt = b * b - 4 * a * c; /* 这个才是判别式*/   if (dt<0)  { /*判别式小于0*/        print("-1");   /* 没有实根 */    }    else if ( dt<=0.0000001 ) {  /* 判别式为0 */        x1= -1*b/(2*a);        printf("x1=x2=%.2f\n",x1);    }    else {         t = sqrt(dt);        x1= (-1*b + t) / (2*a);        x2= (-1*b - t) / (2*a);        if (x1 > x2){            printf("x1=%.2f\n", x1);            printf("x2=%.2f\n", x2);        }        else{           printf("x1=%.2f\n", x2);          printf("x2=%.2f\n", x1);       }    }    return 0;}

您已经分不清判别式和它的平方根了？


Question: 求大佬解答，感激不尽！

第一,water要么赋初值要么放int main上面,第二,float精度不够,建议所有涉及小数的都用double

你molecule变量赋值的时候，其实water变量还没有正确初始化和正确赋值，所以这时water的值是一个随机的数，就造成了molecule的值是不符合你意图的。你把第10行语句，放到14行前面就好了。

太感谢啦，问题解决啦

在这个进度，你写一句，机器就用小学三年级的思维计算一句，四则运算。你不能企图这样建立函数关系。所以那个赋值执行的时候，变量water还没有值，只能瞎编一个，所以是错的。

谢谢，已经改好啦


Question: 萌新遇问题求大佬帮忙解答

while(x>0)    后面没有;号       判断x>0      试一试。

去掉分号也不行

！！！原来忘记还有个去掉等号了，可以了谢谢大佬

while那行末尾多敲了一个分号。因此以那个分号为循环体一直死循环了。

不行唉。。

去掉分号还有个等号也要去掉现在可以啦，谢谢大佬


Question: 求各路gis大神帮助！！

数据路径可能有问题


Question: W5500 UDP接收不到数据

如果这俩原来是直连的，就分别插到交换机上去。

或者插到小路由的两个内网口。 因为W5500这玩意不会自动识别双绞线线序。

IP、端口都没问题，怀疑是W5500不知道对方的MAC地址导致的。。。


Question: 刚学C语言，为什么这个代码运行不了呢

没有输出

你是不是没输出？🤦♂

虽然我没学c，但我学了c++，一看就没输出

关于为什么不能正确运行，首先输入安排的顺序和题目要求不一致；第二不能把scanf_s当作scanf用，要么用scanf，要么给%c增加长度字段如scanf_s("%c%lf%lf",&x,1,&a,&b);第三缺少输出，你计算了不输出等于白算。第四算我主观了，输出格式要按照题目要求来，也就是说，要审题。

#include<stdio.h>#include<math.h>int main(){    char x;    double a, b;    scanf("%c %lf %lf",&x,&a,&b);    switch (x)    {    case'+':        printf("%.2f\n",a+b);        break;    case'-':        printf("%.2f\n",a-b);        break;    case'':        printf("%.2f\n",ab);        break;    case'/':        printf("%.2f\n",a / b);        break;    default:        printf("未知运算符\n");    }    return 0;}希望能帮到你

如果输入的是 * 2 3.6，那你代码scanf_s("%lf %lf %c",&a,&b,&x);输入顺序错了如果报错undefined reference to `scanf_s'，改成scanf修改后：#include<stdio.h>#include<math.h>int main(){    char x;    double a, b;    scanf("%c %lf %lf",&x,&a,&b);    switch (x)    {    case'+':printf("%.2lf",a+b); break;    case'-':printf("%.2lf",a-b); break;    case'':printf("%.2lf",ab); break;    case'/':printf("%.2lf",a / b); break;    default: puts("未知运算符");    }    return 0;}


Question: 怎么办，如何解决。。。

这是什么语言

显然是因为你把main写成了mian，所以系统找不到主函数。


Question: 兄弟们，输出没结果怎么搞

程序跑完了，可能是你没写输出或者输入。贴下源码

✓，我没写输出

既然返回值是0，大约是正常结束的。那么大概率是你没写输出或者流程执行不到输出。

我也这么想的

对的


Question: 求助：cmake构建后没有exe程序

找找是不是在src的文件夹里，或者并列src生成了一些debug,release文件夹

嗯，证明一个东西不存在是很困难的。我是说，它可能藏在角落里，箱子里，或者袜子里。

大佬在不在


Question: 求助很像之前写的变了一点地方

你的return结束掉了这个函数

瞎了

int n;float i=1,j=1;

额，for语句可以这样写吗？

计算机老师这么写的

有没有一种可能你只执行一次，就return0了。。。

我玩傻掉了


Question: 不是只能下划线或者字母开头吗 a是错的啊

题出错了

c++标识符所有标识符必须由一个字母(az或AZ)或下划线(_)开头，标识符的其它部分可以用字母、下划线或数字(09)组成。A和D错在不能以数字开头，B有非法字符，正确答案是C

C是关键字啊

哦对，关键字不可以充当标识符，题目没有正确答案

没办法了，刷题刷到你这样，恐怕只能先休息（禁言）一段时间了。系统估计已经对你免疫了（老师见到你就乱讲，通常是被你气糊涂了，想起你就头疼）。正确答案是C，注意是标示符而不是变量名。


Question: 大佬们 为什么这段代码没有输入 直接运行结束了

你n的值呢？


Question: 求求已经不知道改多少次了

scanf这个函数最好少用，因为它很复杂

i/（2 * i-1）是整数运算，结果也是整数，第一次算出来是1，后面i增大，就舍去小数变成0了，所以sum一直是1，所以要转换成浮点数运算2 * i改成2. * i，或者直接强制转换在前面加上float，变成float(2*i-1)

感谢 ( ੭ ˙ᗜ˙ )੭

2*i改为2.*i不就行了？

谢谢，谢谢

不知道你要干嘛，但是确定的是你必然都是1，从1后，+后面的数值都会是0

那要怎么改才行

因为当i大于1的时候i/（2*i-1）都等于零


Question: 大学C语言新生求教~

不安全哥们

你用的是vs，vs中使用scanf会报错，你没看见下面的ERROR吗，它建议你使用scanf_s，而不是使用scanf，或者在代码的最顶端输入#define  _CRT_SECURE_NO_WARNINGS

已解决，谢谢


Question: 蓝桥杯题目：六六大顺测试用例总是不通过，能帮我看看问题在哪吗

题目里没有关于范围的约定，于是你使用了内置的最长数据类型。然而仍然不够用。你得做好结果是个500位数或者100000位数的心理准备。

那如果超出了最长数据类型，该怎么去表示

用数组记录大数据，每个元素记录其中的一位或者几位，然后自己写计算步骤。可参考 https://blog.csdn.net/CX_YX_0/article/details/128046342


Question: 顺序栈中top为指针类型的，怎么判定栈满

顺序栈中，top指针指向栈顶元素的位置。当栈满时，意味着栈中已经没有剩余的空间可以存储新的元素了。在这种情况下，我们需要判断栈是否满，以便进行相应的处理。 如果top是指针类型，我们可以通过比较top所指向的内存地址和栈的容量来判断栈是否满。因为在顺序栈中，栈底位置固定，栈顶位置随着入栈和出栈操作改变。当top指向的内存地址超过了栈的容量，就表示栈已满。 使用if(*(S.top) >= S.size)判别栈满的原理是通过比较top指针所指向的地址和栈的容量来判断。*(S.top)表示获取top指针所指向的内存地址中的值。如果该值大于等于栈的容量，说明栈已满。


Question: 刚学C语言，为什么这个代码运行不了呢

如果你使用的使Visual stdio编程的话，我建议你把scanf改为scanf_s

您是否确切地知道啥叫“一个单精度数”？


Question: c++ 溢出问题求解决！！！

也许是下水道有杂物加上雨比较大，就造成溢出了。


Question: 为什么两个hello world代码不一样？

因为下面使用宏定义using namespace std，故不需要加std::

我不造啊

回字有四种写法你知道么？


Question: 救救萌新，为什么电脑输出结果和gpt说的不一样😿😿😿😿

gpt追求拟人，这次拟的是一位犯错误的新手，这效果相当赞。

因为--n会修改n的值啊。你要想return，就得先算出n+f吧你要想算n+f就得先算f吧你一算f就得先--n啊n就变成4了所以你算的是4+f(4)啊没有5被累加的动作啊

典型的CPU都不会先把5放在那儿晾着再回头去求f的。

🥺🥺🥺醍醐灌顶了！！！谢谢！


Question: 刚学C语言，为什么这个代码运行不了呢

首先，输出的时候，不能用%d这个表示整型的格式符搭配非整型数据。其次，关系运算符不能连用，连用的结果是错的。以a>b>c为例，其中a>b部分的结果是0或1，接下来是0或1判断是否>c 。故应写作a>b && b>c还有，题目说输入无序，没说互不相等啊。


Question: 刚学C语言，为什么这个代码运行不了呢

运算符%不能接收非整型运算数。

那要怎么改呢


Question: 刚学C语言，为什么这个代码运行不了呢

首先，你不能先计算后输入。第二，余弦函数的正确调用形式需要括号。第三，三角函数的自变量需要是弧度值。第四，scanf的除了格式串的参数需要是地址。第五，double型对应的scanf格式符必须是%lf，缺一个小写L。

scanf("%f%f%f%f,&a,&b,&c,&d);


Question: 求助 C语言顺序表问题

先输出date[5]，而上面scanf只输入到date[4]，date5，在初始化时未赋值，其值为0

第一个输出是多余的，也就是说你的输出函数第一次循环是多余的，跳过即可。for(i=L->Length-1;...


Question: 求助！！！这个C语言程序是哪里错了 ？

谢谢大家支持！但是只是单词拼错了！！！再次感谢

⊙∀⊙！发错位置了

<stdio.h>为标准输入和输出函数，#include<stdio.h>d调用标准库函数，为头文件指令

应该在第一行加入#include <stdio.h>

c++标准库是<iostream>,万能头文件是<bits/stdc++.h>

printf函数属于文件里面的函数，应该include此头文件

缺少包含头文件指令。


Question: 有哪位好心人可以帮忙看看吗

我仔细看了一下,您所写的代码的思路应该是没有问题的。不过图片不是很清楚这边建议您检查一下每一句最后分号是不是打错了（如错打成冒号或中文分号） 另外第9行的printf好像有问题,为什么ta没有颜色？

谢谢，我找到原因了

你在scanf那行末尾误敲了一个中文的分号。需要英文的。

谢谢，我找到原因了


Question: 急急急！！！ 小白求教！！！

首先，不要在意汉字部分，忽略它。其次，不要复制代码，自己一点一点敲上去。


Question: 刚学C语言，为什么这个代码运行不了呢

（后面的\n可以不要）你的问题是‘\’中的\前面也是要转义的，你只是少了一个\而已

printf("He said:\"The symbol is \'\\\'\".");

C/C++中单引号是不要转义的


Question: 刚学C语言，为什么这个代码运行不了呢

你的前4个printf都少参数（a,b,c)而最后一个%要用%%转义的改好的完整程序为 #include <stdio.h> int main(void) {     int a, b, c;     scanf("%d %d %d", &a, &b, &c);     printf("%d+%d+%d=%d\n", a,b,c,a + b + c);     printf("%d-%d-%d=%d\n", a,b,c,a - b - c);     printf("%d*%d*%d=%d\n", a,b,c,a * b * c);     printf("%d/%d/%d=%d\n", a,b,c,a / b / c);     printf("%d%%%d%%%d=%d\n", a,b,c,a % b % c);     return 0; }   结果

printf()和scanf()作为可变参数方法，是从右向左传参（入栈操作），在最左边的参数进行执行（出栈操作）时每遇到标识符(%d等)进行一次出栈，你写了四次出栈一次入栈，编译会报错。正常来说在使用开发工具写的时候就会有报错提示，你可以看看提示信息，避免语法错误。

printf函数“”里面一个%d应该对应逗号后面一个整数变量，可以改成：printf("%d+%d+%d=%d\n",a,b,c,a+b+c);其他同理


Question: 刚学C语言，为什么这个代码运行不了呢

程序有两处错，改好的#include <stdio.h>int main(void){    int n, m,a, b;    scanf("%d %d", &n,&m);    b= (m -2* n) / 2;    a = n - b;    if (a < 0 || b < 0) //这个后面不能有分号        puts("No answer");    else        printf("%d %d\n", a, b); //puts只能一个参数    return 0;}

谢谢提醒！


Question: 在32位操作系统下，任何类型的指针变量都占四个字节,为什么输出结果是8呢

你看看编译器是32位还是64位，64位打印出来是8

理论上，它与操作系统无关，与编译器及生成代码的位数有关（当然，32位系统下是不能运行63位程序的）在64位系统上，用分别用32/64位结果如下

电脑是64位操作系统

64位操作系统全部输出4？


Question: 奇怪的问题，，，，中文显示不出来了

用记事本打开cpp文件，另存为，选择编码为 ANSI /UTF-8试试看？

画面上是没有通过编译，不是什么中文显示不出来。关掉黑窗口，重新编译。

可能是语法检查在括号、分号扫描时遇到了问题。突然发现程序中第一个printf();语句肯定是错误的，导致了编译扫描刚开始就退出了。

这个是编码格式的问题，工具选项里改下字体就行了。

字体已经改成成简体中文了，还是不行

工具显示不出来中文吗？把 编码格式替换一下呢，换成 GB2312或者GBK

找不到编码格式，，，，


Question: 求大佬教教我  qaq

运行窗口的长度是有限的，当有足够长的输出时，它会选择性遗忘最古老的内容，这很合理吧？

原来是这样，我以为我写错了什么，谢谢大佬


Question: 有没有大佬救救我QAQ

import requestsfrom bs4 import BeautifulSoup url = 'https://yield.chinabond.com.cn/cbweb-czb-web/czb/queryGjqxInfo' data = {"zblx": "xy", "srrq_rq": "2021-12-31", "locale": "zh_CN", "qxmc": "1"} html_data = requests.post(url, data=data, headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36'}) html_data = html_data.content.decode('utf-8') soup = BeautifulSoup(html_data, 'html.parser') tb = soup.findAll("table", {"class": "ds"}) tenYear = tb[0].select('tr')[1] deadline = tenYear.select('td')[0].text incomeRate = tenYear.select('td')[1].text data = '标准期限：{0} 收益率(%)：{1}'.format(deadline, incomeRate)print(data)

为什么我看不懂QAQ

【1】= requests【2】= BeautifulSoup【3】= 'https://yield.chinabond.com.cn/cbweb-czb-web/czb/queryGjqxInfo'【4】= "dt"【5】= post【6】= User-Agent【7】= text【8】= table【9】= 9【10】= format

大佬我还是运行不出来QAQ


Question: 笔记本电脑开机黑屏，求助

程序员不是修电脑的，也不知道Windows的内核代码，引起这种情况发生的原因有很多，没办法给你一一列举，一般建议你重装电脑

此事不找售后，更待何时？


Question: 刚学C语言，求助大佬

你把出错的代码放到chatgpt中，叫他找出其中的错误。后续有啥更离奇的问题，也难得到处找人问了，而且答案得到的也快。

OK，感谢你的建议

哈哈，从未见过如此离谱之人。加油。

刚学，眼神有点不好

括号括错了，正确的应该是：#include <stdio.h>int main(){    const int price = 3;    int weight = 5;    int sum = price * weight;    printf("%d\n", sum);    return 0;}

OK，谢谢

这个事儿这样理解，就是我们日常都是把头放在衣服外面的。所以函数头也得放在花括号外面。

谢谢

int main () {程序体}花括号位置错误

谢谢


Question: 大伙们好，我是刚学的C语言，为什么我这个strcmp函数这样写没有返回值，按理来说不是应该是-1吗

-1是整数，不是字符串啊，puts表示它心有余而力不足啊。

所以到那行就异常结束了，没有往下继续执行。

噢噢原来是这样哈哈哈哈哈哈哈，谢谢你


Question: C语言 单链表出现RE问题 求助

经评论区好心人提醒，发现图没截全，补上没截全的那部分

所以结果图各列的标题是啥？我是说尤其是第十列？为啥AC的都是0呢？

啊抱歉，没截全，分别是用时和内存

您可以看我在评论区补充的图

既然AC的内存占用都显示0，我瞎猜哈，有没有一种可能是测试集数据量较大的时候占用内存过多引起的呢？ 我主观上觉得这个问题没必要用那么多内存，个人看法，仅供参考哈。


Question: c语言求助实现2022年北京高考最后一题连续可表数列

首先，不能搞升序排列，你得保持数组元素的原始顺序。其次，别先入为主地认定m的值啊，按照题意m的值是从1开始一个一个试，试到最后得到的。然后，没啥更好的思路之前，最朴实的办法就是写循环一个一个试呗。


Question: 想用gcc编译器怎么一开始就报错？

你的电脑似乎是windows电脑，建议使用Linux系统再安装gcc。

显然没配置对，或者说没配置完整。


Question: ‘设计一个名为alter()的函数，接受两个int类型的变量x和y，把它们的值分别改成两个变量之和以及两变量之差’这是练习题目

不好理解吗？第一行后，x 已经不是 x 了，而是 x+y ；这样，第二行，右边其实就是 x+y - 2y = x-y  -> y

请问2y咋来的

那不写着 2*(*y) 吗

痛苦在于，你不知道楼主到底问的是啥。如果楼主能清晰描述出具体的问题，就这个问题来说，他就不必发问了。

关键是既没有名为alter的函数，也没有两个int类型的参数，不知道干煞嘞

忽然发现自己词穷，这种事咋解释啊，痛苦。

主要是没看懂，不知道从哪个方向得来的

代个数呗 一个5一个8 第一行得13 第二行得-3

第二行的*x已经是第一行的值了


Question: 请问一下，x=3.1,y=3.1时的打印结果为什么会是10m，

-1 < x < -3  这样写是不对的 ，这是自然语言的写法；x > -1 && x < -3 C语言是这样写的。

谢谢，现在理解了


#include <iostream> #include <stdlib.h> #include <vector> using namespace std; struct metal {     int a;     int b;     int c;     int d; }; int main() {     int n=10, ma = 0, mi = 100, j, k = 0;     cin >> n;     std::vector<metal> m(n);     for (int i = 0; i < n; i++)     {         cin >> m[i].a >> m[i].b;         m[i].c = m[i].a / m[i].b;         m[i].d = m[i].a / (m[i].b + 1);         ma = max(m[i].c, ma);         mi = min(m[i].d, ma);     }     int x = 0;     std::vector<int> b;     for (int j = mi; j <= ma; j++)     {         cout << m[0].a << endl;         for (int i = 0; i < n; i++)         {             if (m[i].a / j == m[i].b)             {                 k++;             }             while (k == n)             {                 b.push_back(j);                 ++x;                 k = 0;             }         }         k = 0;     }     cout << b[0] << " " << b[x - 1];     system("pause");     return 0; }

大佬能解释一下为啥我原来的代码里面的结构体数据会变吗

b[n] 会越界。b的个数实际上比n大。

感谢感谢


Question: 求助换行输入的问题。

#include <stdio.h> #include <vector> #include <string.h> int main() {     int n = 0;     std::vector<int> a, b;      char line[256] = { 0 };      gets_s(line);     sscanf_s(line, "%d", &n);      gets_s(line);     char* context = 0;     const char* token = " ";     char* temp = strtok_s(line, token,&context);     while (temp)     {         int c = 0;         sscanf_s(temp, "%d", &c);         a.push_back(c);         temp = strtok_s(NULL, token, &context);     }      gets_s(line);     temp = strtok_s(line, token, &context);     while (temp)     {         int c = 0;         sscanf_s(temp, "%d", &c);         b.push_back(c);         temp = strtok_s(NULL, token, &context);     }      return 0; }

以前参加ACM时，如果是这种输入，超级不喜欢直接 fscanf以及 cin<< 有时候尾巴的 \015\012 两个字符和Linux下的一个字符会导致不同的编译器读出来的不一样。 解决方法： 用 fgets 读取一行，而后在行内 sscanf, 这样无论对方裁判编译器是啥子，都能读出来。

\n

打印的结果后面要换行的地方加个\n

写多个scanf就行了

理论上不用考虑换行与否，你就考虑那些数值就行。


Question: codeblocks  输出字符串与所得结果不一样

大约是因为str这个东西的预留空间不够大。


Question: memcpy将数据拷贝到buf中，在将数据拷贝出来，为什么数据不对呢

哪儿不对呢？你得说它咋不对了，咱才好分析为啥。

代码中存在一些类型不匹配的问题，导致数据拷贝出现错误。给你分析一下：1、你声明了 buf 为 unsigned char，但是原始的 char 类型的数据被拷贝到了 buf 中。char 类型可以是有符号或无符号的，取决于编译器的实现。因此，在将 char 数据拷贝到 unsigned char 类型的 buf 中时，可能会出现类型截断和符号位扩展的问题。 2、在将数据拷贝回来时，你使用了 char e;，但是 e 的类型是有符号的，而你之前将数据拷贝到了 unsigned char* 类型的 buf 中，这样可能导致数据截断和符号位扩展。 修改之后的代码：  ```c++    char a = 170;char b = 68;char c = 18;char d = 28; unsigned char* buf = new unsigned char[1024];unsigned char* p = buf; memcpy(p, &a, sizeof(a));p += sizeof(a); memcpy(p, &b, sizeof(b));p += sizeof(b); memcpy(p, &c, sizeof(c));p += sizeof(c); memcpy(p, &d, sizeof(d));p += sizeof(d); p = buf; unsigned char e;  // 注意这里改为 unsigned char 类型memcpy(&e, p, sizeof(e));  // 使用 sizeof(e) 而不是 1 cout << std::hex << static_cast(e) << endl;  // 将 e 转换为 int 输出 ```


Question: 清除缓存区的函数不是fflush(stdin)吗？

#include <stdio.h>  int main() {     char password[20] = { 0 };     printf("请输入密码：>");     gets_s(password);      printf("请确认密码：>");     char confirmed[20] = { 0 };     gets_s(confirmed);     if ('Y' == confirmed[0])     {         printf("Yes\n");     }     else     {         printf("No\n");     }     return 0; }

又是因为windows下 CR/LF 搞的鬼。win下换行有2字符。第二个输入直接读了上一个换行，导致相当于按了两次回车。 使用 gets 和 sscanf来处理，可以避免这个问题。

rewind(stdin);

fflush函数是设计来处理输出缓冲区的，拿来处理输入缓冲区的话，后果不可预计。

en，我刚开始学，没太理解说的什么意思

我是想用 fflush 函数清除缓存区里面存放的东西的

fflush 函数不能这样用吗


Question: 结构体到底要怎么输入输出

结构体里 char *name; 定义是个指针，在给它赋值前需分配空间，修改如下，供参考： #include <stdio.h> #include <stdlib.h>  typedef struct{     char *name;     int num;     double score; }student; student* gethigh(student* s1,student* s2){     return s1->score > s2->score? s1 : s2; } int main(){     student s1,s2;         s1.name = (char *)malloc(sizeof(char)*16);  // 修改         s2.name = (char *)malloc(sizeof(char)*16);  // 修改     printf("请输入学生的姓名学号成绩：");     scanf("%s%d%lf",s1.name,&s1.num,&s1.score); // 修改         //scanf("%s%d%lf",&s1.name,&s1.num,&s1.score);     scanf("%s%d%lf", s2.name,&s2.num,&s2.score);// 修改         //scanf("%s%d%lf",&s2.name,&s2.num,&s2.score);     student s = *gethigh(&s1,&s2);     printf("学号%d的学生%s的成绩更高：%lf",s.num,s.name,s.score);     //printfin(&s);      return 0; }

你的name是指针，没有保存字符串的空间。


Question: vs里写成的代码，能生成链接或其他形式，给没有编译器的电脑看运行效果吗，比如说写个贪吃蛇游戏，怎么给没有编译器的朋友玩呢

你是用什么编程语言写，可以打包一下如果是python的话，可以考虑用

目前是c语言 这张图提供了宝贵思路 谢谢呀

没事，我可以给你看看c的

为什么你会觉得不可以

可以的吧，给对方的就是生成的那个 exe 文件了，他可能还需要安装你的 vs 对应版本的运行库（这些网上有标准的可以下载了安装）。

好的 我去试试 谢谢呀


Question: 帮帮孩子吧，实在是太难受了

你把代码发出来，我帮你改一下

en，不是代码的问题，是运行代码的窗口问题


Question: c语言可修改左值问题

不是吧，if() 语句的最后一个，j = N - 1 应该是 j == N - 1 吧；看判断逻辑，应该是求数组边界元素之和

谢谢，我一会去看看

确实是求那个M×N数组的边界值和。我改了还是不行🙃

没改对吧？刚在 vc2008 里试了，就改动这一处，是可以通过编译没有错误或警告提示的。

if (i == 0 || i == M - 1 || j == 0 || j = N - 1)这里边 i == M-1 不能这么定义吧，应该是i = M-1

谢谢，我一会去看看


Question: 求助！在这个代码中‘bool inword = false’存在的意义是什么？没看懂，求大佬解惑！

表示当前是不是单词里，只有遇到字母，才进入单词，然后只有遇到空格（如题所言暂未考虑标点类），才结束当前单词；如此循环。

好的谢谢


Question: 求助！l输入500时，循环进行到第五次l会自动归零，是为什么？（c语言）

好的，谢谢谢谢

#include <stdio.h> #include <stdlib.h> int main() {     int l;     int *i = (int*)malloc(sizeof(int) * l);     int n=0;               scanf("%d",&l);          for(n=0;n!=l;n++){         i[n]=0;         printf("%d\n",i[n]);     }     return 0; }  ```c    ```

c里面不能直接int i[n]，这样它并不能动态的根据n的值去分配空间，需要用malloc手动申请

你的free没啦


Question: 新手求助大佬！求大佬来解答

外部循环 'for（a=3;a<num;a+=2）'：这个循环从3开始迭代，每次迭代增加2，直到达到给定的输入 'num' 值之前。这样做是因为偶数除了2外都不可能是素数，所以只检查奇数。 内部循环 'for（b=3;b*b<a;b+=2）'：在每次外部循环迭代时，这个循环用来检查是否有因子可以整除当前的奇数 'a'。它从3开始迭代，每次迭代增加2，直到 'b*b >= a' 为止。这是因为如果存在一个小于等于 'sqrt（a）' 的因子，那么一定会存在一个大于等于 'sqrt（a）' 的因子。所以，只需检查 'b' 的平方是否大于等于 'a'。 'if（a%b==0）'：如果在内部循环中找到了一个可以整除 'a' 的因子 'b'，那么说明 'a' 不是素数，应该中断内部循环。 'if（bb>a）'：在内部循环结束后，如果没有找到能够整除 'a' 的因子，就说明 'a' 是素数。此时，'bb' 的值将大于 'a'，因为在内部循环的最后一次迭代时，'b' 的平方刚好不小于 'a'。所以，如果 'b*b > a'，则打印当前的素数 'a'。  总之，这段代码使用两个嵌套的循环来检查并打印小于给定输入值 'num' 的所有素数。外部循环遍历奇数，内部循环检查是否有因子能够整除当前的奇数，最终根据是否找到因子来判断是否为素数。

万分谢谢，讲解的真详细，谢谢

第一个问题：for(b=3;b*b<a;b+=2)你应该理解为，b从3开始，只要b的平方小于a，b就循环下去，而且每一次循环，b都等于b+2。第二个问题：如果b的平方大于a，则输出a的值


Question: C语言子进程全局变量问题

劝你C里别乱用全局变量，要么用静态的全局变量，通过get函数让外部获取。设计中，把全局变量规划到结构体中，需要与其他模块交互的，结构体放在头文件内，不需要与其他模块交互的，放在.c文件，这是种仿照C++的面向对象式构建，类似class里public和private。如此一来，不管模块是单实例还是多实例，全局变量也不会产生冲突。


Question: 萌新求助！感谢感谢！

@explicit_man能说一下你这个是几几年的版本吗？因为VS2015的调试连接进程叫““VsHub.exe””，后续版本不太清楚。很可能是"vshost.exe"。

抱歉，前段时间有点事，是2022版的，我试一试，非常感谢

我试了一下，结束vshost.exe之后，重新生成一下就可以解决这个问题了，感谢

这是个比较大的可能，“任务管理器”里应该是找到进程 test1.exe 并强行终止它试试

@explicit_man你好！这个应该是编译时出现错误，在程序调试时被强制终止，导致编译器一直卡在上一次调试的进程中。在下一次编译时程序文件被占用，所以无法打开也无法写入。可以进入“任务管理器”，选择标有“进程”的选项卡，进入“Visual Studio”进程，展开并找到“VsHub.exe”，点“结束任务”，然后重启电脑试试。希望能帮到你。


Question: 递归的轨迹，需要弄明白吗，怎样在程序里理解递归呢

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

谢谢您的帮助

递归不管什么语言，思路清晰是第一，首先要明确自己的需求是可以用递归：返回的数据是在循环中的某一层，且可以在最顶层往下查找的时候可以找到，并且可以有一个固定的返回格式避免栈溢出（递归是一种非常消耗性能的循环方式，如果层数过多会引起栈溢出）；递归方法即自己调用自己，在循环调用自己的时候达到某一个条件将返回所需要的数据，且不再继续往下递归！！  以上为个人理解！不喜勿喷

嗯嗯 大佬对递归的理解我十分认同我还想再请教一下：如果自己写的递归有问题，在改的时候需要把递归轨迹捋出来吗，还是有其他思考方式呢？

这个也很容易啊   最简单的方式就是debug方式查看有问题的地方；而且递归一般除非出不来，因为一般递归条件都是一样的如果有问题那就是没办法递归  也就是每一层都有问题   那如果是中间有问题   那就是看业务了   可以在每一层可能会出现问题的地方打log输出   这样也可以清除的看到当前递归到哪一层以及当前的数据是哪一样的了    毕竟递归就是一层一层往下找  然后找到对应的层数返回的时候也是一层一层往回返回的（走回头路）

哦明白了 谢谢帮助


Question: 判断能否构成三角形的代码

if ((a + b) > c and (b + c) > a and ( a + c) > b);多打了一个;

嗯嗯，现在知道了，谢谢😜

你再if那打了个分号是什么意思？？？？？？？？？？？？？？？？？？？？

才学c，不太清楚

oh

if ((a + b) > c and (b + c) > a and ( a + c) > b);有2个错误1.if ((a + b) > c && (b + c) > a &&( a + c) > b);2.行末去掉分号;

OK，感谢

这个and像极了以前刚学的样子

if 语句那行的最后不能有语句结束标记的分号吧，之前好像有个帖子有类似问题

那个分号一旦用了的话，if就不能管后面的那个else了是吧？


Question: 问题

理论上你看到的一切桌面效果，都可以用C实现，只是比较麻烦C的优势是简练，是很理想的算法描述语言所以一般用于入门和基础学习

当你刚开始学习C语言时，有许多适合练手的项目可以帮助你巩固所学知识并提高编程技能。这些项目应该是简单而有趣的，以保持你的学习动力。下面是几个适合初学者的C语言练手项目建议： 简易计算器：编写一个可以进行基本算术运算（如加法、减法和乘法）的程序，让用户能够输入数字和操作符，然后显示结果。 游戏猜数字：创建一个猜数字的小游戏，让用户尝试猜一个随机生成的数字，直到猜对为止。 单词计数器：编写一个程序，读取一个文本文件，并计算其中单词的数量、行数或字符数等信息。 简易日历：设计一个控制台程序，用户可以输入年份和月份，然后显示对应的日历。 迷宫游戏：实现一个简单的控制台迷宫游戏，让用户通过键盘输入移动指令来寻找出口。  至于C语言的应用范围，并不仅局限于后端开发。虽然C语言在系统级编程和嵌入式设备开发方面非常出色，但它也被广泛运用于其他领域。例如，它可用于游戏开发、科学计算、设备驱动程序编写、嵌入式系统开发和网络编程等。因此，学习C语言将为你打开许多不同领域的机会，并让你能够参与各种有趣的项目和应用开发。

感谢


Question: 求助！想问一下win11系统，缺少msvcr110D.dll文件打不开应用该如何解决

首先，从微软官网下载 Visual C++ Redistributable for Visual Studio 2012。你可以在以下链接找到下载页面：https://www.microsoft.com/en-us/download/details.aspx?id=30679 在下载页面中，选择适用于你的系统的版本（32位或64位），然后点击下载按钮。 下载完成后，运行下载的安装程序。 在安装向导中，按照提示进行操作。通常情况下，你只需点击 "Next" 或 "Install" 按钮来完成安装过程。 安装完成后，重新启动你的电脑。

msvcrt， vc 运行库，需要什么版本的 vc执行库吧，网上有合集的，干脆找了下载来全装上拉倒，免得不时地唧唧歪歪


当使用scanf_s函数时，可能会出现运行时错误或警告。这是因为scanf_s是安全版本的输入函数，用于防止缓冲区溢出。该函数在输入时需要提供缓冲区的大小作为参数。 示例代码： #include <stdio.h>  int main() {     char name[20];     printf("请输入您的名字：");     scanf_s("%19s", name, sizeof(name));      printf("您好，%s！\n", name);      return 0; }  上述代码中，我们声明一个大小为20的字符数组name作为缓冲区，并在scanf_s函数中指定缓冲区的大小为sizeof(name)。

理解，感谢

感谢分享


Question: 求助！为什么会重复打印You are 65.Here is your gold watch.

原来如此，谢谢


Question: C语言小白，刚学两天，请问这里else后面的应输入一个语句是啥意思

我学习c语言就是为了考试，工作上从来没用过 0.0

我们做嵌入式的主要还是C

学习c语言还用vs studio这么重型的开发工具么，不过你学习c语言干嘛呢，开发数据库还是服务器？这些都有公司开发过了，非常成熟的产品，推荐你学Go语言，更加实用性

大学要学，笨鸟先飞嘛

加油呀！

if(判断条件){  // 要执行的代码}else{  // 要执行的代码}

谢谢谢谢

判断条件后面没有冒号

你的语法不对 if后面不用接;   加了;就等于if结束了

谢谢，把；删了果然就可以了


Question: DAPP数字货币交易所开发搭建

当涉及到DAPP（去中心化应用程序）和数字货币交易所的开发时，涉及到了许多技术和概念。下面是一个简要的教程，介绍了一些你需要考虑和学习的主要方面。 区块链基础知识：首先，你需要了解区块链技术的基本原理和概念，比如共识机制、智能合约和去中心化存储等。这将有助于你更好地理解以太坊等智能合约平台的工作原理。 以太坊（Ethereum）平台：以太坊是最常用的智能合约平台之一，提供了构建DAPP的基础设施。你可以学习以太坊的背后的技术和工具，以及如何使用Solidity编写智能合约。 智能合约：智能合约是DAPP的核心组成部分。你需要学习如何使用Solidity或其他智能合约语言编写智能合约，并理解如何部署和调用它们。 客户端应用程序开发：为了与智能合约进行交互，你需要开发一个前端应用程序。使用Web3.js或其他以太坊开发库可以帮助你与智能合约进行交互，实现用户界面和交易功能。 安全性：当涉及到数字货币交易所时，安全是至关重要的。你需要学习如何保护用户的数字资产，预防潜在的攻击、漏洞和合约错误。 用户注册和身份验证：你可能需要实现用户注册和身份验证系统，以确保只有授权的用户可以访问和使用交易所。 数字货币钱包集成：为了存储和管理用户的数字货币资产，你需要与不同的数字货币钱包进行集成。学习如何与以太坊钱包进行交互，并确保安全性和良好的用户体验。 交易执行和结算：为了实现数字货币的交易，你需要学习如何执行和结算交易，包括手续费计算、订单匹配和资金转移等。 监管合规性：数字货币交易所通常需要遵守当地的金融监管法规。你需要了解相关的法律法规，并确保你的交易所符合监管要求。 运维和部署：最后，你需要考虑如何部署和维护你的DAPP交易所，包括服务器架构、数据库管理和监控等。  请注意，以上仅是一个简单的概览，涉及到DAPP交易所开发的许多复杂性细节。因此，我建议你进一步学习相关的课程、教程和文档，以获得更深入的理解和技术知识。 希望这些信息对你有帮助！如果你还有其他问题，请随时提问。 欢迎注册使用 http://www.zuixin.org.cn/ 它可以解答你遇到的大部分问题


Question: C#中如何调用C++生成DLL的unsigned char*参数

根据您提供的信息，错误可能是由于以下原因引起的： DLL文件不存在或路径不正确：请确保将ClientDLL.dll文件放在正确的位置，并检查调用代码中的路径是否正确。 DLL文件与应用程序的位数不匹配：如果您的应用程序是64位的，而ClientDLL.dll是32位的，或者反之亦然，就会出现这个错误。请确保您的应用程序和DLL文件具有相同的位数。 函数的参数类型不正确：请仔细检查GenerateKeyEx函数的参数类型并与C#中的定义进行对比。确保参数类型、大小和布局都正确匹配。 可能需要进一步设置DllImport属性：您可以尝试通过设置DllImport属性中的CallingConvention属性来解决此问题，例如：  [DllImport("ClientDLL.dll", EntryPoint = "GenerateKeyEx", CallingConvention = CallingConvention.Cdecl)]public static extern int GenerateKeyEx(    [MarshalAs(UnmanagedType.LPArray)]    byte[] ipSeedArray,    uint iSeedArraySize,    uint iSecurityLevel,    [MarshalAs(UnmanagedType.LPArray)]    byte[] ipVariant,    [MarshalAs(UnmanagedType.LPArray)]    byte[] iopKeyArray,    uint iMaxKeyArraySize); 请尝试根据上述建议进行修改，如果问题仍然存在，请提供更多的代码和错误信息，以便我可以更好地帮助您。

试下stringbuilder


Question: 目前的人工智能太让人失望了，你们觉得呢

还优化？代码都是网上抄来的，你当它真的会编程？你断网让它写个程序试试(以前没写过的)～

从大部分专业领域讲，如果以10分制代表目前人类达到的顶尖水平，那么目前AI经过优化后能做到23，少部分领域能达到4甚至5。人类水平近似指数分布，也就是说AI至少超越了30%50%的人类。或许你觉得AI并不咋地，但我评估过GPT对文章的润色和程序代码的优化，对于缺少项目经验的应届生而言基本上是碾压的……应该庆幸目前的AI仍是一个个孤岛。如果有朝一日这些孤岛联成了网络，并且把人类所有的研究成果不设防地喂狗，那么这个狗子超越人类是指日可待的事情。

嗯嗯嗯，但是吧，能替我们解决很多专业方面的问题，尤其是谷歌上的chat4，真的有程序员思维。国内的文心一言，我在用内测的，感觉上那个比较类似于搜索引擎，不会和我进行连续的对话，这是相对而言的一个比较大的差距。

认同这个观点


Question: 串口发送文件，发送的文件和接收到的文件大小为什么会不一致呢？？

多线程需要加锁

请问 哪里需要加锁？

void *sersend(void *arg) // 串口发送线程函数{    int ik = 0; std::ifstream file; // 以只读方式打开文件 file.open("yyj.pdf", std::ios::in);  // 指针定位到文件末尾 file.seekg(0, std::ios::end); int fileLength = file.tellg();  // 指定定位到文件开始 file.seekg(0, std::ios::beg);  cout << "fileLength:" << fileLength << endl; char *buffer = new char[fileLength + 1]; file.read(buffer, fileLength); buffer[fileLength] = '\0'; // string contents = buffer; // cout << "contents:" << contents << endl; write_serial_data(fd, (char *)buffer, fileLength); if (buffer) {     delete[] buffer; } file.close();  }  我读文件改成 这个读的模式， 测试几次，这个PDF文件是没有问题的，具体啥原因不是太清楚。

所以是原始文件大小和发送字节数不一致？还是发送字节数和接收字节数不一致？还是接受字节数和写出来的文件大小不一致？

看我这个问题是 发送，接收是正确的，问题应该是出在读文件上了， 上述回复我已经把这个代码贴出来了，方便大家


Question: C 嵌入 SQL统带 连接数据库报错

infomix esql/c？这个东西的原理是用一个专用的预处理器将源码中嵌入的sql语句转换为对esql库函数的调用。所以嵌入的sql语句必须是编译时可求值的常量，只有参数可以用变量

学习了。原本不了解还有这样的解决方案。

问题太简洁了，缺乏约束条件。所以可能性太多。


Question: 树的应用与实现  我的代码有什么问题 用的Dev-c++

在函数InitCtree中，使用scanf函数接收输入时，应该使用"%d"格式化符来接收整数，而不是"%c"格式化符来接收字符。 在函数AddChild中，应该在创建CTNode结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数ExchangeTree中，应该在创建BTNode结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数ExchangeTree中，应该在创建第一个孩子结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数ExchangeTree中，应该在创建兄弟结点之后，判断是否成功分配内存，如果分配失败应该进行相应的错误处理。 在函数PostOrder中，应该在访问完根结点之后，将mark指向根结点，而不是将mark指向p。 在函数PostOrder中，应该在访问完根结点之后，将p出栈，而不是将p指向栈顶指针。 在函数PostOrder中，应该在访问完根结点之后，将mark指向根结点的父结点，而不是将mark指向根结点。 在函数PostOrder中，应该在访问完根结点之后，将p出栈之前，先将p赋值给e，然后再出栈。 在函数main中，应该在调用ExchangeTree函数之后，判断是否成功转换二叉树，如果转换失败应该进行相应的错误处理。 在函数main中，应该在调用InitCtree函数之后，判断是否成功初始化树，如果初始化失败应该进行相应的错误处理。


Question: 大佬们，为啥会出现3221225477错误

3221225477 = 0xC0000005 拒绝访问，一般是使用了空/错误指针；看源程序，scanf(...) 里，那些 int 类型的域，都没有引用地址，全错了。


Question: 这个 gcc openmp code 实现并行了吗？怎么速度没变？

某银行分理处，说我处日常开8个窗口为广大用户提供服务。然而在岗的柜员只有1组，她(们)在1号窗口办理一件以后连忙跑到2号窗口坐下，还得面带笑容地问，为啥我的工作效率没有提高到8倍呢？

实现并行：根据你的代码，你使用了OpenMP的并行指令#pragma omp parallel for，并设置了线程数为8（omp_set_num_threads(8)）。这应该可以实现并行计算。然而，你的代码中的计算任务非常简单（对一个循环变量赋值），这种情况下并行化可能不会带来明显的性能提升。 耗时不减少的原因：你的计算任务实际上是一个很轻量级的任务，循环中的计算操作很快就会完成。在这种情况下，并行化的开销可能会超过并行计算带来的性能提升。此外，你的代码中没有涉及到对共享数据的访问或复杂的计算操作，这也限制了并行计算的效果。 减少耗时的方法：如果你想看到并行计算带来的明显性能提升，你需要选择更复杂、耗时较长的计算任务。例如，可以尝试在循环中进行更复杂的数值计算或数据处理操作。 实现并行：你的代码中已经使用了OpenMP来实现并行计算。如果你的代码运行时没有报错，并且输出结果与预期一致，那么你的代码已经成功并行化了。 核心数量与性能提升：服务器的核心数量决定了能够同时执行的线程数。在你的代码中，你设置了8个线程，因此在多核服务器上运行时可以同时执行8个线程。然而，并行计算的性能提升不仅取决于核心数量，还受限于任务的性质、计算复杂度以及数据访问模式等因素。 在实际情况下，性能提升的幅度取决于并行计算的可扩展性和负载平衡。对于复杂的计算任务和合理的并行算法，提高性能的幅度可以达到核心数量的数量级。然而，并行化不会线性地提高性能，因为存在一些开销，例如线程之间的同步、数据划分和通信等。  总结：对于像你提供的代码中的简单计算任务，可能无法通过并行化获得明显的性能提升。如果你想看到并行计算的效果，可以选择更复杂的计算任务，并确保任务本身足够耗时和具有合理的并行算法。此外，性能提升也受到硬件限制、负载平衡和算法设计等因素的影响。


应该是基于32位系统开发，然后64位不支持。或者封闭有问题。


Question: 小萌新寻求大佬们的帮助，阿里嘎多，嘤

你好朋友，看起来这个问题是 Visual Studio 编译器对 scanf 函数的一个警告。该警告是由于 scanf 函数可能面临缓冲区溢出、格式化字符串漏洞等安全问题而引起的。 为了解决这个问题，Microsoft 引入了 scanf_s 函数作为 scanf 函数的替代品，它提供了更多的安全保障。scanf_s 与 scanf 的使用方式相似，但在格式说明符之后需要指定读取的数据长度。 例如，以下代码展示了如何使用 scanf_s 从标准输入读取一个整数： #include <stdio.h>  int main() {     int num;     printf("Enter a number: ");     scanf_s("%d", &num, sizeof(num));     printf("You entered: %d\n", num);     return 0; }  如果你必须使用 scanf 函数，可以通过在源代码中添加预编译指令 #define _CRT_SECURE_NO_WARNINGS 来抑制此警告。然而，这并不推荐，因为这么做可能会降低程序的安全性。除此之外，有些编译器不支持这个指令，这样就会导致编译失败。答题不易，有帮助可以支持一下

好哒，非常感谢


Question: 萌新跪请大佬们指点这个代码的问题到底在哪里

@CSDN-Ada助手 标红的地方代码不能运行。得出的结果始终是一个空字典。但是之前用另外的excel表格又是可以的。萌新完全懵逼了，请大佬们拔冗指点一下，


Question: 找一个开发C语言的浏览器的填表程序。有意联系我。在页面进行循环操作。

?什么意思


Question: 排列组合查找算法求助

选定了三个号后，可能的组合相当于C(46, 4) = 163185种，可以直接生成~

仅供参考： #include <stdio.h> #include <stdlib.h> #define MAX_NUM 26 int comb[MAX_NUM]; int c1,c2; void combination(int m,int n) {     int i,j;      for (i=m;i>=n;i--) {         comb[n]=i; /* 选择当前的“头”元素 */         if (n>1) {             combination(i-1,n-1); /* 进入下一次更小的组合问题 */         } else { /* 满了需要的组合数，输出 */             for (j=comb[0];j>0;j--) printf("%c",'A'+c1-comb[j]);             printf("\n");         }     }     return; } int main(int argc,char **argv) {     if (argc<3) {         printf("%s 组合下标 组合上标\n",argv[0]);         return 1;     }     c1=atoi(argv[1]);     if (c1<1 || MAX_NUM<c1) {         printf("1<=组合下标<=%d\n",MAX_NUM);         return 2;     }     c2=atoi(argv[2]);     if (c2<1 || c1<c2) {         printf("1<=组合上标<=组合下标\n");         return 3;     }     comb[0]=c2;     combination(c1,c2);     return 0; }    //qplw.cpp #include <stdio.h> #include <string.h> #include <stdlib.h> int v=0; int w=0; int m;//记录字符串长度 int n;//记录字符串中的字符种类数 char map[256];//记录是哪几种字符 int count[256];//记录每种字符有多少个 int stack[1000];//递归用的栈，并记录当前生成的排列 void Make_Map(char *str) {//统计字符串的相关信息     int s[256];     int i;     memset(s,0,sizeof(s));     memset(count,0,sizeof(count));     m=strlen(str);     if (w<1 || m<w) w=m;     while(*str) {         s[*str]++;         str++;     }     n=0;     for (i=0;i<256;i++)         if (s[i]) {             map[n]=i;             count[n]=s[i];             n++;         } } void Find(int depth) {//递归式回溯法生成全排列     if (depth==w) {         int i;         for (i=0;i<depth;i++) putchar(map[stack[i]]);         putchar('\n');     } else {         int i;         if (v && depth>0) {             for (i=0;i<depth;i++) putchar(map[stack[i]]);             putchar('\n');         }         for (i=0;i<n;i++)             if (count[i]) {                 stack[depth]=i;                 count[i]--;                 Find(depth+1);                 count[i]++;             }     } } void main(int argc,char**argv) {     if (argc<2) {         printf("%s 要产生全排列的字符串 [限定长度|-1]\n",argv[0]);         return;     }     if (argc>=3) w=atoi(argv[2]);     if (-1==w) v=1;     Make_Map(argv[1]);     Find(0); } //C:\test>qplw //qplw 要产生全排列的字符串 [限定长度|-1] // //C:\test>qplw 123 //123 //132 //213 //231 //312 //321 // //C:\test>qplw 123 2 //12 //13 //21 //23 //31 //32 // //C:\test>qplw 122333 3 //122 //123 //132 //133 //212 //213 //221 //223 //231 //232 //233 //312 //313 //321 //322 //323 //331 //332 //333 // //C:\test>qplw 123 -1 //1 //12 //123 //13 //132 //2 //21 //213 //23 //231 //3 //31 //312 //32 //321 //

某三个号码是固定组合？没有次序变化吧


Question: 关于ME2159升压电路的疑问

用芯生美的CSM9201试试，可以提供DEMO测试

你的原理图上少画了一个肖特基二极管。

@CSDN-Ada助手 有请ada 来解释一下。


Question: 求助，有注释，我的代码没有问题，但运行到一半总会跳过一段代码，怀疑是内存不足，希望有大佬指点迷津，软件为dev-c++

贴主，请你去 ask.csdn.net 提问，会有更多人回答。

@CSDN-Ada助手 请看这个程序的问题，谢谢。 程序的任务是做一个迷宫并走通

程序运行到一半就退出

后面没看，只看到**,**存放在长度5的字符数组了，没处放结束符。如果没有使用字符串相关的库函数，这样用是可以的，然而您愉快地使用了字符串库函数。

是不是我的注释不够清晰啊，本人大一，写出来的代码基本是一坨，大家有被我弄迷惑的可以在评论里说一下

忘了说了，我的任务是做一个迷宫并走通

你看看 user-3 给你的解释


Question: 小白请教问题  :)

return 0；

那个scanf("%d %d")中间别加空格


Question: 小白请教这个代码为啥崩了

使用更改后的代码重新运行，你打印字符串就好好打印字符串，不要变动指针 #include <stdio.h> #include <stdlib.h>  void modify(char*& p) {     p = (char*)malloc(100);     fgets(p, 100, stdin); }  int main() {     char* p;     modify(p);     printf("%s\n", p);     free(p);     return 0; }

嗯是的没错

@CSDN-Ada助手请问上面的代码有什么问题呢？

啥叫崩了呢？

进程意外退出


Question: gcc openmp 入门问题

根据 OpenMP-master.zip 里的示例，我进行了以下尝试。但是无论其中 openmp 的代码写不写进去，运行时间都是大约10秒。而且这个耗时还是可重复的，总是这么长时间。这台服务器是多核的，不是单核的。 请问： 它到底实现没实现并行？如果实现了，为什么耗时不减少？怎么样才能减少耗时？如果没有实现并行，怎么样才能实现并行？如果能实现并行，是不是这台服务器有几个核，速度最多就只能提高到几倍？ 谢谢。 #include <stdio.h>#include <string.h>#include <stdlib.h>#include <omp.h> int main(){ unsigned long i, j; omp_set_num_threads(8); #pragma omp parallel for for(i=0;i<4294967296;i++) {  j = i; } return 0;}

#pragma omp parallel for num_threads(8)这一行前面的#改为//。C代码里面单行注释是//


Question: 询问了几个人都有点模糊，这是对定义字符串的模糊。

C

C只初始化了一个4字符的数组，不是字符串~

你是对的。

D


Question: 求大神解答一下哪里有问题

1、结构体里没有“英语成绩”2、main函数第一个for循环中第一个输入cin>>studentS，这个变量名写错了3、第二个for前面变量声明的时候空格丢个4、最后输出名字的时候变量名又写错了 #include <iostream> #include <string>   using namespace std;  struct Student {     string name;     float c_s;     float m_s;     float eh_s;     float avg_s; };   int main() {     Student students[3];     for (int i=0; i<3; i++) {         cout<< "input the "<< i+1 <<"student name:";         cin >> students[i].name;         cout<< "input Ch score:";         cin >> students[i].c_s;         cout<< "input math score:";         cin >> students[i].m_s;         cout<< "input eh score:";         cin >> students[i].eh_s;         students[i].avg_s = ( students[i].c_s + students[i].m_s + students[i].eh_s )/3.0;     }           int max_index = 0;          for (int i=1; i<3; i++) {         if (students[i].avg_s > students[max_index].avg_s) {             max_index=i;         }     }          cout << "max " << students[max_index].name << endl;     cout << "avg score " << students[max_index].avg_s << endl; }

球球了


Question: 求解，请问哪里出错了？

请问main你的  return 0；到哪里去了

你的返回值类型是int，而你没有返回值,return ;解决办法1：将返回值类型int改为void解决办法2：加返回值

你好，现在改了，还是有这个问题 【】

在这段代码中有几个语法错误，需要进行修正。首先，for 循环后面应该是一个代码块，而不应该以分号 ; 结尾。此外，在判断式中的 a % 6 = 5 应该修改为 a % 6 == 5。最后，printf() 函数调用中的逗号 , 应该修改成英文状态下的逗号 ,。 修正后的代码如下： #include <stdio.h>  int main() {     int a;     for (a = 0;; a++) {         if (a % 2 == 1 && a % 3 == 2 && a % 5 == 4 && a % 6 == 5 && a % 7 == 0) {             break;         }     }     printf("%d", a);     return 0; }  这段代码利用了 for 循环和条件判断语句，对变量 a 进行递增操作，直到找到符合要求的取值停止循环，并且将该值通过 printf() 函数输出。其中 % 表示模运算符，表示对于两个整数，返回它们相除的余数。因此如果 a%2 ==1 则表示 a 除以 2 的余数为 1，其他判断条件同理。

好像不是这几个原因


Question: 函数调用时参数内容发生变化

@赵4老师谢谢老师。我打了断点，下图是反汇编模式下看到的调用情况： 当执行这一行指令时可以看到，下方打印出这个地址的值是正确的，然后单步执行到下一行，如下图：  这个地址的第一个字符被修改成了\000，后面的字符没有变化，这是什么原因呢？

仅供参考： #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

谢谢老师，但是我没看懂是什么意思。

意思就是当你发现某个变量的值莫名其妙不知道被哪里的代码改变了的时候，在这个变量所在地址设置数据断点，再重新开始调试运行，一旦值被改，就会停在修改值的C语句或汇编指令处，此时可以按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。

补充hashmap和list的数据结构


Question: 请问这个程序有什么问题吗，为什么把c设置为整型就可以打印出来，但是如果设置为字符型就什么都不显示。

你没发现两个逗号长得不一样吗？

嗯嗯 刚刚发现了 是自己手残、


Question: 函数内部变量可以被外部访问

栈中的变量通常包括函数参数和函数里声明的临时变量。栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。而栈中的类变量退出其作用域时，会自动执行其析构函数，……所谓在栈中“申请”N字节的空间，其实只是将栈指针寄存器（16位sp，32位esp，64位rsp）的值多减N而已。 其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。 计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）

感谢老师


Question: 请问我这个程序有什么问题嘛，为什么只会输出等级A?

90<=a && a<=100

if条件都错了……2个条件是不是应该用a<=100&&a>=90来表达


Question: java初学者正在跟着翁恺老师学，有一个数数字的问题搞不懂，希望大神们能给解答一下。

打印一下看数字位数，你就明白了

int number=... 这是个整数，若到了个位数，再 /10 结果就是 0 了


Question: 求教-windows控制台CMD putc 打印问题

严格的说是你括号的位置不对while (ch = (getc(fp)) != EOF)改为while ((ch = getc(fp)) != EOF) {

少写了括号，优先级问题while (ch = (getc(fp)) != EOF)改为while ((ch = (getc(fp))) != EOF)

不是中文，是全英文写的hello world

@CSDN-Ada助手 putc输出方框乱码是什么原因？


Question: DEVC++写C语言代码，第一次运行时正常的，但退出再运行就不出现结果了

换VS2022（安装时注意勾选C++桌面开发，默认不勾选）

可能出现了卡顿情况,电脑刷新一下再试试,如果还不行，就把代码复制到一个新的界面,重新编译运行,如果还不行，就是电脑或者devc++的问题了。


Question: 求助，各位大佬们，明天就要交作业啦，呜呜呜

@CSDN-Ada助手 "scanf: This function or variable may be unsafe, Consider using scanf_s" 请写代码对比scanf和scanf_s用法，C4996警告应该怎样解决。

谢谢

谢谢啦

在源代码最上方加上#pragma warning(disable:4996)或者#define _CRT_SECURE_NO_WARNINGS 1都可以。

谢谢，辛苦了


Question: C语言编译没有错误但运行时结果没有出来

调试可以解决百分之九十的问题

可以单步跟踪看看问题出现在哪里

例如我现在正在说的这句话，语法是正确的，然而是废话，不产生输出。

你真是人才


Question: Huffman树的创建，编码，解码

仅供参考： #include <iostream> #include <string> using namespace std; struct huffTree {     int parent;     int lchild;     int rchild;     int weight;     string flag; }; struct Lowest_node {     char ch;     int ch_num; }; void coding(int length,huffTree *tree,int n,int &a,int &b) {     int i;     int r,s;      r=s=length;     for (i=0;i<n;i++) {         if (tree[i].weight<r          && tree[i].parent==-1) {             r=tree[i].weight;             a=i;         }     }     for (i=0;i<n;i++) {         if (tree[i].weight<s          && i!=a          && tree[i].parent==-1) {             s=tree[i].weight;             b=i;         }     } } void frequency(string str) {     int i,j;     int length=str.length();     Lowest_node *node=new Lowest_node[length];      for (i=0;i<length;i++) node[i].ch_num=0;      int char_type_num=0;     for (i=0;i<length;i++) {         for (j=0;j<char_type_num;j++)             if (str[i]==node[j].ch             || ('a'<=node[j].ch && node[j].ch<='z'                 && str[i]+32==node[j].ch))                 break;//         if (j<char_type_num) node[j].ch_num++;         else {             if ('A'<=str[i] && str[i] <= 'Z') node[j].ch=str[i]+32;             else node[j].ch=str[i];             node[j].ch_num++;             char_type_num++;         }     }     for (i=0;i<char_type_num;i++) {         for (j=i;j<char_type_num;j++) {             if (node[j].ch_num<node[j+1].ch_num) {                 int temp;                 char ch_temp;                 temp=node[j].ch_num;                 ch_temp=node[j].ch;                 node[j].ch_num=node[j+1].ch_num;                 node[j].ch=node[j+1].ch;                 node[j+1].ch_num=temp;                 node[j+1].ch=ch_temp;             }         }     }     for (i=0;i<char_type_num;i++)         cout<<"字符"<<node[i].ch<<"出现了"<<node[i].ch_num<<"次"<<endl;     huffTree *huff=new huffTree[2*char_type_num-1];     huffTree temp;     string *code=new string[2*char_type_num-1];      for (i=0;i<2*char_type_num-1;i++) {         huff[i].lchild=-1;         huff[i].parent=-1;         huff[i].rchild=-1;         huff[i].flag=-1;     }     for (j=0;j<char_type_num;j++) huff[j].weight=node[j].ch_num;     int min1,min2;     for (int k=char_type_num;k<2*char_type_num-1;k++) {         coding(length,huff,k,min1,min2);         huff[min1].parent=k;         huff[min2].parent=k;         huff[min1].flag="0";         huff[min2].flag="1";         huff[k].lchild=min1;         huff[k].rchild=min2;         huff[k].weight=huff[min1].weight+huff[min2].weight;     }     for (i=0;i<char_type_num;i++) {         temp=huff[i];         while (1) {             code[i]=temp.flag+code[i];             temp=huff[temp.parent];             if (temp.parent==-1) break;//         }     }     cout<<"字符串的每个字符huffman编码为："<<endl;     for (i=0;i<char_type_num;i++) cout<<node[i].ch<<"  "<<code[i]<<endl;     cout<<"整个字符串的huffman编码为："<<endl;     for (i=0;i<length;i++) {                                                                                //S?         for (j=0;j<char_type_num;j++) {             if (str[i]==node[j].ch)                 cout<<code[j];         }     }     delete[] node;     node=NULL;     delete[] huff;     huff=NULL;     delete[] code;     code=NULL; } int main() {     int length=0;     string str;     cout<<"请输入一个字符串：";     cin>>str;     frequency(str);     return 0; } //请输入一个字符串：2333abcde //字符3出现了3次 //字符2出现了1次 //字符a出现了1次 //字符b出现了1次 //字符c出现了1次 //字符d出现了1次 //字符e出现了1次 //字符串的每个字符huffman编码为： //3  11 //2  000 //a  001 //b  010 //c  011 //d  100 //e  101 //整个字符串的huffman编码为： //000111111001010011100101

谢谢


Question: 程序设计题目：排班系统

每周只上一天班？这保安也太舒服～

lz排出的是轮休表，不是值日表。。。


Question: 求问只能正常运行调用的第一个函数的原因

在每个最后不带\n的printf后面加fflush(stdout);在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin);另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。

do {       printf("Enter 1 to calculate factorial\n");       printf("Enter 2 to calculate fibonacci\n");       printf("Enter 3 to exit\n");       printf("Enter your choice: ");       scanf("%d", &choice);        switch (choice) {           case 1: {               int n, i;               printf("Enter a number: ");               scanf("%d", &n);               srand(time(NULL));               factorial(n);               break;           }            case 2: {               int n;               printf("Enter the number of elements: ");               scanf("%d", &n);               srand(time(NULL));               fibonacci(n);               break;           }            case 3: {               printf("Goodbye!\n");               break;           }            default: {               printf("Invalid choice! Please try again.\n");               break;           }       }        printf("Do you want to continue? (yes/no): ");       scanf("%s", answer);   } while (strcmp(answer, "yes") != 0);

感谢您的回复，但内容与问题无关


Question: 我有点懵了，这么做会被卡住吗？线程玩的熟的帮忙看看。

在析构函数中，线程pool在等待所有子线程退出时一直持有taskQueMtx_的锁，这会导致在子线程尝试获取任务时无法获取到锁，从而导致互锁的情况。为了避免这种情况，可以使用线程安全的等待所有子线程退出的方式，例如使用std:🧵:join_all()函数等待所有子线程退出。这样可以避免在等待过程中一直持有锁的情况，从而避免互锁问题。

谢谢回复 我理解也是会卡住 关键这段代码一直在生产环境使用 从没有卡过。。。

谢谢回复 我理解也是会卡住 关键这段代码一直在生产环境使用 从没有卡过。。。

常在c用多线程处理数据，没在c++用过，但原理应该差不多。看你的程序只有一个锁，在一个线程上锁后其他线程无法使用这个锁，所以应该不会有冲突。

谢谢回答 冲突到没发生 析构的线程和任务的线程肯定不同 但是析构的阻塞掉了 我感觉任务线程有可能卡在④上啊，这块是不是应该会有风险，即使是运气最差的情况下

4这个位置不会卡，它会等1这个位置的锁解锁后才可以对锁进行操作，即使它们属于不同线程也会等待。

但是有可能出现互锁呢 1等4 4等1


Question: 力扣：11. 盛最多水的容器

要让p2指向传入数组的最后一个元素，可以将p2的初始值设置为height + heightSize - 1，即&height[heightSize - 1]。这样，在循环中每次移动指针时，p2就会指向数组的最后一个元素。

数量这玩意只能传进来，不传进来谁知道有几个

第二参数难道不是做这个的么？

int *p2 = &height[heightSize-1];我之前这样写打错了，


Question: vsc怎样配置调用外部函数的那个参数

在当前项目中有实现GetAngle的.c/.cpp源代码或附加连接库里有GetAngle的实现。

我在同一目录下命名了两个文件：Test1.c和Test2.c，这是1里面的，我也在2里面定义了GetAngle函数

还请大佬说的详细点

同一目录下不一定有用，得在makefile（使用nmake生成）或当前项目中添加现有项选Test2.c（使用VS20xx生成）

大佬，求解


Question: 为什么函数里第二行int nums[len];会报错

数组的大小使用变量len来指定，而len的值是在运行时计算得到的，编译器无法确定数组大小，所以会报错。

int *nums=new int[len]; delete [] nums;//nums用完后

感谢

len是变量

哦哦，我知道了，不能在运行时才知道数组的大小，我以为java

你的编译器应该已经告诉你了，它不支持动态大小的数组。

啊？len不是定义的吗

我在vsc调式的时候到这里要点好多次下一步，也可以正常出结果

抱歉，我知道了，不能在运行时才知道数组的大小，我以为java


Question: 程序语言设计基础的课程设计【大哭】，C语言小白表示太难了，题目是会员卡计费系统，想问问有没有C语言大佬帮我解答一下疑问，我的消费总额和充值总额算不出来【大哭】，代码如有雷同他人的，我就是借鉴的那个。

加油，继续努力！！

你add（）函数里打开文件进行追加时（fp=fopen（“emploee_list”，“a”）；），文件名有拼写错误。它应该是“employee_list”，

谢谢

大哥教教我我新手.网课大学生现在啥也不会求带

您可以帮我解答一下消费总额和充值总额为什么算不出来吗？【大哭】

建议使用charGPT

希望有大佬能为我解答，急！


Question: c语言学生成绩系统课程设计

我也小白，首先我感觉int n 完全没必要传参，sort函数里t没有初始化

174   应该定义一个指针，把满足条件的保存         char *p = (char*)malloc( N * sizeof(char));        好吧我也不知道这能不能行

感谢我去试试


Question: 硬件CRC校验和软件CRC校验的问题

参考zlib\crc32.c: /* crc32.c -- compute the CRC-32 of a data stream  * Copyright (C) 1995-2006, 2010 Mark Adler  * For conditions of distribution and use, see copyright notice in zlib.h  *  * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster  * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing  * tables for updating the shift register in one step with three exclusive-ors  * instead of four steps with four exclusive-ors.  This results in about a  * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.  */  /* @(#) $Id$ */  /*   Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore   protection on the static variables used to control the first-use generation   of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should   first call get_crc_table() to initialize the tables before allowing more than   one thread to use crc32().  */  #ifdef MAKECRCH #  include <stdio.h> #  ifndef DYNAMIC_CRC_TABLE #    define DYNAMIC_CRC_TABLE #  endif /* !DYNAMIC_CRC_TABLE */ #endif /* MAKECRCH */  #include "zutil.h"      /* for STDC and FAR definitions */  #define local static  /* Find a four-byte integer type for crc32_little() and crc32_big(). */ #ifndef NOBYFOUR #  ifdef STDC           /* need ANSI C limits.h to determine sizes */ #    include <limits.h> #    define BYFOUR #    if (UINT_MAX == 0xffffffffUL)        typedef unsigned int u4; #    else #      if (ULONG_MAX == 0xffffffffUL)          typedef unsigned long u4; #      else #        if (USHRT_MAX == 0xffffffffUL)            typedef unsigned short u4; #        else #          undef BYFOUR     /* can't find a four-byte integer type! */ #        endif #      endif #    endif #  endif /* STDC */ #endif /* !NOBYFOUR */  /* Definitions for doing the crc four data bytes at a time. */ #ifdef BYFOUR #  define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \                 (((w)&0xff00)<<8)+(((w)&0xff)<<24))    local unsigned long crc32_little OF((unsigned long,                         const unsigned char FAR *, unsigned));    local unsigned long crc32_big OF((unsigned long,                         const unsigned char FAR *, unsigned)); #  define TBLS 8 #else #  define TBLS 1 #endif /* BYFOUR */  /* Local functions for crc concatenation */ local unsigned long gf2_matrix_times OF((unsigned long *mat,                                          unsigned long vec)); local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2);   #ifdef DYNAMIC_CRC_TABLE  local volatile int crc_table_empty = 1; local unsigned long FAR crc_table[TBLS][256]; local void make_crc_table OF((void)); #ifdef MAKECRCH    local void write_table OF((FILE *, const unsigned long FAR *)); #endif /* MAKECRCH */ /*   Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:   x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.    Polynomials over GF(2) are represented in binary, one bit per coefficient,   with the lowest powers in the most significant bit.  Then adding polynomials   is just exclusive-or, and multiplying a polynomial by x is a right shift by   one.  If we call the above polynomial p, and represent a byte as the   polynomial q, also with the lowest power in the most significant bit (so the   byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,   where a mod b means the remainder after dividing a by b.    This calculation is done using the shift-register method of multiplying and   taking the remainder.  The register is initialized to zero, and for each   incoming bit, x^32 is added mod p to the register if the bit is a one (where   x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by   x (which is shifting right by one and adding x^32 mod p if the bit shifted   out is a one).  We start with the highest power (least significant bit) of   q and repeat for all eight bits of q.    The first table is simply the CRC of all possible eight bit values.  This is   all the information needed to generate CRCs on data a byte at a time for all   combinations of CRC register values and incoming bytes.  The remaining tables   allow for word-at-a-time CRC calculation for both big-endian and little-   endian machines, where a word is four bytes. */ local void make_crc_table() {     unsigned long c;     int n, k;     unsigned long poly;                 /* polynomial exclusive-or pattern */     /* terms of polynomial defining this crc (except x^32): */     static volatile int first = 1;      /* flag to limit concurrent making */     static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};      /* See if another task is already doing this (not thread-safe, but better        than nothing -- significantly reduces duration of vulnerability in        case the advice about DYNAMIC_CRC_TABLE is ignored) */     if (first) {         first = 0;          /* make exclusive-or pattern from polynomial (0xedb88320UL) */         poly = 0UL;         for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)             poly |= 1UL << (31 - p[n]);          /* generate a crc for every 8-bit value */         for (n = 0; n < 256; n++) {             c = (unsigned long)n;             for (k = 0; k < 8; k++)                 c = c & 1 ? poly ^ (c >> 1) : c >> 1;             crc_table[0][n] = c;         }  #ifdef BYFOUR         /* generate crc for each value followed by one, two, and three zeros,            and then the byte reversal of those as well as the first table */         for (n = 0; n < 256; n++) {             c = crc_table[0][n];             crc_table[4][n] = REV(c);             for (k = 1; k < 4; k++) {                 c = crc_table[0][c & 0xff] ^ (c >> 8);                 crc_table[k][n] = c;                 crc_table[k + 4][n] = REV(c);             }         } #endif /* BYFOUR */          crc_table_empty = 0;     }     else {      /* not first */         /* wait for the other guy to finish (not efficient, but rare) */         while (crc_table_empty)             ;     }  #ifdef MAKECRCH     /* write out CRC tables to crc32.h */     {         FILE *out;          out = fopen("crc32.h", "w");         if (out == NULL) return;         fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");         fprintf(out, " * Generated automatically by crc32.c\n */\n\n");         fprintf(out, "local const unsigned long FAR ");         fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");         write_table(out, crc_table[0]); #  ifdef BYFOUR         fprintf(out, "#ifdef BYFOUR\n");         for (k = 1; k < 8; k++) {             fprintf(out, "  },\n  {\n");             write_table(out, crc_table[k]);         }         fprintf(out, "#endif\n"); #  endif /* BYFOUR */         fprintf(out, "  }\n};\n");         fclose(out);     } #endif /* MAKECRCH */ }  #ifdef MAKECRCH local void write_table(out, table)     FILE *out;     const unsigned long FAR *table; {     int n;      for (n = 0; n < 256; n++)         fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ", table[n],                 n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); } #endif /* MAKECRCH */  #else /* !DYNAMIC_CRC_TABLE */ /* ========================================================================  * Tables of CRC-32s of all single-byte values, made by make_crc_table().  */ #include "crc32.h" #endif /* DYNAMIC_CRC_TABLE */  /* =========================================================================  * This function can be used by asm versions of crc32()  */ const unsigned long FAR * ZEXPORT get_crc_table() { #ifdef DYNAMIC_CRC_TABLE     if (crc_table_empty)         make_crc_table(); #endif /* DYNAMIC_CRC_TABLE */     return (const unsigned long FAR *)crc_table; }  /* ========================================================================= */ #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1  /* ========================================================================= */ unsigned long ZEXPORT crc32(crc, buf, len)     unsigned long crc;     const unsigned char FAR *buf;     uInt len; {     if (buf == Z_NULL) return 0UL;  #ifdef DYNAMIC_CRC_TABLE     if (crc_table_empty)         make_crc_table(); #endif /* DYNAMIC_CRC_TABLE */  #ifdef BYFOUR     if (sizeof(void *) == sizeof(ptrdiff_t)) {         u4 endian;          endian = 1;         if (*((unsigned char *)(&endian)))             return crc32_little(crc, buf, len);         else             return crc32_big(crc, buf, len);     } #endif /* BYFOUR */     crc = crc ^ 0xffffffffUL;     while (len >= 8) {         DO8;         len -= 8;     }     if (len) do {         DO1;     } while (--len);     return crc ^ 0xffffffffUL; }  #ifdef BYFOUR  /* ========================================================================= */ #define DOLIT4 c ^= *buf4++; \         c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \             crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4  /* ========================================================================= */ local unsigned long crc32_little(crc, buf, len)     unsigned long crc;     const unsigned char FAR *buf;     unsigned len; {     register u4 c;     register const u4 FAR *buf4;      c = (u4)crc;     c = ~c;     while (len && ((ptrdiff_t)buf & 3)) {         c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);         len--;     }      buf4 = (const u4 FAR *)(const void FAR *)buf;     while (len >= 32) {         DOLIT32;         len -= 32;     }     while (len >= 4) {         DOLIT4;         len -= 4;     }     buf = (const unsigned char FAR *)buf4;      if (len) do {         c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);     } while (--len);     c = ~c;     return (unsigned long)c; }  /* ========================================================================= */ #define DOBIG4 c ^= *++buf4; \         c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \             crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4  /* ========================================================================= */ local unsigned long crc32_big(crc, buf, len)     unsigned long crc;     const unsigned char FAR *buf;     unsigned len; {     register u4 c;     register const u4 FAR *buf4;      c = REV((u4)crc);     c = ~c;     while (len && ((ptrdiff_t)buf & 3)) {         c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);         len--;     }      buf4 = (const u4 FAR *)(const void FAR *)buf;     buf4--;     while (len >= 32) {         DOBIG32;         len -= 32;     }     while (len >= 4) {         DOBIG4;         len -= 4;     }     buf4++;     buf = (const unsigned char FAR *)buf4;      if (len) do {         c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);     } while (--len);     c = ~c;     return (unsigned long)(REV(c)); }  #endif /* BYFOUR */  #define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */  /* ========================================================================= */ local unsigned long gf2_matrix_times(mat, vec)     unsigned long *mat;     unsigned long vec; {     unsigned long sum;      sum = 0;     while (vec) {         if (vec & 1)             sum ^= *mat;         vec >>= 1;         mat++;     }     return sum; }  /* ========================================================================= */ local void gf2_matrix_square(square, mat)     unsigned long *square;     unsigned long *mat; {     int n;      for (n = 0; n < GF2_DIM; n++)         square[n] = gf2_matrix_times(mat, mat[n]); }  /* ========================================================================= */ local uLong crc32_combine_(crc1, crc2, len2)     uLong crc1;     uLong crc2;     z_off64_t len2; {     int n;     unsigned long row;     unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */     unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */      /* degenerate case (also disallow negative lengths) */     if (len2 <= 0)         return crc1;      /* put operator for one zero bit in odd */     odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */     row = 1;     for (n = 1; n < GF2_DIM; n++) {         odd[n] = row;         row <<= 1;     }      /* put operator for two zero bits in even */     gf2_matrix_square(even, odd);      /* put operator for four zero bits in odd */     gf2_matrix_square(odd, even);      /* apply len2 zeros to crc1 (first square will put the operator for one        zero byte, eight zero bits, in even) */     do {         /* apply zeros operator for this bit of len2 */         gf2_matrix_square(even, odd);         if (len2 & 1)             crc1 = gf2_matrix_times(even, crc1);         len2 >>= 1;          /* if no more bits set, then done */         if (len2 == 0)             break;          /* another iteration of the loop with odd and even swapped */         gf2_matrix_square(odd, even);         if (len2 & 1)             crc1 = gf2_matrix_times(odd, crc1);         len2 >>= 1;          /* if no more bits set, then done */     } while (len2 != 0);      /* return combined crc */     crc1 ^= crc2;     return crc1; }  /* ========================================================================= */ uLong ZEXPORT crc32_combine(crc1, crc2, len2)     uLong crc1;     uLong crc2;     z_off_t len2; {     return crc32_combine_(crc1, crc2, len2); }  uLong ZEXPORT crc32_combine64(crc1, crc2, len2)     uLong crc1;     uLong crc2;     z_off64_t len2; {     return crc32_combine_(crc1, crc2, len2); }

谢谢赵4老师！辛苦你了。咱们论坛能不能选择最佳答案呀？

赵4老师，我用devc++软件，C工程，提示找不到zutil.h

赵4老师，这是不是linux的代码呀？太难懂了

我看了，这个看不出来的，是硬件CRC，设置好在之后，自动出数。

你的意思是需要一个工具计算出aDataBuffer 对应的crc值吗可以用http://www.ip33.com/crc.html .

谢谢！你理解错了，我想知道计算的过程。比如单片机使用硬件CRC，上位机使用软件CRC，怎么得出和硬件CRC一样的结果。


Question: 求教，想了很久没明白什么道理

你自己能看见出错信息都需要想很久，那么其他人看不见你的出错信息会需要想更久，成本太高了。


Question: void *形参，传参时候的用法

实参传给形参时类型需要匹配，有几种情况是特例：1.实参类型可以自动转换为形参类型，例如char->int，float-double.2.形参的权限比实参的权限小，如char*->const char*.100字面量是int，传参时不会自动转换为指针类型，所以需要强制转换

调用函数时使用的实参表达式的值的类型必须与形参类型一致，或者能够自动转换为形参类型，或者强制转换为形参类型。


Question: 流水灯怎么中断循环执行下个语句

在最后main函数里的死循环里，建议改成四个判断，不要再嵌入while while(1)     {         keynum=key();         if(keynum == 1){           led1(); } else if(keynum == 2 ){    led2(); }     }   类似这样

你点灯的函数中也嵌入了一个死循环while(1)


Question: 进程recv卡住，怎么办？

"recv卡住": 你的socket fd是设置成非阻塞了吗？如果是非阻塞的，recv的返回值有正确处理吗？（比如特殊判断EAGAIN）还有看你描述用的是UDP，UDP本身就是不可靠的，假如某个UDP包丢了，那么对方就收不到了，项目里有针对UDP做可靠性的开发吗

我这不是“某个UDP包丢了”，"recv卡住"是recv长时间卡住

你没把socket fd设置成非阻塞吧？

fd默认是阻塞的，如果调用recv，但此时缓冲区没有内容就会卡住

对方不send了，或网络临时断开或拥塞了，同步recv当然也就卡住了。


Question: getchar相关的，清除缓存不懂

printf一个不以\n结尾的字符串，要想确保字符串真正显示出来，别缓存在标准输出缓冲区中，需要紧跟一句fflush(stdout);rewind(stdin);//这才是C清标准输入缓存的正确方式cin.clear();cin.sync();//这才是C++清标准输入缓存的正确方式

输入密码参考下面： #include <conio.h> #include <stdio.h> char pw[40]; int i,ch; FILE *f; void main() {     cprintf("\r\nPassword:");     i=0;pw[i]=0;     while (1) {         ch=getch();         if (ch==13 || i>=39) break;         switch (ch) {         case 27:             cprintf("\rPassword: %40s"," ");             cprintf("\rPassword: ");             i=0;pw[i]=0;             break;         case 8:             if (i>0) {                 i--;                 pw[i]=0;                 cprintf("\b \b");             }             break;         default:             pw[i]=ch;             i++;             pw[i]=0;             cprintf("*");             break;         }     }     cprintf("\r\n");     f=fopen("password.txt","w");     fprintf(f,"%s\n",pw);     fclose(f); }


Question: devc++源代码未编译

手工确认一下有没有生成exe文件。

生成了

既然生成了那就执行它呗。


Question: 大佬们帮我看看代码，C++代码返回值3221226356，谢谢了

这个返回值 3221226356 在 Windows 平台上通常是由于程序发生了访问非法内存的错误，也就是所谓的“段错误”（Segmentation Fault）。 经过查看代码，可能存在以下问题： 在函数 List_HeadInsert 中，你已经为头结点 L 分配了空间，却又在循环内部重新分配结点空间并且没有释放。这会导致内存泄漏和无法预料的错误。建议将头结点初始化放到 InitList 函数中。 在函数 display 中，当 L 为空链表时，循环内部会出现对 NULL 指针的访问，这也会导致非法访问内存的问题。可以添加判断语句来避免这种情况。 在输入数据时，没有判断是否已经读入完毕，如果输入完最后一个结点后没有及时退出，会进入死循环，导致程序崩溃。  根据以上问题，下面给出修改后的代码： #include <iostream> #include <cstring>  using namespace std;  typedef int ElemType; typedef struct LNode {     ElemType sn;     ElemType sc;     string name;     struct LNode *next; } *LinkList, LNode;  void InitList(LinkList &L); LinkList List_HeadInsert(LinkList &L); void InsertLink(LinkList &L1, LinkList &L2); void display(LinkList L);  int main() {     LinkList L1;     InitList(L1);     List_HeadInsert(L1);     display(L1);     return 0; // 程序结束 }  void InitList(LinkList &L) {     L = (LNode *)malloc(sizeof(LNode));     L->next = NULL; }  LinkList List_HeadInsert(LinkList &L) {     ElemType tsn, tsc;     string tname;     LNode *s, *r = L;     while (cin >> tsn >> tname >> tsc) { // 添加输入判断条件，如果输入完毕就退出循环         s = (LinkList)malloc(sizeof(LNode));         s->name = tname;         s->sc = tsc;         s->sn = tsn;         r->next = s;         r = s;     }     r->next = NULL;     return L; }  void InsertLink(LinkList &L1, LinkList &L2) {     L2->next = L1->next;     L1->next = L2; }  void display(LinkList L) {     if (L == NULL || L->next == NULL) { // 当链表为空或只有头结点时退出函数         return;     }     for (LNode *p = L->next; p != NULL; p = p->next)         cout << p->sn << " " << p->name << " " << p->sc << endl;     cout << endl; }  希望这些修改能够帮助你解决问题。

数据结构对单链表进行数据排序  http://bbs.csdn.net/topics/392201633


应该改为scanf_s("%s"，&name，sizeof（name）)；第二个参数要加上&，第三个参数是长度。

name前面加&

输入姓名那里：scanf_s("%s", name); 修改为：scanf_s("%s", name, 40);

scanf_s() 的参数不对吧，看看帮助，好像对字符和字符串类参数，要有可许空间大小参数的。


Question: 二叉树建立，遍历，叶子节点数，层数

仅供参考： #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: 稀疏矩阵；找不到这个矩阵相加哪里错了，怎么改啊？

在稀疏矩阵相加的函数 add() 中，判断 A 和 B 矩阵当前位置非零元素相加后是否为 0 的语句有误。应该是： if (sum != 0) {    D.data[D.terms].i = A.data[apos].i;    D.data[D.terms].j = A.data[apos].j;    D.data[D.terms++].v = sum; }  即如果相加后不为 0，才将结果添加到 D 矩阵中。 完整的修改代码如下： #include<stdio.h> #include<stdlib.h>   #define SMAX 100 //三元组非零元素的最大个数  struct SPNode //三元组非零元素的行、列和值 {     int i,j,v; };  typedef struct sparmatrix //定义稀疏矩阵(三元组顺序表类型) {     int rows,cols,terms;//稀疏矩阵的行、列和非零元素的个数      struct SPNode data[SMAX]; //三元组表  } sparmatrix;   sparmatrix CreateSparmatrix()//创建稀疏矩阵 {     sparmatrix A;     printf("请输入列表的行数 列数 非零元的个数 \n");     scanf("%d%d%d", &A.rows, &A.cols, &A.terms);     for (int n = 1; n <= A.terms; n++)     {         printf("请依次输入元素行数 列数 值\n");         scanf("%d%d%d", &A.data[n].i, &A.data[n].j, &A.data[n].v);     }     return A; }   sparmatrix Trans(sparmatrix  A)//转置稀疏矩阵  {     sparmatrix C;     C.rows = A.cols;     C.cols = A.rows;     C.terms = A.terms;     for (int n = 1; n <= A.terms; n++)     {         C.data[n].i = A.data[n].j;         C.data[n].j = A.data[n].i;         C.data[n].v = A.data[n].v;     }     return C; }  void ShowSparmatrixA(sparmatrix A)  //显示稀疏矩阵A   {          printf("矩阵A的元素为：\n");     int k,x,y,n;     for(x = 1; x <= A.rows; x++)     {         for(y = 1; y <= A.cols; y++)         {             k = 0;             for(n = 1; n <= A.terms; n++)             {                 if ((A.data[n].i == x) && (A.data[n].j == y))                 {                     printf("%5d", A.data[n].v);                     k = 1;                     break;                 }             }             if (k == 0)              {                 printf("%5d", 0);             }         }         printf("\n");     } }  void ShowSparmatrixB(sparmatrix B)  //显示稀疏矩阵B   {          printf("矩阵B的元素为：\n");     int k,x,y,n;     for(x = 1; x <= B.rows; x++)     {         for(y = 1; y <= B.cols; y++)         {                k = 0;             for(n = 1; n <= B.terms; n++)             {                 if ((B.data[n].i == x) && (B.data[n].j == y))                 {                     printf("%5d", B.data[n].v);                     k = 1;                     break;                 }             }             if (k == 0)              {                 printf("%5d", 0);             }         }         printf("\n");     } }  sparmatrix add(sparmatrix A, sparmatrix B) {        sparmatrix D;      // 初始化结果矩阵 D 的行、列和非零元素个数     D.rows = A.rows;     D.cols = A.cols;     D.terms = 0;

数组下标这玩意，您有时是从0开始用的，有时是从1开始用的，不乱才怪。


Question: make时出现错误，怎么解决呢

没声明出错了那就声明一下呗。


Question: 以单词为单位倒序输出

数组要初始化为空。


Question: 求助一下这个报错该怎么解决

明显不就是提示花括号不匹配吗？花括号一对一对的。

一看这个报错就是说少了}


Question: 求 矩阵LUP分解 为什么直接赋值，得到结果正确，语句计算赋值，得到结果错误，请帮看下为什么

tmp_matrix_d[ik] = sum;你这里的 sum是float，计算结果已经损失精度了

REAL  原始是double，我这里也更改成double过，一样是不正确的结果，很诧异的是这个东西就是损失精度，得到结果是颠覆的。

换个编译器试试，或者关闭优化选项试试

应该是如 user-2所说，基本是tmp_matrix_d 计算得到输出和tmp_a有细小的差别， 矩阵求逆 就出现颠覆性的值

tmp_matrix_d 是怎么计算来的吧，这意味着由于浮点的表示限制，和 tmp_a 还是有误差的。将提及的那个贴里的 matrix.c 中 solve_matrix_equation_by_lup_decomposition() 每一步都对涉及到刚才变化了的 matrix 进行输出，对比了两个的结果，发现，好像是有细微的误差慢慢累积起来的，很是奇怪，怎么最后会有如此的大不同。

就这个问题，你也没找到为什么是吧，直接赋值就OK，计算得到就出现很大的偏差

好像就是这样的，在“数字帝国”站上，用它的矩阵求逆功能，从你的数据里取了前 4x4 如： 15.27 15.48 13.79 10.44 15.48 17.42 17.09 14.54 13.79 17.09 18.17 16.83 10.44 14.54 16.83 16.95 求逆的结果： 12.063130	-29.127886	24.652281	-6.921387 -29.127886	78.401900	-74.196654	24.357593 24.652281	-74.196654	77.738316	-28.724857 -6.921387	24.357593	-28.724857	11.949217 将最右下的数据由 16.95 改为 16.96，再算，结果是： 11.635207	-27.62195	22.876335	-6.182613 -27.62195	73.102244	-67.946782	21.757716 22.876335	-67.946782	70.367855	-25.658828 -6.182613	21.757716	-25.658828	10.673783 两次的结果差异甚大；所以，细微的误差，可能会引发巨震。

看来就是数据的细小差异导致的，


Question: 我在写计时器用system("cls")清屏但是它跳过了

#define _CRT_SECURE_NO_WARNIGS #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<math.h> #include<string.h> #include<time.h> #include<Windows.h> int main() {     for (int  i = 0; i < 24; i++)     {         for (int j = 0; j < 60; j++)         {             for (int k = 0; k < 60; k++)             {                 cprintf("\r%02d:%02d:%02d", i, j, k);                 Sleep (950);                          }         }     }     return  EXIT_SUCCESS; }

win7 x64 + vc2008 好像是执行了的；其实，无须这个调用，输出的把 \n 改为 \r 试试。


Question: 请问高手指针做参数的问题

指针作参数要传递什么取决于参数本身存在的意义，即 “这个参数是什么？以及它要用来干什么？”函数调用时，系统为函数分配栈区内存，函数的返回值、参数、局部变量、临时变量等都会在函数的栈内存中占据一席之地。普通变量传参的时候，是把实参的数据拷贝了一份到函数参数的所在栈内存中。指针变量传参的时候，也是把一个地址作为数据拷贝到了函数参数所在的栈内存中，不同之处在于，指针支持( * 解引用 )、( -> 结构体/联合体的成员访问)、( [ ] 数组下标访问 )等操作，可以通过传入的目标内存地址去访问以及读写目标内存的数据。当然上述这些操作的前提是传入的地址是有效的，即地址指向的确实是一个已存在的内存实例，或者说内存里确实已经有了这么个东西。传入的内容可以是一个局部变量的地址，也可以是一个已经malloc分配过得堆内存地址。 SPI_HandleTypeDef hspi; memset(&hspi, 0, sizeof(SPI_HandleTypeDef)); uint6_t buf[1024] = { 0 }; HAL_StatusTypeDef status = HAL_SPI_Receive(&hspi, buf, sizeof(buf), 100); //----------------------------------------------------- SPI_HandleTypeDef *hspi = (SPI_HandleTypeDef *)malloc(sizeof(SPI_HandleTypeDef)); memset(&hspi, 0, sizeof(SPI_HandleTypeDef)); uint8_t *buf = (uint8_t *)malloc(sizeof(uint8_t) * 1024); memset(buf, 0, sizeof(uint8_t) * 1024); HAL_StatusTypeDef status = HAL_SPI_Receive(hspi, buf, sizeof(uint8_t) * 1024, 100); // ... free(hspi); free(buf);

谢谢！

SPI_HandleTypeDef *hspi; uint8_t buf[1024];  HAL_StatusTypeDef rtn=HAL_SPI_Receive(hspi, buf,1024, 100);

谢谢赵4老师

谢谢！我试试。

习惯上定义一个够大的数组作为接收缓冲区即可，把数组名当作实参传给它即可。


Question: C 语言问题   输入n行ASCII字符，计算每一行字符的个数（不包括换行符），并找出最大的字符

以下是一个用C语言实现的程序，可以计算输入的n行ASCII字符中每一行字符的个数，并找出最大的字符。 #include <stdio.h>      int main() {       int n, i, max_char, max_count = 0;       char c;          printf("请输入行数n: ");       scanf("%d", &n);          printf("请输入%d行ASCII字符：\n", n);          // 初始化最大字符和行数计数器       max_char = 0;       max_count = 0;          // 逐行读取输入       for (i = 0; i < n; i++) {           scanf(" %c", &c);              // 如果这是第一个字符，则更新最大字符和行数计数器           if (i == 0) {               if (c > max_char) {                   max_char = c;                   max_count = 1;               }           } else {               // 否则，将这一行字符的个数和行数计数器加1               if (c > max_char) {                   max_char = c;                   max_count++;               }           }       }          // 找出最大字符并输出       if (max_count > max_char) {           printf("最大字符为：%c\n", max_char);       } else {           printf("最大字符为：%c\n", max_char);           printf("该行字符的个数为：%d\n", max_count);       }          return 0;   }  这个程序首先提示用户输入行数n，然后逐行读取输入的ASCII字符，并计算每一行字符的个数和行数计数器。当读取到第一个字符时，程序会更新最大字符和行数计数器。最后，程序会找出最大字符并输出该行字符的个数和行数计数器，如果两个计数器中有一个比最大字符还要大，则程序会输出最大字符和行数计数器，但不输出该行字符的个数。 请注意，这个程序假设输入的每一行字符都是合法的ASCII字符，即不包含空格、制表符或换行符。如果输入的字符不合法，程序可能会出现错误。

写个循环n次的循环即可。


Question: 如何直接通过指针引用私有成员数据

cout<< p->get() << "    " << p->n << endl;


Question: 题目合并两个有序数组

没仔细看您的代码，初步判断是函数 fun 中 else 后面的 for 语句缺少了大括号。 下面给出我的合并方法： int merge(int array1[], const int length1, int array2[], const int length2) {     int ind1 = length1 - 1;     int ind2 = length2 - 1;     int indMerged = length1 + length2 - 1;     while (ind1 >= 0 && ind2 >= 0)     {         if (array1[ind1] > array2[ind2])         {             array2[indMerged] = array1[ind1];             --ind1;         }         else         {             array2[indMerged] = array2[ind2];             --ind2;         }         --indMerged;     }     while (ind1 >= 0)     {         array2[indMerged] = array1[ind1];         --indMerged;         --ind1;     }     return length1 + length2; }


Question: c语言作业题，求好心人解惑

5i乘号不能省

还是不行呢


Question: 求助大佬们，c语言学习有什么系统好学的资料吗

C Primer Plus 第六版

推荐先看《啊哈C》，因为我刚看过了。 入门级别的

已买，我也用用入门，谢谢🙏


Question: 关于一些结构体的问题

这个完全不关结构体的事，是基本输入输出不过关。字符变量存不下字符串；接受输入值的变量需要取地址。


Question: linux进程卡死，无法通信

要说最可笑的理由，甚至有可能是写日志的文件系统满了。

根据提供的问题描述，可能的原因有如下几点： 1、网络通信问题：由于U进程无法以sendto方式给日志打印进程吐日志，而且H进程给U进程发sendto消息时也无法得到回复，这可能是由于网络通信发生了问题，导致H和U进程之间无法正常通信。 2、内存泄漏问题：U进程在一段时间后卡死，可能是因为U进程存在内存泄漏问题导致的。当内存泄漏严重时，会导致系统资源被大量占用，从而导致系统出现卡顿或崩溃。 3、死锁问题：由于U进程不再以sendto方式给日志打印进程吐日志，而且H进程重启了U进程，这可能导致了死锁问题。例如，U进程可能在等待某个锁的释放，而H进程又在等待U进程的响应，这样就会形成死锁。 为了排查问题，可以采取如下步骤： 1、检查网络连接是否正常，尝试使用其他工具测试网络连接性。 2、检查U进程的代码，是否存在内存泄漏问题。 3、使用调试工具如gdb分析U进程的状态，看是否处于死锁状态。 4、检查U进程的日志打印代码，看是否存在bug或异常情况。

有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成core或dmp文件、……这些方法都不行！ 写日志到文件参考下面： #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER     #pragma warning(disable:4996)     #include <windows.h>     #include <io.h> #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  _vsnprintf         vsnprintf #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef _MSC_VER void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     _vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} int main(int argc,char * argv[]) {     int i; #ifdef _MSC_VER     InitializeCriticalSection(&cs_log); #else     pthread_mutex_init(&cs_log,NULL); #endif     for (i=0;i<10000;i++) {         Log("This is a Log %04d from FILE:%s LINE:%d\n",i, __FILE__, __LINE__);     } #ifdef _MSC_VER     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_log); #endif     return 0; } //1-79行添加到你带main的.c或.cpp的那个文件的最前面 //82-86行添加到你的main函数开头 //90-94行添加到你的main函数结束前 //在要写LOG的地方仿照第88行的写法写LOG到文件MyLog1.log中

H进程卡死的原因可能是U进程的资源被耗尽，导致无法回复H进程的消息，最终导致H进程等待超时而卡死。 要排查这个问题，可以先查看U进程的日志，看看是否有相关的错误或警告信息。还可以使用系统监控工具，如top、ps等，查看U进程的资源占用情况，例如CPU、内存、网络等。如果发现U进程的资源占用过高，可能需要对其进行优化或调整。另外，可以尝试使用调试工具，如gdb、strace等，来跟踪U进程的执行过程，找出可能的问题点。


Question: 小白求教!!!!各位大神，这个语句哪里有问题

去掉内存while死循环，直接写n+=ret;

内层while是个死循环，在它范围内a的值一直不变。


Question: 求助！！！jupyter在导入包时用的import 、as、from都出现乱码

请问解决了吗？我也是这个问题

我也是一样的情况 为什么啊


Question: [求助]nt!KiApcInterrupt蓝屏原因

这个错误消息通常表明您的驱动程序在处理异常时出现了问题。KMODE_EXCEPTION_NOT_HANDLED是一个常见的错误消息，通常指向引起问题的驱动程序或函数。 在这种情况下，您应该记录异常的地址和包含该地址的驱动程序/库的链接日期。您还应该记录异常的参数，以便在未来的调试和分析中使用。 在这个错误消息中，有一些寄存器的值可能为零或不正确。rax、rbx、rcx、rdx、rsi、rdi、rip、rsp、r8、r9、r10、r11、r12、r13、r14、r15和iopl都是可能的值。请注意，这些值可能会被修改或不正确，因此在分析代码时请务必小心。

ChatGPT?


Question: vs code调试c语言为啥不行，这是咋回事啊，搞了3，4个小时了，求助大佬们

.c文件的的路径中不要带中文字符

VS Code本身并不支持C语言调试，因为它是一个基于JavaScript的编辑器，而不是一个完整的集成开发环境（IDE）。 如果您需要在C语言中进行调试，您需要使用一个集成开发环境（IDE），例如Visual Studio或Eclipse。这些IDE通常都有内置的调试器，可以帮助您在代码中设置断点，并在运行时跟踪变量和函数的值。 如果您使用的是Visual Studio Code，您可以安装一个名为“C/C++ Intellisense”的扩展程序，它可以帮助您在编辑器中显示C/C++代码的语法高亮和自动完成。但是，这并不能完全替代使用IDE进行调试

用run code运行是可以的，但就是调试不了，直接运行也不行


Question: c语言统计代码行数，注释行数，空行数，文件总行数

这作业挺有意思，我折腾了几天，写好又重写，写好又重写......。勉强捣鼓出一个。还特地做了一份测试用的c文件，也贴在后面。当作业交的话应该能合格。 #include <stdio.h> #include <cstdlib> #include <fstream>  /** * 统计c源程序总行数、空行数、代码行数、注释行数。根据当前行 * 中是否包含//、/*和* /来判断是否是注释行，但要忽略注释和 * 字符串常量和字符常量中的这些符号。 * * （2023-4-21. Mr Yao） */  /* * 读取当前字符，且忽略所有非换行空白符。 */ inline int get_cur_char(FILE* fp, int* ch) {     while ((*ch = getc(fp)) && *ch != EOF && *ch != '\n' && isspace(*ch));      if (*ch != EOF) return 1;     else return 0; }  /* * 读取当前字符，包括空白符。 */ inline int get_cur_char_space(FILE* fp, int* ch) {     *ch = getc(fp);     if (*ch != EOF) return 1;     else return 0; }  int main(int argc, char* argv[]) {     FILE* fp = 0;     char filename[100];      /**     * DEFAULT 默认状态。     * STRING 字符串常量状态。     * CHAR 字符常量状态。     * BLOCKCOMMENT 块注释状态。     * LINECOMMENT 行注释状态。     */     enum State { DEFAULT = 0, STRING, CHAR, BLOCKCOMMENT, LINECOMMENT };      State cur_state = DEFAULT;    //当前状态。     /**     * total_lines--总行数，comment_lines--注释行数，blank_lines--空行数，code_lines--代码行数     */     int total_lines = 0, comment_lines = 0, blank_lines = 0, code_lines = 0;     /**     * is_comment_line--标记当前行是否是含有注释，is_code_line--标记当前行是否含有代码，     * is_blank_line--标记当前行是空行     */     int is_comment_line = 0, is_blank_line = 0, is_code_line = 0;      int cur_char = DEFAULT;    //当前待分析字符。      if(argc > 1)         fopen_s(&fp, argv[1], "r");      while (fp == 0) {         printf("Failed to open file.\n");         printf("Please input file name:");         scanf_s("%s", filename, 100);         fopen_s(&fp, filename, "r");     }      while (get_cur_char(fp, &cur_char)) {         //开始新行。         is_comment_line = 0; is_code_line = 0; is_blank_line = 0;         if (cur_char == '\n') is_blank_line = 1; //空行         else {             do {                 switch (cur_char)                 {                 case '\n':        //换行则关闭行注释状态                     if (cur_state == LINECOMMENT)                         cur_state = DEFAULT;                     break;                 case '\\':        //忽略转义字符                     if (cur_state != BLOCKCOMMENT) {                         get_cur_char_space(fp, &cur_char);                         if (cur_char == '\n') {                             if(cur_state != LINECOMMENT)is_code_line = 1;                             else is_comment_line = 1;                         }                     }                     break;                 case '/':        //在默认状态下，判断下一个字符                     if (cur_state == DEFAULT) {                         if (get_cur_char_space(fp, &cur_char) && cur_char == '*') {                             //找到块注释，标记该行为注释行，转换成块注释状态                             is_comment_line = 1;                             cur_state = BLOCKCOMMENT;                             break;                         }                         else if (cur_char == '/') {                             //找到行注释，标记该行是注释行，转换成行注释状态                             is_comment_line = 1;                             cur_state = LINECOMMENT;                             break;                         }                         is_code_line = 1;                     }                     break;                 case '*':    //在块注释状态下，找* /                     if (cur_state == BLOCKCOMMENT) {                         is_comment_line = 1;                         while (cur_char == '*') {                             get_cur_char_space(fp, &cur_char);                         }                         if (cur_char == '/') {                             //找到，转换成默认状态                             cur_state = DEFAULT;                         }                     }                     break;                 case '"':    //默认状态下，转换成字符串状态，字符串状态下转换成默认状态                     if (cur_state == DEFAULT || cur_state == STRING) {                         cur_state = (State)((int)cur_state ^ (int)STRING);                         is_code_line = 1;                     }                     break;                 case '\'':    //默认状态下，转换成字符状态，字符状态下转换成默认状态                     if (cur_state == DEFAULT || cur_state == CHAR) {                         cur_state = (State)((int)cur_state ^ (int)CHAR);                         is_code_line = 1;                     }                     break;                 default:                     if (cur_state == DEFAULT) is_code_line = 1;                     else if (cur_state == BLOCKCOMMENT || cur_state == LINECOMMENT)                         is_comment_line = 1;                     break;                 }             } while (cur_char != '\n' && get_cur_char(fp, &cur_char));         }                  /*         * 当前行分析结束，累加数据。         */         ++total_lines;         comment_lines += is_comment_line;         blank_lines += is_blank_line;         code_lines += is_code_line;     }      printf("Total lines: %d\n", total_lines);     printf("Code lines: %d\n", code_lines);     printf("Comment lines: %d\n", comment_lines);     printf("Blank lines: %d\n", blank_lines);      fclose(fp);     return 0; }   测试文件：test.c /**  *  * 这是一份没有语法错误的c源程序，共有28行，代码11行，注释15行，空行6行  *  * （2023-4-21. Mr Yao） **/   #include <stdio.h>  int main(int, char**) { //这行有代码和注释     //\ 本行只有注释， /* " ' 下面2行只有代码。     char a[] = "\     // */ /* abcd";          /*本行只有注释\*/         //本行只有注释      char f[] = "// \""; //本行既有代码也有注释         /**本行有代码和注释。// *\*/char b = '\"';//本行有代码和注释\     \     /**上一行只有注释，本行也只有注释\      * 本行只有注释*/int a = 1;       /*本行既有注释也有代码*/char c[] = "\     \     \\\\\\\\""//上一行只有代码，本行也只有代码";     return 0; }

非常感谢

#include <stdio.h>      int main() {       FILE *fp;       char filename[100];       int total_lines = 0, comment_lines = 0, blank_lines = 0;          printf("Enter the filename: ");       scanf("%s", filename);          fp = fopen(filename, "r");          if (fp == NULL) {           printf("Failed to open file.\n");           return 1;       }          while (fgets(filename, sizeof(filename), fp)) {           if (filename[0] == '#') {               comment_lines++;           } else if (filename[0] == '\n') {               blank_lines++;           } else {               total_lines++;           }       }          fclose(fp);          printf("Total lines: %d\n", total_lines);       printf("Comment lines: %d\n", comment_lines);       printf("Blank lines: %d\n", blank_lines);          return 0;   }

谢谢啦


Question: 用递归正序逆序输出整数的各位数字

if(n) { f1(n/10); cout<<n%10<<"  "; }  ... if(n){cout<<n%10<<"  "; f2(n/10);}


Question: 帮帮忙看看一下兄弟们

百度搜“正则表达式 邮件地址”


Question: cpu烧了，有没有大神帮我看看

小伙子有前途，不要写代码了，转行去网站当小编～


Question: 用C语言做简易公交车查询系统

以下是一个简单的C语言实现公交车查询系统的示例代码： #include <stdio.h>   #include <string.h>      #define MAX_LINES 100   #define MAX_LINE_LEN 3      typedef struct {       char line[MAX_LINE_LEN];   } Line;      int compare_lines(const void *a, const void *b) {       Line *l = (Line*) a;       Line *r = (Line*) b;       return l->line[0] - r->line[0];   }      int main() {       Line lines[MAX_LINES];       int num_lines = 0;          // 添加公交车路线记录       strcpy(lines[num_lines].line, "N10");       num_lines++;       strcpy(lines[num_lines].line, "北京市");       num_lines++;       strcpy(lines[num_lines].line, "1号线");       num_lines++;       strcpy(lines[num_lines].line, "天安门");       num_lines++;       strcpy(lines[num_lines].line, "5号线");       num_lines++;       strcpy(lines[num_lines].line, "国家博物馆");       num_lines++;          // 显示所有公交车信息       printf("\n公交车信息如下：\n");       for (int i = 0; i < num_lines; i++) {           printf("%s\n", lines[i].line);       }          // 修改公交车路线信息       strcpy(lines[2].line, "N10");       num_lines--;       strcpy(lines[2].line, "北京市");          // 显示所有公交车信息       printf("\n修改后的公交车信息如下：\n");       for (int i = 0; i < num_lines; i++) {           printf("%s\n", lines[i].line);       }          // 删除公交车路线记录       strcpy(lines[1].line, "N10");       num_lines--;       num\n");           return 1;       }          strcpy(fp->ptr, "\n公交车信息如下：\n");       for (int i = 0; i < num_lines; i++) {           strcpy(fp->ptr + strlen(fp->ptr), lines[i].line);       }          fclose(fp);          return 0;   }  这个示例代码实现了一个简单的公交车查询系统，包括添加、显示、修改、删除和保存公交车路线信息等功能。你可以根据自己的需求进行修改和扩展。


Question: 求大佬解惑，c语言作业题

很遗憾，one function one x 。你的代码里只有一个变量x，你把它浪费了x=x/10之后，回过头去x<=y意义就不大了，x++就没意思了。

🔗ChatGPT、AI绘图在线体验🔗Admin、Vue、Vite、Node、Midway、uniapp、Iot、外包、小程序🔗Cool-Admin、快速开发、CRUD、权限管理系统

if (n==3)


Question: 求回答     C语言中输入%s 最后的输出结果出现乱码

printf里面的%和变量的一一对应关系scanf里面的%和变量以及变量前加不加&的一一对应关系是C代码中非常容易出错的地方，而且通常编译还不出错。所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

那里应该是%c而不是%s

%c的话  就该设清除缓冲区


Question: 求助（数据结构）:为什么这个“取出函数运行不了，怎么改啊？”

不保证对，仅供参考： #include<stdio.h> #define MAXLEN 100 typedef struct {     char vec[MAXLEN];     int len; } str;//定义结构体类型 str void ConcatStr(str *r1,str *r2)//连接串r1和r2放到串r1中 {     int i=0;     if(r1->len+r2->len>MAXLEN)         printf("两个串太长，无法连接!");     else     {         for(i=0;i<r2->len;i++)             r1->vec[r1->len+i]=r2->vec[i];         r1->vec[r1->len+i]='\0';         r1->len=r1->len+r2->len;     } } void SubStr(str *r,str **pr1,int i,int j)//从第i个位置 ，取j个位置 {     int k=0;     if(i+j-1>r->len)     {         printf("子串超界!");         return ;     }     else     {         for(k=0;k<j;k++)             (*pr1)->vec[k]=r->vec[i+k-1];         (*pr1)->len=j;         (*pr1)->vec[(*pr1)->len]='\0';     }     printf("取出字符为:");     puts((*pr1)->vec); } void DelStr(str *r,int i,int j)//从字符串r的第i个位置开始删除j个字符 {     int k=0;     if(i<1||i>r->len||j<1||i+j-1>r->len)         printf("位置参数数据错误或所要删除的子串超界!");     else     {         for(k=i+j-1;k<r->len;k++,i++)             r->vec[i-1]=r->vec[k];  //将后面的字符串前移覆盖         r->len=r->len-j;         r->vec[r->len]='\0';     } } str *InsStr(str*r,str*r1,int i)//在i个位置插入串r1 {     int k;     if(i<0||i>r->len+1||r->len+r1->len>MAXLEN)         printf("不能插入!");     else     {         for(k=r->len-1;k>=i-1;k--)             r->vec[r1->len+k]=r->vec[k];//后移，空出r1->len个位置         for(k=0;k<r1->len;k++)             r->vec[i-1+k]=r1->vec[k];         r->len=r->len+r1->len;         r->vec[r->len]='\0';     }     return r; } int IndexStr(str *r,str *r1)//模式匹配 {     int i,j,k;     for(i=0;r->vec[i];i++)         for(j=i,k=0;r->vec[j]==r1->vec[k];j++,k++)             if(!r1->vec[k+1])                 return i;     return 0; } int LenStr(str *r)//求串长 {     int i=0;     while(r->vec[i]!='\0')         i++;     return i; } str*CreateStr(str *r)//创建串 {     gets(r->vec);     r->len=LenStr(r);     return r; } int EqualStr(str *r1,str *r2)//串比较 {     int i;     for(i=0;r1->vec[i]==r2->vec[i]&&r1->vec[i]&&r2->vec[i];)         i++;     return(r1->vec[i]-r2->vec[i]); } int main() {     str a,b,c,d;     str *r=&a,*r1;     char choice;     int i,j,ch=1,k;     r->vec[0]='\0';     printf("\n");     printf("     串子系统\n");     printf("        1--输入字串\n");     printf("        2--连接字串\n");     printf("        3--取出字串\n");     printf("        4--删除字串\n");     printf("        5--插入字串\n");     printf("        6--查找字串\n");     printf("        7--比较字串\n");     printf("        8--显示字串\n");     printf("        0--返回\n");     while(ch!=0)     {         printf("请选择菜单号(0-8):");fflush(stdout);         rewind(stdin);scanf("%c",&choice);         switch(choice)         {         case '1':             printf("\n请输入一个字符串:");fflush(stdout);             gets(r->vec);             r->len=LenStr(r);             break;         case '2':             {                 printf("\n请输入要连接的串:");fflush(stdout);                 r1=CreateStr(&b);  //给串r1赋初值                 ConcatStr(r,r1);                 printf("\n连接以后的新串值为:");                 puts(r->vec);                 break;             }         case '3':             printf("\n请输入从第几个字符开始:");fflush(stdout);             rewind(stdin);scanf("%d",&i);             printf("\n请输入取出的连接字符数:");fflush(stdout);             rewind(stdin);scanf("%d",&j);             SubStr(r,&r1,i,j);             break;         case '4':             printf("\n请输入从第几个字符开始:  ");fflush(stdout);             rewind(stdin);scanf("%d",&i);             printf("\n请输入删除的连续字符数:");fflush(stdout);             rewind(stdin);scanf("%d",&j);             DelStr(r,i ,j);             break;         case '5':             {                 printf("\n请输入在第几个字符前插入:");fflush(stdout);                 rewind(stdin);scanf("%d",&i);                 printf("\n请输入所要插入的字符串:");                 r1=CreateStr(&b);                 InsStr(r,r1,i);                 break;             }         case '6':             {                 printf("\n请输入所要查找的字符串:");fflush(stdout);                 r1=CreateStr(&b);                 i=IndexStr(r,r1);                 if(i!=-1)                     printf("\n第一次出现的位置是第%d个\n",i);                 else                     printf("\n该字串不在其中\n");                 break;             }         case '7':             {                 printf("\n请输入第一个串:");fflush(stdout);                 gets(c.vec);                 printf("\n请输入第二个串:");fflush(stdout);                 gets(d.vec);                 k=EqualStr(&c,&d);                 if(k>0)                     printf("\n\t\t第一个串大!");                 else                     if(k<0)                         printf("\n\t\t第二个串大!");                     else                         printf("\n\t\t两个串一样大!");                 break;             }         case '8':             {                 printf("\n\t\t该串值为:");                 if(r->vec[0]=='0')                     printf("空!\n");                 else                     puts(r->vec);                 break;             }         case '0':             ch=0;break;         default:             printf("输入菜单有误，请重新输入!");break;         }     }     return 0; }


Question: 程序可以编译成功就是运行后显示Press any key to continue,一按回车就直接退出来

现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！scanf的格式字符串中不要包含空格和\n

您说的应该是以前码农做的操作，我没有学过计算机操作系统和lunix只知道一些简单的dos命令，用cmd窗口运行代码就见过郝斌的视频操作过，C语言具体怎么做真不知道


Question: 关于vscode，C++问题

text.c这个名字暗示着里面是C语言代码，所以C++不好使。你可以查一下该环境下应该使用的扩展名。

配置了还是不行，文件名字后缀也换成c++了

text.cpp


Question: 想知道主函数里输入的参数怎么用到自定义的以二维数组作参数的函数中二维数组的维度啊（截图里的程序是错误的，下边是高清版）

了解一下OpenCV中的Mat

语法性的错误太多。但是就标题提出的问题而言，简单地说，在相当多版本的C编译器下，根本不支持动态尺寸的数组。所以你首先要确定你的编译器支持，然后再说怎么写，以及修正其他错误。


Question:
C语言新手入门，老师写的这个代码输出是2，3，4，5，6，7，8，9，10，11
我的输出什么都没有，哪位大佬找下原因

题主的问题在于while循环那块，下面给上代码： #include<stdio.h>void test(){    static int a=1;    a++;    printf("%d",a);}int main(){    int i=0;    while(i<10)//题主这里加了分号，陷入while死循环且没有输出    {        test();            i++;    }    return 0;} 运行结果为：234567891011

感谢！！

放到while外面也不行

return 0放外面 删了分号

return 0放在while循环里面了

关键原因是while行末有个多余的分号，这个分号篡夺了循环体的地位，构成了死循环。

把return 0；放while外，return 0；会结束while的操作

把 return 0; 放到while外面

放到while外面了还是不行，也不报错就是无输出


Question: C语言外卖订餐管理系统求助：折扣数据无法读入

在scanf系列函数里，我是说包括fscanf对应double类型的变量的格式符需要使用%lf而不是%f

您是认真的么？编译能成功的话，起码得有含有错误的运行截图吧？还有无法读入的数据文件，你得确认它存在，位置正确，名字正确，权限正确，内容正确呀。


Question: 求键盘输入的一组数据的极值和均值

你不妨想一想为什么你输出的最小值是正确的，在和要求的最大值对比一下

感谢啊，找到问题了。能再问一下为什么这个题目里引用函数一定要用到指针啊。

你不妨琢磨一下，为什么scanf引用变量要用指针（取地址），而printf一般不用。

我这学期刚学，没有接触过scanf和printf。


Question: linux纯C下，调用excel或system函数启动外部程序，全路径中名含中文则会卡死（使用Qt 5.14.2环境编译)

已解决。PCB利用好就OK

我在ubuntu,fedora下测试都是如此，哎，基础知识不过关啊


Question: 为什么我的数码管一直闪啊？

那玩意是显示部件，你得保证它每秒刷新25次以上，才能看不出来闪。我的意思是说，它实际上就应该一直闪，只不过弄好了就看不出来而已。


Question: 求解！C语言基础问题

OK了搞定

在 C 语言中，可以使用scanf函数读取用户输入的数字，并通过判断来限制其大小。以下是一些实现方式： 使用循环和条件语句 int num;printf("请输入一个小于100的整数：");while (scanf("%d", &num) == 1 && num >= 100) {    printf("输入错误，请重新输入：");    while (getchar() != '\n') ; //清空输入缓冲区}printf("您输入的数字是：%d\n", num);

这个有问题

你判断一下不就好了嘛，设置一个最大值和最小值。不在范围内你返回重新输入

输入不在限定范围内，提示并重新输入


Question: 地址总线和数据总线问题

具体问题具体分析。理论上每个系统都可以有不同的设计。


Question: 请问怎么把这个数值转化成 十六进制显示

数字不对吧~

电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址；人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……

union hex_value{    char buf[8];    long long value;};  union hex_value fv_hex; fv_hex.value = amplitude_balue;        tx_Setbuffer[0] = fv_hex.buf[0];        tx_Setbuffer[1] = fv_hex.buf[1];        tx_Setbuffer[2] = fv_hex.buf[2];        tx_Setbuffer[3] = fv_hex.buf[3];        tx_Setbuffer[4] = fv_hex.buf[4];        tx_Setbuffer[5] = fv_hex.buf[5];        tx_Setbuffer[6] = fv_hex.buf[6];        tx_Setbuffer[7] = fv_hex.buf[7]; 是可以的，当时写的是short  ，范围小了，导致是00


Question: 求大佬解决 为啥其所占字节大小不随参数改变而改变

sizeof是编译期运算；不是运行时运算。

因为形参数组名的实质是一个指向首元素的指针。

哦哦哦  谢谢


Question: 求助：vscode 开发stm32 时出现“unknown type name”的问题

找不到HAL_StatusTypeDef的定义https://www.baidu.com/s?wd=HAL_StatusTypeDef


Question: C语言小白，设计了一个“输入一个整型数据，判断其是奇数还是偶数”的C语言程序，但输入除了0之外的数结果都是奇数，我自己找不出来哪里出了问题，有没有大佬帮我看一下程序哪里出错了

有什么特殊环境限制吗，C语言的求模运算是编译器自带的，不依赖库的，因该可以直接用求模看余数是否为0来判断啊。你是用加减2趋近0来判断奇数偶数，那你的两个do while 的判断正负的条件弄反了。

你这个算法，有些费事。while() 里的判断条件不对吧，m>0 时，应该是 while(m>0) 吧，否则也不能循环了；下面的 while() 类似。