C++自学笔记Word格式.docx
- 文档编号:21332166
- 上传时间:2023-01-29
- 格式:DOCX
- 页数:60
- 大小:262.34KB
C++自学笔记Word格式.docx
《C++自学笔记Word格式.docx》由会员分享,可在线阅读,更多相关《C++自学笔记Word格式.docx(60页珍藏版)》请在冰豆网上搜索。
sun=0.
枚举类型元素可以缺省,它们依次为:
0,1,2….
也可以在声明时另行制定枚举元素的值:
enumweekday
{sun=7,mon=1,tue,wed,thu,fri,sat};
枚举值可以进行关系运算
整数值不能直接赋值给枚举变量,如需要将整数赋值给枚举变量,应进行强制类型转换。
day=weekday(7);
设某次体育比赛的结果又四种可能:
胜(WIN)、负(LOSE)、平局(TIE),取消比赛(CANCEL)
编写程序顺序输出这四种情况。
#include<
iostream.h>
enumgame_result{WIN,LOSE,TIE,CANCEL};
Intmain()
{game_resultresult;
enumgame_resultomit=CANCEL;
//C++中前面的enum可以省略。
Intcount;
for(count=WIN;
conut<
=CANCEL;
count++)
{
result=(game_result)count;
If(Result==omit)
{cout<
<
”Thegamewascancelled\n”;
}
else
{cout<
”Thegamewasplayed”;
If(result==WIN)
cout<
”andwewon!
”
If(result==LOSE)
cout<
”andwelost.”
”\n”;
}return0;
结构体的概念:
结构是由不同数据类型的数据组成的集合体。
声明结构类型:
struct结构名
{
数据类型成员名1;
数据类型成员名2;
:
数据类型成员名N;
举例:
structstudent//学生信息结构体
intnum;
//学号
charname[20];
//姓名
charsex;
//性别
intage;
//年龄
floatscore;
//成绩
charaddr[30];
//住址
}A={97001,“linlin”,“f”,19};
结构体变量说明形式:
结构名结构变量名;
注意:
结构变量的存储类型概念,它的寿命,可见性及使用范围与普通变量完全一致。
结构变量说明在结构类型声明之后,二者也可以同时进行。
结构变量占内存大小可用sizeof运算求出。
sizeof(student);
初始化:
说明结构变量的同时可以直接设置初值。
使用:
结构体成员的引用形式:
结构变量名.成员名
内联函数:
声明时使用关键字inline。
编译时在调用处用函数体进行替换,节省了参数传递、控制转移等开销。
注意:
内联函数体内不能有循环语句和switch语句。
内联函数的声明必须出现在内联函数第一次被调用之前。
对内联函数不能进行异常接口声明。
例子:
inlinedoublecalarea(doubleradius)
{return3.14*radius*radius}
intmain()
doubler(3.0);
doublearea;
area=calarea(r);
area<
endl;
return0;
重载函数:
重载函数的形参必须不同:
个数不同或类型不同。
编译程序将根据实参和形参的类型及个数的最佳匹配来选择调用哪一个函数。
函数模板:
可以用来创建一个通用功能的函数,以支持多种不同形参,进一步简化重载函数的函数体设计。
声明方法:
template<
typrname标识符>
函数声明
typenameT>
Tabs(Tx)
{returnx<
0?
-x:
x;
}
voidmain()
{intn=-5;
doubled=-5.5;
abs(n)<
endl;
abs(d)<
类与对象
类:
类是具有相同属性和行为的一组对象的集合,它为属于该类的全部对象提供了统一的抽象描述,其内部包括属性和行为两个主要部分。
利用类可以实现数据的封装、隐藏、继承与派生。
利用类易于编写大型复杂程序,其模块化程度比C中采用函数更高。
(1)抽象:
抽象是对具体对象(问题)进行概括,抽出这一类对象的公共性质并加以描述的过程。
(2)封装:
将抽象出的数据成员、代码成员相结合,将它们视为一个整体。
(3)继承和派生:
是C++中支持层次分类的一种机制,允许程序员在保持原有类特性的基础上,进行更具体的说明。
(4)多态性:
同一名称,不同的功能实现方式。
目的:
达到行为标识统一,减少程序中标识符的个数
类是一种用户自定义类型,声明形式:
实例:
class类名称
public:
//公有的
共有成员(外部接口)成员函数----行为、方法
private:
//私有的
私有成员数据成员----属性
protected:
//保护型
保护型成员
public:
它们是类与外部的接口,任何外部函数都可以访问共有类型数据和函数。
private:
只允许本类中的函数访问,而外部的任何函数都不能访问。
(如果紧跟在类名称的后面声明私有成员,则关键字private可以省略)
protected:
与private类似,其差别表现在继承与派生时对派生类的影响不同。
classClock
voidSetTime(intNewH,intNewM,intNewS);
voidShowTime()
intHour,Minute,Second;
voidClock:
:
SetTime(intNewH,intNewM,intNewS);
Hour=NewH;
Minute=NewM;
Second=NewS;
voidClock:
:
ShowTime()
Hour<
”:
”<
Minute<
Second;
成员函数:
在类中说明原形,可以再类外给出函数体实现,并在函数名前使用类名加以限定。
也可以直接在类中给出函数体,形成内联成员函数。
成员数据:
与一般的变量声明相同,但需要将它放在类的声明体中。
对象:
类的对象是该类的某一特定实体,即类类型的变量。
声明形式:
类名对象名;
例:
clockmyclock;
类中成员的访问方式:
类中成员互相可直接访问。
类外访问使用“对象名.成员名”只能访问public成员。
voidSetTime(intNewH,intNewM,intNewS);
voidmain(void)
{clockmyclock;
myclock.settime(8,30,30);
myclock.showtime();
关键字struct,与类相同,但结构内都是共有的。
构造函数:
由于类的封装性,不能象普通变量一样初始化。
构造函数的作用是在对象被创建时使用特定的值构造对象,或者说将对象初始化为一个特定的状态。
在对象创建时由系统自动调用。
如果程序中未声明,则系统自动产生一个缺省形式的构造函数。
允许为内联函数,重载函数,带缺省形参值的函数。
例:
classclock
{public:
clock(intNewH,intNewM,intNewS);
//构造函数
voidsettime(intNewH,intNewM,intNewS);
coidshowtime()
private;
intHour,Minute,Second;
clock:
clock(intNewH,intNewM,intNewS)
Hour=NewH
Minute=NewM;
Second=NewS;
建立对象时构造函数的作用:
clockc(0,0,0);
//隐含调用构造函数,将初始值作为实参
c.showtime();
类的应用例子:
#include<
constdoublePI=3.14159;
constfloatzhalanDJ=35;
constfloatguodaoDJ=20;
classyuan//声明类Circle
private:
floatbanjing;
public:
yuan(floatr);
//构造函数
floatyuanZC();
//圆周长
floatyuanMJ();
//圆面积
};
yuan:
yuan(floatr)//类的实现
{yuan:
banjing=r;
}//构造函数初始化数据成员radius
floatyuan:
yuanZC()//计算圆的周长
return2*PI*banjing;
yuanMJ()//计算圆的面积
returnPI*banjing*banjing;
floatbanjing;
floatzhalanHF,guodaoHF;
"
Entertheradiusofthepool:
;
//提示用户输入半径
cin>
>
banjing;
yuanXyuan(banjing);
//声明yuan对象
yuanDyuan(banjing+3);
zhalanHF=Dyuan.yuanZC()*zhalanDJ;
//计算栅栏造价并输出
zhalan:
¥"
zhalanHF<
guodaoHF=(Dyuan.yuanMJ()-Xyuan.yuanMJ())*guodaoDJ;
//计算过道造价并输出
guodao:
guodaoHF<
//运行结果:
//Entertheradiusofthepool:
10
//FencingCostis¥2858.85
//ConcreteCostis¥4335.39
拷贝构造函数:
(用一个对象,去初始化另一个对象。
)
#当用类的一个对象去初始化该类的另一个对象时,系统自动调用拷贝构造函数。
(例1)
#当函数的形参为类对象,调用函数时,实参赋值给形参,系统自动调用拷贝构造函数。
(例2)
#当函数的返回值是类对象时,系统自定调用拷贝构造函数。
(例3)
class类名
{public:
类名(形参);
类名(类名&
对象名);
//拷贝构造函数
……
};
类名:
类名(类名&
对象名)//拷贝构造函数的实现
{函数体}
classpoint
point(intxx=0,intyy=0){X=xx;
Y=yy;
point(point&
p);
intGetX(){returnX;
intGetY(){returnY;
private:
intX,Y;
point:
p)
X=p.X;
Y=p.Y;
”拷贝构造函数被调用<
例1:
{pointA(1,2)
pointB(A);
//拷贝构造函数
B.GetX()<
例2:
voidg(pointp)
p.GetX()<
{pointA(1,2);
g(A);
//调用拷贝构造函数
例3:
voidg()
returnA;
{pointB;
B=g();
析构函数:
完成对象被删除前的一些清理工作。
在对象的生存期结束的时候系统自动调用它,然后在释放此对象所属的空间。
如果程序中未声明析构函数,编译器将自动产生一个缺省的析构函数。
类的组合
类中的成员数据室另一个类的对象。
可以再已有的抽象基础上实现更复杂的抽象。
通过对复杂对象进行分解、抽象,使我们能够将一个复杂对象理解为简单对象的组合。
分解得到复杂对象的部分对象,这些部件对象比它高层的复杂对象更容易理解和实现。
然后由这些部件对象来“装配”复杂对象。
类名:
类名(对象成员所需的形参,本类成员形参):
对象1(参数),对象2(参数),…..
{本类初始化}
classPoint
{private:
floatx,y;
//点的坐标
Point(floath,floatv);
floatGetX(void);
floatGetY(void);
//….函数的实现
classD
pointP1,P2;
//线段的两端点
doubledist;
D(Pointa,Pointb);
构造函数
doubleGetDis(void){returndist;
//…函数实现略
Point(intxx=0,intyy=0){x=xx;
y=yy;
D:
D(Pointa,Pointb):
p1(a),p2(b)
{doublex=double(p1.GetX()-p2.GetX());
…………
…………略
前向引用声明
类应该先声明,后使用。
如果需要在某个类的声明之前,引用该类,则应进行前向引用声明。
前向引用声明只为程序引入一个标示符,但具体声明在其他地方。
classB;
classA
viodf(Bb);
classB
viodg(Aa);
类模板:
使用类模板使用户可以为类声明一种模式,使得类中的某些数据成员、某些成员函数的参数、某些成员的函数的返回值,能取任意类型(包括系统预定义的和用户自定义的)。
用来控制类的类型...重载是功能不同类型匹配的模板选择。
template<
模板参数表>
类声明
math.h>
classT>
classcomplex
Treal;
Timag;
complex(Tr=0.0,Ti=0.0)
{real=r,imag=I;
Trealcomplex(){returnreal;
Timagcomplex(){returnimag;
Tabscomplex()
{doublet;
t=(double)real*real+(double)imag*imag;
returnsqrt(t);
}
在类定义体外定义成员函数时,若此成员函数中有模板参数存在,则需要在函数体外进行模板声明,并且在函数名前的类名后缀上“<
Type>
”。
成员函数在类定义体外定义为:
Tcomplex<
T>
realcomplex()
{returnreal;
类模板不是实例的类,而是代表一类的类,根据对象具体实例化。
类模板实例化成一个具体的类,它的格式为:
类名<
实际的类型>
对象名;
使用上面的类模板,创建两个模板参数为double型的对象,语句如下:
complex<
double>
s1,s2;
创建两个int型对象:
complex<
int>
n1,n2;
静态生存期:
这种生存期与程序的运行期相同
在文件作用域中声明的对象具有这种生存期。
在函数内部声明静态生存期对象,要冠以关键字static。
staticinti;
类中的静态数据成员---解决访问权限控制问题。
类中的静态数据成员,不属于任何一个对象,它只属于类。
#用关键字static声明。
#该类的所有对象维护该成员的同一个拷贝。
必须在类外定义和初始化,用“:
”来指明所属的类。
Point(intxx=0,intyy=0){X=xx;
countP++;
Point(Point&
intGetX(){returnX;
intGetY(){returnY;
voidGetC(){cout<
”Objectid=”<
countP<
staticintcountP;
//统计对象的个数
Point:
Point(Point&
{X=p.X;
Y=p.Y;
countP++;
intPoint:
countP=0;
{PointA(4,5);
”PointA,”<
A.GetX()<
”,”<
A,GetY();
A.GetC();
PointB(A);
”PointB,”<
B,GetY();
B.GetC();
静态成员函数:
类外代码可以使用类名和作用域操作符(:
)或者对象名来调用静态成员函数。
(一般静态数据成员与静态成员函数都属于私有的)
班里面有10个人(10个高一1班的对象),体育老师分给你们一个篮球(静态成员函数),你们每个人都带了一个篮球(非静态成员函数),你们都很小气,自己的球只能自己拍,要是5对5打比赛,那就只能用那个静态的篮球了(每个人都可以拿来用,但是带来的影响是对全体的)。
因此,我可以说那个篮球是高一1班的成员。
所以也就是说:
静态成员函数是类的成员函数(因为高一2班就不能拿来玩),但是这个篮球最后还是要还给老师的,任何私人不得占有。
友元:
#友元是C++提供的一种破坏数据封装和数据隐藏的机制。
#通过将一个模块声明为另一个模块的友元,一个模块就能引用到另一个模块中被隐藏的信息。
#可以使用友元函数和友元类。
#为了确保数据的完整性,及数据封装与隐藏的原则,建议尽量不使用或者少使用友元。
#友元可以是非成员函数,必须通过对象名访问private和protected成员。
声明方式:
classP
friendintg(P&
a,P&
b);
//说明函数g为P类的友元
{
intg(P&
b)
{intc;
c=a.X+b.Y;
//可用参数直接以“.”直接访问P类的私有成员
returnc;
友元关系是单向的且不能传递的!
B类是A类的友元,B类可以访问A类,但A类不可以访问B类的私有成员。
引用:
只是对象(变量等)的另一个名字,在引用上的所有操作事实上都是作用在该引用的目标对象上。
可以对一个对象进行多个引用。
(经常用于函数间的数据传递。
inta=100;
int&
i=a;
&
i2=a;
const常类型:
常类型的对象必须进行初始化,而且不能被更改。
#常引用:
被引用的对象不能被修改。
const类型说明符&
引用名;
#常对象:
必须进行初始化,不能被修改。
类名const对象名;
#常成员函数:
通常常对象只能调用它的常成员函数,其他成员函数不能调用。
类型说明符函数名(参数表)const;
#常数
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- C+ 自学 笔记