Question: localtime mktime 高效的实现

楼上的为什么总是这个回复

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。 Linux或Unix下用GDB调试。  GDB常用命令 调用gdb编译需要在cc后面加 -g参数再加-o； [root@redhat home]#gdb 调试文件：启动gdb (gdb) l ：（字母l）从第一行开始列出源码 (gdb) break n :在第n行处设置断点 (gdb) break func：在函数func()的入口处设置断点 (gdb) info break： 查看断点信息 (gdb) r：运行程序 (gdb) n：单步执行 (gdb) c：继续运行 (gdb) p 变量 ：打印变量的值 (gdb) bt：查看函数堆栈 (gdb) finish：退出函数 (gdb) shell 命令行：执行shell命令行 (gdb) set args 参数:指定运行时的参数 (gdb) show args：查看设置好的参数 (gdb) show paths:查看程序运行路径；            set environment varname [=value] 设置环境变量。如：set env USER=hchen；             show environment [varname] 查看环境变量； (gdb) cd 相当于shell的cd; (gdb)pwd ：显示当前所在目录 (gdb)info program： 来查看程序的是否在运行，进程号，被暂停的原因。 (gdb)clear 行号n：清除第n行的断点 (gdb)delete 断点号n：删除第n个断点 (gdb)disable 断点号n：暂停第n个断点 (gdb)enable 断点号n：开启第n个断点 (gdb)step：单步调试如果有函数调用，则进入函数；与命令n不同，n是不进入调用的函数的 list ：简记为 l ，其作用就是列出程序的源代码，默认每次显示10行。 list 行号：将显示当前文件以“行号”为中心的前后10行代码，如：list 12 list 函数名：将显示“函数名”所在函数的源代码，如：list main list ：不带参数，将接着上一次 list 命令的，输出下边的内容。 注意 ：如果运行list 命令得到类似如下的打印，那是因为在编译程序时没有加入 -g 选项： (gdb) list 1       ../sysdeps/i386/elf/start.S: No such file or directory.         in ../sysdeps/i386/elf/start.S run：简记为 r ，其作用是运行程序，当遇到断点后，程序会在断点处停止运行，等待用户输入下一步的命令。 回车：重复上一条命令。 set args：设置运行程序时的命令行参数，如：set args 33 55 show args：显示命令行参数 continue：简讯为 c ，其作用是继续运行被断点中断的程序。 break：为程序设置断点。 break 行号：在当前文件的“行号”处设置断点，如：break  33 break 函数名：在用户定义的函数“函数名”处设置断点，如：break cb_button info breakpoints：显示当前程序的断点设置情况 disable breakpoints Num：关闭断点“Num”，使其无效，其中“Num”为 info breakpoints 中显示的对应值 enable breakpoints Num：打开断点“Num”，使其重新生效 step：简记为 s ，单步跟踪程序，当遇到函数调用时，则进入此函数体（一般只进入用户自定义函数）。 next：简记为 n，单步跟踪程序，当遇到函数调用时，也不进入此函数体；此命令同 step 的主要区别是，step 遇到用户自定义的函数，将步进到函数中去运行，而 next 则直接调用函数，不会进入到函数体内。 until：当你厌倦了在一个循环体内单步跟踪时，这个命令可以运行程序直到退出循环体。 finish： 运行程序，直到当前函数完成返回，并打印函数返回时的堆栈地址和返回值及参数值等信息。 stepi或nexti：单步跟踪一些机器指令。 print 表达式：简记为 p ，其中“表达式”可以是任何当前正在被测试程序的有效表达式，比如当前正在调试C语言的程序，那么“表达式”可以是任何C语言的有效表达式，包括数字，变量甚至是函数调用。 print a：将显示整数 a 的值 print ++a：将把 a 中的值加1,并显示出来 print name：将显示字符串 name 的值 print gdb_test(22)：将以整数22作为参数调用 gdb_test() 函数 print gdb_test(a)：将以变量 a 作为参数调用 gdb_test() 函数 bt：显示当前程序的函数调用堆栈。 display 表达式：在单步运行时将非常有用，使用display命令设置一个表达式后，它将在每次单步进行指令后，紧接着输出被设置的表达式及值。如： display a watch 表达式：设置一个监视点，一旦被监视的“表达式”的值改变，gdb将强行终止正在被调试的程序。如： watch a kill：将强行终止当前正在调试的程序 help 命令：help 命令将显示“命令”的常用帮助信息 call 函数(参数)：调用“函数”，并传递“参数”，如：call  gdb_test(55) layout：用于分割窗口，可以一边查看代码，一边测试： layout src：显示源代码窗口 layout asm：显示反汇编窗口 layout regs：显示源代码/反汇编和CPU寄存器窗口 layout split：显示源代码和反汇编窗口 Ctrl + L：刷新窗口 quit：简记为 q ，退出gdb 当然，gdb的功能远不止这些，包括多进程/多线程/信号/远程调试等功能在这里均没有提及，有需要的读者可以参考其它信息 本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/pizi0475/archive/2011/03/08/6232749.aspx

引用 2 楼 zhao4zhong1 的回复:参考localtime和mktime的源代码。 C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\localtim.c /*** *localtim.c - Convert __time32_t value to time structure * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       Converts time stored as a __time32_t value to a structure of type *       struct tm expressed as local time. * *******************************************************************************/  #include <cruntime.h> #include <limits.h> #include <time.h> #include <stddef.h> #include <memory.h> #include <ctime.h> #include <internal.h>   /*** *struct tm *_localtime32_s(ptm, ptime) - convert __time32_t value to tm structure * *Purpose: *       Convert a value in 32-bit internal (__time32_t) format to a tm struct *       containing the corresponding local time. * * NOTES: *       (1) gmtime must be called before _isindst to ensure that the tb time *           structure is initialized. *       (2) gmtime and localtime use a single statically allocated buffer. *           Each call to one of these routines destroys the contents of the *           previous call. *       (3) __time32_t is a 32-bit long integer representing the number of seconds *           since 00:00:00, 01-01-70 (UTC) (i.e., the Posix/Unix Epoch. Only *           non-negative values are supported. *       (4) It is assumed that the maximum adjustment for local time is *           less than three days (include Daylight Savings Time adjustment). *           This only a concern in Posix where the specification of the TZ *           environment restricts the combined offset for time zone and *           Daylight Savings Time to 2 * (24:59:59), just under 50 hours. * *Entry: *       __time32_t *ptime - pointer to a long time value * *Exit: *       errno_t = 0 success *                 tm members filled-in *       errno_t = non zero *                 tm members initialized to -1 if ptm != NULL * *Exceptions: *       See items (3) and (4) in the NOTES above. If these assumptions are *       violated, behavior is undefined. * *******************************************************************************/  errno_t __cdecl _localtime32_s (         struct tm *ptm,         const __time32_t *ptime         ) {         __time32_t ltime;         errno_t e = 0;         int daylight = 0;         long dstbias = 0;         long timezone = 0;          _VALIDATE_RETURN_ERRCODE( ( ptm != NULL ), EINVAL )         memset( ptm, 0xff, sizeof( struct tm ) );          _VALIDATE_RETURN_ERRCODE( ( ptime != NULL ), EINVAL )          /*          * Check for illegal __time32_t value          */         _VALIDATE_RETURN_ERRCODE_NOEXC( ( *ptime >= 0 ), EINVAL )          __tzset();          _ERRCHECK(_get_daylight(&daylight));         _ERRCHECK(_get_dstbias(&dstbias));         _ERRCHECK(_get_timezone(&timezone));           if ( (*ptime > 3 * _DAY_SEC) && (*ptime < LONG_MAX - 3 * _DAY_SEC) ) {                 /*                  * The date does not fall within the first three, or last                  * three, representable days of the Epoch. Therefore, there                  * is no possibility of overflowing or underflowing the                  * __time32_t representation as we compensate for timezone and                  * Daylight Savings Time.                  */                  ltime = *ptime - timezone;                 e = _gmtime32_s( ptm, <ime );                 if ( e != 0 )                 {                     return e;                 }                  /*                  * Check and adjust for Daylight Saving Time.                  */                 if ( daylight && _isindst( ptm ) ) {                         ltime -= dstbias;                         e = _gmtime32_s( ptm, <ime );                         if ( e != 0 )                         {                             return e;                         }                         ptm->tm_isdst = 1;                 }         }         else {                 e = _gmtime32_s( ptm, ptime );                 if ( e != 0 )                 {                     return e;                 }                  /*                      * The date falls with the first three, or last three days                  * of the Epoch. It is possible the __time32_t representation                  * would overflow or underflow while compensating for                  * timezone and Daylight Savings Time. Therefore, make the                  * timezone and Daylight Savings Time adjustments directly                  * in the tm structure. The beginning of the Epoch is                  * 00:00:00, 01-01-70 (UTC) and the last representable second                  * in the Epoch is 03:14:07, 01-19-2038 (UTC). This will be                  * used in the calculations below.                  *                  * First, adjust for the timezone.                  */                 if ( daylight && _isindst(ptm) ) {                         ltime = (__time32_t)ptm->tm_sec - (timezone + dstbias);                         ptm->tm_isdst = 1;                 }                 else                         ltime = (__time32_t)ptm->tm_sec - timezone;                 ptm->tm_sec = (int)(ltime % 60);                 if ( ptm->tm_sec < 0 ) {                         ptm->tm_sec += 60;                         ltime -= 60;                 }                  ltime = (__time32_t)ptm->tm_min + ltime/60;                 ptm->tm_min = (int)(ltime % 60);                 if ( ptm->tm_min < 0 ) {                         ptm->tm_min += 60;                         ltime -= 60;                 }                  ltime = (__time32_t)ptm->tm_hour + ltime/60;                 ptm->tm_hour = (int)(ltime % 24);                 if ( ptm->tm_hour < 0 ) {                         ptm->tm_hour += 24;                         ltime -=24;                 }                  ltime /= 24;                  if ( ltime > 0 ) {                         /*                          * There is no possibility of overflowing the tm_mday                          * and tm_yday fields since the date can be no later                          * than January 19.                          */                         ptm->tm_wday = (ptm->tm_wday + (int)ltime) % 7;                         ptm->tm_mday += (int)ltime;                         ptm->tm_yday += (int)ltime;                 }                 else if ( ltime < 0 ) {                         /*                          * It is possible to underflow the tm_mday and tm_yday                          * fields. If this happens, then adjusted date must                          * lie in December 1969.                          */                         ptm->tm_wday = (ptm->tm_wday + 7 + (int)ltime) % 7;                         if ( (ptm->tm_mday += (int)ltime) <= 0 ) {                                 ptm->tm_mday += 31;                                 // according to assumption 4 above, timezone can                                 // cause the date to underflow the epoch by                                 // more than a day                                 ptm->tm_yday = ptm->tm_yday + (int)ltime + 365;                                 ptm->tm_mon = 11;                                 ptm->tm_year--;                         }                         else {                                 ptm->tm_yday += (int)ltime;                         }                 }           }           return 0; }   /*** *struct tm *_localtime32(ptime) - convert __time32_t value to tm structure * *Purpose: *       Convert a value in 32-bit internal (__time32_t) format to a tm struct *       containing the corresponding local time. * * NOTES: *       (1) gmtime must be called before _isindst to ensure that the tb time *           structure is initialized. *       (2) gmtime and localtime use a single statically allocated buffer. *           Each call to one of these routines destroys the contents of the *           previous call. *       (3) It is assumed that __time32_t is a 32-bit long integer representing *           the number of seconds since 00:00:00, 01-01-70 (UTC) (i.e., the *           Posix/Unix Epoch. Only non-negative values are supported. *       (4) It is assumed that the maximum adjustment for local time is *           less than three days (include Daylight Savings Time adjustment). *           This only a concern in Posix where the specification of the TZ *           environment restricts the combined offset for time zone and *           Daylight Savings Time to 2 * (24:59:59), just under 50 hours. * *Entry: *       __time32_t *ptime - pointer to a long time value * *Exit: *       If *ptime is non-negative, returns a pointer to the tm structure. *       Otherwise, returns NULL. * *Exceptions: *       See items (3) and (4) in the NOTES above. If these assumptions are *       violated, behavior is undefined. * *******************************************************************************/  struct tm * __cdecl _localtime32 (         const __time32_t *ptime         ) {         errno_t e;         struct tm *ptm = __getgmtimebuf();         if ( ptm == NULL )         {             return NULL;         }          e = _localtime32_s( ptm, ptime );         if ( e != 0 )         {             return NULL;         }         return ptm; }  我也知道linux 内核也有但是看不懂~~

