以下为我学习编写DLL的一些总结，其中包括一些来自互联网（包括一些例子），感谢作者的帮忙。下面提到的例子都经过编程测试通过。
VC中编写Non MFC DLL的方法总结
一、
LIB:   extern "C" int add(int x,int y); //声明为C编译、连接方式的外部函数 
1.1 在程序中如何引入lib.h：
1)#pragma comment( lib, "..\\debug\\libTest.lib" ) 　//指定与静态库一起连接
2)VC中 tools、options、directories、library files菜单或选项，填入库文件路径
引入lib.h后，就可以直接使用ADD函数。
DLL：extern "C" int __declspec(dllexport)add(int x, int y);//声明函数add为DLL的导出函数。
 
1.2 DLL内的函数分为两种：
(1)DLL导出函数，可供应用程序调用；
(2) DLL内部函数，只能在DLL程序使用，应用程序无法调用它们
引入Dll后，不能马上调用Add数，要分为几个步骤来实现调用函数：
 
1.3首先引入实例：
1.3.1 生产DLL
/* 文件名：lib.h　在该头文件里面声明导出函数变量及类*/
#ifndef LIB_H
#define LIB_H
/*必须把要被外部调用的函数，声明成导出函数*/
extern "C" int __declspec(dllexport)add(int x, int y);//函数
extern int globalVar;//把变量声明为外部的可以导出的变量
class __declspec(dllexport)testClass;//声明该类为导出类
#endif
 
/*classTest.h  在该头文件里面声明类*/
 
 
 
#include <stdio.h>
class testClass
{
public:
     testClass();
     void coutData();
protected:
private:
     int a;
};
 

/* 文件名：lib.cpp　可以在任意地方定义导出变量函数类，但必须包括声明所在的头文件*/
#include "lib.h"
#include <stdio.h>
#include "classTest.h"
int globalVar = 10;
int add(int x, int y)
{
     return x + y;
}
 
testClass::testClass()
{
     printf("output the class ! init...\n");
}
 
void testClass::coutData()
{
     a = 20;
     printf("the class'var is a = %d\n",a);
}
 
/* Lib def: */
;LIBRARY   "testdll" 用；表示注释
LIBRARY testdll  //库的名称
EXPORTS 
;use DATA to define the export VAR
globalVar DATA //导出变量
add @ 1      //导出函数
 
 
1.3.2 调用：
/*方法一：动态调用，loadLibrary -- GetProcAddress--FreeLibrary方式*/
 
#include <stdio.h>
#include <windows.h>
typedef int(*lpAddFun)(int, int); //宏定义函数指针类--------------（1）
int main(int argc, char *argv[])
{
　HINSTANCE hDll; //DLL句柄  －－－－－－－（3）
　lpAddFun addFun; //函数指针   －－－－－－（2）
　hDll = LoadLibrary("..\\Debug\\dllTest.dll"); －－－－－－－－（3）
　if (hDll != NULL)
　{
　　addFun = (lpAddFun)GetProcAddress(hDll, "add"); －－－－（4）
//   addFun = (lpAddFun)GetProcAddress(hDll, MAKEINTRESOURCE(1));//直接引用导出函数的序号，在def文件里面已经定义好各个导出函数的符号
　　if (addFun != NULL)
　　{
　　　int result = addFun(2, 3);
　　　printf("%d", result);
　　}
　　FreeLibrary(hDll);－－－－－－－－－－（5）
　}
　return 0;
}
（1）.语句typedef int ( * lpAddFun)(int,int)定义了一个与add函数接受参数类型和返回值均相同的函数指针类型.如。net框架中的委托一样。
（2）.在main函数中定义了lpAddFun的实例addFun
（3）.在函数main中定义了一个DLL HINSTANCE句柄实例hDll，通过Win32 Api函数LoadLibrary动态加载了DLLaddFun。经由函数指针addFun进行了对DLL中add函数的调用
（4）.在函数main中通过Win32 Api函数GetProcAddress得到了所加载DLL模块中函数add的地址并赋给了addFun。经由函数指针addFun进行了对DLL中add函数的调用
（5）.应用工程使用完DLL后，在函数main中通过Win32 Api函数FreeLibrary
释放了已经加载的DLL模块
/*方法二：静态调用方式*/
 
