#include <iostream.h>

　　　　void func();
int n=1; //全局变量

　　　　void main()
{
static int a; // 静态局部变量
int b= -10; // 局部变量
cout <<"a:" <<a
<<" b:" <<b
<<" n:" <<n <<endl;
b+=4;
func();
cout <<"a:" <<a
<<" b:" <<b
<<" n:" <<n <<endl;
n+=10;
func();
}

　　　　void func()
{
static int a=2; // 静态局部变量
int b=5; // 局部变量
a+=2;
n+=12;
b+=5;
cout <<"a:" <<a
<<" b:" <<b
<<" n:" <<n <<endl;
}

　　运行结果为：
　　　　a:0 b:-10 n:l
a:4 b:10 n:13
a:0 b:-6 n:13
a:6 b:10 n:35
程序中主函数main()两次调用了func()函数，从运行结果可以看出，程序控制每次进入func()函数时，局部变量b都被初始化。而静态局部 变量a仅在第一次调用时被初始化，第二次进入该函数时，不再进行初始化，这时它的值是第一次调用后的结果值4。 main()函数中的变量a和b与func()函数中的变量a和b空间位置是不一样的，所以相应的值也不一样。关于变量作用域和可见性的进一步讨论见第6 章。
静态局部变量的用途有许多：可以使用它确定某函数是否被调用过。使用它保留多次调用的值。

对静态局部变量的说明：
(1) 静态局部变量在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，存储在动态存储区空间(而不是静态存储区空间)，函数调用结束后即释放。
(2) 为静态局部变量赋初值是在编译时进行值的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的 值。而为自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。

(3) 如果在定义局部变量时不赋初值的话，对静态局部变量来说，编译时自动赋初值0(对数值型变量)或空字符(对字符型变量)。而对自动变量来说，如果不赋初 值，则它的值是一个不确定的值。这是由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的。
(4) 虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的，也就是说，在其他函数中它是“不可见”的。

变量作用域和存储类别：

了解了基本的变量类型后，我们要进一步了解它的存储类别和变量作用域问题。

换一个角度

extern型的存储变量在处理多文件问题时常能用到，在一个文件中定义extern型的变量即说明这个变量用的是其他文件的。顺便说一下，笔者在做课设时遇到out of memory的错误，于是改成做多文件，再把它include进来（注意自己写的*.h要用“”不用<>），能起到一定的效用。static型的在读程序写结果的试题中是个考点。多数时候整个程序会出现多个定义的变量在不同的函数中，考查在不同位置同一变量的值是多少。主要是遵循一个原则，只要本函数内没有定义的变量就用全局变量（而不是main里的），全局变量和局部变量重名时局部变量起作用，当然还要注意静态与自动变量的区别。

函数：

对于函数最基本的理解是从那个叫main的单词开始的，一开始总会觉得把语句一并写在main里不是挺好的么，为什么偏择出去。其实这是因为对函数还不够熟练，否则函数的运用会给我们编程带来极大的便利。我们要知道函数的返回值类型，参数的类型，以及调用函数时的形式。事先的函数说明也能起到一个提醒的好作用。所谓形参和实参，即在调用函数时写在括号里的就是实参，函数本身用的就是形参，在画流程图时用平行四边形表示传参。

函数的另一个应用例子就是递归了，笔者开始比较头疼的问题，反应总是比较迟钝，按照老师的方法，把递归的过程耐心准确的逐级画出来，学习的效果还是比较好的，会觉得这种递归的运用是挺巧的，事实上，著名的八皇后、汉诺塔等问题都用到了递归。

数组：

分为一维数组和多维数组，其存储方式画为表格的话就会一目了然，其实就是把相同类型的变量有序的放在一起。因此，在处理比较多的数据时（这也是大多数的情况）数组的应用范围是非常广的。

具体的实际应用不便举例，而且绝大多数是与指针相结合的，笔者个人认为学习数组在更大程度上是为学习指针做一个铺垫。作为基础的基础要明白几种基本操作：即数组赋值、打印、排序（冒泡排序法和选择排序法）、查找。这些都不可避免的用到循环，如果觉得反应不过来，可以先一点点的把循环展开，就会越来越熟悉，以后自己编写一个功能的时候就会先找出内在规律，较好的运用了。另外数组做参数时，一维的[]里可以是空的，二维的第一个[]里可以是空的但是第二个[]中必须规定大小。

相关常用的算法还有判断回文，求阶乘，Fibanacci数列，任意进制转换，杨辉三角形计算等等。

字符串：

字符串其实就是一个数组（指针），在scanf的输入列中是不需要在前面加“&”符号的，因为字符数组名本身即代表地址。值得注意的是字符串末尾的‘\0’，如果没有的话，字符串很有可能会不正常的打印。另外就是字符串的定义和赋值问题了，笔者有一次的比较综合的上机作业就是字符串打印老是乱码，上上下下找了一圈问题，最后发现是因为

而不是

前者没有说明指向哪儿，更没有确定大小，导致了乱码的错误，印象挺深刻的。

另外，字符串的赋值也是需要注意的，如果是用字符指针的话，既可以定义的时候赋初值，即

也可以在赋值语句中赋值，即

但如果是用字符数组的话，就只能在定义时整体赋初值，即char a[5]={"abcd"};而不能在赋值语句中整体赋值。

常用字符串函数列表如下，要会自己实现：

注：对字符串是不允许做==或！=的运算的，只能用字符串比较函数

指针：

指针可以说是C语言中最关键的地方了，其实这个“指针”的名字对于这个概念的理解是十分形象的。首先要知道，指针变量的值（即指针变量中存放的值）是指针（即地址）。指针变量定义形式中：基本类型 *指针变量名 中的“*”代表的是这是一个指向该基本类型的指针变量，而不是内容的意思。在以后使用的时候，如*ptr=a时，“*”才表示ptr所指向的地址里放的内容是a。

指针比较典型又简单的一应用例子是两数互换，看下面的程序，

这是不能实现a和b的数值互换的，实际上只是形参在这个函数中换来换去，对实参没什么影响。现在，用指针类型的数据做为参数的话，更改如下：

这样在swap中就把p1,p2 的内容给换了，即把a，b的值互换了。

指针可以执行增、减运算，结合++运算符的法则，我们可以看到:

指针和数组实际上几乎是一样的，数组名可以看成是一个常量指针，一维数组中ptr=&b[0]则下面的表示法是等价的：

a[3]等价于*(a+3)
ptr[3]等价于*(ptr+3)

下面看一个用指针来自己实现atoi（字符串型->整型）函数：

指向多维数组的指针变量也是一个比较广泛的运用。例如数组a[3][4]，a代表的实际是整个二维数组的首地址，即第0行的首地址，也就是一个指针变量。而a+1就不是简单的在数值上加上1了，它代表的不是a[0][1]，而是第1行的首地址，&a[1][0]。

指针变量常用的用途还有把指针作为参数传递给其他函数，即指向函数的指针。
看下面的几行代码：

总之，指针的应用是非常灵活和广泛的，不是三言两语能说完的，上面几个小例子只是个引子，实际编程中，会逐渐发现运用指针所能带来的便利和高效率。

文件：

注：以上用于文本文件的操作，如果是二进制文件就在上述字母后加“b”。

我们用文件最大的目的就是能让数据保存下来。因此在要用文件中数据的时候，就是要把数据读到一个结构（一般保存数据多用结构，便于管理）中去，再对结构进行操作即可。例如，文件aa.data中存储的是30个学生的成绩等信息，要遍历这些信息，对其进行成绩输出、排序、查找等工作时，我们就把这些信息先读入到一个结构数组中，再对这个数组进行操作。如下例：

链表：
链表是C语言中另外一个难点。牵扯到结点、动态分配空间等等。用结构作为链表的结点是非常适合的，例如：

其中next是指向自身所在结构类型的指针，这样就可以把一个个结点相连，构成链表。

链表结构的一大优势就是动态分配存储，不会像数组一样必须在定义时确定大小，造成不必要的浪费。用malloc和free函数即可实现开辟和释放存储单元。其中，malloc的参数多用sizeof运算符计算得到。

链表的基本操作有：正、反向建立链表；输出链表；删除链表中结点；在链表中插入结点等等，都是要熟练掌握的，初学者通过画图的方式能比较形象地理解建立、插入等实现的过程。

