6.3 常类型

6.3 常类型

在编程中，使用 const 关键字可以定义常量类型，表示该变量或对象的值不能被修改。这在确保程序的安全性和稳定性方面非常有用。下面将详细讲述常类型的各种用法及其特性。

6.3.1 一般常量

一般常量是指简单类型的常量，如整型、浮点型等。使用 const 关键字可以在类型说明符之前或之后定义常量。

---

2024/6/27日补充

我的理解：

就是什么变量定义成const就不可以更改值了。 这个功能可以用到安全方面防止外部修改内部数据。学到了

---

定义常量

定义常量的格式如下：

const int x = 2;

或者

int const x = 2;

这两种写法是等价的，都是定义了一个值为2的整型常量 x。

定义常数组

常数组是指数组中的元素都是常量，不能被修改。定义格式如下：

const int a[5] = {1, 2, 3, 4, 5};

这里，数组 a 的每个元素都是 int 类型的常量。

示例

#include <iostream>
using namespace std;

int main() {
    const int m = 15;
    // m = 18; // 错误，m 是常量，不能被修改

    const int x = 2;
    int const y = 2; // 等价于 const int y = 2;

    const int a[5] = {1, 2, 3, 4, 5};
    // a[0] = 10; // 错误，a 的元素是常量，不能被修改

    return 0;
}

6.3.2 常对象

常对象是指对象本身是常量，不能修改其成员变量。定义常对象的格式如下：

const 类名 对象名(初值);

示例

class A {
public:
    A(int i, int j) : x(i), y(j) {}
    int x, y;
};

const A a1(3, 4);
A const a2(8, 19);

int main() {
    // a1.x = 5; // 错误，a1 是常对象，成员变量不能被修改
    // a2.y = 20; // 错误，a2 是常对象，成员变量不能被修改

    return 0;
}

6.3.3 常指针和常引用

常指针和常引用的使用稍微复杂一些，有两种不同的情况：常量指针和指向常量的指针。

常量指针

常量指针表示指针的地址值是常量，不能修改其指向，但可以修改其指向的数据。定义格式如下：

类型* const 指针名 = 初值;

指向常量的指针

指向常量的指针表示指针所指向的数据是常量，不能修改，但指针本身的地址值可以修改。定义格式如下：

const 类型* 指针名 = 初值;

示例

#include <iostream>
using namespace std;

int main() {
    char s1[] = "double";
    char s2[] = "int";

    char* const p1 = s1; // p1 是常量指针，不能修改指针的地址值
    const char* p2 = s2; // p2 是指向常量的指针，不能修改指向的数据

    // p1 = s2; // 错误，p1 是常量指针，地址值不能修改
    p2 = s1; // 合法，可以修改 p2 的地址值

    p1[0] = 'D'; // 合法，可以修改 p1 指向的数据
    // p2[0] = 'I'; // 错误，p2 指向的数据是常量，不能修改

    return 0;
}

6.3.4 常成员函数

常成员函数是使用 const 关键字定义的成员函数，表示该函数不会修改对象的成员变量。只有常成员函数可以被常对象调用。

---

2024/6/28日补充

今天在写编译原理课程设计在考虑显示DFA信息的函数时用这个的时候发现忘记了怎么写。

---

定义常成员函数

常成员函数的定义格式如下：

类型 函数名(参数表) const;

示例

#include <iostream>
using namespace std;

class R {
public:
    R(int r1, int r2) : R1(r1), R2(r2) {}
    void print();
    void print() const;
private:
    int R1, R2;
};

void R::print() {
    cout << R1 << ":" << R2 << endl;
}

void R::print() const {
    cout << R1 << ";" << R2 << endl;
}

int main() {
    R a(5, 4);
    a.print(); // 调用非常成员函数

    const R b(20, 52);
    b.print(); // 调用常成员函数

    return 0;
}

在这个例子中，print() 函数被重载，一种是普通成员函数，另一种是常成员函数。常对象 b 只能调用常成员函数。

6.3.5 常数据成员

常数据成员是指类中的某些数据成员是常量，必须在构造函数的初始化列表中进行初始化。

示例

#include <iostream>
using namespace std;

class A {
public:
    A(int i) : a(i), r(a) {}
    void print() const {
        cout << a << ":" << r << endl;
    }
private:
    const int a;
    const int& r;
    static const int b;
};

const int A::b = 10;

int main() {
    A a1(100);
    A a2(0);
    a1.print();
    a2.print();

    return 0;
}

在这个例子中，A 类有三个常数据成员：a 是常整型变量，r 是常整型引用，b 是静态常整型变量。在构造函数中，a 和 r 使用初始化列表进行初始化。

通过以上对常类型的详细介绍，希望能够帮助读者更好地理解和使用 const 关键字，提高程序的安全性和稳定性。