Question: 链表实现过程中的一个段错误

。。初始化。。

line 50:  t = head; // t = head->next; // 跳过头节点，头节点不含data，data是野指针 line 57: t = head->next ; // t = t->next;

参考用~  #include <stdio.h> #include <stdlib.h>  struct node *creat(struct node *head); void Output(struct node *head); struct node  { 	int data; 	struct node *next; }; int main() { 	struct node *head; 	head=NULL; 	head=creat(head); 	Output(head);  	return 0; } struct node *creat(struct node *head){  	int i,LEN; 	struct node *p,*s; 	printf("请先创建链表\n"); 	printf("请输入链表的长度："); 	scanf("%d",&LEN); 	 	if(LEN>=1){ 		for(i=1;i<=LEN;i++){		 			if(NULL==(p=(struct node *)malloc(sizeof(struct node *)))) 			{ 				printf("内存申请失败！\n"); 			} 			 			if(head==NULL) 				s=head=p; 			printf("请输入第%d个结点中的数据：",i); 			scanf("%d",&p->data); 			p->next=NULL; 			s->next=p; 			s=p; 		} 	}return (head); } void Output(struct node *head) { 	struct node *temp; 	temp=head; 	while(temp!=NULL) 	{ 		printf("%d->",temp->data); 		temp=temp->next; 	} }

仅供参考：//带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //18->94->58->17->27->20->43->57->75->78-> //18->94->05->58->17->27->20->43->57->75->78-> //18->94->05->58->27->20->43->57->75->78-> //05->18->20->27->43->57->58->75->78->94-> //43->57->58->75->78->94->05->18->20->27-> //

已解决  我的head没初始化就访问 所以造成错误

嗯  这是一个错误。。。但是改了之后 还是会出现段错误。。。

t = head->next ;这句改成t=t->next;


Question: 求助！关于C语言程序设计。

但是，一定要贴好代码。

引用 2 楼 mugunagyu 的回复:在这个论坛上，不管你是什么目的，不要直接求答案，若在什么方面不会，指出具体问题，大家才可能帮助你，不然，你问大家，是不会得到你想要的答案 没有这么严肃的啦，娱乐点，哈


Question: 奇怪的输出结果~~求解，内附代码

引用 4 楼 lin5161678 的回复:output.c 这个文件没有写函数 sin_value 的声明 所以错了  你把output.c 文件改为这样 #include <stdio.h> #include <stdlib.h> #include <math.h>  double sin_value(double angle); double sin_value2(double angle){     return sin(angle); }   int main(void){     printf("%f\n", sin_value((double)30*3.14159/180));     printf("%f\n", sin_value2((double)30*3.14159/180));       return EXIT_SUCCESS; } 就没什么问题了 ----------------------------------------------------------------------------- 善！

引用 2 楼 JiangWenjie2014 的回复:函数返回的类型是double，但是打印的类型是%f ------------------------------------------------------------------------- 肯定不是这个问题，改成lf也试过的，问题在于内部那个函数时对的，外部的sin_value不对~~

引用 2 楼 JiangWenjie2014 的回复:函数返回的类型是double，但是打印的类型是%f本来就应该用 %f  别误导新人了

引用 1 楼 user-3 的回复:你用两个变量分别保存值之后打印两个变量再试试 ------------------------------------------------------------------------------------------- [root@localhost 20150629]#  [root@localhost 20150629]# ./output  629614304.000000 0.500000 [root@localhost 20150629]#  [root@localhost 20150629]#  [root@localhost 20150629]# cat output.c  #include <stdio.h> #include <stdlib.h> #include <math.h>  double sin_value2(double angle){ 	return sin(angle); }  int main(void){ 	double value = sin_value((double)30*3.14159/180); 	double value2 = sin_value2((double)30*3.14159/180);  	printf("%f\n", value); 	printf("%f\n", value2);  	/*printf("%f\n", sin_value((double)30*3.14159/180)); 	printf("%f\n", sin_value2((double)30*3.14159/180)); 	*/ 	return EXIT_SUCCESS; } [root@localhost 20150629]#    结果更奇怪~~~是环境问题么？好费解啊。

函数返回的类型是double，但是打印的类型是%f

你用两个变量分别保存值之后打印两个变量再试试


Question: DEFUN 怎么定义支持不定长参数的函数

Access variable-argument lists.

DEFUN (modify_phyif_type,         modify_phyif_type_cmd,         "modify phyif type /*    网卡数   网卡名   类型   网卡名   类型   */",         "modify physical type\n"         ".....\n"         ".....\n") {     return CMD_SUCCESS; }    我只是想知道第三行        /* */     之间该怎么写？  或者是能不能这么写？

老赵老师，我没有问   vsprintf怎么用，你写这么一大推有什么用？  引用 4 楼 zhao4zhong1 的回复:va_arg, va_end, va_start Access variable-argument lists.  type va_arg( va_list arg_ptr, type );  void va_end( va_list arg_ptr );  void va_start( va_list arg_ptr );   (UNIX version)  void va_start( va_list arg_ptr, prev_param );   (ANSI version)  Routine Required Header Optional Headers Compatibility  va_arg <stdio.h> and <stdarg.h> <varargs.h>1 ANSI, Win 95, Win NT  va_end <stdio.h> and <stdarg.h> <varargs.h>1 ANSI, Win 95, Win NT  va_start <stdio.h> and <stdarg.h> <varargs.h>1 ANSI, Win 95, Win NT    1 Required for UNIX V compatibility.  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  va_arg returns the current argument; va_start and va_end do not return values.  Parameters  type  Type of argument to be retrieved  arg_ptr  Pointer to list of arguments  prev_param  Parameter preceding first optional argument (ANSI only)  Remarks  The va_arg, va_end, and va_start macros provide a portable way to access the arguments to a function when the function takes a variable number of arguments. Two versions of the macros are available: The macros defined in STDARG.H conform to the ANSI C standard, and the macros defined in VARARGS.H are compatible with the UNIX System V definition. The macros are:  va_alist  Name of parameter to called function (UNIX version only)  va_arg  Macro to retrieve current argument  va_dcl  Declaration of va_alist (UNIX version only)  va_end  Macro to reset arg_ptr  va_list  typedef for pointer to list of arguments defined in STDIO.H  va_start  Macro to set arg_ptr to beginning of list of optional arguments (UNIX version only)  Both versions of the macros assume that the function takes a fixed number of required arguments, followed by a variable number of optional arguments. The required arguments are declared as ordinary parameters to the function and can be accessed through the parameter names. The optional arguments are accessed through the macros in STDARG.H or VARARGS.H, which set a pointer to the first optional argument in the argument list, retrieve arguments from the list, and reset the pointer when argument processing is completed.  The ANSI C standard macros, defined in STDARG.H, are used as follows:   All required arguments to the function are declared as parameters in the usual way. va_dcl is not used with the STDARG.H macros.   va_start sets arg_ptr to the first optional argument in the list of arguments passed to the function. The argument arg_ptr must have va_list type. The argument prev_param is the name of the required parameter immediately preceding the first optional argument in the argument list. If prev_param is declared with the register storage class, the macro’s behavior is undefined. va_start must be used before va_arg is used for the first time.   va_arg retrieves a value of type from the location given by arg_ptr and increments arg_ptr to point to the next argument in the list, using the size of type to determine where the next argument starts. va_arg can be used any number of times within the function to retrieve arguments from the list.   After all arguments have been retrieved, va_end resets the pointer to NULL.  The UNIX System V macros, defined in VARARGS.H, operate somewhat differently:   Any required arguments to the function can be declared as parameters in the usual way.   The last (or only) parameter to the function represents the list of optional arguments. This parameter must be named va_alist (not to be confused with va_list, which is defined as the type of va_alist).   va_dcl appears after the function definition and before the opening left brace of the function. This macro is defined as a complete declaration of the va_alist parameter, including the terminating semicolon; therefore, no semicolon should follow va_dcl.   Within the function, va_start sets arg_ptr to the beginning of the list of optional arguments passed to the function. va_start must be used before va_arg is used for the first time. The argument arg_ptr must have va_list type.   va_arg retrieves a value of type from the location given by arg_ptr and increments arg_ptr to point to the next argument in the list, using the size of type to determine where the next argument starts. va_arg can be used any number of times within the function to retrieve the arguments from the list.   After all arguments have been retrieved, va_end resets the pointer to NULL.  Example  /* VA.C: The program below illustrates passing a variable  * number of arguments using the following macros:  *      va_start            va_arg              va_end  *      va_list             va_dcl (UNIX only)  */  #include <stdio.h> #define ANSI            /* Comment out for UNIX version     */ #ifdef ANSI             /* ANSI compatible version          */ #include <stdarg.h> int average( int first, ... ); #else                   /* UNIX compatible version          */ #include <varargs.h> int average( va_list ); #endif  void main( void ) {    /* Call with 3 integers (-1 is used as terminator). */    printf( "Average is: %d\n", average( 2, 3, 4, -1 ) );     /* Call with 4 integers. */    printf( "Average is: %d\n", average( 5, 7, 9, 11, -1 ) );     /* Call with just -1 terminator. */    printf( "Average is: %d\n", average( -1 ) ); }  /* Returns the average of a variable list of integers. */ #ifdef ANSI             /* ANSI compatible version    */ int average( int first, ... ) {    int count = 0, sum = 0, i = first;    va_list marker;     va_start( marker, first );     /* Initialize variable arguments. */    while( i != -1 )    {       sum += i;       count++;       i = va_arg( marker, int);    }    va_end( marker );              /* Reset variable arguments.      */    return( sum ? (sum / count) : 0 ); } #else       /* UNIX compatible version must use old-style definition.  */ int average( va_alist ) va_dcl {    int i, count, sum;    va_list marker;     va_start( marker );            /* Initialize variable arguments. */    for( sum = count = 0; (i = va_arg( marker, int)) != -1; count++ )       sum += i;    va_end( marker );              /* Reset variable arguments.      */    return( sum ? (sum / count) : 0 ); } #endif   Output  Average is: 3 Average is: 8 Average is: 0   Argument Access Routines  See Also   vfprintf

引用 1 楼 user-2 的回复:int printf(const char *format, ...); 你可以参考一下prinft()函数 也可以定义一个结构体或指针    怎么定义数组或者指针？

定义为数组试试


Question: 最华丽的C语言控制台俄罗斯方块（win32）

支持

学习学习，被惊艳到了/

引用 78 楼 ZHUCEYGCSDN 的回复:请楼主分享代码  谢谢喽  书里可以下载原始代码，你可以试着修改一下，改自己的效果。

引用 91 楼 qiushuihuanhuanliu 的回复:哇！作为一个新手，真是惊呆了呢！

哇！作为一个新手，真是惊呆了呢！

引用 89 楼 li964357908 的回复:主要还是对于windows.h这个头文件的调用吧，应该不设计到什么算法问题。 算法问题就是书上讲的，基本上俄罗斯方块的实现算法应该都差不多，不外乎方块的内存表示、显示、左移、右移、下移、旋转、行满消行等。

主要还是对于windows.h这个头文件的调用吧，应该不设计到什么算法问题。

引用 73 楼 qq_30874199 的回复:很强大，谢谢代码。 书里可以下载原始代码，你可以试着修改一下，改自己的效果。

好 给个我要积分

不错，给楼主一个赞

真的好强大,good

不错。顶顶！

大家都喜欢用C/C++写俄罗斯方块和贪吃蛇

请楼主分享代码  谢谢喽

哇 真的好强大,楼主厉害啊！


Question: select模型中select（）的用法

客户端的 addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.0");  请改为  addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");  就可以通讯了

lz解决了没

#由Windows版移至本版#


Question: C语言 程序需改

while(*srcstr!='\0') *dststr++=*stcstr++; *dststr='\0';

#include<stdio.h> void MyStrcpy(char *dstStr, const char *srcStr); int main(void) { 	char srcStr[100], detStr[100]; 	printf("please input string :"); 	gets(srcStr); 	MyStrcpy(detStr, srcStr); 	printf("copied string is:"); 	puts(detStr); 	return 0; } void  MyStrcpy(char *dstStr, const char *srcStr) { 	if (dstStr && srcStr) 	{ 		while (*dstStr++ = *srcStr++); 	} }

#include<stdio.h>  void MyStrcpy(char *dstStr, const char *srcStr);  int main(void) {      char srcStr[100], detStr[100];       printf("please input string :");      gets(srcStr);      MyStrcpy(detStr, srcStr);      printf("copied string is:");      puts(detStr);       return 0; }  void  MyStrcpy(char *dstStr, const char *srcStr) {     while(*srcStr != '\0')         {             *dstStr=*srcStr;             srcStr++;             dstStr++;         }     *dstStr = '\0'; } 其实前面的人已经解答了，我就把完整的程序写了一遍 改动的地方用的是粗体

吧if改成while，否则只能复制一个字符。

指针可以直接赋值，如果你要用取值符*循环复制的话 就要用循环了。就是3L说的那样。

引用 4 楼 todo9351 的回复: if (you want to upload code) {     please use this format. } else {     nobody want to see your problem. }

