Question: 小白最近遇到的#include中一些函数无法使用的问题，求指教

谢邀，但很抱歉自己不会，  同苦也，最近年前还有想法用开源的2D图形库画一个行星运行图，但一直都没有增加到eclipse里去。。。

【C/C++程序设计学习与实验系统】，设置里面把编译器设为TC。软件自带DOSBox，可以运行TC编译出来的DOS程序。

这个，dos是直接写屏的，现在要做这个就麻烦得多了，windows最简单就是用gdi绘图了，3d的话directx或者opengl，这个就不是一本书可以得了，要看很多书的

引用 3 楼 ynsenyu的回复:换本新的书吧，要算法还可以借鉴，这系统相关的东西，这都是dos时代的程序了 求推荐→_→要有库在里面的

换本新的书吧，要算法还可以借鉴，这系统相关的东西，这都是dos时代的程序了

换本书吧 ...

console屏幕处理例子程序。终端窗口屏幕处理相关API使用例子。来自MSVC20\SAMPLES\win32\console\ http://download.csdn.net/detail/zhao4zhong1/3461309


Question: 数据结构课程设计-例句搜索

可以把你写的给我看一下吗，我还是没能写出来

先把文本读进内存 然后用vector在把每个单词记录下来 单词以空格区分 然后用vector的性能处理一下 vector<string> word; .............读文本单词到word里的代码 word.find("XXXX"); ////////////////////

我们的课程设计正好这道题，用散列表也就是哈希表就可以

或者参考C:\boost_1_38_0\libs\regex\example\grep\grep.cpp： /*  *  * Copyright (c) 2004  * John Maddock  *  * Use, modification and distribution are subject to the  * Boost Software License, Version 1.0. (See accompanying file  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)  *  */  #include <iostream> #include <fstream> #include <string> #include <vector> #include <boost/program_options.hpp> #include <boost/regex.hpp>  namespace po = boost::program_options;  int after_context; int before_context; bool print_byte_offset; bool count_only; std::string pattern; bool print_non_matching_files; bool files_only; bool print_line_numbers;  boost::regex_constants::syntax_option_type flags = boost::regex_constants::basic; boost::regex re; boost::smatch what; std::string current_file; int file_count;  void process_stream(std::istream& is) {    std::string line;    int match_found = 0;    int linenum = 1;    while(std::getline(is, line))    {       bool result = boost::regex_search(line, what, re);       if(result)       {          if(print_non_matching_files)             return;          if(files_only)          {             std::cout << current_file << std::endl;             return;          }          if(!match_found && !count_only && (file_count > 1))          {             std::cout << current_file << ":\n";          }          ++match_found;          if(!count_only)          {             if(print_line_numbers)             {                std::cout << linenum << ":";             }             if(print_byte_offset)             {                std::cout << what.position() << ":";             }             std::cout << what[0] << std::endl;          }       }       ++linenum;    }    if(count_only && match_found)    {       std::cout << match_found << " matches found in file " << current_file << std::endl;    }    else if(print_non_matching_files && !match_found)    {       std::cout << current_file << std::endl;    } }  void process_file(const std::string& name) {    current_file = name;    std::ifstream is(name.c_str());    if(is.bad())    {       std::cerr << "Unable to open file " << name << std::endl;    }    process_stream(is); }  int main(int argc, char * argv[]) {    try{       po::options_description opts("Options");       opts.add_options()          ("help,h", "produce help message")          //("after-context,A", po::value<int>(&after_context)->default_value(0), "Print arg  lines  of  trailing  context  after  matching  lines. Places  a  line  containing  --  between  contiguous  groups  of matches.")          //("before-context,B", po::value<int>(&before_context)->default_value(0), "Print  arg  lines  of  leading  context  before  matching lines. Places  a  line  containing  --  between  contiguous  groups  of matches.")          //("context,C", po::value<int>(), "Print  arg lines of output context.  Places a line containing -- between contiguous groups of matches.")          ("byte-offset,b", "Print the byte offset within the input file before each line  of output.")          ("count,c", "Suppress normal output; instead print a count of matching  lines for  each  input  file.  With the -v, --invert-match option (see below), count non-matching lines.")          ("extended-regexp,E", "Interpret PATTERN as an POSIX-extended regular expression.")          ("perl-regexp,P", "Interpret PATTERN as a Perl regular expression.")          //("regexp,e", po::value<std::string>(&pattern), "Use PATTERN as the pattern; useful to protect patterns beginning with -.")          ("basic-regexp,G", "Interpret arg as a POSIX-basic regular expression (see below).  This is the default.")          ("ignore-case,i", "Ignore case distinctions in  both  the  PATTERN  and  the  input files.")          ("files-without-match,L", "Suppress  normal  output;  instead  print the name of each input file from which no output would normally have been printed.  The scanning will stop on the first match.")          ("files-with-matches,l", "Suppress  normal  output;  instead  print the name of each input file from which output would normally have  been  printed.   The scanning will stop on the first match.")          ("line-number,n", "Prefix each line of output with the line number within its input file.")          ;       // Hidden options, will be allowed both on command line and       // in config file, but will not be shown to the user.       po::options_description hidden("Hidden options");       hidden.add_options()          ("input-file", po::value< std::vector<std::string> >(), "input file")          ("input-pattern", po::value< std::string >(), "input file")          ;        po::options_description cmdline_options;       cmdline_options.add(opts).add(hidden);        po::positional_options_description p;       p.add("input-pattern", 1);       p.add("input-file", -1);        po::variables_map vm;       po::store(po::command_line_parser(argc, argv).options(cmdline_options)/*.options(hidden)*/.positional(p).run(), vm);       po::notify(vm);        if (vm.count("help"))       {          std::cout << opts << "\n";          return 0;       }       if (vm.count("context"))       {          after_context = vm["context"].as< int >();          before_context = after_context;       }       if(vm.count("extended-regexp"))       {          flags = boost::regex_constants::extended;       }       if(vm.count("basic-regexp"))       {          flags = boost::regex_constants::basic;       }       if(vm.count("perl-regexp"))       {          flags = boost::regex_constants::perl;       }       if(vm.count("ignore-case"))       {          flags |= boost::regex_constants::icase;       }       if(vm.count("byte-offset"))       {          print_byte_offset = true;       }       if(vm.count("count"))       {          count_only = true;       }       if(vm.count("files-without-match"))       {          print_non_matching_files = true;       }       if(vm.count("files-with-matches"))       {          files_only = true;       }       if(vm.count("line-number"))       {          print_line_numbers = true;       }       if(vm.count("input-pattern"))       {          pattern = vm["input-pattern"].as< std::string >();          re.assign(pattern, flags);       }       else       {          std::cerr << "No pattern specified" << std::endl;          return 1;       }       if (vm.count("input-file"))       {          const std::vector<std::string>& files = vm["input-file"].as< std::vector<std::string> >();          file_count = files.size();          for(std::vector<std::string>::const_iterator i = files.begin(); i != files.end(); ++i)          {             process_file(*i);          }       }       else       {          // no input files, scan stdin instead:          process_stream(std::cin);       }     }    catch(const std::exception& e)    {       std::cerr << e.what() << std::endl;    }     return 0; }

参考Linux命令grep对应的源代码。

数据结构有一章专讲（字符）串的操作的可以参考下

没分了，楼主给我点点额哈哈啊啊

很基础的东西，建议楼主把基础打好，特别字符串操作，然后理清思路一步一步写


Question: 程序可以正常运行，但是使用gdb调试出现段错误

使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。


Question: c语言库函数线程安全的问题

http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_09    这里面会列出FILE* 系列的是安全的

不是，但是有些编译器库函数的多线程版本，printf 是同步过的

《Windows核心编程》  仅供参考：//循环向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; }

引用 1 楼 user-3 的回复:fopen，sprintf 不是线程安全的 void* thread_function (void* args) {     char thread_log_filename[20];     FILE* thread_log;     sprintf (thread_log_filename, “thread%d.log”, (int) pthread_self ());     thread_log = fopen (thread_log_filename, “w”);     pthread_setspecific (thread_log_key, thread_log);     write_to_thread_log (“Thread starting.”);     return NULL; }  这个线程函数没问题啊。valgrind 检测可以通过。

fopen，sprintf 不是线程安全的


Question: 关于栈这个东西。我想问问!它是由操作系统在内存中固定划分的一块区域码？

理解和讨论之前请先学会如何观察！  VMMap 是进程虚拟和物理内存分析实用工具。http://technet.microsoft.com/zh-cn/sysinternals/dd535533

栈，DOS下，分两种情况， 一种是操作系统设置的（tiny模式，small也是）， 一种是程序设置的(只需要设置段地址到SS寄存器) 现代操作系统中，往往直接加载就可以了，栈不用设置了； 栈的大小。可以在编译时候设置，不设置的话,编译器采用操作系统默认值。 另外，多线程程序，每个线程一个栈。 操作系统本身，有它自己的内核栈  数据区，和代码区 DOS下，是应用程序可以设置的。 高级语言中，一般都是编译器设置的， 有些是操作系统确定的， 有些是编译器安排，程序运行时确定的。  现代操作系统中。高级语言里面， 是编译器设置内容大小，操作系统加载确定的。

引用 楼主 qq_33447655 的回复:编译器把上面的程序翻译成二进制之后。传给CPU？  经过编译、链接之后将生成EXE文件，里面存储了各二进制信息。当启动这个程序，进程会将文件加载到内存，作好各种准备工作，比如映射需要的DLL等，之后开始执行程序代码  引用 楼主 qq_33447655 的回复:首先#include <stdio.h> 这一句，系统会找到stdio.h这个文件并把里面的内容复制到内存中，复制到内存哪里呢  这些都是编译器、链接器的事，编译后是生成文件，在文件被调用时，才被操作系统加载到内存

看一下《深入理解计算机系统》或者《程序员的自我修养》，或者找些关于编译、链接的资料看一看。

1) 栈是系统划分的, 编译时可以设置大小 2) EXE中已经不存在什么头文件, int a=0之内, 没有变量名, 也就没有什么变量表, 一切都是地址,那是编译器操心的事

对 C 语言来说，编译 与 运行是两个完全独立的过程。  你现在把两个过程掺在一起了。


Question: 求救！蚁群解tsp问题，找不到错

有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成core文件、……这些方法都不行！ 写日志到文件参考下面： //循环向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: qt弹出窗口，在关机的时候

::MessageBoxA(NULL,"msg","title",MB_OK); 或 ::MessageBoxW(NULL,L"msg",L"title",MB_OK);

报错了，怎么解决？

C:\Users\APPLE\Desktop\guanji\widget.cpp:135: error: '_T' was not declared in this scope          ::MessageBox(NULL,_T("msg"),_T("title"),MB_OK);//澶х璇寸殑锛屽湪鍏虫満鐣岄潰鏄剧ず鎻愮ず妗�                                    ^


Question: linux网络协议栈阅读理解--带详尽注释及相关函数流程调用注释，附github注释后源码

不好意思，前面地址发错了，应该是这个 https://github.com/y123456yz/Reading-and-comprehense-linux-Kernel-network-protocol-stack

沙发，接分。


Question: C语言小白指针求解惑

第二个for中你的b已经溢出数组了

b++是会改变b的值而b+i则不会

引用 3 楼 weixin_33887675 的回复:你把第一个for中的语句改为*(b+I)=I+1;   试一试 确实行了，请问原因

