C++中的const关键字

在本文中，讨论了在C++中找到的 const 关键字的各种功能。每当const 关键字附加到任何方法（）、变量、指针变量和类的对象时，它都会阻止特定的对象/方法（）/变量修改其数据项值。

常量变量：

常量变量的声明和初始化有一定的规则：

• const 变量在赋值时不能保持未初始化状态。
• 它不能在程序中的任何地方赋值。
• 需要在声明常量变量时为常量变量提供显式值。

下面是演示上述概念的 C++ 程序：

C++

// C++ program to demonstrate the
// the above concept
#include 
using namespace std;
 
// Driver Code
int main()
{
 
    // const int x;  CTE error
    // x = 9;   CTE error
    const int y = 10;
    cout << y;
 
    return 0;
}

输出：

10

错误声明面临的错误：如果您尝试初始化 const 变量而不分配显式值，则会生成编译时错误 (CTE)。

带有指针变量的 Const 关键字：

指针可以用 const 关键字声明。因此，有三种可能的方式将 const 关键字与指针一起使用，如下所示：

当。。。的时候 指针变量指向一个常量值：

句法：

const data_type* var_name;

下面是实现上述概念的 C++ 程序：

C++

// C++ program to demonstrate the
// above concept
#include 
using namespace std;
 
// Driver Code
int main()
{
    int x{ 10 };
    char y{ 'M' };
 
    const int* i = &x;
    const char* j = &y;
 
    // Value of x and y can be altered,
    // they are not constant variables
    x = 9;
    y = 'A';
 
    // Change of constant values because,
    // i and j are pointing to const-int
    // & const-char type value
    // *i = 6;
    // *j = 7;
 
    cout << *i << " " << *j;
}

输出：

9 A

说明：在上面的例子中，i 和 j 是两个指针变量，分别指向一个内存位置 const int-type 和 char-type，但是存储在这些相应位置的值可以像我们上面所做的那样进行更改。

否则，会出现以下错误：如果我们试图修改常量变量的值。

当 const 指针变量指向值时：

句法：

data_type* const var_name;

下面是演示上述概念的示例：

C++

// C++ program to demonstrate the
// above concept
#include 
using namespace std;
 
// Driver Code
int main()
{
    // x and z non-const var
    int x = 5;
    int z = 6;
 
    // y and p non-const var
    char y = 'A';
    char p = 'C';
 
    // const pointer(i) pointing
    // to the var x's location
    int* const i = &x;
 
    // const pointer(j) pointing
    // to the var y's location
    char* const j = &y;
 
 
    // The values that is stored at the memory location can modified
    // even if we modify it through the pointer itself
    // No CTE error
    *i = 10;
    *j = 'D';
 
    // CTE because pointer variable
    // is const type so the address
    // pointed by the pointer variables
    // can't be changed
    // *i = &z;
    // *j = &p;
 
    cout << *i << " and " << *j
        << endl;
    cout << i << " and " << j;
 
    return 0;
}

输出：

9 and M
0x7ffd1ff8f830 and MC

说明：对应的指针变量 i 和 j 中存储的值是可以修改的，但是常量指针变量指出的 x 和 y 的对应值存储的位置是不可修改的。

否则，将出现以下错误：指针变量是 const 并指向存储 x 和 y 的位置，如果我们尝试更改地址位置，那么我们将面临错误。

当 const 指针指向 const 变量时：

句法：

const data_type* const var_name;

下面是演示上述概念的 C++ 程序：

C++

// C++ program to demonstrate
// the above concept
#include 
using namespace std;
 
// Driver code
int main()
{
    int x{ 9 };
 
    const int* const i = &x;
   
    // *i=10;  
    // The above statement will give CTE
    // Once Ptr(*i) value is
    // assigned, later it can't
    // be modified(Error)
 
    char y{ 'A' };
 
    const char* const j = &y;
   
    // *j='B';
    // The above statement will give CTE
    // Once Ptr(*j) value is
    // assigned, later it can't
    // be modified(Error)
 
    cout << *i << " and " << *j;
 
    return 0;
}

输出：

9 and A

说明：这里，const 指针变量指向const 变量。因此，您既不能更改 const指针变量 (*P)，也不能更改该指针变量 (*P)指向的位置处存储的值。

否则会出现如下错误：这里的指针变量和指针变量指向的位置都是const所以如果修改其中任何一个都会出现如下错误：

通过常量参数的值的函数造成误差的非const参数：传递常量参数值的函数的非const参数无效它给你一个编译时错误。

下面是演示上述概念的 C++ 程序：

C++

// C++ program to demonstrate
// the above concept
#include 
using namespace std;
 
int foo(int* y)
{
    return *y;
}
 
// Driver code
int main()
{
    int z = 8;
    const int* x = &z;
    cout << foo(x);
    return 0;
}

