static关键字（1）

【1】全局、局部静态变量的特点

通过代码分析如下：

#include<iostream>
using namespace std;

static int MAX = 10;
// MAX += 100;   // error! 全局静态变量不可以直接在全局参与运算

void fun(int nValue)
{
    static int x = nValue;    // 局部静态变量
    int b = 10;          // 一般变量
    ++x;
    cout << &x << "  " << x << endl;
    cout << &b << "    " << b << endl;
}

int show()
{
    // x = 100;   // error!不可以改变静态局部变量的值（可见性问题）

    return MAX += 10;
}

void main()
{
    cout << show() << endl;
    cout << &MAX << " " << MAX <<endl;
    for (int i = 0; i < 10; ++i)
    {
        fun(i);
    }
    system("pause");
}

//运行结果如下：
/*
20
00F89000 20
00F8916C  1
0022F6F8    10
00F8916C  2
0022F6F8    10
00F8916C  3
0022F6F8    10
00F8916C  4
0022F6F8    10
00F8916C  5
0022F6F8    10
00F8916C  6
0022F6F8    10
00F8916C  7
0022F6F8    10
00F8916C  8
0022F6F8    10
00F8916C  9
0022F6F8    10
00F8916C  10
0022F6F8    10
请按任意键继续. . .
*/

总结：

（1）局部静态变量只能在函数内部（内部即局部）。值只进行一次初始化，以后每次再执行函数时保持上一次执行过的值。

（2）全局静态变量是在全局变量前加一个static，使该变量只在这个源文件中可用，称之为全局静态变量。全局静态变量即静态全局变量。

　　在多个文件组成的程序里，全局变量与全局静态变量的区别：全局静态变量使得该变量为定义该变量的源文件所独享，其他文件不能使用。　　

　　全局静态变量不可以在全局进行运算操作。

【2】解释形参，局部变量和静态局部变量的差别？

答案：从本质上说，三者均属于局部作用域中的变量，其中局部变量又可区分为普通局部变量和静态局部变量，

它们的差别在于：

（1）形参的作用域为整个函数体，而普通变量和静态局部变量的作用域为：从定义处到包含该变量定义的块的结束处

（2）形参由调用函数时所传递的实参初始化，而普通局部变量和静态局部变量通常用初始化式进行初始化，且均在程

序执行流程第一次经过该对象的定义语句时进行初始化。静态局变量的初始化在整个程序执行过程中只执行一次。

（3）形参和普通局部变量均属于自动变量，在每次调用函数是创建，并在函数结束时撤销，而静态局部变量的生命期

却跨越了函数的多次调用，并在创建后直接到程序结束时才撤销。

【3】静态成员变量有何特点？

静态成员变量只初始化一次，即第一次执行赋值。

示例代码如下：

#include<iostream>
using namespace std;

int fun(int a)
{
    static int x = a;
    x += 10; 
    cout << x << "  ";
    return x;
}

void main()
{
    for (int i = 10; i > 0; --i)
    {
        fun(i);  
    }
    system("pause");
}
// run out：
// 20  30  40  50  60  70  80  90  100  110  请按任意键继续. . .
// 说明：局部静态变量有且仅有第一次初始化。

【4】通过引用如何改变静态局部变量的值？

示例代码如下：

#include<iostream>
using namespace std;

int & fun(int a)
{
    static int x = a;
    x += 10;
    cout<<x<<" ";    
    return x;
}
void  main()
{
    for(int i = 0; i < 10; i++)
    {
        int &y = fun(i);
        y += 100;
    }
}
//运行结果如下：
//10 120 230 340 450 560 670 780 890 1000
//说明：引用返回生存期不受函数限制

【5】通过指针如何改变静态局部变量的值？

示例代码如下：

#include<iostream>
using namespace std;

int *fun(int a)
{
    static int x = a;
    x += 10;
    cout<<x<<" ";
    return &x;
}

void  main()
{
    for(int i = 0; i < 10; i++)
    {
        int *p = fun(i);
        *p = 100+i;
    }
}
//运行结果如下：
//10 110 111 112 113 114 115 116 117 118 
//说明：指针返回生存期不受函数限制

【6】局部变量的生存期如何分析？

示例代码如下：

#include<iostream>
using namespace std;

class Test
{
public:
    Test()
    {
        cout<<"Create Test: "<<endl;
    }
    ~Test()
    {
        cout<<"Free Test: "<<endl;
    }
};

void fun()
{
    Test t1;
}

void main()
{
    for(int i = 0; i < 5; ++i)
    {
        fun();
    }
    cout<<"main end"<<endl;
}
//输出结果如下：“十个 创建和析构 对象”
/*
Create Test:
Free Test:
Create Test:
Free Test:
Create Test:
Free Test:
Create Test:
Free Test:
Create Test:
Free Test:
main end
*/
//说明：局部变量的生存期仅仅在块内

局部变量的生存期仅仅在块内。

【7】静态成员在全局区域开辟的空间，生存期不受函数限制如何分析？

示例代码如下：

#include<iostream>
using namespace std;