引用 2 楼 weixin_33887675的回复:楼主你输出的不是地址而是一个乱值，因为再第一个for  b已经被改变了，而第二个for你以为b的地址还是a数组第一个元素的地址，建议设两个指针一个用于给数组赋值，一个用于打印，而且*b++也有问题，他导致从不 a[1]开始赋值 请问第二个for b是指向a[1]是吗？

你把第一个for中的语句改为*(b+I)=I+1;   试一试

b是指向数组的指针 *b 是数组

*b++  ;  会改变指针值


Question: 指向数组的指针变量

引用 7 楼 qq_33447655 的回复:[quote=引用 1 楼 user-3 的回复:] 1 这是编译器的工作, pa是局部变量, 也就是占用栈空间, A也是一样.由于你定义A的内容是int, 要连续占用4个字节,就是你说的12345-12348 存放的是1, pa只存放A的地址,没有放其它的操作  2 简单一点就是pa[i][j][k] 指针就是间接寻址, 明白什么叫间接寻址就行了 看了下赵四老师的 在结合版主的 我明白了。 3级指针 。[/quote] 嗯，楼主还算是心有灵犀的。

引用 1 楼 user-3 的回复:1 这是编译器的工作, pa是局部变量, 也就是占用栈空间, A也是一样.由于你定义A的内容是int, 要连续占用4个字节,就是你说的12345-12348 存放的是1, pa只存放A的地址,没有放其它的操作  2 简单一点就是pa[i][j][k] 指针就是间接寻址, 明白什么叫间接寻址就行了 或者这么说 :你能说了一下 printf("%d ",*(*(*(pA+i)+j)+k)); 这个3级指针式怎么运算的？就是里面三个*  这部分！

引用 1 楼 user-3 的回复:1 这是编译器的工作, pa是局部变量, 也就是占用栈空间, A也是一样.由于你定义A的内容是int, 要连续占用4个字节,就是你说的12345-12348 存放的是1, pa只存放A的地址,没有放其它的操作  2 简单一点就是pa[i][j][k] 指针就是间接寻址, 明白什么叫间接寻址就行了 看了下赵四老师的 在结合版主的 我明白了。 3级指针 。

仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]

为pa指针赋值  pa是指向int[3][4]二维数组的指针  赋值后将指向你的A[2][3][4]数组的头部，也就是A[0]这个int[3][4]类型

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

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


Question: 关于栈的操作的 问题

r=create(Sqstack);   这是什么鬼，直接将类型作为参数？


Question: 动态二维数组创建，问题出在哪里？高手HELP

int row = 8; int column = 8; int i = 0;   int **array = (int **)malloc(sizeof(int*)*row);  for(i=0;i<row;i++) { 	 array[i] = (int*)malloc(sizeof(int)*column); }  大致就是这样

int(*p)[]; 	p = (int(*)[])malloc(sizeof(int)*row*line);

我也是参考这个写法的 http://zhidao.baidu.com/question/112765442.html?fr=iks&word=%B6%AF%CC%AC%B6%FE%CE%AC%CA%FD%D7%E9&ie=gbk  第一种写法启发的 HELP +QQ ， 楼上的写法精湛，以后学习指导我一下，THANKS   +我QQ:64990997

思考一下为什么不把整个互联网内容当作函数参数传来传去呢？

没有对二维数组“一次性申请内存空间”，且还能按照arr[y][x]这样的格式读写这一说。 楼主试试发明一个让我学习一下。

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

6楼的写法VC6编译通不过。

引用 2 楼 lgs6715 的回复:先申请行指针，再申请列指针。。。这个我早会了。。我需要的是一次性申请内存空间  利用 int (*p)[row] //row为列数 p=(int(*)[row])malloc(sizeof(int)*row*line);// line为行数  利用这种写法，HELP 这种写法局限于row为编译期常量（VC6）。

这种写法理解费劲，还更容易失败。（不都说吃不到的葡萄最酸吗？）


Question: sprintf 报错求助

//由char PhoneNumber[14] = "187-9999-9988";得到char* ExtractedCodes[] = {"187", "9999", "9988"}; #include <stdio.h> #include <string.h> char PhoneNumber[14] = "187-9999-9988"; char PhoneNumber1[14] = "187-9999-9988"; char* ExtractedCodes1[3]; char  ExtractedCodes2[3][5]; int main() {     strcpy(PhoneNumber1,PhoneNumber);     PhoneNumber1[3]=0;     PhoneNumber1[8]=0;     ExtractedCodes1[0]=&PhoneNumber1[0];     ExtractedCodes1[1]=&PhoneNumber1[4];     ExtractedCodes1[2]=&PhoneNumber1[9];     printf("[%s] [%s] [%s]\n",ExtractedCodes1[0],ExtractedCodes1[1],ExtractedCodes1[2]);      sprintf(ExtractedCodes2[0],"%.3s",PhoneNumber);     sprintf(ExtractedCodes2[1],"%.4s",PhoneNumber+4);     sprintf(ExtractedCodes2[2],"%.4s",PhoneNumber+9);     printf("[%s] [%s] [%s]\n",ExtractedCodes2[0],ExtractedCodes2[1],ExtractedCodes2[2]);     return 0; } //[187] [9999] [9988] //[187] [9999] [9988] //

PhoneNum[m]只是char类型  再另外ExtractedCodes这个数组只有1个元素，你sprintf那句访问已经越界了  可以自己单步调试运行看