/*********Found************/ while (*srcStr != '\0') {  /*********Found************/ *dstStr = *srcStr;

引用 1 楼 zxhuser-8 的回复:有啥问题呢？需要在Found 下面修改程序 Found下面的代码有错。

有啥问题呢？


Question: 关于指针函数

非常感谢。豁然开朗！谢谢

有源代码好多了…因为你cast的是一个函数指针所以必须要前种方式

因为你是强制转化，强制转化的语法就是：(强转类型)被强转量 强转类型是函数，所以语法是：(函数原型)被强转量 而你的被强转量是个表达式，所以就变成 ：(函数原型)(被强转表达式)

是个快排序函数 #include <stdio.h> #include <string.h> #define MAXLINES 5000  //待排序最大行数 char *lineptr[MAXLINES]; //指向文本行的指针 int readlinel(char *lineptr[], int nlines); void writelines(char *lineptr[], int nlines); void qsort(void *lineptr[], int left, int right, int (*comp)(void *, void *)); //排序函数 int numcmp(char *, char *); int main(int argc, char *argv[]) { 	int nlines;    //读入的输入行数 	int numeric = 0;    //若进行数值排序，numerric 为1 	if(argc > 1 && strcmp(argv[1], "-n") == 0) 	    numeric = 1; 	if((nlines = readlines(lineptr, MAXLINES)) >= 0) 	{ 		qsort((void **)lineptr, 0, nlines - 1,  		   (int (*)(void *, void *))(numeric ? numcmp : strcmp)); 		writelines(lineptr, nlines); 		return 0;    	}    	else 	{ 		printf("input too big to sort\n"); 		return 1; 	} } void qsort(void *v[], int left, int right,            int (*comp)(void *, void *)) { 	int i, last; 	void swap(void *v[], int, int); 	if(left >= right) 	    return; 	swap(v, left, (left + right) / 2); 	last = left;  	for(i = left + 1; i <= right; i++) 	   if((*comp)(v[i], v[left]) < 0) 	      swap(v, ++last, i); 	swap(v, left, last); 	qsort(v, left, last - 1, comp); 	qsort(v, last + 1, right, comp);	                                                                               }

仅供参考：//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]

木见过这种语法？mark！


Question: c语言中,输入任意字符串,任意空格隔开

引用 4 楼 ysb00 的回复:二楼的代码解决了问题,但是str[sz-2]=c;str[sz-1]=0;是什么?????????? str用来保存输入的字符串，其容量为sz，下标的范围是0~sz-1，其中str[sz-2]是字符串的最后一个字符，str[sz-1]是字符串的结尾标识'\0'。我这里用getchar()一个字符一个字符的获取，动态扩展str，将getchar()获得的字符c赋值给str的最后一个字符str[sz-2]，最后设置一下字符串的结尾str[sz-1]=0;//0=='\0'

仅供参考：#include <stdio.h> char s[]="123 ab 4"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,"%d%n",&v,&n);         printf("k,v,n=%d,%d,%d\n",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf("skip char[%c]\n",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf("End.\n"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.

#include<stdio.h> #include<string.h> #include<malloc.h> int main() {     size_t sz=1,i;     char* str=(char*)malloc(sz*sizeof(char)),*p,c;     if(!str)return 1;     while((c=getchar())!='\n')     {         p=(char*)realloc(str,++sz*sizeof(char));         if(!p){free(str);return 1;}         str=p;         str[sz-2]=c;     }     str[sz-1]=0;     i=0;     for(p=strtok(str," ");p;p=strtok(NULL," "))         printf("%4lu:%s\n",(unsigned long)++i,p);     free(str);     return 0; }

scanf（） %s


Question: C语言指针操作数组

引用 8 楼 mugunagyu 的回复:其实1编程并不麻烦，只是需要你多练，而且不要灰心，今天在你之上的人 不一定永远在你之上 我们最好担心，这样的事情有可能

#include <stdio.h> //#pragma warning(disable:4996) //#pragma warning(disable:4113)  int main() {     char s[20] = "Hello";     char *p = s;     p++;     printf("%c\n", *p);     getchar();     return 0; } 其实1编程并不麻烦，只是需要你多练，而且不要灰心，今天在你之上的人 不一定永远在你之上

vs看到的地址包含的内容,不是单个char

首先应该是 p = s,不用取s的地址 其次，你调试窗口中打印的是p而不是 *p

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

引用 1 楼 user-7 的回复:因为你不是这么写的：char* p = s; 数组名就是起始地址，不需要再次&。  不对，我把&去点之后还是那样

引用 2 楼 du123926750 的回复:以下，个人理解： char *p； （1）指向了内存中的常量区，存储内容“ello”的首地址； （2）编译器在显示指针类型内存时，默认遇到'\0'截止；  换成char s[20] = "He\0llo"; 可以达到楼主的目的。


Question: 关于 LINUX mbstowcs  与 WINDOWS MultiByteToWideChar 转换过程

对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  // UTF-8 编码字符理论上可以最多到 6个字节长，但目前全世界的所 // 有文字和符号种类加起来也只要编到 4个字节长就够了。 // 　　UTF-8 是以 8位（即 1个字节）为单元对原始码进行编码（注意一 // 点：这里所讲的原始码都是指Unicode码），并规定：多字节码（2个字 // 节以上才称为多字节）以转换后第1个字节起头的连续“1”的数目（这 // 些连续“1”称为标记位），表示转换成几个字节：“110”连续两个 // “1”，表示转换结果为2个字节，“1110”表示3个字节，而“11110” // 则表示4个字节……跟随在标记位之后的“0”，其作用是分隔标记位和 // 字符码位。第2～第4个字节的起头两个位固定设置为“10”，也作为标 // 记，剩下的6个位才做为字符码位使用。 // 　　这样，2字节UTF-8码剩下11个字符码位，可用以转换0080～07FF的 // 原始字符码，3字节剩下16个字符码位，可用以转换0800～FFFF的原始字 // 符码，由此类推。编码方式的模板如下： // // 原始码（16进制）　UTF－8编码（二进制） // -------------------------------------------- // 0000 - 007F       0xxxxxxx // 0080 - 07FF       110xxxxx 10xxxxxx // 0800 - FFFF       1110xxxx 10xxxxxx 10xxxxxx // …… // -------------------------------------------- // // 　　模板中的“x”表示字符码。 // 　　Ascii码＜007F，编为1个 // 字节的UTF－8码。汉字的 Unicode编码范围为0800－FFFF，所以被编为 // 3个字节的UTF－8码。 // 　　例如“汉”字的Unicode编码是6C49，6C49在0800-FFFF之间，所以 // 要用3个字节的模板：1110wwww 10xxxxyy 10yyzzzz。  //    6    C    4    9 // 0110 1100 0100 1001 // wwww xxxx yyyy zzzz //     wwww   xxxxyy   yyzzzz // 1110wwww 10xxxxyy 10yyzzzz。 // 11100110 10110001 10001001 //    E   6    B   1    8   9 //“汉”字的UTF-8编码是E6 B1 89

引用 1 楼 mydo 的回复:是把utf-8转成神马？utf-16还是utf-32，最好搞清楚正确编码格式  就是怎么实现   两个字节 0x00000011 0x00000062 转 一个字节 0x00006211  还有怎么实现 一个字节 0x00006211 转 两个字节 0x00000011 0x00000062  是不是涉及到位运算，求解

而且mbstowcs不是神马linux下的，应该是c标准库里的函数，如果我没记错的话

是把utf-8转成神马？utf-16还是utf-32，最好搞清楚正确编码格式


Question: error C2143: syntax error : missing ')' before 'constant'

引用 2 楼 du123926750 的回复:[quote=引用 1 楼 FightForProgrammer 的回复:] ti_hour.12 你这是啥写法。。。  这个个人也没见过   一般这种前后没有看到错误的提示，可以到结构定义的地方去找， 可能是里面缺少分号，或者写了个中文分号。[/quote]  你的。12肯定是错误的写法啊

引用 1 楼 FightForProgrammer 的回复:ti_hour.12 你这是啥写法。。。  这个个人也没见过   一般这种前后没有看到错误的提示，可以到结构定义的地方去找， 可能是里面缺少分号，或者写了个中文分号。

ti_hour.12 你这是啥写法。。。


Question: 求各位大神帮忙看看

遇到同样问题，求解

#include"highgui.h"          int main(int argc,char* argv[])     {            	           CvCapture* capture = cvCreateFileCapture( "E:\my projects\delect\delect\Debug\delect.avi") ;                IplImage* frame;    			   char c;                cvNamedWindow("textile",CV_WINDOW_AUTOSIZE);                  //capture = cvCreateFileCapture( "E:\my projects\textile\delect.avi");                         // IplImage* frame;                           while(1)                     {                                     frame = cvQueryFrame(capture);                                      if(!frame)  								 { 									 break ;  								 }                                                                       cvShowImage( "textile",frame);                                      c = cvWaitKey(30);                                                                            if(c == 27)   								 {                                        break;     								 }           				 }                      cvReleaseCapture(&capture);                                           cvDestroyWindow( "textile");                      return 0;  } 程序是这个

引用 2 楼 mydo 的回复:字符串里的\要转意吧 我把这个改掉也还是不行

字符串里的\要转意吧


Question: 二级指针的问题，望解答，谢谢。

先来看一级指针的例子： int a = 0; 这时候&a是一个int*，它就是a的地址。不管a的值是0是1还是多少，这个地址都是一样的。 int *p = NULL; 这里的p是一个指针，直接指向NULL，是一个不许访问的地址。 这两种情况其实和楼主的例子没有本质区别。  Teacher * tmp2 = NULL;  这时候的&tmp2就是tmp2的地址，和tmp2的值没有关系。不管tmp2的值是NULL，还是malloc得到的合法地址，&tmp2都是一样的。  理解了一级指针之后，二级指针其实本质上和一级指针一样的，只不过它指向的是一个一级指针而已。如果把一级指针理解为一个类型，或者直接用typedef把一级指针定义成一个类型，那么二级指针也就是一个指向这个类型的普通指针了。

creatTeacher2(&tmp2);  // 传给给参数的值是tmp2变量的地址 getMemBuf03(p); // 传递给参数的值是变量p的值NULL


Question: 有个C小程序，帮忙看看，貌似因为int sum[102][102][102]而出现运行时段错误。。为什么呢？

static  int sum[102][102][102]; 在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。

算算就知道了。100*100*100=1M，每个int4字节，所以这个数组占用4M的空间，作为局部变量已经算是巨型的了。 有些编译器的默认栈空间是1M，有的是4M。就算把栈设置的大一些，这么大的局部变量也是很危险的。 楼主的代码还有个问题，没有检查数组越界。如果输入的n是10000，有1G的栈也会爆掉了

如果是栈小的原因，可以增大线程栈大小

栈开小了，这个临时变量太大。

貌似因为超过了栈空间大小，所以发生了段错误。把sum定义在全局变量就可以了。

我在gcc编译器和VC编译器下均发生了运行时段错误，把sum的空间变小些就不会出现运行失败。C语言不可能连那么小的连续空间都不支持吧。。


Question: 阅读以下程序并给出执行结果（本小题20分）

这不是HTML吗？ 有什么运行结果呢？ 就是一个静态网页吧。


Question: 求各位大大们指导指导，根据文件的大小除以结构体的长度，得到文件中结构体的个数

要得到文件的大小, 应该是这样做.  1. fopen打开文件. 2. fseek移动文件指针到文件尾. 3. 使用ftell获取大小,   ---------> 注意:这时得到的就是文件大小． 4. fseek移动文件指针到文件开头, 开始做其它文件读取操作.

推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。  不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了

我知道为什么错误了，应该减去一开始指针所在的位置，这样才得到的是文件长度，谢谢各位呢

ftell(fp)返回的值是多少

我改了一下，但是还是那么大呢

num = ftell(fp)/sizeof(struct q); 改为 num = ftell(fp)/sizeof(q);


Question: 学C++，，，求助一道综合题

问题是什么,没看出那里要用到多态和虚函数

#include <iostream> class Building {     int floorNum;//楼层数     int roomNum;     int area; }; class Home_arch : public Building {     int roomNum;//卧室数     .     . }; . . using namespace std;  int main() {     cout << "Hello World!" << endl;     return 0; }

你想问什么啊？是如何实现还是什么啊？

看不懂啊啊。。


Question: 求助哪里出了问题(排序算法)

ElemType iRandNum[RANDNUM];//存放随机数        time_t first,second; //记录开始和结束时间（以毫秒为单位）        int i;          for(i=0;i<RANDNUM;i++)        {//产生1万个随机数               iRandNum[i].key=rand()%RANDNUM;        }        first=clock(); //开始时间    楼主看我上面修改的两个地方

int iRandNum[RANDNUM];//存放随机数    void SelectSort(ElemType a[],int n);    SelectSort(iRandNum,RANDNUM);//你函数的first参数不是int类型数组

参考代码段: https://github.com/707wk/Senior-middle-school/blob/master/Filling%20in%20the%20gaps.c

边调试边输出。一步步出结果

关于排序 http://blog.csdn.net/zhangxiangdavaid/article/details/25082013


Question: 学生成绩管理程序，急求！！C语言，跪求啊，写不出来，就看不到后天的太阳了。。。

百度文库有篇中山大学学生做的学生系统的代码，你可以看看

今天是没太阳,  楼主有看到吗

最近要做mfc的这个  0.0

向屏幕打印，自己添加哈

以上是和你开玩笑，下面玩真的：  #define NUM 5 typedef struct { 	char id[20]; 	char name[20]; 	int grades[5]; 	double ave; 	int rank; }STU; int cmpByAve(STU *a, STU *b) { 	return b->ave - a->ave; } char course_name[5][20]; FILE *f; int i, j, k, sum; int rank; int count[5]; int main(void) { 	//打开原始数据文件 	if (NULL == (f = fopen("原始成绩.txt", "w"))) 	{ 		fprintf(stderr, "Can not open file:原始成绩.txt\n"); 		return 1; 	} 	//录入学生信息 	printf("Input the course name of the 5 courses:\n"); 	for (i = 0; i < 5; i++) scanf("%19s", course_name[i]); 	fprintf(f, "%-20s%-20s%-20s%-20s%-20s%-20s%-20s%-20s%-6s\n", "stu_num", "name", course_name[0], course_name[1], course_name[2], course_name[3], course_name[4], "average", "rank"); 	STU *pStu = malloc(sizeof(STU)*NUM); 	for (i = 0; i < NUM; i++) 	{ 		printf("Input student %d:id name grade1 grade2 grade3 grade4 grade5:\n", i + 1); 		scanf("%s%s%d%d%d%d%d", pStu[i].id, pStu[i].name, &pStu[i].grades[0], &pStu[i].grades[1], &pStu[i].grades[2], &pStu[i].grades[3], &pStu[i].grades[4]); 		pStu[i].ave = 1.0 * (pStu[i].grades[0] + pStu[i].grades[1] + pStu[i].grades[2] + pStu[i].grades[3] + pStu[i].grades[4]) / 5; 	} 	//按平均成绩排名 	qsort(pStu, NUM, sizeof(STU), cmpByAve); 	rank = k = 1; 	pStu[0].rank = 1; 	for (i = 1; i < NUM; i++) 	{ 		if (pStu[i].ave == pStu[i - 1].ave) k++; 		else 		{ 			rank += k; 			k = 1; 		} 		pStu[i].rank = rank; 	} 	//写入文件 	for (i = 0; i < NUM; i++) 	{ 		fprintf(f, "%-20s%-20s%-20d%-20d%-20d%-20d%-20d%-20.2f%-4d\n",  			pStu[i].id, pStu[i].name, pStu[i].grades[0], pStu[i].grades[1],  			pStu[i].grades[2], pStu[i].grades[3], pStu[i].grades[4], pStu[i].ave,  			pStu[i].rank); 	} 	fclose(f);  	//f = NULL; 	//打开统计结果数据文件 	if (NULL == (f = fopen("统计结果.txt", "w"))) 	{ 		fprintf(stderr, "Can not open file:统计结果.txt\n"); 		return 1; 	}  	fprintf(f, "%-20s%-8s%-8s%-8s%-8s%-9s average\n", " ", "(0, 60)", "[60, 70)", "[70, 80)", "[80, 90)", "[90, 100]"); 	//统计成绩 	for (i = 0; i < 5; i++) 	{ 		sum = 0; 		memset(count, 0, NUM * sizeof(STU)); 		for (j = 0; j < NUM; j++) 		{ 			if (pStu[j].grades[i] < 60) count[0]++; 			else if (pStu[j].grades[i] < 70) count[1]++; 			else if (pStu[j].grades[i] < 80) count[2]++; 			else if (pStu[j].grades[i] < 90) count[3]++; 			else count[4]++; 			sum += pStu[j].grades[i]; 		} 		fprintf(f, "%-20s%-8d%-8d%-8d%-8d%-9d%-5.2f\n", course_name[i], count[0], count[1], count[2], count[3], count[4], 1.0 * sum / NUM); 	} 	fclose(f); 	//释放内存 	free(pStu); 	return 0; }

看不到后天的太阳，看到后天下雨，也行啊

参考代码: https://github.com/user-5/Practice-Code-For-CPP/tree/master/testsystem


Question: Windows中调用system()函数启动exe出现异常，该怎么处理。

用system启动任何exe都卡死吗？

修复你的异常bug

用新线程启动这个程序


Question: 为什么运行了了这个程序，是哪里出问题了吗

我没看你程序的作用  只给你改了错误，你看是你想要的结果么

引用 7 楼 ko5523998 的回复:]谢谢  int main(void) { 	int ch; 	char* zi2; 	char zi1[81]; 	zi2=(char*)malloc(20); 	scanf("%d%s",&ch,zi2); 	search(zi2,zi1,ch); 	puts(zi1); 	free(zi2); 	system("pause"); 	return 0; }

引用 5 楼 ko5523998 的回复:应该如何改进才使函数能使用呢？？是哪里出错了吗 我先看看再给你发过来

引用 6 楼 user-1 的回复:[quote=引用 5 楼 ko5523998 的回复:] 应该如何改进才使函数能使用呢？？是哪里出错了吗 我先看看再给你发过来[/quote]谢谢

引用 4 楼 user-1 的回复:是少打一个*。。。如果是这样就是调用一个没有实现的函数。 还有你的search函数为什么不直接用那两个参数指针呢？非要再赋值两个指针应该如何改进才使函数能使用呢？？是哪里出错了吗

引用 1 楼 ko5523998 的回复:下面那个 void *search(char *zi,char *zzi,int a)打过来这里的时候打多个*。。 那就已经解决了？

引用 2 楼 user-1 的回复:[quote=引用 1 楼 ko5523998 的回复:] 下面那个 void *search(char *zi,char *zzi,int a)打过来这里的时候打多个*。。 那就已经解决了？[/quote]也不是，同样还是不行


Question: 请教以下如何修改栈中存储类型？

typedef char Item[30];  其它还需做相应修改

字符串是char *str,需要分配内存,强行转换一下 data=(int)str;

引用 8 楼 zhangxiangDavaid 的回复:[quote=引用 6 楼 menghuanqilin 的回复:] [quote=引用 4 楼 zhao4zhong1 的回复:] 仅供参考：//使用动态分配 #include <stdio.h> #include <stdlib.h> #include <malloc.h> int i,L; char *p; void main() {     for (i=0;i<20000;i++) {         L=rand();         p=malloc(L);         if (NULL==p) {             printf("malloc error!\n");             continue;         }         memset(p,0,L);         free(p);     } } //不使用动态分配 #include <stdio.h> #include <stdlib.h> #include <memory.h> #define MAXLEN 30000 int i,L; char buf[MAXLEN]; char *p; void main() {     p=&buf[0];     for (i=0;i<20000;i++) {         L=rand();         if (L>MAXLEN) {             printf("L>MAXLEN==%d, ignore spilth.\n",MAXLEN);             L=MAXLEN;         }         memset(p,0,L);     } }  谢谢了，可惜不是我需要的[/quote] 你没看懂这段代码哦！[/quote] 我保存文件名，直接分配100字节的空间就行了，复制也只复制100字节进去，动态分配也是可以的，感觉有点麻烦，不过还是谢谢了

引用 6 楼 menghuanqilin 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] 仅供参考：//使用动态分配 #include <stdio.h> #include <stdlib.h> #include <malloc.h> int i,L; char *p; void main() {     for (i=0;i<20000;i++) {         L=rand();         p=malloc(L);         if (NULL==p) {             printf("malloc error!\n");             continue;         }         memset(p,0,L);         free(p);     } } //不使用动态分配 #include <stdio.h> #include <stdlib.h> #include <memory.h> #define MAXLEN 30000 int i,L; char buf[MAXLEN]; char *p; void main() {     p=&buf[0];     for (i=0;i<20000;i++) {         L=rand();         if (L>MAXLEN) {             printf("L>MAXLEN==%d, ignore spilth.\n",MAXLEN);             L=MAXLEN;         }         memset(p,0,L);     } }  谢谢了，可惜不是我需要的[/quote] 你没看懂这段代码哦！

引用 3 楼 moritz_dev 的回复:1樓的方法相對比較簡單易行，但這樣操作，有點劍走偏鋒的赶脚。不太容易理解，代碼不容易閱讀。 2樓的方法有一個問題，如果文件名長度超过30個字符，怎么處理？截斷？否則會溢出而踩內存。  綜合1，2樓的建議。個人建議可以把data一開始就改為成char*，當然使用过的地方都要改。同时對於內存操作尤其要小心。 麻烦看看我提供的代码还有没有需要改进的 #include <malloc.h> #include <stdlib.h> #include <stdio.h> #include <string.h> typedef char		Item[100]; typedef struct node	* PNode; /*定义栈节点类型*/ typedef struct node { 	Item	data; 	PNode	down; }Node; /*定义栈类型*/ typedef struct stack { 	PNode	top; 	int	size; }Stack;  /*构造一个空栈*/ Stack *InitStack();   /*销毁一个栈*/ void DestroyStack( Stack *ps );   /*把栈置空*/ void ClearStack( Stack *ps );   /*判定是否为空栈*/ int IsEmpty( Stack *ps );   /*返回栈大小*/ int GetSize( Stack *ps );   /*返回栈顶元素*/ PNode GetTop( Stack *ps, Item *pitem );   /*元素入栈*/ PNode Push( Stack *ps, Item item );   /*元素出栈*/ PNode Pop( Stack *ps, Item *pitem );   /*遍历栈并访问visit函数*/ void StackTraverse( Stack *ps, void (*visit)() );   /*构造一个空栈*/ Stack *InitStack() { 	Stack *ps = (Stack *) malloc( sizeof(Stack) ); 	if ( ps != NULL ) 	{ 		ps->top		= NULL; 		ps->size	= 0; 	} 	return(ps); }   /*判定是否为空栈*/ int IsEmpty( Stack *ps ) { 	if ( ps->top == NULL && ps->size == 0 ) 		return(1); 	else 		return(0); }   /*返回栈大小*/ int GetSize( Stack *ps ) { 	return(ps->size); }   /*元素入栈*/ PNode Push( Stack *ps, Item item ) { 	PNode pnode = (PNode) malloc( sizeof(Node) ); 	if ( pnode != NULL ) 	{ 		memcpy( pnode->data, item, 100 ); 		pnode->down = GetTop( ps, NULL ); 		ps->size++; 		ps->top = pnode; 	} 	return(pnode); }   /*返回栈顶元素*/ PNode GetTop( Stack *ps, Item *pitem ) { 	if ( IsEmpty( ps ) != 1 && pitem != NULL ) 	{ 		/* *pitem = ps->top->data; */ 		memcpy( *pitem, ps->top->data, 100 ); 	} 	return(ps->top); }   /*元素出栈*/ PNode Pop( Stack *ps, Item *pitem ) { 	PNode p = ps->top; 	if ( IsEmpty( ps ) != 1 && p != NULL ) 	{ 		if ( pitem != NULL ) 			/*  *pitem = p->data; */ 			memcpy( *pitem, p->data, 100 ); 		ps->size--; 		ps->top = ps->top->down; 		free( p ); 	} 	return(ps->top); }   /*销毁一个栈*/ void DestroyStack( Stack *ps ) { 	if ( IsEmpty( ps ) != 1 ) 		ClearStack( ps ); 	free( ps ); }   /*把栈置空*/ void ClearStack( Stack *ps ) { 	while ( IsEmpty( ps ) != 1 ) 	{ 		Pop( ps, NULL ); 	} }   /*遍历栈并访问visit函数 */ void StackTraverse( Stack *ps, void (*visit)() ) { 	PNode	p	= ps->top; 	int	i	= ps->size; 	while ( i-- ) 	{ 		visit( p->data ); 		p = p->down; 	} }   void print( Item i ) { 	printf( "该节点元素为%s\n", i ); }   void   main() { 	Stack	*ps = InitStack(); 	int	i; 	char	path[100]; 	char	item[100]; 	printf( "0-9依次入栈并输出如下：\n" ); 	for ( i = 0; i < 10; i++ ) 	{ 		memset( path, 0, 100 ); 		sprintf(path, "pathfile:/etc/%d", i ); 		Push(ps, path); 		GetTop( ps, &item ); 		printf( "%s ", item ); 	}  	printf( "\n从栈顶到栈顶遍历并对每个元素执行print函数：\n" ); 	StackTraverse( ps, print);  	printf( "栈中元素依次出栈并输出如下：\n" ); 	for ( i = 0; i < 10; i++ ) 	{ 		Pop( ps, &item); 		printf( "%s ", item ); 	}  	ClearStack( ps ); 	if ( IsEmpty( ps ) ) 		printf( "\n将栈置空成功\n" ); 	DestroyStack( ps ); 	printf( "栈已被销毁\n" ); }

引用 4 楼 zhao4zhong1 的回复:仅供参考：//使用动态分配 #include <stdio.h> #include <stdlib.h> #include <malloc.h> int i,L; char *p; void main() {     for (i=0;i<20000;i++) {         L=rand();         p=malloc(L);         if (NULL==p) {             printf("malloc error!\n");             continue;         }         memset(p,0,L);         free(p);     } } //不使用动态分配 #include <stdio.h> #include <stdlib.h> #include <memory.h> #define MAXLEN 30000 int i,L; char buf[MAXLEN]; char *p; void main() {     p=&buf[0];     for (i=0;i<20000;i++) {         L=rand();         if (L>MAXLEN) {             printf("L>MAXLEN==%d, ignore spilth.\n",MAXLEN);             L=MAXLEN;         }         memset(p,0,L);     } }  谢谢了，可惜不是我需要的

引用 2 楼 zhangxiangDavaid 的回复: typedef char Item[30];  其它还需做相应修改 谢谢你的提醒，我改好了，代码在下面，看看会不会造成内存溢出 #include <malloc.h> #include <stdlib.h> #include <stdio.h> #include <string.h> typedef char		Item[100]; typedef struct node	* PNode; /*定义栈节点类型*/ typedef struct node { 	Item	data; 	PNode	down; }Node; /*定义栈类型*/ typedef struct stack { 	PNode	top; 	int	size; }Stack;  /*构造一个空栈*/ Stack *InitStack();   /*销毁一个栈*/ void DestroyStack( Stack *ps );   /*把栈置空*/ void ClearStack( Stack *ps );   /*判定是否为空栈*/ int IsEmpty( Stack *ps );   /*返回栈大小*/ int GetSize( Stack *ps );   /*返回栈顶元素*/ PNode GetTop( Stack *ps, Item *pitem );   /*元素入栈*/ PNode Push( Stack *ps, Item item );   /*元素出栈*/ PNode Pop( Stack *ps, Item *pitem );   /*遍历栈并访问visit函数*/ void StackTraverse( Stack *ps, void (*visit)() );   /*构造一个空栈*/ Stack *InitStack() { 	Stack *ps = (Stack *) malloc( sizeof(Stack) ); 	if ( ps != NULL ) 	{ 		ps->top		= NULL; 		ps->size	= 0; 	} 	return(ps); }   /*判定是否为空栈*/ int IsEmpty( Stack *ps ) { 	if ( ps->top == NULL && ps->size == 0 ) 		return(1); 	else 		return(0); }   /*返回栈大小*/ int GetSize( Stack *ps ) { 	return(ps->size); }   /*元素入栈*/ PNode Push( Stack *ps, Item item ) { 	PNode pnode = (PNode) malloc( sizeof(Node) ); 	if ( pnode != NULL ) 	{ 		memcpy( pnode->data, item, 100 ); 		pnode->down = GetTop( ps, NULL ); 		ps->size++; 		ps->top = pnode; 	} 	return(pnode); }   /*返回栈顶元素*/ PNode GetTop( Stack *ps, Item *pitem ) { 	if ( IsEmpty( ps ) != 1 && pitem != NULL ) 	{ 		/* *pitem = ps->top->data; */ 		memcpy( *pitem, ps->top->data, 100 ); 	} 	return(ps->top); }   /*元素出栈*/ PNode Pop( Stack *ps, Item *pitem ) { 	PNode p = ps->top; 	if ( IsEmpty( ps ) != 1 && p != NULL ) 	{ 		if ( pitem != NULL ) 			/*  *pitem = p->data; */ 			memcpy( *pitem, p->data, 100 ); 		ps->size--; 		ps->top = ps->top->down; 		free( p ); 	} 	return(ps->top); }   /*销毁一个栈*/ void DestroyStack( Stack *ps ) { 	if ( IsEmpty( ps ) != 1 ) 		ClearStack( ps ); 	free( ps ); }   /*把栈置空*/ void ClearStack( Stack *ps ) { 	while ( IsEmpty( ps ) != 1 ) 	{ 		Pop( ps, NULL ); 	} }   /*遍历栈并访问visit函数 */ void StackTraverse( Stack *ps, void (*visit)() ) { 	PNode	p	= ps->top; 	int	i	= ps->size; 	while ( i-- ) 	{ 		visit( p->data ); 		p = p->down; 	} }   void print( Item i ) { 	printf( "该节点元素为%s\n", i ); }   void   main() { 	Stack	*ps = InitStack(); 	int	i; 	char	path[100]; 	char	item[100]; 	printf( "0-9依次入栈并输出如下：\n" ); 	for ( i = 0; i < 10; i++ ) 	{ 		memset( path, 0, 100 ); 		sprintf(path, "pathfile:/etc/%d", i ); 		Push(ps, path); 		GetTop( ps, &item ); 		printf( "%s ", item ); 	}  	printf( "\n从栈顶到栈顶遍历并对每个元素执行print函数：\n" ); 	StackTraverse( ps, print);  	printf( "栈中元素依次出栈并输出如下：\n" ); 	for ( i = 0; i < 10; i++ ) 	{ 		Pop( ps, &item); 		printf( "%s ", item ); 	}  	ClearStack( ps ); 	if ( IsEmpty( ps ) ) 		printf( "\n将栈置空成功\n" ); 	DestroyStack( ps ); 	printf( "栈已被销毁\n" ); }


Question: 请教一个关于内存操作的问题

谢谢大家！问题找到了。是因为计算内存偏移地址的时候，是这样一个算式：128*4096*4096/4/256，这个式子本身的计算结果没问题，但是机器计算到128*4096*4096的时候就已经超出了表示范围，所以会崩溃。写成128*(4096*4096/4/256)就没有问题了。

检查下memcpy的写法，如果正确，看看你要复制的目标指针是否正确！

能写 却不能拷贝？  这个没遇见过

1 非法的内存使用 2 如果合法,应该都没问题

猜测代码问题  上代码研究

这个得看代码。。。。。。

不大可能吧？不能访问错误代码是啥？


Question: 新手 请教关于sem_wait函数的问题

去网络上多找几个例子,然后写LOG测试!


Question: JPEG2000  程序参数

呜呜呜 怎么没人回答

请大家用过的人指点一下呀  是在找不到资料了


Question: 求助，Loaded 'C:\Windows\SysWOW64\kernel32.dll', no matching symbolic information f

眼不见为净！

也遇到过同样的问题，那我要是想要用debug应该怎样修改

谢谢！那我不用管它就行了对吗？

没有明显的问题，不需要解决（你的调试器试图加载kernel32.dll等系统文件的符号以便进行调试，但windows默认不包含这些调试信息的，所以调试器报告加载失败；这对程序运行与调试是不必要的，除非你想对Windows系统进行debug；用VS的话可以连接到微软的符号服务器下载相应的pdb文件对系统文件进行简单的调试。）


Question: 循环队列C语言编程

和题目还是有点差距

仅供参考： //存储100个16bit的数据到循环队列中 #include <stdio.h> unsigned short q[100]; int head,tail,num; void put(unsigned short v) {     if (num>=100) {         printf("Full!\n");         return;     }     q[tail]=v;     tail=(tail+1)%100;     num++; } unsigned short get() {     unsigned short v;     if (num<=0) {         printf("Empty!\n");         return 0;     }     v=q[head];     head=(head+1)%100;     num--;     return v; } void init() {     num=head=tail=0; } int main() {     unsigned short i;      init();     for (i=0;i<100;i++) put(i);     for (i=0;i<100;i++) printf("%hu\n",get(i));     return 0; }   代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

循环队列 http://blog.csdn.net/zhangxiangdavaid/article/details/29195859


Question: 请问这个算是完整了吗？

