C ++函数重载和initializer_list构造函数

Question

Here i have some code:

#include <string>
#include <iostream>
#include <initializer_list>

template <typename T>
class Test
{
public:
  Test(std::initializer_list<T> l)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
  Test(const Test<T>& copy)
  {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
  Test() = delete;
  Test(Test&&) = delete;
};

void f(const Test<Test<std::string>>& x)
{
  std::cout << __PRETTY_FUNCTION__ << std::endl;
}

void f(const Test<std::string>& x)
{
  std::cout << __PRETTY_FUNCTION__ << std::endl;
  f({x});
}

int main()
{
  Test<std::string> t1 {"lol"};
  f(t1);
  return 0;
}

The problem here is that i wanted to call overload void f(const Test<Test<std::string>>& x) here:

f({x});

I know that if i call it like this:

f(Test<Test<std::string>>{x});

It will get the job done.
I just not quite understand what's happening in terms of compilation in the first case.
I thought that line f({x}) should:

1. Create temporary object Test<std::string> .
2. Bind const reference argument to that object.
3. Recursion continues and go to step 1.

Instead it just passes the same initial object over and over and none temporaries are created. It's like just x is the same as {x} . Why compiler behave like that?

My OS:

Linux Mint 19 Tara

Compiler:

gcc 7.3.0

Compilation command:

g++ -std=c++11 -O0 test.cpp -o test -Wall -pedantic

Answer 1

I thought that line f({x}) should:
- Create temporary object Test

Your wrong,

{x} build a const Test<std::string>& from x (identity).

As the 2 candidates are:

• void f(const Test<Test<std::string>>&) #1
• void f(const Test<std::string>&) #2

overload_resolution are complicated, but currently, #2 is a better match (exact match).

#1