#include "..\\testdll\\classTest.h" //调用导出类时，要把该类所在的头文件也包含进去，有没有其他方法使其不需要的呢？
#pragma comment(lib,"..\\debug\\testdll.lib")
 
extern "C" int __declspec(dllimport)add(int x, int y);//注意要用dllimport表示导入函数，dllexport表示到处函数符号.
extern int __declspec(dllimport)globalVar;//用dllimport导入函数
class __declspec(dllimport) testClass;
 
int main()
{
     int result=add(2,3);
 
     printf("%d\n",result);
 
     printf("the global var is : %d\n",globalVar);
 
     testClass test;
     test.coutData();
     return 0;
}
 
 
PS：注意若要导出的是类，则必须把包含该类的头文件（及该头文件所包含的所有头文件）都加到调用程序中。还有另一种方法，在下面转载哪一段有说明
 
二、
 
如果要被其他语言编写的调用，比如VB等，则要用_stdcall修饰。
例子：
 
/* lib .h */
#ifndef LIB_H
#define LIB_H
int _stdcall add(int x,int y);
#endif
 
/* lib.cpp*/
#include "lib.h"
#include "windows.h"
#include "stdio.h"
// lib.cpp : 采用_stdcall修饰导出函数
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;
}
//用任何一种方法输出函数时,确保用_stdcall调用约定, _stdcall 调用约定是用来调用Win32 API函数。
//_stdcall 以相反的顺序(从右到左) 把参数推入栈中
int _stdcall add(int x,int y)
{
     return x + y;
}
 
/* lib def */
 
; lib.def : 导出DLL函数
LIBRARY LIB
EXPORTS
add @ 1
 
 
调用：
 
#include "stdafx.h"
#include "windows.h"
 
typedef int (_stdcall * lpAddFun)(int,int);
 
int main(int argc, char* argv[])
{
    HINSTANCE hDll;
     lpAddFun addFun;
     hDll = LoadLibrary("..\\Debug\\dllTest.dll");
     if (hDll != NULL)
     {
         addFun = (lpAddFun)GetProcAddress(hDll,"add");
         //或addFun = (lpAddFun)GetProcAddress(hDll,MAKEINTRESOURCE(1));
         //MAKEINTRESOURCE直接使用导出文件中的序号
         if(addFun!=NULL)
         {
             int result =  addFun(2,3);   
              printf("\ncall add in dll:%d",result);
         }   
         FreeLibrary(hDll);
     }   
     return 0;
}
 
 
 以下部分为转载：

