const的常用用法大总结

合集下载

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

static const的用法

static const的用法
static const是用于定义常量的关键字。

它可以用于在编译时定
义一个常量，使得这个常量在运行时无法被修改。

在C++中，static const常量的定义通常放在类的静态成员变量或全局作用
域中。

例子：
```cpp
// 在类中使用static const定义常量
class MyClass {
public:
static const int MY_CONSTANT = 10;
};
// 在全局作用域中使用static const定义常量
static const double PI = 3.14159;
int main() {
// 访问类中的静态常量
int x = MyClass::MY_CONSTANT;
// 使用全局作用域中的常量
double radius = 5.0;
double circumference = 2 * PI * radius;
return 0;
}
```
在上述例子中，MyClass类中的MY_CONSTANT通过static const定义为常量，值为10。

全局作用域中的PI也被定义为常量，并且在main函数中使用。

这些常量在编译时被确定，并且在运行时无法被修改。

注意事项：
- static const常量必须在声明时进行初始化，且只能初始化一次。

- static const常量的值必须是编译时可以确定的表达式，例如字面值、其他常量等。

- static const常量的作用域与所在的类或全局作用域相同，可以通过类名或变量名进行访问。

constcast的用法

constcast的用法在C++中，constcast是一个非常有用的操作符，用于将const对象从参数列表、指针、引用等会导致其值被修改的上下文中“提取”出来，以便进行修改。

本篇文章将分步骤阐述constcast的用法，以帮助读者更好地掌握这一操作符的具体实现。

1. constcast的介绍在C++语言中，使用const修饰符可以定义一个对象为不可修改的。

此时，如果需要对该对象进行修改，就需要使用constcast操作符。

这个操作符会将const对象"解除"在一定程度上的"只读"限制，然后进行修改操作。

因此，constcast是一种类型转换操作，用于处理常量类型转换。

2. constcast的语法在C++中，constcast的语法如下：const_cast<type*>(expression);其中，type表示要转换成的类型，expression表示被转换的对象或指针。

这个语法中的<>方括号并不是必需的，但加上可以帮助我们更好地理解转换的过程。

3. constcast的用法在实际编程中，constcast主要用于以下情况：(1). 去除对象的const属性。

例如：const int x = 3333;int& rx = const_cast<int&>(x);(2). 告诉编译器某种指针类型是const的。

(3). 在函数参数中传递常量指针，而调用方需要非常量指针。

(4). 在类成员函数中去掉指针成员函数的限制。

(5). 在继承类中重写一个接受const参数的函数，但需要在子类中修改参数值的情况下。

以(1)为例，constcast可以将x的const属性去除，变成非const整型。

这段代码中，通过对x的引用rx，我们可以对非const 整数进行操作。

需要注意的一点是，这样的操作并不是安全的，因为本来是const的对象被修改后，程序行为的结果是不可预知的。

const在函数声明中的应用

const在函数声明中的应⽤1.在⼀个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。

有如下⼏种情况，以下会逐渐的说明⽤法：A& operator=(const A& a);void fun0(const A* a );void fun1( ) const; // fun1( ) 为类成员函数const A fun2( );1）修饰参数的const，如 void fun0(const A* a ); void fun1(const A& a);调⽤函数的时候，⽤相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进⾏常量化，如形参为const A* a，则不能对传递进来的指针的内容进⾏改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引⽤对象进⾏改变，保护了原对象的属性。

[注意]：参数const通常⽤于参数为指针或引⽤的情况，且只能修饰输⼊参数;若输⼊参数采⽤“值传递”⽅式，由于函数将⾃动产⽣临时变量⽤于复制该参数，该参数本就不需要保护，所以不⽤const修饰。

[总结]：对于⾮内部数据类型的输⼊参数，因该将“值传递”的⽅式改为“const引⽤传递”，⽬的是为了提⾼效率。

例如，将void Func(A a)改为void Func(const A &a)对于内部数据类型的输⼊参数，不要将“值传递”的⽅式改为“const引⽤传递”。

否则既达不到提⾼效率的⽬的，⼜降低了函数的可理解性。

例如void Func(int x)不应该改为void Func(const int &x)2）修饰返回值的const，如const A fun2( ); const A* fun3( );这样声明了返回值后，const按照"修饰原则"进⾏修饰，起到相应的保护作⽤。

js const 方法

js const 方法
在JavaScript中，`const`关键字用于声明一个常量，这意味着一旦给定一个值，该常量就不能再被重新赋值。

下面是一个简单的示例：
```javascript
const PI = ;
(PI); // 输出
// 尝试重新赋值
PI = ; // 这会导致错误，因为 PI 是一个常量
```
在上面的代码中，`PI`被声明为一个常量，并被初始化为``。

尝试重新赋值会引发一个错误，因为`PI`是一个常量。

需要注意的是，使用`const`声明的变量不能被重新赋值，但这并不意味着其引用的对象不能被修改。

如果`const`声明的变量引用了一个对象，你可以修改这个对象的状态，但不能让这个变量引用另一个对象。

例如：
```javascript
const person = { name: 'Alice' };
= 25; // 这是允许的，因为 person 引用的是一个对象
person = { name: 'Bob', age: 30 }; // 这会导致错误，因为 person 是一个常量
```
在上面的代码中，我们可以修改`person`对象的状态（例如设置其`age`属性），但不能让`person`引用另一个对象。

const在javascript的解释

在JavaScript中，const是一个关键字，用于声明一个不可变的常量。

它用于声明一个值，该值在声明后不能被重新赋值。

一旦使用const关键字声明一个变量，就不能再使用=运算符来改变该变量的值。

const声明的常量必须在声明时进行初始化，即必须给它一个初始值。

这意味着在声明const变量时，必须同时为其赋一个值。

例如：const PI = 3.14;
在上面的例子中，PI被声明为一个常量，并被赋值为3.14。

一旦声明后，无法再对PI进行重新赋值。

需要注意的是，const声明的常量是块级作用域的，它们只在声明它们的块中可见。

如果在函数内部声明一个const常量，则它只在该函数内部可见。

另外，const声明的常量不是完全不可变的。

如果常量是一个对象，那么对象的属性仍然可以被修改。

这是因为const只保证变量引用的地址不变，而不保证对象本身的内容不变。

总结起来，const关键字用于声明一个不可变的常量，它的值在声明后不能被重新赋值。

const在python的用法_概述及解释说明

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与变量的区别与变量不同，常量具有以下几个特点：- 常量只能在定义时进行赋值，在之后不能再被修改。

php 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的类常量，并在类的方法中使用了该常量。

C语言中const关键字用法总结

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

CPP中的CONST总结

C++中const总结对于基本声明1. const int r=100; //标准const变量声明加初始化，因为默认内部连接所以必须被初始化，其作用域为此文件，编译器经过类型检查后直接用100在编译时替换2. extend const int r=100; //将const改为外部连接，作用于扩大至全局，编译时会分配内存，并且可以不进行初始化，仅仅作为声明，编译器认为在程序其他地方进行了定义3. const int r[ ]={1,2,3,4};struct S {int a,b;};const S s[ ]={(1,2),(3.4)}; //以上两种都是常量集合，编译器会为其分配内存，所以不能在编译期间使用其中的值，例如：int temp[r[2]];这样的编译器会报告不能找到常量表达式对于指针1. const int *r=&x; //声明r为一个指向常量的x的指针，r指向的对象不能被修改，但他可以指向任何地址的常量2. int const *r=&x; //与用法1完全等价，没有任何区别3. int * const r=&x; //声明r为一个常量指针，他指向x，r这个指针的指向不能被修改，但他指向的地址的内容可以修改4. const int * const r=&x; //综合1、3用法，r是一个指向常量的常量型指针对于类型检查可以把一个非const对象赋给一个指向const的指针，因为有时候我们不想从这个指针来修改其对象的值；但是不可以把一个const对象赋值给一个非const指针，因为这样可能会通过这个指针改变指向对象的值，但也存在使这种操作通过的合法化写法，使用类型强制转换可以通过指针改变const对象：const int r=100;int * ptr = const_cast<int*>(&r); //C++标准，C语言使用：int * ptr =(int*)&r;对于字符数组如char * name = “china”; 这样的语句，在编译时是能够通过的，但是”china”是常量字符数组，任何想修改他的操作也能通过编译但会引起运行时错误，如果我们想修改字符数组的话就要使用char name[ ] = “china”; 这种形式。

const = ref()用法

一、const和ref的基本概念const和ref都是在编程中常见的关键词，它们在不同的语言中可能有不同的用法，但总体来说，它们都与变量和数据的存储有关。

const表示常量，即其值在声明后不能被改变，而ref则表示引用，即其值是另一个变量的位置区域。

二、const和ref的区别1. const的使用const通常用于声明常量，其值在声明后不可改变。

在一些编程语言中，const还可以用于定义常量函数、常量方法等。

