Question: 请问我这个链表创建代码哪里错了

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

完整的链表操作是少不了链表的释放的，建议加上。

#include <stdio.h> #include <stdlib.h>  typedef struct TNode{     int data1;     int data2;     struct TNode *next; }List;    int main(void) {     int n;     int i;     scanf("%d", &n);     List *L, *p;     L = (List *) malloc (sizeof(struct TNode));     L->next = NULL;     for( i = 0; i < n; i++){   /* 从0开始，就应该i < n*/         p = (List *)malloc (sizeof(struct TNode));         scanf("%d",&p->data1);         scanf("%d",&p->data2);         p->next = L->next;         L->next=p;     }      p = L->next;     while (p) {         printf("%d\t%d\n", p->data1, p->data2);         p = p->next;     }      return 0;  } List定义的是结构体变量，而不是结构体别名，所以要定义结构体别名，应该typedef； 上面的代码是修改后的，参考一下吧

//需要添加关键字typedef //不然就是申明一个结构体，并定义了一个对象List typedef struct TNode{ int data1; int data2; struct TNode *next; }List;  void main(){     int n; int i; scanf("%d",&n); List *L,*p; L=(List *) malloc (sizeof(TNode)); L->next=null; //i<n循环次数才正确 for( i = 0;i<n;i++){ //修改类型为List* p=(List*) malloc (sizeof(TNode)); scanf("%d",&p->data1); scanf("%d",&p->data2); p->next=L->next; L->next=p; }  }


Question: 新手跪求大神解释代码问题

int a[12] = {0,1,2,3,4,5,6,7,8,9}, //有两个元素未初始化 a既是一个指针，也是一个类型int[12]的变量。 cout<<a 和cout<<&a的值是一样的 ,说明此处&a中的a不是作指针来用，而是做变量来用。这个变量a的类型是int[12],所以&a的类型是int (*) [12] 改成   int *p = a;  //此处a作指针用 或者改成   int (*p) [12] = &a;    cout << *( (int*)p+2 ) <<endl; //打印第3个数据

抱歉：2、int a[12];     int *p=&a[0];//指针指向数组第一单元，也是默认为数组头地址，需要&符号的；  int *p=a;与int *p=&a[0];指针赋值表达式是不一样的O(∩_∩)O  谢谢楼主

楼主：c语言，指针数组的赋值是这样的： 1、int a[12];     int *p=a;//指针指向数组，默认为数组头地址，不需&符号；  2、int a[12];     int *p=a[0];//指针指向数组第一单元，也是默认为数组头地址，也不需&符号；


Question: sqlite3执行命令时占用大量内存用到哪去了？

引用 2 楼 xiang90721 的回复:[quote=引用 1 楼 zjq9931 的回复:] 用来缓存数据的啊。 可以加快查询速度啊。  如果是为了缓存数据，这个内存大小是否可以设置呢？因为测试过程中发现，这个内存增长达到一定值后就稳定不再增长了[/quote] 抱歉，详细的我并不了解。 个人感觉应当是可以设定的，但是怎么设定我不知道，也许不能，是软件已经定义好的。

引用 1 楼 zjq9931 的回复:用来缓存数据的啊。 可以加快查询速度啊。  如果是为了缓存数据，这个内存大小是否可以设置呢？因为测试过程中发现，这个内存增长达到一定值后就稳定不再增长了

用来缓存数据的啊。 可以加快查询速度啊。


Question: c语言，实际上就是函数调用

25楼  引用 25 楼 hdt 的回复:建议了解 8086 14个寄存器 数据寄存器 A B C D 指针寄存器 SP BP 变址寄存器 SI DI 控制寄存器  IP(注意 这个与运行代码有关)  FLAG （通过标志位确定下一步如何执行） 段寄存器 CS 代码段寄存器； DS数据段寄存器； SS 堆栈段寄存器； ES 附加段寄存器； 注意红字，你应该能想到代码是在内存中代码段的，通过IP确定执行哪一个代码 ，所以寄存器中间不会存储代码！ 楼上对于8086CPU来讲，上述的描述是对的。使用IP与CS配合到内存代码段读取下一个指令O(∩_∩)O 而我所讲的是目前，新型CPU(当然兼容8086)内部结构，及优势如图这种CPU当然可以当作8086来用O(∩_∩)O

引用 29 楼 zhao4zhong1 的回复:试问哪个厂商敢只出品新CPU，而不附带出品最能发挥该型号CPU性能的汇编器或C编译器？！  80386位早就推出了，试问真正32操作系统何时推出！

楼主借你的帖子回答一些东东，谢谢了O(∩_∩)O  首先，感谢赵4老师，《The Intel 64 and IA-32 Architectures Software Developer's Manual》已经下载了共计11个PDF文件。   大家在学习汇编语言或C语言时不必过分纠结于自己的电脑是什么类型的CPU，目前最新的CPU都提供了三种工作模式，如上图所示，虚拟8086模式，保护地址模式和实地址模式。一般考虑软件的兼容性通常使用虚拟8086模式比较好O(∩_∩)O

还有就是想问一下，目前的主流的c++编译器，那个是完全符合这个新cpu要求的？

引用 26 楼 HomerRo 的回复:25楼  [quote=引用 25 楼 hdt 的回复:] 建议了解 8086 14个寄存器 数据寄存器 A B C D 指针寄存器 SP BP 变址寄存器 SI DI 控制寄存器  IP(注意 这个与运行代码有关)  FLAG （通过标志位确定下一步如何执行） 段寄存器 CS 代码段寄存器； DS数据段寄存器； SS 堆栈段寄存器； ES 附加段寄存器； 注意红字，你应该能想到代码是在内存中代码段的，通过IP确定执行哪一个代码 ，所以寄存器中间不会存储代码！ 楼上对于8086CPU来讲，上述的描述是对的。使用IP与CS配合到内存代码段读取下一个指令O(∩_∩)O 而我所讲的是目前，新型CPU(当然兼容8086)内部结构，及优势如图这种CPU当然可以当作8086来用O(∩_∩)O[/quote] 哦，看看我的知识体系落后了！

引用 11 楼 qq_36179095 的回复:[quote=引用 1 楼 自信男孩的回复:]函数都有自己的函数栈，main函数也是，程序在运行时是将可执行文件加载到内存，即将函数load到栈上，根据栈的特性逐步执行。所以，不是将函数放到CPU寄存器，而是放在栈上的吧。个人见解 cpu工作的时候，运行的肯定是cpu的寄存器里的数据，所以某段数据要执行的时候，系统就自动把它放到寄存器中。不是么[/quote] 不一定是寄存器的，有可能直接从内存里拿

教课书上所讲到的内存四区，以及函数调用时的压栈数据到内存中等都是为了同学们的理解需要。其实，现在的计算机cpu内存除了指令寄存器包存将要执行的几条指令序列，数据寄存器保存中间数据，结果数据和将要用到的数据外。还有一级指令缓冲和二级指令缓冲，一级数据缓冲和二级数据缓冲，i7与i5系列还有高达3M字节的三级缓冲区，集成到cpu中用于保存数据与指令和作为堆栈区，用以加快程序的执行速度，同时减低计算机的功耗。

引用 21 楼 HomerRo的回复:更正一下，main()函数在调用fun()函数时，首先要进行压栈，把main()函数运行到M点时的所有相关变量的数据，包括：未使用的数据，中间数据，用过的的数据等都进行压栈处理，等从fun()函数返回时，再把这些数据出栈，恢复到main()函数在调用fun函数前M点的运行环境，继续向下运行。其中fun()函数的返回值一般在eax寄存器中。 非常认可你这个说法，我昨天晚上也想了一下，确实不应该是只保存未执行的数据。 在此声明一下:我之前的说法是错误的

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……

引用 15 楼 qq_36179095 的回复:[quote=引用 14 楼 倦怠的回复:]lz把必要条件说成了充分条件 就好比，你可以说人是胎生的，但你不能说胎生的就是人 这个明白，就好比，你是人，但人不是你，你只是人的一个实例而已[/quote] 又错了，此人非彼人也，逻辑不要从字面上去解读，而是要把他符号化。 计算机语言不好，可以通过练习加强。天生的逻辑差几乎无法弥补！

lz说的基本都对，这是C语言的函数调用过程O(∩_∩)O 个人认为在调用下一个函数时，如main()调用fun()时有个压栈过程，可能就是楼主所说的把main()函数未使用的数据保存到内存去吧，然后，调用fun()函数。 c语言的内存分为四个区，分别是“栈区,堆区,全局区,代码区”其中全局区也包括字符常量保存区，后二个区应该是只读区吧，所以，把数据保存到内存区，同保存到 栈区，也是这么一个意思O(∩_∩)O。CPU的寄存器区不同的寄存器在程序运行时要用到，在函数返回上一级函数时，也要用来保存返回值的。 据说，c语言内存有四区在面试时经常要考到。

引用 18 楼 qq_36179095 的回复:[quote=引用 16 楼 倦怠的回复:][quote=引用 15 楼 qq_36179095 的回复:] [quote=引用 14 楼 倦怠的回复:]lz把必要条件说成了充分条件 就好比，你可以说人是胎生的，但你不能说胎生的就是人 这个明白，就好比，你是人，但人不是你，你只是人的一个实例而已[/quote] 又错了，此人非彼人也，逻辑不要从字面上去解读，而是要把他符号化。 计算机语言不好，可以通过练习加强。天生的逻辑差几乎无法弥补！ [/quote] 你这个解释说服不了我，[/quote] 我回帖从来没打算说服任何人，每个人都有各自的看法。 我只是指出问题！

引用 16 楼 倦怠的回复:[quote=引用 15 楼 qq_36179095 的回复:] [quote=引用 14 楼 倦怠的回复:]lz把必要条件说成了充分条件 就好比，你可以说人是胎生的，但你不能说胎生的就是人 这个明白，就好比，你是人，但人不是你，你只是人的一个实例而已[/quote] 又错了，此人非彼人也，逻辑不要从字面上去解读，而是要把他符号化。 计算机语言不好，可以通过练习加强。天生的逻辑差几乎无法弥补！ [/quote] 你这个解释说服不了我，

是吗？！#include <stdio.h> #include <setjmp.h> jmp_buf mark; int i=0; void c() {     printf( "c in\n");     if (1==i%2) longjmp( mark, i );     printf( "c out\n"); } void b() {     printf( "b in\n");     c();     printf( "b out\n"); } void a() {     printf( "a in\n");     b();     printf( "a out\n"); } void main( void ) {    int jmpret;    jmpret = setjmp( mark );    printf( "Start %d\n",jmpret);    if( jmpret == 0 ) {        printf( "First\n");        a();        i++;        a();    } else {        printf( "Second\n");    } } //Start 0 //First //a in //b in //c in //c out //b out //a out //a in //b in //c in //Start 1 //Second //

参考，C语言反汇编  http://www.cnblogs.com/thammer/p/5303379.html

这和C语言没关系吧  对于裸机ARM  在CPU刚上电初始化时，SP（堆栈指针寄存器R13）还没有设置，必须使用汇编先设置一个内存地址到R13中，才可以正常调用C中函数  因为C编译器，对函数编译时，首先会有压栈操作，中间是函数体，最后是出栈操作


Question: C语言 对一个链队列进行两种操作是否会冲突？

仅供参考：//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef _MSC_VER     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #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); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #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} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX; CRITICAL_SECTION cs_BBB; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int main() { #ifdef _MSC_VER     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX);     InitializeCriticalSection(&cs_BBB); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef _MSC_VER     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef _MSC_VER     DeleteCriticalSection(&cs_BBB);     DeleteCriticalSection(&cs_HEX);     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }  任何收发两端速度不一致的通讯，都需要在它们之间使用一个足够大的FIFO缓冲区。 对任何FIFO缓冲区的使用，都需要仔细考虑接收端接收时超时无数据和发送端发送时FIFO缓冲区已满这两种情况下该如何做。 这些概念都在这段经典代码中有所体现。 这段经典代码还包括以下必须考虑的因素： ◆跨Windows和Linux平台 ◆多线程锁 ◆多线程日志 ◆日志文件占用的磁盘空间可控 ◆日志中的时间包括毫秒 ◆传输的数据对应的每个字节到底是几 ◆如何退出多线程程序 ◆……

多线程同时操作的话，对节点加锁，就可以了。  如果只有一个出队列操作，并且保证出队列所取的长度远小于当前队列长度，则可以不加锁，因为出入队列操作不冲突。但如果出队列线程也有多个，则无法保证不会取到头结点，故又需要锁了。

