第六章类和对象.docx

第六章类和对象.docx

《第六章类和对象.docx》由会员分享，可在线阅读，更多相关《第六章类和对象.docx（28页珍藏版）》请在冰点文库上搜索。

第六章类和对象

/*第六章类和对象

6.1类的定义分为说明部分和实现部分，类的成员包括数据成员和成员函数。

成员函数可以在类体内定义也可以在类体外定义。

说明部分：

class<类名>

{

public:

<成员函数或成员的说明>

protected:

<成员函数或成员的说明>

private:

<成员函数或成员的说明>

};

实现部分

<各个成员函数的实现>

6.1,2类成员的访问控制public相当于外部接口；

访问权限的修饰符是可以多次出现而且顺序可变。

私有成员可以被自己类中成员函数访问，类的对象也不可以对他进行访问。

6.1.3类的数据成员

注意1类的数九成员是任意类型的也可以是对象。

但是只有其他类的对象才能作为该类的成员，只有自身的指针才能作为自身的成员

当另一个类的对象作为该类的成员时另一个类必须在该类之后定义需要前向引用声明

2在类体中不可以对所定义的数据成员进行初始化。

6.1.4类的成员函数

必须在类体内声明，定义在体内体外均可。

第一种是成员函数直接定义在类的内部。

第二种是成员函数在类部，定义在外部。

格式为

<返回类型><类名>:

:

<成员函数名>（<参数表>）

{

<函数体>

}

作用域运算符（:

:

）的使用格式

<类名><成员函数名>（<参数表>）

<类名>:

:

<数据成员名>

定义和声明都在类中，这个成员函数就是类联函数。

定义在体外的函数变成内联函数要加上inline*/

/*#include

usingnamespacestd;

classDate

{

public:

voidSetDate

（inty,intm,intd）;

intIsLeepYear（）;

voidPrint（）;

private:

intyear,month,day;

};

voidDate:

:

SetDate（inty,intm,intd）

{

year=y;

month=m;

day=d;

}

intDate:

:

IsLeepYear（）//:

:

作用域运算符用来标识某个成员属于某个类

{

return（year%4==0&&year%100!

=0）||（year%400==0）;

}

voidDate:

:

Print（）

{

cout<

}*/

/*#include

usingnamespacestd;

classTest

{

public:

voidSetVal（intx）;

voidSetVal（intx,inty）;

intAdd（intx）;

intAdd（intx,inty）;

intAdd（）;

intGetX（）{returnX;}

intGetY（）{returnY;}

private:

intX,Y;

};

voidTest:

:

SetVal（intx）

{X=x;

Y=x*x;

}

voidTest:

:

SetVal（intx,inty）

{

X=x;

Y=y;

}

intTest:

:

Add（intx,inty）

{

X=x;

Y=y;

returnX+Y;

}

intTest:

:

Add（intx）

{

X=Y=x;

returnX+Y;

}

intTest:

:

Add（）

{

returnX+Y;

}

intmain（）

{Testobj1,obj2;

obj1.SetVal（10,20）;

obj2.SetVal（4）;

cout<<"obj1="<

cout<<"obj2="<

inti=obj1.Add（）;

intj=obj2.Add（3,9）;

intk=obj2.Add（5）;

cout<

return0;

}*/

/*#include

usingnamespacestd;

classDate

{

public:

voidSetDate（inty=2002,intm=10,intn=1）;

intIsLeapYear（）;

voidprint（）{cout<

private:

intyear,month,day;

};

voidDate:

:

SetDate（inty,intm,intd）

{

year=y;

month=m;

day=d;

}

intDate:

:

IsLeapYear（）

{

return（year%4==0&&year%100!

=0）||（year%400==0）;

}

intmain（）

{

Datedate1,date2;

date1.SetDate（）;

date2.SetDate（2000,10,1）;

cout<<"date1:

";

date1.print（）;

cout<<"date2:

";

date2.print（）;

if（date2.IsLeapYear（））cout<<"date2isaleapyear."<

elsecout<<"date2isnotaleapyear."<

return0;

}*/

/*6.2对象的定义

<类名><对象名>（<参数列表>）;有对象数组，对象指针，对象应用等

6.2.2对象的成员

<对象名>.<数据成员名>或<对象名>-><数据成员名>

<对象名>.<数据成员名>（<参数列表>）或<对象名>-><数据成员名>（<参数列表>）

*/

