Question: C语言新人问一个问题【自己花了点时间 没能成功解决】

仅供参考： #include <windows.h> #include <stdio.h>  void ConPrint(char *CharBuffer, int len); void ConPrintAt(int x, int y, char *CharBuffer, int len); void gotoXY(int x, int y); void ClearConsole(void); void ClearConsoleToColors(int ForgC, int BackC); void SetColorAndBackground(int ForgC, int BackC); void SetColor(int ForgC); void HideTheCursor(void); void ShowTheCursor(void);  int main(int argc, char* argv[]) {    HideTheCursor();    ClearConsoleToColors(15, 1);    ClearConsole();    gotoXY(1, 1);    SetColor(14);    printf("This is a test...\n");    Sleep(5000);    ShowTheCursor();    SetColorAndBackground(15, 12);    ConPrint("This is also a test...\n", 23);    SetColorAndBackground(1, 7);    ConPrintAt(22, 15, "This is also a test...\n", 23);    gotoXY(0, 24);    SetColorAndBackground(7, 1);    return 0; }  //This will clear the console while setting the forground and //background colors. void ClearConsoleToColors(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //not used but we need to capture this since it will be    //written anyway (passing NULL causes an access violation).    DWORD count;     //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    SetConsoleTextAttribute(hStdOut, wColor);    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);        FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will clear the console. void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will set the position of the cursor void gotoXY(int x, int y) {    //Initialize the coordinates    COORD coord = {x, y};    //Set the position    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); }  //This will set the forground color for printing in a console window. void SetColor(int ForgC) {    WORD wColor;    //We will need this handle to get the current background attribute    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    CONSOLE_SCREEN_BUFFER_INFO csbi;     //We use csbi for the wAttributes word.    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //Mask out all but the background attribute, and add in the forgournd color       wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);       SetConsoleTextAttribute(hStdOut, wColor);    } }  //This will set the forground and background color for printing in a console window. void SetColorAndBackground(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);;    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), wColor); }  //Direct console output void ConPrint(char *CharBuffer, int len) {    DWORD count;    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), CharBuffer, len, &count, NULL); }  //Direct Console output at a particular coordinate. void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); }  //Hides the console cursor void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  //Shows the console cursor void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }

用\b控制控制光标往移就行了  #include <stdio.h>  int main(void) { 	char choice;  	printf("1. 第一题的答案是( ) A.1 B.2 C.3 D.4\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); 	choice = getchar(); 	printf("Your choice is %c.\n", choice);  	getchar(); 	return 0; }

问题3：scanf是有返回值的，它返回读取了几个变量。 比如这里的scanf ("%d", &a) 如果输入一个整数，那么返回值就是1，表示成功读取到1个整数。 如果输入一个字母，scanf读不到整数，返回0


Question: vs调试出现问题，求各位大牛帮忙看看有没有解决的办法

应该是你建的工程类型不对，看下是不是建成win32项目什么的了，那里面是用不了_tmain的。你要用_tmain就建成控制台应用程序。这样就不会出错了。

在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: 如何给自己的代码做自动化测试？

主要看你做的程序的类型，如果是数据输入 处理 输出 ，那么自动测试就只是动手的问题。

自己写,又不太难

最好有个测试框架，我们用的google的gtest

自己写个bat批处理应该不是很难。 把输入保存在input.txt test.exe < input.txt > output.txt 还可以把预期的输出结果保存到correct_output.txt，然后找个windows的diff工具自动比较

我们公司就有这么一套东西，每次有人提交代码就会自动运行，从某个脚本读取输入，把结果输出到文件，再和标准结果diff，如果不一样就会给N多人发邮件

最好是在window平台的方法工具，我用的开发环境是vs2010


Question: linux环境，获取函数参数类型

pc-lint +1

Tiny C Compiler是开源的。

楼主有这功夫，建议不如去学习学习pc-lint怎么用吧。

请问楼主： 如果我或将来有人将  if((n=func(a,b,c))!=0) 写为  if((n=func(     a,     b,     c ))!=0) ，你用grep还能查询吗？！ 另外，如果func(a,func1(b,func2(c)))呢？！！  所以没有类似C/C++编译器这种金刚钻，还是别揽这种瓷器活了。

来学习的，谢谢各位了！

不听老人言，吃亏在眼前。

我说的可能不够详细，各位误会我的意思了。 linux环境中，我用grep查询一个函数，比如说func函数 查询出来的结果是： /home/cbs/src/...../abc.c:150:  if((n=func(a,b,c))!=0) ....... 把grep结果改一下，改成这样，应该能懂吧。 意思就是说func函数是我调用的，我需要知道函数调用里面的参数类型，用以和原函数参数类型做对比，检测函数调用是否正确。

没这个搞过，这个应该是依赖定义的吧！通过大小也只能大致一个范围 python里也是通过typeid可以获取

参考Tiny C Compiler

引用 10 楼 cvictor 的回复:[quote=引用 9 楼 It_way 的回复:] 为什么不直接在 .h 文件中 grep。 在函数声明的时候肯定有类型。 这个func（a,b,c）函数是函数调用，原函数是定义在别的地方 [/quote] 你要问题是不知道 func(a,b,c) 在哪个 .h 文件中声明的？我觉得在工程路径下面 find . -name *.h | xargs grep func 应该可以吧，你试试

引用 5 楼 zhao4zhong1 的回复:参考Tiny C Compiler 还有个问题是，使用TCC那么可移植性就不好了，我做的是一个检测函数工具，如果要用TCC，那么其他人用我这个函数的时候是否也需要安装TCC呢

引用 9 楼 It_way 的回复:为什么不直接在 .h 文件中 grep。 在函数声明的时候肯定有类型。 这个func（a,b,c）函数是函数调用，原函数是定义在别的地方

为什么不直接在 .h 文件中 grep。 在函数声明的时候肯定有类型。

引用 5 楼 zhao4zhong1 的回复:参考Tiny C Compiler 赵4老师，又见面了！ 能详细说说么，比如通过TCC编译器如何解决我所提到的问题，或者我需要学习一下TCC里面哪些方向的内容？ 谢谢！！！

多谢楼上几位回答，不过没有提出有建设性的建议啊，哎！

linux环境美有用过。 以下是个人在windows下的经验，不知道能不能用的上。。。 不过只要找到头文件就可以了啊，看原型。如果头文件难找。那么，随便填几个类型的数进去，编译失败的时候会有提示应当是什么类型的吧？

c++里面用typeid关键字可以变相获取，c里面就不知道了。 如果非要用c，只能查找头文件了。

这个有点难度。需要在本文件以及包含的所有头文件以及这些头文件嵌套包含的头文件找func的声明。这又涉及到去哪里找头文件，也就是头文件包含路径、gcc的-I选项参数。找到之后需要判断是不是合法的函数声明，如果找到不只一个声明互相冲突了怎么办。 总之，编译器怎么做的，你就需要怎么做了。


Question: #define N 1和#define N (1)有什么区别

安全。。。。

引用 1 楼 zhao4zhong1 的回复:编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E 理解和讨论之前请先学会如何观察！

两个都对，使用代括号的不会出现歧义，是一种好习惯

带上括号是比较好的一种习惯。因为宏定义就是简单的文本替换，展开后没有括号的话有的情况下就会出现违背意愿的代码

这个没区别，定义四则混合运算就不同了。

预编译指令（宏定义）的原理是字符替换，你只要想下两种形式的预编译指令（宏定义）替换后有没有主义差别就行了，你所提到的两种形式的宏定义，由于1是常量，所以加不加括号都无所谓，只是第一种形式更加简洁 对含参数的宏定义才需要括号，而且对每一个参数都需要加括号，最后在给整个表达式加个括号，如  #define ADD(a, b) ((a) + (b))

引用 2 楼 jerry_dqh 的回复:你这样的情况基本没有什么区别，更多的是习惯问题。 对于定义复杂的一些情况就有区别了，比如  define N   a+b define N  (a+b)  这样就会有区别，就像N*c，展开后a+b*c,第二种展开后(a+b)*c, 正解，区别明显大大的。

编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E


Question: [C]关于打印浮点数，求解惑

谢谢楼上各位解惑

表示显示最小的位数，如果格式化后的输出小于这个长度，则用空格或0补齐长度；如果输出大于这个长度，则它不起作用。 因此输出长度不会比1小，因此这里的1不起作用。 C标准总的说明: An optional minimum field width. If the converted value has fewer characters than the field width, it is padded with spaces (by default) on the left (or right, if the left adjustment flag, described later, has been given) to the field width.

格式控制符m.n，m表示输出数据宽度，n表示数据精度 1.2f是非法的，小数点前的数字必须大于小数点后的数字

表示输出的宽度。比如下边的代码 	float f = 3.1415926f; 	printf("%5.2f\n" ,f); 输出的3.14前边会有一个空格，保证整个输出占5个宽度。


Question: select查找次最大描述符值

这个没必要修改，对性能影响不大 如果一定要修改，那就用一个数组把所有的fd都记下来，排好序 这样当删除最大fd时，就可以使用倒数第二个值去select


Question: 求大神帮小弟写个小得不能再小的程序= =

仅供参考：//qplw.cpp #include <stdio.h> #include <string.h> #include <stdlib.h> int v=0; int w=0; int m;//记录字符串长度 int n;//记录字符串中的字符种类数 char map[256];//记录是哪几种字符 int count[256];//记录每种字符有多少个 int stack[1000];//递归用的栈，并记录当前生成的排列 void Make_Map(char *str) {//统计字符串的相关信息     int s[256];     int i;     memset(s,0,sizeof(s));     memset(count,0,sizeof(count));     m=strlen(str);     if (w<1 || m<w) w=m;     while(*str) {         s[*str]++;         str++;     }     n=0;     for (i=0;i<256;i++)         if (s[i]) {             map[n]=i;             count[n]=s[i];             n++;         } } void Find(int depth) {//递归式回溯法生成全排列     if (depth==w) {         int i;         for (i=0;i<depth;i++) putchar(map[stack[i]]);         putchar('\n');     } else {         int i;         if (v && depth>0) {             for (i=0;i<depth;i++) putchar(map[stack[i]]);             putchar('\n');         }         for (i=0;i<n;i++)             if (count[i]) {                 stack[depth]=i;                 count[i]--;                 Find(depth+1);                 count[i]++;             }     } } void main(int argc,char**argv) {     if (argc<2) {         printf("%s 要产生全排列的字符串 [限定长度|-1]\n",argv[0]);         return;     }     if (argc>=3) w=atoi(argv[2]);     if (-1==w) v=1;     Make_Map(argv[1]);     Find(0); } //C:\test>qplw //qplw 要产生全排列的字符串 [限定长度|-1] // //C:\test>qplw 123 //123 //132 //213 //231 //312 //321 // //C:\test>qplw 123 2 //12 //13 //21 //23 //31 //32 // //C:\test>qplw 122333 3 //122 //123 //132 //133 //212 //213 //221 //223 //231 //232 //233 //312 //313 //321 //322 //323 //331 //332 //333 // //C:\test>qplw 123 -1 //1 //12 //123 //13 //132 //2 //21 //213 //23 //231 //3 //31 //312 //32 //321 //

楼上求私信原C代码= =

1.把12个数放到4个数组中，a[0],a[1],a[2],a[3] 2.对列号012做全排列 3.对行号0－3做全排列，针对每一个排列，按相应的顺序输出数组 比如得到一个排列是2013，则输出a[2],a[0],a[1],a[3] 在输出数组时，使用列的排列进行输出 比如列号排列为120，则在输出a[0]时顺序为a[0][1], a[0][2], a[0][0] 循环完成就得到你想到的结果了  感觉这个题目就是对1-12做一个全排列


引用 7 楼 ForestDB 的回复:你自己的陈述就是例子。  如果不用size_t，在机器A上你得写unsigned int；在机器B上你得写unsigned long…… 有了size_t，不管哪个机器，你直接写size_t就行了，你总可以得到“最大无符号数”这个类型，而不用自己去操心。  明白了。谢谢了啊，有点钻牛角尖了可能

引用 3 楼 zhao4zhong1 的回复:32位： typedef unsigned int size_t; 64位： typedef unsigned __int64 size_t;  定义是没错，但是对移植性的影响是什么呢？赵老师方便的话能举个例子吗

引用 1 楼 user-5 的回复:这个通常用于系统API，关于内存操作的通常都是size_t，因为64和32位支持的地址范围不同，就像void *malloc(size_t size);一样，之所以不是int size或者uint64_t size，就是因为这是平台相关的。  那为什么不都用long unsigned int呢，long unsigned int不也是平台相关的吗，干嘛要多定义个size_t？在32位系统中，字节数为4字节；在64位系统中，Visual C++和Mingw64字节数为4字节。GCC（POSIX系统以及Cygwin）为8字节。

