Question: 帮帮新手c语言程序出现问题无法输出

修改如下，供参考：  #include<stdio.h> #include<string.h> #include<stdlib.h> #include<conio.h>  #define MAX 100  struct Book {     char ids[16];     //订单号     char date[32];       //订票日期     char name[16];   //航空公司名称     char hangban[16];//航班号     char src[16];   //出发地     char dst[16];   //目的地     int  price;      //票价     char guest[20];  //订票人名     char guid[20];   //订票人身份证号 };  typedef struct Book* PBook;  //显示菜单 void displayMenu() {  system("CLS");//清屏  printf("-------订票系统-------\n");  printf("-----1.添加航班-------\n");  printf("-----2.修改航班-------\n");  printf("-----3.删除航班-------\n");  printf("----4.按编号查找航班--\n");  printf("----5.按名称查找航班--\n");  printf("----6.显示航班列表----\n");  printf("-------7.退出---------\n");  printf("-------输入选项:------\n"); } //显示指航班信息 void display(PBook pBook) {    printf("订单号  订单日期   航空公司名称   航班号  出发地  目的地  票价  姓名  身份证\n");    printf("%s\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t%s\n",pBook->ids,pBook->date,pBook->name,pBook->hangban,                                     pBook->src,pBook->dst,pBook->price,pBook->guest,pBook->guid); } //显示所有航班列表 void displayList(PBook list,int count) {    printf("列表:\n");    printf("航班号  出发地 目的地  票价\n");    for(int i=0;i<count;i++)    {       printf("%s\t%s\t%s\t%d\n",list[i].hangban,list[i].src,list[i].dst,list[i].price);    } } //添加航班  void add(PBook list,int* count) {    int n;    PBook pBook;    printf("添加航班数量:");    scanf("%d",&n);    for(int i=0;i< n;(*count)++,i++)    {                                          //pBook=(PBook)malloc(sizeof(struct Book));         printf("----第%d个航班：----\n",i+1);         strcpy(list[(*count)].ids, "010");         strcpy(list[(*count)].date,"2021.6.12");         printf("航空公司名称:");         fflush(stdout);rewind(stdin);         scanf("%s",list[(*count)].name);    // pBook->name);         printf("航班号");         fflush(stdout);rewind(stdin);         scanf("%s",list[(*count)].hangban);   //pBook->hangban);         printf("出发地:");         fflush(stdout);rewind(stdin);         scanf("%s",list[(*count)].src);      //pBook->src);         printf("目的地:");         fflush(stdout);rewind(stdin);         scanf("%s",list[(*count)].dst);       //pBook->dst);         printf("票价:");         fflush(stdout);rewind(stdin);         scanf("%d",&list[(*count)].price);     //&pBook->price);         printf("姓名：");         fflush(stdout);rewind(stdin);         scanf("%s",list[(*count)].guest);     //pBook->guest);         printf("身份证:");         fflush(stdout);rewind(stdin);         scanf("%s",list[(*count)].guid);      //pBook->guid);    } } //修改 void update(PBook list,int count) {    char temp[20];    printf("要修改航班号:");    fflush(stdout);rewind(stdin);    scanf("%s",temp);    for(int i=0;i<count;i++)    {       if(strcmp(list[i].hangban,temp)==0)       {           printf("航班号:");           fflush(stdout);rewind(stdin);           scanf("%s",list[i].hangban);           printf("姓名:");           fflush(stdout);rewind(stdin);           scanf("%s",list[i].guest);           printf("身份证:");           fflush(stdout);rewind(stdin);           scanf("%s",list[i].guid);           printf("修改成功!\n");           return;       }    }    printf("没有找到该航班!"); } //删除 void del(PBook list,int* count) {    char temp[20];    printf("要删除航班号:");    fflush(stdout);rewind(stdin);    scanf("%s",temp);    for(int i=0;i<(*count);i++)    {        if(strcmp(list[i].hangban,temp)==0)        {            //PBook pBook=list[i];            for(int j=i;j<(*count)-1;j++)            {                list[j]=list[j+1];            }            //delete(pBook);            (*count)--;            printf("删除成功!\n");            return;        }    }    printf("没有找到该航班!"); } //按航班查询 void searchById(PBook list,int count) {    char temp[20];    printf("要查找的航班号:");    fflush(stdout);rewind(stdin);    scanf("%s",temp);    for(int i=0;i<count;i++)    {        if(strcmp(list[i].hangban,temp)==0)        {             display((list+i));             return;        }    }    printf("没有找到该航班!"); } //按姓名查询 void searchByName(PBook list,int count) {    char temp[20];    printf("要查找的姓名:");    fflush(stdout);rewind(stdin);    scanf("%s",temp);    for(int i=0;i<count;i++)    {        if(strcmp(list[i].guest,temp)==0)        {            display(list+i);            return;        }    }    printf("没有找到该航班!"); }  /**/ void main() {    PBook list;    int   count=0;    char  key;    list=(PBook)malloc(MAX*sizeof(struct Book));    while(1)    {         displayMenu();         fflush(stdin);//清除输入缓存         key=getchar();         switch(key)         {                   case '1'://添加                            add(list,&count);                            break;                   case '2'://修改                            update(list,count);                            break;                   case '3'://删除                            del(list,&count);                            break;                   case '4'://按航班号查找                            searchById(list,count);                            break;                   case '5'://按姓名查找                            searchByName(list,count);                            break;                   case '6'://显示列表                            displayList(list,count);                            break;                   case '7'://退出                            return;                            break;                    default:                            break;         }         printf("按任意键返回..");         getch();    } }


Question: 10进制转2进制时带有小数的该怎么转换