同时入队与出队是有可能引起冲突的，可行的解决办法如加锁保证访问的唯一性

如果是单进程或者单线程里，这样是不会冲突的。因为函数的调用时顺序的，即函数是从开始执行到结束是不会打断的（注意前提）； 但是，如果是多线程或多进程对链队列操作，那么就要处理同步问题。需要加锁

单线程操作肯定不会出现“同时”操作的问题，即使是两个不同的函数，也不会出现“同时”操作。 多线程操作肯定会出现“同时”操作的问题，即使是同一个函数也有可能出现“同时”操作。 解决办法： 临界区，互斥体，事件，加锁等等方式。 windows的话，就是windows多线程程序设计。


Question: C语言编程求帮助

char *cmd=“echo Hello\ndate\nls\n”;

char ** 或者 char a[][]二维数组存放 fopen打开文件 fgets读取一行 fclose关闭文件


Question: c语言，如图输出5行7列数组数据，我只想要第一行，怎么输出呢？

加一个标志flag，先将flag置为1，当输出第一行时，将flag置为0，即可。

用一个全局变量计数，比如int cnt = 0;   之后在那个循环里一开始cnt++; 再判断if(cnt == 1).......;之后在合适的地方再把cnt = 0；

这是输出部分，我想要输出它可能输出多行的第一行，请指教 /********************************************/ 				if (fabs((c[2] - c[0]) - c2) <= 1.0e-6 && fabs((c[3] - c[1]) - c3) <= 1.0e-4) 				{ 					if (m1 > 300) 					{ 						fprintf(fp0, "%lf\t%lf\t%d\t%d\t%d\t%d\t%d\n", w1, ls, m1 - 300, ms1, ms2, s1, s2); 						printf("%lf\t%lf\t%d\t%d\t%d\t%d\t%d\n", w1, ls, m1 - 300, ms1, ms2, s1, s2); 					} 				} 				if (m1 == 310) 				{ 					fprintf(fp1, "%lf\t%lf\t%d\t%d\t%d\t%d\t%d\n", w1, ls, m1 - 300, ms1, ms2, s1, s2); 					printf("%lf\t%lf\t%d\t%d\t%d\t%d\t%d\n", w1, ls, m1 - 300, ms1, ms2, s1, s2); 					break; 				} 				/********************************************/

把源代码贴出来，不然怎么看？


Question: 消去编译出现的strlwr警告

引用 2 楼 user-1 的回复:http://blog.sina.com.cn/s/blog_77f90afc0100wu3n.html 今天在练习谭浩强书（第四版）的180页例7.4时，我将函数声明去掉，出现了跟本帖类似的警告。 于是我就想，要是把string.h文件里的strlwr函数声明拷贝到main函数前，会不会消除警告呢？ 一试果然没有警告了。 这个警告真的莫名其妙。

引用 2 楼 user-1 的回复:http://blog.sina.com.cn/s/blog_77f90afc0100wu3n.html 您好，我打开string.h，发现里面有strlwr()的定义，那么编译器为何还发出warnning呢？

这个函数确实不是标准库中的函数，有些编译器会自己实现


Question: 菜鸟学PE结构遇到一个很有趣的问题

引用 4 楼 paschen 的回复:你文件打开方式是什么，ODOA实际是换行\r\n，读进来的时候有可能被处理成了一个\n  你也可以直接用原始的API函数去读，ReadFile  谢谢版主大大，按照你提供的知识我已经找到问题并解决了问题， 再次谢谢版主大大。

引用 3 楼 zhao4zhong1 的回复:不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了   谢谢赵老师， 按照您说的， 我已经明白并解决了疑惑。 非常感谢。

输出的ch为a，因为是%x，小写，所以输出a。注意不是OD，而是0D，前面是零而不是字母O； 注意一下，fseek让文件指针偏移了0x76个字节，建议再次确认一下偏移的0x76个字节后的数值是否为0D

《Windows PE权威指南》


Question: 打印hello world的疑问

浮点数格式 http://bbs.csdn.net/topics/390676437

引用 11 楼 wqte45 的回复:引用 9 楼 paschen的回复:1819043144 十六进制是 6C6C6548其中48对应的ASCII码是H，65对应的是e，后面的以此类推https://baike.baidu.com/item/ASCII/309296?fr=aladdin&fromid=19660475&fromtitle=ascii%E7%A0%81%E8%A1%A8因为是小端存储，所以你取的时候是从后向前你可以这样组合成其他字符来显示，但实际没必要这样写恩  说的非常好。如果用double类型存储   该怎么转换啊  double就比较麻烦了，因为浮点数的存储格式是分为符号、指数、尾数，就是说不同的位有不同的含义，你需要将组合了字符的数转换成二进制，计算对应的浮点数是多少，通常这个浮点数不一定是一个十进制下的有限小数，当然一个简单的办法是你写出你要的字符串，然后用一个double*指针指向它，然后解引该指针就知道它的值了，当然实际这没什么意义，程序是写给自己看的，电脑中全是数，只有人知道代表什么

引用 8 楼 mk112255的回复:[quote=引用 6 楼 wqte45 的回复:] [quote=引用 5 楼 mk112255的回复:][quote=引用 3 楼 zh19921107 的回复:] 可以逆向将china字符串数组强制转换成int数组，然后输出值。 你说的强制转换是否用int来打印china，还是其他[/quote] 用int打印china[/quote] 个人感觉数组大小与int类型大小相关，在我的电脑int是4位的，一个int类型值只能装4个字符，每4字母相对应的ASII码按顺序由高向低排序，就可以了[/quote] 说的简单，可我不会啊    你能告诉我  double类型的怎么计算吗  可以存8个字节  可是它跟int逆向顺序又不一样   用double该怎么换算啊

引用 9 楼 paschen的回复:1819043144 十六进制是 6C6C6548  其中48对应的ASCII码是H，65对应的是e，后面的以此类推  https://baike.baidu.com/item/ASCII/309296?fr=aladdin&fromid=19660475&fromtitle=ascii%E7%A0%81%E8%A1%A8  因为是小端存储，所以你取的时候是从后向前  你可以这样组合成其他字符来显示，但实际没必要这样写 恩  说的非常好。 如果用double类型存储   该怎么转换啊

引用 6 楼 wqte45 的回复:[quote=引用 5 楼 mk112255的回复:][quote=引用 3 楼 zh19921107 的回复:] 可以逆向将china字符串数组强制转换成int数组，然后输出值。 你说的强制转换是否用int来打印china，还是其他[/quote] 用int打印china[/quote] 个人感觉数组大小与int类型大小相关，在我的电脑int是4位的，一个int类型值只能装4个字符，每4字母相对应的ASII码按顺序由高向低排序，就可以了

#include <stdio.h> #include <string.h>   int main(void) {     char str[] = "china";      int a[2];      memcpy(a, str, strlen(str));      printf("%d, %d\n", a[0], a[1]);      printf("%s\n", (char *)a);      return 0; } 类似这样 对于int类型要申请多长的数组，要看字符串里有多少个字节，比如"china"是5个字节，所以需要申请int类型的长度是5/4 + 1

引用 5 楼 mk112255的回复:[quote=引用 3 楼 zh19921107 的回复:] 可以逆向将china字符串数组强制转换成int数组，然后输出值。 你说的强制转换是否用int来打印china，还是其他[/quote] 用int打印china

