почему этот код компилируется, когда нет очевидного соответствия конструктора?

Пожалуйста, рассмотрите следующий код:

class Foo {
public:
explicit Foo(double) {}
};

Foo * test();
Foo * test() {
return new Foo(Foo(1.0));   // (1)
}

Мой вопрос касается строки (1). Это очень похоже на ошибку, которая заняла у меня некоторое время, чтобы выследить. Я не заметил, что тип был указан дважды из-за ошибки копирования / вставки. Правильная строка очевидно:

  return new Foo(1.0);

Интересно, что это изменение также компилируется без предупреждения:

  return new Foo(Foo(Foo(Foo(1.0))));

Почему эти примеры компилируются без предупреждений с помощью clang, даже если -Wall -Weverything флаги? Почему Foo::Foo(double) принять экземпляр Foo в качестве действительного double аргумент? Это какое-то своеобразное поведение оператора нового?

Мой оригинальный код был в более широком контексте и протестирован с двумя компиляторами на основе LLVM-3. Оба скомпилированы без предупреждений или ошибок. С одним, код фактически функционировал, как я ожидал, и на самом деле я не осознавал, что в течение некоторого времени была ошибка. С другой стороны, экземпляр Foo вел себя очень странно — я не могу описать его должным образом — это было так, как если бы более поздняя копия возвращенного указателя «волшебным образом» стала отличаться от оригинала, что привело к несовпадению состояний между двумя взаимодействующими объекты, которые должны были содержать эквивалентные указатели на общий Foo, но по какой-то причине содержали разные значения после присваивания. Пока я не понимаю, что здесь происходит, это кажется действительно странным!

Интересно, что следующие компиляторы с обоими компиляторами:

class Foo { public: explicit Foo(double) {} };
class Bar { public: explicit Bar(double) {} };

Foo * testFoo() { return new Foo(Foo(1.0)); }
Bar * testBar() { return new Bar(Bar(1.0)); }

Но следующая версия не делает:

Foo * testFooBar() { return new Foo(Bar(1.0)); }