關於靜態數據你會聯想什麼

㈠ 計算機科學中什麼是靜態數據（軟體工程中的需求分析）

靜態數據是指那些不隨時間或其它數據變化而變化的數據.

㈡ 靜態存儲變數STATIC有什麼用舉個例吧，好像和全局變數還有些聯系啊

你這個問題其實非常的大了，簡單說不完的，我找了一段，你有選擇性的看看吧：

C/C++的static有兩種用法：面向過程程序設計中的static和面向對象程序設計中的static。前者應用於普通變數和函數，不涉及類；後者主要說明static在類中的作用。

一、面向過程設計中的static

1、靜態全局變數

在全局變數前，加上關鍵字static，該變數就被定義成為一個靜態全局變數。我們先舉一個靜態全局變數的例子，如下：

//Example 1#include <iostream.h>void fn();static int n; //定義靜態全局變數void main(){ n=20; cout<<n<<endl; fn();}void fn(){ n++; cout<<n<<endl;}
靜態全局變數有以下特點：
該變數在全局數據區分配內存；
未經初始化的靜態全局變數會被程序自動初始化為0（自動變數的值是隨機的，除非它被顯式初始化）；
靜態全局變數在聲明它的整個文件都是可見的，而在文件之外是不可見的；
靜態變數都在全局數據區分配內存，包括後面將要提到的靜態局部變數。對於一個完整的程序，在內存中的分布情況如下圖：
代碼區
全局數據區
堆區
棧區

一般程序的由new產生的動態數據存放在堆區，函數內部的自動變數存放在棧區。自動變數一般會隨著函數的退出而釋放空間，靜態數據（即使是函數內部的靜 態局部變數）也存放在全局數據區。全局數據區的數據並不會因為函數的退出而釋放空間。細心的讀者可能會發現，Example 1中的代碼中將

static int n; //定義靜態全局變數
改為
int n; //定義全局變數
程序照樣正常運行。
的確，定義全局變數就可以實現變數在文件中的共享，但定義靜態全局變數還有以下好處：
靜態全局變數不能被其它文件所用；
其它文件中可以定義相同名字的變數，不會發生沖突；
您可以將上述示例代碼改為如下：

//Example 2//File1#include <iostream.h>void fn();static int n; //定義靜態全局變數void main(){ n=20; cout<<n<<endl; fn();}//File2#include <iostream.h>extern int n;void fn(){ n++; cout<<n<<endl;}
編譯並運行Example 2，您就會發現上述代碼可以分別通過編譯，但運行時出現錯誤。 試著將
static int n; //定義靜態全局變數
改為
int n; //定義全局變數
再次編譯運行程序，細心體會全局變數和靜態全局變數的區別。
2、靜態局部變數

在局部變數前，加上關鍵字static，該變數就被定義成為一個靜態局部變數。

我們先舉一個靜態局部變數的例子，如下：

//Example 3#include <iostream.h>void fn();void main(){ fn(); fn(); fn();}void fn(){ static n=10; cout<<n<<endl; n++;}
通常，在函數體內定義了一個變數，每當程序運行到該語句時都會給該局部變數分配棧內存。但隨著程序退出函數體，系統就會收回棧內存，局部變數也相應失效。
但有時候我們需要在兩次調用之間對變數的值進行保存。通常的想法是定義一個全局變數來實現。但這樣一來，變數已經不再屬於函數本身了，不再僅受函數的控制，給程序的維護帶來不便。
靜態局部變數正好可以解決這個問題。靜態局部變數保存在全局數據區，而不是保存在棧中，每次的值保持到下一次調用，直到下次賦新值。
靜態局部變數有以下特點：

該變數在全局數據區分配內存；
靜態局部變數在程序執行到該對象的聲明處時被首次初始化，即以後的函數調用不再進行初始化；
靜態局部變數一般在聲明處初始化，如果沒有顯式初始化，會被程序自動初始化為0；
它始終駐留在全局數據區，直到程序運行結束。但其作用域為局部作用域，當定義它的函數或語句塊結束時，其作用域隨之結束；
3、靜態函數

在函數的返回類型前加上static關鍵字,函數即被定義為靜態函數。靜態函數與普通函數不同，它只能在聲明它的文件當中可見，不能被其它文件使用。

靜態函數的例子：

//Example 4#include <iostream.h>static void fn();//聲明靜態函數void main(){ fn();}void fn()//定義靜態函數{ int n=10; cout<<n<<endl;}
定義靜態函數的好處：
靜態函數不能被其它文件所用；
其它文件中可以定義相同名字的函數，不會發生沖突；
二、面向對象的static關鍵字（類中的static關鍵字）

1、靜態數據成員

在類內數據成員的聲明前加上關鍵字static，該數據成員就是類內的靜態數據成員。先舉一個靜態數據成員的例子。

//Example 5#include <iostream.h>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();}
可以看出，靜態數據成員有以下特點：
對於非靜態數據成員，每個類對象都有自己的拷貝。而靜態數據成員被當作是類的成員。無論這個類的對象被定義了多少個，靜態數據成員在程序中也只有一份拷 貝，由該類型的所有對象共享訪問。也就是說，靜態數據成員是該類的所有對象所共有的。對該類的多個對象來說，靜態數據成員只分配一次內存，供所有對象共 用。所以，靜態數據成員的值對每個對象都是一樣的，它的值可以更新；
靜態數據成員存儲在全局數據區。靜態數據成員定義時要分配空間，所以不能在類聲明中定義。在Example 5中，語句int Myclass::Sum=0;是定義靜態數據成員；
靜態數據成員和普通數據成員一樣遵從public,protected,private訪問規則；
因為靜態數據成員在全局數據區分配內存，屬於本類的所有對象共享，所以，它不屬於特定的類對象，在沒有產生類對象時其作用域就可見，即在沒有產生類的實例時，我們就可以操作它；
靜態數據成員初始化與一般數據成員初始化不同。靜態數據成員初始化的格式為：
＜數據類型＞＜類名＞::＜靜態數據成員名＞=＜值＞
類的靜態數據成員有兩種訪問形式：
＜類對象名＞.＜靜態數據成員名＞ 或 ＜類類型名＞::＜靜態數據成員名＞
如果靜態數據成員的訪問許可權允許的話（即public的成員），可在程序中，按上述格式來引用靜態數據成員 ；
靜態數據成員主要用在各個對象都有相同的某項屬性的時候。比如對於一個存款類，每個實例的利息都是相同的。所以，應該把利息設為存款類的靜態數據成員。這 有兩個好處，第一，不管定義多少個存款類對象，利息數據成員都共享分配在全局數據區的內存，所以節省存儲空間。第二，一旦利息需要改變時，只要改變一次， 則所有存款類對象的利息全改變過來了；
同全局變數相比，使用靜態數據成員有兩個優勢：
靜態數據成員沒有進入程序的全局名字空間，因此不存在與程序中其它全局名字沖突的可能性；
可以實現信息隱藏。靜態數據成員可以是private成員，而全局變數不能；

2、靜態成員函數
與靜態數據成員一樣，我們也可以創建一個靜態成員函數，它為類的全部服務而不是為某一個類的具體對象服務。靜態成員函數與靜態數據成員一樣，都是類的內部 實現，屬於類定義的一部分。 普通的成員函數一般都隱含了一個this指針，this指針指向類的對象本身，因為普通成員函數總是具體的屬於某個類的具體對象的。通常情況下，this 是預設的。如函數fn()實際上是this->fn()。但是與普通函數相比，靜態成員函數由於不是與任何的對象相聯系，因此它不具有this指 針。從這個意義上講，它無法訪問屬於類對象的非靜態數據成員，也無法訪問非靜態成員函數，它只能調用其餘的靜態成員函數。 下面舉個靜態成員函數的例子。

//Example 6#include <iostream.h>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；
靜態成員之間可以相互訪問，包括靜態成員函數訪問靜態數據成員和訪問靜態成員函數；
非靜態成員函數可以任意地訪問靜態成員函數和靜態數據成員；
靜態成員函數不能訪問非靜態成員函數和非靜態數據成員；
由於沒有this指針的額外開銷，因此靜態成員函數與類的全局函數相比速度上會有少許的增長；
調用靜態成員函數，可以用成員訪問操作符(.)和(->)為一個類的對象或指向類對象的指針調用靜態成員函數，也可以直接使用如下格式：
＜類名＞::＜靜態成員函數名＞（＜參數表＞）
調用類的靜態成員函數。

