C++进阶技巧-优快云博客

本文深入探讨了C++中的const与引用用法、指针与引用的区别、重载规则及C方式编译等内容，帮助读者掌握更高级的语言特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.实例1：const与引用的问题

#include <stdio.h>
#include <stdlib.h>

int main()
{
	const int x=1;
	int& rx=const_cast<int&>(x);//const_cast 去掉const属性
	rx = 5;
	
	printf("x=%d\n",x);   // 1
	printf("rx=%d\n",rx);  // 5
	printf("&x=%d\n",&x);  /// 指向相同的地址 
	printf("&rx=%d\n\n\n",&rx);
	//////////////////////////////
	volatile const int y=2;//volatile 不做优化
	int *p=NULL; 
	p=const_cast<int*>(&y);
	*p =6;
	printf("y=%d\n",y);   //// 6
	printf("*p=%d\n\n\n",*p);  /// 6 
	//////////////////////////////////
	const int z=y;
	p =const_cast<int*>(&z);
	*p=7;
	printf("z=%d\n",z);     /// 7 
	printf("*p=%d\n\n\n",*p);  /// 7
	///////////////////////////////////
	char c = 'c';
	char& rc=c;
	const int& trc=c;
	rc ='a';
	printf("c=%c\n",c);   //a
	printf("rc=%c\n",rc); //a
	printf("trc=%c\n",trc); //c,成为只读变量 
	return 0; 
}

什么是符号表？如何才能进入到符号表，成为真正的常量

（1）符号表是编译器编译过程中产生的数据结构

（2）volatile修饰的const常量不会进入到符号表中

如：volatile const int y =2; //不会进入符号表中

const引用的类型与初始化变量的类型

相同：使初始化变量成为只读变量

不同：生成一个新的只读变量，其初始值与初始化变量相同。

二.实例2：指针与引用

#include <stdio.h>
#include <stdlib.h>

struct SV
{
	int x;
	int y;
	int z;
};

struct SR
{
	int& x;
	int& y;
	int& z;
};

int main()
{
	SV sv={1,2,3};
	SR sr={sv.x,sv.y,sv.z};
	
	printf("&sv  =%p\n",&sv);
	printf("&sv.x=%p\n",&sv.x);
	printf("&sv.y=%p\n",&sv.y);
	printf("&sv.z=%p\n\n\n",&sv.z);
	
	printf("&sr  =%p\n",&sr);
	printf("&sr.x=%p\n",&sr.x);
	printf("&sr.y=%p\n",&sr.y);
	printf("&sr.z=^%p\n\n\n",&sr.z);
	
	SV& rsv=sv;
	rsv.x =4;
	rsv.y =5;
	rsv.z =6;
	
	printf("rsv=%d\n",sv.x);
	printf("rsv=%d\n",sv.y);
	printf("rsv=%d\n",sv.z);
	
	return 0; 
}

指针与引用的区别：

* 指针式变量，其值是一个内存地址。

* 引用只是一个变量的新名字。

* 引用必须初始化，之后无法引用其他值。

* 理解引用的本质是指针常量

三. 案例3：重载

程序1：

#include <stdio.h>
#include <stdlib.h>

void func(int a,int b)
{
	printf("void func(int a,int b)\n");
}


void func(char a,int b)
{
	printf("void func(char a,int b)\n");
}

void func(int a,char b)
{
	printf("void func(int a,char b)\n");
}

void func(char a,char b)
{
	printf("void func(char a,char b)\n");
}

int main()
{
	int a=1;
	char b='2';
	
	func(a,a);
	func(a,b);
	func(b,a);
	func(b,b);
	
	printf("\n\n\n");
	
	func(1,2);
	func(1,'2');
	func('1',2);
	func('1','2');
	
	return 0; 
}

程序2：

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

int main()
{
	printf("sizeof(\'1\')=%d\n",sizeof('1'));// 1
	printf("sizeof(2)=%d\n",sizeof(2));  // 4
	printf("sizeof(3.0)=%d\n\n\n",sizeof(3.0)); // 8
	
	char c='1';
	short s='1';
	int i='1';
	float
	long l='1';
	long long ll='1';
	
	c = 2;// c是char  
	s = 2; // s
	i = 2;
	l = 2;
	ll = 2;
	
	cout<<c<<endl;
	cout<<s<<endl;
	cout<<i<<endl;
	cout<<l<<endl;
	cout<<ll<<endl<<endl;
	
	float f = 0;
	double d = 0;
	f = 3.0;
	d = 3.0;
	cout<<f<<endl;
	cout<<d<<endl;
	return 0; 
}

说明：C++编译器对字面量的处理方式

当使用字面量对变量进行初始化或赋值时

* 无溢出产生：编译器对字面量进行默认类型转换

* 产生溢出：编译器会做出截断操作，并产生警告。

理解重载规则：

（1）精确匹配实参；

（2）通过默认类型转换匹配市实参

（3）通过默认参数匹配实参

四. C方式编译

实例：

#include <stdio.h>
#include <stdlib.h>

extern "C"
{
	void func(int x)
	{
		const int i = 1;
		int& ri =const_cast<int&>(i);
		ri = 5;
		printf("i=%d\n",i);
		printf("ri=%d\n",ri);
	}
}

void func(const char* s)
{
	printf("%s\n",s);
}

int func(int a,int b)
{
	return a+b;
}
int main()
{
	
	return 0; 
}

说明:

（1）extern“C”告诉C++编译器将其中的代码进行C方式编译

C方式编译的主要按照C语言的规则对函数名进行编译

（3）C编译器不会在编译后的函数名中加入参数信息

注意：（可以从他们的汇编代码中看出，）

extern“C”中的重载函数经过C方式编译后将得到相同的函数名，因此extern“C”中不

允许函数重载，但是extern“C”里面的函数可以与它之外的函数进行重载