C/C++ const

const是C语言的关键字,经C++扩充,功能变得强大,用法复杂。const用于定义一个常变量(只读变量)。当const与指针、引用、函数等结合起来使用时,情况会变得更加复杂。下面将从七个方面总结const的用法。

1.const位置

const位置较为灵活,一般来说,除了修饰一个类的成员函数外,const不会出现在一条语句的最后。示例如下:

#include <iostream>
using namespace std;

int main(int argc,char* argv[])
{
    int i=5;
    const int v1=1;
    int const v2=2;
    const int* p1;
    int const * p2;
    //以下三条语句报编译错误,为什么?
    //const * int p3;
    //int* const p3=&v1;
    //int * const p3;
    int * const p3=&i;
    const int* const p4=&v1;
    int const * const p5=&v2;
    const int & r1=v1;
    int const & r2=v2;
    //以下语句报编译错误,为什么?
    //const & int r3;
    //以下语句报警告,并忽略const
    int& const r4=i;

    cout<<*p4<<endl;
    return 0;
}

阅读以上程序,得出如下结论: (1)程序输出结果是1,以上程序演示const的位置与它的语义之间的关系,看似复杂,实际有规律可循。 (2)const和数据类型结合在一起时形成所谓的“常类型”,利用常类型可申明或定义 常变量。const用来修饰类型时,既可以放在类型前面,也可以放在类型后面,如const int i和int const i是合法且等价的。用常类型申明或定义变量时,const只会出现在变量前面。 (3)const和被修饰的类型之间不能有其他标识符。 (4)int const *p和int * const p是不同的申明语句,原因是前者const修饰的是int,后者const修饰的是int*。前者表示指针p指向整型常变量(指针所指单元的内容不允许修改),而指针本身可以指向其他的常变量,即p为指向常量的指针——常量指针。后者表示指针p本身的值不可修改,一旦p指向某个整型变量之后就不能指向其他的变量,即p是个指针常量。 (5)引用本身可以理解为指针常量,在引用前使用const没有意义。上例中int & const r4=I;中const是多余的。即没有引用常量的说法,只有常引用。常引用指被引用对象是一个常量,不允许通过引用和修改被引用对象的值。 在很多情况下,为表达同一种语义,可将const放在不同的位置。但在某些情况下,const只能放在特定的位置,考查const配合二重指针的例子,代码如下:

int main(int argc,char* argv[])
{
    //const配合二重指针
    int const **p1;
    int* const * p2;
    int i=5;
    int j=6;
    const int * ptr1=&i;
    int * const ptr2=&j;
    p1=&ptr1;
    p2=&ptr2;
    cout<<**p1<< " "<<**p2<<endl;
    return 0;
}

阅读以上代码得出如下结论: (1)程序的运行结果是:5 6 (2)int const **p1和int* const * p2申明的二重指针p1和p2的含义完全不同。p1不 是指针常量,它所指向的变量的类型是int const *(指向整型常量的指针)。P2也不是指针常量,其指向的变量类型是int* const(整型指针常量)。若按p1=&ptr1和p2=&ptr2赋值,均产生编译错误。

2.const对象和对象的const成员

const定义一个基本类型的变量是不允许修改该变量的值。const修饰类的对象称为常对象,const修饰的类成员函数称为常函数。考查如下代码:

#include <iostream>
using namespace std;

class A
{
    int num;
public:
    A(){num =5;};
    void disp();
    void disp() const;
    void set(int n){num=n;};
};

void A::disp()
{
    cout<<"Another version of disp()"<<endl;
}

void A::disp() const
{
    cout<<num<<endl;
}
int main(int argc,char* argv[])
{
    A a1;
    a1.set(3);
    a1.disp();
    A const a2;
    a2.disp();
    return 0;
}

程序执行结果是:

    Another version of disp()
    5

阅读以上程序,得出如下结论: (1)常函数的申明与定义分开进行时,两边都要使用const关键字,否则发生编译错误。

(2)只有类的非静态成员函数可以被申明为常函数,原因是静态成员函数不含this指针,属于类级别的函数。其它类型的函数(如外部函数等)不能被申明为常函数。

(3)一个类的两个成员函数,如果函数的返回值类型、函数名、函数的参数列表完全相同,一个是常函数,一个是普通函数,那么它们构成重载关系。如上例中的void disp()和void disp() const。这是因为void disp()和void disp() const具有不同的签名。C++把this指针也作为参数评估的一部分,由于上面的函数被定义成class A的成员函数,那么它们最终会被看作void disp(A*)和void disp(const A*),从而构成重载。