学习了，


Question: c语言while循环

因为你按提示输入最大值后会按下enter键，如果在 scanf("%c",&c)前getchar()的话，getchar()就会接收你刚才按下的enter键字符，之后再输入y、n就能正常运行，但是当你注释掉 scanf("%c",&c)前getchar()后，这个enter键字符就会被scanf("%c",&c)执行，从而c字符接收的就是enter字符了，再与c == 'y'比较当然不相等了

scanf出错了，程序有异常，直接返回


Question: 求嵌入式平台下的加密解密算法

MD5只是摘要算法，不是加密算法，你可以用DES，3DES，速度非常快，适合嵌入式设备，还有AES

要求最好没有什么依赖库，C语音平台...

引用 6 楼 chenandczh 的回复:[quote=引用 3 楼 jwj070524 的回复:] 我以前看飞鸽传书的代码时，传文件用blowfish加密的。 这个讲解一下～ [/quote] 网上有源码的啊，Google一下，blowfish source code就出来了

引用 9 楼 zhao4zhong1 的回复:  老赵，又来刷分了？

#include <stdio.h> #include <math.h> #include <string.h> #include <memory.h> const unsigned int s[4][4]={{7,12,17,22},{5,9,14,20},{4,11,16,23},{6,10,15,21}}; const unsigned long t[64]={//t[i]=4294967296*fabs(sin(i+1));  0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,  0x698098d8,0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,0xa679438e,0x49b40821,  0xf61e2562,0xc040b340,0x265e5a51,0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,  0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,0xfcefa3f8,0x676f02d9,0x8d2a4c8a,  0xfffa3942,0x8771f681,0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,0xbebfbc70,  0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,  0xf4292244,0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,0xffeff47d,0x85845dd1,  0x6fa87e4f,0xfe2ce6e0,0xa3014314,0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391 }; const int serial[64]={  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,  1,6,11,0,5,10,15,4,9,14,3,8,13,2,7,12,  5,8,11,14,1,4,7,10,13,0,3,6,9,12,15,2,  0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9 }; void func(unsigned long& a,           unsigned long b,           unsigned long c,           unsigned long d,           unsigned long M,           unsigned long t,           int s,           int turn) {     unsigned long temp;     switch(turn) {     case 0:         temp=(b&c)|((~b)&d);         break;     case 1:         temp=(d&b)|((~d)&c);         break;     case 2:         temp=b^c^d;         break;     case 3:         temp=c^(b|(~d));         break;     }     temp+=M+t+a;     _asm {         mov ecx,s         rol temp,cl     }     a=b+temp; } void MD512(const unsigned long M[16],unsigned long hash[4]) {     int i,j,index=0;     for (i=0;i<4;i++)         for (j=0;j<4;j++) {             func(hash[0],hash[1],hash[2],hash[3],M[serial[index]],t[index],s[i][0],i);             index++;             func(hash[3],hash[0],hash[1],hash[2],M[serial[index]],t[index],s[i][1],i);             index++;             func(hash[2],hash[3],hash[0],hash[1],M[serial[index]],t[index],s[i][2],i);             index++;             func(hash[1],hash[2],hash[3],hash[0],M[serial[index]],t[index],s[i][3],i);             index++;         } }  void MD5(char* M,int nLen,unsigned long output[4]) {     int i,j;     unsigned long Hash[4]={0x67452301,0xefcdab89,0x98badcfe,0x10325476};     unsigned long hash[4];      //填充     __int64 BitsLen=nLen*8;     int oldlen=nLen;     while(nLen%64!=56) {         M[nLen++]=0;     }     M[oldlen]=0x80u;     *(__int64*)(M+nLen)=BitsLen;     nLen+=8;      //开始处理分组     for (i=0;i<nLen;i+=64) {         memcpy(hash,Hash,sizeof(long)*4);         MD512((const unsigned long*)&M[i],hash);//处理512bits分组         for (j=0;j<4;j++)             Hash[j]+=hash[j];     }      //处理输出。     for (i=0;i<4;i++)         for (j=3;j>=0;j--) {             *((char*)(output+i)+j)=*((char*)(Hash+i)+3-j);         } } int main() {     int i;     char szMessage[1000]={0};     printf("input a string:\n>>>");     scanf("%s",szMessage);     unsigned long output[4];     MD5(szMessage,strlen(szMessage),output);     for (i=0;i<4;i++)         printf("%08lx",output[i]);     printf("\n");     return 0; }

引用 7 楼 chenandczh 的回复:引用 4 楼 u012846431 的回复:md5怎么样md5方便移植吗？ 有源码，试过了可用

引用 4 楼 u012846431 的回复:md5怎么样md5方便移植吗？

引用 3 楼 jwj070524 的回复:我以前看飞鸽传书的代码时，传文件用blowfish加密的。 这个讲解一下～

引用 2 楼 zxhuser-5 的回复:hash加密 应该可行～

md5怎么样

我以前看飞鸽传书的代码时，传文件用blowfish加密的。

hash加密


Question: C语言倒金字塔

仅供参考#include <stdio.h> char s[]="15141312111098765432123456789101112131415"; int n,y; int main() {     for (n=0;n<16;n++) {         printf("\n n=%d\n",n);         for (y=0;y<n;y++) {             printf("%*.*s\n",n+y+((n>=10)?n-9:0)+((y>=9)?y-8:0),1+2*y+2*((y>=9)?(y-8):0),s+20-y-((y>=9)?y-8:0));         }     }     return 0; } // // n=0 // // n=1 //1 // // n=2 // 1 //212 // // n=3 //  1 // 212 //32123 // // n=4 //   1 //  212 // 32123 //4321234 // // n=5 //    1 //   212 //  32123 // 4321234 //543212345 // // n=6 //     1 //    212 //   32123 //  4321234 // 543212345 //65432123456 // // n=7 //      1 //     212 //    32123 //   4321234 //  543212345 // 65432123456 //7654321234567 // // n=8 //       1 //      212 //     32123 //    4321234 //   543212345 //  65432123456 // 7654321234567 //876543212345678 // // n=9 //        1 //       212 //      32123 //     4321234 //    543212345 //   65432123456 //  7654321234567 // 876543212345678 //98765432123456789 // // n=10 //          1 //         212 //        32123 //       4321234 //      543212345 //     65432123456 //    7654321234567 //   876543212345678 //  98765432123456789 //109876543212345678910 // // n=11 //            1 //           212 //          32123 //         4321234 //        543212345 //       65432123456 //      7654321234567 //     876543212345678 //    98765432123456789 //  109876543212345678910 //1110987654321234567891011 // // n=12 //              1 //             212 //            32123 //           4321234 //          543212345 //         65432123456 //        7654321234567 //       876543212345678 //      98765432123456789 //    109876543212345678910 //  1110987654321234567891011 //12111098765432123456789101112 // // n=13 //                1 //               212 //              32123 //             4321234 //            543212345 //           65432123456 //          7654321234567 //         876543212345678 //        98765432123456789 //      109876543212345678910 //    1110987654321234567891011 //  12111098765432123456789101112 //131211109876543212345678910111213 // // n=14 //                  1 //                 212 //                32123 //               4321234 //              543212345 //             65432123456 //            7654321234567 //           876543212345678 //          98765432123456789 //        109876543212345678910 //      1110987654321234567891011 //    12111098765432123456789101112 //  131211109876543212345678910111213 //1413121110987654321234567891011121314 // // n=15 //                    1 //                   212 //                  32123 //                 4321234 //                543212345 //               65432123456 //              7654321234567 //             876543212345678 //            98765432123456789 //          109876543212345678910 //        1110987654321234567891011 //      12111098765432123456789101112 //    131211109876543212345678910111213 //  1413121110987654321234567891011121314 //15141312111098765432123456789101112131415 //

#include <stdio.h>  int main(void) { 	int i, j, n; 	 	printf("Enter the floors of the tower: "); 	scanf("%d", &n);  	for (j = n; j > 0; --j) 	{ 		for (i = j + 1; i <= n; ++i) 		{ 			putchar(' '); 		}  		for (i = 1; i <= j; ++i) 		{ 			printf("%d", i); 		}  		for (i = j - 1; i > 0; --i) 		{ 			printf("%d", i); 		}  		putchar('\n'); 	}  	getchar(); 	return 0; }

#include<stdio.h> #define fayer 20 int main() {          int i,j,k;         for(i=fayer ;i>0;i--)         {                 for(j=1;j<=i;j++)                 {                         printf("%3d",j);                 }                 for(j=i-1;j>0;j--)                 {                         printf("%3d",j);                 }                 printf("\n");                 for(k=0;k<fayer-i+1;k++)                 {                         printf("   ");                 }         }         printf("\n");         return 0; }

怀念一下，当年中学计算机课的习题 #include <stdio.h> #include <math.h>  int main(void) {     int number;     int i,j;      printf("请输入要打印的层数:");     scanf("%d",&number);      for (i = 0; i < number 0; i++)     {         for (j = 0; j < i; j++)             printf(" ");         for (j = 0; j < 2*(number - i) -1; j++)             printf("%d", number - i - abs(number - i - j - 1));         printf("\n");     }     return 0; }


Question: C题目，求答案解释，小白我看不懂

引用 1 楼 user-1 的回复: #include <stdio.h>  int main(void) { 	int A, B, K, bA, bB, b, bits, temp; 	while (1) 	{ 		printf("请输入三个正整数（前两个数小于10000，第三个数不超过8，各数之间用空格隔开，若前两个数都为零则退出程序）：\n"); 		scanf("%d %d %d", &A, &B, &K);//如果VS勾选了SDL，就把scanf换成scanf_s 		if (A < 0 || B < 0 || A > 10000 || B > 10000 || K < 1 || K > 8) 		{ 			printf("输入错误！\n"); 			continue; 		} 		else if (A == 0 && B == 0) 			break; 		else 		{ 			temp = A > B ? A : B; 			bits = 1; 			while (temp >= 10) 			{ 				temp /= 10; 				++bits; 			} 			b = 1; 			for (int i = 1; i < K; i++) 				b *= 10; 			bA = (A / b) % 10; 			bB = (B / b) % 10; 			if (bA == bB && K <= bits) 				printf("-1\n"); 			else 				printf("%d\n", A + B); 		} 	} 	return 0; } 0%100分


Question: C语言内的宏变量问题

引用 29 楼 mymtom 的回复:由于C99支持VLA(variable length array), 如果char voip_exten[ MAX_VOIP_EXTEN]是局部变量，而且不是某结构体的成员，就比较简单了，MAX_VOIP_EXTEN 定义成一个变量，程序启动的时候从数据库给这个变量赋值就就可以了。  #include <stdio.h>  #define MAX_VOIP_EXTEN  256  /* 增加三行就好了 */ int g_max_voip_exten; #undef  MAX_VOIP_EXTEN #define MAX_VOIP_EXTEN  g_max_voip_exten  int foo(void) {     char voip_exten[ MAX_VOIP_EXTEN];      printf("%d\n", (int)sizeof(voip_exten));     return 0; }  int main(int argc, char *argv[]) {      g_max_voip_exten = argc;      foo();      return 0; }   即使在C99中增加了对VLA的支持，但是还是不能初始化VLA,

引用 29 楼 mymtom 的回复:由于C99支持VLA(variable length array), 如果char voip_exten[ MAX_VOIP_EXTEN]是局部变量，而且不是某结构体的成员，就比较简单了，MAX_VOIP_EXTEN 定义成一个变量，程序启动的时候从数据库给这个变量赋值就就可以了。  #include <stdio.h>  #define MAX_VOIP_EXTEN  256  /* 增加三行就好了 */ int g_max_voip_exten; #undef  MAX_VOIP_EXTEN #define MAX_VOIP_EXTEN  g_max_voip_exten  int foo(void) {     char voip_exten[ MAX_VOIP_EXTEN];      printf("%d\n", (int)sizeof(voip_exten));     return 0; }  int main(int argc, char *argv[]) {      g_max_voip_exten = argc;      foo();      return 0; }  恩阿，学习了。 听老师这么讲，这个做法好像还是有局限性的

引用 27 楼 zhao4zhong1 的回复:那就只有将源代码改为动态分配。 恩阿。多谢老师。本来是想，在新的支持协议中有取巧的办法解决这个问题

引用 22 楼 BeanJoy 的回复:[quote=引用 20 楼 zhao4zhong1 的回复:] 楼主会代码生成（Code Generation）技术吗？ 从数据库取出值，然后生成代码，然后编译，然后发布。 如果用户那数据库中值修改了，然后再生成新代码，再编译，再发布？ 可行吗？[/quote] 为什么不可行？

