c++学习5

最近看了一本《c++必知必会》整理一下看的内容

1.指针和引用的区别

   1.1不存在空引用

   1.2所有引用都要初始化

   1.3一个引用永远指向对它初始化的对象

2.一个指向非常量的引用是不可以用字面值或者临时值进行初始化的，但是一个指向常量的引用是可以的，相当于引用设置为指向一个“采用该字面值初始化”的临时位置

double &d=12.3//错误

const double & d=12.3//OK

3.数组会退化成指向其首元素的指针，丢失边界。函数形参会退化成函数指针，但可以保持其参数类型和返回类型

#include<iostream>
using namespace std;
void average(int arr[])
{
}
void average1(int (&arr)[10])//指定数组大小
{
}
void average2(int arr[],int size)//另传值指定数组大小
{
}
int main()
{
 int arr[12];int arrr[10];int arrrr[3];
 int * p=arrr;
 average(arr);//不关心边界
 average1(arrr);//关心边界值，边界值一致就正确
 //average1(arr);//会报错
 //average1(p);不能传指针，局限性
 average2(arrrr,10);
  return 0;
}

void average(int arr[10][20])  也可以声明为void average(int (*arr)[20])，边界20不能退化，否则无法对形参执行指针算术

4.常量指针和指向常量的指针

const T * p=pt;//指向常量的指针

T const * p;//指向常量的指针  因为声明中的修饰符*之前出现的任何东西顺序无关，所以也可以这样写

T * const p=pt;//常量指针，指向一个非常量对象

形式1：

T * pt=new T;

const T * pct=pt;//可以用一个非常量指针赋值给常量指针，那么两个指针指向同一块内存。常量指针不会修改指向的内存中数值。只会因为非常量指向修改值而变化。

因此常见的情形

fun(const T * p1)调用时T * a=new T;fun(a);那么相当于形式1

形式2：

const T a;

const T * p1=&a;

T * p2=p1;//报错，因为如果让常量指针赋值给非常量指针，那么非常量指针可以修改指向的内存值，因此也修改了破坏了指向常量指针的内容

解决方法const_cast

p2=const_cast<T *>(p1);

*pt=a2;//试图修改常量对象

int main()
{
//情形2
 const int * p1=new int;
 //int * p2=p1;报错
   int * p2=const_cast<int *>(p1);
//情形1
int * p3=new int;
const int * p4=p3;
printf("%d  \n",*p4);
*p3=3;
//*p4=4;修改常量值是由非常量指针修改的，被动地修改了指向常量的指针的指向内容
printf("%d  \n",*p4);
  return 0;
}

5.指针的指针

1.当函数需要改变传递给它的指针的值时候，在c++更多地是使用指向指针的引用作为函数参数

#include<iostream>
using namespace std;
void fun(int * p)
{
p=p+2;
}
void fun2(int * &p)
{
p=p+2;
}
int main()
{
int arr[5]={1,2,3,4,5};
int * p=arr;
fun(p);
printf("%d\n",*p);//仍然指向第一个元素


    fun2(p);//直接传入指针的指针，如果函数参数是指针的指针则fun2(&p)
printf("%d\n",*p);//指向第三个元素
  return 0;
}

2.适用于指针的转换不一定适用于指针的指针

Circle * c=new Circle;

Shape * s=c;//正确

Circle * *cc=&c;

Shape * *ss=cc;//错误

char * s1=0;

const char * s2=s1;//指向非常量指针赋值给指向常量的指针

char * a[100[;

const char * * s3=a;//错误，不能把指向非常量的指针的指针赋值给指向常量的指针的指针