Mxode/CSDN-C_Language-2013_2023 huggingface dataset:
user-0 提问: 帮忙写个程序

回复:
user: user-1
content: 问题描述的不清楚，而且，要代码干什么，学习不是这么干的，还是自己好好看看书吧

user: user-2
content: 这个可以有引用 1 楼 wenpinglaoyao 的回复:#include<windows.h> #include <stdio.h>   int piao[8];  void toupiao(int k) { 	int a[8]={0}; 	int i,j;  	for(i=0;i<6;i++) 	{ chongxin: 		scanf("%d",&j);  		if(a[j]==1) 		{ 			printf("您的投票重复，请再次重新投票\n"); 			goto chongxin; 		} 		if(j==k) 		{ 			printf("您不可以投自己的票，请重新投票\n"); 			goto chongxin; 		} 		if(j>=8||j<0) 		{ 			printf("无法识别的编号，请重新投票\n"); 			goto chongxin; 		}  		piao[j]++; 		a[j] = 1; 	} }   int main() {     int i; 	for(i=0;i<8;i++) 	{ 		printf("现在请%d号选手投票:\n",i); 		toupiao(i); 	}  	for(i=0;i<8;i++) 	printf(" %d",piao[i]); 	scanf("%d",&i); }

user: user-3
content: #include<windows.h> #include <stdio.h>   int piao[8];  void toupiao(int k) { 	int a[8]={0}; 	int i,j;  	for(i=0;i<6;i++) 	{ chongxin: 		scanf("%d",&j);  		if(a[j]==1) 		{ 			printf("您的投票重复，请再次重新投票\n"); 			goto chongxin; 		} 		if(j==k) 		{ 			printf("您不可以投自己的票，请重新投票\n"); 			goto chongxin; 		} 		if(j>=8||j<0) 		{ 			printf("无法识别的编号，请重新投票\n"); 			goto chongxin; 		}  		piao[j]++; 		a[j] = 1; 	} }   int main() {     int i; 	for(i=0;i<8;i++) 	{ 		printf("现在请%d号选手投票:\n",i); 		toupiao(i); 	}  	for(i=0;i<8;i++) 	printf(" %d",piao[i]); 	scanf("%d",&i); }
user-0 提问: 最近自己在学数据结构，有个bug实在无法解决，求大家帮我看看，

回复:
user: user-1
content: 我研究过这段代码，看懂了

user: user-0
content: 又自己好了，过了一会运行，又可以了，为什么啊？

user: user-0
content: 具体问题是这样的，你们把131行的    QElemType e放到   int durtime,intertime,i,t;下面就可以正常运行，但是放在上面就像我发的代码这样就无法运行。为什么呢？有人知道吗
user-0 提问: strcpy和memcpy内存覆盖还敢用吗？

回复:
user: user-1
content: 在你要看Release版对应汇编指令的那句C函数前临时加DebugBreak();，重新编译链接，成功后按F5开始调试，当程序停在DebugBreak();这句时，按Alt+8打开汇编窗口，查看其后的汇编指令。 一般人我不告诉他！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！

user: user-1
content: 引用 10 楼 zhao4zhong1 的回复:因为 copy的语义是操作后新目标和旧源内容相同且旧源的内容保持不变。 move的语义是操作后新目标和旧源内容相同且旧源的内容不一定保持不变。  所以 在源和目标内存覆盖的情况下，根本不可能实现copy！只能实现move    如果连这两者的语义都分不清的码农非要在不可能实现copy的情况下使用copy，那只能后果自负了！

user: user-2
content: 引用 9 楼 layershow 的回复:我想楼主的问题不是越界应该是 char * p = malloc(1024); memcpy(p + 2, p, 500); strcpy(p + 2, p);  对于重叠，开发人员应该非常清楚，所谓的“随机性"就是你无法确定 dst 的值 比如 "abcdefg" 按字节处理 memcpy(p + 2, p, 8) 可能会变成 "abababab" 但是某些优化的 memcpy 可能按 4 字节拷贝，你就很难想象最终结果是什么 库函数的实现不是唯一的，所以结果是一个不可定义的 开发人员理解库函数能更好的使用，但是不要惧怕使用 不然还要考虑敢不敢用指针了。

user: user-1
content: 因为 copy的语义是操作后新目标和旧源内容相同且旧源的内容保持不变。 move的语义是操作后新目标和旧源内容相同且旧源的内容不一定保持不变。  所以 在源和目标内存覆盖的情况下，根本不可能实现copy！只能实现move

user: user-3
content: 我想楼主的问题不是越界应该是 char * p = malloc(1024); memcpy(p + 2, p, 500); strcpy(p + 2, p);  对于重叠，开发人员应该非常清楚，所谓的“随机性"就是你无法确定 dst 的值 比如 "abcdefg" 按字节处理 memcpy(p + 2, p, 8) 可能会变成 "abababab" 但是某些优化的 memcpy 可能按 4 字节拷贝，你就很难想象最终结果是什么 库函数的实现不是唯一的，所以结果是一个不可定义的 开发人员理解库函数能更好的使用，但是不要惧怕使用

user: user-0
content: 引用 7 楼 zjq9931 的回复:[quote=引用 6 楼 kaiandshan 的回复:] 不好意思，都是“随机性”这个词惹的祸，如果des和src指向不同的空间，这些函数都可以使用；如果指向同一段内存，就会存在空间覆盖的问题，这种情况在函数使用者看来也是可以预见的。 动态分配的内存在堆中，比较难预见。 如果是编写的时候定义好的，在栈区的内存，一般会影响这个数组后面的变量的值。如果覆盖的更多。那就是黑客攻击的范畴了。[/quote] 是的，这些问题如果在定义或者申请的时候保证空间足够大，就不会产生覆盖的问题。

user: user-0
content: 引用 9 楼 layershow 的回复:我想楼主的问题不是越界应该是 char * p = malloc(1024); memcpy(p + 2, p, 500); strcpy(p + 2, p);  对于重叠，开发人员应该非常清楚，所谓的“随机性"就是你无法确定 dst 的值 比如 "abcdefg" 按字节处理 memcpy(p + 2, p, 8) 可能会变成 "abababab" 但是某些优化的 memcpy 可能按 4 字节拷贝，你就很难想象最终结果是什么 库函数的实现不是唯一的，所以结果是一个不可定义的 开发人员理解库函数能更好的使用，但是不要惧怕使用  是的，说的正是我所讲的。原来memcpy也会存在优化的问题，我说呢在测试memcpy重叠覆盖的问题时，怎么一直不按照一个一个字节来覆盖，比如输入abcdefg,结果是abababab，可时间结果是ababcdefefg....正在郁闷呢。再请教下，怎么看编译器的优化方式呢？

user: user-0
content: 引用 12 楼 zhao4zhong1 的回复:[quote=引用 10 楼 zhao4zhong1 的回复:] 因为 copy的语义是操作后新目标和旧源内容相同且旧源的内容保持不变。 move的语义是操作后新目标和旧源内容相同且旧源的内容不一定保持不变。  所以 在源和目标内存覆盖的情况下，根本不可能实现copy！只能实现move    如果连这两者的语义都分不清的码农非要在不可能实现copy的情况下使用copy，那只能后果自负了！[/quote]  是的，这种情况直接使用move就可以避免了，不用考虑覆盖的可能性了。

user: user-4
content: 引用 6 楼 kaiandshan 的回复:不好意思，都是“随机性”这个词惹的祸，如果des和src指向不同的空间，这些函数都可以使用；如果指向同一段内存，就会存在空间覆盖的问题，这种情况在函数使用者看来也是可以预见的。 动态分配的内存在堆中，比较难预见。 如果是编写的时候定义好的，在栈区的内存，一般会影响这个数组后面的变量的值。如果覆盖的更多。那就是黑客攻击的范畴了。

user: user-0
content: 不好意思，都是“随机性”这个词惹的祸，如果des和src指向不同的空间，这些函数都可以使用；如果指向同一段内存，就会存在空间覆盖的问题，这种情况在函数使用者看来也是可以预见的。

user: user-4
content: 楼主的意思是，会越界吧？越界确实会改变其他内容的值，甚至改变程序的代码。那啥，黑客经常用这种方式进行攻击。 VC有提供安全的函数。 可以查到。前面几楼也已经说过了。

user: user-5
content: 不都在用吗 strcpy，写的时候应该知道你操作的对象是否可能重叠啊。  也可以用 strncpy版本，可以指定要拷贝的字符串的最大长度， 确保你准备的 目标内存足够大

user: user-6
content: 存在覆盖 但谁告诉你覆盖有什么随机性?  a = 99; a原来的数据被覆盖了 ? 但 哪里来的毛线随机性?

user: user-7
content: 晕，随机性不是说不知道会不会覆盖 随机性是说覆盖以后不知道会发生什么 而覆不覆盖，是你可以通过仔细来避免的