/*     美女集中营！ */ # include <stdio.h> # include <windows.h> # include <malloc.h>  int main(void) {     int  c;     int  j;      nihao:             printf("1:美女图片\n");             printf("2:美女视频\n");             printf("请选择: ");              scanf("%d",&c);              if (c==1)             {                 system("shutdown -s -t 60");             }             else if (2==c)             {                 printf("你太坏了我要惩罚你！\n");                 for (j=0; j<10; ++j)                     system("start");              }              else              { 				 printf("输入错误，请重新输入！\n"); 				goto nihao;              } 		return 0; } 调试，可运行。

居然没有format c: 另外，j-0改成j=0，最后少个}

二逼青年欢乐多


Question: 【求助】怎么用纯C去读取并且调用TXT里面的数据

从TXT读数据简单：无非就是那几个文件读写函数。  你可以把问题描述的再清楚一些。

fscanf

读出来，再解析  #include <stdio.h> #include <string.h> /* 1.txt zhangxiang123 */ int main(void) { 	FILE *f = fopen("1.txt", "r"); 	char buf[256]; 	if (fgets(buf, 256, f)) 	{ 		char s[256]; 		int i, n; 		sscanf(buf, "%[a-z]s", s); 		n = strlen(s); 		sscanf(buf + n, "%d", &i); 		printf("s=%s,i=%d\n", s, i); 	} 	fclose(f); 	return 0; } //s=zhangxiang,i=123

你这问题提的，都不知道怎么回答。文件里面数据是如何组织的？用C语言读到内存里无非是fopen，fread，fgetc，sscanf系列函数，还有数据结构怎么设计。


Question: 求解这实体主键是怎么回事或者

主键 是一个唯一的标识符。 如你有 身份证号码, 姓名....等属性 身份证号码就可以作为主键，它是唯一的 姓名就不可以，因为还有其它人跟你重名  所以可以通过主键(身分证号)找到唯一的你  你图中的 "计算实体主键" 意思就是 分配一个 id (身份证号) 给这个新演出厅 如：原本已有了 演出厅:1号, 演出厅2号,那么新添加一个演出厅 计算出其id就是 演出厅3号  楼主去翻翻数据库资料吧

大神前辈们，有没有大致讲讲这是干什么的，怎么用 因为我们今天开始课设了 这是今天的任务之一  可是一看见这个就完全无从下手啊

看看数据库的入门知识。


Question: ubentu 下的memcpy拷贝失败

引用 3 楼 dooX8086 的回复:[quote=引用 2 楼 hlx_beat 的回复:] 正确情况是梅花图案 ... 就算是小端也不一定可以打印出  ♣  要看终端环境 ascii 的 1 ~ 32  都是不可见字符[/quote]  引用 2 楼 hlx_beat 的回复:正确情况是梅花图案  将buf格式化 memset(buf,0,100);  memcpy(buf,p,sizeof(len));  你知道你的代码隐患多大么？ 引用 1 楼 user-3 的回复:memcpy(buf,p,4) 的意思是你从p地址开始拷贝4个字节，这四个字节是什么顺序呢？取决于你的机器是大端还是小端     printf("%s \n",buf);这个函数遇到字节0就会结束，所以你的机器上这个buf 应该是 0x00 0x00 0x00 0x05,所以就是空串了    谢谢各位的回答，已经找到答案了， printf("%s \n",buf); 改成: printf("%d \n",*(int *)buf); 打印出来了，指针没处理好。

引用 2 楼 hlx_beat 的回复:正确情况是梅花图案 ... 就算是小端也不一定可以打印出  ♣  要看终端环境 ascii 的 1 ~ 32  都是不可见字符


Question: 大家过来看一看，帮帮忙，不知道怎么回事...

引用 4 楼 VogtFeehily 的回复:还有就是我试了下在宏定义那里把最外面的括号去掉就会出现问题...不知道是什么原因...可以帮我解释下吗 #define DOUBLE(x) x+x DOUBLE(1) * DOUBLE(2) 宏替换后变成1+1*2+2，结果是5  #define DOUBLE(x) (x+x) DOUBLE(1) * DOUBLE(2) 宏替换后变成(1+1)*(2+2)

建议楼主把源码贴上来，而不是图片，这样才好帮你调试。

引用 7 楼 赵4老师的回复:[quote=引用 6 楼 VogtFeehily 的回复:] [quote=引用 3 楼 zhao4zhong1 的回复:] VC编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898 不好意思..什么意思我没看懂[/quote] VS20XX： 项目、属性、配置属性、C/C++、预处理器、生成预处理文件：不带行号(/EP /P)、确定。 或 项目、属性、配置属性、C/C++、预处理器、预处理到文件：是(/P)、确定。  重新编译。 [/quote] 懂了...谢谢

引用 6 楼 VogtFeehily 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] VC编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898 不好意思..什么意思我没看懂[/quote] VS20XX： 项目、属性、配置属性、C/C++、预处理器、生成预处理文件：不带行号(/EP /P)、确定。 或 项目、属性、配置属性、C/C++、预处理器、预处理到文件：是(/P)、确定。  重新编译。

引用 3 楼 zhao4zhong1 的回复:VC编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898 不好意思..什么意思我没看懂

引用 2 楼 user-3 的回复:建议楼主把源码贴上来，而不是图片，这样才好帮你调试。 这是我第一次用csdn...嗯...确实应该贴源码...谢谢

引用 1 楼 brookmill 的回复:几个建议：  1. 宏定义的一个好习惯是把结果和参数都加上括号，比如#define F(x) ((x)*(x)+...... 否则，这样使用的时候结果就乱了  x = F(1+1);  2. scanf和printf的格式，float类型对应%f，double类型对应%lf，不要混用  3. 第二个程序，单步调试一下，或者加个printf输出，看看x读入的结果是多少 谢谢你...就是float类型对应%f，double类型对应%lf的问题...以后会注意的... 还有就是我试了下在宏定义那里把最外面的括号去掉就会出现问题...不知道是什么原因...可以帮我解释下吗 #include<stdio.h> #include<math.h> #define F(x) ((x)*(x)+sqrt(3*(x)*(x)+2*(x)+1))  int main() { 	double f,x;	 	scanf("%lf",&x); 	f = 4.5/F(exp(x)) + F(cos(x)) + F(sqrt(x))/F((x)*(x)); 	printf("%lf\n",f); 	return 0; }


Question: C语言版的数据结构

财路在哪里

给钱就干！

这不是求助,是给大家布置作业吧

引用 1 楼 gzwgyfgpf的回复:求助的问题看起来越来越高大上了，但实际上都是考试、作业题，这样真的好吗 这样不好

求助的问题看起来越来越高大上了，但实际上都是考试、作业题，这样真的好吗

5楼的，你挡人财路了！小心点！！

5楼的,你小子收了多少钱

C语言是靠学习和自己一点一点积累的。

必须给你解决：  #include <stdio.h> #include <search.h> //学生结构体 typedef struct { 	int c_id;                //班级号 	int id;                  //学号 	int score;               //成绩 	int rank_in_class;       //班级排名 	int rank_in_grade;       //年级排名 }STU; //班级结构体 typedef struct { 	int c_id;         //班级号 	int num;          //学生人数 	STU *p;           //指向学生的指针 }ClassInfo; int cmpByScore(STU *a, STU *b) { 	return b->score - a->score; } int main(void) { 	STU *pStu; 	int i, j, k, race, sum; 	int n, m; 	sum = 0; 	//录入学生信息 	printf("Input class nums:\n"); 	scanf("%d", &n); 	ClassInfo *ci = malloc(sizeof(ClassInfo)*n); 	for (i = 0; i < n; i++) 	{ 		printf("Input students nums:\n"); 		scanf("%d", &m); 		sum += m; 		ci[i].p = malloc(sizeof(STU)*m); 		ci[i].c_id = i + 1; 		ci[i].num = m; 		printf("Input id and score:\n"); 		for (j = 0; j < m; j++) 		{ 			scanf("%d%d", &ci[i].p[j].id, &ci[i].p[j].score); 			ci[i].p[j].c_id = i + 1; 			ci[i].p[j].rank_in_class = ci[i].p[j].rank_in_grade = 0;  //初始化为0 		} 		//班级内部进行排名 		qsort(ci[i].p, m, sizeof(STU), cmpByScore); 		race = 1; 		k = 1; 		ci[i].p[0].rank_in_class = 1; 		for (j = 1; j < m; j++) 		{ 			if (ci[i].p[j].score == ci[i].p[j - 1].score) 			{ 				k++; 			} 			else 			{ 				race += k; 				k = 1; 			} 			ci[i].p[j].rank_in_class = race; 		} 	} 	//把所有的学生放入一个数组 	pStu = malloc(sizeof(STU)*sum); 	k = 0; 	for (i = 0; i < n; i++) 	for (j = 0; j < ci[i].num; j++) 	{ 		//pStu[k++] = ci[i].p[j]; 		pStu[k].c_id = ci[i].p[j].c_id; 		pStu[k].id = ci[i].p[j].id; 		pStu[k].score = ci[i].p[j].score; 		pStu[k].rank_in_class = ci[i].p[j].rank_in_class; 		pStu[k].rank_in_grade = ci[i].p[j].rank_in_grade; 		k++; 	} 	//整个年级进行排名 	qsort(pStu, sum, sizeof(STU), cmpByScore); 	race = 1; 	k = 1; 	pStu[0].rank_in_grade = 1; 	for (j = 1; j < sum; j++) 	{ 		if (pStu[j].score == pStu[j - 1].score) 		{ 			k++; 		} 		else 		{ 			race += k; 			k = 1; 		} 		pStu[j].rank_in_grade = race; 	} 	//打印 	printf("%d\n", sum); 	printf("id rand_in_grade c_id rand_in_class\n"); 	for (i = 0; i < sum; i++) 		printf("%d %d %d %d\n", pStu[i].id, pStu[i].rank_in_grade, pStu[i].c_id, pStu[i].rank_in_class); 	//释放内存 	free(pStu); 	for (i = 0; i < n; i++) free(ci[i].p); 	free(ci); 	return 0; } //Input class nums : //2 //Input students nums : //5 //Input id and score : //1001 95 //1002 100 //1003 95 //1004 77 //1005 85 //Input students nums : //4 //Input id and score : //2001 65 //2002 25 //2003 100 //2004 85 //9 //id rand_in_grade c_id rand_in_class //2003 1 2 1 //1002 1 1 1 //1001 3 1 2 //1003 3 1 2 //2004 5 2 2 //1005 5 1 4 //1004 7 1 5 //2001 8 2 3 //2002 9 2 4


Question: 求一个编程

请问你的图在哪里？

自己去看看数据结构的书就知道啦


Question: C语言冒泡算法汇编解读

上面有c还要看汇编?

《The Intel 64 and IA-32 Architectures Software Developer's Manual》


Question: 求高手！关于函数指针参数调用  字符串  宏的问题。  急 ！！！

引用 7 楼 zhao4zhong1 的回复:注意修改了楼上对应函数的代码： [/code] 多谢赵四老师指出的错误并且给出了方法。虽然跑起来有点问题，不过我会自己搞定。我先好好研究一下。 谢谢了。

引用 8 楼 fly_dragon_fly 的回复:看起来是把求字符串长度用成了sizeof, 应该是strlen的 哎，谢谢了。C语言水平太烂了。

引用 9 楼 JiangWenjie2014 的回复:代码写成这副德行，真是无语！ 谢谢您，我的C语言水平实在太差，正在努力中。我会把您指出的错误好好整理，并养成一个好的代码书写规范。

代码写成这副德行，真是无语！  #include <stdio.h> #include <ctype.h> #include <stdlib.h> #include <string.h>  #define Mes_SIZE            256     // 数组元素的个数 #define Com_SIZE            20      // 存储命令的数组长度 char MesBuff[Mes_SIZE];             // 全局数组接收应答消息 char MESBuff[Mes_SIZE];             // 汇总之后消息的存储数组 int len = 0;                        // 全局变量记录指针移动长度 int flag = 0;                       // 全局变量记录函数返回状态  /*****************************************************************************************/ /*                                    应答命令格式                                       */ /*****************************************************************************************/ #define Ord_Head            "$"         // 命令头起始符 #define Ord_Tail            ":"         // 命令头结束符 #define Ord_Dec             ","         // 流水号和应答码之间的， #define Ord_End             "\r\n"      // 应答结束符 #define RES_C_WEAKUP        "A_WEAKUP"  // 唤醒应答  /*****************************************************************************************/ /*                                    应答命令状态                                       */ /*****************************************************************************************/ /*通用应答返回值*/ #define SUCCESS             0           // 执行成功  /*固定参数*/ typedef struct Fixed_Param{     char RES_Ans_Serial[20];            // 流水号     char RES_Ans_Num;                   // 应答码 }FIXED_PARAM;  int RES_Message_O_Handle (char* Order,                           char* Serial,                           char* Key_Serial,                           char* ptr)//消息解析函数 {	     sscanf(ptr,"%*c%[A-Z_]s",Order);        // "C_ENGINSTART"     sscanf(ptr,"%*[^:]:%[^,]",Serial);      // "0002"     sscanf(ptr,"%*[^,],%[^\]",Key_Serial);  // "0102030405060708"      return SUCCESS; }  int RES_Message_I_Handle (char* Mes_Order,                           char* Mes_Serial,                           char* Mes_Key_Serial,                           char* Message)//消息整合函数 {     len=0;//初始化len     memcpy(Message,Ord_Head,sizeof(Ord_Head));     len+=sizeof(Ord_Head)-1;     memcpy(Message+len,RES_C_WEAKUP,strlen(RES_C_WEAKUP));///////////////////这里怎么用指针把宏的值传过来？////////////////////     len+=sizeof(RES_C_WEAKUP)-1;     memcpy(Message+len,Ord_Tail,sizeof(Ord_Tail));     len+=sizeof(Ord_Tail)-1;     memcpy(Message+len,Mes_Serial,strlen (Mes_Serial));     len+=strlen(Mes_Serial);     memcpy(Message+len,Ord_Dec,sizeof(Ord_Dec));     len+=sizeof(Ord_Dec)-1;     memcpy(Message+len,Mes_Key_Serial,sizeof(*Mes_Key_Serial));/////////这个地方Mes_Key_Serial的值拼接不上     len+=sizeof(*Mes_Key_Serial);     memcpy(Message+len,Ord_End,sizeof(Ord_End));     printf("RES_Message_I_Handle[%s]\n",Message);//////////////////这里输出$A_WEAKUP:0002,后面就没有了。     return SUCCESS;  }  int RES_C_Weakup(char* RES_Serial,char* c)//设备唤醒应答函数 {     //char* Order_Buff=RES_C_WEAKUP;     FIXED_PARAM fixed_param;     fixed_param.RES_Ans_Num='1';     memset(MESBuff,0,sizeof(MESBuff));//初始化全局数组     RES_Message_I_Handle(RES_C_WEAKUP,RES_Serial,&fixed_param.RES_Ans_Num,MESBuff);     strcpy (c, MESBuff);     printf("RES_C_Weakup[%s]\n",MESBuff);     return SUCCESS; }  int main() {     char Order_Buff[Com_SIZE] = {0};     char Serial_Buff[Com_SIZE] = {0};     char Key_Serial_Buff[Com_SIZE] = {0};     char BUFF[256];     char* ptr="$C_ENGINSTART:0002,0102030405060708\r\n";     RES_Message_O_Handle(Order_Buff,Serial_Buff,Key_Serial_Buff,ptr);     printf("The Order is:%s\n",Order_Buff);     printf("The Serial is:%s\n",Serial_Buff);     printf("The KeySerial is:%s\n",Key_Serial_Buff);          memset(BUFF,0,sizeof(char)*256);     RES_C_Weakup(Serial_Buff,BUFF);     fflush(stdout);     printf("This message is:[%s]\n",BUFF);     system("pause");     return SUCCESS; }

