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 两者之间的区别了吧。
const的数组
const的数组一、什么是const的数组1.1 const的含义const是C++语言中的一个关键字，意为常量，表示该变量的值不可被修改。
1.2 const数组的含义const数组即为声明为const类型的数组，其元素值不可被修改。
二、const数组的定义和初始化方法2.1 定义方法const类型数组可以通过以下方式定义：const int arr[5] = {1, 2, 3, 4, 5};其中arr为数组名，5为数组大小，{1, 2, 3, 4, 5}为初始化列表。
2.2 初始化方法常见的初始化方法有以下几种：（1）直接赋值法：const int arr[5] = {1, 2, 3, 4, 5};（2）循环赋值法：for(int i=0;i<5;i++){cin>>arr[i];}（3）字符串转换法：string s = "12345";for(int i=0;i<5;i++){arr[i] = s[i] - '0';}三、使用注意事项3.1 数组元素不可被修改由于声明为const类型的数组元素值不可被修改，因此在程序中不能对其进行赋值操作。
否则会导致编译错误。
3.2 可以使用指针访问元素虽然不能对元素进行修改，但可以通过指针访问元素。
例如：const int arr[5] = {1, 2, 3, 4, 5};const int *p = arr;cout<<*p<<endl; //输出13.3 可以使用const_cast进行类型转换如果需要修改const类型的数组元素，可以使用const_cast进行类型转换。
例如：const int arr[5] = {1, 2, 3, 4, 5};int *p = const_cast<int *>(arr);*p = 6;cout<<arr[0]<<endl; //输出6四、应用场景由于声明为const类型的数组元素值不可被修改，因此常用于存储一些常量数据。
const综合一级指针和二级指针
const int *p, int *const p, const int **p , int **const p, int *const *p的区别被const修饰的符号我们称为常量，更准确的说应该是常变量，例如：const int a=10;我们定义了一个常变量整形a，那么对于a的操作有什么特征呢？当然，你只能使用a给别的变量赋值，但是切记不能给a进行赋值，编译器认为a的内存是不可修改的，因此，试图给a赋值的操作都会失败，编译阶段都不会通过！1.const int *p和int *const p的区别首先要分清楚const修饰的是谁，只有被const修饰的类型是不能被修改的，这里我借用c++标准对于const说明的一句话，const只修饰离它最近的类型符号，那我们来看：●const int *p可以看出const修饰的是int，也就是说*p所代表的整型值是不能被修改的，试图通过*p修改指针所指向的内存数据是非法的，看这个例子：可以看出，const int*p指的是，*p所代表的整形值是常量，不能被修改；而指针p 本身是变量，可以被任意赋值。
更通俗的描述就是，指针p所指向的内存不能被修改，而指针p本身是可以被修改的！另外，const int*p和int const*p是一样的，因为在int const *p中，const的左右两边只有左边int为类型(const是修饰类型的)，右边*p不是类型，因此把const 放到int的左右两边情况是一样的！●int *const p可以看出const修饰的是int *，也就是这个指针变量p是常量，而*p所指向的int 整形值是变量，请看示例:形是变量，可以被任意修改！即，p不能被修改，而p所指向的内存是可以被修改的！2.const int **p , int **const p, int *const *p的区别参照第一点，你能够很快区分const int **p , int **const p的区别。
C语言之const与static用法
double a1;
long a; int a2;
char b;
};
#pragma pack()//sizeof(B)==17 说明：例二中演示了数据对其的情况，由于 CPU 访问数据的特点是一次访问多个字节，故如果多字节 数据的首地址是 2 的整数倍的话，将可以一次内存访问即可取得其所对应的所有数据，所以一个优化 要求就是变量的地址是其数据类型长度的整数倍，例如 int a 的 a 的地址要求是 4 的整数倍。 针对结构体，如果结构体中所有元素类型相同，作为数组处理，入 struct A；否则一般都是其最常 元素的整数倍，例如 struct B 和 C。这样处理的目的是考虑定义结构体数组的情况，例如 struct B b[10];那么这 10 个结构体变量如果每个长度都是 8，将能保证每个变量的第一个元素都能是 4 的整 数倍，否则将达不到这个效果，不能实现高效的内存访问，故编译器将对不符合要求的结构体自动调 整数据对齐。 最后需要交代的是，class 中的 static 变量不被分配到栈上，所以不能计入 sizeof 中，空类的长度 是 1，有虚函数的长度为 4，因为包含一个指向函数表的指针。 下面分析几个面试题： 例一：
void fstatic(void); static void fstatic(void) {
c语言里const int 和int 有什么区别,const的作用是什么
c语言里const int 和int 有什么区别,const 的作用是什么。
一、const int 和int 的区别1、返回值const int & 是返回这个数值的一个常量的引用。
而int 是返回这个数值的一个拷贝。
int 是进行拷贝构造，而const int & 是返回的引用。
拷贝构造更消耗时间，与此同时还用析构函数。
因为产生了一个拷贝，你就可以轻易地修改拷贝的内容。
2、取指针const int类型一旦定义以后就不能修改，int类型是随时可以修改的。
在取指针方面，const有略复杂的东西，但是常规的、合理的操作不应该涉及到，因为const int是用来保存一些全局常量的，这些常量在编译期可以改，在运行期不能改。
听起来这像宏，其实这确实就是用来取代宏的：#define PI 3.14 const float Pi = 3.14; 如果你的代码里用到了100次PI（宏），你的代码中会保存100个3.14这个常数。
鉴于使用常数进行运算的机器代码很多时候会比使用变量来的长，如果你换用100次Pi（const float)，程序编译后的机器码里就不需要出现100次常量3.14，只要在需要的时候引用存有3.14的常量就行了。
特别在复杂的运算里，3.14这个常量（其实是无法修改的变量）会被一直装载在寄存器里带来一些性能提升。
3、内容constint* p; //p可变，p指向的内容不可变，int const* p; //p可变，p指向的内容不可变。
int* const p; //p不可变，p指向的内容可变const int* const p; //p和p指向的内容都不可变。
二、const的作用：1、可以定义const常量，具有不可变性。
例如：const int Max=100; Max++会产生错误;2、便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。
例如：void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改；3、可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。
C++static、const和staticconst类型成员变量声明以及初始化菜鸟教程
C++static、const和staticconst类型成员变量声明以及初始化菜鸟教程const 定义的常量在超出其作用域之后其空间会被释放，而 static 定义的静态常量在函数执行后不会释放其存储空间。
static 表示的是静态的。
类的静态成员函数、静态成员变量是和类相关的，而不是和类的具体对象相关的。
即使没有具体对象，也能调用类的静态成员函数和成员变量。
一般类的静态函数几乎就是一个全局函数，只不过它的作用域限于包含它的文件中。
在 C++ 中，static 静态成员变量不能在类的内部初始化。
在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，如：double Account::Rate = 2.25;static 关键字只能用于类定义体内部的声明中，定义时不能标示为static。
在 C++ 中，const 成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。
const 数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。
因为类可以创建多个对象，不同的对象其const 数据成员的值可以不同。
所以不能在类的声明中初始化const 数据成员，因为类的对象没被创建时，编译器不知道const 数据成员的值是什么。
const 数据成员的初始化只能在类的构造函数的初始化列表中进行。
要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。
class Test{ public: Test():a(0){} enum {size1=100,size2=200}; private: const int a;//只能在构造函数初始化列表中初始化 static int b;//在类的实现文件中定义并初始化conststatic int c;//与static const int c;相同。
}; int Test::b=0;//static成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。
binding reference of type discards qualifiers
Binding Reference of Type Discards Qualifiers在C++中，当我们将一个常量对象的引用绑定到一个非常量引用上时，会出现”binding reference of type discards qualifiers”（绑定类型的引用丢弃了限定符）的错误。
这个错误通常发生在我们试图将一个const对象的引用绑定到一个非const引用上时。
错误产生的原因为了理解这个错误，我们需要先了解一些基本概念。
在C++中，const关键字用来指示某个变量是不可修改的。
当我们声明一个变量为const时，它的值不能被修改。
而当我们声明一个指针或引用时，它们可以指向const对象或非const对象。
考虑以下示例代码：int main() {const int x = 10;int& ref = x; // 错误：binding reference of type discards qualifiers return 0;}在这个例子中，我们声明了一个常量x，并试图将其引用赋值给一个非常量引用ref。
然而，编译器会报错并显示”binding reference of type discards qualifiers”。
这是因为ref是一个非常量引用，它可以修改所引用对象的值。
但由于x是一个常量对象，它的值不能被修改。
因此，编译器会阻止这种赋值操作。
解决方法要解决”binding reference of type discards qualifiers”错误，我们有几种选择：1. 将引用声明为const最简单的解决方法是将引用声明为const。
这样做可以保证引用不会修改所引用对象的值。
修改上面的示例代码：int main() {const int x = 10;const int& ref = x; // 正确：将引用声明为constreturn 0;}现在，我们将ref声明为const int&，与x的类型相匹配。
const引用的数组
const引用的数组const引用的数组是指将数组的引用声明为常量，即不能修改引用所指向的数组的值。
这样做的目的是为了保护数组的数据不被意外地修改。
对于const引用的数组，可以采取以下两种方案：1. 使用const修饰数组的引用类型：```const int arr[] = {1, 2, 3, 4, 5}; // 声明一个常量整型数组const int& ref = arr; // 将数组的引用声明为常量引用// 通过引用访问数组的元素for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {cout << ref[i] << " ";}```上述代码中，通过将数组`arr`的引用声明为常量引用`ref`，可以确保`ref`不会修改数组的值。
通过`ref`可以访问数组的元素，但不能修改它们的值。
2. 使用const修饰数组元素的类型：```int arr[] = {1, 2, 3, 4, 5}; // 声明一个整型数组const int* const ptr = arr; // 声明一个指向常量整型的指针，且指针本身也是常量// 通过指针访问数组的元素for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {cout << ptr[i] << " ";}```上述代码中，通过将指针`ptr`声明为指向常量整型的指针，可以确保指针`ptr`不会修改数组的值。
通过`ptr`可以访问数组的元素，但不能修改它们的值。
这两种方案都可以实现将数组引用声明为常量的目的，具体选择哪种方案可以根据实际需要来决定。
云台控制代码
云台控制代码以下是一个简单的云台控制代码示例，适用于Arduino平台。
该代码通过串口接收指令来控制云台的运动，包括俯仰和水平方向的旋转。
cpp#include <Servo.h>// 云台控制引脚定义const int pitchServoPin = 9; // 俯仰舵机引脚const int yawServoPin = 10; // 水平舵机引脚// 云台控制角度范围const int minPitchAngle = 0; // 最小俯仰角度const int maxPitchAngle = 180; // 最大俯仰角度const int minYawAngle = 0; // 最小水平角度const int maxYawAngle = 180; // 最大水平角度// 串口通信参数const int baudRate = 9600; // 串口波特率// 创建舵机对象Servo pitchServo;Servo yawServo;void setup() {// 初始化串口通信Serial.begin(baudRate);// 云台舵机引脚设置为输出模式pitchServo.attach(pitchServoPin);yawServo.attach(yawServoPin);}void loop() {if (Serial.available() > 0) {// 读取串口指令int command = Serial.parseInt();// 执行相应的控制switch (command) {case 1:// 向上俯仰pitchUp();break;case 2:// 向下俯仰pitchDown();break;case 3:// 向左旋转yawLeft();break;case 4:// 向右旋转yawRight();break;default:// 停止运动stopMotion();}// 等待舵机调整到指定位置delay(15);}}// 俯仰舵机向上运动void pitchUp() {int angle = pitchServo.read() + 1; if (angle > maxPitchAngle) {angle = maxPitchAngle;}pitchServo.write(angle);}// 俯仰舵机向下运动void pitchDown() {int angle = pitchServo.read() - 1; if (angle < minPitchAngle) {angle = minPitchAngle;}pitchServo.write(angle);}// 水平舵机向左旋转void yawLeft() {int angle = yawServo.read() - 1;if (angle < minYawAngle) {angle = minYawAngle;}yawServo.write(angle);}// 水平舵机向右旋转void yawRight() {int angle = yawServo.read() + 1;if (angle > maxYawAngle) {angle = maxYawAngle;}yawServo.write(angle);}// 停止云台运动void stopMotion() {// 停止俯仰舵机运动pitchServo.write(pitchServo.read());// 停止水平舵机运动yawServo.write(yawServo.read()); }。
const int用法
const int用法
"const int" 是 C++ 中用于声明一个常量整数的关键字组合。
在 C++ 中，const 表示常量，int 表示整数类型。
将它们组合起来就可以声明一个常量整数。
常量整数是一个在程序运行时不可修改的值，它在声明时必须被初始化。
一旦初始化后，就不能再改变它的值。
常量整数的声明语法如下：
```cpp
const int identifier = value;
```
其中：
- const：关键字，表示常量。
- int：数据类型，表示整数。
- identifier：标识符，表示常量的名字。
- value：常量的初始值。
例如，下面的代码声明了一个名为MAX_VALUE 的常量整数，它的初始值为 100：
```cpp
const int MAX_VALUE = 100;
```
在程序的其他地方，如果需要使用 MAX_VALUE，可以直接使用它的名字，而不必关心它的具体值。
例如：
```cpp
int num = MAX_VALUE * 2;
```
在上述示例中，变量 num 的值将是 200。
需要注意的是，常量整数在声明时必须被初始化，且一旦初始化后就不能再修改它的值。
试图修改常量整数的值将导致编译错误。
例如：
```cpp
const int MAX_VALUE = 100;
MAX_VALUE = 200; // 编译错误！常量值不能改变。
```
总结起来，const int 的用法可以用来声明一个不可修改的整数常量。
- 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****************。