常用关键字之static和const的使用

关键字static和const

1.static

1.1 static变量和static函数

static变量和普通变量的区别：
普通全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，普通全局变量在各个源文件中都是有效的。
静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。

static全局变量和普通全局变量：static全局变量只初始化一次，防止其他文件中再被引用。
static局部变量和普通局部变量的区别：static再内存中只有一份，普通函数每次被调用一次拷贝一次。
全局静态变量在声明其之外是不可见的，作用域为，从程序开头到结尾。

静态函数和普通函数的区别：
函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用，
1）静态函数在其他文件中科技定义形同的名字，不会发生冲突；
2）静态函数不能被其他文件所用；
3）静态函数会被自动分配在一个一直使用的存储区，直到退出应用程序实例，避免了调用函数时压栈出栈，速度快很多。

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝。

1.2 static成员变量和static成员函数

与static结合的成员变量和成员函数。类中的成员变量或成员函数一旦与static关键字相结合，则该成员变量或成员函数就是属于类的，而不是再是属于任何一个对象的，当然任何一个对象都可以共享该成员变量及成员函数。

静态成员变量：
首先静态成员变量的定义必须在任何程序块之外；其次调用该变量的时候可以直接用类名加上域解析符“::”加上变量名的形式，这是静态成员变量特有的引用方式；在类外部进行定义的时候static关键字是不需要的。

class student
{
public:
    student(){count ++;}
    ~student(){count --;}
private:
    static int count;
    //其它成员变量
};

int student::count = 0;

在C++语法中规定静态成员变量会被默认初始化为0，类外定义可有可无。而实际上在一些编译器中，如果不加上类外的定义，会出现一些不可知的情况，故在实际设计程序的时候最好还是将类外定义加上。

静态成员变量不会影响类及其对象的大小，也即sizeof结果不会受到影响。在上面的代码实例中，无论我们是否声明count这个静态成员变量，sizeof(student)或者sizeof(student的对象)其结果都是不会变的。

静态成员变量属于类而不属于任何一个对象，如此一来可以实现数据共享功能，如下面代码实例所示：

#include<iostream>
using namespace std;

class test
{
public:
    static int num;
};
int test::num = 1;

int main()
{
    test one;
    test two;
    test three;
    cout<<test::num<<" "<<one.num<<" "<<two.num<<" "<<three.num<<endl;
    test::num = 5;
    cout<<test::num<<" "<<one.num<<" "<<two.num<<" "<<three.num<<endl;
    one.num = 8;
    cout<<test::num<<" "<<one.num<<" "<<two.num<<" "<<three.num<<endl;
    two.num = 4;
    cout<<test::num<<" "<<one.num<<" "<<two.num<<" "<<three.num<<endl;
    three.num = 2;
    cout<<test::num<<" "<<one.num<<" "<<two.num<<" "<<three.num<<endl;
    return 0;
}

程序运行结果：
1 1 1 1
5 5 5 5
8 8 8 8
4 4 4 4
2 2 2 2

无论哪个对象调用静态成员变量的方法，其成员变量的值都是相等的，如果其中有任何一个修改该静态成员变量，所有其他的调用静态成员变量都会跟着一起改变。这就是静态成员变量的共享特性，静态成员变量不属于任何对象，但是可以通过对象访问静态成员变量。静态成员变量属于类，因此可以通过类来调用静态成员变量。
静态成员变量如果被设置为private或protected属性，则在类外同样无法访问，但定义该变量的时候却不受此限制，如例2所示，虽然静态成员变量count为private属性，但是它在类外定义的时候不受private限制。

静态成员函数

在类内除了能用static声明静态成员变量外，同样可以使用static声明静态成员函数，静态成员函数只能访问static成员变量。

#include<iostream>
using namespace std;

class test
{
public:
    test(int a, int b){num = a; plus = b;}
    static int getnum(){return num;}
    static int add(){return num+plus;}  //编译不过
    void setnum(int a){num = a;}
    void setplus(int a){plus = a;}
private:
    static int num;
    int plus;
};
int test::num = 1;

int main()
{
    test one;
    one.setnum(5);
    cout<<test::getnum()<<endl;
    return 0;
}

在构造函数中，我们引用了静态成员变量num，这是允许的，同样在setnum函数中，同样引用了静态成员变量num，这个也是允许的。然而在add函数中我们不仅引用了静态成员变量num，同时还访问了非静态成员变量plus，而这是不允许的。静态成员函数只能访问静态成员变量，而不能访问非静态成员变量。普通成员函数（包括构造函数和析构函数）既可以访问普通成员变量，同时又可以访问静态成员变量。

访问静态成员变量和静态成员函数均有两种方式，其一是和普通的成员变量成员函数相同，通过对象来访问，其二则是可以通过类名加上域解析操作符访问。当然访问过程中仍然要遵循private、protected和public关键字的访问权限限定。访问静态成员变量和静态成员函数首选的方法是通过类来访问，毕竟静态成员变量和静态成员函数都是属于类的，与类相关联，而不是属于类的对象。普通成员变量或成员函数不可以通过类来访问。由于静态成员变量和静态成员函数都是属于类，而不是属于对象，因此静态成员函数内部也不存在this指针，因为静态成员函数不属于对象。

