Question: c语言结构体指针与函数的问题

#include<stdio.h> #include<stdlib.h>  typedef struct ClassInfo{     int nClassNO;     char szClassName[20];     int nStudentNumber; }CLASSINFO;  typedef struct ClassInfoInFile{     CLASSINFO Class;     int nStudentInfoOffset;     char carrPreserved[512]; }CLASSINFOINFILE;  typedef struct StudentInfo{     char szID[9];     char szName[21];     double darrScores[3]; }STUDENTINFO;  typedef struct ClassScore {     STUDENTINFO *pStudents;     int nCount; } CLASSSCORE;  int readtext(FILE *fp, CLASSINFOINFILE *classinfohead, CLASSSCORE *classscore) {     STUDENTINFO *m;      fscanf(fp,"%d%s%d", &classinfohead->Class.nClassNO, (*classinfohead).Class.szClassName, &(classinfohead->Class.nStudentNumber));     classinfohead->nStudentInfoOffset = 544;     classscore->nCount = 0;      m = classscore->pStudents;     while(fscanf(fp, "%s %s %lf %lf %lf\n", m->szID, m->szName,                     &m->darrScores[0], &m->darrScores[1], &m->darrScores[2]) == 5) {         m++;         classscore->nCount++;     }      return (*(classscore)).nCount;  } int main() {     FILE *fp;     CLASSINFOINFILE *Class, Class1;     CLASSSCORE *Stu, Stu1;      if(!(fp=fopen("DataForLab3.txt", "r+"))) {         printf("open error!\n");         exit(-1);     }     Class = &Class1;     STUDENTINFO Stu2[20];     Stu1.pStudents = Stu2;     Stu = &Stu1;     readtext(fp, &Class1, &Stu1);      return 0; }  以上是我改过的，你可以尝试一下； 对于你读文件的方式我感觉还是会有问题，主要看你的文件内容的格式了。 程序编译有很多警告和错误；指针和变量运用的还不是很熟；


Question: 关于C语言中数组大小的一个问题

char data[15]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};  改成：  char data[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};  里面是有16个元素

你改成char[15]照理说会出现编译错误，因为你初始化的时候超过了数组边界


Question: C语言strcpy()函数导致段错误

是的，字符串计算长度，不能忘了结尾的“\0”, 空间分配的不够，指针操作就出界了

#include <stdio.h> #include <string.h>  //求单词循环右移中最小的排列 void string_sort(char *s, int n) {     int i, j;     char buf_1[50], buf_2[50];     int st;      strcpy(buf_1, s);     strcpy(buf_2, s);     for(i = 0; i < n; i++)     {         st = buf_2[n-1];         for(j = n - 1; j >= 1; j--)             buf_2[j] = buf_2[j-1];         buf_2[0] = st;         if(strcmp(buf_1, buf_2) > 0)             strcpy(buf_1, buf_2);         puts(buf_1);     }     strcpy(s, buf_1); }  void print_str(char (*str)[50], int len) {     int i;      for (i = 0; i < len; i++)         puts(str[i]); }  int main() {     char word[50][50];     int i, j;     int n, length, num = 1;     char str1[50];      //输入     scanf("%d", &n);     for(i = 0; i < n; i++)         scanf("%s", word[i]);      //将输入的单词做最小化排列     for(i = 0; i < n; i++) {         length = strlen(word[i]);         string_sort(word[i], length);     }      print_str(word, n);     //将各组处理后的单词按从小到大（字典顺序）排列     for(i = 0; i < n-1; i++)     {         for(j = i + 1; j < n; j++) {             if(strcmp(word[i], word[j])>0) {                 strcpy(str1, word[i]);                 strcpy(word[i], word[j]);                 strcpy(word[j],str1);             }         }     }     printf("After sort: \n");     print_str(word, n);     //求不同的循环单词数     for(i = 0; i < n - 1; i++) {         if(strcmp(word[i], word[i+1]) != 0)             num++;     }      printf("%d\n",num);     return 0; }  未发现出现段错误的情况，输入的字符串长度不要超过49，为最后一个'\0'预留一个空位。要么就是定义字符串数组长度为51，即word[50][51]

受教了，码代码的时候考虑欠周，将数组大小改为51就通过了，没有考虑‘\0’的问题，代码提交测试的时候遇到串长超过49的就报错了。

字符数组所需长度为最多字符个数+1 char word[50][50]; char str1[50]; 你这个如果正好是50个字符长，最后一个\0就越界了  你要多一个 char word[50][51]; char str1[51];

不要猜是不是strcpy导致错误，自己单步调试，确定在哪里出现错误先

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


Question: 懂单片机C语言编程的大神看过，使用Keil uVision2编写串口打印功能时，编译无错误，运行时出现如下提示，这是什么原因？

引用 6 楼 include_xy 的回复:引用 3 楼 include_xy 的回复:引用 楼主 include_xy 的回复:你瞧如果我想用浮点数，是不是需要重新安装keil？我知道了，我有个函数定义了但没调用，解决了，谢谢啦

引用 7 楼 include_xy 的回复:引用 3 楼 include_xy 的回复:引用 楼主 include_xy 的回复:你瞧我换成了整型，结果编译链接后出现这个提示 可以不用管 你的void delayms(uint xms)函数定义了，没有调用，是多余的，也可以删掉

你用了 float 类型的变量，链接器没有找到 浮点库。 其实整型已经够用了。

引用 4 楼 wang0635 的回复:你用了 float 类型的变量，链接器没有找到 浮点库。 其实整型已经够用了。

引用 楼主 include_xy 的回复:你瞧

#include<reg52.h> #include<intrins.h> #include<stdio.h> #define uchar unsigned char #define uint unsigned int sbit dula=P2^6; sbit wela=P2^7; sbit adwr=P3^6; sbit adrd=P3^7; uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71}; uchar flag_uart,flag_on,flag_time,ad_val,t0_num,a; float ad_vo; void delayms(uint xms) { uint i,j; for(i=xms;i>0;i--) 	for(j=110;j>0;j--); }  void init() { TMOD=0x21;//定时器/计数器工作方式寄存器,计时器1工作方式2，计时器0工作方式1 SM0=0; SM1=1;   //串行口工作方式寄存器，串行口工作方式1 REN=1; EA=1; ES=1; ET0=1; TR1=1; TH0=(65536-46080)/256; TL0=(65536-46080)%256; TH1=0xfd; TL1=0xfd; }  void display(uchar value) { uchar bai,shi,ge; bai=value/100; shi=value/100/10; ge=value%10;  dula=1; P0=table[bai]; dula=0; P0=0xff; wela=1; P0=0x7e; //数码管段位选与adc0804片选信号输入端同在锁存器U2，由P0口输出信号控制 wela=0;   dula=1; P0=table[bai]; dula=0; P0=0xff; wela=1; P0=0x7d;  wela=0;  dula=1; P0=table[bai]; dula=0; P0=0xff; wela=1; P0=0x7b;  wela=0; }  int get_ad() { uchar adval; adwr=1; _nop_(); adwr=0; _nop_(); adwr=1; P1=0xff; adrd=1; _nop_(); adrd=0; _nop_(); adval=P1; adrd=1; return(adval); }  void main() { init(); wela=1; P0=0x7f; wela=0; while(1) { if(flag_uart==1) 	{ 	flag_uart=0; 	ES=0; 	TI=1; 	switch(flag_on) 		{ 		case 0:puts("Turn on ad!\n"); 			   TR0=1; 			   break; 		case 1:printf("Turn off ad!\n"); 			   TR0=0; 			   break; 		case 2:puts("Error!\n"); 			   break; 		} 	while(!TI);     TI=0; 	ES=1; 	}  if(flag_time==1) 	{ 	flag_time=0; 	ad_val=get_ad(); 	ad_vo=(float)ad_val*5.0/256.0; 	ES=0; 	TI=1; 	printf("The voltage is %fV\n",ad_vo); 	while(!TI); 	TI=0; 	ES=1; 	} 	display(ad_val); } }  void time0() interrupt 1 { TH0=(65536-46080)/256; TL0=(65536-46080)%256; t0_num++; if(t0_num==20) 	{ 	t0_num=0; 	flag_time=1; 	} }  void ser() interrupt 4 { 	RI=0; 	a=SBUF; 	flag_uart=1; 	if(a==1) 		flag_on=0; 	else if(a==2) 		flag_on=1; 		else 		flag_on=2; }

不给代码瞧瞧吗？


Question: 链表写约瑟夫环崩溃，求大神看看出了什么问题

引用 2 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h> #include<string.h>  struct node {     int num;     char name[20];     struct node *next; };  struct node *create_singly_link(int num) {     struct node*head, *prev, *cur;     int i;      head = NULL;     for(i = 0; i < num; i++) {         cur = (struct node *)malloc(sizeof(struct node));         if (!cur) {             printf("Malloc error!");             return NULL;         }         cur->next = NULL;         cur->num = i+1;         snprintf(cur->name, 20-1, "%c", 'A'+i);         if (!head) {             head = cur;             prev = cur;         } else {             prev->next = cur;             prev = prev->next;         }     }     prev->next = head;     return head; }  static void test_print(struct node *phead) {     struct node *pcur = phead->next;      printf("num = %d\t name = %s\n", phead->num, phead->name);     while (pcur != phead) {         printf("num = %2d\t name = %s\n", pcur->num, pcur->name);         pcur = pcur->next;     } }  int output( struct node *head, int start, int step, int total) {     struct node *p, *q;     int count = 0;     int num = 0, i;      q = head;      for(i = 0; i < start; i++)         q = q->next;      while(count < total-1) {         p = q->next;         num++;         if(!(num % step)) {             q->next = p->next;             printf("%s\n", p->name);             free(p);             count++;         } else {             q = p;         }     }     printf("num = %d\t, name = %s\n", q->num, q->name);     free(q);      return 0; } int main(int argc, const char *argv[]) {     int total, step, start;     struct node *head;      printf("Please input total test number: ");     scanf("%d", &total);     head = create_singly_link(total);     test_print(head);      printf("Please input start position and steps: ");     scanf("%d%d", &start, &step);      output(head, start, step, total);      return 0; } 作为一个参考吧～ 谢谢啦。。。。。。。。。。


Question: 有关单链表free失败的问题，在不加free程序是可以正常运行的

你的malloc和free都不对应。你的malloc分配的单个的node节点，别指望通过free（list）来释放所有的节点。且你的那个list并没有通过malloc分配

free Deallocates or frees a memory block.  void free( void *memblock );  Function Required Header Compatibility  free <stdlib.h> and <malloc.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  None  Parameter  memblock  Previously allocated memory block to be freed  Remarks  The free function deallocates a memory block (memblock) that was previously allocated by a call to calloc, malloc, or realloc. The number of freed bytes is equivalent to the number of bytes requested when the block was allocated (or reallocated, in the case of realloc). If memblock is NULL, the pointer is ignored and free immediately returns. Attempting to free an invalid pointer (a pointer to a memory block that was not allocated by calloc, malloc, or realloc) may affect subsequent allocation requests and cause errors.  After a memory block has been freed, _heapmin minimizes the amount of free memory on the heap by coalescing the unused regions and releasing them back to the operating system. Freed memory that is not released to the operating system is restored to the free pool and is available for allocation again.  When the application is linked with a debug version of the C run-time libraries, free resolves to _free_dbg. For more information about how the heap is managed during the debugging process, see Using C Run-Time Library Debugging Support.  Example  /* MALLOC.C: This program allocates memory with  * malloc, then frees the memory with free.  */  #include <stdlib.h>         /* For _MAX_PATH definition */ #include <stdio.h> #include <malloc.h>  void main( void ) {    char *string;     /* Allocate space for a path name */    string = malloc( _MAX_PATH );    if( string == NULL )       printf( "Insufficient memory available\n" );    else    {       printf( "Memory space allocated for path name\n" );       free( string );       printf( "Memory freed\n" );    } }   Output  Memory space allocated for path name Memory freed   Memory Allocation Routines  See Also   _alloca, calloc, malloc, realloc, _free_dbg, _heapmin

