C++构造函数

class Thing

{

public:

Thing( int a=10,int b=20, int c = 30)

//Thing( int a, int b, int c)

{ x=a; y=b; z=c; }

比较两个构造函数头，调用时的区别是什么？

在有参构造函数调用时，如果参数有默认值，则是如下调用的话，Thingt;则系统会自动的调用这个带有三个默认值的构造函数，对象没有参数，一个，两个，三个都会调用此函数。

void printThing()

{cout<<"x="<<x<<"y="<<y<<

"z="<<z<<endl;}//bad practice

private:

intx; int y; int z;

};

int main()

{

Thing t;

t.printThing();

Thing s(1);

s.printThing();

Thing r(1,2);

r.printThing();

Thing v(1,2,3);

v.printThing();

return 0;

}

OUTPUT

x= 10 y= 20 z= 30

x= 1 y= 20 z= 30

x= 1 y= 2z= 30

x= 1 y= 2z= 3

重载构造函数

重载构造函数必须有不同的参数列表，与返回值无关！

class Thing

{

public:

Thing( ) {x =0; y= 0; z=0;} //default constructor

Thing(int a){ x=a;}

Thing(int a, int b) {x=a;y=b;}

Thing(int a, int b, int c)

{x=a;y=b;z=c;}

voidprintThing(){cout<<"x="<<x<<

"y="<<y<<" z="<<z<<endl;}

private:

int x;

int y;

int z;

};

初始化列表

在构造函数头的位置，对类的成员变量进行初始化，叫做初始化列表。

初始化列表的格式为 :成员变量(赋给成员变量的值)

初始化列表优势：1.效率高 2.有一些类型的成员变量，只能用参数化列表的方式初始化，如const、引用

class Point

{

public:

Point() { x =0; y = 0; }

Point(floatx_centre, float y_centre)

{

x=x_centre;

y=y_centre;

}

void printPoint() const { cout << " x=" << x <<

" y=" <<y << endl;}

// const成员函数：成员函数体内，不能修改这个类的成员变量的值

//printPoint里不可以修改x y 的值

private:

floatx;

floaty;

};

class Circle

// A Circle object is a radius and a centre

{

public:

Circle():point(){}; //defaultconstructor

Circle(floatx_centre,float y_centre,float r)

:point(x_centre,y_centre) { radius =r;}

//初始化列表，在Circle的构造函数里，

//调用了Point类的构造函数，并传递相应的参数，给Point的

//成员变量赋值。

//初始化列表的赋值先发生

void setCircle(float r, Point p )//const

{

radius= r;

point = p; //圆心

}

void printCircle() const

//不能通过成员函数修改成员变量的值

//当你不需要在成员函数里修改成员变量的值的时候，建议加上const，可以增加程序的健壮性（鲁棒性）。

{

cout<< "radius:"<<radius;

point.printPoint();

}

private:

floatradius;

Point point;

};

void main()

{

Circle c;//定义一个对象，调用两个构造函数

//当创建复合类的对象时，不仅调用复合类本身的构造函数，

//还将调用复合类的类类型的成员变量的默认构造函数。

c.printCircle();

Point p(5,7);

p.printPoint();

c.setCircle(10,p);

c.printCircle();

Circlec2(33.0,44.0,55.0);

c2.printCircle();

//关于const成员函数增加的代码

constCircle c3( 1, 2, 3 );

//const对象，只能调用const修饰的成员函数,const位于函数小括号

//后面。普通对象，可以调用const成员函数和非const成员函数。

c3.printCircle();

constCircle& c4 = c3;

//const对象，只能赋值给const类型的引用，而不能赋值给普通引用。

c4.printCircle();

//指向常量的指针，即指针指向对象的值不能修改，但可以指向别的对象。

constCircle* c5 = &c2;

c5->printCircle();

//常量指针，c6不能指向别的对象，但是可以修改指向对象的值。

Circle * const c6 =&c1；

Circle* const cp = &c2;//cp只能指向非cosnt对象。

cp->printCircle();

cp->setCircle( 10,p);

//Circle*const p = &c3; //不可以，原因这样有可能会变成可以更改的

const Circle* const pp = &c3;//定义成双cosnt就可以了。

//cp =&c3;

根据const的位置，区分到底哪个是常量——const后面紧跟着的那个就是常量。

}