引用 20 楼 zhao4zhong1 的回复:楼主会代码生成（Code Generation）技术吗？ 从数据库取出值，然后生成代码，然后编译，然后发布。 如果用户那数据库中值修改了，然后再生成新代码，再编译，再发布？ 可行吗？

那就只有将源代码改为动态分配。

引用 24 楼 BeanJoy 的回复:[quote=引用 23 楼 zhao4zhong1 的回复:] [quote=引用 22 楼 BeanJoy 的回复:] [quote=引用 20 楼 zhao4zhong1 的回复:] 楼主会代码生成（Code Generation）技术吗？ 从数据库取出值，然后生成代码，然后编译，然后发布。 如果用户那数据库中值修改了，然后再生成新代码，再编译，再发布？ 可行吗？[/quote] 为什么不可行？[/quote]  可行是可行。 但是这样不得在客户机器上装编译环境，不得把相应的代码拷到客户机器上，在更改数据库一个值后，还得先编译了再运行，谁能接受？反正我是接受不了。[/quote]  这样子就是我这边再打个临时版本给客户，根本起不到远程修改的效果

如果不想将源代码改为动态分配，别无他法。

引用 23 楼 zhao4zhong1 的回复:[quote=引用 22 楼 BeanJoy 的回复:] [quote=引用 20 楼 zhao4zhong1 的回复:] 楼主会代码生成（Code Generation）技术吗？ 从数据库取出值，然后生成代码，然后编译，然后发布。 如果用户那数据库中值修改了，然后再生成新代码，再编译，再发布？ 可行吗？[/quote] 为什么不可行？[/quote] 可行是可行。 但是这样不得在客户机器上装编译环境，不得把相应的代码拷到客户机器上，在更改数据库一个值后，还得先编译了再运行，谁能接受？反正我是接受不了。

纯C语言是不支持动态数组的. C++也只有支持高版C++标准的可以支持动态数组.  你的问题就是动态数组问题.    宏就是一个编译时的文本替换.  所以不可能实现你的需求.  目前来看, 你只能动态分配 , 别无它法了.

楼主会代码生成（Code Generation）技术吗？

引用 10 楼 xiaohuh421 的回复:宏,  不是常量也不是变量.  只是编译时的文本替换.  你的问题, 只需要动态申请内存即可.  动态数组, 只有C++高版本的标准才支持.  并不是动态问题，是要根据数据库改变宏的值，而使得char aaa[MAX_VOIP_EXTEN]这类（很多）数组依旧可用，而不是全部改用malloc

数据下标要确定，我还以为是寻址时要常量，原来是在说定义数组的时候。

仅供参考//codegen.c // 输入一组字符串，比如 // aa ss ddd dd 33 dd // 然后自动生成一个函数 int A(const char*); // 实现A("aa")返回0  A("ss")返回1 依次类推 #include <stdio.h> int main(int argc,char **argv) {     int i;     if (argc<2) {         printf("%s p1 [p2 ...] [>result.c]\nGenerate code int A(const char *a); 0==A(\"p1\") 1==A(\"p2\") ...",argv[0]);         return 1;     }     //printf("#include <string.h>\n");     printf("int A(const char *a) {\n");     for (i=0;i<argc-1;i++) {         printf("    if (0==strcmp(a,\"%s\")) return %d;\n",argv[i+1],i);     }     printf("    return -1;\n");     printf("}\n");     return 0; } //C:\test\Debug>codegen.exe //codegen.exe p1 [p2 ...] [>result.c] //Generate code int A(const char *a); 0==A("p1") 1==A("p2") ... //C:\test\Debug>codegen.exe aa ss ddd dd 33 dd //int A(const char *a) { //    if (0==strcmp(a,"aa")) return 0; //    if (0==strcmp(a,"ss")) return 1; //    if (0==strcmp(a,"ddd")) return 2; //    if (0==strcmp(a,"dd")) return 3; //    if (0==strcmp(a,"33")) return 4; //    if (0==strcmp(a,"dd")) return 5; //    return -1; //} // //c:\test\Debug>codegen.exe aa ss ddd dd 33 dd >result.c // //c:\test\Debug>type result.c //int A(const char *a) { //    if (0==strcmp(a,"aa")) return 0; //    if (0==strcmp(a,"ss")) return 1; //    if (0==strcmp(a,"ddd")) return 2; //    if (0==strcmp(a,"dd")) return 3; //    if (0==strcmp(a,"33")) return 4; //    if (0==strcmp(a,"dd")) return 5; //    return -1; //} //

引用 3 楼 Code_Fly 的回复:[quote=引用 2 楼 jwj070524 的回复:] 直接是不行，C语言不是动态的。一种折中的办法是，先在代码中用undef编译指令取消这些宏定义，然后重新使用这些被取消的符号变成全局变量，之后写一个从数据库中读出这些变量的函数，在程序初始化阶段给这些全局变量赋值。  那这样子那些宏全部变成全局变量，不能作为数组的大小[/quote]  引用 4 楼 lovesmiles 的回复:[quote=引用 2 楼 jwj070524 的回复:] 直接是不行，C语言不是动态的。一种折中的办法是，先在代码中用undef编译指令取消这些宏定义，然后重新使用这些被取消的符号变成全局变量，之后写一个从数据库中读出这些变量的函数，在程序初始化阶段给这些全局变量赋值。  别胡扯，在C语言里面数组下标不能用变量表示，必须是编译期就明确的常量和宏。[/quote] C99支持variable length array，所以如果用GCC的话是可以的。

可以考虑把数据库中取出的值作为数组的最大有效范围的游标吗?如果直接想简单的修改宏，感觉边角困难

malloc不能用啊？


Question: c语言新手，感觉不知道怎么学习才好

引用 14 楼 zhao4zhong1 的回复:计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  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对应的汇编并单步执行观察相应内存和寄存器变化。） 谢谢

引用 13 楼 OrdinaryHeart 的回复:提点我个人建议吧，我觉得你应该先把谭浩强的C看懂看透，这边书很基础，比较适合入门，想全面点也可以看《C Primer》。然后学下C++，可以看《C++ Primer》，如果有C++的基础，再去看windows程序设计会轻松好多的。如果觉得学了C/C++之后没有方向感，可以看一些有项目解析的书。如果想深入C++，还有好多C++的书籍，比如高级C++编程、高效C++等等。学C不要好高骛远，要沉下心来学。 嗯，谢谢指导

多了嚼不烂

慢慢来~~~

引用 8 楼 keaiLVwangdao 的回复:[quote=引用 7 楼 u013163178 的回复:] 我觉得《windows程序设计》这本不存在懂不懂，只要你有求知欲望，C语言不太差，有耐心，按照书上的代码敲几遍就基本懂了，所有的windows程序都是那个基本的框架。你一定会懂的，时间的问题，有些东西你现在不懂，但是你坚持去学习，总有一天你会觉得豁然开朗，这时候你觉得你国过去都是值得的，你会庆幸自己没有放弃。《windows程序设计》确实是有些枯燥，你不必要一次全部懂，只要慢慢了解，就不会害怕了。最后给你一套视频（C语言win32编程）http://www.tudou.com/home/93506222/ 问下，学windows程序设计需要c++的基础吗？或者说我先学c++还是windows程序设计比较好？[/quote]基本不需要，懂C语言就行了

引用 6 楼 keaiLVwangdao 的回复:[quote=引用 5 楼 zjq9931 的回复:] [quote=引用 2 楼 keaiLVwangdao 的回复:] [quote=引用 1 楼 kino_chen 的回复:] 慢慢来，书看的多了，有些以前觉得难懂的就看懂了，读书百遍其义自见~ 现在感觉就c语言书上讲的倒也都明白...但是window程序设计确实是看不懂[/quote] 说明对windows还不了解，另外可能是英语水平不够。我就经历过，英语水平不够，看着很吃力。后来恶补了英语，看着终于不吃力了。[/quote] 嗯，对windows确实不了解，看的时候有的程序看不太懂也没有详细一点的讲解，而且好像用了c++的知识没看到[/quote] windows程序设计，基本上是C语言的，没有涉及C++。

多动手实践，做个小东西出来，应该会好点

引用 7 楼 u013163178 的回复:我觉得《windows程序设计》这本不存在懂不懂，只要你有求知欲望，C语言不太差，有耐心，按照书上的代码敲几遍就基本懂了，所有的windows程序都是那个基本的框架。你一定会懂的，时间的问题，有些东西你现在不懂，但是你坚持去学习，总有一天你会觉得豁然开朗，这时候你觉得你国过去都是值得的，你会庆幸自己没有放弃。《windows程序设计》确实是有些枯燥，你不必要一次全部懂，只要慢慢了解，就不会害怕了。最后给你一套视频（C语言win32编程）http://www.tudou.com/home/93506222/ 顺便谢谢视频

引用 7 楼 u013163178 的回复:我觉得《windows程序设计》这本不存在懂不懂，只要你有求知欲望，C语言不太差，有耐心，按照书上的代码敲几遍就基本懂了，所有的windows程序都是那个基本的框架。你一定会懂的，时间的问题，有些东西你现在不懂，但是你坚持去学习，总有一天你会觉得豁然开朗，这时候你觉得你国过去都是值得的，你会庆幸自己没有放弃。《windows程序设计》确实是有些枯燥，你不必要一次全部懂，只要慢慢了解，就不会害怕了。最后给你一套视频（C语言win32编程）http://www.tudou.com/home/93506222/ 问下，学windows程序设计需要c++的基础吗？或者说我先学c++还是windows程序设计比较好？

引用 5 楼 zjq9931 的回复:[quote=引用 2 楼 keaiLVwangdao 的回复:] [quote=引用 1 楼 kino_chen 的回复:] 慢慢来，书看的多了，有些以前觉得难懂的就看懂了，读书百遍其义自见~ 现在感觉就c语言书上讲的倒也都明白...但是window程序设计确实是看不懂[/quote] 说明对windows还不了解，另外可能是英语水平不够。我就经历过，英语水平不够，看着很吃力。后来恶补了英语，看着终于不吃力了。[/quote] 嗯，对windows确实不了解，看的时候有的程序看不太懂也没有详细一点的讲解，而且好像用了c++的知识没看到

引用 2 楼 keaiLVwangdao 的回复:[quote=引用 1 楼 kino_chen 的回复:] 慢慢来，书看的多了，有些以前觉得难懂的就看懂了，读书百遍其义自见~ 现在感觉就c语言书上讲的倒也都明白...但是window程序设计确实是看不懂[/quote] 说明对windows还不了解，另外可能是英语水平不够。我就经历过，英语水平不够，看着很吃力。后来恶补了英语，看着终于不吃力了。

引用 3 楼 kino_chen 的回复:[quote=引用 2 楼 keaiLVwangdao 的回复:] 现在感觉就c语言书上讲的倒也都明白...但是window程序设计确实是看不懂 是这样的，语言只是基础，刚开始看某些书是有些看不懂的。推荐看看《c陷阱与缺陷》，《c专家编程》。[/quote] 谢谢

引用 2 楼 keaiLVwangdao 的回复:现在感觉就c语言书上讲的倒也都明白...但是window程序设计确实是看不懂 是这样的，语言只是基础，刚开始看某些书是有些看不懂的。推荐看看《c陷阱与缺陷》，《c专家编程》。

引用 1 楼 kino_chen 的回复:慢慢来，书看的多了，有些以前觉得难懂的就看懂了，读书百遍其义自见~ 现在感觉就c语言书上讲的倒也都明白...但是window程序设计确实是看不懂

慢慢来，书看的多了，有些以前觉得难懂的就看懂了，读书百遍其义自见~


Question: c语言访问mysql数据库如何实现（windows环境下）

gcc ... -I（ mysql include的位置） -L（mysql LIB的位置） -lmysqlclient


Question: 线性表的初始化，查找，插入，删除的程序错在哪里？？？还请指教

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

难道lz不能自己改吗

太感谢你了！！！我想追问一下能不能输出它查找的元素的值？

