C/C++ 靜態變量解析

靜態變量：這種變量的內存將保存到整個程序的結束，他的內存是獨立存放到一個叫做靜態內存區的。
          所有的靜態的變量如果不賦值，會默認賦值為0，不管是結構體還是其他類型的變量， 當然靜態變量的初始化也分為靜態初始化和動態初始化，如果有一些不可確定的因素會使用動態初始化
          比如：
          int a = 1;靜態初始化。
          double a = sqrt(2);動態初始化因為sqrt是一個不確定的因素。
          有幾個概念
          內部全局：內部是說不能被其他文件調用，全局是說有限訪問范圍為本文件。
          外部全局：外部是說可以被其他文件調用，全局是說有限訪問范圍為本文件。
          內部局部：內部是說不能被其他文件調用，局部是說有限訪問范圍為本代碼塊。
舉例3種模式
1、內部局部靜態變量，如
int test(void)
{
static i = 1;
.....
}
這個靜態變量是局部的，有效范圍是本代碼塊。
2、外部全局靜態變量
int i = 1;
int test(void)
{
   ....
}
這個靜態變量是全局的，有效范圍是本文件。
並且它是外部的，所以其他文件如果想使用可以使用
extern int i;
3、內部全局靜態變量
static i = 1;
int test(void)
{
   ....
}
這個靜態變量是全局的，有效范圍是本文件。
並且它是內部的，不能被其他文件調用，如果想extern int i;是不行的。
注意extern int i;不能初始化，因為他只是聲明而已，實際的變量在其他文件進行了空間初始化，也就是說內存已經分配了這裡extern int i;不會分配任何內存空間。
這裡展開說一下關於左值和右值。
任何一個有限的內存空間才能作為左值，
如
int a=1;
int *p;
p = &a;
*p = 1;
是可以作為左值的，如果沒有有效內存一定不行
比如
int a;
int b;
a+b = 5;
這裡的a+b 是一段臨時空間不能作為左值

但是關於如果我們抓住一個細節就是這段靜態內存區域在整個程序期間都存在，C/C++是很靈活的，我們就可以定義一個指針來訪問他。
我寫了一段程序。這段程序包含了其他的一些東西，比如flexible array number 來節約內存,

1. t1.h
   
3. #include<iostream>
4. using namespace std;
6. #ifndef TEST_H__
7. #define TEST_H__
8. #include <stdlib.h>
9. #include <string.h>
10. #include <stdio.h>
12. typedef struct chain
13. {
14.          char address[];
15. } CM;
16. typedef struct mc
17. {
18.         int id;
19.         char name[20];
20.         CM* adr;
21. } CHC;
22. #define LEN_S strlen(max_address)+sizeof(CM)+3
23. #define LEN_MAX strlen(max_address)
24. CM* finps(CHC* ins);
25. void fshows(const CHC* ins);
26. int** stre(void);
28. #endif
31. t3.cpp
34. #include<iostream>
35. #include "t1.h"
36. using namespace std;
38. static int st1 = 1;
39. static int st2 = 2;
41. int** stre(void)
42. {
43.         static int* p[2];
44.         p[0] = &st1;
45.         p[1] = &st2;
46.         return p;
47. }
49. CM* finps(CHC* ins)
50. {
51.         char max_address[80];
52.         static CM* ck;
54.         cout<< "please input id:" <<endl;
55.         cin >> ins->id;
56.         cin.get();
57.         cout<<"please input name:"<<endl;
58.         cin.getline(ins->name,19);
59.         cout<<"please input your address"<<endl;
60.         cin.getline(max_address,79);
61.         ck = (CM* )malloc(LEN_S);
62.         ins->adr = ck;
63.         strcpy(ck->address,max_address);
64.         return ck;
66. }
68. void fshows(const CHC* ins)
69. {
70.         cout<<"your information is:"<<endl;
71.         cout<< ins->id <<endl;
72.         cout<< ins->name <<endl;
73.         cout<< ins->adr->address <<endl;
74. }
76. t2.cpp
77. #include<iostream>
78. #include "t1.h"
79. using namespace std;
81. int main(void)
82. {
83.         CHC ins;
84.         CM* dt;
85.         int** p;
86.         dt = finps(&ins);
87.         fshows(&ins);
88.         free(dt);
89.         p = stre();
90.         cout<<"access static values from pointer:"<<endl;
91.         cout<<**p<<endl;
92.         cout<<**(p+1)<<endl;
93. }

注意這裡的

1. static int st1 = 1;
   
2. static int st2 = 2;
3. int** stre(void)
4. {
5.         static int* p[2];
6.         p[0] = &st1;
7.         p[1] = &st2;
8.         return p;
9. }

實際上我定義了一個指針數組來保存st1和st2的地址，並且返回了指向指針的指針p
那麼我們訪問的時候就可以
<endl;

1. cout<<**p<<endl;
2. cout<<**(p+1)<<endl;

<endl;
來進行訪問了，這樣一來雖然定義的內部全局靜態變量但是任然訪問到了。


編譯執行這段程序：
gaopeng@bogon:~/CPLUSPLUS/part9$ g++  t2.cpp t3.cpp
gaopeng@bogon:~/CPLUSPLUS/part9$ ./a.out 
please input id:
1
please input name:
gaopeng
please input your address
chongqing
your information is:
1
gaopeng
chongqing
access static values from pointer:
1
2
< /endl;
< /endl;