(4)非只读对象(如a1)调用某个函数时,先寻找它的非const函数版本,如果没有找到,再调用它的const函数版本。而常对象(a2),只能调用类中定义的常函数,否则出现编译错误。

(5)存在const和非const版本的成员函数时,普通对象若想调用const函数,应该通过建立该对象的常引用或指向该对象的常指针。如上面的程序,要用对象a1调用常函数disp(),可以使用如下语句:

((const A&)a1).disp();
//或者
((const A*)&a1)->disp();

(6)非只读对象中,也可以将部分数据成员定义为常量,称为类对象的常量成员。类对象的非静态常量成员必须在构造函数中初始化,且只能借助于初始化列表,因为初始化列表才是初始化,构造函数中通过赋值运算符进行的是赋值,并非初始化。

3.const修饰函数的参数和函数的返回值

在定义函数时常用到const,主要用来修饰参数和返回值。其目的是让编译器为程序员做变量的只读性检查,以使程序更加健壮。考查如下代码:

void disp1(const int &ri)
{
    cout<<ri<<endl;
}

void disp2(const int i)
{
    cout<<i<<endl;
}

const int disp3(const int& ri)
{
    cout<<ri<<endl;
    return ri;
}

int& disp4(int& ri)
{
    cout<<ri<<endl;
    return ri;
}

const int& disp5(int& ri)
{
    cout<<ri<<endl;
    return ri;
}


int main(int argc,char* argv[])
{
    int n=5;
    disp1(n);
    disp2(n);
    disp3(n);
    disp4(n)=6;
    disp5(n);//disp5(n)=6;是错误的
    getchar();
    return 0;
}

程序运行结果是:

5
5
5
5
6

阅读以上代码得出如下结论: (1)const修饰传递调用的形参申明为常量,没有实用价值。如上例中的void disp2(cons tint i)这样的申明没有意义,因为形参i的改变并不影响实参的值。 (2)函数的返回值是值类型时,被const修饰没有意义,因为此时返回值是一个非左 值,本身就不能改变,上例中const int disp3(cons tint& ri)对返回值的const限定是多余的。 (3)const修饰值类型的形参时,不构成函数重载,如void disp(const int i)与void disp(int i)。但当const修饰非值类型(引用、指针)的形参时构成函数重载,如void disp(const int& i)与void disp(int& i)。

4.常见的对const的误解

(1)误解一:用const修改的变量值一定是不能改变的。当const修饰的局部变量存储在非只读存储器中,通过指针可间接修改。 (2)误解二:常引用或常指针,只能指向常变量,这是一个极大的误解。常引用或者常指针只能说明不能通过该引用(或者该指针)去修改被引用的对象,至于被引用对象原来是什么性质是无法由常引用(常指针)决定的。

5. 将const类型转化为非const类型

使用C++中cons_cast运算符可去除复合类型中的const或volatile属性。当大量使用const_cast是不明智的,只能说程序存在设计缺陷。使用方法见下例:

void constTest()
{
    int i;
    cout<<"please input a integer:";
    cin>>i;
    const int a=i;
    int& r=const_cast<int&>(a);//若写成int& r=a;则发生编译错误
    ++r;
    cout<<a<<endl;
}

int main(int argc,char* argv[])
{
    constTest();
    return 0;
}

程序输入5,输出6。阅读以上程序,得出如下结论: (1)const_cast运算符的语法形式是const_cast< type_id> (expression)。 (2)const_cast只能去除目标的const或者volatile属性,不能进行不同类型的转换。如下转换就是错误的:

const int A={1,2,3};
char* p=const_cast<char*>(A);//不能由const int[]转换为char*

(3)一个变量被定义为只读变量(常变量),那么它永远是常变量。cosnt_cast取消的是间接引用时的改写权限,而不能改变变量本身的const属性。 (4)利用传统的C语言中的强制类型转换也可以将const type*类型转换为type*类型,或者将const type&转换为type&类型。但是使用const_cast会更好一些,因为const_cast转换能力较弱,目的单一明确,不易出错,而C风格的强制类型转换能力太强,风险较大,故建议不要采用C风格的强制类型转换。

6.C++中的const与C中const的区别

