Question: utf-8 和 GB2312 汉字编码方式问题

问题已解决，Linux下采用iconv函数  *************************main.c***************************** #include <stdio.h> #include <stdlib.h> #include <string.h>  #include "iconv_app.h" #include "file.h"  #define OUTLEN 255 int main(void) { 	int rc; 	char *in_utf8 = "靠靠?;//"姝ｅ?ㄥ??瑁?"; 	char *in_gb2312 = "正在安装"; 	char out[OUTLEN];  while(1) { file_open();  //unicode码转为gb2312码 rc = u2g(in_utf8,strlen(in_utf8),out,OUTLEN); printf("unicode-->gb2312 out=%s\n",out); file_write_string(out);  //gb2312码转为unicode码 rc = g2u(in_gb2312,strlen(in_gb2312),out,OUTLEN); printf("gb2312-->unicode out=%s\n",out); file_write_string(out);  file_close(); sleep(10); } 	  return 0; }   ******************iconv_app.c*************************** #include <stdio.h> #include <stdlib.h> #include <string.h> #include <iconv.h>   //代码转换:从一种编码转为另一种编码 int code_convert(char *from_charset,char *to_charset,char *inbuf,int inlen,char *outbuf,int outlen) { iconv_t cd; int rc; char **pin = &inbuf; char **pout = &outbuf;  cd = iconv_open(to_charset,from_charset); if (cd==0) return -1; memset(outbuf,0,outlen); if (iconv(cd,pin,&inlen,pout,&outlen)==-1) return -1; iconv_close(cd); return 0; } //UNICODE码转为GB2312码 int u2g(char *inbuf,int inlen,char *outbuf,int outlen) { return code_convert("utf-8","gb2312",inbuf,inlen,outbuf,outlen); } //GB2312码转为UNICODE码 int g2u(char *inbuf,size_t inlen,char *outbuf,size_t outlen) { return code_convert("gb2312","utf-8",inbuf,inlen,outbuf,outlen); }

如果你用的是linux g++，那么就要用iconv库，转换下就可以了

//TXT文件用于表示UTF8编码的文件头 const unsigned char szHead[3] = {0xEF, 0XBB, 0XBF}; FILE *pFile = fopen("d:\\2.txt", "w"); fwrite(szHead, sizeof(char), 3, pFile); //fprintf(所在位置:经度%f,纬度%f,地址:%s); //.... fclose(pFile); pFile = NULL;   创建TXT文件的时候写入0XEF,0XBB,0XBF表示这个TXT文件是以UTF8进行编码的，这样打开TXT文件就不会看到乱码了。  当然也可以用MultiByteToWideChar和WideCharToMultiByte转换成GBK编码再写

utf-8 非常不自然， wide char 自然但是和 ASCII不兼容，所以才有那么多麻烦

我在发送http请求的时候，加入Accept-Charset: GB2312 http响应报文，仍然还是 Content-Type: text/xml;charset=utf-8 Error-Code: 0 Error-Text:   我能不能这种方式得到GB2312编码的汉字，发送GB2312 http请求

wide char就是个过渡的垃圾。  为什么不将源文件保存为utf-8，然后 gcc sourcefile.c -finput_charset = utf-8 fexec-charset = gbk

顶层软件C++ java我不太懂啊，我用C语言和汇编。Linux GCC用的最多。

MultiByteToWideChar The MultiByteToWideChar function maps a character string to a wide-character (Unicode) string. The character string mapped by this function is not necessarily from a multibyte character set.   int MultiByteToWideChar(   UINT CodePage,         // code page   DWORD dwFlags,         // character-type options   LPCSTR lpMultiByteStr, // address of string to map   int cchMultiByte,      // number of bytes in string   LPWSTR lpWideCharStr,  // address of wide-character buffer   int cchWideChar        // size of buffer );   Parameters CodePage  Specifies the code page to be used to perform the conversion. This parameter can be given the value of any code page that is installed or available in the system. You can also specify one of the following values: Value Meaning  CP_ACP ANSI code page  CP_MACCP Macintosh code page  CP_OEMCP OEM code page  CP_SYMBOL Symbol code page (42)  CP_THREAD_ACP The current thread's ANSI code page  CP_UTF7 Translate using UTF-7  CP_UTF8 Translate using UTF-8    dwFlags  A set of bit flags that indicate whether to translate to precomposed or composite wide characters (if a composite form exists), whether to use glyph characters in place of control characters, and how to deal with invalid characters. You can specify a combination of the following flag constants: Value Meaning  MB_PRECOMPOSED Always use precomposed characters — that is, characters in which a base character and a nonspacing character have a single character value. This is the default translation option. Cannot be used with MB_COMPOSITE.  MB_COMPOSITE Always use composite characters — that is, characters in which a base character and a nonspacing character have different character values. Cannot be used with MB_PRECOMPOSED.  MB_ERR_INVALID_CHARS If the function encounters an invalid input character, it fails and GetLastError returns ERROR_NO_UNICODE_TRANSLATION.   MB_USEGLYPHCHARS Use glyph characters instead of control characters.    A composite character consists of a base character and a nonspacing character, each having different character values. A precomposed character has a single character value for a base/non-spacing character combination. In the character è, the e is the base character and the accent grave mark is the nonspacing character.   The function's default behavior is to translate to the precomposed form. If a precomposed form does not exist, the function attempts to translate to a composite form.   The flags MB_PRECOMPOSED and MB_COMPOSITE are mutually exclusive. The MB_USEGLYPHCHARS flag and the MB_ERR_INVALID_CHARS can be set regardless of the state of the other flags.   lpMultiByteStr  Points to the character string to be converted.  cchMultiByte  Specifies the size in bytes of the string pointed to by the lpMultiByteStr parameter. If this value is –1, the string is assumed to be null terminated and the length is calculated automatically.  lpWideCharStr  Points to a buffer that receives the translated string.  cchWideChar  Specifies the size, in wide characters, of the buffer pointed to by the lpWideCharStr parameter. If this value is zero, the function returns the required buffer size, in wide characters, and makes no use of the lpWideCharStr buffer.  Return Values If the function succeeds, and cchWideChar is nonzero, the return value is the number of wide characters written to the buffer pointed to by lpWideCharStr.   If the function succeeds, and cchWideChar is zero, the return value is the required size, in wide characters, for a buffer that can receive the translated string.   If the function fails, the return value is zero. To get extended error information, call GetLastError. GetLastError may return one of the following error codes:  ERROR_INSUFFICIENT_BUFFER ERROR_INVALID_FLAGS ERROR_INVALID_PARAMETER ERROR_NO_UNICODE_TRANSLATION  Remarks The lpMultiByteStr and lpWideCharStr pointers must not be the same. If they are the same, the function fails, and GetLastError returns the value ERROR_INVALID_PARAMETER.   The function fails if MB_ERR_INVALID_CHARS is set and it encounters an invalid character in the source string. An invalid character is one that would translate to the default character if MB_ERR_INVALID_CHARS was not set, but is not the default character in the source string, or when a lead byte is found in a string and there is no valid trail byte for DBCS strings. When an invalid character is found, and MB_ERR_INVALID_CHARS is set, the function returns 0 and sets GetLastError with the error ERROR_NO_UNICODE_TRANSLATION.  Windows CE: Windows CE does not support the CP_UTF7 and CP_UTF8 values for the CodePage parameter.  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 winnls.h.   Import Library: Use kernel32.lib.  See Also Unicode and Character Sets Overview, Unicode and Character Set Functions, WideCharToMultiByte


Question: C语言结构体的问题。。oj上一直runtime error

可以用STL中的multimap来做。。

改成1000000 这么大的数组，直接栈溢出了 楼主的算法有问题，去网上搜索一下查找第N大的算法 这个用不用链表都没有影响


Question: “编写程序，将句中所有单词的顺序颠倒输出。” 这个是否可以递归实现？

#include <stdio.h> #include <stdlib.h> #include <string.h> char inStr[80+1]; char outStrs[40+1][80+1]; int main() {	gets(inStr); 	int len = strlen(inStr); 	int wordNum = 0; 	int i, j = 0; 	for (i = 0; i < len; i++) 	{ 		if (inStr[i] == ' ')//按空格划分单词  		{ 			j = 0; 			wordNum++; 			continue; 		} 		outStrs[wordNum][j] = inStr[i]; 		j++;  	} 	for (i = wordNum; i > 0 ; i--) 	{ 		printf("%s ", outStrs[i]); 	} 	printf("%s\n", outStrs[0]);  	return 0; }

可以递归,不过这种递归走了极端,是一种递归的误用

#include <stdio.h>  void funiction() { 	char ch=getchar(); 	if(ch!='\n')funiction(); 	printf("%c",ch); }  int main () { 	funiction(); 	return 0; }

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

楼上各种淫才。。。

void reverse( char* InP, char* OutP ) { 	if( InP==NULL || OutP==NULL ) return; 	char *p; 	p = strstr( InP, " " ); 	if( p==NULL ) 	{ 		strcat( OutP, InP ); 		return; 	} 	 	reverse( p+1, OutP ); 	strncat( OutP, InP, p-InP ); } void main() { 	char a[100]="afda affsdfa adfafaf"; 	char b[100]; 	reverse( a, b ); }

#include <stdio.h> #include <string.h>  void reverse (char* buf) {     char* p = strchr(buf, ' '); 	if (p) 	{ 		*p = 0; 		reverse(p+1); 	}     printf("%s ", buf); }  int main(){  	char buf[1000]; 	//scanf("%s", buf);	//用字符串直接模拟吧，就不输入了     strcpy(buf,"a b c d e f g h i j k l m n");//多个词的用例 	reverse(buf); 	printf("\r\n");  	strcpy(buf,"a");	//单个词的用例 	reverse(buf); 	printf("\r\n");  	return 0; }    output:  n m l k j i h g f e d c b a a Press any key to continue

void reverse(存放数据的数组地址，单词的个数，数组的下标)//小标从0开始 { if(单词的个数>1) reverse(数组地址，单词个数自减1，数组下标自加1)； printf(数组地址[数组下标]); }


Question: 遇到小麻烦：acos(1.0000)居然返回： -1.#IND00

为啥？？、、、

自变量超过了定义域


Question: 黑白棋小游戏--C语言学了半年

引用 3 楼 u013163178 的回复:[quote=引用 2 楼 zxh707wk 的回复:] [quote=引用 1 楼 zhao4zhong1 的回复:] http://www.baidu.com/s?wd=%E9%BB%91%E7%99%BD%E6%A3%8B%E5%B0%8F%E6%B8%B8%E6%88%8F--C%E8%AF%AD%E8%A8%80&rsv_spt=1&issp=1&f=8&rsv_bp=0&rsv_idx=2&ie=utf-8&tn=baiduhome_pg  正是有楼主这样连度娘都懒得用的衣食父母，本ID才有论坛积分赚啊！+1[/quote][/quote]

引用 1 楼 zhao4zhong1 的回复:http://www.baidu.com/s?wd=%E9%BB%91%E7%99%BD%E6%A3%8B%E5%B0%8F%E6%B8%B8%E6%88%8F--C%E8%AF%AD%E8%A8%80&rsv_spt=1&issp=1&f=8&rsv_bp=0&rsv_idx=2&ie=utf-8&tn=baiduhome_pg  正是有楼主这样连度娘都懒得用的衣食父母，本ID才有论坛积分赚啊！+1

引用 2 楼 zxh707wk 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] http://www.baidu.com/s?wd=%E9%BB%91%E7%99%BD%E6%A3%8B%E5%B0%8F%E6%B8%B8%E6%88%8F--C%E8%AF%AD%E8%A8%80&rsv_spt=1&issp=1&f=8&rsv_bp=0&rsv_idx=2&ie=utf-8&tn=baiduhome_pg  正是有楼主这样连度娘都懒得用的衣食父母，本ID才有论坛积分赚啊！+1[/quote]


Question: 怎样把反斜杠\，不被当成转义字符处理

都过去一年多了啊 楼主现在有没有好的解决方案啊 ，我今天也遇到这样的问题。我是把字符串转换为stringBuilder 借助这个类的insert方法 在“\”这个字符的index下标前插入一个“\”这样就算解决了。

这样写： \\\\

谢谢各位 我还是用笨方法吧，转义字符也没几个，我挨个在字符串中查找，如找到某个转义字符，先替换成"-"，然后再在“-”后加上因配合转义字符丢掉的那个字母就行了

引用 1 楼 user-8 的回复:两个就行了 \\+1

引用 4 楼 linhan007 的回复:[quote=引用 2 楼 alln0211 的回复:] while(str[i]!='\0') {      if(str[i]=='\\')          {str[i]='-';} }  同样行不通。字符'\'，会自动和'\r'一块变成转义字符[/quote] 用fprintf把字符串写到文本里，再用fgetchar去读呢？

将半角\替换为全角＼

"\\PCS\rConverterUDCtotal_1"，这个字符串里面只有一个反斜杠。\r 这个写法只是 C++ 的字符串的写法，\r 是回车，看不到反斜杠的。 可以看作是： @"\PCS<return>ConverterUDCtotal_1"，<return> 就是回车符。

文件夹名字不允许有\

引用 5 楼 user-8 的回复:[quote=引用 3 楼 linhan007 的回复:] [quote=引用 1 楼 user-8 的回复:] 两个就行了 \\ 字符限定是"\\PCS\rConverterUDCtotal_1"，你可以试一下行不行。字符'\'，会自动和'\r'一块变成转义字符[/quote]文件或文件夹里边不能有\ /等等字符。[/quote] 文件的命名里是不能有\字符，所以用这此字符串用来命名文件前，我才要把反斜杠替换掉。问题是单个反斜杠怎样替换，怎样不被当做转义字符？

引用 3 楼 linhan007 的回复:[quote=引用 1 楼 user-8 的回复:] 两个就行了 \\ 字符限定是"\\PCS\rConverterUDCtotal_1"，你可以试一下行不行。字符'\'，会自动和'\r'一块变成转义字符[/quote]文件或文件夹里边不能有\ /等等字符。

引用 2 楼 alln0211 的回复:while(str[i]!='\0') {      if(str[i]=='\\')          {str[i]='-';} }  同样行不通。字符'\'，会自动和'\r'一块变成转义字符

引用 1 楼 user-8 的回复:两个就行了 \\ 字符限定是"\\PCS\rConverterUDCtotal_1"，你可以试一下行不行。字符'\'，会自动和'\r'一块变成转义字符

两个就行了 \\


Question: 给出一种将非素数分解为素数的算法，希望各位大神高手能帮忙优化

可以用递归，代码精简一些

Finding prime numbers - Kenneth Haugland Different schemas for finding prime numbers explained with code http://www.codeproject.com/Articles/429694/Finding-prime-numbers


Question: 如何取得常量在文件中的偏移

个人意见：6楼代码有画蛇添足之嫌。

#include <stdio.h>   #include <windows.h>   #include <stdlib.h> #include <string.h> #include <malloc.h> #include <io.h> FILE *f; char cmd[256]; char fn[256]; char fn_old[256]; char fn_new[256]; char *b,*p; int fl,i; unsigned long GetFileoffset(const char*FileName,void*VirtualAddress)   {   int pos=-1;     FILE *fp;       IMAGE_DOS_HEADER DOS_header;            //DOS头结构       IMAGE_NT_HEADERS nt_header;             //PE头结构       IMAGE_SECTION_HEADER *psection_header;  //节表结构指针       fp=fopen(FileName,"rb");     fread(&DOS_header,sizeof(struct _IMAGE_DOS_HEADER),1,fp);            fseek(fp,DOS_header.e_lfanew,0);       fread(&nt_header,sizeof(struct _IMAGE_NT_HEADERS),1,fp); 	unsigned long RVA=(unsigned long)VirtualAddress-nt_header.OptionalHeader.ImageBase;      psection_header = new IMAGE_SECTION_HEADER[nt_header.FileHeader.NumberOfSections];       fread(psection_header,nt_header.FileHeader.NumberOfSections*sizeof(struct _IMAGE_SECTION_HEADER),1,fp); 	for(int i=0;i<nt_header.FileHeader.NumberOfSections-1;i++) 	{ 		if(psection_header[i].VirtualAddress<=RVA&&RVA>psection_header[i+1].VirtualAddress) 		{ 			pos=i; 			break; 		} 	} 	if(pos==-1)pos=nt_header.FileHeader.NumberOfSections-1;     unsigned long PointerToRawData=RVA-psection_header[pos].VirtualAddress+psection_header[pos].PointerToRawData;       fclose(fp);          return PointerToRawData;   }    int main() {     char *a="hello world!";     printf("%s",a);     GetModuleFileName(NULL,fn,256);     sprintf(fn_old,"%s_old",fn);     sprintf(fn_new,"%s_new",fn);     f=fopen(fn,"rb");     if (NULL==f) {         printf("Can not open file %s!\n",fn);         return 1;     }     fl=filelength(fileno(f));     b=(char *)malloc(fl);     fread(b,1,fl,f);     fclose(f);     b[GetFileoffset(fn,a)]='G';     f=fopen(fn_new,"wb");     if (NULL==f) {         printf("Can not create file %s!\n",fn_new);         free(b);         return 2;     }     fwrite(b,1,fl,f);     fclose(f);     free(b);     if (!access(fn_old,0)) remove(fn_old);     sprintf(cmd,"cmd.exe /c ren \"%s\" \"%s\"© \"%s\" \"%s\" >NUL 2>NUL",fn,strrchr(fn_old,'\\')+1,fn_new,fn);     WinExec(cmd,SW_HIDE);     return 0; }    谢谢大神zhao4zhong1 的指点 ，在此基础上我修改了一下，让新人少走弯路，希望你不要介意。

