const和static的区别
static const 函数
静态常量函数（static const function）是C++编程中的重要概念。
在本文中，我们将深入探讨静态常量函数的定义、用途和特点，以及如何在代码中正确地使用它。
通过本文的阐述，读者将能够全面理解静态常量函数的作用，从而在实际编程中更加灵活和高效地运用这一概念。
1. 静态常量函数的定义静态常量函数是指在C++中定义为静态（static）和常量（const）的成员函数。
静态函数以关键字static进行修饰，它属于整个类而不是类的某个特定对象，因此不含有指向具体对象的指针（this指针），而是对类的所有实例共享。
常量函数以关键字const进行修饰，在函数声明的尾部加上const关键字表示该函数是一个常量函数，它承诺不会修改对象的成员变量。
2. 静态常量函数的用途静态常量函数在C++编程中具有重要的作用。
静态函数可以直接通过类名调用，不需要对象的存在，因此可以用来处理类的整体数据。
常量函数保证对象的成员变量不被修改，从而增强了程序的可靠性和安全性。
静态常量函数的结合，使得程序设计更加合理和灵活。
3. 静态常量函数的特点静态常量函数具有以下几个特点：（1）静态函数属于整个类，可以直接通过类名调用；（2）常量函数在函数声明的尾部加上const关键字，承诺不会修改对象的成员变量；（3）静态常量函数一般不使用this指针，因为它们不属于任何具体对象。
4. 如何正确使用静态常量函数正确使用静态常量函数可以帮助我们更加高效地编写C++程序。
我们应该清楚地理解静态常量函数的定义和用途，从而在程序设计时充分利用它们的特点。
我们需要注意在类的声明和定义中正确声明和定义静态常量函数，并且在调用时使用类名而不是对象名。
我们需要谨慎地使用const关键字，以保证常量函数不会修改对象的成员变量。
总结静态常量函数是C++编程中的重要概念，它既包含了静态函数的特点，又具有常量函数的安全性。
正确使用静态常量函数可以帮助我们更加灵活和高效地编写C++程序。
static 和 const
static和const
static:
static全局变量：只有本文件函数可引用，在整个程序运行中都存在（生命周期没变，作用域变小）
static局部变量：只有定义该局部变量的函数可引用，整个程序执行过程中都存在（生命周期变长，作用域不变）
static所声明的变量都存在静态区，即一开始系统会自动初始化，默认初始化的值为“0”
全局变量：作用域从定义该变量开始到源程序文件的结束。
（存储在静态区，系统会自动初始化，默认初始化值为“0”）
局部变量：作用域仅限于函数或复合语句内（使用前一定要初始化，因为定义时，系统只是给了一块栈空间给它，那栈空间之前存的是什么数据系统不管也不会自动清零）
注：可以定义局部变量时尽量使用局部，全局变量存在静态区（堆），局部变量存在寄存器（栈）中。
const:可以暂且当作是只读的一个声明。
（可能还有其它作用）。
c++语言static constexpr const的作用和用法
c++语言static constexpr const的作用和用法在C语言中，static、constexpr和const这三个关键字都具有特殊的含义，它们在编译时期就有特殊的作用。
首先，我们来看一下static关键字。
在C语言中，static关键字具有多种含义，但在这种情况下，我们主要关注其存储分类的意义。
在C语言中，变量可以根据其存储位置分为三种类型：自动存储分类（automatic storage duration）、静态存储分类（static storage duration）和外部存储分类（external storageduration）。
其中，static关键字修饰的变量具有静态存储分类，它们在程序执行期间只分配一次，其值在整个程序执行期间保持不变。
接下来，我们来看一下constexpr关键字。
在C++11及其后续版本中，constexpr是一个关键字，它用于指示一个变量或函数可以在编译时期进行求值。
当constexpr被应用于一个变量或函数时，编译器会尝试在编译时期就计算出结果，而不是等到运行时期。
这对于编译时就能确定结果的情况非常有用，因为它可以大大提高编译的效率。
最后，我们来看一下const关键字。
在C语言中，const关键字用于声明一个变量的只读性。
当一个变量被声明为const时，它的值就不能被改变。
这对于确保程序的稳定性和防止意外的数据更改非常有用。
这三个关键字在C语言中的组合使用可以产生一些有趣的效果。
例如，我们可以使用static const constexpr来创建一个常量。
这样的常量在编译时期就能求值，并且具有静态存储分类，这意味着它们在整个程序执行期间都保持不变。
这样的常量通常用于定义程序的固定值，例如常数和标志。
另外，我们还可以使用constexpr来创建更高效的常量。
例如，如果我们有一个数组的大小是在编译时期就能确定的话，我们就可以使用constexpr来声明这个数组。
类的static,const,static const , const static成员的初始化
类的static,const,static const , const static成员的初始化1.类里的const成员初始化：在一个类里建立一个const时，不能给它初值。
像class foo{private：const int i = 100;public:foo(){}......};这样的初始化方式是不能通过编译的，因为在类对象里进行了存储空间分配，编译器不能知道const的内容是什么，所以不能把它用作编译期间的常量。
这意味着对于类里的常数表达式来说，const就像它在C中一样没有作用。
因此这个初始化工作必须发生在构造函数里，并且，要在构造函数的某个特别的地方。
因为const必须在建立它的地方被初始化，所以在构造函数的主体里，const必须已初始化了，否则，就只有等待，直到在构造函数主体以后的某个地方给它初始化，这意味着过一会儿才给const初始化。
当然，无法防止在在构造函数主体的不同地方改变const的值。
构造函数初始化表达式class foo{private：const int i = 100;public:foo(){......}......};如果构造函数是在类外定义，则可以这样写：class foo{private：const int i;public:foo()；......};foo::foo(): i(100){......}2.类里的static成员初始化：类中的static变量是属于类的，而不是属于某个对象，它在整个程序的运行过程中只有一个副本，因此不能在定义对象时对变量初始化，就是不能用构造函数来初始化。
其正确的初始化方式是：<数据类型><类名>::<静态数据成员名>=<值> ，例如class foo{private：const int i;public:foo()；......};int foo::i=100；这表明：(1)初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆。
C语言static和const的区别
C语⾔static和const的区别static:1、不考虑类，static的作⽤：1)第⼀个作⽤：隐藏。
使得全局变量和函数对其它⽂件不可见，同时避免了不同⽂件的命名冲突。
2)第⼆个作⽤：默认初始化为0。
未初始化的全局静态变量和局部静态变量都保存在BBS段，BBS段的特点是，程序运⾏之前会⾃动清零。
3)第三个作⽤：保持局部变量内容的持久性。
此变量声明周期是整个程序的声明周期，但是作⽤域只在声明它的函数中。
2、类中的static，表⽰属于某个类单数不属于类的任何特定对象的变量和函数。
1)对于类的静态数据成员：a、类的静态数据成员独⽴于该类的任意对象⽽存在；其值的修改被类的所有对象看见。
b、static数据成员必须在类定义的外部定义，通常放在包含类的⾮内联成员函数定义的⽂件中。
class A{stctic double d = 0.03;//错误};c、但是也有例外，const static 数据成员可以在类的定义体中进⾏初始化，因为const定义时必须初始化。
2)对于类的成员函数：a、static成员函数由于不与任何对象关联，因此它不具备this指针，因此，它⽆法访问属于类对象的⾮静态数据成员，也⽆法访问⾮静态成员函数。
也就是说，类的静态成员函数，只能调⽤该类的其它静态成员函数和静态数据成员。
b、static成员不是任何对象的组成部分，所以成员函数不能被声明为const。
此外，static成员函数也不可以声明为virtual,volatile。
关于静态成员函数的总结：(1)静态成员之间可以相互访问，不能访问⾮静态成员。
⾮静态成员函数可以任意访问静态和⾮静态成员。
(2)静态函数执⾏速度⽐⾮静态函数稍快。
const:1、const定义后就不能修改，因此定义时要初始化。
2、在C语⾔中const buffsize = 10;int buf[buffsize];是错误的；⽽在C++中是正确的。
C中改为const int buffsize；3、使⽤const⽐使⽤#define有更多的优点：1)const常量有数据类型，⽽宏常量没有。
Const的经典用法& Const与Static的区别
Const经典用法1.基本解释const是一个C语言的关键字，它限定一个变量不允许被改变。
使用const在一定程度上可以提高程序的健壮性，另外，在观看别人代码的时候，清晰理解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语言面试题：关键字static,const,volatile的用法
被无意的代码修改。简而言之，这样可以减少 bug 的出现。
Volatile
97.关键字volatile有什么含意 并给出三个不同的例子。
一个定义为 volatile 的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假
int const * a const;
前两个的作用是一样，a是一个常整型数。第三个意味着 a是一个指向常整型数的指针（也
就是，整型数是不可修改的，但指针可以）。第四个意Βιβλιοθήκη a 是一个指向整型数的常指针（也
就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着 a 是一
3). 多线程应用中被几个任务共享的变量
回答不出这个问题的人是不会被雇佣的。我认为这是区分 C 程序员和嵌入式系统程序员的
最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求
volatile 变量。不懂得 volatile 内容将会带来灾难。 假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一
{
return *ptr * *ptr;
}
下面是答案：
1). 是的。一个例子是只读的状态寄存器。它是 volatile 因为它可能被意想不到地改变。它
是 const 因为程序不应该试图去修改它。
2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个 buffer 的
设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这
个变量的值，而不是使用保存在寄存器里的备份。下面是 volatile 变量的几个例子：
对关键字staic和const的用法
静态与常量的使用在编程中占据着重要的位置。
静态变量和常量的定义和使用能够提高程序的性能和可维护性。
在本文中，将对st本人c 和const的用法进行详细的介绍和讨论。
一、静态(static)变量的定义和使用1. 静态变量的定义静态变量是指在程序运行期间保持不变的变量。
静态变量可以在全局作用域中和局部作用域中定义。
在全局作用域中定义的静态变量在整个程序运行期间都是可见的，而在局部作用域中定义的静态变量只在该函数中可见。
2. 静态变量的使用静态变量的作用范围和生命周期与普通变量不同。
静态变量只在程序运行期间分配一次内存，并且在程序退出之前一直保持其值不变。
静态变量可以用于保存程序的状态信息，也可以用于在函数调用之间传递信息。
3. 静态变量的优点静态变量的优点在于可以节省内存空间，提高程序的运行效率，同时也能够减少对全局变量的使用，提高程序的可维护性。
二、常量(const)的定义和使用1. 常量的定义常量是指在程序运行期间保持不变的值。
常量可以在全局作用域和局部作用域中定义。
常量一旦被定义之后，其值将无法改变。
2. 常量的使用常量可以用于避免程序中的魔法数字，提高程序的可读性和可维护性。
常量也可以用于定义一些固定的数值或字符串，如圆周率、常用的字符串等。
3. 常量的优点常量的优点在于能够提高程序的可读性和可维护性，同时也能够提高程序的安全性，避免在程序运行期间被意外修改。
三、静态和常量的结合使用静态变量和常量在实际编程中经常结合使用，以提高程序的性能和可维护性。
静态常量可以用于定义一些固定的数值或字符串，并且保持在程序运行期间不变。
静态常量还可以用于优化程序的性能，避免重复的内存分配和释放。
四、总结静态变量和常量都是在程序中起着重要作用的关键字。
它们能够提高程序的性能和可维护性，同时也能够提高程序的安全性。
合理地使用静态和常量能够使程序更加稳定、高效。
在实际编程中，应当根据具体的需求来灵活地应用静态和常量，并且遵循编程规范，以便于他人能够理解和维护程序。
extern static const volatile 的用法与应用场景
extern static const volatile 的用法与应用场景在C/C++编程中，extern、static、const和volatile这四个关键字常常被组合使用，以实现一些特殊的效果。
这些关键字在编译和链接过程中起着重要的作用。
本文将详细介绍extern static constvolatile的用法，并列举一些应用场景。
一、extern关键字extern关键字用于声明一个变量或函数在别的文件中存在。
它告诉编译器在其他地方寻找这个变量或函数的定义。
二、static关键字static关键字用于给变量或函数添加静态属性。
静态变量和函数的作用域只限于定义它的文件，不能被其他文件访问。
这使得它们在编译时就可以被优化，并且可以在程序的多个实例之间共享。
三、const关键字const关键字用于声明一个变量或对象为常量。
它告诉编译器这个值一旦赋值后就不能改变。
const关键字可以提高代码的可读性和正确性，因为它防止了程序员无意间改变变量的值。
四、volatile关键字volatile关键字用于告诉编译器，引用的变量可能会被意想不到地改变。
这在处理硬件接口或者与外部设备交互时非常有用，因为这些设备的状态可能会被外部因素（如时间或其他硬件事件）意外地改变。
extern static const volatile的组合用法是指在一个文件中使用extern关键字声明另一个文件中定义了const和volatile属性的变量或函数，这在多个源文件共享资源时非常有用。
应用场景：1. 跨文件共享资源：当需要在多个源文件中共享数据或函数时，可以使用extern关键字来声明这些数据或函数在其他文件中定义。
2. 编译时优化：由于static关键字的作用，这些静态的const 和volatile变量或函数在编译时就可以被优化，并且在多个实例之间共享。
这对于资源有限的嵌入式系统等场景非常有用。
3. 硬件交互：在与外部硬件设备交互时，需要处理硬件状态的意外改变。
C语言const和static
C语⾔const和static
1. const 是constant 的缩写，“恒定不变”的意思。
被const 修饰的东西都受到强制保护，可以预防意外的变动，能提⾼程序的健壮性。
2. const可以修饰变量，函数的⼊参，函数的返回值
3. static第⼀个作⽤：隐藏. 当我们同时编译多个⽂件时，所有未加static前缀的全局变量和函数都具有全局可见性。
4. static的第⼆个作⽤是保持变量内容的持久。
存储在静态数据区的变量会在程序刚开始运⾏时就完成初始化，也是唯⼀的⼀次初始化。
5. static的第三个作⽤是默认初始化为0。
其实全局变量也具备这⼀属性，因为全局变量也存储在静态数据区。
在静态数据区，内存中所
有的字节默认值都是0x00，某些时候这⼀特点可以减少程序员的⼯作量。
static 和 const的解释
static 和 const的解释static 是c++中很常用的修饰符，它被用来控制变量的存储方式和可见性，下面我将从static 修饰符的产生原因、作用谈起，全面分析static 修饰符的实质。
static 的两大作用:一、控制存储方式：static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间。
1、引出原因：函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。
2、解决方案：因此c++ 中引入了static，用它来修饰变量，它能够指示编译器将此变量在程序的静态存储区分配空间保存，这样即实现了目的，又使得此变量的存取范围不变。
二、控制可见性与连接类型:static还有一个作用，它会把变量的可见范围限制在编译单元中，使它成为一个内部连接，这时，它的反义词为”extern”.static作用分析总结：static总是使得变量或对象的存储形式变成静态存储，连接方式变成内部连接，对于局部变量（已经是内部连接了），它仅改变其存储方式；对于全局变量（已经是静态存储了），它仅改变其连接类型。
类中的static成员：一、出现原因及作用：1、需要在一个类的各个对象间交互，即需要一个数据对象为整个类而非某个对象服务。
2、同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。
类的static成员满足了上述的要求，因为它具有如下特征：有独立的存储区，属于整个类。
二、注意：1、对于静态的数据成员，连接器会保证它拥有一个单一的外部定义。
静态数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。
C++中const 、static、 static const和const static的初始化以及修改问题
C++中const 、static、static const和const static的初始化以及修改问题本人系C++初学者，很渣很菜鸟，这也是本人写的第一篇有关C++的博文，说是写，不如说是对网络上高人博文的综合与整理。
（当然，凡是本文涉及到别人博客内容的，都将附上网址链接。
）写这篇博文的目的，是希望对相关知识做出尽可能全面、详尽、简易的解释，以供像我一样的初学者参考，同时也希望得到高人的批评与指正，以此来提高自己。
另外，为保证文章的针对性，同时也限于本人水平，本文只对相关类型的数据做出讨论，并不涉及函数的讨论。
下面，是我的一些整理与见解。
一、const、static、static const、const static变量的初始化Ⅰ.const的初始化（1）只有这一种情况const变量可以不在声明的同时定义，那就是const变量作为类的数据成员出现时。
例如：class Myclass{cons int a;//注意，在任何情况下，const int a与int const a等价,只不过人们习惯写前者};但要注意，这样做是毫无意义的，只是编译能够通过罢了，int const a什么也做不了，因为它没有值。
（2）凡是在函数（包括类中的，main函数及其它）中，const常量必须在声明时初始化，这是因为const被视为常量。
例如：class Myclass(){public:int test(){const int b;……}当输入int const b;一句时，在分号下面出现红色下划线，鼠标移到该处，出现报错：Error:常量变量“b”需要初始值设定项。
（注意，在本文中，以后这种情况我们简称为“下划线报错”）在main函数、全局函数中情况相似。
（3）作为全局常量在全局中写const int b;// 即不在类中，不在函数中写代码时不会出现下划线，但编译时报错：如果不是外部的，则必须初始化常量对象。
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) {
const和static的区别
const和static的区别
const和static的区别
⼀、const
1.static 局部变量将⼀个变量声明为函数的局部变量，那么这个局部变量在函数执⾏完成之后不会被释放，⽽是继续保留在内存中
2.static 全局变量表⽰⼀个变量在当前⽂件的全局内可访问
3.static 函数表⽰⼀个函数只能在当前⽂件中被访问
4.static 类成员变量表⽰这个成员为全类所共有
5.static 类成员函数表⽰这个函数为全类所共有，⽽且只能访问静态成员变量
作⽤：
（1）函数体内static变量的作⽤范围为该函数体，该变量的内存只被分配⼀次，因此其值在下次调⽤时仍维持上次的值；
（2）在模块内的static全局变量和函数可以被模块内的函数访问，但不能被模块外其它函数访问；
（3）在类中的static成员变量属于整个类所拥有，对类的所有对象只有⼀份拷贝；
（4）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因⽽只能访问类的static成员变量。
⼆、static
1.const 常量：定义时就初始化，以后不能更改。
2.const 形参：func(const int a){};该形参在函数⾥不能改变
3.const修饰类成员函数：该函数对成员变量只能进⾏只读操作
作⽤：
（1）阻⽌⼀个变量被改变
（2）声明常量指针和指针常量
（3）const修饰形参，表明它是⼀个输⼊参数，在函数内部不能改变其值；
（4）对于类的成员函数，若指定其为const类型，则表明其是⼀个常函数，不能修改类的成员变量；
（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为”左值”。
Java中this，static，final，const用法详解
Java中this，static，final，const⽤法详解⼀、this⽤类名定义⼀个变量的时候，定义的应该只是⼀个引⽤，外⾯可以通过这个引⽤来访问这个类⾥⾯的属性和⽅法，那们类⾥⾯是够也应该有⼀个引⽤来访问⾃⼰的属性和⽅法纳？JAVA提供了⼀个很好的东西，就是 this 对象，它可以在类⾥⾯来引⽤这个类的属性和⽅法。
Java关键字this只能⽤于⽅法⽅法体内。
当⼀个对象创建后，Java虚拟机（JVM）就会给这个对象分配⼀个引⽤⾃⾝的指针，这个指针的名字就是 this。
因此，this只能在类中的⾮静态⽅法中使⽤，静态⽅法和静态的代码块中绝对不能出现this，这在“Java关键字static、final 使⽤总结”⼀⽂中给出了明确解释。
并且this只和特定的对象关联，⽽不和类关联，同⼀个类的不同对象有不同的this。
总结⼀下，this主要要三种⽤法：１、表⽰对当前对象的引⽤！２、表⽰⽤类的成员变量，⽽⾮函数参数，注意在函数参数和成员变量同名是进⾏区分！其实这是第⼀种⽤法的特例，⽐较常⽤，所以那出来强⼀下。
３、⽤于在构造⽅法中引⽤满⾜指定参数类型的构造器（其实也就是构造⽅法）。
但是这⾥必须⾮常注意：只能引⽤⼀个构造⽅法且必须位于开始！注意：this不能⽤在static⽅法中！所以甚⾄有⼈给static⽅法的定义就是：没有this的⽅法！虽然夸张，但是却充分说明this不能在static⽅法中使⽤！⼆、staticstatic表⽰“全局”或者“静态”的意思，⽤来修饰成员变量和成员⽅法，也可以形成静态static代码块，但是Java语⾔中没有全局变量的概念。
被static修饰的成员变量和成员⽅法独⽴于该类的任何对象。
也就是说，它不依赖类特定的实例，被类的所有实例共享。
只要这个类被加载，Java虚拟机就能根据类名在运⾏时数据区的⽅法区内定找到他们。
因此，static对象可以在它的任何对象创建之前访问，⽆需引⽤任何对象。
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成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。
static,const和staticconst变量的初始化问题
static,const和staticconst变量的初始化问题const 常量的在超出其作⽤域的时候会被释放，但是 static 静态变量在其作⽤域之外并没有释放，只是不能访问。
static 修饰的是静态变量，静态函数。
对于类来说，静态成员和静态函数是属于整个类的，⽽不是属于对象。
可以通过类名来访问，但是其作⽤域限制于包含它的⽂件中。
static 变量在类内部声明，但是必须在类的外部进⾏定义和初始化。
const 常量在类内部声明，但是定义只能在构造函数的初始化列表进⾏。
class A {public:A(int a) : constNum(a) {}private:static int staticNum;const int constNum;};int A::staticNum = 100;从上⾯的代码可以看出，const 常量的不变形只是针对与⼀个对象来说的，同⼀个类的不同对象的 const 常量的值可以不⼀样。
如果想让 const 常量在类的所有实例对象的值都⼀样，可以⽤ static const (const static)，使⽤⽅式如下：1class A {2const static int num1; // 声明3const static int num2 = 13; // 声明和初始化4 };5const int A::num1 = 12; // 定义并初始化6const int num2; // 定义上⾯两种⽅式都可以对 const static 常量进⾏初始化。
注意，第 3 ⾏的代码并没有对 num2 进⾏定义，它只是进⾏声明。
其实这⾥给了值 13也没⽤进⾏初始化，因为变量必须在定义了以后才进⾏初始化。
但是我们会发现很奇怪的问题，如下：1class A {2public:3const static int num2 = 13; // 声明和【初始化】4 };56int main(int argc, char const *argv[])7 {8 cout << A::num2 << endl;9return0;10 }上⾯代码的执⾏结果是 13，也就是说，num2 还没有定义就可以使⽤了。
C#中的静态常量（const）和动态常量（static和readonly）用法和区别
C#中的静态常量（const）和动态常量（static和readonly）⽤法和区别C#中有两种常量类型，分别为readonly(运⾏时常量)与const(编译时常量)，本⽂将就这两种类型的不同特性进⾏⽐较并说明各⾃的适⽤场景。
⼯作原理readonly为运⾏时常量，程序运⾏时进⾏赋值，赋值完成后便⽆法更改，因此也有⼈称其为只读变量。
const为编译时常量，程序编译时将对常量值进⾏解析，并将所有常量引⽤替换为相应值。
下⾯声明两个常量：public static readonly int A = 2; //A为运⾏时常量public const int B = 3; //B为编译时常量下⾯的表达式：int C = A + B;经过编译后与下⾯的形式等价：int C = A + 3;可以看到，其中的const常量B被替换成字⾯量3，⽽readonly常量A则保持引⽤⽅式。
声明及初始化readonly常量只能声明为类字段，⽀持实例类型或静态类型，可以在声明的同时初始化或者在构造函数中进⾏初始化，初始化完成后便⽆法更改。
const常量除了可以声明为类字段之外，还可以声明为⽅法中的局部常量，默认为静态类型(⽆需⽤static修饰，否则将导致编译错误)，但必须在声明的同时完成初始化。
数据类型⽀持由于const常量在编译时将被替换为字⾯量，使得其取值类型受到了⼀定限制。
const常量只能被赋予数字(整数、浮点数)、字符串以及枚举类型。
下⾯的代码⽆法通过编译：public const DateTime D = DateTime.MinValue;改成readonly就可以正常编译：1public readonly DateTime D = DateTime.MinValue;可维护性readonly以引⽤⽅式进⾏⼯作，某个常量更新后，所有引⽤该常量的地⽅均能得到更新后的值。
const的情况要稍稍复杂些，特别是跨程序集调⽤：1public class Class12 {3public static readonly int A = 2; //A为运⾏时常量4public const int B = 3; //B为编译时常量5 }67public class Class28 {9public static int C = Class1.A + Class1.B; //变量C的值为A、B之和10 }1112 Console.WriteLine(Class2.C); //输出"5"假设Class1与Class2位于两个不同的程序集，现在更改Class1中的常量值：1public class Class12 {3public static readonly int A = 4; //A为运⾏时常量4public const int B = 5; //B为编译时常量5 }编译Class1并部署（注意：这时并没有重新编译Class2），再次查看变量C的值：1 Console.WriteLine(Class2.C); //输出"7"结果可能有点出乎意料，让我们来仔细观察变量C的赋值表达式：public static int C = Class1.A + Class1.B;编译后与下⾯的形式等价：public static int C = Class1.A + 3;因此不管常量B的值如何变，对最终结果都不会产⽣影响。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
const和static的区别
一、const关键字
如果把const放在变量类型名前，说明这个变量的值是保持不变的，该变量必须在定义时初始化，初始化后对它进行的任何赋值都是非法的。
当指针或者引用指向一个常量时，必须在类型名前使用const标识这个指针或者引用指向的“变量”为常量，没有的话就是语法错误。
如:const int x=5; const int*px=&x;const int&rx=x;这样一来，直接修改x是不可能的，通过*px或者rx修改x也是不可能的。
当然，这个指针还能指向其他的地方，因为指针本身并没有被标识为const的。
比如，px=&y;
假如变量是一个非常量变量，而指针或者引用的类型名前使用了const，那么，可以直接修改变量，不能通过指针或者引用修改变量。
如果想让一个指针本身成为const的，就要在*后加const，即int*const p =&x;这个时候，p就不能再指向其他变量。
假如x是非常量的，那它可以通过指针进行修改，因为x并没有标识为const。
当然，引用天生就是const的，它必须被初始化，而且初始化后就不能再指向新的变量。
比如，int x=5;int&r =x;r=y;第二句代码不会让r指向y，而是让x的值变成了y。
如果在函数接口(参数)中使用const，和在值、指针中使用是类似的。
但是，这就更难让函数返回指向这个参数对象的指针或者引用了。
如果允许的话，客户代码就有可能通过别名修改常量。
比如，
class Point
{
int x,y;
public:
Point closestPointVal(const Point&pt)
{if(x*x+y*y<pt.x*pt.x+pt.y*pt.y)
return*this;
else return pt;}
Point*closestPointPtr(const Point&pt)
{return(x*x+y*y<pt.x*pt.x+pt.y*pt.y)?this:&pt;}
Point&closestPointRef(const Point&pt)
{return(x*x+y*y<pt.x*pt.x+pt.y*pt.y)?*this:pt;} };
第一个函数是返回值的，不管用不用const，都不会修改实参pt。
而第二个函数可以返回指向pt实参的指针。
客户代码就可以使用这个指针修改实际参数对象的状态。
同样，第三个函数返回的引用也能修改实参对象的状态。
假如这样的函数是合法的，那么就有可能误用，误用后如果出了错，很难弄清是这里出的错，所以编译程序直接就认为这样的函数不合法。
也就是，参数对象使用了const，而返回类型没有，这是错误的。
C++提供了三种方法解决这个问题：1.参数不使用const;2.在成员函数内部，使用const_cast运算符移去const属性;3.在另外合适的地方添加const。
一个真正的程序员是不会放过任何一个机会，将设计人员的设计意图传达给客户代码程序员和维护人员的。
所以，假如某个参数没有被修改，就要用const 来明确说明。
而使用const_cast也很糟糕，不易理解。
所以只能使用第三种方法，在函数返回值前加上const，接收该返回值的指针或者引用也要是const 的。
这样的话，返回值只能作为右值，不能作为左值。
这样的返回值不能调用它所在类的成员函数。
C++提供const关键字，不是为了保证一个变量不被修改，而是为了方便编译程序和维护人员弄清楚一个实体在程序中是否被修改了。
如果函数接口中声明参数为const，我们就认为这个参数不会改变，如果没有声明为const，就认为这个参数一定被改变了，而不管函数到底有没有改变这个参数。
其实，const还有一个含义，就是在函数的参数列表的“)”之后，函数体的“{”之前。
这种用法说明函数不会修改目标对象的值。
二、静态类成员
每建立一个类对象实例，都会为该实例创建一个单独的数据成员集合。
不管是将对象定义为有名的局部变量，有名的全局变量，或者使用new定义为未命名的动态变量，或者按值传递一个对象作为函数参数，或者从一个函数按值返回一个对象。
而对于成员函数，它们的目标代码却只产生一次。
因为每个程序函数都有一个隐含的参数，即this指针。
1用全局变量作为类特性
类为对象实例提供了一个蓝图或者说是模板，类的成员变量都是这个类的所有实例的共性，类的每一个实例都有一个单独的副本。
但是有时我们需要为一个类的所有实例提供共有的数据成员副本，这比在每个类对象中维护单独的副本能更有效的合理利用内存。
最常见的例子就是对类的实例进行计数。
假如这个计数变量count被定义在类中，在构造函数中对其加1，在析构函数中对其减1，似乎能实现计数作用。
但是实际上却是做不到的。
因为count是类的成员变量，每个实例都有一个count，构造函数对其加1，只是对自己的count加了1。
使用全局变量就能解决这个问题。
但是将它用在大型程序中，存在一些问题，这些问题在前面都讲过了。
首先在客户代码任意地方都可能使用count，增加了模块之间的依赖性。
其次，全局变量名增加了重名机会。
最重要的是，count作为全局变量出现时，维护人员不能很好的了解它是做什么的，除非看注释或者查阅大量其他代码。
2static的含义
static和const一样很复杂。
首先，将static用于一个全局变量，是说明该全局变量只对定义在同一个文件中的函数可见。
即使在另一个文件中使用了extern，另一个文件中的函数也不能访问这个全局变量。
static的第二个含义是用于一个函数前，说明该函数只能在同一个文件中调用。
第三个含义是static用于函数的局部变量。
它表明该变量的值不会因为函数终止而消失，它会被保存下来。
再次调用该函数时，这个保存下来的值会用来初始化该变量。
第四个含义就是用于类的成员变量。
它表明对类的所有对象，这个数据成员都只有一个实例。
这个实例被所有对象共有。
static的成员变量可以是private、public、protected的。
定义和访问的语法也和其他数据成员一样。
3静态数据成员的初始化
静态数据成员在类规格说明外部被初始化，这一点和全局变量相似。
但是全局变量可以被隐式地初始化为0，而静态成员变量作为类的数据成员，必须被显式地初始化，因为类的所有的数据成员都必须被显式初始化。
赋值和初始化存在着重要的区别，如果类型名后紧跟着变量名，就是初始化，如果变量名前没有类型名，就是赋值。
初始化对于公共的和非公共的静态数据成员是合法的，但是对非公共的静态数据成员进行赋值却是不合法的。
比如，如果count是private的，那么Point::count=0就是错误的。
静态数据成员只能被初始化一次，所以它应该和其他的成员函数的定义一起放在.cpp文件中，而不能放在头文件中。
一个静态数据成员不能是联合的成员，也不能是位域的类。
联合和位域都表示属于某个特定对象的特殊内存用途，而静态数据成员却不属于特定对象，它属于整个类。
4静态成员函数
static的第五种含义是用在类的成员函数前，表明这个函数不访问非静态数据成员，它只能访问它的参数、类的静态数据成员、全局变量。
注意到静态成员函数访问的三种类型的数据，都不是描述对象状态的。
而在函数参数列表后面使用const表明该函数不会修改该函数的目标对象的数据成员。
所以，一个静态成员函数没有必要在参数列表之后添加一个const。
静态成员函数可以通过对象来调用，也可以直接使用类名来调用。
因为它是类的特性，而不是对象的性质。
定义类的某个数据成员为静态变量，以表明此全局数据逻辑上属于该类。
定义类的成员函数为静态函数，表明此全局函数逻辑上属于该类，而该函数只对静态数据、全局数据、参数进行操作。