#include <stdio.h> #include <stdlib.h>  typedef struct Node {     int data;     struct Node *pNext; } Node, *list;  void Creat_list(list*l, int n); void shuchu(list l); void merge(list la, list lb, list *lc);  int  main(void) {     list la;     list lb;     list lc;      Creat_list(&la, 3);     shuchu(la);     Creat_list(&lb, 3);     shuchu(lb);      merge(la, lb, &lc);      shuchu(lc);      return 0; } void Creat_list(list *l, int n) {     int a;     int i;     list q;      *l = (list)malloc(sizeof(Node));     (*l)->pNext = NULL;     for (i = n; i > 0; i--)     {         q = (list)malloc(sizeof(Node));         scanf("%d", &a);         q->pNext = (*l)->pNext;         (*l)->pNext = q;         q->data = a;     } }  void shuchu(list l) {     list p = l->pNext;      while (p) {         printf("%d\t", p->data);         p = p->pNext;     }     putchar(10); }  void merge(list la, list lb, list *lc) {     list pa;     list pb;     list pc;      pa = la->pNext;     pb = lb->pNext;     *lc = pc = la;      while (pa && pb) {         if (pa->data <= pb->data) {             pc->pNext = pa;             pc = pa;             pa = pa->pNext;         } else {             pc->pNext = pb;             pc = pb;             pb = pb->pNext;         }     }     while (pa) {         pc->pNext = pa;         pc = pa;         pa = pa->pNext;     }     while (pb) {         pc->pNext = pb;         pc = pb;         pb = pb->pNext;     }     free(lb); }  合并算法有点问题，现已改好了，你可以跑一下试试； 1. 合并排序的参数，lb不需要传递二重指针，因为不要将lb设置为传入传出参数，只需要作为传入参数即可，并在merge函数里将其释放。或者在main函数里释放，都是可以的。 2. 合并排序时，有可能两个链表的长度不一样，那么就需要将链表较长的最后加到链表lc中。


Question: 函数指针

函数指针、函数声明、函数实现时都可以省略参数的变量名  只不过在函数实现时如果省略，那么不能在函数中使用这个参数

1. 函数声明的时候参数的名字可以省略，但是参数类型是不可以的； 2. 此处的函数指针，参数的名字是可以省略的； 若要省略函数指针参数，也是可以的。可以考虑这样做；  typedef float (*pfunc)(float ); void dingjifen(float a,float b,int n, pfunc pf)  // 参数省略了 {     float width,x,i,s=0;       width=(b-a)/n;     for(i=1;i<=n;i++){         x=a+width*i;         s+=(*pf)(x)*width;     }     printf("定积分结果为：%f\n",s); }

参数名只是个占位符，若关心的只是其类型和个数时，就可以省略

cout<<"看了好几分钟，不好意思，没看明白"<<endl


Question: 怎样把一个字符串转化成一个数组

MFC 里面： char      cBuff[512]; CString str = "ABCDEFG"; 	 memset(cBuff, 0, sizeof(cBuff)); strcpy(cBuff, str ); //这样cBuff[0] = 'A'  //非MFC环境: char      cBuff[512]; string str = "ABCDEFG"; 	 memset(cBuff, 0, sizeof(cBuff)); strcpy(cBuff, str );

char ch[10]=“abcd”;

#include <stdio.h> #include <string.h>  int main(void) {     char *str = "helloworld";     char arr_str[32];     int len, i;      /* one way */     len = strlen(str);     strncpy(arr_str, str, len+1);      for (i = 0; i < len; i++)         putchar(arr_str[i]);     putchar(10);      /* another way */     memset(arr_str, 0, sizeof(arr_str));     printf("Please input a string: ");     scanf("%s", arr_str);     for (i = 0; i < len; i++)         putchar(arr_str[i]);     putchar(10);      return 0; } 两种方式都可以

我感觉 数字和字符应该差不多 只不过是数组的类型不同 例如 int 和 char

char ch[10]; scanf("%9s",ch);


Question: C指针使用栈的问题

我刚想通了。。。是我智障了，应该先初始化分配内存空间然后才能用。。。我在图书馆还想了好久，诶。。。

若那样，S仅仅是一个指针，指向 struct stack类型的变量，但是指向什么地方，没有赋值确定。后来通过S往它所指的变量字段内存取数据，到底是哪里呢


Question: C语言 socket编程发送http报文，却收不到服务器回复的问题

建议先学会使用抓包软件比如wireshark

发送的请求末尾再加个\n


Question: 小白第一次用递归，不知道哪里搞错了

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

主函数中改成：   	float ans; 	ans = height(10); 	printf("第10次反弹%f米高,第10次落地共经过%f米。\n",ans,sum);

printf("第10次反弹%f米高,第10次落地共经过%f米。\n",height(10),sum);这句不对 在处理printf时，压栈顺序为从右往左，也就是说还没调用height时，sum的值就已经被固定了，你分成两句就行了  #include <stdio.h> float h, sum = 100;	//第十次的高度h，十次共经过sum米  float height(int n)	//计算h { 	if (n == 1) 	{ 		sum += 2 * 50; 		return 50; 	} 	h = height(n - 1) / 2; 	sum += 2 * h; 	return h; }  int main(void) { 	printf("第10次反弹%f米高\n", height(10)); 	printf("第10次落地共经过%f米\n", sum); 	system("pause"); 	return 0; }

你把打印分两行写试试，也就是打印sum的话要在height（10）计算完毕之后。


Question: 链表 的拆分 ，老是不对，请指教

#include<stdio.h> #include<stdlib.h>  struct node {     int data;     struct node *next; };  void init_link_head(struct node **phead); void create_link(struct node **phead, int num); void splite_link(struct node **psrc, struct node **phead); void print_link(struct node *phead); void destroy_link(struct node *phead);  int main(void) {     int num;     struct node *head2, *head1;     init_link_head(&head1);     init_link_head(&head2);      printf("Please input the number of nodes: ");     scanf("%d", &num);     create_link(&head1, num);     print_link(head1);     splite_link(&head1, &head2);     print_link(head1);     print_link(head2);     destroy_link(head1);     destroy_link(head2);     return 0; }  void init_link_head(struct node **phead) {     *phead = (struct node *)malloc(sizeof(struct node));     if (!(*phead)) {         fprintf(stderr, "malloc error!\n");         exit(-1);     }     (*phead)->next = NULL; }  void create_link(struct node **phead, int num) {      int i;     struct node *pnew, *tail = *phead;      for(i = 0; i < num; i++) {         pnew = (struct node *)malloc(sizeof(struct node));         if (!pnew) {             fprintf(stderr, "malloc error!\n");             exit(-1);         }         scanf("%d", &pnew->data);         pnew->next = NULL;         tail->next = pnew;         tail = pnew;     } }  void splite_link(struct node **psrc, struct node **phead) {     struct node *tail, *pcur, *prev;      prev = *psrc;     pcur = (*psrc)->next;     tail = *phead;      while (pcur) {         if (pcur->data % 2) {             prev->next = pcur->next;             tail->next = pcur;             tail = pcur;             tail->next = NULL;             pcur = prev->next;         } else {             prev = prev->next;             pcur = pcur->next;         }     } }  void print_link(struct node *phead) {     struct node *pcur = phead->next;      while (pcur) {         printf("%d\t", pcur->data);         pcur = pcur->next;     }     putchar(10); }  void destroy_link(struct node *phead) {     struct node *pcur = phead->next, *ptmp;      while (pcur) {         ptmp = pcur->next;         free(pcur);         pcur = ptmp;     } }  注释多了，不一定能提高代码的可读性；代码过于臃肿，会降低可读性； 以上是个人的设计，作为一个参考吧～

