#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <string.h>
class Directory
{
public:
      // 静态公有的函数
      Directory()
      {
           strcpy(strTemp,"/测试");
           i=15;
      }
      static void setpath(char const *newpath);
      static void setname( Directory *dir);
      void getpath(char *oldpath);
      char strTemp [50];
      int i;
private:
      
      //静态字符串
      static char path [];
      
};
 
//静态数据成员的初始化
char Directory::path [199] = "/开始测试";
 
// 静态函数访问静态变量
void Directory::setpath(char const *newpath)
{
      printf("path=%s\n",path);
      strncpy(path, newpath, 199);
      printf("path=%s\n",path);
} 
//静态函数访问非静态变量
void Directory::setname(Directory *dir)
{
      dir->getpath("/静态函数访问非静态函数");
    dir->strTemp;//静态函数访问非静态变量
      return;
}
// 非静态函数访问静态变量
void Directory::getpath(char *oldpath)
{   
      strncpy(Directory::path,oldpath, 199);
      printf("Directory::path=%s\n",Directory::path);
} 
 
// 使用实例
void main()
{
      // 通过类名调用setpath()成员函数
    //Directory::setpath("/通过类名调用静态成员函数");
      
      //通过对象调用setpath()成员函数
      Directory dir;
      
      dir.setpath("/静态函数访问静态变量");
      dir.getpath("/非静态函数访问静态变量");
      Directory *dira;
      dir.setname(dira);
      
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/shuigsls/archive/2008/07/13/2645918.aspx

互斥（mutex）

互斥比较类似阻塞，关键在于互斥可以跨进程的线程同步，很多只允许应用程序运行一次的实例就是用互斥方法来实现的。互斥用到以下的API函数：
createMutex(), 创建互斥对象。
releaseMutex(), 解除互斥关系。

互斥的一般使用流程：
首先createMutex创建互斥对象，然后waitForSingleObject进入互斥环境，当用到同步的代码执行完成后，用releaseMutex解除互斥关系，当所有线程访问完后，调用
closeHandle方法释放互斥对象。

waitForSingleObject()函数来防止其它线程进入同步区域的代码。
function waitforsingleobject(hHandle: Thandle; dwMilliseconds: DWORD):   DWORD; stdcall;
这个函数可以使当前线程在dwmilliseconds指定的时间内睡眠，直到hHandle参数指定的对象进入发信号状态为止。一个互斥对象不再被线程拥有时，它就进入发信号状态
当一个进程要终止时，它就进入发信号状态。dwmilliseconds参数可以设为0，这意味着只检查hhandle参数指定的对象是否处理发信号状态，而后立即返回。dwmilliseconds参数设为INFINITE，表示如果信号不出现将一直等下去。

waitForSingeObject()使用的返回值及其含义：
WAIT ABANDONED
指定的对象是互斥对象，并且拥有这个互斥对象的线程在没有释放此对象之前就已终止。此时就称互斥对象被抛弃。这种情况下，这个互斥对象归当前线程所有，并把它设为不发信号状态。
WAIT OBJECT 0
指定的对象处于发信号状态
WAIT TIMEOUT
等待的时间已过，对象仍然是非发信号状态

当一个互斥对象不再被一个线程所拥有，它就处于发信号状态。此时首先调用waitForsingleobject()的线程就成为该互斥对象的拥有者，此互斥对象设为不发信号状态。当线程调用releaseMutex()并传递一个互斥对象的句柄作为参数时，这种拥有关系就被解除，互斥对象重新进入发信号状态。除waitforsingleobject()外，还可以使用waitformultipleobject()和msgwaitformultipleobject()，它们可以等待几个对象变为发信号状态。

信号量（semaphore）

另一种使线程同步的技术是使用信号量对象。它是在互斥的基础上建立的。但信号量增加了资源计数的功能，预定数目的线程允许同时进入要同步的代码。用
createSemaphore()来创建一个信号量对象，其声明如下：

function createsemaphore(lpSemaphoreAttributes: pSecurityAttributes;

lInitalCount, lMaximunCount: longint; lpName: pchar): Thandle; stdcall;

和createmutex()一样，createsemaphore()的第一个参数也是一个指向TsecurityAttributes记录的指针，此参数的缺少值可以设为nil。lInitialcount参数用来指定个信号量的初始计数
值，这个值必须在0和lMaximumcount之间。此参数大于0 ，就表示信号量处于发信号状态。当调用waitforsingleobject()时，此计数值就减1。当调用releasesemaphore()时，此计数值加1。参数lMaximumcount指定计数值的最大值。如果这个信号量代表某种资源，那么这个值代表可用资源总数。参数lpName用于给出信号量对象的名称。类似于createmutex()的lpName参数。

releaseSemaphore()的声明：

function releaseSemaphore(hsemaphore: Thandle; lreleasecount: longint;
lppreviouscount: pointer): bool; stdcall;

ireleasecount参数用于指定每次使计数值加多少。如果参数lppreviouscount不为nil，原有的计数值将存储在lppreviouscount里。信号量对象并不属于某个线程。记住，最后一定要调用colsehandle()来释放由createsemaphore()创建的信号量对象的句柄。

CSTI* ocsti = new CSTI();
delete ocsti; //程序崩掉

出现如下错误：

出现这个错误的原因一般都是操作new申请的内存溢出,因为在c++中,如果用new分配一段内存,操作的时候改变了该部分的大小,在delete时就会出错.比如说如下部分:

char* p=new char[5];
strcpy(p,"aaaaa");
delete[] p;

这段代码就会出错,因为申请了一个size为5的内存,但是strcpy过去了一个size为6的字符串,因此破坏了这个指针,运行debug版本的时候 就会出现先前的错误,但是在release版本中,溢出一个字节的内存很有可能是没有错误的,然后潜在的隐患是肯定存在的,因此,我们在debug遇到这样的错误时候一定要仔细检查对new出的指针的操作.

而我并未对申请的内存做任何操作就报内存溢出的错误，那么可能就是因为new时申请的内存太小，最后经验证发现是因为用的旧的头文件引起的错误，后来换新的头文件后就不在报错了。我试着把新、旧头文件申请的内存大小打出来比较，发现新的头文件果然比旧的内存要大。

这是在用别人提供的库时遇到的问题，所以在提供别人库时要看看头文件是否也有更新。

class a
{
public:
  static FunctionA()
  {
     menber = 1;
  }

private:
  int menber;
}

编译上述代码，出错。原因很简单大家都知道，静态成员函数不能访问非静态成员，这是因为静态函数属于类而不是属于整个对象，静态函数中的 member可能都没有分配内存。静态成员函数没有隐含的this自变量。所以，它就无法访问自己类的非静态成员。（看过一篇很好的文章《浅析C++中的this指针》介绍这个方面的详细内容）

那要想访问怎么办呢？地球人都知道只要将：

int menber;
//change the line above to:
static int menber;

class a
{
public:
  static FunctionA(a* _a)
  {
    a-> menber = 1;
  }

private:
  int menber;
}

HANDLE hMutex = CreateMutex(NULL, false, "Process");
         if (GetLastError() == ERROR_ALREADY_EXISTS)
         {
            CloseHandle(hMutex);
            MessageBox(Application->Handle, "程序已经在运行中，不能重复启动！", "提示", MB_OK +MB_ICONWARNING);
            Application->Terminate();
            return 0;
         }
         Application->CreateForm(__classid(TForm1), &Form1);

void *handle = FindWindow(NULL, WindowName.c_str()); 
if (handle!=NULL)
    return 0; 

进程的互斥运行

　　正常情况下，一个进程的运行一般是不会影响到其他正在运行的进程的。但是对于某些有特殊要求的如以独占方式使用串行口等硬件设备的程序就要求在其进程运行期间不允许其他试图使用此端口设备的程序运行的，而且此类程序通常也不允许运行同一个程序的多个实例。这就引出了进程互斥的问题。

　　实现进程互斥的核心思想比较简单：进程在启动时首先检查当前系统是否已经存在有此进程的实例，如果没有，进程将成功创建并设置标识实例已经存在的标记。此后再创建进程时将会通过该标记而知晓其实例已经存在，从而保证进程在系统中只能存在一个实例。具体可以采取内存映射文件、有名事件量、有名互斥量以及全局共享变量等多种方法来实现。下面就分别对其中具有代表性的有名互斥量和全局共享变量这两种方法进行介绍：

// 创建互斥量
HANDLE m_hMutex = CreateMutex(NULL, FALSE, "Sample07");
// 检查错误代码
if (GetLastError() == ERROR_ALREADY_EXISTS) {
　// 如果已有互斥量存在则释放句柄并复位互斥量
　CloseHandle(m_hMutex);
　m_hMutex = NULL;
　// 程序退出
　return FALSE;
}

上面这段代码演示了有名互斥量在进程互斥中的用法。代码的核心是CreateMutex（）对有名互斥量的创建。CreateMutex（）函数可用来创建一个有名或无名的互斥量对象，其函数原型为：

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针
　BOOL bInitialOwner, // 初始化互斥对象的所有者
　LPCTSTR lpName // 指向互斥对象名的指针
);

如果函数成功执行，将返回一个互斥量对象的句柄。如果在CreateMutex（）执行前已经存在有相同名字的互斥量，函数将返回这个已经存在互斥量的句柄，并且可以通过GetLastError（）得到错误代码ERROR_ALREADY_EXIST。可见，通过对错误代码ERROR_ALREADY_EXIST的检测可以实现CreateMutex（）对进程的互斥。

        建立互斥体，用来同步。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。

参数
lpMutexAttributes
指向一个SECURITY_ATTRIBUTES结构的指针，这个结构决定互斥体句柄是否被子进程继承。    
bInitialOwner
布尔类型，决定互斥体的创建者是否为拥有者
lpName
指向互斥体名字字符串的指针。互斥体可以有名字。
互斥体的好处是可以在进程间共享

心得体会：
    CreateMutex() 用于有独占要求的程序 (在其进程运行期间不允许其他使用此端口设备的程序运行，或不允许同名程序运行)。如有同名程序运行，则通过 GetLastError（）得到错误代码 ERROR_ALREADY_EXIST。

刚才又执行了下得出的结果（程序名samp）
       一般情况下：一进入调试阶段，进程管理器中就出现了samp进程，执行到CreateMutex时返回进程句柄，执行到if(GetLastError() == ERROR_ALREADY_EXISTS ) 进行判断时，跳过不执行if中的内容，所以表示没有互斥。
       调试之前先运行debug中的samp.exe再调试：一进入调试阶段，进程管理器中就出现了两个samp进程，执行到CreateMutex时返回进程句柄，执行到if(GetLastError() == ERROR_ALREADY_EXISTS ) 进行判断时，执行if中的内容，表示有互斥。

