Question

我需要有人一行一行地向我解释这段代码。我特别不理解这一行：

operator std::map<T, U>()

非常感谢。

template <typename T, typename U>
class create_map 
{ 
    std::map<T, U> m_map;
public:
    create_map(const T& key, const U& val) 
    {  
        m_map[key] = val;
    }
    create_map<T, U>& operator()(const T& key, const U& val) 
    {
        m_map[key] = val;
        return *this;
    }
    operator std::map<T, U>()     
    {
        return m_map;     
    }
};

Answer 1

operator std::map<T, U>()     
{
         return m_map;     
}

这是用户定义的转换功能。

这意味着，你可以这样写：

//obj is an object of type create_map
create_map<int,std::string> obj(1,"Nawaz");

//obj implicitly converts into std::map type!
std::map<int,std::string> map_inst=obj;

请参阅此主题以了解有关用户定义转换功能的更多信息：

User Defined Conversions in C++

你也可以看到这一点：Implicit conversion sequences (C++ only)

create_map<T, U>& operator()(const T& key, const U& val) 
{
      m_map[key] = val;
      return *this;
}

这实际上会重载operator()，它会在内部插入或更新（key，val）对m_map;只看函数定义它的作用。

所以使用这个函数你可以写这样的代码，

obj(2,"Sarfaraz"); //this inserts the pair into the underlying m_map;

我还建议您多探索一下std::map，尤其是operator[]中的重载std::map。

Answer 2

代码：

template <typename T, typename U>
class create_map 
{ 
    std::map<T, U> m_map;
public:
    create_map(const T& key, const U& val) 
    {  
        m_map[key] = val;
    }
    create_map<T, U>& operator()(const T& key, const U& val) 
    {
        m_map[key] = val;
        return *this;
    }
    operator std::map<T, U>()     
    {
        return m_map;     
    }
};

此代码的目的是能够通过将调用链接到operator()来指定具有特定键/值对的地图，例如

create_map<int, std::string>( 1, "blah" )( 2, "hah" )( 3, "doh" )

由于该类没有默认构造函数，因此无法使用它来创建空映射。这可能是设计上的。或者它可能是设计错误。

在

operator std::map<T, U>()     
{
    return m_map;     
}

定义了转化为std::map<T, U>，这是最终结果。

可以在指定create_map并且需要std::map的任何地方隐式调用它，例如在函数调用中使用create_map表达式作为参数。

然而，由于复制地图，效率可能非常低。编译器可以很好地优化复制。但不必要地依赖于实施质量（尽管有时候这是最好的）。

所以它应该是

operator std::map<T, U> const& () const
{
    return m_map;     
}

最后const允许将create_map声明为const并使用。

通过这种转换引用，存在与使用引用参数相同的问题，即存在别名的理论可能性，其中保留对const的引用的代码不准备处理引用对象的更改。但在实践中，这不是问题。例如，作为正式参数，当然只写std::string const& s（而不仅仅是std::string s），如果由此产生任何错误则很少 - 我从未遇到任何问题。

干杯＆amp;第h。，

Answer 3

关于它的理解不多。 operator std::map<T, U>()会覆盖类的转换运算符（不带参数）以提供类型为std::map<T, U>的对象实例。 std::map是用于关联键 - >值存储的STL标准类。在您的情况下，它会从T类型的键映射到类型U的值。到目前为止，T和U尚未定义（您编写了template class，但模板参数在哪里？）

转换运算符允许使用类实例代替运算符提供转换的类型，如下所示。

class foo {
    operator char const *() {
        return "foo instance as char const *";
    }
};

// ...

void bar(foo &f)
{
    // here the class instance is used as if it were a char const *
    cout << f << endl;
}

Answer 4

该行

operator std::map<T, U>()

定义了一个函数，当你的create_map对象被用作代码中某处的std :: map时，将调用该函数。

一个更简单的例子是：

class A
{
public:
  operator int()
  {
    return 3;
  }
};

int main()
{
  A a;
  cout << a << endl;
}

现在计算机发现它不知道如何打印变量a，但它知道如何将其转换为int然后打印它。所以“3”被打印出来。

我需要有人向我解释这些代码行

4 个答案: