Mxode/CSDN-C_Language-2013_2023 huggingface dataset:
user-0 提问: 看看大家的解题方法

回复:
user: user-0
content: #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; }

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

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

回复:
user: user-0
content: 引用 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); }  华东师大的大佬！！！ 谢谢谢谢 学到了学到了

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

user: user-2
content: 先把数组 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); }

user: user-0
content: 引用 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 我明白了 谢谢谢谢

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

user: user-3
content: 没有结束符就一直往下打印直到遇到结束符，下面是一种修改方式的代码，供参考。   #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; }

user: user-4
content: 少了个'\0'

user: user-5
content: 你没处理结束符，多一个就行。 for(i=4;i>=0;i--)
user-0 提问: 请教大神 这两者的区别

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 第一张图应该这样#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; }

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

user: user-3
content: 第一图修改，供参考：#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; }

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

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

user: user-2
content: 第一张图的代码是错的，在第一个if的printf后加上return 0就对了。记得要加大括号。 第二张图是对的。 两张图没什么区别，看你喜欢用哪个

user: user-6
content: 把ruturn 0去掉就可以了

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

user: user-8
content: 运行一下不就明白了？

user: user-9
content: grade没有初始化，如果<0 || > 100，最后输出的greade是一个随机值。   两张图片的区别应该是有没有在return 0前加printf吧
user-0 提问: 疑问，枚举类型变量该怎么赋值？大神求解！！

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

user: user-0
content: 引用 3 楼 qzjhjxj的回复:参考：https://blog.csdn.net/zhanghong056/article/details/76697195?utm_medium=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase&depth_1-utm_source=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase 嗯，大概懂了

user: user-1
content: tomorrow = (Weekday)((int)today + 1);

user: user-2
content: 参考：https://blog.csdn.net/zhanghong056/article/details/76697195?utm_medium=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase&depth_1-utm_source=distribute.pc_relevant_bbs_down.none-task-blog-baidujs-2.nonecase

user: user-0
content: 好的，原来这样。

user: user-3
content: 不可以的。那个相当于一个#define的定义。
user-0 提问: C语言全局变量问题，大佬救命

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

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

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

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

user: user-0
content: 之前有看到默认是static 感到不太确定

user: user-0
content: 有人吗 我晕了
user-0 提问: C语言

回复:
user: user-0
content: 感谢指导，谢谢了

user: user-1
content: 楼主的方法:#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; }

user: user-1
content: 供参考：#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; }
user-0 提问: 浮点数减法

回复:
user: user-0
content: 引用 4 楼 赵4老师 的回复:

user: user-1

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

user: user-2
content: 减法运算用补码就是加法运算 X-Y=X+(-Y)=X[补]+(-Y)[补] 所以(-Y)[补]不对

user: user-0
content: 找到错误了
user-0 提问: IAR在函数中已经声明了外部变量 但是却提示错误Undefined external "arr" referred in lvbo 

回复:
user: user-1
content: 参考:https://bbs.csdn.net/topics/398903802

user: user-2
content: 说明编译器确实没找到它。

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

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

user: user-0
content: 我是定义在.c文件里的 .c文件可以引用吗？

user: user-1
content: 你得把extern unsigned long arr[5];这个外部数组的.c .h文件导入进来，不然不知道上哪找。
user-0 提问: 输出1000以内的素数，每行10个。

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2
content: 。。。。。你在教我做事？？？

user: user-3
content: 认真学习！

user: user-4

user: user-5
content: 成就感对菜鸟和大神是公平的。

user: user-6
content: #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");         }     } } 供参考～

user: user-7
content: 牢记1000以内素数的重要性，请看电影《cube》

user: user-8
content: 没问题，楼主这是在教大家解题方法吗

user: user-9
content: 阅，再接再厉。
user-0 提问: C语言如果没有学过指针，这个代码还能简化吗

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

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

user: user-2
content: 另外，我个人痛恨goto，请原谅。

user: user-2
content: 在你的思路上去重复，我没有验证过： #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 !

user: user-0
content: 可是不知道怎么优化了。。。。。

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

user: user-2
content: 有重复，自然就可以简化。
user-0 提问: 为什么这个代码无法读取10.