㈢ 什麼是靜態數據,什麼是動態數據

動態數據是指在系統應用中隨時間變化而改變的數據，如庫存數據等。動態數據的准備和系統切換的時間有直接關系。

動態數據是常常變化，直接反映事務過程的數據，比如，網站訪問量、在線人數、日銷售額等等。

靜態數據是指在運行過程中主要作為控制或參考用的數據,它們在很長的一段時間內不會變化，一般不隨運行而變。動態數據包括所有在運行中發生變化的數據以及在運行中需要輸入、輸出的數據及在連機操作中要改變的數據。

(3)關於靜態數據你會聯想什麼擴展閱讀

內部生成數據,指向用戶或調試人員提供的內部生成數據。數據約定說明對數據要求的制約,應列出對進一步擴充或使用方面的考慮而提出的對數據要求的限制(容量、文件、記錄、臨界性和數據元素最大值)。

在計算機系統中，各種字母、數字元號的組合、語音、圖形、圖像等統稱為數據，數據經過加工後就成為信息。

在計算機科學中，數據是指所有能輸入到計算機並被計算機程序處理的符號的介質的總稱，是用於輸入電子計算機進行處理，具有一定意義的數字、字母、符號和模擬量等的通稱。是組成地理信息系統的最基本要素，種類很多。

參考資料來源：網路-靜態數據

參考資料來源：網路-動態數據

㈣ 什麼叫做靜態數據成員，它有何種特點

有時你希望定義一個類成員，使它的使用完全獨立於該類的任何對象。通常情況下，類成員必須通過它的類的對象訪問，但是可以創建這樣一個成員，它能夠被它自己使用，而不必引用特定的實例。在成員的聲明前面加上關鍵字static(靜態的)就能創建這樣的成員。如果一個成員被聲明為static，它就能夠在它的類的任何對象創建之前被訪問，而不必引用任何對象。你可以將方法和變數都聲明為static。static成員的最常見的例子是main( )。因為在程序開始執行時必須調用main()，所以它被聲明為static。聲明為static的變數實質上就是全局變數。當聲明一個對象時，並不產生static變數的拷貝，而是該類所有的實例變數共用同一個static變數。
聲明為static的方法有以下幾條限制：
· 它們僅能調用其他的static方法。
· 它們只能訪問static數據。
· 它們不能以任何方式引用this或super（關鍵字super與繼承有關，在下一章中描述）。
如果你需要通過計算來初始化你的static變數，你可以聲明一個static塊，Static塊僅在該類被載入時執行一次。
下面的例子顯示的類有一個static方法，一些static變數，以及一個static 初始化塊：
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}

static {
System.out.println("Static block initialized.");
b = a * 4;
}

public static void main(String args[]) {
meth(42);
}
}
一旦UseStatic類被裝載，所有的static語句被運行。首先，a被設置為3，接著static塊執行(列印一條消息)，最後，b被初始化為a*4或12。然後調用main()，main()調用meth()，把值42傳遞給x。3個println ( )語句引用兩個static變數a和b，以及局部變數x 。
注意：在一個static方法中引用任何實例變數都是非法的。
下面是該程序的輸出：
Static block initialized.
x = 42
a = 3
b = 12
在定義它們的類的外面，static方法和變數能獨立於任何對象而被使用。這樣，你只要在類的名字後面加點號運算符即可。例如，如果你希望從類外面調用一個static方法，你可以使用下面通用的格式：
classname.method( )
這里，classname 是類的名字，在該類中定義static方法。可以看到，這種格式與通過對象引用變數調用非static方法的格式類似。一static變數可以以同樣的格式來訪問——類名加點號運算符。這就是Java如何實現全局功能和全局變數的一個控制版本。
下面是一個例子。在main()中，static方法callme()和static變數b在它們的類之外被訪問。
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
下面是該程序的輸出：
a = 42
b = 99

static成員是不能被其所在class創建的實例訪問的。

如果不加static修飾的成員是對象成員，也就是歸每個對象所有的。

加static修飾的成員是類成員，就是可以由一個類直接調用，為所有對象共有的

㈤ 怎樣理解靜態變數和靜態函數

