const的使用

最新推荐文章于 2023-02-08 17:37:18 发布
最新推荐文章于 2023-02-08 17:37:18 发布
阅读量483 收藏 2
点赞数
分类专栏： C++语言 文章标签： const bitwise logical constness
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sanoseiichirou/article/details/50045145
版权

const的使用

《Effective C++》条款3 学习总结

1.const与指针

#include <iostream>

int main(){
    char str[]="hello world";
    char *p1(str);              //指向非常量的非常量指针   指向数据：非常量 指针：非常量
    const char *p2(str);        //指向常量的非常量指针     指向数据：常量 指针：非常量
    char const *p3(str);        //指向常量的非常量指针     指向数据：常量 指针：非常量
    char * const p4(str);       //指向非常量的常量指针     指向数据：非常量 指针：常量
    const char * const p5(str); //指向常量的常量指针       指向数据：常量 指针：常量
    return 0;
}

上面的代码看起来有点晕，有一个规律：
1.以指针的*（星号）为分界点
2.星号 左边 的const修饰的是指针所指向的数据
3.星号 右边 的const修饰的是指针本身
4.const int 和 int const 等价

2.const与类

const的一个重要作用就是：防止用户或程序员意外修改了不应该被修改的值或其他的东西。

举个例子：
我们都知道右值是不能放在等号左边被赋值的

#include <iostream>
int main(){
    int a(10),b(100),c(1110);
    (a+b)=c;  //将a与b相加，然后将c的值赋值给(a+b)的结果
    return 0;
}

错误如下：
这里写图片描述

但是如果是类，并且重载了+运算符

#include <iostream>

class demo{
public:
    demo(){}
    demo(int data_):data(data_){}
    int data=0;
    //重载+运算符
    demo operator+(const demo & other){
        return demo(this->data+other.data);
    }
};

int main(){
    demo a(10),b(100),c(1110);
    (a+b)=c;  //将a与b相加，然后将c的值赋值给(a+b)的结果
    return 0;
}

完美的编译通过了，但是（a+b）确实是右值，这不是矛盾了吗？
所以，我们可以将operator+写成

    const demo operator+(const demo & other){
        return demo(this->data+other.data);
    }

结果，编译提示错误：
这里写图片描述

当然你会说，没有人会那么变态地（a+b）后用c为之赋值。
那么下面一个例子也有足够的理由让你在从在运算符时重视const属性的添加与否。

if(a+b=c){
    //do something
}
else{
    //do something else
}

你看到端倪了吗？
if(a+b=c) ，我们都有粗心的时候，加上const就不会为这种低级错误抓耳挠腮了。当然如果你有足够的自信不会把==写成=，那么加不加const也没有什么区别。

3.const成员函数

const用于成员函数的方式可以是下面的这种方式：

class demo{
public:
    demo(){}
    const demo& do_something()const{
        //do something
    }
};

这种方式的存在理由至少有下面两点：
（来自《Effective C++》）
1.它们使class比较容易被理解。这是因为，得知哪个函数可以改动对象内容而哪个函数不行，很是重要。
2.它们使操作const对象成为可能。（改善C++程序效率的一个根本方法是以pass by reference-to-const方式传递对象，此技术可行的前提是，我们有const成员函数可用来处理取得的const对象）。

第一点很容易理解，第二点需要稍微解释（有经验的读者可以跳过，这里仅供初学者观看）
1.使用reference-to-const可以防止不必要的对象拷贝
（传值和传递引用的根本性的不同指出就是：由于函数有副本机制，传值会激发函数的副本机制，传入的是对象的拷贝，操作的是对象的拷贝，而不是我们传入的那个参数本身）

2.同时可以防止对象被意外修改（因为我们使用了const引用）（此时我们很可能只是取出对象中的某些值加以操作，而不会改变对象的任何一个成员）。

3.两个成员函数，如果只是常量性不同，可以被重载（这是C++一大特性）

class demo{
public:
    demo():m_dat(0){}
    demo(int dat):m_dat(dat){}
    void print(){
        std::cout<<"void print() called"<<std::endl;
        std::cout<<m_dat<<std::endl;
    }
    void print()const{
        std::cout<<"void print()const called"<<std::endl;
        std::cout<<m_dat<<std::endl;
    }
private:
    int m_dat;
};

函数中两个print没有本质的区别，只是 void print()const 发誓始终不会对类进行任何改动。