仅供参考：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("i=%d,bs=%s\n",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("i=%d,hs=%s\n",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     printf("hs=%s,i=%d\n",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("bs=%s,hs=%s\n",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     printf("bs=%s,i=%d\n",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("hs=%s,bs=%s\n",hs,bs); // ASC\GBK字符串转十六进制串     strcpy(s,"a汉");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,"%02X",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,"chs");     printf("s=%s,hs=%s\n",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,"61BABA");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,"%2x",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf("hs=%s,s=%s\n",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉

理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

引用 3 楼 zh19921107 的回复:可以逆向将china字符串数组强制转换成int数组，然后输出值。 你说的强制转换是否用int来打印china，还是其他

引用 3 楼 似缘非缘的回复:可以逆向将china字符串数组强制转换成int数组，然后输出值。 怎么逆向啊？？？？？

可以逆向将china字符串数组强制转换成int数组，然后输出值。


Question: c语言基础问题

引用 8 楼 fantasy408 的回复:[quote=引用 6 楼 cfjtaishan 的回复:] 越界访问的操作，应该是未定义行为。如果想知道a[5]应该是什么值，建议查看栈信息，可以获知数组偏移下一个整型数的值。 有可能是i的值，因为定义a[5]之后（分配空间），就定义了i，所以i在数组之后分配空间。 但是，对于越界操作还是不确定的，越界可能导致程序崩溃 非常感谢您，a[5]确实跟i是重合的[/quote] 这个重合不一定总是出现的，所以我们还是要做到对数组不做越界访问

引用 6 楼 cfjtaishan 的回复:越界访问的操作，应该是未定义行为。如果想知道a[5]应该是什么值，建议查看栈信息，可以获知数组偏移下一个整型数的值。 有可能是i的值，因为定义a[5]之后（分配空间），就定义了i，所以i在数组之后分配空间。 但是，对于越界操作还是不确定的，越界可能导致程序崩溃 非常感谢您，a[5]确实跟i是重合的

引用 5 楼 qq_38204686 的回复:a[5]  其实就是i  这样就可以解释了吧 它俩指向同一片内存 说明它们分配内存时应该是连续的 get了，非常感谢您！ 书上的内容还是得多练多想才能很好的理解

引用 10 楼 zhao4zhong1 的回复:其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。  判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 #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; }  谢谢指点! 只是...您给的例子太高级了，我这个水平还无法看懂

引用 9 楼 cfjtaishan 的回复:[quote=引用 8 楼 fantasy408 的回复:] [quote=引用 6 楼 cfjtaishan 的回复:] 越界访问的操作，应该是未定义行为。如果想知道a[5]应该是什么值，建议查看栈信息，可以获知数组偏移下一个整型数的值。 有可能是i的值，因为定义a[5]之后（分配空间），就定义了i，所以i在数组之后分配空间。 但是，对于越界操作还是不确定的，越界可能导致程序崩溃 非常感谢您，a[5]确实跟i是重合的[/quote] 这个重合不一定总是出现的，所以我们还是要做到对数组不做越界访问[/quote] 谢谢提醒

引用 3 楼 fantasy408的回复:[quote=引用 1 楼 qq_38204686 的回复:] [里面的数字]是偏移量  指向的内存里面肯定是有数据的  只是你没有分配而已 但它一直存在 您好，我在debug它时，观察a[5]，发现只要i为几，a[5]就为几，单步运行时，a[5]随i动态变化，不知是怎么回事...[/quote] 没准那个内存指向的就是i呢

引用 1 楼 qq_38204686 的回复:[里面的数字]是偏移量  指向的内存里面肯定是有数据的  只是你没有分配而已 但它一直存在 您好，我在debug它时，观察a[5]，发现只要i为几，a[5]就为几，单步运行时，a[5]随i动态变化，不知是怎么回事...

过来学习学习，膜拜各位大神


Question: cJson源码中，头文件里函数前面都加extern作用

声明，该函数可能在别的文件里面

如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用  http://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777431.html

对于函数，加与不加都是可以。但是对于全局变量而言是不行的

引用 6 楼 xiaotian_lishu 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 万一 #define cJSON "C" 呢？  额，看不太懂；跟宏定义有啥关系，没关系的吧[/quote] 我只是狡辩而已。

引用 5 楼 zhao4zhong1 的回复:万一 #define cJSON "C" 呢？  额，看不太懂；跟宏定义有啥关系，没关系的吧

万一 #define cJSON "C" 呢？

引用 1 楼 zhao4zhong1 的回复:extern 和 extern "C" 不是一回事。 我说的是类似下面这种： extern cJSON *cJSON_Parse(const char *value); 前面加extern是多余的吧cJson源码中 extern "c" {     代码块 } 是说代码块里面的内容按照c的方式进行编译的吧

extern 和 extern "C" 不是一回事。


Question: 这是一个容器，请老师们帮我看下这个奇怪的输出结果

因为st2中并没有133这个元素，所以结果就是*(st2.end())，结果是未定义的

引用 4 楼 paschen 的回复:for (int i = 0; i <= 10; i++)  改成  for (int i = 0; i < 10; i++)  否则越界了  应该是越界了

for(int i=0;i<=10;i++)             st2.insert(a[i]);  看这里，数组a的长度只有10，for循环里却要取11个值，越界了。

应该是一个随机值，建议查看一下该值对应的空间是否被初始化或者赋值

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


Question: SM2算法生成的私钥以及公钥位数过大（341位和65位）

有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成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的那个文件的最前面 //81-86行添加到你的main函数开头 //90-94行添加到你的main函数结束前 //在要写LOG的地方仿照第88行的写法写LOG到文件MyLog1.log中

不知道楼主最后有没有搞清楚。刚刚开始研究国密算法，请赐教。


Question: 求助大佬，不知道怎么回事双重循环内循环只在外循环第一次时进行

你是说这句吗？ for(H=a;i<=0;H=N+H) 这里有至少2个问题，1、这个循环的条件是i<=0，经过第一次运算后，条件不成立了，所以只有外层循环的第一次才执行；2、i是一个double类型，不能判断是否等于0，整数才能这么做。

第一次执行，i是未初始化的。i是一个随机值。所以第一次执行也是随机的


Question: c语言中如何有技巧地替换goto 语句

引用 3 楼 xiaowangzi666 的回复:我要的是二维数组中可以被赋给15个不同的值，楼上的代码只能赋给一个相同的值，一旦n得到了一个值，则跳出while循环，然后将相同的n赋给二维数组，循环15次。我想要的是输入15个不同的值，赋给15个不同的值 int count=0;       while (count < 15) //筛选输入的数据是否为数值数据  count为输入的浮点数个数     {         printf("Please enter 15 numbers:\n");           while (scanf("%lf", &n) != 1) {             printf("your enter is error,please enter again:");          }         p[i][j++] = n;   //赋值给二维数组         count++;         if (j > 4)         {             j = 0;      //列下标大于4，则重新开始赋值新的一行             i++;             if (i > 2)  //行下标大于2，则跳出循环                 break;         }     } 既然能看出不是15个不同的值，为什么就想不到把输入的while循环放到第二个while里面去呢？

int count=0;     printf("Please enter 15 numbers:\n"); //将15个浮点数输入到一个3行5列的二维数组中     while (scanf("%lf", &n) != 1) {         printf("your enter is error,please enter again:");     }      while (count < 15) //筛选输入的数据是否为数值数据  count为输入的浮点数个数     {         p[i][j++] = n;   //赋值给二维数组         count++;         if (j > 4)         {             j = 0;      //列下标大于4，则重新开始赋值新的一行             i++;             if (i > 2)  //行下标大于2，则跳出循环                 break;         }     }  先判断输入的n是否正确输入

明白了，感谢！

大神快来


Question: 很急 求哪错了

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

#include <stdio.h> #include <malloc.h>  typedef  char ElemType;  typedef struct LNode      //定义单链表节点类型 {     ElemType data;     struct LNode *next;  }LinkList;  void InitList(LinkList *&L) {     L = (LinkList *)malloc(sizeof(LinkList));     L->next = NULL;  }  void DestroyList(LinkList *&L) {     LinkList *p = L, *q = p->next;     while (q)     {         free(p);         p = q;         q = p->next;     }     free(p); }  int ListEmpty(LinkList *L) {     return(L->next == NULL); }  int ListLength(LinkList *L) {     LinkList *p = L; int i = 0;     while (p->next != NULL)     {         i++;         p = p->next;     }     return (i); }  void DispList(LinkList *L) {     LinkList  *p = L->next;     while (p != NULL)     {         printf("%c", p->data);         p = p->next;     }     printf("\n"); }  int GetElem(LinkList  *L, int i, ElemType  &e) {     int j = 0;     LinkList  *p = L;     while (j<i && p != NULL)     {         j++;         p = p->next;     }     if (p == NULL)         return 0;     else     {         e = p->data;         return 1;     } } int LocateElem(LinkList *L, ElemType  e) {     LinkList *p = L->next;     int n = 1;     while (p != NULL && p->data != e)     {         p = p->next;         n++;     }     if (p == NULL)         return (0);     else         return (n); } int ListInsert(LinkList  *&L, int i, ElemType  e) {     int j = 0;     LinkList *p = L, *s;     while (j <i - 1 && p != NULL)     {         j++;         p = p->next;     }     if (p == NULL)  //未找到第i-1个节点         return 0;     else        //找到第i-1个节点*p     {         s = (LinkList *)malloc(sizeof(LinkList));//创建新节点*s         s->data = e;         s->next = p->next; //将*s插入到*p之后         p->next = s;         return 1;     } } int ListDelete(LinkList  *&L, int i, ElemType &e) {     int j = 0;     LinkList *p = L, *q;      int j = 0;     LinkList *p = L, *q;     while (j < i - 1 && p != NULL)     {         j++;         p = p->next;     }     if (p == NULL)  //未找到第i-1个结点         return 0;     else     {         q = p->next;         if (q == NULL)             return 0;         e = q->data;         p->next = q->next;  //c从单链表中删除*q结点         free(q);         return 0;     }      return 0; }  int main(void) {     return 0; } ListDelete函数有问题，循环应该是多了一层。建议对比一下你的代码；

具体说明什么问题，我们看代码才有针对性


Question: 有关动态重定位的一点疑问

没调进来，只是建立了一个数据的映射。只不过是在虚拟内存中的的映射，因为一个进程的整个逻辑地址和操作系统管理的整个虚拟内存的逻辑地址是相互独立的。所以还需要进行第二次的重定位，推荐看《深入理解计算机系统》

建议搜Linux内存管理相关源代码分析博文。


Question: while（1）如何解决无限循环，输入数据组数未知情况下

设置一个判断标志，用于退出while(1)的循环。

设置一个输入值，判断当输入值为这个值时，跳槽死循环，结束程序运行

设置一个信号，做出什么动作时，退出循环。

按Ctrl+C或Ctrl+Break

#include<stdio.h>  int main() {     float a[7];     int i;     float money = 0.0;      while (1)     {         for (i = 0; i <7; i++)         {             scanf_s("%f", &a[i]);             if (a[i] == xxx)    /*xxx是指某个值*/                 return 0;         }         for (i = 0; i < 4; i++)         {             if (a[i] != 0.0)             {                 money+= a[4]/a[i];             }         }         money += 5 * a[5];         if (a[6]<= 3)         {             money += 7 - 2 * a[6];         }         printf("%.2f\n", money);     }     return 0; } 退出循环有多种方法，一种是使用goto语句，即输入某个值判断该值是否等于xxx，根据这个判断goto到while(1)外； 第二种，就是直接return退出程序或者退出函数； 注意，对于浮点数判断相等不能像整型数据判断相等，而是根据相差值的绝对值是否小于1e-6 比如判断浮点数a, b是否相等；  float a, b; if (fabs(a-b) < 1e-6)     printf("a == b\n"); else     printf("a != b\n");

在while中增加，结束条件，如： int a[9] = {0}; while(1) {     ...          for(int i=0; i<9; ++i)         scanf("%d", &a[0])              if(0==a[0])         break; // break while          ... }


Question: 数据结构中一元多项式乘法的代码出错

我知道其他代码，就是想请大神帮我看看我的代码问题

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


Question: 关于C的一个小问题

看看ASCII码就知道，空格符码值是32，同'a', 'b', 'c'一样属于可打印字符。它本身是一个字符，占用的字节数是1。 如果哪天C标准规定char型值是2个字节或4个字节，那空格符就占2个或4个字节，但它本身还是一个字符。

我觉得像这中情况，自己编程可以更快得到答案！sizeof

空格应该就是占1个字符吧，我也是新手

空格占 1个字符

空格多了！ 参考下面：#pragma comment(lib,"gdi32") #include <windows.h> #include <stdio.h>  int main() {     const DWORD uWidth = 18 + 17 * 256, uHeight = 18 + 17 * 128;      PBITMAPINFO pbmi = (PBITMAPINFO) LocalAlloc (LPTR, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2);     pbmi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);     pbmi->bmiHeader.biWidth = uWidth;     pbmi->bmiHeader.biHeight = uHeight;     pbmi->bmiHeader.biPlanes = 1;     pbmi->bmiHeader.biBitCount = 1;     pbmi->bmiHeader.biSizeImage = ((uWidth + 31) & ~31) / 8 * uHeight;     pbmi->bmiColors[0].rgbBlue = 0;     pbmi->bmiColors[0].rgbGreen = 0;     pbmi->bmiColors[0].rgbRed = 0;     pbmi->bmiColors[1].rgbBlue = 255;     pbmi->bmiColors[1].rgbGreen = 255;     pbmi->bmiColors[1].rgbRed = 255;      HDC hDC = CreateCompatibleDC (0);     void * pvBits;     HBITMAP hBitmap = CreateDIBSection (hDC, pbmi, 0, &pvBits, NULL, 0);     SelectObject (hDC, hBitmap);     HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "宋体"); //  HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, SHIFTJIS_CHARSET, 0, 0, 0, 0, "宋体");     SelectObject (hDC, hFont);     BitBlt (hDC, 0, 0, uWidth, uHeight, NULL, 0, 0, WHITENESS);      char c[4];     int i, j;     for (i = 128; i < 256; i++) {         sprintf (c, "%02X", i);         TextOut (hDC, 1, (i - 127) * 17 + 1, c, 2);     }     for (j = 0; j < 256; j++) {         sprintf (c, "%02X", j);         TextOut (hDC, (j + 1)* 17 + 1, 1, c, 2);     }     for (i = 128; i < 256; i++) {         for (j = 0; j < 256; j++) {             c[0] = (char) i;             c[1] = (char) j;             TextOut (hDC, (j + 1) * 17 + 1, (i - 127) * 17 + 1, c, 2);         }     }     for (i = 0; i < 130; i++) {         MoveToEx (hDC, 0, i * 17, NULL);         LineTo (hDC, uWidth, i * 17);     }     for (j = 0; j < 258; j++) {         MoveToEx (hDC, j * 17, 0, NULL);         LineTo (hDC, j * 17, uHeight);     }      BITMAPFILEHEADER bmfh;     bmfh.bfType = *(PWORD) "BM";     bmfh.bfReserved1 = 0;     bmfh.bfReserved2 = 0;     bmfh.bfOffBits = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2;     bmfh.bfSize = bmfh.bfOffBits + pbmi->bmiHeader.biSizeImage;      HANDLE hFile = CreateFile ("goal.bmp", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);     if (hFile != INVALID_HANDLE_VALUE) {         DWORD dwWritten;         WriteFile (hFile, &bmfh, sizeof (BITMAPFILEHEADER), &dwWritten, NULL);         WriteFile (hFile, pbmi, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2, &dwWritten, NULL);         WriteFile (hFile, pvBits, pbmi->bmiHeader.biSizeImage, &dwWritten, NULL);          CloseHandle (hFile);     }      DeleteObject (hFont);     DeleteObject (hBitmap);     DeleteDC (hDC);     LocalFree (pbmi);      return 0; }  生成的goal.bmp

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

#include <stdio.h> int main() {     printf("size of char: %ld byte(s)\n", sizeof(char));     const char space = ' ';     printf("size of one space: %ld byte(s)\n", sizeof(space));     int char_num_per_space = sizeof(space) / sizeof(char);     printf("amount of char in one space: %d\n", char_num_per_space); }  Output:

建议查阅ascii，空格占1个字符，但是tab,'\t'可能是4个空格或者8个空格（可以配置的），但是'\t'就是一个字符

空格占 1个字符

1个                                      。


Question: C语言计算数列1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + …的前n项之和。提交学校OJ一直显示wrong answer

仅供参考：// 按下列数级计算e的近视值，使e有小数点后1000位有效数字。 // e=1+1/1!+1/2!+1/3!+......1/n! #include <iostream> #include <string> using namespace std; inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string SUB_INT(string str1,string str2); string ADD_INT(string str1,string str2) {//高精度加法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         if (str2[0]=='-') {             sign=-1;             str=ADD_INT(str1.erase(0,1),str2.erase(0,1));         } else {             str=SUB_INT(str2,str1.erase(0,1));         }     } else {         if (str2[0]=='-') {             str=SUB_INT(str1,str2.erase(0,1));         } else { //把两个整数对齐，短整数前面加0补齐             string::size_type L1,L2;             int i;             L1=str1.size();             L2=str2.size();             if (L1<L2) {                 for (i=1;i<=L2-L1;i++) str1="0"+str1;             } else {                 for (i=1;i<=L1-L2;i++) str2="0"+str2;             }             int int1=0,int2=0; //int2 记录进位             for (i=str1.size()-1;i>=0;i--) {                 int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;                 int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;                 str=char(int1+'0')+str;             }             if (int2!=0) str=char(int2+'0')+str;         }     }     //运算后处理符号位     if ((sign==-1)&&(str[0]!='0')) str="-"+str;     return str; } string SUB_INT(string str1,string str2) {//高精度减法     int sign=1; //sign 为符号位     string str;     int i,j;     if (str2[0]=='-') {         str=ADD_INT(str1,str2.erase(0,1));     } else {         int res=compare(str1,str2);         if (res==0) return "0";         if (res<0) {             sign=-1;             string temp =str1;             str1=str2;             str2=temp;         }         string::size_type tempint;         tempint=str1.size()-str2.size();         for (i=str2.size()-1;i>=0;i--) {             if (str1[i+tempint]<str2[i]) {                 j=1;                 while (1) {//zhao4zhong1添加                     if (str1[i+tempint-j]=='0') {                         str1[i+tempint-j]='9';                         j++;                     } else {                         str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);                         break;                     }                 }                 str=char(str1[i+tempint]-str2[i]+':')+str;             } else {                 str=char(str1[i+tempint]-str2[i]+'0')+str;             }         }         for (i=tempint-1;i>=0;i--) str=str1[i]+str;     }     //去除结果中多余的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str ="-"+str;     return str; } string MUL_INT(string str1,string str2) {//高精度乘法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         sign*=-1;         str1 =str1.erase(0,1);     }     if (str2[0]=='-') {         sign*=-1;         str2 =str2.erase(0,1);     }     int i,j;     string::size_type L1,L2;     L1=str1.size();     L2=str2.size();     for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式         string tempstr;         int int1=0,int2=0,int3=int(str2[i])-'0';         if (int3!=0) {             for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;             for (j=L1-1;j>=0;j--) {                 int1=(int3*(int(str1[j])-'0')+int2)%10;                 int2=(int3*(int(str1[j])-'0')+int2)/10;                 tempstr=char(int1+'0')+tempstr;             }             if (int2!=0) tempstr=char(int2+'0')+tempstr;         }         str=ADD_INT(str,tempstr);     }     //去除结果中的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str="-"+str;     return str; } string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数     string quotient,residue; //定义商和余数     int sign1=1,sign2=1;     if (str2 == "0") {  //判断除数是否为0         quotient= "ERROR!";         residue = "ERROR!";         if (flag==1) return quotient;         else         return residue ;     }     if (str1=="0") { //判断被除数是否为0         quotient="0";         residue ="0";     }     if (str1[0]=='-') {         str1   = str1.erase(0,1);         sign1 *= -1;         sign2  = -1;     }     if (str2[0]=='-') {         str2   = str2.erase(0,1);         sign1 *= -1;     }     int res=compare(str1,str2);     if (res<0) {         quotient="0";         residue =str1;     } else if (res == 0) {         quotient="1";         residue ="0";     } else {         string::size_type L1,L2;         L1=str1.size();         L2=str2.size();         string tempstr;         tempstr.append(str1,0,L2-1);         for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式             tempstr=tempstr+str1[i];             tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加             if (tempstr.empty()) tempstr="0";//zhao4zhong1添加             for (char ch='9';ch>='0';ch--) { //试商                 string str;                 str=str+ch;                 if (compare(MUL_INT(str2,str),tempstr)<=0) {                     quotient=quotient+ch;                     tempstr =SUB_INT(tempstr,MUL_INT(str2,str));                     break;                 }             }         }         residue=tempstr;     }     //去除结果中的前导0     quotient.erase(0,quotient.find_first_not_of('0'));     if (quotient.empty()) quotient="0";     if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;     if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;     if (flag==1) return quotient;     else         return residue ; } string DIV_INT(string str1,string str2) {//高精度除法,返回商     return DIVIDE_INT(str1,str2,1); } string MOD_INT(string str1,string str2) {//高精度除法,返回余数     return DIVIDE_INT(str1,str2,0); } int main() {     string s1,s2,s3,s4;     int i;      s4="0";      s3="1";     for (i=0;i<1002;i++) s3+="0";      s1="1";     s2="1";      s4=ADD_INT(s4,DIV_INT(s3,s1));     s4=ADD_INT(s4,DIV_INT(s3,s1));      for (i=2;i<451;i++) {//因为450!是一个1001位数         s2=ADD_INT(s2,string("1"));         s1=MUL_INT(s1,s2);         s4=ADD_INT(s4,DIV_INT(s3,s1));     }      cout<<s4<<endl;      return(0); } //271828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516642742746639193200305992 //181741359662904357290033429526059563073813232862794349076323382988075319525101901157383418793070215408914993488416750924 //476146066808226480016847741185374234544243710753907774499206955170276183860626133138458300075204493382656029760673711320 //070932870912744374704723069697720931014169283681902551510865746377211125238978442505695369677078544996996794686445490598 //793163688923009879312773617821542499922957635148220826989519366803318252886939849646510582093923982948879332036250944311 //730123819706841614039701983767932068328237646480429531180232878250981945581530175671736133206981125099618188159304169035 //159888851934580727386673858942287922849989208680582574927961048419844436346324496848756023362482704197862320900216099023 //530436994184914631409343173814364054625315209618369088870701676839642437814059271456354906130310720851038375051011574770 //4171898610687396965521267154688957035035174

我觉得你的程序有点小问题，你的代码AC不了： 1、退出程序的条件设置有误 2、正负号改得太麻烦 这是我修改后的代码和运行结果 #include <stdio.h> int main() { long n; scanf("%ld",&n); while(n>1) { double i=1,s=0,d=1; for(i=1;i<=2*n-1;i+=2) {s+=d/i;d=-d;} printf("%.5f\n", s); scanf("%ld",&n); } return 0; }

#include<stdio.h>  int main() {     long n;     double s = 0.0;     int i;      while (scanf("%ld", &n) != -1)     {         s = 0.0;         for (i = 1; i <= 2 * n - 1; i += 2)         {             if (((i + 1) / 2) % 2 == 1)                 s += 1.0 / i;             else                 s -= 1.0 / i;         }         printf("%.5f\n", s);    /*加一个回车符*/     }     return 0; } 是不是缺少一个回车符呢

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

边界条件 输入输出格式 ……


Question: 新人求教数组

仅供参考：#include <stdio.h> #include <stdlib.h> #include <malloc.h> int **newarr2d(int rows,int cols) {     int **p,i;      p=(int **)malloc(rows*sizeof(int *));     if (NULL==p) exit(1);     for (i=0;i<rows;i++) {         p[i]=(int *)malloc(cols*sizeof(int));         if (NULL==p[i]) exit(1);     }     return p; } void deletearr2d(int **p,int rows) {     int i;      for (i=0;i<rows;i++) {         free(p[i]);     }     free(p); } int main() {     int **arr2d,i,j,r,c;      r=4;     c=5;     //在堆中开辟一个4×5的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      r=6;     c=3;     //在堆中开辟一个6×3的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      return 0; } //  0  1  2  3  4 //  5  6  7  8  9 // 10 11 12 13 14 // 15 16 17 18 19 //  0  1  2 //  3  4  5 //  6  7  8 //  9 10 11 // 12 13 14 // 15 16 17 //

建议是用指针，然后通过malloc，realloc等方式获取空间，并且空间可以伸缩，可增大可减少； 指针和数组在使用上有基本上相近，有一点数组名不能做左值。

#include <iostream>  int main(int argc, char *argv) {     char *arr1 = NULL;     char **arr2 = NULL;      int n = 100;      arr1 = new char[n]; // 动态申请一维数组      int x = 100, y = 99;      // 动态申请二维数组     arr2 = new char*[x];     for(int i=0; i<x; ++i)         arr2[i] = new char[y];      delete []arr1;      for(int i=0; i<x; ++i)         delete []arr2[i];     delete []arr2; }   动态数组用起来不是很方便，如果要存放动态的数据，还是使用容器（vector, list...）好。

百度 定义未知长度的数据 百度 动态数组 百度 柔性数组

百度 定义未知长度的数组 百度 动态数组 百度 柔性数组


Question: C语言CRC校验的问题

引用 1 楼 cfjtaishan 的回复:http://blog.csdn.net/u012993936/article/details/45339983 CRC校验不是新的技术了，为什么不去网上搜一搜，然后学习一下呢？！ 学了，就是不怎么会吸收啊，其他的知识点不会上网搜一下写一下代码一般也就会用了，但是CRC这个就是不怎么会，我都看了很多的资料了，就是学的不清不楚的，代码自己写的不清不楚，甚至拿网上的代码下来还是不怎么会用，有的时候回钻牛角尖，就像这次的任务一样，我怎么都算不出公司给我的那个答案

crc是一种算法类型，实际实现有很多种 公司给了你什么样的资料？应该有输入，有输出结果，还应该有实际算法吧 实际算法是什么样的？是代码形式还是仅仅文字、公式描述？ 你要把这些详细的资料都放出来给大家看看，甚至把你的代码也贴出来 越详细，别人才越容易看出来哪里有问题

仅供参考：/***** crc16.c *****/ #include <stdio.h>  #define CRC16_DNP   0x3D65u     // DNP, IEC 870, M-BUS, wM-BUS, ... #define CRC16_CCITT 0x1021u     // X.25, V.41, HDLC FCS, Bluetooth, ...  //Other polynoms not tested #define CRC16_IBM   0x8005u     // ModBus, USB, Bisync, CRC-16, CRC-16-ANSI, ... #define CRC16_T10_DIF   0x8BB7u     // SCSI DIF #define CRC16_DECT  0x0589u     // Cordeless Telephones #define CRC16_ARINC 0xA02Bu     // ACARS Aplications  #define POLYNOM     CRC16_DNP   // Define the used polynom from one of the aboves  // Calculates the new crc16 with the newByte. Variable crcValue is the actual or initial value (0). unsigned short crc16(unsigned short crcValue, unsigned char newByte) {     int i;      for (i = 0; i < 8; i++) {         if (((crcValue & 0x8000u) >> 8) ^ (newByte & 0x80u)){             crcValue = (crcValue << 1)  ^ POLYNOM;         } else {             crcValue = (crcValue << 1);         }         newByte <<= 1;     }     return crcValue; }  unsigned short exampleOfUseCRC16(unsigned char *Data, int len){      unsigned short crc;     int aux = 0;      crc = 0x0000u; //Initialization of crc to 0x0000 for DNP     //crc = 0xFFFFu; //Initialization of crc to 0xFFFF for CCITT      while (aux < len){         crc = crc16(crc,Data[aux]);         aux++;     }      return (~crc); //The crc value for DNP it is obtained by NOT operation      //return crc; //The crc value for CCITT }  int main() {     unsigned char d[10]={0,1,2,3,4,5,6,7,8,9};      printf("0x%04hX\n",exampleOfUseCRC16(d,10));//0x1078     return 0; }


Question: 新人求助

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

编译期已经告知了printf的问题； printf缺少一个%d,其他没问题； printf("max: %d\n", c);

贴代码，把问题说清啊，截图看不清

看不清          建议调试


Question: 守护进程调用程序，两个程序时间相差8个小时

_tzset Sets time environment variables.  void _tzset( void );  Routine Required Header Compatibility  _tzset <time.h> Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  None  Remarks  The _tzset function uses the current setting of the environment variable TZ to assign values to three global variables: _daylight, _timezone, and _tzname. These variables are used by the _ftime and localtime functions to make corrections from coordinated universal time (UTC) to local time, and by the time function to compute UTC from system time. Use the following syntax to set the TZ environment variable:  set TZ=tzn[+ | –]hh[:mm[:ss] ][dzn]  tzn  Three-letter time-zone name, such as PST. You must specify the correct offset from local time to UTC.  hh  Difference in hours between UTC and local time. Optionally signed.  mm  Minutes. Separated from hh by a colon (:).  ss  Seconds. Separated from mm by a colon (:).  dzn  Three-letter daylight-saving-time zone such as PDT. If daylight saving time is never in effect in the locality, set TZ without a value for dzn. The C run-time library assumes the United States’s rules for implementing the calculation of Daylight Saving Time (DST).   For example, to set the TZ environment variable to correspond to the current time zone in Germany, you can use one of the following statements:  set TZ=GST-1GDT set TZ=GST+1GDT  These strings use GST to indicate German standard time, assume that Germany is one hour ahead of UTC, and assume that daylight savings time is in effect.  If the TZ value is not set, _tzset attempts to use the time zone information specified by the operating system. Under Windows NT and Windows 95, this information is specified in the Control Panel’s Date/Time application. If _tzset cannot obtain this information, it uses PST8PDT by default, which signifies the Pacific time zone.   Based on the TZ environment variable value, the following values are assigned to the global variables _daylight, _timezone, and _tzname when _tzset is called:  Global Variable Description Default Value  _daylight Nonzero value if a daylight-saving-time zone is specified in TZ setting; otherwise, 0 1  _timezone Difference in seconds between UTC and local time. 28800 (28800 seconds equals 8 hours)  _tzname[0] String value of time-zone name from TZ environmental variable; empty if TZ has not been set PST  _tzname[1] String value of daylight-saving-time zone; empty if daylight-saving-time zone is omitted from TZ environmental variable PDT    The default values shown in the preceding table for _daylight and the _tzname array correspond to “PST8PDT.” If the DST zone is omitted from the TZ environmental variable, the value of _daylight is 0 and the _ftime, gmtime, and localtime functions return 0 for their DST flags.   Example  /* TZSET.C: This program first sets up the time zone by  * placing the variable named TZ=EST5 in the environment  * table. It then uses _tzset to set the global variables  * named _daylight, _timezone, and _tzname.  */  #include <time.h> #include <stdlib.h> #include <stdio.h>  void main( void ) {    if( _putenv( "TZ=EST5EDT" ) == -1 )    {       printf( "Unable to set TZ\n" );       exit( 1 );    }    else    {       _tzset();       printf( "_daylight = %d\n", _daylight );       printf( "_timezone = %ld\n", _timezone );       printf( "_tzname[0] = %s\n", _tzname[0] );    }    exit( 0 ); }   Output  _daylight = 1 _timezone = 18000 _tzname[0] = EST   Time Management Routines  See Also   asctime, _ftime, gmtime, localtime, time, _utime

localtime Converts a time value and corrects for the local time zone.  struct tm *localtime( const time_t *timer );  Routine Required Header Compatibility  localtime <time.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  localtime returns a pointer to the structure result. If the value in timer represents a date before midnight, January 1, 1970, localtime returns NULL. The fields of the structure type tm store the following values, each of which is an int:  tm_sec  Seconds after minute (0 – 59)  tm_min  Minutes after hour (0 – 59)  tm_hour  Hours after midnight (0 – 23)  tm_mday  Day of month (1 – 31)  tm_mon  Month (0 – 11; January = 0)  tm_year  Year (current year minus 1900)  tm_wday  Day of week (0 – 6; Sunday = 0)  tm_yday  Day of year (0 – 365; January 1 = 0)  tm_isdst  Positive value if daylight saving time is in effect; 0 if daylight saving time is not in effect; negative value if status of daylight saving time is unknown. The C run-time library assumes the United States’s rules for implementing the calculation of Daylight Saving Time (DST).   Parameter  timer  Pointer to stored time  Remarks  The localtime function converts a time stored as a time_t value and stores the result in a structure of type tm. The long value timer represents the seconds elapsed since midnight (00:00:00), January 1, 1970, coordinated universal time (UTC). This value is usually obtained from the time function.  gmtime, mktime, and localtime all use a single statically allocated tm structure for the conversion. Each call to one of these routines destroys the result of the previous call.  localtime corrects for the local time zone if the user first sets the global environment variable TZ. When TZ is set, three other environment variables (_timezone, _daylight, and _tzname) are automatically set as well. See _tzset for a description of these variables. TZ is a Microsoft extension and not part of the ANSI standard definition of localtime.  Note   The target environment should try to determine whether daylight saving time is in effect.  Example  /* LOCALTIM.C: This program uses time to get the current time   * and then uses localtime to convert this time to a structure   * representing the local time. The program converts the result   * from a 24-hour clock to a 12-hour clock and determines the   * proper extension (AM or PM).  */  #include <stdio.h> #include <string.h> #include <time.h>  void main( void ) {         struct tm *newtime;         char am_pm[] = "AM";         time_t long_time;          time( &long_time );                /* Get time as long integer. */         newtime = localtime( &long_time ); /* Convert to local time. */          if( newtime->tm_hour > 12 )        /* Set up extension. */                 strcpy( am_pm, "PM" );         if( newtime->tm_hour > 12 )        /* Convert from 24-hour */                 newtime->tm_hour -= 12;    /*   to 12-hour clock.  */         if( newtime->tm_hour == 0 )        /*Set hour to 12 if midnight. */                 newtime->tm_hour = 12;          printf( "%.19s %s\n", asctime( newtime ), am_pm ); }   Output  Tue Mar 23 11:28:17 AM   Time Management Routines  See Also   asctime, ctime, _ftime, gmtime, time, _tzset

引用 2 楼 user-2 的回复:东八区和gmt时间的区别。 但是同样获取时间的方式为什么两个程序得到的时间不一样呢

引用 1 楼 zhao4zhong1 的回复:也许只是因为北京的时区是东八区。 没看懂，现在就是系统时间就是正确的，程序就像上面说的那个状况

东八区和gmt时间的区别。

也许只是因为北京的时区是东八区。


Question: 新人求教

看看head->next; 是什么类型

你的定义应该是node和Node混用了，仔细找一下，或者贴上完整代码

程序没看出什么问题啊，“一直是错误的”具体什么情况？

注意源码里是不是将list定义成了node *list？

引用 2 楼 qq_38628693 的回复:[Error] cannot convert 'node*' to 'Node*' in assignment 报错node  Node?？？ 你看一下结构体定义。free(head)肯定在最后面的。


Question: C调用WIN32 API如何控制鼠标？

引用 2 楼 zhao4zhong1 的回复:http://www.autohotkey.com 参考autohotkey源代码中实现模拟鼠标的命令Click和MouseClick对应相关片断。

引用 7 楼 zhao4zhong1 的回复:[quote=引用 6 楼 SXJIAKE 的回复:] 左键按下和弹起同时传？ MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP 而且两句代码还一样？ 改为 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 ); mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 ); mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 ); mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 ); 再试试？[/quote] 试过了，结果一样。

引用 1 楼 zhao4zhong1 的回复:改用SendInput再试试？ 谢谢指点，但应该不是这个问题。 这个问题只在WIN7下才出现，WIN XP下正常，另外，解释执行也正常，只在编译后执行才会这样。实在是想不明白。

引用 3 楼 user-3 的回复:试下：https://msdn.microsoft.com/en-us/library/ms646310(v=vs.85).aspx 谢谢指点，但应该不是这个问题。 这个问题只在WIN7下才出现，WIN XP下正常，另外，解释执行也正常，只在编译后执行才会这样。实在是想不明白。

引用 6 楼 SXJIAKE 的回复:左键按下和弹起同时传？ MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP 而且两句代码还一样？ 改为 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 ); mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 ); mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 ); mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 ); 再试试？

