极客笔记C++ Const关键字
本节将讨论C++编程语言中的const关键字。它用于定义在程序执行过程中无法更改的常量值。这意味着一旦我们在程序中声明一个变量为常量，该变量的值将被固定，永远不会改变。如果我们尝试更改const类型变量的值，程序将显示错误消息。
使用不同参数的const关键字：
- 使用const变量
- 使用const与指针
- 使用const指针与变量
- 使用const与函数参数
- 使用const与类成员函数
- 使用const与类数据成员
- 使用const与类对象
1. Const变量
这是一个const变量，用于定义在程序执行过程中永远不会改变的变量值。如果我们试图修改这个值，会抛出一个错误。
语法
const data_type variable_name;
示例：在C++中使用const关键字的程序
让我们来创建一个程序，以演示在C++编程语言中使用const关键字。
#include
#include
using namespace std;
int main ()
{
// declare the value of the const
const int num = 25;
num = num + 10;
return 0;
}
输出
它显示了编译时错误，因为我们通过10来更新了num 25的分配值。
示例：让我们创建一个简单的程序来演示C++编程语言中const关键字的用法。
/* create a program to use the const keyword with different data types in the C++. */
#include
#include
using namespace std;
int main ()
{
// declare variables
const int x = 20;
const int y = 25;
int z;
// add the value of x and y
z = x + y;
cout << " The sum of the x and y is: " << z << endl;
return 0;
}
输出
The sum of the x and y is: 42
在上述程序中，我们在开始时声明和赋值了const变量x和y。然后，将两个const变量的结果存储到变量’z’中以打印其和。
注意：在C++编程中，当声明const变量时，我们需要同时给定义变量赋值；否则，会显示编译时错误。
2. 常量指针
要创建一个const指针，我们需要在指针的名称前使用const关键字。在初始化之后，无法更改常量指针的地址，这意味着一旦指针被初始化为常量指针，它将始终指向同一个地址。
示例：使用const关键字演示常量指针的程序
让我们以C++编程语言为例，使用const关键字和常量指针。
#include
using namespace std;
int main ()
{
// declaration of the integer variables
int x = 10, y = 20;
// use const keyword to make constant pointer
int* const ptr = &x // const integer ptr variable point address to the variable x
// ptr = &y // now ptr cannot changed their address
*ptr = 15; // ptr can only change the value
cout << " The value of x: " << x << endl;
cout << " The value of ptr: " << *ptr << endl;
return 0;
}
输出
The value of x: 15
The value of ptr: 15
在上面的程序中，指针ptr指向int变量’x’的地址，并且一旦初始化，ptr变量的地址不能被改变，但指针ptr可以改变x的值。
3. 常量变量的指针
这意味着指针指向了一个不能改变的常量变量的值。 常量变量的指针声明：
const int* x;
在这里，x是一个指向const整数类型变量的指针，我们也可以声明一个指向常量变量的指针，如下：
char const* y;
在这种情况下，y是一个指向一个char类型的常量变量的指针。
示例：使用const关键字将指针用于常量变量的程序
#include
using namespace std;
int main ()
{
// declare integer variable
int x = 7, y = 10;
const int *ptr = &x // here x become constant variable
cout << " \n The initial value of ptr:" << *ptr;
cout << " \n The value of x: " <
输出
The initial value of ptr: 7
The value of x: 7
The value of y: 10
The value of ptr: 10
在上面的程序中，指针ptr指向const int（x）变量，并且int（x）变量的值永远不会改变。
4.常量函数参数
我们可以使用const关键字将函数参数声明为常量参数。如果函数参数的值被声明为const，则不允许更改其值。
语法
return_type fun_name (const int x)
{
}
在上面的语法中，return_type表示函数是否返回一个值。 fun_name() 函数包含一个 const 参数，其值一旦在程序中定义就不能改变。
示例：让我们以C++编程语言中使用const关键字与函数参数的例子为例。
#include
using namespace std;
// create an integer Test() function contains an argument num
int Test (const int num)
{
// if we change the value of the const argument, it thwrows an error.
// num = num + 10;
cout << " The value of num: " << num << endl;
return 0;
}
int main ()
{
// call function
Test(5);
}
输出
The value of num: 5
在上面的程序中，num是一个常量参数，我们不能更新num的值。如果我们更新num变量的值，会返回编译时错误。
5. 类的const成员函数
- const是一个类的常量成员函数，它不会改变任何类的数据成员，也不会调用任何非const函数。
- 也被称为只读函数。
- 我们可以通过在成员函数的名称后添加const关键字来创建一个类的常量成员函数。
语法
return_type mem_fun() const
{
}
在上面的语法中，mem_fun()是一个类的成员函数，并且在成员函数的名称后使用const关键字使其成为常量。
示例：使用const关键字和类的成员函数的程序
让我们考虑一个例子，来定义const关键字和类的成员函数。
class ABC
{
// define the access specifier
public:
// declare int variables
int A;
// declare member function as constant using const keyword
void fun () const
{
A = 0; // it shows compile time error
}
};
int main ()
{
ABC obj;
obj.fun();
return 0;
}
输出
上述代码会引发编译错误，因为fun()函数是类ABC的const成员函数，我们试图为其返回错误的数据成员’x’分配一个值。
6. 类的常量数据成员
数据成员类似于在类内声明的变量，但一旦数据成员被初始化，它就永远不会改变，甚至在构造函数或析构函数中也不会改变。常量数据成员使用const关键字在类内部的数据类型之前进行初始化。常量数据成员不能在声明时分配值，但可以在构造函数中分配值。
示例：使用const关键字与类的数据成员
/* create a program to demonstrate the data member using the const keyword in C++. */
#include
using namespace std;
// create a class ABC
class ABC
{
public:
// use const keyword to declare const data member
const int A;
// create class constructor
ABC ( int y) : A(y)
{
cout << " The value of y: " << y << endl;
}
};
int main ()
{
ABC obj( 10); // here 'obj' is the object of class ABC
cout << " The value of constant data member 'A' is: " << obj.A << endl;
// obj.A = 5; // it shows an error.
// cout << obj.A << endl;
return 0;
}
输出：
The value of y: 10
The value of constant data member 'A' is: 10
在上面的程序中，ABC类的对象obj调用ABC构造函数来打印y的值，然后打印常量数据成员’A’的值为10。但是当’obj.A’分配一个新值给’A’数据成员时，会显示编译时错误，因为A的值是常量且不可更改。
7. 常量对象
当我们使用const关键字创建一个对象时，在程序中对象的生命周期内，数据成员的值永远不会改变。常量对象也被称为只读对象。
语法
const class_name obj_name;
const 是一个关键字，用在上面语法中类对象名字之前，使它成为一个常量对象。
示例：我们来创建一个程序，使用C++编程语言中的常量对象。
#include
using namespace std;
class ABC
{
public:
// define data member
int A;
// create constructor of the class ABC
ABC ()
{
A = 10; // define a value to A
}
};
int main ()
{
// declare a constant object
const ABC obj;
cout << " The value of A: " << obj.A << endl;
// obj.A = 20; // It returns a compile time error
return 0;
}
输出
The value of A: 10
在上面的程序中，我们将A的值赋为10，编译器输出”The value of A: 10″，当我们将A的值赋为20时，该类的对象返回程序中的编译时错误。
使用const关键字计算圆的面积的程序
让我们考虑一个使用C++编程语言中的const关键字打印圆的面积的示例。
#include
using namespace std;
int main ()
{
// declare variables
int r;
const double PI = 3.14;
double result;
cout << " Input the radius of a circle: " << endl;
cin >> r;
result = PI * r * r;
cout << " The area of a circle is: " << result;
}
输出
Input the radius of a circle:
5
The area of a circle is: 78.5