Question: 有大佬知道为什么do while循环里重复定义结构指针是可以的呢，还有给结构指正赋NUll是怎么回事，有啥好处

感谢，我另写了一个循环，还真是这样

在循环结构里虽然看着是循环定义，其实编译器只会定义一次，因为在do ... while是一个代码块，这部分的last只会定义一次。后面的直接使用上次定义的。  用NULL的好处是，作为链表结束的标记，因为链表是next指向下一个，什么时候到达末尾了?NULL是一种方法。  楼主的代码少一个大括号，匹配if (number != -1)的   #include<stdio.h> #include<stdlib.h>  typedef struct _node{     int value;     struct _node *next; }Node;  int main(int argc,char const *argv[]) {     Node *head=NULL;     int number;     do {         scanf("%d",&number);         if(number!=-1){             Node *p=(Node *)malloc(sizeof(Node));             p->value=number;             p->next=NULL;             Node *last=head;             if(last){                 while(last->next){                     last=last->next                 }                 last->next=p;             }             else {                 head=p;             }         }     }while(number!=-1);      return 0; } 供参考～

那为什么 int *p=a； int *p=b； 不行呢

在循环里不断给新结点分配内存，指针p是移动的，不存在重复定义。给指针赋值NULL是初始化，不然可能变成野指针，不知道指向哪儿了。


Question: 初学乍练，这几句程序什么意思？

好的，多谢提示。

建议楼主找一下你的代码工程，应该有地方用typedef了V_U32和V_UCHAR  其实可以这么理解：V_U32就是unsigned int，V_UCHAR是unsigned char。  最好找一下定义的地方。

请帮忙解释一下，V_U32  blockse;   V_UCHAR *ramaddr 这两句的V_U32和V_UCHAR是什么东西，为什么这么用？


Question: win10系统 c-free5.0无法运行  怎么都不行 是路径出问题了吗

现在的电脑配置都无比强悍，建议用最大众化的IDE。比如 VISUAL STUDIO 2019，号称宇宙第一IDE，编程和调试都很方便。

建议dev-c++：https://sourceforge.net/projects/embarcadero-devcpp/ 或者：https://www.filehorse.com/download-dev-c/

没使用过这个工具 建议不如换一个啊 VS只用序列号就可以激活 如果想要占用空间少的 可以CodeBlocks 或CodeLite 这两款我试过 确定没问题的


Question: 大佬们萌新实在整不明白这俩个咋打了

感谢大佬。。。。