这没有办法吧

最终版：#include <stdio.h> #include <stdlib.h> #include <string.h> #include <malloc.h> #include <io.h> #include <windows.h> FILE *f; char cmd[256]; char fn[256]; char fn_old[256]; char fn_new[256]; char *b,*p; int fl,i; int main() {     char a[]="hello world!1";      printf("%s",a);      GetModuleFileName(NULL,fn,256);     sprintf(fn_old,"%s_old",fn);     sprintf(fn_new,"%s_new",fn);     f=fopen(fn,"rb");     if (NULL==f) {         printf("Can not open file %s!\n",fn);         return 1;     }     fl=filelength(fileno(f));     b=(char *)malloc(fl);     fread(b,1,fl,f);     fclose(f);     for (i=0;i<fl-14;i++) {         if (0==memcmp(b+i,"hello world!",12) && b[i+12]) {             b[i+12]=0x63-b[i+12];             break;         }     }     f=fopen(fn_new,"wb");     if (NULL==f) {         printf("Can not create file %s!\n",fn_new);         free(b);         return 2;     }     fwrite(b,1,fl,f);     fclose(f);     free(b);     if (!access(fn_old,0)) remove(fn_old);     sprintf(cmd,"cmd.exe /c ren \"%s\" \"%s\"© \"%s\" \"%s\" >NUL 2>NUL",fn,strrchr(fn_old,'\\')+1,fn_new,fn);     WinExec(cmd,SW_HIDE);      return 0; } //C:\test>changemyself //hello world!1 //c:\test>changemyself //hello world!2 //c:\test>changemyself //hello world!1 //c:\test>changemyself //hello world!2

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <malloc.h> #include <io.h> #include <windows.h> FILE *f; char cmd[256]; char fn[256]; char fn_old[256]; char fn_new[256]; char *b,*p; int fl,i; int main(int argc,char **argv) {     char a[]="hello world!1";      printf("%s",a);      sprintf(fn    ,"%s.exe",argv[0]);     sprintf(fn_old,"%s_old.exe",argv[0]);     sprintf(fn_new,"%s_new.exe",argv[0]);     f=fopen(fn,"rb");     if (NULL==f) {         printf("Can not open file %s!\n",fn);         return 1;     }     fl=filelength(fileno(f));     b=(char *)malloc(fl);     fread(b,1,fl,f);     fclose(f);     for (i=0;i<fl-14;i++) {         if (0==memcmp(b+i,"hello world!",12) && b[i+12]) {             b[i+12]=0x63-b[i+12];             break;         }     }     f=fopen(fn_new,"wb");     if (NULL==f) {         printf("Can not create file %s!\n",fn_new);         free(b);         return 2;     }     fwrite(b,1,fl,f);     fclose(f);     free(b);     if (!access(fn_old,0)) remove(fn_old);     sprintf(cmd,"cmd.exe /c ren \"%s\" \"%s\"© \"%s\" \"%s\" >NUL 2>NUL",fn,fn_old,fn_new,fn);     WinExec(cmd,SW_HIDE);      return 0; }

你的意思是在生成的可执行文件中修改这个字符串？


Question: 求一段简单病毒程序及杀毒代码

想研究病毒，就自己多花时间精力。 不要寄希望在别人给简单代码。

病毒起码得能自我复制吧,你们那算病毒吗,那新手每天都在写病毒.

任何一个死循环分配内容都是病毒程序

我曾经在网上贴过欢乐时光的代码，被封号了。

while(1) int *a=new int[10000];

病毒代码 {       while(1)         交叉感染; }  杀毒代码 {       if(找到你)  干死你个B养的; }


Question: 求大神告诉我哪里出错了，详细点，谢谢~~~~

自己用debug模式调试跟踪一下，在while((!sign)&&(bot<=end))处设置个断点看看各个变量的值，然后F10单步跟踪看看查找流程

修改了23行、38行和40行，添加了49行 数字是从大到小排列的，你的逻辑是从小到大排列

#include <stdio.h> #define N 5  void main() { 	int a[N],i,num,bot,end,mid,loc,sign; 	char c; 	printf("请从大到小输入N个数:"); 	scanf("%d",&a[0]); 	i=1; 	while(i<N) 	{ 		scanf("%d",&a[i]); 		if(a[i]<=a[i-1]) 			i++; 		else 			printf("输入错误,请重新输入："); 	} 	while(1) 	{ 		printf("请输入要查找的数:"); 		scanf("%d",&num); 		if(num>a[0]||num<a[N-1]) 			loc=-1; 		bot=0; 		end=N-1; 		sign=0; 		while((!sign)&&(bot<=end)) 		{ 			mid=(bot+end)/2; 			if(num==a[mid]) 			{ 				loc=mid; 				printf("%d是第%d个数\n",num,loc+1); 				sign=1; 			} 			else if(num<a[mid]) 				bot=mid+1; 			else 				end=mid-1; 		} 		if(loc==-1||!sign) 			printf("此数不在范围内.\n"); 		printf("是否继续查找?(Y/N):"); 		getchar(); 		scanf("%c",&c); 		if(c=='N'||c=='n') 			break; 		sign = 0; 	} }

#include <stdio.h> #define N 5 int main() { 	int arr[N] = {}; 	int flag = 1; 	while(flag) 	{ 		printf("input five number(a,b,...):"); 		scanf("%d,%d,%d,%d,%d", &arr[0], &arr[1],&arr[2], &arr[3], &arr[4]); 		int num; 		printf("input find number:"); 		scanf("%d", &num); 		int i = 0; 		for(i = 0; i < N; ++i) 		{ 			if(arr[i] == num) 			{ 				printf("have number%d, index = %d\n\r", arr[i], i); 				flag = 0; 				break; 			} 		} 		if(flag != 0) 			printf("not find number\n\r"); 	} 	return 0; }  写代码注意规范， 实在不想看， 干脆重新给你写一个算了


Question: 大神速进！switch里的default问题

既然说到了指针。  理解和讨论之前请先学会如何观察！  计算机组成原理→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

引用 10 楼 ttrmsdsunsr 的回复:[quote=引用 9 楼 sholber 的回复:] 照你的想法， switch (/* …… */) {     default : /* ……*/;     case 1: /* …… */;     case 2: /* …… */; } 这样就Okay了。你试试看！大神，再问一个简单的问题。。。 int a[3]; scanf("%d",&a); 还是int a[3]; scanf("%d",a);[/quote]  首先，前一个问题的回答，我说的是反话，你不会信以为真，以为default提到前面就Okay吧？ 第二个问题，scanf函数需要一个指针。尽管从理论上，scanf ("%d", & a)和scanf ("%d", a)都可以接受，但实际上它们是不同的。因为a的类型是数组（int [3]），所以，&a的类型是指向数组的指针（int (*) [3]）。 相反，除非做为一元&运算符和sizeof运算符的操作数，数组a在表达式中会被调整为指向数组首元素的指针。所以，正确的做法是scanf ("%d", a);

引用 9 楼 sholber 的回复:照你的想法， switch (/* …… */) {     default : /* ……*/;     case 1: /* …… */;     case 2: /* …… */; } 这样就Okay了。你试试看！大神，再问一个简单的问题。。。 int a[3]; scanf("%d",&a); 还是int a[3]; scanf("%d",a);

引用 5 楼 user-4 的回复:那么,你选'A'就执行了x++和y++ 而你选'B'就只执行了y++大神，再问一个简单的问题。。。 int a[3]; scanf("%d",&a); 还是int a[3]; scanf("%d",a);

引用 4 楼 user-4 的回复:switch内的break只是跳出switch  标准模式  switch(...) {       case  1:....;break;       case  2:....;break;       case  'A':x++;       case  'B':y++;break;       default:.....;break; } 1和2和default都单独有break,那么他们各自独立做了一件事情 'A'和'B'共用一个break; 那么'A'在前,'A'做的'B'没做,但'B'做'A'也要做 任何一个选项都做事情,只到遇到break跳出switch为止.太厉害了!大神！

break；

那么,你选'A'就执行了x++和y++ 而你选'B'就只执行了y++

引用 1 楼 user-4 的回复:因为你最后一个case后,没有break 大神，default后还用加break吗。 还有一个问题，case后面如果加break不就跳出整个循环了吗。那第二个字母怎么输进来？

那DEFAULT后还用加break吗

因为你最后一个case后,没有break


Question: 黑白棋 小游戏编写


Question: c指针

