当前位置: 首页 > 编程笔记 >

详解C/C++中const关键字的用法及其与宏常量的比较

汪学真
2023-03-14
本文向大家介绍详解C/C++中const关键字的用法及其与宏常量的比较,包括了详解C/C++中const关键字的用法及其与宏常量的比较的使用技巧和注意事项,需要的朋友参考一下

1.const关键字的性质

简单来说:const关键字修饰的变量具有常属性。 即它所修饰的变量不能被修改。

2.修饰局部变量

 const int a = 10;
 int const b = 20;

这两种写法是等价的,都是表示变量的值不能被改变,需要注意的是,用const修饰变量时,一定要给变量初始化,否则之后就不能再进行赋值了,而且编译器也不允许不赋初值的写法:

在C++中不赋初值的表达一写出来,编译器即报错,且编译不通过。

在C中不赋初值的表达写出来时不报错,编译时只有警告,编译可以通过。而当你真正给它赋值时才会报错,那么没有初值也不能被赋值这样的变量有什么用哪?

 const chsr* p = "qwerty"; //const用于修饰常量静态字符串

如果没有const的修饰,我们可能会在后面有意无意的写p[4]='x'这样的语句,这样会导致对只读内存区域的赋值,然后程序会立刻异常终止。有了const,这个错误就能在程序被编译的时候就立即检查出来,这就是const的好处。让逻辑错误在编译期被发现。(这个特性在C/C++中相同)

3.修饰指针

常量指针是指针所指向的内容是常量,不可被修改。

 const int * n = &a;
 int const * n = &a;

上面两种写法也是等价的,性质如下:

1)常量指针通过不能这个指针改变变量的值,但是可以通过其他的引用来改变变量的值的。

const int *n = &a;
  *n = b;

上面的写法报错

 int c = 3;
 const int *n = &a;
 a = 10;
 a = c;

这样赋值是可以的。

2)常量指针指向的值不能改变,但是指针本身可以改变,即常量指针可以指向其他的地址。

  int a = 1;
 int b = 2;
 const int *n = &a;
 n = &b;

指针常量是指指针本身是个常量,不能在指向其他的地址,写法如下: 

 int a = 1;
  int b = 2;
  int * const n = &a;
  *n = b;
  b = a;

而这么写是错误的

int a = 1;
 int b = 2;
 int c = 3;
 int * const n = &a;
 n = &b;

它们的区别在于const的位置,可以这样记忆:const在“*”前面时它修饰(*n),而*n是n所指向的变量,所以是常量指针,const在“*”后面时它修饰(n),使指针变为常量,所以是指针常量。

指向常量的常指针

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

指针指向的位置不能改变并且也不能通过这个指针改变变量的值,但是依然可以通过变量赋值,或其他的普通指针改变变量的值。

(这种用法在C和C++中是相同的。)

4.修饰引用

int a = 1;
 int const &a = b;
 const int &a = b;

两种定义形式在本质上是一样的

5.函数中使用const

(1)修饰函数参数

根据const修饰指针的特性,const修饰函数的参数也是分为三种情况

 void StrCopy(char *strdes, const char *strsrc);//防止修改指针指向的内容

其中 strsrc是输入参数,strdes是输出参数。给 strsrc 加上 const 修饰后,如果函数体内的语句试图改动 sresrc 的内容,编译器将指出错误。

 void swap ( int * const p1 , int * const p2 ) //防止修改指针指向的地址

指针p1和指针p2指向的地址都不能修改。

void test ( const int * const p1 , const int * const p2 ) //以上两种的结合

另外当参数为引用时

void function(const Class& Var); //引用参数在函数内不可以改变 
 void function(const TYPE& Var); //引用参数在函数内为常量不可变

(这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的,他禁止对引用的对象的一切修改,唯一不同的是按值传递会先建立一个类对象的副本, 然后传递过去,而它直接传递地址,所以这种传递比按值传递更有效.另外只有引用的const传递可以传递一个临时对象,因为临时对象都是const属性, 且是不可见的,他短时间存在一个局部域中,所以不能使用指针,只有引用的const传递能够捕捉到这个家伙。)

(2)修饰函数返回值

如果给以“指针传递”方式的函数返回值加 const 修饰,那么函数返回值(即指针)的内容不能被修改,该返回值只能被赋给加const 修饰的同类型指针。

const int * fun2() //调用时 const int *pValue = fun2(); 
       //我们可以把fun2()看作成一个变量,即指针内容不可变。 
 c.int* const fun3() //调用时 int * const pValue = fun2(); 
       //我们可以把fun2()看作成一个变量,即指针本身不可变。 
const int fun1() //这个其实无意义,因为参数返回本身就是赋值。

6.修饰类相关

(1)用const修饰的类成员变量,只能在类的构造函数初始化列表中赋值,不能在类构造函数体内赋值。

class A
{
public:
 A(int x) : a(x) // 正确
 {
   //a = x; // 错误
 }
private:
 const int a;
};

(2)const修饰成员函数

用const修饰的类成员函数,在该函数体内不能改变该类对象的任何成员变量, 也不能调用类中任何非const成员函数。一般写在函数的最后来修饰。

class A
{
public:
 int& getValue() const
 {
  // a = 10; // 错误
  return a;
 }
private:
 int a;   // 非const成员变量
};

a. const成员函数不被允许修改它所在对象的任何一个数据成员。

b. const成员函数能够访问对象的const成员,而其他成员函数不可以。

(3)const修饰类对象/对象指针/对象引用

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

因此不能调用该对象的任何非const成员函数,因为对非const成员函数的调用会有修改成员变量的企图。

class A
{
 public:
 void funcA() {}
 void funcB() const {}
};
int main
{
 const A a;
 a.funcB(); // 正确
 a.funcA(); // X

 const A* b = new A();
 b->funcB(); // 正确
 b->funcA(); // X
}

(4)在类内重载成员函数

class A
 {
 public:
  void func() {}
  void func() const {} // 重载
 };

另外,const数据成员只在某个对象生存期内是常量,而对整个类而言是可变的,因为类可以创建多个对象,不同对象的const数据成员值可以不同。

class A
{
public:
 A(int size) 
   : _size(size) // 正确
 {}
private:
 const int _size;
};
A a(10); //对象a的_size值为10
A b(20); //对象b的_size值为20

那么,怎样才能建立在整个类中都恒定的常量呢?用枚举常量。

class A
{
public:
 enum{SIZE1 = 10, SIZE2 = 20};//枚举常量
private:
  int arr1[SIZE1];
  int arr2[SIZE2];
};

枚举常量不会占用对象的存储空间,它们在编译时被全部求值。但缺点是隐含数据类型是只能整数,最大值有限,且不能表示浮点数。

7.修饰全局变量

全局变量的作用域是整个文件,我们应该尽量避免使用全局变量,以为一旦有一个函数改变了全局变量的值,它也会影响到其他引用这个变量的函数,导致除了bug后很难发现,如果一定要用全局变量,我们应该尽量的使用const修饰符进行修饰,这样方式不必要的以为修改,使用的方法与局部变量是相同的。

8.const常量与宏常量的区别

(1).便于进行类型检查

const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查,而对后者只进行字符替换,没有类型安全检查,并且在字符替换时可能会产生意料不到的错误(边际效应)。

//例子:
 void f(const int i) { .........} //对传入的参数进行类型检查,不匹配进行提示

(2)可以节省空间,避免不必要的内存分配

const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝。

#define PI 3.14159   //常量宏
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中
    ......
 double i=Pi; //此时为Pi分配内存,以后不再分配!
 double I=PI; //编译期间进行宏替换,分配内存
 double j=Pi; //没有内存分配
 double J=PI; //再进行宏替换,又一次分配内存!

(3)提高了效率 

 宏定义是一个“编译时”概念,在预处理阶段展开,不能对宏定义进行调试,生命周期结束于编译时期。const常量是一个“运行时”概念,在程序运行时使用,类似于一个只读数据。

编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高

(4)可以保护被它修饰的东西

防止意外的修改,增强程序的html" target="_blank">健壮性。

void f(const int i) { i=10;//error! } //如果在函数体内修改了i,编译器就会报错 

(5)为函数重载提供了一个参考

 class A
 {
   ......
 void f(int i)  {......} //一个函数
 void f(int i) const {......} //上一个函数的重载
   ......
 };

(6)定义域不同

 void f1 ()
 {
  #define N 12
  const int n 12;
 }
 void f2 ()
 {
  cout<<N <<endl; //正确,N已经定义过,不受定义域限制
  cout<<n <<endl; //错误,n定义域只在f1函数中。若想在f2中使用需定义为全局的
 }

(7)做函数参数

   宏定义不能作为参数传递给函数;const常量可以在函数的参数列表中出现。

9.const_cast

const_cast运算符用来修改类型的const或volatile属性。

(1)常量指针被转化成非常量的指针,并且仍然指向原来的对象;

(2)常量引用被转换成非常量的引用,并且仍然指向原来的对象。

 void func()
 {
  const int a = 10;
  int* p = const_cast<int*> (&a);
  *p = 20;
  std::cout<<*p; // 20
  std::cout<<a;  // 10
 }

注:C++中使用const 常量而不使用宏常量,即const 常量完全取代宏常量。

以上所述是小编给大家介绍的C/C++中const关键字的用法及其与宏常量的比较,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对小牛知识库网站的支持!

 类似资料:
  • 本文向大家介绍详解C语言中const关键字的用法,包括了详解C语言中const关键字的用法的使用技巧和注意事项,需要的朋友参考一下 关键字const用来定义常量,如果一个变量被const修饰,那么它的值就不能再被改变,我想一定有人有这样的疑问,C语言中不是有#define吗,干嘛还要用const呢,我想事物的存在一定有它自己的道理,所以说const的存在一定有它的合理性,与预编译指令相比,cons

  • 本文向大家介绍在C#中global关键字的作用及其用法,包括了在C#中global关键字的作用及其用法的使用技巧和注意事项,需要的朋友参考一下 global 是 C# 2.0 中新增的关键字,理论上说,如果代码写得好的话,根本不需要用到它。 假设你现在写了一个类,名字叫 System。那么当你再在代码里写 System 的时候,编译器就不知道你是要指你写的 System 类还是系统的 System

  • 本文向大家介绍浅谈Java中的final关键字与C#中的const, readonly关键字,包括了浅谈Java中的final关键字与C#中的const, readonly关键字的使用技巧和注意事项,需要的朋友参考一下 在编程语言中都有某种方式,告知编译器一块数据是恒定不变的。有两个需求 1. 一个永不改变的编译器常量 2. 一个在运行时被初始化的值,而这个值不会被改变 在Java中,使用fina

  • 本文向大家介绍详解C# partial 关键字的使用,包括了详解C# partial 关键字的使用的使用技巧和注意事项,需要的朋友参考一下 什么是局部类型? C# 2.0 引入了局部类型的概念。局部类型允许我们将一个类、结构或接口分成几个部分,分别实现在几个不同的.cs文件中。 局部类型适用于以下情况: (1) 类型特别大,不宜放在一个文件中实现。 (2) 一个类型中的一部分代码为自动化工具生成的

  • 根据我的理解,存在存储持续时间,这意味着在全局的情况下,它会持续到程序的生存期,但是当您谈到局部的情况时,它意味着默认情况下初始化为零。 C++标准对具有关键字的类数据成员这样说: 3.7.1静态存储持续时间[basic.stc.Static] 局部变量是什么意思?那是函数局部变量吗?因为当您将函数local声明为时,它只在第一次进入该函数时初始化一次。 它也只讨论与类成员有关的存储持续时间,它不

  • 本文向大家介绍C++中volatile关键字及常见的误解总结,包括了C++中volatile关键字及常见的误解总结的使用技巧和注意事项,需要的朋友参考一下 前言 近期看到C++标准中对volatile关键字的定义,发现和java的volatile关键字完全不一样,C++的volatile对并发编程基本没有帮助。网上也看到很多关于volatile的误解,于是决定写这篇文章详细解释一下volatile