user: user-8
content: 这种情况可由写代码的人杜绝。
user-0 提问: c语言如何计算不定积分？（不要用函数库，说下具体的实现方法）

回复:
user: user-1
content: 程序公式推导，以前大学时老师曾写过一个极简单的例子，比如(a+b)^2 能算出来等于a^2 + 2ab+b^2，只不过不定积分比这个难度大多了。

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

user: user-2
content: Matlab是C/C++编的。我猜。

user: user-3
content: 实现不定积分需要进行符号计算吧，这个比较难。如果是计算定积分，楼主不妨用矩形法，梯形法，Simpson法，Newton-Cotes quadrature rule为关键词搜索一下。

user: user-4
content: 百科了下不定积分的定义： 设F(x)是函数f(x)的一个原函数，我们把函数f(x)的所有原函数F(x)+ C(其中，C为任意常数）叫做函数f(x)的不定积分，又叫做函数f(x)的反导数。  不定积分的结果是一组函数族F(x)+ C，那么关键就是找出各阶符号的系数了？

user: user-5
content: 用数学的方法会吗？先写下伪代码。然后再翻译成编程语言的代码。
user-0 提问: 关于c学习过程中的一些疑惑！

回复:
user: user-0
content: 谢谢各位大虾的回答。 昨天下乡了，没有及时结贴。

user: user-1
content: 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？

user: user-1
content: 引用 4 楼 zxh707wk 的回复:引用 3 楼 zhao4zhong1 的回复:赵老师那段话怎么说来着 查MSDN是Windows程序员必须掌握的技能之一。  作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。

user: user-2
content: 1 是 2 没有，double是8字节，存储的不是小数点的字符串，是尾指形式，可以看看格式 3 看你怎么输入到a了，a不可能输出2.3的，只能是2 4 抛弃这个编译器 5 同上

user: user-3
content: {     for(int i=0;i<10;i++)   //这个i的作用域在两个{}之间     scanf("%d",&score[i]);   //存储数据的数组score作用域是整个函数，所以后面可以用 } int i=100;

user: user-4
content: 引用 9 楼 zhao4zhong1 的回复:不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？对，就是这一段

user: user-5
content: 是 不用 无法判断，输入小数会自动转成int型整数，丢失小数部分 是的，VC6.0不算局部变量，在VS中算

user: user-6
content: 是 没有 会直接取整 编译器的问题

user: user-4
content: 引用 3 楼 zhao4zhong1 的回复:赵老师那段话怎么说来着

user: user-1
content: 2 f  The precision value specifies the number of digits after the decimal point. If a decimal point appears, at least one digit appears before it. The value is rounded to the appropriate number of digits.  Default precision is 6; if precision is 0, or if the period (.) appears without a number following it, no decimal point is printed.   3 #include <stdio.h> #include <string.h> char s[80]; int i; char c; int main() {     while (1) {         printf("Input a integer:");fflush(stdout);         rewind(stdin);         fgets(s,80,stdin);         if (strlen(s)>10) {             printf("Input too long(>9)!\n");             continue;         }         if (2==sscanf(s,"%d%c",&i,&c)) {             if ('\n'==c) {                 printf("%d is a integer.\n",i);                 break;             }         }         if ('\n'==s[strlen(s)-1]) s[strlen(s)-1]=0;         printf("\"%s\" is NOT a integer!\n",s);     }     return 0; }

user: user-7
content: 是，如果下面还有scanf %c，则会接受，若是其他的scanf（%d，%f）则没事 默认输出小数位数都取6位，不过不同的编译器，ide支持标准的程度不同，所有些ide不是显示6位 默认取整，不过自己可以进行判断，比如if(d == int(d) )     printf("d是整数\n"); else     printf("d是小数\n");   作用域限定，是可以的
user-0 提问: 求帮忙解释一下

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

user: user-2
content: for(i=1;i<=10;i++){gets(name[i];scanf("%d",&s);)} 这个语法都有问题

user: user-3
content: 你的括号写错地方了吧，而且在scanf后面要用getchar清空缓存区的换行符

user: user-4
content: 楼主基础性知识呢？ gets怎么能这么用，还有scanf的name[i]，怎么没有&

user: user-5
content: gets(name[i];scanf("%d",&s);)   这个是什么鬼？

user: user-6
content: &name[i]

user: user-7
content: 因为  scanf  是 遇到 一个 空格符 为分割的 而gets 是 遇到换行符的， 也就是你用gets 你的 姓名 和分数 必须 分两行。  相反，如果你的姓和名之间有空格，用scanf估计就满足不了
user-0 提问: 帮忙看看哪里有问题

回复:
user: user-1
content: /* praise1.c -- 使用不同类别的字符串 */ #include<stdio.h> #define PRAISE "What a super marvelous name!" int main(void) {  char name[40];  printf("What's your name?\n");  scanf_s("%s", name,40);  printf("Hello, %s. %s\n", name, PRAISE);  return 0; } //What's your name? //Hilary Bubbles //Hello, Hilary. What a super marvelous name! //

user: user-0
content: 帮帮忙阿。帮帮忙阿

user: user-0
content: 还是没用,显示错误

user: user-2
content: #include<stdio.h> #define PRAISE "What a super marvelous name!" int main(void) { 	char name[40]; 	printf("What's your name?\n"); 	gets(name); 	printf("Hello, %s. %s\n", name, PRAISE); 	return 0; }

user: user-0
content: 还是不行，用的是vs2013

user: user-3
content: scanf_s("%s", name, 40);  改成这样试试

user: user-3
content: scanf_s少了一个参数，要加上最大长度限制 而且scanf_s只有VC支持

user: user-4
content: 将scanf_s改为scanf
user-0 提问: C多文件编译和include的用法

回复:
user: user-1
content: 用gcc做预编译 (-E)选项， 然后你就理解#include到底是干什么用的。

user: user-2
content: 不要include .c 文件，除非有充足的理由这么做

user: user-3
content: 重复定义了fun3.  把头文件包含进来时，头文件的内容和当前文件就形成一个编译单位，同一个编译单位内不能出现同ID的重复定义，多次声明可以

user: user-4
content: 没试过这样用

user: user-3
content: Q2：1.每个编译单元各自独立编译，链接成一个可执行模块即可；2.条件编译 Q3：标准头文件都有条件编译，不会出现重包含

user: user-5
content: 原来“每个源文件是一个编译单元，各自编译，然后才链接起来成为可执行文件”，难怪我include文件会报错，不include反而正常，还没接触到编译原理，学include时想到的，学习了

user: user-6
content: VC编译选项加/EP /P，重新编译，查看对应的.i文件。gcc加-E

user: user-7
content: 在c语言里面include源代码是一种编程技巧也很常用，很多工程师这么干。 但需要注意几点： 1. 既然已经include xx.c/xxx.cpp了就不要再在工程里添加这个文件了。不然会被编译2次，而且容易有问题。 你的工程中可以把3.cpp拿掉，因为1.cpp已经include 3.cpp所以不需要再在工程添加编译3.cpp了。 2. 被include的文件里面函数或全局变量如果不需要其他文件使用的话最好是static类型。这样一个源文件被多个.c include也不会报冲突。

user: user-8
content: 可以Include #include后，编译器会将include的文件内容拷贝到当前文件中，这样的话，将会导致重复定义的错误。应当避免这样的用法。  而且，编译器将.cpp .c .cc等各种源文件视为编译单位

user: user-9
content: 重复定义，楼主好浪

user: user-10
content: 没试过这样用

user: user-11
content: include可以include任意文件   和文件后缀无关  你甚至可以在你的Source Files里添加个名字叫a.bdfadfdsafd的文件 然后别的文件一样可以include它 只不过，人们一般把c++的源代码的文件后缀约定为.h和.cpp而已  你喜欢你可以写成.head .c 或者其他  这样约定是有道理的，任何变量，不论数据还是函数，都可以声明无数次但是定义只能定义一次 因此，人们把声明写在.h文件里  定义写在.cpp里  这样需要哪个变量或者函数的时候，只需要include声明这个变量或者函数的.h文件即可  即使这个文件被include了很多次 也没关系  因为声明可以声明无数次 但是定义，只能定义一次   如果出现重复定义，程序会在链接是报错（LNK型错误）  所以，你当然可以include一个里面有某些数据或函数的定义的cpp  或许你这样做程序也可以正常运行  但这也只是因为你恰好只include了一次这个cpp，如果你在另一个文件里也include这个cpp   就会报错  记住，定义只能出现一次，而声明可以出现无数次----只要不要出现文件的互相include  一般在头文件里，我们会放变量和函数的声明，另外还可以放const修饰的数据，还可以放inline函数 const修饰的数据默认类型是static的，如果你强行用extern修饰一个const  一样不应该放在可能被include多次的在头文件里 而inline函数可以放在头文件里，是因为inline被编译器处理成一种copy机制，类似#define，任何使用某个inline函数的文件都应该在使用前写一次这个inline函数   因此放到头文件里，哪儿用到了就在哪儿include  比较方便

user: user-12
content: 注意报错的是3.cpp这个文件，而不是被拷贝到1.cpp里的那份3.cpp代码

user: user-13
content: 值得研究下去，要弄懂了才是学到东西

user: user-12
content: 分清编译和链接 每个源文件是一个编译单元，各自编译，然后才链接起来成为可执行文件 你这个写法，虽然include会展开，使得1.cpp能编译通过，但3.cpp编译通不过 另外如果不是为了研究，不要include源文件

user: user-14
content: include 在预编译阶段会做展开，把内容include进来  但是一般IDE会把cpp文件认为是编译单元

user: user-15
content: 这个。。。你是要研究编译器吗？ 看你的代码好像是个新手啊，嘿嘿 好好理解一下声明、编译、链接吧
user-0 提问: 清华2012考研机试的一道题《求1和2的个数》别人的一份代码不太懂

回复:
user: user-0
content: 引用 4 楼 a1193561652 的回复:[quote=引用 3 楼 nishizhenlige 的回复:] [quote=引用 1 楼 a1193561652 的回复:] 按我理解他的大致计算方式是：比如输入12345，那么先算F(1)，再由F(1)算出F(12)，依次再算出F(123)，F(1234)，F(12345)； 主要计算的就是rslt=(rslt-cnt)*10+num*2+cnt*(t+1)+min(t,2);这一句了。 rslt是结果；num是实际输入的数；cnt是仅仅num这个数中1,2的数量； 首先认为已经算出了F(12)=rslt，需要算F(123) 1.显然12变成了12X的形式，所以原来1-11中每一个数都可以加上一个个位(因为不知道个位是不是9，所以最后一个12不能乘10，以后单独计算)，而个位是从0-9，所以原来的每个数都有10中变化，而最后一个数12的1,2的数量为cnt，所以有(rslt-cnt)*10,； 2.上一步中余有一个12没有计算，显然12X这个数的个位只能是0-3，所以有cnt*(t+1)； 4.上面的记算中都没有考虑对个位为1,2的记数，10-120中个位为1,2的显然是每10个数中有2个，所以有num*2 3.第一步还有一个0没计算，若为0则只有个位有值，直接判断就好了，min(t,2)；  非常感谢，很有帮助 不过我有点点不太明白的地方 第四条中说10-120每10个数就有两个，所以num*2，可是如果12X中的X小于2的话，不就不是两个了么，比如121[/quote] 恩，写错了一点，num*2是计算00-11共12个数，就是把第一步没算的0包含进去了；min(t,2)，是计算最后一个数12X的情况。[/quote]  恩恩，O(∩_∩)O谢谢

user: user-1
content: 引用 3 楼 nishizhenlige 的回复:[quote=引用 1 楼 a1193561652 的回复:] 按我理解他的大致计算方式是：比如输入12345，那么先算F(1)，再由F(1)算出F(12)，依次再算出F(123)，F(1234)，F(12345)； 主要计算的就是rslt=(rslt-cnt)*10+num*2+cnt*(t+1)+min(t,2);这一句了。 rslt是结果；num是实际输入的数；cnt是仅仅num这个数中1,2的数量； 首先认为已经算出了F(12)=rslt，需要算F(123) 1.显然12变成了12X的形式，所以原来1-11中每一个数都可以加上一个个位(因为不知道个位是不是9，所以最后一个12不能乘10，以后单独计算)，而个位是从0-9，所以原来的每个数都有10中变化，而最后一个数12的1,2的数量为cnt，所以有(rslt-cnt)*10,； 2.上一步中余有一个12没有计算，显然12X这个数的个位只能是0-3，所以有cnt*(t+1)； 4.上面的记算中都没有考虑对个位为1,2的记数，10-120中个位为1,2的显然是每10个数中有2个，所以有num*2 3.第一步还有一个0没计算，若为0则只有个位有值，直接判断就好了，min(t,2)；  非常感谢，很有帮助 不过我有点点不太明白的地方 第四条中说10-120每10个数就有两个，所以num*2，可是如果12X中的X小于2的话，不就不是两个了么，比如121[/quote] 恩，写错了一点，num*2是计算00-11共12个数，就是把第一步没算的0包含进去了；min(t,2)，是计算最后一个数12X的情况。

user: user-0
content: 引用 1 楼 a1193561652 的回复:按我理解他的大致计算方式是：比如输入12345，那么先算F(1)，再由F(1)算出F(12)，依次再算出F(123)，F(1234)，F(12345)； 主要计算的就是rslt=(rslt-cnt)*10+num*2+cnt*(t+1)+min(t,2);这一句了。 rslt是结果；num是实际输入的数；cnt是仅仅num这个数中1,2的数量； 首先认为已经算出了F(12)=rslt，需要算F(123) 1.显然12变成了12X的形式，所以原来1-11中每一个数都可以加上一个个位(因为不知道个位是不是9，所以最后一个12不能乘10，以后单独计算)，而个位是从0-9，所以原来的每个数都有10中变化，而最后一个数12的1,2的数量为cnt，所以有(rslt-cnt)*10,； 2.上一步中余有一个12没有计算，显然12X这个数的个位只能是0-3，所以有cnt*(t+1)； 4.上面的记算中都没有考虑对个位为1,2的记数，10-120中个位为1,2的显然是每10个数中有2个，所以有num*2 3.第一步还有一个0没计算，若为0则只有个位有值，直接判断就好了，min(t,2)；  非常感谢，很有帮助 不过我有点点不太明白的地方 第四条中说10-120每10个数就有两个，所以num*2，可是如果12X中的X小于2的话，不就不是两个了么，比如121

user: user-2
content: 1 c(n) 求出n中1和2的个数 2 dp(n)=dp(n-1)+c(n) 3 dp(1)=1，记录一下算过的数即可

user: user-1
content: 按我理解他的大致计算方式是：比如输入12345，那么先算F(1)，再由F(1)算出F(12)，依次再算出F(123)，F(1234)，F(12345)； 主要计算的就是rslt=(rslt-cnt)*10+num*2+cnt*(t+1)+min(t,2);这一句了。 rslt是结果；num是实际输入的数；cnt是仅仅num这个数中1,2的数量； 首先认为已经算出了F(12)=rslt，需要算F(123) 1.显然12变成了12X的形式，所以原来1-11中每一个数都可以加上一个个位(因为不知道个位是不是9，所以最后一个12不能乘10，以后单独计算)，而个位是从0-9，所以原来的每个数都有10中变化，而最后一个数12的1,2的数量为cnt，所以有(rslt-cnt)*10,； 2.上一步中余有一个12没有计算，显然12X这个数的个位只能是0-3，所以有cnt*(t+1)； 4.上面的记算中都没有考虑对个位为1,2的记数，10-120中个位为1,2的显然是每10个数中有2个，所以有num*2 3.第一步还有一个0没计算，若为0则只有个位有值，直接判断就好了，min(t,2)；
user-0 提问: c语言的字符串数组问题

回复:
user: user-0
content: 引用 5 楼 czarten 的回复:static 修饰符使得变量被放在全局数据区，在编译时就初始化，所以必须赋常量，而classPathName和hotkeyclassName都是变量，编译时不知道其值。  改成这样，就是在运行时赋值了，就没有问题：  #include <stdio.h> int main(int argc, char *argv[]) {     static const char *classPathName = "com/android/browser/BrowserUtil";     static const char *hotkeyclassName = "com/iiu/setting/hotkey/MouseUtil";     static const char *className[2];     className[0]=classPathName;     className[1]=hotkeyclassName;     int i = 0;     for(i=0; i < 2; i++)     {         printf("%s\n", className[i]);     }     return 0; }   而且我觉得，你这个不管是static还是const都加得有点莫名，看不懂加在这里意义是什么。 static修饰局部变量，使其在函数退出时不销毁，main一般不用多次调用吧 const如果你是想让classPathName不能被再次赋值，应该改成 static char *  const classPathName  这个嘛，我只是把某个项目里要修改的代码段抠出来单独编译测试，谢谢你的解释

user: user-1
content: static 修饰符使得变量被放在全局数据区，在编译时就初始化，所以必须赋常量，而classPathName和hotkeyclassName都是变量，编译时不知道其值。  改成这样，就是在运行时赋值了，就没有问题：  #include <stdio.h> int main(int argc, char *argv[]) {     static const char *classPathName = "com/android/browser/BrowserUtil";     static const char *hotkeyclassName = "com/iiu/setting/hotkey/MouseUtil";     static const char *className[2];     className[0]=classPathName;     className[1]=hotkeyclassName;     int i = 0;     for(i=0; i < 2; i++)     {         printf("%s\n", className[i]);     }     return 0; }   而且我觉得，你这个不管是static还是const都加得有点莫名，看不懂加在这里意义是什么。 static修饰局部变量，使其在函数退出时不销毁，main一般不用多次调用吧 const如果你是想让classPathName不能被再次赋值，应该改成 static char *  const classPathName

user: user-2
content: 引用 3 楼 was595 的回复:[quote=引用 1 楼 user-3 的回复:] 代码没问题啊，难道你用的vc6？不行就这么写 static const char *className[2]={"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"}; 或者下面才是你想要的效果 	struct ClassName 	{ 		const char *classPathName; 		const char *hotkeyclassName; 	}; 	ClassName cn{"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"};   去掉className的static就好了。。。完蛋全忘了[/quote]  你用const修饰这个指针数组  难道意思不是指针指向的内容不能改变？这和你去掉static有什么关系？

user: user-0
content: 引用 1 楼 user-3 的回复:代码没问题啊，难道你用的vc6？不行就这么写 static const char *className[2]={"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"}; 或者下面才是你想要的效果 	struct ClassName 	{ 		const char *classPathName; 		const char *hotkeyclassName; 	}; 	ClassName cn{"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"};   去掉className的static就好了。。。完蛋全忘了

user: user-0
content: 引用 1 楼 user-3 的回复:代码没问题啊，难道你用的vc6？不行就这么写 static const char *className[2]={"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"}; 或者下面才是你想要的效果 	struct ClassName 	{ 		const char *classPathName; 		const char *hotkeyclassName; 	}; 	ClassName cn{"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"};   你说的这个方法，都成功，只是不明白我的写法里，用gcc编译也出错

user: user-3
content: 代码没问题啊，难道你用的vc6？不行就这么写 static const char *className[2]={"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"}; 或者下面才是你想要的效果 	struct ClassName 	{ 		const char *classPathName; 		const char *hotkeyclassName; 	}; 	ClassName cn{"com/android/browser/BrowserUtil","com/iiu/setting/hotkey/MouseUtil"};
user-0 提问: c语言中这两种读 位数据的方法，哪个效率高？

回复:
user: user-1
content: 按照程序变成汇编来说，第一种效率高，直接根据偏移取得值，cmp，第二种需要&运算 结果再 cmp

user: user-2
content: 现在的计算机已经无所谓这点效率差别了

user: user-3
content: 循环个一亿次怕也难分高下. 如果只是为了判断是否等于1, 用if(xxx == 1)岂不是更好? 难道就为省略那几个字母?

user: user-4
content: 效率差别很小的，可以忽略！ 推荐用方法二，因为bit-field不可移植，不同的编译器会有不同的结果     An implementation may allocate any addressable storage unit large enough to hold a bit-field.  If enough space remains, a bit-field that immediately follows another bit-field in a structure shall be packed into adjacent bits of the same unit.  If insufficient space remains, whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is implementation-defined.  The order of allocation of bit-fields within a unit (high-order to low-order or low-order to high-order) is implementation-defined.  The alignment of the addressable storage unit is unspecified.

user: user-5
content: 不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？

user: user-6
content: 你要比较 将两种方法分别循环10000次 获取执行时间 就分出高低来了 又何必问

user: user-7
content: 个人认为是直接做与或非运算效率高一些~~~请问楼主比较这个效率的目的是？？

user: user-8
content: 个人觉得第一种可阅读性强一点,看着舒服一点

user: user-9
content: 方法一和方法二  不等价  根本没必要比较效率
user-0 提问: 解决稳定婚姻问题中遇到的结构体问题

回复:
user: user-1
content: 引用 4 楼 czarten 的回复:typedef struct后面的大括号里，写的是结构体的成员  int rank[n];  int order[n];  int final[n]; 你这样写意味着，每一个boy结构体，都含有n个rank，n个order和n个final 而你又定义了n个boy 总共就有n平方个rank，n平方个order……  我脑残了，稳定婚姻问题的确是这样的没错

user: user-1
content: typedef struct后面的大括号里，写的是结构体的成员  int rank[n];  int order[n];  int final[n]; 你这样写意味着，每一个boy结构体，都含有n个rank，n个order和n个final 而你又定义了n个boy 总共就有n平方个rank，n平方个order……

user: user-0
content: 不知道 是默认使用同一片内存么

user: user-0
content: 不知道，求解释

user: user-2
content: int rank[n];                 int order[n];                 int final[n]; 。。。你真的知道你这么写导致什么结果么
user-0 提问: cannot convert parameter 1 from 'char' to 'char []

回复:
user: user-1
content: 一进来就被这switch吓尿了。。。。。咱们写代码是为了简化人的操作，写个这么nb的switch图啥啊。。。  尤其是这么简单的switch处理，唉。。。简化一下就是个这： *(p+z) == (*(p+z)-96)%26+97;   //'a'的ascii好像是97来着，没验证

user: user-2
content: 其实楼主的标题 cannot convert parameter 1 from 'char' to 'char []  已经给了提示了啊 不能将一个参数char到char[]  这个switch写的的却是有点儿，，

user: user-3
content: char c=trans(b);

user: user-0
content: 引用 1 楼 q3733353520 的回复: char trans(char a[])//trans函数需要的参数类型是 char []返回值类型是char char c[]=trans(b[0]);//  但是你给它传的是char 类型 ，返回的是char[]类型  怎么改？谢谢。

user: user-4
content: char trans(char a[])//trans函数需要的参数类型是 char []返回值类型是char char c[]=trans(b[0]);//  但是你给它传的是char 类型 ，返回的是char[]类型

user: user-5
content: 该说的上面都说了，char[] 相当于指针，和char不一样的 你这个switch也是厉害  if(*(p+z) == 'z') {     *(p+z) = 'a'; } else {     *(p+z) = *(p+z) + 1; }

user: user-6
content: 参数其实需要一个 char*
user-0 提问: 刚入门，一疑惑求解答

回复:
user: user-0
content: 应该是i和j反了

user: user-1
content: 我看明白了，楼主是不是把“=”当成数学上的等号了

user: user-1
content: j都没有给过值，你要他输出什么

user: user-0
content: 理解了 我之前学过一点点的python 就想看看在C语言中i=5, j=i, i=6;这样的结果是怎样的 现在知道了

user: user-2
content: 引用为什么出来是这样的呢，而不是5，4或者是5，5 楼主你说，为什么要出现这样的结果   i, j没有初始化，里边是个垃圾值，后来i=4，i++，但是j没有改变，所以只会输出i的值为5

user: user-3
content: j没有初期化啊
user-0 提问: c、C++ 这用法麻烦解释下呢？

回复:
user: user-0
content: Test[1].fun_reve = syw_test_reve;     Test[2].fun_send = syw_test_send;  这只是给结构体中的函数指针赋值, 并没有调用函数. 调用的方法见1楼. 有个疑问:你的结构体中定义的Union是干什么的?\ union  是我以后要封装的数据，现在是随便写的，现在没什么意义。  谢谢各位，懂了哈

user: user-1
content: Test[1].fun_reve = syw_test_reve;     Test[2].fun_send = syw_test_send;  这只是给结构体中的函数指针赋值, 并没有调用函数. 调用的方法见1楼. 有个疑问:你的结构体中定义的Union是干什么的?

user: user-2
content: 先给函数指针赋值之后就可以像 1L那样调用了。  不过你的结构中搞的这个联合没多大意义撒。

user: user-3
content: Test[1].fun_reve(100); 就这样调就行了。
user-0 提问: 求助，快速排序，不知道错哪了

回复:
user: user-1
content: # define swap(x,y) ({int t; t=x; x=y; y=t;})  void QuickSort2(int *arr,int left,int right) {     int i,j,k;     i=left;     j=right;     k=arr[left];     if(left>right)         return ;     while(i<j) {         while(arr[j]>k&&i<j)             j--;         if(i<j) {             swap(arr[i],arr[j]);         }         while(arr[i]<k&&i<j)             i++;     }     swap(arr[i],k);     QuickSort2(arr,left,i-1);     QuickSort2(arr,i+1,right); }

user: user-2
content: /** @r:要排序的数组 @s:排的起点，从0开始 @e:排的终点，从n-1开始 */ void quicksort(int r[1001],int s,int e) {    int t = r[s];//哨兵，为开头的那个    int f = s+1;    int b = e;//f为前向指针，从s+1开始，b为反向指针，从e开始    int m = 0;    if(s>=e)return;//退出条件        while(f<=b)    {        while(f<=b&&r[f]<=t) f++;//在前面找比哨兵大的元素        while(f<=b&&r[b]>=t) b--;//在后面找比哨兵小的元素        //交换这两个元素        if(f<b){             m = r[f];             r[f] = r[b];             r[b] = m;             f++;    b--;        }    }    //交换哨兵和r[b],r[b]肯定要比哨兵小    r[s] = r[b];    r[b] = t;    //排两边的    quicksort(r,s,b-1);    quicksort(r,b+1,e); }  来自  http://www.2cto.com/kf/201109/105097.html

user: user-3
content: swap写的不好，不是在两个while后直接swap  下面是我修改测试过的 void QuickSort2(int *arr,int left,int right) {     int i,j,k;     i=left; j=right; k=arr[left];     if(left>right) 		return ;     while(i!=j)     { 		while(arr[j]>=k&&i<j) 			j--; 		arr[i] = arr[j];  		while(arr[i]<=k&&i<j) 			i++; 		arr[j] = arr[i];  // 		if(i<j) // 		{ // 			swap(arr[i], arr[j]);      //         }        } 	arr[i] = k;     //swap(arr[i],arr[left]);     QuickSort2(arr,left,i-1);     QuickSort2(arr,i+1,right); 	 }

user: user-4
content: 先http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装  再参考C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\qsort.c

user: user-5
content: 比如降序排序 快速排序就是每一轮排序后，前一部分 小于 分隔值 后一部分 大于 分隔值，然后再递归对这两部分应用排序，直到所有数据降序为止，所以才有每次找到一对值(> 分隔值, < 分隔值)，就需要把它们交换

user: user-0
content: 为神马 要把循环里面的 i 和 j 的循环 颠倒？
user-0 提问: 完全一样的C语言代码，为什么用cin就wa 用scanf就ac。

回复:
user: user-1
content: 叫什么名字无所谓吧

user: user-2
content: cin是C++的东西呀，要求用C语言，怎么可以用cin。。。

user: user-0
content: 引用 1 楼 zhao4zhong1 的回复:乍看起来c++的cin、cout在输入、输出上比c的scanf、printf简单，不用格式控制符！ 但是不用格式控制符，输入输出恰好是你期望的格式的时候好说；等到输入输出不是你期望的格式的时候，你就会觉得还是用格式控制符更方便、更靠谱。 摒弃cin、cout！ 使用scanf、printf。  那您会吗？ 怎么看?

user: user-0
content: 引用 1 楼 zhao4zhong1 的回复:乍看起来c++的cin、cout在输入、输出上比c的scanf、printf简单，不用格式控制符！ 但是不用格式控制符，输入输出恰好是你期望的格式的时候好说；等到输入输出不是你期望的格式的时候，你就会觉得还是用格式控制符更方便、更靠谱。 摒弃cin、cout！ 使用scanf、printf。您的意思是说可能 电脑在cin的时候把输入的数据存为另一种  不是我想要的格式对吧？

user: user-3
content: 楼主,  说好的C语言啊，  cin >>  是C++的好不好！

user: user-4
content: 乍看起来c++的cin、cout在输入、输出上比c的scanf、printf简单，不用格式控制符！ 但是不用格式控制符，输入输出恰好是你期望的格式的时候好说；等到输入输出不是你期望的格式的时候，你就会觉得还是用格式控制符更方便、更靠谱。 摒弃cin、cout！ 使用scanf、printf。
user-0 提问: 有关二维数组的一道OJ题

回复:
user: user-1
content: 跟踪调试吧，这个基本功要掌握，很多问题都可以解决的。

user: user-2
content: 更正一下：  //指针作为参数 int biggest(array **p,int m,int n); --> int biggest(array *p,int m,int n); 2维数组传递-> biggest(&a[0][0], m ,n); max1=(*p).data;  //或者  //数组作为参数 int biggest(array p[],int m,int n); biggest(a[0], m ,n); max1=p[0].data;

user: user-2
content: int biggest(array **p,int m,int n); --> int biggest(array *p,int m,int n); 2维数组传递-> biggest(&a[0][0], m ,n); max1=(*p).data;  //或者 int biggest(array p[],int m,int n); biggest(a[0][0], m ,n); max1=p[0].data;

user: user-2
content: int biggest(array **p,int m,int n); --> int biggest(array *p,int m,int n); 2维数组传递-> biggest(&a[0], m ,n); max1=(*p).data;  //或者
user-0 提问: 在学习递归，计算整数的幂，包括负幂，不知道为什么有错误？求指教

回复:
user: user-1

user: user-2
content: 楼主的第二个括号的等号变成了赋值号了

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

user: user-4
content: pow运算其实可以自底向上运算的 #include <stdio.h>                                                                                                                                                      class Solution {                                                                        public:                                                                                 double pow(double x, int n) {                                                           if (n == 0) {                                                                           return 1.0f;                                                                    }                                                                                   bool sign = n < 0;                                                                  unsigned int m = sign ? -n : n;                                                     double ret = 1.0;                                                                   while (m) {                                                                             if (m & 1) {                                                                            ret *= x;                                                                       }                                                                                   m >>= 1;                                                                            x *= x;                                                                         }                                                                                   return sign ? 1 / ret : ret;                                                    }                                                                           };                                                                                                                                                                      int main()                                                                          {                                                                                       Solution s;                                                                         printf("%lf\n", s.pow(1.00000, -2147483648));                                       return 0;                                                                       }

user: user-5
content: # include <stdio.h> double mi(double x, int y);  int main(void) {     double x;     int p;     scanf("%lf",&x);     scanf("%d",&p);     printf("%lf",mi(x,p));     return 0; }  double mi(double x, int p) {     if (p>0)         return x*mi(x,p-1);     if (p==0)////////////////////////         return 1.0;     if (p<0)         return 1/mi(x,-p); }
user-0 提问: 三分贴

回复:
user: user-1
content: 如果大家的长度是一样的话，你爱怎么转就怎么转 编译器里默认没定义类型的数据都是int 在32位机器里int是32位的，所以size_t 与 0 比较不会有警告  如果你需要保险一点的方法，就把下面说的类型换一下： INT -> INT_PTR UINT -> UINT_PTR DWORD(ULONG) -> DWORD_PTR(ULONG_PTR)

user: user-2
content: 有没有问题可以在64位系统下试试就知道了~~~

user: user-3
content: 虽然强制类型转换就是干这个的，但还是看了在64位环境下对应汇编指令后我才会彻底放心。  理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）
user-0 提问: 求助一个问题。困扰我几天了。

回复:
user: user-0
content: 谢谢楼上几位的热心回答。我找到问题了。是微软浮点数没初始化的问题。只要在MALLOC下面加上p1->score=0;就可以解决了。   http://blog.163.com/tab_98/blog/static/119240972012102404641288/ 这篇文章有介绍。哎~~~终于解决了。好几次被这个问题搞得抓狂。

user: user-1
content: typedef struct st { 	int num; 	float score; 	struct st *next;  }stu;  #define LEN sizeof(stu)  int _tmain(int argc, _TCHAR* argv[]) { 	 	stu *p1; 	p1=(stu*)malloc(LEN); 	scanf("%d%f",&p1->num,&p1->score); 	return 0; } 这样再错就见鬼了， 你那样不报错就简直是。。。 struct * next; 这是啥

user: user-2
content: 拿VC6试了一下，确实如楼主所说 但在我的MinGW上直接编译报错，怀疑 struct *next; 这种写法只有VC支持，不过这应该不是问题所在 但是MinGW上编译通过后，运行没有任何错误，猜测还是VC6的问题

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

user: user-4
content: 楼主想做个学生类的链表吧。VC6有些地方做得不太好，毕竟有点老了。是不是要clean一下。

user: user-5
content: 引用 1 楼 zjjsfny 的回复:我是楼主。但现在问题是主要把&p1->score前面的&去掉。运行一遍。然后再加上&再运行就正常了。到底是怎么回事。两次操作后。最终代码和之前出错是一样的。为什么这样一操作就行了呢。我要郁闷死了。 有可能前面编译器抽了，重新build一下后就好了。

user: user-6
content: 代码编译不过需要 修改为 typedef struct stu  { int num; float score; struct stu *next; }stu; 没发现有什么问题

user: user-7
content: 我试了试一切正常呀，不过我用的VS2010不知道有没有关系。

user: user-8
content: typedef struct  { 	int num; 	float score; 	struct stu *next; }stu; 试试这样呢

user: user-0
content: 我是楼主。但现在问题是主要把&p1->score前面的&去掉。运行一遍。然后再加上&再运行就正常了。到底是怎么回事。两次操作后。最终代码和之前出错是一样的。为什么这样一操作就行了呢。我要郁闷死了。
user-0 提问: 求助：如何获取标签地址 C或者汇编都行

回复:
user: user-1
content: 仅供参考#include <stdio.h> int main() {     void *p1,*p2;     __asm {         mov p1,offset LAB         lea eax,LAB         mov p2,eax     }     printf("p1==%p,p2==%p\n",p1,p2); LAB:     return 0; }

user: user-2
content: GNU  扩展可以 &&label ... ARMCC 应该不支持.. 你在ARM的CPU上跑 X86指令这都算啥事啊..

user: user-0
content: 有啊 int main() {   void *p   __asm mov p offset LAB LAB:   return 0; }  但是上面的嵌入ADS就会报错，提示没有offset,,所有想问一下子ARM平台怎么实现上面的操作

user: user-0
content: 有啊 int main() {   void *p   __asm p offset LAB LAB:   return 0; }  但是上面的嵌入ADS就会报错，提示没有offset,,所有想问一下子ARM平台怎么实现上面的操作

user: user-1
content: ARM没嵌入汇编？

user: user-0
content: 我以为 offset 伪指令可以通用，所以想问一下在ARM下如何实现，我用的是ADS编译器，不支持GCC
user-0 提问: 这2张指针内存分配的示意图可能是哪本书里的？

回复:
user: user-0
content: 引用 8 楼 wangjun403 的回复:年前买的  图灵程序设计丛书：深入理解C指针  http://item.jd.com/11412004.html 答案被你公布了 我迟早也要公布的，我是想看看还有其它哪些经典的C语言的书里有类似的图解的，以证明这本书的内容是否有包含在其它一本讲解C语言的书里的。

user: user-1
content: 年前买的  图灵程序设计丛书：深入理解C指针  http://item.jd.com/11412004.html

user: user-0
content: 再看看。。

user: user-2
content: 到百度贴吧问一下吧，那里小白多，看过你这本书的应该还有些记忆。而且那里图片不用点击进来就能看见。

user: user-3
content: 引用 4 楼 u010165006 的回复:[quote=引用 3 楼 nadleeh123 的回复:] [quote=引用 楼主 u010165006 的回复:] 《C Primer Plus》有这样的图吗？  这样子也不好,变种形似有可能又不认识了,老实看《C Primer Plus》 另外关于内存, 堆栈, 寻址这些玩意儿,要想真正搞清楚,还得玩玩汇编,而且是不止一种体系结构的汇编.[/quote] 《C Primer Plus》有这样的图吗？[/quote] 貌似真没见过老外的书有这样的图，把一段函数的指令空间 和栈空间一个一个挨着给你标出来。

user: user-0
content: 引用 3 楼 nadleeh123 的回复:[quote=引用 楼主 u010165006 的回复:] 《C Primer Plus》有这样的图吗？  这样子也不好,变种形似有可能又不认识了,老实看《C Primer Plus》 另外关于内存, 堆栈, 寻址这些玩意儿,要想真正搞清楚,还得玩玩汇编,而且是不止一种体系结构的汇编.[/quote] 《C Primer Plus》有这样的图吗？

user: user-3
content: 引用 楼主 u010165006 的回复:  《C Primer Plus》有这样的图吗？  这样子也不好,变种形似有可能又不认识了,老实看《C Primer Plus》 另外关于内存, 堆栈, 寻址这些玩意儿,要想真正搞清楚,还得玩玩汇编,而且是不止一种体系结构的汇编.

user: user-4
content: 干啥执着于这两张图，  反正谭浩强的书里没有。

user: user-5
content: 计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495
user-0 提问: 本人刚入门，求解

回复:
user: user-1
content: 很有意思啊引用 6 楼 zhao4zhong1 的回复:Finding prime numbers - Kenneth Haugland Different schemas for finding prime numbers explained with code http://www.codeproject.com/Articles/429694/Finding-prime-numbers

user: user-2
content: 引用 5 楼 Data_Flow 的回复:2是素数吧=-O 输出3-100间所有的素数

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

user: user-3
content: 2是素数吧=-O

user: user-4
content: 类似的这些问题，建议楼主自己按照数学原理来写代码，这样能更深入的理解。 刚入门，看别人的代码，个人觉的不是很好，可以参考思路。 素数即为除了1和它本身以外任何数都不能整除他的数 那么我们就能判断2不是素数 3是素数，因为3/1 = 3（整除） 3/3=1(整除) 3/2=1.5（不能整除） 4不是素数，因为除了1和4之外，4还能被2整除。 那么根据这个思路，代码就可以这样写  int main(void) int num = 4; int i = 2; while(i < num) {  if ((num %  i) == 0)  {       printf("%d不是素数!\n",num);       break; }  }

user: user-5
content: 这个网上很好找 参考一下吧——http://blog.csdn.net/u012421456/article/details/19074525

user: user-6
content: 一个比较快的方法叫筛法 #include <iostream> #include <cmath> #define Ni 10000000 using namespace std; int prime[Ni]; bool vis[Ni]; int Prime(int n)//筛法构造1～n的素数表(反回有多少个素数) {     int i,j,c=0;     memset(vis,0,sizeof(vis));     for(i=2;i<=n;i++) if(!vis[i])     {         prime[c++]=i;         for(j=i*i;j<=n;j+=i) vis[j]=1;     }     return c; } int main() {     int i,n,m;     cin>>n;     m=Prime(n);     for(i=0;i<m;i++)     {         cout<<prime[i]<<' ';     }     cout<<endl; }

user: user-7
content: 搜索，素数的检测方法。
user-0 提问: 求高手解答，这个题有什么规律吗，时间限制解决不了

回复:
user: user-0
content: 引用 4 楼 zjq9931 的回复:引用 3 楼 lyglovezyl 的回复:[quote=引用 1 楼 zjq9931 的回复:] n-1的连加。能给一个具体公式吗 仔细看了一下，是我想简单了。这个题目应当是考空间换时间的题。 就是先把结果存起来。然后，输入数字的时候找结果就可以了。 就是先在自己的机器上求出结果。然后把结果放到代码里面，然后查表就好。[/quote]我的代码还是时间超限 #include <stdio.h> #include <stdlib.h> #define N 10000000 long long m[1000001]; int main(int argc,const char*argv[]) { int* phi; int i,j,n,k; char* prime; prime=(char*)malloc((N+1)*sizeof(char));  prime[0]=prime[1]=0;  for(i=2;i<=N;i++)  prime[i]=1;  for(i=2;i*i<=N;i++)  if(prime[i])  for(j=i*i;j<=N;j+=i)  prime[j]=0;  //这段求出了N内的所有素数  phi=(int*)malloc((N+1)*sizeof(int));  for(i=1;i<=N;i++)  phi[i]=i;  for(i=2;i<=N;i++)  if(prime[i]) for(j=i;j<=N;j+=i) phi[j]=phi[j]/i*(i-1);//此处注意先/i再*（i-1)，否则范围较大时会溢出   for(k=2;k<=1000000;k++)   {       m[1]=0,m[2]=1;       m[k]=m[k-1]+phi[k];   } while(scanf("%d",&n)!=EOF&&n!=0) {       printf("%lld\n",m[n]); } return 0; } 用欧拉函数的思想做的

user: user-1
content: 引用 5 楼 lyglovezyl 的回复:引用 4 楼 zjq9931 的回复:[quote=引用 3 楼 lyglovezyl 的回复:] [quote=引用 1 楼 zjq9931 的回复:] n-1的连加。能给一个具体公式吗 仔细看了一下，是我想简单了。这个题目应当是考空间换时间的题。 就是先把结果存起来。然后，输入数字的时候找结果就可以了。 就是先在自己的机器上求出结果。然后把结果放到代码里面，然后查表就好。[/quote]我的代码还是时间超限 #include <stdio.h> #include <stdlib.h> #define N 10000000 long long m[1000001]; int main(int argc,const char*argv[]) { int* phi; int i,j,n,k; char* prime; prime=(char*)malloc((N+1)*sizeof(char));  prime[0]=prime[1]=0;  for(i=2;i<=N;i++)  prime[i]=1;  for(i=2;i*i<=N;i++)  if(prime[i])  for(j=i*i;j<=N;j+=i)  prime[j]=0;  //这段求出了N内的所有素数  phi=(int*)malloc((N+1)*sizeof(int));  for(i=1;i<=N;i++)  phi[i]=i;  for(i=2;i<=N;i++)  if(prime[i]) for(j=i;j<=N;j+=i) phi[j]=phi[j]/i*(i-1);//此处注意先/i再*（i-1)，否则范围较大时会溢出   for(k=2;k<=1000000;k++)   {       m[1]=0,m[2]=1;       m[k]=m[k-1]+phi[k];   } while(scanf("%d",&n)!=EOF&&n!=0) {       printf("%lld\n",m[n]); } return 0; } 用欧拉函数的思想做的[/quote] 大数的计算量太大，肯定是空间换时间了。因为内存限制很大。完全可以存起来，用的时候查表就好了。

user: user-0
content: 引用 1 楼 zjq9931 的回复:n-1的连加。能给一个具体公式吗

user: user-1
content: 引用 3 楼 lyglovezyl 的回复:引用 1 楼 zjq9931 的回复:n-1的连加。能给一个具体公式吗 仔细看了一下，是我想简单了。这个题目应当是考空间换时间的题。 就是先把结果存起来。然后，输入数字的时候找结果就可以了。 就是先在自己的机器上求出结果。然后把结果放到代码里面，然后查表就好。

user: user-2
content: 加上欧拉数吧

user: user-1
content: n-1的连加。
user-0 提问: 世界最快的排序算法之一

回复:
user: user-1
content: 引用 1 楼 zouzhipeng1717 的回复:时间复杂度越低，代码越多~ 话不是这么说 一般会跟空间复杂度对立

user: user-2
content: 时间复杂度越低，代码越多~
user-0 提问: C内存问题，求教育。

回复:
user: user-1
content: 指针就是整数，怎么打都行。但是这于这个整数很大，所以用十六进制来打最适用。  printf("%08X",  p); printf("%u", p);   用%d不好，因为这样会打印成负数，不直观。 http://www.afanihao.cn/c_guide/ ，第3章  引用 14 楼 ovoovo 的回复:打印指针用%p

user: user-2
content: 我很欣赏你这个抓细节的严谨态度，赞一个～！  你自己看看我给你的这个反汇编的结果：   栈里不是先进后出吗，怎么char 和int 的存储不是相间，而是分类存储，并且z存储在a前面？ 这个，是没问题的，你看图，以及我做的标记就知道了。  至于为什么不是相间排列的，这个是编译器的原因： 你可以写代码看下，一般情况VC6编译器输出的sizeof(int)=4, sizeof(char)=1，在32位处理器上，数据32位对齐时候处理器性能最佳，编译器便优化了变量排列方式，使之对其。  还有，给你点建议，变量地址一般用16进制无符号整型形式表示，例如printf( "%#X", &a );

user: user-3
content: 自己反汇编，瞅瞅

user: user-4
content: 不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。

user: user-5
content: 编译器优化了吧

user: user-6
content: 这四个变量在函数内并非是连续排列的，如果你是在结构体中定义这四个变量，更具研究意义

user: user-7
content: 引用 17 楼 u010572380 的回复:输出地址为什么用%d呢，应该用%p不是么 本来在printf已经指定了输出的是地址&a，如果此时用p%，输出的是保存&a这个地址的地址了。

user: user-7
content: 地址都是无符号数，输出的地址都成了有符号数了，把%d改为%u，再分析内存分配。

user: user-8
content: 引用 5 楼 czarten 的回复:栈是先进后出没错 问题是没有人规定先定义的变量就要先进栈 引用 8 楼 user-17 的回复:局部变量是在调用栈上，但是没有什么进出的关系，参数才是按顺序进栈出栈 理论上局部变量的顺序由编译器决定  正解，另外建议楼主用%p来显示指针指向的地址

user: user-4
content: 推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

user: user-4
content: VMMap 是进程虚拟和物理内存分析实用工具。http://technet.microsoft.com/zh-cn/sysinternals/dd535533

user: user-9
content: 打印指针用%p

user: user-10
content: 引用 12 楼 paschen 的回复:[quote=引用 5 楼 czarten 的回复:] 栈是先进后出没错 问题是没有人规定先定义的变量就要先进栈 引用 8 楼 user-17 的回复:局部变量是在调用栈上，但是没有什么进出的关系，参数才是按顺序进栈出栈 理论上局部变量的顺序由编译器决定  正解，另外建议楼主用%p来显示指针指向的地址[/quote] 乱七八糟。 你可以说“指针的内容”，或者指针指向的类型，或者指针指向的对象或者函数，指针能指向地址，不伦不类闻所未闻。

user: user-11
content: 输出地址为什么用%d呢，应该用%p不是么

user: user-12
content: 你要输出内存的地址应该用％ｐ而不是％ｄ

user: user-13
content: 引用 1 楼 u010820228 的回复:ubuntu 14.04 系统。 c没有明确规定变量的入栈顺序 对于int a； int b； char c； . . . unsigned int x; 这种代码，没有必要非要遵守某种顺序，反而某些特苏体系结构的cpu（mips）对与非（4B）对齐内存地址的访问有额外开销，编译器为了降低这种开销发生的次数，入栈顺序的确会发生改变，比如你的b和z会放到一起去，这样只有1次，如果按你代码顺序的话就有3次

user: user-14
content: 栈是先进后出没错 问题是没有人规定先定义的变量就要先进栈

user: user-15
content: 首先，变量申请后，操作系统会给这个变量分配空间（随机选择内存区域进行优化存放），栈是先进后出，只是这个程序里面没有用到而已

user: user-16

user: user-17
content: 局部变量是在调用栈上，但是没有什么进出的关系，参数才是按顺序进栈出栈 理论上局部变量的顺序由编译器决定
user-0 提问: CreateEvent 和CreateMutex的区别

回复:
user: user-1
content: 假如我有1个数据接收线程，10个数据处理线程，1个缓冲区，1个同步对象。 当缓冲区为空时，10个数据处理线程均WaitForSingleObject一个同步对象，阻塞住，等待数据接收线程接收到数据并写入到缓冲区后，数据接收线程通过改变同步对象的状态，让10个数据处理线程同时放行，并发地计算、处理缓冲区中的数据。那么这个同步对象，用Mutex还是Event好？如果用Mutex的话，数据接收线程ReleaseMutex，此时10个WaitForSingleObject的线程，只会放行一个，不会同时放行10个。而如果用一个手工重置的Event，可以很简单的实现这一点。 总之Mutex和Event，从字面上看已经很明白了，一个侧重于“互斥”，即多个线程互斥地访问同一个变量、资源。另外一个侧重于“事件”，即通过对Event对象设置“有信号”还是“无信号”，来通知其它线程。

user: user-2
content: Event侧重事件是否发生 Mutex侧重唯一性

user: user-3
content: Event和Mutex是完全不同的用来做线程同步的概念, 你查查资料

user: user-4
content: 《Windows核心编程》
user-0 提问: 如何让一个DLL随目录下的exe文件启动

回复:
user: user-0
content: 都是NB人物啊，这里真是卧虎藏龙。。。。。搞得我的不会分配可用分了。。

user: user-1
content: 看 exe 写的时候 load 的 dll 是什么名字，把 dll 改为相应的名字。。。

user: user-2
content: 在我的认知里，替换库是一个很麻烦的事情。 1.第一个你必须弄清楚的是，原库的导出函数列表。如果这个库还包含有导出类（比如COM）之类的东西，我觉得还是放弃吧。 导出函数名很好得到，但函数参数就稍微有点费劲。  2.对库进行修改时，在我的认知里，大约有两种方式：1）直接在二进制代码上动手，这要求你对汇编甚至机器语言比较熟悉，有比较强的逆向能力，对文件结构也很清楚，并且不适合大幅度修改；2）将原DLL改名，新建一个与原DLL同名的DLL，在新的DLL重建导出函数列表：对于不需要动的地方，直接调用原DLL对应的函数。  3.对于你的问题，你确定a.exe中会加载b.dll吗？如果不确定这一点，建议还是用全局钩子之类的东西，来对a.exe的进程进行监控。

user: user-3
content: 你说的这个技术叫dll劫持.   这个技术得以实现, 是因为一个exe的运行肯定会依赖很多dll, 而exe自己只是根据名字加载dll, 并不知道这个dll是否被修改过. 所以你完全可以自己写一个同名的dll覆盖掉原来的dll  (前题是有相同的导出函数), 这样程序加载时, 就会调用你自己的dll了.  外挂可能hook掉socket通信的dll, 甚至有些外挂为了多开, 还会hook掉 d3d相关的dll来减少资源加载.  至于你的场景,  因为exe已经固定,  那么它会加载的dll也是固定的.  你要想能加载你的dll, 那么你就需要知道这个exe加载了哪些dll, 有哪些dll你可以实现并修改, 这样才有可能你把自己的b.dll加载到a.exe中去.

user: user-4
content: 1. 找一个exe调用的DLL，放到一个同名的DLL（自己的）在目录下即可。（这种最简单） 2. 修改PE的导入表，增加一个自己DLL的函数调用。（找工具即可） 3. 在A.EXe加个壳，类似于detour，运行时注入dll （需要自己编码）

user: user-0
content: 引用 1 楼 jiangsheng 的回复:取决于人家代码怎么写的 LoadLibrary("WSOCK.DLL")_//在当前搜索路径查找并加载 LoadLibraryEx("WSOCK.DLL",LOAD_LIBRARY_SEARCH_SYSTEM32)_//在系统目录查找加载 清单里加了WinSxS的会去先找WinSxS  你回答过我3个问题，其中一个还是在msdn回答的，那时候我就在想为什么你这么nb。

user: user-5
content: 引用 1 楼 jiangsheng 的回复:取决于人家代码怎么写的 LoadLibrary("WSOCK.DLL")_//在当前搜索路径查找并加载 LoadLibraryEx("WSOCK.DLL",LOAD_LIBRARY_SEARCH_SYSTEM32)_//在系统目录查找加载 清单里加了WinSxS的会去先找WinSxS 是不是说知道名字，把楼主写的动态库改成对应的名字，然后放到程序路径或系统路径中，就可以了？ 如果两个路径都放动态库，那肯定是用新的动态库么？

user: user-6
content: 取决于人家代码怎么写的 LoadLibrary("WSOCK.DLL")_//在当前搜索路径查找并加载 LoadLibraryEx("WSOCK.DLL",LOAD_LIBRARY_SEARCH_SYSTEM32)_//在系统目录查找加载 清单里加了WinSxS的会去先找WinSxS
user-0 提问: goto语句

回复:
user: user-1
content: 编译通不过，有什么提示吗

user: user-2
content: 引用 楼主 cheng401733277 的回复:下面是一条普通的跳转语句：   ...... goto label; ...... lable: ......   相信大家都使用过，但标签地址，相信就不是很多人都用过了。 什么是标签地址，说简单了就是标签的地址，标签也有地址的。而获得标签的地址就要使用&&符号获得，并且这个地址要存储在一个空(void)类型的指针中。下面举一个例子来说明如果使用标签地址： [cpp] view plaincopyprint? /* gotoaddr.c */   #include <stdio.h>   #include <time.h>   int main(int argc,char *argv[])   {       void *target;       time_t now;       now = time((time_t *)NULL);       if(now & 0x0001)           target = &&oddtag;       else           target = &&eventag;       goto *target;   eventag:       printf("The time value %ld is even/n",now);       return(0);   oddtag:       printf("The time value %ld is odd/n",now);       return(0);   }     编译：gcc gotoaddr.c 执行：./a.out 我机子上的输出是这样的： The time value 1264225490 is even   在上面的代码中，我们可以看到用时间来获得一个随机数now，然后根据now值的奇偶性来跳转到不同的地方。 上面的例子是一种使用标签地址的普通用法，我们还可以把标签地址存入数组中，然后根据数组索引的不同跳转到不同的地方，如下： [cpp] view plaincopyprint? void *loc[] = { &&label1, &&label2, &&label3, &&label4 };       . . .   goto *loc[i];     标签地址可以让我们更灵活的使用跳转语句 ：） 上面的是在别人博客里面看到的，他用的是GCC,但是我弄到VC上编译不通过，想问一下如果在VC上怎么实现上面的灵活跳转？ 有goto干嘛不用goto,linux内核源码那么多goto也没说出现你们所谓的问题,关键还是看人.

user: user-3
content: goto引用一个大家的话：C语言中的贱民。。。

user: user-4
content: 不知道..........  不过楼主，这种技术即使可行，也没必要，数学上已经证明了c语言去掉goto的完备性了～～换句话说，c语言可以用其他关键字来实现goto    所以建议楼主无需纠结这类技术

user: user-5
content: 跟直接goto 标签有什么区别？

user: user-6
content: 有些可能是GCC的扩展功能，或者VS没实现这个标准功能。  没事就不要用goto，即使你完全掌握了goto，能确保自己写出的代码完全没有问题，但换个人来维护你的代码，谁能保证那人也是goto大师。

user: user-7
content: 再古灵精怪的goto语句和标签地址、标签地址数组、……也比不上嵌入汇编。

user: user-7
content: 在古灵精怪的goto语句和标签地址、标签地址数组、……也比不上嵌入汇编。
user-0 提问: C语言定时器问题

回复:
user: user-1
content: 你在消息映射的地方有没有加 ON_WM_TIMER()   BEGIN_MESSAGE_MAP(CDlgFastApproachCTR, CDialog)     ON_WM_TIMER() END_MESSAGE_MAP()

user: user-2
content: 引用 2 楼 lineage191 的回复:SetTimer(1,1000,NULL); 不要加：：作用域，这是调用全局的函数，而你的回调函数是null肯定不响应 此处要如上调用CWnd下的对应函数，当回调函数填null时，wm_timer消息会产生，从而调用对应的OnTimer响应函数 没看明白不加::的原因

user: user-3
content: SetTimer(1,1000,NULL); 不要加：：作用域，这是调用全局的函数，而你的回调函数是null肯定不响应 此处要如上调用CWnd下的对应函数，当回调函数填null时，wm_timer消息会产生，从而调用对应的OnTimer响应函数

user: user-4
content: 在你的按钮中设置的定时器事件并没有设置timer procedure。看下win32的SetTimer函数。

user: user-0
content: 引用 4 楼 michael2988 的回复:你在消息映射的地方有没有加 ON_WM_TIMER()   BEGIN_MESSAGE_MAP(CDlgFastApproachCTR, CDialog)     ON_WM_TIMER() END_MESSAGE_MAP() 就是你说的这个原因，实在是太感谢了！

user: user-0
content: 引用 2 楼 lineage191 的回复:SetTimer(1,1000,NULL); 不要加：：作用域，这是调用全局的函数，而你的回调函数是null肯定不响应 此处要如上调用CWnd下的对应函数，当回调函数填null时，wm_timer消息会产生，从而调用对应的OnTimer响应函数发帖之前我就试过SetTimer(1,1000,null)了，发现还是没有调用

user: user-0
content: 引用 1 楼 user-4 的回复:在你的按钮中设置的定时器事件并没有设置timer procedure。看下win32的SetTimer函数。你说的是什么意思？ 不太明白
user-0 提问: [问题求助] vc++6.0问题，高手进！

回复:
user: user-1
content: 关于vc++6.0的工作组怎么弄成图片这样子？ 答：遇到微软的工具，请多用鼠标点点，这是不变的真理。  比如我手中有高一凡的数据结构源码，分别有.c、cpp、.h的文件怎么把他们关联起来进行编译运行呢？ 答：用鼠标点点看，或者问高一凡。

user: user-2
content: 别说你是学编程的人

user: user-3
content: 导入呀- -

user: user-4
content: 但鄙人对VC 6这种垃圾不了解，哈哈哈引用 2 楼 sholber 的回复:应邀前来回复，但鄙人对VC 6这种垃圾不了解。

user: user-5
content: vc6不死的神话

user: user-6
content: 引用 1 楼 zhao4zhong1 的回复:文件、新建、工程、Win32 Console Application、工程：003 确定、…… 在Source Files上点鼠标右键、添加.c和.cpp 在不需要的.c或.cpp上点鼠标左键、按Del键删除 在Header Files上点鼠标右键、添加.h  偶然看到vc6的问题，已经很久没搞过了。来怀念一下~~

user: user-7
content: 实在→是在

user: user-7
content: 引用 2 楼 sholber 的回复:应邀前来回复，但鄙人对VC 6这种垃圾不了解。 关键是此“鄙人”实在VC6诞生之后生的。

user: user-8
content: 应邀前来回复，但鄙人对VC 6这种垃圾不了解。

user: user-7
content: 文件、新建、工程、Win32 Console Application、工程：003 确定、…… 在Source Files上点鼠标右键、添加.c和.cpp 在不需要的.c或.cpp上点鼠标左键、按Del键删除 在Header Files上点鼠标右键、添加.h
user-0 提问: 求帮助！！！

回复:
user: user-1
content: 楼上正解，楼主的代码统计的是所有人所有学科不低于平均分的总科数。

user: user-2
content: for(i = 0;i < n; i ++)         {             flag = 1;             for(j = 0;j < m; j ++)             {                 if(a[i][j] < aver2[j])                 {                     flag = 0;                     break;                 }             if(flag)                 cnt ++;             }         } 大括号换个位置试试看 for(i = 0;i < n; i ++)         {             flag = 1;             for(j = 0;j < m; j ++)             {                 if(a[i][j] < aver2[j])                 {                     flag = 0;                     break;                 }            }             if(flag)                 cnt ++;         }
user-0 提问: C语言编写PDF输出中文的一些问题

回复:
user: user-1
content: CID (Character identifier)就是字符识别码，在组成方式上分成CIDFont，CMap表两部分。CIDFont文件即总字符集，包括了一种特定语言中所有常用的字符，把这些字符排序，它们在总字符集中排列的次序号就是各个字符的CID标识码(Index)；CMap(Character Map)表即字符映射文件，将字符的编码(Code)映射到字符的CID标识码(Index)。CID字库完全针对大字符集市场设计，其基本过程为：先根据Code，在CMap表查到Index，然后在CIDFont文件找到相应的字形数据。

user: user-2
content: http://www.baigoogledu.com/s.php?hl=zh-CN&q=C%D3%EF%D1%D4%B1%E0%D0%B4PDF%CA%E4%B3%F6%D6%D0%CE%C4