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

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

---

错误代码：

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;
}