如果想算奇数和偶数的个数的话  while(p != NULL)     {         if(p->data % 2 == 0)         {             a++;            /* p->next = NULL;             tail1->next = p;             tail1 = p;         */ 		//	p=p->next;         }         else         {             b++;      /*       p->next = NULL;             tail2->next = p;             tail2 = p;     */ 		//	p=p->next;         }         p = p->next; 去掉那部分代码就行了。

你想实现的功能是什么楼主


Question: 两个二级上的问题

引用首先 在结构体里边用int x,y,z;是不是相当于int x;int y; int z;  是的  引用其次，我看书上说在对a.u.y成员赋值时，a.u.x的值就不存在了，对a.u.z赋值时，a.u.y的值就不存在了。  那书就说的是错的，不会不存在，但对k赋值，则会改动到u中的成员

写入的时候依次写入了1、2、3，但读的时候由于是连在一起，k的值为123，而n已经没数据可读了，故没读到，仍为0

至于第二个问题是这样的： union是公用体,里面的所有成员共享一份内存,左对齐，公用体变量所占的内存由占用内存最大的的成员决定； 你这里的结构体就是u所占内存最大，所以a所占的内存空间就是u所占的内存空间； 因为公用内存，所以执行a.k=0时把a.u.x原来的数据覆盖了（x和k都是int型,刚好完全覆盖）,所以a.u.x=0.

引用 2 楼 Janxionwang 的回复: #include<stdio.h>  int main() { 	FILE *fp; 	int i,k=0,n=0; 	fp=fopen("d1.dat","w"); 	for(i=1;i<4;i++) 		fprintf(fp,"%d",i);//写进去时候每行只有一个数字，最终结果是第一至第三行依次为123 	fclose(fp); 	fp=fopen("d1.dat","r"); 	fscanf(fp,"%d%d",&k,&n);//你想读两个数字，可是只有一个数字每行 	printf("%d %d\n",k,n); 	fclose(fp); 	return 0; }   如果改成这样：  #include<stdio.h>  int main() { 	FILE *fp; 	int i,k=0,n=0; 	fp=fopen("d1.dat","w"); 	for(i=1;i<4;i++) 		fprintf(fp,"%d%d",i,i+1);//这样才是每行有两个数，n不会空 	fclose(fp); 	fp=fopen("d1.dat","r"); 	fscanf(fp,"%d%d",&k,&n); 	printf("%d %d\n",k,n); 	fclose(fp); 	return 0; }  回答的第一题是不对 的。 写入文件是123 在第一行 ，不是三行  读取的时候 只会读取到123，n是你的初始赋值    第二个问题3楼说的很清楚了。 下面的程序帮助你理解union  #include<stdio.h>  int main() {     union myun{         struct{int x,y,z;}u;         long k;         long long m;     }a;      a.u.y=5;     a.u.x=4;     a.u.z=6;      a.k=1;     a.m=0x00000000200000003;      printf("int = %d long = %ld long long = %ld \n",             sizeof(int), sizeof(long), sizeof(long long));     printf("%d %d %d %d %ld \n",             a.u.x,             a.u.y,             a.u.z,              sizeof(a),             a.m);     return 0; }

1. 检查fscanf的返回值，读出了几个数？因为前面fprintf写的时候，数与数之间没有空格之类的分隔符，全连在一起了，读出时肯定是只按一个数处理了 2. int x,y,z;相当于int x;int y; int z;。只有对a.k赋值时覆盖了前边的值，具体是xyz中哪一个，看编译器高兴怎么安排顺序了，人不能假定就是某种确定的顺序


Question: 栈的销毁问题

好的，感谢各位。另外，抱歉，过了两个月才回复。

如果你非要这样做，可以给将Destroy的返回值定义成栈的地址或使用指针的指针来传参，即： stack * Destroy(stack *one); 或 void Destroy(stack * * one);

销毁用的指针也是形参的方式传进来的，即使one=NULL;也是把形参置空了。如果你非要这样做，void Destroy(stack* one)

#include <stdio.h>  void Destroy(stack *one) {     if (!one) {         printf("栈不存在，无法进行删除操作\n");     return;     }     free(one);     one = NULL; }  void push(stack *one) {     int a;      if (!one) {         printf("栈不存在，无法进行入栈操作\n");         return;     }     if(one->top == MAXSIZE-1) {         printf("栈已满，无法入栈\n");         return;     }     printf("请输入入栈的元素:");     scanf("%d", &a);     one->top++;     one->data[one->top] = a;     printf("元素已经入栈\n"); } 使用free释放空间，前提是栈的申请是在堆上进行的，即通过malloc, realloc等方式申请的； 每个函数之后都加一个";",这个是没必要的。


Question: make命令到链接这一步出错，各路大神帮忙看看。

gcc ${CFLAGS} $< -o ${OUTPUTDIR}/$@  这句话是生成目标文件，不是.0吧。  生成.0文件应该是-c

-M是不是忘记删掉了


Question: 蓝桥杯历届例题，九宫重排

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: 关于栈的链式结构输出问题

#include<stdio.h> #include<stdlib.h>  #define OK 1 #define ERROR 0 #define OVERFLOW -2  typedef int ElemType;  typedef struct Node {     ElemType data;     struct Node *next; }StackNode;  //初始化 StackNode *InitStack(StackNode *top) {     top = (StackNode *)malloc(sizeof (StackNode));     if(!top)         exit (OVERFLOW);     top->next = NULL;      return top; } //判空栈 int EmptyStack(StackNode *top) {     if(!top->next)         return OK;     else         return ERROR; } //压栈 StackNode *PushStack(StackNode *top,ElemType e) {     StackNode *p = (StackNode *)malloc(sizeof (StackNode));     if (!p) {         fprintf(stderr, "malloc error!\n");         exit(-1);     }     p->data = e;      p->next = top->next;     top->next = p;      return top; }  //弹栈 StackNode *PopStack(StackNode *top, ElemType *e) {     StackNode *p = NULL;     if(EmptyStack(top)) {         printf("Stack Underflow!");         return p;     }     p = top->next;     *e = p->data;      top->next = p->next;     free(p);      return top; } //取栈顶 ElemType GetStack(StackNode *top) {     if(EmptyStack(top)) {         printf("Stack Underflow!");         return OVERFLOW;     }     return(top->next->data); } //输入 StackNode *CreatStack(StackNode *top) {     ElemType e;      scanf("%d", &e);     while (e) {         top = PushStack(top, e);         scanf("%d", &e);     }     return top; } //输出 void print(StackNode *top) {      StackNode *p;     p = top->next;     ElemType e;      while (p) {         e = p->data;         printf("%d\t", e);         p = p->next;     }     printf("\n"); }  void reinit_stack(StackNode *stack) {     StackNode *p = stack;     ElemType e;      fprintf(stdout, "Output from stack: \n");     while (!EmptyStack(p)) {         p = PopStack(p, &e);         printf("%d\t", e);     }     putchar(10);     free(stack); }  int main(void) {     ElemType e;     StackNode *top = NULL;     top = InitStack(top);      printf("请输入一组数字（以0结束）：\n");     top = CreatStack(top);     printf("堆栈为：\n");     print(top);     top = PopStack(top, &e);     printf("删除栈顶元素: %d\n", e);     printf("新的堆栈为：\n");     print(top);      e = GetStack(top);     printf("现在栈顶元素为：%d\n", e);      printf("堆栈为：\n");     print(top);      reinit_stack(top);     return 0; } 在你的基础上修改的，参考一下吧； 链表的使用是一个比较难的地方，也是很容易检查C语言的精髓之处学习的如何。


Question: 关于C _asm的je指令问题求助

引用 6 楼 zhao4zhong1 的回复:汇编标号不分大小写; c标号区分大小写。  是啊，所以这可以解释为什么goto c_dest;是Error而jmp c_dest是Legal的，以及为什么goto A_Dest;和goto a_dest;都是Legal的。 但是这并没有解释为什么goto a_dest;和jmp a_dest虽然是Legal但却是incorrect case。

汇编标号不分大小写; c标号区分大小写。

引用 4 楼 zhao4zhong1 的回复:还没见过谁敢说MSDN中的例子不对的。 然而这个例子就是睁眼说瞎话。  明明写的a_dest:    ; __asm label 却说jmp a_dest ; Legal: incorrect case是错误的大小写，都是完全一样的东西，这我就看不明白了。  而且更奇怪的是为什么jmp A_Dest又是正确的大小写了

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

引用 2 楼 zhao4zhong1 的回复:  Jumping to Labels in Inline Assembly Home |  Overview |  How Do I  Like an ordinary C or C++ label, a label in an __asm block has scope throughout the function in which it is defined (not only in the block). Both assembly instructions and goto statements can jump to labels inside or outside the __asm block.  Labels defined in __asm blocks are not case sensitive; both goto statements and assembly instructions can refer to those labels without regard to case. C and C++ labels are case sensitive only when used by goto statements. Assembly instructions can jump to a C or C++ label without regard to case.   The following code shows all the permutations:  void func( void ) {    goto C_Dest;  /* Legal: correct case   */    goto c_dest;  /* Error: incorrect case */     goto A_Dest;  /* Legal: correct case   */    goto a_dest;  /* Legal: incorrect case */     __asm    {       jmp C_Dest ; Legal: correct case       jmp c_dest ; Legal: incorrect case        jmp A_Dest ; Legal: correct case       jmp a_dest ; Legal: incorrect case        a_dest:    ; __asm label    }     C_Dest:       /* C label */     return; }  Don’t use C library function names as labels in __asm blocks. For instance, you might be tempted to use exit as a label, as follows:  ; BAD TECHNIQUE: using library function name as label jne exit    .    .    . exit:    ; More __asm code follows  Because exit is the name of a C library function, this code might cause a jump to the exit function instead of to the desired location.  As in MASM programs, the dollar symbol ($) serves as the current location counter. It is a label for the instruction currently being assembled. In __asm blocks, its main use is to make long conditional jumps:  jne $+5 ; next instruction is 5 bytes long jmp farlabel ; $+5    .    .    . farlabel:    感觉这个例子写错了吧。。为什么goto a_dest和jmp a_dest是错误的大小写？

怎么才能让这段代码执行到je指令这里的时候跳到最后一段代码执行呢


Question: 新手自学C碰到个题不会做，

#include <stdio.h>           void jolly()     {         printf("For he‘s a jolly good fellow!\n");     }           void deny()     {         printf("Which nobody can deny!\n");     }           int main (void)     {     	int i;       	for(i=1;i<=3;i++)       	jolly();             	deny();           	getchar();     	return 0;     }

引用 5 楼 shihengzhen101 的回复:     #include <stdio.h>           void jolly()     {         printf("For he‘s a jolly good fellow!\n");     }           void deny()     {         printf("Which nobody can deny!\n");     }           int main (void)     {       	jolly();       	jolly();       	jolly();             	deny();           	getchar();     	return 0;     }  这是符合你题目的写法，但是不是最简单的 参考：[http://ideone.com/XwqXiV](http://ideone.com/XwqXiV) 谢谢，我明白了

引用 3 楼 qq_36409192 的回复:void jolly() { 	printf("For he‘s a jolly good fellow!\n"); }  void deny() { 	printf("Which nobody can deny!\n"); } 好好看书吧，这是最简答的函数。 而且这样用函数没任何意义。 +++ 用循环吧，循环一次调用一次函数

用for循环吧。字数

引用 1 楼 u010165006 的回复:如果相同的消息要打印100条，你会怎么写？ 我就是不知道怎么写啊

如果相同的消息要打印100条，你会怎么写？


Question: c语言关于循环和递归解一元多项式的小问题

第一张图片有点不清晰，重发

...... double    a[N]; ...... scanf("%lf", &a[i-1]); ...... fun1(N, a, x); ...... for(i=1; i<n; i++) ......  等


Question: 快速排序C语言

同意楼上说法

你这个swap毫无作用 void Swap(int m, int n, int k) {   k=m;m=n;n=k; }  你要用引用或者指针，另外那个k，也就是那个临时变量不需要作为参数传入 void Swap(int &m, int &n, int k) {   k=m;m=n;n=k; }

经供参考： #include <stdio.h> void Quicksort(int a[],int low,int high) { 	int key=a[low],i=low,j=high-1; 	if(high<=low) 		return; 	while(j>i) 	{ 		while(j>i&&a[j]>=key) 			j--; 		a[i]=a[j]; 		while(j>i&&a[i]<=key) 			i++; 		a[j]=a[i]; 	} 	a[i]=key; 	Quicksort(a,low,j); 	Quicksort(a,j+1,high); }  int main () { 	int a[8]={3,2,5,8,4,7,6,9}; 	Quicksort(a,0,8); 	for(int i=0;i<8;i++) 		printf("%3d",a[i]); 	return 0; }

额，改进了为什么我的程序还是不能排正确呢？


Question: getchar()读取换行符

加getchar是因为下面的输入需要%c输入，对于该程序不需要加是因为下面的输入（循环继续）要输入的不是%c类型的字符。 下面再次输入%d缓存里存放的'\n'也无法与%d匹配，但是可以于%c或者getchar获取一个字符匹配。

因为随后的scanf取的格式是%d。如果是%c就必须有它了。


Question: C语言中如何实现数据隐藏？

如果不让别人知道你内部的实现，那么你可以定义对外的函数接口，就是你的模块和外界模块的数据通信的接口； 你需要写函数接口，然后将你需要的参数通过调用你实现的函数接口来拿到；这个接口不一定非要用指针，如果使用结构体指针，你还得让别人的模块指导你的数据结构是什么； 对于是否使用指针，使用指针主要是调用一个函数接口，可以修改传进来的地址里的值，即这个参数是传入传出参数；就是传进来一个地址，经过你的函数处理带走处理后的结果；我估计传指针到你的函数，就是将处理的结果能够返回到调用的函数里。


Question: 求大佬解释，我这段代码哪错了

函数声明，建议不要放在main函数里，放在函数之外，main函数之上最好；

scoresort里的for循环的大括号不对称

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

大括号不对称，这样改：   #include<iostream> using namespace std;  struct student  { 	int num;  	char name[10];  	int score1;  	int score2;  	int score3;  	float aver; };  void main() { 	void input(struct student stu[]);  	void scoresort(struct student stu[]);  	void output(struct student stu[]);  	struct student stu[3],*p=stu;  	input(p);  	scoresort(p);  	output(p);  }  void input(struct student stu[]) { 	int i;  	printf("NUM\tNAME\tSCORE1\tSCORE2\tSCORE3\n");  	for(i=0;i<3;i++)  	{  		scanf("%d%s%d%d%d",&stu[i].num,stu[i].name,&stu[i].score1,&stu[i].score2,&stu[i].score3);  		stu[i].aver=(stu[i].score1+stu[i].score2+stu[i].score3)/3;  	}  	printf("\n");  	cout<<"Before Sort:"<<endl;  	printf("NUM\tNAME\tSCORE1\tSCORE2\tSCORE3\tAVERAGE\n");  	for(i=0;i<3;i++)  		printf("%d\t%s\t%d\t%d\t%d\t%f\n",stu[i].num,stu[i].name,stu[i].score1,stu[i].score2,stu[i].score3,stu[i].aver);   	printf("\n");   }  void scoresort(struct student stu[]) { 	int i=0,j,k;    	struct student p;  	for(;i<2;i++) 	{    k=i;  	for(j=i+1;j<3;j++)  		if(stu[j].aver>stu[k].aver) k=j;  	if(k!=i)  	{ 		p=stu[i];stu[j]=stu[k];stu[k]=p; 	}    	} }  void output(struct student stu[]) { 	int i;          	cout<<"After Sort:"<<endl;  	printf("NUM\tNAME\tSCORE1\tSCORE2\tSCORE3\tAVERAGE\n");  	for(i=0;i<3;i++)  		printf("%d\t%s\t%d\t%d\t%d\t%f\n",stu[i].num,stu[i].name,stu[i].score1,stu[i].score2,stu[i].score3,stu[i].aver);   	printf("\n"); }

scoresort里面少了些 } 右大括号


Question: if-else运算

引用 2 楼 Beginner_WZH 的回复:引用 1楼ck2333 的回复:先判断b^2-4*a*c是大于0，还是等于0，还是小于0，如果大于0，则答案为两解，如果等于0，则为相同的两个解，如果小于0，则无解（解则用求根公式求）能给我写出来看看吗？ 自己的作业自己写，都已经把整个思路告诉你了，还要别人帮你写出来？？

这个满足你的要求：  http://blog.csdn.net/WRNGT/article/details/53177002

就是用数学中的二分法  你可以试试 需要一个高效的算法   否则你懂的


Question: linux 调用自己定义的函数静态库 的结果和放在一个程序里的调用函数的结果不一样了呢？

括号太多，参数传递也有问题，有越界的嫌疑；

引用yujiaxin@yujiaxin-HP-Pavilion-14-Notebook-PC:~$ gcc -o main main.c -L ./ -lls main.c: In function ‘main’: main.c:11:4: warning: implicit declaration of function ‘LS’ [-Wimplicit-function-declaration]     LS((int**)Prebdata,(int**)bDataLS,a,b,5,5); yujiaxin@yujiaxin-HP-Pavilion-14-Notebook-PC:~$ vi main.c yujiaxin@yujiaxin-HP-Pavilion-14-Notebook-PC:~$ gcc -o main main.c -L ./ -lls main.c: In function ‘main’: main.c:11:4: warning: implicit declaration of function ‘LS’ [-Wimplicit-function-declaration]     LS((int**)Prebdata,(int**)bDataLS,a,b,5,5);     ^  你的函数没有声明。  默认的声明和你的函数定义不一致。

LS的逻辑可以再详细一些，不然不容易理解，第一行和第二行，怎么还跟原函数扯上关系了呢

问题已经解决，再建一个.h文件，声明一下就好了，感谢各位的解答，关于程序不简洁明了的问题我会尝试着改进的，感觉各位说的都很有受用，感谢！！


Question: c语言初学者编程的时候遇到个问题不会做求大神解答感激不尽

输入的值保存到数组，然后for循环输出

楼主你把scanf里的空格去掉 或者使用getchar获得两个值

这种简单的小程序，一定要熟练的掌握 #include <stdio.h> #include <stdlib.h> int main () { 	int **a; 	int n; 	scanf("%d",&n); 	a=(int **)malloc(n*sizeof(int *)); 	for(int i=0;i<n;i++) 		a[i]=(int *)malloc(2*sizeof(int)); 	for(int i=0;i<n;i++) 		scanf("%d%d",&a[i][0],&a[i][1]); 	for(int i=0;i<n;i++) 		if(a[i][0]>a[i][1]) 			printf("%d\n",a[i][0]); 		else printf("%d\n",a[i][1]); 	return 0; }


Question: 文件格式化读取 。

#include <stdio.h> #include <string.h> #include <time.h>   int getTime (char *date) {     if (!date)         return -1;     time_t lt;     struct tm *p;        time(<);     p = localtime(<);     sprintf(date, "%04d-%02d-%02d %02d:%02d:%02d",              p->tm_year + 1900, p->tm_mon + 1,              p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);     return 1; }  int main(void) {     char date[32];          getTime(date);     puts(date);     return 0; } 简单一些就好了，不需要那么多用于存放年月日，时分秒的数组变量。

刚刚那个写错个地方0 0 #include "time.h" #include <string.h> #include <stdio.h> //#define OK 1       int getTime(char *date){     time_t lt;     char year[5];     char month[3];     char day[3];     char hours[3];     char min[3];     char sec[3];     struct tm *p;     char *a="-";     char *b=":";       time(<);     p = localtime(<);     sprintf(year, "%4d", p->tm_year+1900);     sprintf(month, "%02d", p->tm_mon+1);     sprintf(day, "%02d", p->tm_mday);     sprintf(hours, "%02d", p->tm_hour);     sprintf(min, "%02d", p->tm_min);     sprintf(sec, "%02d", p->tm_sec);     strcpy(date,year);     strcat(date,a);     strcat(date,month);     strcat(date,a);     strcat(date,day);     strcat(date,a);     strcat(date,hours);     strcat(date,b);     strcat(date,min);     strcat(date,b);     strcat(date,sec);     return 1; }

引用 2 楼 cfjtaishan 的回复:原因是fscanf类似scanf（不同的是读取的位置可能不一样），都是以空格来区分不同输入的。所以如果改成如下形式，是可以的：1 洗衣机 1 100 500 Sat-Mar-18-11:12:39-2017 Sat-Mar-18-14:12:39-2017 1 1字符串不用" "串起来， inDate相邻之间不能有空格，原因上面已解释； 个人建议，对于你要求的时间，不如使用文件里记录秒数，及time_t类型的数据（unsigned int);独到秒数之后再将其转换成这种时间表示方法，一样是可以的。 time(NULL);//获取从1970至目前的秒数，存文件；然后利用localtime,或者其他转换成你想要的时间格式； 另外，fscanf(fp, "...\n")最后要加一个\n #include "time.h" #include <string.h> #include <stdio.h> //#define OK 1    int getTime(char *date){     time_t lt;     char year[5];     char month[3];     char day[3];     char hours[3];     char min[3];     char sec[3];     char date[40]={'\0'};     struct tm *p;     char *a="-";     char *b=":";      time(<);     p = localtime(<);     sprintf(year, "%4d", p->tm_year+1900);     sprintf(month, "%02d", p->tm_mon+1);     sprintf(day, "%02d", p->tm_mday);     sprintf(hours, "%02d", p->tm_hour);     sprintf(min, "%02d", p->tm_min);     sprintf(sec, "%02d", p->tm_sec);     strcpy(date,year);     strcat(date,a);     strcat(date,month);     strcat(date,a);     strcat(date,day);     strcat(date,a);     strcat(date,hours);     strcat(date,b);     strcat(date,min);     strcat(date,b);     strcat(date,sec);     return 1; } 谢谢 能不能顺便帮我看看这个函数有没有缺陷？

有没有那种可以类似正则 的函数


Question: 字符数组字符串输出与读入

数组分配是连续的空间，所以输出是you&me

引用 2 楼 qq_18888869 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 第一个问题：地址值是一样的，都是指数组的开始；但是类型不一样；arr是二维数组，表示的是二维数组的首地址，但是arr[0]可看成是一重指针。它是表示第一个字符数组的首地址（列的首地址）； 第二个问题：你的理解是正确的，strcpy后you后面是一个字符串结束标记，因为strcpy是会拷贝'\0'的，a[0][3] = ‘&';正好将'\0'覆盖； printf("%s ",arr);这句是有问题，%s输入应该是arr[0]; 之所以输出这样的结果，原因第一个字符串“you"后面的'\0'被覆盖了，%s输出时遇到'\0'才结束，所以输出"you&me" 就是说&后边的内容存的是me\0 了吗？ 数组是这样存储的吧？ 我好像在书上看见过[/quote] 对的，虽然是二维数组，但是数组空间在内存里是线性排列的，并且是顺序的，即arr[0][3]是第一行的末尾，arr[1][0]是第二行的第一个，根据内存是线性的，所以&后面的就是"me"

引用 1 楼 cfjtaishan 的回复:第一个问题：地址值是一样的，都是指数组的开始；但是类型不一样；arr是二维数组，表示的是二维数组的首地址，但是arr[0]可看成是一重指针。它是表示第一个字符数组的首地址（列的首地址）； 第二个问题：你的理解是正确的，strcpy后you后面是一个字符串结束标记，因为strcpy是会拷贝'\0'的，a[0][3] = ‘&';正好将'\0'覆盖； printf("%s ",arr);这句是有问题，%s输入应该是arr[0]; 之所以输出这样的结果，原因第一个字符串“you"后面的'\0'被覆盖了，%s输出时遇到'\0'才结束，所以输出"you&me" 就是说&后边的内容存的是me\0 了吗？ 数组是这样存储的吧？ 我好像在书上看见过


Question: 关于‘\0’

需要区分3个0，和一个指针0； 字符‘0’，数字0，‘\0’；指针（void *）0(NULL); 字符‘0’转10十进制是48（0x30~0x39就是0~9） 数字0，就是十进制的0； 字符串结束标记'\0'，十进制就是0； 由于数字0和'\0'的十进制都是一样的，所以可以等价； 指针0，就是NULL，用于指针的初始化。

对的，双引号内的字符串常量会自动添加一个'\0'作为字符串结束标志。sizeof("iloveyou")结果为9 书上写^@是因为控制符号打印不出来， 以^开头的通常在终端显示，后面是该控制符号的ASCII码加上64对应的字符. NUL是名称缩写，是取单词null的前三个字母

引用 楼主 qq_18888869 的回复:#include <stdio.h> int main()  {  	int i, j; 	char *arr="iloveyou"; 	 	for(i=0;arr[i]!=0;i++) 		printf("%c",arr[i]); 	 	return 0;  }  今天看到一个程序用了arr[i]！=0判断字符串的结尾，这样对吗？结尾符的ascll码是0？我看书上写的^@啊。ascll名称是NUL。分别代表的什么意思？求大神指点 一般在程序中会有定义#define NULL 0 也就是说NULL代表了0  而字符'\0'在ASCII中的值就0，所以说判断结尾是否是'\0'，也可以写成和0比较的版本

引用 1 楼 user-4 的回复:'\0'就是八进制0表示的字符，就等于0 你在说什么？

'\0'就是八进制0表示的字符，就等于0


Question: 数据结构—— 两个有序链表序列的合并

#include <stdio.h> #include <stdlib.h>  typedef int ElementType; typedef struct Node *PtrToNode;  struct Node {     ElementType Data;     PtrToNode   Next; };  typedef PtrToNode List;  List Read(); void Print(List L);  List Merge(List L1, List L2); List my_merge_link(List hd1, List hd2);  int main() {     List L1, L2, L;     L1 = Read();     L2 = Read();      Print(L1);     Print(L2);     /*     L = Merge(L1, L2);     Print(L);     */     L = my_merge_link(L1, L2);     Print(L);     return 0; }   List my_merge_link(List hd1, List hd2) {     List pcur, pcur1, pcur2;     List hd;      pcur1 = hd1->Next;     pcur2 = hd2->Next;     hd = (List)malloc(sizeof(struct Node));     pcur = hd;      while (pcur1 && pcur2) {         if (pcur1->Data < pcur2->Data) {             pcur->Next = pcur1;             pcur = pcur1;             pcur1 = pcur1->Next;         } else {             pcur->Next = pcur2;             pcur = pcur2;             pcur2 = pcur2->Next;         }     }      if (pcur1) {         pcur->Next = pcur1;         pcur = pcur1;         pcur1 = pcur1->Next;     }     if (pcur2) {         pcur->Next = pcur2;         pcur = pcur2;         pcur2 = pcur2->Next;     }       return hd; }   //将两个链表表示的递增整数序列合并为一个非递减的整数序列 List Merge(List L1, List L2) {     List L;     List head;     List Tmp, Tmp1, Tmp2;      Tmp1 = L1->Next;     Tmp2 = L2->Next;     head = (List)malloc( sizeof( struct Node ) );     Tmp = head;        while( Tmp1 || Tmp2 ){         L = ( List )malloc( sizeof( struct Node ) );         //若Tmp1为NULL，则将Tmp2->Data复制给L         if( !Tmp1 ){             L->Data = Tmp2->Data;             Tmp2 = Tmp2->Next;         }         else if( !Tmp2 ){             L->Data = Tmp1->Data;             Tmp1 = Tmp1->Next;         }          else{             //注意要求为非递减，故条件为<=,若为递增则改为<             //且增加二者相等时             if( Tmp1->Data <= Tmp2->Data ){                 L->Data = Tmp1->Data;                 Tmp1 = Tmp1->Next;             }              else if( Tmp2->Data < Tmp1->Data ){                 L->Data = Tmp2->Data;                 Tmp2 = Tmp2->Next;             }         }         Tmp->Next = L;         Tmp = L;     }     //由于结束后L1 L2输出为NULL，故empty L1和L2     L1->Next = NULL;     L2->Next = NULL;      return head; }  //题中省略此部分，为方便调试，自行写一个 List Read(){     List head;     List p;     List r;     int n;     head = (List) malloc( sizeof( struct Node ) ) ;     r = head;      printf("Please input the number of nodes: ");     scanf( "%d",&n);     while(n--){         p = (List) malloc( sizeof( struct Node ) );         printf("Pleaes input data: ");         scanf("%d", &p->Data );         r->Next = p;         r = p;     }     r->Next = NULL;     return head; }  void Print( List L ){     List p;     p = L->Next;     if( p == NULL ){         printf("NULL\n");         return;     }      while( p ){         printf( "%d",p->Data );         p = p->Next;         if( p )             printf(" ");     }     printf("\n"); } my_merge_link函数


Question: 二进制转换

引用 3 楼 自信男孩的回复:/*利用栈的数据接构，将二进制转换成十进制*/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h>  #define STACKINCREMENT 10 #define MAXSTACK 60 #define MAX_SIZE 128  typedef char ElemType;  typedef struct{     ElemType *top;     ElemType *base;     int StackSize; }sqStack;  void initStack(sqStack *s) {     s->base = (ElemType *)malloc(MAXSTACK * sizeof(ElemType));     if (!s->base)         exit(0);     s->top = s->base;     s->StackSize = MAXSTACK;  }  void pushStack(sqStack *s, ElemType e) {     if (s->top - s->base >= s->StackSize) {         s->base = (ElemType *)realloc(s->base, (s->StackSize + STACKINCREMENT)*sizeof(ElemType));         if (!s->base)             exit(0);         printf("Realloc memery!\n");         s->top = s->StackSize + s->base;         s->StackSize = s->StackSize + STACKINCREMENT;     }      *(s->top) = e;     s->top++; }  void pullStack(sqStack *s, ElemType *e) {     if (s->base == s->top)     {         printf("stack is empty!\n");         return;     }     *e = *--(s->top); } void destroy(sqStack *s) {     free(s->base);     s->top = s->base = NULL;     s->StackSize = 0; }  int StackLen(sqStack s) {     return (s.top - s.base); }  int main() {     sqStack s;     ElemType buf[MAX_SIZE], e;     int i, len, sum = 0;     printf("请输入二进制数(#号键结束)：");     initStack(&s);      fgets(buf, MAX_SIZE, stdin);    /*buf include '\n' */     len = strlen(buf);      for (i = 0; i < len; i++) {         e = buf[i];         if (e != '\n')             pushStack(&s, e);     }     len = StackLen(s);     printf("len = %d\n", len);     for (i = 0; i < len; i++)     {         pullStack(&s, &e);         sum = sum + (e - 48)*pow(2, i);     }     printf("输入的十进制为：%d", sum);     destroy(&s);     getchar();      return 0; } 改了一下你的程序，发现问题主要出在入栈上，即入栈时没有正确入栈。直接原因是scanf, %c的问题，建议避开输入是接收缓存里的回车符。 我的方法是使用fgets,一次输入，分别入栈。 奥你用的是数组然后赋值给e再入栈，我再仔细看看scanf的定义去，谢谢啦

我去这么复杂，我不敢看都~ 我就查了查用递归写

引用 2 楼 小付同学哦的回复:我去这么复杂，我不敢看都~ 我就查了查用递归写  我是自学算法时候书上的代码，嘿嘿谢谢啦

