Question: C读取.mat数据程序出现链接错误，跪求解决！！！

分享个链接吧，我是按照这个帖子上的方法配置的 http://www.jb51.net/article/34727.htm

已经解决了，还是有些配置没有搞定

不要做A语言代码修改为B语言代码的无用功。 也不要做用A语言代码直接调用B语言代码库这样复杂、这样容易出错的傻事。 只需让A、B语言代码的输入输出重定向到文本文件，或修改A、B语言代码让其通过文本文件输入输出。 即可很方便地让A、B两种语言之间协调工作。 比如： A将请求数据写到文件a.txt，写完后改名为aa.txt B发现aa.txt存在时，读取其内容，调用相应功能，将结果写到文件b.txt，写完后删除aa.txt，改名为bb.txt A发现bb.txt存在时，读取其内容，读完后删除bb.txt 以上A可以替换为任何一种开发语言或开发环境，B可以替换为任何一种与A不同的开发语言或开发环境。 除非A或B不支持判断文件是否存在、文件读写和文件更名。 但是谁又能举出不支持判断文件是否存在、文件读写和文件更名的开发语言或开发环境呢？  共享临时文本文件这种进程之间的通讯方法相比其它方法的优点有很多，下面仅列出我现在能想到的： ·进程之间松耦合 ·进程可在同一台机器上，也可跨机，跨操作系统，跨硬件平台，甚至跨国。 ·方便调试和监视，只需让第三方或人工查看该临时文本文件即可。 ·方便在线开关服务，只需删除或创建该临时文本文件即可。 ·方便实现分布式和负载均衡。 ·方便队列化提供服务，而且几乎不可能发生队列满的情况（除非硬盘空间满） ·……

包含这几个函数的声明的头文件呢， 是不是声明有问题，不是c调用规则?


Question: 和同学打赌该语法是否有歧义，但是没编译器试，特来寻求答案。

vs2012的结果 也是1和0 我勒个去 的确不同编译器不同实现 而且重载++还是得到可能错误的结果

明天在vs上试试 感觉被骗了

n=0; s=n++ + n++ ; tcc结果s=1 gcc和g++结果都是s=0 这结果真出乎我意料！！！ 本来认为c++的结果一定是1的 比如，你完成了一个CInt类 #include <iostream> using namespace std ;  class CInt { private :   int i ; public :   CInt () {   }   CInt (int i) {     this->i = i ;   }   CInt operator++ (int) {     int t = i++ ;     return CInt (t) ;   }   friend CInt operator+ (CInt a ,CInt b) {     int t = a.i + b.i ;     return CInt (t) ;   }   friend inline ostream &operator<< (ostream &os ,CInt &a) {     return os << a.i ;   } } ;  int main () {   CInt a = 0 ;   CInt b = a++ + a++ ;   int c = 0 ;   int d = c++ + c++ ;   cout << b << endl ;   cout << d << endl ;   return 0 ; } 输出是1和0！！！ 这意味着重载++将是很不安全的！！！

即便结果是确定的，出这种题的人也是傻逼

不写这种代码 也不研究它

古往今来都不缺孔乙己式的学究。

C99语法归约过程  #include <stdio.h>  int main(void) { 	s3=a++*a+b+c*a*++b/4; }   归约栈   curr[6]: int  next[75]: main   type-specifier  declaration-specifiers   curr[75]: main  next[69]: (   declaration-specifiers direct-declarator   curr[69]: (  next[1]: void    curr[1]: void  next[70]: )   declaration-specifiers direct-declarator ( type-specifier  declaration-specifiers direct-declarator ( declaration-specifiers  declaration-specifiers direct-declarator ( parameter-declaration  declaration-specifiers direct-declarator ( parameter-list  declaration-specifiers direct-declarator ( parameter-type-list   curr[70]: )  next[67]: {   declaration-specifiers direct-declarator  declaration-specifiers declarator   curr[67]: {  next[75]: s3    curr[75]: s3  next[55]: =   declaration-specifiers declarator { primary-expression  declaration-specifiers declarator { postfix-expression  declaration-specifiers declarator { unary-expression   curr[55]: =  next[75]: a   declaration-specifiers declarator { unary-expression assignment-operator   curr[75]: a  next[30]: ++   declaration-specifiers declarator { unary-expression assignment-operator primary-expression  declaration-specifiers declarator { unary-expression assignment-operator postfix-expression   curr[30]: ++  next[35]: *   declaration-specifiers declarator { unary-expression assignment-operator postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator unary-expression  declaration-specifiers declarator { unary-expression assignment-operator cast-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression   curr[35]: *  next[75]: a    curr[75]: a  next[38]: +   declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * primary-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * unary-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * cast-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression   curr[38]: +  next[75]: b    curr[75]: b  next[38]: +   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression   curr[38]: +  next[75]: c    curr[75]: c  next[35]: *   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression   curr[35]: *  next[75]: a    curr[75]: a  next[35]: *   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression   curr[35]: *  next[38]: +    curr[38]: +  next[75]: b   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-operator   curr[75]: b  next[36]: /   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-operator primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-operator postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-operator unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-operator cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression   curr[36]: /  next[76]: 4    curr[76]: 4  next[74]: ;   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression  declaration-specifiers declarator { unary-expression assignment-operator shift-expression  declaration-specifiers declarator { unary-expression assignment-operator relational-expression  declaration-specifiers declarator { unary-expression assignment-operator equality-expression  declaration-specifiers declarator { unary-expression assignment-operator AND-expression  declaration-specifiers declarator { unary-expression assignment-operator exclusive-OR-expression  declaration-specifiers declarator { unary-expression assignment-operator inclusive-OR-expression  declaration-specifiers declarator { unary-expression assignment-operator logical-AND-expression  declaration-specifiers declarator { unary-expression assignment-operator logical-OR-expression  declaration-specifiers declarator { unary-expression assignment-operator conditional-expression  declaration-specifiers declarator { unary-expression assignment-operator assignment-expression  declaration-specifiers declarator { assignment-expression  declaration-specifiers declarator { expression   curr[74]: ;  next[68]: }   declaration-specifiers declarator { expression-statement  declaration-specifiers declarator { statement  declaration-specifiers declarator { block-item  declaration-specifiers declarator { block-item-list   curr[68]: }  next[0]: NULL   declaration-specifiers declarator compound-statement  function-definition  function-definition-list  translation-unit    按照归约顺序求值，绝对正确！

引用 11 楼 starytx 的回复:又是这样的问题，就没有停止的时候。不要写自己无法预料结果的代码问题就在这里  总有一下新人以为 这样的代码结果是可以预料的 ......

又是这样的问题，就没有停止的时候。不要写自己无法预料结果的代码

在一个表达式计算中，存在++/--这样会修改变量本身的值的情况称作副效应(Side effect)，副效应和其他运算符发生的先后顺序是由序列点(Sequence Point)决定的。到达一个序列点时，之前所有的运算和副效应都应该计算完毕，而之后所有的运算和副效应都没有进行计算。（更具体的说明可以看c标准5.1.2.3节） Sequence Point的定义参见c标准的Annex C。只有一个完整的表达式结束才是一个序列点，在一个表达式内部是没有序列点的。因此在这个例子中，后缀++运算修改值本身到底发生在什么时候，属于标准未定义的行为，在不同的编译器中会有不同的实现，也就是或这个表达式的计算结果在不同编译器下会不同。 结论正如LZ期望的那样：出这个题目的人是NC。

看着好纠结啊这个表达式

其实我关注的这个：“但是没有编译器试“。  亲，既然你能在CSDN发帖子，就说明你能上网；  既然你能上网，为什么不能登录一个可以在线编译C++的网站编译运行一下呢？  即使你手头没有这样的网站，下一个gcc貌似也行啊，亲。

用编译器也测试不出正确的结果。

赌什么？多赌点。让你同学把全部身家压上。这赌局你稳赢了。

这种东西研究有何意义？

同的编译器会得到不同的结果 11121

bu同的编译器会得到不同的结果

不同的编译器会得到不同的结果

不同的编译器，结果可能就不同，另，题目中少了基础运算符

