请看下面的代码：

#define T 13 /*用#define定义的一个常量T*/

int main()

{

    const int t=13;/*用const定义的一个常量*/

    int n=t;/*把t赋值给n*/

    int m=T;/*把T赋值给m*/

}

1.差别:

const与#define最大的差别在于：前者在堆栈分配了空间，而后者只是把具体数值直接传递到目标变量罢了。或者说，const的常量是一个Run-Time的概念，他在程序中确确实实的存在可以被调用、传递。而#define常量则是一个Compile-Time概念，它的生命周期止于编译期：在实际程序中他只是一个常数、一个命令中的参数，没有实际的存在。

const常量存在于程序的数据段.

#define常量存在于程序的代码段。

2优缺点:

至于两者的优缺点，要看具体的情况了。一般的常数应用，我个人认为#define是一个更好的选择：

i.从run-time的角度来看，他在空间上和时间上都有很好优势。

ii.从compile-time的角度来看，类似m=t*10的代码不会被编译器优化，t*10的操作需要在run-time执行。而#define的常量会被合并。

但是：如果你需要粗鲁的修改常数的值，那就的使用const了，因为后者在程序中没有实际的存在.

另外在头文件中使用 #define  可以避免头文件重复包含的问题，这个功能，是const无法取代的。

一、预备知识—程序的内存分配

一个由c/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放

4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放

5、程序代码区—存放函数体的二进制代码。

二、例子程序

这是一个前辈写的，非常详细

 //main.cpp

 int a = 0; 全局初始化区

 char *p1; 全局未初始化区

 main()

 {

 int b;// 栈

 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"优化成一个地方。

 } 

Linux: void *sr_getevtdatap( )
Windows: void *sr_getevtdatap(ehandle)

参数：Linux 无。Windows上sr_waitevtEx( )返回的事件句柄。

返回值：指向数据块的指针

作用：返回与该事件相关的变量数据块的地址。

示例函数：

#include <srllib.h>
#include <dxxxlib.h>
long int dx_handler(void*)
{
        printf( "Got event with event data 0x%s\n",(char*)(sr_getevtdatap()));
        /* Tell SRL to keep the event */
        return( 1 );
}
int main(){
        int dxxxdev;
        int mode = SR_POLLMODE;
        /* Set SRL to run in polled mode */
        if( sr_setparm( SRL_DEVICE, SR_MODEID, &mode ) == -1 )
        {
                printf( "Cannot set SRL to polled mode\n" );
                exit( 1 );
        }
        /* open the device */
        if(( dxxxdev = dx_open( "dxxxB1C1", 0 )) == -1 )
        {
                printf( "failed to open device\n" );
                exit( 1 );
        }
        /* Enable handlers */
        if( sr_enbhdlr( dxxxdev, EV_ANYEVT, dx_handler ) == -1 )
        {
        printf( "Could not enable handler: error = %s\n", ATDV_ERRMSGP( SRL_DEVICE ));
        exit( 1 );
        }
        /* Generate events via async calls */
        if( dx_sethook( dxxxdev, DL_ONHOOK, EV_ASYNC ) == -1 )
        {
                printf( "dx_sethook failed: error = %s\n", ATDV_ERRMSGP( dxxxdev ));
                exit( 1 );
        }
        /*
        * Wait forever while handlers deal with events
        * All handlers return 0 except the one for the last
        * event returns 1 telling SRL to leave the event to wake up
        * sr_waitevt().
        */
        (void)sr_waitevt( -1 );
        /* Cleanup */
}

参数：指向类名的指针，记录主板卡的数目

返回值：0成功 －1失败

作用：仅仅用在windows平台。返回特定类型的板卡资源数量。

#include <windows.h>
#include <srllib.h>
#include <dxxxlib.h>
long chdev[MAXDEVS];
long evt_handle;
main( ... )
{
char channel_name[12], board_name[12];
int brd_handle;
int brd, ch, devcnt = 0;
int numvoxbrds = 0;
if ( sr_getboardcnt(DEV_CLASS_VOICE, &numvoxbrds) == -1)
{
/* error retrieving voice boards */
}
for (brd = 1; brd <= numvoxbrds; brd++)
{
/* build the board name and open the board device to get number of channels */
sprintf(board_name, "dxxxB%d",brd);
if ( (brd_handle = dx_open(board_name, 0)) == -1)
{
/* Board open error */
}
for (ch = 1; ch <= ATDV_SUBDEVS(brd_handle); ch++)
{
sprintf(channel_name, "%sC%d", board_name, ch);
if ( (chdev[devcnt++] = dx_open(channel_name, 0)) == -1)
{
/* Channel open error */
}
} /* End of channel for loop */
dx_close(brd_handle);
} /* End of board loop */
}