c和c++裡面的變數有靜態和動態的，靜態的是static，普通的定義都是動態的，靜態和動態的差別在於變數在程序中的生命周期，靜態變數存在整個程序或者相應的比較長時間的子程序中（多個.cpp文件時存活於當期的子程序中）。而動態變數一般只存在於當前的函數中，生命周期僅限於當前的函數（注意區別函數和程序）。
靜態函數主要在c++中使用的比較多，一般在函數之前聲明。
舉例說明：
#include <iostream>
using namespace std;
class Student //定義Student類
{public:
Student(int n,int a,float s):num(n),age(a),score(s){ } //定義構造函數
void total( );
static float average( ); //聲明靜態成員函數
private:
int num;
int age;
float score;
static float sum; //靜態數據成員
static int count; //靜態數據成員
};
這就是靜態函數和靜態變數的聲明。
函數調用的結果不會訪問或者修改任何對象（非static）數據成員，這樣的成員聲明為靜態成員函數比較好。
其他的一些不太容易說明，有機會再來整理說一下。
希望這些能對你有所幫助。

㈥ C＃中靜態變數和方法有什麼用處

1．靜態變數

在C#程序中，沒有全局變數的概念，這意味著所有的成員變數只有該類的實例才能操作這些數據，這起到了「信息隱藏」的作用。但有些時候，這樣做卻不是個明智的選擇。

假設我們要定義一個圖書類，要求該類能保存圖書的數量，即每增加一本圖書（定義一個實例），圖書的數量應該加1。如果沒有靜態變數，我們需要將圖書的數量保存在每本圖書（實例）里，然而，這樣的變數要在不同圖書（實例）里重復存儲，圖書（實例）數量少的話，我們還能接受，如果圖書（實例）數量較多的話，比如成千上萬，我們無法想像這要造成多少資源（如內存、磁碟空間）的浪費，更讓人無法忍受的是：因為圖書（實例）的數量要保存在每本圖書（實例）里，該值肯定是不同的。要使這些圖書（實例）中保存的圖書（實例）數量一致，我們必須在每增加一本新書（生成一個新實例）時，修改其他所有圖書（實例）中保存的該值。Oh,My God!你會重新嚮往面向過程的程序設計方法，嚮往擁有全局變數的時代。但，這種局面不會出現，因為C#中為你准備好了另外一種變數類型：靜態變數。它在類中類似全局變數，保存類的公共信息，所有該類的實例（對象）共享該值。

靜態變數的聲明方式如下：

[訪問修飾符] static 數據類型 變數名;

這里的訪問修飾符跟類的其它成員一樣，可以是public,protected,private或internal等。

靜態變數又如何使用呢？

靜態變數必須使用類名來引用，而不能使用類的實例，因為，靜態變數不屬於任何實例，而是共有的。我們可以打個比方：在一個班級中，有些物品是個人的，我們想使用時，必須指出物品的所有者，比如說「王三的自行車」，在C#程序中我們可以使用：王三.自行車的格式。有些物品是大家共有的物品，不能以個人名義使用，而是用班級的名義使用，比如班集體出資買的籃球，只能說：「班級的籃球」，而不能說：「王三的籃球」。這絕對是不行的，這對其他人絕對是不公平的，我們可以聯想到許多貪官污吏就是使用了不屬於自己的東西，或以個人名義使用公家的東西而葬送了自己。

說一句有用的就是：靜態變數是用類名來引用它。即：類名.靜態變數名;

舉個具體的例子如下：

using System;

class StaticVar
{
public int x;
public static int y;
public void PrintInfo()
{
Console.WriteLine("非靜態變數x={0}",x);
Console.WriteLine("靜態變數y = {0}",y);
}
}
class Test
{
static void Main(string[] args)
{
StaticVar stv = new StaticVar();
stv.x = 10;
// stv.y = 20; //error;無法使用實例引用訪問靜態成員「StaticVar.y」；改用類型名來限定它
StaticVar.y = 20;
stv.PrintInfo();
}
}

程序中被注釋的部分：stv.y = 20是使用實例引用靜態變數，這將引發錯誤。

另外，我想說一句，對於靜態變數在聲明時，如果沒有給出初始值或使用前沒有賦任何值的話，系統會給他們一個默認值：對於整型數據默認值為0；單精度數據為：0.0f；雙精度數據為0.0；布爾型數據為False；引用型數據為null。

