C和C++的区别之引用 "&"

引用：相当于变量的别名，对引用的操作与直接操作变量一样

void swap(int *const a, int *const b)
{

	int c = 10;
	a = &c;    //对引用的操作和对变量的操作一样

	int tmp = *a;
	*a = *b;
	*b = tmp;
}
//引用相当于变量的别名
void swap(int &a, int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

引用不允许泄漏常量的值给非常量引用

const int a = 10;
const int &p1 = a;   // ok  const int -> const int

int &p = p1;        //error const int -> int
	

标准类型产生的临时量是常量

int fun()   //标准类型产生的量是一个常量
{
	int a = 10;
	return a;
}

int main()
{
        const int &c = fun();   // ok   引用的临时量是常量
        //上面函数产生的量是一个常量 ，那么main函数中的类型是：const int -> const int
        return 0;
}

自定义类型产生的临时量是非常量

struct A       //A结构体中的量是一个常量
{
	int a;
	int b;
	int c;
};

A funa()    //自定义产生的量是一个非常量
{
	A a;
	return a;
}

int main()
{
        A &a = funa();  //  error   引用的临时量是非常量
        // 一个非常量的类型是不能和常量类型赋值的
        return 0;
}

引用必须初始化

int main()
{

	int a = 10;
	int a1 = 30;
	int *p = &a;
	int &b = a;

        int &c;      // error  引用必须初始化
	//b = a1;    //对引用的操作和对变量的操作是完全一样的
}

那么为什么对引用的操作和对变量的操作是完全一样的？

int main()
{

	int a = 10;
	int a1 = 30;
	int *p = &a;
	int &b = a;

	b = 20;//底层是一个指针   在使用地方替换成了指针的解引用
	/* 引用在底层的实现
	002E554B  mov         eax,dword ptr [b]
	002E554E  mov         dword ptr [eax],14h
	*/
	//&b(*Pb)  ===>&a

	*p = 20;指针在底层的实现
	/*
	002E5554  mov         eax,dword ptr [p]  
	002E5557  mov         dword ptr [eax],14h  
	*/
}

在C++中如何用C语言的规则编译？

extern "C"
{
	void fun();   //按C语言的规则编译此函数，
}

int main1()
{
	fun();

	return 0;
}

& 和const对函数重载的影响

& 引用单独使用不参与函数重载

bool compare(int &a,int &b)  //不能形成函数重载
{
	cout << "bool compare(int &a, int &b)" << endl;
	cout << typeid(a).name() << "  " << typeid(b).name() << endl;
	return a == b;
}

const 单独使用不参与函数重载

bool compare(const int a,const int b)  //不能形成函数重载
{
	cout << "bool compare(int a, int b)" << endl;
	cout << typeid(a).name() << "  " << typeid(b).name() << endl;
	return a == b;

const  和  &同时使用可以形成重载

bool compare(const int &a,const int &b)  //可以形成重载
{
	cout << "bool compare(const int &a,const int &b)" << endl;
	cout << typeid(a).name() << "  " << typeid(b).name() << endl;
	return a == b;
}

const 修饰指针如果修饰的内容中没有*，则不参与函数重载

void compare(const int *p1, const int *p2)  //const修饰的内容中有*，则可以形成重载
{
	cout << "bool compareint(const int *p1,const int *p2) " << endl;
	cout << typeid(p1).name() << "  " << typeid(p2).name() << endl;
}

void compare( int *const p1, int *const p2)  //const修饰的内容中没有*，则不可以形成重载
{
	cout << "bool compareint( int *const p1, int *const p2) " << endl;
	cout << typeid(p1).name() << "  " << typeid(p2).name() << endl;
}

未完待续……