回复:
user: user-1
content: 引用 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] 你说的没错，我这么说是为了方便你理解。 有兴趣的话，你可以继续深入研究下去，这里不是终点。

user: user-2
content: 引用 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'还是在的

user: user-1
content: 引用 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);

user: user-2
content: if (ch=='\n') 这句判断没有意义，因为ch不会匹配到字符的，虽然输入10可以和'\n'一样。  %d只会匹配数字，其他字符是不匹配的，即接收不到'\n'。当然也不会存在。

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

user: user-4
content: 因为'\n'就是10，你输入的10被那个if截住了。
user-0 提问: 数组如何传值给一个函数？

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

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

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

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

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

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

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

user: user-1
content: 自己复制，出了性能问题是程序员自己负责，编译器复制，出了性能问题要找编译器公司吗？你作为编译器开发商，你会主动去惹这些麻烦吗？编译器应该帮用户优化而不是给用户带来隐患问题。所以，编译器不提供自动复制，想复制就自己主动复制，出了性能问题自己负责。

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

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

user: user-2
content: 局限是结构体中的数组大小必须是常量。

user: user-2
content: 可以把数组整体放进结构体，传递结构体类型的参数。

user: user-3
content: 数组参数加个const应该可以实现你的要求。
user-0 提问: 求大佬讲解

回复:
user: user-0
content: 谢谢各位大佬

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

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

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

user: user-3
content: 溢出是针对有符号数的，无符号数是进位/借位

user: user-4
content: 题目有点问题，没有明确是有符号还是无符号的

user: user-0
content: 引用 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咋溢出了呢

user: user-5
content: 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，结果正确。

user: user-0
content: 引用 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吗

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

user: user-2
content: 4*x=1100 0000 //符号位是1，说明是负数，保留符号位，左移2位（低位补0） y/2=1101 1100 //符号位是1，保留符号位，右移1位（高位补1） 相加结果，11001 1100，说明溢出了，其实只需要看两个操作数的符号位紧接着的1位是不是都是1，就能判断是否会溢出了
user-0 提问: 揭开内存的秘密，让一切真相大白

回复:
user: user-1
content: 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

user: user-2

user: user-0
content: 文章第一句就是从设计概念上讲，这就排除了例外，寄存器是可以储存数据，但从设计目的来看是为了加快数据储存而不是用来保存数据，要说例外有的计算机连内存都没有，只有寄存器，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++程序设计精要教程》是一本好书，但也没讲的那么细，详情可以查阅相关编译原理的书籍。最后文章若还有疏漏之处，欢迎补充。

user: user-3
content: 引用 楼主 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++程序设计精要教程》。

user: user-4
content: 辛苦了，有空看看当复习也不错。

user: user-5
content: 文字没看 实例代码扫了两眼 发现不少错误 #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 就知道错了
user-0 提问: 初学C语言求助

回复:
user: user-0
content: 刚刚开始学 跟着网课上走  了解的不太多

user: user-0
content: 太谢谢了！好人一生平安

user: user-1
content: 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变量不需要，可以去掉

user: user-2
content: C语言课不该出这种题，算法吗？也不象，让学生掌握什么？
user-0 提问: 请教 遍历list 为什么我得到的值  char * 类型的 不正确呢，整形等是正确的，这里该怎么写，谢谢了

回复:
user: user-0
content: free(tmpQElemPcm.Pcm_data);//释放                 tmpQElemPcm.Pcm_data释放我应该写在什么位置

user: user-0
content: 谢谢楼上两位指导

user: user-1
content: 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实际为野指针，它的内存信息是不确定的

user: user-2
content: 你急匆匆就把内容内存给free掉了， 下面怎么好意思再用呢？  人家内存应该跟你说，离婚了就别再来找我。
user-0 提问: 新手，错误提示none of the 2 overloads can convert parameter 1 from type 'float'是怎么回事ne

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

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

user: user-0
content: 引用 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的语法学好这个是后面修改过的，谢谢提醒

user: user-2
content: 函数的声明和定义与函数的调用不一致。比如 dchafen(lx[50], ca[50]); //调用 float dchafen(int t[], int v[])；//声明 参数是 数组，而你传给他一个整数，如何能够不出错？ 建议把c的语法学好

user: user-1
content: 我不信，你看着办。

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

