Question

我有以下两个功能：

Thing* find_thing_by_name(const String & name, Map<String,Thing*> & thing_map)
{
    auto it = thing_map.find(name);
    return it->second;
}
const Thing* find_thing_by_name(const String & name, const Map<String,Thing*> & thing_map)
{
    auto it = thing_map.find(name);
    return it->second;
}

这只是我想要解决的问题的一个简单示例。

函数具有完全相同的主体，但我需要处理我的地图的const和非const版本。我已经看到使用const转换使用成员函数处理此问题，但这些是非成员函数，我想使用模板解决此问题。如何编写一个减少代码重复的模板化函数？我甚至不确定从哪里开始。

Answer 1

你可以：

template <typename MAP>
auto find_thing_by_name(const String & name, MAP & thing_map)
{
    auto it = thing_map.find(name);
    return it->second;
}

然后

String s = ...;
Map<String,Thing*> nonconst_m = ...;
const Map<String,Thing*> const_m = ...;
find_thing_by_name(s, nonconst_m); // MAP is deduced as Map<String,Thing*>
                                   // thing_map's type is Map<String,Thing*>&
find_thing_by_name(s, const_m);    // MAP is deduced as const Map<String,Thing*>
                                   // thing_map's type is const Map<String,Thing*>&

Answer 2

我认为你推翻了这个问题。两个参数变量的方法中的相同代码（通过const引用和非const引用传递）意味着您的代码不会在方法中修改此参数（仅调用其上的const方法）。否则相同的代码不会编译为const引用。这意味着您应该只实现此方法的一个版本，因为您始终可以使用const Map＆amp; thing_map形式参数在方法中传递非const thing_map实际参数。在你的实际例子中也没有必要在第二个例子中返回const Thing *，因为它 - ＆gt;第二个仍然是Thing *而不是const Thing *。所以这是我的sujestion：

Thing* find_thing_by_name(const String & name, const Map<String,Thing*> & thing_map)
{
    auto it = thing_map.find(name);
    return it->second;
}

或者如果您想限制对Thing对象的访问，请仅实现此版本：

const Thing* find_thing_by_name(const String & name, const Map<String,Thing*> & thing_map)
{
    auto it = thing_map.find(name);
    return it->second;
}

那么你可以用这种方式使用任何一种变体：

...
const Map<String, Thing *> constMapObj;
const Map<String, Thing *> nonConstMapObj;
....
auto res1 = find_thing_by_name(someKey, constMapObj);
auto res2 = find_thing_by_name(someOtherKey, nonConstMapObj);

使用模板减少const和非const非成员函数的代码重复

2 个答案: