C/C++赋值中的退化规则

在赋值过程中

1、const属性可能会丢失。

const int a = 3; 既可以 int b =a ; 或者 const int b = a.  b本身就只是a的一个拷贝，只是一个副本，并不能通过b来访问a。

2、数组会退化为指向首元素的指针。（在数组作为一个值进行拷贝，或者进行算术运算时）

char a[] = "abcde";  char *p = a;  a的类型是 char [6], p的类型是 char *，虽然类型不同，但可以进行赋值； 但是反过来就不行。

作为函数参数的数组 void func(char a[6]); 此处a彻头彻尾的就是一个指针，可在函数体类通过typeid(a).name()或者sizeof(a)来查看。

#include <iostream>
#include <typeinfo>using  namespace std;void g(char a[6])
{ cout << a << "   " << sizeof(a) << "  " << typeid(a).name() << endl;
}int main()
{cout << sizeof(&g) << endl;    //非法，函数没有类型  //cout << sizeof(g) << endl;    char *p = "hello world!";    g(p);    getchar();    return 0;
}

输出结果如下：

实际上，此处的6可用可无，和 void g(char *a)是完全相同的。不仅在赋值过程中，数组参与算术运算时，也会退化为指针。对于char a[6]； a+1的类型为char *.

数组退化为指针后，会丢失第一维的维度信息。

C/C++中的数组名除了在三种情况下，在表达式中都会退化为一个指针常量，丢失第一维信息。见《C和指针》中总结的两种情况：对于数组char a[6]，1、sizeof运算符作用于数组时  sizeof(a)，返回的是整个数组的大小6；2、取地址运算符作用于数组时&a时，得到的是一个数组指针char (*)[6]，维度信息仍然还在。另外在C++还有两种，一是C++中的数组引用,char (&re)[6] = a;二是C++11中的decltype。当然使用typeid()，typedef和using定义类型别名。

二维数组其实是数组的数组，所以二维数组退化之后，是数组指针。

上图将指针分为三种情形：1、指向变量的指针 2、指向数组首元素的指针（注意是一维数组，二维数组的首元素是一维数组）3、指向数组的指针

对于第一中情况p指向一个普通指针变量，不能够随便的改写p[1],p[2]，因为发生了越界。

第二种情况中，p是指向数组首元素的指针，由于数组元素的类型是char *,所以p的类型是char**，此时可以改写p[1],p[2]

第三种情况，p是指向数组的指针，即p是数组指针。

对于char str[] = "hello world" ; &str的类型是 char (*)[13]  ,是个指针，数组指针；不能直接付给一个 char **p的二级指针，于是，可以先 char *ptr = str;  丢掉了数组的维度信息，然后再 char **p = &ptr.注意此时p[1][x] 发生了越界，如不指向数组或者数组的首元素，p[n>1]都发生了越界。

这里需要再说说C++中从C中继承过来的这种内置数组，其行为与类对象不同。既不能使用 = 来拷贝和赋值， 也不能记忆本身以存储的元素的个数，而且对索引是否越界也不检查，所以推荐使用vector。

3、函数会退化为函数指针。

对于void (*pf)(char*) = g,  或者void (*pf)(char*) = &g; 都可以。

调用的时候，可以pf(...)或者(*pf)(...)  , 但是绝对不可以是pf[0](...)。编译之后，函数体的二进制代码存放在代码段，是类型数据，区别于普通的值数据。函数指针指向这块代码地址。sizeof操作符就不能使用在g上，对于那个恒等式，a[i] ==*(a+i)，编译器碰到a[i] 都是按 *(a+i)来解析的（所以a[i] == i[a]），pf[0]按*(pf+0)算术运算是不可以的，类型数据不支持 “+” 运算符。

^--^第三点后半部分只是我自己的解释，不保证是正确的。哈哈。

要保证传递的过程中，类型信息不丢失，有个办法，那就是传引用。数组的引用  char a[6]; char (&ref)[6] = a; 函数的引用 void g()； void (&refg)() = g. 当然，在C++中，还可以对指针进行引用。 char *p ;  char *(&refp) = p.

在引用传递的过程中，(需要说的是，函数调用的时候的形实结合，实际上就是个赋值的过程。)

若实参数是const 的，形参必须也是const的；同样的还有指针传递时，实参是常量指针，形参也必须是常量指针（或其引用）。const char c; 只能const char & rc = c;(char & rc= c不行)。 const char *p; 只能const char *r = p.  注意是常量指针，对于const char * const p = "hello world！"； 可以const char *r = p  也可以const int * const r = p. 表示指针不能改变指向的这个常量可以丢失，通过指针来修改所指向的数据那个红色const不能丢.详情可以参考effective modern C++中关于编译器的类型推导部分。

以下代码来自effective modern C++中的item4.

template<typename T> // template function to
void f(const T& param); // be called
std::vector<Widget> createVec(); // factory function
const auto vw = createVec(); // init vw w/factory return
if (!vw.empty()) {f(&vw[0]); // call f…
}

一般的，[]运算符作用在以T为元素的容器上时返回类型为T&。 vw的类型是const vector<Widget>, 所以&vw[0] 的类型是const Widget *，实参数是常量指针，形参必须也是常量指针（或其引用）；另外形参param的类型已经是T类型的常量引用const T& , 所以，vw的最终类型推导出来是const Widget * const & ， 即常量指针的常量引用。意即不能通过引用修改引用所指的指针的值（红色const），也不能通过引用修改指针所指向的Widget对象（蓝色const）。

顺便一提C++中引用这指针的区别：不能有空引用，即引用变量定义时一定要初始化，而且一旦初始化之后，不能解除绑定，意即引用变量会永远指向给其初始化的那个对象(所以，没有引用常量这么一说)。

最后，对于绑定到临时对象上的引用，会增加临时变量的声明周期，在该引用变量存在的时候，该临时变量也是存在的而不会消亡。