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后面紧跟着的那个就是常量。

}