# include<stdio.h> # include<stdlib.h> # define LIST_INIT_SIZE 100 # define LISTINCREMENT 10 # define OVERFLOW -2 # define OK 1 # define ERROR 0 typedef int ElemType;  typedef struct Sqlist { 	ElemType *elem; 	int length; 	int listsize; }Sqlist;  void main() { 	Sqlist *L,S; 	L=&S; 	int i,j,e,n; 	int InitList_Sq(Sqlist *L,int n); 	int LocateELem_Sq(Sqlist *L,int i); 	int ListInsert_Sq(Sqlist *L,int i,ElemType e); 	int ListDelete_Sq(Sqlist *L,int i); 	int PutList(Sqlist *L); 	printf("输入表的长度：\n"); 	scanf("%d",&n); 	InitList_Sq(L,n); 	PutList(L); 	printf("输入查找的位置:\n"); 	scanf("%d",&i); 	LocateELem_Sq(L,i); 	PutList(L); 	printf("输入插入的位置：\n"); 	scanf("%d",&i); 	printf("输入插入的值：\n"); 	scanf("%d",&e); 	ListInsert_Sq(L,i,e); 	PutList(L); 	printf("输入删除的位置：\n"); 	scanf("%d",&j); 	ListDelete_Sq(L,j); 	PutList(L); }  int InitList_Sq(Sqlist *L,int n) { 	int i; 	ElemType *newbase; 	L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); 	if(!L->elem) 		exit(OVERFLOW); 	L->length=0; 	L->listsize=LIST_INIT_SIZE; 	printf("请输入表中的数据:\n"); 	for(i=0;i<n;i++) 	{  		scanf("%d",&L->elem[i]); 		++L->length; 		if(L->length>L->listsize) 		{ 			newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType)); 			if(!newbase) 				exit(OVERFLOW); 			L->elem=newbase; 			L->listsize+=LISTINCREMENT; 		} 	} 	return OK; }  int ListInsert_Sq(Sqlist *L,int i,ElemType e) { 	ElemType *p,*q,*newbase; 	if(i<1||i>L->length+1) 		return ERROR; 	if(L->length>=L->listsize) 	{ 		newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType)); 		if(!newbase) 			exit(OVERFLOW); 		L->elem=newbase; 		L->listsize+=LISTINCREMENT; 	} 	q=&L->elem[i-1]; 	for(p=&L->elem[L->length-1];p>=q;--p) 		*(p+1)=*p; 	*q=e; 	++L->length; 	return OK; } int LocateELem_Sq(Sqlist *L,ElemType e) { 	for(int i=0;i<L->length;i++) 		if(L->elem[i]==e) return i+1; 	printf("查找的元素为:\n%d\n",e); 	return 0; } int ListDelete_Sq(Sqlist *L,int i) { 	ElemType *p,*q; 	int e; 	if(i<1||i>L->length) 		return ERROR; 	p=&L->elem[i-1]; 	e=*p; 	q=&(L->elem[L->length-1]); 	for(++p;p<=q;++p) 		*(p-1)=*p; 	--L->length; 	printf("删除的元素为：\n%d\n",e); 	return 0; }  int PutList(Sqlist *L) { 	int *p,*q; 	p=L->elem; 	q=L->elem+(L->length-1); 	printf("线性表中元素为：\n"); 	for(p=L->elem;p<=q;++p) 	{ 		printf("%d  ",*p); 	} 	printf("\n表长为：%d  \n",L->length); 	return OK; }改了一下，编译通过了。


Question: 如何将eXosip的UDP模式改为TCP模式？

那些api应该有说明啊。标准的查sdk和手册。网上的谁给的找谁。


Question: 好多问题啊，赵老师求救

for (i = 1; i<MAXCHAR; ++i) 		if (cc[c]>maxvalue) 			maxvalue = cc[i];  第二行 cc[c] 应该是cc[i]

#include<stdio.h> #include<ctype.h> #define MAXHIST   15 #define MAXCHAR  128 int main() { 	int c, i, cnt = 0; 	int len; 	int maxvalue; 	int cc[MAXCHAR]; 	 	for(i=0;i<MAXCHAR;++i)    //initize the array 		cc[i] = 0; 	while((c = getchar())!=EOF) 		if(c < MAXCHAR) 			++cc[c]; 	maxvalue = 0; 	for(i=1; i < MAXCHAR; ++i) 		if(cc[i] > maxvalue)    //error may be here!  			maxvalue = cc[i]; 	for(i=1; i<MAXCHAR; ++i) 	{ 		if(isprint(i)) 			printf("%5d -  %c - %5d :",i,i,cc[i]); 		else 			printf("%5d - - %5d : ",i,cc[i]); 		if(cc[i] > 0) 		{ 			if((len = (int)cc[i]*MAXHIST/maxvalue) >= 0) 			len = 1; 		} 		else 			len = 0; 		while(len > 0) 		{ 			putchar('*'); 			--len; 		} 		putchar('\n'); 	} 	return 0; }

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

for(i=1;i<MAXCHAR;++i) if(cc[c]>maxvalue) maxvalue=cc[i];  你把c和i搞混了，判断条件应该是if(cc[i]>maxvalue)


Question: 怎么就不排序呢，还内存泄漏？

引用 1 楼 SFangtao2012 的回复:#include <stdio.h> void bubble_sort(int a[],int n) { 	bool change; 	int i,j; 	for(i=n-1,change=true; i>=1&&change; i--)			//这里i--，不是i++ 	{ 		change=false; 		for( j=0; j<i; j++) 		{ 			if(a[j]<a[j+1]) 			{ 				int elem; 				elem=a[j+1]; 				a[j+1]=a[j]; 				a[j]=elem; 			} 			change=true; 		} 	} 	for(i=0; i<n; i++) 	{ 		printf("%d",a[i]); 	} } int main() { 	printf("Hello world!\n"); 	int a[]= {1,2,3,4,5,6}; 	int n=6; 	bubble_sort(a,n); 	return 0; } ++ 内存泄露应该出在这儿，数组越界~~~

引用 7 楼 zhao4zhong1 的回复:崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。 赵老师能耐心为我讲这么多，我也感觉自己相当浮躁，沉不下心，不过我还是很明白，这不能当作偷懒的借口，以后就像你说的这么去做了（在这之前，我还真不知道这些调试的方法），谢谢

引用 5 楼 taiyangshen2012555 的回复:[quote=引用 3 楼 spaceman10 的回复:] [quote=引用 2 楼 taiyangshen2012555 的回复:] 刚才百科下内存泄漏，说是动态分配的空间未被回收造成部分内存不可用，可是我这里就没有用malloc，realloc，new这些呀，也不知道内存是被哪个部分给占用，然后又没被我释放的？  你这个问题是数组越界，c++内存分5种，在栈上的内存是系统自动分配的。[/quote] 这个“栈”是什么东西，能给我解释下不？[/quote]我知道栈的定义，但这里的栈不是我定义的，那就应该是系统里面的吧，那用于什么地方，什么时候启用的？

引用 3 楼 spaceman10 的回复:[quote=引用 2 楼 taiyangshen2012555 的回复:] 刚才百科下内存泄漏，说是动态分配的空间未被回收造成部分内存不可用，可是我这里就没有用malloc，realloc，new这些呀，也不知道内存是被哪个部分给占用，然后又没被我释放的？  你这个问题是数组越界，c++内存分5种，在栈上的内存是系统自动分配的。[/quote] 这个“栈”是什么东西，能给我解释下不？

引用 1 楼 SFangtao2012 的回复:#include <stdio.h> void bubble_sort(int a[],int n) { 	bool change; 	int i,j; 	for(i=n-1,change=true; i>=1&&change; i--)			//这里i--，不是i++ 	{ 		change=false; 		for( j=0; j<i; j++) 		{ 			if(a[j]<a[j+1]) 			{ 				int elem; 				elem=a[j+1]; 				a[j+1]=a[j]; 				a[j]=elem; 			} 			change=true; 		} 	} 	for(i=0; i<n; i++) 	{ 		printf("%d",a[i]); 	} } int main() { 	printf("Hello world!\n"); 	int a[]= {1,2,3,4,5,6}; 	int n=6; 	bubble_sort(a,n); 	return 0; } 啊！我怎么老这么马虎，这个程序前面一次被我输错了一次，后来改的时候只改了for的初始条件，却忘了改循环变量的赋值语句了，汗，这么说，就是我从a[n-1]的时候就占用了数组a以外的内存，也没法释放，就造成了内存泄漏，终于懂了，谢谢

引用 2 楼 taiyangshen2012555 的回复:刚才百科下内存泄漏，说是动态分配的空间未被回收造成部分内存不可用，可是我这里就没有用malloc，realloc，new这些呀，也不知道内存是被哪个部分给占用，然后又没被我释放的？  你这个问题是数组越界，c++内存分5种，在栈上的内存是系统自动分配的。


既然是数字，你可以把字符转换成数字！而且A-Z也可以有对应的数字的，所以下面的不会有影响。再说char/wchar_t中有两个字符是有问题的吧……抑或把字符换成字符串

wchar_t  的問題


Question: 将文件存入数组的问题

cout<<(int)fileinput.tellg();

引用 1 楼 user-2 的回复:char data[10][20]  改过来了，不过读进去的数据还是不对，感觉是串行了，但我不知道哪里的问题

char data[10][20]


Question: 求教Linux线程的结合状态和分离状态

引用 5 楼 KuaiPengFei_ 的回复:[quote=引用 3 楼 hpoor 的回复:] [quote=引用 2 楼 KuaiPengFei_ 的回复:] 创建一个线程默认的状态是joinable, 如果一个线程结束运行但没有被join,则它的状态类似于进程中的Zombie Process,即还有一部分资源没有被回收（退出状态码），所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源（类似于wait,waitpid) 但是调用pthread_join(pthread_id)后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此，比如在Web服务器中当主线程为每个新来的链接创建一个子线程进行处理的时候，主线程并不希望因为调用pthread_join而阻塞（因为还要继续处理之后到来的链接），这时可以在子线程中加入代码 pthread_detach(pthread_self()) 或者父线程调用 pthread_detach(thread_id)（非阻塞，可立即返回） 这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源 我想描述的就是你说的这种情形，抱歉我描述不清楚。 有个问题，加入pthread_detach后，pthread_join这个函数还需要加上吗？ 还有我加入pthread_detach后，那个线程函数中存在死循环，这种情形程序会怎么处理？一直执行死循环，不释放资源吗。还是执行一次或者限定的次数再释放资源呢？[/quote]  线程的状态就改变了。 pthread_join这个函数不需要了  死循环是肯定不行的，自己在代码里面加死循环的时候就要知道什么时候可以退出  。[/quote]  好的，我知道了。谢谢你了

引用 3 楼 hpoor 的回复:[quote=引用 2 楼 KuaiPengFei_ 的回复:] 创建一个线程默认的状态是joinable, 如果一个线程结束运行但没有被join,则它的状态类似于进程中的Zombie Process,即还有一部分资源没有被回收（退出状态码），所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源（类似于wait,waitpid) 但是调用pthread_join(pthread_id)后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此，比如在Web服务器中当主线程为每个新来的链接创建一个子线程进行处理的时候，主线程并不希望因为调用pthread_join而阻塞（因为还要继续处理之后到来的链接），这时可以在子线程中加入代码 pthread_detach(pthread_self()) 或者父线程调用 pthread_detach(thread_id)（非阻塞，可立即返回） 这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源 我想描述的就是你说的这种情形，抱歉我描述不清楚。 有个问题，加入pthread_detach后，pthread_join这个函数还需要加上吗？ 还有我加入pthread_detach后，那个线程函数中存在死循环，这种情形程序会怎么处理？一直执行死循环，不释放资源吗。还是执行一次或者限定的次数再释放资源呢？[/quote]  线程的状态就改变了。 pthread_join这个函数不需要了  死循环是肯定不行的，自己在代码里面加死循环的时候就要知道什么时候可以退出  。

引用 1 楼 KuaiPengFei_ 的回复:pthread_join(tid); 去掉了试试，不太明白的意思，但是程序就是在创建一个线程之后停在了这里！ pthread_join去掉后是可以的，但是这样好像不释放资源，而且一直创建新的线程，会耗尽内存空间吧

引用 2 楼 KuaiPengFei_ 的回复:创建一个线程默认的状态是joinable, 如果一个线程结束运行但没有被join,则它的状态类似于进程中的Zombie Process,即还有一部分资源没有被回收（退出状态码），所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源（类似于wait,waitpid) 但是调用pthread_join(pthread_id)后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此，比如在Web服务器中当主线程为每个新来的链接创建一个子线程进行处理的时候，主线程并不希望因为调用pthread_join而阻塞（因为还要继续处理之后到来的链接），这时可以在子线程中加入代码 pthread_detach(pthread_self()) 或者父线程调用 pthread_detach(thread_id)（非阻塞，可立即返回） 这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源 我想描述的就是你说的这种情形，抱歉我描述不清楚。 有个问题，加入pthread_detach后，pthread_join这个函数还需要加上吗？ 还有我加入pthread_detach后，那个线程函数中存在死循环，这种情形程序会怎么处理？一直执行死循环，不释放资源吗。还是执行一次或者限定的次数再释放资源呢？


Question: 16进制转换成字符串

1楼代码是错的。

