将强制转换运算符重载到 std::map 的正确语法是什么？

Question

这是一道 C++03 题。

在下面的代码中，class Foo 是一个模板类，其中包含从 std::string 到 T 成员函数的映射。 class Bar 包含一个 Foo<Bar> 类型的成员变量。我想在class Foo 中实现一个 cast-to-map 运算符，以便它是“直通”的，并且可以像 contained 映射一样使用，没有明确的 getter，但是我无法确定强制转换运算符的正确语法。

#include <iostream>
#include <map>
#include <string>

#define FOO 1

template <typename T>
class Foo
{
public:
#if FOO
  operator
  std::map< std::string, void (T::*)( const std::string&,
                                      const std::string& ) >&()
  {
    return member_;
  }
#else
  Foo() : member_( 42 ) {}
  operator int&() { return member_; }
#endif

private:
#if FOO
  std::map< std::string, void (T::*)( const std::string&,
                                      const std::string& ) > member_;
#else
  int member_;
#endif
};

class Bar
{
public:
#if FOO
  void func()
  {
    fb_["a"] = &Bar::abc;
  }
#else
  void func()
  {
    std::cout << fb_ << std::endl;
  }
#endif

  void abc( const std::string& key, const std::string& val )
  {
    std::cout << key << ": " << val << std::endl;
  }

private:
  Foo<Bar> fb_;
};

int main( int argc, char* argv[] )
{
  Bar b;
  b.func();
  return 0;
}

编译错误很神秘；我不知道该怎么做：

>g++ --version
g++ (GCC) 4.8.3 20140911 (Red Hat 4.8.3-7)
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

>g++ -g main.cpp 
main.cpp: In member function 'void Bar::func()':
main.cpp:33:8: error: no match for 'operator[]' (operand types are 'Foo<Bar>' and 'const char [2]')
     fb_["a"] = &Bar::abc;

您可以看到我玩弄了一个转换为整数的运算符，它工作得很好，但它的语法对于我来说可能过于简单，无法推断为一个转换为映射的运算符。

有人可以帮忙看看正确的语法吗？

Answer 1

@BenVoight 引导我认识到这一点：operator[] 函数调用应用于“原始”对象，而不是“传递”对象。 IE。即使我在class Foo 中实现了一个类型转换为映射的运算符，我随后调用的operator[] 仍然适用于Foo 对象，而不是我的Foo 对象被类型转换的std::map .

这给了我一个想法，也许我需要重载operator[]，我这样做显然是成功的：

#include <iostream>
#include <map>
#include <string>

template <typename T>
class Foo
{
public:
  typedef void (T::*TFunc)( const std::string&, const std::string& );
  typedef std::map< std::string, TFunc > FooMap;
  operator FooMap&()
  {
    return member_;
  }

  TFunc& operator []( const std::string& str )
  {
    return member_[ str ];
  }

private:
  FooMap member_;
};

class Bar
{
public:
  void func()
  {
    fb_["a"] = &Bar::abc;
  }

  void callFunc( const std::string& str, const std::string arg1,
                 const std::string& arg2 )
  {
    (this->*fb_[ str ])( arg1, arg2 );
  }

  void abc( const std::string& key, const std::string& val )
  {
    std::cout << key << ": " << val << std::endl;
  }

private:
  Foo<Bar> fb_;
};

int main( int argc, char* argv[] )
{
  Bar b;
  b.func();
  b.callFunc( "a", "hello", "world" );
  return 0;
}

输出：

>g++ -g main.cpp 
>./a.out    
hello: world