当然我们不会重载如此无聊的函数，只是作为一个例子，更好的例子是iterator：（下面的例子是< array >头文件中的begin函数，用于返回一个迭代器）

      // Iterators.
      iterator
      begin() noexcept
      { return iterator(data()); }

      const_iterator
      begin() const noexcept
      { return const_iterator(data()); }

3.非const函数无法操作const对象

#include <iostream>

class demo{
public:
    demo():m_dat(0){}
    demo(int dat):m_dat(dat){}
    void print(){
        std::cout<<"void print() called"<<std::endl;
        std::cout<<m_dat<<std::endl;
    }
private:
    int m_dat;
};

int main(){
    const demo mx(200);
    mx.print();
    return 0;
}

编译出错：
这里写图片描述
正如编译器所说，我们无法调用非const成员函数 print

为什么呢？
答：因为我们操作的是const对象，也就是该对象禁止我们对其进行任何改动。然而，作为非const成员函数并没有发誓：我不会对对象进行任何的改动。所以，当我们调用print成员函数时，print很有可能对对象进行改动，这是不符合C++const属性的，所以编译器禁止非const函数的调用。

所以我们对代码进行如下改动：

#include <iostream>

class demo{
public:
    demo():m_dat(0){}
    demo(int dat):m_dat(dat){}
    void print(){
        std::cout<<"void print() called"<<std::endl;
        std::cout<<m_dat<<std::endl;
    }
    void print()const{
        std::cout<<"void print()const called"<<std::endl;
        std::cout<<m_dat<<std::endl;
    }
private:
    int m_dat;
};

int main(){
    demo m(100);
    m.print();
    const demo mx(200);
    mx.print();
    return 0;
}

这里写图片描述
如上图，完美运行。可以看出，const对象调用的是void print()const重载。

4.bitwise constness(又称physical constness)和logical constness

(来自《Effective C++》)
bitwise constness成员函数只有在不更改对象之任何成员变量（static除外）时才可以说是const。也就是说他不更改对象内的任何一个bit。这种论点的好处是很容易侦测违反点：编译器只需寻找成员变量的赋值动作即可。bitwise constness正是C++对常量性（constness）的定义，因此const成员函数不可以更改对象内任何non-static成员变量。

但是有些不完全的const函数却可以逃过bitwise constness的检测：

#include <iostream>
#include <cstring>

class demo{
public:
    //默认的构造函数
    demo():m_str(nullptr){}
    //用字符串初始化的构造函数
    demo(char *str):m_str(new char[std::strlen(str)+1]){
        strcpy(m_str,str);
    }
    //重载[]
    char & operator[](std::size_t position)const{
        return m_str[position];
    }
private:
    //存储的字符
    char * m_str;
    //友元函数，重载输出流<<
    friend std::ostream & operator<<(std::ostream & out,const demo&obj);
};

std::ostream & operator<<(std::ostream & out,const demo&obj){
    return out<<obj.m_str;
}

int main(){
    const demo mydemo("hello world");//构造一个demo对象mydemo
    std::cout<<mydemo<<std::endl;//打印mydemo中的字符串
    mydemo[0]='z';      //取出mydemo的中存储的第一个字符，并赋值为‘z’
    std::cout<<mydemo<<std::endl;//再次打印mydemo中的字符串
    return 0;
}

这里写图片描述
如图，hello world 竟然变成了 zello world

从上面的例子中，我们发现char & operator[](std::size_t position)const虽然声明为const成员函数，但是他的返回值确实一个 非常引用。所以我们可以修改之。

但是mydemo的确是const对象，我们怎么就修改了它的成员呢？
答：我们此时并没有修改mydemo的成员，但是我们修改了mydemo成员m_str所指向的数据。（但是这并不是我们使用const对象的初衷，我们的初衷是：哪怕是指向的数据也是无法被修改的）
mydemo的确是const对象，我们可以很直观的知道demo的成员m_str此时具有const属性，我们无法修改它。但是此时的const指的是，m_str这个指针（他是demo的一个成员指针变量）无法被修改const函数修改，但并不意味着它所指向的数据无法修改。

这里的问题关键是：我们让operator[]返回了一个非常量引用。我们只需将返回值声明为const即可：

    const char & operator[](std::size_t position)const{
        return m_str[position];
    }

上述这种情况值得就是logical constness：(来自《Effective C++》)一个const成员函数可以修改它所处理的对象内的某些bits，但只有在客户端侦测不出的情况下才得如此。

