Continuing my saga ，我意识到我可以使用单个 std::initializer_list 参数来重载我的访问函数:

class array_md
{
    //...
    my_type &        operator []( size_type i )
    { /* Lots of code */ }
    my_type const &  operator []( size_type i ) const
    { /* same Lots of code, with "const" sprinkled in */ }
    my_type &        operator []( std::initializer_list<size_type> i )
    { /* Lots of different code */ }
    my_type const &  operator []( std::initializer_list<size_type> i ) const
    { /* same Lots of different code, with "const" sprinkled in */ }
    //...
};

对于我的 at 版本，我现在有:

class array_md
{
    //...
    template < typename ...Index >
    complicated &        at( Index &&...i )  // (1)
    { /* Lots of code */ }
    template < typename ...Index >
    complicated const &  at( Index &&...i ) const  // (2)
    { /* same Lots of code, with "const" sprinkled in */ }
    my_type &            at( std::initializer_list<size_type> i )  // (3)
    { /* Lots of different code */ }
    my_type const &      at( std::initializer_list<size_type> i ) const  // (4)
    { /* same Lots of different code, with "const" sprinkled in */ }
    //...
};

(由于我无法根据初始化列表中的条目数量更改类型，因为它是运行时的，所以我修复了返回类型并在条目数量错误时抛出。) new overloads 很长，我必须为 mutable 和 const 版本重复它，所以我想知道如何保存代码。我试图搞乱 const_cast:

class array_md
{
    //...
    my_type &        operator []( size_type i );
    my_type const &  operator []( size_type i ) const;
    my_type &        operator []( std::initializer_list<size_type> i )
    {
        return const_cast<my_type &>( const_cast<array_md const
         *>(this)->operator [](i) );
    }
    my_type const &  operator []( std::initializer_list<size_type> i ) const;
    //...
};

此处第三个版本调用第四个版本，使用 const_cast 来绕过编译器投诉。 (侵入是可以的，因为我正在剥离 const 我一开始就打它的东西。不要颠倒依赖关系；你最终可能会调用一个 mutable 成员在真正的 const 对象上运行!)我尝试对 at 做同样的事情，用标记 (4) 的重载实现标记 (3) 的重载。但是，因为 at 有三个替代项，所以我得到了与 (2) getting selected instead 相关的错误!与通用重载相比，我将 std::initializer_list 传递给内部 at 调用(按值)是否存在某些问题不会导致完全匹配？我是 old friends与通用方法冲突。

TL;DR:示例代码显示 std::initializer_list 对象在函数参数列表中被取值。这是编译器传递它们的首选吗？还是通过引用代替？如果您需要精确匹配(以克服通用过载)，这一点很重要。

最佳答案

消歧类型转换:

int     f( int );
double  f( double );

template < typename Func, typename ...Args >
void  do_it( Func &&f, Args &&...a );

//...

int  main( int, char *[] )
{
    do_it( (double(*)(double))&f, 5.4 );
    return 0;
}

main 中的代码被迫使用 f 的第二个版本。我认为此功能是 C-cast 所独有的，但它在 static_cast 下。所以我得到了类似的东西:

class array_md
{
    //...
    template < typename ...Index >
    complicated &        at( Index &&...i );  // (1)

    template < typename ...Index >
    complicated const &  at( Index &&...i ) const;  // (2)

    my_type &            at( std::initializer_list<size_type> i )  // (3)
    {
        return const_cast<my_type &>(
          (
            const_cast<array_md const *>( this )
            ->*
            static_cast<
              my_type const &
              (array_md::*)
              ( std::initializer_list<size_type> ) const
            >( &array_md::at )
          )( i )
        );
    }

    my_type const &      at( std::initializer_list<size_type> i ) const;  // (4)
    //...
};

(我的灵感来自于回答别人关于需要区分函数模板重载的帖子。)尝试了几次，尤其是在不必创建中间对象的情况下。

关于c++ - 编译器如何传递 `std::initializer_list` 值？ (或 : how can I get around a universal overload with one? )，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16272630/