C总结.docx

C总结.docx

《C总结.docx》由会员分享，可在线阅读，更多相关《C总结.docx（35页珍藏版）》请在冰豆网上搜索。

C总结

C++知识总结（多态，重载重写，函数指针，函数对象，虚函数等）

动态连接库的创建步骤：

　　一、创建Non-MFCDLL动态链接库

　　1、打开File—>New—>Project选项，选择Win32Dynamic-LinkLibrary—>sampleproject

　　—>工程名：

DllDemo

　　2、新建一个.h文件DllDemo.h

以下是引用片段：

　　#ifdef DllDemo_EXPORTS

　　#define DllAPI __declspec（dllexport）

　　#else

　　#define DllAPI __declspec（dllimport）

　　extern "C" //原样编译

　　{

　　DllAPI int __stdcall Max（int a,int b）; //__stdcall使非C/C++语言内能够调用API

　　}

　　#endif

　　3、在DllDemo.cpp文件中导入DllDemo.h文件,并实现Max（int,int）函数

以下是引用片段：

　　#include "DllDemo.h"

　　DllAPI int __stdcall Max（int a,int b）

　　{

　　if（a==b）

　　return NULL;

　　else if（a>b）

　　return a;

　　else

　　return b;

　　}

　　4、编译程序生成动态连接库

　　二、用.def文件创建动态连接库DllDemo.dll。

　　1、删除DllDemo工程中的DllDemo.h文件。

　　2、在DllDemo.cpp文件头，删除#includeDllDemo.h语句。

　　3、向该工程中加入一个文本文件，命名为DllDemo.def并写入如下语句：

　　LIBRARYMyDll

　　EXPORTS

　　Max@1

　　4、编译程序生成动态连接库。

动态链接的调用步骤：

　　一、隐式调用

　　1、建立DllCnslTest工程

　　2、将文件DllDemo.dll、DllDemo.lib拷贝到DllCnslTest工程所在的目录

　　3、在DllCnslTest.h中添加如下语句：

以下是引用片段：

　　#define DllAPI __declspec（dllimport）

　　#pragma comment（lib，"DllDemo.lib"） //在编辑器link时，链接到DllDemo.lib文件

　　extern "C"

　　{

　　DllAPI int __stdcall Max（int a,int b）;

　　}

　　4、在DllCnslTest.cpp文件中添加如下语句：

以下是引用片段：

　　#include "DllCnslTest.h"//或者 #include "DllDemo.h"

　　void main（）

　　{

　　int value;

　　value = Max（2,9）;

　　printf（"The Max value is %d\n",value）;

　　}

　　5、编译并生成应用程序DllCnslTest.exe

　　二、显式调用

　　1、建立DllWinTest工程

　　2、将文件DllDemo.dll拷贝到DllWinTest工程所在的目录或Windows系统目录下。

　　3、用vc/bin下的Dumpbin.exe的小程序，查看DLL文件（DllDemo.dll）中的函数结构。

　　4、使用类型定义关键字typedef，定义指向和DLL中相同的函数原型指针。

　　例：

以下是引用片段：

　　typedef int（*lpMax）（int a,int b）; //此语句可以放在.h文件中

　　5、通过LoadLibray（）将DLL加载到当前的应用程序中并返回当前DLL文件的句柄。

　　例：

以下是引用片段：

　　HINSTANCE hDll; //声明一个Dll实例文件句柄

　　hDll = LoadLibrary（"DllDemo.dll"）;//导入DllDemo.dll动态连接库

　　6、通过GetProcAddress（）函数获取导入到应用程序中的函数指针。

　　例：

以下是引用片段：

　　lpMax Max;

　　Max = （lpMax）GetProcAddress（hDLL,"Max"）;

　　int value;

　　value = Max（2,9）;

　　printf（"The Max value is %d",value）;

　　7、函数调用完毕后，使用FreeLibrary（）卸载DLL文件。

　　FreeLibrary（hDll）;

　　8、编译并生成应用程序DllWinTest.exe

　　注：

显式链接应用程序编译时不需要使用相应的Lib文件。

************重载与重写的区别

重载发生于同一个作用域内有两个或更多个函数具有相同的名字，但签名不同时。

函数的签名由它所声明的参数/形参的数目和类型构成。

当编译器在一个作用域内查找一个函数名时，发现不止一个函数具有该名字，它就会在该作用域的可用候选函数中，选择形参与函数调用中的实参有着最佳匹配的那一个函数。

重写发生于派生类函数和基类虚函数具有相同的名字和签名时。

在这种情况下，派生类函数的实现将会取代它所继承的积累函数的实现，以便满足对派生对象的虚拟调用。

重写机制改变类的行为而不是改变类的接口。

*****************const使用

1constdouble*cptr;//cptr是一个指向double类型的const对象的指针

 cptr本身不是常量，我们可以改变它的指向，但是不能改变它所指向的对象的值；

2const对象的地址只能付给，指向常量的指针，但一个指向常量的指针可以指向一个非常量，但是仍

然不能改变此非常量对象的值；

3在实际应用中，指向const的指针被用作函数的形式参数，它作为一个约定来保证，函数执行过程中

不会改变被传递给函数的实际对象的值。

4inttemp=90;

 int*constptemp=&temp;//ptemp是一个指向费常量对象的常量指针

*********************************************************************

*****************引用

1引用主要被用作函数的形式参数---通常将一个类对象传递给函数

2指针引用：

           int*pi;

           int*&ppi=pi;

3只有const引用可以用不同类型的对象初始化

　　　　　　doubledval=9.899;

           constint&ddval=dval;

******************字符串

错误！

未找到索引项。

C++提供两种字符串表示：

ｃ风格字符串和C++string类；

字符串被保存在字符数组中，通常用一个char*类型的指针来操控它；

标准ｃ库为操作ｃ风格字符串提供了一组函数：

intstrlen（constchar*）;//返回长度

intstrcmp（constchar*,constchar*）;//比较是否相等

char*strcpy（cosntchar*,constchar*）;//把第二个字符串拷贝到第一个字符串中

char*strcat（str1,str2）;//把２接到１后面

这些函数包括在：

include中

遍历ｃ字符串通过接触指针引用，空字符为false，非空为true

while（*str++）{}

1当我们使用一个指针时，在解除指针的引用之前，测试它是否指向某个对象是必要的：

if（str）{}

*******************内联函数

内联函数就是用本身的代码,替换函数的调用.

当代码复杂时,使用内联,会使程序目标代码体积过大,效率降低

当代码简单时,使用内联,会提高效率,比函数调用的效率要高.

inline只是对编译器的一个提示,编译器可以不理睬内联命令,编译器根据自身需要决定是否内联

*******************内存管理

1、内存分配方式

　　内存分配方式有三种：

（1）从静态存储区域分配。

内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。

例如全局变量，static变量。

（2）在栈上创建。

在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。

栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

　　（3）从堆上分配，亦称动态内存分配。

程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。

动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

2、常见的内存错误及其对策

 *内存分配未成功，却使用了它。

 *内存分配虽然成功，但是尚未初始化就引用它。

 *内存分配成功并且已经初始化，但操作越过了内存的边界。

　*忘记了释放内存，造成内存泄露。

　*释放了内存却继续使用它。

   【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。

防止使用指针值为NULL的内存。

　　【规则2】不要忘记为数组和动态内存赋初值。

防止将未被初始化的内存作为右值使用。

　　【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。

　　【规则4】动态内存的申请与释放必须配对，防止内存泄漏。

　　【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。

3、指针与数组的对比

　数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。

数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。

　　指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。

指针远比数组灵活，但也更危险。

4、指针参数是如何传递内存的？

　　如果函数的参数是一个指针，不要指望用该指针去申请动态内存。

示例7-4-1中，Test函数的语句GetMemory（str,200）并没有使str获得期望的内存，str依旧是NULL，为什么？

voidGetMemory（char*p,intnum）

{

　p=（char*）malloc（sizeof（char）*num）;

}

voidTest（void）

{

　char*str=NULL;

etMemory（str,100）;//str仍然为NULL

　strcpy（str,"hello"）;//运行错误

}　　　　　　示例4.1试图用指针参数申请动态内存

　　毛病出在函数GetMemory中。

编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是_p，编译器使_p=p。

如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。

这就是指针可以用作输出参数的原因。

在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。

所以函数GetMemory并不能输出任何东西。

事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。

如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，见示例4.2。

voidGetMemory2（char**p,intnum）

{

　*p=（char*）malloc（sizeof（char）*num）;

}

voidTest2（void）

{

　char*str=NULL;

GetMemory2（&str,100）;//注意参数是&str，而不是str

　strcpy（str,"hello"）;

　cout<

　free（str）;

}　　　　　　示例4.2用指向指针的指针申请动态内存

　　由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。

这种方法更加简单，见示例4.3。

char*GetMemory3（intnum）

{

　char*p=（char*）malloc（sizeof（char）*num）;

　returnp;

}

voidTest3（void）

{

　char*str=NULL;

　str=GetMemory3（100）;

　strcpy（str,"hello"）;

　cout<

　free（str）;

}　　　　　　　示例4.3用函数返回值来传递动态内存

　　用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。

这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡，见示例4.4。

char*GetString（void）

{

　charp[]="helloworld";

　returnp;//编译器将提出警告

}

voidTest4（void）

{

　char*str=NULL;

　str=GetString（）;//str的内容是垃圾

　cout<

}　　　　　　示例4.4return语句返回指向“栈内存”的指针

