我先学习汇编还是C?_百度知道
我先学习汇编还是C?
我想学习编程技术`目标网络安全工程师`我先学习汇编还是C?
即使想学机器语言也最好先学C语言。有了C语言基础学会内联和混编才能让汇编做应用程序变成可能。C语言入门容易，C语言就是学习编程的镰刀，学好以后向高低两个方向发展都非常好。上来就学汇编是很难测试自己的代码的。没有了这一层，单追求汇编的强大那学习就是恶梦。磨刀不误砍拆工C语言
其他类似问题
按默认排序
其他4条回答
也就有了其他高级语言没有的优势确切的说，资源利用率高。（学汇编要很大的毅力哦）至于楼主提到目标是网络安全工程师、ASP等），汇编是低级语言（面向硬件的），机器字长等很多东西都会存在差异，C是中级语言（可操作部分硬件）！，汇编跟进！、主流的Java、C++等是高级语言（跟硬件无关）个人倾向先学C语言。入门简单。万事开头难，即直接操作硬件，我的目标也是啊，执行效率高。但是汇编是最低层的编程语言，但是比C，楼主要为了目标坚持到底哦，对不同的硬件。所以建议楼主用C语言入门，可以学到许多主要的编程思想！真正玩网络安全（不是脚本小子）需要的不只是C。如计算机网络原理，对程序的优化（如在C语言中嵌入一段汇编指令）非常有帮助，那就要多说几句了。而且，还有很多东西要学习的、C++入门起来难、汇编等，毕竟是涉及操作硬件的编程呀，汇编能够让我们更好的去理解一个程序在机器上运行的整个过程，指令系统。汇编非常强大、还有很多Page脚本语言（如PHP
C语言是一切语言的基础！当然是先学C语言好点！
个人认为先学Ｃ　因为Ｃ是一门基础语言
先学C++吧！
您可能关注的推广
汇编的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁学习汇编语言一定要基于一定得cpu平台，目前的计算机变得越来越复杂，机器字长都是32为何64位，汇编级编程相当复杂，建议从&b&&u&机器字长为8位的单片机&/u&&/b&开始，单片机的芯片最为简单，最能体现计算机内部的原理，学汇编就是为了学计算机组成原理，当你学会点亮第一个LED灯的时候，就会发现汇编和计算机组成原理的真谛。&br&&br&非常不推荐《琢石成器》，里面讲的全是windows系统的一套东西，及其繁琐，而且不触及计算机的本质，&b&&u&单片机是没有操作系统的&/u&&/b&，在单片机上用汇编开发最能够获得直接控制硬件的编程体验，这种直接控制硬件的编程经验能够为以后的操作系统的学习打下良好的基础，更能够从硬件到软件系统地思考问题。&img src=&/0dc387afea646fc0264111fb_b.jpg& data-rawwidth=&600& data-rawheight=&400& class=&origin_image zh-lightbox-thumb& width=&600& data-original=&/0dc387afea646fc0264111fb_r.jpg&&
学习汇编语言一定要基于一定得cpu平台，目前的计算机变得越来越复杂，机器字长都是32为何64位，汇编级编程相当复杂，建议从机器字长为8位的单片机开始，单片机的芯片最为简单，最能体现计算机内部的原理，学汇编就是为了学计算机组成原理，当你学会点亮第一…
为了回答这个问题，我把尘封好几年的Intel Volume 2A-- Instruction Set Reference都翻出来了。想当年都是枕着它入睡的，有失眠的童鞋么，下一本睡前看看，保证看几眼就能感觉到那绵绵不绝的睡意扑面而来。&br&&br&虽然题主用的不是x86的汇编，但是道理是一样的啦。&br&我记得以前写汇编，最喜欢这样用&br&&i& mov
ecx, 40000h&br& xor eax, eax&br& rep
stosd&/i&&br&&br&在stosd前面加rep，就是把从ES:[(E)DI] 起，长度为0x40000的一个区域全部初始化成0.&br&这条rep stosd的指令当然不是原子性的啦，它可以被中断或异常打断。&br&&br&讲到LOCK，它也是蛮有用的。&br&在多处理器环境下，为了保护处理器间的共享资源，在访问这些共享资源的时候，前面就要加LOCK这个指令前缀。&br&&blockquote&The LOCK prefix (F0H) forces an operation that &b&ensures exclusive use of shared&/b&&br&&b&memory in a multiprocessor environment&/b&. See “LOCK—Assert LOCK# Signal Prefix”&br&in Chapter 3, “Instruction Set Reference, A-M,” for a description of this prefix.&/blockquote&&img src=&/eddc6260eed3dd14fd9ca2_b.jpg& data-rawwidth=&610& data-rawheight=&610& class=&origin_image zh-lightbox-thumb& width=&610& data-original=&/eddc6260eed3dd14fd9ca2_r.jpg&&但不是所有的汇编指令都允许在其前面加上LOCK的。&br&在x86汇编里，只有以下指令是允许加LOCK的：&br&&i&&b&ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, CMPXCH8B, DEC, INC,&/b&&/i&&br&&i&&b&NEG, NOT, OR, SBB, SUB, XOR, XADD, XCHG.&/b&&/i&&br&加在其它的指令前面，会产生异常。&br&&br&讲了这么多理论知识，给一个具体的例子好了。&br&下图是处理SMI ISR的一段代码，SMI是System Management Interrupt，它有一个特点就是要等所有的CPU都处理完了才能退出中断。进入SMI中断后，CPU就切换到一个特殊的模式，叫做SMM (System Management Mode)。最先进入SMM的CPU叫做BSP，后面进来的叫AP。下图中那个bNoOfCPUsInSMM和bSMISyncByte就是BSP和AP间共享的变量，所以在对它进行访问时就要在指令前面加LOCK。&br&&img src=&/501e129e71c2e6ec02fa_b.jpg& data-rawwidth=&761& data-rawheight=&237& class=&origin_image zh-lightbox-thumb& width=&761& data-original=&/501e129e71c2e6ec02fa_r.jpg&&
为了回答这个问题，我把尘封好几年的Intel Volume 2A-- Instruction Set Reference都翻出来了。想当年都是枕着它入睡的，有失眠的童鞋么，下一本睡前看看，保证看几眼就能感觉到那绵绵不绝的睡意扑面而来。虽然题主用的不是x86的汇编，但是道理是一样的啦。…
写一个默认显示Hello World的操作系统
写一个默认显示Hello World的操作系统
汇编语言的前景,得看是什么汇编,比如嵌入式那是另一回事了,如果说的是x86汇编语言,&br&前景我非常不看好,对于普通的应用程序来说,开发效率已经成了最为关注的地方,而运行&br&效率已经快成为可有可无的东西了(从java,python等语言的崛起就能看出来).虽然我个人&br&很反感这种理念,但这就是事实.也是近几年的发展趋势,还有跨平台的问题就更不用说了,&br&现有一个算法,x86汇编写的,要移植到iphone上,烦死你!,C写的,代码拷过来编译一下就好了.&br&&br&显然对于汇编来说,无论是普通的汇编还是像HLA这样的&高阶汇编语言&,都是重视&br&运行效率而不是开发效率的.那么从这一点上来说,汇编首先就吃了亏.&br&&br&那么,对于非常重视速度的领域,比如音视频处理,游戏,科学计算之类的软件,汇编是否有巨大的优势呢? 今天来说,我认为优势还是有的,但已经非常小了.我们先不说SIMD,除了SIMD之外,寄存器的占用,指令顺序优化什么的,C或者C++编译器已经做得非常好了.当然,前提是使用者写的C/C++代码&br&不能太蠢. &br&&br&那么说到SIMD,编译器在对待SIMD的时候确实非常笨,几乎完全无法有效的使用SIMD指令.但&br&对C/C++的使用者来说,完全可以使用intrinsics来替代手写SSE/AVX指令.intrinsics非常好用,&br&我一年多还在手写SSE汇编,现在全完用intrinsics了,我真没发现和手写SSE汇编有任何区别.甚至&br&更好,尤其是在intel编译器上! (当然可能会有人提出手写更好,这就小马过河了呵呵).&br&&br&当然,汇编在一些情况下依然优势较大,比如玩bit的情况下(你要知道很在意速度的人是很爱玩bit的!)&br&,比如什么&快速mod&,&快速整型除法&,&快速浮点转定点&之类的,汇编确实优势很大,C当然也能&br&实现,只是反倒不如汇编方便. 但是,即便在这种情况下,完全可以使用内联汇编而不需要整个算法&br&都用汇编,使用内联汇编, Intrinsics再配合编译器的自动优化,完全可以写出效率更高,速度有保证,调试方便的代码,不容易出错的(我是说相对完全手写!)代码.如果你用GCC的话,在写内联汇编的&br&时候甚至不用告诉编译器你到底要用eax还是esi,只要告诉编译器你需要一个空闲的寄存器就行了.&br&真的很方便.&br&&br&所以,综上,直接手写x86汇编的场合确实越来越少了,从商业或者个人就业的角度,业内&br&对x86/x64汇编的需求量肯定会越来越少,但我并不是要说人们不该去学汇编,事实上我认为&br&所有程序员依然应该去学汇编,哪怕你的主力开发语言是lua.因为只有学了汇编,你才能知道&br&cpu什么操作快,什么操作慢,编译器/解释器什么时候聪明什么时候笨, 其实,汇编也没难到哪里去,&br&如果只是拿汇编写算法,或者查看反汇编(你要拿汇编写集群服务器那谁也救不了你了),半个月就能&br&学会,我认识的C/C++高手,没有不会汇编的(起码看的懂!),我认识的专写汇编的,也没有不会C的,&br&&br&以上言论仅针对x86/x64汇编.
汇编语言的前景,得看是什么汇编,比如嵌入式那是另一回事了,如果说的是x86汇编语言,前景我非常不看好,对于普通的应用程序来说,开发效率已经成了最为关注的地方,而运行效率已经快成为可有可无的东西了(从java,python等语言的崛起就能看出来).虽然我个人很反感…
某某在大学遇到一女孩儿，她是世界上最好的女孩儿，现在像她这样的女孩儿不多了。某某想跟她永远幸福地生活在一起……从毕业的那一天，他们撑着过了好几年，是时间太重？是承诺太轻？是现实太近？是梦想太远？是一行脚本胜过万行代码？百般用心却还不如糙猛快？前方的路越走越难，同行的人渐行渐远……&br&&br&多年之后蓦然回首，才终于明白：谈钱伤感情，编程也一样！说喜欢就别想工作，想工作就别说喜欢……个人觉得汇编不是过日子的主儿，不过，你喜欢就好……
某某在大学遇到一女孩儿，她是世界上最好的女孩儿，现在像她这样的女孩儿不多了。某某想跟她永远幸福地生活在一起……从毕业的那一天，他们撑着过了好几年，是时间太重？是承诺太轻？是现实太近？是梦想太远？是一行脚本胜过万行代码？百般用心却还不如糙猛…
来自子话题：
讲讲大概思路，技术细节就不能公开了。&br&破解加了dex壳的app，关键是要获得解密后的源dex，现在Android加壳技术还很不成熟，大多都是通过DexClassLoader或者隐藏的函数openDexFile来将源dex加载进来，然后动态替换Application来启动源程序，跟Windows上传统的PE文件加壳有一定区别。&br&要破解传统的壳，需要跟踪控制流找到OEP，然后把源程序从内存中dump下来，重建输入表，最困难的就是要跟着外壳的控制流走，安全工程师为了加大破解难度，使用了很多技术来让破解者走得更艰难。安全工程师与破解者对抗的关键点就在寻找OEP的困难性上。&br&在Android平台上，正因为新兴的dex加壳技术不成熟，导致有些另类的脱壳方法可以绕过分析算法，直接将源程序dump下来。举个例子，安卓在4.0版本以后提供openDexFile这个函数来从内存中加载dex，所需要提供的参数是源dex在内存中的地址，所以只要对这个函数下断，然后从寄存器里找到内存地址，就能将解密后的源dex从内存中dump下来，直接对其反编译就能获得源代码了。更进一步，关于openDexFile这个函数，其实它与libdvm.so这个库有密不可分的关系，这个库里提供大量操作dex文件的函数，如果对这个库里的相关函数下断，然后从内存中暴力dump一大块内存区域，经常能直接将内存中的源dex给抓下来。
讲讲大概思路，技术细节就不能公开了。破解加了dex壳的app，关键是要获得解密后的源dex，现在Android加壳技术还很不成熟，大多都是通过DexClassLoader或者隐藏的函数openDexFile来将源dex加载进来，然后动态替换Application来启动源程序，跟Windows上传统的…
实际上就是#define ABS ((x)&0?(x):-(x))&br&一个靠谱的编译器会把abs的if编译成条件传送指令，无分支。以x86为例&br&&div class=&highlight&&&pre&&code class=&language-c&&&span class=&kt&&int&/span& &span class=&n&&ABS&/span&&span class=&p&&(&/span&&span class=&kt&&int&/span& &span class=&n&&x&/span&&span class=&p&&){&/span&
&span class=&k&&return&/span& &span class=&n&&x&/span&&span class=&o&&&&/span&&span class=&mi&&0&/span&&span class=&o&&?&/span&&span class=&n&&x&/span&&span class=&o&&:-&/span&&span class=&n&&x&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&/code&&/pre&&/div&clang test.c -S -O2 -o test.s&br&&div class=&highlight&&&pre&&code class=&language-nasm&&&span class=&nf&&movl&/span&
&span class=&o&&%&/span&&span class=&nb&&edi&/span&&span class=&p&&,&/span& &span class=&o&&%&/span&&span class=&nb&&eax&/span&
&span class=&nf&&negl&/span&
&span class=&o&&%&/span&&span class=&nb&&eax&/span&
&span class=&nf&&cmovll&/span&
&span class=&o&&%&/span&&span class=&nb&&edi&/span&&span class=&p&&,&/span& &span class=&o&&%&/span&&span class=&nb&&eax&/span&
&/code&&/pre&&/div&注意这个cmovl&br&改成&br&&div class=&highlight&&&pre&&code class=&language-c&&&span class=&kt&&int&/span& &span class=&n&&ABS&/span&&span class=&p&&(&/span&&span class=&kt&&int&/span& &span class=&n&&x&/span&&span class=&p&&){&/span&
&span class=&k&&if&/span&&span class=&p&&(&/span&&span class=&n&&x&/span&&span class=&o&&&&/span&&span class=&mi&&0&/span&&span class=&p&&)&/span& &span class=&k&&return&/span& &span class=&n&&x&/span&&span class=&p&&;&/span&
&span class=&k&&else&/span& &span class=&k&&return&/span& &span class=&o&&-&/span&&span class=&n&&x&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&/code&&/pre&&/div&编译结果是一样的。&br&再测试一下，&br&&div class=&highlight&&&pre&&code class=&language-c&&&span class=&kt&&int&/span& &span class=&n&&ABS&/span&&span class=&p&&(&/span&&span class=&kt&&int&/span& &span class=&n&&x&/span&&span class=&p&&){&/span&
&span class=&k&&return&/span& &span class=&n&&abs&/span&&span class=&p&&(&/span&&span class=&n&&x&/span&&span class=&p&&);&/span&
&span class=&p&&}&/span&
&/code&&/pre&&/div&编译结果还是一模一样的！！！！现代编译器比一般人想象的智能得多。&br&arm/mips也有类似的条件传送指令。
实际上就是#define ABS ((x)&0?(x):-(x))一个靠谱的编译器会把abs的if编译成条件传送指令，无分支。以x86为例int ABS(int x){
return x&0?x:-x;
}clang test.c -S -O2 -o test.smovl %edi, %eax
cmovll %edi, %eax注意这个cmovl改成int ABS(int …
总的来说，就是因为现在的CPU太牛逼了，你那么写已经没什么用了
总的来说，就是因为现在的CPU太牛逼了，你那么写已经没什么用了
先随便找本书看看，懂得写几个简单的程序之后，就去刷intel的那本手册。&br&======&br&忘记说为什么要刷intel的手册了。原因有3：&br&1、这样你才知道有多少指令是，虽然你可以不用，但是用了更好的，譬如说x86就有一个检查int是否在一对int的范围内的指令，可以用来检查数组越界什么的。&br&2、每一代都有新增加的指令，譬如MMX、SSE、AVX什么的。这些你并不能忽略，因为现在64位在windows上的calling convention都要求你用SSE的寄存器来存放浮点数什么的。&br&3、也是最重要的，必须学会如何写机器码呀！
先随便找本书看看，懂得写几个简单的程序之后，就去刷intel的那本手册。======忘记说为什么要刷intel的手册了。原因有3：1、这样你才知道有多少指令是，虽然你可以不用，但是用了更好的，譬如说x86就有一个检查int是否在一对int的范围内的指令，可以用来检…
你好。&br&《Windows核心编程》，这本书是必看的。&br&然后就是去一些论坛了。&br&走破解路线可以去看雪。&br&渗透测试的话，去暗组之类的地方看看吧，最近比较严，黑客防线都关了。&br&如果走rootkit路线的话，《Rootkit，Windows内核的安全与防护》其实是一本不错的书。&a href=&& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a&的老大写的，对于初学者是一本很好的入门教材。&br&如果看完了以上内容，并对自己智商有信心的话，毛德操大神的《Windows内核情景再现》很可能就是你的下一本读物了。&br&但是千万要小心，毛德操大神的那本书我看了四天看了不到一百页。直想吐学。&br&如果学这方面的知识，参考别人的源码是很重要的。&br&灰鸽子和黑洞早期都已经开源&br&gh0st也是开源的。&br&Darkst上面也有一个开源的远控，可以供参考。&br&还是推荐C++，delphi的DDDK实在是太恶心了。
你好。《Windows核心编程》，这本书是必看的。然后就是去一些论坛了。走破解路线可以去看雪。渗透测试的话，去暗组之类的地方看看吧，最近比较严，黑客防线都关了。如果走rootkit路线的话，《Rootkit，Windows内核的安全与防护》其实是一本不错的书。…
&br&求折叠…… 参见：&a href=&/p/& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/p/14473&/span&&span class=&invisible&&2987&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&br&&br&&br&他看了一下电脑，问我有没有Windows 98的光盘？，我说没有。
&br&他想了一下，叫我把家里电话拿给他，我心里想说修电脑要电话干什么？
&br&但人家是电脑高手，我也不好意思说什么，就把电话拔下来给他了。
&br&他把电话线空着的一头接在主机版的一个插孔内，然后进入了DOS，
&br&然后就开始在电话上不停的按着键，他按键的速度非常快，但是他都只按电话的0，1两个键。
&br&我搞不懂这有什么用？但也不敢问，看了半个多小时，他还是不停的按这两个键，
&br&我渐渐的有些困，我问他这东西要搞多久？他说还要几个小时，我给他倒了杯咖啡，
&br&就一个人去隔壁书房睡觉了。
&br&醒来的时候，一看已经过了5个多小时，我起身到隔壁，看见他正在Windows 98里面调试，
&br&过了一会儿，他说，你试试，我坐上椅子用了一下，真的好了，我当时也不懂电脑，
&br&谢过人家就走了。
&br&后来我慢慢对电脑有了一些概念才了解到，
&br&原来当时那位电脑高手是使用机器语言编了一个Windows 98系统
&br&从我给他的电话直接输入到硬盘，
&br&我后来问我同学那位高手的下落，我同学说前几年去了美国之后，杳无音讯....
&br&========================================================================
&br&因为我那时还是个电脑入门，我朋友帮我介绍了一个电脑高手来帮我修电脑。
&br&他看了一下电脑，问我有没有Windows Me的安装盘？我说没有。
&br&他想了一下，叫我把一张空的DVD刻录盘和一根奈米细针拿给他，
&br&我心里想说修电脑要刻录盘和奈米细针干什么？但人家是电脑高手，我也不好意思说什么，
&br&於是我就把DVD刻录盘拿一张来给他了。
&br&他把奈米细针头对着刻录盘戳，他戳的速度非常快，但是只戳深或浅，
&br&我搞不懂这有什么用？但也不敢问，看了半个多小时，他还是不停的戳着DVD刻录盘，
&br&我渐渐的有些困，我问他这东西要搞多久？他说要几个小时，我给他倒了杯葡萄酒，
&br&就一个人去隔壁客厅沙发上睡觉了。
&br&醒来的时候，一看已经过了6个多小时，我起身到隔壁，看见他正在Windows Me里面调试，
&br&还装上了Office、Photoshop、迅雷、魔兽世界等软件……过了一会儿他说，
&br&你试试，我坐上椅子用了一下，真的好了，我当时也不懂电脑，谢过人家就走了。
&br&后来我慢慢对电脑有了一些基础，终于明白了，
&br&原来当时那位电脑高手是用奈米细针头刻了一个单面双层的DVD，在里面刻上了Windows Me、Office、
Photoshop、魔兽世界的安装程序，我后来问我朋友那位高手的下落，
&br&我朋友说前几年去了法国之后，杳无音讯....
&br&========================================================================
&br&因为我那时还是个电脑新手，我亲戚帮我介绍了一个电脑高手来帮我的电脑D盘恢复数据。 &br&&br&&br&他看了一下电脑，问我有没有Windows XP备份过的Ghost？我说没有。
&br&他想了一下，叫我把一块奈米强力磁铁棒拿给他，还问我D盘里有什么东西？
&br&我心里想说修电脑要奈米强力磁铁棒干什么？
&br&但人家是电脑高手，我也不好意思说什么，就把奈米强力磁铁棒给他了，
&br&还告诉他我的D盘里面全是火影忍者的动画。
&br&他把整颗硬盘拆了，用奈米强力磁铁棒在盘子上面画圈圈，他画圈圈的速度非常快，
&br&但是他的奈米强力磁铁棒好像有碰到又好像没有碰到，我搞不懂这有什么用？但也不敢问，
&br&看了半个多小时，他还是不停的在硬盘上画着圈，我渐渐的有些困，
&br&我问他这东西要搞多久？他说要几个小时，我给他倒了杯苏格兰威士忌，
&br&就一个人去隔壁房间睡觉了。
&br&醒来的时候，一看已经过了7个多小时，我起身到隔壁，看见他正在D盘里面调试，
&br&里面全是火影忍者的动画片，过了一会儿，他说，
&br&你试试，我坐上椅子用了一下，真的好了，我当时也不懂电脑，谢过人家就走了。
&br&后来我慢慢对电脑有了一些体会，终于体悟到，
&br&原来当时那位电脑高手是用奈米强力磁铁棒直接在硬盘上写数据，
&br&他凭着惊人的记忆力将他曾经看过的火影忍者动画片数据都写入了硬盘，我后来问我亲戚那位电脑高手的下落，我亲戚说他前几年去了英国之后，杳无音讯....
&br&========================================================================
&br&就在最近，我刚装上的Vista突然自己崩溃了
&br&就在最近，我刚装上的Vista突然自己崩溃了，虽然我会写很多程序，但是Vista崩溃了我也没
&br&有办法，我朋友给我介绍了一个高手来帮我修电脑。
&br&他看了一下电脑，问我有没有Vista的安装盘，我说没有。
&br&他想了一下，叫我拿一根没用的网线和一把剪刀，我想修电脑要网线和剪刀干什么，但人家
&br&是高手，我也不好说什么，就拿了一根没用的网线和一把剪刀给他。
&br&他把网线一头戳到网卡上，剪断另外一头，然后就在哪里不停的拨弄那八根线。他拨弄的速
&br&度非常快，但是拨弄得线总是不一样，我搞不懂这有什么用，但也不敢问，看了半个多小
&br&时，他还是不停的拨弄着网线。我渐渐的有些困，我问他这东西要搞多久，他说要几个小
&br&时，我给他倒了杯茶，就一个人去隔壁睡觉了。
&br&醒来的时候，一看已经过了4个多小时，我起身到隔壁，看见他正在Vista里面调试，还装给
&br&装好了Visual Studio 2005 Team Suit、Ms SqlServer 2005 Enterprise Edition、BT，还边
&br&下载边看American片……过了一会儿，他惊觉我站在后面，不好意思地对我说，你试试。我
&br&坐上椅子用了一下，真的好了，我当时太震惊了，整个人傻在哪里，谢过人家就走了。
&br&后来我读到了前面那两篇文章，终于醒悟，原来当时那位高手是用网线模拟网络启动，下载
&br&了整个Vista，还有Visual Studio 2005 Team Suit、Ms SqlServer 2005 Enterprise Edition、
&br&BT，以及他正在看的American片，我后来问我朋友那位高手的下落，我朋友说前几年去了
&br&美国之后，杳无音讯了十几年，期间也回过中国两次，最近这一次回来说，干这个太没意思
&br&了，回来收拾收拾准备去阿尔法半人马座，他说他也听不懂那高手说什么，只是最近传闻微
&br&软的Vista全世界都无法激活，估计跟他的离去有关，当然了，这几天也是杳无音讯&br&&br&&br&
求折叠…… 参见：他看了一下电脑，问我有没有Windows 98的光盘？，我说没有。 他想了一下，叫我把家里电话拿给他，我心里想说修电脑要电话干什么？ 但人家是电脑高手，我也不好意思说什么，就把电话拔下来给他了。 他把电话线空着的一…
build target请选择x64指令集。
build target请选择x64指令集。
既然看的是王爽的汇编，我就默认题主是想要在windows上搞逆向之类的（其实是其他的我根本就不懂..）&br&逆向这个东西，涉及到的东西很多而且很杂，仅仅会一点x86汇编是远远不够的，我也只是了解一点，就这么一说，题主当个参考。&br&首先王爽的汇编还停留在16位的8086汇编的阶段，但是现在的操作系统都是跑在32位或64位的保护模式下，特别是64位的windows是不能直接运行16位的程序的。于是楼主的首要任务是学习32位的汇编，这里推荐的书就是 &a class=&member_mention& href=&/people/c708c0b10bc3d8a9387601& data-editable=&true& data-title=&@鸡气猫& data-hash=&c708c0b10bc3d8a9387601& data-tip=&p$b$c708c0b10bc3d8a9387601&&@鸡气猫&/a& 同学说的《intel汇编语言程序设计》，最新的版本是第五版。其实16位汇编转32位我个人觉得只要能真正理解了 逻辑地址、线性地址和物理地址就差不多了，不用急着去搞明白保护模式那些像分页机制之类的深奥的东西。&br&汇编差不多了，也就是懂了个语言，光会这个可不行，你还需要会一些&正向&的东西，连有源码都看不懂的话，看着天书一般的反汇编代码跟就没可能看懂了，而且不但要会，还需要比普通的程序猿更深入的理解。这一方面需要的东西就太多了，像windows的消息机制要懂，要不你不知道怎么跟踪某个按钮的单击事件，directui还没子窗口，这是个大坑....这一方面首先需要看windows API编程方面的书了，推荐《windows程序设计 第五版》虽然老的不行了，但是windows的基础API几乎没啥变化，所以这本书完全可用， &a class=&member_mention& href=&/people/eaba6ab7132eebf8d2f177af15fd99fc& data-editable=&true& data-title=&@bombless& data-hash=&eaba6ab7132eebf8d2f177af15fd99fc& data-tip=&p$b$eaba6ab7132eebf8d2f177af15fd99fc&&@bombless&/a& 提到的罗云彬的《windows环境下32位汇编语言程序设计》可以当做windows程序设计一书的汇编版本，可任选一本看看。深入理解就要看深入解析windows操作系统了。&br&到了这时候题主就可以看一些跟逆向相关的书了，这里首推看雪老大段钢的《加密与解密》第三版，其实主要是在讲各种工具的使用和寄出的逆向方面的知识。不要看前两版，介绍的工具太老了，还在介绍softice和TRW2000（顺便膜拜一下刘涛涛），这两个玩意年龄快有我大了...最重要的两个工具当属OllyDBG和IDA Pro了，分别是动态调试和静态反汇编的神器，动态调试相当于一辆车，你驾驶着他前进，静态反汇编则是地图，防止你迷失在代码中。其中OD是免费的，IDA是收费的（一个IDA Pro +hexrays decompiler插件好几万软妹币...）不过IDA有demo版本，支持的文件格式和CPU比较少，只搞windows的应该够用了，不过没法用F5了（F5是个快捷键，直接反编译成伪C代码）...关于IDA还有一本专门的书《IDA Pro 权威指南》。&br&到了这个时候，一般的无花无壳无VM的小程序就能搞定了，不过在这凶残的世道上这么蠢萌的小程序实在太少见了。&br&接下来如果还想继续深入，就免不了跟各种反调试加密壳做斗争了，你就需要研究PE文件格式，研究多态引擎，虚拟机引擎之类的东西，还经常需要搞驱动或者深入到R0，这些东西有的根本没啥书籍资料，多是些网上的资料，我也不是很了解，这里就简单的推荐几本书吧：&br&PE文件格式：&a href=&/showthread.php?t=61497& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&【翻译】Microsoft PECOFF规范v8和v8.1中文版[更新v8.1版]&i class=&icon-external&&&/i&&/a& 原版在这里&a href=&/en-US/windows/hardware/gg463119& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/en-U&/span&&span class=&invisible&&S/windows/hardware/gg463119&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&，也有过几本书，不过我没看过，感觉这个加上《加密与解密》里面的介绍就够用了，另外还有几张大图&img src=&/29dbdd34f4df277fc86b08d3_b.jpg& data-rawwidth=&2968& data-rawheight=&1911& class=&origin_image zh-lightbox-thumb& width=&2968& data-original=&/29dbdd34f4df277fc86b08d3_r.jpg&&&br&&br&驱动这玩意一共没几本书，就把知道的都说一下吧：&br&《 Windows驱动开发技术详解》&br&《竹林蹊径深入浅出windows驱动开发》&br&《天书夜读 从汇编语言到windows内核编程》&br&《软件调试》&br&既然涉及到了驱动，不补一下汇编的保护模式肯定也不行，就推荐一下杨季文的黑皮书《80x86汇编语言程序设计教程》，据说有错误，不过我没看出来，应该是水平问题，官方的文档就是intel的开发者手册了&a href=&/content/www/us/en/processors/architectures-software-developer-manuals.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Intel速 64 and IA-32 Architectures Software Developer Manuals&i class=&icon-external&&&/i&&/a&&br&关于VMP什么的，着我就真的的无能为力了，自己到下面的论坛找吧。看雪和UPK的精华帖都是很NB的&br&&a href=&/index.php& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&看雪安全论坛&i class=&icon-external&&&/i&&/a&&br&&a href=&/forum.php& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&一蓑烟雨论坛-UPK安全社区&i class=&icon-external&&&/i&&/a&&br&&a href=&/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&吾爱破解论坛-LCG-LSG|软件安全&i class=&icon-external&&&/i&&/a&&br&还有些飘云阁或者第八个男人啥的，都许久没上了，不知道还在不在，就不贴了&br&&br&另外如果题主是要搞arm汇编或者Android上的逆向，就需要看《Android软件安全与逆向分析》 作者 &a class=&member_mention& href=&/people/f2dcea077adbda58e9b444& data-hash=&f2dcea077adbda58e9b444& data-tip=&p$b$f2dcea077adbda58e9b444&&@非虫&/a& （嘿嘿帮忙打个广告）
既然看的是王爽的汇编，我就默认题主是想要在windows上搞逆向之类的（其实是其他的我根本就不懂..）逆向这个东西，涉及到的东西很多而且很杂，仅仅会一点x86汇编是远远不够的，我也只是了解一点，就这么一说，题主当个参考。首先王爽的汇编还停留在16位的80…
这是一个很有意思的东西。不过题主似乎遗忘掉了另外一个编译器GCC，题主应该把GCC也加上去，其实GCC的优化也很意思。&br&乘法其实依旧很慢，相比加法和赋值操作来说的话。&br&我去找了一台机器，CentOS 5.5，CPU Xeon W5580，主频3.2GHz，大约基本的加法与移位是0.3纳秒，乘法大约是0.9纳秒，也就是三倍。可能不是特别精确，但是乘法比加法、移位等操作慢，这是肯定的。我们这里就姑且以三倍的时间来看看这些优化的指令代码吧，我觉得挺有趣的。&br&借用了楼主的例子，&br&&div class=&highlight&&&pre&&code class=&language-cpp&&&span class=&kt&&void&/span& &span class=&n&&foo&/span&&span class=&p&&(&/span&&span class=&kt&&int&/span& &span class=&o&&&&/span&&span class=&n&&a&/span&&span class=&p&&,&/span&&span class=&kt&&int&/span& &span class=&o&&&&/span&&span class=&n&&b&/span&&span class=&p&&)&/span&
&span class=&p&&{&/span&
&span class=&n&&b&/span& &span class=&o&&=&/span& &span class=&n&&a&/span& &span class=&o&&*&/span& &span class=&mi&&192&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&span class=&kt&&void&/span& &span class=&n&&bar&/span&&span class=&p&&(&/span&&span class=&kt&&int&/span& &span class=&o&&&&/span&&span class=&n&&a&/span&&span class=&p&&,&/span&&span class=&kt&&int&/span& &span class=&o&&&&/span&&span class=&n&&b&/span&&span class=&p&&)&/span&
&span class=&p&&{&/span&
&span class=&n&&b&/span& &span class=&o&&=&/span& &span class=&p&&(&/span&&span class=&n&&a&/span& &span class=&o&&&&&/span& &span class=&mi&&6&/span&&span class=&p&&)&/span& &span class=&o&&+&/span& &span class=&p&&(&/span&&span class=&n&&a&/span& &span class=&o&&&&&/span& &span class=&mi&&7&/span&&span class=&p&&);&/span&
&span class=&p&&}&/span&
&span class=&kt&&void&/span& &span class=&n&&baz&/span&&span class=&p&&(&/span&&span class=&kt&&int&/span& &span class=&o&&&&/span&&span class=&n&&a&/span&&span class=&p&&,&/span&&span class=&kt&&int&/span& &span class=&o&&&&/span&&span class=&n&&b&/span&&span class=&p&&)&/span&
&span class=&p&&{&/span&
&span class=&n&&b&/span& &span class=&o&&=&/span& &span class=&p&&(&/span&&span class=&n&&a&/span& &span class=&o&&*&/span& &span class=&mi&&3&/span&&span class=&p&&)&/span& &span class=&o&&&&&/span& &span class=&mi&&6&/span&&span class=&p&&;&/span&
&span class=&p&&}&/span&
&/code&&/pre&&/div&&br&后面我们来看foo函数的，我们先分析bar函数。下面是clang -O2的结果：&br&&div class=&highlight&&&pre&&code class=&language-llvm&&&span class=&err&&foo&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&&span class=&err&&:&/span&
&span class=&err&&#&/span& &span class=&vg&&@foo&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&
&span class=&err&&imull&/span& &span class=&err&&$&/span&&span class=&m&&192&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rdi&/span&&span class=&p&&),&/span& &span class=&nv&&%eax&/span&
&span class=&err&&movl&/span& &span class=&nv&&%eax&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rsi&/span&&span class=&p&&)&/span&
&span class=&k&&ret&/span&
&span class=&err&&bar&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&&span class=&err&&:&/span&
&span class=&err&&#&/span& &span class=&vg&&@bar&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&
&span class=&err&&imull&/span& &span class=&err&&$&/span&&span class=&m&&192&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rdi&/span&&span class=&p&&),&/span& &span class=&nv&&%eax&/span&
&span class=&err&&movl&/span& &span class=&nv&&%eax&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rsi&/span&&span class=&p&&)&/span&
&span class=&k&&ret&/span&
&span class=&err&&baz&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&&span class=&err&&:&/span&
&span class=&err&&#&/span& &span class=&vg&&@baz&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&
&span class=&err&&imull&/span& &span class=&err&&$&/span&&span class=&m&&192&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rdi&/span&&span class=&p&&),&/span& &span class=&nv&&%eax&/span&
&span class=&err&&movl&/span& &span class=&nv&&%eax&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rsi&/span&&span class=&p&&)&/span&
&span class=&k&&ret&/span&
&/code&&/pre&&/div&&br&这里可以看见都被优化成了192。第二条程序里面是(a && 6 ) + (a && 7)，如果按照ICC的汇编来看&br&&div class=&highlight&&&pre&&code class=&language-text&&L__routine_start__Z3barRiS__1:
bar(int&, int&):
(%rdi), %eax
%eax, %edx
%eax, %edx
%edx, (%rsi)
&/code&&/pre&&/div&再按照我们刚才的那个三倍时间对比来看，两个移位加上一个相加的时间，其实ICC的时间和LLVM一样。而GCC是什么情况呢?&br&&div class=&highlight&&&pre&&code class=&language-llvm&&&span class=&err&&bar&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&&span class=&err&&:&/span&
&span class=&err&&movl&/span& &span class=&p&&(&/span&&span class=&nv&&%rdi&/span&&span class=&p&&),&/span& &span class=&nv&&%eax&/span&
&span class=&err&&imull&/span& &span class=&err&&$&/span&&span class=&m&&192&/span&&span class=&p&&,&/span& &span class=&nv&&%eax&/span&&span class=&p&&,&/span& &span class=&nv&&%eax&/span&
&span class=&err&&movl&/span& &span class=&nv&&%eax&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rsi&/span&&span class=&p&&)&/span&
&span class=&k&&ret&/span&
&/code&&/pre&&/div&其实也是优化为了192.&br&&br&那么，我们看baz代码，ICC的优化是：&br&&div class=&highlight&&&pre&&code class=&language-text&&L__routine_start__Z3bazRiS__2:
baz(int&, int&):
(%rdi), %eax
(%rax,%rax,2), %edx
%edx, (%rsi)
&/code&&/pre&&/div&&br&这里代码是(a * 3 ) && 6，如果按照ICC的代码计算，一条lea是0.3纳秒，然后移位是0.3纳秒，这里的时间是优化一条乘法指令的0.9纳秒的。而GCC是什么情况呢？&br&&div class=&highlight&&&pre&&code class=&language-text&&baz(int&, int&):
movl (%rdi), %eax
leal (%rax,%rax,2), %eax
sall $6, %eax
movl %eax, (%rsi)
&/code&&/pre&&/div&这里GCC和ICC的优化一样。&br&&br&然后我们再来看foo函数。&br&&div class=&highlight&&&pre&&code class=&language-llvm&&&span class=&err&&::L__routine_start__Z&/span&&span class=&m&&3&/span&&span class=&err&&fooRiS&/span&&span class=&p&&(&/span&&span class=&kt&&void&/span&&span class=&p&&)&/span&&span class=&err&&:&/span&
&span class=&err&&foo&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&&span class=&err&&:&/span&
&span class=&err&&movl&/span&
&span class=&p&&(&/span&&span class=&nv&&%rdi&/span&&span class=&p&&),&/span& &span class=&nv&&%eax&/span&
&span class=&err&&#&/span&&span class=&m&&3.9&/span&
&span class=&err&&lea&/span&
&span class=&p&&(&/span&&span class=&nv&&%rax&/span&&span class=&p&&,&/span&&span class=&nv&&%rax&/span&&span class=&p&&,&/span&&span class=&m&&2&/span&&span class=&p&&),&/span& &span class=&nv&&%edx&/span&
&span class=&err&&#&/span&&span class=&m&&3.13&/span&
&span class=&err&&shll&/span&
&span class=&err&&$&/span&&span class=&m&&6&/span&&span class=&p&&,&/span& &span class=&nv&&%edx&/span&
&span class=&err&&#&/span&&span class=&m&&3.13&/span&
&span class=&err&&movl&/span&
&span class=&nv&&%edx&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rsi&/span&&span class=&p&&)&/span&
&span class=&err&&#&/span&&span class=&m&&3.5&/span&
&span class=&k&&ret&/span&
&span class=&err&&#&/span&&span class=&m&&4.1&/span&
&span class=&err&&#&/span&&span class=&m&&7.1&/span&
&/code&&/pre&&/div&ICC是进行了一个移位，然后再相加，那么这里的时间应该是0.3+0.3= 0.6,比乘法指令优秀。&br&而GCC呢?&br&&div class=&highlight&&&pre&&code class=&language-llvm&&&span class=&err&&foo&/span&&span class=&p&&(&/span&&span class=&err&&int&&/span&&span class=&p&&,&/span& &span class=&err&&int&&/span&&span class=&p&&)&/span&&span class=&err&&:&/span&
&span class=&err&&movl&/span& &span class=&p&&(&/span&&span class=&nv&&%rdi&/span&&span class=&p&&),&/span& &span class=&nv&&%eax&/span&
&span class=&err&&leal&/span& &span class=&p&&(&/span&&span class=&nv&&%rax&/span&&span class=&p&&,&/span&&span class=&nv&&%rax&/span&&span class=&p&&,&/span&&span class=&m&&2&/span&&span class=&p&&),&/span& &span class=&nv&&%eax&/span&
&span class=&err&&sall&/span& &span class=&err&&$&/span&&span class=&m&&6&/span&&span class=&p&&,&/span& &span class=&nv&&%eax&/span&
&span class=&err&&movl&/span& &span class=&nv&&%eax&/span&&span class=&p&&,&/span& &span class=&p&&(&/span&&span class=&nv&&%rsi&/span&&span class=&p&&)&/span&
&span class=&k&&ret&/span&
&/code&&/pre&&/div&&br&其实和ICC一样的。所以，就这个例子来说，GCC和ICC的优化选择比LLVM略好。
这是一个很有意思的东西。不过题主似乎遗忘掉了另外一个编译器GCC，题主应该把GCC也加上去，其实GCC的优化也很意思。乘法其实依旧很慢，相比加法和赋值操作来说的话。我去找了一台机器，CentOS 5.5，CPU Xeon W5580，主频3.2GHz，大约基本的加法与移位是0.3…
王爽的汇编语言，我正在看第二版，超级通俗易懂，运用知识隔离理论，没讲到的地方绝不提前出现，稳扎稳打按部就班，慢慢就都明白了。
王爽的汇编语言，我正在看第二版，超级通俗易懂，运用知识隔离理论，没讲到的地方绝不提前出现，稳扎稳打按部就班，慢慢就都明白了。
这本书我最近在看，感觉很牛逼，很高端。这本书中文翻译为了算法心得:高效算法的奥秘，而其实它与算法导论之类的算法完全是两个世界，算法导论是我们脑子里面认为的计算机算法研究，如DP，Sort，Search等，但是这些算法研究的东西没有深入到计算机内部去，而如这本书开篇说的一样，它讲的是计算机算术（Computer Arithmetic），也就是说算法导论研究的是数，并且忽略了计算机体系结构，而这本书研究的是参与运算的这些数的位串(bit string)与位元数组(bit vector)，却与计算机体系结构有关的，正是因为这样的特性，这本书不适合学习传统计算机算法，也不适合大部分做应用程序的程序员，但是对于写编译器、追求高效代码、语言低级库设计等程序员来说，这就是非常Nice的书籍了，这也是你所说的它总是在追求指令级别的优化了，所以这并非学院派著作，而是针对特定群体的一本书。不过，我没有读完，我现在判定不了是否是神书，但是目前感觉这本书有点神，读完以后希望我还记得来补充一下（不过感觉应该会记不得了....）
这本书我最近在看，感觉很牛逼，很高端。这本书中文翻译为了算法心得:高效算法的奥秘，而其实它与算法导论之类的算法完全是两个世界，算法导论是我们脑子里面认为的计算机算法研究，如DP，Sort，Search等，但是这些算法研究的东西没有深入到计算机内部去，…
补充一个，《自己动手写操作系统》作者：于渊。适合初学者，懂点汇编，懂点C，就能开始折腾。
补充一个，《自己动手写操作系统》作者：于渊。适合初学者，懂点汇编，懂点C，就能开始折腾。
这是月经问题了。&br&&br&这种问题牵涉到两个概念: &b&副作用(side effect)和顺序点(sequence point)&/b&&br&&br&对于题中的例子：i = j + k++&br&这是个C表达式，有两个方面要考虑：&br&1.&b& 表达式最终的值&/b&：即i最终被赋予的值，同时也是表达式的值&br&2. &b&副作用：&/b&这个表达式不仅运算结果有个值，而且还产生了副作用，具体地说，有&b&两个副作用：&/b&一个是k这个内存对象的值被自增了，另一个是i这个内存对象的值也被改变了。&br&&br&假设初始值：k==1, j==2.&br&&br&一个确定的副作用是：i最终的值是3, 这也是整个表达式(i = j + k++)的值。因为这里用的是后缀的自增符号，所以参与表达式运算的k是初始值1，题主说++的优先级比+优先级高，这是对的，但你理解有偏颇。&br&&br&&b&对于这个表达式, 我们把它替换为A + B, 即A=j, B=K++。 ++优先级高，所以，+的右端的表达式B被优先计算：k++, 但这里是后缀的自加，所以B运算的结果是k的原始值，即1, 到此时，+左右表达式都有确定值了：A=2, B=1, +&/b&&b&运算&/b&&b&可以进行，结果是3.&/b&&br&&br&&b&顺便多说一句，优先级的问题，其实可以画棵语法树来理解，比如这问题中，+作为树根，两个操作数作为两棵子树，整棵树的求值，肯定要两棵子树求值后才能完成。这也是编译器的做法，在词法解析器解析出所有的token后，编译器会内部生成相应的类似语法树，并进行优化，最后生成相应的（中间的或）最终的代码。&br&&/b&&br&至于另一个副作用，&b&k的变化是在时间顺序上是比i早，还是比i晚&/b&？这是一个未指定的行为&b&(unspecified behavior),
因为这里面不存在顺序点(sequence point), 顺序点是一个C标准里的术语，简单说，C标准规定了几种情况，在顺序点A前的表达式的副作用一定比顺序点A后的表达式的副作用先发生。&/b&&br&&b&这几种情况分别是：&/b&&br&&br&&br&&ul&&li&a && b (C99标准 §5.14)： a的运算和副作用肯定在b前面发生&/li&&li&a || b (C99标准 §5.15)： a的运算和副作用肯定在b前面发生&/li&&li&a ? b : c (C99标准 §5.16)： a的运算和副作用肯定在b前面发生&/li&&li&a , b (C99标准 $5.18)： 逗号运算符, a的运算和副作用肯定在b前面发生&/li&&li&函数调用，参数的运算和副作用一定在函数体内的第一条语句前发生&/li&&li&一个完整的表达式（它不是其他表达式的一部分）完成时(以分号分隔），标示着一个顺序点&/li&&li&紧临着函数体结束前(关闭括号}），这也标示一个顺序点&/li&&/ul&C标准就规定了这几种顺序点，其它的未定义，那是给予编译器优化的自由。&br&&br&所以，这个例子里，i先变还是k先变，是未指定的，事实哪种顺序都可以，这得看实际的编译代码。&br&&br&===&br&P.S. 个人觉得这种问题去stackoverflow上问最合适（事实这个问题不用问，已经有人问过类似问题了），比如这个问题：&a href=&/questions/4176328/undefined-behavior-and-sequence-points& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Undefined Behavior and Sequence Points&i class=&icon-external&&&/i&&/a&, 这个问题的所有答案现在都是community wiki， 答案参与者中包括C/C++标准委员会的成员，所以答案的准确性，权威性不用怀疑，可以看成是对标准的通俗化解读，建议题主仔细阅读。
这是月经问题了。这种问题牵涉到两个概念: 副作用(side effect)和顺序点(sequence point)对于题中的例子：i = j + k++这是个C表达式，有两个方面要考虑：1. 表达式最终的值：即i最终被赋予的值，同时也是表达式的值2. 副作用：这个表达式不仅运算结果有个值…
1.数据的读取形式和存储形式无关，存储时都是内存中的连续段，不存在读写效率的问题。&br&2.由于在数学发展过程史中向量默认均指列向量，这样设计可以直接服务已有知识体系，比如&img src=&/equation?tex=a%5E%7BT%7Da+& alt=&a^{T}a & eeimg=&1&&是向量的内积，若用MATLAB写就是a'*a，不存在新的学习成本。
1.数据的读取形式和存储形式无关，存储时都是内存中的连续段，不存在读写效率的问题。2.由于在数学发展过程史中向量默认均指列向量，这样设计可以直接服务已有知识体系，比如a^{T}a 是向量的内积，若用MATLAB写就是a'*a，不存在新的学习成本。
gcc -S -o a.s a.c
gcc -S -o a.s a.c