草庐IT

C++ const 关键字小结

runoob 2023-03-28 原文

const 是 constant 的缩写，本意是不变的，不易改变的意思。在 C++ 中是用来修饰内置类型变量，自定义对象，成员函数，返回值，函数参数。

C++ const 允许指定一个语义约束，编译器会强制实施这个约束，允许程序员告诉编译器某值是保持不变的。如果在编程中确实有某个值保持不变，就应该明确使用const，这样可以获得编译器的帮助。

一、const修饰普通类型的变量

const int  a = 7; 
int  b = a; // 正确
a = 8;       // 错误，不能改变

a 被定义为一个常量，并且可以将 a 赋值给 b，但是不能给 a 再次赋值。对一个常量赋值是违法的事情，因为 a 被编译器认为是一个常量，其值不允许修改。

接着看如下的操作：

实例



#include<iostream>
 
using namespace std;
 
int main(void)
{
    const int  a = 7;
    int  *p = (int*)&a;
    *p = 8;
    cout<<a;
    system("pause");
    return 0;
}

对于 const 变量 a，我们取变量的地址并转换赋值给 指向 int 的指针，然后利用 *p = 8; 重新对变量 a 地址内的值赋值，然后输出查看 a 的值。

从下面的调试窗口看到 a 的值被改变为 8，但是输出的结果仍然是 7。

从结果中我们可以看到，编译器然后认为 a 的值为一开始定义的 7，所以对 const a 的操作就会产生上面的情况。所以千万不要轻易对 const 变量设法赋值，这会产生意想不到的行为。

如果不想让编译器察觉到上面到对 const 的操作，我们可以在 const 前面加上 volatile 关键字。

Volatile 关键字跟 const 对应相反，是易变的，容易改变的意思。所以不会被编译器优化，编译器也就不会改变对 a 变量的操作。

实例



#include<iostream>
 
using namespace std;
 
int main(void)
{
    volatile const int  a = 7;
    int  *p = (int*)&a;
    *p = 8;
    cout<<a;
    system("pause");
    return 0;
}

输出结果如我们期望的是 8。

二、const 修饰指针变量。

const 修饰指针变量有以下三种情况。

  • A: const 修饰指针指向的内容，则内容为不可变量。
  • B: const 修饰指针，则指针为不可变量。
  • C: const 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。

对于 A: 

const int *p = 8;

则指针指向的内容 8 不可改变。简称左定值，因为 const 位于 * 号的左边。

对于 B:

int a = 8;
int* const p = &a;
*p = 9; // 正确
int  b = 7;
p = &b; // 错误

对于 const 指针 p 其指向的内存地址不能够被改变，但其内容可以改变。简称，右定向。因为 const 位于 * 号的右边。

对于 C: 则是 A 和 B的合并

int a = 8;
const int * const  p = &a;

这时，const p 的指向的内容和指向的内存地址都已固定，不可改变。

对于 A，B，C 三种情况，根据 const 位于 * 号的位置不同，我总结三句话便于记忆的话："左定值，右定向，const修饰不变量"。

三、const参数传递和函数返回值。

对于 const 修饰函数参数可以分为三种情况。

A：值传递的 const 修饰传递，一般这种情况不需要 const 修饰，因为函数会自动产生临时变量复制实参值。

实例



#include<iostream>
 
using namespace std;
 
void Cpf(const int a)
{
    cout<<a;
    // ++a;  是错误的，a 不能被改变
}
 
int main(void)
 
{
    Cpf(8);
    system("pause");
    return 0;
}

B：当 const 参数为指针时，可以防止指针被意外篡改。

实例



#include<iostream>
 
using namespace std;
 
void Cpf(int *const a)
{
    cout<<*a<<" ";
    *a = 9;
}
 
int main(void)
{
    int a = 8;
    Cpf(&a);
    cout<<a; // a 为 9
    system("pause");
    return 0;
}

C：自定义类型的参数传递，需要临时对象复制参数，对于临时对象的构造，需要调用构造函数，比较浪费时间，因此我们采取 const 外加引用传递的方法。

并且对于一般的 int、double 等内置类型，我们不采用引用的传递方式。

实例



#include<iostream>
 
using namespace std;
 
class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const
    {
       return _cm;
    }
 
private:
    int _cm;
};
 
 
 
void Cmf(const Test& _tt)
{
    cout<<_tt.get_cm();
}
 
int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;
}

结果输出 8。

对于 const 修饰函数的返回值。

Const 修饰返回值分三种情况。

A：const 修饰内置类型的返回值，修饰与不修饰返回值作用一样。

实例



#include<iostream>
 
using namespace std;
 
const int Cmf()
{
    return 1;
}
 
int Cpf()
{
    return 0;
}
 
int main(void)
{
    int _m = Cmf();
    int _n = Cpf();
 
    cout<<_m<<" "<<_n;
    system("pause");
    return 0;
}

B: const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。

C: const 修饰返回的指针或者引用，是否返回一个指向 const 的指针，取决于我们想让用户干什么。

四、const修饰类成员函数

const 修饰类成员函数，其目的是防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为 const 成员函数。

注意：const 关键字不能与 static 关键字同时使用，因为 static 关键字修饰静态成员函数，静态成员函数不含有 this 指针，即不能实例化，const 成员函数必须具体到某一实例。

下面的 get_cm()const; 函数用到了 const 成员函数：

实例



#include<iostream>
 
using namespace std;
 
class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const
    {
       return _cm;
    }
 
private:
    int _cm;
};
 
 
 
void Cmf(const Test& _tt)
{
    cout<<_tt.get_cm();
}
 
int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;
}

如果 get_cm() 去掉 const 修饰，则 Cmf 传递的 const _tt 即使没有改变对象的值，编译器也认为函数会改变对象的值，所以我们尽量按照要求将所有的不需要改变对象内容的函数都作为 const 成员函数。

如果有个成员函数想修改对象中的某一个成员怎么办？这时我们可以使用 mutable 关键字修饰这个成员，mutable 的意思也是易变的，容易改变的意思，被 mutable 关键字修饰的成员可以处于不断变化中，如下面的例子。

实例



#include<iostream>
using namespace std;
class Test
{
public:
    Test(int _m,int _t):_cm(_m),_ct(_t){}
    void Kf()const
    {
        ++_cm; // 错误
        ++_ct; // 正确
    }
private:
    int _cm;
    mutable int _ct;
};
 
int main(void)
{
    Test t(8,7);
    return 0;
}

这里我们在 Kf()const 中通过 ++_ct; 修改 _ct 的值，但是通过 ++_cm 修改 _cm 则会报错。因为 ++_cm 没有用 mutable 修饰。

原文地址：https://www.cnblogs.com/Forever-Kenlen-Ja/p/3776991.html

C++小结spanclasshl

