Question: 构造函数求解一元二次方程，，学弟求帮助，呜呜呜

else if(result=0){ 注意赋值和比较的区别

好嘞，谢谢您

引用 4 楼 weixin_46515136 的回复:再麻烦问一下  ，为啥输入1   -2  1得时候是  无解，是不是我最后一个else错了  改完==就可以了，不然只要result<=0,就直接到else里，输出无解了

好嘞  ，知道了

引用 2 楼 weixin_46515136 的回复:谢谢大哥，马上要交作业，感谢感谢  等一下  else if(result=0){  这个=改==

谢谢大哥，马上要交作业，感谢感谢

#include<stdio.h> #include<math.h> void hsz(double a,double b,double c) { double result,root; double x1,x2; result=b*b-4*a*c; if(result>0){ x1=(-b+sqrt(b*b-4*a*c))/(2*a); x2=(-b-sqrt(b*b-4*a*c))/(2*a); printf("%.3f,%.3f",x1,x2); } else if(result=0){ x1=(-b+sqrt(b*b-4*a*c))/(2*a); x2=x1; printf("%.3f,%.3f",x1,x2); } else{     printf("没有解");  }        }     int main(void)  {   double a,b,c;   printf("输入 a b c");   scanf("%lf%lf%lf",&a,&b,&c);   hsz(a,b,c);   return 0;  }  %.3f 改一下就可以了


问题解决了 ， 我发现是编译的时候 调用的自己的openssl库，但是运行的时候是local的库，没有把 自己的openssl库导入local里。


Question: 结构体类型的指针变量无法用于表达式，标识符为申明等错误

引用 1 楼 自信男孩 的回复： #include"DynamicList.h" //初始化链表 LinkList* Init_LinkList() {     LinkList* List=(LinkList*)malloc(sizeof(LinkList));     List->size=0;     List->head=(LinkNode*)malloc(sizeof(LinkNode));     List->head->data=NULL;     List->head->next=NULL;      return List; } //指定位置插入 void Insert_LinkList(LinkList* List,int Pos,void* data) {     if(List==NULL||data==NULL)     {         return;     }     if(Pos<0||Pos>List->size)     {         Pos=List->size;     }     //创建新的结点     LinkNode* Pnew=(LinkNode*)malloc(sizeof(LinkNode));     Pnew->data=data;     Pnew->next=NULL;      LinkNode* Pcur=List->head;     for(int i=0;i<Pos;i++)     {         Pcur=Pcur->next;     }     Pnew->next=Pcur->next;     Pnew->next=Pnew;      List->size++;  } //删除 void Remove_LinkList(LinkList* List,int Pos) {     if(List==NULL||Pos<0||Pos>=List->size)     {         return;     }     LinkNode* Pcur=List->head;     for(int i=0;i<Pos;i++)     {         Pcur=Pcur->next;     }      //缓存删除的结点     LinkNode* Pdel=Pcur->next;      Pcur->next=Pdel->next;     free(Pdel);      List->size--; } //获得链表的长度 int Size_LinkList(LinkList* List) {     return List->size; } //查找 int Find_LinkList(LinkList* List,void* data) {     if(List==NULL||data==NULL)     {         return -1;     }      LinkNode* Pcur=List->head->next;     int i=0;     while(Pcur!=NULL)     {         //if(Pcur->data=data)break;         if(Pcur->data==data)break;   //判断语句不要写成赋值语句         Pcur=Pcur->next;         i++;     }     return i; } //返回第一个结点 void* Front_LinkList(LinkList* List) {     return List->head->next; } //打印链表结点 void Print_LinkList(LinkList* List,PRINTLINKNODE print) {     if(List==NULL)     {         return;     }     LinkNode* Pcur=List->head->next;     while(Pcur!=NULL)     {         print(Pcur->data);         Pcur=Pcur->next;     } } //释放 void Free_LinkList(LinkList* List) {     if(List==NULL)     {         return;     }     LinkNode* Pcur=List->head;     while(Pcur!=NULL)     {         LinkNode* Pnext=Pcur->next;         free(Pcur);         Pcur=Pnext;     }     List->size=0;     free(List); }   #define _CRT_SECURE_NO_WARNINGS #include"DynamicList.h"  typedef struct PERSON{     char name[64];     int age;     int score; }Person;  //打印函数 void Myprint(void* data) {     Person* p=(Person*)data;     //printf("NAME:%S,AGE:%d,SCORE:%d\n",p->name,p->age,p->score);     printf("NAME:%s,AGE:%d,SCORE:%d\n",p->name,p->age,p->score);   //%S改成%s }  int main() {     LinkList* List=Init_LinkList();      Person p1={"A",18,100};     Person p2={"B",19,90};     Person p3={"C",20,80};      Insert_LinkList(List,0,&p1);     Insert_LinkList(List,0,&p2);     Insert_LinkList(List,0,&p3);      Print_LinkList(List,Myprint);      Free_LinkList(List);      system("pause");      return 0; } 供参考～  测试没有你贴出的这些问题，源码里有两处错误，对比一下找出自己的问题。  检查一下你的头文件名是否正确换成.cpp编译没有问题，.c一直出错


Question: 求数组转浮点数（float）的方法。

sscanf(buff, "%f%*c%f", &temp1, &temp2);

引用 楼主 pjzmj2012 的回复:求数组转浮点数（float）的方法。 如 有数组buff[]={3,0,1,7,'.',0,4,3,4,9,5,'N',1,2,0,0,6,'.'7,9,0,5,4,6,'E'} 转换为float temp1=3017.043495 temp2=12006.790546 那位大侠知道啊，在线等 或者有数组直接转经纬度的 时分秒也行。 字符数组格式固定就用sscanf格式化读入去掉特定的标识，再转为float就可以了


Question: 给定用户输入的N个不大于这个数的所有素数，并求和输出。:定义一个函数int isprime(int n)用于判断n是否为素数

大佬，能不能给我看看这个 match *Amend(match *head)//输入比赛信息  {  	system("cls"); 	system("color 72"); 	match *p1=head,*p2=head; 	char name1[15],name2[15]; 	int goal1,goal2; 	printf("输入主队:"); 	scanf("%s",name1); 	printf("输入客队:"); 	scanf("%s",name2); 	printf("输入主队得分:"); 	scanf("%d",&goal1); 	printf("输入客队得分:"); 	scanf("%d",&goal2);     while(p1!=NULL&&strcmp(p2->name,name1)!=0) 	{ 		p1=p1->next;  		 		if(p1!=NULL) 		{ 			p1->goal=p1->goal+goal1; 			p1->lose=p1->lose+goal2; 			if(goal1>goal2){ 			p1->num[1]++; 			} 			else if(goal1==goal2){ 				p1->num[2]++; 			} 			else{ 				p1->num[3]++; 			} 			p1->pure=p1->goal-p1->lose; 	        p1->integral=p1->num[1]*3+p1->num[2]; 	        p1->num[0]=p1->num[1]+p1->num[2]+p1->num[3]; 		} 	} 	   	     	while(p2!=NULL&&strcmp(p2->name,name2)!=0) 	{ 		p2=p2->next;  		 		if(p2!=NULL) 		{ 			p2->goal=p2->goal+goal2; 			p2->lose=p2->lose+goal1; 			if(goal2>goal1){ 			p2->num[1]++; 			} 			else if(goal1==goal2){ 				p2->num[2]++; 			} 			else{ 				p2->num[3]++; 			} 			p2->pure=p2->goal-p2->lose; 	        p2->integral=p2->num[1]*3+p2->num[2]; 	        p2->num[0]=p2->num[1]+p2->num[2]+p2->num[3]; 		} 	} 	    	return head; }

对偶٩(๑^o^๑)۶，谢谢谢谢

后面的printf也是同样的，使用了n做控制循环的变量

while(n--){   //n在读取输入的时候逐渐减少到0 scanf("%d",&m);  for(j=1;j<=n;j++){//这时候n等于0，直接循环结束了 ==========》用一个临时变量保存，来进行循环控制  int readn = n; while(readn--){   //n在读取输入的时候逐渐减少到0 scanf("%d",&m);  for(j=1;j<=n;j++){//这时候n等于0，直接循环结束了


Question: 这两处地方有什么区别

引用 3 楼 自信男孩的回复:[quote=引用 2 楼 weixin_45974777 的回复:] [quote=引用 1 楼 user-2的回复:]上面是按指定的格式读取文本文件，下面是按固定的大小（字节）读取二进制文件 可以吧上面那个for循环换成while循环吗[/quote] 可以的 [/quote] 好的，谢谢哥

引用 2 楼 weixin_45974777 的回复:[quote=引用 1 楼 user-2的回复:]上面是按指定的格式读取文本文件，下面是按固定的大小（字节）读取二进制文件 可以吧上面那个for循环换成while循环吗[/quote] 可以的

引用 1 楼 user-2的回复:上面是按指定的格式读取文本文件，下面是按固定的大小（字节）读取二进制文件 可以吧上面那个for循环换成while循环吗

上面是按指定的格式读取文本文件，下面是按固定的大小（字节）读取二进制文件


Question: C语言设计计算

不好意思看到的有点晚，希望能帮到你。 #include <stdio.h> #include <stdlib.h>  /* run this program using the console pauser or add your own getch, system("pause") or input loop */  #include <stdio.h>  double fun(int n, int a)  { 	double sum = 0.0; 	int Fm = 0; 	for(int i = 1;i <= n;i++) 	{		 			Fm = Fm*10+a; 			printf("Fm=%d,%d\n", Fm,a); 			if(i%2 == 0)sum =sum + (-1)*((float)i/(float)Fm); 			else sum = sum + ((float)i/(float)Fm);	 			printf("Fm=%lf\n", sum); 	} 	return sum; }   int main() {  	int a, n; 	double s = 0.01;  	printf("Enter n and a: "); 	scanf("%d%d", &n, &a); 	s = fun(n,a);  // 函数调用  	printf("n=%d, a=%d, s=%lf\n", n, a, s); 	return 0; }

是想学习学习各位的方法，如有冒犯还请见谅

兄台，对不起呀，自己一直在底下试，没有拿出来分享而已，因为9点前这个要提交了，放出这个题目是想看看大神们是怎么想的，没有大神回答的话，9点前我可能就提交自己的答案了，自己的尝试也是不够完善的

引用 2 楼 shanyumanlou 的回复:晚上9点前截止求问 为啥不自己想想，试着写写，完全拿出来问不应该是很理直气壮的事情

晚上9点前截止求问

在线等急问！！！！！


Question: 大佬求帮忙

引用 7 楼 自信男孩的回复:[quote=引用 4 楼 前行者001 的回复:] 你好，你的源程序好像存在好多问题。我下边都帮你找出来了。双斜杠后边注释的就是。 #include<stdio.h> #include<stdlib.h> struct node   {    	int  data;       struct node * next;   }; typedef struct node NODE;   typedef struct node * PNODE;  PNODE ins_list(PNODE p,int n)   //在尾结点后插入 {      PNODE p1;    p1 = (PNODE)malloc(sizeof(NODE));    p1->data = n;        p->next = p1;	//尾插法     p1->next = NULL;	//末尾结点的下一个结点置空         return p1;		//返回末尾结点  } void outlist( PNODE head )   {    	PNODE p;       p = head->next;      printf("删除后链表结点值\n");      while ( p != NULL)       {    		printf("%d  ", p->data);           p = p->next;       }   } void dele(PNODE head, int x)  { 	PNODE p1,p2,p3; 	p1 = head;  	p2 = p1->next;  	p3 = p2->next;  	while(p2->data !=x&&p3->next!=NULL)//当P2->data != x表示当前节点不是所寻找的节点  	{ 		p1=p1->next;   		p2=p2->next;  		p3=p3->next;  	} 	 	if(p3->next!=NULL)//如果P3不为空。说明上边的while循环找到了 x值点  	{ 		free(p2);p1->next = p3; 	} } int main() { 	int x,n; 	char k; 	PNODE head = (PNODE)malloc(sizeof(NODE)); 	head->next = NULL;//头指针一定要置空；不然输出的时候没法控制；  	PNODE p = head; 	while(1) 	{ 		scanf("%d",&n); 		p = ins_list(p, n);//返回尾结点  		k = getchar(); 		if(k=='\n') 		break; 	} 	scanf("%d",&x); 	dele( head, x ); 	outlist( head );       return 0;   }   测试结果 有问题的地方欢迎指正。  没看明白楼主的要求吧[/quote] 不好意思，我看错题意了。

引用 4 楼 前行者001 的回复:你好，你的源程序好像存在好多问题。我下边都帮你找出来了。双斜杠后边注释的就是。 #include<stdio.h> #include<stdlib.h> struct node   {    	int  data;       struct node * next;   }; typedef struct node NODE;   typedef struct node * PNODE;  PNODE ins_list(PNODE p,int n)   //在尾结点后插入 {      PNODE p1;    p1 = (PNODE)malloc(sizeof(NODE));    p1->data = n;        p->next = p1;	//尾插法     p1->next = NULL;	//末尾结点的下一个结点置空         return p1;		//返回末尾结点  } void outlist( PNODE head )   {    	PNODE p;       p = head->next;      printf("删除后链表结点值\n");      while ( p != NULL)       {    		printf("%d  ", p->data);           p = p->next;       }   } void dele(PNODE head, int x)  { 	PNODE p1,p2,p3; 	p1 = head;  	p2 = p1->next;  	p3 = p2->next;  	while(p2->data !=x&&p3->next!=NULL)//当P2->data != x表示当前节点不是所寻找的节点  	{ 		p1=p1->next;   		p2=p2->next;  		p3=p3->next;  	} 	 	if(p3->next!=NULL)//如果P3不为空。说明上边的while循环找到了 x值点  	{ 		free(p2);p1->next = p3; 	} } int main() { 	int x,n; 	char k; 	PNODE head = (PNODE)malloc(sizeof(NODE)); 	head->next = NULL;//头指针一定要置空；不然输出的时候没法控制；  	PNODE p = head; 	while(1) 	{ 		scanf("%d",&n); 		p = ins_list(p, n);//返回尾结点  		k = getchar(); 		if(k=='\n') 		break; 	} 	scanf("%d",&x); 	dele( head, x ); 	outlist( head );       return 0;   }   测试结果 有问题的地方欢迎指正。  没看明白楼主的要求吧

引用 3 楼 Robinhood169 的回复:不行啊 楼上的就可以了吗？符合你的预期吗？你的要求是删除输入的前置节点。楼主说不行，是哪儿不行了。问题就这样不了了

我明白了，谢谢大佬

不行啊

测试方法：11 22 33 44 55 66 77输完后回车，然后再输入EOF，最后输入val（key值）

#include<stdio.h> #include<stdlib.h>  struct node {     int  data;     struct node * next; }; typedef struct node NODE; typedef struct node * PNODE;    PNODE create_link(PNODE phead) {     int cnt, ret, n;     PNODE pnew, pcur;      //scanf("%d", &cnt);      pcur = phead;     while (1) {         ret = scanf("%d", &n);         if (ret == EOF)             break;         pnew = (PNODE)malloc(sizeof(NODE));         if (!pnew)             exit(0);         pnew->data = n;         pnew->next = NULL;         pcur->next = pnew;         pcur = pnew;     }      return phead; }  void visit_link(PNODE phead) {     PNODE pcur = phead->next;      while (pcur) {         printf("%d ", pcur->data);         pcur = pcur->next;     }     putchar(10); }   PNODE del_prev_node(PNODE phead, int val) {     PNODE pcur, prev, prev_prev;      prev_prev = prev = phead;     pcur = phead->next;      while (pcur) {         if (pcur->data == val) {             if (pcur == phead->next)                 break;             prev_prev->next = prev->next;             free(prev);             break;         }         prev_prev = prev;         prev = pcur;         pcur = pcur->next;     }      return phead; }  int main(void) {     int val;     PNODE phead = (PNODE)malloc(sizeof(NODE));     if (!phead)         return -1;      create_link(phead);      //visit_link(phead);     scanf("%d", &val);     del_prev_node(phead, val);     visit_link(phead);      return 0; }    #if 0 PNODE ins_list(PNODE head,int n) {     PNODE p1;     p1 = (PNODE)malloc(sizeof(NODE));     p1->data = n;     p1->next = head->next;     head->next = p1;     //p1->next = NULL;     //return p1;     return head; }  void outlist( PNODE head ) {     PNODE p;     p = head->next;     while ( p != NULL )     {         printf("%d\n", p->data);         p = p->next;     } } void dele(PNODE head, int x) {     PNODE p1,p2,p3;     p1 = head;     p2 = p1->next;     p3 = p2->next;     while(p2->data==x&&p3->next!=NULL)     {         p1=p1->next;         p2=p2->next;         p3=p3->next;     }     free(p2);     p1->next = p3; } int main() {     int x,n, cnt;     char k;     int ret, i;     PNODE head = (PNODE)malloc(sizeof(NODE));     PNODE p = head;     scanf("%d", &cnt);      i = 0;     while(i < cnt)     {         ret = scanf("%d",&n);         if (ret == EOF)             break;         ins_list(head, n);         //p = ins_list(head, n);          //k = getchar();         //if(k=='\n')          //  break;          i++;     }     outlist( head );     scanf("%d",&x);     dele( head, x );     outlist( head );     return 0; } #endif 供参考～  输入EOF，LINUX下输入ctrl+d，windows输入ctrl+z


Question: C语言设计计算

#include <stdio.h> #include <math.h>  double fun(int n);  // 函数声明  int main() {      int n;      double s;      scanf("%d", &n);      s = fun(n);  // 函数调用      printf("n=%d, s=%lf\n", n, s);        return 0;  }  static int is_prime(int n) {     int i;      if (n < 2)         return 0;     for (i = 2; i <= (int)sqrt(n); i++)         if (n % i == 0)             return 0;      return 1; }  static int get_prime(int from, int end) {     int i;      for (i = from; i <= end; i++)         if (is_prime(i))             return i;      return -1; }  // 函数定义  // 补全函数的代码实现  double fun(int n) {     double sum = 0;      int i, j, k = 0;     int flag = -1, ret;      i = 1, j = 2;      while (k < n) {         ret = get_prime(j, n);         if (ret < 0) {             k++;             continue;         }          j = ret;         printf("%c%d/%d + ", flag < 0 ? '-':' ', i, j);          sum += (flag * i*1.0/j);         i++;         j++;         flag *= -1;         k++;     }      return sum; } 供参考～


Question: 一道数据结构的题

可是必须要输入回车，不能输入其他字母呢

引用 7 楼 Robinhood169 的回复：不对啊，输入回车是无法终止程序的，输入一个字母或是符号倒是可以你如果知道scanf的返回值是什么，就知道我的*回车是什么意思了，scanf如果接收数据不正确时就返回0，所以你想停止输入时只要输入非数字就可以了。

引用 7 楼 Robinhood169 的回复:不对啊，输入回车是无法终止程序的，输入一个字母或是符号倒是可以 他说的是输入 * 回车。或者输入一个非数字的字符

不对啊，输入回车是无法终止程序的，输入一个字母或是符号倒是可以

引用 2 楼 Robinhood169 的回复:不好意思老哥，我想问的是如何建立链表，比如说我该怎么输入11 22 33 44 55后保证他是一个独立的链表，不是怎么求交集  上面main方法错了，改一下 typedef struct node {     int data;     node *next; } Node;  Node* createLink() {     Node *p=NULL, *L=NULL;     int n=0;     while (scanf("%d", &n) == 1) { //输入非数字则退出循环         if (L==NULL) {             p = L = (Node*)malloc(sizeof(Node));         } else {             p->next = (Node*)malloc(sizeof(Node));             p = p->next;         }         p->data = n;         p->next = NULL;     }     return L; } int main() {     Node *LA = createLink();     Node *p = LA;     while (p!=NULL) {         printf("%d ", p->data);         LA = p->next;         free(p);         p = LA;     }     return 0; }  程序运行后输入 11 22 33 44 55 *回车

引用 2 楼 Robinhood169 的回复:不好意思老哥，我想问的是如何建立链表，比如说我该怎么输入11 22 33 44 55后保证他是一个独立的链表，不是怎么求交集 原来你是想创建链表啊  typedef struct node {     int data;     node *next; } Node;  Node* createLink() {     Node *p=NULL, *L=NULL;     int n=0;     while (scanf("%d", &n) == 1) { //输入非数字则退出循环         if (L==NULL) {             p = L = (Node*)malloc(sizeof(Node));         } else {             p->next = (Node*)malloc(sizeof(Node));             p = p->next;         }         p->data = n;         p->next = NULL;     }     return L; } int main() {     Node *LA = createLink();     Node *p = LA;     while (p!=NULL) {         printf("%d ", p->data);         p = p->next;     }     free(LA);     return 0; }  程序运行后输入 11 22 33 44 55 *回车

不好意思，我刚刚开始学数据结构，还没有做过一些题目。那个题干只给了我一串链表的数据，我也想过在建立链表的函数中输入节点数，但我在建立链表的函数中输入了节点数，会算在输入的数据里面吗？如果算，那会不会与他给出的条件相冲突呢？

创建链表，你可以创建之前确定链表的节点个数呢 void traverse_list(LinkList L) {     LinkList p = L->next;      while(NULL != p) {         printf("%d ", p->data);         p = p->next;     }     printf("\n");     return; }  void create_list(LinkList *L) {     int i;     int n;     int val;      *L = (LinkList)malloc(sizeof(LNode));     LinkList pTail = *L;      pTail->data = 0;     pTail->next = NULL;      printf("请输入您需要生成的结点个数：");     scanf("%d", &n);      printf("输入数据\n");     //srand(time(0));     for(i = 0; i < n; i++) {         scanf("%d", &val);         //val = rand() % 1000;         LinkList pNew = (LinkList)malloc(sizeof(LNode));         pNew->data = val;         pNew->next = NULL;         pTail->next = pNew;         pTail = pNew;     }  } 比如，带哨兵节点的链表～

for example  Node *retains(Node *LA, Node *LB) {     Node *p, *LC=NULL;     Node *p1 = LA, *p2 = LB;     while (p1 != NULL && p2 != NULL) {         if (p1->data == p2->data) { //如果LA=LB，保存交集元素             if (LC == NULL) {                 LC = p =  (Node*)malloc(sizeof(Node));                 p->data = p1->data;                 p->next = NULL;             } else {                 p->next =  (Node*)malloc(sizeof(Node));                 p = p->next;                 p->data = p1->data;                 p->next = NULL;             }             p1 = p1->next;             p2 = p2->next;         } else if (p1->data < p2->data) { //否则如果LA小则移动LA指针指向下一个元素             p1 = p1->next;         } else { //如果LB小则移动LB指针指向下一个元素             p2 = p2->next;         }     }     return LC; }


Question: 为什么排序算法输入的数据超过1000，程序就无法运行啊..

引用 2 楼 自信男孩 的回复:楼主的程序没发现什么问题我确实编译了，小数据量也运行成功了，但是在程序里面跑的时候，输入的数据超过1100个左右的时候，程序的就不运行了.. 会这样一直闪光标

楼主的程序没发现什么问题

#include "stdio.h" #include "stdlib.h" #include "time.h"  typedef struct Node {     int data;     struct Node *next; }LNode, *LinkList;   /* //单链表插入排序算法 */ void insert_sort_list(LinkList L);    void insert_sort_list(LinkList *L) {     LinkList first;     LinkList t;     LinkList p;     LinkList q;     LinkList head;      /*        将链表拆为有序元素组成的链表和无序元素组成的链表        */     head= (*L)->next;     first = head->next;     head->next = NULL;      while (first != NULL) {         for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);          first = first->next;          if (q == head)         {             (*L)->next = t;             t->next = head;             head = (*L)->next;         }         else         {             p->next = t;             t->next = q;         }     }//; }  void traverse_list(LinkList L) {     LinkList p = L->next;      while(NULL != p) {         printf("%d ", p->data);         p = p->next;     }     printf("\n");     return; }  void create_list(LinkList *L) {     int i;     int n;     int val;      *L = (LinkList)malloc(sizeof(LNode));     LinkList pTail = *L;      pTail->data = 0;     pTail->next = NULL;      printf("请输入您需要生成的结点个数：");     scanf("%d", &n);      printf("输入数据\n");     srand(time(0));     for(i = 0; i < n; i++) {         //scanf("%d", &val);         val = rand() % 1000;         LinkList pNew = (LinkList)malloc(sizeof(LNode));         pNew->data = val;         pNew->next = NULL;         pTail->next = pNew;         pTail = pNew;     }  }  //main() { int main() {     LinkList La = NULL;     clock_t start, finish;     double  duration;      create_list(&La);     printf("排序前元素：");     traverse_list(La);      start=clock();      insert_sort_list(&La);      finish=clock();      printf("排序后元素：");     traverse_list(La);      duration = (double)(finish - start) / CLOCKS_PER_SEC;     printf( "%f seconds\n", duration );     return 0; }  亲测没问题


Question: 求助！！！在CodeBlocks里查看内存,Memory dump窗口总是一闪而过

不管哪个代码都这样…memory不能实时监控

可以发一下代码

菜鸟求助


Question: 求助，急！！！C语言初级

楼上正解而且比较简洁，如果你要好理解的话可以循环每次加一 for(i=1;i<=n;i++){     if(i%7==0){  //被7整除         if(i%3!=0){  //不被3整除             if(1%2==0){  //是偶数                  printf("%5d ", i);                  sum += i;             }         }     } } printf("\nsum=%d\n", sum);

for example int main(int argc, const char * argv[]) {     int n, sum=0, i;     printf("请输入n（n不大能大于%d）:", 0x0000FFFF);     scanf("%d", &n);     for (i=14; i<=n; i+=7) {         if (i%3!=0 && i%2==0) {             printf("%5d", i);             sum += i;         }     }     printf("\nsum=%d\n", sum);     return 0; }


Question: IDA F5反编译的注释到底都是什么意思呀，帮帮小菜鸡我吧。。。啊啊啊

就是局部变量分配的地址


Question: 用随机函数rand

多用几个判断不就好了？这个不难哦，自己看看。头文件time。srand(time(NULL));main先加句这个，作用跟随系统时间获取随机数，确保是不一样的。然后输入人的输入，判断（）判断完的执行语句里再判断后台控制的是啥 大概就是if（strcmp(str,'R')==0){if 后台控制1{x=rand()%100;...}if(2){x=rand()%100;...}};

请参考《C++中产生随机整数的方法（srand()函数与rand()函数）》 希望能够帮到你！


Question: gdb调试C程序的一个问题

嗯，这个地方主要是对bt命令的理解不到位。

当你的程序调用了一个函数，函数的地址，函数参数，函数内的局部变量都会被压入“栈”（Stack）中,bt命令是用来打印当前的函数调用栈的所有信息，如果你要打印变量就应该用 “p 变量”


Question: void InitializeList(List * plist)没有必要用指针的指针呀

引用 3 楼 落笔、守护爱 的回复:[quote=引用 2 楼 自信男孩的回复:]你的这个函数实现呢？不给实现怎么知道要不要用？ void InitializeList(List * plist) {     *plist = NULL; }[/quote] 那确实是需要二重指针，因为用一重指针和swap(int, int)交换两个变量的原因是一样的。

void func(int * ptr) { 	if (ptr != nullptr) 		delete ptr; 	ptr = nullptr; } void func1(int** ptr) { 	if (*ptr != nullptr) 		delete *ptr; 	*ptr = nullptr; } int main() { 	int *x = new int(10); 	func(x); 	cout << hex; 	cout << x << endl; 	x = new int(20); 	func1(&x); 	cout << x << endl;   } 试一下上边代码，自己体会一下其中的区别。

引用 9 楼 落笔、守护爱的回复:[quote=引用 7 楼 真相重于对错的回复:] 一个函数，参数是指针，在函数中修改这个指针的地址，函数返回后，那个指针依然是传入时的地址，只有参数是二级指针，修改参数的地址，函数返回后参数的地址才可能发生改变。 您好，这个函数不需要修改指针的地址呀[/quote] /* 函数原型 */ /* 操作：初始化一个列表           */ /* 操作前：plist指向一个列表      */ /* 操作后：该列表被初始化为空列表 */ void InitializeList(List * plist

之前的排版有点问题  /*下面两个函数表达的意思一样吗？*/ void listadd(List list, Node *pnode) {     list->next = pnode; } void listadd(Node *plist, Node *pnode) {     plist->next = pnode; } /*其实是一样的，第一个函数的参数list, 其实说到底是Node 指针 因为typedef Node * List; 只是 第一个函数让你看起来觉得， 更像是往链表（List嘛，翻译过来就是链表)加节点（Node） 第二个函数呢？ 什么？往节点加节点，你摇脑袋说，不可理解 这就是typdef Node *List; 让你觉得舒服的同时，使你迷失了 对指针，或者链表节点本质的理解。 */  /*最后回到链表，链表其实每个节点都是等价的， 打个比方，5个人组成一个小队，排成一排， 为了带点传奇色彩，想象这个小队是FBI特工组织，代号猎鹰 大家都用右手抓住相邻的人的肩膀，这样就形成一个简单的链表， 链表尾巴的人右手抓着空气（NULL）， 这个链表有5个人 但是要表示链表为空怎么办？ 我这里稍稍改下定义 */ typedef struct Node_t{     char name[16];     Node *next; }Node;  //两种方案：区别在于，你怎么定义头节点（链表标记）  /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1.空即是空，（注意不是色即是空） 没人表示空，Node *plist_head = NULL; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ bool is_empty(Node *p){     if(p == NULL)         return true;     else         return fals; } Node *plist_head = NULL; is_empty(plist_head);//?? ? : yes,空的 /* 但是这样带来一个麻烦，你要往里面加人 必须先创建这个链表头 */     /*-----------------------------     //1.1 (空即是空的 加入组织方法1)     *------------------------------*/     list_add(Node **phead, Node *pnode){  //这里用**，这样出来之后phead就改变了           if(*phead == NULL){             *p = (Node *)malloc(sizof(Node));   //who am I? 我是谁？？??         }         *p->next = pnode;     }     Node *plist_head = NULL; //list头，老大     Node p1 = {"张三"， NULL};     //假设你很莽，直接往头里加     list_add(&plist_head, &p1);     //---ok,现在组织里有两个人了，p是一个人，无名大哥，不知道他是谁，第一个小弟是张三     //---感觉有点怪怪的,一个登记在册的人员：张三，可是突然多出来的大哥蒙着面，不知道是谁      /*------------------------------------     //1.2(空即是空, 加入组织方法2, 先入为主)     *-----------------------------------*/     list_add(Node **phead, Node *pnode){  //这里用**，这样出来之后phead就改变了           if(*phead == NULL){             *phead = pnode;// 嘻嘻，先来的就是大哥, 假设这个phead是老大住的房子, 现在pnode住进去了             pnode->next = NULL;             return; //强调一下，可以出去了，这个组织已经不一样了，空组织迎来老大         }         else{             Node *old_first = *phead->next;             *p->next = pnode;             pnode->next = old_first;         }     }     Node *plist_head = NULL;     Node p1 = {"张三"， NULL};     list_add(&plist_head, &p1);      //---OK,现在组织里有一个人了，没错，张三就是老大了（苍天已死，黄天当立，张角可以继续招小弟了）     //---这样很OK，解决了组织口号问题，空即是空，又不会无故增加一个无民氏进来     //组织很有激情，新来的即可做大哥     //等一下！，我要执行初始化怎么办？，     //--要什么初始化，Node *plist_head = NULL; 完事了  /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //方案2 (色即是空，) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/      //2.1 现造个假人？还是弄个真人，抹去他的名字和记忆，让他当个工具人,随你怎么想了     //反正组织的缔造者认为，虚无缥缈的空不可捉摸，还是有个具体的东西代表一下比较实际     //明明是一个实体Node，却偏偏指鹿为马，Node，你不存在，你是空链表      bool is_empty(Node *plist){ //只是名字上命名为plist，你要知道，他总是Node *         /*         if(p == NULL)   //???，不带这么玩的，p必须是实体         */         if(p->next == NULL) //没有小弟             return true;         else             return false;     }      //来了来了，我的初始化函数终于派上用场,,终于切入楼主正题，初始化     void initialize_list(Node* plist)     {         // plist->name = ????; //无所谓啦，关键看你有没有带小弟         plist->next = NULL; //废了小弟先，     }     //      /*这里用*phead了，因为加人之前，必须要有个工具人头领存在，     不存在空即是空的问题, 可以对比之前1.2的实现*/     /*---------------------------------------     //2.2 加入组织的方法     *--------------------------------------*/     list_add(Node *phead, Node *pnode){           /*这个版本比起1.1的实现如何？         两个字舒服，而且没有使用双重指针，原来苦口婆心         虽然给我塞了个色即是空的概念（第一个节点明明存在，我却要说他是空链表）         但是没有双重指针就是爽，是不是？ 妈妈再也不用担心我的学习了~~~~~~~         */         Node *old_first = phead->next;         *p->next = pnode;         pnode->next = old_first;     }      Node head;  //既然是假人，英雄不问出身姓名，不要名字也罢, 也不知道他带了小弟没有（next）     initialize_list(&head); //强行把next置成NULL，     is_empty(&head);//yes!!, head明明看起来像个正常人，大活人，却要说他是空，这就是当老大的代价吧，色即是空     Node *p1 = (Node*)malloc(sizeof(Node));     strcpy(p1->name, "007");     Node *p2 = (Node*)malloc(sizeof(Node));     strcpy(p2->name, "谍影重重");     list_add(&head, p1);   //链表要领，无论何时，都要记得头是谁     list_add(&head, p2);      /*题外话, 这时候还能直接初始化链表吗？*/     initialize_list(&head); //???     /*想象下电影情节，这像是特工小组档案被直接删除，人还在，没有正常遣散，     也没给遣散费，后果是什么？, 幕后负责人会被清算，对就是你这个写代码的人，哈~     -正确的方式是遍历链表，把他们都free()掉，释放内存，     -安抚一下，现在是和平时期不需要特工了，（其实是没钱发工资了）*/      /*但愿你有这个耐心慢慢去体会, 并最终学会指针，链表？ 节点？     他们不再那么难以捉摸*/ /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~The End~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

谢邀 请注意 typedef Node * List;  // 指向Node(struct node)类型的指针， List已经是指针类型（Node指针） 你再定义，以下函数时 void InitializeList(List * plist); plist已经是指向指针的指针了，相当于Node **plist；  其实不建议定义这样的东西typedef Node * List;  这个并不会给你理解指针带来太多的便利 只是教材在好心玩把戏却让你迷失，他让你误以为List是链表，Node *则是节点。 是这个定义产生了这么神奇的效果吗？  施主，“空即是空，色即是空”，小僧备上一些代码，望施主能脱离苦海 =================以下代码不定义typedef Node *LIst；这种东西----  /*下面两个函数表达的意思一样吗？*/ void listadd(List list, Node *pnode) {     list->next = pnode; } void listadd(Node *plist, Node *pnode) {     plist->next = pnode; } /*其实是一样的，第一个函数的参数list, 其实说到底是Node 指针 因为typedef Node * List; 只是 第一个函数让你看起来觉得， 更像是往链表（List嘛，翻译过来就是链表)加节点（Node） 第二个函数呢？ 什么？往节点加节点，你摇脑袋说，不可理解 这就是typdef Node *List; 让你觉得舒服的同时，使你迷失了 对指针，或者链表节点本质的理解。 */  /*最后回到链表，链表其实每个节点都是等价的， 打个比方，5个人组成一个小队，排成一排， 为了带点传奇色彩，想象这个小队是FBI特工组织，代号猎鹰 大家都用右手抓住相邻的人的肩膀，这样就形成一个简单的链表， 链表尾巴的人右手抓着空气（NULL）， 这个链表有5个人 但是要表示链表为空怎么办？ 我这里稍稍改下定义 */ typedef struct Node_t{     char name[16];     Node *next; }Node;  //两种方案： /* 1.空即是空，（注意不是色即是空） 没人表示空， */ bool is_empty(Node *p){     if(p == NULL)         return true;     else         return fals; } Node *p = NULL; is_empty(p);//?? ? : yes,空的 /* 但是这样带来一个麻烦，你要往里面加人 必须先创建这个链表头 */ //1.1 (空即是空的 加入组织方法1)     list_add(Node **phead, Node *pnode){  //这里用**，这样出来之后phead就改变了           if(*phead == NULL){             *p = (Node *)malloc(sizof(Node));   //who am I? 我是谁？？??         }         *p->next = pnode;     }     Node *plist_head = NULL; //list头，老大     Node p1 = {"张三"， NULL};     //假设你很莽，直接往头里加     list_add(&plist_head, &p1);     //---ok,现在组织里有两个人了，p是一个人，无名大哥，不知道他是谁，第一个小弟是张三     //---感觉有点怪怪的,一个登记在册的人员：张三，可是突然多出来的大哥蒙着面，不知道是谁     1.2(空即是空, 加入组织方法2, 先入为主)     list_add(Node **phead, Node *pnode){  //这里用**，这样出来之后phead就改变了           if(*phead == NULL){             *phead = pnode;// 嘻嘻，先来的就是大哥, 假设这个phead是老大住的房子, 现在pnode住进去了             pnode->next = NULL;             return; //强调一下，可以出去了，这个组织已经不一样了，空组织迎来老大         }         else{             Node *old_first = *phead->next;             *p->next = pnode;             pnode->next = old_first;         }     }     Node *plist_head = NULL;     Node p1 = {"张三"， NULL};     list_add(&plist_head, &p1);      //---OK,现在组织里有一个人了，没错，张三就是老大了（苍天已死，黄天当立，张角可以继续招小弟了）     //---这样很OK，解决了组织口号问题，空即是空，又不会无故增加一个无民氏进来     //组织很有激情，新来的即可做大哥     //等一下！，我要执行初始化怎么办？，     //--要什么初始化，Node *plist_head = NULL; 完事了 //1.2 (色即是空，)     //1 现造个假人？还是弄个真人，抹去他的名字和记忆，让他当个工具人,随你怎么想了     //反正组织的缔造者认为，虚无缥缈的空不可捉摸，还是有个具体的东西代表一下比较实际     //明明是一个实体Node，却偏偏指鹿为马，Node，你不存在，你是空链表      bool is_empty(Node *plist){ //只是名字上命名为plist，你要知道，他总是Node *         /*         if(p == NULL)   //???，不带这么玩的，p必须是实体         */         if(p->next == NULL) //没有小弟             return true;         else             return false;     }      //来了来了，我的初始化函数终于派上用场,,终于切入楼主正题，初始化     void initialize_list(Node* plist)     {         // plist->name = ????; //无所谓啦，关键看你有没有带小弟         plist->next = NULL; //废了小弟先，     }     //      /*这里用*phead了，因为加人之前，必须要有个工具人头领存在，     不存在空即是空的问题, 可以对比之前1.1的实现*/     list_add(Node *phead, Node *pnode){           /*这个版本比起1.1的实现如何？         两个字舒服，而且没有使用双重指针，原来苦口婆心         虽然给我塞了个色即是空的概念（第一个节点明明存在，我却要说他是空链表）         但是没有双重指针就是爽，是不是？ 妈妈再也不用担心我的学习了~~~~~~~         */         Node *old_first = phead->next;         *p->next = pnode;         pnode->next = old_first;     }      Node head;  //既然是假人，英雄不问出身姓名，不要名字也罢, 也不知道他带了小弟没有（next）     initialize_list(&head); //强行把next置成NULL，     is_empty(&head);//yes!!, head明明看起来像个正常人，大活人，却要说他是空，这就是当老大的代价吧，色即是空     Node *p1 = (Node*)malloc(sizeof(Node));     strcpy(p1->name, "007");     Node *p2 = (Node*)malloc(sizeof(Node));     strcpy(p2->name, "谍影重重");     list_add(&head, p1);   //链表要领，无论何时，都要记得头是谁     list_add(&head, p2);      /*题外话, 这时候还能直接初始化链表吗？*/     initialize_list(&head); //???     /*想象下电影情节，这像是特工小组档案被直接删除，人还在，没有正常遣散，     也没给遣散费，后果是什么？, 幕后负责人会被清算，对就是你这个写代码的人，哈~     -正确的方式是遍历链表，把他们都free()掉，释放内存，     -安抚一下，现在是和平时期不需要特工了，（其实是没钱发工资了）*/      /*但愿你有这个耐心慢慢去体会, 并最终学会指针，链表？ 节点？     他们不再那么难以捉摸*/ /*~~~~~~~~~~~~~~~~~The End~~~~~~~~~~~~~~~~~~~~*/

你的函数名说明这个函数是用来进行初始化的，如果是初始化，要不要修改list？要修改的话为什么不需要用指针

打个比方，如果你要通过函数修改一个int的值，你会怎么做？一般有两种方法，通过引用或者指针传参，通过指针也就是传递一个int*的变量，那这样来理解，如果你要通过函数修改int的值，那么就用int*，再扩展，如果你要修改某种类型的值，那么就要传递这种类型的指针

引用 6 楼 user-5的回复:哦 我看错 List 本身是指针  等于这个参数是二级指针  那没什么问题了  改成一级指针这个接口就废了 麻烦您能说具体点吗

引用 7 楼 真相重于对错的回复:一个函数，参数是指针，在函数中修改这个指针的地址，函数返回后，那个指针依然是传入时的地址，只有参数是二级指针，修改参数的地址，函数返回后参数的地址才可能发生改变。 您好，这个函数不需要修改指针的地址呀

您好，这个函数不需要修改指针的地址呀

引用 1 楼 user-5的回复:反了 不但应该使用指针 如果写想用参数返回 还得使用二级指针 一级指针还不够  目前这个接口是算是废了 没有用到这个指针呀，不理解，

引用 1 楼 user-5的回复:反了 不但应该使用指针 如果写想用参数返回 还得使用二级指针 一级指针还不够  目前这个接口是算是废了 void InitializeList(List * plist) {     *plist = NULL; }

引用 2 楼 自信男孩的回复:你的这个函数实现呢？不给实现怎么知道要不要用？ void InitializeList(List * plist) {     *plist = NULL; }

你的这个函数实现呢？不给实现怎么知道要不要用？


Question: 新手求教新手求教

#include <stdio.h>  int main() {     int a[10]={-11,2,3,4,15,56,77,88,99,100};     int i,b,c;     printf("请输入要查找的数：\n");     scanf("%d", &b);     for(i=0;i<=9;i++)     {         if(a[i]==b)         {             c=i;             printf("这个数的下标为：%d",c);             break;         }         //else             //printf("没有这个数！");         //break;     }     if (i > 9)printf("没有这个数！");     return 0; } 供参考～  注意break的位置和判断没有这个数的位置


Question: ean13码校验码的计算(C语言)

引用 1 楼 user-1的回复:https://wenku.baidu.com/view/043b7f2b69eae009581beca1.html 谢谢大佬，可这个怎么用c语言代码运行出来呀


Question: count++后面加个break有什么用

跳出（p!=NULL)循环

跳出第二层while循环

加一个break就是跳出第二层循环～


Question: c语言文件操作，出现Runtime Error:Segmentation fault

引用 8 楼 joeblack1314 的回复:[quote=引用 7 楼 自信男孩 的回复:] 你在自己的电脑上跑跑是不是可以的？ 是可以的，但在学校网上提交就不对，结果老显示-7632，估计是内置的输入的数太大了，但是把k设置成long long int 也不行，就很气[/quote] 你看网上输出的是多个，而你自己电脑上输出的是几个，看一下是否把所有的情况都考虑进去了

引用 7 楼 自信男孩 的回复:你在自己的电脑上跑跑是不是可以的？ 是可以的，但在学校网上提交就不对，结果老显示-7632，估计是内置的输入的数太大了，但是把k设置成long long int 也不行，就很气

你在自己的电脑上跑跑是不是可以的？

引用 3 楼 自信男孩 的回复:[quote=引用 2 楼 joeblack1314 的回复:] [quote=引用 1 楼 自信男孩 的回复:] #include<stdio.h> #include<math.h>  int main() {      int n,e1,m,a[1000],i,b[1000],k;     FILE *fp;     fp=fopen("encryp.dic","r");     if (!fp)         exit(0);     //scanf("%d %d\n%d",&n,&e1,&m);     scanf("%d %d %d",&n,&e1,&m);     if (m >= 1000)         m = 1000-1;     for(i=1;i<=m;i++)     {           fscanf(fp,"%d",&a[i]);         k=(int)pow(a[i],e1);         b[i]=k%n;         printf("%d ",b[i]);     }      fclose(fp);     return 0;   } 供参考～ 还是不行啊兄弟[/quote] 我测试的没问题呢，结果输出和你的预计输出结果是一样的 你说的不行，是哪里不行。  [/quote]

你把k定义成long long试下吧，应该是溢出了

#include<stdio.h> #include<math.h>  int main() {      int n,e1,m,a[1000],i,b[1000],k;     FILE *fp;     fp=fopen("encryp.dic","r");     if (!fp)         exit(0);     //scanf("%d %d\n%d",&n,&e1,&m);     scanf("%d %d %d",&n,&e1,&m);     if (m >= 1000)         m = 1000-1;     for(i=1;i<=m;i++)     {           if (fscanf(fp,"%d",&a[i]) == EOF)             break;         k=(int)pow(a[i],e1);         printf("%d ", k % n);         //b[i]=k%n;         //printf("%d ",b[i]);     }      fclose(fp);     return 0;   } 供参考～

引用 2 楼 joeblack1314 的回复:[quote=引用 1 楼 自信男孩 的回复:] #include<stdio.h> #include<math.h>  int main() {      int n,e1,m,a[1000],i,b[1000],k;     FILE *fp;     fp=fopen("encryp.dic","r");     if (!fp)         exit(0);     //scanf("%d %d\n%d",&n,&e1,&m);     scanf("%d %d %d",&n,&e1,&m);     if (m >= 1000)         m = 1000-1;     for(i=1;i<=m;i++)     {           fscanf(fp,"%d",&a[i]);         k=(int)pow(a[i],e1);         b[i]=k%n;         printf("%d ",b[i]);     }      fclose(fp);     return 0;   } 供参考～ 还是不行啊兄弟[/quote] 我测试的没问题呢，结果输出和你的预计输出结果是一样的 你说的不行，是哪里不行。

引用 1 楼 自信男孩 的回复:#include<stdio.h> #include<math.h>  int main() {      int n,e1,m,a[1000],i,b[1000],k;     FILE *fp;     fp=fopen("encryp.dic","r");     if (!fp)         exit(0);     //scanf("%d %d\n%d",&n,&e1,&m);     scanf("%d %d %d",&n,&e1,&m);     if (m >= 1000)         m = 1000-1;     for(i=1;i<=m;i++)     {           fscanf(fp,"%d",&a[i]);         k=(int)pow(a[i],e1);         b[i]=k%n;         printf("%d ",b[i]);     }      fclose(fp);     return 0;   } 供参考～ 还是不行啊兄弟


Question: c语言程序停止工作,求教！

谢谢兄弟，已经懂了

#include<stdio.h> #include<stdlib.h>  int main() {     FILE *fp;     char s[100],a[100];      if( ( fp=fopen("a.txt","w+")) == NULL )     {         printf("can't open file!\n");         exit(-1);     }      //scanf("%s",&s);     scanf("%s",s);     fprintf(fp,"%s",s);   //文件写成功后fp会指向后面未被写的位置     rewind(fp);    //让fp指针重置，重新指向文件开头。     //fscanf(fp,"%s",&a);     fscanf(fp,"%s", a);     printf("%s",a);     fclose(fp);     return 0;   } 供参考～

明白了，感谢大佬

在fscanf(fp,"%s",&a);之前加一句 fseek(fp, 0L, SEEK_SET); ~~~~~~~~~~ 因为你在前面写文件，这时候文件指针位置是跟随着写的，已经到文件末尾 你读文件末尾是读不到东西的


Question: 关于C的几个问题

大小端是针对不同机器而言的，本机上不用担心这个问题

int *b = &a; *b=&a; 上面代码的两个*意义不同 第一个*，是代表类型，也就是定义了一个名字为b，类型为int*的变量 下面这个*，用来取内容，也叫解引用，也就是取出b这个int*指针的内容，它的内容是一个int类型，而你&a得到的是一个int*类型，int=int*，这样赋值，肯定会出错 你要想不报错 直接 b=&a就好了

定义的时候，int *b * 是类型说明符  定义之后 * 是地址访问符

int *b = NULL, *b=&a 这里b已经定义，因此*b就是对b指向内存的引用。 int *b = &a;是定义并初始化； 第二个问题，楼主最好能写个程序自己验证一下。


Question: 想知道问题出在哪里

#include<stdio.h> #include <stdlib.h>  int substract (int **a,int m,int n); int i,j,M,N,m,n,r; int main() {     //int  substract (int a[10][10],int m,int n);     printf("请输入矩阵的行与列：");     scanf("%d %d",&M,&N);     //int A[M][N];     int **A = (int **)malloc(sizeof(int *) * M);     if (!A)         exit(0);     for (i = 0; i < M; i++) {         A[i] = (int *)malloc(sizeof(int) *N);         if (!A[i])             exit(0);     }     for (i=0;i<M;i++)         for(j=0;j<N;j++)             scanf("%d",&A[i][j]);     r=substract(A,M,N);     printf("\n");     return 0; } int substract (int **a,int m,int n) {     int max,min;     for(j=0;j<n;j++)     {         max=a[0][j];         min=a[0][j];         for(i=1;i<m;i++)         {if(a[i][j]>max) max=a[i][j];             if(a[i][j]<min) min=a[i][j];}         printf("%d\n",max-min);     } } C语言不支持不定数组长度，因此如果行和列都不确定，可以考虑用动态申请空间的方法，建议楼主把释放内存的操作加上～

求助 谢谢！


Question: 十进制转换成八进制

直接贴代码吧

EmptyStack(&p)

那个函数要求的是指针，而不是值。


Question: 求详细说一下报错原因，本人萌新

参数类型对不上啊  hwnd


Question: 小白求助

cpoy_string(a,b);   //不是cpoy是copy 单词拼写错误：

#include <stdio.h> #include <stdlib.h>  int main() {     void copy_string(char from[],char to[]);     char a[]="I am a teacher.";     char b[]="You are a student.";     printf("string a=%s\nstring b=%s\n", a, b);     printf("copy string a to string b:\n");     copy_string(a, b);      //注意是copy_string     printf("\nstring a=%s\nstring b=%s\n", a, b);     return 0;  } void copy_string(char from[],char to[])  {  	int i = 0;  	while(from [i] != '\0')  	{         to[i] = from[i];         i++;     }     to[i] = '\0';  }

引用 1 楼 自信男孩的回复:cpoy_string(a,b);   //不是cpoy是copy 单词拼写错误： 啊，发现了，谢谢谢谢


Question: 关于*(p--) = *(p-1)的拆分

引用 1 楼 真相重于对错 的回复:你是要从后往前计算吗？请贴出全部代码？  代码不是我写的，不要骂我，我也不知道他想干啥。 只是我打断点跟进到*(p--) = *(p-1)这一行的时候， 发现结果跟自己想像的不太一样，有点不明白。  #include <stdio.h>  void fun(char* p, char value) { 	while (*p != '\0') 	{ 		p++; 	} 	p--; 	while (*(p + 1) < value) 	{ 		*(p--) = *(p - 1); 		*(p--) = value; 	}  	printf("%s", p); }  int main() { 	char p[] = "54679", value = '3'; 	fun(p, value); 	return 0; }

引用 2 楼 qybao 的回复:这个要看编译器的，因为语句本身语义有歧义 如果是=左边先运算，那就是你说的后者的情况，即先=左边p--，再把=右边的*(p-1)赋给*p。 如果是=右边先运算，就是先=右边的*(p-1)赋给*p，再=左边p-- 好像c++15以后统一等号右边优先运算  是的，我试了一下， 使用GNU gcc编译器编译的情况是:   先=左边p--，再把=右边的*(p-1)赋给*p； 而使用MSVC++ 15.0（VS2017）编译器的情况是:  先=右边的*(p-1)赋给*p，再=左边p--

或许可以用逗号表达式测试一下编译器对 表达式=表达式 处理的优先级 int main() {     int a[]={1,2,3};     int *p = &a[2];     printf("%p\n", p);     (printf("左:%p,%d\n", p, *p), *(p--)) = (printf("右:%p,%d\n", (p-1), *(p-1)), *(p-1));     printf("%p,%d,%d\n", p, *p, *(p+1));     return 0; }

你是要从后往前计算吗？请贴出全部代码？

引用 7 楼 docker_007 的回复:[quote=引用 6 楼 自信男孩 的回复:] p--; *pt = *(p-1); 你没发现p-1的p已经是p--之后的p了吗？  我当然知道啊，这段代码本来就是我拿来举例说明问题的。我晕[/quote] 知道，为啥还要提问呢？没明白你要提什么问题。

引用 6 楼 自信男孩 的回复:p--; *pt = *(p-1); 你没发现p-1的p已经是p--之后的p了吗？  我当然知道啊，这段代码本来就是我拿来举例说明问题的。我晕


Question: C语言求答案

11,p取a的地址，*p就是a原来的值，再加上b后结果赋值给a，等价于a=a+b

引用 1 楼 自信男孩的回复:a=*p + b;等价a = a+b;即11 非常感谢大佬

a=*p + b;等价a = a+b;即11

#include <stdio.h> #include <stdlib.h> int main() {     int a = 10, b = 1;     int * p = &a;     a = *p + b;     printf("%d", a); }  运行结果：a = 11


Question: 判断线性表为满为什么需要maxsize-1

所以为啥要减一啊  我感觉L->last>=maxsize就可以了

“多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，掰手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？

她讲错了，就是你想的那样，因为我的老师讲的就是L.length=MAXSIZE，（加上>当然更稳妥了）毕竟L.length代表的就是数组的元素个数，线性表中记录的个数。至于评论区的数组下标减一从0开始计数，我觉得和那些没有关系，length代表的是个数，和位序有什么关系

引用 1 楼 真相重于对错 的回复：从 0开始计数maxsize=数组长度=length    会吗？

引用 3 楼 yiyefangzhou24 的回复：int a[3]，实际上是a[0],a[1],a[2]但是长度还是3啊

int a[3]，实际上是a[0],a[1],a[2]

因为L->length是要做数组下表的，若下表是maxsize，那么数组越界了～

从 0开始计数

“不-1也可以”什么意思？？？？？ 我看不懂你在说什么？如果不明白，把代码贴出来，我可以告诉你。

引用 12 楼 真相重于对错 的回复：length 是要求大于等于maxsize-1，或者大于等于maxsize，差别不大，不过是后面代码加一，减一的问题。 具体你还有看其他的代码。就是说，不-1也可以？

引用 10 楼 真相重于对错 的回复：我觉得我已经说的相当清楚了。因为我没看到你的全部代码，我猜测那么length应该代表的是下标。。 否则，如果允许length等于2的话 L->elem[2+1]=L->elem[2]，不成立。。。这是前面的定义 #define Elem type int; typedef struct { 	Elem type lelm[maxsize]; 	int length; }seqlist;

引用 8 楼 真相重于对错 的回复：引用 6 楼 xiaojiaxi_ 的回复:[quote=引用 4 楼 bug10086 的回复：]从0开始，线性表最后一位下标是maxsize-1，当等于时表示已经装满了，大于就更不用说了它这里的maxsize-1不是下标啊，是个数，maxsize代表的数字不等于length吗 看你下边那句代码 for(k=L->length;k>=i;i--) L->elem[k+1]=L->elem[k] 如果L->length == maxsize-1; 那么  L->elem[maxsize-1+1]=L->elem[maxsize-1]; 也就是 L->elem[maxsize]=L->elem[maxsize-1]; 又因为elem应该是个数组，长度为maxsize,下标最大为maxsize-1；所以上述语句超过了elem的长度，越界了[/quote]elem确实是数组elem[maxsize]，如果这个maxsize取3，那length取maxsize-1也就是2时，顺序表还没满啊，还是可以插入啊

引用 6 楼 xiaojiaxi_ 的回复:引用 4 楼 bug10086 的回复：从0开始，线性表最后一位下标是maxsize-1，当等于时表示已经装满了，大于就更不用说了它这里的maxsize-1不是下标啊，是个数，maxsize代表的数字不等于length吗 看你下边那句代码 for(k=L->length;k>=i;i--) L->elem[k+1]=L->elem[k] 如果L->length == maxsize-1; 那么  L->elem[maxsize-1+1]=L->elem[maxsize-1]; 也就是 L->elem[maxsize]=L->elem[maxsize-1]; 又因为elem应该是个数组，长度为maxsize,下标最大为maxsize-1；所以上述语句超过了elem的长度，越界了


Question: 这个sprintf为啥没问题？

你对不可预知的理解有问题  不可预知是 无法确定有没有问题 不是保证会有问题

sprintf影响了第17个字节，但对于下一行的printf来讲没有任何的影响，因为printf函数对于内存是读的操作，但由于你的sprintf越界访问，1、就像你说的，第17年字节被其它变量使用的话，会导致其它变量的值不确定。2、如果第17字节是系统所使用的，操作系统的保护功能可能会中止程序的运行，也有可能直接让系统崩溃，在win98是测试过类似的情况，当字越界的很厉害，就死机了。3、这种越界如果精心构造，利用操作系统的漏洞获取目标计算机的shell,让其它执行某个程序。

VS2015调试，是越界添加了'\0'，最终能输出，但是程序再输出后会报错。

数组越界是未定义行为，因此可能成功，可能失败。  建议用snprintf


Question: 数据结构链表问题

引用 3 楼 自信男孩 的回复:[quote=引用 2 楼 Excel_lent 的回复:] [quote=引用 1 楼 自信男孩 的回复:] 楼主用C编译器编译吧，&作为形参，是C++支持的语法～  可以传二重指针~  我用的是浙江大学PTA的平台，我学的纯c语言，那是不是我就不能写（&L）这类语句？用devc编写的时候好像能通过[/quote] &是C++的语法～如果编译不通过，那就用二重指针吧[/quote] LinkList Read()是表示这个函数类型是LinkList 型，结构指针型吗？我们没有学C语言较高级的知识，看起数据结构有点吃力

引用 2 楼 Excel_lent 的回复:[quote=引用 1 楼 自信男孩 的回复:] 楼主用C编译器编译吧，&作为形参，是C++支持的语法～  可以传二重指针~  我用的是浙江大学PTA的平台，我学的纯c语言，那是不是我就不能写（&L）这类语句？用devc编写的时候好像能通过[/quote] &是C++的语法～如果编译不通过，那就用二重指针吧

引用 1 楼 自信男孩 的回复:楼主用C编译器编译吧，&作为形参，是C++支持的语法～  可以传二重指针~  我用的是浙江大学PTA的平台，我学的纯c语言，那是不是我就不能写（&L）这类语句？用devc编写的时候好像能通过

楼主用C编译器编译吧，&作为形参，是C++支持的语法～  可以传二重指针~


Question: 跪求大神指点！

#include <stdio.h> /*发现是奇数，补1，  */ void add_odd(int a[], int num) {     int i = 1;     for (; i < num; i++)     {         if (a[i] % 2 != 0)         {             a[i]++;         }      } } /*相等返回1， 不相等返回0,表示还要继续分*/ int check(int a[], int num) {     int equal = 1;     int i = 1;     for (; i < num; i++)     { 		if(a[i] != a[1]) 			return 0;	      } 	return equal; }  void main() {      int i, count = 0, a[11] = {0, 10, 2, 8, 22, 16, 4, 10, 6, 14, 20};      /***********SPACE***********/      while (1)     {         if(1 == check(a, 11)){             printf("count=%d number=%d\n", count, a[1]);             break;         }  		add_odd(a, 11);		//补奇数, 有可能补完就相等了,         if(1 == check(a, 11)){             printf("count=%d number=%d\n", count, a[1]);             break;         } 		/*************/         a[0] = 0;   //因为a[0]总是用来保存a[1]的一半         for(i = 1; i < 11; i++){             a[i-1] = a[i -1] /2 + a[i] /2;         }         a[10] = a[10] /2 + a[0];         count++;     } }


Question: 求解怎么可以反推出公式里的值

// elf_hash_chain = 0x0d00a9e9 	size_t v15 = 0x985B8C3D; 	size_t* elf_hash_chain = 0; 	size_t v16; 	do  	{ 		v16 = (((unsigned int)&elf_hash_chain[56102] & (v15 << 7) ^ v15) << 15) & 0xEFC60000 ^ (unsigned int)&elf_hash_chain[56102] & (v15 << 7) ^ v15; 	} while (elf_hash_chain = (size_t*)((size_t)(elf_hash_chain)+1) , v16 != 0x58199ABD && elf_hash_chain); 	 	v16 = (((unsigned int)&elf_hash_chain[56102] & (v15 << 7) ^ v15) << 15) & 0xEFC60000 ^ (unsigned int)&elf_hash_chain[56102] & (v15 << 7) ^ v15; 	printf("%p, %p, %p", v15, v16, elf_hash_chain);

引用 2 楼 user-1 的回复:&elf_hash_chain[56102]  表取地址而已（== elf_hash_chain+56102），与内部值无关  公式应该怎么改？当 v15 = 0x985B8C3D 时 v16 = 0x58199ABD


Question: c需要关于数值转换为hex的问题

直接对数组进行赋值就行啦，在内存中就是以16进制的方式保存的。 	unsigned char buff[4] = { 0 }; 	buff[2] = 3; 	buff[3] = 52;

引用 5 楼 自信男孩 的回复:可以用强转，比如 int a = 0x352; unsigned char buf[4]; memcpy(buf, &a, 4); 这样就放到buf里了。 其实也不用用buf这个变量，也可以 ((unsigned char *)&a)[0], ((unsigned char *)&a)[1], ((unsigned char *)&a)[2], ((unsigned char *)&a)[3], 需要注意下大小端的情况，先在一个小程序里试一下，然后了解大端和小端的情况再考虑发过去

引用 3 楼 不解释、 的回复:因为现在是这种情况，就是352这个数据可能是这种组合形式（xxxxxxxx），收到设备的指令hex为 00 00 03 34，然后这些数据转为10进制是 0  0  3  52，按上面那种组合形式就是00352，去掉前面的0，就是352（就是说这个352可能是组合的值），所以现在就是要反过来，将352转为 00 00 03 34，该怎么实现，大佬指点一下 不用这么麻烦吧，直接全部转网络字节序，不分设备，大端小端的，接收方再转回来。

引用 1 楼 user-4的回复:字节不是这个意思  你描述得太乱 无法理解  352  4个字节的内容是 0x00 0x00 0x01 0x60 不是03一个字节 52一个字节 我意思是能否把352分成3和52，然后再以这种转为16进制！！就是原数据两个两个的拆分开，再把拆分后的转为16进制


Question: c语言gets函数不起作用

在控制台中通过键盘输入数据时，以回车键作为结束标志。当输入结束后，键盘输入的数据连同回车键一起被输入到输入缓冲区中。在程序中第一次调用getchar()函数从输入缓冲区中读取一个字节的数据。需要注意的是，如果此时在程序中第二次调用getchar()函数，因为此时输入缓冲区中还有回车键的数据没有被读出，第二个getchar()函数读出的是回车符。 以上节选自《C++中getchar()的使用方法》 希望能够帮到你！ 另外你的两段代码中，n和N都没有指定值，for怎么能循环起来呢？

引用 1 楼 自信男孩 的回复:gets是遇到换行符返回，因此第一个如果不加getchar，那么输入n之后输入的'\n'就会被gets（第一个）接收，直接返回。要有getchar，我也有这个问题，受教了


Question: 【新手求助】C语言sscanf从字符串中提取指定的几个字符串并打印

引用 4 楼 自信男孩 的回复:#include <stdio.h> #include <string.h>  int main(void) {     char str[] = "04-06 00:04:15.667 24906 24906 E AndroidRuntime: FATAL EXCEPTION: main";     char substr[32], tmpstr[64], *pstr;     int len;       pstr = str;     len = strlen(str);     while (pstr < str+len && sscanf(pstr, "%s", substr)) {         puts(substr);         pstr += strlen(substr);     }      return 0; }  运行一下这个程序，你就可以了解到格式化的输入是怎么样的～   虽然不是我想要的，但是还是结贴吧，谢谢大佬的回答  以下是我的想法： 我想用C/C++实现一个通过过滤adb日志的闪退关键字并且截图功能，速度要很快的，因为闪退瞬间还要执行截图的adb命令能抓到闪退前的页面，哪个语言效率快就用哪个实现 首先是通过 popen执行"adb logcat -c && adb logcat"命令，然后在日志中找是否存在“FATAL EXCEPTION”的关键字（闪退时会有），能尽量快，能不循环遍历就不循环，缩减时间。 目前还差过滤关键字符集还未实现,以下是我的代码：   #include <stdio.h> #include <stdlib.h> #include <string.h> #include<regex> #include <iostream>  using std::cout; using std::endl; int _System(const char * cmd, char *pRetMsg, int msg_len, char *key) { 	FILE * fp; 	char * p = NULL; 	int res = -1; 	char s1[1024] ;  	if (cmd == NULL || pRetMsg == NULL || msg_len < 0) 	{ 		printf("命令输入不能为空/内存不足\n"); 		return -1; 	} 	 	if ((fp = _popen(cmd, "r")) == NULL) 	{ 		printf("Popen Error!\n"); 		return -2; 	} 	else 	{ 			while (!feof(fp)) { 			//还差过滤关键字未实现 				if(fscanf(fp,"%s", s1)){ 					//如果读取的字符中存在“FATAL EXCEPTION”或“FATAL”关键字就执行adb截图命令 					system("adb -s HFKGK19921000041 shell \" LD_LIBRARY_PATH=/data/local/tmp /data/local/tmp/minicap -P 720x1440@720x1440/0 -s > /sdcard/ExceptionScrenn/200.png\""); 				} 				  			} 	} }  int main() { 	char *key = ".*FATAL EXCEPTION.*"; 	char *cmd = "adb logcat -c && adb logcat"; 	char a8Result[125] = { 0 }; 	 	_System(cmd, a8Result, sizeof(a8Result), key);  	return 0; }

引用 1 楼 自信男孩 的回复:sscanf格式化，以空格或回车作为分隔符。  建议楼主用写个程序自己验证一下～   大佬快来帮解答啊，又分拿

就是不知道规则才格式化匹配不对咯    意思参考这个帖子 https://bbs.csdn.net/topics/390810095 知道的大佬帮忙解答下

sscanf格式化，以空格或回车作为分隔符。  建议楼主用写个程序自己验证一下～


Question: 数据结构疑问

题主说的应该是&运算符吧，这个表示返回，也就是每执行一次这个函数，都需要返回（return)这个L，这是这个函数运行所特殊需要的。

那个是引用！

类似于 **L 的作用吧。


Question: 行编辑程序【栈和队列】


Question: 输入一个二进制数，输出它的16位二进制数。

引用 3 楼 chxchxkkk 的回复:并没有越界，他的循环是从1到16。 循环次数没错，但数组下标错，数组下标是从0开始算的，所以是0到15

数组越界～数据越界是未定义行为，所以可能运行没问题，也可能出错～

for(i=1;i<=16;i++) i 最大值 16  a[16] 就越界了

引用 2 楼 qybao 的回复:你先弄清楚数组a[16]的下标是从什么开始到什么结束吧，应该从0到15，但是你用了16，数组越界了 并没有越界，他的循环是从1到16。

什么意思？ 输入一个二进制数，输出一个二进制数？？？？


Question: c语言

Description 输入10个学生，每个学生的数据包括学号、姓名、3门课的成绩。定义结构体类型表示学生类型，输入10个学生的数据， 计算每个学生的平均成绩。按平均成绩由高到低输出所有学生信息，成绩相同时按学号从小到大输出。  { 输入格式 10个学生信息，每行一个学生  输入样例 1 aaa 50 60 70 2 bbb 50 50 50 3 ccc 60 70 80 4 ddd 40 40 40 5 eee 70 80 90 6 fff 30 30 30 7 ggg 80 90 100 8 hhh 20 20 20 9 iii 100 100 100 10 jjj 10 10 10  输出样例 9 iii 100 100 100 7 ggg 80 90 100 5 eee 70 80 90 3 ccc 60 70 80 1 aaa 50 60 70 2 bbb 50 50 50 4 ddd 40 40 40 6 fff 30 30 30 8 hhh 20 20 20 10 jjj 10 10 10 } #include <stdio.h>  struct data {     int num;     char name[100];     float score[3];     float avg, sum; };  int main() {     int i,j;     struct data stu[10],tmp;     for(i=0; i<10; i++)     {         printf("请输入学生的学号：");         scanf("%d", &stu[i].num);          printf("请输入学生的姓名：");         scanf("%s", stu[i].name);          stu[i].sum = 0;         for(j = 0; j < 3; j++)         {             printf("请输入学生的第%d门成绩：",j+1);             scanf("%f", &stu[i].score[j]);             stu[i].sum += stu[i].score[j];         }          stu[i].avg = stu[i].sum / 3;         printf("该名学生的平均成绩为：%.2f", stu[i].avg);         printf("\n\n");     }      for(i=0; i<9; i++)         for(j=0; j<9-i; j++)         {             if (stu[j].avg < stu[j+1].avg)             {                 tmp = stu[j];                 stu[j] = stu[j+1];                 stu[j+1] = tmp;             }             else if (stu[j].avg == stu[j+1].avg)             {                 if (stu[j].num > stu[j+1].num)                 {                     tmp = stu[j];                     stu[j] = stu[j+1];                     stu[j+1] = tmp;                 }             }         }      for(i=0; i<10; i++)     {         printf("%d %s %.0lf %.0lf %.0lf\n", stu[i].num, stu[i].name, stu[i].score[0], stu[i].score[1], stu[i].score[2]);     }     return 0; }  涉及结构体的使用，题目类似，仅供参考


Question: C语言

还有你第三行应该是： int i,sum=0;  要加逗号和分号的。

自己看一下。 a=1,b=100 sum=5050   #include <stdio.h>  void main() {     int a,b,sum=0,i;     scanf("%d%d",&a,&b);     for(i=a; i<=b; i++) sum+=i;     printf("sum=%d",sum); }   你的代码： i如果是表示起始位置，那就是对的。 i如果是表示终止位置，那就是错的。  正确的在1楼回复了。

引用 1 楼 user-1的回复:我想知道你i是用来记录什么的。  如果i是起始位置，那么i=1，输出就是5050，答案是对的。   #include <stdio.h>  void main() {     int i,sum=0;     printf("请输入一个i的值");     scanf("%d",&i);     while(i<=100) {         sum=i+sum;         i++;     }     printf("sum=%d",sum); }    如果i是终止位置，那么i=100时，答案时5050.  #include <stdio.h>  void main() {     int i,sum=0;     printf("请输入一个i的值");     scanf("%d",&i);     while(i) {         sum+=i;         i--;     }     printf("sum=%d",sum); }  你能告诉错误之处吗，然后把正确的写给我看看吗


Question: c小胖在线求答案，请各路大神指点迷津～

引用 2 楼 Jacob Cai的回复:  #include <stdio.h> #include <stdlib.h> int main() {     int m, n;     int i;     printf("请输入两个数字：");     scanf("%d", &m);     scanf("%d", &n);     for(i = 1;; i++)     {         if(i % n == 0 && i % m == 0)         {             break;         }     }     printf("%d", i); }   谢谢大佬

引用 1 楼 simple 小白的回复:你可以在里面加一个比较，比较出m,n的大小 然后i=大的这个数，从输入最大的数开始找 例如： #include<stdio.h> int main() {     int m, n, temp, i;     printf("Input m & n:");     scanf("%d%d", &m, &n);     if(m<n)      {         temp = m;         m = n;         n = temp;     }     for(i=m; i>0; i++)           if(i%m==0 && i%n==0)         {             printf("%d\n", i);             break;         }      return 0; } 谢谢大佬


Question: 请问大佬windows上EOF必要性

引用 楼主 ?Victor.?? 的回复:在windows系统下  ctrl+z好像在\n刷完之后才起作用  while( (c = getchar()) != EOF )  这种表达式想要ctrl+z起作用，必须之前有\n  while( (c = getchar()) != EOF && c != '\n')  这种表达式ctrl好像根本起不到作用，因为要先输一个\n，所以就把(c = getchar()) != EOF屏蔽掉了  那么不如直接用\n了，EOF必要性不大  我表达的好像不是很清楚  有没有大佬有类似经历呢 那还是有区别的，如果只要'\n'，那就不能多行输入了；但是加上EOF，就可以多行输入了，所以多行输入的时候EOF还是必要的。

Linux下我试了bash和zsh也都是这样的，可能是因为shell是行缓冲，只有敲下回车输入的东西才会发给程序

EOF最早应该是在UNIX上的一个概念，UNIX一切皆文件，但是在windows的定义下面，EOF没有那么重要，所以好像定义处理起来没有那么严格，也导致一些没有随时可响应EOF机制。个人理解，不对的勿喷


Question: 应该是比较老的标准

引用 6 楼 ?Victor.?? 的回复:[quote=引用 5 楼 自信男孩 的回复:] 对于EOF, LINUX下输入ctrl+d Windows下输入ctrl+z  while( (c = getchar()) != EOF )     {          putchar( c );          sum += c;      } 这个循环，不应该是c每次读取一个字符然后和EOF比较  不相等就执行putchar()吗，也就是输入一个输出一个  但实际是输入一串，然后输出一串  请问是为什么呢 [/quote] 因为标准输入是行缓冲，需要输入回车才会将输入的内容刷到内存，否则是在输入缓存里。因此只有输入回车才会执行getchar()

引用 5 楼 自信男孩 的回复:对于EOF, LINUX下输入ctrl+d Windows下输入ctrl+z  while( (c = getchar()) != EOF )     {          putchar( c );          sum += c;      } 这个循环，不应该是c每次读取一个字符然后和EOF比较  不相等就执行putchar()吗，也就是输入一个输出一个  但实际是输入一串，然后输出一串  请问是为什么呢

对于EOF, LINUX下输入ctrl+d Windows下输入ctrl+z

引用 3 楼 qybao 的回复:[quote=引用 2 楼 ?Victor.?? 的回复:] 嗯，谢谢大佬  我先输入字符串， 然后\n, 然后ctrl+z, 然后\n， 输出的sum值是不是还包括了一个\n的值 输入的sum应该只包含第一个\n ,第二个\n理论上应该是进不了while循环的[/quote]  比较神奇的是，必须\n才能EOF

引用 2 楼 ?Victor.?? 的回复:嗯，谢谢大佬  我先输入字符串， 然后\n, 然后ctrl+z, 然后\n， 输出的sum值是不是还包括了一个\n的值 输入的sum应该只包含第一个\n ,第二个\n理论上应该是进不了while循环的

引用 1 楼 user-3 的回复:键盘按Ctrl+Z输入EOF信号  嗯，谢谢大佬  我先输入字符串， 然后\n, 然后ctrl+z, 然后\n， 输出的sum值是不是还包括了一个\n的值

键盘按Ctrl+Z输入EOF信号


Question: C语言问题

百度，求二元一次方程的整数解。

#include <stdio.h>  int main(void) {     int i,j;      //for (i=1; i<=422; i++)     for (i=0; i<=422; i++)     {         //for (j=1; j<= 384; j++)         for (j = 0; j<= 384; j++)         {             if (50.8 * i + 55.8 * j == 21450) {                 printf("i = %d, j = %d\n", i, j);                 break;             }         }         if (j <= 384)             break;     }      printf("i = %d, j = %d\n", i, j);      return 0; } 供参考～

这是要求 x, y的值吗，供参考  #include <stdio.h>  int main(void) { 	int i,j; 	double x, y; 	for (i=1; i<=422; i++) 	{ 		for (j=1; j<= 384; j++) 		{ 			if (50.8 * i + 55.8 * j == 21450) 			{ 				x = i; 				y = j; 			} 		} 	} 	 	printf("x = %.2lf, y = %.2lf\n", x, y); 	 	return 0; }


Question: 有没有高手帮忙解决读取二进制文件到二维vector，谢谢

所谓的vector 这种类型，其实有个称呼叫做BMO(Big Memory Object) ,这种类型也很好理解，也就是所类里面包含一个或多个指针字段，这些指针指向了大的内存对象。 举个例子 class A{     T *ptr; public:    } 这种类型非常重要，因为这种类型的存在，才造成拷贝构造函数，移动构造，析构函数，赋值操作符等必须自定义，而不能用编译器自动提供的。 因此，把它写入文件，不能直接read,或 write,因为那样，你写入和读出只是个地址，而不是地址里面的内容。 你那样读对于一维，可能没有问题。但对于二维，就会出问题。

我是指vector的数据结构是这样的

不要把vector写入到文件中，而是把vector中的数据写入文件中

两个一维的元素个数不同，但是已知

这个二维数组是这样的：  vector<int>> V;  vector <vector<int>> VV;   V.push_back(33); V.push_back(13); V.push_back(71);    VV.push_back(V);V.clear();   V.push_back(24); V.push_back(35); V.push_back(63); V.push_back(26);  V.push_back(45);    VV.push_back(V);V.clear();  数据情况是上面这样的，也就是元素个数是已知的。是不是就知道了一维分隔，请指点。

除非文件中有一维的分隔符，不然不能将各个一维数据分别开。


Question: 编译通过，运行无结果

1: exit(0);表退出程序，放在函数中是否放错了？ 2：我记得pip要开两个进程才能测试，你再看看pip原理。


Question: 不理解下面指针的含义，求解。

可以简单地把&理解为取地址的运算符，运行结果就是b的地址；*可以理解为取内容的运算符，可以取出指针指向的内容。为了便于理解，可以分别尝试printf("%d",p)和printf("%d",*p)，看一看输出的结果有什么区别。必然是一个输出地址码，一个输出值。

你理解的都没错，只是你对这个语句的理解错了 int *p=&b;   // 相当于两个语句； int *p; p = &b; ============ 假设你来设计C语言语法，现在有个需求，需要在变量定义的时候进行初始化。 如果是个整型，你也许会想 int b = 5; 嗯，这样很直观，也很完美； 要是一个指针变量呢？  int *p = &b;?很直接。 还有其他办法吗？ int *p =???,, int *p是在做什么事情？这里的* 是解引用吗？ 在定义的时候，*是用来表明这个变量的与众不同，表明p是一个指针变量，然后*号使命结束。

int *p 定义一个 int 类型的指针 p,  int *p = &b, &在这里是取地址的意思， 把指针p指向变量 b 的地址。 *p 是取出 指针 p 指向的变量 b 的值，这里就是 5 了。

你这个 2 怎么回事， 5 吧


Question: 这是哪错了？错误提示program received signal sigsegv segmentation fault

引用 6 楼 自信男孩的回复:[quote=引用 4 楼 weixin_46695826 的回复:] [quote=引用 3 楼 weixin_46221273 的回复:] [quote=引用 2 楼 weixin_46695826的回复:]这应该是对比两个单链表，找出其相同元素存入一维数组中。 那么，链表中存储的数据类型是否为int，这段代码中无法看出。 是否应该加一行：typedef int slink; 是的呀 typedef int ElemType; typedef struct node{ 	ElemType data;     struct node *next; }slink;[/quote]  #include <stdio.h>   //如果头文件没有问题的话，那可能是编译器的问题，我这里运行没有error提示 [/quote] 链表创建呢？没有创建直接用链表怎么可以呢？[/quote] #include<stdio.h>typedef int ElemType;typedef struct node{	ElemType data;    struct node *next;}slink;slink* crelink1(int n){	slink *p,*head,*s;	int i;	p=head=(slink*)malloc(sizeof(slink));	for(i=1;i<=n;i++){		s=(slink*)malloc(sizeof(slink));		p->next=s;		scanf("%d",&s->data);		p=s;	}	p->next=NULL;	return head;	}slink* crelink2(int n){	slink *p,*head,*s;	int i,a[10];	p=head=(slink*)malloc(sizeof(slink));	for(i=0;i<n;i++){		s=(slink*)malloc(sizeof(slink));		p->next=s;		a[i]=p->data;		p=s;	}	p->next=NULL;	return head;	} void list(slink *head){	slink *p;	p=head->next;	printf("The list is ");	while(p!=NULL){		printf("%d\t",p->data);			p=p->next;	}}int change1(slink *head1,slink *head2){		slink *p,*q;		int a[10],j=0,m,n,t;		for(p=head1->next;p!=NULL;p=p->next){		for(q=head2->next;q!=NULL;q=q->next)			if(p->data<=q->data){				a[j]=p->data;				j++;			}	}		for(m=0;m<j;m++){		for(n=1;n<=j;n++){			if(a[n]>a[m]){				a[n]=t;				t=a[m];				a[m]=t;			}		}	}	return j;	}main(){    slink *SL1,*SL2,*SL3;	int i,j;	printf("Input slink1 number:");	scanf("%d",&i);	SL1=crelink1(i);    list(SL1);    printf("\nInput slink2 number:");	scanf("%d",&j);	SL2=crelink1(j);    list(SL2);    printf("\n处理后为："); 	SL3=crelink2(change1(&SL1,&SL2));    list(SL3);}

引用 4 楼 weixin_46695826 的回复:[quote=引用 3 楼 weixin_46221273 的回复:] [quote=引用 2 楼 weixin_46695826的回复:]这应该是对比两个单链表，找出其相同元素存入一维数组中。 那么，链表中存储的数据类型是否为int，这段代码中无法看出。 是否应该加一行：typedef int slink; 是的呀 typedef int ElemType; typedef struct node{ 	ElemType data;     struct node *next; }slink;[/quote]  #include <stdio.h>   //如果头文件没有问题的话，那可能是编译器的问题，我这里运行没有error提示 [/quote] 链表创建呢？没有创建直接用链表怎么可以呢？

引用 4 楼 weixin_46695826的回复:[quote=引用 3 楼 weixin_46221273 的回复:] [quote=引用 2 楼 weixin_46695826的回复:]这应该是对比两个单链表，找出其相同元素存入一维数组中。 那么，链表中存储的数据类型是否为int，这段代码中无法看出。 是否应该加一行：typedef int slink; 是的呀 typedef int ElemType; typedef struct node{ 	ElemType data;     struct node *next; }slink;[/quote]  #include <stdio.h>   //如果头文件没有问题的话，那可能是编译器的问题，我这里运行没有error提示 [/quote] 我的文件拓展名是. c不是. cpp

引用 3 楼 weixin_46221273 的回复:[quote=引用 2 楼 weixin_46695826的回复:]这应该是对比两个单链表，找出其相同元素存入一维数组中。 那么，链表中存储的数据类型是否为int，这段代码中无法看出。 是否应该加一行：typedef int slink; 是的呀 typedef int ElemType; typedef struct node{ 	ElemType data;     struct node *next; }slink;[/quote]  #include <stdio.h>   //如果头文件没有问题的话，那可能是编译器的问题，我这里运行没有error提示

引用 2 楼 weixin_46695826的回复:这应该是对比两个单链表，找出其相同元素存入一维数组中。 那么，链表中存储的数据类型是否为int，这段代码中无法看出。 是否应该加一行：typedef int slink; 是的呀 typedef int ElemType; typedef struct node{ 	ElemType data;     struct node *next; }slink;

a[j]=p->data; // j 是否保证小于10 ?


Question: C语言，

随手写一个也就一分钟不到。。。 int main() {     int n = 0, i;     while (scanf("%d", &n) == 1) {         for (i=0; i<n; i++) {             printf("*");         }         printf("\n");     } }


Question: C语言关于float和double的指定精度问题（非格式化打印）

感谢分享！！1

过来学习一下

学习一下技术

wahahahah

你为什么要减少保留的位数

过来学习学习。

学习了，谢谢大佬激烈的讨论

学习了，谢谢。

学习了，谢谢

引用 21 楼 user-11的回复:[quote=引用 20 楼 不解释、 的回复:] [quote=引用 19 楼 user-11的回复:]sprintf格式化是有四舍五入处理的。 我知道，这操作相当于是先把数据格式化为自己想要精度的字符串，然后再字符串转成浮点型数据，最后将这个转换后的数据发送，    前面都正常，就是在发送的时候，这个数据就变成了好多位小数;这个json函数得参数类型就是double类型的，跟这个有没有关系？ 还有这个转换后的浮点型数据在做为参数传递的时候，会不会后面已经补0了？[/quote] 这个应该是你用的json库的时候转换的问题，你还是详细查一下使用[/quote] 嗯好的，谢谢！

引用 20 楼 不解释、 的回复:[quote=引用 19 楼 user-11的回复:]sprintf格式化是有四舍五入处理的。 我知道，这操作相当于是先把数据格式化为自己想要精度的字符串，然后再字符串转成浮点型数据，最后将这个转换后的数据发送，    前面都正常，就是在发送的时候，这个数据就变成了好多位小数;这个json函数得参数类型就是double类型的，跟这个有没有关系？ 还有这个转换后的浮点型数据在做为参数传递的时候，会不会后面已经补0了？[/quote] 这个应该是你用的json库的时候转换的问题，你还是详细查一下使用

引用 19 楼 user-11的回复:sprintf格式化是有四舍五入处理的。 我知道，这操作相当于是先把数据格式化为自己想要精度的字符串，然后再字符串转成浮点型数据，最后将这个转换后的数据发送，    前面都正常，就是在发送的时候，这个数据就变成了好多位小数;这个json函数得参数类型就是double类型的，跟这个有没有关系？ 还有这个转换后的浮点型数据在做为参数传递的时候，会不会后面已经补0了？

sprintf格式化是有四舍五入处理的。

引用 16 楼 user-11的回复:[quote=引用 15 楼 user-11 的回复:] [quote=引用 14 楼 不解释、 的回复:] [quote=引用 12 楼 Behard的回复:]如果要这样，*100 传递整数，告诉对方单位为 0.01 即可，最简单的应用是电子体温计测量就是这样的 36.0 °C给出的值为 360，单位 0.1°C 你是说我这边直接传递一个整数值过去吗？还是说怎么操作的？我这边的要求就是最终得结果！！如果是两位小数，就以两位小数的数值发送[/quote] 这个你测试下如下代码: char tmpstr[64]; sprintf(tempstr,"%.2lf",a); double tempdouble=atof(tempstr); 再添加这个到json,如果还不行那就是json处理函数对数据有处理造成的,看有没有格式化精度的[/quote] [/quote] 这种结果是建立在小数点后一位不是5得情况下出现了，如果是5那就是正常值，不知道原因是什么

还是不行，还是那个结果！！😌😌

引用 15 楼 user-11 的回复:[quote=引用 14 楼 不解释、 的回复:] [quote=引用 12 楼 Behard的回复:]如果要这样，*100 传递整数，告诉对方单位为 0.01 即可，最简单的应用是电子体温计测量就是这样的 36.0 °C给出的值为 360，单位 0.1°C 你是说我这边直接传递一个整数值过去吗？还是说怎么操作的？我这边的要求就是最终得结果！！如果是两位小数，就以两位小数的数值发送[/quote] 这个你测试下如下代码: char tmpstr[64]; sprintf(tempstr,"%.2lf",a); double tempdouble=atof(tempstr); 再添加这个到json,如果还不行那就是json处理函数对数据有处理造成的,看有没有格式化精度的[/quote]

引用 14 楼 不解释、 的回复:[quote=引用 12 楼 Behard的回复:]如果要这样，*100 传递整数，告诉对方单位为 0.01 即可，最简单的应用是电子体温计测量就是这样的 36.0 °C给出的值为 360，单位 0.1°C 你是说我这边直接传递一个整数值过去吗？还是说怎么操作的？我这边的要求就是最终得结果！！如果是两位小数，就以两位小数的数值发送[/quote] 这个你测试下如下代码: char tmpstr[64]; sprintf(tempstr,"%.2lf",a); double tempdouble=atof(tempstr); 再添加这个到json,如果还不行那就是json处理函数对数据有处理造成的,看有没有格式化精度的

引用 12 楼 Behard的回复:如果要这样，*100 传递整数，告诉对方单位为 0.01 即可，最简单的应用是电子体温计测量就是这样的 36.0 °C给出的值为 360，单位 0.1°C 你是说我这边直接传递一个整数值过去吗？还是说怎么操作的？我这边的要求就是最终得结果！！如果是两位小数，就以两位小数的数值发送


Question: 老哥们，我这个杨辉三角实在不知道哪儿错了


Question: c语言基础

double的格式控制符是%lf，%f是float的

引用 2 楼 无矣的回复:可以在输入之后在打印一下number的值，看是不是你输入的值。还有不要用== 0.0，浮点数之间不要使用==符号比较 好的谢谢😜

引用 1 楼 Italink的回复:double的格式控制符是%lf，%f是float的 是的懂了，谢谢了


Question: 求解

引用 1 楼 ?Victor.?? 的回复:2 5  后三个是垃圾值，也可能被编译器自动赋0  不对，a[10]越界了，是未知的值

2 5  后三个是垃圾值，也可能被编译器自动赋0


Question: C语言求解，，感谢大佬

那就告诉他，基础作业，必须自己做  做错了贴代码来问

引用 1 楼 寻开心的回复:全局变量 int fArray[50] = {1,1,};  void func1() {     for (int i=2; i<=45; i++ )           fArray[i] = fArray[i-1] + fArray[i-2]; }  有了这个数组， 第二个和第三个函数以及主函数自己写吧。 基础题目就是要自己练习的 我弟问的，可我不会呀。

引用 1 楼 寻开心的回复:全局变量 int fArray[50] = {1,1,};  void func1() {     for (int i=2; i<=45; i++ )           fArray[i] = fArray[i-1] + fArray[i-2]; }  有了这个数组， 第二个和第三个函数以及主函数自己写吧。 基础题目就是要自己练习的 重点是我O基础

支持4楼，自己先学习尝试着写一下，遇到难点了再贴代码问，这样才能提高。


Question: 为什么scanf被跳过了？

引用 3 楼 墙角黑猫 的回复:谢谢，解决了，本来用fflush(stdin)清楚除输入缓存但是还不行，后来查一下才发现，gcc不支持，采用了别的清楚输入缓存的方法！  fflush(stdou);是可行的，对于fflush(stdin);有些编译器是未定义的，即不确定好用。

第一个scanf时，你输入数据后有回车符，这个回车符被77行的scanf读取了。

在哪清空输入缓存的？只看到了清空输出缓存。


Question: 为什么在.c文件里编译不起啊？

不起是啥意思？贴全代码吧，尤其是出错的位置。


Question: C语言*统计字符个数*新人求教*我的代码输入时怎么一直不会停止啊

引用 1 楼 user-1 的回复:for i到80循环是不对的，用户不一定输入80个字符，所以应该是在for循环里判断str[i]是不是换行符‘\n'，如果是就break for循环。 谢谢大佬


Question: c语言链表该在什么情况下使用

适用于什么情况，就要看和其他数据结构的对比了 数组   顺序存储，随机访问， 一定定义好长度，扩充不易 队列   适合先入先出 栈      适合先入后出 链表   适合顺序访问，数量变化频繁

离散存储，或者插入删除操作较多的时候用链表比较好

数组解决的是定长的，而链表解决的是不定长的。链表能解决数组定义过长导致内存浪费和定义过短不易扩张的难题

要存储的数据比较多、频繁使用添加、删除数据的情况下用链表好些。


Question: 建立判定素数的自定义函数，对随机的 n 个数，判断哪些是素数

给你写个判断是否是素数的函数，剩下的LZ自己写吧 int isPNum(int num) { //是素数返回1，否则返回0     for (int i=2; i<num/2; i++) {         if (num%i==0) return 0;     }     return num > 1; }


Question: c语言

引用 2 楼 自信男孩的回复:把scanf改成scanf_s，然后在网上找一下scanf_s的用法，vs不支持scanf而是它的安全函数scanf_s 解决了，谢谢改为scanf_s就行了

引用 1 楼 ?Victor.??的回复:scanf_s  或者在预处理指令(#include<stdioh.>后面)加上  #pragma warning(disable : 4996) 哇😭，解决了谢谢😜，把scanf改为scanf_s就行了，


Question: 读入三角形三条边长。 如果输入合法，就计算这个三角形的周长。否则， 提示输入有误。 如果任意两条边的和大于第三边

并且关系是对的，只是if后面多了个分号，去掉它就可以了

if((a+b>c)&&(a+c>b)&&(b+c>a)); 条件错了，不是并且是或者的关系！


Question: 请问这个求完全数的程序哪里有问题呢

引用 1 楼 ?Victor.??的回复:#include<stdio.h>  int main() { 	int a,i,j,count = 0,sum = 0; 	printf("输入一个＞1的数\n"); 	scanf("%d",&a); 	for(i = 1; i<=a; i++) 	{ 		for(j = 1; j<=i/2 ; j++) 		{ 			if(i % j == 0) 			{ 				sum += j; 			} 		} 		if(sum == i) 		{ 			count++; 			printf("第%d个完全数是%d\n",count,i); 		} 		sum = 0; 	} 	return 0; }  供参考~ 你的这个可以正常运行，能帮我看看我的那个是哪里有问题呢，运行以后没有结果。

目测sum循环结束后没有重置为0


Question: 归并排序的问题，麻烦大神帮帮我，头昏脑涨的。。。

https://blog.csdn.net/k_koris/article/details/80508543  供参考～


Question: for循环 末尾循环体 中st[i+1] = getchar(),i++和st[i++] = getchar()有什么区别

区别主要是在i的值有没有变化和s[x]中的x是多少。如果是s[i+1]和s[i++]那么下表的值是不一样的，s[i+1]当i=0时，s[i+1]是值s[1]但是s[i++]是s[0]然后i自增1.。

前者是给str[i+1]赋值，后者是给str[i]赋值，注意i++的用法。你可以把后者改成str[++i]。


Question: 求大佬帮帮小白吧

按照你的需求写个简单的例子，随机生成的题。 只是小学生除法不知道到什么程度，是用分数表示还是小数，所以除法部分LZ再修改吧。  typedef struct expr {     double num1;     double num2;     char opt;     double answer1;     double answer2;     int result;     expr *next; } EXPR, *PEXPR;  typedef struct ques {     PEXPR expr;     int count;     int right; } QUES, *PQUES;  char opts[4] = {'+', '-', '*', '/'};  PQUES pQ;  void genQues() {     if (pQ==NULL) {         srand(time(NULL));         pQ = (PQUES)malloc(sizeof(QUES));         pQ->count = 0;         pQ->right = 0;     }     int tmp = 0;     PEXPR exp = (PEXPR)malloc(sizeof(EXPR));     exp->num1 = rand()%10;     exp->num2 = rand()%9 + 1;     exp->opt = rand()%4;     exp->next = NULL;     switch (exp->opt) {         case 0:             exp->answer1 = exp->num1 + exp->num2;             break;         case 1:             if (exp->num1 > exp->num2) {                 tmp = exp->num1;                 exp->num1 = exp->num2;                 exp->num2 = tmp;             }             exp->answer1 = exp->num1 - exp->num2;             break;         case 2:             exp->answer1 = exp->num1 * exp->num2;             break;         case 3:             exp->answer1 = exp->num1 / exp->num2; //除法根据需要修改         default:             break;     }     exp->result = 0;     if (pQ->count > 0) {         exp->next = pQ->expr;     }     pQ->expr = exp;     pQ->count++; }   int main(int argc, const char * argv[]) {     char Y = 'Y';     PEXPR exp;     while (Y == 'Y' || Y == 'y') {         genQues();         printf("%.0f%c%.0f=?\n", pQ->expr->num1, opts[pQ->expr->opt], pQ->expr->num2);         scanf("%lf", &pQ->expr->answer2);         getchar();         if (pQ->expr->answer2==pQ->expr->answer1) {             pQ->expr->result = 1;             pQ->right++;             printf("Right!\n");         } else {             printf("Wrong!\n");         }         printf("是否继续答题？继续答题输入Y，退出输入N\n");         Y = getchar();     }     printf("总共答题%d，做对%d题，分数%.0f\n", pQ->count, pQ->right, 100.0*pQ->right/pQ->count);     while(pQ->expr!=NULL) {         exp = pQ->expr->next;         free(pQ->expr);         pQ->expr = exp;     }     free(pQ);     return 0; }

/*************************************************************************     > File Name: abb.cpp     > Author: cfjtaishan     > Mail: cfj20080302@163.com      > Created Time: 2020年03月18日 星期三 20时29分46秒  ************************************************************************/  #include <stdio.h> #include <math.h>  float get_result(float a, char opt, float b);  int main(void) { 	char opt1, opt2; 	float a, b, c, result; 	int choice;  	printf("Please input your choice: (1: two number opt, 2: three nubers opt)"); 	scanf("%d", &choice);  	if (choice != 1 && choice != 2) { 		printf("Input error!\n"); 		return -1; 	}  	if (choice == 1) { 		printf("Please input your operation: (eg: 1*2)"); 		scanf("%f%c%f", &a, &opt1, &b); 		printf("=%.2f\n", get_result(a, opt1, b)); 		return 0; 	} 	printf("Please input your operation: (eg: 1*2*3)"); 	scanf("%f%c%f%c%f", &a, &opt1, &b, &opt2, &c); 	if (opt1 == '*' || opt1 == '/') { 		result = get_result(a, opt1, b); 		printf("=%.2f\n", get_result(result, opt2, c)); 	} else if (opt2 == '*' || opt2 == '/') { 		result = get_result(b, opt2, c); 		printf("=%.2f\n", get_result(a, opt1, result)); 	}  	return 0; }   float get_result(float a, char opt, float b) { 	float result;  	switch (opt) { 		case '+':  			result = a+b; 			break;  		case '-': 			result = a-b; 			break;  		case '*': 			result = a*b; 			break;  		case '/': 			if (fabsf(b) > 1e-6) 				result = a/b; 			break; 	}  	return result; }  供参考～  虽然不是完全符合要求，建议在这个基础上可以改一改。


Question: 奇偶个数问题，devc++编译器下，if条件为1却跳过执行

引用 1 楼 m0_46108109 的回复:ji+ji+1;}//这里错了 谢谢！！


Question: leetcode 的第17提题，请帮忙找出代码中的问题

void AddString(struct List **list, char *combination) { 	int len; 	struct List *nw; 	if (!combination) { return ; } 	//if (!len) { return ; }   //你的len在哪赋值的？ 	len = strlen(combination); 	if (!len) { return ; }  	nw = (struct List*)malloc(sizeof(struct List)); 	if (!nw) { return ; } 	nw->s = strdup(combination); 	nw->next = NULL;  	if (*list == NULL) { 		*list = nw; 	} else { 		nw->next = (*list)->next; 		(*list)->next = nw; 	} } 供参考～


Question: 求大佬帮忙

#include <stdio.h> #include <math.h>  float get_result(float a, char opt, float b);  int main(void) { 	char opt1, opt2; 	float a, b, c, result; 	int choice;  	printf("Please input your choice: (1: two number opt, 2: three nubers opt)"); 	scanf("%d", &choice);  	if (choice != 1 && choice != 2) { 		printf("Input error!\n"); 		return -1; 	}  	if (choice == 1) { 		printf("Please input your operation: (eg: 1*2)"); 		scanf("%f%c%f", &a, &opt1, &b); 		printf("=%.2f\n", get_result(a, opt1, b)); 		return 0; 	} 	printf("Please input your operation: (eg: 1*2*3)"); 	scanf("%f%c%f%c%f", &a, &opt1, &b, &opt2, &c); 	if (opt1 == '*' || opt1 == '/') { 		result = get_result(a, opt1, b); 		printf("=%.2f\n", get_result(result, opt2, c)); 	} else if (opt2 == '*' || opt2 == '/') { 		result = get_result(b, opt2, c); 		printf("=%.2f\n", get_result(a, opt1, result)); 	}  	return 0; }   float get_result(float a, char opt, float b) { 	float result;  	switch (opt) { 		case '+':  			result = a+b; 			break;  		case '-': 			result = a-b; 			break;  		case '*': 			result = a*b; 			break;  		case '/': 			if (fabsf(b) > 1e-6) 				result = a/b; 			break; 	}  	return result; }  供参考～  可以在这个基础上改一改～


Question: 求大佬指导一下c语言小程序！

引用 4 楼 自信男孩的回复:=赋值语句和==判断语句需要注意下，建议改成： '1' == str[i] 这样写成=，编译器能够提示错误（编译错误） 谢谢。已解决，确实是判断语句中应该是“==”

引用 1 楼 user-2的回复:等于是==，少了一个= 阿好了。谢谢 没问题了

引用 1 楼 user-2的回复:等于是==，少了一个= 嗯嗯 改了，结果不是全1了，但是结果还是输出了原来的字符串？

等于是==，少了一个=


Question: 哪位大神帮我看看我的程序到底哪儿的错误，程序功能：输入一串字符，找到其中最长的单词并输出该单词和单词长度

#include<stdio.h> #include<string.h>  char A[999]; char C[999]; int n = 0;  void F() { 	char b[999]; 	int i = 0, j = 0; 	int t = 0; 	//while (A[i] != '\n') 	while (1) 	{ #if 1 		if (A[i] == ' ' || A[i] == '\n') { 			b[j] = 0; 			t = strlen(b); 			printf("t = %d\n", t); 			if (t > n) { 				n = t; 				strcpy(C, b); 			} 			j = 0;  		} else { 			b[j++] = A[i]; 		} 		if (A[i] == '\n') 			break; 		i++; #else 		//for (; A[i] >= 65 && A[i] <= 90 || A[i] >= 97 && A[i] <= 122;) 		for (; (A[i] >= 65 && A[i] <= 90) || (A[i] >= 97 && A[i] <= 122);) 		{ 			b[j] = A[i]; 			i++; 			j++; 		} 		b[j] = 0;   //for '\0' 		t = strlen(b); 		printf("t = %d\n", t); 		if (t > n) 		{ 			n = t; 			strcpy(C, b); 		} 		j = 0; 		i++; 		//continue; #endif 	} } int main() { 	int i = 0; 	printf("please input charater: "); 	for (; 1;) 	{ 		A[i] = getchar(); 		//if (A[i] = '\n') 		if (A[i] == '\n') 		{ 			break;  		} 		i++; 	} 	printf("\n"); 	F(); 	//printf("最长的单词是:%s\t共%d个字母\n", C[999], n); 	printf("最长的单词是:%s\t共%d个字母\n", C, n); 	return 0; }  供参考～ 问题不止一处，建议对比代码找一下自己的问题

#include<stdio.h> #include<string.h> char A[999]; char C[999]; int n = 0; void F() { 	char b[999]; 	int i = 0, j = 0; 	int t = 0; 	while (A[i] != '\n') 	{ 		for (; A[i] >= 65 && A[i] <= 90 || A[i] >= 97 && A[i] <= 122;) 		{ 			b[j] = A[i]; 			i++; 			j++; 		} 		t = strlen(b); 		if (t > n) 		{ 			n = t; 			strcpy(C, b); 		} 		continue;  	} } int main() { 	int i = 0; 	printf("please input charater: "); 	for (; 1;) 	{ 		A[i] = getchar(); 		if (A[i] = '\n') 		{ 			break;  		} 		i++; 	} 	printf("\n"); 	F(); 	printf("最长的单词是:%s\t共%d个字母\n", C[0], n); 	return 0; }

#include<stdio.h> #include<string.h> char A[999]; char C[999]; int n = 0; void F() { 	char b[999]; 	int i = 0, j = 0; 	int t = 0; 	while (A[i] != '\n') 	{ 		for (; A[i] >= 65 && A[i] <= 90 || A[i] >= 97 && A[i] <= 122;) 		{ 			b[j] = A[i]; 			i++; 			j++; 		} 		t = strlen(b); 		if (t > n) 		{ 			n = t; 			strcpy(C, b); 		} 		continue;  	} } int main() { 	int i = 0; 	printf("please input charater: "); 	for (; 1;) 	{ 		A[i] = getchar(); 		if (A[i] = '\n') 		{ 			break;  		} 		i++; 	} 	printf("\n"); 	F(); 	printf("最长的单词是:%s\t共%d个字母\n", C[999], n); 	return 0; }

最后那个printf时那个%t写错了，是/t。发现一处错误。

代码贴出来，还有人给你找一下错误。发个图片让人照着图片把代码敲下来吗？

希望能帮我指出问题并解决。蟹蟹


Question: 求大佬看一下

引用 2 楼 lsldlas的回复:引用 1 楼 Mrxlin 的回复:2^n-1        是11层吗 是的

引用 1 楼 Mrxlin 的回复:2^n-1        是11层吗


Question: 有人知道gcc怎么编译具有c++特性的代码（比如c++的类和引用）

文件扩展名直接改成cpp不行吗？


Question: 求优化，测试显示内存超限和段错误，在源代码基础上还能怎么优化？？？

应该不会超时了吧，再超时就不能用链表了~~   #include<stdio.h> #include<stdlib.h>  typedef struct lnode { 	int data; 	struct lnode *next; } Q; Q* list=NULL;  void push(int s,int v);//压入 int pop(int s);//弹出 int is_empty(int s);//判断栈是否空 void free_list(int n);  int main(void) { 	int T,n,q; 	scanf("%d",&T); 	while(T--) { //几组样例 		scanf("%d%d",&n,&q); //读入栈的个数、行数 		//创建n+1个栈的头结点； 		list=(Q*)malloc(sizeof(Q)*(n+1)); 		//初始化 		for(int i=0; i<=n; ++i) 			list[i].next=NULL; 		int temp=0;	//其中第0个栈用来做临时存储 		int op,s,v,s1;//每一行的数据  		while(q--) { //操作的个数 			scanf("%d",&op); 			if(op==1) { //1操作 				scanf("%d%d",&s,&v); 				push(s,v); 			} else if(op==2) { //2操作 				scanf("%d",&s); 				if(is_empty(s)) 					printf("EMPTY\n"); 				else 					printf("%d\n",pop(s)); 			} else { //3操作 				scanf("%d%d",&s,&s1); 				//链表合并 				if(!is_empty(s1)){ 					Q* p=list[s1].next; 					while(p->next!=NULL)  						p=p->next; 					p->next=list[s].next; 					list[s].next=list[s1].next; 					list[s1].next=NULL; 				} 			} 		}          free_list(n);//释放空间 	} 	return 0; } //用链表来做栈，所以采用头插法。 void push(int s,int v) { 	Q* node=(Q*)malloc(sizeof(Q)); 	node->data=v; 	node->next=list[s].next; 	list[s].next=node; } int pop(int s) { 	Q* p=list[s].next; 	int data=p->data; 	list[s].next=p->next; 	free(p); 	return data; }  int is_empty(int s){ 	return list[s].next==NULL; } void free_list(int n){ 	//把所有的栈都清空 	for(int i=0;i<=n;i++){ 		while(!is_empty(i)) 			pop(i); 	} 	//释放头结点 	free (list); }

这个就是模拟栈的操作就可以了啊~~内存么，用malloc分配哈。  #include<stdio.h> #include<stdlib.h>  typedef struct lnode { 	int data; 	struct lnode *next; } Q; Q* list=NULL;  void push(int s,int v);//压入 int pop(int s);//弹出 int is_empty(int s);//判断栈是否空 void free_list(int n);  int main(void) { 	int T,n,q; 	scanf("%d",&T); 	while(T--) { //几组样例 		scanf("%d%d",&n,&q); //读入栈的个数、行数 		//创建n+1个栈的头结点； 		list=(Q*)malloc(sizeof(Q)*(n+1)); 		//初始化 		for(int i=0; i<=n; ++i) 			list[i].next=NULL; 		int temp=0;	//其中第0个栈用来做临时存储 		int op,s,v,s1;//每一行的数据  		while(q--) { //操作的个数 			scanf("%d",&op); 			if(op==1) { //1操作 				scanf("%d%d",&s,&v); 				push(s,v); 			} else if(op==2) { //2操作 				scanf("%d",&s); 				if(is_empty(s)) 					printf("EMPTY\n"); 				else 					printf("%d\n",pop(s)); 			} else { //3操作 				scanf("%d%d",&s,&s1); 				//先把s1逆序存到temp 				while(!is_empty(s1)) 					push(temp,pop(s1)); 				//在把temp逆序存到栈s 				while(!is_empty(temp)) 					push(s,pop(temp)); 			} 		}          free_list(n);//释放空间 	} 	return 0; } //用链表来做栈，所以采用头插法。 void push(int s,int v) { 	Q* node=(Q*)malloc(sizeof(Q)); 	node->data=v; 	node->next=list[s].next; 	list[s].next=node; } int pop(int s) { 	Q* p=list[s].next; 	int data=p->data; 	list[s].next=p->next; 	free(p); 	return data; }  int is_empty(int s){ 	return list[s].next==NULL; } void free_list(int n){ 	//把所有的栈都清空 	for(int i=0;i<=n;i++){ 		while(!is_empty(i)) 			pop(i); 	} 	//释放头结点 	free (list); }


Question: 为什么要有位运算，位运算用在什么地方，位运算存在的意义

为运算在嵌入式开始应用比较多

位运算效率高，在门电路实现的时候，位运算的效率要比加减乘除的效率高多了。

学点硬件或汇编就知道了：当前的计算机都是位运算！差别只是多少位而已

看到不少人说了 所以强调一下  不要用二进制优化程序里面的加减乘除 现代编译器能完成这种程度的优化 手写二进制乘除算是一个不合时宜的炫技行为 十年前可能算是一个技巧  现在不算

除了ls说的，一般在信号控制或嵌入式方面也用的比较广。 还有一些程序优化，用位运算效率更高。比如用异或法找数组重复元素，乘2除2用左移右移，等等。

位运算更快  一点，算法竞赛有一些技巧

位图，哈希，加解密，标志位等等，很多地方都要用

很多地方会用到的 举个例子 处理图片/视频有时候需要把RGB数据转换为BGR数据


Question: 函数调用

谢谢哎~看了你的回复，去搜索了scanf_s的用法。知道了错误 应该这样写scanf_s("%s", st,50); scanf_s("%c", &c,1);  引用 2 楼 user-1 的回复:scanf_s的参数和scanf不一样，%s格式要指定长度 另外，尽量别用string这样的特殊单词来定义变量，有的头文件定义了string类型，容易发生歧义

为什么呢？？


Question: vs2019配置错了吗还是我遇到bug了？

谢了，随人不对但给个鼓励分，解决方法我找到了


Question: 前提是循环链表，实际可运行且结果正确，debug时发现，未初始化的指针tem被默认为指向指针q的指针，为什么呢

1：   return h->next;//不带头结点 ， 那么，头结点分配的空间如何删除？ 2： 要找 循环链表内容是否相等, 要以先列出个伪代码： for (i = B链表中的每个节点)         for (j = A链表中与 i 相等的每个节点)               以 i, j 作为 B.A链表的临时开头，检测B.A链表是否完全相等。

引用 1 楼 user-1 的回复:未初始化的值是随机的。 实际上，如果此值是在栈上，那么进入函数，栈指针esp产生移动，tem = [esp + N], 原地址值是什么，就是未初始化tem的值。 我debug之后发现确实是像您说的那样，但是我有一个问题很疑惑，在我那个程序里，打开文件直接运行，是可以正确跑的，但是当我一行一行进入函数去debug之后发现，函数是一个无限循环，退出debug之后，程序就不能跑了，也会是无限循环，而且会出现warning，tem未初始化，但是如果不debug就会正常运行，我真的很疑惑 我用的Code Blocks   以下是完整的代码   问题描述：循环链表首尾相连都有头结点，然而在很多时候，当两个循环链表长度相等且构成环以后，可能在内容上完全相等，然而若从头结点开始看这两个循环链表可能不能对应相等。此处给出判断两个循环链表内容是否相等的方法。 然而还有通常做法中从首字母开始比一直到结束看是否相等，然而当待比较的字符串含有多个基准字符串的首字母时，也应从待比字符串多处地方依次比较。 #include<stdio.h> #include<malloc.h> #include<stdlib.h> #define true 1 #define false 0  typedef struct Lnode //定义链表结点的数据结构 {     char data;     struct Lnode *next; }node; node *create()//尾插法构建循环链表不带头结点 {   char x;     node *h, *t;     t = h = (node *)malloc(sizeof(node));     h->next = NULL;      scanf("%c", &x);     while (x !='#')     {         node *s = (node *)malloc(sizeof(node));         s->data = x;         s->next = h->next;         t->next = s;         t = s;         scanf("%c", &x);     }     t->next=h->next;//尾和head->next相连     return h->next;//不带头结点 } int compare(node *A,node*B) {     node *p=A;     node *tem;     node *q=B;     int i=0;     int flag=0;     while(1)     {     	if(q->data!=p->data)             q=q->next;//找到B中与A首字符相等的字符位置     	if(q==tem)//如果试图找出B中每个与A首字符相等时其后所构成的字符串与A比较失败后，     				//B循环一遍后又回到最初开始比较的位置，则整个比较失败，返回失败。          	return false;     	if(q->data==p->data)       		while(1)       		{         		if(p->data!=q->data)         		{ 					i++;            			if(i==1)             			q=tem;//tem记录第一次找到B中与A首字符相等的字符位置             		flag=1;//其后试图第二次找到B中与A首字符相等的字符位置             		break;         		}         		p=p->next;         		q=q->next;      			if(p==A)//如果A链表循环一遍到头值后也未发现不相等的字符则成功         			return true ;       		}      		if(flag==1)      		{         		p=A; 				flag=0;//试图第二次找到B中与A首字符相等的字符位置时让p指向A的头重新与A进行比较      		}     } } int main(void) {     printf("请输入两个字符串以分别以#号结束") ;     node *a=create();     node *b=create();     if(compare(a,b))     printf("两个字符串循环相等为同内容循环链表");     else     printf("两个字符串不循环相等为不同内容循环链表"); }


Question: segmentation fault ，我传进去的指针为什么还要初始化？

引用 3 楼 user-1的回复:reader(*head);//从数据库读取数据  ==》》这一句调用有问题 reader函数的参数是 *head, head在main中定义了是结构体指针，这里传参应该把*号去掉。 while(head->flag){         head=menu(*head);  ==》这里也一样 对吼，谢谢(*°∀°)=3

引用 1 楼 user-1的回复:Book *now=head;      ==》这里改成 Book *now = head->next; 试试     Book *temp;     temp=(Book*)malloc(sizeof(Book));     while(fscanf(fp,"%d,%d,%lf",&temp->ISBN,&temp->publishDate,&temp->price)!=EOF){         fscanf(fp,"%s",temp->bookName);         fscanf(fp,"%s",temp->publisher);         fscanf(fp,"%s",temp->author);         now->next=temp;//segmentation fault         temp->next=NULL;         now=now->next;        ==》这里改成 now = temp; 试试看         temp=(Book*)malloc(sizeof(Book));  ==》这里 temp= 改成 temp->next = 试试看         n++;     } 感觉上是这几个地方，试试看 还是一样报错，在函数里面第一个出现head next的地方就会报错


Question: 救救孩子吧

#include<stdio.h> int main() { 	int n, i; 	double h, j, b, a; 	scanf("%d",&n); 	for (i = 1; i <= n; i++) { 		scanf("%lf %lf", &a, &b); 		h = (a - 100)*0.9 * 2; 		j = h * 0.1; 		b = b - h; 		if (b > -j && b < j) { 			printf("perfect!\n"); 		} 		else { 			if (b >= j) { 				printf("fat!\n"); 			} 			else { 				printf("thin!\n"); 			} 		} 	} 	return 0; }  仅供参考


Question: 从键盘输入n的值，根据n的值，输出三角图案，如n=4时，输出图案如下： *******  *****   ***    *

int main() {  int i,a,n,b,j;  scanf("%d",&n);  for(i=n;i>0;i--)//循环执行次数等于n     {         for(j=0;j<n-i;j++)//输出空格         {              printf(" ");          }         for(j=0;j<2*i-1;j++){//输出*         printf("*");         }         printf("\n");     }     return 0; }   代码简化不香嘛？ 你这分开输出不在一行，难道最后不会多出来一行空格嘛？

是作品展示？


Question: C 调bug调崩溃了。。。这是为啥？？？

引用 2 楼 qq_24711751 的回复:vc++6.0 参考以下链接 https://blog.csdn.net/w77_20/article/details/94616321

c99还是哪个标准多少前忘了，要求变量声明必须放在最前面。

我也遇到同样的问题了，但是我用的是TC2。不知道是开发环境的问题还是系统不够安全被黑了。

看不出有什么问题，把全部代码这样贴出来

引用 1 楼 qybao 的回复:编译器什么版本？一些老版本编译器要求变量必须在函数的最开头声明  vc++6.0

编译器什么版本？一些老版本编译器要求变量必须在函数的最开头声明


Question: 请问如何解决下列报错？

//使用哈希表进行单词词频的统计 //参考资料：课件：慕课；书本参考P258  #define MAXSIZETABLE 10000 #define CLOCKS_PER_SEC 1000 //宏定义CLOCKS_PER_SEC为1000，用于将difftime求得的单位从毫秒转化为秒 #include<stdio.h> #include<time.h> #include<stdlib.h> #include<string.h> #include<math.h> #define KEYLENTH 15 #define MAXWORDLEN 80 //所有单词最大长度  typedef char ElementType[KEYLENTH+1];//关键词类型用字符串 typedef int Index;//散列地址类型 typedef struct LNode *PtrToLNode;  struct LNode{ //定义链表的结构，包含链表元素和位置     ElementType Data;     int Count;//增加字段Count存储单词的出现次数     PtrToLNode Next ; }; typedef PtrToLNode Position; //Position是指针，指向结构体struct LNode 类型 typedef PtrToLNode List; typedef struct TblNode *HashTable; struct TblNode{ //定义哈希表结构,包含表长和含有链表头的数组     int TableSize;     List Heads; //指向链表头结点的数组 };  //返回一个不超过最大表长的最小素数 //输入：一个整形数 //输出：一个素数 int nextPrime(int N){      int p=(N%2)?(N+2):(N+1);//从大于N的最小奇数开始探测     int i;      while(p<MAXSIZETABLE)//超过MAXSIZETABLE时停止比较     {         for(i=(int)sqrt(p);i>2;i--)//判断p是否是素数         {             if (!(p%i)) break;//如果p被除了1和它本身整除，则不是素数，退出         }         if(i==2) break;//for 循环正常结束，说明p是素数         else p+=2;      }     return p; }  //计算哈希值的函数，哈希值为Key在哈希表中的地址 //输入：Key，TableSize //输出：一个整形数字 int hash(int Key,int TableSize) {     return Key%TableSize; }  //初始化哈希表 HashTable CreateTable(int TableSize){     HashTable H;     int i;      //先分配内存，内存大小为sizeof(struct HashTable)     H = (HashTable)sizeof(struct TblNode);     //保证散列表的最大长度是素数     H->TableSize = nextPrime(TableSize);     //分配链表头结点数组     H->Heads=(List)malloc(H->TableSize *sizeof(struct LNode));     //初始化表头节点     for(i=0;i<H->TableSize;i++)     {         //H->Heads[i].Data = '\0';//'\0'表示空的字符         memset(H->Heads[i].Data, 0, sizeof(H->Heads[i].Data));         H->Heads[i].Next = NULL;     }      return H;   //需要返回的 }  //在哈希表H中找Key Position Find(ElementType Key,HashTable H) {     Position p;     Index Pos;     int key_Int;//int型key值      //计算key的哈希值     //先将key变为int型数字     key_Int = atoi(Key);//atoi (表示 ascii to integer)是把字符串转换成整型数的一个函数     Pos=hash(key_Int,H->TableSize);      p= H->Heads[Pos].Next;//用Pos这个哈希值，从链表的第一个位置开始      //根据哈希值，在哈希表中查找，找到返回位置，否则返回null     /*while(p && strcmp(p->Data,Key))*/     while(p && (p->Data!=Key)) //strcmp()中参数为字符串类型     {         p=p->Next;     }     return p;//此时P指向找到的结点，或者为NULL }   //销毁HashTable void DestoryTable(HashTable H){     int i;     Position p,Temp;      //删除链表节点的操作：p先指向链表节点,临时指针temp指向p->Next,释放p free(p),P->Temp     for (i = 0;i<H->TableSize;i++)     {         p = H->Heads[i].Next;//先确定要删除的表头，p是表头后面的链条         while(p)         {             Temp = p->Next;             free(p);             p=Temp;         }      }     free(H->Heads);     free(H); }  //将一个字符串进行哈希函数的计算， //输入：字符串，例如abcdd //输出：字符串的哈希地址 int  HashAdd(const char *key) {     //程序计时开始     clock_t start_t,end_t;     double total_t;       //字符串的哈希函数，将字符串进行哈希函数     int TableSize = 110;     unsigned int h = 0; //散列函数值，从初始化为0     int add;     start_t = clock();      while(*key!= '\0')//将字符串每个字符*32后相加再相乘，最后得到的这个字符串的哈希值     {         h = (h <<5) + *key++; //左移5位      }     add = h % TableSize;     end_t = clock();     printf("%d\n",add);      //程序计时结束     total_t = difftime(end_t,start_t)/CLOCKS_PER_SEC;     printf("diff:CPU占用的时间：%f\n",total_t);      return 0; }  //在哈希表中插入Key并且统计词频 //输入：ElementType类型的Key,哈希表H //输出：空值。但是哈希表已经经过Key插入，并且对应的词频已经统计 void InsertAndCount(HashTable H,ElementType Key) {     Position NewCell,P;     Index Pos;     int Key_Int;//将字符串key转变为int类型      //先在哈希表中找Key,调用find(key,H)     P=Find(Key,H);      //若没有找到，可以插入     if(!P)     {         //为新插入的节点开辟内存空间，sizeof(struct LNode)         NewCell = (Position)malloc(sizeof(struct LNode));         strcpy(NewCell->Data,Key);         NewCell->Count=1;//新单词第一次出现          //通过哈希函数计算Key的哈希地址，作为在表中插入的位置         Key_Int = atoi(Key);//将字符串转变为int         Pos = hash(Key_Int,H->TableSize);          //插入这个链表需要插入key，以及next指针，就是插入一个表结点         NewCell->Next = H->Heads[Pos].Next;         H->Heads[Pos].Next = NewCell;         H->Heads[Pos].Count++;//链表中增加了一个新单词     }      //若找到，将原来单词的词频加1     else{         P->Count++;     } }   //判断z字符是否合法：在0-9 a-z A-Z之间单词合法 //输入：char类型的字符 //输出：bool型结果true 或者false bool IsWordChar(char c) {     //若单词合法，返回true     if((c>='a'&&c<='z')||(c>='0'&&c<='9')||(c=='_')||(c>='A'&&c<='Z'))         return true;      //否则返回false     else         return false; }  //从给定文件读取一个单词，返回该单词的长度,若超过长度15将会被截去 //输入：指向文件的指针fp,ElementType类型word //输出：单词的长度 int GetAWord(FILE *fp,ElementType word) {     char tempword[MAXWORDLEN+1],c;     int len=0;//单词长度      //读取fp所指文件中的第一个字符，判断该字符是否合法,若合法则统计直到遇到结束     //字符“\0”     c = fgetc(fp);     while(!feof(fp))     {         if(IsWordChar(c))         {             tempword[len++]=c;//tempword数组存放单词，比如"boy":tempword[3]="boy"         }         c = fgetc(fp);         //跳过单词前的非法字符，或以非法字符结束一个单词         if(len && !IsWordChar(c))             break;//非法字符     }      tempword[len] = '\0'; //设定字符串结束符      //截断太长的单词，超过KEYLENTH就是太长,本例子中KEYLENTH定义为15     if(len>KEYLENTH)     {         tempword[KEYLENTH] = '\0';         len = KEYLENTH;     }     strcpy(word, tempword);     return len; }  //显示词频超过给定比例的所有单词 //输入：哈希表H 比例percent //输出： void Show(HashTable H, double percent) {     int diffwordcount=0;//不同的单词数量     int maxf=0;//最大单词频次     int i;     Position L;     int maxCollision=100;//最大冲突次数     int minCollision=0;//最小冲突次数初始化为100     int *diffwords;//每个词频对应的不同单词的数量      //用for循环扫描整个散列表，统计不同的单词数量和最大词频     //maxf     for(i=0;i<H->TableSize;i++)     {         //头结点统计的单词数量的和就是不同的单词个数         diffwordcount += H->Heads[i].Count;          //统计最大/最小冲突次数         if(maxCollision < H->Heads[i].Count) maxCollision = H->Heads[i].Count;         if(minCollision > H->Heads[i].Count) minCollision = H->Heads[i].Count;          //找出每个头结点链表中的最大maxf         L = H->Heads[i].Next; //L指向链表的表头         while(L)         {             //遍历链表             if(maxf < L->Count) maxf = L->Count;             L = L->Next;         }     }     printf("共有%d个不同单词，词频最大是：%d\n",diffwordcount,maxf);     printf("最大冲突次数是:%d,最小冲突次数是%d\n",maxCollision,minCollision);         //根据最大词频maxf申请一个数组diffwords用于存储词频从1到     //maxf的单词数量     diffwords = (int *)malloc(sizeof(int)*(maxf+1)); //创建一个数组     for (i = 0;i<= maxf ;i++)     {         diffwords[i] = 0;//初始化每个数组元素为0 这里为什么不是int diffwords[40]={0} ?     }     //计算每个数组元素的值，需要遍历链表，找到每个表结点的Count,diffwords[Count]+1     for(i=0;i<H->TableSize;i++)     {         L=H->Heads[i].Next;         //遍历链表         while(L)         {             diffwords[L->Count]++;//词频数组对应元素加一             L=L->Next;         }     }      //求特定的词频，使得大于等于该词频的单词总和超过给定的比例？？？？  }   //main函数,文件中单词词频统计 //统计文件中所有单词出现的频率，并输出词频最大的前10%的单词 //及其词频 int main() {     FILE *fp;     int TableSize = 10000;//散列表的估计大小     char document[30]= "HarryPotter.txt"; //要统计词频的文件名     HashTable H;     int length=0;     int Wordcount=0;     ElementType word;      //1.初始化一张散列表     H = CreateTable(TableSize);     //2.打开文件     //     //if( (fp=fopen(document,"r"))==NULL)      //   printf("无法打开文件\n");      if( (fp=fopen(document,"r"))==NULL) {   //文件打开失败就不要执行下面的读文件操作了         printf("无法打开文件\n");         return -1;     }     //3.对文件进行处理     while(!feof(fp))     {         length = GetAWord(fp,word);//从文件读一个单词         if(length > 3)         {  //只考虑长度大于3的单词             Wordcount++;//统计文件中单词总数             InsertAndCount(H,word);//在哈希表中寻找此word单词,如果在哈希表中则词频加1，不在则插入word}         }     }      //4.文件读取完毕     fclose(fp);     //printf("该文档共出现%d个有效单词",word);     printf("该文档共出现%d个有效单词",Wordcount);     //5.显示词频前10%的所有单词     Show(H,10.0/100);      //6、销毁散列表     DestoryTable(H);      return 0 ; } 供参考～  对比代码找出自己的问题吧

引用 楼主 RunningBComeOn 的回复:语法百度后查找不出来，报错如下。麻烦大神赐教。  //使用哈希表进行单词词频的统计 //参考资料：课件：慕课；书本参考P258  #define MAXSIZETABLE 10000 #define CLOCKS_PER_SEC 1000 //宏定义CLOCKS_PER_SEC为1000，用于将difftime求得的单位从毫秒转化为秒 #include<stdio.h> #include<time.h> #include<stdlib.h> #include<string.h> #include<math.h> #define KEYLENTH 15 #define MAXWORDLEN 80 //所有单词最大长度  typedef char ElementType[KEYLENTH+1];//关键词类型用字符串 typedef int Index;//散列地址类型 typedef struct LNode *PtrToLNode;  struct LNode{ //定义链表的结构，包含链表元素和位置 	ElementType Data; 	int Count;//增加字段Count存储单词的出现次数 	PtrToLNode Next ; }; typedef PtrToLNode Position; //Position是指针，指向结构体struct LNode 类型 typedef PtrToLNode List; typedef struct TblNode *HashTable; struct TblNode{ //定义哈希表结构,包含表长和含有链表头的数组 	int TableSize; 	List Heads; //指向链表头结点的数组 };  //返回一个不超过最大表长的最小素数 //输入：一个整形数 //输出：一个素数 int nextPrime(int N){  	int p=(N%2)?(N+2):(N+1);//从大于N的最小奇数开始探测 	int i;  	while(p<MAXSIZETABLE)//超过MAXSIZETABLE时停止比较 	{ 		for(i=(int)sqrt(p);i>2;i--)//判断p是否是素数 		{ 			if (!(p%i)) break;//如果p被除了1和它本身整除，则不是素数，退出 		} 		if(i==2) break;//for 循环正常结束，说明p是素数 		else p+=2;  	} 	return p; }  //计算哈希值的函数，哈希值为Key在哈希表中的地址 //输入：Key，TableSize //输出：一个整形数字 int hash(int Key,int TableSize) { 	return Key%TableSize; }  //初始化哈希表 HashTable CreateTable(int TableSize){ 	HashTable H; 	int i;	  	//先分配内存，内存大小为sizeof(struct HashTable) 	H = (HashTable)sizeof(struct TblNode); 	//保证散列表的最大长度是素数 	H->TableSize = nextPrime(TableSize); 	//分配链表头结点数组 	H->Heads=(List)malloc(H->TableSize *sizeof(struct LNode)); 	//初始化表头节点 	for(i=0;i<H->TableSize;i++) 	{ 		H->Heads[i].Data = '\0';//'\0'表示空的字符 		H->Heads[i].Next = NULL; 	} }  //在哈希表H中找Key Position Find(ElementType Key,HashTable H) { 	Position p; 	Index Pos; 	int key_Int;//int型key值  	//计算key的哈希值 	//先将key变为int型数字 	key_Int = atoi(Key);//atoi (表示 ascii to integer)是把字符串转换成整型数的一个函数 	Pos=hash(key_Int,H->TableSize); 	 	p= H->Heads[Pos].Next;//用Pos这个哈希值，从链表的第一个位置开始  	//根据哈希值，在哈希表中查找，找到返回位置，否则返回null 	/*while(p && strcmp(p->Data,Key))*/ 	while(p && (p->Data!=Key)) //strcmp()中参数为字符串类型 	{ 		p=p->Next; 	} 	return p;//此时P指向找到的结点，或者为NULL }   //销毁HashTable void DestoryTable(HashTable H){ 	int i; 	Position p,Temp;  	//删除链表节点的操作：p先指向链表节点,临时指针temp指向p->Next,释放p free(p),P->Temp 	for (i = 0;i<H->TableSize;i++) 	{ 		p = H->Heads[i].Next;//先确定要删除的表头，p是表头后面的链条 		while(p) 		{ 			Temp = p->Next; 			free(p); 			p=Temp; 		}  	} 	free(H->Heads); 	free(H); }  //将一个字符串进行哈希函数的计算， //输入：字符串，例如abcdd  //输出：字符串的哈希地址 int  HashAdd(const char *key) { 	//程序计时开始 	clock_t start_t,end_t; 	double total_t; 	  	//字符串的哈希函数，将字符串进行哈希函数 	int TableSize = 110;  	unsigned int h = 0; //散列函数值，从初始化为0 	int add; 	start_t = clock();  	while(*key!= '\0')//将字符串每个字符*32后相加再相乘，最后得到的这个字符串的哈希值 	{ 		h = (h <<5) + *key++; //左移5位  	} 	add = h % TableSize; 	end_t = clock(); 	printf("%d\n",add);  	//程序计时结束 	total_t = difftime(end_t,start_t)/CLOCKS_PER_SEC; 	printf("diff:CPU占用的时间：%f\n",total_t); 	 }  //在哈希表中插入Key并且统计词频 //输入：ElementType类型的Key,哈希表H //输出：空值。但是哈希表已经经过Key插入，并且对应的词频已经统计 void InsertAndCount(HashTable H,ElementType Key) { 	Position NewCell,P; 	Index Pos; 	int Key_Int;//将字符串key转变为int类型  	//先在哈希表中找Key,调用find(key,H) 	P=Find(Key,H);  	//若没有找到，可以插入 	if(!P)  	{ 		//为新插入的节点开辟内存空间，sizeof(struct LNode) 		NewCell = (Position)malloc(sizeof(struct LNode)); 		strcpy(NewCell->Data,Key); 		NewCell->Count=1;//新单词第一次出现  		//通过哈希函数计算Key的哈希地址，作为在表中插入的位置 		Key_Int = atoi(Key);//将字符串转变为int 		Pos = hash(Key_Int,H->TableSize);  		//插入这个链表需要插入key，以及next指针，就是插入一个表结点 		NewCell->Next = H->Heads[Pos].Next; 		H->Heads[Pos].Next = NewCell; 		H->Heads[Pos].Count++;//链表中增加了一个新单词 	}  	//若找到，将原来单词的词频加1 	else{ 		P->Count++; 	} }   //判断z字符是否合法：在0-9 a-z A-Z之间单词合法 //输入：char类型的字符 //输出：bool型结果true 或者false bool IsWordChar(char c) { 	//若单词合法，返回true 	if((c>='a'&&c<='z')||(c>='0'&&c<='9')||(c=='_')||(c>='A'&&c<='Z')) 		return true;  	//否则返回false 	else 		return false; }  //从给定文件读取一个单词，返回该单词的长度,若超过长度15将会被截去 //输入：指向文件的指针fp,ElementType类型word //输出：单词的长度 int GetAWord(FILE *fp,ElementType word) { 	char tempword[MAXWORDLEN+1],c; 	int len=0;//单词长度  	//读取fp所指文件中的第一个字符，判断该字符是否合法,若合法则统计直到遇到结束 	//字符“\0” 	c = fgetc(fp); 	while(!feof(fp)) 	{ 		if(IsWordChar(c)) 		{ 			tempword[len++]=c;//tempword数组存放单词，比如"boy":tempword[3]="boy" 		} 		c = fgetc(fp); 		//跳过单词前的非法字符，或以非法字符结束一个单词 		if(len && !IsWordChar(c)) 			break;//非法字符 	}  	tempword[len] = '\0'; //设定字符串结束符  	//截断太长的单词，超过KEYLENTH就是太长,本例子中KEYLENTH定义为15 	if(len>KEYLENTH) 	{ 		tempword[KEYLENTH] = '\0'; 		len = KEYLENTH; 	} 	strcpy(word, tempword); 	return len; }  //显示词频超过给定比例的所有单词 //输入：哈希表H 比例percent //输出： void Show(HashTable H, double percent) { 	int diffwordcount=0;//不同的单词数量 	int maxf=0;//最大单词频次 	int i; 	Position L;  	int maxCollision=100;//最大冲突次数 	int minCollision=0;//最小冲突次数初始化为100 	int *diffwords;//每个词频对应的不同单词的数量 	 	//用for循环扫描整个散列表，统计不同的单词数量和最大词频 	//maxf 	for(i=0;i<H->TableSize;i++) 	{ 		//头结点统计的单词数量的和就是不同的单词个数 		diffwordcount += H->Heads[i].Count;  		//统计最大/最小冲突次数 		if(maxCollision < H->Heads[i].Count) maxCollision = H->Heads[i].Count; 		if(minCollision > H->Heads[i].Count) minCollision = H->Heads[i].Count;  		//找出每个头结点链表中的最大maxf 		L = H->Heads[i].Next; //L指向链表的表头 		while(L) 		{ 			//遍历链表 			if(maxf < L->Count) maxf = L->Count; 			L = L->Next; 		} 	} 	printf("共有%d个不同单词，词频最大是：%d\n",diffwordcount,maxf); 	printf("最大冲突次数是:%d,最小冲突次数是%d\n",maxCollision,minCollision);     	//根据最大词频maxf申请一个数组diffwords用于存储词频从1到 	//maxf的单词数量 	diffwords = (int *)malloc(sizeof(int)*(maxf+1)); //创建一个数组 	for (i = 0;i<= maxf ;i++) 	{ 		diffwords[i] = 0;//初始化每个数组元素为0 这里为什么不是int diffwords[40]={0} ? 	} 	//计算每个数组元素的值，需要遍历链表，找到每个表结点的Count,diffwords[Count]+1 	for(i=0;i<H->TableSize;i++) 	{ 		L=H->Heads[i].Next; 		//遍历链表 		while(L) 		{ 			diffwords[L->Count]++;//词频数组对应元素加一 			L=L->Next; 		} 	} 	 	//求特定的词频，使得大于等于该词频的单词总和超过给定的比例？？？？  }   //main函数,文件中单词词频统计 //统计文件中所有单词出现的频率，并输出词频最大的前10%的单词 //及其词频 int main() { 	FILE *fp; 	int TableSize = 10000;//散列表的估计大小 	char document[30]= "HarryPotter.txt"; //要统计词频的文件名 	HashTable H; 	int length=0; 	int Wordcount=0; 	ElementType word;  	//1.初始化一张散列表 	H = CreateTable(TableSize); 	//2.打开文件 	if( (fp=fopen(document,"r"))==NULL) printf("无法打开文件\n");  	//3.对文件进行处理 	while(!feof(fp)) 	{ 		length = GetAWord(fp,word);//从文件读一个单词 		if(length > 3) 		{  //只考虑长度大于3的单词 			Wordcount++;//统计文件中单词总数 			InsertAndCount(H,word);//在哈希表中寻找此word单词,如果在哈希表中则词频加1，不在则插入word} 	    } 	}  	//4.文件读取完毕 	fclose(fp); 	printf("该文档共出现%d个有效单词",word); 	//5.显示词频前10%的所有单词 	Show(H,10.0/100);  	//6、销毁散列表 	DestoryTable(H);  	return 0 ; }    引用 2 楼 棉猴 的回复:HashTable CreateTable(int TableSize) { 	HashTable H; 	int i;  	//先分配内存，内存大小为sizeof(struct HashTable) 	H = (HashTable)new HashTable();// --------------分配内存空间---------------- 	//保证散列表的最大长度是素数 	H->TableSize = nextPrime(TableSize); 	//分配链表头结点数组 	H->Heads = (List)malloc(H->TableSize * sizeof(struct LNode)); 	//初始化表头节点 	//for (i = 0; i<H->TableSize; i++) 	//{ 		memset(H->Heads->Data, 0 , KEYLENTH + 1);//------------为Data数组赋初值---------------- 		H->Heads->Next = NULL; 	//} 		return H; }谢谢回复。请问这个和加循环有什么区别？

1在CreateTable()函数中，既然是初始化表头，就没必要使用for循环了 	//初始化表头节点 	//for (i = 0; i<H->TableSize; i++) 	//{ 		strncpy(H->Heads->Data, 0 , KEYLENTH + 1); 		H->Heads->Next = NULL; 	//} 2 把 int  HashAdd(const char *key) 改为 void  HashAdd(const char *key)  VS2015 C++环境，调试能通过


Question: if(x!=0)  y=1;  else  y=2;  与（ ）等价。的真假问题

if(x=0) y=2;  这是条语句 x=0 这是个表达式  在c中，x=0的含义并不是将0赋值给x x=0是个表达式，这个表达式的值是0，而将0赋值给x，是这个表达式的副作用。  也就是说并不是，将0赋值给x，然后表达式的值才是0的。 而是表达式的值是0，而x=0，是这个求值过程中的副作用。  那么 if(x=0) y=2;  的含义是，如果表达式的值为真，将2赋值给y 而x=0这个表达式的值，是x=0后的值，也就是永远为假 所以D不对

D错在用了=号，比较要用==号


Question: 这个代码为啥Dev上运行成功VS就不成功

引用 1 楼 user-1的回复:肯定是你 VSCode 的编译器没安装好。  如果不是，那就是因为两个编译器不同的原因（不过大部分应该一样）。  如果你觉得还不是，那试试这样：  把头文件加上  #include<bits/stdc++.h>  然后把 char * 都改成 string （可能指针内部实现错误吧）。  要是还不行，那我也没办法了，希望得到帮助！ 感谢感谢，解决问题了


引用 2 楼 ?Victor.?? 的回复:就是加_CRT_SECURE_NO_WARNINGS  不用_s  对吗 标准也有安全的函数库啊，不知道的时候可以谷歌百度一下函数的用法，就会有多函数的比较，安全的，非安全的，自己根据需求取舍就好了

不需要，标准c有安全的函数

我一般不用s 使用前先判断长度。

引用 1 楼 qybao 的回复:那是面向windows的函数库，非windows用不了，所以如果考虑到移植，最好用标准的函数库  就是加_CRT_SECURE_NO_WARNINGS  不用_s  对吗

引用 6 楼 真相重于对错 的回复:所谓_s ,就是vs 独有，是不对 看一下这个链接吧 https://zh.cppreference.com/w/c/io  谢谢大佬，明白了，这个网站真不错


Question: 汉诺塔——要求显示递归的层数

在递归的参数里加一个 last 表示上次移动的盘子，f 表示递归层数即可。  希望得到帮助，代码自行思考。

嗯嗯 已经做出来了 感谢各位 自己的代码贴上： #include <stdio.h> #include <stdlib.h> int i=1;  int layer=1;  void hanoi(char src, char mid, char dst, int n) { if (n == 1) { printf("第%d步：将%d号盘子从%c移动到%c\n",i++,n, src, dst); printf("返回第%d层\n",--layer); }  else  { printf("调用第一个递归进入第%d层\n",++layer); hanoi(src, dst, mid, n - 1); printf("第%d步：将%d号盘子从%c移动到%c\n",i++,n, src, dst); printf("调用第二个递归进入第%d层\n",++layer); hanoi(mid, src, dst, n - 1); if(layer!=1) printf("返回第%d层\n",--layer); } }  int main(void) { int n; printf("请输入盘子的个数\n"); while (scanf("%d", &n) != EOF)  { 	printf("盘子移动情况如下：\n"); 	hanoi('A', 'B', 'C', n); 	printf("一共需要%d步\n",i-1); } return 0; }

思路挺简单的，就是用一些指针变量记录移动次数，递归层数，和盘子编号就行了 给你写个例子，偷懒了把指针变量改用数组，数组长度也省略了 递归的思路就不说明了，各种汉诺塔的程序都有解释说明，这里解释一下移动次数和递归层数 void han(int n, char a, char b, char c, int *info) {     if (n==1) {         info[0]++; //每次移动时移动次数递增         printf("第%d步: 将%d号盘子从%c移动到%c\n", info[0], info[2]-info[1]+1, a, c); //打印移动情况，盘子编号看main方法解释     } else {         printf("在第%d层调用第一个递归进入第%d层\n", info[1], info[1]+1); //打印第一次调用递归层数         info[1]++; //调用递归前递归层数递增         han(n-1, a, c, b, info); //然后调用递归（在递归结束后，递归层数要记得递减）         printf("返回第%d层\n", --info[1]); //调用递归结束后递归层数递减，然后打印返回层数         info[0]++; //每次移动完时移动次数递增         printf("第%d步: 将第%d号盘子从%c移动到%c\n", info[0], info[2]-info[1]+1, a, c); //打印移动情况         printf("在第%d层调用第二个递归进入第%d层\n", info[1], info[1]+1); //打印第二次调用递归层数         info[1]++; //调用递归前递归层数递增         han(n-1, b, a, c, info); //然后调用递归（在递归结束后，递归层数要记得递减）         printf("返回第%d层\n", --info[1]); //调用递归结束后递归层数递减，然后打印返回层数     } }  int main(int argc, const char * argv[]) {     char a='A', b='B', c='C';     int n, info[3] = {0, 1, 0}; //数组第一个元素是移动次数，第二个是递归层数，第三个是总盘子数（总盘子数-递归层数+1=盘子编号）     printf("请输入盘子个数:\n");     scanf("%d", &n);     info[2] = n; //设定盘子数     printf("盘子移动情况如下:\n");     han(n, a, b, c, info);     printf("共移动了%d次:\n", info[0]);      return 0; }


Question: 想问一下C语言中怎么把字符型数据转化成ASCII码值来进行运算

两个字符都用字符接收就好了 scanf("%d%c", &y, &c); 改成 scans("%d %c", &y, &c); //中间加个空格，否则你的空格就被当字符读入了

printf("%d\n", 'a');


Question: 怎么封装动态库的头文件

引用 2 楼 红毛怪之飞蓬 的回复:那我还是要在新的C.h里inlclude  A.h，但是提供给同事的时候只能提供一个头文件给他  不知道这种对外提供动态库的行业通常封装方式是怎样的 我也觉得你这个设计有点问题，既然调用你的dll只需要C.h，那何必include A和B，你的C.h就应该只放你的dll入口函数声明以及用到的一些结构体声明，具体实现的C.cpp才去include其它相关的A和B，如果C.h的结构体定义需要A和B的结构体，你可以像之前所说的，在C.h声明一下就好了。也就是1L的把include "A.h"放到C.cpp里，然后在C.h里追加A和B的结构体的声明就好了。

如果不让别人看到A.h, B.h，那么就不要在C.h中包含前两个，因为如果包含，只给了C.h，那么对方编译不通过。 所以，把A.h， B.h不要放在C.h里，而是放在.c源文件里，在源文件里引入前两个头文件

引用 1 楼 qybao 的回复:试试看在新的C.h里不要重新定义A和B结构体，只是声明结构体 比如 A.h 有结构体定义 typedef struct A {     int a; } STA;  C.h则改成 struct A; #include "A.h"  这样应该就不会发生重复定义了吧  那我还是要在新的C.h里inlclude  A.h，但是提供给同事的时候只能提供一个头文件给他  不知道这种对外提供动态库的行业通常封装方式是怎样的


Question: 能不能解释一个，我看不懂。

存p年后的本利合计=本金 * (1 + 年利率)^p，如果年利率不是绝对数字而是百分比就要除以100，他的代码就是循环求乘方

引用 3 楼 自信男孩的回复:[quote=引用 2 楼 weixin_46294972 的回复:] [quote=引用 1 楼 自信男孩的回复:]需求呢?代码是根据需求写出来的～ 按年利率r％存入本钱x，存入p年后的本利合计为y=x*((100+r)/100)^p。求y的值[/quote] 那你的p为什么要定义成float类型呢？[/quote] 这是网上的正确答案。我就是看不懂

引用 2 楼 weixin_46294972 的回复:[quote=引用 1 楼 自信男孩的回复:]需求呢?代码是根据需求写出来的～ 按年利率r％存入本钱x，存入p年后的本利合计为y=x*((100+r)/100)^p。求y的值[/quote] 那你的p为什么要定义成float类型呢？

引用 1 楼 自信男孩的回复:需求呢?代码是根据需求写出来的～ 按年利率r％存入本钱x，存入p年后的本利合计为y=x*((100+r)/100)^p。求y的值

需求呢?代码是根据需求写出来的～

本钱x，刚存入没有利息，所以总额y的值就是x中间循环p是年份，循环一次代表一年，因为i是int类型，比较要把p换成同类型，你的p是float，（int）p是把p强制转换成int类型

x代表本金，r代表利率，p代表年数，y代表p年后的总金额，是这个意思吧？ y=x，表示最开始总金额和本金一样 for循环表示循环p年，每循环一次计算一次总金额 y*=(100+r)/100 等价于 y = y*(100+r)/100，表示每循环一次，重新计算y， y的计算公式是 总金额 = 元金 + 元金*利率，即 y=y+y*(r/100)=y*(100+r)/100 最后打印y，保留2位小数


Question: c语言

int i,j,sum=0; //自己建立3*3数组输入数据 for(i=0;i<3;i++){       for(j=0;j<3;j++){             if(i>=j){                 sum+=arr[i][j]; } } }  上三角的特点就是对角线i=j的时候为界限。所以把i>=j，也就是行大于等于列的加起来就好了


Question: 从屏幕获取两个变量的值和一个算术运算符（+、-、*、/、%），对这两个变量进  行相应的算术运算，输出计算结果，对于其他运算符给出错误信息。

你放心 都是错的

scanf(“%s”, &c)有问题（内存越界），字符串会带有结束符‘\0’，也就是在&c地址的后一个字符被赋值为‘\0’，按照栈内存地址分布，c之后是b，b之后是a，所以‘\0’把b的内存信息修改了，所以你先输入数字的话，后输入的c会修改b的信息，导致结果不对，反过来先输入字符的话，虽然字符修改了b，但后输入的数字又把b改回来了，所以结果正确。 所以正确的做法是”%s”改成”%c”

引用 1 楼 user-3的回复:读入顺序错了啊  一个是先读入字符，再读入数字；  一个是先读入数字，再读入字符。  这肯定不一样啊 那为什么先读入数字运算出来的答案是错的


Question: opengl现在是什么情况

引用 8 楼 帅得不敢出门 的回复:推陈出新是肯定的，  人也是不断学习的， 旧的东西也是一种积累。  那d3d9中有哪些能在d3d12中用啊

引用 5 楼 ggglivw 的回复:你觉得要多少年？还有很多东西用着，不会很快的，就像现在很多祖传代码维护，比如VB这种依然有生存空间。C++做应用开发的软件也很多，就算是维护祖传代码也可以继续生存多年，虽然大家都知道现在用C++开发上层逻辑层应用不好用了。  搞笑，windows上不用c++用什么，都是khronos开发的，我看用不了几年，差不多就像swift淘汰objectivec一样

引用 4 楼 imarshal 的回复:[quote=引用 2 楼 ggglivw 的回复:] 想多了，影响就是以后的招聘会由精通opengl,dx  变成精通  opengl, dx, vulkan  opengl肯定会淘汰，换成metal还差不多[/quote]  你觉得要多少年？还有很多东西用着，不会很快的，就像现在很多祖传代码维护，比如VB这种依然有生存空间。C++做应用开发的软件也很多，就算是维护祖传代码也可以继续生存多年，虽然大家都知道现在用C++开发上层逻辑层应用不好用了。

引用 2 楼 ggglivw 的回复:想多了，影响就是以后的招聘会由精通opengl,dx  变成精通  opengl, dx, vulkan  opengl肯定会淘汰，换成metal还差不多

引用 1 楼 帅得不敢出门 的回复:我们项目目前用opengl，完全被取代夸大了。  问题是这两个现在是同一个开发组

我们项目目前用opengl，完全被取代夸大了。

推陈出新是肯定的，  人也是不断学习的， 旧的东西也是一种积累。

引用 6 楼 imarshal 的回复:[quote=引用 5 楼 ggglivw 的回复:] 你觉得要多少年？还有很多东西用着，不会很快的，就像现在很多祖传代码维护，比如VB这种依然有生存空间。C++做应用开发的软件也很多，就算是维护祖传代码也可以继续生存多年，虽然大家都知道现在用C++开发上层逻辑层应用不好用了。  搞笑，windows上不用c++用什么，都是khronos开发的，我看用不了几年，差不多就像swift淘汰objectivec一样[/quote]  你才是搞笑好吧。谁说windows上就一定要用C++？


Question: 问一下用C语言编译简单的酒店管理系统怎么做（帮写一下用重谢呀）下面的题是英文的，有意者加一下微信好友：TX00ST

引用 2 楼 红毛怪之飞蓬 的回复：英文不好，爱莫能助啊，加油！可以用一下有道翻译嘛

引用 1 楼 Mrxlin 的回复：写控制台操作的吗，为什么是英文的练习，国外大学吗？中外合作大学

英文不好，爱莫能助啊，加油！

写控制台操作的吗，为什么是英文的练习，国外大学吗？


Question: 1.  从键盘输入一行字符，要求输出其相应的密码。密码规则：每个英文字母变成其后的第4个字母，如A变成E, z变成d，非字母字符保持不变.

貌似某个信息学训练的基础题 自己一行代码不写就要答案有啥意思呢， 能学会什么？

#include <stdio.h> #include <ctype.h> #include <string.h>  #define MAX_CHAR_NUM   26  int main() {     char str[100];     int i;      scanf("%s", str); #if 1     i = 0;     while (str[i]) {         if (isupper(str[i]))             str[i] = (str[i] - 'A' + 3) % MAX_CHAR_NUM + 'a';         else if (islower(str[i]))             str[i] = (str[i] - 'a' + 3) % MAX_CHAR_NUM + 'A';         i++;     }     puts(str); #else     int len = strlen(str);     for (i = 0; i < len; i++) {         if (isupper(str[i]))             str[i] = (str[i] - 'A' + 3) % MAX_CHAR_NUM + 'a';         if (islower(str[i]))             str[i] = (str[i] - 'a' + 3) % MAX_CHAR_NUM + 'A';     }     puts(str); #endif      return 0; } 在这个基础上改改吧

#include <stdio.h> #include <string.h>  int main(){         char str[100]={};         char dest[100]={};         gets(str);         int len = strlen(str);         int i;         for (i=0;i<len;i++){                 if(str[i]>='a'&&str[i]<='z'){                         dest[i]=str[i]+4;                         if(dest[i]>'z'){                                 dest[i]=dest[i]-'z'+'a';                         }                 }                 //else if{大写情况}                 else{                         dest[i]=str[i];                 }         }         printf("%s\n",dest);         return 0;

判断大小写，然后mod


Question: 为什么进行加减运算后的结果为0？

printf 不用加 &

#include<stdio.h> struct member {     char name[10];     float jiben;     float fudong;     float zhichu;     float salary; }; int main() {     int N,i;     struct member m1[100];     scanf("%d", &N);     if (N > 100)         N = 100;     for (i = 0; i < N; i++)     {         //scanf("%s %f %f %f", &m1[i].name, &m1[i].jiben, &m1[i].fudong, &m1[i].zhichu);         scanf("%s %f %f %f", m1[i].name, &m1[i].jiben, &m1[i].fudong, &m1[i].zhichu);         m1[i].salary = (m1[i].jiben + m1[i].fudong )-m1[i].zhichu;     }     for (i = 0; i < N; i++)     {         //printf("%s %.2f", &m1[i].name, &m1[i].salary);         printf("%s %.2f", m1[i].name, m1[i].salary);         putchar('\n');     } } 供参考～


Question: printf函数的问题

#define FORMAT "%s C is cool!\n"  则printf(FORMAT,FORMAT);将第一个FORMAT中的"%s"替换为FORMAT(即"%s C is cool!\n") 则输出 %s C is cool!(这是第二个参数的FORMAT内容,包括'\n')  C is cool!(%s被替换了,所以没有)

很好理解呢，第二个FORMAT是对应的%s内容。

第一个format  "%s ...................."//这里的%s是第二个format的内容  第二个里面有%s，所以会先打印一个%s出来