C/C++编程：reference to non-static member function must be called

港控/mmm° 2022-10-11 12:07 327阅读 0赞

> 主要原因是我使用了函数指针，而函数指针所指函数须得是静态才行

--------------------

错误代码：

class Solution {
        
    public:
        string ReverseSentence(string str) {
        
    
            typedef string::const_iterator const_iter;
            const_iter b = str.begin();
            const_iter e = str.end();
            string ret;
            int first = 1;
            while( b != e ){
        
                b = find_if( b, e, legal );
                if( b < e ){
        
                    const_iter after = find_if( b, e, illegal ); // 这里的调用出了问题，编译出错reference to non-static member function must be called
                    if( ret != "" ) ret = string(b, after) + " " + ret;
                    else ret = string(b, after) + ret;
                    b = after;
                }
                else{
        
                    if( 1 == first ) return str;
                    else first = 2;
                }
            }
            return ret;
        }
    private:
         bool legal( char ch ){
         return !illegal(ch); } // 这里是问题
         bool illegal( char ch ){
         return isspace(ch); }
    };

# 解决 #

分析上面的错误，应该说的是，find\_if的第三个参数应该调用一个non static函数，这是什么原因？我们来看下find\_if的代码

template<class InputIterator, class UnaryPredicate>
      InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
    {
        
      while (first!=last) {
        
        if (pred(*first)) return first;
        ++first;
      }
      return last;
    }

第三个谓词pred是一个非成员函数，因为pred的调用过程只有一个参数，就是\*first。但是，对于像bool legal(char ch)这样的成员函数，它是属于类的，所以调用它必须需要对象才可以，这是因为bool legal这样的函数完整的标签是：

bool legal( Solution* this, char ch );

也就是它有一个implicit parameter，这才导致它无法被find\_if这样的函数调用，主要是参数不匹配。当然，把这个函数改成static即可。

> 如果一定要非静态引用怎么办？

#include <string>
    #include <memory>
    #include "mutex"
    
    #ifndef HV_THREAD_POOL_H_
    #define HV_THREAD_POOL_H_
    
    #include <vector>
    #include <thread>
    #include <queue>
    #include <functional>
    #include <atomic>
    #include <mutex>
    #include <condition_variable>
    #include <future>
    #include <memory>
    #include <utility>
    #include <stack>
    
    class HThreadPool {
        
    public:
        using Task = std::function<void()>;
    
        HThreadPool(int size = std::thread::hardware_concurrency())
                : pool_size(size), idle_num(size), status(STOP) {
        
        }
    
        ~HThreadPool() {
        
            stop();
        }
    
        int start() {
        
            if (status == STOP) {
        
                status = RUNNING;
                for (int i = 0; i < pool_size; ++i) {
        
                    workers.emplace_back(std::thread([this]{
        
                        while (status != STOP) {
        
                            while (status == PAUSE) {
        
                                std::this_thread::yield();
                            }
    
                            Task task;
                            {
        
                                std::unique_lock<std::mutex> locker(_mutex);
                                _cond.wait(locker, [this]{
        
                                    return status == STOP || !tasks.empty();
                                });
    
                                if (status == STOP) return;
    
                                if (!tasks.empty()) {
        
                                    --idle_num;
                                    task = std::move(tasks.top());
                                    tasks.pop();
                                }
                            }
    
                            task();
                            ++idle_num;
                        }
                    }));
                }
            }
            return 0;
        }
    
        int clear() {
        
            std::unique_lock<std::mutex> locker(_mutex);
            if (!tasks.empty()) {
        
                std::stack<Task>().swap(tasks);
            }
            return 0;
        }
    
        int stop() {
        
            if (status != STOP) {
        
                status = STOP;
                _cond.notify_all();
                for (auto& worker : workers) {
        
                    worker.join();
                }
            }
            return 0;
        }
    
        int pause() {
        
            if (status == RUNNING) {
        
                status = PAUSE;
            }
            return 0;
        }
    
        int resume() {
        
            if (status == PAUSE) {
        
                status = RUNNING;
            }
            return 0;
        }
    
        int wait() {
        
            while (1) {
        
                if (status == STOP || (tasks.empty() && idle_num == pool_size)) {
        
                    break;
                }
                std::this_thread::yield();
            }
            return 0;
        }
    
        // return a future, calling future.get() will wait task done and return RetType.
        // commit(fn, args...)
        // commit(std::bind(&Class::mem_fn, &obj))
        // commit(std::mem_fn(&Class::mem_fn, &obj))
        template<class Fn, class... Args>
        auto commit(Fn&& fn, Args&&... args) -> std::future<decltype(fn(args...))> {
        
            using RetType = decltype(fn(args...));
            auto task = std::make_shared<std::packaged_task<RetType()> >(
                    std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...));
            std::future<RetType> future = task->get_future();
            {
        
                std::lock_guard<std::mutex> locker(_mutex);
                tasks.emplace([task]{
        
                    (*task)();
                });
            }
    
            _cond.notify_one();
            return future;
        }
    
    public:
        enum Status {
        
            STOP,
            RUNNING,
            PAUSE,
        };
        int                 pool_size;
        std::atomic<int>    idle_num;
        std::atomic<Status> status;
        std::vector<std::thread>    workers;
        std::stack<Task>            tasks;
    
    protected:
        std::mutex              _mutex;
        std::condition_variable _cond;
    };
    
    #endif // HV_THREAD_POOL_H_
    
    class myClass{
        
    public:
    
    };
    
    class pool_task{
        
         HThreadPool *m_threadPool;
         std::string  my_name = "hhhhh" ;
    public:
        pool_task(){
        
            m_threadPool = new HThreadPool(5);
            m_threadPool->start();
        }
    
        void pool_commit(){
        
            std::string param = "aaa";
            m_threadPool->commit([this, param] {
        return this->task(param); });
        }
    
         void task(const std::string& param){
        
            printf("aaaaaaaaaa, %s, %s\n", my_name.c_str(), param.c_str());
        }
    };
    
    int main(){
        
        auto *p = new pool_task();
        p->pool_commit();
        getchar();
        return 0;
    }