Question: 幸运彩票

引用 26 楼 maggielve 的回复:[quote=引用 25 楼 qq_1457346882的回复:][quote=引用 21 楼 maggielve 的回复:][quote=引用 20 楼 qq_1457346882 的回复:][quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include "stdio.h" int main() { 	char a[100][6]; 	int n,i,j,sum1 = 0, sum2 = 0; 	scanf("%d",&n); 	for( i = 0 ; i < n ; i++ ) 		scanf("%s",&a[i]); 	for( i = 0 ; i < n ; i++ ) 	{ 		sum1 = 0, sum2 = 0; 		for( j = 0 ; j < 6 ; j++ ) 		{ 			if( j <= 2 ) 				sum1 += a[i][j]-'0'; 			else 				sum2 += a[i][j]-'0'; 		} 		if( sum1 == sum2 ) 			printf("You are lucky!\n"); 		else 			printf("Wish you good luck.\n"); 	} 		 		 		 		 		 	return 0; } [/quote] 所以你这个表情拿来什么意思呢？你没做处理？[/quote] 我这段代码是对的[/quote] sum1 += a[i][j]-'0'; 那你这还不是经过了处理？把字符换成了数字，我服了

强.。。。。。。。。。。。。

引用 23 楼 maggielve 的回复:[quote=引用 22 楼 weixin_54938528的回复:]很好，对我很有帮助，感谢！ 你码龄才两天够强了[/quote]  啥意思??????????????

引用 25 楼 qq_1457346882的回复:[quote=引用 21 楼 maggielve 的回复:][quote=引用 20 楼 qq_1457346882 的回复:][quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include "stdio.h" int main() { 	char a[100][6]; 	int n,i,j,sum1 = 0, sum2 = 0; 	scanf("%d",&n); 	for( i = 0 ; i < n ; i++ ) 		scanf("%s",&a[i]); 	for( i = 0 ; i < n ; i++ ) 	{ 		sum1 = 0, sum2 = 0; 		for( j = 0 ; j < 6 ; j++ ) 		{ 			if( j <= 2 ) 				sum1 += a[i][j]-'0'; 			else 				sum2 += a[i][j]-'0'; 		} 		if( sum1 == sum2 ) 			printf("You are lucky!\n"); 		else 			printf("Wish you good luck.\n"); 	} 		 		 		 		 		 	return 0; } [/quote] 所以你这个表情拿来什么意思呢？你没做处理？[/quote] 我这段代码是对的

引用 21 楼 maggielve 的回复:[quote=引用 20 楼 qq_1457346882 的回复:][quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include "stdio.h" int main() { 	char a[100][6]; 	int n,i,j,sum1 = 0, sum2 = 0; 	scanf("%d",&n); 	for( i = 0 ; i < n ; i++ ) 		scanf("%s",&a[i]); 	for( i = 0 ; i < n ; i++ ) 	{ 		sum1 = 0, sum2 = 0; 		for( j = 0 ; j < 6 ; j++ ) 		{ 			if( j <= 2 ) 				sum1 += a[i][j]-'0'; 			else 				sum2 += a[i][j]-'0'; 		} 		if( sum1 == sum2 ) 			printf("You are lucky!\n"); 		else 			printf("Wish you good luck.\n"); 	} 		 		 		 		 		 	return 0; } [/quote] 所以你这个表情拿来什么意思呢？你没做处理？

引用 9 楼 lin5161678的回复:[quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf("%1d",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？

引用 18 楼 自信男孩的回复:对于不同，你有么有好好分析？不同，不对就直接问，你自己的思考呢？ 额，我肯定是思考过后不会才问的

对于不同，你有么有好好分析？不同，不对就直接问，你自己的思考呢？

引用 4 楼 maggielve 的回复:[quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf("%1d",&a[i]); 那也不对啊？[/quote]你不会 不是我不对

这个可以非常简单吧：  #include <stdio.h>  int main() {   int a, b, c, d, e, f;    for (scanf("%d", &a); scanf("%1d%1d%1d%1d%1d%1d", &a, &b, &c, &d, &e, &f) == 6;)     a + b + c == d + e + f ? puts("You are lucky!") : puts("Wish you good luck.");    return 0; }

引用 12 楼 lin5161678的回复:[quote=引用 10 楼 maggielve 的回复:][quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf("%1d",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说[/quote] 咱俩的代码不一样，我只是在我的代码上又加了个1，而你这段代码是可以的

引用 13 楼 自信男孩的回复:[quote=引用 12 楼 lin5161678 的回复:][quote=引用 10 楼 maggielve 的回复:][quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf("%1d",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说[/quote] 楼主是自己不懂，就怪别人，别人会的他不会就是别人的错。所以，不要跟他计较这些。 楼主没有虚心学习的态度，只有挑刺和不承认自己的差距的问题～[/quote] 我按照别人说的改了下代码，然后测试有错误，我就说了下有错误，怎么了？我怎么就挑刺了，我怎么就怪别人了？你不要无中生有好不好？

引用 11 楼 qq_1457346882的回复:整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以

引用 22 楼 weixin_54938528的回复:很好，对我很有帮助，感谢！ 你码龄才两天够强了👍

引用 12 楼 lin5161678 的回复:[quote=引用 10 楼 maggielve 的回复:][quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf("%1d",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说[/quote] 楼主是自己不懂，就怪别人，别人会的他不会就是别人的错。所以，不要跟他计较这些。 楼主没有虚心学习的态度，只有挑刺和不承认自己的差距的问题～

引用 10 楼 maggielve 的回复:[quote=引用 9 楼 lin5161678的回复:][quote=引用 4 楼 maggielve 的回复:][quote=引用 2 楼 lin5161678的回复:]    for( i = 0 ; i < n ; i++ )         scanf("%1d",&a[i]); 那也不对啊？[/quote]你不会 不是我不对[/quote] 测试系统显示不对，怎么说？？？[/quote] 测试系统又显示对了，又怎么说

很好，对我很有帮助，感谢！

整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  引用 5 楼 maggielve 的回复:[quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?

引用 20 楼 qq_1457346882 的回复:[quote=引用 14 楼 maggielve 的回复:][quote=引用 11 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了  [quote=引用 5 楼 maggielve 的回复:][quote=引用 3 楼 qq_1457346882的回复:]整数需要处理，不能直接取过来用，看你定义应该是想定义一个空放一个数字，一个数放六个地址里，但是这样是没法做的，就算你定义char单个输进来字符也需要处理转化成数字才能计算，要么就是int类型数字分开存储，但是那你就是存了六个数字不是一个数字了 char可以，2楼说的不对啊，[/quote] 你是想说定义char a[100][6],比如传入2　3　3　0　0　8可以直接a[i][0]+a[i][1]...?[/quote] 嗯，这个可以[/quote] 。。。 这个完全不可以，不经过转换处理的话，字符类型的数据与整型数据所承载的信息是不一样的，包括数据类型大小，地址分配这些存储方式，还有ASCLL码上的值，你有尝试过嘛就说char可以直接用，你传两个char字符，一个传８，一个传９，你看看输出结果是什么[/quote] #include "stdio.h" int main() { 	char a[100][6]; 	int n,i,j,sum1 = 0, sum2 = 0; 	scanf("%d",&n); 	for( i = 0 ; i < n ; i++ ) 		scanf("%s",&a[i]); 	for( i = 0 ; i < n ; i++ ) 	{ 		sum1 = 0, sum2 = 0; 		for( j = 0 ; j < 6 ; j++ ) 		{ 			if( j <= 2 ) 				sum1 += a[i][j]-'0'; 			else 				sum2 += a[i][j]-'0'; 		} 		if( sum1 == sum2 ) 			printf("You are lucky!\n"); 		else 			printf("Wish you good luck.\n"); 	} 		 		 		 		 		 	return 0; }


Question: c语言新手请教——实现字符串连接

懂了，谢了各位。要想输出字符串，需要自己手动添加'\0'。

供参考：int main() {////***连接字符串     char str1[50],str2[20];     int i,j;     printf("输入第一个字符串(不含空格)：\n");     scanf("%s",str1);     printf("输入第二个字符串(不含空格)：\n");     scanf("%s",str2);     i=j=0;     while(str1[i])i++;                     //while(str1[i]!='\0') {i=i+1;}     while(str2[j])     {               str1[i++] = str2[j++];  //str1[i+1] =str2[j];                                                  //printf("连接后的字符串1：%s\n",str1);                                                  //i=i+1;                                                  //j=j+1;     }     str1[i] = '\0';  //strcat(str1,str2);     printf("\n连接后的字符串1：%s\n",str1);         return 0; }

因为你'\0'还存在，没有被修掉

差点儿被你绕昏了，0后面就不算字符串的内容了啊！

楼上说了 。还有数组初始化时要清零 ，操作不要溢出

#include <stdio.h>  #define DEBUG  int main() {////***连接字符串     char str1[50],str2[20];     int i,j;     printf("输入第一个字符串(不含空格)：\n");     scanf("%s",str1);     printf("输入第二个字符串(不含空格)：\n");     scanf("%s",str2);     i=j=0;     while(str1[i]!='\0') {i=i+1;}     while(str2[j]!='\0')     {               //str1[i+1] =str2[j];               str1[i] =str2[j]; #ifdef DEBUG               str1[i+1] = 0;                printf("连接后的字符串1：%s\n",str1); #endif               i=i+1;               j=j+1;     }     str1[i] = 0; //equal '\0' //    strcat(str1,str2);     printf("\n连接后的字符串1：%s\n",str1);     return 0; }  供参考～  在第一个字符串的末尾，即'\0'的位置存放第二个字符串的第一个字符，而不是第一个字符串'\0'的下一个位置存放第二个字符串的第一个字符  另外，字符串都是一个'\0'结束，因此要%s输出，需要添加'\0'


Question: C语言实现打印出心形，初学者的表白神器。

一个建议：循环变量用整型。因为浮点数会有微小的误差，可能导致循环次数跟预想的不同。 比如  for (int i=0; i<21; i++) {     double y = 2.5 - i * 0.2;     .... }


Question: 看看大家的解题方法

#include<stdio.h> #include<stdlib.h>  typedef struct Node { 	int data; 	struct Node *next; }node; typedef struct Node *LinkList;  /*=============================================================== CreateLinkList函数功能： 创建链表L, 并将给定数组a, 以及数组中元素个数n，尾部插入法建立循环链表 ===================================================================*/ LinkList createlist(LinkList *L,int n,int a[]) { 	LinkList p,r; 	int i;  	(*L)=(LinkList)malloc(sizeof(node));  // 建立头结点 	r=*L;  	for(i=0;i<n;i++) 	{ 		p=(LinkList)malloc(sizeof(node));   // 生成新结点 		p->data=a[i]; 		r->next=p; 		r=p; 	} 	r->next=(*L)->next; 	free(*L); 	return r->next; }  int main() { 	int A[]={0}; 	int i,j,N,m; 	LinkList pi,p,temp;  	printf("请输入链表元素的个数："); 	scanf("%d",&N); 	for(i=0;i<N;i++) 	{ 		scanf("%d",&A[i]); 	} 	p=createlist(&pi,N,A); 	m=p->data; 	while(p!=p->next) 	{ 		for(j=1;j<(m-1);j++) 		{ 			p=p->next; 		} 		m=p->next->data; 		printf("%d->",m); 		temp=p->next; 		p->next=temp->next; 		free(temp); 		p=p->next; 	} 	printf("%d\n",p->data);  	return 0; }

这不是约瑟夫环吗？90%是一样的，不一样的地方是这个数数的值是变化的。 先写出一个约瑟夫环的代码，再考虑把这个数数的值变化加进去就好了。

引用 1 楼 forever74 的回复:难怪高考语文总是受重视，原来有人出题都不好好表达。 所有人全部出列还写什么代码，散了吧，所有人都撤了，没啥好看的了。  对头。有挑战性的，应该分出loser和winner。。这样才有意义。。。


Question: C语言输出有误，多输出了乱码，求助！！

引用 8 楼 阿麦的回复:先把数组 a 初值设置为 \0 就可以。 但是更好的习惯是注意防患内存溢出：字符串以 \0 结尾，且不能超出定义长度  void alter(char a[]) {     int i;     int len = strlen(a);     if (len > 19)     {         len = 19;         a[19] = '\0';     }     for(i=len; i>=0; i--)     {         a[2*i+1]=a[i];         a[2*i]=' ';        }     puts(a); }  华东师大的大佬！！！ 谢谢谢谢 学到了学到了

for循环从4开始吧，因为需要考虑到'\0'，字符串需要以'\0'结束。

引用 3 楼 云中屋的回复:没有结束符就一直往下打印直到遇到结束符，下面是一种修改方式的代码，供参考。   #include<stdio.h> void alter(char a[]) {     int i;     for(i=3;i>=0;i--)     {         a[2*i+1]=a[i];         a[2*i]=' ';        }     a[2*4] = '\0'; //在最后增加一个结束符      puts(a);       } int main() {     char a[40];     printf("输入一个四位数：\n");     scanf("%s",&a);     alter(a);     return 0; }  OK 我明白了 谢谢谢谢

引用 1 楼 user-5的回复:你没处理结束符，多一个就行。 for(i=4;i>=0;i--) 谢谢大佬 十分感谢

你没处理结束符，多一个就行。 for(i=4;i>=0;i--)


Question: 请教大神 这两者的区别

希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

第一张图应该这样#include <stdio.h> int main() {     int  score;     char grade;     printf("Please input score:");     scanf("%d",&score);     if(score<0 || score>100){         printf("Input error!\n");         return 0；      }     else if(score >= 90)        grade = 'A';     else if(score >= 80)        grade = 'B';     else if(score >= 70)        grade = 'C';     else if(score >= 60)        grade = 'D';     else        grade = 'E';     printf("grade:%c\n",grade);     return 0; }

引用 7 楼 maggielve 的回复:[quote=引用 4 楼 是疗伤烧肉粽~ 的回复:]第一张图的代码是错的，在第一个if的printf后加上return 0就对了。记得要加大括号。 第二张图是对的。 两张图没什么区别，看你喜欢用哪个 没错啊？选择结构，执行一次就不往下执行了 [/quote]。。。。你自己去运行一下就知道哪里错了

第一图修改，供参考：#include <stdio.h> int main() {     int  score;     char grade;     printf("Please input score:");     scanf("%d",&score);     if(score<0 || score>100)        grade = 'F';//printf("Input error!\n");     else if(score >= 90)        grade = 'A';     else if(score >= 80)        grade = 'B';     else if(score >= 70)        grade = 'C';     else if(score >= 60)        grade = 'D';     else        grade = 'E';      if(grade == 'F')        printf("Input error!\n");     else        printf("grade:%c\n",grade);        return 0; }

引用 4 楼 是疗伤烧肉粽~ 的回复:第一张图的代码是错的，在第一个if的printf后加上return 0就对了。记得要加大括号。 第二张图是对的。 两张图没什么区别，看你喜欢用哪个 没错啊？选择结构，执行一次就不往下执行了

差不多，第一张图<0 || > 100，printf之后要ruturn -1，不然程序不会退出

把ruturn 0去掉就可以了

可以在第一个else下放置{}，范围到return 0前面

运行一下不就明白了？

grade没有初始化，如果<0 || > 100，最后输出的greade是一个随机值。   两张图片的区别应该是有没有在return 0前加printf吧


Question: 疑问，枚举类型变量该怎么赋值？大神求解！！

引用 5 楼 早打大打打核战争的回复:tomorrow = (Weekday)((int)today + 1); 高手厉害，的确是我格式有问题。编译成功了！谢谢！！

tomorrow = (Weekday)((int)today + 1);

好的，原来这样。

不可以的。那个相当于一个#define的定义。


Question: C语言全局变量问题，大佬救命

引用 4 楼 user-2的回复:全局位置的 int a; 分配空间建立全局变量并初始化为0，并慷慨地允许其他文件使用这个变量。 static int a; 分配空间建立全局变量并初始化为0，并禁止其他文件分享该变量。  extern int a; 这个出现在“其他文件”里面，并不分配空间建立变量，而是把上面第一行那个变量介绍到本文件来发挥作用。 谢谢 老铁 我懂了

全局变量就是全局变量，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”其他文件可使用extern来引用同一个变量。static是静态存储的意思。在开头声明该文件可用。在代码块中使用只能在代码块中可见，和代码块中栈的变量区别是，栈中声明的变量会清理，比如while里声明的int变量一个循环后会被重新创建，而static的变量值不变，而且不会消除，重新创建。程序存在static变量存在。

全局变量默认情况下和static还有extern都不同。 所以全局变量没有默认存储类别。

之前有看到默认是static 感到不太确定

有人吗 我晕了


Question: C语言

感谢指导，谢谢了

楼主的方法:#include"stdio.h" int main() {     float grade[][4]={60,70,80,90,56,89,67,88,34,78,90,66};//存放成绩     float *search(float(*pointer)[4]);     float *p;     int i,j;     for(i=0;i<3;i++)        {          p=search(grade+i);          if(p==*(grade+i)){             printf("No.%d",i+1);//输出学号             for(j=0;j<4;j++)                printf("%6.2f",*(p+j));// 输出满足条件的学生的成绩             printf("\n");          }        }     // system("pause");     return 0; }   float *search(float(*pointer)[4])  {     float *pt;     int i;     pt=NULL;     for(i=0;i<4;i++)        if(*(*pointer+i)<60)pt=*pointer;     return pt; }

供参考：#include"stdio.h"  int main(int argc, char* argv[]) {     float grade[][4]={60,70,80,90,56,89,67,88,34,78,90,66};//存放成绩     float *search(float(*pointer)[4]);     float *p;     int i,j;     for(i=0;i<3;i++)        {           p=search(grade+i);           if(p){              //if(p==*(grade+i)){              printf("No.%d ",i+1);//输出学号              for(j=0;j<4;j++)                 printf("%6.2f",*(*(grade+i)+j));// 输出满足条件的学生的成绩              printf("\n");           }        }      //system("pause");     return 0; }   float *search(float(*pointer)[4]) {     float *pt;     int i;     pt=NULL;     for(i=0;i<4;i++)        if(*(*pointer+i)<60) pt=(*pointer+i);     return pt; }


Question: 浮点数减法

引用 4 楼 赵4老师 的回复:

引用 2 楼 user-2 的回复:减法运算用补码就是加法运算 X-Y=X+(-Y)=X[补]+(-Y)[补] 所以(-Y)[补]不对  嗯嗯，明白了，谢谢大佬

找到错误了


Question: c#从数据库得到点的坐标大小，在zedgraphcontrol分别显示

1.打开数据库； 2.读一行数据，并显示； 3.重复第2条，直至结束 4.Game over


Question: IAR在函数中已经声明了外部变量 但是却提示错误Undefined external "arr" referred in lvbo

说明编译器确实没找到它。

或者说你的工程/项目引用文件不全，不是源代码写法的事。

编译的时候不会出这个错误，连接的时候你得确保把相关的目标文件都连接进来。

我是定义在.c文件里的 .c文件可以引用吗？

你得把extern unsigned long arr[5];这个外部数组的.c .h文件导入进来，不然不知道上哪找。


Question: 输出1000以内的素数，每行10个。

希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

。。。。。你在教我做事？？？

认真学习！

成就感对菜鸟和大神是公平的。

#include <stdio.h> #include <stdlib.h> #include <math.h>  int prime(int n) {     int i, flag = 1;      if (abs(n) < 2)         return 0;      for(i=2;i<n;i++)   //for (i = 2; i < sqrt(n)+1; i++) 优化，降低时间复杂度         if (n % i == 0)         {             flag = 0;             break;         }     return(flag); } int main(void) {     int a, n = 0;      for (a = 2;a <= 1000;a++)     {         if (prime(a) == 1)         {             printf("%5d", a);             n++;             if (n % 10 == 0)                 printf("\n");         }     } } 供参考～

牢记1000以内素数的重要性，请看电影《cube》

没问题，楼主这是在教大家解题方法吗

阅，再接再厉。


Question: 请教大神

scanf("%d%*[^0-9-]%d", &a, &b);

scanf("%d%*c%d", &a, &b); 仅限单个字符作为分隔符。


Question: C语言如果没有学过指针，这个代码还能简化吗

while (xy[x - 1][y - 1] != 8 || x > 3 || x < 1 || y>3 || y < 1);//检查  这句有问题，应该先判断越界

那个字符串可以定义成二维数组，就不带星了，抱歉顺手写成指针了。

另外，我个人痛恨goto，请原谅。

在你的思路上去重复，我没有验证过： #include <stdio.h> #define DRAW printf("  1 2 3\n\n1 %d|%d|%d\n  -----\n2 %d|%d|%d\n  -----\n3 %d|%d|%d\n", xy[0][0], xy[0][1], xy[0][2], xy[1][0], xy[1][1], xy[1][2], xy[2][0], xy[2][1], xy[2][2]) //排出井字棋 //能短点就短点  int main() { 	int x, y; 	int xy[3][3] = { 		{8,8,8}, 		{8,8,8}, 		{8,8,8}, 	}; 	int i = 2; 	char * player[2] = { "反方","正方" }; 	int k=1;     //这个和上一行是新加的，用来表示双方 	DRAW; 	for (; i == 2; k=1-k) {      // 有变动 		const int SIZE = 3; 		int t, j; 		int hz, hf, lz, lf, zdjz, zdjf, fdjz, fdjf; //定义行，列，对角线的正反方计数变量  		hz = hf = lz = lf = zdjz = zdjf = fdjz = fdjf = 0;//初始化变量   		//输入   		do { 			printf("%s，请在8的区域输入：",player[k]);  // 有变动 			scanf("%d，%d", &x, &y); // 有风险 ，两个格式符之间的逗号，是中文的 		} while (xy[x - 1][y - 1] != 8 || x > 3 || x < 1 || y>3 || y < 1);//检查  		xy[x - 1][y - 1] = k; // 有变动 		DRAW;  		//循环判断  		for (t = 0; t < SIZE; t++) { 			hz = lz = 0; 			for (j = 0; j < SIZE; j++) { 				//检查行  				if (xy[t][j] == k ) { // 有变动 					hz++; 				} 				if (hz == 3) { 					i = k; // 有变动 					break; // 有变动 				} 				//检查列  				if (xy[j][t] == k ) { // 有变动 					lz++; 				} 				if (lz == 3) { 					i = k; // 有变动 					break; // 有变动 				} 			} 			if (i != 2)break; // 有变动 			//检查正对角线 			if (xy[t][t] == k ) { // 有变动 				zdjz++; 			} 			if (zdjz == 3) { 				i = k; // 有变动 				break; // 有变动 			} 			//检查反对角线  			if (xy[t][SIZE - t - 1] == k) { // 有变动 				fdjz++; 			} 			if (fdjz == 3) { 				i = k; // 有变动 				break; // 有变动 			} 		} 		//        printf("hz:%d,lz:%d,zdjz:%d,fdjz:%d\n\n",hz,lz,zdjz,fdjz); 	} 	// 有变动 	//if (i == 1) { 	//	printf("正方胜利"); 	//} 	//else { 	//	printf("反方胜利"); 	//} 	printf("%s胜利",player[i]);  	return 0; } 短一些也算简化吧？ 进一步 by yourself !

可是不知道怎么优化了。。。。。

这个说的是流程上的简化，以后还可以琢磨算法上的简化。

有重复，自然就可以简化。


Question: 为什么这个代码无法读取10.

引用 6 楼 自信男孩 的回复:[quote=引用 5 楼 文武双缺 的回复:][quote=引用 3 楼 自信男孩 的回复:]if (ch=='\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\n'一样。 %d只会匹配数字，其他字符是不匹配的，即接收不到'\n'。当然也不会存在。 一楼说的就是问题的答案！ 你输入10，然后回车，ch就接收到10这个数了（%d匹配数10，回车符后续会被丢掉），就会进入“if (ch=='\n')”了。（‘\n’的数值也是10） 补充一点： 你代码中(如下)的odd和even作为除数是不能等于‘0’的，使用前要做好判断，否则也会出问题的。 printf("Odd number is %d,and which average is %d.\nEven average is %d, and which average is %d",         odd, sum_odd / odd, even, sum_even / even);[/quote] “%d匹配数10，回车符后续会被丢掉” 回车符不是被丢掉吧，回车符还在输入缓存里，不信的话可以在scanf_s之后加一个getchar();可以将回车符接收到，并打出来看看是不是回车符  回车的目的是将输入缓存的数据刷到内存里，但是'\n'还是在的[/quote] 你说的没错，我这么说是为了方便你理解。 有兴趣的话，你可以继续深入研究下去，这里不是终点。

引用 5 楼 文武双缺 的回复:[quote=引用 3 楼 自信男孩 的回复:]if (ch=='\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\n'一样。  %d只会匹配数字，其他字符是不匹配的，即接收不到'\n'。当然也不会存在。 一楼说的就是问题的答案！ 你输入10，然后回车，ch就接收到10这个数了（%d匹配数10，回车符后续会被丢掉），就会进入“if (ch=='\n')”了。（‘\n’的数值也是10） 补充一点： 你代码中(如下)的odd和even作为除数是不能等于‘0’的，使用前要做好判断，否则也会出问题的。 printf("Odd number is %d,and which average is %d.\nEven average is %d, and which average is %d",         odd, sum_odd / odd, even, sum_even / even);[/quote]  “%d匹配数10，回车符后续会被丢掉” 回车符不是被丢掉吧，回车符还在输入缓存里，不信的话可以在scanf_s之后加一个getchar();可以将回车符接收到，并打出来看看是不是回车符  回车的目的是将输入缓存的数据刷到内存里，但是'\n'还是在的

引用 3 楼 自信男孩 的回复:if (ch=='\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\n'一样。  %d只会匹配数字，其他字符是不匹配的，即接收不到'\n'。当然也不会存在。 一楼说的就是问题的答案！ 你输入10，然后回车，ch就接收到10这个数了（%d匹配数10，回车符后续会被丢掉），就会进入“if (ch=='\n')”了。（‘\n’的数值也是10） 补充一点： 你代码中(如下)的odd和even作为除数是不能等于‘0’的，使用前要做好判断，否则也会出问题的。 printf("Odd number is %d,and which average is %d.\nEven average is %d, and which average is %d",         odd, sum_odd / odd, even, sum_even / even);

楼上说的对，'\n'的ASCII值就是10，可以把'\n'改成'\0'，'\0'的ASCII值是0。

因为'\n'就是10，你输入的10被那个if截住了。


Question: 数组如何传值给一个函数？

引用 11 楼 qybao的回复:自己复制，出了性能问题是程序员自己负责，编译器复制，出了性能问题要找编译器公司吗？你作为编译器开发商，你会主动去惹这些麻烦吗？编译器应该帮用户优化而不是给用户带来隐患问题。所以，编译器不提供自动复制，想复制就自己主动复制，出了性能问题自己负责。 可能我不了解编译器原理。函数里自动帮我复制数组就怕出问题，那用户自己复制数组编译器就不会出问题？

引用 12 楼 qq_16774199 的回复：[quote=引用 11 楼 qybao的回复:]自己复制，出了性能问题是程序员自己负责，编译器复制，出了性能问题要找编译器公司吗？你作为编译器开发商，你会主动去惹这些麻烦吗？编译器应该帮用户优化而不是给用户带来隐患问题。所以，编译器不提供自动复制，想复制就自己主动复制，出了性能问题自己负责。 可能我不了解编译器原理。函数里自动帮我复制数组就怕出问题，那用户自己复制数组编译器就不会出问题？[/quote]不是说了吗？用户用了复制出问题和用户没用复制你却给主动别人带来问题，这是不同级别严重性。

你有选择语言的自由，你也有自己设计语言的自由。 但学习语言首先就不得不接受它。 所以你的思路已经跑偏了，摆正位置先。 否则下一步要质疑的就是硬件了：干嘛不搞十进制？

引用 8 楼 qybao的回复:Java也是这样的，你试试就知道了。在函数内改变数组元素，看看函数外变不变 既然普通变量可以传值传址，为什么语法上不给数组传值的写法呢？至于用不用那是程序员的事，自己复制一个数组那开销还不是少不了。

Java也是这样的，你试试就知道了。在函数内改变数组元素，看看函数外变不变

引用 6 楼 qybao 的回复:你这是要反人类行动吗？ 为什么数组需要转成指针？为啥不先去好好思考这个问题。 假设你这个数组有1亿个元素，如果是按值传递，光是参数拷贝1亿个数据估计就要花好一段时间，而且还占用内存（原来的数组已经很占内存了，再复制一个数组就更占用内存，调几次函数内存就要枯竭了）。好的编译器不应该自动给程序带来类似这样的性能隐患。正是为了解决这些问题，编译器才采用传地址的方式来传数组，一是省时间，不需要元素拷贝，而是省空间，参数只占用一个指针大小的空间。如果用户自己需要新的数组，就自己手动去声明一个数组，然后用内存拷贝方式自己去复制。这样，性能问题完全交由用户自己去控制，而不是编译器自动给用户制造麻烦。  请问java也是这样的做法吗？

因为C语言的设计者希望一方面简化编译器的复杂度，另一方面给C猿以足够的自由。  你真的需要副本的话完全可以在上级（调用者）函数里自己处理，memcpy搞定即可。

引用 3 楼 forever74的回复:局限是结构体中的数组大小必须是常量。 为什么这么麻烦，如果是普通变量就很容易，传值传址一个*号的事情。

局限是结构体中的数组大小必须是常量。

可以把数组整体放进结构体，传递结构体类型的参数。

数组参数加个const应该可以实现你的要求。


Question: 求大佬讲解

谢谢各位大佬

引用 8 楼 qybao 的回复:[quote=引用 5 楼 我当时害怕极了QAQ 的回复:]  老师，我晕了  8位整形范围不是-128到127吗  -100咋溢出了呢 溢出应该是不以表示范围来判断的，正因为它溢出，所以才保证了它的值还在范围里 比如 0x7FFFFFFF(4位int的最大值) + １ = 0x80000000 (变为负数) 这个负数也在 0x80000000到0x7FFFFFFF的范围里，那它算不算溢出？ [/quote]   明白了，应该用和的补码判断溢出  我直接算原码的和了  就是没有判断溢出。。。

四楼的四老师已经生动证明了，溢出和出错是两回事。溢出并不必然伴随着出错。  回想你八岁的时候，溢出了一颗牙齿，太正常了。

引用 5 楼 我当时害怕极了QAQ 的回复:老师，我晕了  8位整形范围不是-128到127吗  -100咋溢出了呢 溢出应该是不以表示范围来判断的，正因为它溢出，所以才保证了它的值还在范围里 比如 0x7FFFFFFF(4位int的最大值) + １ = 0x80000000 (变为负数) 这个负数也在 0x80000000到0x7FFFFFFF的范围里，那它算不算溢出？

溢出是针对有符号数的，无符号数是进位/借位

题目有点问题，没有明确是有符号还是无符号的

引用 4 楼 赵4老师 的回复:x表示-16 y表示-72 z=4*x+y/2  =4*(-16)+(-72)/2  =-100   4*x=1100 0000 //符号位是1，说明是负数，保留符号位，左移2位（低位补0）表示-64 y/2=1101 1100 //符号位是1，保留符号位，右移1位（高位补1）表示-36 相加结果，1 1001 1100虽然有溢出，但取其低8位，1001 1100 表示-100，结果正确。  老师，我晕了  8位整形范围不是-128到127吗  -100咋溢出了呢

引用 1 楼 qybao 的回复:4*x=1100 0000 //符号位是1，说明是负数，保留符号位，左移2位（低位补0） y/2=1101 1100 //符号位是1，保留符号位，右移1位（高位补1） 相加结果，11001 1100，说明溢出了，其实只需要看两个操作数的符号位紧接着的1位是不是都是1，就能判断是否会溢出了  大佬，y/2我算的不一样  不应该是由（y补）先算y = 11001000  y/2 = 10100100吗

要看它的整型长度多少，如果只有1字节的话，肯定溢出了


Question: 揭开内存的秘密，让一切真相大白

希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

文章第一句就是从设计概念上讲，这就排除了例外，寄存器是可以储存数据，但从设计目的来看是为了加快数据储存而不是用来保存数据，要说例外有的计算机连内存都没有，只有寄存器，cpu直接向硬件发送指令。不过你回复的内容可以作为本文内容的补充，幸苦了！想不到我的帖子引出了论坛中比我更老的程序员。  内存对齐算法其实很复杂，与cpu步长、平台、编译器都有关系，具体细节我没有写出来，既然你提出来了，我就来补充一下。每个平台上的特定编译器都有自己的内存对齐方案，以Win32平台下的微软C编译器为例，策略如下： 1)结构体变量的首地址是其最长基本类型成员的整数倍。 编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能是该基本数据类型的整倍的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为对齐模数。 2)结构体每个成员相对于结构体首地址的偏移量都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节。 为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。 3)结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要，编译器会在最末一个成员之后加上填充字节。  备注： a、结构体总大小是包括填充字节，最后一个成员满足上面两条以外，还必须满足第三条，否则就必须在最后填充几个字节以达到本条要求。 b、如果结构体内存在长度大于处理器位数的元素，那么就以处理器的倍数为对齐单位；否则，如果结构体内的元素的长度都小于处理器的倍数的时候，便以结构体里面最长的数据元素为对齐单位。 4) 结构体内类型相同的连续元素将在连续的空间内，和数组一样。  我们还可以为编译器设置编译参数来影响对齐策略，程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变对齐系数，其中的n就是上面讲的默认对齐系数。取值规则为： 1、结构的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。 2、结构体的整体对齐规则：在数据成员完成各自对齐之后，结构体本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。  概括来说内存对齐策略是综合数据类型、cpu步长还有编译器参数三方面得出的结果，其实了解内存对齐对写C代码没有很大的帮助，只对写编译器的人有帮助，《C++程序设计精要教程》是一本好书，但也没讲的那么细，详情可以查阅相关编译原理的书籍。最后文章若还有疏漏之处，欢迎补充。

引用 楼主 jaj2003的回复:C语言是面向底层的语言，虽然语法和概念都很少，但却蕴含着丰富的底层知识，如果你在使用C语言时觉得语法你都会，却总是遇到这样那样的问题，并且为此一直迷惑不解，那么你欠缺的就是藏在语言下面的底层知识。要知道所有底层语言都是围绕内存工作的，因此搞懂内存是一个好的开始，本贴虽然不能为你解答所有的问题，但可以为你指引一个正确的方向。点击 https://blog.csdn.net/jaj2003/article/details/112993815 可以看到完成的内容，因为太长所以只能放入博客中。进入之前先掂量下自己的水平，因为看完只会有两种结果，对于有编程功底追寻语言背后真相的人，这篇帖子也许能让你获得重生，如果是小白来看热闹的，只会更快的将你劝退。本人花了很多时间整理，并且尽量写的通俗易懂，望珍惜。 作者辛苦了，写的很不错，道出了一般情形。但凡事皆有例外：（1）关于Cpu不能存取数据，或换句话说，内存不是Cpu的一部分，例外便是我国自主设计生产的DJS 130计算机，它采用部分内存作为寄存器，而寄存器是Cpu的一部分，所以Cpu也是可以存取数据的。（2）关于栈的操作，写的是X8086体系结构，事实有的计算机根本没有栈，根本设有push和pop指令。如IBM SYS 390系列机，它的栈是通过内存模拟的，想多大有多大，且运行中能自动检测是否溢出，且可以自动增长。(3) 即使是X8086体系也有不同之处，栈的大小在程序运行时可以设置，当然也可以在编译通过编译参数设置。例如borland编译器曾提供一个外部变量，用于在运行时设置栈的大小，格式为extern int _stklen=栈大小，这也是一种特殊的变量定义而非变量说明，其引入C++的理由正是由于有上述类似需求存在，变量定义要素参见《C++程序设计精要教程》。(4)函数参数并非全部自右向左入栈，这只是大部分编译器的做法，事实上C国际标准自己都说，入栈顺序由编译器自行决定，所以在写程序时不提倡写f(x++,x++)之类的函数调用，由于参数入栈顺序不同导致结果不同，造成程序可移植性问题；这也导致C++编译规定，函数参数默认值的表达式不得包含同一参数表的参数，具体原因参见《C++程序设计精要教程》。（5）关于内存对齐按步长对齐不妥，确切地说是按数据成员的类型对齐，关于更复杂内存布局如包含虚函数和虚基类的情况参见《C++程序设计精要教程》。

辛苦了，有空看看当复习也不错。

文字没看 实例代码扫了两眼 发现不少错误 #include <stdio.h> int main() { 	char *str = (char*) 0X000007FFF2E5FE2C4; //使用数值表示一个明确的地址 	str="abc"; 	return 0; } 对于支持64bit整型常量的编译环境来说  这段代码不存在会报错的地方 指针指向不合法的内存就不合法吧 你不比较不解引用 没什么关系  然后就是代码里面所有输入unsigned int类型的代码都写错 scanf("%ud",&len) 应该用 %u 而不是%ud 没有%ud 这个控制符 你这里是运气好d后面没有输入项所以没看出问题 你写一个 %ud%ud 就知道错了


Question: 初学C语言求助

刚刚开始学 跟着网课上走  了解的不太多

太谢谢了！好人一生平安

if(d!=g)后面的逻辑都不对，改成以下即可 if(d==g) { //如果奇偶相同就累加即可     n = n + h; }  h = h * 2; //h和a一起变化即可，不需要m控制  另外，int a = (a-c)/10; 改成 a = (a-c)/10; //不需要重新声明a m变量不需要，可以去掉

C语言课不该出这种题，算法吗？也不象，让学生掌握什么？


Question: 求教大佬

在ch2=getchar()之前加一句getchar()处理就好 因为输入a回车时，回车符残留在输入缓存里，所以加一句getchar()清空该回车符即可


Question: 请教 遍历list 为什么我得到的值  char * 类型的 不正确呢，整形等是正确的，这里该怎么写，谢谢了

free(tmpQElemPcm.Pcm_data);//释放                 tmpQElemPcm.Pcm_data释放我应该写在什么位置

谢谢楼上两位指导

list_pcm.push_back(tmpQElemPcm);//list保存了tmpQElemPcm的引用 free(tmpQElemPcm.Pcm_data);//释放tmpQElemPcm的Pcm_data也就等于释放了list_pcm保存的tmpQElemPcm的引用的Pcm_data 所以 memcpy(s_outBuf, (*lit).Pcm_data, (*lit).bufflehead);//这里的(*lit).Pcm_data的内存因为已经在上面释放掉了，所以Pcm_data实际为野指针，它的内存信息是不确定的

你急匆匆就把内容内存给free掉了， 下面怎么好意思再用呢？  人家内存应该跟你说，离婚了就别再来找我。


Question: 各位大佬求助

引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen("mike"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, "mike");     FILE* fp = fopen("selfSu.txt", "wb");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen("selfSu.txt", "rb");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf("姓名：%s\t编号：%d\t名字长度：%d\n", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～ 引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen("mike"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, "mike");     FILE* fp = fopen("selfSu.txt", "wb");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen("selfSu.txt", "rb");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf("姓名：%s\t编号：%d\t名字长度：%d\n", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～ 引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen("mike"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, "mike");     FILE* fp = fopen("selfSu.txt", "wb");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen("selfSu.txt", "rb");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf("姓名：%s\t编号：%d\t名字长度：%d\n", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～   谢谢~

哦，名字也没有写进去。 题目需要你另外写名字，不能光写结构体。

显然你缺少了malloc，所以名字没地方放。

引用 1 楼 自信男孩 的回复:#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h>  typedef struct Student {     char *name; //名字     int id;     int name_len; //名字长度 }Stu;  int main0101() {     //写     Stu s;     s.id = 1;     s.name_len = strlen("mike"); //名字长度     s.name = (char*)malloc(s.name_len + 1);     strcpy(s.name, "mike");     FILE* fp = fopen("selfSu.txt", "wb");     if (!fp)         return -1;      fwrite(&s, sizeof(s), 1, fp);     fclose(fp);      return 0; }  int main() {     main0101();   //先写才能再读     //读     FILE* fp = fopen("selfSu.txt", "rb");     if (!fp)         return -1;     Stu s;      fread(&s, sizeof(Stu), 1, fp);      fclose(fp);      printf("姓名：%s\t编号：%d\t名字长度：%d\n", s.name, s.id, s.name_len);      free(s.name);      return 0; }  供参考～ 楼主这么定义结构体和读取很容易导致内存溢出～在main函数里释放了。


Question: 新手，错误提示none of the 2 overloads can convert parameter 1 from type 'float'是怎么回事ne

还 缺少头文件 敲错函数名 多余的返回值 两个差分函数的参数应为double数组 (int)那些行都是多余的 等

引用 6 楼 forever74 的回复:我不信，你看着办。谢谢啦

引用 7 楼 真相重于对错 的回复:函数的声明和定义与函数的调用不一致。比如 dchafen(lx[50], ca[50]); //调用 float dchafen(int t[], int v[])；//声明 参数是 数组，而你传给他一个整数，如何能够不出错？ 建议把c的语法学好 引用 7 楼 真相重于对错 的回复:函数的声明和定义与函数的调用不一致。比如 dchafen(lx[50], ca[50]); //调用 float dchafen(int t[], int v[])；//声明 参数是 数组，而你传给他一个整数，如何能够不出错？ 建议把c的语法学好这个是后面修改过的，谢谢提醒

我不信，你看着办。

引用 4 楼 forever74 的回复:还是不行是肯定的，问题是还出这个错误？嗯，还是这个问题

还是不行是肯定的，问题是还出这个错误？

引用 1 楼 forever74 的回复:把所有的float都换成double就不会出这个错误了。还是不行，是不是我的函数结构有问题呀

还是不行，是不是我这个函数结构有问题呀

把所有的float都换成double就不会出这个错误了。


Question: 请问为啥上面调用的是位置，下面掉用的是该函数呢

就是关于L的调用，L是一个线性表的数据结构的变量


Question: 【C语言】新手求教一些关于指针的问题，两指针变量相等的相关问题，求教大佬们

指针就是地址，地址就是指针；指针变量是一个变量，它保存了基本类型变量的地址。 如果指针变量p保存了变量a的地址，那么称作p指向了a，*p 就是变量a。 如果p是一个指针变量，*p 表示了以 p 的内容为地址的变量，就是p指向的变量。 举例如下：                     int a ;  //定义int类型变量                     int *p = &a;   //变量 p 是一个 int* 类型的一级指针变量，&是取地址符，p保存了a 的地址                     cout << *p <<endl; //输出 p 指向变量的值，即输出a的值                     cout <<  p << endl; //输出 p 的值，即输出变量a在内存中的地址                     int **q;  //定义二级指针变量                     q = &p; // 二级指针变量q保存了一级指针变量p的地址                     cout << q <<endl; //输出指针变量p在内存中的地址                     cout <<  *q << endl; //输出q指向变量的值，即变量p的值，即a的地址                     cout <<  **q << endl; //可以这样理解  cout<<*(*q), 等价于 cout <<*p， 即输出a的值

1 如果想让两个指针变量指向的地址相同，用q=p；如果想让两个指针变量指向的地址不同但地址存储的值相同，用*q=*p；为什么去掉q=&b会出错？因为指针变量要初始化指向一个有效的地址才能使用，所以没有q=&b，q就是个野指针 2 q=p，是让两个指针变量指向的同一个地址；*q=*p是让两个指针本来指向的地址的值相同。①p指向a的地址，q指向b的地址，*q=*p是让两个地址的值相同，所以b地址的值也变成了20；②b为啥变了？参考① 3 int *t = (int*)p是定义一个int*类型的指针变量t，并把p指向的地址转换为int*类型后赋给t；*(int*)p是把p指向的地址转换为int*，然后取出改地址的值，这样得到的值就是一个int类型


Question: SQL中如何把A表的字段数据更新到B表的字段

应该去到SQL论坛问吧。


Question: 求各位数字之后和反序数的代码

引用 4 楼 智者知已应修善业的回复:可以一气呵成的为何要写2个? 可能看起来简洁

可以一气呵成的为何要写2个?

//2 反序数 #include<stdio.h> int main() {     int n=0,res=0;     scanf("%d",&n);          while(n){          res = res*10 + n%10;          n /= 10;     }     printf("%d",res);      return 0; }

反序数 int main() {     int n=0, res=0;     scanf(“%d”, &n);     for(; n>0; n/=10)          res = res*10 + n%10;     printf(“%d”, res);     return 0; }


Question: c语言中结构体数组后加一个点一个变量是为什么

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

建议查一下结构体变量如何访问其元素，同事也看一下结构体指针变量如何访问结构体元素；  这是基本的语法知识，建议翻翻书或者网上搜一下

结构体就是一个可以包含不同数据类型的一个结构，它是一种可以自己定义的数据类型。number是成员变量，作用是数组的一个成员info[i]，可以用调用多个属性变量

啥叫结构体？


Question: 求助代码的含义

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。

理解和讨论之前请先学会如何观察！   VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898


Question: While 语句的一点问题

引用 楼主 玖歌star 的回复:while ((txt[next++=getchar())! ='\n'可以用大括号吗？谢谢先把语法错误改了 然后重新组织一下问题 你的[ 没有对应的]

引用 楼主 玖歌star 的回复:while ((txt[next++=getchar())! ='\n'可以用大括号吗？谢谢 写得也不合格式也不合逻辑!如果next是数值型怎么能赋值字符型?比较表达式也不对怎么能放在括号外?

用大括号，没明白楼主的意思，想要实现什么？在()中很少见到用{}大括号的

不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。


引用 7 楼 forever74的回复:题目指出，输入不知道多少个绝对值不超过1000的整数，因此上述代码均不符合题意，因为一旦第1024个才符合要求那就都无法完成任务。 1024？？？啥意思？？？

引用 8 楼 自信男孩的回复:[quote=引用 5 楼 maggielve 的回复:][quote=引用 2 楼 自信男孩的回复:]#include <stdio.h>  int main() {     int a[1000];     char buf[1024];     //int i = 1;      fgets(buf, sizeof(buf), stdin);       int i = 0, pos = 0, k = 0;     while (buf[i]) {         if (buf[i] == '\n' || buf[i] == 0 || buf[i] == ' ') {             if (buf[i]  == '\n' || buf[i] == 0)                 break;             sscanf(buf+pos, "%d", &a[k]);             printf("%d\n", a[k]);             k++;             pos = i+1;         }         i++;     }     buf[i] = 0;     sscanf(buf+pos, "%d", &a[k]);     k++;      /*     while( getchar() != '\n' )     {         scanf("%d",&a[i]);         i++;     }     */     for( int i = 0 ; i < k; i++ )         if( a[i] == 250 )         {             //printf("%d",i);             printf("%d",i+1);             break;         }     return 0; }  供参考～  这次我应该又把简单问题复杂度话了～  我严重怀疑你是在我面前装逼，我都看不懂你的代码写的是什么？[/quote]  既然看不懂，就当我没回复过，以后你的帖子我就bypass   #include<stdio.h> int main() {     int a,i;     i=0;     while(1)     {         scanf("%d",&a);         if(a==250)	break;         i++;     }     printf("%d\n",i+1);     return 0; }  网上的，比较简单。但是楼主比较懒～[/quote] 额，你用c语言基础知识写代码就行，我连指针还没学呢！

引用 5 楼 maggielve 的回复:[quote=引用 2 楼 自信男孩的回复:]#include <stdio.h>  int main() {     int a[1000];     char buf[1024];     //int i = 1;      fgets(buf, sizeof(buf), stdin);       int i = 0, pos = 0, k = 0;     while (buf[i]) {         if (buf[i] == '\n' || buf[i] == 0 || buf[i] == ' ') {             if (buf[i]  == '\n' || buf[i] == 0)                 break;             sscanf(buf+pos, "%d", &a[k]);             printf("%d\n", a[k]);             k++;             pos = i+1;         }         i++;     }     buf[i] = 0;     sscanf(buf+pos, "%d", &a[k]);     k++;      /*     while( getchar() != '\n' )     {         scanf("%d",&a[i]);         i++;     }     */     for( int i = 0 ; i < k; i++ )         if( a[i] == 250 )         {             //printf("%d",i);             printf("%d",i+1);             break;         }     return 0; }  供参考～  这次我应该又把简单问题复杂度话了～  我严重怀疑你是在我面前装逼，我都看不懂你的代码写的是什么？[/quote]  既然看不懂，就当我没回复过，以后你的帖子我就bypass   #include<stdio.h> int main() {     int a,i;     i=0;     while(1)     {         scanf("%d",&a);         if(a==250)	break;         i++;     }     printf("%d\n",i+1);     return 0; }  网上的，比较简单。但是楼主比较懒～

引用 3 楼 djmjxm的回复:为什么a[0]不符值呢 444，666，250，-590，     520是第三个数

引用 2 楼 自信男孩的回复:#include <stdio.h>  int main() {     int a[1000];     char buf[1024];     //int i = 1;      fgets(buf, sizeof(buf), stdin);       int i = 0, pos = 0, k = 0;     while (buf[i]) {         if (buf[i] == '\n' || buf[i] == 0 || buf[i] == ' ') {             if (buf[i]  == '\n' || buf[i] == 0)                 break;             sscanf(buf+pos, "%d", &a[k]);             printf("%d\n", a[k]);             k++;             pos = i+1;         }         i++;     }     buf[i] = 0;     sscanf(buf+pos, "%d", &a[k]);     k++;      /*     while( getchar() != '\n' )     {         scanf("%d",&a[i]);         i++;     }     */     for( int i = 0 ; i < k; i++ )         if( a[i] == 250 )         {             //printf("%d",i);             printf("%d",i+1);             break;         }     return 0; }  供参考～  这次我应该又把简单问题复杂度话了～  我严重怀疑你是在我面前装逼，我都看不懂你的代码写的是什么？

哈哈哈，你不要笑我了，好不好？

为什么a[0]不符值呢

供参考：#include "stdio.h" int main() { 	int a[1000]; 	int i = 1，j; 	while( getchar() != '\n' ) 	{ 		scanf("%d",&a[i]); 		i++; 	} 	for( j = 1;j<i; j++ ) 		if( a[j] == 250 ) 		{ 			printf("%d",j); 			break;	 		}  	return 0; }


Question: 新手实在是想不通为啥总会重定义

引用 1 楼 真相重于对错 的回复:头文件上加一句 #pragma once  试试 换成#pragma once就好了，谢谢！

引用 2 楼 qq_33487700 的回复:将  #ifndef #define  #endif  换为 #pragma once 换成#pragma once就可以了，谢谢！

引用 3 楼 forever74 的回复:[quote=引用 楼主 return_master 的回复:]我所有的头文件都用#ifndef/#define/#endif处理过了，但还是重定义。 如图，这个Bits64是我定义的联合体，只在这里定义过一次，其他地方都没出现过，为啥还是会重定义  你敲出来的内容准确度存疑。 图片上有个struct calsses就疑似错误。  所以建议你检查一下你的#ifndef后面的内容和#define后面是否真的一致。[/quote] 大佬眼力真好

引用 楼主 return_master 的回复:我所有的头文件都用#ifndef/#define/#endif处理过了，但还是重定义。 如图，这个Bits64是我定义的联合体，只在这里定义过一次，其他地方都没出现过，为啥还是会重定义  你敲出来的内容准确度存疑。 图片上有个struct calsses就疑似错误。  所以建议你检查一下你的#ifndef后面的内容和#define后面是否真的一致。

头文件上加一句 #pragma once  试试


Question: 打印*菱形

可参


Question: 持续写文件到ssd，会造成写入速度变慢

同意3楼和8楼

还有一个毛病就是你这种频繁写入的工作条件下，SSD的寿命比常规机械硬盘短得多。  所以如果数据量真的大，长久保存的还是用常规硬盘，追求性能的还是用RAMDISK。

引用 6 楼 baidu_35309186 的回复:引用 3 楼 早打大打打核战争 的回复:现在的SSD普遍使用TLC甚至QLC，芯片的实际写入性能是很低的（比机械硬盘还低），厂商吹嘘的性能指标实际是靠里面的SLC缓存带起来的，所以持续写入大量数据掉速是很正常的用的是kioxia的nvme ssd，我写demo把一个100M的文件重复写到里面去都不行，所以这是硬盘问题？无解了？  如果条件允许的话，你可以把SSD上的数据备份出来，然后作为数据盘（而不是系统盘）接到电脑上，格式化，用大文件将其写满，看总共用时，就能计算出它的实际写入性能了。

引用 2 楼 赵4老师 的回复:fopen第二个参数里有b吗？有的

引用 3 楼 早打大打打核战争 的回复:现在的SSD普遍使用TLC甚至QLC，芯片的实际写入性能是很低的（比机械硬盘还低），厂商吹嘘的性能指标实际是靠里面的SLC缓存带起来的，所以持续写入大量数据掉速是很正常的 学到了

fopen第二个参数里有b吗？

在同一个文件夹下，不要存放太多的文件！我们每次创建一个文件FATFS系统都要进行扫描有没有这个文件，没有就创建，随着新建文件的增多会导致扫描的时间变长，导致文件建立效率降低，时间变长。当然也可能有其他原因


Question: 看到一个结构体的练习，不太明白输出结果

因为++a[i].s[3]寻址发生了错误，去掉就可以 正常输出了 #include<stdio.h> struct s1 { 	 char* s; 	int i; 	struct s1* sip;  }; int main() { 	static s1 a[] = { { const_cast < char*>("abcd"),1,a + 1},{const_cast <char*>("efgh"),2,a + 2},{const_cast <char*>("ijk1"),3,a} }; 	int i; 	for (int i=0;i<2;i++) 	{ 		printf("%d\n", --a[i].i); 		printf("%c\n", a[i].s[3]); 	} 	return 0; }

先了解了a[i].i和a[i].s[3]是输出什么，然后明白了这个，就好理解前面加++还是--了。  自增和自减，分为前置和后置，优先级不一样，可以网上搜一下，学习一下；总要自己动手学吧，不能只会了这个问题，以后遇到稍微修改的问题不会了。

供参考：#include<stdio.h> struct s1 {    char* s;     int  i;   struct s1* sip; };  int main() {     static s1 a[] = { { const_cast < char*>("abcd"),1,a + 1},{const_cast <char*>("efgh"),2,a + 2},{const_cast <char*>("ijk1"),3,a} };     int i;     for (int i=0;i<2;i++)       {          printf("%d\n", --a[i].i);          printf("%c\n", ++a[i].s[3]);       }      return 0; }  //输出：对值的操作，不存在寻址的问题 //0   i=0: --a[i].i        a[0].i = 1         --a[0].i = 0 //e   i=0: ++a[i].s[3]     a[0].s[3] = 'd'   ++a[0].s[3] = 'e'  //1   i=1: --a[i].i        a[1].i = 2        --a[1].i = 1 //i   i=1: ++a[i].s[3]     a[1].s[3] = 'h'   ++a[1].s[3] = 'i'


Question: 求教 是哪里出问题了

引用 1 楼 user-1 的回复：看不懂日语，只能从语法错误修改下，供参考：#include<stdio.h> #include<stdlib.h> #include<time.h>  int main(void) {     int retry = 0;     int card;        //这里已经定义了card     srand(time(NULL));     card = rand() % 13 + 1;//int card = rand() % 13 + 1;     printf("card = %d\n", card);          if (card > 21){         switch (card) {                if (card == 1) {  //这里这条件永远不会满足                printf("あなたの勝ち\n");                break;                }                else {                      printf("あなたの負け\n");                      break;                }         }     }     printf("もう一度カードを引くか確認\n");     printf("retryを入力してください。\n");      scanf("%d", &retry);//scanf_s("%d", &retry);     switch (retry){            if (retry == 0) {                break;            }     }while(retry);//while (card);//?这里就死循环了      return 0; }我私信你了 老哥


Question: 十进制小数的整数部分，肯定能转成二进制，这个也没错把？

引用 3 楼 qybao 的回复:整数部分，单纯的转换为二进制是可以的，但加上小数部分，再结合浮点数的内存存储，那就未必了，因为有精度限制。 谢谢，我问的是，小数的整数部分，应该能转成十进制的吧？也即是整数部分和十进制能一一对应起来？ 仅仅是小数部分不同？

浮点数是有精度的，并不一定能精确地转成二进制。例如： int main(void) { 	float a = 123456789.0f; 	std::cout << std::fixed << a << std::endl; } 打印结果是：123456792.000000 你看，整数部分转换后的结果就不对了。

恩，没错，是可以用二进制表示的。确切的说都可以用二进制表示和存储的。因为计算机只认识二进制0和1，不认别的，所以说计算机认识并计算的都是可以用0和1标识的。


Question: 请教二进制小数肯定能转成十进制小数，这个没错把？

引用 3 楼 oracleperl 的回复:[quote=引用 2 楼 qybao 的回复:]是没错，但是计算机未必能精确把十进制小数表示出来。  我说的是二进制小数，肯定能转成十进制小数，这个没错把？ 比如 .11就是十进制的0.75 .10就是十进制的0.5 .01就是十进制的0.25[/quote] 这个是没错，但转成十进制小数后，它并没有脱离计算机，它并没有实质的脱离计算机中二进制的记录方式，它仍然是保存在计算机中的，这就和保存它的标准、存储方式相关，就会存在误差，建议楼主参考这篇博文：https://www.jianshu.com/p/8ee02e9bb57d

引用 2 楼 qybao 的回复:是没错，但是计算机未必能精确把十进制小数表示出来。  我说的是二进制小数，肯定能转成十进制小数，这个没错把？ 比如 .11就是十进制的0.75 .10就是十进制的0.5 .01就是十进制的0.25

二进制小数肯定能转成十进制小数，这个没错； 但用32位或64位保存的二进制小数，不一定都能表示成包含15位有效数字的十进制小数。

不考虑 无限循环小数 无限不循环小数之类的情况 是的

是没错，但是计算机未必能精确把十进制小数表示出来。

引用 4 楼 qzjhjxj 的回复:[quote=引用 3 楼 oracleperl 的回复:][quote=引用 2 楼 qybao 的回复:]是没错，但是计算机未必能精确把十进制小数表示出来。  我说的是二进制小数，肯定能转成十进制小数，这个没错把？ 比如 .11就是十进制的0.75 .10就是十进制的0.5 .01就是十进制的0.25[/quote] 这个是没错，但转成十进制小数后，它并没有脱离计算机，它并没有实质的脱离计算机中二进制的记录方式，它仍然是保存在计算机中的，这就和保存它的标准、存储方式相关，就会存在误差，建议楼主参考这篇博文：https://www.jianshu.com/p/8ee02e9bb57d[/quote] 谢谢老师： 二进制的0.125  0.5 0.75转成十进制小数，怎么会有误差呢？用0和1都能表示的啊 你的这篇文章，图片不能显示的

理论上是没错的。我想你的为不在这里，而在二进制口算的是多少，但是实际上对应的十进制不是。  建议楼主查一下浮点数在内存里的表示。网上是有的，建议好好查查，仔细看一些别人文章的介绍，书本上也是有的，浮点数的表示比较复杂，不能按照 整型数的去理解～


Question: 各位大佬，vscode不能识别头文件，如何设置才会识别呢？


Question: 请教如何保证两个十进制的float数值相加相减等，肯定能得到正确的结果？谢谢

引用 2 楼 oracleperl 的回复:[quote=引用 1 楼 早打大打打核战争 的回复:]你得先定义“正确”，比如精确到小数点后多少位 比如两位？如何做到？[/quote]  最简单的方法，使用定点小数运算，比如需要精确到小数点后两位，可以把浮点数放大1000倍，转化为整数再运算，最终结果再转化回去就可以了。早期计算机是不支持浮点运算的，涉及到小数的计算，通常都会使用定点小数格式，因为这种格式以整数方式存储小数，隐含有一个固定的小数点位置，所以称之为定点小数。现代的一些软件，为了保证小数运算的精度，比如VB、.net、Delphi中的currency类型，仍然使用定点小数格式。 另一个方法，使用intel DFP，十进制浮点库，这个库实现了IEEE754-2008定义的十进制浮点类型运算，可以免费使用：https://software.intel.com/content/www/us/en/develop/articles/intel-decimal-floating-point-math-library.html

实际应用中的定点小数，比如VB、.net、Delphi中的currency类型，是放大10000倍存储为整数，固定四位小数，可以保证三位小数的运算精度，参考：https://docs.microsoft.com/en-us/office/vba/language/reference/user-interface-help/currency-data-type

引用 7 楼 oracleperl 的回复:[quote=引用 6 楼 早打大打打核战争 的回复:]定点小数存储为整数，不遵循IEEE754的标准，比如12345.6789，固定四位小数，存储为整数123456789 嗯，我可以理解，小数也当作整数 但是比如工资系统，两位小数，乘以100存储为整数，但是最终还是要除以100的啊，这么一除，不就有不对了？[/quote]  你要精确到小数点后两位，就要存储三位小数

引用 6 楼 早打大打打核战争 的回复:定点小数存储为整数，不遵循IEEE754的标准，比如12345.6789，固定四位小数，存储为整数123456789 嗯，我可以理解，小数也当作整数 但是比如工资系统，两位小数，乘以100存储为整数，但是最终还是要除以100的啊，这么一除，不就有不对了？

引用 4 楼 早打大打打核战争 的回复:[quote=引用 2 楼 oracleperl 的回复:][quote=引用 1 楼 早打大打打核战争 的回复:]你得先定义“正确”，比如精确到小数点后多少位 比如两位？如何做到？[/quote]  最简单的方法，使用定点小数运算，比如需要精确到小数点后两位，可以把浮点数放大1000倍，转化为整数再运算，最终结果再转化回去就可以了。早期计算机是不支持浮点运算的，涉及到小数的计算，通常都会使用定点小数格式，因为这种格式以整数方式存储小数，隐含有一个固定的小数点位置，所以称之为定点小数。现代的一些软件，为了保证小数运算的精度，比如VB、.net、Delphi中的currency类型，仍然使用定点小数格式。 另一个方法，使用intel DFP，十进制浮点库，这个库实现了IEEE754-2008定义的十进制浮点类型运算，可以免费使用：https://software.intel.com/content/www/us/en/develop/articles/intel-decimal-floating-point-math-library.html [/quote] 谢谢，我先把原理学习清楚，目前知道了，根据IEEE754标准 1. 只有以5结尾的小数，才能二进制和十进制互转，不会有精度问题 2. 二进制小数肯定可以分毫不差转成十进制，但是十进制小数只有以5结尾的小数才能分毫不差转成二进制  另外对于你说的定点数，我不是很理解，再怎么顶点，不也是小数吗？难道不遵循IEEE754的标准吗？ 谢谢

浮点数都是有精度的，别说保证运算后的结果“正确”了。你就是单定义一个float变量，它的值都不一定“正确”。 int main(void) { 	float a = 123456789.0f; 	std::cout << std::fixed << a << std::endl; } 这段代码运行一下试试看。

引用 1 楼 早打大打打核战争 的回复:你得先定义“正确”，比如精确到小数点后多少位 比如两位？如何做到？

你得先定义“正确”，比如精确到小数点后多少位


Question: 请教，变量名储存在哪里？

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

引用 7 楼 赵4老师 的回复:[quote=引用 5 楼 qq_16774199 的回复:][quote=引用 4 楼 user-3的回复:]a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1 你好。这是逼着我学汇编呢[/quote] 看来你快开窍了。 [/quote]  我已经把java基础知识过了一遍，最近又把学习C语言的事抱起来，原因就是想弄懂内存的事。 仅仅为了弄懂内存去学汇编，时间成本太高。坐飞机两千公里到兰州，就为了吃正宗的兰州拉面，多数人是不会。

引用 7 楼 赵4老师 的回复:[quote=引用 5 楼 qq_16774199 的回复:][quote=引用 4 楼 user-3的回复:]a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1 你好。这是逼着我学汇编呢[/quote] 看来你快开窍了。  [/quote]  你说得都很有道理，不想学汇编的原因是，它也要花费时间，每个人时间都很宝贵。 另外，用汇编把内存学明白了，可是它对写好安卓APP有帮助吗？

局部变量储存在函数栈里。   全局变量和静态变量存放在数据段  还有堆，是动态申请的空间存放在堆上～

引用 4 楼 user-3的回复:a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1 你好。这是逼着我学汇编呢

obj文件也应该算

纠正楼上 pdf文件  →  pdb文件

变量名存在于 源代码 编译器 pdf文件 …… 中


Question: 请问float值是如何表示的？(1 bit)  指数(8 bits)  尾数(23 bits) 小数点在哪里？

引用 10 楼 qybao 的回复:那是人类存储的思维，但计算机的思维不一样，计算机就变成1.0*10^-2，存1.0和指数-2，明白了吗？如果是0.05就是5.0*10^-2，也就是整数部分必须大于0，这是计算机的规则（除非你发明另一种不按规则出牌的计算机）。 上面举的例子是10进制的，如果是2进制，只有0和1，按照整数大于0的规则就注定了整数只能是1，所以尾数的第一位肯定是1就是这么来的。 我要保存一个0.00 何来1?

看错了，你是说存0.00，我还以为是0.01 0是特殊值，浮点数有单独的定义 也就是说计算机的浮点存储，有针对0专门做了相应的规则 具体可以参考下 https://zh.wikipedia.org/wiki/IEEE_754

引用 11 楼 oracleperl 的回复:我要保存一个0.00 何来1? 你要谁来保存，你自己保存可以用0.01，但是计算机帮你保存就不是这样了，就会转成符合计算机的格式来保存 就好想你要保存一个汉子“问”，你认为计算是直接保存“问”这个字吗？如果是这样，那就不会有不同国家的编码问题了。 所以，你想存，和计算机能存，是两码是，就好比人家做不了的是，你还能逼着人家做吗？你要想让人家做好，你就要遵守人家的规则，否则人家就是给你做错。

浮点数的0只有符号位是0或者1，其余全0

引用 5 楼 qybao 的回复:[quote=引用 4 楼 oracleperl 的回复:] “浮点数存储格式” 举个例子？ 我只知道浮点数float 32bits构成 ，如下： 符号(1 bit)  指数(8 bits)  尾数(23 bits)  实在不知道小数点在哪，也不知道指数(8 bits)是如何表示的，每一位分别啥意思 参考一下吧 https://www.jianshu.com/p/8ee02e9bb57d [/quote] 谢谢，图不能显示

引用 8 楼 qybao 的回复:看了一些资料， 所有的浮点数，都是1.XXXXXX * 2的N次方的形式 而浮点数的小数位数，是指数的值决定的？ =》不是，因为这是二进制形式，要转成10进制才知道小数位数  大致好像是这样，但是没完全看懂，好像有四种规则，位数的第一位肯定是1？这些我都不理解。 《深入理解计算机系统》的有关于这方面的说明，但是没有例子，文字也很难懂，看不懂。 =》尾数第一位是1，这是默认规则，因为不允许0.xxxx以0开头的小数的方式（类似于十进制的科学计数法，整数大于0小于10），因为二进制只有0和1，又因为规定第一位不能位0，所以第一位只能是1，为了省存储空间，就可以把第一位省略掉（因为第一位必然是1）  没看懂，那我存储小数 0.01，难道第一位不是0吗？

看了一些资料， 所有的浮点数，都是1.XXXXXX * 2的N次方的形式 而浮点数的小数位数，是指数的值决定的？  大致好像是这样，但是没完全看懂，好像有四种规则，位数的第一位肯定是1？这些我都不理解。 《深入理解计算机系统》的有关于这方面的说明，但是没有例子，文字也很难懂，看不懂。

引用 4 楼 oracleperl 的回复:“浮点数存储格式” 举个例子？ 我只知道浮点数float 32bits构成 ，如下： 符号(1 bit)  指数(8 bits)  尾数(23 bits)  实在不知道小数点在哪，也不知道指数(8 bits)是如何表示的，每一位分别啥意思 参考一下吧 https://www.jianshu.com/p/8ee02e9bb57d

引用 2 楼 qybao 的回复:按照浮点数存储格式把数算出来就知道小数点在哪了 “浮点数存储格式” 举个例子？ 我只知道浮点数float 32bits构成 ，如下： 符号(1 bit)  指数(8 bits)  尾数(23 bits)  实在不知道小数点在哪，也不知道指数(8 bits)是如何表示的，每一位分别啥意思

引用 1 楼 赵4老师 的回复:浮点数格式 http://bbs.csdn.net/topics/390676437 看不懂

按照浮点数存储格式把数算出来就知道小数点在哪了


Question: 请教这句代码的意思

楼上正解！同时满足不是字符Y和字符N的情况下才执行 WEONG

判断ch是否为'y'和'n'，即如果不是'y'同时不是'n'，则执行WRONG();函数


Question: 谁先倒

参考下这篇博客：https://blog.csdn.net/21aspnet/article/details/174326

为什么加上\n，就不对了呢？

第12行多打了  \n   scanf("%d %d %d %d",&a[i],&b[i],&c[i],&d[i]);


Question: 在校内oj系统中，老是出现Presentation Error,有懂的哥帮忙看下

引用 10 楼 h2plus0 的回复:这道题可能是不是要处理一种特殊情况， 就是当最大值的idx是0的时候，那时交换要判断一下 ，分别处理  。。。。 temp = a[0];     a[0] = a[min];     a[min] = temp;  // ----------------------------------- 加上这段     if(max==0) {     	max = min;     } //----------------------------------      temp = a[n - 1];     a[n - 1] = a[max];     a[max] = temp; 。。。。。。。牛逼！ 这回通过了，谢了哥！

引用 7 楼 自信男孩 的回复:#include <stdio.h> #include<stdlib.h>    int main() {     int n, j = 1;     int max, min, temp;     int *a = NULL;      scanf("%d", &n);     //int *a = (int *)malloc(sizeof(int)*n);     a = (int *)malloc(sizeof(int)*n);     for (int i = 0; i < n; i++) {         scanf("%d", &a[i]);     }     min = max = 0;     while (j < n) {         if (a[j] > a[max])             max = j;         if (a[j] < a[min])             min = j;         j++;     }     temp = a[0];     a[0] = a[min];     a[min] = temp;     temp = a[n - 1];     a[n - 1] = a[max];     a[max] = temp;     for (j = 0; j< n - 1; j++)         printf("%d ", a[j]);     printf("%d\n", a[n - 1]);   //这里/n我加没加也都是通过不了     free(a);     return 0; } 再试一下，怀疑你提交的服务器的编译问题，编译不通过；不会吧，要是最后输出不做最后一个元素特殊处理，就都是元素+空格的话题是PE错误，就应该大致都是对的。之前有个问题我也是PE错误，就是最后空格多出来一个，不过这题就邪门了

引用 6 楼 user-3 的回复:这样改下，再试试：#include <stdio.h> #include<stdlib.h>  int main() { 	int n,j; 	int max,min,temp; 	scanf("%d", &n); 	int *a = (int *)malloc(sizeof(int)*n); 	for ( j = 0; j < n; j++) { 		scanf("%d", &a[j]); 	} 	min=max =0;         j=1; 	while (j < n) { 		if (a[j] > a[max]) 			max = j; 		if (a[j] < a[min]) 			min = j; 		j++; 	} 	temp = a[0]; 	a[0] = a[min]; 	a[min] = temp; 	temp = a[n - 1]; 	a[n - 1] = a[max]; 	a[max] = temp;  	for ( j = 0; j < n ; j++){             if(j==0) 		printf("%d", a[j]);             else printf(" %d", a[j]);         }         free(a); 	return 0; }不行还是通不过

引用 3 楼 user-3 的回复:上面多打了z，修改： for(int i = 0;i < n; i++)             printf("%d%c",a[i],(i<n-1)?' ':'\n');  还是不行，通过不了，我快吐了

引用 1 楼 自信男孩 的回复:代码没问题，注意在最后加一句free(a);//释放空间  有问题的地方可能是你的编译器或者服务器上的编译器是C语言的，像 for (int i = 0; i < n-1; i++)这样的在for循环里面定义局部变量的，一般的C语言编译器不支持，是C++的特性。  鉴于上面已经定义了j，后面的循环都可以用j作为循环变量。不行啊哥！还是Wrong Answer#include <stdio.h> #include<stdlib.h>   int main() { 	int n, j = 1; 	int max, min, temp; 	scanf("%d", &n); 	int *a = (int *)malloc(sizeof(int)*n); 	for (int i = 0; i < n; i++) { 		scanf("%d", &a[i]); 	} 	min = max = 0; 	while (j < n) { 		if (a[j] > a[max]) 			max = j; 		if (a[j] < a[min]) 			min = j; 		j++; 	} 	temp = a[0]; 	a[0] = a[min]; 	a[min] = temp; 	temp = a[n - 1]; 	a[n - 1] = a[max]; 	a[max] = temp; 	for (j = 0; j< n - 1; j++) 		printf("%d ", a[j]); 	printf("%d\n", a[n - 1]);   //这里/n我加没加也都是通过不了 	free(a); 	return 0; }

最后输出修改试试：for(int i = 0;i < n; i++)             printf("%d%c",a[i],(i<n-1)?'z':'\n');


Question: 如何把一个变量和一个指针连起来？

#include <stdio.h> #include <stdlib.h> #include <malloc.h> int main() {     int **point;     int *pb;     int a=1,c=3;     point = (int**)malloc(3 * sizeof(int*));     point[0] = &a;     pb=(int *)malloc(1*sizeof(int));     *pb=2;     point[1] = pb;     point[2] = &c;     printf("%d, %d, %d\n", *point[0], *point[1], *point[2]);//1, 2, 3     free(pb);     free(point);     return 0; }  A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价

这样point实际变成了一个一维数组，如果要与a连接，只能 *(point+0)=a=1;或者point[0]=a=1;

本来应该是point=&a就可以了，但是你又给point动态分配内存了，改了point指向，后面就没法正确释放point的内存了。


Question: 关于宏定义问题

老赵你应该先看帖，楼主开篇都说了“如果改变输出到文件再加载进来太麻烦了”，他的要求是输出存到变量中，尽可能简单

本来输出到控制台的数据，我想保存到内存变量中如std::string，但现在大量的printf,puts，改代码太麻烦了，我想找一个简便的方法

恩，放到一个环形缓存里？

引用 5 楼 早打大打打核战争 的回复:[quote=引用 4 楼 赵4老师 的回复:]管道重定向可以满足你的需求。  这样太繁琐了，我那样写输出s到文件或者显示即可，其他不需要做任何修改 [/quote] 我是说在执行你原来程序的bat或sh脚本中添加命令行参数比如 1>>mem 2>>mem 其中mem是你自己写的从标准输入读，写到你想放的内存中的一小段程序。  这样做的话，你原来程序连一个字都不用动。  明白吗？

引用 4 楼 赵4老师 的回复:管道重定向可以满足你的需求。  这样太繁琐了，我那样写输出s到文件或者显示即可，其他不需要做任何修改

管道重定向可以满足你的需求。

只需要在第一个putc之前定义： std::string s; #define putc(c, f) s.insert(s.end(), c) 然后putc输出就到s中了


Question: C语言

2楼的代码是错的 没参考价值 别学  	return ((年 > 400 ? --年 -= 年 / 400 * 400 : 年) ? 365 * 年 + ((年 / 4) - (年 / 100) + (年 / 400)) : 0); 这句话属于自作聪明  --年 -= 年 / 400 * 400 是UB 糟糕的做法  不同编译环境对这个表达式的处理不同

用计算月的日期试看


Question: illegal use of this type as an expression，下面的代码没问题，就是编译不通过

非常感谢，这个问题我搞了很久没解决，现在可以了

https://blog.csdn.net/fzubbsc/article/details/29354959    #include<stdio.h> #include <stdlib.h> #define N 5  typedef int ElementType;  typedef struct Node {     ElementType data;     struct Node *next; }Node; typedef struct Node* LinkList;  /*===============================================================   CreateLinkList函数功能：   创建链表L, 并将给定数组a, 以及数组中元素个数n，头插入法建立链表   ===================================================================*/ void createlist(LinkList *L,int n,int a[]) {     LinkList p;     int i;      (*L)=(LinkList)malloc(sizeof(Node));  // 建立头结点     (*L)->next=NULL;   // 建立空的单链表(*L)      for(i=0;i<n;i++)     {         p=(LinkList)malloc(sizeof(Node));  // 生成新结点         p->data=a[i];         p->next=(*L)->next;         (*L)->next=p;     } }  /*===============================================================   Outputlist函数功能：   依次输出链表L中的每个数据   ===================================================================*/ void Outputlist(LinkList L) {     LinkList p;     p=L->next;    // 使p指向单链表的第一个结点     printf("数组a中的元素为：");     while(p!=NULL)     {         printf("%d ",p->data);         p=p->next;     } }   int main() {     int A[N];     int i;     LinkList pi;    //定义放在这里试试       for(i=0;i<N;i++)     {         scanf("%d",&A[i]);     }      //LinkList q;      createlist(&pi,N,A);     Outputlist(pi);      return 0; }  供参考～


Question: 求救

Pv Ps 两个值传入是否正常？

if(TIM_GetITStatus(TIM4,TIM_IT_Update)==SET)  {	 	static  u8 tsec;  	c10ms++; 	if(tsec++>=10) 		{ 	tsec=0; 		Encoder_TIM=ABS(32768-TIM3 -> CNT);    printf(" %d ",  Encoder_TIM/30); 			printf(" %3.1f", pwm   ); 			      TIM3 -> CNT=32768; 	     	}		TIM_ClearITPendingBit(TIM4, TIM_IT_Update );  	 }  }这呢

c10ms=0;了以后就一直跳过这个最大的if了。 除非另有代码修改它。


Question: C语言小白求助！这道题c为什么等于0不等于1？

引用 3 楼 自信男孩的回复:还是那个短路取值的问题，建议楼主学习一下||和&&； 谢谢指导我现在明白了！

++a的结果是1，条件成立，所以||后面的处理被忽略

还是那个短路取值的问题，建议楼主学习一下||和&&；

你的成绩： 免试给满分 或者 （试卷及格 并且 实验及格）  难道你还关注一下实验步骤？ 或许你爱学习，你会，但计算机不会。

从左向右执行，++a，先加后判断，a已经等于1了，又因为是||符号，后面的就不执行了，所以c也是0


Question: 7-76 然后是几点 (20分)

引用 9 楼 user-3的回复:这种还是把时间化成0点起分钟数，加减分钟数，再化回去比较简单。 还可以吧，我的代码不算太复杂，

引用 8 楼 user-3的回复:[quote=引用 6 楼 maggielve 的回复:][quote=引用 4 楼 user-3的回复:]好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间[/quote]  喏， 1010，十点十分 -110= -1小时，-50分钟 该是是820啊，哪里不是同一天了？[/quote] 就算这样，我的代码也对啊？

引用 10 楼 maggielve 的回复:[quote=引用 8 楼 user-3的回复:][quote=引用 6 楼 maggielve 的回复:][quote=引用 4 楼 user-3的回复:]好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间[/quote]  喏， 1010，十点十分 -110= -1小时，-50分钟 该是是820啊，哪里不是同一天了？[/quote] 就算这样，我的代码也对啊？[/quote] 楼主的代码还是有问题的，不然不会三个测试点只通过了一个。 输入2359  001 ,应该得到 000 或2400 ，楼主的代码结果是2360 。 输入900   -1 ，应该是859 ，楼主的代码结果是899。

引用 5 楼 maggielve 的回复:[quote=引用 3 楼 自信男孩的回复:]#include <stdio.h> #include <stdlib.h>  int main() {     int num1, num2, sign = 0;     scanf("%d %d",&num1,&num2);      int h = num1/100;     int m = num1%100;      if (num2 < 0) {         sign = 1;         num2 = abs(num2);     }     int h1 = num2/60;     //int m1 = num2 - h1*60;     int m1 = num2 % 60;       if (sign) {         if (m - m1 < 0) {             m = m + 60 - m1;             h1 += 1;         } else {             m -= m1;         }          if (h - h1 < 0)             h = h + 24 - h1;         else             h = h - h1;     } else {         if (m + m1 > 60) {             h =  (h + h1 + 1) % 24;             m = (m + m1) % 60;         } else {             m = (m + m1) % 60;             h = (h + h1) % 24;         }     }      if( h*100+m >= 0 && h*100+m < 100 )         printf("%03d",h*100+m);     else         printf("%d",h*100+m);       /*     h += h1;     m += m1;     if( m > 60 )     {         h++;         m -= 60;     }     if( h*100+m >= 0 && h*100+m < 100 )         printf("%03d",h*100+m);     else         printf("%d",h*100+m);     */     return 0; } 供参考～ 你又成功的把这一道简单题给弄麻烦了[/quote]  看来我不止一次把简单问题搞复杂了。我记性不好，要不一一罗列一下，至少大于2个吧

这种还是把时间化成0点起分钟数，加减分钟数，再化回去比较简单。

引用 6 楼 maggielve 的回复:[quote=引用 4 楼 user-3的回复:]好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间[/quote]  喏， 1010，十点十分 -110= -1小时，-50分钟 该是是820啊，哪里不是同一天了？

供参考：#include "stdio.h" int main(int argc, char* argv[]) {  	int num1, num2; 	scanf("%d %d",&num1,&num2); 	 	int h  = num1/100; 	int m  = num1%100; 	int h1 = num2/60; 	int m1 = num2%60;    //num2 - h1*60;  	h += h1; 	m += m1;         if(m<0){                 h--;                 m += 60;         } 	if( m > 59 ){        //if( m > 60 ) 		h++; 		m -= 60; 	}         if(h<0)  h += 24;   //超过一天的处理         if(h>=24)h -= 24; 	if( h*100+m >= 0 && h*100+m < 100 ) 		printf("%03d",h*100+m); 	else 		printf("%d",h*100+m);  	return 0; }

引用 4 楼 user-3的回复:好吧， num2若是负的，大概率m1就是负的； m+=m1;以后，m是负的咋办？ 起始时间和流逝的时间是同一天的时间

引用 3 楼 自信男孩的回复:#include <stdio.h> #include <stdlib.h>  int main() {     int num1, num2, sign = 0;     scanf("%d %d",&num1,&num2);      int h = num1/100;     int m = num1%100;      if (num2 < 0) {         sign = 1;         num2 = abs(num2);     }     int h1 = num2/60;     //int m1 = num2 - h1*60;     int m1 = num2 % 60;       if (sign) {         if (m - m1 < 0) {             m = m + 60 - m1;             h1 += 1;         } else {             m -= m1;         }          if (h - h1 < 0)             h = h + 24 - h1;         else             h = h - h1;     } else {         if (m + m1 > 60) {             h =  (h + h1 + 1) % 24;             m = (m + m1) % 60;         } else {             m = (m + m1) % 60;             h = (h + h1) % 24;         }     }      if( h*100+m >= 0 && h*100+m < 100 )         printf("%03d",h*100+m);     else         printf("%d",h*100+m);       /*     h += h1;     m += m1;     if( m > 60 )     {         h++;         m -= 60;     }     if( h*100+m >= 0 && h*100+m < 100 )         printf("%03d",h*100+m);     else         printf("%d",h*100+m);     */     return 0; } 供参考～ 你又成功的把这一道简单题给弄麻烦了

我考虑了啊？

题目里说，流逝的分钟数有可能是负值，楼主你似乎没有考虑。


Question: C语言小白求助！请问这道题怎么理解？

c的结果是真假，0为假，1为真。  注意||，如果||左边的表达式为真，||后面的表达式不会执行；因此叫做短路取值；  所以b = 2不会执行，所以b=5不变。

我们知道，把整数理解为逻辑值时，非零为真，零为假； 反之把逻辑值用作整数时，真值为1，假值为0； 逻辑运算符 && 和 || 在左操作数能确定运算结果时会短路跳过右操作数。


Question: 求帮助，初学C语言输入三个数没反应，输入十个数时，直接结束

学习了，小白路过

main前面要有int scanf里面不要有\n

重发一遍：…… #include <stdio.h>  int main(void) { int a, b, n;  printf("输入三个数：\n"); scanf("%d %d %d", &a, &b, &n); if(n >= 0) {      if(a > b)      printf("%d", a); } else printf("%d", b);  return 0; }

1、旧版本的C语言写法是main()，现在新规范写法是int main(void)，不过可能在老编译器上无法运行。 2、scanf()里面不要加\n。在scanf()里面加\n意思不是代表回车，而是表示忽略所有的空白符(制表 空格 回车)。你加了\n，所以回车的时候会被忽略，不能进入下一个语句。 改后版本： #include <stdio.h>  int main(void) { 	int a, b, n;  	printf("输入三个数：\n"); 	scanf("%d %d %d\n", &a, &b, &n); 	if(n >= 0) 	{     		if(a > b) 	    	printf("%d", a); 	} 	else 	printf("%d", b);  return 0; }

int   main（）

if(n >= 0)      if(a > b)      printf("%d", a);      else      printf("%d", b); 直接这样就行了，不应该在第一个if后面加{}

scanf("%d%d%d", …)试试看。

#include <stdio.h> int main ( ) {     int a,b,n;     printf("输入三个数\n");     //scanf("%d %d %d\n",&a,&b,&n);     scanf("%d %d %d",&a, &b, &n);     if (n>=0)     {         if(a>b)             printf("%d",a);         else             printf("%d", b);     }      return 0; }  供参考～

挺不错的啊挺不错的啊


Question: 数据结构（c语言）

引用 2 楼 自信男孩的回复:f1函数是创建一个节点，赋值一个string给在node，并连接到list中。 如果v给的是一个null，则返回失败。 谢谢啦(((*°▽°*)八(*°▽°*)))♪

引用 楼主 喝着奶茶敲实验的回复:啊怎么写哇 第一问   函数 f1（）是做什么的？ 第二问 什么可能的情况使代码运行失败？


Question: 求助

MSDN上提到，scanf()函数的返回值 Returns the number of fields successfully converted and assigned; A return value of 0 indicates that no fields were assigned. 意思大概就是当通过scanf()函数成功读取数据后，该函数的返回值是读取数据的变量的个数；如果未能成功读取数据，则该函数的返回值是0。 所以，要结束while()虚幻，只需要输入非数字即可。VS2015 C++环境调试  当输入2按下回车后，scanf()函数返回值是1，所以会运行while中的语句；之后输入a按下回车，此时scanf()函数返回值是0，结束while循环，执行之后的代码，完成输出。

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.

引用 5 楼 forever74 的回复:代码里%d后面有空格，你输入的时候2和回车中间也该加空格。跟空格没关系，格式化输入会自动将空格忽略，只有非空格字符才会严格按转换批示字符串匹配。

你代写得有问题，本来就不应该有输出的。你一直输入数字然后回车，程序会一直在while(scanf("%d",&a)==1)中循环的，除非你输入非法的字符才会结束循环。

供参考：https://blog.csdn.net/21aspnet/article/details/174326 建议改为如下形式：while(scanf("%d",&a),a){//输入0时结束输入

代码里%d后面有空格，你输入的时候2和回车中间也该加空格。

引用 1 楼 自信男孩 的回复：回车符是将输入缓存的内容刷到内存，如果输入缓存里没有内容，那么如何刷到内存？程序在下面，我输入的是2 加回车但是没输出

#include<iostream> #include<cstdio> using namespace std; long long a,s,i,w; int main() { 	while(scanf("%d ",&a)==1) { 		s+=a; 		i++; 	} 	w=1; 	for(int j=1; j<i; j++) 		w*=2; 	cout<<s*w;  	    return 0; }

回车符是将输入缓存的内容刷到内存，如果输入缓存里没有内容，那么如何刷到内存？


Question: 求助

只有一个if呀 还有else和for咋搞

#include<stdio.h> void menu() {     printf("********************************************************\n");     printf("**********************加減乗除電卓**********************\n");     printf("*選択した計算方法 1~4 を入力し、Enterを押してください。*\n");     printf(" 1.+ \n");     printf(" 2.- \n");     printf(" 3.* \n");     printf(" 4./ \n");     printf("********************************************************\n"); } int main(void) {     int i = 0;     int j = 0;     int num = 0;     int select = 0;     do     {         menu();         //scanf_s("%d", &select);         scanf("%d", &select);         printf("1つ数字を入力し、Enterを押してください。2回繰り返すことが必要です。");          //scanf_s("%d%d", &i, &j);         scanf("%d%d", &i, &j);         switch (select)         {             case 1:                 printf("%d+%d=%d\n", i, j, num = i + j);                 break;             case 2:                 printf("%d-%d=%d\n", i, j, num = i - j);                 break;             case 3:                 printf("%d*%d=%d\n", i, j, num = i * j);                 break;             case 4:                 if (j == 0) {                     printf("Input error!\n");                     break;                 }                  printf("%d/%d=%d\n", i, j, num = i / j);                 break;             default:                 printf("入力ミスは、再入力してください。");                 break;         }     } while (select);     return 0; } 供参考～  注意当做除法时，j ！= 0

不必要全都要用到(最近老打错别字什么的，心好累)

if~else和switch都是选择分支结构，for和while都是循环结构，break这里用应该是退出循环。你应该是要写一个四则运算的程序吧？两种结构里面选其中之一任意搭配就可以了吧，不必要全年都要用到


Question: 请教为什么printf("result is=%f\n",1234567.1);返回的是1234567.125 ？

换成%.1f就是输出一位小数了。同理%.3f就是输出3位小数

.125就是八分之一。说明浮点指数截断后，最后一个阶是二的负三次幂。

……人家跟你说得清清楚楚，你在这里质疑计算机有什么用？  不得不说在我看来你在钻牛角尖。明明自己去学习并实践一下浮点数的十进制如何转二进制就能明白的，建议再去研究一下计算机组成原理，真的明白原理后，我想你的计算机无用论会不攻自破。  另外，我想说计算机不是万能的，他能帮我们提高效率，但是你如果真的想得到特别特别准确，甚至说绝对准确的数据是不可能的。而且现实生活中也不是需要绝对准确的数据，对数据的要求都是在一个可接受的误差范围内，这也是学计算机要学习数值计算方法的原因。绝大多数情况下，我们需要的是满足误差范围的数据。

这种应该算误差吧，要保留1位小数的话用％.1f

有效位数超出了

这个是编译器的问题

简短截说 10进制小数就是用1/10,1/100,1/1000，……分 2进制小数就是用1/2,1/4,1/8,……分 N进制小数就是用1/N,1/(N*N),1/(N*N*N),……分 所以如果限制最小的用来分的阶数（也就是小数点后最多多少位），M进制小数和N进制小数对有些数两者都能精确表示，对有些数两者只有其一能精确表示，对有些数，两者都不能精确表示。 如果不限制最小的用来分的阶数（也就是小数点后最多多少位，也就是允许使用无限位，不一定非得是循环小数），那M进制小数和N进制小数都能精确表示任何有理数。

引用 52 楼 oracleperl 的回复:引用 赵老师好 请教下 1. 如果是整数，二进制和十进制互转没有问题对吧？ 2.二进制转十进制也是可以精确转的对吧？，比如如下演算    二进制0.1111= 1*(1/2)+1*(1/4)+(1/8)+1/16= 7/8 3. 十进制小数转二进制就不一定能精确转了对吧？似乎是二进制没法记录10进制的所有值    或者说二进制的数值是十进制数值的子集？我这样理解对吧？   但我还没搞明白十进制转二进制的原理 1.对 2.不对 3.对。半对（二进制没法记录10进制的所有值，10进制也没法记录二进制的所有值，二进制的数值和十进制数值之间谁都不是谁的子集）。错。 N（正整数N≥2）进制的小数比如  N=2，2进制： 10.11 W1=1,W0=0,W-1=1,W-2=1其中-1,-2是下标， 对应数值为W1*N^1+W0*N^0+W-1*N^-1+W-2*N^-2其中^表示指数  N=3，3进制： 20.11 W1=2,W0=0,W-1=1,W-2=1其中-1,-2是下标， 对应数值为W1*N^1+W0*N^0+W-1*N^-1+W-2*N^-2其中^表示指数  N=10，10进制： 90.11 W1=9,W0=0,W-1=1,W-2=1其中-1,-2是下标， 对应数值为W1*N^1+W0*N^0+W-1*N^-1+W-2*N^-2其中^表示指数  显然： N=3,3进制 0.1 W0=0,W-1=1,对应数值为W0*N^0+W-1*N^-1即0*3^0+1*3^-1=0.33333333333333无限循环，无法用长度有限的10进制表示 同理，对有些长度有限的10进制小数，无法用长度有限的2进制表示

引用 46 楼 oracleperl 的回复:[quote=引用 45 楼 青蛙工作室 的回复:]严重怀疑楼主是来钓鱼提升CSDN的活跃度的，这么一个基础的问题纠缠了5页，而且看楼主的ID，oracle、perl，3年码龄，根本就不像一个刚接触计算机的小白。各位热心的CSDNer，可以散了。 对你来说是基础的，对别人来说未必是基础的 [/quote]  那你倒是解释一下你的ID，oracle perl，这是一个不懂电脑的小白能想到的？而且在CSDN已有3年，3年啊，哪怕新生儿都上幼儿园了。

好厉害👍，真心都大神！

厉害了，不知道是咋回事

不管你怎么输入，都不会输出0.125那么大的精度偏差。 出现精度偏差的原因是因为计算机存储的是二进制，当你定义一个数值之后，计算机会自动转换成二进制对象，对于整数部分处理起来比较简单，二进制 可以表示出可表示范围内的所有整数，但是小数点以下部分就比较难了。比如0.5可以用2的负1次方。即.1；0.25比如0.5可以用2的负2次方，即.01；0.75比如0.5可以用2的负1次方+可以用2的负2次方，即.11。（这里只是表述一个小数，实际上小数点也会被转换成一个二进制，即一个double或者long型对象，会有相应位数表示正负和小数点的位置。），因此小数部分的表达公式是，进制数乘以该位置的负指数次之后。例如一个二进制.101=1*2^-1+0*2^-2+1*2^-3。 如果你数学足够好，你就会发现，二进制可以表示成唯一的一个十进制数，但是并不是所有十进制数都可以用二进制表示出来，但是可以不断地去用二进制进行逼近。因此在精度范围内，两者输出是一致的。但是如果超过了精度范围，你就会发现两者出现不一致。这个误差是由于设计程序语言设计之初就导致的误差，是系统误差。因此我们在进行一个高精度计算时（或者在进行金融相关的计算与数据存储时候），并不会使用int、long、double这些数据类型，而是使用BigDecimal。

引用 32 楼 oracleperl 的回复:[quote=引用 22 楼 lin5161678 的回复:][quote=引用 13 楼 oracleperl 的回复:] i请教这句"作为常识，大多数十进制有限位小数不能精确转换为二进制。“ 该怎么理解？ 因为 十进制不是2的次幂 所以 有的十进制小数无法用二进制精确表示 如果是 八进制小数 十六进制小数 那么 取值范围之内 就都能精确的用二进制表示[/quote] 说不通啊，举个例子？ 我现在想打印给float赋值123.99 然后就错了？理由是十进制没法转成二进制？ 那么计算机还有什么用？我们还敢写程序吗？比如工资计算程序，就算错了？ [/quote] 工资本来也不是按浮点处理的，  引用 47 楼 oracleperl 的回复:[quote=引用 44 楼 zlzfc 的回复:]printf("result is=%.2f\n", 123456.99f); 就可以了 谢谢。这样我知道可以，但我不知道为什么那样是错的 我看了书《深入理解计算机系统》，说只有2的N次方的进制之间的转换才能确保一致 书上说 float32位，尾数24位，假设4个bits表示一个十进制数字，难道6个4位不能表示123.99吗？ [/quote] 你把123.99转为2进制表示就知道了

引用 47 楼 oracleperl 的回复:[quote=引用 44 楼 zlzfc 的回复:]printf("result is=%.2f\n", 123456.99f); 就可以了 谢谢。这样我知道可以，但我不知道为什么那样是错的 我看了书《深入理解计算机系统》，说只有2的N次方的进制之间的转换才能确保一致 书上说 float32位，尾数24位，假设4个bits表示一个十进制数字，难道6个4位不能表示123.99吗？ [/quote]不停说话是没用的 这东西能实践  0.2611 十进制 转换为二进制小数 写出来  转换过程 转换结果都"写"出来 自己实际操作一次 就什么都明白了 来吧干活

引用 44 楼 zlzfc 的回复:printf("result is=%.2f\n", 123456.99f); 就可以了 谢谢。这样我知道可以，但我不知道为什么那样是错的 我看了书《深入理解计算机系统》，说只有2的N次方的进制之间的转换才能确保一致 书上说 float32位，尾数24位，假设4个bits表示一个十进制数字，难道6个4位不能表示123.99吗？

引用 45 楼 青蛙工作室 的回复:严重怀疑楼主是来钓鱼提升CSDN的活跃度的，这么一个基础的问题纠缠了5页，而且看楼主的ID，oracle、perl，3年码龄，根本就不像一个刚接触计算机的小白。各位热心的CSDNer，可以散了。 对你来说是基础的，对别人来说未必是基础的

引用 25 楼 oracleperl 的回复:[quote=引用 21 楼 真相重于对错 的回复:][quote=引用 20 楼 oracleperl 的回复:][quote=引用 17 楼 真相重于对错 的回复:]从数学的角度讲，数是无限的，而计算机只能表示有限的数，就算整形也受到位数的限制，内存的容量不管多大，也有尽头。而数是无限的。因此计算机无法表示所有的数。这个并不是计算机无用。。 谢谢赵老师，这个我能理解 但是为什么printf("result is=%f\n",123.99f); 这么小的一个十进制数，printf不能返回正确的值？ 难道这个123.99转二进制也会转错？这是我不理解的。 [/quote] 你要了解为什么会转错，那么先要了解，计算机中如何存储整数，进而了解计算机中如何存储小数。了解这些就没有疑惑，不了解这些，别人也没法讲清楚。[/quote] 大神，别人没法讲清楚的事，包括书籍，C标准文档，都是“别人” 那么我如何了解清楚呢？[/quote]  这个梗不错，有开心麻花的范儿。


Question: 求大佬，不会写了

供参考：#include<stdio.h>  #define N 30  struct students {      int num;     //学号     char name[20];//姓名   // int gender;  //性别 男M，女F     char gender;  //性别 男M，女F      int age;     //年龄    float score;   //成绩    float grade;   //操评 };  int main() {   struct students stu[N];//stu[30]      int i;    float qualified=0;//合格    float qualifiedf=0;//合格率     for(i=0;i<N;i++) //for(i=0;i<30;i++)       {        //scanf("%d %c %d %d %d %d",          scanf("%d %s %c %d %f %f",          &stu[i].num,stu[i].name,&stu[i].gender,&stu[i].age,&stu[i].score,&stu[i].grade);       //&stu[i].num,&stu[i].name,&stu[i].gender,&stu[i].age,&stu[i].score,&stu[i].grade);       }    for(i=0;i<N;i++)       {      //if(stu[i].score>60 && stu[i].gender=='M')        if(stu[i].score>=60 && stu[i].gender=='M')           qualified=qualified+1;       }  //qualifiedf=qualified/30;    qualifiedf=qualified/N;    printf("qualifiedf=%.2f\n",qualifiedf);     int count=0;    for(i=0;i<N;i++)       {        if(stu[i].age<18 && stu[i].gender=='F')// 小于18女生总数           count++;       }    printf("count=%d\n", count);     return 0; }

小于18女生总数： int count=0; for(i=0;i<30;i++) {     if(stu[i].age<18 && stu[i].gender=='F')         count++; } printf("%d\n", count);

&stu[i].name 这个不太对吧，用stu[i].name或者&stu[i].name[0]


Question: C语言 贪吃蛇邮箱控制台报错

请参考《VS2015贪吃蛇代码分析（10-1）》 希望能够帮到您！

#include<stdio.h> #include<Windows.h> #include<conio.h>  #define MAP_WIDTH 60 //平均宽度 #define MAP_HEIGHT 20 //平均高度  struct snake { 	//x坐标 	int x;  	//y坐标 	int y;  	//@或者* 	char ch; }; //结构体数组：代表蛇 struct snake g_snake[MAP_WIDTH*MAP_HEIGHT]; //蛇实际的长度 int g_snake_length = 5; void  SetPos(int  x, int  y) {  	COORD  point = { x ,  y }; //光标要设置的位置x,y 	HANDLE  HOutput = GetStdHandle(STD_OUTPUT_HANDLE); //使用GetStdHandle(STD_OUTPUT_HANDLE)来获取标准输出的句柄 	SetConsoleCursorPosition(HOutput, point); //设置光标位置 }  void DrawSnake() { 	int i = 0; 	for (i = 0; i < g_snake_length; i++) 	{ 		//设置坐标到（0,0）位置 		SetPos(g_snake[i].x, g_snake[i].y);  		//绘制贪吃蛇**** 		printf("%c", g_snake[i].ch); 	}   }  void HideCorsor()  {  	HANDLE fd = GetStdHandle(STD_OUTPUT_HANDLE);  	CONSOLE_CURSOR_INFO cinfo;  	cinfo.bVisible = 0;  	cinfo.dwSize = 1;  	if (SetConsoleCursorInfo(fd, &cinfo))  		printf("执行成功\n");  	else  		printf("执行失败\n");  	  } int main() { 	//隐藏光标 	HideCorsor(); 	int i, j; 	//[0,21) 	for (j = 0; j < MAP_HEIGHT + 1; j++) 	{ 		if (j == MAP_HEIGHT) 		{ 			//绘制一行 			for (i = 0; i < MAP_WIDTH; i++) 			{ 				printf("-"); 			} 			printf("\n");  		} 		else 		{   //绘制空行 			for (i = 0; i < MAP_WIDTH; i++) 			{ 				printf(" "); 			} 			printf("|"); 			printf("\n"); 		}  	} 	g_snake_length = 5;  	g_snake[0].x = 0; 	g_snake[0].y = 0; 	g_snake[0].ch = '*';  	g_snake[1].x = 1; 	g_snake[1].y = 0; 	g_snake[1].ch = '*';  	g_snake[2].x = 2; 	g_snake[2].y = 0; 	g_snake[2].ch = '*';  	g_snake[3].x = 3; 	g_snake[3].y = 0; 	g_snake[3].ch = '*';  	g_snake[4].x = 4; 	g_snake[4].y = 0; 	g_snake[4].ch = '@';  	//绘制贪吃蛇**** 	DrawSnake();  	while (1) 	{ 		int tail_x = g_snake[0].x; 		int tail_y = g_snake[0].y; 		//向右移动一格 		//（0,0），（1,0），（2,0），（3,0），（4,0)@ 		//         （1,0），（2,0），（3,0），（4,0）,(5,0)@  		//[0,5) 		for (i = 0; i < g_snake_length - 1; i++) 		{ 			g_snake[i].x = g_snake[i + 1].x; 			g_snake[i].y = g_snake[i + 1].y; 		} 		int key = _getch(); 		switch (key) 		{ 		case 'w'://上 			printf("上"); 			g_snake[g_snake_length - 1].y -= 1; 			break;  		case 'a'://左 			printf("左"); 			g_snake[g_snake_length - 1].x -= 1; 			break;  		case 's'://下 			printf("下"); 			g_snake[g_snake_length - 1].y += 1; 			break;  		case 'd'://右 			printf("右"); 			g_snake[g_snake_length - 1].x += 1; 			break; 		} 		//清除尾坐标 		SetPos(tail_x, tail_y); 		putchar(' ');   		//绘制贪吃蛇**** 		DrawSnake();   	}     	return 0; }

出现乱码还能有别的原因 出现上下左右只能是你就这样写的

没代码，不知道你是怎么写的


引脚定义呢？

板子可以确定是好的

不亮也有可能是电路的问题，哪里虚焊了，烧掉了，没通电，共阴的当成共阳了之类的。


引用 4 楼 logωon 的回复:我刚接触C++。。请问这个vs2019视图是哪个啊？ 名字带View的是视图

你这是文档-视图项目，必须在视图上点左键哟！

一上来就MFC，有基础了吗

我刚接触C++。。请问这个vs2019视图是哪个啊？

引用 1 楼 user-4 的回复:既没有双冒号，也没有足够的参数，还能编译成功，说明不是在调用API，那你只能自己调试了。  哈哈，楼主这是在调戏编译器的节奏。想骗过编译器。结果也被编译器骗了。。


Question: 数据结构：两个顺序表取并集，请问代码哪里不对？

ompiling... Sqlist_Operate.c F:\数据结构与算法\顺序表\Sqlist_Operate.c(126) : error C2275: 'ElementType' : illegal use of this type as an expression         F:\数据结构与算法\顺序表\Sqlist_Operate.c(7) : see declaration of 'ElementType' F:\数据结构与算法\顺序表\Sqlist_Operate.c(126) : error C2146: syntax error : missing ';' before identifier 'e' F:\数据结构与算法\顺序表\Sqlist_Operate.c(126) : error C2065: 'e' : undeclared identifier 执行 cl.exe 时出错.  Sqlist_Operate.obj - 1 error(s), 0 warning(s)

#include <stdio.h> #include <stdlib.h> #include <string.h>  #define SIZE 100  //typedef int ElementType typedef int ElementType; typedef struct {     ElementType *array;   // 存放元素的数组     int length;  // 当前长度     int capacity;  // 数组容量 }SqList;  // 顺序表的创建 SqList *createList(int capacity) {     SqList *L;      L=(SqList*)malloc(sizeof(SqList));     L->length=0;     //L->capacity=SIZE;     L->capacity=capacity;     L->array=(ElementType*)malloc(capacity*sizeof(ElementType));      return L; }  // 获得顺序表的元素 int GetElement(SqList *L,int i,ElementType *e) {     if(i<1||i>L->length){         return 0;     }     *e=L->array[i-1];     return 1; }  // 顺序表的查找 int find(SqList *L,ElementType e) {     int i;      i=L->length-1;     while(i>=0&&L->array[i]!=e){         i--;     }      if (i >= 0)         return i;     else         return 0; }  // 顺序表的插入 int insertlist(SqList *L,int i,ElementType e) {     int k;      if(L->length>=L->capacity)   // 1.判断顺序表的存储空间是否满     {         return 0;     }     if(i<1||i>L->length+1)     // 2.判断插入位置i是否合法     {         return 0;     }     for(k=L->length-1;k>=i-1;k--)     {         L->array[k+1]=L->array[k];    // 3.从最后一个元素开始向后移动     }     L->array[i-1]=e;      // 4.在第i个位置插入元素     L->length++;         // 5.表长度加1      return 1; }  // 顺序表的删除 int deletelist(SqList *L,int i,ElementType *e) {     int k;      if(i<1||i>L->length)    // 1.判断删除位置i是否合法     {         return 0;     }     *e=L->array[i-1];    // 删除的第i个元素     for(k=i;k<L->length;k++)     {         L->array[k-1]=L->array[k];    // 2. 从i+1个元素开始向前移动     }     L->length--;     return 1; }  // 顺序表的长度 int listlength(SqList *L) {     return L->length; }  //按尾部插入法生成初始数据 void Addlist(SqList *L) {     int value;     printf("请输入内容，-1结束\n");     scanf("%d",&value);     while(value!=-1)     {         insertlist(L,L->length+1,value);         scanf("%d",&value);     } }  //输出数据 void Outputlist(SqList *L) {     int i;     for(i=0;i<L->length;i++)     {         printf("%d ",L->array[i]);     }     printf("\n"); }  // 顺序表的合并：取并集 int mergelist(SqList *L1,SqList *L2) {     int L1_Len,L2_Len;     int i;      //L1_Len=listlength(*L1);     L1_Len=listlength(L1);     L2_Len=listlength(L2);      ElementType e;     for(i=1;i<=L2_Len;i++)     {         GetElement(L2,i,&e);         //if(!find(*L1,e))     // 在表L1中没找到该元素，则将该元素插入表L1中         if(!find(L1,e))     // 在表L1中没找到该元素，则将该元素插入表L1中         {             printf("hellowrold!\n");             //insertlist(L1,++L1_Len,e);             insertlist(L1,L1->length+1,e);         }     }  }  int main() {     SqList *LA,*LB;     ElementType e;      //SqList *LA=createList(capacity);     //SqList *LB=createList(capacity);     LA=createList(SIZE);     LB=createList(SIZE);      printf("尾部插入法生成初始数据：\n");      //Addlist(&LA);     Addlist(LA);     printf("LA表中元素为：");     //Outputlist(&LA);     Outputlist(LA);      //Addlist(&LB);     Addlist(LB);     printf("LB表中元素为：");     //Outputlist(&LB);     Outputlist(LB);      //mergelist(&LA,&LB);     mergelist(LA, LB);     printf("LA和LB取并集后的元素为：");     //Outputlist(&LA);     Outputlist(LA);      return 0; }  供参考  语法错误太多，基本上几条语句就对应一个编译error；  解决语法错误是最基本的编程能力，还需要多努力呀

错误6和错误7是看的小甲鱼视频里面写的

MATLAB用惯了，有几年没用C语言了，这次学习数据结构，有些跟着书上敲，疏忽了一些问题，对指针不熟。

Addlist(&LA); printf("LA表中元素为："); Outputlist(&LA);  Addlist(&LB); printf("LB表中元素为："); Outputlist(&LB);  mergelist(&LA,&LB); printf("LA和LB取并集后的元素为："); Outputlist(&LA);  这些函数调用全部写错了，LA和LB本身就是指针了，再取地址&LA明显是错误的。 修改如下后能正确运行  int main() {     SqList *LA, *LB;     ElementType e;      LA = createList(10);     LB = createList(10);      printf("尾部插入法生成初始数据：\n");      Addlist(LA);     printf("LA表中元素为：");     Outputlist(LA);      Addlist(LB);     printf("LB表中元素为：");     Outputlist(LB);      mergelist(LA, LB);     printf("LA和LB取并集后的元素为：");     Outputlist(LA);      return 0; }   楼主对变量的声明和定义、指针等概念掌握的很不清晰

错误： 1、typedef int ElementType  //这里少了个 ；号  typedef int ElementType; 2、L = (SqList*)malloc(sizeof(SqList));  //L没有声明   SqList *L = (SqList*)malloc(sizeof(SqList));  3、i = L->length - 1; //i 没有声明  int i = L->length - 1; 4、for (k = L->length - 1; k >= i - 1; k--)  //k没有声明  for (int k = L->length - 1; k >= i - 1; k--) 5、for (k = i; k < L->length; k++)  //错误同上 for (int k = i; k < L->length; k++) 6、L1_Len = listlength(*L1);  //形参是指针，实参是取值，形参和实参不符 L1_Len = listlength(L1); 7、 if (!find(*L1, e))     // 在表L1中没找到该元素，则将该元素插入表L1中    //错误同上  if (!find(L1, e))      8、     SqList *LA, *LB;                                 //这里已经声明了     ElementType e;      SqList *LA = createList(capacity);    //这里的SqList *LA就重复了     LA = createList(capacity);  这里的capacity没有定义，不知道是什么，随便输入个int值如LA = createList(10);      SqList *LB = createList(capacity);                                                    LB = createList(10);  以上修改后编译通过


Question: 为什么我这个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("输入字符集：");fflush(stdout);     rewind(stdin);     for(i=1;i<=n;i++) {         scanf("%c",&a[i].data);     }     for(i=1;i<=n;i++) {         printf("a[%d].data:%c\n",i,a[i].data);     }     printf("\n");     printf("输入权值：");fflush(stdout);     rewind(stdin);     for(i=1;i<=n;i++) {         scanf("%d",&a[i].weight);     }     for(i=1;i<=n;i++) {         printf("a[%d].weight:%d\n",i,a[i].weight);     }     printf("\n");     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("i:%d\n",i);         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;     m=3*n;     a=(Hufftree)malloc(sizeof(Huffnode)*m);     GetHuffmamCode(a,n);     return 0; } //输入字符个数：3 //输入字符集：abc //a[1].data:a //a[2].data:b //a[3].data:c // //输入权值：10 20 30 //a[1].weight:10 //a[2].weight:20 //a[3].weight:30 // //i:1 //a //00 //i:2 //b //01 //i:3 //c //1 //

对于%c的输入，需要注意上次输入的'\n'可能被接收。

printf("%c\n",a[i].data);前面随便打印输出一行字符串，看看程序走到这个输出语句了吗

太长没太仔细看 你的a，数组下标应该从0到m-1，但你的处理却是从1到m，造成内存越界了吧？


Question: SHFileOperation函数会把文件拷贝成文件夹？

没人回复啊怎么


Question: 关于c语言中位操作的疑问

写入前使用掩码，例如：  uint8_t mask = 0xFE;//小端存储的机器中第一个bit位有写保护 uint8_t a = 0xFF;//被保护数据 uint8_t b = 0x02;//待写入数据 uint8_t c =( b & mask) | (a & (~mask)) ;  memcpy(&a,&c,sizeof(uint8_t));

C++可以用类来实现，C只能自己小心处理。


Question: 学习C语言时遇到的两个问题

楼主的代码：

total -= 1

result=result-x 等价 result-=x

引用 1 楼 user-2的回复:1、result-=1 2、尽量使算法不需要保留原始输入数据，比如求和，可以将每个输入的数据累加到一个变量，然后计数即可；如果必须保留，可以先分配一定长度，当不够时，再重新分配更大长度，把原有数据复制过去，realloc()就是干这个的。或者也可以使用链表。 是因为一开始定义的result=1的缘故吗？请问如果用-=的话可以怎么改一下？

哦哦 明白了！原来是我一直概念没搞清啊

引用 7 楼 啊6吧 的回复:[quote=引用 5 楼 qzjhjxj的回复:]楼主的代码： 那请问为啥total=total-1就能输出正确的结果呢？[/quote] total -= total;/*这句分开写法：*/total = total - total = 0; total -= 1；/*这句分开写法   ：*/total = total - 1;执行顺序为：total-1，total =total,就是变量total先减1运算，再赋值。

引用 5 楼 qzjhjxj的回复:楼主的代码： 那请问为啥total=total-1就能输出正确的结果呢？


Question: 求助

只有想不到，没有做不到。 修改main，这个简单，自己写个编译器即可。 如果觉得C语法反人类，还可以修改C语法，创建新编程语言。。

首先这个事没啥意义。 其次个人觉得最简方式是宏定义，你可以把定义藏进头文件足够了。

百度吧。这个我记得编译链接过程中，会占用这个默认名称。


Question: C++

供参考：#include <stdio.h> int main(int argc, char* argv[]) {     int a[10]={0},b,i=0;     scanf("%d",&b);     while(b){           a[i++] = b%10;           printf("%d",a[i-1]);           b /= 10;          }     printf("\n");      return 0; } int main(void) { 	char buf[11], *p=buf; 	scanf("%10s", buf); 	while(*p)p++;         while(p-- != buf) printf("%c",*p); 	printf("\n");    	return 0; }

引用 3 楼 weixin_51991747 的回复:while(*p)p++;    while(p-- != buf) printf("%c",*p);是什么意思？？？  如:原数为4563，假设首地址为buf=0，while(*p)p++;这句就是p 从0开始一直走到4563的结尾处，也就是p=4;  while(p-- != buf) printf("%c",*p);这句就是p=4开始往回倒，一直倒回到p==buf=0的位置，倒着输出呀。

把每位数取出来再加起来


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


Question: 自闭中

最后一个words不要*号

引用 3 楼 向阳森 的回复:[quote=引用 1 楼 赵4老师的回复:]13:   char words[]="... 16:   cnline((char *)words, i, j); 能详细讲一下原因吗！谢谢[/quote] 你的函数形参和调用函数输入的实参类型不匹配，要改成一样的类型

引用 1 楼 赵4老师的回复:13:   char words[]="... 16:   cnline((char *)words, i, j); 能详细讲一下原因吗！谢谢

chline(*words, i, j); 参数去掉*，否则类型不匹配。应为实参是char，形参是char *


Question: C语言小白求助！为什么①不能选B，②不能选A?

不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fputc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fscanf,fprintf,fgets,fgetc,fputc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

考虑权限问题 带+都不选 考虑文本模式对文件数据有特殊处理 不带b都不选 1. A 不带b B 带+ C OK D 带+ 选C 2. A 带+ B 带+ C 不带b D OK  结论 答案是 CD

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

从打开文件后的操作上来看，fp1只是做了读操作，其他没有。从安全角度上讲old.data文件的打开方式应该是只读的，r+是可以读写的，添加写权限不安全；  但是B也没问题。  第二个空，道理也是一样的。

感觉答案只是从严谨的角度定的吧，你的想法也没问题

因为题目不是你出的。


Question: C语言小白求助！这里的stdin是什么意思？

引用 1 楼 user-1的回复:标准输入的意思。 谢谢回答！！！

标准输入的意思。


Question: 请问输出超限怎么解决

引用 4 楼 user-1的回复:勉强一点试试 while(scanf(...)==2) 吧 嗯好，非常感谢

勉强一点试试 while(scanf(...)==2) 吧

样例输入为 no 370 371

为啥都喜欢把关键部位藏起来呢？样例输出呢？

有人来吗，求大佬告知


Question: 挑战全球各种Code Editors！

TSEPro11_Setup.exe 百万军中取上将首级如探囊取物， 千万行里改关键源码在弹指瞬间。 功能超强的程序编辑器！ https://blog.csdn.net/zhao4zhong1/article/details/126596717

试试还能发帖么

还没结帖，赶紧蹭一蹭

有要分的

厉害 厉害

不错，不错！

是我没说清楚，能编辑多大的文件，是单个文件大小，多个文件的总量意义不大。

引用 7 楼 早打大打打核战争 的回复:一百万行printf？ 这个名副其实的“一百万行printf”也是我利用此神器的几个键盘宏生成的。 顺便可用于打脸那些以代码行数论程序员工作量的外行领导。

一百万行printf？

引用 5 楼 早打大打打核战争 的回复:是我没说清楚，能编辑多大的文件，是单个文件大小，多个文件的总量意义不大。 单个文件也毫无压力：

引用 3 楼 早打大打打核战争 的回复:能编辑多大的文件，一百万行代码行不行？ 你以为不行吗？  以上是打开opencv+contrib所有源代码后的局部截图

能编辑多大的文件，一百万行代码行不行？


Question: 这串代码有什么错误嘛？我想让一串数字输入到文件里面，然后将文件中的数字再读取出来

找了好多资料都找不到相关内容


Question: 请教到底什么是函数原型，谢谢

我们都知道C语言提倡在调用之前通过包含头文件等手段先提供函数原型，我们照办。 凡是违反这个原则的，在C猿看来都是大逆不道。  所以我仍然表示我无法提供你所需要的函数原型的精确定义。从而无法正面回答你的问题。5楼所述都是侧面功能性描述。 从而我也仍然认为你的纠结是钻牛角尖。

引用 4 楼 oracleperl 的回复:[quote=引用 3 楼 自信男孩 的回复:]    函数声明可以省略形参名，但是函数定义的首部必须写出所有形参名并给出其对应的数据类型。     函数原型的主要目的为声明函数返回值类型以及函数的期望接受的参数的个数、参数类型和参数顺序     如果程序中没有某个函数的函数原型（没有说明），编译系统就会用第一次出现的这个函数（函数定义或函数调用）构造函数原型         在缺省下编译系统默认函数返回值为int         而对函数参数类型不做任何假设     常见错误         和函数原型不匹配的函数调用会导致语法错误         函数原型和函数定义不一致，也会产生错误         C语言环境下，如果函数不进行声明就使用，可能会发生错误，因为默认将返回值做为int类型来处理，所以，最好是在使用之前对函数进行声明。    感觉楼主还是比较懒的，网上的信息还是比较多的，为什么不亲自找找并总结一下。如果看一个帖子的说明还怀疑，看2个可能可以做个对照，看多个的时候可以总结一下那个更靠谱的定义。  最后还真别钻牛角尖，没用的。 网上的信息未必是对的，很多文字逻辑混乱 另外，这个不存在钻牛角尖一说，概念是要搞清楚的。 [/quote]  所以，你需要判断和总结。从网上查资料还是比较快的，如果去查专门的文献或书籍，我想你没这么快。网上的表述可能加上了很多人自己的见解在里面，并且可能讲解的更通俗易懂，更多时候还会有例子。一个概念，可能描述的不见得你就能理解。

总结，在调用点上方让编译器两眼一抹黑的就叫没有原型，无论你在下面写得多么完善。

反过来说，出现在调用点下方/其他文件里的函数定义不起原型作用，因此不认为是原型。

好吧，惯着你。前提是编译器和你一样从头开始流式阅读源文件。 C意义下所谓原型prototype，它是干啥的呢？ 用于在函数被调用之前通知编译/连接器，这个函数有几个参数，每个参数是什么类型的，以及捎带着预期的返回值是什么类型的。 为啥要通知是另一个问题。  于是，凡是起这个作用的，出现在函数被调用的行的上方的函数声明/函数定义都可以被编译/连接器理解为是prototype。  通常我们写那个声明的目的是为了解放函数定义的位置， 所以，在一个程序中如果你能保证函数定义和函数调用出现在同一个源文件，并且定义总在调用上方出现，那就完全不必出现函数声明。 所以所以，在通常的语境下，我们称头文件里的函数声明，以及源文件里位于靠近文件头方向的函数声明为 函数原型。

引用 3 楼 自信男孩 的回复:函数声明可以省略形参名，但是函数定义的首部必须写出所有形参名并给出其对应的数据类型。     函数原型的主要目的为声明函数返回值类型以及函数的期望接受的参数的个数、参数类型和参数顺序     如果程序中没有某个函数的函数原型（没有说明），编译系统就会用第一次出现的这个函数（函数定义或函数调用）构造函数原型         在缺省下编译系统默认函数返回值为int         而对函数参数类型不做任何假设     常见错误         和函数原型不匹配的函数调用会导致语法错误         函数原型和函数定义不一致，也会产生错误         C语言环境下，如果函数不进行声明就使用，可能会发生错误，因为默认将返回值做为int类型来处理，所以，最好是在使用之前对函数进行声明。    感觉楼主还是比较懒的，网上的信息还是比较多的，为什么不亲自找找并总结一下。如果看一个帖子的说明还怀疑，看2个可能可以做个对照，看多个的时候可以总结一下那个更靠谱的定义。  最后还真别钻牛角尖，没用的。 网上的信息未必是对的，很多文字逻辑混乱 另外，这个不存在钻牛角尖一说，概念是要搞清楚的。

int f(int x);   这个可以看做声明  int f(int x)  //这一行可以看做实现 return 100; }


Question: 请问 我怎么写这个装进unsigned char tx_Setbuffer[1024]; 里数据，写法不会

引用 3 楼 2004v2004 的回复:strcpy(tx_Setbuffer+8, "Versio"); //字符串用strcpy拷贝的方式  我这里这个不对呢 不对是指什么？是程序运行出错，还是运行后赋值后结果不对？ 如果是报错，改成 strcpy((char*)(tx_Setbuffer+8), "Versio"); 或用内存拷贝的方式 memcpy(tx_Setbuffer+8, "Versio", strlen("Versio")); 再不行就循环一个一个赋值 如果是结果不对，那就看你希望的结果是什么了，上面的做法只是单纯的把"Versio"的每个字符存入tx_Setbuffer+8开始的内存中

memcpy(tx_Setbuffer + 8, "Versio", 8);        用这个是OK的 谢谢了

for example tx_Setbuffer[6] =(unsinged char)strtol("32", NULL, 16); //字符串转成数字类型 strcpy(tx_Setbuffer+8, "Versio"); //字符串用strcpy拷贝的方式 tx_Setbuffer[17]=((unsinged char))strtol("1", NULL, 0); //字符串转成数字类型


Question: C语言小白求助！请问这道题c为什么错了？

谢谢解答！！！

不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fputc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fscanf,fprintf,fgets,fgetc,fputc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

我还说fprintf也可以，谁要跟我抬杠，我就甩这几行代码给他： #include <stdio.h> int main() {     int i=0x12345678;     FILE *f=fopen("data.bin","wb");     fprintf(f,"%c%c%c%c",(char)(i>>24),(char)(i>>16&0xFF),(char)(i>>8&0xFF),(char)(i&0xFF));     fclose(f);     return 0; }

fwrite可以是可以；但不能拦着fputc也可以： int fputc( int c, FILE *stream );

纠正 ACD都行  AD需要一点技巧而已

出题人自己不清醒而已  AC都行 A需要一些技巧而已

C fwrite()函数

【可把整数以二进制形式存放到文件中】这里的二进制形式指的是什么？ 如果是比如5，以101写入文件的话，那就是A，用fprintf的格式打印可以实现 C能实现的是字节方式存储，但是存储内容本身是16进制

B是读，A和D是字符形式；所以选C，如果C错，那就有问题了吧，那就是答案错误～   https://wenku.baidu.com/view/f4332ec509a1284ac850ad02de80d4d8d15a01b6.html

fwrite啊，以二进制的形式"wb"打开文件