char bin[50] = {0xab,0xbc,0xcd}; char str[100]; for (i = 0; i < 3; i++) {     sprintf(str+i*2,"%02X",(unsigned char)bin[i]); }

引用 1 楼 piaobotudou 的回复:char buf[10]; char bin[50] = {0xab,0xab,0xbc,0xcd}; char str[100] = {0}; int len = strlen(bin); int i; for (i = 0; i < len; i++) {        sprintf(buf,"%.2x",(unsigned char)bin[i]);         strcat(str,buf); }     return 0; 多谢指点


Question: atol函数的返回值问题

不过也无所谓了，反正任何输入前的检查肯定得要自已做，如果是转double的话，把转int的结果稍做一下变换就可以满足了，收贴吧

引用 13 楼 SXJIAKE 的回复:[quote=引用 2 楼 bug1190 的回复:] [quote=引用 1 楼 zxhuser-4 的回复:] 不返回0那返回啥呢？ 我就草了，，我规定，返回值为int，-1表示转换失败，0表示成功，在参数列表中加入一个int型的指针，将返回结果写入！这样还有上面的类似问题吗? [/quote] API：StrToIntEx[/quote] 能不能再找一个关于Str转Double的好用的函数，那样就完美了，strtod不算哟，，

引用 13 楼 SXJIAKE 的回复:[quote=引用 2 楼 bug1190 的回复:] [quote=引用 1 楼 zxhuser-4 的回复:] 不返回0那返回啥呢？ 我就草了，，我规定，返回值为int，-1表示转换失败，0表示成功，在参数列表中加入一个int型的指针，将返回结果写入！这样还有上面的类似问题吗? [/quote] API：StrToIntEx[/quote] 谢谢，哥们帮我解决了大问题了，

引用 2 楼 bug1190 的回复:[quote=引用 1 楼 zxhuser-4 的回复:] 不返回0那返回啥呢？ 我就草了，，我规定，返回值为int，-1表示转换失败，0表示成功，在参数列表中加入一个int型的指针，将返回结果写入！这样还有上面的类似问题吗? [/quote] API：StrToIntEx

实在想在一定范围内精确表示十进制小数，请搜索“定点小数”

引用 10 楼 bug1190 的回复:[quote=引用 9 楼 zhao4zhong1 的回复:] http://bbs.csdn.net/topics/360055953 fscanf我在项目中用过，存在同样的问题，对格式要求太严，“%lf”转换成double时不能保证准确的纯度，本来是555.666,转换后有时就成了555.66600000000003，而且同样有遇到空格的问题，哎，说来说去就是效果差，不太适合在项目当中用，容易被坑，，或者 坑别人，，[/quote] 这只能说明你对计算机表示浮点数理解不透彻。 http://bbs.csdn.net/topics/390676437

引用 9 楼 zhao4zhong1 的回复:http://bbs.csdn.net/topics/360055953 fscanf我在项目中用过，存在同样的问题，对格式要求太严，“%lf”转换成double时不能保证准确的纯度，本来是555.666,转换后有时就成了555.66600000000003，而且同样有遇到空格的问题，哎，说来说去就是效果差，不太适合在项目当中用，容易被坑，，或者 坑别人，，

引用 7 楼 zhao4zhong1 的回复:正则表达式不是万能的，有限状态自动机是万能的。 谁能用正则表达式实现以下文法的解析？ include\float.h ... #define DBL_DIG         15                      /* # of decimal digits of precision */ #define DBL_EPSILON     2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */ #define DBL_MANT_DIG    53                      /* # of bits in mantissa */ #define DBL_MAX         1.7976931348623158e+308 /* max value */ #define DBL_MAX_10_EXP  308                     /* max decimal exponent */ #define DBL_MAX_EXP     1024                    /* max binary exponent */ #define DBL_MIN         2.2250738585072014e-308 /* min positive value */ #define DBL_MIN_10_EXP  (-307)                  /* min decimal exponent */ #define DBL_MIN_EXP     (-1021)                 /* min binary exponent */ #define _DBL_RADIX      2                       /* exponent radix */ #define _DBL_ROUNDS     1                       /* addition rounding: near */  #define FLT_DIG         6                       /* # of decimal digits of precision */ #define FLT_EPSILON     1.192092896e-07F        /* smallest such that 1.0+FLT_EPSILON != 1.0 */ #define FLT_GUARD       0 #define FLT_MANT_DIG    24                      /* # of bits in mantissa */ #define FLT_MAX         3.402823466e+38F        /* max value */ #define FLT_MAX_10_EXP  38                      /* max decimal exponent */ #define FLT_MAX_EXP     128                     /* max binary exponent */ #define FLT_MIN         1.175494351e-38F        /* min positive value */ #define FLT_MIN_10_EXP  (-37)                   /* min decimal exponent */ #define FLT_MIN_EXP     (-125)                  /* min binary exponent */ #define FLT_NORMALIZE   0 #define FLT_RADIX       2                       /* exponent radix */ #define FLT_ROUNDS      1                       /* addition rounding: near */ ... C++ Floating-Point Constants Floating-point constants specify values that must have a fractional part. These values contain decimal points (.) and can contain exponents.  Syntax  floating-constant :  fractional-constant exponent-partopt floating-suffixopt digit-sequence exponent-part floating-suffixopt  fractional-constant :  digit-sequenceopt . digit-sequence digit-sequence .  exponent-part :  e signopt digit-sequence E signopt digit-sequence  sign : one of  + –  digit-sequence :  digit digit-sequence digit  floating-suffix :one of  f l F L  Floating-point constants have a “mantissa,” which specifies the value of the number, an “exponent,” which specifies the magnitude of the number, and an optional suffix that specifies the constant’s type. The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. For example:  18.46 38.  The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:  18.46e0      // 18.46 18.46e1      // 184.6  If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.  Floating-point constants default to type double. By using the suffixes f or l (or F or L — the suffix is not case sensitive), the constant can be specified as float or long double, respectively.  Although long double and double have the same representation, they are not the same type. For example, you can have overloaded functions like  void func( double );  and   void func( long double ); 想来想去，我还是单独写个验证能否转换的函数算了，sscanf_s也不可靠，对格式要求太严，也没必要去为了解决这个问题而使用正则，

引用 4 楼 zhao4zhong1 的回复:参考下面：#include <stdio.h> char s[]="123 ab 4"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,"%d%n",&v,&n);         printf("k,v,n=%d,%d,%d\n",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf("skip char[%c]\n",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf("End.\n"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.  看来还是你比较上道，，，明白俺的意思，，我也在考虑用这个函数，应该能解决，不过有一点还不清楚的地方就是：这个函数的格式指定时，能不能有一块的格式写成可有可无的形式，就是如果跟实串匹配成功了，就提取，如果没匹配成功，则也跳过，而不是直接返回个0，就此函数返回，，这种情况是可以用多次调用这个函数来解决，但我觉得那样麻烦，有没有一种高级点的格式写法，只调用一次把这个问题解决掉，，格式比如像： int nRetValue = _stscanf_s(pszBuf,TEXT("%*[ \t+]%[0-9]"),szTextBuf,sizeof(szTextBuf)/sizeof(TCHAR));  	if (nRetValue==0)  	{  		_tprintf_s(TEXT("Sscanf Return Empty\n"));  	}

改用strtol函数就行了，通过第二参数判断是否转换成功  #include <stdio.h> #include <stdlib.h>  int main(void) { 	char str[][10] = { "0", "0a", " 0 " }; 	long l; 	char *end; 	int i;  	for (i = 0; i < sizeof(str) / sizeof(str[0]); ++i) 	{ 		l = strtol(str[i], &end, 10); 		printf("%ld %c(%d)\n", l, *end, *end); 	}  	getchar(); 	return 0; }

用sscanf

引用 1 楼 zxhuser-4 的回复:不返回0那返回啥呢？ 我就草了，，我规定，返回值为int，-1表示转换失败，0表示成功，在参数列表中加入一个int型的指针，将返回结果写入！这样还有上面的类似问题吗?

不返回0那返回啥呢？


Question: 返回参数地址的问题~请大神乱入~

第一张图的p应该是函数里面x的地址吧？

引用 2 楼 magic_ggyy 的回复:x在函数里应该是个临时变量吧？那*p之所以打印出来是10 是因为打印出来的是临时变量x的值吧？ 所谓临时变量，就是说该地址(也就是p指针，fct里面x的地址)只有在fct这个函数里面才有效，fct返回了之后就可能失效了。 参数地址是在栈上，函数返回之后，你的第一个例子的栈暂时还没有别人用过，所以还能得到上次的值。 而第二个例子中间多了两个cout<<的调用，栈上的临时变量的地址被他们覆盖了，所以10这个值也就不存在了。 打个比方，从硬盘上删除一个文件，马上恢复运气好的话还能恢复回来。时间长了被覆盖了之后就没法恢复了。

第二张图为什么打印出来的*p的值又变了呢？


Question: 定义宏#define PRINT() printf("填什么？")，调用PRINT();PRINT();可打印出23

没看懂的配熬过

哈哈哈哈哈... 大嘴你改卖菜刀肯定有前途。

引用 13 楼 DelphiGuy 的回复:大嘴这个代码可行，就是有位置依赖，如果PRINT();PRINT();之类的就是BUG了。 刚被给出可实现的代码，就立马改需求的人会被码农在心里杀一万遍不止！

函数形式的宏定义？  #include <stdio.h> #define PN(a) printf("%d\n", (a))  int main(void) { 	PN(23); 	PN(31);  	getchar(); 	return 0; }

引用 18 楼 DelphiGuy 的回复:哈哈哈哈哈... 大嘴你改卖菜刀肯定有前途。

#include <stdio.h> #define PRINT() printf("%d",__LINE__-2) int main(){     PRINT();     PRINT();     return 0; } //23

引用 10 楼 DelphiGuy 的回复:就是编码问题，使用wprintf。 不解，请详细讲一下！

这操蛋的代码

引用 5 楼 brookmill 的回复:[quote=引用 3 楼 wangmm2008 的回复:] [quote=引用 2 楼 brookmill 的回复:] #define PRINT() printf("23\r") 这个好像打印不出来呀，是不是我写的代码有问题？  #include <stdio.h> #define PRINT() printf("23\r") int main(){     PRINT();     PRINT(); } [/quote] 代码没问题，我用gcc和VS2013都试了，可以打出来[/quote] 终端里面运行没有输出，vim里面:!a运行输出23

引用 5 楼 brookmill 的回复:[quote=引用 3 楼 wangmm2008 的回复:] [quote=引用 2 楼 brookmill 的回复:] #define PRINT() printf("23\r") 这个好像打印不出来呀，是不是我写的代码有问题？  #include <stdio.h> #define PRINT() printf("23\r") int main(){     PRINT();     PRINT(); } [/quote] 代码没问题，我用gcc和VS2013都试了，可以打出来[/quote] 我用gcc，没有打印东西出来

引用 3 楼 wangmm2008 的回复:[quote=引用 2 楼 brookmill 的回复:] #define PRINT() printf("23\r") 这个好像打印不出来呀，是不是我写的代码有问题？  #include <stdio.h> #define PRINT() printf("23\r") int main(){     PRINT();     PRINT(); } [/quote] 代码没问题，我用gcc和VS2013都试了，可以打出来

引用 1 楼 jerry_dqh 的回复:可能是编码的原因，宏的用法并没有问题。 这是个笔试题，就让写宏定义中printf()怎么写

引用 2 楼 brookmill 的回复:#define PRINT() printf("23\r") 这个好像打印不出来呀，是不是我写的代码有问题？  #include <stdio.h> #define PRINT() printf("23\r") int main(){     PRINT();     PRINT(); }

#define PRINT() printf("23\r")

可能是编码的原因，宏的用法并没有问题。

就是编码问题，使用wprintf。

引用 2 楼 brookmill 的回复:#define PRINT() printf("23\r") 为什么只打印出一个23呢，不是两个PRINT么

换个写法应该就行了  #define PRINT() printf("\r23")


Question: 请教

1、将矩阵看做二值图像； 2、获得二值图像的水平投影和垂直投影； 3、对两个投影曲线取同一位置，且相邻波峰间距也相同的一段； 4、得到求最大间距，然后将转换成方阵边长


Question: 关于 const char *const buf;请问buf这个变量该如何初始化呢？

初始化是一开始在声明时就同时赋的值，怎麽搞都可以。  在声明後，再赋值就不行了。

这个声明的意思是，不许修改buf指向的内容(第一个const)，buf初始化之后不许指向其他地址(第二个const) 只要满足这两个条件，怎么初始化都行。 从语法上来说这样应该也可以  const char *const buf = malloc(100); 但是这样没什么意义因为没法修改buf的内容

我试试呵呵。

const char *const buf = "abc";


