Question

我有一些类似于此SSCCE的代码：

#include <map>
#include <string>
#include <functional>

using std::map;
using std::string;
using std::function;
using std::forward;

template<typename ToType, typename... FromTypes>
ToType construct(FromTypes&&... fromTypes) {
  return ToType(forward<FromTypes>(fromTypes)...);
}

class Variant {
public:
  map<string, Variant> toMap() const;
};

map<string, Variant> Variant::toMap() const {
  return {
      {"test", {}},
      {"test1", {}},
    };
}

// #1
template <typename MapType>
MapType variantToMap(Variant const& v) {
  // I expect an error on the following line because it's referencing the function labeled #4 which has not been declared yet.
  return variantToMap<MapType>(v, construct<typename MapType::key_type, string>, construct<typename MapType::mapped_type, Variant>);
}

// #2
template <typename MapType>
MapType variantToMap(Variant const& v, function<typename MapType::key_type(string)> const& keyConvert) {
  // I expect an error on the following line because it's referencing the function labeled #4 which has not been declared yet.
  return variantToMap<MapType>(v, keyConvert, construct<typename MapType::mapped_type, Variant>);
}

// #3
template <typename MapType>
MapType variantToMap(Variant const& v, function<typename MapType::mapped_type(Variant)> const& valueConvert) {
  // I expect an error on the following line because it's referencing the function labeled #4 which has not been declared yet.
  return variantToMap<MapType>(v, construct<typename MapType::key_type, string>, valueConvert);
}

// #4
template <typename MapType>
MapType variantToMap(Variant const& v, function<typename MapType::key_type(string)> const& keyConvert, function<typename MapType::mapped_type(Variant)> const& valueConvert) {
  MapType res;
  for (auto pair : v.toMap()) {
    res[keyConvert(pair.first)] = valueConvert(pair.second);
  }

  return res;
}

int main() {
  Variant a;

  // #1
  variantToMap<map<string, Variant>>(a);

  // #2
  {
    int counter = 0;
    variantToMap<map<int, Variant>>(a, [&counter](string) -> int { return ++counter; });
  }

  // #3
  variantToMap<map<string, int>>(a, [](Variant) -> int { return 42; });

  // #4
  {
    int counter = 0;
    variantToMap<map<int, int>>(a, [&counter](string) -> int { return ++counter; }, [](Variant) -> int { return 42; });
  }

  return 0;
}

编译并正常工作。

但是，因为它被宣布无序，我希望这会抛出错误。我认为它之所以没有与这些函数都是模板化的事实有关。但是，这对我来说仍然有点混乱，因为（例如）variantToMap＃1中对variantToMap＃4的调用有3个参数，这意味着

Clang和GCC是否不恰当地接受这些功能，还是允许这样做？如果允许的话，它的基本原理是什么？

应该注意的是，我已经重新安排了这些功能，我只是好奇它为什么会起作用。

Answer 1

C ++使用two phase name lookup来解析模板定义中找到的标识符。（除非你有MSVC，它只使用第二阶段）。

声明/定义模板时，将解析所有不依赖于模板参数的名称。实例化时，将解析依赖于模板参数的名称。这次，在实例化时可见的名称参与，并且可以在查找期间找到。

在您的情况下，内部variantToMap调用依赖于模板参数，因此在调用外部函数之前不会解析它们。此时，所有4个变体都可见，并且可以找到。

重载模板函数声明顺序

1 个答案: