一、const的用法
const是不改变的。在C和C++中,我们使用关键字const来使程序元素保持不变。const关键字可以在C++程序的许多上下文中使用。它可以用于:
变量 | 指针 | 函数参数和返回类型 |
类数据成员 | 类成员函数 | 对象 |
1) const变量
如果你用const关键字做任何变量,你就不能改变它的值。同样,必须在声明的时候初始化常数变量。
Example:
int main
{
const int i = 10;
const int j = i + 10; // works fine
i++; // this leads to Compile time error
}
在上面的代码中,我们使 i 成为常量,因此如果我们试图改变它的值,我们将得到编译时错误。尽管我们可以用它来代替其他变量。
2)指针与const关键字
指针也可以使用const关键字来声明。当我们使用const和指针时,我们可以用两种方式来做:可以把const应用到指针指向的地方,或者我们可以使指针本身成为一个常数。
①指向const变量的指针:
这意味着指针指向一个const变量。
const int* u;
在这里,表示u是一个指针,可以指向const int类型变量。我们也可以这样写,
char const* v;
表示v是指向const类型的char的指针。
指向const变量的指针非常有用,因为它可以用来使任何字符串或数组不可变
②const指针
为了使指针保持不变,我们必须把const关键字放到右边。
int x = 1;
int* const w = &x;
这里,w是一个指针,它是const,指向一个int,现在我们不能改变指针,这意味着它总是指向变量x但是可以改变它指向的值,通过改变x的值。
当你想要一个可以在值中改变但不会在内存中移动的存储器时,常量指针指向一个变量是很有用的。因为指针总是指向相同的内存位置,因为它是用const关键字定义的,但是那个内存位置的值可以被更改。
3)const函数参数和返回类型
void f(const int i)
{
i++; // error
}
const int g()
{
return 1;
}
注意几个要点:
①对于建立在数据类型中,返回const或非const值,不会有任何影响。
const int h()
{
return 1;
}
int main()
{
const int j = h();
int k = h();
}
j和k都将被赋值为1。不会出现错误。
②对于用户定义的数据类型,返回const,将阻止它的修改。
③在程序执行时创建的临时对象总是const类型。
④如果一个函数有一个非const参数,它在发出调用时不能传递const参数。
void t(int*)
{
// function logic
}
如果我们把一个const int参数传递给函数t,会出现错误。
⑤但是,一个具有const类型参数的函数,可以传递一个const类型参数以及一个非const参数。
void g(const int*)
{
// function logic
}
这个函数可以有一个int,也可以有const int类型参数。
4)将类数据成员定义为const
这些是类中的数据变量,使用const关键字定义。 它们在声明期间未初始化。 它们的初始化在构造函数中完成。
class Test
{
const int i;
public:
Test (int x)
{
i = x;
}
};
int main()
{
Test t(10);
Test s(20);
}
在这个程序中,i 是一个常量数据成员,在每个对象中它的独立副本将会出现,因此它使用构造函数对每个对象进行初始化。一旦初始化,它的值就不能改变
5)把类对象定义为const
当一个对象被声明或使用const关键字创建时,它的数据成员在对象的生命周期中永远不会被改变。
语法:
const class_name object;
例如,如果在上面定义的类测试中,我们想要定义一个常数对象,我们可以这样做:
const Test r(30);
6)将类的成员函数定义为const
const成员函数决不会修改对象中的数据成员。
语法:
return_type function_name() const;
const对象和const成员函数的例子:
class StarWars
{
public:
int i;
StarWars(int x) // constructor
{
i = x;
}
int falcon() const // constant function
{
/*
can do anything but will not
modify any data members
*/
cout << "Falcon has left the Base";
}
int gamma()
{
i++;
}
};
int main()
{
StarWars objOne(10); // non const object
const StarWars objTwo(20); // const object
objOne.falcon(); // No error
objTwo.falcon(); // No error
cout << objOne.i << objTwo.i;
objOne.gamma(); // No error
objTwo.gamma(); // Compile time error
}
输出结果:
Falcon has left the Base
Falcon has left the Base
10 20
在这里,我们可以看到,const成员函数永远不会改变类的数据成员,并且它可以与const和非const对象一起使用。但是const对象不能与试图改变其数据成员的成员函数一起使用。
二、关于const的疑问:
1.const什么时候为只读变量? |
2.const什么时候是常量? |
const常量的判别标准:
1.只有字面量初始化的const常量才会进入符号表 |
2.使用其他变量初始化的const常量仍然是只读变量 |
3.被volatile修饰的const常量不会进入符号表 |
注意:
1.const引用的类型与初始化变量的类型相同时:初始化变量成为只读变量 |
2.const引用的类型与初始化变量的类型不相同时:初生成一个新的只读变量 |
Example:
#include <stdio.h>
int main()
{
const int x = 1; //字面量初始化,此时x为常量,进入符号表
const int& rx = x; //rx代表只读变量
int& nrx = const_cast<int&>(rx); //去掉rx的只读属性
nrx = 5; //改变了nrx内存空间的值
printf("x = %d\n", x); // 1
printf("rx = %d\n", rx); // 5
printf("nrx = %d\n", nrx); // 5
printf("&x = %p\n", &x); // &x = 002CFD80
printf("&rx = %p\n", &rx); // &x = 002CFD80
printf("&nrx = %p\n", &nrx); // &x = 002CFD80
//输出的地址相同,说明了x、rx、nrx代表同样的内存空间
volatile const int y = 2;//volatile代表易变的
int* p = const_cast<int*>(&y);
*p = 6;
printf("y = %d\n", y); //y = 6
printf("p = %p\n", p); //p = 001BF928
//判别是否是常量是编译器在编译时能不能确认它的值
const int z = y;
p = const_cast<int*>(&z);
*p = 7;
printf("z = %d\n", z); // z = 7
printf("p = %p\n", p); //p = 001BF910
char c = 'c';
char& rc = c;
const int& trc = c;
rc = 'a';
printf("c = %c\n", c); // c = a
printf("rc = %c\n", rc);// rc = a
printf("trc = %c\n", trc);//trc = c
//变量c是char类型,而trc是int类型,所以生成了一个新的只读变量
return 0;
}
输出结果:
References: