C++编程基础二 03-const形参与实参

// C++函数和类 03-const形参与实参.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string>
#include <array>
#include <climits>
#include <math.h>
using namespace std;

int cube1(int i);
int cube2(const int i);
int pCube1(int *pi);
int pCube2(const int *pi);
int pCube3(int *const pi);
int rCube1(int &r);
int rCube2(const int &r);
int main()
{

    //一般变量来说，其实没有顶层const和底层const的区别，而只有向指针这类复合类型的基本变量，才有这样的区别。
    //如何区分顶层const和底层const?
    //1.指向常量的指针（底层const）：代表不能改变其指向内容的指针。声明时const可以放在类名前后都可以。
    //   例如：
    //int num_a = 1;
    //int const *p_a = &num_a; //底层const
    //*p_a=2; //错误，如果需要改变num_a的值，不能通过*pa来改变，只能num_a来改变值。
    //2.指针常量（顶层const）：代表指针本身是常量，声明时必须初始化。之后它储存的地址就不能再改变。声明时const必须放在*符号后面，即：*const。
    //  例如：
    //int num_b = 2;
    //int *const p_b = &num_b; //顶层const
    //p_b = &num_a; //错误，常量指针不能改变储存的地址值。
    //一个指针本身添加const限定符就是顶层const，而指针所指的对象添加const限定符就是底层const。

// 例子1：执行对象拷贝时有限制，常量的底层const不能赋值给非常量的底层const。
    int num_c = 3;
    const int *p_c = &num_c;  //p_c为底层const的指针
    //int *p_d = p_c; //错误，不能将底层const指针复制给非底层const指针。
    const int *p_d = p_c; //正确，可以将底层const指针复制给底层const指针。

//例子2：使用命名强制类型转换函数const_cast时，需要能够分辨底层const和顶层const，因为const_cast只能改变运算对象的底层const。
    int num_e = 4;
    const int *p_e = &num_e;
//    *p_e = 5; //错误，不能改变底层const指针指向的内容。
    int *p_f = const_cast<int *>(p_e);//正确，const_cast可以改变运算对象的底层const。但是使用时，一定要知道num_e不是const的类型。
    *p_f = 5; //正确，非顶层const指针可以改变指向的内容
    cout << num_e; //输出5

//练习：
    const int a = 1;
  //int * pi = &a; //错误，&a是底层const是底层const，不能赋值给非底层const
    const int *pi = &a; //正确,&a是底层const，可以赋值给底层const
    const int *const*const ppi = &pi; //即是底层const，也是顶层const
    const int *const*const*pppi = &ppi; //底层const 


//_______________________________参考__________________________________________________
    
 
    int num1 = 10;
    const int num2 = 10;
    num1 = 20;      //为int类型的变量，可以修改它的值    
    //num2 = 20; //int类型的常量，不可以修改它的值

    int *p1 = &num1; //普通指针，int类型的变量可以初始化。也可以通过*p1修改int类型值。
//    int *p2 = &num2;//出错 int类型的常量不可以初始化， 不能修改常量的值。

    //在这里const包含两层含义：
    const int *p3 = &num1; //底层const，int类型的变量和常量都可以初始化，但是不能通过*p3,*p4,去修改num1，num2的值。
    const int *p4 = &num2; //

    int *const p5 = &num1; //顶层const，int类型的变量可以初始化。
//    int *const p6 = &num2; //出错  int类型的常量不可以初始化。
     
    //int类型的引用，可以通过r1区修改num1的值，所以只能用int类型去初始化，不能用const int类型
    int &r1 = num1;
//    int &r2 = num2; //出错
//    const int 类型的引用，不能修r3,r4的值
//    可以使用int类型的数据来初始化，也可以使用const int类型
    const int &r3 = num1;
    const int &r4= num2;

//实参为int类型或const int 类型
    cout << cube1(num1) << " "<<cube1(num2) << endl;
    cout << cube2(num1) << " " << cube2(num2) << endl;

//实参只能为int类型
    cout << pCube1(&num1) << endl;
//    cout << pCube1(&num2) << endl; //出错

//    所以实参是int类型，也可以是const int类型
    cout << pCube2(&num1) << " " << pCube2(&num2) << endl;

//所以实参类型只能是int类型。
    cout << pCube3(&num1) << endl;
//    cout << pCube3(&num2) << endl; //出错

// 实参只能是int类型
    cout << rCube1(num1) << endl;
//    cout << rCube1(num2) << endl; //出错

// 实参的类型可以是int类型，也可以是const int 类型
    cout << rCube2(num1) << " " << rCube2(num2) << endl;
    return 0;

}


//可以修改形参：
int cube1(int i)
{
    //i = 0;  //错误的：
    return i * i*i;
}
//不可以修改形参i
int cube2(const int i)
{
    //i=0; //出错
    return i * i*i;
}
int pCube1(int *pi)
{
    *pi = 0;
    return *pi*(*pi)*(*pi);
}

//可以修改pi，但是不可以修改*pi.所以实参是int类型，也可以是const int类型
int pCube2(const int *pi)
{
    //*pi = 0; //错误
    return *pi*(*pi)*(*pi);
}
//不可以修改pi，但是可以修改*pi，所以实参类型只能是int类型。
int pCube3(int *const pi)
{
    *pi = 0;
    return *pi*(*pi)*(*pi);
}
//可以修改r，实参只能是int类型
int rCube1(int &r)
{
    //r = r * r*r;
    return r * r*r;
}
//不可以修改r,实参的类型可以是int类型，也可以是const int 类型
int rCube2(const int &r)
{
    //r = r * r*r; //出错
    return r * r*r;
}

//总结：
//1.int cube(int i); 实参可以为int类型，也可以为const int类型。在函数体中可以修改i的值，
//函数不会修改实参的值。
//2.int cube(const int i); 实参可以为int类型，也可以为const int类型。在函数体中不可以修改i的值，
//函数不会修改实参的值。
//3.int pCube(int *pi); 实参为int* 类型的指针，不能为const int*类型。可以通过修改*pi的值修改实参指向的对象的值，
//修改pi对实参没有影响。
//4.int pCube(const int *pi);实参可以为const int*类型，也可以为int*类型。不可以通过修改*pi的值修改实参指向的对象的值，
//修改pi对实参没有影响。
//5.int pCube(int *const pi);实参为int*类型，不能为const int*类型。可以通过修改*pi的值修改实参指向的对象的值，不可以给pi赋值。
//6.void prest(int &r);实参为int类型，不可以为const int 类型。可以通过修改r的值，从而修改实参的值。
//7.void print(const int &r);实参可以为int类型，也可以为const int类型，不可以修改r的值。