C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\mktime.c /*** *mktime.c - Convert struct tm value to __time32_t value. * *       Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: *       Defines _mktime32() and _mkgmtime32(), routines to converts a time value *       in a tm structure (possibly incomplete) into a __time32_t value, then *       update (all) the structure fields with "normalized" values. * *******************************************************************************/  #include <cruntime.h> #include <stddef.h> #include <ctime.h> #include <time.h> #include <internal.h>  /*  * ChkAdd evaluates to TRUE if dest = src1 + src2 has overflowed  */ #define ChkAdd(dest, src1, src2)   ( ((src1 >= 0L) && (src2 >= 0L) \     && (dest < 0L)) || ((src1 < 0L) && (src2 < 0L) && (dest >= 0L)) )  /*  * ChkMul evaluates to TRUE if dest = src1 * src2 has overflowed  */ #define ChkMul(dest, src1, src2)   ( src1 ? (dest/src1 != src2) : 0 )   /*  * Core function for both _mktime32() and _mkgmtime32()  */ static __time32_t __cdecl _make__time32_t( struct tm *, int);   /*** *__time32_t _mktime32(tb) - Normalize user time block structure * *Purpose: *       _mktime32 converts a time structure, passed in as an argument, into a *       calendar time value in internal format (__time32_t). It also completes *       and updates the fields the of the passed in structure with 'normalized' *       values. There are three practical uses for this routine: * *       (1) Convert broken-down time to internal time format (__time32_t). *       (2) To have _mktime32 fill in the tm_wday, tm_yday, or tm_isdst fields. *       (3) To pass in a time structure with 'out of range' values for some *           fields and have _mktime32 "normalize" them (e.g., pass in 1/35/87 and *           get back 2/4/87). *Entry: *       struct tm *tb - pointer to a tm time structure to convert and *                       normalize * *Exit: *       If successful, _mktime32 returns the specified calender time encoded as *       a __time32_t value. Otherwise, (__time32_t)(-1) is returned to indicate an *       error. * *Exceptions: *       None. * *******************************************************************************/  _CRTIMP __time32_t __cdecl _mktime32 (         struct tm *tb         ) {         return( _make__time32_t(tb, 1) ); }   /*** *__time32_t _mkgmtime32(tb) - Convert broken down UTC time to __time32_t * *Purpose: *       Convert a tm structure, passed in as an argument, containing a UTC *       time value to internal format (__time32_t). It also completes and updates *       the fields the of the passed in structure with 'normalized' values.  *Entry: *       struct tm *tb - pointer to a tm time structure to convert and *                       normalize * *Exit: *       If successful, _mkgmtime returns the calender time encoded as __time32_t *       Otherwise, (__time32_t)(-1) is returned to indicate an error. * *Exceptions: *       None. * *******************************************************************************/  _CRTIMP __time32_t __cdecl _mkgmtime32 (         struct tm *tb         ) {         return( _make__time32_t(tb, 0) ); }   /*** *static __time32_t _make__time32_t(tb, ultflag) - * *Purpose: *       Converts a struct tm value to a __time32_t value, then updates the struct *       tm value. Either local time or UTC is supported, based on ultflag. *       This is the routine that actually does the work for both _mktime32() and *       _mkgmtime32(). * *Entry: *       struct tm *tb - pointer to a tm time structure to convert and *                       normalize *       int ultflag   - use local time flag. the tb structure is assumed *                       to represent a local date/time if ultflag > 0. *                       otherwise, UTC is assumed. * *Exit: *       If successful, _mktime32 returns the specified calender time encoded as *       a __time32_t value. Otherwise, (__time32_t)(-1) is returned to *       indicate an error. * *Exceptions: *       None. * *******************************************************************************/  static __time32_t __cdecl _make__time32_t (         struct tm *tb,         int ultflag         ) {         __time32_t tmptm1, tmptm2, tmptm3;         struct tm tbtemp;         long dstbias = 0;         long timezone = 0;          _VALIDATE_RETURN( ( tb != NULL ), EINVAL, ( ( __time32_t )( -1 ) ) )          /*          * First, make sure tm_year is reasonably close to being in range.          */         if ( ((tmptm1 = tb->tm_year) < _BASE_YEAR - 1) || (tmptm1 > _MAX_YEAR           + 1) )             goto err_mktime;           /*          * Adjust month value so it is in the range 0 - 11.  This is because          * we don't know how many days are in months 12, 13, 14, etc.          */          if ( (tb->tm_mon < 0) || (tb->tm_mon > 11) ) {              /*              * no danger of overflow because the range check above.              */             tmptm1 += (tb->tm_mon / 12);              if ( (tb->tm_mon %= 12) < 0 ) {                 tb->tm_mon += 12;                 tmptm1--;             }              /*              * Make sure year count is still in range.              */             if ( (tmptm1 < _BASE_YEAR - 1) || (tmptm1 > _MAX_YEAR + 1) )                 goto err_mktime;         }          /***** HERE: tmptm1 holds number of elapsed years *****/          /*          * Calculate days elapsed minus one, in the given year, to the given          * month. Check for leap year and adjust if necessary.          */         tmptm2 = _days[tb->tm_mon];         if ( !(tmptm1 & 3) && (tb->tm_mon > 1) )                 tmptm2++;          /*          * Calculate elapsed days since base date (midnight, 1/1/70, UTC)          *          *          * 365 days for each elapsed year since 1970, plus one more day for          * each elapsed leap year. no danger of overflow because of the range          * check (above) on tmptm1.          */         tmptm3 = (tmptm1 - _BASE_YEAR) * 365L + ((tmptm1 - 1L) >> 2)           - _LEAP_YEAR_ADJUST;          /*          * elapsed days to current month (still no possible overflow)          */         tmptm3 += tmptm2;          /*          * elapsed days to current date. overflow is now possible.          */         tmptm1 = tmptm3 + (tmptm2 = (__time32_t)(tb->tm_mday));         if ( ChkAdd(tmptm1, tmptm3, tmptm2) )             goto err_mktime;          /***** HERE: tmptm1 holds number of elapsed days *****/          /*          * Calculate elapsed hours since base date          */         tmptm2 = tmptm1 * 24L;         if ( ChkMul(tmptm2, tmptm1, 24L) )             goto err_mktime;          tmptm1 = tmptm2 + (tmptm3 = (__time32_t)tb->tm_hour);         if ( ChkAdd(tmptm1, tmptm2, tmptm3) )             goto err_mktime;          /***** HERE: tmptm1 holds number of elapsed hours *****/          /*          * Calculate elapsed minutes since base date          */          tmptm2 = tmptm1 * 60L;         if ( ChkMul(tmptm2, tmptm1, 60L) )             goto err_mktime;          tmptm1 = tmptm2 + (tmptm3 = (__time32_t)tb->tm_min);         if ( ChkAdd(tmptm1, tmptm2, tmptm3) )             goto err_mktime;          /***** HERE: tmptm1 holds number of elapsed minutes *****/          /*          * Calculate elapsed seconds since base date          */          tmptm2 = tmptm1 * 60L;         if ( ChkMul(tmptm2, tmptm1, 60L) )             goto err_mktime;          tmptm1 = tmptm2 + (tmptm3 = (__time32_t)tb->tm_sec);         if ( ChkAdd(tmptm1, tmptm2, tmptm3) )             goto err_mktime;          /***** HERE: tmptm1 holds number of elapsed seconds *****/          if  ( ultflag ) {              /*              * Adjust for timezone. No need to check for overflow since              * localtime() will check its arg value              */              __tzset();              _ERRCHECK(_get_dstbias(&dstbias));             _ERRCHECK(_get_timezone(&timezone));              tmptm1 += timezone;              /*              * Convert this second count back into a time block structure.              * If localtime returns NULL, return an error.              */             if ( _localtime32_s(&tbtemp, &tmptm1) != 0 )                 goto err_mktime;              /*              * Now must compensate for DST. The ANSI rules are to use the              * passed-in tm_isdst flag if it is non-negative. Otherwise,              * compute if DST applies. Recall that tbtemp has the time without              * DST compensation, but has set tm_isdst correctly.              */             if ( (tb->tm_isdst > 0) || ((tb->tm_isdst < 0) &&               (tbtemp.tm_isdst > 0)) ) {                 tmptm1 += dstbias;                 if ( _localtime32_s(&tbtemp, &tmptm1) != 0 )                     goto err_mktime;             }          }         else {             if ( _gmtime32_s(&tbtemp, &tmptm1) != 0 )                 goto err_mktime;         }          /***** HERE: tmptm1 holds number of elapsed seconds, adjusted *****/         /*****       for local time if requested                      *****/          *tb = tbtemp;         return (__time32_t)tmptm1;  err_mktime:         /*          * All errors come to here          */          errno = EINVAL;         return (__time32_t)(-1); }

#include "time.h" #include "stdlib.h" #include "stdio.h" #include "math.h" #define BEGIN_YEAR 1970 #define USER_BEGIN_YEAR 1900 #define YEAR_DIFFERENCE (BEGIN_YEAR - USER_BEGIN_YEAR) enum TIME_DEF {         SEC = 1,         MIN = SEC * 60,         HOUR = MIN * 60,         DAY = HOUR * 24,          YEAR = DAY * 365, }; time_t time_difference = 8 * HOUR; #define YEAR_CYCLE_DAY ((365 * 3) + 366) //1461 size_t leap(size_t year) {     if(((year%4) == 0 && (year%100) != 0 )|| (year%400) == 0 ) return 1;     else return 0; }  static time_t mom_day_table[2][12]={                 {31,28,31,30,31,30,31,31,30,31,30,31},                 {31,29,31,30,31,30,31,31,30,31,30,31}, };   tm* localtime(time_t *p) {         if(!p)         {                 return nullptr;         }         time_t t  = *p;         static tm ret;         memset(&ret,0,sizeof(ret));          t += time_difference;          time_t day = t / DAY;         day += 719542;         time_t year_not_cycle_day = day % YEAR_CYCLE_DAY;          ret.tm_year = ((day / YEAR_CYCLE_DAY) * 4);         ret.tm_year += year_not_cycle_day / 365;         ret.tm_year -= BEGIN_YEAR;          year_not_cycle_day %= 365;             size_t switc_table = leap(BEGIN_YEAR + ret.tm_year);          for(size_t i = 0;i < 12; ++i)         {                 if(year_not_cycle_day >= mom_day_table[switc_table][i])                 {                         year_not_cycle_day -= mom_day_table[switc_table][i];                         ret.tm_mon ++;                 }                 else                 {                         break;                 }         }            year_not_cycle_day ++;         ret.tm_mday = year_not_cycle_day;         ret.tm_sec = t % MIN;         ret.tm_min = (t % HOUR) / MIN;         ret.tm_hour = (t % DAY) / HOUR;         ret.tm_wday = t + (3 * DAY);          ret.tm_wday %= (7 * DAY);         ret.tm_wday /= DAY;         ret.tm_year  += YEAR_DIFFERENCE;           return &ret; } time_t mktime(int year,int mon,int day,int hour,int min,int sec) {         static time_t mon_yday[2][12] =         {                 {0,31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},                 {0,31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335},         };          time_t ret = 0;          time_t tool_day = 0;         year += BEGIN_YEAR;         year -= YEAR_DIFFERENCE;         year += mon / 12;         mon %= 12; //1461         tool_day += (year / 4) * YEAR_CYCLE_DAY;         tool_day += (year % 4) * 365;          tool_day -= 719542l;         if(mon > 0) tool_day += mon_yday[leap(year)][mon];         else if(mon < 0) tool_day -= mon_yday[leap(year)][abs(mon)];         tool_day += day - 1;         ret += tool_day * DAY;         ret += hour * HOUR;         ret += min * MIN;         ret += sec * SEC;          return ret - time_difference; } time_t mktime(tm* mk) {         if(!mk)         {                 return 0;         }         return mktime(mk->tm_year,mk->tm_mon,mk->tm_mday,mk->tm_hour,mk->tm_min,mk->tm_sec); }


Question: C语言菜鸟求助，[Error] expected identifier before 'false'

楼主，你这是C语言的写法，但是文件确却是C++后缀名，建立的文件不对，所以报错

楼主标题标明c语言，却又是c++代码，麻烦下次选好分类

引用 4 楼 baijiaheizhiganmao 的回复:typedef enum {false, true} bool; 删掉这句.false和true是内置的,你完全可以直接拿来用.但是这个是示例，是不能删的。只可以改自己写的子程序

Dev C++中，新建项目时，选择C项目，这样自动产生的文件就是C语言文件，而不是C++的了 再把你上面那些代码复制进去 编译就按C语言的语法了

这是题目要求

引用 9 楼 only_one_moment 的回复:应该是我自己写的子函数不正确和原来主函数没关系的 把文件名 “数组作业1.cpp” 改成 “数组作业1.c“

应该是我自己写的子函数不正确和原来主函数没关系的

引用 7 楼 wang0635 的回复:引用 6 楼 only_one_moment 的回复:[quote=引用 2 楼 wang0635 的回复:] 文件名改成 1.c 试试。好像在C++中false是个关键字不行。。。 将编译器出错信息完整贴上来看看[/quote]

引用 6 楼 only_one_moment 的回复:引用 2 楼 wang0635 的回复:文件名改成 1.c 试试。好像在C++中false是个关键字不行。。。 将编译器出错信息完整贴上来看看

文件名改成 1.c 试试。好像在C++中false是个关键字

就是做一个带头结点的链表的操作，只有子函数是我们的作业，前面的头文件的声明都是不能动的，但是出现了 5	14	E:\未命名1.cpp	[Error] expected unqualified-id before 'false' 5	14	E:\未命名1.cpp	[Error] expected identifier before 'false' 这两个错误。没找出来。求帮助，谢谢~~~


Question: 能帮我解释一下这整道题的原理吗

else 和最接近的 if 搭配

{     int	x = 100, a = 10, b = 20;     int	v1 = 5, v2 = 0;     if (a < b)         if (b != 15)             if(!v1) 				x = 1;             else 				if(v2) 					x = 10;     x = -1;     printf("%d\n", x); } 这样能看清楚了吧

这代码风格真是不能忍...  else 和最接近的 if 搭配  最后的x = -1;跟上面的if else没有任何关系 所以程序相当于给x赋值-1


Question: 求解释

楼主不适合当码农。鉴定完毕。

if(x!=y) 	{ 		if(x>y)  			printf("X>Y\n"); 		else     			printf("X<Y\n"); 	} 	else 		printf("X==Y\n");  楼主这样看，也许就明白了。

这不是来判断两个数的大小吗？

判断两整数关系

引用 7 楼 zhao4zhong1 的回复:楼主不适合当码农。鉴定完毕。 楼主应该找更高大上的职业。。

就是代码不明白啊

题在哪呢，只看到了代码

整个都不明白

你哪里不明白？

显示两个数关系,只有>,<,= 三种


Question: 计算机软件基本知识二：可执行文件的结构和加载

学会使用dumpbin（windows）和objdump（linux）

《Windows PE权威指南》


Question: 二叉树的非递归遍历算法都是什么意思？

我当年看算法也没一次就看懂，看不懂只要先知道有原理和有这么回事就行，先往后看，等有一些基础再回来看也就明白了

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

递归就是嵌套调用一个函数，非递归就是除了递归的

贴出看不懂的地方

非递归法就是迭代法，一两句说不清楚，建议看书


Question: 计算机软件基本知识一：堆和栈 （作者：刘涛）

谢谢刘涛的精彩介绍，学习了。

不错，很详细，学习了


Question: 利用栈写非递归二叉树的中序遍历，求哪里错了

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

引用 1 楼 宇智波菜鸟的回复:思路就不正确，如果是中序遍历的话，在访问其右孩子节点时，该节点必须在栈中。在退出栈操作里，你还得判断这个节点有没有被访问过，数据结构里必须要增加一项标识。 非常感谢，明白了，谢谢


Question: win32 API 图形基础问题

多谢 解决了