user: user-1
content: 还是不行是肯定的，问题是还出这个错误？

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

user: user-0
content: 还是不行，是不是我这个函数结构有问题呀

user: user-1
content: 把所有的float都换成double就不会出这个错误了。
user-0 提问: 【C语言】新手求教一些关于指针的问题，两指针变量相等的相关问题，求教大佬们

回复:
user: user-1
content: 指针就是地址，地址就是指针；指针变量是一个变量，它保存了基本类型变量的地址。 如果指针变量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的值

user: user-2
content: 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类型
user-0 提问: 求各位数字之后和反序数的代码

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

user: user-1
content: 可以一气呵成的为何要写2个?

user: user-2

user: user-2
content: //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; }

user: user-3
content: 反序数 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; }
user-0 提问: 求助代码的含义

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

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

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

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

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

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

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

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

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

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

user: user-2
content: 将  #ifndef #define  #endif  换为 #pragma once

user: user-3
content: 头文件上加一句 #pragma once  试试
user-0 提问: 持续写文件到ssd，会造成写入速度变慢

回复:
user: user-1
content: 同意3楼和8楼

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

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

user: user-0
content: 引用 3 楼 早打大打打核战争 的回复:现在的SSD普遍使用TLC甚至QLC，芯片的实际写入性能是很低的（比机械硬盘还低），厂商吹嘘的性能指标实际是靠里面的SLC缓存带起来的，所以持续写入大量数据掉速是很正常的用的是kioxia的nvme ssd，我写demo把一个100M的文件重复写到里面去都不行，所以这是硬盘问题？无解了？

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

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

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

user: user-4
content: fopen第二个参数里有b吗？

user: user-5
content: 在同一个文件夹下，不要存放太多的文件！我们每次创建一个文件FATFS系统都要进行扫描有没有这个文件，没有就创建，随着新建文件的增多会导致扫描的时间变长，导致文件建立效率降低，时间变长。当然也可能有其他原因
user-0 提问: 看到一个结构体的练习，不太明白输出结果

回复:
user: user-1
content: 因为++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; }

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

user: user-3
content: 供参考：#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'
user-0 提问: 求教 是哪里出问题了

回复:
user: user-0
content: 引用 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; }我私信你了 老哥

user: user-1
content: 看不懂日语，只能从语法错误修改下，供参考：#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; }
user-0 提问: 十进制小数的整数部分，肯定能转成二进制，这个也没错把？

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

user: user-1
content: 整数部分，单纯的转换为二进制是可以的，但加上小数部分，再结合浮点数的内存存储，那就未必了，因为有精度限制。

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

user: user-3
content: 恩，没错，是可以用二进制表示的。确切的说都可以用二进制表示和存储的。因为计算机只认识二进制0和1，不认别的，所以说计算机认识并计算的都是可以用0和1标识的。
user-0 提问: 请教二进制小数肯定能转成十进制小数，这个没错把？

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

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

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

user: user-1

user: user-3
content: 不考虑 无限循环小数 无限不循环小数之类的情况 是的

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

user: user-0
content: 引用 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都能表示的啊 你的这篇文章，图片不能显示的

user: user-5
content: 理论上是没错的。我想你的为不在这里，而在二进制口算的是多少，但是实际上对应的十进制不是。  建议楼主查一下浮点数在内存里的表示。网上是有的，建议好好查查，仔细看一些别人文章的介绍，书本上也是有的，浮点数的表示比较复杂，不能按照 整型数的去理解～
user-0 提问: 各位大佬，vscode不能识别头文件，如何设置才会识别呢？

回复:
user: user-1
content: 参考下这几篇文章：https://blog.csdn.net/weixin_36224284/article/details/111814538?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-2&spm=1001.2101.3001.4242  https://blog.csdn.net/weixin_39553753/article/details/111732093?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-3&spm=1001.2101.3001.4242
user-0 提问: 请教如何保证两个十进制的float数值相加相减等，肯定能得到正确的结果？谢谢

回复:
user: user-1
content: 引用 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

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

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

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

user: user-1
content: 定点小数存储为整数，不遵循IEEE754的标准，比如12345.6789，固定四位小数，存储为整数123456789

user: user-0
content: 引用 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的标准吗？ 谢谢

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

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

