Можно ли сделать доступным для всех классов пул потоков?

ThreadPool::ThreadPool() :nthreads(1),stop(false) {
 
    for (unsigned int i = 0; i < nthreads; ++i) {
 
        threads.emplace_back( //add thread to threads container
            std::thread( //thread creation
 
                [this]() { //lambda for wating for tasks
 
                    while (!stop) {
                        task_wrapper task; //create it before mutex lock 
 
                        {
                            std::unique_lock<std::mutex> ul(mtx); //unique_lock is used for condition var
 
                            cv.wait(ul, [this]() { //wait for tasks or stop of the programm
 
                                return !tasks.empty() || stop;
 
                                });
 
                            if (stop)
                                return;
 
                            task = std::move(tasks.front()); //take task from tasks container
 
                            tasks.pop(); //delete taken task from container
 
                        }
 
                        task(); //run task
 
                    }
 
                }));
 
    }
}

#ifndef THREAD_POOL_HPP
#define THREAD_POOL_HPP
//Example of thread pool
 
#include<thread> //for std::thread
#include<condition_variable> //for std::conditional_variable
#include<mutex> //for std::mutex
#include<future> //for std::future
#include<queue> //for std::queue
#include<functional> //for std::bind
#include<atomic> //for std::atomic
#include<type_traits> //for std::invoke_result c++17
#include"taskwrapper.hpp" //for task_wrapper
 
class ThreadPool
{
public:
 
    ThreadPool(); //on default creates 1 thread
    ThreadPool(const size_t); //creates number of threads
    ThreadPool(const ThreadPool&) = delete; //no copy constructor
    ThreadPool(ThreadPool&&) = delete; //no move constructor
 
    ~ThreadPool();
 
    ThreadPool& operator=(const ThreadPool&) = delete; //no copy operator
    ThreadPool& operator=(ThreadPool&&) = delete; //no move operator
 
    void AddThread(const size_t n); //Increase number of threads in the pool
 
    void StopPool(); //Stop poooling
 
    size_t ThreadsNumber();//return the nuber of the working threads
 
 
    template<typename T, typename... Args>  
    std::future<typename std::invoke_result<T,Args...>::type> AddTask(T&& obj, Args&&... args){ //return future which contains function return value
 
        using rtype = typename std::invoke_result<T,Args...>::type; // deduce function return type
 
        std::packaged_task<rtype()> ptask(std::bind(std::forward<T>(obj), std::forward<Args>(args)...));
        std::future<rtype> future = ptask.get_future(); //get future from packaged task
 
        {
            std::lock_guard<std::mutex> lg(mtx); //needed to safely add task to tasks container
 
            tasks.emplace(std::move(ptask)); //add task to task container.
 
        }
 
        cv.notify_one(); //notify waiting thread
 
        return future; //return future
    }
 
 
private:
    size_t nthreads; //number of threads
 
    std::atomic<bool> stop; //variable to check if we have to stop threading
 
    std::mutex mtx;
 
    std::condition_variable cv;
 
    std::queue<task_wrapper> tasks; //container for tasks
 
    std::vector<std::thread> threads; //container for threads
 
};
#endif

#include "threadpool.hpp"
 
ThreadPool::ThreadPool() :nthreads(1),stop(false) {
 
    for (unsigned int i = 0; i < nthreads; ++i) {
 
        threads.emplace_back( //add thread to threads container
            std::thread( //thread creation
 
                [this]() { //lambda for wating for tasks
 
                    while (!stop) {
                        task_wrapper task; //create it before mutex lock 
 
                        {
                            std::unique_lock<std::mutex> ul(mtx); //unique_lock is used for condition var
 
                            cv.wait(ul, [this]() { //wait for tasks or stop of the programm
 
                                return !tasks.empty() || stop;
 
                                });
 
                            if (stop)
                                return;
 
                            task = std::move(tasks.front()); //take task from tasks container
 
                            tasks.pop(); //delete taken task from container
 
                        }
 
                        task(); //run task
 
                    }
 
                }));
 
    }
}
 
 
ThreadPool::ThreadPool(const size_t n):nthreads(n),stop(false) {
 
    for (unsigned int i = 0; i < nthreads; ++i) {
 
        threads.emplace_back( //add thread to threads container
            std::thread( //thread creation
 
                [this]() { //lambda for wating for tasks
                    while (!stop) {
                        task_wrapper task; //create it before mutex lock 
 
                        {
                            std::unique_lock<std::mutex> ul(mtx); //unique_lock is used for condition var
 
                            cv.wait(ul, [this]() { //wait for tasks or stop of the programm
 
                                return !tasks.empty() || stop;
 
                                });
 
                            if (stop)
                                return;
 
                            task = std::move(tasks.front()); //take task from tasks container
 
                            tasks.pop(); //delete taken task from container
 
                        }
 
                        task(); //run task
 
                    }
                }));
 
    }
 
}
 
 
ThreadPool::~ThreadPool() {
    if(!stop)
        StopPool();
}
 
 
void ThreadPool::StopPool() {
 
    stop = true;
 
    cv.notify_all();
 
    for (auto& thread : threads) {
        thread.join();
    }
 
}
 
 
void ThreadPool::AddThread(const size_t n) {
 
    nthreads += n;
 
    for (unsigned int i = 0; i < n; ++i) {
 
        threads.emplace_back( //add thread to threads container
            std::thread( //thread creation
 
                [this]() { //lambda for wating for tasks
 
                    while (!stop) {
                        task_wrapper task; //create it before mutex lock 
 
                        {
                            std::unique_lock<std::mutex> ul(mtx); //unique_lock is used for condition var
 
                            cv.wait(ul, [this]() { //wait for tasks or stop of the programm
 
                                return !tasks.empty() || stop;
 
                                });
 
                            if (stop)
                                return;
 
                            task = std::move(tasks.front()); //take task from tasks container
 
                            tasks.pop(); //delete taken task from container
 
                        }
 
                        task(); //run task
 
                    }
 
                }));
 
    }
}
 
 
size_t ThreadPool::ThreadsNumber() {
    return nthreads;
}

#ifndef TASK_WRAPPER_HPP
#define TASK_WRAPPER_HPP
#include <memory>
 
class task_wrapper{
    public:
        template<typename T>
        task_wrapper(T&& f):func(new impl<T>(std::move(f))){};
 
        task_wrapper() = default;
        task_wrapper(const task_wrapper&) = delete;
        task_wrapper(task_wrapper&& t):func(std::move(t.func)){}
 
        task_wrapper& operator=(const task_wrapper&) = delete;
        task_wrapper& operator=(task_wrapper&& t){
            func = std::move(t.func);
            return *this;
        }
 
        void operator()(){(*func)();}
    private:
        struct impl_base
        {
            virtual void operator()() = 0;
            virtual ~impl_base() = default;
        };
 
        template<typename T>
        struct impl : impl_base
        {
            T f;
            impl(T&& _f):f(std::forward<T>(_f)){}
            virtual void operator()(){f();}
        };
        
        std::unique_ptr<impl_base> func;
        
};
#endif