看了很多值类型 和 引用类型的文章（谷歌能搜索出来的）
看了越多疑问越大，而这些资料中没有具体的说明。
问题：
1、堆栈 和 堆 分别存于计算机的哪个硬件（CPU缓存，内存，硬盘）？
2、为什么只有值类型和引用类型？
3、为什么说引用类型是指针？
4、堆栈必堆小小多少？
以下是个人的分析，不是权威结果。
1、堆栈 和 堆 分别存于计算机的哪个硬件（CPU缓存，内存，硬盘）？
使用排除法来看这个问题
（1）CPU缓存
（2）内存
（3）硬盘
（3）可以排除堆栈的可能，因为 硬盘最慢
（2）最有可能存堆栈，因为 速度适中，且相对来说存储空间足够大
（1）可能性很小，应为仅几年来CPU的缓存越来越大 但目前家用级别的CPU的1，2，3级缓存很少超过10MB（多核情况下每个核心分到的更少）；
真像可能就是堆栈和堆都是放在内存里的。
那么为什么堆栈比堆快呢？
个人认为这情况和hashtable与list等数据容器的差异，差不多。
存取方式决定的。
堆栈：只能存取值类型，且先进先出，不够的时候直接压栈（就像"向右看起"的命令一样） --简单快捷
堆：首先，堆的分配模式会存在碎片，并不是连续性的(这里直的是多个对象，找到一个适合的内存空间就把对象放进去，就像家居摆放物件一样，有时候不贴个纸条的话，得找半天)。
2、为什么只有值类型和引用类型？
这个我觉得追溯到本源比较好解释，就是CPU只能进行数学计算。（看下汇编代码会好理解些）
值类型：就是数字，CPU可以直接进行运算。
引用类型：最终指向值类型的指针。object是指针，object的ToString的函数还是一个指针，ToString内有String类型还是指针，最终指向一个Char[] 字符集合
（注，我对String的理解就是Char[]）。
所以对象无法直接进行运算，只能通过指针找到能运算的部分，再进行运算。这也就是为啥只有2个类型了，一个是值用于运算，一个是指针，指向需要运算的地方。
3、为什么说引用类型是指针？
由上可知，引用类型是指针必然性。
一个Class内除了Int32等 值类型外其他皆是指针，委托，函数，函数内的对象，属性，事件 都是指针。
根据这种特性，指针（引用类型）作为参数传递，出来的时候会根据函数内的改变而改变，而值要作为参数输入并输出的话就要ref了。
（注： 个人发现 DateTime 作为参数时具有值类型的特征）
4、堆栈必堆小小多少？
未知，希望有知道的朋友能给出测试方法或者结果
我的推测是既然是在内存，必然没有限制，除非人为的限制
我使用线程测试内存上限时发现没有具体的上限。我的是64位+8G内存的笔记本以下是测试结果：（线程内分别创建class和sturct）
X86: 一个应用程序只能达到1300多一点的线程，再也上不去了，提交内存约1440k
class:运行稳定。sturct：大约2分钟 内存溢出
X64：一个应用程序只能达到8000多的线程，提交内存约10000k（还能继续）
class:运行稳定。sturct：行稳定
最终 我的结论：在C#里class 和sturct 如果真的是一个分配在堆，一个分配在堆栈，那么堆栈和堆的空间大小没有区别，只存在速度的区别
以下是测试代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
for (var i = 0; i < 10000; i++)
{
Thread th = new Thread(() =>
{
abc a = new abc(1);
});
th.Start();
}
Console.ReadKey();
}
}
struct abc
{
public abc(Int32 x)
{
ds = String.Empty;
Test();
}
String ds;
private void Test()
{
while (true)
{
ds += "A";
Thread.Sleep(1000);
}
}
}
class bc
{
public bc(Int32 x)
{
ds = String.Empty;
Test();
}
String ds;
private void Test()
{
while (true)
{
ds += "A";
Thread.Sleep(1000);
}
}
}
}
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
for (var i = 0; i < 10000; i++)
{
Thread th = new Thread(() =>
{
abc a = new abc(1);
});
th.Start();
}
Console.ReadKey();
}
}
struct abc
{
public abc(Int32 x)
{
ds = String.Empty;
Test();
}
String ds;
private void Test()
{
while (true)
{
ds += "A";
Thread.Sleep(1000);
}
}
}
class bc
{
public bc(Int32 x)
{
ds = String.Empty;
Test();
}
String ds;
private void Test()
{
while (true)
{
ds += "A";
Thread.Sleep(1000);
}
}
}
}
IL：
class 的
// 代码大小 28 (0x1c)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void [mscorlib]System.Object::.ctor()
IL_0006: nop
IL_0007: nop
IL_0008: ldarg.0
IL_0009: ldsfld string [mscorlib]System.String::Empty
IL_000e: stfld string ConsoleApplication1.bc::ds
IL_0013: ldarg.0
IL_0014: call instance void ConsoleApplication1.bc::Test()
IL_0019: nop
IL_001a: nop
IL_001b: ret
} // end of method bc::.ctor sturct 的
// 代码大小 20 (0x14)
.maxstack 8
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldsfld string [mscorlib]System.String::Empty
IL_0007: stfld string ConsoleApplication1.abc::ds
IL_000c: ldarg.0
IL_000d: call instance void ConsoleApplication1.abc::Test()
IL_0012: nop
IL_0013: ret
} // end of method abc::.ctor 堆栈容量测试：
using System; using System.Threading; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { String txt = System.IO.File.ReadAllText("demo.txt");//一个3.11MB的文本 Thread th = new Thread(() => { abc a = new abc(1); for (var i = 0; i < 1000; i++) { a.ds += txt; } }); th.Start(); Console.ReadKey(); } } struct abc { public abc(Int32 x) { ds = String.Empty; } public String ds; } }
测试结果：X64 能 提交内存3000K以上
我的结论和想法是这样的：
首先我是站在CPU的角度去思考的。
1、堆栈 堆 可能都是一样的指针，他们本身只是数据容器。
2、他们的区别在于存取方式不一致导致的存取速度不一样。
3、堆栈 和堆 没有具体大小，除非人为设置，且很有可能由CLR或者编译器动态选择数据容器。（毕竟我只能看到IL，看不到先X86反编译汇编）
4、值类型传参实为传值，引用类型传参实为传地址（指针），这也是堆栈和堆数据使用上的区别。CPU对堆栈的态度是拿来就用，对堆就是找到再用。