改用SendInput再试试？


Question: 为什么说使用命令行参数的程序依赖于用户的内存如何正确地使用它们？

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


Question: C语言递归函数问题求解~

只改一处就好。  #include <stdio.h> #include <iostream> using namespace std;  struct ll { 	int *a; 	int *b; 	int n; };  void tt(ll *&a, int *n) // 直接传*是不行的，里面重新分配后指针地址已经变化了，变化后的地址无法传回去，所以传指针的引用 { 	int i; 	a = (ll *)realloc(a, (*n + 1) * sizeof(ll)); 	a[*n].n = *n + 1; 	*n = *n + 1; 	for (i = 0;i < *n;i++) 	{ 		printf("%d\n", a[i].n); 	} 	printf("I'm here %d\n", *n); 	if (*n < 20) 	{ 		tt(a, n); 	} }  void  main() { 	int i; 	ll *pp; 	int n = 0; 	pp = new ll[n]; 	tt(pp, &n); 	printf("----%d\n", n); 	for (i = 0;i < n;i++) 	{ 		printf("%d\n", pp[i].n); 	} }

问题在于递归函数tt中，第一个参数不应该是个已分配的指针地址，因为这个地址可能随着每次的realloc变化，所以这里传递的应该是指针变量的地址，即传递pp的地址，函数修改如下：   void tt(ll **a,int *n) { 	int i; 	*a=(ll *) realloc(*a,(*n+1)*sizeof(ll)); 	(*a)[*n].n=*n+1; 	*n=*n+1; 	for(i=0;i<*n;i++) 	{ 		printf("%d\n",(*a)[i].n); 	} 	printf("I'm here %d\n",*n); 	if(*n<20) 	{ 		tt(a,n); 	} }   main函数中的调用也应该改为   tt(&pp,&n);