void myprintf(char* fmt, ...)  {  char* pArg=NULL; char *p; char c;   pArg = (char*) &fmt; //你觉得这句是什么什么意思

计算机组成原理→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

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


Question: 请大神看一下我的程序为什么OJ通不过，一直wrong answer

引用 5 楼 fly_dragon_fly 的回复:把abs换掉 OK，accepted解决了，换成if语句判断，小于零求反就解决了。谢谢

引用 4 楼 u013163178 的回复:输入是03:00,你用int来接受u输入,真的好吗 用int接受03和00，系统就当3和0处理了。不影响计算啊？

把abs换掉

输入是03:00,你用int来接受u输入,真的好吗

引用#2 00:00 06:00也对啊，分别是0.00与180.00，没问题啊

试试 00:00 06:00

上面输出是 90.00 172.50 没复制完全


Question: 对于一个数组x 将相同的x值对应的y(x)取平均值 应该怎么实现？急急急~~~~~~

引用 2 楼 darksworld 的回复:[quote=引用 1 楼 ri_aje 的回复:] 可以按 x 值排序，然后同 x 的点就相邻了，然后再遍历一遍，把相邻同 x 的点求 y 平均即可。 或者直接遍历一遍，用散列表存储同 x 的点。  “把相邻同 x 的点求 y 平均即可”，刚刚忘说x已经按照从小到大排列了，请问具体引号里的这句话具体怎么操作。。。[/quote] 就是这样，比如有点， (1,0) (2,0) (2,1) (2,4) (3,7) (4,1) 那么相邻同 x=2 的点就是 (2,0) (2,1) (2,4) 把他们的 y 值取平均就是 5/3。因为所有点按 x 值已序，所以 x 值相同的点在序列中一定相邻。

查找 累加，计数 相除

double  x[100]={......}; double  y[100]={........}; bool    check[100]={0};     //检查过的数据做个标记,即空间换时间 long    checknum=0;         //检查过的数目  double  cx[100]={0};   //没重复的x值 double  py[100]={0};   //对应y平均值 long    yn[100]={0};   //同x值的个数 long    cn=0;          //无重复的x个数  double   sum=0; double   count=0;  for(int i=0;i<100;i++) { 	if(!check[i]) 	{ 		check[i]=true; 		sum=y[i]; 		count=1; 		cx[cn]=x[i]; 		checknum++; 		for(int j=i+1;j<100;j++) 		{ 			if(x[i]==x[j]) 			{ 				sum+=y[j]; 				count++; 				check[j]=true; 				checknum++; 				yn[cn]++; 			}         } 		py[cn]=sum/count; 		cn++; 	} 	if(checknum>=100) break; }

if(x[i]==x[j])  {                 sum+=y[j];                 count++;                 check[j]=true;                 checknum++;//这个漏了  }

double  x[100]={......}; double  y[100]={........}; bool    check[100]={0};     //检查过的数据做个标记,即空间换时间 long    checknum=0;         //检查过的数目  double   sum=0; double   count=0;  for(int i=0;i<100;i++) { 	if(!check[i]) 	{ 		check[i]=true; 		sum=y[i]; 		count=1; 		checknum++; 		for(int j=i+1;j<100;j++) 		{ 			if(x[i]==x[j]) 			{ 				sum+=y[j]; 				count++; 				check[j]=true; 			}         } 		平均值=sum/count; 	} 	if(checknum>=100) break; } 你可以再定义一个数组来保存平均值

关键要确定x有那几个y对应

引用 1 楼 ri_aje 的回复:可以按 x 值排序，然后同 x 的点就相邻了，然后再遍历一遍，把相邻同 x 的点求 y 平均即可。 或者直接遍历一遍，用散列表存储同 x 的点。  “把相邻同 x 的点求 y 平均即可”，刚刚忘说x已经按照从小到大排列了，请问具体引号里的这句话具体怎么操作。。。


Question: C语言课设问题：五子棋

引用 1 楼 user-2 的回复:还有 木马？那个是运行的exe，360要添加信任

还有 木马？


Question: 关于对话框的回调函数自定义变量位置

BOOL CALLBACK XinZengLuRu (HWND hDlg, UINT message,                             WPARAM wParam, LPARAM lParam) {     TCHAR sXuHao[10],sFileDir[1024];     HWND hList=GetDlgItem(hDlg,LV_A);     switch(message)     {     case WM_INITDIALOG :     {         TCHAR sField[5][50]={"序号","班级","姓名","身份证号"};         ListView_SetExtendedListViewStyle(hList, LVS_EX_GRIDLINES|LVS_EX_CHECKBOXES);         AddList(sField,hList);         return TRUE ;     }     case WM_CLOSE:         EndDialog(hDlg,0);         return 0;     case WM_COMMAND:         switch(LOWORD(wParam))         {         case BT_XUANZE:             ZeroMemory(sFileDir,sizeof(sFileDir));             SetDlgItemText(hDlg,ET_WENJIAN,GetFileDir(sFileDir));                    return 0;         case BT_LURUPL:                          return 0;         }         return 0;     }     return 0; }


Question: 运行后有出乱码

赵4老师都回复了，我只能接分了。 我是谁？

没有‘\0’的原因，那怎么解决啊

_chsize Changes the file size.  int _chsize( int handle, long size );  Routine Required Header Optional Headers Compatibility  _chsize <io.h> <errno.h> 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  _chsize returns the value 0 if the file size is successfully changed. A return value of –1 indicates an error: errno is set to EACCES if the specified file is locked against access, to EBADF if the specified file is read-only or the handle is invalid, or to ENOSPC if no space is left on the device.  Parameters  handle  Handle referring to open file  size  New length of file in bytes  Remarks  The _chsize function extends or truncates the file associated with handle to the length specified by size. The file must be open in a mode that permits writing. Null characters ('\0') are appended if the file is extended. If the file is truncated, all data from the end of the shortened file to the original length of the file is lost.  Example   /* CHSIZE.C: This program uses _filelength to report the size  * of a file before and after modifying it with _chsize.  */  #include <io.h> #include <fcntl.h> #include <sys/types.h> #include <sys/stat.h> #include <stdio.h>  void main( void ) {    int fh, result;    unsigned int nbytes = BUFSIZ;     /* Open a file */    if( (fh = _open( "data", _O_RDWR | _O_CREAT, _S_IREAD                     | _S_IWRITE ))  != -1 )    {       printf( "File length before: %ld\n", _filelength( fh ) );       if( ( result = _chsize( fh, 329678 ) ) == 0 )          printf( "Size successfully changed\n" );       else          printf( "Problem in changing the size\n" );       printf( "File length after:  %ld\n", _filelength( fh ) );       _close( fh );    } }   Output  File length before: 0 Size successfully changed File length after:  329678     File Handling Routines  See Also   _close, _creat, _open  _fileno Gets the file handle associated with a stream.  int _fileno( FILE *stream );  Function Required Header Compatibility  _fileno <stdio.h> 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  _fileno returns the file handle. There is no error return. The result is undefined if stream does not specify an open file.  Parameter  stream  Pointer to FILE structure  Remarks  The _fileno routine returns the file handle currently associated with stream. This routine is implemented both as a function and as a macro. For details on choosing either implementation, see Choosing Between Functions and Macros.  Example   /* FILENO.C: This program uses _fileno to obtain  * the file handle for some standard C streams.  */  #include <stdio.h>  void main( void ) {    printf( "The file handle for stdin is %d\n", _fileno( stdin ) );    printf( "The file handle for stdout is %d\n", _fileno( stdout ) );    printf( "The file handle for stderr is %d\n", _fileno( stderr ) ); }   Output  The file handle for stdin is 0 The file handle for stdout is 1 The file handle for stderr is 2   Stream I/O Routines  See Also   _fdopen, _filelength, fopen, freopen

fopen, _wfopen Open a file.  FILE *fopen( const char *filename, const char *mode );  FILE *_wfopen( const wchar_t *filename, const wchar_t *mode );  Function Required Header Compatibility  fopen <stdio.h> ANSI, Win 95, Win NT  _wfopen <stdio.h> or <wchar.h> 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    The c, n, and t mode options are Microsoft extensions for fopen and _fdopen and should not be used where ANSI portability is desired.  Return Value  Each of these functions returns a pointer to the open file. A null pointer value indicates an error.   Parameters  filename  Filename  mode  Type of access permitted  Remarks  The fopen function opens the file specified by filename. _wfopen is a wide-character version of fopen; the arguments to _wfopen are wide-character strings. _wfopen and fopen behave identically otherwise.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tfopen fopen fopen _wfopen    The character string mode specifies the type of access requested for the file, as follows:  "r"  Opens for reading. If the file does not exist or cannot be found, the fopen call fails.  "w"  Opens an empty file for writing. If the given file exists, its contents are destroyed.  "a"  Opens for writing at the end of the file (appending) without removing the EOF marker before writing new data to the file; creates the file first if it doesn’t exist.  "r+"  Opens for both reading and writing. (The file must exist.)  "w+"  Opens an empty file for both reading and writing. If the given file exists, its contents are destroyed.  "a+"  Opens for reading and appending; the appending operation includes the removal of the EOF marker before new data is written to the file and the EOF marker is restored after writing is complete; creates the file first if it doesn’t exist.  When a file is opened with the "a" or "a+" access type, all write operations occur at the end of the file. The file pointer can be repositioned using fseek or rewind, but is always moved back to the end of the file before any write operation is carried out. Thus, existing data cannot be overwritten.  The "a" mode does not remove the EOF marker before appending to the file. After appending has occurred, the MS-DOS TYPE command only shows data up to the original EOF marker and not any data appended to the file. The "a+" mode does remove the EOF marker before appending to the file. After appending, the MS-DOS TYPE command shows all data in the file. The "a+" mode is required for appending to a stream file that is terminated with the CTRL+Z EOF marker.  When the "r+", "w+", or "a+" access type is specified, both reading and writing are allowed (the file is said to be open for “update”). However, when you switch between reading and writing, there must be an intervening fflush, fsetpos, fseek, or rewind operation. The current position can be specified for the fsetpos or fseek operation, if desired.  In addition to the above values, the following characters can be included in mode to specify the translation mode for newline characters:  t  Open in text (translated) mode. In this mode, CTRL+Z is interpreted as an end-of-file character on input. In files opened for reading/writing with "a+", fopen checks for a CTRL+Z at the end of the file and removes it, if possible. This is done because using fseek and ftell to move within a file that ends with a CTRL+Z, may cause fseek to behave improperly near the end of the file.   Also, in text mode, carriage return–linefeed combinations are translated into single linefeeds on input, and linefeed characters are translated to carriage return–linefeed combinations on output. When a Unicode stream-I/O function operates in text mode (the default), the source or destination stream is assumed to be a sequence of multibyte characters. Therefore, the Unicode stream-input functions convert multibyte characters to wide characters (as if by a call to the mbtowc function). For the same reason, the Unicode stream-output functions convert wide characters to multibyte characters (as if by a call to the wctomb function).  b  Open in binary (untranslated) mode; translations involving carriage-return and linefeed characters are suppressed.   If t or b is not given in mode, the default translation mode is defined by the global variable _fmode. If t or b is prefixed to the argument, the function fails and returns NULL.   For more information about using text and binary modes in Unicode and multibyte stream-I/O, see Text and Binary Mode File I/O and Unicode Stream I/O in Text and Binary Modes.  c  Enable the commit flag for the associated filename so that the contents of the file buffer are written directly to disk if either fflush or _flushall is called.  n  Reset the commit flag for the associated filename to “no-commit.” This is the default. It also overrides the global commit flag if you link your program with COMMODE.OBJ. The global commit flag default is “no-commit” unless you explicitly link your program with COMMODE.OBJ.  Valid characters for the mode string used in fopen and _fdopen correspond to oflag arguments used in _open and _sopen, as follows.  Characters in mode String Equivalent oflag Value for _open/_sopen   a _O_WRONLY | _O_APPEND (usually _O_WRONLY | _O_CREAT | _O_APPEND)  a+ _O_RDWR | _O_APPEND (usually _O_RDWR | _O_APPEND | _O_CREAT )  r _O_RDONLY  r+ _O_RDWR  w _O_WRONLY (usually _O_WRONLY | _O_CREAT | _O_TRUNC)  w+ _O_RDWR (usually _O_RDWR | _O_CREAT | _O_TRUNC)  b _O_BINARY  t _O_TEXT  c None  n None    Example  /* FOPEN.C: This program opens files named "data"  * and "data2".It  uses fclose to close "data" and  * _fcloseall to close all remaining files.  */  #include <stdio.h>  FILE *stream, *stream2;  void main( void ) {    int numclosed;     /* Open for read (will fail if file "data" does not exist) */    if( (stream  = fopen( "data", "r" )) == NULL )       printf( "The file 'data' was not opened\n" );    else       printf( "The file 'data' was opened\n" );     /* Open for write */    if( (stream2 = fopen( "data2", "w+" )) == NULL )       printf( "The file 'data2' was not opened\n" );    else       printf( "The file 'data2' was opened\n" );     /* Close stream */    if( fclose( stream ) )       printf( "The file 'data' was not closed\n" );     /* All other files are closed: */    numclosed = _fcloseall( );    printf( "Number of files closed by _fcloseall: %u\n", numclosed ); }   Output  The file 'data' was opened The file 'data2' was opened Number of files closed by _fcloseall: 1   Stream I/O Routines  See Also   fclose, _fdopen, ferror, _fileno, freopen, _open, _setmode

#include <stdio.h> #include <io.h> int main() {     FILE *fp;     char text[1024]={0};     if ((fp=fopen("D:\\123.txt","rb+"))==NULL)     {         fp=fopen("D:\\123.txt","wb");     }     fprintf(fp,"%s","D:\\123\\VD.exe\r\nF:\\123\\video");     fflush(fp);     _chsize(_fileno(fp),ftell(fp));     rewind(fp);     while (fgets(text,1024,fp)!=NULL)     {         puts(text);     }     fclose(fp);     return 0;  } //D:\123\VD.exe // //F:\123\video //

没有‘\0’的原因

不要沉啊，求大神


Question: 字符串指针与字符串数组的问题

#include <stdio.h> #include <cstdlib> void main(){ 	char st[20],*ps; 	int i; 	printf("input a string:"); 	scanf("%s",st);//改用scanf，直接给数据赋值 	ps=st;//指针指向数组首地址 	for(i=0;ps[i]!='\0';i++) 		if(ps[i]=='k'){ 			printf("there is a 'k' in the string\n"); 			break; 		} 		if(ps[i]=='\0') 			printf("There is no 'k' in the string\n"); 		system ("pause"); }

char st[20],*ps;  //定义了一个数组， 以及一个指针 	int i; 	printf("input a string:"); 	ps=st; //数组名也等于一个指针, 赋值之后ps可以操作st这个数组的内容 	scanf("%s",ps);  //这里不要用scanf_s（）; 不具备通用性， scanf()才是标准C的函数  	for(i=0;ps[i]!='\0';i++)  //for循环要加大括号， 否则第二个if不在for循环的作用域中 	{ 		if(ps[i] == 'k'){ 			printf("there is a 'k' in the string\n"); 			break; 		} 		if(ps[i]=='\0') 			printf("There is no 'k' in the string\n"); 	}

把“scanf_s("%s",ps);”改成“scanf_s("%s",ps，20);”或者“scanf("%s",ps);”

引用 2 楼 fly_dragon_fly 的回复:scans_s 要么指定长度，要么传入数组名，直接传指针不行的 scanf_s("%s", st)  用scanf_s的话确实要指定长度，直接传入指针或数组名都无法得到正确结果

引用 6 楼 adusuccessfully 的回复:另外 char st[20],*ps;     int i;     printf("input a string:");     ps=st;     scanf_s("%s",ps);  我觉得可以简化，没有必要再定义一个指针：  char ps[20]; 	int i; 	printf("input a string:"); 	//scanf("%s",ps); 	scanf_s("%s",ps,20);   嗯，如果优化代码确实是这样，我因为是想把指针学得透彻一点。所以才把代码写成这样

感谢各位的不吝赐教~  自己也验证了一下：把scanf_s("%s",ps);这行代码改成scanf("%s",ps);程序可以得出正确结果，但是依然会有一个安全警告，如果不喜欢可以改成scanf_s("%s",ps,20);或者scanf_s("%s",st,20);程序都可运行出正确结果

我试了，一楼的解答是正确的~~~  #include <stdio.h> #include <cstdlib> void main(){ 	char st[20],*ps; 	int i; 	printf("input a string:"); 	ps=st; 	//scanf("%s",ps); 	scanf_s("%s",ps,20); 	for(i=0;ps[i]!='\0';i++) 		if(ps[i]=='k'){ 			printf("there is a 'k' in the string\n"); 			break; 		} 	if(ps[i]=='\0') 		printf("There is no 'k' in the string\n"); 	system ("pause"); 		//return 0; }  百度一下scanf_s，得知：很多带“_s”后缀的函数是为了让原版函数更安全，传入一个和参数有关的大小值，避免引用到不存在的元素，有时hacker可以利用原版的不安全性黑掉系统。比如:char d[20];写成scanf_s("%s",d,20);才是正确的，有这个参数20使准确性提高。 学习了~~~


Question: P3段无法继续输入，scanf不能运行了，为啥？

p1：,p2：,p3： 这是干啥的？

请判断scanf的返回值！

楼上程序有些瑕疵，换这个：#include <stdio.h> int main() { 	int l, i, r, j, k, m, n; 	int a[1001]; 	char s; 	char b[1001]; 	float t; 	float c[1001]; P1:scanf("%d", &l); 	for (i = 0; i < l; i++) 	{ 		scanf("%d", &a[i]); 	} 	scanf("%d", &r); 	puts("P1 End");  P2:scanf("%d", &m); 	getchar(); 	for (j = 0; j < m; j++) 	{ 		scanf("%c", &b[j]); 		getchar(); 	} 	scanf("%c", &s); 	puts("P2 End");  P3:scanf("%d", &n); 	for (k = 0; k < n; k++) 	{ 		scanf("%f", &c[k]); 	} 	scanf("%f", &t); 	puts("P3 End"); }

这样改：#include <stdio.h> int main() { 	int l, i, r, j, k, m, n; 	int a[1001]; 	char s; 	char b[1001]; 	float t; 	float c[1001]; P1:scanf("%d", &l); 	for (i = 0; i < l; i++) 	{ 		scanf("%d", &a[i]); 	} 	scanf("%d", &r); 	puts("P1 End");     //运行位置输出  P2:scanf("%d", &m); 	getchar(); 	for (j = 0; j < m; j++) 	{ 		scanf("%c", &b[j]); 	} 	getchar(); 	scanf("%c", &s); 	puts("P2 End");      //运行位置输出  P3:scanf("%d", &n); 	for (k = 0; k < n; k++) 	{ 		scanf("%f", &c[k]); 	} 	scanf("%f", &t); 	puts("P3 End");    //运行位置输出 }


Question: 编程题-去掉字符串重复字符

可以用位图算法实现。或者哈希表。就可以提高效率

#include <stdio.h>  void funiction(char* old,char* new) { 	int temp[256]={0}; 	for(;*old;old++) 	{ 		if(temp[*old]==0) 		{ 			*new=*old; 			temp[*old]=1; 			new++; 		} 	} 	*new='\0'; }  int main () { 	char oldstr[100]; 	char newstr[100]; 	gets(oldstr); 	funiction(oldstr,newstr); 	puts(newstr); 	return 0; }

拿第一个和后面的比较，相同的就用后面的字符覆盖；然后拿第二个和后面的比较，相同的就用后面的字符覆盖。依次类推，直到字符串的末尾;

引用 6 楼 user-8 的回复:华为的一道编程题目也就这个，下面是我写的。。  #include <iostream> using namespace std; void stringFilter(const char *pInputStr,long lInputLen,char *pOutputStr) { int i,j; *pOutputStr = *pInputStr; int k=0; for(i=1;i<lInputLen;i++) { bool m_flag=false; for(j=0;j<i;j++) { if(pInputStr[i]==pInputStr[j]) { m_flag=false; break;     } else   m_flag=true; } if(m_flag) pOutputStr[++k]=pInputStr[i]; } pOutputStr[++k]=0; return; } int _tmain(int argc, _TCHAR* argv[]) {     char a[1000]; char *str=a; cin>>str; int len=strlen(a)+1; char b[1000]; stringFilter(str,len,b);//b只能用数组，用指针就报错,要用指针的话要给指针分配内存空间，如用new,或将指针指向一个静态数组 cout<<b; system("pause"); return 0; } 写的代码很好1

楼主可以参考这个帖子，我以前看过~~~http://bbs.csdn.net/topics/390933887

新建一个串，原串逐个边检查边往新串里插入。

查找子串的变体，可以参考一些查炸子串的算法

#include<set> #include<string> #include<iostream> using namespace std;  int main() { 	set<char> s; 	string  str; 	cin >> str; 	for(auto const &a : str) 	{ 		s.insert(a); 	}  	for(auto const &a : s) 	{ 		cout << a; 	} 	cout << endl; }


Question: 问个指针初始化的问题

引用 6 楼 a30037338 的回复:关于第一段代码和第二段代码， 如果不崩溃只能说你的编译器对这种情况做了一些优化或者你运气好， 这个指针指向的内存刚好可以被你操作。我这里VS2010， GCC-4.4.6版本 两个编译器都会奔溃， 这也是必然的。 char * str ;    //这样仅仅是定义了一个指针， 指针指向哪里， 是未知的。 strcpy(); //这个函数修改了一个未知的指针， 这是不可容忍的错误。不论这个指针是一个普通局部变量，还是结构成员， 没有分配内存的指针是野指针。。。  char * str = (char*)malloc(sizeof(char)*10); //这是c的指针的经典用法。  关于  stu.str又不能输出了， 上面已经说了， 对一个未知的指针操作， 程序崩溃才是必然结果+1,你们怎么都喜欢用野指针呢

另外，野指针是可能指向可读可写区域的，所以你有时能运行成功，不出错。

typedef struct __Test {     char *str; }Test_t;   int main(int argc, char *argv[]) {     Test_t stu;     char *str = (char *)malloc(10*sizeof(char));     strcpy(str, "hello 1");     printf("%s\n", str);       stu.str = str;     strcpy(stu.str, "hello 2");     printf("%s\n", stu.str);     return 0; } 试试这样可以输出吗？

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

引用 3 楼 wangjun403 的回复:[quote=引用 2 楼 CharlesSimonyi 的回复:] 使用未初始化指针会产生未定义行为，未定义行为在不同的编译器，不同的平台上会有不同的结果，所以不能做出统一的解释。 比如我这里编译你的代码运行后Debug下报错，Relase下崩溃，均不能正常输出任何内容。 如果感兴趣其背后到底发生了什么可以转到反汇编查看反汇编代码，我这里反汇编后可以看到Debug模式下未初始化的指针都会被编译器初始化为0xcccccccc，从而后面strcpy使用该指针时CRT发现了错误并报错。Relase下该未初始化的指针为0x00000001，从而后面strcpy使用该指针时，触发操作系统的内存访问保护从而程序崩溃结束运行，因为0x00000001的内存是不可访问的。  请问第一个问题 stu.str为什么不提示”未初始化“[/quote]  对于 char *str; 标准地讲，C并没有规定非要产生一个警告（diagnostic message），即使它没有初始化，也没有赋初值。如果C的实现认为它可以检查到这类问题，它可以产生警告，这对C的用户来说是有裨益的，也许还有用户口碑的因素。 对于以上声明，检查可能比较简单，但对其它情况，比如结构内部的指针，C的实现可能要花更多的代价才能检查出问题，这可能是不值得的。所以，C的实现干脆就不能保证它会发现问题。

引用 10 楼 wangjun403 的回复:[quote=引用 8 楼 mymtom 的回复:] 第一段代码会有warning吗？ 第一段有warning，我最奇怪的是第二段没有warning  编译器：MingW4.6[/quote]   typedef struct __Test {     char *str; }Test_t;   int main(int argc, char *argv[]) {     Test_t stu;  //那么请问，这一句都干了什么     strcpy(stu.str, "hello 2");     printf("%s\n", stu.str);     return 0; }

不要相信变量未定义的行为，否则总有一天你会付出很大的代价！ 不要过分相信你的编译器，因为你不可能永远依赖他。就算你依赖他，运行你代码的其他人也不一定会使用它。

引用 8 楼 mymtom 的回复:第一段代码会有warning吗？ 第一段有warning，我最奇怪的是第二段没有warning  编译器：MingW4.6

我在vs2010下试，在debug模式下回崩溃，在release下可以运行 这两种模式下都会有两个warning:一个是说strcpy不安全，建议strcpy_s替换；另一个是：使用了未初始化的局部变量“str”  #include <string> int main(int argc, char *argv[]) { 	char *str; 	strcpy(str, "hello 1"); 	printf("%s\n", str); 	return 0; }   #include <string> typedef struct __Test { 	char *str; }Test_t;   int main(int argc, char *argv[]) { 	Test_t stu; 	strcpy(stu.str, "hello 2"); 	printf("%s\n", stu.str); 	return 0; }

第一段代码会有warning吗？

str 和 stu.str没有初始化，也就是所为的野指针，指向的内存地址是不确定(有可能是已分配的内存空间，即使是没分配的内存空间，也可能以后被分配系统分配给其他变量)，容易造成程序崩溃； str是单独的指针变量，没有初始化所以有警告 stu.str因为结构stu定义的变量，而stu.str是结构体stu的成员变量，所以编译器没给出警告  stu.str不能输出是正常的，原因如上，野指针指向的地址是不确定

楼主试图从内存的角度来理解程序试试,看看你的每一步,对应内存都发生什么.

跟编译器有关！可以让它提示也可以不提是警告

strcpy修改的是对象，而不是指针本身，一个指针不初始化就是一个野指针，用strcpy去修改一个野指针所指的对象是非常危险的，运行时可能发生无法预估的错误。

typedef struct __Test { 	char *str; }Test_t;  int main(int argc, char *argv[]) { 	Test_t stu; 	strcpy(stu.str, "hello 2"); 	printf("%s\n", stu.str); 	return 0; }    第二段代码在我这里编译器VC2010也是会报出warning提示的，仍然是编译器问题。

引用 2 楼 CharlesSimonyi 的回复:使用未初始化指针会产生未定义行为，未定义行为在不同的编译器，不同的平台上会有不同的结果，所以不能做出统一的解释。 比如我这里编译你的代码运行后Debug下报错，Relase下崩溃，均不能正常输出任何内容。 如果感兴趣其背后到底发生了什么可以转到反汇编查看反汇编代码，我这里反汇编后可以看到Debug模式下未初始化的指针都会被编译器初始化为0xcccccccc，从而后面strcpy使用该指针时CRT发现了错误并报错。Relase下该未初始化的指针为0x00000001，从而后面strcpy使用该指针时，触发操作系统的内存访问保护从而程序崩溃结束运行，因为0x00000001的内存是不可访问的。  请问第一个问题 stu.str为什么不提示”未初始化“

我也很困惑，昨天编了个sub_str()函数想仿造Perl的substr，死活出不了结果。。。


Question: 初学者求助！请各位大神帮忙写个代码

这是本人写的，按“＃”更改密码那个想不出来，请各位大神帮忙修改，谢谢了。  #include <f330lib.h>  unsigned char n[4]; unsigned char p[4]={'2','4','1','0'};		// compare password 2410  void keyGetPwd(void)		//define function "keyGetPwd" { 	unsigned char i,j=0;	// unsigned i,j 	lcdInit();		// initialise lcd screen  	lcdSetXY(0,0);		// 1st column and 1st row 	lcdPutStr("WELCOME");		// place "WELCOME" at 1st column and 1st row  	lcdSetXY(0,1);		// 1st column and 2nd row 	lcdPutStr("Password:");		// palce "Password:" at 1st column and 2nd row    	for (i=1;i<5;i++)		// for loop get key char,until i=4,total 4 words(2410) 	{ 		j=keyGet();		// j get from keypad 		lcdPutCh('*');		// "*" is present instead of what char get from key pad 		n[i-1]=j;		// use "*" to clear the word 		  		if (j==0x2A)	// if "*" entered 		{ 			lcdInit();   			lcdSetXY(0,0);      			lcdPutStr("WELCOME");  	  		lcdSetXY(0,1);     			lcdPutStr("Password:");	  			i = 0;		// after clear restart 		}  		else if (j==0X23)	// if "#" entered 		{ 			lcdInit();   			lcdSetXY(0,0);      			lcdPutStr("New Password:");  	  		lcdSetXY(0,1);     			lcdPutStr(""); 		} 	} }  void main (void) { 	unsigned char m = 0; 	 	Init_Device();		// initialize device 	keyInit();		// initialize keypad 	lcdInit();		// initialize lcd screen  	while(1)  	{  		keyGetPwd();		// keygetpassword function       		if ((p[0] == n[0])&&(p[1] == n[1])&&(p[2] == n[2])&&(p[3]))  // compare the n[] array data from key set with unsigned char p[] array 		{   			lcdInit(); 			lcdSetXY(0,0); 			lcdPutStr("WELCOME"); 			lcdSetXY(0,1); 			lcdPutStr("Correct");		// if 2 array are same, display Correct 			m = 0;		// if correct password rerun  		} 		else 		{ 			lcdInit(); 			lcdSetXY(0,0);  			lcdPutStr("WELCOME"); 			lcdSetXY(0,1); 			lcdPutStr("Incorrect");		// if 2 array are not same, display Incorrect 			m++; 			if (m == 3)		// only can keyin 3 times wrong password 			{ 				lcdInit(); 				lcdSetXY(0,1); 				lcdPutStr("Entry is Locked!"); // after key 3 times wrong password display 				while(1);		// refuse any password entry	 			} 		} 				delayms (5000);		// delay 5 seconds 	 	} }

我只需要代码就可以了，非机子不可吗？

关于单片机的，没机子怎么写。。。

简单的密码输入问题。。。


Question: sqlite3_step: errmsg    SQL logic error or missing database

谢谢  问题已经解决了   程序太大了  是在其他线程 因为某些原因把其重新打开 造成的问题

数据库查询逻辑错误或丢失的数据库。

引用 1 楼 user-2 的回复:里面的errmsg不是出现了错误信息的么？还是其他什么问题？  SQL logic error or missing database

引用 1 楼 user-2 的回复:里面的errmsg不是出现了错误信息的么？还是其他什么问题？  我不太清楚 这个错误信息是什么造成的

里面的errmsg不是出现了错误信息的么？还是其他什么问题？

引用 3 楼 q3733353520 的回复:[quote=引用 1 楼 user-2 的回复:] 里面的errmsg不是出现了错误信息的么？还是其他什么问题？  SQL logic error or missing database[/quote] 根据错误信息很明显的可以找问题啊。 要么sql语句出了问题，要么数据库不存在。你可以用SQLite的命令行检查


Question: 求高手解答一个班级选票系统，万分感激！！！

谢了，不过这不是c语言吧

#include <stdio.h>  #include <stdlib.h>  typedef struct node  { // 候选人结构  char name[8];  int num;  int score;  int tax;  }Node;  void shellSort( Node **, int );  int main(void)  {  int n = 0;  Node * pArray[9]={};//指针数组，长度9  int count = 0;  //int status = 1;  int vote = -1;  printf("Input the number of the candidates(1-9):\n");  scanf("%d", &n);  while(getchar()!='\n')  {;  }  while (n>9 || n<1)  {if (n>9)  {printf("No, there cannot be so many candidates. Retry.\n");  }  else{  printf("No candidates? It cannot be! Retry!\n");}  scanf("%d", &n);  while(getchar()!='\n')  { ;}  }  for (count=0; count<n; count++)  {  pArray[count] = (Node *)malloc(sizeof(Node));  pArray[count]->num = count+1;  pArray[count]->tax = 0;  pArray[count]->score = 0;  printf("Input No.%d candidate's name:\n", count+1);  gets(pArray[count]->name);  }  while (vote)  {  printf("Now, let us vote:\n*************\n");  for (count=0; count<n; count++)  {  printf("%d. %s\n", count+1, pArray[count]->name);  }  printf("0.quit\n*************\n");  scanf("%d", &vote);  while(getchar()!='\n')  {  ;  }  while (vote<0 || vote>n)  {  printf("No joke, thank you. Revote.\n");  scanf("%d", &vote);  while(getchar()!='\n')  {  ;  }  }  if (vote>0&&vote<=n)  {  pArray[vote-1]->score++;  }  }  printf("Finish voting. Let's find the winner......\n\n");  shellSort( pArray, n );  for (count=0; count<n; count++)  {  pArray[count]->tax=count+1;  printf("%d. %s %d votes.\n", count+1, pArray[count]->name, pArray[count]->score);  }  for(count=0; count<n; count++)  {  free(pArray[count]);  pArray[count] = NULL;  }  return 0;  }  void shellSort( Node *p[], int len )  {  const int Length = len;  int i = 0;  int j = 0;  int gap = 0;  Node *temp = NULL;  gap = Length/2;  while (gap>0)  {  for (i=gap; i<Length; i++)  {  j = i - gap;  temp = *(p+i);  while ( (j>=0) && (p[j]->score < temp->score) )  {  *(p+j+gap) = *(p+j);  j = j - gap;  }  *(p+j+gap) = temp;  }  gap /= 2;  }  }


Question: c控制台程序如何save&load

console屏幕处理例子程序。终端窗口屏幕处理相关API使用例子。来自MSVC20\SAMPLES\win32\console\ http://download.csdn.net/detail/zhao4zhong1/3461309

我记得控制台程序可以SetConsoleCtrlHandler得到事件，由于不能得到wndproc，并不知道系统在之前做了些什么，最好还是用GUI的消息机制，自己处理一下更为简单

手机码字，有错误的地方，请见谅，在路上，没电脑


Question: 为什么指针字符串无法单个修改？

引用 7 楼 Evankaka 的回复:字符串常量，它是放在静态区的，你改不了的 char *a=new char[10]; a="hello,c."; 然后再来改试试。 记得要delete  不懂就别误人子弟

字符串常量不可改，当然，如果你硬要改那我也拿你没办法

昨天刚看到这个问题  p 指向的是一个常量区, 是不能改变的, 即不能够对p[i]赋值, 而第二种情况下, p是一个字符数组, 其是可以改变的，可以对p[i]赋值的。 你可以看一下char *和char数组的区别

引用 17 楼 ricciinhp 的回复:我觉得我说了很清楚了，虽然有些地方对于新手来说可能会产生误解 对自己的理解能力还是很自信的， 谢谢。

引用 16 楼 ricciinhp 的回复:[quote=引用 14 楼 zerg73 的回复:] [quote=引用 13 楼 ricciinhp 的回复:] [quote=引用 11 楼 ricciinhp 的回复:] [quote=引用 5 楼 zerg73 的回复:] [quote=引用 2 楼 ricciinhp 的回复:] 可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？[/quote] char*是一个指针吧，一个指针占多少个字节？4个，hello.c占几个字节？ 7个 那么编译器怎么让p = “hello.c”成功赋值呢，显然肯定不能直接在栈上初始化 这样编译器就把"hello.c"这个字符串放在整个程序的只读数据区里面，只让char* p取得这个字符串的首地址  而为什么a[] = "hello.c"可以改呢？那是因为a是一个数组，这样编译器就可以直接把那个字符串拷贝到栈上 于是你用a[0]='H'这样操作就能成功执行了[/quote] 其实这么说也会有误导的嫌疑。问题的关键在于char* p是一个指针，它必须是内存中的一个地址，这样就必须把字符串放在内存中的某个位置，好让p指向这个字符串的首地址 至于为什么必须是放在只读数据区里面，我个人觉得这个要涉及到C语言的设计哲学。[/quote] 那我们就不讨论哲学，讨论为什么malloc之后 a="hello,c"; 和 a[0]='h';a[1]='e';a[2]='l';a[3]='l';a[4]=',';a[5]='c';a[6]='\0'; 之间的区别。 为啥前者就不能修改呢？后者可以修改，难道有区别？[/quote] 你malloc之后直接a="helloc,c"是不行的，必须要用strcpy函数拷贝过去 如果用a="helloc,c"，那么a又指向了只读数据区中的字符串，而且这样还造成了内存泄露[/quote] 原来是这样啊。。。。看来有必要写一个等号的重载了，主要strcpy不常用。搞懂问题真开心，可以结帖了

我觉得我说了很清楚了，虽然有些地方对于新手来说可能会产生误解

引用 14 楼 zerg73 的回复:[quote=引用 13 楼 ricciinhp 的回复:] [quote=引用 11 楼 ricciinhp 的回复:] [quote=引用 5 楼 zerg73 的回复:] [quote=引用 2 楼 ricciinhp 的回复:] 可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？[/quote] char*是一个指针吧，一个指针占多少个字节？4个，hello.c占几个字节？ 7个 那么编译器怎么让p = “hello.c”成功赋值呢，显然肯定不能直接在栈上初始化 这样编译器就把"hello.c"这个字符串放在整个程序的只读数据区里面，只让char* p取得这个字符串的首地址  而为什么a[] = "hello.c"可以改呢？那是因为a是一个数组，这样编译器就可以直接把那个字符串拷贝到栈上 于是你用a[0]='H'这样操作就能成功执行了[/quote] 其实这么说也会有误导的嫌疑。问题的关键在于char* p是一个指针，它必须是内存中的一个地址，这样就必须把字符串放在内存中的某个位置，好让p指向这个字符串的首地址 至于为什么必须是放在只读数据区里面，我个人觉得这个要涉及到C语言的设计哲学。[/quote] 那我们就不讨论哲学，讨论为什么malloc之后 a="hello,c"; 和 a[0]='h';a[1]='e';a[2]='l';a[3]='l';a[4]=',';a[5]='c';a[6]='\0'; 之间的区别。 为啥前者就不能修改呢？后者可以修改，难道有区别？[/quote] 你malloc之后直接a="helloc,c"是不行的，必须要用strcpy函数拷贝过去 如果用a="helloc,c"，那么a又指向了只读数据区中的字符串，而且这样还造成了内存泄露

引用 13 楼 ricciinhp 的回复:[quote=引用 11 楼 ricciinhp 的回复:] [quote=引用 5 楼 zerg73 的回复:] [quote=引用 2 楼 ricciinhp 的回复:] 可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？[/quote] char*是一个指针吧，一个指针占多少个字节？4个，hello.c占几个字节？ 7个 那么编译器怎么让p = “hello.c”成功赋值呢，显然肯定不能直接在栈上初始化 这样编译器就把"hello.c"这个字符串放在整个程序的只读数据区里面，只让char* p取得这个字符串的首地址  而为什么a[] = "hello.c"可以改呢？那是因为a是一个数组，这样编译器就可以直接把那个字符串拷贝到栈上 于是你用a[0]='H'这样操作就能成功执行了[/quote] 其实这么说也会有误导的嫌疑。问题的关键在于char* p是一个指针，它必须是内存中的一个地址，这样就必须把字符串放在内存中的某个位置，好让p指向这个字符串的首地址 至于为什么必须是放在只读数据区里面，我个人觉得这个要涉及到C语言的设计哲学。[/quote] 也有可能是为了安全考虑

引用 13 楼 ricciinhp 的回复:[quote=引用 11 楼 ricciinhp 的回复:] [quote=引用 5 楼 zerg73 的回复:] [quote=引用 2 楼 ricciinhp 的回复:] 可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？[/quote] char*是一个指针吧，一个指针占多少个字节？4个，hello.c占几个字节？ 7个 那么编译器怎么让p = “hello.c”成功赋值呢，显然肯定不能直接在栈上初始化 这样编译器就把"hello.c"这个字符串放在整个程序的只读数据区里面，只让char* p取得这个字符串的首地址  而为什么a[] = "hello.c"可以改呢？那是因为a是一个数组，这样编译器就可以直接把那个字符串拷贝到栈上 于是你用a[0]='H'这样操作就能成功执行了[/quote] 其实这么说也会有误导的嫌疑。问题的关键在于char* p是一个指针，它必须是内存中的一个地址，这样就必须把字符串放在内存中的某个位置，好让p指向这个字符串的首地址 至于为什么必须是放在只读数据区里面，我个人觉得这个要涉及到C语言的设计哲学。[/quote] 那我们就不讨论哲学，讨论为什么malloc之后 a="hello,c"; 和 a[0]='h';a[1]='e';a[2]='l';a[3]='l';a[4]=',';a[5]='c';a[6]='\0'; 之间的区别。 为啥前者就不能修改呢？后者可以修改，难道有区别？

引用 11 楼 ricciinhp 的回复:[quote=引用 5 楼 zerg73 的回复:] [quote=引用 2 楼 ricciinhp 的回复:] 可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？[/quote] char*是一个指针吧，一个指针占多少个字节？4个，hello.c占几个字节？ 7个 那么编译器怎么让p = “hello.c”成功赋值呢，显然肯定不能直接在栈上初始化 这样编译器就把"hello.c"这个字符串放在整个程序的只读数据区里面，只让char* p取得这个字符串的首地址  而为什么a[] = "hello.c"可以改呢？那是因为a是一个数组，这样编译器就可以直接把那个字符串拷贝到栈上 于是你用a[0]='H'这样操作就能成功执行了[/quote] 其实这么说也会有误导的嫌疑。问题的关键在于char* p是一个指针，它必须是内存中的一个地址，这样就必须把字符串放在内存中的某个位置，好让p指向这个字符串的首地址 至于为什么必须是放在只读数据区里面，我个人觉得这个要涉及到C语言的设计哲学。

引用 11 楼 ricciinhp 的回复:[quote=引用 5 楼 zerg73 的回复:] [quote=引用 2 楼 ricciinhp 的回复:] 可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？[/quote] char*是一个指针吧，一个指针占多少个字节？4个，hello.c占几个字节？ 7个 那么编译器怎么让p = “hello.c”成功赋值呢，显然肯定不能直接在栈上初始化 这样编译器就把"hello.c"这个字符串放在整个程序的只读数据区里面，只让char* p取得这个字符串的首地址  而为什么a[] = "hello.c"可以改呢？那是因为a是一个数组，这样编译器就可以直接把那个字符串拷贝到栈上 于是你用a[0]='H'这样操作就能成功执行了[/quote] 基本我搞懂我的问题问题出在哪儿了，就是指针a无法对静态数据进行操作，但是为什么我在使用了malloc之后还是不能修改呢？

引用 5 楼 zerg73 的回复:[quote=引用 2 楼 ricciinhp 的回复:] 可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？[/quote] char*是一个指针吧，一个指针占多少个字节？4个，hello.c占几个字节？ 7个 那么编译器怎么让p = “hello.c”成功赋值呢，显然肯定不能直接在栈上初始化 这样编译器就把"hello.c"这个字符串放在整个程序的只读数据区里面，只让char* p取得这个字符串的首地址  而为什么a[] = "hello.c"可以改呢？那是因为a是一个数组，这样编译器就可以直接把那个字符串拷贝到栈上 于是你用a[0]='H'这样操作就能成功执行了

引用 9 楼 Evankaka 的回复:[quote=引用 8 楼 zerg73 的回复:] [quote=引用 7 楼 Evankaka 的回复:] 字符串常量，它是放在静态区的，你改不了的 char *a=new char[10]; a="hello,c."; 然后再来改试试。 记得要delete 就是说new出来的是可以修改的，而C不行？[/quote] C不行？什么意思呢？char *a=“hello,c”。这里hello,c是字符串常量 ，会放在静态区，在整个程序运行时一直都存在，当程序关了后，它才想释放。然后如果是C语言用malloc/free来开辟堆安间[/quote] 刚才我试了一下，如果在malloc之后我写 a="hello,c"; a[0]='H'; 就回程序直接报错，但是如果从0开始单个给a赋值再修改就不会出问题，这又是为什么？

引用 8 楼 zerg73 的回复:[quote=引用 7 楼 Evankaka 的回复:] 字符串常量，它是放在静态区的，你改不了的 char *a=new char[10]; a="hello,c."; 然后再来改试试。 记得要delete 就是说new出来的是可以修改的，而C不行？[/quote] C不行？什么意思呢？char *a=“hello,c”。这里hello,c是字符串常量 ，会放在静态区，在整个程序运行时一直都存在，当程序关了后，它才想释放。然后如果是C语言用malloc/free来开辟堆安间

引用 7 楼 Evankaka 的回复:字符串常量，它是放在静态区的，你改不了的 char *a=new char[10]; a="hello,c."; 然后再来改试试。 记得要delete 就是说new出来的是可以修改的，而C不行？

引用 4 楼 user-6 的回复: #include <stdio.h>  void main() { 	char a[] = "hello,c."; 	char *p ; 	p = a; 	p[0] = 'H'; 	printf("%s",p); }  谢谢，但是书上不是说数组和字符串指针的存储方式一样么，为什么a的类型换成指针就不行了呢？

引用 2 楼 ricciinhp 的回复:可以做个变换，如下： int i = 1; 1 = 2; 你觉得编译器会让你通过吗，骚年？ 这俩不该是两个东西么，书上说指针是变量啊，你那个的第二句不该是i=2？

引用 1 楼 luo_miao 的回复:指针指向的是常量，不能修改。可以这样：  char a[64] = { 0 }; memcpy( a, "hello,c.", strlen("hello,c.") ); a[0] = 'H';  原来指针指向的是常量啊。。。。那么除此之外有别的修改方法吗请问？


Question: make 时出错误~求大神看看

引用 2 楼 ricciinhp 的回复:在msx264.c文件的第58行，将整型值强制转化成指针时出错了，你改一下源代码，如下 void *p = (void*)integer //58行哦  谢谢~

gcc的版本不对。我猜。


Question: C数据结构程序设计

看着好像操作系统的题啊，


Question: 做了个学生信息管理，半成品~~文件内查找有问题，真心求指导不胜感激

void cx_num()     //学号查找 {char ch2;  int a;  FILE *fp;   printf("请输入要查找的学号:\n");  scanf("%d",&a);  printf("--------------------------------------------------------------------------------");  printf("\t\t学号	姓名	性别	年龄	成绩	地址\n");  fp=fopen("stu.txt","r");  ch2=fgetc(fp);  while(ch2!=EOF)  {putchar(ch2);   if(strcmp(ch2,a)==0) // a是数字，ch2是字符，为什么用字符串比较？                                                                                // 不是应该把输入的转换成字符串，然后跟文件中的字符串对比吗？或者都转换为数字也可以    printf("%s",ch2);   // ch2是字符，也不能用%s打印   else    printf("没有找到\n") ;  } }

printf("\t\t学号	姓名	性别	年龄	成绩	地址\n");  fp=fopen("stu.txt","r");  ch2=fgetc(fp);   //把这句放到循环中，  while(ch2!=EOF)  {putchar(ch2);   if(strcmp(ch2,a)==0)    printf("%s",ch2);   else    printf("没有找到\n") ;  }     循环有问题，

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

学号查找和姓名查找那儿，一查就会崩溃

学会发问！再具体点

引用 6 楼 hnwyllmm 的回复:void cx()             //3功能查找 {  system("cls");  printf("--------------------------------------------------------------------------------");  printf("       1.按学号查找              2.按姓名查找              3.返回主菜单\n");  printf("--------------------------------------------------------------------------------\n");  printf("请输入所需要功能对应的数字：\n");  scanf("%d",&choose);  switch(choose)  {  case 1:cx_num();  break;  case 2:cx_name();  break;  default:main();       // 虽然这里没有出错，但是建议楼主不要这样做。这样写，查询次数一多，每次都选3，跑不了多久就会挂的，递归调用占用栈空间，会造成栈溢出  break;  }嗯嗯，学习了


Question: PAT Basic Level 第1020题，一个CASE提示段错误，另外，求教关于double类型数组的排序算法

有没有可可能是总需求量大于总存储量 导致越界呢

Linux： 进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令  Windows： 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。


Question: 关于malloc和字符串常量的问题请教下大家，谢谢

无链接的标识符只能声明一次。傻了吧？ 6.7 Declarations 3 If an identifier has no linkage, there shall be no more than one declaration of the identifier (in a declarator or type specifier) with the same scope and in the same name space, except that: — a typedef name may be redefined to denote the same type as it currently does, provided that type is not a variably modified type; — tags may be redeclared as specified in 6.7.2.3. 4 All declarations in the same scope that refer to the same object or function shall specify compatible types.

你所说的有问题是什么意思。问题描述不清

第一种不行是你重复声明变量Ip1，变量名相同当然不行  你把  char *Ip1="192.168.0.1"; 改成 Ip1="192.168.0.1"; 也是可以的，只是会出现内存泄露

第一种情况char *Ip1=(const char *)malloc(sizeof(char)*16);     char *Ip1="192.168.0.1";  =右边是const型，左为是非const 型，不可以直接赋值，可以去掉const属性。 再执行到第二行时第一行的堆内存会泄露。  第二种情况是定义一个指向常量存储区字符串的指针，没有问题。

char *ip1=(char *)malloc(sizeof(char)*16);   //不要用const char* //char *ip1="192.168.0.1"; //malloc 分配的内存相当于数组， 数组的赋值显然不能这样 sprintf(ip1,"%s", "192.168.0.1");   第二种情况 const char *ip1 = "192.168.0.1"; //字符串的字面值是在只读常量区，要用const char *, 显式的说明这个变量不可改


Question: 算法求解，是牛人过来看看吧。

引用 28 楼 DelphiGuy 的回复:[quote=引用 26 楼 zhao4zhong1 的回复:] 验证到底循环多少次，查表法的速度才刚赶上带进位循环法，其实很简单，将你的初始化表的代码放到循环中。  我为什么要把初始化表的代码放到循环中？那是静态数据，完全可以： static unsigned short LookupTable[256] = {0x0000, 0x0002, 0x0008,...}; 我用一个初始化函数，是为了减少回帖的字数，你滴明白。 引用 27 楼 zhao4zhong1 的回复:我就不信，一次循环的时候，查表法的速度也比带进位循环法快。  没错，把你的代码中两处mov ecx,16都改成mov ecx,1，仍然比查表法慢1/4。  [/quote] 静态数据初始化不需要执行时间的深（qian）奥（xian）道理偶还是明白滴。

我的大体思路如下：   	for(i=15;i>=0;i--) 	{ 		if((1<<i)&X) 			ZLow|=(1<<((i<<1)+1)); 		if((1<<i)&Y) 			ZLow|=(1<<(i<<1));		 		if((1<<(i+16))&X) 			ZHigh|=(1<<((i<<1)+16+1)); 		if((1<<(i+16))&Y) 			ZHigh|=(1<<((i<<1)+16));				 	}

我实在没看懂你想问什么  64位的数据是什么意思 你直接开辟一个2倍大小的数组然后按序交错插入有什么问题

引用 26 楼 zhao4zhong1 的回复:验证到底循环多少次，查表法的速度才刚赶上带进位循环法，其实很简单，将你的初始化表的代码放到循环中。  我为什么要把初始化表的代码放到循环中？那是静态数据，完全可以： static unsigned short LookupTable[256] = {0x0000, 0x0002, 0x0008,...}; 我用一个初始化函数，是为了减少回帖的字数，你滴明白。 引用 27 楼 zhao4zhong1 的回复:我就不信，一次循环的时候，查表法的速度也比带进位循环法快。  没错，把你的代码中两处mov ecx,16都改成mov ecx,1，仍然比查表法慢1/4。

甚至在比如不超过128次的前提下，查表法的效率都可能要低于带进位循环移位法。

引用 20 楼 DelphiGuy 的回复:[quote=引用 19 楼 zhao4zhong1 的回复:] [quote=引用 18 楼 DelphiGuy 的回复:] 抱歉，还真没找到，连6502、8031这种档次的CPU都有循环移位指令。不过在低端处理器上循环移位指令可能会更慢（尤其带进 位循环）。 “8次寄存器循环移位指令”比“1或2次读写内存指令“慢。涨姿势了。[/quote]  1. 在cache命中的情况下，“8次寄存器循环移位指令”肯定比“1或2次读写内存指令“慢，尤其是带进位循环移位。 2. 你的算法用了128次rcl，我的算法用了8次内存读+10次移位+10次逻辑操作，你说哪个快？ 3. 很明显我说的意思是在低端处理器上用循环移位指令实现的算法很可能比查表法慢得更多（相对于PC上的两者速度比）。 [/quote] 略扫一下您老的兴： 如果只计算一次，你的算法需要加上构造查找表的指令，再加上查找表多占的内存，你是不是得承认还是我的办法效率最高？ 顺便要回一丁点我已经丢了的面子（尽管面子不值什么钱和积分）？

我就不信，一次循环的时候，查表法的速度也比带进位循环法快。

引用 23 楼 DelphiGuy 的回复:[quote=引用 21 楼 zhao4zhong1 的回复:] [quote=引用 20 楼 DelphiGuy 的回复:] [quote=引用 19 楼 zhao4zhong1 的回复:] [quote=引用 18 楼 DelphiGuy 的回复:] 抱歉，还真没找到，连6502、8031这种档次的CPU都有循环移位指令。不过在低端处理器上循环移位指令可能会更慢（尤其带进 位循环）。 “8次寄存器循环移位指令”比“1或2次读写内存指令“慢。涨姿势了。[/quote]  1. 在cache命中的情况下，“8次寄存器循环移位指令”肯定比“1或2次读写内存指令“慢，尤其是带进位循环移位。 2. 你的算法用了128次rcl，我的算法用了8次内存读+10次移位+10次逻辑操作，你说哪个快？ 3. 很明显我说的意思是在低端处理器上用循环移位指令实现的算法很可能比查表法慢得更多（相对于PC上的两者速度比）。 [/quote] 略扫一下您老的兴： 如果只计算一次，你的算法需要加上构造查找表的指令，再加上查找表多占的内存，你是不是得承认还是我的办法效率最高？ 顺便要回一丁点我已经丢了的面子（尽管面子不值什么钱和积分）？ [/quote]  查找表是静态的，只需要初始化一次，也可以直接写成初始化数据，我之所以用一个初始化函数，是为了缩短代码，查找表的512字节写成文本有将近 2KB（算上0x前缀和逗号、空格）。你的代码效率太低，没有可比性。 [/quote] 验证到底循环多少次，查表法的速度才刚赶上带进位循环法，其实很简单，将你的初始化表的代码放到循环中。

引用 22 楼 zhao4zhong1 的回复:甚至在比如不超过128次的前提下，查表法的效率都可能要低于带进位循环移位法。  似乎你要表达的意思和你的描述之间并不一致。  rcl/rcr是慢指令，尤其是移多位的情况下，诸如rcl reg,n、rcl reg,cl这样的指令，8条就赶得上查表法整个代码的时间了。你闲得没事干也可以试一试。

引用 9 楼 sholber 的回复:有两个相同元素个数的数组，把这两个数组的元素按位插入，得到新的数组。例如：数组a第一个元素为10，数组b第一个元素为5。数组为int型。那么换算成二进制10为0000 0000 0000 0000 0000 0000 0000 1010.  5的二进制为0000 0000 0000 0000 0000 0000 0000 0101. 按算法规则插入后为。0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1001 1001.    [quote=引用 2 楼 my_live_123 的回复:] 蛮力法：  for(i = 0; i < 32; ++i) result |= (((a >> i) & 0x1) << (2 * i + 1) ) | (((b >> i) & 0x1) << 2 * i  )   有几个问题： 1，将int视为32位是否安全，是否可移植； 2，int在有些机器上可能有填充比特（padding bits），你们这么武断地移来移去是否安全，是否是可移植的？ 3，因为是int，如果最高位是1，>>运算符的行为是否是未定义的？ 不先回答这些问题，怎么搞都没有意义了。[/quote]  你的问题很有价值，这些问题的确需要进一步考虑，谢谢！  这两句姑且认为是伪代码！我只是把数学公式改写成这个样子！

引用 21 楼 zhao4zhong1 的回复:[quote=引用 20 楼 DelphiGuy 的回复:] [quote=引用 19 楼 zhao4zhong1 的回复:] [quote=引用 18 楼 DelphiGuy 的回复:] 抱歉，还真没找到，连6502、8031这种档次的CPU都有循环移位指令。不过在低端处理器上循环移位指令可能会更慢（尤其带进 位循环）。 “8次寄存器循环移位指令”比“1或2次读写内存指令“慢。涨姿势了。[/quote]  1. 在cache命中的情况下，“8次寄存器循环移位指令”肯定比“1或2次读写内存指令“慢，尤其是带进位循环移位。 2. 你的算法用了128次rcl，我的算法用了8次内存读+10次移位+10次逻辑操作，你说哪个快？ 3. 很明显我说的意思是在低端处理器上用循环移位指令实现的算法很可能比查表法慢得更多（相对于PC上的两者速度比）。 [/quote] 略扫一下您老的兴： 如果只计算一次，你的算法需要加上构造查找表的指令，再加上查找表多占的内存，你是不是得承认还是我的办法效率最高？ 顺便要回一丁点我已经丢了的面子（尽管面子不值什么钱和积分）？ [/quote]  查找表是静态的，只需要初始化一次，也可以直接写成初始化数据，我之所以用一个初始化函数，是为了缩短代码，查找表的512字节写成文本有将近 2KB（算上0x前缀和逗号、空格）。你的代码效率太低，没有可比性。

引用 19 楼 zhao4zhong1 的回复:[quote=引用 18 楼 DelphiGuy 的回复:] 抱歉，还真没找到，连6502、8031这种档次的CPU都有循环移位指令。不过在低端处理器上循环移位指令可能会更慢（尤其带进 位循环）。 “8次寄存器循环移位指令”比“1或2次读写内存指令“慢。涨姿势了。[/quote]  1. 在cache命中的情况下，“8次寄存器循环移位指令”肯定比“1或2次读写内存指令“慢，尤其是带进位循环移位。 2. 你的算法用了128次rcl，我的算法用了8次内存读+10次移位+10次逻辑操作，你说哪个快？ 3. 很明显我说的意思是在低端处理器上用循环移位指令实现的算法很可能比查表法慢得更多（相对于PC上的两者速度比）。

引用 18 楼 DelphiGuy 的回复:抱歉，还真没找到，连6502、8031这种档次的CPU都有循环移位指令。不过在低端处理器上循环移位指令可能会更慢（尤其带进 位循环）。 “8次寄存器循环移位指令”比“1或2次读写内存指令“慢。涨姿势了。

引用 6 楼 DelphiGuy 的回复:楼主说的是单片机，您这x86汇编十有八九是不能用的，虽然确实有x86兼容的SOCs，AMD Geode、intel Quark之类的，不过估计楼主的单片机不会是这一类。 单片机没有带进位的循环移位指令，谁信呢？

解决之道是使用unsigned char类型的数组，因为unsigned char和signed char是保证没有填充比特的。唯一需要注意的问题是字节的比特数，当然，你可以假定CHAR_BIT == 8。

俺这个连新数组都省了,新数据直接存在了老数组里 再弄个解密还原的就完整了

不知道俺这么老实的算法入不入得了楼主的法眼 void  ToPassword(long *n1,long *n2) { 	if(n1==NULL||n2==NULL)  		return;  	long H=0,L=0;  	for(int i=15;i>=0;i--) 	{ 		H|=(*n1>>(16+i))&1; 		H<<=1; 		H|=(*n2>>(16+i))&1;  		L|=(*n1>>i)&1; 		L<<=1; 		L|=(*n2>>i)&1;  		if(i>0)  		{ 			H<<=1; 			L<<=1; 		} 	} 	*n1=H; 	*n2=L; }  应用: long  Num1[100]={....}; long  Num2[100]={....};  for(int i=0;i<100;i++) ToPassword(&Num1[i],&Num2[i]);

引用 15 楼 DelphiGuy 的回复:[quote=引用 13 楼 zhao4zhong1 的回复:] [quote=引用 6 楼 DelphiGuy 的回复:] 楼主说的是单片机，您这x86汇编十有八九是不能用的，虽然确实有x86兼容的SOCs，AMD Geode、intel Quark之类的，不过估计楼主的单片机不会是这一类。 单片机没有带进位的循环移位指令，谁信呢？[/quote]  可能有，也可能没有，你不能假定是x86。 [/quote] 求教育，举一个不支持“带进位循环移位指令”的CPU型号。 我觉得“带进位循环移位指令”应该是CPU的标配吧。


Question: 问一下职业方向

慢慢学习，到后面你会发现主要问题都不是 逻辑问题。

软件做到后面就是熟练工了。不会有那么多逻辑的问题。

你做的那些嵌入式都是一些简单application，你想做一些深入的自己就好好学习操作系统（Linux之类的），协议（这个很多，有限无线通信协议，ethernet, wlan, bt, lte, 接口协议,pci, sd, usb, 存储协议/算法, 大数据处理），太多了，其实你还是一个小白

楼主是在校学生吗？若是在校学生的话，找工作是参加校园招聘，可以看看往年各个公司的笔试题，自己就可以有方向地去学习~~~ 这个链接是我15年一些公司的笔试面试题： 2015百度，腾讯，新浪，美团，360，去哪儿网，迈瑞，展讯通信，杰发科校园招聘笔试题（软件开发类） http://download.csdn.net/detail/adusuccessfully/8096019

lz喜欢算法，但不想写代码，那就去找算法研究员之类工作吧。记得要找带“研究员”字样的职位，不是“工程师”职位

看来得高人回帖

我感觉数学比较适合你。

搞哲学吧。 研究一下计算机科学的数学原理。哈哈。


Question: sscanf语句读取 字符串信息

我自己用strstr查找status format_address字符串，后再sscanf，解决了。 这样做能够比较准确的定位到指定的字符串  程序代码： /*********************************sscanf匹配长字符串函数*******************************/ /************************************************************************************/ /************************************************************************************/ /************************************************************************************/ /************************************************************************************/ #include <stdlib.h> #include <stdio.h> #include <string.h>  char data_buff[] = "<GeocoderSearchResponse>\r\n\t<status>0</status>\r\n\tsomething\r\n\t<formatted_address>geocode chinese address here</formatted_address>\r\n</GeocoderSearchResponse>\r\n"; // \t代表table int main(void)  {          int status;         char geo_addr[100];         int ret;                  char *p; printf("data_buff :\n%s\n",data_buff); system("pause");   p = strstr(data_buff,"<status>"); if(p == NULL)     {         printf("<status> Not Found!>");         return (-1);     } printf("p = %s\n",p); ret = sscanf(p,"<status>%d</status>",&status); printf("ret from html: %d\n",ret); printf("status from html: %d\n",status); system("pause");  p = strstr(data_buff,"<formatted_address>"); if(p == NULL)     {         printf("<formatted_address> Not Found!>");         return (-1);     } printf("p = %s\n",p); ret = sscanf(p,"<formatted_address>%[^<]</formatted_address>",geo_addr); printf("ret from html: %d\n",ret); printf("geo_addr from html: %s\n",geo_addr);  return(0);  }

#include <stdio.h> #include <string.h> #include <stdlib.h> char data_buff[] = "<GeocoderSearchResponse>\r\n" "   <status>0</status>\r\n" "   something" "   <formatted_address>geocode chinese address here</formatted_address>\r\n" "</GeocoderSearchResponse>\r\n"; int main() {     int status;     char geo_addr[100];     int ret;      ret=sscanf(data_buff, "<GeocoderSearchResponse>" "%*[^<]<status>%d</status>" "%*s" "%*[^<]<formatted_address>%99[^<]" ,&status,geo_addr);     if (2==ret) {         printf("status from html: %d\n",status);         printf("geo_addr from html: [%s]\n",geo_addr);         return 0;     } else {         printf("Format error:[%s]\n",data_buff);         return 1;     } } //status from html: 0 //geo_addr from html: [geocode chinese address here] //

#include <stdio.h> #include <string.h> #include <stdlib.h> char data_buff[] = "<GeocoderSearchResponse>\r\n" "   <status>0</status>\r\n" "   something" "   <formatted_address>geocode chinese address here</formatted_address>\r\n" "</GeocoderSearchResponse>\r\n"; char *p,*q; int L; int main() {     int status;     char geo_addr[100];     int ret;      p=strstr(data_buff,"<status>");     if (NULL==p) goto ERR;     ret = sscanf(p+strlen("<status>"),"%d",&status);     if (ret!=1) goto ERR;      p=strstr(data_buff,"<formatted_address>");     if (NULL==p) goto ERR;     q=strstr(data_buff,"</formatted_address>");     if (NULL==q || q<p) goto ERR;     L=__min(100-1,q-p-strlen("<formatted_address>"));     strncpy(geo_addr,p+strlen("<formatted_address>"),L);geo_addr[L]=0;     printf("status from html: %d\n",status);     printf("geo_addr from html: [%s]\n",geo_addr);     return 0; ERR:     printf("Format error:[%s]\n",data_buff);     return 1; } //status from html: 0 //geo_addr from html: [geocode chinese address here] //


Question: 急求一个可使用的C语言代码，有关进制的转换

引用 5 楼 Const_User的回复:最终版本：（修改了一下）  #include<stdio.h> #include<string.h> #include<stdlib.h> #include<math.h> #define SIZE 33 int check(char[]);//检查输入数字的合法性，并且返回进制 void toB(int,int,char[],int); void OtoB(char[],int); void DtoB(char[],int); void HtoB(char[],int); void toO(int,int,char[],int); void BtoO(char[],int); void DtoO(char[],int); void HtoO(char[],int); void toD(int,int,char[],int); void BtoD(char[],int); void OtoD(char[],int); void HtoD(char[],int); void toH(int,int,char[],int); void BtoH(char[],int); void OtoH(char[],int); void DtoH(char[],int); void trans(int,int); int AtoI(char); int main(void) { int i,j; char arr[SIZE]; while(i=check(arr)) { printf("请输入您想转换为的进制数(以数字0结束输出)：__\b\b"); scanf("%d",&j); while(j) { switch(j) { case 2:toB(i,j,arr,strlen(arr));break; case 8:toO(i,j,arr,strlen(arr));break; case 10:toD(i,j,arr,strlen(arr));break; case 16:toH(i,j,arr,strlen(arr));break; default: printf("您所输入的数制错误，请输入2、8、10、16！"); } putchar('\n'); printf("请输入您想转换为的进制数(以数字0结束输出)：__\b\b"); scanf("%d",&j); } /*for(int i=0;*(arr+i);i++) *(arr+i)='\0';*/ getchar(); } return 0; } int check(char c_arr[]) { int j; char arr[SIZE]={0}; printf("您的输入为（按两下回车键结束输出）："); while(gets(c_arr)&&c_arr[0])//在新一行不用输任何字符，只需按下回车键结束输入 { 	strcpy(arr,c_arr); if(c_arr[0]=='B') j=2; else if(c_arr[0]=='0'&&(c_arr[1]=='x'||c_arr[1]=='X')) j=16; else if(c_arr[0]=='0') j=8; else if(c_arr[0]>'0'&&c_arr[0]<='9') j=10; else { printf("您的输入有误，请按照如下格式输入：B101、0302、324、0x123、0X123!\n"); printf("您的输入为（按两下回车键结束输出）："); continue; } } strcpy(c_arr,arr); return j; } void toB(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的二进制数为：%*s\n",size-1,c_arr+1); else switch(src) { case 8:OtoB(c_arr,size);break; case 10:DtoB(c_arr,size);break; case 16:HtoB(c_arr,size); } } void OtoB(char c_arr[],int size) { int i,count,sum; printf("输出的二进制数为："); for(i=1,sum=0,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(8,count); trans(sum,2); } void DtoB(char c_arr[],int size) { int i; printf("输出的二进制数为："); trans(atoi(c_arr),2); } void HtoB(char c_arr[],int size) { int i,count,sum; printf("输出的二进制数为："); for(i=2,sum=0,count=size-3;i<size;i++,count--) sum+=AtoI(c_arr[i])*pow(16,count); trans(sum,2); }   void trans(int c_ch,int sys) { if(c_ch>=sys) trans(c_ch/sys,sys); switch(c_ch%sys) { case 10:printf("a");break; case 11:printf("b");break; case 12:printf("a");break; case 13:printf("a");break; case 14:printf("a");break; case 15:printf("a");break; default:printf("%d",c_ch%sys); } }   void toO(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的八进制数为：%*s\n",size-1,c_arr+1); else switch(src) { case 2:BtoO(c_arr,size);break; case 10:DtoO(c_arr,size);break; case 16:HtoO(c_arr,size); } } void BtoO(char c_arr[],int size) { int i,count,sum; printf("输出的八进制数为："); for(i=1,sum=0,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(2,count); trans(sum,8); } void DtoO(char c_arr[],int size) { int i; printf("输出的八进制数为："); trans(atoi(c_arr),8); } void HtoO(char c_arr[],int size) { int i,count,sum; printf("输出的八进制数为："); for(i=2,sum=0,count=size-3;i<size;i++,count--) sum+=AtoI(c_arr[i])*pow(16,count); trans(sum,8); } void toD(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的十进制数为：%*s\n",size,c_arr); else switch(src) { case 2:BtoD(c_arr,size);break; case 8:OtoD(c_arr,size);break; case 16:HtoD(c_arr,size); } } void BtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(2,count); printf("%d",sum); } void OtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(8,count); printf("%d",sum); } void HtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=2,count=size-3;i<size;i++,count--) sum+=AtoI(c_arr[i])*pow(16,count); printf("%d",sum); } void toH(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的十六进制数为：%*s\n",size-2,c_arr+2); else switch(src) { case 2:BtoH(c_arr,size);break; case 8:OtoH(c_arr,size);break; case 10:DtoH(c_arr,size); } } void BtoH(char c_arr[],int size) { int i,sum=0,count; printf("输出的十六进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(2,count); trans(sum,16); } void OtoH(char c_arr[],int size) { int i,sum=0,count; printf("输出的十六进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(8,count); trans(sum,16); } void DtoH(char c_arr[],int size) { printf("输出的十六进制数为："); trans(atoi(c_arr),16); } int AtoI(char c_ch) { 	int i; 	switch(c_ch) 	{ 	case 'a':i=10;break; 	case 'b':i=11;break; 	case 'c':i=12;break; 	case 'd':i=13;break; 	case 'e':i=14;break; 	case 'f':i=15;break; 	default:i=c_ch-'0'; 	} 	return i; }  转16的全错了啊啊啊啊啊啊

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

热心人真多。。。

[size=24px改正后的代码][/size]  #include<stdio.h> #include<string.h> #include<stdlib.h> #include<math.h> #define SIZE 33 int check(char[]);//检查输入数字的合法性，并且返回进制 void toB(int,int,char[],int); void OtoB(char[],int); void DtoB(char[],int); void HtoB(char[],int); void toO(int,int,char[],int); void BtoO(char[],int); void DtoO(char[],int); void HtoO(char[],int); void toD(int,int,char[],int); void BtoD(char[],int); void OtoD(char[],int); void HtoD(char[],int); void toH(int,int,char[],int); void BtoH(char[],int); void OtoH(char[],int); void DtoH(char[],int); void trans(int,int); int main(void) { int i,j; char arr[SIZE]; while(i=check(arr)) { printf("请输入您想转换为的进制数(以数字0结束输出)：__\b\b"); scanf("%d",&j); while(j) { switch(j) { case 2:toB(i,j,arr,strlen(arr));break; case 8:toO(i,j,arr,strlen(arr));break; case 10:toD(i,j,arr,strlen(arr));break; case 16:toH(i,j,arr,strlen(arr));break; default: printf("您所输入的数制错误，请输入2、8、10、16！"); } putchar('\n'); printf("请输入您想转换为的进制数(以数字0结束输出)：__\b\b"); scanf("%d",&j); } /*for(int i=0;*(arr+i);i++) *(arr+i)='\0';*/ getchar(); } return 0; } int check(char c_arr[]) { char c; int i,j; char arr[SIZE]={0}; printf("您的输入为（按两下回车键结束输出）："); while(gets(c_arr)&&c_arr[0])//在新一行不用输任何字符，只需按下回车键结束输入 { 	strcpy(arr,c_arr); if(c_arr[0]=='B') j=2; else if(c_arr[0]=='0'&&(c_arr[1]=='x'||c_arr[1]=='X')) j=16; else if(c_arr[0]=='0') j=8; else if(c_arr[0]>'0'&&c_arr[0]<='9') j=10; else { printf("您的输入有误，请按照如下格式输入：B101、0302、324、0x123、0X123!\n"); printf("您的输入为（按两下回车键结束输出）："); continue; } } strcpy(c_arr,arr); return j; } void toB(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的二进制数为：%*s\n",size-1,c_arr+1); else switch(src) { case 8:OtoB(c_arr,size);break; case 10:DtoB(c_arr,size);break; case 16:HtoB(c_arr,size); } } void OtoB(char c_arr[],int size) { int i,count,sum; printf("输出的二进制数为："); for(i=1,sum=0,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(8,count); trans(sum,2); } void DtoB(char c_arr[],int size) { int i; printf("输出的二进制数为："); trans(atoi(c_arr),2); } void HtoB(char c_arr[],int size) { int i,count,sum; printf("输出的二进制数为："); for(i=2,sum=0,count=size-3;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(16,count); trans(sum,2); }   void trans(int c_ch,int sys) { if(c_ch>=sys) trans(c_ch/sys,sys); switch(c_ch%sys) { case 10:printf("a");break; case 11:printf("b");break; case 12:printf("a");break; case 13:printf("a");break; case 14:printf("a");break; case 15:printf("a");break; default:printf("%d",c_ch%sys); } }   void toO(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的八进制数为：%*s\n",size-1,c_arr+1); else switch(src) { case 2:BtoO(c_arr,size);break; case 10:DtoO(c_arr,size);break; case 16:HtoO(c_arr,size); } } void BtoO(char c_arr[],int size) { int i,count,sum; printf("输出的八进制数为："); for(i=1,sum=0,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(2,count); trans(sum,8); } void DtoO(char c_arr[],int size) { int i; printf("输出的八进制数为："); trans(atoi(c_arr),8); } void HtoO(char c_arr[],int size) { int i,count,sum; printf("输出的八进制数为："); for(i=2,sum=0,count=size-3;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(16,count); trans(sum,8); } void toD(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的十进制数为：%*s\n",size,c_arr); else switch(src) { case 2:BtoD(c_arr,size);break; case 8:OtoD(c_arr,size);break; case 16:HtoD(c_arr,size); } } void BtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(2,count); printf("%d",sum); } void OtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(8,count); printf("%d",sum); } void HtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=2,count=size-3;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(16,count); printf("%d",sum); } void toH(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的十六进制数为：%*s\n",size-2,c_arr+2); else switch(src) { case 2:BtoH(c_arr,size);break; case 8:OtoH(c_arr,size);break; case 10:DtoH(c_arr,size); } } void BtoH(char c_arr[],int size) { int i,sum=0,count; printf("输出的十六进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(2,count); trans(sum,16); } void OtoH(char c_arr[],int size) { int i,sum=0,count; printf("输出的十六进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*pow(8,count); trans(sum,16); } void DtoH(char c_arr[],int size) { printf("输出的十六进制数为："); trans(atoi(c_arr),16); }

完整程序： #include<stdio.h> #include<string.h> #define SIZE 33 int check(char[]);//检查输入数字的合法性，并且返回进制 void toB(int,int,char[],int); void OtoB(char[],int); void DtoB(char[],int); void HtoB(char[],int); void toO(int,int,char[],int); void BtoO(char[],int); void DtoO(char[],int); void HtoO(char[],int); void toD(int,int,char[],int); void BtoD(char[],int); void OtoD(char[],int); void HtoD(char[],int); void toH(int,int,char[],int); void BtoH(char[],int); void OtoH(char[],int); void DtoH(char[],int); void trans(int,int); int main(void) { int i,j; char arr[SIZE]; while(i=check(arr)) { printf("请输入您想转换为的进制为(以数字0结束输出)：__\t\t%2d"); scanf("%d",&j); while(j) { switch(j) { case 2:toB(i,j,arr,strlen(arr));break; case 8:toO(i,j,arr,strlen(arr));break; case 10:toD(i,j,arr,strlen(arr));break; case 16:toH(i,j,arr,strlen(arr));break; default: printf("您所输入的数制错误，请输入2、8、10、16！"); } printf("请输入您想转换为的进制为(以数字0结束输出)：__\t\t%2d"); scanf("%d",&j); } } return 0; } int check(char c_arr[]) { char c; int i,j; printf("您的输入为："); while(scanf("%s",c_arr)&&c_arr[0])//在新一行不用输任何字符，只需按下回车键结束输入 { if(c_arr[0]=='B') j=2; else if(c_arr[0]=='0'&&(c_arr[1]=='x'||c_arr[1]=='X')) j=16; else if(c_arr[0]=='0') j=8; else if(c_arr[0]>0&&c_arr[0]<10) j=10; else { printf("您的输入有误，请按照如下格式输入：B101、0302、324、0x123、0X123!"); scanf("%*s"); continue; } } return j; } void toB(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的二进制数为：%*s\n",size-1,c_arr+1); else switch(src) { case 8:OtoB(c_arr,size);break; case 10:DtoB(c_arr,size);break; case 16:HtoB(c_arr,size); } } void OtoB(char c_arr[],int size) { int i; printf("输出的二进制数为："); for(i=1;i<size;i++) trans(c_arr[i]-'0',2); } void DtoB(char c_arr[],int size) { int i; printf("输出的二进制数为："); trans(atoi(c_arr),2); } void HtoB(char c_arr[],int size) { int i; printf("输出的二进制数为："); for(i=1;i<size;i++) trans(c_arr[i]-'0',2); } void trans(int c_ch,int sys) { if(c_ch/sys>=sys) trans(c_ch/sys,sys); printf("%d",c_ch%sys); } void toO(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的八进制数为：%*s\n",size-1,c_arr+1); else switch(src) { case 8:BtoO(c_arr,size);break; case 10:DtoO(c_arr,size);break; case 16:HtoO(c_arr,size); } } void BtoO(char c_arr[],int size) { int i,sum,count; printf("输出的八进制数为："); for(i=1,sum=0,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*power(2,count); trans(sum,8); } void DtoO(char c_arr[],int size) { int i; printf("输出的八进制数为："); trans(atoi(c_arr),8); } void HtoO(char c_arr[],int size) { int i,count; printf("输出的八进制数为："); for(i=2,sum=0,count=size-3;i<size;i++,count--) sum+=(c_arr[i]-'0')*power(16,count) trans(sum,8); } void toD(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的十进制数为：%*s\n",size,c_arr); else switch(src) { case 8:BtoD(c_arr,size);break; case 10:OtoD(c_arr,size);break; case 16:HtoD(c_arr,size); } } void BtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*power(2,count); printf("%d",sum); } void OtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*power(8,count); printf("%d",sum); } void HtoD(char c_arr[],int size) { int i,sum=0,count; printf("输出的十进制数为："); for(i=2,count=size-3;i<size;i++,count--) sum+=(c_arr[i]-'0')*power(16,count); printf("%d",sum); } void toH(int src,int dest,char c_arr[],int size) { if(src==dest) printf("输出的十六进制数为：%*s\n",size-2,c_arr+2); else switch(src) { case 8:BtoH(c_arr,size);break; case 10:OtoH(c_arr,size);break; case 16:DtoH(c_arr,size); } } void BtoH(char c_arr[],int size) { int i,sum=0,count; printf("输出的十六进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*power(2,count); trans(sum,16); } void OtoH(char c_arr[],int size) { int i,sum=0,count; printf("输出的十六进制数为："); for(i=1,count=size-2;i<size;i++,count--) sum+=(c_arr[i]-'0')*power(8,count); trans(sum,16); } void DtoH(char c_arr[],int size) { int i,sum=0,count; printf("输出的十六进制数为："); trans(atoi(c_arr),16); }

#include <stdio.h> #include <stdlib.h> #include <string.h>  int Hex2Octal(char *tInputNum) { 	int x = strtol(tInputNum, NULL, 16);  	printf("Octal: %o\n", x);	 }   int Hex2Bibary(char tInputNum[20]) { 	int number,i,j,s=0; 	int result = 0; 	int b[50],p[30];  	memcpy(tInputNum, &tInputNum[2], sizeof(tInputNum)-2);  	//printf("%s\n", tInputNum); 	for(number=0; ;number++) 	{ 		if(tInputNum[number] == '\0') 			break; 	}  	for(i=0; i<number; i++) 	{ 		if(tInputNum[i]<='9' && tInputNum[i]>='0') 			b[i] = tInputNum[i]-48; 		else 		{ 			switch(tInputNum[i]) 			{ 				case 'A': 				case 'a': 					b[i] = 10; 				break;	 				case 'B': 				case 'b': 					b[i] = 11; 				break;	 				case 'C': 				case 'c': 					b[i] = 12; 				break;	 				case 'D': 				case 'd': 					b[i] = 13; 				break;	 				case 'E': 				case 'e': 					b[i] = 14; 				break;	 				case 'F': 				case 'f': 					b[i] = 15; 				break;	 				default:  					s=1; 				break;		  			} 		} 	}  	for(i=0; i< number; i++) 	{ 		//printf("%d", b[i]); 	} 	//putchar(10);  	for(j=number-1,i=1; j>=0; j--, i*=16) 	{ 		result += b[j]*i; 	} 	 	for(j=0; result!=0; j++) 	{ 		p[j] = result%2; 		result = result/2; 	}  	if(s == 1) 		printf("wrong num\n"); 	else{ 		printf("Binary: ");  		//printf("%d\n", j-1); 		for(number=j-1; number>=0; number--) 		{ 			printf("%d", p[number]); 		} 		putchar(10); 	} }  int Hex2Decimal(char * tInputNum) { 	int x = strtol(tInputNum, NULL, 16);  	printf("Decimal: %d\n", x);	  }  int main() { 	int num; 	char mInputNum[20]; 	memset(mInputNum, 0, sizeof(mInputNum));  	scanf("%s", mInputNum); 	printf("mInputNum = [%s]\n", mInputNum);  	num = strlen(mInputNum);  	int i; 	for(i=0; i<num; i++) 	{ 		if( (mInputNum[i]<='9' && mInputNum[i]>= '0')  			|| (mInputNum[i]>= 'a' && mInputNum[i]<='f') 			|| (mInputNum[i]>= 'A' && mInputNum[i]<='F') 			|| mInputNum[i] == 'x' || mInputNum[i] == 'X') 		{}else{ 			printf("Wrong Input, Bye-Bye [%c]\n", mInputNum[i]);	   		}	 	}  	switch(mInputNum[0]) 	{ 		case '0': 			switch(mInputNum[1]) 			{ 				case 'x': 				//16	 					Hex2Octal(mInputNum); 					Hex2Bibary(mInputNum); 					Hex2Decimal(mInputNum); 				break; 				default: 				//8  				for(i=1; i< num; i++) 				{ 					if(mInputNum[1]>='0' && mInputNum[1]<= '7') 					{  					}else{ 						printf("for 8 Wrong Input, Bye-Bye[%c]\n", mInputNum[i]);	   					} 				}  				break; 			} 		break; 		case 'B': 				  		break; 		default:  		break; 	} }   写了一部分

#include<stdio.h> #define SIZE 33 int check(char[],int);//检查输入数字的合法性，并且返回进制 void toB(int,int,char[],int); void OtoB(char[],int); void DtoB(char[],int); void HtoB(char[],int); void toO(int,int,char[],int); void BtoO(char[],int); void DtoO(char[],int); void HtoO(char[],int); void toD(int,int,char[],int); void BtoD(char[],int); void OtoD(char[],int); void HtoD(char[],int); void toH(int,int,char[],int); void BtoH(char[],int); void OtoH(char[],int); void DtoH(char[],int); int main(void) { int i,j; char arr[SIZE]; while(i=check(arr,SIZE)) { printf("请输入您想转换为的进制为(以数字0结束输出)：__\t\t%2d"); scanf("%d",&j); while(j) { switch(j) { case 2:toB(i,j,arr,SIZE);break; case 8:toO(i,j,arr,SIZE);break; case 10:toD(i,j,arr,SIZE);break; case 16:toH(i,j,arr,SIZE);break; default: printf("您所输入的数制错误，请输入2、8、10、16！"); } printf("请输入您想转换为的进制为(以数字0结束输出)：__\t\t%2d"); scanf("%d",&j); } } return 0; } int check(char c_arr[],int size) { char c; int i,j; printf("您的输入为："); while((c=getchar())!='\n') { for(i=0;i<size;i++) c_arr[i]=c; if(c_arr[0]=='B') j=2; else if(c_arr[0]=='0'&&(c_arr[1]=='x'||c_arr[1]=='X')) j=16; else if(c_arr[0]=='0') j=8; else if(c_arr[0]>0&&c_arr[0]<10) j=10; else { printf("您的输入有误，请按照如下格式输入：B101、0302、324、0x123、0X123!"); scanf("%*s"); continue; } } return j; } /*没写完*/ void toB(int src,int dest,char c_arr[],int size) { if(src==dest)  }


Question: 如何用c语言读取二进制文件并输出这个图型

电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

引用 3 楼 zerg73 的回复:楼上是不是回复错帖子了。。。 仅供参考，仅供参考。 楼主可以参考34～37行，将二进制字符串转为实际字节。

楼上是不是回复错帖子了。。。

题目的要求不太清晰啊……二进制文本的格式和含义是啥


Question: 字符串求助

引用 3 楼 ycao24 的回复:[quote=引用 1 楼 zhao4zhong1 的回复:] #include <stdio.h> char s[]="FE 01 01 87 03 B5 01 01 00 00 00 00 00 00 32 B8"; int i; int main() {     i=0;     while (1) {         printf("[%.2s] ",(char *)s+i*3);         if (s[i*3+2]==0) break;         i++;     }     return 0; } //[FE] [01] [01] [87] [03] [B5] [01] [01] [00] [00] [00] [00] [00] [00] [32] [B8]   感谢赵老师 帮我解决问题[/quote]  这个表情应该是要报酬的意思吧。

引用 1 楼 zhao4zhong1 的回复:#include <stdio.h> char s[]="FE 01 01 87 03 B5 01 01 00 00 00 00 00 00 32 B8"; int i; int main() {     i=0;     while (1) {         printf("[%.2s] ",(char *)s+i*3);         if (s[i*3+2]==0) break;         i++;     }     return 0; } //[FE] [01] [01] [87] [03] [B5] [01] [01] [00] [00] [00] [00] [00] [00] [32] [B8]   感谢赵老师 帮我解决问题

#include <stdio.h> char s[]="FE 01 01 87 03 B5 01 01 00 00 00 00 00 00 32 B8"; int i,n,v; char b[100]; int main() {     i=0;     while (1) {         if (1!=sscanf((char *)s+i*3,"%2X",&v)) break;         b[i]=(char)v;         i++;         if (i>=100) break;     }     n=i;     for (i=0;i<n;i++) printf("%02X ",(unsigned char)b[i]);     return 0; } //FE 01 01 87 03 B5 01 01 00 00 00 00 00 00 32 B8


Question: 什么是相对定时器？

看接口也只能猜，要看源码才行。 可能它有一个绝对计时，比如从系统开始，晶振中断就计数。 而相对计时就相对这个计数而已

相对定时器就是设定时长，在此刻之后设定时长到了时触发。其工作原理通常是利用当前时刻＋设定时长计算出一个未来的绝对时刻，再使用时钟定时器实现，或者，利用每间隔较短时长比如一秒，累加计数器，直到计数器值到达设定时长比如五秒实现。 时钟定时器就是设定绝对时刻如XX年XX月XX日XX时XX分XX秒，在设定绝对时刻到了时触发。  我猜。


Question: 这样写c语言真的没事吗

memcpy(ptr,&a,4); //第3个参数是目的指针ptr指向缓冲区的大小，单位字节，而ptr指向的data只有1个字节，这不就写越界了。  int main(void) {     uint8_t data[1];             /* 没有初始化，data[0]='\0';  */     uint8_t*  ptr=data;       /*  OK */     int a = 1;     *ptr++ = 6 ;  /*  相当于把data[0]赋值为6，但这时ptr指针已经指向了下一个字节的位置，这个位置是未知的，不能使用*ptr了  */     memcpy(ptr,&a,4);  /* ptr已经指向未知内存地址，不可随便写，执行效果没有段错误，那是幸运的，这里写了系统的随机内存 */     ptr+=4;     /* 向后移动了4个字节，本身就是指向了随机内存 */     printf("data is %d \n",ptr);   /*  打印随机内存的地址，32位系统上会是个很大的数值 */     return 0; } 要想入门C语言，除了学校里的谭教授那本书，必须看《C和指针》

引用 24 楼 f012011028 的回复:[quote=引用 23 楼 shenyi0106 的回复:] [quote=引用 19 楼 f012011028 的回复:] 楼上的似乎没有说对的 data的空间是在c语言的栈上，而不是堆上，所以不会影响到其他进程，每个进程的栈大小好像是8k，所以你这个程序跑一辈子也不会出错，也不可能影响到别的进程，如果memcpy要是访问到栈之外的空间的话，会发生段错误 例如 while 1       ptr++       memcpy  最后就是段错误结束进程  线程默认栈空间是1M，而非这位兄台所说的8K，如果非要说个8K，那只能说这是64位操作系统的内存页大小。  LZ给的代码运行不会出错，但是会改变变量a的值。  int a = 1;  在实际做项目中，这类错误也时有发生，由于字节对齐的缘故，给一个变量赋值，导致更改了其他变量的值，这类错误一般很难查找。所以应该尽量避免这类写代码的方式。比如用指针作为缓冲区的时候，不管是输入还是输出，都要带一个size参数，以确保不会越界。  当然，这类问题是C/C++程序的“天然特性”，只有通过不断的写，不断的思考，在历练中使错误发生率降到最低[/quote]  栈的大小windows上我不清楚分配多少，linux上默认不会分配到1M 你确定楼主的程序*ptr++ = 6 会改变a的值？[/quote] windows+vs2010改变不了，a和data[]与ptr的组合没有直接关系。我运行的时候a的地址在data的前面，不过也难免什么时候分到后面，ptr++说不定会改变a。不过内存栈一次分多大我觉得不是关键问题，系统有虚拟内存，运行的时候调一部分进去的

引用 5 楼 u010848119 的回复:之所以能够正常运行，是因为main函数里面修改的那段内存还没有被别的地方使用，如果程序中有另外一个变量需要访问这段内存中的内容，而实际这段内容已经被你的函数修改了，这时候就会出错。 建议：1.变量定义要初始化；2.对数组下标做合法性判断；3.做好越界、内存溢出等防护措施；4.使用memcpy需谨慎。

引用 23 楼 shenyi0106 的回复:[quote=引用 19 楼 f012011028 的回复:] 楼上的似乎没有说对的 data的空间是在c语言的栈上，而不是堆上，所以不会影响到其他进程，每个进程的栈大小好像是8k，所以你这个程序跑一辈子也不会出错，也不可能影响到别的进程，如果memcpy要是访问到栈之外的空间的话，会发生段错误 例如 while 1       ptr++       memcpy  最后就是段错误结束进程  线程默认栈空间是1M，而非这位兄台所说的8K，如果非要说个8K，那只能说这是64位操作系统的内存页大小。  LZ给的代码运行不会出错，但是会改变变量a的值。  int a = 1;  在实际做项目中，这类错误也时有发生，由于字节对齐的缘故，给一个变量赋值，导致更改了其他变量的值，这类错误一般很难查找。所以应该尽量避免这类写代码的方式。比如用指针作为缓冲区的时候，不管是输入还是输出，都要带一个size参数，以确保不会越界。  当然，这类问题是C/C++程序的“天然特性”，只有通过不断的写，不断的思考，在历练中使错误发生率降到最低[/quote]  栈的大小windows上我不清楚分配多少，linux上默认不会分配到1M 你确定楼主的程序*ptr++ = 6 会改变a的值？

引用 19 楼 f012011028 的回复:楼上的似乎没有说对的 data的空间是在c语言的栈上，而不是堆上，所以不会影响到其他进程，每个进程的栈大小好像是8k，所以你这个程序跑一辈子也不会出错，也不可能影响到别的进程，如果memcpy要是访问到栈之外的空间的话，会发生段错误 例如 while 1       ptr++       memcpy  最后就是段错误结束进程  线程默认栈空间是1M，而非这位兄台所说的8K，如果非要说个8K，那只能说这是64位操作系统的内存页大小。  LZ给的代码运行不会出错，但是会改变变量a的值。  int a = 1;  在实际做项目中，这类错误也时有发生，由于字节对齐的缘故，给一个变量赋值，导致更改了其他变量的值，这类错误一般很难查找。所以应该尽量避免这类写代码的方式。比如用指针作为缓冲区的时候，不管是输入还是输出，都要带一个size参数，以确保不会越界。  当然，这类问题是C/C++程序的“天然特性”，只有通过不断的写，不断的思考，在历练中使错误发生率降到最低

引用 21 楼 zaoqitouteng 的回复:大哥，使用内置的数组类型还敢把指针这样移动无异于自杀啊，以后用指针就记着两点，数组名和大小，不然就跟埋了地雷一样说不定哪天就 “boom”!  我没说可以这么用，我就把把这块的道理告他他

楼主结贴！分给我就完事了

违法不一定被抓。 但不说明违法没有问题。

引用 11 楼 jim5197 的回复:[quote=引用 10 楼 xihu1364 的回复:] 不是你的东西你在用，你说可以不？  你的合法老婆被别人正当的用，你愿意不 这你都能联想起来，你的合法老婆肯定被人用过了。而且看样子你还不知道[/quote]  只是打比方，用得着这么认真....  用了不属于你的东西，发生什么后果...就不可预知了

区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。  在你防采花功力还不济的时候，你的老婆是不是被别人用过你也无从知晓。 在你采花功力还不济的时候，用别人的老婆的后果就会很严重。  采花大盗必备工具： OpenProcessToken LookupPrivilegeValue AdjustTokenPrivileges CloseHandle OpenProcess ReadProcessMemory VirtualQueryEx VirtualProtectEx WriteProcessMemory CloseHandle

引用 10 楼 xihu1364 的回复:不是你的东西你在用，你说可以不？  你的合法老婆被别人正当的用，你愿意不 这你都能联想起来，你的合法老婆肯定被人用过了。而且看样子你还不知道

不是你的东西你在用，你说可以不？  你的合法老婆被别人正当的用，你愿意不

1.程序是错的。 2.应用层的程序内存空间独立，一般是影响不了其他程序的。

引用 6 楼 zhao4zhong1 的回复:其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。 老师 您好  1、那这样写是没有问题的吗？ 2、如果这样写没有问题，我直接用指针去访问没有分配的内存就像上例中ptr，万一访问到其他程序的内存怎么办？

使用API ReadProcessMemor和WriteProcessMemory还能读写其它进程的内存呢！


Question: 谁能帮帮我，我编了好久都没编出来，急用

引用 4 楼 TELIUOSE 的回复:用C语言来编。 纯C你能使用STL?楼主究竟搞清楚STL的使用场景不？

引用 楼主 TELIUOSE 的回复:【设计要求】 设计基于堆的优先队列的哈夫曼编码程序。 （1）采用STL的堆、向量等数据结构。  我编不好，不知道是我想错了还是理解不透彻，希望大伙能帮我用C语言编出这道题，谢谢了！！！  这到底是要用C++还是用C？

引用 1 楼 zhao4zhong1 的回复:把你的半成品贴上来。 老师风范，可以帮你费力找问题，拒绝顺手写代码

用C语言来编。

把你的半成品贴上来。


Question: 请教一个问题 马上就要考试了 这个编程不会做

引用 9 楼 sholber 的回复:不该点进来，被楼上有些代码**到了，话说写个简单的程序就不能不那么臃肿么 float pay (int weight)  {     return weight >= 20 ? weight * 7.5 : weight * 9.3;  }66666666666666666666666666666666666

引用 9 楼 sholber 的回复:不该点进来，被楼上有些代码**到了，话说写个简单的程序就不能不那么臃肿么 float pay (int weight)  {     return weight >= 20 ? weight * 7.5 : weight * 9.3;  }  佩服

我也是刚学C，我觉得这个比较浅显易懂。希望对你有用！

#include <stdio.h> void main() { 	int weight; 	float price,pay; 	printf("input the weight:\n"); 	scanf("%d",&weight); 	if(weight<=0) 		printf("error!\n"); 	else if(weight>20) 	{ 		price=7.5; 		pay=(float)weight*price; 		printf("pay=%.1f\n",pay); 	} 	else if(weight<=20) 	{ 		price=9.3; 		pay=(float)weight*price; 		printf("pay=%.1f\n",pay);  	} 	 }

嗯，分两种情况，一个是小于20公斤的，另一个是大于20公斤的，分情况计算。

这是在逗我玩呢？

#include <stdio.h> void CalPrice(void) {     float weight = 0;     float price = 0; mark_alarm:     printf("请输入购买的质量:]\r\n");     scanf("%f",&weight);     if( weight <= 0 )     {         printf("输入无效\r\n");         goto mark_alarm;     }     else if( weight > 20 )     {         price = weight * 7.5;         printf("您购买%f斤,单价7.5, 应支付%f元！\n", weight, price);     }     else     {         price = weight * 9.5;         printf("您购买%f斤,单价9.5,应支付%f元！\n", weight, price);     } }

#include <stdio.h> int _tmain(int argc, _TCHAR* argv[]) { 	float weight = 0; 	float price = 0; 	printf("请输入购买的质量:"); 	scanf("%f",&weight); 	if(weight > 20 && weight > 0) 	{ 		price = weight * 7.5; 		printf("您购买%f斤,单价7.5, 应支付%f元！\n", weight, price); 	} 	else 	{ 		price = weight * 9.5; 		printf("您购买%f斤,单价9.5,应支付%f元！\n", weight, price); 	} 	return 0; }

bool pay(uint32 weight, uint32 *pay_value) {    if(weight>20)    {         *pay_value = weight*7.5    }    else    {          *pay_value = weight*9.3    }     return true; }  貌似没啥难度，这里的批发价是指超出20公斤的部分有批发价还是全部都是批发价?


Question: 一个C语言结构体的问题，有些不理解

这样初始化看着别扭，直接先memset清零，再对需要赋值的字段分别赋值。。

struct第四个成员是个数组啊。

引用 10 楼 zhao4zhong1 的回复:引用 9 楼 PhycoKnight 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] para_data是数组。哇，赵老师！我知道是数组，只是自己见的程序少，以前没见到过大括号整体赋值这种做法。 “变量赋值”和“变量初始化”不是一回事！ “变量赋值”发生在运行期，其写法遵循赋值语法规定。 “变量初始化”发生在编译期或运行期，其写法遵循初始化列表语法规定。 [/quote]非常感谢耐心解答！

引用 9 楼 PhycoKnight 的回复:引用 6 楼 zhao4zhong1 的回复:para_data是数组。哇，赵老师！我知道是数组，只是自己见的程序少，以前没见到过大括号整体赋值这种做法。 “变量赋值”和“变量初始化”不是一回事！ “变量赋值”发生在运行期，其写法遵循赋值语法规定。 “变量初始化”发生在编译期或运行期，其写法遵循初始化列表语法规定。

对于这种连续内存块的初始化， c99标准和c++11标准都有不同的规定。 c99  struct T{      int a;      int b;     double c; };  struct T  t[ ] = {     {1, 2, 0.5},     {5, 12, 78.00},     {45, 12, 44} };  //这样就定义了一个结构体数组并且赋了初值  里面的{} 相当于这样 int arr[10] = {0}; //对他进行初始化

用来初始化数组

保留的，一般只是起一个占用空间的作用，以备后用。 大括号是用来初始化结构体里边的数组成员para_data的。

引用 4 楼 my_live_123 的回复:C标准初始化就是这样的规则，记住吧！如果非要问为什么，只有C他爹里奇知道为什么了！不过从规则上看，为了避免歧义，构成一个初始化块！ 好吧，thx


Question: c和指针 里提到的一个标量的问题

Integer and ﬂoating types are collectively called arithmetic types   Arithmetic types and pointer types are collectively called scalar types.Array and structure types are collectively called aggregate types

可以具体一点吗？还有我的第二个问题，可以解答么？谢谢哦

思路基本理清

明白了，谢了哈

你那个内容过时了。标准在4楼帖着

看清楚回答啊

那为什么说结构体变量也是一个标量呢。

不是矢量类型，是复合类型 比如数组 结构体

那段话说是因为x是一个标量才不合法，那么和标量相对的矢量类型又是什么？

比如int x; int*px=&x;那么px+1 就指向x后一个位置那这个位置上存放的东西你不清楚自然解引用就不合法

c里面算术类型和指针类型统称为标量类型

typedef struct {       int a;       short b[2]; }  Ex2;  typedef struct EX {       int a;       char b[3];       Ex2 c;       struct EX *d; } Ex;  Ex x ={10, "hi", {5, {-1, 25}}, 0}; Ex *px = &x;


Question: malloc和free的问题

要不结帖吧,看上去,xihu1364,好像解决了你的问题了 不过,你的表述,和代码 我确实没看懂. 不知道你的实际需求

结贴吧  没有什么好讨论的  使用 itoa就解决了额  想明白原理就看我贴的代码

引用 9 楼 xihu1364 的回复:     #include <stdio.h>       //反转字符串       char *reverse(char *s)       {           char temp;           char *p = s;    //p指向s的头部           char *q = s;    //q指向s的尾部           while(*q)               ++q;           q--;                  //交换移动指针，直到p和q交叉           while(q > p)           {               temp = *p;               *p++ = *q;               *q-- = temp;           }           return s;       }              /*       * 功能：整数转换为字符串       * char s[] 的作用是存储整数的每一位       */       char *my_itoa(int n)       {           int i = 0,isNegative = 0;           static char s[100];      //必须为static变量，或者是全局变量           if((isNegative = n) < 0) //如果是负数，先转为正数           {               n = -n;           }           do      //从各位开始变为字符，直到最高位，最后应该反转           {               s[i++] = n%10 + '0';               n = n/10;           }while(n > 0);                  if(isNegative < 0)   //如果是负数，补上负号           {               s[i++] = '-';           }           s[i] = '\0';    //最后加上字符串结束符           return reverse(s);         }              int main(void)       {           int m;           printf("请输入int型整数m：");           scanf("%d",&m);           printf("整数=%d,字符串=%s\n",m,my_itoa(m));           return 0;       }    我写的这个跟你贴的这个函数，有一点不一样。如下： 写一个把10进制整数转化为16进制，10进制，8进制字符串的函数  函数原形如下： void int_to_str(int value,char *buff,int flag)；value 为整数变量 ，buff 为字符串指针，flag 用来表示8，10，16进制 。 你贴的：  while(q > p)           {               temp = *p;               *p++ = *q;               *q-- = temp;           }   前提是内存区已经有数据了。

引用 16 楼 xihu1364 的回复:PTR=(char*)malloc(sizeof(i+1));  ...大神，鉴定完毕！我心里想的是i+1，sizeof竟然无意识的敲出来了。。。谢谢你！

知道改吧  改成 PTR=(char*)malloc(i+1);

PTR=(char*)malloc(sizeof(i+1));  ...

#include <stdio.h> #include <stdlib.h>  //我感觉必须要用到全局变量，因为void int_to_str(int value,char *buff,int flag)的限制性有两个：不能有返回值；不能使用二级指针。 //要想申请的malloc函数内存不产生泄露，我能想到的办法只有全局变量了。 char* PTR; #define MAX_SIZE 100  void int_to_str(int value,char *buff,int flag){ 	char a[MAX_SIZE]={0};//这个数组是逐步跟随a[i]=value%flag;语句进行接收转换后的进制数。不会用动态数组，MAX_SIZE就挺好的。 	int i=0; 	char* ptrEnd=NULL;  	while(value){//逐步求解进制数 		a[i]=value%flag; 		value=value/flag; 		i++; 	} 	PTR=(char*)malloc(sizeof(i+1));//动态申请内存空间，大小是i+1。这个1是为截止符留的空间。 	ptrEnd=PTR; //先让ptrEnd指向内存区的首地址，为下面的复制数据做好准备。 	while(i){   //此时第一次循环的i是前面累加后的i值，不是0。 		*ptrEnd=a[i-1]; 		ptrEnd++; 		i--; 	} 	*ptrEnd='#';//此时数据复制完毕，以#为截止符，不能用'\0',因为这个0 跟数字里的0等同。  	free(PTR);//。这个函数用来释放动态申请的内存。 	PTR=NULL;// }  int main(void) {     int value=100; 	char* buff=NULL; 	int flag=2; 	 	int_to_str(value,buff,flag);  	while(*PTR!='#'){ 		printf("%d",*PTR); 		PTR++; 	} 	printf("\n");  	 	return 0 ; }

引用 12 楼 xihu1364 的回复:图片   我还一个一个去敲怎么贴代码？就像刚才你那样

图片   我还一个一个去敲

引用 7 楼 xihu1364 的回复:把测试代码贴上 我去调调贴上来啦，大神！

把测试代码贴上 我去调调

引用 4 楼 xihu1364 的回复:上面知道保存 首地址，打印的时候居然不记得  我一开始是把打印数据放在了main函数里，刚才收一抖放在这个函数里了。 即使放在main函数还是有问题。

引用 3 楼 xihu1364 的回复:*ptrEnd='#';//此时数据复制完毕，以#为截止符，不能用'\0',因为这个0 跟数字里的0等同。 while(*PTR!='#'){ printf("%d",*PTR); PTR++; } printf("\n");  free(PTR);//问题就出在这一句上；  红色地方就是你的问题所在，都移动了指针，free肯定出问题  是的，如果我把 while(*PTR!='#'){ printf("%d",*PTR); PTR++; } printf("\n"); 这些删除了还是有问题。

上面知道保存 首地址，打印的时候居然不记得

引用 1 楼 u012683733 的回复:函数的功能是进行进制的转换 并且将转换后的值作为一个字符串。


Question: 求问c语言 fscanf 读txt文件一行多个字符串 最后一个字符串被重复

在vc++6.0中试过，运行正常

因为你没有判断fscanf函数的返回值。

我也觉得奇怪了。

我在vs2010上简单试了一下1楼的程序：  #include <stdio.h> int main() { 	char No[20]; 	char Name[20]; 	char Major[20]; 	char Class[20]; 	char Phone[20];  	FILE * fp = fopen("search.txt","r"); 	if(fp) 	{ 		fscanf(fp,"%s%s%s%s%s",No,Name,Major,Class,Phone); 		printf("%s %s %s %s %s\n",No,Name,Major,Class,Phone); 	} 	else 		printf("文件不存在！！");	 	return 0; }  这个没有写操作，直接给文件“search.txt"里存了一行：123  wyx computer s1  1224324，这样做没出现楼主说的那种情况…… 楼主能不能把你这个练习的完整程序贴出来？？我们一块学习~~~

#include <stdio.h>  int main() { 	char No[20]; 	char Name[20]; 	char Major[20]; 	char Class[20]; 	char Phone[20];  	FILE * fp = fopen("search.txt","r"); 	fscanf(fp,"%s%s%s%s%s",No,Name,Major,Class,Phone); 	printf("%s %s %s %s %s\n",No,Name,Major,Class,Phone); 	return 0; }