The acronym IPARP stands for “Integrated Pattern Analysis, Recognition, and Prediction.” The toolbox was created in Matlab (version 5.2) to facilitate performance analysis common in data mining and automatic target recognition (ATR) applications. The toolbox provides an integrated, semi-automated environment in which ATR researchers can address various “what-if” questions in a straightforward and systematic manner. Some typical queries that can be answered by the toolbox are as follows:

q       How many features do I need for maximum ATR performance?

q       What classifier should I use for this particular problem?

q       Where is the point of diminishing returns?

q       What is the impact of data mismatch on data-mining performance?

q       Do data statistics change over time?

q       What is the performance-versus-cost trade-off if I substitute computationally expensive features with something less expensive using approximation algorithms?

q       Are there features that work consistently well across multiple environmental conditions?

q       Is in situ performance optimization necessary? If yes, what is the appropriate classifier/feature structure?

The toolbox is designed to reduce the algorithm-design time so that we can focus on more important and interesting aspects of algorithm design—finding innovative ways to solve challenging problems by quickly knowing what works, what doesn’t, and why. In short, the goal of designing this toolbox was to enable the user to rapidly optimize the performance of a complex ATR system.


ps: 最近写的一个报告中，涉及到了自动目标识别方面的知识，查了很多文献，感觉IPARP Toolbox能从整体上反映了我们的思想，有些不谋而合的感觉。For more details, http://www.killmine.com/OnlineManual/TechnologyOverview.htm

图6 建立一个非MFC DLL

　　在建立的工程中添加lib.h及lib.cpp文件，源代码如下：

/* 文件名：lib.h　*/

#ifndef LIB_H

#define LIB_H

extern "C" int __declspec(dllexport)add(int x, int y);

#endif


/* 文件名：lib.cpp　*/

#include "lib.h"

int add(int x, int y)

{

return x + y;

}

#include <stdio.h>

#include <windows.h>

typedef int(*lpAddFun)(int, int); //宏定义函数指针类型

int main(int argc, char *argv[])

{

HINSTANCE hDll; //DLL句柄

lpAddFun addFun; //函数指针

hDll = LoadLibrary("..\\Debug\\dllTest.dll");

if (hDll != NULL)

{

addFun = (lpAddFun)GetProcAddress(hDll, "add");

if (addFun != NULL)

{

int result = addFun(2, 3);

printf("%d", result);

}

FreeLibrary(hDll);

}

return 0;

}

; lib.def : 导出DLL函数

LIBRARY dllTest

EXPORTS

add @ 1

#pragma comment(lib,"dllTest.lib")

//.lib文件中仅仅是关于其对应DLL文件中函数的重定位信息

extern "C" __declspec(dllimport) add(int x,int y);

int main(int argc, char* argv[])

{

int result = add(2,3);

printf("%d",result);

return 0;

}

BOOL APIENTRY DllMain( HANDLE hModule,

DWORD ul_reason_for_call,

LPVOID lpReserved

)

{

switch (ul_reason_for_call)

{

case DLL_PROCESS_ATTACH:

printf("\nprocess attach of dll");

break;

case DLL_THREAD_ATTACH:

printf("\nthread attach of dll");

break;

case DLL_THREAD_DETACH:

printf("\nthread detach of dll");

break;

case DLL_PROCESS_DETACH:

printf("\nprocess detach of dll");

break;

}

return TRUE;

}

hDll = LoadLibrary("..\\Debug\\dllTest.dll");

if (hDll != NULL)

{

addFun = (lpAddFun)GetProcAddress(hDll, MAKEINTRESOURCE(1));

//MAKEINTRESOURCE直接使用导出文件中的序号

if (addFun != NULL)

{

int result = addFun(2, 3);

printf("\ncall add in dll:%d", result);

}

FreeLibrary(hDll);

}

#define MAKEINTRESOURCEA(i) (LPSTR)((DWORD)((WORD)(i)))

#define MAKEINTRESOURCEW(i) (LPWSTR)((DWORD)((WORD)(i)))

#ifdef UNICODE

#define MAKEINTRESOURCE MAKEINTRESOURCEW

#else

#define MAKEINTRESOURCE MAKEINTRESOURCEA

#define CALLBACK __stdcall //这就是传说中的回调函数

#define WINAPI __stdcall //这就是传说中的WINAPI

#define WINAPIV __cdecl

#define APIENTRY WINAPI //DllMain的入口就在这里

#define APIPRIVATE __stdcall

#define PASCAL __stdcall

int __stdcall add(int x, int y);

typedef int(__stdcall *lpAddFun)(int, int);

图7 调用约定不匹配时的运行错误

　　图8中的那段话实际上已经给出了错误的原因，即“This is usually a result of　…”。

　　单击此处下载__stdcall调用例子工程源代码附件。
4.6 DLL导出变量

　　DLL定义的全局变量可以被调用进程访问；DLL也可以访问调用进程的全局数据，我们来看看在应用工程中引用DLL中变量的例子（单击此处下载本工程附件）。

/* 文件名：lib.h　*/

#ifndef LIB_H

#define LIB_H

extern int dllGlobalVar;

#endif


/* 文件名：lib.cpp */

#include "lib.h"

#include <windows.h>


int dllGlobalVar;


BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)

{

switch (ul_reason_for_call)

{

case DLL_PROCESS_ATTACH:

dllGlobalVar = 100; //在dll被加载时，赋全局变量为100

break;

case DLL_THREAD_ATTACH:

case DLL_THREAD_DETACH:

case DLL_PROCESS_DETACH:

break;

}

return TRUE;

}


;文件名：lib.def

;在DLL中导出变量

LIBRARY "dllTest"

EXPORTS

dllGlobalVar CONSTANT

;或dllGlobalVar DATA

GetGlobalVar

　　从lib.h和lib.cpp中可以看出，全局变量在DLL中的定义和使用方法与一般的程序设计是一样的。若要导出某全局变量，我们需要在.def文件的EXPORTS后添加：

变量名　CONSTANT　　　//过时的方法

　　或

变量名　DATA　　　 　//VC++提示的新方法

在主函数中引用DLL中定义的全局变量：

#include <stdio.h>

#pragma comment(lib,"dllTest.lib")

extern int dllGlobalVar;

int main(int argc, char *argv[])

{

printf("%d ", *(int*)dllGlobalVar);

*(int*)dllGlobalVar = 1;

printf("%d ", *(int*)dllGlobalVar);


return 0;

}

　　特别要注意的是用extern int dllGlobalVar声明所导入的并不是DLL中全局变量本身，而是其地址，应用程序必须通过强制指针转换来使用DLL中的全局变量。这一点，从*(int*)dllGlobalVar可以看出。因此在采用这种方式引用DLL全局变量时，千万不要进行这样的赋值操作：

dllGlobalVar = 1;

　　其结果是dllGlobalVar指针的内容发生变化，程序中以后再也引用不到DLL中的全局变量了。

　　在应用工程中引用DLL中全局变量的一个更好方法是：

#include <stdio.h>

#pragma comment(lib,"dllTest.lib")

extern int _declspec(dllimport) dllGlobalVar; //用_declspec(dllimport)导入

int main(int argc, char *argv[])

{

printf("%d ", dllGlobalVar);

dllGlobalVar = 1; //这里就可以直接使用, 无须进行强制指针转换

printf("%d ", dllGlobalVar);

return 0;

}

　　通过_declspec(dllimport)方式导入的就是DLL中全局变量本身而不再是其地址了，笔者建议在一切可能的情况下都使用这种方式。
4.7 DLL导出类

　　DLL中定义的类可以在应用工程中使用。

　　下面的例子里，我们在DLL中定义了point和circle两个类，并在应用工程中引用了它们（单击此处下载本工程附件）。

//文件名：point.h，point类的声明

#ifndef POINT_H

#define POINT_H

#ifdef DLL_FILE

class _declspec(dllexport) point //导出类point

#else

class _declspec(dllimport) point //导入类point

#endif

{

public:

float y;

float x;

point();

point(float x_coordinate, float y_coordinate);

};

#endif


//文件名：point.cpp，point类的实现

#ifndef DLL_FILE

#define DLL_FILE

#endif

#include "point.h"

//类point的缺省构造函数

point::point()

{

x = 0.0;

y = 0.0;

}

//类point的构造函数

point::point(float x_coordinate, float y_coordinate)

{

x = x_coordinate;

y = y_coordinate;

}


//文件名：circle.h，circle类的声明

#ifndef CIRCLE_H

#define CIRCLE_H

#include "point.h"

#ifdef DLL_FILE

class _declspec(dllexport)circle //导出类circle

#else

class _declspec(dllimport)circle //导入类circle

#endif

{

public:

void SetCentre(const point ¢rePoint);

void SetRadius(float r);

float GetGirth();

float GetArea();

circle();

private:

float radius;

point centre;

};

#endif


//文件名：circle.cpp，circle类的实现

#ifndef DLL_FILE

#define DLL_FILE

#endif

#include "circle.h"

#define PI 3.1415926

//circle类的构造函数

circle::circle()

{

centre = point(0, 0);

radius = 0;

}

//得到圆的面积

float circle::GetArea()

{

return PI *radius * radius;

}

//得到圆的周长

float circle::GetGirth()

{

return 2 *PI * radius;

}

//设置圆心坐标

void circle::SetCentre(const point ¢rePoint)

{

centre = centrePoint;

}

//设置圆的半径

void circle::SetRadius(float r)

{

radius = r;

}

类的引用：

#include "..\circle.h"　　//包含类声明头文件

#pragma comment(lib,"dllTest.lib");


int main(int argc, char *argv[])

{

circle c;

point p(2.0, 2.0);

c.SetCentre(p);

c.SetRadius(1.0);

printf("area:%f girth:%f", c.GetArea(), c.GetGirth());


return 0;

}

　　从上述源代码可以看出，由于在DLL的类实现代码中定义了宏DLL_FILE，故在DLL的实现中所包含的类声明实际上为：

class _declspec(dllexport) point //导出类point

{

…

}

　　和

class _declspec(dllexport) circle //导出类circle

{

…

}

　　而在应用工程中没有定义DLL_FILE，故其包含point.h和circle.h后引入的类声明为：

class _declspec(dllimport) point //导入类point

{

…

}

　　和

class _declspec(dllimport) circle //导入类circle

{

…

}

不错，正是通过DLL中的

class _declspec(dllexport) class_name //导出类circle　

{

…

}

　　与应用程序中的

class _declspec(dllimport) class_name //导入类

{

…

}

　　匹对来完成类的导出和导入的！

　　我们往往通过在类的声明头文件中用一个宏来决定使其编译为class _declspec(dllexport) class_name还是class _declspec(dllimport) class_name版本，这样就不再需要两个头文件。本程序中使用的是：

#ifdef DLL_FILE

class _declspec(dllexport) class_name //导出类

#else

class _declspec(dllimport) class_name //导入类

#endif

　　实际上，在MFC DLL的讲解中，您将看到比这更简便的方法，而此处仅仅是为了说明_declspec(dllexport)与_declspec(dllimport)匹对的问题。

　　由此可见，应用工程中几乎可以看到DLL中的一切，包括函数、变量以及类，这就是DLL所要提供的强大能力。只要DLL释放这些接口，应用程序使用它就将如同使用本工程中的程序一样！

　　本章虽以VC++为平台讲解非MFC DLL，但是这些普遍的概念在其它语言及开发环境中也是相同的，其思维方式可以直接过渡。

第一种:调用C语言中有关文件处理的标准库函数。

第二种:直接调用操作系统提供的有关方面的功能。

所谓"文件"一般指存储在外部介质上数据的集合。

2 文件类型指针

Turbo C在stdio.h文件中有以下的文件类型声明:

typedef struct

{ short level;                    /*缓冲区"满"或"空"的程度*/

  unsigned flags;                 /*文件状态标志*/

  char fd;                       /*文件描述符*/

  unsigned char hold;             /*如无缓冲区不读取字符*/

  short        bsize;            /*级冲区的大小*/

  unsigned char *baffer;           /*数据缓冲区的位置*/

  unsigned ar    *curp;           /*指针，当前的指向*/

  unsigned     istemp;           /*临时文件，指示器*/

  short        token;            /*用于有效性检查*/

}FILE;

3 文件的打开和关闭

和其他高级语言一样，对文件读写之前应该"打开"该文件，在使用结束之后应关闭该文件。

一、文件的打开(fopen函数)

ANSI C规定了标准输入输出函数库，用fopen()函数来实现打开文件。fopen函数的调用方式通常为：

FILE *fp;

