C++ const修饰指针

const修饰某类型的指针

“const int * p1”,p1是指向int型的指针变量,然后再作为常量。变量的地址可以改变,但内容不能改变,类型也必须一致。
#include <iostream>
using namespace std;

int main ( )
{
    int x = 12;
    int y = 25;
    char c = 'D';

    const int * p1;

    //新分配一块int型空间,再将p1指向新空间作为常量,OK!
    p1 = new int(100);
    cout << "p1: " << *p1 << endl;
    delete p1;

    //将p1指向非int型变量作为常量,NG!
    //p1 = &c;    //类型不匹配

    //将p1指向int型变量作为常量,OK!
    p1 = &x;
    cout << "p1: " << *p1 << endl;

    //修改p1的地址,OK!
    p1 = &y;        //地址可以被修改
    cout << "p1: " << *p1 << endl;

    //修改p1指针的值,NG!
    //*p1 = 156;    //指针值不能被修改

    //通过其它变量,间接地修改p1指针的值,OK!
    y = 158;
    cout << "p1: " << *p1 << endl;

    return 0;
}
运行结果:
p1: 100
p1: 12
p1: 25
p1: 158

const修饰指针后再限定类型

“int const * p2”,p2是指针变量,然后再作为常量并限制为int类型。变量的地址可以改变,但内容不能改变,类型也必须一致。

许多书上都说,这和“const int * p1”不一样,但究竟哪儿不一样却不说明。笔者作了很多测试,认为是一样的。等将来发现有不一样之处,再来更新此页吧。
#include <iostream>
using namespace std;

int main ( )
{
    int x = 12;
    int y = 25;
    char c = 'D';

    int const * p2;

    //新分配一块int型空间,再将p2指向新空间作为常量,OK!
    p2 = new int(100);
    cout << "p2: " << *p2 << endl;
    delete p2;

    //将p2指向非int型变量作为常量,NG!
    //p2 = &c;    //类型不匹配

    //将p2指向int型变量作为常量,OK!
    p2 = &x;
    cout << "p2: " << *p2 << endl;

    //修改p2的地址,OK!
    p2 = &y;        //地址可以被修改
    cout << "p2: " << *p2 << endl;

    //修改p2指针的值,NG!
    //*p2 = 156;    //指针值不能被修改

    //通过其它变量,间接地修改p2指针的值,OK!
    y = 158;
    cout << "p2: " << *p2 << endl;

    return 0;
}
运行结果:
p2: 100
p2: 12
p2: 25
p2: 158

const修饰指针地址

“int * const p3”,p3是指针变量,其地址作为常量并指针限制为int类型。变量的地址不可以改变,但内容可以改变。定义时必须同时赋初始值。
#include <iostream>
using namespace std;

int main ( )
{
    int x = 12;
    int y = 25;

    //int * const p3;    //编译出错,初始化必须赋值
    int * const p3 = &x;

    //新分配一块int型空间,再将p3指向新空间作为常量,NG!
    //p3 = new int(100);

    //修改p3的地址,NG!
    //p3 = &y;      //地址不能被修改

    //修改p3指针的值,OK!
    *p3 = 156;      //指针值可以被修改
    cout << "p3: " << *p3 << endl;

    return 0;
}
运行结果:
p3: 156

const修饰指针并修饰地址

“const int * const p4”,这是前2种的结合,既不允许修改地址,也不允许修改内容。
#include <iostream>
using namespace std;

int main ( )
{
    int x = 12;
    int y = 25;

    //const int * const p4;    //编译出错,初始化必须赋值
    const int * const p4 = &x;

    //修改p4的地址,NG!
    //p4 = &y;      //地址不能被修改

    //修改p4指针的值,NG!
    //*p4 = 156;    //指针值不能被修改

    cout << "p4: " << *p4 << endl;

    //通过其它变量,间接地修改p4指针的值,OK!
    x = 123;
    cout << "p4: " << *p4 << endl;

    return 0;
}
运行结果:
p4: 12
p4: 123