const修饰符、const与指针一起使用(C++学习笔记 6)

一、 在C++中使用const修饰符来定义常量。(const来自单词constant,是常量的意思)

用法:const 类型 常量名 = 表达式;
例如:const int LIMIT = 100;

这个常量LIMIT是有类型的,占用存储单元,有地址,可以用指针指向它,但不能修改它。

二、对应C中的#define,在C中,习惯使用#define来定义常量

例如:#define LIMIT 100

这种方法只是在预编译时进行字符置换,把程序中出现的标识符LIMIT全部置换为100,在预编译之后,程序中不再有LIMIT这个标识符。LIMIT不是变量,没有类型,不占用存储单元,而且容易出错。

三、const的作用与#define相似,但它消除了#define的不安全性。

例子1: 使用#define的不安全性

#include
void main(){
        int a=1;
        #define T1 a+a
        #define T2 T1-T1
        printf("T2 is:%d",T2);
}

程序按理说应该打印出 : T2 is:0
但是程序的实际输出是:
const修饰符、const与指针一起使用(C++学习笔记 6)_第1张图片
原因是:
程序把 printf(“T2 is:%d”,T2); 这个句子看做是 printf(“T2 is:%d”,a+a-a+a);

如果程序中用const取代了#define,将不会引起这个错误。如下面的例子:

例子2: 用const取代#define。

#include
using namespace std;

int main(){
        int a=1;
        const int T1=a+a;
        const int T2=T1-T1;
        cout<<"T2 is :"<<T2<<endl;
        return 0;
}

程序的运行结果:
const修饰符、const与指针一起使用(C++学习笔记 6)_第2张图片

四、const与指针一起使用

它们的组合情况较复杂,可归纳为3种:指向常量的指针、常指针、指向常量的常指针。

  1. 指向常量的指针(例:const int *pi = &i;)

    “指向常量的指针” 是指一个指向常量的指针变量,我们不能通过该指针修改它所指向的东西。例如:

const int *pi = &i;   //声明指向常量的指针
这个语句的含义是:声明一个名为pi的指针变量,它指向一个整型常量,初始化pi为指向i。

由于使用了const,不允许改变指针所指地址中的常量(但是可改变地址),例如:

#include
using namespace std;

int main(){
        int i=1;
        const int *pi=&i;
        cout<<*pi<<endl;//输出1
        i=2;
        cout<<*pi<<endl;//输出2
        //*pi=3;     //这样修改会出错
        //cout<<*pi<
        return 0;
}

例如, 声明一个名为name的指针变量,它指向一个字符型常量,初始化name为指向字符串“chen”。

const char *name="chen";     //声明指向常量的指针 

下面的语句是错误的:(不允许改变指针所指地址中的常量)

name[3]='a';

下面的语句是允许的:(可改变指针所指的地址)

name="zhang";   
  1. 常指针(例:int *const pi=&i)
    “常指针” 是指把指针所指的地址,而不是它指向的对象声明为常量,不可以改变指针所指的地址,例如:
int *const pi = &i;  //常指针
这个语句的含义是:声明一个名为name的指针变量,该指针是指向字符型数据的常指针,用"chen"的地址初始化该常指针。

创建一个常指针,就是创建一个不能移动的固定指针,即不能改变指针所指的地址,但是它所指地址中的数据可以改变,例如:

#include
using namespace std;

int main(){
        int i1=30;
        int i2=40;
        int *const pi=&i1;
        //pi=&i2;  
        //这里会出错,不能再重新给pi赋值了,即不能再指向另一个地址了
        cout<<*pi<<endl; //输出30
        i1=60;
        cout<<*pi<<endl;//输出60
        *pi=90;
        cout<<"i1的值为:"<<i1<<" "<<"pi中存储的值为:"<<*pi;
        return 0;
}

例如, 声明一个名为name的指针变量,该指针是指向字符型数据的常指针,用“chen”的地址初始化该常指针。

char *const name="chen";

例如,

Name[3]='a';    //合法,可改变指针所指的数据
name="zhang";     //出错,不能改变指针所指向的地址
  1. 指向常量的常指针(例:int const *const pi = &i1;)
    “指向常量的常指针” 既不可以通过该指针修改它所指向地址中的数据,也不可以改变该指针所指的地址。
#include
using namespace std;
int main(){
        int i1=30;
        int i2=40;
        int const *const p = &i1;
        cout<<"*p的值为:"<<*p<<endl<<"i1的值为:"<<i1<<endl;
        //*p=50;  不能改变该指针指向地址中的数据
        //p=&i2;   不能改变该指针所指的地址
        return 0;
}

例如, 声明一个名为“name”的指针变量,它是一个指向字符型常量的常指针,用“chen”的地址初始化该指针。

const char *const name="chen";

下面的语句是错误的:

Name[3]='a';   //出错,不能改变指针所指地址中的常量
name="zhang";    //出错,不能改变指针所指的地址

你可能感兴趣的:(c++,C++中const用法)