看了你的代码，我想说的是，哥们儿，基础还须多花点时间，感觉一两句话真解释不清。  char** ExtractCodesFromPhoneNumber(char *PhoneNum, char length, char separate) {     int i_seperate[] = {0};     int SeperateCnt = 0;       char* ExtractedCodes[] = {0};            // 这样声明，声明ExtractedCodes数组有char*元素个数为1噢，要存放3个字符指针明显不够；该指针也没有指向任何可写内存空间，后面的sprintf当然会报错。     for(int i = 0; i < length; ++i)     {         if(PhoneNum[i] == '-')         {             ++SeperateCnt;             i_seperate[SeperateCnt] = i;    //              for(int m = i_seperate[SeperateCnt - 1]; m < i_seperate[SeperateCnt]; ++i) // 0、1、2             {                 sprintf(ExtractedCodes[SeperateCnt], "%d", PhoneNum[m]);     //这里还是先弄清char和int之间的区别吧             }         }     } //    char* ExtractedCodes[] = {"187", "9999", "9988"};     char** p = ExtractedCodes;    //此处p也指向函数内部临时变量噢，函数结束后，p就成野指针了。。。调用者再使用它可能会访问违规的说       return p; }

谢谢版主回复，我这个sprintf生成的是字符串， 我希望通过这句话由原来的char PhoneNumber[14] = "187-9999-9988";得到char* ExtractedCodes[] = {"187", "9999", "9988"}; 应该用%s,可是也不行。 指针使用有错吗？

%d是整型，你提供的确不是一个整型变量

顶一下。。。。。。


Question: 关于链表问题

引用 14 楼 zhao4zhong1 的回复:[quote=引用 12 楼 zhangxiangDavaid 的回复:] 画图、画图、画图…… 三遍不够，就再三遍 仅停留在画图阶段离玩转指针还差十万八千里。[/quote] 对于这个问题，特别是初学者，画图就是最好的理解方式。

引用 15 楼 zhangxiangDavaid 的回复:[quote=引用 14 楼 zhao4zhong1 的回复:] [quote=引用 12 楼 zhangxiangDavaid 的回复:] 画图、画图、画图…… 三遍不够，就再三遍 仅停留在画图阶段离玩转指针还差十万八千里。[/quote] 对于这个问题，特别是初学者，画图就是最好的理解方式。[/quote] 我并不这么认为。我认为 用调试器查看指针操作对应的汇编指令以及该汇编指令读写的具体内存地址和字节 就比画图更直观、更具体、更好理解。  没有最好，只有更好。

画图、画图、画图…… 三遍不够，就再三遍

引用 12 楼 zhangxiangDavaid 的回复:画图、画图、画图…… 三遍不够，就再三遍 仅停留在画图阶段离玩转指针还差十万八千里。

红色部分的意思就是L和P后接同一个节点，然后L接到P的前边

如果第一个结点的值就是key，这时则让r的next域指向第一个结点，而这个结点原来就是由head指向的，就用语句 r->next =head 然后再让head指向r head =r

代码有问题吧，我改了一下  for（i=n;i>0;i--）    {        p=（linklist）malloc（sizeof（LNode））； //生成新的节点        scanf(&p->data);       //输入元素的值        p->next=L;       //新建的节点插入到链表的头，所以p->next应该指向上一个节点        L=p;//把p赋值给L用来生成下一个节点用     }

实在理解不了建议把自己用单步运行调试这段代码，一步一步看各变量怎么变化

数据结构：链表 http://blog.csdn.net/zhangxiangdavaid/article/details/25082013

画图理解……

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

代码好多，我就是想知道红色代码的意思，以及其实现的过程，谢谢。

仅供参考：//带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*q1,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将整个链表逆序     if (head->next!=NULL && head->next->next!=NULL) {         p=head->next;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head->next=p;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //84->28->20->23->96->19->59->97->29->41-> //84->28->05->20->23->96->19->59->97->29->41-> //84->28->05->20->96->19->59->97->29->41-> //05->19->20->28->29->41->59->84->96->97-> //97->96->84->59->41->29->28->20->19->05-> //41->29->28->20->19->05->97->96->84->59-> //

我也知道看书，我是说能具体解释一下吗？本人小白一枚

基本的插入操作，多看看书

引用    for（i=n;i>0;i--）    {        p=（linklist）malloc（sizeof（LNode））； //生成新的节点        scanf(&p->data);       //输入元素的值        p->next=L->next;       //插入到表头        L-next=p;     }  这段代码向链表头插入一些节点， 假如：原有链表为head->A->B->C 这时向链表头插入D，并且保证链表正常访问，那么插入的过程就是： 1、首先需要让D->next指向A。 2、然后让head->next指向D。 需要先执行第一步的原因就是如果直接执行第二步，就会是这样的结果head->D->null，就会导致程序再也无法找到A节点。


Question: 用C语言解决一个棘手的问题

#include "stdafx.h" #include <string.h> #include<stdlib.h> void swap(char *a,char *b) { 	char temp=*a; 	*a=*b; 	*b=temp; } void all(char str[],int n) { 	char *temp= str+n ; 	if(*temp=='\0') 	{ 		printf("%s\n",str); 		return; 	}  	for(char *temp1=temp;*temp1!='\0';temp1++) 	{ 		swap(temp,temp1); 		all(str,n+1); 		swap(temp,temp1); 	} } int _tmain(int argc, _TCHAR* argv[]) { 	char str[]="abcde"; 	all(str,0); 	system("pause"); 	return 0; }

之前想简单了，需要多次替换，每次都将上次替换的结果之后的部分继续两两交换  #include <stdlib.h> #include <stdio.h>  void change(char *a, char *b) {     char tmp = *a;     *a = *b;     *b = tmp;  }  int all(int m, int n, char *a, int size, int num) {     int i, j;     if(n == size)     {         printf("%d: %s\n", num, a);         return ++ num;     }     for(j = n; j < size; j ++)     {         change(&a[n], &a[j]);         num = all(0, n + 1, a, size, num);         change(&a[n], &a[j]);     }     return num; }  int main() {     int i = 0,j = 0, m = 1;     char a[5] = {'a','b','c','d','e'};     all(0, 0, a, sizeof(a), 0);     return 0; }

//全排列的生成算法 //  全排列的生成算法就是对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。任何n个字符集的排列都可以与1～n的n个数字的排列一一对应， //  因此在此就以n个数字的排列为例说明排列的生成法。 //  n个字符的全体排列之间存在一个确定的线性顺序关系。所有的排列中除最后一个排列外，都有一个后继；除第一个排列外，都有一个前驱。每个排列的后继都可以从 //  它的前驱经过最少的变化而得到，全排列的生成算法就是从第一个排列开始逐个生成所有的排列的方法。 //  全排列的生成法通常有以下几种： //  字典序法 //  递增进位数制法 //  递减进位数制法 //  邻位交换法 //  递归类算法 //1.字典序法 效率高且顺序自然 //  字典序法中，对于数字1、2、3......n的排列，不同排列的先后关系是从左到右逐个比较对应的数字的先后来决定的。例如对于5个数字的排列12354和12345，排列12345在前， //  排列12354在后。按照这样的规定，5个数字的所有的排列中最前面的是12345，最后面的是54321。 //  字典序算法如下： //  设P是1～n的一个全排列:p=p1p2......pn=p1p2......pj-1pjpj+1......pk-1pkpk+1......pn //  1）从排列的右端开始，找出第一个比右边数字小的数字的序号j（j从左端开始计算），即 j=max{i|pi<pi+1} //  2）在pj的右边的数字中，找出所有比pj大的数中最小的数字pk，即 k=max{i|pi>pj}（右边的数从右至左是递增的，因此k是所有大于pj的数字中序号最大者） //  3）对换pi，pk //  4）再将pj+1......pk-1pkpk+1pn倒转得到排列p’’=p1p2.....pj-1pjpn.....pk+1pkpk-1.....pj+1，这就是排列p的下一个下一个排列。 //  例如839647521是数字1～9的一个排列。从它生成下一个排列的步骤如下： //  自右至左找出排列中第一个比右边数字小的数字4 839647521 //  在该数字后的数字中找出比4大的数中最小的一个5 839647521 //  将5与4交换 839657421 //  将7421倒转 839651247 //  所以839647521的下一个排列是839651247。 //2.递增进位数制法 //  在递增进位制数法中，从一个排列求另一个排列需要用到中介数。如果用 ki表示排列p1p2...pi...pn中元素pi的右边比pi小的数的个数，则排列的中介数就是对应的 //  排列k1 ...... ki...... kn-1。 //  例如排列839647521的中介数是72642321，7、2、6、......分别是排列中数字8、3、9、......的右边比它小的数字个数。 //  中介数是计算排列的中间环节。已知一个排列，要求下一个排列，首先确定其中介数，一个排列的后继，其中介数是原排列中介数加1，需要注意的是，如果中介数的 //  末位kn-1+1=2，则要向前进位，一般情形，如果ki+1=n-i+1，则要进位，这就是所谓的递增进位制。例如排列839647521的中介数是72642321，则下一个排列的中介数 //  是67342221+1=67342300（因为1+1=2，所以向前进位，2+1=3，又发生进位，所以下一个中介数是67342300）。 //  得到中介数后，可根据它还原对应得排列。 //  算法如下： //  中介数k1、k2、......、kn-1的各位数字顺序表示排列中的数字n、n-1、......、2在排列中距右端的的空位数，因此，要按k1、k2、......、kn-1的值从右向左 //  确定n、n-1、......、2的位置，并逐个放置在排列中：i放在右起的ki+1位，如果某位已放有数字，则该位置不算在内，最后一个空位放1。 //  因此从67342300可得到排列849617523，它就是839647521的后一个排列。因为9最先放置，k1=6，9放在右起第7位，空出6个空位，然后是放8，k2=7，8放在右起第8位， //  但9占用一位，故8应放在右起第9位，余类推。 //3.递减进位制数法 //  在递增进位制数法中，中介数的最低位是逢2进1，进位频繁，这是一个缺点。把递增进位制数翻转,就得到递减进位制数。 //  839647521的中介数是67342221(k1k2...kn-1)，倒转成为12224376(kn-1...k2k1)，这是递减进位制数的中介数：ki(i=n-1,n-2,...,2)位逢i向ki-1位进1。给定排列p， //  p的下一个排列的中介数定义为p的中介数加1。例如p=839647521，p的中介数为12224376，p的下一个排列的中介数为12224376+1=12224377，由此得到p的下一个 //  排列为893647521。 //  给定中介数，可用与递增进位制数法类似的方法还原出排列。但在递减进位制数中，可以不先计算中介数就直接从一个排列求出下一个排列。具体算法如下： //  1）如果p(i)=n且i<>n，则p(i)与p(i-1)交换 //  2）如果p(n)=n，则找出一个连续递减序列9、8、......、i，将其从排列左端删除，再以相反顺序加在排列右端，然后将i-1与左边的数字交换 //  例如p=893647521的下一个排列是983647521。求983647521的下一个排列时，因为9在最左边且第2位为8，第3位不是7，所以将8和9从小到大排于最右端364752189， //  再将7与其左方数字对调得到983647521的下一个排列是367452189。又例如求987635421的下一个排列，只需要将9876从小到大排到最右端并将5与其左方数字3对调， //  得到534216789。 //4.邻位对换法 效率最高但顺序不自然 //  邻位对换法中下一个排列总是上一个排列某相邻两位对换得到的。以4个元素的排列为例，将最后的元素4逐次与前面的元素交换，可以生成4个新排列： //  1 2 3 4, 1 2 4 3, 1 4 2 3, 4 1 2 3 //  然后将最后一个排列的末尾的两个元素交换，再逐次将排头的4与其后的元素交换，又生成四个新排列： //  4 1 3 2, 1 4 3 2, 1 3 4 2, 1 3 2 4 //  再将最后一个排列的开头的两个元素交换，将4从后往前移： //  3 1 2 4, 3 1 4 2, 3 4 1 2, 4 3 1 2 //  如此循环4!次既可求出全部排列。 //5.元素增值法（n进制法）效率低 //  1）从原始排列p=p1p2......pn开始，第n位加n-1，如果该位的值超过n，则将它除以n，用余数取代该位，并进位（将第n-1位加1） //  2）再按同样方法处理n-1位，n-2位，......，直至不再发生进位为止，处理完一个排列就产生了一个新的排列 //  3）将其中有相同元素的排列去掉 //  4）当第一个元素的值>n则结束 //  以3个数1、2、3的排列为例：原始排列是1 2 3，从它开始，第3个元素是3，3+2=5，5 Mod 3=2，第2个元素是2，2+1=3，所以新排列是1 3 2。通过元素增值，顺序产生的 //  排列是：1 2 3，1 3 2，2 1 1，2 1 3，2 2 2，2 3 1，2 3 3，3 1 2，3 2 1 //  有下划线的排列中存在重复元素，丢弃，余下的就是全部排列。 //6.递归类算法 //  全排列的生成方法用递归方式描述比较简洁，实现的方法也有多种。 //  1）回溯法 //  回溯法通常是构造一颗生成树。以3个元素为例；树的节点有个数据，可取值是1、2、3。如果某个为0，则表示尚未取值。 //  初始状态是(0，0，0)，第1个元素值可以分别挑选1，2，3，因此扩展出3个子结点。用相同方法找出这些结点的第2个元素的可能值，如此反复进行，一旦出现新结点的3个 //  数据全非零，那就找到了一种全排列方案。当尝试了所有可能方案，即获得了问题的解答。 //  2）递归算法 //  如果用P表示n个元素的排列，而Pi表示不包含元素i的排列，(i)Pi表示在排列Pi前加上前缀i的排列，那么，n个元素的排列可递归定义为： //  如果n=1，则排列P只有一个元素i //  如果n>1，则排列P由排列(i)Pi构成（i=1、2、....、n-1）。 //  根据定义，容易看出如果已经生成了k-1个元素的排列，那么，k个元素的排列可以在每个k-1个元素的排列Pi前添加元素i而生成。例如2个元素的排列是1 2和2 1，对与个 //  元素而言，p1是2 3和3 2，在每个排列前加上1即生成1 2 3和1 3 2两个新排列，p2和p3则是1 3、3 1和1 2、2 1，按同样方法可生成新排列2 1 3、2 3 1和3 1 2、3 2 1。 //  3）循环移位法 //  如果已经生成了k-1个元素的排列，则在每个排列后添加元素k使之成为k个元素的排列，然后将每个排列循环左移（右移），每移动一次就产生一个新的排列。 //  例如2个元素的排列是1 2和2 1。在1 2 后加上3成为新排列1 2 3，将它循环左移可再生成新排列2 3 1、3 1 2，同样2 1 可生成新排列2 1 3、1 3 2和3 2 1。

可以模拟冒泡法，每次将两个字符调换然后输出：  #include <stdlib.h> #include <stdio.h>  void change(char *a, char *b) {     char tmp = *a;     *a = *b;     *b = tmp; }  int main() {     int i = 0,j = 0, m = 1;     char a[5] = {'a','b','c','d','e'};     for(i = 0; i < sizeof(a); i ++)         for(j = 0; j < sizeof(a) - 1; j ++)         {             printf("%d : %s\n", m, a);             change(&a[j], &a[j + 1]);             m ++;         }     return 0; }   [root@cobe ~]# ./allstr  1 : abcde 2 : bacde 3 : bcade 4 : bcdae 5 : bcdea 6 : cbdea 7 : cdbea 8 : cdeba 9 : cdeab 10 : dceab 11 : decab 12 : deacb 13 : deabc 14 : edabc 15 : eadbc 16 : eabdc 17 : eabcd 18 : aebcd 19 : abecd 20 : abced

#include<iostream> #include<vector> #include<iterator> #include<algorithm> using namespace std; int main() {  char ch[] = {'a','b','c','d'};  vector<char> cv(ch,ch+sizeof(ch)/sizeof(char));   copy(cv.begin(),cv.end(),ostream_iterator<char>(cout," "));  cout << endl;  while(next_permutation(cv.begin(),cv.end()))  //标准库有现成的算法  {   copy(cv.begin(),cv.end(),ostream_iterator<char>(cout," "));   cout << endl;  }   return 0; }


Question: C语言中用scanf读数据经常出现问题，比如说读字符读进来之前的一个newline。这个问题有关输入流、缓冲区，但从来没有搞懂过，求教……

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

scanf最后用空白符结尾时，scanf会跳过空白符去读下一个字符，并不是达到你去年\n的效果，你需要用getchar来接收掉 空白符包括空格，制表符，换行符，回车符和换页符

scanf("abc = %d",&abc); 用户必须这么输入 abc=10 =后面才是真正需要输入的整数 但是因为格式串中有格式以外的字符 所以 abc=都必须先输入然后才能输入整数。

scanf( "%d\n" );scanf 格式中的非格式字符，要求原样输入， 其中 空格，回车等空白字符字符，要求必须输入空白字符（空格，\t,\r,\n等） 所以不仅解决不了问题，还会增加问题


Question: 还是C语言基础问题，别嫌烦，我觉得我的基本功根本就不扎实。

printf returned 1是指printf输出了一个字符，然后printf函数返回了这个值.      int x = 500;     printf("%d\n", printf("abcdef%d\n", x));  打印结果为10，abcdef500再加一个换行符，一共10个字符。 函数返回值是一个自定义的量，并不一定是0就指成功，非0就是失败。 对于0是成功，非0是失败是一种编程习惯，因为非零值有很多，如果函数某一步出错，就可以返回一个非零值代表这种出错结果。 例如  char c; if(c == 'a')     return 0; if(c == 'b')     return 1; if(c == 'c')     return 2;

同样，scanf()如果成功了，也返回1，只不过一般我们都没有去使用这个返回值。

printf 返回自己打印的字符数。  main 一般返回 0 表示正常结束，非零表示异常结束。不过这个要你自己写在你的程序文档里的。没有强制规定。

printf是一个函数，它成功打印后返回1，不信楼主把%d改成%s再看看printf返回值是什么


Question: 函数调用问题-参数

好奇地问一下，你这个函数名里的是 mms  是制造报文规约吗？ 是不是IEC-61850里的东西？ 电力自动化方面的动态链接库？

非常感谢二位，主要我是调用动态链接库，可能是调用是出问题了，还以为是未初始化导致的段错误。

引用 1 楼 user-2 的回复: 	char* server = "xxx"; 	char (*domain)[MAX_NAME_LEN]; 	int num = 3; 	mms_fetch_domain_name_list(server, &domain, &num);   我的理解： 1、第二个和第三个参数都是输出参数，所以不需要初始化。如果一定要赋初值，直接为NULL或0就可以了。 2、这个函数的功能，就是要取得一组domain_name。一个domain_name用一个指向一个字符数组的指针表示，也就是 char (*p)[MAX_NAME_LEN]。一组domain_name就是由一组这样的指针表示。这组指针在函数中又组成了一个数组。 但是从参数上看不出来。因为只要第一个指针就够了，你可以通过依次找下一个指针来找到所有的指针。所以， char (*domain)[MAX_NAME_LEN]这样的定义是正确的。执行完函数之后，domain就已经是第一个指针了。但是还有一个问题，就是你要找多少个下一个指针才算完？这就是第三个参数的作用了。它表示指针的个数。 总之，第二个参数和第三个参数都是输出参数。


Question: 关于double和float打印问题，求大神啊

参考float.h: ... #define DBL_DIG         15                      /* # of decimal digits of precision */ #define DBL_EPSILON     2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */ #define DBL_MANT_DIG    53                      /* # of bits in mantissa */ #define DBL_MAX         1.7976931348623158e+308 /* max value */ #define DBL_MAX_10_EXP  308                     /* max decimal exponent */ #define DBL_MAX_EXP     1024                    /* max binary exponent */ #define DBL_MIN         2.2250738585072014e-308 /* min positive value */ #define DBL_MIN_10_EXP  (-307)                  /* min decimal exponent */ #define DBL_MIN_EXP     (-1021)                 /* min binary exponent */ #define _DBL_RADIX      2                       /* exponent radix */ #define _DBL_ROUNDS     1                       /* addition rounding: near */  #define FLT_DIG         6                       /* # of decimal digits of precision */ #define FLT_EPSILON     1.192092896e-07F        /* smallest such that 1.0+FLT_EPSILON != 1.0 */ #define FLT_GUARD       0 #define FLT_MANT_DIG    24                      /* # of bits in mantissa */ #define FLT_MAX         3.402823466e+38F        /* max value */ #define FLT_MAX_10_EXP  38                      /* max decimal exponent */ #define FLT_MAX_EXP     128                     /* max binary exponent */ #define FLT_MIN         1.175494351e-38F        /* min positive value */ #define FLT_MIN_10_EXP  (-37)                   /* min decimal exponent */ #define FLT_MIN_EXP     (-125)                  /* min binary exponent */ #define FLT_NORMALIZE   0 #define FLT_RADIX       2                       /* exponent radix */ #define FLT_ROUNDS      1                       /* addition rounding: near */ ... 浮点数格式 http://bbs.csdn.net/topics/390676437

楼主为什么不 double a = 555.1234567890123456123456789012345612345678901234561234567890123456; float b = 555.1234567890123456123456789012345612345678901234561234567890123456f; 呢？

原因出在，浮点型数据存储的时候，取转换成1.x的小数点后22位进行存储，再转换过来的时候数据就发生改变了，谢谢大家的回复！

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

楼主为什么不   printf("%.888f %.16666lf  \n",b,a); 呢？

Input a float point number:555.1234567890 f=555.123474 hex=44 0A C7 E7 bin= 1000100000010101100011111100111 bin=  10001000   00010101100011111100111     - 136 -127 0.00010101100011111100111     - 9        0.00010101100011111100111

float最多能用7位有效数字  http://blog.csdn.net/dxy612/article/details/5518477

而且后边的小数部分为什么会打印出错，好像不是随机出现的，是不是数据存储的时候进行覆盖了

还是没有搞懂，你给的例子只不过是吧浮点型的数据进行拆分，555是超出了float整数部分的，但是超出的部分是怎么存储的。


Question: 变量前面加 "-" 是什么含义???????

应该是取反吧

这都要问， 还写程序？

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

先上结论，就是取负。 以下假设32位系统，即sizeof(unsigned long)为4。 数据在内存中以补码形式存放。 3的补码：0000 0000 0000 0000 0000 0000 0000 0011 -3的补码：1111 1111 1111 1111 1111 1111 1111 1101 因为以无符号输出，最高位就不代表符号，所以输出10进制数：4294967293 注：4294967293的二进制表示为：1111 1111 1111 1111 1111 1111 1111 1101

总之 他先定义了两个无符号数（没有负数）  然后给其中一个赋予了负值，给你看结果如何。方便你理解  意思就是在定义了是无符号数之后赋予其负值的结果为何，你看了结果就能明白

小心白马非马论，小心求补码非取负论！

引用 12 楼 Z_R_Z_798205 的回复:[quote=引用 4 楼 dustpg 的回复:] 这里这个符号读作"负"  验证结果显示,这里 '-' 号的意义是求补码[/quote]  delete后发现占用内存没有少，所以验证了delete不会归还内存？ C/C++许多没有绝对结论，要看具体实现，有符号负数又不一定绝对是补码， 有些老计算机负数形式是反码，难道就不行么.  这里读作“负”

引用 15 楼 zhao4zhong1 的回复:验证一下对浮点数是怎么求“补码”的？  确实求"补码"这个用在浮点数不正确. 不好意思,我确定一下 "补码" 这一说的范围. 因为我是在做 bitmap 的时候遇到了,bitmap 操作把数据区分为 0 和 1,所以不会去用浮点,所以在 bitmap 里 '-' 号用来求补码

验证一下对浮点数是怎么求“补码”的？

引用 13 楼 dustpg 的回复:[quote=引用 12 楼 Z_R_Z_798205 的回复:] [quote=引用 4 楼 dustpg 的回复:] 这里这个符号读作"负"  验证结果显示,这里 '-' 号的意义是求补码[/quote]  delete后发现占用内存没有少，所以验证了delete不会归还内存？ C/C++许多没有绝对结论，要看具体实现，有符号负数又不一定绝对是补码， 有些老计算机负数形式是反码，难道就不行么.  这里读作“负”[/quote]   不好意思,我没把我的范围说明清楚. 这个问题是基于 gcc 的 C99,内核对内存的数据不存在正负号只说,只存在 0 和 1 只说. 这个问题是在内核 bitmap 时候遇到的,所以这里我对于数据的定义不分正负,只分 0 和 1. 对于 delete 后内存没少这个问题我有点建议,不管是C还是C++,它都是基于一个操作系统来实现它的库, 所以光通过 free 或 delete 来观测内存有无减少判断物理内存的变化,这是及其不对了,毕竟还有缓存和缓冲的存在. 就像使用 malloc 分配内存和 free 内存这两个动作,内存都没有变化,逼近 glib 有自己的内存管理,内核也有自己的内存管理. 这里面涉及太多内存管理的知识..................

引用 18 楼 fefe82 的回复:C99 6.3.1.3 Signed and unsigned integers 1 When a value with integer type is converted to another integer type other than _Bool, if the value can be represented by the new type, it is unchanged. 2 Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type. 3 ...  6.5.3.3 Unary arithmetic operators 3 The result of the unary - operator is the negative of its (promoted) operand. The integer promotions are performed on the operand, and the result has the promoted type.  谢谢

引用 17 楼 zhao4zhong1 的回复:小心白马非马论，小心求补码非取负论！   恩,谢谢

引用 4 楼 dustpg 的回复:这里这个符号读作"负"  验证结果显示,这里 '-' 号的意义是求补码

引用 1 楼 zhao4zhong1 的回复:仅供参考：//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+     通过验证在变量前面加 "-" 号的作用是求补码

引用 9 楼 Z_R_Z_798205 的回复:[quote=引用 6 楼 user-8 的回复:] 取a的相反数  虽然结果肯定不是-3，因为是无符号数  结果为有符号数-3对应的那个无符号数  ????????? 我做过验证 ~b 和 -b 在内核的含义不同,~b 是求反码,-b 是求补码,这种运用在 bitmap 中有重要意义.  谢谢[/quote]  不同那是当然

引用 6 楼 user-8 的回复:取a的相反数  虽然结果肯定不是-3，因为是无符号数  结果为有符号数-3对应的那个无符号数  ????????? 我做过验证 ~b 和 -b 在内核的含义不同,~b 是求反码,-b 是求补码,这种运用在 bitmap 中有重要意义.  谢谢

引用 7 楼 ljh56789 的回复:此处-为单目运算符，b内存是-3的二进制，由于b是unsigned long所以b是-3的二进制所表示的无符号数  我 dump 出内存看多,里面存的的是 b 的补码


Question: c 字符替换问题把表达式如： 1+-*/2  过滤成 1+2

参考《编译原理》中的词法分析和有限状态自动机。  再供参考：//有字符串 //1_22_333,,4444__55555,_666666 //需要解析为 //1 //22 //333 //_ //4444 //55555 //666666 #include <stdio.h> char s[]="1_22_333,,4444__55555,_666666"; char c,*p,*p1; int st; void main() {     st=0;     p=s;     while (1) {         c=*p;         if (0==c) {             switch (st) {             case 1:printf("_\n");    break;             case 2:printf("%s\n",p1);break;             }             break;//         }         switch (st) {         case 0:                  if ('_'==c) {                            st=0;}             else if (','==c) {                            st=1;}             else             {p1=p;                       st=2;}         break;         case 1:                  if ('_'==c) {                            st=1;}             else if (','==c) {printf("_\n");              st=1;}             else             {p1=p;                       st=2;}         break;         case 2:                  if ('_'==c) {*p=0;printf("%s\n",p1);*p=c;st=0;}             else if (','==c) {*p=0;printf("%s\n",p1);*p=c;st=1;}             else             {                            st=2;}         break;         }         p++;     } } //1 //22 //333 //_ //4444 //55555 //666666

感谢大家 ！手机不太好打字 不知道是我手机太次 还是csdn的app有问题页面闪烁的厉害

不知道楼主的真是意思是什么，仅仅只是过滤掉第二个*-+/符号么？  #include <stdlib.h> #include <stdio.h>  int main() {     int lim = 10;     char s[20];     int c,i,last,b = 0;     last = 'a';     for(i = 0; i < lim-1 && (c=getchar()) != EOF && c!='\n'; )     {         if(isspace(c))             continue;         if(b == 0 && (c == '+' || c== '-' || c == '*' || c == '/'))         {             b = 1;             s[i ++] = c;         }         if(isdigit(c))         {             s[i ++] = c;         }         last = c;     }     s[i] ='\0';     printf("%s\n", s);     return i; }  [root@cobe ~]# ./trstc  2+-*/3 2+3 [root@cobe ~]# ./trstc  33+*2345 33+2345 [root@cobe ~]# ./trstc  33 +- * / 2323 33+2323

想了下，算法可以这么写，遇到加减乘除任一一个时，记录它并忽略后面所有的字符，直到数字的出现

把你的代码，我增加了一段试运行后，与你的结果不一致，我这边输入1+-*/2，输出还是为1+-*/2的，  不知道我这边增加的代码是否有问题？  建议你换一个算法看看，  我这边的运行结果   我运行时的代码如下：  #include <stdio.h> int main() { 	int getline(char s[],int lim); 	char s[10]; 	int lim=10; 	 	getline(s,lim); 	 	printf("%s",s);	 }  int getline(char s[],int lim) {     int c,i,last,b;     last = 'a';     for(i = 0; i < lim-1 && (c=getchar()) != EOF && c!='\n'; )     {                 if(isspace(c))             continue;         if((isdigit(c) || c !='.' || last !='.' ) )            if( c != '+' || last != '+')             if(c != '-' || last != '-')               if(c != '*' || last != '*')                 if(c != '/' || last != '/')                      s[i++] = c;         last = c;     }     s[i] ='\0';     return i; }


Question: 根据有序链表生成huffman树，为什遍历不出来啦，新人帮看看代码如下

引用 3 楼 yuhuangkong818 的回复:[quote=引用 1 楼 anshiny的回复:]creathuffman函数从逻辑上讲是错的。 why给点建议啊～～～卡这蛮久[/quote] #include<stdio.h> #include<stdlib.h>  typedef struct data { 	int  weight;//权重  	char ch; //字符  	struct data *lchild, *rchild, *next; } dlink; typedef dlink *linkdata;  linkdata creat() {//输入字符权重  	linkdata head = NULL, s; 	int x; 	char str; 	printf("请输入权重与字符以 0,0结尾  权重在前字符在后 例如:11,a\n"); 	scanf("%d,%c", &x, &str); 	while(x != 0 && str != '0') { 		s = (linkdata)malloc(sizeof(dlink)); 		s->lchild = s->rchild = s->next = NULL; 		s->weight = x; 		s->ch = str; 		if(head) { 			s->next = head; 		} 		head = s; 		scanf("%d,%c", &x, &str);    }    return head;	 }   void print(linkdata head) {//打印 	linkdata p = head; 	int i = 0; 	while(p) { 		printf("%4c---%d", p->ch, p->weight); 		p = p->next; 		i++; 		if(i % 5 == 0) 			printf("\n"); 	} 	printf("\n"); 	return; }  void  sort(linkdata head) { 	linkdata p, q, k; 	dlink t; 	for(p=head; p!=NULL; p=p->next) { 		k = p; 		for(q=k->next; q!=NULL; q=q->next) { 			if(q->weight < k->weight) { 				k = q; 			} 		} 		if(k != p) { 			t.weight = p->weight; 			t.ch = p->ch; 			t.lchild = p->lchild; 			t.rchild = p->rchild;  			p->weight = k->weight; 			p->ch = k->ch; 			p->lchild = k->lchild; 			p->rchild = k->rchild;  			k->weight = t.weight; 			k->ch = t.ch; 			k->lchild = t.lchild; 			k->rchild = t.rchild; 		} 	} }   linkdata insert(linkdata root, linkdata s) { 	linkdata p1, p2; 	if(root == NULL) { 		root = s; 		return root; 	}    	p1 = NULL;    	p2 = root;    	while(p2 && p2->weight<s->weight) {    		p1 = p2;    		p2 = p2->next;    	}    	s->next = p2;    	if(p1 == NULL) { 		root = s; 	} else { 		p1->next = s; 	} 	return root; }  linkdata del(linkdata root, linkdata s) { 	linkdata p1, p2; 	if(root == NULL) { 		return NULL; 	}    	p1 = NULL;    	p2 = root;    	while(p2 && p2!=s) {    		p1 = p2;    		p2 = p2->next;    	} 	if(p2 == NULL) return root;    	if(p1 == NULL) { 		root = s->next; 		return root; 	} 	p1->next = p2->next; 	return root; }   linkdata creathuffman(linkdata root) { 	linkdata s, r1, r2; 	sort(root); 	while(root && root->next) { 		r1 = root; 		r2 = root->next; 		s = (linkdata)malloc(sizeof(dlink)); 		s->next = NULL; 		s->weight = r1->weight + r2->weight; 		s->ch = '#', 		s->lchild = r1; 		s->rchild = r2;		 		root = del(root, r2); 		root = del(root, r1); 		root = insert(root, s); 		r1->next = r2->next = NULL; 	} 	return root; }  void preorder(linkdata t) { 	if(t) { 		printf("(%c)%d ", t->ch, t->weight); 		preorder(t->lchild); 		preorder(t->rchild); 	} }

引用 2 楼 user-3的回复:为什么看起来creathuffman应该是编译不过的 给点意见呗～～～～～

引用 1 楼 anshiny的回复:creathuffman函数从逻辑上讲是错的。 why给点建议啊～～～卡这蛮久

为什么看起来creathuffman应该是编译不过的

creathuffman函数从逻辑上讲是错的。


Question: acm水题

谢谢大家，我今天又试了下没有return 0；也a了，可能那天杭电bug

引用 1 楼 user-3 的回复:真的是return 0的问题吗？  输入是a=0结束？ 是的，没有这句a不了，加了就能a

引用 2 楼 u010165006 的回复:int main() 需要返回一个int值，main()也是函数。 其他题不要return 0；也能ac，这题不行。我也不知道为什么

int main（）{ } 中的int指函数的类型，也就是这个函数结束之后会返回一个什么样的值。

int main() 需要返回一个int值，main()也是函数。

真的是return 0的问题吗？  输入是a=0结束？


Question: ACM水题，uva上的两道，可是就是不知道为啥一直WA，求解啊~~

看了上面一道, 在Problem之前打印几行0.0000是做什么?


Question: C语言三维数组，我直接给出三个下标居然不能输出？

引用 4 楼 qq_33447655 的回复:[quote=引用 3 楼 paschen 的回复:] A[0][0][3] 类型是int， 不是int*  你需要在前面加上&取地址后则是int* 或者A[i][j] 这种形式也是int* 版主，我最后一部分的理解对不？ 我觉得我一段程序，一个函数。我不能只是知道他的语法我想要的是理解！而不是知其然不知其所以然！否则这等于没学！[/quote]  T* a 加1移动的是sizeof(T) T** a加1移动的是sizeof(T*) T[x][y] 加1移动的是sizeof(T[x]) 以此类推

引用 3 楼 paschen 的回复:A[0][0][3] 类型是int， 不是int*  你需要在前面加上&取地址后则是int* 或者A[i][j] 这种形式也是int* 版主，我最后一部分的理解对不？ 我觉得我一段程序，一个函数。我不能只是知道他的语法我想要的是理解！而不是知其然不知其所以然！否则这等于没学！

数组你可以理解为一个指针： 例如int a[2][3]，这时a就是一个指针。 而当你使用a[1][2]时，这就已经相当于将指针指向了这个数据。就已经是一个int了。这时你要把a[1][2]赋值给int *p当然就要取地址。  当你定义三维数组int a[2][3][4]，最终把int *pa = a[1][2];是正确的原理跟上面一样，a[1][2]还未指定到某一个数字，因此它是指针，可以进行赋值操作。  对于pa ++，是相当于将指针移动四个字节的位置。

同意楼上的……

int *pa=&A[0][0][3];


Question: #endif出错

void ... 那条语句后要加上分号

定义函数后面要有分号


Question: 我想用循环去做，但是完全没有思路昂

看看啦。。。。

同一天是指同一个星期几吗? 如果是应该找7的倍数

#include <stdlib.h> #include <stdio.h>  int m[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};  int week(int year, int month, int day) {     int i = 0;     int w = (year + (year - 1)/4 - (year - 1)/100 + (year - 1)/400)%7;     for(i = 1; i < month; i ++){         if(i == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))         {             day ++;         }         day += m[i];     }     w = (w += (day % 7 - 1))%7;     return w; }  int main() {     int year = 0;     int month = 0;     int day = 0;     int i = 0, j = 0;     int w = 0;     int is_r = 0;     printf("输入生日，年月日空格分隔\n");     scanf("%d", &year);     scanf("%d", &month);     scanf("%d", &day);     is_r = year;      w = week(year, month, day);      printf("%d-%d-%d 星期:%d\n", year, month, day, w);     while(1)     {         if(w == week(++year, month, day))         {             printf("最近的相同年为:%d,相差:%d\n",year, year - is_r);             break;         }     } }

阳历比较好算，注意下闰年就可以了。阴历还分大进和小进（有没有30那天） 逻辑理清楚了，实现就很简单了

仅供参考：#include <afxdisp.h> #include <stdio.h> #include <stdlib.h> int main(int argc, TCHAR* argv[]) {     COleDateTime t;     COleDateTimeSpan ts;     CString s,fmt;     int nYear;     int nMonth;     int nDay;     int nHour;     int nMin;     int nSec;     int lDays;     int nHours;     int nMins;     int nSecs;     int i,N;     // initialize MFC and print and error on failure     if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0)) {         printf("Fatal Error: MFC initialization failed\n");         return 1;     }     if (argc<13) {         printf("Usage:%s sYYYY sMM sDD shh smm sss pDD phh pmm pss n {SQL|YYYY|YY}\n",argv[0]);         return 2;     }     if (stricmp(argv[12],"SQL")==0) fmt="%Y-%m-%d %H:%M:%S";     else if (stricmp(argv[12],"YYYY")==0) fmt="%Y%m%d %H%M%S";     else if (stricmp(argv[12],"YY")==0) fmt="%y%m%d %H%M%S";     else {         printf("Usage:%s sYYYY sMM sDD shh smm sss pDD phh pmm pss n {SQL|YYYY|YY}\n",argv[0]);         return 3;     }     nYear =atoi(argv[ 1]);     nMonth=atoi(argv[ 2]);     nDay  =atoi(argv[ 3]);     nHour =atoi(argv[ 4]);     nMin  =atoi(argv[ 5]);     nSec  =atoi(argv[ 6]);     lDays =atoi(argv[ 7]);     nHours=atoi(argv[ 8]);     nMins =atoi(argv[ 9]);     nSecs =atoi(argv[10]);     N     =atoi(argv[11]);     if (N<=0) {         printf("Usage:%s sYYYY sMM sDD shh smm sss pDD phh pmm pss n {SQL|YYYY|YY}\n",argv[0]);         return 4;     }     t=COleDateTime( nYear, nMonth, nDay, nHour, nMin, nSec);     ts=COleDateTimeSpan( lDays, nHours, nMins, nSecs );     for (i=1;i<=N;i++) {         s=t.Format(fmt);         printf("%08d %s\n",i,s);         t=t+ts;     }     return 0; }


Question: 不需要返回值可以用void，可是这个明明需要返回值啊？？

局部变量内存已经释放了，给分吧

那就结贴吧

我懂了


Question: 用vs2013，做C程序出现的问题，bool”类型的实参与“const char*”类型的形参不兼容

括号问题，你代码先比较str[j]>0 得到的bool值才作为参数  改成：  if(strcmp(str[k],str[j])>0)k=j;

if( strcmp( str[k], str[j] ) > 0 ) k=j; 看清楚括号配对


Question: 开机自动启动

在C:\AUTOEXEC.BAT里面加一句： start /D "你的exe文件所在目录" "你的exe文件文件名.exe"

编译于VS2013，其他编译器未测试：  #define STRICT #include <windows.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <objbase.h> #include <shlobj.h> static HRESULT CreateShortCut() { 	HRESULT       hRes;                  /* Returned COM result code */ 	IShellLink*   pShellLink = NULL;            /* IShellLink object pointer */ 	IPersistFile* pPersistFile = NULL;          /* IPersistFile object pointer */ 	WCHAR          wszLinkfile[MAX_PATH]; /* pszLinkfile as Unicode string */ 	int           iWideCharsWritten;     /* Number of wide characters written */ 		hRes = ::CoInitialize(NULL); 		if (hRes != S_OK) 		{ 			printf("初始化COM库失败"); 		} 		hRes = CoCreateInstance(CLSID_ShellLink,     /* pre-defined CLSID of the IShellLink object */ 			NULL,                 /* pointer to parent interface if part of aggregate */ 			CLSCTX_INPROC_SERVER, /* caller and called code are in same process */ 			IID_IShellLink,      /* pre-defined interface of the IShellLink object */ 			(void**)&pShellLink);         /* Returns a pointer to the IShellLink object */ 		if (hRes != S_OK) 		{ 			printf("创建IShellLink实例失败"); 		} 		else 		{ 			hRes = pShellLink->QueryInterface(IID_IPersistFile, (void**) & pPersistFile); 			if (hRes != S_OK) 			{ 				printf("获取IPersistFile接口失败"); 			} 			else 			{ 				//设置快捷方式中的程序路径 				pShellLink->SetPath(L"D:\\Program Files (x86)\\Beyond Compare 3.3.5.15075 Portable.exe"); 				pShellLink->SetWorkingDirectory(L"C:\\"); 				//确保快捷方式路径由ANSI字符串组成 				MultiByteToWideChar( 					CP_ACP, 					0, 					"C:\\Users\\admin\\Desktop\\xcode.lnk", 					-1, 					wszLinkfile, 					MAX_PATH); 				//保存快捷方式 				pPersistFile->Save(wszLinkfile, TRUE); 			} 		} 		pPersistFile->Release(); 		pShellLink->Release(); 		::CoUninitialize(); 	return (hRes); }  int main(int n, char **argv) { 	HRESULT   hRes;                      /* result of calling COM functions */ 	hRes = CoInitialize(NULL); 	if (SUCCEEDED(hRes)) 	{ 		hRes = CreateShortCut();   /* Index of icon in the file */ 	} 	/* call CoUninitialize() and exit the program. */ 	CoUninitialize(); 	return 0; }

那有没有代码可以实现喃

目测楼主是指Windows下开机启动， 其实Windows下可以通过修改注册表的方式添加开机自动启。 还有一个方式就是在Windows自带的启动文件夹下，添加link文件。 就是这个文件夹C:\Users\admin\AppData\Roaming\Microsoft\Windows\Start Menu\Programs下 添加快捷方式，这个可以搜索“c 快捷方式”

可以在开机启动的ini文件中加入要运行的程序

得先把杀毒软件关掉。

windows一般都是通过修改注册表，linux不知道...

可以写到注册表相关位置  http://blog.csdn.net/wchoclate/article/details/17390733

写到注册表里，  或者做成一个服务


Question: 【求助】关于Fibonacci数列

1s内运行完毕思路：费波纳茨数列除10007后的余数也满足费波纳茨数列的特点，这样就可以满足题目要求，并且可计算范围远超题目要求！！！！（要源代码可以找我）

我觉得这里对10007求余的好处仅是为了能将结果保存到数组中. 因为Fn很快会比int大，导致溢出，结果错误。 ans[i]=(ans[i-1]+ans[i-2])%mod; 而且每次循环求余不会对影响结果。

我自己的程序，样例输入为10时结果正确，样例输入为22时就错误。谁知道原因是什么：#include<stdio.h> int main() { 	int n,i,s; 	scanf("%d",&n); 	int a[n]; 	a[0]=a[1]=a[2]=1; 	for(i=3;i<=n;i++) 	{ 		a[i]=a[i-1]+a[i-2]; 	} 	 s=a[n]%1007; 	 printf("%d",s); 	return 0; }

参考答案。为什么要“ ans[i]=(ans[i-1]+ans[i-2])%mod;”：#include<cstdio> const int mod=10007; const int MAXN=1000000+10; int ans[MAXN]; int main() {     ans[1]=ans[2]=1;     int n;     scanf("%d",&n);     for(int i=3;i<=n;i++)         ans[i]=(ans[i-1]+ans[i-2])%mod;     printf("%d\n",ans[n]);     return 0; }

参考@user-4 的思想，  试着编写着代码发现1,000,000范围内的运行在3秒内运行完成（包括手动输入n值的时间）  试着输入16位的数字，运行时间为36s，自己觉得此方法不错，  #include <stdio.h> int main() { 	//Fn=Fn-1+Fn-2 ==> Rn=Rn-1+Rn+2    	unsigned long mod=10007; 	int n; 	int Rn1=1; 	int Rn2=1; 	int Ans,i,tmp;  	printf("input n:\n"); 	scanf("%d",&n);  	for(i=0;i<n;i++) 	{ 		if(i==0) 			Ans=Rn1; 		else if(i==1) 			Ans=Rn2; 		else if(i==2) 			Ans=Rn1+Rn2; 		else 		{ 			tmp=Rn1; 			Rn1=Ans%mod; 			Rn2=tmp%mod; 			Ans=(Rn1+Rn2)%mod; 		} 	}  	printf("input n is:%d\n",n); 	printf("remainder is:%d\n",Ans); 	 	return 0; }

因为有 (a + b) % c == (a % c + b % c) % c 所以，每次加法运算后取模与最终取模等价，但是有不溢出的好处


Question: 顺序表里面'ListInsert_Sq' : cannot convert parameter 3 from 'int' to 'int *'

引用 7 楼 yjxkyjxk 的回复:把完整的代码贴上来，我们试着调试看看? 找到错误的根源了，我太马虎了。 最开始函数声明的时候，第三个参数写成指针了，实现的时候却用的是变量，然后就各种报错过不去---

把完整的代码贴上来，我们试着调试看看?

引用 5 楼 user-2 的回复:查一查下面的xxx是什么 typedef xxx ElemType;  typedef int Status; typedef int ElemType; typedef struct SqList{ 	ElemType *elem; 	int length; 	int listsize; }SqList;

查一查下面的xxx是什么 typedef xxx ElemType;

引用 3 楼 yjxkyjxk 的回复:[quote=引用 2 楼 qq_17049875 的回复:] typedef int Status; 预定义的Status语句是这个  不太清楚编译器是否自己会对深层次的数据类型进行检查，不过看报错信息，目测不会。  从规避我们不了解的深层次的部分、还是维护代码的可读性，建议还是在第一层传入参数时，其数据类型与函数定义时一致。[/quote] int i; 	ElemType t = 0; 	for(i = 0;i < 5;i++) 	{ 		ListInsert_Sq(&L, i , t); 		t ++; 	} 依然还是刚才的错误！cannot convert parameter 3 from 'int' to 'int *'

引用 2 楼 qq_17049875 的回复:typedef int Status; 预定义的Status语句是这个  不太清楚编译器是否自己会对深层次的数据类型进行检查，不过看报错信息，目测不会。  从规避我们不了解的深层次的部分、还是维护代码的可读性，建议还是在第一层传入参数时，其数据类型与函数定义时一致。

typedef int Status; 预定义的Status语句是这个

调用 ListInsert_Sq(&L, i , i);时，其函数定义为  Status ListInsert_Sq(SqList *L,int i ,ElemType e)  而i的定义在代码中为 int ,  与原函数定义 ElemType 不一致


Question: 求助Winsock和多线程的问题

表达的不清楚！！！  什么时候判断html网页传输完毕，  http服务器响应客户端： http/1.1 200 OK\r\n Content-Length:   感觉长度判断，满意不


Question: c语言的问题 其运行结果我看不懂

引用 4 楼 qq_33869330 的回复:其中“a%cb%c\tc%c\tabc\n”是什么来的， 我见过%d\n和%f的  没见过这样的a%cb%c\tc%c\tabc\n  能说说  大神们    我把你的代码大概这样子隔开看得比较清楚，具体的我也不是很知道，因为我也是刚学，大概就是ASCII码一些字符之间的转换。每一个对应一个字母的输出这样子。。不是很懂 例如第一条输出是输出c1 c2 c3，就是分别对应的，你看图片。

%c 是对应一个char型。%d 是对应一个int型。%f 是对应一个float型。%s 是对应一个char *型。 \t \n 等为转义字符。 详细内容可以baidu c 转义字符 格式化符

引用 2 楼 qq_33869330 的回复:结果上面的aabb  cc  abc   B a什么的是什么来的  与代码有什么关系？ 你对应的看这条输出语句：  printf("a%cb%c\tc%c\tabc\n",c1,c2,c3);

结果上面的aabb  cc  abc   B a什么的是什么来的  与代码有什么关系？

都是一些ASCII码与字符的对应转换，没什么难的。


Question: 请各位帮我看看这段C源码那里不对。

#include<stdio.h> #include<math.h> int main() {   void max(int a,int b,int c);     void min(int a,int b,int c);     void f();    double a4;    int a1,a2,a3;    scanf("%d%d%d",&a1,&a2,&a3);    a4=a2*a2-4*a1*a3;     if(a4>0) 	{      max(a1,a2,a3); 	}      else if(a4==0) 	{      min(a1,a2,a3); 	}     else     f();     return 0; } void max(int a,int b,int c)  {     int i,j,x1,x2;     i=(-b)/2*a;     j=sqrt(b*b-4*a*c);     x1=i+j;x2=i-j;     printf("%d %d\n",x1,x2);  } void min(int a,int b,int c) {    int i;    i=(-b)/2*a;    printf("%d\n",i);  } void f() { printf("无解\n");  }

好的，谢谢，成功解决问题。

引用 1 楼 zhangxiangDavaid 的回复:至少需要修改成这样：  #include<stdio.h> #include<stdio.h> #include<math.h> //函数名如果不能见名知义，但也不能让人产生误解 int compute1(int a, int b, int c); int compute2(int a, int b, int c); void f(); int main() { 	double a4; 	int a1, a2, a3; 	scanf("%d%d%d", &a1, &a2, &a3); 	a4 = a2*a2 - 4 * a1*a3; 	if (a4>0) 	{ 		max(a1, a2, a3); 	} 	else if (a4 == 0)  	{ 		min(a1, a2, a3); 	} 	else 		f(); 	return 0; } int compute1(int a, int b, int c) { 	int i, j, x1, x2; 	i = (-b) / 2 * a; 	j = sqrt(b*b - 4 * a*c); 	x1 = i + j; x2 = i - j; 	printf("%d %d\n", x1, x2);  } int compute2(int a, int b, int c) { 	int i; 	i = (-b) / 2 * a; 	printf("%d\n", i); } void f() { 	printf("无解\n"); }   大大，我在请问下，我刚才我在试了下你的代码，可是还是有错误，请问是什么原因呢？你可以试试你的电脑？

引用 1 楼 zhangxiangDavaid 的回复:至少需要修改成这样：  #include<stdio.h> #include<stdio.h> #include<math.h> //函数名如果不能见名知义，但也不能让人产生误解 int compute1(int a, int b, int c); int compute2(int a, int b, int c); void f(); int main() { 	double a4; 	int a1, a2, a3; 	scanf("%d%d%d", &a1, &a2, &a3); 	a4 = a2*a2 - 4 * a1*a3; 	if (a4>0) 	{ 		max(a1, a2, a3); 	} 	else if (a4 == 0)  	{ 		min(a1, a2, a3); 	} 	else 		f(); 	return 0; } int compute1(int a, int b, int c) { 	int i, j, x1, x2; 	i = (-b) / 2 * a; 	j = sqrt(b*b - 4 * a*c); 	x1 = i + j; x2 = i - j; 	printf("%d %d\n", x1, x2);  } int compute2(int a, int b, int c) { 	int i; 	i = (-b) / 2 * a; 	printf("%d\n", i); } void f() { 	printf("无解\n"); }   好的，谢谢。


Question: 为什么普通数组传到函数里面sizeof返回就不正确了

C/C++ 里的根本没办法把数组类型作为参数传入函数，传到函数内的已经退化成了指针，sizeof得到的是指针的大小

另外字符数组应该也一样，如果是字符串可以用strlen得到大小，其他数组你需要自己把数组大小传入函数内

形式参数是变量 传进来后，数组名作为一个地址，赋值给了一个指针变量，sizeof的结果是指针的大小 字符串数组，是字符串，还是指针数组？如果是字符串，sizeof结果也是指针，strlen才是长度；如果是指针数组，仍然得到指针大小


Question: 点对点通信，这个概念是不是有多个解释？我看维基的是ppp

“点对点通信“和”ppp“是两个概念  ppp是 point to point protocol, 也就是点对点协议。  ppp 是数据链路层的协议。可以理解为“点对点通信“的一种实现。而且，计算机网络中说到的点对点通信，一般也就是指数据链路层上的点对点通信。  另外有一个概念是  p2p  ，即 Peer to Peer ，是指对等网络。

icmp并不传输数据 tcp传输数据  如果把数据比作货物，tcp比作运输货物的汽车，那么可以把icmp比作检查道路是否通畅的工作人员。 汽车发现一条道路不通时，它会选择另一条路走；发现路堵塞时，它会慢点开。 而工作人员发现道路有问题时，他就向单位报告。

先坚持把书看完。

引用 3 楼 HeBanBei 的回复:第二个问题。  icmp检查和报告差错的原因，但它没有改正错误。  tcp的可靠传输，没有能力知道也不需要知道造成差错的原因。 但它能发现错误并修正错误。 修正错误？  tcp有确认机制， 超时重传（发方一旦发出一个保文，就开启定时器，等待这个发送数据的ack应答：ack == seq + len）  如果发现错误的时候，收方会发送icmp包给发送方。


Question: ++自增运算符的计算顺序

关于C,C++表达式求值顺序 http://blog.csdn.net/fefe82/article/details/37833767，http://bbs.csdn.net/topics/370153775

这是一个不确定行为，编译器可以任意实现

置顶帖、置顶帖、置顶帖……

(++c) + (c++)   这类的代码在项目里是不会用的，用了会被经理骂的，个人觉得好像只有考试这么干，  个人建议不用太花心思在这上面，如果真有这类的题，弄不明白就跳过好了。其他作好即可。

楼上几位说的都挺有道理，还是建议楼主写代码时分开写，这样就不用纠结，输出是几了。 另外我在VS2010上试了下，那两种输出都是 4 6。

查了一下sequence point 这些例子应该都是不对的

如果一个表达式不仅算出一个值，还修改了环境，就说这个表达式有副作用（因为它多做了额外的事）。c++和++c 就是有副作用的表达式。  C/C++ 语言的规定，任何依赖于特定计算顺序、依赖于在顺序点之间实现修改效果的表达式，其结果都没有保证  也就是说，你的那段代码换个编译器的话，结果很有可能就不一样了

同一个表达式中,对同一个变量不能超过一次赋值


Question: 利用C语言对txt文件进行处理

先定义结构体，最好读一下c语言的结构部分

仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen("data.txt","r");     if (NULL==f) {         printf("Can not open file data.txt!\n");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,"NAME: %32[^\n]",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,"DIMENSION: %d",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,"DATA\n")) st=3;         } else if (st==3) {             if (3==sscanf(ln,"%d%d%d",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf("s.NAME=[%s]\n",s.NAME);     printf("s.DIMENSION=%d\n",s.DIMENSION);     for (i=0;i<n;i++) {         printf("s.DATA[%d].NO,X,Y=%d,%d,%d\n",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8

先定义结构体，你知道分隔符是什么，读出来。。。

利用getline过去每一行数据储存到iostream类对象中，然后将每一个iostream类读入到string中，就可以每行数据以空格键为分隔单个读入数据，创建一个结构用于储存数据就OK咧

至少你把结构体先给定义出来……


Question: 一个信号报告的程序，编译没有错误，结果是空的，倒是多出了一行”请按任意键继续“

system("pause");就是按任意键继续啊。 至于你说的“结果是空的”，因为你的变量是整型，与switch的常量字符不匹配（如 1！='1'）。

好吧，我以前也犯过类似的错误，不过慢慢改正就好了，加油！！

引用 4 楼 Tim_Alan 的回复:问题找到了，case 在这段代码里面本该接一个整型常量，但是加了‘’之后就变成了字符常量，所以匹配不到，没有结果（错误太低级了，刚开始学编程不要喷没事，这种情况，很正常， 抱歉，回答对你没有帮助

引用 3 楼 lm_whales 的回复:R=0,S=任意 0～9 S=0，R=任意整数， 这些情况都没有考虑进去 不知道是不会出现这种情况，还是写代码的时候漏掉了？ S=1~9，R=1~5，没描述清楚不好意思

system("pause");就是按任意键继续啊。

输入一个小于60的正整数试试看。 如果输入的是大于59的且各个位是0的正数，或0，确实会如楼主说所说的输出。


Question: windows sdk函数DPtoLP的问题

参考MSDN中的例子代码中调用DPtoLP的地方。 MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl

和设置的 显示器分辨率 以及 显示器 尺寸有关系吧


Question: 求问一个能删除数组中连续的相同的数的方法，谢谢！

int rm(int *a,int n,int reps){     int i,j,k;     //[j,i) =>a[k..]     for(i=0,j=0,k=0;i<n;i++){         if(a[i]!=a[j]){             if(i-j>=reps) k-=i-j;             j =i;         }         a[k++]=a[i];     }     if(i-j>=reps) k-=i-j;     return k; }

//0 1 1 3 4 4

直接上代码：  #include <stdio.h> void removeDuplicate(int *arr, int n, int *newSize) { 	int i, j, k, key, times; 	i = j = 0; 	key = arr[0]; 	while (j < n) { 		times = 0; 		while (j < n && arr[j] == key) { 			j++; 			times++; 		} 		if (times < 3) { 			for (k = 0; k < times; k++) { 				arr[i++] = arr[j - times + k]; 			} 		} 		if (j < n) { 			key = arr[j]; 		} 	} 	*newSize = i; } int main(void){ 	int arr[] = { 0,1,1,2,2,2,3,4,4,5,5,5,5 }; 	int n = sizeof(arr) / sizeof(arr[0]); 	int newSize; 	removeDuplicate(arr, n, &newSize); 	//打印 	for (n = 0; n < newSize; n++) { 		printf("%d ", arr[n]); 	} 	return 0; }

另外，考虑到删除后，可能会出现前面跳过的序列跟后面新的没处理的序列合并后，有相同数据的情况 也要特别关注一下，不然可能会产生错误的结果

分成两种序列  1）不相同序列跳过， 2）相同序列，处理（删除掉） 判断只是个循环，并计数的过程

感谢大家的帮助！！

可以用两层循环依次找出重复的数，当然你也可以先排序，然后再删除

补充： 1.tmpRepeatCount表示repeatArray数组里已经被赋值的个数  2."再建一个数组"指，再建一个数组用于存放经过删除处理后的orignArray值

参考二楼paschen的意见，这边再详细下思路，如下：  可定义宏:#define repeatCount 3  输入的20个数的原始数组定义为orignArray[10]，其数据的下标我们用index表示，如origrnArray[0]对应的index值为0  再初始化一个重复数组repeatArray[20]，这个数组里被输入的数我们定义为tmpRepeatCount=0  做一个for循环，20个数中抽取第一个数与其他数做对比，对比规则如下： 1.如抽取的第一个数与其他数不相等，则对比下一个 2.如抽取的第一个数与其他数相等，则把对index值赋予repeatArray数组的第一个元素，tmpRepeatCount+1 3.当第一个数与其他数对比完成后，判断此条件tmpRepeatCount>=repeatCount 为真，则删除orignArray[repeatArray[i]] 4.循环step1~3，把第二个数与其他数对比。注其他数指第三个数到第20个数  其中删除方法，可自己定义如赋值'\0'，或者再建一个数组什么的。  over


Question: C 代码转 java 代码的问题

在线等，急急急


Question: 请问学数据结构前需要学习C++吗?我有一些C语言的基础,求高手指教!

刚好我在C入门中，下来也该琢磨数据结构了。此贴对我很有用

引用 19 楼 u012502355 的回复:] #10 看到了吗，他那里有好资料。 不论什么语言，掌握了数据结构和算法的用法才是重要的。 test

引用 20 楼 u010165006 的回复:[quote=引用 16 楼 yyxgs 的回复:] [quote=引用 15 楼 u010165006 的回复:] 建议楼主还是看《大话数据结构》吧，有一些比喻比较形象好理解，又不失专业。   请问严蔚敏《数据结构(C语言版)》和你推荐的这本书哪本比较适合新手呢?[/quote] 你可以去当当网或者亚马逊先看看这本书的评论。[/quote]   哦哦，那你的意见呢?

引用 19 楼 u012502355 的回复:#10 看到了吗，他那里有好资料。 不论什么语言，掌握了数据结构和算法的用法才是重要的。   嗯嗯，看到了，谢谢你们!

引用 16 楼 yyxgs 的回复:[quote=引用 15 楼 u010165006 的回复:] 建议楼主还是看《大话数据结构》吧，有一些比喻比较形象好理解，又不失专业。   请问严蔚敏《数据结构(C语言版)》和你推荐的这本书哪本比较适合新手呢?[/quote] 你可以去当当网或者亚马逊先看看这本书的评论。

引用 23 楼 u010165006 的回复:[quote=引用 22 楼 yyxgs 的回复:] [quote=引用 20 楼 u010165006 的回复:] [quote=引用 16 楼 yyxgs 的回复:] [quote=引用 15 楼 u010165006 的回复:] 建议楼主还是看《大话数据结构》吧，有一些比喻比较形象好理解，又不失专业。   请问严蔚敏《数据结构(C语言版)》和你推荐的这本书哪本比较适合新手呢?[/quote] 你可以去当当网或者亚马逊先看看这本书的评论。[/quote]   哦哦，那你的意见呢?[/quote] 如果你不是计算机专业的，还是大话好点。[/quote]   谢谢!

引用 22 楼 yyxgs 的回复:[quote=引用 20 楼 u010165006 的回复:] [quote=引用 16 楼 yyxgs 的回复:] [quote=引用 15 楼 u010165006 的回复:] 建议楼主还是看《大话数据结构》吧，有一些比喻比较形象好理解，又不失专业。   请问严蔚敏《数据结构(C语言版)》和你推荐的这本书哪本比较适合新手呢?[/quote] 你可以去当当网或者亚马逊先看看这本书的评论。[/quote]   哦哦，那你的意见呢?[/quote] 如果你不是计算机专业的，还是大话好点。

引用 1 楼 lrgdongnan 的回复:不需要，数据结构和语言是分离的，有C语言基础就可以学数据结构了！   谢谢!!请问大神数据结构到底是什么?资料上都太抽象,完全不懂...

引用 2 楼 lilianjie001 的回复:有C语言的基础学习起来比较容易，不一定非得学习C++，C++也不是一时半会能学好的   谢谢指点!

不需要，数据结构和语言是分离的，有C语言基础就可以学数据结构了！

引用 17 楼 u012502355 的回复:不论什么语言，只要你会其中的一种。然后结合数据结构学习，关键是代码练习。这样提高才比较快。。   谢谢指点,数据结构对其他语言也是有用的吗?

引用 15 楼 u010165006 的回复:建议楼主还是看《大话数据结构》吧，有一些比喻比较形象好理解，又不失专业。   请问严蔚敏《数据结构(C语言版)》和你推荐的这本书哪本比较适合新手呢?

建议楼主还是看《大话数据结构》吧，有一些比喻比较形象好理解，又不失专业。

引用 7 楼 lrgdongnan 的回复:数据结构，说白了，就是讲在计算机里怎么表示数据，处理数据。建议你看《数据结构 严蔚敏版》这本书，适合初学者！   哦哦，原来是这样,谢谢!

引用 9 楼 qq_30539199 的回复:我也正在学，看视频吧，可以懂的，只要坚持住！！   嗯嗯，共同加油

引用 8 楼 wang0635 的回复:数据结构是用什么语言描述的，就需要什么语言的基础   哦哦，需要专业数学知识吗?

完全不需要，数据结构可以用于任何语言


Question: 求推荐一款调试c/c++的工具

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

引用 6 楼 akirya 的回复:[quote=引用 5 楼 ID19870510 的回复:] [quote=引用 4 楼 akirya 的回复:] [quote=引用 2 楼 ID19870510 的回复:] [quote=引用 1 楼 akirya 的回复:] 这个是IDE的基本功能，没这个功能只能成为文本编辑器。  我用eclipse的 CDT插件 为啥没法直接看变量的值[/quote] 直接上visual stduio [/quote]  额 我电脑有点烂。。有没有轻便点的 推荐一下[/quote] 那得多烂啊，现在3000块的本子跑VS速度都能接受。[/quote] 不对，都能eclipse了 跑VS只会比eclipse快。

引用 6 楼 akirya 的回复:[quote=引用 5 楼 ID19870510 的回复:] [quote=引用 4 楼 akirya 的回复:] [quote=引用 2 楼 ID19870510 的回复:] [quote=引用 1 楼 akirya 的回复:] 这个是IDE的基本功能，没这个功能只能成为文本编辑器。  我用eclipse的 CDT插件 为啥没法直接看变量的值[/quote] 直接上visual stduio [/quote]  额 我电脑有点烂。。有没有轻便点的 推荐一下[/quote] 那得多烂啊，现在3000块的本子跑VS速度都能接受。[/quote]   五六年前的电脑了  vs不够很大吗 有没有小点的

引用 5 楼 ID19870510 的回复:[quote=引用 4 楼 akirya 的回复:] [quote=引用 2 楼 ID19870510 的回复:] [quote=引用 1 楼 akirya 的回复:] 这个是IDE的基本功能，没这个功能只能成为文本编辑器。  我用eclipse的 CDT插件 为啥没法直接看变量的值[/quote] 直接上visual stduio [/quote]  额 我电脑有点烂。。有没有轻便点的 推荐一下[/quote] 那得多烂啊，现在3000块的本子跑VS速度都能接受。

引用 4 楼 akirya 的回复:[quote=引用 2 楼 ID19870510 的回复:] [quote=引用 1 楼 akirya 的回复:] 这个是IDE的基本功能，没这个功能只能成为文本编辑器。  我用eclipse的 CDT插件 为啥没法直接看变量的值[/quote] 直接上visual stduio [/quote]  额 我电脑有点烂。。有没有轻便点的 推荐一下

引用 2 楼 ID19870510 的回复:[quote=引用 1 楼 akirya 的回复:] 这个是IDE的基本功能，没这个功能只能成为文本编辑器。  我用eclipse的 CDT插件 为啥没法直接看变量的值[/quote] 直接上visual stduio

引用 2 楼 ID19870510 的回复:[quote=引用 1 楼 akirya 的回复:] 这个是IDE的基本功能，没这个功能只能成为文本编辑器。  我用eclipse的 CDT插件 为啥没法直接看变量的值[/quote] 那只能说CDT插件做得烂呗。

引用 1 楼 akirya 的回复:这个是IDE的基本功能，没这个功能只能成为文本编辑器。  我用eclipse的 CDT插件 为啥没法直接看变量的值

这个是IDE的基本功能，没这个功能只能成为文本编辑器。

Vs2010 外加 插件 VA_X，用好了绝对爽

VS 2012变量监控，汇编代码对应源码，内存查看，寄存器，调用的dll 一目了然，不要太爽

我用qtcreator加提取版的vc编译器，还可以，调试估计要装vs

当然是VS了，电脑性能不好建议先换台电脑吧，搞计算机的还说电脑性能不好，太寒碜了吧！

Dev C++很不错

在WINDOWS下你就用VS吧，调试功能已经很强大了，你说的只是其中最基本的功能，而且VS调试时对STL中容器也有特别处理

code blocks


Question: 在VS下调用system时 路径有空格为什么就显示找不到文件

引用 3 楼 libinden71 的回复:[quote=引用 2 楼 user-1 的回复:] 有空格要用双引号括起来  system("start \"F:\\Visual Studio\\Common7\\IDE\\devenv.exe\""); 运行起来是这样的，没有打开软件！ 我换了个也有空格的软件的路径  结果显示居然是一样的怎么不是D:[/quote]‘   system("start  \"\"  \"F:\\Visual Studio\\Common7\\IDE\\devenv.exe\"");

引用 2 楼 user-1 的回复:有空格要用双引号括起来  system("start \"F:\\Visual Studio\\Common7\\IDE\\devenv.exe\""); 运行起来是这样的，没有打开软件！ 我换了个也有空格的软件的路径  结果显示居然是一样的怎么不是D:

是不是 字符集的问题啊？


Question: 关于C语言跨平台编码问题

引用 5 楼 zxh707wk 的回复:跨平台不如不跨平台 严重同意！  说“跨平台一定比不跨平台好”就和说“双性恋一定比异性恋好”一样！

跨平台不如不跨平台

一点小小的经验,注意 unsigned long 和 unsigned int 的区别,这个很重要!!!!!!

1. 这个，还真的是需要穷举。 2. 你不在实际的平台上编译一下，怎么知道不同平台需要包含的头文件是不是一样。 3. 编译器啊，不同的平台又有不同的编译器。

在你的底层进行一次封装。 而在这些封装中使用 #ifdef 之类的宏来进行条件编译。


Question: 请大家帮忙看下代码 任意值相加等于固定值的组合问题

仅供参考：//n个(2<=n<=20)整数(整数范围-10<=x<=10)，判断是否可以从这n个数中找到若干个数，其和为10 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <algorithm> using namespace std; int MAXN=20; int MINN=2; int x[20]; int n,i,j,k,sum; int main() {     srand((unsigned)time(NULL));     n=MINN+rand()%(MAXN-1);     for (i=0;i<n;i++) {         x[i]=-10+rand()%21;         printf("%d,",x[i]);     }     printf("\n");     sort(&x[0],&x[n]);     do {         for (i=2;i<=n;i++) {             sum=0;             k=n/2-i/2;             for (j=k;j<k+i;j++) {                 sum+=x[j];             }             if (10==sum) {                 for (j=k;j<k+i;j++) {                     if (j==k+i-1) {                         printf("%d==10\n",x[j]);                     } else {                         printf("%d+",x[j]);                     }                 }                 printf("YES\n");                 return 1;             }         }     } while (next_permutation(&x[0],&x[n]));     printf("NO\n");     return 0; }

动态规划，动态规划


引用 4楼super_miker 的回复:[quote=引用 2 楼 smileFFFF 的回复:] 我想用麻烦点的，就是逐个判断句子中的每一个单词，在逐个替换，应该怎么弄啊？   这个错在哪了啊 #include<stdio.h> #include<string.h> int main() { 	char a[10000]; 	int l,i,b; 	 	while(scanf("%s",a)!=EOF) 	{ 	 	l=strlen(a); 	for(i=0;i<l;i++) 		{ 			if(a[i]=='b') 			a[i]=' '; 			continue; 			if(a[i]=='q') 			a[i]=','; 			continue; 			if(a[i]=='t') 			a[i]='!'; 			continue; 			if(a[i]=='m') 			a[i]='l'; 			continue; 			if(a[i]=='i') 			a[i]='e'; 			continue; 			if(a[i]=='c') 			a[i]='a'; 			continue; 			if(a[i]=='a') 			a[i]='c'; 			continue; 			if(a[i]=='e') 			a[i]='i'; 			continue; 			 		} 	for(i=0;i<l;i++) 		printf("%s",a[i]);  	}   return 0; }  	for(i=0;i<l;i++) 		printf("%s",a[i]); => printf("%s", a);[/quote]谢谢～

引用 2 楼 smileFFFF 的回复:我想用麻烦点的，就是逐个判断句子中的每一个单词，在逐个替换，应该怎么弄啊？   这个错在哪了啊 #include<stdio.h> #include<string.h> int main() { 	char a[10000]; 	int l,i,b; 	 	while(scanf("%s",a)!=EOF) 	{ 	 	l=strlen(a); 	for(i=0;i<l;i++) 		{ 			if(a[i]=='b') 			a[i]=' '; 			continue; 			if(a[i]=='q') 			a[i]=','; 			continue; 			if(a[i]=='t') 			a[i]='!'; 			continue; 			if(a[i]=='m') 			a[i]='l'; 			continue; 			if(a[i]=='i') 			a[i]='e'; 			continue; 			if(a[i]=='c') 			a[i]='a'; 			continue; 			if(a[i]=='a') 			a[i]='c'; 			continue; 			if(a[i]=='e') 			a[i]='i'; 			continue; 			 		} 	for(i=0;i<l;i++) 		printf("%s",a[i]);  	}   return 0; }  	for(i=0;i<l;i++) 		printf("%s",a[i]); => printf("%s", a);

参考：  #include <stdio.h> #include <string.h> int i; char str[10001]; char encrypt[] = "c adifghejkmlnopqrs!uvwxyz"; int main(void) { 	while (1) { 		if (1 == scanf("%10001s", str)) { 			for (i = 0; i < strlen(str); i++) { 				str[i] = encrypt[str[i] - 'a']; 			} 			printf("%s\n", str); 		} 		else break; 	} 	return 0; }

#include<stdio.h> #include<string.h> int main(){     char str[10010];     char tab[200];     int i;     memset(tab,'0',sizeof(tab));     char *t1="bqtmicael";     char *t2=" ,!leacim";     for(i=0;i<9;i++){         tab[t1[i]]=t2[i];     }          while(gets(str)){         for(i=0;str[i];i++){             if(tab[str[i]]!='0'){                 putchar(tab[str[i]]);             }else{                 putchar(str[i]);             }         }         printf("\n");     }     return 0; }