这里主要总结常用的5种排序，分别是快速排序，冒泡排序（也叫交换排序），选择排序，shell排序，插入排序。

下边分别介绍：

1快速排序，就是从一个序列中随意取一个数，然后对剩下的数进行分类，小的放到左边，大的放到右边。如此进行下去知道最后。N(n-1)/2.空间复杂度是o（n）.

2冒泡排序，就是从第一个数开始和后一个数比较，然后依情况交换，然后再用第二个和第三个比较交换，如此反复，直到最后一个。一直进行n轮就可以完成排序。

3选择排序，就是将一个序列中的最小的放到第一个，然后再将剩下的数据用相同的方式分别放到后一位。它的空间复杂度是O(1).

4shell排序，就是将有一定间隔的数进行排序，并且间隔变小，也就是开始是n/2,然后继续变小，一般都是以一半为标准，直到最后间隔只有1，也就完成了排序。需要的空间复杂度是O(1).

5插入排序，就比如平时玩的扑克排，一般整理排的时候需要将排排序，当你拿到一张新排的时候，就要比较左边和右边，只有在左右中间的那个值的时候才说明排序成功。它需要的空间复杂度也是O(1).

Ps:空间复杂度就是需要另外占用的空间。

以上排序中，只有快速排序是O（n），其他都是O（1），因为只有快速排序需要另外再起存储空间，而其他都是在原来空间中增加一个空间就可以。

