C++ const关键字的使用知识点总结

const的使用

const声明一个常量

在C++中，有变量和常量之分，常量在程序运行中不允许被改变，主要有两种声明方式。

1. const关键字

    const double PI=10；//声明了一个PI常量,并定义为10

1. #define 关键字

    #define PI 3.1415  //声明了一个PI常量,并定义为10

由于const声明的常量是有类型的，而#define没有，所以const更利于编译器的安全检查，另外const有节约内存空间等好处。所以在声明常量上，const要比#define好用。

const修饰指针

1. const int *p;

   表示指向常量的指针，意思是不能指针来改变变量的值，但是变量本身可以随便改变自己的值。另外也可以改变p的指向

   如下代码：

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    int b = 20;
    const int *p1;//const在类型前，称为指向常量的指针，即不能通过指针改变其所指向的变量的值。
    int *p2;
    p1 = &a;
    p2 = &b;
    *p1 = 30;//不可以，注意，该语句存在语法错误的，并不能通过编译，即不能通过指针改变其所指向的变量的值。
    *p2 = 40;//而相反，该语句的指针并未加const，可以修改变量的值。
    a = 30;//可以，变量本身可以随便改变自己的值。
    p1 = &b;//可以， 可以改变p的指向
    system("pause");
    return 0;
}

2.int const *p=&a;
表示常量指针，意思是指针p本身是一个常量，不能改变P的指向，可以通过*p改变指向变量a的值。通俗一点就是p比较专一，只能指向变量a，以后不能更改。另外该语句使用时，生命和定义必须一起，如int const *p；是错误的。

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    int b = 20;
    int* const p1=&a;//声明常量指针，注意，与const声明普通的常量一样，该语句必须在声明的时候定义。
    int *p2;
    p2 = &b;
    *p1 = 30;//可以，通过指针改变变量的值
    *p2 = 40;//该语句的指针并未加const，可以修改变量的值。
    a = 30;//可以，变量本身可以随便改变自己的值。
    p1 = &b;//错误，不可以改变p的指向
    system("pause");
    return 0;
}

3.const int * const p=&a
定义指向常量的常量指针。功即不能改变p的指向，也不能通过*p改变所指向的变量的值。

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    int b = 20;
    const int* const p1 = &a;//声明常量指针，注意，与const声明普通的常量一样，该语句必须在声明的时候定义。
    int *p2;
    p2 = &b;
    //*p1 = 30;//不可以通过指针改变变量的值
    *p2 = 40;//该语句的指针并未加const，可以修改变量的值。
    a = 30;//可以，变量本身可以随便改变自己的值。
    //p1 = &b;//错误，不可以改变p的指向
    system("pause");
    return 0;
}

const在函数中的应用

coust修饰函数参数

1.void function(const int Var);修饰普通参数，表示形参在函数中不能被修改。

#include<iostream>
using namespace std;

int max(const int a, int b)
{
    a++;//错误，不能修改形参a的值。
    b++;//可以修改b的值
    return (a > b) ? a : b;
}
int main()
{
    int a = 10;
    int b = 20;
    int c = max(a, b);

    system("pause");
    return 0;
}

2.void function(const int* Var);参数指针所指内容为常量不可变，即在子函数中，不能通过指针改变所指向变量的值，和 const int *p;有些类似。

#include<iostream>
using namespace std;
int max(const int *temp1, int *temp2)
{   
    *temp1 = 30;//错误，不能通过指针修改形参a的值。
    *temp2 = 40;//可以修改b的值
    int c =50；
    temp1=&c;//可以改变指针的指向。
    return (*a > *b) ? (*a) : *b;
}
int main()
{
    int a = 10;
    int b = 20;
    int *p1 = &a, *p2 = &b;
    int c = max(p1, p2);

    system("pause");
    return 0;
}

3.void function( int* const Var);参数指针本身为常量不可变，不可以改变指针的指向，但可以通过指针改变变量的值。与上面那个相反。

#include<iostream>
using namespace std;

int max( int * const a, int *b)
{


    *a = 30;//可以修改形参a的值。
    *b = 40;
    int c = 50;
    a= &c;  //不可以修改a的指向。
    return (*a > *b) ? (*a) : *b;
}
int main()
{
    int a = 10;
    int b = 20;
    int *p1 = &a, *p2 = &b;
    int c = max(p1, p2);
    system("pause");
    return 0;
}

类中使用const

1.const 成员函数

任何不会修改类的成员变量的函数应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提高程序的健壮性。以下程序中，类stack 的成员函数GetCount 仅用于计数，从逻辑上讲GetCount 应当为const 函数，编译器将指出GetCount 函数中的错误。

class Stack
{
public:
void Push(int elem);
int Pop(void);
int GetCount(void) const; // const 成员函数,const 关键字只能放在函数声明的尾部
private:
int m_num;
int m_data[100];
};
int Stack::GetCount(void) const
{
++ m_num; // 编译错误，企图修改成员数据m_num
Pop(); // 编译错误，企图调用非const 函数
return m_num;
}

2.关于Const函数的几点规则：

a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.

b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.

c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.

e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的

3.const修饰成员变量

const修饰类的成员函数，表示成员常量，不能被修改，同时它只能在初始化列表中赋值。

class Stack
  {
public:
    void Push(int elem);
    int Pop(void);
    int GetCount(void) const; // const 成员函数

    Stack(int a)
    {   
        m_num = a;//错误的幅值方式
    }
    Stack(int a) :m_num(a);//只能这样，通过初始化列表幅值。

private:
    const int m_num;//生命成员变量，并且成员变量不能被修改。
    int m_data[100];
};

4.const修饰类对象，对象指针，对象引用

a.const修饰类对象表示该对象为常量对象，其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。

b.const修饰的对象，该对象的任何非const成员函数都不能被调用，因为任何非const成员函数会有修改成员变量的企图。

#include<iostream>
using namespace std;
class Stack
{
public:
    void Push(int elem);
    int Pop();

    int GetCount() const; // const 成员函数

    Stack(int a) :m_num(a);//只能这样，通过初始化列表幅值。

private:
    const int m_num;//生命成员变量，并且成员变量不能被修改。
    int m_data[100];
};

int main()
{
const Stack test(2);
test.Pop();//错误，不能调用非const函数
test.GetCount();//正确，可以调用const函数。
const Stack *test2 = new Stack(2);
test2->Pop();//错误
test2->GetCount();//正确
}

备注：以上代码的编译环境为vs2015+win10；