Question: 一行字符串可能含有多个正的浮点数, 请找出这些浮点数, 并输出它们的准确和.

引用 5 楼 KarivV 的回复: #include <stdio.h> #include <string.h> #include <malloc.h> #include <stdlib.h>  #define MAXLEN 50 #define MAXCOUNT 100  int main() { 	int flag = 0; 	int count = 0, stamp = 0; 	char float_tem[MAXLEN] = ""; 	char **numArr = (char **)malloc(MAXCOUNT * sizeof(char *)); 	for (int i = 0; i < MAXCOUNT; ++i)         { 		numArr[i] = (char *)malloc(MAXLEN * sizeof(char)); 		memset(numArr[i], 0, MAXLEN); 	}     char buff[MAXLEN * MAXCOUNT] = ""; 	fgets(buff, sizeof(buff), stdin);          for (int j = 0; buff[j] != '\n'; ++j)  	{ 		if (buff[j] < '0' || buff[j] > '9') 			continue; 		else 		{ 			memset(float_tem, 0, MAXLEN); 			stamp = 0; 			flag = 0; 			while (1) 			{ 				if (buff[j] == '.') 				{ 					if (flag == 1) 						break; 					else 						flag = 1; 				} 				else if (buff[j] < '0' || buff[j] > '9') 					break; 				float_tem[stamp] = buff[j]; 				++j; 				++stamp; 			} 			memcpy(numArr[count], float_tem, strlen(float_tem)); 			++count; 			--j; 		} 	}  	for (int k = 0; k < count; ++k) 	{ 		printf("%f\n", atof(numArr[k])); 	}  	for (int p = 0; p < MAXCOUNT; ++p) 		free(numArr[p]); 	free(numArr);  	return 0; }   或许我是真的闲吧... 忽略丑陋的排版和拙劣的语法  反正能跑  没试。但是按楼主的描述你的代码估计不行 "123.123.123.123.132.132.132.13.132.123.132"

引用 2 楼 Relongera 的回复:[quote=引用 1 楼 提及的回复:]一行字符串可能含有多个正数, 请找出这些数, 并输出它们的和. ccc语言 emmmmmm，这也太那个了吧[/quote]  那个？？    问心自问，别人为什么要帮你？

一行字符串可能含有多个整数, 请找出这些数, 并输出它们的乘积. ccc语言

引用 1 楼 提及的回复:一行字符串可能含有多个正数, 请找出这些数, 并输出它们的和. ccc语言 emmmmmm，这也太那个了吧

一行字符串可能含有多个正数, 请找出这些数, 并输出它们的和. ccc语言


Question: C语言疑惑

count = 0; while (count < 3) {     data = get_data();     if (!IsOk(data))             continue;     count++; }

设置一个计数器变量，循环查找，每找到一个就给计数器累加一，检查计数器的值，等于3了就退跳出循环。


Question: 求答

引用 2 楼 qybao的回复:int i=1, s=0; for (; s<=500; i+=2) s+=i; printf(“n=%d\n”, i); 谢谢你，我是c语言的菜鸟，以后可以经常请教您吗？

你会结贴吗？最近被不结贴的小学生搞怕了。


Question: 帮我看看哪里错了啊

兄弟你main函数输出了一遍，在函数内又输出了一遍啊 引用 3 楼 Glissip 的回复:[quote=引用 1 楼 user-2 的回复：]两个函数的循环里 a[i] != '\0'  另外 main里加密解密函数,不是写反了吗,虽然这个关系不是很大加密解密结果后面有两行一摸一样的结果，这是什么原因呢？[/quote]

引用 1 楼 user-2 的回复：两个函数的循环里 a[i] != '\0'  另外 main里加密解密函数,不是写反了吗,虽然这个关系不是很大加密解密结果后面有两行一摸一样的结果，这是什么原因呢？

引用 1 楼 user-2 的回复：两个函数的循环里 a[i] != '\0'  另外 main里加密解密函数,不是写反了吗,虽然这个关系不是很大然后现在结果它重复了两个


Question: 指针咋哪哪不对劲

这书哪里卖的，你可以把它丢了。根本就是不懂C语言的人写的书。

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

引用 7 楼 636f6c696e的回复:都告诉你了ch不是字符，就没有'ch'这种写法，“ch”表示字符串，如果要找字符串，string库有现成的接口 引用 5 楼 涤 的回复:那我偏要找'ch'这么写呢 我没有说要'ch'这样写啊

主要问题： 1、把函数的局部变量作为引用返回，显然不对。可以返回静态的引用 2、比较运算里没有i参与，始终比较的是前两个。 3、一些下标泄露的小问题，比如要判断 i+1是不是0，而不是i，因为你判断2个字符 原始修改：  #include <stdio.h> #include <string.h> int * count( char *p ); int * count2( char *p ); int main() {     char p[]="abch2384784chch1cchh22";     printf("'ch' %d \n",*(count(p)));     printf("'ch' %d \n",*(count2(p))); }   int *count( char *p) {     static int cnt=0;     int i=0;     while(*(p+i+1))     {         if(*(p+i)=='c'&&*(p+i+1)=='h')             cnt++;         i++;     }      return  &cnt; }   int *count2( char *p) {     static int cnt=0;     int i=0;     while(*(p+i))     {         if(strncmp(p+i,"ch",2)==0)             cnt++;         i++;     }      return  &cnt; }    简化：  #include <stdio.h> int count( const char *p ); int main() {     const char p[]="abch2384784chch1cchh22";     printf("'ch' %d \n",count(p)); }  int count( const char *p) {     int cnt=0;     while(*(p+1))     {         if(*p=='c' && *(p+1)=='h')             ++cnt;         ++p;     }     return  cnt; }

那我偏要找'ch'这么写呢

'ch'不是字符，*p = 'ch'; 书上不应该出现这个低级错误吧

哥，ch特指一个字符，是函数的入参，而不是'ch'两个字符，

并且理解错了意思

哇，这个程序不对，刚试了其他数据


Question: C语言求π/4=1-1/3+1/5-1/7+…编程π的近似值直到最后一项的绝对值小于10的_4次方为止，输出π的值并统计累加的项数

#include<stdio.h> #include<math.h> int main() { 	int i, q; 	float n, p, sum=1; 	i = 1; 	p = pow(10, -4); 	do { 		q = pow(-1, i); 		sum += 1.0 / (2 * i + 1)*q; 		i++; 	} while (1.0 / (2 * i + 1) >= p); 	n = sum * 4; 	printf("%f,%d\n", n, i); 	return 0; }  change：  #include<stdio.h> #include<math.h> int main() { 	int i, q; 	float PI, tmp, sum = 0, end; 	i = 0; 	end = pow(10, -4); 	do { 		tmp = 1.0 / (2 * i + 1); 		sum += tmp* pow(-1, i); 		i++; 	} while (tmp >= end); 	PI = sum * 4; 	printf("%f,%d\n", PI, i - 1); 	return 0; }

引用 1 楼 user-1的回复:错误1：sum也应该是浮点型 错误2：q的赋值，即确定符号，应该放在循环内部 错误3：因为i为int，故1/(2*i-1)得到的也只能是整型，且舍弃后都是为0，比较简单的方法是把被除数改为1.0，注意改两个地方，sum求和，dowhile判断 那那那正确的应该怎么改


Question: 简单弹性摁键控制问题。为什么摁下下摁键，灯就一直亮，不会因为弹起而灭？

上面程序少写了while(1) include<reg52.h> #define unsigned int uint; sbit key=P2^1; sbit led=P2^2; void delayms( ) void main() {key=1; led=0; while(1) {  if(key== 0) { 	delayms(10);  if(key== 0)								//摁下摁键 		{ 				led=1; //灯亮  } }} void delayms(uint xms)			     {uint i,j;   for(i=xms;i>0;i--)    for(j=110;j>0;j--)


Question: 求大佬帮忙解一下这道题

有别的方式吗😭😭😭😭这个好像不适用c语言

#include <stdio.h> #include <stdlib.h> #include <string.h>  //定义一个函数完成这些操作 void Change(char a[])   //传入一个字符数组 { 	int n; 	n = strlen(a);       //字符个数 	for (int i = 0; i < n; i++) 	{ 		switch (a[i]) 		{ 		case 'c': 		case 'C': 			printf("BEIJING OLYMPIC GAMES\n"); break; 		case 'j': 		case 'J': 			printf("JAPAN WORLD CUP\n"); break; 		case 'k': 		case 'K': 			printf("KOREA WORLD CUP\n"); break; 		default: 			printf("%c\n", a[i]); 			break; 		} 	} }  int main() { 	char str[100]; 	gets(str);      //输入字符串（字符数组） 	Change(str);    //调用定义好的操作函数 	system("pause"); }


Question: C语言编程

不好意思，二月需要计算

每一年的固定月天数是固定的


Question: 一个关于C语言链表的问题,求大神赐教啊

if(!p0)         {             printf("error-----------------");         } 这个地方是不是有问题呢，如果p0==NULL了，这个逻辑是输出提示错误的语句，然后继续向后执行了，后面对p0的操作就会导致段错误。所以这个地方需要改一下： if(!p0)         {             printf("error-----------------");             return head;         }  另外，每行的字节数建议限制在80个字符左右，多了代码可读性就会大大折扣了。

extern struct Book *insert(struct Book *head, struct Book *book)   //按ISBN号顺序插入 { 	struct Book *p0, *p1, *p2 = NULL;//添加了p2的初始值 } VS2015，C++调试环境

struct Book *insert(struct Book *head, struct Book *book)   //按ISBN号顺序插入 {     struct Book *p0, *p1, *p2;     p1 = head;     p0 = book;     if(head == NULL)     {         head = p0;         p0->next = NULL;     }     else     {         while(strcmp(p0->ISBN,p1->ISBN)>0&&(p1->next!=NULL))         {             p2=p1;             p1=p1->next;         }         if(strcmp(p0->ISBN,p1->ISBN)<=0)         {             if (head == p1) {                 p0->next = p1;                 head = p0;             } else {                 p0->next = p2->next;                 p2->next = p0;             }             /*             if(head==p1)head=p0;             else p2->next=p0;             p0->next=p1;             */         }         else         {             p1->next=p0;             p0->next=NULL;         }     }     return head; }  插入函数做了修改，可以试一下。

bool CheckDay(int year, int month, int day) {     bool leap = false, rt_val = false;   //初始化leap       if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)         leap = true;       switch (month) {         case 1:         case 3:         case 5:         case 7:         case 8:         case 10:         case 12:             if (day <= 31)                 rt_val = true;             break;           case 4:         case 6:         case 9:         case 11:             if (day <= 30)                 rt_val = true;             break;           case 2:             if (leap && day <= 29)                 rt_val = true;             if (!leap && day <= 28)                 rt_val = true;     }       return rt_val; } 上面的代码有个小问题，看一下这个。

bool CheckDay(int year, int month, int day)                   //检查日格式 {     if(day>=1&&day<=28) return true;     else if(month==1||month==3||month==5||month==7||month==8||month==10||month==12)     {         if(day<=31) return true;     }     else if(month==4||month==6||month==9||month==11)     {         if(day<=30) return true;     }     else if(month==2)     {         if(year%4==0&&day<=29) return true;         else return false;     }     else return false;     return false; }  bool CheckDay(int year, int month, int day) {     bool leap, rt_val = false;      if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)         leap = true;      switch (month) {         case 1:         case 3:         case 5:         case 7:         case 8:         case 10:         case 12:             if (day <= 31)                 rt_val = true;             break;          case 4:         case 6:         case 9:         case 11:             if (day <= 30)                 rt_val = true;             break;          case 2:             if (leap && day <= 29)                 rt_val = true;             if (!leap && day <= 28)                 rt_val = true;     }      return rt_val; } 对比一下同一个函数两个不同写法。

贴图党真懒得帮你看。 程序崩溃至少自己调试下死在哪一行啊？ windows上VS，linux上gdb 运行下就会自动挂在崩溃行上


Question: 大佬们帮忙看一下c的文件读入哪里错了

现象是什么？可以通过添加printf输出信息，看一下执行到哪里出的问题。

救救孩子啊啊啊啊啊啊啊啊啊啊啊啊啊

来个大神吧拜托了啊啊

就差一个文件读取了 实在找不出哪里错了


Question: 输出两个正整数之间的所有素数

#include <stdio.h> int main() {     int m, n, i, j;     int k;     printf("输入两个整数：");     scanf("%d%d", &m, &n);      // 这里是做一个循环，遍历你输入的两个整数之间的所有整数     for(i = m; i <= n; i++)     {         // k用来判断是否为素数， 如果 k > 0，说明当前的整数不是素数         k = 0;          // 这个循环是判断当前整数是否为素数，从2开始一直到小于当前数的最大整数         // 我想什么是素数你应该知道的吧         for(j = 2; j < i; j++)         {             // 这里是将当前判断的数分别比它小的整数取余数，如果正好整除，             //说明当前判断的整数不是素数             if(i%j == 0)             {                 k++;                 // 这里最好是添加一个break，这样的话，如果不是素数，当前循环终止，                 //判断下一个数书否为素数                 break;             }          }          // 如果k == 0 说明当前整数数个素数，然后输出         if(k == 0)         {             printf("%d\n", i);         }     }      return 0; }

首先明白素数的定义，第二个for循环是来检验这个数除自身以外是否有其它整除，如果有k＋＋，到循环结束，如果k＝＝0，说明除自身以外没有其它整除的数，这个数是素数，否则就不是


Question: C语言基础问题在线求助！求各位大佬救救孩子吧，看看到底是哪里出了问题

引用 2 楼 自信男孩的回复:#include<stdio.h>  #define N 20  void bubblesort(int a[],int n) {     int i,j,t;     //for(i=1;i<n;i++)     for(i=0;i<n;i++)     {         //for(j=0;j<n-i;j++)         for(j=0;j<n-i-1;j++)         {             if(a[j]>a[j+1])             {                 t=a[j];                 a[j]=a[j+1];                 a[j+1]=t;             }          }     } }   int merge_array(int *data1, int n1, int *data2, int n2, int *data3) {     int i, j, k;      i = j = k = 0;     while (i < n1 && j < n2) {         if (data1[i] < data2[j]) {             data3[k] = data1[i];             k++;             i++;         } else if (data1[i] == data2[j]) {             data3[k] = data1[i];             k++;             i++;             j++;         } else {             data3[k] = data2[j];             k++;             j++;         }     }     while (i < n1) {             data3[k] = data1[i];             k++;             i++;     }     while (j < n2) {             data3[k] = data2[j];             k++;             j++;     }      return k; }  int main() {     int data1[N],data2[N],n1,n2,n3,i,j,k;     //int data3[N];     int data3[N * 2];     scanf("%d",&n1);     if (n1 > N)         n1 = N;     for(i=0;i<n1;i++)     {         scanf("%d",&data1[i]);     }     scanf("%d",&n2);     if (n2 > N)         n2 = N;     for(i=0;i<n2;i++)     {         scanf("%d",&data2[i]);     }      bubblesort(data1,n1);     bubblesort(data2,n2);      n3 = merge_array(data1, n1, data2, n2, data3);  /*     for(i=0;i<n1;i++)     {         data3[i]=data1[i];     }     for(j=n1;j<n3;j++)     {         k=j-n1;         data3[j]=data2[k];     } */     for(i=0;i<n3;i++)     {         printf("%d ",data3[i]);     }     putchar(10);     return 0; }  供参考～  建议对比自己的代码找一下每个修改之处自己的问题。 谢谢我认真看过了，你真是太厉害啦

两个问题: 1.n3应该在输入n1.n2之后再赋值 2.数组date3没有进行去重和排序


Question: 关于%s的一个问题

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.

scanf("%s%s", ch1, ch2);   你会发现使用空格分割输入或者使用回车分割输入都是一样的  只有 %s 才能这样！

修改答案  ---  是 %s 不会读取空格，也就是说遇到空格结束读取，如果遇到回车则忽略  若 %c 则会读取到回车

b读入换行符然后输出空格 > 为什么会输出空格呢？不应该输出回车吗？  scanf 不会读取空格，也就是说遇到空格结束读取，  所以   %s 消耗 "ac"  %c 消耗 " "  %c 消耗 "c"   所以 printf 打印 "c"

引用 3 楼 提及 的回复:原理？？？  你需要什么样的原理  这是别人设计好的  因为字符串就是最后一个元素为 \0 的字符数组  回车键是用来结束输入的  使用 %s 遇到回车结束输入，回车不做为结果，回车符保存在输入缓冲区，等待下一次读取 并且在输入的字符串后面追加 \0  > 只有字符数组最后一个元素是 \0 才能将其称作字符串，否则就是字符数组  所以在使用的时候，就需要填写 <数组大小-1> 的最大域宽，做好安全工作   如果你想使用 %s 将读取的内容作为字符数组的话，不可以  但你可以使用 %<number>c  将读取的内容作为字符数组。只需限定域宽，不会追加 \0不好意思，之前那个测试函数不用看了我傻了。。 其实问题的起因是我看到一段代码这样实现了一个由字符组成地图的输入,但是现在原理我是清楚了但是还是不懂下面这段为啥不用getchar掉换行符                 char map[2][12][12] ; 		for (i=0; i<2; i++)  			for (j=0; j<12; j++)  				scanf("%s", map[i][j]);

引用 3 楼 提及 的回复:原理？？？  你需要什么样的原理  这是别人设计好的  因为字符串就是最后一个元素为 \0 的字符数组  回车键是用来结束输入的  使用 %s 遇到回车结束输入，回车不做为结果，回车符保存在输入缓冲区，等待下一次读取 并且在输入的字符串后面追加 将其需要填写 <数组大小-1> 的最大域宽， 如果你想使用 %s 将读取的内容作为字符数组的话，不可以 组。只需限定域宽，不会追加 \0 quote]  [quote=引用 3 楼 提及 的回复:] 原理？？？  你需要什么样的原理  这是别人设计好的  因为字符串就是最后一个元素为 \0 的字符数组  回车键是用来结束输入的  使用 %s 遇到回车结束输入，回车不做为结果，回车符保存在输入缓冲区，等待下一次读取 并且在输入的字符串后面追加 \0  > 只有字符数组最后一个元素是 \0 才能将其称作字符串，否则就是字符数组  所以在使用的时候，就需要填写 <数组大小-1> 的最大域宽，做好安全工作   如果你想使用 %s 将读取的内容作为字符数组的话，不可以  但你可以使用 %<number>c  将读取的内容作为字符数组。只需限定域宽，不会追加 \0那请问下面这段简单的代码 我输入ac c为啥是输出c呢 按道理不应该b读入换行符然后输出空格吗 #include <iostream> #include <stdio.h> using namespace std;  int main() {   char a[50],b;     scanf("%s",a);     scanf("%c",&b);     b=getchar();     printf("%c",b);     return 0; }