Linux: long (*handler)( )
Windows: long (*handler) (unsigned long parm)

参数：设备句柄，事件类型，事件处理函数

返回值：0成功 －1失败

作用：让事件处理函数开始监听事件

示例程序：

#include <srllib.h>
#include <dxxxlib.h>
/* LINUX: set up handler */
long int dx_handler(void* pData)
{
printf( "dx_handler() called, event is 0x%x\n", sr_getevttype());
return( 0 );
/* tell SRL to dispose of the event */
}
main()
{
int dxxxdev;
int mode = SR_POLLMODE;
/* LINUX: set SRL to run in non-signal mode */
if( sr_setparm( SRL_DEVICE, SR_MODEID, &mode ) == -1 )
{
printf( "Failed to set SRL mode\n" );
exit( 1 );
}
/* open dxxx channel device */
if(( dxxxdev = dx_open( "dxxxB1C1", 0 )) == -1 )
{
printf( "dx_open failed\n" );
exit( 1 );
}
/* Enable a handler for all events on dxxxdev */
if( sr_enbhdlr( dxxxdev, EV_ANYEVT, dx_handler ) == -1 )
{
        printf( "Error: could not enable handler\n");
exit( 1 );
}
}

Linux: long (*handler)( )
Windows: long (*handler) (unsigned long parm)

参数：设备句柄，事件类型，事件处理函数

返回值：0成功 －1失败

作用：让一个事件处理函数不在起作用。

示例程序：

#include <srllib.h>
#include <dxxxlib.h>
#include <cstdio>
using namespace std;
/* LINUX: set up handler */
long int dx_handler(void * pdata){
    printf( "dx_handler() called, event is 0x%x\n", sr_getevttype());
    return( 0 );
}
main()
{
int dxxxdev;
int mode = SR_POLLMODE;
/* LINUX: set SRL to run in non-signal mode */
if( sr_setparm( SRL_DEVICE, SR_MODEID, &mode ) == -1 )
{
   printf( "Failed to set SRL mode\n" );
   exit( 1 );
}
/* open dxxx channel device */
if(( dxxxdev = dx_open( "dxxxB1C1", 0 )) == -1 )
{
printf( "dx_open failed\n" );
exit( 1 );
}
/* enable handler dx_handler on device dxxxdev ..... */
if( sr_enbhdlr( dxxxdev, EV_ANYEVT, dx_handler ) == -1 )
{
printf( "Error: could not enable handler\n" );
exit( 1 );
}
getchar();
/* Disable the handler */
if( sr_dishdlr( dxxxdev, EV_ANYEVT, dx_handler ) == -1 )
{
printf( "Error: could not disable handler\n" );
exit( 1 );
}
}

Linux  long sr_GetThreadDeviceGroup (long *Devices,int *NumDevices)
Windows  int sr_GetThreadDeviceGroup (long *Devices,int *NumDevices)

参数：设备指针，设备个数

返回值：0成功 －1失败

作用：返回该线程创建的所有设备句柄。

示例程序：

#define MAX_DEVICES 96
#define DEVICES_PER_TRUNK 24

EventPollThread ()
{
long Devices [MAX_DEVICES];
int DevNum, index;
long EventHandle;
for (DevNum = 0; DevNum < DEVICES_PER_TRUNK; DevNum++)
{
Devices [DevNum] = dx_open(...);
}
sr_CreateThreadDeviceGroup (Devices);
while (1)
{
sr_WaitThreadDeviceGroup (-1);
// do something with the event
if (done == true)
{
break;
}
}
DevNum = MAX_DEVICES;
sr_GetThreadDeviceGroup (&Devices, &DevNum);
printf ("%d devices in the device group:\n", DevNum);
for (index = 0; index < DevNum; index++)
{
// NOTE: This loop will execute 24 times
printf ("Device handle #%2d: %d\n", index, Devices[index]);
}
sr_DeleteThreadDeviceGroup();
}

Linux long sr_DeleteThreadDeviceGroup(void)
Windows  int sr_DeleteThreadDeviceGroup(void)

参数：空

返回值：0成功  －1 失败

作用：移除所有的该线程创建的设备句柄组。

示例程序：

EventPollThread ()
long Devices [24];
int DevNum;
long EventHandle;
for (DevNum = 0; DevNum < 24; DevNum++)
Devices [DevNum] = dx_open(...);
sr_CreateThreadDeviceGroup (Devices);
while (1)
sr_WaitThreadDeviceGroup (-1);
// do something with the event
if (done == true)
{
break;
}
}
sr_DeleteThreadDeviceGroup();
}

Linux long sr_CreateThreadDeviceGroup (long *Devices,int NumDevices)
Windows int sr_CreateThreadDeviceGroup (long *Devices,int NumDevices)

参数：设备句柄指针。设备句柄个数。

返回值：0成功 －1失败

示例程序：

EventPollThread ()
{
long Devices [24];
int DevNum;
long EventHandle;
for (DevNum = 0; DevNum < 24; DevNum++)
{
Devices [DevNum] = dx_open(...);
}
sr_CreateThreadDeviceGroup (Devices, 24);
while (1)
{
sr_WaitThreadDeviceGroup (-1);
// do something with the event
}
}

Linux long sr_AddToThreadDeviceGroup (long *evices, int NumDevices)
Windows: int sr_AddToThreadDeviceGroup (long *evices,int NumDevices)

参数：一列设备句柄列表的头指针。设备列表中设备句柄的个数。

返回值：0成功  -1失败

示例程序;

EventPollThread ()
{
long Devices [24];
int DevNum;
long EventHandle;
for (DevNum = 0; DevNum < 24; DevNum++)
{
Devices [DevNum] = dx_open(...);
}
sr_CreateThreadDeviceGroup (Devices);
while (1)
{
sr_WaitThreadDeviceGroup (-1);
// do something with the event
if (done == true)
{
break;
}
}

参数：设备句柄

返回值：设备句柄的子设备的数目

示例程序：

#include <srllib.h>
#include <dxxxlib.h>
int main()
{
        int dxxxdev;
        /* Open a dxxx channel device */
        if(( dxxxdev = dx_open( "dxxxB1", 0 )) == -1 )
        {
                printf( "Error: cannot open device\n" );
                exit( 1 );
        }
        printf( "Device has %d subdevices\n", ATDV_SUBDEVS( dxxxdev ));
        return 0;
}

参数：设备句柄

返回值：用来打开这个设备的字符串。设备名例如:
• dxxxBbCc

• dtiBbTt

b 代表系统中的板卡号。

c 代表真实或虚拟D/4x板卡中的频道号

t  表示数字网络接口中的时间片序号

示例程序：

#include <srllib.h>
#include <dxxxlib.h>
int main(){
        int dxxxdev;
        /* Open a dxxx channel device */
        if(( dxxxdev = dx_open( "dxxxB1C1", 0 )) == -1 )
        {
                printf( "Error: cannot open device\n" );
                exit( 1 );
        }
        printf( "Device name is %s\n", ATDV_NAMEP( dxxxdev ));
        return 1;
}

参数：设备句柄

返回值：句柄无效Linux返回EDV_BADDESC Windows返回
AT_FAILURE，否则返回一个错误代码。错误代码在DEVICElib.h中定义。

示例程序：

#include <srllib.h>
#include <dxxxlib.h>
int main(){
        int dxxxdev;
        int parm = ET_RON;
        /* Open dxxx channel device */
        if(( dxxxdev = dx_open( "dxxxB1C1", 0 )) == -1 )
        {
                printf( "Error: cannot open device\n" );
                exit( 1 );
        }
        /*Attempt to set a board level parameter on a channel device-will fail */
        if( dx_setparm( dxxxdev, DXBD_R_EDGE, &parm ) == -1 )
        {
                printf( "The last error on the device was 0x%x\n", ATDV_LASTERR( dxxxdev ));
        }
}