c++语法--析构函数的偶尔职能：

析构函数函数体，一般是打印信息，因为对象是在栈中，当程序结束时栈也被释放了，不存在内存泄漏。。只有当对象里面还申请了堆空间（成员变量时链表的头指针，成员函数中有add_tail这样的要申请堆空间的），才要在析构函数中去delete内存。。。。
class CList
{
    SNode *m_phead; //默认的是私有成员      链表最重要的就是头节点，头插还是尾插都与头节点有关
    char m_name[20];
   
    public:
    CList()
    {
    m_phead=NULL;
    }
   /* ~CList()
    {
    cout<<m_name<<endl;        //这样的析构函数是不合格的    对象里的堆空间没有被释放，，会造成内存泄漏
    }
    */
    void RemoveAll()
    {
    SNode *p=m_phead;
     SNode *p1=new SNode;
     while(p)
     {
     p1=p;
     p=p->pnext;           ////////////////////////////////////////////////////////////////////////
     delete p1;
     }
    }
    ~CList()
    {
    cout<<m_name<<endl;                       //这样的析构函数才是合格
    RemoveAll();
    }     
   
    void SetName(const char *p)
    {
    strcpy(m_name,p);
    }
   
   
    void AddHead(int data)
    {
    SNode *p=new SNode;
    p->data=data;
    p->pnext=m_phead;
    m_phead=p;
    }
    void AddTail(int data)
    {
    SNode *p=new SNode;
    p->data=data;
    p->pnext=NULL;
   
    if(!m_phead)
    {
    m_phead=p;
    return;
    }
     SNode *p1=new SNode;
     p1=m_phead;
     while(p1->pnext)
     {p1=p1->pnext;}
     p1->pnext=p;
    }
   
    void print()
    {
     SNode *p=m_phead;
     cout<<m_name<<endl;
     while(p)
     {
     cout<<p->data<<endl;
     p=p->pnext;
     }
    }
}
int main()
{
CList list1,list2;
list1.SetName("list1");         //传参是字符串，加双引号
list1.AddHead(1);
list1.AddTail(2);

list2.SetName("list2");
list2.AddHead(1);
list2.AddTail(2);

return 0；
}

c++语法--static
静态成员变量要在类外分配空间和初始化，生命周期为整个程序过程
设想一款战斗游戏，里面的人数开始是0个，出生一个人数加一，死亡一个人数减一,,,,,同一类的每个人要知道现在的人数，因为人数多到某一值时，就大胆的战斗，否则就先隐蔽。。。。。可以
知道    成员变量和静态成员变量的区别：：：前者是某个对象只能知道，使用，更改自己的成员变量，后者是一个类的所有对象都可以知道，使用，更改这个静态成员变量。
class Game
{
static int count;

public:
Game()
{
count++;
}

~Game()
{
count--;
}
}
Game::count=0;
静态成员函数不可以调用成员变量，，，因为其实质不是成员函数

c++语法---友元函数
即非成员函数可以访问私有成员变量
友元机制：允许一个类将对其非公有成员访问权授予指定的函数或类