/*#include

usingnamespacestd;

classpoint{

public:

voidsetpoint（intx,inty）;

voidmove（intxoff,intyoff）;

intgetX（）{returnX;}

intgetY（）{returnY;}

private:

intX;intY;

};

voidpoint:

:

setpoint（intx,inty）

{X=x;

Y=y;

}

voidpoint:

:

move（intxoff,intyoff）

{

X+=xoff;

Y+=yoff;

}

intmain（）

{

pointp1,p2;

p1.setpoint（1,2）;

p2.setpoint（3,4）;

p1.move（5,6）;

p2.move（7,8）;

cout<<"point1is（"<

cout<<"point2is（"<

return0;

}*/

/*6.3函数与析构函数的定义

构造函数的作用就是利用特定的值构造对象。

将对象初始化为一种特殊的状态

性质1构造函数的性质必须与类名相同

2构造函数不指定函数类型

3可以有多个参数

4创建对象是系统自动调用构造函数

格式

Date:

:

Date（inty,intm,intd）:

year（y）,month（m）,day（d）

//

冒号之后初始化函数列表

{

cout<<"ConstructorofDatewith3parameters"<

}*/

/*#include

usingnamespacestd;

classDate

{

public:

Date（inty,intm,intd）;

Date（inty=2000）:

year（y）

{month=10;

day=1;

cout<<"ConstructorofDatewith1parameters."<

}

intIsLeepYear（）;

voidPrint（）;

private:

intyear,month,day;

};

Date:

:

Date（inty,intm,intd）:

year（y）,month（m）,day（d）

//冒号之后初始化函数列表

{

cout<<"ConstructorofDatewith3parameters"<

}

intDate:

:

IsLeepYear（）//:

:

作用域运算符用来标识某个成员属于某个类

{

return（year%4==0&&year%100!

=0）||（year%400==0）;

}

voidDate:

:

Print（）

{

cout<

}*/

/*析构函数与构造函数相反

性质

1析构函数名是在类名前面加~

2不指向返回类型，隐含有返回值

3没有参数，不能重载。

一类只能定义一个析构函数。

6.3.2默认的构造函数

格式

<类名>:

:

<类名>（）

默认的析构函数

格式

<类名>:

:

<类名>~（）

*/

/*#include

usingnamespacestd;

classDate

{

public:

Date（inty,intm,intd）;

Date（inty=2000）:

year（y）

{

month=10;

day=1;

cout<<"ConstructorofDatewith1parameters"<

~Date（）{cout<<"DestructorofDate:

"<

intIsLeepYear（）;

voidPrint（）{cout<

private:

intyear,month,day;

};

Date:

:

Date（inty,intm,intd）:

year（y）,month（m）,day（d）

{

cout<<"ConstructorofDatewith3parameters"<

}

intDate:

:

IsLeepYear（）//:

:

作用域运算符用来标识某个成员属于某个类

{

return（year%4==0&&year%100!

=0）||（year%400==0）;

}*/

/*6.3.3复制构造函数

<类名>:

:

<类名>（const<类名>&<引用对象名>）

{

//复制构造函数体

}*/

/*#include

usingnamespacestd;

classDate

{

public:

Date（inty,intm,intd）;

Date（inty=2000）:

year（y）

{

month=10;

day=1;

cout<<"ConstructorofDatewith1parameters"<

}

Date（constDate&d）;

~Date（）{cout<<"DestructorofDate:

"<

intIsLeepYear（）;

voidPrint（）{cout<

private:

intyear,month,day;

};

Date:

:

Date（inty,intm,intd）:

year（y）,month（m）,day（d）

{

cout<<"ConstructorofDatewith3parameters"<

}

Date:

:

Date（constDate&d）

{year=d.year;

month=d.month;

day=d.day;

cout<<"CopyconstructorofDate."<

}

intDate:

:

IsLeepYear（）//:

:

作用域运算符用来标识某个成员属于某个类

{

return（year%4==0&&year%100!

=0）||（year%400==0）;

}*/

/*6.4自由储存对象

随时建立（new）和删除（delete）的对象为自由储存对象.

new创建对象数组会调用默认构造函数，delete删除对象是调用析构函数*/

/*#include

usingnamespacestd;

classTest

{

public:

Test（）;

Test（inti,intj）;

~Test（）{cout<<"Destructorcalled:

"<

voidSet（inti,intj）;

voidPrint（）{cout<

private:

intX,Y;

};

Test:

:

Test（）:

X（0）,Y（0）

{cout<<"Defaultconstructorcalled."<

}

Test:

:

Test（inti,intj）:

X（i）,Y（j）

{

cout<<"Construtorcalled:

"<

}

voidTest:

:

Set（inti,intj）

{

X=i;

Y=j;

}

intmain（）

{

Test*ptr1,*ptr2,*ptr3;

ptr1=newTest（1,2）;

ptr2=newTest（3,4）;

ptr3=newTest[2];

ptr3[0].Set（5,6）;

ptr3[1].Set（7,8）;

ptr1->Print（）;

ptr2->Print（）;

ptr3[0].Print（）;

ptr3[1].Print（）;

deleteptr1;

deleteptr2;

delete[]ptr3;

return0;

}*/

