Sfinae超负荷在不同尺寸的元素上

Question

考虑一个包含两种类型的结构 - firstObjects和secondObjects，它们都是std :: tuple＆lt;＆gt;＆gt;，例如，例如

struct Objects
{
    using FirstObjects = std::tuple<int, int>;
    using SecondObjects = std::tuple<int>;
}; 

：我们添加以下枚举：

enum class ObjectCategory
{
    FIRST,
    SECOND
};

现在考虑上述类型上的以下类，如上所述（唯一的合同是它具有firstObjects和> SecondObjects，并且它们为std :: tuple）：

template <typename T>
class SomeClass
{
public:
    using FirstObjects = typename T::FirstObjects;
    using SecondObjects = typename T::SecondObjects;
    
    template <std::size_t Idx>
    using FirstObject = typename std::tuple_element<Idx, FirstObjects>::type;
    template <std::size_t Idx>
    using SecondObject = typename std::tuple_element<Idx, SecondObjects>::type;        
    
    template <ObjectCategory Category, std::size_t Idx>
    using ObjectType = std::conditional_t<Category == ObjectCategory::FIRST, FirstObject<Idx>, SecondObject<Idx>>;
    
    template <ObjectCategory Category, std::size_t Idx>
    std::enable_if_t<Category == ObjectCategory::FIRST, const ObjectType<Category, Idx>>& getObject()
    {
        return std::get<Idx>(firstObjects_);
    }

    template <ObjectCategory Category, std::size_t Idx>
    std::enable_if_t<Category == ObjectCategory::SECOND, const ObjectType<Category, Idx>>& getObject()
    {
        return std::get<Idx>(secondObjects_);
    }    
    
    template <ObjectCategory Category, std::size_t Idx>
    void doSomething()
    {
        const ObjectType<Category, Idx>& obj = getObject<Category, Idx>();
    }
    
private:
    FirstObjects firstObjects_;
    SecondObjects secondObjects_;
};

简而> t :: firstObjects 和secondObjects _ type t :: secondObjects，并且具有dosomething（）函数根据Objectcategory选择，返回i-th对象的sfinae-overpraded getObject（） getter方法。

我现在遇到的问题是：

int main()
{
    struct Objects
    {
        using FirstObjects = std::tuple<int, int>;
        using SecondObjects = std::tuple<int>;
    };    
    SomeClass<Objects> object{};
    object.doSomething<ObjectCategory::FIRST, 0>(); // <------ works fine
    object.doSomething<ObjectCategory::FIRST, 1>(); // <------ compiler error
}

最后一行使编译器抱怨：

/usr/include/c++/4.9/tuple: In instantiation of 'struct std::tuple_element<1ul, std::tuple<int> >':
70:114:   required by substitution of 'template<class T> template<ObjectCategory Category, long unsigned int Idx> using ObjectType = std::conditional_t<(Category == FIRST), typename std::tuple_element<Idx, typename T::FirstObjects>::type, typename std::tuple_element<Idx, typename T::SecondObjects>::type> [with ObjectCategory Category = (ObjectCategory)0; long unsigned int Idx = 1ul; T = main()::Objects]'
87:42:   required from 'void SomeClass<T>::doSomething() [with ObjectCategory Category = (ObjectCategory)0; long unsigned int Idx = 1ul; T = main()::Objects]'
104:50:   required from here
/usr/include/c++/4.9/tuple:682:12: error: invalid use of incomplete type 'struct std::tuple_element<0ul, std::tuple<> >'
     struct tuple_element<__i, tuple<_Head, _Tail...> >
            ^
In file included from /usr/include/c++/4.9/tuple:38:0,
                 from 4:
/usr/include/c++/4.9/utility:85:11: error: declaration of 'struct std::tuple_element<0ul, std::tuple<> >'
     class tuple_element;
           ^
 In substitution of 'template<class T> template<ObjectCategory Category, long unsigned int Idx> using ObjectType = std::conditional_t<(Category == FIRST), typename std::tuple_element<Idx, typename T::FirstObjects>::type, typename std::tuple_element<Idx, typename T::SecondObjects>::type> [with ObjectCategory Category = (ObjectCategory)0; long unsigned int Idx = 1ul; T = main()::Objects]':
87:42:   required from 'void SomeClass<T>::doSomething() [with ObjectCategory Category = (ObjectCategory)0; long unsigned int Idx = 1ul; T = main()::Objects]'
104:50:   required from here
70:114: error: no type named 'type' in 'struct std::tuple_element<1ul, std::tuple<int> >'

似乎不喜欢secondObjects只有一个元素，因此std :: get＆lt; 1＆gt;（ secondObjects _）不起作用？但是，为什么这甚至是首先发生的，因为我在dosomething on objectCategory :: first而不是objectcategory :: second？

如何解决？

------编辑1 ------

解决方案@taekahn指出的是要更改getObject（）方法如下：

    template <ObjectCategory Category, std::size_t Idx>
    const auto& getObject()
    {
        return std::get<Idx>(firstObjects_);
    }

    template <ObjectCategory Category, std::size_t Idx, typename = std::enable_if_t<Category == ObjectCategory::SECOND>>
    const auto& getObject()
    {
        return std::get<Idx>(secondObjects_);
    }

似乎有效，因为编译器未评估编译器/在使用关键字auto 而不是显式类型时，检查已删除的方法的返回类型的有效性。 但这只是猜想 - 真的很喜欢一个知识渊博的C ++从业者来体重！

------编辑2 ----------------------------------------------------------------------------------------------》

迄今为止尝试进行

    object.doSomething<ObjectCategory::SECOND, 0>();

战争时，是将第一个Getter函数修改为

    template <ObjectCategory Category, std::size_t Idx, typename = std::enable_if_t<Category == ObjectCategory::FIRST>, bool = 0 /* dummy param */>
    auto& getObject()
    {
        return std::get<Idx>(firstObjects_);
    }

添加Sfinae以及虚拟模板最后，ARG允许超载。