你这个明显一开始cxClient和cyClient都没值。 应该在WM_CREATE的消息里用GetClientRect给这两个变量赋值；第二个方法就是你在窗口显示后调整窗口大小，触发WM_SIZE消息。

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {     static int cxClient, cyClient;     HDC hdc;     PAINTSTRUCT ps;     HPEN	hPen, hPenOld;	//增加两个变量     switch (message)     {     case WM_SIZE:         cxClient = LOWORD(lParam);         cyClient = HIWORD(lParam);//你原来打成了cxClient了         return 0;     case WM_PAINT:         hdc = BeginPaint(hwnd, &ps);          //////////////////划线的颜色         hPen = CreatePen( PS_SOLID , 3 , RGB( 255 , 0 , 0 )); 		hPenOld = ( HPEN )SelectObject ( hdc , hPen ); 		///////////////////          Rectangle(hdc, cxClient / 8, cyClient / 8,                   7 * cxClient / 8, 7 * cyClient / 8);          MoveToEx(hdc, 0, 0, NULL);         LineTo(hdc, cxClient, cyClient);          MoveToEx(hdc, 0, cyClient, NULL);         LineTo(hdc, cxClient, 0);          Ellipse(hdc, cxClient / 8, cyClient / 8,                 7 * cxClient / 8, 7 * cyClient / 8);          RoundRect(hdc, cxClient / 4, cyClient / 4,                   3 * cxClient / 4, 3 * cyClient / 4,                   cxClient / 4, cyClient / 4);          /////////////////释放         SelectObject (hdc , hPenOld); 		DeleteObject ( hPen );         //////////////////          EndPaint(hwnd, &ps);         return 0;     case WM_DESTROY:         PostQuitMessage(0);         return 0;     }     return DefWindowProc(hwnd, message, wParam, lParam);  }  改成这样试试

断点的时候 while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg);   } 这个 一直循环没有执行  其他我和书上对了很多遍没有问题

首先保证你的代码是都执行了。 更新窗口试试


Question: 新人求助文件文件读取遇到的问题

没准还得加一句     wcout.imbue(locale("chs")); 在开头才能正确输出汉字。

先将文件d:\a\a.txt在记事本中另存为编码为Unicode的文件。 typedef struct{  wchar_t s[100][20];  wchar_t vexs[100];  int arcs[100][100]; } MGraph;  MGraph *G;  G = (MGraph *)malloc(sizeof(MGraph));  FILE *gp;  gp = fopen("d:\\a\\a.txt", "r,css=UTF16-LE");    for (i = 1; i <= n; i++){     fwscanf(gp, L"%s" ,G->s[i]);  }  fclose(gp);   for (i = 1; i <= n; i++)  wcout<< G->s[i]<<endl;

改为%s试试

文本内容    a吉吉米， 不死，  四部，  费，  像，  及，  还有，  不过，  爱上，  跟他，  好吧，  换吗，  奋斗，  上网，     主要是想把这些存成结点的名称

代码 typedef struct{  char s[100][20];  char vexs[100];  int arcs[100][100]; }MGraph;       MGraph *G;  G = (MGraph *)malloc(sizeof(MGraph));  FILE *gp;  gp = fopen("d:\\a\\a.txt", "r");    for (i = 1; i <= n; i++){  fscanf(gp, "%c" ,&G->s[i]);    }  fclose(gp);   for (i = 1; i <= n; i++)  cout<< G->s[i]<<endl;


Question: 在全局变量中复制二维数组为什么复制不进去

fscanf(fp,"%d",&board[i][j]); 改为:fscanf(fp,"%c",&board[i][j]);

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

引用 3 楼 lin5161678 的回复:[quote=引用 2 楼 hhhhhhhhhhkkkkkkkkkk 的回复:] 呵呵，二维数组不像一维数组这样好复制，你这个要用值复制的话，应该这样： 将  memcpy(current.state,board,sizeof(board));  改成  for(int i=0;i<SIZE;i++)     memcpy(current.state[i],board[i],sizeof(board[i]));  也就是要一维一维的复制。说错了 二维数组 直接这样复制就可以了   memcpy(current.state,board,sizeof(board));  完全没问题  [/quote] 唉，二维指针用习惯了都忘了二维数组还可以这样，太失败了。 楼主你这程序好像没啥毛问题，我用VS都编译出结果了，正常的，只不过因为显示用的是%d，所以结果是数字。

引用 2 楼 hhhhhhhhhhkkkkkkkkkk 的回复:呵呵，二维数组不像一维数组这样好复制，你这个要用值复制的话，应该这样： 将  memcpy(current.state,board,sizeof(board));  改成  for(int i=0;i<SIZE;i++)     memcpy(current.state[i],board[i],sizeof(board[i]));  也就是要一维一维的复制。说错了 二维数组 直接这样复制就可以了   memcpy(current.state,board,sizeof(board));  完全没问题

fscanf(fp,"%d",&board[i][j]);  你这里给的 "%d" ，但是后边给了一个 char *，这肯定是不行的。  你需要在输入之后输出一把，看看你的读入是不是就已经失败了。


Question: 图像去重方法

训练不都要重复吗？没有重复的训练靠谱吗？


Question: https如果没有数字证书，服务器公钥是直接在握手的时候发送给客户端？

1. 握手是产生会话密钥, 必须要有证书 2. 消息认证是让接收方能够识别消息源, 真伪之类, 签名是保证不被小三侵犯, 双方骗骗无妨

up 起来，高手呢

引用 1 楼 akirya 的回复:证书是确定服务器是不是伪造的。  你的意思是，要搞https规定：数字证书必须存在？   我第1个问题，是看别人帖子里，书本上没有明说，也是第一次见过这个说法，就赶紧问问。  对了，那第2个问题呢？

证书是确定服务器是不是伪造的。


Question: 怎么通过一次循环找到两个最小值

int a[n]; //a[n]初始化 ... int min1=a[0],min2=a[0],b=0; for(int i =0;i<n; i ++) { if(a[i]<min1) min1=a[i]; if(min1<min2) { b=min2; min1=b; min2=min1; } }

引用 1 楼 user-2 的回复:定义两个变量来存两个最小值，假如为min1（最小）与min2（第二小），循环中判断，如果比min1小，让min2等于min1，min1等于此数；如果介于min1与min2之间，则min2等于此数，这亲遍历完一遍就是两个最小的数了  min1初值设置为数组中前两个数中小的那个，min2是大的那个


Question: 985考研题。

void 指针，变参函数，宏，Variant 类型等等都可以 宏最简单 void 指针，可变参数  需要多传入一个参数表示类型 可变参数，参数和数据类型一致，可以传入三个参数，1个表示类型，两个表示，被除数和结果 void* 需要传入地址，而非数值 另外一种是用 struct 包装 类型和数值信息。 就像 Variant 数据类型一样 任何一种都可以

引用 4 楼 wang0635 的回复:用void指针可以吧 #include <stdio.h>  enum data_type {INT, LONG, FLOAT, DOUBLE}; void div2(void *in, void *out, enum data_type type);  int main() { 	int		i1 = 1, i2; 	long	l1 = 222222222L, l2; 	float	f1 = 1.9f, f2; 	double	d1 = 2.3, d2;  	div2(&i1, &i2, INT); 	printf("i1 = %d, i2 = %d\n", i1, i2); 	div2(&l1, &l2, LONG); 	printf("l1 = %ld, l2 = %ld\n", l1, l2); 	div2(&f1, &f2, FLOAT); 	printf("f1 = %f, f2 = %f\n", f1, f2); 	div2(&d1, &d2, DOUBLE); 	printf("d1 = %f, d2 = %f\n", d1, d2);  	return 0; }  void div2(void *in, void *out, enum data_type type) { 	switch (type) 	{ 	case INT: 		*(int *)out = *(int *)in / 2; 		break; 	case LONG: 		*(long *)out = *(long *)in / 2; 		break; 	case FLOAT: 		*(float *)out = *(float *)in / 2; 		break; 	case DOUBLE: 		*(double *)out = *(double *)in / 2; 		break; 	} }  增加一个参数，实现类型识别，这个想法可以。

用  char*  读进来  再计算

引用 8 楼 angel6709 的回复:这出题老师只有教学经验，没有任何工作经验，鉴定完毕 个人觉得有的时候高校考试题目有孔乙己之嫌

引用 2 楼 ipqtjmqj 的回复:如果可以用宏函数, 则很简单 #define DIV2(data) ((data) / 2) 如果不可以: 不知道函数可以增加一个参数吗, 用'i', 'l', 'f', 'd'显式表示类型. http://codepad.org/fquSdoPH居然可以是void类型

这出题老师只有教学经验，没有任何工作经验，鉴定完毕

引用 6 楼 include500 的回复:[quote=引用 4 楼 wang0635 的回复:] 用void指针可以吧 #include <stdio.h>  enum data_type {INT, LONG, FLOAT, DOUBLE}; void div2(void *in, void *out, enum data_type type);  int main() { 	int		i1 = 1, i2; 	long	l1 = 222222222L, l2; 	float	f1 = 1.9f, f2; 	double	d1 = 2.3, d2;  	div2(&i1, &i2, INT); 	printf("i1 = %d, i2 = %d\n", i1, i2); 	div2(&l1, &l2, LONG); 	printf("l1 = %ld, l2 = %ld\n", l1, l2); 	div2(&f1, &f2, FLOAT); 	printf("f1 = %f, f2 = %f\n", f1, f2); 	div2(&d1, &d2, DOUBLE); 	printf("d1 = %f, d2 = %f\n", d1, d2);  	return 0; }  void div2(void *in, void *out, enum data_type type) { 	switch (type) 	{ 	case INT: 		*(int *)out = *(int *)in / 2; 		break; 	case LONG: 		*(long *)out = *(long *)in / 2; 		break; 	case FLOAT: 		*(float *)out = *(float *)in / 2; 		break; 	case DOUBLE: 		*(double *)out = *(double *)in / 2; 		break; 	} } 没看懂 enum data_type {INT, LONG, FLOAT, DOUBLE}; void div2(void *in, void *out, enum data_type type); 这是第一排枚举吧，第二排定义的函数太复杂没看懂。 对于我新手来说不知道怎么回事。[/quote] 这个函数原型见过吧 void qsort(void *base,int nelem,int width,int (*fcmp)(const void *,const void *));

引用 4 楼 wang0635 的回复:用void指针可以吧 #include <stdio.h>  enum data_type {INT, LONG, FLOAT, DOUBLE}; void div2(void *in, void *out, enum data_type type);  int main() { 	int		i1 = 1, i2; 	long	l1 = 222222222L, l2; 	float	f1 = 1.9f, f2; 	double	d1 = 2.3, d2;  	div2(&i1, &i2, INT); 	printf("i1 = %d, i2 = %d\n", i1, i2); 	div2(&l1, &l2, LONG); 	printf("l1 = %ld, l2 = %ld\n", l1, l2); 	div2(&f1, &f2, FLOAT); 	printf("f1 = %f, f2 = %f\n", f1, f2); 	div2(&d1, &d2, DOUBLE); 	printf("d1 = %f, d2 = %f\n", d1, d2);  	return 0; }  void div2(void *in, void *out, enum data_type type) { 	switch (type) 	{ 	case INT: 		*(int *)out = *(int *)in / 2; 		break; 	case LONG: 		*(long *)out = *(long *)in / 2; 		break; 	case FLOAT: 		*(float *)out = *(float *)in / 2; 		break; 	case DOUBLE: 		*(double *)out = *(double *)in / 2; 		break; 	} } 没看懂 enum data_type {INT, LONG, FLOAT, DOUBLE}; void div2(void *in, void *out, enum data_type type); 这是第一排枚举吧，第二排定义的函数太复杂没看懂。 对于我新手来说不知道怎么回事。

引用 3 楼 super_admi 的回复:这个题目，要看考察点在哪里，如果考察的是基本数据类型，那么你定义一个只处理双精度数据类型的函数即可，调用的时候，做强制转换；若考察的是联合体或者结构体，那么可以参考COM调用中通用类型的实现；若查考的是函数重载（早起C语言规则没有函数重载一说吧？），见楼上；若查考的是宏，见楼上。这可能是结构体，或者强制转化。因为这个书上都是有内容的，宏书上没有。能给代码吗？谢谢

不用泛型，要一个函数，只能是函数重载的形式啦，不然你怎么将不同类型的数据传入函数，函数中又如何分辨


Question: 有经历过华三通信的笔试和面试的吗，分享一下内容好吗？

请问您应聘的是什么职位呀？笔试涉及的只有c和数据结构吗？编程是不是考的链表和字符串的相关操作呀？谢谢！

我过了的，但是没有去；是北京上地那家；笔试和面试；笔试都是基础的；面试就谈你做的，然后你觉得你做的最好的方面谈；当时弹的是存储方面的问题。


Question: 新手一枚，求大家帮忙看看下面的代码有什么问题

整数之间运算想得到float类型的结果需要：(float)整数 大小写不能随便换。


Question: 链表访问越界

附代码#include <iostream> #include <string.h> #include <cstdio> #include <stdlib.h>  using namespace std; struct Node { 	int data; 	struct Node *next; 	struct Node *pre; }; typedef struct Node Node, *PNode; struct FrontNode { 	PNode head; 	PNode tail; }; typedef FrontNode DuLink, *PDuLink; /******************************/ /*			   建立           */ /******************************/  void CreateList(DuLink *h) {  	h->head = (PNode)malloc(sizeof(Node)); 	h->tail = (PNode)malloc(sizeof(Node)); 	h->head->pre = NULL; 	h->head->next = NULL; 	h->tail->pre = NULL; 	h->tail->next = NULL; 	h->head->data = 0;  	PNode p = h->head;     for(int i = 0; i < 600; i++)     {         PNode q;         q = (PNode)malloc(sizeof(Node));         q->data = 0;          p->next = q;         q->pre = p;         p = q;     }     h->tail = p; }  int main() {     DuLink sum;     CreateList(&sum);     DuLink rn;     CreateList(&rn);  //    rn.tail->pre->data = 2; //    sum.tail->pre->data = 1;     rn.head->next->data = 2;     sum.head->next->data = 2;     for(int n = 1; n < 2000; n++)     {         PNode p = rn.tail->pre, q;         int ret = 0;         while(p!=rn.head)         {             int temp = (p->data*n+ret);             //cout << temp << endl;             p->data = temp%10;             ret = temp/10;             p = p->pre;         }         //cout << "乘法" << endl;         p = rn.head->next;         ret = 0;         while(p!=rn.tail) 		{             int temp = p->data+ret*10;             p->data = temp/(2*n+1);             ret = temp%(2*n+1);             p = p->next;         }         //cout << "除法" << endl;         p = rn.tail->pre;         q = sum.tail->pre;         ret = 0;         while(q!=sum.head)         {             int temp = p->data + q->data + ret;             q->data = temp%10;             ret = temp/10;             p = p->pre;             q = q->pre;         }         //cout << "加法" << endl;     }     PNode p = sum.head->next;     int k;     cin >> k;     int cnt = 0;     while(cnt <= k)     {         if(cnt == 0)             cout << p->data << ".";         else             cout << p->data;         p = p->next;         cnt++;     }     cout << endl; }

