Basically the std::initializer_list constructor takes precedence over the copy constructor in class A (as it should by the standard)

I think this is where you are not sure whether this is the expected behavior, right?

I don't know what behaviour to expect, frankly. As the behaviour is different for the stack variable case with different compilers it looks like the compiler writers weren't sure either, unless there are compiler-dependent conditionals in the QVariant code.

I have tested this on 6.7.2 with VC2019 and MinGW, with the same results: {} initialising a stack allocated QList<QVariant> behaves differently to {} initialising a QList<QVariant> member variable of a stack allocated class instance.

My only claim here is that this is tricky :-)

I got intrigued and made some tests.

This is my output on Windows where I print the function calls from qlist.h.
(only have an older Qt / system at hand right now)

Windows 10, 5.15.2, MSVC2019

QList<class QVariant>::QList called
QList<class QVariant>::QList(InputIterator) called
QList<class QVariant>::QList(initializer_list) called
QList<class QVariant>::QList called
QList<class QVariant>::QList(InputIterator) called
QList<class QVariant>::QList(initializer_list) called
A results are length 1
\ -  QVariant(QVariantList, (QVariant(int, 1), QVariant(int, 2), QVariant(QString, "3")))
\ -  QVariant(int, 1)
\ -  QVariant(int, 2)
\ -  QVariant(QString, "3")
(QVariant(int, 1), QVariant(int, 2), QVariant(QString, "3"))
B results are length 3
\ -  QVariant(int, 1)
\ -  QVariant(int, 2)
\ -  QVariant(QString, "3")
Stack C results are length 3
\ -  QVariant(int, 1)
\ -  QVariant(int, 2)
\ -  QVariant(QString, "3")

I assume the problem, if any, has to do with either the QDebug output (don't trust how it interprets data) or some QVariant voodoo, as it does not happen for STL containers.

Made an online test. No issues

Edit:

Maybe this sequence of output

QList<class QVariant>::QList called
QList<class QVariant>::QList(InputIterator) called
QList<class QVariant>::QList(initializer_list) called

indicates that it encapsulates the QVariantList somehow and creates an "inner" list inside another QVariantList using the initializer_list c'tor...

@KenAppleby-0 I think this is where you are not sure whether this is the expected behavior, right?

Why doesn't the same happen with the stack variable?

It does here (Linux, GCC 13, Qt 5.15.3 or 6.7.2):

chrisw@newton:/tmp/tt$ ./tt 
A results are length 1
\ -  QVariant(QVariantList, (QVariant(int, 1), QVariant(int, 2), QVariant(QString, "3")))
B results are length 3
\ -  QVariant(int, 1)
\ -  QVariant(int, 2)
\ -  QVariant(QString, "3")
Stack C results are length 1
\ -  QVariant(QVariantList, (QVariant(int, 1), QVariant(int, 2), QVariant(QString, "3")))

QList<QVariant> C{ x };

A results are length 1

• QVariant(QVariantList, QList(QVariant(int, 1), QVariant(int, 2), QVariant(QString, "3")))

Simple:
You use X to initialize A, which uses the whole list to initalize the results member which becomes a single element list of QList<QVariant> == QVariantList.

That's how I would explain this behavior.

@kshegunov made a good explanation here

As you say @Axel-Spoerl, case A produces a QList<QVariant>, as it should do, of course, with one element which is a QVariant<QList<QVariant>>.

This is fair enough, but tricky, I claim.

Constructing a QList<QVariant> on the stack using the same {} method produces a different result:

class A
{
public:
    A(QList<QVariant> resultsList)
      : results{ resultsList } // <<<<<<
    {
        qDebug() << "A results are length" << results.size();
        for (auto& r : results) qDebug() << "\\ - " << r;
    }
    QList<QVariant> results;
};

class B
{
public:
    B(QList<QVariant> resultsList)
      : results(resultsList) // <<<<<<
    {
        qDebug() << "B results are length" << results.size();
        for (auto& r : results) qDebug() << "\\ - " << r;
    }
    QList<QVariant> results;
};

int main(int , char *[])
{
    const QList<QVariant> x{ 1, 2, "3" };

    A a1{ x };
    B b1{ x };

    QList<QVariant> C{ x };

    qDebug() << "Stack C results are length" << C.size();
    for (auto& r : C) qDebug() << "\\ - " << r;
}

A results are length 1
- QVariant(QVariantList, QList(QVariant(int, 1), QVariant(int, 2), QVariant(QString, "3")))
B results are length 3
- QVariant(int, 1)
- QVariant(int, 2)
- QVariant(QString, "3")
Stack C results are length 3
- QVariant(int, 1)
- QVariant(int, 2)
- QVariant(QString, "3")