弱回调

弱回调

利用std::bind、std::shared_ptr、 std::weak_ptr 实现弱回调

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

class Product {
public:
    Product(const std::string& name) : 
        productName(name) 
    {
        printf("Product created.\n");
    }
    ~Product() {
        printf("product destroyed.\n");
    }
    const std::string& getName() const {
        return productName;
    }
private:
    std::string productName;
};

class Factory: public std::enable_shared_from_this<Factory> {
public:
    std::shared_ptr<Product> 
        getProduct(const std::string& productName) {
        
        pthread_mutex_lock(&mutex);
        
        auto& wpro = container[productName];
        auto spro = wpro.lock();
        
        if (!spro) {
            auto wfac =  std::weak_ptr<Factory>(shared_from_this());
            /*the KEY POINT*/
            spro.reset(new Product(productName), 
                        std::bind(&Factory::deleteProduct,
                                    wfac, std::placeholders::_1));
            wpro = spro;
        }

        pthread_mutex_unlock(&mutex);
        
        return spro;
    }

private:
    // "static" is the key point
    static void deleteProduct(std::weak_ptr<Factory>& wptr, Product* pro) { 
        pthread_mutex_lock(&mutex); 
        
        auto sptr = wptr.lock();
        
        if (sptr) {
            sptr->container.erase(pro->getName());
        }
        delete pro;
        pthread_mutex_unlock(&mutex);
    }
private:
    std::unordered_map<std::string, std::weak_ptr<Product>> container;
};