引用 1 楼 user-1 的回复:head->pre 与 tail->next 没有赋值。 引用 1 楼 user-1 的回复:head->pre 与 tail->next 没有赋值。 谢谢，已解决

head->pre 与 tail->next 没有赋值。


Question: c语言  i++ 和 ++i 问题求解

引用 9 楼 CarryU 的回复:[quote=引用 5 楼 lz20120808 的回复:] 首先结果是：a=1,b=1,c=0,d=1 a++,b++; 独自成为一句表示a=a+1;，b同理； 而包含在一句代码中，c++表示先使用c的值，c再自加1，而++d表示先自加1 ，然后再使用d的值。。希望明白 明白了，十分感谢，不知道实际编程中会遇到这样的问题吗？[/quote]这个东西比较的简单，注意一下就不会出错~

后置自增符号是进行自增操作，并返回增加前的拷贝

引用 5 楼 lz20120808 的回复:首先结果是：a=1,b=1,c=0,d=1 a++,b++; 独自成为一句表示a=a+1;，b同理； 而包含在一句代码中，c++表示先使用c的值，c再自加1，而++d表示先自加1 ，然后再使用d的值。。希望明白 明白了，十分感谢，不知道实际编程中会遇到这样的问题吗？

程序执行的顺序点

引用 3 楼 CarryU 的回复:[quote=引用 2 楼 fefe82 的回复:] a++；a 自增，返回a 自增之前的值。 ++a ; a 自增，返回 a 自增之后的值。  a++,++b; 两个返回的值都被丢弃了（没有赋值给任何变量）。后续打印出的 a b 自增后的值。 printf(...., c++, ++b) ， 这个打印出来的是两个 ++ 的返回值。 a++不是等同于a=a+1有赋值吗？[/quote]  a++ 有赋值。  a++ 与 a=a+1 并不是等同的。比如他们的返回值就是不同的。

引用 2 楼 fefe82 的回复:a++；a 自增，返回a 自增之前的值。 ++a ; a 自增，返回 a 自增之后的值。  a++,++b; 两个返回的值都被丢弃了（没有赋值给任何变量）。后续打印出的 a b 自增后的值。 printf(...., c++, ++b) ， 这个打印出来的是两个 ++ 的返回值。 a++不是等同于a=a+1有赋值吗？

月经来了


Question: 请大家帮我看看，是哪出了问题。为什么输入”1，小风“。输出的“1，乱码”

仅供参考：#include <stdio.h> char s[]="123 ab 4"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,"%d%n",&v,&n);         printf("k,v,n=%d,%d,%d\n",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf("skip char[%c]\n",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf("End.\n"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.

引用 1 楼 user-3 的回复:你输入的是中文的逗号吧，scanf函数中要求的可是英文的 嗯，他说的没啥错……

你输入的是中文的逗号吧，scanf函数中要求的可是英文的

没用啊，不是这个问题，麻烦你们再仔细看看


Question: 结构体中的成员数组的下标可以大于数组的长度吗

你这块内存是在堆里面分配的，导致没有错误的原因可能有两个： 1. 堆的算法，一个内存申请经常会多给你一些内存，不是好意，是和具体的堆管理算法有关，举个例子，如果堆对于小内存申请有时候为了计算方便会固定的给你 16，,32，64，等字节，也就是说，比如你申请了 33自己，堆很可能会给你 64 字节，因为为了分配和回收算法等一系列原因，堆经常是把固定大小的字节块串成一串，比如16字节的是一串，32字节的是一串，64字节的是一串。堆在数据结构中就是一个或者几个大的链表。  2. 看程序你的内存只有申请没有释放也没有申请其他内存，通常程序崩溃是在 free 的过程，或者有人再次申请内存时候，本身的胡乱操作不会导致崩溃，崩溃的原因是，你越界以后会破坏整个堆的结构，因为你每块申请到的内存前面都有一个内存控制块，这个块就是刚才说的堆的链表指针等等，所以越界会破坏这个链表，导致不可知的非法访问，如果你访问到了小地址或者其他不属于该程序地址空间的地址，CPU就会出异常，你的程序就挂了。

数组范围需要你来控制, 如果你不控制, 要么正常, 要么错误, 要么程序挂掉 for(int i=1;i<=16;i++)  改为10

其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

引用 15 楼 hanxia12356789 的回复:[quote=引用 14 楼 liutao_1977 的回复:] 建议楼主，请仔细看我的回复，因为我实现过保护模式下操作系统内核的堆。  谢谢，已经仔细看过了，还是对堆内存的管理有点模糊，能不能推荐些这方面的资料[/quote]  http://bbs.csdn.net/topics/391844682?page=1#post-400484115 这是我写的帖子，详细解释了堆，你先看看有没有帮助

引用 14 楼 liutao_1977 的回复:建议楼主，请仔细看我的回复，因为我实现过保护模式下操作系统内核的堆。  谢谢，已经仔细看过了，还是对堆内存的管理有点模糊，能不能推荐些这方面的资料

建议楼主，请仔细看我的回复，因为我实现过保护模式下操作系统内核的堆。

没问题只是运气好，如果越界的内存刚好用于其他操作，就可能出现问题了。。

数组下标有效值是 [0,n-1]，除此之外的都会导致未定义行为。

引用 5 楼 hanxia12356789 的回复:[quote=引用 4 楼 fefe82 的回复:] [quote=引用 3 楼 hanxia12356789 的回复:] [quote=引用 2 楼 fefe82 的回复:] [quote=引用 1 楼 fefe82 的回复:] 你的代码呢？  ==================  一般来说，数组的引用下标竟然可以超过数组的长度是错误的，不管是不是结构体成员。（当然存在一些特殊用法，没看到你的程序不讨论）  错误的程序的结果是“不可预测”的。不可预测就意味着它可能产生你期望的“正确结果”，也可能崩溃，也可能给出一个结果但是是错误，也可能被编译器直接拒绝给出一个错误，等等。  刚才没看到你的代码。你的程序不涉及特殊用法，是错误的。你需要增加 Maxsize 。[/quote]   你需要增加 Maxsize是什么意思，Maxsize已经在开头宏定义了[/quote]  既然你需要用到 element[16] ，那就至少把 Maxsize 改成 17 。[/quote] 但是为什么Maxsize是10的时候编译运行并没有报错呢，而下面的代码，当下标超过数组长度的时候就会报错 #include<iostream> using namespace std; int main() { 	int a1[10]; 	for(int i=0;i<=10;i++) 	{ 		a1[i]=i; 	} }[/quote] 这就叫 不可预测。 你不知道它什么时候会出错，什么时候会崩溃。

超出的16 - 10 的int，你没有给出定义，但你的程序可以访问，而其它地方也不会访问它，越出了但结果不出错。当你(struct Node *)malloc (sizeof(struct Node) * 2)，你看下一个node会不会出现问题。

引用 4 楼 fefe82 的回复:[quote=引用 3 楼 hanxia12356789 的回复:] [quote=引用 2 楼 fefe82 的回复:] [quote=引用 1 楼 fefe82 的回复:] 你的代码呢？  ==================  一般来说，数组的引用下标竟然可以超过数组的长度是错误的，不管是不是结构体成员。（当然存在一些特殊用法，没看到你的程序不讨论）  错误的程序的结果是“不可预测”的。不可预测就意味着它可能产生你期望的“正确结果”，也可能崩溃，也可能给出一个结果但是是错误，也可能被编译器直接拒绝给出一个错误，等等。  刚才没看到你的代码。你的程序不涉及特殊用法，是错误的。你需要增加 Maxsize 。[/quote]   你需要增加 Maxsize是什么意思，Maxsize已经在开头宏定义了[/quote]  既然你需要用到 element[16] ，那就至少把 Maxsize 改成 17 。[/quote] 但是为什么Maxsize是10的时候编译运行并没有报错呢，而下面的代码，当下标超过数组长度的时候就会报错 #include<iostream> using namespace std; int main() { 	int a1[10]; 	for(int i=0;i<=10;i++) 	{ 		a1[i]=i; 	} }

引用 3 楼 hanxia12356789 的回复:[quote=引用 2 楼 fefe82 的回复:] [quote=引用 1 楼 fefe82 的回复:] 你的代码呢？  ==================  一般来说，数组的引用下标竟然可以超过数组的长度是错误的，不管是不是结构体成员。（当然存在一些特殊用法，没看到你的程序不讨论）  错误的程序的结果是“不可预测”的。不可预测就意味着它可能产生你期望的“正确结果”，也可能崩溃，也可能给出一个结果但是是错误，也可能被编译器直接拒绝给出一个错误，等等。  刚才没看到你的代码。你的程序不涉及特殊用法，是错误的。你需要增加 Maxsize 。[/quote]   你需要增加 Maxsize是什么意思，Maxsize已经在开头宏定义了[/quote]  既然你需要用到 element[16] ，那就至少把 Maxsize 改成 17 。

引用 2 楼 fefe82 的回复:[quote=引用 1 楼 fefe82 的回复:] 你的代码呢？  ==================  一般来说，数组的引用下标竟然可以超过数组的长度是错误的，不管是不是结构体成员。（当然存在一些特殊用法，没看到你的程序不讨论）  错误的程序的结果是“不可预测”的。不可预测就意味着它可能产生你期望的“正确结果”，也可能崩溃，也可能给出一个结果但是是错误，也可能被编译器直接拒绝给出一个错误，等等。  刚才没看到你的代码。你的程序不涉及特殊用法，是错误的。你需要增加 Maxsize 。[/quote]   你需要增加 Maxsize是什么意思，Maxsize已经在开头宏定义了

引用 1 楼 fefe82 的回复:你的代码呢？  ==================  一般来说，数组的引用下标竟然可以超过数组的长度是错误的，不管是不是结构体成员。（当然存在一些特殊用法，没看到你的程序不讨论）  错误的程序的结果是“不可预测”的。不可预测就意味着它可能产生你期望的“正确结果”，也可能崩溃，也可能给出一个结果但是是错误，也可能被编译器直接拒绝给出一个错误，等等。  刚才没看到你的代码。你的程序不涉及特殊用法，是错误的。你需要增加 Maxsize 。


Question: 急求！！！

引用 1 楼 user-1 的回复:第一个，第一次循环结束后，i变成了21，p也指向num[20]了，所以下一次使用p之前应先p--，保证它指向num[19] 第二个，function(1)=1; function(2)=2; 两句有问题，函数值是数值表达式，不能被赋值实际上这两句是多余的


Question: 求解C语言

#include <stdio.h> #include <math.h> #define PI 3.14159265 int main() {     double p,s,c;      p=PI/4.0;     s=sin(p);     c=cos(p);     printf("%g\n",s*s+s*c-c*c);//0.5     return 0; }

请帮忙编写一下代码吧


Question: 一个数如果恰好等于它的因子之和 为什么s=0必须在for里面啊

谢谢，我已经问过老师啦，因为只有for里面的才会循环，，，我也给忘啦，，，谢谢你，

因为你每次求因子和肯定是从0开始加起来啊，不然不就会存储了上一轮的和么


Question: 有熟悉libevent的么

这个是单线程的事件驱动啊 建议楼主学习一个epoll或者iocp，看看基本原理

单线程的啊，肯定是这样的，如果你的方法会阻塞，请把阻塞部分另开线程去执行。

一个进程中回调函数在同一时刻只会有一个事件在执行，楼主没明白事件驱动的含义吧


Question: C语言指针问题求解……

引用 4 楼 fefe82 的回复:[quote=引用 3 楼 csy0526 的回复:] [quote=引用 1 楼 fefe82 的回复:] 1. C 语言中所谓的“二维数组”，实际上是数组的数组。（“二维数组”这个叫法在这里非常误导人，“二维指针”也是一样）。   C 语言中所谓的“二维指针”，实际上是指向指针的指针。     int a[10]; 是“含有10个(int)元素的数组”，它可以被转化为“指向(int)的指针”    int a[10][20]; 是“含有10个(含有20个int元素的数组)元素的数组” （数组的数组），它可以被转化为“指向(含有20个int元素的数组)的指针" （数组的指针）。它不能被转化为int** ("指向(指向int的指针)的指针”)。  2. a 是数组，不是“指向数组头元素的指针”。a 出现在表达式中时，多数情况下会被自动转化为“指向数组头元素的指针”。    比如，在 p = a 中，a 会被转化为“指向数组头元素的指针”。然而此时 p 是“指向(含有4个int元素的数组)的指针”，两者类型不匹配。   &a 是一个 a 不会被转化的情况，此时 a 还是数组，对数组取地址，得到指向数组的指针（“指向(含有4个int元素的数组)的指针”）。p=&a 两者类型才匹配。    (顺带说一下，还有一种不会转化的情况是 sizeof(a))。  3. 这里你可以传一个指针数组。int *p[4];  非常感谢你的答复！ 确实，你在第二点中提到a是数组的时候，很多我无法理解的东西就能解释通了，豁然开朗啊！ 只是关于这点，还有一个小问题： 在我看过的一些C语言的书和视频里面是这么讲的，数组名里面存放的是数组第一个元素的地址。 换句话说，就是数组名是指向数组第一个元素的指针。 结合你前面的解释来看，应该说这句话并不是在所有场合下都成立的吧？[/quote]  “数组名里面存放的是数组第一个元素的地址” “换句话说，就是数组名是指向数组第一个元素的指针。” 我的个人觉得，对现在的 C 语言来说，这句话在任何场合都不成立。  这句话带来了很多对数组的误解。[/quote]  谢谢！你的解答让我获益良多！