在静态成员函数内部可以声明静态变量，注意不是静态成员变量。如果在静态成员函数内部声明一个静态变量，则该类的所有对象将共享这个变量。

#include<iostream>
using namespace std;

class test
{
public:
    static void add(int a);
};

void test::add(int a)
{
    static int num = 0;
    int count = 0;
    num += a;
    count += a;
    cout<<num<<" "<<count<<endl;
}

int main()
{
    test one,two,three;
    one.add(5);
    two.add(4);
    three.add(11);
    return 0;
}

程序运行结果：
5 5
9 4
20 11

为了直截了当地说明这个问题，我们只在类test中声明了一个静态成员函数add，并且在类外对这个函数进行了定义。注意，在类外定义静态成员函数是不需要static关键字的。在add函数内部我们定义了一个静态变量num，并且初始化为0，为了增强对比效果，我们又定义了一个普通的变量count。在主函数中定义了三个变量，分别调用静态成员函数，结果num值打印结果是累加的，而count则每次都是从0开始的，并不是累加的。通过对比我们很容易看出，static是被这三个对象同时共享的，三个对象一份数据。

（注：本文静态成员变量和静态成员函数部分摘自C++之静态的变量和静态函数。）

2.const

2.1 const变量和const函数

const变量
const 在概念上是简单的：用“const”修饰的变量变为常量，不能被程序修改。在数据声明时，const关键字指定的对象或变量是不可修改的。

 const int i = 5;  
 //i++；//错误
 //i=10；//错误

const在 * 左边，变量为const;
const在 * 右边，指针为const.

int main()
{
    const int a;   //a为const，常数型数
    int const b;　　//b为const，常数型数
    const int *c;　　//c为const,指向长整型数的指针（所指向的内存数据不能修改，但本身可以修改）
    int *const d;　　//int*为const，常量指针（指针变量不能被修改，但是它所指向内存空间可以被修改）
    const int * const e;　　//int*为const;e为const，指向常整形的常指针（指针和它所指向的内存空间，都不能被修改）
     
    return 0;
}   

在C++中const的常用做法就是替代define，define定义的常量不进行语法检查，增加了错误的可能性。
const和#define的区别

const分配内存的时机，是编译器编译期间，与#define相同

C++中的const常量类似于宏定义#define

const int c=5 等价于 #define c 5

1. 编译器处理方式不同 define宏是在预处理阶段展开。 const常量是编译运行阶段使用。

2. 类型和安全检查不同 define宏没有类型，不做任何类型检查，仅仅是展开。 const常量有具体的类型，在编译阶段会执行类型检查。

注意：尽量以const替换#define

const函数

const char * func(char *str);
const修饰的是返回值，前面已经说过，这里的const修饰的是char，也就是说返回值的内容是不能被更改的。

2.1 const成员变量和const成员函数

在类中，如果你不希望某些数据被修改，可以使用const关键字加以限定。const 可以用来修饰成员变量和成员函数。

const成员变量
const 成员变量的用法和普通 const 变量的用法相似，只需要在声明时加上 const 关键字。初始化 const 成员变量只有一种方法，就是通过构造函数的初始化列表。

const成员函数（常成员函数）
const 成员函数可以使用类中的所有成员变量，但是不能修改它们的值，这种措施主要还是为了保护数据而设置的。const 成员函数也称为常成员函数。

我们通常将 get 函数设置为常成员函数。读取成员变量的函数的名字通常以get开头，后跟成员变量的名字，所以通常将它们称为 get 函数。

class Student
{
public:
    Student(char *name, int age, float score);
    void show();
    //声明常成员函数
    char *getname() const;
    int getage() const;
    float getscore() const;
private:
    char *m_name;
    int m_age;
    float m_score;
};

Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }

void Student::show()
{
    cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}

//定义常成员函数
char * Student::getname() const
{
    return m_name;
}

int Student::getage() const
{
    return m_age;
}

float Student::getscore() const
{
    return m_score;
}

getname()、getage()、getscore() 三个函数的功能都很简单，仅仅是为了获取成员变量的值，没有任何修改成员变量的企图，所以我们加了 const 限制，这是一种保险的做法，同时也使得语义更加明显。

需要强调的是，必须在成员函数的声明和定义处同时加上 const 关键字。char *getname() const和char *getname()是两个不同的函数原型，如果只在一个地方加 const 会导致声明和定义处的函数原型冲突。

此外，C++中只有被声明为const的成员函数才能被一个const类对象调用。

最后再来区分一下 const 的位置：
函数开头的 const 用来修饰函数的返回值，表示返回值是 const 类型，也就是不能被修改，例如const char * getname()。
函数头部的结尾加上 const 表示常成员函数，这种函数只能读取成员变量的值，而不能修改成员变量的值，例如char * getname() const。

(注：本文常成员变量和常成员函数部分摘自C++ const成员变量和成员函数（常成员函数）。)