总结函数的参数，指针参数及const修饰的情况

void testn(int n)
{
 n = 0; //正确，但外部n值未变，小心逻辑错误
}

void testn(const int n)
{
 n = 0; //编译错误，加const可以防止逻辑错误
}

void testn(int* n)
{
 n = new int(3); //正确，但外部指针 n值未变，小心逻辑错误
 *n = 0;   //正确，n指向变量 的值被改变
}

void testn(int* const n)
{
 n = new int(3); //编译错误，n是常量指针，加const可以防止逻辑错误
 *n = 0;   //正确，n指向变量值被改变
}

void testn(const int*  n)
{
 n = new int(3); //正确，但外部指针n值未变，小心逻辑错误
 *n = 0;   //编译错误，加const可以防止指针指向的变量值被改变
}

void testn(int**  ppn)
{
 *ppn = new int[3];  //正确，ppn指向的指针值被改变
 **ppn = 6;    //正确，ppn指向的最终变量值被改变
 *ppn[0] = 7;   //正确，ppn指向的最终变量值被改变

 ppn = new int*[3];  //正确，但外部二级指针ppn值未变，小心逻辑错误
 ppn[0] = new int(5); //正确，但外部二级指针ppn值未变，小心逻辑错误
}

void testn(int**  const ppn)

　　 {

　　  *ppn = new int[3];  //正确，二级指针ppn值被改变
 **ppn = 6;    //正确，ppn指向的最终变量值被改变
 *ppn[0] = 7;   //正确，ppn指向的最终变量值被改变

 //ppn[0] = new int(5); //正确，同*ppn
 //ppn = new int*[3]; //编译错误，ppn是常量二级指针加const可以防止逻辑错误
}

void testn( int* const*  ppn)
{
 //*ppn = new int[3]; //编译错误，ppn的值为常量指针，不能改变*ppn的值
 **ppn = 6;    //正确，二级指针指向的最终变量值被改变
 *ppn[0] = 7;   //正确，二级指针指向的最终变量值被改变

 ppn = new int*[3];  //正确，但外部二级指针ppn值未变，小心逻辑错误
 ppn[0] = new int(5); //编译错误，不能改变*ppn的值
}

void testn( int const**  ppn) //同testn(const int **  ppn)
{
 *ppn = new int[3];  //正确，二级指针ppn指向的指针值被改变
 //**ppn = 6;   //编译错误，不能改变**ppn的值
 //*ppn[0] = 7;   //编译错误，*ppn[0] = **ppn

 //ppn = new int*[3]; //编译错误，'int **' 到 'const int **' 转换错误 
}

//总结：函数 参数为传值方式时，加const可以防止逻辑错误
//函数参数为传址方式时，加const可以防止参数数据被改变
//当参数为多级指针时，看const修饰对象 可以看const与变量名之间的*
//当const与变量之间没有*时，修饰的就是多级指针本身
//当const与变量之间有一个*时，修饰的是多级指针的值
//如此推算直到修饰最后的变量值，所以const放在变量类型前后效果相同

 

http://www.dnbcw.com/biancheng/zhizhen/elff57413.html