0529C++课堂纪要Word文档格式.docx
《0529C++课堂纪要Word文档格式.docx》由会员分享，可在线阅读，更多相关《0529C++课堂纪要Word文档格式.docx（78页珍藏版）》请在冰点文库上搜索。
/*
在C语言中
intf（）；
表示返回值为int，接受任意参数的函数
intf（void）；
表示返回值为int的无参函数
在C++中
intf（）;
和intf（void）具有相同的意义，都表示返回值为int的无参函数
*/
C++更加强调类型，任意的程序元素都必须显示指明类型
bool类型
C++中的布尔类型
C++在C语言的基本类型系统之上增加了bool
C++中的bool可取的值只有true和false
理论上bool只占用一个字节，
如果多个bool变量定义在一起，可能会各占一个bit，这取决于编译器的实现
true代表真值，编译器内部用1来表示
false代表非真值，编译器内部用0来表示
bool类型只有true（非0）和false（0）两个值
C++编译器会在赋值时将非0值转换为true，0值转换为false
三目运算符增强
intmain（）
{
inta=10;
intb=20;
//返回一个最小数并且给最小数赋值成3
//三目运算符是一个表达式，表达式不可能做左值
（a<
b?
a:
b）=30;
printf（"
a=%d,b=%d\n"
a,b）;
system（"
pause"
）;
return0;
}
1）C语言返回变量的值C++语言是返回变量本事
2）
C语言中的三目运算符返回的是变量值，不能作为左值使用
C++中的三目运算符可直接返回变量本身，因此可以出现在程序的任何地方
注意：
3）
三目运算符可能返回的值中如果有一个是常量值，则不能作为左值使用
（a<
1:
4）C语言如何支持类似C++的特性那？
变量的本质是内存空间的别名，是一个标号。
const专题讲座
constinta;
intconstb;
constint*c;
int*constd;
constint*conste;
//第一个第二个意思一样代表一个常整形数
//第三个c是一个指向常整形数的指针（所指向的内存数据不能被修改，但是本身可以修改）
//第四个d常指针（指针变量不能被修改，但是它所指向内存空间可以被修改）
//第五个e一个指向常整形的常指针（指针和它所指向的内存空间，均不能被修改）
C语言中的const变量
C语言中const变量是只读变量，有自己的存储空间
C++中的const常量
可能分配存储空间,也可能不分配存储空间
当const常量为全局，并且需要在其它文件中使用
当使用&
操作符取const常量的地址
constinta=1;
constintb=2;
intarray[a+b]={0};
inti=0;
for（i=0;
i<
（a+b）;
i++）
{
array[%d]=%d\n"
i,array[i]）;
}
Pressentertocontinue..."
getchar（）;
C++中的const常量类似于宏定义
constintc=5;
≈#definec5
C++中的const常量在与宏定义不同
const常量是由编译器处理的，提供类型检查和作用域检查
宏定义由预处理器（CPP）处理，单纯的文本替换
voidfun1（）
#definea10
constintb=20;
//#undefa
引用专题讲座
1、引用是C++的概念，属于C++编译器对C的扩展
2、引用的本质
1）引用在C++中的内部实现是一个常指针
Type&
nameType*constname
2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。
这是C++为了实用性而做出的细节隐藏
引用在实现上，只不过是把：
间接赋值成立的三个条件的后两步和二为一。
//当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）
引用当左值
//基础类型a返回的时候，也会有一个副本
int&
getAA2（）
inta;
a=10;
returna;
voidmain21（）
inta1=0;
inta2=0;
a1=getAA1（）;
a2=getAA2（）;
int&
a3=getAA2（）;
//乱码
a1:
%d\n"
a1）;
a2:
a2）;
a3:
a3）;
当函数返回值为引用时
若返回栈变量
不能成为其它引用的初始值
不能作为左值使用
若返回静态变量或全局变量
可以成为其他引用的初始值
即可作为右值使用，也可作为左值使用
C++链式编程中，经常用到引用，运算符重载专题
指针引用
//指针的引用而已
intgetTe2（Teacher*&
myp）
myp=（Teacher*）malloc（sizeof（Teacher））;
myp->
age=34;
1const引用让变量拥有只读属性
voidprintTe2（constTeacher1*constpt）
//const引用让变量（所指内存空间）拥有只读属性
voidprintTe（constTeacher1&
t）
//t.age=11;
2Const引用用字面量初始化const引用
voidmain（）
constintb=10;
b:
%d"
&
b）;
//int&
a1=19;
如果不加const编译失败
constint&
a=19;
&
a:
a）;
C++对C函数加强专题讲座
内联函数
结论：
1）内联函数在编译时直接将函数体插入函数调用的地方
2）inline只是一种请求，编译器不一定允许这种请求
3）内联函数省去了普通函数调用时压栈，跳转和返回的开销
默认参数及默认参数的规则
默认参数和占位参数
intfunc（inta,intb,int=0）
returna+b;
函数重载
函数重载（FunctionOverload）
用同一个函数名定义不同的函数
当函数名和不同的参数搭配时函数的含义不同
函数重载至少满足下面的一个条件：
参数个数不同
参数类型不同
参数顺序不同
函数重载调用规则。
。
//当函数默认参数遇上函数重载会发生什么
intfunc（inta,intb,intc=0）
returna*b*c;
Intfunc（inta,intb）
intc=0;
c=func（1,2）;
//存在二义性，调用失败，编译不能通过
c=%d\n"
c）;
函数重载与函数指针
C++中类的封装
基本概念
//类是把属性和方法封装。
//类的内部
//类的外部
//我们抽象了一个类，用类去定义对象
//类是一个数据类型，类是抽象的
//对象是一个具体的变量。
占用内存空间。
//类做函数参数的时候，类封装了属性和方法，在被调用函数里面，不但可以使用属性，而且可以使用方法（成员函数）；
//面向过程编程加工的是：
函数
//面向对象编程加工的是：
类
类的访问控制，三个关键字
public
成员变量和成员函数可以在类的内部和外界访问和调用
private
成员变量和成员函数只能在类的内部被访问和调用
类的真正形态
在用struct定义类时，所有成员的默认属性为public
在用class定义类时，所有成员的默认属性为private
C++中的构造和析构专题讲座
为什么对象需要初始化显示调用方案及局限性分析
Testt1;
t1.init（10）;
//不好用蹩脚的地方
//
Testt11,t12,t13;
t11.init（11）;
t12.init（12）;
t13.init（13）;
Testarray[3999]={t11,t12,t13};
C++编译器提供的构造方案
classTest
public:
//构造函数无参构造函数默认构造函数
Test（）
a=10;
//带参数的构造函数
//调用方法3中
Test（intmya）
a=mya;
//第三中初始化对象的方法
//赋值构造函数copy构造函数
//copy构造函数的用法4中应用场景
Test（constTest&
obj）
printf（"
我完成对象的初始化，我也是是构造函数aaaaa"
）
protected:
private:
};
有参构造函数的三种调用方法
//1（）
Testt1（10）;
//c++默认调用有参构造函数自动调用
//=
Testt2=11;
//c++默认调用有参构造函数自动调用
//手工调
Testt3=Test（12）;
//我们程序员手动调用构造函数
赋值构造函数（copy构造函数）四种应用场景
第一个应用场景
//单独搭建一个舞台
voidObjPlay01（）
AAa1;
//变量定义
//赋值构造函数的第一个应用场景
//我用对象1初始化对象2
AAa2=a1;
//定义变量并初始化
a2=a1;
//用a1来=号给a2编译器给我们提供的浅copy
第二个应用场景
voidObjPlay02（）
AAa1（10）;
AAa2（a1）;
//a2=a1;
a2.getA（）;
第三个应用场景
//alt+f8排版
voidf（Locationp）
{
cout<
<
"
Funtion:
"
<
p.GetX（）<
"
p.GetY（）<
endl;
voidmainobjplay（）
LocationA（1,2）;
f（A）;
第四个应用场景
//40=等号操作
//42对象初始化操作
//对象初始化操作和=等号操作是两个不同的概念
//LocationB;
//B=g（）;
LocationB=g（）;
//如果返回的匿名对象，来初始化另外一个同类型的类对象，那么匿名对象会直接转成新的对象。
//匿名对象的去和留，关键看，返回时如何接过来。
cout<
测试测试"
endl;
//42对象初始化操作是两个不同概念
深copy浅copy专题
className
Name（constchar*pname）
size=strlen（pname）;
pName=（char*）malloc（size+1）;
strcpy（pName,pname）;
Name（Name&
obj）
//用obj来初始化自己
pName=（char*）malloc（obj.size+1）;
strcpy（pName,obj.pName）;
size=obj.size;
~Name（）
cout<
开始析构"
if（pName!
=NULL）
{
free（pName）;
pName=NULL;
size=0;
}
voidoperator=（Name&
obj3）
if（pName!
=NULL）
测试有没有调用我。
//用obj3来=自己
pName=（char*）malloc（obj3.size+1）;
strcpy（pName,obj3.pName）;
size=obj3.size;
}
char*pName;
intsize;
//对象的初始化和对象之间=号操作是两个不同的概念
voidplayObj（）
Nameobj1（"
obj1....."
Nameobj2=obj1;
//obj2创建并初始化
Nameobj3（"
obj3..."
//重载=号操作符
obj2=obj3;
//=号操作
业务操作。
5000"
voidmain61（）
playObj（）;
类的三种构造函数的调用规则研究
1当类中没有定义任何一个构造函数时，c++编译器会提供无参构造函数和拷贝构造函数
2当类中定义了任意的非拷贝构造函数（无参、有参），c++编译器不会提供无参构造函数
3当类中定义了拷贝构造函数时，c++编译器不会提供无参数构造函数
4默认拷贝构造函数成员变量简单赋值
总结：
只要你写了构造函数，那么你必须用。
构造函数是C++中用于初始化对象状态的特殊函数
构造函数在对象创建时自动被调用
构造函数和普通成员函数都遵循重载规则
拷贝构造函数是对象正确初始化的重要保证
必要的时候，必须手工编写拷贝构造函数
构造函数和析构函数调用顺序总结
构造函数与析构函数的调用顺序
当类中有成员变量是其它类的对象时
首先调用成员变量的构造函数
调用顺序与声明顺序相同
之后调用自身类的构造函数
析构函数的调用秩序与对应的构造函数调用秩序相反
对象组合中的初始化列表（为什么有，怎么样的解决方案）
//对象做函数参数
//1研究拷贝构造
//2研究构造函数，析构函数的调用顺序
//总结构造和析构的调用顺序
#include"
iostream"
usingnamespacestd;
classABCD
ABCD（inta,intb,intc）
this->
a=a;
b=b;
c=c;
ABCD（）construct,a:
%d,b:
%d,c:
this->
a,this->
b,this->
c）;
~ABCD（）
~ABCD（）construct,a:
intgetA（）
returnthis->
a;
intb;
intc;
classMyE
MyE（）:
abcd1（1,2,3）,abcd2（4,5,6）,m（100）
MyD（）"
~MyE（）
~MyD（）"
MyE（constMyE&
obj）:
abcd1（7,8,9）,abcd2（10,11,12）,m（100）
MyD（constMyD&
obj）\n"
//private:
ABCDabcd1;
//c++编译器不知道如何构造abc1
ABCDabcd2;
constintm;
intdoThing（MyEmye1）
doThing（）mye1.abc1.a:
mye1.abcd1.getA（））;
intrun2（）
MyEmyE;
doThing（myE）;
//
intrun3（）
run3start..\n"
ABCDabcd=ABCD（100,200,300）;
//若直接调用构造函数哪
//想调用构造函数对abc对象进行再复制，可以吗？
//在构造函数里面调用另外一个构造函数，会有什么结果？
//ABCD（400,500,600）;
//临时对象的生命周期
run3end\n"
//run2（）;
run3（）;
构造析构综合练习
直接调用构造函数，关键看有没有对象去接受匿名对象。
构造函数中调用构造函数
newdelete专题
//1newdelete操作符号c++的关键字
//mallocfree函数
//2new在堆上分配内存delete
//分配基础类型、分配数组类型、分配对象
Testt1（1,2）;
//在临时区分配内存
//new+类型返回一个内存首地址
//new操作符也会自动的调用这个类的构造函数、
//delete自动的调用这个类的析构函数
//相当于我们程序员可以手工控制类的对象的生命周期
Test*p=newTest（1,2）;
p->
getA（）<
deletep;
getTestObj（&
p）;
混搭风。
深入理解malloc和new的区别、delete和free的区别
static关键字
classBB
intgetC（）
returnc;
voidsetC（intnyc）
c=nyc;
//静态成员函数是属于整个类，
//在类的静态数据成员函数中，是不能调用具体的对象的变量的属性。
（抛砖）
//不能调用普通成员变量
staticvoidgetMem（）
//cout<
a<
c<
staticintc;
intBB:
c=0;
//给静态变量初始化要在类的外部
//static修饰的变量，是属于类，，所
升级会员 