感谢各位大神的指导，谢谢！

因为tt函数里修改了pp的地址值，所以需要每次更新a（参数）都要修改pp的地址值，所以应该传&pp；或者tt函数里a使用引用void tt(ll *&a, int *n);引用&是C++的一种用法，C语言建议使用二重指针，这样每次都能把上次realloc申请的新地址拿到；  #include <cstdio> #include <cstdlib> #include <iostream>  struct ll{     int *a;     int *b;     int n; };  void tt(ll **a,int *n) {     int i;     *a = (ll *) realloc(*a,(*n+1)*sizeof(ll));     (*a)[*n].n = *n+1;     *n = *n+1;     for(i = 0;i < *n;i++)         printf("%d\n", (*a)[i].n);      printf("I'm here %d\n",*n);     if(*n < 20)     {         tt(a, n);     } }  int  main() {     int i;     ll *pp;     int n = 0;     pp = new ll[n];     tt(&pp, &n);     printf("----%d\n", n);     for(i=0;i<n;i++)     {         printf("%d\n",pp[i].n);     }      return 0; } 改程序里只有new是属于C++的关键字，没有用到cin/cout，所以不用using namespace std;命名空间


Question: 想将D盘文件file1中的字符复制到file2中，程序一个劲儿的写值，哪里有错？大神们帮帮忙~

厉害，学习了~~

# include <stdio.h> # include <stdlib.h>  int main(void) {     FILE *fp1, *fp2;     char ch1, ch2, ch3;      if ((fp1 = fopen("D:\\file1.dat","w+")) == NULL)     {         printf("您要找的文件file1.dat不存在！");         exit(0);     }     printf("请输入file1.dat中的字符：");     ch1 = getchar();     while (ch1 != '\n')     {         fputc(ch1, fp1);         putchar(ch1);         ch1 = getchar();     }     printf("\n");      if ((fp2 = fopen("E:\\file2.bat","w")) == NULL)     {         printf("您要找的文件file2.dat不存在");         exit(0);     }     printf("请输入file2.dat中的字符：");     ch2 = getchar();     while (ch2 != '\n')     {         fputc(ch2, fp2);         putchar(ch2);         ch2 = getchar();     }      //rewind(fp1);    /* 修改文件指针位置；*/     fseek(fp1, 0, SEEK_SET);     while (!feof(fp1))     {         ch3 = fgetc(fp1);         fputc(ch3, fp2);         putchar(ch3);     }     putchar(10);     fclose(fp1);     fclose(fp2);      return 0; }  文件1需要修改其文件指针的位置，因为开始对fp1进行写时，文件指针已经指向了文件末尾，所以若想读取文件1的内容，需要让fp1指向文件开头；因此需要fseek或者rewind都可以更改文件的位置

fp1写入，关闭，再读取


Question: 求哪里出错了

#include<stdio.h> #include <stdlib.h>  #define N 30 #define C_LEN_ID 10  typedef struct _ST_STUDENT {     char szId[C_LEN_ID];     float fScore;     struct _ST_STUDENT *pNext; }ST_STUDENT, *P_ST_STUDENT;  int main() {     float fAvg;     int i,j,n;      P_ST_STUDENT pllHead = NULL;     P_ST_STUDENT pllCur = NULL;     P_ST_STUDENT pstStu;      printf("请输入有多少个学生信息:");     scanf("%d",&n);     pllHead = (ST_STUDENT*)malloc(sizeof(ST_STUDENT));     pllHead->pNext = NULL;     pllCur = pllHead;     fAvg = 0;     for(i = 0;i < n;i++)     {         pstStu = (P_ST_STUDENT)malloc(sizeof(ST_STUDENT));         pllCur->pNext = pstStu;         pllCur = pllCur->pNext;         pllCur->pNext = NULL;         printf("请输入第%d 位学生的学号：",i+1);         scanf("%s", pllCur->szId);         printf("请输入课程成绩：" );         scanf("%f", &(pllCur->fScore));         fAvg += pllCur->fScore;     }      pllCur = pllHead->pNext;     while (pllCur) {         printf("ID: %s, Score: %0.1lf\n", pllCur->szId, pllCur->fScore);         pllCur = pllCur->pNext;     }     fAvg /= n;     printf("该班平均成绩为%.1f\n", fAvg);      return 0; } 暂未发现这部分代码有问题，或者说问题可能不出在这部分代码里。 也可能是你的输入格式有问题。