修正，上面我的回复，贴错喽这个是对应的   curr[6]: int  next[75]: main   type-specifier  declaration-specifiers   curr[75]: main  next[69]: (   declaration-specifiers direct-declarator   curr[69]: (  next[1]: void    curr[1]: void  next[70]: )   declaration-specifiers direct-declarator ( type-specifier  declaration-specifiers direct-declarator ( declaration-specifiers  declaration-specifiers direct-declarator ( parameter-declaration  declaration-specifiers direct-declarator ( parameter-list  declaration-specifiers direct-declarator ( parameter-type-list   curr[70]: )  next[67]: {   declaration-specifiers direct-declarator  declaration-specifiers declarator   curr[67]: {  next[75]: s3    curr[75]: s3  next[55]: =   declaration-specifiers declarator { primary-expression  declaration-specifiers declarator { postfix-expression  declaration-specifiers declarator { unary-expression   curr[55]: =  next[75]: a   declaration-specifiers declarator { unary-expression assignment-operator   curr[75]: a  next[30]: ++   declaration-specifiers declarator { unary-expression assignment-operator primary-expression  declaration-specifiers declarator { unary-expression assignment-operator postfix-expression   curr[30]: ++  next[35]: *   declaration-specifiers declarator { unary-expression assignment-operator postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator unary-expression  declaration-specifiers declarator { unary-expression assignment-operator cast-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression   curr[35]: *  next[75]: a    curr[75]: a  next[38]: +   declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * primary-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * unary-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression * cast-expression  declaration-specifiers declarator { unary-expression assignment-operator multiplicative-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression   curr[38]: +  next[75]: b    curr[75]: b  next[38]: +   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression   curr[38]: +  next[75]: c    curr[75]: c  next[35]: *   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression   curr[35]: *  next[75]: a    curr[75]: a  next[35]: *   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression   curr[35]: *  next[30]: ++    curr[30]: ++  next[75]: b    curr[75]: b  next[36]: /   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * ++ primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * ++ postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * ++ unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression * cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression   curr[36]: /  next[76]: 4    curr[76]: 4  next[74]: ;   declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / primary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / postfix-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / unary-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression / cast-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression + multiplicative-expression  declaration-specifiers declarator { unary-expression assignment-operator additive-expression  declaration-specifiers declarator { unary-expression assignment-operator shift-expression  declaration-specifiers declarator { unary-expression assignment-operator relational-expression  declaration-specifiers declarator { unary-expression assignment-operator equality-expression  declaration-specifiers declarator { unary-expression assignment-operator AND-expression  declaration-specifiers declarator { unary-expression assignment-operator exclusive-OR-expression  declaration-specifiers declarator { unary-expression assignment-operator inclusive-OR-expression  declaration-specifiers declarator { unary-expression assignment-operator logical-AND-expression  declaration-specifiers declarator { unary-expression assignment-operator logical-OR-expression  declaration-specifiers declarator { unary-expression assignment-operator conditional-expression  declaration-specifiers declarator { unary-expression assignment-operator assignment-expression  declaration-specifiers declarator { assignment-expression  declaration-specifiers declarator { expression   curr[74]: ;  next[68]: }   declaration-specifiers declarator { expression-statement  declaration-specifiers declarator { statement  declaration-specifiers declarator { block-item  declaration-specifiers declarator { block-item-list   curr[68]: }  next[0]: NULL   declaration-specifiers declarator compound-statement  function-definition  function-definition-list  translation-unit


Question: 关于指定密码位数然后根据每位可能的字符来列举出所有组合，求交流求指点

这样的笨方法for,密码有多少位数，就有多少重for，越写越没效率了，求大神指点  #include <stdio.h>  void perm(char*,int,int);  int main() {     char codeArray[] = "0123456789abcdefghijklmnopqrstuvwxyz";     int inputDigits = 0;          printf("键入密码位数：");     scanf("%d",&inputDigits);          perm(codeArray, inputDigits, sizeof(codeArray));          return 0; }  void perm(char* num, int digits,int iMax) {     if (1 == digits) {                  for (int i = 0; i < iMax; i++) {             printf("%c",num[i]);         }              }          if (2 == digits) {         for (int i = 0; i < iMax; i++)             for (int j = 0; j < iMax; j++) {                 printf("%c%c    ",num[i],num[j]);                          }              }           }


Question: 关于windows编程中，字符转化成double问题，求答，谢

WCHAR   对应wtof  TCHAR.H routine     _UNICODE & _MBCS not defined      _MBCS defined      _UNICODE defined   _tstof                          atof                                                            atof                            _wtof   _ttof                            atof                                                             atof                           _wtof

转为char[] 然后 atof

宽字符可以用wcstod / wcstof。使用这些函数时，请确保正确设置了code page

要先把 宽字符 转换为一般的char， 才可以用atof


Question: 套接字创建错误求解

如果你要用 SOCK_RAW，就必须有 root 权限。  如果你要在普通用户权限下运行，需要 以 root 身份执行：  chmod 4755 program ,给 程序增加一个 s 属性.

使用超级管理员运行 $su password

权限不够，个人认为如果是学习的话，还是使用root权限……

sudo ??


Question: 求用C语言在VC++6.0环境下编一段低级钩子DLL程序屏蔽Alt键

引用 1 楼 crow6313077 的回复:我觉得你原来写的钩子中没有处理win键和菜单键的相关处理吧？ 在MSDN中简单查了以下Virtual-Key中有VK_RWIN等。对于如何向notepad中输入文字，查看一下相关的API吧，在获取到Alt的消息时，不直接return true，先使用API在Notepad中输入a。这样就行了吧。 楼主加油。 你说的”相关处理“，是不是指”打一个“a”？ 我是在编一个汉字输入法的程序。要用到这4个键位。原来的程序非常复杂有2000行左右。我在1楼提到的那段程序是一个简化程序，只要求屏蔽右边的Alt、CTRL、win键和菜单键，左边的不屏蔽。那个问题只要求屏蔽，不要求打一个“a”。 因为打一个“a”的问题比较容易实现。我的输入法程序中是打出一个汉字的。但问题在于：打出汉字之后仍然要跳出菜单。这个“跳出菜单”的功能我无法屏蔽掉。 我的输入法程序，往notepad.exe窗口里打字比较复杂。看到你说可以“使用API在Notepad中输入a”，很高兴，不知具体如何操作？能给出教材或资料的链接吗？

楼上的根据啥说我”原来写的钩子中没有处理win键和菜单键的相关处理“？ 我不是用wParam提供的虚拟键码来判断win键和菜单键的，是用lParam的第24位是否=1来判断是否扩展键的。所谓扩展键就是空格键右边的4个键位：Alt、CTRL、win键和菜单键。空格的左边也有Alt、CTRL、win键，但是它们的lParam的第24位=0。 你所说的”相关的API“是哪些？具体如何找？如何”使用API在Notepad中输入a“？


Question: linux调整分区大小

你干嘛不去刻录张光碟呢，我当时装环境的时候一直是装了卸，卸了装的 直到后来我用了虚拟机 fdisk正常用没问题的

引用 1 楼 Richardicy 的回复:百度下fdisk命令修改主分区会不会破坏操作系统啊,开不了机就跪了,我没有u盘和光碟.

引用 2 楼 user-2 的回复:图形界面有 GParted我安装不了啊

图形界面有 GParted

百度下fdisk命令


Question: C语言谭浩强链表题目求解？

引用 3 楼 u010030181 的回复:少年，不要试图去返回局部变量的地址…… struct student *cha(struct student *head,struct student* p0)里面的相应改下，main函数中改成如下struct student *p0 = (struct student*)malloc(sizeof(struct student)); scanf("%d",&x); p0->number=x; p0->next=NULL; 非常感谢！！

引用 4 楼 I_better 的回复:[quote=引用 1 楼 user-2 的回复:] cha()函数第二个参数实际运行时只是个复本，函数结束时丢失。用指针吧 你是对的[/quote] 非常感谢！！

引用 1 楼 user-2 的回复:cha()函数第二个参数实际运行时只是个复本，函数结束时丢失。用指针吧 你是对的

引用 1 楼 user-2 的回复:cha()函数第二个参数实际运行时只是个复本，函数结束时丢失。用指针吧 不是这个问题哈。。。。就是用的指针。函数结束后，链表的number是正确的。。。

cha()函数第二个参数实际运行时只是个复本，函数结束时丢失。用指针吧


Question: 求C或C++写的求非对称矩阵的特征值特征向量源码

老大哥，最后怎么样了，4年后的我也想找用C++写的求矩阵的代码

zgjx0802@sina.com  matlab的源码可以发下我吗，我可以转成C++的  谢谢了

找了好几天，没有找到一个合适的代码，有高手能帮忙吗？


Question: 多进程，多线程 共享内存通信

解决死锁问题就行了吧

仅供参考//循环向a函数每次发送200个字节长度（这个是固定的）的buffer, //a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理， //在处理的时候每次从新buffer中取两个字节打印 #ifdef WIN32     #pragma warning(disable:4996) #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef WIN32     #include <windows.h>     #include <process.h>     #include <io.h>     #define  MYVOID             void     #define  vsnprintf          _vsnprintf #else     #include <unistd.h>     #include <sys/time.h>     #include <pthread.h>     #define  CRITICAL_SECTION   pthread_mutex_t     #define  MYVOID             void * #endif //Log{ #define MAXLOGSIZE 20000000 #define MAXLINSIZE 16000 #include <time.h> #include <sys/timeb.h> #include <stdarg.h> char logfilename1[]="MyLog1.log"; char logfilename2[]="MyLog2.log"; static char logstr[MAXLINSIZE+1]; char datestr[16]; char timestr[16]; char mss[4]; CRITICAL_SECTION cs_log; FILE *flog; #ifdef WIN32 void Lock(CRITICAL_SECTION *l) {     EnterCriticalSection(l); } void Unlock(CRITICAL_SECTION *l) {     LeaveCriticalSection(l); } void sleep_ms(int ms) {     Sleep(ms); } #else void Lock(CRITICAL_SECTION *l) {     pthread_mutex_lock(l); } void Unlock(CRITICAL_SECTION *l) {     pthread_mutex_unlock(l); } void sleep_ms(int ms) {     usleep(ms*1000); } #endif void LogV(const char *pszFmt,va_list argp) {     struct tm *now;     struct timeb tb;      if (NULL==pszFmt||0==pszFmt[0]) return;     vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);     ftime(&tb);     now=localtime(&tb.time);     sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);     sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );     sprintf(mss,"%03d",tb.millitm);     printf("%s %s.%s %s",datestr,timestr,mss,logstr);     flog=fopen(logfilename1,"a");     if (NULL!=flog) {         fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);         if (ftell(flog)>MAXLOGSIZE) {             fclose(flog);             if (rename(logfilename1,logfilename2)) {                 remove(logfilename2);                 rename(logfilename1,logfilename2);             }         } else {             fclose(flog);         }     } } void Log(const char *pszFmt,...) {     va_list argp;      Lock(&cs_log);     va_start(argp,pszFmt);     LogV(pszFmt,argp);     va_end(argp);     Unlock(&cs_log); } //Log} #define ASIZE    200 #define BSIZE    240 #define CSIZE      2 char Abuf[ASIZE]; char Cbuf[CSIZE]; CRITICAL_SECTION cs_HEX ; CRITICAL_SECTION cs_BBB ; struct FIFO_BUFFER {     int  head;     int  tail;     int  size;     char data[BSIZE]; } BBB; int No_Loop=0; void HexDump(int cn,char *buf,int len) {     int i,j,k;     char binstr[80];      Lock(&cs_HEX);     for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%03d %04x -",cn,i);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             Log("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         Log("%s\n",binstr);     }     Unlock(&cs_HEX); } int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      lent=0;     Lock(cs);     if (fbuf->size>=len) {         lent=len;         if (fbuf->head+lent>BSIZE) {             len1=BSIZE-fbuf->head;             memcpy(buf     ,fbuf->data+fbuf->head,len1);             len2=lent-len1;             memcpy(buf+len1,fbuf->data           ,len2);             fbuf->head=len2;         } else {             memcpy(buf     ,fbuf->data+fbuf->head,lent);             fbuf->head+=lent;         }         fbuf->size-=lent;     }     Unlock(cs);     return lent; } MYVOID thdB(void *pcn) {     char        *recv_buf;     int          recv_nbytes;     int          cn;     int          wc;     int          pb;      cn=(int)pcn;     Log("%03d thdB              thread begin...\n",cn);     while (1) {         sleep_ms(10);         recv_buf=(char *)Cbuf;         recv_nbytes=CSIZE;         wc=0;         while (1) {             pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);             if (pb) {                 Log("%03d recv %d bytes\n",cn,pb);                 HexDump(cn,recv_buf,pb);                 sleep_ms(1);             } else {                 sleep_ms(1000);             }             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {     int lent,len1,len2;      Lock(cs);     lent=len;     if (fbuf->size+lent>BSIZE) {         lent=BSIZE-fbuf->size;     }     if (fbuf->tail+lent>BSIZE) {         len1=BSIZE-fbuf->tail;         memcpy(fbuf->data+fbuf->tail,buf     ,len1);         len2=lent-len1;         memcpy(fbuf->data           ,buf+len1,len2);         fbuf->tail=len2;     } else {         memcpy(fbuf->data+fbuf->tail,buf     ,lent);         fbuf->tail+=lent;     }     fbuf->size+=lent;     Unlock(cs);     return lent; } MYVOID thdA(void *pcn) {     char        *send_buf;     int          send_nbytes;     int          cn;     int          wc;     int           a;     int          pa;      cn=(int)pcn;     Log("%03d thdA              thread begin...\n",cn);     a=0;     while (1) {         sleep_ms(100);         memset(Abuf,a,ASIZE);         a=(a+1)%256;         if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop         send_buf=(char *)Abuf;         send_nbytes=ASIZE;         Log("%03d sending %d bytes\n",cn,send_nbytes);         HexDump(cn,send_buf,send_nbytes);         wc=0;         while (1) {             pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);             Log("%03d sent %d bytes\n",cn,pa);             HexDump(cn,send_buf,pa);             send_buf+=pa;             send_nbytes-=pa;             if (send_nbytes<=0) break;//             sleep_ms(1000);             if (No_Loop) break;//             wc++;             if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);         }         if (No_Loop) break;//     } #ifndef WIN32     pthread_exit(NULL); #endif } int main() { #ifdef WIN32     InitializeCriticalSection(&cs_log);     InitializeCriticalSection(&cs_HEX );     InitializeCriticalSection(&cs_BBB ); #else     pthread_t threads[2];     int threadsN;     int rc;     pthread_mutex_init(&cs_log,NULL);     pthread_mutex_init(&cs_HEX,NULL);     pthread_mutex_init(&cs_BBB,NULL); #endif     Log("Start===========================================================\n");      BBB.head=0;     BBB.tail=0;     BBB.size=0;  #ifdef WIN32     _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);     _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2); #else     threadsN=0;     rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);     rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1); #endif      if (!access("No_Loop",0)) {         remove("No_Loop");         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     while (1) {         sleep_ms(1000);         if (No_Loop) break;//         if (!access("No_Loop",0)) {             No_Loop=1;         }     }     sleep_ms(3000);     Log("End=============================================================\n"); #ifdef WIN32     DeleteCriticalSection(&cs_BBB );     DeleteCriticalSection(&cs_HEX );     DeleteCriticalSection(&cs_log); #else     pthread_mutex_destroy(&cs_BBB);     pthread_mutex_destroy(&cs_HEX);     pthread_mutex_destroy(&cs_log); #endif     return 0; }

只用线程吧，记得加互斥锁。

太长太慢懒得看，线程，进程应只选其一

需求：主进程中往A队列写, 子进程从A队列读并写入B队列，子线程从B队列读！


Question: 怎么在一堆散乱的点中找到一个X轴最大的点？UG二次开发，针对STL模型文件

各位大神帮帮忙啊！

就是说：一个stl格式的人体三维模型，竖直方向为Z轴，侧面投影在XZ平面，如果要找到他的头部X轴最大点，可能是脑门儿上一点或者是鼻尖或者是下巴点，怎么找啊？关键是：构成模型的点云是散乱的，不是一层一层的规律点云。我想是先通过Z轴坐标确定头部位置，然后从Z轴最小坐标开始，Z值每加0.01就遍历所有的点云一次，通过比较找到X轴的最大点。调试的时候找到了X轴最大点，可当我让这个点生成小球的时候却怎么也看不到小球。尝试过调整Z轴每次增加值的精度，还是不行。难道是我生成小球有问题吗？请问各位有什么好方法吗?或者我的逻辑有什么错误？

能说的详细点么？

求代码啊！各位大神帮帮忙！


Question: PCI BIOS中断如何去写PCI中的内容？

谢谢，非常有用！

上网搜 PCI BIOS Specification 中断其实很简单，就那么几个寄存器，设置寄存器、调用中断、读返回值 如果你不知道那些值是啥意思，那可能要先去看 PCI 规范了


Question: 求第七位以水仙花数的时候，运行超时

#include <stdio.h>  int mypow(int a, int ae) //不要用math的pow函数，因为是浮点运算，太慢了 { 	int powret; 	if (a == 0 || a == 1) //对于0和1的情况，没有必要计算 		powret = a; 	else { 		powret = 1; 		while (ae > 0) 		{ 			powret = powret * a; 			ae--; 		} 	}  	return powret; }  int split_and_sum(int i, int e) { 	int ret = 0; 	while (i > 0) { 		ret += mypow(i % 10, e); 		i /= 10; 	}  	return ret; }  int main(void) { 	int N; 	scanf("%d", &N); 	int min = 10, max;  	min = mypow(min, N - 1);//注意，3位数只有2个0 	max = min * 10;  	for (int i = min; i < max; ++i) 	{ 		int sum = split_and_sum(i, N); 		if (sum == i) 			printf("%d\n", i); 	}  	return 0; }

引用 2 楼 u012836877 的回复:[quote=引用 1 楼 user-3 的回复:] http://blog.csdn.net/user-3/article/details/6427287  刚学不久。这个看不太懂[/quote]  #include<stdio.h> int aa(int a,int n) { 	int aaa = 1; 	for (int i=0;i<n;i++) 	{ 		aaa = aaa*a; 	} 	return aaa; } void main() {  	int k = aa(5,0); 	printf("::%d\n",k); 	int n = 0, nn = 0; 	for (int a=1;a<10;a++) 	{ 		for (int b=0;b<10;b++) 		{ 			for (int c=0;c<10;c++) 			{ 				n = aa(a,3)+aa(b,3)+aa(c,3); 				nn = a*100+b*10+c; 				if (n == nn) 				{ 					printf("水仙花数为:%d\n",n); 				} 				for (int d=0;d<10;d++) 				{ 					n = aa(a,4)+aa(b,4)+aa(c,4)+aa(d,4); 					nn = a*1000+b*100+c*10+d; 					if (n == nn) 					{ 						printf("四叶玫瑰数为:%d\n",n); 					} 					for (int e=0;e<10;e++) 					{ 						n = aa(a,5)+aa(b,5)+aa(c,5)+aa(d,5)+aa(e,5); 						nn = a*10000+b*1000+c*100+d*10+e; 						if (n == nn) 						{ 							printf("五角星数为:%d\n",n); 						} 						for (int f=0;f<10;f++) 						{ 							n = aa(a,6)+aa(b,6)+aa(c,6)+aa(d,6)+aa(e,6)+aa(f,6); 							nn = a*100000+b*10000+c*1000+d*100+e*10+f; 							if (n == nn) 							{ 								printf("六合数为:%d\n",n); 							} 							for (int g=0;g<10;g++) 							{ 								n = aa(a,7)+aa(b,7)+aa(c,7)+aa(d,7)+aa(e,7)+aa(f,7)+aa(g,7); 								nn = a*1000000+b*100000+c*10000+d*1000+e*100+f*10+g; 								if (n == nn) 								{ 									printf("北斗七星数为:%d\n",n); 								} 							} 						} 					} 				} 			} 		} 	} }

引用 1 楼 user-3 的回复:http://blog.csdn.net/user-3/article/details/6427287  刚学不久。这个看不太懂


Question: 有没有熟知zstack串口通信的？

来了

问题已经解决了，随便来个人冒个泡，让偶结贴给分吧


Question: 结构体定义中遇到的问题

typedef typedef type-declaration synonym;  The typedef keyword defines a synonym for the specified type-declaration. The identifier in the type-declaration becomes another name for the type, instead of naming an instance of the type. You cannot use the typedef specifier inside a function definition.  A typedef declaration introduces a name that, within its scope, becomes a synonym for the type given by the decl-specifiers portion of the declaration. In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types — they introduce new names for existing types.  Example  // Example of the typedef keyword typedef unsigned long ulong;  ulong ul;     // Equivalent to "unsigned long ul;"  typedef struct mystructtag {    int   i;    float f;    char  c; } mystruct;  mystruct ms;   // Equivalent to "struct mystructtag ms;"  typedef int (*funcptr)();  // funcptr is synonym for "pointer                            //    to function returning int"  funcptr table[10];   // Equivalent to "int (*table[10])();"

typedef struct {   uint16 Addr;  // linked target's short address   uint16 profileID;   uint16 deviceID;   uint8 deviceVersion;   uint8 EP;     // linked target's end-point } zllRemoteLinkedTarget_t; 这是声明了一种结构体类型是吧？类型名是zllRemoteLinkedTarget_t，每一个这种类型的对象呢包括那么一堆东西（Addr, profileID, blablabla）。好了，现在我想再声明一种结构体类型，这个类型的对象是一个数组，每个元素的类型是zllRemoteLinkedTarget_t，所以就 typedef struct {   zllRemoteLinkedTarget_t arr[MAX_LINKED_TARGETS]; } zllRemoteLinkedTargetList_t; 这样喽。 你试着将zllRemoteLinkedTarget_t类比成int，就很好理解了

引用 7 楼 xiaoxiaobaibaicai 的回复:[quote=引用 5 楼 starytx 的回复:] 就是把第一个结构体的一个数组定义为一个新类型zllRemoteLinkedTargetList_t; 那个数组里面的内容是不是zllRemoteLinkedTarget_t结构体里面的各项的值？[/quote]是的。如果你需要多处定义第一个结构体的那种数组，就可以使用第二个那种来定义。比如： zllRemoteLinkedTargetList_t X; X.arr[0].Addr = 123;

引用 5 楼 starytx 的回复:就是把第一个结构体的一个数组定义为一个新类型zllRemoteLinkedTargetList_t; 那个数组里面的内容是不是zllRemoteLinkedTarget_t结构体里面的各项的值？

就是只定义一个数组嘛，可以独立出来

引用 3 楼 luo_miao 的回复:zllRemoteLinkedTargetList_t 起始就是一个 zllRemoteLinkedTarget_t 结构体的数组，有什么不理解的地方？  其实

引用 1 楼 focuslight 的回复:typedef struct {   zllRemoteLinkedTarget_t arr[MAX_LINKED_TARGETS]; } zllRemoteLinkedTargetList_t;  这个没写全， 少指针 这个是ti给的程序，木有问题啊


Question: 见鬼的printf函数！

谢谢各位，问题已经解决了。  我这数据是从串口接收来的，是串口发来的数据格式引起的。（尝试出来的）

没太看明白，是换行输出的原因？

printf ("%s\n", str_GNGGA);

目测楼主只是需要加一个fflush(stdout);

我看不到图啊

你要爬先确定buff中的字符串  是否是只有一组数据？ 把buff 打印出来就知道怎么回事了

还有其他线程在运行吧

msgstr_add 没有'\0'结束符，导致printf越界了？

查下是不是有什么地方内存溢出

没看懂楼主的意思

原本是想执行 strncpy(str_GNGGA,msgstr_add,8); 这一句。 结果printf ("%s", str_GNGGA);就出现上述结果，也就是不是第一个PRINTF语句同步。  才用PRINTF("====")测试。结果同样。  在MAC下，用gcc  main.c -o kk  编译。

printf函数它是把数据先放到输出缓冲区的，当缓冲区满或者是遇到换行符(\n)或者是强制刷新(fflush)才会真正输出到设备上。  引用 楼主 mini_peng 的回复:如图所示，两个printf函数相临紧挨一起； 一个执行，另一个不执行；  图片左边是代码，右边是GCC后执行结果。 第一个printf打印字符串执行完后， 第二个printf("==========Flag==========\n")  居然不是同步有结果输出。呈现有时执行有时不执行的效果。  何故？  (补充一下：花括号的位置和数量，都正确。第二个printf下就是右花括号，else  { } 的)


Question: 求大神帮忙，数据结构中   飞机场起飞降落问题。本人新手，不太懂。多谢啦

好的，多谢！

引用 2 楼 qq_23624255 的回复:是这样的，有代码吗？如果有发我一份可以吗    多谢 没有代码，自己写写看，哪里调试不出来就贴出来。

是这样的，有代码吗？如果有发我一份可以吗    多谢

引用 楼主 qq_23624255 的回复:模拟一个飞机场起飞降落过程。要求只有一条跑道，输出   每条队列的内容，平均起飞等待时间，平均降落等待的时间 把这条跑道想象成一个队列。设定好队列的大小（一共可以存放多少飞机），每个元素出队列需要多长时间（飞机起飞时间），每个元素入队时间（飞机在跑道降落时间），一架飞机飞走了你处理队头指针的时间（待飞的下一架飞机从当前位置运送到起飞点的时间——假如需要的话。） 然后：  每条队列的内容（遍历一下嘛）；平均起飞等待时间（你把队满到队空所花费的时间统计出来/飞机总数）；平均降落等待的时间（你把队空到队慢所花费的时间统计出来/飞机总数）。 我想这样基本可以了。


Question: 求助，链表的删除操作，看不太懂，求教

非常感谢，希望以后多多关注哈

void deletef(slink *head) {     slink *p,*q;     char str[20];     p=head->next;	// 第一个元素     q=head;			// q始终指向目标元素节点的上一个节点     if(head->next==NULL)		// 空链表         printf("链表为空，无元素可删除。\n");     else     {         printf("请输入要删除人的姓名或者学号：\n");         gets(str);		// 取得输入的姓名或学号         while(p!=NULL)         {             if(strcmp(p->name,str)!=0&&strcmp(p->num,str)!=0)	// 姓名和学号都和节点p的信息不匹配             {                 q=p;		// 用q保存节点p                 p=p->next;	// p指向下一个节点，继续循环             }             else			// 找到匹配的节点p了就退出循环                 break;         }     }	         if(p==NULL)		// p为NULL说明找到链表尾了             printf("未找到要删除的结点\n");         else         {             q->next=p->next;		// p上上一个节点q的next下接p的next,从而将p从链表中踢出去了             free(p);			// 释放p分配的空间             printf("删除成功\n");         } }


Question: 求教把一个复杂问题用代码实现的步骤。

谢谢大家的回复，受教了

自顶向下，逐步细化。

具体问题抽象化，复杂问题模块化

很简单，其实是因为问题难度增加了

拿到一个题目，先把题目的意思理解清楚，有了思路在写，不要看一句写一句，有个大致的流程图在心里，当然如果你能先把伪代码写出来再实现那就基本不是问题了……

大家都是这样的.所以程序员在写代码的时候很讨厌别人打扰他.


Question: 编写一个随机点名系统

主要功能已实现，思路就是利用随机函数，交换int数组中的值，已达到“洗牌”效果，然后利用打乱的索引值来访问字符串数组。仅供参考 // 交换两个int值 void change(int *a, int *b) { 	int n = *a; 	*a = *b; 	*b = n; }  #define STUDENT_NUM 7		// 定义学生总数 int main() {  	const char * name[STUDENT_NUM] =  	{ 		"张三", 		"李四", 		"王五", 		"赵六", 		"路人甲", 		"路人乙", 		"无名氏" 	};  	int nIndex[STUDENT_NUM] ={0}; 	srand((UINT)time(0));	// 设置随机种子 	for (int i =0; i != STUDENT_NUM; i++)		 // 初始化索引数组 	{ 		nIndex[i] = i; 	} 	for (int i =0; i != STUDENT_NUM; i++)	// 打乱索引数组中的值 	{ 		change(&(nIndex[i]) , &(nIndex[rand()%STUDENT_NUM])); 	} 	for (int i = 0; i != STUDENT_NUM; i++)		// 打印打乱值的索引对应的字符串 	{ 		printf("%s\n" ,name[nIndex[i]]); 	} 	 	return 0; }

随机必然有重复。 所谓“不重复的随机”实际上是洗牌。 洗牌算法参考下面： #include <stdio.h> #include <stdlib.h> #include <time.h> int d[6]; int i,n,a,b,t; int c,j; void main() {     srand(time(NULL));     printf("shuffle 0..n-1 demo\n");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf("_____n=%d_____\n",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=0;i<n;i++) d[i]=i;/* 填写0～n-1 */             for (i=n;i>0;i--) {/* 打乱0～n-1 */                 a=i-1;b=rand()%i;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf("%04d:",c);             for (i=0;i<n;i++) printf("%d",d[i]);             printf("\n");         }     }     printf("shuffle 1..n demo\n");     for (n=1;n<=5;n++) {/* 测试1～5个元素 */         printf("_____n=%d_____\n",n);         j=1;         for (c=1;c<=n;c++) j=j*c;/* j为n! */         j*=n*2;         for (c=1;c<=j;c++) {/* 测试n*2*n!次 */             for (i=1;i<=n;i++) d[i]=i;/* 填写1～n */             for (i=n;i>1;i--) {/* 打乱1～n */                 a=i;b=rand()%i+1;                 if (a!=b) {t=d[a];d[a]=d[b];d[b]=t;}             }             printf("%04d:",c);             for (i=1;i<=n;i++) printf("%d",d[i]);             printf("\n");         }     } }


Question: C语言的system函数问题

在PATH环境变量里的命令都可以的啊。

总是发现Path环境变量被某些软件安装时错误修改。比如带空格的目录名未加引号、带汉字的目录引起目录查找混乱等问题，严重影响系统查找可执行文件和dll。 编译此源代码，生成PathShortener.exe，然后在cmd窗口里面运行PathShortener.exe>path.txt，打开path.txt，手动将其内容拷贝粘贴覆盖修改‘我的电脑、属性、高级、环境变量、系统变量、Path、编辑、变量值’即可纠正设置错误的Path http://download.csdn.net/detail/zhao4zhong1/2652343

引用 8 楼 zhao4zhong1 的回复:[quote=引用 7 楼 SXJIAKE 的回复:] [quote=引用 6 楼 wyf156470292 的回复:] [quote=引用 3 楼 SXJIAKE 的回复:] 调用命令行内置命令的，不是外部 exe。比如： copy、ren 等由 cmd.exe 原生提供，可以调用。 xcopy、reg 等由位于 system32 中的 xcopy.exe、reg.exe 提供，不能调用。 notepad在system32中也有exe程序呀，不太懂……可以再详细点吗？[/quote] 經測試： system("notepad.exe"); 根本無法執行，打出來： 'notepad.exe' 不是内部或外部命令，也不是可运行的程序或批处理文件。[/quote] 需要提示你path环境变量中没有指向notepad.exe所在目录c:\windows\system32吗？ 需要提示你Linux下没有notepad.exe吗？ 需要提示你可能notepad.exe文件被谁删掉了吗？ 需要吗？ [/quote] 不需要，我如果连这些常识不知道还来这里搞什么？不过原因我找到了，并非不支持，而是我用的编译器的“编译运行”调起来程序就不行，而单独运行或在 cmd 里运行是可以的。不知道这个编译器做了什么操作，使我的环境变量发生了变化。

引用 7 楼 SXJIAKE 的回复:[quote=引用 6 楼 wyf156470292 的回复:] [quote=引用 3 楼 SXJIAKE 的回复:] 调用命令行内置命令的，不是外部 exe。比如： copy、ren 等由 cmd.exe 原生提供，可以调用。 xcopy、reg 等由位于 system32 中的 xcopy.exe、reg.exe 提供，不能调用。 notepad在system32中也有exe程序呀，不太懂……可以再详细点吗？[/quote] 經測試： system("notepad.exe"); 根本無法執行，打出來： 'notepad.exe' 不是内部或外部命令，也不是可运行的程序或批处理文件。[/quote] 需要提示你path环境变量中没有指向notepad.exe所在目录c:\windows\system32吗？ 需要提示你Linux下没有notepad.exe吗？ 需要提示你可能notepad.exe文件被谁删掉了吗？ 需要吗？

引用 6 楼 wyf156470292 的回复:[quote=引用 3 楼 SXJIAKE 的回复:] 调用命令行内置命令的，不是外部 exe。比如： copy、ren 等由 cmd.exe 原生提供，可以调用。 xcopy、reg 等由位于 system32 中的 xcopy.exe、reg.exe 提供，不能调用。 notepad在system32中也有exe程序呀，不太懂……可以再详细点吗？[/quote] 經測試： system("notepad.exe"); 根本無法執行，打出來： 'notepad.exe' 不是内部或外部命令，也不是可运行的程序或批处理文件。

引用 3 楼 SXJIAKE 的回复:调用命令行内置命令的，不是外部 exe。比如： copy、ren 等由 cmd.exe 原生提供，可以调用。 xcopy、reg 等由位于 system32 中的 xcopy.exe、reg.exe 提供，不能调用。 notepad在system32中也有exe程序呀，不太懂……可以再详细点吗？

引用 4 楼 zhao4zhong1 的回复:将要调用的命令写到一个临时批处理文件比如tmp.bat中，然后system之。 敢问大师如何system这个批处理文件

将要调用的命令写到一个临时批处理文件比如tmp.bat中，然后system之。

这个函数支持的函数有限

权限问题，猜测


Question: 用C语言编写一个函数，删除一个字符串的一部分

不就是一个小小的函数吗，大家整那么复杂干啥。看朕的： int del_substr (char * str, char const * substr) {     int cnt = 0;     char * p, * q, * r;     while (q = (char *)substr, * (p = r = str ++) != '\0')         while (* q != '\0' && * p ++ == * q)             if (* ++ q == '\0' && ++ cnt)                 while ((* r ++ = * p ++) != '\0') ;     return cnt; }

仅供参考：（我当初咋没给这四个字申请专利呢？） #include <stdio.h> #include <string.h> #include <locale.h> char s[256]; char *p; int r,n,i; int main() {     setlocale(LC_ALL,"chs");     while (1) {         printf("请输入一行文字(空行结束),\"%%20\"将替换为\" \",\"你懂得\"将替换为\"XXXXXX\":\n");         fgets(s,256,stdin);         if ('\n'==s[0]) break;         p=s;         while (1) {             p=strstr(p,"%20");             if (p) {                 memmove(p+1,p+3,strlen(p)-3+1);                 p[0]=' ';             } else break;         }         p=s;         while (1) {             p=strstr(p,"你懂得");             if (p) {                 memmove(p+6,p+6,strlen(p)-6+1);                 for (i=0;i<6;i++) p[i]='X';             } else break;         }         printf("%s",s);     }     return 0; } //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //abcdefg%20helloworld%20something.pdf //abcdefg helloworld something.pdf //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //这是测试文字你懂得，在这个你懂的地方，就得做你懂得的事 //这是测试文字XXXXX，在这个你懂的地方，就得做XXXXX的事 //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //

#include<stdio.h>  int del_substr(char *str,char const *substr); int index_of_str1(const char *str2,const char *str1); int count_len(const char *str);  //若str1在str2中，返回在str2中的位置，不然返回-1 int index_of_str1(const char *str2,const char *str1) { 	int index=0; 	if( count_len(str1) > count_len(str2) ) 		return -1;  		while(*str2 != '\0') 		{ 			int i = 0; 			if(*str1 == *str2) 			{	 				if( *(str1+1) == '\0') 					return index;  				if(*(str1+1) == *(str2+1) ) 					{ 						str1++,str2++; 						i++; 					} 				else 				{ 					str2++,index++; 				} 					 			} 			else 			{ 				str2++; 				str1-i; 				index++; 				if( count_len(str1) > count_len(str2) ) 				{ 					return -1; 				} 				 			} 				 		} }  int del_substr(char *str, char const *substr) { 	int i; 	int index = index_of_str1(str,substr); 	int str_len=count_len(str); 	int substr_len=count_len(substr);  	if( index >= 0 ) 	{	 		char *pstr=str; 		int num = str_len-substr_len+1;	 		char *newstr = malloc(sizeof(char)*num); 		char *tmp_str=newstr; 		 		for(i=0;i<index;i++) 		{ 			*tmp_str++=*pstr++;  		}  		pstr=pstr+substr_len; 		while(*pstr != '\0') 		{ 			*tmp_str++=*pstr++; 		}  		*(tmp_str)='\0';  		while(*newstr != '\0') 		{ 			*str++=*newstr++; 		} 		 		*str='\0';   		 		return 1; 	}  	return 0; }    //计算字符串的长度 int count_len(const char *str) { 	int len=0; 	while(*str != '\0') 	{ 		len++; 		str++; 	} 	return len; }  int main() { 	char str2[]="dededef"; 	char str1[]="de";  	printf("删除之前：%s\n",str2); 	del_substr(str2,str1); 	printf("删除之后：%s\n",str2); 	return 0; }

当str为dededef，substr为de时，你的程序最后输出str应该为def,结果不对啊 引用 1 楼 user-7 的回复:int Strncmp(const char *cs, const char *ct, unsigned int count) {     unsigned char c1, c2;      while (count)     {         c1 = *cs++;         c2 = *ct++;         if (c1 != c2)             return c1 < c2 ? -1 : 1;         if (!c1)             break;         count--;     }     return 0; }  unsigned int Strlen(const char *s) {     const char *sc;      for (sc = s; *sc != '\0'; ++sc)         /* nothing */;     return sc - s; }  int del_substr(char *str, char const *substr) {     char *start = str;     char *index = str;     int len = Strlen(substr);      while(*index != '\0')     {         if(Strncmp(index, substr, len) == 0)             index += len;         *start++ = *index++;     }     *start = '\0'; } ,自己看看吧

和二楼功能一样，差不多 引用 4 楼 starytx 的回复:仅供参考 // 计算字符串长度 size_t MyStrLen(const char *str) { 	size_t nLen = 0; 	while (*str++) 	{ 		nLen++; 	} 	return nLen; } // 返回src中子串substr开始的字符指针，找不到返回NULL  char * _FindStr( char *src, const char *substr) { 	size_t nSrcLen = MyStrLen( src); 	size_t nSubstrLen = MyStrLen(substr);  	if (nSrcLen < nSubstrLen) 	{ 		return NULL; 	} 	const char *p1 = src; 	char *pBegin = src; 	const char *p2 = substr; 	bool bFlag = false; 	while (*p1 && MyStrLen(p1) >= nSubstrLen && *p2) 	{ 		if (*p1 == *p2) 		{ 			p1++; 			p2++; 			bFlag = true; 		} 		else 		{ 			bFlag = false; 			pBegin++; 			p1 = pBegin; 			p2 = substr; 		} 	}  	if (bFlag) 	{ 		return pBegin; 	} 	return NULL; }  int del_substr( char *str ,const char *substr) { 	if (0 == str || 0 == substr ) 	{ 		return false; 	} 	char *pFind = _FindStr(str,substr); 	bool bFlag = false; 	while (pFind)		// 循环处理，以便删除后续再次出现的子串 	{ 		bFlag = true; 		const char * pRight = pFind + MyStrLen(substr); 		while (*pRight) 		{ 			*pFind++= *pRight++; 		} 		*pFind = 0; 		pFind = _FindStr(str,substr); 	} 	if (bFlag) 	{ 		return 1; 	}  	return 0; }  int main() {  	char str[] = "abcdefgcdet"; 	printf("原串：%s\n" ,str); 	char *substr = "cde"; 	if (del_substr(str,substr)) 	{ 		printf("删除%s后：%s\n",substr,str) ; 	} 	 	return 0; }

家庭作业么。。。。


Question: 小弟我实在是找不出是哪错了，求帮忙

引用 10 楼 michael2988 的回复:[quote=引用 8 楼 changhongyuan 的回复:] [quote=引用 7 楼 xionggch 的回复:] int StrAss(HStr & T) //新建 {     printf("请输入：");     char c;int i=0;     T.ch=(char *)malloc(sizeof(char));   //这里只分配了一个字节的空间     for(i=0;(c=getchar())!='#';i++)     {         T.ch[i]=c;    //要是输入多个字节就会溢出        T.ch = (char*)realloc( sizeof(char) * (i+2) );     }     T.ch[i] = '\0';     T.length=i;     printf("输入的字符为：");     ViewStr(T);     return OK; }   您看看。我已经把malloc开辟的空间调成100了[/quote]  当程序调用getchar时，程序就等着用户按键，用户输入的字符被存放在键盘缓冲区中，直到用户按回车为止（回车字符也放在缓冲区中）。当用户键入回车之后，getchar才开始从stdio流中每次读入一个字符。 所以你的情况是，输入#后，还有一个换行符存在于键盘缓冲区中。      for(i=0;(c=getchar())!='#';i++)     {         T.ch[i]=c;     }     // 消耗掉换行符     int ent = getchar(); [/quote]谢谢您   我明白了。

int StrAss(HStr & T) //新建 {     printf("请输入：");     char c;int i=0;     T.ch=(char *)malloc(sizeof(char));   //这里只分配了一个字节的空间     for(i=0;(c=getchar())!='#';i++)     {         T.ch[i]=c;    //要是输入多个字节就会溢出       }     T.length=i;     printf("输入的字符为：");     ViewStr(T);     return OK; }

引用 8 楼 changhongyuan 的回复:[quote=引用 7 楼 xionggch 的回复:] int StrAss(HStr & T) //新建 {     printf("请输入：");     char c;int i=0;     T.ch=(char *)malloc(sizeof(char));   //这里只分配了一个字节的空间     for(i=0;(c=getchar())!='#';i++)     {         T.ch[i]=c;    //要是输入多个字节就会溢出        T.ch = (char*)realloc( sizeof(char) * (i+2) );     }     T.ch[i] = '\0';     T.length=i;     printf("输入的字符为：");     ViewStr(T);     return OK; }   您看看。我已经把malloc开辟的空间调成100了[/quote]  当程序调用getchar时，程序就等着用户按键，用户输入的字符被存放在键盘缓冲区中，直到用户按回车为止（回车字符也放在缓冲区中）。当用户键入回车之后，getchar才开始从stdio流中每次读入一个字符。 所以你的情况是，输入#后，还有一个换行符存在于键盘缓冲区中。      for(i=0;(c=getchar())!='#';i++)     {         T.ch[i]=c;     }     // 消耗掉换行符     int ent = getchar();

先不说别的，这句好像就有点问题吧 if(a=0) printf("一样大\n");

引用 7 楼 xionggch 的回复:int StrAss(HStr & T) //新建 {     printf("请输入：");     char c;int i=0;     T.ch=(char *)malloc(sizeof(char));   //这里只分配了一个字节的空间     for(i=0;(c=getchar())!='#';i++)     {         T.ch[i]=c;    //要是输入多个字节就会溢出        T.ch = (char*)realloc( sizeof(char) * (i+2) );     }     T.ch[i] = '\0';     T.length=i;     printf("输入的字符为：");     ViewStr(T);     return OK; }   您看看。我已经把malloc开辟的空间调成100了

引用 4 楼 rozniak 的回复:我刚才又看了一下，你的问题是 1.主函数中 a=StrCompare(T).  = 的意思是赋值。 ==才是比较。 2.函数int StrAss有问题。我就是不知道 int StrAss()函数的错在哪  找了半个多小时了  找不到

就是，程序运行提示输入字符，当运行到连接两个串函数时，再输入另一个串，连接完成后显示结果就出问题了

你能说说代码有什么问题吗？我这边可以运行啊？

你首先应该学会怎么提问题


Question: C语言 关于在头文件中定义变量的问题？

一般情况下防止重定义   #ifndef xxx #define  xxx #endif

引用 11 楼 adusuccessfully 的回复:[quote=引用 9 楼 mymtom 的回复:] C语言基本要求 不要在头文件中定义变量或者函数。  楼主为啥要在头文件中定义个a呢，有什么意义呢？  引用 10 楼 xionggch 的回复:a是全局变量，也就是说所有包含头文件"module1.h"中用的变量a是同一个变量a 所以main函数中a=50后，变量a值就变成50了 main函数中的a赋值就将头文件中a的赋值覆盖了  [/quote]我只是实验一下，存在两个副本这个说法是在网上看到的，所以就试一下看看了

是啊，a是全局 然后  初始化的时候给了5  然后执行的时候是先用50覆盖了5,最后加的5     a是整个程序的全局，是共用的

引用 9 楼 mymtom 的回复:C语言基本要求 不要在头文件中定义变量或者函数。  楼主为啥要在头文件中定义个a呢，有什么意义呢？  引用 10 楼 xionggch 的回复:a是全局变量，也就是说所有包含头文件"module1.h"中用的变量a是同一个变量a 所以main函数中a=50后，变量a值就变成50了 main函数中的a赋值就将头文件中a的赋值覆盖了

C语言基本要求 不要在头文件中定义变量或者函数。

这种奇葩编译能通过？？？？是地球人开发的编译器吗？  两个副本？？？谁教你的？拉出来枪毙五百次！

不是说头文件中定义变量，在各个包含了头文件的模块中都对应着不同地址单元么？ ------------------------- 这句话哪里说的？  如果你的h文件没有 防止多次include保护机制， 编译会不通过吧，多重定义。 如果是 头文件有 防止多次include保护机制， 这个头文件不会实际上不会被包含2次的， 所以不存在你说的两个副本。

@nwcfafniw 在vc中有时候能通过，不知道是不是bug，但是正常情况下还是会报重定义的错。

引用 4 楼 haigegee1988 的回复:他们不是两个副本吗？赋值应该不受影响才对啊 首先，千万不要在头文件中定义变量，只能在头文件中声明变量。你这种情况，在linux下就直接报“变量重复定义”的错误了。至于VC我不了解它怎么处理这种情况，但应该不是当成两个副本来处理。

他们不是两个副本吗？赋值应该不受影响才对啊

如果没记错，头文件会在编译的时候链接a等于5。  10或者55 就是取决于 a的附值顺序的问题。 头文件先附值，主函数后。建议不这么用，程序会有歧义

a定义的时候是5 附值后是50 50➕5 55。你可以单步调试看一看

奇怪的是 有时候能编译通过，有时候又不能。。。。


Question: 刚学完C语言的同学有福了，有个视频，教大家怎么从C语言跨入Windows编程的大门

这个要收费，只有第一个视频能免费观看~~~

现在前六节可以免费观看了！

不会吧，我该下。

引用 1 楼 u013163178 的回复:还是跨入linux/unix吧 同

还是跨入linux/unix吧


Question: 数组维数，是常量表达式？

引用 13 楼 mymtom 的回复:[quote=引用 11 楼 q3733353520 的回复:] 跟编译器有关   variable-sized object may not be initialized  变长数组不可在定义的时候初始化 编译器无关，C语言中是不能对变长数组初始化的。[/quote] 其实C++也不允许对变长数组初始化； 再进一步，事实上C++98是不支持变长数组的 (g++支持变长数组，但是可以用g++ -std=c++98 -Wall -pedantic让g++ 对变长数组输出警告) 楼主的程序用C++可以正确编译，其实是由于C++和C对于常量表达式的规定有细微差别。 注意C++里const variables是常量表达式，在C里不是。 所以就楼主的程序来说： 用C编译的话，a[n]是变长数组。 用C++编译的话，a[n]是普通数组。  C99的整型常量表达式    An integral constant expression shall have integral type and shall only have operands that are integer constants, enumeration constants, character constants, sizeof expressions, and floating constants that are the immediate operands of casts.  Cast operators in an integral constant expression shall only convert arithmetic types to integral types, except as part of an operand to the sizeof operator.  C++98的整型常量表达式  1 In several places, C++ requires expressions that evaluate to an integral or enumeration constant: as array bounds (8.3.4, 5.3.4), as case expressions (6.4.2), as bitfield lengths (9.6), as enumerator initializers (7.2), as static member initializers (9.4.2), and as integral or enumeration nontype template arguments (14.3). constantexpression: conditionalexpression An integral constantexpression can involve only literals (2.13), enumerators, const variables or static data members of integral or enumeration types initialized with constant expressions (8.5), nontype template parameters of integral or enumeration types, and sizeof expressions. Floating literals (2.13.3) can appear only if they are cast to integral or enumeration types. Only type conversions to integral or enumeration types can be used. In particular, except in sizeof expressions, functions, class objects, pointers, or references shall not be used, and assignment, increment, decrement, functioncall, or comma operators shall not be used.

引用 11 楼 q3733353520 的回复:跟编译器有关   variable-sized object may not be initialized  变长数组不可在定义的时候初始化 编译器无关，C语言中是不能对变长数组初始化的。

C语言中不能对变长数组初始化 3 The type of the entity to be initialized shall be an array of unknown size or an object type that is not a variable length array type.

数组的大小，在编译的时候必须是确定的，这只跟编译器有关！

这种栈中的要常量，new的可以用变量

#include <stdio.h> #include <stdlib.h> #include <malloc.h> int **newarr2d(int rows,int cols) {     int **p,i;      p=(int **)malloc(rows*sizeof(int *));     if (NULL==p) exit(1);     for (i=0;i<rows;i++) {         p[i]=(int *)malloc(cols*sizeof(int));         if (NULL==p[i]) exit(1);     }     return p; } void deletearr2d(int **p,int rows) {     int i;      for (i=0;i<rows;i++) {         free(p[i]);     }     free(p); } int main() {     int **arr2d,i,j,r,c;      r=4;     c=5;     //在堆中开辟一个4×5的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      r=6;     c=3;     //在堆中开辟一个6×3的二维int数组     arr2d=newarr2d(r,c);     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             arr2d[i][j]=i*c+j;         }     }     for (i=0;i<r;i++) {         for (j=0;j<c;j++) {             printf(" %2d",arr2d[i][j]);         }         printf("\n");     }     deletearr2d(arr2d,r);      return 0; } //  0  1  2  3  4 //  5  6  7  8  9 // 10 11 12 13 14 // 15 16 17 18 19 //  0  1  2 //  3  4  5 //  6  7  8 //  9 10 11 // 12 13 14 // 15 16 17 //

很多才开始编程的人总是想要做变长数组，其实是没考虑到内存分配的问题。所有的程序员其实都要首先考虑数据结构和程序逻辑，数据结构就是说数据如何存储。对于变长的情况，一般可考虑给定一个最大值，总是有上限的吧。看起来是浪费了点内存，其实是节省了CPU和程序员的时间。实在要变长的数据结构，首先考虑的是链表。链表才是动态内存分配的基本结构。不然动态分配了放哪里呢？

引用 15 楼 Daffodiles 的回复:mymtom： 引用注意C++里const variables是常量表达式，在C里不是。 const variables C语言当作什么了？ 举例说明。 下面的程序作为C++编译是正确的。 但是作为C程序编译会报错。  #include <stdio.h> int main() {     int ch;     const int n = 3;      switch (ch) {     case n:         break;     case 1:         break;     default:         break;     }      return 0; }

引用 14 楼 mymtom 的回复:[quote=引用 13 楼 mymtom 的回复:] [quote=引用 11 楼 q3733353520 的回复:] 跟编译器有关   variable-sized object may not be initialized  变长数组不可在定义的时候初始化 编译器无关，C语言中是不能对变长数组初始化的。[/quote] 其实C++也不允许对变长数组初始化； 再进一步，事实上C++98是不支持变长数组的 (g++支持变长数组，但是可以用g++ -std=c++98 -Wall -pedantic让g++ 对变长数组输出警告) 楼主的程序用C++可以正确编译，其实是由于C++和C对于常量表达式的规定有细微差别。 注意C++里const variables是常量表达式，在C里不是。 所以就楼主的程序来说： 用C编译的话，a[n]是变长数组。 用C++编译的话，a[n]是普通数组。  C99的整型常量表达式    An integral constant expression shall have integral type and shall only have operands that are integer constants, enumeration constants, character constants, sizeof expressions, and floating constants that are the immediate operands of casts.  Cast operators in an integral constant expression shall only convert arithmetic types to integral types, except as part of an operand to the sizeof operator.  C++98的整型常量表达式  1 In several places, C++ requires expressions that evaluate to an integral or enumeration constant: as array bounds (8.3.4, 5.3.4), as case expressions (6.4.2), as bitfield lengths (9.6), as enumerator initializers (7.2), as static member initializers (9.4.2), and as integral or enumeration nontype template arguments (14.3). constantexpression: conditionalexpression An integral constantexpression can involve only literals (2.13), enumerators, const variables or static data members of integral or enumeration types initialized with constant expressions (8.5), nontype template parameters of integral or enumeration types, and sizeof expressions. Floating literals (2.13.3) can appear only if they are cast to integral or enumeration types. Only type conversions to integral or enumeration types can be used. In particular, except in sizeof expressions, functions, class objects, pointers, or references shall not be used, and assignment, increment, decrement, functioncall, or comma operators shall not be used. [/quote]

认真看看编译器的错误提示...

#include <stdio.h> #define n 3 int main()  {       int a[n]={1,2,3};  }   这样，就没错了！ 为什么，用const就错呢？ 编译器会很老么？

引用 4 楼 u013163178 的回复: //这个也是对的哦 int main() {     int n;     scanf("%d",&n);     a[n];     return 0; }  这怎么可能是对的............

引用 2 楼 Daffodiles 的回复:引用c++ 应该不会错 c有可能会错  编译器太老了？ 矮，C为什么老错呢？  c和c++在处理const上是不同的   没什么为什么

我的编译没有问题,我的编译环境是: gcc version 4.8.1 (Ubuntu 4.8.1-2ubuntu1~12.04)/*************************************************************************     > File Name: t.c     > Author: 傻李     > Mail: hellojukay@gmail.com      > Created Time: 2014年11月23日 星期日 20时44分06秒  ************************************************************************/  #include<stdio.h> int main() { 	int const a =9; 	int b[a]; 	b[0] = 22; 	printf("%d",b[0]); 	return 0; }

引用c++ 应该不会错 c有可能会错  编译器太老了？ 矮，C为什么老错呢？

c++ 应该不会错 c有可能会错  编译器太老了？


Question: 渣渣写的半成品贪吃蛇，为什么用键盘输入总是会延迟一步呢？

引用 6 楼 zxh707wk 的回复:仅供参考 //#define WIN32_LEAN_AND_MEAN #define HEIGHT 20 #define WIDE 76 #define ICO "*"  int flage; int time_interval;  struct node {     int x;     int y;     struct node* next; };  void getpos(HANDLE hOut,COORD *pos) {     CONSOLE_SCREEN_BUFFER_INFO info;     GetConsoleScreenBufferInfo( hOut , &info );     *pos = info.dwCursorPosition; } void gotopos(HANDLE hOut,COORD pos) {     SetConsoleCursorPosition(hOut, pos); }  void put_logo() {     int i;     for(i=0; i<8; i++)     {         printf("\n");     }     for(i=0; i<35; i++)     {         printf(" ");     }     printf("snake");     Sleep(2000);     system("cls"); }  void start_map() {     int i;     int j;     for(i=0; i<HEIGHT+3; i++)     {         for(j=0; j<WIDE+3; j++)         {             if(i==0||i==HEIGHT+2)             {                 printf("=");             }             else if(j==0||j==WIDE+2)             {                 printf("|");             }             else             {                 printf(" ");             }         }         printf("\n");     } }  struct node* clear_last(HANDLE hOut,COORD pos,struct node* p,int x,int y) {     pos.X = p->x;     pos.Y = p->y;     gotopos(hOut,pos);     printf(" ");     p->x=x;     p->y=y;     return p->next; }  int check_ways(struct node* q,int x,int y,int len) {     int i;     if(x<1||x>WIDE+1)     {         return 1;     }     if(y<1||y>HEIGHT+1)     {         return 1;     }     for(i=0; i<len; i++)     {         if(q->x==x&&q->y==y)         {             return 1;         }         q=q->next;     }     return 0; }  DWORD WINAPI  snake() {     struct node snakes;     struct node* head;     struct node* p;     struct node* q;     HANDLE hOut;     COORD pos;     int i;     int len;     len=10;     snakes.x=1;     snakes.y=1;     snakes.next=NULL;     pos.X=snakes.x;     pos.Y=snakes.y;     start_map();     hOut = GetStdHandle(STD_OUTPUT_HANDLE);     gotopos(hOut,pos);     head=p=q=malloc(sizeof(struct node));     p->x=snakes.x++;     p->y=snakes.y;     printf(ICO);     p->next=q;     for(i=0; i<len-1; i++)     {         q=p;         p=malloc(sizeof(struct node));         p->x=snakes.x++;         p->y=snakes.y;         printf(ICO);         p->next=head;         q->next=p;     }     printf(ICO);     snakes.x=snakes.x-1;     p=head;     for(;; Sleep(time_interval*50))     {         switch(flage)         {         case 1:             snakes.y--;             break;         case 2:             snakes.y++;             break;         case 3:             snakes.x--;             break;         case 4:             snakes.x++;             break;         default :             goto _NEXT;             break;         }         if(check_ways(head,snakes.x,snakes.y,len))         {             goto _END;         }         p=clear_last(hOut,pos,p,snakes.x,snakes.y);         pos.X=snakes.x;         pos.Y=snakes.y;         gotopos(hOut,pos);         printf(ICO);         printf("\b"); _NEXT:         ;     } _END:     ;     pos.X=25;     pos.Y=10;     gotopos(hOut,pos);     printf("game over!you have %d long snakes\b",len); } E:\编程\snake\snake.c|17|error: unknown type name 'HANDLE'|

引用 9 楼 aa2303632 的回复:大写字母的变量都没有定义你用什么编译器的？

引用 8 楼 zxh707wk 的回复:[quote=引用 7 楼 aa2303632 的回复:]E:\编程\snake\snake.c|17|error: unknown type name 'HANDLE'| 忘给main.c了 #define WIN32_LEAN_AND_MEAN  #include <stdio.h> #include <stdlib.h> #include <windows.h> #include "snake.h"  int main() {     HANDLE hThrd;     DWORD threadId;     flage=4;     time_interval=10;     hThrd=CreateThread(NULL,0,snake,(LPVOID)0,0,&threadId);     for(;;)     {         switch(getch())         {         case 224:             switch(getch())             {             case 72:                 if(flage!=2&&flage>0)                 {                     flage=1;                 }                 break;             case 80:                 if(flage!=1&&flage>0)                 {                     flage=2;                 }                 break;             case 75:                 if(flage!=4&&flage>0)                 {                     flage=3;                 }                 break;             case 77:                 if(flage!=3&&flage>0)                 {                     flage=4;                 }                 break;             }             break;         case 32:             flage=-flage;             break;         case 'w':             if(time_interval<200)             {                 time_interval=time_interval+1;             }             break;         case 'e':             if(time_interval>1)             {                 time_interval=time_interval-1;             }             break;         }         Sleep(100);     }     getchar();     return 0; } [/quote]大写字母的变量都没有定义

引用 7 楼 aa2303632 的回复:E:\编程\snake\snake.c|17|error: unknown type name 'HANDLE'| 忘给main.c了 #define WIN32_LEAN_AND_MEAN  #include <stdio.h> #include <stdlib.h> #include <windows.h> #include "snake.h"  int main() {     HANDLE hThrd;     DWORD threadId;     flage=4;     time_interval=10;     hThrd=CreateThread(NULL,0,snake,(LPVOID)0,0,&threadId);     for(;;)     {         switch(getch())         {         case 224:             switch(getch())             {             case 72:                 if(flage!=2&&flage>0)                 {                     flage=1;                 }                 break;             case 80:                 if(flage!=1&&flage>0)                 {                     flage=2;                 }                 break;             case 75:                 if(flage!=4&&flage>0)                 {                     flage=3;                 }                 break;             case 77:                 if(flage!=3&&flage>0)                 {                     flage=4;                 }                 break;             }             break;         case 32:             flage=-flage;             break;         case 'w':             if(time_interval<200)             {                 time_interval=time_interval+1;             }             break;         case 'e':             if(time_interval>1)             {                 time_interval=time_interval-1;             }             break;         }         Sleep(100);     }     getchar();     return 0; }

谁来告诉我下吧。。

引用 3 楼 zxh707wk 的回复:snake.c //#define WIN32_LEAN_AND_MEAN #define HEIGHT 20 #define WIDE 76 #define ICO "*"  int flage; int time_interval;  struct node {     int x;     int y;     struct node* next; };  void getpos(HANDLE hOut,COORD *pos) {     CONSOLE_SCREEN_BUFFER_INFO info;     GetConsoleScreenBufferInfo( hOut , &info );     *pos = info.dwCursorPosition; } void gotopos(HANDLE hOut,COORD pos) {     SetConsoleCursorPosition(hOut, pos); }  void put_logo() {     int i;     for(i=0; i<8; i++)     {         printf("\n");     }     for(i=0; i<35; i++)     {         printf(" ");     }     printf("snake");     Sleep(2000);     system("cls"); }  void start_map() {     int i;     int j;     for(i=0; i<HEIGHT+3; i++)     {         for(j=0; j<WIDE+3; j++)         {             if(i==0||i==HEIGHT+2)             {                 printf("=");             }             else if(j==0||j==WIDE+2)             {                 printf("|");             }             else             {                 printf(" ");             }         }         printf("\n");     } }  struct node* clear_last(HANDLE hOut,COORD pos,struct node* p,int x,int y) {     pos.X = p->x;     pos.Y = p->y;     gotopos(hOut,pos);     printf(" ");     p->x=x;     p->y=y;     return p->next; }  int check_ways(struct node* q,int x,int y,int len) {     int i;     if(x<1||x>WIDE+1)     {         return 1;     }     if(y<1||y>HEIGHT+1)     {         return 1;     }     for(i=0; i<len; i++)     {         if(q->x==x&&q->y==y)         {             return 1;         }         q=q->next;     }     return 0; }  DWORD WINAPI  snake() {     struct node snakes;     struct node* head;     struct node* p;     struct node* q;     HANDLE hOut;     COORD pos;     int i;     int len;     len=10;     snakes.x=1;     snakes.y=1;     snakes.next=NULL;     pos.X=snakes.x;     pos.Y=snakes.y;     start_map();     hOut = GetStdHandle(STD_OUTPUT_HANDLE);     gotopos(hOut,pos);     head=p=q=malloc(sizeof(struct node));     p->x=snakes.x++;     p->y=snakes.y;     printf(ICO);     p->next=q;     for(i=0; i<len-1; i++)     {         q=p;         p=malloc(sizeof(struct node));         p->x=snakes.x++;         p->y=snakes.y;         printf(ICO);         p->next=head;         q->next=p;     }     printf(ICO);     snakes.x=snakes.x-1;     p=head;     for(;; Sleep(time_interval*50))     {         switch(flage)         {         case 1:             snakes.y--;             break;         case 2:             snakes.y++;             break;         case 3:             snakes.x--;             break;         case 4:             snakes.x++;             break;         default :             goto _NEXT;             break;         }         if(check_ways(head,snakes.x,snakes.y,len))         {             goto _END;         }         p=clear_last(hOut,pos,p,snakes.x,snakes.y);         pos.X=snakes.x;         pos.Y=snakes.y;         gotopos(hOut,pos);         printf(ICO);         printf("\b"); _NEXT:         ;     } _END:     ;     pos.X=25;     pos.Y=10;     gotopos(hOut,pos);     printf("game over!you have %d long snakes\b",len); }  snake.h #include "snake.c"  void put_logo(); void getpos(HANDLE hOut,COORD *pos); void gotopos(HANDLE hOut,COORD pos); DWORD WINAPI  snake();  main.c #define WIN32_LEAN_AND_MEAN  #include <stdio.h> #include <stdlib.h> #include <windows.h> #include "snake.h"  int main() {     HANDLE hThrd;     DWORD threadId;     flage=4;     time_interval=10;     hThrd=CreateThread(NULL,0,snake,(LPVOID)0,0,&threadId);     for(;;)     {         switch(getch())         {         case 224:             switch(getch())             {             case 72:                 if(flage!=2&&flage>0)                 {                     flage=1;                 }                 break;             case 80:                 if(flage!=1&&flage>0)                 {                     flage=2;                 }                 break;             case 75:                 if(flage!=4&&flage>0)                 {                     flage=3;                 }                 break;             case 77:                 if(flage!=3&&flage>0)                 {                     flage=4;                 }                 break;             }             break;         case 32:             flage=-flage;             break;         case 'w':             if(time_interval<200)             {                 time_interval=time_interval+1;             }             break;         case 'e':             if(time_interval>1)             {                 time_interval=time_interval-1;             }             break;         }         Sleep(100);     }     getchar();     return 0; } 那我到底哪里有问题？

给楼主分享一个开源中国社区中的一个贪吃蛇游戏的代码链接，可以参考学习： http://www.oschina.net/code/snippet_261347_26002 下面是运行界面：

我把你的程序粘到vs2010里运行，运行的屏幕为啥是一闪一闪的？


Question: 高手帮我看看这个代码是怎么修改

strPath += _T("e:\temp");


Question: 大家看看我的代码有没有啥问题

引用 4 楼 dennes1988 的回复:[quote=引用 3 楼 zxhuser-2 的回复:] c99标准。。。 看样子我的错误已经明显到大家不屑于指出的程度了 好想知道到底咋回事啊[/quote] 错不错，我就不知道了，我没有这样的环境测试，数组这样使用确实很爽，但好多编译器并不支持这样的使用，还有函数的声明没特别要求的话，放到最外层，放main()里面是想干嘛？

引用 3 楼 zxhuser-2 的回复:c99标准。。。 看样子我的错误已经明显到大家不屑于指出的程度了 好想知道到底咋回事啊

c99标准。。。

引用 1 楼 u010030181 的回复:编译通过？运行正常？ 好牛逼的编译器……  我用的xcode啊 听起来问题很严重的样子，求指点，哪里有问题？

编译通过？运行正常？ 好牛逼的编译器……


Question: C语言 自动关机程序 求解

引用 4 楼 wency935486 的回复:[quote=引用 1 楼 u010030181 的回复:] 先声明一个char数组char buffer [50] = {0};	sprintf (buffer, "at %d:%d shutdown -s -t 0",n,m);	 	system(buffer); 为什么要定义数组？能讲一下不？ system(buffer);的作用是什么？[/quote] 定不定义数组，不是一定的，你也可以malloc申请内存，存储这个字符串的。system(buffer)有什么用的？那就翻书看看基础知识吧……

引用 4 楼 wency935486 的回复:[quote=引用 1 楼 u010030181 的回复:] 先声明一个char数组char buffer [50] = {0};	sprintf (buffer, "at %d:%d shutdown -s -t 0",n,m);	 	system(buffer); 为什么要定义数组？能讲一下不？ system(buffer);的作用是什么？[/quote]  3楼不是说的很清楚么 system("at n:m shutdown -s -t 0");  你这个 m n 在字符串中代表的不是变量对应的值 而是 字母m和n

引用 1 楼 u010030181 的回复:先声明一个char数组char buffer [50] = {0};	sprintf (buffer, "at %d:%d shutdown -s -t 0",n,m);	 	system(buffer); 为什么要定义数组？能讲一下不？ system(buffer);的作用是什么？

引用 1 楼 u010030181 的回复:先声明一个char数组char buffer [50] = {0};	sprintf (buffer, "at %d:%d shutdown -s -t 0",n,m);	 	system(buffer);+1


Question: c语言 字符串转化为16进制数和16进制数转化为char型如何实现

#include <stdio.h> #include <stdlib.h>  unsigned long long StrToHex(const char *pstr) {     unsigned long long ull = 0ULL;     if (pstr != NULL) {         while (*pstr != 0) {             char ch = *pstr++;             if (ch != ' ') {                 if (ch == '0' && (*pstr == 'x' || *pstr == 'X')) {                     pstr++;                     while (*pstr != 0) {                         unsigned char uc = 0;                         if (*pstr >= '0' && *pstr <= '9') {                             uc = (unsigned char)(*pstr - '0');                         } else if (*pstr >= 'a' && *pstr <= 'f') {                             uc = (unsigned char)(*pstr - 'a' + 10);                         } else if (*pstr >= 'A' && *pstr <= 'F') {                             uc = (unsigned char)(*pstr - 'A' + 10);                         } else {                             break;                         }                         ull <<= 4;                         ull |= uc;                         pstr++;                     }                 }                 break;             }         }     }     return ull; }  int HexToStr(unsigned long long ull, char *pstr, size_t size) {     int ret = -1;     if (pstr != NULL && size > 0) {         char pref[] = { '0', 'x' };         size_t cch = sizeof(pref);         unsigned long long _ull = ull;          while (_ull > 0) {             _ull >>= 4;             cch++;         }          if (size >= cch) {             *pstr++ = pref[0];             *pstr++ = pref[1];              while (cch-- > sizeof(pref)) {                 pstr++;             }              *pstr-- = 0;              while (ull > 0ULL) {                 unsigned char uc = ull & 0xF;                 *pstr-- = uc + ((uc < 10) ? '0' : ('A' - 10));                 ull >>= 4;             }              ret = 0;         }     }     return ret; }  int main(int argc, char *argv[]) {     char str[32] = { 0 };     char *hexstr = "0x00123abcdefgh";     unsigned long long ullret = 0ULL;     unsigned long long ulltest = 0x123456789ABCDEFULL;      // 自己编写函数将字符串作为 16 进制数字字符串解释为整数     ullret = StrToHex(hexstr);     printf("StrToHex:\n%s -> 0x%llX\n", hexstr, ullret);      // 自己编写函数将整数格式化为以 16 进制表示的字符串     if (HexToStr(ulltest, str, 32) != -1) {         printf("HexToStr:\n0x%llX -> %s\n", ulltest, str);     }      putchar('\n');      // 用 strtoull 将字符串作为 16 进制数字字符串解释为整数     ullret = strtoull(hexstr, NULL, 16);     printf("strtoull:\n%s -> 0x%llX\n", hexstr, ullret);      // 用 sprintf/snprintf 将整数格式化为以 16 进制表示的字符串     if (snprintf(str, 32, "0x%llX", ulltest) > 0) {         printf("snprintf:\n0x%llX -> %s\n", ulltest, str);     }      putchar('\n');      return 0; }

其实字符在计算机中存储的都是ASCII码，可以再MSDN搜索ASCII character codes 有2种方法转换，一种是，输入ASCII表，直接在表中搜素字符对应的16进制； 一种是根据字符对应的10进制数转换到16进制

打错了,是GNU不是GUN

GUN提供了类似的例子，楼主可以看卡． /* Copyright (C) 1991-2014 Free Software Foundation, Inc.    This file is part of the GNU C Library.     The GNU C Library is free software; you can redistribute it and/or    modify it under the terms of the GNU Lesser General Public    License as published by the Free Software Foundation; either    version 2.1 of the License, or (at your option) any later version.     The GNU C Library is distributed in the hope that it will be useful,    but WITHOUT ANY WARRANTY; without even the implied warranty of    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU    Lesser General Public License for more details.     You should have received a copy of the GNU Lesser General Public    License along with the GNU C Library; if not, see    <http://www.gnu.org/licenses/>.  */  #include <ctype.h> #include <locale.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include <math.h>  struct ltest   {     const char *str;		/* Convert this.  */     double expect;		/* To get this.  */     char left;			/* With this left over.  */     int err;			/* And this in errno.  */   }; static const struct ltest tests[] =   {     { "12.345", 12.345, '\0', 0 },     { "12.345e19", 12.345e19, '\0', 0 },     { "-.1e+9", -.1e+9, '\0', 0 },     { ".125", .125, '\0', 0 },     { "1e20", 1e20, '\0', 0 },     { "0e-19", 0, '\0', 0 },     { "4\00012", 4.0, '\0', 0 },     { "5.9e-76", 5.9e-76, '\0', 0 },     { "0x1.4p+3", 10.0, '\0', 0 },     { "0xAp0", 10.0, '\0', 0 },     { "0x0Ap0", 10.0, '\0', 0 },     { "0x0A", 10.0, '\0', 0 },     { "0xA0", 160.0, '\0', 0 },     { "0x0.A0p8", 160.0, '\0', 0 },     { "0x0.50p9", 160.0, '\0', 0 },     { "0x0.28p10", 160.0, '\0', 0 },     { "0x0.14p11", 160.0, '\0', 0 },     { "0x0.0A0p12", 160.0, '\0', 0 },     { "0x0.050p13", 160.0, '\0', 0 },     { "0x0.028p14", 160.0, '\0', 0 },     { "0x0.014p15", 160.0, '\0', 0 },     { "0x00.00A0p16", 160.0, '\0', 0 },     { "0x00.0050p17", 160.0, '\0', 0 },     { "0x00.0028p18", 160.0, '\0', 0 },     { "0x00.0014p19", 160.0, '\0', 0 },     { "0x1p-1023",       1.11253692925360069154511635866620203210960799023116591527666e-308,       '\0', 0 },     { "0x0.8p-1022",       1.11253692925360069154511635866620203210960799023116591527666e-308,       '\0', 0 },     { "Inf", HUGE_VAL, '\0', 0 },     { "-Inf", -HUGE_VAL, '\0', 0 },     { "+InFiNiTy", HUGE_VAL, '\0', 0 },     { "0x80000Ap-23", 0x80000Ap-23, '\0', 0 },     { "1e-324", 0, '\0', ERANGE },     { "0x100000000000008p0", 0x1p56, '\0', 0 },     { "0x100000000000008.p0", 0x1p56, '\0', 0 },     { "0x100000000000008.00p0", 0x1p56, '\0', 0 },     { "0x10000000000000800p0", 0x1p64, '\0', 0 },     { "0x10000000000000801p0", 0x1.0000000000001p64, '\0', 0 },     { NULL, 0, '\0', 0 }   };  static void expand (char *dst, int c); static int long_dbl (void); static int locale_test (void);  int main (int argc, char ** argv) {   char buf[100];   const struct ltest *lt;   char *ep;   int status = 0;   int save_errno;    for (lt = tests; lt->str != NULL; ++lt)     {       double d;        errno = 0;       d = strtod(lt->str, &ep);       save_errno = errno;       printf ("strtod (\"%s\") test %u", 	     lt->str, (unsigned int) (lt - tests));       if (d == lt->expect && *ep == lt->left && save_errno == lt->err) 	puts ("\tOK");       else 	{ 	  puts ("\tBAD"); 	  if (d != lt->expect) 	    printf ("  returns %.60g, expected %.60g\n", d, lt->expect); 	  if (lt->left != *ep) 	    { 	      char exp1[5], exp2[5]; 	      expand (exp1, *ep); 	      expand (exp2, lt->left); 	      printf ("  leaves '%s', expected '%s'\n", exp1, exp2); 	    } 	  if (save_errno != lt->err) 	    printf ("  errno %d (%s)  instead of %d (%s)\n", 		    save_errno, strerror (save_errno), 		    lt->err, strerror (lt->err)); 	  status = 1; 	}     }    sprintf (buf, "%f", strtod ("-0.0", NULL));   if (strcmp (buf, "-0.000000") != 0)     {       printf ("  strtod (\"-0.0\", NULL) returns \"%s\"\n", buf);       status = 1;     }    const char input[] = "3752432815e-39";    float f1 = strtold (input, NULL);   float f2;   float f3 = strtof (input, NULL);   sscanf (input, "%g", &f2);    if (f1 != f2)     {       printf ("f1 = %a != f2 = %a\n", f1, f2);       status = 1;     }   if (f1 != f3)     {       printf ("f1 = %a != f3 = %a\n", f1, f3);       status = 1;     }   if (f2 != f3)     {       printf ("f2 = %a != f3 = %a\n", f2, f3);       status = 1;     }    const char input2[] = "+1.000000000116415321826934814453125";   if (strtold (input2, NULL) != +1.000000000116415321826934814453125L)     {       printf ("input2: %La != %La\n", strtold (input2, NULL), 	      +1.000000000116415321826934814453125L);       status = 1;     }    static struct { const char *str; long double l; } ltests[] =     {       { "42.0000000000000000001", 42.0000000000000000001L },       { "42.00000000000000000001", 42.00000000000000000001L },       { "42.000000000000000000001", 42.000000000000000000001L }     };   int n;   for (n = 0; n < sizeof (ltests) / sizeof (ltests[0]); ++n)     if (strtold (ltests[n].str, NULL) != ltests[n].l)       { 	printf ("ltests[%d]: %La != %La\n", n, 		strtold (ltests[n].str, NULL), ltests[n].l); 	status = 1;       }    status |= long_dbl ();    status |= locale_test ();    return status ? EXIT_FAILURE : EXIT_SUCCESS; }  static void expand (dst, c)      char *dst;      int c; {   if (isprint (c))     {       dst[0] = c;       dst[1] = '\0';     }   else     (void) sprintf (dst, "%#.3o", (unsigned int) c); }  static int long_dbl (void) {   /* Regenerate this string using       echo '(2^53-1)*2^(1024-53)' | bc | sed 's/\([^\]*\)\\*$/    "\1"/'    */   static const char longestdbl[] =     "17976931348623157081452742373170435679807056752584499659891747680315"     "72607800285387605895586327668781715404589535143824642343213268894641"     "82768467546703537516986049910576551282076245490090389328944075868508"     "45513394230458323690322294816580855933212334827479782620414472316873"     "8177180919299881250404026184124858368";   double d = strtod (longestdbl, NULL);    printf ("strtod (\"%s\", NULL) = %g\n", longestdbl, d);    if (d != 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000)     return 1;    return 0; }  /* Perform a few tests in a locale with thousands separators.  */ static int locale_test (void) {   static const struct   {     const char *loc;     const char *str;     double exp;     ptrdiff_t nread;   } tests[] =     {       { "de_DE.UTF-8", "1,5", 1.5, 3 },       { "de_DE.UTF-8", "1.5", 1.0, 1 },       { "de_DE.UTF-8", "1.500", 1500.0, 5 },       { "de_DE.UTF-8", "36.893.488.147.419.103.232", 0x1.0p65, 26 }     }; #define ntests (sizeof (tests) / sizeof (tests[0]))   size_t n;   int result = 0;    puts ("\nLocale tests");    for (n = 0; n < ntests; ++n)     {       double d;       char *endp;        if (setlocale (LC_ALL, tests[n].loc) == NULL) 	{ 	  printf ("cannot set locale %s\n", tests[n].loc); 	  result = 1; 	  continue; 	}        /* We call __strtod_interal here instead of strtod to tests the 	 handling of grouping.  */       d = __strtod_internal (tests[n].str, &endp, 1);       if (d != tests[n].exp) 	{ 	  printf ("strtod(\"%s\") returns %g and not %g\n", 		  tests[n].str, d, tests[n].exp); 	  result = 1; 	}       else if (endp - tests[n].str != tests[n].nread) 	{ 	  printf ("strtod(\"%s\") read %td bytes and not %td\n", 		  tests[n].str, endp - tests[n].str, tests[n].nread); 	  result = 1; 	}     }    if (result == 0)     puts ("all OK");    return result; }

仅供参考． /*************************************************************************     > File Name: sprintf_3.c     > Author: 傻李     > Mail: hellojukay@gmail.com      > Created Time: 2014年11月23日 星期日 16时39分18秒  ************************************************************************/ #include<string.h> #include<stdio.h> int main() { 	char buffer[10]; 	char buffer_0x[20]; 	long int test; 	//输入字符创，转化为16进制打印 	printf("输入一个字符串:") 	fgets(buffer,10,stdin); 	test = atol(buffer); 	printf("%x(16)\n",test); 	//输入整数，转化为字符串打印,首先转化为对应十进制 	printf("输入一个16进制数:") 	scanf("%x",&test); 	sprintf(buffer_0x,"%d",test); 	puts(buffer_0x); 	return 0; }


Question: 提问一个数据结构中清空与销毁的问题

就是那么搞的啊 你说的清空指的是删除节点还是删除节点数据？ 1楼的代码就是清空（销毁）啊~！！ 不知道你说清空和销毁指的是啥

你这个清空跟销毁怎么感觉没什么多大的区别？

如果你有一个头节点head,你free(head)的话,只会删除第一个节点,你要删除所有节点,就这么干 struct node *tmp; if(head != NULL) do{     tmp = head ->next;     free(head);     head = tmp; }while(tmp != NULL);


Question: 为什么这个程序不能运行

可以设置一个特殊字符作为结束标记，只要不是循环中要统计的字符就行了。

scanf("%c",&c);  这样好像没法给c得到EOF吧，建议改成类似这样的 while (c!= 'q') 或者这样也行 while (scanf("%c",&c)!=EOF)  输入Ctrl+Z(windows)或者Ctrl+D(linux)可以结束循环。循环里面的scanf可以删掉了。


Question: 运行这个程序时输入“input”为什么输出语句中只有一个“i"，而没有整个”input“

#include<iostream> using namespace std;

仅供参考	char c[20] = {0}; 	printf("Please input a character:\n"); 	scanf("%s",&c);			// 字符串要用 %s 	char * p = c; 	while (*p != '\0') 	{ 		printf("The ASCII of %c is %d\n",*p,*p); 		p++; 	}  汉子无法用原先的ascll码表示，一个汉字需要2个字节来表示

你scanf里边是%c就是接收一个字符，怎么能输出后边的呢？

scanf函数会将多余的字符留在缓冲区，下去调用scanf不等待键盘输出，直接重缓冲区读取数据。 以下内容，仅供参考。 /*************************************************************************     > File Name: scanf_1.c     > Author: 傻李     > Mail: hellojukay@gmail.com      > Created Time: 2014年11月22日 星期六 12时07分00秒  ************************************************************************/  #include<stdio.h> int main() { 	char ch; 	printf("Please input a character:\n"); 	scanf("%c",&ch); 	while(ch != '\n') 	{ 		printf("The ASCII of %c is %d\n",ch,ch); 		scanf("%c",&ch); 	} 	return 0; }

引用 2 楼 starytx 的回复:你scanf里边是%c就是接收一个字符，怎么能输出后边的呢？+1

3楼正解，char只有一个字节哈， 汉字是2个字节， 所有你打印的只是汉字中国中的中字的前1个字节........

什么意思，不清楚，可否详细说明一下


Question: 不借助任何工具用c语言打开bmp图像，将其转换为JPEG格式并存储

好复杂的一个问题,显示图片都不是很难,难就在还要换格式

首先解析bitmap文件，bitmap文件有两个部分，一个是头，一个是体。头和体都是固定的结构，“体”要注意调色板。  头的结构在windows的一个头里有，网上也有资料。 体由三部分组成：  1. 基本info 2. 调色板 3. 像素信息  其中调色板可选，超过256色没有调色板。而256色以下的，必须有调色板。这部分细节还是要看网上资料。  jpeg的编码用libjpeg库。

就是查bmp和jpg的文件格式。 如果不能用库，jpg文件生成也就是3个步骤：DCT变换，量化，游程编码。

bmp格式比较简单，自己写。编码成jpeg可以用libjpeg库。

上网上找bmp文件的结构体，将文件中的数据读到结构体中，然后在找jpeg结构体 根据需要填充即可

哥们，你在上多媒体的课么


Question: 求解答？？

unsigned long long 有取值范围的，存不了1000位的十进制数，大数一般用字符串存储

高精度数字可以用整数数组来模拟,需要定义相关的运算函数,如+-*/

你的问题本身就不对

引用 3 楼 useruser1 的回复:如果定义不超100位10进制应该怎么定义？ 表示很大的数据就用 char a[100];

如果定义不超100位10进制应该怎么定义？

其实不确定，但肯定是不超100位，十进制应该不行，那就是二进制的，是吗？

楼主说的100位是指二进制位还是十进制为？


Question: 问几个问题

人呢?自顶~~~~

不知道怎么改才可以,比如我把key改成apt+m；然后return i，m不知道为什么会报错

我对问题2编写了一个函数,不过只能输出一个值,而不能输出自己本身的下标 #include <stdio.h> #include <stdlib.h> int search(int *apt,int n,int key) { 	int *p,i=0;     for(p=apt;p<apt+n-1;p=apt+i) 	{	if(*p==key) 			return i; 		i++;     } 	return -1; } int b[]={90,80,90}; int main() {	int d; 	d=search(b,sizeof(b)/sizeof(b[0]),b[2]); 	if(d!=-1) 		printf("%d",d); 	else 		printf("No the same"); 	system("pause"); 	return 0; }

仅供参考 /*************************************************************************     > File Name: qsort_3.c     > Author: 傻李     > Mail: hellojukay@gmail.com      > Created Time: 2014年11月22日 星期六 12时55分56秒  ************************************************************************/  #include<stdio.h> struct node { 	int data; 	int No;//编号 }; int comp(void *a,void *b) { 	return (*(struct node *)a).data - (*(struct node *)b).data; }  int main() { 	int a[] = {5,1,2,5,8,6,85,5,8,5,8,5,8,6,8,2,5,8,2,0,2,99,5}; 	int len = sizeof(a)/sizeof(int); 	int i,j; 	struct node arry[len]; 	for(i =0; i < len; ++i ) 	{ 		arry[i].No = i; 		arry[i].data = a[i];  	} 	//排序数组 	qsort(arry,len,sizeof(struct node),comp); 	for(i = 0, j = 1; j < len; ) 	{ 		if(arry[i].data == arry[j].data) 		{     //区间[arry[i], arry[j]]内的值相等 			++j; 		} 		else if(j -i >1) 		{ 			for(;i <j ;++i) 			printf("( 编号:%2d ,  数值:%2d )\n",arry[i].No ,arry[i].data); 		} 		else 		{ 			i = j; 			++j; 		} 	} 	return 0; }

return只能返回一个值，不能像你写的都返回两个值了，所以报错了啊。如果需要返回多个值，可以考虑使用传引用进去。


Question: fscanf()文件读入的问题

引用 1 楼 user-3 的回复:建议楼主检查fscanf的返回值，如果返回EOF就跳出循环。         if (fscanf(fp, "%s%s%s", p->Name, p->IdNum, p->PassWord) == EOF) {             free(p);             break;         } 这个方法我也试过，的确可行，不过我想知道的是为什么会出这种错....我觉着问题可能出在最后一个字符串末尾的\n上，不过不知道除了检查返回值以外，有没有什么能针对这个问题的解决办法...求指教

引用 2 楼 cutail 的回复:feof是根据FILE中的结束标记位是否被标记来判断是否结束的。当读完最后一条记录时（读取成功），结束标记位没有置1，所以循环中feof判断没有达到文件尾，继续进入循环，这就多进入了一次。 那怎么解决呢？除了检查fscanf返回值的方法以外有没有什么办法？我调试的时候感觉问题出在了最后一条字符串末尾的\n上，只是还没想出什么好的解决方法

引用 5 楼 michael2988 的回复:“C”语言的“feof()”函数和数据库中“eof()”函数的运作是完全不同的。数据库中“eof()”函数读取当前指针的位置，“C”语言的“feof()”函数返回的是最后一次“读操作的内容”。   [quote=引用 4 楼 u013805360 的回复:] [quote=引用 1 楼 user-3 的回复:] 建议楼主检查fscanf的返回值，如果返回EOF就跳出循环。         if (fscanf(fp, "%s%s%s", p->Name, p->IdNum, p->PassWord) == EOF) {             free(p);             break;         } 这个方法我也试过，的确可行，不过我想知道的是为什么会出这种错....我觉着问题可能出在最后一个字符串末尾的\n上，不过不知道除了检查返回值以外，有没有什么能针对这个问题的解决办法...求指教[/quote][/quote] 最后一次读操作之后文件的位置指针不是指向了最后一个字符串后面吗？而且如果最后一个字符串末尾没有\n的话就不会多执行一次while循环了，为什么呐...

“C”语言的“feof()”函数和数据库中“eof()”函数的运作是完全不同的。数据库中“eof()”函数读取当前指针的位置，“C”语言的“feof()”函数返回的是最后一次“读操作的内容”。   引用 4 楼 u013805360 的回复:[quote=引用 1 楼 user-3 的回复:] 建议楼主检查fscanf的返回值，如果返回EOF就跳出循环。         if (fscanf(fp, "%s%s%s", p->Name, p->IdNum, p->PassWord) == EOF) {             free(p);             break;         } 这个方法我也试过，的确可行，不过我想知道的是为什么会出这种错....我觉着问题可能出在最后一个字符串末尾的\n上，不过不知道除了检查返回值以外，有没有什么能针对这个问题的解决办法...求指教[/quote]

非常感谢，弄明白了 引用 7 楼 michael2988 的回复:eof() 才是返回指针位置，而feof() 返回最后一次读取的内容。  http://baike.baidu.com/view/656648.htm?fr=aladdin


Question: 看不懂代码 求助已知 abc+cba=1333，其中a、b、c均为一位数，编程序求出a、b、c的值。

它的思路就是简单的穷举，把所有可能的组合都验证一遍。 y=100*c+10*b+a; printf("a = %d, b = %d, c = %d, x=%d, y = %d\n", a, b, c, x, y);  // 加上这一行，运行一下看看输出就明白了。  if(x+y==1333)

这3个for循环在一起连着，{}可以省略不写，你可以把{}加上慢慢算呗

求帮助 我就是不知道他是按照什么顺序执行的


Question: 100分求c语言或c++（最好c语言）编制的词法分析程序（要求见内部）

BNF都有了, 一行行照着抄就是了.  没几行的事...

比如 const a=1.3  需输出**  REALCON 1.3 表中 const 是 CONSTTK，REALCON 哪來的？

DIY LEX+YACC FLEX+BISON

引用 14 楼 FancyMouse 的回复:这用lex yacc就是杀鸡用牛刀。 词法分析你们教的正则语法/DFA呢。把DFA画出来，再写代码简直照图画瓢。

自己看看，慢慢实现

引用 12 楼 taodm 的回复:哦，只写词法部分要容易很多。 恩，本周只要词法分析

哦，只写词法部分要容易很多。

引用 10 楼 taodm 的回复:如果不借助现成的lex/yacc库，自己从0实现这样的解析库，纯C++，利用强大的stl，总代码量应该也不低于3K；C嘛，估计要过万了。  应该不用吧。。我同学用c++300多行写出来了，我在网上找了一个词法分析也是270多行，不过实在没时间改啊。。大神能帮我改一下吗 #include <stdio.h>        #include <stdlib.h>  #include <string.h>  #include <ctype.h>  #define LEN sizeof(struct Node)  #define NULL 0    FILE *fp;                                      /*fp是一个指向FILE类型结构的指针变量，可以使fp指向某一个文                                                      件的结构变量，从而通过该结构体变量中的文件信息访问该文件*/ struct Node  {char data;      struct Node *next;                        /* 定义动态链表数据结构   */    };    void output(struct Node*);                /*扫描输出函数*/  void scaner();                              /*词法分析*/    void getbc();    void getch();  void concat();  int letter(char ch);  int degit(char ch);  int reserve();  void retract();  void back(int a,char *b); void back1(int a, int b); struct Node *head,*p;  char ch;                                                  /*全局变量*/    char *key[]={"begin","do","else","end","if","then","var","while"};    /*关键字表*/   char token[20];                                                   /*字符数组，存放构成单词的符号串*/      int main(void)  {      fp = fopen("test.c", "at+");     head=(struct Node *)malloc(LEN);                              /*分配头节点存储空间*/      if(!head) {printf("error");exit(1);}      head->next=NULL;      head->data=' ';     p=head;      printf("输入 \"$\" 结束.\n");      printf("关键字 t=1; 分界符 t=2; 算术运算符 t=3;\n");     printf("关系运算符 t=4; 常数 t=5; 标识符 t=6;\n");     printf("\n");     printf("输入源程序:\n");       while(1)      {          int i=0;          char temp[256];                                            /*每行长度不超过256个字符*/        gets(temp);                                                          /*输入源程序，以行为单位*/        if(temp[0]=='$') break;                                            /*当输入的第一个字符为#时表示输入源代码结束*/               p->next=(struct Node *)malloc(LEN);          if(!(head->next)) {printf("error");exit(1);}          p=p->next;                                                                 /*将输入的代码以行为单位存入缓冲区*/           while(temp[i]!='\0' && i<256)         {              p->data=temp[i];              p->next=(struct Node *)malloc(LEN);              if(!(p->next)) {printf("error");exit(1);}              p=p->next;              i++;        }          p->data='\n';         p->next=NULL;                                                             /*尾结点*/      }            output(head);                                                             /*扫描缓冲区，输出结果*/      p=head->next;      while(p->next!=NULL)       scaner();                                                                 /*词法分析*/      fclose(fp);    system("pause");      return 0;    }          void   output(struct   Node   *head) {     if(!head)   {printf("error");exit(1);}                                /*扫描缓冲区函数*/       p=head->next;        while(p->next!=NULL)        {            printf("%c",p->data);            p=p->next;        }        printf("\n");    }                                                            /*若ch中是空白字符，则不停调用getch()直到读入的不是空白字符为止*/ void getbc() {        while (ch==' ')     getch();    }   void getch()                                              /*从缓冲区读入一字符*/    {     ch=p->data;     p=p->next; }   void concat()                                            /*将ch中的字符连接到token的后面*/    {        unsigned int i;   i=strlen(token);    token[i]=ch;    token[i+1]='\0'; }      int letter(char ch)                                 /*判断ch中的是否是字母*/    {       return isalpha((int)ch); }      int digit(char ch)                                    /*判断ch中的是否是数字*/  {      return isdigit((int)ch); }    int reserve()                                           /*判断token中的字符串是否是关键字或是标识符*/    {      int k;    for(k=0;k<8;k++)    {        if(strcmp(key[k],token)==0) return (k);   }   return 6;                                                 /*如果是标识符返回值为t=6*/ }   void retract()                                      /*指针回退一个字符*/    {    struct Node *Q;    Q=head->next;   while(Q->next!=p)   Q=Q->next;   p=Q; }    void back(int a, char  *b)                              /*返回函数，输出序列*/ {     printf("(%d,%s)\n",a,b);     fprintf(fp,"(%d,%s)\n",a,b); }   void back1(int a, int b)                                /*返回函数，输出序列*/ {      printf("(%d,%d)\n",a,b);   fprintf(fp,"(%d,%d)\n",a,b); }     void scaner()                                            /*词法分析函数*/    {      int c;      token[0]=NULL;                                         /*将token清空*/     getch();        getbc();                                               /*读入一个单词*/        if(letter(ch))                                           /*处理字符的情况*/        {         while(letter(ch)||digit(ch))          {              concat();              getch();          }          retract();      c=reserve();                                      //c中存放的为K的值，当K为6时，是标识符     if(c!=6) back1(1,c);                            //t=1为关键字     else back(6,token);         }     else if(digit(ch))                                    /*处理数字的情况*/        {          while(digit(ch))          {               concat();        getch();          }          retract();         printf("(5,%d)\n",atoi(token));                  fprintf(fp,"(5,%d)\n",atoi(token));     }    else   switch(ch)                                            /*处理特殊符号的情况*/        {         case'+': back(3,"10H");break;                   //符号处理         case'-': back(3,"11H");break;          case'*': back(3,"20H");break;         case'/': back(3,"21H");break;                     //下面的还没处理         case',': back(2,"0");break;         case';': back(2,"1");break;         case'.': back(2,"2");break;         case':=': back(2,"3");break;         case'(': back(2,"4");break;         case')': back(2,"5");break;            case'=': back(4,"02H");break;         case'<': { getch();             if(ch=='=') back(4,"01H");               else if (ch=='>') back(4,"05H");             else              {    retract();                  back(4,"00H");             }           }break;           case'>': {  getch();              if(ch=='=') back(4,"04H");             else { retract();              back(4,"03H");             }         }break;     } }

引用 6 楼 baijiaheizhiganmao 的回复:楼主不要连手都不动。至少自己把框架打好。 我看见网上有几个类似的，但是这星期我们老师光是课设就布置了3个，实在没时间做呀，求好人

楼主不要连手都不动。至少自己把框架打好。

这像是“编译原理”的题啊～～～  哈哈   自己慢慢做吧～～

100块钱都难有人干。。 还是和同学老师讨论吧。小部分不会再来问

引用 2 楼 tpnndhqc 的回复:[quote=引用 1 楼 u013049001 的回复:] 大神快来 楼主啊，说真的，你才是大神啊！谁会弄这样的一整个工程啊！ 小程序论坛能帮你，这玩意也帮？会玩死人的，自己做吧~[/quote] 我是大神就不会来求救了，不知如何下手啊

引用 1 楼 u013049001 的回复:大神快来 楼主啊，说真的，你才是大神啊！谁会弄这样的一整个工程啊！ 小程序论坛能帮你，这玩意也帮？会玩死人的，自己做吧~

大神快来


Question: vs2010   预编译  结果错误

引用 1 楼 user-2 的回复:不要把printf放到else同一行里面。 #else printf("abc\n"); 这样分成两行才是正确的写法。 我不知道为什么VC能输出abc，也不想知道，没有意义。 一楼方法解决了问题,是不是因为预编译一定要单独占据一行呢

引用 1 楼 user-2 的回复:不要把printf放到else同一行里面。 #else printf("abc\n"); 这样分成两行才是正确的写法。 我不知道为什么VC能输出abc，也不想知道，没有意义。  谢谢，请问，if  else  endif 前面加上#有什么意义，和不加有啥区别？？？@user-2


Question: 关于函数

thank you very much

引用 2 楼 user-2 的回复:仅供参考 long fun(long nNum) { 	static long nTmp = 0; 	if (nNum > 0) 	{ 		nTmp = nTmp*10+nNum%10; 		nNum = nNum/10; 		fun(nNum); 	} 	return nTmp; }

long num_rev(long l) {     char str[100] = {0};     sprintf(str, "%ld", l);      // 字符串反向     char *p1 = str;                     // 指向首字符     char *p2 = str + strlen(str) - 1;   // 指向最后一个有效字符     while (p2 > p1)     {         char c = *p1;         *p1 = *p2;         *p2 = c;         p1++;         p2--;     }      sscanf(str, "%ld", &l);      return l; }


Question: 字符串逆序

我是在楼主的基础上修改的。函数可以不需要那么多参数，也可以不需要返回值：  #include<stdio.h> #include<string.h> #define MAX_STR_LEN 100 void str_rev(char * s) { 	int i,d; 	char c; 	d=strlen(s); 	for(i=0;i<d/2;i++) 	{ 		c=s[i]; 		s[i]=s[d-i-1]; 		s[d-i-1]=c; 	} 	s[d] = '\0'; }  int main() { 	char s[MAX_STR_LEN]; 	gets(s); 	str_rev(s); 	puts(s); 	return 0; }

或者使用strrev()函数，不过这不是标准库函数

#include<stdio.h> #include<string.h>  void swap(char *, char *); //逆序 void reverse(char *str) {     int i = 0, j = strlen(str) - 1;     for(; i <( j/2) ; ++i) 	swap(&str[i], &str[j-i]); } //交换值 void swap(char *a , char *b) {     char tmp;     tmp = *a;     *a = *b;     *b = tmp; }  int main() {     char str[] = "hello world";     reverse(str);     printf("%s",str);     return 0; }

函数无需那么多参数，就一个char*参数就行了，直接修改实参数组的值，仅供参考 void str_rev(char * s) { 	char *p1 = s;		// 指向首字符 	char *p2 = s + strlen(s) - 1;		// 指向最后一个有效字符 	while (p2 > p1) 	{ 		char c = *p1; 		*p1 = *p2; 		*p2 = c; 		p1++; 		p2--; 	} }  int main(） { 	char str[100] = {0}; 	gets(str); 	str_rev(str); 	puts(str);  	return 0; }

str_rev 没有返回值，而且不明白你要实现什么？


Question: 今天笔试遇到一个题，求助！！

谢谢大家的回复

耶稣的叛徒。。。

#include <stdio.h> #define SIZE 50  int main() { 	int ath[SIZE] = {0}; 	int odd, i; 	int flag; 	int count = SIZE; 	printf("请选择：0-单数出列\t1-双数出列"); 	scanf("%d", &odd); 	 	while(count >= 1) { 		flag = 0; 		for(i=0; i<SIZE; i++){ 			if(ath[i] == 0){ 				if(count == 1) { 					printf("最后剩下的是%d\n", i + 1); 					return 0; 				} 				if(flag == odd){ 					ath[i] = 1; 					count--; 				}  				flag = 1 - flag; 			} 		} 	}     return 0; }  或者 #include <stdio.h> #include <math.h>  int main() { 	int n, odd; 	printf("请输入运动员人数："); 	scanf("%d", &n); 	printf("请选择：0-单数出列\t1-双数出列"); 	scanf("%d", &odd); 	switch(odd){ 	case 0: printf("最后剩下的是%d\n", (int)(pow(2, (int)(log(n)/log(2))))); break; 	case 1: printf("最后剩下的是1\n"); break; 	}     return 0; }

高端一下就是约瑟夫环吧，简单的想就弄一个数组，0表示在队列里，1表示出列，每次都遍历数组，若在队列里，就用此次遍历的次数取余来判定需不需要出列就行。到最后剩下一个就是答案了。

发现一个有趣的现象：单数出列最后剩下的无非就是2,4,8,16,32,64等等这样的结果，也就是说只要你给的人数在这些数字某两个之间（前闭合区间），那么最后剩下的就是较小的那个数，例如你的例子是50,50在32和64之间，那么最后就剩下32号

用的递归函数，这个是单数出列的，双数出列比较容易想，肯定剩下第一号。 int fun(int *p ,int nNum) { 	if (nNum > 1) 	{ 		int i = 0;       // 双数出列的话，改为 1 		for (; i < nNum/2; i++) 		{ 			p[i] = p[2*i+1];    // 双数出列的话改为 p[i] = p[2*i]; 		} 		fun(p ,i); 	} 	return p[0]; }  int _tmain(int argc, _TCHAR* argv[]) { 	int n[50] = {0};     	for (int i = 0; i != 50; i++) 	{ 		n[i] = i + 1;    // 初始化为1~49 	} 	printf("最后剩下第 %d 号\n" ,fun(n,50)); 	return 0; }

链表、数组都可以解决

约瑟夫环  。