C++ 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对象的使⽤。

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是什么意思。

const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

const关键字使用非常的灵活，这一点和php差别很大，php中const用来在类中定义一个常量，而在c中，const因位置不同有不同的作用，因情景不同有不同的角色，使用起来也是非常的灵活。

一、const用来修饰普通的变量(指针变量除外)的时候，const type name 和type const name 这两种形式是完全等价的，都表示其是常量，不能进行修改。

二、const用来修饰指针变量的时候，分为以下四种情况1、const type *name :这种情况下,const修饰的指针变量name所指向的type 类型对象，也就是说指向的这个对象是不能进行修改的，因为其是常量，而指针变量确实可以进行修改的。

2、type const *name :这种情况下,const修饰的指针变量name所指向的type 类型对象，意思完全同上，只是颠倒了以下顺序。

3、type * const name :这种情况下,const修饰的指针变量name，也就是说这个指针变量的值是不能进行修改的，但是指针变量所指向的对象确实可以修改的。

4、const type * const name :这种情况下,const修饰的指针变量name以及指针变量name所指向的对象，也就是说这个指针变量以及这个指针变量所指向的对象都是不能进行修改的。

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

另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一定帮助。

另外CONST在其它编程语言中也有出现，例如Pascal、C++、PHP5、B#.net、HC08 C、C#等。

在c中，对于const定义的指针，不赋初值编译不报错，int* const px;这种定义是不允许的。

（指针常量定义的时候对其进行初始化）int const *px;这种定义是允许的。

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类型，就不能再对其进行赋值操作。

使用const可以带来如下好处：
1.保证变量的值不会被改变。

这在程序中起到了重要的作用，因为一些常量在程序中的值是不允许被改变的。

2.有助于编译器进行优化。

const常量在程序中只需要被读取，而不需要被修改，这样编译器可以将其存储在只读的数据段中，不必在栈或堆上开辟空间。

这样可以减少内存的使用，提高程序的运行速度。

3.提高代码的可读性。

使用const可以使代码更加清晰明了，让其他程序员更容易理解代码的含义。

const可以用于变量、函数参数、函数返回值等，具体用法如下： 1.变量：
const int a = 10; //声明一个const整型变量a，其值为10，不可更改
const char b = 'A'; //声明一个const字符型变量b，其值为'A'，不可更改
2.函数参数：
void fun(const int a); //声明一个函数fun，参数为const
类型的整型变量a，表示在函数中a的值不能被修改
3.函数返回值：
const int fun(); //声明一个函数fun，返回值为const类型的整型变量，表示返回值不能被修改
总之，使用const关键字可以提高程序的可靠性、可读性和效率，是C语言中非常实用的关键字。

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++学习笔记一、预处理器1、引用指示符：#include#include <somefile.h>#include “myfile.h”用<>括起来的，表明这个头文件是一个工程或者标准头文件，查找过程会检查预定义的目录；用””引号括起来的，表明该文件是用户提供的文件，查找文件时将从当前文件目录开始。

2、条件指示符：#ifndef … #define…. #endif#ifndef SOMEFILE_H#define SOMEFILE_H#endif条件指示符#ifndef可以检查SOMEFILE_H在前面的文件中是否已经被定义，如果没有定义，则执行#ifndef和#endif之间的所有语句，相反，如果已经被定义了，那么#ifndef 和#endif之间的所有语句都会被忽略。

3、条件指示符:#ifdef…#endif#ifdef语句通常用来避免头文件重复引用，但是也可以用来判断一个预处理器常量是否被定义，以便有条件的包含程序代码。

int mian(){#ifdef DEBUGcout << “Beginning execution of mian()\n”;#endif}在Unix系统中，可以使用-D选项，并在后面写上预处理器常量的名字来定义预处理器常量。

$ CC –DDEBUG mian.c4、编译指示符：__cplusplus和__STDC__编译C++程序时，编译器自动定义了一个预处理器名字__cplusplus(前面两个下划线)，一般会根据它来判断是否是C++程序。

#ifdef __cplusplusextern “C”//表明程序是C++程序，extern “C”的作用，见后面介绍。

#endif在编译标准C时，编译器将自动定义名字__STDC__。

__cplusplus和__STDC__在程序中不会同时被定义的。

5、预定义名字：__LINE__、__FILE__、__TIME__、__DA TE____LINE__是指程序源码文件已经被编译的行数。

C语言三剑客之《C专家编程》一书精华提炼C语言的设计哲学:一切工作程序员自己负责。

语言中的所有特性都不需要隐式的运行时支持。

程序员所做的都是对的。

程序员应该知道自己在干什么，并保证自己的所作所为是正确的。

第1章-- C: 穿越时空的迷雾小即是美。

事物发展都有个过程，由简入繁，不能一开始就想得太复杂，Multics， IBM的OS/360都是因此而失败。

C语言的许多特性是为了方便编译器设计者而建立的。

----唉，怎么这个样子C语言的基本数据类型直接与底层硬件相对应。

----确实如此register关键字，这个设计可以说是一个失误，如果让编译器在使用各个变量时自动处理寄存器的分配工作，显然比一经声明就把这类变量在生命周期内始终保留在寄存器里要好，使用register关键字，简化了编译器，却把包袱丢给了程序员。

C编译器不曾实现的一些功能必须通过其他途径实现----标准I/O 库和C预处理器。

在宏扩展中，空格会对扩展的结果造成很大的影响。

宏后面不可加';'，它不是C语句。

宏最好只用于命名常量，并为一些适当的结构提供简捷的记法。

宏名应该大写这样便很容易与函数调用区分开来。

const关键字原先如果命名为readonly就好多了。

const int *p;是指不能够通过通过p来改变int的值，即：*p = 30和p[3] = 4都是错误，但p是可以改变。

const int *与int *是相容的，都是指向int的指针；const int **与int **不相容，前者是指向const int *的指针，int **是指向int *的指针。

尽量不要在你的代码中使用无符号类型，以免增加不必要的复杂性。

只有在使用位段和二进制掩码时，才可以使用无符号数。

应该在表达式中使用强制类型转换，使操作数均为有符号数，或者无符号数，这样就不必由编译器来选择结果的类型。

有个例子，在ANSI C中，-1 < (unsigned char)1为真，而-1 < (unsigned int)1 为假。

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++语言中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 的作用主要有以下几个方面：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 的数组。

C语⾔const和static
1. const 是constant 的缩写，“恒定不变”的意思。

被const 修饰的东西都受到强制保护，可以预防意外的变动，能提⾼程序的健壮性。

2. const可以修饰变量，函数的⼊参，函数的返回值
3. static第⼀个作⽤：隐藏. 当我们同时编译多个⽂件时，所有未加static前缀的全局变量和函数都具有全局可见性。

4. static的第⼆个作⽤是保持变量内容的持久。

存储在静态数据区的变量会在程序刚开始运⾏时就完成初始化，也是唯⼀的⼀次初始化。

5. static的第三个作⽤是默认初始化为0。

其实全局变量也具备这⼀属性，因为全局变量也存储在静态数据区。

在静态数据区，内存中所
有的字节默认值都是0x00，某些时候这⼀特点可以减少程序员的⼯作量。

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”。

1.const的用法：为什么使用const？采用符号常量写出的代码更容易维护；指针常常是边读边移动，而不是边写边移动；许多函数参数是只读不写的。

const最常见用途是作为数组的界和switch分情况标号（也可以用枚举符代替）用法1：常量取代了C中的宏定义，声明时必须进行初始化。

const限制了常量的使用方式，并没有描述常量应该如何分配。

如果编译器知道了某const的所有使用，它甚至可以不为该const 分配空间。

最简单的常见情况就是常量的值在编译时已知，而且不需要分配存储。

―《C++ Program Language》用const声明的变量虽然增加了分配空间，但是可以保证类型安全。

C标准中，const定义的常量是全局的，C++中视声明位置而定。

用法2：指针和常量使用指针时涉及到两个对象：该指针本身和被它所指的对象。

将一个指针的声明用const“预先固定”将使那个对象而不是使这个指针成为常量。

要将指针本身而不是被指对象声明为常量，必须使用声明运算符*const。

所以出现在* 之前的const是作为基础类型的一部分：char *const cp; //到char的const指针char const *pc1; //到const char的指针const char *pc2; //到const char的指针（后两个声明是等同的）从右向左读的记忆方式：cp is a const pointer to char.pc2 is a pointer to const char.用法3：const修饰函数传入参数将函数传入参数声明为const，以指明使用这种参数仅仅是为了效率的原因，而不是想让调用函数能够修改对象的值。

同理，将指针参数声明为const，函数将不修改由这个参数所指的对象。

通常修饰指针参数和引用参数：void Fun( const A *in); //修饰指针型传入参数void Fun(const A &in); //修饰引用型传入参数用法4：修饰函数返回值可以阻止用户修改返回值。

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

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

为了满⾜这⼀要求，可以使⽤const关键字对变量加以限定：1. const int MaxNum = 100; //班级的最⼤⼈数这样 MaxNum 的值就不能被修改了，任何对 MaxNum 赋值的⾏为都将引发错误：1. MaxNum = 90; //错误，试图向 const 变量写⼊数据我们经常将 const 变量称为常量（Constant）。

创建常量的格式通常为：const type name = value;const 和 type 都是⽤来修饰变量的，它们的位置可以互换，也就是将 type 放在 const 前⾯：type const name = value;但我们通常采⽤第⼀种⽅式，不采⽤第⼆种⽅式。

另外建议将常量名的⾸字母⼤写，以提醒程序员这是个常量。

由于常量⼀旦被创建后其值就不能再改变，所以常量必须在定义的同时赋值（初始化），后⾯的任何赋值⾏为都将引发错误。

⼀如既往，初始化常量可以使⽤任意形式的表达式，如下所⽰：1. #include <stdio.h>2.3. int getNum(){4. return 100;5. }6.7. int main(){8. int n = 90;9. const int MaxNum1 = getNum(); //运⾏时初始化10. const int MaxNum2 = n; //运⾏时初始化11. const int MaxNum3 = 80; //编译时初始化12. printf("%d, %d, %d\n", MaxNum1, MaxNum2, MaxNum3);13.14. return 0;15. }运⾏结果：100, 90, 80const 和指针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指向的变量也是常量。