Как инициализировать статические переменные класса если они в привате?

class Pump
{
   inline static size_t m_count=0;
};

#ifndef PUMPS_H
#define PUMPS_H
 
 
class Pumps
{
    public:
        Pumps();
        virtual ~Pumps();
 
    protected:
 
    private:
        static int quontity=0;
};
 
#endif // PUMPS_H

int Pumps::quontity = 0;

#include <iostream>
 
class Test {
public:
    Test() {
        count++;
    }
    ~Test() {
        count--;
    }
    static int getCount() {
        return count;
    }
private :
    static int count;
};
 
int Test::count{0};
 
int main() {
    Test t1{};
    std::cout << Test::getCount() << std::endl;
    Test t2{};
    Test t3{};
    Test t4{};
    std::cout << Test::getCount() << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
 
struct pump
{
    size_t m_id;
    bool m_started;
    
    pump(const size_t id) noexcept
        : m_id(id)
        , m_started()
    {
        std::cout << "pump " << this->m_id << " was created\n";
    }
 
    void run()
    {
        if(this->m_started)
            return;
        
        this->m_started = true;
        std::cout << "pump " << this->m_id << " was runned\n";
    }
    
    void stop()
    {
        if(!this->m_started)
            return;
        
        this->m_started = false;
        std::cout << "pump " << this->m_id << " was stopped\n";
    }
};
 
 
struct pumps
{
    using pumps_t = std::vector<pump>;
    
    void add(const size_t id) 
    {
        this->m_pumps.emplace_back(id);
    }
    
    void run_all()
    {
        for(auto& pump: this->m_pumps)
            pump.run();
    }
    
    void stop_all()
    {
        for(auto& pump: this->m_pumps)
            pump.stop();
    }
    
    
    ~pumps()
    {
        this->stop_all();
    }
    
    pumps_t m_pumps = {};
};
 
 
int main()
{
    pumps device;
    device.add(1);
    device.add(2);    
    device.run_all();
}

#include <ctime>
#include <cstdlib>
#include <iomanip>
#include <ostream>
#include <array>
#include <iterator>
#include <algorithm>
#include <iostream>
#include <map>
 
class Object {
private:
    static std::map<const Object*, Object*> objects;
public:
    Object() {
        objects.insert(std::make_pair(this, this));
    }
    virtual ~Object() {
        objects.erase(this);
    }
 
    virtual const std::string &toString() const = 0;
 
    static std::vector<Object*> findAll() {
        std::vector<Object*> result;
        result.reserve(objects.size());
        for (auto object : objects) {
            result.push_back(object.second);
        }
        return std::move(result);
    }
    
    template<typename T>
    static std::vector<T*> findByType()
    {
        std::vector<T*> result;
        for(auto object : objects) {
            T *typedObject = dynamic_cast<T*>(object.second);
            if (typedObject != nullptr) {
                result.push_back(typedObject);
            }
        };
        return std::move(result);
    }
 
 
};
 
std::map<const Object*, Object*> Object::objects{};
 
class Cat : public Object {
private:
    static const std::string name;
public:
    virtual const std::string &toString() const {
        return name;
    }
};
 
const std::string Cat::name = "cat";
 
class Dog : public Object {
private:
    static const std::string name;    
public:
    virtual const std::string &toString() const {
        return name;
    }
};
 
const std::string Dog::name = "dog";
 
 
int main(int argc, char **argv) {
    Dog *d = new Dog();
    Cat *c = new Cat();
    Cat *c2 = new Cat();
 
    std::vector<Object*> all = Object::findAll();
    std::cout << "Number of objects: " << all.size() << ", first one: " << all[0]->toString() << std::endl;
 
    std::vector<Cat*> cats = Object::findByType<Cat>();
    std::cout << "Number of cats: " << cats.size() << ", first cat: " << cats[0]->toString() << std::endl;
    
    std::vector<Dog*> dogs = Object::findByType<Dog>();
    std::cout << "Number of dogs: " << dogs.size() << ", first cat: " << dogs[0]->toString() << std::endl;
    
    return 0;
}