关于静态数据你会联想什么

㈠ 计算机科学中什么是静态数据（软件工程中的需求分析）

静态数据是指那些不随时间或其它数据变化而变化的数据.

㈡ 静态存储变量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 是主数据的意思，主数据和静态数据应该是不同的两个数据。