const int
CC++中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语言初学者心中的痛，这是因为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关键字用法总结
C++语言中const关键字用法总结一、const是什么在C/C++ 语言中，const关键字是一种修饰符。
所谓“修饰符”，就是在编译器进行编译的过程中，给编译器一些“要求”或“提示”，但修饰符本身，并不产生任何实际代码。
就const 修饰符而言，它用来告诉编译器，被修饰的这些东西，具有“只读”的特点。
在编译的过程中，一旦我们的代码试图去改变这些东西，编译器就应该给出错误提示。
所以，const修饰符的作用主要是利用编译器帮助我们检查自己代码的正确性。
我们使用con st在源码中标示出“不应该改变”的地方，然后利用编译器，帮助我们检查这些地方是否真的没有被改变过。
如果我们不小心去修改了这些地方，编译器就会报错，从而帮助我们纠正错误。
使用const和不使用cons t，对于最终编译产生的代码并没有影响。
虽然const对于最终代码没有影响，但是尽可能使用const，将帮助我们避免很多错误，提高程序正确率。
二、const可以修饰哪些对象在上面已经提到过了，const是一种修饰符，那它可以作为哪些对象的修饰符呢？下面列举了一些C/C++中用到cons t的地方。
1，const变量2，const指针3，const引用4，const类5，类的const成员变量6，类的const成员函数7，const修饰函数的形参与返回值下面我们分别讨论上面几种情况下，const的用法。
三、const与变量当一个变量被c onst修饰后，具有以下几个特点：1）该变量只能读取不能修改。
（编译器进行检查）2）定义时必须初始化。
3）C++中喜欢用con st来定义常量，取代原来C风格的预编译指令define。
1 const int var; // Error:常量变量"var"需要初始化设定项2 const int var1 = 42;3 var1 = 43; // Error：表达式必须是可以修改的左值上面代码中第一行和第三行都有错误，注释便是编译器给出的错误提示。
c语言常量表达式
c语言常量表达式C语言中常量表达式是指在编译时就能确定值的表达式，常用于定义常量、数组长度、枚举值等。
常量表达式在编译时就被计算，可以提高程序的效率和可读性。
常量表达式可以使用任何C语言中的常量和运算符，包括整型、浮点型、字符型、枚举、sizeof、_Alignof等。
以下是常用的常量表达式：1. 整型常量表达式整型常量表达式由整型常量、运算符、括号组成，例如：const int a = 5;const int b = 2;const int c = (a + b) * 3;在上面的例子中，c的值为21，因为(a+b)*3=21。
2. 浮点型常量表达式浮点型常量表达式由浮点型常量、运算符、括号组成，例如：const float pi = 3.14f;const float r = 2.0f;const float area = pi * r * r;在上面的例子中，area的值为12.56f，因为pi*r*r=3.14f*2.0f*2.0f=12.56f。
3. 字符型常量表达式字符型常量表达式由字符常量、运算符、括号组成，例如：const char ch1 = 'a';const char ch2 = 'b';const char ch3 = ch1 + ch2;在上面的例子中，ch3的值为'ab'，因为ch1+ch2='a'+'b'='ab'。
4. 枚举常量表达式枚举常量表达式由枚举常量、运算符、括号组成，例如：enum color {RED, GREEN, BLUE};const int a = RED;const int b = GREEN;const int c = a + b;在上面的例子中，c的值为1，因为a+b=0+1=1。
5. sizeof常量表达式sizeof常量表达式用于计算变量或类型的大小，例如：const int a = 5;const int b = sizeof(a);在上面的例子中，b的值为4，因为int类型占4个字节。
const修饰符详解
const关键字是用来修饰一个变量使其成为常量(constant)的。常量只能在定义时进行初始化，而此后对这个变量的任何改变都将是非法的。const关键字在就是为了保证了它修饰的对象不被修改。
对于指针来说，const关键字同样可以保证它修饰的对象不被修改，但是与一般的对象有所不同，const可以指定指针本身为常量，也可以指定指针所指的对象为常量，亦或兼而有之。咱们看看下面这个例子：
class X
{
static const int size=50;
int a[size];
public:
X();
};
const对象只能调用const成员函数，一个普通对象同样可以调用const成员函数，因此，const成员函数更具有一般性，但是成员函数不会默认为const。声明一个const成员函数，需要将const限定符放在函数名的后面：
void f (void ) const;
当我们运用const成员函数时，遇到需要改变数据成员，可以用mutable进行特别的指定：
class X
{
mutable int i;
public:
X();
void nochange() const;
};
void X::nochange const(){i++;}
extern const int a;
这表示const的定义在其他的什么地方，这里仅仅是一个声明，但是这样的做法使const使用了外部连接，也就是说上面的extern强制进行了对const的存储空间分配，这样我们就无法再用const作为常量折叠（在可能的情况下，符号常量的值会代替改名字的出现，这个替代过程叫做常量折叠）使用了，即使我们在其他地方定义了const的值,如：
const超详细用法详解,史上最全
例如：
#define PI 3.14159 file://常量宏
const doulbe Pi=3.14159; file://此时并未将Pi放入ROM中
......
double i=Pi; file://此时为Pi分配内存，以后不再分配！
double I=PI; file://编译期间进行宏替换，分配内存
pointer const 可以指定普通变量,用改指针不能修改它指向的对象，并不表示指向的对象是const不能被改变，例如：
int i = 10;
const int * p = &i;
*p = 11; //wrong
i = 11 ; //correct
自己的一个经验：一个具体的概念可以用范型的概念来赋值，但是一个范型的概念不能用具体的概念来赋值。
5. 函数中引用的const传递：
void F1 ( const X& px); //这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的，他禁止对引用的对象的一切修改，唯一不同的是按值传递会先建立一个类对象的副本，然后传递过去，而它直接传递地址，所以这种传递比按值传递更有效。
**另外只有引用的const传递可以传递一个临时对象，因为临时对象都是const属性，且是不可见的，他短时间存在一个局部域中，所以不能使用指针，只有引用的const传递能够捕捉到这个家伙。
Fuction1() = CX(1); //没有问题，可以作为左值调用
Fuction2() = CX(1); //编译错误，const返回值禁止作为左值调用。因为左值把返回值作为变量会修改其返回值，const声明禁止这种修改。
const指针用法
const指针用法一、基本语法```T某 const p; // 指针常量，指向类型为T的非常量对象，不允许更改指针的指向```二、指针类型的转换当一个指针类型被转换为const指针类型时，会带来一些语法和语义的变化。
例如，原本可读写的内存区域变成只读的，原本可以通过指针修改的属性和方法变成只读的等等。
这种类型转换通常是为了增强代码的安全性和可读性，防止错误地修改或删除某些重要的数据。
三、const指针的用途1.函数参数传递在函数参数传递时，const指针可以用来修饰函数参数，防止函数修改指针指向的数据。
例如：```C++void printData(const int某 data, int count)for (int i = 0; i < count; ++i)std::cout << data[i] << " ";}std::cout << std::endl;```2.类成员指针在类成员指针中，const指针可以用来定义只读的成员函数，防止函数修改对象成员的值。
例如：```C++class Personpublic:int age;std::string name;//定义只读成员函数int getAge( const { return age; }std::string getName( const { return name; }};int main。
Person p;p.age = 30; = "Tom";//定义只读的指针变量//访问对象成员std::cout << pPtr->getAge( << std::endl; // 输出：30std::cout << pPtr->getName( << std::endl; // 输出："Tom"return 0;```3.常量数据当指针所指向的数据是一个常量时，需要用const指针来访问它，否则会编译错误或运行错误。
const的用法
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 两者之间的区别了吧。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
const int* a = &b 和const* int a = &b的区别收藏如果const关键字不涉及到指针，我们很好理解，下面是涉及到指针的情况：int b = 500;const int* a = &b; [1]int const *a = &b; [2]int* const a = &b; [3]const int* const a = &b; [4]如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。
不知道，也没关系，我们可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。
另外const 的一些强大的功能在于它在函数声明中的应用。
在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。
有如下几种情况，以下会逐渐的说明用法：A& operator=(const A& a);void fun0(const A* a );void fun1( ) const; // fun1( ) 为类成员函数const A fun2( );---------------------------------------------------------------------------------------------------------------------------------------------const int * pi 、int const * pi与int * const pi及其操作（本贴已经做了重大修改）1 从const int i 说起你知道我们申明一个变量时象这样int i ；这个i是可能在它处重新变赋值的。
如下：int i=0;//…i=20;//这里重新赋值了不过有一天我的程序可能需要这样一个变量（暂且称它变量），在申明时就赋一个初始值。
之后我的程序在其它任何处都不会再去重新对它赋值。
那我又应该怎么办呢？用cons t 。
//**************const int ic =20;//…ic=40;//这样是不可以的，编译时是无法通过，因为我们不能对const 修饰的ic重新赋值的。
//这样我们的程序就会更早更容易发现问题了。
//**************有了const修饰的ic 我们不称它为变量，而称符号常量，代表着20这个数。
这就是c onst 的作用。
ic是不能在它处重新赋新值了。
认识了const 作用之后，另外，我们还要知道格式的写法。
有两种：const int ic=20;与int const ic=20;。
它们是完全相同的。
这一点我们是要清楚。
总之，你务必要记住c onst 与int哪个写前都不影响语义。
有了这个概念后，我们来看这两个家伙：const int * pi与int const * pi ，按你的逻辑看，它们的语义有不同吗？呵呵，你只要记住一点，int 与const 哪个放前哪个放后都是一样的，就好比const int ic;与int const ic;一样。
也就是说，它们是相同的。
好了，我们现在已经搞定一个“双包胎”的问题。
那么int * const pi与前两个式子又有什么不同呢？我下面就来具体分析它们的格式与语义吧！2 const int * pi的语义我先来说说const int * pi是什么作用（当然int const * pi也是一样的，前面我们说过，它们实际是一样的）。
看下面的例子：//*************代码开始***************int i1=30;const int * pi=&i1;pi=&i2; //4.注意这里，pi可以在任意时候重新赋值一个新内存地址i2=80; //5.想想看：这里能用*pi=80;来代替吗？当然不能printf( “%d”, *pi ) ; //6.输出是80//*************代码结束***************语义分析：看出来了没有啊，pi的值是可以被修改的。
即它可以重新指向另一个地址的，但是，不能通过*pi来修改i2的值。
这个规则符合我们前面所讲的逻辑吗？当然符合了！首先const 修饰的是整个*pi（注意，我写的是*pi而不是pi）。
所以*pi是常量，是不能被赋值的（虽然pi所指的i2是变量，不是常量）。
其次，pi前并没有用const 修饰，所以pi是指针变量，能被赋值重新指向另一内存地址的。
你可能会疑问：那我又如何用const 来修饰pi呢？其实，你注意到int * const pi中const 的位置就大概可以明白了。
请记住，通过格式看语义。
哈哈，你可能已经看出了规律吧？那下面的一节也就没必要看下去了。
不过我还得继续我的战斗！3 再看int * const pi确实，int * const pi与前面的int const * pi会很容易给混淆的。
注意：前面一句的const 是写在pi前和*号后的，而不是写在*pi前的。
很显然，它是修饰限定pi的。
我先让你看例子：//*************代码开始***************int i1=30;int i2=40;int * const pi=&i1;//pi=&i2; 4.注意这里，pi不能再这样重新赋值了，即不能再指向另一个新地址。
//所以我已经注释了它。
i1=80; //5.想想看：这里能用*pi=80;来代替吗？可以，这里可以通过*pi修改i1的值。
//请自行与前面一个例子比较。
printf( “%d”, *pi ) ; //6.输出是80//***************代码结束*********************看了这段代码，你明白了什么？有没有发现pi值是不能重新赋值修改了。
它只能永远指向初始化时的内存地址了。
相反，这次你可以通过*pi来修改i1的值了。
与前一个例子对照一下吧！看以下的两点分析1). pi因为有了const 的修饰，所以只是一个指针常量：也就是说pi值是不可修改的（即pi不可以重新指向i2这个变量了）(看第4行)。
2). 整个*pi的前面没有const 的修饰。
也就是说，*pi是变量而不是常量，所以我们可以通过*pi来修改它所指内存i1的值（看5行的注释）总之一句话，这次的pi是一个指向int变量类型数据的指针常量。
我最后总结两句：１）．如果const 修饰在*pi前则不能改的是*pi(即不能类似这样：*pi=50;赋值)而不是指pi。
２）．如果const 是直接写在pi前则pi不能改(即不能类似这样：pi=&i;赋值)。
请你务必先记住这两点，相信你一定不会再被它们给搞糊了。
现在再看这两个申明语句int const *pi和int * const pi时，呵呵，你会头昏脑胀还是很轻松惬意？它们各自申明的pi分别能修改什么，不能修改什么？３．补充三种情况。
这里，我再补充以下三种情况。
其实只要上面的语义搞清楚了，这三种情况也就已经被包含了。
不过作为三种具体的形式，我还是简单提一下吧！情况一：int * pi指针指向const int i常量的情况//**********begin*****************const int i1=40;int *pi;pi=&i1;//这样可以吗？不行，VC下是编译错。
//const int 类型的i1的地址是不能赋值给指向int 类型地址的指针pi的。
否则pi岂不是能修改i1的值了吗！pi=(int* ) &i1;//这样可以吗？强制类型转换可是C所支持的。
//ＶＣ下编译通过，//***********end***************情况二：const int * pi指针指向const int i1的情况//*********begin****************const int i1=40;const int * pi;pi=&i1;//两个类型相同，可以这样赋值。
很显然，i1的值无论是通过pi还是i1都不能修改的。
//*********end*****************情况三：用const int * const pi申明的指针//***********begin****************int iconst int * const pi=&i;//你能想象pi能够作什么操作吗？pi值不能改，也不能通过p i修改i的值。
因为不管是*pi还是pi都是const的。
//************end****************。