Mxode/CSDN-C_Language-2013_2023 huggingface dataset:
user-0 提问: C语言strcpy()函数导致段错误

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

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

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

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

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

user: user-5
content: 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。
user-0 提问: 懂单片机C语言编程的大神看过，使用Keil uVision2编写串口打印功能时，编译无错误，运行时出现如下提示，这是什么原因？

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

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

user: user-0
content: 引用 3 楼 include_xy 的回复:引用 楼主 include_xy 的回复:你瞧我换成了整型，结果编译链接后出现这个提示

user: user-0
content: 引用 3 楼 include_xy 的回复:引用 楼主 include_xy 的回复:你瞧如果我想用浮点数，是不是需要重新安装keil？

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

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

user: user-0
content: 引用 楼主 include_xy 的回复:你瞧

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

user: user-3
content: 不给代码瞧瞧吗？
user-0 提问: 函数指针

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

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

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

user: user-4
content: cout<<"看了好几分钟，不好意思，没看明白"<<endl
user-0 提问: 怎样把一个字符串转化成一个数组

回复:
user: user-1
content: 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 );

user: user-2
content: char ch[10]=“abcd”;

user: user-2
content: ch[10]=“abcd”;

user: user-3
content: #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; } 两种方式都可以

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

user: user-5
content: char ch[10]; scanf("%9s",ch);
user-0 提问: C指针使用栈的问题

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

user: user-1
content: 若那样，S仅仅是一个指针，指向 struct stack类型的变量，但是指向什么地方，没有赋值确定。后来通过S往它所指的变量字段内存取数据，到底是哪里呢
user-0 提问: 小白第一次用递归，不知道哪里搞错了

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

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

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

user: user-4
content: 你把打印分两行写试试，也就是打印sum的话要在height（10）计算完毕之后。
user-0 提问: 链表 的拆分 ，老是不对，请指教

回复:
user: user-1
content: #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;     } }  注释多了，不一定能提高代码的可读性；代码过于臃肿，会降低可读性； 以上是个人的设计，作为一个参考吧～

user: user-2
content: 如果想算奇数和偶数的个数的话  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; 去掉那部分代码就行了。

user: user-2
content: 你想实现的功能是什么楼主
user-0 提问: 两个二级上的问题

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

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

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

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

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

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

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

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

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

user: user-2
content: #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等方式申请的； 每个函数之后都加一个";",这个是没必要的。
user-0 提问: make命令到链接这一步出错，各路大神帮忙看看。

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

user: user-2
content: -M是不是忘记删掉了
user-0 提问: 蓝桥杯历届例题，九宫重排

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

回复:
user: user-1
content: #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语言的精髓之处学习的如何。
user-0 提问: 新手自学C碰到个题不会做，

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

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

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

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

user: user-4
content: 用for循环吧。字数

user: user-5
content: void jolly() { 	printf("For he‘s a jolly good fellow!\n"); }  void deny() { 	printf("Which nobody can deny!\n"); } 好好看书吧，这是最简答的函数。 而且这样用函数没任何意义。

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

user: user-4
content: 如果相同的消息要打印100条，你会怎么写？
user-0 提问: c语言关于循环和递归解一元多项式的小问题

回复:
user: user-0

user: user-0
content: 。。。。。。。。。。。。。。。

user: user-0
content: 第一张图片有点不清晰，重发

user: user-1
content: ...... double    a[N]; ...... scanf("%lf", &a[i-1]); ...... fun1(N, a, x); ...... for(i=1; i<n; i++) ......  等
user-0 提问: 快速排序C语言

回复:
user: user-1
content: 同意楼上说法

user: user-2
content: 你这个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; }

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

user: user-0
content: 额，改进了为什么我的程序还是不能排正确呢？
user-0 提问: getchar()读取换行符

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

user: user-2
content: 因为随后的scanf取的格式是%d。如果是%c就必须有它了。
user-0 提问: C语言中如何实现数据隐藏？

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

回复:
user: user-1
content: 函数声明，建议不要放在main函数里，放在函数之外，main函数之上最好；

user: user-2
content: scoresort里的for循环的大括号不对称

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

user: user-4
content: 大括号不对称，这样改：   #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"); }

user: user-5
content: scoresort里面少了些 } 右大括号
user-0 提问: if-else运算

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

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

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

