如何避免重複的代碼，包括std :: map和std :: mutex

Question

我有一個類，包括一個地圖和一個互斥體。在每一個成員函數互斥體保護從多個線程訪問這個類的對象可在地圖，爲前：

class bar 
{ 
public: 
    void hello() {} 
    void set_something(int x) {} 
    int get_something(int x, int y) { return x + y; } 
}; 

class foo 
{ 
public: 
    foo() 
    { 
     m_map[0]; 
     m_map[1]; 
     m_map[2]; 
    } 
    void hello(unsigned int index) 
    { 
     std::lock_guard<std::mutex> lock(m_mut); 
     const auto iter = m_map.find(index); 
     if (iter != m_map.end()) 
      iter->second.hello(); 
    } 
    void set_something(unsigned int index, int x) 
    { 
     std::lock_guard<std::mutex> lock(m_mut); 
     const auto iter = m_map.find(index); 
     if (iter != m_map.end()) 
      iter->second.set_something(x); 
    } 
    int get_something(unsigned int index, int x, int y) 
    { 
     std::lock_guard<std::mutex> lock(m_mut); 
     const auto iter = m_map.find(index); 
     if (iter != m_map.end()) 
      return iter->second.get_something(x, y); 
     return 0; 
    } 
private: 
    std::mutex     m_mut; 
    std::map<unsigned int, bar> m_map; 
}; 

有一種優雅的方法，以避免重複的代碼？

Answer 1

你可以使用代理服務器RAII這樣的：

#include <iostream> 
#include <mutex> 
#include <map> 

template < typename F, typename S> 
struct mutex_map { 
    std::recursive_mutex m_; 
    std::map<F,S> map_; 

    struct Proxy { 
     Proxy(std::map<F,S> & map, std::recursive_mutex &m) : map_(&map), lock_(m) { 
      std::cout << "lock\n"; 
     } 
     ~Proxy() { std::cout << "unlock\n"; } 
     std::map<F,S>* map_; 
     std::unique_lock<std::recursive_mutex> lock_; 

     std::map<F,S>* operator->() { return map_; } 
    }; 

    Proxy operator->() { 
     return { map_, m_ }; 
    } 
}; 

int main() { 
    mutex_map<int, int> mm; 

    mm->emplace(1, 3); 
    std::cout << (mm->find(1) == mm->end()) << "\n"; 
    std::cout << (mm->find(2) == mm->end()) << "\n"; 
} 

Answer 2

您可以將常用的部分爲「do_something」，並通過仿函數到其中：

... 
void do_something(const std::function<void(bar&)>& func) 
{ 
    std::lock_guard<std::mutex> lock(m_mut); 
    const auto iter = m_map.find(index); 
    if (iter != m_map.end()) 
     func(std::ref(*iter)); 
} 

int get_something(unsigned int index, int x, int y) 
{ 
    do_something(std::bind(&bar::get_something, std::placeholders::_1, index, x, y)); 
} 
... 

一個問題 - 你需要保護與互斥唯一的std ::地圖或std ::地圖和它的要素是什麼？你可能會認爲有關粒度