0415班C++课堂纪要.docx
《0415班C++课堂纪要.docx》由会员分享，可在线阅读，更多相关《0415班C++课堂纪要.docx（58页珍藏版）》请在冰点文库上搜索。
0415班C++课堂纪要
C++对C的加强
程序设计方法的发展历程
面向过程的结构化程序设计方法。
自顶向下、逐步求精。
面向对象的方法
封装、继承、多态
把对象的属性和操作封装起来，形成一个类；类是一个抽象的概念；class
C语言和C++语言关系
C语言是在实践的过程中逐步完善起来的C语言的目标是高效
C语言+面向对象方法论===》ObjectiveC/C++
每一个程序员都不能固步自封，要多接触新的行业、新的技术领域。
暂新的突破自我
namespace概念
在C语言中只有一个全局作用域
在C语言中只有一个全局作用域
std是c++标准命名空间，c++标准程序库中的所有标识符都被定义在std中，比如标准库中的类iostream、vector
可以更好地控制标识符的作用域
1）当使用的时候，该头文件没有定义全局命名空间，必须使用namespacestd；这样才能正确使用cout。
若不引入usingnamespacestd,需要这样做。
std:
:
cout。
2）c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。
3）C++命名空间的定义：
namespacename{…}
4）usingnamespaceNameSpaceA;
5）namespce定义可嵌套。
namespaceNameSpaceA
{
inta=0;
}
namespaceNameSpaceB
{
inta=1;
namespaceNameSpaceC
{
structTeacher
{
charname[10];
intage;
};
}
}
intmain（）
{
usingnamespaceNameSpaceA;
usingNameSpaceB:
:
NameSpaceC:
:
Teacher;
printf（"a=%d\n",a）;
printf（"a=%d\n",NameSpaceB:
:
a）;
Teachert1={"aaa",3};
printf（"t1.name=%s\n",t1.name）;
printf（"t1.age=%d\n",t1.age）;
system（"pause"）;
return0;
}
Register
//register关键字请求编译器让变量a直接放在寄存器里面，速度快
//在c语言中register修饰的变量不能取地址，但是在c++里面做了内容
/*
//1
register关键字的变化
register关键字请求“编译器”将局部变量存储于寄存器中
C语言中无法取得register变量地址
在C++中依然支持register关键字
C++编译器有自己的优化方式，不使用register也可能做优化
C++中可以取得register变量的地址
//2
C++编译器发现程序中需要取register变量的地址时，register对变量的声明变得无效。
//3
早期C语言编译器不会对代码进行优化，因此register变量是一个很好的补充。
*/
函数检测增强
/*
在C语言中，重复定义多个同名的全局变量是合法的
在C++中，不允许定义多个同名的全局变量
C语言中多个同名的全局变量最终会被链接到全局数据区的同一个地址空间上
intg_var;
intg_var=1;
C++直接拒绝这种二义性的做法。
*/
intmain（intargc,char*argv[]）
{
printf（"g_var=%d\n",g_var）;
return0;
}
struct类型加强
struct类型的加强：
C语言的struct定义了一组变量的集合，C编译器并不认为这是一种新的类型
C++中的struct是一个新类型的定义声明
structStudent
{
charname[100];
intage;
};
intmain（intargc,char*argv[]）
{
Students1={"wang",1};
Students2={"wang2",2};
return0;
}
C++中所有的变量和函数都必须有类型
f（i）
{
printf（"i=%d\n",i）;
}
g（）
{
return5;
}
intmain（intargc,char*argv[]）
{
f（10）;
printf（"g（）=%d\n",g（1,2,3,4,5））;
getchar（）;
return0;
}
总结：
/*
在C语言中
intf（）；表示返回值为int，接受任意参数的函数
intf（void）；表示返回值为int的无参函数
在C++中
intf（）;和intf（void）具有相同的意义，都表示返回值为int的无参函数
*/
C++更加强调类型，任意的程序元素都必须显示指明类型
/*
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
//三目运算符是一个表达式，表达式不可能做左值
（aa:
b）=30;
printf（"a=%d,b=%d\n",a,b）;
system（"pause"）;
return0;
}
1）C语言返回变量的值C++语言是返回变量本事
2）
C语言中的三目运算符返回的是变量值，不能作为左值使用
C++中的三目运算符可直接返回变量本身，因此可以出现在程序的任何地方
注意：
3）
三目运算符可能返回的值中如果有一个是常量值，则不能作为左值使用
（a1:
b）=30;
4）C语言如何支持类似C++的特性那？
变量的本质是内存空间的别名，是一个标号。
const专题讲座
constinta;
intconstb;
constint*c;
int*constd;
constint*conste;
含义：
//第一个第二个意思一样代表一个常整形数
//第三个c是一个指向常整形数的指针（所指向的内存数据不能被修改，但是本身可以修改）
//第四个d常指针（指针变量不能被修改，但是它所指向内存空间可以被修改）
//第五个e一个指向常整形的常指针（指针和它所指向的内存空间，均不能被修改）
结论：
C语言中的const变量
C语言中const变量是只读变量，有自己的存储空间
C++中的const常量
可能分配存储空间,也可能不分配存储空间
当const常量为全局，并且需要在其它文件中使用
当使用&操作符取const常量的地址
符号表、编译过程中若发现对const使用了extern或者&操作符，则给对应的常量分配存储空间（兼容C）
intmain（）
{
constinta=10;
int*p=（int*）&a;
printf（"a===>%d\n",a）;
*p=11;
printf（"a===>%d\n",a）;
printf（"Hello......\n"）;
return0;
}
C++中的const常量类似于宏定义
constintc=5;≈#definec5
C++中的const常量在与宏定义不同
const常量是由编译器处理的，提供类型检查和作用域检查
宏定义由预处理器处理，单纯的文本替换
引用专题讲座
1、引用是C++的概念，属于C++编译器对C的扩展
intmain（）
{
inta=0;
int&b=a;//int*constb=&a
b=11;//*b=11;
return0;
}
2、普通引用有自己的空间吗？
structTeacer{
int&a;
int&b;
};
intmain（）
{
printf（"sizeof（Teacher）%d\n",sizeof（Teacer））;
system（"pause"）;
return0;
}
3、//当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）
C++对C函数增强
内联函数
1）内联函数在编译时直接将函数体插入函数调用的地方
2）inline只是一种请求，编译器不一定允许这种请求
3）内联函数省去了普通函数调用时压栈，跳转和返回的开销
默认参数
函数默认参数的规则
只有参数列表后面部分的参数才可以提供默认参数值
一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数值
/*
函数占位参数
占位参数只有参数类型声明，而没有参数名声明
一般情况下，在函数体内部无法使用占位参数
*/
默认参数和占位参数
intfunc（inta,intb,int=0）
{
returna+b;
}
intmain66（intargc,char*argv[]）
{
printf（"func（10,20）=%d\n",func（10,20））;
printf（"Pressentertocontinue..."）;
getchar（）;
return0;
}
函数重载
用同一个函数名定义不同的函数
当函数名和不同的参数搭配时函数的含义不同
函数重载至少满足下面的一个条件：
参数个数不同
参数类型不同
参数顺序不同
*/
//当函数默认参数遇上函数重载会发生什么
/*
intfunc（inta,intb,intc=0）
{
returna*b*c;
}
intfunc（inta,intb）
{
returna+b;
}
intmain（）
{
intc=0;
c=func（1,2）;//存在二义性，调用失败，编译不能通过
printf（"c=%d\n",c）;
printf（"Pressentertocontinue..."）;
getchar（）;
return0;
}
*/
/*
编译器调用重载函数的准则
将所有同名函数作为候选者
尝试寻找可行的候选函数
精确匹配实参
通过默认参数能够匹配实参
通过默认类型转换匹配实参
匹配失败
最终寻找到的可行候选函数不唯一，则出现二义性，编译失败。
无法匹配所有候选者，函数未定义，编译失败。
*/
/*
函数重载的注意事项
重载函数在本质上是相互独立的不同函数（静态链编）
重载函数的函数类型是不同的
函数返回值不能作为函数重载的依据
函数重载是由函数名和参数列表决定的。
*/
//重载和函数指针结合
/*
函数重载与函数指针
当使用重载函数名对函数指针进行赋值时
根据重载规则挑选与函数指针参数列表一致的候选者
严格匹配候选者的函数类型与函数指针的函数类型
*/
/*
intfunc（intx）//int（inta）
{
returnx;
}
intfunc（inta,intb）
{
returna+b;
}
intfunc（constchar*s）
{
returnstrlen（s）;
}
typedefint（*PFUNC）（inta）;//int（inta）
intmain（intargc,char*argv[]）
{
intc=0;
PFUNCp=func;
c=p
（1）;
printf（"c=%d\n",c）;
printf（"Pressentertocontinue..."）;
getchar（）;
return0;
}
*/
函数重载与函数指针
当使用重载函数名对函数指针进行赋值时
根据重载规则挑选与函数指针参数列表一致的候选者
严格匹配候选者的函数类型与函数指针的函数类型
面向过程编程到面向对象编程训练
#include"iostream"
usingnamespacestd;
//目标：
抽象立方体求立方体的s和v
classCube
{
public:
voidsetA（inta）
{
m_a=a;
}
intgetA（）
{
returnm_a;
}
voidsetB（inta）
{
m_a=a;
}
intgetB（）
{
returnm_b;
}
voidsetC（inta）
{
m_a=a;
}
intgetC（）
{
returnm_c;
}
voidsetABC（inta=0,intb=0,intc=0）
{
m_a=a;
m_b=b;
m_c=c;
}
public:
intgetS（）
{
m_s=2*（m_a*m_b+m_a*m_c+m_b*m_c）;
returnm_s;
}
intgetV（）
{
m_v=m_a*m_b*m_c;
returnm_v;
}
public:
char*cubeEqueal（Cube&c1,Cube&c2）
{
if（c1.getA（）==c2.getA（）&&
c1.getB（）==c2.getB（）&&
c1.getC（）==c2.getC（））
{
return"相等";
}
return"不相等";
}
char*cubeEqueal（Cube&c2）
{
if（m_a==c2.getA（）&&
m_b==c2.getB（）&&
m_c==c2.getC（））
{
return"相等";
}
return"不相等";
}
private:
intm_a;
intm_b;
intm_c;
intm_v;
intm_s;
};
voidmain34（）
{
Cubecube1,cube2,cube3;
cube1.setABC（1,2,3）;
cube2.setABC（2,3,4）;
cube3.setABC（1,2,3）;
//cout<cout<cout<//cout<//cout<system（"pause"）;
}
voidmain31（）
{
Cubecube1;
cube1.setABC（1,2,3）;
cube1.getV（）;
cube1.getS（）;
cout<<"体积为：
"<system（"pause"）;
}
//全局函数
char*cubeEqueal（Cube&c1,Cube&c2）
{
if（c1.getA（）==c2.getA（）&&
c1.getB（）==c2.getB（）&&
c1.getC（）==c2.getC（））
{
return"相等";
}
return"不相等";
}
voidmain33（）
{
Cubecube1,cube2,cube3;
cube1.setABC（1,2,3）;
cube2.setABC（2,3,4）;
cube3.setABC（1,2,3）;
cout<cout<system（"pause"）;
}
C++中的构造函数和析构函数
基本概念
构造函数总结
构造函数是C++中用于初始化对象状态的特殊函数
构造函数在对象创建时自动被调用（默认调用），隐身调用
构造函数和普通成员函数都遵循重载规则
拷贝构造函数是对象正确初始化的重要保证
必要的时候，必须手工编写拷贝构造函数
构造函数的调用
自动调用：
一般情况下C++编译器会自动调用构造函数
手动调用：
在一些情况下则需要手工调用构造函数
构造函数有三种
有参构造函数、默认构造函数、拷贝构造函数
析构函数
有参构造函数调用的三种方法
//
classTest
{
public:
//有参构造函数
Test（inta）
{
m_a=a;
}
//无参数构造函数
Test（）
{
m_a=0;
}
//四种应用场景
//赋值构造函数copy构造函数
Test（constTest&obj）
{
}
public:
voidprint（）
{
cout<<"m_a"<}
protected:
private:
intm_a;
};
voidmain66（）
{
//括号法
Testt1（10）;//c++编译器自动调用这个类的有参构造函数
t1.print（）;
//=
Testt2=20;//c++编译器自动调用这个类的有参构造函数
t2.print（）;
//
Testt3=Test（30）;//程序员手工的调用构造函数进行对象初始化
t3.print（）;
system（"pause"）;
}
构造函数用来完成对象的构造（初始化）工作，
赋值构造函数（copy构造函数）和=操作是两个不同的概念
赋值构造函数（copy构造函数）的四个应用场景
voidmain81（）
{
Test88t1;
//t1.SetBuf（"我是t1"）;
t1.setA（10）;
Test88t3;
//第一种场景
//1赋值构造函数和=操作是两个不同的概念
//2赋值构造函数copy构造函数也是构造函数
//在这个场景之下。
t2被创建，并且自动的调用copy构造
//3当我们没有编写copy构造函数（赋值构造函数）的时候，c++编译器会默认给我们提供一个copy构造函数执行的是浅copy
Test88t2=t1;//对象t2的初始化
cout<//t2=t1;//是对象的=操作
system（"pasue"）;
}
voidmain888（）
{
Test88t1;
t1.setA（10）;
//第二种场景
Test88t2（t1）;
system（"pasue"）;
}
voidf（Locationp）
{
cout<<"Funtion:
"<}
voidplayobjmain（）
{
LocationA（1,2）;
f（A）;
}
classLocation
{
public:
Location（intxx=0,intyy=0）
{
X=xx;Y=yy;cout<<"ConstructorObject.\n";
}
Location（constLocation&p）//复制构造函数
{
X=p.X;Y=p.Y;cout<<"Copy_constructorcalled."<~Location（）{cout<intGetX（）{returnX;}intGetY（）{returnY;}
private:
intX,Y;
};
voidf（Locationp）
{
cout<<"Funtion:
"<}
//voidplayobjmain（）
//{
//LocationA（1,2）;
//f（A）;
//}
Locationg（）
{
LocationA（1,2）;
returnA;
}
voidmain101（）
{
LocationB;
B=g（）;
}
voidmain102（）
{
//g（）返回一个匿名对象
LocationB=g（）;
}
voidmain1111（）
{
main102（）;
system（"pause"）;
}
构造函数析构函数调用规则
规则总结：
/*
1当类中没有定义任何一个构造函数时，c++编译器会提供无参构造函数和拷贝构造函数
2当类中定义了任意的非拷贝构造函数（无参、有参），c++编译器不会提供无参构造函数
3当类中定义了拷贝构造函数时，c++编译器不会提供无参数构造函数
4默认拷贝构造函数成员变量简单赋值
总结：
只要你写了构造函数，那么你必须用。
*
升级会员 