Question: C语言udp服务器接收BC95模块发送的十六进制数据

是的，字符串是靠‘\0’来判定是否结束的 这对于byte[]的接收不适用 一般都是包头携带数据长度，根据数据长度来判定是否结束

用strlen来判断接收数据大小，只适用于该数据刚好是字符串的情况，BC95_Senddata是如何发送数据的，你清楚吗？若不知道，改成直接把buf全部打印出来，研究一下。

void print_client_info(const struct sockaddr_in *client_addr) { 	char ipstr[128] = {0}; 	inet_ntop(AF_INET, &(client_addr->sin_addr).s_addr, ipstr, sizeof(ipstr)); 	int client_port = ntohs(client_addr->sin_port); 	printf("client IP = %s, PORT = %d\n", ipstr, client_port); }  int main(int agrc, const char *argv[]) { 	int socket_fd; 	socklen_t addr_len; 	struct sockaddr_in serveraddr, clientaddr; 	unsigned char buf[MAXLINE] = {0};  	bzero(&serveraddr, sizeof(serveraddr)); 	bzero(&clientaddr, sizeof(clientaddr));  	serveraddr.sin_family = AF_INET; 	serveraddr.sin_addr.s_addr = htonl(INADDR_ANY); 	serveraddr.sin_port = htons(SERVER_PORT);  	addr_len = sizeof(clientaddr);  	socket_fd = socket(AF_INET, SOCK_DGRAM, 0); 	bind(socket_fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)); 	while(1) {  		addr_len = sizeof(clientaddr);  		memset(buf, 0, sizeof(buf));  		recvfrom(socket_fd, buf, sizeof(buf), 0, (struct sockaddr *)&clientaddr, &addr_len);  		print_client_info(&clientaddr);  	//	printf("recive from client:\n %s\n",buf); 		printf("buf大小: %d\n",strlen(buf));  		for(int i = 0; i < strlen(buf); i++) { 			buf[i] = toupper(buf[i]); 			printf("%X\n",buf[i]); 		} 		printf("\n");  		sendto(socket_fd, buf, strlen(buf), 0, (const struct sockaddr *)&clientaddr, sizeof(clientaddr)); 	} 	close(socket_fd); 	return 0; }

你都没说具体出错信息，怎么帮你


Question: 二维字符串输入问题

引用 3 楼 LiuCunZhiPu 的回复:引用 1 楼 hezhe1008 的回复:char a[10][10];没用啊 memset(a, 0, 100);

引用 1 楼 hezhe1008 的回复:char a[10][10];没用啊

char *a[10]; 这里只是分配了指针，但没有为字符串分配空间，需要： a[0] = new char[100]; 否则会出现异常

char a[10][10];

char *a[10]; 表是有10个char*指针的数组，但每个指针初始并没有指向一块有效的内存，你需要初始化之后再赋值  解决办法，可以先为每个指针动态申请空间

#include <stdio.h> #include <stdlib.h> #include <string.h>  void ascend(char **X) {     int i,j;     char *t;     for(i=0;i<9;i++)         for(j=0;j<9-i;j++)             if(strcmp(X[j],X[j+1])>0){                 t=X[j];                 X[j]=X[j+1];                 X[j+1]=t;             } }  int main() {     char *a[10];     int i;      for(i=0;i<10;i++) {         a[i] = (char *)malloc(sizeof(char) * 10);         if (!a[i])             return -1;         scanf("%s", a[i]);     }      ascend(a);     for(i=0;i<10;i++) {         printf("%s ",a[i]);         free(a[i]);     }     putchar(10);      return 0; } char *a[10]是10个野指针，直接用肯定是不可以的。所以需要用new或malloc申请堆上的空间，然后就可以直接赋值了。


Question: 数据结构

引用 11 楼 zj19941201 的回复:[quote=引用 9 楼 cfjtaishan 的回复:] #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring>  typedef int TElemtype;  typedef struct BiTNode {     TElemtype data;     struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;  typedef struct {     BiTNode *elem;     int base;     int top; }Stack;  void initstack(Stack &S) {     S.elem = (BiTNode *)malloc(20*sizeof(BiTNode));     if (!S.elem) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     S.base = S.top = 0; }  void push(Stack &S,BiTree T) {     memcpy(S.elem+S.top, T, sizeof(BiTNode));     //S.elem[S.top] = T;     ++S.top; } BiTNode pop (Stack &S) {     return S.elem[--S.top]; }  #if 0 void pref(BiTree &T,Stack &S) {     BiTNode p = *T;      while(p!=NULL|| (S.top!=S.base))     {         if(p!=NULL){             printf("%d", p->data);             push(S,p);             p = p->lchild;         }else{             p = pop(S);             p = T->rchild;         }     } } #endif int main() {     Stack S;     initstack(S);     return 0; } 栈申请没什么问题。  说错了，就是卡在你改的这一步，memcpy(S.elem+S.top, T, sizeof(BiTNode));     //S.elem[S.top] = T; 报错：[Error] no match for 'operator=' in '*(S.Stack::elem + ((sizetype)(((long long unsigned int)S.Stack::top) * 24ull))) = T'  [/quote] 如果不改呢？会有问题吗？

引用 12 楼 cfjtaishan 的回复:[quote=引用 11 楼 zj19941201 的回复:] [quote=引用 9 楼 cfjtaishan 的回复:] #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring>  typedef int TElemtype;  typedef struct BiTNode {     TElemtype data;     struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;  typedef struct {     BiTNode *elem;     int base;     int top; }Stack;  void initstack(Stack &S) {     S.elem = (BiTNode *)malloc(20*sizeof(BiTNode));     if (!S.elem) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     S.base = S.top = 0; }  void push(Stack &S,BiTree T) {     memcpy(S.elem+S.top, T, sizeof(BiTNode));     //S.elem[S.top] = T;     ++S.top; } BiTNode pop (Stack &S) {     return S.elem[--S.top]; }  #if 0 void pref(BiTree &T,Stack &S) {     BiTNode p = *T;      while(p!=NULL|| (S.top!=S.base))     {         if(p!=NULL){             printf("%d", p->data);             push(S,p);             p = p->lchild;         }else{             p = pop(S);             p = T->rchild;         }     } } #endif int main() {     Stack S;     initstack(S);     return 0; } 栈申请没什么问题。  说错了，就是卡在你改的这一步，memcpy(S.elem+S.top, T, sizeof(BiTNode));     //S.elem[S.top] = T; 报错：[Error] no match for 'operator=' in '*(S.Stack::elem + ((sizetype)(((long long unsigned int)S.Stack::top) * 24ull))) = T'  [/quote] 如果不改呢？会有问题吗？[/quote]   不改的话，在编译时就会报错报错 ：[Error] no match for 'operator=' in '*(S.Stack::elem + ((sizetype)(((long long unsigned int)S.Stack::top) * 24ull))) = T'  我看不懂这个报错什么意思啊，你改的哪一步是什么啊，能不能解释一下啊，谢谢。

引用 9 楼 cfjtaishan 的回复:#include <iostream> #include <cstdio> #include <cstdlib> #include <cstring>  typedef int TElemtype;  typedef struct BiTNode {     TElemtype data;     struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;  typedef struct {     BiTNode *elem;     int base;     int top; }Stack;  void initstack(Stack &S) {     S.elem = (BiTNode *)malloc(20*sizeof(BiTNode));     if (!S.elem) {         fprintf(stderr, "malloc error!\n");         exit(1);     }     S.base = S.top = 0; }  void push(Stack &S,BiTree T) {     memcpy(S.elem+S.top, T, sizeof(BiTNode));     //S.elem[S.top] = T;     ++S.top; } BiTNode pop (Stack &S) {     return S.elem[--S.top]; }  #if 0 void pref(BiTree &T,Stack &S) {     BiTNode p = *T;      while(p!=NULL|| (S.top!=S.base))     {         if(p!=NULL){             printf("%d", p->data);             push(S,p);             p = p->lchild;         }else{             p = pop(S);             p = T->rchild;         }     } } #endif int main() {     Stack S;     initstack(S);     return 0; } 栈申请没什么问题。  说错了，就是卡在你改的这一步，memcpy(S.elem+S.top, T, sizeof(BiTNode));     //S.elem[S.top] = T; 报错：[Error] no match for 'operator=' in '*(S.Stack::elem + ((sizetype)(((long long unsigned int)S.Stack::top) * 24ull))) = T'

memcpy(S.elem+S.top, T, sizeof(BiTNode));     //S.elem[S.top] = T; 说错了，就是卡在你改的这一步，报错：[Error] no match for 'operator=' in '*(S.Stack::elem + ((sizetype)(((long long unsigned int)S.Stack::top) * 24ull))) = T'

引用 5 楼 zhao4zhong1 的回复:再供参考：#include <stdio.h> #include <stdlib.h> #include <conio.h> #include <graphics.h> int xs[10000]; int ys[10000]; int i=0,xx,yy; int fc,bc; void push(int x,int y) { 	xs[i]=x; 	ys[i]=y; 	if (i<10000-1) { 		i=i+1; 	} else { 		printf("stack overflow!\n"); 		exit(1); 	} } void pop(void) { 	i=i-1; 	xx=xs[i]; 	yy=ys[i]; } int check(int x,int y) { 	int	c;  	c=getpixel(x,y); /*	获取当前点的颜色 */ 	return ((c!=bc)&&(c!=fc));/* 如果颜色为边界色或填充色则不填充 */ } void seedfilling(int x,int y,int fill_color,int boundary_color) { 	fc=fill_color; 	bc=boundary_color; 	push(x,y); 	while (1) { 		if (i<=0) return; 		pop(); 		if (check(xx,yy)) { 			putpixel(xx, yy, 14);getch();  /* 加上这行显示当前填充状态 */  			putpixel(xx, yy, fill_color); /* 画点 */  			if (check(xx-1,yy  )) push(xx-1,yy	); 			if (check(xx  ,yy+1)) push(xx  ,yy+1); 			if (check(xx  ,yy-1)) push(xx  ,yy-1); 			if (check(xx+1,yy  )) push(xx+1,yy	); 			/* 去掉下面四句就是四连通 */ 			if (check(xx-1,yy-1)) push(xx-1,yy-1); 			if (check(xx-1,yy+1)) push(xx-1,yy+1); 			if (check(xx+1,yy-1)) push(xx+1,yy-1); 			if (check(xx+1,yy+1)) push(xx+1,yy+1);         }     } } void main() {     int a,b,color;     int gdriver = DETECT, gmode, errorcode;     int poly[10];  	initgraph(&gdriver,	&gmode,	"d:\\bc\\bgi");     a=150;     b=140;     color=4;     poly[0]=110;/* 第一个点的x坐标以及y坐标 */     poly[1]=110;     poly[2]=200;/* 第二点 */     poly[3]=105;     poly[4]=170;/* 第三点 */     poly[5]=120;     poly[6]=150;/* 第四点 */     poly[7]=170;     poly[8]=110;/* 多边形的起点与终点一样 */     poly[9]=110;     drawpoly(5,poly);/* 显示各点连接起来的多边形 */      /* 保证边界对八连通是封闭的 */     setviewport(0,1,600,300,0);     drawpoly(5,poly);/* 显示各点连接起来的多边形 */     setviewport(1,0,600,300,0);     drawpoly(5,poly);/* 显示各点连接起来的多边形 */     setviewport(1,1,600,300,0);     drawpoly(5,poly);/* 显示各点连接起来的多边形 */      /* 恢复默认viewport */     setviewport(0,0,600,300,0);      seedfilling(a,b,color,15);  /* 种子填充多边形 */      getch();     closegraph(); }   老师，我就是对结点这个东西理解有点困惑，我想把结点放进栈，难以实现。把整形和字符类型的这些类型放进栈我自己可以实现。如果说把二叉树的节点放进栈内是不是相当于把这个节点的地址放进了栈内啊。

引用 6 楼 cfjtaishan 的回复:[quote=引用 4 楼 zj19941201 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 这样定义是没问题，主要是实现。 typedef struct BiTNode{     TElemtype data;     struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;  typedef struct{     BiTNode *elem;     int base;     int top; }Stack  我在申请空间的时候就报错了，我不知道是哪里出了问题，还是传参的时候错了？[/quote] 贴出你的代码，看一下是哪儿出了问题。[/quote]  好的！ typedef int TElemtype; typedef struct BiTNode{ 	TElemtype data; 	struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; typedef struct{ 	 BiTNode *elem; 	 int base; 	 int top; }Stack;   void initstack(Stack &S)  {  	S.elem = (BiTNode *)malloc(20*sizeof(BiTNode));  	S.base=S.top=0;  }    void push(Stack &S,BiTree T)  {  	S.elem[S.top]=T;  	++S.top;  }  BiTNode pop (Stack &S)  {  	return *S.elem[--S.top];  }    void pref(BiTree &T,Stack &S)  {  	BiTree *p;  	while(p!=NULL|| (S.top!=S.base))  	{  		if(p!=NULL){  		printf("%d",p->data);  		push(S,p);  		p=p->lchild;	  		}else{  			p=pop(S);  			p=T->rchild;  		}  	}  }  int main() { 	Stack S; 	initsatck(S); return 0； }

引用 4 楼 zj19941201 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 这样定义是没问题，主要是实现。 typedef struct BiTNode{     TElemtype data;     struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;  typedef struct{     BiTNode *elem;     int base;     int top; }Stack  我在申请空间的时候就报错了，我不知道是哪里出了问题，还是传参的时候错了？[/quote] 贴出你的代码，看一下是哪儿出了问题。

引用 1 楼 cfjtaishan 的回复:这样定义是没问题，主要是实现。 typedef struct BiTNode{     TElemtype data;     struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;  typedef struct{     BiTNode *elem;     int base;     int top; }Stack  我在申请空间的时候就报错了，我不知道是哪里出了问题，还是传参的时候错了？

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


Question: 给定一个日期，输出这个日期是该年的第几天。

引用 2 楼 hdt 的回复:c/c++其中有很多陷阱，有过一本书叫好像叫 《c 陷阱》 如果你去一个一个试错，来学习c++/c的话，估计猴年马月也学不会。 建议先找一本，比较基础，入门教程，系统的学习一下。 回错了

/* valid return 1, invalid return 0*/ int check_value(int year, int month, int day) {     int leap = 0, ret = 1;      if ((year % 400) || (year % 4 == 0 && year % 100 != 0))         leap = 1;     if (month <= 0 || month > 12) {         fprintf(stdout, "Month invalid!\n");         ret = 0;         return ret;     }      switch (month) {         case 1:         case 3:         case 5:         case 7:         case 8:         case 10:         case 12:             if (day > 31 || day <= 0) {                 fprintf(stdout, "Day invalid!\n");                 ret = 0;             }             break;          case 2:             if (leap) {                 if (day > 29 || day <= 0) {                     fprintf(stdout, "Day invalid!\n");                     ret = 0;                 }             } else {                 if (day > 28 || day <= 0) {                     fprintf(stdout, "Day invalid!\n");                     ret = 0;                 }             }             break;          case 4:         case 6:         case 9:         case 11:             if (day > 30 || day <= 0) {                 fprintf(stdout, "Day invalid!\n");                 ret = 0;             }             break;          default:             break;     }     return ret; } 每次输入年月日后都做一次检测，检测算法仅供参考

CSpanTime类

用CTime吧, 把当前日期与当年的第一天相减, 就得到相关天数, 这样就不难得出是当年第几天了.


Question: 输出两个链表的共同元素，链表仍使用原来的La链表，为啥这个输入abc     bcz 时只输出b啊

void MergeList_3(LinkList &La,LinkList &Lb) {     LNode *pa,*pb,*p;     pa = La->next;     pb = Lb->next;     p = La;     p->next = NULL;     while(pa && pb)     {         if(pa->data == pb->data)         {             LNode *temp;             temp = pa;             pa = pa->next;             pb = pb->next;             temp->next = p->next;             p->next = temp;         }         else if(pa->data < pb->data)         {             pa = pa->next;         }         else         {             pb = pb->next;         }     } } 可以参考一下上面的代码； 问题出在 if(pa->data == pb->data)判断条件体里。因为楼主的逻辑里，在将La链表里的数据放到新的链表里时，修改了原La的链表的下个节点。即当节点pa指向'b'时，pa->next就指向了NULL，所以La的'c'节点找不到了。 修改的办法如上，用temp指向要加到新的La的链表，然后让pa指向下一个节点，即‘c'，最后再将temp链到新的La上。 最后的while(pa), while(pb)没有意义，建议删除。


Question: 如图所示，我已经用了strcut结构语句，为什么显示我错误呢？

楼主还是使用typedef来定义吧！ 楼主的问题我也经常遇到，后来放弃了。用typedef就方便多了。

声明前加Enum和struct

C语言不像C++那样可以直接用结构体名或者枚举名来定义变量，需要前面加上关键字struct 或enum 如果实在想直接使用某个名字而不想加struct或者enum，可以typedef一下，typedef的使用建议查一下

struct PCB {  }; struct PCB a;  //struct不能少   如果不想用加struct,使用typedef  typedef struct PCB {  }MyPCB;  MyPCB a;

错误提示都告诉你了，要再申明前面加关键字Enum和struct

struct PCB XXX enum State XXX 声明时前面加上各自的struct 和State

你用的是c吧？？？ 改成c++的试试


Question: 为什么没有执行最后的求和程序就退出了

#include<stdio.h>  int main(void) {     long num;     long sum = 0L;     int status;      printf("please enter an integer to be summed ");     printf("(q to quit): ");     status = scanf("%ld", &num);     while (status == 1)     {         sum= sum + num;         printf("please enter next integer (q to quit): ");         status=scanf("%ld", &num);      }     printf("Those integers sum to %ld.\n", sum);      return 0; }  sum的输出应该是使用%ld格式。 程序可以输出结果，如果是cmd闪一下退出，建议加两行getchar();或者system("pause");（需要包含头文件stdlib.h)

ctrl f5             system("pause")

复制了楼主代码，可以运行，结果也正确


Question: 用C语言编链栈 但是老是显示为空是怎么回事？

初始化和创建栈有问题呢，一个问题没有将初始化的top带到main函数里，即main里的top->next并没有初始化为NULL，另一个问题，即创建栈没有什么操作，只是做了一个无用的循环，并且也没有将创建的栈带回main函数里的top，即top没变动。 对于楼主用链表模拟栈操作，建议不要创建栈了，直接在入栈和出栈的地方创建节点和释放节点。


Question: 顺序表删除，想要实现任意输入一串字符，删除其中任意位置。最后main函数内的内容不知道该怎么修改

#include<stdio.h> #include<stdlib.h>  #define OK 1 #define OVERFLOW 0 #define ERROR -1 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define elemtype char  typedef struct {     char * elem;     int length;     int listsize; }SqList;  int Initlist(SqList *L) {     L->elem = (char*)malloc(LIST_INIT_SIZE*sizeof(char));     if (!(L->elem))         exit(OVERFLOW);     L->length = 0;     L->listsize = LIST_INIT_SIZE;      return OK; } int listDelete_sq(SqList *L, int i, int *e) {     if(i < 1 || i > L->length)         return ERROR;     char * p, *q;     if (!L->elem)         exit(OVERFLOW);     p = &(L->elem[i-1]);     *e = *p;   /* 类型不匹配 */     q = L->elem + L->length-1;     for(++p; p <= q; ++p)         *(p-1) = *p;     --L->length;      return OK; } int main(void) {     int pos, ch;     SqList L;     int i;     Initlist(&L);     printf("please input the data:");     for (i = 0; i < 10; i++)     {         if ((ch = getchar()) == '\n')             break;         L.elem[i] = ch;         L.length++;     }     printf("cur pos %d\n", L.length);     printf("Input position: ");     scanf("%d", &pos);     listDelete_sq(&L, pos, &ch);     printf("Delete: %c\n", ch);     printf("the final array is:");     for(i = 0; i < L.length; i++)     {         printf("%c", L.elem[i]);     }     putchar(10);     return 0; }  上面的代码已经调试好，参考一下吧； 源代码里：初始化和删除操作的函数都需要改动；  另外，有两处循环逻辑有问题；


Question: 求教

注意scanf第一个参数是%d而不是d%  scanf("%d", &a);


Question: c语言

3/5返回的是整数 3/5.0返回的是double类型

3/5是0，只输出整数部分。 3/5.0有一个是浮点数，才输出小数部分

完全可以问百度和google呀

int /int = int   int / double = double

C++ Floating-Point Constants Floating-point constants specify values that must have a fractional part. These values contain decimal points (.) and can contain exponents.  Syntax  floating-constant :  fractional-constant exponent-partopt floating-suffixopt digit-sequence exponent-part floating-suffixopt  fractional-constant :  digit-sequenceopt . digit-sequence digit-sequence .  exponent-part :  e signopt digit-sequence E signopt digit-sequence  sign : one of  + –  digit-sequence :  digit digit-sequence digit  floating-suffix :one of  f l F L  Floating-point constants have a “mantissa,” which specifies the value of the number, an “exponent,” which specifies the magnitude of the number, and an optional suffix that specifies the constant’s type. The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. For example:  18.46 38.  The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:  18.46e0      // 18.46 18.46e1      // 184.6  If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.  Floating-point constants default to type double. By using the suffixes f or l (or F or L — the suffix is not case sensitive), the constant can be specified as float or long double, respectively.  Although long double and double have the same representation, they are not the same type. For example, you can have overloaded functions like  void func( double );  and   void func( long double );

常量也有类型： C++ Integer Constants Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.  Syntax  integer-constant :  decimal-constant integer-suffixopt octal-constant integer-suffixopt hexadecimal-constant integer-suffixopt 'c-char-sequence'  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffixopt long-suffix unsigned-suffixopt  unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.  To specify a decimal constant, begin the specification with a nonzero digit. For example:  int i = 157;   // Decimal constant int j = 0198;  // Not a decimal number; erroneous octal constant int k = 0365;  // Leading zero specifies octal constant, not decimal  To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:  int i = 0377;   // Octal constant int j = 0397;   // Error: 9 is not an octal digit  To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:  int i = 0x3fff;   // Hexadecimal constant int j = 0X3FFF;   // Equal to i  To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:  unsigned uVal = 328u;             // Unsigned value long lVal = 0x7FFFFFL;            // Long value specified                                    //  as hex constant unsigned long ulVal = 0776745ul;  // Unsigned long value

整数和小数区别

区别是一个是整数除法，一个是实数除法； 整数除法得到的值是整数，实数除法得到的是实数；

前面一个也可以称为整除（即除了之后的值只取整数部分，小数部分舍弃），而后面一个涉及到了数据类型的隐式转换（数据类型的转换分为显示转换也叫强制类型转换，和隐式转换），隐式转换中数据类型会由低级向高级转换（此处表现为一个整数和一个浮点数相除，结果会自动向高级的浮点数转换），因此后一个的结果是一个浮点数（即使是10/5.0时结果会显示为2，但只是省略了后面的小数为0的部分没显示，实际上还是浮点数的类型）。 以上属于我个人理解，仅供参考，如有不当之处请指出，谢谢~

前者是整数除法，结果为0（商0）  后者3会隐式转换double，进行浮点数除法，结果为double类型的0.6

得到的结果是整数 和 小数


Question: 百思不得其解的代码，求大佬指教。

参考一下吧 #include <stdio.h> #include <ctype.h>  #define ID_LEN 18 const unsigned char weight_list[] = { 7,     9, 10, 5, 8,     4, 2, 1, 6,     3, 7, 9, 10,     5, 8, 4, 2 }; const char check_code[] = { '1',     '0', 'X', '9', '8', '7',     '6', '5', '4', '3', '2' };  int check_digit(char *sid); int check_id(char *sid);  int main(void) {     char id[20];     int num, flag = 0;      scanf("%d", &num);      while (num--) {         scanf("%s", id);         if (check_digit(id)) {             if (!check_id(id)) {   /* Invalid ID */                 flag = 1;                 printf("%s\n", id);             }         } else {             flag = 1;             printf("%s\n", id);   /* Invalid ID */         }     }     if (!flag)         printf("All path!\n");      return 0; }  int check_digit(char *sid) {     int i;      for (i = 0; i < ID_LEN - 1; i++)         if (!isdigit(sid[i]))             return 0;      return 1; }   int check_id(char *sid) {     int weight_sum = 0, mode;     int i;      for (i = 0; i < ID_LEN - 1; i++)         weight_sum += (sid[i] - '0') * weight_list[i];     mode = weight_sum % 11;      if (sid[ID_LEN-1] == check_code[mode])         return 1;     else         return 0; }

首先，你检查前17位是否包含“X”是不对的，这对于你这4个输入没问题，但不符合题目里“检查前17位是否全为数字”这句话，正确的做法是检查其值是否在48到57范围内。 其次，后面做检查的代码并没有完全写对啊，比如第二个检查应该是arr[i][17] == '0'并且answer == 1，仔细核对一遍再试吧。

#include <atlstr.h>  #include <time.h> //随机生成大于18岁的身份证号 CString GenerationId(int OldThan = 18) {     time_t t = time(NULL);     tm *tTm = localtime(&t);     int iBaseYear = 1950;     int YearRange = tTm->tm_year + 1900 - iBaseYear - OldThan;     srand(t + rand());     int SixHead = rand() % 999999 + 111111;     int Year = rand() % YearRange + iBaseYear;     int Month = rand() % 12 + 1;     int Day = rand() % 28 + 1;     int ThrEnd = rand() % 999;     TCHAR chi[12] = TEXT("10X98765432");     int Wi[18] = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1 };     TCHAR strID[19] = {0};     _stprintf(strID, TEXT("%06d%04d%02d%02d%03d"), SixHead, Year, Month, Day, ThrEnd);     int Sum = 0;     TCHAR buf[MAX_PATH] = {0};     for(int i = 0; i < 17; i++)     {         Sum += Wi[i] * (strID[i] - '0');     }     TCHAR cLast = chi[Sum % 11];     strID[17] = cLast;     CString tStr = strID;     return tStr; }  //校验身份证号合法性, 传入身份证串. BOOL checkValid(const char *idStr) {     char chi[12] = "10X98765432";     int Wi[18] = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1 };     int Sum = 0;     for(int i = 0; i < 17; i++)     {         Sum += Wi[i] * (idStr[i] - '0');     }     char cLast = chi[Sum % 11];     return idStr[17] == cLast; }


Question: C环境中，如何向stdin中写入数据

http://www.autohotkey.com 使用.ahk脚本，理论上可以将90%以上的手动操作转化为自动运行的程序。

shell语句执行的命令是由某一个服务提供的的操作，我如果想改只能去改这个服务的源码了？

赵老师您好！感谢您的帮助，但是我确实没看懂上面的代码~~问题是这样的，我想重写一个system函数，子进程用execl执行一个shell语句，需要在终端上输入密码，并重复输入一次，我现在想做成，当这个shell语句阻塞在等待输入时，由父进程向子进程的stdin里写入一个密码并重复写入一次，这样就不需要有任何手动输入的操作了。 问题一：能否向stdin里写入数据？ 问题二：父子进程间的stdin是否是同一个？  能否在子进程中将stdin重定向为管道读端，这样父进程直接向管道写端写入就可以了？  谢谢~~！

API SendInput http://www.autohotkey.com

仅供参考：/*     Application:    Code Injection in Explorer     Author:     @_RT     Compiled on:    Feb 2014     URL:http://www.codeproject.com/Tips/732044/Code-Injection-2      We will see the different steps involved to perform a code injection into an already running process.      Following are the quick steps through the process of injection.     1.Get the API addresses that you will be calling from the injected code.     2.Prepare shell code of your function that you want to get executed from the injected process.     3.Get the process ID of the running process that you wish to inject into by enumerating through the       list of processes or by finding the process's window (in case it's a GUI application) by class name or title.     4.Open the process using its Pid with All Access rights.     5.Allocate different memory spaces in the process that you are going to inject to with desired access       rights for holding different segments of your shell code.         Code part (executable instructions)         Data part (strings, function parameters, etc.)     6.Write the allocated memories with the respective values (code and data).     7.Call CreateRemoteThread API and pass to it the start of allocated memory address where you have       written your shell code from the process we are injecting. */  #include <windows.h> #pragma comment(lib,"user32.lib")  LPVOID addr; LPVOID addr2;  BOOL InjectExecutable(DWORD dwPid,LPVOID si,LPVOID pi,int sisize,int pisize) {     LPVOID hNewModule;     HANDLE hProcess;     CHAR S[]    = { "C:\\Windows\\system32\\notepad.exe" };     BYTE byt[]  = {0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x01, 0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x00, 0x68};                  //push  0   , push     0, push     0, push     1, push     0, push     0, push     0, push 0xXXXXXXXX     BYTE byt2[] = {0xE8};//call 0xXXXXXXXX     BYTE byt3[] = {0x68};//push 0xXXXXXXXX      hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPid);     if (hProcess == NULL)     {         return FALSE;     }      LPVOID staddr = VirtualAllocEx(hProcess, NULL, sizeof(S), MEM_COMMIT, PAGE_READWRITE);     WriteProcessMemory(hProcess, staddr, S, sizeof(S), NULL);     LPVOID fnaddr = VirtualAllocEx(hProcess, NULL, 4, MEM_COMMIT, PAGE_READWRITE);     WriteProcessMemory(hProcess, fnaddr, pi, sisize, NULL);     LPVOID fnaddr2 = VirtualAllocEx(hProcess, NULL, 4, MEM_COMMIT, PAGE_READWRITE);     WriteProcessMemory(hProcess, fnaddr2, si, pisize, NULL);      hNewModule = VirtualAllocEx(hProcess, NULL, 100, MEM_COMMIT, PAGE_EXECUTE_READWRITE);     if (hNewModule == NULL)     {         return FALSE;     }     LPTHREAD_START_ROUTINE strtaddr = (LPTHREAD_START_ROUTINE)hNewModule;      WriteProcessMemory(hProcess, hNewModule, byt3, sizeof(byt3), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(byt3));     WriteProcessMemory(hProcess, hNewModule, &fnaddr, sizeof(fnaddr), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(fnaddr));                    // push &pi ;lpProcessInformation     WriteProcessMemory(hProcess, hNewModule, byt3, sizeof(byt3), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(byt3));     WriteProcessMemory(hProcess, hNewModule, &fnaddr2, sizeof(fnaddr2), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(fnaddr2));                   // push &si ;lpStartupInfo     WriteProcessMemory(hProcess, hNewModule, byt, sizeof(byt), NULL);           // push 0 , push 0, push 0, push 1, push 0, push 0, push 0, push 0xXXXXXXXX==&S[0];"C:\\Windows\\system32\\notepad.exe"     hNewModule = (LPVOID)((int)hNewModule + sizeof(byt));                       // lpCurrentDirectory,lpEnvironment,dwCreationFlags,bInheritHandles,lpThreadAttributes,lpProcessAttributes,lpCommandLine,lpApplicationName     WriteProcessMemory(hProcess, hNewModule, &staddr, sizeof(staddr), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(staddr));     WriteProcessMemory(hProcess, hNewModule, byt2, sizeof(byt2), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(byt2));                      // call CreateProcessA     addr = (LPVOID)((int)addr - ((int)hNewModule + 4));     WriteProcessMemory(hProcess, hNewModule, &addr, sizeof(addr), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(addr));     WriteProcessMemory(hProcess, hNewModule, byt, 2, NULL);     hNewModule = (LPVOID)((int)hNewModule + 2);                                 // push 0 ;DWORD dwExitCode   // exit code for this thread     WriteProcessMemory(hProcess, hNewModule, byt2, sizeof(byt2), NULL);     hNewModule = (LPVOID)((int)hNewModule + sizeof(byt2));                      // call ExitThread     addr2 = (LPVOID)((int)addr2 - ((int)hNewModule + 4));     WriteProcessMemory(hProcess, hNewModule, &addr2, sizeof(addr2), NULL);      CreateRemoteThread(hProcess, 0, 0, strtaddr, NULL, 0, NULL);     return TRUE; }  int main() {     _STARTUPINFOA si;     PROCESS_INFORMATION pi;      ZeroMemory(&si, sizeof(si));     si.cb = sizeof(si);     ZeroMemory(&pi, sizeof(pi));      DWORD dwPid;     HMODULE ldlib = LoadLibraryA("Kernel32.dll");     addr = GetProcAddress(ldlib, "CreateProcessA");     addr2 = GetProcAddress(ldlib, "ExitThread");     HWND hWnd1=FindWindow(NULL, "Program Manager");     if (NULL==hWnd1) {         return 1;     }     GetWindowThreadProcessId(hWnd1, &dwPid);      InjectExecutable(dwPid,&si,&pi,sizeof(si),sizeof(pi));      return 0; }

审题！审题！审题！子进程已经被scanf阻塞了，并不是进程间通信，需要父进程向stdin里写入数据来结束子进程的阻塞，有什么办法哪个做到

仅供参考：#pragma comment(lib,"user32") #include <stdio.h> #include <string.h> #include <windows.h> int main() {     SECURITY_ATTRIBUTES sa          = {0};     STARTUPINFO         si          = {0};     PROCESS_INFORMATION pi          = {0};     HANDLE              hPipeOutputRead  = NULL;     HANDLE              hPipeOutputWrite = NULL;     HANDLE              hPipeInputRead   = NULL;     HANDLE              hPipeInputWrite  = NULL;     BOOL                bTest = 0;     DWORD               dwNumberOfBytesRead = 0;     DWORD               dwNumberOfBytesWrite = 0;     CHAR                szMsg[100];     CHAR                szBuffer[256];      sa.nLength = sizeof(sa);     sa.bInheritHandle = TRUE;     sa.lpSecurityDescriptor = NULL;      // Create pipe for standard output redirection.     CreatePipe(&hPipeOutputRead,  // read handle             &hPipeOutputWrite, // write handle             &sa,      // security attributes             0      // number of bytes reserved for pipe - 0 default             );      // Create pipe for standard input redirection.     CreatePipe(&hPipeInputRead,  // read handle             &hPipeInputWrite, // write handle             &sa,      // security attributes             0      // number of bytes reserved for pipe - 0 default             );      // Make child process use hPipeOutputWrite as standard out,     // and make sure it does not show on screen.     si.cb = sizeof(si);     si.dwFlags     = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;     si.wShowWindow = SW_HIDE;     si.hStdInput   = hPipeInputRead;     si.hStdOutput  = hPipeOutputWrite;     si.hStdError   = hPipeOutputWrite;      CreateProcess (           NULL, "cmd.exe",           NULL, NULL,           TRUE, 0,           NULL, NULL,           &si, &pi);      // Now that handles have been inherited, close it to be safe.     // You don't want to read or write to them accidentally.     CloseHandle(hPipeOutputWrite);     CloseHandle(hPipeInputRead);      // Now test to capture DOS application output by reading     // hPipeOutputRead.  Could also write to DOS application     // standard input by writing to hPipeInputWrite.     sprintf(szMsg, "ver\n");     WriteFile(           hPipeInputWrite,      // handle of the write end of our pipe           &szMsg,               // address of buffer that send data           strlen(szMsg),        // number of bytes to write           &dwNumberOfBytesWrite,// address of number of bytes read           NULL                  // non-overlapped.           );      while(TRUE)     {        bTest=ReadFile(           hPipeOutputRead,      // handle of the read end of our pipe           &szBuffer,            // address of buffer that receives data           256,                  // number of bytes to read           &dwNumberOfBytesRead, // address of number of bytes read           NULL                  // non-overlapped.           );        if (!bTest){           sprintf(szMsg, "Error #%d reading pipe.",GetLastError());           printf("%s",szMsg);           break;       }        // do something with data.       szBuffer[dwNumberOfBytesRead] = 0;  // null terminate       printf("%s",szBuffer);       if ('>'==szBuffer[dwNumberOfBytesRead-1]) break;     }      sprintf(szMsg, "chcp\nexit\n");     WriteFile(           hPipeInputWrite,      // handle of the write end of our pipe           &szMsg,               // address of buffer that send data           strlen(szMsg),        // number of bytes to write           &dwNumberOfBytesWrite,// address of number of bytes read           NULL                  // non-overlapped.           );      while(TRUE)     {        bTest=ReadFile(           hPipeOutputRead,      // handle of the read end of our pipe           &szBuffer,            // address of buffer that receives data           256,                  // number of bytes to read           &dwNumberOfBytesRead, // address of number of bytes read           NULL                  // non-overlapped.           );        if (!bTest){           sprintf(szMsg, "Error #%d reading pipe.",GetLastError());           printf("%s",szMsg);           break;       }        // do something with data.       szBuffer[dwNumberOfBytesRead] = 0;  // null terminate       printf("%s",szBuffer);     }      // Wait for CONSPAWN to finish.     WaitForSingleObject (pi.hProcess, INFINITE);      // Close all remaining handles     CloseHandle (pi.hProcess);     CloseHandle (hPipeOutputRead);     CloseHandle (hPipeInputWrite);      return 0; } //C:\test>test //Microsoft Windows [版本 5.2.3790] //(C) 版权所有 1985-2003 Microsoft Corp. // //C:\test>ver // //Microsoft Windows [版本 5.2.3790] // //C:\test>chcp //活动的代码页: 936 // //C:\test>exit //Error #109 reading pipe. //C:\test>

进程间通信方式都能实现吧. 百度:  进程间通信方式

建议参考管道的实现


Question: c语言中，将要释放的指针作为参数传递后，取址载传入另一个函数，再释放有问题吗？

没看出来这么做的必要性 但是这么释放肯定是可以的

你的代码看不出你要表达的逻辑； 申请空间就要释放，不需要去释放同一指针，但是要保留申请时空间的首地址。

代码很乱啊，ppData是什么？cJSON_Delete就是释放内存的函数吗？如果ppData就是x，应该没问题。


Question: 小萌新求解

首先for语句的判断条件肯定是可以为符号的，这里的‘=’ 对应的ascii码是61，你可以理解为‘=’对应的就是整数61.接下来不能进入循环就是你对for循环判断条件的理解不对，条件为真才进入循环，f声明之后没有初始化，f=='=' 不为真故进不了循环的，这就跟你测试结果一直了。 而表达式（I=5）默认就为真，故可以进入到循环。 以上请了解。

建议看一下for循环的3个表达式代表的意思；当第二个条件（判断表达式）为真时才会执行循环体； 变量f，若初始值为'='，则循环体会执行，否则循环体是不会执行的。 还有另外一种办法，就是在循环前，将f的初始值设置为非'='，然后在循环体里对f赋值'='（当然是在需要的时候）。循环判断条件编程 for (l = 0; f != '='; l++)

for循环中的第二个判断语句为真时，才会执行for中的逻辑，你写成f==‘=’不会执行是因为，f不是'='所以，明白了for的执行过程在写逻辑就行了


Question: 新人求教

return  0；

如果是int main()那么最后要有一个返回值也就是return 0; 其次分号不可以加在while后面小括号外面，分号会打断循环，也就是终止。

while ()后不能有;号 且，一般最后一句都要加个return 0;

while后面不加分号，主函数最后一句语句加一个return 0;表示程序正常结束。

如果你输入的k是大于0的数字，那么while循环满足条件，但是会陷入死循环，不会往下执行。

while ()后的;号  造成了死循环，执行不到后面的语句。

引用 2 楼 weixin_40051278 的回复:while ()后不能有;号 且，一般最后一句都要加个return 0; 赞同 while后加分号，那么就相当于while没有循环体。

补图


Question: 新手求教

输入s 用double 定义

引用 1 楼 醉少爷的回复:使用long long数据类型 谢谢，我的不支持long long

引用 楼主 JZhao1998 的回复:#include <stdio.h> int main() { unsigned long int i,n,sum; 	scanf("%d",&n); 	sum=0; 	for(i=1;i<=n;i++) 	{ 		sum=sum+i; 	} 	printf("%d",sum); 	return 0; }  题目要求1  < =  n  < =  1,000,000,000 这样已经超出了范围 ,该怎么办呢 楼主： 个人的几个粗浅的看法：1、unsigned long int（无符号整数型）最大支持整数为4294967295也就是约42个亿，因此，SUM汇总值应该能够放的下；                                              2、printf("%d",sum)中的%d表示一个有符号的整数数值在正负21亿，出错了。如果改成printf("%u",sum)中的%u表示一个无符号的整数数值在42亿结果就正确了；                                              3、double型如全是整数,最多提供15位有效数字。_int64无符号类型支持所有19位及以下的有效数字（c语言支持）。  这个为修改printf("%d",sum)为printf("%u",sum)的运算结果，应该符合要求O(∩_∩)O

引用 6 楼 ciji6985的回复:10亿了，double好像也不够吧？？ double应该够了吧，数量级是十的三十二次方

引用 5 楼 自信男孩的回复:用double是可行的，如果不用double可以考虑大数据的加法运算（数组模拟大数据） 这种还没学，不懂得写。

为什么double可以

10亿了，double好像也不够吧？？

大家，不用了，我已经解决了

使用long long数据类型


Question: 求助，二叉树先序遍历只能遍历左子树，求大神解决！

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


Question: 技术小白发帖求救   望大神解惑

求一个短整型的补码：先输入一个八进制的短整型数，然后调用函数计算出这个数的补码，然后以八进制输出;函数中的语句主要是通过位运算与0100000来取得最高位的值，然后判断最高是位是否为1，如果为1，那补码就等于原码取反加1，否则补码等于原码;

建议查一下&， ～运算符； &是按位与，~是按位取反。都是对于二进制而言的。


Question: 新手报到，看看这有啥问题啊，求助进制转换

int定量整形，输入时应该用%d而不用%f

仅供参考：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> int main() {     int i,v;     char bs[33];     char b[33];     char hs[9];     char h[9];     char s[4];     char *e;  // 十进制整数转二进制串；     i=1024;     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("i=%d,bs=%s\n",i,bs); // 十进制整数转十六进制串；     i=1024;     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("i=%d,hs=%s\n",i,hs); // 十六进制字符串转成十进制数     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     printf("hs=%s,i=%d\n",hs,i); // 二进制字符串转化为十六进制字符串；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     ltoa(i,h,16);     sprintf(hs,"%08s",h);     printf("bs=%s,hs=%s\n",bs,hs); // 二进制字符串转化为十进制数；     strcpy(bs,"00000000000000000000010000000000");     i=strtol(bs,&e,2);     printf("bs=%s,i=%d\n",bs,i); // 十六进制字符串转成二进制串     strcpy(hs,"00000400");     sscanf(hs,"%x",&i);     ltoa(i,b,2);     sprintf(bs,"%032s",b);     printf("hs=%s,bs=%s\n",hs,bs); // ASC\GBK字符串转十六进制串     strcpy(s,"a汉");     i=0;     while (1) {         if (0==s[i]) break;         sprintf(hs+i*2,"%02X",(unsigned char)s[i]);         i++;     }     setlocale(LC_ALL,"chs");     printf("s=%s,hs=%s\n",s,hs); // 十六进制字符串转成汉字（GBK）及字符(ASC)     strcpy(hs,"61BABA");     i=0;     while (1) {         if (1!=sscanf(hs+i*2,"%2x",&v)) break;         s[i]=(char)v;         i++;     }     s[i]=0;     printf("hs=%s,s=%s\n",hs,s);      return 0;  } //i=1024,bs=00000000000000000000010000000000 //i=1024,hs=00000400 //hs=00000400,i=1024 //bs=00000000000000000000010000000000,hs=00000400 //bs=00000000000000000000010000000000,i=1024 //hs=00000400,bs=00000000000000000000010000000000 //s=a汉,hs=61BABA //hs=61BABA,s=a汉

scanf时类型应给是d%

8进制，16进制都是对整型数而言的。 浮点数和整型数在内存里的存储方式是不一样的。所以，浮点数不能用整型数的去输出（八进制和十六进制都是整型数）


Question: c primer plus上一个简单的文件压缩程序

谢谢各位了 问题已解决

引用 8 楼 cfjtaishan 的回复:[quote=引用 3 楼 BlackMitnick 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] 有可能是文件不存在，建议加一条调试语句看一下文件打开失败的原因；  if ((in = fopen(argv[1], "r")) == NULL)     {         fprintf(stderr, "I couldn't open the file \"%s\"\n",                 argv[1]);         fprintf(stderr, " open error: %s\n", strerror(errno));         exit(2);     } 使用strerror(errno)注意，加头文件errno.h 谢谢dalao 我试了一下  I couldn't open the file “eddy” open error No such file or directory 我在那个目录下新建了一个eddy文件呀 麻烦详细解释一下 对于文件输入/输出这一部分实在有点懵[/quote] 这句提示就是没有找到文件，或者文件名不对，或者路径不对[/quote] 谢谢大佬 我弄好了 第一个确实没加txt的原因 第二我发现eddy.txt前面要加路径

引用 3 楼 BlackMitnick 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 有可能是文件不存在，建议加一条调试语句看一下文件打开失败的原因；  if ((in = fopen(argv[1], "r")) == NULL)     {         fprintf(stderr, "I couldn't open the file \"%s\"\n",                 argv[1]);         fprintf(stderr, " open error: %s\n", strerror(errno));         exit(2);     } 使用strerror(errno)注意，加头文件errno.h 谢谢dalao 我试了一下  I couldn't open the file “eddy” open error No such file or directory 我在那个目录下新建了一个eddy文件呀 麻烦详细解释一下 对于文件输入/输出这一部分实在有点懵[/quote] 这句提示就是没有找到文件，或者文件名不对，或者路径不对

引用 5 楼 BlackMitnick 的回复:[quote=引用 4 楼 u010165006 的回复:] 当前目录下没有eddy 这个文件，你可以dir看一下。 呃 我在那个目录下新建了一个eddy.txt文件 还是提示I couldn't open the file “eddy”  但是我如果把argv[1]改成argv[0] 程序成功运行了 生成了一个reducto.exe.red文件 我不知道为什么 麻烦详细解释一下[/quote] 你创建的文件名是eddy.txt，但是你程序里要打开的是eddy，很明显对不上号。

文件名没加后缀吧，是eddy.txt不是eddy

引用 4 楼 u010165006 的回复:当前目录下没有eddy 这个文件，你可以dir看一下。 呃 我在那个目录下新建了一个eddy.txt文件 还是提示I couldn't open the file “eddy”  但是我如果把argv[1]改成argv[0] 程序成功运行了 生成了一个reducto.exe.red文件 我不知道为什么 麻烦详细解释一下

当前目录下没有eddy 这个文件，你可以dir看一下。

引用 1 楼 cfjtaishan 的回复:有可能是文件不存在，建议加一条调试语句看一下文件打开失败的原因；  if ((in = fopen(argv[1], "r")) == NULL)     {         fprintf(stderr, "I couldn't open the file \"%s\"\n",                 argv[1]);         fprintf(stderr, " open error: %s\n", strerror(errno));         exit(2);     } 使用strerror(errno)注意，加头文件errno.h 谢谢dalao 我试了一下  I couldn't open the file “eddy” open error No such file or directory 我在那个目录下新建了一个eddy文件呀 麻烦详细解释一下 对于文件输入/输出这一部分实在有点懵

说明打开文件没有成功，另外命令行中如果文件路径中有空格需要加上引号，你检查下是什么原因


Question: register变量的存储问题

register关键字 是声明变量的存储位置的，与范围无关。  这个关键字现在很少使用了，编译器会处理这个事情，而且即使你应用了这个关键字，在一些场合，编译器依然会“我行我素”的

double表示的范围大约是：1.79769e+308 ~ 2.22507e-308，具体可搜索浮点数内存表示方式  而int可表示的范围只是：2^31-1 ~ -2^31，long long是：2^63-1 ~ -2^63  这与是否为register没有关系

double的范围是多少


Question: makefile里加了个变量，结果编译错误，求解

结贴了。自己搜到了答案：美元符号“$”在Makefile中有特殊的含义，在命令或者文件名中使用“$”时需要用两个美元符号“ 改成了下面这样就行了 SVNREVSTR=$(shell svn info | grep Revision | awk '{print $$2}') TC_CFLAGS+=-DSVNREV=$(SVNREVSTR)  感谢各位的回答！

可能是你的svn不在默认的路径中，带上全路径试一下吧

百度搜“跟我一起写makefile”

引用 2 楼 cfjtaishan 的回复:是不是-D后面应该有一个空格，但你的Makefile里没有这个空格 这儿不需要空格的

引用 1 楼 zhao4zhong1 的回复:百度搜“跟我一起写makefile” 谢谢赵老师。我正在看。不过我这几句makefile还是看不出啥问题啊

是不是-D后面应该有一个空格，但你的Makefile里没有这个空格


Question: 为什么我的结果是正确的但是提交后总是错误？

引用 2楼赵4老师 的回复:边界条件 输入输出格式 ……赵老师是我们学习的榜样

边界条件 输入输出格式 ……

把你的需求贴一下


Question: c语言缓冲区问题，求解

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。

提醒：scanf是开源的。 参考crt\src\input.c

#include<stdio.h> int main(void) {     int a;     char b;     printf("shuzi:");     scanf("%d", &a);           getchar();    /*接收换行符\n*/           printf("zimu:");     scanf("%c",&b);     printf("a = %d, b = %c", a,b);           return 0; }


Question: 多线程并发服务器字符串加密反转，遇quit退出

引用 5 楼 zyl730 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] 多进程的话，参考 Microsoft SDK\samples\winbase\SharedMem\Consumer.Cpp Microsoft SDK\samples\winbase\SharedMem\Makefile Microsoft SDK\samples\winbase\SharedMem\Producer.Cpp Microsoft SDK\samples\winbase\SharedMem\Queue.h Microsoft SDK\samples\winbase\SharedMem\ReadMe.Txt Microsoft SDK\samples\winbase\SharedMem\Common.h不好意思，第一次混论坛，这个是要在哪里查看，不会。。。。[/quote] 搜索下载Microsoft SDK 6

我刚才看了一下.......对不起，我标题写错了，是多进程，很抱歉

仅供参考：//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef _MSC_VER     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef _MSC_VER     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef _MSC_VER void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX; CRITICAL_SECTION cs_BBB; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef _MSC_VER     pthread_exit(NULL); #endif } int main() { #ifdef _MSC_VER     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX);     InitializeCriticalSection(&cs_BBB); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef _MSC_VER     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef _MSC_VER     DeleteCriticalSection(&cs_BBB);     DeleteCriticalSection(&cs_HEX);     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }

你的程序逻辑里没有对遇到quit退出的操作；如果需要建议在我修改的基础加上。

服务器，注意对端发来的数据num是实际数据的长度，所以对于字符串结束标记加的位置应该为recvbuf[num] = 0; #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h>  #define PORT 1234 #define BACKLOG 5 #define MAXDATASIZE 1024 #define MAXNAMESIZE 64  void process_cli(int  connfd, struct sockaddr_in client);  int main() {     int  listenfd, connfd;     pid_t  pid;     struct  sockaddr_in  server;     struct sockaddr_in  client;     int  len;      if ((listenfd =socket(AF_INET, SOCK_STREAM, 0)) == -1)     {         perror("Creatingsocket failed.");         exit(1);     }      int opt =SO_REUSEADDR;     setsockopt(listenfd,SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));     bzero(&server,sizeof(server));     server.sin_family=AF_INET;     server.sin_port=htons(PORT);     server.sin_addr.s_addr= htonl (INADDR_ANY);     if (bind(listenfd,(struct sockaddr *)&server, sizeof(server)) == -1)     {         perror("Bind()error.");         exit(1);     }      if(listen(listenfd,BACKLOG)== -1)     {         perror("listen() error\n");         exit(1);     }     len=sizeof(client);     while(1)     {         if ((connfd =accept(listenfd,(struct sockaddr *)&client, (socklen_t *)&len))==-1) {             perror("accept() error\n");             exit(1);         }         if ((pid = fork())>0){             close(connfd);             //continue;         }         else if (pid==0) {             close(listenfd);             process_cli(connfd, client);             exit(0);         }         else         {             printf("fork()error\n");             exit(0);         }     }     close(listenfd); }  void process_cli(int connfd, struct sockaddr_in client) {     int num;     char  recvbuf[MAXDATASIZE], sendbuf[MAXDATASIZE], cli_name[MAXNAMESIZE];     printf("Yougot a connection from %s. ",inet_ntoa(client.sin_addr) );     num = recv(connfd,cli_name, MAXDATASIZE,0);     if (num == 0)     {         close(connfd);         printf("Client disconnected.\n");         return;     }     printf("num = %d\n", num);     cli_name[num] = '\0';     printf("Client's name is %s.\n", cli_name);      while ((num = recv(connfd, recvbuf, MAXDATASIZE, 0)) > 0)     {         recvbuf[num] = '\0';         printf("Receivedclient( %s ) message: %s\n", cli_name, recvbuf);         int i = 0;          for (i = 0; i < num; ++i)             sendbuf[i] = recvbuf[num - i - 1];          sendbuf[num] = '\0';    /* 若send中不用strlen(sendbuf)则这句是多余的*/         send(connfd, sendbuf, num, 0);         usleep(5000);   /*保证客户端分两次获取*/         for (i = 0;i < num; i++)         {             if((recvbuf[i]>='a' && recvbuf[i]<='z')||(recvbuf[i]>='A'&&recvbuf[i]<='Z'))             {                 recvbuf[i] += 4;   /*简单表达式*/                 if((recvbuf[i] > 'Z' && recvbuf[i] <= 'Z' + 4)||(recvbuf[i] > 'z'))                     recvbuf[i] = recvbuf[i]- 26;             }             sendbuf[i] = recvbuf[i];         }         sendbuf[num] = '\0';   /*这句不能少，因为下面send用到了strlen*/         send(connfd, sendbuf, strlen(sendbuf),0);      }     close(connfd); }    客户端；注意fgets会将回车符加入到缓存里； #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h>  #define PORT 1234 #define MAXDATASIZE 1024  void process(FILE*fp, int sockfd); char *getMessage(char* sendline,int len, FILE* fp);  int main(int argc,char *argv[]) {     int fd;     struct hostent  *he;     struct sockaddr_in  server;      if (argc !=2) {         printf("Usage:%s <IP Address>\n",argv[0]);         exit(1);     }      if((he=gethostbyname(argv[1]))==NULL)     {         printf("gethostbyname() error\n");         exit(1);     }     if((fd=socket(AF_INET, SOCK_STREAM, 0))==-1)     {         printf("socket()error\n");         exit(1);     }      bzero(&server,sizeof(server));     server.sin_family =AF_INET;     server.sin_port=htons(PORT);     server.sin_addr= *((struct in_addr *)he->h_addr);      if(connect(fd,(struct sockaddr *)&server,sizeof(server))==-1)     {         printf("connect() error\n");         exit(1);     }      process(stdin,fd);      close(fd);      return 0; }  void process(FILE *fp, int  sockfd) {     char sendline[MAXDATASIZE],recvline[MAXDATASIZE];     int num;      printf("Connected to server. \n");     printf("Input client's name : ");     if (fgets(sendline, MAXDATASIZE, fp) == NULL)     {         printf("\nExit.\n");         return;     }     sendline[strlen(sendline)-1] = 0;    /* delete '\n' */     send(sockfd,sendline, strlen(sendline), 0);     while(getMessage(sendline, MAXDATASIZE, fp) != NULL)     {         sendline[strlen(sendline)-1] = 0;    /* delete '\n' */         send(sockfd, sendline, strlen(sendline), 0);         //send(sockfd, sendline, num-1,0);         int i = 2;         while (i--) {    /* 第二次接收的是加密后的*/             if ((num = recv(sockfd, recvline, MAXDATASIZE,0)) == 0) {                 printf("Server terminated.\n");                 return;             }             recvline[num] = '\0';             if (i == 0)                 printf("Recv encrpt string from server: \n");             printf("server string return  :%s\n", recvline);             printf("Server Message: %s\n",recvline);         }     }     printf("\nExit.\n"); }  char  *getMessage(char*  sendline,int len, FILE*  fp) {     printf("Inputstring to server:");     return(fgets(sendline,MAXDATASIZE, fp)); }  参考一下吧。代码里也有其他问题，我不一一罗列。建议楼主拷贝到本地测试跑跑，和自己的代码对比一下（我在楼主的基础上修改的），消化一下多进程的socket编程；

引用 4 楼 zhao4zhong1 的回复:多进程的话，参考 Microsoft SDK\samples\winbase\SharedMem\Consumer.Cpp Microsoft SDK\samples\winbase\SharedMem\Makefile Microsoft SDK\samples\winbase\SharedMem\Producer.Cpp Microsoft SDK\samples\winbase\SharedMem\Queue.h Microsoft SDK\samples\winbase\SharedMem\ReadMe.Txt Microsoft SDK\samples\winbase\SharedMem\Common.h不好意思，第一次混论坛，这个是要在哪里查看，不会。。。。

引用 1 楼 zhao4zhong1 的回复://循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印我刚才看了一下.......对不起，我标题写错了，是多进程，很抱歉


Question: 一种输出正确，一种却错了，求指导

个人建议，对于系统库头文件的引用使用<>，对于自定义头文件使用""

#include <stdio.h> #include <stdlib.h>  int main() {     system("color f0");     int j = 0;     char ch[100], tran[100];     printf("input ciper code:");     gets(ch);     printf("ciper code:%s\n",ch);     while (ch[j] != '\0')     {         if (ch[j] >= 'A'&& ch[j] <= 'Z')             tran[j] = 155 - ch[j];         else if (ch[j] >= 'a' && ch[j] <= 'z')             tran[j] = 219 - ch[j];         else             tran[j] = ch[j];         j++;     }     tran[j] = 0;    /*'\0' 字符串结束标记*/     printf("original text:");     puts(tran);     system("pause");     return 0; } 第一个程序是puts，需要的参数是字符串，但是tran缺少字符串结束标记，所以应该加上，这样就一样了。

谢谢指导和提醒，是要加上tran[ j ]=' \0 '表示字符串结束。


Question: 入门级选手，求教

a除b 或者b除a 有一个结果是整数

引用 2 楼 cfjtaishan 的回复:#include<stdio.h> #include <stdbool.h>  bool check_denominator(int n) {     if(1 == n)         return false;     else if(0 == n % 2)         return check_denominator(n/2);     else if(0 == n % 5)         return check_denominator(n/5);     else         return true; }  int greatest_common_divisor(int a, int b) {     int common = b % a;     while (common != 0) {         b = a;         a = common;         common = b % a;     }     return a; }   int main(){      int a, b, n, ret = 1;     int common;      scanf("%d", &n);     while (n--) {         ret = scanf("%d%d", &a, &b);         common = greatest_common_divisor(a, b);         if (false == check_denominator(b/common))             printf("Yes\n");         else if(true == check_denominator(b/common))             printf("No\n");     }     return 0; } 分母只含有2或5的任意次方或者2与5结合的整数的分数都能化成有限小数 除此之外的分数都能化成无限循环小数 遇到问题，还是建议楼主多动手，多去查查资料。 遇到问题就直接请别人帮忙反而不好。请人帮忙是解决问题的一种方法，但是不是首选的，或者第一步做的。而应该是最后一步做的，前面的应该是自己在努力想办法解决问题。 谢谢你了，我自己也想了，但是没有头绪，所以来这里问你们

引用 3 楼 zhao4zhong1 的回复: 谢谢你，其实我自己也想了好久，我找的资料说，例如m/n得来的小数，如果小数点后面位数大于n为则为无限小数，所以我就想来这里问问人


Question: STM32  ZIgbee  问题

百度搜相关关键字。

自己顶 ~~~~~

帮顶 ！！！ 有没有人呀！

不知道AT命令怎么发送 能否告知一下！


Question: 双向链表的查找

Position Locate(DList L,ElemType x) {     Position p = L->head;      while (p && p != L->tail) {         if (x == p->data)             return p;         p = p->next;     }      return NULL; }

仅供参考：//不带表头结点的双向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next;     struct NODE *prev; } *head,*p,*q,*s,*p1,*p2,*q1,**ta; int i,k,n,t,m,v,N=10; int main() {     setlocale(LC_ALL,"chs");     srand(time(NULL));      head=NULL;      printf("创建%d个节点的双向链表:",N);//创建N个节点的双向链表     p=head;     for (i=0;i<N;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) exit(1);         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         q->prev=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             q->prev=p;             p=q;         }     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;     }      k=3;     v=5;     printf("将值为%d的结点插入到双向链表的第%d个结点前:",v,k);//将值为v的结点插入到双向链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=v;             q->next=head;             q->prev=NULL;             head->prev=q;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=v;                 q->next=p->next;                 q->prev=p;                 p->next->prev=q;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;     }      k=5;     printf("删除第%d个节点:",k);//删除第k个节点     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=head;             head=head->next;             head->prev=NULL;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     if (q->next) q->next->prev=p;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;     }      printf("从小到大排序:");//从小到大排序     for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {         for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {             if (p->data > q->data) {                  //交换data //              printf("swap %02d %02d\n",p->data,q->data); //              t=p->data;p->data=q->data;q->data=t;                  //或者                  //交换prev和next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         head->prev=NULL;                         p->next=q->next;                         p->prev=q;                         if (q->next) q->next->prev=p;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         head->prev=NULL;                         p2=p->next;                         p->next=q->next;                         p->prev=q->prev;                         if (q->next) q->next->prev=p;                         q->next=p2;                         p2->prev=q;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         p->prev=q;                         if (q->next) q->next->prev=p;                         q->next=p;                         q->prev=p1;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         p->prev=q->prev;                         if (q->next) q->next->prev=p;                         q->next=p2;                         p2->prev=q;                         q->prev=p1;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个双向链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d<->",s->data); //                  if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;} //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个双向链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         n++;         s=s->next;     }      printf("将整个链表逆序:");//将整个链表逆序     if (n>=2) {         p=head;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p->prev=q;             p=q;             q=q1;             if (NULL==q) break;         }         head=p;         head->prev=NULL;     }      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;     }      m=4;     n=6;     printf("将双向链表中前%d个结点和后%d个结点进行互换:",m,n);//将双向链表中前m个结点和后n个结点进行互换,m+n为链表总长     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m==k) {             q=p;         }         s=p;         p=p->next;     }     q1=head;     head=q->next;     head->prev=NULL;     s->next=q1;     q1->prev=s;     q->next=NULL;      //输出整个双向链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d<->",s->data);         if (NULL!=s->next && s->next->prev!=s) {printf(" !\n");break;}         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的双向链表:93<->03<->60<->05<->57<->71<->02<->41<->26<->85<-> //将值为5的结点插入到双向链表的第3个结点前:93<->03<->05<->60<->05<->57<->71<->02<->41<->26<->85<-> //删除第5个节点:93<->03<->05<->60<->57<->71<->02<->41<->26<->85<-> //从小到大排序:02<->03<->05<->26<->41<->57<->60<->71<->85<->93<-> //将整个链表逆序:93<->85<->71<->60<->57<->41<->26<->05<->03<->02<-> //将双向链表中前4个结点和后6个结点进行互换:57<->41<->26<->05<->03<->02<->93<->85<->71<->60<-> //


Question: fopen 返回 NULL，请问怎样解决？

引用 6 楼 paschen 的回复:可能被系统重定位了，32位程序在64位系统上运行时，系统默认会对文件、注册表进行重定位，相关内容可以在MSDN上搜索，你程序实际可能定位到了：SysWOW64目录 64 位 Windows 平台注意点之文件系统重定向 http://www.cnblogs.com/jiake/p/4981555.html

关闭UAC、防火墙、杀毒软件、…… 用管理员身份运行

建议查看一下返回原因，使用strerror(errno)查看是什么原因导致的NULL，   引用 3 楼 jaklsdkfjosfij 的回复:但是这个文件确实是存在的啊。 2017-10-16 15:16:28.443 Error   ():<Util.cpp  310> ComputFileMd5(fopen C:\WINDOWS\system32\PBOC_LIB.dll failed!)  文件名对不上吧。

GetLastError 返回2，什么原因？

getlasterror()，判断一下错误原因 估计是权限问题！


Question: 如何打印出一个结构体数组中的二位字符串数组组员中的一个元素？

引用 5 楼 hzy_76 的回复:另外，习惯上都把UNIT8定义为unsigned short，char是1字节，应给是UNIT4才对。 注意不要误导人. UINT8 中的8是指bit数, 也就是8bit的无符号整型, 正好占一字节.  一般都是unsigned char 对应也有UINT16  === unsigned short UINT32  UINT64

好像初始化的时候就错了。初始化结构体应该是用常量去初始化，但是我在那个结构体数组中却用了两个变量。是不是这样呢？

引用 10 楼 hzy_76 的回复:不好意思，刚才思维混乱了，UNIT8没错。但是你这个定义还是有问题吧：   UINT8 *hubei_province[][6] = {     {"Wuhan",     "Jiangan",    "Jianghan"  },     {"Xiangyang", "Xiangcheng", "Fancheng"  },     {"Yichang",   "Xiling",     "Wujiagang" }, };  三维数组？6是每个字符串长度？ 第一个[]是行吧，第二[]不是列吗？6表示一个数组中最多有6个字符串。

引用 7 楼 cfjtaishan 的回复:typedef struct _AREA_SUBAREA_ {     ABV_EAD_UInt8* area;     ABV_EAD_UInt8* sub_area;   }AREA_SUBAREA;   类型不匹配呢，sub_area和hubei_province类型不匹配。怎么直接赋值呢？ 里面的一些类型都是unsigned char类型的。如果是UINT8**的话，改如何打印呢？

引用 7 楼 cfjtaishan 的回复:typedef struct _AREA_SUBAREA_ {     ABV_EAD_UInt8* area;     ABV_EAD_UInt8* sub_area;   }AREA_SUBAREA;   类型不匹配呢，sub_area和hubei_province类型不匹配。怎么直接赋值呢？  哦，对对，应该是UINT8**吧，之前写的是UINT8**，改来改去掉了个*号。

引用 4 楼 hzy_76 的回复:还是没看懂，那你这二维数组的定义怎么设计的？比如hubei_province，按unsigned char的思路，这样保存不了二维字符串数组，只能保存字符串数组。 我用的编译器char类型带符号的，一个char类型的可能占用16位，所以加了个unsigned去掉符号位，就是8位了。  hubei_province这个如果不这样写，该怎么写？这样应该没问题吧。UINT8* 的一个二维指针数组，里面每一个元素都是一个指针。应该没问题啊

说明一下，UINT8是unsigned char类型

引用 1 楼 hzy_76 的回复:UINT8是unsigned short？你用来保存字符串？好像从定义就开始错了嘛！ UINT8是unsigned char


Question: iostrom.h的头文件找不到该怎么办

iostream.h是老的C++头文件，标准以后的是 #include <iostream>  using namespace std;

iostrom.h也许是iostream.h？

关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”


Question: C语言链表输出少一个数据怎么办

谢谢各位！已解决

对于系统库文件，建议用<>，对于自定义头文件，建议用""

少一个的原因是创建的时候就少创建一个，最后输入的节点其实并没有加入链表；只需要将最后输入的节点加入链表即可：如下， //#include"stdafx.h" #include <stdio.h> #include <stdlib.h> //#include "malloc.h"  #define LEN sizeof(struct student)   /* 注意单词的大小写*/  struct student {     int num;     int score;     struct student *next; };  int n;  struct student *creat(void) {     struct student *ptr,*p1,*p2;     int t;     printf("please input number of students:\n");     scanf("%d", &t);     printf("please input student data:\n");     p1 = p2 = (struct student *)malloc(sizeof(struct student));     scanf("%d,%d", &p1->num,&p1->score);     ptr = NULL;     t = t-1;     n = 0;     do {         n = n + 1;         if(n==1)             ptr = p1;         else             p2->next=p1;         p2=p1;         p1 = (struct student *)malloc(sizeof(struct student));         scanf("%d,%d", &p1->num,&p1->score);     }while(n < t);     /*将最后一个节点加入链表*/     p2->next = p1;     p1->next = NULL;     //p2->next=NULL;     printf("\n");     return(ptr); }      int main() {     struct student *ptr, *phead;     int i = 1;     phead = creat();     printf("please output linklist data:\n");     ptr = phead;     while(ptr)     {         printf("student%d:num=%d,score=%d\n",i++,ptr->num,ptr->score);         ptr = ptr->next;     }     return 0; }

在自己觉得有问题的地方, 用printf将存疑的变量打印输出,  直到发现问题

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

不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。   “多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，掰手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？


Question: 各位看看我编的代码，为啥就不能动呢？？？

路过

引用 1 楼 zhang_hao1949 的回复:while(1)这个语句后面多了和个分号 支持，写的时候建议细心些。

while(1)这个语句后面多了和个分号


Question: 请问有哪里有gcc的官方论坛？

tolower

百度搜相关关键字。

gcc有官网，但是支持方式应该是邮件列表，没有论坛。 即使是邮件列表，也不会解决这样的问题的。  貌似strlwr不是标准函数吧。

引用 2 楼 xsklld 的回复:strlwr是什么？没听过这个函数。 这是将大写字母转换成小写字母的函数，在string.h里。

引用 1 楼 zhao4zhong1 的回复:百度搜相关关键字。 您好赵老师，只能找到一个gcc的官方网站gcc.gnu.org，仔细看了一下，里面好像没有forum字眼，但是有一个gcc-help@gcc.gnu.org邮件地址，我发信过去，但是遭退信了。还有百度的gcc吧，很冷清。

strlwr是什么？没听过这个函数。


Question: 用int a[3][3],和int a[3][3]={0}为什么结果会不一样

a和b是scanf输入赋值，不初始化也没事。c没有初始化。里面是垃圾值，不是0

a和b数组可以不初始化，但是c数组必须要初始化。数组不初始化就是随机值，随机值加上a和b的值，就是不确定了。 a和b数组从终端输入，即使不初始化，是随机值，但是会被终端输入的数据覆盖。

2楼   +1

若若的说一句不管你怎么换都行，不会影响结果！只要你的输入正确就行了！你的a，b数组都是有赋值操作的；我刚刚试了你说的问题，int a[3][3];与int a[3][3]={0}是一样的输出。

局部动态变量要赋值，否则为随机数

应该是没有初始化。单步运行一下看一下拿到的都是什么值

2楼   +2

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

c数据 += 要赋初值吧


Question: 判断是否为回文字符

引用 1 楼 qq_38204686 的回复:我不认为这个程序可以实现判断回文 是的，我有些地方错误较多，重新改正了下。 #include<stdio.h> #include<string.h> #define N 100 main() {     char ch[N];     gets(ch);     int len=strlen(ch),i,j;     printf("请输入一串字符:\n");          for(i=0,j=len-1;i<=j;i++,j--)         {             if(ch[i]==ch[j])             printf("是回文数\n");             else             printf("不是回文数\n");             break;              //为什么这里if语句判断与常识相反，第一个元素与最后一个比较不相等时，应该判定为不是回文，但是那样写却会判定为是回文，如果颠倒就会判定正确！这是为什么？？？//          } } 这是正确的！ 更多 0

我不认为这个程序可以实现判断回文


Question: C语言 循环结构卡住问题

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

单精度浮点数(float)总共用32位来表示浮点数，其中尾数用23位存储，加上小数点前有一位隐藏的1(IEEE754规约数表示法)，2^(23+1) = 16777216。因为 10^7 < 16777216 < 10^8，所以说单精度浮点数的有效位数是7位。考虑到第7位可能的四舍五入问题，所以单精度最少有6位有效数字（最小尺寸）。  #include <stdio.h> int main() {     float a=1,password;     printf("输入你的数字:\n");     scanf("%f",&password);     printf("%f\n", password);     while(a<password) {         printf("%f\n", a);         a=a+1;     }     printf("\n\n我猜数字是:%.0f\n",a);      return 0; } a增加到16777216已经不增加了。其实就是到最大值了。建议用double类型定义a

你的数据是while 叠加，应该是溢出了


Question: 老谭的C语言 算利息的问题 小白求教

这是浮点数精度的问题，float精度是小数点后6位，double类型比float精度长

float的能保证的精度也就是6位


Question: 关于C4996警告怎么处理？

谢谢各位！！！！！！！！！

看你的代码上面没有加啊。

引用 4 楼 ckc 的回复:我都是在最前面加上 #pragma warning(disable:4996) 支持

在安装路径中加入那句话 我的在C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcprojectitems

我都是在最前面加上 #pragma warning(disable:4996)

必须要加入英文符号的分号，不知道你加了没有？

引用 7 楼 zhao4zhong1 的回复:[quote=引用 4 楼 ckc 的回复:] 我都是在最前面加上 #pragma warning(disable:4996) [/quote]

因为这个函数是不安全，可能造成缓冲区溢出，所以现在建议用scanf_s来代替如果仍想用可以选择以下任何一种方法： 1、新建项目时不要勾选安全开发生命周期检查 2、在项目属性的C/C++命令行中加上 /D _CRT_SECURE_NO_WARNINGS


Question: 在写代码的时候出现这样的问题 不知道哪里错了

定义指针的时候顺带赋值NULL。

# include <stdio.h> # include <stdlib.h> # include <string.h>  typedef struct student {     char name[32];     float score;     struct student *next; }STU;  STU *myCreatelist(STU *head) {     STU *q,*p;     char temp[10];     int flag=1;     float t=0;     head=(STU*)malloc(sizeof(STU));     head->next = NULL;     q=head;     while(flag)     {         p = (STU*)malloc(sizeof (STU));         p->next = NULL;         printf("input name\n");         scanf("%s", temp);         printf("input score\n");         strcpy(p->name,temp);         scanf("%f", &t);         p->score = t;         q->next=p;         q = p;         printf("inpuut flag\n");         scanf("%d",&flag);     }     p=head->next;     while(p)     {         printf("name is :%s\n",p->name);         printf("score is :%.2f\n",p->score);         p=p->next;     }     printf("\n");     return head; } int main () {     STU *head = NULL,*p,*q;     head = myCreatelist(head);     q = head->next;     while (q)     {         if(!strcmp (q->name,"x6")) {             p=q->next;             q->next=p;             break;         } else {             q = q->next;         }     }     p = head->next;     while (p)     {         printf("name is :%s\n",p->name);         printf("score is :%f\n",p->score);         p = p->next;     }      return 0; } 结构体定义有问题，name定义的长度太短，只要输入一个字符就会导致溢出，score若是一个成绩，建议定义成变量而非数组。

《C++Primer第四版中文版》中提到 除了使用数值 0 或在编译时值为 0 的 const 量外，还可以使用 C++ 语言从 C 语言中继承下来的预处理器变量 NULL，该变量在 cstdlib头文件中定义，其值为 0。如果在代码中使用了这个预处理器变量，则编译时会自动被数值 0 替换。因此，把指针初始化为 NULL 等效于初始化为 0 值： // cstdlib #defines NULL to 0 STU *head = NULL; // ok: equivalent to int *pi = 0;

引用 1 楼 赵4老师的回复:局部变量head没赋初值就用 可是指针如何附初值，设为全局变量吗

局部变量head没赋初值就用


Question: 定义pow函数,编译出错。

引用 13 楼 jiht594 的回复:先把多余的main删了， 看看你的错误行号。 5、11、3、19  代码一行一行写。 错误太多就把代码都删掉。 写一行、编译一次。 好

关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”

引用 5 楼 SoFii 的回复:第7行最后一个逗号是中文的。。。我把所有符号都换了。还是不行~

引用 10 楼 qq_40158211 的回复:#include <stdio.h> double power(double x, double y); void main(void) { 	double x = 3.0, y = 3.0, z; 	z = power(x, y); 	printf("%.1f to the power of %.1f is %.1f\n", x, y, z); } double power(double x, double y) { 	double z = 1; 	while (y) 	{ 		z *= x; 		y--; 	} 	return z; }                           //   第7行y后面   改英文逗号 3.0 to the power of 3.0 is 27.0 请按任意键继续. . .

对于double类型，不能直接while(y)，建议使用while (fabs(y - 0.0) < 1e-6) 另外，double数据输出，要用%lf，而不能用%f。

#include <stdio.h> double power(double x, double y); void main(void) { 	double x = 3.0, y = 3.0, z; 	z = power(x, y); 	printf("%.1f to the power of %.1f is %.1f\n", x, y,z); } double power(double x, double y) { 	double z = 1; 	while (y) 	{ 		z *= x; 		y--; 	} 	return z; } 虽然这么改就可以输出答案！但我还是要说的是，你这个逻辑还是有问题的哟！如果你输入的x，y是真的浮点数怎么办哟！

贴上你的报错；看了下语法没问题，有可能是楼上说的中文标点符号的问题

第7行最后一个逗号是中文的。。。

int main(); 说实话，计算机科学只能算工科

<img src="https://img-bbs.csdn.net/upload/201710/15/1508045216_181093.png" alt="">

一个main和两个main都是不行。

也许是因为你有两个main函数？


Question: C语言执行的时候停止工作问题

仅供参考：//链表实现一元多项式的加法减法乘法 #include <stdio.h> #include <stdlib.h> typedef struct node {     float coef;   //系数     int expn;     //指数     struct node *next; } PolyNode;      //多项式节点 polynomial node typedef PolyNode* Polynomial; Polynomial createPolynomial() {  //创建多项式     PolyNode *p, *q, *head = (PolyNode *)malloc(sizeof(PolyNode));   //头节点     head->next = NULL;     float coef;     int expn;     printf("输入该多项式每一项的系数和指数，每项一行，输入0 0结束！\n");     while (scanf("%f %d", &coef, &expn) && coef) {   // 默认，按指数递减排列         if (head->next) {             p = head;             while (p->next && expn < p->next->expn)                 p = p->next;             if (p->next) {                 if (expn == p->next->expn) { //有相同指数的直接把系数加到原多项式                     p->next->coef += coef;                     if (p->next->coef > -0.000001 && p->next->coef < 0.000001) { //若是相加后系数为0，则舍弃该节点                         q = p->next;                         p->next = q->next;                         free(q);                     }                 } else {                     q = (PolyNode*)malloc(sizeof(PolyNode));                     q->coef = coef;                     q->expn = expn;                     q->next = p->next;                     p->next = q;                 }             } else {                 p->next = (PolyNode*)malloc(sizeof(PolyNode));                 p = p->next;                 p->coef = coef;                 p->expn = expn;                 p->next = NULL;             }         } else {             head->next = (PolyNode*)malloc(sizeof(PolyNode));             head->next->coef = coef;             head->next->expn = expn;             head->next->next = NULL;         }     }     return head; } Polynomial multiply(Polynomial poly, float coef, int expn) {  //多项式与指定单项式相乘，该单项式为 coefx^expn     PolyNode *p, *q, *Poly = (PolyNode*)malloc(sizeof(PolyNode));     p = Poly;     q = poly->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = (q->coef*coef);         p->expn = (q->expn + expn);         q = q->next;     }     p->next = NULL;     return Poly; } void add(Polynomial poly1, Polynomial poly2) {  //把 poly2 加到 poly1 上     PolyNode *p, *q, *r;     r = poly1;     p = poly1->next;  //指向第一个节点     q = poly2->next;     poly2->next = NULL;     while (p && q) {         if (p->expn > q->expn) {             r->next = p;             p = p->next;             r = r->next;         } else if (p->expn < q->expn) {             r->next = q;             q = q->next;             r = r->next;         } else {             PolyNode *t;             p->coef += q->coef;             if (!(p->coef > -0.000001 && p->coef < 0.000001)) //系数不为0             {                 r->next = p;                 r = r->next;                 p = p->next;             } else {                 t = p;                 p = p->next;                 free(t);             }             t = q;             q = q->next;             free(t);         }     }     if (p)         r->next = p;     if (q)         r->next = q; } Polynomial polySubtract(Polynomial poly1, Polynomial poly2) {  //多项式减法 poly1-poly2形成一个新的多项式     //把poly2的系数取相反数，形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode)); //构造头节点     PolyNode *p, *q;     p = poly;     q = poly2->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = -(q->coef);  //系数取反         p->expn = q->expn;         q = q->next;     }     p->next = NULL;     add(poly, poly1);  //利用加法     return poly; } Polynomial polyAdd(Polynomial poly1, Polynomial poly2) { //多项式相加 poly1+poly2形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //和多项式的头节点     poly->next = NULL;     PolyNode *p, *q, *r;     r = poly;     p = poly1->next;     q = poly2->next;     while (p&&q) {         if (p->expn > q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = p->coef;             r->expn = p->expn;             p = p->next;         } else if (p->expn < q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = q->coef;             r->expn = q->expn;             q = q->next;         } else {             float m = p->coef + q->coef;             if (!(m > -0.000001 && m < 0.000001)) {                 r->next = (PolyNode*)malloc(sizeof(PolyNode));                 r = r->next;                 r->coef = m;                 r->expn = p->expn;             }             q = q->next;             p = p->next;         }     }     while (p) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = p->coef;         r->expn = p->expn;         p = p->next;     }     while (q) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = q->coef;         r->expn = q->expn;         q = q->next;     }     r->next = NULL;     return poly; } Polynomial polyMultiply(Polynomial poly1, Polynomial poly2) {  //多项式相乘     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //创建多项式和的头节点     poly->next = NULL;     PolyNode *p;     p = poly2->next;     while (p) {         add(poly, multiply(poly1, p->coef, p->expn));         p = p->next;     }     return poly; } void printPoly(Polynomial poly) {  //打印多项式     if (poly && poly->next) {         PolyNode *p = poly->next;  //p指向第一个节点         while (p->next) {             printf("%gx^%d", p->coef, p->expn);             p = p->next;             if (p && (p->coef > 0))                 printf("+");         }         if (p->expn == 0)             printf("%g", p->coef);   //打印常数项         else             printf("%gx^%d", p->coef, p->expn);         printf("\n");     } } void freePoly(Polynomial poly) {  //释放内存     if (poly && poly->next) {         PolyNode *p, *q;         p = poly;         while (p) {             q = p->next;             free(p);             p = q;         }     }     poly = NULL; } int main() {     printf("用链表实现多项式的加减法\n");     Polynomial poly1, poly2, poly3;     printf("创建多项式一\n");     poly1 = createPolynomial();     printf("多项式一：\n");     printPoly(poly1);     printf("创建多项式二\n");     poly2 = createPolynomial();     printf("多项式二：\n");     printPoly(poly2);     printf("两多项式相加，和为：\n");     poly3 = polyAdd(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两个多项式相乘，积为：\n");     poly3 = polyMultiply(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两多项式相减，差为：\n");     poly3 = polySubtract(poly1, poly2);     printPoly(poly3);     freePoly(poly1);     freePoly(poly2);     freePoly(poly3);     system("pause");     return 0; }

#include <stdio.h> #include <stdlib.h> #include <malloc.h>  typedef struct TNode{     int data1;     int data2;     struct TNode *next; }node,*pnode;  pnode CreateList(int n); pnode ComList(pnode A,pnode B); void Dayin();  void Dayin(pnode A) {     node *p;     p = A->next;     while(p){         printf("%dx^%d\t",p->data1,p->data2);         p = p->next;     }     putchar(10); }   pnode CreateList(int n) {     int i;     node *L;     node *p;     L=(struct TNode*) malloc (sizeof(node));     L->next = NULL;     for(i = 1;i <= n;i++){         p=(struct TNode*) malloc (sizeof(node));         printf("请输入第%d的系数",n+1-i);         scanf("%d",&p->data1);         printf("请输入第%d的指数",n+1-i);         scanf("%d",&p->data2);         p->next = L->next;         L->next = p;     }     return L; } pnode ComList(pnode A,pnode B) {     int x;     node *L3;     node *rc;     node *p1;     node *p2;     node *u;     p1 = A->next;     p2 = B->next;     L3 = A;     rc = L3;     while(p1 && p2){         if(p1->data2 == p2->data2){             x= p1->data1 + p2->data1;             if(x!=0) {                 p1->data1 = x;                 rc->next = p1;                 rc = rc->next;                 p1 = p1->next;                 p2 = p2->next;             }         } else if (p1->data2 > p2->data2) {             p2 = p2->next;         } else {             p1 = p1->next;         }     }      while (p1) {         rc->next = p1;         p1 = p1->next;     }     while (p2) {         rc->next = p2;         p2 = p2->next;     }      return L3;  } int main() {     int n1,n2;     node *L1;     node *L2;     printf("请输入第一个多项式项数");     scanf("%d",&n1);     L1 = CreateList(n1);     Dayin(L1);     printf("请输入第二个多项式项数");     scanf("%d",&n2);     L2 = CreateList(n2);     Dayin(L2);     pnode L3 = ComList(L1,L2);     printf("After combine: \n");     Dayin(L3);     return 0; }  comList的逻辑有问题，详见上面的代码； 另外，建议加上对链表的释放。

引用 3 楼 cfjtaishan 的回复:#include <stdio.h> #include <stdlib.h> #include <malloc.h>  typedef struct TNode{     int data1;     int data2;     struct TNode *next; }node,*pnode;  pnode CreateList(int n); pnode ComList(pnode A,pnode B); void Dayin();  void Dayin(pnode A) {     node *p;     p = A->next;     while(p){         printf("%dx^%d\t",p->data1,p->data2);         p = p->next;     }     putchar(10); }   pnode CreateList(int n) {     int i;     node *L;     node *p;     L=(struct TNode*) malloc (sizeof(node));     L->next = NULL;     for(i = 1;i <= n;i++){         p=(struct TNode*) malloc (sizeof(node));         printf("请输入第%d的系数",n+1-i);         scanf("%d",&p->data1);         printf("请输入第%d的指数",n+1-i);         scanf("%d",&p->data2);         p->next = L->next;         L->next = p;     }     return L; } pnode ComList(pnode A,pnode B) {     int x;     node *L3;     node *rc;     node *p1;     node *p2;     node *u;     p1 = A->next;     p2 = B->next;     L3 = A;     rc = L3;     while(p1 && p2){         if(p1->data2 == p2->data2){             x= p1->data1 + p2->data1;             if(x!=0) {                 p1->data1 = x;                 rc->next = p1;                 rc = rc->next;                 p1 = p1->next;                 p2 = p2->next;             }         } else if (p1->data2 > p2->data2) {             p2 = p2->next;//我这里改成了rc->next=p2;rc=p2;p2=p2->next         } else {             p1 = p1->next;//我这里改成了rc->next=p1;rc=p1;p1=p1->next         }     }      while (p1) {         rc->next = p1;         p1 = p1->next;[     }     while (p2) {         rc->next = p2;         p2 = p2->next;     }      return L3;  } int main() {     int n1,n2;     node *L1;     node *L2;     printf("请输入第一个多项式项数");     scanf("%d",&n1);     L1 = CreateList(n1);     Dayin(L1);     printf("请输入第二个多项式项数");     scanf("%d",&n2);     L2 = CreateList(n2);     Dayin(L2);     pnode L3 = ComList(L1,L2);     printf("After combine: \n");     Dayin(L3);     return 0; }  comList的逻辑有问题，详见上面的代码； 另外，建议加上对链表的释放。  哥，我按照你的改了一下才能正确的实现相加，，，然后，我还想问问，为什么要加ELSE 才能不出错，不加else  就报内存出错，就是我原来的代码 VS上说 0X00881731处有未经处理的异常：0XC0000005，读取位置0X0000004时发生访问冲突

引用 5 楼 u013129143 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] #include <stdio.h> #include <stdlib.h> #include <malloc.h>  typedef struct TNode{     int data1;     int data2;     struct TNode *next; }node,*pnode;  pnode CreateList(int n); pnode ComList(pnode A,pnode B); void Dayin();  void Dayin(pnode A) {     node *p;     p = A->next;     while(p){         printf("%dx^%d\t",p->data1,p->data2);         p = p->next;     }     putchar(10); }   pnode CreateList(int n) {     int i;     node *L;     node *p;     L=(struct TNode*) malloc (sizeof(node));     L->next = NULL;     for(i = 1;i <= n;i++){         p=(struct TNode*) malloc (sizeof(node));         printf("请输入第%d的系数",n+1-i);         scanf("%d",&p->data1);         printf("请输入第%d的指数",n+1-i);         scanf("%d",&p->data2);         p->next = L->next;         L->next = p;     }     return L; } pnode ComList(pnode A,pnode B) {     int x;     node *L3;     node *rc;     node *p1;     node *p2;     node *u;     p1 = A->next;     p2 = B->next;     L3 = A;     rc = L3;     while(p1 && p2){         if(p1->data2 == p2->data2){             x= p1->data1 + p2->data1;             if(x!=0) {                 p1->data1 = x;                 rc->next = p1;                 rc = rc->next;                 p1 = p1->next;                 p2 = p2->next;             }         } else if (p1->data2 > p2->data2) {             p2 = p2->next;//我这里改成了rc->next=p2;rc=p2;p2=p2->next         } else {             p1 = p1->next;//我这里改成了rc->next=p1;rc=p1;p1=p1->next         }     }      while (p1) {         rc->next = p1;         p1 = p1->next;[     }     while (p2) {         rc->next = p2;         p2 = p2->next;     }      return L3;  } int main() {     int n1,n2;     node *L1;     node *L2;     printf("请输入第一个多项式项数");     scanf("%d",&n1);     L1 = CreateList(n1);     Dayin(L1);     printf("请输入第二个多项式项数");     scanf("%d",&n2);     L2 = CreateList(n2);     Dayin(L2);     pnode L3 = ComList(L1,L2);     printf("After combine: \n");     Dayin(L3);     return 0; }  comList的逻辑有问题，详见上面的代码； 另外，建议加上对链表的释放。  哥，我按照你的改了一下才能正确的实现相加，，，然后，我还想问问，为什么要加ELSE 才能不出错，不加else  就报内存出错，就是我原来的代码 VS上说 0X00881731处有未经处理的异常：0XC0000005，读取位置0X0000004时发生访问冲突[/quote] 不只是else的问题，if中还要对p2 = p2->next做修改

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。


Question: while （函数）的问题

建议你看看 while的条件 特别是isalnum 的具体用法 它不会读到结尾 而是读到空格就不读了

啊，是的，刚想到isalnum，起床就看到你回复了。

在试了，但有点不太明白，为什么会那样运行， 它没有一次读完，而是读着读着就执行一次  循环里的 内容

这样猜测不如单步调试


Question: (signed char)~0在vs2017上为什么是-1呢？

无符号数(~0)0的求反运算11111111  有符号数(~0)0的求反运算在补码000000000的基础上操作11111111不过它是负数所以11111111的原码为结果即10000001

理解和讨论之前请先学会如何观察！  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

如果全二进制各位全为1（0取~），表示有符号数就是-1，最高位的1是符号位（表示负数），具体网上搜索负数的表示方法

~ 表示取一个数的二进制的反码

负数在内存中是如何存的


Question: 新手c语言，求助break问题

if (a[i]=='\0')    /*或判断a[i] == 0*/     break;

“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

注意赋值语句＝，和关系判断＝＝区别

a[i] == '\0'

这种函数内部产生的值没有变量名，会存储在未知的地址。 你不能在后面来一段 for (i=1;i<=5;i++)               sum=sum+f(i); f（i）是进入递归，不是存储数字，也就是说，你这么写，结合上面一段，会不断产生形参，直到堆栈区溢出，程序崩溃 递归产生的值要立刻使用，即使定义其他变量名比如一个数组也很容易数据溢出（即使你能做到，也最好不要这么干，纯粹增加修改麻烦）

引用 1 楼 baidu_37097818 的回复:a[i] == '\0' 能不能在给我解决一个问题，在应用递归函数后，不是按照递归，递归中的每一个值都是已知？我在利用for语句进行总和运算，这样为什么就程序自动瓦解了?具体函数如下： #include <stdio.h>          int main ()          {             int f(int n);           printf(" sum  :%d ",f(5));            return 0;          }          int f(int n)          {             int c;             if(n==1)              c=10;              else              { c=f(n-1)+2;}             int i,sum=0;             for (i=1;i<=5;i++)               sum=sum+f(i);               return (sum);          }


Question: 函数的指针传递问题

是的，你参数是按值传递的，也就是说函数中的形参只是实参的一个复制品，函数中只是修改了一个复制品，并不影响原件

没有变化，因为p是函数fac上的局部变量，p = p+1;只是修改了fac函数上的局部变量，而没有修改调用函数里的head； head是调用函数的里的变量（或者全局变量）

[b]没有变呢，举个例子,p=&f , 就是把变量   f   的地址给p，*p里为f的值

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

p是局部变量，只会影响到本函数fac栈内的内存。 但*p就不是局部变量了，它和*head一样，都指向head所指的内存，该内存并不在函数fac的栈内。 所以head和*head都没有变化，但在函数fac栈内p有变化。

是啊  关于值传递和引用传递