/*6.5this指针

成员函数的对象的指针，

指向类对象的地址隐含与类的非静态成员函数中，

可以引用对象的数据成员和成员函数

Date&Date:

:

AddYear（intn）

{if（day==29&&month==2&&！

IsLeapYear（year+n））

{

day=1;month=3;

}

year+=n;

return*this;

}

可以改为Date&Date:

:

AddYear（intn）

{if（this->day==29&&this->month==2&&！

IsLeapYear（this->year+n））

{

this->day=1;this->month=3;

}

this->year+=n;

return*this;

}

6.6静态成员

6.6.1静态数据成员用static

<数据类型><类名>:

:

<静态数据成员名>=<初始值>

静态数据成员的值可以被任何一个对象更新*/

/*#include

usingnamespacestd;

classpoint

{

public:

point（intxx=0,intyy=0,intzz=0）:

X（xx）,Y（yy）,Z（zz）

{

count++;

}

voidDisplay（）

{

cout<<"thispointis（"<

cout<<"thereare"<

}

private:

intX,Y,Z;

staticintcount;

};

intpoint:

:

count=0;

intmain（）

{pointp1（1,2,3）,p2（4,5,6）;

p1.Display（）;

p2.Display（）;

return0;

}*/

/*6.6.2静态成员函数

可以在类内和类外定义

在类外定义时static不能直接作为前缀

<类名>:

:

<静态数据成员名>

<类名>:

:

<静态数据成员名>（<参数列表>）

*/

/*#include

usingnamespacestd;

classPoint

{

public:

Point（intxx=0,intyy=0,intzz=0）:

X（xx）,Y（yy）,Z（zz）

{

count++;

}

staticvoidDisplay（Point&p）;

private:

intX,Y,Z;

staticintcount;

};

voidPoint:

:

Display（Point&p）

{

cout<<"thispointis（"<

cout<<"thereare"<

}

intPoint:

:

count=0;

intmain（）

{

Pointp1（1,2,3）,p2（4,5,6）;

p1.Display（p1）;

p2.Display（p2）;

return0;

}*/

/*6.7常成员const

const可以修饰类对象本身和对象的成员函数和数据成员

分别叫做常对象，常成员函数，常数据成员

6.7.1

<类名>const<对象名>

或const<类名><对象名>

6.7.2常成员函数

<返回类型><成员函数名>（<参数表>）const;

当成员函数是常成员函数时常对象和一般对象都可以调用它；

而一般成员函数只有一般对象可以调用

*/

/*#include

usingnamespacestd;

classPoint

{

public:

Point（intxx=0,intyy=0）:

X（xx）,Y（yy）{}

voidMove（intxoff,intyoff）

{

X+=xoff;

Y+=yoff;

}

voidPrint（）const{cout<<"Thepointis（"<

private:

intX,Y;

};

intmain（）

{

Pointp1（1,2）;

constPointp2（3,4）;

p1.Move（5,6）;

p1.Print（）;

p2.Move（7,8）;

p2.Print（）;

return0;

}//p2是常对象而Move不是一个常成员函数*/

/*#include

usingnamespacestd;

classPoint

{

public:

Point（intxx=0,intyy=0）:

X（xx）,Y（yy）{}

voidPrint（）{cout<<"Thepointis（"<

'<

voidPrint（）const{cout<<"Thepointis（"<

private:

intX,Y;

};

intmain（）

{

Pointp1（1,2）;

constPointp2（3,4）;

p1.Print（）;

p2.Print（）;

return0;

}*/

/*6.7.3常成员函数

定义必须在类体类

常成员函数的初始化只能通过构造函数的成员初始化列表显式进行

*/

/*

#include

usingnamespacestd;

classMyclass

{

public:

Myclass（inti,intj）;

voidPoint（）const{cout<

private:

constinta;

intb;

};

Myclass:

:

Myclass（inti,intj）:

a（i）,b（j）{}

intmain（）{

Myclassobj1（1,2）;

obj1.Point（）;

return0;

}//首先执行初始化列表，然后才执行构造函数体；

*/

/*6.8友元（friend）

友元可以在类的外部直接访问类的私有成员和保护成员；

6.8.1友元函数

函数钱加friend，可以放在公有部分，私有部分，保护部分*/

/*#include

usingnamespacestd;

classTIME;

classDATE

{

public:

DATE（inty=2003,intm=1,intd=1）:

year（y）,month（m）,day（d）{}