区别：

1堆的容量比较大，栈的容量比较小。

2堆相当于一个全局变量，可以为各种函数使用，栈一般只是为函数内部使用。在建立了新的对象时，可以使用new，也可以直接classtype a；前者就是new，后者就是直接放到了栈中。

3 堆的变量可以动态分配和释放 不用了就放了 节约内存

栈的内存只有在函数结束后才释放。

2 通过单一指令调用不同函数，就是多态Polymorphism,"ability to asume many forms" 虚函数是c＋＋语言polymorphism性质以及动态联编的关键

3 既然抽象类中的虚函数不打算被调用，那么就把它设置成纯虚函数。

4 拥有纯虚函数者为抽象类。

5 抽象类不能产生出对象实体，但是我们可以拥有指向抽象类的指针，以便于操作抽象类的各个派生类。

6 虚函数派生下去仍是虚函数，可以不写virtual。

举例函数模块A，函数模块B，如果函数模块B中的某个函数b要在固定时间n调用函数A中的某个函数a。 这里首先明白哪个是回调函数，这里的函数a就是回调函数。

如果要完成这个任务，就要在函数模块B中增加一个函数，叫注册函数c，当时间满足了规定的n，就要调用A中的a， B中的注册函数c并不知道要执行什么操作，它只是负责在一定的时机调用函数a。

c函数一般存放了函数a的指针，以便调用，还有就是定时的时间参数。

这里需要注意几点：

1函数模块A和函数模块B必须在同一个物理地址块中，如果是在不同的物理地址的程序模块是不可以使用的。

2一般应用到定时的调用某个模块的函数

3被调用的函数a可以没有实现

举个例子，就是，买米a，老板b不在，你留电话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。导致产生"野指针"。

-------------------------------------------------------------------------

指针与数组的对比
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个对象。

char * change(int n, int base)
{
  char *p, *val;
  if(base<2||base>36)
   return NULL;
  val = (char *) malloc(40);
  if(!val)
   return NULL;
  p=val;
  while( n)
  {
   *p= (n%base)>9? n%base-10+'a':n%base+'0';
   n/=base;
   ++p;
  }

  reverse(val,p);
  *p='\0';
  ++p;
  return val;
}

 int main(int argc, char* argv[])
 {
  char * test;
  int n,base;
  while(cin>>n>>base)
  {
   test=change(n,base);
   if(test){
    cout<<"Change "<<n<<" to base "<<base<<" = "<<test<<endl;
    free(test);
   }
   else
    cout<<"Wrong input."<<endl;
  }
  return 0;
 }

死锁：

构成死锁的条件四个，缺一不可

1一个线程只能单独用一个资源

2正在使用的资源可以申请其他资源，同时自己的不会放开

3只有申请到其他资源，这个线程才会放开

4各个线程是循环状态，就是每个线程要按照一定的顺序申请，然后最后成为一个环。

原子操作：就是不可以有中断的操作

信号量:与pv有关，表示资源的分配和释放的情况。信号S，p则s－1，v则s＋1。s表示可以使用的进程的数目。如果s>0表示还有进程可以使用，调用p则分配了资源，那么s－1，s<0表示没有了资源可以使用，或者需要释放的资源。 调用v操作，表示释放的资源，因此s＋1。调用P操作测试消息是否到达，调用V操作发送消息。

都是设计到同步和互斥概念的东西。

临界区：就是在p（s）和v（s）之间的一种状态。

线程同步：

　使隶属于同一进程的各线程协调一致地工作称为线程的同步

1、CEvent(BOOL bInitiallyOwn=FALSE,
BOOL bManualReset=FALSE,
LPCTSTR lpszName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);