浮点数格式 [url=http://bbs.csdn.net/topics/390676437][/url]

整数转除2取余，小数部分乘2，取积的整数部分。


Question: 那位大佬帮我看一下这个程序 非常简单

#include <stdio.h> #include <stdlib.h> #include <string.h>  int format(char* str, int* cnt) {   if (!str || !cnt) return -1;    if (strlen(str) == 0) {     printf("###\n");     return 0;   }    *cnt = 0;   int len = strlen(str);   char* tmp = (char*)malloc(strlen(str) * sizeof(char));   memset(tmp, 0, strlen(str) * sizeof(char));   for (int i = 0; i < strlen(str); i++) {     if (str[i] == '#') {       *cnt += 1;       if (i) *(tmp + i) = ' ';     } else       *(tmp + i) = *(str + i);   }   if (strlen(tmp) == 0) {     printf("###\n");   } else if (str[0] == '#' && str[strlen(str) - 1] == '#') {     printf("%d %d %s\n", *cnt - 1, *cnt, tmp);   } else if (str[0] != '#' && str[strlen(str) - 1] != '#') {     printf("%d %d %s\n", *cnt + 1, *cnt, tmp);   } else {     printf("%d %d %s\n", *cnt, *cnt, tmp);   }   if (!tmp) free(tmp);   return 0; }  int main() {   int line = 0;   scanf("%d", &line);   while (line--) {     char input[128] = {0};     scanf("%s", input);     int cnt = 0;     int len = strlen(input);     if (format(input, &cnt)) return -1;   }   return 0; }


Question: 请教一个函数指针的问题。

自问自答了！直接汇编调试时可以发现，ptr 指针里 的值里的地址存放的是一条 jmp 跳转指令，直接跳转到了 Add 函数的首地址，不是我之前想象中的把 add 的地址直接赋值给 ptr....

// ConsoleApplication2.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 //  #include <iostream>   int(*ptr)(int, int);  int Add(int c1, int c2) { 	return c1 + c2; } int main(int, char**) { 	int a = 10; 	int b = 20; 	int c = 0;  	c = a;  	ptr = &Add; 	using namespace std; 	cout << Add << endl; 	cout << ptr << endl;  	return 0; }   00791195 00791195 C:\Users\Administrator\source\repos\ConsoleApplication2\Debug\ConsoleApplication2.exe (进程 5736)已退出，返回代码为: 0。 按任意键关闭此窗口...

麻烦您再帮我看看。我的问题在哪儿。

调试栏的地址为啥不一样咧？

你的cmd显示是正确的。

ptr=&Add  ptr是一个函数指针类型变量，它指向了Add这地址，他就是Add这个函数啊


Question: 【C语言】纯char实现超大数运算

仅供参考：  #include <stdio.h> #include <string.h> #define MAXLEN 1000 char a1[MAXLEN]; char a2[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; void main(void) {     scanf("%d",&n);     for (j=0;j<n;j++) {         scanf("%s%s",a1,a2);          L=strlen(a1);         for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';          L=strlen(a2);         for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';          for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];          for (i=0;i<MAXLEN;i++) {             if (v3[i]>=10) {                 v3[i+1]+=v3[i]/10;                 v3[i]=v3[i]%10;             }         }          printf("Case %d:\n", j+1);         printf("%s + %s = ", a1, a2);          z=0;         for (i=MAXLEN-1;i>=0;i--) {             if (z==0) {                 if (v3[i]!=0) {                     printf("%d",v3[i]);                     z=1;                 }             } else {                 printf("%d",v3[i]);             }         }         if (z==0) printf("0");          printf("\n");     } } //Sample Input //3 //0 0 //1 2 //112233445566778899 998877665544332211 // //Sample Output //Case 1: //0 + 0 = 0 //Case 2: //1 + 2 = 3 //Case 3: //112233445566778899 + 998877665544332211 = 1111111111111111110


Question: 哪位大佬看看

scanf("%c", G->vexs[i]); 参数为数组元素也要用地址，scanf("%c", &G->vexs[i]);


Question: 新人请教一下关于三重for嵌套循环的疑问

感谢各位大佬的帮助  万分感谢！！!

引用 1 楼 真的小白啊 的回复:感觉你写的有点复杂啊  好的 感谢各位大佬的帮助 我再仔细看看

后面两个图案不对  纠正

不难 就是有点琐碎

按照你这个第2，3个for语句控制输出每行s*（i+1）个空格，第一个for语句控制输出每行一个*号；s每次自减1，i每次自增1；第一次执行i=0，输出s的初值，也就是9个空格，第二次i=1，s=8，输出16个空格；所以，代码就用二楼的

其实两个循环就可以啦，在第二个循环里面判断一下位置是否超过规定，超过则打星，不超则打空格。 你的肯定错了，for(j) 应该是具体打印每个行中的数据，而你打印*的语句并不包含在内，而且你包含在内也不对。语言不好描述，直接上代码吧.  	for (i = 0; i < 10; i++) { 		for (k = s; k > 0; k--) { 			printf(" "); 		} 		for(j=i;j>=0;j--) 			printf("*"); 		s--; 		printf("\n");  	}

感觉你写的有点复杂啊


Question: 关于mtrace调试内存泄漏时的问题

Linux不是开源的吗？看_IO_file_doallocate函数中都干了什么。

mtrace(); 看一下这个函数里怎么操作的。


Question: 定时器不执行 OnTimer方法，要怎么改？

引用 10 楼 真相重于对错 的回复:查settime的原型啊 感谢大佬，大佬移步，这个帖子随便回复我结贴给分，https://bbs.csdn.net/topics/399174441

查settime的原型啊

引用 7 楼 真相重于对错 的回复:定时器不执行 OnTimer方法，要怎么改？OnTimer现在查到的是只有使用MFC才可以自动调用这个函数，MFC 内部实现了函数映射，但是 我现在不是使用MFC也想用定时器，现在查到的是使用回调函数，现在回调函数可以实现定时器想要的功能了，又出现新问题，我不知道怎么关闭定时器，无论我把KillTimer(NULL,2);这句话写在回调函数第一行还是定时器后面都不执行关闭定时器操作，请问您有什么思路吗？ void CALLBACK TimerProc (   HWND hWnd,   UINT nMsg,   UINT nTimerid,   DWORD dwTime   ){ 	   	//KillTimer(NULL,2); 	keybd_event(VK_RETURN, 0, 0, 0);//按键下去 	keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);//，按键上来，模拟"回车"命令	 		 }; int main(){ 	SetTimer(NULL,2, 1000, TimerProc); 	int ret = MessageBox(NULL,TEXT("0000"),NULL, MB_YESNO); 	KillTimer(NULL,2); 	while(1){ 	//	SetTimer(NULL,2, 1000, TimerProc); 		MessageBox(NULL,TEXT("111111"),NULL, MB_YESNO); 		Sleep(2000); 	} 	 	system("PAUSE"); 	return 0; }

引用 2 楼 赵4老师 的回复:仅供参考：#pragma comment(lib,"user32") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     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,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log("In myTimerProc1\n"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log("In myTimerProc2\n"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log("In main\n");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2   还有个问题需要问一下，  void CALLBACK TimerProc (   HWND hWnd,   UINT nMsg,   UINT nTimerid,   DWORD dwTime   ){ 	   	KillTimer(NULL,2); 	keybd_event(VK_RETURN, 0, 0, 0);//按键下去 	keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);//，按键上来，模拟"回车"命令	 		 }; int main(){  	SetTimer(NULL,2, 1000, TimerProc); 	int ret = MessageBox(NULL,TEXT("111111"),NULL, MB_YESNO); 	system("PAUSE"); 	return 0; } 我这个样子写定时器的关闭，可以实现定时器关闭吗？我不知道要怎么测试，希望得到解答，谢谢啦！  引用 2 楼 赵4老师 的回复:仅供参考：#pragma comment(lib,"user32") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     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,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log("In myTimerProc1\n"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log("In myTimerProc2\n"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log("In main\n");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2  使用回调函数的定时器要怎么关闭呢？

定时器不执行 OnTimer方法，要怎么改？

引用 2 楼 赵4老师 的回复:仅供参考：#pragma comment(lib,"user32") #include <stdio.h> #include <time.h> #include <sys/timeb.h> #include <windows.h> CRITICAL_SECTION cs_log; char datestr[16]; char timestr[16]; char mss[4]; void log(char *s) {     struct tm *now;     struct timeb tb;      EnterCriticalSection(&cs_log);     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,s);     LeaveCriticalSection(&cs_log); } VOID CALLBACK myTimerProc1(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log("In myTimerProc1\n"); } VOID CALLBACK myTimerProc2(   HWND hwnd, // handle of window for timer messages   UINT uMsg, // WM_TIMER message   UINT idEvent, // timer identifier   DWORD dwTime // current system time ) {  log("In myTimerProc2\n"); } int main() {     int i;     MSG msg;      InitializeCriticalSection(&cs_log);     SetTimer(NULL,0,1000,myTimerProc1);     SetTimer(NULL,0,2000,myTimerProc2);     for (i=0;i<20;i++) {         Sleep(500);         log("In main\n");         if (GetMessage(&msg,NULL,0,0)) {             TranslateMessage(&msg);             DispatchMessage(&msg);         }      }     DeleteCriticalSection(&cs_log);     return 0; } //2018-04-17 10:07:54.218 In main //2018-04-17 10:07:54.718 In myTimerProc1 //2018-04-17 10:07:55.218 In main //2018-04-17 10:07:55.718 In myTimerProc2 //2018-04-17 10:07:56.218 In main //2018-04-17 10:07:56.218 In myTimerProc1 //2018-04-17 10:07:56.718 In main //2018-04-17 10:07:56.718 In myTimerProc1 //2018-04-17 10:07:57.218 In main //2018-04-17 10:07:57.718 In myTimerProc2 //2018-04-17 10:07:58.218 In main //2018-04-17 10:07:58.218 In myTimerProc1 //2018-04-17 10:07:58.718 In main //2018-04-17 10:07:58.718 In myTimerProc1 //2018-04-17 10:07:59.218 In main //2018-04-17 10:07:59.718 In myTimerProc2 //2018-04-17 10:08:00.218 In main //2018-04-17 10:08:00.218 In myTimerProc1 //2018-04-17 10:08:00.718 In main //2018-04-17 10:08:00.718 In myTimerProc1 //2018-04-17 10:08:01.218 In main //2018-04-17 10:08:01.718 In myTimerProc2 //2018-04-17 10:08:02.218 In main //2018-04-17 10:08:02.218 In myTimerProc1 //2018-04-17 10:08:02.718 In main //2018-04-17 10:08:02.718 In myTimerProc1 //2018-04-17 10:08:03.218 In main //2018-04-17 10:08:03.718 In myTimerProc2 //2018-04-17 10:08:04.218 In main //2018-04-17 10:08:04.218 In myTimerProc1 //2018-04-17 10:08:04.718 In main //2018-04-17 10:08:04.718 In myTimerProc1 //2018-04-17 10:08:05.218 In main //2018-04-17 10:08:05.718 In myTimerProc2 //2018-04-17 10:08:06.218 In main //2018-04-17 10:08:06.218 In myTimerProc1 //2018-04-17 10:08:06.718 In main //2018-04-17 10:08:06.718 In myTimerProc1 //2018-04-17 10:08:07.218 In main //2018-04-17 10:08:07.718 In myTimerProc2  谢谢，解决了

引用 1 楼 真相重于对错 的回复:你又没有把定时器和回调函数绑定，系统怎么知道要调用那个函数我知道没绑定，我在查，我没查到才问的！！！！

你又没有把定时器和回调函数绑定，系统怎么知道要调用那个函数


Question: 新手小白，找个大佬带带我

好的好的，谢谢大家

引用 7 楼 qq_45773596 的回复:[quote=引用 6 楼 自信男孩的回复:][quote=引用 2 楼 真的小白啊 的回复:]这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf("sum = %lf\n", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；  [/quote] 我晕了，哪一个方法是对的呀[/quote] 跟方法没关系的。是类型运算出现的问题。这位朋友给你推荐的算法没问题的，而是变量的类型有点问题，改成long double（自测）就可以。 当然，用unsigned long long也是没问题的。  这也是楼主需要注意的，需要考虑类型的取值范围，考虑是否会溢出以及类型的运算等等

引用 6 楼 自信男孩 的回复:[quote=引用 2 楼 真的小白啊 的回复:]这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf("sum = %lf\n", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；  [/quote]  感谢对小白的指正，在变量类型方面我还存在许多不足

引用 6 楼 自信男孩的回复:[quote=引用 2 楼 真的小白啊 的回复:]这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf("sum = %lf\n", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；  [/quote] 我晕了，哪一个方法是对的呀

引用 2 楼 真的小白啊 的回复:这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf("sum = %lf\n", sum);     return 0; }  测试了一下，你的程序输出结果是： sum = 2561327494111820288.000000 个人感觉这个结果是不对的，因为这个结果应该是一个奇数，而不是偶数；  last和sum定义为unsigned long long后得到的结果是 sum = 2561327494111820313  将last和sum定义为long double后就没问题了，得到了： sum = 2561327494111820313.000000  另外，对于long double的输出建议用%.0Lf格式输出，因为阶层和不会得到一个浮点数（实数），应该得到一个整数才对；

引用 3 楼 qq_45773596 的回复:刚才试了。谢谢哈 不过第四行和倒数第二行代码，我不太理解 在做ACM题时，经常都会遇到一些比较大的整数。而常用的内置整数类型常常显得太小了:其中long 和 int 范围 是[-2^31,2^31)，即-2147483648~2147483647。而unsigned范围是[0,2^32)，即0~4294967295。也就是说， 常规的32位整数只能够处理40亿以下的数。 那遇到比40亿要大的数怎么办呢？这时就要用到C++的64位扩展了。不同的编译器对64位整数的扩展 有所不同。VC6.0的64位整数分别叫做__int64与unsigned __int64，其范围分别是[-2^63, 2^63)与[0,2^64)，即-9223372036854775808~9223372036854775807与0~18446744073709551615(约1800亿亿)。对64位整数的运算与32位整数基本相同，都支持四则运算与位运算等。

引用 2 楼 真的小白啊的回复:这样是不是就明白一些  int main() {     /*      * 1!+2!+3!+…+19!+20!      *      * 1*1 + 2*1 + 3*2*1 + 4*3*2*1 +      * */          //一个数用来保存每一项阶乘     double last = 1;     //一个数用来求和     double sum = 0;     //从1到20     for (int i = 1; i <= 20; i++)     {         last *= i;  //i=1 => 1*(1)    i=2 => 2*(1*1)    i=3 => 3*(2*1*1)    i=4 => 4*(3*2*1*1)         sum += last;    //累加起来     }     //打印结果     printf("sum = %lf\n", sum);     return 0; }  懂了，谢谢哈

刚才试了。谢谢哈 不过第四行和倒数第二行代码，我不太理解

20!很大了，装不下了，供参考：#include<stdio.h>  int main() {     int i;     __int64 s=0,tmp=1;     for(i=1;i<=20;i++)     {        tmp *= i;        s+=tmp;     }     printf("%I64d\n",s);          return 0; }

过来学习，谢谢分享


Question: 新人求助

windows下cls在linux和mac下是clear。 也可以编辑.bashrc文件，添加一行 alias cls='clear';

引用 2 楼 H-M-A-L 的回复:[quote=引用 1 楼 自信男孩的回复:]建议使用system("clear"); MAC系统是unix（源）因此，和windows还是有区别的。 LINUX下可以用clear来清屏～ 我就是用clear，然后显示TERM environment variable not set[/quote] 再试试reset命令

引用 1 楼 自信男孩的回复:建议使用system("clear"); MAC系统是unix（源）因此，和windows还是有区别的。 LINUX下可以用clear来清屏～ 我就是用clear，然后显示TERM environment variable not set


Question: 求助！mfc如何在单步调试时，跳过对系统dll的调试？

分清楚F10和F11 该用哪个用哪个，不要坚持一个键敲到底。


Question: 补全程序

1）int x 2) return 1;


Question: 如果用switch语句怎么做。

这个没办法用switch做，只能用if else if做，如果用switch，需要枚举每个分数，写起来不是一点的冗繁。

可以先用if ---else写一下，然后改成switch ... case形式；


Question: 完全不晓得咋做啊啊啊

百度背包问题

先遍历所有可能，得到一个或一组≤N的最大值， 然后再在上一步的结果中遍历得到总体评分最高的一个即可。


Question: base64解码的长度怎么算?

引用 5 楼 qq_40162781 的回复:[quote=引用 3 楼 舉杯邀明月 的回复:]假设编码之后的字符数是Ｌ，那么解码长度： n = L/4*3 +(3&(L-1))%3  不管BASE64文本的后面是否补了＝，上面的计算结果肯定是“原始长度”n。   为什么是+， 还有(3&(L-1))%3是什么意思。。  [/quote] 刚才把我以前写的BASE64模块找来看了一下，发现我在3楼的说法不太准确。   Ｌ的值 是BASE64编码文本去掉分隔符（按“标准”要76字符换行）、 　去掉末尾的=字符之后的“纯编码”长度值。 昨天回复时，忘记我的“中间处理层”接口函数了。

引用 5 楼 qq_40162781 的回复:[quote=引用 3 楼 舉杯邀明月 的回复:]假设编码之后的字符数是Ｌ，那么解码长度： n = L/4*3 +(3&(L-1))%3  不管BASE64文本的后面是否补了＝，上面的计算结果肯定是“原始长度”n。   为什么是+， 还有(3&(L-1))%3是什么意思。。  [/quote]  你在C版块提问，不至于看不懂 C语言格式的运算表达式吧。

引用 3 楼 舉杯邀明月 的回复:假设编码之后的字符数是Ｌ，那么解码长度： n = L/4*3 +(3&(L-1))%3  不管BASE64文本的后面是否补了＝，上面的计算结果肯定是“原始长度”n。   为什么是+， 还有(3&(L-1))%3是什么意思。。

另外： 如果BASE64文本的编码长度为Ｌ 如果： 3 & L ==1 那么： 编码长度不合法！

太帅了啊

好像字节对齐也是用这原理?

仅供参考：#include <stdio.h> #include <string.h> #include <stdlib.h>  #define BASE64_VALUE_SZ 256 int     base64_value[BASE64_VALUE_SZ]; const unsigned char alphabet[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; class Base64Utility { public:     Base64Utility();     int base64_encode(char *src, int srclen, char *dst, int tail);     int base64_decode(char *src, int srclen, char *dst); private:     void base_64_init(void); }; Base64Utility::Base64Utility() {     base_64_init(); } void Base64Utility::base_64_init(void) {     int i;      for (i = 0; i < BASE64_VALUE_SZ; i++) base64_value[i] = -1;     for (i = 0; i < 64; i++) base64_value[(int) alphabet[i]] = i;     base64_value['='] = 0; } int Base64Utility::base64_encode(char *src, int srclen, char *dst, int tail) {     int     bits, char_count, len;     char    *o_char, *lim, *o_lim;     unsigned char   c;      if ( !src || !dst) return 0;     len = srclen;     lim = src + len;     o_char = dst;     o_lim  = dst + (len*4)/3 + 1;     char_count = 0;     bits = 0;     while ( (src < lim) && (o_char < o_lim)) {         c = *(src++);         bits += c;         char_count++;         if (char_count == 3) {             *(o_char++) = alphabet[bits >> 18];             *(o_char++) = alphabet[(bits >> 12) & 0x3f];             *(o_char++) = alphabet[(bits >> 6) & 0x3f];             *(o_char++) = alphabet[bits & 0x3f];             bits = 0;             char_count = 0;         } else {             bits <<= 8;         }     }     if (char_count != 0) {         bits <<= 16 - (8 * char_count);         *(o_char++) = alphabet[bits >> 18];         *(o_char++) = alphabet[(bits >> 12) & 0x3f];         if (char_count == 1) {             if (tail) {                 *(o_char++) = '=';                 *(o_char++) = '=';             }         } else {             *(o_char++) = alphabet[(bits >> 6) & 0x3f];             if (tail) {                 *(o_char++) = '=';             }         }     }     *(o_char) = 0;     return strlen(dst); } int Base64Utility::base64_decode(char *src, int srclen, char *dst) {     int j;     unsigned int k;     int c, base_result_sz;     long val;      if (!src || !dst) return 0;     base_result_sz = srclen;     val = c = 0;     for (j = 0; *src; src++) {         k = (int) *src % BASE64_VALUE_SZ;         if (base64_value[k] < 0) continue;         val <<= 6;         val += base64_value[k];         if (++c < 4) continue;         dst[j++] = (char) (val >> 16);         dst[j++] = (val >> 8) & 0xff;         dst[j++] = val & 0xff;         val = c = 0;     }     switch (c) {         case 2://xxxxxx xx0000             dst[j++] = (val >> 4) & 0xff;         break;         case 3://XXXXXX XXxxxx xxxx00             dst[j++] = (char) (val >> 10);             dst[j++] = (val >> 2) & 0xff;         break;     }     return j; } Base64Utility b64u; #define MAXLENS 1024768 #define MAXLEND 1366360 char bufd[MAXLEND]; char bufs[MAXLENS]; FILE *fs,*fd; int fsize; int main(int argc,char *argv[]) {     if (argc<4) {     USE:         printf("%s <-e|-E|-d> srcfile desfile\n",argv[0]);         return 1;     }     if (stricmp(argv[1],"-e") && stricmp(argv[1],"-d")) goto USE;     if (0==stricmp(argv[1],"-e")) {         fs=fopen(argv[2],"rb");         if (NULL==fs) {             printf("Can not open file %s!\n",argv[2]);             return 2;         }         fsize=fread(bufs,1,MAXLENS,fs);         if (fsize<=0) {             fclose(fs);             printf("Can not read file %s!\n",argv[2]);             return 3;         }         if (MAXLENS==fsize) printf("Warning: Up to %d bytes.\n",MAXLENS);         fclose(fs);         b64u.base64_encode(bufs,fsize,bufd,('E'==argv[2][1]));         fd=fopen(argv[3],"w");         if (NULL==fd) {             printf("Can not create file %s!\n",argv[3]);             return 4;         }         fprintf(fd,"%s",bufd);         fclose(fd);     } else {//0==stricmp(argv[1],"-d")         fd=fopen(argv[2],"rb");         if (NULL==fd) {             printf("Can not open file %s!\n",argv[2]);             return 2;         }         fsize=fread(bufd,1,MAXLEND,fd);         if (fsize<=0) {             fclose(fd);             printf("Can not read file %s!\n",argv[2]);             return 3;         }         if (MAXLEND==fsize) printf("Warning: Up to %d bytes.\n",MAXLEND);         fclose(fd);         fsize=b64u.base64_decode(bufd,fsize,bufs);         fs=fopen(argv[3],"wb");         if (NULL==fs) {             printf("Can not create file %s!\n",argv[3]);             return 4;         }         if (fsize!=(int)fwrite(bufs,1,fsize,fs)) {             printf("Write %s error!\n",argv[3]);             fclose(fs);             return 5;         }         fclose(fs);     }     return 0; }

因为base64存在补=号，所以算出来的只是一个范围，长度*3/4+1最大长度，如果要具体算出来编码之前的长度，需要自行判断补=号情况减去对应的占位


Question: 为什么int变量一下子 变成29972，应该一直加1才对

仅供参考：#include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

数组最好用memset初始化一下0，这样能保证后面的数值都是空的，否则可能会出现你现在这个情况

#define _CRT_SECURE_NO_WARNINGS #include<cstdio> #include<cstring> #include<stdlib.h>  struct str {     //char a[];     char a[1024]; };   int main() {     //FILE *p;     FILE *fp;     char myfile[] = "C:\\Users\\hmc\\Desktop\\mynum.txt";      str aa;     printf("请输入字符串：");     if ((fp = fopen(myfile, "w")) == NULL)     {         printf("未找到%s", myfile);         return 0;     }     int mycout = 0;//字符串个数     scanf("%s", &aa.a);     while (strncmp(aa.a,"#", 1) != 0)     {         for (int i = 0; i < strlen(aa.a)+1; i++)         {             if (aa.a[i] >= 65 && aa.a[i] <=90)             {                 aa.a[i] += 32;             }         }         fwrite(&aa.a, strlen(aa.a)+1, 1, fp);         mycout++;         printf("mycout实时值%d ", mycout);         //printf("加32了");         scanf("%s", &aa.a);     }     fclose(fp);     printf("mycount最终值%d",mycout);      return 0; } 供参考～  数组长度需要确定的。要么定义为char a[1024];/*举例，长度可以根据需要而定*/，定义成char a[];等价定义了一个char *a;这个a是一个野指针，需要给其分配空间；两种方式选其一吧。

修改，供参考：#include<cstdio> #include<cstring> #include<stdlib.h>  struct str {        char a[256]; }; int main() {     FILE *p;     char myfile[] = "C:\\Users\\hmc\\Desktop\\mynum.txt";     str aa;     if ((p = fopen(myfile, "w")) == NULL)     {          printf("未找到%s", myfile);          return 0;     }     printf("请输入字符串：");     int mycout = 0;       //字符串个数     scanf("%s", aa.a);    //scanf("%s", &aa.a);     while (strcmp(aa.a,"#")!=0) //while (strcmp(aa.a,"#")==1)     {         for (int i = 0; i < strlen(aa.a)+1; i++)         {               if (aa.a[i] >= 65 && aa.a[i] <=90)               {                   aa.a[i] += 32;               }         }         fwrite(&aa.a, strlen(aa.a)+1, 1, p);         mycout++;         printf("mycout实时值%d ", mycout);         //printf("加32了");         scanf("%s", aa.a);//scanf("%s", &aa.a);     }     fclose(p);     printf("mycount最终值%d",mycout);          return 0; }   //请输入字符串：C:\\Users\\hmc\\Desktop\\mynum.txt # //mycout实时值1 mycount最终值1请按任意键继续. . .  //mynum.txt: //c:\\users\\hmc\\desktop\\mynum.txt

struct str { char a[]; }; 这个用法是错误的 1. 柔性数组要求 第一个元素是完整类型 并且空数组是最后一个元素 2. 柔性数组的使用方式是 用malloc等函数分配内存的时候 指定柔性数组大小 没有使用malloc等函数 无法应用柔性数组  然后 没有不固定长度的数组  哪怕是std::string 也是固定长度  遇到长度不足的情况手动重新分配内存

换了个编译器就没问题，这是为什么？


Question: 求助！C语言malloc与结构体调用导致读取字符串的字符时出错

引用 7 楼 自信男孩的回复:[quote=引用 6 楼 weixin_45710571 的回复:][quote=引用 3 楼 狐帝的回复:]代码不完整，所以只能从你现有代码来琢磨。fileData是个全局变量吧？在ReadInputFile函数里，读完文件之后，fileData.data = data，本意是想通过fileData将读入的数据带回？但是ReadInputFile的后面有free(data)，data（以及fileData.data）指向的存储区就被释放掉了，那么fileData.data就指向了无效的存储区。所以其他代码再访问fileData.data时就会出错。 原来是这样的，感谢指导！再请教一下如果不释放malloc申请过的空间，那如何才能保证程序复用时内存不泄露，代码循环时不出错呢，或者在何处释放才是正确的呢[/quote]  不在使用的时候要释放。内存泄露是因为程序在运行的时候malloc之后没有free才会出现，如果free了就不会泄露，如果程序退出了，即使不free，系统也会给予释放（系统回收）；所以，一般说内存泄露是指程序一直运行，不退出，而程序不停的申请空间，而不free；  注意释放的地址应该是malloc的地址，这个应该是相同的地址，否则会出现释放错误； malloc的空间是可以反复使用的，注意保存好malloc的地址值就好了，等不用的时候记着释放即可；[/quote] 嗯嗯，懂了，谢谢你！

引用 6 楼 weixin_45710571 的回复:[quote=引用 3 楼 狐帝的回复:]代码不完整，所以只能从你现有代码来琢磨。fileData是个全局变量吧？在ReadInputFile函数里，读完文件之后，fileData.data = data，本意是想通过fileData将读入的数据带回？但是ReadInputFile的后面有free(data)，data（以及fileData.data）指向的存储区就被释放掉了，那么fileData.data就指向了无效的存储区。所以其他代码再访问fileData.data时就会出错。 原来是这样的，感谢指导！再请教一下如果不释放malloc申请过的空间，那如何才能保证程序复用时内存不泄露，代码循环时不出错呢，或者在何处释放才是正确的呢[/quote]  不在使用的时候要释放。内存泄露是因为程序在运行的时候malloc之后没有free才会出现，如果free了就不会泄露，如果程序退出了，即使不free，系统也会给予释放（系统回收）；所以，一般说内存泄露是指程序一直运行，不退出，而程序不停的申请空间，而不free；  注意释放的地址应该是malloc的地址，这个应该是相同的地址，否则会出现释放错误； malloc的空间是可以反复使用的，注意保存好malloc的地址值就好了，等不用的时候记着释放即可；

引用 3 楼 狐帝的回复:代码不完整，所以只能从你现有代码来琢磨。fileData是个全局变量吧？在ReadInputFile函数里，读完文件之后，fileData.data = data，本意是想通过fileData将读入的数据带回？但是ReadInputFile的后面有free(data)，data（以及fileData.data）指向的存储区就被释放掉了，那么fileData.data就指向了无效的存储区。所以其他代码再访问fileData.data时就会出错。 原来是这样的，感谢指导！再请教一下如果不释放malloc申请过的空间，那如何才能保证程序复用时内存不泄露，代码循环时不出错呢，或者在何处释放才是正确的呢

调试代码的必要知识：到啥时候说啥话。 不要指望刚执行一句的时候就看见结果。

unsigned char* data;  这个也要分配内存才能存放数据的

Filep = data = NULL; 这句得分开写： Filep = NULL;  data  = NULL;


Question: 用c语言读取文本，一直都出错，到文件路径应该没问题的

或者加一句#pragma warning(disable:4996)

引用 1 楼 user-4的回复:第2行应该放在第1行的上面吧。 谢谢，可以了。

引用 4 楼 forever74的回复:[quote=引用 2 楼 qq_52473673 的回复:][quote=引用 1 楼 user-4的回复:]第2行应该放在第1行的上面吧。 貌似没区别吧，我在dev上试了一下，是可以打开的，但在visual中，就是打不开[/quote]  你得这么想：要是没区别，那你这趟就白来了。 既然来都来了，为什么不试一试再说呢？[/quote] 非常感谢大家的帮助，正如一楼所说，可以，没来的看消息，所以回复晚了，还是谢谢大家，嘻嘻

引用 2 楼 qq_52473673 的回复:[quote=引用 1 楼 user-4的回复:]第2行应该放在第1行的上面吧。 貌似没区别吧，我在dev上试了一下，是可以打开的，但在visual中，就是打不开[/quote]  你得这么想：要是没区别，那你这趟就白来了。 既然来都来了，为什么不试一试再说呢？

编译就没能成功，没能生成可执行文件，所以没有课运行的程序。如楼上所言，把第1、2行互换一下就行。

引用 1 楼 user-4的回复:第2行应该放在第1行的上面吧。 貌似没区别吧，我在dev上试了一下，是可以打开的，但在visual中，就是打不开

第2行应该放在第1行的上面吧。


Question: 求问这段代码怎么叙述运行过程

把注释抄下来，再润色一下。


Question: 求助！！！有大牛能用c语言帮帮我这个苦逼的大学生吗  上学期才学完的c

供参考：#include<stdio.h>  int fun(int n) {     if(n%2==0 || n%3==0 || n%5==0)           return 1;     else  return 0; }  int main() {     int i,cnt,n;     while(scanf("%d",&n)!=EOF && n>=1 && n<=10000){           cnt=0;           for(i=1;cnt < n;i++)               if(i==1 || fun(i)) cnt++;           printf("%d\n",i-1);     }          return 0; }


Question: nulltrp怎么意思，怎么解决，求大佬指教

nullptr是空指针的意思,类型是nullptr_t，之前使用NULL可能会出现问题

如果你只是想问nullptr是什么意思，参考https://blog.csdn.net/qq_42956179/article/details/115408545 C++11里面对于指针安全做了很大改善，NULLC++里面的宏定义其实是个0，而nullptr则为空，你可以自行看一下为什么void和NULL为什么会出现问题

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


Question: 有一个字符串，内有若干个字符，现输入一个字符，要求程序将字符串中该字符删去。用外部函数实现。

1. file2.cpp: 应该先#include <stdio.h>，否则编译失败，从而无法生成enter_string符号，会导致最终链接失败。 2. file4.cpp: 应该先#include <stdio.h>，否则编译失败，从而无法生成print_string符号，会导致最终链接失败。 3. 设定project时是不是设置成Win32或Windows应用程序了？应该设置成Console或控制台应用程序，否则就会出现找不到WinMain函数的链接错误。

几个文件必须全部编译成功后才能链接生成exe程序，你的第2 4个文件，由于没有头文件编译失败，这种去情况应先改正编译错误。

引用 3 楼 weixin_58044954 的回复:已经用extern联了呀extern 只是在这个文件里声明了这几个函数是外部的，告知这几个函数不在本部门里，至于这个外部的范围它的也不知道呢。

已经用extern联了呀

几个文件之间得让他有关联，不然它不知道到哪去找这个声明为外部的函数，无路可走。

链接错误，猜测一下，几个文件应先分别编译最后再构建，你可能没有编译其他的几个文件。


Question: 请教一个16进制问题

不是 0x2710对应的是10000，除以10，对应的是3e8。舍弃的是10进制下的最后一位。

你的意思 0x2710 转换到 0x3e 最后的8 忽略 对吗

int mmlen; struct oh {  unsigned int cm:12; } cmlen; mmlen=10000; cmlen.cm=mmlen/10;

不就是x / 10吗


Question: 有一个字符串，内有若干个字符，现输入一个字符，要求程序将该字符串中该字符删去。用外部函数实现。

重新发了个帖子，麻烦你看一下

那你把代码和编译错误都发出来


Question: while的用法求助！！！！！！！

第一个while里面不会更新ch，相当于只会从文件里读取到一个字节的数据；  第二个是循环读取文件内容的。

不要使用 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;  //... } 类似的例子还可以举很多。

第一个ch = fgetc(fp); 在while（）循环体外，ch只从文件读入一次，只要这一次不在文件尾，在while(ch!=EOF)永远成真，死循环了。

第一种写法，在while循环中，ch就没变化，当然会陷入死循环。 第二种写法，每次while循环，ch都会重新被fgetc(fp)赋值，总会读到EOF，所以就能跳出循环。


Question: 改正错误

改这样试试：#include  <stdio.h>  struct  stu{         int  id;  //学号         char name[20];//姓名         int  age;  //年龄         int  score;  //成绩 };  int  main(){              //声明函数及变量         void   readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]);         void   stdoutForStu(struct  stu  *p,  int  num);         const  int  NUM  =  2;     //学生数量         struct  stu  students[NUM]; //stu型数组         struct  stu  *p  = students;  //指向stu型一维数组型指针         char  filename[] = "ex804.txt"; //待读取的文件路径及名称          ///文件获取输入         readFileForStu(p,NUM,filename,"r");          //向屏幕输出显示         stdoutForStu(p,NUM);                  return  0; }  // //  *  函数名称：readFileForStu //  *  函数功能：从文件格式化读取数据 //  *  写入格式：共读取  num  行；每行读出一个  stu  型数据，每个成员变量之间用空格分隔 //  *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址。该数组用于保存文件读取数据 //  *  形式参数：int  num，一维数组元素个数，也即读取文件的行数 //  *  形式参数：char  filename[]，待读取的文件路径及名称 //  *  形式参数：char  mode[]，文件使用方式 //  *  返  回  值：无  void  readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]) {         //  请编程实现本函数         int i;         FILE *fp;         fp=fopen(filename,mode);         if(fp==NULL){            printf("Open file fail!\n");            return;         }         for(i=0;i<num;i++)         {          //fread(&p[i],sizeof(struct stu),1,fp);          fscanf(fp,"%d%s%d%d",&p[i].id,p[i].name,&p[i].age,&p[i].score);         }         fclose(fp); }  // //  *  函数名称：stdoutForStu //  *  函数功能：向显示器输出显示数据 //  *  输出格式：共输出  num  行；每行输出一个  stu  型数据，每个成员变量之间用空格分隔 //  *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址 //  *  形式参数：int  num，一维数组元素个数 //  *  返  回  值：无  void  stdoutForStu(struct  stu  *p,  int  num) {         //  请编程实现本函数         int i;         for(i=0;i<num;i++)             printf("%d %s %d %d\n",p[i].id,p[i].name,p[i].age,p[i].score); }  //1 libai 100 100 //2 lihei 200 200 //请按任意键继续. . .  //10001 ZhangSan 25 99 //10002 ZhaoLiu 18 100 //请按任意键继续. . .

引用 2 楼 qzjhjxj的回复:修改如下，供参考：#include  <stdio.h>  struct  stu{         int  id;  //学号         char name[20];//姓名         int  age;  //年龄         int  score;  //成绩 };  int  main(){              /*声明函数及变量*/         void   readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]);         void   stdoutForStu(struct  stu  *p,  int  num);         const  int  NUM  =  2;     //学生数量         struct  stu  students[NUM]; //stu型数组         struct  stu  *p  = students;  //指向stu型一维数组型指针         char  filename[] = "ex804.txt"; //待读取的文件路径及名称          /*从文件获取输入*/         readFileForStu(p,NUM,filename,"r");          /*向屏幕输出显示*/         stdoutForStu(p,NUM);                  return  0; }  /*   *  函数名称：readFileForStu   *  函数功能：从文件格式化读取数据   *  写入格式：共读取  num  行；每行读出一个  stu  型数据，每个成员变量之间用空格分隔   *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址。该数组用于保存文件读取数据   *  形式参数：int  num，一维数组元素个数，也即读取文件的行数   *  形式参数：char  filename[]，待读取的文件路径及名称   *  形式参数：char  mode[]，文件使用方式   *  返  回  值：无     */ void  readFileForStu(struct  stu  *p,  int  num,  char  filename[],char  mode[]) {         //  请编程实现本函数         int i;         FILE *fp;         fp=fopen(filename,mode);         if(fp==NULL){            printf("Open file fail!\n");            return;         }         for(i=0;i<num;i++)         {          fread(&p[i],sizeof(struct stu),1,fp);         }         fclose(fp); }  /*   *  函数名称：stdoutForStu   *  函数功能：向显示器输出显示数据   *  输出格式：共输出  num  行；每行输出一个  stu  型数据，每个成员变量之间用空格分隔   *  形式参数：struct  stu  *  p，指向  stu  型一维数组首地址   *  形式参数：int  num，一维数组元素个数     *  返  回  值：无     */ void  stdoutForStu(struct  stu  *p,  int  num) {         //  请编程实现本函数         int i;         for(i=0;i<num;i++)             printf("%d %s %d %d\n",p[i].id,p[i].name,p[i].age,p[i].score); }  //1 jjjj 18 90 //2 kkkk 19 91 //请按任意键继续. . . 大佬，我把你的程序放在测试平台上跑了一遍。输出结果不正确 测试数据1输出错误   错误输出： 1768693809 bai 100 1002 lihei 200 200 540028978 31580664196240  0 0 期望输出： 1 libai 100 1002 lihei 200 200 测试数据2输出错误   错误输出： 808464433 1 ZhangSan 25 9910002 ZhaoLiu 18 100@ 1512059440 1282367848824210793 8 100@ 0 0 期望输出： 10001 ZhangSan 25 9910002 ZhaoLiu 18 100

fp=fopen("ex804.txt","mode");  这条语句不会，应该是fp=fopen("ex804.txt",mode); 这条语句的错误会导致文件无法打开，导致fp为NULL，后面就可能会引发异常。


Question: 新手小白，想询问一下，哪里错了

猜一猜，下面的程序片断将打印什么内容？ int m = 5;  switch (0) {     m ++;     default: printf ("%d\n", m); }

引用 2 楼 user-2 的回复:case ' b>max':  这里的类型不对，'b>max' 是什么类型呢，不是 字符型，也不是 字符串，case 后面跟整形才对。 这种说法是不正确的。  首先，case 后面必须跟整型常量表达式（而不是通常意义上的整型）。  其次，'b>max' 是字符常量，它的类型是 int 。因此，'b>max' 的类型是 int 。根据整型常量表达式的定义，'b>max' 也是整型常量表达式。  所以 case 'b>max' 在语法上是没有问题的。  问题在哪里呢？对于单字符的字符常量，比如 'x'，在编译时转换为 int 类型的字符编码。但是，对于包含多个字符的字符常量，比如 'abcd'，在编译时如何打包成 int 类型的编码，由编译器（C实现）决定。有很多机器上，int 类型的长度是 4 个字节，正好可以编码4个字符，但超过4个字符就会出现警告。  来看下面这个例子，这个例子可以正常执行并打印 “Okay.”： switch ('b>ma') {     case 'b>ma' : printf ("Okay.\n"); } 在很多机器上，这个示例不会产生“字符太长”的警告，但有可能出现“字符常量由多个字符组成”的警告。但相对于字符太长的警告，后面一个警告是可以接受的。

谢谢侬，嘿嘿

供参考：#include<stdio.h>  int main() {    int a,b,c;    printf("请输入三个数:\n");    scanf("%d%d%d",&a,&b,&c);    printf("最大值:%d\n",a>b?(a>c?a:c):(b>c?b:c));        return 0; }


Question: 看不懂指针，唉！

编译不过与指针没关系 ，执行语句应放在函数定义中，你没写函数定义，啥编译器也通不过。

TC编译器是不是目前只有学校里教学会使用了。 建议使用VS编译调试工具；  代码没写在函数里呢？看着不符合语法规则～ p = a;只能出现在函数里。int *p, a[3];可以放在函数外，因为这是定义，定义的全局变量；

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

换一个编辑器吧

应该用 #include <stdio.h> ... <>和""内的头文件查找路径不一样


Question: 哪位大神帮忙看一下哪点错了。

引用 1 楼 自信男孩 的回复:struct studeng stud[n];这儿有问题呢。n是随机值，不确定大小；C语言不支持不确定的数组长度； 可以考虑用动态申请空间的方式来实现：  struct studeng *stud = NULL;  在scanf后面加上一句申请空间的语句：  stud = (struct student *)malloc(sizeof(struct student)); if (!stud)     exit(0);  后面对stud可以以数组的形式访问和操作；  最后注意不适用stud时，记得free(stud);释放；  stud = (struct student *)malloc(sizeof(struct student) * n); if (!stud)     exit(0); 用这个，上面那个有问题，忘了乘于n了。这个n是输入之后的n；


Question: 怎么调用随机四参数法生成多孔介质

师兄，我也想问这个问题，怎么把随机四参数的代码和LBM的代码进行联动啊？您这个问题解决了么？

老哥，现在会用了吗？方便加个QQ吗？1974595531


Question: 请教一下，为什么我的sprintf转化double类型数据的时候全成0了？

引用 7 楼 狐帝 的回复:单看这段代码，没什么问题。恐怕还是有其他的代码影响到了tmpbuffer的内容。 建议测试一下，楼主的代码是有问题的。%.15lf是有必要的。从输出的默认精确位数上可以理解是需要吧

引用 6 楼 狐帝 的回复:[quote=引用 5 楼 自信男孩 的回复:][quote=引用 3 楼 qzjhjxj 的回复:]这样改下，供参考：#include<stdio.h> int main() {     int    i;     char   tmpbuffer[8][20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466,0.02414235618335,                        -0.158289852824976, 1.54926741892562, 0.162671275351189,0.55};    for (i=0;i<8;i++)    {        sprintf(tmpbuffer[i],"%18.15f",U13Coef[i]);        printf("%s\n",tmpbuffer[i]);    }        return 0; }   // -0.000000428344451 // 0.000041556454936 //-0.001508777414466 // 0.024142356183350 //-0.158289852824976 // 1.549267418925620 // 0.162671275351189 // 0.550000000000000 //请按任意键继续. . . 注意列的长度，18+15>20，所以20的长度是不合适的。[/quote] %18.15f 是指总长度18个字符，其中小数点后占15个字符。总长并不是18+15。[/quote] 用到sprintf，哪儿18+15个字符不是占18+15个字节吗？当然楼主的例子整数部分没有那么大，我的考虑是如果是整数部分比较大，这样就会有问题的～

引用 5 楼 自信男孩 的回复:[quote=引用 3 楼 qzjhjxj 的回复:]这样改下，供参考：#include<stdio.h> int main() {     int    i;     char   tmpbuffer[8][20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466,0.02414235618335,                        -0.158289852824976, 1.54926741892562, 0.162671275351189,0.55};    for (i=0;i<8;i++)    {        sprintf(tmpbuffer[i],"%18.15f",U13Coef[i]);        printf("%s\n",tmpbuffer[i]);    }        return 0; }   // -0.000000428344451 // 0.000041556454936 //-0.001508777414466 // 0.024142356183350 //-0.158289852824976 // 1.549267418925620 // 0.162671275351189 // 0.550000000000000 //请按任意键继续. . . 注意列的长度，18+15>20，所以20的长度是不合适的。[/quote] %18.15f 是指总长度18个字符，其中小数点后占15个字符。总长并不是18+15。

引用 3 楼 qzjhjxj 的回复:这样改下，供参考：#include<stdio.h> int main() {     int    i;     char   tmpbuffer[8][20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466,0.02414235618335,                        -0.158289852824976, 1.54926741892562, 0.162671275351189,0.55};    for (i=0;i<8;i++)    {        sprintf(tmpbuffer[i],"%18.15f",U13Coef[i]);        printf("%s\n",tmpbuffer[i]);    }        return 0; }   // -0.000000428344451 // 0.000041556454936 //-0.001508777414466 // 0.024142356183350 //-0.158289852824976 // 1.549267418925620 // 0.162671275351189 // 0.550000000000000 //请按任意键继续. . . 注意列的长度，18+15>20，所以20的长度是不合适的。

#include <stdio.h>  int main(void) {     int i;     //char tmpbuffer[20];     char tmpbuffer[64];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466, 0.02414235618335,-0.158289852824976, 1.54926741892562, 0.162671275351189, 0.55};      for (i=0; i<8; i++) {         sprintf(tmpbuffer,"%.15lf",U13Coef[i]);         puts(tmpbuffer);     }     return 0; } 供参考～ 注意小数点后的保留位数；  默认是6位，多余6位的不显示； 自然不转换到buffer里。

#include <stdio.h> int main() {     char tmpbuffer[20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466, 0.02414235618335,-0.158289852824976, 1.54926741892562, 0.162671275351189, 0.55};     for (int i=0;i<8;i++) {         sprintf(tmpbuffer,"%.15lf",U13Coef[i]);         printf("i:%d tmpbuffer:[%s]\n",i,tmpbuffer);     }     return 0; } //i:0 tmpbuffer:[-0.000000428344451] //i:1 tmpbuffer:[0.000041556454936] //i:2 tmpbuffer:[-0.001508777414466] //i:3 tmpbuffer:[0.024142356183350] //i:4 tmpbuffer:[-0.158289852824976] //i:5 tmpbuffer:[1.549267418925620] //i:6 tmpbuffer:[0.162671275351189] //i:7 tmpbuffer:[0.550000000000000] //

#include <stdio.h> int main() {     char tmpbuffer[20];     double U13Coef[8]={-0.000000428344451, 0.000041556454936,-0.001508777414466, 0.02414235618335,-0.158289852824976, 1.54926741892562, 0.162671275351189, 0.55};     for (int i=0;i<8;i++) {         sprintf(tmpbuffer,"%.15lg",U13Coef[i]);         printf("i:%d tmpbuffer:[%s]\n",i,tmpbuffer);     }     return 0; } //i:0 tmpbuffer:[-4.28344451e-07] //i:1 tmpbuffer:[4.1556454936e-05] //i:2 tmpbuffer:[-0.001508777414466] //i:3 tmpbuffer:[0.02414235618335] //i:4 tmpbuffer:[-0.158289852824976] //i:5 tmpbuffer:[1.54926741892562] //i:6 tmpbuffer:[0.162671275351189] //i:7 tmpbuffer:[0.55] //


Question: 【求助】写一个统计文件中单词和字符个数的程序

k=open("in.txt","r")j=k.read()x=len(j)a=0for i in range(0,x+1):    if 65<=ord(j[i])<=90 or 97<=ord(j[i])<=122:        if ord(j[i+1])<65 or 90<ord(j[i+1])<97 or ord(j[i+1])>122:            a=a+1print(str(a)+" "+str(x-1))

int main()                 //写一个统计文件中单词和字符个数的程序。在此，单词指的是仅由字母组成的串。诸如is7years这样的串按照两个单词计算。{ FILE *f; char word[100]; char c; int i =0,len,m=0,n=0; f = fopen("in.txt","r"); while((c=fgetc(f))!=EOF) {                                       word[i++] = c; } word[i]='\0'; len = strlen(word); /*printf("%d\n",len);*/ for(i=0;i<len;i++) {     if(word[i]!='\0') n++;      if((i==len-1) && ((word[i+1]>='a' && word[i+1]<='z') || (word[i+1]>='A' && word[i+1]<='Z')))     {         m++;         break;          }     if(((word[i]>='a' && word[i]<='z') || (word[i]>='A' && word[i]<='Z')))     {     if(((word[i+1]>='a' && word[i+1]<='z') || (word[i+1]>='A' && word[i+1]<='Z')))     {              continue;     }else{             m++;          }      } } printf("%d %d",m,n); fclose(f);  }

k=open("in.txt","r") j=k.read() x=len(j) a=0 for i in range(0,x+1):     if 65<=ord(j[i])<=90 or 97<=ord(j[i])<=122:         if ord(j[i+1])<65 or 90<ord(j[i+1])<97 or ord(j[i+1])>122:             a=a+1 print(str(a)+" "+str(x-1))

写错了

供参考：#include <stdio.h> #include <stdlib.h>  int main() {     char fname[]="in.txt";     char str[1024];     int  i,sum=0,k=0,n;     FILE *fp;     if((fp = fopen(fname,"r")) == NULL){         printf("cannot open the file!");         exit(0);     }     i=0;     while((str[i++]=fgetc(fp))!=EOF);//读入文件到数组     str[i-1] = '\0';     fclose(fp);     n = i;     for(i=0;i<n;i++)  //文件内容输出         printf("%c",str[i]);     for(i=0;i<n;i++){  //计算单词个数         if((str[i]<='z'&&str[i]>='a')||(str[i]<='Z'&&str[i]>='A')) {             k = 1;             continue;         }         if(k) sum++;         if(str[i]>'z'||str[i]<'a'||str[i]>'Z'||str[i]<'A'){             k = 0;             continue;         }     }     printf("\n共%d个单词,共%d个字符\n",sum,n-1);          return 0; }   //I am an (BeiHang)student.is7years //共7个单词,共33个字符 //请按任意键继续. . .

#include <stdio.h> #include <ctype.h> #include <string.h> #include <errno.h>  #define     FILE_PATH   "in.txt" #define     WORD_LEN    64 #define     METHOD_ONE  int main() {     FILE *fp; #ifdef METHOD_ONE     int flag = 0; #else     int pre_ch = 0; #endif     int ch, word_cnt = 0, ch_cnt = 0;     char word[WORD_LEN];     int i = 0;      fp = fopen(FILE_PATH, "r");     if (!fp) {         fprintf(stderr, "open %s error: %s\n", FILE_PATH, strerror(errno));         return -1;     }      while ((ch = fgetc(fp)) != EOF) {         if (ch == '\n')             continue;         ch_cnt++; #ifdef METHOD_ONE         if (isalpha(ch)) {             flag = 1;             if (i >= WORD_LEN - 1) {                 word[i] = 0;                 puts(word);                 fprintf(stdout, "Word is too length!\n");                 i = 0;                 continue;             }             word[i++] = ch;         } else if (!isalpha(ch) && flag) {             word_cnt++;             word[i] = '\0';             puts(word);             i = 0;             flag = 0;         } #else         if (isalpha(ch)) {             if (i >= WORD_LEN - 1) {                 word[i] = 0;                 puts(word);                 fprintf(stdout, "Word is too length!\n");                 i = 0;                 continue;             }             word[i++] = ch;         }          if (!isalpha(ch) && isalpha(pre_ch)) {             word_cnt++;             word[i] = 0;             i = 0;             puts(word);         }         pre_ch = ch; #endif     }      fclose(fp);      printf("word:%d, ch:%d\n", word_cnt, ch_cnt);      return 0; } 供参考～


Question: srand((unsigned)time(NULL))；如何声明time

缺少头文件吧，看看引入的头文件里有没time.h吧

好了，谢谢各位

在随机数里要用time的话，就要#include <time.h>

还有上边的[M]我自己定义成了int型函数，不知道对不对


Question: 离散数学

引用 1 楼 user-1的回复:穷举法，不行么？ 可以可以，之前两个字母写反了，一直出错

穷举法，不行么？


Question: 大佬，教教孩子吧

引用 5 楼 qzjhjxj 的回复:[quote=引用 4 楼 qq_57019597 的回复:] 这种是什么情况呀 哭了 头文件：Windows下为--> windows.h，Sleep是区分大小写的，有的编译器是大写，有的是小写。  第2行改为：  #include<windows.h>     第19行：Sleep(1); 第16行改为：if(fabs(x-1)<1e-6){  [/quote] 懂了懂了，谢谢

引用 4 楼 qq_57019597 的回复: 这种是什么情况呀 哭了 头文件：Windows下为--> windows.h，Sleep是区分大小写的，有的编译器是大写，有的是小写。  第2行改为：  #include<windows.h>     第19行：Sleep(1); 第16行改为：if(fabs(x-1)<1e-6){

这种是什么情况呀 哭了

谢谢你们啦

#include <stdio.h> #include <unistd.h> #include <math.h>  int main(void) {     int i, j, k, z;     float x;      for (i = 1; ;i++)         for (j = 1; j <= i;j++)             for (k = 1; k <= j; k++)                 for (z = 1; z <= k; z++) {                     x = 1.0/i + 1.0/j + 1.0/k + 1.0/z;                      if (fabsf(x - 1) < 1e-6) {                         printf("%d, %d, %d, %d\n", i, j, k, z);                         printf("%.2f+%.2f+%.2f+%.2f = %.2f\n", 1.0/i, 1.0/j, 1.0/k, 1.0/z, x);                         sleep(1);                         //return 0;                     }                 }      return 0; } 供参考～  sleep需要等待一个一个的输出～

float a = 4, b = 4, c = 4,d = 4; 写完手工


Question: C语言分割字符串strtok和strsep

感谢楼上两位的指导，收获很大。 谢谢。

仅供参考：#include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else                     return string; } void main() {     strcpy(string,"A \tstring\t\tof ,,tokens\n\nand some  more tokens, ");     strcpy(seps1,",\n");strcpy(seps2," \t");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234| LIYI|China | 010 |201110260000|OK");     strcpy(seps1,"|");strcpy(seps2," ");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234|LIYI||010|201110260000|OK");     strcpy(seps1,"");strcpy(seps2,"|");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234|LIYI||010|201110260000|OK");     strcpy(seps1,"|");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",a");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",a,,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,a,,b,,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,,");     strcpy(seps1,",");strcpy(seps2," ");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     } } // //[A      string          of ,,tokens // //and some  more tokens, ] //Tokens: // <A> <string> <of> <> <tokens> <> <and> <some> <more> <tokens> <> //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234> <LIYI> <China> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <> <010> <201110260000> <OK> //[a] //Tokens: // <a> //[a,b] //Tokens: // <a> <b> //[a,,b] //Tokens: // <a> <> <b> //[,a] //Tokens: // <> <a> //[a,] //Tokens: // <a> <> //[,a,,b] //Tokens: // <> <a> <> <b> //[,,a,,b,,] //Tokens: // <> <> <a> <> <b> <> <> //[,] //Tokens: // <> <> //[,,] //Tokens: // <> <> <> //[,,,] //Tokens: // <> <> <> <>

strdup返回是malloc的首地址，因此str会跟着变化，但是str_bak会保存的malloc的首地址，这样free(str_bak);就不会有问题。free的参数是malloc返回的值（地址值）；     引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h> #include <string.h>  int main(int arg, const char *argv[]) {     //char* string = strdup( "aaa#test#test#");          /*字符串不能为常量，所以strdup*/     char *str,  *str_bak;     char* p;      str = str_bak = strdup("aaa#test#test#");          /*字符串不能为常量，所以strdup*/      while((p = strsep(&str, "#")) != NULL)     {         printf("%s\n", p);     }      free(str_bak);      return 0;  }


Question: 从大到小排序，为啥我的结果是错的

万分感谢，嘿嘿

if (k != i)引用缺少大括号  for (i = 0; i < 7; i++) {     k = i;     for (j = i + 1; j < 7; j++)         if (a[j] > a[k])             k = j;     if (k != i)     {         t = a[k];         a[k] = a[i];         a[i] = t;     } }

引用 2 楼 自信男孩 的回复:#include<stdio.h>   //void main() int main() {     int a[7]={15,34,6,27,48,4,20},i,j,k,t;     printf("排序前的数列：");     for(i=0;i<7;i++)         printf("%5d",a[i]);     for(i=0;i<7;i++)     {         k=i;         for(j=i+1;j<7;j++)             if(a[j]>a[k])                 k=j; #if 0         if(k!=i){             t=a[k];a[k]=a[i];a[i]=t;         } #else         if (k != j)             t = a[k], a[k] = a[i], a[i] = t; #endif     }     printf("\n从大到小排序后（选择法）\n");     for(i=0;i<7;i++)         printf("%5d",a[i]);      printf("\n");      return 0; } 供参考～  少一个大括号，或者用逗号代替分号; 把if (k != j)改成if (k != i)因为上面初始的是k = i;

把你的内层for循环里第二个if后交换的部分，三个语句加上花括号，那是个整体  if(k!=i)  { t=a[k];a[k]=a[i];a[i]=t; }

修改如下，供对照：#include<stdio.h> void main() {     int a[7]={15,34,6,27,48,4,20},i,j,k,t;     printf("排序前的数列：");     for(i=0;i<7;i++)         printf("%5d",a[i]);     for(i=0;i<7-1;i++)     {         k=i;         for(j=i+1;j<7;j++)            if(a[j]>a[k]) k=j;         if(k!=i)         {            t   =a[k];            a[k]=a[i];            a[i]=t;         }     }     printf("\n从大到小排序后（选择法）\n");     for(i=0;i<7;i++)         printf("%5d",a[i]);     printf("\n");      }


Question: 请问这道题答案为什么是20？

夜已深，上面的发言有一些手误的地方。  规则一：除非明确指定，否则，子表达式的值计算和副作用是无序的； 规则二：对运算符的操作数的值计算，前序于运算符本身的值计算（也就是整个表达式的值）。  对于表达式 p -> age = p -> age ++ 来说，子表达式 p -> age ++ 的值计算用 V++ 表示，而 S++ 代表它的副作用；整个赋值表达式的副作用记为 S=。那么，依据规则，这里有两种可能的顺序：  先 V++（20），再 S++ （21），最后 S= （20）  或者  先 V++（20），再 S=（20），最后 S++（21）。  给赵4老湿点赞吧，我是代替赵老湿回答问题的。

p->age = p->age++;自增是有副作用的。要么p->age++;要么p->age = p->age + 1;楼主题目里的写法不常见，结果不好理解和推理，因为有矛盾在里面；  如果是20，那么p->age++的++最终要计算的。如果是21，那么就是先以p->age++为整体，然后再算++，相当于写了2次的age。

引用 1 楼 浪客 的回复:++在后面，先赋值再+1 我代表赵4老湿指出你的两点错误。  首先，表达式 p -> age = p -> age ++ 的行为是未定义的。最后输出的结果可能是 20，也可能是 21。  其次，说先 ++ ，再赋值，这是没有任何依据的。  后缀递增表达式的值是递增前的原值，同时还有修改操作数存储值的副作用。所以，从总体上，表达式 p -> age = p -> age ++ 有三个基本动作：  1，计算表达式 p -> age ++ 的值。这个值是结构成员 age 的原始值 20； 2，表达式 p -> age ++ 发起一个副作用，这会修改结构成员 age 的存储值，修改为 21； 3，表达式  p -> age = p -> age ++ 发起一个副作用，用子表达式 p -> age ++ 的值修改赋值运算符左边的 p -> page，修改为 20。 注意，表达式   p -> age = p -> age ++ 也要计算一个值，它是 p -> page 被赋值后的值，但被丢弃，所以不用管。  以上三个动作按什么顺序发生呢？按照规定，必须先计算运算符操作数的值。总体上，先计算子表达式 p -> age ++ 的值，这个值是 20。所以，这三个动作发生的次序可能是 2 -> 1 -> 3 也可能是 2 -> 3 -> 1 不管哪种顺序，成员 age 都会被写入两次，但最终结果不同。如果是第一种顺序，那么，成员 age 最终的值是 20；如果是第二种顺序，则成员 age 最终的值是 21。

++在后面，先赋值再+1


Question: 警告处理

引用 13 楼 赵4老师 的回复:被鄙视相对被无视还是要好很多。我的阿Q精神胜利法又奏效了。 赵4老湿，你个糟老头子，坏得很。朕要忙去了，过半个月再来看你们都咧咧啥了。

被鄙视相对被无视还是要好很多。我的阿Q精神胜利法又奏效了。

引用 9 楼 赵4老师 的回复:我要说的话别人都替我说完了。 “别人”？太不礼貌了。赵4，还老湿呢，朕鄙视你。

引用 8 楼 均陵鼠侠的回复:[quote=引用 5 楼 佛系咸鱼en 的回复:][quote=引用 楼主 佛系咸鱼en的回复:]出现这个警告该如何处理，求指点 for (int j = 0; j < 20; ++j)  		{ 			if (d[i] == j) 			{ 				k[i] = j; 				break; 			} 			else if (d[i] > j && d[i] < j + 1) //其中数组d为double在j+1处有误 			{ 				k[i] = j + 1; 				break; 			}  		}[/quote]  窝哈哈哈，原来如此。赵4老湿将会告诉你，对于表达式 d [i] < j + 1 来说，依据常规算术转换（Usual arithmetic conversions）的规则，要先计算子表达式 d [i] 和 j + 1 的值，再将这两个值转换为相同的类型，然后进行比较。  子表达式 d [i] 的结果类型是 double，先按下不表；  在子表达式 j + 1 中，子表达式 j 的类型是 int ，常量 1 的类型也是 int，相加后的结果类型是 int。  如此一来，需要将子表达式 j + 1 的结果从它原来的 int 类型转换为 double 类型。  但是，在计算子表达式 j + 1 的时候，如果 j 的值是 int 类型的最大值，则这个计算可能会溢出。在这种情况下，编译器就可能会倾向于认为，既然表达式 j + 1 的结果迟早要转换为 double ，那么，何不将 j 或者 1 提前转换为 double 呢？这样就可以避免溢出。例如： d [i] < (double) j + 1; 或者 d [i] < j + 1.0; 不管是采用哪一种方式，对于加法运算来说，也是先进行常规算术转换，将两个操作数都转换为 double 类型，于是相加的结果自然是不会溢出的、double 类型的值。[/quote] 太详细了，非常感谢，比心❤

引用 9 楼 赵4老师的回复:我要说的话别人都替我说完了。 你们两个太好了，感谢，比心❤

我要说的话别人都替我说完了。

引用 5 楼 佛系咸鱼en 的回复:[quote=引用 楼主 佛系咸鱼en的回复:]出现这个警告该如何处理，求指点 for (int j = 0; j < 20; ++j)  		{ 			if (d[i] == j) 			{ 				k[i] = j; 				break; 			} 			else if (d[i] > j && d[i] < j + 1) //其中数组d为double在j+1处有误 			{ 				k[i] = j + 1; 				break; 			}  		}[/quote]  窝哈哈哈，原来如此。赵4老湿将会告诉你，对于表达式 d [i] < j + 1 来说，依据常规算术转换（Usual arithmetic conversions）的规则，要先计算子表达式 d [i] 和 j + 1 的值，再将这两个值转换为相同的类型，然后进行比较。  子表达式 d [i] 的结果类型是 double，先按下不表；  在子表达式 j + 1 中，子表达式 j 的类型是 int ，常量 1 的类型也是 int，相加后的结果类型是 int。  如此一来，需要将子表达式 j + 1 的结果从它原来的 int 类型转换为 double 类型。  但是，在计算子表达式 j + 1 的时候，如果 j 的值是 int 类型的最大值，则这个计算可能会溢出。在这种情况下，编译器就可能会倾向于认为，既然表达式 j + 1 的结果迟早要转换为 double ，那么，何不将 j 或者 1 提前转换为 double 呢？这样就可以避免溢出。例如： d [i] < (double) j + 1; 或者 d [i] < j + 1.0; 不管是采用哪一种方式，对于加法运算来说，也是先进行常规算术转换，将两个操作数都转换为 double 类型，于是相加的结果自然是不会溢出的、double 类型的值。

警告的内容是让你用4字节存储的数据改成8字节存储，因为已经溢出了。贴代码吧，或许更好的解决问题～

short int si; int i; i=(int)si+10000;

Warning C26451

引用 1 楼 user-4的回复:Warning C26451 有看过，有点无从下手

引用 4 楼 均陵鼠侠的回复:[quote=引用 2 楼 赵4老师 的回复:]short int si; int i; i=(int)si+10000; 不得了，赵4老湿终于回来了。大家快来看呐，别让他跑了！ short int si; int i; i = (int) si + 10000; 嘻，赵老湿你是认真的吗？ 变量 si 没有初始化或者赋值，而且，10000 是一个整型常量，它的类型是 int。在做这个加法运算时， 要对变量 si 的值做整型提升。提升之后，两个操作数的类型相同，不再进一步转换，直接做加法。  当然，赵老湿说这我知道，我只是做一个例子来说明，不要在意这些细节。不过我有一个更好的例子： char c; int i = 50; c = i + 60ULL; 赵老湿你看，这个例子多明显呐。唉，不过楼主的信息不完整，人家写的也许并不是 C 语言程序。[/quote] 是C语言程序

引用 楼主 佛系咸鱼en的回复:出现这个警告该如何处理，求指点 for (int j = 0; j < 20; ++j)  		{ 			if (d[i] == j) 			{ 				k[i] = j; 				break; 			} 			else if (d[i] > j && d[i] < j + 1) //其中数组d为double在j+1处有误 			{ 				k[i] = j + 1; 				break; 			}  		}

引用 2 楼 赵4老师 的回复:short int si; int i; i=(int)si+10000; 不得了，赵4老湿终于回来了。大家快来看呐，别让他跑了！ short int si; int i; i = (int) si + 10000; 嘻，赵老湿你是认真的吗？ 变量 si 没有初始化或者赋值，而且，10000 是一个整型常量，它的类型是 int。在做这个加法运算时， 要对变量 si 的值做整型提升。提升之后，两个操作数的类型相同，不再进一步转换，直接做加法。  当然，赵老湿说这我知道，我只是做一个例子来说明，不要在意这些细节。不过我有一个更好的例子： char c; int i = 50; c = i + 60ULL; 赵老湿你看，这个例子多明显呐。唉，不过楼主的信息不完整，人家写的也许并不是 C 语言程序。


Question: 求帮助

你得贴运行图，才知道是向左错还是向上错的。

scanf("%d\n",&a[i]); 试试？

从代码上看没什么问题的，不知道你的输入数据是怎么样的，结果不对又是什么内容，所以贴出你运行时的测试数据和结果～


Question: C语言程序设计题，帮帮忙。

老赵比曹操跑的快~

引用 4 楼 lin5161678 的回复:[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h>  int count(int n);  int main() {     int m;      scanf("%d", &m);      printf("%d\n", count(m));     return 0; }  int count(int n) {     static int bit;     if (n == 0)         return 0;     bit++;     count(n/10);      return bit; }  供参考～不应该使用static 这样写 调用2次就错了[/quote] 考虑改进呀，没有不应该，只有做不好。   #include <stdio.h>  static int bit; int count(int n);  int main() {     int m, ret;      do {         ret = scanf("%d", &m);         printf("%d\n", count(m));         bit = 0;     } while (ret == 1);      return 0; }  int count(int n) {     if (n == 0)         return 0;     bit++;     count(n/10);      return bit; } 供参考～

引用 1 楼 自信男孩 的回复:#include <stdio.h>  int count(int n);  int main() {     int m;      scanf("%d", &m);      printf("%d\n", count(m));     return 0; }  int count(int n) {     static int bit;     if (n == 0)         return 0;     bit++;     count(n/10);      return bit; }  供参考～不应该使用static 这样写 调用2次就错了

引用 2 楼 早打大打打核战争 的回复:int count(int n) {   return n < 10 ? 1 : count(n / 10) + 1; } 你这是抄袭我已经想好的，但还没有发表出来的答案！我代表赵4老湿严肃滴批评你！

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

引用 3 楼 均陵鼠侠 的回复:[quote=引用 2 楼 早打大打打核战争 的回复:]int count(int n) {   return n < 10 ? 1 : count(n / 10) + 1; } 你这是抄袭我已经想好的，但还没有发表出来的答案！我代表赵4老湿严肃滴批评你！[/quote]  那也应该跟老赵没关系吧~


Question: 64位全FF左右移64位还是全FF是为什么？

引用 2 楼 user-2 的回复:任何情况下，若 rhs 为负或大于或等于提升后的 lhs 中的位数，则行为未定义。  https://zh.cppreference.com/w/c/language/operator_arithmetic 引用 3 楼 自信男孩 的回复:https://blog.csdn.net/huqinwei987/article/details/70941199 供参考～  感谢两位的回答。结帖撒花。

上边是GDB调试打印信息，下边是源码，就这几行


Question: R7-7 找出数组中元素的最大数，并指出其位置 (10 分)

#include<stdio.h> #include<string.h>  #define MAX_SIZE    10  int main(void) {     int array[MAX_SIZE];     int i, idx = 0;      for (i = 0; i < MAX_SIZE; i++) {         scanf("%d", &array[i]);         if (array[i] > array[idx])             idx = i;     }       printf("No.%d = %d\n", idx+1, array[idx]);     return 0; }   供参考～  如果在数组内有多个相同的最大值，那么需要特殊处理一下，楼主可以自己试着修改一下～


Question: Python：随机产生10个100以内的整数，找出差值相差最小的两个整数。

这是C/C++的板块，你提用python？C语言可以实现一下

import random origin_list = [random.randint(0, 99) for i in range(10)] print("10个100以内的随机整数是：", origin_list) origin_list.sort() dif_list = [[origin_list[i] - origin_list[i-1], (origin_list[i], origin_list[i-1])] for i in range(1, len(origin_list))] dif_list.sort(key=lambda x: x[0]) result = [i[1] for i in dif_list if i[0] == dif_list[0][0]] print("差值最小的两个数是：", result, ",其差为：", dif_list[0][0])


Question: 求助！！！！使用c/c++读取16进制文件问题

解决链接： Java实现将16进制转10进制浮点型输出到文件中： https://blog.csdn.net/weixin_43917334/article/details/117033747 c语言16进制转txt可读文件： https://blog.csdn.net/weixin_43917334/article/details/117033192

FILE *fp=fopen("d.txt","w"); fprintf(fp,"%g\n",f); fclose(fp);

将起始地址对应的数强制类型转换为float *类型后，取其值即可。如果字节序反了，先颠倒一下。 float f; unsigend char b[4]={0xBA,0x12,0x2A,0x43}; f=*(float *)&b[0];

先读取到缓存里（按照字符串），然后可以考虑调用sscanf，转换成对应数值，memcpy到int数据内（4个一组）

已解决：方案  使用c语言把dat文件转txt文件然后使用Java按行读取txt，将每8个字符串进行一次转换


Question: 输入正整数n，计算s = 1/1! + 1/2! + 1/3! + ……+ 1/n!的值。

???有毒

楼主什么问题？头文件写到函数内，没见过这么写的呢。

供参考：#include<stdio.h>  int main() {     int    j,k,n;     double f,s;      scanf("%d",&n);     s=0.0;          //2分     for(k=1;k<=n;k++){         f=1.0;      //2分         for(j=1;j<=k;j++)//3分            f *= j;   //3分         s=s+1.0/f;     }     printf("sum=%f\n",s);          return 0; }

厉害


Question: 程序运行时出现堆已损坏

应该是文件路径问题吧，可以通过strerror(errno);看一下fopen打开失败的原因。

已经解决了，但是无满意结帖不退分，不想浪费分数，随便来几个人我把分散一下


Question: 大佬们求助

供参考：//1.输出1~100之间 各位数的乘积 > 各位数的和 的数  #include<stdio.h>  int fun(int n) {     int sum=0,product=1,m;     while(n){           m = n%10;           product *= m;           sum += m;           n /= 10;     }     if(product > sum)        return 1;     else        return 0; }  int main() {     int i,j=0;     for(i=1;i<100;i++)         if(fun(i))printf("%d%c",i,++j%9!=0?' ':'\n');         return 0; } //2.哥德巴赫猜想  #include<stdio.h>  int  isPrime(int n) {     int i;     if(n<=3) return n>1;     for(i=2;i*i<=n;i++)        if(n%i == 0) return 0;     return 1; }  int main() {     int i,j;     for (i=4;i<=20;i+=2){         for(j = i/2; j >= 2; j--){             if(isPrime(j) && isPrime(i-j)){                printf("%2d = %2d + %2d\n",i,j,i-j);//输出                break;             }         }     }          return 0; }

第一题   void test() {     int n,k,s;     for(n=11; n<100; n++)     {         k=(n%10)*(n/10);         s=n%10+n/10;         if(k>s)         {             printf("%d\n",n);         }     } }


Question: 单片机数码管显示万年历

单片机也要说明是哪类的,万年历也要说明是否含农历.

不会的时候，基础总要会的，上网找个别人做的例程，运行仿真，结合现象来看代码，理解一点后，尝试 修改代码仿真测试

proteus仿真和keil软件不会，

1.设计个电路板，自己焊接一下。 2.业务逻辑，用单片机处理。 3.处理结果，送数码管显示出来即可。


Question: 求一元二次方程的解

引用 2 楼 user-2 的回复:修改如下，供参考：#include <stdio.h> #include <math.h>  void Calculate(double a, double b, double c) {       double esp=pow(10,-6);//防止输出 -0.0000       if(a==0) return;       double m = b * b - 4 * a * c;       if (m == 0)       {           printf("该方程只有一个根:x=%.4f\n",(-b)/(a * 2)+esp);       }       if (m > 0)       {           printf("该方程有两个不同的实根\n");           double m0 = (-b + sqrt(m)) / (2 * a)+esp;           double n0 = (-b - sqrt(m)) / (2 * a)+esp;           printf("x1=%.4f x2=%.4f\n",m0,n0);       }       if (m < 0)       {           printf("该方程有两个不同的复数根\n");           if (b != 0)           {               double m1 = -b  / (2 * a)+esp;               double m2 = sqrt(-m) / (2 * a)+esp;               double n1 = -b  / (2 * a)+esp;               double n2 = - sqrt(-m) / (2 * a)+esp;               printf("x1=%.4f%c%.4fi x2=%.4f%c%.4fi\n",m1,(m2 > 0 ? '+' : '-'),fabs(m2),                                                        n1,(n2 > 0 ? '+' : '-'),fabs(n2));           }           else           {               double m3 = sqrt(-m) / (2 * a)+esp;               double n3 = -sqrt(-m)/ (2 * a)+esp;               printf("x1=%.4fi x2=%.4fi\n",m3,n3);           }       } }  int main() {       double a, b, c;        scanf("%lf%lf%lf",&a,&b,&c);       Calculate(a, b, c);              return 0; }  关于浮点数与0的比较，不能完全按照整型数与0直接进行比较；可以参考楼主的比较fabsf(m) < 1e-6（单精度），双精度:fabs(m) < 1e-16  https://blog.csdn.net/qq_40679299/article/details/79338570 https://www.cnblogs.com/youxin/p/3306136.html


Question: 请问这道题我的答案为什么不对？

楼主这么说，我还是很高兴的，这又给了我继续在这里混的兴趣。

引用 20 楼 均陵鼠侠的回复:[quote=引用 12 楼 早打大打打核战争 的回复:]你的答案是错的，老师的答案是对的。*a实际上是a[0]，不是a[0][0]，是int[3]类型，所以 int a[2][3]={{1,2,3},{4,5,6}}; int i,j;  for(i=0; i<2;i++) for(j=0;j<3;j++) printf("%d ",*(*a+5*i+j)); i=0时输出的是*(a[0]+0)==a[0][0]、*(a[0]+1)==a[0][1]、*(a[0]+2)==a[0][2] i=1时输出的则是*(a[0]+5+0)==a[0][5]==a[1][2]、*(a[0]+5+1)==a[0][6]、*(a[0]+5+2)==a[0][7]，越界了  不，表达式 * a 的确是得到了数组 a 的首元素，但因为这个元素的类型是数组，所以，就表达式 * (* a + 5 * i + j) 而言，它会继续转换为指向数组首元素的指针。即，转换为指向“数组 a 的首元素的首元素”的指针。有点绕，其实就是指向 a [0][0] 的指针。  还有，楼主的答案是正确的，没有任何问题，前面有我的分析过程（虽然我知道基本上没人看，但我还是写出来了）。有不同意见请提出，我们继续讨论。[/quote] 我有认真看了一遍的 感谢您认真仔细的解答对我这个刚接触c语言的小白很有帮助

啊，我是依据楼主的程序写的，但是楼主的程序写错了(当时我也没注意到楼主程序的数组和题目不一样)，所以那个分析的结论无效(不过分析过程还是对的，只是无的放矢了)～～～

引用 12 楼 早打大打打核战争 的回复:你的答案是错的，老师的答案是对的。*a实际上是a[0]，不是a[0][0]，是int[3]类型，所以 int a[2][3]={{1,2,3},{4,5,6}}; int i,j;  for(i=0; i<2;i++) for(j=0;j<3;j++) printf("%d ",*(*a+5*i+j)); i=0时输出的是*(a[0]+0)==a[0][0]、*(a[0]+1)==a[0][1]、*(a[0]+2)==a[0][2] i=1时输出的则是*(a[0]+5+0)==a[0][5]==a[1][2]、*(a[0]+5+1)==a[0][6]、*(a[0]+5+2)==a[0][7]，越界了  不，表达式 * a 的确是得到了数组 a 的首元素，但因为这个元素的类型是数组，所以，就表达式 * (* a + 5 * i + j) 而言，它会继续转换为指向数组首元素的指针。即，转换为指向“数组 a 的首元素的首元素”的指针。有点绕，其实就是指向 a [0][0] 的指针。  还有，楼主的答案是正确的，没有任何问题，前面有我的分析过程（虽然我知道基本上没人看，但我还是写出来了）。有不同意见请提出，我们继续讨论。

引用 16 楼 forever74的回复:[quote=引用 4 楼 m0_55062981 的回复:][quote=引用 1 楼 forever74的回复:]你的答案没错。  老师的错误在于，如果没有耐心分析学生的答案，那就不要出开放式的题目。 那个请问这样运行了代码只有第一行输出正确，其它行都是乱的是哪里出了问题吗？[/quote]  显然是你的验证代码写得不对。[/quote] 是的 非常感谢

引用 17 楼 早打大打打核战争的回复:题目中的数组是int a[3][5]; 楼主可能为了省事，测试代码用的是int a[2][3]; 但是数组元素计算公式没有改 printf("%d ",*(*a+5*i+j)); 应该是 printf("%d ",*(*a+3*i+j)); 对 我代码写错了

引用 4 楼 m0_55062981 的回复:[quote=引用 1 楼 forever74的回复:]你的答案没错。  老师的错误在于，如果没有耐心分析学生的答案，那就不要出开放式的题目。 那个请问这样运行了代码只有第一行输出正确，其它行都是乱的是哪里出了问题吗？[/quote]  显然是你的验证代码写得不对。

结果跟编译器有关？&a[i][j]是个整形数的指针，加1就是地址移动一个整形数位置，*a取的是数组名所代表的指针。那代表的是整形数的指针？整形数组的指针？存在两种解释，若是整形数的指针，结果是一样的;要是整形数组的指针，加1表示地址加了一个数组长度，就访问溢出了，就有问题了。

理解和讨论之前请先学会如何观察！  //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]   不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

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

int a[][]; 可能的结果是： 系统同步声明了以下几个标记（a[][], *a[], **a;），类似*a操作是不规范但不少系统会支持的标记。 数组的[]标记和指针的*还有引用的&标记，严格的讲，是可以互相取代但却有不同含义或者不同实现的。（&标记比较常用于单个数据，较少应用于数组操作） 过去有不少黑客尝试在不支持指针的系统（比如：Java）中通过null数组获取void指针（好像没有成功，至少没有相关的危害报告）。

引用 6 楼 focuslight的回复:你代码贴出来看看 请您帮忙看看 #include <stdio.h> int main() { 	int a[2][3]={{1,2,3},{4,5,6}}; 	int i,j;  	for(i=0; i<2;i++) 		for(j=0;j<3;j++) 			printf("%d ",*(*a+5*i+j)); }

引用 7 楼 均陵鼠侠的回复:首先，题目本身是值得商榷的。题目中暗示 a 的元素类型为 int，但其实不然。a是一个元素类型为 int [5]的数组。如下图所示，a 是具有3个元素的、元素类型为“具有5个int类型元素的数组”。  表面上看，这是一个扣字眼的无聊话题，但它很重要，尤其是有助于分析含有数组的表达式。言归正传，就题目的实际所指而言，楼主的答案是：  * (* (a + i) + j) * (* a + 5 * i + j)  先来看第一个答案。首先，表达式 a 的类型为 int [3][5]，在这里自动转换为指向数组 a 首元素的指针。数组 a 的元素类型是 int [5]，所以转换为 int (*) [5]；  接着，表达式 a + i 得到另一个指针，指向数组 a 的元素 i，元素的类型是 int [5]；  接着，表达式 * (a + i) 得到指针所指向的实体，即，得到数组 a 的元素 i，元素的类型是 int [5]；  接着，因为数组 a 的元素 i 是数组（即，表达式 * (a + i) 的结果是 int [5] 类型的数组），在这里自动转换为指向其首元素的指针。元素的类型是 int ，所以转换为指向 int 的指针，指向数组 a 的元素 i 的元素 0。  接着，表达式 * (a + i) + j 的结果是指针，指向数组 a 的元素 i 的元素 j；  最后，表达式 * (* (a + i) + j) 的结果是得到数组 a 的元素 i 的元素 j 本身。当然了，在一个需要值的场合，这个左值会执行左值转换，转换为该元素的存储值。  所以，第一个答案是正确的。  再来看第二个答案。首先，表达式 a 的类型为 int [3][5]，在这里自动转换为指向数组 a 首元素的指针。数组 a 的元素类型是 int [5]，所以转换为 int (*) [5]；  接着，表达式 * a 得到指针所指向的实体，即，得到数组 a 的首元素。数组 a 的元素类型是 int [5]，所以是得到一个 int [5] 类型的数组。因为后面要做加法，所以这个数组自动转换为指向其首元素的指针（int *），实际上指向数组 a 的元素 0 的元素 0；  接着，表达式 * a + 5 * i 将刚才的指针向后移动 5 * i 个 int 大小的位置。在 C 语言里，数组的成分具有连续分配的特点，所以，这实际上是得到一个指向数组 a 的元素 i 的元素 0 的指针；  接着，表达式 * a + 5 * i + j 继续移动指针，再移动 j 个 int 大小的位置，得到一个指向数组 a 的元素 i 的元素 j 的指针。  最后，表达式 * (* a + 5 * i + j) 的结果是得到数组 a 的元素 i 的元素 j 本身。当然了，在一个需要值的场合，这个左值会执行左值转换，转换为该元素的存储值。  所以，第二个答案也是正确的。  通过上面的分析可知，表达式 * a 等价于 & a [0][0] 。既然 & a [0] [0] 可以使用，那么 * a 也没有任何问题。 好的 非常感谢

你代码贴出来看看

引用 2 楼 focuslight的回复:运行代码一下，你的答案也对，可能题库里答案没你这种形式。  a表示二维数组a的首地址，而*a表示二维数组a第一行a[0]的首地址。这样在使用的时候就有所区别。比如 对a的操作a[4]表示a的第四行首地址，而对*a的操作(*a)[4]则代表第一行的第4个元素，即a[0][4]。 请问我运行了一下代码只有第一行输出正确其它行都是乱的是哪里出了问题吗？那个题目的正确答案我也试了都是一样的

引用 1 楼 forever74的回复:你的答案没错。  老师的错误在于，如果没有耐心分析学生的答案，那就不要出开放式的题目。 那个请问这样运行了代码只有第一行输出正确，其它行都是乱的是哪里出了问题吗？

题目明确指出五种访问方式, 显然标准答案是最适合的. 楼主的答案仅仅是等价而已. 第5种强调的是从基地址(&a[0][0])出发的一种访问方式. 用*a表达第0个元素的地址,已在第3种方式中体现.


Question: [c语言求助]

open -- read -- /* 处理 */ -- close

少不了打开文件，读取文件，然后是一些类似字符串判断的操作；特定的一条可能会考虑使用字符串比较～


Question: c语言毕设看不太懂啊

所有LED端口设置为推挽输出，且输出为低电平。

“将所有LED端口的模式设置为推拉模式，并将输出电平设置为低电平 ” 这是数模电相关的吧，


Question: 求大神解答一下

非常感谢

供参考：//输入十进制数，转换为 r进制 数输出。 #include<stdio.h> #include<string.h>  int n,r,count=0; void print( int x ) {      if( x <= 9 )          printf( "%d",x );      else          printf( "%c",x - 10 + 'A' );  } void change( int n,int r ) {      if( n )  //递归条件是：n/r != 0      {          change( n / r, r ); //递归调用          print( n % r );      }  } int main( ) {     scanf( "%d%d",&n,&r ) ;     change( n,r );    //递归函数          return 0; }

引用 3 楼 自信男孩的回复:[quote=引用 2 楼 m0_58034981 的回复:]嗯，谢谢，同时请问一下chang(n / r,r)是什么意思 同样的道理嘛， n/r的结果给change的第一个形参n，r给第二个形参r，虽然是同名但是在内存中是相互独立的。[/quote] 非常感谢你。

引用 2 楼 m0_58034981 的回复:嗯，谢谢，同时请问一下chang(n / r,r)是什么意思 同样的道理嘛， n/r的结果给change的第一个形参n，r给第二个形参r，虽然是同名但是在内存中是相互独立的。

嗯，谢谢，同时请问一下chang(n / r,r)是什么意思

print( n % r );print是一个自定义函数，形参是int类型的，n%r就是把结果作为实参传递给形参；即n % r的结果赋值给x


Question: 为什么在 DLL 中 malloc() 的内存出现 access violation

感谢各位的回复，经过了一段时间的尝试，我把这段代码挂到进程上去调试，最后找到问题的所在了，来此结帖，并感谢各位的热心回复。代码上各位看不出问题来，是因为有问题的地方其实没有体现出来，在第二个malloc()调用所处的文件中，我没有写 #include <stdlib.h>，我使用的编译器也没有报错 (C99 的话这里会报错)，导致了 malloc() 函数成为了隐式声明函数，隐式函数声明默认返回值是 int，所以返回值从 void* 被编译器改成了 int，机器现在都是 64 位的，指针的高 32 位地址由于返回值是 int 被截断，后续再尝试访问这个地址空间，肯定属于非法操作了，因此出现了 access violation。

引用 7 楼 forever74 的回复:我觉得鼠侠的意思是，这段代码是在把油门当作刹车踩，因此不能以此为证据说明刹车有问题。 而我想刹车或许是好的，或许有问题，或许...好吧，我没见过那辆车。 是的。 而且单就已经公布的这部分代码来说，是没有任何问题的。毕竟你很难想象内存已经分配成功却无法用一个简单的表达式来访问，这是不可思议的。如果代码检查和调试的方法都已经用过了，那就试着从编写一个最简单的DLL，只包含以上功能（再添加一个释放内存的接口，在DLL中分配内存，也应该在DLL中释放，不然可能会出问题的），如果没有问题，再说。

我一直觉得，论坛什么的只能解决领进门阶段的一些小问题，到了修行在个人的阶段，论坛就没啥用了。 四老师强调在入门阶段多锻炼调试，我想就是这个意思。

引用 2 楼 赵4老师 的回复:C Run-Time Libraries https://msdn.microsoft.com/en-us/library/abx4dbyh.aspx感谢回复，但是我感觉我这个问题和CRT没什么太大的关系，因为我在DLL的AMI_init()函数中也 malloc()了内存，都能正常访问，但是在AMI_Get()函数中的malloc()就不行了。

引用 5 楼 均陵鼠侠 的回复:你给出的信息相对有限，而且程序也是错的，所以通常没有办法准确判断。 struct {     int data;     struct list* next; }list;   void init() {     struct list* n;     n = (struct list*)malloc(sizeof(struct list));     // access n->data caused memory access violation. } 就这，list 是一个变量，你确定 struct list 是合法的并且这段代码能通过编译？  感谢回复，抱歉造成疑惑，全部的代码很长，我怕误导大家，这是我自己随手写的一段主要的示意，我感觉上觉得和DLL被两次调用有关，第一次调用 AMI_Init()，第二次调用 AMI_Get()，但是似乎第二次调用和第一次调用之间的内存空间是两个导致越界无法访问。

引用 1 楼 真相重于对错 的回复:调试，判断n是否为空？ 感谢回复，n 不为空，分配成功了，但是无法访问。

调试，判断n是否为空？


Question: __stdcall与变参函数的栈清理

引用 4 楼 Intel0011 的回复:看了一下gcc的汇编代码，与VC是相似的，没什么不同，没明白你说的意思 关于那个__cdecl函数指针调用__stdcall却正常的问题，我搞懂了，和你说下我的心得吧  在gcc上测试 之前__cdecl指针能调用__stdcall函数应该只是个巧合，函数自身的栈空间足够大，调用__stdcall函数的次数少，所以没出岔子，调用次数一多就出问题了，因为esp一直是在加的  __stdcall指针调用__cdecl函数却是可行的，因为调用函数后不修改esp，esp就是在减的，相当于增加了main的栈空间。而且函数变量gcc通过ebp定位，而ebp在传参之后、调用函数之后入栈，最后可以准确还原，而传参通过esp定位，esp又是在减的，也就是传参的入栈位置都是在新的栈空间。  然后是cl的测试 __cdecl调用__stdcall一下就失败了，记得之前调用WinAPI是测试成功了的，忘了是什么情况了  不过它的__stdcall调用__cdecl也成功了，原因应该跟gcc的差不多，传参通过push，那么就是以esp定位，但不同的是，它变量是直接写的变量名，如move dword ptr[c] , 0 ，我估计本质应该也是用的ebp定位

1. 变参函数用__stdcall 是无法实现的, 所以编译器强制编译成了__cdecl 2. 函数参数进栈一般用push, 但是也可以直接 mov [esp+x], vvv 的方式, 作用是等效的

引用 3 楼 六道佩恩 的回复:话说调用约定会影响变参函数的参数的类型提升吗？  LoadLibrary+__cdecl函数指针调用Windows API，按理说会出问题的对吧，怪就怪在GCC和CL在命令行的编译结果运行正常，而VC的IDE上（CPP）就出问题了，得__stdcall函数指针。这波没出问题反而搞不懂，__cdecl和__stdcall都试了，汇编是不同的（调用后修改esp与否），但运行都正常？？？Windows API使用__stdcall的话，最后应该是修改了栈顶的吧？  还是这个__cdecl和__stdcall，在gcc上，__cdecl，调用函数后没有调整栈顶；__stdcall，调用后反而调整栈顶了，函数最后修改了栈顶，结果调用结束后gcc又改了回来，使栈顶还是指向调用各个函数时通用的传参空间。我是不是可以认为，表面上看是gcc对__cdecl没有修改栈顶而对__stdcall修改了，是由于它对栈的使用方式和VC不同，所以才造成了表象相反，在它的使用方式内，__cdecl没有改esp仍视为清理了栈，而__stdcall改了esp应视为没有清理栈，是吧？ 函数的参数的类型提升是在C语言标准中已经规定了的，与调用约定的类型无关，调用约定只是规定了参数的压栈顺序以及由谁来做栈平衡的动作 Windows API大部分是__stdcall，只有变参函数是__cdecl，因为Windows API是已经编译好的，其调用约定已定  看了一下gcc的汇编代码，与VC是相似的，没什么不同，没明白你说的意思  int __attribute__((__stdcall__)) fun1(int num) {     return num + num; }  fun1:         push    ebp         mov     ebp, esp         mov     eax, DWORD PTR [ebp+8]         add     eax, eax         pop     ebp         ret     4  //这里有清栈，由于是__stdcall，所以由自己清栈  int __attribute__((__cdecl__)) fun2(int i, int j) {     return i + j; }  fun2:         push    ebp         mov     ebp, esp         mov     edx, DWORD PTR [ebp+8]         mov     eax, DWORD PTR [ebp+12]         add     eax, edx         pop     ebp         ret   //这里没有清栈，由于是__cdecl，所以由调用方清栈  int main(void) {     fun1(1);     fun2(1, 2);     return 0; }  main:         push    ebp         mov     ebp, esp         push    1 //传参的栈空间         call    fun1 //fun1自己清栈         push    2 //传参的栈空间         push    1 //传参的栈空间         call    fun2         add     esp, 8 //调用方清栈         mov     eax, 0         leave         ret

引用 4 楼 Intel0011 的回复:Windows API大部分是__stdcall，只有变参函数是__cdecl，因为Windows API是已经编译好的，其调用约定已定  我的意思是，那些函数已经确定，__stdcall导致末尾的ret会修改栈顶对吧？ 那么调用方也需要按__stdcall来调用对吧？ 但问题在于，我测试调用方按__cdecl来调用，结果也能正常运行？  为了确定gcc确实是按__cdecl编译的，对比__stdcall和__cdecl调用函数后的操作，一个没动作，一个有修改esp的操作，所以它确实按我指示的__cdecl调用了__stdcall函数，但却正常运行了（不是一个函数，是多个）

引用 2 楼 Intel0011 的回复:1、对于变参函数，其调用约定只能为__cdecl，因为只有调用者才知道传了多少个参数，被调用者是无法知道的（有标志意义的参数除外），所以这时也只能由调用者来做栈清理，恢复到调用前的状态 2、每次传参都是拿同一段空间反复使用，这本身就是栈的处理方式，是优于堆的地方，每一次函数调用后，都会恢复到调用前的状态，所以一般情况下栈不需要特别大的空间，函数式编程中的尾递归就是栈的极致利用方式 3、不论是那种调用约定，只要每一次函数调用后将栈恢复到调用前的状态，都可以认为是栈清理，也叫栈平衡   话说调用约定会影响变参函数的参数的类型提升吗？  LoadLibrary+__cdecl函数指针调用Windows API，按理说会出问题的对吧，怪就怪在GCC和CL在命令行的编译结果运行正常，而VC的IDE上（CPP）就出问题了，得__stdcall函数指针。这波没出问题反而搞不懂，__cdecl和__stdcall都试了，汇编是不同的（调用后修改esp与否），但运行都正常？？？Windows API使用__stdcall的话，最后应该是修改了栈顶的吧？  还是这个__cdecl和__stdcall，在gcc上，__cdecl，调用函数后没有调整栈顶；__stdcall，调用后反而调整栈顶了，函数最后修改了栈顶，结果调用结束后gcc又改了回来，使栈顶还是指向调用各个函数时通用的传参空间。我是不是可以认为，表面上看是gcc对__cdecl没有修改栈顶而对__stdcall修改了，是由于它对栈的使用方式和VC不同，所以才造成了表象相反，在它的使用方式内，__cdecl没有改esp仍视为清理了栈，而__stdcall改了esp应视为没有清理栈，是吧？

引用 楼主 六道佩恩 的回复:我主要有两个问题： 1. 关于变参函数，是不是不管声明何种调用约定，其都会实现为__cdecl？下面是VC的汇编，实际指定的是__stdcall。 2. gcc的对栈清理的方式怎么和VC不一样啊？或者说这算栈清理吗？ 观察了它几次调用，发现它每次传参都是拿同一段空间反复使用，就是图中入栈的那段，对不同函数的调用，传参都是用的这同一段，作为调用方把控了传参的栈空间，是不是也相当于做了栈清理？或者说这能算栈清理吗？ （编译用的32位，非x64约定） 1、对于变参函数，其调用约定只能为__cdecl，因为只有调用者才知道传了多少个参数，被调用者是无法知道的（有标志意义的参数除外），所以这时也只能由调用者来做栈清理，恢复到调用前的状态 2、每次传参都是拿同一段空间反复使用，这本身就是栈的处理方式，是优于堆的地方，每一次函数调用后，都会恢复到调用前的状态，所以一般情况下栈不需要特别大的空间，函数式编程中的尾递归就是栈的极致利用方式 3、不论是那种调用约定，只要每一次函数调用后将栈恢复到调用前的状态，都可以认为是栈清理，也叫栈平衡

1. stdcall 等调用约定的规则就限制了他们进行变参函数的使用   。    当然也有些特殊情况。 2.栈清理  是什么东西??    参数传递的入栈和出栈吗？   gcc 和 vc 传参时对栈的使用基本是相同的   ，只不过 gcc 提前分配了空间  而vc使用push ，但是每次使用完栈都是平衡的 。


Question: const char *和char *的问题

const的作用用于限制该字符串在该函数内（比如strcmp）是不能被修改的，是只读的。  加了比不加更好，虽然不影响结果；比如自定义mystrcmp(char *s1, char *s2);这样自定义形参也是没问题的，从功能上考虑是比较，自然不需要修改s1, s2两个字符串；因此加上const更严谨；

引用 1 楼 user-2 的回复：对，没错。 尤其是在一个人写代码的时候。  而在团队合作的环境下，函数原型里的一个const相比洋洋洒洒地用文字约定神马东西不能改就简洁多了，也明确多了。谢谢🙏


Question: 新手求助

main开始吧，既然是字符串，那么应该定义成char str[80];，形参也应该是char p[]; ， p[i]-'0'

赵4老湿正在赶来的路上，但他不愿意回答这种简单问题，所以我代替他回答一下： # include <string.h>   int BinToDec (char p []) {     if (strlen (p) == 0) return 0;       return * p - '0' << strlen (p) - 1 | BinToDec (p + 1); } 我们采用了递归的方法，按照每个 0、1 的阶，将它移动到二进制数的指定位置，移完之后就是最终结果。


Question: C程里面这个看不懂了，求助！！！

clock() &(,<<8)比  (clock() >> 8) & 1更快吧.

clock()的返回值右移8位，然后最低位是不是1。这个返回值的第二个8位可能比较特殊；应该是多长时间会为1吧

The clock() function returns an approximation of processor time used by the program. The value returned is the CPU time used so far as a clock_t; to get the number of seconds used, divide by CLOCKS_PER_SEC.  If the processor time used is not available or its value cannot be represented, the function returns the value (clock_t) -1.  还有很多注意事项，建议搜索一下 clock 函数，你贴的这段函数应该是在循环代码块里边儿吧？轮循 clock 获取时间，满足条件就显示 _


Question: c语言链表出现段错误怎么解决

引用 3 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  struct ListNode {     int address;     int data;     int next;     struct ListNode *Next; };  int main() {     int k;     struct ListNode *head;      head=(struct ListNode *)malloc(sizeof(struct ListNode));     head->Next=NULL;      struct ListNode *p,*q;     p = head;     int first;     int number;     int i;     int m;     scanf("%d%d%d",&first,&number,&m);     int l=m;     for(i=0; i<number; i++)     {         q=(struct ListNode *)malloc(sizeof(struct ListNode));         scanf("%d %d %d",&q->address,&q->data,&q->next);          /*         if(head==NULL)      //head不会为NULL了，这个判断是冗余的         {             head=p=q;         }         else         {*/             p->Next=q;             p=q;         //}     }     p->Next=NULL;     p = head->Next;      //输入链表里了     //m=4     struct ListNode *head1,*temp;     head1=(struct ListNode *)malloc(sizeof(struct ListNode));     head1->Next=NULL;     temp=head1;     //while(m)     while(m && p)       //这里可能出现段错误     {         if(p->data==m)         {             q=(struct ListNode *)malloc(sizeof(struct ListNode));             q->address=p->address;             q->data=p->data;             q->next=p->next;             /*             if(head1==NULL)     //同样冗余             {                 head1=temp=q;             }             else             {*/                 temp->Next=q;                 temp=q;             //}             m--;             p=head->Next;         }         else         {             p=p->Next;         }     }   //现在head1内 4 3 2 1     if(number==l)     {         temp->Next=NULL;         p=head1->Next;         int a=0;         while(p)         {             if(a==0)             {                 printf("%05d %d ",p->address,p->data);             }             else             {                 if(p->next!=-1)                     printf("%05d\n%05d %d ",p->address,p->address,p->data);                 else                 {                     printf("%05d\n%05d %d ",p->address,p->address,p->data);                 }              }             p=p->Next;         }         printf("-1");     }     else     {         p=head->Next;         int a;         a=l+1;         while(a<=number)         {             if(p->data==a)             {                 q=(struct ListNode *)malloc(sizeof(struct ListNode));                 q->address=p->address;                 q->data=p->data;                 q->next=p->next;                 if(head1==NULL)                 {                     head1=temp=q;                 }                 else                 {                     temp->Next=q;                     temp=q;                 }                 a++;                 p=head->Next;             }             else             {                 p=p->Next;             }         }         //printf("1\n");         temp->Next=NULL;         //printf("3\n");         p=head1->Next;         a=0;         while(p)         {             if(a==0)             {                 printf("%05d %d ",p->address,p->data);                 a++;             }             else             {                 if(p->next!=-1)                     printf("%05d\n%05d %d ",p->address,p->address,p->data);                 else                 {                     printf("%05d\n%05d %d ",p->address,p->address,p->data);                 }             }             p=p->Next;         }         printf("-1");      }     return 0; } 供参考～  功能都写在main中很难理解逻辑；建议功能分别用自定义函数实现，main函数调用的方式谢谢~ 加上之后可能有的测试用例通过了 某些还是会有段错误 我再好好看看

引用 4 楼 自信男孩 的回复:发一下需求里提到的测试用例，以及用例的输出样例；

发一下需求里提到的测试用例，以及用例的输出样例；

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

输入测试用例调试运行下去都没有错误


Question: C语言两个数的最小公倍数

// 最大公约数 int greatest_common_divisor(int a, int b) {     if(b == 0) return a;     else return greatest_common_divisor(b, a % b); } // 最小公倍数 int least_common_multiple(int a, int b) {     return a * b / greatest_common_divisor(a, b); }

供参考：#include <stdio.h>  int main() { 	int a,b; 	int yu; 	int m,n; 	printf("input two numbers:\n"); 	scanf("%d%d", &m, &n);     m>n?(a=m,b=n):(a=n,b=m); //大值放a，小值放b 	while (a%b != 0)//辗转相除法 ,得到最大公约数b 	{ 	      yu = a%b; 	      a = b;           b = yu;     } 	printf("最小公倍数为:%d\n",m*n/b);//最小公倍数=两数的乘积 ÷ 最大公约数          	return 0; }

引用 1 楼 真相重于对错的回复:我去，先把基本语法搞清楚。 初学者，希望大佬可以指出

我去，先把基本语法搞清楚。

，望采纳，不懂的可以关注私信我。


Question: C入门代码

引用#include<stdio.h> int main(){     int n[10];     int i;     int max = n[0];     printf("请输入10个数：");     for(int i = 0;i <= 10;++i)         scanf("%d",&n[i]);     for(int i = 0;i <= 10;++i)         max = n[i] > max ? n[i] : max;         printf("max = %d\n",max);     return 0; } for（）里对数组下标操作越界，应改为：for(int i=0; i<10 ;i++)

if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) 这句改一下： if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) 逻辑更清晰一些～  #include<stdio.h> int main(){     int n[10];     //int i;     //int max = n[0]; //随机值，可能max也放不下的随机值     int max;      printf("请输入10个数：");     for(int i = 0;i <= 10;++i)         scanf("%d",&n[i]);     max = n[0]; //在这初始化     for(int i = 0;i <= 10;++i)         max = n[i] > max ? n[i] : max;     printf("max = %d\n",max);     return 0; } 供参考  max初始化有问题，可能导致程序结果异常；

好的，谢谢


Question: 求解！！！

你莫不是用了全角的小于号＜？

没看出什么问题来。第一个else建议和后面的if写在一行。

好像没啥问题，报错< 是非法的。望采纳，不懂的可以关注私信我。

‘<'  是非法字符


Question: 【新手求助】二进制转十进制

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

#include <stdio.h>  int main() {     int remainder, number = 0, decimal_number = 0, temp = 1;     printf("\n Enter any binary number= ");     scanf("%d", &number);      // Iterate over the number until the end.     while (number > 0)     {         remainder = number % 10;         number = number / 10;         decimal_number += remainder * temp;         temp = temp * 2;  // used as power of 2     }      printf("%d\n", decimal_number); }    望采纳，不懂的可以关注私信我。

供参考：#include<stdio.h>  int BinToDec(char p[]) {     int sum=0,i=0;     while(p[i]!='\0')     {         sum = sum*2 + p[i]-'0';         i++;     }     return sum;  }  int main() {     int  s;     char str[80];     printf("Enter only 0,1 string:");     scanf("%s",str);     s=BinToDec(str);     printf("Bin=%s<=>Dec=%d\n",str,s);          return 0; }


Question: 求助

return new int[]{i,j}; 返回的是 函数指针，return new int[2]; 返回的是函数，望采纳，不懂的可以关注私信我。

实事求是地说，在这个版块内，这个问题还得赵老湿来。你@赵老湿。

public int[]  这是C++的语法吧，C语言没有public关键字；  int []这样作为返回值类型不常见，常见的是int *返回指针。从函数实现的返回值来看就是这样的，返回的是指针（地址值）  #include <stdio.h> int main() {     int num[10]={2,9,17,21,35,99,333,128,101,121,};      int i,j;     for(i=0;i<=9;i++)     {         for(j=0;j<=9;j++)         {             if(i != j && num[i]+num[j]==120)             {                 printf("%d %d ",i,j);                 //i=100;  //这里赋值会导致数组越界，因为第二层循环可能还没结束，if (num[i]这里就会出现数组越界了；                 break;             }         }         if (j <= 9)     //继续跳出循环             break;     } } 供参考～  代码有点问题修复一下，如上；

另贴出我自己写的： #include <stdio.h> int main() { 	int num[10]={2,9,17,21,35,99,333,128,101,121,}; 	int i,j; 	for(i=0;i<=9;i++) 	{ 		for(j=0;j<=9;j++) 		{ 			if(num[i]+num[j]==120) 			{ 				printf("%d %d ",i,j); 				i=100; 			} 		} 	}  }


Question: 大佬，救命

希望对您有帮助，盼采纳：https://blog.csdn.net/it_xiangqiang/category_10581430.html

C语言教程（附带C语言100例）http://download.csdn.net/detail/zhao4zhong1/8830817

大学应该有课本吧，建议先把课程里的学习了再考虑扩展性的学习。


Question: 各路大神，帮帮孩子吧( •︠ˍ•︡ )

<<linux C prime plus>>可以找找，或者买一本～


Question: 求助，急需帮助，纯C语言

引用 3 楼 自信男孩的回复:[quote=引用 2 楼 weixin_52677262 的回复:][quote=引用 1 楼 自信男孩的回复:]为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。 我当然写了几个功能[/quote] 那你只把需求发出来，你的代码一条也不贴。你是想让大家帮你写全，调试完，测试完，没问题的？还是其他要求？  需求不明确。  [/quote] 明白了，下次发问题时会写清楚需求

引用 2 楼 weixin_52677262 的回复:[quote=引用 1 楼 自信男孩的回复:]为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。 我当然写了几个功能[/quote] 那你只把需求发出来，你的代码一条也不贴。你是想让大家帮你写全，调试完，测试完，没问题的？还是其他要求？  需求不明确。

引用 1 楼 自信男孩的回复:为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。 我当然写了几个功能

为什么不自己先试试呢？需求这么详细，总能自己写一个功能吧。