C++中指针和引用有两种类型：静态类型和动态类型


静态类型：指针或引用声明时的类型
动态类型：运行时实际指向的对象类型


class A
{
};


class B : public A
{


};


A *p1 = NULL;//p1的静态类型是 A*


p1 = new B; //p1的动态类型是B*


B *p2 = NULL;//p2的静态类型是B*
p2 = new B; //p2的动态类型是 B*

C#的两种数据类型：值类型，引用类型




值类型：
byte，short，int，long，float，double，decimal，char，bool 和 struct 统称为值类型。




1.
值类型变量声明后，不管是否赋值，编译器都给它分配内存。


2.
值类型的实例通常是在线程栈上分配的（静态分配），但是在某些情形下可以存储在堆中。


3.
值类型在栈内分配空间大小因变量类型而异。






引用类型：
string 和 class统称为引用类型。




1.
引用类型声明时，只在栈中分配一小片内存用于容纳一个地址，而此时并没有为其分配堆上的内存空间。



当使用 new 创建一个类的实例时，分配堆上的空间，并把堆上空间的地址保存到栈上分配的小片空间中。


2.
引用类型的对象一定是在堆空间中分配（动态分配）。


3.
引用类型在栈内的空间大小相同。



代码注解：

引用变量的两种类型：
    编译时类型（模糊一点，一般是一个父类）
    由声明时的类型决定。
    运行时类型（运行时，具体是哪个子类就是哪个子类）
    由实际对应的对象类型决定。
通过动态绑定调用该对象的方法。动态绑定会使我们的程序编写更加灵活，但是会减慢程序运行速度。这也是JAVA比C++/C慢的主要原因之一。

1.两种数据类型
我们知道，在JS中数据类型按照访问方式和存储方式的不同可分为基本类型和引用类型。
2.基本类型
基本类型有String、Boolean、Number,Undefined、Null，这些基本类型都是按值传递的，也称为值类型。
3.引用类型
引用类型有对象、数组、函数，它们都是按引用访问的。
4.两者区别
基本类型和引用类型由于两者在内存中存储的方式不同，造成两者访问的方式也不同。其中，基本类型存储在内存的栈中，是按值访问；引用类型存储在内存的堆中，是按引用访问。可如下图所示：
当有
var n1 = 10;
var n2 = 10;

var arr1 = [1,2,3,4]
var arr2 = [1,2,3,4]
其在内存中存储方式如图：

值类型是在栈中直接保存的变量的实际值，而引用类型在栈中仅仅保存的是变量指向堆中的地址，从上图中可以看出，值类型的变量n1和n2都是10，但是在栈中却为这两个变量分别开辟了两块空间来存储，而引用类型的变量arr1和arr2也相同，但是在堆中仅仅开辟了一块内存来存储，而在栈中存储的是这两个变量指向堆中的地址，这两个变量都指向堆中的同一片地址。
5.拷贝上的区别
正是由于两者在存储方式上的不同，造成了两者在拷贝时的差异。首先，先看两段代码：
var n1 = 10;
//将n1拷贝给n2
var n2 = n1;

n1 = 12;
console.log(n1);
console.log(n2);
先定义变量n1=10，然后将n1拷贝给n2，再接着改变n1的值为12，分别打印n1和n2的值，打印结果为：


从结果中我们可以看到，n1变为12了，但是n2不受影响，依旧是10。
再看另外一段代码：
var arr1 = [1,2,3,4]
//将arr1拷贝给arr2
var arr2 = arr1;
//向arr1中尾部添加一个元素5
arr1.push(5);

console.log(arr1);
console.log(arr2);
先定义数组arr1，然后将arr1拷贝给arr2，再接着向arr1中尾部追加一个元素，分别打印arr1和arr2的值，打印结果为：


从结果中我们可以看到：我们先将arr1拷贝给了arr2，但是当我们改变arr1时，arr2也跟着一起改变了。这印证了前文所说的，arr1和arr2实际上是指向了内存中的同一片地址，当arr1发生变化时，实际上是将指向的这片内存地址中的数据变化了，而arr2也指向的是这片地址，所以arr2也会跟着变化。
上面代码中的arr2=arr1，就是我们俗称的浅拷贝，浅拷贝仅仅拷贝的是变量名，其在内存的存储没有被拷贝，指向的还是同一片内存地址，这就是造成了一个变化另外一个也跟着变化，这在日常开发中不是我们想要的。
那如何实现真正的拷贝呢？
6.深拷贝

真正的拷贝，就是拷贝过后，arr1和arr2指向的不再是同一片内存地址，而是分别指向各自的地址，这样发生变化的时候就不会出现同时变化，这就是深拷贝。
下面我们封装一个深拷贝函数，来实现引用类型的深拷贝：
//参数p为原对象
//参数c为原对象的类型，若原对象为数组，则传入c为[],若原对象是对象传入c为{}，也可不传默认为{}
function deepCopy(p,c){
	var c = c || {};
	for(var i in p){
		if(typeof p[i] === "object"){
			c[i] = (p[i].constructor === Array)?[]:{};
			deepCopy(p[i],c[i])
		}else{
			c[i] = p[i]
		}
	}
	return c;
}

7.测试
//参数p为原对象
//参数c为原对象的类型，若原对象为数组，则传入c为[],若原对象是对象传入c为{}，也可不传默认为{}
function deepCopy(p,c){
	var c = c || {};
	for(var i in p){
		if(typeof p[i] === "object"){
			c[i] = (p[i].constructor === Array)?[]:{};
			deepCopy(p[i],c[i])
		}else{
			c[i] = p[i]
		}
	}
	return c;
}

//定义数组arr1
var arr1 = [1,2,3,4]
//将arr1拷贝给arr2
var arr2 = deepCopy(arr1,[]);
//向arr1中尾部添加一个元素5
arr1.push(5);
console.log('arr1:',arr1);
console.log('arr2:',arr2);

测试结果：

结果中可以看到，arr1变化没有引起arr2的变化，实现了真正的拷贝。
完。