c++里面的静态成员和静态变量

C++ 里面的静态成员和静态成员函数

1.记录对象产生的个数

C里面使用全局变量

2.c语言里面适用全局变量的缺点：

（1）将来如果需要记录其他类产生的对象，需要多个全局变量，全局变量会和一个类硬生生的产生关系;

（2） 违背了低耦合的编程思想

3静态成员变量初始化位置

  （1）类实现文件.cpp文件

  （2）main()函数实现之前

  （3）不能在函数内部进行初始化

    (4) 不能放在构造函数内部进行初始化

 （5）无论静态变量成员是private还是public，初始化还是要放在类的实现文件或者是main()函数之前

为什么初始化不能放在初始化列表中，因为静态变量只能有一个，如果放在初始化列表，每次创建对象，都会有一个静态变量产生;

下面这个例子实现了对学生类的增删改查，其中用到双链表的数据结构;

删除函数和打印函数应该是每个成员共享的，而不依赖于每一个对象，如果声明为普通成员函数，那么每次调用函数，都需要构造对象，然而打印和删除并不是具体针对某一对象；所以删除和打印应该使用静态成员函数;

//double link for explan static arguments

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

class DNode //节点类
{
public:
struct Student
{ //数据域
int num;
char name[20];
float score;
}m_data; //变量名

static DNode *s_head;
static DNode *s_tail;
DNode *m_next;//指针域
DNode *m_pre;
public:
DNode();//:s_head(NULL),s_tail(NULL)
DNode(int num,const char *name,float score);//:s_head(NULL),s_tail(NULL)
//有参构造函数声明
void headInsert(); //头插法声明
void tailInsert(); //头插法声明
static void headDelete();//头删法实现
static void tailDelete();//尾删法实现
static void printDlist();//打印节点声明
~DNode();

};//类的声明到此结束
DNode * DNode::s_head=NULL;
DNode * DNode::s_tail=NULL;
//DNode * DNode::s_head =NULL;
//DNode * DNode::s_tail =NULL;
DNode::DNode()//无参构造函数
{//构造函数能直接类里面的数据

cout<<"num:";
cin>>m_data.num;
cout<<"name:";
cin>>m_data.name;
cout<<"score";
cin>>m_data.score;

}

DNode::DNode(int num,const char *name,float score)
{ //有参构造
m_data.num=num;
strcpy(m_data.name,name);
m_data.score=score;
}

DNode::~DNode()//析构函数实现
{//判断要脱的是否是第一个节点
if(s_head==this)
{
s_head=s_head->m_next;
if(s_head==NULL)
{//来到是要拖的最后一个节点
s_tail=NULL;
}
else
{
s_head->m_pre=NULL;//有确保安全性

}
}
else
{
this->m_pre->m_next=this->m_next;
if(this == s_tail)
{//要删除的节点视尾节点
s_tail=this->m_pre;
}
else
{
this->m_next->m_pre=this->m_pre;
}

}
//最后一个节点
}

void DNode::headInsert()
{
if(s_head==NULL)
{
s_head=s_tail=this;
this->m_next=NULL;
}
else
{
this->m_next=s_head;
s_head->m_pre=this;
s_head=this;
}
}
void DNode::tailInsert()
{
if(s_head==NULL)
{
s_head=s_tail=this;
this->m_next=NULL;
}
else
{
this->m_pre=s_tail;
this->m_next=NULL;
s_tail->m_next=this;
s_tail=this;
}
}

void DNode::headDelete()
{
if(s_head==NULL)
{
return ;
}
delete s_head;
}

void DNode::tailDelete()
{
if(s_head==NULL)
{
return ;
}
delete s_tail;
}

void DNode::printDlist()
{
DNode *temp=s_head;
for(;temp;temp=temp->m_next)
{
cout<<"[num="<<temp->m_data.num<<",name="<<temp->m_data.name<<",score="<<temp->m_data.score<<"}-->";
}
cout<<"NULL\n";

}
int main(int argc,char *argv[])
{
int select;
DNode *d;
while(1)
{
cout<<"========"<<endl;
cout<<"1.头增"<<endl;
cout<<"2.尾增"<<endl;
cout<<"3.头删"<<endl;
cout<<"4.尾删"<<endl;
cout<<"5.打印数据"<<endl;
cout<<"0.退出"<<endl;
cin>>select;
switch(select)
{
case 1:
d=new DNode;
d->headInsert();
break;
case 2:
d=new DNode;
d->tailInsert();
break;
case 3:
DNode::headDelete();
break;
case 4:
DNode::tailDelete();
break;
case 5:
DNode::printDlist();
break;
case 0:
exit(0);
break;

}

cout<<" "<<endl;
}
return 0;
}


静态成员函数初始化:

(1)初始化在类体外进行，而且前面不能加static;

(2)初始化时不加改成元的访问权限控制符private;

(3)初始化时使用作用域运算符来标明它所属的类，因此，静态数据成员是类的成员，而不是对象的成员

静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化

静态数据成员初始化的格式如下：

<数据类型> <类名>::<静态数据成员名> = <值>

DNode * DNode::s_head = NULL

4.静态成员的访问

  （1）静态成员变量不属于任何对象，所以不依赖于任何对象访问

  （2）所有对象共享静态成员变量

    (3)    无论是对象或者类去访问某个静态变量成员，public属性的静态访问访问如下

  Student::count;

  Student s1;

  s1.count

  private属性的静态成员函数变量，需要依赖于public公共的接口，不能直接访问;

5.静态成员函数

一般对私有的静态成员变量进行操作

6.静态成员函数的注意点

  （1）静态成员函数不能访问非静态数据成员，不能调用非静态成员函数，因为静态成员不依赖于对象, 所以无法传入this指针

  （2） 非静态成员函数可以访问静态成员函数或者调用静态成员函数;