C++学习笔记摘录十一.docx
《C++学习笔记摘录十一.docx》由会员分享，可在线阅读，更多相关《C++学习笔记摘录十一.docx（29页珍藏版）》请在冰豆网上搜索。
C++学习笔记摘录十一
C++学习笔记
SkySeraph2010-7-31阅读整理
摘自：
链表：
1：
这里要创建一个窗口。
以前是在DOS下操作也就是命令副，现在我们用WINDOWS来创建。
从开始的时候已经说明了。
我使用的环境为VC++2008SP1所以这里也是这样演示。
首先。
在启动，在菜单栏选择 新建-项目-visualc++-win32-win32项目，确定，下一步选择空项目，会创建一个什么都没有的项目。
这个项目是C++使用的。
然后在解决方案视图。
选择头文件右键添加新建项选择头文件，添加。
。
然后资源文件也需要创建资源文件。
rc
这里要在菜单项目添加个类使用C++类然后在属性里面选择好静态MFC如图：
需要注意的是静态库中的MFC他会独立编译 也就是程序会比较大。
但是可以在没有安装MFC中的机器上运行，如果使用共享DLL的话程序会比较小，他不会把MFC中的类需要的支持库一起编译进去。
2:
这次编写的VC++程序需要经常操作所以不在详细写了
需要注意VC++6.0和VC++2008的区别6.0可以直接使用MFC而2008你却需要创建一个MFC程序然后保留
stdafx.cppstdafx.h等几个必要的其他不需要的窗口可以直接删除这样就是一个空白的MFC程序！
我是学了段时间的VC++2008后才知道怎么操作的所以现在转回来学C++了
VC++如何添加MFC类？
其实很简单，切换到类视图
如图：
即可
添加成员变量或者函数同样在你添加的类名那里右击添加即可！
句柄的概念：
VC++如何添加MFC类
句柄的概念1
句柄的概念2
还有点需要注意的是在VC++2008中默认是支持UNICODE的而VC6.0是默认不支持，所以在编程中你得使用修饰符来表示 _T（""） 你们如果发现有不能将参数2从“constchar[11]”转换为“LPCTSTR” 就是没有加上UNICODE的原因错误！
继续，在2008或者2005中你使用sprintf会遇到问题，那是因为他使用了更加安全的运行库。
所以你得使用 sprintf_s才可以，或者屏蔽这个警告
在预编译头文件stdafx.h里（注意：
一定要在没有include任何头文件之前）定义下面的宏：
#define_CRT_SECURE_NO_DEPRECATE或者#paramwarning（disable:
4996）
以上方法没有使用新的更安全的CRT函数，显然不是一个值得推荐的方法，可是你又不想一个一个地改。
那么还有一个更方便的方法：
在预编译头文件stdafx.h里（同样要在没有include任何头文件之前）定义下面的宏：
#define_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES1
此节源码下载，请使用VC++2008SP1编译点我下载
3:
#include
usingnamespacestd;
classFather
{
public:
voidsmart（）
{
cout<<"父亲很聪明！
"< }
virtualvoidbeatuerful（）{}
virtual~Father（）
{
cout<<"父亲被析构！
"< }
};
classSon:
publicFather
{
public:
voidbeatuerful（）
{
cout<<"儿子也很帅"< }
~Son（）
{
cout<<"儿子被析构！
"< }
};
intmain（）
{
Father*pt;
intChoice=4;
while（Choice<99）
{
boolquit=false;
cout<<"（0）退出
（1）父亲
（2）儿子：
";
cin>>Choice;
switch（Choice）
{
case0:
quit=true;
break;
case1:
pt=newFather;
pt->beatuerful（）;
break;
case2:
pt=newSon;
pt->beatuerful（）;
pt->smart（）;
deletept;
break;
default:
cout<<"请输入0到2之间的数字：
";
}
if（quit）
{
break;
}
}
cout<<"程序结束！
"< return0;
}
多重与单一继承1
#include
usingnamespacestd;
classFather
{
public:
voidsmart（）
{
cout<<"父亲很聪明！
"< }
//virtualvoidbeatuerful（）{}
virtual~Father（）
{
cout<<"父亲被析构！
"< }
};
classSon:
publicFather
{
public:
voidbeatuerful（）
{
cout<<"儿子也很帅"< }
~Son（）
{
cout<<"儿子被析构！
"< }
};
intmain（）
{
Father*pt;
intChoice=4;
while（Choice<99）
{
boolquit=false;
cout<<"（0）退出
（1）父亲
（2）儿子：
";
cin>>Choice;
switch（Choice）
{
case0:
quit=true;
break;
case1:
pt=newFather;
// pt->beatuerful（）;
break;
case2:
pt=newSon;
dynamic_cast（pt）->beatuerful（）;//如果我们不想使用多重继承而又不想浪费父类的函数那么可以使用强制转换。
这个函数的意思是把pt这个父类的指针转换为Son类的指针，这样可以让pt指向派生类！
因为pt是指向父类的如果不转换会出错！
如果在vc6中需要开启rtti 如图：
vc6.0rtti，如果不开启程序会崩溃而vc2008不需要，但是这个并不会实现程序的多态性，所以少用为妙！
pt->smart（）;
deletept;
break;
default:
cout<<"请输入0到2之间的数字：
";
}
if（quit）
{
break;
}
}
cout<<"程序结束！
"< return0;
}
vc6.0rtti
#include
usingnamespacestd;
classFather
{
public:
Father（）
{
cout<<"构造Father\n";
}
voidsmart（）
{
cout<<"父亲很聪明！
"< }
//virtualvoidbeatuerful（）{}
virtual~Father（）
{
cout<<"父亲被析构！
"< }
};
classMother
{
public:
Mother（）
{
cout<<"构造Mother\n";
}
virtualvoidbeatuerful（）
{
cout<<"母亲很漂亮"< }
virtual~Mother（）//如果不用虚函数那么将会引起程序崩溃
{
cout<<"析构Mother"< }
};
classSon:
publicFather,publicMother
{
public:
Son（）
{
cout<<"构造Son\n";
}
voidbeatuerful（）
{
cout<<"儿子也很帅"< }
~Son（）
{
cout<<"儿子被析构！
"< }
};
intmain（）
{
Father*pt;
Mother*pm;
intChoice=0;
while（Choice<99）
{
boolquit=false;
cout<<"（0）退出
（1）父亲
（2）儿子：
";
cin>>Choice;
switch（Choice）
{
case0:
quit=true;
break;
case1:
pt=newFather;
// pt->beatuerful（）;
break;
case2:
pm=newSon;
pm->beatuerful（）;
//pt->smart（）;
deletepm;
break;
default:
cout<<"请输入0到2之间的数字：
";
}
if（quit）
{
break;
}
}
cout<<"程序结束！
"< return0;
}//我们也可以使用多重继承，这样可以不需要dynamic_cast就可以实现多态性。
#include
usingnamespacestd;
classHuman//我们定义一个最高级别的类这种也被称为抽象类，可以叫做ADT，但是这个抽象类并不是真正的因为真正的是虚函数是不会有任何功能的，真正的抽象类是必须具备一个或者一个以上没有任何功能的虚函数，这个虚函数的存在仅仅是为了让子类来继承并具体化功能。
所以，我们把这个叫做模拟抽象类
{
public:
Human（）
{
cout<<"构造human\n";
}
virtualvoidsmart（）{}
virtualvoidbeatuerful（）{}
virtual~Human（）
{
cout<<"析构HUMAN"< }
};
classFather:
virtualpublicHuman//虚基类。
下同，如果不使用这个，那么程序无法使用，因为会产生两异性，下面的son他不知道是哪个的
{
public:
Father（）
{
cout<<"构造Father\n";
}
virtualvoidsmart（）
{
cout<<"父亲很聪明！
"< }
//virtualvoidbeatuerful（）{}
virtual~Father（）
{
cout<<"父亲被析构！
"< }
};
classMother:
virtualpublicHuman
{
public:
Mother（）
{
cout<<"构造Mother\n";
}
virtualvoidbeatuerful（）
{
cout<<"母亲很漂亮"< }
virtual~Mother（）
{
cout<<"析构Mother"< }
};
classSon:
publicFather,publicMother
{
public:
Son（）
{
cout<<"构造Son\n";
}
virtualvoidbeatuerful（）
{
cout<<"儿子也很帅"< }
virtual~Son（）
{
cout<<"儿子被析构！
"< }
};
intmain（）
{
Human*p;
intChoice=0;
while（Choice<99）
{
boolquit=false;
cout<<"（0）退出
（1）父亲
（2）儿子：
";
cin>>Choice;
switch（Choice）
{
case0:
quit=true;
break;
case1:
p=newFather;
p->smart（）;
deletep;
break;
case2:
p=newSon;
p->beatuerful（）;
p->smart（）;
deletep;
break;
case3:
p=newMother;
p->beatuerful（）;
deletep;
break;
default:
cout<<"请输入0到2之间的数字：
";
break;
}
if（quit）
{
break;
}
}
cout<<"程序结束！
"< return0;
}
#include
usingnamespacestd;
classHuman//需要注意的是这个类中定义的纯虚函数仅仅是为派生类提供的一个接口，他只是一个抽象的类，所以我们不能为他定义对象，比如下面p=newhumanp->smart（）就是会报错就好像你把书中写的电视机让他实现真实存在的电视机一样播放影片，除非你能让照片中的飞机飞上天！
！
{
public:
Human（）
{
cout<<"构造human\n";
}
virtualvoidsmart（）=0;//只要为这个函数赋值为0 就是纯虚函数。
但是纯虚函数需要每个派生的类都必须要把他实例化才能运行不然会报错，也就是为每个子类添加纯虚函数的功能，这个就是纯虚函数，你不用能直接调用它因为他是抽象的，他只有被子类集成过来并且赋予了新功能才能被调用！
一个类可以有多个纯虚函数，包括有纯虚函数的类叫做抽象类，他不是上一节的模拟抽象类！
virtualvoidbeatuerful（）=0;
virtual~Human（）
{
cout<<"析构HUMAN"< }
};
classFather:
virtualpublicHuman
{
public:
Father（）
{
cout<<"构造Father\n";
}
virtualvoidbeatuerful（）
{
cout<<"父亲不是很帅\n";
}
virtualvoidsmart（）
{
cout<<"父亲很聪明！
"< }
//virtualvoidbeatuerful（）{}
virtual~Father（）
{
cout<<"父亲被析构！
"< }
};
classMother:
virtualpublicHuman
{
public:
Mother（）
{
cout<<"构造Mother\n";
}
virtualvoidsmart（）
{
cout<<"Mother并不聪明\n";
}
virtualvoidbeatuerful（）
{
cout<<"母亲很漂亮"< }
virtual~Mother（）
{
cout<<"析构Mother"< }
};
classSon:
publicFather,publicMother
{
public:
Son（）
{
cout<<"构造Son\n";
}
virtualvoidbeatuerful（）
{
cout<<"儿子也很帅"< }
virtualvoidsmart（）
{
cout<<"儿子很聪明\n";
}
virtual~Son（）
{
cout<<"儿子被析构！
"< }
};
intmain（）
{
Human*p;//虽然我们不能给抽象类定义对象，但是我们可以定义一个抽象类的指针，这样我们可以在程序运行时动态的指向抽象类的子类而实现其继承的功能，这就是多态性的好处
intChoice=0;
while（Choice<99）
{
boolquit=false;
cout<<"（0）退出
（1）父亲
（2）儿子：
";
cin>>Choice;
switch（Choice）
{
case0:
quit=true;
break;
case1:
p=newFather;
p->smart（）;
p->beatuerful（）;
deletep;
break;
case2:
p=newSon;
p->beatuerful（）;
p->smart（）;
deletep;
break;
case3:
p=newMother;
p->beatuerful（）;
p->smart（）;
deletep;
break;
default:
cout<<"请输入0到2之间的数字：
";
break;
}
if（quit）
{
break;
}
}
cout<<"程序结束！
"< return0;
}
抽象类的实际应用：
#include
usingnamespacestd;
classSharp//抽象类
{
public:
virtualdoublearea（）=0;
};
classTrigon:
publicSharp//求三角形面积
{
protected:
doubleH,W;
public:
Trigon（doubleh,doublew）//带参数的构造函数
{
H=h;
W=w;
}
doublearea（）//返回面积
{
returnH*W/2;
}
};
classSquare:
publicTrigon//正方形
{
public:
Square（doubleh,doublew）:
Trigon（h,w）{}//这里是构造函数有两个参数并且这两个参数传递给基类的构造函数。
已知，基类的构造函数会把参数传递给其保护乘员，所以下面这个计算原面积的函数可以是使用基类的保护程序来做返回！
而不需要在定义保护类乘员
doublearea（）
{
returnH*W;
}
};
classCircle:
publicSharp//圆形
{
protected:
doubleradius;//半径
public:
Circle（doubler）
{
radius=r;
}
doublearea（）
{
returnradius*radius*3.14;
}
};
intmain（）
{
Sharp*p;
while
（1）
{
intchoice;
boolquit=false;
cout<<"（0）退出
（1）三角
（2）正方（3）圆形：
";
cin>>choice;
switch（choice）
{
case0:
quit=true;
break;
case1:
p=newTrigon（5.0,6.0）;
cout<<"三角的面积为：
"<area（）< break;
case2:
p=newSquare（70.0,72.0）;
cout<<"正方的面积为：
"<area（）< break;
case3:
p=newCircle（43.2）;
cout<<"圆形的面积为：
"<area（）< break;
default:
cout<<"请输入0-3的数：
";
break;
}
if（choice<4&&choice>0）
{
deletep;
}
if（quit）
{
break;
}
}
}
复杂的抽象结构：
#include
usingnamespacestd;
classAnimal
{
public:
Animal（int）;
virtual~Animal（）
{
cout<<"Animal被析构\n";
}
virtualintGetAge（）
{
returnItsage;
}
virtualvoidSleep（）=0;
virtualvoidPropagate（）=0;
virtualvoidMove（）=0;
virtualvoidBoby（）=0;
virtualvoidEat（）=0;
virtualvoidShow（）=0;
private:
intItsage;
};
Animal:
:
Animal（intAge）:
Itsage（Age）
{
cout<<"创建构造函数年龄...\n";
}
classMammalia:
publicAnimal
{
public:
Mammalia（intAge）:
Animal（Age）
{
cout<<"创建哺乳类...\n";
}
virtualvoidPropagate（）
{
cout<<"哺乳类动物考胚胎繁育后台\n";
}
virtual~Mammalia（）
{
cout<<"
升级会员 