还有一个问题：有时我们需要修改某些变量，但是const对象只允许调用const函数，而const函数中，我们无法对对象中的任何变量做出修改。此时我们就需要用到mutable变量。
mutable可以释放掉non-static成员的bitwise constness约束。
上例子：（下面我们重载了adjust_length的const版本和非const版本）

#include <iostream>
#include <cstring>

class demo{
public:
    demo():m_str(nullptr),length(0){}
    demo(char *str){
        length=std::strlen(str);
        m_str=new char[this->length+1];
        strcpy(m_str,str);
    }
    void adjust_length()const{
        std::size_t tmp=strlen(m_str);
        if(length!=tmp){
            length=tmp;
        }
    }
    void adjust_length(){
        std::size_t tmp=strlen(m_str);
        if(length!=tmp){
            length=tmp;
        }
    }
private:
    char * m_str;
    std::size_t length;
};

int main(){
    return 0;
}

编译器提示错误：
这里写图片描述

错误处在下面这一段代码：

    void adjust_length()const{
        std::size_t tmp=strlen(m_str);
        if(length!=tmp){
            length=tmp;
        }
    }

我们无法校对const对象的length，而这种校对又显得十分重要（虽然不太必要，仅一个例子），我们可以这样做，如下：

#include <iostream>
#include <cstring>

class demo{
public:
    demo():m_str(nullptr),length(0){}
    demo(char *str){
        length=std::strlen(str);
        m_str=new char[this->length+1];
        strcpy(m_str,str);
    }
    void adjust_length()const{
        std::size_t tmp=strlen(m_str);
        if(length!=tmp){
            length=tmp;
        }
    }
    void adjust_length(){
        std::size_t tmp=strlen(m_str);
        if(length!=tmp){
            length=tmp;
        }
    }
private:
    char * m_str;
    mutable std::size_t length;
};

int main(){
    return 0;
}

精髓就在：这里写图片描述 这里。

5.在const和non-const函数的重载重避免代码重复

假设有下面这样的一个类：

class demo{
public:
    demo():m_str(nullptr){}
    demo(char *str):m_str(new char[std::strlen(str)+1]){
        strcpy(m_str,str);
    }
    const char & operator[](std::size_t position)const{
        //....检查position是否越界
        //....检查数据的完整新
        //....对该操作进行记录，写入log（日志）
        return m_str[position];
    }
    char & operator[](std::size_t position){
        //....检查position是否越界
        //....检查数据的完整新
        //....对该操作进行记录，写入log（日志）
        return m_str[position];
    }
private:
    char * m_str;
};

我们会发现，operator[]的const和非const版本的过程极度相似，甚至二者之间的差别只是返回值const和非const的差别。

即使我们将中间的类似过程封装为demo类的private成员函数，但是我们还是不可避免的造成了一些不必要的开销，如函数的调用，函数的返回值等。

问题解决：Casting away constness

安全版本：

class demo{
public:
    demo():m_str(nullptr){}
    demo(char *str):m_str(new char[std::strlen(str)+1]){
        strcpy(m_str,str);
    }
    const char & operator[](std::size_t position)const{
        //....检查position是否越界
        //....检查数据的完整新
        //....对该操作进行记录，写入log（日志）
        return m_str[position];
    }
    char & operator[](std::size_t position){
        return const_cast<char&>(static_cast<const demo>(*this)[position]);
    }
private:
    char * m_str;
};

代码的亮点就在：

    char & operator[](std::size_t position){
        return const_cast<char&>(static_cast<const demo>(*this)[position]);
    }

解释：此时我们做了两次数据类型转换。

第一次：

static_cast<const demo>(*this)[position];

这里我们为了调用const版本的operator[] ，我们只有将对象转换为const对象然后再调用const版本的operator[] ，因为我们没有直接的语法可以调用const版本的函数重载。

第二次：

const_cast<char&>(/*......*/);

此时，我们将const版本调用后返回的const char&转换为char&，去掉const属性我们要调用的是const_cast。第一次之所以调用static_cast是因为第一次转换并没有涉及const属性的去除。

这里我们用的的技巧是：当const版本和非const版本函数重载其操作非常相似时，我们可以通过 非const版本函数调用 const版本函数重载 来避免代码重复。

值得注意的是：上述行为的反向行为是危险的。这个反向行为就是：重载const版本函数时，通过调用 非const版本函数 来达到避免代码重用的目的。

