Question

我基本上是在尝试为std::map创建一个线程安全的包装器类。由于我来自C语言，因此很难弄清C ++的所有细微差别。我试图覆盖[] operator，以接受std::string参数，仅将其传递给我的std::map成员。通过引用std::map::operator[]，它应该可以正常工作：

T& operator[]( const Key& key );

这是我的课程：

thread_map.hpp

#ifndef THREAD_MAP_H
#define THREAD_MAP_H

#include <map>
#include <functional>
#include <mutex>

template <class T>class Thread_map
{
private:
    std::map<std::string, T> map;
    std::mutex map_mutex;

public:

    ~Thread_map();

    T& at(size_t pos);
    T& operator[](std::string &key);

    size_t size() const;
    bool empty() const;

    void clear();
    void insert(std::pair<std::string, T> pair);
    T& erase(const std::string &key);

    bool for_each(std::function<bool (Thread_map, std::string&, T&)> fun);
};

template<class T> Thread_map<T>::~Thread_map()
{
    this->map.clear();
}

template<class T> T& Thread_map<T>::at(size_t pos)
{
    T *value;
    this->map_mutex.lock();
    value = this->map.at(pos);
    this->map_mutex.unlock();
    return value;
}

template<class T> T& Thread_map<T>::operator[](std::string &key)
{
    this->map_mutex.lock();
    T &value = this->map[key];
    this->map_mutex.unlock();
    return value;
}

template<class T> size_t Thread_map<T>::size() const
{
    size_t size;
    this->map_mutex.lock();
    size = this->map.size();
    this->map_mutex.unlock();
    return size;
}

template<class T> bool Thread_map<T>::empty() const
{
    bool empty; 
    this->map_mutex.lock();
    empty = this->map.empty();
    this->map_mutex.unlock();
    return empty;
}

template<class T> void Thread_map<T>::clear()
{
    this->map_mutex.lock();
    this->map.clear();
    this->map_mutex.unlock();
}

template<class T> void Thread_map<T>::insert(std::pair<std::string, T> pair)
{
    this->map_mutex.lock();
    this->map.insert(pair);
    this->map_mutex.unlock();
}

template<class T> T& Thread_map<T>::erase(const std::string &key)
{
    T *value;
    this->map_mutex.lock();
    value = this->map.erase(key);
    this->map_mutex.unlock();
    return value;
}

template<class T> bool Thread_map<T>::for_each(std::function<bool 
(Thread_map, std::string&, T&)> fun)
{

}


#endif

我将实现放入头文件中，因为听说您使用模板类进行了此操作。我说的对吗？我的问题是，当我尝试致电接线员时

Thread_map<std::string> map;
map["mkey"] = "value";

g ++在map [“ mkey”]上引发无效的初始化错误。据我所知，问题是mkey被编译为std::string("mkey")，这仅仅是值，而不是引用。但是，以下原因为何或如何起作用？

std::map<std::string, std::string> map;
map["mkey"] = "value";

我的意思是我可以按值传递字符串，但这似乎效率不高。

Answer 1

引用需要一个可以修改的变量地址。对于左值字符串（“某些字符串”），没有可以修改值的地址。我知道有一些方法可以解决此问题：

删除参考（不推荐）

一种方法是从参数中删除“＆”。像这样：

T& operator[](std::string key);

这样，您不需要的是左值，而是右值。问题是，无论何时发送一个值，都不会发送4个字节的内存地址，而是发送sizeof（“ Your string”）个字节。繁重的方法。

设为常量左值（推荐方式）

解决此问题的最漂亮方法是使参数const lvalue（即所谓的rvalue reference），向编译器保证不会在内部更改给定地址的值此功能。看起来像这样：

T& operator[](const std::string &key);

现在您可以发送左值字符串和右值字符串。

放弃

这种方式不如第一种好，但绝对不如第二种好。您可以轻松使用声明：

T& operator[](std::string &key);

当您传递值时，请使用另一个字符串变量来存储该值，并在调用时使用此变量：

Thread_map<std::string> map;
string key = "mkey";
map[key] = "value";

（不要那样做。只是作为知识的延伸）。

C ++用std :: string覆盖[]运算符

1 个答案:

删除参考（不推荐）

设为常量左值（推荐方式）

放弃