Datasets:

Mxode

/

CSDN-Community-C-Language-3years

like 2

[ { "cid": "1", "user": "user-1", "content": "BOOL WINAPI GetGUIThreadInfo( _In_ DWORD idThread, _Inout_ LPGUITHREADINFO lpgui ); BOOL WINAPI GetGUIThreadInfo( _In_ DWORD idThread, _Inout_ LPGUITHREADINFO lpgui ); Parameters idThread [in] Type: DWORD The identifier for the thread for which information is to be retrieved. To retrieve this value, use the GetWindowThreadProcessId function. If this parameter is NULL, the function returns information for the foreground thread. lpgui [in, out] Type: LPGUITHREADINFO A pointer to a GUITHREADINFO structure that receives information describing the thread. Note that you must set the cbSize member to sizeof(GUITHREADINFO) before calling this function. Return value Type: Type: BOOL If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError. Remarks This function succeeds even if the active window is not owned by the calling process. If the specified thread does not exist or have an input queue, the function will fail. This function is useful for retrieving out-of-context information about a thread. The information retrieved is the same as if an application retrieved the information about itself. For an edit control, the returned rcCaret rectangle contains the caret plus information on text direction and padding. Thus, it may not give the correct position of the cursor. The Sans Serif font uses four characters for the cursor:", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "多线程日志参考下面：//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef _MSC_VER #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER #include <windows.h> #include <process.h> #include <io.h> #define MYVOID void #define vsnprintf _vsnprintf #else #include <unistd.h> #include <sys/time.h> #include <pthread.h> #define CRITICAL_SECTION pthread_mutex_t #define MYVOID void * #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]=\"MyLog1.log\"; char logfilename2[]=\"MyLog2.log\"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef _MSC_VER void Lock(CRITICAL_SECTION *l) { EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) { LeaveCriticalSection(l); } void sleep_ms(int ms) { Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) { pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) { pthread_mutex_unlock(l); } void sleep_ms(int ms) { usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) { struct tm *now; struct timeb tb; if (NULL==pszFmt||0==pszFmt[0]) return; vsnprintf(logstr,MAXLINSIZE,pszFmt,argp); ftime(&tb); now=localtime(&tb.time); sprintf(datestr,\"%04d-%02d-%02d\",now->tm_year+1900,now->tm_mon+1,now->tm_mday); sprintf(timestr,\"%02d:%02d:%02d\",now->tm_hour ,now->tm_min ,now->tm_sec ); sprintf(mss,\"%03d\",tb.millitm); printf(\"%s %s.%s %s\",datestr,timestr,mss,logstr); flog=fopen(logfilename1,\"a\"); if (NULL!=flog) { fprintf(flog,\"%s %s.%s %s\",datestr,timestr,mss,logstr); if (ftell(flog)>MAXLOGSIZE) { fclose(flog); if (rename(logfilename1,logfilename2)) { remove(logfilename2); rename(logfilename1,logfilename2); } } else { fclose(flog); } } } void Log(const char *pszFmt,...) { va_list argp; Lock(&cs_log); va_start(argp,pszFmt); LogV(pszFmt,argp); va_end(argp); Unlock(&cs_log); } //Log} #define ASIZE 200 #define BSIZE 240 #define CSIZE 2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX; CRITICAL_SECTION cs_BBB; struct FIFO_BUFFER { int head; int tail; int size; char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) { int i,j,k; char binstr[80]; Lock(&cs_HEX); for (i=0;i<len;i++) { if (0==(i%16)) { sprintf(binstr,\"%03d %04x -\",cn,i); sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]); } else if (15==(i%16)) { sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]); sprintf(binstr,\"%s \",binstr); for (j=i-15;j<=i;j++) { sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.'); } Log(\"%s\\n\",binstr); } else { sprintf(binstr,\"%s %02x\",binstr,(unsigned char)buf[i]); } } if (0!=(i%16)) { k=16-(i%16); for (j=0;j<k;j++) { sprintf(binstr,\"%s \",binstr); } sprintf(binstr,\"%s \",binstr); k=16-k; for (j=i-k;j<i;j++) { sprintf(binstr,\"%s%c\",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.'); } Log(\"%s\\n\",binstr); } Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) { int lent,len1,len2; lent=0; Lock(cs); if (fbuf->size>=len) { lent=len; if (fbuf->head+lent>BSIZE) { len1=BSIZE-fbuf->head; memcpy(buf ,fbuf->data+fbuf->head,len1); len2=lent-len1; memcpy(buf+len1,fbuf->data ,len2); fbuf->head=len2; } else { memcpy(buf ,fbuf->data+fbuf->head,lent); fbuf->head+=lent; } fbuf->size-=lent; } Unlock(cs); return lent; } MYVOID thdB(void *pcn) { char *recv_buf; int recv_nbytes; int cn; int wc; int pb; cn=(int)pcn; Log(\"%03d thdB thread begin...\\n\",cn); while (1) { sleep_ms(10); recv_buf=(char *)Cbuf; recv_nbytes=CSIZE; wc=0; while (1) { pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes); if (pb) { Log(\"%03d recv %d bytes\\n\",cn,pb); HexDump(cn,recv_buf,pb); sleep_ms(1); } else { sleep_ms(1000); } if (No_Loop) break;// wc++; if (wc>3600) Log(\"%03d %d==wc>3600!\\n\",cn,wc); } if (No_Loop) break;// } #ifndef _MSC_VER pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) { int lent,len1,len2; Lock(cs); lent=len; if (fbuf->size+lent>BSIZE) { lent=BSIZE-fbuf->size; } if (fbuf->tail+lent>BSIZE) { len1=BSIZE-fbuf->tail; memcpy(fbuf->data+fbuf->tail,buf ,len1); len2=lent-len1; memcpy(fbuf->data ,buf+len1,len2); fbuf->tail=len2; } else { memcpy(fbuf->data+fbuf->tail,buf ,lent); fbuf->tail+=lent; } fbuf->size+=lent; Unlock(cs); return lent; } MYVOID thdA(void *pcn) { char *send_buf; int send_nbytes; int cn; int wc; int a; int pa; cn=(int)pcn; Log(\"%03d thdA thread begin...\\n\",cn); a=0; while (1) { sleep_ms(100); memset(Abuf,a,ASIZE); a=(a+1)%256; if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop send_buf=(char *)Abuf; send_nbytes=ASIZE; Log(\"%03d sending %d bytes\\n\",cn,send_nbytes); HexDump(cn,send_buf,send_nbytes); wc=0; while (1) { pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes); Log(\"%03d sent %d bytes\\n\",cn,pa); HexDump(cn,send_buf,pa); send_buf+=pa; send_nbytes-=pa; if (send_nbytes<=0) break;// sleep_ms(1000); if (No_Loop) break;// wc++; if (wc>3600) Log(\"%03d %d==wc>3600!\\n\",cn,wc); } if (No_Loop) break;// } #ifndef _MSC_VER pthread_exit(NULL); #endif } int main() { #ifdef _MSC_VER InitializeCriticalSection(&cs_log); InitializeCriticalSection(&cs_HEX); InitializeCriticalSection(&cs_BBB); #else pthread_t threads[2]; int threadsN; int rc; pthread_mutex_init(&cs_log,NULL); pthread_mutex_init(&cs_HEX,NULL); pthread_mutex_init(&cs_BBB,NULL); #endif Log(\"Start===========================================================\\n\"); BBB.head=0; BBB.tail=0; BBB.size=0; #ifdef _MSC_VER _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1); _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else threadsN=0; rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log(\"%d=pthread_create %d error!\\n\",rc,threadsN-1); rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log(\"%d=pthread_create %d error!\\n\",rc,threadsN-1); #endif if (!access(\"No_Loop\",0)) { remove(\"No_Loop\"); if (!access(\"No_Loop\",0)) { No_Loop=1; } } while (1) { sleep_ms(1000); if (No_Loop) break;// if (!access(\"No_Loop\",0)) { No_Loop=1; } } sleep_ms(3000); Log(\"End=============================================================\\n\"); #ifdef _MSC_VER DeleteCriticalSection(&cs_BBB); DeleteCriticalSection(&cs_HEX); DeleteCriticalSection(&cs_log); #else pthread_mutex_destroy(&cs_BBB); pthread_mutex_destroy(&cs_HEX); pthread_mutex_destroy(&cs_log); #endif return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 8 楼 早打大打打核战争 的回复:你检查一下SetActiveWindow成功了没有 的确是设置失败（返回NULL），可是这个跟WM_ACTIVATE有关系吗？ 刚刚我把SetActiveWindow(hwnd); 注释了，保留SetForegroundWindow ( hwnd2 );，结果是这样的： 在我并没有设置激活的情况下，消息依然显示是先失去激活，之后又激活，但这时输入的字符都在记事本那里，这边窗口应该是失去激活的。 我也顺便确认了下，WM_ACTIVATE是非队列消息，那么应该就不存在因延迟而混乱的情况。", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "你检查一下SetActiveWindow成功了没有", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复:估计是多道程序（包括多进程、多线程、……）输出日志信息时没有加锁。 引用 6 楼 早打大打打核战争 的回复:输出log时加上时间就能看出来了 你们说的日志、log是啥？？windows 日志吗？ 对于不同进程即便顺序混乱，但对于单个程序来说，不可能也不应该混乱吧？它这不是一个一个消息逐步处理的吗？顺序乱了的话，岂不就异常了？", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "引用 2 楼 赵4老师 的回复:帮结帖+蹭分 问题都还没解决呢", "referer": "user-0" }, { "cid": "7", "user": "user-2", "content": "引用 4 楼 赵4老师 的回复:估计是多道程序（包括多进程、多线程、……）输出日志信息时没有加锁。 从而导致看上去日志信息的顺序和实际程序输出日志的顺序不完全一致。 我猜。", "referer": "user-0" }, { "cid": "8", "user": "user-2", "content": "估计是多道程序（包括多进程、多线程、……）输出日志信息时没有加锁。", "referer": "user-0" }, { "cid": "9", "user": "user-3", "content": "输出log时加上时间就能看出来了", "referer": "user-0" }, { "cid": "10", "user": "user-2", "content": "帮结帖+蹭分", "referer": "user-0" }, { "cid": "11", "user": "user-0", "content": "问题应该是找到了，GetActiveWindow和GetFocus都是只能获取当前线程相关的。 现在应该只剩一个问题，WM_ACTIVATE应该是先激活（1）再失去激活（0），但这里收到的消息顺序是相反的，而且实际的效果是先激活了，再由于调用了SetForegroundWindow而失去激活，先1再0才对呀", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "推荐是看书，还是按看视频，本人看书感觉有点乏味", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 3 楼 ctrigger 的回复:[quote=引用 2 楼 namedashadiao 的回复:]数据结构和算法有推荐的学习途径吗？ 大学不学数据结构和算法么？啥情况？？ 严蔚敏老师的数据结构不错，适合入门。[/quote] 不是不学，大二学，想提前学", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "写是最好的练习", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "引用 2 楼 namedashadiao 的回复:数据结构和算法有推荐的学习途径吗？ 大学不学数据结构和算法么？啥情况？？ 严蔚敏老师的数据结构不错，适合入门。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "数据结构和算法有推荐的学习途径吗？", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "学完数据结构与算法再蓝桥吧", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "谢谢大佬！不过还想问问我原来的为什么运行出来的结果很奇怪", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "#include<stdio.h> #include<string.h> char s1[500],s2[20]; char substr[20]; void findshort(char str[]) { int len, i, sub_len = 0; len = strlen(str); for (i = 0; str[i]; i++) { if (sub_len == 0 && (str[i] == ' ' || str[i] == '\\n')) continue; if (str[i] == ' ' || str[i] == '\\n') { if (sub_len < len && sub_len != 0) { len = sub_len; memcpy(substr, &str[i-sub_len], sub_len); substr[sub_len] = 0; } sub_len = 0; } else if (str[i] != '\\n') { sub_len++; } } #if 0 int c,i,j,min; c=strlen(s); min=0; j=0; for(i=0;i<c;i++) { if (s[i]>=((s[i]>='a'&&s[i]<='z')||(s[i]>='A'&&s[i]<='Z'))) j++; else { if (min<j) for(int n=0;n<j;n++) s2[n]=s[i-j+n]; j=0; } } #endif } int main() { fgets(s1, 500, stdin); findshort(s1); printf(\"%s\\n\", substr); return 0; } 供参考～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "把while(scanf(\"%d %d \",&a,&b)!=EOF) 改成 while(scanf(\"%d%d \",&a,&b)!=0) 然后输入非数字退出循环。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "不行不行，我用VC还是结束不了", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "linux: ctrl+d windows: ctrl+z 试试～", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "Linux是 ctrl + D windows 是ctrl + z", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用if(i％5=0) printf(\"\\n\");这句有误，应该为if(i％5==0)", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "建议看看动态规划，你这个明显是有重叠子问题，这是状态转移方程，这个跟数组没冲突。", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "[i]表示的是地址门牌号为i f[i]表示的是那第i个门牌号里住了几个人", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "他的地址不变，也就是存放的空间不变，而不是他里面存放的东西不能变。", "referer": "user-0" }, { "cid": "5", "user": "user-4", "content": "计算斐波那契数列 1,1,2,3,5,....", "referer": "user-0" }, { "cid": "6", "user": "user-5", "content": "不是呀 数组元素你可以修改的 f[i]=f[i-1]+f[i-2]就是从数组的第三个元素开始 元素的值是前两个元素的和", "referer": "user-0" }, { "cid": "7", "user": "user-6", "content": "一般来说，数组元素赋初值后是可以改变的。f［i］=f[i-2]+f［i-1］，这句话的意思就是从第三个元素开始，后面的每个元素等于前两个元素之和", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "同问楼主解决了吗", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "各位大佬写出来的把可能的中序排列写一下就行，这样比较简单，但是我觉得没有这课树我画出最接近的树前序序列为abcdfeg", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "如何过滤掉毛刺和抖动？？如何判断第一个波形，第一个波形的波幅要不要纳入计算？？？最后一个波形如何判断，如何处理？？题主是这还是一个比较规则的波形，现实采样的波形必定有毛刺，有些波形比如脉搏还会有抖动（就是上升过程中到部分人的都会中途抖一下）。请不要以纯数学的角度来考虑问题。。。我抖没百度到解决方法，估计波幅算法都是属于每个公司的核心资产。。。。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "而且抖动那次有的时候比最终的那个波顶还要高，有的时候却比最终那个波顶低，而且不是每次都会抖那么一下。。请问各位怎么处理。。。。。", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "感觉你说的波幅和我的不一样，不属于核心算法，只是求一个正弦波的斜率", "referer": "user-1" }, { "cid": "4", "user": "user-1", "content": "那就太简单了，最简单的方法就是找出最大最小值即可。复杂一点找出两个拐点就可以。。", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "引用 3 楼 顾染尘 的回复:[quote=引用 2 楼 ctrigger 的回复:]扫描点，找Y最大值，最小值。 （最大值-最小值）/ 2。。。 我理解就是峰值减去谷值除以2，对的吗？（我还以为幅度是要求角度或者是斜率）感谢！[/quote] 对，就是这样的。 方程应该类似这样的：y = Asin(ωx + φ)，复制是A。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "引用 2 楼 ctrigger 的回复:扫描点，找Y最大值，最小值。 （最大值-最小值）/ 2。。。 我理解就是峰值减去谷值除以2，对的吗？（我还以为幅度是要求角度或者是斜率）感谢！", "referer": "user-0" }, { "cid": "7", "user": "user-2", "content": "扫描点，找Y最大值，最小值。 （最大值-最小值）/ 2。。。", "referer": "user-0" }, { "cid": "8", "user": "user-3", "content": "從圖形求幅度？掃描每個點的坐標不就出來了嗎", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "void gen_random(int upper_bound) { int i; srand(time(NULL); //生成一个种子～ for(i=0;i<N;i++) a[i]=rand()%upper_bound; }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "可以的，蟹蟹。", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "伪随机数。设置一个seed吧。 看看这样是否可行。 #include <stdlib.h> #include <time.h> #define N 100000 int a[N]; void gen_random(int upper_bound) { int i; \t \tsrand((unsigned int)time(NULL)); \t for(i=0;i<N;i++) a[i]=rand()%upper_bound; } int howmany(int value) { int count=0,i; for (i=0;i<N;i++) if(a[i]==value) ++count; return count; } int main(void) { int i; gen_random(10); printf(\"value\\thow many\\n\"); for(i=0;i<10;i++) printf(\"%d\\t%d\\n\",i,howmany(i)); return 0; }", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "https://bbs.csdn.net/topics/390659274", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "switch(s) { case 1:printf(\"d=%d\\n\",d=a+b-c);break; case 2:printf(\"d=%d\\n\",d=a+c-b);break; case 3:printf(\"d=%d\\n\",d=b+c-a);break; case 4:printf(\"d=%d\\n\",d=0);break; case 5:printf(\"d=%d\\n\",d=c-b+a);break; case 6:printf(\"d=%d\\n\",d=a-b+c);break; case 7:printf(\"d=%d\\n\",d=b-a+c);break; case 8:printf(\"d=%d\\n\",d=a+b);break; case 9:printf(\"d=%d\\n\",d=a+c);break; case 10:printf(\"d=%d\\n\",d=b+c);break; default:printf(\"enter data error!\\n\"); }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "许多年过去了，赵4老师还是如此的独领风骚", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "靠猜是猜不出来或猜不全的。建议楼主贴全代码和对应的编译提示～", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "这是链接错误。 需要在链接选项中添加依赖的库文件。", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "上贴中红字应改为 “/link /LIBPATH:附加依赖库.lib所在目录\"， “/link 附加依赖库.lib\" //zhao4zhong1添加(^_^)", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "https://code.visualstudio.com/docs/cpp/config-msvc From the main menu, choose Terminal > Configure Default Build Task. In the dropdown, which will display a tasks dropdown listing various predefined build tasks for C++ compilers. Choose cl.exe build active file, which will build the file that is currently displayed (active) in the editor. Tasks C++ build dropdown This will create a tasks.json file in a .vscode folder and open it in the editor. Your new tasks.json file should look similar to the JSON below: { \"version\": \"2.0.0\", \"tasks\": [ { \"type\": \"shell\", \"label\": \"cl.exe build active file\", \"command\": \"cl.exe\", \"args\": [ \"/Zi\", \"/EHsc\", \"/Fe:\", \"${fileDirname}\\\\${fileBasenameNoExtension}.exe\", \"${file}\", “/link /LIBPATH:附加依赖库.lib所在目录\"， “/link /IMPLIB:附加依赖库.lib\" //zhao4zhong1添加(^_^) ], \"problemMatcher\": [\"$msCompile\"], \"group\": { \"kind\": \"build\", \"isDefault\": true } } ] } The command setting specifies the program to run; in this case that is \"cl.exe\". The args array specifies the command-line arguments that will be passed to cl.exe. These arguments must be specified in the order expected by the compiler. This task tells the C++ compiler to take the active file (${file}), compile it, and create an executable file (/Fe: switch) in the current directory (${fileDirname}) with the same name as the active file but with the .exe extension (${fileBasenameNoExtension}.exe), resulting in helloworld.exe for our example.", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "他们在这两个例子中都是指针向后移一位是吗", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "应该说某种情况下，p++和p+1是一样的，*(p+1)是取值", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "p++是指针 *(p+1)是指针指向的值 p++和p+1也要看前后文才能确定是不是一样 *(p+1)和*(p++)在不同的前后文指向的值可能一样也可能不一样", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "不一样的。p++是p+1赋值给p，而*(p+1)是p+1的地址，但是不会赋值给p，即这两个的区别：p++和p+1是否修改p上是不一样的。", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "p++指针位置后移一位，再用*p取值取的就是下一个位置的值 （p+1）是取后一位指针，指针p指向的值*p还是原来位置的值", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "我想问一下在指针里面他们有什么不同，我看例子两个作用好像都是一样的，都是指针指向的对象向又偏移一个单位", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这样的题不难，最好自己写。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "写个吧，你看看行不行？ #include <stdio.h> #define LEN 10 int main(void) { \tint a[LEN], n, i; \tint maxpos, minpos, sum; \t \t/* 输入n值 */ \tprintf(\"input n:\\n\"); \tscanf(\"%d\", &n); \t \t/* 输入n个数组值 */ \tprintf(\"input n numbers:\\n\"); \tfor(i=0; i<n; i++) \t{ \t\tscanf(\"%d\", &a[i]); \t} \t \t/* 初始化 */ \tmaxpos = minpos = 0; \tsum = a[0]; \t \t/* 扫描数组，找最大值、最小值位置，并计算和 */ \tfor(i=1; i<n; i++) \t{ \t\tsum = sum + a[i]; \t\tif(a[i] > a[maxpos]) maxpos = i; \t\tif(a[i] < a[minpos]) minpos = i; \t} \t \t/* 输出结果 */ \tprintf(\"max_value:\\t%d\\tmin_value:\\t%d\\n\", a[maxpos], a[minpos]); \tprintf(\"max_positon:\\t%d\\tmin_positon:\\t%d\\n\", maxpos, minpos); \tprintf(\"average_value:\\t%.2f\\n\", 1.0*sum/n); \treturn 0; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 3 楼 user-1的回复:[quote=引用 2 楼 陳錄生 的回复:]It works, why? 我的电脑fedora 33，也正常工作。 我觉得应该是“bzero(&s_addr, sizeof(s_addr));”已经赋值0了。即使后面不执行if语句，效果是一样的。[/quote] freebsd handbook是if( INADDR_ANY),而且之前没有报错，太搞了。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "引用 2 楼 陳錄生 的回复:It works, why? 我的电脑fedora 33，也正常工作。 我觉得应该是“bzero(&s_addr, sizeof(s_addr));”已经赋值0了。即使后面不执行if语句，效果是一样的。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "It works, why?", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "引用if(INADDR_ANY) s_addr.sin_addr.s_addr = htonl(INADDR_ANY); INADDR_ANY的值就是0，是不是写反了？？？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "一般来说，服务器端调用accept函数，addr就是客户端地址信息。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "这个是对端的地址，对端socket的地址： The argument addr is a pointer to a sockaddr structure. This structure is filled in with the address of the peer socket", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#define后面的分号去掉，因为define是等价替换，替换之后在malloc的括号里就会出现;分号；", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "#define最后的分号';'去掉试试", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "S.base = (StackData*)malloc(STACK_INIT_SIZE * sizeof(StackData)); 就这一句，一直报错。。。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "那确实是包含WS_CHILD风格，可能是为了避免出现任务栏窗口", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 19 楼 早打大打打核战争 的回复:54808041是十六进制还是十进制 十六进制", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "54808041是十六进制还是十进制", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "引用 14 楼 六道佩恩 的回复:1. 顶级窗口的父窗口真的是桌面窗口吗？毕竟GetParent得到的是NULL，凭借对桌面窗口调用GetWindow函数得到第一个顶层窗口的句柄这一点应该也无法说明所有顶级窗口的父窗口是桌面窗口吧？主要是我一直也没看到微软文档说过顶级窗口的父窗口是桌面窗口，不过就“SetParent指定父窗口为NULL时设置桌面窗口为父窗口”，测试结果是设置后GetWindow仍然得到NULL，应该算佐证了“顶级窗口的父窗口真的是桌面窗口”吧。 先说点其他的。。。 因为我又去看了下msdn上GetParent的说明，发现GetParent有了更详细的说明，微软确实一直在更新啊。 以前的版本（vs2008）： If the window is a child window, the return value is a handle to the parent window. If the window is a top-level window, the return value is a handle to the owner window. If the window is a top-level unowned window or if the function fails, the return value is NULL 微软说了，这个函数可以获取owner窗口，但我实际测试时不行，我以前一直疑惑为什么这个函数获取不到我想要的owner窗口，直到我今天看到最新说明。。。 最新说明： If the window is a child window, the return value is a handle to the parent window. If the window is a top-level window with the WS_POPUP style, the return value is a handle to the owner window. 只有带了WS_POPUP风格后，对其GetParent，才能获取其owner 原来，我以前的窗口虽然不带WS_CHILD，但恰好也没有带WS_POPUP风格，而是WS_OVERLAPPED风格（0x00000000）。所以不行。 而且最新的说明还指明了这个函数返回NULL的情况： This function typically fails for one of the following reasons: 1、The window is a top-level window that is unowned or does not have the WS_POPUP style. 2、The owner window has WS_POPUP style. 这又能看到另一个条件：owner 窗口还不能带WS_POPUP风格（当然也不能带WS_CHILD,必须是WS_OVERLAPPED） 当然，前面都说的是使用GetParent去获取owner的条件，言外之意是，即使获取失败，也并不代表它没有owner。 所以想要健壮的获取owner 窗口，还是用GW_OWNER 调用GetWindow比较好。 这在GetParent的Remark一节中，微软也是这么建议的，在Remark中，我还看到了微软建议的获取真正父窗口该用的函数！ To obtain a window's owner window, instead of using GetParent, use GetWindow with the GW_OWNER flag. To obtain the parent window and not the owner, instead of using GetParent, use GetAncestor with the GA_PARENT flag. 那么终于可以说回正题了，我说了那么多，其实就是想引出GetAncestor这个函数。。微软建议使用GA_PARENT调用GetAncestor来获取窗口的真正父窗口。我也实际测试了，确实可以：使用这个函数后，所有top-level窗口的父窗口确实都是桌面！ 我想这些应该就可以解答你的疑惑了。 但其实我觉得吧，没必要太纠结。毕竟在windows下开发，微软说什么就是什么。。。 引用 14 楼 六道佩恩 的回复:2. 我测试了下，只有子窗口获取父窗口时，才会显示桌面窗口的句柄。这个列表框为什么一定要设置为WS_CHILD？同为桌面窗口的子窗口的话，顶级窗口不行吗？ 没太听懂你说的。你是不是说反了。 我说的明明是：下拉列表框必须是top-level的啊。。。因为它很可能需要超出它自己app的主窗口的范围。所以它只能是桌面的子窗口。 而它自己app的主窗口一般就只是它的owner。 引用 14 楼 六道佩恩 的回复:3. 你的4.1我觉得有个地方说错了，“当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态”，可见与否不是看WS_VISIBLE吗，我测过了，拥有者窗口最小化后，拥有的窗口隐藏后，它已经没有WS_VISIBLE样式了，IsWindowVisible也返回0，这应该算是影响了其可见状态吧？ 你说的对，可能我以前的印象有误， 我现在看了下，owner窗口有WS_MINIMIZE后（最小化），owned窗口就会被隐藏。而不是取决于owner的WS_VISIBLE。所以窗口C还是不会自动隐藏，因为窗口B只是隐藏了，而没有WS_MINIMIZE（最小化）。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 17 楼 user-2 的回复:[quote=引用 16 楼 六道佩恩 的回复:] 我是这样想的，它这样的设计是不是还牵涉到什么原因而使得这个列表框需要一个WS_CHILD 其他的先不讨论，你说的这个我先确定下： 你确定你这个下拉列表框带WS_CHILD？？ 不会吧。。。创建桌面的child window 这种做法我自己还真没做过。。。 [/quote] 你对比下样式，WS_CHILD是0x40 00 00 00", "referer": "user-0" }, { "cid": "6", "user": "user-2", "content": "引用 16 楼 六道佩恩 的回复:我是这样想的，它这样的设计是不是还牵涉到什么原因而使得这个列表框需要一个WS_CHILD 其他的先不讨论，你说的这个我先确定下： 你确定你这个下拉列表框带WS_CHILD？？ 不会吧。。。创建桌面的child window 这种做法我自己还真没做过。。。", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "原来如此，总算能石锤顶级窗口的父窗口是桌面了 我又试了下IsChild，这个没效果，估计是跟GetParent配套的 引用 15 楼 user-2 的回复:[quote=引用 14 楼 六道佩恩 的回复:] 2. 我测试了下，只有子窗口获取父窗口时，才会显示桌面窗口的句柄。这个列表框为什么一定要设置为WS_CHILD？同为桌面窗口的子窗口的话，顶级窗口不行吗？ 没太听懂你说的。你是不是说反了。 我说的明明是：下拉列表框必须是top-level的啊。。。因为它很可能需要超出它自己app的主窗口的范围。所以它只能是桌面的子窗口。 而它自己app的主窗口一般就只是它的owner。 [/quote] 关于这个，我的意思是，列表框的实现，它是创建为以桌面为父窗口的子窗口。然后作为子窗口处于Z序顶端，我的问题是，它为什么不实现为一个TOPMOST的顶级窗口呢，这样的效果感觉应该是一样的？我是这样想的，它这样的设计是不是还牵涉到什么原因而使得这个列表框需要一个WS_CHILD，毕竟我考虑的是由自己来实现类似效果的层面。如果没什么特别原因，那就当我没说", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "引用 8 楼 早打大打打核战争 的回复:实现很简单，就和组合框的下拉列表框一个套路就可以了，SetParent(LISTBOX_HWND, NULL); 然后显示的时候用SetWindowPos设置HWND_TOP标志把LISTBOX置顶即可 关键是移动窗口呢？窗口的Z序变化呢？", "referer": "user-0" }, { "cid": "9", "user": "user-2", "content": "引用 10 楼 六道佩恩 的回复:不过有个问题，它为什么要设为桌面窗口的子窗口？设为顶级窗口不行吗？ 所有顶层窗口（我更愿意称“顶层“窗口为“弹出式”窗口）的父窗口都是桌面。 windows系统中的窗口之间的关系很容易理解错误，个人认为主要原因就在于它有两类窗口（带WS_CHILD风格和不带WS_CHILD风格），却用了同一套窗口之间父子关系建立的API（CreateWindow创建时指定父窗口、SetParent创建后修改父窗口等等）。 所以，你在调用任何有关父子关系的API时，要始终清楚你操作的窗口对象是“弹出式”窗口，还是“子”（带WS_CHILD风格）窗口（我更愿意称“子“窗口为“嵌入式”窗口）。 1.1、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）也为“弹出式”窗口时，这个所谓的“父窗口”，在这时其实是指“拥有者”窗口（owner），窗口A的真正父窗口是桌面。 1.2、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）为“嵌入式”窗口时，系统将找到容纳该“嵌入式”窗口的“弹出式”窗口，以该“弹出式”窗口作为owner窗口。 1.3、Owner窗口一旦指定不能更改。通过GetWindow函数（指定GW_OWNER标志）可获取owner窗口的句柄（如果存在的话）。 1.4、当CreateWindow创建“嵌入式”窗口B时，必须指定一个父窗口（hWndParent参数），父窗口类型不限。“嵌入式”窗口也可以作为其父窗口。 2.1、当调用SetParent修改“弹出式”窗口A的所谓“父窗口”（hWndNewParent）时，窗口A自动变为“嵌入式”窗口（也印证了1.3条所述），且程序员需要手动修正窗口A的风格（加上WS_CHILD,去掉WS_POPUP），否则窗口可能会表现不正常。 2.2、当调用SetParent修改“嵌入式”窗口B的父窗口（hWndNewParent）时，父窗口类型不限（参照1.4）。 拥有父子关系的窗口表现： 3.1、子窗口只能显示在它的父窗口的客户区中，超出父窗口客户区的部分将被裁减掉；父窗口被隐藏时，它的所有子窗口也被隐藏；最小化父窗口不影响子窗口的可见状态，子窗口会随着父窗口被最小化，但是它的WS_VISIBLE属性不变。父窗口被销毁的时候，它的所有子窗口都会被销毁。 由此可见，下拉列表框 必须不能 是程序主窗口的子窗口！ 因为它的显示区域很可能需要超出主窗口客户区！ 3.2、桌面窗口与所有顶层窗口（“弹出式”窗口）也是父/子关系，但又有其特殊性：对桌面窗口调用GetWindow函数（指定GW_CHILD标志）可得到第一个顶层窗口的句柄，但对某一个顶层窗口调用GetParent却会返回NULL，不会返回桌面窗口的句柄。 额外说下 拥有/被拥有（owner-owned）关系的窗口表现： 4.1、顶层窗口（“弹出式”窗口）之间可以存在owner-owned关系。owner-owned关系对窗口可见性的影响为：owned窗口永远显示在owner窗口的前面；当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态。（根据这一点，如果窗口A 拥有窗口B,窗口B拥有窗口C,则当窗口A最小化的时候，窗口B被隐藏，但是窗口 C还是可见的）；当owner窗口被销毁的时候，它所拥有的窗口都会被销毁。", "referer": "user-0" }, { "cid": "10", "user": "user-1", "content": "1. 所有顶级窗口都是桌面窗口的子窗口， 组合框的下拉列表框这样设计，就是为了能够不改变它所在的窗口Z序的情况下，让列表框能显示在置顶窗口之前，如果把它设计为所在窗口的子窗口，那么必须把列表框的父窗口置顶，列表框才能显示在置顶窗口之前 2. 组合框的下拉列表框能像你说的那样“当窗口移动时，列表框跟着动”吗，能“当窗口Z序变化时，列表框也跟着变化”吗（这个其实可以做到，只要设置为TOPMOST即可，但是没有必要），不能，因为它的设计是列表框显示之后，只要在它之外有鼠标点击或者按键事件，列表框就自动隐藏，所以避免了跟随所在窗口移动、动态改变Z序之类的操作", "referer": "user-0" }, { "cid": "11", "user": "user-0", "content": "引用 12 楼 user-2 的回复:[quote=引用 10 楼 六道佩恩 的回复:] 不过有个问题，它为什么要设为桌面窗口的子窗口？设为顶级窗口不行吗？ 所有顶层窗口（我更愿意称“顶层“窗口为“弹出式”窗口）的父窗口都是桌面。 windows系统中的窗口之间的关系很容易理解错误，个人认为主要原因就在于它有两类窗口（带WS_CHILD风格和不带WS_CHILD风格），却用了同一套窗口之间父子关系建立的API（CreateWindow创建时指定父窗口、SetParent创建后修改父窗口等等）。 所以，你在调用任何有关父子关系的API时，要始终清楚你操作的窗口对象是“弹出式”窗口，还是“子”（带WS_CHILD风格）窗口（我更愿意称“子“窗口为“嵌入式”窗口）。 1.1、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）也为“弹出式”窗口时，这个所谓的“父窗口”，在这时其实是指“拥有者”窗口（owner），窗口A的真正父窗口是桌面。 1.2、当CreateWindow创建“弹出式”窗口A并指定“父窗口”（hWndParent参数）为“嵌入式”窗口时，系统将找到容纳该“嵌入式”窗口的“弹出式”窗口，以该“弹出式”窗口作为owner窗口。 1.3、Owner窗口一旦指定不能更改。通过GetWindow函数（指定GW_OWNER标志）可获取owner窗口的句柄（如果存在的话）。 1.4、当CreateWindow创建“嵌入式”窗口B时，必须指定一个父窗口（hWndParent参数），父窗口类型不限。“嵌入式”窗口也可以作为其父窗口。 2.1、当调用SetParent修改“弹出式”窗口A的所谓“父窗口”（hWndNewParent）时，窗口A自动变为“嵌入式”窗口（也印证了1.3条所述），且程序员需要手动修正窗口A的风格（加上WS_CHILD,去掉WS_POPUP），否则窗口可能会表现不正常。 2.2、当调用SetParent修改“嵌入式”窗口B的父窗口（hWndNewParent）时，父窗口类型不限（参照1.4）。 拥有父子关系的窗口表现： 3.1、子窗口只能显示在它的父窗口的客户区中，超出父窗口客户区的部分将被裁减掉；父窗口被隐藏时，它的所有子窗口也被隐藏；最小化父窗口不影响子窗口的可见状态，子窗口会随着父窗口被最小化，但是它的WS_VISIBLE属性不变。父窗口被销毁的时候，它的所有子窗口都会被销毁。 由此可见，下拉列表框 必须不能 是程序主窗口的子窗口！ 因为它的显示区域很可能需要超出主窗口客户区！ 3.2、桌面窗口与所有顶层窗口（“弹出式”窗口）也是父/子关系，但又有其特殊性：对桌面窗口调用GetWindow函数（指定GW_CHILD标志）可得到第一个顶层窗口的句柄，但对某一个顶层窗口调用GetParent却会返回NULL，不会返回桌面窗口的句柄。 额外说下 拥有/被拥有（owner-owned）关系的窗口表现： 4.1、顶层窗口（“弹出式”窗口）之间可以存在owner-owned关系。owner-owned关系对窗口可见性的影响为：owned窗口永远显示在owner窗口的前面；当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态。（根据这一点，如果窗口A 拥有窗口B,窗口B拥有窗口C,则当窗口A最小化的时候，窗口B被隐藏，但是窗口 C还是可见的）；当owner窗口被销毁的时候，它所拥有的窗口都会被销毁。 [/quote] 又见大佬你了 感谢你把这些完整地说了一遍，修正了我一些理解上的缺失 但是我还是有几个疑问： 1. 顶级窗口的父窗口真的是桌面窗口吗？毕竟GetParent得到的是NULL，凭借对桌面窗口调用GetWindow函数得到第一个顶层窗口的句柄这一点应该也无法说明所有顶级窗口的父窗口是桌面窗口吧？主要是我一直也没看到微软文档说过顶级窗口的父窗口是桌面窗口，不过就“SetParent指定父窗口为NULL时设置桌面窗口为父窗口”，测试结果是设置后GetWindow仍然得到NULL，应该算佐证了“顶级窗口的父窗口真的是桌面窗口”吧。 2. 我测试了下，只有子窗口获取父窗口时，才会显示桌面窗口的句柄。这个列表框为什么一定要设置为WS_CHILD？同为桌面窗口的子窗口的话，顶级窗口不行吗？ 3. 你的4.1我觉得有个地方说错了，“当owner窗口最小化的时候，它所拥有的窗口都会被隐藏；但不影响它所拥有的窗口的可见状态”，可见与否不是看WS_VISIBLE吗，我测过了，拥有者窗口最小化后，拥有的窗口隐藏后，它已经没有WS_VISIBLE样式了，IsWindowVisible也返回0，这应该算是影响了其可见状态吧？", "referer": "user-0" }, { "cid": "12", "user": "user-0", "content": "引用 11 楼 早打大打打核战争 的回复:1. 所有顶级窗口都是桌面窗口的子窗口， 组合框的下拉列表框这样设计，就是为了能够不改变它所在的窗口Z序的情况下，让列表框能显示在置顶窗口之前，如果把它设计为所在窗口的子窗口，那么必须把列表框的父窗口置顶，列表框才能显示在置顶窗口之前 2. 组合框的下拉列表框能像你说的那样“当窗口移动时，列表框跟着动”吗，能“当窗口Z序变化时，列表框也跟着变化”吗（这个其实可以做到，只要设置为TOPMOST即可，但是没有必要），不能，因为它的设计是列表框显示之后，只要在它之外有鼠标点击或者按键事件，列表框就自动隐藏，所以避免了跟随所在窗口移动、动态改变Z序之类的操作 为什么你们都说顶级窗口是桌面窗口的子窗口？获取顶级窗口父窗口的句柄是NULL呀 还有就是，你还没说将列表框设计为顶级窗口这个方案，这个方案看起来应该也是可行的呀", "referer": "user-0" }, { "cid": "13", "user": "user-0", "content": "引用 9 楼 六道佩恩 的回复:[quote=引用 8 楼 早打大打打核战争 的回复:]实现很简单，就和组合框的下拉列表框一个套路就可以了，SetParent(LISTBOX_HWND, NULL); 然后显示的时候用SetWindowPos设置HWND_TOP标志把LISTBOX置顶即可 关键是移动窗口呢？窗口的Z序变化呢？[/quote] 我测试了一下，当窗口移动时，列表框没有跟着动，当窗口Z序变化时，列表框也没有跟着变化，看来没我想的那么好。 不过有个问题，它为什么要设为桌面窗口的子窗口？设为顶级窗口不行吗？", "referer": "user-0" }, { "cid": "14", "user": "user-1", "content": "实现很简单，就和组合框的下拉列表框一个套路就可以了，SetParent(LISTBOX_HWND, NULL); 然后显示的时候用SetWindowPos设置HWND_TOP标志把LISTBOX置顶即可", "referer": "user-0" }, { "cid": "15", "user": "user-1", "content": "组合框中的那个LISTBOX的父窗口确实是桌面窗口，所以会有这种效果： 估计这么设计的原因就是为了让它能够在不改变顶级窗口位置关系的情况下完整显示出来", "referer": "user-0" }, { "cid": "16", "user": "user-0", "content": "引用 6 楼 早打大打打核战争 的回复:组合框中的那个LISTBOX的父窗口确实是桌面窗口，所以会有这种效果： 估计这么设计的原因就是为了让它能够在不改变顶级窗口位置关系的情况下完整显示出来 那么这种效果是我们自己无法实现的是吗？", "referer": "user-0" }, { "cid": "17", "user": "user-1", "content": "可以突破父窗口的范围有什么奇怪，只要建立的窗口风格不是child，比如overlapped、popup之类的，都可以突破父窗口的范围 至于列表框其父窗口是桌面窗口这个还有待确认", "referer": "user-0" }, { "cid": "18", "user": "user-0", "content": "引用 4 楼 早打大打打核战争 的回复:可以突破父窗口的范围有什么奇怪，只要建立的窗口风格不是child，比如overlapped、popup之类的，都可以突破父窗口的范围 至于列表框其父窗口是桌面窗口这个还有待确认 你看看这些证据够不够，前三张是根据鼠标位置获取窗口句柄和相关信息，后四张是spy++的，用来佐证这里的获得的确是父窗口而不是拥有者窗口，鼠标用来提示获取的是哪个窗口 这里明显能看到，这里的组合框就是大窗口的子窗口，但它的列表框已经超出了组合框的父窗口了；还有就是，这里列表框的父窗口句柄对比GetDeskWindow获得的桌面窗口句柄，是一样的，它的父窗口是桌面窗口", "referer": "user-0" }, { "cid": "19", "user": "user-0", "content": "引用 1 楼 zgl7903 的回复:https://docs.microsoft.com/en-us/cpp/mfc/reference/ccombobox-class?view=msvc-160#remarks 组合框由与静态控件或编辑控件组合在一起的列表框组成 引用 2 楼 早打大打打核战争 的回复:顾名思义，名字都叫“组合框”啊，就是EDIT和LISTBOX组合呀~~~ 你们没get到我的问题啊 组合框的列表框可以突破它（组合框）本身的窗口范围，甚至可以突破父窗口的范围，查该列表框发现其父窗口是桌面窗口 我的问题在于，它是怎么实现的（指该组合框的列表框）？如果由我们自己来实现的话，有办法实现吗？", "referer": "user-0" }, { "cid": "20", "user": "user-1", "content": "顾名思义，名字都叫“组合框”啊，就是EDIT和LISTBOX组合呀~~~", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "if(delta=0) 改成if(delta==0)", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "中间i，表示i==0时退出for循环。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "中间那个变量忘记删了，只看n，i就行了", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "for循环结构：for(初始化变量；结束条件；每次执行操作) （具体的名词忘了） 所以i/=10每次除以10，中间的i是一个逻辑运算，i==0的时候退出", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "引用 2 楼 ctrigger的回复:中间i，表示i==0时退出for循环。 哦哦哦 懂了 谢谢", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "看你的char[20] 你是不是想定义一个字符串一维数组； 如果是你应该给你想要定义的字符串取一个名字像str；所以你可以这样写char str[20]; 如过你仅仅是想要定义一个字符的话你可以这样写char a;", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "char是数据类型，要这么写 char s[20]才行", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:贴出代码看看 谢谢你啊，我已经改好了", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "贴出代码看看", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "对弈变量的大小写，另外，引入头文件时也要注意大小写；从编译提示上应该没有正确引入头文件。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 4 楼 棉猴的回复:不是students，是student这个结构 结构写在student.h里面，在主函数(student_system.c)里又写了#include \"student.h\"。", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "不是students，是student这个结构", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "引用 2 楼 棉猴的回复: 从出错提示上看，应该是你的结构struct student没有定义完整。也就是说，在调用average()函数时，student可能只有声明没有定义 我在主函数那里声明了struct student students[50];", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "从出错提示上看，应该是你的结构struct student没有定义完整。也就是说，在调用average()函数时，student可能只有声明没有定义", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "Count的C是小写", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "char str[100] = { 0 }; \tchar *x = \"abc\"; \tchar *y = \"def\"; \tstrcpy(str, x); \tstrcpy(str + strlen(x), y); \tprintf(\"z=%s\", str);", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "你是在用c++（而不是c），所以你的直觉是对的，我们当然可以写 z= a+b; #include <iostream> void foo() { \tstd::string a(\"c++:\"); \tstd::string b(\"z=a+b\"); \tstd::string z = a + b; \tstd::cout << z.c_str() << std::endl; }", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "C++版： #include <iostream> using namespace std; int main(void) { \tstring x = \"abc\"; \tstring y = \"def\"; \tstring z; \t \tz = x + y; \tcout << \"z = \" << z << endl; \t \treturn 0; } C版： #include <stdio.h> int main(void) { \tchar str[100]; \tchar *x = \"abc\"; \tchar *y = \"def\"; \tchar *z = str; \t \twhile(*x) *z++ = *x++; \twhile(*y) *z++ = *y++; \t \tz = str; \tprintf(\"z = %s\\n\", z); \t \treturn 0; }", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "可以通过strlen（）函数和for循环将两个字符串数组组合起来，将组合后的字符串输出便可以实现所谓的字符串相加了", "referer": "user-0" }, { "cid": "5", "user": "user-5", "content": "改成 z=str; strcpy(z, a); strcat(z, b); printf(“z=%s”, z);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 3 楼 ctrigger的回复:先看书入门，再写代码巩固和提高。别无他法。。 高手自律，自学习惯，太多人不能坚持，遇到点问题直接放弃", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "先看书入门，再写代码巩固和提高。别无他法。。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:建议针对具体问题来讨论～ 这个论坛的主要目的是为了给初学者提供一个讨论的地方，比如来看我视频教程的同学遇到问题，就可以在这里讨论 这里是我的视频教程 欢迎大家积极参与，所以没有设置具体的讨论问题，可能做得还不够完善，谢谢您的建议！", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "建议针对具体问题来讨论～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "在stm32f10.h中首行添加这两段代码：#ifndef __stm32f10x_h#define __stm32f10x_h 末行添加这一行代码：#endif /__stm32f10x_h/", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 2 楼 Spectre Ghost 的回复:这是位运算呀 2*1=2 3左移两位然后取反", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "这是位运算呀", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "a&=~(3<<2*1) a=a&(~(3<<2*1)) 3(0000 0000 0000 0011)左移两位就是12(0000 0000 0000 1100)，取反(1111 1111 1111 0011)，再按位与就是把低3、4位置0，其余保留。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 5 楼 ctrigger 的回复:用IF语句： int hahaha(int x, int y, int a, int b) { int result = -1; int ad = b - a*x; int aa = y - x; if(ad % aa == 0) result = ad / aa; return result; }感谢大佬", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "用IF语句： int hahaha(int x, int y, int a, int b) { int result = -1; int ad = b - a*x; int aa = y - x; if(ad % aa == 0) result = ad / aa; return result; }", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 1 楼 阿麦 的回复:这是数学题啊 int hahaha(int x, int y, int a, int b) { int ad = b - a*x; int aa = y - x; return ad % aa == 0 ? ad / aa : -1; } 如果if 怎么写呢", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "引用 1 楼 阿麦 的回复:这是数学题啊 int hahaha(int x, int y, int a, int b) { int ad = b - a*x; int aa = y - x; return ad % aa == 0 ? ad / aa : -1; } 感觉和鸡兔同笼的问题有那么一点点相似", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "这是数学题啊 int hahaha(int x, int y, int a, int b) { int ad = b - a*x; int aa = y - x; return ad % aa == 0 ? ad / aa : -1; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "这个是题目", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 2 楼 一颗白面馒头 的回复:]n没有初始化？你输入的数都没有按照你的想法保存在a数组里 对，主要问题在这里。 下面的循环也有问题，i >= 0这不就是一个死循环了吗？ 整个程序都感觉很奇怪～ [/quote] 哈哈哈，吃了炫迈的for循环？", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "引用 2 楼 一颗白面馒头 的回复:n没有初始化？你输入的数都没有按照你的想法保存在a数组里 对，主要问题在这里。 下面的循环也有问题，i >= 0这不就是一个死循环了吗？ 整个程序都感觉很奇怪～", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "有人说在 \"%d\"前加一个空格，即 \" %d\"，不知道灵不灵 另外： 第一、n 没有赋初值，危险，这样 n 可能会是任何值，导致 core dump 第二、for(int i=0; i>=0; i++) 这个循环不会结束的，会运行到天荒地老", "referer": "user-0" }, { "cid": "5", "user": "user-1", "content": "n没有初始化？你输入的数都没有按照你的想法保存在a数组里", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:根据链式队列的特点：先进先出，从头出，从尾进的特点，因此入队跟队尾有关系，C和D都跟队头有关，因此不会选。 p->next = rear->next;是把rear的next（一般是NULL）赋值给p->next；一般是NULL，但是不清楚链表创建，所以这样写p->next = rear->next;比较保险； rear = rear->next = p;先从右向左计算，p赋值给rear->next;然后rear->next赋值给rear，因此最后是把p放到队尾，并且让rear指向p； 哇，谢谢大神，讲的非常清楚。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "根据链式队列的特点：先进先出，从头出，从尾进的特点，因此入队跟队尾有关系，C和D都跟队头有关，因此不会选。 p->next = rear->next;是把rear的next（一般是NULL）赋值给p->next；一般是NULL，但是不清楚链表创建，所以这样写p->next = rear->next;比较保险； rear = rear->next = p;先从右向左计算，p赋值给rear->next;然后rear->next赋值给rear，因此最后是把p放到队尾，并且让rear指向p；", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 8 楼 棉猴的回复:printf()函数的%d和%s打印内容时要求的参数格式不同，%d打印时，后面直接跟变量名，而%s打印时需要跟变量地址。所以 int *a = &b; printf(\"%d\\n\", *a);//------*a是指针指向的内容------- char *pa = arr; printf(\"%s\", pa);//---------pa是指针---------- 所以您说的打印pc指向的内容时，因为pc本身就是指针，所以不需要加* 好的，明白了，非常感谢", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "printf()函数的%d和%s打印内容时要求的参数格式不同，%d打印时，后面直接跟变量名，而%s打印时需要跟变量地址。所以 int *a = &b; printf(\"%d\\n\", *a);//------*a是指针指向的内容------- char *pa = arr; printf(\"%s\", pa);//---------pa是指针---------- 所以您说的打印pc指向的内容时，因为pc本身就是指针，所以不需要加*", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 6 楼 棉猴的回复:\t printf(\"%s\\n\", t.pc);//--------打印t.pc指向的内容------------ printf(\"%p\\n\", t.pc);//--------打印t.pc本身的内容------------ VS2015 C++环境调试结果 其中，0x004ffb94就是t.pc本身的内容，0x004ffb94这个地址上的内容是\"hello bit\\n\" 对于printf()函数的%p的详细用法，请参考 《C++中printf()函数的用法10-6》 希望能够帮到您！ 第二个打印地址懂了，但是第一个还是有点懵比如说int *a;int b=3;a=&b;打印*a就是就意味着打印b里面的值吗？相比那个题目*pc不是意味打印arr数组里面的值吗", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "printf(\"%s\\n\", t.pc);//--------打印t.pc指向的内容------------ printf(\"%p\\n\", t.pc);//--------打印t.pc本身的内容------------ VS2015 C++环境调试结果 其中，0x004ffb94就是t.pc本身的内容，0x004ffb94这个地址上的内容是\"hello bit\\n\" 对于printf()函数的%p的详细用法，请参考 《C++中printf()函数的用法10-6》 希望能够帮到您！", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 3 楼 qybao的回复:没有t.*pc，只有*t.pc //pc才是成员，char *pc只是说成员pc是个char*类型，并不是说成员是*pc，类型是char。好好理解一下区别。 我理解的是*p解析arr首元素地址，等于arr里面存放的变量", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "引用 3 楼 qybao的回复:没有t.*pc，只有*t.pc //pc才是成员，char *pc只是说成员pc是个char*类型，并不是说成员是*pc，类型是char。好好理解一下区别。 你如果是打印pc地址应该是什么呢", "referer": "user-0" }, { "cid": "7", "user": "user-2", "content": "没有t.*pc，只有*t.pc //pc才是成员，char *pc只是说成员pc是个char*类型，并不是说成员是*pc，类型是char。好好理解一下区别。", "referer": "user-0" }, { "cid": "8", "user": "user-3", "content": "t. *pc要求pc是实例成员指针类型char *S::pc;参见《C++程序设计精要教程》各种指针混合的用法P131,P298: 包括C普通指针，实例成员指针，静态成员指针以及基于类模板的各种指针等。", "referer": "user-0" }, { "cid": "9", "user": "user-4", "content": "引用char *pc == (char *)(pc) char *pc != (char)(* pc) 括号仅用于帮助理解。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "去年11月21日的代码 #include<stdio.h> #include<string.h> int main() { int T,n,s,sum=0,res=0,d; scanf(\"%d%d\",&T,&n); d=n; int a[n+5],b[n+5],i=1,j; while(d>0) { scanf(\"%d %d\",&a[i],&b[i]); //printf(\"%d %d\\n\",a[i],b[i]); i++; d--; } for(i=1;i<n;i++) { for(j=i+1;j<=n;j++) { if(a[i]>a[j]) { s=a[i]; a[i]=a[j]; a[j]=s; s=b[i]; b[i]=b[j]; b[j]=s; } } } for(i=1;i<=n;i++) { for(j=1;j<=b[i];j++) { sum=sum+a[i]; res++; if(sum>=T) { goto out; } } } out: printf(\"%d\\n\",res); return 0; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "前面的回答少写了个解引用，printf(\"%f\\n\",*(float*)&f.a); 另外看了下，发现你对浮点型的结构有误解 #include \"stdio.h\" int main( void ) { \tint a=0x3FC00000; \tprintf(\"%f\", *(float*)&a ); \treturn 0; } 另外，可变参数那里，具体会因编译器而有所不同，转8字节这个，gcc是这样的", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "把b的类型换成8字节的long long，然后你赋值的这个浮点二进制改为64位结构的。 原因是对于可变参数的处理，整型转8字节，浮点型转double，你这里它认为的是整型，所以按仅填了4字节，而%f要读8字节。、 第二种方法就是让编译器认为你传的是4字节float类型，帮你自动转，方法是，printf(\"%f\\n\",(float*)&f.a);", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "1.125转换成二进制是1.001，指数是0，而而指数位的起始值是127，所以指数值是0111 1111，符号位是0，尾数位是001 0000 0000 0000 0000 0000，所以合在一起的值是0011 1111 1001 0000 0000 0000 0000 0000，而变量使用主机字节序存储（大头big-endian），即低地址保存数值的低位，高地址保存数值的高位，所以1.125对应的二进制值是0x0000903f float f1 = 0.0f; \tint i1 = 0x3f900000;//---------注意，i1是主机字节序------- \tCopyMemory(&f1, &i1, sizeof(i1));//----f1的值变为1.125---------- 请参考《C++浮点型变量的存储方式》 希望能够帮到您！", "referer": "user-0" }, { "cid": "5", "user": "user-4", "content": "你算的不对 1.0125 ，转为2进制是1.0000001100110011...... 指数是1，尾数是0000001100110011..... 符号位0，指数是0。 16进制就是3f81999a", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "我用的系统是centos7", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "现在可以转了，但是问题是数据不对， #include<stdio.h> 2 #include<stdlib.h> 3 union Ui{ 4 float a; 5 int b; 6 }ui; 7 8 int main(){ 9 union Ui f; 10 f.b=0x3d000009; 11 printf(\"%f\\n\",f.a); 12 return 0; 13 } ~ 0x3d000009对应二进制的话 0为符号位 指数为为0x7c 表示的值应该是0x7c-0x7f=-3 尾数位为0x09 二进制为1001 二进制的小数为为三位则小数位的10进制应该为0.125其整数位的十进制为1 结果应该为 1.0125 实际给的值却是 0.031250 二进制为 00001 为什么会这样呢？", "referer": "user-0" }, { "cid": "8", "user": "user-2", "content": "union U { float f; int d; } u; u.d=-0x3d800005; printf(\"%f\\n\",u.f);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 9 楼 自信男孩的回复:[quote=引用 6 楼 陳錄生 的回复:][quote=引用 4 楼 NorZ的回复:][quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote] ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？[/quote] 也没看到pkey指向buf的操作呢[/quote] FREEBSD CC", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "引用 6 楼 陳錄生 的回复:[quote=引用 4 楼 NorZ的回复:][quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote] ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？[/quote] 也没看到pkey指向buf的操作呢", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "pkey是野指针，没看到它指向可以正常读写的内存区域，也没有malloc呢。怎么可以使用呢？ 即使能够用，但不能保证一直能用～ 还有pkey即使指向了可以读写的内存，那么遇到'='没有加'\\0'，%s输出的时候会继续向后输出，直到遇到'\\0'", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "引用 6 楼 陳錄生 的回复:[quote=引用 4 楼 NorZ的回复:][quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote] ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？[/quote] 关键你并没有这样的赋值操作呀...你不如循环结束后给 pkey[pos] 赋值 '\\0' 再打印看看，或者循环结束后打印 pos 的值，才能确定是不是没有被 != '=' 卡住", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 4 楼 NorZ的回复:[quote=引用 3 楼 陳錄生 的回复:][quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote] ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？[/quote] buf 在fgets函数分配了内存，pkey 和buf指向同一字符串了？", "referer": "user-0" }, { "cid": "6", "user": "user-2", "content": "本身代码的逻辑上，没有什么问题，pkey多赋值了一个空格，影响不大，就是为啥能执行，我很好奇", "referer": "user-0" }, { "cid": "7", "user": "user-2", "content": "引用 3 楼 陳錄生 的回复:[quote=引用 1 楼 NorZ的回复:]你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。[/quote] ...不是这个问题，我不理解的是你的 buf 是个指针，没有分配内存，pkey 也是，为啥能跑起来，是什么编译器和运行环境啊？你执行的 cfg 这个二进制程序，是你代码编译出来的吗？", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "引用 1 楼 NorZ的回复:你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？ *( pkey+pos) = *( buf+pos); 一样结果。", "referer": "user-0" }, { "cid": "9", "user": "user-3", "content": "你这个程序居然能跑起来。。。内存越界了啊，一个指针不能存东西的，要么定义成char数组，要么用malloc动态分配", "referer": "user-0" }, { "cid": "10", "user": "user-2", "content": "你这代码我看着就很不理解，你的 buf 和pkey为什么没有分配空间也可以直接用啊？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "Thanks", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 6 楼 赵4老师的回复:不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) { if (条件1) break; //... if (条件2) continue; //... if (条件3) return; //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) { a=fgetc(f); //... b=fgetc(f);//可能此时已经feof了！ //... } 而这样写就没有问题： while (1) { a=fgetc(f); if (feof(f)) break; //... b=fgetc(f); if (feof(f)) break; //... } 类似的例子还可以举很多。 这代码看了头晕。Thanks all the same.", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) { if (条件1) break; //... if (条件2) continue; //... if (条件3) return; //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) { a=fgetc(f); //... b=fgetc(f);//可能此时已经feof了！ //... } 而这样写就没有问题： while (1) { a=fgetc(f); if (feof(f)) break; //... b=fgetc(f); if (feof(f)) break; //... } 类似的例子还可以举很多。", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "修改一下，这样看看行不行？ #include <stdio.h> int main(void) { \tFILE *fp; \tchar buf[BUFSIZ]; \t \tif((fp = fopen(__FILE__, \"r\")) == NULL) \t{ \t\tperror(\"fopen\"); \t\treturn 1; \t} \t \twhile(!feof(fp) && fgets(buf, BUFSIZ, fp)) \t{ \t\tprintf(\"%s\", buf); \t} \t \treturn 0; }", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "先判断返回值再打印，再while判断 feof", "referer": "user-0" }, { "cid": "6", "user": "user-4", "content": "判断一下fgets返回值，读到EOF时会返回NULL，然后break出循环就好了～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "逗号分隔还是要写每个case的，case范围扩展可以只写区间两端，case 'a'...'z' 代表26个case，还是非常有用的", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "GCC的case范围扩展，从Pascal学来的，GCC和clang/llvm都支持", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 4 楼 赵4老师 的回复:语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。说得对，算了，不纠结了", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "C/C++不支持switch case的这种写法。", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "语法糖越甜，编译调试查错越苦！ 把有限的生命浪费在品尝/品鉴无穷多种的语法糖中，我认为不值当。", "referer": "user-0" }, { "cid": "6", "user": "user-4", "content": "哎呀，我还没用过 'a'...'z' 这种写法 真的可以吗", "referer": "user-0" }, { "cid": "7", "user": "user-5", "content": "逗号分隔是可以的，不能用..., vs2019警告但还是可以编译的", "referer": "user-0" }, { "cid": "8", "user": "user-6", "content": "你选的语言不是c/c++吧？", "referer": "user-0" }, { "cid": "9", "user": "user-7", "content": "直接用if...else 判断ASCII码范围", "referer": "user-0" }, { "cid": "10", "user": "user-8", "content": "写全了吗，写全了的话就是少了个结尾的花括号", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "看到缩进格式全无的代码，顿时毛骨悚然。。。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:标点符号没有进入这个if((str[i]>='a'&&str[i]<='z') || (str[i]>='A'&&str[i]<='Z') || (str[i]>='0'&&str[i]<='9')||(str[i]==32))，所以标点符号没有被做任何处理。 应该怎么修改呢", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "标点符号没有进入这个if((str[i]>='a'&&str[i]<='z') || (str[i]>='A'&&str[i]<='Z') || (str[i]>='0'&&str[i]<='9')||(str[i]==32))，所以标点符号没有被做任何处理。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf(\"%s %d\", &str[10], &a); 改成 scanf(\"%s %d\", str, &a); //str数组名就是字符串首地址， &str[10]是下标为10的元素的地址，数组越界（数组下标只到9） strcmp(str[10], \"triange\") 改成 strcmp(str, \"triange\"); //str[10]是一个元素（只有1个字符，不是字符串，字符串用数组名就可以了）", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:scanf中对于str有问题 scanf(\"%s%d\", str, &a); strcmp的第一个参数应该是str而不是str[10] 楼主需要复习一下数组，数组名，数组首地址等等，已经函数调用的参数的类型 现在通过啦，太感谢了*⸜( •ᴗ• )⸝*❤️", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "scanf中对于str有问题 scanf(\"%s%d\", str, &a); strcmp的第一个参数应该是str而不是str[10] 楼主需要复习一下数组，数组名，数组首地址等等，已经函数调用的参数的类型", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include<stdio.h> #include <math.h> #define N 10 #define M 10 int is_prime(int n) { int i, tm; if (n < 2) return 0; tm = sqrt(n); for (i = 2; i <= tm; i++) if (n % i == 0) return 0; return 1; } void sort(int *arr, int size) { int i, j; int tmp; for (i = 0; i < size; i++) for (j = 0; j < size - i -1; j++) if (arr[j] > arr[j+1]) { tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; } } void show(int *arr, int size) { int i; for (i = 0; i < size; i++) printf(\"%d \", arr[i]); putchar(10); } int main () { int cnt, len, tmp; int array[N]; int i, j, k; scanf(\"%d\", &cnt); for (i = 0; i < cnt; i++) { scanf(\"%d\", &len); if (len > N) len = N; k = 0; for (j = 0; j < len; j++) { scanf(\"%d\", &tmp); if (is_prime(tmp)) array[k++] = tmp; } sort(array, k); show(array, k); } #if 0 int a[M][N],b[M][N],s[M],n,i,j; int c=0; scanf(\"%d\",&n); for(i=0;i<n;i++) {scanf(\"%d\",&a[i][0]); for(j=1;j<=a[i][0];j++) {scanf(\"%d\",&a[i][j]); if (prime(a[i][j])) {b[i][c]=a[i][j]; c++; } } s[i]=c; c=0; } for(i=0;i<n;i++) px(b[i],s[i]); for(i=0;i<n;i++) {for(j=0;j<s[i];j++) printf(\"%-2d\",b[i][j]); printf(\"\\n\");} #endif return 0; } #if 0 int prime( int p ) { int i,f; if(p<=1) f=0; else {f=1; for(i=2;i<p;i++){ if(p%i==0) f=0;} } return f; } void px(int a[],int n) { int i,j,k,t; for(i=0;i<n-1;i++) for(j=0;j<n-i-1;j++) if(a[j]>a[j+1]) { t=a[j]; a[j]=a[j+1]; a[j+1]=t; } } #endif 供参考～ 题目要求是输入的整数是<= 10，没说是输入的n（楼主定义的）也是10，如果n是大于10的，会出现数组越界，出现段错误；", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 1 楼 自信男孩的回复:注意单词的大小写，status确实没有定义，楼主应该用Status？ 从代码上看，完全可以typedef int Status; 试试，主要看一下OK是什么？ 解决了，三克油", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "解决了，三克油", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "注意单词的大小写，status确实没有定义，楼主应该用Status？ 从代码上看，完全可以typedef int Status; 试试，主要看一下OK是什么？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "我直接打印一下a，你看这样觉得合理嘛，0*0*0", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "引用 2 楼 limeilu110的回复:如果！整段程序运行下来没有跟预期要输出的值相匹配的结果！！！那这段程序什么都不做也可以理解啊！ 建议跟踪一下个个环节的变量值变化！！！看程序有没有按设计的运行！！ 我刚运行了下，也追踪了其中两个变量～～i,a的变化！运行过程中变量在按程序的设计走！但是没有匹配的结果！所以程序感觉上什么都没有做！！！！没有匹配的结果！！", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "如果！整段程序运行下来没有跟预期要输出的值相匹配的结果！！！那这段程序什么都不做也可以理解啊！ 建议跟踪一下个个环节的变量值变化！！！看程序有没有按设计的运行！！", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "那是因为printf所在if判断条件不满足，建议楼主把i++到if (i == xxx) {}之后，即while循环内的最后位置。 改一下位置再试试。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "float proc(float f1, float f2, char m) {\t \tswitch (m) \t{ \tcase '+': \t\treturn f1 + f2; \t\tbreak; \tcase '-': \t\treturn f1 - f2; \t\tbreak; \tcase '*': \t\treturn f1 * f2; \t\tbreak; \tcase '/': \t\treturn f1 / f2; \t\tbreak; \tdefault: \t\tabort(); \t\tbreak; \t} } float fun2(const char ch[100]) { \tfloat f[100];\t\t// 参数 \tint ifCnt = 0;\t\t// 参数个数 \tchar m[100] = { 0 }; // 方法 \tint imCnt = 0; \tchar ch2[100]; \tif (!ch || !ch[0]) \t\tabort();\t \tstrncpy_s(ch2, 100, ch, 100); \tint iBegin = 0, iEnd = 0; \tint i = 0; \tfor (; (i < 100) && (ch2[i] != '\\0'); ++i) \t{ \t\tswitch (ch2[i]) \t\t{ \t\tcase '*': \t\tcase '/': \t\tcase '+': \t\tcase '-': \t\t\tif (i == 0) \t\t\t\tabort(); \t\t\tiEnd = i;\t \t\t\tm[imCnt++] = ch2[iEnd]; \t\t\tch2[iEnd] = '\\0'; \t\t\tf[ifCnt++] = atof(&ch2[iBegin]); \t\t\tiBegin = iEnd + 1; \t\t\tbreak; \t\tcase '0': \t\tcase '1': \t\tcase '2': \t\tcase '3': \t\tcase '4': \t\tcase '5': \t\tcase '6': \t\tcase '7': \t\tcase '8': \t\tcase '9': \t\tcase '.': \t\t\tbreak; \t\tdefault: \t\t\tabort(); \t\t} \t} \tf[ifCnt++] = atof(&ch2[iBegin]); \t{ \t\tfloat fResult = f[0]; \t\tint ifCur = 1; \t\tfor (i = 0; i < imCnt; ++ifCur) \t\t{ \t\t\tfResult = proc(fResult, f[ifCur], m[i++]); \t\t} \t\treturn fResult; \t} }", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "float proc(float f1, float f2, char m) {\t \tswitch (m) \t{ \tcase '+': \t\treturn f1 + f2; \t\tbreak; \tcase '-': \t\treturn f1 - f2; \t\tbreak; \tcase '*': \t\treturn f1 * f2; \t\tbreak; \tcase '/': \t\treturn f1 / f2; \t\tbreak; \tdefault: \t\tabort(); \t\tbreak; \t} } float fun2(const char ch[100]) { \tfloat f[100];\t\t// 参数 \tint ifCnt = 0;\t\t// 参数个数 \tchar m[100] = { 0 }; // 方法 \tint imCnt = 0; \tchar ch2[100]; \tif (!ch || !ch[0]) \t\tabort();\t \tstrncpy_s(ch2, 100, ch, 100); \tint iBegin = 0, iEnd = 0; \tint i = 0; \tfor (; (i < 100) && (ch2[i] != '\\0'); ++i) \t{ \t\tswitch (ch2[i]) \t\t{ \t\tcase '*': \t\tcase '/': \t\tcase '+': \t\tcase '-': \t\t\tif (i == 0) \t\t\t\tabort(); \t\t\tiEnd = i;\t \t\t\tm[imCnt++] = ch2[iEnd]; \t\t\tch2[iEnd] = '\\0'; \t\t\tf[ifCnt++] = atof(&ch2[iBegin]); \t\t\tiBegin = iEnd + 1; \t\t\tbreak; \t\tcase '0': \t\tcase '1': \t\tcase '2': \t\tcase '3': \t\tcase '4': \t\tcase '5': \t\tcase '6': \t\tcase '7': \t\tcase '8': \t\tcase '9': \t\tcase '.': \t\t\tbreak; \t\tdefault: \t\t\tabort(); \t\t} \t} \tf[ifCnt++] = atof(&ch2[iBegin]); \t{ \t\tfloat fResult = f[0]; \t\tint ifCur = 1; \t\tfor (i = 0; i < imCnt; ++ifCur) \t\t{ \t\t\tfResult = proc(fResult, f[ifCur], m[i++]); \t\t} \t\treturn fResult; \t} }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "感谢，我另写了一个循环，还真是这样", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "在循环结构里虽然看着是循环定义，其实编译器只会定义一次，因为在do ... while是一个代码块，这部分的last只会定义一次。后面的直接使用上次定义的。 用NULL的好处是，作为链表结束的标记，因为链表是next指向下一个，什么时候到达末尾了?NULL是一种方法。 楼主的代码少一个大括号，匹配if (number != -1)的 #include<stdio.h> #include<stdlib.h> typedef struct _node{ int value; struct _node *next; }Node; int main(int argc,char const *argv[]) { Node *head=NULL; int number; do { scanf(\"%d\",&number); if(number!=-1){ Node *p=(Node *)malloc(sizeof(Node)); p->value=number; p->next=NULL; Node *last=head; if(last){ while(last->next){ last=last->next } last->next=p; } else { head=p; } } }while(number!=-1); return 0; } 供参考～", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "那为什么 int *p=a； int *p=b； 不行呢", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "在循环里不断给新结点分配内存，指针p是移动的，不存在重复定义。给指针赋值NULL是初始化，不然可能变成野指针，不知道指向哪儿了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "好的，多谢提示。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "建议楼主找一下你的代码工程，应该有地方用typedef了V_U32和V_UCHAR 其实可以这么理解：V_U32就是unsigned int，V_UCHAR是unsigned char。 最好找一下定义的地方。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "请帮忙解释一下，V_U32 blockse; V_UCHAR *ramaddr 这两句的V_U32和V_UCHAR是什么东西，为什么这么用？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "现在的电脑配置都无比强悍，建议用最大众化的IDE。比如 VISUAL STUDIO 2019，号称宇宙第一IDE，编程和调试都很方便。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "建议dev-c++：https://sourceforge.net/projects/embarcadero-devcpp/ 或者：https://www.filehorse.com/download-dev-c/", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "没使用过这个工具 建议不如换一个啊 VS只用序列号就可以激活 如果想要占用空间少的 可以CodeBlocks 或CodeLite 这两款我试过 确定没问题的", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "感谢大佬。。。。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "改成 scanf(“%s”, s); for(i=0; i<80&&s[i]!=‘\\0’; i++) {//要用循环 if((s[i]>=‘a’&&s[i]<=‘z’) || (s[i]>=‘A’&&s[i]<=‘Z’) || (s[i]>=‘0’&&s[i]<=‘9’)) printf(“%c”, s[i]); }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你要想想，进入for(; *last; last=&(*last)->next); 退出循环的条件是什么？是*last不成立，也就是*last==null，那么*last什么时候会==null？那不就是*last=Node1.next才是null吗（因为Node1不是null）？所以(*last->next)=malloc是错的，因为*last已经是null了，*last->next本身就是错的（相当于null->next），所以，*last=malloc才是正确的。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "不明白为啥要用二级指针，只有一个主函数完全没有必要这样。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "第一次进入for( ; *last; last=&(*last)->next );由于last指向head，head指向NULL，所以不执行for循环，后面的语句让head指向了第一个节点Node1；第二次进入for( ; *last; last=&(*last)->next )循环时*last也就是head是指向Node1的，所以会让last指向最新一节Node1。下面把Node2联接到Node1上，不应该是 (*last-next） = (Node *)malloc( sizeof(Node) )吗?", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 2 楼 user-2 的回复:字符串要有结束符'\\0'，否则就会一直输入内存信息直到遇到字符串结束符 所以 puts(flag); outflag[strlen(flag)] = '\\0'; //这里追加设定字符串结束符 puts(outflag); 另外，flag[i] ^ 1 有可能导致运算结果是非显示字符，这样outflag显示的内容也不一定能看得到 楼主申请的空间少一个'\\0'的位置，所以，outflag[strlen(flag)] = '\\0';这样操作会导致内存越界操作～", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "字符串要有结束符'\\0'，否则就会一直输入内存信息直到遇到字符串结束符 所以 puts(flag); outflag[strlen(flag)] = '\\0'; //这里追加设定字符串结束符 puts(outflag); 另外，flag[i] ^ 1 有可能导致运算结果是非显示字符，这样outflag显示的内容也不一定能看得到", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <string.h> int main() { /*const char* flag; char* outflag; flag = \"ZmxhZ3tzaG91a2FrdX0=\"; outflag = (char*)malloc(BASE64_DECODE_OUT_SIZE(strlen(flag))); base64_decode(flag, strlen(flag), outflag); puts(outflag); free(outflag); return 0;*/ int i; char* flag; flag = \"ZmxhZ3t9CgoK\"; char* outflag = (char*)malloc(strlen(flag) + 1); for (i = 0; i < strlen(flag); i++) { outflag[i] = flag[i] ^ 1; } outflag[i] = 0; //add '\\0' puts(flag); puts(outflag); free(outflag); return 0; } 供参考～ 注意'\\0'，出现乱码，对于字符串而言，大部分都是因为'\\0'导致（没在对应的字符串结尾加上'\\0'导致）", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf_s替换scanf，注意这两者的区别，详细的请查阅scanf_s的使用", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "也可以输入# pragma warning (disable : 4996)消除此类警告", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "Embarcadero Dev-Cpp比较友好，使用更方便。 最新版：Embarcadero_Dev-Cpp_6.1_TDM-GCC_9.2_Setup.exe", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "请看提示 大概的意思是“scanf函数已经不安全了，请使用scanf_s()函数代替scanf()函数” 如果您觉得使用scanf_s()函数不方便，还是习惯使用scanf()函数，请参考 《VS2015中使用scanf()不报错的设置方法》 希望能够帮到您！", "referer": "user-0" }, { "cid": "5", "user": "user-5", "content": "提示你scanf函数不安全，改为用 scanf_s函数", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 8 楼 forlorn pedestrian的回复:引用[quote]\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗 我觉得，你把第三项和第1，2项的关系表达式写一下，就明白了", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "公式，是你算第n项，仅仅算n项，带进去n才有效。 这个算法是，先算第0和第1项，然后根据0，1项，算出第2项。。。然后根据第1，2项，算出第3项。。。依次类推 算出第n项。。。 那么，算第2项时，公式里n=2，是不是就没毛病了", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "引用 8 楼 forlorn pedestrian的回复:引用[quote]\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗 算第n项的时候，代n进去没错。 但你这个算法是，先算第0项和第一项，然后算第二项，依次类推，算出第n项。。 算第三项的表达式时，公式里n=3 算第四项时，公式里n=4", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "引用 11 楼 自信男孩的回复:[quote=引用 2 楼 weixin_46056697 的回复:]我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了 你改一下试试？问题没看到重点，建议自己试试～[/quote] 确实，我的错，没注意", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "引用 2 楼 weixin_46056697 的回复:我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了 你改一下试试？问题没看到重点，建议自己试试～", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "引用 9 楼 自信男孩 的回复:#include<stdio.h> int main() { //float x, /*n,*/ c, a, b; double x, /*n,*/ c, a, b; int n, i; //scanf_s(\"%f%d\", &x, &n); scanf(\"%lf%d\", &x, &n); if (n == 0) { c = 1; printf(\"%.2lf\", c); return 0; } if (n == 1) { c = x; printf(\"%.2lf\", c); return 0; } a = 1.0; b = x; for (i = 2; i <= n; i++) { //c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a; c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a; a = b; b = c; } printf(\"%.2lf\", c); return 0; } 供参考～ 把scanf改成scanf_s吧", "referer": "user-0" }, { "cid": "7", "user": "user-3", "content": "#include<stdio.h> int main() { //float x, /*n,*/ c, a, b; double x, /*n,*/ c, a, b; int n, i; //scanf_s(\"%f%d\", &x, &n); scanf(\"%lf%d\", &x, &n); if (n == 0) { c = 1; printf(\"%.2lf\", c); return 0; } if (n == 1) { c = x; printf(\"%.2lf\", c); return 0; } a = 1.0; b = x; for (i = 2; i <= n; i++) { //c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a; c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a; a = b; b = c; } printf(\"%.2lf\", c); return 0; } 供参考～", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "引用[quote]\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗", "referer": "user-0" }, { "cid": "9", "user": "user-1", "content": "1.a,b赋初值不应该在for循环里，否则a,b一直被赋初值，你的递归就无效了； 2.不应该带n去算，因为计算P2时，n=2,计算P3时，n=3....所以带进去i比较合适 3.如果带进去i,那么浮点数运算i应该也为浮点数，否则运算不出正确结果", "referer": "user-0" }, { "cid": "10", "user": "user-1", "content": "#include<stdio.h> int main() { \tfloat i; \tfloat x, c, a,b; \tint n; \tscanf_s(\"%f%d\", &x, &n); \ta = 1; \tb = x; \tif (n == 0) \t\tc = 1; \telse if (n == 1) \t\tc = x; \telse \t\tfor (i = 2; i <= n; i++) { \t\t\tc = (2 * i - 1) / i * x * b - (i - 1) / i * a; \t\t\ta = b; \t\t\tb = c; \t\t} \tprintf(\"%.2f\", c); \treturn 0; }", "referer": "user-0" }, { "cid": "11", "user": "user-4", "content": "用嵌套吧 float polya(float n, float x) { \tfloat sum; \tif (n == 0) \t\tsum = 1; \telse if (n == 1) \t\tsum = x; \telse if (n>1) \t\tsum = ((2 * n - 1)*x*polya(n - 1, x) - (n - 1)*polya(n - 2, x)) / n; \treturn sum; } int main() { \tfloat x, n, c, a, b; \tint i; \tscanf_s(\"%f%f\", &x, &n); \tc = polya(n, x); \tprintf(\"%.2f\", c); \treturn 0; }", "referer": "user-0" }, { "cid": "12", "user": "user-2", "content": "我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了", "referer": "user-0" }, { "cid": "13", "user": "user-1", "content": "for循环错了，虽然你计算c后，给a，b赋值，但下一次循环后，a,b还是1和x", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 7 楼 自信男孩的回复:c1为分配空间，是一个野指针，直接scanf可能会出现段错误。 c2是一个char普通变量，用%s会导致越界，因为%s会考虑加上'\\0'，输入了M/F之后再把'\\0'放哪里。 啊啊啊，确实，仔细一想确实都是错误，感谢大神指点（我还是太弱了", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "c1为分配空间，是一个野指针，直接scanf可能会出现段错误。 c2是一个char普通变量，用%s会导致越界，因为%s会考虑加上'\\0'，输入了M/F之后再把'\\0'放哪里。", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "引用 3 楼 user-3 的回复:[quote=引用 1 楼 一颗白面馒头的回复:]scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）[/quote] 有这个感觉，这里面指针用的好乱", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "引用 3 楼 user-3的回复:[quote=引用 1 楼 一颗白面馒头的回复:]scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）[/quote] 其实这个题老师是让用C++编的，但是标准C里面没有对字符串直接声明的数据类型，之前对name的定义是数组，但是因为是先确定数组的大小，我就改成了指针类型", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 1 楼 一颗白面馒头的回复:scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 上完课回去试试", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "引用 1 楼 一颗白面馒头的回复:scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）", "referer": "user-0" }, { "cid": "7", "user": "user-3", "content": "建议重新看看指针的知识（感觉你这些指针定义 赋值啥的很乱很乱）", "referer": "user-0" }, { "cid": "8", "user": "user-2", "content": "scanf(\"%s\",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf(\"%s\", c1);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "源代码如下： #include <stdio.h> #include <ctype.h> #include <string.h> int is_upper(char *p) { \twhile(*p) \t{ \t\tif(islower(*p)) return 0; \t\tp++; \t} \treturn 1; } int main(void) { \tchar str[] = \"FORBES The CEO of Boloco's Social Media Strategy\"; \tchar *p; \tint count = 0; \t \tp = strtok(str, \" \"); \t \twhile(p != NULL) \t{ \t\tif(is_upper(p)) \t\t{ \t\t\tcount++; \t\t\tprintf(\"%d:\\t%s\\n\", count, p); \t\t} \t\tp = strtok(NULL, \" \"); \t} \t \treturn 0;\t } 运行结果如下： 引用1: FORBES 2: CEO", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "引用 2 楼 火柴先生 的回复:引用 1 楼 自信男孩 的回复:先确定单词，然后遍历单词，判断是否有小写字符。我认为最后判断应该是：是否全为大写字符 我的描述不是这样吗？先确定单词，就是在每个单词后面的第一个空格用'\\0'填充，然后再遍历这个单词是不是全大写，这样应该没问题吧。 对于加不加'\\0'都没关系，因为知道单词的开头，知道单词的结尾，做差就知道单词的长度了～", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 5 楼 sdhexu 的回复:好人做到底，给你完善一下代码吧： // 状态机 三种状态 public enum MachineState { \tSTART, \tUPPER_WORDS, \tNOTUPPER_WORDS } // 判断一个字符是否为空白 private bool IsSpace( char c ) { \treturn ( c == ' ' || c == '\\t' || c == '\\r' || c == '\\n' ); } // 判断一个字符是否为单词的分隔符，可以视情况将其他标点符号加入 private bool IsSeparator( char c ) { \treturn IsSpace(c) || ( c == ',' || c == '.' ); } // 判断所有字母为大写的单词个数 public int GetUpperWordsCount( string p ) { \tMachineState state = MachineState.START; \tint count = 0; \tforeach( char c in p ) \t{ \t\tswitch( state ) \t\t{ \t\t\tcase MachineState.START: \t\t\t\tif( c >= 'A' && c <='Z' ) // 如果第一个字符为大写，状态改变 \t\t\t\t\tstate = MachineState.UPPER_WORDS; \t\t\t\telse if( IsSpace( c )) // 如果是空白，保持开始状态 \t\t\t\t\tbreak; \t\t\t\telse // 其他情况，小写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS; \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.UPPER_WORDS: \t\t\t\tif( IsSeparator( c )) // 如果遇到单词分隔，计数并改状态 \t\t\t\t{ \t\t\t\t\t++count; \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\telse if( c>='A' && c <= 'Z' ) // 如果还是大写，保持状态 \t\t\t\t\tbreak; \t\t\t\telse // 其他情况（单词有不是大写的字符），进入非大写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS; \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.NOTUPPER_WORDS: \t\t\t if( IsSeparator( c )) // 直到遇到分隔符，否则都是非大写状态 \t\t\t\t{ \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\tbreak; } \t} } 今天看了下代码，发现您忽视了是要输出全为大写字母的单词的情况，如果考虑输出，还能否在一次遍历的情况下完成，这看起来很难。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "引用 6 楼 sdhexu的回复:词法分析器，有穷自动状态机，是编译原理中的知识，它的好处是，连续多个空白符，很容易处理，不会影响计算结果。只遍历一遍字符，效率很高。。理解困难的话，画一个状态图，就容易理解了。 效率的确高，这是我C语言考试最后一道编程题里面的一部分内容，明天再好好看看您的代码，十分感谢！之前也上过编译原理的课，可以看出自己的确学艺不精，要好好努力！", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "词法分析器，有穷自动状态机，是编译原理中的知识，它的好处是，连续多个空白符，很容易处理，不会影响计算结果。只遍历一遍字符，效率很高。。理解困难的话，画一个状态图，就容易理解了。", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "好人做到底，给你完善一下代码吧： // 状态机 三种状态 public enum MachineState { \tSTART, \tUPPER_WORDS, \tNOTUPPER_WORDS } // 判断一个字符是否为空白 private bool IsSpace( char c ) { \treturn ( c == ' ' || c == '\\t' || c == '\\r' || c == '\\n' ); } // 判断一个字符是否为单词的分隔符，可以视情况将其他标点符号加入 private bool IsSeparator( char c ) { \treturn IsSpace(c) || ( c == ',' || c == '.' ); } // 判断所有字母为大写的单词个数 public int GetUpperWordsCount( string p ) { \tMachineState state = MachineState.START; \tint count = 0; \tforeach( char c in p ) \t{ \t\tswitch( state ) \t\t{ \t\t\tcase MachineState.START: \t\t\t\tif( c >= 'A' && c <='Z' ) // 如果第一个字符为大写，状态改变 \t\t\t\t\tstate = MachineState.UPPER_WORDS; \t\t\t\telse if( IsSpace( c )) // 如果是空白，保持开始状态 \t\t\t\t\tbreak; \t\t\t\telse // 其他情况，小写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS; \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.UPPER_WORDS: \t\t\t\tif( IsSeparator( c )) // 如果遇到单词分隔，计数并改状态 \t\t\t\t{ \t\t\t\t\t++count; \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\telse if( c>='A' && c <= 'Z' ) // 如果还是大写，保持状态 \t\t\t\t\tbreak; \t\t\t\telse // 其他情况（单词有不是大写的字符），进入非大写状态 \t\t\t\t\tstate = MachineState.NOTUPPER_WORDS; \t\t\t\tbreak; \t\t\t\t \t\t\tcase MachineState.NOTUPPER_WORDS: \t\t\t if( IsSeparator( c )) // 直到遇到分隔符，否则都是非大写状态 \t\t\t\t{ \t\t\t\t\tstate = MachineState.START; \t\t\t\t} \t\t\t\tbreak; } \t} }", "referer": "user-0" }, { "cid": "7", "user": "user-3", "content": "很简单的词法分析器，有穷自动状态机。。效率是最高的，没有之一。 public enum MachineState { START, UPPER_WORDS, } public int GetUpperWordsCount( string p ) { MachineState state = MachineState.START; int count = 0; foreach( char c in p ) { switch( state ) { case MatchineState.START: if( c >= 'A' && c <='Z' ) state = MachineState.UPPER_WORDS; break; case MatchineState.UPPER_WORDS: if( c == ' ' || c == '\\t' || c == '\\r' || c == '\\n' || c == ',' || c == '.' ) { ++count; state = MatchineState.START; } else if( c>='A' && c <= 'Z' ) break; else state = MatchineState.START; break; } } }", "referer": "user-0" }, { "cid": "8", "user": "user-4", "content": "我也认为应该先确定单词，在检查单词是否全部为大写。", "referer": "user-0" }, { "cid": "9", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:先确定单词，然后遍历单词，判断是否有小写字符。我认为最后判断应该是：是否全为大写字符", "referer": "user-0" }, { "cid": "10", "user": "user-2", "content": "先确定单词，然后遍历单词，判断是否有小写字符。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 2 楼 weaker1209 的回复:可以给我用动态数组检查鞍点的完整代码让我跑一下吗，不是很理解 你自己先研究一下判断鞍点的函数，根据形参，要什么参数传入什么参数就可以了", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "可以给我用动态数组检查鞍点的完整代码让我跑一下吗，不是很理解", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "int n, *max, *min, **a; cin>>n; if (n < 1 || n > 6) { cout<<\"Input error!\"<<endl; return -1; } max = new int [n]; min = new int [n]; a = new int *[n]; for (int i = 0; i < n; i++) a[i] = new int [n]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) cin>>a[i][j]; 用动态数组 检查鞍点的方法： void check_saddle_point(int (*point)[2], int (*array)[COL], int row, int col) { int i, j, k, cnt = 0; int row_idx, col_idx; int max_row, min_col; for (i = 0; i < row; i++) { max_row = array[i][0]; col_idx = 0; /* find max value in row */ for (j = 1; j < COL; j++) if (max_row < array[i][j]) { max_row = array[i][j]; col_idx = j; } /* Find min value in col */ min_col = array[i][col_idx]; row_idx = i; for (k = 0; k < row; k++) if (min_col > array[k][col_idx]) { min_col = array[k][col_idx]; row_idx = k; } /* Check the condition*/ if (row_idx == i && min_col == max_row) { point[cnt][0] = row_idx; point[cnt][1] = col_idx; cnt++; } } }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0. 因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "我自己回复一下我自己吧，我已经debug出问题所在了 主要是我的txt文本是windows写的，传到Linux系统，然后换行符是\\r\\n，造成去掉最后一个\\n后仍有一个\\r去占据字符的长度，所以造成bug。 抱歉，浪费巨佬的时间了。", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "问题出在你没放代码的地方 readvariable() 里面，因为 ./data/0.txt 后面是 \\r\\n ,在win下正常去掉 \\r\\n 正常，在Linux下只去了 \\n ,导致你的字符串为 ./data/0.txt\\r", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "引用 2 楼 calmuse 的回复:[quote=引用 1 楼 自信男孩 的回复:]strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0. 因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。 非常感谢，是我记错了strcmp的函数功能，的确两个不相等，大佬，我能再多问一下吗？ 我用strlen看了一下，\"./data/0.txt\"的长度是12，而我从文本中读取出来的data_name是13，因为data_name最后我加了一个\\0 我不明白的是，我看书上都说字符串最后会用\\0作为结尾，为什么我在Linux上跑，\"./data/0.txt\"的长度就是12，不是13[/quote] strlen函数是不计算'\\0'的，如果不同系统下不一样的，建议楼主看一下行结束符是不是不一样。把字符串打印出来看看有什么区别～", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 1 楼 自信男孩 的回复:strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0. 因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。 非常感谢，是我记错了strcmp的函数功能，的确两个不相等，大佬，我能再多问一下吗？ 我用strlen看了一下，\"./data/0.txt\"的长度是12，而我从文本中读取出来的data_name是13，因为data_name最后我加了一个\\0 我不明白的是，我看书上都说字符串最后会用\\0作为结尾，为什么我在Linux上跑，\"./data/0.txt\"的长度就是12，不是13", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "total是整数不能用%.2f输出的，但是total/5.0是按照浮点数除法计算的，因此得到的是浮点数。所以用%.2f输出是没问题的～", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "printf()函数当输出的是浮点数时，[.precision]中的precision表示输出的小数的位数。.2f表示输出的浮点数包含2位小数。对于printf()函数的详细使用方法，请参考《C++中printf()函数的用法10-9》 希望能够帮到您！", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "用.2f是因为total/5.0，注意是5.0", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "输出的是total/5.0的值（平均数），5.0是浮点数，结果也会转成浮点数，保留2位小数", "referer": "user-0" }, { "cid": "5", "user": "user-5", "content": "total是整数，total/5.0，就是双精度浮点数，%.2f意思保留两位小数输出", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "~~~~~仅供参考", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "# include<stdio.h> int main(void) { \tint i,j,con=0; \tfor(i=1;i<=10;i++) \t{ \t\tint sum=1; \t\tfor(j=1;j<=i;j++) \t\t{ \t\t\tsum=sum*j; \t\t} \t\tprintf(\"%d\\n\",sum); \t\tcon=con+sum; \t} \tprintf(\"%d\\n\",con); \treturn 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "#include <stdio.h> int main(int argc, char* argv[]) { int a,b,c,d=0; for(a=1; a<=10; a++) { c=1; for(b=1; b<=a; b++) c = c * b;//用c来计算阶乘 d+=c; //用d来计算和 } printf(\"%d\\n\",d); system(\"pause\"); return 0; }", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "#include<stdio.h> int main() { int a,b, k; unsigned long c = 0; for(a=1;a<=10;a++) { k = a; for(b=1;k>0;k--) { b*=k; } c=c+b; } printf(\"%lu\\n\",c); return 0; } 供参考～ 二层循环里对a进行的修改～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "哦哦，懂了，谢啦", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "引用 2 楼 Am0_0mA 的回复:感谢！把x初始化和EOF改成'\\n'后能输出结果了。 不过我不是很懂为啥缺少EOF输入。C程序设计语言这本书里面讲EOF是getchar函数在没有输入时返回的一个特殊值。当读取到文本流最后，已经没有下一个字符时，getchar函数不就应该返回EOF了嘛。为什么还要手动输入EOF作为结束符呢。 对EOF是文件末尾的标识符，所以你需要输入EOF，'\\n'是行结束符，不是文件末尾～", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "感谢！把x初始化和EOF改成'\\n'后能输出结果了。 不过我不是很懂为啥缺少EOF输入。C程序设计语言这本书里面讲EOF是getchar函数在没有输入时返回的一个特殊值。当读取到文本流最后，已经没有下一个字符时，getchar函数不就应该返回EOF了嘛。为什么还要手动输入EOF作为结束符呢。", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "x没有初始化，另外，EOF输入linux 用ctrl+d，Windows下用ctrl+z试试 楼主是缺少输入EOF，或者楼主缺少'\\n'。 建议楼主把EOF改成'\\n'试试～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "会修改，不是给予提示。因为const修饰的是xyz数组，不能通过xyz数组去修改，但是其他的变量（指针）是可以修改的，不受限制。const修饰的并不是只读的内存。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "给你段代码，跑一下就知道了 int main() { const int a[] = {1, 2}; int *p = (int*)a; //a[0]=2; *p = 2; printf(\"%d\\n\", a[0]); return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "修改啊，const 只是编译器级的不可修改，实际内存读写权限是系统相关的", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 1 楼 user-1的回复:这个比较难，有时间我尝试下 我印象中：猜数字游戏，中的数字，是不重复的。 这是作业马上要交了，我死定了", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "这个比较难，有时间我尝试下 我印象中：猜数字游戏，中的数字，是不重复的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "一个字节8位，可以表示0到0xff,具体什么意思，要看他的程序要求啊", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据 还有就是编译时一直显示到达不了break，也没有死循环", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "引用 1 楼 真相重于对错 的回复:这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据 这个数组为什么是5个字节？0xFF是什么意思？初始化的意思吗？", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 7 楼 自信男孩 的回复:[quote=引用 6 楼 47897566 的回复:][quote=引用 5 楼 自信男孩 的回复:]CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？[/quote] 判断数据用的吧，比如协议数据按照什么格式，对端收到之后可以根据初始[0]值是否符合协议要求～[/quote] 明白了，感谢", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "你得看 CommandDatatable 数据哪里读出来的啊，这代码能看出啥？？", "referer": "user-0" }, { "cid": "7", "user": "user-1", "content": "引用 6 楼 47897566 的回复:[quote=引用 5 楼 自信男孩 的回复:]CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？[/quote] 判断数据用的吧，比如协议数据按照什么格式，对端收到之后可以根据初始[0]值是否符合协议要求～", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "引用 5 楼 自信男孩 的回复:CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？", "referer": "user-0" }, { "cid": "9", "user": "user-2", "content": "这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "第二行，int main（）后面多了“；”号。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "main()后面不要加分号；", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "main(); //这里多了个分号，把它去掉", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 楼主 forlorn pedestrian的回复:题目内容：输入年、月，输出这个月一共有多少天 输入：两个整数 输出： 对应月份天数 样例1：输入 2018 2 输出 28 #include<stdio.h> int main() { \tint a, b, c, d; \tscanf(\"%d%d\", &a, &b); \tif ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0)){ \t\tif (b == 2) \t\t\tc = 29; \t\tif (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) \t\t\tc = 31; \t\tif (b = 4 || b == 6 || b == 9 || b == 11) \t\t\tc = 30; \t} \telse if (b == 2); \t\tc = 30;\t \t\t if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) \t\t\tc = 31; \t\telse if (b = 4 || b == 6 || b == 9 || b == 11) \t\t\tc = 30; \t\telse\tprintf(\"%d\", c); \t\treturn 0; } a % 100 == 0改成a％100！＝0； if (b = 4 || b == 6 || b == 9 || b == 11)中b＝＝4； else if (b == 2); c = 30;\t 这里c＝28； else\tprintf(\"%d\", c); 这里的else去掉", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "//样例1：输入 2018 2 输出 28 #include<stdio.h> int main() { #ifdef IF_ELSE int a, b, c, d; scanf(\"%d%d\", &a, &b); //if ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0)){ if (((a % 4 == 0) && (a % 100 != 0)) || (a % 400 == 0)){ if (b == 2) c = 29; if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) c = 31; if (b = 4 || b == 6 || b == 9 || b == 11) c = 30; } //else if (b == 2); else if (b == 2) c = 30; if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) c = 31; else if (b = 4 || b == 6 || b == 9 || b == 11) c = 30; else printf(\"%d\", c); #else int year, month, days = 0; int leap = 0; scanf(\"%d%d\", &year, &month); if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) leap = 1; switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: days = 31; break; case 2: days = 28 + leap; break; case 4: case 6: case 9: case 11: days = 30; break; default: printf(\"Not support!\\n\"); break; } printf(\"%d\", days); #endif return 0; } 供参考` 有两个问题：闰年判断和if后面多一个分号； 另外，这个问题用switch case比较好一些，供参考～", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "引用if ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0))闰年判断这句有误，a%100 !=0。这句引用if (b = 4 || b == 6 || b == 9 || b == 11)有误，b==4。整体逻辑判断错了，修改如下：#include <stdio.h> int main(int argc, char* argv[]) { int a=0, b=0, c=0; printf(\"请输入年月：\"); scanf(\"%d %d\", &a, &b); if (b == 2) { if ((a % 4 == 0 && a % 100 != 0) || (a % 400 == 0)) {c = 29;} else {c = 28;} } else if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) { c = 31;} else if (b == 4 || b == 6 || b == 9 || b == 11) { c = 30;} printf(\"%d年%d月有%d天\\n\",a,b,c); system(\"pause\"); return 0; }", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "else if(b==2); //这里多了个分号 而且紧接着的c=30应该改成c=28 另外，else printf(“%d”, c) 前面的else去掉", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 24 楼 funnywhere 的回复:[quote=引用 23 楼 lin5161678的回复:][quote=引用 22 楼 funnywhere的回复:][quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案[/quote] 那就不叫答案吧，因为我看到一篇介绍gcc如何进行内存分配的文章，可以说找到正确的解释了。[/quote] 局部变量分配汇编指令 Intel 是 sub esp，xxx，ARM处理器是 sub sp, sp, #xxx ，不管什么编译器，就这种方法，还正确答案，别逗", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "引用 28 楼 火花20180731 的回复:可执行文件相当于一个内存模板，系统会按照这个内存模板起一个进程，按模板中的内容为进程分配内存(给一个空闲的虚拟的地址区间，可与物理内存建立映射)，并填充初始数据。第一次进程运行结束后，占用的内存被释放，用过的地址区间再次空闲。第二次进程运行再次从这个空闲地址开始分配，所以两次地址打印相同。现代操作系统都是虚拟内存，进程间内存是互不相干的，跟第几次运行都没关系，即时同时运行也一样", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "引用 29 楼 funnywhere 的回复:[quote=引用 26 楼 赵4老师的回复:]理解和讨论之前请先学会如何观察！ 这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！ 提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！ 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 确实很有道理。[/quote] 老赵的话，十年前就是复制粘贴的，水了一辈子了。", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "如果你的代码中没有使用某个变量，通常会被编译器优化掉（取决于编译器优化级别），如果你只读使用，编译器会将其优化为常量嵌入到代码中（立即数），只有你对它进行了写操作或者取地址，编译器才会为它实际分配空间", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 23 楼 lin5161678的回复:[quote=引用 22 楼 funnywhere的回复:][quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案[/quote] 那就不叫答案吧，因为我看到一篇介绍gcc如何进行内存分配的文章，可以说找到正确的解释了。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "引用 26 楼 赵4老师的回复:理解和讨论之前请先学会如何观察！ 这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！ 提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！ 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 确实很有道理。", "referer": "user-0" }, { "cid": "7", "user": "user-3", "content": "可执行文件相当于一个内存模板，系统会按照这个内存模板起一个进程，按模板中的内容为进程分配内存(给一个空闲的虚拟的地址区间，可与物理内存建立映射)，并填充初始数据。第一次进程运行结束后，占用的内存被释放，用过的地址区间再次空闲。第二次进程运行再次从这个空闲地址开始分配，所以两次地址打印相同。", "referer": "user-0" }, { "cid": "8", "user": "user-2", "content": "以前的老赵又回来了～～～", "referer": "user-0" }, { "cid": "9", "user": "user-4", "content": "理解和讨论之前请先学会如何观察！ 这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！ 提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！ 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0" }, { "cid": "10", "user": "user-5", "content": "引用 22 楼 funnywhere的回复:[quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案", "referer": "user-0" }, { "cid": "11", "user": "user-6", "content": "只單獨輸出a或b，是不是意味著這時候另一個變量在整個程序生命期中沒有用到？比如： #include <stdio.h> #include <stdlib.h> int main() { int b ; int a ; printf(\"%x\\n\",&a); //只输出a的地址，本人机器上为61FE1C system(\"pause\"); return 0; } 這段程序中，b只在定義時出現一次。 這就是你要明白的其中一點：編譯器有優化功能，它掃描了整個程序發現b其實可以不要，於是就很可能被省略掉了。 那麽這個時候，不管你輸出的是a還是b，它的地址分配都是一樣的，即屬於該程序的變量空間只有一個整數。", "referer": "user-0" }, { "cid": "12", "user": "user-0", "content": "引用 21 楼 lin5161678的回复:[quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了", "referer": "user-0" }, { "cid": "13", "user": "user-5", "content": "引用 20 楼 funnywhere 的回复:并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢", "referer": "user-0" }, { "cid": "14", "user": "user-0", "content": "引用 19 楼 老马何以识途的回复:只單獨輸出a或b，是不是意味著這時候另一個變量在整個程序生命期中沒有用到？比如： #include <stdio.h> #include <stdlib.h> int main() { int b ; int a ; printf(\"%x\\n\",&a); //只输出a的地址，本人机器上为61FE1C system(\"pause\"); return 0; } 這段程序中，b只在定義時出現一次。 這就是你要明白的其中一點：編譯器有優化功能，它掃描了整個程序發現b其實可以不要，於是就很可能被省略掉了。 那麽這個時候，不管你輸出的是a還是b，它的地址分配都是一樣的，即屬於該程序的變量空間只有一個整數。 并没有优化掉，都在的。", "referer": "user-0" }, { "cid": "15", "user": "user-0", "content": "引用 13 楼 眼里有光～的回复:函数内部的变量是局部变量，比如你int a,b，这种非静态局部变量是放在栈上的，栈区是操作系统来管理的，程序在运行的时候操作系统自动为局部变量分配空间，局部变量出了作用域以后，操作系统自动回收这部分空间，也就是说不需要由程序员自己去申请和释放这块内存。 你上面出现的情况，每次运行单输出a和b的地址有时是一样的，这是正常情况，程序本次运行操作系统可能将这个地址分配给a，下次运行操作系统将这个地址分配给b，操作系统怎么分配栈区地址其实根本不用程序员操心。 感觉跟操作系统关系不大。感觉是gcc编译器的某种策略，换成msvc就没有这个现象。", "referer": "user-0" }, { "cid": "16", "user": "user-7", "content": "函数内部的变量是局部变量，比如你int a,b，这种非静态局部变量是放在栈上的，栈区是操作系统来管理的，程序在运行的时候操作系统自动为局部变量分配空间，局部变量出了作用域以后，操作系统自动回收这部分空间，也就是说不需要由程序员自己去申请和释放这块内存。 你上面出现的情况，每次运行单输出a和b的地址有时是一样的，这是正常情况，程序本次运行操作系统可能将这个地址分配给a，下次运行操作系统将这个地址分配给b，操作系统怎么分配栈区地址其实根本不用程序员操心。", "referer": "user-0" }, { "cid": "17", "user": "user-8", "content": "短时间内一样的地址巧合而已。", "referer": "user-0" }, { "cid": "18", "user": "user-0", "content": "引用 7 楼 qybao 的回复:[quote=引用 6 楼 funnywhere 的回复:] 你再给a也赋个值10000，你会发现如果只单独输出a或b的地址，也是一样的。 你把你的代码和运行结果贴出来看看 #include <stdio.h> #include <stdlib.h> int main() { int b = 10000; int a = 10000; printf(\"%X\\n\",&b); //你确定轮流注释这两句打印语句运行出来的结果一样？a，b同时被使用，编译优化不会舍弃任何一个，内存地址肯定不同 //printf(\"%X\\n\",&a); //估计你代码哪里有问题，要不就是进程加载时不是重复使用原来的内存（这很正常） system(\"pause\"); return 0; }[/quote]", "referer": "user-0" }, { "cid": "19", "user": "user-0", "content": "轮流注释地址就是一样的啊。试了好多种方案都不知道怎么解释。要不我就不会发帖问了。", "referer": "user-0" }, { "cid": "20", "user": "user-9", "content": "程序加载到内存时才会分配内存，但是编译器会指定偏移量。比如数组会指定长度～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "a未定义，maxxx函数接收的数组是不是不是a而是其他呢？", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "哦哦 明白了", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "i<a j<b c[i][j] 这里的a，b，c在哪里定义的？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "我已经找到问题了，谢谢你们啦", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "就这些代码的话，第一个for连着第二个for循环那里就是给学号从大到小排序了，这可能就是他按学号输出的原因", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "但从这些代码里看不出为什么来。提供更多的代码吧，另外，直接贴代码，不建议贴图片～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "%.20lf指定了输出小数多少位？ https://blog.csdn.net/thanklife/article/details/53033071?utm_medium=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-1.nonecase&depth_1-utm_source=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-1.nonecase", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "是呀 浮点数输出根据精度不同 是会这样的 一般浮点数都是小数点后6位确保的 再后面的值就不一定是正确的了", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "printf(\"%6.2f\".floatNum)：保留两位小数 说明：%6.2f 表明待打印的数（floatNum）至少占6个字符宽度（包括两位小数和一个小数点），且小数点后面有2位小数，小数点占一位，所以整数部分至少占3位。注意：这里的6是待打印的数至少占据的字符宽度，包括两位小数（如果小数不够两位用0补位，例如100.1打印出来为100.10）和一个小数点，所以整数部分至少占3个字符宽度。 1.单精度实数的有效位数一般为7位，输出6位小数，超出有效位数输出就是错误的。 2.双精度数有效位数一般为16位，输出6位小数，超出有效位数可能截断或错误值。 3.关于保留小数点后有效位数四舍五入，原则保留0位小数的时候，只要小数点后第一位>=5，就可以进位，但是保留1位或者2位等等，保留小数的后一位要>5才可以进位，否则就舍去。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "引用 1 楼 user-4 的回复:printf(\"%6.2f\".floatNum)：保留两位小数 说明：%6.2f 表明待打印的数（floatNum）至少占6个字符宽度（包括两位小数和一个小数点），且小数点后面有2位小数，小数点占一位，所以整数部分至少占3位。注意：这里的6是待打印的数至少占据的字符宽度，包括两位小数（如果小数不够两位用0补位，例如100.1打印出来为100.10）和一个小数点，所以整数部分至少占3个字符宽度。 1.单精度实数的有效位数一般为7位，输出6位小数，超出有效位数输出就是错误的。 2.双精度数有效位数一般为16位，输出6位小数，超出有效位数可能截断或错误值。 3.关于保留小数点后有效位数四舍五入，原则保留0位小数的时候，只要小数点后第一位>=5，就可以进位，但是保留1位或者2位等等，保留小数的后一位要>5才可以进位，否则就舍去。感谢😁", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "O_EXCL 表示如果要创建的文件已存在，则出错，同时返回 -1，并且修改 errno 的值。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "题目要求输入都结束后结果一起输出，你这是输入一个就输出一个，和要求不符合。应该把结果都保存到数组里，最后一起输出", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "100个元素你都当做int就可以了（以占用空间最大的数据类型为主），int本来就可以存char，所以20个元素存int，20个存char完全没问题。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 2 楼 qybao 的回复:union就是成员共享一块内存空间 比如 union { int a; char b; } 有a，b两个成员，但是因为空间是共享的，int的空间最大（4个字节），所以以它为准，a成员使用4个字节，b成员使用一个字节，b存在于a里面。如下图， 整个union的空间为@@@@ a @@@@ b @ 也就是a的第一个字节和b的内存空间重合 如果赋值b=1，内存变为 a 1@@@ b 1 如果赋值a=1，内存变为 a 0001 b 0 可见改变a可能会影响b（因为内存共有），同理改变b也可能会影响a 对比一下struct struct { int a; char b; } a和b是不共享空间的，所以整个结构体的空间是int的4个字节+char的1个字节=5个字节（先不考虑内存对齐，如果考虑对齐就是8个字节），内存分布如下图 整个struct的空间为@@@@@ a @@@@ b ？？？？@ ？表示不使用这些空间，也就是a和b没有重合的内存空间，a使用前4个字节，b使用后1个字节 如果赋值b=1，内存变为 a @@@@ b ？？？？1 如果赋值a=1，内存变为 a 0001 b ????1 可见改变a不影响b（因为a和b的内存独立），同理改变b也不影响a 所以union就是为了让成员共享一块内存空间，改变一个成员，其他成员也可能发生变化 所以 问题1，100个元素是union类型，每个元素可以存int或char，用户自己选择 比如 array[0].a=1;//存int array[1].b=‘a’;//存char 问题2 两个成员指a和b，a和b共享同一块内存 问题3 数据存储最小单元是字节（char），任何多字节的类型（其实就相当于char数组)都可以存字符串，只不过内存存储的值不同而已。 比如 int a; strcpy((char*)&a, “ab”); //int存字符串 printf(“%s”, &a); //打印字符串 所以你的array存字符串也没问题，只要控制好不内存越界就可以 问题4 你是怎么赋值的，上面说了，成员是共享内存空间的，给一个成员赋值可能会影响另外的成员，估计是你赋值不对。 那请问一下这100个数组元素的内存是针对元素分配的吗？就比如我可以放20个int类20个char类 这样可以吗？", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "不可以自选，对于联合体，联合体的长度是有元素中占用空间最大的决定，比如第一个联合体有一个int，一个char，这两个元素共用一个内存，那就是int类型的长度，因为sizeof(int) > sizeof(char)", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "union就是成员共享一块内存空间 比如 union { int a; char b; } 有a，b两个成员，但是因为空间是共享的，int的空间最大（4个字节），所以以它为准，a成员使用4个字节，b成员使用一个字节，b存在于a里面。如下图， 整个union的空间为@@@@ a @@@@ b @ 也就是a的第一个字节和b的内存空间重合 如果赋值b=1，内存变为 a 1@@@ b 1 如果赋值a=1，内存变为 a 0001 b 0 可见改变a可能会影响b（因为内存共有），同理改变b也可能会影响a 对比一下struct struct { int a; char b; } a和b是不共享空间的，所以整个结构体的空间是int的4个字节+char的1个字节=5个字节（先不考虑内存对齐，如果考虑对齐就是8个字节），内存分布如下图 整个struct的空间为@@@@@ a @@@@ b ？？？？@ ？表示不使用这些空间，也就是a和b没有重合的内存空间，a使用前4个字节，b使用后1个字节 如果赋值b=1，内存变为 a @@@@ b ？？？？1 如果赋值a=1，内存变为 a 0001 b ????1 可见改变a不影响b（因为a和b的内存独立），同理改变b也不影响a 所以union就是为了让成员共享一块内存空间，改变一个成员，其他成员也可能发生变化 所以 问题1，100个元素是union类型，每个元素可以存int或char，用户自己选择 比如 array[0].a=1;//存int array[1].b=‘a’;//存char 问题2 两个成员指a和b，a和b共享同一块内存 问题3 数据存储最小单元是字节（char），任何多字节的类型（其实就相当于char数组)都可以存字符串，只不过内存存储的值不同而已。 比如 int a; strcpy((char*)&a, “ab”); //int存字符串 printf(“%s”, &a); //打印字符串 所以你的array存字符串也没问题，只要控制好不内存越界就可以 问题4 你是怎么赋值的，上面说了，成员是共享内存空间的，给一个成员赋值可能会影响另外的成员，估计是你赋值不对。", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "你怎么写的？？？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "问题不少 1 变量和结构体同名 student student[number] 2 c不支持用常量定义数组的长度 student student[number] 可以把number变成宏或用动态数组 3 student_average函数没有返回值 4 student_printf函数多了个f，和函数定义不一样", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include<stdio.h> #include<math.h> long long int back(long long int n); int main(void) { int i; long long int n,b; scanf(\"%lld\",&n); if(n==back(n)) printf(\"HW\\n\"); else { for(i=1;i<=10;i++) { b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\", i, n); break; } } if(i>10) printf(\"NONE\\n\"); } return 0; } long long int back(long long int n) { //long long int len,i,d,s=0; long long int s=0; int len, i, d; len=log10(n)+1; printf(\"len = %d\\n\", len); for(i=1;i<=len;i++) { d=n%10; s=s*10+d; n=n/10; } return s; } 供参考～ back参数和返回值有点问题，其他暂未发现问题～", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "引用 3 楼 user-2 的回复:for(i=1;i<=10;i++) { b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t } if(i>10) printf(\"NONE\\n\"); 在你这个循环里i永远小于10，也就下面的if永远不会成立，建议改成如下代码（仅供参考） for(i=1;;i++) { b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t if(i>10) { printf(\"NONE\\n\"); break; } } 楼主这部分没问题，注意i <= 10当i> 10时就是退出循环了。 引用 4 楼 user-2 的回复:补充一下，形参和实参还是不要同名要好一些（虽然这个函数里没什么问题） 被你的一句话给误解了。楼主的没问题。因为for循环是提前退出还是执行完退出的问题。 你如果认为楼主的有问题，建议自己再梳理一下逻辑～", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "if(i>10) printf(\"NONE\\n\"); 这儿改成i >= 10", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "谢各位仁兄回复。", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "补充一下，形参和实参还是不要同名要好一些（虽然这个函数里没什么问题）", "referer": "user-0" }, { "cid": "6", "user": "user-2", "content": "for(i=1;i<=10;i++) { b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t } if(i>10) printf(\"NONE\\n\"); 在你这个循环里i永远小于10，也就下面的if永远不会成立，建议改成如下代码（仅供参考） for(i=1;;i++) { b=back(n); n=n+b; if(n==back(n)) { printf(\"%d %lld\\n\",i,n); break; }\t if(i>10) { printf(\"NONE\\n\"); break; } }", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "望各位仁兄，帮帮忙。提交时总是验证为答案错误，不知何因。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "因为你的while判断条件是x，而你在循环里并没有修改x的值，x>0一直满足，跳不出循环。应该在循环里加个修改x的语句，比如--i;", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 2 楼 呆萌霍比特人的傻大脚板的回复:因为第一个scanf在循环体外,只执行一次.如果不写这行,那么while就没有存在的必要,反正你就算一次, 好的谢谢。。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 1 楼 user-3的回复:因为while循环没有终止的条件啊，它会一直一直循环下去 好的谢谢。。", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "因为第一个scanf在循环体外,只执行一次.如果不写这行,那么while就没有存在的必要,反正你就算一次,", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "因为while循环没有终止的条件啊，它会一直一直循环下去", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 楼主 诗岑 的回复:编译器VS2019 一直给我报这个错 是版本不兼容吗？ 可能你建立的是C语言工程，EasyX只支持C++ 你将源文件的后缀改为.cpp试试", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "还是不行", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "我也是一样的问题，下面还是说easyX is only for C++", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-0", "content": "做出来了，", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 1 楼 user-1的回复:显然没考虑到int越界或越界处理不对 比如 a+b>0，可能a，b都是负数，相加结果超出-2^31变成正数。lz用a=2^31，b=-3 试试就知道了 我做出来了，谢谢。我不仅int越界了，fabs（）函数也用错了，改成了abs（）就对了", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "显然没考虑到int越界或越界处理不对 比如 a+b>0，可能a，b都是负数，相加结果超出-2^31变成正数。lz用a=2^31，b=-3 试试就知道了", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "结构体的date长度没指定 把 int date[] 改成 int date[N]", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "报错的展示出来", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "如果我的SoC里没有这些寄存器，是不是也可以自己定义，然后使用啊？", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "除非你SoC不支持NandFlash，否则肯定有这些寄存器，上面你列的这些寄存器都是NFlash标准的，接口又不是GPIO可以模拟的，必须要通过控制器完成。 看下SoC spec文档，如果支持，那么肯定有，可能名称不一定完全一样。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "把n改成unsigned long或unsigned long long试试", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 1 楼 user-2的回复:int类型（整数类型）的范围为-2^31 ~ 2^31-1，即-2147483648~2147483647 题目要求输入数字是<2^32 对于2^31~2^32-1的数字 你的程序是不是无法判断啦 谢谢，我做出来了。", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "int类型（整数类型）的范围为-2^31 ~ 2^31-1，即-2147483648~2147483647 题目要求输入数字是<2^32 对于2^31~2^32-1的数字 你的程序是不是无法判断啦", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "谢谢各位 弄懂啦！感谢对小白的帮助~", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "函数传数组时用数组的名字就可以了，用name[30]这样是传数组元素（下标为30的元素），所以意思不一样", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "..... strcpy(char *dst , char *src)，你要传入地址进去 例如strcpy(stu[i].name , stu[j].name)", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "把for语句里name后面的[30]去了再试试", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 4 楼 火柴先生 的回复:[quote=引用 2 楼 yqy1234hf 的回复:]这个是不可能绕过素数判断的 自己写循环 被除数/最小素数A/最小素数B/...最小素数N 看看能否除尽 如果不能就把素数表长度减少一位 然后增大最后一个素数 判断是否能除尽 去穷尽所有的素数对就可以了您可以看一下三楼的回复[/quote] 嗯嗯 我题目理解错了 你这个应该就是求素数因子 简单的说就是能整除某个数的队列中的质数? 我理解的对吗？", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 3 楼 user-2 的回复: void AllFactor(int nInput) { \tprintf(\"%d的全素数因子：\", nInput); \tfor (int i = 2; i <= nInput; ++i) \t{ \t\tif (nInput % i == 0) \t\t{ \t\t\tprintf(\"\\t%d\", i); \t\t\tnInput /= i--; \t\t} \t} } 谢谢这应该就是我想看到的代码，我所担心的会不会在这个过程中输出非素数因子，在循环过程中其实不可能出现的，因为如果出现非素数，那么他一定可以在次数更低的循环中找到它对应的素数因子并输出，是不是这样?", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 2 楼 yqy1234hf 的回复:这个是不可能绕过素数判断的 自己写循环 被除数/最小素数A/最小素数B/...最小素数N 看看能否除尽 如果不能就把素数表长度减少一位 然后增大最后一个素数 判断是否能除尽 去穷尽所有的素数对就可以了您可以看一下三楼的回复", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "void AllFactor(int nInput) { \tprintf(\"%d的全素数因子：\", nInput); \tfor (int i = 2; i <= nInput; ++i) \t{ \t\tif (nInput % i == 0) \t\t{ \t\t\tprintf(\"\\t%d\", i); \t\t\tnInput /= i--; \t\t} \t} }", "referer": "user-0" }, { "cid": "5", "user": "user-1", "content": "这个是不可能绕过素数判断的 自己写循环 被除数/最小素数A/最小素数B/...最小素数N 看看能否除尽 如果不能就把素数表长度减少一位 然后增大最后一个素数 判断是否能除尽 去穷尽所有的素数对就可以了", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "晕啦,malloc没打上去,怎么看都没看你出问题", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "p = (struct node*)(sizeof(struct node)); p->a = b;//此处为啥不能读入 这个是什么语法？ 是要malloc吗", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "if (t->next == NULL || t->next->a > b) \t\t{ \t\t\t// p = (struct node*)(sizeof(struct node)); \t\t\tp = (struct node*)malloc(sizeof(struct node)); \t\t\tp->a = b;//此处为啥不能读入 \t\t\tp->next = t->next; \t\t\tt->next = p; \t\t\tbreak; \t\t}", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "void ChongDongDeHua1(void) { \tint nInit = 1; \tint nNum[3] = { 0, 0, 0 }; \tprintf(\"输入小时数：\"); \tint nHour = 0; \tscanf_s(\"%d\", &nHour); \tfor (int i = 0; i < nHour; ++i) \t{ \t\tif (i == 0) \t\t{ \t\t\tnNum[i] = nInit; \t\t} \t\telse \t\t{ \t\t\tnNum[2] += nNum[1]; \t\t\tnNum[1] = nNum[0]; \t\t\tnNum[0] = nNum[2]; \t\t} \t} \tint nTotal = nNum[0] + nNum[1] + nNum[2]; \tprintf(\"输出病毒数：%d\\r\\n\", nTotal); } void ChongDongDeHua2(void) { \tint nSampleMax = 20; \tprintf(\"最多%d个小朋友\\r\\n\", nSampleMax); \tint* pSample = new int[nSampleMax]; \tint nInput = 0; \tint nTotal = 0; \tint nSampleCount = 0; \t \twhile (true) \t{ \t\tscanf_s(\"%d\", &nInput); \t\tif (nInput == -1) \t\t\tbreak; \t\tif (nSampleCount >= nSampleMax) \t\t{ \t\t\tdelete[] pSample; \t\t\tprintf(\"输入错误，最多%d个小朋友\\r\\n\", nSampleMax); \t\t\treturn; \t\t} \t\tpSample[nSampleCount++] = nInput; \t\tnTotal += nInput; \t} \tif (nTotal % 2 == 0) \t{ \t\tint nLoopCount = nSampleCount / 2; \t\tint* pID = new int[nLoopCount]; \t\tfor (int i = 0; i < nLoopCount; ++i) \t\t{ \t\t\tint nSelect = i + 1; \t\t\tint nAddID = 0; \t\t\tpID[nAddID] = 0; \t\t\twhile (pID[0] + nSelect <= nSampleCount) \t\t\t{ \t\t\t\tint nPreAddID = nAddID; \t\t\t\twhile (nAddID + 1 < nSelect && pID[nAddID] + 1 < nSampleCount) \t\t\t\t{ \t\t\t\t\tpID[nAddID + 1] = pID[nAddID] + 1; \t\t\t\t\t++nAddID; \t\t\t\t} \t\t\t\tif (nAddID + 1 < nSelect) \t\t\t\t{ \t\t\t\t\tnAddID = nPreAddID; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tint nSubTotal = 0; \t\t\t\t\tfor (int j = 0; j < nSelect; ++j) \t\t\t\t\t{ \t\t\t\t\t\tnSubTotal += pSample[pID[j]]; \t\t\t\t\t} \t\t\t\t\tfor (int j = pID[nAddID]; j < nSampleCount; ++j) \t\t\t\t\t{ \t\t\t\t\t\tnSubTotal -= pSample[pID[nAddID]]; \t\t\t\t\t\tpID[nAddID] = j; \t\t\t\t\t\tnSubTotal += pSample[pID[nAddID]]; \t\t\t\t\t\t \t\t\t\t\t\tif (nSubTotal == nTotal / 2) \t\t\t\t\t\t{ \t\t\t\t\t\t\tprintf(\"能否均分：Yes\\r\\n\"); \t\t\t\t\t\t\tprintf(\"组合结果：\"); \t\t\t\t\t\t\tfor (int k = 0; k < nSelect; ++k) \t\t\t\t\t\t\t{ \t\t\t\t\t\t\t\tprintf(\"%d \", pSample[pID[k]]); \t\t\t\t\t\t\t} \t\t\t\t\t\t\tprintf(\"\\r\\n\"); \t\t\t\t\t\t\tdelete[] pSample; \t\t\t\t\t\t\tdelete[] pID; \t\t\t\t\t\t\t \t\t\t\t\t\t\treturn; \t\t\t\t\t\t} \t\t\t\t\t} \t\t\t\t} \t\t\t\tif (nAddID == 0) \t\t\t\t\t++pID[nAddID]; \t\t\t\telse \t\t\t\t\t++pID[--nAddID]; \t\t\t} \t\t} \t} \tdelete[] pSample; \tprintf(\"能否均分：No\\r\\n\"); }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:bool ListDelete(SqList *&L,int i,ElemType &e) { int j; if(i<1 ||i>L->length) return false; i--; e=L->data[i]; //for(j=i;L->length-1;j++) { for(j=i; j < L->length-1;j++) { L->data[j] = L->data[j+1]; } L->length--; return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧大佬知道怎么解决么", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "引用 3 楼 自信男孩 的回复:bool ListDelete(SqList *&L,int i,ElemType &e) { int j; if(i<1 ||i>L->length) return false; i--; e=L->data[i]; //for(j=i;L->length-1;j++) { for(j=i; j < L->length-1;j++) { L->data[j] = L->data[j+1]; } L->length--; return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧修改后还是报错", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "bool ListDelete(SqList *&L,int i,ElemType &e) { int j; if(i<1 ||i>L->length) return false; i--; e=L->data[i]; //for(j=i;L->length-1;j++) { for(j=i; j < L->length-1;j++) { L->data[j] = L->data[j+1]; } L->length--; return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "#include\"sqlist.cpp\" int main() { \tSqList *L; \tElemType e; \tprintf(\"顺序表的基本运算如下：\\n\"); \tprintf(\"(1)初始化顺序表L\\n\"); \tInitList(L); \tprintf(\"(2)依次插入a,b,c,d,e元素\\n\"); \tListInsert(L,1,'a'); \tListInsert(L,2,'b'); \tListInsert(L,3,'c'); \tListInsert(L,4,'d'); \tListInsert(L,5,'e'); \tprintf(\"(3)输出顺序表L：\");DispList(L); \tprintf(\"(4)顺序表L长度：%d\\n\",ListLength(L)); \tprintf(\"(5)顺序表L为%s\\n\",(ListEmpty(L)?\"空\":\"非空\")); \tGetElem(L,3,e); \tprintf(\"(6)顺序表L的第3个元素：%c\\n\",e); \tprintf(\"(7)元素a的位置：%d\\n\",LocateElem(L,'a')); \tprintf(\"(8)在第4个元素位置上插入f元素\\n\"); \tListInsert(L,4,'f'); \tprintf(\"(9)输出顺序表L:\");DispList(L); \tprintf(\"(10)删除L的第3个元素\\n\"); \tListDelete(L,3,e); \tprintf(\"(11)输出顺序表L:\");DispList(L); \tprintf(\"(12)释放顺序表L\\n\"); \tDestroyList(L); \treturn 1; }", "referer": "user-0" }, { "cid": "5", "user": "user-1", "content": "你的函数调用在哪里，main函数在哪里？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "应该是吧，能帮忙写一下吗？", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "绕，没看懂什么意思。 是不是表达要用字符数组排序，用数组下标查找", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这个配置参数起作用BinPackArguments: true", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "找到答案了，用// clang-format off关闭就好了", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "搜astyle", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <string.h> const int TXTLEN=8; int main(){ char text[TXTLEN+1], key[TXTLEN+1]; rewind(stdin); printf(\"Please input key(%d bytes):\",TXTLEN); fgets(key,TXTLEN+1,stdin); if ('\\n'==key[strlen(key)-1]) key[strlen(key)-1]=0; printf(\"%s\\n\",key); rewind(stdin); printf(\"Please input text(%d bytes):\",TXTLEN); fgets(text,TXTLEN+1,stdin); if ('\\n'==text[strlen(text)-1]) text[strlen(text)-1]=0; printf(\"%s\\n\",text); printf(\"(%s)%d,(%s)%d\\n\", key, strlen(key),text, strlen(text)); return 0; } //Please input key(8 bytes):123456789 //12345678 //Please input text(8 bytes):123456789 //12345678 //(12345678)8,(12345678)8 //", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "引用 1 楼 自信男孩 的回复:亲测没问题呢，结构都是8； 楼主的代码没有定义TXTLEN的长度，可能在别处定义了，没有发出来。如果这个TXTLEN定义8，那么是可能是16的。 自测时用的TXTLEN是32", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "亲测没问题呢，结构都是8； 楼主的代码没有定义TXTLEN的长度，可能在别处定义了，没有发出来。如果这个TXTLEN定义8，那么是可能是16的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你需要理解，在计算机的大脑里没有1234xx等数字，都是0,1的值。因此只需要通过移位和&操作，就可以把一个十进制（其他进制）对应的二进制的每一位给算出来～", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "用&来做吧，&的效率应该是更快一些～", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "是单纯的模2求余数？还是十进制转二进制吗？ 如果是前者，用与运算即可，即和1做&运算 比如 int main() { int a=5; printf(“%d模2的余数为%d\\n”, a, a&1); //a和1做&运算即为a模2的余数 return 0; } 如果是前者，十进制转2进制，那就多一步移位运算 比如 void tobinary(int n) { int a = n&1; //模2求余 if (n>1) { tobinary(n>>1); //右移1位相当于除以2 } printf(“%d”, a); //打印二进制 } int main() { tobinary(5); //打印5的2进制 return 0; } 以上代码都不出现除法和取模，但是都达到同样的效果", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "赋值有两种形式，一种是把源变量的内容复制到目的变量，一种是让目的变量的地址等于源变量的地址。理解这两种的区别，你就明白了你的问题", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "数组变量，数组名其实表示的是常量地址，所以b=a；相当于把a的地址赋值给b，但是实际上b的地址也是常量，所以不能赋值 结构体 变量名难道不是表示常量地址吗？不理解", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 3 楼 宇来风满楼 的回复:能啊,用已定义数组赋值给新数组 #include <stdio.h> int main() { char a[]=\"abcdefg\"; char b[10]; b=a; printf(\"%s\\n\",b); return 0; } 上面的编译就无法通过； 而下面的才能通过： #include <stdio.h> #include<string.h> int main() { char a[]=\"abcdefg\"; char b[10]; for (int i=0;i<strlen(a);i++) b[i]=a[i]; printf(\"%s\\n\",b); return 0; }", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "能啊,用已定义数组赋值给新数组", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "能啊,用已定义数组赋值给新数字", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "struct book{ char name[10]; char auther[10]; float value; }; struct book math; math=(stuck book){\"studymath\",\"john\",45.3};", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "是字符集的问题，忽略了这个，改成多字符集或者 输出%ws 就可以了。感谢1楼", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "楼主执行的操作是什么，比如./a.out a 5？", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "你这个TCHAR是不是wchar呀，把%s改成%ws试试", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "float值有效位数6位，前6位保证有效，之后不保证。 计算机使用32位，存储float类型有关，IEEE754标准 可以使用64位的double声明，double可以保证15位有效", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "float值有效位数6位，前6位保证有效，只有不保证。 计算机使用32位，存储float类型有关， 可以使用64位的double声明，double可以保证15位有效", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "float有效数字只有6位 请换double", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "void AssisTest(void) { \tint nMaxInput = 20; \tchar* pL2W = new char[nMaxInput + 2]; \tchar* pW2L = new char[nMaxInput + 2]; \tchar* pNum = new char[nMaxInput + 2]; \t*pL2W = 0; \t*pW2L = 0; \t*pNum = 0; \tint nInput = 0; \tfor (int i = 0; (nInput = getchar()) != 10; ++i) \t{ \t\tif (i >= nMaxInput) \t\t{ \t\t\tprintf(\"总数不超过20个！\\r\\n\"); \t\t\treturn; \t\t} \t\tif ('a' <= nInput && nInput <= 'z') \t\t{ \t\t\tpL2W[++*pL2W] = nInput - 'a' + 'A'; \t\t} \t\telse if ('A' <= nInput && nInput <= 'Z') \t\t{ \t\t\tpW2L[++*pW2L] = nInput - 'A' + 'a'; \t\t} \t\telse if ('0' <= nInput && nInput <= '9') \t\t{ \t\t\tint nMinID = 0; \t\t\tint nMaxID = *pNum - 1; \t\t\tint nInsertID = nMinID; \t\t\twhile (nMinID <= nMaxID) \t\t\t{ \t\t\t\tnInsertID = (nMinID + nMaxID) / 2; \t\t\t\tif (pNum[nInsertID + 1] < nInput && nInsertID == nMinID) \t\t\t\t{ \t\t\t\t\t++nMinID; \t\t\t\t\t++nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] < nInput) \t\t\t\t{ \t\t\t\t\tnMinID = nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] == nInput) \t\t\t\t{ \t\t\t\t\tbreak; \t\t\t\t} \t\t\t\telse if (nMaxID == nInsertID) \t\t\t\t{ \t\t\t\t\t--nMaxID; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tnMaxID = nInsertID; \t\t\t\t} \t\t\t} \t\t\tfor (int j = *pNum - 1; j >= nInsertID; --j) \t\t\t{ \t\t\t\tpNum[j + 2] = pNum[j + 1]; \t\t\t} \t\t\t++*pNum; \t\t\tpNum[nInsertID + 1] = nInput; \t\t} \t\telse \t\t{ \t\t\tprintf(\"要求：随机输入数字 大写 小写字母！\\r\\n\"); \t\t\treturn; \t\t} \t} \tpL2W[*pL2W + 1] = 0; \tpW2L[*pW2L + 1] = 0; \tpNum[*pNum + 1] = 0; \tprintf(\"小变大：%s\\r\\n\", pL2W + 1); \tprintf(\"大变小：%s\\r\\n\", pW2L + 1); \tprintf(\"数字排序：%s\\r\\n\", pNum + 1); \tdelete[] pL2W; \tdelete[] pW2L; \tdelete[] pNum; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "void AssisTest(void) { \tint nMaxInput = 20; \tchar* pL2W = new char[nMaxInput + 2]; \tchar* pW2L = new char[nMaxInput + 2]; \tchar* pNum = new char[nMaxInput + 2]; \t*pL2W = 0; \t*pW2L = 0; \t*pNum = 0; \tint nInput = 0; \tfor (int i = 0; (nInput = getchar()) != 10; ++i) \t{ \t\tif (i >= nMaxInput) \t\t{ \t\t\tprintf(\"总数不超过20个！\\r\\n\"); \t\t\treturn; \t\t} \t\tif ('a' <= nInput && nInput <= 'z') \t\t{ \t\t\tpL2W[++*pL2W] = nInput - 'a' + 'A'; \t\t} \t\telse if ('A' <= nInput && nInput <= 'Z') \t\t{ \t\t\tpW2L[++*pW2L] = nInput - 'A' + 'a'; \t\t} \t\telse if ('0' <= nInput && nInput <= '9') \t\t{ \t\t\tint nMinID = 0; \t\t\tint nMaxID = *pNum - 1; \t\t\tint nInsertID = nMinID; \t\t\twhile (nMinID <= nMaxID) \t\t\t{ \t\t\t\tnInsertID = (nMinID + nMaxID) / 2; \t\t\t\tif (pNum[nInsertID + 1] < nInput && nInsertID == nMinID) \t\t\t\t{ \t\t\t\t\t++nMinID; \t\t\t\t\t++nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] < nInput) \t\t\t\t{ \t\t\t\t\tnMinID = nInsertID; \t\t\t\t} \t\t\t\telse if (pNum[nInsertID + 1] == nInput) \t\t\t\t{ \t\t\t\t\tbreak; \t\t\t\t} \t\t\t\telse if (nMaxID == nInsertID) \t\t\t\t{ \t\t\t\t\t--nMaxID; \t\t\t\t} \t\t\t\telse \t\t\t\t{ \t\t\t\t\tnMaxID = nInsertID; \t\t\t\t} \t\t\t} \t\t\tfor (int j = *pNum - 1; j >= nInsertID; --j) \t\t\t{ \t\t\t\tpNum[j + 2] = pNum[j + 1]; \t\t\t} \t\t\t++*pNum; \t\t\tpNum[nInsertID + 1] = nInput; \t\t} \t\telse \t\t{ \t\t\tprintf(\"要求：随机输入数字 大写 小写字母！\\r\\n\"); \t\t\treturn; \t\t} \t} \tpL2W[*pL2W + 1] = 0; \tpW2L[*pW2L + 1] = 0; \tpNum[*pNum + 1] = 0; \tprintf(\"小变大：%s\\r\\n\", pL2W + 1); \tprintf(\"大变小：%s\\r\\n\", pW2L + 1); \tprintf(\"数字排序：%s\\r\\n\", pNum + 1); \tdelete[] pL2W; \tdelete[] pW2L; \tdelete[] pNum; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "字母大小写视为相同吗？", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "需求不明确，建议楼主细化一下吧", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "没看懂，你这输入与输出，有啥逻辑关系", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "结构体啊。。。。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "Windows： 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 Linux： 进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "大佬们这个出发短点咋个办那", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你自己不都说了么，四闰百不闰，四百闰，你把100,200,300,500,600,。。。这些给当成闰年再算，结果肯定有问题啊", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "# include <stdio.h> int main() { int year,t,s,day; scanf(\"%d\",&year); t=(year-1)/4; s=(year-1)%4; switch(s) { case 0:day=t*(365*3+366);break; case 1:day=t*(365*3+366)+365;break; case 2:day=t*(365*3+366)+365*2;break; case 3:day=t*(365*3+366)+365*3;break; } int i; i=day%7; switch(i) { case 0:printf(\"星期天\\n\");break; case 1:printf(\"星期一\\n\");break; case 2:printf(\"星期二\\n\");break; case 3:printf(\"星期三\\n\");break; case 4:printf(\"星期四\\n\");break; case 5:printf(\"星期五\\n\");break; case 6:printf(\"星期六\\n\");break; } return 0; } 供参考～ case 0改成星期天，其他依次修改一下i值对应的星期值就可以了～ case0不就是7%7得0吗？怎么把0改成星期一了呢？", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "有测试用例吗？发一下，不知道你说的哪里错是测试出错，还是其他错误？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "上面那老哥说的对，V=PI*r*r*h*(1/3); 这句错误，1 和 3 均为整形，两个相除的商也应该是整形，所以 1/3=0 ，应该用 1.0/3 或者 1/3.0", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "V=PI*r*r*h*(1/3);这句有问题 1/3计算机中结果是0 整形相除 改一下 V=PI*r*r*h*(1.0/3);", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "V=PI*r*r*h*(1/3); 这句错误，修改如下： #include<stdio.h> #include<stdlib.h> #define PI 3.14 int main(int argc, char* argv[]) { int r,h,l; float S,V; r=5; h=12; l=13; S=PI*r*l+PI*r*r; V=PI*r*r*h/3;//这句修改 printf(\"表面积S=%f\\n体积V=%f\\n\",S,V); system(\"pause\"); return 0;", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "代码没问题啊，或者你把r,h.l换成浮点型试试", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 2 楼 自信男孩 的回复:都可以连写也可以单写，需要注意的是%c处理起来比较麻烦。 //请今后要用 char c; scanf(\"%c\",&c); //时，都改为 char s[2]; char c; scanf(\"%1s\",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "都可以连写也可以单写，需要注意的是%c处理起来比较麻烦。", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "Format Specification Fields: scanf and wscanf Functions A format specification has the following form: % [width] [{h | l | I64 | L}]type The format argument specifies the interpretation of the input and can contain one or more of the following: White-space characters: blank (' '); tab ('\\t'); or newline ('\\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input. Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates. Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list. The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read. When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string. An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification. Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number. The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%. An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "eb和ec刚好差1，反码和补码也是1的关系，计算机存储是补码", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "浮点数格式 http://bbs.csdn.net/topics/390676437", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "你看错了，前面的是低位，后面是高位， 你没发现你算的是41，08，51，eb; 正好和他的相反吗？至于是ec,eb，不过是浮点的精度问题", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "学会调试", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "引用 17 楼 qzjhjxj 的回复:引用所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？这里 int a[10] = {1}，后面是大括号{}，就是数组10个元素都被初始化为1，而不是a[0]被初始化为1。如果要a[0]初始化为1，应该是a[10]=1. a[10] = 1;这个操作已经数组越界了，下表最大10-1 建议你自己试试，写几条语句试试，然后再发表看法，或许更有说服力。 一维数组初始化（定义式），不用大括号，你打算用什么来初始化？", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "引用所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？这里 int a[10] = {1}，后面是大括号{}，就是数组10个元素都被初始化为1，而不是a[0]被初始化为1。如果要a[0]初始化为1，应该是a[10]=1.", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "引用 15 楼 自信男孩 的回复:[quote=引用 11 楼 SleekStone 的回复:][quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？ 除了第一个a[0]为1，其他都是0. 一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 对，自测一下就好了～[/quote]我想说的在14楼，不过刚刚看到外面有个帖子https://bbs.csdn.net/topics/398136483，我觉得那里面5楼的兄弟说得有道理", "referer": "user-0" }, { "cid": "4", "user": "user-1", "content": "引用 11 楼 SleekStone 的回复:[quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？ 除了第一个a[0]为1，其他都是0. 一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 对，自测一下就好了～", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "引用 12 楼 xian_wwq 的回复:[quote=引用 11 楼 SleekStone 的回复:][quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？ 除了第一个a[0]为1，其他都是0. 一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 确实如此，在环境中跑一下，一目了然[/quote]我的意思不是在怀疑这个结果，我是在怀疑这个表述“int a[10]={0}的时候，10个元素都被初始化为0，int a[10]={1},只有a[0]被初始化为了1，其它被初始化为了0”，这种表述我不知道正不正确，我依稀记得我上学的时候老师说的是“int a[10]={x}，只有第一个元素被初始化为了x，其它元素值是由编译器提供实现的，有的编译器会设成0”，如果我记得没错的话，就意味着对于int a[10]={x}，C++标准只规定了a[0]，初始化为x，其它值标准是不做保证的，我刚才去找了找看能不能找到这个标准，可惜我没找到，如果有朋友找到相关的标准了，也希望告知我一下，", "referer": "user-0" }, { "cid": "6", "user": "user-2", "content": "1. 直接给每个元素赋值 int array[4] = {1,2,3,4}; 2. 给一部分赋值，后面的全部为0 int array[4] = {1,2}; 3. 由赋值参数个数决定数组的个数 int array[] = {1,2}; 4. 数组元素的值是随机分配的 int array[4] = {}; 当初始化参数时，推荐使用 int array[4] = {0};", "referer": "user-0" }, { "cid": "7", "user": "user-4", "content": "引用 11 楼 SleekStone 的回复:[quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？ 除了第一个a[0]为1，其他都是0. 一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 确实如此，在环境中跑一下，一目了然", "referer": "user-0" }, { "cid": "8", "user": "user-3", "content": "引用 10 楼 自信男孩 的回复:[quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？ 除了第一个a[0]为1，其他都是0. 一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？", "referer": "user-0" }, { "cid": "9", "user": "user-1", "content": "引用 8 楼 SleekStone 的回复:[quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？ 除了第一个a[0]为1，其他都是0. 一般初始化，都是初始化为0.", "referer": "user-0" }, { "cid": "10", "user": "user-5", "content": "引用 4 楼 自信男孩的回复:[quote=引用 3 楼 m0_51355118 的回复:]错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样 k是可变的，数组长度是不确定的～[/quote] c99允许这样定义和使用，只是无法初始化，要另外赋值", "referer": "user-0" }, { "cid": "11", "user": "user-3", "content": "引用 6 楼 自信男孩 的回复:[quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？", "referer": "user-0" }, { "cid": "12", "user": "user-3", "content": "引用 5 楼 user-6 的回复:[quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0不会 有初始化没指定初始化项都会初始化为0[/quote]int a[10] = {1};这样呢？", "referer": "user-0" }, { "cid": "13", "user": "user-1", "content": "引用 1 楼 SleekStone 的回复:int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.", "referer": "user-0" }, { "cid": "14", "user": "user-6", "content": "引用 1 楼 SleekStone 的回复:int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0不会 有初始化没指定初始化项都会初始化为0", "referer": "user-0" }, { "cid": "15", "user": "user-1", "content": "引用 3 楼 m0_51355118 的回复:错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样 k是可变的，数组长度是不确定的～", "referer": "user-0" }, { "cid": "16", "user": "user-5", "content": "错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样", "referer": "user-0" }, { "cid": "17", "user": "user-1", "content": "a数组是不确定大小的，大小由n决定。C语言不支持可变数组。楼主可以用动态申请空间形式申请空间（当做数组用） a = (int *)malloc(sizeof(int) * k); if (!a) exit(0); memset(a, 0, k * sizeof(int));", "referer": "user-0" }, { "cid": "18", "user": "user-3", "content": "int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "[quote=引用 3 楼 自信男孩 的回复:]#include<stdio.h> // int main() int getcount(int n) { int i,count; if(n>60) count++; return count; } int main() { int n,count=0; printf(\"input a numble:\\n\"); scanf(\"%d\",&n); count=getcount(90); printf(\"%d\",count); return 0; } 供参考～ getcount函数里的count是未初始化的，需要注意下～[ 谢谢", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "#include<stdio.h> // int main() int getcount(int n) { int i,count; if(n>60) count++; return count; } int main() { int n,count=0; printf(\"input a numble:\\n\"); scanf(\"%d\",&n); count=getcount(90); printf(\"%d\",count); return 0; } 供参考～ getcount函数里的count是未初始化的，需要注意下～", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "修改后是这样：#include<stdio.h> int getcount(int n) { int count; if(n>60) count++; return count; } int main() { int n,count=0; printf(\"input a numble:\\n\"); scanf(\"%d\",&n); count=getcount(n); printf(\"%d\",count); return 0; }", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "int main()//这一行必须取消 int getcount(int n) { int i,count; if(n>60) count++; return count; } int main() { int n,count=0; printf(\"input a numble:\\n\"); scanf(\"%d\",&n); count=getcount(90);//这行调用getcount()函数，应该是count=getcount(n);才正确 printf(\"%d\",count); return 0; }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "相等的时候为什么输出为空啊", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "多分号～需要注意下～", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "引用 1 楼 一颗白面馒头的回复:while循环里面的if条件判断后面不加分号 。。。。我去，我忘记把删除语句后面的分号也删了", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "while循环里面的if条件判断后面不加分号", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "没有问题，我故意不加括号的，不是为了读取字符，而是为了测试EOF，最终的输出只有1和0", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "个人觉得应该和系统环境以及编译器或者IDE有关，不是每种组合的运行结果都是这样，我的linux+gcc输入ctrl+z就会提示已停止，不会输出0。", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "while(ch = getchar() != EOF) 改一下 while((ch = getchar()) != EOF) 因为!=优先级比=高，因此会把判断结果赋值给ch，而不是getchar()的返回值赋值给ch", "referer": "user-0" } ]