2、BOOL CEvent：：SetEvent();

3、BOOL CEvent：：ResetEvent();

CSemaphore (LONG lInitialCount=1,
LONG lMaxCount=1,
LPCTSTR pstrName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);

OOP object oriented programming
property         method
member variable,member function

encapsulation
enheritance
polymorphism
overloading

ellipse circle triangle rectangle square

virtual作用？
如果没有virtual，那么就继承了基类指针的性质，如果有virtual，那么就指向对

象的类型。虚函数正式为了对“如果以一个基类的指针指向一个派生类的对象，那么

通过该指针只能够调用基类所定义的成员函数”这条规则反其道而行的设计。

纯虚函数作用？
就是在基类中并不实现，但是为了在派生类中使用，就需要分配一个并不执行，但

是还需要继承的函数。就是纯虚函数 virtual function（）＝0；纯虚函数不需要

定义，在派生类中被重新定义。

什么是抽象类？
拥有虚函数的类。抽象类不能产生出对象实体，但是可以拥有指向抽象类的指针，

便于操作抽象类的各个派生类。
虚函数派生下去仍是虚函数，而且可以省略virtual。

虚函数到底有什么作用？
1如果你估计派生类会重新定义一个成员函数，那么你就把基类中的这个函数写成

virtual
2通过单一指令调用不同函数，就是多态Polymorphism,"ability to asume many

forms"
3虚函数是c＋＋语言polymorphism性质以及动态联编的关键
4既然抽象类中的虚函数不打算被调用，那么就把它设置成纯虚函数。
5拥有纯虚函数者为抽象类。
6抽象类不能产生出对象实体，但是我们可以拥有指向抽象类的指针，以便于操作抽

象类的各个派生类。
7虚函数派生下去仍是虚函数，可以不写virtual。

虚函数怎样工作？
在含有虚函数的类中，编译器会为它做出一个虚函数表，表中的每一个元素都指向

一个虚函数的地址。

什么是upcasting？
它是向上强制性类型转换。
class CMyDoc:public CDocument;
CMyDoc mydoc;

(CDocument)mydodc.func();(upcasting)
注意一般不用upcasting。

静态变量到底是什么？
static double m_rate;
static成员变量不属于对象的一部分，而是类的一部分，程序可以在没有诞生任何

对象的时候就处理此种成员变量，但首相你必须初始化它。
static成员变量的初始化不要安排到构造函数中，因为构造函数可以一再被调用；

也不要把初始化安排在头文件中，因为可能会被嵌入到许多地方。应该在类以外的

任何位置设定其初值。
static变量可以想象成一个全程变量。
static成员函数不需要借助任何对象，可以被调用执行，所以编译器不会为它暗加

一个this指针。因此static成员函数无法处理类中的non－static成员变量。
static的构造很析够就相当于全局变量，只是它会在全局函数之前析够。构造函数

和析够函数都是以函数为标志的。

error LINK2001：unresolved external symbol""();一般是因为没有初始化static

的值。

new的好处？
分配对象所需内存空间，并且引发构造函数的执行。

什么是RTTI?
RTTI Runtime Type Information 动态类型识别
就是知道程序执行过程中某个对象是属于那个类的。

什么是动态生成（Dynamic Creation）?

什么是异样处理(Exception Handling)?
使用三个expection保留字:
try:其后跟随一段以{}圈出的程序代码，exception将在那里被处理。（就是将要处

理的代码）
catch：其后{},里边是处理程序。（就是怎样处理了）
throw：用来产生一个exception。

什么是模板？
template，就是可以重复利用的架构。
template <class T>
T power(T base,int exponent);

这里的T就是可以随时改变的量。当然这里的T是类的意思，可以是系统定义的类，

也可以是自己定义的类。
这里注意对于，模板，两个对象如果都使用了同一个模板，在编译的时候是不知道

的，但是链接的时候，连接器就会将他们重复的部分去掉。标准的说就是 链接器会

把所有冗余的template码剔除。在Borland链接器里头称为smart技术。