user: user-0
content: 引用 1楼ck2333 的回复:先判断b^2-4*a*c是大于0，还是等于0，还是小于0，如果大于0，则答案为两解，如果等于0，则为相同的两个解，如果小于0，则无解（解则用求根公式求）能给我写出来看看吗？

user: user-1
content: 先判断b^2-4*a*c是大于0，还是等于0，还是小于0，如果大于0，则答案为两解，如果等于0，则为相同的两个解，如果小于0，则无解（解则用求根公式求）
user-0 提问: linux 调用自己定义的函数静态库 的结果和放在一个程序里的调用函数的结果不一样了呢？

回复:
user: user-1
content: 括号太多，参数传递也有问题，有越界的嫌疑；

user: user-2
content: 引用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);     ^  你的函数没有声明。  默认的声明和你的函数定义不一致。

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

user: user-0
content: 问题已经解决，再建一个.h文件，声明一下就好了，感谢各位的解答，关于程序不简洁明了的问题我会尝试着改进的，感觉各位说的都很有受用，感谢！！
user-0 提问: c语言初学者编程的时候遇到个问题不会做求大神解答感激不尽

回复:
user: user-1
content: 输入的值保存到数组，然后for循环输出

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

user: user-3
content: 这种简单的小程序，一定要熟练的掌握 #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; }
user-0 提问: 文件格式化读取 。

回复:
user: user-1
content: #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; } 简单一些就好了，不需要那么多用于存放年月日，时分秒的数组变量。

user: user-0
content: 刚刚那个写错个地方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; }

user: user-0
content: 引用 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; } 谢谢 能不能顺便帮我看看这个函数有没有缺陷？

user: user-1
content: 原因是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

user: user-0
content: 有没有那种可以类似正则 的函数
user-0 提问: 字符数组字符串输出与读入

回复:
user: user-1
content: 数组分配是连续的空间，所以输出是you&me

user: user-2
content: 引用 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"

user: user-0
content: 引用 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 了吗？ 数组是这样存储的吧？ 我好像在书上看见过

user: user-2
content: 第一个问题：地址值是一样的，都是指数组的开始；但是类型不一样；arr是二维数组，表示的是二维数组的首地址，但是arr[0]可看成是一重指针。它是表示第一个字符数组的首地址（列的首地址）； 第二个问题：你的理解是正确的，strcpy后you后面是一个字符串结束标记，因为strcpy是会拷贝'\0'的，a[0][3] = ‘&';正好将'\0'覆盖； printf("%s ",arr);这句是有问题，%s输入应该是arr[0]; 之所以输出这样的结果，原因第一个字符串“you"后面的'\0'被覆盖了，%s输出时遇到'\0'才结束，所以输出"you&me"
user-0 提问: 关于‘\0’

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

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

user: user-3
content: 引用 楼主 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比较的版本

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

user: user-4
content: '\0'就是八进制0表示的字符，就等于0
user-0 提问: 数据结构—— 两个有序链表序列的合并

回复:
user: user-1
content: #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函数
user-0 提问: 请教大神一个关于定义结构体的简单问题

回复:
user: user-1
content: 重新把书再看一遍。

user: user-2
content: 有变量名，没有类型名。

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

user: user-4
content: struct info {     char name[10];     int number[20]; }wyl[N];  结构体类型就是struct info,之所以会报错是因为类型没名字。 后面定义结构体普通变量还是指针变量，都是struct info 作为类型； struct info *p;  struct info b;
user-0 提问: 关于C程序底层宏相关调试的问题

回复:
user: user-1
content: #define MAX(a,b)  ((a)>(b)?(a):(b))

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

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

user: user-2
content: debug调试也是在程序生成可执行程序后的，而宏定义是在预编译阶段，预编译阶段就是还没有生命目标文件（.o文件）；因为预编译阶段对于宏是等价替换，debug调试可以直接到替换后的代码。
user-0 提问: 求大佬看看，哪错了，怎么连输入都不行

回复:
user: user-1
content: #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输入，这样可以规避这个问题。
user-0 提问: vc6.0中编译错误

回复:
user: user-1
content: 可以使用malloc,realloc申请内存，用free释放

user: user-2
content: malloc,realloc,free

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

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

回复:
user: user-0
content: 终于明白了，非常感谢上楼。

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

user: user-0
content: 非常感谢，谢谢！