危险版本：

#include <iostream>
#include <cstring>

class demo{
public:
    demo():m_str(nullptr){}
    demo(char *str):m_str(new char[std::strlen(str)+1]){
        strcpy(m_str,str);
    }
    const char & operator[](std::size_t position)const{
        return static_cast<const char&>((*const_cast<demo*>(this))[position]);
    }
    char & operator[](std::size_t position){
        //....检查position是否越界
        //....检查数据的完整新
        //....对该操作进行记录，写入log（日志）
        return m_str[position];
    }
private:
    char * m_str;
};

int main(){
    const demo d("hello");
    std::cout<<d[0]<<std::endl;
    return 0;
}

解释：上述代码中：

    const char & operator[](std::size_t position)const{
        return static_cast<const char&>((*const_cast<demo*>(this))[position]);
    }

细心的同学会发现：它的步骤就是是 安全版本 的反向。虽然static_cast< const char& >(…..) 显得多余。

为什么是危险的？
答：const版本函数中调用的是非const版本函数，关键就是我们不知道非const版本的函数中，对数据到底做了什么处理，到底有没有修改数据。所以，这种做法是危险的。

转载请注明出处

seiiseii
关注
专栏目录
const用法
hnu_zzu的博客
01-10 205
1. const基本知识点 1.1 const声明的变量只能被读 const int i=5; int j=0; i=j; //非法，导致编译错误 j=i; //合法 1.2 必须初始化 const int i=5; //合法 const int i=5 与int const i=5等价 const int j; //非法，导致编译错误 1.3 如何在另一.c源文件中引用const常量 extern const int i; //合法 extern co
const 用法
m0_56797675的博客
05-20 2443
const 用法 const 修饰变量，这个变量被称为常变量，不能被修改，但本质上还是一个变量 #通过指针改变num的值 int main() { int num = 10; int* p = &num; *p = 20; printf("%d ", num); return 0; } #这里num被 const修饰本来不能被修改，但num把地址交给了p，结果p通过解引用找到num，把num给修改了 int main() { const int num = 10; int *p =
const
weixin_33725272的博客
11-03 105
const const主要是为了程序的健壮型,减少程序出错. 最基本的用法: const int a=100; b的内容不变,b只能是100也就是声明一个int类型的常量(#define b =100) int const b=100; //和上面作用一样 const指针和引用一般用在函数的参数中 int* m = &a...
const变量
weixin_46146815的博客
02-08 88
C++ const变量
const用法详解（转）
weixin_30396699的博客
10-06 543
面向对象是C++的重要特性. 但是c++在c的基础上新增加的几点优化也是很耀眼的 就const直接可以取代c中的#define 以下几点很重要,学不好后果也也很严重 const 1. 限定符声明变量只能被读 const int i=5; int j=0; ... i=j; //非法，导致编译错误 j=i; //合法 2. 必须初始化 const int i=5; ...
Vue基础知识总结 10：使用vue-cli（vue脚手架）快速搭建项目
热门推荐
学Java，找哪吒
10-08 4万+
???? Java学习路线：搬砖工逆袭Java架构师 ???? 简介：Java领域优质创作者????、CSDN哪吒公众号作者✌ 、Java架构师奋斗者???? ???? 扫描主页左侧二维码，加入群聊，一起学习、一起进步 ???? 欢迎点赞 ???? 收藏 ⭐留言 ???? ...
泥鳅般的const（一个小Demo彻底搞清楚）
gaoxueyi551的专栏
11-02 806
如果您觉的const修饰符学的还是一头雾水或者想更深入的理解其用途, 不妨认真看完这个小Demo，看完之后相信您对其理解便如拨云见日，大彻大悟一般。
C++中const使用说明
07-04
`const`的使用能够帮助我们确保代码的稳定性和安全性，同时也能提高编译器的错误检查能力。以下是对`const`在C++中使用的详细说明： 1. **`const`修饰指针** - `const`位于星号左侧：`const int *a` 表示指针`a`...
Const使用方法介绍
07-30
为了程序的健壮型,减少程序出错，这里详细介绍了const的用法。
C++ const使用详解
03-02
C++ const 使用详解 C++ 中的 const 关键字是非常重要的，它可以用来修饰变量、指针、函数参数、返回值、成员函数等，具有非常多的用途。下面将对 const 的使用做详细的解释。 一、const 基础 const 关键字可以...
c++ ；类中的const使用
04-26
c++ ；有关类中的const如何使用，简单的实现const常亮及修饰符
C语言 const使用详解
流楚丶格念的博客
10-18 2976
文章目录const前导知识定义基本用法修饰变量变量？常量？const与define的区分：代码应用const 定义变量修改const 变量值const 修饰指针const 与 struct 的爱恨情仇 const前导知识 定义 它是定义只读变量的关键字，或者说 const 是定义常变量的关键字。 const 定义的是变量，但又相当于常量；说它定义的是常量，但又有变量的属性，所以叫常变量 基本用法 用 const 定义的变量的值是不允许改变的，即不允许给它重新赋值，即使是赋相同的值也不可以。所以说它定义的是只
浅谈ES6语法中箭头函数的用法
Pe7erjmd的博客
05-01 229
ES6箭头函数的用法箭头函数的用法箭头函数的特点箭头函数的改写箭头函数和普通函数的区别 箭头函数的用法 你好！今天来写一下箭头函数的用法，因为在使用中还是经常会遇到箭头函数的使用，因此需要辨别箭头函数的多种写法，在实际使用时才不会发懵，这次也是通过复写我在B站看到的一个比较好的教程，也不知道这样算不算抄袭，我还标的原创，emmmm，因为就是当学习笔记在用嘛，所以大佬如果找过来我再删掉好了，kk。 ...
【新手向】C++中const的用法总结，超级简单的，看不懂的话………………………………………………我再给你讲一遍
能饮一杯否
02-11 451
1.      定义常量const int a = 10; a=0;//编译错误 const double Pi=3.14; const char * School_name = "Peking University";2.      定义常量指针不可通过指针修改其指向的内容int n,m; const int *p = &amp;n; *p = 5;//错 n = 4;//对，其指向的内容可以改...
C++11的enum class & enum struct和enum
Sei的博客
12-04 1万+
C++标准文档——n2347（学习笔记） 链接：http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf旧版enum存在的问题 1 问题1向整形的隐式转换 2 问题2无法指定底层所使用的数据类型 3 问题3enum的作用域 4 不同编译器解决该问题的方法不统一 enum class 和 enum struct 1 enum
C++的chrono、ratio和ctime等头文件
Sei的博客
11-29 6178
C++的chrono、ratio和ctime等头文件推荐网站：http://www.cplusplus.com/ 参考： - http://www.cplusplus.com/ - http://www.cplusplus.com/reference/chrono/ - http://www.cplusplus.com/reference/ctime/C的chronoratio和c
C\C++中的整形提升
Sei的博客
12-04 3715
1. 什么是整形提升？首先我们来看看整形提升的概念： From the text K&R, C Programming Language, 2nd Ed. p. 174 A.6.1 Integral Promotion A character, a short integer, or an integer bit-field, all either signed or not,
C++11中的POD
Sei的博客
05-03 3680
C++11中的PODC11中的POD 什么是POD 什么是Trival Type 1 如何判定Trival Type 什么是Standard-layout 1 Standard-layout标准布局的意义 2 如何判断标准布局1.什么是POD？ C++11中的POD分为两部分的内容，包括Trival Type和Standard-layout。 2.什么是Trival Type？ A tri
重载new和delete的一些规则
Sei的博客
11-20 3176
重载new和delete的一些规则重载new和delete的一些规则 一般规则 特殊规则1 特殊规则2 特殊规则3 new和delete重载实例 直接获取当前的new_handler 转载请注明出处参考：《Effective C++》一般规则1.内存分配失败时调用new_handler 关于new_handler参考： http://blog.csdn.net/sanoseiichirou/ar
C++ 的const 使用
最新发布
05-23
在 C++ 中，const 关键字用于声明一个变量为常量，表示该变量的值不能被修改。const 关键字可以修饰变量、函数返回值、函数参数等，下面分别介绍其用法： 1. 修饰变量 const int a = 10; // 常量a const int *p = &a; // 指向常量的指针 int const *q = &a; // 指向常量的指针，与p等价 *p = 20; // 错误，不能修改指针所指向的变量的值 q = &b; // 正确，可以修改指针的指向 2. 修饰函数返回值 const int func() { return 10; // 返回常量10 } int b = func(); // 正确，可以将常量赋值给非常量 3. 修饰函数参数 void func(const int &a) { a = 20; // 错误，不能修改常量引用所绑定的变量的值 } int b = 10; func(b); // 正确，可以将非常量传递给常量引用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值