const用法 C语言

const的五种用法包括：
1. const修饰变量，即常量。

这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。

2. const修饰指针，常用来限制指针所指向的内容不被修改。

有两种情况：const char * p或char const *p，p指向的内容（*p）不能修改；char* const p，表示p不能改变，但是p指向的内容（*p）可以改变。

3. const修饰函数，有三种情况：const修饰返回值（放在最前），表示返回的值不能修改；const修饰形参（中间位置），表示在函数体内，该形参不能修改；const修饰函数（放在最后），该形式只用于成员函数，表示函数内，成员变量不能修改。

4. const修饰对象，const对象只能调用const成员函数，不能调用普通函数。

非const对象，既可以调用普通成员函数，也可以调用const成员函数。

5. 用来声明常类型，常类型的变量或对象的值是不能被更新的。

定义或说明常类型时必须进行初始化。

以上就是const的五种用法，在使用时需要根据实际需求进行选择。

c语言中的const的作用及解析
在 C 语言中，const 关键字可以用来修饰变量、函数参数和函数返回值，其主要功能是限制变量或参数的修改权限，只允许读取。

const 修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。

const 的作用主要包括以下几个方面:
1. 定义 const 常量:const 定义的常量具有不可变性，可以在程序中保存常数，比如定义一个 const int 类型的常量，表示一个固定的整数。

2. 避免意义模糊的数字出现：在使用变量或参数时，如果变量或参数的名称与其所表示的含义不相关，会导致程序难以理解和维护。

const 关键字可以用来避免意义模糊的数字出现，比如在一个函数中定义一个 const int 类型的参数，表示该参数是一个常量，不能修改。

3. 提高程序的健壮性:const 关键字可以用来保护被修饰的东西，防止意外的修改，增强程序的健壮性。

比如在一个函数中定义一个 const int 类型的参数，如果在函数体内修改了该参数的值，会导致程序崩溃或产生不可预料的结果。

4. 节省空间:const 定义的常量在程序运行期间只有一份拷贝，不需要分配额外的内存空间，可以节省内存空间。

5. 提高程序的效率:const 关键字可以用来限制变量或参数的修改权限，可以避免不必要的内存分配和读写操作，从而提高程序的效率。

const 关键字在 C 语言中有着重要的作用，可以用来定义常量、保护变量或参数、提高程序的健壮性和效率等。

正确合理地使用 const 关键字可以提高程序的质量和维护性。

C语言的const使用方法C语言的const使用方法C语言是一个有结构化程序设计、具有变量作用域(variable scope)以及递归功能的过程式语言。

以下是店铺为大家搜索整理的C 语言的const使用方法，希望能给大家带来帮助!const是一个C语言的关键字，它限定一个变量不允许被改变。

使用const在一定程度上可以提高程序的安全性和可靠性。

const的使用是c语言中一个比较微妙的地方，请看下面几个问题。

问题：const变量和常量为什么下面的例子在使用一个const变量来初始化数组，ANSI C 的编译器会报告一个错误呢?const int n = 5;int a[n];答案与分析:1)这个问题讨论的是“常量”与“只读变量”的区别。

常量肯定是只读的，例如5，“abc”，等，肯定是只读的，因为常量是被编译器放在内存中的只读区域，当然也就不能够去修改它。

而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。

C语言关键字const就是用来限定一个变量不允许被改变的修饰符(Qualifier)。

上述代码中变量n被修饰为只读变量，可惜再怎么修饰也不是常量。

而ANSI C规定数组定义时长度必须是“常量”，“只读变量”也是不可以的。

2) 注意：在ANSI C中，这种写法是错误的，因为数组的大小应该是个常量，而const int n,n只是一个变量(常量 != 不可变的变量，但在标准C++中，这样定义的是一个常量，这种写法是对的)，实际上，根据编译过程及内存分配来看，这种用法本来就应该是合理的，只是ANSI C对数组的规定限制了它。

3) 那么，在ANSI C 语言中用什么来定义常量呢?答案是enum类型和#define宏，这两个都可以用来定义常量。

问题：const变量和 const 限定的内容下面的代码编译器会报一个错误，请问，哪一个语句是错误的呢?typedef char * pStr;char string[4] = "abc";const char *p1 = string;const pStr p2 = string;p1++;p2++;答案与分析：问题出在p2++上。