引用 1 楼 赵4老师的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。 我试着改，都改了好几天了，还是不能运行下去，才想着求助的……我回去再调着看看吧，谢谢啦


Question: 请教大神一个关于定义结构体的简单问题

重新把书再看一遍。

有变量名，没有类型名。

你定义的结构体如果后别不在需要定义其他的结构体变量，可以像你那样定义，不设置标志名，但是如果你后边还要使用它定义其他的结构体变量，你就要设置上标志，你的 struct  info{char name[20]; char number[20;]} 如果你的number是个字符串的话（应该就是，因为你后边用了gets()去读取），要用char定义。

struct info {     char name[10];     int number[20]; }wyl[N];  结构体类型就是struct info,之所以会报错是因为类型没名字。 后面定义结构体普通变量还是指针变量，都是struct info 作为类型； struct info *p;  struct info b;


Question: 返回值总是不正确

引用 29 楼 jack960330 的回复:[quote=引用 28 楼 cfjtaishan 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 函数内申明函数是可以的，但是不建议这么做，对于代码可读性会很差，也不利于代码维护。建议还是放在函数外。放在源文件头，或者单独建头文件。[/quote] +1[/quote]谢谢了

引用 28 楼 cfjtaishan 的回复:[quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 函数内申明函数是可以的，但是不建议这么做，对于代码可读性会很差，也不利于代码维护。建议还是放在函数外。放在源文件头，或者单独建头文件。[/quote] +1

引用 5 楼 jack960330 的回复:[quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 函数内申明函数是可以的，但是不建议这么做，对于代码可读性会很差，也不利于代码维护。建议还是放在函数外。放在源文件头，或者单独建头文件。

%lf？确定不是%f？

把你的WalletPay的实现发上来看看

VS IDE中，在不明白的符号上点鼠标右键，选查找所有引用。

引用 22 楼 qq_28869995 的回复:[quote=引用 15 楼 jack960330 的回复:] [quote=引用 13 楼 a393062456 的回复:] [quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] NONONO，你没弄懂他的逻辑，如果他的逻辑是调用，那么这里改成调用，最后就能得到正确的值。我的猜测是他可能在调用的时候直接复制了前面定义的函数名，但是忘记把参数改掉了。[/quote] 我想你说的这种情况不太可能，调用和声明的写法差别也太大了，更何况，他如果这是调用，那前面的返回类型是什么鬼？？？？[/quote]我那个前面是声明,调用是用struct里的函数指针调用的.[/quote] 直到刚才，我才完全看明白

引用 22 楼 qq_28869995 的回复:[quote=引用 15 楼 jack960330 的回复:] [quote=引用 13 楼 a393062456 的回复:] [quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] NONONO，你没弄懂他的逻辑，如果他的逻辑是调用，那么这里改成调用，最后就能得到正确的值。我的猜测是他可能在调用的时候直接复制了前面定义的函数名，但是忘记把参数改掉了。[/quote] 我想你说的这种情况不太可能，调用和声明的写法差别也太大了，更何况，他如果这是调用，那前面的返回类型是什么鬼？？？？[/quote]我那个前面是声明,调用是用struct里的函数指针调用的.[/quote] 看来你也发现了。。你帮忙找找，walletPay函数到底在哪定义的？？？

引用 15 楼 jack960330 的回复:[quote=引用 13 楼 a393062456 的回复:] [quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] NONONO，你没弄懂他的逻辑，如果他的逻辑是调用，那么这里改成调用，最后就能得到正确的值。我的猜测是他可能在调用的时候直接复制了前面定义的函数名，但是忘记把参数改掉了。[/quote] 我想你说的这种情况不太可能，调用和声明的写法差别也太大了，更何况，他如果这是调用，那前面的返回类型是什么鬼？？？？[/quote]我那个前面是声明,调用是用struct里的函数指针调用的.

哦，我明白他的逻辑了

我晕。。不是吧？？？？？？？？？？楼主啊，你的程序到底咋写的啊。。。。

引用 17 楼 a393062456 的回复:[quote=引用 15 楼 jack960330 的回复:] [quote=引用 13 楼 a393062456 的回复:] [quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] NONONO，你没弄懂他的逻辑，如果他的逻辑是调用，那么这里改成调用，最后就能得到正确的值。我的猜测是他可能在调用的时候直接复制了前面定义的函数名，但是忘记把参数改掉了。[/quote] 我想你说的这种情况不太可能，调用和声明的写法差别也太大了，更何况，他如果这是调用，那前面的返回类型是什么鬼？？？？[/quote] 类型是他自己写的一个钱包类。我的猜测是他想写一个类似QQ钱包的东西。而且他这调用我猜是直接复制的前面定义的函数头，然后忘记改了[/quote] 你怎么知道他类型是一个类？？？他发来的偏偏没有那个类型的定义

引用 16 楼 jack960330 的回复:[quote=引用 14 楼 a393062456 的回复:] [quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] 你只考虑了程序的表面，并没有根据整个程序的逻辑去推敲他可能的目的。[/quote] 你说的这个可能性不高。[/quote] 至于是不是，等他自己来就知道了

引用 15 楼 jack960330 的回复:[quote=引用 13 楼 a393062456 的回复:] [quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] NONONO，你没弄懂他的逻辑，如果他的逻辑是调用，那么这里改成调用，最后就能得到正确的值。我的猜测是他可能在调用的时候直接复制了前面定义的函数名，但是忘记把参数改掉了。[/quote] 我想你说的这种情况不太可能，调用和声明的写法差别也太大了，更何况，他如果这是调用，那前面的返回类型是什么鬼？？？？[/quote] 类型是他自己写的一个钱包类。我的猜测是他想写一个类似QQ钱包的东西。而且他这调用我猜是直接复制的前面定义的函数头，然后忘记改了

引用 14 楼 a393062456 的回复:[quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] 你只考虑了程序的表面，并没有根据整个程序的逻辑去推敲他可能的目的。[/quote] 你说的这个可能性不高。

引用 13 楼 a393062456 的回复:[quote=引用 12 楼 jack960330 的回复:] [quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] NONONO，你没弄懂他的逻辑，如果他的逻辑是调用，那么这里改成调用，最后就能得到正确的值。我的猜测是他可能在调用的时候直接复制了前面定义的函数名，但是忘记把参数改掉了。[/quote] 我想你说的这种情况不太可能，调用和声明的写法差别也太大了，更何况，他如果这是调用，那前面的返回类型是什么鬼？？？？

引用 12 楼 jack960330 的回复:[quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] 你只考虑了程序的表面，并没有根据整个程序的逻辑去推敲他可能的目的。

引用 12 楼 jack960330 的回复:[quote=引用 11 楼 a393062456 的回复:] [quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。[/quote] NONONO，你没弄懂他的逻辑，如果他的逻辑是调用，那么这里改成调用，最后就能得到正确的值。我的猜测是他可能在调用的时候直接复制了前面定义的函数名，但是忘记把参数改掉了。

引用 11 楼 a393062456 的回复:[quote=引用 10 楼 jack960330 的回复:] [quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。[/quote] 所以我才说你把重点搞错了，不管他后面是否有这样的不合常理的声明，都不影响他的结果，因此，你的问题对解决此问题毫无意义，不好意思，我可能说的有点直白。

引用 10 楼 jack960330 的回复:[quote=引用 9 楼 a393062456 的回复:] [quote=引用 8 楼 jack960330 的回复:] [quote=引用 7 楼 jack960330 的回复:] [quote=引用 6 楼 a393062456 的回复:] [quote=引用 5 楼 jack960330 的回复:] [quote=引用 4 楼 a393062456 的回复:] [quote=引用 2 楼 jack960330 的回复:] [quote=引用 1 楼 a393062456 的回复:]  这两个地方是什么意思，函数的内部函数？还是说你本意是调用这两个函数？ 如果是函数调用，不是这么写的，应该是banksave(value1,value2)这种形式， 你这写的啥都不是，怎么可能得到结果 函数声明啊。。。你自己不会连这都没看明白吧，函数体里声明函数是可以的[/quote] 好，你说是函数声明，那么看看你前面的savebank的实现，你的amout在程序里面用到了， 但你在哪里调用了这个savebank()?在哪里给savebank这个函数的参数传值了？[/quote] 第一，问题并不是我提出的；第二，你说的这根本不是重点。函数定义肯定是在外部的，函数内声明函数是可以的 [/quote] 那你回个屁啊，没看到我前面开始提的是问他到底是内部函数的声明还是调用？用的是提问的方式？学好语文吧[/quote] 第一，我还是要指出，你的语气很容易伤到别人，不是正常的说话方式；其次，人家明摆着是函数指针啊。。你自己看不明白说人家写的不对。。。。。。[/quote] 函数声明，sorry 打错了 [/quote] 好吧，我语气不对。首先，你说我看不懂，我确实看不懂，所以我用了提问的方式。其次，我看不懂的原因不是因为语法看不懂，你去看他整个程序，有先定义再声明这种用法？再次，整个程序，他有调用过这个函数？我看了整个程序，所以才有这个疑问，所以问他。请问你看了整个程序吗[/quote] 当然看啦 ，要不我要怎么解决问题呢，很可惜的是，他并没有将完整的程序发出来，所以我不是也问楼主了么，他那个类型是什么类型。，。。当然了，老实说，他这个程序我确实也没完全看明白，但是现在，我们并不是要解答这个程序用来干什么，是用来练习也好，还是做实际开发也好，我们现在最重要的是要解答他的问题，那就是为什么输出不对，语法没问题，肯定是什么地方的处理逻辑有问题。[/quote] 所以我才问他到底是调用还是内部函数的声明啊。而且看他这通篇程序的逻辑，他是想通过finpft()这个函数调用banksave,finaceprofit()这两个函数，计算出本金和利息。然后再打印出来。按逻辑应该是调用，但我不确定。所以才问。而且没道理前面都定义了，这里面再来两个声明。


Question: 关于C程序底层宏相关调试的问题

#define MAX(a,b)  ((a)>(b)?(a):(b))

#define MAX(a,b)  (a>b?a:b) 宏定义就是等价替换，debug直接到（a >b ? a: b)不可以吗？

VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898

debug调试也是在程序生成可执行程序后的，而宏定义是在预编译阶段，预编译阶段就是还没有生命目标文件（.o文件）；因为预编译阶段对于宏是等价替换，debug调试可以直接到替换后的代码。


Question: 求大佬看看，哪错了，怎么连输入都不行

#include<stdio.h> int main() {     int m, n, i, j;     char k[100] = {0}, a, b;     scanf("%d%d", &m, &n);     getchar();     for(i = 0; i < m; i++)         scanf("%c", &k[i]);     getchar();     for(i = 0; i < n; i++) {         scanf("%c %c", &a, &b);         for(j = 0; j < m; j++) {             if(k[j] == a)                 k[j] = b;             else if(k[j] == b)                 k[j]=a;         }         getchar();     }     for(i = 0; i < m; i++)         printf("%c",k[i]); return  0; }  还是%c搞的鬼，因为输入后回车符还在输入缓存里，下次的%c会吸收'\n'，另外，scanf(%c %c", &a, &b);根据样例需要加个空格。 建议对于字符数组，直接使用fgets输入，这样可以规避这个问题。


Question: printf什么都没有打出来？

哇哇哇 问过那个问题之后好久没有上来了 刚刚看到好多回复好感动 还没有细看大家的回答 现谢谢大家啦！！！！！！！

再供参考：//将c:\\tmp文件夹下的所有文件的内容全部放到用malloc分配的内存中 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <io.h> struct FB {     char fn[256];     size_t fl;     char *b;     struct FB *next;     struct FB *prev; } *fh,*fb,*ft; char ln[256]; char fpn[256]; FILE *af; FILE *f; int L,n; int main() {     system("dir /b /a-d c:\\tmp\\*.* >c:\\allfn.txt");     af=fopen("c:\\allfn.txt","r");     if (NULL==af) {         printf("Can not open file c:\\allfn.txt!\n");         return 1;     }     fh=NULL;     fb=NULL;     n=0;     while (1) {         if (NULL==fgets(ln,256,af)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) ln[L-1]=0;         printf("read %s\n",ln);         strcpy(fpn,"c:\\tmp\\");         strcat(fpn,ln);         ft=(struct FB *)malloc(sizeof(struct FB));         if (NULL==ft) {             printf("Can not malloc ft!\n");             fclose(af);             return 2;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]==%p\n",n,ft);         strcpy(ft->fn,fpn);         f=fopen(fpn,"rb");         if (NULL==f) {             printf("Can not open file %s!\n",fpn);             fclose(af);             return 3;//之前的malloc在main退出后由操作系统自动free         }         ft->fl=_filelength(fileno(f));         ft->b=malloc(ft->fl);         if (NULL==ft->b) {             printf("Can not malloc ft->b!\n");             fclose(f);             fclose(af);             return 4;//之前的malloc在main退出后由操作系统自动free         }         printf("ft[%d]->b==%p\n",n,ft->b);         if (ft->fl!=fread(ft->b,1,ft->fl,f)) {             printf("fread error!\n");             fclose(f);             fclose(af);             return 5;//之前的malloc在main退出后由操作系统自动free         }         fclose(f);         ft->next=NULL;          if (NULL==fh) {             ft->prev=NULL;             fh=ft;         } else {             fb->next=ft;             ft->prev=fb;         }         fb=ft;         n++;     }     fclose(af);     printf("-----list-----\n");     for (ft=fh;NULL!=ft;ft=ft->next) {         printf("%8d %s\n",ft->fl,ft->fn);         if (NULL!=ft) fb=ft;     }     printf("-----free-----\n");     n--;     if (NULL!=fh) {         for (ft=fb->prev;NULL!=ft;ft=ft->prev) {             if (NULL!=ft->next->b) {                 printf("ft[%d]->b==%p\n",n,ft->next->b);                 free(ft->next->b);             }             if (NULL!=ft->next) {                 printf("ft[%d]==%p\n",n,ft->next);                 free(ft->next);             }             n--;         }         if (NULL!=fh->b) {             printf("ft[0]->b==%p\n",fh->b);             free(fh->b);         }         printf("ft[0]==%p\n",fh);         free(fh);     }     return 0; } //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //找不到文件 // //C:\tmp\tmp\Debug>tmp //找不到文件 //-----list----- //-----free----- // //C:\tmp\tmp\Debug>dir /a-d c:\tmp // 驱动器 C 中的卷是 C_HD5_1 // 卷的序列号是 1817-D526 // // c:\tmp 的目录 // //2011-06-30  18:04            44,840 my_c.rar //2011-06-30  17:18             1,036 err.frm //2011-06-30  14:32            14,243 出租.txt //2011-06-28  12:08            23,681 MSDN98书签.txt //             4 个文件         83,800 字节 //             0 个目录 17,041,870,848 可用字节 // //C:\tmp\tmp\Debug>tmp //read my_c.rar //ft[0]==00421800 //ft[0]->b==00520068 //read err.frm //ft[1]==00421670 //ft[1]->b==0052AFC0 //read 出租.txt //ft[2]==00421530 //ft[2]->b==00378F28 //read MSDN98书签.txt //ft[3]==004213F0 //ft[3]->b==0052B3F8 //-----list----- // 44840 c:\tmp\my_c.rar //  1036 c:\tmp\err.frm // 14243 c:\tmp\出租.txt // 23681 c:\tmp\MSDN98书签.txt //-----free----- //ft[3]->b==0052B3F8 //ft[3]==004213F0 //ft[2]->b==00378F28 //ft[2]==00421530 //ft[1]->b==0052AFC0 //ft[1]==00421670 //ft[0]->b==00520068 //ft[0]==00421800 // //C:\tmp\tmp\Debug>

仅供参考：//不带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next; } *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;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             p=q;         }     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         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;             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;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         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;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         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;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个单链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         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=q;             q=q1;             if (NULL==q) break;         }         head=p;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         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;     s->next=q1;     q->next=NULL;      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16-> //将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16-> //删除第5个节点:08->74->05->07->03->99->31->56->88->16-> //从小到大排序:03->05->07->08->16->31->56->74->88->99-> //将整个链表逆序:99->88->74->56->31->16->08->07->05->03-> //将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56-> //

引用 1 楼 自信男孩的回复:很可能是存的时候出的问题； 因为其他没问题，只有这个有问题； 建议提供一下赋值的部分逻辑，以及结构体的信息； 刚刚找错找哭了

list->before是字符串类型不？

函数没什么问题，最好是把完整的代码发一下，不然很难看出哪里出问题了的。

引用 2 楼 desertion76 的回复:[quote=引用 1 楼 自信男孩的回复:]很可能是存的时候出的问题； 因为其他没问题，只有这个有问题； 建议提供一下赋值的部分逻辑，以及结构体的信息； 刚刚找错找哭了[/quote] 你能字节不停尝试和思考，已经很不错了；不要气馁，慢慢来，遇到问题，解决问题，总结问题，反反复复，摔倒了再爬起来，然后总结一下，可以学到新的东西，慢慢对编程就会领会，加油吧~ 有问题，就提出来；

代码没有什么问题，但是这样递归有点麻烦呀感觉，不如在用个循环。

估计是数据本身的问题，单步调试下


Question: vc6.0中编译错误

可以使用malloc,realloc申请内存，用free释放

malloc,realloc,free

C语言不支持可变数组； 建议，将数组定义成一个定长的，然后通过输入n，nn来确定使用数组的多少元素； 比如，将数组长度定义成宏，长度为10，你输入的n,nn是小于等于10的就可以了。

数组的长度必须是 const 表达式或者 字面值。 n，或者nn都是非const变量，是不能用作数组的长度。 也就是说 doubel arr[2]是没有问题的，但是int n =2;doubel arr[n]是错的。 如果可以的话使用vs2012这样的集成开发环境来学习c++，vc6就不要用了。


Question: c语言指针问题，

#include <stdio.h> #include <stdlib.h>  #define STACK_INIT_SIZE 32 #define STACKINCREMENT 10  #define TRUE 1 #define FALSE 0  typedef char SElemType; typedef struct node {     SElemType *base;     SElemType *top;     int stacksize; }Sqstack;  typedef enum ret {     ERROR = -1,        OK = 0, }Status;  //栈的顺序存储表示 Status InitStack(Sqstack *L) {     //构造一个空栈     (*L).base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));     if(!(*L).base)         exit(ERROR);     (*L).top = (*L).base;     (*L).stacksize = STACK_INIT_SIZE;      return OK; } Status DestroyStack(Sqstack *L) {     if((*L).top == (*L).base)         return ERROR;     free((*L).base);     (*L).base = NULL;     return OK; } //清空栈 Status ClearStack(Sqstack *L) {     (*L).top = (*L).base;     return OK; } //判断栈是否为空 int IsEmpty(Sqstack *L) {     if((*L).top == (*L).base)         return TRUE;     else         return FALSE; }  int StackLength(Sqstack *L) {      if((*L).top != (*L).base)         return  (*L).top - (*L).base;     else         return 0; }  Status GetTop(Sqstack *L,SElemType *e) {     if((*L).top != (*L).base)         *e = *((*L).top - 1);     return OK; } //插入元素为e的新元素 Status Push(Sqstack *L,SElemType e) {     if((*L).top - (*L).base >= (*L).stacksize)     {         (*L).base = (char *)realloc((*L).base, ((*L).stacksize + STACKINCREMENT) * sizeof(char));         if(!(*L).base)             return ERROR;         (*L).stacksize += STACKINCREMENT;     }     *((*L).top) = e;     (*L).top++;      return OK; }  Status Pop(Sqstack *L,SElemType *e) {     if (!IsEmpty(L))         *e = *(--L->top);     return OK; } //遍历栈中的元素 Status StackTravers(Sqstack *L, void(* vi)(SElemType)) {     if((*L).top == (*L).base)         return ERROR;     while((*L).top > (*L).base)     {         vi(*(*L).base);         (*L).base++;     }     return 0; } #if 0 //算法3.1数制转换 void conversion() {     Sqstack s;     int mod,n,e;     InitStack(&s);//初始化栈     scanf("%d",&n);//等待用户输入     //printf("%d",n);     while(n)//进行8进制的转换     {         mod = n % 8;         n =  n/ 8;         Push(&s,mod);     }     while(!IsEmpty(&s))//输出结果     {         Pop(&s,&e);         printf("%d\n",e);     }     printf("\n"); } #endif //算法3.2.2括号匹配检验 Status check() {     Sqstack s;     char ch[80], *p, e;      if(!InitStack(&s))//初始化栈成功     {         printf("请输入一个表达式：\n");         fgets(ch, 80, stdin);         p = ch;         while (*p)//没有到串尾              switch(*p) {                 case '(':                 case '[':                     Push(&s,*p++);                     break;                  case ')':                 case ']':                     if(!IsEmpty(&s)) {                         Pop(&s,&e);                         if((*p == ')' && e!='(')|| (*p== ']'&& e!= '[')) {                             printf("左右括号不匹配\n");                             exit(ERROR);                         } else {                             p++;                             break;                         }                     } else {                         printf("缺乏左括号\n");                         exit(ERROR);                     }                     break;                  default:                     p++;             }     }     if(IsEmpty(&s))//字符串结束时栈空         printf("括号匹配\n");     else         printf("右括号不匹配\n");     return OK; }   int main() {     check();     return 0; } 问题还比较多，以上是我的demo，对比一下吧～

贴出更多一些的代码，并且将你的测试用例贴一下；

代码太多就没全贴，将pop函数注释掉后，*p的值就没有发生变化，pop是对栈进行操作的，为什么*p的值也会改变呢？


Question: 字符串反转问题

终于明白了，非常感谢上楼。

while(head != '\0') //这个判断应该错误 应该是 while(head<=tail)

非常感谢，谢谢！

//问题要求：请将一个字符串反转后，然后输出。  #include <stdio.h> #include <string.h>  void f(char * q) {     char p[10] = "Hello";     char *head = p;     char *tail = q + strlen(q) - 1;       *(head + strlen(q)) = '\0';     while(head != '\0')     {         *head = *tail;         head ++;         tail --;     }     printf("%s\n", p); }   void reverse(char *str);  int main(void) {     char a[] = "abcdefg";      //f(a);     reverse(a);      puts(a);     return 0; }   void reverse(char *str) {     int tmp;     char *head, *tail;      if (!str)         return;     head = str;     tail = str + strlen(str) - 1;      while (head < tail) {         tmp = *head;         *head = *tail;         *tail = tmp;         head++;         tail--;     } } head指向字符串头，tail指向字符串末个字符；两个一个加，一个减，所以在中间某个位置，会有head >= tail，所以是判断head < tail作为退出条件;  另外，main函数里a指向只读区域（常量），所以不能修改。需要改一下，不然会出现段错误。

还是有点不明白，可以发一下源代码吗？

char* head = p;            char* tail = q + strlen(q) - 1;//这里也要注意一下*的位置 char *head会指向指针所指的内容， char* head 才是指针本身的赋值      while(head < tail){ char tem = *head; *head = *tail;            //头等于尾，尾要等于头啊，这才是调转 *tail = tem;         head ++;         tail --; }   你这种写法，head的值以及被tail覆盖了，那当循环到要用到head原来的值的地方怎么办？


Question: 请教一个关于类型强制转换的问题

引用 4 楼 zhao4zhong1 的回复:理解和讨论之前请先学会如何观察！  //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]  引用 4 楼 zhao4zhong1 的回复:理解和讨论之前请先学会如何观察！  //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]  引用 4 楼 zhao4zhong1 的回复:理解和讨论之前请先学会如何观察！  //char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]   说实话，这个弄得太高深了，没有看懂，不过还是多谢 。

学习了,多谢各位。

只是表示一个函数指针，返回值为int参数为空。

是一个函数指针类型，参数为空，且返回值为int的函数指针

函数指针，可指向返回值为int、参数为空的函数


Question: 新手提问

这个问题你来错地方了 http://jingyan.baidu.com/article/3ea51489e562bb52e61bbab0.html


Question: Beginner恒：在ASCLL码的使用过程中出现了一些最起初的问题

引用 3楼赵4老师 的回复:仅供参考：#pragma comment(lib,"user32") #pragma comment(lib,"gdi32") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> wchar_t a2w[256]={ 0x0020,0x263a,0x263b,0x2665,0x2666,0x2663,0x2660,0x2022, 0x25d8,0x25cb,0x25d9,0x2642,0x2640,0x266a,0x266b,0x263c, 0x25ba,0x25c4,0x2195,0x203c,0x00b6,0x00a7,0x25ac,0x21a8, 0x2191,0x2193,0x2192,0x2190,0x221f,0x2194,0x25b2,0x25bc, 0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027, 0x0028,0x0029,0x002a,0x002b,0x002c,0x002d,0x002e,0x002f, 0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037, 0x0038,0x0039,0x003a,0x003b,0x003c,0x003d,0x003e,0x003f, 0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047, 0x0048,0x0049,0x004a,0x004b,0x004c,0x004d,0x004e,0x004f, 0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057, 0x0058,0x0059,0x005a,0x005b,0x005c,0x005d,0x005e,0x005f, 0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067, 0x0068,0x0069,0x006a,0x006b,0x006c,0x006d,0x006e,0x006f, 0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077, 0x0078,0x0079,0x007a,0x007b,0x007c,0x007d,0x007e,0x2302, 0x00c7,0x00fc,0x00e9,0x00e2,0x00e4,0x00e0,0x00e5,0x00e7, 0x00ea,0x00eb,0x00e8,0x00ef,0x00ee,0x00ec,0x00c4,0x00c5, 0x00e9,0x00e6,0x00c6,0x00f4,0x00f6,0x00f2,0x00fb,0x00f9, 0x00ff,0x00d6,0x00dc,0x00a2,0x00a3,0x00a5,0x20a7,0x0192, 0x00e1,0x00ed,0x00f3,0x00fa,0x00f1,0x00d1,0x00aa,0x00ba, 0x00bf,0x2310,0x00ac,0x00bd,0x00bc,0x00a1,0x00ab,0x00bb, 0x2591,0x2592,0x2593,0x2502,0x2524,0x2561,0x2562,0x2556, 0x2555,0x2563,0x2551,0x2557,0x255d,0x255c,0x255b,0x2510, 0x2514,0x2534,0x252c,0x251c,0x2500,0x253c,0x255e,0x255f, 0x255a,0x2554,0x2569,0x2566,0x2560,0x2550,0x256c,0x2567, 0x2568,0x2564,0x2565,0x2559,0x2558,0x2552,0x2553,0x256b, 0x256a,0x2518,0x250c,0x2588,0x2584,0x258c,0x2590,0x2580, 0x03b1,0x00df,0x0393,0x03c0,0x03a3,0x03c3,0x00b5,0x03c4, 0x03a6,0x0398,0x03a9,0x03b4,0x221e,0x03c6,0x03b5,0x2229, 0x2261,0x00b1,0x2265,0x2264,0x2320,0x2321,0x00f7,0x2248, 0x00b0,0x2219,0x00b7,0x221a,0x207f,0x00b2,0x25a0,0x00ff, }; extern "C" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t ws[256];     unsigned char s[256];     int i;       system("color F0");     system("cls");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(16,  0, 0, 0, 0, 0, 0, 0, 0           , 0, 0, 0, 0, "Lucida Console");     SelectObject(hdc,hfont);     TextOutW(hdc,10,10,L"你好",2);     for (i=0;i<256;i++) s[i]=i;     for (i=0;i<256;i++) ws[i]=a2w[s[i]];     TextOutW(hdc,10, 40,ws    ,32);     TextOutW(hdc,10, 80,ws+ 32,32);     TextOutW(hdc,10,120,ws+ 64,32);     TextOutW(hdc,10,160,ws+ 96,32);     TextOutW(hdc,10,200,ws+128,32);     TextOutW(hdc,10,240,ws+160,32);     TextOutW(hdc,10,280,ws+192,32);     TextOutW(hdc,10,320,ws+224,32);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system("color 07");     system("cls");     ShowTheCursor();     return 0; }  你好，我看不懂啊！

引用 1楼幻夢之葉 的回复:1：在我机子上是可以输出心形的 putchar('\n'); 或者 printf("\n"); 换行  2： scanf("%f,&f"); 改为 scanf("%f",&f); //变量不用在双引号内  还有一个要指出 是ASCII， 不是ASCLL那为什么我的输出不了呢，配置问题嘛？还是系统问题

换个简单点的：#include <conio.h> #include <stdlib.h> int main() {     int i;      system("chcp 437 >NUL");     for (i=0;i<256;i++) {         if (i==0x08 || i==0x09 || i==0x0A || i==0x0D)             cprintf(" ");         else             cprintf("%c",i);         if (i%32==31) cprintf("\r\n");     }     return 0; }


Question: C语言尾插法，为什么我输入'"王一，123，却输出乱码，文件里也是乱码

#include <stdio.h> #include <stdlib.h> #include <string.h>  #define     NAME_LEN   10 #define     TEL_LEN    12  typedef struct Node {     char n[NAME_LEN];     char t[TEL_LEN];     struct Node* next; }Node, *Linklist;  void InitLinklist(Linklist* L) {     *L = (Linklist)malloc(sizeof(Node));     (*L)->next = NULL; }  void CreateLinklist(Linklist L) {     Node *r, *s;     char in[10];     char it[12];      r = L;     printf("请输入顾客姓名，电话号码:\n");     scanf("%s",in);     scanf("%s",it);     while(in[0]!='0') {         s = (Linklist)malloc(sizeof(Node));         strncpy(s->n, in, NAME_LEN);         strncpy(s->t, it, TEL_LEN);         r->next = s;         r = s;         printf("请输入顾客姓名，电话号码:\n");         scanf("%s",in);         scanf("%s",it);     }     r->next = NULL; } int WriteLinklistToFile(const char* strFile, Linklist L) {     FILE *fpFile;     Linklist head = L->next;      if(!(fpFile = fopen(strFile,"a"))) {         printf("Open file failed\n");         return 0;     }     while(head) {         fprintf(fpFile,"%s\t%s\n",head->n, head->t);         head = head->next;     }     fclose(fpFile);      return 1; }; int ReadFromFile(const char* strFile) {     FILE *fpFile;     if (!(fpFile = fopen(strFile,"r")))     {         printf("Open file failed\n");         return 0;     }     printf("The contents of File are:\n");     while (!feof(fpFile))         putchar(fgetc(fpFile));      fclose(fpFile);     return 1; } void Destroy(Linklist L) {     Linklist p = L, tmp;     while (p) {         tmp = p->next;         free(p);         p = tmp;     } } int main() {     char* strName = "曾经顾客信息.txt";     Linklist L;      InitLinklist(&L);     CreateLinklist(L);     WriteLinklistToFile(strName, L);     ReadFromFile(strName);     Destroy(L);      return 0; }

好感谢,终于解决了

//s->n[0] = in[0]; //指向了临时变量，退出后会被销毁，你n的指向将会的内容是不可预测的 //s->t[0] = it[0]; strcpy(s->n, in); //char* 请使用strcpy函数进行深拷贝 strcpy(s->t, it);


Question: 加了free()报错

nclude "stdafx.h" #include<string.h> #include<stdlib.h> #define N 50  char *join1(char *,char *);   int _tmain(int argc, _TCHAR* argv[]) {     char *string1;     char *string2;     char *string3;     string1 = (char *)malloc(sizeof(char)*N);     string2 = (char *)malloc(sizeof(char)*N);     //string3 = (char *)malloc(sizeof(char)*N);     printf("请输入字符串1：");     gets(string1);     printf("请输入字符串2：");     gets(string2);     string3 = join1(string1,string2);     printf("%s\n",string3);     free(string1);     free(string2);     string3 = NULL;      return 0; }  char *join1(char *string1, char *string2) {     int i,j;     int count1,count2;     static char temp[50];     count1 = strlen(string1);     count2 = strlen(string2);       for(i=0;i<count1;i++)     {         temp[i] = *string1;         string1++;     }     for(i=count1;i<count1+count2;i++)     {         temp[i] = *string2;         string2++;     }     temp[count1+count2] = '\0';      return temp; } string3不用申请空间；因为它是用于指向静态变量temp的，若申请，找不到释放的地方，反而会造成内存泄漏； 静态变量在数据段申请，不能用free释放；程序结束后，系统会释放数据段的空间。 string1,string2需要free掉； 因为其是堆上的空间；

引用 1 楼 twintiger 的回复:string3 = join1(string1,string2);这句话使得前面string3 = (char *)malloc(sizeof(char)*N);分配的地址泄漏，再也没有机会free掉了。  string3=join(string,string2)实际上srting3指向静态地址temp,当然不能free了。  另外，你是string1++，srting2++也使得这两个malloc的区域首部没有指针指向他们了，同样会造成内存泄漏。  用指针和malloc，free要特别小心。 请教： 1、“string3=join(string,string2)实际上srting3指向静态地址temp,当然不能free了“  意思是string3不用free了么？ 2、“string1++，srting2++也使得这两个malloc的区域首部没有指针指向他们了，同样会造成内存泄漏。” 那应该怎么操作，才能避免内存泄漏？

引用 4 楼 sinat_14884161 的回复:二楼说的关于string3没有问题，但是string2和sring1有问题。 楼主的话，建议把书仔细看看，有些概念不是很清楚  int _tmain(int argc, _TCHAR* argv[]) {     char *string1;     char *string2;     char *string3;     string1 = (char *)malloc(sizeof(char)*N);     string2 = (char *)malloc(sizeof(char)*N); 	//可以注释掉这句话     //string3 = (char *)malloc(sizeof(char)*N);     printf("请输入字符串1：");     gets(string1);     printf("请输入字符串2：");     gets(string2); 	//string3 指向了join1中 temp变量的地址，不再是由malloc返回的地址 	//在C，c++中 free只能对由malloc函数返回的变量进行操作 	//这也就是为什么 在 之后的free（string3）会报错的原因 	//事实上这里的sring3 可以不需要malloc分配空间，因为分配的空间，你并没有使用  	//注意这里传入string1和string2并不会改变两个实参中的地址，在下面free是不会有问题 	//因为在这里join1都是拷贝了实参的值，是join1函数中string1和string2都是实参的拷贝     string3 = join1(string1,string2);     printf("%s\n",string3);    	//在这里调用free没有问题 	free(string2); 	free(string1);      string3 = NULL; 	system("pause");          return 0; }   是的，join函数里面string1和string2是作为指针的值参传入的，在函数体里面加减不影响返回后string1和string2，如果对指针指向的内容修改会影响到返回后的主程序。因此可以free。

你试图free一个static char[]

string3 = join1(string1,string2); 你的string3已经指向了新的内存地址，而不是你malloc得到的了，free自然出错


Question: isdigit()函数

[quote=引用 1 楼 cfjtaishan 的回复:] 因为isdigit是判断字符的，而l是整型数，所以返回0； 字符‘1’~'9'是十六进制0x30~0x39,即48～57；


Question: scanf的参数中加入\n会怎样？例如scanf("%f\n",a)

Format Specification Fields: scanf and wscanf Functions A format specification has the following form:  % [width] [{h | l | I64 | L}]type  The format argument specifies the interpretation of the input and can contain one or more of the following:   White-space characters: blank (' '); tab ('\t'); or newline ('\n'). A white-space character causes scanf to read, but not store, all consecutive white-space characters in the input up to the next non–white-space character. One white-space character in the format matches any number (including 0) and combination of white-space characters in the input.   Non–white-space characters, except for the percent sign (%). A non–white-space character causes scanf to read, but not store, a matching non–white-space character. If the next character in stdin does not match, scanf terminates.   Format specifications, introduced by the percent sign (%). A format specification causes scanf to read and convert characters in the input into values of a specified type. The value is assigned to an argument in the argument list.  The format is read from left to right. Characters outside format specifications are expected to match the sequence of characters in stdin; the matching characters in stdin are scanned but not stored. If a character in stdin conflicts with the format specification, scanf terminates, and the character is left in stdin as if it had not been read.  When the first format specification is encountered, the value of the first input field is converted according to this specification and stored in the location that is specified by the first argument. The second format specification causes the second input field to be converted and stored in the second argument, and so on through the end of the format string.  An input field is defined as all characters up to the first white-space character (space, tab, or newline), or up to the first character that cannot be converted according to the format specification, or until the field width (if specified) is reached. If there are too many arguments for the given specifications, the extra arguments are evaluated but ignored. The results are unpredictable if there are not enough arguments for the format specification.  Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, determines whether the input field is interpreted as a character, a string, or a number.   The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign (%) is followed by a character that has no meaning as a format-control character, that character and the following characters (up to the next percent sign) are treated as an ordinary sequence of characters, that is, a sequence of characters that must match the input. For example, to specify that a percent-sign character is to be input, use %%.  An asterisk (*) following the percent sign suppresses assignment of the next input field, which is interpreted as a field of the specified type. The field is scanned but not stored.

引用 2 楼 TIMEJP 的回复:[quote=引用 1 楼 幽兰星梦的回复:]不要加换行符，在scanf中加换行符不是表示接受一个回车符，而是表示忽略所有的空白字符 我昨天试了下，scanf("%f %f\n"&a, &b)，这样既是你是正确输入的话scanf也会叫你多输入一次[/quote]   '\n' 是新行键，光标换到下一行

引用 1 楼 幽兰星梦的回复:不要加换行符，在scanf中加换行符不是表示接受一个回车符，而是表示忽略所有的空白字符 我昨天试了下，scanf("%f %f\n"&a, &b)，这样既是你是正确输入的话scanf也会叫你多输入一次

这个一试便知

加了\n后，你输入一个数后，它是不会立即显示的，要等再接收到一个非（空格、制表符、回车）的输入scanf语句才结束。


Question: 大神这题思路什么？怎么解题

引用 5 楼 a393062456 的回复:按输入的每个数字的第一位排序，第一位最大的排最前面，然后按照顺序拼接 这里没说完，第一位相同的再比较第二位，以此内推

按输入的每个数字的第一位排序，第一位最大的排最前面，然后按照顺序拼接

求数字位数，数字拼接，遍历循环

#include <stdio.h> #include <string.h>  #define     ROW     10 #define     COL     12  void  sort_num_list(char (*num)[COL], int len);  int main(void) {     char num_list[ROW][COL];     int i;     int n;      printf("Please input the number of sample:");     scanf("%d", &n);      for (i = 0; i < n; i++)         scanf("%s", num_list[i]);      sort_num_list(num_list, n);      for (i = 0; i < n; i++)         printf("%s", num_list[i]);     putchar(10);      return 0; }  void  sort_num_list(char (*num)[COL], int len) {     int i, j;     int max_i;     char tmp[COL];      for (i = 0; i < len - 1; i++) {         max_i = i;         for (j = i+1; j < len; j++)             if (strcmp(num[max_i], num[j]) < 0)                 max_i = j;         if (max_i != i) {             strncpy(tmp, num[max_i], COL);             strncpy(num[max_i], num[i], COL);             strncpy(num[i], tmp, COL);         }     } } 字符串模拟整型数。 该程序还可以继续优化，比如输入的非数字，可以重新输入等等。

上机考试题发来这里问，太慢了，还不如直接QQ发到同学，让同学搜百度快

百度搜相关关键字。


Question: 回调函数使用中void (*)表示什么啊

谢谢大家，会尽快给分的

前面之所以说这种定义方式不严谨，的确如你所想，它是可以传入任何整数值的，后续当成函数指针调用，也是可以随意指定参数的，这样会有很大风险。但还是那句话：void*本身，无关参数。

所谓指针，你可以简单理解为地址。当然，一般情况下，指针一层含义，就是size，用于实现增，或者减。  唯独void指针，是没有size的，所以，你可以将它强制转为任何size的指针，或者把任何size的指针转为它。这样做当然是有风险的，size信息在转换中丢失，若你前后的size不一致，则可能会导致非法内存访问。   仅看它“地址”这一层含义。函数指针，也是指针，只不过程序不是按这个地址去取值，而是跳到这个地址去执行代码。所以，你传入void(*)若是一个函数指针，应该算是没有参数的，因为这里没有任何函数参数传递时的入栈出栈（当然你也可以手动完成，还是有很大风险）。  总的来说，void(*)只代表了本身可以是任意类型，若是函数指针，它管不到参数头上去。

始终与参数无关。前者传的是函数指针，后者传的是指针。 引用 7 楼 u013910218 的回复:[quote=引用 3 楼 vnvlyp 的回复:] 你那个定义不是很严谨而已 https://linux.die.net/man/3/libnids，这里写的是 void nids_register_tcp(void (*tcp_func)(struct tcp_stream *ts, void **param));  这样写 void nids_register_tcp(void (*)); 会接受任何指针类型(void *)，哪怕并不是一个函数，编译器也不会报错   也就是说void(*)可以接收任何类型的函数了？？ 而不管函数的返回值类型、参数个数和参数类型？？？？[/quote]

不是的，函数会调指针的类型是  type (*)(parament) 以类型和表达式规则来看   首先(*)表明是一个指针，其次 type表示这个指针的类型是type 后面的(parament)表明这个东西有参数是函数指针。。。 所以这是执行参数为(parament) 返回值是type的函数地址的一个指针

引用 6 楼 super_admi 的回复:与参数无关。参数在后面有限制，除非你使用不定参数类型。  引用 4 楼 u013910218 的回复:也就是说void(*)可以接受所有类型的函数了？不管他的返回值和参数个数以及参数类型？？ 谢谢

引用 3 楼 vnvlyp 的回复:你那个定义不是很严谨而已 https://linux.die.net/man/3/libnids，这里写的是 void nids_register_tcp(void (*tcp_func)(struct tcp_stream *ts, void **param));  这样写 void nids_register_tcp(void (*)); 会接受任何指针类型(void *)，哪怕并不是一个函数，编译器也不会报错   也就是说void(*)可以接收任何类型的函数了？？ 而不管函数的返回值类型、参数个数和参数类型？？？？

引用#4也是就说void(*)可以接受所有类型的函数吗？不管函数的返回值和参数类型以及参数个数吗？

感觉函数指针指向的函数参数少了。

这个（void(*))表示这个参数是个函数指针，也就是把你的回调函数传进入。


Question: 求大神帮助解答问题

引用 1 楼 zhao4zhong1 的回复:仅供参考：#include <stdio.h> #include <string.h> #define MAXLEN 1000 char ln[MAXLEN]; FILE *f; int i,z; int b,n,L; int main(int argc,char **argv) {     if (argc<2) {         printf("Usage:%s fullpathfilename.ext\nget total blank/non-blank/total linenumbers.\n",argv[0]);         return 1;     }     f=fopen(argv[1],"r");     if (NULL==f) {         printf("Can not open file [%s]!\n",argv[1]);         return 2;     }     z=0;     b=0;     n=0;     L=0;     while (1) {         if (NULL==fgets(ln,MAXLEN,f)) break;         L=strlen(ln);         if ('\n'==ln[L-1]) {             if (0==z) {                 for (i=0;i<L-1;i++) {                     if (!(' '==ln[i] || '\t'==ln[i])) break;                 }                 if (i<L-1) z=1;//当前行不是空行             }             if (0==z) b++; else n++;             z=0;         } else {             if (0==z) {                 for (i=0;i<L;i++) {                     if (!(' '==ln[i] || '\t'==ln[i])) break;                 }                 if (i<L) z=1;//当前行不是空行             }         }     }     fclose(f);     if (L>0 && '\n'!=ln[L-1]) {         if (0==z) b++; else n++;//最后一行末尾无'\n'也计算     }     printf("File:[%s] total blank/non-blank/total linenumbers is %d/%d/%d\n",argv[1],b,n,b+n);     return 0; }   虽然目前看不懂，还是谢谢了


Question: c语言中的格式化占位符到底是什么意思？

结果不同应该是溢出了。 运算式是整形的。

http://blog.csdn.net/richerg85/article/details/20456969 参考一下这位仁兄的博客

这个值是12，那么在内存单元就是以0101这样的二进制序列表示的。输出到终端（显示器），是什么值要看你以什么格式输出了；意思，在内存中存放的二进制都是一样的，不同的地方是输出方式。该程序以%d输出就是12，但是以%f输出，那么就要将12的二进制按照浮点数的表示形式输出，但是浮点数和整型数在内存中表示是不一样的，它有整数和小数部分。 建议你熟悉一下浮点型在内存中的表示，然后将12的二进制数放到浮点型的表示里，就能知道为啥输出的不一样了。

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

%号加后面的字符表示要调用什么类型的代码块(比如int，char)每个代码块的处理方式不同 ，所以出的结果不同 http://blog.csdn.net/a29562268/article/details/56331674 参考printf函数实现代码

程序本身是定义为 int 类型，如果你用 %f 的话，可能会导致数据溢出。

#include <stdio.h> #include <stdlib.h>  int main(){     int  a=3;     int b=4;     //printf("result:%f",a+b%(a+b)/a+a*b-b);	     printf("result:%d",a+b%(a+b)/a+a*b-b);		//在这里，我们最好用 %d 的形式，因为你定义的类型是 int 型 	return 0; }

我要提醒楼主的是，可能是C语言运算符和结合性的问题，建议你查一下C语言运算符的优先级。


Question: ACM数学手稿

你的算法复杂了把~~ x+y+z = a; 3x+2y+z = b; 先算出x 的取值范围：[0, (b - a - y) / 2]也就是[0, (b - a) / 2] 循环一次即可： for (x: 0->(b - a) / 2)   y + z = a - x;  2y + z = b - 3x;  然后再解二元一次方程即可了啊 最后得出，x, y, z的值

引用 1 楼 user-2 的回复:这不是一个单纯行问题的简化版吗？为啥要用三个循环嵌套？如果变量很多，你岂不是要一堆的嵌套？那就死定了。 那该用什么呢？


Question: 判断回文，输入一组字符串，如果是回文，则输出YES，否则输出NO，，，朋友们大神帮我看一下

引用 3 楼 sinat_24853299 的回复:引用 2 楼 user-5 的回复:我要提醒楼主，一定要注意了，在C语言中，如果要想使用字符串，一定要定义一个数组来存储字符串，因为在C语言中没有字符串类型，所以我们只能用数组来存储了。  谢谢，请问什么时候用#include<string.h> 该头文件是声明一些用于处理字符串的库函数，比如计算字符串长度：strlen,字符串拷贝：strcpy, strncpy,字符串比较：strcmp,strncmp等等

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

if (i < j) { printf("YES");  } else { printf("NO"); }

char a;  改成：  char a[100];

引用 6 楼 user-5 的回复:在使用字符串函数时要包含头文件 <string.h>,因为使用字符函数时，关于一些字符串函数的定义则全部包含在这个头文件里面，所以我们要在程序的开头声明此头文件。谢谢，这个可以看一下吗 //将字符串中除了下标为偶数同时asc值也为偶数的字符外，其余全部删除 #include<stdio.h> main()  { 	int i=0, j=0,c; 	char a[255]; 	char b[255]; 	gets(a); 	for (i = 0; i <= strlen(a); i++)  	{ 		c = a[i];                                              //可能是这的问题 		if ((i % 2 != 1) && (c % 2 !=1)) 		{ 			b[j] = a[i]; 			printf("%c", b[j]); 			 		} 		j++; 	} 	 }

C语言里面关于字符数组的函数定义的头文件，常用函数有strlen、strcmp、strcpy等等，更详细的可以到include文件夹里面查看该文件。

引用 1 楼 user-5 的回复:#include <stdio.h> #include<string.h> void main() { 	int i=0 ; 	//char a; 	char a[20]; 	//gets(a); 	gets(a); 	int j = strlen(a) - 1; 	while (i <= j) 	{ 		if (a[i] == a[j])        //i和j下面有波浪线显示：表达式必须包含指向对象的指针类型 		{ 			i++; 			j--; 		} 		else 		break;  	} 	if (i >= j) 	{ 		printf("YES"); 	} 	else 	{ 		printf("NO"); 	} 	//怎么改啊    } 好了，谢谢


Question: 结构体指针作为函数的返回值时，为什么不需要用空格分隔返回值类型和函数名？

这两个空格加不加都是可以的，怎么写是你的代码格式的问题，指针的话，一般都是挨着函数名或变量。当然不挨着的话也不会有任何问题，这就是你的习惯问题了。

这两个空格都可以没有，也都可以加。  C 语言只有在不加会引起歧义的时候才必须加空格。比如： int main vs intmain 。int b vs intb。其它的地方都可以去掉。（所以你帖子里程序中的 intb 是错误的）  这也包括回车和缩进。空白字符在程序中更多的作用是让程序看起来更清晰。

函数名和后面的左括号可以不加空格，怎么写这是属于coding style的问题。就是代码格式的问题，结构体指针，一般都是将*加在靠近（紧挨着）函数名或变量。 这些都是coding sytle的范畴，不影响编译和运行。 最后，建议要有自己的固定的代码风格。可以参考Linux内核的coding style.


Question: 关于指向字符串数据的指针，以及GTK程序问题

引用 3 楼 cfjtaishan 的回复:[quote=引用 2 楼 m0_37789286 的回复:] [quote=引用 1 楼 cfjtaishan 的回复:] g_print是%s输出的是字符串，就是数据，只不过%s就应该是是地址。 但后面的b_gains,b_points 是指针   将指针输出？那输出的不应该是字符窜的首地址吗？  [/quote] %s就是从指针指向的地址开始输出，直到遇到\0结束输出。 这些指针变量存放的是gtk_entry_get_text得到的字符串的首地址。 %s就是把首地址开始的字符一个个输出到终端，直到遇到字符串结束标记。[/quote] 啊 是这样   非常感谢  我没有理解好这个  ，那如果我想将这个字符串的内容进行运算  就可以取×p_points然后循环取出了吧  谢谢你的回答，很有帮助！

引用 2 楼 m0_37789286 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] g_print是%s输出的是字符串，就是数据，只不过%s就应该是是地址。 但后面的b_gains,b_points 是指针   将指针输出？那输出的不应该是字符窜的首地址吗？  [/quote] %s就是从指针指向的地址开始输出，直到遇到\0结束输出。 这些指针变量存放的是gtk_entry_get_text得到的字符串的首地址。 %s就是把首地址开始的字符一个个输出到终端，直到遇到字符串结束标记。

引用 1 楼 cfjtaishan 的回复:g_print是%s输出的是字符串，就是数据，只不过%s就应该是是地址。 但后面的b_gains,b_points 是指针   将指针输出？那输出的不应该是字符窜的首地址吗？


Question: program warning(1:4668)，这个错误代码是什么意思

贴一下你的程序