2．靜態方法

靜態方法與靜態變數一樣，不屬於任何特定的實例，屬於類全體成員共有，由類名來調用。但要注意以下幾點：

靜態方法只能訪問類的靜態成員，不能訪問類的非靜態成員；

非靜態方法可以訪問類的靜態成員，也可以訪問類的非靜態成員；

靜態方法不能使用實例來調用，只能使用類名來調用。這里用一個具體的例子來說明：

using System;

namespace TestStatic
{
class StaticTest
{
int x;
static int y;
public StaticTest(int a,int b)
{
x = a;
y = b;
}
public void SimplePrint()
{
Console.WriteLine("x="+x+",y="+y);
}
public static void StaticPrint()
{
Console.WriteLine("y={0}",y);
// Console.WriteLine("x={0}",x); //靜態方法中不能使用非靜態成員
}
}
class Test
{
static void Main(string[] args)
{
StaticTest st = new StaticTest(10,23);
st.SimplePrint();
//st.StaticPrint(); //靜態方法不能使用實例來調用
StaticTest.StaticPrint();
}
}
}

㈦ 什麼是靜態數據

靜態數據就是在你程序運行的過程中，始終分配一塊內存空間的變數，這塊內存會一直持續使用到程序結束或者該空間被free掉
譬如
void main()
{
void print();
void print();
void print();
}
void print()
{
static int i;//int i;
}
如果是定義為static int i，那麼i就是一個靜態數據，i佔用的內存空間會從第一次調用print函數開始一直被佔用，直到main函數結束釋放該內存空間，但是如果是定義為int i，那麼i就不是一個靜態數據，這樣每次調用print函數的時候i會分配到一個內存空間，當返回main函數的時候釋放該空間，如此反復3次。

㈧ c++中什麼是靜態數據成員 什麼是靜態成員函數 分別有什麼作用

＊＊＊ 我主要說的關鍵是「靜態成員是屬於類的」，而不屬於任何對象所有 ＊＊＊

在此對一些內容作詳細的解釋，其中小部分與樓上有點相同，但我說的關鍵處，與它不同，並修改一些說法。

首先，我在這里把樓主的「靜態成員」和「靜態方法」，分別對應下面的「靜態數據成員」和「靜態成員函數」。並把他們都成為靜態成員。（它們實際是同一個概念的不同說法。）

「靜態成員是屬於類的，由該類的全體對象共享」------就是對是這樣的

「無論你建立了多少個該類的對象，靜態成員在內存上只有一個」------我要說的是，無論你建多少個該類的對象，所有成員函數在內存上也只有一個

為什麼說靜態成員是屬於類的呢？？

因為,
我們假設 class A };並定義對象 A abc;
一般的引用類的成員的方法是通過對象去引用：abc.i; abc.display;。
但可以通過類 A::i來引用i , 通過A::display()來引用display(). 《這里是要特別要注意的！！！》
而普通成員就不行，
雖然不管是靜態成員還是普通成員，在內存里只有一個副本。但從這個角度去看，靜態成員是屬於類的。

對於靜態成員函數，我們也許還分不清楚這個問題，但是，
特別是對於靜態數據成員，我們就很容易理解了。
如果不定義為靜態數據成員，那麼每個對象都分別有一個i的副本（拷貝）。但定義為靜態數據成員之後，所有的對象共享有一個i的副本，就是說i在內存里就一個副本。
那麼，不同對象引用i，對i的改變的話, 其他對象中i的值也會被改變，而且所有對象的值都是相同的。
在引用靜態數據成員時，可以不通過對象而通過類，靜態數據成員在內存只有一個，而且可以通過類來引用。這是靜態數據成員屬於類，很明顯的。

這是實現不同對象間數據共享的一種方法。

靜態成員函數，與靜態數據成員類似。就不說，需要注意的是，它在內存里始終只有一個副本（普通成員函數也一樣）。

關於靜態成員的生命周期，在此就不多說了。

㈨ 靜態數據是什麼

從字面意思理解靜態數據就是狀態沒做改變時候的數據。而master data 是主數據的意思，主數據和靜態數據應該是不同的兩個數據。