Question: 纯小白求助，如何做出一个能实际应用的软件

希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

引用 11 楼 user-6的回复:[quote=引用 10 楼 weixin_45486151的回复:][quote=引用 4 楼 user-6的回复:][quote=引用 楼主 weixin_45486151的回复:]我是数学专业的开学大二，计算机知识仅限于学完了c语言程序设计这门课程。今天英语四级出分，需要准考证号，但是我给忘记了...但是前几位的大家都一样，所以我就想用c设计了一个枚举程序。让我很困惑的是我如何一次次的把数据上传到那个成绩查询网站上呢。 使用爬虫提交表单，应该可以吧[/quote] 您好可以细说一下不，蟹蟹啦[/quote] 要学的多喽，放弃吧，不的话，Python爬虫，不过大部分网站都要反爬手段，比如验证码，那么你需要去学Python的ocr文字识别，还要训练模型，只会基础的c是没指望了[/quote] 现在已经接触了入门的机器学习，现在已经可以能应用那种识别纯数字的文本了

引用 8 楼 weixin_45486151 的回复:这个成绩没什么，因为过一段时间学校教务系统可以查看，主要是对这个方法很感兴趣。感觉现在学的编程对解决事情没什么用啊 还是有用的，比如“拼夕夕抢优惠商品”， 你懂的

引用 3 楼 轻箬笠的回复:我觉得够呛，就算有办法穷举，查分网站肯定也有次数限制的，否则被攻击了咋办。 类似楼主这种，直接问辅导员是最好的办法，别问我咋知道的。毕业去打印六级成绩，问我要准考证号，我就是问的导员，让导员帮忙拿的，因为学校有留档的，只需要学号就可以查到了。 这个成绩没什么，因为过一段时间学校教务系统可以查看，主要是对这个方法很感兴趣。感觉现在学的编程对解决事情没什么用啊

引用 6 楼 自信男孩 的回复:[quote=引用 2 楼 liups 的回复:] [quote=引用 1 楼 自信男孩 的回复:] 你写的这个应用程序应该是能够访问网站的后台，比如数据库，这样你才能与真正的数据交互。 不会是来搞笑的吧，这么多专家分就给这样的答案！[/quote] 你给个不搞笑的答案吧[/quote]楼上多人已给

引用 2 楼 liups 的回复:[quote=引用 1 楼 自信男孩 的回复:] 你写的这个应用程序应该是能够访问网站的后台，比如数据库，这样你才能与真正的数据交互。 不会是来搞笑的吧，这么多专家分就给这样的答案！[/quote] 你给个不搞笑的答案吧

我同意轻箬笠的观点，就像Q.Q密码输错了几次之后要输入验证码一样，网站会采取一些措施来验证你是否为机器人.

引用 楼主 weixin_45486151的回复:我是数学专业的开学大二，计算机知识仅限于学完了c语言程序设计这门课程。今天英语四级出分，需要准考证号，但是我给忘记了...但是前几位的大家都一样，所以我就想用c设计了一个枚举程序。让我很困惑的是我如何一次次的把数据上传到那个成绩查询网站上呢。 使用爬虫提交表单，应该可以吧

引用 10 楼 weixin_45486151的回复:[quote=引用 4 楼 user-6的回复:][quote=引用 楼主 weixin_45486151的回复:]我是数学专业的开学大二，计算机知识仅限于学完了c语言程序设计这门课程。今天英语四级出分，需要准考证号，但是我给忘记了...但是前几位的大家都一样，所以我就想用c设计了一个枚举程序。让我很困惑的是我如何一次次的把数据上传到那个成绩查询网站上呢。 使用爬虫提交表单，应该可以吧[/quote] 您好可以细说一下不，蟹蟹啦[/quote] 要学的多喽，放弃吧，不的话，Python爬虫，不过大部分网站都要反爬手段，比如验证码，那么你需要去学Python的ocr文字识别，还要训练模型，只会基础的c是没指望了

引用 4 楼 user-6的回复:[quote=引用 楼主 weixin_45486151的回复:]我是数学专业的开学大二，计算机知识仅限于学完了c语言程序设计这门课程。今天英语四级出分，需要准考证号，但是我给忘记了...但是前几位的大家都一样，所以我就想用c设计了一个枚举程序。让我很困惑的是我如何一次次的把数据上传到那个成绩查询网站上呢。 使用爬虫提交表单，应该可以吧[/quote] 您好可以细说一下不，蟹蟹啦

引用 1 楼 自信男孩 的回复:你写的这个应用程序应该是能够访问网站的后台，比如数据库，这样你才能与真正的数据交互。 不会是来搞笑的吧，这么多专家分就给这样的答案！


Question: c primer plus第294页

就是后缀自加在本行或者本表达式中，值按原值；下一行或者以后用到该变量的表达式按该变量加1处理；这样*p++就是首先P自增了，但是当前表达式的P++仍按P计算，下一行再有*p，此时的P按P原值+1处理。

引用 11 楼 马振宇 的回复:引用 10 楼 lin5161678 的回复：[quote=引用 9 楼 自信男孩 的回复:] [quote=引用 6 楼 lin5161678 的回复:] [quote=引用 5 楼 自信男孩 的回复:] [quote=引用 2 楼 马振宇 的回复:] [quote=引用 1 楼 自信男孩 的回复：]*start++;是start++现结合，那么由于后置自增，所以start++成为一个整体，先将*(start++)赋值个total，然后再start += 1;还是没明白，他说start先求值是什么意思呢？ 就是先计算start指向的内存的内容，然后赋值给total，然后在计算start指针变量的偏移[/quote]start指针什么时候偏移都可以  *操作的不是 start  [/quote] 你这么说我也不明白你要表达的了[/quote] *操作之前 start 可以已经完成+1  但*操作的依然是start+1之前的地址  两者没有必然联系  没有必须先完成取值 最后才执行 +1[/quote]有什么依据吗？很难理解[/quote] 依据是 *操作前后没有序列点 标准没要求副作用必须完成

引用 10 楼 lin5161678 的回复：引用 9 楼 自信男孩 的回复:[quote=引用 6 楼 lin5161678 的回复:] [quote=引用 5 楼 自信男孩 的回复:] [quote=引用 2 楼 马振宇 的回复:] [quote=引用 1 楼 自信男孩 的回复：]*start++;是start++现结合，那么由于后置自增，所以start++成为一个整体，先将*(start++)赋值个total，然后再start += 1;还是没明白，他说start先求值是什么意思呢？ 就是先计算start指向的内存的内容，然后赋值给total，然后在计算start指针变量的偏移[/quote]start指针什么时候偏移都可以  *操作的不是 start  [/quote] 你这么说我也不明白你要表达的了[/quote] *操作之前 start 可以已经完成+1  但*操作的依然是start+1之前的地址  两者没有必然联系  没有必须先完成取值 最后才执行 +1[/quote]有什么依据吗？很难理解

引用 9 楼 自信男孩 的回复:引用 6 楼 lin5161678 的回复:[quote=引用 5 楼 自信男孩 的回复:] [quote=引用 2 楼 马振宇 的回复:] [quote=引用 1 楼 自信男孩 的回复：]*start++;是start++现结合，那么由于后置自增，所以start++成为一个整体，先将*(start++)赋值个total，然后再start += 1;还是没明白，他说start先求值是什么意思呢？ 就是先计算start指向的内存的内容，然后赋值给total，然后在计算start指针变量的偏移[/quote]start指针什么时候偏移都可以  *操作的不是 start  [/quote] 你这么说我也不明白你要表达的了[/quote] *操作之前 start 可以已经完成+1  但*操作的依然是start+1之前的地址  两者没有必然联系  没有必须先完成取值 最后才执行 +1

引用 6 楼 lin5161678 的回复:引用 5 楼 自信男孩 的回复:[quote=引用 2 楼 马振宇 的回复:] [quote=引用 1 楼 自信男孩 的回复：]*start++;是start++现结合，那么由于后置自增，所以start++成为一个整体，先将*(start++)赋值个total，然后再start += 1;还是没明白，他说start先求值是什么意思呢？ 就是先计算start指向的内存的内容，然后赋值给total，然后在计算start指针变量的偏移[/quote]start指针什么时候偏移都可以  *操作的不是 start  [/quote] 你这么说我也不明白你要表达的了

哪位大神能帮忙看看

引用 3 楼 lin5161678 的回复：start++ 先求值  问题是 这个表达式求值结果就是start  而不是start+1 那是start本身的值  和 * 操作没关系start++求值结果还是start？更迷糊了

引用 5 楼 自信男孩 的回复:引用 2 楼 马振宇 的回复:[quote=引用 1 楼 自信男孩 的回复：]*start++;是start++现结合，那么由于后置自增，所以start++成为一个整体，先将*(start++)赋值个total，然后再start += 1;还是没明白，他说start先求值是什么意思呢？ 就是先计算start指向的内存的内容，然后赋值给total，然后在计算start指针变量的偏移[/quote]start指针什么时候偏移都可以  *操作的不是 start

引用 2 楼 马振宇 的回复:引用 1 楼 自信男孩 的回复：*start++;是start++现结合，那么由于后置自增，所以start++成为一个整体，先将*(start++)赋值个total，然后再start += 1;还是没明白，他说start先求值是什么意思呢？ 就是先计算start指向的内存的内容，然后赋值给total，然后在计算start指针变量的偏移

分清楚表达式的值 和 表达式的操作数的值  这是2个不同概念


Question: 小白求问，如果在字符串中判断到特定符号然后删除

楼上方法不错