逆向建立：

用递归实现链表逆序输出：

插入结点（已有升序的链表）：

删除结点：

经常有链表相关的程序填空题，做这样的题要注意看下面提到的变量是否定义了，用到的变量是否赋初值了，是否有给分配空间的没有分配空间，最后看看返回值是否正确。

笔者水平有限，难免有疏漏、错误的地方，浅显之处，还望指正见谅。上述内容仅是个提示作用，并不包括C语言的全部内容。

看了 **的 想到的
tekyDec 29, 2005 -  Show original item

看完后.明白**讲的为什么char** 不能自动转化为 const char**,(原文)但对我影响最深的是下面的话:

==================================================================
char *p="abc" 能不能编译通过要看你使用的编译器。鉴于大量遗留代码的存在，大部分编译器允许其通过，或者给个警告。当然，程序员自己必须保证绝不去修改其值。

程序员不应该在代码中出现*p='A'这样的语句。这是当初约定好了的：编译器允许char *p="abc"通过，而程序员保证不去修改它。
b. *p='A'编译时应该允许通过，因为单就这条语句而言，它完全合法。
c. 运行时*p='A'能不能通过要看实际的运行环境，包括你使用的操作系统、编译器、编译器选项 等等，一句话，其运行结果由不得你，且不应该由你去关心，因为这种行为本身已经违反约定了。
==================================================================

工作关系吧,用CString 和string用的太多了,很少这样定义字符串 char *p=“abcde“了
匝一看,还不适应,:(,渐渐的回想才想起一些来(哎,还是太生疏,赶快写下来,以后别忘了)

这样定义的字符串char *p=“abcde“ ; char *p1=“123445667“;

正如上面提到的是不能再 *p='A',运行的时候会出错,同样,strcpy(p,p1)也会出错哟,

"abcde"字符串可以看做是个常量字符串了,是不能被修改的,

但如果 char p[]=“abcde“ 这样定义,就没有问题,你可以修改*p='A',只要不越界就ok.

并且发现这样两种定义
char *p=“abcde“

char p[]=“abcde“

在运行的时候,p指向的地址也不是一样的,可见char *p=“abcde“还是有特殊的处理 :),具体怎么处理就不知道了,高手请指教:)

pstr=(char *)malloc(strlen(ibuf)+1);
strcpy(pstr,ibuf);
for(i=0,pt=strtok(pstr,ChrSet);pt!=NULL;i++,pt=strtok(NULL,ChrSet))
{
 if(i>=num||pt==NULL) break;
}
strcpy(tmp,pt);
free(pstr);
return(tmp);
}

例：
char *pt;
char buf[]="324324324|234324324|23432432432|23432432432|33333";
pt=GetField(buf,"|",3);

static void addArray(char *buff, char array[][MQ_ARRAY_LEN])
{
  

    int index = 0;
    int i=0;

    char *pt,*pstr;
    char * ChrSet= ",";

    pstr=(char *)malloc(strlen(buff)+1);
    pstr = strcpy( pstr, buff);
    for(i=0,pt=strtok(pstr,ChrSet); pt!=NULL; i++, pt=strtok(NULL,ChrSet))
    {
        if(pt==NULL) break;
      //  printf("dealing ... %s\n", pt);
        strcpy(array[index],pt);
        index++;
    }
    free(pstr);

}

作者:宋宝华   更新日期:2005-07-22

作者:宋宝华   更新日期:2005-07-22

图1 主画面

图2 切换到设置XX画面

作者:宋宝华   更新日期:2005-07-22

图1 菜单范例

图2 经典的Hello,World!

作者:宋宝华   更新日期:2005-07-22

图1 CPU与NVRAM地址线连接

作者:宋宝华   更新日期:2005-07-22

C语言嵌入式系统编程修炼之一:背景篇

作者:宋宝华   更新日期:2005-08-30
来源:yesky.com   

图1 系统硬件架构

图2 交叉开发环境

六年前，我刚热恋“面向对象”（Object-Oriented）时，一口气记住了近十个定义。六年后，我从几十万行程序中滚爬出来准备写点心得体会时，却无法解释什么是“面向对象”，就象说不清楚什么是数学那样。软件工程中的时髦术语“面向对象分析”和“面向对象设计”，通常是针对“需求分析”和“系统设计”环节的。“面向对象”有几大学派，就象如来佛、上帝和真主用各自的方式定义了这个世界，并留下一堆经书来解释这个世界。

有些学者建议这样找“对象”：分析一个句子的语法，找出名词和动词，名词就是对象，动词则是对象的方法（即函数）。

当年国民党的文人为了对抗毛泽东的《沁园春·雪》，特意请清朝遗老们写了一些对仗工整的诗，请蒋介石过目。老蒋看了气得大骂：“娘希匹，全都有一股棺材里腐尸的气味。”我看了几千页的软件工程资料，终于发现自己有些“弱智”，无法理解“面向对象”的理论，同时醒悟到“编程是硬道理。”

面向对象程序设计语言很多，如Smalltalk、Ada、Eiffel、Object Pascal、Visual Basic、C++等等。C++语言最讨人喜欢，因为它兼容C 语言，并且具备C 语言的性能。近几年，一种叫Java 的纯面向对象语言红极一时，不少人叫喊着要用Java 革C++的命。我认为Java 好比是C++的外甥，虽然不是直接遗传的，但也几分象样。外甥在舅舅身上玩耍时洒了一泡尿，俩人不该为此而争吵。

关于C++程序设计的书藉非常多，本章不讲C++的语法，只讲一些小小的编程道理。如果我能早几年明白这些小道理，就可以大大改善数十万行程序的质量了。

1. C++面向对象程序设计的重要概念

早期革命影片里有这样一个角色，他说：“我是党代表，我代表党，我就是党。”后来他给同志们带来了灾难。

会用C++的程序员一定懂得面向对象程序设计吗？

不会用C++的程序员一定不懂得面向对象程序设计吗？

两者都未必。就象坏蛋入党后未必能成为好人，好人不入党未必变成坏蛋那样。

我不怕触犯众怒地说句大话：“C++没有高手，C 语言才有高手。”在用C 和C++编程8年之后，我深深地遗憾自己不是C 语言的高手，更遗憾没有人点拨我如何进行面向对象程序设计。我和很多C++程序员一样，在享用到C++语法的好处时便以为自己已经明白了面向对象程序设计。就象挤掉牙膏卖牙膏皮那样，真是暴殄天物呀。

人们不懂拼音也会讲普通话，如果懂得拼音则会把普通话讲得更好。不懂面向对象程序设计也可以用C++编程，如果懂得面向对象程序设计则会把C++程序编得更好。本节讲述三个非常基础的概念：“类与对象”、“继承与组合”、“虚函数与多态”。理解这些概念，有助于提高程序的质量，特别是提高“可复用性”与“可扩充性”。

1.1 类与对象

对象（Object）是类（Class）的一个实例（Instance）。如果将对象比作房子，那么类就是房子的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。类可以将数据和函数封装在一起，其中函数表示了类的行为（或称服务）。类提供关键字public、protected 和private 用于声明哪些数据和函数是公有的、受保护的或者是私有的。

这样可以达到信息隐藏的目的，即让类仅仅公开必须要让外界知道的内容，而隐藏其它一切内容。我们不可以滥用类的封装功能，不要把它当成火锅，什么东西都往里扔。

类的设计是以数据为中心，还是以行为为中心？

主张“以数据为中心”的那一派人关注类的内部数据结构，他们习惯上将private 类型的数据写在前面，而将public 类型的函数写在后面，如表8.1(a)所示。

主张“以行为为中心”的那一派人关注类应该提供什么样的服务和接口，他们习惯上将public 类型的函数写在前面，而将private 类型的数据写在后面，如表8.1(b)所示。

很多C++教课书主张在设计类时“以数据为中心”。我坚持并且建议读者在设计类时“以行为为中心”，即首先考虑类应该提供什么样的函数。Microsoft 公司的COM 规范的核心是接口设计，COM 的接口就相当于类的公有函数[Rogerson 1999]。在程序设计方面，咱们不要怀疑Microsoft 公司的风格。

设计孤立的类是比较容易的，难的是正确设计基类及其派生类。因为有些程序员搞不清楚“继承”（Inheritance）、“组合”（Composition）、“多态”（ Polymorphism）这些概念。