fp=fopen(文件名，使用文件方式);

例如：fp=fopen("al",nr");

它表示要打开名字为al的文件，使用文件方式为"读入"(r代表read，即读入),fopen函数带回指向al文件的指针并赋给fp，这样fp就和文件al相联系了，或者说，fp指向al文件。可以看出，在打开一个文件时，通知给编译系统以下3个信息:①需要打开的文件名，也就是准备访问的文件的名字。②使用文件的方式("读"还是"写"等)。③让哪一个指针变量指向被打开的文件。

说明:

(1)用"r"方式打开的文件只能用于向计算机输人而不能用作向该文件输出数据，而且该文件应该已经存在，不能用"r"方式打开一个并不存在的文件(即输入文件)，否则出错。

(2)用"w"方式打开的文件只能用于向该文件写数据(即输出文件)，而不能用来向计算机输入。如果原来不存在该文件，则在打开时新建立一个以指定的名字命名的文件。如果原来已存在一个以该文件名命名的文件，则在打开时将该文件删去，然后重新建立一个新文件。

(3)如果希望向文件末尾添加新的数据(不希望删除原有数据)，则应该用"a"方式打开。但此时该文件必须已存在，否则将得到出错信息。打开时，位置指针移到文件末尾。

(4)用"r+"、"w+"、"a+"方式打开的文件既可以用来输人数据，也可以用来输出数据。用"r+"方式时该文件应该已经存在，以便能向计算机输入数据。用"w+"方式则新建立一个文件，先向此文件写数据，然后可以读此文件中的数据。用"a+"方式打开的文件，原来的文件不被删去，位置指针移到文件末尾，可以添加，也可以读。

(5)如果不能实现"打开"的任务，fopen函数将会带回一个出错信息。出错的原因可能是用"r"方式打开一个并不存在的文件;磁盘出故障;磁盘己满无法建立新文件等。此时fopen函数将带回一个空指针值NULL(NULL在stdio.h文件中已被定义为0)。

    (6)用以上方式可以打开文本文件或二进制文件，这是ANSI C的规定，用同一种缓冲文件系统来处理文本文件和二进制文件。但目前使用的有些C编译系统可能不完全提供所有这些功能(例如有的只能用"r"、"w"、"a"方式)，有的C版本不用"r+"、"w+"、"a+"，而用"rw"、"wr"、"ar"等，请读者注意所用系统的规定。

(7)在向计算机输人文本文件时，将回车换行符转换为一个换行符，在输出时把换行符转换成为回车和换行两个字符。在用二进制文件时，不进行这种转换，在内存中的数据形式与输出到外部文件中的数据形式完全一致，一一对应。

(8)在程序开始运行时，系统自动打开3个标准文件:标准输入、标准输出、标准出错输出。

二、文件的关闭(fclose 函数)

fclose(文件指针);

例如：fclose(fp);

4   文件的读写

一、fputc函数和fgetc函数(putc函数和getc函数)

1. fputc函数

把一个字符写到磁盘文件上去。其一般调用形式为： 

fputc(ch,fp);

2. fgetc函数

从指定的文件读入一个字符，该文件必须是以读或读写方式打开的。fgetc函数的调用形式为：

ch=fgetc(fp);

如果想从一个磁盘文件顺序读入字符并在屏幕上显示出来，可以：

ch=fgetc(fp);

while(ch!=EOF)

   { putchar(ch);

     ch=fgetc(fp);

  }

如果想顺序读入一个二进制文件中的数据，可以用：

while(! feof(fp))

   {c=fgetc(fp);

   }

3. fputc和fgetc函数使用举例

例11.1 从键盘输入一些字符，逐个把它们送到磁盘上去，直到输入一个"#"为止。

#include <stdio.h>

main()

{ file*fp;

  char ch,filename[l0];

  scanf("%s"，filename);

  if((fp=fopen(filename，"w"))==NULL)

    {printf("cannot open file\n");

        exit(0);

       ch=getchar();

       while(ch!='#')

      {

         fputc(ch,fp);putchar(ch);

         ch=getchar();

      }

     fclose(fp);

    }

运行情况如下:

file1.c            (输入磁盘文件名)

computer and c#    (输入一个字符串)

computer and c     (输出一个字符串)

可以用DOS命令将file1.c文件中的内容打印出来;

C>type file.c

computer and c

证明了在file1.c 文件中已存入了"computer and c"的信息。

二、fread函数和fwrite函数

ANSI C标准提出设置两个函数(fread和fwrite)，用来读写一个数据块。它们的一般调用形式为：

fread(buffer,size,count,fp);

fwrite(buffer,size,count,fp);

其中：

buffer：是一个指针。对fread来说，它是读入数据的存放地址。对fwrite比来说，是要输出数据的地址(以上指的是起始地址)。

size：要读写的字节数。

count：要进行读写多少个size字节的数据项。

fp：文件型指针。

如果文件以二进制形式打开，用fread和fwrite函数就可以读写任何类型的信息，如：

fread(f,4,2,fp);

其中f是一个实型数组名。一个实型变量占4个字节。这个函数从fp所指向的文件读入2次(每次4个字节)数据，存储到数组f中。

如果有一个如下的结构体类型：

struct student_type

{char name[10];

   int num;

   int age;

  char addr[30];

}stud[40];

结构体数组stud有40个元素，每一个元素用来存放一个学生的数据(包括姓名、学号、年龄、地址)。假设学生的数据已存放在磁盘文件中，可以用下面的for语句和fread函数读入40个学生的数据：

for(i=0;i<40;i++)

fread(&stud[i],sizeof(struct student_type),l,fp);

同样，以下for语句和fwrite函数可以将内存中的学生数据输出到磁盘文件中去：

for(i=0;i<40,i++)

fwrite(&stud[i],sizeof(struct student_type),l,fp);

如果fread或fwrite调用成功，则函数返回值为count的值，即输人或输出数据项的完整个数。

11.4.3 fprintf函数和fscanf函数

它们的一般调用方式为：

fprintf(文件指针，格式字符串，输出表列);

fscanf(文件指针，格式字符串，输入表列);

例如：

fprintf(fp,"%d,%6.2f",i,t);

它的作用是将整型变量i和实型变量t的值按%d和%6.2f的格式输出到fp指向的文件上。

二、例子程序

这是一个前辈写的，非常详细
//main.cpp
  int a=0;    //全局初始化区
  char *p1;   //全局未初始化区
  main()
  {
   intb;栈
   char s[]="abc";   //栈
   char *p2;         //栈
   char *p3="123456";   //123456\0在常量区，p3在栈上。
   static int c=0；   //全局（静态）初始化区
   p1 = (char*)malloc(10);
   p2 = (char*)malloc(20);   //分配得来得10和20字节的区域就在堆区。
   strcpy(p1,"123456");   //123456\0放在常量区，编译器可能会将它与p3所向"123456"优化成一个地方。
}

二、堆和栈的理论知识

2.1申请方式
stack:
       由系统自动分配。例如，声明在函数中一个局部变量int b;系统自动在栈中为b开辟空间
heap:
       需要程序员自己申请，并指明大小，在c中malloc函数
               如p1=(char*)malloc(10);
               在C++中用new运算符
               如p2=(char*)malloc(10);
               但是注意p1、p2本身是在栈中的。

2.2申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈
        溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，
       会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点
       链表中删除，并将该结点的空间分配给程序，另外，对于

大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的
        意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大
        小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超
        过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存
        储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。
        堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，
       也比较大。

2.4申请效率的比较：

栈:由系统自动分配，速度较快。但程序员是无法控制的。

堆:是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
     另外，在WINDOWS下，最好的方式是用Virtual Alloc分配内存，他不是在堆，也不是在 
     栈,而是直接在进程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，
     也最灵活。

2.5堆和栈中的存储内容

栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可 
        执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右向左
       入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束
       后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函
       数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

2.6存取效率的比较

char s1[]="aaaaaaaaaaaaaaa";
char *s2="bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：
#include
voidmain()
{
char a=1;
char c[]="1234567890";
char *p="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇编代码
10:a=c[1];
004010678A4DF1movcl,byteptr[ebp-0Fh]
0040106A884DFCmovbyteptr[ebp-4],cl
11:a=p[1];
0040106D8B55ECmovedx,dwordptr[ebp-14h]
004010708A4201moval,byteptr[edx+1]
004010738845FCmovbyteptr[ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

2.7小结：

堆和栈的区别可以用如下的比喻来看出：

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。