class Test
{
public:
    Test()
    {
        cout<<"Create Test: "<<endl;
    }
    ~Test()
    {
        cout<<"Free Test: "<<endl;
    }
};

void fun()
{ 
    static Test t1;
}
void main()
{
    for(int i = 0; i < 10; ++i)
    {
        fun();
    }
    cout<<"main end"<<endl;
}
//输出结果如下：
/*
    Creat  Test
    main  end
    Free   Test
*/
//说明：静态成员在全局区域开辟的空间，生存期不受函数限制

【8】类内静态成员变量必须在类外初始化，并且遵循访问属性原则举例？

示例代码如下：

#include<iostream>
using namespace std;

class Test
{
//private:  //注意访问权限不同的区别
public:
    int value;
    static int num;   //静态类的成员变量
public:
    Test(int x=0):value(x)
    {
    }
    ~Test()
    {}
};
int Test::num=0;  //必须在类外初始化
void main()
{
    Test t1(10), t2(20), t3(30);
    
    cout<<t1.num<<endl;
    t1.num += 100;
    cout<<Test::num<<endl;
}
//运行结果如下：
/*
0
100
*/
//说明：类内静态成员变量必须在类外初始化，并且遵循访问属性原则

【9】静态成员变量的计数作用如何体现？

示例代码如下：

#include<iostream>
using namespace std;

class Test
{
private:
    int value;
    static int num;
public:
    Test(int x=0):value(x)
    {
        cout<<"Create Test: "<<++num<<endl;
    }
    ~Test()
    {
        cout<<"Destroy Test: "<<--num<<endl;
    }
};

int Test::num=0;
void main()
{
    Test t1[10];   //创建十个对象，用num进行计数
}

//运行结果如下：
/*
Create Test: 1
Create Test: 2
Create Test: 3
Create Test: 4
Create Test: 5
Create Test: 6
Create Test: 7
Create Test: 8
Create Test: 9
Create Test: 10
Destroy Test: 9
Destroy Test: 8
Destroy Test: 7
Destroy Test: 6
 Destroy Test: 5
Destroy Test: 4
Destroy Test: 3
Destroy Test: 2
Destroy Test: 1
Destroy Test: 0
*/

【10】类中静态成员的访问权限如何分析？

示例代码如下：

#include<iostream>
using namespace std;

#include<iostream.h>
class Test
{
public:
    int value;
    static int num;
public:
    Test(int x=0):value(x)
    {
        cout<<"Create Test: "<<++num<<endl;
    }
    ~Test()
    {
        cout<<"Destroy Test: "<<--num<<endl;
    }
    
    void fun()
    // == void fun(Test * const this) //注意const的位置
    {
        this->value+=10;
        cout<<num<<endl;
    }
    //static void sfunc()
    static void sfunc(Test &t) //静态成员函数没有this指针
    {   // no this  pointer;
        //value += 10;        //error！！！因为静态成员函数没有this指针，
        t.value+=10;
        cout<<num<<endl;
    }
};
int Test::num=0;  //初始化静态成员变量
void main()
{
    Test t1(10),t2(10);
    t1.fun();
    t1.sfunc(t1);
    
    Test::sfunc(t2);
    
    Test::num = 10; //公共变量可以访问，私有不可
    
}
//运行结果如下：
/*
Create Test: 1
Create Test: 2
2
2
2
Destroy Test: 9
Destroy Test: 8
*/

【11】类的静态数据成员~常量成员~静态常量成员各有何区别？

示例代码如下：

#include<iostream>
using namespace std;

class Test
{
private:
    int value;
    static int num;
    const int max;
    static const int min;   //=0;// vs2005可以直接初始化  vC6.0  error!!!!!
public:
    Test(int x=0):value(x),max(x+20)  //类中const数据成员变量采用参数列表进行初始化 
    {
        // == value = x;
        // == max = x+20;
    }
    ~Test()
    {
    }
};

int Test::num=10;       //静态成员变量在类外初始化
const int Test::min=0;  //静态常量成员在类外初始化

void main()
{
    Test t1(10),t2(20);
}

【12】静态成员函数~一般成员函数~常成员函数之间的访问权限如何？

示例代码如下：

#include<iostream>
using namespace std;

class Test
{
public:
    int value;
    static int num;

public:
    Test(int x = 0):value(x)
    {}
    ~Test()
    {}
public:
    void func()
    // void func(Test * const this)
    {
        cfunc(); //sfunc(this);//相当于限制了this的能力
        cout<<value++<<endl;
        cout<<num++<<endl;
    }
    void cfunc() const
    // void sfunc(const Test * const this)
    {
        //func();// func(this);  //error! 相当于扩大了this的能力
        this->value;             //成员变量不可以变量
        //cout<<value++<<endl;   //error! const修饰限定对象的成员不被改变
        cout<<num++<<endl;     //OK  因为num为静态成员变量
        sfun();
    }
    static void sfun() //const
    {  // no this
        //func();
    }
};

int Test::num=0;

void main()
{
    Test t1(10);
    t1.func();
    //t1.sfunc(); //error!!!sfunc()为静态成员函数  不可以通过对象直接调用
}