标准输入是属于行缓冲的，因此需要输入回车才能将输入的内容刷到内存（在这之前是输入的内容在输入缓存里）

引用 1 楼 提及的回复:自己测试一下不就知道了   我自己试过了换行符貌似它直接帮你去掉了，但是不清楚原理

自己测试一下不就知道了


Question: 大一学生，请教各位大佬，为什么此程序输出时总是-1IND00，该怎么解决？

已经发现问题了，一个是第一个for语句t的范围弄错，还有一个就是您所说的赋值的问题。

引用 1 楼 jsx_SEVEN的回复:t应该给个初始值，我这边显示：使用了未初始化的局部变量。写点注释 其实我是想编一个用泰勒公式求sin(x)的程序，除了初始赋值出了点问题，估计还有其它问题我没有看出来

t应该给个初始值，我这边显示：使用了未初始化的局部变量。写点注释


Question: 大佬们看一看，为啥我运行之后啥也没有

死循环了，while (1 <= 100)，改成while (i <= 100)再试试～

函数 hhh 里面的 while 是死循环吧 ？ 这图片里面的条纹太亮瞎眼了，看得视神经疼！ while(1 <= 100){} 的循环判断条件是 圆括号里的 「 （数字 1 ）1 <= 100」，这个条件永远成立，所以 while 循环一直执行。  程序一直在执行这个 while 循环 ，当然没有输出了。 你的初衷应该是写成 字母 i <= 100 吧？ 改一下再运行。


Question: C语言，小白请教各位大神…

vs2015,中的编译库才是正确的、平板上编译器不标准

第一个是赋值表达式，输出的是真假，非0为真。

之前写错了，答案合适呢 [图片]

003F18E3  mov         edx,dword ptr [ebp-0ECh]   003F18E9  push        edx   003F18EA  mov         eax,dword ptr [ebp-0F0h]   003F18F0  push        eax   003F18F1  mov         ecx,dword ptr [x]   003F18F4  push        ecx   003F18F5  mov         edx,dword ptr [x]   003F18F8  push        edx   003F18F9  push        offset string "%d,%d,%d,%d\n" (03F7B30h)   003F18FE  call        _printf (03F104Bh)   003F1903  add         esp,14h   这一部分是调用printf函数对应的汇编，可以看到push了四个值，以及一个字符串进去，这里的四个值里面的后面两个push都是[x]，也就是都是推入的x的值，而x在经过前面的计算后，值是30，所以入栈的四个值就是0，0，30，30

VS2017，结果是30，30，0，0，我用汇编调试了一下，发现是这样的，printf()，这个语句，先是计算后面四个算式，而且从右往左计算，第三个和第四个好理解，结果就是0，第二个式子的结果不重要，重要的是，经过这个计算后，printf里面对应的第二个%d对应的值是在x这个变量里面，注意，这个时候，x=1，但是并没有将这个结果1显示出来；然后，计算第一个式子，结果是x=30，同时printf里面对应的第一个%d对应的值也是是在x中国变量里面。 计算完成后是显示过程，在调用pritf函数的时候，传入的四个%d对应的值，就是0，0，x的值，x的值(右往左传递)，所以，对应显示到屏幕上，就是30，30，0，0.

这种未定义的行为就不应该出现

这个是我自己的理解，要是你查到了更权威的解释，麻烦分享给我， 我用的是VS2017，运行结果是30,30,0,0 我测试了一下，有一种解释：不同编译器，编译器版本不同，它们的prinf（）的计算和打印的顺序不同。 我看前面的好像有4种答案：30,1,0,1；1,1,0,1；30,30,0,0；30,1,0,0。 ①30,1,0,1 这个应该是心里算的答案，从左往右，计算一个打印一个。（可以想象成计算完后放入了某个空间，后面的计算会修改变量的值，但没有修改放在这里准备打印的值） ②1,1,0,1 这个应该是从左往右计算完每个表达式（30,1,0,1），然后从右往左打印，打印完后面三个后x=y==z把x改成了1，再打印第一个的时候，x被改成了1.所以打印出了1。 ③30,30,0,0 这个应该是从右往左计算完每个表达式（30,1,0,0），然后从左往右打印，计算完后第一个表达式x=y=z把x改成了30,打印到x=(y==z)时，x就成了30。 ④30,1,0,0 这个应该是从右往左计算，计算一个打印一个。

看不明白  太深了 ~

这种应该类似i=i++这种，不同编译器处理方式不同，应量避免使用

这个太专业了

应该是判断吧

不会是敲错了吧

从左向右是30 1 0 1  从右向左是30 30 0 0

引用 6 楼 hitzsf的回复:vs2017，cb 都是：30,30,0,0 编译器的问题？我第一次在平板上用mobie C编译运行真的是1 1 0 1，然后后来用dev c++ 5.11在电脑上试了一次，是 30 30 0 0；但是还是不懂为什么第二个运行结果也是30，关系运算符==优先级不是应该高于赋值运算符吗？那x=y==z为什么会等于30呢？

vs2017，cb 都是：30,30,0,0

仔细检查你的代码和题目一样吗

答案错了吧，不管从函数从右往左还是从左往右传参数，x=y=z的结果都是30啊，因为执行这个表达式之前z都没变过。

引用 1 楼 focuslight的回复:VS 下运行结果是 30,1,0,0  printf 从右向左运算 但是我用软件运行的结果是：1，1，0，1；很纳闷为啥呀

但是我用软件运行的结果是：1，1，0，1；很纳闷为啥呀


Question: 函数求和

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

不知这个题目来源于哪，题干的叙述个人认为很不C/C++。C/C++中个人认为不存在所谓“子函数”的概念，更别提多少层子函数。C/C++中所有的函数是平行的，不存在嵌套定义的函数。当然，国内有C/C++的书中有“子函数”的提法，但本人不愿接受。 仅个人观点，不争论，不讨论。

从1到100累加求和，用函数表示，计算机程序

楼主描述中的“第一层”和“第二层”是什么意思？

引用 3 楼 qq_44826458 的回复:谢谢，这个程序和我的问题有出出，不对哦 不知道你回答的哪个人，我的测试结果是如题意的，有可能是你自己阐述出错

#include <stdio.h> float addition(int x); float division (int i); int main(int argc, char *argv[]) {     int num;     printf("请输入一个整数：\r\n");     scanf("%d", &num);     printf("%f\r\n", addition(num));     getchar();     return 0; } float addition(int x) {     int i;     float sum = 0.0;     for(i = 1; i <= x; i += 2)     {         sum += division(i);         printf("sum=%f\n", sum);     }     return sum; } float division (int i) {     static x = 1;     if (x == 1)     {         x = 0;         return 1.0 / i;     }     else     {         x = 1;         return -(1.0 / i);      } }

谢谢，这个程序和我的问题有出出，不对哦

#include <stdio.h> double div (int i) { 	return 1.0 / ( 2 * i - 1 ); } double total (int n) { 	double sum = 0; 	int sign = 1; 	for ( int i = 1; i <= n; i++, sign *= -1 ) { 		sum += div (i)*sign; 	}//end for 	return sum; } main ( ) { 	int x = 100; 	double result; 	result = total (x); 	printf ("%lf\n", result); }

#include "stdio.h" int main( void ) { 	int x=0, i=0 , flag=1; 	double sum=0; 	scanf("%d",&x); 	for( i=1 ; i<=x ; i++ ) 	{ 		sum+=flag * (1.0/(2*i-1)); 		flag=-flag; 	} 	printf("%g",sum); 	return 0;	 }


Question: 已触发了一个断点


Question: 小白VC6.0运行出错

这个问题好像是缺少sp6造成的，试试

缺少 #include "stdafx.h"  ？？？？？

执行link.exe时出错


Question: A+B问题

#include <stdio.h> int main ( ) { 	int a, b, n; 	scanf ("%d", &a); 	scanf ("%d", &b); 	n = a + b; 	printf ("%d\n", n); 	return 0; }

如果是求n个数的和，你的程序是可以的，只是输入数字的时候，数字之间应是空格而不能用逗号

scanf("%d %d",&a, &b); printf("%d", a+b);

你写的是平均值呀  题目没要求多次输出数据  n是多余的


Question: C语言for循环失效，什么问题，怎么解决？