1.2 继承与组合

如果A 是基类，B 是A 的派生类，那么B 将继承A 的数据和函数。示例程序如下：

class A

{

public:

void Func1(void);

void Func2(void);

};

class B : public A

{

public:

void Func3(void);

void Func4(void);

};

// Example

main()

{

B b; // B的一个对象

b.Func1(); // B 从A 继承了函数Func1

b.Func2(); // B 从A 继承了函数Func2

b.Func3();

b.Func4();

}

这个简单的示例程序说明了一个事实：C++的“继承”特性可以提高程序的可复用性。正因为“继承”太有用、太容易用，才要防止乱用“继承”。我们要给“继承”立一些使用规则：

一、如果类A 和类B 毫不相关，不可以为了使B 的功能更多些而让B 继承A 的功能。

不要觉得“不吃白不吃”，让一个好端端的健壮青年无缘无故地吃人参补身体。

二、如果类B 有必要使用A 的功能，则要分两种情况考虑：

（1）若在逻辑上B 是A 的“一种”（a kind of ），则允许B 继承A 的功能。如男人（Man）是人（Human）的一种，男孩（Boy）是男人的一种。那么类Man 可以从类Human 派生，类Boy 可以从类Man 派生。示例程序如下：

class Human

{

…

};

class Man : public Human

{

…

};

class Boy : public Man

{

…

};

（2）若在逻辑上A 是B 的“一部分”（a part of），则不允许B 继承A 的功能，而是要用A和其它东西组合出B。例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head 应该由类Eye、Nose、Mouth、Ear 组合而成，不是派生而成。示例程序如下：

class Eye

{

public:

void Look(void);

};

class Nose

{

public:

void Smell(void);

};

class Mouth

{

public:

void Eat(void);

};

class Ear

{

public:

void Listen(void);

};

// 正确的设计，冗长的程序

class Head

{

public:

void Look(void) { m_eye.Look(); }

void Smell(void) { m_nose.Smell(); }

void Eat(void) { m_mouth.Eat(); }

void Listen(void) { m_ear.Listen(); }

private:

Eye m_eye;

Nose m_nose;

Mouth m_mouth;

Ear m_ear;

};

如果允许Head 从Eye、Nose、Mouth、Ear 派生而成，那么Head 将自动具有Look、Smell、Eat、Listen 这些功能：

// 错误的设计

class Head : public Eye, public Nose, public Mouth, public Ear

{

};

上述程序十分简短并且运行正确，但是这种设计却是错误的。很多程序员经不起“继承”的诱惑而犯下设计错误。

一只公鸡使劲地追打一只刚下了蛋的母鸡，你知道为什么吗？

因为母鸡下了鸭蛋。

本书3.3 节讲过“运行正确”的程序不见得就是高质量的程序，此处就是一个例证。

1.3 虚函数与多态

除了继承外，C++的另一个优良特性是支持多态，即允许将派生类的对象当作基类的对象使用。如果A 是基类，B 和C 是A 的派生类，多态函数Test 的参数是A 的 指针。那么Test 函数可以引用A、B、C 的对象。示例程序如下：

class A

{

public:

void Func1(void);

};

void Test(A *a)

{

a->Func1();

}

class B : public A

{

…

};

class C : public A

{

…

};

// Example

main()

{

A a;

B b;

C c;

Test(&a);

Test(&b);

Test(&c);

};

以上程序看不出“多态”有什么价值，加上虚函数和抽象基类后，“多态”的威力就显示出来了。

C++用关键字virtual 来声明一个函数为虚函数，派生类的虚函数将（override）基类对应的虚函数的功能。示例程序如下：

class A

{

public:

virtual void Func1(void){ cout<< “This is A::Func1 \n”}

};

void Test(A *a)

{

a->Func1();

}

class B : public A

{

public:

virtual void Func1(void){ cout<< “This is B::Func1 \n”}

};

class C : public A

{

public:

virtual void Func1(void){ cout<< “This is C::Func1 \n”}

};

// Example

main()

{

A a;

B b;

C c;

Test(&a); // 输出This is A::Func1

Test(&b); // 输出This is B::Func1

Test(&c); // 输出This is C::Func1

};

如果基类A 定义如下：

class A

{

public:

virtual void Func1(void)=0;

};

那么函数Func1 叫作纯虚函数，含有纯虚函数的类叫作抽象基类。抽象基类只管定义纯虚函数的形式，具体的功能由派生类实现。

结合“抽象基类”和“多态”有如下突出优点：

（1）应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。这一

招叫“以不变应万变”，可以大大提高程序的可复用性（这是接口设计的复用，而不是代码实现的复用）。

（2）派生类的功能可以被基类指针引用，这叫向后兼容，可以提高程序的可扩充性和可维护性。以前写的程序可以被将来写的程序调用不足为奇，但是将来写的程序可以被以前写的程序调用那可了不起。

2 良好的编程风格

内功深厚的武林高手出招往往平淡无奇。同理，编程高手也不会用奇门怪招写程序。良好的编程风格是产生高质量程序的前提。

2.1 命名约定

有不少人编程时用拼音给函数或变量命名，这样做并不能说明你很爱国，却会让用此程序的人迷糊（很多南方人不懂拼音，我就不懂）。程序中的英文一般不会太复杂，用词要力求准确。匈牙利命名法是Microsoft 公司倡导的[Maguire 1993]，虽然很烦琐，但用习惯了也就成了自然。没有人强迫你采用何种命名法，但有一点应该做到：自己的程序命名必须一致。

以下是我编程时采用的命名约定：

（1）宏定义用大写字母加下划线表示，如MAX_LENGTH；

（2）函数用大写字母开头的单词组合而成，如SetName, GetName ；

（3）指针变量加前缀p，如*pNode ；

（4）BOOL 变量加前缀b，如bFlag ；

（5）int 变量加前缀i，如iWidth ；

（6）float 变量加前缀f，如fWidth ；

（7）double 变量加前缀d，如dWidth ；

（8）字符串变量加前缀str，如strName ；

（9）枚举变量加前缀e，如eDrawMode ；

（10）类的成员变量加前缀m_，如m_strName, m_iWidth ；

对于int, float, double 型的变量，如果变量名的含义十分明显，则不加前缀，避免烦琐。如用于循环的int 型变量i,j,k ；float 型的三维坐标（x,y,z）等。

2.2 使用断言

程序一般分为Debug 版本和Release 版本，Debug 版本用于内部调试，Release 版本发行给用户使用。断言assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。以下是一个内存复制程序，在运行过程中，如果assert 的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。

//复制不重叠的内存块

void memcpy(void *pvTo, void *pvFrom, size_t size)

{

void *pbTo = (byte *) pvTo;

void *pbFrom = (byte *) pvFrom;

assert( pvTo != NULL && pvFrom != NULL );

while(size - - > 0 )

*pbTo + + = *pbFrom + + ;

return (pvTo);

}

assert 不是一个仓促拼凑起来的宏，为了不在程序的Debug 版本和Release 版本引起差别，assert 不应该产生任何副作用。所以assert 不是函数，而是宏。程序员可以把assert 看成一个在任何系统状态下都可以安全使用的无害测试手段。

很少有比跟踪到程序的断言，却不知道该断言的作用更让人沮丧的事了。你化了很多时间，不是为了排除错误，而只是为了弄清楚这个错误到底是什么。有的时候，程序员偶尔还会设计出有错误的断言。所以如果搞不清楚断言检查的是什么，就很难判断错误是出现在程序中，还是出现在断言中。幸运的是这个问题很好解决，只要加上清晰的注释即可。这本是显而易见的事情，可是很少有程序员这样做。这好比一个人在森林里，看到树上钉着一块“危险”的大牌子。但危险到底是什么？树要倒？有废井？有野兽？除非告诉人们“危险”是什么，否则这个警告牌难以起到积极有效的作用。难以理解的断言常常被程序员忽略，甚至被删除。[Maguire 1993]

以下是使用断言的几个原则：

（1）使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。

（2）使用断言对函数的参数进行确认。

（3）在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”一旦确定了的

假定，就要使用断言对假定进行检查。

（4）一般教科书都鼓励程序员们进行防错性的程序设计，但要记住这种编程风格会隐瞒错误。当进行防错性编程时，如果“不可能发生”的事情的确发生了，则要使用断言进行报警。

2.3 new、delete 与指针

在C++中，操作符new 用于申请内存，操作符delete 用于释放内存。在C 语言中，函数malloc 用于申请内存，函数free 用于释放内 存。由于C++兼容C 语言，所以new、delete、malloc、free 都有可能一起使用。new 能比malloc 干更多的事，它可以申请对象的内存，而malloc 不能。C++和C 语言中的指针威猛无比，用错了会带来灾难。对于一个指针p，如果是用new申请的内存，则必须用delete 而不能用free 来释放。如果是用malloc 申请的内存，则必须用free 而不能用delete 来释放。在用delete 或用free 释放p 所指的内存后，应该马上显式地将p 置为NULL，以防下次使用p 时发生错误。示例程序如下：

void Test(void)

{

float *p;

p = new float[100];

if(p==NULL) return;

…// do something

delete p;

p=NULL; // 良好的编程风格

// 可以继续使用p

p = new float[500];

if(p==NULL) return;

…// do something else

delete p;

p=NULL;

}

我们还要预防“野指针”，“野指针”是指向“垃圾”内存的指针，主要成因有两种：

（1）指针没有初始化。

（2）指针指向已经释放的内存，这种情况最让人防不胜防，示例程序如下：

class A

{

public:

void Func(void){…}

};

void Test(void)

{

A *p;

{

A a;

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

}

p->Func(); // p 是“野指针”，程序出错

}

2.4 使用const

在定义一个常量时，const 比#define 更加灵活。用const 定义的常量含有数据类型，该常量可以参与逻辑运算。例如：

const int LENGTH = 100; // LENGTH 是int 类型

const float MAX=100; // MAX 是float 类型

#define LENGTH 100 // LENGTH 无类型

#define MAX 100 // MAX 无类型

除了能定义常量外，const 还有两个“保护”功能：

一、强制保护函数的参数值不发生变化

以下程序中，函数f 不会改变输入参数name 的值，但是函数g 和h 都有可能改变name的值。

void f(String s); // pass by value

void g(String &s); // pass by referance

void h(String *s); // pass by pointer

main()

{

String name=“Dog”;

f(name); // name 的值不会改变

g(name); // name 的值可能改变

h(name); // name 的值可能改变

}

对于一个函数而言，如果其‘&’或‘*’类型的参数只作输入用，不作输出用，那么应当在该参数前加上const，以确保函数的代码不会改变该参数的值（如果改变了该参数的值，编译器会出现错误警告）。因此上述程序中的函数g 和h 应该定义成：

void g(const String &s);

void h(const String *s);

二、强制保护类的成员函数不改变任何数据成员的值

以下程序中，类stack 的成员函数Count 仅用于计数，为了确保Count 不改变类中的任何数据成员的值，应将函数Count 定义成const 类型。

class Stack

{

public:

void push(int elem);

void pop(void);

int Count(void) const; // const 类型的函数

private:

int num;

int data[100];

};

int Stack::Count(void) const

{

++ num; // 编译错误，num 值发生变化

pop(); // 编译错误，pop 将改变成员变量的值

return num;

}

2.5 其它建议

（1）不要编写一条过分复杂的语句，紧凑的C++/C 代码并不见到能得到高效率的机器代码，却会降低程序的可理解性，程序出错误的几率也会提高。

（2）不要编写集多种功能于一身的函数，在函数的返回值中，不要将正常值和错误标志混在一起。

（3）不要将BOOL 值TRUE 和FALSE 对应于1 和0 进行编程。大多数编程语言将FALSE定义为0，任何非0 值都是TRUE。Visual C++将TRUE 定义为1，而Visual Basic 则将TRUE定义为-1。示例程序如下：

BOOL flag;

…

