const变量使用总结

CC++中CONST⽤法总结（推荐）1、修饰常量时：const int temp1; //temp1为常量，不可变 int const temp2; //temp2为常量，不可变2、修饰指针时： 主要看const在*的前后，在前则指针指向的内容为常量，在后则指针本⾝为常量；const int *ptr; //*ptr为常量； int const *ptr; //*ptr为常量； int* const ptr; //ptr为常量； const int * const ptr; //*ptr、ptr均为常量；3、const修饰类对象时： const修饰类对象时，其对象中的任何成员都不能被修改。

const修饰的对象，该对象的任何⾮const成员函数都不能调⽤该对象，因为任何⾮const成员函数都会有修改成员变量的可能。

class TEMP{ void func1(); void func2() const; } const TEMP temp; temp.func1(); //错误； temp.func2(); //正确；4、const修饰成员变量： const修饰的成员变量不能被修改，同时只能在初始化列表中被初始化，因为常量只能被初始化，不能被赋值； 赋值是使⽤新值覆盖旧值构造函数是先为其开辟空间然后为其赋值，不是初始化；⽽初始化列表开辟空间和初始化是同时完成的，直接给与⼀个值，所以const成员变量⼀定要在初始化列表中完成。

class TEMP{ const int val; TEMP(int x)val(x){}; //只能在初始化列表中赋值； }5、const修饰类的成员函数 const成员函数表⽰该成员函数不能修改类对象中的任何⾮const成员变量。

⼀般const写在函数的后⾯，形如：void func() const; 如果某个成员函数不会修改成员变量，那么最好将其声明为const，因为const成员函数不会对数据进⾏修改，如果修改，编译器将会报错；class TEMP{ void func()const; //常成员函数，不能修改对象中的成员变量，也不能调⽤类中任何⾮const成员函数； } 对于const类对象，只能调⽤类中的const成员函数，所以const修饰成员函数的作⽤主要就是限制对const对象的使⽤。

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使用方法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++上。

const在python的用法概述及解释说明1. 引言1.1 概述本文将介绍在Python中const的用法，并对其进行解释和说明。

const是"constant"的缩写，表示常量，在程序中被定义后不可更改的值。

我们将讨论const在Python中的作用、与变量的区别以及在实际应用中的注意事项。

1.2 文章结构本文分为五个部分：引言、const在python的用法、const在python中的实现方式、const的使用注意事项以及const在实际应用中的例子。

首先，我们会介绍整篇文章所涵盖的内容，然后详细探讨const在Python中的使用方法和其作用。

接下来，我们将阐述常见的三种实现方式，并指出它们之间的异同。

随后，我们会提醒读者在使用const时需要特别注意的一些事项。

最后，我们会给出一些实际应用案例，以便读者更好地理解const在实践中如何运用。

1.3 目的本文旨在帮助读者了解并熟悉常量(const)在Python编程语言中所扮演的角色以及其正确使用方法。

通过深入剖析其概念和实现方式，读者能够更好地理解如何有效地利用常量来提高代码质量和可维护性。

此外，我们将通过实际应用案例的分享，为读者提供更多实践经验和灵感。

希望本文能够为读者提供有益的信息，并在Python编程中正确合理地使用常量这一工具。

2. const在python的用法2.1 什么是const在Python中，const通常指代常量，即一旦定义后就不可更改的值。

它与变量的区别在于它的值是固定的，并且不能被重新赋值或修改。

2.2 const的作用常量的作用是为程序中确定不变的数值或对象提供一个易于识别和维护的标识符。

通过使用常量，我们可以在代码中使用有意义的名称来引用这些数值或对象，而无需记住其具体的数值或属性。

2.3 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来定义一些有特殊用途的类常量，不过这样定义是存在一些劣势的。

1. const修饰普通变量和指针const修饰变量，一般有两种写法：const TYPE value;TYPE const value;这两种写法在本质上是一样的。

它的含义是：const修饰的类型为TYPE的变量value是不可变的。

对于一个非指针的类型TYPE，无论怎么写，都是一个含义，即value只不可变。

例如：const int nValue；//nValue是constint const nValue；// nValue是const但是对于指针类型的TYPE，不同的写法会有不同情况，例如：A. const char *pContent;B. char * const pContent;C. char const *pContent;D. const char* const pContent;对于前三种写法，我们可以换个方式，给其加上括号A. const (char) *pContent;B. (char*) const pContent;C. (char) const *pContent;这样就一目了然。

根据对于const修饰非指针变量的规则，很明显，A=C.- 对于A,C, const修饰的类型为char的变量*pContent为常量，因此，pContent的内容为常量不可变.- 对于B, 其实还有一种写法：const (char*) pContent;含义为：const修饰的类型为char*的变量pContent为常量，因此，pContent指针本身为常量不可变.- 对于D, 其实是A和B的混合体，表示指针本身和指针内容两者皆为常量不可变总结:(1)指针本身是常量不可变(char*) const pContent;const (char*) pContent;(2)指针所指向的内容是常量不可变const (char) *pContent;(char) const *pContent;(3)两者都不可变const char* const pContent;还有其中区别方法：沿着*号划一条线，如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。

php const用法PHP const用法在PHP中，我们可以使用const关键字来定义常量。

常量是一个不可改变的值，它在定义之后不能被重新赋值。

常量的使用有很多场景，并且可以提升代码的可读性和可维护性。

下面是一些常见的const用法，以及对它们的详细讲解：1.定义常量使用const关键字可以定义一个常量。

常量名通常使用大写字母，并且使用下划线来分隔单词。

例如：const PI = ;在上述示例中，我们定义了一个名为PI的常量，其值为。

一旦定义了常量，就不能再改变它的值。

2.常量的作用域常量在定义后会被视为全局可见。

这意味着常量可以在代码的任何地方使用，而不受作用域的限制。

例如：const DATABASE_NAME = 'my_database';function getConnection() {echo 'Connecting to ' . DATABASE_NAME;}getConnection(); // 输出：Connecting to my_database 在上述示例中，我们在函数外定义了一个常量DATABASE_NAME，然后在函数内部使用了该常量。

函数能够访问并打印出该常量的值。

3.类常量在类中，我们可以使用const关键字来定义类常量。

类常量的定义与全局常量相似，但需要添加访问修饰符public、protected或private。

例如：class Car {const MAX_SPEED = 200;public function accelerate() {echo 'Accelerating up to ' . self::MAX_SPEED . ' km/h';}}$car = new Car();$car->accelerate(); // 输出：Accelerating up to 200km/h在上述示例中，我们定义了一个名为MAX_SPEED的类常量，并在类的方法中使用了该常量。

const⽤法总结1. const修饰变量int b = 100;const int* a = &b; //情况1int const* a = &b; //情况2int* const a = &b; //情况3const int* const a = &b; //情况4const修饰有三种情况：第⼀：const在“ * ”左边，则const⽤来修饰指针所指向的变量，即指针指向为常量，如情况1，情况2；第⼆：const在“ * ”右边，则const⽤来修饰指针本⾝，即指针本⾝是常量，如情况3；第三：const在“ * ”两边，则const既修饰指针本⾝也修饰指针所指变量，如情况4；注意：const的相对位置只与“ * ”有关，和变量的类型声明没有位置关系，其次const修饰指针所指变量时可以不初始化，但const修饰指针本⾝时必须初始化。

2. const在函数中的使⽤2.1 const修饰函数的参数输⼊参数采⽤“指针传递”，那么加const修饰可以防⽌意外的改动该指针指向的内存单元，起到保护作⽤，如StringCopy函数//输⼊参数： strSrc 输出参数：strDestvoid StringCopy(char* strDest, const char* strSrc);如果还想保护指针本⾝，则可以声明指针本⾝为常量，例如：void OutputString(const char* const pStr);如果参数⽤于输出，不论它是什么类型，也不论它采⽤“指针传递”还是“引⽤传递”，都不能加const修饰，即const只能修饰输⼊参数。

另外如果如果输⼊参数采⽤“值传递”，由于函数将⾃动⽤实参的拷贝初始化形参，因此即使在函数内部修改了该参数，改变的也只是堆栈上的拷贝⽽不是实参，所以⼀般不需要const修饰。

最好不要把void Func(const int x)改为void Func(const int &x)这样即达不到提⾼效率的⽬的有让⼈费解。

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：表达式必须是‎可以修改的左‎值上面代码中第‎一行和第三行‎都有错误，注释便是编译‎器给出的错误‎提示。

CONST用法面向对象是C++的重要特性.但是c++在c的基础上新增加的几点优化也是很耀眼的就const直接可以取代c中的#define以下几点很重要,学不好后果也也很严重const1. 限定符声明变量只能被读const int i=5;int j=0;...i=j; //非法，导致编译错误j=i; //合法2. 必须初始化const int i=5; //合法const int j; //非法，导致编译错误3. 在另一连接文件中引用const常量extern const int i; //合法extern const int j=10; //非法，常量不可以被再次赋值4. 便于进行类型检查用const方法可以使编译器对处理内容有更多了解。

#define I=10const long &i=10; /*dapingguo提醒：由于编译器的优化，使得在const long i=10; 时i不被分配内存，而是已10直接代入以后的引用中，以致在以后的代码中没有错误，为达到说教效果，特别地用&i明确地给出了i的内存分配。

不过一旦你关闭所有优化措施，即使const long i=10;也会引起后面的编译错误。

*/ char h=I; //没有错char h=i; //编译警告，可能由于数的截短带来错误赋值。

5. 可以避免不必要的内存分配#define STRING "abcdefghijklmn\n"const char string[]="abcdefghijklm\n";...printf(STRING); //为STRING分配了第一次内存printf(string); //为string一次分配了内存，以后不再分配...printf(STRING); //为STRING分配了第二次内存printf(string);...由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。

在C语言中const作用的的全面总结const 是一个关键字，用于声明一个常量。

在C语言中，const 的作用主要有以下几个方面：1. 声明常量：const 用于声明一个常量，即一个不可修改的值。

常量的值在声明后不能被修改。

例如：const int MAX_SIZE = 100; 声明了一个名为 MAX_SIZE 的常量，其值为 100，不能被修改。

2. 防止意外修改：通过使用 const 关键字，可以防止在程序中意外地修改一个变量的值。

当一个变量被声明为 const 类型时，任何试图修改其值的操作都会导致编译错误。

3. 优化编译器：const 可以用于给编译器提供有关变量值的信息，从而优化生成的代码。

编译器可以根据 const 的声明来进行一些优化，例如将常量值直接嵌入到代码中，而不是每次都去访问内存。

4. 类型检查：const 可以提供类型检查，防止将一个类型错误的值赋给一个变量。

当一个变量被声明为 const 类型时，任何试图将不兼容的值赋给该变量的操作都会导致编译错误。

5. 作用域：const 变量的作用域和普通变量一样，可以是全局的也可以是局部的。

在不同的作用域中可以使用相同的 const 变量名，它们不会相互干扰。

6. 常量指针：const 还可以用于声明指向常量的指针。

这意味着指针指向的值是不可修改的，但指针本身可以修改。

例如：const int *ptr; 声明了一个指向常量的指针，即不能通过 ptr 修改指向的值，但可以修改 ptr 指向的位置。

7. 常量参数：const 可以用于声明函数的参数为常量参数，这样可以确保函数内部不会修改参数的值。

这样的函数被称为常量函数，可以接受常量参数并返回常量结果。

8. 数组长度：const 可以用于声明数组的长度，使得在程序中可以更方便地使用数组。

例如：const int SIZE = 10; int arr[SIZE]; 声明了一个大小为 10 的数组。

const用法const是Javascript语言中的一种保留关键字，可以用来声明常量，一旦声明，这个常量就不能被修改或重新分配。

const声明可以用于声明变量，也可以用于声明函数和类，不仅可以在函数内部使用，还可以在函数外部使用。

const的用法可以分为两类，一类是声明常量，另一类是声明可读写的常量。

声明常量时，使用const声明的变量只能被赋值一次，而声明可读写的常量时，使用const声明的变量可以多次赋值，但其值不能被改变。

const还有其他用途，如用于定义一组只读常量值，用作防止某些变量值被意外修改，以及用于简化程序书写，使程序更加规范严谨。

一、const声明常量1、const声明变量const声明的变量只能被赋值一次，一旦声明，就不能被修改或重新分配，实例如下：const PI = 3.14;console.log(PI); // 3.14PI = 3.15; //Error: PI is read-only此外，使用const声明的变量必须赋值，否则会报错：const PI; //Error: SyntaxError: missing = in const declaration2、const声明函数使用const声明的函数同样只能被赋值一次，且必须提前声明，而不能等到函数体中再声明，实例如下：//正确：const add = function(x, y) {return x + y;};console.log(add(1, 2)); // 3//错误：const sub;sub = function(x, y) {return x - y;};console.log(sub(4, 2)); // Error: Uncaught TypeError: sub is not a function3、const声明类使用const声明类和使用const声明函数同样要提前声明，不能等到类体中再声明，实例如下：//正确：const Person = class {constructor(name) { = name;}sayHi() {console.log(`hi, I ${}`); }};let person = new Person(Johnperson.sayHi(); // hi, I John//错误：const Student;Student = class {constructor(name) { = name;}sayHi() {console.log(`hi, I ${}`); }};let student = new Student(Johnstudent.sayHi(); // Error: Uncaught TypeError: Student is not a constructor二、const声明可读写的常量1、const声明只读属性const声明可以用于声明一个对象的只读属性，只能在对象初始化时被赋值，以下为实例：const person = {na Johnage: 30};Object.defineProperty(person, name {writable: false});console.log(); // John = Jackconsole.log(); // John2、const声明不可更改的值const还可以声明不可更改的值，即以下形式的值：数字、字符串、布尔值、undefined、null等。

C语⾔中const,volatile,restrict的⽤法总结变量声明中带有关键词const，，这是显⽽易见的⼀点。

指针使⽤const则要稍微复杂点，因为不得不把让指针本⾝成为const 和指针指向的值成为const区别开来、下⾯的声明表⽰pf指向的值必须是不变的constfloat *pf；⽽pf则是可变的，它可以指向另外⼀个const或⾮const值；相反，下⾯的声明说明pf是不能改变的，⽽pf所指向的值则是可以改变的：float* const pf；最后，当然可以有既不能改变指针的值也不能改变指针指向的值的值的声明⽅式：constfloat * const pf；需要注意的是，还有第三种放置const关键字的⽅法：float const * pf; //等价于constfloat * pf;总结就是：⼀个位于*左边任意位置的const使得数据成为常量，⽽⼀个位于*右边的const使得指针本⾝成为const还要注意的⼀点是关于const在全局数据中的使⽤：使⽤全局变量被认为是⼀个冒险的⽅法，它使得数据在程序的任何部分都可以被错误地修改，如果数据是const，那么这种担⼼就是多余的了不是嘛？因此对全局数据使⽤const是合理的。

然⽽，在⽂件之间共享const数据要格外⼩⼼，有两个策略可以使⽤。

⼀个是遵循外部变量的惯⽤规则，在⼀个⽂件进⾏定义声明，在其他⽂件进⾏引⽤声明（使⽤关键字extern）。

/*file1.c------定义⼀些全局常量*/const double PI = 3.14159;/*file2.c-----是⽤在其他⽂件中定义的全局变量*/extern const dounle PI;另外⼀个⽅法是把全局变量放在⼀个include⽂件⾥，这时候需要格外注意的是必须使⽤静态外部存储类/*constant.h----定义⼀些全局常量*/static const double PI = 3.14159;/*file1.c-----使⽤其他⽂件定义的全局变量*/#include”constant.h”。

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语言中的用法在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成员函数。

stm32 const用法const是C/C++中的关键字，用于声明某个变量或函数是只读的，即不能被修改的。

在STM32开发中，const关键字常用于声明常量，常量通常是一些无需修改且应该保持不变的值。

1. 常量声明：```cconst uint8_t MY_CONSTANT = 10; // 声明一个常量并赋值为10```在上述示例中，使用const关键字声明了一个名为MY_CONSTANT的常量，并将其值设置为10。

这意味着在程序的其余部分中，MY_CONSTANT的值不能被修改。

2. 常量指针声明：```cconst uint8_t* const MY_CONSTANT_PTR =&MY_CONSTANT; // 声明一个指向常量的常量指针```在上述示例中，使用const关键字声明了一个指向常量的常量指针MY_CONSTANT_PTR，并将其值设置为指向MY_CONSTANT变量的地址。

这意味着MY_CONSTANT_PTR指向的值不能被修改，且MY_CONSTANT变量也不能通过MY_CONSTANT_PTR进行修改。

3. const修饰函数参数：```cvoid myFunction(const uint8_t* data, const uint16_t dataSize); // 声明一个只读函数，函数参数不能被修改```在上述示例中，函数myFunction的参数data和dataSize被const修饰，这意味着在函数的实现中不能修改这两个参数的值。

这样可以确保在函数内部不会意外地修改到传入的参数，提高代码的可读性和可维护性。

4. const修饰函数返回值：```cconst uint8_t myFunction(void); // 声明一个只读函数，函数返回值不能被修改```在上述示例中，函数myFunction的返回值被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是一个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指向的变量也是常量。