引用 1 楼 user-1的回复:if(flag==1)	 {	 printf("%d%c%d=%d\n",x,op,y,z);	 break;	 }	 --> if(flag==1)	 {	 printf("%d%c%d=%d\n",x,op,y,z);	 //break;	 }	  你这里的break直接跳出for循环了，还有op=getchar()后最好再加上一个getchar()吸收回车符。 记得结贴：） 谢谢！你的答案回答到点子上了，非常有用


Question: 翻牌问题

仅供参考，输入输出需要按照题设要求改改： #include <stdio.h> #include <stdlib.h>  typedef struct tag_list_node {     void *next;     int num; }list_node_s;  void display_list(list_node_s* head) {          if (NULL == head)     {         return;     }          list_node_s *cur = head;     printf("list member:");     while(cur != NULL)     {         printf(" %d", cur->num);         cur = cur->next;     }     printf("\n"); }  list_node_s* init_list(int num) {     list_node_s *head;     list_node_s *cur;     list_node_s *next;     int i;          head = (list_node_s *)malloc(sizeof(list_node_s));     head->num = 1;     head->next = NULL;          cur = head;     for (i = 2; i <= num; i++)     {         next = (list_node_s *)malloc(sizeof(list_node_s));         next->num = i;         cur->next = next;         cur = next;     }          cur->next = NULL;      display_list(head);      return head;     }   list_node_s* remove_node_from_list_head(list_node_s* head) {     if (NULL == head || NULL == head->next)     {         return NULL;     }          list_node_s *new_head = head->next;     free(head);     return new_head; }  void insert_node_from_list_tail(list_node_s* head, int num) {     list_node_s *cur = head;     list_node_s *node;          while (cur->next != NULL)     {         cur = cur->next;     }          node = (list_node_s *)malloc(sizeof(list_node_s));     node->num = num;     node->next = NULL;     cur->next = node; }  int list_proc(list_node_s* head) {     list_node_s *cur_head = head;          while (cur_head->next != NULL)     {         cur_head = remove_node_from_list_head(cur_head);         insert_node_from_list_tail(cur_head, cur_head->num);         cur_head = remove_node_from_list_head(cur_head);         display_list(cur_head);     }          return cur_head->num; }  int main() {     list_node_s *head;     int num;     int last_num;          scanf("%d", &num);     head = init_list(num);     last_num = list_proc(head);     printf("%d\n", last_num);          return 0; }

不难吧，用个链表数据结构就能做啊

#include <stdio.h>  int main() {   int T, n, x, y;    scanf("%d", &T);   while (T--)   {     scanf("%d", &n);     if (y = 0, (x = n) == 1) puts("1");     else     {       while (x > (1 << y)) x -= (1 << y++);       printf("%d\n", x != 1 ? (x - 1) * 2 : n);     }   }    return 0; }

这题可以直接计算：


Question: 如何解决两个头文件中函数名相同问题？

限定文件作用域

改名最稳妥.

C++用命令空间解决，C语言应该搞不定，编译都会有问题。

static限定为文件作用域，定义两个指针，通过指针调用函数。

基本上只能改名字,让它们不一样 C语言里面也没命名空间的概念 当然可以强行用c++来编译

要么改了其中一个文件里的函数名，两个文件对外的接口如果是相同的函数名那么肯定是不行的。如果两个函数名一样，但是一个对内，一个对外，那么对内的可以加上static，头文件里就不要声明对内的函数了。


Question: C语言

#include <stdio.h>  int main() {     int i;     int ROW = 10;     while(ROW > 0)     {         for(i = 0; i < ROW; i++)         {             printf("*");         }         printf("\n");          ROW--;     }     return 0; }


Question: 求求各位大佬教教我！文件指针错误的问题

贴出代码，另外，文件指针在获取到打开之后要判断文件是否打开成功


Question: 大神帮忙

看看运算符优先级

引用 1 楼 focuslight 的回复:if((p=fopen("f:\\aa\\w1.txt", w))==NULL)  改成这样试试 不要乱教啊，，，，，


Question: 我的服务端和客户端怎么了

引用 2 楼 user-2的回复:贴源码出来，我跑下试试 应该是send里面strlen的问题

引用 3 楼 自信男孩的回复:客户端send函数里，为什么send的长度是sizeof(sendBuf) + 1个长度，应该是strlen(sendBuf) + 1吧 对对对，我蠢了，谢谢老哥

sizeof(sendBuf)+1，发送的字节数到对端已经越界了，看到你的服务器接收也是128个字节，但是客户端发了129个字节。

贴源码出来，我跑下试试

呜呜呜呜，我给你们劈个叉，你们救救我吧


Question: 控件是子窗口吗？为什么QQ的搜索栏或按钮没有窗口句柄？

引用 6 楼 六道佩恩 的回复:[quote=引用 5 楼 stherix 的回复:] QQ的控件基本是自绘的 也就是非win控件,没有句柄的 但是QQ留了一个IAccessible接口用于获取 https://www.cnblogs.com/SadlyCodes/p/3472406.html 是用的windows自带的那些绘图函数吗？[/quote]  这个不清楚 GDI+,opengl,directx都有可能

引用 5 楼 stherix 的回复:QQ的控件基本是自绘的 也就是非win控件,没有句柄的 但是QQ留了一个IAccessible接口用于获取 https://www.cnblogs.com/SadlyCodes/p/3472406.html 是用的windows自带的那些绘图函数吗？

引用 3 楼 六道佩恩 的回复:[quote=引用 2 楼 zuoziyang521 的回复:]  请问楼主还有下载tanzhou---js视频嘛，同求方便的话请加QQ754925743，谢谢，借贴回复，实属抱歉 https://pan.baidu.com/s/1IMZ1OtgjqIMa0-elNYgiYw am32[/quote] 谢谢博主

引用 8 楼 六道佩恩 的回复:[quote=引用 7 楼 stherix 的回复:] [quote=引用 6 楼 六道佩恩 的回复:] [quote=引用 5 楼 stherix 的回复:] QQ的控件基本是自绘的 也就是非win控件,没有句柄的 但是QQ留了一个IAccessible接口用于获取 https://www.cnblogs.com/SadlyCodes/p/3472406.html 是用的windows自带的那些绘图函数吗？[/quote]  这个不清楚 GDI+,opengl,directx都有可能[/quote] 理论上这些库不都是调用Win API实现的吗？[/quote] opengl,directx 这个应该不算win api

引用 7 楼 stherix 的回复:[quote=引用 6 楼 六道佩恩 的回复:] [quote=引用 5 楼 stherix 的回复:] QQ的控件基本是自绘的 也就是非win控件,没有句柄的 但是QQ留了一个IAccessible接口用于获取 https://www.cnblogs.com/SadlyCodes/p/3472406.html 是用的windows自带的那些绘图函数吗？[/quote]  这个不清楚 GDI+,opengl,directx都有可能[/quote] 理论上这些库不都是调用Win API实现的吗？

引用 2 楼 zuoziyang521 的回复: 请问楼主还有下载tanzhou---js视频嘛，同求方便的话请加QQ754925743，谢谢，借贴回复，实属抱歉 https://pan.baidu.com/s/1IMZ1OtgjqIMa0-elNYgiYw am32

纯自绘也未尝不可。


Question: 如何通过C来实现128位的RSA加密和DES加密？

百度！！！！！！！！！！！！！！！！！！


Question: 两台电脑用+Ubantu显示不同路由

引用 3 楼 user-1_16_com 的回复:你的虚拟机网段跟PC都处于同一个网段的话，可以关闭PC机的防火墙试试。 桥接之后没有设置成同一个IP。。。。

是否需要一个交换机 还是把笔记本再插一根网线？

你的虚拟机网段跟PC都处于同一个网段的话，可以关闭PC机的防火墙试试。

看IP地址的话都是192.168.15.2网段的 但是两台设备在Ubantu里面就是ping不通 相互连接的时候显示不在同一个路由


Question: C语言，堆排序的代码运行显示“heapsort”: 找不到标识符，是什么问题？

先声明后使用 或者把被调用函数放在调用函数之前

#include <stdio.h> #include<stdlib.h>  #define N 14 typedef int KeyType; typedef int InfoType; typedef int SeqList;  typedef struct {     KeyType key;     InfoType otherinfo; }RecType;  void build_max_heap(RecType  R[],int n);  //建大根堆算法 void heapsort(RecType  R[], int n);   //堆排序的算法 //void main() int main() {     int i,n;     RecType R[N];     printf("请输入将要排序元素的个数:");     scanf("%d", &n);     printf("\n");     for(i=0; i < n; i++)     {         printf("请输入第%d个数为：",i+1);         scanf("%d",&R[i].key);         scanf("%d",&R[i].otherinfo);     }     printf("排序前的数据:\n");  //打印排序前的数据     for (int i = 0; i < n; i++)     {         printf("%d ",R[i].key);         printf("%d ",R[i].otherinfo);     }     heapsort(R, n);     printf("\n排序后的数据:\n"); //打印排序后的数据     for (i = 0;i < n;i++) {         printf("%d  ",R[i].key);         printf("%d  ",R[i].otherinfo);     }     printf("\n");     system("pause"); } void max_heapify(RecType  R[],int k,int m)             //用筛选法调整堆 {     RecType t;     int i,j,x;      t=R[k];     x=R[k].key;     i=k;     j=2*i;     while(j<=m)     {         if (j<m && R[j].key<R[j+1].key)             j=j+1;         if(x<R[j].key)         {             R[i]=R[j];             i=j;             j=2*i;         }         else             break;     }     R[i]=t;  } void build_max_heap(RecType  R[],int n)  //建大根堆算法 {     int i;      for (i = n/2;i >= 1;i--)         max_heapify(R,i,n); }  void heapsort(RecType  R[], int n)   //堆排序的算法 {      //int i,n;     int i;      build_max_heap(R,n);     for (i = n;i >1;i--)     {         R[0] = R[1];         R[1] = R[i];         R[i] = R[0];         max_heapify(R,1,i-1);     } } 供参考！  解决了大部分问题，但是你的算法有问题（为仔细看，没有解决），建议你还是在梳理一下算法 但从这个error描述来讲，就是没有在调用前声明该函数导致的。把函数声明放到main函数前就可以了。 但是有个其他问题，你见过scanf输入一个结构体的吗？  heapsort中n是局部变量，并且是一个随机值，直接传到build_max_heap(R,n);里，肯定会导致越界。


Question: 关于进栈问题的提问

这个栈中节点有两个元素，一个是该元素的值，一个是指向下一个值的地址，方便找到下一个元素。这里s->next应该是空，null。表示这个是栈的最后一个元素temp->next=s->next和前一行是设置这个要插入进去的元素的值和他的下一个元素的地址，s->next=temp是将temp链接到栈后面，s的下一个元素指向的是temp表示插入了一个元素。

链表的定义中，Next的属性就是本身Stack, 所以s-Next=Temp,是指将新增的Temp链到S后面去。

这是在链表队列的末尾再添加一个元素


Question: 急求！！有序链表合并

可以看看我博客中一些数据结构的实现，有应该有链表

先自己写写，遇到问题再提出来吧


Question: 各位大神，小弟又有一个关于结构体指针强转的问题想要请教一下

引用 7 楼 lin5161678 的回复:[quote=引用 6 楼 ze_hit 的回复:] [quote=引用 5 楼 lin5161678 的回复:] 你的顾虑的确是合理的 的确可能存在因为不对齐造成错误的可能性  所以 那段代码 要么就是通过其他手法设置了对齐  比如pack(4) 而你没注意 要么就是只能部署到特定平台  谢谢您的回答，我还有一个问题想请教一下。如果上面的代码中，假设buff是发送缓冲区，我对B结构体指针不使用强制转换，而是采用以下方式：  B bs; bs.b1... ; bs.b2...;     //填写和修改bs memcpy(buff + sizeof(A), &bs, sizeof(B)); XXXXXXXX buff;     //将buff发送给接收方  而在接收方，也不采用直接强制转换的方式取出结构体的内容，而是采用下面的方式：  char recv[1024] = {0};   //定义接收缓冲区 XXXXXXXX recv；  //  将数据接收到缓冲区中 B rs； memcpy(&B, recv + sizeof(A), sizeof(B)); rs.b1...; rs.b2...;    //读取接收到的B结构体内容  使用这种方式是不是就可以从根本上解决我之前提出的问题，从而实现无需指定对齐方式的情况下跨平台移植呢？[/quote]  单纯讨论 写入缓冲区 和 从缓冲区读数据  的确从解决之前的问题(内存没对齐) 实现跨平台 但需要注意 因为跨平台 你发送和接受的环境中 sizeof(A) 不保证一样大 同理sizeof(B) 也不保证一样大 略有瑕疵[/quote] 谢谢您，是我表述有误，我本意是指发送和接收方具有相同平台，而这段代码在不同平台上跑。

引用 6 楼 ze_hit 的回复:[quote=引用 5 楼 lin5161678 的回复:] 你的顾虑的确是合理的 的确可能存在因为不对齐造成错误的可能性  所以 那段代码 要么就是通过其他手法设置了对齐  比如pack(4) 而你没注意 要么就是只能部署到特定平台  谢谢您的回答，我还有一个问题想请教一下。如果上面的代码中，假设buff是发送缓冲区，我对B结构体指针不使用强制转换，而是采用以下方式：  B bs; bs.b1... ; bs.b2...;     //填写和修改bs memcpy(buff + sizeof(A), &bs, sizeof(B)); XXXXXXXX buff;     //将buff发送给接收方  而在接收方，也不采用直接强制转换的方式取出结构体的内容，而是采用下面的方式：  char recv[1024] = {0};   //定义接收缓冲区 XXXXXXXX recv；  //  将数据接收到缓冲区中 B rs； memcpy(&B, recv + sizeof(A), sizeof(B)); rs.b1...; rs.b2...;    //读取接收到的B结构体内容  使用这种方式是不是就可以从根本上解决我之前提出的问题，从而实现无需指定对齐方式的情况下跨平台移植呢？[/quote]  单纯讨论 写入缓冲区 和 从缓冲区读数据  的确从解决之前的问题(内存没对齐) 实现跨平台 但需要注意 因为跨平台 你发送和接受的环境中 sizeof(A) 不保证一样大 同理sizeof(B) 也不保证一样大 略有瑕疵

引用 5 楼 lin5161678 的回复:你的顾虑的确是合理的 的确可能存在因为不对齐造成错误的可能性  所以 那段代码 要么就是通过其他手法设置了对齐  比如pack(4) 而你没注意 要么就是只能部署到特定平台  谢谢您的回答，我还有一个问题想请教一下。如果上面的代码中，假设buff是发送缓冲区，我对B结构体指针不使用强制转换，而是采用以下方式：  B bs; bs.b1... ; bs.b2...;     //填写和修改bs memcpy(buff + sizeof(A), &bs, sizeof(B)); XXXXXXXX buff;     //将buff发送给接收方  而在接收方，也不采用直接强制转换的方式取出结构体的内容，而是采用下面的方式：  char recv[1024] = {0};   //定义接收缓冲区 XXXXXXXX recv；  //  将数据接收到缓冲区中 B rs； memcpy(&B, recv + sizeof(A), sizeof(B)); rs.b1...; rs.b2...;    //读取接收到的B结构体内容  使用这种方式是不是就可以从根本上解决我之前提出的问题，从而实现无需指定对齐方式的情况下跨平台移植呢？

`B* b = (B*) (buff +sizeof(A));`感觉这种写法与`B* b = p`这个写法并没有什么不同，个人理解是4字节对齐可能是快一点，但是这种告诉你一个不是4字节对齐的地址，也会按照字节序得到想要数据的

引用 1 楼 user-4 的回复:这样访问根本不会有问题，只是这么写的话对性能会有点影响罢了。 如果要避免这种问题，直接用4字节对齐的方式不就好了？  在x86上我试过，确实不会出错，但是好像ARM和SPARC非对齐访问是不允许的吧！

可以对A强制4字节对齐，pack(4)


Question: 关于运算符优先级的问题。

引用 1 楼 下雨听风人的回复:在表达式b = !(x+1>0)&&y++||++z;中 优先级排序如下 () ++ ! + > && || = ++既然比逻辑与的优先级要高，为什么输出显示y的自增并没有运行呢？ y的结果为0. 因为!(x+1)为0不会在进行&后面的做算了 相当于!(x+1)｜|++z

如果不确定优先级，建议用括号来确定你想要的优先级。

b = !(x+1>0)&&y++||++z; 我感觉可能是这样  这里既然赋值的优先级最低  那么久限制性赋值的右侧表达式 右侧表达式中||的优先级最低  那就先看 ||的左侧表达式  左侧中逻辑与的优先级最低 那就先看 逻辑与的表达式 不知道这么想对不对

优先级保证的是执行!(x+1>0)&&(y++)，而不是执行(!(x+1>0)&&y)++ 并不是一条语句里的++必须都在&&之前执行

优先级高 不等于先算 计算顺序和优先级无关


Question: C语言代码优化问题？以下代码哪里有问题欢迎讨论。小白问题。

动态分配的，和局部有什么关系?

“sndkkek”  （）/

这期的时候就可以了

个人建议，char a[]------->string                   数组---------->vector 我写的代码不好，那就用那些牛人写的代码吧

C语言代码优化 有多个 级别， 你 反汇编 一下 看看， 是 怎么优化的

严重错误：返回局部变量的指针  memcpy，memncpy这两个函数可以连接下

引用 12 楼 lin5161678 的回复:[quote=引用 11 楼 stherix 的回复:] char s[50]="\0";    //这个不能保证字符串s末尾有'\0'  这个不用谈了你还是谈谈吧  能还是不能  让我见识一下基础差的同学是怎么理解代码的  //s = "\0";   //这个地方是一个严重错误，导致内存泄露，因为s从堆上申请的空间，     //比如首地址是：0x001, s = "\0"这条语句就让s指向的"\0"字符串常量的地址，比如是0xff2，那么0x001的的地址就找不到，会导致内存泄露我也没说这段话说错 这不是给了 33.3分了么 全部是这段话的得分 [/quote]  我有点地方没看,对此抱歉 因为我只看了他的回复,没看他的代码注释 原作者代码严重问题主要是在函数里返回局部变量的值和改变了申请内存的指针  你说他的注释基本是错的,我就认为你说他的观点基本是错的 然而你又只引用了一处

你这不是代码优化，而是代码找茬，三个函数都有严重错误。

引用 11 楼 stherix 的回复: char s[50]="\0";    //这个不能保证字符串s末尾有'\0'  这个不用谈了你还是谈谈吧  能还是不能  让我见识一下基础差的同学是怎么理解代码的  //s = "\0";   //这个地方是一个严重错误，导致内存泄露，因为s从堆上申请的空间，     //比如首地址是：0x001, s = "\0"这条语句就让s指向的"\0"字符串常量的地址，比如是0xff2，那么0x001的的地址就找不到，会导致内存泄露我也没说这段话说错 这不是给了 33.3分了么 全部是这段话的得分

引用 10 楼 lin5161678 的回复:[quote=引用 9 楼 stherix 的回复:] [quote=引用 8 楼 lin5161678 的回复:] 你加的注释基本写错了 引用 8 楼 lin5161678 的回复:char s[50]="\0";    //这个不能保证字符串s末尾有'\0' 的确保证了 50个字节全部是 0  不要抬杠,自己看你自己的原话,和你引用的东西[/quote]他给3个函数加了注释 结果只有最后一个函数的注释算说对  2/3说错 评价基本写错有什么不对?? 还得定量吗? 那就33.3分[/quote] 看你回了这么多的份上 我来一条一条给你解释吧  char s[50]="\0";    //这个不能保证字符串s末尾有'\0'  这个不用谈了 static char s[50]="\0";//这个不能保证字符串s末尾有'\0'   这个是保证可以为\0的,但是你引用的是上一条 //s = "\0";   //这个地方是一个严重错误，导致内存泄露，因为s从堆上申请的空间，     //比如首地址是：0x001, s = "\0"这条语句就让s指向的"\0"字符串常量的地址，比如是0xff2，那么0x001的的地址就找不到，会导致内存泄露  的确是严重错误,申请了内存,有把指针指向了其他地址,导致申请的内存永远也无法释放,更严重的是,他以为新指向的地址是内存分配过的 之后会导致可能应用程序崩溃

引用 9 楼 stherix 的回复:[quote=引用 8 楼 lin5161678 的回复:] 你加的注释基本写错了 引用 8 楼 lin5161678 的回复:char s[50]="\0";    //这个不能保证字符串s末尾有'\0' 的确保证了 50个字节全部是 0  不要抬杠,自己看你自己的原话,和你引用的东西[/quote]他给3个函数加了注释 结果只有最后一个函数的注释算说对  2/3说错 评价基本写错有什么不对?? 还得定量吗? 那就33.3分

引用 8 楼 lin5161678 的回复:你加的注释基本写错了 引用 8 楼 lin5161678 的回复:char s[50]="\0";    //这个不能保证字符串s末尾有'\0' 的确保证了 50个字节全部是 0  不要抬杠,自己看你自己的原话,和你引用的东西

引用 5 楼 stherix 的回复:怀疑别人前,请先做好功课怀疑别人前,请先做好功课

引用 5 楼 stherix 的回复:他写的没错 怀疑别人前,请先做好功课 就算 初始化的确不懂吧  static char s[50]="\0";//这个不能保证字符串s末尾有'\0' static 总懂了吧 静态存储 哪怕不初始化都有默认0  更何况还初始化了 怎么就不能保证末尾有'\0' ??

引用 5 楼 stherix 的回复:他写的没错 怀疑别人前,请先做好功课 这样的常识 那么多人不懂吗? 初始化的时候 没指定的元素就是0  int arr[10] = {1}; arr[1]是 0  有疑问吗?  为什么换成char 就傻掉了?

引用 4 楼 lin5161678 的回复:[quote=引用 3 楼 自信男孩 的回复:] #include <string.h> #include <stdio.h> #include <stdlib.h>  char *mid_1(char * ,int ,int); char *mid_2(char * ,int ,int); char *mid_3(char * ,int ,int); int main(void) {     char *p="https://zhidao.baidu.com/ihome/homepage/recommendquestion";     char *q;     printf("%s\n",mid_1(p,1,15));     printf("%s\n",mid_2(p,1,15));     printf("%s\n", q = mid_3(p,1,15));     free(q);     return 0; }  char *mid_1(char * str_,int start,int end){//自己写的MID函数     int i;     char s[50]="\0";    //这个不能保证字符串s末尾有'\0'     for(i=0;i<end;i++)         s[i]=str_[start+i-1];     s[i] = 0; //末尾加上'\0'     return s; } //自己写的MID函数 char *mid_2(char * str_,int start,int end) {     int i;     static char s[50]="\0";//这个不能保证字符串s末尾有'\0'     for(i=0;i<end;i++)         s[i]=str_[start+i-1];     s[i] = 0;    //末尾加上'\0'     return s; } char *mid_3(char * str_,int start,int end){//自己写的MID函数     int i;     char *s;     s=(char *)malloc(strlen(str_)* sizeof(char));     //s = "\0";   //这个地方是一个严重错误，导致内存泄露，因为s从堆上申请的空间，     //比如首地址是：0x001, s = "\0"这条语句就让s指向的"\0"字符串常量的地址，比如是0xff2，那么0x001的的地址就找不到，会导致内存泄露     for(i = 0; i < end; i++)         s[i]=str_[start+i-1];     s[i] = 0; //补上'\0'     return s; }  第一个返回了局部变量，结果是未定义的；局部变量的生命周期是从定义开始到函数调用结束而结束，因此到main里，这个变量就不存在了，结束了。 第二个和第三返回了静态变量和堆上的空间，可以正常返回。因为他们的生命周期是从定义开始到程序结束（静态变量）或者遇到free（堆上的空间）；  其他问题详见上面的代码注释你加的注释基本写错了 char s[50]="\0";    //这个不能保证字符串s末尾有'\0' 的确保证了 50个字节全部是 0 [/quote]  他写的没错 怀疑别人前,请先做好功课

厉害，非常有用，感谢楼主

引用 3 楼 自信男孩 的回复:#include <string.h> #include <stdio.h> #include <stdlib.h>  char *mid_1(char * ,int ,int); char *mid_2(char * ,int ,int); char *mid_3(char * ,int ,int); int main(void) {     char *p="https://zhidao.baidu.com/ihome/homepage/recommendquestion";     char *q;     printf("%s\n",mid_1(p,1,15));     printf("%s\n",mid_2(p,1,15));     printf("%s\n", q = mid_3(p,1,15));     free(q);     return 0; }  char *mid_1(char * str_,int start,int end){//自己写的MID函数     int i;     char s[50]="\0";    //这个不能保证字符串s末尾有'\0'     for(i=0;i<end;i++)         s[i]=str_[start+i-1];     s[i] = 0; //末尾加上'\0'     return s; } //自己写的MID函数 char *mid_2(char * str_,int start,int end) {     int i;     static char s[50]="\0";//这个不能保证字符串s末尾有'\0'     for(i=0;i<end;i++)         s[i]=str_[start+i-1];     s[i] = 0;    //末尾加上'\0'     return s; } char *mid_3(char * str_,int start,int end){//自己写的MID函数     int i;     char *s;     s=(char *)malloc(strlen(str_)* sizeof(char));     //s = "\0";   //这个地方是一个严重错误，导致内存泄露，因为s从堆上申请的空间，     //比如首地址是：0x001, s = "\0"这条语句就让s指向的"\0"字符串常量的地址，比如是0xff2，那么0x001的的地址就找不到，会导致内存泄露     for(i = 0; i < end; i++)         s[i]=str_[start+i-1];     s[i] = 0; //补上'\0'     return s; }  第一个返回了局部变量，结果是未定义的；局部变量的生命周期是从定义开始到函数调用结束而结束，因此到main里，这个变量就不存在了，结束了。 第二个和第三返回了静态变量和堆上的空间，可以正常返回。因为他们的生命周期是从定义开始到程序结束（静态变量）或者遇到free（堆上的空间）；  其他问题详见上面的代码注释你加的注释基本写错了 char s[50]="\0";    //这个不能保证字符串s末尾有'\0' 的确保证了 50个字节全部是 0


Question: 求救！C语言函数如何返回指向空数组的指针？

为什么要这么做呢？ 这个题目完全不需要啊。

空数组是指什么？是指数组内容为空，还是一个没有长度的数组？

返回NULL不就好了，C++都不支持不占内存的数组

直接返回NULL不就行了 为什么一定要返回一个空数组指针呢


Question: C语言数据结构栈删除操作疑惑

要看你的入栈是先动指针还是先动数据了，因此需要看一下你的入栈和初始化栈的操作

引用 4 楼 xyz-x的回复:我用#CSDN#这个app发现了有技术含量的博客，小伙伴们求同去《c++实现栈》, 一起来围观吧 https://blog.csdn.net/xyzbaihaiping/article/details/51125005  可以看看这个 看下那个图*top不是栈顶的那个元素，*--top才是，top为了方便入栈 发的是c++的，博主有c语言的应该，我有点忘记了

要看數據結構和入棧操作，看起來可能這個top只是用於做入口索引，不存儲數據。

要看你的push函数是怎么实现的，可能是因为压数据的时候s.top指定并不是指向当前数据，而是需要先位移一下则是当前pop的数据。

top不是栈顶数据，而是栈顶数据的上一个


Question: 求助：C语言实现

请问出现了一堆这个提示： undefined reference to `CreateCompatibleDC@4' 是怎么回事，我用的是DEV C++，没搞懂是环境的问题吗？

仅供参考：#pragma comment(lib,"gdi32") #include <windows.h> #include <stdio.h>  int main() {     const DWORD uWidth = 18 + 17 * 256, uHeight = 18 + 17 * 128;      PBITMAPINFO pbmi = (PBITMAPINFO) LocalAlloc (LPTR, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2);     pbmi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);     pbmi->bmiHeader.biWidth = uWidth;     pbmi->bmiHeader.biHeight = uHeight;     pbmi->bmiHeader.biPlanes = 1;     pbmi->bmiHeader.biBitCount = 1;     pbmi->bmiHeader.biSizeImage = ((uWidth + 31) & ~31) / 8 * uHeight;     pbmi->bmiColors[0].rgbBlue = 0;     pbmi->bmiColors[0].rgbGreen = 0;     pbmi->bmiColors[0].rgbRed = 0;     pbmi->bmiColors[1].rgbBlue = 255;     pbmi->bmiColors[1].rgbGreen = 255;     pbmi->bmiColors[1].rgbRed = 255;      HDC hDC = CreateCompatibleDC (0);     void * pvBits;     HBITMAP hBitmap = CreateDIBSection (hDC, pbmi, 0, &pvBits, NULL, 0);     SelectObject (hDC, hBitmap);     HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "宋体"); //  HFONT hFont = CreateFont (16, 0, 0, 0, 0, 0, 0, 0, SHIFTJIS_CHARSET, 0, 0, 0, 0, "宋体");     SelectObject (hDC, hFont);     BitBlt (hDC, 0, 0, uWidth, uHeight, NULL, 0, 0, WHITENESS);      char c[4];     int i, j;     for (i = 128; i < 256; i++) {         sprintf (c, "%02X", i);         TextOut (hDC, 1, (i - 127) * 17 + 1, c, 2);     }     for (j = 0; j < 256; j++) {         sprintf (c, "%02X", j);         TextOut (hDC, (j + 1)* 17 + 1, 1, c, 2);     }     for (i = 128; i < 256; i++) {         for (j = 0; j < 256; j++) {             c[0] = (char) i;             c[1] = (char) j;             TextOut (hDC, (j + 1) * 17 + 1, (i - 127) * 17 + 1, c, 2);         }     }     for (i = 0; i < 130; i++) {         MoveToEx (hDC, 0, i * 17, NULL);         LineTo (hDC, uWidth, i * 17);     }     for (j = 0; j < 258; j++) {         MoveToEx (hDC, j * 17, 0, NULL);         LineTo (hDC, j * 17, uHeight);     }      BITMAPFILEHEADER bmfh;     bmfh.bfType = *(PWORD) "BM";     bmfh.bfReserved1 = 0;     bmfh.bfReserved2 = 0;     bmfh.bfOffBits = sizeof (BITMAPFILEHEADER) + sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2;     bmfh.bfSize = bmfh.bfOffBits + pbmi->bmiHeader.biSizeImage;      HANDLE hFile = CreateFile ("goal.bmp", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);     if (hFile != INVALID_HANDLE_VALUE) {         DWORD dwWritten;         WriteFile (hFile, &bmfh, sizeof (BITMAPFILEHEADER), &dwWritten, NULL);         WriteFile (hFile, pbmi, sizeof (BITMAPINFOHEADER) + sizeof (RGBQUAD) * 2, &dwWritten, NULL);         WriteFile (hFile, pvBits, pbmi->bmiHeader.biSizeImage, &dwWritten, NULL);          CloseHandle (hFile);     }      DeleteObject (hFont);     DeleteObject (hBitmap);     DeleteDC (hDC);     LocalFree (pbmi);      return 0; }


Question: c基础题，萌新在线等，挺急的

就这两题。。 实在没思路了 接触c才两个月

再来一题  编写程序，用指向一维数组的指针变量p实现对二维数组b中各元素的输入和输出。（输出用指针变量的多种表现形式进行数组元素的多次输出。）


Question: 跪求找错

不是a, b,c,d,e没有定义，看一下error的第一条，有一条语句没有;分号。  把这个函数的代码都贴出来吧


Question: c语言小白求问

是想用二分法求零到六上这个函数的根，精确到0.000001 输入零和六以后输出结果不正确...

#include<stdio.h>  //void main(void) int main(void) {     double x1,x2,f1,f2,x,f,t=0;      printf("请输入区间范围");     scanf("%lf%lf",&x1,&x2);     f1 = x1*x1*x1-7*x1-1;     f2 = x2*x2*x2-7*x2-1;     do     {         if(f1*f2 > 0) {             printf("此区间没有根，请重新输入");             break;         }         else         {             x=(x2+x1)/2;             f=x*x*x-7*x-1;         }         if(f*f1>0)         {             x1=x;             f1=f;         }         else         {             x2=x;             f2=f;         }         t = t+1;     } while(0.000001>x2-x1);     printf("该区间上有根%lf,二分次数为%lf",x,t); }  供参考！  建议贴出测试用例，以及预想的结果。 主要是通过你的代码看不出算法是什么


Question: c语言该怎么学

首先你得配好环境建议使用虚拟机＋Ubantu 然后你得会基础语法 最后你得多练习

引用 3 楼 冷风1023的回复:第一步、打开书本 第二步、看书学习 第三步、在机器上练习 第四步、总结 第五步、做项目 以上一直要while(1)循环，直到你放弃这门语言 太真实了8，，，，，

用编译器多练习


Question: 求大佬解惑

用单步调试啊。想做一个合格的程序员，单步调试是必须的！

漫漫逐步调试。

闪退说明你程序挂了，调试的时候会自动挂到问题发生点的


Question: 单片机

去嵌入式板块问吧，


Question: 一个排序程序的小问题。排序结果为什么有时候不对，有时又是对的，

#include <stdio.h>   void swap(int *a, int *b) {     int c;     c = *a;     *a = *b;     *b = c; } int main() {     int a[10];     int max, maxno;     int i, j;     printf("\n请输入10个正整数：");     for (i = 0; i < 10; i++)         scanf_s("%d", &a[i]);      for (i = 0; i < 10; i++)  //遍历数组的10个值     {         //max = a[i];   //把最大值 放在 max中         maxno = i;     //把最大值的下标放在 序号中         for (j = i + 1; j < 10; j++)         {             //if (max < a[j])     //如果数组的其它值大于最大值             if (a[maxno] < a[j])     //如果数组的其它值大于最大值             {                 //max = a[j];   //记住最大值                 maxno = j;    //记住最大值下樯             }         }         if (i != maxno)    //如果 最大值 下标不等于当前下标             swap(&a[i], &a[maxno]);   //交换最大值 与当前值         printf("%d\t", a[i]);     }     printf("\n"); }  供参考！  max可以不用的。

引用 6 楼 636f6c696e的回复:虽然你这么写结果是对的，但还是多了很多次无效的比较，你的算法核心是每次找到剩余数中最大的数放到第一个。 那为什么要交换那么多次呢？每次循环交换一个最大的不就成了？ [quote=引用 5 楼 UIUI 的回复:] [quote=引用 3 楼 user-3的回复:]交换应该放在第二个循环外，第一个循环内。  选择排序，是找到子序列的最大值，然后再与第一个元素交换。 我最后贴的也是对的，能正确输出[/quote][/quote] 多谢，放到外面是对的，确实能减少交换次数。

虽然你这么写结果是对的，但还是多了很多次无效的比较，你的算法核心是每次找到剩余数中最大的数放到第一个。 那为什么要交换那么多次呢？每次循环交换一个最大的不就成了？ 引用 5 楼 UIUI 的回复:[quote=引用 3 楼 user-3的回复:]交换应该放在第二个循环外，第一个循环内。  选择排序，是找到子序列的最大值，然后再与第一个元素交换。 我最后贴的也是对的，能正确输出[/quote]

引用 3 楼 user-3的回复:交换应该放在第二个循环外，第一个循环内。  选择排序，是找到子序列的最大值，然后再与第一个元素交换。 我最后贴的也是对的，能正确输出

逻辑错了，交换一次后maxno和i就不同了，所以后面每次j的循环都会进行交换，应该把交换放在第二个for循环外： int a[10];     int max, maxno;     int i, j;     printf("\n请输入10个正整数：");     for (i = 0; i < 10; i++)         scanf("%d", &a[i]);      for (i = 0; i < 10; i++)  //遍历数组的10个值     {         max = a[i];   //把最大值 放在 max中         maxno = i;     //把最大值的下标放在 序号中         for (j = i + 1; j < 10; j++)         {             if (max < a[j])     //如果数组的其它值大于最大值              {                 max = a[j];   //记住最大值                  maxno = j;    //记住最大值下樯             }         } if (i != maxno)    //如果 最大值 下标不等于当前下标                 swap(&a[i], &a[maxno]);   //交换最大值 与当前值         printf("%d\t", a[i]);     }     printf("\n");

for (i = 0; i < 10; i++)  //遍历数组的10个值     {         max = a[i];   //把最大值 放在 max中         maxno = i;     //把最大值的下标放在 序号中         for (j = i + 1; j < 10; j++)         {             if (max < a[j])     //如果数组的其它值大于最大值              {                 max = a[j];   //记住最大值                  maxno = j;    //记住最大值下樯                          if (i != maxno)    //如果 最大值 下标不等于当前下标    是因为上面有交换，这里才能交换。。。没有交换，则不能交换，不能 //放到比较条件外，  调试工具真是好用。比较容易找到问题                 swap(&a[i], &a[maxno]);   //交换最大值 与当前值             }         }         printf("%d\t", a[i]);     }

void swap(int *a, int *b)  { 	int c; 	c = *a; 	*a = *b; 	*b = c; } main() { 	int a[10]; 	int max, maxno; 	int i, j; 	printf("\n请输入10个正整数："); 	for (i = 0; i < 10; i++) 		scanf_s("%d", &a[i]);  	for (i = 0; i < 10; i++)  //遍历数组的10个值 	{ 		max = a[i];   //把最大值 放在 max中 		maxno = i;     //把最大值的下标放在 序号中 		for (j = i + 1; j < 10; j++) 		{ 			if (max < a[j])     //如果数组的其它值大于最大值  			{ 				max = a[j];   //记住最大值  				maxno = j;    //记住最大值下樯 			} 			if (i != maxno)    //如果 最大值 下标不等于当前下标 				swap(&a[i], &a[maxno]);   //交换最大值 与当前值 		} 		printf("%d\t", a[i]); 	} 	printf("\n"); }


Question: 求助

dsw只是工程文件,里面没有代码的 如果没有.c .cpp这样的代码文件,也只是一个空壳而已  另外,现在还有在用VC6的吗? 真是老古董的老师去教一堆懵懂的学生

强行改文件后缀试试？

救救孩子吧(我都快绝望了……)

谢谢解答的朋友，我已经重打了(-ι_- )


Question: 记事本编辑文字的部分是子窗口还是控件?

引用 8 楼 六道佩恩 的回复:额，“窗口也属于控件”这个说法我还从没见到过，刚搜了下没搜到，之前Microsoft查阅控件的说明好像也没看到这个说法，请问这个说法是怎么来的？ 没见过就去见见  不要全靠搜索 看看书 比如 Windows程序设计

控件本身就是一个窗体

既是子窗口，也是控件。

引用 7 楼 Simple-Soft 的回复:[quote=引用 6 楼 六道佩恩 的回复:] [quote=引用 2 楼 Simple-Soft 的回复:] 你可以用spy++查看，vc自带的，可以看出那个控件的类型和名字，肯定是应该是texybox 类名是Edit，无标题，仅根据这一点能区分控件和窗口吗？[/quote] 控件啊！窗口也属于控件啊[/quote] 额，“窗口也属于控件”这个说法我还从没见到过，刚搜了下没搜到，之前Microsoft查阅控件的说明好像也没看到这个说法，请问这个说法是怎么来的？

有句柄的，之前用过

子窗口控件.

编辑区应该是控件,文本框之类的 控件也都有句柄

引用 6 楼 六道佩恩 的回复:[quote=引用 2 楼 Simple-Soft 的回复:] 你可以用spy++查看，vc自带的，可以看出那个控件的类型和名字，肯定是应该是texybox 类名是Edit，无标题，仅根据这一点能区分控件和窗口吗？[/quote] 控件啊！窗口也属于控件啊

引用 2 楼 Simple-Soft 的回复:你可以用spy++查看，vc自带的，可以看出那个控件的类型和名字，肯定是应该是texybox 类名是Edit，无标题，仅根据这一点能区分控件和窗口吗？


Question: * a和*a和* a的区别

引用 3 楼 user-1 的回复:随便瞟了眼就发现有问题： q = top; delete q; top = top -> next;  都把top释放了，还访问top->next，这不是野指针么？ 确实有问题，主要是while循环的判断条件有问题，清空的是对象ls中的内容，对象q用来辅助清空内容，因此判断的应该是ls中的top.而不是判断q

好像不关定义的事，怎么这个停止运行框有时有，有时没有。 这是codeblock的问题么？ 只能怪学校实验室的电脑了诶。

艹，这代码怎么是这样的 我再发一下 #include <iostream> using namespace std; template <class DataType> struct Node{     DataType data;     Node *next; }; template <class DataType> class LinkStack{     private:     Node<DataType> * top;     public:     LinkStack(){top=NULL;}     ~LinkStack();     void push(DataType x);     DataType pop();     DataType gettop();     int Empty(); };   template <class DataType> LinkStack<DataType>::~LinkStack(){     Node<DataType> *q = top;     while(q!=NULL){         q = top;         delete q;         top = top -> next;     } }  template <class DataType> void LinkStack<DataType>::push(DataType x){     Node<DataType> *s = new Node<DataType>;     //定义变量格式要完全     s -> data = x;     s -> next = top;     top = s; }  int main(){     cout<<"sdsdsd"<<endl;     LinkStack<string> ls;     cout<<"xxxxxx"<<endl;     ls.push("lzh");     cout<<"sdsd";     cout<<"sldksd"; }


Question: 新人提问

引用 18 楼 weixin_44930231的回复:[quote=引用 16 楼 636f6c696e的回复:]p=1 p=p*base=1*base=base p=p*base=base*base=base^2 ... 所以n次循环后p=base^n 如果这还理解不了的话，那也没辙了。 不知道我在六楼的回复怎么样\^O^/[/quote] 好吧是10楼引用六楼

引用 16 楼 636f6c696e的回复:p=1 p=p*base=1*base=base p=p*base=base*base=base^2 ... 所以n次循环后p=base^n 如果这还理解不了的话，那也没辙了。 不知道我在六楼的回复怎么样\^O^/

引用 13 楼 caohanxing1的回复:是求2的i次方，和-3的i次方？ 是的   power（2，i）与power（-3，i）就是求2与-3的i次方

#include <stdio.h> int power(int n, int m); main() { 	int i; 	for (i = 0; i < 10; ++i) 		printf("%d %3d %6d\n", i, power(2, i), power(-3, i)); 	return 0; } int power(int base, int n) { 	int i, p; 	p = 1; 	for (i = 1; i <= n; ++i) 		p = p * base; 	return p; }

1. p是变量，可以把数据存入变量，也可以从变量里提取数据。 2. 计算有先后，对于p = p* base，先计算p*base，这个时候是从p中取数据，得到乘积结果后，再计算 p=乘积结果，即把结果存入p。 3. 变量是同一个变量，只是这两个p是对p的不同操作，一个取值来计算，一个保存数据。

是求2的i次方，和-3的i次方？

赋值没这么难理解吧！高中都在讲

引用 8 楼 自信男孩的回复:两个p是一样的，只是先用p的当前值与Base相乘，然后把结果再放到p中。 谢谢你的回复   很直接

引用 6 楼 stherix的回复:只能理解为 p= 1 * base; 第一轮循环结束后,p的值就是base了 这就是算幂的函数 p要乘以n次base 最终p的值是base的n次方 有一些理解了 调用power函数需要两个参数base与n i与p是power函数中的两个变量 首先赋值p=1使得for的循环体p=p*base首先得到第一个p的值p=1*base即p=base 而在for的参数列表中i的意义就是控制次数，相乘的次数。使得幂运算转换成了乘法运算。i=1相当于第一次乘法运算，而此时p的值为1，p=p*base使得p值变为base，之后第二次循环++i，此时p=p*base就相当于p=base*base即p=base的2次方，直到for判断语句i<=n判断为假停止执行语句块，但此时for已经循环了n次，所以此时return p中的p值为base的n次方，已达到目的，求底数的n次幂，即power函数的功能。

两个p是一样的，只是先用p的当前值与Base相乘，然后把结果再放到p中。

引用 6 楼 stherix的回复:只能理解为 p= 1 * base; 第一轮循环结束后,p的值就是base了 这就是算幂的函数 p要乘以n次base 最终p的值是base的n次方 p的值是base的n次方，那么p*base中，base为底数，p为指数，但*是乘法运算或返回重复若干次的字符串，所以p=p*base是一个乘法运算又如何进行base的N次方运算？或者说*还可以表示相乘的次数，所以p=p*base也可以理解为base乘以p次base？ 另 power语句块声明了变量i，由power的参数列表可以知道i就是base，那么p=p*base是否可以看成并写做p=p*i？ 还有谢谢你的解答。

好像可以直接用math函数吧 用这个#include<math.h> 直接写pow（int x，int n）就等于x的n次幂 这样就不用写自定义函数啦

引用 4 楼 stherix的回复:p = p * base; 这个等号不是数学上的相等,而是赋值语句 先计算等号右边的值,再把结果赋给左边的变量 谢谢你的回答 不过  在power的语句块中先声明了一个变量p然后赋值p=1     在只声明了一个变量p且p被赋值的情况下p=p*base是否可以理解为1=1*base？           而这个base是否就是在power语句块中声明的变量i？

头文件是include<stdio.h>

引用 1 楼 stherix的回复:你能理解 p = p + 1; 这个的意思吗?  至于写出来显示错误 建议仔细学好最基础的东西 标识符命名,赋值语句,等等 嗯 才开始学c     第一本书就是这个   一章章看过来    这里小白理解不了    查也没有具体解答   so   来这里提问    希望可以解惑 另   这个程序就是书上的原版


Question: 求大佬看一下为啥错了，怎么修改

引用 9 楼 拥抱Linux的回复:[quote=引用 8 楼 神无影 的回复:]  谢谢啦⊙∀⊙！问一下手机上怎么结帖  我没怎么用过CSDN的手机app，不清楚。你有空就摸索一下吧，找不到也没关系，把上面的问题搞懂就行了。[/quote] 嗯嗯，谢谢啦以后有问题了还希望多多指教非常感谢

引用 8 楼 神无影 的回复:谢谢啦⊙∀⊙！问一下手机上怎么结帖  我没怎么用过CSDN的手机app，不清楚。你有空就摸索一下吧，找不到也没关系，把上面的问题搞懂就行了。

引用 7 楼 拥抱Linux的回复:不是说好了数组长度是16个元素，而下标最大值为15么？  // 变量 i 作为数组下标，等于 16 的时候 越界访问了 // 改成 i < 16 或者 i < N  即可 for (i = 1; i <= 16; i++) { 		if ((a[i].s) < min) { 			min = a[i].s; 		} 	}  谢谢啦⊙∀⊙！问一下手机上怎么结帖

再问一下下面这个程序哪里错了没报错，就是没结果，要求输出成绩最低的几位，⊙∀⊙！手机上这程序怎么结帖 #include <stdio.h> #define N 16   typedef struct {       char num[10];       int s; } STREC; int fun(STREC a[], STREC b[]) {    int i,min,count=0;    min=a[0].s;    for(i=1;i<=16;i++)    {    	   if ((a[i].s)<min) 		  { 		  	min= a[i].s; 		  }     }    for(i=0;i<N;i++)    {        if( a[i].s==min )        {         b[count]=a[i];         count++;        }         }     return count; } int main() {      STREC s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},{"GA011",91},{"GA017",64},{"GA018",64},{"GA016",72}};     STREC h[N];     int i,n;     n=fun(s,h);     for(i=0;i<n; i++)         printf("%s %4d\n",h[i].num,h[i].s);     return 0; }

int fun(STREC a[], STREC b[],int x,int y) {     int i,count=0;     for(i=0;i<N;i++)     {         if( (x <= a[i].s) && (a[i].s<= y) )         {             b[count] = a[i];             //b[count].num=a[i].num;             //b[count].s=a[i].s;             count++;         }      }     return count; } 供参考！  结构体可以直接赋值，如果结构体元素有10几个，那么你也要一个元素一个元素的赋值吗？

自己发的帖子，在电脑上的浏览器里打开之后，标题右边有几个可以点击的文字块，其中一个就是「结帖」，那么点击「结帖」就进入了结帖环节。 结帖的时候，需要给某些楼层的回答「打分」，根据页面的指引，点击最终的「结帖」或者「完成」按钮就好了。

引用 2 楼 拥抱Linux的回复:下次建议把程序的功能是什么，也说一下。 代码里的错误已经用注释标注出来了，具体如下：  #include <stdio.h> // 增加一个头文件<string.h> #include <string.h>  #define N 16  typedef struct { 	char num[10]; 	int s; } STREC;  int fun(STREC a[], STREC b[], int x, int y) { 	int i, count = 0; 	for (i = 0; i < N; i++) { 		if ((x <= a[i].s) && (a[i].s <= y)) { 			// 数组不能这样赋值，因为数组名在赋值运算符左边的时候它的值是一个地址常量，是不能被赋值的 			// 要么通过循环来对数组元素逐一赋值， 			// 对于字符数组的话，还可以使用<string.h>里的相关函数strcpy等 			//b[count].num = a[i].num; 			strcpy(b[count].num, a[i].num); 			b[count].s = a[i].s; 			count++; 		} 	} 	return count; }  // 整个程序是想输出成绩位于low和high之间的学生信息吗？ int main() { 	STREC s[N] = { { "GA005", 85 }, { "GA003", 76 }, { "GA002", 69 }, { "GA004", 85 }, { "GA001", 96 }, { "GA007", 72 }, { "GA008", 64 }, { "GA006", 87 }, 		       { "GA015", 85 }, { "GA013", 94 }, { "GA012", 64 }, { "GA014", 91 }, { "GA011", 90 }, { "GA017", 64 }, { "GA018", 64 }, { "GA016", 72 } }; 	STREC h[N]; 	int i, n, low, heigh, t;         // 高的英语单词是high，嘿嘿，这就不帮你改了 	scanf("%d%d", &low, &heigh); 	if (heigh < low) { 		t = heigh; 		heigh = low; 		low = t; 	} 	n = fun(s, h, low, heigh); 	printf("The student's data between %d--%d :\n", low, heigh); 	for (i = 0; i < n; i++) 		printf("%s %4d\n", h[i].num, h[i].s); 	return 0; }  Linux环境下，clang编译后，测试运行截图：  如有帮助，烦请及时结贴、给分！ ：） 问一下，怎么结帖，谢谢大佬啦

#include <stdio.h> #define N 16   typedef struct {       char num[10];       int s; } STREC; int fun(STREC a[], STREC b[],int x,int y) {    int i,count=0;    for(i=0;i<N;i++)    {        if( (x <= a[i].s) && (a[i].s<= y) )        {         b[count].num=a[i].num;         b[count].s=a[i].s;         count++;        }         }     return count; } int main() {      STREC s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},{"GA001",96},{"GA007",72},{"GA008",64},{"GA006",87},{"GA015",85},{"GA013",94},{"GA012",64},{"GA014",91},{"GA011",90},{"GA017",64},{"GA018",64},{"GA016",72}};     STREC  h[N];     int i,n,low,heigh,t;     scanf("%d%d", &low,&heigh);     if ( heigh< low )     {          t=heigh;         heigh=low;         low=t;      }     n=fun( s,h,low,heigh );     printf("The student's data between %d--%d :\n",low,heigh);     for(i=0;i<n; i++)         printf("%s %4d\n",h[i].num,h[i].s);     return 0; }


Question: 编写一个c程序，求s=1+（1+2）+（1+2+3）+...+（1+2+3+n）的值

错误清单： （1） fun函数少了一个 右花括号。 （2）fun 函数内的 printf 语句，变量 n 的前面多了一个 & 。 （3）fun 函数内，return 语句放在了 for 循环内，应该放到 for  循环的后面。 其它，好像没啥问题了。你先修正之后试试。


Question: 跪求万年历的数据流图和数据字典

不会。真不会。真不会。


Question: 关于scanf 输入问题

你不是指定了宽度为3吗？你输入了1.254 2.654，指定宽度3，于是接收了1.2，这就是3个字符，所以第一个结果就是1.2。然后你在scanf里指定的规则是“%3f,%2f，第一个%3f已经满足，接下来scanf等着你输入逗号，但输入缓冲区里只剩下“54 2.654”，匹配不到逗号，所以scanf退出，只成功匹配到a。你通过scanf的返回值就能知道成功匹配了几个变量。

引用 3 楼 weixin_44813559的回复:[quote=引用 2 楼 qq_38834405的回复:]指定宽度是在printf里面 scanf 也可以，只不过有规定好像我也不太清楚[/quote] 那是scanf_s，需要指定大小

第一个输入逗号呢？

引用 2 楼 qq_38834405的回复:指定宽度是在printf里面 scanf 也可以，只不过有规定好像我也不太清楚

指定宽度是在printf里面

顺序有点乱，好像重复了，能看懂就行


Question: 数组的应用  新手编程

引用 1 楼 拥抱Linux的回复:下面是参考代码，留了一个空，你看看能不能看懂代码的意思，然后思考一下怎么填比较合适——这不是刁难你，而是希望你能有思考、有收获。  // 输入任意的5个整数放在一维数组中，假定输入的5个数是：1，2，8，2，10，编写程序打印下面的方阵： #include <stdio.h> #define LEN 5 int main(int argc, char const *argv[]) { 	int a[LEN];         // 输入5个整数 	for (int i = 0; i < LEN; i++) { 		scanf("%d", &a[i]); 	} 	// 5行输出，被分成5次大循环来完成， 	for (int i = 0; i < LEN; i++) { 		// 第 i 行的输出，是从数组的第 i 个元素开始的，按数组的长度（元素个数）来确定小循环的次数 		// 下标如果超出数组上限的话，又重新归零，从而达到首尾相接的效果。 		for (int j = i, count = 1;; j++, count++) { 			if (j == LEN) { 				j = 0; 			} 			printf("%d ", a[j]);         // 下面圆括号中是 if 的判断条件表达式，问号需要你根据程序和题意改成合适的变量名或者整数 			if (count == ?) { 				break; 			} 		} 		printf("\n"); 	} 	return 0; }  上面的 if 的判断条件里填入合适的变量名或者整数值之后，程序的测试运行截图如下：  十分感谢🙏🙏  但是因为前期没有学过int main ()括号里加东西，和count 函数，但看了后百度了一下还是有了一定了解。感谢🙏

引用 2 楼 qq_44695678 的回复:十分感谢  但是因为前期没有学过int main ()括号里加东西，和count 函数，但看了后百度了一下还是有了一定了解。感谢  main()圆括号里的东西，你现在可以不用搭理；count是上面代码中的一个int型变量的名称而已，不是函数哦！ 上面代码中的 ？ 应该写 LEN 或者 5 ，也就是数组的长度值。 祝你C语言学习进步！


Question: 数据结构

为什么开始要把L的next变成null呢，那不是失去了第一个有效节点吗


Question: 利用OpenGL来做出一个反导弹系统

提问的方式方法都不对，谁有空闲 时间来看你一大堆图片？


Question: C语言

引用 3 楼 user-2 的回复:另请教下，你那种格式的怎么弄的。我回复的格式不太好看。但是从VS拷贝出来的，怎么没有缩进呢。  在代码前后加(c后面空格删除) [code=c ]   [/code]

引用 1 楼 stherix 的回复:int main() { 	double limit, total = 0; 	scanf("%lf", &limit);  	for (int i = 1;; i++) 	{ 		total += 1.0 / i; 		if (total > limit) 		{ 			printf("%d\n", i - 1); 			break; 		} 	} 	return 0; } 输出时不用 i - 1，不然就不大于limit了。 另请教下，你那种格式的怎么弄的。我回复的格式不太好看。但是从VS拷贝出来的，怎么没有缩进呢。

#include<stdio.h>  int main() { 	double dSum = 0.0; 	double dLimit = 0.0; 	scanf("%lf", &dLimit); 	long long i = 1; 	for (; ; ++i) 	{ 		dSum += 1.0 / i; 		if (dSum > dLimit) 		{ 			break; 		} 	}  	printf("满足条件的最小i值为：%ld.\n", i);  	return 0; }  // 注：limit不要输入太大，不然会运行很久很久（一般20以内会很快出结果）


Question: 关于句柄的一些问题

引用 3 楼 stherix的回复:句柄可不是结构体指针,他只是一个整形数字 是windows操作系统对系统资源的一个编号,比如某个文件,某个外设,一个窗体等等 这是由操作系统分配的 hout就是标准输出设备的句柄,一般代表显示输出设备也就是控制台屏幕 通过这个句柄获取到它的屏幕信息,修改光标位置后,再把设置写回设备 那些结构体都是windowsAPI规定的参数,你不能改成自定义的结构或者其他类型的参数 麻烦你帮我举个标准输入和错误句柄的例子可以么？

GetStdHandle((STD_OUTPUT_HANDLE)); 就是控制台界面的句柄，一个标识。有了这个句柄你就能设置控制台窗口的一些属性了 比如，文字颜色，字体，背景样色，透明度，窗口位置等等等等。 比如你的程序中控制的就是光标位置。


Question: 求大佬看看，这段程序哪里有问题

提问代码的问题，上面的回答已经说了，这里就不重复了。 只是对于这类语法错误，建议使用拥有「代码静态分析工具或插件」的文本编辑器或者IDE，这样的话，在编写代码阶段，代码静态分析工具或插件就能提示代码的语法错误，当然它还能指出其它一些潜在危险或错误。这就大大减轻了编写代码的负担，能让人更专注于代码和算法本身。 另外，下面提供一个代码供参考：  #include <stdio.h>  int main(int argc, char const *argv[]) { 	int year, month, day; 	int leap = 0; 	int day_num = 0; 	scanf("%d/%d/%d", &year, &month, &day); 	if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) 		leap = 1; 	switch (month) { 	case 12: 		day_num += 30; 	case 11: 		day_num += 31; 	case 10: 		day_num += 30; 	case 9: 		day_num += 31; 	case 8: 		day_num += 31; 	case 7: 		day_num += 30; 	case 6: 		day_num += 31; 	case 5: 		day_num += 30; 	case 4: 		day_num += 31; 	case 3: 		day_num += 28 + leap; // 这里是易错点。 	case 2: 		day_num += 31; 	case 1: 		day_num += day; 	} 	printf("%d", day_num); 	return 0; }

#include<stdio.h>  int main() {     int year,month,day,n, leap = 0;     printf("Input the year:");     scanf("%d",&year);     printf("Input the month:");     scanf("%d",&month);     printf("Input the day:");     scanf("%d",&day);      if (month > 2 && ((year % 4 == 0 && year % 100 != 0) || year %400 == 0))         leap = 1;     //switch(month):     switch(month)     {         case 1:             n = day;             break;         case 2:n=(day +31);                break;         case 3:n=(day +59);                break;         case 4:n=(day +90);                break;         case 5:n=(day +120);                break;         case 6:n=(day +151);                break;         case 7:n=(day +181);                break;         case 8:n=(day +212);                break;         case 9:n=(day +243);                break;         case 10:n=(day +273);                 break;         case 11:n=(day +304);                 break;         case 12:n=(day +334);                 break;     }     if (month > 2)         n += leap;      printf("the day is the %d day of the year\n",n);      return 0; }

#include<stdio.h>  int main() {     int year,month,day,n, leap = 0;     printf("Input the year:");     scanf("%d",&year);     printf("Input the month:");     scanf("%d",&month);     printf("Input the day:");     scanf("%d",&day);      if ((year % 4 == 0 && year % 100 != 0) || year %400 == 0)         leap = 1;     //switch(month):     switch(month)     {         case 1:             n = day;             break;         case 2:n=(day +31);                break;         case 3:n=(day +59);                break;         case 4:n=(day +90);                break;         case 5:n=(day +120);                break;         case 6:n=(day +151);                break;         case 7:n=(day +181);                break;         case 8:n=(day +212);                break;         case 9:n=(day +243);                break;         case 10:n=(day +273);                 break;         case 11:n=(day +304);                 break;         case 12:n=(day +334);                 break;     }     if (month > 2)         n += leap;      printf("the day is the %d day of the year\n",n);      return 0; }   供参考！  代码可以写的更精简一些

switch(month)后面多了一个: switch(month) {     .     .     .  }

switch(month)后面不能有冒号:


Question: 求大佬看看这段程序错在哪

#include<stdio.h>  int main() {     int i;     double I=0;     int k=-1;      //for(i=1;(1/i)>=1e-5;i+=2)     for(i = 1; (1.0 / i) >= 1e-5; i += 2)     {         k = -k;         I += (k * 1.0 / i);     }     printf("%f\n",I);      return 0; }  供参考！

k是int，所以k/i会被转换成int，就是0 改成double(k) / i 就好了

除了1楼说的问题，还有个printf错误。 double类型的输出，要用lf. 改成：printf("%lf",I);


Question: C语言循环语句，小白求问。。

哪里不会？还是只想做个伸手党？

#include<stdio.h>  int main() { 	int a[100]; 	for (int i = 0; i < 100; ++i) 	{ 		a[i] = 100 + i; 	}  	printf("正序输出：\n"); 	for (int i = 0; i < 100; ++i) 	{ 		printf("%d\t", a[i]); 	} 	printf("\n"); 	printf("反序输出：\n"); 	for (int i = 99; i >= 0; --i) 	{ 		printf("%d\t", a[i]); 	} 	printf("\n");  	printf("奇数输出：\n"); 	for (int i = 0; i < 100; ++i) 	{ 		if (1 == a[i] % 2) 			printf("%d\t", a[i]); 	} 	printf("\n");  	printf("偶数输出：\n"); 	for (int i = 0; i < 100; ++i) 	{ 		if (0 == a[i] % 2) 			printf("%d\t", a[i]); 	} 	printf("\n");  	return 0; }  // 结贴给分。


Question: 如何自己实现一个mini的C语言文件操作函数？

如果在系统环境下，简单。把系统接口（也就是api）包装一下完事了 如果在独立环境在，困难。因为你，不是写在一个运行库，而是在写一个系统。 （fopen， fread， fwrite， fclose 这些函数就是系统接口，没有系统，他们是没有的）

引用 1 楼 单眼皮的小健 的回复：fatfa，搜这个文件系统，非常短小精悍是fatfs，打错

fatfa，搜这个文件系统，非常短小精悍


Question: 救急救急大佬们

好的，我测试下，等会结

问题已解决，结贴给分！

#include <stdio.h>  int main() { 	int n = 0; 	printf("请输入一个整数:"); 	scanf("%d", &n); 	char s[29] = {'\0'}; 	// 前28位先写0 	for (int i = 0; i < 28; ++i) 	{ 		s[i] = '0'; 	}  	int x = n;  //保存n 	for (int i = 0; i < 28; ++i) 	{ 		int k = n & 0x0001; 		if (1 == k) 		{ 			s[27 - i] = '1'; 		} 		n = n >> 1;  // 移位 		if (0 == n) 		{ 			break; 		} 	} 	printf ("%d 的二进制为：%s.", x, s); 	return 0; }

将一些很大的数比如4664556转化为二进制，然后补充成为28位的二进制，直接输出0101101就行

1，不考虑溢出是吧？ 2，二进制怎么保存，字符串？

哪里不会？转换2进制实质是不停%2 /2的过程

引用 6 楼 wshyhm的回复:问题已解决，结贴给分！ 能不能再加一点，根据得到的二进制数求真值反码补码


Question: C语言编程

嗯，好像不是严格匹配你的题目的要求，比如把均值放进一维数组之类的，因为觉得那样写太罗嗦。你看看吧，不合适的话，当作个了解参考就行了。

参考代码，如下：  #include <stdio.h>  int main(int argc, char const *argv[]) { 	float a[3][3]; 	float sum[3] = { 0 }; 	for (int i = 0; i < 3; i++) { 		for (int j = 0; j < 3; j++) {                         // 按行输入逐个数值，以空格或回车分隔 			scanf("%f", &a[i][j]);                         // 累加各列之和 			sum[j] += a[i][j]; 		} 	}         // 逐个输出各列和的平均值 	for (int i = 0; i < 3; i++) { 		printf("%.2f ", sum[i] / 3); 	} 	printf("\n"); 	return 0; }   Linux环境下，clang编译后测试运行截图，如下：  输入的时候，是否按矩阵的形式输入，并不影响输出结果，因为代码是按3个一行、3个一列来获取数据的。希望能帮到你。

#include <stdio.h> #define N 3  int main() { 	int i, j; 	float matrix[N][N]; 	float average[N] = {0}; 	for ( i = 0; i < N; i++) 	{ 		for ( j = 0; j < N; j++) 		{ 			scanf("%f", &matrix[i][j]); 		} 		getchar();   //吸收回车 	} 	for ( j = 0; j < N; j++) 	{ 		for ( i = 0; i < N; i++) 		{ 			average[j] += matrix[i][j];  //求列累加和 		} 		average[j] = average[j] / N;     //求均值 	} 	for ( i = 0; i < N; i++) 	{ 		printf("%.2f ", average[i]);    //两位小数 	} }

求求了感谢各位大佬！！


Question: //第四章第四题，输入一个小于1000的数字，求平方根（只显示整数部分）

调用函数直接输入了，就在fun()里面

你的输入在哪里？ scanf("%d", &x);


Question: C语言：删除链表结点运行free(p)时，出现错误。。。after Nomal block(#65)

贴图不如贴出代码对于问题呈现的更快，更直接些


Question: C语言二进制转化为十进制

大整数大于0，不带符号，无前导0，至少1位数字，且不超过100位数字  100位的数用long long也放不下吧


Question: 一个c语言的问题

问题原因是，使用scanf 输入数据之后的输入缓冲区有残留数据，这些残留数据被下一次循环的scanf 无脑读入了。于是，错误的值被赋予了变量，后面的输入全都错位了，变量就没有得到想要的值。  推荐解决方案一：在scanf 语句后面添加如下语句，吸收掉输入缓冲区残留数据，  int getBuff; while ((getBuff = getchar() != '\n') && (getBuff != EOF));  它的具体机制是，使用循环把输入缓冲区的数据读完,直到读到缓冲区的\n或者是空值。  推荐解决方案二：其实俺并不推荐这种办法，因为受平台和软件限制，基本上只在windows的VC系IDE里起效，而gcc、clang都不支持。  //使用fflush()函数 // fflush()不是标准库文件，gcc、clang就不支持，即缺少移植性     fflush(stdin);  希望能帮到你。

for(int i=0;i<4;i++)     {         scanf("%c %d %d",&c[i],&a[i],&b[i]);         getchar();     }  加一个getchar()吸收下每行输入后的回车字符。


Question: 指针晕乎吖

p1是指向常量区的指针，一经分配内存，不可更改；你的函数是在操作无效内存，所以出错

你这么用指针是不对的，你第一个指针已经分配好了固定的字符串长度的地址，你再把第二个字符串的数组追加到第一个上，是相当于溢出的。

strcat 函数实现有误。请重写代码。

常量字符串不能被修改

指针是可以用的，应该是你的字符常量有问题

引用 17 楼 拥抱Linux的回复:[quote=引用 12 楼 涤 的回复:] [quote=引用 11 楼 拥抱Linux的回复:]1楼说的对！你的代码的问题，不是指针用得不对，而是没有区分清楚字符串常量和字符（串）变量。  开头的两句定义语句：  char *p1="people`s republic ";  char *p2="of China";  右边的两个字符串是作为常量储存或者放在内存中的常量区的，是不允许被代码修改的，否则会出现内存访问错误：segmentation fault (core dumped)。  简单地说，就是下面这样的赋值语句是错误的：  "people`s republic " = "people`s republic of China"; // 也就是， 常量 = （右值）;  因为，常量是不能被赋值的，是不允许的。也就是内存中的常量区是不允许这样修改的 。这样说，应该可以明白吧？ 那p1="mat"是可以的吧，这是改变p1的指向还是"mat" 代替了原来的字符串?为什么那两个字符串作为常量储存呢，作为常量储存是什么意思吖[/quote]  p1 = "mat"; 可以，因为 p1 是字符（串）指针变量，这条语句的意思是「把字符串"mat"的首地址赋予字符指针变量p1」，所以是可以的。 改变的是指针p1的指向，肯定不会改变"mat"呀！ 也不会代替原来的字符串"people`s republic "，因为现在等于是有了两个字符串："mat"和"people`s republic "，只不过现在p1指向了字符串"mat"而不再指向字符串"people`s republic "了。 常量，顾名思义就是恒常的量，就是在程序执行过程中，其值不发生改变的量；而与之相对，其值可变的量就称为变量。常量，包括常见的数值、字符串等，比如int型数值 1 就是int型常量，字符串"good" 就是字符串常量，它们被存放在内存中的常量存储区。 而何谓常量存储区或者常量区呢？这就涉及到内存中的分区问题，包括代码区、常量区、静态区（全局区）、堆区、栈区等，这方面的内容三言两语就不容易说清楚了，建议你根据这些关键词查找相关的资料了解学习一下吧。[/quote] 好的，我知道了，谢谢你的帮助吖

引用 12 楼 涤 的回复:[quote=引用 11 楼 拥抱Linux的回复:]1楼说的对！你的代码的问题，不是指针用得不对，而是没有区分清楚字符串常量和字符（串）变量。  开头的两句定义语句：  char *p1="people`s republic ";  char *p2="of China";  右边的两个字符串是作为常量储存或者放在内存中的常量区的，是不允许被代码修改的，否则会出现内存访问错误：segmentation fault (core dumped)。  简单地说，就是下面这样的赋值语句是错误的：  "people`s republic " = "people`s republic of China"; // 也就是， 常量 = （右值）;  因为，常量是不能被赋值的，是不允许的。也就是内存中的常量区是不允许这样修改的 。这样说，应该可以明白吧？ 那p1="mat"是可以的吧，这是改变p1的指向还是"mat" 代替了原来的字符串?为什么那两个字符串作为常量储存呢，作为常量储存是什么意思吖[/quote] char *p1 = (char[]){"people`s republic "};

引用 20 楼 lin5161678的回复:[quote=引用 19 楼 Cherry Cry  的回复:] 因为你对p1 p2 是const的  看你的赋值就知道  ，放在数组中或者放在容器中就可以错的 p1 p2都不是const的 p1 p2完全可以写在赋值符号左边[/quote] 不好意思，应该是常量指针 而不是指针常量   应该所指对象是不能修改的

引用 12 楼 涤 的回复:[quote=引用 11 楼 拥抱Linux的回复:]1楼说的对！你的代码的问题，不是指针用得不对，而是没有区分清楚字符串常量和字符（串）变量。  开头的两句定义语句：  char *p1="people`s republic ";  char *p2="of China";  右边的两个字符串是作为常量储存或者放在内存中的常量区的，是不允许被代码修改的，否则会出现内存访问错误：segmentation fault (core dumped)。  简单地说，就是下面这样的赋值语句是错误的：  "people`s republic " = "people`s republic of China"; // 也就是， 常量 = （右值）;  因为，常量是不能被赋值的，是不允许的。也就是内存中的常量区是不允许这样修改的 。这样说，应该可以明白吧？ 那p1="mat"是可以的吧，这是改变p1的指向还是"mat" 代替了原来的字符串?为什么那两个字符串作为常量储存呢，作为常量储存是什么意思吖[/quote]  p1 = "mat"; 可以，因为 p1 是字符（串）指针变量，这条语句的意思是「把字符串"mat"的首地址赋予字符指针变量p1」，所以是可以的。 改变的是指针p1的指向，肯定不会改变"mat"呀！ 也不会代替原来的字符串"people`s republic "，因为现在等于是有了两个字符串："mat"和"people`s republic "，只不过现在p1指向了字符串"mat"而不再指向字符串"people`s republic "了。 常量，顾名思义就是恒常的量，就是在程序执行过程中，其值不发生改变的量；而与之相对，其值可变的量就称为变量。常量，包括常见的数值、字符串等，比如int型数值 1 就是int型常量，字符串"good" 就是字符串常量，它们被存放在内存中的常量存储区。 而何谓常量存储区或者常量区呢？这就涉及到内存中的分区问题，包括代码区、常量区、静态区（全局区）、堆区、栈区等，这方面的内容三言两语就不容易说清楚了，建议你根据这些关键词查找相关的资料了解学习一下吧。

用这个string类不是很好吗?非要用char *吗？

引用 13 楼 lin5161678 的回复:[quote=引用 11 楼 拥抱Linux 的回复:] 1楼说的对！你的代码的问题，不是指针用得不对，而是没有区分清楚字符串常量和字符（串）变量。  开头的两句定义语句：  char *p1="people`s republic ";  char *p2="of China";  右边的两个字符串是作为常量储存或者放在内存中的常量区的，是不允许被代码修改的，否则会出现内存访问错误：segmentation fault (core dumped)。  简单地说，就是下面这样的赋值语句是错误的：  "people`s republic " = "people`s republic of China"; // 也就是， 常量 = （右值）;  因为，常量是不能被赋值的，是不允许的。也就是内存中的常量区是不允许这样修改的 。这样说，应该可以明白吧？例子错了  "people`s republic " = "people`s republic of China";   和你前面说的 和 楼主的错误 都没什么关系  这个是数组不能做左值  [/quote]  嗯，也可以这么说吧。俺当时举这个例子是基于两方面的原因，（1）字符串常量，是常量，不能作为左值，（2）具体这个字符串常量，是提问的代码里面的那个字符串常量，这样看比较直观，举别的例子，或者拿字符数组的数组名来举例的话，担心提问者不理解。  另外，俺之前看的资料是把数组名和具体字符串常量不能作为左值分开来讲的，所以俺也是一直把这两种情况分开来归类的，尽管这两种情况的编译器报错信息写的都是数组类型不能被赋值。 也多谢赐教！

引用 19 楼 Cherry Cry  的回复:因为你对p1 p2 是const的  看你的赋值就知道  ，放在数组中或者放在容器中就可以错的 p1 p2都不是const的 p1 p2完全可以写在赋值符号左边

引用 14 楼 我是瓶起子 的回复:[quote=引用 12 楼 涤 的回复:] [quote=引用 11 楼 拥抱Linux的回复:]1楼说的对！你的代码的问题，不是指针用得不对，而是没有区分清楚字符串常量和字符（串）变量。  开头的两句定义语句：  char *p1="people`s republic ";  char *p2="of China";  右边的两个字符串是作为常量储存或者放在内存中的常量区的，是不允许被代码修改的，否则会出现内存访问错误：segmentation fault (core dumped)。  简单地说，就是下面这样的赋值语句是错误的：  "people`s republic " = "people`s republic of China"; // 也就是， 常量 = （右值）;  因为，常量是不能被赋值的，是不允许的。也就是内存中的常量区是不允许这样修改的 。这样说，应该可以明白吧？ 那p1="mat"是可以的吧，这是改变p1的指向还是"mat" 代替了原来的字符串?为什么那两个字符串作为常量储存呢，作为常量储存是什么意思吖[/quote] char *p1 = (char[]){"people`s republic "};[/quote]现在的确是可以修改了  但是越界

引用 11 楼 拥抱Linux 的回复:1楼说的对！你的代码的问题，不是指针用得不对，而是没有区分清楚字符串常量和字符（串）变量。  开头的两句定义语句：  char *p1="people`s republic ";  char *p2="of China";  右边的两个字符串是作为常量储存或者放在内存中的常量区的，是不允许被代码修改的，否则会出现内存访问错误：segmentation fault (core dumped)。  简单地说，就是下面这样的赋值语句是错误的：  "people`s republic " = "people`s republic of China"; // 也就是， 常量 = （右值）;  因为，常量是不能被赋值的，是不允许的。也就是内存中的常量区是不允许这样修改的 。这样说，应该可以明白吧？例子错了  "people`s republic " = "people`s republic of China";   和你前面说的 和 楼主的错误 都没什么关系  这个是数组不能做左值

引用 11 楼 拥抱Linux的回复:1楼说的对！你的代码的问题，不是指针用得不对，而是没有区分清楚字符串常量和字符（串）变量。  开头的两句定义语句：  char *p1="people`s republic ";  char *p2="of China";  右边的两个字符串是作为常量储存或者放在内存中的常量区的，是不允许被代码修改的，否则会出现内存访问错误：segmentation fault (core dumped)。  简单地说，就是下面这样的赋值语句是错误的：  "people`s republic " = "people`s republic of China"; // 也就是， 常量 = （右值）;  因为，常量是不能被赋值的，是不允许的。也就是内存中的常量区是不允许这样修改的 。这样说，应该可以明白吧？ 那p1="mat"是可以的吧，这是改变p1的指向还是"mat" 代替了原来的字符串?为什么那两个字符串作为常量储存呢，作为常量储存是什么意思吖

也不是非要用数组，只是"people`s republic ";被编译为常量了，所以你可以*p1申请内存，然后拷贝"people`s republic ";  当然最方便还是用数组


Question: 数据结构顺序表初始化

引用 3 楼 自信男孩 的回复:引用 2 楼 qq_36536451 的回复:[quote=引用 1 楼 自信男孩 的回复:] 第一种情况是通过返回值，可以返回初始化的顺序表；第二种与第三种类似，即通过类似指针的形式，以传出参数的形式获取初始化的顺序表。第二种是C++才有的语法---引用&  主要是分配空间不清楚 分配空间，前两个都是堆上申请的，第三是栈上的空间（如果是局部变量）。  不同的空间，其生命周期也是不一样的，堆上空间是手动申请，手动释放，不释放知道程序退出才会被回收。栈上的空间是函数内。函数被调用，从第一的位置开始到函数调用结束被释放。  [/quote] 谢谢 嗯 还有最后一个问题  图一是给顺序表分配空间  图二是给数组分配空间   有什么区别吗  是因为图二数组大小没有定义吗   这样的话图二顺序表的空间又是怎么样的呢

引用 2 楼 qq_36536451 的回复:引用 1 楼 自信男孩 的回复:第一种情况是通过返回值，可以返回初始化的顺序表；第二种与第三种类似，即通过类似指针的形式，以传出参数的形式获取初始化的顺序表。第二种是C++才有的语法---引用&  主要是分配空间不清楚 分配空间，前两个都是堆上申请的，第三是栈上的空间（如果是局部变量）。  不同的空间，其生命周期也是不一样的，堆上空间是手动申请，手动释放，不释放知道程序退出才会被回收。栈上的空间是函数内。函数被调用，从第一的位置开始到函数调用结束被释放。


Question: c语言共用体内存共用问题，为什么和理解的不一样，求解答，谢谢

引用 5 楼 qybao 的回复：楼上的，你睁大眼睛看清楚的意思 不是两个不同的联合体变量（例子里是info2，info3，这是两个变量）共用一块内存好吧，看错，向你道歉，中文歧义多

引用 3 楼 qybao 的回复：联合体是里面的字段（例子里是stu1，stu2，stu3，这是联合体的字段）共用一块内存，不是两个不同的联合体变量（例子里是info2，info3，这是两个变量）共用一块内存。好好区别一下联合体的字段和联合体变量先不看变量类型，只要是2个分别定义的变量（int a；int b），他们就互不干扰，各自占用自己的内容，只是现在变量类型是共用体而已，这就转不过来。不要误人子弟

info2和info3不是同一个变量，你操作info2不会影响info3，输出bbdd

我的理解是共用体共用的内存是内部变量共用同一段内存，比如info2.stu2='a';那么info2这个联合体内的所有数据都共用一段数据，也就说stu1='a'、stu2='a'、stu3='a' 而在你的代码里info2和info4是两个联合体的实例，也就说他们是不同的联合体（当然联合体指针*info1和*info3也就不一样的啦），所以才会出现你所运行的效果。 为了验证这一点，你可以把info1和info3的内存地址打印出来看一下，肯定是不一样的。 下面是我电脑上的结果：


Question: 歌德巴赫猜想在线等

以后再也不回答这些结帖率为0的帖子了，都快2周了，还不结贴。

#include <stdio.h>  // 判断是否素数 bool IsPrimeNumber(int nNum) { 	bool bIsPrime = true; 	if (2 == nNum || 3 == nNum) 	{ 		return bIsPrime; 	}  	for (int i = 2; i*i <= nNum; ++i) 	{ 		if (0 != nNum %i) 		{ 			continue; 		} 		// 不是素数 		bIsPrime = false; 		break; 	}  	return bIsPrime; }  int main() { 	int k = 1; 	for (int n = 4; n <= 200; n = n + 2, ++k) 	{ 		for (int i = 2; i <= n / 2; ++i) 		{ 			bool bIsPrime = true; 			bIsPrime = IsPrimeNumber(i); 			if (bIsPrime) 			{ 				bIsPrime = IsPrimeNumber(n - i); 				if (bIsPrime) 				{ 					printf ("%d = %d + %d\t", n, i , n - i); 					if (0 == k % 5) 					{ 						printf ("\n"); 					} 					break; 				} 			} 		} 	} 	return 0; }  // 正确答案，结题给分，谢谢！

所以问题是什么？秀一下你的代码么？

不好意思， 少了 y 声明  BOOL isPrimeNo (int x) {     int  t = 2+ (int) sqrt(x);     int  y；       for (int k=2; k < t; ++k) {         y = x / k;         if (y * k == x) {             return FALSE;         }     }       return TRUE; }

判断是否是 质数的程序：   BOOL isPrimeNo (int x) {     int  t = 2+ (int) sqrt(x);      for (int k=2; k < t; ++k) {         y = x / k;         if (y * k == x) {             return FALSE;         }     }      return TRUE; }

引用 1 楼 下雨的猫的回复:#include <stdio.h> #include <stdlib.h> #include <math.h> int main() { 	int n,j,i,flag,t; 	for (n = 4;n <= 100;n = n + 2) 	{ 		for(i = 2;i < n;i++) 		{ 			flag = 1; 			j = 2; 			while(j < i) 			{ 				if(i % j == 0) 				{ 				flag = 0; 				break; 				} 				j++;  			} 			j = 2; 			t = n - i; 				while(j < t) 				{ 					if(i % j == 0) 					{ 						flag = 0; 							break; 					} 					j++; 				} 				if(flag == 1) 				{  				printf("%2d+%2d=%2d  ",i,t,n); 					} 			} 	}  	return 0;  } 兄弟，你算的结果里有9错了


Question: 回文判断

好的，谢谢指导。

搞复杂了，回文判断只需要一个头指针和尾指针依次判断就好了，为啥还要用栈数据结构？

nu@nu-System-Product-Name:~/Code/C++$ ./ab Please input a number: 123321 1, 1 2, 2 3, 3 3, 3 2, 2 1, 1 是回文数  补上测试方法！

问题搞得很复杂呢。单独用栈或者单独用队列都可以完成回文的判定，当然都用也是可以的。  #include<stdio.h> #include<stdlib.h>  typedef struct{     int *base;     int *top;     int stacksize; }stack;  typedef  struct node{     int data;     struct node *next; }node,*queue;  typedef struct{     queue front;     queue rear; }link;  int intstack(stack *s) {     s->base = (int*)malloc(10*sizeof(int));     s->top = s->base;     //s->stacksize=100;     s->stacksize = 10;     return 1; } int gettop(stack *s,int *e) {     if(s->top==s->base)         return -1;     *e = *(s->top-1);      return 0; }  int push(stack *s,int e) {     *s->top++ = e;      return 0; }  int pop(stack *s,int *e) {     *e = *(--s->top);      return 0; } int intqueue(link *q) {     q->front=q->rear=(queue)malloc(sizeof(node));     q->front->next=NULL;      return 0; } int enqueue(link *q,int e) {     queue p=(queue)malloc(sizeof(node));     p->data = e;     p->next=NULL;     q->rear->next = p;     q->rear = p;      return 0; } int getqueue(link *q,int e) {     e = q->front->data;      return e; } int dequeue(link *q,int *e) {     queue p=(queue)malloc(sizeof(node));     p = q->front->next;     *e = p->data;     q->front->next=p->next;     if(q->rear==p) q->rear=q->front;     free(p);      return 0; } int huiwen(char str[]) {  } int main() {     int a,b, m, n;     stack s;     link q;     intstack(&s);     intqueue(&q);      printf("Please input a number: ");     scanf("%d", &a);      while (a) {         b = a % 10;          push(&s, b);         enqueue(&q, b);         a /= 10;     }      while (s.base != s.top && q.front != q.rear) {         pop(&s, &m);         dequeue(&q, &n);         printf("%d, %d\n", m,  n);         if (m != n)             break;     }      if (s.base != s.top)         printf("不是回文数\n");     else if (q.front != q.rear)         printf("不是回文数\n");     else         printf("是回文数\n");   #if 0      printf("输入栈和队列:\n");     scanf("%d", &a);     while(a!=0)     {         push(&s,a);         enqueue(&q,a);         scanf("%d",&a);     }     printf("栈的输出:\n");     while(s.base!=s.top)     {         gettop(&s,&a);         printf("%d",a);         pop(&s,&a);     }     printf("\n");     printf("队列的输出:\n");     while(q.front!=q.rear)     {         dequeue(&q,&a);         printf("%d",a);     }     printf("\n");     printf("输入一串数字:\n");     scanf("%d",&b);     while(!b)     {         push(&s,b);         enqueue(&q,b);     }     while(!b)     {         if(gettop(&s,&b)!=getqueue(&q,b))         {             printf("不是回文数\n");         }     }     printf("是回文数\n"); #endif     return 0; }  供参考！ 栈和队列都用的方式判断回文。

然后我又改成了return *e和return e还是不对

引用 2 楼 Bule蓝 的回复:[quote=引用 1 楼 user-3的回复:]int gettop(stack *s,int *e)；int getqueue(link *q,int e)；你这两个函数都没有返回值，if(gettop(&s,&b)!=getqueue(&q,b))这一句比较的时候是没有那你的数字串来比较的，所以就出错了 不对呀，我加了一个return 1后，也没用呀。[/quote] 不能return 1 呀，你要把栈顶和队首的元素拿出来呀，要不他们比较相不相等的时候拿什么比

引用 1 楼 user-3的回复:int gettop(stack *s,int *e)；int getqueue(link *q,int e)；你这两个函数都没有返回值，if(gettop(&s,&b)!=getqueue(&q,b))这一句比较的时候是没有那你的数字串来比较的，所以就出错了 不对呀，我加了一个return 1后，也没用呀。


Question: 求教：如何求最短回路？（每条边只通过一次，通过所有顶点）注：边上数字为权值

欧拉回路问题，图中有顶点的度数是奇数，所以这个图不存在欧拉回路。

这种题目用迪杰斯特拉算法就可以解决，由于算法一言半语解释不清楚，给你看一下这篇文章，了解一下这个算法https://baike.baidu.com/item/%E8%BF%AA%E6%9D%B0%E6%96%AF%E7%89%B9%E6%8B%89%E7%AE%97%E6%B3%95/4049057?fr=aladdin


Question: 关于C语言有符号输出

引用 2 楼 weixin_44813559 的回复:[quote=引用 1 楼 拥抱Linux的回复:]因为在（1）占据4个字节的（2）有符号的int型里，-2147483648在内存中就是1...(31个0) 啊。 你定义的n在内存中不就是1...(31个0)这样的吗？那当然就输出-2147483648啦。 俺猜测你的困惑的原因不在于有符号、无符号int型，而在于int型数据在内存中的存储形式，要知道这些数据在内存中是以补码的形式存储的。对于补码而言，要获取真正的值并显示出来，就要把补码再转换回原码，然后才显示出来。 所以，对于1...(31个0)，以%d输出的时候，编译器首先判断了它是一个有符号Int型数据，1是符号位，不动，右边的31个0是补码，需要转换为原码，就成了2147483648，所以最终输出-2147483648。 你再看看什么是原码、反码、补码，应该就会明白了。 希望可以帮到你。 可是1...(31个0)转化为原码，符号位不动，取反加1就变成1...(32个0)了呀，怎么弄[/quote]  那怎么会呢？ 33个位就超出int的4个字节了呀！ （1）负数的补码，从根本上来说，就是由符号位结合它的绝对值（正数）的「真值」的二进制形式经过取反、加一后得来的。 具体到你的例子，-2147483648 的补码是什么？ 就是 符号位是 1 再「结合」它的绝对值 2147483648 的二进制形式经过取反、加一得来的啊。2147483648 的二进制形式是 1...(31个0)，取反之后是 0...(31个1)，再加一，得到1...(31个0)，这已经是32位了，对吧？ 那么，符号位的 1 放在哪里呢？ 符号位的 1  当然还是放在最高位啦， 那就和 刚刚得到的 1...(31个0) 的最高位的 1 重合了嘛！ 「重合」，注意一下，它还是只有32位，并不会去占据33位。这个 1...(31个0) 就这样就作为补码成功地表示了 负数 -2147483648 了呀。 （2）至于你说，由这个补码还原回去还原不了的问题，那是因为你还原的方法不对。 后面的31个0取反、加1，也只能得到 1...(31个0)啊，无论如何它还是得是32位啊！ 那还原回去的值，就是 符号位的 1 表示负，结合 1...(31个0) ，总的表示 -2147483648 了呀！明白了吧？  就是说，1...(31个0)作为有符号int型数据的话，它不能在内存里表示 正数 2147483648，但是不代表从数值概念上讲，它不是 正数 2147483648 的表示形式呀！这两个概念要区分开。 （3）你看4个字节的int型数据的机器里，int型的表示范围是多少？是[-2147483648,2147483647]，为什么最大值不是2147483648呢？因为它作为 int型 的话，那就表示不了啊！正数的补码就是它的原码，符号位是0，后面的才是数值位，而2147483648的二进制形式是1...(31个0)已经把32位空间都占满了，那么符号位的 0 去哪里呢？放到第33位去，那就超出4个字节了呀！ 放到最高位，那不就变成了0...(31个0)了吗？ 你看，这怎么办？ 没办法，int型它就是只有这么大的表示范围，这是规定啊！其实也有办法，把数据类型从 int型 改成 long int型不就好了吗？ ——所以，俺这段话想表达的意思就是，虽然 1...(31个0) 作为有符号 int型数据的时候，它不能在内存里表示 正数 2147483648，但是不代表从数值概念上讲，它不是 正数 2147483648 的二进制表示形式呀。巧就巧在 -2147483648 作为 int 型数据，它有补码，但是没有原码和反码。这也是为什么int 的表示范围没有关于 0 对称的原因，同时 0 的补码也只有 1个 的原因 。 （4）最后，再次建议你，看看什么是原码、反码、补码，包括它们的来龙去脉，以及在某个数据类型下的表示情况。

引用 1 楼 拥抱Linux的回复:因为在（1）占据4个字节的（2）有符号的int型里，-2147483648在内存中就是1...(31个0) 啊。 你定义的n在内存中不就是1...(31个0)这样的吗？那当然就输出-2147483648啦。 俺猜测你的困惑的原因不在于有符号、无符号int型，而在于int型数据在内存中的存储形式，要知道这些数据在内存中是以补码的形式存储的。对于补码而言，要获取真正的值并显示出来，就要把补码再转换回原码，然后才显示出来。 所以，对于1...(31个0)，以%d输出的时候，编译器首先判断了它是一个有符号Int型数据，1是符号位，不动，右边的31个0是补码，需要转换为原码，就成了2147483648，所以最终输出-2147483648。 你再看看什么是原码、反码、补码，应该就会明白了。 希望可以帮到你。 可是1...(31个0)转化为原码，符号位不动，取反加1就变成1...(32个0)了呀，怎么弄


Question: 两个多项式相加的程序为啥不对(~_~;)

引用 1 楼 user-1的回复:LinkList Add_L(LinkList P,LinkList Q)；你这一个函数里面的p都没初始化，然后主函数的Q也没有初始化，你试试改一下可不可以 改了，还是不行。输入系数和指数，没有输出，直接结束程序了。


Question: C语言疑问，请问各位大佬我这个为什么运行没结果

引用 楼主 user-0的回复:#include<stdio.h> #include<math.h> #define N 100 #define T 2000 void main() {  int i,j,l,k,k1;  double cha,x,y,s;  double t[T][N][N];  printf("\t\t\t二维非稳态导热问题\t\t");  printf("\n\t\t\t\t\t\t----\n");  printf("\n形区域，边长L=W=0.1，求该矩形区域内的温度分布。\n");  /*自动赋予温度初场*/   for(i=0;i<N;i++)    for(j=0;j<N;j++)     t[0][i][j]=600;  /*四个边界上的第一类边界条件*/  for(j=0;j<N;j++)  {   t[0][0][j]=10;   t[0][N-1][j]=10;  }  for(i=0;i<N;i++)  {   t[0][i][0]=20;   t[0][i][N-1]=20;  }  /*步长计算*/  x=(double)0.1/(N-1);  y=(double)0.1/(N-1);  s=(double)20.0/(T-1);  /*迭代循环*/ cha=1;k=0;   while(cha>0.0001&&k<T)/*迭代是否收敛判断*/   {   k++;k1=k; 	 for(i=1;i<N-1;i++)        for(j=1;j<N-1;j++)         t[k][i][j]=(t[k-1][i][j+1]+t[k-1][i][j-1]+t[k-1][i+1][j]+t[k-1][i-1][j]-4*t[k-1][i][j])*((0.0001062*s)/(x*x))+t[k-1][i][j];      cha=0; 	for(i=0;i<N;i++)       for(j=0;j<N;j++)        cha=cha+fabs(t[k][i][j]-t[k-1][i][j]);        cha=cha/(N*N);   }    /*输出温度分布，其中l控制输出值的排列;这个结果是按照笛卡尔坐标系下平面从左上角开始依次的*/  printf("\n经数值离散计算的该矩形区域内温度分布为：\n");  l=0; for(k=0;k<k1;k++)  for(j=0;j<N;j++)   for(i=0;i<N;i++)   {    printf("%4.3f ",t[k][i][j]);    l=l+1;    if(l==N)    {     printf("\n");     l=0;    }   }  /*为了是生成的exe文件结果算的后不会立即退出，方便观看*/  getchar();getchar();  /*其中第一个getchar读取了回车键，第二个getchar读取任意键*/ } 一块边长为 0.1x0.1(m)的正方形铜箔片，其厚度可忽略不计。初始时刻(t0=0s) 铜箔片温度 T0=600℃，此时突然将铜片边界分别与T∞=20℃、T∞=10℃的恒定冷源接触进行冷却降温；如图1已知铜箔片的导热系数λ=366W/(mk)，ρ=8930kg/m3  cp =386J/(kg*k) ,热扩散系数 a=0.0001062(m2/s)，忽略上下平面的导热，假定表面传热系数h=∞；构建二维常物性非稳态第二类边界条件导热问题；模型如图所示，计算在其他参数不变的情况下，铜箔片的温度随时间的变化规律以及温度分布。 关于二维非稳态迭代运算


Question: 简单C语言程序（C程序设计语言练习2-4），求指错~~~

结论，能正常输出？

引用 13 楼 17- 的回复:结论，能正常输出？ 我12楼的代码应该是没问题的，您遇到什么问题了吗？

引用 6 楼 qq_38834405 的回复:[quote=引用 4 楼 ZhouJunjie100 的回复:] [quote=引用 2 楼 qq_38834405 的回复:] 你的编译器不会报错吗在定义函数的时候 我好像一直这样定义函数诶，您是发现了什么问题吗？求分享~[/quote]对不起，孤陋寡闻了。。。第一次知道可以这么用。你代码问题在于数组越界，在第一个for循环的开始加个k=0就不会越界了。但是你的算法有问题。。（我以为越界是因为你没定义大小的缘故。。信口开河了。。[/quote] 可否详细说说我的算法问题是什么呢

引用 6 楼 qq_38834405 的回复:[quote=引用 4 楼 ZhouJunjie100 的回复:] [quote=引用 2 楼 qq_38834405 的回复:] 你的编译器不会报错吗在定义函数的时候 我好像一直这样定义函数诶，您是发现了什么问题吗？求分享~[/quote]对不起，孤陋寡闻了。。。第一次知道可以这么用。你代码问题在于数组越界，在第一个for循环的开始加个k=0就不会越界了。但是你的算法有问题。。（我以为越界是因为你没定义大小的缘故。。信口开河了。。[/quote] 感谢感谢，k忘了每次要初始化了，十分感谢你的回复和帮忙

引用 5 楼 qq_38834405 的回复:[quote=引用 3 楼 ZhouJunjie100的回复:]没有报错呀，您是觉得这句话哪里有问题吗 你得给大小。c数组初始化需要大小，声明的时候不用[/quote] 数组作为函数参数本质上应该是向函数传递数组指针，所以不用定义大小的

#include <stdio.h> #include<string.h>//加个头文件 /*在你的代码上修改的*/ void squeeze(char s1[100], char s2[100]); int main() { 	int temp_s1, i; 	char s1[100] = "abcdefghijklmnopqrstuvwxyz"; 	char s2[100] = "bcuvwx"; 	temp_s1 = strlen(s1);//计算s1的长度 	squeeze(s1, s2); 	for (i = 0; i < temp_s1; i++) { 		if (s1[i] != '\0') { 			printf("%c", s1[i]); 		} 	} 	return 0; } void squeeze(char s1[100], char s2[100]) { 	int k = 0; 	int temp_s1, temp_s2; 	temp_s1 = strlen(s1); 	temp_s2 = strlen(s2); 	for (int i = 0; i < temp_s1; i++) { 		for (int j = 0; j < temp_s2; j++) { 			if (s1[i] == s2[j]) { 				s1[i] = '\0';//相同就变成'\0' 			} 		} 	} }

引用 4 楼 ZhouJunjie100 的回复:[quote=引用 2 楼 qq_38834405 的回复:] 你的编译器不会报错吗在定义函数的时候 我好像一直这样定义函数诶，您是发现了什么问题吗？求分享~[/quote]对不起，孤陋寡闻了。。。第一次知道可以这么用。你代码问题在于数组越界，在第一个for循环的开始加个k=0就不会越界了。但是你的算法有问题。。（我以为越界是因为你没定义大小的缘故。。信口开河了。。

引用 3 楼 ZhouJunjie100的回复:没有报错呀，您是觉得这句话哪里有问题吗 你得给大小。c数组初始化需要大小，声明的时候不用

引用 2 楼 qq_38834405 的回复:你的编译器不会报错吗在定义函数的时候 我好像一直这样定义函数诶，您是发现了什么问题吗？求分享~

没有报错呀，您是觉得这句话哪里有问题吗

你的编译器不会报错吗在定义函数的时候

void squeeze(char s1[],char s2[]){

最后总结一下吧，我这道题的实现逻辑出现了问题。感谢大家的提醒~参考了书上的答案，把我最后的代码贴上来以供参考吧~ #include <stdio.h> void squeeze(char s1[],char s2[]); int main() { 	char s1[100]="abcdefghijklmnopqrstuvwxyz"; 	char s2[100]="bcuvwx"; 	squeeze(s1,s2);  	printf("%s",s1); 	return 0; } void squeeze(char s1[],char s2[]){ 	int k=0; 	int j=0; 	for(int i=0;s1[i]!='\0';i++){ 		for(j=0;s2[j]!='\0'&&s1[i]!=s2[j];j++); 		if(s2[j]=='\0') s1[k++]=s1[i]; 	} 	s1[k]='\0'; }

你大概是想不相同的保留在原位置。暂且先不谈这个能不能实现，你的k最大也就第二个数组的大小，最后k位置\0第一个数组就只能这么大了。（我觉得找相同比找不相同好解））


Question: 求大神帮我看看怎么回事，c语言链表！

楼主，你的后面那个*LinkList是什么意思啊

ABCD空指针，没有初始化，传参数也都有问题，void creatlist(LinkList &L,int n)，改为void creatlist(LinkList L,int n)，很多是指针问题


Question: socket通讯

MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl 安装MSDN98 然后在里面找socket的例子代码。


Question: error C2143: syntax error : missing ')' before ';' 求解答

不管是可读性还是后续修改上来讲，个人建议即便是循环或者判断只有一条语句，也加上大括号。 引用 8 楼 @风轻云淡_ 的回复:我觉得他们可能不是节约省略，而是忘记了。我就是这么过来的

我觉得他们可能不是节约省略，而是忘记了。我就是这么过来的

不要省略大括号哦，for循环后边，省略了就相当于只循环for后边的一句话

我发现很多初学者语法都不太熟，还喜欢沈略大括号

偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。

if(i=0; i<=L->last)  语法错误，if里面应该是一个表达式，而不是语句

if 的 圆括号 里 只能是 表达式， 不能是 语句；也就是说  if  的 圆括号 里 不能 有 分号 。

给个建议， 该加{}的地方不要节约 代码格式规范一点，问题很快就能找到

输出函数可以写成这样  void Output(SeqList *L)  //输出函数 { 	int i; 	for (i = 0; i <= L->last; i++) 			printf("%2d ", L->elem[i]); 	printf("\n"); }

if语句里不能有;啊,这有什么疑问?


Question: 宏定义的空格问题

引用 3 楼 拥抱Linux 的回复:[quote=引用 2 楼 上帝I文件 的回复:] [quote=引用 1 楼 拥抱Linux 的回复:] 上面的是对的，下面的宏定义里type和name没有空格的是错的。  （1）上面的type和name有空格的，  #define DECLARE(name, type) type name##_##type##_type  int main() { 	DECLARE(val, int); }  宏展开之后，是 int val_int_type  （2）下面的，type和name没有空格的，宏展开之后是 typename_int_type  对于第（2）个宏展开的结果，C编译器肯定把它当成一个标识符了，而且是一个没有定义的标识符，所以才会报错。  估计要么是试卷印刷错误？ 要么是故意写错来考查对宏展开的理解？谢谢回答，第一个代码是把“type name##_##type##_type”整个当做一个标识符了，也就是说，第二个空格后面的所有字符都会被当做一个标识符？那么是否可以理解为第一个标识符中不能有空格（括号内的空格除外）的存在？[/quote]  没看懂你这几句话是什么意思呢。。。特别是没看懂你说的什么当作标识符的意思。 实际上，无论是第一个代码还是第二个代码，根本的地方都在于，宏的展开究竟是如何实现的。 宏的展开，就是简简单单的文本替换，牢牢记住这个就可以了。 第一个代码：  #define DECLARE(name, type) type name##_##type##_type int main() {     DECLARE(val, int); }  宏展开的时候，就是用字符串"val"、"int"分别代替宏定义中的"name"、"type"，所以得到的结果是  int val_int_type;  在宏定义里面，原来的空格还是原来的空格呀，空格也是一个字符，也是整个宏的一部分啊！ 而第二个代码，  #define DECLARE(name, type) typename##_##type##_type  int main() {     DECLARE(val, int); }  宏展开的时候，同样也是文本替换，"val"、"int"分别替换宏里面的"name"、"type"，而"typename"很明显既不是"type"也不是"name"，当然就不能被替换了呀！  这里面，没有什么标识符的问题哦！ 宏，文本替换。就是这么简单！——千万不要把简单的问题复杂化了哦！ 不知道这样解释，能不能想通呢？[/quote] 谢谢，理解了

引用 2 楼 上帝I文件 的回复:[quote=引用 1 楼 拥抱Linux 的回复:] 上面的是对的，下面的宏定义里type和name没有空格的是错的。  （1）上面的type和name有空格的，  #define DECLARE(name, type) type name##_##type##_type  int main() { 	DECLARE(val, int); }  宏展开之后，是 int val_int_type  （2）下面的，type和name没有空格的，宏展开之后是 typename_int_type  对于第（2）个宏展开的结果，C编译器肯定把它当成一个标识符了，而且是一个没有定义的标识符，所以才会报错。  估计要么是试卷印刷错误？ 要么是故意写错来考查对宏展开的理解？谢谢回答，第一个代码是把“type name##_##type##_type”整个当做一个标识符了，也就是说，第二个空格后面的所有字符都会被当做一个标识符？那么是否可以理解为第一个标识符中不能有空格（括号内的空格除外）的存在？[/quote]  没看懂你这几句话是什么意思呢。。。特别是没看懂你说的什么当作标识符的意思。 实际上，无论是第一个代码还是第二个代码，根本的地方都在于，宏的展开究竟是如何实现的。 宏的展开，就是简简单单的文本替换，牢牢记住这个就可以了。 第一个代码：  #define DECLARE(name, type) type name##_##type##_type int main() {     DECLARE(val, int); }  宏展开的时候，就是用字符串"val"、"int"分别代替宏定义中的"name"、"type"，所以得到的结果是  int val_int_type;  在宏定义里面，原来的空格还是原来的空格呀，空格也是一个字符，也是整个宏的一部分啊！ 而第二个代码，  #define DECLARE(name, type) typename##_##type##_type  int main() {     DECLARE(val, int); }  宏展开的时候，同样也是文本替换，"val"、"int"分别替换宏里面的"name"、"type"，而"typename"很明显既不是"type"也不是"name"，当然就不能被替换了呀！  这里面，没有什么标识符的问题哦！ 宏，文本替换。就是这么简单！——千万不要把简单的问题复杂化了哦！ 不知道这样解释，能不能想通呢？

引用 1 楼 拥抱Linux 的回复:上面的是对的，下面的宏定义里type和name没有空格的是错的。  （1）上面的type和name有空格的，  #define DECLARE(name, type) type name##_##type##_type  int main() { 	DECLARE(val, int); }  宏展开之后，是 int val_int_type  （2）下面的，type和name没有空格的，宏展开之后是 typename_int_type  对于第（2）个宏展开的结果，C编译器肯定把它当成一个标识符了，而且是一个没有定义的标识符，所以才会报错。  估计要么是试卷印刷错误？ 要么是故意写错来考查对宏展开的理解？谢谢回答，第一个代码是把“type name##_##type##_type”整个当做一个标识符了，也就是说，第二个空格后面的所有字符都会被当做一个标识符？那么是否可以理解为第一个标识符中不能有空格（括号内的空格除外）的存在？


Question: 输出所有形如aabb的四位完全平方数(前两位数字相等，后两位数字相等)

基本数学思维都没有的话，学编程挺困难的

因为前两位数字相等，后两位数字相等


Question: 〔求教大神〕：C中用settimer实现定时，执行功能函数成功后可否得到一个功能码？

引用 1 楼 user-2的回复:在OnTimer if(nIDEvent==XXX)全局变量X=fun(); 然后获取这个全局变量X 你好，可否详细讲解一下呢？这个是用signal信号来确定fun的执行的，调用的fun是void型的

定时器回调fun传入一个全局变量地址，回调结果保存到这个里面就行啦

引用 3 楼 不解释、 的回复:[quote=引用 1 楼 user-2的回复:]在OnTimer if(nIDEvent==XXX)全局变量X=fun(); 然后获取这个全局变量X 你好，可否详细讲解一下呢？这个是用signal信号来确定fun的执行的，调用的fun是void型的[/quote] 那你就如三楼所说设一个全局变量，fun执行之后改变这个全局变量的值，在其他地方调用这个全局变量就知道执行的情况了

引用 1 楼 user-2的回复:在OnTimer if(nIDEvent==XXX)全局变量X=fun(); 然后获取这个全局变量X 不好意思，标题有误，这个用的是setitimer而不是SetTimer


Question: 哪位大佬可以看一下 这是什么意思

按工号排序的吧，，，


Question: 求大佬解决个问题，感谢

scanf("%lf",&a);

scanf("%lf,&a");<<======写错了，改成：scanf("%lf",&a);


Question: c语言链式队列问题

引用 10 楼 jsx_SEVEN的回复:[quote=引用 9 楼 qq_38780412的回复:][quote=引用 8 楼 jsx_SEVEN的回复:][quote=引用 7 楼 qq_38780412 的回复:] [quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点[/quote] 你是说不带头节点的吗？还是带头节点的啊？[/quote] 不带头结点，，嗯，对，不带[/quote] 我以为是带头节点的  我再看看你你之前说的  按照有带头结点的再想想

引用 9 楼 qq_38780412的回复:[quote=引用 8 楼 jsx_SEVEN的回复:][quote=引用 7 楼 qq_38780412 的回复:] [quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点[/quote] 你是说不带头节点的吗？还是带头节点的啊？[/quote] 不带头结点，，嗯，对，不带

引用 8 楼 jsx_SEVEN的回复:[quote=引用 7 楼 qq_38780412 的回复:] [quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点[/quote] 你是说不带头节点的吗？还是带头节点的啊？

引用 7 楼 qq_38780412 的回复:[quote=引用 6 楼 jsx_SEVEN的回复:][quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？[/quote] Q->front指向的是第一个结点，Q->front->next指向的是第二个结点

引用 6 楼 jsx_SEVEN的回复:[quote=引用 5 楼 qq_38780412 的回复:] [quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········ [/quote] Q->front-next不是指向第一个有元素的结点吗？ Q->rear=Q->front->next;这个不是把第一个结点Q->rear吗？

引用 5 楼 qq_38780412 的回复:[quote=引用 4 楼 jsx_SEVEN的回复:][quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊[/quote]  DestroyQueue(LinkQueue *Q) {      while(Q->front)      {           Q->rear=Q->front->next;   //队尾指针指向队首指针的下一个结点           free(Q-front);                       //释放队首结点            Q->front=Q->rear;             //队首指针指向队尾指针，      } }  链队一般不止一个结点。 当只有一个结点时，front和rear都指向那一个，第一句让rear指向front的下一个，也就是空；第二句释放这个结点；第三句让front也指向空。 当有多个结点时，假设有五个，front指向第一个，rear指向第五个，第一句让rear指向front的下一个，也就是第二个结点；第二句释放第一个结点；第三句让front指向当前队尾指针指向的这个结点，也就是第二个结点。然后下一次循环，第一句让rear指向第三个结点········

引用 4 楼 jsx_SEVEN的回复:[quote=引用 3 楼 qq_38780412 的回复:] [quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。[/quote] 那free(Q->front) 释放了Q->front,那下一句Q->front=Q->rear这句怎么解释啊

引用 3 楼 qq_38780412 的回复:[quote=引用 2 楼 jsx_SEVEN的回复:] //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解[/quote]  头结点不存东西的应该是带头结点的单链表，链队的实现用的是不带头结点的链表，额外增加了front和rear来指向第一个元素和最后一个元素。

引用 2 楼 jsx_SEVEN的回复: //*链队入队操作*// int EnterQueue(        LinkQueue * Q,int x) {         LinkQueueNode * NewNode;                            NewNode=(LinkQueueNode * )malloc(sizeof(LinkQUeueNode));   //*为NewNode申请节点*//          if(NewNode!=NULL)         {                 NewNode->data=x;                 NewNode->next=NULL;   //新结点的指针域指向空                 Q->rear->next=NewNode;    //链队的尾结点的指针域指向新结点                 Q->rear=NewNode;     //新入队的结点变成链队的尾结点                    return 1;                         }         else return 0;          }  如果没有 Q->rear->next = NewNode，新结点不会加入原链队 我刚刚看到一个销毁一个链式队列的代码 DestroyQueue(LinkQueue *Q) { 	while(Q->front) 	{ 		Q->rear=Q->front->next; 		free(Q-front); 		Q->front=Q->rear; 	} } 我想问一下Q->front不是头节点吗？头结点不是没有存储数据的吗？那while(Q->front)不就是为0吗？这步不太理解

看图最直接，上图，自己对比有没有必要~  理解半天不如动手画个图~~


Question: 有没有大佬

江湖救急，拿去用吧~~   #include<stdio.h> int main() { 	int n,a,b; 	double sum=0; 	printf("程序功能：计算s=1/2+2/3+3/5+5/8+8/13+13/21......\n"); 	do { 		printf("\n请输入要求和的项数："); 		scanf("%d",&n); 		if(n<1) 			printf("项数无效，请重新输入！\n\n"); 	} while(n<1); 	int i,tmp; 	a=1,b=2; 	for( i=0;i<n;i++){ 		printf("第%d项: %d/%d\n",i+1,a,b); 		sum+=a/(double)b; 		tmp=a+b; 		a=b; 		b=tmp; 	} 		printf("前%d项之和为%.2f\n",i,sum); 		return 0; 	}


Question: 关于sizeof函数计算结构体类型空间大小时遇到的问题

把结构体的末尾改成： } __attribute__(packed); 就可以防止对齐，从而达到需求。这在操作系统开发中非常有用

两条原则： 1.把数据的地址除数据的大小，如果余数结果为0（整除），那么数据就是对齐的。 2.结构最终大小是所对齐数据中最大数据的整数倍，如果不够需要进行填充。 根据这两条，那个数据结构是16，没有问题

这个是不一定的，因系统而已。有些系统必须把每个成员都放在偶数地址上，或4的倍数的地址上，会存在为使用的缝隙。––C Primer Plus

勘误一下： 上面写的「比如int型在32位、64位x86机器上占4个字节，它的地址的数值必须是4的整数倍，也就是 0x7fff....00 这样的地址。」把地址的值写错了，十六进制下4的倍数不是这样的，应该是二进制下的 .....00 这样的地址。一直习惯看到 十六进制的地址，一下子没改过来。不好意思啊！其它内容应该没有笔误。

对于结构体类型，成员的内存对齐，除了有结构体内部的对齐，还有整个结构体本身在内存中的对齐。 看过的一个参考资料，还是比较准确、形象的，截图如下： （1）  （2）  另外，结构体本身在内存中的对齐基数可以用宏alignof来得到，看资料是C11之后支持的，相关头文件为<stdalign.h>。 例如：  #include <stdalign.h> // 获取结构体变量TestStu本身的内存对齐基数，数值的单位是字节 printf("Alignment of int is %zu\n", alignof(TestStu));   输出结果是： Alignment of structure TestStu is 4 意思是，结构体变量TestStu在内存中占用的空间，要以4个字节为基数来对齐。  从上面的截图也可以看出，结构体成员没有占据的部分，就以空字节来占位（padding）。  另外，成员之间也不一定是紧密挨在一起的，各个类型都有相应的「地址的数值」的限制。 简单地说，占单个字节的类型没有限制，其它的占偶数个字节的类型都有限制，比如int型在32位、64位x86机器上占4个字节，它的地址的数值必须是4的整数倍，也就是 0x7fff....00 这样的地址。所以如果一个char和一个int顺序定义的话，在内存里，它们俩也不会紧挨在一起，而是二者之间有空的占位字节（padding）。   总结一下： 你看的书里提到的「如果没有自定义字节对齐数，变量会按照它本身对齐」这句话是对的，但是具体到你的例子，不能只考虑结构体成员而忽视了结构体变量本身——结构体变量也是变量啊！ 还有一点就是，在需要对齐的情况下，变量对地址的数值也是有要求的，不是见到一个地址就放上去的。  希望能帮到你。：）  PS. 在gcc的文档里也说过，数据在内存里也可以不对齐，直接一个紧挨着下一个也行，只是这样的读取效率就低多了。对齐是以空间换时间。

说实话，基本用不到这些，一般直接sizeof，然后再用到其他方面就好了

结构体的最终大小需要是其最大成员大小的整数倍，这个结构体是4个字节，所以A的后面还会预留3个字节，一共16

B后面补2个字节，A后面补3个字节，所以是16.另外，结构体对齐得到值是4个倍数，而不是一个13

引用 1 楼 user-9 的回复:结构体的最终大小需要是其最大成员大小的整数倍，所以A的后面还会预留3个字节。  这个就是最简单的计算标准。

结构体的对齐问题，不仅仅要考虑单个结构体，还必须考虑 结构体构成数组(array)时、相应的成员必须位对齐。显然上面说的 13字节进行array时无法 位对齐，如果补3个字节空位到16字节，再进行array时，可以实现位对齐。  位对齐要求，与系统内存分页操作便利有关。  ”如果没有自定义字节对齐数，变量会按照它本身对齐“, 这句话好像不对，应该与编译器设置有关（缺省位对齐)。

引用 1 楼 user-9 的回复:结构体的最终大小需要是其最大成员大小的整数倍，所以A的后面还会预留3个字节。 这是在哪本书里讲的，求教大佬

结构体的最终大小需要是其最大成员大小的整数倍，所以A的后面还会预留3个字节。


Question: c语言帮帮忙

在这里帮你是害你，这些都是最最基本的

引用 2 楼 qq_43428547 的回复:既然是wraning那肯定是语句错误  1.x没有加& 2.y没有加& 3.没有return 0； 4.if没有{} 5.else没有{} 6.x==0,y==0

商会出现小数 应该会警告 double转换到int出现截断，造成数据丢失


Question: 出现declaration syntax error错误

C语言没有bool类型，也没有取引用

c语言没有 bool类型


Question: 问一个问题

形参char  (*ss) [M]：是一个数组指针，是一个指向列数为M的二维数组

在调用fun这个函数时，以二维数组名x作为实参。 二维数组名x可以看成一个存放地址常量的指针，其值为二维数组中第一个元素的地址。 即x的值与x[0]的值相同，只是其基类型为具有M个char型元素的数组类型。 因此二维数组名可理解为一个行指针。 所以fun函数对应的形参也必须是一个行指针变量。 fun函数的首部可以是以下三种形式之一：  fun(char (*ss)[M]) /*上述代码使用形式*/ fun(char ss[ ][M]) fun(char ss[N][M])

这是ss是个指针   它指向一个char类型的数组，这个数组有M个元素

char(* ss)[M]  ss是指向 char[M]数组的指针