　　用调试器逐步跟踪Test4，发现执行str=GetString语句后str不再是NULL指针，但是str的内容不是“helloworld”而是垃圾。

如果把示例4.4改写成示例4.5，会怎么样？

char*GetString2（void）

{

　char*p="helloworld";

　returnp;

}

voidTest5（void）

{

　char*str=NULL;

　str=GetString2（）;

　cout<

}　　　　　示例4.5return语句返回常量字符串

　　函数Test5运行虽然不会出错，但是函数GetString2的设计概念却是错误的。

因为GetString2内的“helloworld”是常量字符串，位于静态存储区，它在程序生命期内恒定不变。

无论什么时候调用GetString2，它返回的始终是同一个“只读”的内存块。

5、杜绝“野指针”

　　“野指针”不是NULL指针，是指向“垃圾”内存的指针。

人们一般不会错用NULL指针，因为用if语句很容易判断。

但是“野指针”是很危险的，if语句对它不起作用。

“野指针”的成因主要有两种：

（1）指针变量没有被初始化。

任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。

所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。

例如char*p=NULL;

char*str=（char*）malloc（100）;　　

（2）指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。

　　（3）指针操作超越了变量的作用范围。

这种情况让人防不胜防，示例程序如下：

classA

{

　public:

　　voidFunc（void）{cout<<“FuncofclassA”<

};

voidTest（void）

{

　A*p;

　{

　　Aa;

　　p=&a;//注意a的生命期

　}

　p->Func（）;//p是“野指针”

}　　函数Test在执行语句p->Func（）时，对象a已经消失，而p是指向a的，所以p就成了“野指针”。

但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。

6、有了malloc/free为什么还要new/delete？

　　malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。

它们都可用于申请动态内存和释放内存。

　　对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。

对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。

由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。

　　因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。

注意new/delete不是库函数。

我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示例6。

classObj

{

　public:

　　Obj（void）{cout<<“Initialization”<

　　~Obj（void）{cout<<“Destroy”<

　　voidInitialize（void）{cout<<“Initialization”<

　　voidDestroy（void）{cout<<“Destroy”<

};

voidUseMallocFree（void）

{

　Obj*a=（obj*）malloc（sizeof（obj））;//申请动态内存

　a->Initialize（）;//初始化

　//…

　a->Destroy（）;//清除工作

　free（a）;//释放内存

}

voidUseNewDelete（void）

{

　Obj*a=newObj;//申请动态内存并且初始化

　//…

　deletea;//清除并且释放内存

}　　　　　示例6用malloc/free和new/delete如何实现对象的动态内存管理

　　类Obj的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。

函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完成初始化与清除工作。

函数UseNewDelete则简单得多。

　　所以我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。

由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。

　　既然new/delete的功能完全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？

这是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

　　如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。

如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。

所以new/delete必须配对使用，malloc/free也一样。

8、malloc/free的使用要点

　　函数malloc的原型如下：

void*malloc（size_tsize）;　　用malloc申请一块长度为length的整数类型的内存，程序如下：

int*p=（int*）malloc（sizeof（int）*length）;　　我们应当把注意力集中在两个要素上：

“类型转换”和“sizeof”。

　　*malloc返回值的类型是void*，所以在调用malloc时要显式地进行类型转换，将void*转换成所需要的指针类型。

　　*malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。

我们通常记不住int,float等数据类型的变量的确切字节数。

例如int变量在16位系统下是2个字节，在32位下是4个字节；而float变量在16位系统下是4个字节，在32位下也是4个字节。

最好用以下程序作一次测试：

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

　　*函数free的原型如下：

voidfree（void*memblock）;　　为什么free函数不象malloc函数那样复杂呢？

这是因为指针p的类型以及它所指的内存的容量事先都是知道的，语句free（p）能正确地释放内存。

如果p是NULL指针，那么free对p无论操作多少次都不会出问题。

如果p不是NULL指针，那么free对p连续操作两次就会导致程序运行错误。

9、new/delete的使用要点

　　运算符new使用起来要比函数malloc简单得多，例如：

int*p1=（int*）malloc（sizeof（int）*length）;

int*p2=newint[length];　　这是因为new内置了sizeof、类型转换和类型安全检查功能。

对于非内部数据类型的对象而言，new在创建动态对象的同时完成了初始化工作。

如果对象有多个构造函数，那么new的语句也可以有多种形式。

例如classObj

{

　public:

　　Obj（void）;//无参数的构造函数

　　Obj（intx）;//带一个参数的构造函数

　　…

}

voidTest（void）

{

　Obj*a=newObj;

　Obj*b=newObj

（1）;//初值为1

　…

　deletea;

　deleteb;

}　　如果用new创建对象数组，那么只能使用对象的无参数构造函数。

例如Obj*objects=newObj[100];//创建100个动态对象　　不能写成Obj*objects=newO