输出：将出现仿佛const的值被传递给函数的任何非const参数，那么就会出现下面的编译时间错误的编译时间错误：

简而言之，上述讨论可以总结如下：

1. int value = 5;         // non-const value

2. const int *ptr_1 = &value;      // ptr_1 points to a “const int” value, so this is a pointer to a const value.

3. int *const ptr_2 = &value;        // ptr_2 points to an “int”, so this is a const pointer to a non-const value.

4. const int *const ptr_3 = &value;   // ptr_3 points to a “const int” value, so this is a const pointer to a const value.

常量方法：

与成员函数和成员函数参数一样，类的对象也可以声明为const 。声明为 const 的对象无法修改，因此只能调用 const成员函数，因为这些函数确保不会修改对象。

句法：

const Class_Name Object_name;

• 当一个函数被声明为 const 时，它可以被任何类型的对象、const 对象和非常量对象调用。
• 每当对象被声明为 const 时，都需要在声明时对其进行初始化。但是，只有在构造函数的帮助下才能在声明时进行对象初始化。

常量函数声明有两种方式：

普通常量函数声明：

const void foo()
{
   //void foo() const Not valid
}                  
int main()
{
   foo(x);
}  

类的 const成员函数：

class
{
   void foo() const
   {
       //.....
   }
}

下面是一个常量函数的例子：

C++

// C++ program to demonstrate the
// constant function
#include 
using namespace std;
 
// Class Test
class Test {
    int value;
 
public:
    // Constructor
    Test(int v = 0)
    {
        value = v;
    }
 
    // We get compiler error if we
    // add a line like "value = 100;"
    // in this function.
    int getValue() const
    {
        return value;
    }
     
    // a nonconst function trying to modify value
    void setValue(int val) {
        value = val;
    }
};
 
// Driver Code
int main()
{
    // Object of the class T
    Test t(20);
 
    // non-const object invoking const function, no error
    cout << t.getValue() << endl;
     
    // const object
      const Test t_const(10);
   
    // const object invoking const function, no error
    cout << t_const.getValue() << endl;
   
    // const object invoking non-const function, CTE
    // t_const.setValue(15);
     
    // non-const object invoking non-const function, no error
    t.setValue(12);
     
    cout << t.getValue() << endl;
 
    return 0;
}

输出：

20

如果您尝试从 const 对象调用非常量函数，则会出现以下错误

常量函数参数和返回类型：

一个函数()参数和 函数()的返回类型可以声明为常量。 无法更改常量值，因为任何此类尝试都会产生编译时错误。

下面是实现上述方法的 C++ 程序：

C++

// C++ program to demonstrate the
// above approach
#include 
using namespace std;
 
// Function foo() with variable
// const int
void foo(const int y)
{
    // y = 6; const value
    // can't be change
    cout << y;
}
 
// Function foo() with variable int
void foo1(int y)
{
    // Non-const value can be change
    y = 5;
    cout << '\n'
         << y;
}
 
// Driver Code
int main()
{
    int x = 9;
    const int z = 10;
   
    foo(z);
    foo1(x);
 
    return 0;
}

输出：

10
5

说明：将显示以下错误：

• // y = 6;不能更改或修改 const 值。

对于 const 返回类型：函数() 的返回类型是 const，因此它向我们返回一个 const 整数值。下面是实现上述方法的 C++ 程序：

C++

// C++ program for the above approach
#include 
using namespace std;
 
const int foo(int y)
{
    y--;
    return y;
}
 
int main()
{
    int x = 9;
    const int z = 10;
    cout << foo(x) << '\n'
         << foo(z);
 
    return 0;
}

输出：

8
9

没有什么实质性的问题，通过const或非const变量的函数，因为这会被函数返回的值会自动保持恒定。由于函数的参数是非常量的。

对于const 返回类型和const 参数：这里，函数的返回类型和参数都是const 类型。下面是实现上述方法的 C++ 程序：

C++

// C++ program for the above approach
#include 
using namespace std;
 
const int foo(const int y)
{
    // y = 9; it'll give CTE error as
    // y is const var its value can't
    // be change
    return y;
}
 
// Driver code
int main()
{
    int x = 9;
    const int z = 10;
    cout << foo(x) << '\n'
         << foo(z);
 
    return 0;
}

输出：

9
10

说明：这里，const 和非const 值都可以作为const 参数传递给函数，但是我们不能更改传递的变量的值，因为参数是const。否则，我们将面临如下错误：

// y=9;它会给出编译时错误，因为 y 是 const var 它的值不能改变。

想要从精选的视频和练习题中学习，请查看C++ 基础课程，从基础到高级 C++ 和C++ STL 课程，了解基础加 STL。要完成从学习语言到 DS Algo 等的准备工作，请参阅完整的面试准备课程。