c语言const大写,从C语言过渡到C++之const

1. 定义常量

1.1 C语言中定义常量的方法

在C语言从零开始这个系列中,我们讲了C语言定义常量的方法。没有看过的同学请参考:C语言从零开始(五)-常量&变量

为什么要定义常量我就不再赘述了,这里重点说说这么定义有什么不好。经常有这样的面试题:请写出下面这段代码的执行结果:

#include

#define SUM 5 + 1;

void main()

{

int a = 2 * SUM;

printf("%d", a);

}

经常有人答12,其实结果是11。不信你用计算机运行一下试试。

为什么会错呢,因为#define定义的常量是伪常量,它在参加编译时做的是原样字符替换。就是2 * SUM这句在编译器看来应该是

int a = 2 * 5 + 1;

如果你的本意是想得到12,那么定义中应该这么写:

#define SUM (5 + 1);

这样的经典错误很多人都犯过,虽然道理大家都知道,但是总会因为粗心大意掉进这个坑里。

于是,C++引入const常量彻底解决了这个问题。后来部分C语言的编译器也开始支持const的使用,这就充分说明了它的价值。

1.2 const常量

在C++中,我们用下面的形式定义常量:

const int MONTH = 12;

const int SUM = 5 + 1;

严格意义上讲,const常量应该叫做“常变量”,它定义了一个值不会被修改的变量。

为了代码风格统一,我们依然习惯把const常量用全大写字母命名。

特点

const常量与普通常量最大的不同有两点:

值不能改变

可以用作数组大小的定义

例如:

const int MAX = 10;

int arr[MAX] = {0};

for (int i = 0; i < MAX; i++)

{

// Do something

}

1.3 作用范围

const定义的常量的作用域类似与static,只能被当前文件访问。如果想在其他文件中使用该如何写呢?

// file1

const int MAX = 10;

// file 2

extern const int MAX;

不过并不推荐这么使用,还是建议大家把const定义写在头文件中,在需要的文件中包含这个头文件。

2. 指针与const

const的修饰特点是修饰离它最近的部分。它一般有两种用法。

2.1 指向const变量的指针

让指针指向一个const对象,防止指针修改所指向的值。

int age = 30;

const int* ptr = &age;

这段代码定义了一个指针ptr,它指向一个const int类型的数据,不可修改。

*ptr += 1; // 报错

cin >> *ptr; // 报错

这两种写法都是非法的。

注意:依然可以用 age变量修改。

2.2 const指针

将指针本身声明为一个常量,防止指针位置改变

int a = 3;

int* const p = &a;

p++; // 错误

注意:只有const指针能够指向const变量,例如:

const int a = 9;

const int* p = &a; // 正确

int* ptr = &a; //错误

特殊使用:

const int* const p = &a;

这句话的意思是指针变量和指向的地址中的内容都不可变

3. 函数与const

3.1 const参数

如果希望参数在函数内部不被修改,可以用const修饰,如下:

void fun(const int a)

{

a++; // 非法操作

}

由于a被const修饰为常变量,因此再对它进行a++操作就会报错。

这种写法的目的只是为了限制参数在函数内部的修改,如今越来越多的人喜欢这样实现:

void fun(int a)

{

const int& b = a;

b++; // 非法操作

}

效果是完全一样的。

3.2 const返回值

如果函数返回值是一个基本数据类型,用const修饰是没有意义的。比如:

const int fun()

{

return 1;

}

fun()函数的返回值是不可能做“左值”再被修改的,因为没人会这么使用:

fun() = 2;

编译器也会把这种写法先过滤掉。

一般,const只用来修饰返回值是一个类的对象的函数。例如:

class A

{

public:

A()

{

m_i = 0;

}

A(int i) : m_i(i){}

void Modify(int i)

{

m_i = i;

}

private:

int m_i;

};

A GetA()

{

return A(1);

}

const A GetConstsA()

{

return A(1);

}

void Update(A& a)

{

a.Modify(2);

}

void Update2(const A& a)

{

A m = a;

m.Modify(2);

}

int main()

{

GetA() = A(1); // 正确

GetA().Modify(5); // 正确

GetConstsA() = A(1); // 报错

GetConstsA().Modify(); // 报错

Update(GetA()); // 正确

Update(GetConstsA()); // 报错

Update2(GetConstsA()); // 正确

return 0;

}

能看懂其中的奥秘吗?总结一下,const修饰的返回值如果是类的对象,那么:

这个返回值不能做左值(放在等号左边被赋值或者调用其成员函数)

这个返回值的别名必须也被const修饰

4. 举一反三

知道了一般参数和返回值被const修饰的情况,我们应该能够推导出const修饰指针参数和返回值的情况。我们用一段代码来看看容易出现的错误。

void fun1(int* p)

{

// Do nothing

}

void fun2(const int* cp)

{

*cp = 3; // 错误

int i = *cp;

int* ip2 = cp; // 错误

}

const char* fun3()

{

return "result of function fun3()";

}

const int* const fun4()

{

static int i;

return &i;

}

int main()

{

int x = 0;

int* p = &x;

const int* cp = &x;

fun1(p);

fun1(cp); // 错误

fun2(p);

fun2(cp);

char* cp = fun3(); // 错误

const char* ccp = fun3();

int* p2 = fun4(); // 错误

const int* const ccp = fun4();

const int* cp2 = fun4();

*fun4() = 1; // 错误

return 0;

}

这段程序的各种赋值其实完全符合第2部分中介绍的原则。在传参和赋值的过程中需要注意:

指针内容被const修饰时,*p不可修改

指针内容被const修饰时,不能赋值给内容非const的指针

指针变量和内容都被const修饰时,只能给相同情况的指针赋值

说起来有些拗口,仔细想想其实和第二部分所讲的内容相似。

OK,今天就先到这里。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值