请说明错误现象, 另外注意内存管理


Question: OJ ACM的题目给定一个日期，输出这个日期是该年的第几天。

while(scanf("%d/%d/%d",&years,&months,&days)) 你这句是打算无限循环吗

#include<stdio.h>  int main() {     int years,months,days,i;     int sum=0,a[12]={31,28,31,30,31,30,31,31,30,31,30,31};     while(3 == scanf("%d/%d/%d", &years,&months,&days))     {         if (months > 12 || days > 31)             continue;         sum = 0;         if((years%4==0 && years%100!=0) || years%400) {             if (months > 2)                 sum = 1; /*1: leap year */         }         for(i=0;i<months-1;i++)             sum += a[i];         sum = sum + days;         printf("%d\n",sum);     }     return 0; } 年月日的范围需要做一下判断； 代码冗余太多，可以做进一步简化，详见上面修改的部分。 如果还有问题，可以进一步对年月日的范围做检测

超时            。


Question: GPT硬盘修改磁盘GUID后系统无法加载

系统只能放在4个主分区中的某一个中。


Question: 内存有没有释放

你这个涉及操作系统底层管理虚拟内存时使用的“实际使用时再实际申请的延迟申请策略”。  int main() {         sleep(15);         int i =0;         for(; i< 10; i++)         {                 void * buf = (void *) malloc(20*1024*1024);                 printf("== mal == %p\n", buf);                 memset(buf,1,20*1024*1024);//加上这句再试试                 sleep(3);                 printf("** fre ** %p\n", buf);                 free(buf);                 sleep(3);         }         getchar();  }

谢谢 @paschen and @赵4老师 , 查阅了一下glibc相关以及OS内存管理策略，确实是这样的。在调用 free时，操作系统不会马上把内存回收，而是放在一个free block list里，下次再malloc时，如果命中等大小的free block， 则直接反给malloc，如果命中值稍大点也可以切出用户想要的大小然后返回，这样一是可以提高性能，二是为了避免有太多的内存碎片。 参考： https://www.zhihu.com/question/29161424 http://blog.csdn.net/hylongsuny/article/details/7742995

系统资源也是会占用内存，此外系统未必会在你释放内存后立即回收掉所有内存

怀疑libc造成的，写了个小程序测试free，如下： int main() {         sleep(15);         int i =0;         for(; i< 10; i++)         {                 void * buf = (void *) malloc(20*1024*1024);                 printf("== mal == %p\n", buf);                 sleep(3);                 printf("** fre ** %p\n", buf);                 free(buf);                 sleep(3);         }         getchar();  } 观察top下内存状况：发现一直没什么变化，最后循环全部执行完后观察结果，也没有20M释放：  VIRT    RES    SHR                                                                                24828   1364   1276   why???

你malloc申请的空间大吗?

引用 4 楼 zhao4zhong1 的回复:也许人家库使用了内存池管理中的延迟释放策略。 恩，这个有查，像glib库就会有这种情况，不过我把glib库全部注释掉了，另外也使用了这个帖子中用到的环境变量： http://bbs.chinaunix.net/archiver/tid-4164035.html but, 还是不行。另外，我在是系统函数free和malloc(还有realloc, zalloc)下加的日志，完全匹配。。。 挺奇怪的，top以及htop都显示内存一点不变，是不是linux底层tcp socket释放需要一定时间 ？

也许人家库使用了内存池管理中的延迟释放策略。

搜“内存延迟释放”？

引用 1 楼 cfjtaishan 的回复:你malloc申请的空间大吗?  最大的一块是5152，是在每次发消息时申请，不过我将malloc以及free 地址打印出来了，每次都有释放。


Question: 包含指针的结构数组，初始化问题

引用 4 楼 weixin_40525837 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] #include <stdio.h>  struct entry {     int value;     struct entry *next; };   int main(void) {     struct entry list[3] = { {0,&list[1]},{1,&list[2]},{3,0} };      struct entry *p = &list[0];      while (p) {         printf("value = %d\n", p->value);         p = p->next;     }     return  0; } 值已经被赋值上了。 上面的代码可以打印出0, 1, 3   这个可以啊！ 关键是为啥通过list[0].value的形式，打印不出来呢~ 能不能具体解析一下这里面的工作原理~   [/quote] #include <stdio.h>  struct entry {     int value;     struct entry *next; };   int main(void) {     struct entry list[3] = { {0,&list[1]},{1,&list[2]},{3,0} };      struct entry *p = &list[0];      while (p) {         printf("value = %d\n", p->value);         p = p->next;     }      int i;     for (i = 0; i < 3; i++)         printf("value = %d\n", list[i].value);     return  0; } 这样也是可以打出来0, 1, 3呢

引用 3 楼 cfjtaishan 的回复:#include <stdio.h>  struct entry {     int value;     struct entry *next; };   int main(void) {     struct entry list[3] = { {0,&list[1]},{1,&list[2]},{3,0} };      struct entry *p = &list[0];      while (p) {         printf("value = %d\n", p->value);         p = p->next;     }     return  0; } 值已经被赋值上了。 上面的代码可以打印出0, 1, 3   这个可以啊！ 关键是为啥通过list[0].value的形式，打印不出来呢~ 能不能具体解析一下这里面的工作原理~

你这样初始化，就是想一口气吃成个胖子，请将数组的各个元素分开来，一个一个赋值

#include <stdio.h> struct entry {     int value;     struct entry *next; }; int main() {     struct entry list[3] = { {0,&list[1]},{1,&list[2]},{3,0} };      printf("list[0].next:%p,&list[1]:%p\n",list[0].next,&list[1]);     printf("list[1].next:%p,&list[2]:%p\n",list[1].next,&list[2]);     return 0; } //list[0].next:1043FF38,&list[1]:1043FF38 //list[1].next:1043FF40,&list[2]:1043FF40 //  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！


Question: 在eclipse CDT 上编写的C程序编译成功但不能运行是怎么回事？

将 项目、属性、C/C++、附加包含目录：附加头文件所在目录 分号间隔多项 中实际不存在的目录删掉。

虽然有那个警告但是在hello.c上是可以运行的


Question: 单链表问题

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

#include<stdio.h> #include<stdlib.h> //#include<malloc.h> #include<string.h>  typedef struct {     int num;     char name[10];     int score; }student;  typedef struct l_node {     student data;     struct l_node* next; }l_node;  l_node* init(); void outputl_node();  l_node *l = NULL; int main() {     init();     outputl_node(); }  l_node* init() {     l_node* p;     int n;      l = (l_node*)malloc(sizeof(l_node));     l->next = NULL;     printf("输入初始化的人数：\n");     scanf("%d", &n);     for(int i=0;i<n;i++)     {         p = (l_node*)malloc(sizeof(l_node));         printf("请输入第%d位学号:\n", i+1);         scanf("%d",&p->data.num);         printf("请输入第%d位姓名\n", i+1);         scanf("%s", p->data.name);         printf("请输入第%d位分数\n", i+1);         scanf("%d", &p->data.score);         p->next = l->next;         l->next = p;     }     return l; }  void outputl_node() {     l_node* p;     p = l->next;     while (p)     {         printf("学号：");         printf("%d\t",p->data.num);         printf("姓名:");         printf("%s\t",p->data.name);         printf("分数：");         printf("%d\n",p->data.score);         p = p->next;     } }  代码有多处语法错误，如果楼主的编译器不能提示这些错误，建议使用更高版本的编译器。 该单链表是带哨兵的链表，链表建立是采用头插法（相对的是尾插法），即每次新创建的节点都插入链表头前（哨兵后）

因为l这个指针是属于main函数的，在init函数中不可见。请将它改为全局变量，也就是在main函数声明这个l. 另外，init函数请不要在main函数里面声明

引用 2 楼 das白的回复:全局变量 局部变量  函数传递参数 分清全局变量和局部变量 你的l是局部变量 只能在一定范围内用 可以通过函数参数传递 也可以设成全局变量

全局变量 局部变量  函数传递参数

新手，不太懂


Question: C语言如何实现移动重定位表

《Windows PE权威指南》


Question: C语言九九乘法表

你可以试试 这个方法看看是不是正确

#include<stdio.h> int main() { 	int a, b; 	int  n; 	while(scanf("%d",&n)!= EOF) 	{ 		for (a = 1; a <= n; a++) 		{ 			for (b = 1; b <= a; b++) 			{ 				printf("%d*%d=%d", a, b, a*b); 				if (a != b) printf("\t"); 				if (a == b) printf("\n"); 			} 		} 	} 	return 0; }

#include<stdio.h>  int main() {     int a, b;      for (a = 1; a <= 9; a++)     {         for (b = 1; b <= a; b++)         {             printf("%d * %d = %d", b, a, a*b);             printf("\t");         }             printf("\n");     }     return 0; } 不需要加判断，另外交换输出printf中，a, b的输出顺序；   #include<stdio.h>  /* int main() {     int a, b;      for (a = 1; a <= 9; a++)     {         for (b = 1; b <= a; b++)         {             printf("%d * %d = %d", a, b, a*b);             printf("\t");         }             printf("\n");     }     return 0; } */  int main(void) {     int i, j;      for (i = 1; i <= 9; i++) {         for (j = 1; j <= i; j++) {             printf("%d * %d = %d", j, i, i * j);             putchar('\t');         }         printf("\n");     }     return 0; }

空格有要求吗            。

仅供参考：#include <stdio.h> #include <string.h> int main() {     int a,b;     char s[73],t[10];      for (a=9;a>0;a--) {         s[0]=0;         for (b=a;b<10;b++) {             sprintf(t," %dx%d=%d",a,b,a*b);             if (a==2 && b==5) strcat(s," ");             strcat(s,t);             if (a==1 && b>=4) strcat(s," ");         }         printf("%60s\n",s);     }     return 0; } //                                                      9x9=81 //                                               8x8=64 8x9=72 //                                        7x7=49 7x8=56 7x9=63 //                                 6x6=36 6x7=42 6x8=48 6x9=54 //                          5x5=25 5x6=30 5x7=35 5x8=40 5x9=45 //                   4x4=16 4x5=20 4x6=24 4x7=28 4x8=32 4x9=36 //             3x3=9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27 //       2x2=4 2x3=6 2x4=8  2x5=10 2x6=12 2x7=14 2x8=16 2x9=18 // 1x1=1 1x2=2 1x3=3 1x4=4  1x5=5  1x6=6  1x7=7  1x8=8  1x9=9

严格对照一下标准答案


Question: 求证素数

引用 4 楼 susususu2 的回复:谢谢，老赵有两下子！ 虽然我听着很受用；但估计仍然解决不了楼主的问题。

谢谢，老赵有两下子！

Finding prime numbers - Kenneth Haugland  Different schemas for finding prime numbers explained with code http://www.codeproject.com/Articles/429694/Finding-prime-numbers

老赵，介绍一些检验素数的办法，位数在万位以上，蟹蟹。

数论


Question: C 数据结构与算法  后缀表达式计算

百度搜相关关键字。


Question: 结构体数组的插入与删除，插入部分结果总出错，请各位大神帮忙看一下

stu[a].num=10113;     strcpy(stu[a].name ,"Chu");     stu[a].score =98; 直接修改了数据，怎么会不重复

#include<stdio.h> #include<string.h>  struct Student {     int num;     char name[20];     int score; };  #define MAX_STU_NUM 20  int get_cur_stu_num(struct Student *pstu); void print_stu_info(struct Student *pstu, int nums);  int main() {     struct Student stu[MAX_STU_NUM] = {         {10101, "Zhao", 89},         {10102, "Qian", 90},         {10103,"Sun",93},         {10104,"Li",94},         {10105,"Zhou",95},         {10106,"Wu",96},         {10107,"Zheng",97},         {10108,"Wang",98},         {10109,"Feng",99},         {10110,"Cheng",100}     };     struct Student tmp;     int i, j, a, x, cur_nums;      cur_nums = get_cur_stu_num(stu);     print_stu_info(stu, cur_nums);      printf("   ---要插入的数据下标---\n");      scanf("%d",&a);     if (a > MAX_STU_NUM - 1) { /*check array's index*/         printf("Overflow!\n");         return 0;     }     tmp.num = 10113;     strcpy(tmp.name ,"Chu");     tmp.score  = 98;      if (a > cur_nums) {         stu[cur_nums] = tmp;     }     else {         for (j = cur_nums + 1; j > a; j--)             stu[j] = stu[j-1];         stu[a] = tmp;     }     cur_nums++;      print_stu_info(stu, cur_nums);      printf("   ---要删除的数据下标---\n");     scanf("%d",&x);     if (x < cur_nums) {         for (i = x; i < cur_nums; i++)             stu[i] = stu[i+1];     }     cur_nums--;     print_stu_info(stu, cur_nums);       return 0; }  int get_cur_stu_num(struct Student *pstu) {     int i;      for (i = 0; i < MAX_STU_NUM; i++)         if (pstu[i].num <= 0)             break;      return i; }  void print_stu_info(struct Student *pstu, int nums) {     int i;      printf("   学号    姓名   成绩\n");     for(i=0;i<nums;i++)         printf("%7d%8s%6d\n", pstu[i].num, pstu[i].name, pstu[i].score); } 上面的代码是根据我的想法改的。可以参考一下； 如果直接将插入的数据放到数组里，肯定会将原来的数据覆盖，所以先要放到一个临时的变量里，然后在插入数组里。

#include<stdio.h> #include<string.h> struct Student { int num; char name[20]; int score;  }; int main() { struct Student stu[20]={{10101,"Zhao",89},{10102,"Qian" ,90},{10103,"Sun",93},{10104,"Li",94}, {10105,"Zhou",95},{10106,"Wu",96},{10107,"Zheng",97},{10108,"Wang",98},{10109,"Feng",99},{10110,"Cheng",100}}; int i; printf("   学号    姓名   成绩\n"); for(i=0;i<10;i++) printf("%7d%8s%6d\n",stu[i].num,stu[i].name,stu[i].score);  printf("   ---要插入的数据下标---\n"); int a,j;      scanf("%d",&a);     for(i=0; i<11; i++)  //不知道为啥结果总是被覆盖         {               if(i==a)               {                   for( j=11; j>i; j--)                   {                       stu[j]=stu[j-1];                   }                    stu[a].num=10113;     strcpy(stu[a].name ,"Chu");     stu[a].score =98;             }           }   printf("   学号    姓名   成绩\n");     for(i=0;i<11;i++) printf("%7d%8s%6d\n",stu[i].num,stu[i].name,stu[i].score);  printf("   ---要删除的数据下标---\n");     int x;     scanf("%d",&x);     for(i=x;i<10;i++)   stu[i]=stu[i+1]; printf("   学号    姓名   成绩\n"); for(i=0;i<9;i++) printf("%7d%8s%6d\n",stu[i].num,stu[i].name,stu[i].score);   return 0; }


Question: C语言有些问题求解

之所以差别很大，主要是浮点数和整型数在内存里的存放格式是不一样的。对于整型数，我们比较好理解，但是对于浮点数，因为它分为整型和小数部分，所以在内存里需要区分，自然存放的格式不一样了。 建议查一下浮点数在内存里的存放格式，可以找到这个问题的答案。

引用 4 楼 susususu2 的回复:printf语句不属于c语言，书上是这样写的。 这话不要这么说，需要标明是那本书里的文字描述，不然不能证明这句话的正确性。 用C语言的朋友，经常使用这个函数，怎么能说它不属于C语言呢?

printf语句不属于c语言，书上是这样写的。

这个代码实际是没有强制转换，只是printf的入参不一样，导致结果并不是想要的

不会强制转换的。printf的第一个参数一定是字符指针，其他参数类型编译器不知道，所以不知道怎么转换，于是就不转换了

浮点数格式 http://bbs.csdn.net/topics/390676437


Question: C 数据结构与算法 后缀表达式求值

百度搜相关关键字。


Question: memset(pt->data, 0, 100) 这句是不是有问题？

#define HEAP_DEFAULT_SIZE 100 #define HEAP_EXTENDED_SIZE 200  // 用这种写法，根本不需要一个指针指来指去的 typedef struct t_type { 	int code; 	unsigned char data[]; } mytype;  int main(void) { 	mytype *pt = (mytype *)malloc(sizeof(mytype) + HEAP_DEFAULT_SIZE * sizeof(unsigned char)); 	if (pt != NULL) 	{ 		pt->code = 2; 		memset(pt->data, 0, HEAP_DEFAULT_SIZE); 		*pt->data = 'a'; 		mytype *pn = (mytype *)realloc(pt, sizeof(mytype) + HEAP_EXTENDED_SIZE * sizeof(unsigned char)); 		if (pn != NULL) 		{ 			pt = pn; 			memset(pt->data, 0, HEAP_EXTENDED_SIZE); 			*pt->data = 'b'; 		} 		free(pt); 	} 	return 0; }

22楼的规范

21楼正解！

引用 22 楼 zhoujielunzhimi 的回复:mytype mt; mt.code = 100; mt.data = (unsingned char*) malloc(sizeof(unsigned char) * 100); memset(mt.data, 0, 100); mytype mt; mt.code = 100; mt.data = (unsingned char*) malloc(sizeof(unsigned char) * 100); memset(mt.data, 0, sizeof(unsigned char) * 100);

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <string.h>  typedef struct t_type {     int code;     unsigned char *data; } mytype;  int main() {     mytype *pt = (mytype *)malloc(sizeof(mytype) + 100);     pt->code = 2;     pt->data = (unsigned char *)pt + sizeof(mytype);     memset(pt->data, 0, 100);     *(pt->data) = 'a';     unsigned char *tmp = pt->data;     unsigned char *pn = (unsigned char *)malloc(200);     if (pn == 0) {         printf("malloc is error!");         return -1;     }     memset(pn, 0, 200);     pt->data = pn;     free(pn);     free(pt);     return 0; }

free(tmp); 应改为  free(pn);

pt->data = (unsigned char *)(pt + sizeof(mytype)); 应改为  pt->data = (unsigned char *)pt + sizeof(mytype);

引用 16 楼 Saleayas 的回复:free(tmp);这句不正确。 这一句为什么不正确？

引用 16 楼 Saleayas 的回复:free(tmp);这句不正确。 执行不到这一句就崩了。

free(tmp);这句不正确。

引用 14 楼 destory27 的回复:[quote=引用 13 楼 1FCSOFT 的回复:] [quote=引用 12 楼 destory27 的回复:]   memset(&p->data, 0, 1); 不明白什么意思[/quote]  void *memset(void *s,int c,size_t n)        第一个参数是指针类型，，所以传地址[/quote] pt,pt->data本身都是指针地址

引用 10 楼 kugeniha 的回复:sizeof(mytype)      建议输出一下 输出结果：8（int 4+指针4）

引用 13 楼 1FCSOFT 的回复:[quote=引用 12 楼 destory27 的回复:]   memset(&p->data, 0, 1); 不明白什么意思[/quote]  void *memset(void *s,int c,size_t n)        第一个参数是指针类型，，所以传地址

引用 12 楼 destory27 的回复:memset(&p->data, 0, 1); 不明白什么意思

memset(&p->data, 0, 1);

sizeof(mytype)      建议输出一下

再修改一次： typedef struct t_type{     int code;     unsigned char *data; } mytype;  int main() {     int dataSize = 100;//100就不行，换成665就可以，为什么？     int objNum = 8;     mytype *pt = (mytype *)malloc(sizeof(mytype) * objNum + dataSize);     pt->code = 2;     pt->data = (unsigned char *)(pt + objNum); //指向data空间首地址     printf("%d:%d", pt, pt->data); //显示data指针相对pt移动了64个字节，这个合理     memset(pt->data, 0, dataSize);//给data初始化     *(pt->data) = 'a';     unsigned char *tmp = pt->data;     unsigned char *pn = (unsigned char *)malloc(200);     if (pn == 0)     {         printf("malloc is error!");         return -1;     }     memset(pn, 0, 200);     pt->data = pn;     free(tmp);     free(pt);     return 0; }

引用 7 楼 kugeniha 的回复:挪8个结构体后，剩下的空间已经没有100那么大了，所有后面的memset 100有问题 改成 memset(pt->data, 0, 1);还是出错

(unsigned char *)(pt + sizeof(mytype)) 可能已经越界了  对指针pt加一个数，移动的是这个数乘以这个类型的大小


Question: 环形列表问题

这样改：  #include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef struct circle { 	int people; 	int count = 0; 	struct circle *next; }one; //创建链表环 one *create(int n) { 	one *head, *p1, *p2, t; 	head = NULL; 	printf("input the numbers of the people:\n"); 	for (int i = 0;i < n;i++) 	{ 		p1 = (one *)malloc(sizeof(one));  		if (!p1) { 			exit(1); //开辟空间，如果分配失败退出 		}  		scanf("%d", &p1->people); 		t.count++;		//这里计数没有用，除非将t声明成全局变量，或者作为引用参数传进来 		if (head == NULL) { 			head = p1; 		} else { 			p2->next = p1; 		}  		p2 = p1; 	} 	p2->next = head; 	return head; } int main() { 	one *head, *p, *del, t; 	int n, i = 2, dis; 	printf("please input the people numbers: \n"); 	scanf("%d", &n); 	head = create(n); 	p = head; 	t.count = n;	// 要计数的 	printf("please input the distance you want to selete:\n"); 	scanf("%d", &dis); 	while (1)   //无限循坏直到只剩一人break退出 	{ 		if (t.count == 2 && i == dis)   //只剩两人时  		{ 			printf("the no.%d is out \n", p->next->people); 			del = p->next; 			p->next = NULL; 			free(del); 			t.count--; 			printf("the no.%d is the last person int the end:\n", p->people); 			break; 		}    //  if() 		if (i == dis)   //遇到等距数dis则删除结点，继续循环  		{ 			printf("the no.%d is out \n", p->next->people); 			del = p->next; 			p->next = del->next; 			free(del);  //删除结点 			t.count--;   //相应人数减一  			i = 1;       //重新计数  		}  // if( ) 		p = p->next; 		i++; 	}  // while()  	return 0; }

#include<stdio.h> #include<stdlib.h> #include<string.h>  struct node {     int num;     char name[20];     struct node *next; };  struct node *create_singly_link(int num) {     struct node*head, *prev, *cur;     int i;      head = NULL;     for(i = 0; i < num; i++) {         cur = (struct node *)malloc(sizeof(struct node));         if (!cur) {             printf("Malloc error!");             return NULL;         }         cur->next = NULL;         cur->num = i+1;         snprintf(cur->name, 20-1, "%c", 'A'+i);         if (!head) {             head = cur;             prev = cur;         } else {             prev->next = cur;             prev = prev->next;         }     }     prev->next = head;     return head; }  static void test_print(struct node *phead) {     struct node *pcur = phead->next;      printf("num = %d\t name = %s\n", phead->num, phead->name);     while (pcur != phead) {         printf("num = %2d\t name = %s\n", pcur->num, pcur->name);         pcur = pcur->next;     } }  int output( struct node *head, int start, int step, int total) {     struct node *p, *q;     int count = 0;     int num = 0, i;      q = head;      for(i = 0; i < start; i++)         q = q->next;      while(count < total-1) {         p = q->next;         num++;         if(!(num % step)) {             q->next = p->next;             printf("%s\n", p->name);             free(p);             count++;         } else {             q = p;         }     }     printf("num = %d\t, name = %s\n", q->num, q->name);     free(q);      return 0; } int main(int argc, const char *argv[]) {     int total, step, start;     struct node *head;      printf("Please input total test number: ");     scanf("%d", &total);     head = create_singly_link(total);     test_print(head);      printf("Please input start position and steps: ");     scanf("%d%d", &start, &step);      output(head, start, step, total);      return 0; } 约瑟夫环，可以参考一下这个程序。

#include<stdio.h> //#include<malloc.h> #include<stdlib.h>  typedef struct circle {     int people;     struct circle *next; }one;  int count;  //创建链表环 one *create(int n) {     one *head,*p1,*p2;     int i;      head = NULL;     for(i = 0; i < n; i++)     {         p1 = (one *)malloc(sizeof(one));         if(!p1)             exit(1); //开辟空间，如果分配失败退出         scanf("%d", &p1->people);         count++;         if(!head)             head = p1;         else             p2->next = p1;         p2 = p1;     }     p2->next = head;     return head; }  void print_cicle(one *head) {     one *p = head;     int i = 0;      while (i < 6) {         printf("%d\t", p->people);         p = p->next;         i++;     }      putchar(10); }  int main() {     one *head, *p, *pre;     int n, i = 2, dis;     printf("please input the people numbers: \n");     scanf("%d",&n);     head = create(n);     printf("count = %d\n", count);      print_cicle(head);     p = head;     pre = p;     printf("please input the distance you want to selete:\n");     scanf("%d", &dis);      i = 0;     while (1) {         i++;         //printf("+++++No.%d\n", p->people);         if (count == 1)             break;         if (i % dis == 0) {             printf("the no.%d is out \n", p->people);             if (p == head) {                 head = head->next;                 free(p);                 pre = head;                 p = head;             } else {                 pre->next = p->next;                 free(p);                 p = pre->next;             }             count--;         } else {             pre = p;             p = p->next;         }     }     printf("the no.%d is the last person int the end:\n", p->people);     free(p);       /*     while(1)   //无限循坏直到只剩一人break退出     {         if(t.count==2&&i==dis)   //只剩两人时         {             printf("the no.%d is out \n",p->next->people);             del=p->next;             p->next=NULL;             free(del);             t.count--;             printf("the no.%d is the last person int the end:\n",p->people );             break;         }    //  if()         if(i==dis)   //遇到等距数dis则删除结点，继续循环         {             printf("the no.%d is out \n",p->next->people);             del=p->next ;             p->next=del->next;             free(del);  //删除结点             t.count--;   //相应人数减一             i=1;       //重新计数         }  // if( )         p = p->next;         i++;     }  // while()     */     return 0; } 参考一下吧

第二个if中，p->next==p时，free后应该break


Question: 定义max函数输出结果错误

是的，最后的12,13符号有误。

看了函数没错啊 是不是你输入错了  那个逗号是中文的么?


Question: 请大神帮我看看哪里有问题，为何得不出正确的答案，没有人帮我，希望我能走桃花运碰到好人！

#include <stdio.h> #include <stdlib.h> #define MAX_SIZE 1024  void InsertNum_Stack(int *Num_Stack,int *Top_Num,int num); void InsertChar_Stack(char *Char_Stack,int *Top_char,char num); int Decide(char *Char_Stack,int *Top_char,char num); void Deal_date(char *Char_Stack,int *Num_Stack,int *Top_char,int *Top_num);   int main() {     int Num_Stack[MAX_SIZE] = {0};     int Top_Num = -1;     char Char_Stack[MAX_SIZE] = {0};                                                           //符号栈初始化；     int Top_char = -1;     char *temp,dest[10];                                                                        //数据暂存；     char *str = NULL;     int num = 0,i;      str = (char *)malloc(MAX_SIZE*sizeof(char));     if (!str) {         printf("申请存储空间失败！\n");         exit(0);     }     printf("请输入要运算的公式(包括等号)：");     scanf("%s",str);     while(*str != '='){         temp = dest;         while(*str >= '0'&& *str <= '9'){             *temp = *str;             temp++;             str++;         }         if(*str != '(' && *(temp-1) != '\0'){             *temp = '\0';             num = atoi(dest);             InsertNum_Stack(Num_Stack,&Top_Num,num);         }         while(*str == '+'||*str == '-'||*str == '*'||*str == '/'||*str == '('||*str == ')'||*str == '='){             i = Decide(Char_Stack,&Top_char,*str);                                             //优先级判断；             if(i == 0){                 InsertChar_Stack(Char_Stack,&Top_char,*str);                                   //字符压栈；                 break;             }             else if(i == 1){                 str++;             }             else if(i == -1){                 Deal_date(Char_Stack,Num_Stack,&Top_char,&Top_Num);                             //数据处理；                 if(*str == '=')                     break;             }         }         if(*str != '=')             str++;     }     printf("结果 = %d\n",Num_Stack[0]);     return 0; }  void InsertNum_Stack(int *Num_Stack,int *Top_Num,int num) {     (*Top_Num)++;     printf("Top num = %d\n", *Top_Num);      Num_Stack[*Top_Num] = num;      return; }  void InsertChar_Stack(char *Char_Stack,int *Top_char,char num){     (*Top_char)++;     Char_Stack[*Top_char] = num;     return; }  int Decide(char *Char_Stack,int *Top_char,char num) {     if(*Top_char == -1||num == '('||(Char_Stack[*Top_char] == '('&&Char_Stack[*Top_char] != ')'))         return 0;     else if((Char_Stack[*Top_char] == '+'||Char_Stack[*Top_char] =='-')&&(num == '*'||num == '/'))         return 0;     else if(Char_Stack[*Top_char] == '('&&num == '(')         return 0;     else if((Char_Stack[*Top_char] == '(' && num == '+')||num == '-'||num == '*'||num == '/')         return 0;     else if(Char_Stack[*Top_char] == '('&&num == ')'){         Top_char--;         return 1;     }     else         return -1; }  void Deal_date(char *Char_Stack,int *Num_Stack,int *Top_char,int *Top_num){     int num_1 = Num_Stack[*Top_num];     int num_2 = Num_Stack[*Top_num-1];     int value = 0;     if(Char_Stack[*Top_char] == '+')         value = num_1 + num_2;     else if(Char_Stack[*Top_char] == '*')         value = num_1 * num_2;     else if(Char_Stack[*Top_char] == '/')         value = num_2 / num_1;     else if(Char_Stack[*Top_char] == '-')         value = num_2 - num_1;     (*Top_num)--;     //Num_Stack[*Top_num] == value;     Num_Stack[*Top_num] = value;     Top_char--;     return; }  改了之后上面的代码，可以运行不带括号的，但是还是100以内的运算 加上括号就会有问题，建议继续查找问题。 其实可以看一下别人是怎么处理的，可以拿别人的源码分析一下

程序里bug很多，比如;  void InsertNum_Stack(int *Num_Stack,int *Top_Num,int num){ *(Top_Num)++; Num_Stack[*Top_Num] = num; return; }  void InsertChar_Stack(char *Char_Stack,int *Top_char,char num){ *(Top_Num)++; Char_Stack[*Top_char] = num; return;  } 这两个函数中下面这两行应该把*移到括号里面，类似的bug还有 *(Top_Num)++; *(Top_Num)++;  另外，算法也有问题，计算表达式的值多看看编译原理中的算符优先算法。

有没有调试信息发出来看看？


Question: 单链表节点删除问题

引用 2 楼 qq_38204686 的回复:应该是你代码有问题 建议调试  还有就是 能把你代码贴上来么 谢谢您，谢谢你

/////////////////////////删除节点函数 struct students *Delete(struct students *p) { 	struct students *pNewHead = p; 	struct students *pSecLink = pNewHead;		//读取两次此单链表，并让 pNewLink 链的节点读取比 ph 链晚一个节点。 	struct students *ph = p;			//原始链表，读取数据。 	printf("请输入要删除学生的学号："); 	int iNum = 0; 	scanf("%d", &iNum); 	int iCount = 0;		//用来错开两条链表的空间，以方便节点删除后的连接。 	int iJudgeLinkPlace = 0;		//标记删除的节点是 链头还是其他节点，链头用1标记，链身和链尾都用2表示 	while (ph != NULL) 	{ 		if (iNum == p->iNum) 		{ 			iJudgeLinkPlace = 1; 			pNewHead = p->pNext;  			break; 		} 		else if (iNum == ph->iNum) 		{ 			iJudgeLinkPlace = 2; 			pSecLink->pNext = ph->pNext;  			break; 		} 		else 		{ 			iCount++; 			ph = ph->pNext; 			if (iCount >= 2) 			{ 				pSecLink = pSecLink->pNext; 			} 		} 	} 	switch (iJudgeLinkPlace) 	{ 	case 1: 	{ 			  struct students *pNewL = pNewHead; 			  do{ 				  pNewL->iNum--; 				  pNewL = pNewL->pNext; 			  } while (pNewL != NULL); 			  break; 	} 	case 2: 	{ 			  struct students *pNewLMid = pSecLink->pNext; 			  if (pNewLMid != NULL) 			  do{ 				  pNewLMid->iNum--; 				  pNewLMid = pNewLMid->pNext; 			  } while (pNewLMid != NULL); 			  break; 	} 	}  	return(pNewHead); } 这是节点删除函数，完整的有点长

应该是你代码有问题 建议调试  还有就是 能把你代码贴上来么

有大佬吗？兄弟，姐妹啊，大哥大姐啊。 叔叔阿姨啊，怎么回事？


Question: 感觉自己的编程白学了

哈哈哈，学好理论，然后会自己搞搞就可以了。。等出来工作后，被老大怼几次后，就会进步飞快了

我也想当学生。

第九题题目就错了 ， C语言是严格区分大小写的； 大写B没有定义，怎么计算

你的电脑安装成Ubuntu了吗

是应该为9啊，但实际编程肯定不会这么写的

第9题a+B，B未定义，所以是错的

桌面背景很好看  你们老师也不错了  没给你们留算法题

我怎么感觉第9题：a+B=69 呢？

这些题没什么呀。

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

第9题是逗号运算符， 最后一位是最终结果，，但最后一位的变量一般与前几位的结果有关


Question: c在sublime里能像python一样配置输入输出新建窗口显示么

{      "encoding":"utf-8",      "cmd": "cmd /c g++ -fexec-charset=GBK \"${file}\" -o \"${file_path}/${file_base_name}\" && start cmd /c \"\"${file_path}/${file_base_name}\" && pause\"",      "file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",      "working_dir": "${file_path}",      "selector": "source.c++",      "variants":      [          {              "name": "Run",             "cmd": "cmd /c g++ -fexec-charset=GBK \"${file}\" -o \"${file_path}/${file_base_name}\" && start cmd /c \"\"${file_path}/${file_base_name}\" && pause\""         }      ]  } 这是我的配置，拿走不谢


Question: makefile 编译效率问题

Makefile 就是为了解决所有文件重复编译的问题，，会根据时间截决定该文件是否需要重新编译， 最终链接的还是.o文件  gcc -o app add.c div.c mul.c sub.c main.c -I include/  是直接生成了可执行文件    集预处理 编译 汇编 链接 于一体  gcc -c add.c -I include  是产生了中间文件.o文件  最终将.o文件链接在一起   这是Makefile 就会起到作用

引用 2 楼 Simpledcc 的回复:gcc编译的时候是不是对待.o文件只是进行链接处理,所以才不会像直接编译.c文件那样. 不只是简单的链接处理  ，，，我知道的一点是 会进行标识符检查，比如变量的重复定义，因为每个.cpp文件生成一个.o文件可以，单独编译时没问题，当这些.o文件链接在一起，可能会出现个这种问题 。 （类的静态数据成员初始化：要是初始化过程放到.h文件中，，很有可能导致重复定义）  只针对 “.o文件只进行链接处理” 的解释


Question: [Error] expected '=', ',', ';', 'asm' or '__attribute__' before '{' token

谢谢老哥 。。。

猜测  void init 加个; 或者加个大括号

这是错误的提示


Question: 贪心算法求最短路径，输入不同地点名称，显示最短距离均为零，求代码纠错，谢谢！！！

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

求解答……


Question: 请问这个代码有错吗，不管这个代码的目的，输入数字5，却没有结果输出

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

引用 2 楼 MENGLONG___ 的回复:为什么把\n去掉就会结束呢？ 这是scanf函数的设计，scanf是行缓冲，当遇到回车时，才将输入缓冲里的数据刷到内存，因此遇到回车才行，如果在scanf格式化输入里还有回车，那么输入的回车不能将数据刷到内存，而是匹配回车符

楼主是要算阶乘吗？应当改成这样的代码：  #include <stdio.h>  int f(int n);  void main() { 	int n, x; 	scanf("%d", &n); 	x = f(n); 	printf("%d", x); } int f(int n) { 	int i, z; 	int res = 0; 	if (n > 1) { 		res = n*f(n - 1); 	} else { 		return 1; 	} 	return res; }

scanf("%d\n",&n); 改成 scanf("%d",&n);  http://blog.csdn.net/weiweicsdn1/article/details/52185453

有那个\n的话，按正常的方式输入你应该是没有结果才对，就是运行不到x=f(n)这里。 不过输入一个数按下回车之后，再按一下回车就会向下运行了。

为什么把\n去掉就会结束呢？

递归要有退出条件，scanf格式输入里面\n去掉

你这样递归   最后的答案也不会对     这个程序执行到循环时  就一直循环  梯归   ，处理器  运算快的话   能算出来   不过是随机值  因为返回Z的值 已经超过int类型取值范围了  也就是数据溢出，产生错误 而且这个程序，输入值为2时  就会崩溃