Qt/C++ 构造函数与explicit
1、默认构造函数
默认构造函数是指所有参数都提供了默认值的构造函数,通常指无参的构造函数或提供默认值的构造函数。如类Test1和Test2的构造函数
class Test1 { public: Test1(){} // default constructor } ; 或 class Test2 { public: Test2(int i=1){} // default constructor } ;
如果你没有为你的类提供任何构造函数,那么编译器将自动为你生成一个默认的无参构造函数。一旦你为你的类定义了构造函数,哪怕只是一个,那么编译器将不再生成默认的构造函数。
2、何时需要为你的类提供默认构造函数
有很多情况,列举如下:
1. 当你使用静态分配的数组,而数组元素类型是某个类的对象时,就要调用默认的构造函数,比如下面的代码。
Object buffer[10]; // call default constructor
2. 当你使用动态分配的数组,而数组元素类型是某个类的对象时,就要调用默认的构造函数,比如下面的代码,如果Object没有默认的构造函数,是无法通过编译的,因为new操作符要调用Object类的无参构造函数类初始化每个数组元素。
Object* buffer = new Object[10];
3. 当你使用标准库的容器时,如果容器内的元素类型是某个类的对象时,那么这个类就需要默认的构造函数,原因同上。
vector<Object> buffer;
4. 一个类A以另外某个类B的对象为成员时,如果A提供了无参构造函数,而B未提供,那么A则无法使用自己的无参构造函数。下面的代码将导致编译错误。
class B { B(int i){} }; class A { A(){} B b; }; int main(void) { A a(); // error C2512: 'B' : no appropriate default constructor available getchar() ; return 0 ; }
再比如下面的代码,类A定义了拷贝构造函数,而没有提供默认的构造函数,B继承自A,所以B在初始化时要调用A的构造函数来初始化A,而A没有默认的构造函数,故产生编译错误。
class A { A(const A&){} }; class B : public A { }; int main(void) { B b; //error C2512:'B': no appropriate default constructor available getchar() ; return 0 ; }
除以上情况之外还有很多,不在此一一举例描述。
参考自:http://www.cnblogs.com/graphics/archive/2012/10/02/2710340.html
从Qt谈到C++(一):关键字explicit与隐式类型转换
提出疑问
当我们新建了一个Qt的widgets应用工程时。会自动生成一个框架,包含了几个文件。其中有个mainwindow.h的头文件。就是你要操纵的UI主界面了。我们看看其中的一段代码:
class MainWindow : public QMainWindow { Q_OBJECT//一个宏,暂不考虑 public: explicit MainWindow(QWidget *parent = 0); ~MainWindow(); private: Ui::MainWindow *ui; };
这段代码定义了一个新的类MainWindow,继承自QMainWindow。我们可以看到在它的构造函数里,前面有一个关键字 explicit 。相信大家都对没有这个关键字的构造函数不陌生。那么这个 explicit 是起到什么作用的呢?
explicit研究
explicit是C++中的关键字,不是C语言中的。英文直译是“明确的”、“显式的”意思。出现这个关键字的原因,是在C++中有这样规定的基础上: 当定义了只有一个参数的构造函数时,同时也定义了一种隐式的类型转换。 先看类型转换。
类型转换
C/C++中,有很多类型转换。比如:
double a = 12.34; int b = (int)a;
我们都知道这时b的值是12. 在变量前面加括号包裹的类型,就能实现显式的类型转换。这种叫做强制类型转换。顺便值得一提的是,C++中还支持这种强制类型转换的例子:
double a = 12.34; int b = int(a);
除此之外,还有一种转换叫做 隐式类型转换。
double a = 12.34; int b = a;
同样的,b的值也是12.虽然没有显式的转换类型,但是编译器会帮你自动转换。同样的,不仅是基本数据类型,自己定义的类和对象之间也存在这种转换关系。
隐式转换的场景
等于号与构造函数
比如你有一个类的对象A:
class A { public: A(int i) { a = i; } int getValue() { return a; }; private: int a; };
你会发现,你在main函数中,使用下面的语句时是合法的:
A a = 10;
之所以类A的对象可以直接使用整型通过等于号来初始化,是因为这一语句调用了默认的单参数构造函数,其效果等价于 A temp(10); a(temp);
首先编译器执行A temp(10);在栈中创建了一个临时对象(假设叫做temp)。然后再调用对象a的拷贝初始化构造函数 a(temp) 给a初始化。然后临时对象temp销毁。这就是编译器做的隐式转换工作。你可以想到这样的隐式操作的结果和直接显示调用A a(10);的结果是一样的,但是隐式转换因为使用了拷贝构造函数所以在开销上会更高一些。当然这基本数据类型,或许不明显。如果一个复杂的对象,比如Qt的窗口。那么开销可想而知。
又如当你使用如下语句会不通过:
A a = "123";
因为没有参数为字符串的单参数构造函数。知道了这个,你修改一下就能通过了。
class A { public: A(int i) { a = i; } A(char * c) { a=c[0]; } int getValue() { return a; }; private: int a; };
函数调用
我们再定义一个函数print 用来打印A对象的值。
void print(A a) { cout<<a.getValue(); };
在main函数中:
void main() { print(10); }
这样是可以编译运行的。虽然我们并没有创建一个类A的对象来传给print 函数。但是编译器默认会调用类A的单参数构造函数,创建出一个类A的对象出来。
加上explicit
上面可以看出编译器会为你做一些,隐式的类型转换工作。这或许会让你感到方便,但是有时候却会带来麻烦。我们来做一个假设:
上面这个类A,只接受整型和字符串型。所以你想传递一个字符串 “2” 作为参数来构造一个新的对象。比如 A b = “2”; 然而,你却写错了,双引号写成了单引号变成了 A b = ‘2’; 然而这样并不会报错。编译器 会把 字符 ‘2’ 转型成 整型 也就是它的ascll码—— 50。为了避免这样我们不希望的隐式转换,我们可以加上explicit 关键字。
public: explicit A(int i) { a=i; }
这样就能避免隐式的类型转换了,当你误写成单引号的时候,就会报错。这样就只允许显示的调用单参数构造函数了。如 A a(10); A b("123");
不仅如此,在加上explicit之后,print函数也会报错了。因为编译器不会主动调用explicit标识的构造器。这就需要你自己显示的来调用了:
print(A(10));
当然了,是否应该禁止隐式转换是没有定论的,没有一种放之四海皆准的标准,具体看你的情景需要了。
explicit使用注意事项:
* explicit 关键字只能用于类内部的构造函数声明上。
* explicit 关键字作用于单个参数的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数),如Circle(int x, int y = 0) 。
* 在C++中,explicit关键字用来修饰类的构造函数,被修饰的构造函数的类,不能发生相应的隐式类型转换,只能以显示的方式进行类型转换。
顺便一提
explicit关键字只用在类内部的声明中。在外部的实现部分不需要使用。
#include<iostream> using namespace std; class A { public: explicit A(int i); A(char * c) { a=c[0]; } int getValue() { return a; }; private: int a; }; A::A(int i)//无需再指明explicit { a=i; } void print(A a) { cout<<a.getValue(); }; void main() { print(A(10)); }
转自:http://blog.csdn.net/guodongxiaren/article/details/24455653?utm_source=tuicool&utm_medium=referral