关于DLL的函数：  
   
  动态链接库中定义有两种函数：导出函数(export   function)和内部函数(internal   function)。  
  导出函数可以被其它模块调用，内部函数在定义它们的DLL程序内部使用。  
   
  输出函数的方法有以下几种：  
   
  1、传统的方法  
   
  在模块定义文件的EXPORT部分指定要输入的函数或者变量。语法格式如下：  
  entryname[=internalname]   [@ordinal[NONAME]]   [DATA]   [PRIVATE]  
   
  其中：  
   
  entryname是输出的函数或者数据被引用的名称；  
   
  internalname同entryname;  
   
  @ordinal表示在输出表中的顺序号(index)；  
   
  NONAME仅仅在按顺序号输出时被使用（不使用entryname）；  
   
  DATA表示输出的是数据项，使用DLL输出数据的程序必须声明该数据项为_declspec(dllimport)。  
   
  上述各项中，只有entryname项是必须的，其他可以省略。  
   
  对于“C”函数来说，entryname可以等同于函数名；但是对“C++”函数（成员函数、非成员函数）  
  来说，entryname是修饰名。可以从.map映像文件中得到要输出函数的修饰名，或者使用  
  DUMPBIN   /SYMBOLS得到，然后把它们写在.def文件的输出模块。DUMPBIN是VC提供的一个工具。  
   
  如果要输出一个“C++”类，则把要输出的数据和成员的修饰名都写入.def模块定义文件。  
   
  2、在命令行输出  
   
  对链接程序LINK指定/EXPORT命令行参数，输出有关函数。  
   
  3、使用MFC提供的修饰符号_declspec(dllexport)  
   
  在要输出的函数、类、数据的声明前加上_declspec(dllexport)的修饰符，表示输出。__declspec  
  (dllexport)在C调用约定、C编译情况下可以去掉输出函数名的下划线前缀。extern   "C"使得在C++中  
  使用C编译方式成为可能。在“C++”下定义“C”函数，需要加extern   “C”关键词。用extern   "C"来  
  指明该函数使用C编译方式。输出的“C”函数可以从“C”代码里调用。  
   
  例如，在一个C++文件中，有如下函数：  
  extern   "C"   {void   __declspec(dllexport)   __cdecl   Test(int   var);}  
  其输出函数名为：Test    
   
  MFC提供了一些宏，就有这样的作用。  
   
  AFX_CLASS_IMPORT：__declspec(dllexport)  
   
  AFX_API_IMPORT：__declspec(dllexport)  
   
  AFX_DATA_IMPORT：__declspec(dllexport)  
   
  AFX_CLASS_EXPORT：__declspec(dllexport)  
   
  AFX_API_EXPORT：__declspec(dllexport)  
   
  AFX_DATA_EXPORT：__declspec(dllexport)  
   
  AFX_EXT_CLASS：   #ifdef   _AFXEXT    
  AFX_CLASS_EXPORT  
  #else  
  AFX_CLASS_IMPORT  
   
  AFX_EXT_API：#ifdef   _AFXEXT  
  AFX_API_EXPORT  
  #else  
  AFX_API_IMPORT  
   
  AFX_EXT_DATA：#ifdef   _AFXEXT  
  AFX_DATA_EXPORT  
  #else  
  AFX_DATA_IMPORT  
   
  像AFX_EXT_CLASS这样的宏，如果用于DLL应用程序的实现中，则表示输出（因为_AFX_EXT被定义，通  
  常是在编译器的标识参数中指定该选项/D_AFX_EXT）；如果用于使用DLL的应用程序中，则表示输入  
  （_AFX_EXT没有定义）。  
   
  要输出整个的类，对类使用_declspec(_dllexpot)；要输出类的成员函数，则对该函数使用  
  _declspec(_dllexport)。如：  
   
  class   AFX_EXT_CLASS   CTextDoc   :   public   CDocument  
  {  
  …  
  }  
   
  extern   "C"   AFX_EXT_API   void   WINAPI   InitMYDLL();  
   
  这几种方法中，最好采用第三种，方便好用；其次是第一种，如果按顺序号输出，调用效率会高些；  
  最次是第二种。    
   
  六、模块定义文件(.DEF)  
   
  模块定义文件(.DEF)是一个或多个用于描述DLL属性的模块语句组成的文本文件，每个DEF文件至少必  
  须包含以下模块定义语句：  
   
  *   第一个语句必须是LIBRARY语句，指出DLL的名字；  
  *   EXPORTS语句列出被导出函数的名字；将要输出的函数修饰名罗列在EXPORTS之下，这个名字必须与  
  定义函数的名字完全一致，如此就得到一个没有任何修饰的函数名了。  
  *   可以使用DESCRIPTION语句描述DLL的用途(此句可选)；  
  *   ";"对一行进行注释(可选)。  
   
  七、DLL程序和调用其输出函数的程序的关系  
   
  1、dll与进程、线程之间的关系  
   
  DLL模块被映射到调用它的进程的虚拟地址空间。  
  DLL使用的内存从调用进程的虚拟地址空间分配，只能被该进程的线程所访问。  
  DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。  
  DLL使用调用进程的栈。  
   
  2、关于共享数据段  
   
  DLL定义的全局变量可以被调用进程访问；DLL可以访问调用进程的全局数据。使用同一DLL的每一个  
  进程都有自己的DLL全局变量实例。如果多个线程并发访问同一变量，则需要使用同步机制；对一个  
  DLL的变量，如果希望每个使用DLL的线程都有自己的值，则应该使用线程局部存储(TLS，Thread    
  Local   Strorage)。  
   
  在程序里加入预编译指令，或在开发环境的项目设置里也可以达到设置数据段属性的目的.必须给  
  这些变量赋初值,否则编译器会把没有赋初始值的变量放在一个叫未被初始化的数据段中。