c语言中const的含义和意思C语言中，const关键字用于指定程序中的常量。

其含义是该变量只能被初始化一次，且在初始化后不能被修改。

也就是说，const修饰的变量是只读的，不能再被改变。

const关键字可以修饰变量、函数、指针等。

下面将分别介绍它们的含义和用法：1. const修饰变量在C语言中，可以使用const关键字来定义常量。

例如：const int MAX_NUM = 100;这里将MAX_NUM定义为一个常量，它的值不能再被修改。

2. const修饰函数在C语言中，我们可以使用const关键字来修饰函数，指明该函数不会修改任何参数的值。

例如：int sum(const int* arr, int n){int s = 0;for(int i=0;i<n;i++){s += arr[i];}return s;}在上面的例子中，我们使用const修饰了函数的第一个参数（指针），这意味着函数不会修改指针所指的内容。

3. const修饰指针在C语言中，const还可以用来修饰指针。

例如：const int* p;这个例子中，p是一个指向int类型的指针，但是它指向的内容是只读的，不能被修改。

另一个例子：int* const p;在这个例子中，p是一个指向int类型的指针，但是它本身是不可变的，不能再指向其他的地址。

总之，在C语言中，使用const可以帮助我们在编写程序时更加安全地使用变量、函数和指针。

它可以防止数据被随意修改，保证程序的正确性。

c语言中const的用法c语言中const有着重要的作用，它可以用来确保变量值在执行过程中不被意外改变，避免程序出现混乱的状态。

在编程中，const 指令可以提供一种方式确保变量的值在执行过程中不会被改变。

以下是关于c语言中const的一些用法。

1.义常量const关键字可以用来定义常量，其中的值在程序执行过程中不会发生变化。

例如，定义一个PI常量，其值为3.14：const double PI = 3.14;这就表明PI的值不可以被修改，否则程序将会报错。

定义常量时，变量的声明类型和值要在定义时就确定，之后不能再改变。

2.明指针const关键字也可以用来声明指针，用来防止指针指向的内容被意外修改。

例如：int a = 10;const int* p = &a;这里声明的指针p是const的，它指向的内存空间在程序运行过程中不能被修改，否则程序会报错。

3.定函数参数c语言中const也可以用于在函数声明和定义中限定函数参数。

在函数定义时，可以使用const将参数变量声明为只读，因此它的值在函数中不能改变。

