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） 非静态成员函数可以访问静态成员函数或者调用静态成员函数;