const与指针

const在C和C++中的区别

int main()
​
{
​
const int n = 10;//C语言中以变量为主。
​
int ar[n] ={1,2};// error;
​
int*p=(int*)&n;//
​
*p = 100;
​
printf("%n = %d *p=%d n",n,*p);
​
return 0;
​
}
​
int main()
​
{
​
Const int n = 10;// C++ 语言中以常量为主。
​
int ar[n] = {1,2,3,4};// ok;
​
int *p =(int *)&;
​
*p= 100;
​
cout<<"n ="<<n<<" *p="<<*p<<end1;
​
return 0;
​
}

const与指针的关系

int main()
​
{
​
int a = 10,b= 10;
​
int *p1 = &a;// 普通指针
​
const int *p2 = &a;//指向为常性（解引用为常性）
​
int const*p2 = &a;
​
int * const p3 = &a;// 指针变量自身为常性
​
const int* const p4 = &a;//指向（解引用）和指针变量自身都为常性：
​
}
​
int main()
​
{
​
int a = 0;
​
int *p1 = &a;// ok;
​
const int *p2 = &a;// ok;
​
int* const p3 = &a;// ok;
​
const int* const p4=&a;// ok;
​
return 0;
​
}
​
//编译方式不同
常变量和指针

int main()
​
{
​
const int a = 10;
​
int *p1 =&a;// error;
​
const int *p2 = &a;// ok;
​
int * const p3 = &a;// error;
​
const int* const *p4 = &a;// ok;
​
int *p5 =（int*）&a;// ok 不安全
​
return 0;
​
}

同类型指针的赋值兼容规程

int main()
​
{
int a=10,b=20;
int *p=&a;
int *s1=p;
const int *s2=p;
int *const s3=p;
const int *const s4=p;
}

总结：能力强的指针赋值给能力弱的指针

4.引用

引用定义：类型&引用变量名称=变量名称；

&与类型结合称之为引用符号，不是取地址符，代表别名

int main()
​
{
int a=10;
int b=a;//变量
int &c=a;//引用
return 0;
}

引用特点

int main()
​
{
int a=10;
int &x;//error 定义引用必须初始化
int &y=NULL;//error没有空引用
int &b=a;
int &C=b;//error //没有引用的引用、所谓的二级引用
​
}

const引用

int main()
​
{
int a=10;
const int b=20;
int &x=b;
const int &x=b;
const int &y=a;
const int &z=10;
return 0;
}
//为了安全
const int &x=b;
const int &z=10;

引用作为形参替代指针

使用指针交换两个整型值

void my_swap(int *ap,int *bp)
​
{
​
assert(ap != NULL & bp != NULL);
​
int tmp = *ap;
​
*ap = *bp;*
​
bp = tmp;
​
}
​
int main()
​
{
​
int a = 10,b = 20;
​
Cout<<"a ="<<a<<"b="<<b<<endl;
​
my_swap(&a,&b);
​
Cout<<"a ="<<a<<"b="<<b<<end1;
​
return 0;
​
}

使用引用交换两个整型值

void my_swap（int &x，int &y）//不存在NULL引用，不需要判空 ，比指针安全：
​
{
​
int tmp = x;
​
×= y;
​
y = tmp;
​
}
​
int main()
​
{
​
int a= 10,b = 20;
​
cout<<"a ="<<a<<"b="<<b<<end1;
​
my_Swap(a,b);
​
cout<<"a = "<<a<<" b ="<<b<<endl;
​
return 0;
​
}

指针与引用有什么区别？

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

程序为指针变量分配内存区域;而不为引用分配内存区域。

解引用是指针使用时要在前加"*";引用可以直接使用。

指针变量的值可以发生改变，存储不同实例的地址;引用在定义时就被初始化，之后无法改变（不能是其他实例的引用）。

指针变量的值可以为空（NULL，nullptr）;没有空引用。

指针变量作为形参时需要测试它的合法性（判空NULL）;引用不需要判空;

对指针变量使用"sizeof"得到的是指针变量的大小。对引用变量使用"sizeof"得到的是变量的大小。

理论上指针的级数没有限制;但引用只有一级。即不存在引用的引用，但可以有指针的指针。

++引用与++指针的效果不一样。例如就++操作而言，

对指针变量的操作，会使指针变量指向下一个实体（变量或对象）的地址;而不是改变所指实体（变量或对象）的内容。

对引用的操作直接反应到所引用的实体（变量或对象）。

不可以对函数中的局部变量或对象以引用或指针方式返回。

int * func_1()
​
{
int a=10;
return &a;
}
int &func_2()
{
int a=10;
return a;
}

从汇编层次理解引用与指针变量的区别

int  main()
​
{
int a=10;
int *ip=&a;
int& b=a;
*ip=100;
b=200;
return 0;
}

//汇编

 

分析效率

struct Student
​
{
​
char s_id[20];
​
char s_name[20];
​
char s_sex[8];
​
int s_age; 
​
};
​
void funa(struct Student sx)
​
{
​
}
​
void  funb(struct Student *ps)
​
{
}
​
void func(struct Student& st)
​
{
​
}
​
int main()
​
{
​
struct Student s1={};
​
funa(s1);
​
funb(&s1);
​
func(s1);
​
return 0;
​
}