user: user-1
content: 你得先定义“正确”，比如精确到小数点后多少位
user-0 提问: 请教，变量名储存在哪里？

回复:
user: user-1
content: 引用 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

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

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

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

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

user: user-3
content: a,b,c不存在，编译后都是地址，变量只是高级语言提供操作地址的一种手段，变为低级语言，就是直接把变量的值move变量对应的地址 比如 a = 1，就是 mov 地址a 1

user: user-1
content: obj文件也应该算

user: user-1
content: 纠正楼上 pdf文件  →  pdb文件

user: user-1
content: 变量名存在于 源代码 编译器 pdf文件 …… 中
user-0 提问: 请问float值是如何表示的？(1 bit)  指数(8 bits)  尾数(23 bits) 小数点在哪里？

回复:
user: user-0
content: 引用 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?

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

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

user: user-2
content: 浮点数的0只有符号位是0或者1，其余全0

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

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

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

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

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

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

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

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

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

user: user-3
content: 浮点数格式 http://bbs.csdn.net/topics/390676437
user-0 提问: 请教这句代码的意思

回复:
user: user-1
content: 楼上正解！同时满足不是字符Y和字符N的情况下才执行 WEONG

user: user-2
content: 判断ch是否为'y'和'n'，即如果不是'y'同时不是'n'，则执行WRONG();函数
user-0 提问: 谁先倒

回复:
user: user-1
content: 参考下这篇博客：https://blog.csdn.net/21aspnet/article/details/174326

user: user-0
content: 为什么加上\n，就不对了呢？

user: user-1
content: 第12行多打了  \n   scanf("%d %d %d %d",&a[i],&b[i],&c[i],&d[i]);
user-0 提问: 如何把一个变量和一个指针连起来？

回复:
user: user-1
content: #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] //以上三行等价

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

user: user-3
content: 本来应该是point=&a就可以了，但是你又给point动态分配内存了，改了point指向，后面就没法正确释放point的内存了。
user-0 提问: 关于宏定义问题

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

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

user: user-2
content: 恩，放到一个环形缓存里？

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

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

user: user-3
content: 管道重定向可以满足你的需求。

user: user-1
content: 只需要在第一个putc之前定义： std::string s; #define putc(c, f) s.insert(s.end(), c) 然后putc输出就到s中了
user-0 提问: C语言

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

user: user-2
content: 用计算月的日期试看
user-0 提问: illegal use of this type as an expression，下面的代码没问题，就是编译不通过

回复:
user: user-0
content: 非常感谢，这个问题我搞了很久没解决，现在可以了

user: user-1
content: 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; }  供参考～
user-0 提问: 求救

回复:
user: user-1
content: Pv Ps 两个值传入是否正常？

user: user-0
content: 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 );  	 }  }这呢

user: user-2
content: c10ms=0;了以后就一直跳过这个最大的if了。 除非另有代码修改它。
user-0 提问: C语言小白求助！这道题c为什么等于0不等于1？

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

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

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

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

user: user-4
content: 从左向右执行，++a，先加后判断，a已经等于1了，又因为是||符号，后面的就不执行了，所以c也是0
user-0 提问: C语言小白求助！请问这道题怎么理解？

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

user: user-2
content: 我们知道，把整数理解为逻辑值时，非零为真，零为假； 反之把逻辑值用作整数时，真值为1，假值为0； 逻辑运算符 && 和 || 在左操作数能确定运算结果时会短路跳过右操作数。
user-0 提问: 求帮助，初学C语言输入三个数没反应，输入十个数时，直接结束

回复:
user: user-1
content: 学习了，小白路过

user: user-2
content: main前面要有int scanf里面不要有\n

user: user-3
content: 重发一遍：…… #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; }

user: user-3
content: 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; }

user: user-4
content: int   main（）

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

user: user-6
content: scanf("%d%d%d", …)试试看。

user: user-7
content: #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; }  供参考～

user: user-8
content: 挺不错的啊挺不错的啊
user-0 提问: 数据结构（c语言）

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

user: user-1
content: f1函数是创建一个节点，赋值一个string给在node，并连接到list中。 如果v给的是一个null，则返回失败。

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

回复:
user: user-0
content: 只有一个if呀 还有else和for咋搞

user: user-1
content: #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

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

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