Question: 问一下C语言库函数是如何简写的

尺有所短，寸有所长。

殊不知，库函数命名越通俗清晰易懂，越容易和用户的编写的函数重名！

英语也是一门计算机语言的说。  manual n. 手册, 指南 adj. 手的, 手动的, 手工的, 体力的, 手册(性质)的, [律]实际占有的

如果LZ在Linux平台下，有个man命令，很方便的说。

引用 11 楼 zxh707wk 的回复:lz你吃鸡蛋还有研究它是哪个国家的哪种鸡生的吗 跟你说的完全没有可比性？就算跟鸡蛋扯上关系，程序员也是蛋的营养价值专家，而不是普通吃蛋的民众。

引用 12 楼 ForestDB 的回复:[quote=引用 9 楼 liaoyungchun 的回复:] [quote=引用 8 楼 ForestDB 的回复:] strspn -- span a string wcsspn strcspn -- span the complement of a string wcscspn  str wcs --> wide-char-str spn --> span  可以man之 貌似这个更准确，但是真没这类资料么？[/quote]  都说了man之， strcspn -- span the complement of a string 这就是man中的[/quote]  man是啥意思？是一本什么手册之类的吗？

不过我感觉库函数命名复杂的原因可能是历史悠久产生的，版本不断演进，命名规范也不停变化导致的。

感觉应该是没有答案了，我其实喜欢看这个网站： http://www.cplusplus.com/reference/ 也是英文的，只是英文的解释很多跟看不出名字的取法而已，比如我刚才说的。  再比如说 fwide：Stream orientation (function ) ------名称跟意义完全匹配不上嘛  这种名称数不胜数，只能用多了才能记住。 C语言我非常喜欢，不过这些库函数的名称实在取得让人蛋疼。

引用 9 楼 liaoyungchun 的回复:[quote=引用 8 楼 ForestDB 的回复:] strspn -- span a string wcsspn strcspn -- span the complement of a string wcscspn  str wcs --> wide-char-str spn --> span  可以man之 貌似这个更准确，但是真没这类资料么？[/quote]  都说了man之， strcspn -- span the complement of a string 这就是man中的

lz你吃鸡蛋还有研究它是哪个国家的哪种鸡生的吗

很经典的例子就是  string_copy  大部分指针实现

翻一番标准目录

引用 8 楼 ForestDB 的回复:strspn -- span a string wcsspn strcspn -- span the complement of a string wcscspn  str wcs --> wide-char-str spn --> span  可以man之 貌似这个更准确，但是真没这类资料么？

String Manipulation These routines operate on null-terminated single-byte character, wide-character, and multibyte-character strings. Use the buffer-manipulation routines, described in Buffer Manipulation, to work with character arrays that do not end with a null character.  String-Manipulation Routines  Routine Use  _mbscoll, _mbsicoll, _mbsncoll, _mbsnicoll Compare two multibyte-character strings using multibyte code page information (_mbsicoll and _mbsnicoll are case-insensitive)  _mbsdec, _strdec, _wcsdec Move string pointer back one character  _mbsinc, _strinc, _wcsinc Advance string pointer by one character  _mbslen Get number of multibyte characters in multibyte-character string; dependent upon OEM code page  _mbsnbcat Append, at most, first n bytes of one multibyte-character string to another  _mbsnbcmp Compare first n bytes of two multibyte-character strings  _mbsnbcnt Return number of multibyte-character bytes within supplied character count  _mbsnbcpy Copy n bytes of string  _mbsnbicmp Compare n bytes of two multibyte-character strings, ignoring case  _mbsnbset Set first n bytes of multibyte-character string to specified character  _mbsnccnt Return number of multibyte characters within supplied byte count  _mbsnextc, _strnextc, _wcsnextc Find next character in string  _mbsninc. _strninc, _wcsninc  Advance string pointer by n characters  _mbsspnp, _strspnp, _wcsspnp Return pointer to first character in given string that is not in another given string  _mbstrlen Get number of multibyte characters in multibyte-character string; locale-dependent  sprintf, _stprintf Write formatted data to a string  strcat, wcscat, _mbscat Append one string to another  strchr, wcschr, _mbschr Find first occurrence of specified character in string  strcmp, wcscmp, _mbscmp Compare two strings  strcoll, wcscoll, _stricoll, _wcsicoll, _strncoll, _wcsncoll, _strnicoll, _wcsnicoll Compare two strings using current locale code page information (_stricoll, _wcsicoll, _strnicoll, and _wcsnicoll are case-insensitive)  strcpy, wcscpy, _mbscpy Copy one string to another  strcspn, wcscspn, _mbscspn,  Find first occurrence of character from specified character set in string  _strdup, _wcsdup, _mbsdup Duplicate string  strerror Map error number to message string  _strerror Map user-defined error message to string  strftime, wcsftime Format date-and-time string  _stricmp, _wcsicmp, _mbsicmp Compare two strings without regard to case  strlen, wcslen, _mbslen, _mbstrlen Find length of string  _strlwr, _wcslwr, _mbslwr Convert string to lowercase  strncat, wcsncat, _mbsncat Append characters of string  strncmp, wcsncmp, _mbsncmp Compare characters of two strings  strncpy, wcsncpy, _mbsncpy Copy characters of one string to another  _strnicmp, _wcsnicmp, _mbsnicmp Compare characters of two strings without regard to case  _strnset, _wcsnset, _mbsnset Set first n characters of string to specified character  strpbrk, wcspbrk, _mbspbrk Find first occurrence of character from one string in another string  strrchr, wcsrchr,_mbsrchr Find last occurrence of given character in string  _strrev, _wcsrev,_mbsrev Reverse string  _strset, _wcsset, _mbsset Set all characters of string to specified character  strspn, wcsspn, _mbsspn Find first substring from one string in another string  strstr, wcsstr, _mbsstr Find first occurrence of specified string in another string  strtok, wcstok, _mbstok Find next token in string  _strupr, _wcsupr, _mbsupr Convert string to uppercase  strxfrm, wcsxfrm Transform string into collated form based on locale-specific information  vsprintf, _vstprint Write formatted output using a pointer to a list of arguments

引用 4 楼 liaoyungchun 的回复:[quote=引用 2 楼 JiangWenjie2014 的回复:] wcsspn = wc + s + spn = wchar_t + string + span wcscspn = wc + s + c + spn = wchar_t + string + counter + span 你知道《Counter Strike》的吧，就是反恐精英，counter是形容词，"相反"的意思，就是wcscspn的功能刚好和wcsspn相反。 strspn、wcsspn、_mbsspn、_mbsspn_l（返回第一个字符的索引，在字符串中，它不属于字符集。） strcspn、wcscspn、_mbscspn、_mbscspn_l（返回字符串中第一个匹配项的索引，字符的索引也是一组字。） 我要的就是这个，其它函数有吗？最好有个列表。。。[/quote]  还真没有，但是一般C库函数用多了自然就能记住了。或者网上找个手册，手册里面对每个函数都有详细解释的。

引用 5 楼 u010030181 的回复:[quote=引用 3 楼 liaoyungchun 的回复:] [quote=引用 1 楼 u010030181 的回复:] 你难道要把C语言库函数都弄懂？http://see.xidian.edu.cn/cpp/u/hanshu/ 我的意思不是这个，这个都能找到，是库函数名称的全称对应表。这样方便记忆。[/quote] 我个人认为不是很有必要，经常用的不是很多，记住经常用的就OK了，其他的有印象就OK了，当然你能记住那就更OK了……[/quote] 我目前在学习阶段，还不是很清楚哪些常用，可能写各种程序的不一样吧，所以现在在看《C语言参考手册这本书》，应该是全看一遍。

引用 3 楼 liaoyungchun 的回复:[quote=引用 1 楼 u010030181 的回复:] 你难道要把C语言库函数都弄懂？http://see.xidian.edu.cn/cpp/u/hanshu/ 我的意思不是这个，这个都能找到，是库函数名称的全称对应表。这样方便记忆。[/quote] 我个人认为不是很有必要，经常用的不是很多，记住经常用的就OK了，其他的有印象就OK了，当然你能记住那就更OK了……

引用 2 楼 JiangWenjie2014 的回复:wcsspn = wc + s + spn = wchar_t + string + span wcscspn = wc + s + c + spn = wchar_t + string + counter + span 你知道《Counter Strike》的吧，就是反恐精英，counter是形容词，"相反"的意思，就是wcscspn的功能刚好和wcsspn相反。 strspn、wcsspn、_mbsspn、_mbsspn_l（返回第一个字符的索引，在字符串中，它不属于字符集。） strcspn、wcscspn、_mbscspn、_mbscspn_l（返回字符串中第一个匹配项的索引，字符的索引也是一组字。） 我要的就是这个，其它函数有吗？最好有个列表。。。

引用 1 楼 u010030181 的回复:你难道要把C语言库函数都弄懂？http://see.xidian.edu.cn/cpp/u/hanshu/ 我的意思不是这个，这个都能找到，是库函数名称的全称对应表。这样方便记忆。


Question: 让一个数组进行大小排列，最少的次数为多少。。。

引用 3 楼 ForestDB 的回复:什么次数？比较的次数？移动的次数？交换的次数？ 就是最终按自己的要求排序，最有效地排序方法和次数是多少

引用 1 楼 pengzongjy 的回复:[quote=引用 楼主 pengzongjy 的回复:] 各位大神，一个数组排列所需的最少次数是多少呢？我第一次用的是N的平方次，第二次为1到N的相加次 第二次应该是1到N-1的相加次[/quote] 谢谢了，我后来找到一篇文章，和大家分享下http://blog.csdn.net/likezhaobin/article/details/6908257 感谢大家的回答。

什么次数？比较的次数？移动的次数？交换的次数？

普通的排序算法都是N平方，快速排序最好的时候是nlogn，最坏情况为O(n^2) 归并(merge sort)和堆排序(heap sort)复杂度都为nlog2(n)

引用 楼主 pengzongjy 的回复:各位大神，一个数组排列所需的最少次数是多少呢？我第一次用的是N的平方次，第二次为1到N的相加次 第二次应该是1到N-1的相加次


Question: 《C程序设计语言》第二版里面一个问题跪求解决！！

终于解决了，第77行跟第22行一样的错误居然没看到，本新手表示还是得多练啊 while (len = getline(line, MAXLEN) > 0)

发现第8行和22行有错 改正： char *lineptr[MAXLINES]; if ((nlines = readlines(lineptr, MAXLINES)) >= 0)  但还是不信啊，没有输出排序结果

C++还不会呐，准备自学

C中最容易错的地方是一堆char*, 用C++写吧，容易很多

高手新手都来看下呗，忘了注释可能看得会挺费劲


Question: Windows下如何使用API获取IO使用率，网络IO，iowait时间等信息

我不提平台的时候，都默认WindowsXP ＋VC6＋MSDN98.

引用 8 楼 zhao4zhong1 的回复:[quote=引用 7 楼 iDoPlay 的回复:] [quote=引用 6 楼 zhao4zhong1 的回复:] 搜“PDH” 恩 这是啥，，，大神能不能说的详细些。[/quote] 查MSDN是Windows程序员必须掌握的技能之一。 Performance Data Helper You can use the performance data provided by applications, services, and drivers to determine system bottlenecks and fine-tune system and application performance. The easiest way to display the performance data is to use the Performance Monitor application located in the Administrative Tools group.   If you need to collect performance data for your application, the easiest way to do this is to use the interface provided by the Performance Data Helper (PDH) interface. Applications that need more control over performance data collection can use the registry interface directly. This is the method that is used by the functions in PDH.DLL and by the Performance Monitor. It is more efficient for the Performance Monitor to use the registry interface, because it displays counters grouped by object. If you are retrieving individual counters, rather than a group of counters from a particular object, it is just as efficient to use the PDH interface.   This overview discusses both interfaces.   The PDH Interface  The Registry Interface  In addition, this overview discusses how to add your own performance counters, by creating an extensible performance DLL. For more information, see Adding Performance Counters.     [/quote]   多谢大神！我弱弱的问一句Performance Counter Class 与 Performance Data Helper有什么区别呢？ 前者用于.NET 平台？后者呢。

