【C语言】const 关键字详解

原创

LuckiBit

修改于 2024-12-07 17:25:54

38900

代码可运行

文章被收录于专栏：C语言C语言

运行总次数：0

代码可运行

C语言const关键字详解

const关键字在C语言中用于定义常量，提供只读的变量。这意味着一旦初始化，const变量的值不能再被修改。下面详细介绍const关键字的用法、作用以及其在不同上下文中的应用。

1. 基本概念

1.1 `const`关键字的基本用法

const关键字可以用于修饰基本数据类型、指针、函数参数等。它通过在变量声明前加上const关键字来使用。

示例

#include <stdio.h>

int main() {
    const int a = 10;  // a 是一个常量，不能被修改
    printf("a = %d\n", a);
    // a = 20;  // 错误：不能修改常量
    return 0;
}

输出结果

a = 10

1.2 `const`与#define的比较

#define：预处理器指令，用于定义宏，编译时替换。
const：编译器处理，提供类型安全的常量定义。

示例

#include <stdio.h>

#define PI_DEFINE 3.14
const float PI_CONST = 3.14;

int main() {
    printf("PI_DEFINE = %f\n", PI_DEFINE);
    printf("PI_CONST = %f\n", PI_CONST);
    return 0;
}

输出结果

PI_DEFINE = 3.140000
PI_CONST = 3.140000

2. `const`在指针中的应用

2.1 `const`修饰指针指向的内容

当const修饰指针指向的内容时，表示指针指向的内存内容不能被修改。

示例

#include <stdio.h>

int main() {
    int x = 10;
    const int *p = &x; // p 是指向常量的指针
    printf("x = %d\n", x);
    printf("*p = %d\n", *p);
    // *p = 20;  // 错误：不能通过指针修改指向的内容
    x = 20;  // 可以直接修改变量x的值
    printf("x = %d\n", x);
    printf("*p = %d\n", *p);
    return 0;
}

输出结果

x = 10
*p = 10
x = 20
*p = 20

2.2 `const`修饰指针本身

当const修饰指针本身时，表示指针的地址不能被修改。

示例

#include <stdio.h>

int main() {
    int x = 10;
    int *const p = &x; // p 是一个常量指针，指向的地址不能改变
    printf("x = %d\n", x);
    printf("*p = %d\n", *p);
    *p = 30; // 可以修改指针指向的内容
    printf("x = %d\n", x);
    printf("*p = %d\n", *p);
    // int y = 20;
    // p = &y; // 错误：不能修改常量指针的地址
    return 0;
}

输出结果

x = 10
*p = 10
x = 30
*p = 30

2.3 `const`修饰指针和指针指向的内容

可以同时修饰指针和指针指向的内容，表示指针的地址和指向的内容都不能被修改。

示例

#include <stdio.h>

int main() {
    int x = 10;
    const int *const p = &x; // p 是一个常量指针，指向的内容也是常量
    printf("x = %d\n", x);
    printf("*p = %d\n", *p);
    // *p = 30;  // 错误：不能修改指针指向的内容
    // int y = 20;
    // p = &y;   // 错误：不能修改常量指针的地址
    return 0;
}

输出结果

x = 10
*p = 10

3. `const`在函数参数中的应用

3.1 `const`修饰函数参数

const修饰函数参数可以防止函数内部修改传入的参数值，增加代码的安全性和稳定性。

示例

#include <stdio.h>

void foo(const int x) {
    printf("x = %d\n", x);
    // x = 20;  // 错误：不能修改const参数
}

int main() {
    foo(10);
    return 0;
}

输出结果

x = 10

3.2 `const`指针作为函数参数

可以将const指针作为函数参数，确保函数内部不能修改指针指向的内容。

示例

#include <stdio.h>

void printArray(const int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int array[5] = {1, 2, 3, 4, 5};
    printArray(array, 5);
    return 0;
}

输出结果

1 2 3 4 5

3.3 `const`返回类型

函数可以返回const类型，防止调用者修改返回值。

示例

#include <stdio.h>

const int* getPointer(const int *arr) {
    return arr;
}

int main() {
    int array[5] = {1, 2, 3, 4, 5};
    const int *p = getPointer(array);
    for (int i = 0; i < 5; i++) {
        printf("%d ", p[i]);
    }
    printf("\n");
    return 0;
}

输出结果

1 2 3 4 5

4. `const`与volatile的组合使用

