static数据成员与static成员函数

深藏阁楼爱情的钟 2022-02-21 13:20 322阅读 0赞

## 定义：用static关键字声明的数据成员称为静态数据成员。 ##

每个类只有一个存储单元，静态数据成员为该类的所有对象共有，不属于某个对象。静态数据成员的**初始化必须在类以外**进行定义性说明。

形式为：<类型> <类名>：：<静态数据成员> =值

静态成员注意以下几点：

1、静态成员**必须初始化**，如果其是有公共访问属性的可以通过对象重新设置值，其最终值以最后一次设置的为准。

2、初始化方式**只能是在类以外**进行定义性说明

3、**访问方式**可以是对象**.**静态成员或ClassName**：：**静态数据成员

通过下面的例子来理解定义：

class A\{

private:

int w,h;

int m ;

**public:**

** static int area;**//静态数据成员的定义形式

int area1;

void setVal(int x)

area = x;

int getArea()

return area;

A(int x,int y)

w=x,h=y;

A()\{\}

\};

**intA::area = 0;** //必须在类外声明性初始化，其他**任何初始化**都是**错误**的。

void main()

Aconst a(3,4);

Ac(2,6);

Af;

c.area1 =4;

c.setVal(4);

**c.area = 8;**//初始化后可以改变其值，不初始化程序编译都通不过

**f.area =16;**

cout<<A::area <<c.area<<endl;/\*都输出 16。以最后一次的改变为准所有对象共享统一静态成员内存空间，两种访问方式都行，当然必须是公共的静态成员，私有的不能在类外访问。\*/

system("pause")；

2.静态数据成员被 类 的所有对象所共享，包括该类派生类的对象。即派生类对象与基类对象共享基类的静态数据成员。举例如下：  
class base\{  
public :  
static int \_num;//声明  
\};  
int base::\_num=0;//静态数据成员的真正定义  
  
class derived:public base\{  
\};  
  
main()  
\{  
base a;  
derived b;  
a.\_num++;  
cout<<"base class static data number \_num is"<<a.\_num<<endl;  
b.\_num++;  
cout<<"derived class static data number \_num is"<<b.\_num<<endl;  
\}  
// 结果为1,2;可见派生类与基类共用一个静态数据成员。  
  
3.静态数据成员可以成为成员函数的可选参数，而普通数据成员则不可以。举例如下：  
class base\{  
public :  
static int \_staticVar;  
int \_var;  
void foo1(int i=\_staticVar);//正确,\_staticVar为静态数据成员  
void foo2(int i=\_var);//错误,\_var为普通数据成员  
\};  
  
4.★静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为 所属类类型的 指针或引用。举例如下：  
  
class base\{  
public :  
static base \_object1;//正确，静态数据成员  
base \_object2;//错误  
base \*pObject;//正确，指针  
base &mObject;//正确，引用  
\};  
  
5.★这个特性，我不知道是属于标准c++中的特性，还是vc6自己的特性。  
静态数据成员的值在const成员函数中可以被合法的改变。举例如下：  
  
class base\{  
public:  
base()\{\_i=0;\_val=0;\}  
  
mutable int \_i;  
static int \_staticVal;  
int \_val;  
void test() const\{//const 成员函数  
  
\_i++;//正确，mutable数据成员  
\_staticVal++;//正确，static数据成员  
\_val++;//错误  
  
\}  
\};  
int base::\_staticVal=0;

## 定义：用static关键字声明的函数成员称为静态函数成员。 ##

每个类只有一个存储单元，静态函数成员为该类的所有对象共有，不属于某个对象。共有的静态函数成员可以通过类名或对象名来调用。静态函数成员**必须通过对象名**来访问**非静态数据成员**。静态成员呢？

注意：

1、静态成员函数在类外**实现**时候**无须加static关键字，**否则是错误的。

通过下面题目来理解静态成员函数

A：**静态函数成员**必须通过**对象名**来访问**非静态数据成员**。找出下面程序的错误。

class A\{

public:

**static** int getVal()

return x;//**错误**不能调用**非静态**数据成员，要通过类的**对象**来调用。

A(int xx)\{\}

private:

int x;

\};

void main()

Aa(3);

cout << a.getVal();

system("pause");

通过类的对象来引用非静态数据成员改正如下：

class A\{

public:

**static** int getVal(**A a**);//静态成员函数

A(int xx)\{x= xx;\}

private:

int x;

\};