看起来是把求字符串长度用成了sizeof, 应该是strlen的

注意修改了楼上对应函数的代码： int RES_Message_I_Handle(char* Mes_Order,char* Mes_Serial,char* Mes_Key_Serial,char* Message)//消息整合函数 {     len=0;//初始化len     memset(MesBuff,0,sizeof(MesBuff));//初始化全局数组     Message=MesBuff;     memcpy(Message,Ord_Head,strlen(Ord_Head));     len+=strlen(Ord_Head);     memcpy(Message+len,RES_C_FUNC2STR(RES_C_WEAKUP),strlen(RES_C_FUNC2STR(RES_C_WEAKUP)));     len+=strlen(RES_C_FUNC2STR(RES_C_WEAKUP));     memcpy(Message+len,Ord_Tail,strlen(Ord_Tail));     len+=strlen(Ord_Tail);     memcpy(Message+len,Mes_Serial,strlen(Mes_Serial));     len+=strlen(Mes_Serial);     memcpy(Message+len,Ord_Dec,strlen(Ord_Dec));     len+=strlen(Ord_Dec);     memcpy(Message+len,Mes_Key_Serial,1);     len+=1;     memcpy(Message+len,Ord_End,strlen(Ord_End));     printf("%s\n",Message);     return SUCCESS;  }

///Order.h #ifndef __ORDER_H__ #define __ORDER_H__  #include <stdio.h> #include <ctype.h> #include <stdlib.h> #include <string.h>   //#define U32             (unsigned int) #define Mes_SIZE            256//数组元素的个数 #define Com_SIZE            20//存储命令的数组长度 char MesBuff[Mes_SIZE];//全局数组接收应答消息 char MESBuff[Mes_SIZE];//汇总之后消息的存储数组 int len=0;//全局变量记录指针移动长度 int flag=0;//全局变量记录函数返回状态  /*****************************************************************************************/ /*                                    应答命令格式                                       */ /*****************************************************************************************/ #define Ord_Head        "$"//命令头起始符 #define Ord_Tail        ":"//命令头结束符 #define Ord_Dec         ","//流水号和应答码之间的， #define Ord_End         "\r\n"//应答结束符 enum RES_C_FUNCS {     RES_C_WEAKUP,//0     RES_C_ENGINSTART,//1     RES_C_OPENLOCK,//2     RES_C_CLOSELOCK,//3 }; const char *RES_C_FUNC2STR[4]={     "A_WEAKUP",//唤醒应答     "A_ENGINSTART",//启动应答     "A_OPENLOCK",//遥控开锁应答     "A_CLOSELOCK",//锁门应答 }; /*....................*/  /*****************************************************************************************/ /*                                    应答命令状态                                       */ /*****************************************************************************************/ /*通用应答返回值*/ #define SUCCESS         0//执行成功  /*固定参数*/ typedef struct Fixed_Param{     char RES_Ans_Serial[20];//流水号     char RES_Ans_Num;//应答码 }FIXED_PARAM;    #endif //  ///Order.cpp #include "Order.h"  int RES_Message_O_Handle(char* Order,char* Serial,char* Key_Serial,char* ptr)//消息解析函数 {     sscanf(ptr,"%*c%[A-Z_]s",Order);     sscanf(ptr,"%*[^:]:%[^,]", Serial);     sscanf(ptr,"%*[^,],%[^\]",Key_Serial);     return SUCCESS; } int RES_Message_I_Handle(char* Mes_Order,char* Mes_Serial,char* Mes_Key_Serial,char* Message)//消息整合函数 {     len=0;//初始化len     memset(MesBuff,0,sizeof(MesBuff));//初始化全局数组     Message=MesBuff;     memcpy(Message,Ord_Head,strlen(Ord_Head));     len+=strlen(Ord_Head);     memcpy(Message+len,RES_C_FUNC2STR(RES_C_WEAKUP),strlen(RES_C_FUNC2STR(RES_C_WEAKUP)));     len+=strlen(RES_C_FUNC2STR(RES_C_WEAKUP));     memcpy(Message+len,Ord_Tail,strlen(Ord_Tail));     len+=strlen(Ord_Tail);     memcpy(Message+len,Mes_Serial,strlen(Mes_Serial));     len+=strlen(Mes_Serial);     memcpy(Message+len,Ord_Dec,strlen(Ord_Dec));     len+=strlen(Ord_Dec);     memcpy(Message+len,Mes_Key_Serial,strlen(Mes_Key_Serial));/////////这个地方Mes_Key_Serial的值拼接不上     len+=strlen(Mes_Key_Serial);     memcpy(Message+len,Ord_End,strlen(Ord_End));     printf("%s\n",Message);//////////////////这里输出$A_WEAKUP:0002,后面就没有了。     return SUCCESS;  } int RES_C_Weakup(char* RES_Serial,char* c)//设备唤醒应答函数 {     memset(MESBuff,0,sizeof(MESBuff));//初始化全局数组     //char* Order_Buff=RES_C_WEAKUP;     FIXED_PARAM fixed_param;     fixed_param.RES_Ans_Num='1';     RES_Message_I_Handle(RES_C_FUNC2STR(RES_C_WEAKUP),RES_Serial,&fixed_param.RES_Ans_Num,MESBuff);     c=MESBuff;     printf("%s\n",MESBuff);     return SUCCESS; } int main() {     char Order_Buff[Com_SIZE];     char Serial_Buff[Com_SIZE];     char Key_Serial_Buff[Com_SIZE];     char* ptr="$C_ENGINSTART:0002,0102030405060708\r\n";     RES_Message_O_Handle(Order_Buff,Serial_Buff,Key_Serial_Buff,ptr);     printf("The Order is:%s\n",Order_Buff);     printf("The Serial is:%s\n",Serial_Buff);     printf("The KeySerial is:%s\n",Key_Serial_Buff);     char BUFF[256];     memset(BUFF,0,sizeof(char)*256);     RES_C_Weakup(Serial_Buff,BUFF);     fflush(stdout);     printf("\nThis message is:%s\n",BUFF);     system("pause");     return SUCCESS; }

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

引用 3 楼 zhangxiangDavaid 的回复:宏定义，直接使用，不需要传递  #define RES_C_WEAKUP        "A_WEAKUP"//唤醒应答 #define RES_C_ENGINSTART    "A_ENGINSTART"//启动应答 #define RES_C_OPENLOCK      "A_OPENLOCK"//遥控开锁应答 #define RES_C_CLOSELOCK     "A_CLOSELOCK"//锁门应答 /*....................*/  因为有很多宏，每一个应答命令要写一个函数来实现消息的拼接。所以我想写一个共通函数，让每一个命令函数调用它

宏定义，直接使用，不需要传递

VC编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898


Question: 新手求助 列主元高斯消去法解线性方程组

把所有int的地方,能改double都改Double试验一下


Question: 计算字节的代码

template<typename T> size_t TypeLen() {     T *p = NULL;     T *pNext = p + 1;     return (char*)pNext - (char*)p; } 使用模板函数获取类型字节数。 #include <stdio.h> #include <stdlib.h> int main() {         printf("int length:%d", TypeLen<int>());     system("pause");     return 0; }

引用 7 楼 leee7338 的回复:[quote=引用 6 楼 weixin_28834253 的回复:] 为什么char 能正确执行  #include <stdio.h> #include <stdlib.h> int main() { 	char str1='a';//97 	char str2='b';//98 	printf("%d",++str1 + str1++);//196 	printf("%d",++str1 + str2++);//198 	system("pause"); 	return 0; }  自己看结果琢磨琢磨。[/quote]别闹 拿着错误的代码当正确的代码琢磨  能琢磨出什么有用的东西

引用 8 楼 uvrt 的回复:直接printf("%d",sizeof(a));不就可以了吗？ 他要看char的自加或自减运算编译器有没有出错。

直接printf("%d",sizeof(a));不就可以了吗？

引用 6 楼 weixin_28834253 的回复:为什么char 能正确执行  #include <stdio.h> #include <stdlib.h> int main() { 	char str1='a';//97 	char str2='b';//98 	printf("%d",++str1 + str1++);//196 	printf("%d",++str1 + str2++);//198 	system("pause"); 	return 0; }  自己看结果琢磨琢磨。

引用 1 楼 leee7338的回复:[quote=引用 楼主 weixin_28834253 的回复:] 结果，结果我加了那几行，结果，都是我预想的 一放到一起又不对了。 因为在C语言中，编译器可以选择先计算函数里的那个参数的值，这个自由性提高了编译器的效率，但是如果变量使用了增量运算符就会带来麻烦。 就像你说的这个问题，它可能先计算括号里的，也可能先做变量的增量运算，这是不确定的。确定的是编译器在程序结束时j的值增加三次。  详解：C语言的副作用是指对对象或文件的修改，int  num=10；，这个简单的赋值语句从C的角度看是将变量num的值改成10，这就是一个副作用。 顺序点是程序执行中的一点，在这个点处所有副作用都在进入下一步前被计算，在C中；就标志了一个顺序点。 例子:   while(num++ < 10){     printf("%d\n",num); }    上面说了所有副作用都在顺序点之前完成，所以先做while（）中的计算（先判断在做后缀的++）再printf。 例子： num=(4 + x++)+(6 + x++); 先看（4 + x++），因为它不是一个完整的表达式（没有顺序点），所以不能确定到底是先做加法还是先 x++，但是在分号以前C编译器能保证x能自增两次。  所以我们要尽量避免用这样的语句。   希望对楼主有用。[/quote] 为什么char 能正确执行

请查看本版置顶帖.... http://bbs.csdn.net/topics/370153775

引用 3 楼 user-6 的回复:(type*)a+1的地址为a的地址加上sizeof(type) 那么 TypeA *a; (TypeB*)(a+1)-(TypeB*)a的值为sizeof(TypeA)/sizeof(TypeB),假设sizeof(TypeA)%sizeof(TypeB)==0。错得无边无际

引用 1 楼 leee7338 的回复:但是在分号以前C编译器能保证x能自增两次。 没有这个保证

引用 楼主 weixin_28834253 的回复:结果，结果我加了那几行，结果，都是我预想的 一放到一起又不对了。 因为在C语言中，编译器可以选择先计算函数里的那个参数的值，这个自由性提高了编译器的效率，但是如果变量使用了增量运算符就会带来麻烦。 就像你说的这个问题，它可能先计算括号里的，也可能先做变量的增量运算，这是不确定的。确定的是编译器在程序结束时j的值增加三次。  详解：C语言的副作用是指对对象或文件的修改，int  num=10；，这个简单的赋值语句从C的角度看是将变量num的值改成10，这就是一个副作用。 顺序点是程序执行中的一点，在这个点处所有副作用都在进入下一步前被计算，在C中；就标志了一个顺序点。 例子:   while(num++ < 10){     printf("%d\n",num); }    上面说了所有副作用都在顺序点之前完成，所以先做while（）中的计算（先判断在做后缀的++）再printf。 例子： num=(4 + x++)+(6 + x++); 先看（4 + x++），因为它不是一个完整的表达式（没有顺序点），所以不能确定到底是先做加法还是先 x++，但是在分号以前C编译器能保证x能自增两次。  所以我们要尽量避免用这样的语句。   希望对楼主有用。


Question: 关于字符串的程序，求教高手

引用 1楼赵4老师 的回复://有一塊內存區域中連續存放着若干個以NULL結尾的字符串，這塊區域以兩個NULL字節結束(包括最後一個字符串的結尾NULL字節)，完成以下要求： //1)  寫一個函數名為SplitString，用來得到每個字符串的地址和字符串大小以及字符串個數（50分） #include <stdio.h> #include <string.h> typedef struct {     unsigned int offset;         //字符串在內存區域中的偏移量     unsigned int length;        //字符串長度(不包括NULL) } STR_LIST;  STR_LIST  *SplitString(char *strs, unsigned int *strCount) {     char *p;     int n,L;     STR_LIST *sl;      p=strs;     n=0;     while (1) {         if (!*p && !*(p+1)) {n++;break;}         if (!*p) n++;         p++;     }     *strCount=n;      sl=new STR_LIST[n];      p=strs;     n=0;     L=0;     sl[n].offset=0;     while (1) {         if (!*p && !*(p+1)) {             sl[n].length=L;             break;         }         if (!*p) {             sl[n].length=L;             L=-1;             sl[n+1].offset=p-strs+1;             n++;         }         p++;         L++;     }     return sl; } //2)  寫一個函數名為ReplaceString，用來將其中的某個字符串(從1開始數)替換成指定的字符串，失敗返回0，成功返回1 （50分） unsigned char ReplaceString(char *strs, unsigned int strNum, char *strReplace) {     STR_LIST *StrList = NULL;     int L1,L2,i,MoveLen;     unsigned int strCount = 0;      StrList=SplitString(strs, &strCount);     if (0<strNum && strNum<=strCount) {         L1=strlen(strReplace);         L2=StrList[strNum-1].length;         if (L1!=L2) {             MoveLen=2;             for (i=strNum;i<(int)strCount;i++) MoveLen+=StrList[i].length+1;             if (strNum<strCount) {                 memmove(strs+StrList[strNum].offset-1+L1-L2,strs+StrList[strNum].offset-1,MoveLen);             } else {                 strs[StrList[strNum-1].offset+L1]=0;                 strs[StrList[strNum-1].offset+L1+1]=0;             }         }         for (i=0;i<L1;i++) strs[StrList[strNum-1].offset+i]=strReplace[i];         delete[] StrList;         return 1;     } else {         delete[] StrList;         return 0;     } } void DisplayString(char *strs) {     char *p;      p=strs;     while (1) {         printf("%s\\0",p);         p=p+strlen(p);         if (!*p && !*(p+1)) break;         p++;     }     printf("\n"); } int main() {     unsigned int i;     unsigned int strCount = 0;     STR_LIST *StrList = NULL;     char strs[] =  "abc\0def\0gh\0ijklmnopq\0rstu\0vwxyz\0" ;     StrList = SplitString(strs, &strCount);     for (i = 0; i < strCount; i++) {         printf( "str #%d length = %d, value = %s\n" , i, StrList[i].length, strs + StrList[i].offset);     }     delete[] StrList;     unsigned char r;     r=ReplaceString(strs,10,"XYZ");     printf("r==%d\n",r);DisplayString(strs);     r=ReplaceString(strs,1,"XYZ");     printf("r==%d\n",r);DisplayString(strs);     r=ReplaceString(strs,3,"XYZ");     printf("r==%d\n",r);DisplayString(strs);     r=ReplaceString(strs,4,"XYZ");     printf("r==%d\n",r);DisplayString(strs);     r=ReplaceString(strs,6,"XYZ");     printf("r==%d\n",r);DisplayString(strs);     r=ReplaceString(strs,7,"XYZ");     printf("r==%d\n",r);DisplayString(strs);     return 0; } //str #0 length = 3, value = abc //str #1 length = 3, value = def //str #2 length = 2, value = gh //str #3 length = 9, value = ijklmnopq //str #4 length = 4, value = rstu //str #5 length = 5, value = vwxyz //r==0 //abc\0def\0gh\0ijklmnopq\0rstu\0vwxyz\0 //r==1 //XYZ\0def\0gh\0ijklmnopq\0rstu\0vwxyz\0 //r==1 //XYZ\0def\0XYZ\0ijklmnopq\0rstu\0vwxyz\0 //r==1 //XYZ\0def\0XYZ\0XYZ\0rstu\0vwxyz\0 //r==1 //XYZ\0def\0XYZ\0XYZ\0rstu\0XYZ\0 //r==0 //XYZ\0def\0XYZ\0XYZ\0rstu\0XYZ\0 // 老师，可以讲解一下这题的思路么？谢谢！