在使用const声明变量时，需要保证其值是确定的，不能是变量、函数的返回值或其他动态的值。

2. ref的使用ref则常用于创建变量的引用。

在C++中，可以通过符号来获取变量的位置区域，从而创建引用。

在其他语言中，也有类似的操作符或关键词来表示引用。

通过引用，可以在不改变原变量值的基础上对其进行操作，这在函数参数传递中很常见。

三、const和ref的结合使用在某些情况下，const和ref还可以结合使用。

比如在C++中，可以使用const引用来防止函数对参数的修改，同时保证函数的输入参数不被改变。

这样一来，即保证了数据的安全性，又提高了程序的运行效率。

四、const ref的适用场景1. 在函数参数传递中，使用const ref可以避免不必要的数据复制，提高程序的运行效率；2. 在声明常量时，使用const可以明确表明该变量的值不会改变，增强代码的可读性和可维护性；3. 在涉及到大量数据处理的程序中，适当地使用const和ref可以优化内存的使用和程序的运行效率。

五、const ref的注意事项1. 在使用const ref时，需要确保在函数内部不会修改参数的值，否则可能会导致未知的错误；2. 在声明常量时，需要确保其值是在编译时就可以确定的，而不是在运行时才确定的。

六、总结const和ref是编程中常见的关键词，它们分别表示常量和引用。

在程序设计中，适当地使用const和ref可以提高程序的效率和安全性，同时也增强了代码的可读性和可维护性。

const超详细用法详解,史上最全

4. 可以节省空间，避免不必要的内存分配。
例如：
#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声明禁止这种修改。

delphi const用法

delphi const用法Delphi是一种面向对象的编程语言，其const关键字在变量和常量定义中起着重要的作用。

在本文中，我们将详细探讨Delphi中const的用法。

我们将一步一步回答有关Delphi const的问题，包括const的基本概念、常量的定义和使用、const与其他类型之间的关系以及const在Delphi 中的最佳实践。

第一步：基本概念在Delphi中，const是一个关键字，用于定义常量。

常量是不可更改的值，其值在编译时确定，并在程序运行期间保持不变。

const的值是在编译时确定的，因此无法在程序运行时改变。

第二步：常量的定义和使用要定义一个常量，可以使用const关键字和变量名来指定常量的名称。

常量定义的语法如下：const常量名称: 常量类型= 常量值;例如，要定义一个名为Pi的常量，其值为3.14159，可以使用以下代码：constPi: Double = 3.14159;在程序中使用常量时，只需使用其名称即可。

而不需要使用赋值语句。

例如，可以在数学计算中使用常量Pi来计算圆的面积：varradius: Double;area: Double;beginradius := 5.0;area := Pi * radius * radius;end;第三步：const与其他类型之间的关系在Delphi中，const可以用于不同的数据类型，包括整数、浮点数、字符串和枚举类型等。

通过适当地声明常量类型，可以确保在编译时进行类型检查，并避免错误的数据操作。

例如，要定义一个字符串类型的常量，可以使用以下代码：constGreeting: string = 'Hello, World!';可以在程序中使用常量Greeting来输出问候语：beginWriteln(Greeting);end;此外，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是一种在金融领域中常用的函数，它在计算股票价格和股票收益率时起到了重要的作用。

本文将介绍股票函数const 的定义、应用场景以及计算方法，以帮助读者更好地理解和应用这一函数。

一、股票函数const的定义股票函数const是指在计算股票价格和股票收益率时所使用的函数。

它的英文全称是“Constant”,意思是常数，也就是在计算中不会发生变化的值。

在股票领域中，const通常用于计算股票的年化收益率和股票的现值。

二、股票函数const的应用场景股票函数const在金融领域中有着广泛的应用场景，其中包括：1. 计算股票的年化收益率：通过使用const函数，可以将股票的日收益率或月收益率转化为年化收益率，以便更好地评估股票的盈利能力和风险。

2. 计算股票的现值：通过使用const函数，可以将未来的股票收益折算为现值，以便进行投资决策和估值分析。

3. 计算股票的风险收益比：通过使用const函数，可以将股票的预期收益与风险进行比较，以帮助投资者更好地评估股票的投资价值和风险水平。

三、股票函数const的计算方法股票函数const的计算方法根据具体的应用场景而不同，下面将介绍两种常见的计算方法：1. 计算股票的年化收益率：年化收益率 = (1 + 日收益率)^365 - 1其中，日收益率是指股票每日的收益率。

通过将日收益率加1后乘以365，再减去1，即可得到股票的年化收益率。

