const和static的用法总结

const

（1）const修饰一般常量及数组

const  int   a=10;         等价的书写方式： int const  a=10;
const  int   arr[3]={1,2,3};               int const  arr[3]={1,2,3};

对于类似这些基本数据类型，修饰符const可以用在类型说明符前，也可以用在类型说明符后，其结果是一样的。
（2）const修饰指针变量*及引用变量&
&应当是取址符，*是指针符，也就是说，
&用于返回变量的实际地址，*用于返回地址所指向的变量，他们应当互为逆运算。
在定义变量的引用的时候，&只是个定义引用的标志，不代表取地址。

const   char*p1="hello";  *p1不能改

char*const  p2="world"; p2不能改

int const c=21;变量c的值不能改

const    int*d=&a; 指针变量d指向的值不能改变

int *const    e=&b;指针的指向不能改变

int const*f   const=&a;指针不能改变，指针指向的值也不能改变

const在*左边  指针指向常量

const在*右边 指针本身为常量

(3)函数中使用const
const修饰函数参数

void f(const int i)传递过来的参数在函数内不可以改变（因为i本身就是形参）
  void f(const char*p) 参数指针所指的内容为常量不可变
  void f(char *const p)参数指针本身为常量不可变

（4）用const修饰类成员
使用const关键字修饰的函数为常成员函数，声明格式
类型说明符 函数名（参数表）const
?const是函数类型的一个组成部分，因此在函数的定义部分也要用const关键字。
?如果将一个对象说明为常对象，则通过该常对象只能调用它的常成员函数，而不能调用其他成员函数。
?常对象成员函数不能更新目的对象的数据成员，也不能针对目的对象调用该类中没有用const修饰的成员函数。
?const关键字可以用于对重载函数的区分。

void print();  
void print() const;

使用const关键字修饰的引用为常引用，声明格式
const 类型说明符 & 引用名

static

1、静态全局变量
在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。

#include <iostream> 
using namespace std;
void fn();
static int n; //定义静态全局变量 
void main()
{
n=20;
cout<<n<<endl;
fn();
} void fn()
{
n++;
cout<<n<<endl;
} 

静态全局变量有以下特点：
该变量在全局数据区分配内存；
未经初始化的静态全局变量会被程序自动初始化为0
静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的； 　
代码中将static int n; //定义静态全局变量
改为int n; //定义全局变量
程序照样正常运行。
定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：
静态全局变量不能被其它文件所用；
其它文件中可以定义相同名字的变量，不会发生冲突；

2、静态函数　　
在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

#include <iostream>
using namespace std;
static void fn();//声明静态函数
void main()
{
fn();
}
void fn()//定义静态函数
{
int n=10;
cout<<n<<endl;
}

定义静态函数的好处：
静态函数不能被其它文件所用；
其它文件中可以定义相同名字的函数，不会发生冲突；
3、 类中的static关键字
静态数据成员在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

 #include <iostream>
 using namespace std;
 class Myclass
 {
 public:
 Myclass(int a,int b,int c);
 void GetSum();
 private:
 int a,b,c;
 static int Sum;//声明静态数据成员
 };
 int Myclass::Sum=0;//定义并初始化静态数据成员
Myclass::Myclass(int a,int b,int c)
{
this->a=a;
this->b=b;
this->c=c;
Sum+=a+b+c;
}
void Myclass::GetSum()
{
cout<<"Sum="<<Sum<<endl;
}
void main()
{
Myclass M(1,2,3);
M.GetSum();
Myclass N(4,5,6);
N.GetSum();
M.GetSum();
}

可以看出，静态数据成员有以下特点：
对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞
类的静态数据成员有两种访问形式：
＜类对象名＞.＜静态数据成员名＞ 或 ＜类类型名＞::＜静态数据成员名＞
4、静态成员函数
与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。 普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。

 #include <iostream>
 class Myclass
 {
 public:
 Myclass(int a,int b,int c);
 static void GetSum();/声明静态成员函数
 private:
 int a,b,c;
 static int Sum;//声明静态数据成员
 };
 int Myclass::Sum=0;//定义并初始化静态数据成员
Myclass::Myclass(int a,int b,int c)
{
this->a=a;
this->b=b;
this->c=c;
Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
}
void Myclass::GetSum() //静态成员函数的实现
{
// cout<<a<<endl;
/错误代码，a是非静态数据成员
 cout<<"Sum="<<Sum<<endl;
 }
void main()
{
Myclass M(1,2,3);
M.GetSum();
Myclass N(4,5,6);
N.GetSum();
Myclass::GetSum();
}
关于静态成员函数，可以总结为以下几点:

?出现在类体外的函数定义不能指定关键字static；
?静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
?非静态成员函数可以任意地访问静态成员函数和静态数据成员；
?静态成员函数不能访问非静态成员函数和非静态数据成员；