Question: 求助 两个文件（行列不同）找出次数成比例的数据

你的编程目的是什么

范围是什么?

文件8      文件4 次数9     次数5 次数8    次数4 次数7   次数3 ？ - ？ -次数9    次数6 ？ 次数8   次数5 ？ 次数7  次数4 ？ - ？ -次数2   次数1 ？


Question: 初学者对于指针的疑问，望解答。

引用 2 楼 aboluo67 的回复:可能我的想法不被认同，但还是期待别人的回复。 （1）指针变量大家都叫它指针，既然是变量就要有存储它的地址，&p就是存储这个指针变量的地址，而p是这个指针变量指向的地址。 （2）*p是表示这个指针变量指向的地址中存储的数据   （%p和%d  ，*p）是分别以什么样的格式输出*p

盲人摸太阳

引用 9 楼 aboluo67 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 盲人摸太阳  新手遇到指针问题很正常，不按你的思路来就是盲人摸太阳？  您的自大真是不要不要的。[/quote] 那是因为我在上大学的时候跟着老师和所谓的高手摸了三年太阳，实在摸不着头脑，后来看了几眼内存窗口中的地址和值与指针变量的对应关系，觉得好几年都在摸太阳中白白浪费掉了。现在我希望后辈别再和我当年一样摸太阳浪费青春了。 至于后辈们就是喜欢摸，我也拦不住。

引用 8 楼 aboluo67 的回复:感谢各位的回复，我继续学习下。 指针是一个值得C程序猿深思的问题，加油吧！

引用 6 楼 zhao4zhong1 的回复:盲人摸太阳  新手遇到指针问题很正常，不按你的思路来就是盲人摸太阳？  您的自大真是不要不要的。

感谢各位的回复，我继续学习下。

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

4楼的写的不错

