一、问题
 
 c++代码：
 
 
 

  
 
 
 
#include <iostream>
#include <stdio.h>
using namespace std;
int main(){
    int a=1;
    cout<<a++<<" "<<a<<endl;//12
    a=1;
    cout<<a<<" "<<a++<<endl;//21
    a=1;
    printf("%d %d\n",a,a++);//21
    a=1;
    printf("%d %d\n",a++,a);//12
}
 
 

  
 
 
 
 java代码：
 
 
 

  
 
 
 
public class Test{
    public static void main(String[] args){
        int a=1;
        System.out.println((a++)+" "+a);//1 2
        a=1;
        System.out.println(a+" "+(a++));//1 1
    
    }
  }
 
 

  
 
 
 
  　　对比两段代码，可知JAVA代码中比较有规律（从左到右），而C中的规律呢？（向下看）
 
 C代码：
 
 
 

  
 
 
 
#include "stdafx.h"
#include <iostream>
#include <stdio.h>
using namespace std;
int a=1;
int afun(){
    printf("调用afun(){a++;}\n");
    return a++;
}
int bfun(){
    printf("调用bfun(){a;}\n");
    return a;
}
void main(){
    //printf("%d %d\n",a++,a);//12
    printf("%d %d\n",afun(),bfun());
}
 
 

  
 
 
 
 运行结果：
 
 
 
 　　注意与之前直接打印所输出的结果不同（为什么啊？？？往下看）：
 
 （1）直接打印 printf("%d %d\n",a++,a);//输出12
 
 （2）函数调用 printf("%d %d\n",afun(),bfun());//输出11
 
 二、原理（cout与printf原理一样）
 
 下面内容参考博文：http://blog.csdn.net/kzzhr/article/details/8482657
 
                          http://www.zzzj.com/html/20090609/71613.html
 
       其实，在处理printf时，压栈顺序为从右往左，也就是说从右往左的计算（“计算”不等于“输出”）。
 
 　　a++和++a的压栈的区别：在计算时，遇到x++会记录此时的x的值作为最后的输出结果。遇到x和++x的时候则不会将此时的计算结果作为最终的输出，只会修改x的值，在最终输出的时候都输出x的值（所以++x和x的结果总是一样的）。
 
  
 
       为什么会是这个样子呢？参见某高手解释吧：
 
       对于a++的结果，是有ebp寻址函数栈空间来记录中间结果的，在最后给printf压栈的时候，再从栈中把中间结果取出来；而对于++a的结果，则直接压寄存器变量，寄存器经过了所有的自增操作。
 
 三、小试牛刀
 
 
 测试：
 
 
a=1;   
printf("%d %d %d %d %d %d\n",a++, ++a, a++, ++a, a++, ++a );  

 
 
 输出：6 7 4 7 2 7
 

好好学习，天天向下
 
一、栈的存放
 
局部变量
堆中对象的引用（对象在堆内存中的 地址）
全局变量存储在堆中
局部变量存储在栈中
栈的属性：每条线程都有一个独立的栈，在线程创建时创建
 
二、栈的操作
 
栈的存取顺序是先进后出，后进先出，就像是桶装羽毛球，先放进去的后拿出来
 
public class storage {
    //先规定栈的最大容量
    Object[] objs;
    //获取当前栈容量
    int size;

    public void SQ(int MaxLen) {
        this.objs = new Object[MaxLen];
    }
    
    //进行压栈操作(就是在栈中存入内容)
    public void push(Object x) {
     //先给当前指针位置赋值,然后指针变大
        System.out.println("压栈操作,压入内容为" + (objs[size++] = x)); 
   }

    //弹栈操作
    public void popu() {
    //获取栈顶数据,然后弹出栈中,栈容量减少
        System.out.println("弹出栈顶内容:" + objs[size - 1]);
        size--;
    }

    //获取栈内所有数据
    public void getAllStack() {
        System.out.println("栈顶到栈底所有数据为");
        for (int i = size - 1; i >= 0; i--) {
            System.out.println(objs[i] + " ");
        }
    }
}
 
public class run {
    public static void main(String[] args) {
        storage storage = new storage();
        storage.SQ(20);
        storage.push(1);
        storage.push(2);
        storage.push(3);
        storage.push(4);
        storage.getAllStack();
        storage.popu();
        storage.popu();
        storage.getAllStack();
    }
}
 
三、栈和栈帧
 
java栈以帧为单位来保存线程的状态
JVM对java栈只进行两种操作——>一帧为单位的压栈和弹栈

 网上找的问题 现在贴出来应为比较常碰到
 
 
 
 
 
什么是堆和栈？ 
一个由c/C++编译的程序占用的内存分为以下几个部分 
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放 
5、程序代码区—存放函数体的二进制代码。 