int A::getVal(A a)\{ //在**类外实现**静态成员函数，**不能加static**关键字。

return**a.x**;

void main()

Aa(3);

cout<< a.getVal(a);//输出 3

system("pause");

B、静态函数成员可以调用静态数据成员

class A\{

public:

**static** int getVal(A a);

A(int xx)\{x= xx;\}

private:

**static** int staticVar;

int x;

\};

**int A::staticVar =100;**

**int A::getVal(A a)**

//return a.staticVar;正确的调用方法一

//return A::staticVar;正确的调用方法二

return staticVar; //正确的调用方法三

void main()

Aa(3);

cout << a.getVal(a);

system("pause");

1.静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用 类成员函数指针来储存。举例如下：  
class base\{  
static int func1();  
int func2();  
\};  
  
int (\*pf1)()=&base::func1;//普通的函数指针  
int (base::\*pf2)()=&base::func2;//成员函数指针  
  
  
2.静态成员函数不可以调用类的非静态成员。因为静态成员函数不含this指针。  
  
3.静态成员函数不可以同时声明为 virtual、const、volatile函数。举例如下：  
class base\{  
virtual static void func1();//错误  
static void func2() const;//错误  
static void func3() volatile;//错误  
\};  
  
  
最后要说的一点是，静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。

全局变量与全局静态变量的区别：  
(a）若程序由一个源文件构成时，全局变量与全局静态变量没有区别。  
(b)若程序由多个源文件构成时，全局变量与全局静态变量不同：全局静态变量使得该变量成为定义该变量的源文件所独享，即：全局静态变量对组成该程序的其它源文件是无效的。  
(c)具有外部链接的静态；可以在所有源文件里调用；除了本文件，其他文件可以通过extern的方式引用；  
  
静态全局变量的作用：  
（a）不必担心其它源文件使用相同变量名，彼此相互独立。  
（b）在某源文件中定义的静态全局变量不能被其他源文件使用或修改。  
(c) 只能在本文件中使用！具有内部链接的静态；不允许在其他文件里调用；

数据成员可以分静态变量、非静态变量两种.

静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名\+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.

非成静态员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内容中..

一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数..

分两个方面来总结，第一方面主要是相对于面向过程而言，即在这方面不涉及到类，第二方面相对于面向对象而言，主要说明static在类中的作用。

一、在面向过程设计中的static关键字

1、静态全局变量

定义：在全局变量前，加上关键字 static 该变量就被定义成为了一个静态全局变量。

特点：

A、该变量在全局数据区分配内存。

B、初始化：如果不显式初始化，那么将被隐式初始化为0(自动变量是随机的,除非显式地初始化)。

C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。

D、文件作用域下声明的const的常量默认为static存储类型。

静态全局变量不能被其它文件所用；(好像是区别extern的)

其它文件中可以定义相同名字的变量，不会发生冲突；

全局变量与全局静态变量的区别：  
 (a）若程序由一个源文件构成时，全局变量与全局静态变量没有区别。  
 (b)若程序由多个源文件构成时，全局变量与全局静态变量不同：全局静态变量使得该变量成为定义该变量的源文件所独享，即：全局静态变量对组成该程序的其它源文件是无效的。  
 (c)具有外部链接的静态；可以在所有源文件里调用；除了本文件，其他文件可以通过extern的方式引用；  
静态全局变量的作用：  
（a）不必担心其它源文件使用相同变量名，彼此相互独立。  
（b）在某源文件中定义的静态全局变量不能被其他源文件使用或修改。  
 (c)  只能在本文件中使用！具有内部链接的静态；不允许在其他文件里调用；

通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。

但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。

静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。

特点：

A、该变量在全局数据区分配内存。

B、初始化：如果不显式初始化，那么将被隐式初始化为0,以后的函数调用不再进行初始化。

C、它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或　语句块结束时，其作用域随之结束。3、静态函数（注意与类的静态成员函数区别）定义：在函数的返回类型前加上static关键字，函数即被定义成静态函数。特点：

A、静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

定义静态函数的好处：静态函数不能被其它文件所用；

其它文件中可以定义相同名字的函数，不会发生冲突；

二、面向对象的static关键字（类中的static关键字）

1、静态数据成员

在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

//Example 5

\#include<iostream.h>

class Myclass

public:

Myclass(int a,intb,int c);

void GetSum();

private:

int a,b,c;

static int Sum;//声明静态数据成员

\};

intMyclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(inta,int b,int c)

this->a=a;

this->b=b;

this->c=c;

Sum+=a+b+c;

voidMyclass::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中，语句intMyclass::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,intb,int c);

static voidGetSum();/声明静态成员函数

private:

int a,b,c;

static int Sum;//声明静态数据成员

\};

intMyclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(inta,int b,int c)