c++第三次作业

                   C++ 数据共享之——类中的静态数据成员

 
 

思考：我们常说在抽象类的时候，需要把一个类的所有对象具有的相同属性给抽象提取出来。但是往往一个类中不仅仅只有这些 “实例属性” ，还有一些属性是整个类所共有称为 “类属性” ，不属于任何一个具体的对象，在不破坏面向对象程序设计语言的封装性的特性上把这些属性表现出来？

 
以一个 点类 为例，在一个程序中我们可能会声明很多个点类，当我们想要知道一共声明了多少个点类时，就需要这种 “类属性”，来记录相应的数据。

以上面的需求为例。

通过思考，第一种方法是声明一个全局变量来记录到底需要的数据。

点类的头文件

      class Point
      {
        public:
            Point(int x, int y,int count);  //构造函数
            
            Point(Point& p); //复制构造函数
            
            ~Point();  // 析构函数
        
            int getX();
            int getY();
        
            void showConut();
        private:
            int x, y;
            int count;
      };

点类的函数具体实现

    #include "Point.h"
    using namespace std;
    #include<iostream>
    
    Point::Point(int x, int y,int count)
    {
        this->x = x;
        this->y = y;
        this->count = count;
    }
    
    Point::Point(Point& p)
    {
        x = p.x;
        y = p.y;
        count = p.count;
    }
    
    Point::~Point()
    {
        count--;
    }
    
    int Point::getX()
    {
        return x;
    }
    
    int Point::getY()
    {
        return y;
    }
    
    void Point::showConut()
    {
        cout << "一共有"<< count <<"个点类" << endl;
    }

主函数测试

    #include <iostream>
    #include"Point.h"
    
    int main()
    {
        Point p1(1,2,1);//使用默认构造函数初始化点
        p1.showConut();
        Point p2(1, 2, 2);
        p2.showConut();
    }

运行结果图

第一种方法小结：
第一种方法的意思就是，每当你生成一个点类时，你需要告诉这个点类，你到底是第几个点，这样的操作显得很多余，而且容易出错，有时不小心输错了，就可能带来意向不到的后果，虽然这样是满足了题目的要求但是不推荐。
 

第二种方法，在类中声明静态数据成员

点类

    class Point
    {
    public:
        Point(int x, int y); //构造函数
        
        Point(Point& p); //复制构造函数
        
        ~Point();  // 析构函数
    
        int getX();
        int getY();
    
        void showConut();
    private:
        int x, y;
        static int count;
    };

点类的具体实现

    #include "Point.h"
    using namespace std;
    #include<iostream>
    
    Point::Point(int x, int y)
    {
        this->x = x;
        this->y = y;
        count++;
    }
    
    Point::Point(Point& p)
    {
        x = p.x;
        y = p.y;
        count++;
    }
    
    Point::~Point()
    {
        count--;
    }
    
    int Point::getX()
    {
        return x;
    }
    
    int Point::getY()
    {
        return y;
    }
    
    void Point::showConut()
    {
        cout << "一共有"<< count <<"个点类" << endl;
    }
    
    int Point::count = 0;

main方法

    #include <iostream>
    #include"Point.h"
    
    int main()
    {
        Point p1(2,1);//使用默认构造函数初始化点
        p1.showConut();
        Point p2(2, 2);
        p2.showConut();
    
    
    }

第二种方法小结：
在第二种方法中，只是做了一些小小的改动，在 count 前添加了static就实现和第一种方法一样的效果，而且不用再告诉声明的点类到底是第几个点类，减小了出错的可能性，同时也不用在每一个点类中分配count的存储空间，一举多得，推荐第二种方法来做类似的需求。

静态数据成员小结:

1.静态成员函数的初始化必须在类的外部实现。
2.用static修饰
3.使用时，应当是 类名：：表示符

转载于:https://www.cnblogs.com/tianbatua112/p/11576657.html