Qt中的赋值运算符没有重载是怎么实现初始化的？

[newboy686]

今天，在写代码的时候，参考了一些Qt自带的例程，发现了好几处某个类的实例在用赋值运算符（=）进行初始化，可是查看帮助没有发现有对应类型的重载函数，例如：QBrush的初始化函数包括以下的构造函数和赋值运算符重载函数。

QBrush();
QBrush(Qt::BrushStyle style);
QBrush(const QColor & color, Qt::BrushStyle style = Qt::SolidPattern);
QBrush(Qt::GlobalColor color, Qt::BrushStyle style = Qt::SolidPattern);
QBrush(const QColor & color, const QPixmap & pixmap);
QBrush(Qt::GlobalColor color, const QPixmap & pixmap);
QBrush(const QPixmap & pixmap);
QBrush(const QImage & image);
QBrush(const QBrush & other);
QBrush(const QGradient & gradient);
QBrush & operator=(const QBrush & brush);
QBrush & operator=(QBrush && other);

但是，在Qt自带的例程中可以看到下面的用法，是我自己简化出来的，但是可以编译、运行。

QBrush brush = Qt::blue;
qDebug() << brush;

经过调试，输出结果为：
QBrush(QColor(ARGB 1, 0, 0, 1) , SolidPattern )

请问：这是怎么一个初始化原理呢？

[Italink]

这跟QT无关吧，C++类支持这个操作

#include<iostream>
using namespace std;
class MyClass
{
public:
	MyClass(int i)  { 
		data = i; 
	}
	//MyClass(int i) :data(i) {}
private:
	int data;
};
int main() {
	MyClass my = 1;	
	return 0;
}

[真相重于对错]

class A{ public: A(S s); }; S s1 A a1=s1 //这里不是赋值，而是初始化，是构造。 如果要调用赋值 A a1=.... ...... a1=s//所谓的赋值是在要修改原对象时候才会调用。

[newboy686]

谢谢楼上各位了，#3讲的太详细了，意思明白了，但是原理不太懂

[sdghchj]

变量声明后面用的=表示隐式调用拷贝构造函数进行初始化，但会被编译器省略。

#include<iostream>
using namespace std;
class A{
public:
    A(int a){
        cout<<"A(int a)"<<endl;
    }
    A(const A&){
        cout<<"A(const A&)"<<endl;
    }
private:
    A& operator=(const A&){
    }
};

int main()
{
    A a(1); //直接显示调用A(int)
    A b(A(1)); //先显示调用A(int)，再显式调用A(const A&)，编译器优化省略掉A(const A&)的调用，最后只调用A(int)
    A c = A(1); //先显示调用A(int)，再隐式调用A(const A&)，编译器优化省略掉A(const A&)的调用，最后只调用A(int)
    A d = 1; //先隐示调用A(int)，再隐式调用A(const A&)，编译器优化省略掉A(const A&)的调用，最后只调用A(int)
    return 0;
}

#include<iostream>
using namespace std;
class A{
public:
    explicit A(int a){ //必须显示调用
        cout<<"A(int a)"<<endl;
    }
    A(const A&){
        cout<<"A(const A&)"<<endl;
    }
private:
    A& operator=(const A&){
    }
};

int main()
{
    A a(1); //直接显示调用A(int)
    A b(A(1)); //先显示调用A(int)，再显式调用A(const A&)，编译器优化省略掉A(const A&)的调用，最后只调用A(int)
    A c = A(1); //先显示调用A(int)，再隐式调用A(const A&)，编译器优化省略掉A(const A&)的调用，最后只调用A(int)
    A d = 1; //1个错误
    return 0;
}

#include<iostream>
using namespace std;
class A{
public:
    A(int a){ 
        cout<<"A(int a)"<<endl;
    }
    explicit A(const A&){ //必须显示调用
        cout<<"A(const A&)"<<endl;
    }
private:
    A& operator=(const A&){
    }
};

int main()
{
    A a(1); //直接显示调用A(int)
    A b(A(1)); //先显示调用A(int)，再显式调用A(const A&)，编译器优化省略掉A(const A&)的调用，最后只调用A(int)
    A c = A(1); //1个错误
    A d = 1; //1个错误
    return 0;
}

#include<iostream>
using namespace std;
class A{
public:
    explicit A(int a){ //必须显示调用
        cout<<"A(int a)"<<endl;
    }
    explicit A(const A&){ //必须显示调用
        cout<<"A(const A&)"<<endl;
    }
private:
    A& operator=(const A&){
    }
};

int main()
{
    A a(1); //直接显示调用A(int)
    A b(A(1)); //先显示调用A(int)，再显式调用A(const A&)，编译器优化省略掉A(const A&)的调用，最后只调用A(int)
    A c = A(1); //1个错误
    A d = 1; //2个错误
    return 0;
}