#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */

DLLIMPORT void HelloWorld (void);

#endif /* _DLL_H_ */

C文件
dllmain.c
#include <stdio.h>
#include <stdlib.h>

DLLIMPORT void HelloWorld ()
{
    MessageBox (0, "Hello World from DLL!\n", "Hi", MB_ICONINFORMATION);
}

BOOL APIENTRY DllMain (HINSTANCE hInst     /* Library instance handle. */ ,
                       DWORD reason        /* Reason this function is being called. */ ,
                       LPVOID reserved     /* Not used. */ )
{
    switch (reason)
    {
      case DLL_PROCESS_ATTACH:
        break;

      case DLL_PROCESS_DETACH:
        break;

      case DLL_THREAD_ATTACH:
        break;

      case DLL_THREAD_DETACH:
        break;
    }

    /* Returns TRUE on success, FALSE on failure */
    return TRUE;
}

还有要注意的在.def文件中指定输出的函数，编译生成了hello.dll文件

DLL调用部分
dllcall.c
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

HINSTANCE hDLL; //定义DLL包柄
typedef void ( *func)();    //定义函数指针原型
func hello;  //定义函数指针
int main()
{
 if (hDLL == NULL)
    hDLL=LoadLibrary("hello.dll");  //加载DLL
 hello = (func)GetProcAddress(hDLL,"HelloWorld"); //获取函数指针
 hello();
 FreeLibrary(hDLL);  //释放DLL
 return 0;
}

编译执行

 

integers(整数)编码为：i<整数>e
开始标记i，结束标记为e
例如： i1234e 表示为整数1234
 i-1234e 表示为整数-1234
整数没有大小限制
 i0e 表示为整数0
 i-0e 为非法
以0开头的为非法如： i01234e 为非法

lists(列表)编码为：l<bencoding编码类型>e
开始标记为l,结束标记为e
列表里可以包含任何bencoding编码类型，包括整数，字符串，列表，字典。
例如： l4:test5abcdee 表示为二个字符串["test","abcde"]

dictionaries(字典)编码为d<bencoding字符串><bencoding编码类型>e
开始标记为d,结束标记为e
关键字必须为bencoding字符串
值可以为任何bencoding编码类型
例如： d3:agei20ee 表示为{"age"=20}
 d4:path3:C:\8:filename8:test.txte 表示为{"path"="C:\","filename"="test.txt"}

具体文件结构如下：
全部内容必须都为bencoding编码类型。
整个文件为一个字典结构,包含如下关键字
announce:tracker服务器的URL(字符串)
announce-list(可选):备用tracker服务器列表(列表)
creation date(可选):种子创建的时间，Unix标准时间格式，从1970 1月1日 00:00:00到创建时间的秒数(整数)
comment(可选):备注(字符串)
created by(可选):创建人或创建程序的信息(字符串)
info:一个字典结构，包含文件的主要信息，为分二种情况：单文件结构或多文件结构
单文件结构如下：
          length:文件长度，单位字节(整数)
          md5sum(可选)：长32个字符的文件的MD5校验和，BT不使用这个值，只是为了兼容一些程序所保留!(字符串)
          name:文件名(字符串)
          piece length:每个块的大小，单位字节(整数)
          pieces:每个块的20个字节的SHA1 Hash的值(二进制格式)
多文件结构如下：
          files:一个字典结构
                 length:文件长度，单位字节(整数)
                 md5sum(可选):同单文件结构中相同
                 path:文件的路径和名字，是一个列表结构，如\test\test.txt 列表为l4:test8test.txte
          name:最上层的目录名字(字符串)
          piece length:同单文件结构中相同
          pieces:同单文件结构中相同 
实例：
用记事本打开一个.torrent可以看来类似如下内容
d8:announce35:http://www.manfen.net:7802/announce13:creation datei1076675108e4:infod6:lengthi17799e4:name62:MICROSOFT.WINDOWS.2000.AND.NT4.SOURCE.CODE-SCENELEADER.torrent12:piece lengthi32768e6:pieces20:?W ?躐?緕排T酆ee

很容易看出
announce＝http://www.manfen.net:7802/announce
creation date＝1076675108秒(02/13/04 20:25:08)
文件名=MICROSOFT.WINDOWS.2000.AND.NT4.SOURCE.CODE-SCENELEADER.torrent
文件大小＝17799字节
文件块大小＝32768字节

struct a
{
    void (*func)(char *);
};

void hello(char *name)
{
    printf ("hello %s\n",name);
}

int main()
{
    struct a a1;
    a1.func = hello;
    a1.func("illusion");
    system("PAUSE");
    return 0;
}

Microsoft (R) Library Manager Version 6.00.8168 Copyright (C) Microsoft Corp 1992-1998. All rights reserved. Creating library SQLITE.lib and object SQLITE.exp
  这样就成功地创建了在WIN32程序中访问sqlite所需要的库,可以用于链接WIN32程序.
    到此所有使用sqlite的准备工作已告罄.现在在MSVC6中新建一个Win32 Console Application工程,把sqlite.dll,sqlite.h和sqlite.lib文件复制到工程文件夹中,把sqlite.h文件加入到项 目中,然后在Project Setting的Link中的对象库模块中增加sqlite.lib文件. 或者project->add to project->files，选择这个lib文件
然后修改加入如下代码即可:

#include <IOSTREAM>
#include <STRING>
#include <SSTREAM>
#include <stdio.h>
#include "sqlite3.h"

using namespace std;

sqlite3* pDB;

int createTable()
{
  char* errMsg;
  std::string dropTab="drop table test_tab;";
  string strSQL= "create table test_tab (f1 int, f2 long, f3 varchar(20));";
  int res = sqlite3_exec(pDB,dropTab.c_str(),0,0, &errMsg);
  if (res != SQLITE_OK)
  {
   std::cout << "执行SQL 出错." << errMsg << std::endl;
   //return -1;
  }

  res = sqlite3_exec(pDB,strSQL.c_str(),0,0, &errMsg);

  if (res != SQLITE_OK)
  {
    std::cout << "执行创建table的SQL 出错." << errMsg << std::endl;
    return -1;
  }
  else
  {
      std::cout << "创建table的SQL成功执行."<< std::endl;
  }

  return 0;
}

int insert1()
{
  char* errMsg;

  int res = sqlite3_exec(pDB,"begin transaction;",0,0, &errMsg);

  for (int i= 1; i < 100; ++i)
  {
    std::stringstream strsql;
    strsql << "insert into test_tab  values(";
    strsql  << i << ","<< (i+10) <<",'huyi'"<< ");";
    std::string str = strsql.str();
    cout << str <<endl;
    res = sqlite3_exec(pDB,str.c_str(),0,0, &errMsg);
    if (res != SQLITE_OK)
    {
      std::cout << "执行SQL 出错." << errMsg << std::endl;
      return -1;
    }
  }
  res = sqlite3_exec(pDB,"commit transaction;",0,0, &errMsg);
  std::cout << "SQL成功执行."<< std::endl;
  return 0;
}

int select1()
{
  char* errMsg;
 int nrow = 0, ncolumn = 0;
 char **azResult; //二维数组存放结果
  string strSQL= "select * from test_tab;";
     /*
  int res = sqlite3_exec(pDB,strSQL.c_str(),0,0, &errMsg);

  if (res != SQLITE_OK)
  {
    std::cout << "执行SQL 出错." << errMsg << std::endl;
    return -1;
  }
  else
  {
       std::cout << "SQL成功执行."<< std::endl;
  }
  */
  sqlite3_get_table(pDB, strSQL.c_str(), &azResult, &nrow, &ncolumn, &errMsg);
     int i = 0;
  for( i=0 ; i<( nrow + 1 ) * ncolumn ; i++ )
  {
   if (i>0 && i%ncolumn==0)
    printf("\n");
      printf( "%s ",azResult[i]);
  }
         printf("\n");
  //释放掉 azResult 的内存空间
  sqlite3_free_table( azResult );
  sqlite3_close(pDB); //关闭数据库
  return 0;
}

int main(int argc, char* argv[])
{
  if (argc < 2)
  {
    std::cout << "请输入命令行参数：sqlite数据库名." << std::endl;
    return 0;
  }

  int res = sqlite3_open(argv[1], &pDB);

  if( res ){
    std::cout << "Can't open database: "<< sqlite3_errmsg(pDB);
    sqlite3_close(pDB);
    return -1;
  }
  res = createTable();
  if (res != 0)
  {
      return 0;
  }
  res = insert1();
  if (res != 0)
  {
      return 0;
  }
  select1();
   return 0;
}

介绍：

       设计内存池的目标是为了保证服务器长时间高效的运行，通过对申请空间小而申请频繁的对象进行有效管理，减少内存碎片的产生，合理分配管理用户内存，从而减少系统中出现有效空间足够，而无法分配大块连续内存的情况。

目标：

    此次设计内存池的基本目标，需要满足线程安全性（多线程），适量的内存泄露越界检查，运行效率不太低于malloc/free方式，实现对4-128字节范围内的内存空间申请的内存池管理（非单一固定大小对象管理的内存池）。

内存池技术设计与实现

    本内存池的设计方法主要参考SGI的alloc的设计方案，为了适合一般的应用，并在alloc的基础上做一些简单的修改。

    Mempool的内存池设计方案如下（也可参考候捷《深入剖析STL》）

    从系统申请大块heap内存，在此内存上划分不同大小的区块，并把具有相同大小的区块连接起来，组成一个链表。比如A大小的块，组成链表L，当申请A大小时，直接从链表L头部（如果不为空）上取到一块交给申请者，当释放A大小的块时，直接挂接到L的头部。内存池的原理比较简单，但是在具体实现过程中大量的细节需要注意。

    1：字节对齐。

    为了方便内存池中对象的管理，需要对申请内存空间的进行调整，在Mempool中，字节对齐的大小为最接近8倍数的字节数。比如，用户申请5个字节，Mempool首先会把它调整为8字节。比如申请22字节，会调整为24，对比关系如下

（图1）

对于超过128字节的申请，直接调用malloc函数申请内存空间。这里设计的内存池并不是对所有的对象进行内存管理，只是对申请内存空间小，而申请频繁的对象进行管理，对于超过128字节的对象申请，不予考虑。这个需要与实际项目结合，并不是固定不变的。实现对齐操作的函数如下

static size_t round_up(size_t size)
{
        return (((size)+7) &~ 7);// 按8字节对齐
}

2：构建索引表

内存池中管理的对象都是固定大小，现在要管理0-128字节的范围内的对象申请空间，除了采用上面提到的字节对齐外，还需要变通一下，这就是建立索引表，做法如下；
static _obj*  free_list[16];
创建一个包含16个_obj*指针的数组，关于_obj结构后面详细讲解。free_list[0]记录所有空闲空间为8字节的链表的首地址；free_list[1]对应16字节的链表，free_list[2]对应24字节的列表。free_list中的下标和字节链表对应关系参考图1中的“序号”和“对齐字节”之间的关系。这种关系，我们很容易用算法计算出来。如下

static size_t freelist_index(size_t size)
{
        return (((size)+7)/7-1);// 按8字节对齐
}

    所以，这样当用户申请空间A时，我们只是通过上面简单的转换，就可以跳转到包含A字节大小的空闲链表上,如下；
_obj** p = free_list[freelist_index(A)];

3:构建空闲链表

通过索引表，我们知道mempool中维持着16条空闲链表，这些空闲链表中管理的空闲对象大小分别为8，16，24，32，40…128。这些空闲链表链接起来的方式完全相同。一般情况下我们构建单链表时需要创建如下的一个结构体。

struct Obj
{
    Obj *next;
    Char* p;
    Int iSize;
}

next指针指向下一个这样的结构，p指向真正可用空间,iSize用于只是可用空间的大小，在其他的一些内存池实现中，还有更复杂的结构体，比如还包括记录此结构体的上级结构体的指针，结构体中当前使用空间的变量等，当用户申请空间时，把此结构体添加的用户申请空间中去，比如用户申请12字节的空间，可以这样做

Obj *p = (Obj*)malloc(12+sizeof(Obj));
p->next = NULL;
p->p = (char*)p+sizeof(Obj);
p->iSize = 12;

但是，我们并没有采用这种方式，这种方式的一个缺点就是，用户申请小空间时，内存池加料太多了。比如用户申请12字节时，而真实情况是内存池向内存申请了12+ sizeof(Obj)=12+12=24字节的内存空间，这样浪费大量内存用在标记内存空间上去，并且也没有体现索引表的优势。Mempool采用的是union方式

union Obj
{
    Obj *next;
    char client_data[1];
}

这里除了把上面的struct修改为union，并把int iSize去掉，同时把char*p，修改为char client_data[1]，并没有做太多的修改。而优势也恰恰体现在这里。如果采用struct方式，我们需要维护两条链表，一条链表是，已分配内存空间链表，另一条是未分配（空闲）空间链表。而我们使用索引表和union结构体，只需要维护一条链表，即未分配空间链表。具体如下

索引表的作用有两条1：如上所说，维护16条空闲链表2：变相记录每条链表上空间的大小，比如下标为3的索引表内维持着是大小为24字节的空闲链表。这样我们通过索引表减少在结构体内记录p所指向空间大小的iSize变量。从而减少4个字节。

Union的特性是，结构内的变量是互斥存在的。再运行状态下，只是存在一种变量类型。所以在这里sizeof(Obj)的大小为4，难道这里我们也需要把这4字节也加到用户申请空间中去嘛？其实不是，如果这样，我们又抹杀了union的特性。

当我们构建空闲分配链表时，我们通过next指向下一个union结构体，这样我们不使用p指针。当把这个结构体分配出去时，我们直接返回client_data的地址，此时client_data正好指向申请空间的首字节。所以这样，我们就不用在用户申请空间上添加任何东西。

图2

    Obj的连接方式如上所示，这样我们无需为用户申请空间添加任何内容。   

4：记录申请空间字节数

如果采用面向对象方式，或者我们在释放内存池的空间时能够明确知道释放空间的大小，无需采用这种方式。

图3

在C语言中的free没有传递释放空间大小，而可以正确释放，在这里也是模仿这种方式，采用这种记录申请空间大小的方式去释放内存。用户申请空间+1操作将在字节对齐之前执行，找到合适空间后，把首字节改写为申请空间的大小，当然1个字节最多纪录256个数，如果项目需要，可以设置为short类型或者int类型，不过这样就需要占用用户比较大的空间。当释放内存空间时，首先读取这个字节，获取空间大小，进行释放。为了便于对大于128字节对象的大小进行合适的释放，同时也对大于128字节的内存申请，添加1字节记录大小。所以现在这里限制了用户内存申请空间不得大于255字节，不过现在已经满足项目要求。当然也可以修改为用short类型记录申请空间的大小。

    // 申请
    *(( unsigned char *)result) = (size_t)n;
    unsigned char * pTemp = (unsigned char*)result;
    ++pTemp;
    result = (_obj*)pTemp;
    return result;

    // 释放
    unsigned char * pTemp = (unsigned char *)ptr;
    --pTemp;
    ptr = (void*)pTemp;
    n = (size_t)(*( unsigned char *)ptr);

5：内存池的分配原理

在内存池的设计中，有两个重要的操作过程1：chunk_alloc，申请大块内存，2：refill回填操作，内存池初始化化时并不是为索引表中的每一项都创建空闲分配链表，这个过程会推迟到，只有用户提取请求时才会创建这样的分配链表。详细参考如下代码（在sgi中stl_alloc.h文件中你也可以看到这两个函数），主要步骤在注释中已经说明。

/**
* @bri: 申请大块内存，并返回size*(*nobjs)大小的内存块
* @param: size,round_up对齐后的大小,nobjs
* @return: 返回指向第一个对象内存指针
*/
static char* chunk_alloc(size_t size, int *nobjs)
{
     /**< 返回指针 */
     char* __result;
     /**< 申请内存块大小 */
     size_t __total_bytes = size *(*nobjs);
     /**< 当前内存可用空间 */
     size_t __bytes_left = _end_free - _start_free;

     /**< 内存池中还有大片可用内存 */
     if (__bytes_left >= __total_bytes)
     {
         __result = _start_free;
         _start_free += __total_bytes;
         return (__result);
     }
     /**< 至少还有一个对象大小的内存空间 */
     else if (__bytes_left >= size)
     {
         *nobjs = (int)(__bytes_left/size);
         __total_bytes = size * (*nobjs);
         __result = _start_free;
         _start_free += __total_bytes;
         return (__result);
     }
     /**< 内存池中没有任何空间 */
     else
     {
         /**< 重新申请内存池的大小 */
         size_t __bytes_to_get = 2 * __total_bytes + round_up(_heap_size >> 4);
         /**< 把内存中剩余的空间添加到freelist中 */
         if(__bytes_left > 0)
         {
              _obj *VOLATILE* __my_free_list = 
                   _free_list + freelist_index(__bytes_left);
              ((_obj*)_start_free)->free_list_link =
*__my_free_list;
              *__my_free_list = (_obj*)_start_free;
         }
         // 申请新的大块空间
         _start_free = (char*)malloc(__bytes_to_get);
         /*=======================================================================*/
         memset(_start_free,0,__bytes_to_get);
         /*=======================================================================*/
         // 系统内存已经无可用内存，那么从内存池中压缩内存
         if(0 == _start_free)
         {
              size_t __i;
              _obj *VOLATILE* __my_free_list;
              _obj *__p;
              /**< 从freelist中逐项检查可用空间(此时只收集比size对象大的内存空间) */
              for (__i = size; __i <= (size_t)__MAX_BYTES; __i += __ALIGN)
              {
                   __my_free_list = _free_list + freelist_index(__i);
                   __p = *__my_free_list;
                   /**< 找到空闲块 */
                   if (__p != 0)
                   {
                       *__my_free_list = __p->free_list_link;
                       _start_free = (char*)__p;
                       _end_free = _start_free + __i;
                       return (chunk_alloc(size,nobjs));
                   }
              }
              _end_free = 0;
              /**< 再次申请内存，可能触发一个异常 */
              _start_free = (char*)malloc(__bytes_to_get);
         }
         /**< 记录当前内存池的容量 */
         _heap_size += __bytes_to_get;
         _end_free = _start_free + __bytes_to_get;
         return (chunk_alloc(size,nobjs));
     }
}

/*=======================================================================*/
/**
 * @bri: 填充freelist的连接，默认填充20个
 * @param: __n，填充对象的大小，8字节对齐后的value
 * @return: 空闲
 */
static void* refill(size_t n)
{
     int __nobjs = 20;
     char* __chunk = (char*)chunk_alloc(n, &__nobjs);
     _obj *VOLATILE* __my_free_list;
     _obj *VOLATILE* __my_free_list1;
     _obj * __result;
     _obj * __current_obj;
     _obj * __next_obj;
     int __i;
     // 如果内存池中仅有一个对象
     if (1 == __nobjs) 
         return(__chunk);
     __my_free_list = _free_list + freelist_index(n);
     /* Build free list in chunk */
     __result = (_obj*)__chunk;
     *__my_free_list = __next_obj = (_obj*)(__chunk + n);
     __my_free_list1 = _free_list + freelist_index(n);
     for (__i = 1;; ++__i)
     {
         __current_obj = __next_obj;
         __next_obj = (_obj*)((char*)__next_obj+n);
         if(__nobjs - 1 == __i)
         {
              __current_obj->free_list_link = 0;
              break;
         }else{
              __current_obj->free_list_link = __next_obj;
         }
     }
     return(__result);
}

经过上面操作后，内存池可能会成为如下的一种状态。从图上我们可以看到，已经构建了8，24，88，128字节的空闲分配链表，而其他没有分配空闲分配链表的他们的指针都指向NULL。我们通过判断索引表中的指针是否为NULL，知道是否已经构建空闲分配表或者空闲分配表是否用完，如果此处指针为NULL，我们调用refill函数，重新申请20个这样大小的内存空间，并把他们连接起来。在refill函数内，我们要查看大内存中是否有可用内存，如果有，并且大小合适，就返回给refill函数。

图4

    6：线程安全
    采用互斥体，保证线程安全。

内存池测试

    内存池的测试主要分两部分测试1：单线程下malloc与mempool的分配速度对比2：多线程下malloc和mempool的分配速度对比，我们分为4，10，16个线程进行测试了。
    测试环境：操作系统：windows2003+sp1，VC7.1+sp1，硬件环境：intel(R) Celeron(R) CPU 2.53GHz,512M物理内存。

    申请内存空间设定如下
#define ALLOCNUMBER0 4
#define ALLOCNUMBER1 7
#define ALLOCNUMBER2 23
#define ALLOCNUMBER3 56
#define ALLOCNUMBER4 10
#define ALLOCNUMBER5 60
#define ALLOCNUMBER6 5
#define ALLOCNUMBER7 80
#define ALLOCNUMBER8 9
#define ALLOCNUMBER9 100

    Malloc方式和mempool方式均使用如上数据进行内存空间的申请和释放。申请过程，每次循环申请释放上述数据20次
    我们对malloc和mempool，分别进行了如下申请次数的测试（单位为万）

图5

可以看到mempool无论在多线程还是在单线程情况下，mempool的速度都优于malloc方式的直接分配。

    Malloc方式debug模式下，在不同的线程下，运行时间如下，通过图片可知，malloc方式，在debug模式下，申请空间的速度和多线程的关系不大。多线程方式，要略快于单线程的运行实现。

图6

    Malloc方式release模式测试结果如下。

图7

多线程的优势，逐渐体现出来。当执行200w次申请和释放时，多线程要比单线程快1500ms左右，而4，10，16个线程之间的差别并不是特别大。不过整体感觉4个线程的运行时间要稍微高于10，16个线程的情况下，意味着进程中线程越多用在线程切换上的时间就越多。

下面是mempool在debug测试结果

图8

    下面是mempool在release模式下的测试结果

图9

    以上所有统计图中所用到的数据，是我们测试三次后平均值。

通过上面的测试，可以知道mempool的性能基本上超过直接malloc方式，在200w次申请和释放的情况下，单线程release版情况下，mempool比直接malloc快110倍。而在4个线程情况下，mempool要比直接malloc快7倍左右。以上测试只是申请速度的测试，在不同的压力情况下，测试结果可能会不同，测试结果也不能说明mempool方式比malloc方式稳定。

    小结：内存池基本上满足初期设计目标，但是她并不是完美的，有缺陷，比如,不能申请大于256字节的内存空间，无内存越界检查，无内存自动回缩功能等。只是这些对我们的影响还不是那么重要。

由于这是一个公司项目，代码涉及版权，所以不能发布出来。如果你想做自己的内存池，可以与我联系ugg_xchj#hotmail.com.

#include <stdio.h>
void print_arr (char (*a)[4])
{
    int i;
    for(i = 0; i < 3; i++)
    printf("%s\n", a[i]);
}

int main()
{
    char *str_arr[3][4] = {"yes", "no", "uncertain"};
    print_arr (str_arr);
    return 0;
}

如果要以二级指针的形式传参，可以在定义为字符串指针数组的形式
char *str_arr[] = {"yes", "no", "uncertain"};
void print_arr (char **a)
{
    int i;
    for (i=0; i<3;i++)
    printf("%s\n", *(a+1));
}

三个函数的申明分别是:
void* realloc(void* ptr, unsigned newsize);
void* malloc(unsigned size);
void* calloc(size_t nelem, size_t elsize);
都在stdlib.h函数库内

它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL

malloc用于申请一段新的地址,参数size为需要内存空间的长度,如:
char* p;
p=(char*)malloc(20);

calloc与malloc相似,参数nelem为申请地址的单位元素长度,elsize为元素个数,如:
char* p;
p=(char*)calloc(sizeof(char),20);
这个例子与上一个效果相同

realloc是给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度
如:
char* p;
p=(char*)malloc(sizeof(char)*20);
p=(char*)realloc(p,sizeof(char)*40);

注意，这里的空间长度都是以字节为单位。

C语言的标准内存分配函数：malloc，calloc，realloc，free等。
malloc与calloc的区别为1块与n块的区别：
malloc调用形式为(类型*)malloc(size)：在内存的动态存储区中分配一块长度为“size”字节的连续区域，返回该区域的首地址。
calloc调用形式为(类型*)calloc(n，size)：在内存的动态存储区中分配n块长度为“size”字节的连续区域，返回首地址。
realloc调用形式为(类型*)realloc(*ptr，size)：将ptr内存大小增大到size。
free的调用形式为free(void*ptr)：释放ptr所指向的一块内存空间。
C++中为new/delete函数。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1669532

      现在不难理解这段程序为什么会出现死循环了。j[8]的位置就是变量i所在的位置。这样当i=8时的j[i]=0语句，实际上就是将i的值置为0，然后 i 又从0到8循环一直下去.  如果将原句改为int j[8],i; 就不会出现死循环，而仅仅是一个段越界错误.

另一个程序:
#include <stdio.h>
int main()
{
        int i;
        char c;
        for(i=0;i<5;i++)
        {
                scanf("%d",&c);
                printf("i=%d ",i);
        }
        printf("\n");
}
编译后运行
[foxman@local~]#./a.out
0    (输入0)
i=0  (输出 i 值)
1
i=0
2
i=0
3
i=0
4
i=0
...
这样一直循环下去。

问题在于，c被声明为char类型，而不是int类型。当程序要求scanf读入一个整数时，应该传递给它一个指向整数的指针。而程序中scanf得到的却是一个指向字符的指针，scanf函数并不能分辨这种情况，只能将这个指向字符的指针作为指向整数的指针而接受，并且在指针指向的位置存储一个整数。因为整数所占的存储空间要大于字符所占的存储空间，所以c附近的内存会被覆盖.

由上面分析，i 和 c 是由高地址到低地址存储在栈中，这样在c所在位置尝试存储一个4字节变量，会占用比c高的3个字节(覆盖掉 i 字节的低3位)，即使 i 总是为零，一直循环下去.

如果每次输入Ctrl+D作为字符终止符不存储int到c处，那么就会输出正常i=0..4了.

#ifndef lint
static char vcid[] = "$Id: directshow.c,v 1.22 2005/11/12 14:12:39 fuhuizhong Exp $";
#endif /* lint */

/**//*
* 作者：傅惠忠
* /modified by xiaoshao_0_0
*/
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <linux/types.h>
#include <linux/videodev.h>
#include "jpeglib.h"
#include <setjmp.h>
#include <SDL/SDL.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#define USB_VIDEO "/dev/video1"

SDL_Surface *screen,*img;
int cam_fd;
int width,height;
const int bpp = 24;
struct video_mmap cam_mm;
struct video_capability cam_cap;
struct video_picture cam_pic;
struct video_mbuf cam_mbuf;
struct video_window win;
char *cam_data = NULL;
int nframe;

void errexit(char *msg)
...{
fputs(msg,stderr);
exit(-1);
}

void e_sig(int signum)
...{
printf(" ERROR:signal %d ",signum);
exit(-1);
}

void setup_sighandler()
...{
signal(SIGTERM,&e_sig);
signal(SIGINT,&e_sig);
signal(SIGSEGV,&e_sig);
signal(SIGILL,&e_sig);
signal(SIGFPE,&e_sig);
}

void init_video(int w,int h,int bpp); /**//* bpp == bits per pixel, 暂时无效*/
void init_screen(int w,int h,int bpp); /**//* like above*/
void read_video(int ,int);
void show_img(char *pixels);
void window_loop();
void exchange_r_b( char * f,long size);
void compress_to_jpeg_file( FILE *outfile, char * image_buffer,int w,int h, int quality);
void save_snapshot();

void free_dev()
...{
printf("free device ");
close(cam_fd);
}

int main(int argc,char *argv[])
...{
int i;
float scale = 1.0;
if( argc == 2 ) ...{
scale = atof(argv[1]);
if(scale<0.3 || scale>1.0)
errexit("scale out of range (0.3 ~ 1.0) ");
}
width = (int)(640*scale);
height = (int)(480*scale);

atexit( &free_dev );
init_video(width,height,bpp);
init_screen(width,height,bpp);
setup_sighandler();

window_loop();

getchar();
munmap(cam_data,cam_mbuf.size);

exit(0);
}

void config_vid_pic()
...{
char *hp = getenv("HOME");
char cfpath[100];
FILE *cf;
int ret;
sprintf( cfpath,"%s/.dshow.conf",hp );
cf = fopen(cfpath,"r");
/**//* The struct video_picture consists of the following fields

brightness Picture brightness
hue Picture hue (colour only)
colour Picture colour (colour only)
contrast Picture contrast
whiteness The whiteness (greyscale only)
depth The capture depth (may need to match the frame buffer depth)
palette Reports the palette that should be used for this image

The following palettes are defined

VIDEO_PALETTE_GREY Linear intensity grey scale (255 is brightest).
VIDEO_PALETTE_HI240 The BT848 8bit colour cube.
VIDEO_PALETTE_RGB565 RGB565 packed into 16 bit words.
VIDEO_PALETTE_RGB555 RGV555 packed into 16 bit words, top bit undefined.
VIDEO_PALETTE_RGB24 RGB888 packed into 24bit words.
VIDEO_PALETTE_RGB32 RGB888 packed into the low 3 bytes of 32bit words. The top 8bits are undefined.
VIDEO_PALETTE_YUV422 Video style YUV422 - 8bits packed 4bits Y 2bits U 2bits V
VIDEO_PALETTE_YUYV Describe me
VIDEO_PALETTE_UYVY Describe me
VIDEO_PALETTE_YUV420 YUV420 capture
VIDEO_PALETTE_YUV411 YUV411 capture
VIDEO_PALETTE_RAW RAW capture (BT848)
VIDEO_PALETTE_YUV422P YUV 4:2:2 Planar
VIDEO_PALETTE_YUV411P YUV 4:1:1 Planar
*/
if (ioctl(cam_fd, VIDIOCGPICT, &cam_pic) < 0) ...{
errexit("ERROR:VIDIOCGPICT ");
}
//cam_pic.palette =VIDEO_PALETTE_RAW;
cam_pic.palette =VIDEO_PALETTE_RGB24;

if( cf==NULL ) ...{
cam_pic.brightness = 44464;
cam_pic.hue = 36000;
cam_pic.colour = 0;
cam_pic.contrast = 43312;
cam_pic.whiteness = 13312;
cam_pic.depth = 24;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*设置摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
return;
}

fscanf(cf,"%d",&cam_pic.brightness);
fscanf(cf,"%d",&cam_pic.hue);
fscanf(cf,"%d",&cam_pic.colour);
fscanf(cf,"%d",&cam_pic.contrast);
fscanf(cf,"%d",&cam_pic.whiteness);
fclose( cf );
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*设置摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}

}

void init_video(int w,int h,int bpp) /**//* bpp == bytes per pixel*/
...{
int ret;

cam_fd = open( USB_VIDEO, O_RDWR );
if( cam_fd<0 )
errexit("Can't open video device ");

ret = ioctl( cam_fd,VIDIOCGCAP,&cam_cap );
/**//* 摄像头的基本信息
struct video_capability cam_cap;
name[32] Canonical name for this interface
type Type of interface
channels Number of radio/tv channels if appropriate
audios Number of audio devices if appropriate
maxwidth Maximum capture width in pixels
maxheight Maximum capture height in pixels
minwidth Minimum capture width in pixels
minheight Minimum capture height in pixels
*/
if( ret<0 ) ...{
errexit("Can't get device information: VIDIOCGCAP ");
}

print_device_info();

/**//* The struct video_window contains the following fields.

x The X co-ordinate specified in X windows format.
y The Y co-ordinate specified in X windows format.
width The width of the image capture.
height The height of the image capture.
chromakey A host order RGB32 value for the chroma key.
flags Additional capture flags.
clips A list of clipping rectangles. (Set only)
clipcount The number of clipping rectangles. (Set only)
*/
if( ioctl(cam_fd,VIDIOCGWIN,&win)<0 ) ...{
errexit("ERROR:VIDIOCGWIN ");
}
win.x = 0;
win.y = 0;
win.width=width;
win.height=height;
if (ioctl(cam_fd, VIDIOCSWIN, &win) < 0) ...{
errexit("ERROR:VIDIOCSWIN ");
}

config_vid_pic();

ret = ioctl(cam_fd,VIDIOCGMBUF,&cam_mbuf);
/**//*
struct video_mbuf
{
int size; Total memory to map
int frames; Frames
int offsets[VIDEO_MAX_FRAME];
};
*/

/**//*struct video_buffer.
视频缓存的信息读取结构，设定也是一样的结构。但是一般是X自己设定，你只要读取就好了。
void *base Base physical address of the buffer
int height Height of the frame buffer
int width Width of the frame buffer
int depth Depth of the frame buffer
int bytesperline Number of bytes of memory between the start of two adjacent lines*/

if( ret<0 ) ...{
errexit("ERROR:VIDIOCGMBUF,Can't get video_mbuf ");
}
printf("Frames:%d ",cam_mbuf.frames);
nframe = cam_mbuf.frames;
cam_data = (char*)mmap(0, cam_mbuf.size, PROT_READ|PROT_WRITE,MAP_SHARED,cam_fd,0);
if( cam_data == MAP_FAILED ) ...{
errexit("ERROR:mmap ");
}
printf("Buffer size:%d Offset:%d ",cam_mbuf.size,cam_mbuf.offsets[0]);
}

void print_device_info()
...{
int type=cam_cap.type;
int i;
char type_info[14][100]=
...{
"VID_TYPE_CAPTURE Can capture to memory",
"VID_TYPE_TUNER Has a tuner of some form",
"VID_TYPE_TELETEXT Has teletext capability",
"VID_TYPE_OVERLAY Can overlay its image onto the frame buffer",
"VID_TYPE_CHROMAKEY Overlay is Chromakeyed",
"VID_TYPE_CLIPPING Overlay clipping is supported",
"VID_TYPE_FRAMERAM Overlay overwrites frame buffer memory",
"VID_TYPE_SCALES The hardware supports image scaling",
"VID_TYPE_MONOCHROME Image capture is grey scale only",
"VID_TYPE_SUBCAPTURE Capture can be of only part of the image",
"VID_TYPE_MPEG_DECODER Can decode MPEG streams",
"VID_TYPE_MPEG_ENCODER Can encode MPEG streams",
"VID_TYPE_MJPEG_DECODER Can decode MJPEG streams",
"VID_TYPE_MJPEG_ENCODER Can encode MJPEG streams",
};
printf("Device name:%s Width:%d ~ %d Height:%d ~ %d ",
cam_cap.name,
cam_cap.maxwidth, cam_cap.minwidth,
cam_cap.maxheight, cam_cap.minheight);
for(i=0;i<14;i++)
...{
if(type&(2^i))
...{ printf(type_info[i]);
printf(" ");
}
else
...{
printf("==not supported==%s",type_info[i]);
printf(" ");
}
}
}

void init_screen(int w,int h,int bpp) // like above
...{
if ( SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO) < 0 ) ...{
fprintf(stderr, "无法初始化SDL: %s ", SDL_GetError());
exit(1);
}
img = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, bpp, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000);
screen = SDL_SetVideoMode(width, height, bpp, SDL_SWSURFACE);
if ( screen == NULL ) ...{
fprintf(stderr, "无法设置视频模式：%s ", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
}

void read_video(int captrue_frame,int sync_frame)
...{
int ret;
//int frame=0; /*这个似乎比较关键*/
//这个地方原作者弄错了。
cam_mm.frame=captrue_frame;
/**//* struct video_mmap
{
unsigned int frame; Frame (0 - n) for double buffer
int height,width;
unsigned int format; should be VIDEO_PALETTE_*
};
*/
ret = ioctl(cam_fd,VIDIOCMCAPTURE,&cam_mm);
if( ret<0 ) ...{
errexit("ERROR: VIDIOCMCAPTURE ");
}
//cam_mm.frame=sync_frame;
ret = ioctl(cam_fd,VIDIOCSYNC,&sync_frame);
if( ret<0 ) ...{
errexit("ERROR: VIDIOCSYNC ");
}
}

void show_img(char *pixels)
...{
int row_stride = width*3;
char *pbuf = (char*)img->pixels;
int row;

/**//* for(row=0; row<height; row++) {
memcpy(pbuf, pixels, row_stride);
pbuf += img->pitch;
pixels += row_stride;
}*/
memcpy(pbuf,pixels,row_stride*height);
SDL_BlitSurface(img, NULL, screen, NULL);
SDL_UpdateRect(screen,0,0,width,height);
}

void window_loop()
...{
int ret;
SDL_Event event;
int keystat = 0;
Uint32 ticks = 0;
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY,1000);
/**///////////////
cam_mm.height = height;
cam_mm.width = width;
cam_mm.frame=0;
cam_mm.format=VIDEO_PALETTE_RGB24;
ret = ioctl(cam_fd,VIDIOCMCAPTURE,&cam_mm);

if( ret<0 ) ...{
errexit("ERROR: VIDIOCMCAPTURE ");
}
//Here just start caputer frame0,it not in the loop.
/**///////////////
while ( 1 ) ...{
SDL_PollEvent(&event);
switch (event.type) ...{
case SDL_QUIT:
exit(0);
case SDL_KEYDOWN:
if( event.key.keysym.sym == SDLK_F8 && keystat == 0 )
save_snapshot();
if( event.key.keysym.sym == SDLK_F9 && keystat == 0 )
config_vid_pic();
if( event.key.keysym.sym == SDLK_UP && keystat == 0 )
increase_brightness();
if( event.key.keysym.sym == SDLK_DOWN && keystat == 0 )
decrease_birghtness();
if( event.key.keysym.sym == SDLK_LEFT && keystat== 0 )
increase_contrast();
if( event.key.keysym.sym == SDLK_RIGHT && keystat==0 )
decrease_contrast();
keystat = 1;
break;
case SDL_KEYUP:
keystat = 0;
break;
default:
break;
}
if( (SDL_GetTicks()-ticks)<30)
continue;
read_video(1,0);//captrue=1,sync=0
show_img( cam_data+cam_mbuf.offsets[0]);
read_video(0,1);//captrue=0,sync=1
show_img( cam_data+cam_mbuf.offsets[1]);
ticks = SDL_GetTicks();
}
}
void increase_brightness()
...{
int ret=0;
cam_pic.brightness+=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*设置摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}
void decrease_birghtness()
...{
int ret=0;
cam_pic.brightness-=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*设置摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}
void increase_contrast()
...{
int ret=0;
cam_pic.contrast+=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*设置摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}
void decrease_contrast()
...{
int ret=0;
cam_pic.contrast-=1000;
ret = ioctl( cam_fd, VIDIOCSPICT,&cam_pic ); /**//*设置摄像头缓冲中voideo_picture信息*/
if( ret<0 ) ...{
close(cam_fd);
errexit("ERROR: VIDIOCSPICT,Can't set video_picture format ");
}
}

void compress_to_jpeg_file( FILE *outfile, char * image_buffer,int w,int h, int quality)
...{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1]; /**//* pointer to JSAMPLE row[s] */
int row_stride; /**//* physical row width in image buffer */
int image_width;
int image_height;
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, outfile);

image_width = w;
image_height = h;
cinfo.image_width = image_width; /**//* image width and height, in pixels */
cinfo.image_height = image_height;
cinfo.input_components = 3; /**//* # of color components per pixel */
cinfo.in_color_space = JCS_RGB; /**//* colorspace of input image */
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo, quality, TRUE /**//* limit to baseline-JPEG values */);
jpeg_start_compress(&cinfo, TRUE);
row_stride = image_width * 3; /**//* JSAMPLEs per row in image_buffer */
while (cinfo.next_scanline < cinfo.image_height) ...{
row_pointer[0] = (JSAMPROW)& image_buffer[cinfo.next_scanline * row_stride];
(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
}

jpeg_finish_compress(&cinfo);

jpeg_destroy_compress(&cinfo);

/**//* And we're done! */
}
void exchange_r_b( char * f,long size)
...{
char r,b;
long i;
for( i = 0; i < size ; i++)
...{
r = *f;
b = *( f + 2);
*f = b;
*(f + 2) = r;
f = f +3;
}

}

void save_snapshot()
...{
char *basepath = getenv("HOME");
char *basename = "/snapsot";
char *extname = ".jpg";
char filename[100];
int i = 0;
FILE *fo;
for(;;) ...{
sprintf(filename,"%s%s%d%s",basepath,basename,i,extname);
fo = fopen(filename,"rb");
if( fo==NULL )
break;
else
fclose(fo);
i += 1;
}
printf("snapshot:%s ",filename);
fo = fopen(filename,"wb");
exchange_r_b( cam_data, width*height );
compress_to_jpeg_file( fo, cam_data, width, height, 90 );
fclose(fo);
}

一个比较清淅的摄像头参数设置

//loadVariablesNum("schlist.tx", 0);
//fscommand("fullscrean", true);
var my_cam = Camera.get();
//LAN
//Lower image quality, higher motion quality my_cam.setQuality(400000,0)
//Higher image quality, lower motion qualitymy_cam.setQuality(0,100)
//// 确保最低品质为 100，无论采用多大的带宽
my_cam.setQuality(0, 100); //
my_cam.setKeyFrameInterval(15);
my_cam.setLoopback(true);
//my_cam.setMotionLevel(35, 1000);
my_cam.setMode(320, 240, 25, true);

// 捕获摄像头
myVideo1.attachVideo(my_cam);
myVideo1.smoothing = true;
myVideo1._alpha = 100;
myVideo1._rotation = 360;
// 在舞台上的 myVideo1 对象的边界内显示视频流
my_cam.onStatus = function(infoMsg) {
 if (infoMsg.code == 'Camera.Muted') {
  // 拒绝
  trace('User denies access to the camera');
 } else if (infoMsg.code == 'Camera.Unmuted') {
  // 接受
  trace('User allows access to the camera');
 }

};
//System.showSettings(3);
// 显示指定的 Flash Player"设置"面板
stop(); 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>
#define BUFFER_SIZE 16

struct prodcons
{
   int buffer[BUFFER_SIZE];
   pthread_mutex_t lock;/*互斥锁*/
   int readpos, writepos;
   pthread_cond_t notempty;/*缓冲区非空信号*/
   pthread_cond_t notfull;/*缓冲区非满信号*/
};

void init(struct prodcons *b)
{
   pthread_mutex_init(&b->lock, NULL);
   pthread_cond_init(&b->notempty, NULL);
   pthread_cond_init(&b->notfull, NULL);
   b->readpos = 0;
   b->writepos = 0;
}
void put(struct prodcons *b, int data)
{
   pthread_mutex_lock(&b->lock);//获取互斥锁
   while((b->writepos + 1) % BUFFER_SIZE == b->readpos)
   {
      printf("wait for not full\n");
      pthread_cond_wait(&b->notfull, &b->lock);//不满时逃出阻塞
   }
   b->buffer[b->writepos] = data;
   b->writepos++;
   if(b->writepos >= BUFFER_SIZE) b->writepos = 0;
   pthread_cond_signal(&b->notempty);//设置状态变量
   pthread_mutex_unlock(&b->lock);//释放互斥锁
}

int get(struct prodcons *b)
{
   int data;
   pthread_mutex_lock(&b->lock);
   while(b->writepos == b->readpos)
   {
     printf("wait for not empty\n");
     pthread_cond_wait(&b->notempty, &b->lock);
   }
   data = b->buffer[b->readpos];
   b->readpos++;
   if(b->readpos >= BUFFER_SIZE) b->readpos = 0;
   pthread_cond_signal(&b->notfull);
   pthread_mutex_unlock(&b->lock);
   return data;
}

#define OVER (-1)
struct prodcons buffer;

void *producer(void *data)
{
   int n;
   for(n=0; n<1000; n++)
   {
      printf("put->%d\n",n);
      put(&buffer, n);
   }
   put(&buffer, OVER);
   printf("producer stopped\n");
   return NULL;
}

void *consumer(void *data)
{
   int d;
   while(1)
   {
      d = get(&buffer);
      if(d == OVER)
      break;
      printf("             %d->get\n",d);
   }
   printf("consumer stopped!\n");
   return NULL;
}
int main(void)
{
   pthread_t th_a, th_b;
   void *retval;
   init(&buffer);
   pthread_create(&th_a, NULL, producer, 0);
   pthread_create(&th_b, NULL, consumer, 0);
   pthread_join(th_a, &retval);
   pthread_join(th_b, &retval);
   return 0;
}
pthread_cond_wait函数，是线程阻塞在一个条件变量上，原型为：
extern int pthread_cond_wait(pthread_cond_t *_restrict_cond, pthread_mutex_t* _restrict_mutex)
线程解开mutex指向的锁并被条件变量cond阻塞，线程可以被函数pthread_cond_signal和pthread_cond_broadcast唤醒。
还有另一个函数pthread_cond_timedwait函数，他比vpthread_cond_wait函数多一个时间参数，经历给定时间後，阻塞将被解除。

int **AllocMatrix ( int iRow, int iCol )
void FreeMatrix ( int** p )

示例程序：

#include  < stdio.h >
#include  < stdlib.h >
#include  < string .h >
/**/ //////////////////////////////////////////////////////////// //
void  FreeMatrix( int   ** p);
int **  AllocMatrix( int  iRow,  int  iCol);

int   ** AllocMatrix( int  iRow,  int  iCol)
{
     int **  tdarray  =  NULL;
     int *  tmparray  =  NULL;
     int  i  =   0 ;
     // allocate pointer array
     if ( ! (tdarray  =  ( int ** )malloc( sizeof ( char * ) * iRow)))
     {
        printf( " allocate iRow wrong\n " );
        exit( 1 );
    }
     // allocate actual array space
     if ( ! (tmparray  =  ( int * )malloc( sizeof ( int ) * (iRow  *  iCol))))
     {
        FreeMatrix(tdarray);
        printf( " allocate iRow wrong\n " );
        exit( 1 );
    }
     // initialize memory
    memset(tmparray,  0x00 ,  sizeof ( int ) * (iRow  *  iCol));
     // evaluate the pointer array
     for (i = 0 ; i < iRow; i ++ )
        tdarray[i]  =  (tmparray  +  (i *  iCol) * sizeof ( int ));
     return  tdarray;
}

void  FreeMatrix( int   ** p)
{
     if (p)
     {
        free(p[ 0 ]);
        free(p);
    }
}

void  main( void )
{
     int   ** arr  =  AllocMatrix( 2 , 2 );
    arr[ 1 ][ 1 ]  =   1 ;
    arr[ 0 ][ 1 ]  =   4 ;
    printf( " %d, %d \n " ,arr[ 1 ][ 1 ], arr[ 0 ][ 1 ]);
    FreeMatrix(arr);
}

    int *a;
    int N;
    scanf("%d", &N);
    a = (int *) malloc(N * sizeof(int));
    ....
    free(a);

    这样就动态分配了数组a[N]。数组的长度N可输入确定，也可用程序中的变量确定。但要注意程序结束后要用free()将其释放，否则内存会泄漏。

--------------------------------------------------------------------------------
验证一下：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int i = 0;

    int *a;
    int N;

    printf("Input array length: ");
    scanf("%d", &N);
    printf("\n");

    a = (int *) malloc(N * sizeof(int));
   
    for(i = 0; i < N; i++)
    {
        a[i] = i + 1;

        printf("%-5d", a[i]);
        if ((i + 1) % 10 == 0)
            printf("\n");
    }

    free(a);

    printf("\n");   
    return 0;
}

运行结果(VC):
=========================================================
Input array length: 100↙

1    2    3    4    5    6    7    8    9    10
11   12   13   14   15   16   17   18   19   20
21   22   23   24   25   26   27   28   29   30
31   32   33   34   35   36   37   38   39   40
41   42   43   44   45   46   47   48   49   50
51   52   53   54   55   56   57   58   59   60
61   62   63   64   65   66   67   68   69   70
71   72   73   74   75   76   77   78   79   80
81   82   83   84   85   86   87   88   89   90
91   92   93   94   95   96   97   98   99   100

=========================================================