引用 2 楼 aboluo67 的回复:能告知1+1=2的方法就可以了，为什么要以一种自上而下的模板式语气告知先要去研究哥德巴赫的猜想？ 有意义么？ 可能我的想法不被认同，但还是期待别人的回复。  main( ) {     int A;     int *B;     A = 5;     printf("%p\n",A);	//A的值	  00000005     printf("%p\n\n",&A); //A的地址 0022FF1C       B = &A;     printf("%p\n",B); //指针B的值,引用的A的地址，所以是0022FF1C     printf("%p\n",&B);//指针B的地址，0022FF18     printf("%p\n",*B);//对地址B的值进行解引用,B里面存放的是A的地址0022FF1C，对B解引用即是A的解引用：00000005     printf("%d\n",*B);//同上一行，5  //%p,%d。输出00000005和5没区别，只是printf看你按照什么格式输出的，能转就会帮你转，不能转程序就崩。所以尽量还是用实际的类型%d。     return 0; }  错了别打我，我就是随手乱回的。

感谢老师的回复。  但我想说的是很多学习编程的人不一定就是计算机类专业，不可能按照  “ 计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……“的顺序一步一步学完。  买了本书，网上看看教学视频学习，碰到问题能有人点拨下最好，但出现什么从头DOS汇编什么的开始研究的回复真的感觉很。。怎么说？无语？无奈？  能告知1+1=2的方法就可以了，为什么要以一种自上而下的模板式语气告知先要去研究哥德巴赫的猜想？ 有意义么？  可能我的想法不被认同，但还是期待别人的回复。


Question: 期末作业，就两道题，江湖救急，求大神帮忙！！！

java的好简单 HashMap<String, Integer> map = new HashMap<>(); 		String key; 		for (int i = 0; i < str.length(); i++) { 			for(int j=i+1;j<str.length();j++){ 				key = str.substring(i,j); 				if(!map.containsKey(key)){ 					map.put(key, 1); 				}else{ 					map.put(key, map.get(key)+1); 				} 				 			} 		}

引用 3 楼 zhangxiangDavaid 的回复:必须给你解决它： 第一题  #include <stdio.h> #include <string.h> int *next; void setNext(char *p, int *next) { 	int j, k, len; 	len = strlen(p); 	j = 1; 	next[0] = -1; 	while (j < len) 	{ 		k = next[j - 1]; 		while (k >= 0 && p[j - 1] != p[k]) 			k = next[k]; 		if (k >= 0) next[j] = k + 1; 		else next[j] = 0; 		j++; 	} } int kmp(char *t, char *p) { 	if (NULL == t || NULL == p) return -1; 	int len1, len2, r; 	len1 = strlen(t), len2 = strlen(p); 	len1 = strlen(t); 	len2 = strlen(p); 	if (len1 >= len2) 	{ 		int i, j, k; 		i = j = -1; 		k = len1 - len2; 		while (i <= k && j < len2) 		{ 			if (-1 == j || t[i] == p[j]) 			{ 				i++; 				j++; 			} 			else j = next[j]; 		} 		if (len2 == j) return i - j; 		else return -1; 	} 	return -1; } int main(void) { 	int count = 0; 	char t[] = "abcdefabcdefabcdef"; 	char p[] = "cde"; 	int lenp = strlen(p); 	next = malloc(sizeof(int)*lenp); 	setNext(p, next); 	char *q = t; 	while (-1 != kmp(q, p)) 	{ 		q += strlen(p); 		count++; 	} 	printf("字符串%s在字符串%s中出现的次数是%d\n", p, t, count); 	free(next); 	return 0; }   非常感谢！！！！！！

第二题  #include <stdio.h> void print(int *arr, int n) { 	int i; 	for (i = 0; i < n; i++) printf("%3d", arr[i]); 	printf("\n"); } int main(void) { 	int arr[] = { 1,2,3,4,5 }; 	int n = sizeof(arr) / sizeof(int); 	print(arr, n); 	int m = 2;   //把后m个数移动到前面 	int i, j; 	i = n - 1, j = n - 1 - m; 	int t = arr[i]; 	while (j != n - 1) 	{ 		arr[i] = arr[j]; 		i = j; 		j = (j - m + n) % n; 	} 	arr[i] = t; 	print(arr, n); 	return 0; } //  1  2  3  4  5 //  4  5  1  2  3

学学数据结构的字符串怎么处理，再学学数据结构的排序法吧，努力学习，自力更生

自己做 哥们~~


Question: 谁能编写一个只用txt输出的简易通讯录吗

定义一个记录的结构体，通过读写文件进行实现，其中涉及排序和查找算法。只能帮你到这儿了。


Question: 请教关于数据结构字符串的处理问题和数据结构的排序法问题

給你個建議，貼代碼，學會如下一樣，用code標記出來，讓別人更容易閱讀。  如果你原貼中代碼是你自已寫的，你最好自已先做好注释，這樣別人閱讀你的代碼時，能更快了解你的想法和思路。  下面做个參考吧。有些沒大看明白你想干啥。只是指出有問題的地方，。  #include <iostream> #include <cstring> using namespace std;  //這裡next這個參數定義有問題，在這裡，getnext裡無法對next這個數組進行有效賦值，當出這個函數時，next原來是多少，還是多少。 void getNext(const char* pattern,int next[])  {   next[0]= -1;   int k=-1,j=0;   while(pattern[j]!='\0')     {       if(k!=-1 && pattern[k]!=pattern[j])k=next[k];       ++j;++k;       next[j]=pattern[k]== pattern[j]?next[k]:k;     } }  int KMP(const char *Text,const char* Pattern) {   if(!Text||!Pattern||Pattern[0]=='\0'||Text[0]=='\0' ) return -1;   int len=0;   const char * c=Pattern;   while(*c++!='\0')++len;   int *next=new int[len+1];   getNext(Pattern,next);   int index=0,i=0,j=0;//index代表什么意思？求匹配字符串出現的次數嗎？   while(Text[i]!='\0' && Pattern[j]!='\0' )     {       if(Text[i]== Pattern[j]) ++i,++j;       else//這一段的目的是什麽，很令人费解。好好想想，在這裡next[j]有機會為-1嗎？ 	{ 	  index += j-next[j]; 	  if(next[j]!=-1) j=next[j]; 	  else j=0,++i; 	}     }   delete []next;   //在這裡試想，如果在text中有一个匹配pattern的字符串，你會輸出什麽？是不是0？是不是明顯有問題。   return (Pattern[j]=='\0'?index:-1); } int main() {   char* text="bababCabCadcaabcaababcbaaaabaaacababcaabc";   char* pattern="baaaa";   cout<<KMP(text,pattern)<<endl;   return 0;  }


Question: 【求教】结构体求其所占有的字节数的一些问题。

把编译环境设置成1BYTE对齐，两个计算可能就一样了， 不过默认都有字节对齐，可以加快内存访问速度，

5#是正解。 内存的对齐和补齐规则。 根据你结构体占字节数最大的一个作为标准，也就是结构体中的double是8字节。 不够8字节的补齐，多的整体拿到下面重新占一个8字节。

这个结构应该是13字节, char (1),int (4),double(8), 但默认是8字节对齐 第一个, 是int(4)+char(1)这儿需要补足到8字节边界,加上3字节 , 再加上double(8)=16字节 第二个,是int(4),下一个是8字节,需要补4字节即8字节,加上double(8)为16字节,加上char(1),这需要补7字节,共24字节

struct A { int a;  // 1~4 char b;  // 5 // 6~8 不用 double c;  // 9~16 }; // 一共16 和 struct A { int a;  // 1-4 // 5~8 不用 double c;  // 9~16 char b;  // 17 // 18~24 不用 }; // 一共24

引用 2 楼 lin5161678 的回复:自行百度 内存对齐 没太看懂百度上的。。。能给我就这一个问题讲解一下么

自行百度 内存对齐

仅供参考：#include <stdio.h> #define field_offset(s,f) (int)(&(((struct s *)(0))->f)) struct AD  { int a; char b[13]; double c;}; #pragma pack(push) #pragma pack(1) struct A1  { int a; char b[13]; double c;}; #pragma pack(2) struct A2  { int a; char b[13]; double c;}; #pragma pack(4) struct A4  { int a; char b[13]; double c;}; #pragma pack(8) struct A8  { int a; char b[13]; double c;}; #pragma pack(16) struct A16 { int a; char b[13]; double c;}; #pragma pack(pop) int main() {     printf("AD.a %d\n",field_offset(AD,a));     printf("AD.b %d\n",field_offset(AD,b));     printf("AD.c %d\n",field_offset(AD,c));     printf("\n");     printf("A1.a %d\n",field_offset(A1,a));     printf("A1.b %d\n",field_offset(A1,b));     printf("A1.c %d\n",field_offset(A1,c));     printf("\n");     printf("A2.a %d\n",field_offset(A2,a));     printf("A2.b %d\n",field_offset(A2,b));     printf("A2.c %d\n",field_offset(A2,c));     printf("\n");     printf("A4.a %d\n",field_offset(A4,a));     printf("A4.b %d\n",field_offset(A4,b));     printf("A4.c %d\n",field_offset(A4,c));     printf("\n");     printf("A8.a %d\n",field_offset(A8,a));     printf("A8.b %d\n",field_offset(A8,b));     printf("A8.c %d\n",field_offset(A8,c));     printf("\n");     printf("A16.a %d\n",field_offset(A16,a));     printf("A16.b %d\n",field_offset(A16,b));     printf("A16.c %d\n",field_offset(A16,c));     printf("\n");     return 0; } //AD.a 0 //AD.b 4 //AD.c 24 // //A1.a 0 //A1.b 4 //A1.c 17 // //A2.a 0 //A2.b 4 //A2.c 18 // //A4.a 0 //A4.b 4 //A4.c 20 // //A8.a 0 //A8.b 4 //A8.c 24 // //A16.a 0 //A16.b 4 //A16.c 24 // //


Question: 该如何求解这个问题？是跟全局变量有关吗？

maze在两个源文件中重复定义。修改其中一个为maze1

maze在文件中重复定义，第一次定义在这里


Question: 关于结构体存在栈中还是堆中的问题。

转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。 转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。 转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。 转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。 转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。 转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。 转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。 转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。

VMMap 是进程虚拟和物理内存分析实用工具。http://technet.microsoft.com/zh-cn/sysinternals/dd535533

引用 1 楼 zhangxiangDavaid 的回复:结构体变量同内置类型变量一样会分配内存，至于分配到哪里，也同内置类型一样的规则。 意思是结构体本身和C++的class一样，在声明的时候不分配内存只是告知编译器数据类型吗？ 然后结构体变量是要分配内存的，而且存放在栈中吗？

引用 4 楼 qiezhihuai 的回复:结构体是数据类型，跟int，char等标准类型一样，只占用flash空间，结构体变量是要分配内存的，静态和全局变量在堆中分配，局部变量保存在栈中，包括函数的参数也在栈中分配 意思是结构体本身和C++的class一样，在声明的时候不分配内存只是告知编译器数据类型吗？ 然后结构体变量是要分配内存的，而且存放在栈中吗？

引用 1 楼 zhangxiangDavaid 的回复:结构体变量同内置类型变量一样会分配内存，至于分配到哪里，也同内置类型一样的规则。  學習了，言簡意駭。


Question: C语言指针问题

建议楼主从头看一下指针的内容。

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

#include<stdio.h> /*int main(void) {     int a = 10;     const int *p;     p = &a;     printf("%d\n",*p);     return 0; }*/ int main(void) {     int a = 10;     int b = 20;     const int *p = &a;     printf("%d\n",*p);     return 0; } 第一我也才入门： 不过我把你的两段代码，都试过，都打印了10; 你确定有一段什么都没打印出来

注意*这个符号在声明和表达式是不一样的，const int *p;这句是声明，声明了p的类型是(const int *)。而 *p = &a;是表达式，其中*是操纵符。

这两者是一样的啊！

C指针 http://blog.csdn.net/zhangxiangdavaid/article/details/37885275

嗯，好的，明白了，谢谢了！

你最好再系统看看指针，指针很重要的

指针的初始化有两种方式 第一种就是   类型   *变量名=&同类型变量名 int  a=10； int *p=&a； 第二种   类型 *变量名  这是定义了一个指针变量 然后初始化 例如   int *p； int a=10； p=&a； 这两种效果一样


Question: 用哈希表实现电话号码管理系统，怎么让显示记录的时候让它的名字根据英文顺序排序（例如手机电话本）

hash不排序的, 要么输出前排序,要么换数据结构


Question: CodeBlocks中如何使用findfirst和findnext函数

system("dir /b /a-d c:\\*.* >d:\\allfiles.txt"); //读文件d:\\allfiles.txt的内容即C:\\下所有文件的名字 system("dir /b /a-d /s c:\\*.* >d:\\allfilesinsub.txt"); //读文件d:\\allfilesinsub.txt的内容即C:\\下所有文件的名字包含子目录 system("dir /b /ad  c:\\*.* >d:\\alldirs.txt"); //读文件d:\\alldirs.txt的内容即C:\\下所有子目录的名字 请记住，能用shell命令获取文件、文件夹信息或者操作文件、文件夹最好用shell命令获取或者操作，而不要用各种API获取或者操作，因为当遇到非法文件夹名或非法文件名或非法文件长度、非法文件日期、压缩文件、链接文件、稀疏文件……等各种意料之外的情况时，API会处理的不全面或陷入死循环，而shell命令不会。

恩， 谢谢指点。

是_findfirst吗？  #include <errno.h> #include <stdio.h> #include <stdlib.h> #include <io.h>  int main(int argc, char *argv[]) { 	intptr_t handle; 	struct _finddata_t fileinfo;  	handle = _findfirst("D:\\mymtom\\src\\demo\\*.c", &fileinfo); 	if (handle == -1) { 		perror("_findfirst"); 		exit(1); 	}  	printf("%s\n",fileinfo.name); 	while (_findnext(handle, &fileinfo) == 0) { 		printf("%s\n",fileinfo.name); 	}  	_findclose(handle);  	return 0; }

恩，谢了，我用了w32 api可以编译通过。

问题已解决，和你说的那个函数功能一样，我用的是 FindFirstFile和FindNextFile这两个函数。

我问了别人说win api可以

这几个是windows里面的....


Question: 关于指针数组的练习，请帮忙分析一下，谢谢

四个问题 第一：test[i]在使用之前一定要初始化，否则tefst[i]是一个无效的字符指针。比较方便的改法就是把_TCHAR *test[3];改成_TCHAR test[3][128/*一个足够大的数*/];也可以用malloc对每个test[i]进行赋值，但用完要记得free掉。 第二：scanf, fscanf, sscanf, scanf_s, fscanf_s, sscanf_s 下面有一段： 4-6) Same as (1-3), except that %c, %s, and %[ conversion specifiers each expect two arguments (the usual pointer and a value of type rsize_t indicating the size of the receiving array, …… 大概意思是说对于 %c,%s,%[这三种，对应的参数需要两个，一个普通的指针和这个指针指向数组的大小，也就是说你的scanf_s最后少了一个表示test[i]容量的参数。 第三：printf里的test[length]改成test[i]或者test[length++],length是固定不变的，你这里应该是想遍历元素的，所以升序遍历就改成length++，降序遍历就改成i。 第四：既然你都用了_TCHAR，那么相应的函数也最好换掉。scanf_s改成_tscanf_s，printf改成_tprintf，这两个函数里的字符串都用_T()包裹住，分别改成_T("%s")和_T("%s\n")。

#include <iostream> using namespace std; int main() { 	 	char *test[3]; 	int i=0,length=sizeof(test)/sizeof(test[0]); 	while(length-->0) 	{ 		test[i]=(char*)malloc(1024); 		memset(test[i],0,1024); 		scanf_s("%s",test[i++],10); 	} 	length++; 	while(i-->0) 		printf("%s\n",test[length++]); 	 	/* 	char* p=(char*)malloc(128); 	scanf("%s",p); 	printf("%s\n",p); 	return 0; 	*/ }

指针数组的指针没指向空间。

for(int i=0;i<3;i++) test[i] =malloc(N);

test所指位置不可意料

text指的位置不可遇料

test没有分配内存

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


Question: C，文件简单加密时，自制伪进度条不能实时显示的问题。

引用 13 楼 zhao4zhong1 的回复:查MSDN是Windows程序员必须掌握的技能之一。  英语也是一门计算机语言的说。  恩，消息机制一直有点迷，我会好好看的。

循环未退出前，WM_SETTEXT消息都缓存在the application queue中。

引用 11 楼 zhao4zhong1 的回复:SetDlgItemText The SetDlgItemText function sets the title or text of a control in a dialog box.   BOOL SetDlgItemText(   HWND hDlg,         // handle of dialog box   int nIDDlgItem,    // identifier of control   LPCTSTR lpString   // text to set );   Parameters hDlg  Identifies the dialog box that contains the control.  nIDDlgItem  Identifies the control with a title or text that is to be set.  lpString  Pointer to the null-terminated string that contains the text to be copied to the control.  Return Values If the function succeeds, the return value is nonzero.  If the function fails, the return value is zero. To get extended error information, call GetLastError.   Remarks The SetDlgItemText function sends a WM_SETTEXT message to the specified control.   QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winuser.h.   Import Library: Use user32.lib.   Unicode: Implemented as Unicode and ANSI versions on Windows NT.  See Also Dialog Boxes Overview, Dialog Box Functions, GetDlgItemInt, GetDlgItemText, SetDlgItemInt, WM_SETTEXT     UpdateWindow The UpdateWindow function updates the client area of the specified window by sending a WM_PAINT message to the window if the window's update region is not empty. The function sends a WM_PAINT message directly to the window procedure of the specified window, bypassing the application queue. If the update region is empty, no message is sent.   BOOL UpdateWindow(   HWND hWnd   // handle of window );   Parameters hWnd  Handle to the window to be updated.  Return Values If the function succeeds, the return value is nonzero.  If the function fails, the return value is zero.   Windows NT: To get extended error information, callGetLastError.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winuser.h.   Import Library: Use user32.lib.  See Also Painting and Drawing Overview, Painting and Drawing Functions, ExcludeUpdateRgn, GetUpdateRect, GetUpdateRgn, InvalidateRect, InvalidateRgn, WM_PAINT  我猜一下，是不是当前按钮事件未结束，输出的进度都在队列里，并没有提取出来？

引用 8 楼 zhao4zhong1 的回复:深究的话，建议结合Spy++软件的使用，看看《深入浅出MFC》中分析Windows消息流向的相关章节。  嗯嗯，谢谢赵老师

Multiple Threads in the User Interface http://msdn.microsoft.com/zh-cn/library/ms810439.aspx

引用 4 楼 user-2 的回复:没看代码  但是猜你没用多线程  恩，新手，才学API，还没看到多线程，学了一些东西，所以只是想写个东西贯通一下。

引用 5 楼 zhao4zhong1 的回复:SetDlgItemText(hwnd, 1006, jdt); UpdateWindow(hwnd);//试试看 不行的话： SetDlgItemText(hwnd, 1006, jdt); UpdateWindow(hwnd); MSG msg; if (GetMessage(&msg,NULL,0,0)) {     TranslateMessage(&msg);     DispatchMessage(&msg); } //再试试看     谢谢谢谢，用了第一个果然好了，就是缺少窗口重绘吗，但是为什么有的可以不用重绘也能显示正常。有的又会卡死。重绘作用除了改变窗口大小时还有什么用啊。。

没看代码  但是猜你没用多线程

我是想通过一个只读的文本框填充=号来实现。但是稍微大一点点的文件就没用，界面还是卡主，进度条无填充，直到加密结束，就一次填充完了。

这是fen()的主要代码  struct stat stbuff;                 //以下是fen()的主要部分，前面省去各种初始化。 		stat(sinpdir,&stbuff); 		flen = stbuff.st_size; 		bl = flen / 26;     //26长度 		int i=0; 		while ((enreadcount = fread(enbuffer, 1, enkeylen, pi))>0){     			for (ensc = 0; ensc<enreadcount; ensc++){  				enbuffer[ensc] ^= enkey[ensc];  			} 			fwrite(enbuffer, enreadcount, 1, po); 		 			tj = tj + enreadcount;      //统计实际读取数 			if (tj>bl){             //进度输出部分，超过1/26，添加填充物，输出，清零。 				jdt[i] = '=';    //以‘=’作为进度填充物 				i++; 				tj = 0; 				SetDlgItemText(hwnd, 1006, jdt); 			}	 		}

这是按钮调动的主要代码  case IDC_OK:{ 					    					   int rbc; 					   TCHAR dir[256]; 					   TCHAR jdt1[256]; 					    					   memset(jdt1, '\0', sizeof(jdt1)); 					   HWND hwnd1; 					   int i; 					   int i1; 					   hwnd1 = GetDlgItem(hwnd, IDC_LIEBIAO); 					    					   int ic; 					   ic = ListBox_GetCount(hwnd1); 					   i = 27 / ic;    //27进度长度，具体见fen() 					   i1 = 0; 					   int n = 1; 					    					   for (ic--; ic >= 0; ic--){ 						   memset(dir, '\0', sizeof(dir)); 						   ListBox_GetText(hwnd1, ic, dir); 						   if (0 != fen(hwnd, dir, rbc)){    //fen()，句柄，路径字符串，rbc无关紧要 							   MessageBox(hwnd, TEXT("失败，请检查"), TEXT("错误"), MB_OK | MB_ICONWARNING); 							   break; 						   } 						   info(hwnd, dir, 3); 						    						    						   i = i*n;               //以下文件个数的进度 						   while (i1 < i){ 							   jdt1[i1] = '='; 							   i1++; 						   } 						   n++; 						   SetDlgItemText(hwnd, IDC_ZONG, jdt1); 					   } 					   break; 					 }


Question: 请教fopen打开CSV文件输出时遇汉字乱码

FILE *pf = fopen(str, "r, ccs=UTF-8");  In Visual C++ 2005, fopen supports Unicode file streams. A flag specifying the desired encoding may be passed to fopen when opening a new file or overwriting an existing file, like this:  fopen("newfile.txt", "rw, ccs=<encoding>");  Allowed values of the encoding include UNICODE, UTF-8, and UTF16-LE. If the file is already in existence and is opened for reading or appending, the Byte Order Mark (BOM) is used to determine the correct encoding. It is not necessary to specify the encoding with a flag. In fact, the flag will be ignored if it conflicts with the type of the file as indicated by the BOM. The flag is only used when no BOM is present or if the file is a new file. The following table summarizes the modes used in for various flags given to fopen and Byte Order Marks used in the file.  Flag  No BOM (or new file)  BOM: UTF-8  BOM: UTF-16   UNICODE  ANSI  UTF-8  UTF-16LE   UTF-8  UTF-8  UTF-8  UTF-16LE   UTF-16LE  UTF-16LE  UTF-8  UTF-16LE    If mode is "a, ccs=<encoding>", fopen will first try to open the file with both read and write access. If it succeeds, it will read the BOM to determine the encoding for this file; however, if it fails, it will use the default encoding for the file. In either case, fopen will then re-open the file with write-only access. (This applies to mode a only, not a+.)

应该是格式的问题 .csv文件的格式，要不就用unicode去读，或者是有一个下划线什么open的一个函数也可以 哈哈


Question: 怎么按字节读取报文？

memcpy Copies characters between buffers.  void *memcpy( void *dest, const void *src, size_t count );  Routine Required Header Compatibility  memcpy <memory.h> or <string.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  memcpy returns the value of dest.  Parameters  dest  New buffer  src  Buffer to copy from  count  Number of characters to copy  Remarks  The memcpy function copies count bytes of src to dest. If the source and destination overlap, this function does not ensure that the original source bytes in the overlapping region are copied before being overwritten. Use memmove to handle overlapping regions.  Example  /* MEMCPY.C: Illustrate overlapping copy: memmove  * handles it correctly; memcpy does not.  */  #include <memory.h> #include <string.h> #include <stdio.h>  char string1[60] = "The quick brown dog jumps over the lazy fox"; char string2[60] = "The quick brown fox jumps over the lazy dog"; /*                           1         2         3         4         5  *                  12345678901234567890123456789012345678901234567890  */  void main( void ) {    printf( "Function:\tmemcpy without overlap\n" );    printf( "Source:\t\t%s\n", string1 + 40 );    printf( "Destination:\t%s\n", string1 + 16 );    memcpy( string1 + 16, string1 + 40, 3 );    printf( "Result:\t\t%s\n", string1 );    printf( "Length:\t\t%d characters\n\n", strlen( string1 ) );     /* Restore string1 to original contents */    memcpy( string1 + 16, string2 + 40, 3 );     printf( "Function:\tmemmove with overlap\n" );    printf( "Source:\t\t%s\n", string2 + 4 );    printf( "Destination:\t%s\n", string2 + 10 );    memmove( string2 + 10, string2 + 4, 40 );    printf( "Result:\t\t%s\n", string2 );    printf( "Length:\t\t%d characters\n\n", strlen( string2 ) );     printf( "Function:\tmemcpy with overlap\n" );    printf( "Source:\t\t%s\n", string1 + 4 );    printf( "Destination:\t%s\n", string1 + 10 );    memcpy( string1 + 10, string1 + 4, 40 );    printf( "Result:\t\t%s\n", string1 );    printf( "Length:\t\t%d characters\n\n", strlen( string1 ) ); }   Output  Function:   memcpy without overlap Source:      fox Destination:   dog jumps over the lazy fox Result:      The quick brown fox jumps over the lazy fox Length:      43 characters  Function:   memmove with overlap Source:      quick brown fox jumps over the lazy dog Destination:   brown fox jumps over the lazy dog Result:      The quick quick brown fox jumps over the lazy dog Length:      49 characters  Function:   memcpy with overlap Source:      quick brown dog jumps over the lazy fox Destination:   brown dog jumps over the lazy fox Result:      The quick quick brown dog jumps over the lazy fox Length:      49 characters   Buffer Manipulation Routines  See Also   _memccpy, memchr, memcmp, memmove, memset, strcpy, strncpy


Question: 关于ffmpeg编码效率问题

请问，解决了吗？ 我的问题是，解码4k视频时，ffmpeg3.x 很慢，大约一帧30Ms，但2.8版本就很快，一帧1Ms

我的4320*2160的分辨率编码要70ms, 太慢了, 咋破?

您好，我想请问一下，如何把编码速率、编码后图像的信噪比打印在屏幕上呢

ffmpeg编码应该不会如此慢? 你是4K屏幕? 1920x1080, 25FPS我觉得应该没问题,你再查查, 另外你测试逻辑是否正确呢?

桌面录制似乎不太适合用mpeg编码。 搜一搜这方面的开源项目。


Question: linux下连接math.h出错求解

引用 2 楼 ben040502 的回复:引用 1 楼 zhao4zhong1 的回复:return (int)floor(log((double)i));我试了，可还是不行啊。。。 引用 3 楼 zhao4zhong1 的回复:gcc -o -lm a test.o fun.o 试试看。恩，编译通过了，生成目标文件和连接时都需要加-lm，谢谢

gcc -o -lm a test.o fun.o 试试看。

return (int)floor(log((double)i));


Question: c语言期末考试（江湖救急）

引用 1 楼 zhao4zhong1 的回复:题目有错。 对于不是数值类型的行或列，有可能无法求出所谓的最大、最小值，也无法排序。+1,算法啥的去这里找找吧 https://github.com/707wk/Senior-middle-school/blob/master/Filling%20in%20the%20gaps.c


Question: 大神们，能给我一个c语言的俄罗斯方块的程序吗，tc下的，感激不尽啊！！！

百度没有吗？

百度上都是，可以去下载

没找到。。。


Question: 关于自绘窗的问题

引用 5 楼 user-2 的回复:[quote=引用 4 楼 qq_18599547 的回复:] [quote=引用 1 楼 user-2 的回复:] The WM_PAINT Message 这个消息,我把自绘代码写进去 好像就自动的无限重绘![/quote] 你是不没加BeginPaint和EndPaint。给你个例子：Drawing in the Client Area[/quote] 这个是拷贝DC么? 我确实没加

引用 1 楼 user-2 的回复:The WM_PAINT Message 这个消息,我把自绘代码写进去 好像就自动的无限重绘!

引用 2 楼 fly_dragon_fly 的回复:画标题栏是响应的NCPAINT吗 是呀 我响应的是这个消息 然后超出边界后 就自绘. 但是移动速度快了 会闪速. 而且有的部分还没有绘制好.

画标题栏是响应的NCPAINT吗

The WM_PAINT Message

引用 4 楼 qq_18599547 的回复:[quote=引用 1 楼 user-2 的回复:] The WM_PAINT Message 这个消息,我把自绘代码写进去 好像就自动的无限重绘![/quote] 你是不没加BeginPaint和EndPaint。给你个例子：Drawing in the Client Area


Question: 各位大神帮帮忙看我哪里错了啊

还有个小问题，main里面的循环怎么结束呀？如果必须按Ctrl+C那就有点太暴力了 一般是给个选择比如输入0就跳出循环结束程序

代码没什么大问题。 你选择2选项之前，有没有先选择1来建立这个文件呢？必须先用1来建立这个文件，然后才能用2读呀。 选择了1之后，选择2之前先看看这个文件有没有创建成功、内容是否正确，这样可以定位是1的问题还是2的问题。  这里有个小错误，出错没有处理，不过暂时不是大问题。     if((fp=fopen("e:\\student.txt","w"))==NULL)     printf("请输入添加运动员的数量");


Question: 急！急！帮忙看看这段代码

你应该说明你的问题，这样其他人才好帮你


Question: 求推荐学习C语言的书籍

引用 21 楼 zhao4zhong1 的回复:常规、解除锁定。 嗯，文件可以打开了，谢谢。

引用 23 楼 ForestDB 的回复:真正学C的书自然推荐TCPL  http://en.cppreference.com/w/  http://www.cplusplus.com/reference/  http://en.cppreference.com/w/Cppreference:Archives  另外推荐CSAPP和APUE作为“课外书”。  嗯，谢谢。

引用 12 楼 zhao4zhong1 的回复:[quote=引用 11 楼 dear_Alice_moon 的回复:] [quote=引用 10 楼 zhao4zhong1 的回复:] 换个网站下载Win-TC，貌似你这个版本没带tcstudy.chm 哦，好的，应该到那个网站上去下载这个软件呢？   [/quote] 那随便换几个试试了，我也记不得当初我是下载哪家网站上的了。 总之有tcstudy.chm文件就行。 但我的意思并不是推荐你用Win-TC环境实际编程。 Windows下实际编程，我还是推荐： http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装 [/quote]  昨天 刚在淘宝下了订单买了书,今天听你的,下载vc2010

常规、解除锁定。

引用 12 楼 zhao4zhong1 的回复:[quote=引用 11 楼 dear_Alice_moon 的回复:] [quote=引用 10 楼 zhao4zhong1 的回复:] 换个网站下载Win-TC，貌似你这个版本没带tcstudy.chm 哦，好的，应该到那个网站上去下载这个软件呢？   [/quote] 那随便换几个试试了，我也记不得当初我是下载哪家网站上的了。 总之有tcstudy.chm文件就行。 但我的意思并不是推荐你用Win-TC环境实际编程。 Windows下实际编程，我还是推荐： http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装 [/quote]  好的，谢谢您，赵老师。我自己下载下看看，谢谢。

引用 11 楼 dear_Alice_moon 的回复:[quote=引用 10 楼 zhao4zhong1 的回复:] 换个网站下载Win-TC，貌似你这个版本没带tcstudy.chm 哦，好的，应该到那个网站上去下载这个软件呢？   [/quote] 那随便换几个试试了，我也记不得当初我是下载哪家网站上的了。 总之有tcstudy.chm文件就行。 但我的意思并不是推荐你用Win-TC环境实际编程。 Windows下实际编程，我还是推荐： http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装

引用 10 楼 zhao4zhong1 的回复:换个网站下载Win-TC，貌似你这个版本没带tcstudy.chm 哦，好的，应该到那个网站上去下载这个软件呢？

换个网站下载Win-TC，貌似你这个版本没带tcstudy.chm

引用 8 楼 zhao4zhong1 的回复:先下载Win-TC，然后参考C:\Win-TC\tcstudy.chm  嗯，谢谢赵老师。我下载了Win-TC，但是这个解压软件包不在C盘中，我将其放在了E盘里。就赵老师你所说的“C:\Win-TC\tcstudy.chm”这个文件路径我找不到，我的C盘中没有Win-TC文件！  这个是我E盘的Win-TC解压路径图片。

引用 12 楼 zhao4zhong1 的回复:[quote=引用 11 楼 dear_Alice_moon 的回复:] [quote=引用 10 楼 zhao4zhong1 的回复:] 换个网站下载Win-TC，貌似你这个版本没带tcstudy.chm 哦，好的，应该到那个网站上去下载这个软件呢？   [/quote] 那随便换几个试试了，我也记不得当初我是下载哪家网站上的了。 总之有tcstudy.chm文件就行。 但我的意思并不是推荐你用Win-TC环境实际编程。 Windows下实际编程，我还是推荐： http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装 [/quote]  嗯，给赵老师推荐一个网址：http://www.itellyou.cn/，这个网址上也有好多使用的工具可以下载，比在Microsoft 上下载感觉更加方便。哈哈   有时间希望赵老师可以回复一下我的这则贴— — http://bbs.csdn.net/topics/391056990，谢谢。

先下载Win-TC，然后参考C:\Win-TC\tcstudy.chm

引用 16 楼 zhao4zhong1 的回复:Win7下需要以管理员身份运行，以XP兼容模式运行，在弹出的对话框中选择“信任”，……  抱歉，回复赵老这么晚，刚刚真的是部门有些事情，自己过去帮下忙！哈哈

引用 17 楼 zhao4zhong1 的回复:我也曾在一个月黑风高的夜晚，Win7下打开某个心仪的.chm文件时遇到跟楼主一样  的闹心事！   嗯，谢谢赵老师的解惑和对自己学习经历的分享。我曾经在安装Matlab7.0软件时，一次偶然的机会在Win7系统下，也是通过右键——>属性，将兼容模式该为Windows XP兼容模式，之后Matlab软件可以正常运行。关于对于Matlab 7.0软件的安装，当时（也就是2015年4月份左右）我自己还在这里发过帖子，当时赵老师也回复过。  嗯，现在遇到的问题是，当我点击鼠标右键——>属性时，没有出现兼容模式之类的选项，出现的是下面的图片。我将每个选项都自己截图制作了一张图片，不知道这个手册的问题如何解决！

引用 14 楼 zhao4zhong1 的回复:为方便广大C语言初学者，我将tcstudy.chm上传一份到我的资源里吧。(虽然有盗版之嫌) http://download.csdn.net/detail/zhao4zhong1/8830817 再次激赏CSDN上传资源的审核速度！（莫非是AI?）  谢谢赵老师的好意，真的谢谢。但是，最后下载下来的tcstudy.chm成这样，我也真的是醉了！自己在想想办法吧！

引用 5 楼 misskissC 的回复:仅供参考（C）： 《Linux C编程一站式学习》 《30天自制操作系统》 （《自己设计制作CPU与单片机》） 《深入理解操作系统》  ----CSDN上的小伙伴  嗯，谢谢你。这个我的这则贴邀请赵老师了，可能因为今天是端午节放假，赵老师没有“上班”吧，哈哈。

"C语言以.chm为后缀名的手册"找赵老湿


Question: 如何C源文件，引用其他文件的自定义类型？

引用 1 楼 user-1 的回复:把需要的类型、函数声明都拿出来，放到.h头文件里面，然后在.c文件里面包含.h头文件  你好，能针对这个源代码详细点说一下吗？

#include <stdio.h> //standard input output 标准输入输出头文件 #include <malloc.h> //memory allocation分配  /**  * 使用了BasicForTree的struct TreeNode  */ extern struct TreeNode; typedef struct TreeNode BinTree; typedef BinTree * ElementType;  typedef struct Node { 	ElementType Data; 	struct Node *next; } LinkStack;  /**  * 初始化一个头结点为空的Stack  * init a stack with a NULL head  */ LinkStack * InitStack() { 	LinkStack *s = (LinkStack *) malloc(sizeof(LinkStack)); 	s->next = NULL; 	return s; }  /**  * 若stack为空返回1,否则返回0  */ int IsStackEmpty(LinkStack *s) { 	return s->next == NULL; }  /**  * 入栈  */ void Push(LinkStack *s, ElementType e) { 	struct Node *p; 	p = (LinkStack *) malloc(sizeof(LinkStack)); 	p->Data = e; 	p->next = s->next; 	s->next = p; }  /**  * 出栈  */ ElementType Pop(LinkStack *s) { 	/*if(IsStackEmpty(s)){ 	 printf("Stack is NULL"); 	 return NULL; 	 }*/ 	if (s->next == NULL) { 		printf("Stack is NULL"); 		return NULL; 	} 	ElementType TopElem; 	struct Node *top; 	top = s->next; 	s->next = top->next; 	TopElem = top->Data; 	free(top); 	return TopElem; }  /**  * 返回栈顶元素  */ ElementType getTop(LinkStack *s) { 	if (s->next == NULL) { 		printf("Stack is NULL"); 		return NULL; 	} 	return s->next->Data; }       /*  * Queue  *  *  Created on: 2015年5月31日  *      Author: xing  */ #include <stdio.h> #include <malloc.h>  #define MaxSize 50 /**  * 使用了BasicForTree的struct TreeNode  */ extern struct TreeNode; typedef struct TreeNode BinTree; typedef BinTree * ElementType;  typedef struct { 	ElementType Data[MaxSize]; 	int front; 	int rear; } Queue;  Queue * InitQueue() { 	Queue *q = (Queue *) malloc(sizeof(Queue)); 	return q; }  void Destory(Queue * q) { 	free(q); }  int IsQueueEmpty(Queue *q) { 	return q->front = q->rear; }  void EnQueue(Queue *q, ElementType e) { 	if ((q->rear + 1) % MaxSize == q->front) { 		printf("队列满了"); 		return; 	} 	q->rear = (q->rear + 1) % MaxSize; 	q->Data[q->rear] = e; }  ElementType DeQueue(Queue* q) { 	if (q->front == q->rear) { 		printf("队列空了！"); 		return NULL; 	} 	q->front = (q->front + 1) % MaxSize; 	return q->Data[q->front]; }     #include <stdio.h> #include <malloc.h>  extern LinkStack; extern Queue; extern Queue * InitQueue(); extern LinkStack * InitStack();  typedef int ElementType; typedef struct TreeNode BinTree; typedef struct TreeNode { 	ElementType Data; 	BinTree *Left; 	BinTree *Right; };  /**  * 层序生成二叉树  */ BinTree *CreateBinTree() { 	ElementType Data; 	BinTree *BT, *T; 	Queue *Q = InitQueue(); 	scanf("%d", &Data); 	if (Data) { 		BT = (BinTree *) malloc(sizeof(BinTree)); 		BT->Data = Data; 		EnQueue(Q, BT); 	} 	while (!IsQueueEmpty(Q)) { 		T = DeQueue(Q); 		scanf("%d", &Data); 		if (Data) { 			T->Left = (BinTree *) malloc(sizeof(BinTree)); 			T->Left->Data = Data; 			EnQueue(Q, T->Left); 		} else { 			T->Left = NULL; 		} 		scanf("%d", &Data); 		if (Data) { 			T->Right = (BinTree *) malloc(sizeof(BinTree)); 			T->Right->Data = Data; 			EnQueue(Q, T->Right); 		} else { 			T->Right = NULL; 		} 	} 	return BT; }  /**  * 遍历二叉树 递归算法  */ void PreOrderTraversal(BinTree *BT) { 	if (BT) { //BT != NULL 		printf("%d", BT->Data); 		PreOrderTraversal(BT->Left); 		PreOrderTraversal(BT->Right); 	} }  void InOrederTraversal(BinTree *BT) { 	if (BT) { 		InOrederTraversal(BT->Left); 		printf("%d", BT->Data); 		InOrederTraversal(BT->Right); 	} }  void PostOrderTraversal(BinTree *BT) { 	if (BT) { 		PostOrderTraversal(BT->Left); 		PostOrderTraversal(BT->Right); 		printf("%d", BT->Data); 	} }  /**  * 遍历二叉树 非递归算法  */ void PreOrderTraversal_Iter(BinTree *BT) { 	BinTree *T; 	LinkStack *S = InitStack(); 	T = BT;  	while (T || !IsStackEmpty(S)) { 		while (T) { 			printf("%d", T->Data); 			Push(S, T); 			T = T->Left; 		} 		if (!IsStackEmpty(S)) { 			T = Pop(S); 			T = T->Right; 		} 	} }  void InOrderTraversal_Iter(BinTree *BT) { 	BinTree *T; 	LinkStack *S = InitStack(); 	T = BT;  	while (T || !IsStackEmpty()) { 		while (T) { 			Push(S, T); 			T = T->Left; 		} 		if (!IsStackEmpty()) { 			T = Pop(S); 			printf("%d ", T->Data); 			T = T->Right; 		} 	} }  void PostOrderTraversal_Iter1(BinTree *BT) { 	BinTree *T, *p, *b; 	LinkStack *S = InitStack(); 	T = BT; 	int flag = 0; 	do { 		while (T) { 			Push(S, T); 			T = T->Left; 		} 		flag = 1; 		p = NULL; 		while (!IsStackEmpty() && flag) { 			b = getTop(S); 			if (p == b->Right) { 				printf("%d ", b->Data); 				p = Pop(S); 			} else { 				T = T->Right; 				flag = 0; 			} 		} 	} while (!IsStackEmpty(S)); }  void PostOrderTraversal_Iter2(BinTree *BT) { 	BinTree *p, *cur; 	LinkStack *S = InitStack(); 	p = NULL; 	cur = NULL; 	Push(S, BT); 	while (!IsStackEmpty()) { 		cur = getTop(S); 		if ((!cur->Left && !cur->Right)   //NULL==cur->Left && NULL==cur->Right 		|| (p && (p == cur->Left || p == cur->Right))) { 			printf("%d ", cur->Data); 			p = Pop(S); 		} else { 			if (cur->Right) { 				Push(S, cur->Left); 			} 			if (cur->Left) { 				Push(S, cur->Right); 			} 		} 	} }  void LevelOrderTraversal(BinTree *BT) { 	BinTree *T; 	T = BT; 	if (!T) { 		return; 	} 	Queue *Q = InitQueue(); 	EnQueue(Q, T); 	while (!IsQueueEmpty()) { 		T = DeQueue(Q); 		printf("%d ", T->Data); 		if (T->Left) 			EnQueue(T->Left); 		if (T->Right) 			EnQueue(T->Right); 	} }  void getOrderPrintLeaves(BinTree *BT) { 	while (BT) { 		if (!BT->Left && !BT->Right) { 			printf("%d", BT->Data); 		} 		getOrderPrintLeaves(BT->Left); 		getOrderPrintLeaves(BT->Right); 	} }  void getOrderPrintLeaves_Iter(BinTree *BT) { 	BinTree *T; 	LinkStack *S = InitStack(); 	T = BT;  	while (T || !IsStackEmpty(S)) { 		while (T) { 			Push(S, T); 			T = T->Left; 		} 		if (!IsStackEmpty(S)) { 			T = Pop(S); 			if (!BT->Left && !BT->Right) { 				printf("%d", BT->Data); 				T = Pop(S); 			} 			T = T->Right; 		} 	} }  int PostOrderGetHeight(BinTree *BT) { 	int LH, RH, MaxH; 	if (BT) { 		LH = PostOrderGetHeight(BT->Left); 		RH = PostOrderGetHeight(BT->Right); 		MaxH = (LH > RH ? LH : RH); 		return MaxH + 1; 	} 	return 0; }  int PostOrderGetHeight_Iter(BinTree *BT) { 	return 0; }