Question: c语言中如何释放子函数中开辟的内存呢？

子函数realloc完了将指针的地址返回给主函数被，用指针的指针来传递。

引用 19 楼 zhao4zhong1 的回复:楼主功力还不够深厚啊！ 仅供参考： #include <assert.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> int K,n; unsigned long ulrand(void) {     return (      (((unsigned long)rand()<<24)&0xFF000000ul)     |(((unsigned long)rand()<<12)&0x00FFF000ul)     |(((unsigned long)rand()    )&0x00000FFFul)); } float **sub(float **p) {     float **p1;     int K1,i,j;      for (i=0;i<K;i++) for (j=0;j<n;j++) p[i][j]=(float)(i*n+j);      while (1) {         K1=ulrand()%100000;         if (K1!=K) break;     }      if (K1<K) {         for (i=K1;i<K;i++) free(p[i]);         p1=(float**)realloc(p,K1*sizeof(float*));         assert(p1);         p=p1;     } else {//K1>K         p1=(float**)realloc(p,K1*sizeof(float*));         assert(p1);         p=p1;         for (i=K;i<K1;i++) {             p[i]=(float*)calloc(n,sizeof(float));             assert(p[i]);         }     }      K=K1;      for (i=0;i<K;i++) for (j=0;j<n;j++) p[i][j]=(float)(i*n+j);      return p; } int main() {     float **P;     int i;      K=ulrand()%100000;     n=ulrand()%1000;      P=(float**)calloc(K,sizeof(float*));     assert(P);     for (i=0;i<K;i++) {         P[i]=(float*)calloc(n,sizeof(float));         assert(P[i]);     }      P=sub(P);      for (i=0;i<K;i++) {         free(P[i]);     }     free(P);      return 0; }  多谢指教！！

引用 14 楼 shuhaitao333 的回复:[quote=引用 11 楼 user-4 的回复:] [quote=引用 10 楼 shuhaitao333 的回复:] [quote=引用 8 楼 user-4 的回复:] 你的代码是不是  main { char* p = malloc func(p) free(p) }  func(int* p) { p  = realloc }  对吗 对，不过指针都是二级的。[/quote]C语言 只有值传递 你这样做 无法修改main中 p指针的值  p还是指向原来的malloc 得到的内存块  而这个内存块可能在realloc的时候 被释放了  free(已经释放的内存) 就会死  改正可以是 main { int** p = malloc p = func(p) free(p) }  int** func(int* p) { int** pp  = realloc 处理pp return pp; }  另外 以后这样的问题需要把代码也贴出来  查错比较方便   如果代码太长可以和我现在做的一样 做一些精简 保留需要注意的地方[/quote] 看起来是我在楼下说的意思。对不对？[/quote]多谢你，我试试行不行。

引用 16 楼 schlafenhamster 的回复:P1=malloc(m+1行)；//  这是 p 不够大 ；所以 分配 大点的 把p和增加的一行赋给P1；//  把 p 里的 内容 复制到 P1 for（i=0;i<m;i++）//  释放 p 所占的 内存 free (p[i]);// free(p);// 然后   *p=P1；// 主函数 caller 只知道 有 P1。如果 P1 以后不用了， 则在 主 函数 中 释放 它。 好，我试试，多谢。