if(flag) { // do something } // 正确的用法

if(flag==TRUE) { // do something } // 危险的用法

if(flag==1) { // do something } // 危险的用法

if(!flag) { // do something } // 正确的用法

if(flag==FALSE) { // do something } // 不合理的用法

if(flag==0) { // do something } // 不合理的用法

（4）小心不要将“= =”写成“=”，编译器不会自动发现这种错误。

（5）不要将123 写成0123，后者是八进制的数值。

（6）将自己经常犯的编程错误记录下来，制成表格贴在计算机旁边。

3 小结

C++/C 程序设计如同少林寺的武功一样博大精深，我练了8 年，大概只学到二三成。所以无论什么时候，都不要觉得自己的编程水平天下第一，看到别人好的技术和风格，要虚心学习。本章的内容少得可怜，就象口渴时只给你一颗杨梅吃，你一定不过瘾。我借花献佛，推荐一本好书：Marshall P. Cline 著的《C++ FAQs》[Cline 1995]。你看了后一定会赞不绝口。会编写C++/C 程序，不要因此得意洋洋，这只是程序员基本的技能要求而已。如果把系统分析和系统设计比作“战略决策”，那么编程充其量只是“战术”。如果指挥官是个大笨蛋，士兵再勇敢也会吃败仗。所以我们程序员不要只把眼光盯在程序上，要让自己博学多才。我们应该向北京胡同里的小孩们学习，他们小小年纪就能指点江山，评论世界大事。

8.5.1名字空间定义
    namespace 开头，后面是名字空间的名字。

    namespace cplusplus_primer {
     class matrix {/*****/};
     void inverse(matrix &);
     matrix operator+(const matrix &m1,matrix &m2)
     {
      /******/
     }
     const double pi = 3.1416;
   
    }

    在名字空间cplusplus_primer中声明的类的名字是
    cplusplus_primer::matrix
    函数的名字是
    cplusplus_primer::inverse()
    常量的名字是
    cplusplus_primer::pi

    类，函数，常量被声明它的名字空间的名字限定修饰：
    这些名字被成为限定修饰符(qualified name)

    名字空间的定义不一定是连续的.例如
    namespace cplusplus_primer{
    class  matrix {/*****/}
    const double pi = 3.1416;

    }

    namespace cplusplus_primer{
    void inverse(matrix &);
    matrix operator+ (const matrix &m1,const matrix &m2)
        {/********/}
    }

    名字空间的定义可是非连续的，这对生成一个库很有帮助,它使我们更容易将库的源代码组织成
    接口和实现部分。

 8.5.2域操作符
     ::
     用户声明的名字空间成员名自动被加上前缀，名字空间名后面加上域操作符(::),名字空间成员名
     由该名字空间名进行限定修饰。

     名字空间成员的声明被隐藏在其名字空间中，除非我们为编译器指定查找的声明的名字空间,否则
     编译器将在当前域及嵌套包含当前域的域中查找该名字的声明。

     注意！！！
     域操作符也可以被用来引用全局名字空间的成员。因为全局名字空间没有名字。
     ::member_name
     指的是全局名字空间的成员。

     #include <iostream>
     const int max = 65000;
     const int lineLength = 12;

     void fibonacci(int max)
     {
        if (max <2) return;
 cout << "0 1";
 int v1 = 0,v2=1,cur;
 for (int ix=3;ix <= max;++ix)
 {
     cur = v1+v2;
     if(cur>::max) break;   //引用全局名字空间的变量；
     cout << cur <<"";
     v1=v2;
     v2=cur;
     if(ix % lineLength ==0) cout << endl;
 }
     }

8.5.3 嵌套名字空间
     
      。。。。。

8.6 使用名字空间成员

     使用限定修饰的名字形式namespace_name::member_name来引用名字空间，毫无疑问是非常麻烦的。

     using 声明，using指示符

8.6.1 名字空间别名
    
     namespace International_Business_Machines
     {/*********/}

     namespace IBM = International_Business_Machines;

8.6.2 using声明
   
    
      namespace cplusplus_primer
      {
        namespace MatrixLib
        {
         class matrix {/******/};
        }
      }

      
      using cplusplus::MatrixLib::matrix;
     

      using 声明引入的名字有以下特性：
       1> 它在该域中必须唯一。
       2> 由外围域中声明引入的相同名字被其隐藏。
       3> 它被嵌套域中的相同名字的声明隐藏。

       namespace blip {
        int bi = 16,bj = 15, bk = 23;

       }

       int bj = 0;

       void mainip()
       {
         using blip::bi;    //函数mainip()中的bi指向blip::bi
  ++bi;              //设置blip::bi为17
  using blip::bj     //隐藏全局域中的bj
  ++bj;
  int bk;            //bk在局部域中声明
  using blip:bk;     //错误:在mainip()中重复定义bk

       }

       int wrongInit = bk; //错误：bk在这里不可见

8.6.3 using 指示符

       namespace blip{
       int bi = 16,bj = 15, bk = 23;
       }

       int bj = 0;

       void mainip()
       {
         using namespace blip;

  ++bi;       //设置blip::bi为17;
  ++bj;        //错误：二义性
                 全局bj还是blip:bj?

         ++::bj;     // 设置全局bj为1  
  ++blip::bj; // 设置blip::bj为16
  int bk = 97; //局部bk隐藏blip:bk
  ++bk;        //设置局部bk为98

      
       }

当我们把一个应用程序移植到一个包装在名字空间中的新版本时，using指示符非常
有用，但是使用多个using指示符会引起全局名字空间污染问题。
用多个选择性的using声明来代替using指示符会使这个问题最小化，由多个using
声明引起的二义性的错误在声明点就能被检测到，因此建议使用using声明而不是
using指示符,以便更好地控制程序中地全局名字空间污染问题。
      

节选自《高质量C++编程指南》中的《内存管理》，并对其进行简单整理......

内存分配方式
---------------------------------------------------------------------------------------------

内存分配方式有三种：
---------------------------
（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。 例如全局变量static变量。
（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储 单元自动被释放。栈内存 分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

常见的内存错误及其对策
------------------------------------------------------------------------------------------
 发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。

常见的内存错误及其对策如下：

1>内存分配未成功，却使用了它。
------------------------------------------
 编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检 指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果  是用malloc或new来申请内存，应该用if(p==NULL) 或if(p=NULL)进行防错处理。

2>内存分配虽然成功，但是尚未初始化就引用它
------------------------------------------
 犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初 错误（例如数组）。
内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所 以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。

3>内存分配成功并且已经初始化，但操作越过了内存的边界。
------------------------------------------
 例如在使用数组时经常发生下标"多1"或者"少1"的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。

4>忘记了释放内存，造成内存泄露。
------------------------------------------
 含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。

5>释放了内存却继续使用它。
------------------------------------------
有三种情况：
（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
（2）函数的return语句写错了，注意不要返回指向"栈内存"的"指针"或者"引用"，因为该内存在函数体结束时被自动销毁。
（3）使用free或delete释放了内存后，没有将指针设置为NULL。导致产生"野指针"。

【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。
【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。
【规则3】避免数组或指针的下标越界，特别要当心发生"多1"或者"少1"操作。
【规则4】动态内存的申请与释放必须配对，防止内存泄漏。
【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生"野指针"。

------------------------------------------------------------------------------------
指针与数组的对比
-----------------
 C++/C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。
    
数组
-------------
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。

指针
--------------
指针可以随时指向任意类型的内存块，它的特征是"可变"，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。

下面以字符串为例比较指针与数组的特性。

1.修改内容
------------------------------------------
 示例1中，字符数组a的容量是6个字符，其内容为hello\0。a的内容可以改变，如a[0]= 'X'。
指针p指向常量字符串"world"（位于静态存储区，内容为world\0），常量字符串的内容是不可以被修改的。
从语法上看，编译器并不觉得语句p[0]= ‘X'有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。
 

 示例7-3-1 修改数组和指针的内容
   ------------------------------
   char a[] = "hello";
   a[0] = 'X';
   cout << a << endl;
   char *p = "world"; // 注意p指向常量字符串  
   p[0] = 'X';  // 编译器不能发现该错误cout << p << endl;
  

2.内容复制与比较
------------------------------------------
数组复制
--------
不能对数组名进行直接复制与比较。示例2中，若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。应该用标准库函数strcpy进行复制。同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。

指针复制
--------
语句p = a 并不能把a的内容复制指针p，而是把a的地址赋给了p。要想复制a的内容，可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制。同理，语句if(p==a) 比较的不是内容而是地址，应该用库函数strcmp来比较。

  示例2 数组和指针的内容复制与比较
  -----------------------------------
        // 数组...
  char a[] = "hello";
  char b[10];
  strcpy(b, a); //不能用b = a;
  if(strcmp(b, a) == 0) // 不能用  if (b == a)...
  // 指针...
  int len = strlen(a);
  char *p = (char *)malloc(sizeof(char)*(len+1));  
  strcpy(p,a); // 不要用 p = a;
  if(strcmp(p, a) == 0) // 不要用 if (p == a)...

3 计算内存容量
------------------------------------------
数组
----
用运算符sizeof可以计算出数组的容量（字节数）。
示例3中，sizeof(a)的值是12（注意别忘了'\0'）。

指针
----
指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，
相当于sizeof(char*)，而不是p所指的内存容量。

C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

注意
----
当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
示例3中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。
      
       示例3 计算数组和指针的内存容量
 -----------------------------
        char a[] = "hello world";
 char *p  = a; cout<< sizeof(a) << endl;// 12字节
 cout<< sizeof(p) << endl;// 4字节

 示例3（b） 数组退化为指针
 -----------------------------
 void Func(char a[100])
 {
  cout<< sizeof(a) << endl;// 4字节而不是100字节
   }

4指针参数是如何传递内存的？
------------------------------------------
如果函数的参数是一个指针，不要指望用该指针去申请动态内存。
示例4-1中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？

 示例4-1 试图用指针参数申请动态内存
 ----------------------------------
 void GetMemory(char *p, int num)
 {
  p = (char *)malloc(sizeof(char) * num);
 }
 void Test(void)
 {
  char *str = NULL;
  GetMemory(str, 100);// str 仍然为 NULL
  strcpy(str, "hello"); // 运行错误
 }

毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，
指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，
就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。
在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。
所以函数GetMemory并不能输出任何东西。
事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。

如果非得要用指针参数去申请内存，那么应该改用"指向指针的指针"，见示例4-2。

 示例4-2用指向指针的指针申请动态内存
 ------------------------------------
 void GetMemory2(char **p, int num)
 {
  *p = (char *)malloc(sizeof(char) * num);
 }
 void Test2(void)
 {
  char *str = NULL;
  GetMemory2(&str, 100); // 注意参数是 &str，而不是str
  strcpy(str, "hello");
  cout<< str << endl;
  free(str);
 }

由于"指向指针的指针"这个概念不容易理解，我们可以用函数返回值来传递动态内存。
这种方法更加简单，见示例4-3。

 示例4-3 用函数返回值来传递动态内存
 -----------------------------------
 char *GetMemory3(int num)
 {
  char *p = (char *)malloc(sizeof(char) * num);
  return p;
 }
 void Test3(void)
 {
  char *str = NULL;
  str = GetMemory3(100);
  strcpy(str,"hello");
  cout<< str << endl;
  free(str);
 }

用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。这里强调不要用return语句返回指向"栈内存"的指针，因为该内存在函数结束时自动消亡，见示例4-4。

 示例4-4 return语句返回指向"栈内存"的指针
 --------------------------------------------
 char *GetString(void)
 {
  char p[] = "hello world";
  return p;// 编译器将提出警告
 }
 void Test4(void)
 {
  char *str = NULL;str = GetString();// str 的内容是垃圾
  cout<< str << endl;
 }

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

如果把示例4-4改写成示例4-5，会怎么样？

 示例4-5 return语句返回常量字符串
 -----------------------------------
 char *GetString2(void)
 {
  char *p = "hello world";
  return p;
 }
 void Test5(void)
 {
  char *str = NULL;
  str = GetString2();
  cout<< str << endl;
 }

函数Test5运行虽然不会出错，但是函数GetString2的设计概念却是错误的。
因为GetString2内的"hello world"是常量字符串，位于静态存储区，它在程序生命期内恒定不变。
无论什么时候调用GetString2，它返回的始终是同一个"只读"的内存块。

5 free和delete把指针怎么啦？
------------------------------------------
别看free和delete的名字恶狠狠的（尤其是delete），
它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。
用调试器跟踪示例5，发现指针p被free以后其地址仍然不变（非NULL），
只是该地址对应的内存是垃圾，p成了"野指针"。
如果此时不把p设置为NULL，会让人误以为p是个合法的指针。
如果程序比较长，我们有时记不住p所指的内存是否已经被释放，
在继续使用p之前，通常会用语句if (p !=NULL)进行防错处理。
很遗憾，此时if语句起不到防错作用，因为即便p不是NULL指针，
它也不指向合法的内存块。

 示例5  p成为野指针
 --------------------
 char *p = (char *) malloc(100);
 strcpy(p, "hello");
 free(p);        // p 所指的内存被释放，但是p所指的地址仍然不变 ...
 if(p != NULL) // 没有起到防错作用
 {      strcpy(p, "world"); // 出错
 }

6 动态内存会被自动释放吗？
------------------------------------------
函数体内的局部变量在函数结束时自动消亡。很多人误以为示例6是正确的。
理由是p是局部的指针变量，它消亡的时候会让它所指的动态内存一起完蛋。这是错觉！

 示例7-6 试图让动态内存自动释放
 ------------------------------
 void Func(void)
 {
  char *p = (char *) malloc(100); // 动态内存会自动释放吗？
 }

 我们发现指针有一些"似是而非"的特征：
 ------------------------------------
（1）指针消亡了，并不表示它所指的内存会被自动释放。
（2）内存被释放了，并不表示指针会消亡或者成了NULL指针。
     这表明释放内存并不是一件可以草率对待的事。也许有人不服气，
     一定要找出可以草率行事的理由：
     如果程序终止了运行，一切指针都会消亡，动态内存会被操作系统回收。
     既然如此，在程序临终前，就可以不必释放内存、不必将指针设置为NULL了。
     终于可以偷懒而不会发生错误了吧？
 想得美。如果别人把那段程序取出来用到其它地方怎么办？

7 杜绝"野指针"
------------------------------------------
"野指针"不是NULL指针，是指向"垃圾"内存的指针。
人们一般不会错用NULL指针，因为用if语句很容易判断。
但是"野指针"是很危险的，if语句对它不起作用。

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

（1）指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，
它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，
要么将指针设置为NULL，要么让它指向合法的内存。例如
 char *p = NULL;
 char *str = (char *) malloc(100);

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

（3）指针操作超越了变量的作用范围。这种情况让人防不胜防，示例程序如下：
 class A
 {
 public:
  void Func(void){ cout << "Func of class A" << endl;
  }

 void Test(void)
 {
 A  *p;
 {
  A  a;
  p = &a; // 注意 a 的生命期
 }
  p->Func();// p是"野指针"
 }

函数Test在执行语句p->Func()时，对象a已经消失，而p是指向a的，所以p就成了"野指针"。
但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。

8 有了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如何实现对象的动态内存管理，见示例8。

 示例8 用malloc/free和new/delete如何实现对象的动态内存管理
 -------------------------------------------------------------
 class Obj
 {
 public :
  Obj(void){ cout << "Initialization" << endl; }
  ~Obj(void){cout << "Destroy" << endl; }
  void Initialize(void){ cout << "Initialization" << endl; }
  void    Destroy(void){ cout << "Destroy" << endl; }
 };
 void UseMallocFree(void)
 {
  Obj  *a = (obj *)malloc(sizeof(obj)); // 申请动态内存
  a->Initialize(); // 初始化
  a->Destroy(); // 清除工作
  free(a);// 释放内存
 }
 void UseNewDelete(void)
 {
  Obj  *a = new Obj;// 申请动态内存并且初始化
  delete a;// 清除并且释放内存
 }

类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也一样。

9 内存耗尽怎么办？
------------------------------------------
如果在申请动态内存时找不到足够大的内存块malloc和new将返回NULL指针，宣告内存申请失败。
通常有三种方式处理"内存耗尽"问题。

（1）判断指针是否为NULL，如果是则马上用return语句终止本函数。例如：
 void Func(void)
 {
  A  *a = new A;
  if(a == NULL)
  {
   return;
  }
 ...
 }

（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如：
 void Func(void)
 {
  A  *a = new A;
  if(a == NULL)
  {
   cout << "Memory Exhausted" << endl;
   exit(1);
  }
  ...
 }

（3）为new和malloc设置异常处理函数。

例如Visual C++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数，
也可以让malloc享用与new相同的异常处理函数。详细内容请参考C++使用手册。

上述（1）（2）方式使用最普遍。如果一个函数内有多处需要申请动态内存，
那么方式（1）就显得力不从心（释放内存很麻烦），应该用方式（2）来处理。

很多人不忍心用exit(1)，问："不编写出错处理程序，让操作系统自己解决行不行？"
不行。如果发生"内存耗尽"这样的事情，一般说来应用程序已经无药可救。
如果不用exit(1) 把坏程序杀死，它可能会害死操作系统。
道理如同：如果不把歹徒击毙，歹徒在老死之前会犯下更多的罪。

有一个很重要的现象要告诉大家。对于32位以上的应用程序而言
，无论怎样使用malloc与new，几乎不可能导致"内存耗尽"。
我在Windows 98下用Visual C++编写了测试程序，见示例9。
这个程序会无休止地运行下去，根本不会终止。
因为32位操作系统支持"虚存"，内存用完了，自动用硬盘空间顶替。
我只听到硬盘嘎吱嘎吱地响，Window 98已经累得对键盘、鼠标毫无反应。

我可以得出这么一个结论：对于32位以上的应用程序，"内存耗尽"错误处理程序毫无用处。这下可把Unix和Windows程序员们乐坏了：反正错误处理程序不起作用，我就不写了，省了很多麻烦。

我不想误导读者，必须强调：不加错误处理将导致程序的质量很差，千万不可因小失大。

  示例9试图耗尽操作系统的内存
  void main(void)
  {
   float *p = NULL;
   while(TRUE)
   { 
    p = new float[1000000]; 
    cout << "eat memory" << endl; 
    if(p==NULL) exit(1);
   }
  }

10 malloc/free 的使用要点
------------------------------------------
 函数malloc的原型如下：
  void * malloc(size_t size);
 用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 << sizeof(char) << endl;
cout << sizeof(int) << endl;
cout << sizeof(unsigned int) << endl;
cout << sizeof(long) << endl;
cout << sizeof(unsigned long) << endl;
cout << sizeof(float) << endl;
cout << sizeof(double) << endl;
cout << sizeof(void *) << endl;
 
在malloc的"()"中使用sizeof运算符是良好的风格，但要当心有时我们会昏了头，写出 p = malloc(sizeof(p))这样的程序来。

 函数free的原型如下：

void free( void * memblock );
 
为什么free函数不象malloc函数那样复杂呢？这是因为指针p的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p是NULL指针，那么free对p无论操作多少次都不会出问题。
如果p不是NULL指针，那么free对p连续操作两次就会导致程序运行错误。

11 new/delete 的使用要点
------------------------------------------
 
运算符new使用起来要比函数malloc简单得多，例如：
int  *p1 = (int *)malloc(sizeof(int) * length);
int  *p2 = new int[length];
这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，
new在创建动态对象的同时完成了初始化工作。
如果对象有多个构造函数，那么new的语句也可以有多种形式。
例如
class Obj
{
public :
 Obj(void);  // 无参数的构造函数
 Obj(int x);  // 带一个参数的构造函数
...
}
void Test(void)
{
 Obj  *a = new Obj;
 Obj  *b = new Obj(1); // 初值为1
 ...
 delete a;
 delete b;
}
如果用new创建对象数组，那么只能使用对象的无参数构造函数。例如
 Obj  *objects = new Obj[100]; // 创建100个动态对象
不能写成
 Obj  *objects = new Obj[100](1);// 创建100个动态对象的同时赋初值1
在用delete释放对象数组时，留意不要丢了符号‘[]'。例如
 delete []objects; // 正确的用法
delete objects; // 错误的用法
后者相当于delete objects[0]，漏掉了另外99个对象。

12 一些心得体会
------------------------------------------
（1）越是怕指针，就越要使用指针。不会正确使用指针，肯定算不上是合格的程序员。
（2）必须养成"使用调试器逐步跟踪程序"的习惯，只有这样才能发现问题的本质。

最后，说一句："呵呵，有点长，不知道大家有没有时间把它看完？"

auto　　static、　　register　　const 　　volatile 　　extern

(1)auto

　　这个这个关键字用于声明变量的生存期为自动，即将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。这个关键字不怎么多写，因为所有的变量默认就是auto的。

(2)register

　　这个关键字命令编译器尽可能的将变量存在CPU内部寄存器中而不是通过内存寻址访问以提高效率。

(3)static

　　常见的两种用途:
　　　　1>统计函数被调用的次数;
　　　　2>减少局部数组建立和赋值的开销.变量的建立和赋值是需要一定的处理器开销的，特别是数组等含有较多元素的存储类型。在一些含有较多的变量并且被经常调用的函数中，可以将一些数组声明为static类型，以减少建立或者初始化这些变量的开销.

　　详细说明:
　　　　1>、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。
　　　　2>、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。
　　　　3>当static用来修饰全局变量时，它就改变了全局变量的作用域，使其不能被别的程序extern，限制在了当前文件里，但是没有改变其存放位置，还是在全局静态储存区。

　　使用注意:
　　　　1>若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；
　　　　2>若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；
　　　　3>设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题(只要输入数据相同就应产生相同的输出)。

(4)const

　　被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。它可以修饰函数的参数、返回值，甚至函数的定义体。

　　作用:
　　　　1>修饰输入参数
　　　　　　a.对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。
　　　　　　b.对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。
　　　　2>用const修饰函数的返回值
　　　　　　a.如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。
　　　　　　　如对于： const char * GetString(void);
　　　　　　　如下语句将出现编译错误：
　　　　　　 　char *str = GetString();//cannot convert from 'const char *' to 'char *'；
　　　　　　　正确的用法是：
　　　　　　　const char *str = GetString();
　　　　　　b.如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值。 如不要把函数int GetInt(void) 写成const int GetInt(void)。
　　　　3>const成员函数的声明中，const关键字只能放在函数声明的尾部,表示该类成员不修改对象.

　　　说明：
　　　　const type m; //修饰m为不可改变
　　　示例：
　　　　typedef char * pStr; //新的类型pStr;
　　　　char string[4] = "abc";
　　　　const char *p1 = string；
　　　　p1++; //正确，上边修饰的是*p1,p1可变
　　　　const pStr p2 = string;
　　　　p2++; //错误，上边修饰的是p2，p2不可变,*p2可变
　　　同理，const修饰指针时用此原则判断就不会混淆了。
　　　　const int *value; //*value不可变，value可变
　　　　int* const value; //value不可变，*value可变
　　　　const (int *) value; //(int *)是一种type,value不可变,*value可变
　　　　　　　　　　　　　　//逻辑上这样理解，编译不能通过，需要tydef int* NewType;
　　　　const int* const value;//*value,value都不可变

(5)volatile

　　表明某个变量的值可能在外部被改变，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。它可以适用于基础类型如：int,char,long......也适用于C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，结构或者类的所有成员都会被视为volatile.
　　该关键字在多线程环境下经常使用，因为在编写多线程的程序时，同一个变量可能被多个线程修改，而程序通过该变量同步各个线程。
　　简单示例：
　　　DWORD __stdcall threadFunc(LPVOID signal)
　　　{
　　　　　int* intSignal=reinterpret_cast(signal);
　　　　　*intSignal=2;
　　　　　while(*intSignal!=1)
　　　　　sleep(1000);
　　　　　return 0;
　　　}
　　该线程启动时将intSignal 置为2，然后循环等待直到intSignal 为1 时退出。显然intSignal的值必须在外部被改变，否则该线程不会退出。但是实际运行的时候该线程却不会退出，即使在外部将它的值改为1，看一下对应的伪汇编代码就明白了：
　　　　　mov ax,signal
　　　　　label:
　　　　　if(ax!=1)
　　　　　goto label
　　对于C编译器来说，它并不知道这个值会被其他线程修改。自然就把它cache在寄存器里面。C 编译器是没有线程概念的,这时候就需要用到volatile。volatile 的本意是指：这个值可能会在当前线程外部被改变。也就是说，我们要在threadFunc中的intSignal前面加上volatile关键字，这时候，编译器知道该变量的值会在外部改变，因此每次访问该变量时会重新读取，所作的循环变为如下面伪码所示：
　　　　　label:
　　　　　mov ax,signal
　　　　　if(ax!=1)
　　　　　goto label

　　注意：一个参数既可以是const同时是volatile，是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

(6)extern

　　extern 意为“外来的”···它的作用在于告诉编译器：有这个变量，它可能不存在当前的文件中，但它肯定要存在于工程中的某一个源文件中或者一个Dll的输出中。

memset请教

 
作者：tianzhushan     发表时间：2002/09/03 09:08am
 
版主：
   请问：
   memset ,memcpy 和strcpy 的根本区别？
   我总觉得memset,memcpy 可以用strcpy等代替 
 

--------------------------------------------------------------------------------
此文章相关评论:
 
该文章有15个相关评论如下：(点这儿可以发表评论)
 
zhuhuix 发表于： 2002/09/03 09:14am
 
char str[100];
memset(str,0,100);
memcpy(str,"This is a",9);
strcpy(&str[9],"example!");
 
yuejw 发表于： 2002/09/03 09:14am
 
它们用处不同，但大部分情况下可以完成相同的要求。
memset用来对一段内存空间全部设置为某个字符。

memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象。

strcpy就只能拷贝字符串了，它遇到'\0'就结束拷贝。
 
 
HopeCao 发表于： 2002/09/03 10:02am
 
很详细！
 
tianzhushan 发表于： 2002/09/03 05:37pm
 
各位： 
   能否就这三者的最典型的应用各举一个例子。
   结合例子，说说他们的区别和联系，以及为什么用这个而不用另外一个。
   越详细越好。
   谢谢！
 
betydu 发表于： 2002/09/04 09:21am
 
对版主yuejw的补充
memset用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘ ’或‘\0’；例:char a[100];memset(a, '\0', sizeof(a));
memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度；例：char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a)，会造成b的内存地址溢出。

strcpy就只能拷贝字符串了，它遇到'\0'就结束拷贝；例：char a[100],b[50];strcpy(a,b);如用strcpy(b,a)，要注意a中的字符串长度（第一个‘\0’之前）是否超过50位，如超过，则会造成b的内存地址溢出。
 
 
iloveunix 发表于： 2002/09/04 04:56pm
 
补充：我的一点心得
memset可以方便的清空一个结构类型的变量或数组。
如：
struct sample_struct
{
 char   csName[16];
 int    iSeq;
 int    iType;
};

对于变量
struct sample_strcut  stTest;

一般情况下，清空stTest的方法：
stTest.csName[0]='\0';
stTest.iSeq=0;
stTest.iType=0;

用memset就非常方便：
memset(&stTest,0,sizeof(struct sample_struct));

如果是数组：
struct sample_struct   TEST[10];
则
memset(TEST,0,sizeof(struct sample_struct)*10);

 
 
zhtrue 发表于： 2002/09/04 05:06pm
 
对这个问题有疑问，不是对函数的疑问，而是因为没有弄懂mem和str的区别。
mem是一段内存，他的长度，必须你自己记住
str也是一段内存，不过它的长度，你不用记，随时都可以计算出来
所以memcpy需要第三个参数，而strcpy不需要
 
 
tianzhushan 发表于： 2002/09/05 06:19pm
 
谢谢各位的高见！小弟受益匪浅
 
凌曦 发表于： 2002/09/05 09:47pm
 
str也可以用用个参数的strncpy(a,b,n)
 
arbol 发表于： 2002/09/06 03:02pm
 
还有，记住memcpy是不拷贝最后的终止符的
 
编程浪子 发表于： 2002/09/12 00:58am
 
楼上的邮政老兄好像说错了吧？应该是strcpy不拷贝'\0'的，而memcpy应该是通吃，见着什么拷贝什么。
 
chrmhf 发表于： 2002/09/13 08:29am
 
memset主要应用是初始化某个内存空间。
memcpy是用于COPY源空间的数据到目的空间中。
strcpy用于字符串COPY,遇到‘\0’，将结束。
－－－－－－－－－－－－－－－－－－－－－－
如果你理解了这些，你应该知道他们的区别：例如你初始化某块空间的时候，用到memcpy
那么应该怎么写，是不是显得很笨。
int  m[100]
->memset((void*)m,0x00,sizeof(int)*100);//GOOD
..memcpy((void*)m,"\0\0\0\0....",sizeof(int)*100);//foolish
 
 
HopeCao 发表于： 2002/09/13 01:58pm
 
strcpy
 原型：extern char *strcpy(char *dest,char *src);
 用法：#include <string.h>
 功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
 说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
       返回指向dest的指针。
memcpy
 原型：extern void *memcpy(void *dest, void *src, unsigned int count);
 用法：#include <string.h>
 功能：由src所指内存区域复制count个字节到dest所指内存区域。
 说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。
memset
 原型：extern void *memset(void *buffer, int c, int count);
 用法：#include <string.h>
 功能：把buffer所指内存区域的前count个字节设置成字符c。
 说明：返回指向buffer的指针。
 
 
编程浪子 发表于： 2002/09/15 09:38pm
 
呵呵，各位都是高手，真是不厌其烦的谆谆教导啊！
 
 
obss 发表于： 2002/09/17 06:25pm
 
谢谢，有些收获
 
 
 

#include “filename.h”是指编译器将从当前工作目录上开始查找此文件

#include filename.h>是指编译器将从标准库目录中开始查找此文件

二、头文件的作用

加强安全检测

通过头文件可能方便地调用库功能，而不必关心其实现方式

三、* , &修饰符的位置

对于*和&修饰符，为了避免误解，最好将修饰符紧靠变量名

四、if语句

不要将布尔变量与任何值进行比较，那会很容易出错的。

整形变量必须要有类型相同的值进行比较

浮点变量最好少比点，就算要比也要有值进行限制

指针变量要和NULL进行比较，不要和布尔型和整形比较

五、const和#define的比较

const有数据类型，#define没有数据类型

个别编译器中const可以进行调试，#define不可以进行调试

在类中定义常量有两种方式

1、 在类在声明常量，但不赋值，在构造函数初始化表中进行赋值；

2、 用枚举代替const常量。

六、C++函数中值的传递方式

有三种方式：值传递(Pass by value)、指针传递(Pass by pointer)、引用传递(Pass by reference)

void fun(char c) //pass by value

void fun(char *str) //pass by pointer

void fun(char &str) //pass by reference

如果输入参数是以值传递的话，最好使用引用传递代替，因为引用传递省去了临时对象的构造和析构

函数的类型不能省略，就算没有也要加个void

七、函数体中的指针或引用常量不能被返回

Char *func(void)

{

char str[]=”Hello Word”;

//这个是不能被返回的，因为str是个指定变量，不是一般的值，函数结束后会被注销掉

return str;

}

函数体内的指针变量并不会随着函数的消亡而自动释放

八、一个内存拷贝函数的实现体

void *memcpy(void *pvTo,const void *pvFrom,size_t size)

{

assert((pvTo!=NULL)&&(pvFrom!=NULL));

byte *pbTo=(byte*)pvTo; //防止地址被改变

byte *pbFrom=(byte*)pvFrom;

while (size-- >0)

pbTo++ = pbForm++;

return pvTo;

}

九、内存的分配方式

分配方式有三种，请记住，说不定那天去面试的时候就会有人问你这问题

1、 静态存储区，是在程序编译时就已经分配好的，在整个运行期间都存在，如全局变量、常量。

2、 栈上分配，函数内的局部变量就是从这分配的，但分配的内存容易有限。

3、 堆上分配，也称动态分配，如我们用new,malloc分配内存，用delete,free来释放的内存。

十、内存分配的注意事项

用new或malloc分配内存时，必须要对此指针赋初值。

用delete 或free释放内存后，必须要将指针指向NULL

不能修改指向常量的指针数据

十一、内容复制与比较

//数组……

char a[]=”Hello Word!”;

char b[10];

strcpy(b,a);

if (strcmp(a,b)==0)

{}

//指针……

char a[]=”Hello Word!”;

char *p;

p=new char[strlen(a)+1];

strcpy(p,a);

if (strcmp(p,a)==0)

{}

十二、sizeof的问题

记住一点，C++无法知道指针所指对象的大小，指针的大小永远为4字节

char a[]=”Hello World!”

char *p=a;

count sizeof(a) end; //12字节

count sizeof(p) endl; //4字节

而且，在函数中，数组参数退化为指针，所以下面的内容永远输出为4

void fun(char a[1000])

{

count sizeof(a) endl; //输出4而不是1000

}

十三、关于指针

1、 指针创建时必须被初始化

2、 指针在free 或delete后必须置为NULL

3、 指针的长度都为4字节

４、释放内存时，如果是数组指针，必须要释放掉所有的内存，如

char *p=new char[100];

strcpy(p,”Hello World”);

delete []p; //注意前面的［］号

p=NULL;

５、数组指针的内容不能超过数组指针的最大容易。

如:

char *p=new char[5];

strcpy(p,”Hello World”); //报错 目标容易不够大

delete []p; //注意前面的［］号

p=NULL;

十四、关于malloc/free 和new /delete

l malloc/free 是C/C+的内存分配符，new /delete是C++的内存分配符。

l 注意：malloc/free是库函数，new/delete是运算符

l malloc/free不能执行构造函数与析构函数，而new/delete可以

l new/delete不能在C上运行，所以malloc/free不能被淘汰

l 两者都必须要成对使用

l C++中可以使用_set_new_hander函数来定义内存分配异常的处理

十五、Ｃ++的特性

Ｃ++新增加有重载(overload)，内联（inline），Const，Virtual四种机制

重载和内联：即可用于全局函数，也可用于类的成员函数；

Const和Virtual：只可用于类的成员函数；

重载：在同一类中，函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual关键字。和全局函数同名的函数不叫重载。如果在类中调用同名的全局函数，必须用全局引用符号::引用。

覆盖是指派生类函数覆盖基类函数

函数名相同；

参数相同；

基类函数必须有Virtual关键字；

不同的范围(派生类和基类)。

隐藏是指派生类屏蔽了基类的同名函数相同

1、 函数名相同，但参数不同，此时不论基类有无Virtual关键字，基类函数将被隐藏。

2、 函数名相同，参数也相同，但基类无Virtual关键字(有就是覆盖)，基类函数将被隐藏。

内联：inline关键字必须与定义体放在一起，而不是单单放在声明中。

Const：const是constant的缩写，“恒定不变”的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

1、 参数做输入用的指针型参数，加上const可防止被意外改动。

2、 按值引用的用户类型做输入参数时，最好将按值传递的改为引用传递，并加上const关键字，目的是为了提高效率。数据类型为内部类型的就没必要做这件事情；如：

将void Func(A a) 改为void Func(const A &a)。

而void func(int a)就没必要改成void func(const int &a);

3、 给返回值为指针类型的函数加上const，会使函数返回值不能被修改，赋给的变量也只能是const型变量。如：函数const char*GetString(void); char *str=GetString()将会出错。而const char *str=GetString()将是正确的。

4、 Const成员函数是指此函数体内只能调用Const成员变量，提高程序的键壮性。如声明函数 int GetCount(void) const;此函数体内就只能调用Const成员变量。

Virtual：虚函数：派生类可以覆盖掉的函数，纯虚函数：只是个空函数，没有函数实现体；

十六、extern“C”有什么作用？

Extern “C”是由Ｃ＋＋提供的一个连接交换指定符号，用于告诉Ｃ＋＋这段代码是Ｃ函数。这是因为C++编译后库中函数名会变得很长，与C生成的不一致，造成Ｃ＋＋不能直接调用C函数，加上extren “c”后，C++就能直接调用C函数了。

Extern “C”主要使用正规DLL函数的引用和导出 和 在C++包含C函数或C头文件时使用。使用时在前面加上extern “c” 关键字即可。

十七、构造函数与析构函数

派生类的构造函数应在初始化表里调用基类的构造函数；

派生类和基类的析构函数应加Virtual关键字。

不要小看构造函数和析构函数，其实编起来还是不容易。

#include iostream.h>

class Base

{

public:

virtual ~Base() { cout "~Base" endl ; }

};

class Derived : public Base

{

public:

virtual ~Derived() { cout "~Derived" endl ; }

};

void main(void)

{

Base * pB = new Derived; // upcast

delete pB;

}

输出结果为：

~Derived

~Base

如果析构函数不为虚，那么输出结果为

~Base

十八、#IFNDEF/#DEFINE/#ENDIF有什么作用

仿止该头文件被重复引用