函数压栈是怎么回事？ 
函数压栈的本质是参数传递 
这又跟汇编语言连系起来了.汇编语言的过程即proc可以理解成函数 
比如一个最简单的计算两数之和函数 
如果用汇编来写估计是这样的 

sub proc 
pop ax ;从stack取a 并放在AX寄存器中 
pop bx ;从stack取b 并放在BX寄存器中 
add ax,bx ; 计算a+b 
ret //返回 
sub endp 

显然要调用这个函数,你应当先把b值push进stack,然后再push a 
因为stack是先进后出的 
所以调用汇编像这样 
比如计算4+5 
push 5; 
push 4; 
call sub; //返回值在AX中 
在这个例子中先压5或先压4得到的结果没有变化 
但大多数程序,如果参数的顺序错误将是灾难性的 


因为不管什么高级语言最终都要编译成汇编语言,然后是机器语言 
同样下面这个C程序,计算a+b值,必然会编译成上面的汇编代码 
int sub(int a ,int b) {return a+b;} 
所以C在调用这个函数sub时,必须要压栈(即传入参数)但这些工作,在C语言里,并不需要你来完成.你只要写出 
sub(7,9); 
编译器在编译成汇编时就会自动完成相关的压栈工作. 

根据函数调用方式和参数压入顺序目前存在三种约定: 

stdcall 
cdecl 
fastcall 
这都相关压栈顺序和栈的清理工作约定 
他们的细节都不相同,但有一点是肯定的,参数比须从右向左压入栈中 
stdcall中 函数必须自已清理栈 
cdecall 由调用者清除堆栈 C的默认函数调用方式 所以这样C支持可变参数 
fastcall 是把函数参数列表的前三个参数放入寄存器eax,edx,ecx,其他参数压栈 

源代码: 
int function(int a, int b) 
{ 
return a + b; 
} 

void main() 
{ 
function(10, 20); 
} 

1.__cdecl 

_function 
push ebp 
mov ebp, esp 
mov eax, [ebp+8] ;参数1 
add eax, [ebp+C] ;加上参数2 
pop ebp 
retn 
_main 
push ebp 
mov ebp, esp 
push 14h ;参数 2入栈 
push 0Ah ;参数 1入栈 
call _function ;调用函数 
add esp, 8 ;修正栈 
xor eax, eax 
pop ebp 
retn 

2.__fastcall 

@function@8 
push ebp 
mov ebp, esp ;保存栈指针 
sub esp, 8 ;多了两个局部变量 
mov [ebp-8], edx ;保存参数 2 
mov [ebp-4], ecx ;保存参数 1 
mov eax, [ebp-4] ;参数 1 
add eax, [ebp-8] ;加上参数 2 
mov esp, ebp ;修正栈 
pop ebp 
retn 
_main 
push ebp 
mov ebp, esp 
mov edx, 14h ;参数 2给EDX 
mov ecx, 0Ah ;参数 1给ECX 
call @function@8 ;调用函数 
xor eax, eax 
pop ebp 
retn 

3.__stdcall 

_function@8 
push ebp 
mov ebp, esp 
mov eax, [ebp] ;参数 1 
add eax, [ebp+C] ;加上参数 2 
pop ebp 
retn 8 ;修复栈 
_main 
push ebp 
mov ebp, esp 
push 14h ;参数 2入栈 
push 0Ah ;参数 1入栈 
call _function@8 ;函数调用 
xor eax, eax 
pop ebp 
retn 

       函数调用的压栈模型对于我们学习C语言非常重要，最直观的体现在我们后面要学的函数的递归，函数的递归就充分利用的函数的压栈模型
        

        当函数从入口函数main函数开始执行时，编译器会将我们操作系统的运行状态，main函数的返回地址、main的参数、mian函数中的变量、进行依次压栈；当main函数开始调用fa()函数时，编译器此时会将main函数的运行状态进行压栈，再将fa()含糊的返回地址、fa函数的参数、fa定义变量依次压栈；当fa调用fb的时候，编译器此时会将fa函数的运行状态进行压栈，再将fb含糊的返回地址、fb函数的参数、fb定义变量依次压栈。
        

        当函数fb运行完成后，fb所有的压栈都会被编译器释放掉，编译器再从栈中接收到fa函数的运行状态后，衔接调用fb函数之前的操作，继续执行，同理，fa执行完后，编译器对mian函数的处理也相同。
        一个函数可以在栈上分配内存，也可以在堆上分配内存，更可以在全局区域分配内存，因此理解内存从哪里来，对于我们函数参数的传递，变量的调用异常重要。

        fb函数在栈上分配的内存，不能被fa和mian函数所调用，因为它会在fb函数执行完后被编译器释放掉；而 fb函数使用new或者malloc在堆上分配的内存或者在全局区分配的内存，只要不被程序员自己释放掉，是可以可以被fa和main函数所调用的。