引用 3 楼 csy0526 的回复:[quote=引用 1 楼 fefe82 的回复:] 1. C 语言中所谓的“二维数组”，实际上是数组的数组。（“二维数组”这个叫法在这里非常误导人，“二维指针”也是一样）。   C 语言中所谓的“二维指针”，实际上是指向指针的指针。     int a[10]; 是“含有10个(int)元素的数组”，它可以被转化为“指向(int)的指针”    int a[10][20]; 是“含有10个(含有20个int元素的数组)元素的数组” （数组的数组），它可以被转化为“指向(含有20个int元素的数组)的指针" （数组的指针）。它不能被转化为int** ("指向(指向int的指针)的指针”)。  2. a 是数组，不是“指向数组头元素的指针”。a 出现在表达式中时，多数情况下会被自动转化为“指向数组头元素的指针”。    比如，在 p = a 中，a 会被转化为“指向数组头元素的指针”。然而此时 p 是“指向(含有4个int元素的数组)的指针”，两者类型不匹配。   &a 是一个 a 不会被转化的情况，此时 a 还是数组，对数组取地址，得到指向数组的指针（“指向(含有4个int元素的数组)的指针”）。p=&a 两者类型才匹配。    (顺带说一下，还有一种不会转化的情况是 sizeof(a))。  3. 这里你可以传一个指针数组。int *p[4];  非常感谢你的答复！ 确实，你在第二点中提到a是数组的时候，很多我无法理解的东西就能解释通了，豁然开朗啊！ 只是关于这点，还有一个小问题： 在我看过的一些C语言的书和视频里面是这么讲的，数组名里面存放的是数组第一个元素的地址。 换句话说，就是数组名是指向数组第一个元素的指针。 结合你前面的解释来看，应该说这句话并不是在所有场合下都成立的吧？[/quote]  “数组名里面存放的是数组第一个元素的地址” “换句话说，就是数组名是指向数组第一个元素的指针。” 我的个人觉得，对现在的 C 语言来说，这句话在任何场合都不成立。  这句话带来了很多对数组的误解。

引用 1 楼 fefe82 的回复:1. C 语言中所谓的“二维数组”，实际上是数组的数组。（“二维数组”这个叫法在这里非常误导人，“二维指针”也是一样）。   C 语言中所谓的“二维指针”，实际上是指向指针的指针。     int a[10]; 是“含有10个(int)元素的数组”，它可以被转化为“指向(int)的指针”    int a[10][20]; 是“含有10个(含有20个int元素的数组)元素的数组” （数组的数组），它可以被转化为“指向(含有20个int元素的数组)的指针" （数组的指针）。它不能被转化为int** ("指向(指向int的指针)的指针”)。  2. a 是数组，不是“指向数组头元素的指针”。a 出现在表达式中时，多数情况下会被自动转化为“指向数组头元素的指针”。    比如，在 p = a 中，a 会被转化为“指向数组头元素的指针”。然而此时 p 是“指向(含有4个int元素的数组)的指针”，两者类型不匹配。   &a 是一个 a 不会被转化的情况，此时 a 还是数组，对数组取地址，得到指向数组的指针（“指向(含有4个int元素的数组)的指针”）。p=&a 两者类型才匹配。    (顺带说一下，还有一种不会转化的情况是 sizeof(a))。  3. 这里你可以传一个指针数组。int *p[4];  非常感谢你的答复！ 确实，你在第二点中提到a是数组的时候，很多我无法理解的东西就能解释通了，豁然开朗啊！ 只是关于这点，还有一个小问题： 在我看过的一些C语言的书和视频里面是这么讲的，数组名里面存放的是数组第一个元素的地址。 换句话说，就是数组名是指向数组第一个元素的指针。 结合你前面的解释来看，应该说这句话并不是在所有场合下都成立的吧？

up      dd


Question: qt 对话框testdialog的lineEdit要获取对话框xt的lineEdit的内容，为什么获取不到，求大神帮忙

引用 2 楼 q12wwww 的回复:[quote=引用 1 楼 user-1 的回复:] xt *tt=new xt()是什么意思,重新new一个, 原来那个不用了? 这是为了在testdialog.cpp里引用xt.cpp的啊[/quote]刚new出来的都没显示, edit当然就没有值了, 你应该在main把w,s想办法关联一下, 在display中直接得s就可以了

引用 1 楼 user-1 的回复:xt *tt=new xt()是什么意思,重新new一个, 原来那个不用了? 这是为了在testdialog.cpp里引用xt.cpp的啊

xt *tt=new xt()是什么意思,重新new一个, 原来那个不用了?


Question: 求大神指导怎样用C++编出其逻辑关系

if (a in ATGC) { return (a == b)?1:0; }

A a; B b; if (b == 0) { return 0; } else  {  if (a in ATGC) { return a == b; }  return 1; }


Question: int定义变量位置不同而出现的问题

源代码文件扩展名改为.cpp

古老的 C 语言编译器，变量的定义必须放在运行的代码之前。

编译器太老了


Question: borland c中出现declaration syntax error怎么办？？

偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。

每一个函数声明都要加;号 函数定义才不要

void view(Hnode *q) 这样的后面要加分号，后面的也要加分号


Question: 击button第一次显示第二次隐藏，当第一次button点击是，点击第二个buttton显示同时收回第一个button显示内容

应该用Combox控件

把逻辑层的代码发上来啊，不知道你的UI业务是什么逻辑...  当你点击一个选项时，复选框需要返回init的状态。 有时点击两次才响应的问题有很多，比如你的业务逻辑写的有漏洞、或者当你鼠标点击压下时有拖动控件效果。。。  具体要看你代码


Question: VC++

!= 是一个整体，中间不能有空格

这是语法错误 ，多自己根据编译器提示的去改正错误

你这是编译出错。代码写的有问题，根据错误信息检查下把


Question: C移除分支预测

引用 9 楼 fefe82 的回复:[quote=引用 4 楼 asxqy714 的回复:] [quote=引用 3 楼 fefe82 的回复:] [quote=引用 2 楼 asxqy714 的回复:] [quote=引用 1 楼 fefe82 的回复:] 哪些属于条件执行指令？ ? :  算吗？ if else while swicth 这些需要判断的都是条件执行指令[/quote]  return a>32767 ? 32767 : (a<-32768 ? -32768 : a);[/quote] 有没有类似 if (data[c] >= 128)     sum += data[c]; 替换为： int t = (data[c] - 128) >> 31; sum += ~t & data[c]; 这样的方法[/quote] 这个不对。  如果 data[c] == 0x80000000 （ 绝对值最大的负数）， data[c] - 128 = 0xeffffff80, t = 0, ~t = 0xffffffff[/quote]  大概应该改成 int t = (data[c] >> 31) | (data[c] - 128) >> 31