user: user-2
content: //问题要求：请将一个字符串反转后，然后输出。  #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指向只读区域（常量），所以不能修改。需要改一下，不然会出现段错误。

user: user-0
content: 还是有点不明白，可以发一下源代码吗？

user: user-3
content: 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原来的值的地方怎么办？
user-0 提问: C语言尾插法，为什么我输入'"王一，123，却输出乱码，文件里也是乱码

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

user: user-0
content: 好感谢,终于解决了

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

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

user: user-1
content: 因为isdigit是判断字符的，而l是整型数，所以返回0； 字符‘1’~'9'是十六进制0x30~0x39,即48～57；
user-0 提问: 大神这题思路什么？怎么解题

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

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

user: user-2
content: 求数字位数，数字拼接，遍历循环

user: user-3
content: #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);         }     } } 字符串模拟整型数。 该程序还可以继续优化，比如输入的非数字，可以重新输入等等。

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

user: user-4
content: 百度搜相关关键字。
user-0 提问: 回调函数使用中void (*)表示什么啊

回复:
user: user-0
content: 谢谢大家，会尽快给分的

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

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

user: user-1
content: 始终与参数无关。前者传的是函数指针，后者传的是指针。 引用 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]

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

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

user: user-0
content: 引用 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(*)可以接收任何类型的函数了？？ 而不管函数的返回值类型、参数个数和参数类型？？？？

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

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

user: user-0
content: 也就是说void(*)可以接受所有类型的函数了？不管他的返回值和参数个数以及参数类型？？

user: user-3
content: 你那个定义不是很严谨而已 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 *)，哪怕并不是一个函数，编译器也不会报错

user: user-4
content: 感觉函数指针指向的函数参数少了。

user: user-5
content: 这个（void(*))表示这个参数是个函数指针，也就是把你的回调函数传进入。
user-0 提问: 求大神帮助解答问题

回复:
user: user-0
content: 引用 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; }   虽然目前看不懂，还是谢谢了

user: user-1
content: 仅供参考：#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; }
user-0 提问: c语言中的格式化占位符到底是什么意思？

回复:
user: user-1
content: 结果不同应该是溢出了。 运算式是整形的。

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

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

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

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

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

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

user: user-5
content: 我要提醒楼主的是，可能是C语言运算符和结合性的问题，建议你查一下C语言运算符的优先级。
user-0 提问: ACM数学手稿

回复:
user: user-1
content: 你的算法复杂了把~~ 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的值

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

user: user-2
content: 这不是一个单纯行问题的简化版吗？为啥要用三个循环嵌套？如果变量很多，你岂不是要一堆的嵌套？那就死定了。
user-0 提问: 判断回文，输入一组字符串，如果是回文，则输出YES，否则输出NO，，，朋友们大神帮我看一下

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

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

user: user-3
content: if (i < j) { printf("YES");  } else { printf("NO"); }

user: user-4
content: char a;  改成：  char a[100];

user: user-0
content: 引用 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++; 	} 	 }

user: user-5
content: 在使用字符串函数时要包含头文件 <string.h>,因为使用字符函数时，关于一些字符串函数的定义则全部包含在这个头文件里面，所以我们要在程序的开头声明此头文件。

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

user: user-0
content: 引用 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"); 	} 	//怎么改啊    } 好了，谢谢

user: user-0
content: 引用 2 楼 user-5 的回复:我要提醒楼主，一定要注意了，在C语言中，如果要想使用字符串，一定要定义一个数组来存储字符串，因为在C语言中没有字符串类型，所以我们只能用数组来存储了。  谢谢，请问什么时候用#include<string.h>

user: user-5
content: 我要提醒楼主，一定要注意了，在C语言中，如果要想使用字符串，一定要定义一个数组来存储字符串，因为在C语言中没有字符串类型，所以我们只能用数组来存储了。

user: user-5
content: #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"); 	} 	//怎么改啊    }
user-0 提问: 结构体指针作为函数的返回值时，为什么不需要用空格分隔返回值类型和函数名？

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

user: user-2
content: http://bbs.csdn.net/topics/392094659

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

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

回复:
user: user-0
content: 引用 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然后循环取出了吧  谢谢你的回答，很有帮助！

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

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

user: user-1
content: g_print是%s输出的是字符串，就是数据，只不过%s就应该是是地址。