引用 13 楼 schlafenhamster 的回复:"在主函数中没有释放语句"  主函数 只释放 最后的 p。 void 子函数（int **p） { P1=malloc(m+1行)； 把p和增加的一行赋给P1； for（i=0;i<m;i++）//以下三行要删除？？？？ free (p[i]);// free(p);// 然后 *p=P1； }

引用 11 楼 user-4 的回复:[quote=引用 10 楼 shuhaitao333 的回复:] [quote=引用 8 楼 user-4 的回复:] 你的代码是不是  main { char* p = malloc func(p) free(p) }  func(int* p) { p  = realloc }  对吗 对，不过指针都是二级的。[/quote]C语言 只有值传递 你这样做 无法修改main中 p指针的值  p还是指向原来的malloc 得到的内存块  而这个内存块可能在realloc的时候 被释放了  free(已经释放的内存) 就会死  改正可以是 main { int** p = malloc p = func(p) free(p) }  int** func(int* p) { int** pp  = realloc 处理pp return pp; }  另外 以后这样的问题需要把代码也贴出来  查错比较方便   如果代码太长可以和我现在做的一样 做一些精简 保留需要注意的地方[/quote] 看起来是我在楼下说的意思。对不对？

"在主函数中没有释放语句"  主函数 只释放 最后的 p。

引用 9 楼 schlafenhamster 的回复:主函数中开辟 P  -》 给 子程序 -》子程序 发现 P 不够大 ， 开辟 P1， 删除 P ， 返回 P1。  注意这里  P1 是 通过 P 返回的 ， 所以 这个 P 是 2级 指针  即：  void 子函数（int **p） { ；；；； *p=P1； } 你的意思是不是： void 子函数（int **p） { P1=malloc(m+1行)； 把p和增加的一行赋给P1； for（i=0;i<m;i++） free (p[i]); free(p); 然后 *p=P1； } 在主函数中没有释放语句。 我理解的对不对？

引用 10 楼 shuhaitao333 的回复:[quote=引用 8 楼 user-4 的回复:] 你的代码是不是  main { char* p = malloc func(p) free(p) }  func(int* p) { p  = realloc }  对吗 对，不过指针都是二级的。[/quote]C语言 只有值传递 你这样做 无法修改main中 p指针的值  p还是指向原来的malloc 得到的内存块  而这个内存块可能在realloc的时候 被释放了  free(已经释放的内存) 就会死  改正可以是 main { int** p = malloc p = func(p) free(p) }  int** func(int* p) { int** pp  = realloc 处理pp return pp; }  另外 以后这样的问题需要把代码也贴出来  查错比较方便   如果代码太长可以和我现在做的一样 做一些精简 保留需要注意的地方

引用 8 楼 user-4 的回复:你的代码是不是  main { char* p = malloc func(p) free(p) }  func(int* p) { p  = realloc }  对吗 对，不过指针都是二级的。

引用 6 楼 schlafenhamster 的回复:子函数中： P=(float**)realloc(P,(m+1)*sizeof(float*)); 等等一系列操作后返回指针P。  返回 P 前， 原来 P 要 删除。  就是 P1=新内存，（比原来大）  复制 P到 P1 删除  P 返回 P1 我推测你的意思是：先在子函数中开辟一个更大的内存P1然后把P放进P1，然后在子函数中删除P，再把P1返回到主函数中。 但是有几个问题：a. P是我在主函数中开辟的，如果我在子函数中释放，可行吗？ b. 怎么样返回P1，这个我不懂具体命令。c. P1是否需要在子函数中释放？还是在主函数中释放？

引用 4 楼 schlafenhamster 的回复:不如 分配一个 超大的 内存我也考虑过这么做，毕竟频繁的开辟释放内存也是效率不高的。但是如果分配大内存的话会在其他方面引起麻烦，也会大大降低效率。我要做一个逼近的算法，这样会增加我扫描的范围。

不如 分配一个 超大的 内存

引用 2 楼 zhao4zhong1 的回复:都free了，还怎么realloc？  realloc Reallocate memory blocks.  void *realloc( void *memblock, size_t size );  Routine Required Header Compatibility  realloc <stdlib.h> and <malloc.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  realloc returns a void pointer to the reallocated (and possibly moved) memory block. The return value is NULL if the size is zero and the buffer argument is not NULL, or if there is not enough available memory to expand the block to the given size. In the first case, the original block is freed. In the second, the original block is unchanged. The return value points to a storage space that is guaranteed to be suitably aligned for storage of any type of object. To get a pointer to a type other than void, use a type cast on the return value.  Parameters  memblock  Pointer to previously allocated memory block  size  New size in bytes  Remarks  The realloc function changes the size of an allocated memory block. The memblock argument points to the beginning of the memory block. If memblock is NULL, realloc behaves the same way as malloc and allocates a new block of size bytes. If memblock is not NULL, it should be a pointer returned by a previous call to calloc, malloc, or realloc.  The size argument gives the new size of the block, in bytes. The contents of the block are unchanged up to the shorter of the new and old sizes, although the new block can be in a different location. Because the new block can be in a new memory location, the pointer returned by realloc is not guaranteed to be the pointer passed through the memblock argument.  realloc calls malloc in order to use the C++ _set_new_mode function to set the new handler mode. The new handler mode indicates whether, on failure, malloc is to call the new handler routine as set by _set_new_handler. By default, malloc does not call the new handler routine on failure to allocate memory. You can override this default behavior so that, when realloc fails to allocate memory, malloc calls the new handler routine in the same way that the new operator does when it fails for the same reason. To override the default, call   _set_new_mode(1)  early in your program, or link with NEWMODE.OBJ.  When the application is linked with a debug version of the C run-time libraries, realloc resolves to _realloc_dbg. For more information about how the heap is managed during the debugging process, see Using C Run-Time Library Debugging Support.  Example  /* REALLOC.C: This program allocates a block of memory for  * buffer and then uses _msize to display the size of that  * block. Next, it uses realloc to expand the amount of  * memory used by buffer and then calls _msize again to  * display the new amount of memory allocated to buffer.  */  #include <stdio.h> #include <malloc.h> #include <stdlib.h>  void main( void ) {    long *buffer;    size_t size;     if( (buffer = (long *)malloc( 1000 * sizeof( long ) )) == NULL )       exit( 1 );     size = _msize( buffer );    printf( "Size of block after malloc of 1000 longs: %u\n", size );     /* Reallocate and show new size: */    if( (buffer = realloc( buffer, size + (1000 * sizeof( long )) ))          ==  NULL )       exit( 1 );    size = _msize( buffer );    printf( "Size of block after realloc of 1000 more longs: %u\n",              size );     free( buffer );    exit( 0 ); }   Output  Size of block after malloc of 1000 longs: 4000 Size of block after realloc of 1000 more longs: 8000   Memory Allocation Routines  See Also   calloc, free, malloc  你可能没看清，我realloc是在子函数中使用的。我在主函数中调用子函数以后，在程序的最后才free的。 也就是说我先在主函数中molloc，然后调用子函数realloc，最后才free。


Question: 3D空间如何判断两点是否在同一个矩形框内

你可以将四边形拆分成两个三角形，然后判断点是否在三角形内 http://www.blackpawn.com/texts/pointinpoly/default.html


Question: 定义只能有一次,那为什么我能定义两次?

引用 13 楼 TheNewIpad 的回复:[quote=引用 12 楼 hollebab 的回复:] 楼上两位的回答我实在看不懂,我就说下我现在的观点吧. 我打了这个命令: gcc test1.c test2.c 这两条命令的意思是把两个文件分别编译,然后链接. 链接的意思是gcc把两个编译得到的.o文件头尾连在一起,那不就相当于我单纯地把两个源文件test1.c和test2.c头尾连在一起,然后编译,那不就重复定义了吗?可是为什么gcc test1.c test2.c这样编译就不会产生错误信息呢?  定义，可以理解成占用内存的行为。  比如定义一个变量。 int a; 这就是定义。 比如实现一个函数。 声明： 告诉编译器，你有某个东西。 比如声明一个变量 extern int a；  比如声明一个函数。 int func();[/quote] 我知道,然后呢?

引用 12 楼 hollebab 的回复:楼上两位的回答我实在看不懂,我就说下我现在的观点吧. 我打了这个命令: gcc test1.c test2.c 这两条命令的意思是把两个文件分别编译,然后链接. 链接的意思是gcc把两个编译得到的.o文件头尾连在一起,那不就相当于我单纯地把两个源文件test1.c和test2.c头尾连在一起,然后编译,那不就重复定义了吗?可是为什么gcc test1.c test2.c这样编译就不会产生错误信息呢?  定义:     可以理解成占用内存的行为。  比如          int a; 定义一个变量。           int func(){//...}  定义（实现）一个函数 声明：      告诉编译器，你有某个东西。 比如          extern int a； 声明一个变量          int func();    声明一个函数。

引用 12 楼 hollebab 的回复:楼上两位的回答我实在看不懂,我就说下我现在的观点吧. 我打了这个命令: gcc test1.c test2.c 这两条命令的意思是把两个文件分别编译,然后链接. 链接的意思是gcc把两个编译得到的.o文件头尾连在一起,那不就相当于我单纯地把两个源文件test1.c和test2.c头尾连在一起,然后编译,那不就重复定义了吗?可是为什么gcc test1.c test2.c这样编译就不会产生错误信息呢?  定义，可以理解成占用内存的行为。  比如定义一个变量。 int a; 这就是定义。 比如实现一个函数。 声明： 告诉编译器，你有某个东西。 比如声明一个变量 extern int a；  比如声明一个函数。 int func();

编译器看到的是 .c 文件。 #include 被直接包含在 .c 文件内。

你没有使用test2.c 编译器不会处理 使用的时候才会进行定义 没有定一两次 调试一下就知道了

不是,是重复定义了

既然是声明,那就是说能声明多次,那为什么我这样又显示重复声明了? #include "3.h" #include "3.h" main() { }

c语言的struct token  等于C++的token  楼主只是在声明变量而已

引用 5 楼 zhao4zhong1 的回复:定义和声明不是一回事！ 你的意思是3.h中的内容是声明?

定义和声明不是一回事！

因为上个帖子中别人说定义只能出现一次,而现在我包含了2次3.h这个文件,那就是定义了2次了

我问的是为什么3.h中的内容能被定义两次?

struct token x 是声明变量。同样的对y也一样。

struct token {     int i;     int j; };  这个是定义struct的具体内容。  struct token y;  这个是定义一个struct token类型的变量。


Question: 多线程读串口

仅供参考//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef WIN32     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #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 WIN32 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,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 WIN32     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,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 WIN32     pthread_exit(NULL); #endif } int main() { #ifdef WIN32     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 WIN32     _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 WIN32     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; }

做一个协议，一个线程接收，根据收到的数据来判断数据属于哪个线程。


Question: 关于while循环   字符

有是一个粗心大意造成的问题

我喜欢 for(;;) { scanf("%c",&ch);  if(ch=='Y')                                                     break; printf("%c",ch);  }

哎呀，应该是： while(ch!=Y'||ch!='y')

我想知道实现输入y继续，输入其他退出循环最简单的算法是什么

ch='Y' 赋值为真，当然一直循环

以后把定值写在左边就不会出错了，=和==你用错了

ch='Y'||'y'的含义是： 将'Y'赋值给ch，并以ch的值作为逻辑值判断（当然为真）；或者将'y'的值作为逻辑值判断（还是为真）

引用 16 楼 u013163178 的回复:#include <stdio.h> #include <malloc.h> int main(void) {	 	char ch='y';//把y换成a之类的循环也会执行，为什么？ 	while(ch=='Y'||ch=='y') 	{ 	scanf("%c",&ch); 	getchar(); 	printf("%c",ch); 	} 	return 0; } getchar()在这里起到了什么作用啊？

引用 12 楼 u013823973 的回复:[quote=引用 8 楼 wenbo228228 的回复:] #include <stdio.h> #include <malloc.h> int main(void) { 	char ch='y';//把y换成a之类的循环也会执行，为什么？ 	while((ch=='y')||(ch=='Y')) 	{ 	scanf("%c",&ch); 	printf("%c",ch); 	} 	return 0; }  解决了==问题后，输入t程序结束，为什么输入y还是结束？ scanf后缓冲区里面还有个回车，在下一次的时候不会要你输入，直接把回车赋值给ch了造成循环结束 可以在循环里面刷新缓冲区[/quote]  怎么刷新，我没学过字符的操作

=和==不分啊

引用 1 楼 worldy 的回复:ch='Y'||'y'  判断是否相等是==，不是= ch==('Y'||'y')，加上挎号，确保||运算最先执行  正解了啊， =是赋值操作，不会为false的

楼主仔细看看，然后调试就出来了，很明显的问题啊

引用 8 楼 wenbo228228 的回复:#include <stdio.h> #include <malloc.h> int main(void) { 	char ch='y';//把y换成a之类的循环也会执行，为什么？ 	while((ch=='y')||(ch=='Y')) 	{ 	scanf("%c",&ch); 	printf("%c",ch); 	} 	return 0; }  解决了==问题后，输入t程序结束，为什么输入y还是结束？ scanf后缓冲区里面还有个回车，在下一次的时候不会要你输入，直接把回车赋值给ch了造成循环结束 可以在循环里面刷新缓冲区

上面打错了。 ch 都有初始值了，while肯定会执行的。

引用 8 楼 wenbo228228 的回复:#include <stdio.h> #include <malloc.h> int main(void) { 	char ch='y';//把y换成a之类的循环也会执行，为什么？ 	while((ch=='y')||(ch=='Y')) 	{ 	scanf("%c",&ch); 	printf("%c",ch); 	} 	return 0; }  解决了==问题后，输入t程序结束，为什么输入y还是结束？  你要把 scanf("%c",&ch); 这句提到 if 上面去吧。

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


Question: 网上下的c源码 从来都是无法运行

是 linux 的. vc 下也可以.先搞util, 是个 lib 1. 用 word 把 源文件 改存为 txt 的 vc 创建一个 静态库项目 叫 util, 加入所有 文件. 2. rebuild all 就有了 util.lib  然后是其他  vc下不要什么 make

打开C++ IDE 点击 fpgrowth.c rebuild all  加入 其他 文件。  rebuild all  修改 设置。

面的 3个 项目， 一个一个 做。 问题在于， 源文件 不是 txt 格式 （是 网页），要 先转换。如：  /*----------------------------------------------------------------------   File    : fpgrowth.c   Contents: fpgrowth algorithm for finding frequent item sets   Author  : Christian Borgelt   History : 2004.11.21 file created from eclat.c             2004.11.23 absolute/relative support output changed             2004.12.09 filter added (binary logarithm of supp. quotient)             2005.06.20 use of flag for "no item sorting" corrected             2007.02.13 adapted to modified module tabread             2008.01.22 special processing of chains added             2008.05.02 default limit for maximal number of items removed             2008.09.01 adapted to modified modules tract and report             2008.09.02 pruning with perfect extensions added             2008.09.09 more flexible information output control added             2008.10.26 maximum item set size removed from recursion             2008.10.31 adapted to changes in item set reporting             2008.11.13 adapted to changes in transaction management             2009.05.28 adapted to modified function tbg_filter()             2009.10.15 adapted to item set counter in reporter             2009.10.18 treatment of item chains simplified             2009.10.19 closed and maximal item set mining added             2010.02.08 adapted to new repository for filtering             2010.03.03 copy pointer removed from structure FPNODE             2010.03.04 memory system eliminated (now array of nodes)             2010.03.17 head union tail pruning for maximal sets added             2010.07.14 output file made optional (for benchmarking)             2010.07.20 created projections are no longer reallocated             2010.07.25 separate frequent pattern tree module removed             2010.07.26 fixed frequent pattern tree for each recursion             2010.07.27 variant with children/sibling nodes added             2010.07.29 variant added that processes the tree top-down             2010.07.30 simple node structure variant redesigned             2010.08.03 complex node variant with item reordering added             2010.08.05 top-down processing with single tree added             2010.08.19 item selection file added as optional input             2010.08.22 adapted to modified modules tabread and tract             2010.08.30 bug in header table initialization fixed             2010.10.15 adapted to modified interface of module report             2010.11.24 adapted to modified error reporting (tract)             2010.12.07 added some explicit type casts (for C++)             2010.12.11 adapted to a generic error reporting function             2010.12.20 adapted to function tbg_ifrqs() (filter problem)             2011.03.20 optional integer transaction weights added             2011.07.08 adapted to modified function tbg_recode()             2011.08.17 adapted algorithm variants to finding generators             2011.08.28 output of item set counters per size added             2011.08.29 bug in rec_single() fixed (perfect extensions)             2011.09.16 choice of item loop direction generalized             2011.09.21 added use of 16-items machine for simple trees             2011.09.27 bug in algorithm and mode checking fixed (hut)             2012.04.09 bug in function rec_single() fixed (isr_xable())             2012.05.25 masking of packed items added to proj_simple()             2012.05.30 simple tree functions split w.r.t. use of fim16             2012.06.19 use of 16-items machine for complex trees added             2012.06.20 function fpg_adjust() added (consistency check)             2013.03.07 direction parameter added to sorting functions             2013.04.02 adapted to type changes in module tract             2013.10.15 checks of return code of isr_report() added             2013.10.18 optional pattern spectrum collection added             2013.10.31 bug in function fpg_adjust fixed (check of mrep)             2013.11.12 item selection file changed to option -R#             2014.05.12 option -F# added (support border for filtering) ------------------------------------------------------------------------   Reference for the FP-growth algorithm:     J. Han, H. Pei, and Y. Yin.     Mining Frequent Patterns without Candidate Generation.     Proc. 19th ACM SIGMOD Int. Conf. on Management of Data     (SIGMOD'00, Dallas, TX), 1-12.     ACM Press, New York, NY, USA 2000   Top-down variant on single tree (option -ad):     Top-Down FP-Growth for Association Rule Mining     K. Wang, L. Tang, J. Han, and J. Liu.     Proc. 6th Pacific-Asia Conf. on Advances in Knowledge Discovery     and Data Mining (PAKDD 2002, Taipei, Taiwan), 334-340.     Springer-Verlag, London, United Kingdom 2002 ----------------------------------------------------------------------*/ #include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h> #include <limits.h> #include <float.h> #include <math.h> #include <time.h> #include <assert.h> #include "memsys.h" #ifndef ISR_PATSPEC #define ISR_PATSPEC #endif #ifdef FPG_MAIN #ifndef PSP_REPORT #define PSP_REPORT #endif #ifndef TA_READ #define TA_READ #endif #endif #include "fpgrowth.h" #include "fim16.h" #ifdef FPG_MAIN #include "error.h" #endif #ifdef STORAGE #include "storage.h" #endif  /*----------------------------------------------------------------------   Preprocessor Definitions ----------------------------------------------------------------------*/ #define PRGNAME     "fpgrowth" #define DESCRIPTION "find frequent item sets " \                     "with the fpgrowth algorithm" #define VERSION     "version 5.8 (2014.05.13)         " \                     "(c) 2004-2014   Christian Borgelt"

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

引用 8 楼 philip_puma 的回复:linux 轻松无压力。  是用的IDE 还是直接make命令？

引用 8 楼 philip_puma 的回复:linux 轻松无压力。  是吗 linux下运行出来了？用的什么编译器？

很明显，修改Makefile

..................... 这

linux 轻松无压力。

引用 1 楼 jerry_dqh 的回复:有什么错误贴出来， 网上下的可能有时候要修改一下makefile。 放在eclipse新建一个c++项目里make target, build   报错又不一样了 ..\src\tract.h:56:18: fatal error: random: No such file or directory  #include <random>                   ^

Microsoft Windows [版本 6.1.7601] 版权所有 (c) 2009 Microsoft Corporation。保留所有权利。  C:\Users\lenovo>make make: *** No targets specified and no makefile found.  Stop.  C:\Users\lenovo>cd /d D:\learn\fpgrowth\fpgrowth\src  D:\learn\fpgrowth\fpgrowth\src>make cd ../../util/src;  make memsys.o  ADDFLAGS="" 系统找不到指定的路径。 makefile:73: recipe for target '../../util/src/memsys.o' failed make: *** [../../util/src/memsys.o] Error 1  D:\learn\fpgrowth\fpgrowth\src>cd /d D:\learn\fpgrowth\tract\src  D:\learn\fpgrowth\tract\src>make cd ../../util/src;  make arrays.o   ADDFLAGS="" 系统找不到指定的路径。 makefile:200: recipe for target '../../util/src/arrays.o' failed make: *** [../../util/src/arrays.o] Error 1  D:\learn\fpgrowth\tract\src>cd /d D:\learn\fpgrowth\util\src  D:\learn\fpgrowth\util\src>make gcc -std=c99 -Wall -Wextra -Wno-unused-parameter -Wconversion -pedantic  -DNDEBU G -O3 -funroll-loops -DARRAYS_MAIN -c arrays.c -o sortargs.o gcc   sortargs.o -o sortargs make: *** No rule to make target 'lists.c', needed by 'listtest.o'.  Stop.  D:\learn\fpgrowth\util\src>      百度一个离线的mingw ,只设了环境变量 path=D:\mingw\bin  然后有3个makefile

有什么错误贴出来， 网上下的可能有时候要修改一下makefile。


Question: 数据结构C语言版实习题10个题目求解答

看起来不难，要自己多练啊！

不是有本课后答案的书吗

这是谁谁的什么出版社的书啊？楼主你从网上搜过课后题答案吗？

1. MergeSort

《算法精解（C语言描述）》

我只能说你的胃口很大。

作业题拜拜            。

你这样的话,这道题目得300分


Question: c语言面试考些什么？

考“strlen,strcpy,ctrcat”是必要的，这样可以把那些根本跑来打酱油的人用最低的成本挡在技术面试官办公室的门外。这种面试其实根本不算面试，无非就是公司派一个前台小姐（根本不用懂技术）发你一张纸让你写写，写不出来就可以打发走了。  你要知道，现在连初中毕业的待业青年，随便报个班学几天，也想当“程序员”。

我感觉应届生可能会面试这些，一般社会招人如果是我的话，不会问这些。


Question: 设计一个简单计算器

楼主是什么意思，给我们派作业吗

源码一大堆，思想就是树

楼主是课程设计？

作业帖？？？

google中搜索： site:download.csdn.net VC++ 计算器


Question: c语言宏定义问题

引用 6 楼 q191201771 的回复:因为编译前有个预处理阶段，会把宏定义进行替换 所以就相当你直接在main里面写了那三行代码好的~理解了~谢谢

引用 3 楼 q191201771 的回复:for (i = 0; i <= 2; i++) 越界访问内存了 a[2]的话只能a[0],a[1] <=改成< 谢谢不过可以再请教一下为何利用宏不用指针等也能进行互换呢忘解答~谢谢~

引用 1 楼 user-3 的回复:若要用函数改变函数外部的变量的值，要么此变量是全局的，要么你传递的是变量的指针。 void swap(int * x, int * y){int n;n = *x;*x = *y;*y = n;}   这样就能改变了。 若是C++，传递引用也行。 这个我知道，就是不太清楚为什么利用宏不用指针等也可以解决这种问题

至于为何会报错....我没看出来


Question: 邻接矩阵创建输入问题

谢谢，还是不明白原理，还要继续学习啦

scanf里敢加空格？！

for(i=0; i<G.vexnum; ++i)         scanf("%c",&G.vexs[i]); getchar();//添加这个，尝试一下。或刷新一下输入缓存也可行，下文紧接着输入字符，它可能获得是个回车字符，导致输入异常

看起来好像是输入缓冲区的问题。在G.arcs[j][i]=w;后添加fflush（stdin）


Question: c/c++入门到进阶的学习过程应该是怎样的？

把c++primer 多看几遍，每次再看就理解不一样。  MFC了解下就行了，现在招聘MFC的太少了。。学学linux. 真心要玩MFC的话，windows编程看看，加上孙鑫的视频，效果更佳

搜索下载安装MSDN98 mk:@MSITStore:C:\MSDN98\98VS\2052\vcsample.chm::/html/_core_alphabetical_list_of_mfc_samples.htm Alphabetical List of MFC Samples Sample Illustrations  ACDUAL Demonstrates how to add dual interface support to an MFC-based Automation server.  AUTOCLIK Tutorial example illustrating Automation features in Visual C++ Tutorials.  AUTODRIV A simple Automation client application that drives the AUTOCLIK tutorial sample application.  BINDENRL Databound controls in a dialog-based application with property pages.   BINDSCRB Illustration of the use of new COM interfaces to components currently supported by the Microsoft Office suite of products.   CALCDRIV Automation client.  CATALOG Illustration of direct calls to ODBC functions in general, and the ODBC functions SQLTables and SQLColumns in particular.  CATALOG2 Illustration of direct calls to ODBC functions in general using Windows Common Controls.  CHATSRVR Discussion server application for CHATTER.  CHATTER Client application that uses Windows Sockets.  CHKBOOK Record-based (nonserialized) document.  CIRC Tutorial sample that teaches you how to create a simple ActiveX control called Circle.  CMNCTRL1 Demonstrates how to create and change the styles of Windows Common Controls using MFC classes (Part 1).  CMNCTRL2 Demonstrates how to create and change the styles of Windows Common Controls using MFC classes (Part 2).  COLLECT MFC C++ template-based collection classes, and standard prebuilt collection classes.  CONTAINER Tutorial example illustrating ActiveX Visual Editing container features in Visual C++ Tutorials.  COUNTER Using an ISAPI DLL to send image data (rather than HTML data) back to a Web browser.   CTRLBARS Custom toolbar and status bar, dialog bar, and floating palette.  CTRLTEST Owner-draw list box and menu, custom control, bitmap button, spin control.  CUBE OpenGL application using MFC device contexts along with OpenGL's resource contexts.  DAOCTL DAO database class functionality and ActiveX controls let you examine a database.  DAOENROL Based on ENROLL, but migrated to the DAO database classes. Also serves as Step 4 of the DaoEnrol tutorial.  DAOTABLE Creates a Microsoft Access database (.mdb file) and its tables, fields, queries, and indexes using MFC DAO database classes.   DAOVIEW DAO database classes and Windows Common Controls let you view the schema of a database.  DBFETCH Demonstrates the use of bulk row fetching in the ODBC database classes.  DBVList Demonstrates the virtual list view functionality available for the list view common control.  DIBLOOK Device-independent bitmap and color palette.  DLGCBR32 Adding a toolbar and a status bar to a dialog-based application.  DLGTEMPL Shows how to create dialog templates dynamically.  DLLHUSK Sharing the DLL version of the Foundation class library with an application and custom DLL.  DLLTRACE Statically linking the MFC library to a custom DLL.  DOCKTOOL Dragging and floating toolbars that are "dockable".  DRAWCLI Full-featured object-oriented drawing application that is also an ActiveX Visual Editing container.  DRAWPIC Getting a Windows handle to a bitmap or icon from an LPPICTUREDISP.  DYNABIND Dynamic binding of database columns to a recordset.   DYNAMENU Dynamically modifying list of items in menus; handling commands not known at compile time; and updating the status bar command prompt for such commands.  ENROLL Tutorial example illustrating database features in Visual C++ Tutorials.  EXTBIND Shows how to bind data-aware controls across a dialog box boundary.  FIRE Dialog-based application that demonstrates five Windows Common Controls.  FTPTREE Displays the contents of an FTP site in a tree control.  GUIDGEN A dialog-based MFC application used to generate globally unique identifiers, or GUIDs, which identify OLE classes, objects, and interfaces.  HELLO Simple application with frame window but no document or view.  HELLOAPP Minimal "Hello World" application.  HIERSVR ActiveX Visual Editing server application with drag and drop.  HTTPSVR Uses MFC Windows Socket classes to implement an Internet HTTP server.  IMAGE Demonstrates an ActiveX control that is capable of downloading data asynchronously.  INPROC An in-process Automation server that can be loaded as a DLL in the client's address space.   IPDRIVE A simple Automation client application that drives the INPROC sample application.   LISTHDR Demonstrates the List View and Header Common Controls.  MAKEHM Command line utility for associating resources with Help contexts.  MDI MDI application that does not use documents and views.  MDIBIND Demonstrates data binding in CWnd-derived windows, but only at run time.   MDIDOCVW New version of the MDI sample that uses the document/view architecture.  MFCBIND Shows how to create an ActiveX document (formerly known as a DocObject) container using the ActiveX document container support classes.  MFCCALC An Automation server that implements a simple calculator.  MFCIE Uses MFC's CHtmlView and CreBar classes to implement a subset of the functionality provided by Microsoft Internet Explorer.  MFCRows Shows how to useCOleDBRecordView to scroll through a table in a database. Also how to use multiple accessors so you can update an Access table that contains an AutoNumber field to be retrieved.  MFCUCASE Demonstrates MFC support for Internet Server filter DLLs.  MODELESS Demonstrates the use of an MFC CDialog object as a modeless dialog.  MTGDI Multithread illustration, where GDI resources are converted to MFC objects and back.  MTMDI Multithread illustration, where user-interface events are processed in a separate user-interface thread.  MTRECALC Multithread illustration, where recalculations are done in a worker thread.  MULTIPAD Simple MDI text editor using the CeditView class.  MUTEXES Demonstrates the use of the Cmutex class for multithreading.  NPP Editor demonstrating toolbars, status bars, and other controls.  OCLIENT ActiveX Visual Editing container application, with drag and drop.  ODBCINFO Shows how to determine various ODBC driver capabilities at run time.  OLDBARS Provides support for applications that rely on the old implementations of CToolBar and CStatusBar by providing the source code for these classes.  OLEVIEW Implementing an OLE object browser through custom OLE interfaces.  PINBALL An Internet Server Extension DLL that provides graphics and also redirects users to a Web site for further research.  PROPDLG Property sheets (dialogs).  ROWLIST Illustrates full row selection in a list-view common control.   SAVER Screen saver written with MFC.  SCRIBBLE Main tutorial example in  Visual C++ Tutorials.  SMILEY Modifying properties, calling methods, and handling events from the SMILE control in the SMILEY container.  SNAPVW Shows how to use property pages in a MDI child frame window.  SPEAKN Multimedia sound using user-defined resources.  StockTicker An MFC and ATL application that retrieves stock quotes from the Web and displays them in an ATL control. The user can set the display's properties, including rate of data refresh.  STDREG Tool for populating the Student Registration database (used by the Enroll database tutorial) in any format supported by an ODBC driver. Illustrates SQL table creation.  SUPERPAD ActiveX Visual Editing server that edits text using CEditView.  TEAR MFC console application that uses the Wininet.dll.   TEMPLDEF Command line tool that expands source files similar to C++ templates.   TSTCON Implements an ActiveX control container using MFC's support for OLE embedding. You can use TSTCON to test ActiveX controls, change their properties, and invoke their methods.  TESTHELP An ActiveX control that has its own help file and tooltips.  TRACER Tool that sets the Foundation class application trace flags kept in AFX.INI.  TRACKER Illustration of the various CRectTracker styles and options.  VCTERM Simple terminal emulation program illustrating the use of the Mscomm32.ocx ActiveX control.  VIEWEX Multiple views, scroll view, splitter windows.  WIZARD97  Demonstrates implementing a wizard that supports background bitmaps and wide header titles and images. This wizard design is supported for Windows 98 and Windows NT 5.0; you must be using Windows 98 or Windows NT 5.0 for this sample to work properly.  WORDPAD Uses MFC's support for rich edit controls to create a basic word processor.  WWWQUOTE Retrieves information from a database and provides it to the user via an HTTP connection to the server.    See Also  Microsoft Foundation Class Library Samples Index

C语言基本语法是必须的，其他（包括C++语法，数据结构）都是根据需要选配

C++学习步骤zz C++知识分类：  ①基础知识（C 语言、标准库、文件、注册表、数据结构）       ②高级知识（多线程、串口通讯、网口通讯、动态库、MFC、COM、ATL、ActiveX）          ③专业知识（图像处理、多媒体、OpenGL、DirectShow、数据库、网络安全）     C++学习步骤：  第1阶段  先花一个月时间学习基本C语言，然后再看林锐博士的高质量编程，最后才去看C++ prime,the c++ programming language(一般作为参考书，比如调试时发现编译错误，但又觉得莫名其妙时！)，看完这些，基本会基于对象编程了！  第2阶段：  尝试实现封装C语言的字符处理函数，做一个字符串! 可以结合Effective C++/More Effective C++/Exceptional C++一起看，这样下来，你对指针操作，异常处理，智能指针会有深入的理解！ 这时，你基本上可以用c++工作了!  第3阶段——面向对象的设计 入 门的例子就是结合VC一起学，研究MVC模式，最好提高功力的书就是深入浅出MFC,这本书关键是要看懂前面3章，懂得如何去按MVC模式封装底层的C语 言，实现面向对象机制！同时，还可以看有关STL的书，这方面的好书比较少，入门的书倒是比较多！这个阶段的关键在于理解如何结合语言特性和软件需求来设 计！  第4阶段——编写自己的系统库  一般能进入这一境界的实在太少，这需要你懂太多知识！首先，你要基础理论知识比较扎实，按我的理解，无法独立完成一 个小的核心操作系统和编译器的人 和那种先天数学功底弱的人是没希望了！因为，当你抽象一个外部系统并建立自己的解决方案时，必然有现在还无法解决的问题，这时，你必然会对原有语言进行改 进，更牛的人甚至是设计自己的硬件！呵呵，进入这一境界，才算入世了！这时，语言已融入你的思想，不再是语言控制你，而是你控制语言了！可惜，目前中国还 没听说这号人出现，也许... 学C++和武侠里面的学剑差不多，大多数人只会用来劈材，少数人能够自立门派，为数不多的人能成为大师，至于心剑合一则是百年一遇！ 最后，路漫漫其修远兮！  秘籍：  [Lippman2000] Essential C++ Essential C++,by Stanley B. Lippman Addison Wesley Longman 2000,276 pages Essential C++ 中文版 ，侯俊杰 译，282页   [Gregory95] C++:The Core Language C++:The Core Language by Gregory Satir 1995 O'Reilly C++语言核心，张铭泽　译 ，236页 [Deitel98] The Complete C++ Training Course The Complete C++ Training Course 2/e by Harvey M.Deitel 1998 Prentice Hall C++大学教程(第二版)，邱仲潘等　译，816页 [Stevens2000] Standard C++ Bible Standard C++ Bible    2000   Al Stevens    IDG 标准C++宝典，林丽闽等 译，766页 [Eckel2000] Thinking in C++ Thinking in C++ 2/e    Bruce Eckel   2000 1470 pages Prentice Hall C++ 编程思想，刘宗田等 译，420页 [Lippman98] C++Primer C++ Primer,3rd Editoin,by Stanley Lippman and Josee Lajoie Addison Wesley Longman,1998 1237 pages C++ Primer 中文版，侯俊杰 译，1999，1237页 [Struostrup2000] The C++ Programming Language The C++ Programming Language,Special Editoin,by Bjarne Stroustrup Addison Wesley Longman,2000,1017 pages C++程序语言经典本，叶秉哲 译，儒林 1999 [ANSI C++] C++规格书 1998.9.1 PDF格式 ANSI C++ 1996 Draft 层级二：专家经验(C++/OOP) [Meyers96] More Effective C++ More Effective C++,by Scott Meyers,Addison Wesley,1996,318pages More Effective C++中文版，侯俊杰，培生 2000. 318页 [Meyers98] Effective C++ Effective C++，Second Edition,by Scott Meyers,Addison Wesley Longman,1998.256pages Effective C++ 2/e 中文版,侯俊杰,培生 2000.256页 [Sutter99] Exceptional C++ Exceptional C++，by Herb Sutter,Addison Wesley Longman,2000.208pages Exceptional C++中文版，侯俊杰,培生 2000.248页 [Sutter2001]More Exceptional C++ More Exceptiona

标准教程: 所有语言都是先看入门书,实际上看完入门书之后整个语言差不多就算学会了,可以做一些简单的程序,当然较复杂的也是可以做的. 然后你得看另一本入门书,因为大师写的书各有特色,仅看一本是远远不够的,也算是作为一种巩固扩展. 然后想要进一步提高的话就是看数据结构了,如果已经掌握的话随意,看完后功力能得到很大提升,对任何语言都是如此.因为数据结构是一种思想. 再下来得结合操作系统,比如windows或unix,也就是你说的mfc,其实就是很多操作系统的函数的库而已,调用这些函数可以写出windows下的程序. 底层的函数是windows API,稍高级点的就是mfc了,也就是api的进一步封装函数,调用一个mfc函数相当于调用很多api函数 达到这一步的话,你自然就会知道接下去学什么了,实际上我也只是看完入门书而已,也就是第一步~

可以先看看c++primer


Question: c语言求助

你的单科成绩是整数吗？如果是的话用浮点型输出又没有强制类型转换可能会出问题。

请问能告诉我为什么数字成员打印出来全是0

for(p=stud;p<stud+SIZE;p++) 不建议进行指针的比较  何不 p=stud;  for(int i=0;i<SIZE;i++) {    dosometing;   p++; }


Question: 新人求助！！！程序急用！！！无法运行！！！谢谢您了！代码贴上

#include <stdio.h> #include <stdlib.h> #include <math.h> #include <time.h> #define re 0.000001 #define PI 3.1415926 void main() {     FILE *fp;     int l,w;     double s,t,N_decay;     double q=0.01,D=0.02;     double p;     int a,b,c;     int i,j,k;     int index;     int count=0,response=100;     double rand_p;     double theta,phi;     int N_init=100,N_pore=0,N_walkers=0;     static int array[999][3];     static int cube[100][100][100];     static double X_old[100],Y_old[100],Z_old[100],X_new[100],Y_new[100],Z_new[100];     s=0.5*re;     p=2*q*s/3/D;     fp=fopen("D:\\test.txt","w");     for(i=0;i<N_init-1;i++) {         for(j=0;j<N_init-1;j++) {             for(k=0;k<N_init-1;k++) {                 cube[i][j][k]=1;                 if(pow((i-50),2)+pow((j-50),2)+pow((k-50),2)<=100) {                     cube[i][j][k]=0;                     array[N_pore][0]=i;                     array[N_pore][1]=j;                     array[N_pore][2]=k;                     N_pore++;                 }             }         }     }     N_walkers=N_pore;     if(N_init<N_pore) {         for(i=0;i<N_init-1;i++) {             index=(int) floor(rand()*N_pore);             X_old[i]=(array[index][0]+rand())*re;             Y_old[i]=(array[index][1]+rand())*re;             Z_old[i]=(array[index][2]+rand())*re;         }         N_walkers=N_init;     } else {         N_init=N_pore;         for(w=0;w<N_pore-1;w++) {             X_old[w]=(array[w][0]+rand())*re;             Y_old[w]=(array[w][1]+rand())*re;             Z_old[w]=(array[w][2]+rand())*re;         }         N_walkers=N_pore;     }     do {         for(i=0;i<N_walkers;i++) {             theta=rand()*2*PI;             phi=rand()*PI;             X_new[i]=X_old[i]+s*sin(phi)*cos(theta);             Y_new[i]=Y_old[i]+s*sin(phi)*sin(theta);             Z_new[i]=Z_old[i]+s*cos(phi);             a=(int)floor(X_new[i]/re);             b=(int)floor(Y_new[i]/re);             c=(int)floor(Z_new[i]/re);             if(cube[a][b][c]==0) {                 X_old[i]=X_new[i];                 Y_old[i]=Y_new[i];                 Z_old[i]=Z_new[i];             } else {                 rand_p=rand();                 if(rand_p<p) {                     for(l=i;l<N_walkers;l++) {                         X_old[l]=X_old[l+1];                         Y_old[l]=Y_old[l+1];                         Z_old[l]=Z_old[l+1];                     }                     N_walkers--;                 }             }         }         count++;         t=s*s/6/D*count;         if(count%response==0) {             N_decay=N_walkers/N_init;             fprintf (fp,"弛豫时间是%lf 衰减率是%lf \n",t,N_decay);         }     } while(N_walkers/N_init>0.01);     fclose(fp); }

引用 5 楼 zhao4zhong1 的回复:在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。 请问只是加一个static就可以了吗？在我这个程序里，还需要用malloc吗？谢谢了

引用 2 楼 talentwyb 的回复:meiyo没有 ，直接就说无法运行程序   无法运行程序，是程序被占用了？或者路径不对，还是什么？有其他提示吗

编译调施自己来——没有问题的问题是无法回答的问题，就是没有问题，也不是好问题！ 针对过程中的错误，在来求助如何？

引用 9 楼 sadadi 的回复: if(N_init<N_pore) {         for(i=0;i<N_init-1;i++) {             index=(int) floor(rand()*N_pore);             X_old[i]=(array[index][0]+rand())*re;             Y_old[i]=(array[index][1]+rand())*re;             Z_old[i]=(array[index][2]+rand())*re;         }   index 随机数的值 应该取余(%) 在合理范围内 index=(int)floor((double)rand()%N_pore);

meiyo没有 ，直接就说无法运行程序

D盘中有test.txt文件么


Question: C语言中关于字符串的一些问题

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式的值【比如printf("%p\n",...)】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=...】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

连续的内存：字符指针变量一次加1，内存是字节编址，一次过一个字节。当然是连续的内存！ 道理很简单，x初始化位1.每次加一，就是x[1,n],x属于N+(自然数)！这是个等差数列。在自然数范畴内，它是连续的

至少你这个例子中是连续的（指地址连续），不然的话你的string++就会崩掉。数据结构有很多种，有连续的，也有不连续的，这要看你是什么情况，根据不同的情况使用不同的数据结构。至于内存是怎么存储的，现在不必去深究，你只要知道数据在内存中是以什么样的数据结构存储的就OK了。计算机可表示的最小信息单位为“位”（bit），但计算机可存取的最小单位却不是位，而是字节，一个字符（比如字母）的大小就是一个字节，每一个字节有一个地址。

不知道楼主的内存单元具体大小是多少，如果一个内存单元存的下就是一个，存不下就用两个或三个等等

调试，ALT+6查看内存，你就懂了、、、

c的字符串只是指针而已，

比如char* str="abcdef"，给这个字符串分配的就是连续的7个字节，因为char类型占用一个字节。然后，str指针指向这个字符串的首地址。

连续的内存单元。 不知道你说的可能存在一个内存单元，这里面内存单元是什么含义。


Question: 用VC如何编写贪食蛇程序？

GDI、DirectX、OpenGL均可。


Question: 初学windows api多线程的疑问

超出int范围

printf不是线程安全的。  //循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef WIN32     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #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 WIN32 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,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 WIN32     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,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 WIN32     pthread_exit(NULL); #endif } int main() { #ifdef WIN32     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 WIN32     _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 WIN32     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; }

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。  检查是否资源泄漏的办法之一： 在任务管理器 进程 查看 选择列 里面选择：内存使用、虚拟内存大小、句柄数、线程数、USER对象、GDI对象 让你的程序(进程)不退出,循环执行主流程很多遍，越多越好，比如1000000次甚至无限循环，记录以上各数值，再隔至少一小时，越长越好，比如一个月，再记录以上各数值。如果以上两组数值的差较大或随时间流逝不断增加，则铁定有对应资源的资源泄漏！

引用 2 楼 hollebab 的回复:我虽然不懂多线程,不过我觉得应该线程数对特定的机器有上限值,你的已经达到上限了 感觉加上主线程好像只有三个线程吧，不是太多吧，是不是两个线程都用了printf占用同样的资源，是资源冲突引起的，可以用关键区或者互斥对象之间的线程同步方法保护一下这两个printf试试看

内存不够了 越界了

#include <STDIO.H> #include <WINDOWS.H> static int i=0; DWORD WINAPI ThreadProc(LPVOID lpParam) { 	while(TRUE) 	{ 		i++; 		printf("%d A new Thread.\n",i);                 Sleep(100); 	} 	return 0; } DWORD WINAPI ThreadProc2(LPVOID lpParam) { 	while(TRUE) 	{ 		i++; 		printf("\t%d A second Thread.\n",i);                 Sleep(100); 	} 	return 0; } int main() { 	HANDLE hThread[2]; 	DWORD dwThreadId; 	hThread[0]=CreateThread(NULL,0,ThreadProc,NULL,0,&dwThreadId); 	hThread[1]=CreateThread(NULL,0,ThreadProc2,NULL,0,&dwThreadId); 	WaitForMultipleObjects(2,hThread,TRUE,INFINITE); 	CloseHandle(hThread[0]); 	CloseHandle(hThread[1]); 	return 0; }

我虽然不懂多线程,不过我觉得应该线程数对特定的机器有上限值,你的已经达到上限了

为什么不调试?

哪有这样写代码的？两个线程各是一个死循环，没有退出机制，i很快就越界了。 当然，此问题很可能是多线程同时对i进行写造成资源访问冲突。


Question: 还是我！真的不会啊！

printf ("sum=%d t=%d p=%f\n", sum, t, p);

哈哈哈！刚脑门开了个洞！没想到！刚睡下 就想起来了！不过还是谢谢了！！

# include <stdio.h> main () {     int i, sum=0, t=0;//sum  总数     int p;     for (i=1; i<=100; ++i)     {         if (i%2!=0)         {             sum = sum+i;//1到100的奇数之和！             t = t+1;//1到100的奇数的个数！            }     }          p = sum/t;//求平均值！       printf ("sum=%d t=%d p=%d\n", sum, t, p);   }

两个问题； 一、p = sum/t;//求平均值！会产生数据丢失，int / int再传给float,改成 p = (float)sum / t; 二、格式化输出问题； p是float类型的数据，你用%d输出，能输出吗？？？ 改为p=%f

因为平均值是一个浮点数，输出的时候用%f而不是%d


Question: winddows对话框画动态图用C语言可以写吗，该如何做

不懂SDK，就是建一个windows对话框，然后再上面实现图形的移动

你讲得的是WIN32 SDK吗？


Question: 菜鸟请教C语言printf的问题

这个有什么疑问？因为你的是指针啊。当然会打印它的地址了

推荐楼主阅读我的博客文章《参禅与悟道——浅谈人生》，重点参考我的座右铭：人必有所不为然后可以有为。

引用 34 楼 ko1_1ok 的回复:[quote=引用 31 楼 afire22 的回复:] sizeof()  和 strlen()的区别一看就知道！基础没学好 好吧，那我也问你： 1、sizeof（数组名）的时候，返回数组的长度吗？ 2、strlen和sizeof都是库函数吗？ 3、sizeof是返回的值是在编译时决定的，还是在运行时决定的？  [/quote] 1.比如声明数组char a[20]，则sizeof（a）= 20，但strlen是根据有效字符来判断的，检测的是'\0'。如果声明的是字符串指针char* a = "hello";则sizeof(a)=4, strlen(a) = 5；数组名和指针有区别。因为数组的运算中，数组名还是要去调用指针的。 2.都是库函数 3.sizeof的值编译时就决定了

引用 36 楼 afire22 的回复:[quote=引用 34 楼 ko1_1ok 的回复:] [quote=引用 31 楼 afire22 的回复:] sizeof()  和 strlen()的区别一看就知道！基础没学好 好吧，那我也问你： 1、sizeof（数组名）的时候，返回数组的长度吗？ 2、strlen和sizeof都是库函数吗？ 3、sizeof是返回的值是在编译时决定的，还是在运行时决定的？  [/quote] 1.比如声明数组char a[20]，则sizeof（a）= 20，但strlen是根据有效字符来判断的，检测的是'\0'。如果声明的是字符串指针char* a = "hello";则sizeof(a)=4, strlen(a) = 5；数组名和指针有区别。因为数组的运算中，数组名还是要去调用指针的。 2.都是库函数 3.sizeof的值编译时就决定了 [/quote] 1.#include <stdio.h>  void show_array(int arr[]) { 	printf("the value of sizeof was %d\n", sizeof(arr) );  }  int main() { 	int arr[4] = { 		1,2,3,4 	}; 	 	show_array(arr); 	 	return 0; }  2.错

ch指针指向字符串，这个字符串sizeof就是4，一个字是4个字节

引用 28 楼 ko1_1ok 的回复:[quote=引用 25 楼 zhao4zhong1 的回复:] 奉劝楼主： 这辈子不用sizeof，完全不妨碍你成为软件开发高级工程师。  那你直接用01来完成编码，完全不妨碍你成为软件开发高级工程师 为什么要用编译器？还要发展计算理论做什么？[/quote] 你知道的太多了！ 啊——！……

引用 32 楼 zhao4zhong1 的回复:[quote=引用 28 楼 ko1_1ok 的回复:] [quote=引用 25 楼 zhao4zhong1 的回复:] 奉劝楼主： 这辈子不用sizeof，完全不妨碍你成为软件开发高级工程师。  那你直接用01来完成编码，完全不妨碍你成为软件开发高级工程师 为什么要用编译器？还要发展计算理论做什么？[/quote] 你知道的太多了！ 啊——！…… [/quote] 小辈与你相差甚远

sizeof()  和 strlen()的区别一看就知道！基础没学好

引用 31 楼 afire22 的回复:sizeof()  和 strlen()的区别一看就知道！基础没学好 好吧，那我也问你： 1、sizeof（数组名）的时候，返回数组的长度吗？ 2、strlen和sizeof都是库函数吗？ 3、sizeof是返回的值是在编译时决定的，还是在运行时决定的？

引用 30 楼 l5250926 的回复:[quote=引用 27 楼 ko1_1ok 的回复:] [quote=引用 24 楼 l5250926 的回复:] 你哪里用%c了？？？？printf(“%d”,sizeof(ch))就是输出指针变量ch的字节数塞，不是4是什么 引用 10 楼 shtenlll 的回复:用“char”的话“%d”要改成%c 我回复的是十楼的话。。  好吧，那l5250926： 那我问你， 1、sizeof为什么不输出字符串所占字节数长度 2、sizeof是什么？ 3、sizeof是返回的值是在编译时决定的，还是在运行时决定的[/quote]   sizeof是求类型的大小的！ sizeof（指针）返回的是ch变量本身的大小，至于你说的那些，我不知道，我也没必要去知道 问问题的人应该保持谦和的态度，即使别人回答错了，也是一片好心，lz学的东西还有很多，不仅仅是技术上的。[/quote] 以事论事，从上面的回答来看，也不是所有回答者都是一片好心，那我也不客气。如果语气不合适你的话，还望海涵

奉劝楼主： 这辈子不用sizeof，完全不妨碍你成为软件开发高级工程师。

引用 27 楼 ko1_1ok 的回复:[quote=引用 24 楼 l5250926 的回复:] 你哪里用%c了？？？？printf(“%d”,sizeof(ch))就是输出指针变量ch的字节数塞，不是4是什么 引用 10 楼 shtenlll 的回复:用“char”的话“%d”要改成%c 我回复的是十楼的话。。  好吧，那l5250926： 那我问你， 1、sizeof为什么不输出字符串所占字节数长度 2、sizeof是什么？ 3、sizeof是返回的值是在编译时决定的，还是在运行时决定的[/quote]   sizeof是求类型的大小的！ sizeof（指针）返回的是ch变量本身的大小，至于你说的那些，我不知道，我也没必要去知道 问问题的人应该保持谦和的态度，即使别人回答错了，也是一片好心，lz学的东西还有很多，不仅仅是技术上的。

引用 26 楼 u012514171 的回复:输出的是‘啊’（两个字节）的首地址  好吧，你给我解释下为什么吧

引用 25 楼 zhao4zhong1 的回复:奉劝楼主： 这辈子不用sizeof，完全不妨碍你成为软件开发高级工程师。  那你直接用01来完成编码，完全不妨碍你成为软件开发高级工程师 为什么要用编译器？还要发展计算理论做什么？

引用 24 楼 l5250926 的回复:你哪里用%c了？？？？printf(“%d”,sizeof(ch))就是输出指针变量ch的字节数塞，不是4是什么 引用 10 楼 shtenlll 的回复:用“char”的话“%d”要改成%c 我回复的是十楼的话。。  好吧，那l5250926： 那我问你， 1、sizeof为什么不输出字符串所占字节数长度 2、sizeof是什么？ 3、sizeof是返回的值是在编译时决定的，还是在运行时决定的

输出的是‘啊’（两个字节）的首地址

printf("the ch was:%08x\n", ch);

这小东西都不会啊，真是的

ch是char *，sizeof(ch)即sizeof(char *)，32位平台下输出4表示char指针是4个byte大小。


Question: 字符串处理大数据问题，自己测试没什么问题，提交不过，不知道错哪了

请贴题目. 建议检查输出格式是否符合要求.

scanf("%1009s%1009s",as[i],bs[i]);  防止越界。

引用 7 楼 fendouqingchun123 的回复:谢谢，不过我刚试了，答案还是错误 编译器，版本号？

谢谢，不过我刚试了，答案还是错误

引用 5 楼 fendouqingchun123 的回复:是要加句  if(1<=t<=20)  吗？  嗯，是的，也可以   t = t % 20 + 1;

是要加句  if(1<=t<=20)  吗？

是不是输入没有取地址符

引用 2 楼 fendouqingchun123 的回复:最多有20组数据，每次只计算其中一组a+b之和，所以定义为二维数组，但每次调用只用其中一行数据  scanf("%d",&t);   t的合法边界没有检测。

char as[20][1010],bs[20][1010],cs[20][1010];   二维数组到后面怎么又变成一维了？


Question: 谭浩强C程序设计中一道作业题

解决了，妹的，开辟内存的时候忘了乘以单位 也就是指针的size了

for (int i = 0; i < num_count; i++)     {         printf("%s\n", *nums);         free(*nums);     } 这里，如果free第一次释放之后，*nums无指向了。但是我没看完，也没看懂。而且LZ这种算法有点渣，且浪费内存

顶住顶住顶住

顶一下，在线等。。。


内存中是已经修改了的，但是因为编译器的处理，导致一些代码变量在运行前直接被替换了，而不是运行时对内存访问来输出数据。

const folding和copy propagation的问题。 http://blog.csdn.net/tobebetterprogrammer/article/details/25333613


Question: 谁帮忙看看这个斐波那契数列的问题出在哪啊

引用 8 楼 a515360208 的回复:[quote=引用 6 楼 mimimayia 的回复:] [quote=引用 1 楼 a515360208 的回复:] 斐波那契数列定义的初始条件你都弄错啦， F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*） 我没有用递归,因为我看不懂 我一直没弄明白这句程序怎么执行 Fn=F(n-1)+F(n-2)（n>=2，n∈N*）[/quote] 是递归不明白还是什么不明白？？？ 递归要多调试菜懂的、、、、[/quote] 就是不明白Fn=F(n-1)+F(n-2)这句怎么执行 我看过别人编的递归的,可是怎么也不明白程序到哪去找这几个参数

引用 7 楼 longburulin 的回复:[quote=引用 5 楼 mimimayia 的回复:] [quote=引用 2 楼 longburulin 的回复:] #include <stdio.h> int  main(){ long long  a1,a2,a3,N; a1=1; a2=2; scanf("%lld",&N);  if (N==0||N==1||N==2){ printf("%lld",N); } else if(N>2 && N<=50){  for(int i=2;i<N;i++){  a3=a1+a2; a1=a2; a2=a3; } printf("%lld",a3);}  else  { printf("wrong number"); }     return 0; } 用long long 就可以了 这个我也改了,改完之后还是通不过,不过我觉得也有道理,可是我两个地方都错了吧  [/quote]哪里通不过？ 应该是可以的 除了F0=1;其他都能得出正确结果啊[/quote] 已经过了,除了你说的这个改 了 还有就是1,1,2,3那个位置,加上个1就对了,谢谢啊

引用 6 楼 mimimayia 的回复:[quote=引用 1 楼 a515360208 的回复:] 斐波那契数列定义的初始条件你都弄错啦， F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*） 我没有用递归,因为我看不懂 我一直没弄明白这句程序怎么执行 Fn=F(n-1)+F(n-2)（n>=2，n∈N*）[/quote] 是递归不明白还是什么不明白？？？ 递归要多调试菜懂的、、、、

引用 5 楼 mimimayia 的回复:[quote=引用 2 楼 longburulin 的回复:] #include <stdio.h> int  main(){ long long  a1,a2,a3,N; a1=1; a2=2; scanf("%lld",&N);  if (N==0||N==1||N==2){ printf("%lld",N); } else if(N>2 && N<=50){  for(int i=2;i<N;i++){  a3=a1+a2; a1=a2; a2=a3; } printf("%lld",a3);}  else  { printf("wrong number"); }     return 0; } 用long long 就可以了 这个我也改了,改完之后还是通不过,不过我觉得也有道理,可是我两个地方都错了吧  [/quote]哪里通不过？ 应该是可以的 除了F0=1;其他都能得出正确结果啊

引用 1 楼 a515360208 的回复:斐波那契数列定义的初始条件你都弄错啦， F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*） 我没有用递归,因为我看不懂 我一直没弄明白这句程序怎么执行 Fn=F(n-1)+F(n-2)（n>=2，n∈N*）

引用 2 楼 longburulin 的回复:#include <stdio.h> int  main(){ long long  a1,a2,a3,N; a1=1; a2=2; scanf("%lld",&N);  if (N==0||N==1||N==2){ printf("%lld",N); } else if(N>2 && N<=50){  for(int i=2;i<N;i++){  a3=a1+a2; a1=a2; a2=a3; } printf("%lld",a3);}  else  { printf("wrong number"); }     return 0; } 用long long 就可以了 这个我也改了,改完之后还是通不过,不过我觉得也有道理,可是我两个地方都错了吧

引用 3 楼 Baoge_leopard 的回复:你的这个程序没问题，只是第一个数是从1开始的，斐波那契数列变成了1、2、3、5、8、13…… 原来是缺个1,郁闷,


Question: DevC++ 在编译后调试时却弹出对话框“源文件未编译”

提示已经很清楚了，少提示里面对应的文件。 可能你DevC++安装不全

http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装

引用 2 楼 zhao4zhong1 的回复:No such file or firectory 都提示 No such file or directory 了

No such file or firectory

吃饱了撑的你，文件名带空格。


Question: 想学汇编的看进来

第一个下载了，第二个打不开

好高端的样子，ding一个

引用 4 楼 TheNewIpad 的回复:有Intel汇编语言程序设计简单易学？ arm显得指令更简洁易懂一些，虽然有时重复比较集中候看起来繁琐，但对新手来说相对友好。  不选powerpc和mips也有原因，powerpc有些寄存器的不同位表示了不同信息，但偏偏又要用到，用起来的时候感觉缚手缚脚的比较蛋疼。  mips条条框框比较多，需要顾及cpu的特性。

引用 5 楼 hollebab 的回复:虽说是x86汇编,但windows下和linux下又有区别,我无语,这是每个系统都要学一遍吗> 学汇编是让你理解cpu工作的方式，并不是让你直接用来写代码 除开原厂的工程师，基本上大部分程序员很难用汇编写几行代码。

引用 4 楼 TheNewIpad 的回复:有Intel汇编语言程序设计简单易学？ 你让一个新手连指针都没玩透就去玩x86各种蛋疼的寻址方式，不把他们搞晕才怪

有Intel汇编语言程序设计简单易学？

想学。但是它真的好难。作为深入理解计算机系统的基础吧

引用 1 楼 zhao4zhong1 的回复:据说arm不支持非对齐的双字读写。 RISC通病，基本都有一些要求，要在编码上迁就CPU

据说arm不支持非对齐的双字读写。


Question: 使用冒泡排序的时候出现的异常

for (b=0;b<6-k;b++) 造成问题的原因基本上是不好的习惯导致的，

16行b++  引用 楼主 k91191 的回复:中断指向第22行，但是把第21行删掉后又能成功运行，这是为什么？ 把第21行删掉后又能成功运行？？？ 你确定？  一个简单的冒泡排序没必要#define吧  # include <stdio.h>  void sort(int * a, int len);  int main(void) { 	int a[6] = {10, 2, 8, -8, 11, 0}; 	int i;  	sort(a, 6);  	for (i=0; i<6; ++i) 	{ 		printf("%d ", a[i]); 	} 	printf("\n");  	return 0; }  //冒泡排序 void sort(int * a, int len) { 	int i, j, t;  	for (i=0; i<len-1; ++i) 	{ 		for (j=0; j<len-1-i; ++j) 		{ 			if (a[j] > a[j+1])  // >表示升序 <表示降序 			{ 				t = a[j]; 				a[j] = a[j+1]; 				a[j+1] = t;  			} 		} 	} }

引用 3 楼 u012514171 的回复:void pai (int a[]) /*对数组进行排序*/ {     int k,b,tem;     for (k=1;k<7;k++)     {         for (b=0;b<6-k;a++)//b++         {             if (a[b]>a[b+1])             {                 tem = a[b];                 a[b] = a[b+1];                 a[b+1] =tem;             }         }     } }第一个循环k = 1还有第二个for循环的第三个参数是b++

void pai (int a[]) /*对数组进行排序*/ {     int k,b,tem;     for (k=1;k<7;k++)     {         for (b=0;b<6-k;a++)         {             if (a[b]>a[b+1])             {                 tem = a[b];                 a[b] = a[b+1];                 a[b+1] =tem;             }         }     } }第一个循环k = 1

引用 楼主 k91191 的回复:void pai (int a[]) /*对数组进行排序*/ { 	int k,b,tem; 	for (k=0;k<7;k++) 	{ 		for (b=0;b<6-k;a++) // 这一行貌似有问题 		{ 			if (a[b]>a[b+1])  // ？ 			{ 				tem = a[b]; 				a[b] = a[b+1];  // ？ 				a[b+1] =tem;   // ？ 			} 		} 	} } [  冒泡排序也搞得这么复杂

第二个循环for (b=0;b<6-k;a++)？

for (b=0;b<6-k;a++)  这个a++是怎么个意思捏？

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。


Question: 关于二级指针的问题

第一个没有内存，第二个有内存，比如int a[]跟int *a的区别。。

引用 13 楼 zhao4zhong1 的回复:[quote=引用 12 楼 hjgzj 的回复:] [quote=引用 1 楼 zhao4zhong1 的回复:] #pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  果然是一处复制 到处粘贴啊   请给我用你的模版的权利 不然我举报你作弊[/quote] 本ID所有回帖内容遵循GPL协议。[/quote]

引用 6 楼 u010059563 的回复:那请问**q和*q[]的区别是什么？ 一个是指针的指针，一个是指针数组。

引用 12 楼 hjgzj 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] #pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  果然是一处复制 到处粘贴啊   请给我用你的模版的权利 不然我举报你作弊[/quote] 本ID所有回帖内容遵循GPL协议。

引用 1 楼 zhao4zhong1 的回复:#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  果然是一处复制 到处粘贴啊   请给我用你的模版的权利 不然我举报你作弊

有两点提示： 1.**menu是一个指向字符串的二级指针变量；*menu[]是一个一级指针变量数组；前者一个，后者多个；前者二级，后者一级；前者单个变量，后者数组； 2.数组初始化可以不指定维数，有初始化成员个数决定。

有两点提示： 1.**menu是一个指向字符的二级指针变量；*menu[]是一个一级指针变量数组；前者一个，后者多个；前者二级，后者一级； 2.数组初始化可以不指定维数，有初始化成员个数决定。

一个在栈区，一个在代码区，你说行吗？

你的数组里面实际存的是char* 类型的。一般多级指针我是先用typedef取个别名，然后再用就不会弄混了。比如楼主的数组，可以先typedef char* pchar；pchar* menu[]{}； 这样我觉得要好理解一些。 因为楼主的数组是双重指针，所以用的时候是不是要解引用两次，但是实际存的是char*，解引用两次就会出错了。解引用一次已经得到字符串了，再次解引用的话就会出错了，把数据当地址来用了。个人见解而已，仅供楼主参考~

那请问**q和*q[]的区别是什么？

二级的指针 就是指向地址的地址

没内存你往哪里放数据呢。

不行就换一种呗！ 不要嫌麻烦。。。。。。。  。。。。。。。。容我吐槽一句：为什么我们学校是先上数据结构再上离散数学。。。。。。。。。。。。

char **menu是一个指针，不过是二级指针  *menu[]是一组指针，每一个是一级指针  用二级指针时必须有一级指针（一个或一组）”过渡“，才能用来引用对象  二级指针用法的形象比喻： 你（二级指针）知道有个人（一级指针），他拥有所有房间的钥匙（多个对象）。 但现在那个”他“是谁、在哪？不知道！

引用 楼主 u010059563 的回复:char **menu = { 	"a - add new record", 	"d - delete record", 	"q - quit", 	NULL,  }; 我通过这种方式赋值，结果在运行的时候出现段错误，但是换成*menu[]后，就不会出现错误，请大神指教，关于这方面的问题我好纠结啊！ 如果你会使用%p格式输出指针值（地址的话），你可以看到menu指针指向了串的首字符‘a',它会将从’a'开始的四个字符当作指针用，'a'的码值是0x61，指针值最后一个字节就是0x61


Question: 输出十六进制数据的奇怪...

%x 输出的是无符号的小写十六进制  输出的ffffffd6对应的32位整数是-42

还有buffer[i]的值无法赋到memory[a]中


Question: 求一个三层交换机的代码实现！！

牛逼的华为有没有出G级别的Wi-Fi路由器？

三层交换机有路由的功能，但它终究不是路由器，还是交换机！

引用 12 楼 Symfund 的回复:你这个贴我要顶上 了  三层交换机其实就是一个在硬件层面上实现了快速前转的路由器.  IP前转(IP forwarding)典型地涉及到路由查找(route lookup)，TTL计数器(TTL count)自减，重新计算checksum，  基于layer 3 路由协议有：IP, IPX, AppleTalk  （三层交换机其实就是一个在硬件层面上实现了快速前转的路由器.）这几话不能这么说！！

研究下一代的路由器吧，10Gbps的Wi-Fi路由器已经出来了，性能不再是问题了！  802.11ac, multiuser-MIMO, Broadcom, Qualcomm, VIVE,   Asus的1.7GbpsWi-Fi路由器已经上市了，  你的算法再好，也比不上上成的硬件！

Linux就是一个“三层交换机”

扯远了！！。。

说来说去，一切都归于算法，数学。微积分都能搞定，非线性的图，分形都能搞定，这个应该能搞定吧。

forwarding algorithm  前转算法  在硅芯级上实现前转算法哦！

按照这个Layer 3 switch东西顺藤摸瓜，一目了然，轻车熟路，豁然开朗。  Layer-3 switch vs. router ASICs, QoS, Netflow 路由器需要更多的CPU与horsepower(马力）

引用 4 楼 Symfund 的回复:我虽然不懂，但猜对了，三层交换机的翻译确实是：Layer 3 switch 你有没有去百度一下，，看都是什么？？

你这个课题很好，收藏了！

我虽然不懂，但猜对了，三层交换机的翻译确实是：Layer 3 switch

请给出三层交换机当中所有涉及到的英文关键词，比方说：  三层？ --> layer 3 ?  交换机  -> switch ?  算法 -> algorithm  路由 -> route  ISO,

引用 楼主 u012889234 的回复:求一个三层交换机的代码实现！！   邮箱  1505086281@qq.com 百度，，谷歌都没找到啊，找了半天！！

哈哈，伸手党，都懒得找开源代码了？


Question: string 问题

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

等效与等价！ 有位网上writer（高手！）用过”等效与等价“的说法及相关探讨。  等效是指，两个形式上不同的讨论对象，在某些情况下有同样（或者相似）的效果，但并不能将这种相同、相似扩展到所有情况下  等价是指，两个形式上不同的讨论对象，在所有情况下是相同的，即实际上这两个对象本质上是同一个、而形式上不同而已（典型例子就是一维数组元素引用时的a[i]与*(a+i)）  char*(char [ ])对象与string 对象是等效关系，某些时候是有相同效果，但不是等价关系。

楼主要散分哦，至少给我一半的分！

#include <cstdio> #include <string> #include <iostream> using namespace std;  int main(int argc, char* argv[]) { 	string str= "sdf"; 	str += "asdgvsd"; // string类型支持+=运算符重载操作 	cout << str << endl; // cout会根据str的类型智能输出 	printf("%s\n",str.c_str()); // printf支持的是C字符串，因此需要用c_str进行转换  	return 0; }

你看是不是加掉了头文件string #include <iostream> #include <string> using namespace std;  int main() { 	char *p = "asdfag";  	string str = "sdf"; 	str += "asdgvsd";  	cout << str << endl;  //%s输出的是字符串，后面要有'\0'，而string类型是没有'\0'的，要做一个转换 	printf("%s", str.c_str()); 								 	return 0; }

首先，string是一个类，char* 是一个指针类型。 string对+=进行了+的操作符重载，我记得+=会因为+重载了而自动重载。在这里，+=就相当于string.h中的strcat，是对字符串的拼接。 string应该使用流操作，即cout<<str;显示没有匹配操作，是因为楼主没有引用string头文件，或者其他可能的原因。在string类中，对<<操作符的重载是已经有的。左操作数为流对象引用，右操作数为string对象。

cout<<str;//为什么这里会显示无匹配操作符，编译是怎么编译的  string 类的 << 重载定义声明和实现在<string>中，楼主包含了这个头文件了没啊？    printf("%s",str);//当改为printf输出时为什么初始赋值是乱码，后面添加的字符串有错  string通过printf打印不是这么干的 应该是 printf("%s", str.c_str());

char *p="asdfag"; string str="sdf"; str += "asdgvsd";//这个追加在编译时不会有错 cout << str.c_str();//为什么这里会显示无匹配操作符，编译是怎么编译的 printf("%s",str.c_str());//当改为printf输出时为什么初始赋值是乱码，后面添加的字符串有错   str += "asdgvsd";//这个追加在编译时不会有错，是因为string类重载了操作符+=，支持char *类型 cout << str.c_str();//为什么这里会显示无匹配操作符，编译是怎么编译的 -> cout 不支持string数据类型，支持char, char*类型 printf("%s",str.c_str());//当改为printf输出时为什么初始赋值是乱码，后面添加的字符串有错 -> printf只支持char, char *类型。


Question: 关于二级指针的疑惑

不懂，看看大神怎么说

一定要使“每一级”的指针都得到初始化 使TA们准确的指向一个内存。静态内存、栈或堆都可以的。

1. re      = (double **)malloc(2*sizeof(double *));若此语句执行成功，则re为“2个具连续地址的指向浮点数的一级指针”的首地址。    2. *re是“第一个指向浮点数的一级指针”的地址，但这个地址里的内容是不定的（未经过初始化，在使用**re之前，你还得再初始化*re）。所以下标访问方式(*re)[x]不能代表一个正确的内存（作值时代表一块内存）。而且x的最大值也只能为1。    你用笔在纸上画画，或许有点帮助的说    建议将指针初始化为NULL，然后在malloc后再判断一下指针是否为NULL后再使用。

CSDN的脚本嵌套出问题了！ 引用，代码，span  <引用>     <C++代码>         <红色高亮>         </红色高亮>     </C++代码> </引用>

引用 楼主 u012789847 的回复:虽然知道二级指针是指向指针的指针   但是还是觉得有些疑惑的地方，以下是自己写的一个程序，就是矩阵求差，但是总是会报错，能否指点一下。  #include <stdio.h> #include <stdlib.h>    int function(double *p, int p_r, int p_c, double *q, int q_r, int q_c, double **re) { 	int i; 	int j;   	if(p==NULL||q==NULL){ 		*re     = NULL; 		return 1; 	}   	if(p_r!=q_r||p_c!=q_c){ 		*re     = NULL; 		return 1; 	}   	if(p_r*p_c>1024||q_r*q_c>1024){ 		*re     = NULL; 		return 2; 	}   	// *re指向的存储空间未分配，你自己补上吧！这个错误有CSDN的网友已经指出。 	for(i=0; i<p_r; i++){ 		for(j=0; j<p_c; j++){ 			(*re)[i*p_r+j]  = p[i*p_r+j]-q[i*p_r+j]; // 此处你怎么能将p_r行p_c列的数组按p_r列p_c行来处理呢，这个错误大部分CSDN网友都没有发现！ 		} 	}   	return 0; }   int main() { 	double  p[2][3] = {1,2,3,4,5,6}; 	double  q[2][3] = {1,1,1,1,1,1}; 	double  *re;   	int     i; 	int     j;   	function(p, 2, 3, q, 2, 3, &re);   	for(i=0; i<2; i++){ 		for(j=0; j<3; j++){ 			printf("%3d\n", re[i][j]); 		} 	}   	return 0; }   楼主的思维乱得像一坨浆糊！请看红色标亮的地方！ 正确的代码如下：  #include <stdlib.h>  int function(double *p, int p_r, int p_c, double *q, int q_r, int q_c, double **re) { 	int i; 	int j;     	if(p==NULL||q==NULL) 	{ 		*re     = NULL; 		return 1; 	}    	if(p_r!=q_r||p_c!=q_c) 	{ 		*re     = NULL; 		return 1; 	}    	if(p_r*p_c>1024||q_r*q_c>1024) 	{ 		*re     = NULL; 		return 2; 	}  	*re = (double *)malloc(p_r * p_c * sizeof(double));    	for(i=0; i<p_r; i++) 	{ 		for(j=0; j<p_c; j++) 		{ 			(*re)[i*p_c+j] = p[i*p_c+j]-q[i*p_c+j]; 		} 	}    	return 0; }  int main() { 	double  p[2][3] = {1,2,3,4,5,6}; 	double  q[2][3] = {1,1,1,1,1,1}; 	double  *re;    	int     i; 	int     j;    	function(*p, 2, 3, *q, 2, 3, &re);    	for(i=0; i<2; i++) 	{ 		for(j=0; j<3; j++) 		{ 			printf("%f ", re[i*3+j]); 		} 		printf("\n"); 	}  	free(re); 	re = NULL;   	return 0; }

48:2: warning: passing argument 7 of 'function' from incompatible pointer type [enabled by default] 4:5: note: expected 'double **' but argument is of type 'double ***' 是因为：  double  **re; 为re动态分配空间后，re作为function的最后一个参数时不必再取地址。

引用 4 楼 u012789847 的回复:In function 'function': 26:33: error: invalid operands to binary - (have 'double' and 'double *')  In function 'main': 48:2: warning: passing argument 7 of 'function' from incompatible pointer type [enabled by default] 4:5: note: expected 'double **' but argument is of type 'double ***' 错误提示这这样的  你这个错误就是申请内存时，返回的是一级的内存指针，你却将其当作二级指针来用，第二个错误就是将二级指针取地址，也就是变成三级指针当参数来调用，而事实上函数的参数应该是二级指针。

指针事实上就是一个int，不过这个int的数值是一个内存地址，也就是指针就是用来保存一个地址的，也就是指向一个地址，当我们使用取值符*的时候，也就是到这个地址里取回其保存的值，二级指针很简单，就是这个指针里保存的是一个地址，按着这个地址找到的内存中保存的依然是一个内存地址。   (*re)[i*p_r+j]  = p[i*p_r+j]-q[i*p_r+j];  这一句是有很严重的问题的 你先声明了一个指针re，然后再用另一个指针指向这个指针，当你使用*re的时候，取的是你一开始声明的指针值，得到的结果就是一开始的double  *re，这个二级指针的使用是正确的。 但如果再次使用[]进一步读取的，也就是要读取double  *re所指向的内存就错误了，因为double  *re事实上是一个野指针，你根本没有给它赋值过 你可以这样用：double r[6]，然后是double *re = r;就可以了

1 #include <stdio.h>   2 #include <stdlib.h>   3   4 int function(double *p, int p_r, int p_c, double *q, int q_r, int q_c, double **re)   5 {   6   7         int i;   8         int j;   9  10         if(p==NULL||q==NULL){  11                 *re     = NULL;  12                 return 1;  13         }  14  15         if(p_r!=q_r||p_c!=q_c){  16                 *re     = NULL;  17                 return 1;  18         }  19  20         if(p_r*p_c>1024||q_r*q_c>1024){  21                 *re     = NULL;  22                 return 2;  23         }  24         for(i=0; i<p_r; i++){  25                 for(j=0; j<p_c; j++){  26                         (*re)[i*p_r+j]  = *(p+i*p_r+j)-(q+i*q_r+j);  27                 }  28         }  29  30         return 0;  31 }  32  33 int main()  34 {  35         double  p[]     = {1,2,3,4,5,6};  36         double  q[]     = {1,1,1,1,1,1};  37         double  **re;  38  39         int     i;  40         int     j;  41  42         re      = (double **)malloc(2*sizeof(double *));  43  44         for(i=0; i<2; i++){  45                 p[i]    = (double *)malloc(3*sizeof(double));  46         }  47  48         function(p, 2, 3, q, 2, 3, &re);  49  50         for(i=0; i<2; i++){  51                 for(j=0; j<3; j++){  52                         printf("%3d\n", (*re)[i*2+j]);  53                 }  54         }  55  56         return 0;  57 } 还是会出错    不知道中间有地方写错了没有？

都没有为re分配内存啊，怎么玩呢？

（1）照你题目要求，根本不需要二级指针 （2）如果你要用二级指针返回，需要开辟内容空间


Question: 我想高手们给我指出我这个程序框架的问题

其实我就是想以提问形式做一个程序，但是以我现在的知识还不能做出来，想找人帮忙！

char ch;  do {     scanf("%c", &ch);      switch (ch)     {         case '1':             printf("Question 1 is:");             break;         default:             break;     }  } while (ch != 'e' );

需求是哈？？？问题都描述不清楚，谁会回复？

怎么就没有人回复？


Question: window获取各个网卡总的发包大小和收包大小

dwInOctets和mi.dwOutOctets都是DWORD类型的，如果流量超过4G，需要怎么处理才能正确显示，谢谢！

还有一个就是 因为mi.dwInOctets和mi.dwOutOctets都是DWORD类型的，当你实际接收发送字节数超出了DWORD能表示的范围，实际上4GB是很容易超出的，mi.dwInOctets和mi.dwOutOctets溢出之后就是又从0开始记得

引用 4 楼 ztjfromnowon 的回复:这个在win7下好像不能获取到正确的值。。。。。？？  我的本机就是win7的 测试是没有问题的   注意mi.dwInOctets和mi.dwOutOctets是目前接受和发送的总量，你如果是要每秒或者每分钟的数据，需要用本次总量-上次的总量

http://blog.csdn.net/yy405145590/article/details/9242463 看看这个.

引用 3 楼 zilaishuichina 的回复:__int64 CPerfInfo::GetNetBytes() { 	char *buff = NULL; 	DWORD dwSize = 0;  	IP_ADAPTER_INFO *pInfo = NULL; 	if (ERROR_BUFFER_OVERFLOW == GetAdaptersInfo(pInfo, &dwSize)) 	{ 		buff = new char[dwSize]; 		if (buff == NULL) 		{ 			return 0; 		}  		pInfo = (IP_ADAPTER_INFO *)buff; 		if (NO_ERROR != GetAdaptersInfo(pInfo, &dwSize))  		{ 			delete[] buff; 			return 0; 		}  		MIB_IFROW mi; 		while (pInfo) 		{ 			mi.dwIndex = pInfo->Index; 			if(NO_ERROR == GetIfEntry(&mi)) 			{ 				if (mi.dwOperStatus == IF_OPER_STATUS_CONNECTED || mi.dwOperStatus == IF_OPER_STATUS_OPERATIONAL) 				{ 					delete[] buff; 					return mi.dwInOctets + mi.dwOutOctets;//这就是接收字节和发送字节数 				} 			}  			pInfo = pInfo->Next; 		}  		delete[] buff; 		return 0; 	} 	else 	{ 		return 0; 	} }   这个在win7下好像不能获取到正确的值。。。。。？？

在MSDN里面搜“PDH Counter”

引用 楼主 ztjfromnowon 的回复:在window下，有什么api可以直接获取到网卡的总的发包大小和收包大小 吗 ？？ 求大神指教 linux下设备net_device结构，dev里面相关成员记录。 例如： net_device->stats->rx_packets++; net_device->stats->rx_bytes += skb->len;  windows这大爷我不知道


Question: 《数字游戏》问题求解

标准答案的时间规模是t，而你的程序规模是2*n*t。很明显，当n和t都很大的时候，标准答案时间复杂度O(n)，你的答案时间复杂度O(n^2)。 不论多少个人的报数，你只用考虑这个栋栋！人数大小只是改变栋栋报的每两个数之间的差值。如果是1个人，那么栋栋第一次和第二次报数差1，如果两个人，差3，如果三个人，差6，以此类推。把这个差值把握好，就可以得出op1的公式了，然后剩下的操作都很简单，最后把total输出。 而且程序完全不用数组来存储栋栋报的数字，因为最后只求和，所以不用浪费内存。

没有人回复呢。。求帮助。。


Question: 屏幕一行输入不下怎么办? "\"这符号怎么称呼?

这个叫 “续行符”， 用这个关键词去搜吧


Question: while循环中的malloc与free出错

非常感谢各位高手，问题解决了，是数组初始化的问题，不过感觉比较奇怪，原本以为calloc函数分配内存之后会随即将内存中的值置零，结果在Debug的时候发现并非如此，不知是何原因。

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。

仅供参考//使用动态分配 #include <stdio.h> #include <stdlib.h> #include <malloc.h> int i,L; char *p; void main() {     for (i=0;i<20000;i++) {         L=rand();         p=malloc(L);         if (NULL==p) {             printf("malloc error!\n");             continue;         }         memset(p,0,L);         free(p);     } } //不使用动态分配 #include <stdio.h> #include <stdlib.h> #include <memory.h> #define MAXLEN 30000 int i,L; char buf[MAXLEN]; char *p; void main() {     p=&buf[0];     for (i=0;i<20000;i++) {         L=rand();         if (L>MAXLEN) {             printf("L>MAXLEN==%d, ignore spilth.\n",MAXLEN);             L=MAXLEN;         }         memset(p,0,L);     } }

free失败无非这两种情况： 1 内存越界，free的时候free多了。检查中间任何和内存写有关的地方。这种问题一般是必现 2 内存破坏，相邻的内存越界。检查所有内存拷贝和内存写的地方。这种问题一般非必现。  楼主的应该是内存破坏。你在调试状态，把出错的指针在memory里，看看相邻内存里的内容是啥

感觉会不会是malloc失败？给if加上else，在else中free并置NULL试试

谢谢user-5和adlay！  1. 因为看到有的书上讲指针变量free之后，应当将其设置为NULL，以免出现错误，这个错误可能真是编译系统不同引起的。  2. 完整的代码比较长，我截取其中与Ai和Ax相关的一段：   #define NONZEROLIMIT 1.0e-8  while(iteration_flag) { 			//................  			//------------------------------------------ 			num_non_zero = 0;  			for (i_dof_struc = 0; i_dof_struc<num_dof_struc; i_dof_struc++) 			for (j_dof_struc = 0; j_dof_struc<num_dof_struc; j_dof_struc++) 			if (fabs(A[i_dof_struc][j_dof_struc])>NONZEROLIMIT) 				num_non_zero++;  			//------------------------------------------ 			Ai = (int *)malloc(num_non_zero * sizeof (int)); 			if (!Ai) printf("Allocation problem for Ai !!!");  			Ax = (double *)malloc(num_non_zero * sizeof (double)); 			if (!Ax) printf("Allocation problem for Ax !!!");  			SYS_Zero_Vec(num_dof_struc, x);  			i_non_zero = 0; 			k = 0; l = 0; m = 0;  			for (j = 0; j<num_dof_struc; j++) 			{ 				for (i = 0; i<num_dof_struc; i++) 				{ 					if (fabs(A[i][j])>NONZEROLIMIT) 					{ 						i_non_zero++; 						Ai[l++] = i; 						Ax[m++] = A[i][j]; 					} 				} 			}  			//------------------------------------------  			(void)umfpack_di_symbolic(num_dof_struc, num_dof_struc, Ap, Ai, Ax, &Symbolic, NULL, NULL); 			(void)umfpack_di_numeric(Ap, Ai, Ax, Symbolic, &Numeric, NULL, NULL); 			umfpack_di_free_symbolic(&Symbolic); 			(void)umfpack_di_solve(UMFPACK_A, Ap, Ai, Ax, x, B, Numeric, NULL, NULL); 			umfpack_di_free_numeric(&Numeric);  			free(Ax); Ax = NULL; 			free(Ai); Ai = NULL;                          //.........  }   其中 A为一个方阵，这段代码是调用UMFPACK库函数求解代数方程组Ax=B，在某次迭代中，Ai与Ax分配好内存大小之后，访问它们的时候应该没有越界，不知道可能是什么原因？

估计是中间访问 Ai 和 Ax 越界了 还是给完整代码吧，这样看不出问题的。

free后的指针最好不用，不同的编译系统处理不同，如果用了，会留下隐患。


Question: 还是我！还是一样的问题！

请你以后写判断的时候常量写在前面 0 == x  当你写成0=x的时候编译器就会报错的

引用 1 楼 zhao4zhong1 的回复:x=0和x==0不是一回事！ +1   对于==的使用，编程规范一般要求某个变量和数字相等比较，数字放在左操作数，变量名放在右操作数，比如这样写： 0 == x

引用 1 楼 zhao4zhong1 的回复:x=0和x==0不是一回事！  ++++

x=0和x==0不是一回事！


Question: 循环体内数组定义问题

#include <stdio.h>  int main() {     int a = 3;     int i =0;     for(;i<=a;i++)         int b[5] ={2};     printf("%d\n",b);     return 0; } 编译不通过

引用 5 楼 zhao4zhong1 的回复://编写程序输出下列图形： //00001 //00010 //00100 //01000 //10000 #include <stdio.h> int main() {     int i;      for (i=0;i<5;i++) printf("%.5s\n","000010000"+i);     return 0; }  赞一个~~

如果按照下面的程序运行就可以正常输出图形

引用 11 楼 a515360208 的回复:[quote=引用 9 楼 u013955671 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] //编写程序输出下列图形： //00001 //00010 //00100 //01000 //10000 #include <stdio.h> int main() {     int i;      for (i=0;i<5;i++) printf("%.5s\n","000010000"+i);     return 0; }  赞！！！！可是这是怎么实现的呀没看懂[/quote] "00001000"也有一个地址，%s都是从字符串指向的地址开始的，上面的程序等价于：  char *p = "000010000"; for (i=0;i<5;i++)     printf("%.5s\n", p + i);[/quote] 牛逼啊，我等还得加倍学习！

数组只能在定义时整体赋值，其他任何时候都只能单独操作一个元素 理所当然的，一个数组不能定义两次，所以你自以为重设数组内容的那条语句实际上是定义了一个新的没用的数组

引用 5 楼 zhao4zhong1 的回复://编写程序输出下列图形： //00001 //00010 //00100 //01000 //10000 #include <stdio.h> int main() {     int i;      for (i=0;i<5;i++) printf("%.5s\n","000010000"+i);     return 0; } 给你点赞，

引用 8 楼 u013955671 的回复:[quote=引用 3 楼 PDD123 的回复:] 第二个能正确显示。 在花括号括起来的程序段内外有相同名字的变量时，程序段优先使用的是花括号内的变量，第一个程序中在定义括号内的a前用的是括号外的a，而定义括号内的a时使用的是另外的空间，并没有把括号外的a的值进行重置。  第二个虽然正确，但是括号外的a不起作用，最好删了。  强烈建议：在一个变量还在起作用的时候，不要定义同名的变量！ 你好~程序优先选择花括号内的变量，第一个程序中在定义括号内的a前用的是括号外的a，而定义括号内的a时使用的是另外的空间，并没有把括号外的a的值进行重置。但是为何第二个将它的位置提前就可行，依然是将其放置在括号内部啊[/quote] 第一个程序，循环体在使用a的时候，括号内的a不是还没有定义么？没定义如何使用？

引用 10 楼 starytx 的回复:[quote=引用 7 楼 u013955671 的回复:] [quote=引用 4 楼 starytx 的回复:] 同名变量的作用于问题。一般遵循最“近”原则，也就是大括号内定义的会覆盖大括号外定义的 覆盖效果之针对于该程序段内部吗？因为我另外做测试发现重新定义的数组只对该内部有用，到外部之后起作用的依然是一开始定义的数组[/quote]到了外部都超出该变量的作用域了，当然就没他啥事了。[/quote] 谢谢解答

引用 11 楼 a515360208 的回复:[quote=引用 9 楼 u013955671 的回复:] [quote=引用 5 楼 zhao4zhong1 的回复:] //编写程序输出下列图形： //00001 //00010 //00100 //01000 //10000 #include <stdio.h> int main() {     int i;      for (i=0;i<5;i++) printf("%.5s\n","000010000"+i);     return 0; }  赞！！！！可是这是怎么实现的呀没看懂[/quote] "00001000"也有一个地址，%s都是从字符串指向的地址开始的，上面的程序等价于：  char *p = "000010000"; for (i=0;i<5;i++)     printf("%.5s\n", p + i);[/quote] 谢谢解答

引用 9 楼 u013955671 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] //编写程序输出下列图形： //00001 //00010 //00100 //01000 //10000 #include <stdio.h> int main() {     int i;      for (i=0;i<5;i++) printf("%.5s\n","000010000"+i);     return 0; }  赞！！！！可是这是怎么实现的呀没看懂[/quote] "00001000"也有一个地址，%s都是从字符串指向的地址开始的，上面的程序等价于：  char *p = "000010000"; for (i=0;i<5;i++)     printf("%.5s\n", p + i);

引用 7 楼 u013955671 的回复:[quote=引用 4 楼 starytx 的回复:] 同名变量的作用于问题。一般遵循最“近”原则，也就是大括号内定义的会覆盖大括号外定义的 覆盖效果之针对于该程序段内部吗？因为我另外做测试发现重新定义的数组只对该内部有用，到外部之后起作用的依然是一开始定义的数组[/quote]到了外部都超出该变量的作用域了，当然就没他啥事了。

引用 5 楼 zhao4zhong1 的回复://编写程序输出下列图形： //00001 //00010 //00100 //01000 //10000 #include <stdio.h> int main() {     int i;      for (i=0;i<5;i++) printf("%.5s\n","000010000"+i);     return 0; }  赞！！！！可是这是怎么实现的呀没看懂

引用 3 楼 PDD123 的回复:第二个能正确显示。 在花括号括起来的程序段内外有相同名字的变量时，程序段优先使用的是花括号内的变量，第一个程序中在定义括号内的a前用的是括号外的a，而定义括号内的a时使用的是另外的空间，并没有把括号外的a的值进行重置。  第二个虽然正确，但是括号外的a不起作用，最好删了。  强烈建议：在一个变量还在起作用的时候，不要定义同名的变量！ 你好~程序优先选择花括号内的变量，第一个程序中在定义括号内的a前用的是括号外的a，而定义括号内的a时使用的是另外的空间，并没有把括号外的a的值进行重置。但是为何第二个将它的位置提前就可行，依然是将其放置在括号内部啊

引用 4 楼 starytx 的回复:同名变量的作用于问题。一般遵循最“近”原则，也就是大括号内定义的会覆盖大括号外定义的 覆盖效果之针对于该程序段内部吗？因为我另外做测试发现重新定义的数组只对该内部有用，到外部之后起作用的依然是一开始定义的数组


Question: 想写一个IDE 可是不知道怎么分析头文件里定义的变量和函数 求助

去了解一下clang，可以直接生成程序的语法树，下面是clang文档里的例子： http://clang.llvm.org/docs/IntroductionToTheClangAST.html  $ cat test.cc int f(int x) {   int result = (x / 42);   return result; }  # Clang by default is a frontend for many tools; -Xclang is used to pass # options directly to the C++ frontend.  $ clang -Xclang -ast-dump -fsyntax-only test.cc TranslationUnitDecl 0x5aea0d0 <<invalid sloc>> ... cutting out internal declarations of clang ... `-FunctionDecl 0x5aeab50 <test.cc:1:1, line:4:1> f 'int (int)'   |-ParmVarDecl 0x5aeaa90 <line:1:7, col:11> x 'int'   `-CompoundStmt 0x5aead88 <col:14, line:4:1>     |-DeclStmt 0x5aead10 <line:2:3, col:24>     | `-VarDecl 0x5aeac10 <col:3, col:23> result 'int'     |   `-ParenExpr 0x5aeacf0 <col:16, col:23> 'int'     |     `-BinaryOperator 0x5aeacc8 <col:17, col:21> 'int' '/'     |       |-ImplicitCastExpr 0x5aeacb0 <col:17> 'int' <LValueToRValue>     |       | `-DeclRefExpr 0x5aeac68 <col:17> 'int' lvalue ParmVar 0x5aeaa90 'x' 'int'     |       `-IntegerLiteral 0x5aeac90 <col:21> 'int' 42     `-ReturnStmt 0x5aead68 <line:3:3, col:10>       `-ImplicitCastExpr 0x5aead50 <col:10> 'int' <LValueToRValue>         `-DeclRefExpr 0x5aead28 <col:10> 'int' lvalue Var 0x5aeac10 'result' 'int'

引用 楼主 LYP951018 的回复:最近想写一个IDE。。。。。假如用户#include一个头文件 我怎么分析出里面定义的函数和变量方便智能提示和高亮啊。。。。万一这个头文件错误怎么办。。。能不能借助编译器来完成这些工作啊。。。唉 头大死。。。。求解啊。。。。 ctag 不过你最好有心理准备，IDE的工作量不是随便说说的。。真要定制你也可以从eclipse开始啊

参考Tiny C？

引用 2 楼 LYP951018 的回复:引用 1 楼 zhao4zhong1 的回复:参考Tiny C？ 有什么相关资料吗。。我找了一下。。只有关于编译文件的一些。。。。 TinyC是开源的C编译器。


Question: c

[size=14px]AC代码： #include<stdio.h> int main() {     double sum=0,t=1;     for(int i=1;i<=30;i++)     {         t*=i;         sum+=t;     }     printf("%.2e\n",sum);     return 0; } [/size]

static int s;  int sum(int n,int jie) {  	if(n==1) 	{ 		s++; 		jie--; 		n=jie; 		if(jie==1) 			return s++; 	} 		s+=n; 		sum(n-1,jie); }   int main() { 	int n=30; 	int jie=30; 	cout<<sum(n,jie)<<endl; 	     return(0); }

引用 5 楼 Symfund 的回复:这个不考察编程能力滴：  程序员要有点数学素养，这个叫阶乘级数和：    印度有一个天才级无穷级数和大神，可以跟高斯叫板，他叫：Srinivasa Ramanujan  http://en.wikipedia.org/wiki/Ramanujan  他是无穷级求和，求积分的外星人。 他有一个精度极高的Pi的表达式：    不明觉厉

引用 6 楼 Symfund 的回复:你想知道，他的那么多神奇的公式是怎么从他脑子里蹦出来的吗？  量子理论当中，不是有很多公式都是以级数和的形式给出的吗？  我只知道有个魔群月光猜想，哈哈~~

阶乘积求和~~~~~soga!厉害~

标题改为：编程实现无究阶乘级数求和

这个题目的课题很好，但是标题不显眼，不霸气！收藏了！

引用 9 楼 daiweifeng 的回复:[quote=引用 6 楼 Symfund 的回复:] 你想知道，他的那么多神奇的公式是怎么从他脑子里蹦出来的吗？  量子理论当中，不是有很多公式都是以级数和的形式给出的吗？  我只知道有个魔群月光猜想，哈哈~~[/quote]  嗯，太神奇了！

引用 1 楼 longburulin 的回复:int main() {    int i;     long sum=0,temp=1;     for(i=1;i<=30;i++)    {         temp*=i;         sum+=temp;    }    printf("%.2e\n",sum);   return 0; }上面输出写错了

int main() {    int i;     long sum=0,temp=1;     for(i=1;i<=30;i++)    {         temp*=i;         sum+=temp;    }    printf("%.2e\n",long);   return 0; }

你可以尝试把每位数字转换成字符输出，不然肯定会溢出的

快给我分啊，给大家科普了一下，有点功劳吧！

引用 3 楼 rumlee 的回复:用long类型肯定是不行的，long类型没有那么大，肯定会溢出，所以干脆直接用double类型了。   void main(){ 	double sum  = 0.0; 	for(int i=1;i<=30;i++){ 		double sum1 = 1.0; 		for(int j=1;j<i;j++){ 			sum1 *= j; 		} 		sum += sum1; 	} 	printf("%.2e",sum); }   上面写错了，里面一个循环应该是j<=i  最终计算结果应该是 2.74e+032


Question: 一个关于difftime（）的问题....

引用 6 楼 zhao4zhong1 的回复:[quote=引用 5 楼 Z5813 的回复:] [quote=引用 2 楼 zhao4zhong1 的回复:] #include <stdio.h> #include <time.h> #include <windows.h> int main(){     time_t start,end;     double duration;     start = time(NULL);     Sleep(2500);     end = time(NULL);     printf("\n\nstart :%d\n",start);     printf("end   :%d\n",end);     duration = difftime(end,start);     printf("duration:%f\n",duration);     return 0; } // // //start :1400815736 //end   :1400815738 //duration:2.000000 //  我这边VC6运行没问题。  楼主重建所有了吗？ 我怕没有@到你，重新回复一下吧。 就是我用的是DEV C++和CODEBLOCK，编译器是MinGW的GCC，版本是4.8.1，没有用VC6试过 我分别在这两个IDE里建项目试过，结果都是一样，我怀疑和编译器有关Y_Y...但是又找不到difftime的源码[/quote] 别总以为Linux系的东东一定比Windows系的东东更开源！  先 http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装  再参考C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\difftime.c /*** *difftime.c - return difference between two times as a double * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       Find difference between two time in seconds. * *******************************************************************************/   #include <cruntime.h> #include <time.h> #include <internal.h>  /*** *double _difftime32(b, a) - find difference between two times * *Purpose: *       returns difference between two times (b-a) * *Entry: *       __time32_t a, b - times to difference * *Exit: *       returns a double with the time in seconds between two times *       0 if input is invalid * *Exceptions: * *******************************************************************************/  double __cdecl _difftime32 (         __time32_t b,         __time32_t a         ) {         _VALIDATE_RETURN_NOEXC(             ( ( a >= 0 ) && ( b >= 0 ) ),             EINVAL,             0         )          return( (double)( b - a ) ); }  [/quote]   您好！请教一下difftime的参数能自己输入吗？我用%d获取的，为什么就不对？ http://tieba.baidu.com/p/4067042157

引用 3 楼 Z5813 的回复:我用的是MinGW的编译器 = =，在dev c++ 和codeblock里面结果都是一样的只返回第一个参数， 如果用VC6没问题的话，我想跟编译器有关系了Y_Y   CFree测试正常，用的是MinGW的编译器。

引用 6 楼 zhao4zhong1 的回复:[quote=引用 5 楼 Z5813 的回复:] [quote=引用 2 楼 zhao4zhong1 的回复:] #include <stdio.h> #include <time.h> #include <windows.h> int main(){     time_t start,end;     double duration;     start = time(NULL);     Sleep(2500);     end = time(NULL);     printf("\n\nstart :%d\n",start);     printf("end   :%d\n",end);     duration = difftime(end,start);     printf("duration:%f\n",duration);     return 0; } // // //start :1400815736 //end   :1400815738 //duration:2.000000 //  我这边VC6运行没问题。  楼主重建所有了吗？ 我怕没有@到你，重新回复一下吧。 就是我用的是DEV C++和CODEBLOCK，编译器是MinGW的GCC，版本是4.8.1，没有用VC6试过 我分别在这两个IDE里建项目试过，结果都是一样，我怀疑和编译器有关Y_Y...但是又找不到difftime的源码[/quote] 别总以为Linux系的东东一定比Windows系的东东更开源！  先 http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装  再参考C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\difftime.c /*** *difftime.c - return difference between two times as a double * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       Find difference between two time in seconds. * *******************************************************************************/   #include <cruntime.h> #include <time.h> #include <internal.h>  /*** *double _difftime32(b, a) - find difference between two times * *Purpose: *       returns difference between two times (b-a) * *Entry: *       __time32_t a, b - times to difference * *Exit: *       returns a double with the time in seconds between two times *       0 if input is invalid * *Exceptions: * *******************************************************************************/  double __cdecl _difftime32 (         __time32_t b,         __time32_t a         ) {         _VALIDATE_RETURN_NOEXC(             ( ( a >= 0 ) && ( b >= 0 ) ),             EINVAL,             0         )          return( (double)( b - a ) ); }  [/quote]  不管怎样先谢谢你！ 从VC的源码里看也没啥问题，.....，其实我现在更关心为什么在GCC里面编译出来会出现这种结果，是函数没有完全实现吗，虽然这有点不可能，PS.还有俺对linux系和win系木有歧视.... Y_Y

C:\Microsoft SDK\src\crt\difftime.c C:\Android\Mydroid\bionic\libc\tzcode\difftime.c C:\Program Files\Borland\CBuilder6\Source\Rtl\Source\time\difftime.c C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\src\crt\difftime.c C:\Program Files\Microsoft Visual Studio\VC98\CRT\SRC\DIFFTIME.C C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\difftime.c C:\Program Files\Microsoft Visual Studio 8\VC\crt\src\difftime.c C:\Program Files\Microsoft Visual Studio 9.0\VC\crt\src\difftime.c D:\BC\CRTL\MATH\DIFFTIME.C

引用 5 楼 Z5813 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] #include <stdio.h> #include <time.h> #include <windows.h> int main(){     time_t start,end;     double duration;     start = time(NULL);     Sleep(2500);     end = time(NULL);     printf("\n\nstart :%d\n",start);     printf("end   :%d\n",end);     duration = difftime(end,start);     printf("duration:%f\n",duration);     return 0; } // // //start :1400815736 //end   :1400815738 //duration:2.000000 //  我这边VC6运行没问题。  楼主重建所有了吗？ 我怕没有@到你，重新回复一下吧。 就是我用的是DEV C++和CODEBLOCK，编译器是MinGW的GCC，版本是4.8.1，没有用VC6试过 我分别在这两个IDE里建项目试过，结果都是一样，我怀疑和编译器有关Y_Y...但是又找不到difftime的源码[/quote] 别总以为Linux系的东东一定比Windows系的东东更开源！  先 http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装  再参考C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\difftime.c /*** *difftime.c - return difference between two times as a double * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       Find difference between two time in seconds. * *******************************************************************************/   #include <cruntime.h> #include <time.h> #include <internal.h>  /*** *double _difftime32(b, a) - find difference between two times * *Purpose: *       returns difference between two times (b-a) * *Entry: *       __time32_t a, b - times to difference * *Exit: *       returns a double with the time in seconds between two times *       0 if input is invalid * *Exceptions: * *******************************************************************************/  double __cdecl _difftime32 (         __time32_t b,         __time32_t a         ) {         _VALIDATE_RETURN_NOEXC(             ( ( a >= 0 ) && ( b >= 0 ) ),             EINVAL,             0         )          return( (double)( b - a ) ); }

引用 2 楼 zhao4zhong1 的回复:#include <stdio.h> #include <time.h> #include <windows.h> int main(){     time_t start,end;     double duration;     start = time(NULL);     Sleep(2500);     end = time(NULL);     printf("\n\nstart :%d\n",start);     printf("end   :%d\n",end);     duration = difftime(end,start);     printf("duration:%f\n",duration);     return 0; } // // //start :1400815736 //end   :1400815738 //duration:2.000000 //  我这边VC6运行没问题。  楼主重建所有了吗？ 我怕没有@到你，重新回复一下吧。 就是我用的是DEV C++和CODEBLOCK，编译器是MinGW的GCC，版本是4.8.1，没有用VC6试过 我分别在这两个IDE里建项目试过，结果都是一样，我怀疑和编译器有关Y_Y...但是又找不到difftime的源码

引用 1 楼 longburulin 的回复:#include <stdio.h> #include <process.h> #include <windows.h> #include <time.h> int main(){     time_t start,end;     double duration; 	system("cls");     start = time(NULL);     Sleep(2000);     end = time(NULL);      printf("%s",ctime(&start));      printf("%s",ctime(&end));     duration = difftime(end,start);     printf("duration:%f\n",duration); 	getchar();     return 0; } 输出格式不对 看到的结果有误 改成 %lf还是返回一样的结果。


Question: 原理真有编程天赋测试这种东西

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

我是D，真的干过这样的事儿。我把学校的一份表格，连表格带内容，还有边距、字体都弄得一样，保证打印下来可以对上，弄完超有成就感。

这个世界只有 1% 的是知识提供者，信息制造者，他们是地球人的精英；99% 是信息接受者，注定是平庸的！

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

天赋肯定有人是有的，架构，算法，协议之类的 绝大部分还是需要码农来搬砖的

引用 5 楼 user-5 的回复:最后要提一下这里的测试有比较大的paradigm prejudice。要知道并不是所有语言都需要有赋值。对于纯FP语言来说完全回避赋值同样能够完成日常的任务（虽然我不觉得没有限制的pure FP是普遍良好的设计应该支持的东西）。所以即便能筛出程序员，也只是其中的一部分。相对地，对于普通程序员来说，传统FP可能见惯了的那套（比如说lambda啊first class continuation啊beta-eta-equivalence啊monad啊什么的）对他们可能很难理解，怎么学都学不清楚直至有意拒绝理解的恐怕大有人在——显然也没法就凭这点否认他们可以是程序员。 那个文章里面题只是一个例子，后面还有一大堆测试。但我英文水平不行，没有找到全文，不知是否能找到全文。。。

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

引用 1 楼 Symfund 的回复:码农摆弄的是一个代码结构，数学家摆弄的是一个数学结构，农民工摆弄的是一个砖块结构。 关键是理解问题，有些代码的组织方式非常让人费解。。。

还是不是程序员测试。不明目的地折腾代码，只是撸码不是编程。 合格的程序员应该能弄清楚指派语义是谁的工作。对于让形式系统从无意义到有意义这一点，单靠直觉是起不到多少作用的，更重要的是经验以及其它更加难以言喻的天赋。所以无法指望一个以“使用”代码表达“意义”的程序员就一定在这项能力上表现良好，也不能指望具有这方面良好（或者良好+稳定）直觉的人就一定能完成程序员的工作——更没法指望他们能设计出具有好的taste的语言。当然，在编程以外的领域有其它的直觉可以参考。

引用 2 楼 zjq9931 的回复:[quote=引用 1 楼 Symfund 的回复:] 码农摆弄的是一个代码结构，数学家摆弄的是一个数学结构，农民工摆弄的是一个砖块结构。 关键是理解问题，有些代码的组织方式非常让人费解。。。[/quote] 有可能是读者水平不够，也有可能是写的烂，不能一概而论。


Question: 请问如何在一段含0x00的内存空间里查找ascii码串??

thanks

memcmp Compare characters in two buffers.  int memcmp( const void *buf1, const void *buf2, size_t count );  Routine Required Header Compatibility  memcmp <memory.h> or <string.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  The return value indicates the relationship between the buffers.  Return Value Relationship of First count Bytes of buf1 and buf2  < 0 buf1 less than buf2  0 buf1 identical to buf2  > 0 buf1 greater than buf2    Parameters  buf1  First buffer  buf2  Second buffer  count  Number of characters  Remarks  The memcmp function compares the first count bytes of buf1 and buf2 and returns a value indicating their relationship.  Example  /* MEMCMP.C: This program uses memcmp to compare  * the strings named first and second. If the first  * 19 bytes of the strings are equal, the program  * considers the strings to be equal.  */  #include <string.h> #include <stdio.h>  void main( void ) {    char first[]  = "12345678901234567890";    char second[] = "12345678901234567891";    int result;     printf( "Compare '%.19s' to '%.19s':\n", first, second );    result = memcmp( first, second, 19 );    if( result < 0 )       printf( "First is less than second.\n" );    else if( result == 0 )       printf( "First is equal to second.\n" );    else if( result > 0 )       printf( "First is greater than second.\n" );    printf( "Compare '%.20s' to '%.20s':\n", first, second );    result = memcmp( first, second, 20 );    if( result < 0 )       printf( "First is less than second.\n" );    else if( result == 0 )       printf( "First is equal to second.\n" );    else if( result > 0 )       printf( "First is greater than second.\n" ); }   Output  Compare '1234567890123456789' to '1234567890123456789': First is equal to second. Compare '12345678901234567890' to '12345678901234567891': First is less than second.   Buffer Manipulation Routines  See Also   _memccpy, memchr, memcpy, memset, strcmp, strncmp

引用 1 楼 user-4 的回复:memcmp ++

把code中的..34改成255..  0x00 = 255d..所以char数组定义为char[255]就可以了吧..(因为我写的测试用的文件只有34个字节..所以循环写成那样了..)

#include <iostream>   #include <pthread.h>    #include <stdlib.h>  #include <stdio.h> #include <windows.h>    using namespace std;   char buffer[255] ; int main(int args, char* argv[])   {     FILE* fp ;       _wfopen_s(&fp,TEXT("Sample"),TEXT("rb")) ;         fread(buffer,34,1,fp) ;  	for(int xun = 0 ; xun < 34 ; ++ xun) 	{ 		if((buffer[xun] == 'h') && (buffer[xun + 1] == 'e') && (buffer[xun + 2] == 'l') && (buffer[xun + 3] == 'l') && (buffer[xun + 4] == 'o')) 			cout << "偏移地址:" << xun ; 	}  }   看着有点搓..  - - 我试过可以...

memcmp


Question: 看libvirt源码，有个地方没明白？

我是用source insight看的，查不到定义，在windows环境下没有相关定义，应该是linux下的某个特性吧。

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。

既然你知道 df/dx 就是 f'(x)的意思，何必纠结表示法呢！ 奇技淫巧只会造成他人阅读代码的障碍，并不可取！