Question: 树

仅供参考#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,"%d%n",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf("%d,%d\n",a,b);     return 0; }


仅供参考//用C语言编程，求出2^x=x^10这个方程的解。 #include <math.h> #include <stdio.h> double x,e; void main () {     x=-1.0;     e=0.001;     while (1) {         while (1) {             if (pow(2.0,x)<pow(x,10.0)) {                 x+=e;             } else {                 break;             }         }         e/=10.0;         if (e<1e-15) break;         while (1) {             if (pow(2.0,x)>pow(x,10.0)) {                 x-=e;             } else {                 break;             }         }         e/=10.0;         if (e<1e-15) break;     }     printf("%+.14g\n",x);      x=1.0;     e=0.001;     while (1) {         while (1) {             if (pow(2.0,x)>pow(x,10.0)) {                 x+=e;             } else {                 break;             }         }         e/=10.0;         if (e<1e-15) break;         while (1) {             if (pow(2.0,x)<pow(x,10.0)) {                 x-=e;             } else {                 break;             }         }         e/=10.0;         if (e<1e-15) break;     }     printf("%+.14g\n",x); }

用牛顿迭代法，到两次迭代解的差小于给定的误差为止。

求 sin(x)


Question: 请问C语言如何获取文件中不定长的字符串

非常感谢大家的帮助 问题已解决

strlen + malloc

仅供参考//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen("data.txt","r");     if (NULL==f) {         printf("Can not open file data.txt!\n");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,"NAME: %32[^\n]",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,"DIMENSION: %d",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,"DATA\n")) st=3;         } else if (st==3) {             if (3==sscanf(ln,"%d%d%d",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf("s.NAME=[%s]\n",s.NAME);     printf("s.DIMENSION=%d\n",s.DIMENSION);     for (i=0;i<n;i++) {         printf("s.DATA[%d].NO,X,Y=%d,%d,%d\n",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8

这还不简单吗，倒起来查找逗号啊。

还得包含string.h头文件

#include <stdio.h> #include <stdlib.h> #include <ctype.h> #define BUFSIZE 1024  int main(void) { 	const char filename[] = "D:\\test.txt"; 	FILE *fp; 	char buf[BUFSIZE]; 	char ch; 	int i; 	 	fp = fopen(filename, "r"); 	if (fp == NULL) 	{ 		fprintf(stderr, "Failed to open file %s", filename); 		exit(EXIT_FAILURE); 	}   	while (fgets(buf, BUFSIZE, fp) != NULL) 	{ 		for (i = 0; i < strlen(buf); ++i) 		{ 			if (isdigit(buf[i]) && i > 0 && buf[i - 1] == ',') 			{ 				buf[i - 1] = '\0'; 			} 		}  		printf("name: %s\n", buf); 	}  	getchar(); 	return 0; }

可以用strcok()将字符串分割，然后判断分割后的字符串的第一个字符，得到是否是name。

把整串字符串读取下来，然后遍历字符串，根据逗号的位置来截取字符串。 不定长的字符串，你可以使用malloc动态分配。


Question: 无法输出中文字符串

引用 2 楼 gaoce227 的回复:ok了 ，貌似vi编码的问题 UI?VI？ 设置本地字符环境吧？

ok了 ，貌似vi编码的问题

char 是asccii码，不能输出汉字


Question: 请各位路过看下指点指点

Linux下不知道。 Windows下参考API ReadDirectoryChangesW和Microsoft SDK\samples\winbase\IO\fWatch\*.*

太難了還沒學到說

引用 1 楼 zhao4zhong1 的回复:man 不是，赵老师，我想用强制锁这种机制来响应一个进程打开一个文件的事件，具体就是对文件进行打开或者读的操作，内核会响应该事件并且发送信号给持有锁的进程，但是现在代码写完了遇到了一个问题，当我鼠标双击文件所在的目录的时候，内核也会向拥有锁的进程发送信号，不知道fcntl怎么可以屏蔽打开目录这件事，或者说双击目录的时候，对该目录下的文件做了哪些动作，真的是打开了目录下的所有文件吗？网上找了好长时间的资料都没有涉及的，请赵老师赐教啊！！谢谢赵老师了先

man


Question: 初学者关于OpenGL 的问题

搜网络教程“学OpenGL编3D游戏”。


Question: 有关字符输出问题 const char* str="\x56\x78\x12\x34"; printf("%x",*(int*)str);

char*p2="abcdef";为什么这个输出是abcdef呢？菜鸟求指教。。。

都那么晚睡。。。。谢谢啦

一般的32位和64位编译器，int都是4个字节。某些古老的编译器可能是2字节。 const char* str="\x56\x78\x12\x34";  // str指向一块内存，它的前4个字节依次是0x56, 0x78, 0x12, 0x34 printf("%x",*(int*)str);  // 把str指向的内存的4个字节按照int格式输出。小端系统会把字节顺序反过来，输出0x34127856；大端系统保持字节顺序，输出0x56781234。

一个类似的例子： char str[] = { 0x56, 0x78, 0x12, 0x34 };         printf("%x",*(int*)str);  // 小端系统输出0x34127856，大端系统输出0x56781234


Question: C 函数值赋予传递的问题?

我主要是要获取 sprintf 这个格化输出的字符串值，在其它的的函数中，使用，刚开始没想到用，可以用全局变量来定义，更简单  谢谢了  二楼的方法也可以，只要稍修改一下就可以了，  static char * conn_rsp_timer_fn(unsigned long arg) { static char name[512]; ............. }  int conn_free(struct conn *conn)  {      char *IP =  conn_rsp_timer_fn(arg);      printk("Client IP %s",IP);        .............................  }

随便定义一个全局变量就可以解决这个问题？你有什么困难吗啡

找个test.h 头文件定义全局变量  extern char name[];  test.c 头部定义 char name;  OK了。。可以在任意函数里调用这个定义的值的，     sprintf(name,"取到名：%s",conn->session->initiator_name);   收工

有没有类于shell 这样的可以定义全局变量这样更新比如在代码顶部：  定义: char *name[];  这样name 这个就可供所有函数里调用的值 谢谢

conn_rsp_timer_fn(unsigned long arg , char *name)  编译报错char*name

可以给conn_rsp_timer_fn函数增加一个char * 形参，作为一个输出参数，然后在conn_free 中也增加一个char *形参，作为输入参数来调用，简单示例如下： conn_rsp_timer_fn(unsigned long arg , char *name)  ... conn_free(struct conn *conn ,char *ip) ...  使用时： char name[200]  = {0};  conn_rsp_timer_fn(xx ,name); conn_free(xx ,name);


Question: solaris socket write broken pipe

没有定义。查一下这个宏所在的头文件，加上应该可以了。


Question: connect阻塞问题

如果该程序只有一个主线称的话，当然会没反应，程序阻塞在connect,你通过IP和port去登录程序，程序已经没去鸟这个连接。试试多线程

如果是单独创建一个线程去connect就不会有这问题，怀疑是主线程去connect，此时消息阻塞，肯定没反应了。

你发出connect的代码是C代码还是php代码？ 管理界面是用什么框架/服务器的？ 有多少是开源的，有多少是你不方便透露的？  目前根本猜不出你的程序究竟在干什么。

服务器绑定了ip和端口，允许连接之后客户端才能反问。


Question: 请问这个C程序那里出错了？

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。

请判断scanf的返回值。

gcc报错，我也不懂expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘<’ token

用VC6.0 我也沒出現問題喔 #define ms 60 建議最好改成 #define MS 60

引用 2 楼 u010019464 的回复:我用的是dev c++编译器，操作系统是win8的 报什么错？有什么提示？ 我win8 dev c++没问题

我用的是dev c++编译器，操作系统是win8的

没看出来有什么错呀？楼主遇到什么问题？ 可以考虑在printf的时候加一个换行：   "秒数=%d\n"


Question: c简单隐藏字符串到文件中出错，求高手解决

我刚解决就贴上去了，没看到你的回复。

引用 2 楼 Idle_ 的回复:你hide_info时将原始信息都破坏了还打算怎么还原？  0xfe & fgetc(ofp)，获取的原始信息最低bit被清空了，比如这么做了之后'a'和'b'是一样的值 你好，这个没动原始文件的信息，就像i+1并没有更改i的值，i=i+1,才更改了i的值。 我就是想简单将字符串和bmp组合成一个新的bmp文件，然后从新bmp文件提取隐藏信息。 你说的没错，就是最低位清零，bmp位图数据最低位不重要，是0是1几乎没影响，所以将字符串的bit从 高到低依次存到bmp位图数据字节的最低位。

搞到底，还是自己来。 第12行，fputc((0xfe & fgetc(ofp)) + (*p & 0x80 ? 1 : 0), nfp); 我要的是高位的1或0，不是128或0 第37行，ch += (fgetc(fp) & 0x01); 这个把我坑了，运算符优先级要注意，一直以为不管怎样最后算加法的， 第18行增加for(i = 0; i < 8; ++i) fputc(fgetc(ofp) & 0xfe, nfp); 就是用来判断字符串结束的null 第36、37行的循环稍微改一下 for(i = 0; i < 8; ++i){         ch <<= 1; 	ch += (fgetc(fp) & 0x01);	 } 满足条件后，不让ch后移，之前没注意  嗯，大体逻辑没错，就是细节出错，细节啊 不知道，该怎么处理分数，自己提出的问题，自己解决了，哎。

啊，自己先顶一下


Question: 在程序运行时遇到 Stopped (tty output)

机器终端映射的串口和应用打开的串口不能是同一个

可以参考：http://blog.chinaunix.net/uid-13173049-id-3235553.html


Question: vs调试出现问题，请教各位大牛

谢谢，我的file文件好像找不到，我自己在研究研究...

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

找你代码调用了fopen的地方，检查参数传递错了没有

打错字了，一直出现expression（file != NULL），为什么？