引用 14 楼 fefe82 的回复:最多连续回复三次，终于可以继续了 ... 顺带回复7楼 ==================== 最后，让我们看看我们的这些努力在现在的 CPU 和 编译器 下是多么的没有意义：  原始的带有 if 的 func 会被编译成下面的样子 （gcc -O2）(%edi 是参数, %eax 是返回值）    cmp    $0xffff8000,%edi   mov    $0xffff8000,%eax   mov    $0x7fff,%edx   cmovge %edi,%eax   cmp    $0x7fff,%eax   cmovg  %edx,%eax   retq  两个减法(cmp)，其余全部是 mov 类指令，没有分支，没有其它运算 ... 再一次学习了

C 的话，inline 函数，都改成 宏定义

引用 4 楼 asxqy714 的回复:[quote=引用 3 楼 fefe82 的回复:] [quote=引用 2 楼 asxqy714 的回复:] [quote=引用 1 楼 fefe82 的回复:] 哪些属于条件执行指令？ ? :  算吗？ if else while swicth 这些需要判断的都是条件执行指令[/quote]  return a>32767 ? 32767 : (a<-32768 ? -32768 : a);[/quote] 有没有类似 if (data[c] >= 128)     sum += data[c]; 替换为： int t = (data[c] - 128) >> 31; sum += ~t & data[c]; 这样的方法[/quote] 这个不对。  如果 data[c] == 0x80000000 （ 绝对值最大的负数）， data[c] - 128 = 0xeffffff80, t = 0, ~t = 0xffffffff

引用 5 楼 fefe82 的回复:[quote=引用 4 楼 asxqy714 的回复:] [quote=引用 3 楼 fefe82 的回复:] [quote=引用 2 楼 asxqy714 的回复:] [quote=引用 1 楼 fefe82 的回复:] 哪些属于条件执行指令？ ? :  算吗？ if else while swicth 这些需要判断的都是条件执行指令[/quote]  return a>32767 ? 32767 : (a<-32768 ? -32768 : a);[/quote] 有没有类似 if (data[c] >= 128)     sum += data[c]; 替换为： int t = (data[c] - 128) >> 31; sum += ~t & data[c]; 这样的方法[/quote]  The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a nonnegative value, the value of the result is the integral part of the quotient of E1 / 2E2. If E1 has a signed type and a negative value, the resulting value is implementation-defined.[/quote] 还和编译器有关

引用 4 楼 asxqy714 的回复:[quote=引用 3 楼 fefe82 的回复:] [quote=引用 2 楼 asxqy714 的回复:] [quote=引用 1 楼 fefe82 的回复:] 哪些属于条件执行指令？ ? :  算吗？ if else while swicth 这些需要判断的都是条件执行指令[/quote]  return a>32767 ? 32767 : (a<-32768 ? -32768 : a);[/quote] 有没有类似 if (data[c] >= 128)     sum += data[c]; 替换为： int t = (data[c] - 128) >> 31; sum += ~t & data[c]; 这样的方法[/quote]  The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a nonnegative value, the value of the result is the integral part of the quotient of E1 / 2E2. If E1 has a signed type and a negative value, the resulting value is implementation-defined.

引用 11 楼 fefe82 的回复:  int func(int a) { if(a>32767)    return 32767; if(a<-32768)    return -32768; else      return a; } int func2(int a ) {   int sz = sizeof(int) * CHAR_BIT - 1;   int bigger = ~((a >> sz) | ((a - 32767) >> sz));  // if a > 32767, bigger == 0xffffffff, else bigger ==0;   int smaller  = (a >> sz) & ((a + 32768) >> sz); // if a < -32768, smaller == 0xffffffff, else smaller ==0;   int res = 0;   res += bigger & 32767;   res += smaller & (-32768);   res += (~bigger) & (~smaller) & a;   return res;  }  这个正是我想要的，学习了，十分感谢！

引用 7 楼 user-2 的回复:inline bool is_plus_long(int a) { return a>32767; } inline bool is_neg_long(int a)｛return a<-32768;｝ inline bool is_short(int a){return !is_plus_long(a) && !is_neg_long(a);} //func 的实现 inline int make_short(int a){          return is_plus_long( a )*32767 + is_neg_long( a )*(-32768) + is_short (a) *a; }  用乘法 实现 分支效果 比较指令可以优化为 非跳转指令 如此即可 不过这种优化，真的有必要么？ 感谢你的回答，小白一个，做一个面试题，没遇到过这种问题，主要是要学会决解这种问题的思想。再次感谢！

引用 3 楼 fefe82 的回复:[quote=引用 2 楼 asxqy714 的回复:] [quote=引用 1 楼 fefe82 的回复:] 哪些属于条件执行指令？ ? :  算吗？ if else while swicth 这些需要判断的都是条件执行指令[/quote]  return a>32767 ? 32767 : (a<-32768 ? -32768 : a);[/quote] 有没有类似 if (data[c] >= 128)     sum += data[c]; 替换为： int t = (data[c] - 128) >> 31; sum += ~t & data[c]; 这样的方法

引用 2 楼 asxqy714 的回复:[quote=引用 1 楼 fefe82 的回复:] 哪些属于条件执行指令？ ? :  算吗？ if else while swicth 这些需要判断的都是条件执行指令[/quote]  return a>32767 ? 32767 : (a<-32768 ? -32768 : a);

引用 1 楼 fefe82 的回复:哪些属于条件执行指令？ ? :  算吗？ if else while swicth 这些需要判断的都是条件执行指令

哪些属于条件执行指令？ ? :  算吗？


Question: 数据结构问题

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

引用 3 楼 believeforever6 的回复: 下次贴代码可以这样  string str = "hello word";

谢谢你，解决了， 我还有一段代码，自己看不出哪里出错了麻烦帮忙改一下 Description  利用串操作实现基于给定英文段落（100~200000）构造英文词典（英文单词按字典序排序）  Input  一篇文章（包含若干个单词，标点符号全部是标准的英文字符）。  Output  输出文章里面所有单词（按照字典序，每个单词一行）。  Sample Input  Hello world! Sample Output  hello world  我的代码 #include <cstring> #include <cstdio> #include <algorithm> #include <iostream> using namespace std; int main () {     char ch[210000];     char cch[2100][100];     while(gets(ch)){         int lch=strlen(ch);         int flog=0;         int ans=0;         int cnt=0;         for(int i=0;i<lch;i++){             if(ch[i]>='a'&&ch[i]<='z'){                 flog=1;                 cch[ans][cnt]=ch[i];                 cnt++;             }             else if(ch[i]>='A'&&ch[i]<='Z'){                 flog=1;                 cch[ans][cnt]=ch[i]+32;                 cnt++;             }             else if(flog==1){                 flog=0;                 ans++;                 cnt=0;             }         }         sort(ch,ch+ans);         for(int i=0;i<ans;i++){             cout << cch[i]<<endl;         }     } }

这看起来就是一个简单的进栈、出栈的问题。  首先，建立一个栈，当有人上车时，就把他们依次入栈，当有人下车时，就按下车人数出栈若干次并输出即可。


Question: 为什么*argv可以与NULL进行比较？

@user-1，没有注意到，漏过了。多谢

5.1.2.2.1 Program startup 2 If they are declared, the parameters to the main function shall obey the following constraints: — The value of argc shall be nonnegative. — argv[argc] shall be a null pointer. .......


Question: 请问下面的函数，如果在主函数中memory(pointer,10);为什么程序会出现错误，既不能直接对a分配，在函数中定义p来分配也不行，该怎么用函数分配呢

呃。。入参是a，指针a并没有赋值，并且a应该使用引用

int memory(int **a,int number) {     *a = ...//malloc     //... }


Question: 初级的C语言程序，但是学艺不精中文字符串总有问题，还请大侠赐教！

谢谢各位了，已经搞定了。

楼主贴代码的时候可以用编辑器的代码功能。

'张三' ==> "张三"  注意引号，其余同。


Question: MinGW 无法运行

http://www.mingw.org/wiki/InstallationHOWTOforMinGW 我上去看了，找不到 rxvt.exe , sh.exe,


Question: 求助求助

哪有这好事 单向循环链表得了

严格来说有点难哈，我能想到的只有一个近乎作弊的办法，就是把一个struct当作链域来用，那当然想要多少枚向前向后的指针都没有问题。  node->nodelink->prev node->nodelink->next


Question: c 语言实现多线程ping

win 系统有api 能拿到返回值   ＝ ＝！ 我要回答linux 怎么都是win 的破烂问题！！

自己实现一下ping 在多线程sleep()一下就行了，ping的实现是原始套接字发icmp 好像echo包就行了。

还是实现多进程ping来得容易：#include <windows.h> #include <stdio.h> #include <string.h> char YN(int k) {     FILE *f;     char fn[40];     char ln[80];     char yn;     int n;      yn='N';     sprintf(fn,"d:\\ping%d.txt",k);     f=fopen(fn,"r");     if (NULL!=f) {         n=0;         while (1) {             if (NULL==fgets(ln,80,f)) break;//             if (strstr(ln,"ms ")) {                 yn='Y';                 break;//             }             n++;             if (n>=4) break;//         }         fclose(f);     }     return yn; } void main(int argc,char **argv) {     char cmdstr[256];     int i;     int IP[3];     char c;      if (argc<2) {     USAGE:         printf("Usage example:\n    %s 192.168.60.\nto test 192.168.60.1-254\n",argv[0]);         return;     }     if (4==sscanf(argv[1],"%d.%d.%d%c",&IP[0],&IP[1],&IP[2],&c)) {         if (0<=IP[0] && IP[0]<=255          && 0<=IP[1] && IP[1]<=255          && 0<=IP[2] && IP[2]<=255          && '.'==c) {             for (i=1;i<255;i++) {                 sprintf(cmdstr,"cmd /c ping %s%d -n 1 -w 1000 >d:\\ping%d.txt",argv[1],i,i);                 WinExec(cmdstr,SW_HIDE);             }             Sleep(3000);             for (i=1;i<255;i++) {                 printf("%c %s%d\n",YN(i),argv[1],i);             }             Sleep(3000);             WinExec("cmd /c del /q d:\\ping*.txt",SW_HIDE);         } else goto USAGE;     } else goto USAGE; }

select可以控制时间的啊，楼主怎么写的贴出来看看就好了


Question: 在线等！急！ 关于 初级 汇编语言的题目

据说AT&T汇编中，带l的操作，一般都是4个字节，32位。 引用 4 楼 qq_32056009 的回复:为什么 数据类型 是 int 呢？

晕死，AT&T汇编……完全看不懂。

为什么 数据类型 是 int 呢？

1楼答案有待实际验证，不一定对。

int *p,q; p=&q; q=%ebx

理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  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对应的汇编并单步执行观察相应内存和寄存器变化。）

引用 3 楼 zhao4zhong1 的回复:1楼答案有待实际验证，不一定对。 movl (%eax), %edx ;将eax的值对应地址开始的4个字节的值读到edx中 movl (%edx),%ebx ;将edx的值对应地址开始的4个字节的值读到ebx中 If the register %eax maps to a C variable p and the register %edx maps to a C variable q.  What is the data type of p in C?  What is the data type of q in C? Write the equivalent C code for the above operation? 1楼我将操作方向弄反了。 int *p,q; q=*p; //再将q的值读到ebx中


Question: 求教一个最新问题，就是关于释放内存的问题！！

free了current, current->Next就不存在了

引用 2 楼 hzk745 的回复:你为啥不这样修改呢？ //释放链表     /*current = Head;       while (current != NULL)     {         node* p=current;         current = current->Next;         free(p);     }嗯嗯  我先建立了一个临时变量 就可以了！

引用 3 楼 user-3 的回复:先把current的内容复制给另一个变量，然后current指向下一条，再释放temp中的内容。嗯 可以了！！谢谢啦！


Question: 用C语言实现在txt文件中的查找与替换功能

数据结构（C语言）书里都有讲，串的模式匹配，我看的时候挺伤脑筋的，算法好不好，性能差距很大（比如对于几M的文本文件）。

引用 2 楼 zhao4zhong1 的回复:所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。 ++ 这个最原始最单纯，也未必效率有多差，说不定是最好的

参考Linux命令sed的源代码！

引用 楼主 baidu_32054243 的回复:如何实现在txt文件中的查找与替换功能，能不能给代码和大量注解，想了好几天都没有头绪 字符串查询子串推荐BoyerMoore算法，效率很高

查找很简单吧, 比如文件的长度为N字节, 要查找的字符串长度为M字节 则循环N-M次, 每次得到的字符串与要查找的字符串比较. 如果相等, 就找到了.  替换的话, 先执行查找操作, 得到若干个要替换的字符串首字符的索引,  然后把文件写到内存中, 如查到要替换的字符串个数为N, 则执行2N+1次fread操作 接着用一次fwrite覆盖原文件.


Question: if的语法

就是判断条件成不成立

if()()里就是条件表达式，值为真就成立，反之if不成立

c语言里没有bool类型，if直接判断（）中的值是不是0，如果是char类型，看它的ascii码值，指针看是不是NULL

C语言中BOOL类型后增加的，如果编译器不支持C99标准，是不认识BOOL是啥东东的

为0为假，非0都是真

if后可以根任何类型，只要该类型可以转换为bool，如char、int、int*等都行，如果是其他类类型，也要求这个类能转换成bool

C 语言没 BOOL 类型 （或 bool 类型）。  C 语言中， if () 中的表达式需要为 scaler type （包括整型，浮点型与指针类型）。当表达式的值不为 0 是，执行 if () { ... } 中的部分。当表达式的值为零时，执行 else { .. } 中的部分 （如果没有 else ，则什么也不执行）。

为0为假，非0都是真


Question: 关于strcpy

编译器，对debug版本和release版本对局部变量也就是栈的上分配的字节数不一样。debug版本会多一些，这也是很多程序 debug版本没事儿，release版本出错的原因之一。

或许和你的编译选项有关，你也许用的是 debug  版本，试试release版本会不会崩溃

其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

1.编译时：C语言是并不进行越界检查的一门语言。虽然你越界了，但是仍然不会报错  2.运行：你在strcpy(t,s)或者输出printf("%s\n",t)的时候,都是传递的指针。在strcpy或者printf内部只是借用这个指针进行间接访问（类似于t[4]这种形式。                 在运行时出错，除非访问了系统地址段才会报错。                其次，当程序较大，使用了t[2]后面的内存，则程序的输出会出错

你的字符串再长点，一定会崩溃。 姑且算是32位的，因此这个2字节后面，还有函数指针4个字节，2个参数8字节，一共有22个有效的内存空间，那么在执行strcpy(t,s);的后，这些内存空间压入到栈里不在需要了，执行结束后，指向的是后面的printf函数，之前的代码不再被访问，因此即使你strcpy了9个字节的长度（包括结束符0），也不会影响后面的print函数的执行，因此程序不会崩溃。

看运气

运气好而已  比如mac os * thread #1: tid = 0x821f8, 0x00007fff841340ae libsystem_kernel.dylib`__pthread_kill + 10, queue = 'com.apple.main-thread', stop reason = signal SIGABRT   * frame #0: 0x00007fff841340ae libsystem_kernel.dylib`__pthread_kill + 10     frame #1: 0x00007fff8b6a2500 libsystem_pthread.dylib`pthread_kill + 90     frame #2: 0x00007fff8cacf37b libsystem_c.dylib`abort + 129     frame #3: 0x00007fff8cacf4f2 libsystem_c.dylib`abort_report_np + 181     frame #4: 0x00007fff8caf59cc libsystem_c.dylib`__chk_fail + 48     frame #5: 0x00007fff8caf599c libsystem_c.dylib`__chk_fail_overflow + 16     frame #6: 0x00007fff8caf5be9 libsystem_c.dylib`__strcpy_chk + 83     frame #7: 0x0000000100000f17 a.out`main + 39     frame #8: 0x00007fff923915ad libdyld.dylib`start + 1 (lldb)

C语言不对数组下标是否越界进行检查

越界了，但不代表会崩溃，只有单越界后这部分内容可能用于其他用途时就可能导致意外或不正确的结果 这种错误有时是很难发现的 为了防止这种溢出，新版VS都默认要求使用更加安全的函数strcpy_s，该函数需要输入目的地字符数组的大小，函数中会检查是否越界

想象一排空房子，属于你的有两个房间，其他的房间虽然不属于你，其他房间没有人的时候，你想住哪儿住哪儿，但是如果其他房间有人，你要住进去，那就要打架了！

并不是所有错误的程序都会崩溃。  所有错误的程序都有可能崩溃。


Question: 新手请教

第一个程序，当i等于1时，内层for循环执行5次，此时j的值为5；i等于2时，由于此时j=5，内层循环for不满足执行条件，所以无操作；以此类推，以后外层的三次for循环，内层for都不满足循环条件。         第二个程序，j每次都会在外层for循环执行后、内层for循环执行前进行初始化，这样就能输出您要的答案。

#include<stdio.h> int main() {     int i = 1,j;     for (;i <= 5;i++)     {         j=1;         for (;j <= 5 - i;j++)                       printf(" ");                   printf("*****\n");     } } 比较一下.

因为在进入第二个for循环时会先执行j=1

第二个程序中你j在哪声明的

为什么  j  不一样呢

因为第2个j的赋值在循环里面，赋了5次值。


Question: C 的链表问题

引用 10 楼 hzk745 的回复:1.通过调试基本可以判断是如下函数有问题，因为插入的数据并没有对next字段进行赋值为NULL,加上这个就好了 Status ListInsert(LinkList L, int i, int e)	//ListInsert {	 int j; LNode *p, *s; p = L;  if((L == NULL) || i<0 || i>/*ListLength(*L)+1*/100) { exit(ERROR); }  for(j=0; j<i-1; j++){ p = p->next; }  s = (LNode*)malloc(sizeof(LNode)); s->data = e; s->next = p->next ; p->next  = s; s->next=NULL; return OK; }  明白了！！谢谢！！！

感觉你的程序写的函数分离的不太好。譬如我不太明白你在listlength函数中申请新节点有什么用意，直接将链表的头结点传进来，循环遍历一下，到NULL 就截止，返回一下循环次数就行了  int listLength(LNode L) { 	int n = 0; 	while (L.next != NULL) 		n++; 	return n; }

引用 10 楼 煦风之伤的回复:1.通过调试基本可以判断是如下函数有问题，因为插入的数据并没有对next字段进行赋值为NULL,加上这个就好了 Status ListInsert(LinkList L, int i, int e)	//ListInsert {	 int j; LNode *p, *s; p = L;  if((L == NULL) || i<0 || i>/*ListLength(*L)+1*/100) { exit(ERROR); }  for(j=0; j<i-1; j++){ p = p->next; }  s = (LNode*)malloc(sizeof(LNode)); s->data = e; s->next = p->next ; p->next  = s; s->next=NULL; return OK; }

再供参考：//不带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next; } *head,*p,*q,*s,*p1,*p2,*q1,**ta; int i,k,n,t,m,v,N=10; int main() {     setlocale(LC_ALL,"chs");     srand(time(NULL));      head=NULL;      printf("创建%d个节点的单链表:",N);//创建N个节点的单链表     p=head;     for (i=0;i<N;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) exit(1);         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             p=q;         }     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=3;     v=5;     printf("将值为%d的结点插入到单链表的第%d个结点前:",v,k);//将值为v的结点插入到单链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=5;             q->next=head;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=5;                 q->next=p->next;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=5;     printf("删除第%d个节点:",k);//删除第k个节点     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=head;             head=head->next;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      printf("从小到大排序:");//从小到大排序     for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {         for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {             if (p->data > q->data) {                  //交换data //              printf("swap %02d %02d\n",p->data,q->data); //              t=p->data;p->data=q->data;q->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个单链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         n++;         s=s->next;     }      printf("将整个链表逆序:");//将整个链表逆序     if (n>=2) {         p=head;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head=p;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      m=4;     n=6;     printf("将单链表中前%d个结点和后%d个结点进行互换:",m,n);//将单链表中前m个结点和后n个结点进行互换,m+n为链表总长     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m==k) {             q=p;         }         s=p;         p=p->next;     }     q1=head;     head=q->next;     s->next=q1;     q->next=NULL;      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16-> //将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16-> //删除第5个节点:08->74->05->07->03->99->31->56->88->16-> //从小到大排序:03->05->07->08->16->31->56->74->88->99-> //将整个链表逆序:99->88->74->56->31->16->08->07->05->03-> //将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56-> //

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  仅供参考：//带表头结点的单向链表 #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-> //

引用 6 楼 suwei2002 的回复:[quote=引用 5楼我是你的主体 的回复:][quote=引用 4 楼 Alexander的回复:]1：p=(LNode*)malloc…… 申请了一块LNode大小的内存空间并把首地址赋给p  2：p=&L； 把L的地址赋给p  之后第1行申请的内存没有释放就结束了程序，导致内存泄漏 我尝试free(p)后还是不行……我还试了不给p申请空间，直接让它指向L的地址也不行。。[/quote]除了内存泄漏外ListLength好像没别的问题了(先不考虑逻辑上的问题) 那问题有可能是出在lnsert上[/quote]    引用 6 楼 suwei2002 的回复:[quote=引用 5楼我是你的主体 的回复:][quote=引用 4 楼 Alexander的回复:]1：p=(LNode*)malloc…… 申请了一块LNode大小的内存空间并把首地址赋给p  2：p=&L； 把L的地址赋给p  之后第1行申请的内存没有释放就结束了程序，导致内存泄漏 我尝试free(p)后还是不行……我还试了不给p申请空间，直接让它指向L的地址也不行。。[/quote]除了内存泄漏外ListLength好像没别的问题了(先不考虑逻辑上的问题) 那问题有可能是出在lnsert上[/quote]   Status ListInsert(LinkList L, int i, int e)											//ListInsert {	 	int j; 	LNode *p, *s; 	p = L;  	if((L == NULL) || i<0 || i>/*ListLength(*L)+1*/100) 	{ 		exit(ERROR); 	}  	for(j=0; j<i-1; j++){ 		p = p->next; 	}  	s = (LNode*)malloc(sizeof(LNode)); 	s->data = e; 	s->next = p->next ; 	p->next  = s;  	return OK; }  这段是Insert的操作....还麻烦看一看?

引用 5楼我是你的主体 的回复:[quote=引用 4 楼 Alexander的回复:]1：p=(LNode*)malloc…… 申请了一块LNode大小的内存空间并把首地址赋给p  2：p=&L； 把L的地址赋给p  之后第1行申请的内存没有释放就结束了程序，导致内存泄漏 我尝试free(p)后还是不行……我还试了不给p申请空间，直接让它指向L的地址也不行。。[/quote]除了内存泄漏外ListLength好像没别的问题了(先不考虑逻辑上的问题) 那问题有可能是出在lnsert上

引用 4 楼 Alexander的回复:1：p=(LNode*)malloc…… 申请了一块LNode大小的内存空间并把首地址赋给p  2：p=&L； 把L的地址赋给p  之后第1行申请的内存没有释放就结束了程序，导致内存泄漏 我尝试free(p)后还是不行……我还试了不给p申请空间，直接让它指向L的地址也不行。。

引用 1 楼 user-5的回复:Init没有任何用 参数应该为 LinkList *ppL , 不然a没有初始化 *ppL 代表什么意思呢

引用 1 楼 user-5的回复:Init没有任何用 参数应该为 LinkList *ppL , 不然a没有初始化 请问Linklist 和 LNode* 不是等同的么按照最开始的定义看


Question: 考研中有些真题没有答案 求大神指点

下次又不考这题，会不会 能咋着 把偶数节点取下,依次插入到尾节点 an后面 也没啥原理，直接写就是代码了


Question: 请问第二个线程创建后覆盖了第一个线程创建的数据？

引用 4 楼 ipqtjmqj的回复:引用 3 楼 dezhihuang 的回复:[quote=引用 1 楼 ipqtjmqj 的回复:] 你传给每个线程的参数是同一个，都是test，虽然链表是动态创建的，但保存头结点，即test.pHead只有一块内存，当然会覆盖了。请问有什么解决办法呢？ 不知你要建几个线程，我看你i是0到10，但每次却加5， 假设建n个线程，i 从0到n-1，则先前建test时改成 ThreadStruct *test = new ThreadStruct[n]; 然后原来每次传的是test改成test+i[/quote] 非常感谢，按你说的成功了！谢谢

引用 3 楼 dezhihuang 的回复:引用 1 楼 ipqtjmqj 的回复:你传给每个线程的参数是同一个，都是test，虽然链表是动态创建的，但保存头结点，即test.pHead只有一块内存，当然会覆盖了。请问有什么解决办法呢？ 不知你要建几个线程，我看你i是0到10，但每次却加5， 假设建n个线程，i 从0到n-1，则先前建test时改成 ThreadStruct *test = new ThreadStruct[n]; 然后原来每次传的是test改成test+i


Question: 关于txt里面的’\0'

\0 这种转义表达方式只是C/C++里定义的，你在文本文件中输入\0他是理解成一个 \ 和一个0  貌似Windows自带的记事本你是没办法输入这些不可显示的字符的

txt中\0是2个字符.字符串中是1个字符 用空格回车都可以分开,


好吧 那楼上的大神能不能推荐几本winsock网络编程的书啊。我现在的系统是win7 工具就是VS2010

别看赵4 乱回答 你要做底层网络的操作呀 那个我原来也想，不过后来没有实验成功过  我记得就winxp 里面可以 用sendarp 这个函数 你那个方法貌似 已经不可行 不用试验了

什么鬼MSDN98\SAMPLES\VC98\SDK\NETDS\WINSOCK\*.*

MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl 先下载安装MSDN98  再参考： MSDN98\SAMPLES\VC98\SDK\NETDS\WINSOCK\*.*


Question: 求解，编译没问题，但是运行就结束进程

你想要表达啥不太理解，主要在两点： 1.char *a[15]={"xiangtuo"};，这个是指针数组，也就是说，a[0]就是char*元素指向“xiangtuo”，所以sort(char *a[],int n),这个里面穿的n为啥不是1而是15？ 2.printf("%s",a),这个肯定有问题，估计是乱码 你可以重新整理下你的思路，想下到底要做啥？

因为你这程序不到1秒就运行完了，竟然退出了，在程序最后加上getchar();  表示等待用户输入一个字符

getchar();

a里面放的是指针变量a[0]的地址，printf(“%s”,a)能输出字符串吗……

你只初始化了数组的第一个元素，15个字符串，只有第一个是有值的，后面14个全部为NULL，对NULL调用strcmp函数，直接引发内存崩溃。

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


Question: C 语言函数 atof()

自己实际测试一下比听别人说印象要好得多

如果汉字字母开头会得到0.0 如果是如“1.5xxx”会得到1.5 楼主自己测试下不就知了

atof, atoi, _atoi64, atol Convert strings to double (atof), integer (atoi, _atoi64), or long (atol).  double atof( const char *string );  int atoi( const char *string );  __int64 _atoi64( const char *string );  long atol( const char *string );  Routine Required Header Compatibility  atof <math.h> and <stdlib.h> ANSI, Win 95, Win NT  atoi <stdlib.h> ANSI, Win 95, Win NT  _atoi64 <stdlib.h> Win 95, Win NT  atol <stdlib.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  Each function returns the double, int, __int64 or long value produced by interpreting the input characters as a number. The return value is 0 (for atoi and _atoi64), 0L (for atol), or 0.0 (for atof) if the input cannot be converted to a value of that type. The return value is undefined in case of overflow.  Parameter  string  String to be converted  Remarks  These functions convert a character string to a double-precision floating-point value (atof), an integer value (atoi and _atoi64), or a long integer value (atol). The input string is a sequence of characters that can be interpreted as a numerical value of the specified type. The output value is affected by the setting of the LC_NUMERIC category in the current locale. For more information on the LC_NUMERIC category, see setlocale. The longest string size that atof can handle is 100 characters. The function stops reading the input string at the first character that it cannot recognize as part of a number. This character may be the null character ('\0') terminating the string.  The string argument to atof has the following form:  [whitespace] [sign] [digits] [.digits] [ {d | D | e | E }[sign]digits]  A whitespace consists of space and/or tab characters, which are ignored; sign is either plus (+) or minus ( – ); and digits are one or more decimal digits. If no digits appear before the decimal point, at least one must appear after the decimal point. The decimal digits may be followed by an exponent, which consists of an introductory letter ( d, D, e, or E) and an optionally signed decimal integer.  atoi, _atoi64, and atol do not recognize decimal points or exponents. The string argument for these functions has the form:  [whitespace] [sign]digits  where whitespace, sign, and digits are exactly as described above for atof.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _ttoi atoi atoi _wtoi  _ttol atol atol _wtol    Example  /* ATOF.C: This program shows how numbers stored  * as strings can be converted to numeric values  * using the atof, atoi, and atol functions.  */  #include <stdlib.h> #include <stdio.h>  void main( void ) {    char *s; double x; int i; long l;     s = "  -2309.12E-15";    /* Test of atof */    x = atof( s );    printf( "atof test: ASCII string: %s\tfloat:  %e\n", s, x );     s = "7.8912654773d210";  /* Test of atof */    x = atof( s );    printf( "atof test: ASCII string: %s\tfloat:  %e\n", s, x );     s = "  -9885 pigs";      /* Test of atoi */    i = atoi( s );    printf( "atoi test: ASCII string: %s\t\tinteger: %d\n", s, i );     s = "98854 dollars";     /* Test of atol */    l = atol( s );    printf( "atol test: ASCII string: %s\t\tlong: %ld\n", s, l ); }   Output  atof test: ASCII string:   -2309.12E-15   float:  -2.309120e-012 atof test: ASCII string: 7.8912654773d210   float:  7.891265e+210 atoi test: ASCII string:   -9885 pigs      integer: -9885 atol test: ASCII string: 98854 dollars      long: 98854   Data Conversion Routines |  Floating-Point Support Routines |  Locale Routines  See Also   _ecvt, _fcvt, _gcvt, setlocale, strtod, wcstol, strtoul

NULL会抛异常 空字符串和汉字得到0


Question: C sqlite在安卓环境下匹配出乱码，x86正常

编辑器的编码格式，编译器的编码编译选项，操作系统的默认字符集，都有关

引用 1 楼 zhao4zhong1 的回复:对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A 你好，都是utf8编码，有的时候匹配出的乱码还不一定一样，有的时候能匹配出所需内容，但是后面却多了一个乱码，但有时连所需内容都没匹配出来， 最令人不明白的是，在x86环境下，代码没有任何问题，试验过无数次，也不会出现乱码的情况

windows和linux的默认字符集不一样吧？


Question: linux c api连接数据库代码怎么变成occi方式代码

你链接mysql ？？？

引用 2 楼 xiaoshang_program 的回复:你链接mysql ？？？写错了 应该是连oracle  ...

参考 demo\*.c Program Name                              Features Illustrated cdemo81.c                                 Using basic SQL processing with release 8 and later functionality. cdemo82.c                                 Performing basic processing of user-defined objects. cdemocor.c                                Using complex object retrieval (COR) to improve performance. cdemodr1.c,cdemodr2.c,cdemodr3.c          Using INSERT/UPDATE/DELETE statements with RETURNING clause used with basic datatypes, LOBs and REFs. cdemodsa.c                                Describing information about a table. cdemodsc.c                                Describing information about an object type. cdemofo.c                                 Registering and operating application failover callbacks. cdemolb.c                                 Create and insert LOB data and then read, write, copy, append and trim the data. cdemolb2.c                                Writing and reading of CLOB/BLOB columns with stream mode and callback functions. cdemolbs.c                                Writing and reading to LOBs with the LOB buffering system. cdemobj.c                                 Pinning and navigation of REF object. cdemorid.c                                Using INSERT, UPDATE, DELETE statements and fetches to get multiple rowids in one round-trip. cdemoses.c                                Using session switching and migration. cdemothr.c                                Using the OCIThread package. cdemosyev.c                               Registering predefined subscriptions and specifying a callback function to be invoked for client notifications (for more information about Advanced Queuing, see Oracle Streams Advanced Queuing User’s Guide and Reference). ociaqdemo00.c,ociaqdemo01.c,ociaqdemo02.c Advanced queuing. cdemodp.c,cdemodp_lip.c                   Loading data with the direct path load functions. cdemdpco.c                                Loading a column object with the direct path load functions. cdemdpno.c                                Loading a nested column object with the direct path load functions. cdemdpin.c                                Loading derived type (inheritance) - direct path. cdemdpit.c                                Loading an object table with inheritance - direct path. cdemdpro.c                                Loading a reference with the direct path load functions. cdemdpss.c                                Loading SQL strings with the direct path load functions. cdemoucb.c,cdemoucbl.c                    Using static and dynamic user callbacks. cdemoupk.c,cdemoup1.c,cdemoup2.c          Using dynamic user callbacks with multiple packages. cdemodt.c                                 Datetime and interval example. cdemosc.c                                 Scrollable cursor. cdemol2l.c                                Accesses LOBs using the LONG API. cdemoin1.c                                Inheritance demo which modifies an inherited type in a table and displays a record from the table. cdemoin2.c                                Inheritance demo to do attribute substitutability. cdemoin3.c                                Inheritance demo that describes an object, inherited types, object tables, and a sub-table. cdemoanydata1.c                           Anydata demo. Inserts and selects rows to and from anydata table. cdemoanydata2.c                           Anydata demo. Creates a type piecewise using OCITypeBeginCreate() and then describes the new type created. cdemosp.c                                 Session pooling. cdemocp.c                                 Connection pooling. cdemocpproxy.c                            Connection pooling with proxy functionality. cdemostc.c                                Statement caching. cdemouni.c                                Program for OCI UTF16 API. nchdemo1.c                                Shows nchar implicit conversion feature and codepoint feature.


Question: 求助,CRC计算错误！百思不得其解啊....

引用 1 楼 UAVGCS 的回复:单步调一下啊！ 调试了，还是这样.......后来确定了是接收到的数据长度有错误

上面的错了。 正确的如下 #include <stdio.h> #include <stdlib.h> #include <windows.h> WORD GetCheckCode(const char * pSendBuf, int nEnd) { 	WORD wCrc = WORD(0xFFFF); 	for(int i=0; i<nEnd; i++)	 	{ 		 		wCrc ^= WORD(BYTE(pSendBuf[i])); 		for(int j=0; j<8; j++)		 		{ 			if(wCrc & 1)		 			{	 				wCrc >>= 1; 		 				wCrc ^= 0xA001; 	 			} 			else	 			{ 				wCrc >>= 1;  			}	 		}	 	} 	return wCrc; } void main() { 	BYTE szSend[8] = {0}; 	szSend[0] = 0x01; 	szSend[1] = 0x03; 	szSend[2] = 0x00; 	szSend[3] = 0x02; 	szSend[4] = 0x00; 	szSend[5] = 0x01;	 	WORD CRCCode = GetCheckCode((char*)szSend,6);	 	BYTE Code[2] = {0}; 	memcpy(Code,&CRCCode,sizeof(Code)); 	memcpy(&szSend[6],Code,sizeof(Code)); }  引用 楼主 zhk_xbox 的回复:我做个 modbus的东西 需要CRC校验码 然后不知道为什么都计算错误 比如设备手册上给的0x01,0x03,0x00,0x02,0x00,0x01计算出来的CRC是0x25,0xca(0x25ca) 我这边计算的变成了c79a，代码如下：   unsigned int  u16CRC_Reg = 0xffff;  for(int iDataLenght = 0; iDataLenght < 8; iDataLenght++)   {     //Step2:把数据帧中的第一个字节(开始)的8位与CRC寄存器     //      中的低字节进行异或运算,结果存回CRC寄存器     u16CRC_Reg = u16CRC_Reg ^ u8InData[iDataLenght];      u16CRC_Temp = 0x0000;      //Step3:将CRC寄存器向右移一位，最高位填以0,最低位移出并检测     //Step4:如果最低位为0,重复第3步(下一次移位);     //      如果最低位为1,将CRC寄存器与一个预设的固定值(0A001H)进行异或运算     for(int iByte =  0; iByte < 8; iByte++)     {       if(u16CRC_Reg & 0x0001)       {         u16CRC_Reg = (u16CRC_Reg >> 1) ^ CRC_Mul;       }       else         u16CRC_Reg = u16CRC_Reg >> 1;     }   }    cout<<hex<<u16CRC_Reg<<endl;

引用 楼主 zhk_xbox 的回复:我做个 modbus的东西 需要CRC校验码 然后不知道为什么都计算错误 比如设备手册上给的0x01,0x03,0x00,0x02,0x00,0x01计算出来的CRC是0x25,0xca(0x25ca) 我这边计算的变成了c79a，代码如下：   unsigned int  u16CRC_Reg = 0xffff;  for(int iDataLenght = 0; iDataLenght < 8; iDataLenght++)   {     //Step2:把数据帧中的第一个字节(开始)的8位与CRC寄存器     //      中的低字节进行异或运算,结果存回CRC寄存器     u16CRC_Reg = u16CRC_Reg ^ u8InData[iDataLenght];      u16CRC_Temp = 0x0000;      //Step3:将CRC寄存器向右移一位，最高位填以0,最低位移出并检测     //Step4:如果最低位为0,重复第3步(下一次移位);     //      如果最低位为1,将CRC寄存器与一个预设的固定值(0A001H)进行异或运算     for(int iByte =  0; iByte < 8; iByte++)     {       if(u16CRC_Reg & 0x0001)       {         u16CRC_Reg = (u16CRC_Reg >> 1) ^ CRC_Mul;       }       else         u16CRC_Reg = u16CRC_Reg >> 1;     }   }    cout<<hex<<u16CRC_Reg<<endl;  看我楼上代码

GetCRC(const char * buf,int len) { 	unsigned short crc; 	int i,j; 	short tc; 	crc = 0xffff; 	byte sbit;	 	if (len != 0) 	{		 		for(i = 0;i < len;i++) 		{	 			tc = (short)(crc>>8); 			crc = (tc^buf[i])&0x00FF; 			for(j = 0;j < 8;j++) 			{ 				sbit = (char)(crc & 0x01); 	 				crc >>= 1;				 				if (sbit != 0)  					crc = (crc ^ 0xA001) & 0x0000FFFF;  			} 		} 	} 	return crc; }

单步调一下啊！

引用 4 楼 爷就是这个范儿的回复:上面的错了。 正确的如下 #include <stdio.h> #include <stdlib.h> #include <windows.h> WORD GetCheckCode(const char * pSendBuf, int nEnd) { 	WORD wCrc = WORD(0xFFFF); 	for(int i=0; i<nEnd; i++)	 	{ 		 		wCrc ^= WORD(BYTE(pSendBuf[i])); 		for(int j=0; j<8; j++)		 		{ 			if(wCrc & 1)		 			{	 				wCrc >>= 1; 		 				wCrc ^= 0xA001; 	 			} 			else	 			{ 				wCrc >>= 1;  			}	 		}	 	} 	return wCrc; } void main() { 	BYTE szSend[8] = {0}; 	szSend[0] = 0x01; 	szSend[1] = 0x03; 	szSend[2] = 0x00; 	szSend[3] = 0x02; 	szSend[4] = 0x00; 	szSend[5] = 0x01;	 	WORD CRCCode = GetCheckCode((char*)szSend,6);	 	BYTE Code[2] = {0}; 	memcpy(Code,&CRCCode,sizeof(Code)); 	memcpy(&szSend[6],Code,sizeof(Code)); }  [quote=引用 楼主 zhk_xbox 的回复:] 我做个 modbus的东西 需要CRC校验码 然后不知道为什么都计算错误 比如设备手册上给的0x01,0x03,0x00,0x02,0x00,0x01计算出来的CRC是0x25,0xca(0x25ca) 我这边计算的变成了c79a，代码如下：   unsigned int  u16CRC_Reg = 0xffff;  for(int iDataLenght = 0; iDataLenght < 8; iDataLenght++)   {     //Step2:把数据帧中的第一个字节(开始)的8位与CRC寄存器     //      中的低字节进行异或运算,结果存回CRC寄存器     u16CRC_Reg = u16CRC_Reg ^ u8InData[iDataLenght];      u16CRC_Temp = 0x0000;      //Step3:将CRC寄存器向右移一位，最高位填以0,最低位移出并检测     //Step4:如果最低位为0,重复第3步(下一次移位);     //      如果最低位为1,将CRC寄存器与一个预设的固定值(0A001H)进行异或运算     for(int iByte =  0; iByte < 8; iByte++)     {       if(u16CRC_Reg & 0x0001)       {         u16CRC_Reg = (u16CRC_Reg >> 1) ^ CRC_Mul;       }       else         u16CRC_Reg = u16CRC_Reg >> 1;     }   }    cout<<hex<<u16CRC_Reg<<endl; [/quote] 多谢 多谢 正常了 因为发送数据包的设备有问题 发送的数据长度不正常 而且我这边也把CRC的高低位也弄反了


Question: dcmtk中addDicomfile()函数的使用问题

好吧，我自己解决了，才想起来帖子还没结...

引用 3 楼 wang0635 的回复:[quote=引用 楼主 U201212366 的回复:] 最近我接触dicomdir，然后像先生成一个dicomdir文件，代码如下： #include "stdafx.h" #include "dcmdir_study.h" #include "dcmdir_studyDlg.h" #include "../include/dcmtk/dcmdata/dcddirif.h" ////////////////////////////////////////////////////////////////////////////////// 略去mfc结构代码 ///////////////////////////////////////////////////////////////////////////////// void Cdcmdir_studyDlg::OnBnClickedButton1() {      DicomDirInterface dicomdir;      OFCondition status = dicomdir.createNewDicomDir();这里操作成功了吗？      status = dicomdir.addDicomFile("1348","D:");      if (status.bad())      {           MessageBox("Cannot add dicom file");           return;       }      status = dicomdir.writeDicomDir();      if (status.bad())      {          MessageBox("Cannot write dicomdir");      } /////////////////////////////////////////////////////////////////////////////// 问题是一直无法添加dicom文件，addDicomfile()函数哪里用错了吗 createNewDicomDir()操作成功了吗？[/quote]  引用 3 楼 wang0635 的回复:[quote=引用 楼主 U201212366 的回复:] 最近我接触dicomdir，然后像先生成一个dicomdir文件，代码如下： #include "stdafx.h" #include "dcmdir_study.h" #include "dcmdir_studyDlg.h" #include "../include/dcmtk/dcmdata/dcddirif.h" ////////////////////////////////////////////////////////////////////////////////// 略去mfc结构代码 ///////////////////////////////////////////////////////////////////////////////// void Cdcmdir_studyDlg::OnBnClickedButton1() {      DicomDirInterface dicomdir;      OFCondition status = dicomdir.createNewDicomDir();这里操作成功了吗？      status = dicomdir.addDicomFile("1348","D:");      if (status.bad())  这里去掉判断，并且我用文件对话框获取一个dicom文件，用getpathname()得到的路径作为 addDicomFile()的参数，最终会出现一个414b的dicomdir文件，但实际上status仍然是个bad value      {           MessageBox("Cannot add dicom file");           return;       }      status = dicomdir.writeDicomDir();      if (status.bad())      {          MessageBox("Cannot write dicomdir");      } /////////////////////////////////////////////////////////////////////////////// 问题是一直无法添加dicom文件，addDicomfile()函数哪里用错了吗 createNewDicomDir()操作成功了吗？[/quote] 操作应该是成功的，如果不判断是否天际成功

引用 楼主 U201212366 的回复:最近我接触dicomdir，然后像先生成一个dicomdir文件，代码如下： #include "stdafx.h" #include "dcmdir_study.h" #include "dcmdir_studyDlg.h" #include "../include/dcmtk/dcmdata/dcddirif.h" ////////////////////////////////////////////////////////////////////////////////// 略去mfc结构代码 ///////////////////////////////////////////////////////////////////////////////// void Cdcmdir_studyDlg::OnBnClickedButton1() {      DicomDirInterface dicomdir;      OFCondition status = dicomdir.createNewDicomDir();这里操作成功了吗？      status = dicomdir.addDicomFile("1348","D:");      if (status.bad())      {           MessageBox("Cannot add dicom file");           return;       }      status = dicomdir.writeDicomDir();      if (status.bad())      {          MessageBox("Cannot write dicomdir");      } /////////////////////////////////////////////////////////////////////////////// 问题是一直无法添加dicom文件，addDicomfile()函数哪里用错了吗 createNewDicomDir()操作成功了吗？

引用 1 楼 zhao4zhong1 的回复:建议先编译链接调试自带的例子代码（如果有）；没有的话，在网上搜可用的相关例子代码参考一下。 额。。。这个就是OFFIS DCMTK上的示例代码...

引用 5 楼 zhao4zhong1 的回复:找Bug的时候要抱着“怀疑一切，打击一切”的心态。 谢谢，受教了

找Bug的时候要抱着“怀疑一切，打击一切”的心态。


Question: C语言新手问题

char** space_Malloc(char **mabuff,const int buffsize ,const int size) {     int count;     char *temcp;     char **temmabuff;      if (mabuff == NULL || buffsize <= 0 || size <=0)     {         temmabuff = EOF;         printf("Error_space : %d\n",temmabuff);         return temmabuff;     }      temmabuff = mabuff;     for (count=0; count<buffsize; count++)     {         temcp = temmabuff[count] = (char *)malloc(sizeof(char)*size);         if (temcp == NULL)         {             count--;             for (; count>0; count--)             {                 free(temmabuff[count]);                 temmabuff[count] = NULL;             }             temmabuff = EOF;             printf("Error_malloc : %d\n",temmabuff);             return temmabuff;         }         temmabuff[count][0] = '\0';     }      return temmabuff; }


Question: linux下main函数的参数是在栈里还是在堆里

请参考《CSAPP》中第8章 异常控制流，有图片显示告诉你，char ** agrv和char ** env保存在栈上，且在main函数栈之前，agrv和env指向一个以NULL为结尾的char*数组，数组中每一个值都指向一个字符串。 以上char*数组和字符串都是在栈中，且在mian函数栈前。

int argc, char **argv, char **env 这三个是在栈中 *argv 也许在栈中，毕竟程序员自己也可用用 alloca 分配栈上内存 **argv 在命令行参数 或者命令行参数某个copy的存储位置   env 与此雷同

堆是由你手动分配释放的

当然是在栈里

栈里，地址就很说明问题

在环境中。

LZ的截图已经能够说明问题了。 ch是在栈上的，argc/argv/env三个参数的地址离它不远。

ls的解释似乎合理

main的形参肯定是栈上呀，要不退出main之后岂不是内存泄露了


Question: 学C++不久 有些错误不懂 求大神解答 错误C4113

LRESULT CALLBACK WndProc(HHWND,UINT,WPARAM,LPARAM);

第二行的函数原型 LRESULT CALLBACK WndProc(HHWND,WPARAM,LPARAM); 与后面的函数定义参数个数不同

。。。我不知道怎么改 而且是什么问题也不清楚。。

淡定点,这是警告,不是错误, 检查一下11行是什么


Question: 求助帮我看看关于一元二次方程的程序

#include <stdio.h> #include <math.h> void main() {     double a,b,c;     scanf("%lf%lf%lf",&a,&b,&c);          if (b*b-4.0*a*c <0.0) printf("无实根\n");     else if (b*b-4.0*a*c==0.0) printf("%.4g\n%.4g\n", -b                   /2.0*a, -b                   /2.0*a);     else                       printf("%.4g\n%.4g\n",(-b+sqrt(b*b-4.0*a*c))/2.0*a,(-b-sqrt(b*b-4.0*a*c))/2.0*a); }

引用 2 楼 kid_0203 的回复:引用 1楼user-3 的回复:main，不是 mian我改了之后结果仍然错误，，，  #include <stdio.h> #include <math.h> void main() { 	float a,b,c; 	scanf("%f%f%f",&a,&b,&c); 	if(b*b-4*a*c<0) 		printf("无实根\n"); 	if(b*b-4*a*c==0) 		printf("%.4f\n%.4f\n",-b/2*a,-b/-2*a); 	if(b*b-4*a*c>0) 		printf("%.4f\n%.4f\n",(-b+sqrt(b*b-4*a*c))/2*a,(-b-sqrt(b*b-4*a*c))/2*a); } 没问题呀，输入的时候每次输入一个数之后回车

main，不是 mian


Question: VS2015中if...ese if语句

这是C/C++最基本的语法，怎么可能会不支持，但你要了解清楚怎么用 比如else的话你只能放在最后，且后面不跟小括号，表示前面情况都不满足，就执行此处

最后一个分支理论上来讲都最好都用else。如果你用if else，那可能会有漏掉的未处理的分支

可以的啊    。。。

当然可以用 else ... ，你为什么会认为不能？

else 后面不能有小括号

可以支持的，VS只是集成环境，这些规则是C/C++语言规定的。if else if 在这两个工具中是一模一样的。


Question: C语言报错（单链表，不超过50行）    急

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

while(d && (locate != d->date)) {        d = d->next; }

跟踪代码调试自己就能找到错误的

逻辑有点问题，帮你改了下main函数   void main(){     int locate;     int datas;     NODE *c, *d;     c = create();     d = c->next;     printf("请输入插入位置\n");     scanf("%d", &locate);     NODE* tail = NULL;     while (d && locate != d->data){         tail = d;         d = d->next;     }     if (d == NULL){         printf("%d不存在\n",locate);     }     else{         printf("请输入数据：");         scanf("%d", &datas);         insert(tail, datas);         printf("改变后的链表：");         while (c->next!= NULL){             c = c->next;             printf("%d ", c->data);          }     } }


Question: 寻求帮助呀！！！C++，为什么会出现如图的错误！？error C4700: 使用了未初始化的局部变量“current”“e”“prev”	??

引用 4 楼 wang268218 的回复:current = (ST *)malloc(sizeof(ST)); 这不是相当于初始化current了吗??? 干任何事都是要讲究先后次序的。

非局部变量不需要初始化的原因是，编译器已自动帮你完成了初始化。

局部变量使用前必须初始化，因为当局部变量被第一次使用时，程序将无法正确判断该变量的值。

if (NULL == Head)         Head = current; //不初始化你就赋值，它里面都是垃圾数据啊     else         prev->Next = current; 其他的同上，一样的错误