先说一下C中const与#define的区别。#define是宏定义,定义的内容是存放在符号表中的文字常量,不能寻址。const修饰的是常变量,是可寻址的,且具有外部连接性。

在<

//const.cpp
const int a=1;

//main.cpp
#include <iostream>
using namespace std; 

extern const int a;
int main(int argc,char* argv[])
{
    cout<<"b:"<<b<<endl;
}

上面的这段代码在VS2010是不能编译通过的,提示错误如下:

error LNK2001: 无法解析的外部符号 "int const a" (?a@@3HB)

但是将后两个源文件缀名改为.c,采用C语言的编译器编译的话,就可以通过。<<C++编程思想>>中还提到,通常C++编译器并不为const变量创建存储空间,相反它把这个定义保存在它的符号表里,除非像extern const int a;使用extern进行定义(另外一些情况,如取一个const地址),那么C++编译器会为const变量分配存储空间。这是因为extern意味着变量具有外部连接,因此必须分配存储空间,也就说会有多个不同的编译单元引用它,所以它必须有存储空间来提供寻址的能力。

这里需要注意,通常情况下,extern不是定义变量的一部分,常用于申明,不会分配存储空间。但是如果在定义const变量时使用extern,那么说明该const变量具有外部连接性,促使C++编译器为const变量分配存储空间,看来extern与const结合时的用法很是耐人寻味啊。

此外,还需要注意的是为什么使用const定义变量时,C++编译器并不为const变量创建存储空间,相反把这个定义保存在的符号表里。那是因为编译时会进行常量折叠。常量折叠是其中一种被很多现代编译器使用的编译器优化技术,在编译时简化常量表达式的一个过程。简单来说就是将常量表达式计算求值,并用求得的值来替换表达式,放入常量表,可以算作一种编译优化。

7.extern const使用注意事项

如果在同一个源文件定义const变量,使用extern const去前置申明它时,会发生什么情况,考察如下代码:

//main.cpp
#include <iostream>
using namespace std; 

extern const int a;
int main(int argc,char* argv[])
{
    cout<<"a:"<<a<<endl;
}
const int a=8;

这段代码编译不通过,报如下错误:

1>main.obj : error LNK2001: 无法解析的外部符号 "int const a" (?a@@3HB)

这时,在定义const int a=8前面加上extern即可,看来,extern const申明和定义变量时需成对出现。 如果使用extern const来前置申明一个不具有外部连接性的const变量,是会报错的,因为使用extern申明变量的前提条件是变量具有外部连接性。


参考文献

[1]陈刚.C++高级进阶教程[M].武汉:武汉大学出版社,2008. [2]C++编程思想.机械工业出版社.2015 [3]常量折叠.百度百科

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • C++临时变量的常量性

    在Linux环境使用g++编译,会出现: invalid initialization of non-const reference of type ‘std:...

    Dabelv
  • Golang 变量申明方式

    Golang 申明变量主要有三种方式: 一是使用 var 关键字,申明包级或函数级变量; 二是使用短变量申明方式,只能申明函数级变量,且需指明变量值; 三...

    Dabelv
  • 临时变量作为非const的引用进行参数传递引发的编译错误

    Linux环境运行,使用g++编译,观察如下代码,会出现: invalid initialization of non-const reference of t...

    Dabelv
  • 【ES6基础】const介绍

    在ES6之前,JavaScript被其他编程语言诟病没有定义常量的能力,甚至在大多数企业的开发文档中,对于常量的定义都使用var。一般经常会使用所有字母大写和下...

    前端达人
  • const 详解

    http://blog.csdn.net/hackbuteer1/article/details/7459212

    bear_fish
  • 初级程序员面试不靠谱指南(二)

    3.read-only的const。如果你突然冒出一句看似很高深的话但又不解释一般都是装逼,就像前面提到过const准确的应该理解为一个read-only的变量...

    一心一怿
  • QMap容器小知识

    Qt君
  • const特性总结(不断更新)

    作者:bakari  时间:2012.6.5 1、指向const对象的指针---const int *cptr; i、在此,cptr是指向int类型的const...

    CloudDeveloper
  • 学习c++中的小问题总结

    徐飞机
  • C++雾中风景3:const用法的小结

    const关键字,翻译成中文是常量,常数的意思。所以在绝大多数场合之中,const是来定义常量的,定义常量也是好的编程习惯。在C类语言之中,定义常量通常会使用宏...

    HappenLee

扫码关注云+社区

领取腾讯云代金券