改成 scanf(“%s”, s); for(i=0; i<80&&s[i]!=‘\0’; i++) {//要用循环     if((s[i]>=‘a’&&s[i]<=‘z’) || (s[i]>=‘A’&&s[i]<=‘Z’) || (s[i]>=‘0’&&s[i]<=‘9’))         printf(“%c”, s[i]); }


Question: 指向指针的指针问题，在线等，问题见二楼

不明白为啥要用二级指针，只有一个主函数完全没有必要这样。

第一次进入for( ; *last; last=&(*last)->next );由于last指向head，head指向NULL，所以不执行for循环，后面的语句让head指向了第一个节点Node1；第二次进入for( ; *last; last=&(*last)->next )循环时*last也就是head是指向Node1的，所以会让last指向最新一节Node1。下面把Node2联接到Node1上，不应该是 (*last-next） = (Node *)malloc( sizeof(Node) )吗?


Question: VS2019使用strlen()函数时，为啥后面多了乱码

引用 2 楼 user-2 的回复:字符串要有结束符'\0'，否则就会一直输入内存信息直到遇到字符串结束符 所以 puts(flag); outflag[strlen(flag)] = '\0'; //这里追加设定字符串结束符 puts(outflag);  另外，flag[i] ^ 1 有可能导致运算结果是非显示字符，这样outflag显示的内容也不一定能看得到  楼主申请的空间少一个'\0'的位置，所以，outflag[strlen(flag)] = '\0';这样操作会导致内存越界操作～

#include <stdio.h> #include <stdlib.h> #include <string.h>  int main() {     /*const char* flag;       char* outflag;       flag = "ZmxhZ3tzaG91a2FrdX0=";       outflag = (char*)malloc(BASE64_DECODE_OUT_SIZE(strlen(flag)));       base64_decode(flag, strlen(flag), outflag);       puts(outflag);       free(outflag);       return 0;*/     int i;     char* flag;     flag = "ZmxhZ3t9CgoK";     char* outflag = (char*)malloc(strlen(flag) + 1);     for (i = 0; i < strlen(flag); i++)     {         outflag[i] = flag[i] ^ 1;     }     outflag[i] = 0;   //add '\0'     puts(flag);     puts(outflag);     free(outflag);     return 0; }  供参考～  注意'\0'，出现乱码，对于字符串而言，大部分都是因为'\0'导致（没在对应的字符串结尾加上'\0'导致）


Question: 求解

scanf_s替换scanf，注意这两者的区别，详细的请查阅scanf_s的使用

也可以输入# pragma warning (disable : 4996)消除此类警告

Embarcadero Dev-Cpp比较友好，使用更方便。 最新版：Embarcadero_Dev-Cpp_6.1_TDM-GCC_9.2_Setup.exe

请看提示  大概的意思是“scanf函数已经不安全了，请使用scanf_s()函数代替scanf()函数” 如果您觉得使用scanf_s()函数不方便，还是习惯使用scanf()函数，请参考 《VS2015中使用scanf()不报错的设置方法》 希望能够帮到您！

提示你scanf函数不安全，改为用 scanf_s函数


Question: 代码有误，样例只有第一个输出正确，不知错误在哪，求教

引用 8 楼 forlorn pedestrian的回复:引用[quote]		c = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗 我觉得，你把第三项和第1，2项的关系表达式写一下，就明白了

公式，是你算第n项，仅仅算n项，带进去n才有效。 这个算法是，先算第0和第1项，然后根据0，1项，算出第2项。。。然后根据第1，2项，算出第3项。。。依次类推 算出第n项。。。 那么，算第2项时，公式里n=2，是不是就没毛病了

引用 8 楼 forlorn pedestrian的回复:引用[quote]		c = (2 * i - 1) / i * x * b - (i - 1) / i * a; 请问为啥这里用i了，题目里不是给的n吗 算第n项的时候，代n进去没错。 但你这个算法是，先算第0项和第一项，然后算第二项，依次类推，算出第n项。。 算第三项的表达式时，公式里n=3 算第四项时，公式里n=4

引用 11 楼 自信男孩的回复:[quote=引用 2 楼 weixin_46056697 的回复:]我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了 你改一下试试？问题没看到重点，建议自己试试～[/quote] 确实，我的错，没注意

引用 2 楼 weixin_46056697 的回复:我不知道勒让德公式是怎样的，你的代码错误应该是n定义成浮点型了，改成定义整型就好了 你改一下试试？问题没看到重点，建议自己试试～

引用 9 楼 自信男孩 的回复:#include<stdio.h>  int main() {     //float x, /*n,*/ c, a, b;     double x, /*n,*/ c, a, b;     int n, i;      //scanf_s("%f%d", &x, &n);     scanf("%lf%d", &x, &n);     if (n == 0) {         c = 1;         printf("%.2lf", c);         return 0;     }     if (n == 1) {         c = x;         printf("%.2lf", c);         return 0;     }     a = 1.0;     b = x;     for (i = 2; i <= n; i++) {         //c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a;         c = (2 * i - 1)*1.0 / i * x * b - (i - 1) *1.0/ i * a;         a = b;         b = c;     }     printf("%.2lf", c);     return 0;  } 供参考～ 把scanf改成scanf_s吧

1.a,b赋初值不应该在for循环里，否则a,b一直被赋初值，你的递归就无效了； 2.不应该带n去算，因为计算P2时，n=2,计算P3时，n=3....所以带进去i比较合适 3.如果带进去i,那么浮点数运算i应该也为浮点数，否则运算不出正确结果

#include<stdio.h> int main() { 	float i; 	float x, c, a,b; 	int n; 	scanf_s("%f%d", &x, &n); 	a = 1; 	b = x; 	if (n == 0) 		c = 1; 	else if (n == 1) 		c = x; 	else 		for (i = 2; i <= n; i++) { 			c = (2 * i - 1) / i * x * b - (i - 1) / i * a; 			a = b; 			b = c; 		} 	printf("%.2f", c); 	return 0; }

用嵌套吧 float polya(float n, float x) { 	float sum; 	if (n == 0) 		sum = 1; 	else if (n == 1) 		sum = x; 	else if (n>1) 		sum = ((2 * n - 1)*x*polya(n - 1, x) - (n - 1)*polya(n - 2, x)) / n; 	return sum; } int main() { 	float x, n, c, a, b; 	int i; 	scanf_s("%f%f", &x, &n); 	c = polya(n, x); 	printf("%.2f", c); 	return 0; }

for循环错了，虽然你计算c后，给a，b赋值，但下一次循环后，a,b还是1和x


Question: C语言（非C++，基础C）  结构体数组的成员指针的赋值 问题

引用 7 楼 自信男孩的回复:c1为分配空间，是一个野指针，直接scanf可能会出现段错误。 c2是一个char普通变量，用%s会导致越界，因为%s会考虑加上'\0'，输入了M/F之后再把'\0'放哪里。 啊啊啊，确实，仔细一想确实都是错误，感谢大神指点（我还是太弱了

引用 3 楼 user-3 的回复:[quote=引用 1 楼 一颗白面馒头的回复:]scanf("%s",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf("%s", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）[/quote] 有这个感觉，这里面指针用的好乱

引用 3 楼 user-3的回复:[quote=引用 1 楼 一颗白面馒头的回复:]scanf("%s",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf("%s", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）[/quote] 其实这个题老师是让用C++编的，但是标准C里面没有对字符串直接声明的数据类型，之前对name的定义是数组，但是因为是先确定数组的大小，我就改成了指针类型

引用 1 楼 一颗白面馒头的回复:scanf("%s",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf("%s", c1); 上完课回去试试

引用 1 楼 一颗白面馒头的回复:scanf("%s",&c1);这句话有问题，c1本来就是个指针，你还取地址，&c就相当于char **类型了，可以改成scanf("%s", c1); 感觉不止这个问题，他结构体里面name也是指针，后面给name赋值的时候也有问题（供参考）

建议重新看看指针的知识（感觉你这些指针定义 赋值啥的很乱很乱）


Question: 字符串计算单词个数

源代码如下：  #include <stdio.h> #include <ctype.h> #include <string.h>  int is_upper(char *p) { 	while(*p) 	{ 		if(islower(*p)) return 0; 		p++; 	} 	return 1; }  int main(void) { 	char str[] = "FORBES The CEO of Boloco's Social Media Strategy"; 	char *p; 	int count = 0; 	 	p = strtok(str, " "); 	 	while(p != NULL) 	{ 		if(is_upper(p)) 		{ 			count++; 			printf("%d:\t%s\n", count, p); 		} 		p = strtok(NULL, " "); 	} 	 	return 0;	 }   运行结果如下： 引用1:      FORBES 2:      CEO

引用 2 楼 火柴先生 的回复:引用 1 楼 自信男孩 的回复:先确定单词，然后遍历单词，判断是否有小写字符。我认为最后判断应该是：是否全为大写字符 我的描述不是这样吗？先确定单词，就是在每个单词后面的第一个空格用'\0'填充，然后再遍历这个单词是不是全大写，这样应该没问题吧。 对于加不加'\0'都没关系，因为知道单词的开头，知道单词的结尾，做差就知道单词的长度了～

引用 5 楼 sdhexu 的回复:好人做到底，给你完善一下代码吧：   // 状态机 三种状态 public enum MachineState { 	START, 	UPPER_WORDS, 	NOTUPPER_WORDS }  // 判断一个字符是否为空白 private bool IsSpace( char c ) { 	return ( c == ' ' || c == '\t' || c == '\r' || c == '\n' ); }  // 判断一个字符是否为单词的分隔符，可以视情况将其他标点符号加入 private bool IsSeparator( char c ) { 	return IsSpace(c) || ( c == ',' || c == '.' ); }  // 判断所有字母为大写的单词个数 public int GetUpperWordsCount( string p ) { 	MachineState state = MachineState.START; 	int count = 0; 	foreach( char c in p ) 	{ 		switch( state ) 		{ 			case MachineState.START: 				if( c >= 'A' && c <='Z' )  // 如果第一个字符为大写，状态改变 					state = MachineState.UPPER_WORDS; 				else if( IsSpace( c ))     // 如果是空白，保持开始状态 					break; 				else                       // 其他情况，小写状态 					state = MachineState.NOTUPPER_WORDS;  				break; 				 			case MachineState.UPPER_WORDS: 				if( IsSeparator( c ))   // 如果遇到单词分隔，计数并改状态 				{ 					++count; 					state = MachineState.START; 				} 				else if( c>='A' && c <= 'Z' ) // 如果还是大写，保持状态 					break; 				else   // 其他情况（单词有不是大写的字符），进入非大写状态 					state = MachineState.NOTUPPER_WORDS; 				break; 				 			case MachineState.NOTUPPER_WORDS: 			    if( IsSeparator( c ))   // 直到遇到分隔符，否则都是非大写状态 				{ 					state = MachineState.START; 				} 				break;          } 	} } 今天看了下代码，发现您忽视了是要输出全为大写字母的单词的情况，如果考虑输出，还能否在一次遍历的情况下完成，这看起来很难。

引用 6 楼 sdhexu的回复:词法分析器，有穷自动状态机，是编译原理中的知识，它的好处是，连续多个空白符，很容易处理，不会影响计算结果。只遍历一遍字符，效率很高。。理解困难的话，画一个状态图，就容易理解了。   效率的确高，这是我C语言考试最后一道编程题里面的一部分内容，明天再好好看看您的代码，十分感谢！之前也上过编译原理的课，可以看出自己的确学艺不精，要好好努力！

很简单的词法分析器，有穷自动状态机。。效率是最高的，没有之一。   public enum MachineState {           START,           UPPER_WORDS, }  public int GetUpperWordsCount( string p ) {          MachineState state = MachineState.START;          int count = 0;          foreach( char c in p )          {                 switch( state )                 {                       case MatchineState.START:                             if( c >= 'A' && c <='Z' )                                   state = MachineState.UPPER_WORDS;                             break;                        case MatchineState.UPPER_WORDS:                              if( c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == ',' || c == '.' )                              {                                    ++count;                                    state = MatchineState.START;                              }                              else if( c>='A' && c <= 'Z' )                                     break;                              else                                    state = MatchineState.START;                             break;                 }          } }

我也认为应该先确定单词，在检查单词是否全部为大写。

先确定单词，然后遍历单词，判断是否有小写字符。


Question: 在vscode上运行正常但在pta上显示段cuo'wu

引用 2 楼 weaker1209 的回复:可以给我用动态数组检查鞍点的完整代码让我跑一下吗，不是很理解 你自己先研究一下判断鞍点的函数，根据形参，要什么参数传入什么参数就可以了

可以给我用动态数组检查鞍点的完整代码让我跑一下吗，不是很理解

int n, *max, *min, **a;     cin>>n;      if (n < 1 || n > 6) {         cout<<"Input error!"<<endl;         return -1;     }     max = new int [n];     min = new int [n];      a = new int *[n];     for (int i = 0; i < n; i++)         a[i] = new int [n];      for (int i = 0; i < n; i++)         for (int j = 0; j < n; j++)             cin>>a[i][j];   用动态数组  检查鞍点的方法：  void check_saddle_point(int (*point)[2], int (*array)[COL], int row, int col) {     int i, j, k, cnt = 0;     int row_idx, col_idx;     int max_row, min_col;      for (i = 0; i < row; i++) {         max_row = array[i][0];         col_idx = 0;         /* find max value in row */         for (j = 1; j < COL; j++)             if (max_row < array[i][j]) {                 max_row = array[i][j];                 col_idx = j;             }          /* Find min value in col */         min_col = array[i][col_idx];         row_idx = i;         for (k = 0; k < row; k++)             if (min_col > array[k][col_idx]) {                 min_col = array[k][col_idx];                 row_idx = k;             }         /* Check the condition*/         if (row_idx == i && min_col == max_row) {             point[cnt][0] = row_idx;             point[cnt][1] = col_idx;             cnt++;         }      } }


Question: C 中 fopen的文件名使用char数组的问题

我自己回复一下我自己吧，我已经debug出问题所在了  主要是我的txt文本是windows写的，传到Linux系统，然后换行符是\r\n，造成去掉最后一个\n后仍有一个\r去占据字符的长度，所以造成bug。  抱歉，浪费巨佬的时间了。

问题出在你没放代码的地方 readvariable() 里面，因为 ./data/0.txt 后面是 \r\n ,在win下正常去掉 \r\n 正常，在Linux下只去了 \n ,导致你的字符串为 ./data/0.txt\r

引用 2 楼 calmuse 的回复:[quote=引用 1 楼 自信男孩 的回复:]strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0.  因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。 非常感谢，是我记错了strcmp的函数功能，的确两个不相等，大佬，我能再多问一下吗？ 我用strlen看了一下，"./data/0.txt"的长度是12，而我从文本中读取出来的data_name是13，因为data_name最后我加了一个\0 我不明白的是，我看书上都说字符串最后会用\0作为结尾，为什么我在Linux上跑，"./data/0.txt"的长度就是12，不是13[/quote] strlen函数是不计算'\0'的，如果不同系统下不一样的，建议楼主看一下行结束符是不是不一样。把字符串打印出来看看有什么区别～

引用 1 楼 自信男孩 的回复:strcmp当比较的两个字符串不同的时候返回1或-1，当相同的时候返回0.  因此楼主的说的相同是不对的，代码恰恰提示的是data_name和./data/0.txt字符串不相同。 非常感谢，是我记错了strcmp的函数功能，的确两个不相等，大佬，我能再多问一下吗？ 我用strlen看了一下，"./data/0.txt"的长度是12，而我从文本中读取出来的data_name是13，因为data_name最后我加了一个\0 我不明白的是，我看书上都说字符串最后会用\0作为结尾，为什么我在Linux上跑，"./data/0.txt"的长度就是12，不是13


Question: c语言数组

total是整数不能用%.2f输出的，但是total/5.0是按照浮点数除法计算的，因此得到的是浮点数。所以用%.2f输出是没问题的～

printf()函数当输出的是浮点数时，[.precision]中的precision表示输出的小数的位数。.2f表示输出的浮点数包含2位小数。对于printf()函数的详细使用方法，请参考《C++中printf()函数的用法10-9》 希望能够帮到您！

输出的是total/5.0的值（平均数），5.0是浮点数，结果也会转成浮点数，保留2位小数

total是整数，total/5.0，就是双精度浮点数，%.2f意思保留两位小数输出


Question: 想求1到10的阶乘之和但运行程序老是得不到我要的结果，麻烦各位帮忙看一下问题出在哪了，现在烦恼着，谢谢大家了

~~~~~仅供参考

# include<stdio.h> int main(void) { 	int  i,j,con=0; 	for(i=1;i<=10;i++) 	{ 		int sum=1; 		for(j=1;j<=i;j++) 		{ 			sum=sum*j; 		} 		printf("%d\n",sum); 		con=con+sum; 	} 	printf("%d\n",con); 	return 0;  }

#include <stdio.h>  int main(int argc, char* argv[]) {    int a,b,c,d=0;    for(a=1; a<=10; a++)     {       c=1;       for(b=1; b<=a; b++)            c = c * b;//用c来计算阶乘       d+=c; //用d来计算和     }   printf("%d\n",d);   system("pause");   return 0; }

#include<stdio.h> int main() {     int a,b, k;     unsigned long c = 0;      for(a=1;a<=10;a++)     {         k = a;         for(b=1;k>0;k--)         {  b*=k;          }         c=c+b;     }     printf("%lu\n",c);     return 0; } 供参考～  二层循环里对a进行的修改～


Question: c语言写的程序，能编译运行，但是确无法在屏幕上显示结果

哦哦，懂了，谢啦

引用 2 楼 Am0_0mA 的回复:感谢！把x初始化和EOF改成'\n'后能输出结果了。 不过我不是很懂为啥缺少EOF输入。C程序设计语言这本书里面讲EOF是getchar函数在没有输入时返回的一个特殊值。当读取到文本流最后，已经没有下一个字符时，getchar函数不就应该返回EOF了嘛。为什么还要手动输入EOF作为结束符呢。 对EOF是文件末尾的标识符，所以你需要输入EOF，'\n'是行结束符，不是文件末尾～

x没有初始化，另外，EOF输入linux 用ctrl+d，Windows下用ctrl+z试试 楼主是缺少输入EOF，或者楼主缺少'\n'。  建议楼主把EOF改成'\n'试试～


Question: linux c下 const 用法问题。

会修改，不是给予提示。因为const修饰的是xyz数组，不能通过xyz数组去修改，但是其他的变量（指针）是可以修改的，不受限制。const修饰的并不是只读的内存。

给你段代码，跑一下就知道了  int main() {     const int a[] = {1, 2};     int *p = (int*)a;     //a[0]=2;     *p = 2;     printf("%d\n", a[0]);     return 0; }

修改啊，const 只是编译器级的不可修改，实际内存读写权限是系统相关的


Question: 反猜数游戏编程怎么做

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

这个比较难，有时间我尝试下 我印象中：猜数字游戏，中的数字，是不重复的。


一个字节8位，可以表示0到0xff,具体什么意思，要看他的程序要求啊

引用 1 楼 真相重于对错 的回复:这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据 还有就是编译时一直显示到达不了break，也没有死循环

引用 1 楼 真相重于对错 的回复:这是个无符号字符数组啊相当于一个字节数组，==0Xff表示这个数组第一个元素是否为0xFF，程序中用到7个case，表示它有7种可能，不是要求这个字符数组一定要有7个数据 这个数组为什么是5个字节？0xFF是什么意思？初始化的意思吗？

引用 7 楼 自信男孩 的回复:[quote=引用 6 楼 47897566 的回复:][quote=引用 5 楼 自信男孩 的回复:]CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？[/quote] 判断数据用的吧，比如协议数据按照什么格式，对端收到之后可以根据初始[0]值是否符合协议要求～[/quote] 明白了，感谢

你得看 CommandDatatable 数据哪里读出来的啊，这代码能看出啥？？

引用 6 楼 47897566 的回复:[quote=引用 5 楼 自信男孩 的回复:]CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？[/quote] 判断数据用的吧，比如协议数据按照什么格式，对端收到之后可以根据初始[0]值是否符合协议要求～

引用 5 楼 自信男孩 的回复:CommandDatatable[0]==0XFF 这是是CommandDatatable数组（或缓存）的第一个字节（元素）与0xff比较，判断是否相等。 有什么作用呢？


Question: 求解

第二行，int main（）后面多了“；”号。

main()后面不要加分号；

main(); //这里多了个分号，把它去掉


Question: 输出指定月份的天数，敲出代码输出结果有误，但我不知道错哪了，求指导

引用 楼主 forlorn pedestrian的回复:题目内容：输入年、月，输出这个月一共有多少天  输入：两个整数    输出： 对应月份天数  样例1：输入 2018 2    输出 28 #include<stdio.h> int main() { 	int a, b, c, d; 	scanf("%d%d", &a, &b); 	if ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0)){ 		if (b == 2) 			c = 29; 		if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) 			c = 31; 		if (b = 4 || b == 6 || b == 9 || b == 11) 			c = 30; 	} 	else if (b == 2); 		c = 30;	 		 if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12) 			c = 31; 		else if (b = 4 || b == 6 || b == 9 || b == 11)  			c = 30; 		else	printf("%d", c); 		return 0; } a % 100 == 0改成a％100！＝0；  if (b = 4 || b == 6 || b == 9 || b == 11)中b＝＝4；   else if (b == 2); c = 30;	 这里c＝28；  else	printf("%d", c); 这里的else去掉

//样例1：输入 2018 2    输出 28 #include<stdio.h> int main() {  #ifdef IF_ELSE     int a, b, c, d;     scanf("%d%d", &a, &b);     //if ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0)){     if (((a % 4 == 0) && (a % 100 != 0)) || (a % 400 == 0)){         if (b == 2)             c = 29;         if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12)             c = 31;         if (b = 4 || b == 6 || b == 9 || b == 11)             c = 30;     }     //else if (b == 2);     else if (b == 2)     c = 30;     if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12)         c = 31;     else if (b = 4 || b == 6 || b == 9 || b == 11)         c = 30;     else         printf("%d", c);  #else     int year, month, days = 0;     int leap = 0;      scanf("%d%d", &year, &month);      if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))         leap = 1;      switch (month) {         case 1:         case 3:         case 5:         case 7:         case 8:         case 10:         case 12:             days = 31;             break;          case 2:             days = 28 + leap;             break;          case 4:         case 6:         case 9:         case 11:             days = 30;             break;          default:             printf("Not support!\n");             break;     }      printf("%d", days); #endif     return 0; } 供参考`  有两个问题：闰年判断和if后面多一个分号；  另外，这个问题用switch case比较好一些，供参考～

引用if ((a % 4 == 0) && (a % 100 == 0) || (a % 400 == 0))闰年判断这句有误，a%100 !=0。这句引用if (b = 4 || b == 6 || b == 9 || b == 11)有误，b==4。整体逻辑判断错了，修改如下：#include <stdio.h>  int main(int argc, char* argv[]) {     int a=0, b=0, c=0;     printf("请输入年月：");     scanf("%d %d", &a, &b);     if (b == 2)       { if ((a % 4 == 0 && a % 100 != 0) || (a % 400 == 0))             {c = 29;}         else             {c = 28;}       }      else        if (b == 1 || b == 3 || b == 5 || b == 7 || b == 8 || b == 10 || b == 12)            { c = 31;}        else          if (b == 4 || b == 6 || b == 9 || b == 11)            { c = 30;}       printf("%d年%d月有%d天\n",a,b,c);      system("pause");      return 0; }

else if(b==2); //这里多了个分号 而且紧接着的c=30应该改成c=28  另外，else printf(“%d”, c) 前面的else去掉


Question: C语言中变量何时分配空间？

引用 24 楼 funnywhere 的回复:[quote=引用 23 楼 lin5161678的回复:][quote=引用 22 楼 funnywhere的回复:][quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案[/quote] 那就不叫答案吧，因为我看到一篇介绍gcc如何进行内存分配的文章，可以说找到正确的解释了。[/quote] 局部变量分配汇编指令 Intel 是 sub esp，xxx，ARM处理器是 sub     sp, sp, #xxx ，不管什么编译器，就这种方法，还正确答案，别逗

引用 28 楼 火花20180731 的回复:可执行文件相当于一个内存模板，系统会按照这个内存模板起一个进程，按模板中的内容为进程分配内存(给一个空闲的虚拟的地址区间，可与物理内存建立映射)，并填充初始数据。第一次进程运行结束后，占用的内存被释放，用过的地址区间再次空闲。第二次进程运行再次从这个空闲地址开始分配，所以两次地址打印相同。现代操作系统都是虚拟内存，进程间内存是互不相干的，跟第几次运行都没关系，即时同时运行也一样

引用 29 楼 funnywhere 的回复:[quote=引用 26 楼 赵4老师的回复:]理解和讨论之前请先学会如何观察！  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 确实很有道理。[/quote] 老赵的话，十年前就是复制粘贴的，水了一辈子了。

如果你的代码中没有使用某个变量，通常会被编译器优化掉（取决于编译器优化级别），如果你只读使用，编译器会将其优化为常量嵌入到代码中（立即数），只有你对它进行了写操作或者取地址，编译器才会为它实际分配空间

引用 23 楼 lin5161678的回复:[quote=引用 22 楼 funnywhere的回复:][quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案[/quote] 那就不叫答案吧，因为我看到一篇介绍gcc如何进行内存分配的文章，可以说找到正确的解释了。

引用 26 楼 赵4老师的回复:理解和讨论之前请先学会如何观察！  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！ 确实很有道理。

以前的老赵又回来了～～～

引用 22 楼 funnywhere的回复:[quote=引用 21 楼 lin5161678的回复:][quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了[/quote] 别扯 这只是黑盒测试 没什么能叫做答案

引用 21 楼 lin5161678的回复:[quote=引用 20 楼 funnywhere 的回复:] 并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢[/quote] 因为我找到正确答案了

引用 20 楼 funnywhere 的回复:并没有优化掉，都在的。 那么你的依据呢 你凭什么说 b变量还在呢

引用 19 楼 老马何以识途的回复:只單獨輸出a或b，是不是意味著這時候另一個變量在整個程序生命期中沒有用到？比如：  #include <stdio.h> #include <stdlib.h> int main() {     int b ;     int a ;     printf("%x\n",&a);  //只输出a的地址，本人机器上为61FE1C     system("pause");     return 0; }  這段程序中，b只在定義時出現一次。  這就是你要明白的其中一點：編譯器有優化功能，它掃描了整個程序發現b其實可以不要，於是就很可能被省略掉了。 那麽這個時候，不管你輸出的是a還是b，它的地址分配都是一樣的，即屬於該程序的變量空間只有一個整數。 并没有优化掉，都在的。

引用 13 楼 眼里有光～的回复:函数内部的变量是局部变量，比如你int a,b，这种非静态局部变量是放在栈上的，栈区是操作系统来管理的，程序在运行的时候操作系统自动为局部变量分配空间，局部变量出了作用域以后，操作系统自动回收这部分空间，也就是说不需要由程序员自己去申请和释放这块内存。  你上面出现的情况，每次运行单输出a和b的地址有时是一样的，这是正常情况，程序本次运行操作系统可能将这个地址分配给a，下次运行操作系统将这个地址分配给b，操作系统怎么分配栈区地址其实根本不用程序员操心。   感觉跟操作系统关系不大。感觉是gcc编译器的某种策略，换成msvc就没有这个现象。

短时间内一样的地址巧合而已。

引用 7 楼 qybao 的回复:[quote=引用 6 楼 funnywhere 的回复:] 你再给a也赋个值10000，你会发现如果只单独输出a或b的地址，也是一样的。 你把你的代码和运行结果贴出来看看 #include <stdio.h> #include <stdlib.h> int main() {     int b = 10000;     int a = 10000;     printf("%X\n",&b);   //你确定轮流注释这两句打印语句运行出来的结果一样？a，b同时被使用，编译优化不会舍弃任何一个，内存地址肯定不同     //printf("%X\n",&a);  //估计你代码哪里有问题，要不就是进程加载时不是重复使用原来的内存（这很正常）     system("pause");     return 0; }[/quote]

轮流注释地址就是一样的啊。试了好多种方案都不知道怎么解释。要不我就不会发帖问了。

程序加载到内存时才会分配内存，但是编译器会指定偏移量。比如数组会指定长度～


Question: 求大神解答

a未定义，maxxx函数接收的数组是不是不是a而是其他呢？

哦哦  明白了

i<a j<b c[i][j] 这里的a，b，c在哪里定义的？


Question: 为什么是按学号输出

我已经找到问题了，谢谢你们啦

就这些代码的话，第一个for连着第二个for循环那里就是给学号从大到小排序了，这可能就是他按学号输出的原因

但从这些代码里看不出为什么来。提供更多的代码吧，另外，直接贴代码，不建议贴图片～


Question: 萌新求助！关于浮点数的输出

浮点数格式 http://bbs.csdn.net/topics/390676437

是呀 浮点数输出根据精度不同 是会这样的  一般浮点数都是小数点后6位确保的 再后面的值就不一定是正确的了

引用 1 楼 user-4 的回复:printf("%6.2f".floatNum)：保留两位小数 说明：%6.2f 表明待打印的数（floatNum）至少占6个字符宽度（包括两位小数和一个小数点），且小数点后面有2位小数，小数点占一位，所以整数部分至少占3位。注意：这里的6是待打印的数至少占据的字符宽度，包括两位小数（如果小数不够两位用0补位，例如100.1打印出来为100.10）和一个小数点，所以整数部分至少占3个字符宽度。  1.单精度实数的有效位数一般为7位，输出6位小数，超出有效位数输出就是错误的。 2.双精度数有效位数一般为16位，输出6位小数，超出有效位数可能截断或错误值。 3.关于保留小数点后有效位数四舍五入，原则保留0位小数的时候，只要小数点后第一位>=5，就可以进位，但是保留1位或者2位等等，保留小数的后一位要>5才可以进位，否则就舍去。感谢😁


Question: 在linux 中用open操作文件，用O_EXCL创建一个不存在的文件直接报错

O_EXCL 表示如果要创建的文件已存在，则出错，同时返回 -1，并且修改 errno 的值。


Question: 按要求输出 数组

题目要求输入都结束后结果一起输出，你这是输入一个就输出一个，和要求不符合。应该把结果都保存到数组里，最后一起输出


Question: 小白求问 关于用union共用体构造混合数组

100个元素你都当做int就可以了（以占用空间最大的数据类型为主），int本来就可以存char，所以20个元素存int，20个存char完全没问题。

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

不可以自选，对于联合体，联合体的长度是有元素中占用空间最大的决定，比如第一个联合体有一个int，一个char，这两个元素共用一个内存，那就是int类型的长度，因为sizeof(int) > sizeof(char)

你怎么写的？？？


Question: 有大佬知道这个报错怎么改吗，感谢

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


Question: 回文陷阱

#include<stdio.h> #include<math.h>  long long int back(long long int n);  int main(void) {     int i;     long long int n,b;     scanf("%lld",&n);     if(n==back(n))         printf("HW\n");     else     {         for(i=1;i<=10;i++)         {              b=back(n);             n=n+b;             if(n==back(n))             {                 printf("%d %lld\n", i, n);                 break;             }         }         if(i>10)             printf("NONE\n");     }      return 0; } long long int back(long long int n) {     //long long int len,i,d,s=0;     long long int s=0;     int len, i, d;     len=log10(n)+1;     printf("len = %d\n", len);     for(i=1;i<=len;i++)     {         d=n%10;         s=s*10+d;         n=n/10;     }     return s; } 供参考～  back参数和返回值有点问题，其他暂未发现问题～

引用 3 楼 user-2 的回复:for(i=1;i<=10;i++) {  b=back(n); n=n+b; if(n==back(n)) { printf("%d %lld\n",i,n); break; }	 } if(i>10) printf("NONE\n"); 在你这个循环里i永远小于10，也就下面的if永远不会成立，建议改成如下代码（仅供参考） for(i=1;;i++) {  b=back(n); n=n+b; if(n==back(n)) { printf("%d %lld\n",i,n); break; }	 if(i>10) { printf("NONE\n"); break; } }   楼主这部分没问题，注意i <= 10当i> 10时就是退出循环了。  引用 4 楼 user-2 的回复:补充一下，形参和实参还是不要同名要好一些（虽然这个函数里没什么问题）  被你的一句话给误解了。楼主的没问题。因为for循环是提前退出还是执行完退出的问题。  你如果认为楼主的有问题，建议自己再梳理一下逻辑～

if(i>10)             printf("NONE\n"); 这儿改成i >= 10

谢各位仁兄回复。

补充一下，形参和实参还是不要同名要好一些（虽然这个函数里没什么问题）

望各位仁兄，帮帮忙。提交时总是验证为答案错误，不知何因。


Question: c语言

因为你的while判断条件是x，而你在循环里并没有修改x的值，x>0一直满足，跳不出循环。应该在循环里加个修改x的语句，比如--i;

引用 2 楼 呆萌霍比特人的傻大脚板的回复:因为第一个scanf在循环体外,只执行一次.如果不写这行,那么while就没有存在的必要,反正你就算一次, 好的谢谢。。

引用 1 楼 user-3的回复:因为while循环没有终止的条件啊，它会一直一直循环下去 好的谢谢。。

因为while循环没有终止的条件啊，它会一直一直循环下去


Question: easyx is only for C++

引用 楼主 诗岑 的回复:编译器VS2019 一直给我报这个错 是版本不兼容吗？ 可能你建立的是C语言工程，EasyX只支持C++ 你将源文件的后缀改为.cpp试试

还是不行

我也是一样的问题，下面还是说easyX is only for C++


Question: code blocks上算例题都是对的，但提交OJ时说我的例题都错了，试了好久，大佬帮帮吧

做出来了，

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


Question: 指针与函数搞得我头昏脑胀     求解错误

结构体的date长度没指定 把 int date[] 改成 int date[N]

报错的展示出来


Question: 关于NAND FLASH控制器的寄存器。

如果我的SoC里没有这些寄存器，是不是也可以自己定义，然后使用啊？

除非你SoC不支持NandFlash，否则肯定有这些寄存器，上面你列的这些寄存器都是NFlash标准的，接口又不是GPIO可以模拟的，必须要通过控制器完成。 看下SoC spec文档，如果支持，那么肯定有，可能名称不一定完全一样。


Question: 大佬帮帮，oj上提示输出超限，codeblock上是正常的

把n改成unsigned long或unsigned long long试试

引用 1 楼 user-2的回复:int类型（整数类型）的范围为-2^31 ~ 2^31-1，即-2147483648~2147483647 题目要求输入数字是<2^32 对于2^31~2^32-1的数字 你的程序是不是无法判断啦 谢谢，我做出来了。


Question: 向函数传递数据结构 小白求问！！！

谢谢各位 弄懂啦！感谢对小白的帮助~

函数传数组时用数组的名字就可以了，用name[30]这样是传数组元素（下标为30的元素），所以意思不一样

..... strcpy(char *dst , char *src)，你要传入地址进去  例如strcpy(stu[i].name , stu[j].name)

把for语句里name后面的[30]去了再试试


Question: C语言：编写一个函数，输出整数m的全部素数因子。（m=120,素数因子为：2，2，2，3，5）

引用 4 楼 火柴先生 的回复:[quote=引用 2 楼 yqy1234hf 的回复:]这个是不可能绕过素数判断的   自己写循环  被除数/最小素数A/最小素数B/...最小素数N    看看能否除尽    如果不能就把素数表长度减少一位  然后增大最后一个素数 判断是否能除尽    去穷尽所有的素数对就可以了您可以看一下三楼的回复[/quote] 嗯嗯  我题目理解错了   你这个应该就是求素数因子   简单的说就是能整除某个数的队列中的质数?  我理解的对吗？

引用 3 楼 user-2 的回复: void AllFactor(int nInput) { 	printf("%d的全素数因子：", nInput);  	for (int i = 2; i <= nInput; ++i) 	{ 		if (nInput % i == 0) 		{ 			printf("\t%d", i); 			nInput /= i--; 		} 	} } 谢谢这应该就是我想看到的代码，我所担心的会不会在这个过程中输出非素数因子，在循环过程中其实不可能出现的，因为如果出现非素数，那么他一定可以在次数更低的循环中找到它对应的素数因子并输出，是不是这样?

引用 2 楼 yqy1234hf 的回复:这个是不可能绕过素数判断的   自己写循环  被除数/最小素数A/最小素数B/...最小素数N    看看能否除尽    如果不能就把素数表长度减少一位  然后增大最后一个素数 判断是否能除尽    去穷尽所有的素数对就可以了您可以看一下三楼的回复


Question: 不能读入,请大佬分析一下

晕啦,malloc没打上去,怎么看都没看你出问题

p = (struct node*)(sizeof(struct node));  p->a = b;//此处为啥不能读入  这个是什么语法？ 是要malloc吗

if (t->next == NULL || t->next->a > b) 		{ 			// p = (struct node*)(sizeof(struct node)); 			p = (struct node*)malloc(sizeof(struct node));  			p->a = b;//此处为啥不能读入 			p->next = t->next; 			t->next = p; 			break;  		}


Question: 各位大佬，帮忙看看！

void ChongDongDeHua1(void) { 	int nInit = 1; 	int nNum[3] = { 0, 0, 0 };  	printf("输入小时数：");  	int nHour = 0; 	scanf_s("%d", &nHour);  	for (int i = 0; i < nHour; ++i) 	{ 		if (i == 0) 		{ 			nNum[i] = nInit; 		} 		else 		{ 			nNum[2] += nNum[1]; 			nNum[1] = nNum[0]; 			nNum[0] = nNum[2]; 		} 	}  	int nTotal = nNum[0] + nNum[1] + nNum[2];  	printf("输出病毒数：%d\r\n", nTotal); }  void ChongDongDeHua2(void) { 	int nSampleMax = 20; 	printf("最多%d个小朋友\r\n", nSampleMax);  	int* pSample = new int[nSampleMax];  	int nInput = 0; 	int nTotal = 0; 	int nSampleCount = 0; 	 	while (true) 	{ 		scanf_s("%d", &nInput);  		if (nInput == -1) 			break;  		if (nSampleCount >= nSampleMax) 		{ 			delete[] pSample; 			printf("输入错误，最多%d个小朋友\r\n", nSampleMax); 			return; 		}  		pSample[nSampleCount++] = nInput; 		nTotal += nInput; 	}   	if (nTotal % 2 == 0) 	{ 		int nLoopCount = nSampleCount / 2; 		int* pID = new int[nLoopCount];  		for (int i = 0; i < nLoopCount; ++i) 		{ 			int nSelect = i + 1; 			int nAddID = 0;  			pID[nAddID] = 0;  			while (pID[0] + nSelect <= nSampleCount) 			{ 				int nPreAddID = nAddID; 				while (nAddID + 1 < nSelect && pID[nAddID] + 1 < nSampleCount) 				{ 					pID[nAddID + 1] = pID[nAddID] + 1; 					++nAddID; 				}  				if (nAddID + 1 < nSelect) 				{ 					nAddID = nPreAddID; 				} 				else 				{ 					int nSubTotal = 0; 					for (int j = 0; j < nSelect; ++j) 					{ 						nSubTotal += pSample[pID[j]]; 					}  					for (int j = pID[nAddID]; j < nSampleCount; ++j) 					{ 						nSubTotal -= pSample[pID[nAddID]]; 						pID[nAddID] = j; 						nSubTotal += pSample[pID[nAddID]]; 						 						if (nSubTotal == nTotal / 2) 						{ 							printf("能否均分：Yes\r\n");  							printf("组合结果："); 							for (int k = 0; k < nSelect; ++k) 							{ 								printf("%d ", pSample[pID[k]]); 							}  							printf("\r\n");  							delete[] pSample; 							delete[] pID; 							 							return; 						} 					} 				}  				if (nAddID == 0) 					++pID[nAddID]; 				else 					++pID[--nAddID]; 			} 		} 	}  	delete[] pSample;  	printf("能否均分：No\r\n"); }


Question: dev c++ 数据结构编译运行caption问题

引用 3 楼 自信男孩 的回复:bool ListDelete(SqList *&L,int i,ElemType &e) {     int j;     if(i<1 ||i>L->length)         return false;     i--;     e=L->data[i];     //for(j=i;L->length-1;j++) {     for(j=i; j < L->length-1;j++) {         L->data[j] = L->data[j+1];     }     L->length--;     return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧大佬知道怎么解决么

引用 3 楼 自信男孩 的回复:bool ListDelete(SqList *&L,int i,ElemType &e) {     int j;     if(i<1 ||i>L->length)         return false;     i--;     e=L->data[i];     //for(j=i;L->length-1;j++) {     for(j=i; j < L->length-1;j++) {         L->data[j] = L->data[j+1];     }     L->length--;     return true; } 供参考～ 找一下自己的问题～ 数组越界访问，出现段错误～不细心吧修改后还是报错

#include"sqlist.cpp"  int main()  {  	SqList *L;  	ElemType e;  	printf("顺序表的基本运算如下：\n");  	printf("(1)初始化顺序表L\n");  	InitList(L);  	printf("(2)依次插入a,b,c,d,e元素\n");  	ListInsert(L,1,'a');  	ListInsert(L,2,'b');  	ListInsert(L,3,'c');  	ListInsert(L,4,'d');  	ListInsert(L,5,'e');  	printf("(3)输出顺序表L：");DispList(L);  	printf("(4)顺序表L长度：%d\n",ListLength(L));  	printf("(5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));  	GetElem(L,3,e);  	printf("(6)顺序表L的第3个元素：%c\n",e);  	printf("(7)元素a的位置：%d\n",LocateElem(L,'a'));  	printf("(8)在第4个元素位置上插入f元素\n");  	ListInsert(L,4,'f');  	printf("(9)输出顺序表L:");DispList(L);  	printf("(10)删除L的第3个元素\n");  	ListDelete(L,3,e);  	printf("(11)输出顺序表L:");DispList(L);  	printf("(12)释放顺序表L\n");  	DestroyList(L);  	return 1;  }

你的函数调用在哪里，main函数在哪里？


Question: C语言题目

应该是吧，能帮忙写一下吗？

绕，没看懂什么意思。 是不是表达要用字符数组排序，用数组下标查找


Question: 请问用clang-format格式化代码时，如何设置取消数组自动合成一行的格式

这个配置参数起作用BinPackArguments: true

找到答案了，用// clang-format off关闭就好了

搜astyle


Question: 最近碰到一个特别搞人心态的事情，是关于C语言连续输入两个字符串的问题

#include <stdio.h> #include <string.h> const int TXTLEN=8; int main(){     char text[TXTLEN+1], key[TXTLEN+1];     rewind(stdin);     printf("Please input key(%d bytes):",TXTLEN);     fgets(key,TXTLEN+1,stdin);     if ('\n'==key[strlen(key)-1]) key[strlen(key)-1]=0;     printf("%s\n",key);     rewind(stdin);     printf("Please input text(%d bytes):",TXTLEN);     fgets(text,TXTLEN+1,stdin);     if ('\n'==text[strlen(text)-1]) text[strlen(text)-1]=0;     printf("%s\n",text);     printf("(%s)%d,(%s)%d\n", key, strlen(key),text, strlen(text));     return 0; } //Please input key(8 bytes):123456789 //12345678 //Please input text(8 bytes):123456789 //12345678 //(12345678)8,(12345678)8 //

引用 1 楼 自信男孩 的回复:亲测没问题呢，结构都是8；  楼主的代码没有定义TXTLEN的长度，可能在别处定义了，没有发出来。如果这个TXTLEN定义8，那么是可能是16的。 自测时用的TXTLEN是32


Question: 麻烦各位帮我们看看这个怎么做？萌新实在不会……

你需要理解，在计算机的大脑里没有1234xx等数字，都是0,1的值。因此只需要通过移位和&操作，就可以把一个十进制（其他进制）对应的二进制的每一位给算出来～

用&来做吧，&的效率应该是更快一些～

是单纯的模2求余数？还是十进制转二进制吗？ 如果是前者，用与运算即可，即和1做&运算 比如 int main() {     int a=5;     printf(“%d模2的余数为%d\n”, a, a&1); //a和1做&运算即为a模2的余数     return 0; }  如果是前者，十进制转2进制，那就多一步移位运算 比如 void tobinary(int n) {     int a = n&1; //模2求余     if (n>1) {         tobinary(n>>1); //右移1位相当于除以2     }     printf(“%d”, a); //打印二进制 } int main() {     tobinary(5); //打印5的2进制     return 0; }  以上代码都不出现除法和取模，但是都达到同样的效果


Question: 关于数组与结构体赋值

赋值有两种形式，一种是把源变量的内容复制到目的变量，一种是让目的变量的地址等于源变量的地址。理解这两种的区别，你就明白了你的问题

数组变量，数组名其实表示的是常量地址，所以b=a；相当于把a的地址赋值给b，但是实际上b的地址也是常量，所以不能赋值 结构体 变量名难道不是表示常量地址吗？不理解

引用 3 楼 宇来风满楼 的回复:能啊,用已定义数组赋值给新数组 #include <stdio.h>  int main() {     char a[]="abcdefg";     char b[10];     b=a;     printf("%s\n",b);     return 0; } 上面的编译就无法通过； 而下面的才能通过： #include <stdio.h> #include<string.h>  int main() {     char a[]="abcdefg";     char b[10];     for (int i=0;i<strlen(a);i++)         b[i]=a[i];     printf("%s\n",b);     return 0; }

能啊,用已定义数组赋值给新数组

能啊,用已定义数组赋值给新数字

struct book{ char name[10]; char auther[10]; float value; }; struct book math; math=(stuck book){"studymath","john",45.3};


Question: 请教 控制台传参数只能输出首个字符

是字符集的问题，忽略了这个，改成多字符集或者 输出%ws 就可以了。感谢1楼

楼主执行的操作是什么，比如./a.out a 5？

你这个TCHAR是不是wchar呀，把%s改成%ws试试


Question: 强制类型转换时遇到的数据错误

浮点数格式 http://bbs.csdn.net/topics/390676437

float值有效位数6位，前6位保证有效，之后不保证。 计算机使用32位，存储float类型有关，IEEE754标准 可以使用64位的double声明，double可以保证15位有效

float值有效位数6位，前6位保证有效，只有不保证。 计算机使用32位，存储float类型有关， 可以使用64位的double声明，double可以保证15位有效

float有效数字只有6位 请换double


Question: C语言

void AssisTest(void) { 	int nMaxInput = 20;  	char* pL2W = new char[nMaxInput + 2]; 	char* pW2L = new char[nMaxInput + 2]; 	char* pNum = new char[nMaxInput + 2];  	*pL2W = 0; 	*pW2L = 0; 	*pNum = 0;  	int nInput = 0; 	for (int i = 0; (nInput = getchar()) != 10; ++i) 	{ 		if (i >= nMaxInput) 		{ 			printf("总数不超过20个！\r\n"); 			return; 		}  		if ('a' <= nInput && nInput <= 'z') 		{ 			pL2W[++*pL2W] = nInput - 'a' + 'A'; 		} 		else if ('A' <= nInput && nInput <= 'Z') 		{ 			pW2L[++*pW2L] = nInput - 'A' + 'a'; 		} 		else if ('0' <= nInput && nInput <= '9') 		{ 			int nMinID = 0; 			int nMaxID = *pNum - 1; 			int nInsertID = nMinID;  			while (nMinID <= nMaxID) 			{ 				nInsertID = (nMinID + nMaxID) / 2;  				if (pNum[nInsertID + 1] < nInput && nInsertID == nMinID) 				{ 					++nMinID; 					++nInsertID; 				} 				else if (pNum[nInsertID + 1] < nInput) 				{ 					nMinID = nInsertID; 				} 				else if (pNum[nInsertID + 1] == nInput) 				{ 					break; 				} 				else if (nMaxID == nInsertID) 				{ 					--nMaxID; 				} 				else 				{ 					nMaxID = nInsertID; 				} 			}  			for (int j = *pNum - 1; j >= nInsertID; --j) 			{ 				pNum[j + 2] = pNum[j + 1]; 			}  			++*pNum; 			pNum[nInsertID + 1] = nInput; 		} 		else 		{ 			printf("要求：随机输入数字 大写 小写字母！\r\n"); 			return; 		} 	}  	pL2W[*pL2W + 1] = 0; 	pW2L[*pW2L + 1] = 0; 	pNum[*pNum + 1] = 0;  	printf("小变大：%s\r\n", pL2W + 1); 	printf("大变小：%s\r\n", pW2L + 1); 	printf("数字排序：%s\r\n", pNum + 1);  	delete[] pL2W; 	delete[] pW2L; 	delete[] pNum; }


Question: C语言问题


Question: C语言

字母大小写视为相同吗？

需求不明确，建议楼主细化一下吧

没看懂，你这输入与输出，有啥逻辑关系


Question: 这个文本编辑器，各位大佬有没有啥思路？

结构体啊。。。。


Question: exe触发断点问题

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

大佬们这个出发短点咋个办那


Question: 计算星期值

你自己不都说了么，四闰百不闰，四百闰，你把100,200,300,500,600,。。。这些给当成闰年再算，结果肯定有问题啊

# include <stdio.h> int main() {     int year,t,s,day;      scanf("%d",&year);      t=(year-1)/4;      s=(year-1)%4;      switch(s)     {         case 0:day=t*(365*3+366);break;         case 1:day=t*(365*3+366)+365;break;         case 2:day=t*(365*3+366)+365*2;break;         case 3:day=t*(365*3+366)+365*3;break;      }     int i;      i=day%7;      switch(i)     {         case 0:printf("星期天\n");break;         case 1:printf("星期一\n");break;         case 2:printf("星期二\n");break;         case 3:printf("星期三\n");break;         case 4:printf("星期四\n");break;         case 5:printf("星期五\n");break;         case 6:printf("星期六\n");break;     }     return 0; } 供参考～  case 0改成星期天，其他依次修改一下i值对应的星期值就可以了～  case0不就是7%7得0吗？怎么把0改成星期一了呢？

有测试用例吗？发一下，不知道你说的哪里错是测试出错，还是其他错误？


Question: 圆锥体积

上面那老哥说的对，V=PI*r*r*h*(1/3); 这句错误，1 和 3 均为整形，两个相除的商也应该是整形，所以 1/3=0 ，应该用 1.0/3 或者 1/3.0

V=PI*r*r*h*(1/3);这句有问题   1/3计算机中结果是0  整形相除 改一下 V=PI*r*r*h*(1.0/3);

V=PI*r*r*h*(1/3); 这句错误，修改如下： #include<stdio.h> #include<stdlib.h> #define PI 3.14  int main(int argc, char* argv[]) {     int r,h,l;     float S,V;     r=5;     h=12;     l=13;     S=PI*r*l+PI*r*r;      V=PI*r*r*h/3;//这句修改     printf("表面积S=%f\n体积V=%f\n",S,V);     system("pause");     return 0;

代码没问题啊，或者你把r,h.l换成浮点型试试


Question: scanf()格式说明符

引用 2 楼 自信男孩 的回复:都可以连写也可以单写，需要注意的是%c处理起来比较麻烦。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。

都可以连写也可以单写，需要注意的是%c处理起来比较麻烦。

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


Question: 8.52的二进制

eb和ec刚好差1，反码和补码也是1的关系，计算机存储是补码

你看错了，前面的是低位，后面是高位， 你没发现你算的是41，08，51，eb; 正好和他的相反吗？至于是ec,eb，不过是浮点的精度问题


Question: 请问我这个代码为啥运行不了啊？自己找不到错误，有能力的老哥帮帮忙吧谢谢了。

学会调试


Question: 数组初始化

引用 17 楼 qzjhjxj 的回复:引用所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？这里 int a[10] = {1}，后面是大括号{}，就是数组10个元素都被初始化为1，而不是a[0]被初始化为1。如果要a[0]初始化为1，应该是a[10]=1. a[10] = 1;这个操作已经数组越界了，下表最大10-1   建议你自己试试，写几条语句试试，然后再发表看法，或许更有说服力。 一维数组初始化（定义式），不用大括号，你打算用什么来初始化？

引用 15 楼 自信男孩 的回复:[quote=引用 11 楼 SleekStone 的回复:][quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 对，自测一下就好了～[/quote]我想说的在14楼，不过刚刚看到外面有个帖子https://bbs.csdn.net/topics/398136483，我觉得那里面5楼的兄弟说得有道理

引用 11 楼 SleekStone 的回复:[quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote] 对，自测一下就好了～

引用 12 楼 xian_wwq 的回复:[quote=引用 11 楼 SleekStone 的回复:][quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote]  确实如此，在环境中跑一下，一目了然[/quote]我的意思不是在怀疑这个结果，我是在怀疑这个表述“int a[10]={0}的时候，10个元素都被初始化为0，int a[10]={1},只有a[0]被初始化为了1，其它被初始化为了0”，这种表述我不知道正不正确，我依稀记得我上学的时候老师说的是“int a[10]={x}，只有第一个元素被初始化为了x，其它元素值是由编译器提供实现的，有的编译器会设成0”，如果我记得没错的话，就意味着对于int a[10]={x}，C++标准只规定了a[0]，初始化为x，其它值标准是不做保证的，我刚才去找了找看能不能找到这个标准，可惜我没找到，如果有朋友找到相关的标准了，也希望告知我一下，

1. 直接给每个元素赋值 int array[4] = {1,2,3,4}; 2. 给一部分赋值，后面的全部为0 int array[4] = {1,2}; 3. 由赋值参数个数决定数组的个数 int array[] = {1,2}; 4. 数组元素的值是随机分配的 int array[4] = {}; 当初始化参数时，推荐使用 int array[4] = {0};

引用 11 楼 SleekStone 的回复:[quote=引用 10 楼 自信男孩 的回复:][quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？[/quote]  确实如此，在环境中跑一下，一目了然

引用 10 楼 自信男孩 的回复:[quote=引用 8 楼 SleekStone 的回复:][quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.[/quote]所以你的意思是：int a[10] = {0}的时候，10个元素都被初始化为了0，int a[10] = {1}的时候，只有a[0] 被初始化为了1，其它都为0？

引用 8 楼 SleekStone 的回复:[quote=引用 6 楼 自信男孩 的回复:][quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？[/quote] 为什么不自己写个程序试一下呢？  除了第一个a[0]为1，其他都是0.  一般初始化，都是初始化为0.

引用 4 楼 自信男孩的回复:[quote=引用 3 楼 m0_51355118 的回复:]错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样 k是可变的，数组长度是不确定的～[/quote] c99允许这样定义和使用，只是无法初始化，要另外赋值

引用 6 楼 自信男孩 的回复:[quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.[/quote]int a[10] = {1};这样呢？

引用 5 楼 user-6 的回复:[quote=引用 1 楼 SleekStone 的回复:]int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0不会  有初始化没指定初始化项都会初始化为0[/quote]int a[10] = {1};这样呢？

引用 1 楼 SleekStone 的回复:int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0。你这个代码的主要问题在于int a[k]，数组声明的时候，长度应该是个常量，不应该是你这种运行时计算出来的变量。 这样写，都被初始化为0,10个元素都会被初始化0.

引用 1 楼 SleekStone 的回复:int a[10] = {0};这样初始化是可以的，但是只有a[0]被初始化为了0不会  有初始化没指定初始化项都会初始化为0

引用 3 楼 m0_51355118 的回复:错误提示很清楚啊，可变大小的对象不能被初始化。可以先定义int a[k],b[k];然后用memset给数组赋值。像memset(a,0,sizeof(a));这样 k是可变的，数组长度是不确定的～

a数组是不确定大小的，大小由n决定。C语言不支持可变数组。楼主可以用动态申请空间形式申请空间（当做数组用）  a = (int *)malloc(sizeof(int) * k); if (!a)     exit(0); memset(a, 0,  k * sizeof(int));


Question: 大神求救，这个为什么会报错   没定义 ？

[quote=引用 3 楼 自信男孩 的回复:]#include<stdio.h> //    int main() int getcount(int n) {     int i,count;     if(n>60)         count++;     return count; } int main() {     int n,count=0;     printf("input a numble:\n");     scanf("%d",&n);     count=getcount(90);     printf("%d",count);     return 0; }  供参考～  getcount函数里的count是未初始化的，需要注意下～[              谢谢

修改后是这样：#include<stdio.h> int getcount(int n) { int count; if(n>60) count++; return count; } int main() { int n,count=0; printf("input a numble:\n"); scanf("%d",&n); count=getcount(n); printf("%d",count); return 0; }

int main()//这一行必须取消 int getcount(int n) { int i,count; if(n>60) count++; return count; } int main() { int n,count=0; printf("input a numble:\n"); scanf("%d",&n); count=getcount(90);//这行调用getcount()函数，应该是count=getcount(n);才正确 printf("%d",count); return 0; }


Question: 判断输入括号是否成对

相等的时候为什么输出为空啊

多分号～需要注意下～

引用 1 楼 一颗白面馒头的回复:while循环里面的if条件判断后面不加分号 。。。。我去，我忘记把删除语句后面的分号也删了

while循环里面的if条件判断后面不加分号


Question: C程序设计语言-练习1-6，问题求助

没有问题，我故意不加括号的，不是为了读取字符，而是为了测试EOF，最终的输出只有1和0

个人觉得应该和系统环境以及编译器或者IDE有关，不是每种组合的运行结果都是这样，我的linux+gcc输入ctrl+z就会提示已停止，不会输出0。

while(ch = getchar() != EOF) 改一下  while((ch = getchar()) != EOF) 因为!=优先级比=高，因此会把判断结果赋值给ch，而不是getchar()的返回值赋值给ch


Question: 小白求问，真的很简单

谢谢各位的解答 懂了！谢谢各位！

while循环结束后，p已经指到了数组的最后一个元素地址 而s则表示这个数组第一个元素的首地址 所以这里可以直接用p-s

没有代码没有真相

这里可以填p-s;并且后面的注释也说明了这一点。 另外，需要注意的是myStrlen函数的s，虽然写的是数组形式，其实是指针，因为编译器已经将其按照指针处理的。  从另一个知识点也能证明这里不是数组，而是指针，根据参数传递是值传递，是实参赋值给形参（可以这么理解），如果形参是数组名，根据数组名不能做左值，因此就矛盾了。  所以，形参数名字写成数组，直接可以理解为指针就好了。


Question: fgets函数相关问题

引用 2 楼 自信男孩的回复:楼主的程序fgets放在一个while循环里，自然后面的覆盖前面的。改成每次fgets之后都去判断空格，字符，数字等等即可～   建议判断一下fgets的返回值。另外，注意fgets会把回车符号加到缓存里～ 主要是我之前不知道fgets遇到回车就结束了，后来调试发现不对劲，才找到的原因

已解决，每次读取到回车后fgets都会结束读取，出现这个情况的原因是后来的读取的数据将前面的数据给覆盖了


Question: 求助大佬这个用c语言怎么写

#include<stdio.h> int main(){ 	int n, a, b; 	scanf("%d", &n); 	a = 0; b = n - 1; 	for(int i = 0; i < n; i ++){ 		for(int j = 0; j < n; j ++){ 			if(a == j || b == j) 				printf("*"); 			else 				printf(" "); 		} 		a ++; b --; 		printf("\n"); 	} 	return 0; }


Question: 两个压缩矩阵怎样实现相乘

给LZ一段代码参考吧  int** toMatrix(int n, char c) { //对称压缩矩阵转矩阵（沿对角线存储半个恢复回原来的矩阵）     int i, j, k, t, l;     int **a = (int**)malloc(sizeof(int*)*n);     for (int i=0; i<n; i++) {         a[i] = (int*)malloc(sizeof(int)*n);     }     l = n*(n-1)/2 + n;     printf("生成矩阵%c, 请输入%d个压缩矩阵中的数：\n", c, l);     for (i=0; i<l; i++) {         scanf("%d", &t);         for(j=1; j<=n; j++) {             for (k=1; k<=j; k++) {                 if (j*(j-1)/2+(k-1)==i) {                     a[j-1][k-1] = t;                     a[k-1][j-1] = t;                 }             }         }     }     return a; }  int** multiplyMatrix(int **a, int **b, int n) { //矩阵乘法(必须满足矩阵A的列数和矩阵B的行数相同，本题忽略，都是n*n矩阵)     int i, j, k, s;     int **c = (int**)malloc(sizeof(int*)*n);     for (int i=0; i<n; i++) {         c[i] = (int*)malloc(sizeof(int)*n);     }     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             s = 0;             for (k=0; k<n; k++) {                 s += a[i][k]*b[k][j];             }             c[i][j] = s;         }     }     return c; }  void destoryMatrix(int **a, int n) {     int i;     for (i=0; i<n; i++) {         free(a[i]);     }     free(a); }  int main() {     int n, i, j, **a, **b, **c;     printf("请输入阶数n：\n");     scanf("%d", &n);     a = toMatrix(n, 'A');     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             printf("%5d", a[i][j]);         }         printf("\n");     }          b = toMatrix(n, 'B');     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             printf("%5d", b[i][j]);         }         printf("\n");     }          printf("A * B = \n");     c = multiplyMatrix(a, b, n);     for (i=0; i<n; i++) {         for (j=0; j<n; j++) {             printf("%5d", c[i][j]);         }         printf("\n");     }          destoryMatrix(a, n);     destoryMatrix(b, n);     destoryMatrix(c, n); }

你这个是压缩矩阵，是沿对角线存储了半个。

引用 3 楼 zgl7903的回复:理解矩阵乘法 我这知道怎样乘，但就是压缩矩阵不会乘

理解矩阵乘法

引用 1 楼 老马何以识途的回复:一維數組就要定位行列了，其實也簡單，A第x行第y列就是A[(x - 1) * n + (y - 1)] 能具体讲一下吗


Question: 求帮助，急，介绍一下

你的程序块中的','换成';'

if(a<b)     {         c=a,a=b,b=c;     } 这一步用于保证a >= b；否则执行if内的交换  while(b!=0)     {         c=a%b,a=b,b=c;     } 这一步可以考虑学习一下最大公约数的求值算法～

d=a,e=b; c=a,a=b,b=c; c=a%b,a=b,b=c; 不知道原题是什么，但我想不会是测试逗号表达式吧，所以认为这几句逗号应该是分号。整理代码如下   #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> int main() {     int a, b, c, d, e;     scanf("%d%d", &a, &b);     d = a;     e = b;     if (a < b)    //交换，如果a小于b,则两数交换     {                 c = a;         a = b;          b = c;             }     while (b != 0)     {                 c = a % b;   //循环求模              a = b;                b = c;             }     printf("%d\n%d\n", a, (d*e) / a);     return 0; }

这个就是一个求两个数的最小公倍数和最大公因数的代码


Question: 有大佬能解释一下吗

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

printf("%c\n", *string_p++); printf("%c\n", string_p[1]); 第一个printf是因为++后后增，因此是先求表达式的值，即(*string_p++)，然后自增string_p指针，指向'8'的地址， 第二个是在第一个基础上的，因此string_p[0]是'8'，string_p[1]即'4'了。

这个其实就是指针的使用了  多去看看指针的定义吧 char* string_p = "48430";   //此时 指针指向字符串的首地址，也即字符串首个字符的地址  该地址的值是'4'  即此时*string_p=4 printf("%c\n", *string_p++);  //* 和后置++优先级是一样的，但是他们的结合顺序是自右向左的 所以先执行的的string_p++,string_p指向下一个值得地址，*string_p 取值为4 printf("%c\n", string_p[1]);   //刚才的string_p自增了 此时string_p指向的'8'  string_p[1]表示之后的第2个字符  也就是4  是8后面的4

String_p是一个字符串数组的名称 = 第一个字符的地址，所以*string_p == 4 ,又因为后面有++，所以字符数组指针后移，string_p[0] = 8,所以 string_p[1] = 4


Question: 请问大神到地使出了什么问题，为什么c,b输不上。

输入时，a b c 之间为空格，不用，号

确认一下你的输入的逗号和scanf中的逗号是否一致，scanf是格式化输入，因此要按照scanf中第一个参数的格式输入。

你看一下 你输入的是不是中文的逗号

应该是逗号问题吧，代码中的是中文逗号，cmd中的是英文逗号，两个不一致导致的，建议别用逗号，用空格代替比较好，不容易出错

因为你输入的时候用的逗号是中文的，c语言符号一定要用英文！！


Question: 求指点数据结构链栈将一个十进制数转换为二进制数

#include <stdio.h> #include <malloc.h>  typedef struct node{     int data;     struct node *link; }NODE;  NODE *push(NODE *top, int m) {     NODE *p;//,top;     p=(NODE *)malloc(sizeof(NODE));     p->data =m;     p->link =top;     top=p;     return top; } NODE *pop(NODE *top, int *x) {     NODE *q;     q=top;     top=top->link ;     *x = q->data;     free(q);     return top; } void conversion(int N,int r) {     NODE *top1 = NULL;     int val;     //top1=(NODE *)malloc(sizeof(NODE));     int x=N,y=r;     while(N!=0)     {         top1=push(top1, N%r);         N=N/r;     }     printf("\n十进制数%d所对应的%d进制数是:",x,y);     while(top1!=NULL)     {         top1=pop(top1, &val);          printf("%d", val);     }     printf("\n"); }  //void main() int main() {     int n,r;     printf("请输入任意一个十进制整数及其所需转换的进制数:\n");     scanf("%d%d",&n,&r);     conversion(n,r); } 供参考～  对比代码找一下自己的问题吧～


Question: C语言acm题,怎么做啊？

啊这，我们学校内网哥你也进不去啊，题目我都贴全了，我也不知道咋回事

引用 2 楼 qq_51501668 的回复:[quote=引用 1 楼 user-2的回复:]你的程序定义了一堆整数， n=b/3;  你确定这句不会有问题？ 你的怎么这么麻烦 别把简单问题想复杂了 供参考  int main(){    int a,b;    while (scanf("%d %d",&a,&b)!=EOF)    {       unsigned int x,y,z;       scanf("%u %u %du",&x,&y,&z);       printf("%u\n",2*(x+y)+3*z-a-b);    }  }  哥，不对啊，每次都是 Wrong answer on test 4 [/quote]  那就说明acm的test4有特殊的情况 现在没考虑到  你能把acm的网址给我吗  我替你去看看

引用 1 楼 user-2的回复:你的程序定义了一堆整数， n=b/3;  你确定这句不会有问题？ 你的怎么这么麻烦 别把简单问题想复杂了 供参考  int main(){    int a,b;    while (scanf("%d %d",&a,&b)!=EOF)    {       unsigned int x,y,z;       scanf("%u %u %du",&x,&y,&z);       printf("%u\n",2*(x+y)+3*z-a-b);    }  }  哥，不对啊，每次都是 Wrong answer on test 4

过了，谢谢大佬们

#include<stdio.h>  int main() {   unsigned long long int a,b,x,y,z,A,B;     scanf("%lld%lld",&a,&b);     scanf("%lld%lld%lld",&x,&y,&z);     if(a>=2*x+y)     A=0;     else     A=2*x+y-a;     if(b>=3*z+y)     B=0;     else     B=3*z+y-b;     printf("%lld",A+B);     return 0; }

还有如果一个颜色很多另一个颜色很少还是需要晶体。可能要讨论。

引用int main(){    int a,b;    while (scanf("%d %d",&a,&b)!=EOF)    {                  unsigned int x,y,z;                  scanf("%u %u %u",&x,&y,&z);//这是改好的。 //原来的： scanf("%u %u %du",&x,&y,&z);                 printf("%u\n",2*(x+y)+3*z-a-b);    }  }结果为负，超范围了。unsigned int：32位，0<=X<=4294967295;   long: 32位，-2147483648<=X<=2147483647.

a, b如果太大结果不就是负的了？但我改了一下还是不行

引用 5 楼 qzjhjxj 的回复:引用scanf("%u %u %du",&x,&y,&z);这句输入有问题吧看，%du多了个d   引用 4 楼 qq_51501668 的回复:啊这，我们学校内网哥你也进不去啊，题目我都贴全了，我也不知道咋回事  那你改一下 不知道是不是范围溢出了 int main(){    int a,b;    while (scanf("%d %d",&a,&b)!=EOF)    {       long long x,y,z;       scanf("%lld %lld %lld",&x,&y,&z);       printf("%lld\n",2*(x+y)+3*z-a-b);    }  }


Question: C 语言多进程 vs 多线程性能问题

我每次测试10秒，然后结果/10来显示数据， 还有计时问题，我直接使用了系统的时间函数，没有事用tsc来计算。  误差也肯定有，但是应该不会影响整体效果吧。

使用电脑计时有时误差会很大，因为待测程序段的运行会影响电脑时钟。 将待测程序段循环足够多次，手动掐秒表计时可能更准确。


Question: 程序编译后，出现"eh.h is only for C++!"

引用 2 楼 丁劲犇的回复:你文件名是不是.c？另存为cpp即可。 好的，谢谢，已经解决了

你文件名是不是.c？另存为cpp即可。

你编译的不是这段代码。


Question: 急求 这段代码哪里错了？

for (mark = MAXSIZE-1; mark >= 0; mark--)     {         if (bigint[mark] == 0) break;     } 楼主的问题出在这里，看一下，MAXSIZE是200，而传进来的bigint有200个吗？ 还有bigint传进来的内容是初始化的bigint1,bigint2, bigint3，第200个元素是几，楼主需要了解一下，不然这个问题不好解决。  int bigint1[MAXSIZE] = {0,0,9,8,7,6,5,4,3,2,1}; 这是初始化，前几个元素赋值了？答案是11个，那么第12个到MAXSIZE后面的数据初始化为几？看样子是没有初始化，其实编译器都给初始化了，为0. 既然这么理解了，那么上面的自定义函数里的处理是不是就有问题了？  不知道这么解释，楼主是否能够明白～

都没说是什么错...


Question: 我想问一下如何在循环中做到输出条件中的最后一个数无多余字符而前面输出的都有空格

感谢校友！！！

#include <stdio.h> int main (){ 	int i,a,b,c,d,k=0; 	for (i=100;i<999;i++){         a=i/100; 	    b=i%100/10; 	    c=i%10; 	    d=a*a*a+b*b*b+c*c*c; 	    if (i==d){ 	    	k++; 	    	if (k==1){ 	    		printf("%d",i); 	    	} 	    	else{  	    		if (k>1) 	    			printf (" %d",i); 	    	}       } 	} 	return 0; }          //做个计数器就可以了  jlu校友

#include <stdio.h> int main() {     int i,j,k,n;     n=0;     for (i=1;i<10;i++)     for (j=0;j<10;j++)     for (k=0;k<10;k++) {         if (i*i*i+j*j*j+k*k*k==i*100+j*10+k) {             if (n==0) {                 printf("%d",i*100+j*10+k);                 n=1;             } else {                 printf(" %d",i*100+j*10+k);             }         }     }     printf("\n");     return 0; } //153 370 371 407 //

引用 1 楼 宇来风满楼 的回复:空格不是看不见吗，有啥影响 引用 1 楼 宇来风满楼 的回复:空格不是看不见吗，有啥影响 学校作业要求，想刷分就得按要求来

算，可这样第一个字符前又有空格了

做个计数。当输出第一个的时候输出“%d” 后面全都输出“ %d”

指定格式输出，如：“%2d”，自动靠右，最后没空格的，楼主这算不算你说的意思？

空格不是看不见吗，有啥影响


Question: C语言作业

数组长度～[]在定义的时候，中括号里的是数组长度～

引用 7 楼 weixin_44382508 的回复:数组元素数组打错了   就是这个数组的容量    例如int array[10]   那这个array数组最多有10个元素

数组元素数组

引用 4 楼 轻语2000的回复:[quote=引用 3 楼 qq_52134323的回复:][quote=引用 1 楼 轻语2000的回复:]这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 数组的容量是看哪个符号里的大小[/quote] 那个容量是你自己根据需求定义的，肯定不一样啊，你看看书[/quote] 好难啊这个题

请问你说的需求定义在我发的图里哪个位置

引用 3 楼 qq_52134323的回复:[quote=引用 1 楼 轻语2000的回复:]这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 数组的容量是看哪个符号里的大小[/quote] 那个容量是你自己根据需求定义的，肯定不一样啊，你看看书

引用 1 楼 轻语2000的回复:这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 数组的容量是看哪个符号里的大小

引用 1 楼 轻语2000的回复:这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。 为啥有的时候数字不一样，容量是看字节吗

这个你不看书来这里问我是没有想到的，里面的数字是表示数组的容量。


Question: C++语言

是否是写一个函数将字符数组中的x替换为y ##仅供参考 #include<stdio.h> #include<string.h> void RepChar(char s[],char x,char y) { 	for(int i=0;i<strlen(s);i++) 	{ 		if(s[i]==x) 			s[i]=y; 	} } int main() { 	char str[]="xycnbyxyx"; 	RepChar(str,'x','y'); 	printf("%s\n",str);	 } /*运行结果： yycnbyyyy */


Question: 【C语言】【飞机大战】光标不移动

引用 1 楼 小布的笔记 的回复:编译不成功？？？在我的电脑上是能的。。。

仅供参考：#include <conio.h> #include <windows.h>  void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); } void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE;       SetConsoleCursorInfo(hStdOut, &cciCursor);    } } void GetWH(int *w,int *h) {     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     CONSOLE_SCREEN_BUFFER_INFO csbi;     if (GetConsoleScreenBufferInfo(hStdOut, &csbi)) {         *w=csbi.srWindow.Right;         *h=csbi.srWindow.Bottom;     } else {         *w=80;         *h=25;     } } void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  int main() {     unsigned short k;     int x,y,w,h;     char d;      SetConsoleOutputCP(437);     ClearConsole();     GetWH(&w,&h);     x=w/2;y=h/2;     HideTheCursor();     ConPrintAt(x,y,"O",1);     d='o';     while (1) {         Sleep(50);         if (kbhit()) {             k=getch();             if (27==k) break;//按Esc键退出             if (0==k||0xe0==k) k|=getch()<<8;//非字符键             switch (k) {                 case 0x48e0:case 0x04800://上                     d='u';                     if (y>0) {                         ConPrintAt(x,y," ",1);                         y--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 0x50e0:case 0x05000://下                     d='d';                     if (y<h) {                         ConPrintAt(x,y," ",1);                         y++;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 0x4be0:case 0x04b00://左                     d='l';                     if (x>0) {                         ConPrintAt(x,y," ",1);                         x--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 0x4de0:case 0x04d00://右                     d='r';                     if (x<w-1) {                         ConPrintAt(x,y," ",1);                         x++;                         ConPrintAt(x,y,"O",1);                     }                 break;             } //          cprintf("%04x pressed.\r\n",k);         } else {             switch (d) {                 case 'u':                     if (y>0) {                         ConPrintAt(x,y," ",1);                         y--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 'd':                     if (y<h) {                         ConPrintAt(x,y," ",1);                         y++;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 'l':                     if (x>0) {                         ConPrintAt(x,y," ",1);                         x--;                         ConPrintAt(x,y,"O",1);                     }                 break;                 case 'r':                     if (x<w-1) {                         ConPrintAt(x,y," ",1);                         x++;                         ConPrintAt(x,y,"O",1);                     }                 break;             }         }     }     ClearConsole();     ShowTheCursor();     return 0; }

编译不成功？？？


Question: 在一个数列的 插入一个数 然后排序

引用 1 楼 xws245925587 的回复:#include<stdio.h>  #ifndef _count_arry  #define _count_arry(a) (sizeof(a) / sizeof(a[0])) #endif  int main() { 	int a[6] = { 1,7,10,14,16 }; 	int i, j, x, t; 	scanf_s("%d", &x); 	a[5] = x;  	for (j = 0; j < _count_arry(a) - 1; j++) 	{ 		for (i = 0; i< _count_arry(a) - 1 - j; i++)           		{ 			if (a[i]>a[i + 1])   			{ 				t = a[i];       				a[i] = a[i + 1];     				a[i + 1] = t; 			} 		} 	}   	for (i = 0; i < 6; i++) 	{ 		printf("%d ", a[i]); 	} 	system("pause"); }   for (i = 0; i< _count_arry(a) - 1 - j; i++)          这里为什么要  -1啊 ，我减掉1后   就对了

引用 1 楼 xws245925587 的回复:#include<stdio.h>  #ifndef _count_arry  #define _count_arry(a) (sizeof(a) / sizeof(a[0])) #endif  int main() { 	int a[6] = { 1,7,10,14,16 }; 	int i, j, x, t; 	scanf_s("%d", &x); 	a[5] = x;  	for (j = 0; j < _count_arry(a) - 1; j++) 	{ 		for (i = 0; i< _count_arry(a) - 1 - j; i++) 		{ 			if (a[i]>a[i + 1])   			{ 				t = a[i];       				a[i] = a[i + 1];     				a[i + 1] = t; 			} 		} 	}   	for (i = 0; i < 6; i++) 	{ 		printf("%d ", a[i]); 	} 	system("pause"); } 谢谢谢谢！！！

引用 3 楼 果、失 的回复:[quote=引用 1 楼 xws245925587 的回复:]#include<stdio.h>  #ifndef _count_arry  #define _count_arry(a) (sizeof(a) / sizeof(a[0])) #endif  int main() { 	int a[6] = { 1,7,10,14,16 }; 	int i, j, x, t; 	scanf_s("%d", &x); 	a[5] = x;  	for (j = 0; j < _count_arry(a) - 1; j++) 	{ 		for (i = 0; i< _count_arry(a) - 1 - j; i++)           		{ 			if (a[i]>a[i + 1])   			{ 				t = a[i];       				a[i] = a[i + 1];     				a[i + 1] = t; 			} 		} 	}   	for (i = 0; i < 6; i++) 	{ 		printf("%d ", a[i]); 	} 	system("pause"); }   for (i = 0; i< _count_arry(a) - 1 - j; i++)          这里为什么要  -1啊 ，我减掉1后   就对了[/quote]因为你要用数组下标，而数组下标是从0开始的，代表数组中的第一个元素，下标值不能超过数组长度的那个数值，比如数组a[10],你的下标最多到a[9]

引用 2 楼 果、失 的回复:_count_arry(a) (sizeof(a) / sizeof(a[0])) 这个有什么作用哦？？ 谢谢啦求出数组的长度，类似于字符串函数里面的strlen().


Question: 栈实现四则运算求助

typedef char OperandType;//运算类型 你怎么能用char去定义一个answer呢?


Question: 大一新生程序小白求助

stdio.h和math.h是不同的头文件，第一个头文件在你使用scanf/printf等这些基本上库函数时需要引入头文件，math.h是数学函数库，比如abs，sqrt等这些数学库时，需要引入这个头文件。 对于main的返回值是int还是void看编译器吧，这个无需纠结～   建议楼主不要纠结这两个问题，等你编写程序多的时候自然会理解和解决这两个问题。比如，math.h什么时候引入，你编写程序时，编译时不引入就会报错，那么你自然要解决编译报错问题，那么最终的解决就会考虑引入这个头文件，因此楼主还是多关注基础的知识点，多写，多调程序吧

先安抚你一下，这个东西我保证你后面自然会懂，现在不管都行。然后我具体说一下，这个东西是c的头文件，里面有各种函数，如果你的程序要用他们那你就要把他写出来，这个#include<stdio.h>是一定会用的scanf和pringf这种基础函数都在里面，所以写程序不管三七二十一先写在前面，那个#include<math.h>里面有许多关于数学的函数。打个比方，你要做一个事情，你可以把所有工具先准备好，也就是把各个头文件都写出来摆在那里，就算不用也可以摆出来嘛，没什么影响；你也可以只把要用的工具摆出来，这样代码更简洁。至于那个void main是另外的东西这里就不说了

这。。建议你先看几本基础入门书籍就不会问这种问题了。 不同的.h头文件包含不同的功能函数，实际需要哪些功能就包含对应的头文件。 main()函数前面的int和void表示的是返回值的类型


Question: c语音网络程序中用  recv函数接受数据会遇到不知道对方发送多长数据的问题

加一个头部信息，来确定具体该获得具体多长的消息。

比较省事的方法就是用一些类似libuv、libev等库，直接在回调函数中处理数据，不需要去关心数据到底啥时候来。 或者用select、epoll等来管理套接字。单独开线程接收也可以。

用多线程吧，把接受单独放一个线程。或者使用套接字的非阻塞模式

在独立的线程中等待。另外，如果是tcp的，最好定义一个数据结构，指定长度。因为tcp的流会连续到来，有可能尾巴上有半个包

哪位给个答案

业务数据加上个包头，在包头中记录数据长度。 接收数据后先解析数据长度，没有接收足长则继续。否则就退出循环。

recv 最后参数 用 MSG_PEEK, 可以窥探是否有数据


Question: C语言问题

确实，二楼说得对，把1换成i，我也刚学到这

你for语句里面判断条件打错了，形成了一个死循环

for (i = 1; 1 <= 10; i++)，这句里应该是"i<=10;"才对，楼主输入" 1 <= 10"这是数字 1 吧。

1小于等于10，肯定停不下来啊


Question: 写了个二叉树的程序不懂哪里错了，有大佬帮忙看看吗

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

引用 1 楼 神棍日常坑人的回复:把函数内的星号去掉吧 可以请你帮我看看为什么printf（“”%c“”,a[i].data）输出不了吗 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX_SIZE 1024 typedef struct{ 	char data; 	int weight; 	int parent; 	int lchild; 	int rchild; }Huffnode,*Hufftree; typedef struct stack{ 	int top; 	int elem[MAX_SIZE]; }Stack; void Initstack(Stack *s) { 	s->top=-1; } void push(Stack *s,int e) { 	s->top++; 	s->elem[s->top]=e; } int pop(Stack *s) { 	return s->elem[s->top--]; } bool isempty(Stack *s) { 	if(s->top==-1) 		return true; 	else 		return false; } void GetHuffmamCode(Hufftree a,int n) { 	int i,j,s1,s2,max,c,p; 	Stack s; 	char ch; 	Initstack(&s); 	printf("输入字符集："); 	for(i=1;i<=n;i++) 	{ 		scanf("%c",&a[i].data); 		scanf("%c",&ch); 	} 	printf("输入权值："); 	for(i=1;i<=n;i++) 	{ 		scanf("%d",&a[i].weight); 		scanf("%c",&ch); 	} 	int m=2*n-1; 	for(i=1;i<=n;i++) 	{ 		a[i].parent=0; 		a[i].rchild=0; 		a[i].lchild=0; 	} 	for(i=n+1;i<=m;i++) 	{ 		a[i].data=NULL; 		a[i].weight=0; 		a[i].parent=0; 		a[i].lchild=0; 		a[i].rchild=0; 	} 	for(i=n+1;i<=m;i++) 	{ 		max=65535; 		for(j=1;j<=i-1;j++) 		{ 			if(a[j].parent==0&&a[j].weight<=max) 			{ 				s1=j; 				max=a[j].weight; 			} 		} 		a[s1].parent=i; 		max=65535; 		for(j=1;j<=i-1;j++) 		{ 			if(a[j].parent==0&&a[j].weight<=max) 			{ 				s2=j; 				max=a[j].weight; 			} 		} 		a[s2].parent=i; 		a[i].weight=a[s1].weight+a[s2].weight; 		a[i].lchild=s1; 		a[i].rchild=s2; 	} 	for(i=1;i<=n;i++) 	{ 		c=i; 		p=a[i].parent; 		while(p!=0) 		{ 			if(a[p].lchild==c) 				push(&s,0); 			else 				push(&s,1); 			c=p; 			p=a[p].parent; 		} 		printf("%c\n",a[i].data); 		while(!isempty(&s)) 			printf("%d",pop(&s)); 		printf("\n"); 	} } int main() { 	Hufftree a; 	int n; 	int m; 	printf("输入字符个数："); 	scanf("%d",&n); 	m=2*n-1; 	a=(Hufftree)malloc(sizeof(Huffnode)*m); 	GetHuffmamCode(a,n); 	return 0; }

把函数内的星号去掉吧


Question: 请大家帮忙给弟弟看一下 初学 找不出错误

谢谢谢谢，小白难哭了

#include<stdio.h> #include<math.h> int main() {     float area, L, v, m;     float r = 1.4;     float M = 3.1415;     area = M * r * r;     L = 2 * M * r;     v = (M * r * r * r)*4 / 3;     m = 2 * M * r * r;     printf("所以圆的表面积为；%0.4f\n周长为：%f\n", area, L);     printf("所以球的体积为：%0.4f\n表面积为；%f\n",v,m);      return 0; } 都是缺少符号导致，建议看回教材

float r=1.4; float M=3.1415这两句前面的float可以省略，直接赋值：r=1.4;M=3.1415;

float area L v m;这句应该是这样的：float area,L,v,m;几个变量之间要有‘，’号。 L=2Mr；这句应该是这样的：L=2*M*r;必须要有‘*’号。 m=2Mr*r;这句同样的：m=2*M*r;


Question: 求解决！急！

n输入完，加if判断，修改如下： int count,i,n;     double grade,total,average;     total = 0;     count = 0;      printf("请输入学生数：");     scanf ("%d",&n);     if(n>=1)    {       printf("请输入%d个学生的成绩：",n);       for (i=1;i<=n;i++)       {         scanf ("%lf",&grade);         total = total + grade;         if (grade >= 60)            { count++;}       }       average = total/n;       printf ("平均成绩average = %.1f\n",average);       printf ("及格人数count = %d\n",count);    }    else    { printf("学生人数输入错误！");}        return 0;

if(n==0)    return 0;

引用 2 楼 user-3的回复:你这写的是什么  这个当n=0的时候好像不行

引用 3 楼 UIUI的回复:你的 count 为什么置 0 ?低于60的时候? 因为count是及格人数orz

你的 count 为什么置 0 ?低于60的时候?

你这写的是什么

#include <stdio.h> #include <iostream.h> //---------------------------------------------------------------------------  #pragma argsused int main(int argc, char* argv[]) {     int count,i,n;     double grade,total,average;     total = 0;     count = 0;      printf("请输入学生数：");     scanf ("%d",&n);      printf("请输入%d个学生的成绩：",n);     for (i=1;i<=n;i++)       {         scanf ("%lf",&grade);         total = total + grade;         if (grade >= 60)            {              count++;            }        }       average = total/n;       printf ("平均成绩 = %.1f\n",average);       printf ("及格人数 = %d\n",count);        return 0; }


Question: 我想问一下我的代码哪里不对了，我也找不出错误

//if (a=1){     if (a==1){  供参考～

感谢讲解，一针见血


Question: 如何用C语言读取串口数据

搜“serial库”

#ifndef _COMM_H_  #define _COMM_H_  #define WM_FOUNDCOMM WM_USER+1  //自定义消息WM_FOUNDCOMM,收到该消息表示串口已经找到 #define WM_READCOMM WM_USER+2   //自定义消息WM_READCOMM,收到该消息缓冲区有数据, 可以读取 extern void FindComm();     //申明为外部函数  extern void OpenComm(int nBaud, int nData, int nStop, int nCal); extern void CloseComm(); extern UINT ThreadFunc(LPVOID pParam); //申明全局线程处理函数  extern CString DisplayCString2Hex(CString Data, bool Blank_allow); extern CString DisplayHex2CString(CString Data); extern int ConvertHexC2String(CString str, CByteArray &senddata); extern bool ComIsOK;     //申明为外部变量  extern HANDLE hCom; extern CString strcomname; #endif  #include "stdafx.h"  #include "commassist.h"  #include "commassistDlg.h"  #include "comm.h"  char ConvertHexChar(char ch); HANDLE hCom;   //串口句柄  CString strcomname;  //串口名,如"COM1"  bool ComIsOK;   //串口打开状态标识,为真表示已打开,否则未打开  //============自动寻找串口函数=================================  //函数功能:通过扫描注册表来找出当前所有物理串口  //输入参数:无  //返回类型:无  //说    明:若搜索成功,则每搜到一个串口便发送消息通知主对话框,并将串口号以WPARAM传递 void FindComm() { 	//枚举当前系统中的串口  	LONG result = 0; 	HKEY key = NULL; 	result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, //需要打开的主键的名称  		"HARDWARE\\DEVICEMAP\\SERIALCOMM", //需要打开的子键的名称, 设备串口 		0,      //保留必须设置为0  		KEY_READ,  //安全访问标记也就是权限  		&key);     //得到的将要打开键的句柄当不再需要句柄 	//必须调用 RegCloseKey 关闭它  	if (result) 	{ 		AfxMessageBox("无法获取串口请确认是否安装并连接串口!"); return; 	} 	TCHAR portname[250];     //串口名  	TCHAR data[250]; 	DWORD portnamelen = 0;     //串口名长度  	DWORD datalen = 0; 	int index = 0; 	while (1)    //找完COM后跳出  	{ 		portnamelen = 255; 		datalen = 255; 		result = RegEnumValue(key,   //Long一个已打开项的句柄或者指定一个标准项名 			index++,   //Long欲获取值的索引。注意第一个值的索引编号为零 			portname,  //String用于装载位于指定索引处值名的一个缓冲区 			&portnamelen, //Long用于装载lpValueName缓冲区长度的一个变量。 			//一旦返回它会设为实际载入缓冲区的字符数量 			NULL,   //Long未用设为零  			NULL,   //Long用于装载值的类型代码的变量  			(LPBYTE)data, //Byte用于装载值数据的一个缓冲区   			&datalen);  //Long用于装载lpData缓冲区长度的一个变量。 		//一旦返回它会设为实际载入缓冲区的字符数量 		if (result)  break; 		//发送消息,WM_USER+1为自定义消息,即找到串口的,并将串口号"COMx"通过WPARAM参数传送给主对话框窗口 		//::AfxGetMainWnd()->m_hWnd,获得主对话框句柄  		//(WPARAM)(LPCTSTR)data,类型转换   		::SendMessage(::AfxGetMainWnd()->m_hWnd, WM_FOUNDCOMM, (WPARAM)(LPCTSTR)data, 0); 	} 	RegCloseKey(key);      //调用 RegCloseKey 关闭打开键的句柄  } //============自动寻找串口函数结束==================   //==========串口打开函数===========================  //功    能:打开串口,将已打开的串口句柄赋值给hCom,给出串口打开状态ComIsOK,完成串 //输入参数:波特率,数据位,停止位,校验位  //返回类型:无  void OpenComm(int nBaud, int nData, int nStop, int nCal) { 	hCom = CreateFile(strcomname,   //串口号  		GENERIC_READ | GENERIC_WRITE,  //允许读或写  		0,         //独占方式  		NULL, 		OPEN_EXISTING,      //打开而不是创建  		FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,//重叠方式,用于异步通信 		NULL);  	if (hCom == INVALID_HANDLE_VALUE) 	{ 		AfxMessageBox("打开COM失败串口不存在或已被占用!"); 		ComIsOK = false; 		return; 	} 	ComIsOK = true; 	SetCommMask(hCom, EV_TXEMPTY | EV_RXCHAR);  //设置事件掩码,暂时没用上 	SetupComm(hCom, 1024, 1024);  //设置输入缓冲区和输出缓冲区的大小都是1024  	COMMTIMEOUTS TimeOuts; 	//设定读超时  	TimeOuts.ReadIntervalTimeout = MAXDWORD; 	TimeOuts.ReadTotalTimeoutConstant = 0; 	TimeOuts.ReadTotalTimeoutMultiplier = 0; 	//设定写超时  	TimeOuts.WriteTotalTimeoutConstant = 500; 	TimeOuts.WriteTotalTimeoutMultiplier = 100; 	if (SetCommTimeouts(hCom, &TimeOuts) == false) 	{ 		CloseHandle(hCom); 		ComIsOK = false; 		return; 	} 	//串口属性配置  	DCB dcb; 	GetCommState(hCom, &dcb); 	dcb.BaudRate = nBaud; //dcb.BaudRate=9600; //波特率为9600  	dcb.ByteSize = nData; //dcb.ByteSize=8; //每个字节为8位  	dcb.StopBits = nStop; //dcb.StopBits=ONESTOPBIT;   //1位停止位  	dcb.Parity = nCal; //dcb.Parity=NOPARITY; //无奇偶检验位  第 18 页 共 39 页    	SetCommState(hCom, &dcb); 	PurgeComm(hCom, PURGE_TXCLEAR | PURGE_RXCLEAR); 	if (SetCommState(hCom, &dcb) == false) 	{ 		CloseHandle(hCom); 		ComIsOK = false; 		return; 	} 	return; } //==========串口打开函数结束=====================    //==========串口关闭控制函数=====================  void CloseComm() { 	CloseHandle(hCom); 	hCom = NULL; 	ComIsOK = false; } //==========串口关闭控制函数结束==================   //==========串口监听线程函数======================  UINT ThreadFunc(LPVOID pParam) { 	// CCommassistDlg* pdlg = (CCommassistDlg*)pParam;  //定义指针指向主对话框  	COMSTAT ComStat; 	DWORD dwErrorFlags; 	while (ComIsOK) 	{ 		DWORD dwBytesRead = 100; 		ClearCommError(hCom, &dwErrorFlags, &ComStat); 		dwBytesRead = min(dwBytesRead, (DWORD)ComStat.cbInQue); 		if (!dwBytesRead) 		{ 			Sleep(10);//continue;//使用continue时打开串口后CPU占用率非常高  		} 		else ::SendMessage(::AfxGetMainWnd()->m_hWnd, WM_READCOMM, 1, 0); //发 送消息, 已读到 	} 	return 0; } //==========串口监听线程函数结束===============  //=================字符串转16进制显示==========  //字符串转16进制显示的函数  //传入参数Data为字符串  //Blank_allow为空格允许标志,为真则代表允许加入空格  //函数返回为CString的结果sResult  CString DisplayCString2Hex(CString Data, bool Blank_allow) { 	CString sResult; 	CString sTemp; 	int Data_Length; 	Data_Length = Data.GetLength(); 	if (Data_Length == 0) return ""; 	char *pchar = new char[Data_Length];  //用了new分配内存空间,要记得释放  	strncpy(pchar, Data, Data_Length); 	for (int i = 0; i<Data_Length; i++) 	{ 		sTemp.Format("%02X", pchar[i]); 		if (Blank_allow) 		{ 			if (i == Data_Length - 1) sResult = sResult + sTemp; //去掉最后一个空格  			else 				sResult = sResult + sTemp + " "; 		} 		else sResult = sResult + sTemp; 	} 	delete pchar;   //释放内存空间  	return sResult; } //===============函数结束============================   //=================16进制转字符串======================  //16进制转字符串,输入16进制的字符串,输出转换为16进制码  //传入参数str为字符串,判断输入是否按照16进制格式输入  int ConvertHexC2String(CString str, CByteArray &senddata) { 	//先判断输入字符串是否2个字符一组  	int str_Length, iLength; 	int hexdata, l_data; 	char hstr, lstr; 	char cTemp; 	str_Length = str.GetLength(); 	iLength = 0; 	senddata.SetSize(str_Length / 2);  //预先设置数组长度,不设置时,允许有错  	char *ppchar = new char[str_Length]; 	strncpy(ppchar, str, str_Length); 	for (int i = 0; i<str_Length;) 	{ 		cTemp = ppchar[i]; 		if (cTemp == ' ') 		{ 			//iLength--;  			i++; 			continue; //如检测到空格则跳过继续下一次循环  		} 		else 		{ 			hstr = ppchar[i];  //取出字符作为16进制高位  			i++; 			lstr = ppchar[i];  //取出下一个字符作为16进制低位  			if (lstr == ' ')   //若取出的低位为空格则不符合16进制2个一组的格式终止循环 			{ 				AfxMessageBox("请按照16进制每2个字符一组的方式输入",MB_ICONERROR);  				break; 			} 			else 			{ 				hexdata = ConvertHexChar(hstr);  //高位转换为相应的0进制  				l_data = ConvertHexChar(lstr);  //低位转换为相应的10进制  				if ((hexdata == -1) || (l_data == -1)) 				{ 					AfxMessageBox("请按照16进制字符要求输入", MB_ICONERROR); 					break; 				} 				else hexdata = hexdata * 16 + l_data; //安装16进制方式高位低位合并   				senddata[iLength] = (char)hexdata; //int整型数转换为char字符型并存入数组senddata[] 				i++; //进入下一次循环  				iLength++; //成功转换一组(2个)字符记录长度加1  			} 		} 	} 	senddata.SetSize(iLength); 	delete ppchar; 	return iLength; }  //===============函数结束===========================   char ConvertHexChar(char ch) { 	//将一个字符转换为相应的十六进制  	if ((ch >= '0') && (ch <= '9')) 		return ch - 48;//0x30;  	else if ((ch >= 'A') && (ch <= 'F')) 		return ch - 'A' + 10; 	else if ((ch >= 'a') && (ch <= 'f')) 		return ch - 'a' + 10; 	else 		return (-1); }   //=================16进制转字符串显示=====================  //16进制转字符串显示的函数  //传入参数Data为16进制的字符串  //函数返回为CString的结果sResult  CString DisplayHex2CString(CString Data) { 	CString sResult; 	CString sTemp; 	int Data_Length; 	Data_Length = Data.GetLength(); 	if (Data_Length == 0) return ""; 	char *pchar = new char[Data_Length];  //用了new分配内存空间,要记得释放  	strncpy(pchar, Data, Data_Length); 	for (int i = 0; i<Data_Length; i++) 	{ 		sTemp.Format("%02X", pchar[i]); 		sResult = sResult + sTemp; 	} 	delete pchar;   //释放内存空间  	return sResult; } //===============函数结束=============================


Question: 小白问大家几个问题

引用 2 楼 UIUI的回复:你定义的数组大小是 n-1 那么, 你循环读入的 最大下标应该为 n-1-1; 你读入n-1 个,当然有问题. 不知道你是什么编译器. 这个 int number[n-1];  怎么也编译能通过..... 确实是这样，对数组大小理解错了，感谢 至于编译器为什么能通过我也不知道

第一个for循环后的那个scanf是多余的


Question: 输入单词输出单词字母数

感觉可以考虑用getchar()和while循环，每getchar一次i+1,遇到空格时打印i，然后重置i。（我也是新手，共勉）


Question: 我想问一下我错哪了，我没看出来，求教

#include<stdio.h>  int main() {     /*        题目名称：符合条件自然数         题目描述：编写程序，打印所有小于正整数data且可被11整除的自然数。           输入：从键盘输入一个正整数data         输出：输出所有小于data且可被11整除的自然数，数与数之间以一个空格做间隔，最后一个数后无多余字符。        */      /*     int a,i,c;      scanf("%d", &a);      //for(i=1;i<a-1;i++) {     for(i=1; i < a; i++) {          if (i%11==0)              printf("%d",i);          printf(" ") ;     }         c=i;         c=c%11;         if (c==0)         printf("%d",c);         else        */     int data, i;      scanf("%d", &data);      for (i = 0; i < data; i++) {         if (i % 11 == 0) {             if (i != 0)                 printf(" ");             printf("%d", i);         }     }     return 0;  } 供参考～  自然数应该是从0开始的吧

小于正整数a 你的for循环for(i=1;i<a-1;i++){ 却是小于a-1的  举个例子 输入111  最后一个数本来是110  你的循环就少了110了  改一下：for(i=1;i<a;i++){


Question: 提领指向不完全类型指针

谢谢。 感谢大佬

链表的定义有问题  改一下 typedef struct queNode_c{ char data; struct queNode* next;  // struct queNode* last; } queNode;  这种用typedef定义的结构体相当于以下效果： struct queNode_c{ char data; struct queNode* next;  // 此时 queNode还没有定义呢 你用这个  编译器认识这是哪个啊  struct queNode* last; }  typedef queNode_c queNode； 改成以下的： typedef struct queNode_c{ char data; struct queNode_c* next;   struct queNode_c* last; } queNode;


Question: 求助求助，急急急，怎么写，大神帮帮忙，求这个程序补充内容

示例：// //  // /*  *  栈操作  * */ #include <stdio.h> #include <stdlib.h> #define  N 50 栈大小 //结构体 栈 typedef struct stack {     int top; //栈顶位置     int data[N]; //数据 } STACK; //是否为空 int isEmpty(STACK * stack) {     if(stack->top == -1)     {         return 1;     }     return 0; } //是否已满 int isFull(STACK * stack) {     if(stack->top == N-1)     {         return 1;     }     return 0; }  //设为空 void setEmpty(STACK * stack) {     stack->top = -1; } //压栈 int push(STACK * stack, int data) {     if(isFull(stack))     {         printf("栈已满\n");         return -1;     }     stack->top += 1;     stack->data[stack->top] = data;  } //弹栈 int pop(STACK * stack) {     if(isEmpty(stack))     {         printf("栈已空");         return -1;     }     int num = stack->data[stack->top];     stack->top -= 1;     //printf("top=%d\n",stack->top);     return num;  } void test() {     printf("栈结构体类型大小:%d\n",sizeof(STACK));     printf("分配内存，并初始化:\n");     STACK * stack = (STACK *)calloc(1,sizeof(STACK)); //calloc分配内存： 元素个数 元素大小     if(stack == NULL)     {         printf("内存分配失败\n");         return;     }     printf("内存分配成功,地址为:%p\n",stack);     setEmpty(stack);     //压栈     for(int i = 0; i < N; i++)     {         printf("压入数据:%d\n",i);         push(stack,i);     }     //弹栈    while (!isEmpty(stack))    {        printf("弹栈:%d\n",pop(stack));    }     //释放内存     free(stack);  }  int main1(int agc, char * argv[]) {      test();     return 0; }


Question: 求助大佬

这是按你的代码改的，运行如下图： 程序代码：int ss(int x){    int f=1;    if(x<=1) f=0; //小于等于1的数都没有素数    if(x==2) f=1; //数字2只有1和2两个因数，因而必定是素数    for(int i=2;i<x;i++)//从2到x-1都无法被x整除，x是素数         if(x%i==0) f=0;    return f; }  int main(int argc, char* argv[]) {     int M,N,count=0,sum=0;     printf("请输入给定区间整数M和N(1≤M≤N≤1000)：");     scanf("%d %d",&M,&N);     if(M>=1&&M<=N&&N<=1000)         {          for(int j=M;j<=N;j++)            {if(ss(j)==1)                 {count++;                  sum+=j;                  printf("   %d   ",j);                  if(count%5==0)                  printf("\n");                 }            }         printf("\namount=%d sum=%d",count,sum);        }     else printf("输入给定区间整数M和N错误！");     cin>>M;     return 0;  }

#include <stdio.h> #include <math.h> int Judge(int i); int main() { 	int m,n; 	int i,j,z = 0; 	int sum = 0; 	printf("请输入区间范围: "); 	scanf("%d %d",&m,&n); 	for(i = m;i <= n;i ++) 	{ 		j = Judge(i); 		if(j == 1) 		{ 			printf("%d ",i); 			z ++; 			if(z % 5 == 0) 			{ 				printf("\n"); 			} 			sum += i; 		} 	 } 	 printf("\namount = %d sum = %d",z,sum);  	return 0; } int Judge(int b) { 	int i,a; 	if(b == 1) 	{ 		return 0; 	} 	a = (int)sqrt(b);//因为如果一个数可以被别的数整除那那个数和商在开平方的值的两侧，所以求一半就可以了  	for(i = 2;i <= a;i ++) 	{ 		if(b % i == 0) 		{ 			return 0; 		} 	} 	return 1; }

#include <stdio.h> #include <math.h>  //int ss(int x) int is_prime(int x) {     if (x < 2)         return 0;      //int f = 1;     int i;     for(i=2;i<x;i++)     {         if(x%i==0) {             //f=0;             break;         }     }     if (i < x)         return 0;     else         return 1;      //return f; } int main() {     int M,N,count=0,sum=0;     scanf("%d %d",&M,&N);     if (M < 1 || N < M || N > 1000)         return -1;     //if(M>=1&&M<=N&&N<=1000)     //{         for(int j=M;j<=N;j++)         {             if(is_prime(j)==1)             {                 count++;                 if(count%5==1&&count>1)                     printf("\n");                 printf("%d ",j);                 sum+=j;             }         }         printf("\namount=%d sum=%d",count,sum);     //}     //else return 0;     return 0; }  供参考～  楼主的素数判断有问题，楼主判断逻辑里1也是素数了。

引用 6 楼 qzjhjxj 的回复:[quote=引用 5 楼 user-4 的回复:]#include <stdio.h> #include <math.h> int ss(int x) {    int f = 1;    if (x <= 2)         return 0;    for (int i = 2; i < x; i++)    {       if (x % i == 0)          f = 0;    }    return f; } int main() {    int M, N, count = 0, sum = 0;    scanf("%d %d", &M, &N);    if (M >= 1 && M <= N && N <= 1000)    {       for (int j = M; j <= N; j++)       {          if (ss(j))          {             count++;             printf("%d ", j);             sum += j;             if (count % 5 == 0)             {                printf("\n");             }          }       }       printf("\namount=%d sum=%d", count, sum);    }    else       return 0; } 楼上的第六句把2排除在外了，2是素数。[/quote]  可能我记错了吧

引用 5 楼 user-4 的回复:#include <stdio.h> #include <math.h> int ss(int x) {    int f = 1;    if (x <= 2)         return 0;    for (int i = 2; i < x; i++)    {       if (x % i == 0)          f = 0;    }    return f; } int main() {    int M, N, count = 0, sum = 0;    scanf("%d %d", &M, &N);    if (M >= 1 && M <= N && N <= 1000)    {       for (int j = M; j <= N; j++)       {          if (ss(j))          {             count++;             printf("%d ", j);             sum += j;             if (count % 5 == 0)             {                printf("\n");             }          }       }       printf("\namount=%d sum=%d", count, sum);    }    else       return 0; } 楼上的第六句把2排除在外了，2是素数。


Question: 为什么会这样，free到底干了什么

free是针对malloc/realloc等在堆上申请空间的释放用的。用于标记申请的空间可以再次被申请了。

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

int main() {     int *p;     printf("%p %d\n",p,*p); //此时p未初始化 称之为野指针  也就是p本身地址未知->00400080  p指向的地址未知->17744     *p = 5;   //p本身的地址未知，那么你可能无法将p指向其他地址 因为此时p本身的地址你可能无权限访问       p=(int *)malloc(sizeof(int));  //此时给p初始化了  p的地址为0x55e5857e22a0     *p=5; //此时你可以将p指针指向其地址了 p =0x55e5857e22a0     *p=5     printf("%p %d\n",p,*p);       free(p); //free是释放p指向的地址  此时p=0x55e5857e22a0  *p=0     *p=6;  //将p指向另外一个地址 此时p=0x55e5857e22a0  *p=6       printf("%p %d\n",p,*p);//总结以下：free是释放p指向的地址 p指针本身的地址是不变的 所以如果你要释放一个地址，最好如下写：     free(p);     p = NULL;//只释放地址，本身地址不为null的指针叫迷途指针 在大的程序中很可能会出问题       return 0; }

引用 楼主 学码就是爱好 的回复:但是下面程序释放了申请了内存为什么*P还会被赋值6？ #include <stdio.h> #include<malloc.h> int main() {     int *p;     p=(int *)malloc(sizeof(int));     *p=5;     printf("%p %d\n",p,*p);      free(p);     *p=6;      printf("%p %d\n",p,*p);      return 0; }  0x55e5857e22a0 5 0x55e5857e22a0 6 #include <stdio.h> #include <malloc.h> int main(void) {     int *p;     p=(int *)malloc(sizeof(int));     *p=5;     printf("%p %d\n",p,*p);      free(p); //这句执行后p就成为野指针，p指向的内存被释放，不归你程序所有     *p=6; //这句是非法访问      //如果在这里插入其他函数调用，你再试试     {        p=(int *)malloc(sizeof(int));        *p=5;        free(p);     }      printf("%p %d\n",p,*p);      return 0; }

释放内存就是设置一个flag，告诉系统这块内存已经不用了，系统可以把这块内存拿给其他程序使用，但是系统不一定马上会把它分配给其它程序（要看其它程序malloc时是否刚好分配到这块内存），一时半会这块内存属于自由状态，所以继续使用该内存可能不会出错，相当于没有申请内存所有权就强行侵占内存使用。所以*p=6就属于这种行为，一时半会可能不会出错。如果该内存被其他程序分配申请使用权了，那*p=6可能就会报内存非法访问错误了。


Question: 求大佬帮忙看看新人打的代码哪里有问题

试试把0排除后的结果吧，除了0，其他的我就不知道了

引用 11 楼 神棍日常坑人的回复:[quote=引用 10 楼 NGUforever 的回复:] 我换了啊 不知道你们有没有啥特别的数据实例没有，代码肯定是没问题的，只是说没有对输入的数据进行判断处理[/quote] 这学校的破oj不给我们下实验数据，我自己用你的代码试了好几组都没问题，我甚至怀疑是不是oj有问题。。。。

引用 10 楼 NGUforever 的回复:我换了啊 不知道你们有没有啥特别的数据实例没有，代码肯定是没问题的，只是说没有对输入的数据进行判断处理

引用 9 楼 神棍日常坑人的回复:[quote=引用 7 楼 NGUforever 的回复:]emmmm，我试了试你的，但是系统说答案错误。。。 把输出的bs和ys交换一下位置，bs代表最小公倍数，ys代表最大公约数  注释等于白写了[/quote] 我换了啊

引用 7 楼 NGUforever 的回复:emmmm，我试了试你的，但是系统说答案错误。。。 把输出的bs和ys交换一下位置，bs代表最小公倍数，ys代表最大公约数  注释等于白写了

好的，感谢大佬帮忙

恳求大佬帮忙吧，就算没找到错给个参考例子也行，如果过了的话我就立马结帖

emmmm，我试了试你的，但是系统说答案错误。。。

引用 楼主 NGUforever 的回复:题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf ("%d%d",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf ("%d %d\n",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行

写一段给你参考一下吧，也可以用for循环暴力破解，感觉超时可能就是你用的两个while的原因  #include<stdio.h> int main(){ 	int m, n, temp, bs, ys; 	scanf ("%d %d", &m, &n); 	//判断 m 、 n 的大小，大的给 m ，小的给 n 	if(m < n){ 		temp = n; 		n = m;  		m = temp; 	} 	//将最小公倍 bs 数暂定为 m 与 n 的乘积 	bs = m * n; 	//使用取余的方法求最大公因数 ys 	while(1){ 		if(m % n == 0) 			break; 		temp = m % n; 		m = n; 		n = temp; 	}; 	ys = n; 	//将 m 与 n 的乘积除以最大公因数 ys 得最小公倍数 bs 	bs /= ys; 	printf("%d %d\n", bs, ys); 	return 0; }

引用 4 楼 神棍日常坑人的回复:[quote=引用 3 楼 NGUforever 的回复:][quote=引用 2 楼 神棍日常坑人 的回复:][quote=引用 楼主 NGUforever 的回复:]题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf ("%d%d",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf ("%d %d\n",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行[/quote] emmmm,编译器显示会运行while里的东西啊，是我理解错大佬的意思了吗[/quote] 我说反了，是对的，运行超时没看出来，不过你的代码思路确实挺复杂的[/quote] 好吧，谢谢大佬帮忙

引用 3 楼 NGUforever 的回复:[quote=引用 2 楼 神棍日常坑人 的回复:][quote=引用 楼主 NGUforever 的回复:]题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf ("%d%d",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf ("%d %d\n",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行[/quote] emmmm,编译器显示会运行while里的东西啊，是我理解错大佬的意思了吗[/quote] 我说反了，是对的，运行超时没看出来，不过你的代码思路确实挺复杂的

引用 2 楼 神棍日常坑人 的回复:[quote=引用 楼主 NGUforever 的回复:]题目如下： 题目描述 已知两个正整数m和n，求其最大公约数和最小公倍数。  输入与输出要求： 输入的正整数m和n之间用空格分隔。输出的最大公约数和最小公倍数之间用空格分隔。测试用例保证m、n及其最小公倍数可以用int存储。  程序运行效果： Sample 1： 输入：12 36 输出：12 36 Sample 2： 输入：13 7 输出：1 91 我的代码： #include <stdio.h> int main () {     int m,n,min,flag1;     int max,tool;     flag1=1;      scanf ("%d%d",&m,&n);     if (n>m)     {         tool=n;         n=m;         m=tool;     }     tool=m;     while (flag1==1)     {         if ((tool%m==0)&&(tool%n==0))         {             max=tool;             flag1=0;         }          tool=tool+1;     }     flag1=1;     tool=n;     while (flag1==1)     {         if ((m%tool==0)&&(n%tool==0))         {             min=tool;             flag1=0;         }          tool=tool-1;     }     printf ("%d %d\n",min,max);          return 0; } 每次提交都显示运行超时，自己找了好久找不到问题在哪，求大佬帮忙看看ORZ while(true)结束循环，你这里flag1一开始就被置为1了，while(flag1 == 1)循环就直接结束了，循环里面的内容就不会被执行[/quote] emmmm,编译器显示会运行while里的东西啊，是我理解错大佬的意思了吗

题目描述 问题描述： 已知整数a、b、c。你的任务是求出区间[a,b]内的整数，满足该数与“该数的所有因数（不包括本身但包括1,1的因数和按0处理）相加之和”的差的绝对值小于等于c的数字。例如27的因数是1、3、9。那么27与27的所有因数和的差为:27-(1+3+9)=14。  输入与输出要求： 输入三个整数a、b、c。a、b代表所求区间范围，满足1<=a<=b<=10000，c代表限制条件，c>=0。输出满足条件的整数，每五个数为一行，整数之间用tab分隔，最后一个数后为换行符。当该区间没有符合条件的整数时，输出“There is no proper number in the interval.”  程序运行效果： Sample 1： 输入：1 10000 0 输出：6          28        496       8128 Sample 2： 输入：2000 5000 4 输出：2048    2144     4030     4096 Sample 3： 输入：900 1000 0 输出：There is no proper number in the interval. 我的代码： #include <stdio.h> #include <math.h> int main () {    int a,b,c,ans,i1,i2,d,e,flag,flag1;    i2=c=d=flag=flag1=1;    i1=2;    e=1;     scanf ("%d%d%d",&a,&b,&c);     ans=a;     while (ans<=b)     {         i1=2;         e=1;         if ((ans==1&&b==1)&&(c!=0))                 {ans=ans+1;                 printf ("1");                 flag1=0;}         if (ans==1)             ans=ans+2;         while (i1<ans&&flag1==1)         {             if (ans%i1==0)                 {d=ans/i1;                 e=e+d;}             i1=i1+1;         }         if (fabs(e-ans)<=c&&flag1==1)         {             printf ("%d\t",ans);             flag=0;         }         ans=ans+1;     }     if (flag==1&&flag1==1)     {printf ("There is no proper number in the interval.");}     printf ("\n");     return 0; } 这一题我每次提交都显示答案错误，哭了，试了好多例子都没问题啊ORZ，如果大佬有空的话可以顺带把这题也解答一下吗，拜托您了


Question: 时间超限

引用 1 楼 自信男孩 的回复：while ((order = getchar()) == '\n') ; 改成这样试试 注意while末尾有分号，即getchar()得到的是'\n'则继续循环，否则退出～我懂了，是因为输入格式是 “数字 数字” 命令：ABCD...但是外面那个循环扫描不到EOF

引用 1 楼 自信男孩 的回复：while ((order = getchar()) == '\n') ; 改成这样试试 注意while末尾有分号，即getchar()得到的是'\n'则继续循环，否则退出～在这里order是命令，就是ABCDEF是不同的命令￼，花括号里是根据不同的命令做出不同的指令，如果加上分号的话，{｝里就没有用了，可能是我没把题目说清楚。￼


Question: 计算机小白想要通过OJ作业

#include <stdio.h> #include <math.h>  int main() {     int a, b, c;     int sum = 0;     int count = 0;     int sure = 0;      scanf("%d %d %d", &a, &b, &c);     for(int i = a; i <= b; i++)     {         sum = 0;         for(int k = 1; k < i; k++)         {             if(i % k == 0)             {                 sum = sum + k;             }         }         if(fabs(i - sum)<= c)         {             sure = 1;             count++;             if(count != 0 && (count % 5) == 0)             {                 printf("%d\n",i);                 count = 0;             }             else             {                 printf("%d\t",i);             }          }      }     if(sure == 0)         printf("There is no proper number in the interval.\n");      return 0; } 给个样例给你，你看不懂的话问我就行。


Question: Time Limit Exceeded Length

不过还是超时啊

引用 1 楼 自信男孩的回复:#include<stdio.h>  //void sort(int s[]) void sort(int s[], int len) {     int t;     //for(int i=0;s[i]!='\0';i++)     for(int i=0; i < len;i++)         //for(int j=i+1;s[j]!='\0';j++)         for(int j=i+1; j < len;j++)             if(s[i]<s[j])             {                 t=s[i];                 s[i]=s[j];                 s[j]=t;             } }  int main() {     int n,m;     int a[3005],b[1005];     while(scanf("%d %d",&n,&m)!=EOF)     {         for(int i=0;i<n;i++)             scanf("%d",&a[i]);         int k=0;         for(int i=0;i<n;i++)             for(int j=i+1;j<n;j++){                 b[k]=a[i]+a[j];                 k++;             }         //sort(b);         sort(b, k);         for(int i=0;i<m;i++)             printf("%d ",b[i]);         printf("\n");     } } 供参考～  楼主是不是搞混了，'\0'是字符串的结束标记，不是int整型数的结束 是了 谢谢 昨天我也考虑到了是这个位置出了问题，但最后改来改去的把自己搞懵了


Question: c语言初学者求教

我会了，谢谢大家

谢谢了，我试试

一般不同编译器99%的语法都是按照标准来的，当然不同编译器之间 也会有略微的不同。就像这个scanf函数，可能在别的编译器没有错误，但是到了微软的编译器里面，必须得用微软提供的“安全”的scanf_s函数才行。不过一般没有什么太大的错误 遇到了看一下错误提示小改一下就行

引用 5 楼 user-3的回复:错误提示显示 scanf函数是不安全的 楼主可以试试下面这段代码 应该可以解决你的问题 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h>  int max(int a, int b) { 	if (a > b) return a; 	else return b; }  int main() { 	int x, y,z; 	printf("请输入两个整数："); 	scanf("%d %d", &x, &y); 	z = max(x, y); 	printf("max=%d\n", z); 	return 0; } 代码仅供参考 谢谢了，这个我在书上没第一行就成功了，为什么实际操作就有了问题，这是编译器的问题？

引用 2 楼 自信男孩的回复:把scanf改成scanf_s吧，其他不变；建议楼主从网上搜一下scanf_s的用法，尤其是对%s, %c等需要增加参数～ 行，我找找谢谢了

引用 1 楼 qybao的回复:微软的编译器现在那么霸道了？竟然是错误而不是警告？ 代码本身没问题，编译器让它有问题 看错误提示是，scanf被认为是不安全的（有内存越界的可能），所以编译器推荐你用scanf_s 其实用scanf_s反而还不利于移植，所以可以define一下_CRT_SECURE_NO_WARNNINGS 宏来忽略该错误提示 这个代码加在哪里？我打了scanf_s调试时就成了空白


Question: while和switch

少了break

对于switch里的case语句后，你需要根据你的意图添加break语句来跳出当前的循环，否则系统就会默认为顺序向下执行

楼主的switch中缺少break;如果在每个case后面加一个break;则会输出: fat hat cat 试试加上break;  不加break;则会顺序执行～第一次从0开始一次执行case 1, case 2, default，第二次从case 1执行，执行case 1, case 2, default以此类推～

没有break; case语句最后如果有break就跟你想的一样了

加break

case 0:printf_s("fat ");break; case 1:printf_s("hat ");break; case 2:printf_s("cat ");break; default:printf_s("oh no!");break; 你少了break

我的理解是 分别打印3行 fat hat cat


Question: 将第一个字母变成第26个字母，第i个字母变成第（26-i+1）个字母

谢谢，问题解决了，谢谢

把最后一个else if删掉 没必要 其他看起来没问题，不要用ASCII值计算用字母代替  容易理解

对于大小写，不同的操作这个是正确的。 //大写 b[i] = 26 - (a[i] - 'A') + 'A'; //小写 b[i] = 26 - (a[i] - 'a') + 'a'; 试试～

引用 楼主 clear1over 的回复:有大佬帮忙看一下这个问题出在哪了吗？ 你这编译不通过吧？ 第二个else if没有构成完整的语句，也就是那后面啥都没接，你可以加个分号，表示空语句。 另外，你代码里最好还是不要直接用90、65等数字，用'Z'、'A'、'z'、'a'，这些字符本质上就是数字，用它用数字效果一样，还不如就用字符


Question: 一个小白想要通过OJ

谢谢各位啦！

引用 2 楼 自信男孩 的回复:[quote=引用 1 楼 5250 的回复:]#include <stdio.h> #include <string.h>  int main() {    char num[10];    memset(num, -1, sizeof(char) * 10);    scanf("%s", num);    for (int i = 0; i < 10; i++)    {       if (num[i] != -1)          printf("%c ", num[i]);    }    printf("\n");    return 0; }  供参考  这个程序，可以这么做： for (int i = 0; i < strlen(num); i++)[/quote]  谢谢

#include <stdio.h> #include <stdlib.h> #include <string.h>    void print_digit(unsigned long num);  int main(void) {     unsigned long num;      scanf("%lu", &num);       print_digit(num);     putchar(10);      return 0; }  void print_digit(unsigned long num) {     if (num == 0)         return;      print_digit(num / 10);     printf("%lu ", num % 10); }  供参考～  可以考虑使用递归函数，如上～

引用 1 楼 5250 的回复:#include <stdio.h> #include <string.h>  int main() {    char num[10];    memset(num, -1, sizeof(char) * 10);    scanf("%s", num);    for (int i = 0; i < 10; i++)    {       if (num[i] != -1)          printf("%c ", num[i]);    }    printf("\n");    return 0; }  供参考  这个程序，可以这么做： for (int i = 0; i < strlen(num); i++)