const和volatile可以一起使用，表示一个变量是只读的，但可能会被外部因素修改，如硬件寄存器。

示例

#include <stdio.h>

volatile const int *p;

int main() {
    int x = 10;
    p = &x;
    printf("x = %d\n", *p);
    // *p = 20;  // 错误：不能通过指针修改指向的内容
    return 0;
}

输出结果

x = 10

5. `const`在数组中的应用

5.1 `const`修饰数组元素

可以使用const修饰数组元素，防止数组元素被修改。

示例

#include <stdio.h>

int main() {
    const int arr[] = {1, 2, 3};
    for (int i = 0; i < 3; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    // arr[0] = 10; // 错误：不能修改const数组的元素
    return 0;
}

输出结果

1 2 3

5.2 `const`修饰多维数组

可以使用const修饰多维数组，防止数组的任何维度被修改。

示例

#include <stdio.h>

int main() {
    const int matrix[2][2] = {{1, 2}, {3, 4}};
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    // matrix[0][0] = 10; // 错误：不能修改const多维数组的元素
    return 0;
}

输出结果

1 2 
3 4

6. `const`在结构体中的应用

6.1 `const`修饰结构体成员

可以使用const修饰结构体成员，防止结构体成员被修改。

示例

#include <stdio.h>

struct Point {
    const int x;
    const int y;
};

int main() {
    struct Point p = {10, 20};
    printf("Point: (%d, %d)\n", p.x, p.y);
    // p.x = 30; // 错误：不能修改const结构体成员
    return 0;
}

输出结果

Point: (10, 20)

6.2 `const`结构体指针

可以使用const修饰结构体指针，防止指针指向的结构体内容被修改。

示例

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void printPoint(const struct Point *p) {
    printf("Point: (%d, %d)\n", p->x, p->y);
    // p->x = 10; // 错误：不能修改const结构体指针指向的内容
}

int main() {
    struct Point p = {10, 20};
    printPoint(&p);
    return 0;
}

输出结果

Point: (10, 20)

7. `const`在联合体中的应用

7.1 `const`修饰联合体成员

可以使用const修饰联合体成员，防止联合体成员被修改。

示例

#include <stdio.h>

union Data {
    const int i;
    const float f;
};

int main() {
    union Data d = {10};
    printf("d.i = %d\n", d.i);
    // d.i = 20; // 错误：不能修改const联合体成员
    return 0;
}

输出结果

d.i = 10

8. `const`与字符串

8.1 `const`字符串

字符串字面量在C语言中是const char*类型，表示字符串内容是只读的，不能修改。

示例

#include <stdio.h>

int main() {
    const char *str = "Hello, World!";
    printf("str = %s\n", str);
    // str[0] = 'h'; // 错误：不能修改const字符串内容
    return 0;
}

输出结果

str = Hello, World!

8.2 `const`修饰字符数组

可以使用const修饰字符数组，防止数组内容被修改。

示例

#include <stdio.h>

int main() {
    const char str[] = "Hello, World!";
    printf("str = %s\n", str);
    // str[0] = 'h'; // 错误：不能修改const字符数组内容
    return 0;
}

输出结果

str = Hello, World!

总结

const关键字在C语言中用于定义常量，提供只读的变量。通过使用const，可以提高代码的可读性和安全性，防止不必要的修改。const可以修饰基本数据类型、指针、数组、结构体、联合体等，并且可以与volatile关键字组合使用。在实际编程中，合理使用const关键字，可以帮助我们编写出更加健壮和可靠的代码。

其他知识点

1. `const`修饰局部变量和全局变量

示例

#include <stdio.h>

const int globalVar = 100; // 全局常量

void foo() {
    const int localVar = 50; // 局部常量
    printf("localVar = %d\n", localVar);
}

int main() {
    foo();
    printf("globalVar = %d\n", globalVar);
    return 0;
}

输出结果

localVar = 50
globalVar = 100

2. `const`修饰静态变量

示例

#include <stdio.h>

void foo() {
    static const int staticVar = 20; // 静态常量
    printf("staticVar = %d\n", staticVar);
}

int main() {
    foo();
    return 0;
}

输出结果

staticVar = 20

3. `const`与内联函数

在C99标准中，可以将const关键字与内联函数结合使用，确保函数参数不被修改。

示例

#include <stdio.h>

inline void printValue(const int value) {
    printf("Value = %d\n", value);
}

int main() {
    int x = 10;
    printValue(x);
    return 0;
}

输出结果

Value = 10

4. `const`在函数返回值中的应用

可以将函数返回值声明为const，防止调用者修改返回的值。

示例

#include <stdio.h>

const int getValue() {
    return 42;
}

int main() {
    const int value = getValue();
    printf("Returned value = %d\n", value);
    // value = 50; // 错误：不能修改const返回值
    return 0;
}

输出结果

Returned value = 42

5. `const`在C++中的扩展

在C++中，const关键字的应用更加广泛，可以用于修饰成员函数、引用、迭代器等。

示例

#include <iostream>

class MyClass {
public:
    const int value;

    MyClass(int val) : value(val) {}

    void printValue() const {
        std::cout << "Value = " << value << std::endl;
    }
};

int main() {
    MyClass obj(10);
    obj.printValue();
    // obj.value = 20; // 错误：不能修改const成员变量
    return 0;
}

输出结果

Value = 10

6. `const`与指针的历史背景

在早期的C语言标准（如K&R C）中，const关键字并不存在。const关键字是从ANSI C（C89/C90）标准开始引入的，以提供更好的类型安全和代码可读性。它的引入允许程序员定义不可修改的变量，从而减少了意外修改变量的可能性，增加了代码的稳定性和可维护性。

通过了解const关键字的各种用法和应用场景，我们可以更好地编写高质量的C语言代码，确保代码的安全性和可维护性。

结束语

本节内容已经全部介绍完毕，希望通过这篇文章，大家对C语言const关键字有了更深入的理解和认识。
感谢各位的阅读和支持，如果觉得这篇文章对你有帮助，请不要吝惜你的点赞和评论，这对我们非常重要。再次感谢大家的关注和支持！

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

c 语言

c++

腾讯技术创作特训营S10

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

c 语言

c++

腾讯技术创作特训营S10

登录后参与评论

0 条评论

热度

【C语言】const 关键字详解

【C语言】const 关键字详解

C语言const关键字详解

1. 基本概念

1.1 const关键字的基本用法

示例

输出结果

1.2 const与#define的比较

示例

输出结果

2. const在指针中的应用

2.1 const修饰指针指向的内容

示例

输出结果

2.2 const修饰指针本身

示例

输出结果

2.3 const修饰指针和指针指向的内容

示例

输出结果

3. const在函数参数中的应用

3.1 const修饰函数参数

示例

输出结果

3.2 const指针作为函数参数

示例

输出结果

3.3 const返回类型

示例

输出结果

4. const与volatile的组合使用

示例

输出结果

5. const在数组中的应用

5.1 const修饰数组元素

示例

输出结果

5.2 const修饰多维数组

示例

输出结果

6. const在结构体中的应用

6.1 const修饰结构体成员

示例

输出结果

6.2 const结构体指针

示例

输出结果

7. const在联合体中的应用

7.1 const修饰联合体成员

示例

输出结果

8. const与字符串

8.1 const字符串

示例

输出结果

8.2 const修饰字符数组

示例

输出结果

总结

其他知识点

1. const修饰局部变量和全局变量

示例

输出结果

2. const修饰静态变量

示例

输出结果

3. const与内联函数

示例

输出结果

4. const在函数返回值中的应用

示例

输出结果

5. const在C++中的扩展

示例

输出结果

6. const与指针的历史背景

结束语

社区

活动

圈层

1.1 `const`关键字的基本用法

1.2 `const`与#define的比较

2. `const`在指针中的应用

2.1 `const`修饰指针指向的内容

2.2 `const`修饰指针本身

2.3 `const`修饰指针和指针指向的内容

3. `const`在函数参数中的应用

3.1 `const`修饰函数参数

3.2 `const`指针作为函数参数

3.3 `const`返回类型

4. `const`与volatile的组合使用

5. `const`在数组中的应用

5.1 `const`修饰数组元素

5.2 `const`修饰多维数组

6. `const`在结构体中的应用

6.1 `const`修饰结构体成员

6.2 `const`结构体指针

7. `const`在联合体中的应用

7.1 `const`修饰联合体成员

8. `const`与字符串

8.1 `const`字符串

8.2 `const`修饰字符数组

1. `const`修饰局部变量和全局变量

2. `const`修饰静态变量

3. `const`与内联函数

4. `const`在函数返回值中的应用

5. `const`在C++中的扩展

6. `const`与指针的历史背景