用strtok啊。  char data[1024]; 初始化data char *p = strtok(data, "*～+=%$"); char data2[1024] = {0}; while(p) { memcpy(data2 + strlen(data2), p, strlen(p); p = strtok(NULL, "*～+=%$"); }

建一个256字符的替换表

引用 3 楼 weixin_43925997 的回复:[quote=引用 1 楼 自信男孩的回复:]反过来，判断非*~+=%$等符号之外的用空格替换 switch (ch) {     case '*'         xxx;         break;     ...     default:     break; } 伪代码～ 代码已经做别的处理了，做了中英文识别，小写转大写，然后又让删除特定符号，有十几个，不知道这么加进去好看了，if里面可以家很长很长，但是太难看了[/quote] 你把要删除的字符放到一个数组里，每次判断都从数组里查询，这样就不会if很长了。

引用 1 楼 自信男孩的回复:反过来，判断非*~+=%$等符号之外的用空格替换 switch (ch) {     case '*'         xxx;         break;     ...     default:     break; } 伪代码～ 代码已经做别的处理了，做了中英文识别，小写转大写，然后又让删除特定符号，有十几个，不知道这么加进去好看了，if里面可以家很长很长，但是太难看了

正则表达式速查 正则表达式举例 正则表达式学习 (4页A4纸)http://download.csdn.net/detail/zhao4zhong1/1808549 #include <iostream> #include <string> #include <regex> using namespace std; int main() {     string str("This expression could match from A and beyond. [ expression  express ]");     string rs = "exp\\w*";  // 正则字符串，exp开始的单词     cout << str << endl;      regex expression(rs); // 字符串传递给构造函数，建立正则表达式  // regex_match 判断一个正则表达式(参数 e)是否匹配整个字符序列 str. 它主要用于验证文本。 // 注意，这个正则表达式必须匹配被分析串的全部，否则函数返回 false. // 如果整个序列被成功匹配，regex_match 返回 True.     bool ret = regex_match(str, expression);     if (ret)         cout << "可以匹配整个文本" << endl;     else         cout << "不能匹配整个文本" << endl;  // regex_search 类似于 regex_match, 但它不要求整个字符序列完全匹配。 // 你可以用 regex_search 来查找输入中的一个子序列，该子序列匹配正则表达式 e.     ret = regex_search(str, expression);     if (ret)         cout << "能够搜索到 " << rs << endl;     else         cout << "不能搜索" << endl;  // regex_replace 在整个字符序列中查找正则表达式e的所有匹配。 // 这个算法每次成功匹配后，就根据参数fmt对匹配字符串进行格式化。 // 缺省情况下，不匹配的文本不会被修改，即文本会被输出但没有改变。      str = regex_replace(str, expression, string("表达式")); // VC2010或者TR1注意：这里第三个参数要用string()转换 // http://www.johndcook.com/cpp_regex.html // started with C++ TR1 regular expressions     cout << str << endl;     return 0; } //This expression could match from A and beyond. [ expression  express ] //不能匹配整个文本 //能够搜索到 exp\w* //This 表达式 could match from A and beyond. [ 表达式  表达式 ]


Question: 好像遇到了点问题？

不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。

最后一个数字应该是0.....是零的话也输出不了

输入一个字母就退出while循环了。即输入一个非数字的字符（当然空格和换行也是不行的）。


Question: devc++调试自增变量会乱变的问题

没用过dev. 想说一句vs是宇宙第一编译器

这个软件不行，我也这样

从你的表述中看到应该是你那边编译器的问题喽！换个编译器。  验证代码没问题只要是给定指定输入能达到期望的输出就可以了。 看一下你第一张图就是个大位数加法的算法，再加你的这个结构体定义。 我好像在《程序员的数学思维》这本书上有看到过。

http://blog.csdn.net/zhao4zhong1/article/details/53078924 老司机找bug的十年心路历程

引用 6 楼 自信男孩的回复:[quote=引用 5 楼 weixin_44484668 的回复:] int main(){ 	int a[10]={0}, k=0; 	while(k<10){ 		a[k++]=5; 	} 	for(int i=0; i<10; i++){ 		printf("%d ", a[i]); 	} 	return 0; }  比如这个，我想让a数组10个元素都是5，直接编译输出是对的，经过调试确实错的(调试时k的取值会不断变化，第一次放上去是1？不应该是0吗？第一次直接变为3了。可我没有让循环进行下去啊，只是单纯的想查看k的值) 第一次k是0，其实是a[k++] = 5;可以分解为：a[k] = 5; k++;运行也是这么分解运行的。[/quote] 你说的这个步骤我是明白的，先让a[k取值]5，然后k++。调试的时候我放在k上，k会不停地变化怎么解？假如我的最终结果不正确，我想看看哪里出错了，放到k上，k变一个数，再次放k又变。比如i=0时，第一次k是0，我在放到k上，k变成了1，那么i=0时，就成了a[1]=5，这样最后成了a[10]=5

引用 6 楼 自信男孩的回复:[quote=引用 5 楼 weixin_44484668 的回复:] int main(){ 	int a[10]={0}, k=0; 	while(k<10){ 		a[k++]=5; 	} 	for(int i=0; i<10; i++){ 		printf("%d ", a[i]); 	} 	return 0; }  比如这个，我想让a数组10个元素都是5，直接编译输出是对的，经过调试确实错的(调试时k的取值会不断变化，第一次放上去是1？不应该是0吗？第一次直接变为3了。可我没有让循环进行下去啊，只是单纯的想查看k的值) 第一次k是0，其实是a[k++] = 5;可以分解为：a[k] = 5; k++;运行也是这么分解运行的。[/quote] 是不是不能查看k的值，因为查看一次k就变化一次，严重影响我的最终结果

那我放在k上，为什么经过一段时间k的值会变化？我不调试结果没问题，调试的时候这样结果就会变。

引用 5 楼 weixin_44484668 的回复:int main(){ 	int a[10]={0}, k=0; 	while(k<10){ 		a[k++]=5; 	} 	for(int i=0; i<10; i++){ 		printf("%d ", a[i]); 	} 	return 0; }  比如这个，我想让a数组10个元素都是5，直接编译输出是对的，经过调试确实错的(调试时k的取值会不断变化，第一次放上去是1？不应该是0吗？第一次直接变为3了。可我没有让循环进行下去啊，只是单纯的想查看k的值) 第一次k是0，其实是a[k++] = 5;可以分解为：a[k] = 5; k++;运行也是这么分解运行的。

引用 3 楼 weixin_44484668的回复:[quote=引用 1 楼 飞雪蝶映的回复:]结构体的定义是怎样的你得弄出来呀 大整数运算那里的代码 struct bign{   int d[1000]，len;   bign(){      memset(d, 0, sizeof(d);)      len=0;   } }[/quote] 而且我发现只要调试循环体内的自增变量就会出现这种情况，不知道什么原因

引用 1 楼 飞雪蝶映的回复:结构体的定义是怎样的你得弄出来呀 大整数运算那里的代码 struct bign{   int d[1000]，len;   bign(){      memset(d, 0, sizeof(d);)      len=0;   } }

看你的帖子扭的脖子疼，能不能直接发代码呢？不截图

结构体的定义是怎样的你得弄出来呀


Question: 比较小白的问题  麻烦各位进来看一眼

引用 1 楼 user-1 的回复:用while替代goto 我在后面加了一个分号   变成  loop:;就好了  谢谢你

用while替代goto


参考：  the equivalent of _vscprintf && _vscwprintf under Linux

Linux下要学会使用man命令比如 man vsprintf man 1 vsprintf man 2 vsprintf man 3 vsprintf man 3p vsprintf

这个函数需要：Required for UNIX V compatibility. 需要兼容UNIX V  如果不兼容，可以用fprintf，输出到文件，返回值就是大小了。 然后再分配。

linux底下也是可以的，这个代码十多年前写过，现在一时半会儿不知道在哪里，哪天找到了告诉你


Question: C语言基础求解！！

引用 4 楼 qq_18298599 的回复：往回看修饰符？已经看到了！之前只看到了scanf的*，没注意printf的不同

往回看修饰符？

Format Specification Fields: printf and wprintf Functions A format specification, which consists of optional and required fields, has the following form:  %[flags] [width] [.precision] [{h | l | I64 | L}]type  Each field of the format specification is a single character or a number signifying a particular format option. The simplest format specification contains only the percent sign and a type character (for example, %s). If a percent sign is followed by a character that has no meaning as a format field, the character is copied to stdout. For example, to print a percent-sign character, use %%.  The optional fields, which appear before the type character, control other aspects of the formatting, as follows:  type  Required character that determines whether the associated argument is interpreted as a character, a string, or a number (see Table R.3).  flags  Optional character or characters that control justification of output and printing of signs, blanks, decimal points, and octal and hexadecimal prefixes (see Table R.4). More than one flag can appear in a format specification.  width  Optional number that specifies the minimum number of characters output. (See printf Width Specification.)   precision  Optional number that specifies the maximum number of characters printed for all or part of the output field, or the minimum number of digits printed for integer values (see Table R.5).  h | l | I64 | L  Optional prefixes to type-that specify the size of argument (see Table R.6).

printf Width Specification The second optional field of the format specification is the width specification. The width argument is a nonnegative decimal integer controlling the minimum number of characters printed. If the number of characters in the output value is less than the specified width, blanks are added to the left or the right of the values — depending on whether the – flag (for left alignment) is specified — until the minimum width is reached. If width is prefixed with 0, zeros are added until the minimum width is reached (not useful for left-aligned numbers).  The width specification never causes a value to be truncated. If the number of characters in the output value is greater than the specified width, or if width is not given, all characters of the value are printed (subject to the precision specification).  If the width specification is an asterisk (*), an int argument from the argument list supplies the value. The width argument must precede the value being formatted in the argument list. A nonexistent or small field width does not cause the truncation of a field; if the result of a conversion is wider than the field width, the field expands to contain the conversion result.

#include <stdio.h> int main() {     for (int w=2;w<8;w++) printf("%d [%*d]\n",w,w+3,w);     return 0; } //2 [    2] //3 [     3] //4 [      4] //5 [       5] //6 [        6] //7 [         7] //   作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。


Question: c语言指针做函数实参问题求解

#include<stdio.h>  int max(int x,int y); int min(int x,int y); int add(int x,int y); void process(int x,int y, int (*fun)(int, int)); int main() {       int a,b;      printf("Please input a and b:\n");     scanf("%d %d",&a,&b);      printf("max=");     process(a,b,max);      printf("min=");     process(a,b,min);      printf("sum=");     process(a,b,add);     return 0; }  void process(int x,int y,int (*fun)(int, int)) {     int value;     //value =(*fun)(x,y);     value = fun(x,y);     printf("%d\n",value); }  int max(int x,int y) {     int max;     if(x>y)     {         return x;     }     else     {         return y;     }  }  int min(int x,int y) {     int min;     if(x<y)     {         return x;     }     else     {         return y;     } }  int add(int x,int y) {     return (x+y); } 供参考～  函数指针变量需要确定参数个数和类型～

引用 2 楼 赵4老师 的回复：printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”这个有时间限制吗🚫

引用 1 楼 qq_36835025 的回复：对不起，自己粗心scanf里面打错了符号，刚检查出来那问题解决了吗？ 指向函数的指针不是： int （*p）（）= & fun；//fun是函数名，要加取地址符吗？

对不起，自己粗心scanf里面打错了符号，刚检查出来


Question: 关于c语言强转问题

是在嵌入式系统用的哦，

引用 楼主 守望者910 的回复:请问各位老师，这个整数强转成地址，然后赋值的时候总是段错误怎么回事呀？比如 unsigned  int  a =0x12345678   unsigned short *p;      p=（unsigned  short *）a;    *p =0x78; 编译出现段错误是怎么回事呀？请各位老师指出问题 你的这种用法是在嵌入式系统用的。在Windows下，访问内存，你必须先向系统申请一片内存，系统返回内存地址，你才能使用该地址 你随便写个地址就访问是几个意思，万一该地址被系统或其他地方使用，你这样一改写，岂不出现问题，而且该问题很难查找

引用 3 楼 weixin_44327736的回复:不是unsigned int 的范围问题吗？感觉0x12345678已经超过它的存储范围了 没超过范围呀，这个范围是0x0-0xffffffff，没超过呀

每个进程都有自己的地址范围，不是随便就能用的。

引用 1 楼 user-5 的回复:你怎么知道0x12345678 这个地址是能让你访问的？ IsBadReadPtr The IsBadReadPtr function verifies that the calling process has read access to the specified range of memory.   BOOL IsBadReadPtr(   CONST VOID *lp,  // address of memory block   UINT ucb         // size of block );   Parameters lp  Pointer to the first byte of the memory block.  ucb  Specifies the size, in bytes, of the memory block. If this parameter is zero, the return value is zero.  Return Values If the calling process has read access to all bytes in the specified memory range, the return value is zero.  If the calling process does not have read access to all bytes in the specified memory range, the return value is nonzero.   If the application is compiled as a debugging version, and the process does not have read access to all bytes in the specified memory range, the function causes an assertion and breaks into the debugger. Leaving the debugger, the function continues as usual, and returns a nonzero value This behavior is by design, as a debugging aid.   Remarks If the calling process has read access to some, but not all, of the bytes in the specified memory range, the return value is nonzero.   In a preemptive multitasking environment, it is possible for some other thread to change the process's access to the memory being tested. Even when the function indicates that the process has read access to the specified memory, you should use structured exception handling when attempting to access the memory. Use of structured exception handling enables the system to notify the process if an access violation exception occurs, giving the process an opportunity to handle the exception.   QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winbase.h.   Import Library: Use kernel32.lib.  See Also Memory Management Overview, Memory Management Functions, IsBadCodePtr, IsBadStringPtr, IsBadWritePtr

你怎么知道0x12345678 这个地址是能让你访问的？


Question: VS Code写C语言标准头文件报错，小白求解

希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

单击旁边的小灯泡，打开配置的json文件，把头文件的路径写进IncludePath就可以了

初学不建议用vscode，配置项多。还是vs比较，跟着引导生成就可以了。

按照提示，设置好头文件的路径即可

Visual C++ 2010 Express简体中文版http://pan.baidu.com/s/1bnwRVLt


Question: 实型数据，赋值运算符

默认情况下，浮点常量都是以double存储在内存中，末尾加上f后强制编译器按照float存储。 例如3.14E30和3.14E30f，3.14E30以64位double存在内存中，float f=3.14E30需要隐式转换，double转为float， 3.14E30f以32位float存储在内存中，float f=3.14E30f不需要隐式转换

理解和讨论之前请先学会如何观察！  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

float f=3.14，计算机按什么类型存储3.14

类型隐式提升char类型的计算，提升为int，float类型的提升为double类型。

浮点数格式 http://bbs.csdn.net/topics/390676437


Question: While

不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。

引用 楼主 qq_45444545的回复:While这个逻辑思维是怎么样的，求解 while(条件){执行语句}，进入while循环时判断条件，条件为真，执行语句，条件为假，跳出循环


Question: c语言

参数个数需要统一，一个一个改吧


Question: 大神帮我看看这个哪里错了，平均分数不对

刚才打断点 逐步循环了一下！发现应该是i=0

引用 5 楼 qq_42755412 的回复：[quote=引用 4 楼 不减20斤不换网名的回复:][quote=引用 3 楼 qq_42755412 的回复：]# include <stdio.h>  int main(void) { int i, j, k; float a;  k = 0; i = 1;//初始应该改为0,即i=0;  printf("请输入分数，以-1结束："); scanf("%d", &j);  while (j != -1) { k = k + j; i = i + 1;  printf("请输入分数，以-1结束："); scanf("%d", &j); } //printf("%d",i); 循环结束时i比输入的值的个数多1 if (i != 0) { a = (float) k / i; printf("平均分数是：%.2f\n", a); } else    printf("No\n");   return 0; }谢谢大哥[/quote] 没事，很高兴帮到你。有问题还可以问我，只不过缺点积分下东西[/quote]太直接了

引用 4 楼 不减20斤不换网名的回复:[quote=引用 3 楼 qq_42755412 的回复：]# include <stdio.h>  int main(void) { int i, j, k; float a;  k = 0; i = 1;//初始应该改为0,即i=0;  printf("请输入分数，以-1结束："); scanf("%d", &j);  while (j != -1) { k = k + j; i = i + 1;  printf("请输入分数，以-1结束："); scanf("%d", &j); } //printf("%d",i); 循环结束时i比输入的值的个数多1 if (i != 0) { a = (float) k / i; printf("平均分数是：%.2f\n", a); } else    printf("No\n");   return 0; }谢谢大哥[/quote] 没事，很高兴帮到你。有问题还可以问我，只不过缺点积分下东西

引用 3 楼 qq_42755412 的回复：# include <stdio.h>  int main(void) { int i, j, k; float a;  k = 0; i = 1;//初始应该改为0,即i=0;  printf("请输入分数，以-1结束："); scanf("%d", &j);  while (j != -1) { k = k + j; i = i + 1;  printf("请输入分数，以-1结束："); scanf("%d", &j); } //printf("%d",i); 循环结束时i比输入的值的个数多1 if (i != 0) { a = (float) k / i; printf("平均分数是：%.2f\n", a); } else    printf("No\n");   return 0; }谢谢大哥

# include <stdio.h>  int main(void) {     int i, j, k;     float a;      k = 0;     //i = 1;     i = 0;     printf("请输入分数，以-1结束：");     scanf("%d", &j);      while (j != -1)     {         k = k + j;         i = i + 1;          printf("请输入分数，以-1结束：");         scanf("%d", &j);     }     printf("k = %d, i = %d\n", k, i);     if (i != 0)     {         a = (float) k / i;         printf("平均分数是：%.2f\n", a);     }     else         printf("No\n");       return 0; } 供参考～ i应该从0开始。

把i的初始值改成0，试一试


Question: 实型数据

float 的精度是 6~7 位有效数字。  计算机中存储的是二进制，无法精确的表示所有的十进制小数 比如  0.25 转换成二进制是 0.01 0.2 转换成二进制是 0.0011001....  float 共 32 位二进制比特，一位表示符号，八位表示指数，23位表示底数（尾数）： 所以 float 的十进制精度是 log(2^23) = 6.92 位有效数字  关于浮点型数据在内存中的存储方式可以自行百度，附其中一条结果： https://www.cnblogs.com/BradMiller/archive/2010/11/25/1887945.html

参考下： https://www.cnblogs.com/c-primer/p/5992696.html


Question: 求解惑

else if 中对disc赋值为0，需要把=改为==

这是c语言的问题，我发错了


Question: dataset相同编号，不同数量的数据合并问题

我觉得这跟数据是不是从数据库来的没关系，主要是手段。比如楼主从字符串获取了数据，完全可以用linq来处理。效果跟处理数据库的数据是一样的。 比如下面的代码就跟楼主想要的效果差不多。 5 sum中使用group by 下面例子讲解如何使用sum来统计每一组比如下面 每一个player属于一个组team的然后又一个得分score 然后我们使用sum来统计分组中所有玩家的分数 view sourceprint? var players = new List<Player> {     new Player { Name = "Alex", Team = "A", Score = 10 },     new Player { Name = "Anna", Team = "A", Score = 20 },     new Player { Name = "Luke", Team = "L", Score = 60 },     new Player { Name = "Lucy", Team = "L", Score = 40 }, };   var teamTotalScores =     from player in players     group player by player.Team into playerGroup     select new     {         Team = playerGroup.Key,         TotalScore = playerGroup.Sum(x => x.Score),     };  例子来源：http://www.bamn.cn/News/views/123

引用 1 楼 轻箬笠 的回复:对C#的了解仅限于简单的例子。类似楼主这个问题。用sql语句就可以处理了 select sum(number1) as n1, sum(number2) as n2 from table group by id  不好意思，你可能没懂我的操作，我所得到的数据不是从数据库中获取的，而是通过输入框，扫描二维码标签录入的。所以目前看来跟数据库没多大联系。谢谢你的解答。不然就冷贴了


Question: C语言实验求助！！！

实验诶。。。这样不好吧，自己加油做吧，努力一下，并不难的，就是有点长


Question: 求助请教！codeup 1003

引用 1 楼 user-1的回复:为什么要写m=m+i; 一语点醒梦中人，因我看题目的意思是每一行的总和，以为第一个数既要表示后面数的个数又要算进 去但看样例并不是

为什么要写m=m+i;


Question: codeup问题1817，我写的代码总是时间超限！有大佬可以帮我看看吗！

#include <stdio.h>  int main() {   char a[13], b[13], *p = a;   int x, y;    while (scanf("%c", p) != EOF)     if (*p == 10)     {       *(p + 1) = 0, p = a;       sscanf(a, "%d", &x);       sscanf(b, "%d", &y);       printf("%d\n", x + y);     }     else       if (*p == 32) *(p + 1) = 0, p = b;       else         if (*p != ',') p++;      return 0; }


Question: C语言指针部分中*p与p的区别

//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 | //+------------------+-----------------------------------------+---------------+

引用 2 楼 自信男孩 的回复：[quote=引用 1 楼 （.....） 的回复:] 对，指针的算数运算有个 *p++ 和*++p 嗯，那会学的比较混 描述的时候是不是应该指明指针p是一重指针还是二重指针？[/quote]嗯，int * p 一重 不太清楚为什么： * p + + = *（p++） 要先取*p，再增址。括号优先级不是最高吗  （今天借机会问一下）

//是 int * p

引用 1 楼 （.....） 的回复:对，指针的算数运算有个 *p++ 和*++p 嗯，那会学的比较混 描述的时候是不是应该指明指针p是一重指针还是二重指针？

对，指针的算数运算有个 *p++ 和*++p 嗯，那会学的比较混


Question: 求解一道题

五百元有这个整额货币吗，两块的也没有了哦

我的思路是先确定最大面额的找零货币的张数，也就是50块的张数，用找零/50可以得出50块的张数，然后计算20块的张数，用找零总数减去50块的张数×50可以得出余额a，再用a/20即可得出20块的张数，10块的，5块的还有剩下的面值的货币张数也同理，我利用while循环让程序可以一直运行，但是相比单次程序，这个程序的运行初始化的时间会比较长，具体原因我不知道，求大佬指点

#include<stdio.h> int main() {     int sum;     int pay;     int givechange;      int one,two,five,ten,twenty,fifty,hundred;         one = 0;         two = 0;         five = 0;         ten = 0;         twenty = 0;         fifty = 0;      while(1)     {          printf("input sum\n");         scanf("%d",&sum);           printf("input pay\n");         scanf("%d",&pay);           givechange = pay - sum;         printf("give change for %d\n",givechange);           fifty  = givechange / 50;         twenty = (givechange - (fifty*50)) / 20;          ten   = (givechange - (fifty*50) - (twenty*20)) / 10;          five  = (givechange - (fifty*50) - (twenty*20) - (ten*10)) / 5;          two   = (givechange - (fifty*50) - twenty*20) - (ten*10) - (five*5) / 2;          one   = givechange - (fifty*50) - (twenty*20) - (ten*10) - (five*5) - (two*2);           printf("*******************\n");         printf("fifty= %d\n",fifty);         printf("twenty= %d\n",twenty);         printf("ten= %d\n",ten);         printf("five= %d\n",five);         printf("two= %d\n",two);         printf("one= %d\n",one);         printf("\n");         printf("\n");      } }

这种大问题应该怎么入手小白也很懵

啊哈，思路：（稍点一下，毕竟upon hearing of your genius）  一个数：463 哈 先对100进行除法，取整结果（这就是要找顾客的100元的张数） 再对100进行取余，结果为63  （不是循环结构，是顺序结构）  新的数：63 哈 再对10进行整除（注意20元和50元） 再对10进行取余，变成了个位数  新的数，（注意5元）即可


Question: 实型变量

f+1-f，不是说浮点数参与运算时都是双精度吗，书上说最末位加上1，保存为float类型，有点矛盾，大神能解释一下

浮点数格式 http://bbs.csdn.net/topics/390676437

哪位大神能解释一下f+1-f，0怎么来的，里面那些隐式转换能详细解释一下

引用 3 楼 轻箬笠的回复:f+1-f时都是double类型，我咋觉得这句话就有问题呢？ f+1-f，是float+int-float，为啥要转成double进行计算呢，不是转成float进行计算的吗？我记得做算术运算的时候，有个转换顺序的，类似上面这种情况，没有出现double的话，转成float就终止了。难道是我记错了？ 浮点数参与运算是以双精度进行的，float先转成double类型，参与运算，所以double+int-double，还是double，

认真看了两遍这题，发现玩了多年的C不认识了！！ 1：float输出的为什么是近似值？上次在项目中已发现这个问题，但时间太紧了没上心。 2：floa只能保存6位有效数？我没看错吧？惊~


Question: 运行这个程序，电脑CPU使用空前高（不是标题党）

数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633

引用 7 楼 自信男孩 的回复：#include<stdio.h> #include<malloc.h>  //int n=1;   // 用来统计链表中节点个数。 int n=0;   // 用来统计链表中节点个数。 struct Student {     int num;     float score;     struct Student * next; };  int main() {     struct Student  * head;      struct Student * creat();      // 输入函数的声明     void print(struct Student * head);   // 输出函数      head=creat();     print(head);      return 0; }  struct Student * creat() {     struct Student *head;     struct Student *p1,*p2;      head=NULL;     p1=p2=(struct Student *)malloc(sizeof(struct Student));      scanf("%d%f",&p1->num,&p1->score);     // 输入第一个节点的数据      while(p1->num!=0)     {         n++;         if(n==1)             head=p1;         else {             p2->next=p1;             p2=p1;         }          // 接着再开辟一个新的节点         p1 = (struct Student *)malloc(sizeof(struct Student));         scanf("%d%f",&p1->num,&p1->score);     }     free(p1);    //最后一个几点需要释放掉，因为并没有链入链表中     p2->next=NULL;      printf("n = %d\n", n);     return (head); }  void print(struct Student * head) {     struct Student * p;     int i;     printf("the  %d records are :\n",n);     printf("num      score\n");     for(i=0,p=head; i < n; i++) {         printf("%d         %f\n",p->num,p->score);         p=p->next;     } }   程序有问题，输出的时候，按照楼主的逻辑，最后一个节点也算上，但是最后一个节点并没有链入链表中，而是直接返回了。所以 n的值比链表实际长度大1. 看一下上面的逻辑～辛苦了，老哥 free（p1） // 这个学到了 那个n，我也知道为啥了，确实有毛病

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

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

运行不成功的具体表现是： 书上输入（1001，99 1002，98 0，0） 即输出两节点数据  而我不一样...同上输入后，按回车键没反应，瞎试了试发现（无法输入数字，而输入字符后按回车字符消失）并且额..电脑喘的厉害....

引用 1 楼 （.....） 的回复：积极向上正能量.....我电脑喘了好一阵子

积极向上正能量.....


Question: 用低级钩子尝试屏蔽系统按键，像WIN,alt+Tab都成功了，但是任务管理器的就是不行

引用 2 楼 赵4老师的回复:任务管理器和普通进程不一样。 不能用拦截系统按键的方式阻止任务管理器打开吗，那有其他办法吗

任务管理器和普通进程不一样。

不沉~~~


Question: 记录输入的数字、空格和换行、其他字符的输入个数

#include<stdio.h>  //void main() int main() {     //int blank=0,i=0,z,a[10]={0,0,0,0,0,0,0,0,0,0},others=0;     int blank=0,i=0,z,a[10]={0}, others=0;     for (;;)//死循环用来输入     {         z=getchar();         if (z==32||z==10)//判断是否为空格和换行         {             blank=blank+1;         }         //if (z>=48&&z<=57)//判断是否为数字         else if (z>=48&&z<=57)//判断是否为数字         {             a[z-'0']++;             /*             switch (z)             {                 case 48:a[0]=a[0]+1;break;                 case 49:a[1]=a[1]+1;break;                 case 50:a[2]=a[2]+1;break;                 case 51:a[3]=a[3]+1;break;                 case 52:a[4]=a[4]+1;break;                 case 53:a[5]=a[5]+1;break;                 case 54:a[6]=a[6]+1;break;                 case 55:a[7]=a[7]+1;break;                 case 56:a[8]=a[8]+1;break;                 case 57:a[9]=a[9]+1;break;             }             */         }         //if (!(z>=48&&z<=57)&&!(z==32||z==10))//去除数字和空格和换行的其他字符         else         {             others=others+1;         }         if (z==10)//遇到换行时结束输入         {             break;         }     }     printf("blank=%d\n",blank);     for (i=0;i<10;i++)     {         printf("a[%d]=%d\n",i,a[i]);     }     printf("others=%d\n",others);  }  供参考～  程序写的有些复杂，可以更简单一些的。

有什么问题吗？

原来其它字符的ASCII码是这样的啊


引用 7 楼 赵4老师 的回复:CX的全称是Coordinate axis X CY的全称是Coordinate axis Y 好的，非常感谢！

CX CY  x轴和y轴

可惜我没搜到相关图。 只搜到这个：

千字不如一图。

引用 1 楼 cmztestat 的回复:CX CY  x轴和y轴 引用 3 楼 hack_to_hell 的回复:“SM_CYSIZEFRAME is the height of the vertical border”我从开始就把它当成是官档写错了，我按X和Y都是width  根据SM_CYCAPTION来看的话，这里的X和Y应该是指横向宽和纵向高吧，所以CX是指左右边框的横向宽度，CY指上下边框的纵向宽度？

引用 1 楼 cmztestat 的回复:CX CY  x轴和y轴 所以X轴是指上下边框？ 那么对于Y轴的左右边框，说它的高度岂不是很不合理？


引用 6 楼 qq_43208299 的回复：[quote=引用 3 楼 自信男孩的回复:]scanf_s缺少一个参数，scanf_s比scanf安全，前提是第三个参数，可以确定%s字符串长度。 产什么意思，不是很明白[/quote]以上代码如果用scanf_s,第二行应改为scanf_s("%s",buf,5),表示最多读取4个字符，因为buf[4]要放'\0'。   搜一下呗，这是我挑的，scanf_s函数有三个参数，你少一个

引用 3 楼 自信男孩的回复:scanf_s缺少一个参数，scanf_s比scanf安全，前提是第三个参数，可以确定%s字符串长度。 产什么意思，不是很明白

引用 1 楼 user-4的回复:使用scanf_s需要设置缓冲区长度，而原来的scanf不安全就是因为很容易越界  	scanf_s("%s", name,sizeof(name));  那sizeo缓冲的f长度是为上面的20吗？

引用 2 楼 csucxy的回复:这个程序在运行时会报运行时错误，楼主的编译器是？ VS2012 这程序运行时没有报错，但就是没有输出字符串

这个程序在运行时会报运行时错误，楼主的编译器是？


Question: 数组问题

引用 2 楼 英雄@末路的回复:你换个名字，放main前面就没事了 好的，十分感谢您的回复！

引用 1 楼 Italink的回复:标准库中已经使用了begin，end，所以你再定义为数组就会报错，可以换个名字，加前后缀，换大小写 好的，谢谢您的用心回复，十分感谢！

你换个名字，放main前面就没事了


Question: keil5  编译问题

因为我环境没配好

浮点不支持？这个要看你的具体环境吧


Question: 为什么：指针所指的字符串，不能赋值（改变）

能不能修改要看编译器的行为，谁说不能改，只要你不加/GF编译选项就可以改，只是不建议这么做 如果加了/GF编译选项就不能改，否则运行出现异常

定义指针指向字符串常量，只是把字符常量的地址给指针，指针是不会构造对象的，而使用字符数组定义，则是通过这个字符串常量进行构造自己的字符串前者使用指针指向常量，所以不能修改，后者字符数组是自己的字符串，可所以可以修改

如果你用了new那就可以这么干

：我是一只没得感情的程序猴子

引用 5 楼 自信男孩 的回复：因为p只是一个指针，占用4个字节，其存放的是字符串常量的地址，而p[1] = 'x';是对字符串常量赋值，所以会出错。 而a是数组可读可写有收获，谢谢

引用 11 楼 （.....） 的回复:[quote=引用 7 楼 赵4老师 的回复：]#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！ 不了不了，谢谢[/quote] 怕了吧。

引用 7 楼 赵4老师 的回复：#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！ 不了不了，谢谢

引用 8 楼 英雄@末路 的回复：指针，常量，地址空间这些概念要先搞清楚啊 那个字符串是常量。。。谢谢，会注意的

引用 3 楼 Mr_sandman1994 的回复：char * p="“hello ..”；实际上是const char *p = "Hello ...";  常量无法修改；好的，谢谢

指针，常量，地址空间这些概念要先搞清楚啊 那个字符串是常量。。。


Question: 有两个问题请教一下

1 是添加字符串结束符 2 是先+1再用，省的把当前的值覆盖了，s[0]不是前面用过了么。


Question: 如何给子窗口设定编号？

SetWindowLong(hWnd, GWL_ID,  XXXX)

这个字段本来就是添加一些附带信息用的，一般不会很大，实际上一般也用不上这个字段 如果你要附带比较大的数据，一般也不是这么使用的，应该先自行分配内存，再将内存存入wc.cbWndExtra即可 没必要一定要给wc.cbWndExtra分配很大的空间，使用也不方便，重在设计

引用 5 楼 user-2 的回复:你可以指定从第几个字节开始呀 但是每次只能读取几个字节呀

你可以指定从第几个字节开始呀

引用 3 楼 user-2 的回复:wc.cbWndExtra是为每个窗口预留的空间，每个窗口实例私有，如果这个成员值为1024，是为这个窗口实例分配了1KB空间，不是窗口类 wc.cbClsExtra是为每个窗口类预留的空间，所有以这个窗口类生成的窗口实例共享 可是如果用GetWindowLongPtr这些来读写，最多只能用其中的8个字节是吗？

引用 1 楼 user-2 的回复:很简单，使用WNDCLASS结构中cbWndExtra参数保存即可  wc.cbWndExtra这个成员，这个成员指定了系统为每个窗口分配多少字节的额外空间。 创建窗口后，如果想要使用这段额外空间，可以使用以下六个函数之一： GetWindowWord(hWnd, n)  // 从第n个字节开始，读取两个字节 GetWindowLong(hWnd, n)  // 从第n个字节开始，读取四个字节 GetWindowLongPtr(hWnd, n) // 从第n个字节开始读取。如果系统是32位，则读取4个字节；如果系统是64位，则读取8个字节。（这个一般用来读取指针变量） SetWindowWord(hWnd, n, value) SetWindowLong(hWnd, n, value) SetWindowLongPtr(hWnd, n, value) 额，，，可是这几个子窗口是用的同一个窗口类。。。。还有就是，cbWndExtra不是预留的成员吗？怎么成了指定分配一段空间了？如果这个成员值为1024，是不是为这个类分配了1KB空间？


Question: 请问这个程序如何退出循环

引用 11 楼 （.....）的回复:‘y’   ‘Y’ system（“pause”） 是不是没用到啊 方便加一下你可以吗，交流一下

引用 10 楼 （.....） 的回复：// 按 除y或Y以外的其它键就行了 if（c==y||c==Y）      continue； else          break；哦，对不起，没认真看，我说的不对口

引用 11 楼 （.....）的回复:‘y’   ‘Y’ system（“pause”） 是不是没用到啊 应该是没用到吧，额额

‘y’   ‘Y’ system（“pause”） 是不是没用到啊

引用 6 楼 （.....）的回复:continue语句的作用是跳过本循环中剩余的语句而强制执行下一次循环。continue语句只用在for、while、do-while等循环体中，常与if条件语句一起使用，用来加速循环。 请问 要是要在没输入第一个数字的想要退出怎么办， 即 请输入第一个整数（已打印好）：此时想要退出怎么办

引用 5 楼 （.....）的回复:我：是了，键盘输入y或Y，继续循环。否则跳出循环  我还有一个问题： scanf（“\n%c”，&c）； 是什么意思，能换行吗…… 这是用来屏蔽回车的， 因为请输入运算符 和请输入第二个整数会在同一行，输不了运算符

引用 1 楼 自信男孩的回复:#include<stdio.h> #include <stdlib.h> int main() {     int a,b,y;     char c;     /*printf("请输入第一个整数:");       scanf("%d",&a);       printf("请输入运算符:");       scanf("\n%c",&c);       printf("请输入第二个整数:");       scanf("%d",&b);       printf("计算:y=%d%c%d\n",a,c,b);*/     //scanf("计算:y=%d%c%d\n",&a,&c,&b);     while(1)     {         printf("请输入第一个整数:");         scanf("%d",&a);         printf("请输入运算符:");         scanf("\n%c",&c);         printf("请输入第二个整数:");         scanf("%d",&b);         printf("计算:y=%d%c%d\n",a,c,b);         switch(c)         {             case'+':y=a+b;break;             case'*':y=a*b;break;             case'-':y=a-b;break;             case'/':y=a/b;break;             default:                     printf("请检查是否输入错误\n");break;         }         printf("y=%d\n",y);         printf("Continue (Y/N)");         getchar();         scanf("%c", &c);         if (c == 'Y' || c == 'y')             continue;         else             break;         system("pause");     }     return 0; } 供参考～ yes和no的意思吗

引用 1 楼 自信男孩的回复:#include<stdio.h> #include <stdlib.h> int main() {     int a,b,y;     char c;     /*printf("请输入第一个整数:");       scanf("%d",&a);       printf("请输入运算符:");       scanf("\n%c",&c);       printf("请输入第二个整数:");       scanf("%d",&b);       printf("计算:y=%d%c%d\n",a,c,b);*/     //scanf("计算:y=%d%c%d\n",&a,&c,&b);     while(1)     {         printf("请输入第一个整数:");         scanf("%d",&a);         printf("请输入运算符:");         scanf("\n%c",&c);         printf("请输入第二个整数:");         scanf("%d",&b);         printf("计算:y=%d%c%d\n",a,c,b);         switch(c)         {             case'+':y=a+b;break;             case'*':y=a*b;break;             case'-':y=a-b;break;             case'/':y=a/b;break;             default:                     printf("请检查是否输入错误\n");break;         }         printf("y=%d\n",y);         printf("Continue (Y/N)");         getchar();         scanf("%c", &c);         if (c == 'Y' || c == 'y')             continue;         else             break;         system("pause");     }     return 0; } 供参考～ 请问这个是什么意思呢printf("continue(Y/N)")

请问这个是什么意思呢printf("continue(Y/N)")


Question: 求助！帮帮孩子吧

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 [code=c]//请今后要用 char c; scanf("%c",&c); //时，都改为 char s[2]; char c; scanf("%1s",s); c=s[0]; //自动跳过一个或多个空格或Tab字符或回车换行，读取下一个字符。 [/code]

这是c primer plus第六版的194面的例子，是一个识别单词的程序 输出实例： reason is a powerful servant but an inadequate master. | character=55,word=9,lines=3,partial lines=0

#include<stdio.h> #include<ctype.h> int main(void) { 	char c;//字符 	char pre;//读入前一个字符 	long n_chars=0L;//读入字符数 	int p_lines=0;//不完整行数行数  	int n_words=0;//单词数 	int n_lines=0;//行数 	bool inword=false; 	printf("Enter text to be annalyzed(| to terminate):\n"); 	while((c=getchar())!='|') 	{ 		n_chars++; 		if(c=='\n') 			n_lines++; 		if(!isspace(c) && !inword) 		{ 			inword=true; 			n_words++; 		} 		if(isspace(c)&&inword) 			inword=false; 		pre='c'; 	} 	if(pre='\n') 		p_lines=0; 	printf("charecters=%ld,words=%d,lines=%d,partial lines=%d",n_chars,n_words,n_lines,p_lines); 	return 0; }

好的，等我开个机…马上

scanf的%c能接收空格并识别空格 while外，判断pre='\n'有问题。  建议贴出你的代码，可以帮你试一下

第十五行两个分号忽略一下

按回车没有结果


Question: 为什么要求原码呢？

因为结果是一样的，而补码乘法很费力

因为结果是一样的，而补码乘法很费力

但那不是原码的十进制数， -2的原码是-10或1000 0010，即82H


Question: 用主函数调用两个函数求最大公约数和最小公倍数

楼主你想问什么

int yue(int m,int n) {     int a,b,c;     a=m;     b=n;     while (1) {         c=a>b?a-b:b-a;         if(c == 0 || (a%c==0 && b%c == 0))             break;         a=b;         b=c;         c=a>b?a-b:b-a;     }     if (c == 0)         c = b;      return c; } 需要用循环


Question: c语言计算最大公约数

#include<stdio.h>  int main() {     int a,b,c,m,n;     printf("pease input two numbers:\n");     scanf("%d%d",&m,&n);     a=m;     b=n;     while (1) {         c=a>b?a-b:b-a;         if(c == 0 || (a%c==0 && b%c == 0))             break;         a=b;         b=c;         c=a>b?a-b:b-a;     }     if (c == 0)         c = b;     printf("%d与%d的最大公约数是%d\n",m,n,c); } 供参考～

#include<stdio.h>  int main() {     int a,b,c,m,n;     printf("pease input two numbers:\n");     scanf("%d%d",&m,&n);     a=m;     b=n;     while (1) {         c=a>b?a-b:b-a;         if(c == 0 || (a%c==0 && b%c == 0))             break;         a=b;         b=c;         c=a>b?a-b:b-a;     }     printf("%d与%d的最大公约数是%d\n",m,n,c); }  楼主的基础做了微调，但是这种算法有一个bug，那就是当m和n相等时，最后的结果最大公约数是0；


Question: C语言Time Limit Exceeded问题

嗯，我写一般会多加个括号，输入格式中％c会读取空格

引用 3 楼 tb_youth 的回复:while((scanf("%d%c%d",&a,&c,&b))!=EOF) 不加也没有影响，加了反而会冗余。scanf的返回值和EOF比较。

while((scanf("%d%c%d",&a,&c,&b))!=EOF)

输入scanf不等于eof再前加个括号

应该是输入格式的问题，比如1+2这样是可以的，1 + 2这样的就不执行，因为c字符匹配的运算符是' '空格。所以不会出结果。 建议把需求贴出来吧，还有除法运算时，对于除数是否为0没有判断


Question: 求教c

仿真calc为0x00，老师能具体解释下吗

理解和讨论之前请先学会如何观察！  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素


Question: 关于IMS的一点理解

5G的语音解决方案还是ims

差不多，VOLTE语音是走独立的pdn，与上网流量属于不同的PDN,互不影响


Question: 大神求救！

去掉第一个scanf的%d后的空格；  测试过了，输入4之后加上空格也是不行的。所以，只能去掉scanf中的空格

把你scanf中%d后的空格去掉 或者输入4的时候后面再输入一个空格


Question: 求大佬搭救，找不出错误

关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”

逗号是中文字符了吧，从编译提示上看到是这样的

引用 3 楼 LEooW的回复:change前面的逗号是中文字符吧，换成英文的逗号 十分谢谢你，对我很有帮助，祝你生活如意

change前面的逗号是中文字符吧，换成英文的逗号

chage前面是个全角，改成,

贴代码，这玩意儿看不清


Question: 如何获取标题栏的高度？

我就说这个问题还能难倒我？

引用 1 楼 赵4老师 的回复:仅供参考：             titlebarheight = win32api.GetSystemMetrics(win32con.SM_CYSIZE)             edgewidth = win32api.GetSystemMetrics(win32con.SM_CXEDGE)             cxborder = win32api.GetSystemMetrics(win32con.SM_CXBORDER)             cxsizeframe = win32api.GetSystemMetrics(win32con.SM_CXSIZEFRAME) #           print(titlebarheight,edgewidth,cxborder,cxsizeframe)             cx=left+cxsizeframe+edgewidth             cy=top+cxsizeframe+titlebarheight+cxborder+edgewidth+3  SM_CYSIZE得出来的是22。。。也不符合


Question: C语言 请教

理解和讨论之前请先学会如何观察！

typedef unsigned short int Uint16; typedef unsigned       int Uint32; #define AddrSizeof(SAddr,EAddr) (               \     (                                           \         (Uint16)(                               \             (Uint32)(EAddr) - (Uint32)(SAddr)   \         ) >> 1                                  \     ) + 1                                       \ ) /*求取两个地址之间有多少个U16数据*/ #include <stdio.h> int main() {     int i,j,s,e,a;      for (i=0;i<=32;i++) {         for (j=0;j<=32;j++) {             s=i;             e=i+j;             a=AddrSizeof(s,e);             printf("%2d..%2d 0x%02x..0x%02x %2d 0x%02x\n",s,e,s,e,a,a);         }     }     return 0; } // 0.. 0 0x00..0x00  1 0x01 // 0.. 1 0x00..0x01  1 0x01 // 0.. 2 0x00..0x02  2 0x02 // 0.. 3 0x00..0x03  2 0x02 // 0.. 4 0x00..0x04  3 0x03 // 0.. 5 0x00..0x05  3 0x03 // 0.. 6 0x00..0x06  4 0x04 // 0.. 7 0x00..0x07  4 0x04 // 0.. 8 0x00..0x08  5 0x05 // 0.. 9 0x00..0x09  5 0x05 // 0..10 0x00..0x0a  6 0x06 // 0..11 0x00..0x0b  6 0x06 // 0..12 0x00..0x0c  7 0x07 // 0..13 0x00..0x0d  7 0x07 // 0..14 0x00..0x0e  8 0x08 // 0..15 0x00..0x0f  8 0x08 // 0..16 0x00..0x10  9 0x09 // 0..17 0x00..0x11  9 0x09 // 0..18 0x00..0x12 10 0x0a // 0..19 0x00..0x13 10 0x0a // 0..20 0x00..0x14 11 0x0b // 0..21 0x00..0x15 11 0x0b // 0..22 0x00..0x16 12 0x0c // 0..23 0x00..0x17 12 0x0c // 0..24 0x00..0x18 13 0x0d // 0..25 0x00..0x19 13 0x0d // 0..26 0x00..0x1a 14 0x0e // 0..27 0x00..0x1b 14 0x0e // 0..28 0x00..0x1c 15 0x0f // 0..29 0x00..0x1d 15 0x0f // 0..30 0x00..0x1e 16 0x10 // 0..31 0x00..0x1f 16 0x10 // 0..32 0x00..0x20 17 0x11 // 1.. 1 0x01..0x01  1 0x01 // 1.. 2 0x01..0x02  1 0x01 // 1.. 3 0x01..0x03  2 0x02 // 1.. 4 0x01..0x04  2 0x02 // 1.. 5 0x01..0x05  3 0x03 // 1.. 6 0x01..0x06  3 0x03 // 1.. 7 0x01..0x07  4 0x04 // 1.. 8 0x01..0x08  4 0x04 // 1.. 9 0x01..0x09  5 0x05 // 1..10 0x01..0x0a  5 0x05 // 1..11 0x01..0x0b  6 0x06 // 1..12 0x01..0x0c  6 0x06 // 1..13 0x01..0x0d  7 0x07 // 1..14 0x01..0x0e  7 0x07 // 1..15 0x01..0x0f  8 0x08 // 1..16 0x01..0x10  8 0x08 // 1..17 0x01..0x11  9 0x09 // 1..18 0x01..0x12  9 0x09 // 1..19 0x01..0x13 10 0x0a // 1..20 0x01..0x14 10 0x0a // 1..21 0x01..0x15 11 0x0b // 1..22 0x01..0x16 11 0x0b // 1..23 0x01..0x17 12 0x0c // 1..24 0x01..0x18 12 0x0c // 1..25 0x01..0x19 13 0x0d // 1..26 0x01..0x1a 13 0x0d // 1..27 0x01..0x1b 14 0x0e // 1..28 0x01..0x1c 14 0x0e // 1..29 0x01..0x1d 15 0x0f // 1..30 0x01..0x1e 15 0x0f // 1..31 0x01..0x1f 16 0x10 // 1..32 0x01..0x20 16 0x10 // 1..33 0x01..0x21 17 0x11 // 2.. 2 0x02..0x02  1 0x01 // 2.. 3 0x02..0x03  1 0x01 // 2.. 4 0x02..0x04  2 0x02 // 2.. 5 0x02..0x05  2 0x02 // 2.. 6 0x02..0x06  3 0x03 // 2.. 7 0x02..0x07  3 0x03 // 2.. 8 0x02..0x08  4 0x04 // 2.. 9 0x02..0x09  4 0x04 // 2..10 0x02..0x0a  5 0x05 // 2..11 0x02..0x0b  5 0x05 // 2..12 0x02..0x0c  6 0x06 // 2..13 0x02..0x0d  6 0x06 // 2..14 0x02..0x0e  7 0x07 // 2..15 0x02..0x0f  7 0x07 // 2..16 0x02..0x10  8 0x08 // 2..17 0x02..0x11  8 0x08 // 2..18 0x02..0x12  9 0x09 // 2..19 0x02..0x13  9 0x09 // 2..20 0x02..0x14 10 0x0a // 2..21 0x02..0x15 10 0x0a // 2..22 0x02..0x16 11 0x0b // 2..23 0x02..0x17 11 0x0b // 2..24 0x02..0x18 12 0x0c // 2..25 0x02..0x19 12 0x0c // 2..26 0x02..0x1a 13 0x0d // 2..27 0x02..0x1b 13 0x0d // 2..28 0x02..0x1c 14 0x0e // 2..29 0x02..0x1d 14 0x0e // 2..30 0x02..0x1e 15 0x0f // 2..31 0x02..0x1f 15 0x0f // 2..32 0x02..0x20 16 0x10 // 2..33 0x02..0x21 16 0x10 // 2..34 0x02..0x22 17 0x11 // 3.. 3 0x03..0x03  1 0x01 // 3.. 4 0x03..0x04  1 0x01 // 3.. 5 0x03..0x05  2 0x02 // 3.. 6 0x03..0x06  2 0x02 // 3.. 7 0x03..0x07  3 0x03 // 3.. 8 0x03..0x08  3 0x03 // 3.. 9 0x03..0x09  4 0x04 // 3..10 0x03..0x0a  4 0x04 // 3..11 0x03..0x0b  5 0x05 // 3..12 0x03..0x0c  5 0x05 // 3..13 0x03..0x0d  6 0x06 // 3..14 0x03..0x0e  6 0x06 // 3..15 0x03..0x0f  7 0x07 // 3..16 0x03..0x10  7 0x07 // 3..17 0x03..0x11  8 0x08 // 3..18 0x03..0x12  8 0x08 // 3..19 0x03..0x13  9 0x09 // 3..20 0x03..0x14  9 0x09 // 3..21 0x03..0x15 10 0x0a // 3..22 0x03..0x16 10 0x0a // 3..23 0x03..0x17 11 0x0b // 3..24 0x03..0x18 11 0x0b // 3..25 0x03..0x19 12 0x0c // 3..26 0x03..0x1a 12 0x0c // 3..27 0x03..0x1b 13 0x0d // 3..28 0x03..0x1c 13 0x0d // 3..29 0x03..0x1d 14 0x0e // 3..30 0x03..0x1e 14 0x0e // 3..31 0x03..0x1f 15 0x0f // 3..32 0x03..0x20 15 0x0f // 3..33 0x03..0x21 16 0x10 // 3..34 0x03..0x22 16 0x10 // 3..35 0x03..0x23 17 0x11 // 4.. 4 0x04..0x04  1 0x01 // 4.. 5 0x04..0x05  1 0x01 // 4.. 6 0x04..0x06  2 0x02 // 4.. 7 0x04..0x07  2 0x02 // 4.. 8 0x04..0x08  3 0x03 // 4.. 9 0x04..0x09  3 0x03 // 4..10 0x04..0x0a  4 0x04 // 4..11 0x04..0x0b  4 0x04 // 4..12 0x04..0x0c  5 0x05 // 4..13 0x04..0x0d  5 0x05 // 4..14 0x04..0x0e  6 0x06 // 4..15 0x04..0x0f  6 0x06 // 4..16 0x04..0x10  7 0x07 // 4..17 0x04..0x11  7 0x07 // 4..18 0x04..0x12  8 0x08 // 4..19 0x04..0x13  8 0x08 // 4..20 0x04..0x14  9 0x09 // 4..21 0x04..0x15  9 0x09 // 4..22 0x04..0x16 10 0x0a // 4..23 0x04..0x17 10 0x0a // 4..24 0x04..0x18 11 0x0b // 4..25 0x04..0x19 11 0x0b // 4..26 0x04..0x1a 12 0x0c // 4..27 0x04..0x1b 12 0x0c // 4..28 0x04..0x1c 13 0x0d // 4..29 0x04..0x1d 13 0x0d // 4..30 0x04..0x1e 14 0x0e // 4..31 0x04..0x1f 14 0x0e // 4..32 0x04..0x20 15 0x0f // 4..33 0x04..0x21 15 0x0f // 4..34 0x04..0x22 16 0x10 // 4..35 0x04..0x23 16 0x10 // 4..36 0x04..0x24 17 0x11 // 5.. 5 0x05..0x05  1 0x01 // 5.. 6 0x05..0x06  1 0x01 // 5.. 7 0x05..0x07  2 0x02 // 5.. 8 0x05..0x08  2 0x02 // 5.. 9 0x05..0x09  3 0x03 // 5..10 0x05..0x0a  3 0x03 // 5..11 0x05..0x0b  4 0x04 // 5..12 0x05..0x0c  4 0x04 // 5..13 0x05..0x0d  5 0x05 // 5..14 0x05..0x0e  5 0x05 // 5..15 0x05..0x0f  6 0x06 // 5..16 0x05..0x10  6 0x06 // 5..17 0x05..0x11  7 0x07 // 5..18 0x05..0x12  7 0x07 // 5..19 0x05..0x13  8 0x08 // 5..20 0x05..0x14  8 0x08 // 5..21 0x05..0x15  9 0x09 // 5..22 0x05..0x16  9 0x09 // 5..23 0x05..0x17 10 0x0a // 5..24 0x05..0x18 10 0x0a // 5..25 0x05..0x19 11 0x0b // 5..26 0x05..0x1a 11 0x0b // 5..27 0x05..0x1b 12 0x0c // 5..28 0x05..0x1c 12 0x0c // 5..29 0x05..0x1d 13 0x0d // 5..30 0x05..0x1e 13 0x0d // 5..31 0x05..0x1f 14 0x0e // 5..32 0x05..0x20 14 0x0e // 5..33 0x05..0x21 15 0x0f // 5..34 0x05..0x22 15 0x0f // 5..35 0x05..0x23 16 0x10 // 5..36 0x05..0x24 16 0x10 // 5..37 0x05..0x25 17 0x11 // 6.. 6 0x06..0x06  1 0x01 // 6.. 7 0x06..0x07  1 0x01 // 6.. 8 0x06..0x08  2 0x02 // 6.. 9 0x06..0x09  2 0x02 // 6..10 0x06..0x0a  3 0x03 // 6..11 0x06..0x0b  3 0x03 // 6..12 0x06..0x0c  4 0x04 // 6..13 0x06..0x0d  4 0x04 // 6..14 0x06..0x0e  5 0x05 // 6..15 0x06..0x0f  5 0x05 // 6..16 0x06..0x10  6 0x06 // 6..17 0x06..0x11  6 0x06 // 6..18 0x06..0x12  7 0x07 // 6..19 0x06..0x13  7 0x07 // 6..20 0x06..0x14  8 0x08 // 6..21 0x06..0x15  8 0x08 // 6..22 0x06..0x16  9 0x09 // 6..23 0x06..0x17  9 0x09 // 6..24 0x06..0x18 10 0x0a // 6..25 0x06..0x19 10 0x0a // 6..26 0x06..0x1a 11 0x0b // 6..27 0x06..0x1b 11 0x0b // 6..28 0x06..0x1c 12 0x0c // 6..29 0x06..0x1d 12 0x0c // 6..30 0x06..0x1e 13 0x0d // 6..31 0x06..0x1f 13 0x0d // 6..32 0x06..0x20 14 0x0e // 6..33 0x06..0x21 14 0x0e // 6..34 0x06..0x22 15 0x0f // 6..35 0x06..0x23 15 0x0f // 6..36 0x06..0x24 16 0x10 // 6..37 0x06..0x25 16 0x10 // 6..38 0x06..0x26 17 0x11 // 7.. 7 0x07..0x07  1 0x01 // 7.. 8 0x07..0x08  1 0x01 // 7.. 9 0x07..0x09  2 0x02 // 7..10 0x07..0x0a  2 0x02 // 7..11 0x07..0x0b  3 0x03 // 7..12 0x07..0x0c  3 0x03 // 7..13 0x07..0x0d  4 0x04 // 7..14 0x07..0x0e  4 0x04 // 7..15 0x07..0x0f  5 0x05 // 7..16 0x07..0x10  5 0x05 // 7..17 0x07..0x11  6 0x06 // 7..18 0x07..0x12  6 0x06 // 7..19 0x07..0x13  7 0x07 // 7..20 0x07..0x14  7 0x07 // 7..21 0x07..0x15  8 0x08 // 7..22 0x07..0x16  8 0x08 // 7..23 0x07..0x17  9 0x09 // 7..24 0x07..0x18  9 0x09 // 7..25 0x07..0x19 10 0x0a // 7..26 0x07..0x1a 10 0x0a // 7..27 0x07..0x1b 11 0x0b // 7..28 0x07..0x1c 11 0x0b // 7..29 0x07..0x1d 12 0x0c // 7..30 0x07..0x1e 12 0x0c // 7..31 0x07..0x1f 13 0x0d // 7..32 0x07..0x20 13 0x0d // 7..33 0x07..0x21 14 0x0e // 7..34 0x07..0x22 14 0x0e // 7..35 0x07..0x23 15 0x0f // 7..36 0x07..0x24 15 0x0f // 7..37 0x07..0x25 16 0x10 // 7..38 0x07..0x26 16 0x10 // 7..39 0x07..0x27 17 0x11 // 8.. 8 0x08..0x08  1 0x01 // 8.. 9 0x08..0x09  1 0x01 // 8..10 0x08..0x0a  2 0x02 // 8..11 0x08..0x0b  2 0x02 // 8..12 0x08..0x0c  3 0x03 // 8..13 0x08..0x0d  3 0x03 // 8..14 0x08..0x0e  4 0x04 // 8..15 0x08..0x0f  4 0x04 // 8..16 0x08..0x10  5 0x05 // 8..17 0x08..0x11  5 0x05 // 8..18 0x08..0x12  6 0x06 // 8..19 0x08..0x13  6 0x06 // 8..20 0x08..0x14  7 0x07 // 8..21 0x08..0x15  7 0x07 // 8..22 0x08..0x16  8 0x08 // 8..23 0x08..0x17  8 0x08 // 8..24 0x08..0x18  9 0x09 // 8..25 0x08..0x19  9 0x09 // 8..26 0x08..0x1a 10 0x0a // 8..27 0x08..0x1b 10 0x0a // 8..28 0x08..0x1c 11 0x0b // 8..29 0x08..0x1d 11 0x0b // 8..30 0x08..0x1e 12 0x0c // 8..31 0x08..0x1f 12 0x0c // 8..32 0x08..0x20 13 0x0d // 8..33 0x08..0x21 13 0x0d // 8..34 0x08..0x22 14 0x0e // 8..35 0x08..0x23 14 0x0e // 8..36 0x08..0x24 15 0x0f // 8..37 0x08..0x25 15 0x0f // 8..38 0x08..0x26 16 0x10 // 8..39 0x08..0x27 16 0x10 // 8..40 0x08..0x28 17 0x11 // 9.. 9 0x09..0x09  1 0x01 // 9..10 0x09..0x0a  1 0x01 // 9..11 0x09..0x0b  2 0x02 // 9..12 0x09..0x0c  2 0x02 // 9..13 0x09..0x0d  3 0x03 // 9..14 0x09..0x0e  3 0x03 // 9..15 0x09..0x0f  4 0x04 // 9..16 0x09..0x10  4 0x04 // 9..17 0x09..0x11  5 0x05 // 9..18 0x09..0x12  5 0x05 // 9..19 0x09..0x13  6 0x06 // 9..20 0x09..0x14  6 0x06 // 9..21 0x09..0x15  7 0x07 // 9..22 0x09..0x16  7 0x07 // 9..23 0x09..0x17  8 0x08 // 9..24 0x09..0x18  8 0x08 // 9..25 0x09..0x19  9 0x09 // 9..26 0x09..0x1a  9 0x09 // 9..27 0x09..0x1b 10 0x0a // 9..28 0x09..0x1c 10 0x0a // 9..29 0x09..0x1d 11 0x0b // 9..30 0x09..0x1e 11 0x0b // 9..31 0x09..0x1f 12 0x0c // 9..32 0x09..0x20 12 0x0c // 9..33 0x09..0x21 13 0x0d // 9..34 0x09..0x22 13 0x0d // 9..35 0x09..0x23 14 0x0e // 9..36 0x09..0x24 14 0x0e // 9..37 0x09..0x25 15 0x0f // 9..38 0x09..0x26 15 0x0f // 9..39 0x09..0x27 16 0x10 // 9..40 0x09..0x28 16 0x10 // 9..41 0x09..0x29 17 0x11 //10..10 0x0a..0x0a  1 0x01 //10..11 0x0a..0x0b  1 0x01 //10..12 0x0a..0

我想问的是求取这两地址之间数据个数为什么要这么算

这不是语句，这是宏


Question: 为什么程序一致输出结果却不同？


Question: C语言scanf语句

这个双精度浮点数变量命名不是要的d开头吗。

引用 3 楼 bsnow 的回复:第一个正确输入"a=1b=3c=2" 中间不要空格  对不起以上我乱写的。  你第一句根本就输入不进去，因为你要求输入的字符 %c

第一个正确输入"a=1b=3c=2" 中间不要空格

第一输入有问题，你可以在scanf后面加一条语句打印出a, b, c，看一下是不是输入的。 第一个程序的正确输入是a=1 b=3 c=2

输入需要严格按照你scanf中的格式进行输入，你想输入1 3 2 应该按格式输入 a=1 b=3 c=2，最好把你scanf中那些a=去掉


Question: c语言小白求助大佬

主要是我真的不喜欢原来专业的。我尽力去尝试吧!还有1年多，多学多问

先确认一下你的输入是不是放到m, n的内存中，可以在scanf后通过printf打印出m, n的值。

输入的时候。121,11逗号不要用中文输入法。用英文输入法。 跨专业考研有点悬。除了编程语法，还有计算机组成原理，操作系统，网络知识，数据库等都要去学。 除了windows操作系统，linux操作系统也是一个面试的考题，考官或多或少都会问一些基本知识或者一些基本操作的问题。 另外一个就是英语口语。。

你121 和11之间用了中文的逗号


Question: (江湖救急)--VS2015 命令参数设置后调试接收不到

注意图中红框标出部分，你设置的是Release/Win32的属性，我猜你调试运行的可能是Debug或者是Release/X64的。 项目属性设置时要注意Debug/Release及Win32/X64四种情况。你的截图中只设置了其中一种。 如果调试运行与设置是对应的，运行结果应该是

你注意配置是Release而不是Debug了吗？


Question: 萌新求助大佬们

引用 2 楼 赵4老师的回复:仅供参考：#include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else                     return string; } void main() {     strcpy(string,"A \tstring\t\tof ,,tokens\n\nand some  more tokens, ");     strcpy(seps1,",\n");strcpy(seps2," \t");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234| LIYI|China | 010 |201110260000|OK");     strcpy(seps1,"|");strcpy(seps2," ");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234|LIYI||010|201110260000|OK");     strcpy(seps1,"");strcpy(seps2,"|");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"1234|LIYI||010|201110260000|OK");     strcpy(seps1,"|");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",a");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,"a,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",a,,b");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,a,,b,,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,");     strcpy(seps1,",");strcpy(seps2,"");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     }      strcpy(string,",,,");     strcpy(seps1,",");strcpy(seps2," ");     printf("\n[%s]\nTokens:\n",string);     token=zzstrtok(string,seps1,seps2);     while (token!=NULL) {         printf(" <%s>",token);         token=zzstrtok(NULL,seps1,seps2);     } } // //[A      string          of ,,tokens // //and some  more tokens, ] //Tokens: // <A> <string> <of> <> <tokens> <> <and> <some> <more> <tokens> <> //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234> <LIYI> <China> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <010> <201110260000> <OK> //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234> <LIYI> <> <010> <201110260000> <OK> //[a] //Tokens: // <a> //[a,b] //Tokens: // <a> <b> //[a,,b] //Tokens: // <a> <> <b> //[,a] //Tokens: // <> <a> //[a,] //Tokens: // <a> <> //[,a,,b] //Tokens: // <> <a> <> <b> //[,,a,,b,,] //Tokens: // <> <> <a> <> <b> <> <> //[,] //Tokens: // <> <> //[,,] //Tokens: // <> <> <> //[,,,] //Tokens: // <> <> <> <>  哇，厉害厉害，谢谢老师，我先去试试

引用 1 楼 user-2的回复:以逗号拆分字符串 谢谢，我发现c语言中，定义个结构体，直接可以拿到

以逗号拆分字符串


Question: 关于用c语言将mysql数据库某个表数据导入到sqlserver

我这要求就是只通过c语言编写的程序来进行数据转移，不能用其他数据库的管理软件。。。。

mysql导出为csv 用bcp将csv导入SQLServer


Question: （江湖救急）无法解析的外部符号 stderr未定义（VS2015）

头文件<stdio.h>

#define stderr (2)


Question: C语言采用头文件做函数声明，源文件实现，之后main函数引用一直出错，求大神帮忙看看

引用 3 楼 赵4老师 的回复：KeyWord_Index.c 和 LinkList.c 里面都定义了 _smaller _equal _bigger这几个函数我只写在了define.h中，但是多次导入，不过有经过头文件预编译，正常来说，不是不会重复么

引用 1 楼 user-2 的回复：看错误信息，应该是你把smaller, bigger, equal_in这几个函数的代码，写道某个.h文件中引起的。我把几个代码写进了define.h中，但有进行预编译，应该不会造成头文件重复吧？


Question: 江湖救急

引用 2 楼 636f6c696e的回复:垃圾代码，死钻牛角尖没意义 这代码拉不垃圾都好，我们都要从这脚步开始学习的。

垃圾代码，死钻牛角尖没意义

关于C,C++表达式求值顺序 http://blog.csdn.net/fefe82/article/details/37833767，http://bbs.csdn.net/topics/370153775

引用 3 楼 qq_45444545 的回复:[quote=引用 2 楼 636f6c696e的回复:]垃圾代码，死钻牛角尖没意义 这代码拉不垃圾都好，我们都要从这脚步开始学习的。[/quote] 学习编代码为了什么？还不是为了更好的写好代码，好的代码除了执行效率高之外，还要要求容易理解。 你目前写的代码没看出有什么效率的问题，反而是不易理解，所以不建议写～ 实际项目中写这样的代码，不会给自个加分，可能会减分

都说了是牛角尖，你非要去钻，走好不送，别乱代表别人 引用 3 楼 qq_45444545 的回复:[quote=引用 2 楼 636f6c696e的回复:]垃圾代码，死钻牛角尖没意义 这代码拉不垃圾都好，我们都要从这脚步开始学习的。[/quote]

这还不算垃圾代码啊？一条语句有这么多等号。就象中学里面的证明题，你得一步一步写出来。 除了对变量进行赋值之外，一条语句尽量不要出现超过两个等号。

#include <stdio.h>  int main(void) {    int ivalue = 7;    ivalue += ivalue * ivalue / ivalue - 5;    /*    ivalue = 7, ivalue * ivalue = 49,  ivalue * ivalue / ivalue = 7,  ivalue * ivalue / ivalue - 5 = 2 (注意ivalue的值并没有变)     ivalue += ivalue * ivalue / ivalue - 5;等价 ivalue =ivalue + ivalue * ivalue / ivalue - 5; --> ivalue = 7 + 2 = 9    */    printf("%d\n", ivalue);        ivalue = 7;    ivalue += ivalue *= ivalue /= ivalue - 5;    /*    根据运算符优先级，先从右边算    ivalue /= ivalue - 5;等价ivalue = ivalue / (ivalue - 5); 所以ivalue = 7 / 2 = 3(整数除法，不计小数) --> 注意ivalue的值已近改变    因为ivalue = ivalue / (ivalue - 5); 的结果为3    所以ivalue *= ivalue /= ivalue - 5;等价于ivalue *= 3且ivalue = 3，故算的 ivalue = 9    所以ivalue += ivalue *= ivalue /= ivalue - 5;等价于ivalue += 9且ivalue = 9，故算的 ivalue = 18    */    printf("%d\n", ivalue);    return 0; }  实际代码中还是不要这么写，要简洁明了，不要浪费脑细胞，当然学习一下还是可以的


Question: 数据结构(第2版）朱昌杰 肖建于编著课后习题答案

建议把代码输入编译器里，编译运行。有问题建议贴代码并描述清除问题和需求；  编程更注重动手和调试，相比理论动手能力更重要些。


Question: 数据结构(第2版)朱昌杰 肖建于 编著 课后习题答案


Question: 如何在非客户区绘图

应该是可以的，完全由你决定

引用 1 楼 user-1 的回复:随便写了一个，会把标题栏整残了，要漂亮自己画吧 可以设置标题栏的背景色并重绘吗？就像客户区那样

引用 1 楼 user-1 的回复:随便写了一个，会把标题栏整残了，要漂亮自己画吧 case WM_NCPAINT:          {             RECT        rcWnd, rcClient, rcCaption;             if (IsIconic(hwnd)) break;             hdc = GetWindowDC(hwnd);             GetWindowRect(hwnd, &rcWnd);             GetClientRect(hwnd, &rcClient);             rcCaption.left = 0;             rcCaption.right = rcCaption.left + (rcWnd.right - rcWnd.left);             rcCaption.top = 0;             rcCaption.bottom = rcCaption.top + (rcWnd.bottom - rcWnd.top) - (rcClient.bottom - rcClient.top) - ((rcWnd.right - rcWnd.left) - (rcClient.right - rcClient.left)) / 2;             DrawText(hdc, TEXT("Hello, Windows 98!"), -1, &rcCaption, DT_SINGLELINE | DT_CENTER | DT_VCENTER);             Rectangle(hdc, 5, 5, 30, 30);             ReleaseDC(hwnd, hdc);          }          return TRUE; // 关键  看来是我误会了，我原本想要的是在现有的标题栏上绘图，不过就现在来看，是我理解错了，原本的标题栏就是独立绘图的一部分，不过我还是有一点不明白，如果在绘图后执行DefWindowProc，那么可以理解为它把我的绘图遮盖了，但如果先执行DefWindowProc再绘图不是应该就可以了吗，我的绘图应该会显示在标题栏上才对吧


Question: C语言输出缓冲问题

vc++编译器的标准输出好像是无缓冲，gcc是行缓冲

你的程序执行完，系统会回收资源并将输入缓存里的数据刷到终端（输出终端）～


Question: 求解

for (int i=0;i<4;i++) {     for (int j=0;j<5;j++)  printf("%2d ",i*5+j+1);     printf("\n"); }


Question: 自增和乘的关系

找下运算符优先级不就清楚了么？ ++ --的优先级比乘高

//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 | //+------------------+-----------------------------------------+---------------+

首先你这不是C/C++，楼主问错了地方。 其次程序调试运行，在关注点中断，逐步执行，追踪变量的值，而不是编译运行看最终结果。 最后，++优先级别高于*、/，然而如前面几位说的，要避免这么写，也没必要去钻研这类问题，实际开发一般情况下没人会这么写。

引用 2 楼 自信男孩的回复:不建议这么写，如果想了解，建议查一下运算符的优先级，还有为啥不通过编译运行之后看一下结果，然后分析呢？ 我编译了，分析不出来嘛

a 等于5 你看不懂 你不会把a改成6 再运行吗? 要不要这么死板啊 动动脑子

不要纠结这样的问题，不要写这种模棱两可的代码，要写明确的，才能让编译器按照自己的意愿来工作


Question: 结构体中指针所占有的内存问题？

引用 2 楼 zjq9931 的回复:是的，大小未知，不过你可以用指针代替这一项，就可以了。 这个好像不能用指针代替吧？虽然使用方法跟指针一样。

是的，大小未知，不过你可以用指针代替这一项，就可以了。

百度柔性数组


Question: 为什么获取的数据长度一直是4，是代码出了问题吗

int的取值范围啊

引用 1 楼 Emy_Happy的回复:a是int，就是4和字节，你输出a看看是什么就知道了 那怎么才是正确的呢，我想知道那串数字的长度

引用 1 楼 Emy_Happy的回复:a是int，就是4和字节，你输出a看看是什么就知道了 我定义a是155575657655呀

a是int，就是4和字节，你输出a看看是什么就知道了

你首先要知道sizeof的作用啊， 如果sizeof(a)的结果等于a，那还要sizeof干什么？ sizeof求的是变量的大小，不是变量的数值 sizeof就像求是的杯子a的容积，而155575657655就像杯子里的水分子的数量 显然，这两个并没有必然的联系，水分子的个数并不影响杯子的容积


Question: 为什么我每次用typedef定义之后，总是说我未定义变量，请大佬帮忙

引用 3 楼 liups的回复:2楼说得对！ void main() { init();	 	 u8 num; 对于C语言来说，u8应该放在init前面，C++则都可以 多谢大佬，讲的很详细

引用 2 楼 Operating System的回复:把变量的定义放在函数的首句，试一试 多谢大佬，刚才试了一下，果然没问题了

把变量的定义放在函数的首句，试一试

请大佬帮帮忙

说明这个版本的编译器未支持新的C语言标准。

引用 6 楼 user-3的回复:只是老的C语言是这样，新标准C和C++一样可以在使用变量前再定义。 我这个是用keil4写的，不知道为什么也这样，但是把u8 num写前面就没事了

只是老的C语言是这样，新标准C和C++一样可以在使用变量前再定义。


Question: 求大佬帮忙

可以用空格和*直接打印

引用 9 楼 BakenJ 的回复:如果是9行，前5行一个大循环，后4行一个大循环，大循环里面空格一个小循环，*一个小循环就OK了哦，这是一个菱形

循环 打印空格 打印* 打印空格 打印回车 第三个可以省略

填充二维空间  #include<stdio.h> int main(){ 	int size,i,j; 	scanf("%d", &size); 	for (i = 1; i <= size; ++i) { 		for (j = 0; j < size - i; ++j) 			printf(" "); 		for (j = 0; j < 2 * i - 1; ++j) 			printf("*"); 		printf("\n"); 	} }

可以直接用空格键和*构建一个金字塔

引用 1 楼 莯绿和熙的回复:可以直接用空格键和*构建一个金字塔 你这回答也是，，，

引用 3 楼 636f6c696e的回复:循环 打印空格 打印* 打印空格 打印回车 第三个可以省略 但是上下层的*是不在一条线上的

想象下电脑屏幕就是一个个的点阵。就类似 ............ ............ ............ ............ ............ ............ 那现在你要在这个点阵上面显示金字塔，大致的想法就是放个金字塔上去，金字塔遮住的地方都输出*，其他地方不做处理。

思路的话，，，你可以认为是输出一个长方形，长方形你总会吧，然后金字塔的部分判断后输出*，非金字塔的部分判断后输出空格


Question: C语言小白

1，先了解内存，主要是要区分堆和栈，其他的存储区域可以暂时不去看 2，用内存的思想，自己试着去解释指针 3，函数的参数传递 4，结构体什么的 5，容器和算法

C语言教程（附带C语言100例）http://download.csdn.net/detail/zhao4zhong1/8830817

不管做什么，实战是快速提升自身实力最有效的办法，环境越迫切，实力提升越快（当然，前提是不能超过自身承受能力），生死关头，进步神速。  但是，实战也是需要一定基础才能做的，必须楼上的说让你看书，就是为了掌握最基础的理论，而刷题，其实就是一种实战。  但是实战不局限于刷题，生活中能用程序解决的问题，比比皆是，只要你用心观察。

谢谢大家，我会好好看看的

就看书写代码，什么网课什么的没必要

我联系你可以在网上找一些相关的视频，推荐你看郝冰c语言

引用 1 楼 tb_youth 的回复：先找一本书看两遍，再在oj上刷题这大哥说的简单直接有效，我学C快一个月了，我才发现身边有个架构师能都帮不到你什么，能帮你的只是告诉你什么东西可以忽略重点学什么，应该怎么样学

先找一本书看两遍，再在oj上刷题


Question: C语言做一个系统弹窗

字符集不对  设置方法：    或改为： MessageBox(0, L"你的机器将于5分钟后重启。", L"提示",0);

出错信息是什么？？？ 加入一下指令试试 #pragma comment(lib, "user32")


Question: 素数表(函数专题） 为什么我写的老是时间超限？

试试这个？   #include<stdio.h> #include<stdbool.h> #include<stdlib.h> #include<time.h>   #define N 5   long long QuickPow(long long a,long long n,long long MOD){     long long ret=1,tmp=a%MOD;     while(n){         if(n&1) ret=ret*tmp%MOD;         tmp=tmp*tmp%MOD;         n>>=1;     }     return ret; }   bool Miller_Rabin(long long x, long long a) // a^(x-1) = 1 (mod x) {     long long tmx = x - 1;     long long s2 = tmx & -tmx;     long long res = QuickPow(a, tmx/s2, x);     if(res == 1 || res == tmx)         return 1;     while(s2>1)     {         res=(res*res)%x;         if(res == 1)             return 0;         if(res == tmx)             return 1;         s2>>=1;     }     return 0; }   bool prime(long long x) {     int k = N;     if(x == 2 || x == 3) return 1;     if(x < 2 || x%2 == 0 || x%3 == 0) return 0;     while(k--)         if(!Miller_Rabin(x, rand()%(x-2)+2))             return 0;     return 1; }  int main(){ 	long long m,n; 	scanf("%lld %lld",&m,&n); 	for(;m<=n;m++){ 	if(prime(m)==1) printf("%d ",m); 	} 	return 0; }

#include<stdio.h>  int prime(int n){     int i,x=0;     if(n<2)         return 0;     for(i=2;i<=n/2;i++){         if(n%i==0) {             x++;             break;         }     }     if(x == 0)         return 1;     else         return 0; }  int main() {     int m,n;     scanf("%d %d",&m,&n);     for(;m<=n;m++){         if(prime(m)==1) printf("%d ",m);     }     return 0; } 供参考～

百度一下，查找素数的算法。 for(i=1;i<=n/2;i++){//i应该从2开始 if(n%i==0) x++;//当你发现他不是素数时，难道还要继续下去，而不是返回0？你的意思难道是求他的所有因数？ }


Question: 大神帮我看看这个冒泡哪里错了

if (a[j] > a[j+i])j和j+1比较，而不是和j+i比较。

估计是抄别人的抄错了吧😂

if (a[j] > a[j+i]) --> if (a[j] > a[j+1])


Question: BeginPaint无法在控制台上绘图，而GetDC可以，为什么？

引用 4 楼 六道佩恩 的回复:把GetDC+ValidateRect用在WM_PAINT里不也是可以的吗？ 从原理上来说，是可以的，因为在WM_PAINT中只要使无效变为有效即可

引用 5 楼 user-1 的回复:[quote=引用 4 楼 六道佩恩 的回复:] 把GetDC+ValidateRect用在WM_PAINT里不也是可以的吗？ 从原理上来说，是可以的，因为在WM_PAINT中只要使无效变为有效即可 [/quote] 啊我终于成功了！在BeginPaint前加了一行InvalidateRect( h , NULL , 0 ) 终于可行了

引用 3 楼 user-1 的回复:[quote=引用 2 楼 六道佩恩 的回复:] HWND hwnd = GetConsolewindow( ); GetDC( hwnd ); 这样你主动获取了控制台的DC，你当然可以对其为所欲为 BeginPaint一般是WM_PAINT消息触发而由程序自己来处理的，是被动的[/quote] 如果从本质来看，它们的区别是什么？把GetDC+ValidateRect用在WM_PAINT里不也是可以的吗？

引用 2 楼 六道佩恩 的回复:HWND hwnd = GetConsolewindow( ); GetDC( hwnd ); 这样你主动获取了控制台的DC，你当然可以对其为所欲为 BeginPaint一般是WM_PAINT消息触发而由程序自己来处理的，是被动的

引用 1 楼 user-1 的回复:BeginPaint无法在控制台上绘图是什么意思 HWND hwnd = GetConsolewindow( ); GetDC( hwnd );

BeginPaint无法在控制台上绘图是什么意思


Question: 为什么％ld也显示不出来长数据

引用 6 楼 赵4老师的回复:常量也有类型！ C++ Integer Constants Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.  Syntax  integer-constant :  decimal-constant integer-suffixopt octal-constant integer-suffixopt hexadecimal-constant integer-suffixopt 'c-char-sequence'  decimal-constant :  nonzero-digit decimal-constant digit  octal-constant :  0 octal-constant octal-digit  hexadecimal-constant :  0x hexadecimal-digit 0X hexadecimal-digit hexadecimal-constant hexadecimal-digit  nonzero-digit : one of  1 2 3 4 5 6 7 8 9  octal-digit : one of  0 1 2 3 4 5 6 7  hexadecimal-digit : one of  0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F  integer-suffix :  unsigned-suffix long-suffixopt long-suffix unsigned-suffixopt  unsigned-suffix : one of  u U  long-suffix : one of  l L  64-bit integer-suffix :  i64  To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.  To specify a decimal constant, begin the specification with a nonzero digit. For example:  int i = 157;   // Decimal constant int j = 0198;  // Not a decimal number; erroneous octal constant int k = 0365;  // Leading zero specifies octal constant, not decimal  To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:  int i = 0377;   // Octal constant int j = 0397;   // Error: 9 is not an octal digit  To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:  int i = 0x3fff;   // Hexadecimal constant int j = 0X3FFF;   // Equal to i  To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:  unsigned uVal = 328u;             // Unsigned value long lVal = 0x7FFFFFL;            // Long value specified                                    //  as hex constant unsigned long ulVal = 0776745ul;  // Unsigned long value 谢谢大佬，我才入门，见笑了

数据越界了，越界的数据会被截断，高于long的内容会去掉（二进制形式）

%d %x %o对应int %ld %lx %lo对应long int %lld %llx %llo对应long long int %u 对应 unsigned int %lu 对应 unsigned long int %llu 对应 unsigned long long int long变量的范围和int一样，容纳的范围是-20亿 到 20亿 左右 你这个超范围了 long long c = 9999999999; printf("%lld", c ); 就行了

这个很好解释 long类型表示的范围是-2147483648～+2141483647,共有4294967296个数 你初始值为9999999999明显超过了范围，所以编译器帮你做了9999999999 mod 4294967296 = 1410065407 如果你想显示9999999999，只需将long改为long long即可，当然printf中也要改成%lld  #include <stdio.h>  int main(void) {    long long c = 9999999999;    printf("%lld\n", c);    return 0; }

sizeof一下，看看你的系统上long的字节大小


Question: ValidateRect窗口句柄为NULL时的功能是什么

猜测应该没什么用，应该是兼容以前的系统如Win3.1。下面是Windows源码中的内容，可以参考一下 另外，如果有兴趣，你可以下载ReactOS源码，找一下ValidateRect源代码看看 /***************************************************************************\ * xxxValidateRect (API) * * * History: * 16-Jul-1991 DarrinM   Ported from Win 3.1 sources. \***************************************************************************/  BOOL xxxValidateRect(     PWND   pwnd,     LPRECT lprcValid) {     CheckLock(pwnd);      /*      * BACKWARD COMPATIBILITY HACK      *      * In Windows 3.0 and less, ValidateRect/InvalidateRect() call with      * hwnd == NULL always INVALIDATED and ERASED the entire desktop, and      * synchronously sent WM_ERASEBKGND and WM_NCPAINT messages before      * returning.  The Rgn() calls did not have this behavior.      */     if (pwnd == NULL) {         return xxxRedrawWindow(                 pwnd,                 NULL,                 NULL,                 RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE | RDW_ERASENOW);     } else {         return xxxRedrawWindow(pwnd, lprcValid, NULL, RDW_VALIDATE);     } }  /***************************************************************************\ * xxxRedrawWindow (API) * * Forward to xxxInvalidateWindow if the window is visible. * * BACKWARD COMPATIBILITY HACK * * In Windows 3.0 and less, ValidateRect/InvalidateRect() call with pwnd == NULL * always INVALIDATED and ERASED all windows, and synchronously sent * WM_ERASEBKGND and WM_NCPAINT messages before returning.  The Rgn() calls * did not have this behavior. This case is handled in * InvalidateRect/ValidateRect. * * History: * 16-Jul-1991 DarrinM   Ported from Win 3.1 sources. \***************************************************************************/  BOOL xxxRedrawWindow(     PWND   pwnd,     LPRECT lprcUpdate,     HRGN   hrgnUpdate,     DWORD  flags) {     CheckLock(pwnd);      /*      * Always map NULL to the desktop.      */     if (pwnd == NULL) {         pwnd = PtiCurrent()->rpdesk->pDeskInfo->spwnd;     }      UserAssert(pwnd != NULL);      if (IsVisible(pwnd)) {          TL   tlpwnd;         HRGN hrgn = hrgnUpdate;          if (flags & (RDW_VALIDATE | RDW_INVALIDATE)) {              /*              * Create a (in)validate region in client window coordinates.              */             if (hrgn == NULL) {                 if (!lprcUpdate) {                     hrgn = HRGN_FULL;                 } else {                     hrgn = ghrgnInv0;  #ifdef USE_MIRRORING                     if (TestWF(pwnd, WEFLAYOUTRTL)) {                         MirrorRect(pwnd, lprcUpdate);                     } #endif                      if (pwnd == PWNDDESKTOP(pwnd)) {                         SetRectRgnIndirect(hrgn, lprcUpdate);                     } else {                         GreSetRectRgn(                                 hrgn,                                 lprcUpdate->left + pwnd->rcClient.left,                                 lprcUpdate->top + pwnd->rcClient.top,                                 lprcUpdate->right + pwnd->rcClient.left,                                 lprcUpdate->bottom + pwnd->rcClient.top);                     }                 }             } else {                 /*                  * If necessary, make a copy of the passed-in region, because                  * we'll be trashing it...                  */                 if (hrgn != HRGN_FULL) {                     CopyRgn(ghrgnInv0, hrgn);  #ifdef USE_MIRRORING                     MirrorRegion(pwnd, ghrgnInv0, TRUE); #endif                      hrgn = ghrgnInv0;                 }                  if (pwnd != PWNDDESKTOP(pwnd)) {                     GreOffsetRgn(hrgn, pwnd->rcClient.left, pwnd->rcClient.top);                 }             }         }          ThreadLock(pwnd, &tlpwnd);         xxxInternalInvalidate(pwnd, hrgn, flags | RDW_REDRAWWINDOW);         ThreadUnlock(&tlpwnd);     }      return TRUE; }  BOOL NtUserValidateRect(  // API ValidateRect     IN HWND hwnd,     IN CONST RECT *lpRect OPTIONAL) {     PWND pwnd;     TL tlpwnd;     RECT rc;      BEGINRECV(BOOL, FALSE);      /*      * Probe arguments      */     if (ARGUMENT_PRESENT(lpRect)) {         try {             rc = ProbeAndReadRect(lpRect);             lpRect = &rc;         } except (StubExceptionHandler(TRUE)) {             MSGERROR(0);         }     }      ValidateHWNDOPT(pwnd, hwnd);      ThreadLock(pwnd, &tlpwnd);      retval = xxxValidateRect(pwnd, (PRECT)lpRect);      ThreadUnlock(&tlpwnd);      TRACE("NtUserValidateRect");     ENDRECV(); }

引用 2 楼 六道佩恩 的回复:[quote=引用 1 楼 user-2 的回复:] 你问问题的角度很刁钻啊，官方文档只是说了，每个参数单独是NULL的意义，并没有指出，两个同时都是NULL时的意义，也有可能是无意义的 .....第二个NULL表示整个客户区啊，，，哪里有问题[/quote] 个人觉得，你怎么每天都在研究界面什么的，我觉得这种够用就行了，你想写出特别的功能，就得从底层重写控件，有这功夫研究底层的东西比较有用

引用 1 楼 user-2 的回复:你问问题的角度很刁钻啊，官方文档只是说了，每个参数单独是NULL的意义，并没有指出，两个同时都是NULL时的意义，也有可能是无意义的 .....第二个NULL表示整个客户区啊，，，哪里有问题


Question: 请教 下图程序是由什么语言编写的。

应该是VB或者更早的QB

basic其实已经算是失败者了，但它毕竟得到过微软和老比的大力支持，再加上它确实有很多方便的地方，所以，basic衍生出无数的变种，最常见的就是windows下的vbs和office里面的vba.  而早期的basic其实是电脑硬件中内置的语言。从你的代码注释来看，我比较怀疑这里的basic是一个方言版本，通过COM端口来控制工业机器人。  其实编程很多东西都是相通的，到了实际应用阶段，语法什么的都是小问题，查查资料就能了解，而算法和业务，才是核心。

这是basic语言代码，但具体是哪种basic不好说。  像这种goto语句，早期的basic代码中出现得很多，而print #1这种语句，貌似我只在basic中见过。

引用 2 楼 邦德猪 的回复:[quote=引用 1 楼 user-3 的回复:] 好像是vcscript    还有吗？ 前辈！   我想调这个岗位却不懂这个，我想学这个！ [/quote] 不了解这个产品背景，总体上来说VBScript已经是属于小众工具，但是也许在你这个产品上永远都不会淘汰，看场景吧。

引用 3 楼 user-3 的回复：[quote=引用 2 楼 邦德猪 的回复:] [quote=引用 1 楼 user-3 的回复:] 好像是vcscript    还有吗？ 前辈！   我想调这个岗位却不懂这个，我想学这个！ [/quote] 不了解这个产品背景，总体上来说VBScript已经是属于小众工具，但是也许在你这个产品上永远都不会淘汰，看场景吧。 [/quote]好的，谢谢前辈！

引用 1 楼 user-3 的回复:好像是vcscript    还有吗？ 前辈！   我想调这个岗位却不懂这个，我想学这个！

好像是vcscript


Question: 我是一名准大一，初学c语言。有个问题想要请教

你理解了字符串的本质了就会了，很简单

#include<stdio.h> int main() { 	char info[20]; 	printf("请输入身份证号码:"); 	scanf("%s",info); 	printf("生日：%c%c%c%c年%c%c月%c%c日\n",info[6],info[7],info[8],info[9],info[10],info[11],info[12],info[13]); 	return 0; }

引用 1 楼 自信男孩的回复:公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。 这是身份证的结构形式，自己试试写写～ 那个可以帮忙写个代码吗


Question: 一样的程序运行完全不一样，用的dev

不好意思看错了 引用 3 楼 自信男孩 的回复:[quote=引用 2 楼 636f6c696e 的回复:] status哪里赋值了，你这个程序就是个不可预期的 status是接收的scanf的返回值。[/quote]

第二个程序一下能运行一下不能运行，头疼。 有时候会显示[Error]ld returned 1 exit status.大部分时候是可以的

第一个程序从运行的第一行输出可以知道，并不是运行的第一个程序的exe文件，看第一个程序的第一个输出是"Input a xxx"，而你的运行结果是please xxx  自定义函数里在计算KEL时，cel是未初始化的，计算出来的结果是通过随机数计算出来的值。所以，在计算KEL是不是应该用CEL

引用 2 楼 636f6c696e 的回复:status哪里赋值了，你这个程序就是个不可预期的 status是接收的scanf的返回值。

status哪里赋值了，你这个程序就是个不可预期的


Question: c语言问题

好的，谢谢各位大佬解释

y=3    在while循环里循环了三次直到while(0退出)所以是2³

引用 1 楼 尐东东的回复:"z*=x" 等同于 "z = z * x"，其中“*”换成其他运算符同样成立 最后z为什么等于2的3次方，等于8。我知道pow是求次方的，但循环就有点不明白了

最后z为什么等于2的3次方，8

z *= x;等价z = z * x;

"z*=x" 等同于 "z = z * x"，其中“*”换成其他运算符同样成立

书看少了，上面都有

z*＝x是z＝z*x z－＝x是z＝z－x 以此类推


Question: 求大神能解释下着代码？

引用 9 楼 qq_45444545的回复:我想问下为什么int iHours这个ihours为什么要加i！为什么不直接写hours的 前面的i表示变量类型是int,代码编写规范

其实名字无所谓，都可以，不影响

其实就是变量名写的花里胡哨把你迷住了

这个变量字母太多了吧 你试一下简写

引用 6 楼 Tybrother 的回复：[quote=引用 5 楼 不减20斤不换网名的回复:]int  i ＝8 int  j ＝13 int sum  sum＝i*j 然后输出就好了  手机打的符号这些我就省略，自己加一下。 别人看不懂他自己打的，那就肯定不知道怎么输出呗。。。[/quote]他是吧书上的提示语也打进去了

引用 5 楼 不减20斤不换网名的回复:int  i ＝8 int  j ＝13 int sum  sum＝i*j 然后输出就好了  手机打的符号这些我就省略，自己加一下。 别人看不懂他自己打的，那就肯定不知道怎么输出呗。。。

定义了3个变量，第一个初始化为8，第二个赋值为13，将这两个的变量的值乘积赋给第三个变量，然后使用printf逐个输出，刚学慢慢来，遇到问题很正常，加油

引用 1 楼 不减20斤不换网名的回复:你是照书上敲的吧 对，书上没有解释 看的太懵了

你是照书上敲的吧


Question: 有个问题请大神请教

引用 3 楼 keep_running_man的回复:[quote=引用 1 楼 user-1的回复:]优先级只是决定了表达式的结合次序，而不是运算顺序！ 优先级高，仅仅确定了一层括号，而不会影响运算顺序 https://blog.csdn.net/qq_40946921/article/details/88323975 那运算顺序怎么看，脑子钝。[/quote] 一般是从左到右$-#

引用 1 楼 user-1的回复:优先级只是决定了表达式的结合次序，而不是运算顺序！ 优先级高，仅仅确定了一层括号，而不会影响运算顺序 https://blog.csdn.net/qq_40946921/article/details/88323975 那运算顺序怎么看，脑子钝。

那运算顺序怎么看，脑子钝。


Question: C语言关于数组有个小问题请大佬指点一二

引用 14 楼 Operating System的回复:可以的你放心，相信我 当我没说尴尬😓

引用 14 楼 Operating System的回复:可以的你放心，相信我 我试了不好使啊。。。。

可以的你放心，相信我

引用 12 楼 Operating System的回复:把数组中的数字，在前面#define一下，后面的程序用宏代替，可以吗？ 我记得当初学的时候老师说宏定义也不行

把数组中的数字，在前面#define一下，后面的程序用宏代替，可以吗？

引用 10 楼 Operating System的回复:数组在定义时，大小就一定了 不不，我的意思是以后改程序时方便(以后会改数组大小)

数组在定义时，大小就一定了

引用 8 楼 Operating System的回复: 可是以后数组不一定有十个啊

引用 6 楼 Operating System的回复:dm函数里你要写什么功能？ 判断数组ia有多少个元素

dm函数里你要写什么功能？

引用 4 楼 Operating System的回复: 为什么运行结果不对呢？我设想是ia数组里有几个元素，最后输出ia就是从0到n-1

int dm(ia)函数里的ia[m]指的是形参ia,而ia并不是数组或指针，所以报错，把形参ia换个名吧

引用 1 楼 user-3的回复:1、定义一个数组ia，并试图用{}形式的初值列表初始化数组，可是{}中不给初值 2、定义一个函数dm，形参不给数据类型。原则上，如果形参必须指定数据类型，如果赖皮不给，则可能会认定为整型(这是指C程序，如果是C++，直接报错)。明显形参ia与前面定义全局的数组ia不是一个东西，也不能是一个东西。 第一条，如果不赋值默认为0吧我记得


Question: 带有头结点的双链表的实现和相关操作。做好写注释…

不懂行情…你说个价格！

引用 1 楼 user-2 的回复:哦 你出多少钱? 写不好扣你工资

哦 你出多少钱?


Question: 求助：写函数，对二维整型数组转置

引用 3 楼 自信男孩的回复:memcpy(m,b,9)；楼上已经给解答了，第三参数是拷贝的字节数，9说明是拷贝9个字节，而m的字节数是9 * sizeof(int)个，在 32位系统上，int是占4个字节。 懂啦，谢谢谢谢

引用 2 楼 user-2的回复:[quote=引用 1 楼 user-2 的回复:] 函数内部memcpy的参数不对，应该是：  memcpy(m,b, 9*sizeof(int))  更简单的写法是 memcpy(m,b, sizeof(m)) [/quote] 懂啦，谢谢谢谢

引用 1 楼 user-2的回复:函数内部memcpy的参数不对，应该是：  memcpy(m,b, 9*sizeof(int))  懂啦，谢谢谢谢

引用 1 楼 user-2 的回复:函数内部memcpy的参数不对，应该是：  memcpy(m,b, 9*sizeof(int))  更简单的写法是 memcpy(m,b, sizeof(m))


Question: 这是个什么程序啊？新人，不懂！

两个for循环，第一个for选定a【i】并将其值赋给q作为参考值，第二轮for令q与数组其余值比较，找出数组中最大值并记下其下标，第二轮for结束后将最大值和数组第一位交换，然后再到第一个for并选定数组中第二个元素做参考，然后找出数组剩余元素最大的放在第二位。故该程序的目的就是将数组中10个元素从大到小排列（另外printf（“%d”，a【i】）

从大到小，printf里面有需要地址符吗

引用 楼主 Sccx271811的回复:main() { int i,j,p,q,s,a[10]; printf("input 10 numbers:\n"); for(i=0;i<10;i++) scanf("%d",&a[i]); for(i=0;i<10;i++) { p=i;q=a[i]; for(j=i+1;j<10;j++) if(q<a[j]){p=j;q=a[j];} if(i!=p) { s=a[i]; a[i]=a[p]; a[p]=s; } printf("%d",&a[i]); } } 为啥手机上运行出来不正常，电脑上就正常！！

引用 1 楼 Operating System 的回复:10个数由小到大排序 选择排序方法排序，是从大到小排序。

排序算法，首先输入10个数，然后对其进行排序，这个是选择排序。因为你这个是从小到大的，所以其思想是每一趟都选出来未排序中的最小一个放在已排好序的末位

10个数由小到大排序


Question: 使用  OpenMP 后耗时增加了好几倍，如何正确使用 OpenMP？

已找到问题原因。  https://segmentfault.com/q/1010000020026020


Question: c语言结构体强转后数据不对

应该叫造型，这样才标准

尽量应该传字符串，尽量避免传结构体

结构体内存对齐问题 实战中不是会遇到这个问题吗？

引用 10 楼 轻箬笠 的回复:前几天刚碰到类似的问题。 楼主把UINT8 *picData;换成UINT8 picData[0];试试 引用 11 楼 SanLenoTwo 的回复:picTmp.picData = pktBuff; 换成UINT8 picData[0]之后就无法进行赋值操作了。 楼主换个思维啊。 char buf[4096] = {0}; picturePkt *pkt = (picturePkt *)buf; memcpy((void *)picTmp.picData, (void *)pktBuff, len); send(buf);

typedef struct _PICTURE_PKT_TAG_ {     UINT8  isLastPkt;     //是否是最后一个包                            0     UINT8  pktLength;     //数据包长度  最大包长255字节       1     UINT32 curPktNum;     //当前包序号                                 2 3 4 5      UINT32 nextPktNum;    //下一个包序号                            6 7 8 9      UINT8 *picData;       //包数据                                           10 11 12 13 }picturePkt; //单字节对齐 UINT8  占1个字节 UINT32占四字节 UINT8 * picData 是个指针，这个指针地址，你给他赋值picTmp.picData = pktBuff;  你让他指向了pktBuff，你问别人为什么

UINT8 * 是一个指针类型，32位系统占用4个字节。 picData = pktBuff = 0x027fff6c; 强转成UINT8 之后变为四个字节，分别为 02 7f ff 6c

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

引用 2 楼 SanLenoTwo 的回复:谢谢，大小端是决定了数据的存放位置。我想知道 i=10  buf=6c i=11  buf=ff i=12  buf=7f i=13  buf=2 这几个数据是怎么来的。  你看一下 i=8  buf=0 i=9  buf=0  i=10  buf=6c i=11  buf=ff 这几个值合起来是：nextPktNum， i=12  buf=7f i=13  buf=2  i=14  buf=ff i=15  buf=d8 这几个合起来是：picData

百度搜索 内存对齐 现在上课不教这个吗?

注意你的系统是小端系统还是大端系统，一般我们用的都是小端系统，小端系统遵循高对高，低对低，即高地址存放高字节， 低地址存放低字节。  大端系统正好相反，“高对地，低对高”

引用 9 楼 SanLenoTwo 的回复:因为要将picTmp数据发送出去，所以必须一个字节一个字节的取出来。picTmp.picData = pktBuff;本身没错，因为直接picTmp.picData[0]这种方式得到的数据是对的，强转之后数据就不对了。我的理解是数组的地址赋给了picTmp.picData强转之后直接访问就可以了，但是看来首先得到的是指针地址占据的四个字节。 你要发送消息就直接定义无属性的空间，把你要发送的按字节填充进去，你怎么强转都是没有用的。你想直接发结构，需要把结构序列化

引用 楼主 SanLenoTwo 的回复:在工作中遇到如下问题，望各位大侠解答一下不胜感激。 typedef struct _PICTURE_PKT_TAG_ {     UINT8  isLastPkt;     //是否是最后一个包     UINT8  pktLength;     //数据包长度  最大包长255字节     UINT32 curPktNum;     //当前包序号     UINT32 nextPktNum;    //下一个包序号     UINT8 *picData;       //包数据 }picturePkt; //单字节对齐  代码段：     picturePkt picTmp;      picTmp.isLastPkt = isLastPkt;     picTmp.pktLength = ret;     picTmp.curPktNum = curPktNum;     picTmp.nextPktNum = nextPktNum;     picTmp.picData = pktBuff;     UINT8 *picBuff = (UINT8 *)&picTmp;     //强转之后的数据有问题 i=0  buf=0 i=1  buf=36 i=2  buf=0 i=3  buf=0 i=4  buf=0 i=5  buf=0 i=6  buf=1 i=7  buf=0 i=8  buf=0 i=9  buf=0  i=10  buf=6c i=11  buf=ff i=12  buf=7f i=13  buf=2  i=14  buf=ff i=15  buf=d8 i=16  buf=ff i=17  buf=e0  请问i=10 buf=6c ------ i=13 buf=2这段数据是怎么来的，我看了一下这四个数据组合之后的值27fff6c是pktBuff的地址，应该如何去理解。 你后面的指定应该这样定义的 picturePkt* picBuff = &picTmp; 完全没必要强转成指向UINT8 类型的指针


Question: 为什么我用winsock获取的IP是169.254开头的，但是自己IP正常可以上网

因为你只获取了第一个ip地址啊。 addr[0] 可以获取所有的自己找找代码。

引用 1 楼 user-2 的回复:[quote=引用 楼主 geralt14 的回复:] 获取部分：          char szHost[256]; 	::gethostname(szHost,256); 	HOSTENT*pHost=::gethostbyname(szHost); 	if(pHost!=NULL) 	{ 		CString cstrIP; 		in_addr*addr=(in_addr*)*(pHost->h_addr_list); 		cstrIP.Format(" 本机IP: %s",inet_ntoa(addr[0])); 		m_bar.SetText(cstrIP,0,0); 	}   获取的错误IP：   自己的电脑IP是好好的   一个是内网的，一个是外网的，你的局域网的192.168.2.11 广域网IP是16.254.8.20[/quote]   那怎么获取局域网IP呢

引用 楼主 geralt14 的回复:获取部分：          char szHost[256]; 	::gethostname(szHost,256); 	HOSTENT*pHost=::gethostbyname(szHost); 	if(pHost!=NULL) 	{ 		CString cstrIP; 		in_addr*addr=(in_addr*)*(pHost->h_addr_list); 		cstrIP.Format(" 本机IP: %s",inet_ntoa(addr[0])); 		m_bar.SetText(cstrIP,0,0); 	}   获取的错误IP：   自己的电脑IP是好好的   一个是内网的，一个是外网的，你的局域网的192.168.2.11 广域网IP是16.254.8.20


Question: pscad与c#接口

目前，我已经全部改成了兼容的软件，编译时不再报函数未定义的错误，但是又出现了LINK2005这样的重复定义的错误，还在研究其原因

引用 5 楼 super_admi 的回复：一般情况下，如果是C++和C#的相互通信，大致会采用SOCKET和COM两种方式，我一般使用COM方式，即：使用C#写一个COM库，然后在C++中调用。  但按你的说法，PSCAD只支持C，而不支持C++，那么，如果非要和C#通信，建议使用SOCKET方式，因为在C中调用COM库是一个非常麻烦的事情。大致方式如下： 1.使用C#建立一个SOCKET监听服务，每收到请求时，抛给一个新的线程去处理； 2.C通过SOCKET接口，和C#端交互数据。谢谢你的回复，但是我并不是要和C #通讯，请看2楼我的回复，只是我在pscad里用c语言调用vs编译的c语言lib文件时出现读取不了lib里函数的问题

引用 2 楼 梦沁兰香 的回复:[quote=引用 1 楼 user-2 的回复:]  C#是要.net环境支持的，pacad能用.net?老老实实用C或fortran写吧，C#是托管代码，调试不会成功的  不好意思，之前一直没注意过这个问题，以为只有C/C++的分别，我仔细看了一下，我用的仅仅是C，不是C#，整个模型里仅有C和fortran两种语言，这也是我一直想不通的问题，PSCAD明明是支持C的，如果我不调用.lib里集成的函数，直接将函数写在.c文件里，PSCAD运行是没有问题的，但是如果我将函数定义放在.lib里，用C调用.lib里的函数，就会报错，在运行说明中出现提示说我调用的函数未定义，但是PSCAD又能找到相应的.lib文件，感觉只是读不出来.lib里定义的函数，但是在VS下采用这种调用方式又不会有问题。[/quote] c++写的包装成C接口，注意编译lib时的平台，和版本要对应

引用 1 楼 user-2 的回复:C#是要.net环境支持的，pacad能用.net?老老实实用C或fortran写吧，C#是托管代码，调试不会成功的  不好意思，之前一直没注意过这个问题，以为只有C/C++的分别，我仔细看了一下，我用的仅仅是C，不是C#，整个模型里仅有C和fortran两种语言，这也是我一直想不通的问题，PSCAD明明是支持C的，如果我不调用.lib里集成的函数，直接将函数写在.c文件里，PSCAD运行是没有问题的，但是如果我将函数定义放在.lib里，用C调用.lib里的函数，就会报错，在运行说明中出现提示说我调用的函数未定义，但是PSCAD又能找到相应的.lib文件，感觉只是读不出来.lib里定义的函数，但是在VS下采用这种调用方式又不会有问题。

引用 3 楼 user-2 的回复: c++写的包装成C接口，注意编译lib时的平台，和版本要对应[/quote]  是的，我刚注意到这个问题，我发现我使用的PSCAD安装的是其自带的GNU Fortran编译器，在编译C文件的时候可能使用了GCC，与我用的Visual Studio编译出来的.lib文件不兼容，现在我准备尝试将PSCAD使用的编译器换成Interl Visual Fortran进行仿真  非常感谢大神的回复！！！谢谢~

引用 楼主 梦沁兰香 的回复:问题背景：现在在做一个pscad的仿真模型，由于对fortran语言不够了解，想用.c文件调用c#工程生成的lib文件，然后用.f文件写一个接口程序调用前面的c文件，最后在pscad里自定义元件调用.f实现自定义元件对c#工程的调用  问题是在vs环境下测试没有问题的用c#调用c#工程生成的lib文件的方式在pscad环境里就会报错，错误为make:***[xxx.exe] Error1  有大神遇到过类似的情况吗？ C#是要.net环境支持的，pacad能用.net?老老实实用C或fortran写吧，C#是托管代码，调试不会成功的


Question: 请问这道题为什么一定要有-‘0’呢？

'1'是49 '0'是48 '1'-'0'就可以得到1了 '9'-'0'也可以得到9

是因为s1和str都是char类型吗？所以需要减掉字符0

引用 1 楼 自信男孩的回复:'0'~'9'和数字0~9对于十进制数而言，相差0x30，即相差'0'，比如5和'5'就是5 == '5'-'0'; 那后面的时间换算那里呢？str[9]不是十六进制数字呀

printf("%d", '0'); 自己做个测试就知道了


Question: 我是小白，请教几个问题

引用 11 楼 莯绿和熙 的回复:[quote=引用 10 楼 BakenJ的回复:][quote=引用 9 楼 莯绿和熙 的回复:] [quote=引用 8 楼 BakenJ的回复:][quote=引用 7 楼 莯绿和熙 的回复:] [quote=引用 6 楼 BakenJ的回复:]我也刚学，真的要自己摸索方法，然后与书本对比找不同才能搞懂 主要是没有答案呀！没法对答案呢。？[/quote]教材的题写了吗[/quote] 我准备上大一，听说《阿哈C语言》不错就先买了这本看看，打算预习一下，但买回来发现没答案[/quote]学C语言看<<C语言程序设计>>比较系统吧，而且有解析有答案，不过看个人喜好吧,我是把这本当教材,而且我也是准大一[/quote] 嗯嗯，谢谢你哦，非常感谢！[/quote]不用谢，都是小白，我也在摸索~~

引用 10 楼 BakenJ的回复:[quote=引用 9 楼 莯绿和熙 的回复:] [quote=引用 8 楼 BakenJ的回复:][quote=引用 7 楼 莯绿和熙 的回复:] [quote=引用 6 楼 BakenJ的回复:]我也刚学，真的要自己摸索方法，然后与书本对比找不同才能搞懂 主要是没有答案呀！没法对答案呢。？[/quote]教材的题写了吗[/quote] 我准备上大一，听说《阿哈C语言》不错就先买了这本看看，打算预习一下，但买回来发现没答案[/quote]学C语言看<<C语言程序设计>>比较系统吧，而且有解析有答案，不过看个人喜好吧,我是把这本当教材,而且我也是准大一[/quote] 嗯嗯，谢谢你哦，非常感谢！

引用 9 楼 莯绿和熙 的回复:[quote=引用 8 楼 BakenJ的回复:][quote=引用 7 楼 莯绿和熙 的回复:] [quote=引用 6 楼 BakenJ的回复:]我也刚学，真的要自己摸索方法，然后与书本对比找不同才能搞懂 主要是没有答案呀！没法对答案呢。？[/quote]教材的题写了吗[/quote] 我准备上大一，听说《阿哈C语言》不错就先买了这本看看，打算预习一下，但买回来发现没答案[/quote]学C语言看<<C语言程序设计>>比较系统吧，而且有解析有答案，不过看个人喜好吧,我是把这本当教材,而且我也是准大一

引用 8 楼 BakenJ的回复:[quote=引用 7 楼 莯绿和熙 的回复:] [quote=引用 6 楼 BakenJ的回复:]我也刚学，真的要自己摸索方法，然后与书本对比找不同才能搞懂 主要是没有答案呀！没法对答案呢。？[/quote]教材的题写了吗[/quote] 我准备上大一，听说《阿哈C语言》不错就先买了这本看看，打算预习一下，但买回来发现没答案

引用 7 楼 莯绿和熙 的回复:[quote=引用 6 楼 BakenJ的回复:]我也刚学，真的要自己摸索方法，然后与书本对比找不同才能搞懂 主要是没有答案呀！没法对答案呢。？[/quote]教材的题写了吗

引用 6 楼 BakenJ的回复:我也刚学，真的要自己摸索方法，然后与书本对比找不同才能搞懂 主要是没有答案呀！没法对答案呢。？

我也刚学，真的要自己摸索方法，然后与书本对比找不同才能搞懂

引用 4 楼 Operating System的回复:#include<stdio.h> int main() { 	int n,i,j,k=1; 	printf("请输入:"); 	scanf("%d",&n); 	for(i=1;i<=n;i++){ 		for(j=0;j<i;j++) 			printf("%d  ",k++); 		printf("\n"); 	} 	return 0; } #include<stdio.h> int main() { 	int n,i,j; 	printf("请输入:"); 	scanf("%d",&n); 	for(i=1;i<=n;i++){ 		for(j=0;j<i;j++) 			printf("%d  ",i); 		printf("\n"); 	} 	return 0; } 第一个输出的是k＋＋但你定义的初始是k＝1，那输出不就变成2了吗？还有，k和i.j有什么关系？

引用 1 楼 自信男孩的回复:书上都说了动手试一试，找找规律，那你让别人帮你写，怎么算是自己动手呢。 主要是需求不难，建议还是自己先动手写写 谢谢你的提醒，但我还是不太会，可以教教我吗？

最近刚学，真的不太会，我刚才写了半天也没写出来，这才问问你们的