例如：void foo(const int a){a = 10; // error，编译会报错}4. const成员函数const有时也可以用于声明成员函数，表明其为只读操作，不能修改成员变量。

const成员函数不能修改类中数据成员和静态成员，但是可以调用非const成员函数。

例如：class Foo{public:void nonConstFunc();void constFunc() const;private:int m_value;};5. const_castconst_cast也是一种常用的表达式，它可以用于在不同类型之间转换，也可以用于去除const属性。

例如：int a = 10;const int* p = &a;int* p1 = p; // errorint* p2 = const_cast<int*>(p); //const int*转换成int* 以上就是围绕c语言中const的用法做的介绍，它可以用于定义常量、声明指针、限定函数参数和const成员函数等。

C语言中的const一直是C语言初学者心中的痛，这是因为const在不同位置有不同作用，在不同情景有不同角色。

这让初学者摸不清头脑。

今天，和大家一起研究一下const，让它的每个角色都“深入人心”！====================================================================== ========================情景一：最简单的const用法#include<stdio.h>int main(){int const a;a=5;printf("a=%d\n",a);return 0;}如果编译这个c文件，就会报错：1071.c: In function ‘main’:1071.c:5: error: assignment of read-only variable ‘a’显而易见，这是const在搞鬼，因为声明了const的变量是不能修改的！如果将源代码修改为如下这样，就没有问题了！#include<stdio.h>int main(){int const a=5;printf("a=%d\n",a);return 0;}总结：const声明的变量必须要进行初始化赋值，如果错过这个机会，以后再想给const的变量赋值，可就没门了！切记～PS：int const和const int是一回事，“颠倒写”都是可以的。

以后遇到了别犯晕，呵呵。

但是，还是要留个心眼，当const和指针搀和到一起时，这个“颠倒写”的规律可未必成立。

====================================================================== ========================情景二：发明const为了什么？在const诞生之前，开发者一直使用#define V AR 100来定义一些有特殊用途的类常量，不过这样定义是存在一些劣势的。

c语言const用法
const 关键字是C语言中一个重要的常量声明修饰符，它常常用于声明、定义
一个常量，它完全一静态类型，也就是说变量的值在声明定义之后不能改变。

1、const用来修饰基本的数据类型，如int、float等，这样声明的变量在运行
程序时不会改变。

例如：const int m=100;
2、对于指针也可以使用const关键字，当使用const修饰指针时，可以将指针
指向的内存地址保护起来，防止被意外改变，一般来说所指向的内存地址不允许修改，如果需要修改，需要使用带const修饰符的指针。

例如：int a=100;const int *p=&a;//p所指向的为a的地址，不可被改变
3、const也可以用来修饰类对象及函数，当const修饰类时，表示该类不能被
修改，因此它可以用于类的成员函数中，以保证类的派生类不会改变其它成员函数的行为。

例如：class A
{
public:
void foo(){}
void bar()const{}
private:
int m_data;
};
4、const也可以用来保护函数的参数，当参数加上const后，参数不能被修改，使用这种方法可以对参数传递的内容更加安全。

例如：void foo(const int a) //a值不会被改变
总之，const修饰符具有非常重要的作用，它可以在一定程度上提高C程序质量、增强语言功能，防止一些意外改变，应该积极地采用。

C++语言中con‎st关键字用‎法总结一、const是‎什么在C/C++ 语言中，const关‎键字是一种修‎饰符。

所谓“修饰符”，就是在编译器‎进行编译的过‎程中，给编译器一些‎“要求”或“提示”，但修饰符本身‎，并不产生任何‎实际代码。

就const 修饰符而言，它用来告诉编‎译器，被修饰的这些‎东西，具有“只读”的特点。

在编译的过程‎中，一旦我们的代‎码试图去改变‎这些东西，编译器就应该‎给出错误提示‎。

所以，const修‎饰符的作用主‎要是利用编译‎器帮助我们检‎查自己代码的‎正确性。

我们使用co‎n st在源码‎中标示出“不应该改变”的地方，然后利用编译‎器，帮助我们检查‎这些地方是否‎真的没有被改‎变过。

如果我们不小‎心去修改了这‎些地方，编译器就会报‎错，从而帮助我们‎纠正错误。

使用const和‎不使用con‎s t，对于最终编译‎产生的代码并‎没有影响。

虽然cons‎t对于最终代‎码没有影响，但是尽可能使‎用const‎，将帮助我们避‎免很多错误，提高程序正确‎率。

二、const可‎以修饰哪些对‎象在上面已经提‎到过了，const是‎一种修饰符，那它可以作为‎哪些对象的修‎饰符呢？下面列举了一‎些C/C++中用到con‎s t的地方。

1，const变‎量2，const指‎针3，const引‎用4，const类‎5，类的cons‎t成员变量6，类的cons‎t成员函数7，const修‎饰函数的形参‎与返回值下面我们分别‎讨论上面几种‎情况下，const的‎用法。

三、const与‎变量当一个变量被‎c onst修‎饰后，具有以下几个‎特点：1）该变量只能读‎取不能修改。

（编译器进行检‎查）2）定义时必须初‎始化。

3）C++中喜欢用co‎n st来定义‎常量，取代原来C风‎格的预编译指‎令defin‎e。

1 const int var; // Error:常量变量"var"需要初始化设‎定项2 const int var1 = 42;3 var1 = 43; // Error：表达式必须是‎可以修改的左‎值上面代码中第‎一行和第三行‎都有错误，注释便是编译‎器给出的错误‎提示。

c语言const用法const是C语言中一个重要的关键字，它的主要作用是用来声明常量。

const声明的常量有以下几种类型：数字、字符、字符串、布尔值和空值。

由于const在C语言中扮演着重要的角色，因此使用const的用法也非常重要。

以下是关于const用法的详细介绍：1. const用法的基本格式const声明常量的基本格式如下：const [类型] [常量名] = [初始值]；在上述格式中，[类型]表示将要声明的常量的数据类型，[常量名]表示将要声明的常量的变量名，[初始值]表示将要声明的变量的初始值。

例如：const int data = 10;2. const用法的范围const声明的常量的作用域在声明它的函数（或文件）内有效，即只在声明它的函数（或文件）内可用。

例如：const int data = 10;int func() {tprintf(data = %ddata); //以}3. const用法的用处const声明的常量有以下三个用处：（1）用于防止意外的变量修改。

举个例子，如果声明一个常量保存程序运行时间，那么就可以将其定义为const，以防止误操作导致时间出乎预料地加快或减慢；（2）用于标识静态变量和动态变量，以便在编程的程序中更好的管理变量；（3）用于提高程序的可靠性，使程序可以更好地针对性的检测和调试。

4. const用法的注意事项除了上述提到的const用法，还有以下几点需要注意：（1）在C语言中，const常量一般定义在文件头部，以便在整个文件中使用。

（2）const用法不一定必须指定变量的类型，只要声明时已经确定类型，也可以只声明常量。

（3）在const声明的常量中，只能使用常量或者枚举值，不能使用变量或表达式。

（4）const声明的常量不能修改，就算在函数中使用指针类型也不能修改其中的值。

以上就是C语言const用法的详细介绍。

从上述内容来看，const 用法具有防止意外的变量修改的功能，使程序更具有可靠性。

C语言关键字const用法C语言关键字const用法导语：C是高级语言，它把高级语言的基本结构和语句与低级语言的实用性结合起来。

下面就由店铺为大家介绍一下C语言关键字const用法，欢迎大家阅读!c语言中的const">C语言中的constconst是C语言中保留的一个关键字，用来定义常量，如果一个变量被const修饰，那么它的值就不能被改变。

使用符号常量写出的代码更容易维护；一些指针常常是边读边移动，而不是边写边移动；许多编程规范对于函数参数会强制要求只读不写，在这些情况下，都需要借助const实现。

那么有些人会问，C语言中不是已经存在#define了吗，为什么还要使用const呢？相比于#define，const修饰符有如下优势：1、const能够使编译器进行类型检查，而预编译指令#define只是简单的对值进行替换。

2、 const可以保护被修饰的变量等，防止变量因为意外被修改，从而增强程序的健壮性。

3、编译器通常不为普通const常量分配存储空间，而是将他们保存在符号表中，这使得它成为了一个编译期间的常量，没有了存储于内存操作，使得它的效率很高。

const用法const最常见的用法就是作为数组的边界和switch分情况标号，分类如下：常变量： const + 类型说明符 + 变量名常引用： const + 类型说明符 + &引用名常对象：类名 + const 对象名常成员函数：类名::fun(形参) + const常数组：类型说明符 + const 数组名[大小]常量指针：const + 类型说明符* 指针名或者类型说明符+const *指针名首先提示的是：在常变量（const + 类型说明符 + 变量名）、常引用（const + 类型说明符 + &引用名）、常对象（类名 + const 对象名）、常数组（类型说明符+ const 数组名[大小]），const”与“类型说明符”或“类名”（其实类名是一种自定义的类型说明符）的位置可以互换。

（1）可以定义const 常量（2）const 可以修饰函数的参数、返回值.详细内容：1、什么是const常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。

（当然，我们可以偷梁换柱进行更新：）2、为什么引入constconst 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

3、cons有什么主要的作用（1）可以定义const常量，具有不可变性。

例如：const int Max=100; int Array[Max];（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。

例如：void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改；（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。

同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。

还是上面的例子，如果在函数体内修改了i，编译器就会报错；例如：void f(const int i) { i=10;....void f(int i) {......} ....} ....};（6）可以节省空间，避免不必要的内存分配。

例如：#define PI ....double i=Pi; ...}；这样，在调用函数Fun时就不能修改类里面的数据（9）在另一连接文件中引用const常量extern const int i;抽象const对于关键字const的解释有好几种方式，最常见的就是位元const 和抽象const。

下面我们看一个例子：class A { public: ...... A f(const A& a); ...... }; 如果采用抽象const进行解释，那就是f函数不会去改变所引用对象的抽象值，如果采用位元const进行解释，那就成了f函数不会去改变所引用对象的任何位元。

const的用法1、用作变量修饰符const可以在定义变量时作为修饰符，用来表示该变量不可修改。

需要注意的是：const修饰某个变量时，总是限定const所处位置的右侧。

例如代码 const int nc = 0; 用来声明一个整型常量 nc，这个常量不可更改。

假如执行下面的语句int main(int argc, char* argv[]){const int nc = 0;nc = 1; //修改了常量 nc，不能编译过去return 0;}编译时会报错“l-value specifies const object”需要说明的是，声明变量时，const int nc = 0 与 i nt const nc = 0 意义是一样的，个人推荐使用后面一种 i nt const nc = 0 ，这样别人在看代码的时候，可以先很快的知道 nc 是常量。

大家看完我上面所说的，可能更好的理解下面我所说的int const *p 与 int *const p 的区别。

前面我也说了，const 是修饰它位置右侧的，所以 int const *p 主要是修饰*p 为常量，也就是说*p 的值不能改变；而 int *const p 则是修饰 p 为常量，也就是说指针 p 为一个常量指针。

可以根据下面的代码来加深印象int main(int argc, char* argv[]){int n = 0;int m = 1;int const *p1 = &n;int * const p2 = &n;p1 = &m;(*p1) = m; //这里编译出错，错误为“error C2166: l-value specifies const object”p2 = &m; //这里编译出错，错误为“error C2166: l-value specifies const object”(*p2) = m;return 0;}执现在大家该明白了 int const *p 与 int *const p 两者之间的区别了吧。

const在c语言中的用法举例
1. 嘿，你知道不，const 可以用来定义常量呢！比如说，“const int MAX_VALUE = 100;”，这就像给一个数字挂上了“不许变”的牌子，多厉害呀！
2. 哇塞，const 还能防止你不小心修改不该动的变量哟！就像设置了一道保护墙，“const char MESSAGE = "Hello World!";”，它可就稳稳地在那啦！
3. 哎呀呀，你想想看，要是没有 const，你的程序是不是可能会变得乱糟糟的呀！比如定义个“const double PI = ;”，这多明确呀，就是圆周率嘛，不能乱改的呢！
4. 嘿，const 在指针上也有大用处呢！“const int ptr;”，这就表示通过这个指针不能修改指向的值，很神奇吧！
5. 哇哦，你再看看这个，const 可以让你的函数参数更规范呢！就像“void myFunction(const int value);”，这就表示在函数里不能随便改这个参数的值哟！
6. 哟呵，const 能避免很多潜在的错误呢！就好比你要走一条路，const 给你划清了界限，像“const std::string NAME = "John";”，多清晰呀！
7. 哈哈，const 简直就是 C 语言里的小宝贝呀！它能让你的代码更可靠更稳定哦！比如“const float GRAVITY = ;”，可别乱动这个重力加速度的值
呀！我的观点就是，const 在 C 语言中的用法真的超级重要，能让我们的编程之路走得更顺畅呀！。

const在c语言中的用法在C语言中，const是一个用于限定定义变量或函数表达式类型的修饰符，其意义是变量或表达式一旦被const修饰，就意味着该变量的值或表达式的值不可被改变。

1. const的定义const修饰符的本意是"read-only"，也就是常量，它使用最主要的作用是引用非变量可被改变的值，用来显示为可被信任或只读的值。

可用于修饰全局变量以及局部变量，以及函数参数、函数返回值以及指针类型。

2. const的作用（1）保护定义的变量不允许被改变，确保程序的稳定性和安全性。

（2）const修饰可以有效的防止程序出现意外的错误。

（3）使用const可以有效地减少编程过程中的无用的编译和修改操作。

（4）使用const等修饰符可以易于理解和调试程序。

3. const的用法（1）变量修饰：使用const关键字修饰变量，这个变量及其值就无法被改变了。

例如，int const a = 10;a = 20; //运行出错（2）函数修饰：将定义函数的参数、指针以及返回值用const进行修饰，使得这些修饰的参数、指针以及返回值甚至在函数内部也处于只读状态。

例如，int const * checkData(int const *data);4. const的特点（1）const的作用域：const只在声明时存在，而不像#define那样会一直存在到程序结束，并且一个定义的实体，和在其他地方使用#define 定义常量不同，它只在声明和定义的一段语句有效，到了这段代码结束就失效。

（2）使用const可以避免定义无用的变量。

（3）const有利于代码的可维护性，使得代码更容易维护和调试，也有助于降低重大的程序错误的发生。

1.const 用于定义常量，定义时必须进行初始化，一经定义不能修改。

2.const用作函数参数：1）指针参数：const 在* 的左边，表示该指针的数据不能改变，但是地址可以改变。

例如：void fun(const int *p){*p = 10; //非法，不能改变指针p的数据int num(20);p = &num; //合法，可以改变p指向的地址，同时改变了p的数据，此时*p = 20}const 在* 的右边，表示该指针的地址不能改变，但是数据可以改变。

例如：void fun(int * const p){*p = 10; //合法，改变了指针p的数据int num(20);p = &num; //非法，不能改变p指向的地址}2）引用参数：const 作为引用参数时，只可以将其值赋给其他变量，不能修改其数值。

例如：void fun(const int &p){int i;i = p; //合法，将p的数值赋给了变量ip = 10; //非法，不能改变p的数值}3.const 用作类的成员函数1）const 修饰类的成员函数时，必须写在函数的后面。

例如：class Test;void Test::fun(void) const2）const成员函数可以调用类中const成员函数，不能调用非const成员函数。

例如：void Test::gun(void);void Test::hun(void) constvoid Test::fun(void) const{gun( ); //非法，不能调用非const成员函数hun( ); //合法，可以调用const成员函数}3）const 对象可以调用类中const成员函数，但是不能调用非const成员函数。

例如：void Test::gun(void);void Test::fun(void) const;Test A;A.gun( ) //非法，不能调用非const成员函数A.fun( ); //合法，可以调用const成员函数4）类中非const 对象和非const 成员函数都可以调用const成员函数。

c中const的用法在C语言中，const是一个关键字，用于修饰变量、函数参数和函数返回值，表示该值不能被修改。

const关键字在C语言中被广泛用于提高程序的稳定性和安全性。

本文将介绍const在C语言中的用法。

一、const修饰变量1. 局部变量：在函数内部声明的局部变量，如果用const修饰，则该变量在函数内部是只读的，不能被修改。

2. 全局变量：在代码中声明的全局变量，如果用const修饰，则该全局变量在程序执行期间是只读的，不能被修改。

例如：```cconst int my_variable = 10; //全局常量变量void my_function() {const int local_variable = 5; //局部常量变量//...函数内部使用local_variable，但不能修改它}```二、const修饰指针1. 指向常量的指针：指向一个常量的指针，指向的变量不能被修改。

2. 指向普通变量的指针：如果一个指针指向一个普通变量，用const修饰该指针，表示该指针不能被用来修改它所指向的变量的值。

例如：```cint my_variable = 10;int* const p = &my_variable; // p指向my_variable，不能通过p来修改my_variable的值```三、const修饰函数参数和返回值1. 函数参数：如果一个函数接受一个常量指针或常量引用作为参数，则该参数的值不能被修改。

2. 返回值：如果一个函数返回一个常量指针或常量引用，则该函数的返回值不能被修改。

例如：```cconst int* get_constant_pointer() { //返回一个指向常量的指针return &my_variable; //my_variable不能被修改}```四、注意事项1. const关键字只保证变量的值不能被修改，但不能保证指针所指向的内存空间不会被释放或重新分配。

C语⾔const⽤法概述const概念有时候我们希望定义这样⼀种变量，它的值不能被改变，在整个作⽤域中都保持固定。

例如，⽤⼀个变量来表⽰班级的最⼤⼈数，或者表⽰缓冲区的⼤⼩。

为了满⾜这⼀要求，可以使⽤const关键字对变量加以限定。

const int MaxNum = 100; //班级的最⼤⼈数MaxNum = 90; //错误，试图向 const 变量写⼊数据我们经常将 const 变量称为常量（Constant）。

创建常量的格式通常为：const type name = value;const和指针const int *p1;//指针所指向的内容只读，指针的指向可以改变int const *p2;//指针所指向的内容只读，指针的指向可以改变int * const p3;//指针只读，指针的指向不可改变const int * const p4;//指针本⾝和它指向的数据都是只读的int const * const p5;//指针本⾝和它指向的数据都是只读的const 和指针结合的写法多少有点让初学者摸不着头脑，⼤家可以这样来记忆：const 离变量名近就是⽤来修饰指针变量的，离变量名远就是⽤来修饰指针指向的数据，如果近的和远的都有，那么就同时修饰指针变量以及它指向的数据。

const 和函数形参在C语⾔中，单独定义 const 变量没有明显的优势，完全可以使⽤#define命令代替。

const 通常⽤在函数形参中，如果形参是⼀个指针，为了防⽌在函数内部修改指针指向的数据，就可以⽤ const 来限制。

size_t strlen ( const char * str );int strcmp ( const char * str1, const char * str2 );char * strcat ( char * destination, const char * source );char * strcpy ( char * destination, const char * source );int system (const char* command);int puts ( const char * str );int printf ( const char * format, ... );const 和⾮ const 类型转换char *指向的数据有读取和写⼊权限，⽽const char *指向的数据只有读取权限，降低数据的权限不会带来任何问题，但提升数据的权限就有可能发⽣危险。

c语言const的用法详解C语言`const`的用法详解C语言作为一种广泛应用的编程语言，提供了丰富的特性和关键字来帮助开发者编写高效、可靠的代码。

其中之一就是`const`（常量）关键字，它允许开发者定义不可修改的常量值。

本文将详细解释`const`关键字的用法，并介绍其在变量声明、函数参数以及指针中的使用。

## 1. 常量### 1.1 常量基本概念在C语言中，常量是指其值在程序执行期间不能被改变的标识符。

常量可以通过`const`关键字来定义。

比如：```cconst int MAX_VALUE = 100;```上述代码将一个名为`MAX_VALUE`的整型常量定义为100。

在后续程序中，无论如何操作，都无法更改该常量的值。

### 1.2 `const`关键字修饰变量除了可以定义常量外，`const`关键字还可以用于修饰普通变量，使其成为不可修改的。

这对于提高代码可读性和安全性非常有益。

```cconst int count = 10;```在上述例子中，我们将一个名为`count`的整型变量声明为不可修改。

也就是说，在后续使用过程中，任何对`count`的修改操作都会导致编译错误。

## 2. `const`关键字与变量声明在变量声明过程中，`const`关键字可以用于指定该变量为常量，即不可修改。

这种方式可以帮助防止程序中的错误或潜在的bug，并增加代码的可靠性。

```cvoid exampleFunc(const int value);```上述代码片段是一个函数原型的示例，其中形参`value`被定义为不可修改的常量。

这意味着在该函数内部，无论如何操作，都不能改变传入的参数值。

## 3. `const`关键字与函数指针通过函数指针，C语言允许程序动态调用函数，在某些情况下非常有用。

而使用`const`关键字修饰函数指针，则能够限制被调用函数对变量值的修改。

```cint calculateFunc(const int a, const int b);```在上述示例中，我们定义了一个名为`calculateFunc`的函数，并将其形参和返回值类型都声明为不可修改。

c语言const的用法const是一个C语言的关键字，它限定一个变量不允许被改变。

使用const在一定程度上可以提高程序的安全性和可靠性，另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一些帮助。

下面小编就跟大家介绍下c语言const的用法。

我们来分情况看语法上它该如何被使用。

1、函数体内修饰局部变量。

例：void func(){const int a=0;}首先，我们先把const这个单词忽略不看，那么a是一个int类型的局部自动变量，我们给它赋予初始值0。

然后再看const.const作为一个类型限定词，和int有相同的地位。

const int a;int const a;是等价的。

于是此处我们一定要清晰的明白，const修饰的对象是谁，是a,和int没有关系。

const 要求他所修饰的对象为常量，不可被改变，不可被赋值，不可作为左值(l-value)。

这样的写法也是错误的。

const int a;a=0;这是一个很常见的使用方式：const double pi=3.14;在程序的后面如果企图对pi再次赋值或者修改就会出错。

然后看一个稍微复杂的例子。

const int* p;还是先去掉const 修饰符号。

注意，下面两个是等价的。

int* p;int *p;其实我们想要说的是，*p是int类型。

那么显然，p就是指向int 的指针。

同理const int* p;其实等价于const int (*p);int const (*p);即，*p是常量。

也就是说，p指向的数据是常量。

于是p+=8; //合法*p=3; //非法，p指向的数据是常量。

那么如何声明一个自身是常量指针呢?方法是让const尽可能的靠近p;int* const p;const右面只有p,显然，它修饰的是p,说明p不可被更改。

然后把const去掉，可以看出p是一个指向 int形式变量的指针。

于是p+=8; //非法*p=3; //合法再看一个更复杂的例子，它是上面二者的综合const int* const p;说明p自己是常量，且p指向的变量也是常量。