指针和引用的区别

指针和引用的区别，从语法规则上来说：

1. 从语法规则上讲，指针变量存储某个实例（变量或对象）的地址，引用是某个实例化的别名。

int main()
{
	int a = 10;
	int& b = a;
	int* ip = &a;
	*ip = 100;
	b += 20;
}

2. 程序为指针变量分配内存区域，而不为引用分配内存区域
3. 解引用是指针使用时要在前加“ * ”，引用可以直接使用
4. 指针变量的值可以发生改变，存储不同实例的地址，引用在定义时就被初始化，之后无法改变
5. 有空指针，没有空引用
6. 指针变量作为形参时需要测试它的合法性（判空），引用不需要判空，因此引用比指针要安全

int funa(int* p)
{
	if (p == NULL)
	{
		return -1;
	}
	*p += 10;
	return *p;
}
int funb(const int& a) //（int& b）
{
}
int main()
{
	int a = 10;
	funb(10);
	funb(a);
}

7. 对指针变量使用sizeof得到的是指针变量的大小， 对引用变量使用sizeof得到的是变量的大小

int main()
{
	double dx=12.25;
	double& rx=dx;
	double* dp=&dx;

	cout<<"sizeof(rx): "<<sizeof(rx)<<endl;   double类型的变量是8个字节大小
	cout<<"sizeof(dp): "<<sizeof(dp)<<endl;   x86系统4个字节
	return 0；
}

8. 理论上指针的级数没有限制：但引用只有一级。即不存在引用的引用，但可以有指针的指针。两个引用号是右值引用，而不是引用的引用。
9. 引用++是对某一个实体（变量或对象）的++，指针++，是指向下一个实体。

int main()
{
	int ar[5]{ 1,2,3,4,5 };
	int& a = ar[0];
	int* p = &ar[0];
	for (int i = 0; i < 5; ++i)
	{
		cout << ar[i] << " ";  //1 2 3 4 5
	}
	cout << endl;
	++a;
	for (int i = 0; i < 5; ++i)
	{
		cout << ar[i] << " ";//11 2 3 4 5
	}
	cout << endl;
	cout << "*p= " << *p << endl; //11
	++p;
	cout << "*p= " << *p << endl;  //2
	return 0;
}

引用和指针的相同点：
1.绝不允许把局部变量以指针的方式或者引用的方式返回
不加fun函数可以正常打印，那是应为栈回收给内存的时候，数据残留在内存中，一但调用fun函数，就会清扫，数据就没有了

int* funa()
{
	int a = 10;
	return &a;
}
int& funb()
{
	int a = 20;
	return a;//这里返回的是a的别名
}
void fun()
{
	int ar[10] = { 1 };
}
int main()
{
	int* p = funa();
	fun();
	cout << *p << endl;
	int& x = funb();
	fun();
	cout << x << endl;
	return 0;
}

如果想让变量以指针的方式或者引用的方式返回，则加静态或者全局，让变量的生存期不受函数影响

指针和引用的区别，从编译的时候说：
引用在编译的时候变成一个指针，但它不是一个普通的指针，它是自身为常性的指针

void fun(int& x)
{
	int* ip = &x;
	x = 100;
}
int main()
{
	int a = 10;
	int& b = a;
	fun(a);
	fun(b);
	return 0;
}
//换成指针
void fun(int* const x)
{
	int* ip = x;
	*x = 100;
}
int main()
{
	int a = 10;
	int* const b = &a;
	fun(&a);
	fun(b);
	return 0;
}