有关C++ const 关键字小结的更多相关文章

  1. ruby - Ruby 的 AST 中的 'send' 关键字是什么意思？ - 2

    我正在尝试学习Ruby词法分析器和解析器(whitequarkparser)以了解更多有关从Ruby脚本进一步生成机器代码的过程。在解析以下Ruby代码字符串时。defadd(a,b)returna+bendputsadd1,2它导致以下S表达式符号。s(:begin,s(:def,:add,s(:args,s(:arg,:a),s(:arg,:b)),s(:return,s(:send,s(:lvar,:a),:+,s(:lvar,:b)))),s(:send,nil,:puts,s(:send,nil,:add,s(:int,1),s(:int,3))))任何人都可以向我解释生成的

  2. ruby-on-rails - `const_missing' : uninitialized constant (NameError) - 2

    每次我尝试使用“script/runner-eproductionClassName.run”从我的Rails2.2应用程序的lib目录运行任何类时，我都会收到以下错误:/usr/lib/ruby/gems/1.8/gems/rails-2.2.2/lib/commands/runner.rb:47:/usr/lib/ruby/gems/1.8/gems/activesupport-2.2.2/lib/active_support/dependencies.rb:89:in`const_missing':uninitializedconstantClassName(NameError)

  3. ruby - 为什么 return 关键字会导致我的 'if block' 出现问题？ - 2

    下面的代码工作正常:person={:a=>:A,:b=>:B,:c=>:C}berson={:a=>:A1,:b=>:B1,:c=>:C1}kerson=person.merge(berson)do|key,oldv,newv|ifkey==:aoldvelsifkey==:bnewvelsekeyendendputskerson.inspect但是如果我在“ifblock”中添加return，我会得到一个错误:person={:a=>:A,:b=>:B,:c=>:C}berson={:a=>:A1,:b=>:B1,:c=>:C1}kerson=person.merge(berson

  4. ruby - 在 Ruby 中跳过额外的关键字参数 - 2

    我定义了一个方法:defmethod(one:1,two:2)[one,two]end当我这样调用它时:methodone:'one',three:'three'我得到:ArgumentError:unknownkeyword:three我不想从散列中一个一个地提取所需的键或排除额外的键。除了像这样定义方法之外，有没有办法规避这种行为:defmethod(one:1,two:2,**other)[one,two,other]end 最佳答案 如果不想写**other中的other，可以省略。defmethod(one:1,two:2

  5. jquery - Ruby 1.9.1、Rails 2.3.2 和 jrails 0.4 出现 "rescue in const_missing"错误 - 2

    我最近开始了一个项目，团队决定我们希望使用jQuery而不是Prototype/Scriptaculous来满足我们的javascript需求。我们设置了我们的项目，并开始切换。插件已安装viatheseinstructions，一切都按计划进行。不久之后，当尝试运行“./script/server”时，我们收到以下错误:=>Rails2.3.2applicationstartingonhttp://0.0.0.0:3000/usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/depende

  6. ruby - 是否有可能在 Ruby 中以哈希的形式访问关键字参数？ - 2

    我知道我能做到:classParentdefinitialize(args)args.eachdo|k,v|instance_variable_set("@#{k}",v)endendendclassA但我想使用关键字参数来更清楚地说明可以接受哪个散列键方法(并进行验证表明不支持此键)。所以我可以写:classAdefinitialize(param1:3,param2:4)@param1=param1@param2=param2endend但是有没有可能写一些更短的东西而不是@x=x;@y=y;...从传递的关键字参数初始化实例变量？是否可以访问作为哈希传递的关键字参数？

  7. ruby :关键字 "in"是什么意思 - 2

    当我第一次在ruby​​中找到关键字“in”时。我想也许我可以这样做:1英寸(0..10)但看起来我不能那样使用它。然后我在ruby​​-lang.org中搜索它，然后用谷歌搜索它。没有答案!ruby中关键字“in”的含义是什么？ 最佳答案 您应该能够执行以下操作:foriin0..10doputsiend您提到的表达式1in(0..10)将不起作用，因为常量(1)不能在一定范围内变化-它是一个常量!您需要在in关键字之前命名一个变量。希望对您有所帮助。参见thispage 关于ruby

  8. ruby - 为什么关键字参数必须作为带有符号键的散列传递，而不是 Ruby 中的字符串键？ - 2

    我们不能将关键字参数作为带有字符串键的散列传递，关键字参数仅适用于作为符号键的散列。一个简单的例子:defmy_method(first_name:,last_name:)puts"first_name:#{first_name}|last_name:#{last_name}"endmy_method({last_name:'Sehrawat',first_name:'Manoj'})#=>first_name:Manoj|last_name:Sehrawatmy_method({first_name:'Bob',last_name:'Marley'})#=>first_name:Bo

  9. 对于体育新闻中文文本关键字提取有哪些关键字提取算法及其步骤 - 2

    对于体育新闻中文文本的关键字提取，常用的算法包括TF-IDF、TextRank和LDA等。它们的基本步骤如下：1.TF-IDF算法： -将文本进行分词和词性标注处理。-统计每个词在文本中的词频（TF）。-计算每个词在整个语料库中出现的文档频率（DF）和逆文档频率（IDF）。-计算每个词的TF-IDF值，并按照值的大小进行排序，选择排名前几的词作为关键字。2.TextRank算法：-将文本进行分词和词性标注处理。-将分词结果转化成图模型，每个词语为节点，根据词语之间的共现关系建立边。-对图模型进行迭代计算，计算每个节点的PageRank值，表示该节点的重要性。-选择排名前几的节点作为关键字。3.

  10. ruby - 从用户提交的文本中提取关键字的好方法是什么？ - 2

    我正在构建一个网站，该网站允许用户通过以图形方式表示支持和反对特定问题的论点来理解辩论。(Wrangl)我想对这些辩论进行分类，以便更容易找到它们并将它们联系起来。我不想让发起辩论的人在他们看到任何好处之前添加标签和类别，从而激怒他们，所以我正在寻找一种自动提取关键字的方法。有什么好的方法可以利用辩论的标题和描述(以及可能的论点本身的内容，一旦有的话)来提取，比如说，可以用作元数据将类似辩论联系在一起的十个强关键字，或者即使是在可以查看辩论的HTML页面头部的“元”关键字标记的内容。例如。DatamappervsActiveRecord该网站使用Ruby和Sinatra编码，使用Dat

随机推荐