引用 10 楼 zhao4zhong1 的回复:我不提平台的时候，都默认WindowsXP ＋VC6＋MSDN98.  多谢大神！我搞明白了！

引用 7 楼 iDoPlay 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] 搜“PDH” 恩 这是啥，，，大神能不能说的详细些。[/quote] 查MSDN是Windows程序员必须掌握的技能之一。 Performance Data Helper You can use the performance data provided by applications, services, and drivers to determine system bottlenecks and fine-tune system and application performance. The easiest way to display the performance data is to use the Performance Monitor application located in the Administrative Tools group.   If you need to collect performance data for your application, the easiest way to do this is to use the interface provided by the Performance Data Helper (PDH) interface. Applications that need more control over performance data collection can use the registry interface directly. This is the method that is used by the functions in PDH.DLL and by the Performance Monitor. It is more efficient for the Performance Monitor to use the registry interface, because it displays counters grouped by object. If you are retrieving individual counters, rather than a group of counters from a particular object, it is just as efficient to use the PDH interface.   This overview discusses both interfaces.   The PDH Interface  The Registry Interface  In addition, this overview discusses how to add your own performance counters, by creating an extensible performance DLL. For more information, see Adding Performance Counters.

引用 6 楼 zhao4zhong1 的回复:搜“PDH” 恩 这是啥，，，大神能不能说的详细些。

其实我跟楼主一样，不知道具体的API的  以前做过驱动开发，大多数这种处理我是通过调用DeviceIoControl向设备发送控制命令来获取一些信息的 至于真正方便快捷的r3 API我就真的不清楚的，或许你可以参考下Nt和ZW开头的API`   例如: NtQueryXXXX或者ZwQueryXXX开头的API~

引用 3 楼 Luisfan 的回复:这个你要自己上MSDN查获取IO相关的资料  怎么找呢，连API的名字也不知道，我只知道获取进程IO信息的，不过 我还是决定一个一个看看！

这个你要自己上MSDN查获取IO相关的资料

WMI 应该可以吧

为什么都没有人。。。

搜“PDH”


Question: 为什么这个程序的输出结果是这样的，竟然有101？

int i=0; int a[50]={0};  for(i =0;i<50;i++) {  a[i]= (i+1)*2; printf("%d\t",a[i]); } printf("\n");

OK,你的写法够奇葩

数组下标越界

从a[0]开始的，，没有a[50]，后面的数。随机的。

a[i] , i == 5 ， 已经越界了

引用 3 楼 u011717322 的回复:应该不会出现你这样的问题。是不是你的编译器的问题？ 我用VS看了下，没有101.最后一个是100. 哦。上面的回答是对的，a[50]是没有的，随机值。

数组a的访问越界了，a[i]应该改为a[i-1]，C语言的数组下标是从0开始的。

int a[50]; a[0], a[1],...,a[49]  没有 a[50].


Question: linux 下用C写的一个TEA加密算法 加密字符串一旦比较长就会出问题，部分字符解密不了

随便瞄了一眼 for(i=len;i<len1-len;i++)//使用‘\0’补齐 *(en+i)='\0';   这里就错啦 去网上找一个吧 这种东西除非你是搞这方面的想学习，否则直接用别人写好的


Question: 看不懂 谁可以帮忙解释下吗

a=b=c=8;  !a&&b++&&c; !a为假，整个表达式为假，b++，c都不运算，a 8 b 8 c 8  a||--b||c--; a为真，整个表达式为真，--b，c--都不运算，a 8 b 8 c 8  a-8&&--b||c||b++; a-8 == 0，为假，(a - 8 && --b)为假，--b不运算，c为真，整个表达式为真，b++不运算，a 8 b 8 c 8  --a||b&&c||++b; --a为真，b不运算，(--a || b)为真，c运算，整个表达式为真，++b不运算，a 7 b 8 c 8

引用 8 楼 ForestDB 的回复:int a,b,c; a=b=c=8; !a&&b++&&c;  !a为假，整个表达式都为假，b++和c都不运算了，a，b，c都还是8。           如果表达式为真呢 输出的是什么

记得&&和||的短路，还有++的前与后。

!a&&b++&&c; printf("%d, %d, %d\n", a, b, c);   比如这个 !a&&b++&&c; 对 printf函数有影响吗

确实看不懂这样的代码

可以不用懂……无非锻炼你的记忆力， 记住&& ++ + -， --，||，|....运算符的优先级++、--放前后的问题，没啥价值……

C语言怪异代码大赛历届作品大全 1984～1996，1998，2000，2001，2004～2006，2011，2012 http://download.csdn.net/detail/zhao4zhong1/5538847

http://bbs.csdn.net/topics/370153775  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。  //C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+


Question: DECT的显示功能需要哪些知识实现

能输出了那么有输入么？

这个其实自解压的压缩包，安装过后一般解压在C盘，你也可以直接用7-zip解压。  引用 6 楼 liaocao2010 的回复:[quote=引用 1 楼 turingo 的回复:] LM3S9B96开发板的例程包中有免费的GUI开源库，你可以参考一下。 从这里http://www.embedinfo.com/list.asp?id=349#xz下载。 SW-DK-LM3S9B96-6288.exe这个有什么用啊，不是说源码么，怎么我安装了在注册表里面都找不到[/quote]

我也没具体做过，只是来凑凑热闹。

引用 1 楼 turingo 的回复:LM3S9B96开发板的例程包中有免费的GUI开源库，你可以参考一下。 从这里http://www.embedinfo.com/list.asp?id=349#xz下载。 SW-DK-LM3S9B96-6288.exe这个有什么用啊，不是说源码么，怎么我安装了在注册表里面都找不到

引用 4 楼 zhao4zhong1 的回复:信号强度 大神，您来了，显示那些要怎么做的，有没有具体的教程类的资料能看看啊

信号强度

显示文字总得也实现吧。 然后是 向上卷动 保存和恢复显示 要不要显示新号强度、当前电池容量？  别拿豆包不当干粮； 别当粘贴不是劳动。

引用 1 楼 turingo 的回复:LM3S9B96开发板的例程包中有免费的GUI开源库，你可以参考一下。 从这里http://www.embedinfo.com/list.asp?id=349#xz下载。 万分感谢，好人一生平安，祝你每天生活愉快


Question: 请教指针作为函数参数的问题

函数内部用的指针地址，和 参数指针 首先不一样。  另外  参数的指针 地址   函数内部可以多次调用。这样很方便。  而且 其它函数需要用到这个地址的时候 也可以继续使用。不会让其指向发生改变。  其它函数也可以用。

假设主函数里面是一个数组你++的话会改变指针多指向的值

我學到了

这种情况在别的语言中一样存在的，主要目的正如前面几位说的，就是为了保证形参的值不被改变

支持赵老师的答案，我们只是需要改变指针的时候，才直接传指针的地址，其他时候都是用的指针的副本

引用 4 楼 starytx 的回复:顶老赵。终于没说机器语言。 担心使用形参改变了传进来的实参的指向

指针可以移动，需要入参指向原始的位置。

当此函数多次被调用的时候，这样可以保存以前地址的值。

顶老赵。终于没说机器语言。 担心使用形参改变了传进来的实参的指向

怕原来指针的值丢了，无法再被free或delete了呗。

可能 Des 在其他地方还需要，如果不需要的话，可以直接使用。因为 C 函数参数是值复制的。

直接用的话，担心指针++后其指向被改变了。


Question: 通过串口发送结构体到pc

给分，留邮箱，晚上发到你邮箱

[quote=引用 8 楼 w74839520 的回复:] 首先 你用的是什么芯片，芯片有串口相关的资料。  我用的是TI的CC2530，串口部分的源代码跟这个链接的一样http://blog.163.com/a_hui8/blog/static/205830307201282085853248/  还请大哥指教

引用 11 楼 xiaoxiaobaibaicai 的回复:[quote=引用 10 楼 w74839520 的回复:] 给分，留邮箱，晚上发到你邮箱  ok啊，那就辛苦大哥了，595907836@qq.com[/quote]  引用 11 楼 xiaoxiaobaibaicai 的回复:[quote=引用 10 楼 w74839520 的回复:] 给分，留邮箱，晚上发到你邮箱  ok啊，那就辛苦大哥了，595907836@qq.com[/quote]    //名称：UART0收发字符串 //说明：从PC上通过串口调试助手发送字符串给目标板，并以“#”结束。 //目标板再将收到的信息通过串口回传给PC.实验使用UART0,波特率为19200 *****************************************/ /*引用********************************************/ #include <iocc2530.h> #include <string.h> /*宏定义*****************************************/ #define uint unsigned int #define uchar unsigned char #define rled P1_0 #define gled P1_1 /*函数声明和定义*******************************/ void inituart0(void); void uarttx_send_string(uchar *data,int len); //初始化串口0函数 void inituart0(void) {   CLKCONCMD &=0XBF;//系统时钟为32MHZ   while(CLKCONSTA & 0X40);//等待时钟稳定   CLKCONCMD &=0XF8;//主时钟频率为32MHZ      PERCFG &=0XFE;//设USART0的ALT 1   P0SEL |=0X3C;//P0口2、3、4、5做外设   P2DIR &=0X3F;//P0外设优先级USART0最高      U0CSR |=0X80;//设USART0 工作方式为 UART   U0GCR |=9;   U0BAUD |=59;//设波特率   UTX0IF=0;//UART0 TX中断标志位清0 } //串口发送字符串函数 void uarttx_send_string(uchar *data,int len) {   int j;   for(j=0;j<len;j++)   {     U0DBUF=*data++;     while(UTX0IF==0);     UTX0IF=0;   } } /*变量定义和赋值*******************************/ uchar recdata[30]=""; uchar rxtxflag=1;//接收发送标志 1：接收   3：发送 uchar temp=0;//无数据接收到时，设为0 uint datanumber=0;//接收字符串计数 /*主函数*******************************/ void main(void) {   P1DIR=0X03;//初始化LED   rled=0;   gled=0;        inituart0();//初始化串口   U0CSR |=0X40;//USART0 接收使能   IEN0 |=0X04;//usart0 接收中断使能   EA=1;//开总中断      while(1)   {     if(rxtxflag==1)//接收状态     {       gled=!gled;//接收指示       if(temp!=0)       {         if((temp!='#')&&(datanumber<20))//'#'被定义为结束字符，最多能接收20个字符         {           recdata[datanumber++]=temp;         }         else         {           rxtxflag=3;//进入发送状态         }         temp=0;       }     }          if(rxtxflag==3)//发送状态     {       gled=0;       rled=1;//发送状态指示       U0CSR &=~0X40;//USART0 接收禁止       uarttx_send_string(recdata,datanumber);//发送字符串       uarttx_send_string("\n",sizeof("\n"));//发送换行符       U0CSR |=0X40;//USART0 接收使能       rxtxflag=1;//恢复到接收状态       datanumber=0;//指针归0       rled=0;//关发送指示     }   } } /*接收中断函数*******************************/ //串口接收一个字符,一旦有数据从串口传至CC2530， //则进入中断，将接收到的数据赋值给变量temp。 #pragma vector=URX0_VECTOR __interrupt void UART0_ISR(void) {   URX0IF=0;//清标志   temp=U0DBUF;//读取缓存到temp }

引用 10 楼 w74839520 的回复:给分，留邮箱，晚上发到你邮箱  ok啊，那就辛苦大哥了，595907836@qq.com

首先 你用的是什么芯片，芯片有串口相关的资料。  如果是ARM 是有寄存器可以设置 手法 然后  封装成 void channel_send_data(void const *p, size_t size); void channel_recv_data(void *p, size_t size);  void send(zllRemoteLinkedTargetList_t const *data) {     channel_send_data(data, sizeof(*data)); }   void recv(zllRemoteLinkedTargetList_t *data) {     channel_recv_data(data, sizeof(*data)); }  这样的手法函数，把主要发送的数据 送给这个函数就行了。   另外楼主要是妹子的话，我很乐意教你。哈哈哈哈~~:-)

引用 4 楼 luciferisnotsatan 的回复:注意下大小端就行了 不太明白你的意思，能说仔细点吗

引用 3 楼 skyman1991 的回复:楼主是在问节点怎么发送还是pc端怎么接收？ pc端怎么接收，就是希望将灯设备的信息通过串口在pc端显示

引用 1 楼 user-5 的回复:void channel_send_data(void const *p, size_t size); void channel_recv_data(void *p, size_t size);  void send(zllRemoteLinkedTargetList_t const *data) { 	channel_send_data(data, sizeof(*data)); }  void recv(zllRemoteLinkedTargetList_t *data) { 	channel_recv_data(data, sizeof(*data)); } 谢谢解答，不过这好像不是我想要的，我说仔细点，就是我这套设备是ti的zll套件，有一个遥控器和3个灯，遥控器可以和多盏灯注册组网，现在我想通过串口把已经和遥控器注册的灯设备的信息在pc端显示，串口部分的源代码跟这个链接的一样http://blog.163.com/a_hui8/blog/static/205830307201282085853248/，希望你能帮我看看，可以加分的

注意下大小端就行了

楼主是在问节点怎么发送还是pc端怎么接收？

直接发送不就行了吗？


Question: 栈问题

（*s)->next;错误的地方看一看看报错自己修改修改在

mg=https://forum.csdn.net/PointForum/ui/scripts/csdn/Plugin/003/monkey/2.gif][/img]  哦哦 不小心 移了 一个 i

*S->top++ = e; 运算符 suffix ++ 优先级最低吧  这样 编译期会有错误吧。。。 结构对象被打开了 不能++了吧。。。 我这里是不能加了啊。。。  我对上边 大哥 给出的 C++优先级表 的 描述语 有些不太理解 //| ++               | Postfix increment                       | None    后缀自增 优先级老高了 但我这里 很低啊。。  g++ t3.cpp -o t3pp out : 4  //  #include<stdio.h> struct aa     {         int aa;         int bb;     };      int main()     {         int a = 2;         int b = 2 * a++;         printf("%d\n", b);         return 0;                 //struct aa aa1 = {};        //aa1 + 1 = 0;        //* (char*)(&aa1 +1) = 0;     }  另外 除了楼主说的 那个表达式 优先级有些错误外 其他代码的逻辑 没有细看mg=https://forum.csdn.net/PointForum/ui/scripts/csdn/Plugin/003/monkey/2.gif][/img]  最后 加油吧！

引用 楼主 helloworld1014 的回复:/* **栈的实现 */ #include "datastruct.h"  /* **栈的存储结构 */ #define STACK_INIT_SIZE 100				//存储空间初始分配量 #define STACKINCREMENT 10				//存储空间 分配增量 typedef struct{ 	ElemType *base;						//栈底指针 	ElemType *top;						//栈顶指针 	int stacksize;						//当前分配存储空间 }SqStack;  /* **构造一个空栈 */ Status InitStack(SqStack* S) { 	S->base = (ElemType*)malloc(STACK_INIT_SIZE * sizeof(ElemType)); 	if(S->base == NULL) 		return ERROR; 	else{ 		S->base = S->top;					//空栈 		S->stacksize = STACK_INIT_SIZE; 		return OK; 	} }  /* **获取站定元素，但不删除该元素 */ Status GetTop(SqStack* S, ElemType *e) { 	if(S->base == S->top) 		return ERROR; 	*e = *(S->top-1); 	return OK; }  /* **向栈插入新的元素 */ Status Push(SqStack* S, ElemType e) { 	if(S->top - S->base >= S->stacksize){              //判断栈是否满 		S->base = (ElemType*)realloc(S->base, (STACKINCREMENT+STACKINCREMENT) * sizeof(ElemType)); 		if(S->base == NULL) 			exit(OVERFLOW); 		else{ 			S->top = S->base + S->stacksize; 			S->stacksize += STACKINCREMENT; 		} 	} 	*S->top++ = e;               //程序跑到这就报错，不知道什么原因 	return OK; }  int main(int argc, char* argv[]) { 	SqStack S; 	int i; 	InitStack(&S); 	for (i=0;i<10;i++) 	{ 		Push(&S,i); 	} 	system("pasue"); 	return 0; }  *S->top++ = e;               //程序跑到这就报错，不知道什么原因 大家看看啥原因？ 看到你源码的第26行，我就不往下看了，先解决这个问题吧。

整个写法和思路都有问题，指针不知所向，参考http://blog.csdn.net/hopeyouknow/article/details/6725049

//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+


Question: 关于C语言的语法问题

跟编译器有关，不要这样用就能避免问题。

引用 13 楼 liulianglin 的回复:[quote=引用 3 楼 xwuno1 的回复:] 这个跟printf的运算顺序是没有关系，问题在于入栈和出栈。首先按顺序读取i， ++i，然后在最后出栈的时候就先运行++i，后输出i的了。 如果i= 1，则按照考试的要求的话，printf("%d,%d\n", i, i++)的结果就是2， 1。 你写的这个例子不是很明显理解这个问题，但是最好不要写这样的代码。  PS #3楼的大神不知有没有试运行过代码，，，，真实输出应该是  2 2 [/quote] 个人认为 输出结果和编译器、操作系统有关，#12是我机器的反汇编，输出结果是1 ，1 而且，在这行代码执行之后，继续printf出来i，依然是1（反汇编为证）

引用 13 楼 liulianglin 的回复:[quote=引用 3 楼 xwuno1 的回复:] 这个跟printf的运算顺序是没有关系，问题在于入栈和出栈。首先按顺序读取i， ++i，然后在最后出栈的时候就先运行++i，后输出i的了。 如果i= 1，则按照考试的要求的话，printf("%d,%d\n", i, i++)的结果就是2， 1。 你写的这个例子不是很明显理解这个问题，但是最好不要写这样的代码。  PS #3楼的大神不知有没有试运行过代码，，，，真实输出应该是  2 2 [/quote]这个具体的是根据编译器不同而不同，我说的是按照考试要求的话，结果是2,1。你可以去看看程序员面试宝典上面有这类题目。

引用 3 楼 xwuno1 的回复:这个跟printf的运算顺序是没有关系，问题在于入栈和出栈。首先按顺序读取i， ++i，然后在最后出栈的时候就先运行++i，后输出i的了。 如果i= 1，则按照考试的要求的话，printf("%d,%d\n", i, i++)的结果就是2， 1。 你写的这个例子不是很明显理解这个问题，但是最好不要写这样的代码。  PS #3楼的大神不知有没有试运行过代码，，，，真实输出应该是  2 2

printf("%d,%d\n",i,++i); 00AB3735  mov         eax,dword ptr [i]   00AB3738  add         eax,1   00AB373B  mov         dword ptr [i],eax   00AB373E  mov         esi,esp   00AB3740  mov         ecx,dword ptr [i]   00AB3743  push        ecx   00AB3744  mov         edx,dword ptr [i]   00AB3747  push        edx   00AB3748  push        offset string "%d,%d\n" (0AB5740h)   00AB374D  call        dword ptr [__imp__printf (0AB82DCh)]   00AB3753  add         esp,0Ch   00AB3756  cmp         esi,esp   00AB3758  call        @ILT+315(__RTC_CheckEsp) (0AB1140h)    这条指令在win7 32bit反汇编，可以看到执行顺序是从左至右

就是有规定我也不会去写这样的代码。

呵呵，细看一下，8楼还应该看看1楼版主和5楼的回复。

引用 8 楼 wojiaohuangyu 的回复:从右到左，我们老师今天才讲过。。。。         2楼、4楼、7楼的链接或建议都忽视么。你们老师是怎么讲的？是否你们老师只是讲的是函数入栈的顺序（尽管不同的函数调用协议入栈顺序并不相同）？而楼主提的却是”参数运算的顺序“，你是否需要再确认一下？

从右到左，我们老师今天才讲过。。。。

像这种东西，是跟编译器有关的，楼主最好还是不要花太多时间在这上边

引用 3 楼 xwuno1 的回复:这个跟printf的运算顺序是没有关系，问题在于入栈和出栈。首先按顺序读取i， ++i，然后在最后出栈的时候就先运行++i，后输出i的了。 如果i= 1，则按照考试的要求的话，printf("%d,%d\n", i, i++)的结果就是2， 1。 你写的这个例子不是很明显理解这个问题，但是最好不要写这样的代码。刚刚好相反 和入栈出栈没什么关系 和 运算顺序 有那么点关系  你得明白一点 进栈的是 这些表达式的求值结果 而不是这些表达式  foo(1+3) 进栈数据是 4 而不是1+3 明白吗 先完成求值 再进栈 完全没问题  而这里求值顺序不同可能出现不同的求职结果  然后不同的求值结果 都按照你所说的顺序入栈  毫无违和感

C/C++ 语言对于函数参数的计算顺序没有要求。 这就是为什么建议 短路表达式运算符不建议重载的原因。

尽量避免写这种含糊不清的代码，勤快点分开多写几行起码质量有保证

参考置顶帖子http://bbs.csdn.net/topics/370153775

没有 请输入长度最少是6的字符串


Question: 一个查看日志的工具

引用 7 楼 door8 的回复:  不要重复造轮子 一个log4cxx开源库搞定. 嗯，谢谢！

不要重复造轮子 一个log4cxx开源库搞定.

引用 5 楼 zhao4zhong1 的回复:建议楼主学会使用  C:\>findstr /? 在文件中寻找字符串。  FINDSTR [/B] [/E] [/L] [/R] [/S] [/I] [/X] [/V] [/N] [/M] [/O] [/F:file]         [/C:string] [/G:file] [/D:dir list] [/A:color attributes] [/OFF[LINE]]         strings [[drive:][path]filename[ ...]]    /B         在一行的开始配对模式。   /E         在一行的结尾配对模式。   /L         按字使用搜索字符串。   /R         将搜索字符串作为一般表达式使用。   /S         在当前目录和所有子目录中搜索匹配文件。   /I         指定搜索不分大小写。   /X         打印完全匹配的行。   /V         只打印不包含匹配的行。   /N         在匹配的每行前打印行数。   /M         如果文件含有匹配项，只打印其文件名。   /O         在每个匹配行前打印字符偏移量。   /P         忽略有不可打印字符的文件。   /OFF[LINE] 不跳过带有脱机属性集的文件。   /A:attr    指定有十六进位数字的颜色属性。请见 "color /?"   /F:file    从指定文件读文件列表 (/ 代表控制台)。   /C:string  使用指定字符串作为文字搜索字符串。   /G:file    从指定的文件获得搜索字符串。 (/ 代表控制台)。   /D:dir     查找以分号为分隔符的目录列表   strings    要查找的文字。   [drive:][path]filename              指定要查找的文件。  除非参数有 /C 前缀，请使用空格隔开搜索字符串。 例如: 'FINDSTR "hello there" x.y' 在文件 x.y 中寻找 "hello" 或 "there"。'FINDSTR /C:"hello there" x.y' 文件 x.y  寻找 "hello there"。  一般表达式的快速参考:   .        通配符: 任何字符   *        重复: 以前字符或类别出现零或零以上次数   ^        行位置: 行的开始   $        行位置: 行的终点   [class]  字符类别: 任何在字符集中的字符   [^class] 补字符类别: 任何不在字符集中的字符   [x-y]    范围: 在指定范围内的任何字符   \x       Escape: 元字符 x 的文字用法   \<xyz    字位置: 字的开始   xyz\>    字位置: 字的结束  有关 FINDSTR 常见表达法的详细情况，请见联机命令参考。  C:\> 谢谢！以前确实没用过，以后搜索的时候，可以试试！

引用 3 楼 zhao4zhong1 的回复:最多能容纳多少行？ 有源码，可以自己定义，我目前用了4K的缓冲区 显示数据，用的是Listview，不知道能显示多少行 保存的数据，理论上在32机器，是2G吧(因为在内存里，但实际会低很多，几十M，几百M?) 只是自己为了方便，花了一下午弄的，自己觉得听方便的，就拿出来共享一下，没啥价值

最多能容纳多少行？

引用 1 楼 user-3 的回复:实现机制呢?  根DebugView, 区别在哪里呢, 除了debugview要手动设置过虑外.  在代码中使用的复杂性又是怎么样的呢?    效率怎么样呢?  ....还有很多问题, 不一一例举了. 实现机制，共享内存，一些同步的东西， 效率还行吧 使用很简单，一个.h，一个.lib


Question: 函数可以返回局部变量么？

楼上说的很详细  <<effective c++>> 这本书里写得更详细

返回值是可以的，但是不能返回地址。这个比较重要

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

int具有值语义， 返回的拷贝，所以没有问题。  但是int*或int&是引用语义， 没有返回拷贝， 所以不能返回局部变量的引用或地址。

可以返回局部变量，一般所说的是不能返回局部变量的地址（比如说一个局部对象的指针）

函数可以返回局部变量, 但一般不能返回局部变量指针. 返回局部变量, 只要是基本的数据类型, 那是没有问题的. 但如果返回的是一个类, 或者结构体就是需要考虑内部是否有指针, 如果有指针, 也可能是不安全的.

引用楼上说的很详细<<effective c++>> 这本书里写得更详细  哪章哪节？

引用 1 楼 Baoge_leopard 的回复:一般的来说，函数是可以返回局部变量的。 局部变量的作用域只在函数内部，在函数返回后，局部变量的内存已经释放了。因此，如果函数返回的是局部变量的值，不涉及地址，程序不会出错。但是如果返回的是局部变量的地址(指针)的话，程序运行后会出错。因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放了，这样指针指向的内容就是不可预料的内容，调用就会出错。准确的来说，函数不能通过返回指向栈内存的指针(注意这里指的是栈，返回指向堆内存的指针是可以的)。 Up

可以的，但是不能返回局部变量的地址   int *M()   {     int a=2;     return &a;    /* bad */   }

引用 1 楼 Baoge_leopard 的回复:一般的来说，函数是可以返回局部变量的。 局部变量的作用域只在函数内部，在函数返回后，局部变量的内存已经释放了。因此，如果函数返回的是局部变量的值，不涉及地址，程序不会出错。但是如果返回的是局部变量的地址(指针)的话，程序运行后会出错。因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放了，这样指针指向的内容就是不可预料的内容，调用就会出错。准确的来说，函数不能通过返回指向栈内存的指针(注意这里指的是栈，返回指向堆内存的指针是可以的)。 +1

一个函数return后，这个函数即结束，其中所有的在该函数内声明定义的变量全部死亡～～ 我们之所以能return a  是因为： 当程序走到reuturn a这句话的时候，其实是找了个临时的空间，复制一个a的副本，然后将这个副本返回，因为a已经死了～～  当然，其实单纯从学习c++的角度而言，你暂时不需要知道这么详细，你只需要理解了1楼说的话就OK了   其他这些你学多了再回头来理解


Question: 请教：这段time函数应该怎么理解

struct tm {   int tm_sec; /* seconds */   int tm_min; /* minutes */   int tm_hour; /* hours */   int tm_mday; /* day of the month */   int tm_mon; /* month */   int tm_year; /* year */   int tm_wday; /* day of the week */   int tm_yday; /* day in the year */   int tm_isdst; /* daylight saving time */   }    库结构体 定义的东西。可以调用这个结构体

time_t: arithmetic types capable of representing times

理解和讨论之前请先学会如何观察！  VS IDE中，在不明白的符号上点鼠标右键，选转到定义。

time_t是一个struct结构，结构定义在time.h头文件里面    struct tm {   int tm_sec; /* seconds */   int tm_min; /* minutes */   int tm_hour; /* hours */   int tm_mday; /* day of the month */   int tm_mon; /* month */   int tm_year; /* year */   int tm_wday; /* day of the week */   int tm_yday; /* day in the year */   int tm_isdst; /* daylight saving time */   }

就把它当成int这样的类型来理解。 多看函数参考手册，或者man page。

是个结构体变量这段代码是用time给t赋值，再用locatetime把t转换成本地时间并存到ptm中。


Question: 菜鸟问基础问题

参考 http://www.cppblog.com/luqingfei/archive/2010/08/06/122435.html Windows操作系统干脆为用户程序安排好了一切。具体表现在为用户程序的代码段、数据段和堆栈段全部预定义好了段描述符。这些段的起始地址为0，限长为ffffffff，所以用它们可以直接寻址全部的4GB地址空间。程序开始执行的时候，CS，DS，ES和SS都已经指向了正确的描述符，在整个程序的生命周期内，程序员不必改动这些段寄存器，也不必关心它们的值究竟是多少（实际上，想改也改不了）。

依稀记得32位的机器上这几个段地址就一样了。 可以找8086的汇编，再找找32位汇编，一查就知。


Question: 求c语言大神

正序倒序一起来 /*************************************************************************     > File Name: f.c     > Author: Jukay     > Mail: hellojukay@gmail.com      > Created Time: 2014年11月09日 星期日 19时00分44秒  ************************************************************************/  #include<stdio.h> void print(unsigned); int main() { 	unsigned int a; 	scanf("%u",&a); 	printf("%d",a); 	printf("\n"); 	print(a); 	return 0; }  void print(unsigned int a) { 	printf("%d",a%10); 	if(a/10 == 0) 		; 	else 		print(a/10); }

正序太简单，还是倒叙吧 /*************************************************************************     > File Name: f.c     > Author: Jukay     > Mail: hellojukay@gmail.com      > Created Time: 2014年11月09日 星期日 19时00分44秒  ************************************************************************/  #include<stdio.h> void print(unsigned); int main() { 	unsigned int a; 	scanf("%u",&a); 	print(a); 	return 0; }  void print(unsigned int a) { 	printf("%d",a%10); 	if(a/10 == 0) 		; 	else 		print(a/10); }

正序输出，那么可以把除10取余的值倒叙放到数组里。

long lNum = 0L; 	int i = 0; 	int nArray[6] = { 0 }; 	scanf_s("%ld", &lNum);  	while (i < 6 && lNum > 0) 	{ 		nArray[i++] = (int)lNum % 10L; 		lNum /= 10L; 	}  	while (--i >= 0) 	{ 		printf("%d", nArray[i]); 	} 	printf("%d\n");

给你个逆序输出的：  int n = 0; 	cout<<"请输入n:"<<endl; 	cin>>n; 	cout<<"逆序如下："<<endl;  	while( n != 0 )  //一直循环到n 等于 0时，表示n此时是一个一位数了，也就是输入数字的最高位，退出循环 	{ 		cout<<n%10;  //n%10 标示n对10求余，结果是n的个位数 将这个个位数输出 比如：123 % 10，结果就是3 		 		n /= 10;//n/10 标示n对10求商，结果是n除了个位数意外的数，比如：n如果等于123，n /= 10的话，n就等于12，	  	} 	cin>>n;


Question: 高分在线等（纹理坐标）

我印象纹理坐标有几种寻址方式，当uv 坐标不在 [0,1]区间时也有意义。 opengl 的话，可以搜索 GL_TEXTURE_WRAP_S , GL_TEXTURE_WRAP_T  这类关键字，能够看到解释

参考 http://www.cppblog.com/flashboy/archive/2009/01/03/71056.html

自顶


Question: 下面写的这个函数为什么有内存泄露？

同意楼上的，你这个函数返回的是个动态数组，用完之后要free，不然它还是在的。还有，你这循环1000*1000次，不说是这么一个大函数，就算只是一个小的赋值操作，都要等一下才能看的到结果。

//计算协方差的逆阵     double** E_inv = MatrixInverse(cov,nBand);  这个E_inv 没释放

还有谁知道原因吗？

引用 5 楼 u013580497 的回复:不能重复利用吗？我觉得那个函数里面的E_inv、x_u、temp三个指针占用的空间应该是重复利用的，但结果是随调用次数增加，内存占用也增加

不能重复利用吗？

引用 2 楼 u013163178 的回复:同意楼上的，只是这里改一下 free(temp);temp = NULL; free(x_u);temp = NULL; 改成 free(temp);temp = NULL; free(x_u);x_u = NULL;  嗯，这里粗心了，但改了还是一样的结果，占用的内存感觉没被释放

引用 1 楼 user-6 的回复:看看这个函数调用double** E_inv = MatrixInverse(cov,nBand);  这个函数是这样的：  //矩阵的求逆 double** MatrixInverse(double **A,int M)  { 	int i,j,k; 	double** A_inv = CreateMatrix(M,M); 	double** AE = CreateMatrix(M,2*M); 	for (i=0;i<M;i++) 	{ 		memset(A_inv[i],0,sizeof(double)*M); 		memset(AE[i],0,sizeof(double)*2*M); 	} 	for(i=0;i<M;i++)     {         for(j=0;j<M;j++)         {             AE[i][j]=A[i][j];         }     } 	for(i=0;i<M;i++)     {         for(j=M;j<2*M;j++)         {             if(i==(j-M))             {                 AE[i][j]=1;             }             else             {                 AE[i][j]=0;             }         }     } 	/*****************求逆模块***********************/     for(i=0;i<M;i++)     {         if(AE[i][i]==0)         {             for(k=i;k<M;k++)             {                 if(AE[k][k]!=0)                 {                     for(int j=0;j<2*M;j++)                     {                         double temp;                         temp=AE[i][j];                         AE[i][j]=AE[k][j];                         AE[k][j]=temp;                     }                     break;                 }             }             if(k==M)             {                 printf("该矩阵不可逆！\n");             }         }         for(j=2*M-1;j>=i;j--)         {             AE[i][j]/=AE[i][i];         }         for(k=0;k<M;k++)         {             if(k!=i)             {                 double temp=AE[k][i];                 for(j=0;j<2*M;j++)                 {                     AE[k][j]-=temp*AE[i][j];                 }             }         }     }     /*****************获取逆矩阵***********************/ 	 for(i=0;i<M;i++)     {         for(j=M;j<2*M;j++)         {             A_inv[i][j-M]=AE[i][j];         }     } 	 for (i=0;i<M;i++) 	 { 		 free(AE[i]); 		 AE[i] = NULL; 	 } 	 free(AE); 	 AE = NULL; 	 return A_inv; }  //创建一个m行n列的double型矩阵 double** CreateMatrix(int m, int n) { 	double** Matrix; 	int i;     Matrix = (double **) malloc(sizeof(double *) * m);     for(i = 0; i < m; i++)     {             Matrix[i] = (double *) malloc(sizeof(double) * n);     }     return Matrix; }


Question: 基于EasyX Library的吃果子游戏设计

创意还行。找个PPMM先给画个萌点的素材。


Question: 运行这个程序怎么会出现这个结果

引用 楼主 qq_21327741 的回复:#include <stdio.h> #include <math.h> void main() {       float x,y;        printf("请输入任意一个x的值：x=:");    scanf("%f",&x);    if (x<1)    {  y=x;       printf("y的值为：y=:%f\n",y);        }    else if (x>=10)    {  y=3*x-1;       printf("y的值为：y=:%f\n",y);    }    else        y=2*x-5;        printf("y的值为：y=:%f\n",y); } 输出结果没错，进了if（x<1）满足这个条件了，直接就输出了。如果不是要这个结果，你的逻辑有问题

太大了~~~公司邮件发不出去！！ 你到我网盘去下载吧！！ http://pan.baidu.com/s/1o6C3hJO

引用 11 楼 qq_21327741 的回复:[quote=引用 8 楼 cxzzwb 的回复:] 我怀疑的是，你没加{}的时候，编译器只把y=2*x-5; 这一句当做是最后一个eles块内的语句，而把最后一句printf当做是main块内的，所以运行的时候并没有执行y=2*x-5;  我刚做了个测试  main() { 	   float x,y;            printf("请输入任意一个x的值：x=:");        scanf("%f",&x);        if (x<1)        {   	      y=x;           printf("y的值为：y=:%f\n",y);        }        else if (x>=10)        { 	      y=3*x-1;           printf("y的值为：y=:%f\n",y);        }        /*else        {        	  y=2*x-5;           printf("y的值为：y=:%f\n",y);        }*/        else           y=2*x-5;           y=2*x-5;           printf("y的值为：y=:%f\n",y);     }  注意，我多了一行y=2*x-5; 得到的输出结果为 y=:0.500000 y=:-4.000000  所以可以证明我刚刚的推断是正确的！！ 请问你用得是什么软件写的c语言，能把软件包发给我吗，我的是win7系统的，邮箱895007098@qq.com.谢谢[/quote] 我用的是Dev-C++的，稍后发你

引用 8 楼 cxzzwb 的回复:我怀疑的是，你没加{}的时候，编译器只把y=2*x-5; 这一句当做是最后一个eles块内的语句，而把最后一句printf当做是main块内的，所以运行的时候并没有执行y=2*x-5;  我刚做了个测试  main() { 	   float x,y;            printf("请输入任意一个x的值：x=:");        scanf("%f",&x);        if (x<1)        {   	      y=x;           printf("y的值为：y=:%f\n",y);        }        else if (x>=10)        { 	      y=3*x-1;           printf("y的值为：y=:%f\n",y);        }        /*else        {        	  y=2*x-5;           printf("y的值为：y=:%f\n",y);        }*/        else           y=2*x-5;           y=2*x-5;           printf("y的值为：y=:%f\n",y);     }  注意，我多了一行y=2*x-5; 得到的输出结果为 y=:0.500000 y=:-4.000000  所以可以证明我刚刚的推断是正确的！！ 请问你用得是什么软件写的c语言，能把软件包发给我吗，我的是win7系统的，邮箱895007098@qq.com.谢谢

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

很简单，，你加大括号，被程序运行了，

引用 6 楼 qq_21327741 的回复:[quote=引用 3 楼 u013163178 的回复:] #include <stdio.h> #include <math.h> void main() {       float x,y;        printf("请输入任意一个x的值：x=:");    scanf("%f",&x);    if (x<1)    {  y=x;//这里y被赋值为0.5       printf("y的值为：y=:%f\n",y);        }    else if (x>=10)//这后面的代码都不执行    {  y=3*x-1;       printf("y的值为：y=:%f\n",y);    }    else        y=2*x-5;//不执行        printf("y的值为：y=:%f\n",y);//执行 请问你是用什么软件写的这个程序，软件发给我可好，邮箱：895007098@qq.com[/quote] 我用linux下的vim

#include <stdio.h> #include <math.h> void main() {       float x,y;        printf("请输入任意一个x的值：x=:");    scanf("%f",&x);    if (x<1)    {  y=x;       printf("y的值为：y=:%f\n",y);        }    else if (x>=10)    {  y=3*x-1;       printf("y的值为：y=:%f\n",y);    }    else {        y=2*x-5;        printf("y的值为：y=:%f\n",y);     } }  if 和else当条件满足时只会执行后面的第一句语句，加上{}后除外。

引用 3 楼 u013163178 的回复:#include <stdio.h> #include <math.h> void main() {       float x,y;        printf("请输入任意一个x的值：x=:");    scanf("%f",&x);    if (x<1)    {  y=x;//这里y被赋值为0.5       printf("y的值为：y=:%f\n",y);        }    else if (x>=10)//这后面的代码都不执行    {  y=3*x-1;       printf("y的值为：y=:%f\n",y);    }    else        y=2*x-5;//不执行        printf("y的值为：y=:%f\n",y);//执行 请问你是用什么软件写的这个程序，软件发给我可好，邮箱：895007098@qq.com

为什么else后不加大括号的时候就只调用printf，上面的那一个y=2*x-5怎么就不调用。 而如果换成这样的话，换成这样，为什么那个y=2*x-5就能被调用 #include <stdio.h> #include <math.h> void main() {       float x,y;         printf("请输入任意一个x的值：x=:");    scanf("%f",&x);    if (x<1)    {  y=x;//这里y被赋值为0.5       printf("y的值为：y=:%f\n",y);         }      if (x>=10)    {  y=3*x-1;       printf("y的值为：y=:%f\n",y);    }    else        y=2*x-5        printf("y的值为：y=:%f\n",y)

else {        y=2*x-5;        printf("y的值为：y=:%f\n",y); } 大括号括起来 else的分支，如果不给大括号，默认是紧接着的一行代码

楼上可能正解

你最后的else没加  大括号对，导致else里只有y=2*x-5;有效。。 后面一句 printf("y的值为：y=:%f\n",y); 无论如何都会被调用


Question: 关于递归的运行错误问题

引用 5 楼 zhao4zhong1 的回复:“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出  了解基本工作原理和主要递归因素，从这个帖子不但解决了问题，还更深入理解递归函数的运用了，谢谢你!

引用 3 楼 u013163178 的回复:你这哪里是求阶乘啊，你是求m的n次幂 #include <stdio.h>  long Power_loop (int m,int n) {     long result = 1;     for (int i = 1; i <= n;i++){         result *= m;     }     return result; }  long PowerRecursive (int a,int b) {     if (b > 1)//改这里         return PowerRecursive(a,b-1) * a;     else         return a;//改这里      } int main(void) {     printf("loop = %ld\n",Power_loop(9,8));     printf("Recursive = %ld\n",PowerRecursive(9,8));     return 0; } 如果是求阶乘的话，就该这么写啊 #include<stdio.h> int f(int n) { 	if(n == 1 || n == 2) 	return n; 	else 	return f(n-1)*n; }  int main() { 	int n; 	scanf("%d",&n); 	printf("%d",f(5)); 	return 0; } 感谢，您用两个例子让我更清晰了解我的练习题的问题了，确实算的是次幂，只是用了递归的思想去完成。

递归没有退出条件，即没有对b值的边界没有判断，所以会一直递归下去。另外，递归函数会不断申请函数栈空间，死循环会造成栈溢出，所以会有段错误。

引用 1 楼 wufeng55 的回复:你的程序有问题啊，递归的函数是个死递归，a的值不变，只是b的值一直在变化，函数里的if语句执行不了，怎么能return呢？ 你好，程序确实有问题，我已经修改好了。这个程序算的是一个数的阶乘，所以a的值是一直不变的 修改后正确的应该是这样的：  #include <stdio.h>  long Power_loop (int m,int n) {     long result = 1;     for (int i = 1; i <= n;i++){         result *= m;     }     return result; }  long PowerRecursive (int a,int b) {     if (b > 0)         return PowerRecursive(a,b-1) * a;     else         return 1;      } int main(void) {     printf("loop = %ld\n",Power_loop(9,8));     printf("Recursive = %ld\n",PowerRecursive(9,8));     return 0; }


Question: 为什么执行这个程序时会有错误

楼主应该是想用变长数组，新版本支持，测试环境GCC 4.8.2，支持，但是你这样也不对，即使用变长数组，但在使用前要进行申明,如：int a=10,b=10; char chars [a][b],需这样，即使用使用变长数组也得在使用前对维变量进行赋值的

钻石级C/C++er都不用QQ、微信这种经常打断编程思路的工具。

引用 6 楼 zhao4zhong1 的回复:#include <stdio.h> int main() {     int i,j,temp,a[6];      printf("请输入六个整数（空格间隔）：\n");     for (i=0;i<6;i++) scanf("%d",&a[i]);     for (i=0;i<5;i++) {         for (j=i+1;j<6;j++) {             if (a[i]>a[j]) {                 temp=a[i];a[i]=a[j];a[j]=temp;             }         }     }     printf("排序后:\n");     for (i=0;i<6;i++) printf("%d ",a[i]);     return 0; }  老师，能否把你的软件发到我的邮箱上，我的邮箱是895007098@qq.com. 您的QQ是，或者微信账号是，能否告诉我，这样我在遇到一些不懂的问题就可以方便向您请教。谢谢。

引用 12 楼 zhouxiaofeng1021 的回复:int i,j,temp,a[i]; 这里a[i]错了 不能这样写的 i值必须是常量，这是编译时候后就确定控件大小，静态分配 改成a[6]就可以 如果用动态大小数据 需要分配堆内存 分配堆内存是什么意思？

a[i] 静态数组定义需要用常量

引用 7 楼 qq_21327741 的回复:[quote=引用 6 楼 zhao4zhong1 的回复:] #include <stdio.h> int main() {     int i,j,temp,a[6];      printf("请输入六个整数（空格间隔）：\n");     for (i=0;i<6;i++) scanf("%d",&a[i]);     for (i=0;i<5;i++) {         for (j=i+1;j<6;j++) {             if (a[i]>a[j]) {                 temp=a[i];a[i]=a[j];a[j]=temp;             }         }     }     printf("排序后:\n");     for (i=0;i<6;i++) printf("%d ",a[i]);     return 0; }  老师，能否把你的软件发到我的邮箱上，我的邮箱是895007098@qq.com. 您的QQ是，或者微信账号是，能否告诉我，这样我在遇到一些不懂的问题就可以方便向您请教。谢谢。[/quote] 有问题的时候，应该上论坛来讨论。 你不能只图自己方便。 论坛讨论可以别人分享， 问题也可以快速得到解答。

好吧，那请您把那个软件发给我好吗

但是这个程序还是有错误，不能排序，请问要怎么改，才能从小到大排序

引用int i,j,temp,a[i];  -->  int i,j,temp,a[6];

引用 2 楼 qq_21327741 的回复:什么意思，那要怎么改，为什么数组的大小要用常量？ 说好的用常量的呀！ int i,j,temp,a[i]; 改成 int i,j,temp,a[6]; 不就可以了吗？  3.5.4.2 Array declarators  Constraints     The expression that specifies the size of an array shall be an integral constant expression that has a value greater than zero.  Semantics     If, in the declaration `` T D1 ,'' D1 has the form            D[ constant-expression<opt>]  and the type specified for ident in the declaration `` T D '' is `` "derived-declarator-type-list T" ,'' then the type specified for ident is `` derived-declarator-type-list array of T .''/60/ If the size is not present, the array type is an incomplete type.     For two array types to be compatible, both shall have compatible element types, and if both size specifiers are present, they shall have the same value.

什么意思，那要怎么改，为什么数组的大小要用常量？

数组的大小要用常量啊 constant


Question: C语言新手 各位大神帮忙看看 这个程序有什么问题

好的 谢谢了

假如输入分别是1 2 3 4 a转置前的逻辑结构就是 1 2 3 4  双重循环的转置过程就是 1=1 3=2 2=2 4=4 结果打印出来就是 12 24


Question: VC++6.0中如何修改输出窗口的背景颜色和字体颜色。还有怎么插入音乐

引用 6 楼 binaryhead 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] 给我￥10000，我全卖给你。 一份拷贝就卖这么多啊，img=https://forum.csdn.net/PointForum/ui/scripts/csdn/Plugin/001/face/111.gif][/img][/quote] 里面包含很多我的独门秘笈。比如http://bbs.csdn.net/topics/390930260里面提到的技术，卖一万明显偏少。

出错啊

引用 4 楼 zhao4zhong1 的回复:给我￥10000，我全卖给你。 一份拷贝就卖这么多啊，img=https://forum.csdn.net/PointForum/ui/scripts/csdn/Plugin/001/face/111.gif][/img]

很简单，用windows的mci函数。 http://bbs.csdn.net/topics/230044009

给我￥10000，我全卖给你。

引用 1 楼 zhao4zhong1 的回复:#include <windows.h> #include <stdio.h>  void ConPrint(char *CharBuffer, int len); void ConPrintAt(int x, int y, char *CharBuffer, int len); void gotoXY(int x, int y); void ClearConsole(void); void ClearConsoleToColors(int ForgC, int BackC); void SetColorAndBackground(int ForgC, int BackC); void SetColor(int ForgC); void HideTheCursor(void); void ShowTheCursor(void);  int main(int argc, char* argv[]) {    HideTheCursor();    ClearConsoleToColors(15, 1);    ClearConsole();    gotoXY(1, 1);    SetColor(14);    printf("This is a test...\n");    Sleep(5000);    ShowTheCursor();    SetColorAndBackground(15, 12);    ConPrint("This is also a test...\n", 23);    SetColorAndBackground(1, 7);    ConPrintAt(22, 15, "This is also a test...\n", 23);    gotoXY(0, 24);    SetColorAndBackground(7, 1);    return 0; }  //This will clear the console while setting the forground and //background colors. void ClearConsoleToColors(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //not used but we need to capture this since it will be    //written anyway (passing NULL causes an access violation).    DWORD count;     //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    SetConsoleTextAttribute(hStdOut, wColor);    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);        FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will clear the console. void ClearConsole() {    //Get the handle to the current output buffer...    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    //This is used to reset the carat/cursor to the top left.    COORD coord = {0, 0};    //A return value... indicating how many chars were written    //   not used but we need to capture this since it will be    //   written anyway (passing NULL causes an access violation).    DWORD count;    //This is a structure containing all of the console info    // it is used here to find the size of the console.    CONSOLE_SCREEN_BUFFER_INFO csbi;    //Here we will set the current color    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //This fills the buffer with a given character (in this case 32=space).       FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);       //This will set our cursor position for the next print statement.       SetConsoleCursorPosition(hStdOut, coord);    } }  //This will set the position of the cursor void gotoXY(int x, int y) {    //Initialize the coordinates    COORD coord = {x, y};    //Set the position    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); }  //This will set the forground color for printing in a console window. void SetColor(int ForgC) {    WORD wColor;    //We will need this handle to get the current background attribute    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    CONSOLE_SCREEN_BUFFER_INFO csbi;     //We use csbi for the wAttributes word.    if(GetConsoleScreenBufferInfo(hStdOut, &csbi))    {       //Mask out all but the background attribute, and add in the forgournd color       wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);       SetConsoleTextAttribute(hStdOut, wColor);    } }  //This will set the forground and background color for printing in a console window. void SetColorAndBackground(int ForgC, int BackC) {    WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);;    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), wColor); }  //Direct console output void ConPrint(char *CharBuffer, int len) {    DWORD count;    WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), CharBuffer, len, &count, NULL); }  //Direct Console output at a particular coordinate. void ConPrintAt(int x, int y, char *CharBuffer, int len) {    DWORD count;    COORD coord = {x, y};    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);    SetConsoleCursorPosition(hStdOut, coord);    WriteConsole(hStdOut, CharBuffer, len, &count, NULL); }  //Hides the console cursor void HideTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = FALSE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }  //Shows the console cursor void ShowTheCursor() {    CONSOLE_CURSOR_INFO cciCursor;    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);     if(GetConsoleCursorInfo(hStdOut, &cciCursor))    {       cciCursor.bVisible = TRUE; 	  SetConsoleCursorInfo(hStdOut, &cciCursor);    } }   PlaySound The PlaySound function plays a sound specified by the given filename, resource, or system event. (A system event may be associated with a sound in the registry or in the WIN.INI file.)   BOOL PlaySound(   LPCSTR pszSound,     HMODULE hmod,        DWORD fdwSound     );   Parameters pszSound  A string that specifies the sound to play. If this parameter is NULL, any currently playing waveform sound is stopped. To stop a non-waveform sound, specify SND_PURGE in the fdwSound parameter.  Three flags in fdwSound (SND_ALIAS, SND_FILENAME, and SND_RESOURCE) determine whether the name is interpreted as an alias for a system event, a filename, or a resource identifier. If none of these flags are specified, PlaySound searches the registry or the WIN.INI file for an association with the specified sound name. If an association is found, the sound event is played. If no association is found in the registry, the name is interpreted as a filename.   hmod  Handle of the executable file that contains the resource to be loaded. This parameter must be NULL unless SND_RESOURCE is specified in fdwSound.  fdwSound  Flags for playing the sound. The following values are defined:  SND_APPLICATION  The sound is played using an application-specific association.  SND_ALIAS  The pszSound parameter is a system-event alias in the registry or the WIN.INI file. Do not use with either SND_FILENAME or SND_RESOURCE.  SND_ALIAS_ID  The pszSound parameter is a predefined sound identifier.  SND_ASYNC  The sound is played asynchronously and PlaySound returns immediately after beginning the sound. To terminate an asynchronously played waveform sound, call PlaySound with pszSound set to NULL.  SND_FILENAME  The pszSound parameter is a filename.  SND_LOOP  The sound plays repeatedly until PlaySound is called again with the pszSound parameter set to NULL. You must also specify the SND_ASYNC flag to indicate an asynchronous sound event.  SND_MEMORY  A sound event's file is loaded in RAM. The parameter specified by pszSound must point to an image of a sound in memory.  SND_NODEFAULT  No default sound event is used. If the sound cannot be found, PlaySound returns silently without playing the default sound.  SND_NOSTOP  The specified sound event will yield to another sound event that is already playing. If a sound cannot be played because the resource needed to generate that sound is busy playing another sound, the function immediately returns FALSE without playing the requested sound.  If this flag is not specified, PlaySound attempts to stop the currently playing sound so that the device can be used to play the new sound.   SND_NOWAIT  If the driver is busy, return immediately without playing the sound.  SND_PURGE  Sounds are to be stopped for the calling task. If pszSound is not NULL, all instances of the specified sound are stopped. If pszSound is NULL, all sounds that are playing on behalf of the calling task are stopped.  You must also specify the instance handle to stop SND_RESOURCE events.   SND_RESOURCE  The pszSound parameter is a resource identifier; hmod must identify the instance that contains the resource.  SND_SYNC  Synchronous playback of a sound event. PlaySound returns after the sound event completes.  Return Values Returns TRUE if successful or FALSE otherwise.  Remarks The sound specified by pszSound must fit into available physical memory and be playable by an installed waveform-audio device driver. PlaySound searches the following directories for sound files: the current directory; the Windows directory; the Windows system directory; directories listed in the PATH environment variable; and the list of directories mapped in a network. For more information about the directory search order, see the documentation for the OpenFile function.  If it cannot find the specified sound, PlaySound uses the default system event sound entry instead. If the function can find neither the system default entry nor the default sound, it makes no sound and returns FALSE.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Unsupported.   Header: Declared in mmsystem.h.   Import Library: Use winmm.lib.   Unicode: Implemented as Unicode and ANSI versions on Windows NT.  See Also Waveform Audio Overview, Waveform Functions 赵老师的代码库里到底有多少藏品啊？

有错误啊，我是用的C语言，不是C++


Question: 为什么输入97.5还能通过，不显示出错误

那我应该怎么改才能让97.5成功输入呢，改为float类型的时候就不能进行求余

你定义的是整数，读的格式是%d，当然不会有错。读进来的就是97

引用 2 楼 qq_21327741 的回复:那我应该怎么改才能让97.5成功输入呢，改为float类型的时候就不能进行求余float强制转换为int再求余


Question: c语言简单问题

搜scanf与输入缓存区

引用 楼主 changkai11 的回复:#include<stdio.h>  int main () { 	char k1,k2; 	int a; 	scanf("%d",&a); 	switch(a) 	{ 	case 1: 	    printf("请输入插入的数___\b"); 		scanf("%c",&k1); 		printf("*******"); 		printf("输入插入位置___\b"); 		scanf("%c",&k2);//case 1中的我想是输一个数，跳一行，但是，直接都输出了，这是为什么 	} 	printf("*******%C***%C",k1,k2); }  就是2楼说的%c只接收一个字符，所以回车就给了k2了！！！ 添加一个getchar（）；在一二输入之间

没有加break吧

用%d，不要用%c 用%c的话，空格回车什么的都算输入，k2就把回车读入了

k1的ASCII值为\n   只需要给两个scanf之间加getch（）


Question: 求大神帮解答，下面程序运行总是出错，而且。。而且我实在找不出了

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

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

仅供参考 http://yun.baidu.com/s/17yIcQ

while(((p->a)!=k)&&p)  while(p&&((p->a)!=k))

#include <stdio.h> #include<stdlib.h>  typedef struct LNode { char a; struct LNode *next; }LNode,*LinkList;   void CreatList(LinkList head) {     LinkList p,q; char c; p=head; printf("输入一段链表："); scanf("%c",&c); if(c=='\n')         printf("这是一个空链表"); while (c!='\n') { q=(LinkList)malloc(sizeof(LNode)); q->next=NULL; q->a=c; p->next=q; p=q; scanf("%c",&c); } }   void ShowList(LinkList head) {     LinkList p; p=head->next; if(p==NULL) printf("这是个空表"); else { while(p!=NULL) { printf("%c",p->a); p=p->next; } }printf("*******"); printf("\n"); }   int InsertList(LinkList head,char k1,char k2) {      LinkList p,q; p=head->next;	 while(((p->a)!=k2)&&p)//应该先判断p是否为空，才能判断它的成员a存不存在。         p=p->next;     if(p) {         q=(LinkList)malloc(sizeof(LNode)); q->a=k1; q->next=p->next; p->next=q; return 1; } else { printf("这里没有%c",k2); return 0; } }   int DeleteList(LinkList head,char k) { LinkList q,p; p=head->next; q=head; while(((p->a)!=k)&&p)//同上，如果p 是空，p->a就肯定会出错。 {         q=q->next; p=p->next; } if(p) {         q->next=p->next; return 1; } else { printf("这里没有%c",k); return 0; } }    void InvertList(LinkList head) { LinkList p,q; p=head->next; while (p->next) { q=p->next; p->next=q->next; q->next=head->next; head->next=q; } }   int main () { char k1,k2,k3;     LinkList head; head=(LinkList)malloc(sizeof(LNode)); head->next=NULL; CreatList(head);//创建一个链表 if(head->next!=NULL) { printf("当前连表为:"); ShowList(head);//显示并判断当前链表 } if(head->next!=NULL) { printf("输入一个你想插入的字符"); k1=getchar();         printf("想把这个字插在哪个字符后面");	 k2=getchar(); if(InsertList(head,k1,k2)) { printf("在%c后插入%c，得到了链为：",k2,k1); ShowList(head); } printf("请输入表内你想删除的字符"); if(DeleteList(head,k3)) { printf("删除%c后，得到的表为:",k3); ShowList(head); } if(head!=NULL) { printf("操作的最后结果\n"); InvertList(head); ShowList(head); } } return 0; }  自己断点调一下就行了。

我是来拜贴的，，

问题还是比较多的……  创建链表函数中，最后加个  	p->next = NULL; printf("输入一个你想插入的字符"); 		k1 = getchar(); 		printf("想把这个字插在哪个字符后面");	 		k2 = getchar();  第二个getchar()会读入回车符，而不是你想要的数字  最后，k3为何不初始化？？？'

我数据结构新手。。我试了一下。。实在不知道怎么去改。。。能否帮我改下呢

F5调试运行肯定能找出你程序中的问题,  如果只是阅读代码, 很多问题你都找不出来的.


Question: 我是新手，，请大家帮我解答一下，那有错，为什么运行结果是错误的，

谢谢，，是我太粗心了，，

#include "stdio.h" void main() {     int a,b,c=1,d[2][3];     for (a=0;a<2;a++)     {     	for (b=0;b<3;b++)     	{     	d[a][b]=c;     	c++;     	}     }     for (a=0;a<2;a++)     {     	for (b=0;b<3;b++)     	{     	printf("d[%d][%d]=%d,",a,b,d[a][b]);     	}     	printf("\n");     } } 我运行这个是没错的

#include "stdio.h" void main() { 	int a, b, c = 1, d[2][3]; 	for ( a = 0; a < 2; a++ ) 	{ 		for ( b = 0; b < 3; b++ ) 		{ 			d[a][b] = c; 			c++; 		} 	} 	for ( a = 0; a < 2; a++ ) 	{ 		for ( b = 0; b < 3; b++ ) 		{ 			printf( "d[%d][%d]=%d,", a, b, d[a][b] );//输出整数都用%d 		} 		printf( "\n" ); 	} }


Question: 求助哈希表的编译出错

&htbl->table[i]等价于htbl->table + i, 与htbl->table的类型相同


Question: 多维数组指针的问题。

对于一维数组,  a是第一维指针  即 int[]    a+n == a[n] 对于二给数组.  a是第一维指针 int[]    a+n == a[n]       a[x]即第二维指针.  a[x] +n == a[x][n] 其它类似.

引用 3 楼 user-2 的回复:对于后面两个不明白的，a+1并不是元素4的地址，或者说a+1并不是指向元素4；而是说a+1是int[3]的地址，或者说a+1指向的是{4, 5, 6}，能想通这一点，就明白了。 "*p或者p[0]都算是解引用" 还有 “a+1指向的是{4, 5, 6}”   解释的很透彻， 非常感谢，明白了！

要理解这个，得有一定的抽象思考的能力。 首先第一点，没有多维数组，只有一维数组；所谓的多维，不过是一维的递归定义。 其次对于一维数组，其数组名是指向第0个元素的指针（在不够准确的上下文中），对其解引用（*p或者p[0]都算是解引用）得到第0个元素。  理解了上述两点之后，再来看： int a[2][3]={1,2,3,4,5,6}; 这里的a是一个一维数组，该数组有2个元素，元素类型为int[3]； 第0个int[3]是个一维数组，有3个元素，元素类型为int，值分别是1，2，3； 同理，第1个int[3]也是一个一维数组，值分别是4，5，6。  a[1][1] a[1]，取a的第1个元素，即第1个int[3]（记得它又是个数组）； a[1][1]，取a[1]的第1个元素，即5。  *(a[1]+1) 同上，对于一维数组，*p和p[0]是一回事，*(p + 1)和p[1]是一回事。  **（a+1） a指向数组的第0个元素，那么a + 1则指向数组的第1个元素，即第一个int[3]； *(a + 1)即对其解引用，得到第1个int[3]，它是个数组； **(a + 1)对第1个int[3]解引用，即得到第1个int[3]的第0个元素，即4。  (*(a+1))[1] 同上*(a + 1)得到第1个int[3]，然后[1]取该int[3]的第1个元素，即5。

还是没想明白。。求解答


Question: 新手麻煩大家幫我看一下問題出在哪? 謝謝

引用 4 楼 ForestDB 的回复:int sum, n; while (scanf("%d", &n) == 1)     sum += n; 我的功能是想要按下Enter後計算出總和。 請問要谮麼做?

int sum, n; while (scanf("%d") == 1)     sum += n;

引用 1 楼 ForestDB 的回复:while((c=getchar())!='\n') 进入循环的时候第一个字符被取走了 如果LZ输入 11 2 3 4 我猜会输出10  如果我的猜测是对的，说明LZ对于输入流的概念很模糊。 請問大神要如何解決此問題?

引用 6 楼 pengzongjy 的回复:1#说的对，进入循环的时候第一个字符被取走了，计算是从T[1]开始的。所以改为这样就可以满足你的要求。#include <stdio.h>  void main() { 	int T[200] = {0}; 	int i = 0; 	int sum = 0; 	char c; 	 	printf("請輸入一連串整數可以包含空格\n"); 	do  	{ 		scanf("%d", &T[i]);  		if(T[i] != ' ') 		sum = sum + T[i];  		 		//if(c=='\n')    break; 	}while((c=getchar())!='\n'); 	printf("Sum = %d\n", sum);  }  感恩豁然開朗了


Question: 二叉树的遍历

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


Question: JAVA调用SO文件报UnsatisfiedLinkError

引用 7 楼 ForestDB 的回复:http://wenku.baidu.com/link?url=iZW31aQI7Zr5lc9Hs5VYBf50lAP9ZKHGx6IUj_qXoQWaDXey_6Xv9_cCiMlJc5W_ubpuETYZmaX_n4ZLMsqmJADgzkQlvMF6l-OdYj43SVu  随便搜的。  https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html  感谢ForestDB，已经搞定了，原因有两点： 1、JAVA和android的虚拟环境不一样 2、Linux和android的系统库文件不一样  这样导致了在Linux下通过JNI标准命名方式编译的SO文件，在android是调用失败的，原因是Linux和android的系统库不一样，而生产的SO跟生产环境库文件有依赖关系  然后搭建了NDK和Cywin环境，然后生产的SO可以被android调用，参考地址： http://zctya.blog.163.com/blog/static/1209178201181074018603/

引用 5 楼 ForestDB 的回复:应该不可以，搜个靠谱的吧  一个类的完整名称（包括包名），会影响到生成的native code的函数签名，而linker也是靠名字来的。 JNI的方法名命名规则是JNI通过包名，找类名，再找到方法名，然后加载运行，而你说的没有包名就找不到类名，或者不认识包名？然后就无法link，是这个意思吗？  你是否有好的文章推荐

引用 3 楼 ForestDB 的回复:LZ贴的代码不全吧？ 没有package 为何生成的函数签名有包的样子？  你说Comm.java吗？这个我是从根据网上的操作流程自己copy上去的，因为是JAVA调用，没用包名，这个应该可以吧，不然该如何修改？

LZ贴的代码不全吧？ 没有package 为何生成的函数签名有包的样子？

java怎么发到c论坛了，是不是邀请错人啦，我不会啊


Question: 我在cmd运行wmic process get CommandLine 命令后报错

微软的命令几乎都带/? Linux的命令几乎都带--help

引用 3 楼 zhao4zhong1 的回复:C:\>wmic wmic:root\cli>process get CommandLine /?  属性                                    类型                    操作 ========                                ====                    ========= CommandLine                             N/A                     N/A  可用下列 GET 开关:  /VALUE                       - 返回值 /ALL(默认)                   - 返回属性的数据和元数据 /TRANSLATE:<table name>      - 通过从 <table name> 值转换输出。 /EVERY:<interval> [/REPEAT:<repeat count>] - 每(X 间隔)秒返回值，如果指定了 /REPEAT，命令会执行 <repeat count> 次数。 /FORMAT:<format specifier>   - 处理此 XML 结果的关键字/XSL 文件名。  注意: /TRANSLATE 和 /FORMAT 开关的顺序会影响输出的外观。 第一种情况: 如果 /TRANSLATE 在 /FORMAT 的前面，编排格式会跟在结果转换后面。 第二种情况: 如果 /TRANSLATE 在 /FORMAT 的后面，会直接转换格式已经编排的结果。  wmic:root\cli>exit 多谢呀

引用 1 楼 turingo 的回复:直接运行 wmic process get 呢？ 直接运行这个命令时可以的

直接运行 wmic process get 呢？


Question: c语言文件格式转换问题

引用 2 楼 huangbiao11 的回复:[quote=引用 1 楼 bjym1987 的回复:] 你都存到t2结构体里面去了，遍历还能有什么问题？  最大的问题是，不知道怎么遍历t2 这样的结构体。  struct t2 {     char user[128];     char cn[128];     char modules[128];     char pd[128];     char desc[128]; };  另一个问题是，存到t2里面的只有值，读取出来也只有值，比如文件2第一行第一节数据user=ceshi1，存到t2里面只有ceshi1这个部分，但是放到t1 里面的格式要为 n:ceshi1，不知道怎么弄。[/quote] fprintf(f,"{n:%s,p:%s,t:%s,g:1,m:->>%s}\n",t2.user,t2.pd,t2.modules,t2.cn);

{n:ceshi1,p:269,t:t2,g:1,m:->>zzz} {n:ceshi2,p:8,t:t2,g:1,m:->>bbb} {n:hehe,p:60713,t:t2,g:1,m:->>ttt} 才对吧。

比如这里文件2转换为文件1为   这里看不出有何映射关系。

有点想json解析的内容

引用 1 楼 bjym1987 的回复:你都存到t2结构体里面去了，遍历还能有什么问题？  最大的问题是，不知道怎么遍历t2 这样的结构体。  struct t2 {     char user[128];     char cn[128];     char modules[128];     char pd[128];     char desc[128]; };  另一个问题是，存到t2里面的只有值，读取出来也只有值，比如文件2第一行第一节数据user=ceshi1，存到t2里面只有ceshi1这个部分，但是放到t1 里面的格式要为 n:ceshi1，不知道怎么弄。

你都存到t2结构体里面去了，遍历还能有什么问题？


Question: 初学者求帮看代码哪里有问题

引用 14 楼 ilikehigame 的回复:[quote=引用 楼主 q2953346886 的回复:] 原题是让编一个简单的日期计算器 输入年、月、日，输出该日期的前一天和后一天 本渣编了半天，编译显示没错误，但是运行了也没反应。代码如下： #include <stdio.h> void main() {  int year,month,day;  printf("请输入一个年、月、日：\n");  scanf("%d,%d,%d",&year,&month,&day);   if(month==5||month==7||month==10)    {  if(day==31)  printf("前一天：%d年%d月30日,后一天：%d年%d月1日",year,month,month+1);       else if(day==1)  printf("前一天：%d年%d月30日,后一天：%d年%d月2日",year,month-1,month);      else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1);    }     else if(month==8) 	{ 	   if(day==31)  printf("前一天：%d年8月30日,后一天：%d年9月1日",year,year);        else if(day==1)  printf("前一天：%d年7月31日,后一天：%d年8月2日",year,year); 	}        else if(month==4||month==6||month==9||month==11) 	   {  if(day==30)  printf("前一天：%d年%d月29日,后一天：%d年%d月1日",year,month,month+1);             else if(day==1)  printf("前一天：%d年%d月31日,后一天：%d年%d月2日",year,month-1,month);               else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 	   } 	   else if(month==12)    { if(day==31) printf("前一天：%d年12月30日,后一天：%d年1月1日",year,year+1);     if(day==1) printf("前一天：%d年11月30日,后一天：%d年12月2日",year,year);    else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1);   }     else if(month==1)    { if(day==31) printf("前一天：%d年1月30日,后一天：%d年2月1日",year,year);     else if(day==1) printf("前一天：%d年12月31日,后一天：%d年1月2日",year-1,year);    else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1);   } 	   else  	   { 		   if(year%4==0&&year%100!=0||year%400==0) 		   { if(month==2) 		   {                if(day==29) printf("前一天：%d年2月28日,后一天：%d年3月1日",year,year);                  else if(day==1) printf("前一天：%d年1月31日,后一天：%d年2月2日",year,year);                else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 		   } 		   } 		      else if(month==3) 			  { 			  if(day==31) printf("前一天：%d年3月30日,后一天：%d年4月1日",year,year);               else if(day==1) printf("前一天：%d年2月29日,后一天：%d年3月2日",year,year);               else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 			  } 			   		   else  		   { 		   if(month==2) 		   {                if(day==28) printf("前一天：%d年2月27日,后一天：%d年3月1日",year,year);                  else if(day==1) printf("前一天：%d年1月31日,后一天：%d年2月2日",year,year);                else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 		   } 		      else if(month==3) 			  { 			  if(day==31) printf("前一天：%d年3月30日,后一天：%d年4月1日",year,year);               else if(day==1) printf("前一天：%d年2月28日,后一天：%d年3月2日",year,year);               else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 		    			  }       	 		} 	   }  }  没什么问题，只是你输入的格式不对，因为你写的是scanf("%d,%d,%d",&year,&month,&day); 所以输入的格式是：2004,2,28回车就对了！！！！数字中间要用逗号隔开[/quote]真是这个问题~我想了一天也没想明白多谢了。

引用 楼主 q2953346886 的回复:原题是让编一个简单的日期计算器 输入年、月、日，输出该日期的前一天和后一天 本渣编了半天，编译显示没错误，但是运行了也没反应。代码如下： #include <stdio.h> void main() {  int year,month,day;  printf("请输入一个年、月、日：\n");  scanf("%d,%d,%d",&year,&month,&day);   if(month==5||month==7||month==10)    {  if(day==31)  printf("前一天：%d年%d月30日,后一天：%d年%d月1日",year,month,month+1);       else if(day==1)  printf("前一天：%d年%d月30日,后一天：%d年%d月2日",year,month-1,month);      else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1);    }     else if(month==8) 	{ 	   if(day==31)  printf("前一天：%d年8月30日,后一天：%d年9月1日",year,year);        else if(day==1)  printf("前一天：%d年7月31日,后一天：%d年8月2日",year,year); 	}        else if(month==4||month==6||month==9||month==11) 	   {  if(day==30)  printf("前一天：%d年%d月29日,后一天：%d年%d月1日",year,month,month+1);             else if(day==1)  printf("前一天：%d年%d月31日,后一天：%d年%d月2日",year,month-1,month);               else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 	   } 	   else if(month==12)    { if(day==31) printf("前一天：%d年12月30日,后一天：%d年1月1日",year,year+1);     if(day==1) printf("前一天：%d年11月30日,后一天：%d年12月2日",year,year);    else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1);   }     else if(month==1)    { if(day==31) printf("前一天：%d年1月30日,后一天：%d年2月1日",year,year);     else if(day==1) printf("前一天：%d年12月31日,后一天：%d年1月2日",year-1,year);    else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1);   } 	   else  	   { 		   if(year%4==0&&year%100!=0||year%400==0) 		   { if(month==2) 		   {                if(day==29) printf("前一天：%d年2月28日,后一天：%d年3月1日",year,year);                  else if(day==1) printf("前一天：%d年1月31日,后一天：%d年2月2日",year,year);                else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 		   } 		   } 		      else if(month==3) 			  { 			  if(day==31) printf("前一天：%d年3月30日,后一天：%d年4月1日",year,year);               else if(day==1) printf("前一天：%d年2月29日,后一天：%d年3月2日",year,year);               else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 			  } 			   		   else  		   { 		   if(month==2) 		   {                if(day==28) printf("前一天：%d年2月27日,后一天：%d年3月1日",year,year);                  else if(day==1) printf("前一天：%d年1月31日,后一天：%d年2月2日",year,year);                else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 		   } 		      else if(month==3) 			  { 			  if(day==31) printf("前一天：%d年3月30日,后一天：%d年4月1日",year,year);               else if(day==1) printf("前一天：%d年2月28日,后一天：%d年3月2日",year,year);               else printf("前一天：%d年%d月%d日,后一天：%d年%d月%d日",year,month,day-1,year,month,day+1); 		    			  }       	 		} 	   }  }  没什么问题，只是你输入的格式不对，因为你写的是scanf("%d,%d,%d",&year,&month,&day); 所以输入的格式是：2004,2,28回车就对了！！！！数字中间要用逗号隔开

引用 11 楼 q2953346886 的回复:[quote=引用 9 楼 hhhhhhhhhhkkkkkkkkkk 的回复:] 你运行我的代码看一下，那两个getchar就像我那样放，目的是不让控制台显示一下就退了。下面是我代码运行的一些结果：  图片没了[/quote] 这是刚注册的号，我这里看显示图片已删除，麻烦复制一下改完后的代码吧，麻烦您了。

我这能看到图片的啊，是不是你级不够？

引用 9 楼 hhhhhhhhhhkkkkkkkkkk 的回复:你运行我的代码看一下，那两个getchar就像我那样放，目的是不让控制台显示一下就退了。下面是我代码运行的一些结果：  图片没了

润年是用的你的算法，好像结果不对。

引用 7 楼 r_Jimy 的回复:一般只要在程序返回前加个getchar或scanf从控制台读数据即可，如果程序只在最后返回，加在最后就可以了 然后你随意输入个字符上程序读到数据，它就return了大学刚学c，表示不太懂，我把两个getchar加到最后一个大括号前然后运行后还是直接显示“press any key to continue”。到底应该加到哪里啊

引用 5 楼 r_Jimy 的回复:[quote=引用 4 楼 hhhhhhhhhhkkkkkkkkkk 的回复:] 如果在VS下调试的话，最后那要两个getchar();才能看到显示的结果，否则控制台显示一下就关闭了，根本来不及看结果。第一个getchar();是用来接收scanf输入完成后敲的那一下回车键的。第二个才是暂停用的。 楼主说的没反应应是这样的情况了[/quote]我使用visual c++6.0 运行的，另外求问一下两个getchar 应该加到哪里？

引用 4 楼 hhhhhhhhhhkkkkkkkkkk 的回复:如果在VS下调试的话，最后那要两个getchar();才能看到显示的结果，否则控制台显示一下就关闭了，根本来不及看结果。第一个getchar();是用来接收scanf输入完成后敲的那一下回车键的。第二个才是暂停用的。 楼主说的没反应应是这样的情况了

没有问题呀！ 输入 1990,1,1输出为 前一天：1989年12月31日,后一天：1990年1月2日  只是看起来闰年的处理似乎有点问题。

运行了下，是有反应的，结果也是正确的。不过你这写法太难看了。下面是我写的：  #include"stdio.h" void main() { 	int year, month, day; 	printf("请输入一个年、月、日：\n"); 	scanf_s("%d,%d,%d", &year, &month, &day); 	if (!((month >= 1) && (month <= 12))) 	{ 		printf("输入月错误"); goto _exit; 	}  	int monDay[12],preYear,preMon,preDay,afterYear,afterMon,afterDay; 	bool dYear = false; 	monDay[0] = monDay[2] = monDay[4] = monDay[6] = monDay[7] = monDay[9] = monDay[11]=31; 	monDay[3] = monDay[5] = monDay[8] = monDay[10] = 30; 	monDay[1] = 28; 	if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) 	{ 		dYear = true; monDay[2] = 29; 	} 	if (!((day >= 1) && (day <= monDay[month-1]))) 	{ 		printf("输入日错误"); goto _exit; 	} 	//计算前一天： 	preDay = day - 1; 	preMon = month; 	preYear = year; 	if (preDay < 1) 	{ 		preMon--; 		if (preMon < 1) 		{ 			preMon = 12; 			preYear--; 		} 		preDay = monDay[preMon-1]; 	} 	char*beforeStr = ""; 	if (preYear < 0){ beforeStr = "公元前"; preYear = -preYear; } 	printf("前一天：%s%d年%d月%d日\n", beforeStr,preYear, preMon, preDay); 	//计算后一天： 	afterDay = day + 1; 	afterMon = month; 	afterYear = year; 	if (afterDay > monDay[month-1]) 	{ 		afterDay = 1; afterMon++; 	} 	if (afterMon > 12) 	{ 		afterMon = 1; 		afterYear++; 	} 	beforeStr = ""; 	if (afterYear<0){ beforeStr = "公元前"; afterYear = -afterYear; } 	printf("后一天：%s%d年%d月%d日\n", beforeStr, afterYear, afterMon, afterDay); _exit: 	getchar(); 	getchar(); }

有的地方少了接个year，但是貌似这个不是主要问题


Question: 求c语言这题哪里错了 小弟刚学数构 求大神

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

帮你顶一下，更重要的是看看自己的等级~

Status InOrderTraverse(BiTree T,Status(*Visit)(TElemType e)) { LinkStack S; InitStack(S); BiTree p; p=T; while(p || InitStack(S)) { if(p) { Push(S,p); p=p->lchild; } else { Pop(S,p); if(!Visit(p->data)) return ERROR; p=p->rchild; } return OK; }  这个函数你在写什么？你参数都没有搞懂。就乱用pop和push


Question: 关于fopen的使用

FILE *fopen（const char *path,const char *mode); path是文件的路径加名字，mode是打开文件的模式

跟你重新温习基础： 定义函数 FILE * fopen(const char * path,const char * mode); 函数说明 参数path字符串包含欲打开的文件路径及文件名，参数mode字符串则代表着流形态。         "1.txt" 是文件名   字符‘r’  打开只读文件，该文件必须存在

1.txt是个文件名， 其路径是当前文件夹。  r是打开方式


Question: C语言字符串比较问题：

#include <stdio.h> #include<string.h> #define N 60 void main() { char a[N],b[N]; memset(a,'\0',N); memset(b,'\0',N); printf("请输入第一个字符串：\n"); gets(a); printf("请输入第二个字符串：\n"); gets(b); int i=0; while(a[i]==b[i]) { i++; } int n=a[i]-b[i]; printf("%d\n",n); }  你最好不要输入一样的值，不然你想打印多少，你打印的时候最好也把i的值打印出来，这样你才理解为什么输出是这样。

感觉这判定条件有问题, 如果后面都是'\0' ,还是会向下进行的啊,   #include <stdio.h> #include<string.h> #define N 60 int main() {     char a[N],b[N];     memset(a,'\0',N);     memset(b,'\0',N);     printf("请输入第一个字符串：\n");     scanf("%s", a);     printf("请输入第二个字符串：\n");     scanf("%s", b);     int i = 0;     while(a[i] != '\0' && b[i] != '\0')     {         if (a[i] != b[i]) {             break;         }         i++;     }     int n=a[i]-b[i];     printf("%d\n",n);     return 0; }

#include <stdio.h> #define N 60 void main() { 	char a[N],b[N]; 	printf("请输入第一个字符串：\n"); 	gets(a); 	printf("请输入第二个字符串：\n"); 	gets(b); 	int i=0; 	while(a[i]==b[i]) 	{ 		i++; 	} 	int n=a[i]-b[i]; 	printf("a = %c  %d b = %c %d  %d\n",a[i],a[i],b[i],b[i],n); }

输出 a[i]  b[i]