使用std :: string key [duplicate]避免std :: map / std :: unordered_map查找中的临时值

Question

这个问题在这里已有答案：

• 避免std :: map :: find（） 4个答案的 关键构造

请考虑以下代码：

std::map<std::string, int> m1;
auto i = m1.find("foo");

const char* key = ...
auto j = m1.find(key);

这将为每个地图查找创建一个临时的std :: string对象。 避免它的规范方法是什么？

Answer 1

不要使用指针; 相反，直接传递字符串。 然后你可以利用参考资料：

void do_something(std::string const & key)
{
    auto it = m.find(key);
    // ....
}

C ++通常变得“更正确”，你使用它的习语越多，不要尝试用它来编写C语言。

Answer 2

您可以通过为std::map一个自定义比较器类来避免临时性，该类可以比较char * s。 （默认情况下将使用指针的地址，这不是您想要的。您需要比较字符串的值。）

因此，像：

class StrCmp
{
public:
  bool operator () (const char *a, const char *b)
  {
    return strcmp(a, b) < 0;
  }
};

// Later:
std::map<const char *, int, StrCmp> m;

然后，像普通地图一样使用，但传递char *。 请记住，您在地图中存储的任何内容都必须在地图期间保持活动状态 。 这意味着你需要char文字，或者你必须保持指针所指向的数据。 出于这些原因，我会使用std::map<std::string>并吃掉临时表，直到分析显示上面的内容确实需要。

Answer 3

无法避免复制字符数据的临时std::string实例。 请注意，如果标准库实现使用短字符串优化，则此成本非常低并且不会产生动态内存分配。

但是，如果您需要频繁代理C风格的字符串，您仍然可以提出绕过此分配的自定义解决方案。 如果你真的经常这样做，你的字符串是不够受益冗长从短串优化这可以还清。

如果您只需要一个非常小的字符串功能子集（例如只有赋值和副本），那么您可以编写一个小的专用字符串类，它存储一个const char *指针和一个释放内存的函数。

 class cheap_string
 {
 public:
     typedef void(*Free)(const char*);
 private:
     const char * myData;
     std::size_t mySize;
     Free myFree;
 public:
     // direct member assignments, use with care.
     cheap_string ( const char * data, std::size_t size, Free free );

     // releases using custom deleter (a no-op for proxies).
     ~cheap_string ();

     // create real copies (safety first).
     cheap_string ( const cheap_string& ); 
     cheap_string& operator= ( const cheap_string& ); 
     cheap_string ( const char * data );
     cheap_string ( const char * data, std::size_t size )
         : myData(new char[size+1]), mySize(size), myFree(&destroy)
     {
         strcpy(myData, data);
         myData[mySize] = '\0';
     }

     const char * data () const;
     const std::size_t size () const;

     // whatever string functionality you need.
     bool operator< ( const cheap_string& ) const;
     bool operator== ( const cheap_string& ) const;

     // create proxies for existing character buffers.
     static const cheap_string proxy ( const char * data )
     {
          return cheap_string(data, strlen(data), &abandon);
     }

     static const cheap_string proxy ( const char * data, std::size_t size )
     {
          return cheap_string(data, size, &abandon);
     }

 private:
     // deleter for proxies (no-op)
     static void abandon ( const char * data )
     {
         // no-op, this is used for proxies, which don't own the data!
     }

     // deleter for copies (delete[]).
     static void destroy ( const char * data )
     {
         delete [] data;
     }
 };

然后，您可以将此类用作：

 std::map<cheap_string, int> m1;
 auto i = m1.find(cheap_string::proxy("foo"));

临时的cheap_string实例不像std::string那样创建字符缓冲区的副本，但它保留了用于在标准容器中存储cheap_string实例的安全复制语义。

注意 ：如果您的实现不使用返回值优化，您将需要找到proxy方法的替代语法，例如具有特殊重载的构造函数（对于placement new采用自定义proxy_t类型proxy_t std::nothrow proxy_t ） 。

Answer 4

好吧，map的find实际上接受了对键的常量引用，因此您无法避免在某个时刻创建它。

对于代码的第一部分，您可以使用值为“foo”的常量静态std :: string进行查找。 这样你就不会创建副本了。

如果你想要Spartan的方式，你总是可以创建自己的类型，可以像字符串一样使用，但也可以保存指向字符串文字的指针。

但无论如何，与地图查找相关的开销是如此之大，所以这并没有多大意义。 如果我是你，我首先用谷歌的密集哈希替换map / unordered_map。 然后我将运行英特尔的VTune（这些天放大器），看看时间在哪里并优化这些地方。 我怀疑字符串，因为键会出现在瓶颈十大列表中。

Answer 5

看看llvm中的StringRef类。

它们可以从c-strings，string literals或std :: string构建得非常便宜。 如果你制作了这些的地图，而不是std :: string，那么构造速度会非常快。

但这是一个非常脆弱的系统。 您需要确保无论您插入的字符串的来源是什么，都会在地图的生命周期内保持活动状态并且不会被修改。