Datasets:

Mxode

/

CSDN-Community-C-Language-3years

like 2

[ { "cid": "1", "user": "user-0", "content": "@赵4老师谢谢老师。我打了断点，下图是反汇编模式下看到的调用情况： 当执行这一行指令时可以看到，下方打印出这个地址的值是正确的，然后单步执行到下一行，如下图： 这个地址的第一个字符被修改成了\\000，后面的字符没有变化，这是什么原因呢？", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "仅供参考： #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; }", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢老师，但是我没看懂是什么意思。", "referer": "user-1" }, { "cid": "4", "user": "user-1", "content": "意思就是当你发现某个变量的值莫名其妙不知道被哪里的代码改变了的时候，在这个变量所在地址设置数据断点，再重新开始调试运行，一旦值被改，就会停在修改值的C语句或汇编指令处，此时可以按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "补充hashmap和list的数据结构", "referer": "user-0" } ]

[ { "cid": "2", "user": "user-2", "content": "你没发现两个逗号长得不一样吗？", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "嗯嗯 刚刚发现了 是自己手残、", "referer": "user-2" } ]

[ { "cid": "2", "user": "user-2", "content": "栈中的变量通常包括函数参数和函数里声明的临时变量。栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。而栈中的类变量退出其作用域时，会自动执行其析构函数，……所谓在栈中“申请”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中运行。（一般人我不告诉他！）", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "感谢老师", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "90<=a && a<=100", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "if条件都错了……2个条件是不是应该用a<=100&&a>=90来表达", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "打印一下看数字位数，你就明白了", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "int number=... 这是个整数，若到了个位数，再 /10 结果就是 0 了", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "严格的说是你括号的位置不对while (ch = (getc(fp)) != EOF)改为while ((ch = getc(fp)) != EOF) {", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "少写了括号，优先级问题while (ch = (getc(fp)) != EOF)改为while ((ch = (getc(fp))) != EOF)", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "不是中文，是全英文写的hello world", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "@CSDN-Ada助手 putc输出方框乱码是什么原因？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "换VS2022（安装时注意勾选C++桌面开发，默认不勾选）", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "可能出现了卡顿情况,电脑刷新一下再试试,如果还不行，就把代码复制到一个新的界面,重新编译运行,如果还不行，就是电脑或者devc++的问题了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "@CSDN-Ada助手 \"scanf: This function or variable may be unsafe, Consider using scanf_s\" 请写代码对比scanf和scanf_s用法，C4996警告应该怎样解决。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-1" }, { "cid": "4", "user": "user-0", "content": "谢谢啦", "referer": "user-x" }, { "cid": "5", "user": "user-3", "content": "在源代码最上方加上#pragma warning(disable:4996)或者#define _CRT_SECURE_NO_WARNINGS 1都可以。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "谢谢，辛苦了", "referer": "user-3" } ]

[ { "cid": "2", "user": "user-2", "content": "调试可以解决百分之九十的问题", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "可以单步跟踪看看问题出现在哪里", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "例如我现在正在说的这句话，语法是正确的，然而是废话，不产生输出。", "referer": "user-0" }, { "cid": "5", "user": "user-5", "content": "你真是人才", "referer": "user-4" } ]

[ { "cid": "1", "user": "user-1", "content": "仅供参考： #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", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "每周只上一天班？这保安也太舒服～", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "lz排出的是轮休表，不是值日表。。。", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "在每个最后不带\\n的printf后面加fflush(stdout);在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin);另外请检查scanf的返回值。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "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);", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "感谢您的回复，但内容与问题无关", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "在析构函数中，线程pool在等待所有子线程退出时一直持有taskQueMtx_的锁，这会导致在子线程尝试获取任务时无法获取到锁，从而导致互锁的情况。为了避免这种情况，可以使用线程安全的等待所有子线程退出的方式，例如使用std:🧵:join_all()函数等待所有子线程退出。这样可以避免在等待过程中一直持有锁的情况，从而避免互锁问题。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢回复 我理解也是会卡住 关键这段代码一直在生产环境使用 从没有卡过。。。", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "谢谢回复 我理解也是会卡住 关键这段代码一直在生产环境使用 从没有卡过。。。", "referer": "user-1" }, { "cid": "4", "user": "user-2", "content": "常在c用多线程处理数据，没在c++用过，但原理应该差不多。看你的程序只有一个锁，在一个线程上锁后其他线程无法使用这个锁，所以应该不会有冲突。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "谢谢回答 冲突到没发生 析构的线程和任务的线程肯定不同 但是析构的阻塞掉了 我感觉任务线程有可能卡在④上啊，这块是不是应该会有风险，即使是运气最差的情况下", "referer": "user-2" }, { "cid": "6", "user": "user-2", "content": "4这个位置不会卡，它会等1这个位置的锁解锁后才可以对锁进行操作，即使它们属于不同线程也会等待。", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "但是有可能出现互锁呢 1等4 4等1", "referer": "user-2" } ]

[ { "cid": "2", "user": "user-2", "content": "要让p2指向传入数组的最后一个元素，可以将p2的初始值设置为height + heightSize - 1，即&height[heightSize - 1]。这样，在循环中每次移动指针时，p2就会指向数组的最后一个元素。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "数量这玩意只能传进来，不传进来谁知道有几个", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "第二参数难道不是做这个的么？", "referer": "user-3" }, { "cid": "5", "user": "user-0", "content": "int *p2 = &height[heightSize-1];我之前这样写打错了，", "referer": "user-3" } ]

[ { "cid": "2", "user": "user-2", "content": "在当前项目中有实现GetAngle的.c/.cpp源代码或附加连接库里有GetAngle的实现。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "我在同一目录下命名了两个文件：Test1.c和Test2.c，这是1里面的，我也在2里面定义了GetAngle函数", "referer": "user-2" }, { "cid": "4", "user": "user-0", "content": "还请大佬说的详细点", "referer": "user-2" }, { "cid": "5", "user": "user-2", "content": "同一目录下不一定有用，得在makefile（使用nmake生成）或当前项目中添加现有项选Test2.c（使用VS20xx生成）", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "大佬，求解", "referer": "user-0" } ]

[ { "cid": "2", "user": "user-2", "content": "数组的大小使用变量len来指定，而len的值是在运行时计算得到的，编译器无法确定数组大小，所以会报错。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "int *nums=new int[len]; delete [] nums;//nums用完后", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "感谢", "referer": "user-3" }, { "cid": "5", "user": "user-4", "content": "len是变量", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "哦哦，我知道了，不能在运行时才知道数组的大小，我以为java", "referer": "user-4" }, { "cid": "7", "user": "user-5", "content": "你的编译器应该已经告诉你了，它不支持动态大小的数组。", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "啊？len不是定义的吗", "referer": "user-5" }, { "cid": "9", "user": "user-0", "content": "我在vsc调式的时候到这里要点好多次下一步，也可以正常出结果", "referer": "user-0" }, { "cid": "10", "user": "user-0", "content": "抱歉，我知道了，不能在运行时才知道数组的大小，我以为java", "referer": "user-5" } ]

[ { "cid": "1", "user": "user-1", "content": "加油，继续努力！！", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "你add（）函数里打开文件进行追加时（fp=fopen（“emploee_list”，“a”）；），文件名有拼写错误。它应该是“employee_list”，", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-2" }, { "cid": "4", "user": "user-3", "content": "大哥教教我我新手.网课大学生现在啥也不会求带", "referer": "user-2" }, { "cid": "5", "user": "user-0", "content": "您可以帮我解答一下消费总额和充值总额为什么算不出来吗？【大哭】", "referer": "user-2" }, { "cid": "6", "user": "user-2", "content": "建议使用charGPT", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "希望有大佬能为我解答，急！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "我也小白，首先我感觉int n 完全没必要传参，sort函数里t没有初始化", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "174 应该定义一个指针，把满足条件的保存 char *p = (char*)malloc( N * sizeof(char)); 好吧我也不知道这能不能行", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "感谢我去试试", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "参考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); }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢赵4老师！辛苦你了。咱们论坛能不能选择最佳答案呀？", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "赵4老师，我用devc++软件，C工程，提示找不到zutil.h", "referer": "user-1" }, { "cid": "4", "user": "user-0", "content": "赵4老师，这是不是linux的代码呀？太难懂了", "referer": "user-1" }, { "cid": "5", "user": "user-1", "content": "你需要看HAL_CRC_Calculate的实现", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "我看了，这个看不出来的，是硬件CRC，设置好在之后，自动出数。", "referer": "user-1" }, { "cid": "7", "user": "user-2", "content": "你的意思是需要一个工具计算出aDataBuffer 对应的crc值吗可以用http://www.ip33.com/crc.html .", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "谢谢！你理解错了，我想知道计算的过程。比如单片机使用硬件CRC，上位机使用软件CRC，怎么得出和硬件CRC一样的结果。", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "你自己能看见出错信息都需要想很久，那么其他人看不见你的出错信息会需要想更久，成本太高了。", "referer": "user-0" } ]

[ { "cid": "2", "user": "user-2", "content": "实参传给形参时类型需要匹配，有几种情况是特例：1.实参类型可以自动转换为形参类型，例如char->int，float-double.2.形参的权限比实参的权限小，如char*->const char*.100字面量是int，传参时不会自动转换为指针类型，所以需要强制转换", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "调用函数时使用的实参表达式的值的类型必须与形参类型一致，或者能够自动转换为形参类型，或者强制转换为形参类型。", "referer": "user-0" } ]

[ { "cid": "2", "user": "user-2", "content": "在最后main函数里的死循环里，建议改成四个判断，不要再嵌入while while(1) { keynum=key(); if(keynum == 1){ led1(); } else if(keynum == 2 ){ led2(); } } 类似这样", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "你点灯的函数中也嵌入了一个死循环while(1)", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "\"recv卡住\": 你的socket fd是设置成非阻塞了吗？如果是非阻塞的，recv的返回值有正确处理吗？（比如特殊判断EAGAIN）还有看你描述用的是UDP，UDP本身就是不可靠的，假如某个UDP包丢了，那么对方就收不到了，项目里有针对UDP做可靠性的开发吗", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "我这不是“某个UDP包丢了”，\"recv卡住\"是recv长时间卡住", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "你没把socket fd设置成非阻塞吧？", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "fd默认是阻塞的，如果调用recv，但此时缓冲区没有内容就会卡住", "referer": "user-1" }, { "cid": "5", "user": "user-2", "content": "对方不send了，或网络临时断开或拥塞了，同步recv当然也就卡住了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "printf一个不以\\n结尾的字符串，要想确保字符串真正显示出来，别缓存在标准输出缓冲区中，需要紧跟一句fflush(stdout);rewind(stdin);//这才是C清标准输入缓存的正确方式cin.clear();cin.sync();//这才是C++清标准输入缓存的正确方式", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "输入密码参考下面： #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); }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "手工确认一下有没有生成exe文件。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "生成了", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "既然生成了那就执行它呗。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这个返回值 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; } 希望这些修改能够帮助你解决问题。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "应该改为scanf_s(\"%s\"，&name，sizeof（name）)；第二个参数要加上&，第三个参数是长度。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "name前面加&", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "输入姓名那里：scanf_s(\"%s\", name); 修改为：scanf_s(\"%s\", name, 40);", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "scanf_s() 的参数不对吧，看看帮助，好像对字符和字符串类参数，要有可许空间大小参数的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "仅供参考： #include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点 char data; //数据 struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树 char data; scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树 if (data == '#') { *T = NULL; } else { *T = (BiTree)malloc(sizeof(BiTNode)); nn++; (*T)->data = data; //生成根结点 CreateBiTree(&(*T)->lchild);//构造左子树 CreateBiTree(&(*T)->rchild);//构造右子树 } return 0; } void Visit(BiTree T) {//输出 if (T->data != '#') { printf(\"%c \",T->data); } } void PreOrder(BiTree T) {//先序遍历 if (T != NULL) { Visit(T); //访问根节点 PreOrder(T->lchild); //访问左子结点 PreOrder(T->rchild); //访问右子结点 } } void InOrder(BiTree T) {//中序遍历 if (T != NULL) { InOrder(T->lchild); //访问左子结点 Visit(T); //访问根节点 InOrder(T->rchild); //访问右子结点 } } void PostOrder(BiTree T) {//后序遍历 if (T != NULL) { PostOrder(T->lchild); //访问左子结点 PostOrder(T->rchild); //访问右子结点 Visit(T); //访问根节点 } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。 BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree)); int sp=0; BiTree p = T;//p是遍历指针 while (p || sp) { //栈不空或者p不空时循环 if (p != NULL) { stack[sp]=p;sp++; //存入栈中 printf(\"%c \",p->data); //访问根节点 p = p->lchild; //遍历左子树 } else { sp--;p=stack[sp]; //退栈 p = p->rchild; //访问右子树 } } free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。 BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree)); int sp=0; BiTree p = T;//p是遍历指针 while (p || sp) { //栈不空或者p不空时循环 if (p != NULL) { stack[sp]=p;sp++; //存入栈中 p = p->lchild; //遍历左子树 } else { sp--;p=stack[sp]; //退栈 printf(\"%c \",p->data); p = p->rchild; //访问右子树 } } free(stack); } typedef struct BiTNodePost{ BiTree biTree; char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归) BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost)); int sp=0; BiTree p = T;//p是遍历指针 BiTreePost BT; while (p != NULL || sp) {//栈不空或者p不空时循环 while (p != NULL) {//遍历左子树 BT = (BiTreePost)malloc(sizeof(BiTNodePost)); BT->biTree = p; BT->tag = 'L';//访问过左子树 stack[sp]=BT;sp++; //存入栈中 p = p->lchild; } while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点 sp--;BT=stack[sp]; //退栈 printf(\"%c \",BT->biTree->data); free(BT); } if (sp) {//遍历右子树 BT=stack[sp-1]; BT->tag = 'R';//访问过右子树 p = BT->biTree; p = p->rchild; } } free(stack); } void LevelOrder(BiTree T) {//层次遍历 BiTree p; BiTree *queue; int h=0,t=0,n=0; if (T == NULL) return; p=T; queue=(BiTree *)malloc(nn*sizeof(BiTree)); queue[t]=p;t=(t+1)%10;n++;//根节点入队 while (n) { //队列不空循环 p=queue[h]; //对头元素出队 printf(\"%c \",p->data); //访问p指向的结点 h=(h+1)%10;n--; //退出队列 if (p->lchild != NULL) {//左子树不空，将左子树入队 queue[t]=p->lchild;t=(t+1)%10;n++; } if (p->rchild != NULL) {//右子树不空，将右子树入队 queue[t]=p->rchild;t=(t+1)%10;n++; } } free(queue); } int main() { BiTree T; setlocale(LC_ALL,\"chs\"); CreateBiTree(&T); printf(\"先序遍历 ：\");PreOrder (T);printf(\"\\n\"); printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\"); printf(\"\\n\"); printf(\"中序遍历 ：\");InOrder (T);printf(\"\\n\"); printf(\"中序遍历(非递归)：\");InOrder2 (T);printf(\"\\n\"); printf(\"\\n\"); printf(\"后序遍历 ：\");PostOrder (T);printf(\"\\n\"); printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\"); printf(\"\\n\"); printf(\"层次遍历 ：\");LevelOrder(T);printf(\"\\n\"); return 0; } //ABC##DE#G##F### //先序遍历 ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历 ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历 ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历 ：A B C D E F G // /// A /// / /// B /// / \\ /// C D /// / \\ /// E F /// \\ /// G", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "在稀疏矩阵相加的函数 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;", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "数组下标这玩意，您有时是从0开始用的，有时是从1开始用的，不乱才怪。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "没声明出错了那就声明一下呗。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "数组要初始化为空。", "referer": "user-0" } ]

[ { "cid": "2", "user": "user-2", "content": "明显不就是提示花括号不匹配吗？花括号一对一对的。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "一看这个报错就是说少了}", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "tmp_matrix_d[ik] = sum;你这里的 sum是float，计算结果已经损失精度了", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "REAL 原始是double，我这里也更改成double过，一样是不正确的结果，很诧异的是这个东西就是损失精度，得到结果是颠覆的。", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "换个编译器试试，或者关闭优化选项试试", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "应该是如 user-2所说，基本是tmp_matrix_d 计算得到输出和tmp_a有细小的差别， 矩阵求逆 就出现颠覆性的值", "referer": "user-1" }, { "cid": "5", "user": "user-2", "content": "tmp_matrix_d 是怎么计算来的吧，这意味着由于浮点的表示限制，和 tmp_a 还是有误差的。将提及的那个贴里的 matrix.c 中 solve_matrix_equation_by_lup_decomposition() 每一步都对涉及到刚才变化了的 matrix 进行输出，对比了两个的结果，发现，好像是有细微的误差慢慢累积起来的，很是奇怪，怎么最后会有如此的大不同。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "就这个问题，你也没找到为什么是吧，直接赋值就OK，计算得到就出现很大的偏差", "referer": "user-2" }, { "cid": "7", "user": "user-2", "content": "好像就是这样的，在“数字帝国”站上，用它的矩阵求逆功能，从你的数据里取了前 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\t-29.127886\t24.652281\t-6.921387 -29.127886\t78.401900\t-74.196654\t24.357593 24.652281\t-74.196654\t77.738316\t-28.724857 -6.921387\t24.357593\t-28.724857\t11.949217 将最右下的数据由 16.95 改为 16.96，再算，结果是： 11.635207\t-27.62195\t22.876335\t-6.182613 -27.62195\t73.102244\t-67.946782\t21.757716 22.876335\t-67.946782\t70.367855\t-25.658828 -6.182613\t21.757716\t-25.658828\t10.673783 两次的结果差异甚大；所以，细微的误差，可能会引发巨震。", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "看来就是数据的细小差异导致的，", "referer": "user-2" } ]

[ { "cid": "2", "user": "user-2", "content": "#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; }", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "win7 x64 + vc2008 好像是执行了的；其实，无须这个调用，输出的把 \\n 改为 \\r 试试。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "指针作参数要传递什么取决于参数本身存在的意义，即 “这个参数是什么？以及它要用来干什么？”函数调用时，系统为函数分配栈区内存，函数的返回值、参数、局部变量、临时变量等都会在函数的栈内存中占据一席之地。普通变量传参的时候，是把实参的数据拷贝了一份到函数参数的所在栈内存中。指针变量传参的时候，也是把一个地址作为数据拷贝到了函数参数所在的栈内存中，不同之处在于，指针支持( * 解引用 )、( -> 结构体/联合体的成员访问)、( [ ] 数组下标访问 )等操作，可以通过传入的目标内存地址去访问以及读写目标内存的数据。当然上述这些操作的前提是传入的地址是有效的，即地址指向的确实是一个已存在的内存实例，或者说内存里确实已经有了这么个东西。传入的内容可以是一个局部变量的地址，也可以是一个已经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);", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢！", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "SPI_HandleTypeDef *hspi; uint8_t buf[1024]; HAL_StatusTypeDef rtn=HAL_SPI_Receive(hspi, buf,1024, 100);", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "谢谢赵4老师", "referer": "user-2" }, { "cid": "5", "user": "user-0", "content": "谢谢！我试试。", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "习惯上定义一个够大的数组作为接收缓冲区即可，把数组名当作实参传给它即可。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "以下是一个用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字符，即不包含空格、制表符或换行符。如果输入的字符不合法，程序可能会出现错误。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "写个循环n次的循环即可。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "cout<< p->get() << \" \" << p->n << endl;", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "没仔细看您的代码，初步判断是函数 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; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "5i乘号不能省", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "还是不行呢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "C Primer Plus 第六版", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "推荐先看《啊哈C》，因为我刚看过了。 入门级别的", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "已买，我也用用入门，谢谢🙏", "referer": "user-2" } ]

[ { "cid": "2", "user": "user-2", "content": "这个完全不关结构体的事，是基本输入输出不过关。字符变量存不下字符串；接受输入值的变量需要取地址。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "要说最可笑的理由，甚至有可能是写日志的文件系统满了。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "根据提供的问题描述，可能的原因有如下几点： 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或异常情况。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成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中", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "H进程卡死的原因可能是U进程的资源被耗尽，导致无法回复H进程的消息，最终导致H进程等待超时而卡死。 要排查这个问题，可以先查看U进程的日志，看看是否有相关的错误或警告信息。还可以使用系统监控工具，如top、ps等，查看U进程的资源占用情况，例如CPU、内存、网络等。如果发现U进程的资源占用过高，可能需要对其进行优化或调整。另外，可以尝试使用调试工具，如gdb、strace等，来跟踪U进程的执行过程，找出可能的问题点。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "去掉内存while死循环，直接写n+=ret;", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "内层while是个死循环，在它范围内a的值一直不变。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "请问解决了吗？我也是这个问题", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "我也是一样的情况 为什么啊", "referer": "user-0" } ]

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

[ { "cid": "1", "user": "user-1", "content": ".c文件的的路径中不要带中文字符", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "VS Code本身并不支持C语言调试，因为它是一个基于JavaScript的编辑器，而不是一个完整的集成开发环境（IDE）。 如果您需要在C语言中进行调试，您需要使用一个集成开发环境（IDE），例如Visual Studio或Eclipse。这些IDE通常都有内置的调试器，可以帮助您在代码中设置断点，并在运行时跟踪变量和函数的值。 如果您使用的是Visual Studio Code，您可以安装一个名为“C/C++ Intellisense”的扩展程序，它可以帮助您在编辑器中显示C/C++代码的语法高亮和自动完成。但是，这并不能完全替代使用IDE进行调试", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "用run code运行是可以的，但就是调试不了，直接运行也不行", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这作业挺有意思，我折腾了几天，写好又重写，写好又重写......。勉强捣鼓出一个。还特地做了一份测试用的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; }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "非常感谢", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "#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; }", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "谢谢啦", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "if(n) { f1(n/10); cout<<n%10<<\" \"; } ... if(n){cout<<n%10<<\" \"; f2(n/10);}", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "百度搜“正则表达式 邮件地址”", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "小伙子有前途，不要写代码了，转行去网站当小编～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "以下是一个简单的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; } 这个示例代码实现了一个简单的公交车查询系统，包括添加、显示、修改、删除和保存公交车路线信息等功能。你可以根据自己的需求进行修改和扩展。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "很遗憾，one function one x 。你的代码里只有一个变量x，你把它浪费了x=x/10之后，回过头去x<=y意义就不大了，x++就没意思了。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "🔗ChatGPT、AI绘图在线体验🔗Admin、Vue、Vite、Node、Midway、uniapp、Iot、外包、小程序🔗Cool-Admin、快速开发、CRUD、权限管理系统", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "if (n==3)", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "printf里面的%和变量的一一对应关系scanf里面的%和变量以及变量前加不加&的一一对应关系是C代码中非常容易出错的地方，而且通常编译还不出错。所以在编译源代码之前值得专门仔细检查一遍甚至多遍。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "那里应该是%c而不是%s", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "%c的话 就该设清除缓冲区", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "不保证对，仅供参考： #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; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "现在的码农竟然99%都不会在cmd窗口中输入cd命令设置当前目录为程序所在目录，输入程序名运行程序了！scanf的格式字符串中不要包含空格和\\n", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "您说的应该是以前码农做的操作，我没有学过计算机操作系统和lunix只知道一些简单的dos命令，用cmd窗口运行代码就见过郝斌的视频操作过，C语言具体怎么做真不知道", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "text.c这个名字暗示着里面是C语言代码，所以C++不好使。你可以查一下该环境下应该使用的扩展名。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "配置了还是不行，文件名字后缀也换成c++了", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "text.cpp", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "了解一下OpenCV中的Mat", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "语法性的错误太多。但是就标题提出的问题而言，简单地说，在相当多版本的C编译器下，根本不支持动态尺寸的数组。所以你首先要确定你的编译器支持，然后再说怎么写，以及修正其他错误。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "题主的问题在于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", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "感谢！！", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "放到while外面也不行", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "return 0放外面 删了分号", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "return 0放在while循环里面了", "referer": "user-0" }, { "cid": "6", "user": "user-4", "content": "关键原因是while行末有个多余的分号，这个分号篡夺了循环体的地位，构成了死循环。", "referer": "user-0" }, { "cid": "7", "user": "user-5", "content": "把return 0；放while外，return 0；会结束while的操作", "referer": "user-0" }, { "cid": "8", "user": "user-6", "content": "把 return 0; 放到while外面", "referer": "user-0" }, { "cid": "9", "user": "user-0", "content": "放到while外面了还是不行，也不报错就是无输出", "referer": "user-6" } ]

[ { "cid": "1", "user": "user-1", "content": "在scanf系列函数里，我是说包括fscanf对应double类型的变量的格式符需要使用%lf而不是%f", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "您是认真的么？编译能成功的话，起码得有含有错误的运行截图吧？还有无法读入的数据文件，你得确认它存在，位置正确，名字正确，权限正确，内容正确呀。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你不妨想一想为什么你输出的最小值是正确的，在和要求的最大值对比一下", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "感谢啊，找到问题了。能再问一下为什么这个题目里引用函数一定要用到指针啊。", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "你不妨琢磨一下，为什么scanf引用变量要用指针（取地址），而printf一般不用。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "我这学期刚学，没有接触过scanf和printf。", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-0", "content": "已解决。PCB利用好就OK", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "我在ubuntu,fedora下测试都是如此，哎，基础知识不过关啊", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "那玩意是显示部件，你得保证它每秒刷新25次以上，才能看不出来闪。我的意思是说，它实际上就应该一直闪，只不过弄好了就看不出来而已。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "OK了搞定", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "在 C 语言中，可以使用scanf函数读取用户输入的数字，并通过判断来限制其大小。以下是一些实现方式： 使用循环和条件语句 int num;printf(\"请输入一个小于100的整数：\");while (scanf(\"%d\", &num) == 1 && num >= 100) { printf(\"输入错误，请重新输入：\"); while (getchar() != '\\n') ; //清空输入缓冲区}printf(\"您输入的数字是：%d\\n\", num);", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "这个有问题", "referer": "user-1" }, { "cid": "4", "user": "user-2", "content": "你判断一下不就好了嘛，设置一个最大值和最小值。不在范围内你返回重新输入", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "输入不在限定范围内，提示并重新输入", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "具体问题具体分析。理论上每个系统都可以有不同的设计。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "数字不对吧~", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址；人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "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", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "sizeof是编译期运算；不是运行时运算。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "因为形参数组名的实质是一个指向首元素的指针。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "哦哦哦 谢谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "找不到HAL_StatusTypeDef的定义https://www.baidu.com/s?wd=HAL_StatusTypeDef", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "有什么特殊环境限制吗，C语言的求模运算是编译器自带的，不依赖库的，因该可以直接用求模看余数是否为0来判断啊。你是用加减2趋近0来判断奇数偶数，那你的两个do while 的判断正负的条件弄反了。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "你这个算法，有些费事。while() 里的判断条件不对吧，m>0 时，应该是 while(m>0) 吧，否则也不能循环了；下面的 while() 类似。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！） 单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。 栈中的变量通常包括函数参数和函数里声明的临时变量。栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。而栈中的类变量退出其作用域时，会自动执行其析构函数，……所谓在栈中“申请”N字节的空间，其实只是将栈指针寄存器（16位sp，32位esp，64位rsp）的值多减N而已。 VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。”但我又不得不承认： 有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物； 而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。而我本人属前者。 不要企图依赖输出指针相关表达式...的值【比如printf(\"%p\\n\",...);或者cout<<...】来理解指针的本质，而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。 这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！ 提醒：“学习用汇编语言写程序”和“VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。（Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）想要从本质上理解C指针，必须学习C和汇编的对应关系。”不是一回事！ 不要迷信书、考题、老师、回帖；要迷信CPU、编译器、调试器、运行结果。并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "多谢!", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "写一行，调试一行，行行出BUG", "referer": "user-1" }, { "cid": "4", "user": "user-1", "content": "其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "例2的a一样能得到num的地址，没问题。只不过离开这个函数也就是a的作用域以后a本身就不在了。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "见过大佬N次。例2，用在实际情况里，我的程序没有正常运行。而且，指针 一般不都是要 malloc 的吗？", "referer": "user-3" }, { "cid": "7", "user": "user-3", "content": "所以说您把实际存在问题的部分当作无关紧要的内容，从而简化掉了。 指针变量首先是个变量，变量肯定是对应着一小块存储空间的，这个不需要另外申请。 一般要malloc的是目标空间，也就是把自己的首地址送去给指针变量保存的那个空间。而您这里的目标已经有了，就是num，所以不存在什么空间问题。 问题就是局部变量a离开作用域以后失去了定义。", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "待验证！谢谢大佬！", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-1", "content": "#include <stdlib.h>//int rand;", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "删掉那行int rand;", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "函数名前置类限定嘛", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "另外这样写（无论前者后者）严谨地说不算是清空，因为它只清到行末。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "功能上没有区别。效率上前者不可能高于后者，现代编译器中大概率编译成一样的。至于为什么，恐怕您得问编者了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "int *a = new int [n];", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "调式噻，一步步运行看哪里不对噻；加数据函数里，应该先放数据，在调 rear 吧；其它，显示数据，你显示的是下标，数据应该是 q->data[q->rear] 吧，而且显示过程把数据清空了，对还是不对。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "不是哥们，你不会debug一下吗", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "所以，红灯凭什么要亮呢？", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "使用arduino-ide_2.0.4可以单步调式", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "帮你改了两个地方。 #include <stdio.h> #define SIZE_ONE 7 #define SIZE_TWO 3 void copy_fun(double array_ar[],double source_ar[]); int main(void) { int index; double source[SIZE_TWO]; double array[SIZE_ONE] = { 1.2, 2.3, 4.2, 7.9, 6.3, 9.3, 9.3 }; copy_fun(array,source);//删去void printf(\"source's value as following:\\n\"); for (index = 0; index < SIZE_TWO; index++) printf(\"%.1f \", source[index]); return 0; } void copy_fun(double array_ar[],double source_ar[]) { int i, index; for (index = 0, i = 2; index < SIZE_ONE- 4; index++, i++)//SIZE改为SIZE_ONE source_ar[index] = array_ar[i]; }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "#include <stdio.h> #define SRC_ARR_LENGTH 7 #define DST_ARR_LENGTH 3 void copy_fun(double src_ar[], double dst_ar[]) { int j = 0; for (int i = 0; i < SRC_ARR_LENGTH; i++) { if ((i>=2) && (i<=4)) { dst_ar[j++] = src_ar[i]; } } } int main() { double dstArray[DST_ARR_LENGTH] = {0, 0}; double srcArray[SRC_ARR_LENGTH] = { 1.2, 2.3, 4.2, 7.9, 6.3, 9.3, 9.3 }; copy_fun(srcArray, dstArray); printf(\"source's value as following:\\n\"); for (int i = 0; i < DST_ARR_LENGTH; i++) { printf(\"%.1f \", dstArray[i]); } printf(\"\\n\"); return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "函数调用语句不能带前面的void，带着那玩意就被编译器理解为函数原型声明了。另外，啥地方定义了SIZE了？你的函数里SIZE-4没法解释啊。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "十分感谢，我已经对代码进行了修改，可以输出想要的结果了。", "referer": "user-3" }, { "cid": "5", "user": "user-4", "content": "失效，什么阶段什么表现；编译时，照着提示的错误信息和错误所在行，去修改；若运行结果不对，调试，在复制语句上断点，看每次复制时的状况，有错误，看错哪里，改。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf(\"%d,&gread\"); 注意引号位置scanf(\"%d\",&gread);", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "#include <stdio.h> int main() { int grade; scanf(\"%d\", &grade); if(grade >= 90) { printf(\"成绩为优秀\\n\"); } else if((grade >= 70) && (grade <90)) { printf(\"成绩为良好\\n\"); } else if((grade >= 30) && (grade < 70)) { printf(\"成绩为合格\\n\"); } else { printf(\"成绩为差\\n\"); } return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "#include <stdio.h> int main() { int gread; scanf(\"%d\",&gread); if (90<=gread ) printf(\"成绩为优秀\\n\"); else if (70<=gread && gread<90) printf(\"成绩为合格\\n\"); else if (30<=gread && gread<70) printf(\"成绩为良好\\n\"); else if ( 0<=gread && gread<30) printf(\"成绩为差\\n\"); return 0; }", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "码的漂亮，应该效仿！", "referer": "user-3" }, { "cid": "5", "user": "user-3", "content": "https://bbs.csdn.net/topics/380157851", "referer": "user-4" }, { "cid": "6", "user": "user-5", "content": "子曾经说过，思而不学则die所以咱得学，而不是想当然地随便写。", "referer": "user-0" }, { "cid": "7", "user": "user-6", "content": "scanf() 语句的后双引号放哪里去了", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "兄弟，我改完了以后，还是不行。 运行是不能正常运行，就无论输入什么数值，它都是只有一个输出（成绩为优秀和成绩为差）一起输出的", "referer": "user-6" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf() 语句里不是要求用逗号么，还问为什么？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "if 和 else if 行末不应该有语句结束标记字符分号 ;", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "; 号", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "随意敲数据类型的后果。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "不调试么，走一边大概就能知道问题在哪里吧；好像数据类型有不对", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "Coe() 里的 s ，最前面的声明是 int 但看函数里的使用，又是 float", "referer": "user-3" }, { "cid": "5", "user": "user-4", "content": "这个问题可能与浮点数精度有关，因为浮点数在计算机中的表示方式可能存在精度损失。在程序中，你将浮点数输入到s变量中，但在Coe函数中，你将其与18.5进行比较。由于在计算机内部存储和表示浮点数时的精度限制，可能会导致s变量与18.5进行比较时的结果不是你期望的。因此，建议你可以将s变量与一个非常接近的整数进行比较，而不是浮点数18.5。例如，你可以定义一个整数常量，如下所示： #define BASE_S 185 然后，将s与BASE_S进行比较，如下所示： if (s <= BASE_S) { s1 = 0; } else if (s - BASE_S <= 5) { s1 = 1; } else if (s - BASE_S > 5) { s1 = (s - BASE_S) / 5 + 1; } 这样，你就可以将浮点数s转换为整数进行比较，避免了由于精度误差导致的计算结果错误的问题。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "谢谢🙏，懂", "referer": "user-4" }, { "cid": "7", "user": "user-0", "content": "t输入16 s输入18.6 ch选择211 结果应该是525，输出的却是450.", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf(\"%9s\",Name);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "还请麻烦您细讲一下什么是定义标识符 现在我只是跟着翁恺老师的视频跟着敲代码 当然老师的代码是输出了出来", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "标识符，identifier，指的是程序代码里的那些“名字”，各种东西的名字。 变量名是标识符的重要子集。 C中一个变量使用之前需要定义/声明，定义和声明当然还有自己的差别。 变量声明是一个说明，清晰表达这个名字的变量是什么类型的，这将会决定以后什么样的操作才是合法的，因为不同类型的操作集是有区别的。 而变量定义除了具有声明类型的功能，还向编译器要求在计算机内存里分配一块空间来存放这个变量。 综上，您敲代码时跳过的 int price; （在这个程序里简约形式可以这样写，也就是省略初始化，=0字样）就是一个承担了定义任务的声明。 上面最后这行内容再笼统一下就表达为 标识符price未定义。", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "教材还是要看的，细看，尤其不要主观上觉得哪部分没用或者“聪明地发现”内容重复，于是就忽略一些内容。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "哦哦好的谢谢您 教材现在在看谭浩强老师的版本 当然只是粗看 之后我定会细看 感谢你提出的意见", "referer": "user-1" }, { "cid": "5", "user": "user-1", "content": "我一直说，初学者排错只看第一个错，改之，重新编译。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "意思是未定义标识符的问题吗？我的理解是；如果正确了应该就可以定义了不知道我的理解是否正确 还请指正", "referer": "user-1" }, { "cid": "7", "user": "user-1", "content": "当然不正确，因为您的确没有定义标识符price。", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "您看看上面的那个回复 这里回复我发不了图片给您", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "你的第一个函数，init...忘记调用了。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "看 ShowList() 里，你的表链有个起始的空表头项，那 Linklist L; 就不对了，应该是 linnode L; 吧，这样的话，那些函数调用参数也要改下变成 &L 了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h> #define WIRTE_UINT(des ,x ,pos ,len) ( \\ (des) \\ & \\ ~( /* 除要修改的位为0，其余都为1 */ \\ ( \\ (1<<(len))-1 /* 长度为len位的1 */ \\ ) \\ <<(32-(pos)-(len)) /* 左移32-(pos)-(len)位 */ \\ ) \\ | \\ ( \\ (x) \\ <<(32-(pos)-(len)) \\ ) \\ ) #define READ_UINT(src ,pos ,len) ( \\ ( \\ ( \\ (unsigned)(src) \\ ) \\ >>(32-(pos)-(len)) /* 逻辑右移32-(pos)-(len)位 */ \\ ) \\ & \\ ( \\ (1<<(len))-1 /* 长度为len位的1 */ \\ ) \\ ) int main() // 1111111111222222222233 { //bit 01234567890123456789012345678901 unsigned int des = 0x661; // 00000000000000000000011001100001 unsigned int r; des = WIRTE_UINT(des ,3 ,28 ,2); // 00000000000000000000011001101101 printf(\"des==0x%08X\\n\",des); r = READ_UINT(des ,28 ,2); printf(\"r==%d\\n\",r); return 0; } //des==0x0000066D //r==3", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "参考C:\\Program Files (x86)\\Windows Kits\\8.1\\Include\\um\\WinUser.h /* * Extended Window Styles */ #define WS_EX_DLGMODALFRAME 0x00000001L #define WS_EX_NOPARENTNOTIFY 0x00000004L #define WS_EX_TOPMOST 0x00000008L #define WS_EX_ACCEPTFILES 0x00000010L #define WS_EX_TRANSPARENT 0x00000020L #if(WINVER >= 0x0400) #define WS_EX_MDICHILD 0x00000040L #define WS_EX_TOOLWINDOW 0x00000080L #define WS_EX_WINDOWEDGE 0x00000100L #define WS_EX_CLIENTEDGE 0x00000200L #define WS_EX_CONTEXTHELP 0x00000400L #endif /* WINVER >= 0x0400 */ #if(WINVER >= 0x0400) #define WS_EX_RIGHT 0x00001000L #define WS_EX_LEFT 0x00000000L #define WS_EX_RTLREADING 0x00002000L #define WS_EX_LTRREADING 0x00000000L #define WS_EX_LEFTSCROLLBAR 0x00004000L #define WS_EX_RIGHTSCROLLBAR 0x00000000L #define WS_EX_CONTROLPARENT 0x00010000L #define WS_EX_STATICEDGE 0x00020000L #define WS_EX_APPWINDOW 0x00040000L #define WS_EX_OVERLAPPEDWINDOW (WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE) #define WS_EX_PALETTEWINDOW (WS_EX_WINDOWEDGE | WS_EX_TOOLWINDOW | WS_EX_TOPMOST) #endif /* WINVER >= 0x0400 */ #if(_WIN32_WINNT >= 0x0500) #define WS_EX_LAYERED 0x00080000 #endif /* _WIN32_WINNT >= 0x0500 */ #if(WINVER >= 0x0500) #define WS_EX_NOINHERITLAYOUT 0x00100000L // Disable inheritence of mirroring by children #endif /* WINVER >= 0x0500 */ #if(WINVER >= 0x0602) #define WS_EX_NOREDIRECTIONBITMAP 0x00200000L #endif /* WINVER >= 0x0602 */ #if(WINVER >= 0x0500) #define WS_EX_LAYOUTRTL 0x00400000L // Right to left mirroring #endif /* WINVER >= 0x0500 */ #if(_WIN32_WINNT >= 0x0501) #define WS_EX_COMPOSITED 0x02000000L #endif /* _WIN32_WINNT >= 0x0501 */ #if(_WIN32_WINNT >= 0x0500) #define WS_EX_NOACTIVATE 0x08000000L #endif /* _WIN32_WINNT >= 0x0500 */", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "故障bit需要是变量，需要set和reset", "referer": "user-1" }, { "cid": "4", "user": "user-2", "content": "既然是单片机，为什么不外置编码器来直接提供故障号呢？有了号，再来个函数指针数组直接搞定。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "硬件不做改动", "referer": "user-2" }, { "cid": "6", "user": "user-0", "content": "单从软件角度有没有更好的定义方法？", "referer": "user-2" }, { "cid": "7", "user": "user-2", "content": "既然是软的那为什么不用故障号变量，却一定要用比特表达呢？ 所以您得说清楚什么需求什么约束，否则问题没啥意义呀。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这是蝙蝠侠的第二台座驾的草稿啊，你从哪里翻出来的？当年还可以卖给超人，现在估计他不感兴趣了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "logged in被翻译为登录然后误作登陆然后再翻回去成了landed这种事会被人笑的", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "另外数组名就是地址，所以这个scanf里面就不要对数组名取地址了。", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "arr2 数组溢出了，你就定义了一个字符的空间，输入字符串，起码得两个吧，一个字符，一个字符串结束标记字节 0x00；所以，把 arr2 定义得大些试试，如 arr2[64]", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "懂了懂了，谢谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "%lf%lf%lf", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "另外我眼神不行，认不出%和f中间是数字1还是小写L，请确保用小写L 。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "是小写l，感谢您的回答", "referer": "user-2" }, { "cid": "5", "user": "user-2", "content": "格式串里的非格式符，例如逗号，是需要你精确地原样输入的。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "好像还真是逗号的问题，把逗号换成空格就正常了。", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "不要做A语言代码修改为B语言代码的无用功。也不要做用A语言代码直接调用B语言代码库这样复杂、这样容易出错的傻事。只需让A、B语言代码的输入输出重定向到文本文件，或修改A、B语言代码让其通过文本文件输入输出。即可很方便地让A、B两种语言之间协调工作。比如：A将请求数据写到文件a.txt，写完后改名为aa.txtB发现aa.txt存在时，读取其内容，调用相应功能，将结果写到文件b.txt，写完后删除aa.txt，再将b.txt改名为bb.txtA发现bb.txt存在时，读取其内容，读完后删除bb.txt以上A可以替换为任何一种开发语言或开发环境，B可以替换为任何一种与A不同的开发语言或开发环境。除非A或B不支持判断文件是否存在、文件读写和文件更名。但是谁又能举出不支持判断文件是否存在、文件读写和文件更名的开发语言或开发环境呢？可以将临时文件放在RamDisk上提高效率减少磨损磁盘。数据的结构很复杂的话，文本文件的格式问题可参考json或xml 共享临时文本文件这种进程之间的通讯方法相比其它方法的优点有很多，下面仅列出我现在能想到的：·进程之间松耦合·进程可在同一台机器上，也可跨机，跨操作系统，跨硬件平台，甚至跨国。·方便调试和监视，只需让第三方或人工查看该临时文本文件即可。·方便在线开关服务，只需删除或创建该临时文本文件即可。·方便实现分布式和负载均衡。·方便队列化提供服务，而且几乎不可能发生队列满的情况（除非硬盘空间满）·…… “跨语言、跨机，跨操作系统，跨硬件平台，跨国，跨*.*的”苦海无边，回头是“使用共享纯文本文件进行信息交流”的岸！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。提醒：再牛×的老师也无法代替学生自己领悟和上厕所！单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。不要依赖调试器输出复杂数据结构！而要将复杂数据结构的整个内容在处理它的每一步使用一小段代码按自己很容易理解的格式输出，非常有助于调试！或者可以说是“基础设施”数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "initlist; 没有带入 l 指针，应该是 initlist(l); 吧；listinsert() 里最后没有填入数据；交换部分，没看懂，也不知道对不对。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "是因为ida版本问题吗还是在用ida打开文件的时候一些框框我没点", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "求教教了", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "https://xege.org/", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "easyx.cn", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "能不能详细说一说，我们书上没这个内容，现在束手无策了，谢谢谢谢", "referer": "user-2" }, { "cid": "4", "user": "user-2", "content": "绘图用easyx库，算法参考 https://blog.csdn.net/liuyuan_jq/article/details/6314261 中的python代码： from visual import * scene.width = 400 scene.height = 300 scene.autoscale = 0 scene.range = (100,100,100) scene.center = (50,40,0) ball = sphere(pos=(0,2,0),radius=2, color=color.green) ground = box(pos=(50,-1,0),size=(100,2,10)) gravity = 9.8 # m/s**2 velocity = 25 # m/s angle = 45 # degrees angle = angle * (pi/180) # converted to radians VelocityY = velocity * sin(angle) VelocityX = velocity * cos(angle) seconds = 0 dt = .01 finished = False while not finished: rate(100) # go thru the loop no more than 100 times/s seconds += dt # position equation: y(t) = y0 + v0*t + .5 * a * t**2 ballY = 2 + VelocityY * seconds - .5 * gravity * seconds**2 ballX = VelocityX * seconds ball.pos = vector(ballX,ballY,0) if ballY - 2 &lt;= 0: finished = True print \"initial velocity: \" + str(velocity) print \"angle thrown: \" + str(angle) print \"seconds in flight: \" + str(seconds) print \"distance in the x direction: \" + str(ballX)", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "有没有用C语言写的那种呢？", "referer": "user-2" }, { "cid": "6", "user": "user-0", "content": "谢谢各位朋友了，帮帮孩子", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "用 EOF 来判别，最后得按个 Ctrl+Z 组合键吧", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "放话了 已经好了", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "easyx.cn", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "/* 快来抄作业 */ #include <stdio.h> int main(){ int i, j, m, n, sum; for (i=100; i<1000; i++) { m = i; sum = 0; for (j=0; j<3; j++) { n = m%10; m /= 10; sum += n*n*n; } if (sum == i) { printf(\"%d\\n\", i); } } return 0; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "所以是概念性错误，数组没有第四元素。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "数组越界你的修改只是瞎猫碰上死耗子罢了 char *a[]={\"asd\",\"asda\",\"sx\",NULL};", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "有两个问题： 1.在函数printHero的参数列表中，struct hero heroArray[]应该改为struct Hero heroArray[]，大小写不匹配导致编译错误。 2.在函数bubbleSort的实现中，应该包含头文件#include，以便在比较字符串时使用string类型，否则将无法编译程序", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢你！研究了好久都没发现自己写错了orz", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "b是静态变量，也就是说每次调用b，都是在上一个b的基础上进行调用。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "第二第三次调用fun的时候，进去以后b就不是2了，上次结束时b是多少现在还是多少。这就是static的用处。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "目前是别的异常导致开发板出现断电重启，只能是在重启后，自己在遍历一次该文件，去掉这些不可见字符，在继续写了。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "这个没办法。就好象头疼，如果不找到原因，你没办法直接避免头疼。同样的道理。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "学会在IDE中调试时看每句C对应的汇编指令", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "184#include <stdio.h>int d=1;void fun(int p){int d=15; /* 这里定义个局部变量d，且初始化等于15 /d+=p++; / 这个d是局部变量d, p++没啥意义，结果不会传出函数外面 /printf(\"%d\",d); / p=3 时 d=18 注意这里没换行 /}int main( ){int a=3;fun(a);d+=a++; / 这个d是全局变量d，所以d等于4 */printf(\"%d\",d);return 0;} /* 所以最终结果输出184 */", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "求解析 越详细越好", "referer": "user-0" } ]