博客

一、

1）static修饰的静态成员

成员：成员变量，成员方法

1.static声明为静态的，称为静态成员，不管这个类创建了多少对象，静态成员只有一个拷贝，但是类的其他所有成员共享这个拷贝。

静态对象属于类，不属于对象。

2.静态变量，是在编译阶段就分配好空间，对象还没创建的时候就有了空间。

3.静态成员变量必须在类中声明，类外定义。定义的时候不用加static

class person{
public:
    static int num;
};
int person::num = 100;
void test()
{
    person ob;
    cout<<ob.num<<endl ;// 100
    cout<<person::num<<endl;//100
    ob.num = 300;
    cout<<person::num<<endl; //300
    cout<<ob.num<<endl;//300
}

对象都可以对其进行修改、以及使用作用域对其修改，

谁最后修改就等于谁。

二、 static修饰静态成员函数

1.属于类不属于对象，大家共享它。

这里使用静态成员函数去访问data就可以不实例化成员去访问data函数，静态函数不能操作非静态数据，非静态函数也能访问静态数据

class person{
private: int num ;
       static int data;
       
public: static int getstaticdata(void) //这个可以使用类::getstaticdata()访问
       {
          return data;
       }
       int getdata(void)  // 使用这个成员函数的时候，必须先实例化对象，然后用对象.getdata()访问
       {
           return data;
       }
};
int person::data =100;
void test()
{
   cout<<person::getstaticdata()<<endl; //100
}
int main()
{
    test();
    return  0;
}

三、const修饰静态成员变量 ，既要实现共享(static)，又要实现不能修改(const),static前面加上const,定义的时候也要加哦。

#include <iostream>
using namespace std;
class DATA{
public:
   const static int num;
};
const int DATA::num = 100;
int main()
{
        DATA ob;
        ob.num = 300;//err ,const修饰，不准修改
}

案例1.静态成员统计实例化对象个数

class DATA{

     public:static int mount;
             DATA()
    {
        mount++;
        cout<<"构造函数"<<endl;
    }
    DATA(const DATA &ob)
    {
        mount++;
        cout<<"拷贝构造函数"<<endl;
    }
    ~DATA()
    {
        mount--;
        cout<<"析构函数"<<endl;
    }
};
int DATA::mount = 0;
void test()
{
  DATA ob1;
  DATA ob2;
  cout<<"对象个数为："<<DATA::mount<<endl;
  {
      DATA ob3;
      DATA ob4;
      cout<<"对象个数为："<<DATA::mount<<endl;
  }
  cout<<"对象个数为："<<DATA::mount<<endl;
}
int mount =0;
int main()
{

    test();
    return  0;
}

案例二：单例模式设计(打印机)

#include <iostream>
#include<cstring>
#include<stdlib.h>
using namespace std;
class Printer {
private: static Printer *signelprinter ;   //先定义个一个静态的对象指针变量，去保存唯一的实例地址
    Printer(){testnum=0;}                //这里的构造函数和拷贝构造函数都放进private，避免外部再实例化对象。
    Printer(const Printer &ob){}
public:
   static Printer * getsignelprinter()     //获取单例指针方法。
    {
        return  signelprinter;
    }
    int testnum;
    void printfTest(char*test) //功能函数
    {
        cout<<"正在打印test"<<test<<endl;
        testnum++;
    }
};
Printer * Printer::signelprinter = new Printer; //初始化静态对象指针变量
int main()
{
    Printer *p1 = Printer::getsignelprinter();
   p1->printfTest("体检报告");
   p1->printfTest("入职报告");
    Printer *p2 = Printer::getsignelprinter();
    p2->printfTest("离职报告");
    cout<<"总共打印份数:"<<p2->testnum<<endl;
}