相关疑难解决方法(0)

我创建了一个模板如下

template<typename T>
void f(T const& t) { }

我希望这可以通过容器调用,也可以通过初始化列表调用.我认为这将是initializer_list<int>,如下调用.

f({1, 2, 3});

但GCC表现得好像不符合标准

m.cpp: In function 'int main()':
m.cpp:6:25: warning: deducing 'const T' as 'const std::initializer_list<int>'
m.cpp:4:6: warning:   in call to 'void f(const T&) [with T = std::initializer_list<int>]'
m.cpp:6:25: warning:   (you can disable this with -fno-deduce-init-list)

谁能解释我如何在没有警告的情况下完成这项工作？谢谢!

我正在尝试在可变参数模板函数中使用大括号括起来的初始化列表,但是编译器抱怨...我是在问太多还是我做错了什么？

这最好通过示例来说明:

struct Bracy
{
    Bracy(int i, int j)
    {
    }
};

struct Test
{

    void consumeOne(int i)
    {
    }

    void consumeOne(const Bracy & bracy)
    {
    }

    void consume()
    {
    }

    template<typename T, typename ...Values>
    void consume(const T & first, Values... rest)
    {
        consumeOne(first);
        consume(rest...);
    }

    template<typename ...Values>
    Test(Values... values)
    {
        consume(values...);
    }
};

void testVariadics()
{
    Test(7,{1,2}); //I'd like {1,2} to be passed to consumeOne(const Bracy & bracy)
}

GCC(4.7)说:

main.cpp:45:14: error: no matching function for call to ‘Test::Test(int, …

我有一个带有模板参数T的类模板Templ,而Templ类有一个类型为T的数据成员,称为obj.我编写了一个可变参数构造函数模板,它将参数转发给obj的构造函数:

template <class T>
class Templ
{
public:
     template <class... Args> explicit Templ (Args&&... args)
     : obj (std::forward<Args>(args)...)
     {
     }
private:
     T obj;
};

现在我意识到类型T可能是一个带有init-list构造函数的类,我希望它可以通过Templ访问.所以我检查了什么std::list::emplace,std::make_shared做了什么.它们具有像我一样的可变函数,但它们没有覆盖init-list的覆盖.由于某些原因.

所以第一个问题:为什么？我的意思是,如果我使用一个带有init-list ctor的类T,然后我用std::list<T>？为什么list ::\templates没有带初始化列表的版本？也许有一个很好的理由我应该这样做...所以我想知道.

此外,无论STL做什么 - 我应该提供一个init-list ctor作为好的设计吗？我的意思是,它就像可变的ctor,对吗？允许用户选择任何类型或种类的T,带TEMPL <>使用,并且直接调用为T.定义的任何构造函数即使它是一个构造函数采取一个init-列表.

是否有可能有一个泛型构造函数,它接受任何类型的初始化列表,即使它有嵌套列表？

假设您对接受其构造函数嵌套初始化列表的类具有以下部分模板特化:

模板类ClassA;

template <>
class ClassA<4> {

  typedef std::initializer_list<double> list_type;
  typedef std::initializer_list<list_type> llist_type;
  typedef std::initializer_list<llist_type> lllist_type;
  typedef std::initializer_list<lllist_type> initializer_type;

  size_t n_[4] = {0};
  double* data_;

public:

  ClassA(initializer_type l) {

    assert(l.size() > 0);
    assert(l.begin()->size() > 0);
    assert(l.begin()->begin()->size() > 0);
    assert(l.begin()->begin()->begin()->size() > 0);

    size_t m = n_[0] = l.size();
    size_t n = n_[1] = l.begin()->size();
    size_t o = n_[2] = l.begin()->begin()->size();
    n_[3] = l.begin()->begin()->begin()->size();

    data_ = new double[m*n*o*n_[3]];

    int i=0, j=0, k=0, p=0;
    for (const auto& u : l) {
      assert(u.size() …