2. 计算股票的现值：现值 = 未来收益 / (1 + 折现率)^n其中，未来收益是指股票未来的预期收益，折现率是指投资者对未来收益的折现率，n是指未来收益的时间跨度。

通过将未来收益除以(1 + 折现率)^n，即可得到股票的现值。

四、总结股票函数const是金融领域中常用的函数，它在计算股票价格和股票收益率时起到了重要的作用。

通过使用const函数，可以计算股票的年化收益率和现值，帮助投资者更好地评估股票的盈利能力和风险。

关键字：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在一定程度上可以提高程序的安全性和可靠性，另外，在观看别人代码的时候，清晰理解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指向的变量也是常量。

Dan Saks总结的const所有用法

In my last column, I discussed one of the reasons why the rules by which a compiler can place data into ROM are a bit more complicated in C++ than they are in C.1I have more to say about that subject, but before I do, I’d like to reply to the following query I received through e-mail from Phil Baurer at Komatsu Mining Systems:“We’re having an interesting prob-lem using const with a typedef. I hoped you could comment on this sit-uation. I am wondering if we are bumping into some unknown (by us) rule of the C language.“We are using the Hitachi C com-piler for the Hitachi SH-2 32-bit RISC microcontroller. We thought the fol-lowing code:t y p e d e f v o i d*V P;c o ns t V P v e c t o r T a b l e[]={..<d a t a>..};(1) should be identical to:c o ns t v o i d*v e c t o r T a b l e[]={..<d a t a>..};(2)“However, the linker places v e c t o r T a b l e in (1) into the C O N S T A N T section, but it places v e c t o r T a b l e in (2) into the D A T A section.“Is this the proper behavior or a bug in the compiler?”This is proper behavior; it is not a bug. You are indeed bumping into some rules of the C language that you apparently don’t know about. Don’t feel bad; you’re not alone. I believe many other C and C++ pro-grammers are confused about theserules, which is why I’m answering thisin my column.I presented some of these rules inan earlier column.2However, in look-ing back at that column, I don’t thinkI emphasized strongly enough thepoints which seem to be the sourceof your confusion. So let me tryagain.Declarat orsHere’s the first insight:Every declaration in C and C++ has twoprincipal parts: a sequence of zero or moredeclaration specifiers, and a sequence ofone or more declarators, separated bycommas.For example:A declarator is the name beingdeclared, possibly surrounded byoperators such as *, [], (), and (in thecase of C++) &. As you already know,the symbol *in a declarator means“pointer to” and []means “array of.”Thus, *x[N]is a declarator indicatingthat x is an “array of N elements ofpointer to ...” something, where thatsomething is the type specified in thedeclaration specifiers. For example,s t a t i c u ns i g ne d l o ng i nt*x[N];declares x as an object of type “array ofN elements of pointer to unsignedlong int.” (As explained later, the key-word s t a t i c does not contribute tothe type.)How did I know that *x[N]is an“array of ... pointer to ...” rather than a“pointer to an array of ...?” It followsfrom this rule:The operators in a declarator group accord-ing to the same precedence as they do whenthey appear in an expression.For example, if you check the near-est precedence chart for either C orC++, you’ll see that []has higherprecedence than *. Thus the declara-tor *x[N]means that x is an arraybefore it’s a pointer.Parentheses serve two roles indeclarators: first, as the function calloperator, and second, as grouping. Asthe function call operator, ()have thesame precedence as []. As grouping,()have the highest precedence of all.Embedded Systems Programming FEBRUARY 1999 13Dan Saks const T vs.T constAlthough C and C++ read mostly from top-to-bottom and left-to-right, pointer declarationsread, in a sense, backwards.For example, *f (i nt )is a declarator specifying that f is a “function ...returning a pointer ... .” In contrast,(*f )(i nt )specifies that f is a “pointer to a function ... .”A declarator may contain more than one identifier. The declarator *x [N ]contains two identifiers, x and N .Only one of those identifiers is the one being declared, and it’s called the declarator-id. The other(s), if any,must have been declared previously.For instance, the declarator-id in *x [N ]is x .A declarator need not contain any operators at all. In a declaration as simple as:i nt n;the declarator is just the identifier n without any operators.Declaration specifiersSome of the declaration specifiers leading up to a declarator can be type specifiers such as i nt , u ns i g ne d , or an identifier that names a type. They can also be storage class specifiers such as e x t e r n or s t a t i c . In C++ they can also be function specifiers such as i nl i ne or v i r t u a l .Here’s another insight: Type specifiers contribute to the type of the declarator-id; other specifiers provide non-type information that applies directly to the declarator-id.For example:s t a t i c u ns i g ne d l o ng i nt *x [N ];declares x as a variable of type “array of N elements of type pointer to unsigned long int.” The keyword s t a -t i c specifies that x has statically allo-cated storage.The examples in your letter lead me to suspect that you may have been tripped up by the fact that:The keywords c o ns t and v o l a t i l e are type specifiers.For example, the const in:c o ns t v o id *ve c t o r T a b l e []= {..<d a t a >..};(2)does not apply directly to v e c t o r T a b l e ;it applies directly to v o i d . This decla-ration declares v e c t o r T a b l e as a vari-able of type “array of pointer to const void.” It appears that you were expect-ing it to be “const array of pointer to void.”Here’s yet another important insight:The order in which the declaration speci-fiers appear in a declaration doesn’t matter.Thus, for example,c o ns t V P v e c t o r T a b l e []is equivalent to:V P c o ns t v e c t o r T a b l e []andc o ns t v o id *ve c t o r T a b l e []is equivalent to:v o i d c o ns t *v e c t o r T a b l e []Most of us place storage class speci-fiers such as s t a t i c as the first (left-most) declaration specifier, but it’s just a common convention, not a language requirement.The declaration specifiers c o n s t and v o l a t i l e are unusual in that:The only declaration specifiers that can also appear in declarators are c o n s t and v o l a t i l e .For example, the const in:v o i d *c o ns t v e c t o r T a b l e []appears in the declarator. In this case,you cannot rearrange the order of the keywords. For example:*c o ns t v o i d v e c t o r T a b l e []is an error.A clarifying styleAs I explained earlier, the order of the declaration specifiers doesn’t matter to the compiler. Therefore, these dec-larations are equivalent:c o ns t v o id *ve c t o r T a b l e [] (3)v o i d c o ns t *v e c t o r T a b l e [](4)Almost all C and C++ programmers prefer to write const and volatile to the left of the other type specifiers, as in (3). I prefer to write const and volatile to the right, as in (4), and I recom-mend it. Strongly.Although C and C++ read mostly from top-to-bottom and left-to-right,pointer declarations read, in a sense,backwards. That is, pointer declara-tions read from right-to-left. By plac-ing const to the right of the other type specifiers, you can read pointer decla-rations strictly from right-to-left and get const to come out in the “right”places. For example:T c o ns t *p ;declares p as a “pointer to a const T,”which is exactly what it is. Also:T *c o ns t p ;declares p as a “const pointer to a T,”which is also the correct interpretation.Writing const to the right of the14FEBRUARY 1999 Embedded Systems ProgrammingMost of us place storage class specifiers such as static as the first (leftmost)declaration specifier, but it’s just a common convention, not a languagerequirement.which makes it appear that v e c t o r T a b l e has type “array of pointer to const void.” This is wrong! The cor-rect interpretation is to replace VP as:uses. Just about everyone who usesconst places it to the left. However,given how few C and C++ program-mers really understand what they’redoing when it comes to using const indeclarations, “everyone else does it” ishardly an argument in favor of thecurrently popular style. Why not buckthe trend and try using a clearer style?As long as I’m on a roll here, Imight as well get in my digs in on arelated style point. Although most Cprogrammers seem to have remainedunsullied by this, many C++ program-mers have acquired the most unfortu-nate habit of writing:c o ns t i nt*p;rather than:c o ns t i nt*p;That is, they use spacing to join the *with the declaration specifiers ratherthan with the declarator. I reallybelieve C++ programmers do them-selves and each other a disservicewhen they write declarations in thisstyle. Sure, the spacing makes no dif-ference to the compiler, but puttingthe space after the *leaves many peo-ple with a false impression about theunderlying structure of declarations.Recognizing the boundary betweenthe last declaration specifier and thedeclarator is one of the keys to under-standing declarations. Breaking updeclarators with spaces this way onlyconfuses the situation.I hope I’ve answered your questionand clarified some issues.e s pDan Saks is the president of Saks &Associates, a C/C++ training and consult-ing company. He is also a contributing edi-tor for the C/C++ Users Journal. Heserved for many years as secretary of the C++standards committee and remains an activemember. With Thomas Plum, he wrote C++Programming Guidelines. You can writeto him at dsaks@.References1. “Static vs. Dynamic Initialization,”December 1998, p. 19.2. “Placing c o n s t in Declarations,” June1998, p. 19.16FEBRUARY 1999 Embedded Systems Programming。