在fopen.c里面的一部分代码 {     REG1 FILE *stream=NULL;     REG2 FILE *retval=NULL;      _VALIDATE_RETURN((file != NULL), EINVAL, NULL);     _VALIDATE_RETURN((mode != NULL), EINVAL, NULL);     _VALIDATE_RETURN((*mode != _T('\0')), EINVAL, NULL);      /* Get a free stream */     /* [NOTE: _getstream() returns a locked stream.] */      if ((stream = _getstream()) == NULL)     {         errno = EMFILE;         return(NULL);     } 一直出现expression（file != NULL），问什么

要么贴代码，要么别问


Question: 字符串中16进制数据转换成字符串

引用 2 楼 zhao4zhong1 的回复:#include <stdio.h> #include <string.h> char str[100] = "EB4D67E8F2FCE45F613144876EF8D1B9"; char bin[50]; int i,v,L; int main() {     L=strlen(str);     for (i=0;i<L/2;i++) {         sscanf(str+i*2,"%2X",&v);         bin[i]=(char)v;         printf("%02X ",(unsigned char)bin[i]);     }     return 0; } //EB 4D 67 E8 F2 FC E4 5F 61 31 44 87 6E F8 D1 B9  作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。 老师，再请教十六进制转换成字符串，怎样，下面写得有哪里不合适吗？  char buf[10]; char bin[50] = {0x,ab,0xbc,0xcd}; char str[100]; len = strlen(bin);  for (i = 0; i < len; i++) {        sprintf(buf,"%s",bin[i]);         strcat(str,buf); }

char bin[50] = {0xab,0xbc,0xcd}; char str[100]; for (i = 0; i < 3; i++) {     sprintf(str+i*2,"%02X",(unsigned char)bin[i]); }

将每一个字符处理成对应16进制的数值，将数值高位和低位做逻辑加运算。示例如下： const char str[]  = "EB4D67E8F2FCE45F613144876EF8D1B9";  const int targLen = sizeof(str)*0.5;  unsigned char _CharTo16Num( const char c ) { 	if( c<65 ) 	{ 		return c-48;//0-9 	} 	else 	{ 		return c-65+10;// 10-15 	} } void _converTest() { 	unsigned char targ[targLen]={};  	for( int i=0,j=0;i< sizeof(str);i+=2,j++) 	{ 		targ[j] = _CharTo16Num( str[i] )<<4|_CharTo16Num(str[i+1] );  		printf("%x\t",targ[j]); 	} 	 }

#include <stdio.h> #include <string.h>   int s2h(const char *s, char *h) {     int i, n;     char *p;      static unsigned char t[256] = {          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,          0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,    /* 0-9 */          0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* A-F */          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,          0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0,    /* a-f */          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0     };      p = h;     n = strlen(s);     if (n % 2) {         h[0] = t[(unsigned char)s[0]];         ++p;         ++s;     }      for (i = 0; i < n; i = i + 2) {         *(p++) = (t[(unsigned char)s[i]] << 4) | t[(unsigned char)s[i + 1]];     }      return (n + 1) / 2; }  int main(int argc, char *argv[]) {     char s[] = "EB4D67E8F2FCE45F613144876EF8D1B9";     char h[1024];     int i, n;      n = s2h(s, h);     for (i = 0; i < n; ++i) {         printf("%02x", (unsigned char)h[i]);     }     printf("\n");      return 0; }

引用 6 楼 user-3 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] #include <stdio.h> #include <string.h> char str[100] = "EB4D67E8F2FCE45F613144876EF8D1B9"; char bin[50]; int i,v,L; int main() {     L=strlen(str);     for (i=0;i<L/2;i++) {         sscanf(str+i*2,"%2X",&v);         bin[i]=(char)v;         printf("%02X ",(unsigned char)bin[i]);     }     return 0; } //EB 4D 67 E8 F2 FC E4 5F 61 31 44 87 6E F8 D1 B9  作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。 从来不用scanf的路过[/quote] 乍看起来c++的cin、cout在输入、输出上比c的scanf、printf简单，不用格式控制符！ 但是不用格式控制符，输入输出恰好是你期望的格式的时候好说；等到输入输出不是你期望的格式的时候，你就会觉得还是用格式控制符更方便、更靠谱。 摒弃cin、cout！ 使用scanf、printf。 试试不用scanf实现和下面程序功能完全一样的功能： #include <stdio.h> char s[]="123 ab 4"; char *p; int v,n,k; void main() {     p=s;     while (1) {         k=sscanf(p,"%d%n",&v,&n);         printf("k,v,n=%d,%d,%d\n",k,v,n);         if (1==k) {             p+=n;         } else if (0==k) {             printf("skip char[%c]\n",p[0]);             p++;         } else {//EOF==k             break;         }     }     printf("End.\n"); } //k,v,n=1,123,3 //k,v,n=0,123,3 //skip char[ ] //k,v,n=0,123,3 //skip char[a] //k,v,n=0,123,3 //skip char[b] //k,v,n=1,4,2 //k,v,n=-1,4,2 //End.

引用 2 楼 zhao4zhong1 的回复:#include <stdio.h> #include <string.h> char str[100] = "EB4D67E8F2FCE45F613144876EF8D1B9"; char bin[50]; int i,v,L; int main() {     L=strlen(str);     for (i=0;i<L/2;i++) {         sscanf(str+i*2,"%2X",&v);         bin[i]=(char)v;         printf("%02X ",(unsigned char)bin[i]);     }     return 0; } //EB 4D 67 E8 F2 FC E4 5F 61 31 44 87 6E F8 D1 B9  作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。 从来不用scanf的路过

多谢各位回复

引用 2 楼 zhao4zhong1 的回复:#include <stdio.h> #include <string.h> char str[100] = "EB4D67E8F2FCE45F613144876EF8D1B9"; char bin[50]; int i,v,L; int main() {     L=strlen(str);     for (i=0;i<L/2;i++) {         sscanf(str+i*2,"%2X",&v);         bin[i]=(char)v;         printf("%02X ",(unsigned char)bin[i]);     }     return 0; } //EB 4D 67 E8 F2 FC E4 5F 61 31 44 87 6E F8 D1 B9  作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。 多谢老师指教


Question: 奇怪的结构体初始化

陣列從0開始喔 樓主

typedef struct{ int a; int b;}ab; ab test[2] = {     [0] = {1,2},     [1] = {3,4}, };  这种语法C89标准不支持，C99支持  引用 1 楼 user-5 的回复:用gcc4.8.2编译通过。 一般写法ab test[2] = {  {1,2},  {3,4},  };  看不出来加上[0]和[1]有多大好处 加上[0]和[1]可以在初始化时改变顺序，如 typedef struct{ int a; int b;}ab; ab test[2] = {     [0] = {1,2},     [1] = {3,4}, }; 等价 typedef struct{ int a; int b;}ab; ab test[2] = {     [1] = {3,4},     [0] = {1,2}, }; 不加， typedef struct{ int a; int b;}ab; ab test[2] = {      {1,2},      {3,4}, }; 显然不等价 typedef struct{ int a; int b;}ab; ab test[2] = {     {3,4},     {1,2}, };

C99中的designated initilization，详情参考我的博客（初始化部分） http://www.cnblogs.com/edward-bian/p/3870683.html

把[1] = {3,4}改成[2] = {3,4} test只有两个元素。改成2溢出了吧。


任何通讯系统，当发送方快速多次发送遇上接收方龟速接收，都会导致通讯卡壳的。

谁能帮忙看下问题啊。。。为啥多次mq_send 和多次的mq_receive之后会失败？

问题没有解决。。。新问题：。多次mq_send 和多次的mq_receive之后会失败，当描述符的路径（("/mq1proces"）改一改又可以使用多次 后失败，这是什么原因呢？  请帮忙解决后再贴上没有问题后的代码。。。

路过帮结帖并接分。

问题已解决。。

另外，自己发现一个问题笔误，childFun里面： mqd_22 == mq_open("/mq1proces" ,O_RDWR);   ==号改为=。 但是问题还是没有解决，同样的执行结果

楼主问题解决之后最好把解决方法给简单的说一下啊，一个问题已解决很是让后来搜到你这个链接的哥们蛋疼不已的

还不能结贴。。。。还是有问题。。。多次mq_send 和多次的mq_receive之后会失败，当描述符的路径（("/mq1proces"）改一改又可以使用多次 后失败，这是什么原因呢？


Question: 有趣的汇编程序

建议楼主移驾汇编论坛。

纯DOS下试试这个？ CODE   SEGMENT     'CODE'        ASSUME     CS:CODE, DS:CODE, ES:CODE, SS:CODE EndFlag    DB      0 Int9Enter  PROC   FAR 	STI 	PUSH	BP 	PUSH	AX 	PUSH	BX 	PUSH	CX 	PUSH	DX 	PUSH	SI 	PUSH	DI 	PUSH	DS 	PUSH	ES 	PUSH	CS 	POP	ES 	CLD         MOV	AX,	0F000h         MOV	DS,	AX         MOV	SI,	0FFFEH         CMP	BYTE PTR [SI], 0FCH	;PC/AT? 	PUSH	CS 	POP	DS         JNZ	$PCXT1         MOV	CS:BYTE PTR PCAT,  01         MOV	AL,	0ADH                       ;Select 8042 for Scan-Code         CALL SetKey         CLI	         XOR	CX,	CX     $J1:         IN	AL,	64H                       ;Test 8042 Ready?         LOOPNZ   $J1         IN	AL,	60H 		;Get  Scan-Code         STI	         CMP	AL,	0FEH         JZ	$J2		     	;Jmp To Control Char         CMP	AL,	0FAH         JNZ	$J3 $J2:	JMP	$Exit1 ;    $PCXT1: 	IN	AL,60H		;Get PC/XT Scan-Code     $J3: 	;D7=0  - Down    1  - Up 	CMP	AL,1	;[ESC] KEY 	JZ	$End 	CALL	ShowCode 	CALL	Music 	JMP	$Exit1 $End:	MOV	BYTE PTR CS:EndFlag,-1	 ;    $Exit1: 	CALL	AllowKey 	POP	ES 	POP	DS 	POP	DI 	POP	SI 	POP	DX 	POP	CX 	POP	BX 	POP	AX 	POP	BP 	CLI 	IRET ; PCAT	  DB	0		;0 - PC/XT   1 - PC/AT HEX    DB '0123456789ABCDEF' Int9Enter ENDP ; ; SetKey  PROC	NEAR 	PUSH	AX 	CLI	 	SUB	CX,	CX   $SET: 	IN	AL,	64H 	TEST	AL,	02 	LOOPNZ	$SET 	POP	AX 	OUT	64H,	AL 	STI	 	RET	 SetKey   ENDP ; ; AllowKey PROC	NEAR 	CLI	 	MOV	AL,	20H 	OUT	20H,	AL 	CMP	CS:BYTE PTR PCAT,00 	JZ	$PCXT2 	MOV	AL,	0AEH 	CALL	SetKey 	RET ;    $PCXT2: 	IN	AL,	61H 	MOV	AH,	AL 	OR	AL,	80H 	OUT	61H,	AL 	XCHG	AH,	AL 	OUT	61H,	AL 	RET AllowKey ENDP ; ShowCode	PROC 	PUSH	AX 	PUSH	AX 	MOV	CL,4 	SHR	AL,CL 	XOR	BH,BH 	MOV	BL,AL 	MOV	AL,CS:HEX[BX] 	MOV	AH,0EH 	INT	10H 	POP	AX 	AND	AL,0FH 	XOR	BH,BH 	MOV	BL,AL 	MOV	AL,CS:HEX[BX] 	MOV	AH,0EH 	INT	10H 	MOV	AX,0E08H 	INT	10H 	MOV	AX,0E08H 	INT	10H 	POP	AX 	RET ShowCode	ENDP ; Music	PROC	NEAR 	XOR	AH,AH 	CMP	AL,_AL 	JNE	$NEW 	JMP	Loc_84 $NEW:	MOV	_AL,AL 	TEST	AL,80H 	JNZ	$Up 	CALL	KeyPush 	MOV	BX,AX 	MOV	KeyDownTbl[BX],-1 ; $Down:	SHL	AX,1 	MOV	BX,AX 	MOV	AX,OFFSET CS:ToneTbl 	ADD	BX,AX 	MOV	CX,OFFSET CS:ToneTbl 	CMP	BX,CX 	JGE	Loc_79 Loc_78: 	MOV	BX,TblLen-2 	ADD	BX,AX 	JMP	Loc_80 Loc_79: 	MOV	CX,TblLen-4 	ADD	CX,AX 	CMP	BX,CX 	JG	Loc_78 Loc_80: 	MOV	AL,0B6H 	OUT	43H,AL		; port 43H, 8253 wrt timr mode 	MOV	AX,2870H 	MOV	DX,12H 	DIV	WORD PTR CS:[BX] 	OUT	42H,AL		; port 42H, 8253 timer 2 spkr 	MOV	AL,AH 	OUT	42H,AL		; port 42H, 8253 timer 2 spkr 	IN	AL,61H		; port 61H, 8255 port B, read 	OR	AL,3 	OUT	61H,AL		; port 61H, 8255 B - spkr, etc 	JMP	Loc_84 ; $Up:	AND	AL,7FH 	MOV	BX,AX 	MOV	KeyDownTbl[BX],0 Loc_81:	CALL	KeyPop 	CMP	SI,OFFSET KeyStack-1 	JE	$Off 	MOV	BX,AX 	CMP	KeyDownTbl[BX],0 	JE	Loc_81 	CALL	KeyPush 	JMP	$Down $Off:	INC	KeySP 	IN	AL,61H		; port 61H, 8255 port B, read 	AND	AL,0FCH 	OUT	61H,AL		; port 61H, 8255 B - spkr, etc Loc_84: 	MOV	CX,8 LocLoop_85: 	LOOP	LocLoop_85 	RET ; ToneTbl	DB	42H, 0, 45H, 0, 4AH, 0 	DB	4EH, 0, 53H, 0, 57H, 0 	DB	5DH, 0, 62H, 0, 68H, 0 	DB	6EH, 0, 75H, 0, 7CH, 0 	DB	83H, 0, 8BH, 0, 93H, 0 	DB	9EH, 0, 0A5H, 0, 0AFH, 0 	DB	0B9H, 0, 0C4H, 0, 0D0H, 0 	DB	0DCH, 0, 0E9H, 0, 0F7H, 0 	DB	6, 1, 16H, 1, 26H, 1 	DB	38H, 1, 4AH, 1, 5EH, 1 	DB	73H, 1, 88H, 1, 9FH, 1 	DB	0B8H, 1, 0D2H, 1, 0EEH, 1 	DB	0BH, 2, 2AH, 2, 4BH, 2 	DB	6EH, 2, 93H, 2, 0BAH, 2 	DB	0E4H, 2, 10H, 3, 3EH, 3 	DB	70H, 3, 0A5H, 3, 0DCH, 3 	DB	18H, 4, 56H, 4, 98H, 4 	DB	0F0H, 4, 28H, 5, 76H, 5 	DB	0CAH, 5, 22H, 6, 80H, 6 	DB	0E3H, 6, 4BH, 7, 0BAH, 7 TblLen	EQU	$-ToneTbl KeyDownTbl	DB	80H DUP(0) KeyStack	DB 100 DUP(?) KeySP	DW	KeyStack _AL	DB	0 Music	ENDP ; KeyPush	PROC 	MOV	SI,KeySP 	MOV	BYTE PTR [SI],AL 	INC	SI 	MOV	KeySP,SI 	RET KeyPush	ENDP KeyPop	PROC 	MOV	SI,KeySP 	DEC	SI 	MOV	AL,BYTE PTR [SI] 	MOV	KeySP,SI 	RET KeyPop	ENDP ; ; START	PROC 	PUSH	CS 	POP	DS 	MOV	AX,3509H 	INT	21H 	MOV	AX,ES 	MOV	WORD PTR OldInt9+2,AX 	MOV	WORD PTR OldInt9,BX 	MOV	AX,2509H 	MOV	DX,OFFSET Int9Enter 	INT	21H ; WaitINT9: 	CMP	BYTE PTR CS:EndFlag,0 	NOP 	JZ	WaitINT9 ; Quit:	MOV	DX,WORD PTR OldInt9 	MOV	AX,WORD PTR OldInt9+2 	MOV	DS,AX 	MOV	AX,2509H 	INT	21H 	MOV	AX,4C00H 	INT	21H OldInt9	DD	? START	ENDP ; CODE	ENDS 	END	START

之前看有人用汇编写过贪食蛇，你可以试一下

自己写个程序，运行，反汇编

恩恩，谢谢赵4老师


Question: PAT题目总，不知哪里错了，百思不解！！！！！！！

我粘贴这段的时候从来不看楼主问的是啥问题。

引用 6 楼 zhao4zhong1 的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。 呵呵，说起来一套一套的，跟政府官员一样。 PAT这种题库，错了不知道哪里错的，看不见输入数据，不知道正确答案。这跟调试，看日志有什么关系？ 就你这还骗了那么多积分，都是复制粘贴的吗？

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

按二楼的改了以后再  引用 8 楼 u012421456 的回复:定义的是long，输入的时候用%ld试试

定义的是long，输入的时候用%ld试试

题目对时间，内存有没有要求？将函数内的变量全部移出 函数外，改用全局变量。

引用 4 楼 user-5 的回复:实在看不出来还有哪错了。我自己写了一个作为参考吧 #include<stdio.h>  int main() {   int n, i, result = -1;   long a, x;   scanf("%d %ld", &n, &x);   for (i = 0; i < n; i++) {     scanf("%ld", &a);     if (result < 0 && a == x) {       result = i;     }   }   if (result >= 0) {     printf("%d\n", result);   } else {     printf("Not Found\n");   }   return 0; }  谢谢！ 虽然编译还是部分错误，还是感谢你的帮助！

引用 1 楼 user-5 的回复:1. 编译器支持可变长数组吗？把a[n]改成a[30]试试 2. 只处理一组数据就行吗？ 3. 对long int用%d可能会有问题  %ld j+1 这些在修改后 编译器提示有部分错误 0 答案错误 1 256 0/4  1 答案正确 1 256 1/1  2 答案错误 1 256 0/2  3 答案正确 1 256 1/1  4 答案错误 1 256 0/2

printf("%d",j+1);  // 这里错了，应该是 printf("%d",j); 输出X的位置（从0开始数）


Question: linux fcntl

GDB 单步跟踪一下

引用 3 楼 misskissC 的回复:之所以整个大方向，是因为我也没用过这个函数，也不会。  linux 终端下，输入命令：man  fcntl  【Read it, practice it】  FCNTL(2)                                                     Linux Programmer's Manual                                                    FCNTL(2)    NAME        fcntl - manipulate file descriptor  SYNOPSIS        #include <unistd.h>        #include <fcntl.h>         int fcntl(int fd, int cmd, ... /* arg */ );  DESCRIPTION        fcntl() performs one of the operations described below on the open file descriptor fd.  The operation is determined by cmd.         fcntl() can take an optional third argument.  Whether or not this argument is required is determined by cmd.  The required argument type is        indicated in parentheses after each cmd name (in most cases, the required type is int, and we identify the argument using the name arg), or        void is specified if the argument is not required.     Duplicating a file descriptor        F_DUPFD (int)               Find the lowest numbered available file descriptor greater than or equal to arg and make it be a copy of fd.  This is different from               dup2(2), which uses exactly the descriptor specified.                On success, the new descriptor is returned.                See dup(2) for further details.     ........ 在文件加锁之后，用鼠标点击文件所在的目录，内核也会报事件，向拥锁进程发信号，在fcntl中使用DNOTIFY控制不了，为啥，大神们，求救啊～～～～～～～～～～～～～～～

引用 1 楼 misskissC 的回复:man fcntl  能说的详细下吗？我只想在我双击打开文件的时候获得内核发送的消息，但是fcntl中的锁会响应双击文件夹（该文件所在的文件夹），设置参数屏蔽也没有效果，不知道怎么做？请再指点一下阿，多谢！！！

man fcntl


Question: 求大神，

Enter、Ctrl+Z、Enter

引用 7 楼 zhao4zhong1 的回复:Enter、Ctrl+Z、Enter 已经知道了，不过同样谢谢你。

windows里面Ctrl+Z

引用 1 楼 user-3 的回复:windows里面Ctrl+Z linux里面Ctrl+D 为什么我试了不行呢。按下ctrl+z只是输入^z、、、

引用 4 楼 user-3 的回复:[quote=引用 3 楼 CYTCHAN 的回复:] [quote=引用 1 楼 user-3 的回复:] windows里面Ctrl+Z linux里面Ctrl+D 为什么我试了不行呢。按下ctrl+z只是输入^z、、、[/quote] 我在windows试了一下，好像ctrl+z之前之后都要按回车才行[/quote] 我试了下，怎么不行啊

引用 3 楼 CYTCHAN 的回复:[quote=引用 1 楼 user-3 的回复:] windows里面Ctrl+Z linux里面Ctrl+D 为什么我试了不行呢。按下ctrl+z只是输入^z、、、[/quote] 我在windows试了一下，好像ctrl+z之前之后都要按回车才行

引用 楼主 CYTCHAN 的回复:书中“如果输入中不包含字符”，如何理解？在我看来，我们输入的不都属于字符吗，难道还有输入不是字符的？ 我觉得他的意思是，不输入abc之类的字符，一上来直接就Ctrl+Z给你个EOF，这样就进不去这个while循环了。

windows里面Ctrl+Z linux里面Ctrl+D


Question: C语言中主函数中相关问题？？？

引用 楼主 pingheng74 的回复:主函数中：分别输入的   scanf("%d",&b[i])与scanf("%d",&mp[i][j])在主函数中什么作用？在整个代码中又是什么作用呢？ 请大侠帮小弟解释一下呗。谢谢了！！！ 就是让你从键盘先输入n个整数，给b[0]到b[n-1]赋值；然后再输入n*n个整数，给mp[0][0]到mp[n-1][n-1]赋值。 楼主问的是这个吗？


Question: 一道网络选择题

同觉选D！！！

现在题目越来越变态了。。。

引用 1 楼 MisteryMethod 的回复:TTL 归零时才应该丢弃，只有转发时减少TTL 才需要丢弃掉报文，为1的时候如果是到本机的报文应该是没问题的，例如ping 路由器时采用TTL = 1时是可以得到回的response的。选D？

引用 1 楼 MisteryMethod 的回复:TTL 归零时才应该丢弃，只有转发时减少TTL 才需要丢弃掉报文，为1的时候如果是到本机的报文应该是没问题的，例如ping 路由器时采用TTL = 1时是可以得到回的response的。  分析的有理

TTL  Time to live 就是生命周期，BC 都一定不对，A 的话可以说对，可以说不对，如果是需要转发的报文，那应该是会被丢弃掉的。


Question: 求解:输出1/2013的结果,要求精确到小数后30位

引用 7 楼 Fung3zZ 的回复:[quote=引用 6 楼 zjq9931 的回复:] 如果不暂存，实时输出，那么想多少位都是可以的。int a = 1; int b = 2013; int i = 0; for (i = 0; i < 2013; i++) { 	printf("%d", a/b); 	a = a%2013*10; } 看到的这个代码, 下面那个a = a%2013*10 是怎么回事, 能再给我解释下吗[/quote] 和上面我写的是一个思路，这个更专业话，我那个更好懂，你可以不断的缩减我那个程序。就可以得到这个了。

引用 6 楼 zjq9931 的回复:如果不暂存，实时输出，那么想多少位都是可以的。int a = 1; int b = 2013; int i = 0; for (i = 0; i < 2013; i++) { 	printf("%d", a/b); 	a = a%2013*10; } 看到的这个代码, 下面那个a = a%2013*10 是怎么回事, 能再给我解释下吗

如果不暂存，实时输出，那么想多少位都是可以的。

引用 4 楼 zjq9931 的回复:晕了，没有验证，刚才的代码有错误，改好了。  #include<stdio.h>  int main() { 	int a=1; 	int b=2013; 	int result[100]; 	int i; 	int iNum; 	for(i=0; i<100; i++) 	{ 		if(a==0) 		{ 			break; 		} 		if(a<b) 		{ 			a*=10; 			if(a<b) 			{ 				result[i]=0; 			} 			else 			{ 				i--; 			} 			continue; 		} 		else 		{ 			result[i]=a/b; 			a=a%b; 		} 	} 	iNum = i;  	printf("0."); 	for(i=0; i<iNum; i++) 	{ 		printf("%d", result[i]); 	} 	printf("\n%d 位\n", i); 	return 0; }  引用 4 楼 zjq9931 的回复:晕了，没有验证，刚才的代码有错误，改好了。  #include<stdio.h>  int main() { 	int a=1; 	int b=2013; 	int result[100]; 	int i; 	int iNum; 	for(i=0; i<100; i++) 	{ 		if(a==0) 		{ 			break; 		} 		if(a<b) 		{ 			a*=10; 			if(a<b) 			{ 				result[i]=0; 			} 			else 			{ 				i--; 			} 			continue; 		} 		else 		{ 			result[i]=a/b; 			a=a%b; 		} 	} 	iNum = i;  	printf("0."); 	for(i=0; i<iNum; i++) 	{ 		printf("%d", result[i]); 	} 	printf("\n%d 位\n", i); 	return 0; } 懂了, 谢谢大哥了

代码写下了，原理你可明白？  #include<stdio.h>  int main() { 	int a=1; 	int b=2013; 	int result[100]; 	int i; 	int iNum; 	for(i=0; i<100; i++) 	{ 		if(a==0) 		{ 			break; 		} 		if(a<b) 		{ 			a*=10; 			result[i]=0; 			continue; 		} 		else 		{ 			result[i]=a/b; 			a=a%b; 		} 	} 	iNum = i;  	for(i=0; i<iNum; i++) 	{ 		printf("%d", result[i]); 		if(i==0 && result[i]==0) 		{ 			printf("."); 		} 	} 	printf("\n%d 位\n", i); 	return 0; }

使用bc计算器

你可以自己实现除法


Question: 望指教，是什么问题，谢谢

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

@zjq9931 BNode *t; t = CreateB(t); 和 BNode t; CreateB(&t); 区别是什么？

#include <stdio.h> #include <conio.h> #include <stdlib.h>  #define OK 1 #define ERROR 0 #ifndef NULL #define NULL 0 #endif  typedef struct BNode{ 	char c; 	struct BNode *lchild, *rchild; } BNode;  BNode* CreateB(BNode *t) { 	char ch; 	scanf("%c", &ch); 	if(' ' == ch)  	{ 		t = NULL; 	} 	else{ 		t = (BNode *)malloc(sizeof(BNode)); 		if(NULL == t) 			exit(0); 		t->c = ch; 		t->lchild = CreateB(t->lchild);; 		t->rchild = CreateB(t->rchild);		 	} 	return t; }  int VisitB(BNode *t, void(*visit)(char c)) { 	if(t != NULL) 	{ 		visit(t->c); 		VisitB(t->lchild, visit); 		VisitB(t->rchild, visit); 	} 	return OK; }  void Visit(char c) {  	printf("%-2c", c);  }  int main(void) { 	BNode *t; 	t = CreateB(t); 	//printf("%d\n",CreateB(t)); 	VisitB(t, Visit); 	getch(); 	return 0; }


Question: c语言如何清除浏览器缓存？急

这个不知，但是查查相关的API看看？


Question: 关于结构体里面指针的指针（续）

unsigned char **rgba; 主要是因为要把图像的RGBA各个通道的数据分开存储在4个内存空间里。 LZ想怎么存读到的像素数据？用 unsigned char *pixels;也可以， 只用一段连续的内存存储整张图片的像素数据。

其实你可以参考libpng给的示例程序代码，然后在它的基础上做修改，改成适合你的。

好眼熟的代码，貌似这是我很久以前整的代码。。。

发烧，大脑有些，不够用，单步跟踪。应当那个可以跟出来吧？

顶顶等高手帮忙解决