LoadRunner函数大全之中文解释

msnshow

// lrc_save_uint_by_ref  函数将  
//  无符号  integer  类型值保存在字符串中，  
//  并将  val  设置为指向该字符串。VuGen  将此  
//  函数生成为注释掉的调用。如果要将此值  
//  用作参数，可以更改  name  并取消调用的注释。  
int lrc_save_uint_by_ref(const char* name, unsigned int *val);  
  
//  输入表示  long  类型的字符串时，lrc_long  函数  
//  返回长整型值。  
long lrc_long(const char* str);  
  
//  输入表示  long  类型的字符串时，lrc_long_by_ref  函数  
//  返回指向长整型值的指针。  
long* lrc_long_by_ref(const char* str);  
  
// lrc_save_long  函数将长整型值  
//  保存在指定变量  name  下的字符串中，  
//   以便您可以将其用于参数化。VuGen   
//  将此函数生成为注释掉的调用。如果  
//  要将此值用作参数，可以更改  name   
//  并取消调用的注释。  
int lrc_save_long(const char* name, long val);  
  
// lrc_save_long_by_ref  函数将长整型值保存在字符串中，  
//  并将  val  设置为指向该字符串。  
int lrc_save_long_by_ref(const char* name, long *val);  
  
//  输入表示无符号  long  类型值的字符串时，  
// lrc_ulong  函数返回无符号长整型值。  
unsigned long lrc_ulong(const char* str);  
  
//  输入表示无符号  long  类型值的字符串时，  
// lrc_ulong_by_ref  函数返回指向无符号长整型值  
//  的指针。  
unsigned long* lrc_ulong_by_ref(const char* str);  
  
// lrc_save_ulong  函数将无符号  
//  长整型值保存在指定变量  name  下  
//  的字符串中，以便您可以将其用于参数化。  
// VuGen  将此函数生成为注释掉的调用。  
//  如果要将此值用作参数，可以更改  name   
//  并取消调用的注释。  
int lrc_save_ulong(const char* name, unsigned long val);

msnshow

// lrc_save_ulong_by_ref  函数将无符号长整型值保存为字符串，  
//  并将  val  设置为指向该字符串。  
int lrc_save_ulong_by_ref(const char* name, unsigned long *val);  
  
//  输入表示短整型值的字符串时，lrc_short  函数  
//  返回短整型值。  
short lrc_short(const char* str);  
  
//  输入表示短整型值的字符串时，lrc_short_by_ref  函数  
//  返回指向短整型值的  
//  指针。  
short* lrc_short_by_ref(const char* str);  
  
// lrc_save_short  函数将短整型值保存  
//  在指定变量  name  下的字符串中，以便  
//  您可以将其用于参数化。VuGen  将此  
//  函数生成为注释掉的调用。如果要将此值  
//  用作参数，可以更改  name  并取消调用的  
//  注释。  
int lrc_save_short(const char* name, short val);  
  
// lrc_save_short_by_ref  函数将短整型值保存在字符串中，  
//  并将  val  设置为指向该字符串。  
int lrc_save_short_by_ref(const char* name, short *val);  
  
//  输入表示货币值的字符串时，lrc_currency  函  
//  数返回货币值。  
CY lrc_currency(const char* str);  
  
//  输入表示货币值的字符串时，  
// lrc_currency_by_ref  函数返回指向  
//  货币结构的指针。  
CY* lrc_currency_by_ref(const char* str);  
  
// lrc_save_currency  函数将货币  (CY)  值  
//  保存在指定变量  name  下的字符串中，以便您  
//  可以将其用于参数化。VuGen  将此函数  
//  生成为注释掉的调用。如果要将此值  
//  用作参数，可以更改  name  并取消调用的  
//  注释。  
int lrc_save_currency(const char* name, CY val);  
  
// lrc_save_currency_by_ref  函数将由“val ”

msnshow

//  指针引用的货币值保存到字符串参数中。  
int lrc_save_currency_by_ref(const char* name, CY *val);  
  
//  输入表示  date  类型值的字符串时，  
// lrc_date  函数返回  DATE  类型值。  
DATE lrc_date(const char* str);  
  
//  输入表示  date  类型值的字符串时，lrc_date_by_ref  函数  
//  返回指向  DATE  的指针。  
DATE* lrc_date_by_ref(const char* str);  
  
// lrc_save_date  函数将  date  类型值保存  
//  为字符串。VuGen  将此函数生成为注释掉的调用。  
//  如果要将此值用作参数，可以更改  name  并取消  
//  调用的注释。  
int lrc_save_date(const char* name, DATE val);  
  
// lrc_save_date_by_ref  函数将  date  类型值保存为字符串。  
int lrc_save_date_by_ref(const char* name, DATE *val);  
  
//  输入包含“true ”或“false ”的字符串时，  
// lrc_bool  函数返回  Boolean  类型值。  
VARIANT_BOOL lrc_bool(const char* str);  
  
//  输入包含“true ”或“false ”的字符串时，  
// lrc_bool_by_ref  函数返回指向  Boolean   
//  类型值的指针。  
VARIANT_BOOL* lrc_bool_by_ref(const char* str);  
  
// lrc_save_bool  函数将  Boolean  类型值  
//  保存为字符串参数。VuGen  将此函数生成为  
//  注释掉的调用。如果要将此值用作参数，可以  
//  更改  name  并取消调用的注释。  
int lrc_save_bool(const char* name, VARIANT_BOOL val);  
  
// lrc_save_bool_by_ref  函数将  Boolean  类型值  
//  保存到字符串参数中。  
int lrc_save_bool_by_ref(const char* name, VARIANT_BOOL *val);  
  
//  输入表示无符号短整型值的字符串时，  
// lrc_ushort  函数返回无符号  
//  短整型值。  
unsigned short lrc_ushort(const char* str);

msnshow

//  输入表示无符号短整型值的字符串时，  
// lrc_ushort_by_ref  函数返回指向无符号短整型值  
//  的指针。  
unsigned short* lrc_ushort_by_ref(const char* str);  
  
// lrc_save_ushort  函数将无符号  
//  短整型值保存在参数中。  
int lrc_save_ushort(const char* name, unsigned short val);  
  
// lrc_save_ushort_by_ref  函数将无符号短整型值  
//  保存到参数中。  
int lrc_save_ushort_by_ref(const char* name, unsigned short *val);  
  
//  输入包含浮点数的字符串时，  
// lrc_float  函数返回浮点数。  
float lrc_float(const char* str);  
  
//  输入包含浮点数的字符串时，  
// lrc_float_by_ref  函数返回指向浮点数  
//  的指针。  
float* lrc_float_by_ref(const char* str);  
  
// lrc_save_float  函数将浮点类型  
//  浮点值保存在字符串参数中。VuGen  将此  
//  函数生成为注释掉的调用。如果要使用  
//  该参数，可以更改  name  并取消调用的  
//  注释。  
int lrc_save_float(const char* name, float val);  
  
// lrc_save_float_by_ref  函数将浮点  
//  类型浮点值保存在字符串参数中。  
int lrc_save_float_by_ref(const char* name, float *val);  
  
//  输入包含  double  类型值的字符串时，  
// lrc_double  函数返回  double  类型值。  
double lrc_double(const char* str);  
  
//  输入包含  double  类型值的字符串时，lrc_double_by_ref   
//  函数返回指向  double  类型值的指针。  
double* lrc_double_by_ref(const char* str);  
  
// lrc_save_double  函数将双精度浮点类型值保存在字符串参数中。VuGen  将此函数生成为注释掉的调用。如果要将此值用作参数，可以更改  name  并取消调用的注释。

msnshow

int lrc_save_double(const char* name, double val);  
  
// lrc_save_double_by_ref  函数将双精度浮点  
//  类型值保存在字符串参数中。  
int lrc_save_double_by_ref(const char* name, double *val);  
  
//  输入包含  dword  类型值的字符串时，lrc_dword  函数  
//  返回双字类型值。  
DWORD lrc_dword(const char* str);  
  
// lrc_save_dword  函数将双字类型值  
//  保存在字符串参数中。VuGen  将此函数  
//  生成为注释掉的调用。如果要将此值用作  
//  参数，可以更改  name  并取消调用的注释。  
int lrc_save_dword(const char* name, DWORD val);  
  
// lrc_BSTR  函数将任何字符串转换为  BSTR 。  
BSTR lrc_BSTR(const char* str);  
  
// lrc_save_BSTR  函数将  BSTR  值保存  
//  为字符串参数。VuGen  将此函数生成为  
//  注释掉的调用。如果要将此值用作参数，  
//  可以更改  name  并取消调用的注释。  
int lrc_save_BSTR(const char* name, BSTR val);  
  
// lrc_ascii_BSTR  函数将字符串  
//  转换为  ascii_BSTR 。  
BSTR lrc_ascii_BSTR(const char* str);  
  
// lrc_ascii_BSTR_by_ref  函数将字符串转换  
//  为  ascii_BSTR ，并返回指向该  BSTR  的指针。  
BSTR* lrc_ascii_BSTR_by_ref(const char* str);  
  
//  当不再使用  COM  对象时，  
// lrc_Release_Object  函数释放该对象。  
//  释放对象后，对象的引用计数将减  1  
                                                      
//   （例如，IUnknown_1  到  IUnknown_0 ）。
//   
int lrc_Release_Object(const char* interface);  
  
// lrc_save_ascii_BSTR  函数将  ascii BSTR  保存  
//  到字符串参数中。VuGen  将此函数生成为注释掉的调用。

msnshow

//  如果要将此值用作参数，可以更改  name  并取消调用的  
//  注释。  
int lrc_save_ascii_BSTR(const char* name, BSTR val);  
  
// lrc_save_ascii_BSTR_by_ref  函数将  ascii BSTR  保  
//  存到字符串参数中。  
int lrc_save_ascii_BSTR_by_ref(const char* name, BSTR *val);  
  
// lrc_save_VARIANT  函数将任何数据类型的值  
//  保存到字符串参数中。  
int lrc_save_VARIANT(const char* name, VARIANT val);  
  
// lrc_save_variant_<Type-Name>  函数系列  
//   由  VuGen  生成，用于将指定的  <Type-Name>   
//  变量保存为字符串参数。VuGen  将这些代码行  
//  生成为注释掉的调用。如果要将此值用作参数，  
//  可以更改  name  并取消调用的  
//  注释。  
int lrc_save_variant_<Type-Name>(const char* name, VARIANT val);  
  
// lrc_save_variant_short  将  short  变量类型值保存到字符串参数中。  
int lrc_save_variant_short(const char* name, VARIANT val);  
  
// lrc_save_variant_ushort  将  short  变量类型值保存到字符串参数中。  
int lrc_save_variant_ushort(const char* name, VARIANT val);  
  
// lrc_save_variant_char  将  short  变量类型值保存到字符串参数中。  
int lrc_save_variant_char(const char* name, VARIANT val);  
  
// lrc_save_variant_int  将  int  变量类型值保存到字符串参数中。  
int lrc_save_variant_int(const char* name, VARIANT val);  
  
// lrc_save_variant_uint  将无符号  integer  变量  
//  类型值到字符串参数中。  
int lrc_save_variant_uint(const char* name, VARIANT val);  
  
// lrc_save_variant_ulong  将无符号  long  变量  
//  类型值保存到字符串参数中。  
int lrc_save_variant_ulong(const char* name, VARIANT val);  
  
// lrc_save_variant_BYTE  将  BYTE  变量类型值保存到字符串参数中。  
int lrc_save_variant_BYTE(const char* name, VARIANT val);  
  
// lrc_save_variant_long  将  long  变量类型值保存到字符串参数中。

msnshow

int lrc_save_variant_long(const char* name, VARIANT val);  
  
// lrc_save_variant_float  将  float  变量类型值保存到字符串参数中。  
int lrc_save_variant_float(const char* name, VARIANT val);  
  
// lrc_save_variant_double  将  double  变量  
//  类型值保存到字符串参数中。  
int lrc_save_variant_double(const char* name, VARIANT val);  
  
// lrc_save_variant_bool  将  boolean  变量类型值保存到字符串参数中。  
int lrc_save_variant_bool(const char* name, VARIANT val);  
  
// lrc_save_variant_scode  将  scode  变量类型值保存到字符串参数中。  
int lrc_save_variant_scode(const char* name, VARIANT val);  
  
// lrc_save_variant_currency  将  currency  变量  
//  类型值保存到字符串参数中。  
int lrc_save_variant_currency(const char* name, VARIANT val);  
  
// lrc_save_variant_date  将  DATE  变量类型值保存到字符串参数中。  
int lrc_save_variant_date(const char* name, VARIANT val);  
  
// lrc_save_variant_BSTR  将  BSTR  变量类型值保存到字符串参数中。  
int lrc_save_variant_BSTR(const char* name, VARIANT val);  
  
// lrc_save_variant_<Type-Name>_by_ref  函数  
//  系列由  VuGen  生成，以便将通过变量中的引用方式  
//  存储的、指定了  <Type-Name>  的变量保存为字符串  
//  参数。VuGen  将这些代码行生成为注释掉的调用。  
//  如果要将此值用作参数，可以更改  name  并取消调用的  
//  注释。  
//   
int lrc_save_variant_<Type-Name>_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_short_by_ref  将通过变量中  
//  的引用方式存储的值保存为参数。  
int lrc_save_variant_short_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_ushort_by_ref  将  
//  通过变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_ushort_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_char_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。

msnshow

int lrc_save_variant_char_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_int_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_int_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_uint_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_uint_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_ulong_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_ulong_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_BYTE_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_BYTE_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_long_by_ref  将  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_long_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_float_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_float_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_double_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_double_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_bool_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_bool_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_scode_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_scode_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_currency_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_currency_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_date_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。

msnshow

int lrc_save_variant_date_by_ref(const char* name, VARIANT val);  
  
// lrc_save_variant_BSTR_by_ref  将通过  
//  变量中的引用方式存储的值保存为参数。  
int lrc_save_variant_BSTR_by_ref(const char* name, VARIANT val);  
  
// lrc_BYTE  函数将字符串转换  
//  为无符号字符（字节）数值。  
BYTE lrc_BYTE(const char* str);  
  
// lrc_BYTE_by_ref  函数将字符串转换  
//  为无符号字符（字节）数值，并返回指向该字节  
//  的指针。  
char * lrc_BYTE_by_ref(const char* str);  
  
// lrc_save_BYTE  函数将  byte  类型值保存为参数。  
// VuGen  将此函数生成为注释掉的调用。如果要将此值  
//  用作参数，可以更改  param_name  并取消调用的  
//  注释。  
int lrc_save_BYTE(const char* param_name, BYTE val);  
  
// lrc_save_BYTE_by_ref  函数将  byte   
//  类型值保存为参数。VuGen  将此函数生成为  
//  注释掉的调用。如果要将此值用作参数，可以  
//  更改  param_name  并取消调用的注释。  
int lrc_save_BYTE_by_ref(const char* param_name, BYTE *val);  
  
//  输入表示超级整型值的字符串时，lrc_hyper  函  
//  数返回超级（64  位）整型值。  
hyper lrc_hyper(const char* str);  
  
//  输入表示超级整型值的字符串时，  
// lrc_hyper_by_ref  函数返回指向  
//  超级（64  位）整型值的指针。  
hyper* lrc_hyper_by_ref(const char* str);  
  
// lrc_save_hyper  函数将  64  位超级  
//  整型值保存在字符串参数中。VuGen  将  
//  此函数生成为注释掉的调用。如果要将  
//  此值用作参数，可以更改  name  并取消  
//  调用的注释。  
int lrc_save_hyper(const char* name, hyper val);  
  
// lrc_save_hyper_by_ref  函数将  64  位

msnshow

//  超级整型值保存到字符串参数中。  
int lrc_save_hyper_by_ref(const char* name, hyper *val);  
  
//  输入表示无符号超级整型值的字符串时，  
// lrc_uhyper  函数返回无符号超级  
//  （64  位）整型值。  
uhyper lrc_uhyper(const char* str);  
  
//  输入表示无符号超级整型值的字符串时，  
// lrc_uhyper_by_ref  函数返回指向  
//  无符号超级（64  位）整型值。  
uhyper* lrc_uhyper_by_ref(const char* str);  
  
// lrc_save_uhyper  函数将无符号  64  位  
//  超级整型值保存在字符串参数中。VuGen  将  
//  此函数生成为注释掉的调用。如果要将此值  
//  用作参数，可以更改  name  并取消调用的  
//  注释。  
int lrc_save_uhyper(const char* name, uhyper val);  
  
// lrc_save_uhyper_by_ref  函数将无符号   
// 64  位超级整型值保存到字符串参数中。VuGen   
//  将此函数生成为注释掉的调用。如果要将此值  
//  用作参数，可以更改  name  并取消调用的  
//  注释。  
int lrc_save_uhyper_by_ref(const char* name, uhyper *val);  
  
// lrc_char  函数将包含  char  类型数值  
//  的字符串转换为  char  变量。  
char lrc_char(const char* str);  
  
// lrc_char_by_ref  函数将包含  char  类型数值的  
//  字符串转换为  char  变量。  
char* lrc_char_by_ref(const char* str);  
  
// lrc_save_char  函数将  char 类型   
// (0 - 127)  保存到字符串参数中。  
// VuGen  将此函数生成为注释掉的调用。  
//  如果要将此值用作参数，可以更改  name   
//  并取消调用的注释。  
int lrc_save_char(const char* name, char val);  
  
// lrc_save_char_by_ref  函数将  char  类型   
// (0 - 127)  保存到字符串参数中。VuGen  将此函数生成为注释掉的调用。如果要将此值  
//  用作参数，可以更改  name  并取消调用的  
//  注释。  
int lrc_save_char_by_ref(const char* name, char *val);  
  
// lrc_variant_empty  函数返回空变量。  
VARIANT lrc_variant_empty();  
  
// lrc_variant_empty_by_variant  返回  
//  包含对空变量引用的变量。  
VARIANT lrc_variant_empty_by_variant();  
  
// lrc_variant_null  函数返回  null  变量。  
VARIANT lrc_variant_null();  
  
// lrc_variant_null_by_variant  返回  
//  包含对  null  变量引用的变量。  
VARIANT lrc_variant_null_by_variant();  
  
// lrc_variant_short  函数将字符串转换为  
//  短整型值，并在变量中将其返回。  
VARIANT lrc_variant_short(const char* str);  
  
// lrc_variant_short_by_variant  函数将字符串  
//  转换为短整型值，并返回包含对某变量（其中包含  
//  该短整型值）引用的变量。  
VARIANT lrc_variant_short_by_variant(const char* str);  
  
// lrc_variant_ushort  函数将字符串转换为  
//  无符号短整型值，并在变量中将其返回。  
VARIANT lrc_variant_ushort(const char* str);  
  
// lrc_variant_char  函数将字符串转换为   
// char  类型值，并在变量中将其返回。  
VARIANT lrc_variant_char(const char* str);  
  
// lrc_variant_int  函数将字符串转换为整型   
//  值，并在变量中将其返回。  
VARIANT lrc_variant_int(const char* str);  
  
// lrc_variant_uint  函数将字符串转换为  
//  无符号整型值，并将其存储在变量中返回。  
VARIANT lrc_variant_uint(const char* str);

msnshow

// lrc_variant_ulong  函数将字符串转换为  
//  无符号长整型值，并将其存储在变量中返回。  
VARIANT lrc_variant_ulong(const char* str);  
  
// lrc_variant_BYTE  函数将字符串转换为  
//  无符号  char (byte)  类型值并存储于变量中。  
VARIANT lrc_variant_BYTE(const char* str);  
  
// lrc_variant_BYTE_by_variant  函数将字符串  
//  转换为无符号  char (byte)  类型值，并返回包含  
//  对某变量（包含该  byte ）引用的变量。  
VARIANT lrc_variant_BYTE_by_variant(const char* str);  
  
// lrc_variant_long  函数将字符串  
//  转换为存储于变量中的长整型值。  
VARIANT lrc_variant_long(const char* str);  
  
// lrc_variant_long_by_variant  函数将  
//  字符串转换为存储于变量中的长整型值，并且  
//  返回包含对某变量（其中包含该长整型值）  
//  引用的变量。  
VARIANT lrc_variant_long_by_variant(const char* str);  
  
// lrc_variant_float  函数将字符串转换为  
//  存储于变量中的浮点类型值。  
VARIANT lrc_variant_float(const char* str);  
  
// lrc_variant_float_by_variant  函数将  
//  字符串转换为浮点类型值，并且返回包含对某  
//  变量（其中包含该值）引用的变量。  
VARIANT lrc_variant_float_by_variant(const char* str);  
  
// lrc_variant_double  函数将字符串转换为  
//  存储于变量中的双精度型浮点值。  
VARIANT lrc_variant_double(const char* str);  
  
// lrc_variant_double_by_variant  函数将  
//  字符串转换为双精度型值，并且返回包含对某变量  
//  （其中包含该值）引用的变量。  
VARIANT lrc_variant_double_by_variant(const char* str);  
  
// lrc_variant_bool  函数将包含“true ”或“false ”  
//  的字符串转换为存储于变量中的  Boolean  类型值。  
VARIANT lrc_variant_bool(const char* str);

msnshow

// lrc_variant_bool_by_variant  函数将  
//  包含“true ”或“false ”的字符串转换为   
// Boolean  值，并且返回包含对某变量（其中  
//  包含该值）引用的变量。  
VARIANT lrc_variant_bool_by_variant(const char* str);  
  
// lrc_variant_scode  函数将包含系统错误代码值的。  
//  字符串转换为存储于变量中的错误代码  
VARIANT lrc_variant_scode(const char* errcode);  
  
// lrc_variant_scode_by_variant  函数将  
//  包含系统错误代码值的字符串转换为错误代码，  
//  并且返回包含对某变量（其中包含该值）引用  
//  的变量。  
VARIANT lrc_variant_scode_by_variant(const char* errcode);  
  
// lrc_variant_currency  函数将包含货币值  
//  的字符串转换为存储于变量中的货币值。  
VARIANT lrc_variant_currency(const char* str);  
  
// lrc_variant_currency_by_variant  函数  
//  将包含货币值的字符串转换为货币值，并且  
//  返回包含对某变量（其中包含该值）引用的  
//  变量。  
VARIANT lrc_variant_currency_by_variant(const char* str);  
  
// lrc_variant_date  函数将包含  date  类型值的  
//  字符串转换为存储于变量中的  date  类型值。  
VARIANT lrc_variant_date(const char* str);  
  
// lrc_variant_date_by_variant  函数将  
//  包含  date  类型值的字符串转换为  date  类型值，  
//  并且返回包含对某变量（其中包含该  date  类型值）  
//  引用的变量。  
VARIANT lrc_variant_date_by_variant(const char* str);  
  
// lrc_variant_BSTR  函数将字符串转换为  
//  存储于变量中的  BSTR  类型值。  
VARIANT lrc_variant_BSTR(const char* str);  
  
// lrc_variant_BSTR_by_variant  函数将字符串  
//  转换为  BSTR  值，并且返回包含对某变量（其中  
//  包含该值）引用的变量。

msnshow

VARIANT lrc_variant_BSTR_by_variant(const char* str);  
  
// lrc_variant_ascii_BSTR  函数将字符串分配给  
//  存储于变量中的  ASCII BSTR  值  
VARIANT lrc_variant_ascii_BSTR(const char* str);  
  
// lrc_variant_CoObject  函数将  IUnknown  接口  
//  指针分配给变量。  
VARIANT lrc_variant_CoObject(IUnknown* pUnknown);  
  
// lrc_variant_CoObject_by_variant  函数将  
//    IUnknown  接口指针分配给变量，并且返回  
//  包含对某变量（其中包含  IUnknown  引用）  
//  引用的变量。  
VARIANT lrc_variant_CoObject_by_variant(IUnknown* pUnknown);  
  
// lrc_variant_DispObject  函数将  
//    IDispatch  接口指针分配给变量。  
VARIANT lrc_variant_DispObject(IDispatch* pDispatch);  
  
// lrc_variant_DispObject_by_variant  函数  
//  将  IDispatch  接口指针分配给变量，并且返回包含  
//  对某变量（其中包含  IDispatch  引用）引用的  
//  变量。  
VARIANT lrc_variant_DispObject_by_variant(IDispatch* pDispatch);  
  
// lrc_variant_short_by_ref  函数将字符串  
//  分配给通过变量中的引用方式存储的短整型值。  
VARIANT lrc_variant_short_by_ref(const char* str);  
  
// lrc_variant_ushort_by_ref  函数将字符串  
//  分配给通过变量中的引用方式存储的无符号短整型值。  
VARIANT lrc_variant_ushort_by_ref(const char* str);  
  
// lrc_variant_char_by_ref  函数将字符串分配  
//  给通过变量中的引用方式存储的  char  类型值。  
VARIANT lrc_variant_char_by_ref(const char* str);  
  
// lrc_variant_int_by_ref  函数将字符串分配给  
//  通过变量中的引用方式存储的  integer  类型值。  
VARIANT lrc_variant_int_by_ref(const char* str);  
  
// lrc_variant_uint_by_ref  函数将字符串分配给  
//  通过变量中的引用方式存储的无符号  integer  类型值。

msnshow

VARIANT lrc_variant_uint_by_ref(const char* str);  
  
// lrc_variant_ulong_by_ref  函数将字符串分配给  
//  通过变量中的引用方式存储的长整型值。  
VARIANT lrc_variant_ulong_by_ref(const char* str);  
  
// lrc_variant_BYTE_by_ref  函数将字符串分配给  
//  通过变量中的引用方式存储的  char (byte)  类型值。  
VARIANT lrc_variant_BYTE_by_ref(const char* str);  
  
// lrc_variant_long_by_ref  函数将字符串分配给  
//  通过变量中的引用方式存储的长整型值。  
VARIANT lrc_variant_long_by_ref(const char* str);  
  
// lrc_variant_float_by_ref  函数将字符串分配给  
//  通过变量中的引用方式存储的浮点型浮点值。  
VARIANT lrc_variant_float_by_ref(const char* str);  
  
// lrc_variant_double_by_ref  函数将字符串分配给  
//  通过变量中的引用方式存储的双精度型值。  
VARIANT lrc_variant_double_by_ref(const char* str);  
  
// lrc_variant_bool_by_ref  函数将包含“true ”  
//  或“false ”的字符串分配给通过变量中的  
//  引用方式存储的  Boolean  类型值。  
VARIANT lrc_variant_bool_by_ref(const char* str);  
  
// lrc_variant_scode_by_ref  函数将包含  
//  系统错误代码值的字符串分配给通过变量中的  
//  引用方式存储的错误代码中。  
VARIANT lrc_variant_scode_by_ref(const char* str);  
  
// lrc_variant_currency_by_ref  函数将字符串  
//  分配给通过变量中的引用方式存储的货币类型值。  
VARIANT lrc_variant_currency_by_ref(const char* str);  
  
// lrc_variant_date_by_ref  函数将字符串  
//  分配给通过变量中的引用方式存储的  date  类型值。  
VARIANT lrc_variant_date_by_ref(const char* str);  
  
// lrc_variant_BSTR_by_ref  函数将字符串分配给的  
//  通过变量中引用方式存储的  BSTR  值。  
VARIANT lrc_variant_BSTR_by_ref(const char* str);

msnshow

// lrc_variant_ascii_BSTR_by_ref  函数将字符串  
//  分配给通过变量中的引用方式存储的  ascii BSTR  值。  
VARIANT lrc_variant_ascii_BSTR_by_ref(const char* str);  
  
// lrc_variant_CoObject_by_ref  函数将指针  
//  分配给变量中的  IUnknown  接口。  
VARIANT lrc_variant_CoObject_by_ref(IUnknown* pUnknown);  
  
// lrc_variant_DispObject_by_ref  函数将指针  
//  转换为变量中的  IDispatch  接口。  
VARIANT lrc_variant_DispObject_by_ref(IDispatch* pDispatch);  
  
// lrc_variant_variant_by_ref  函数创建包含现有  
//  变量的新变量。  
VARIANT lrc_variant_variant_by_ref(VARIANT * pVar);  
  
// lrc_variant_from_variant_by_ref  函数从  
//  另一个变量引用中获取变量。  
VARIANT lrc_variant_from_variant_by_ref(VARIANT var);  
  
// Create<n>D<Type-Name>Array  函数系列  
//  创建由  Type-name  指定的类型的  n  维数组。  
//  对于每一维，该调用必须指定  lower_bound   
//  和  upper_bound 。  
<Type-Name> Array Create<n>D<Type-Name>Array(int lower_bound,int upper_bound, int  
lower_bound, int upper_bound...);  
  
// Destroy<Type-Name>Array  函数系列销毁  
//   由  Type-name  指定的类型的数组。对于在  
//  脚本中（而非由  VuGen ）创建的数组，可以使用  
//  它们恢复内存。  
void Destroy<Type-Name>Array(<Type-Name>Array Array);  
  
// DestroyBoolArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyBoolArray(BoolArray Array);  
  
// DestroyBstrArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyBstrArray(BstrArray Array);  
  
// DestroyByteArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyByteArray(ByteArray Array);

msnshow

// DestroyCharArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyCharArray(CharArray Array);  
  
// DestroyCoObjectArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyCoObjectArray(CoObjectArray Array);  
  
// DestroyCurrencyArray  释放由数组占用的内存。于  
//  该函数用恢复由脚本为数组分配的内存。  
void DestroyCurrencyArray(CurrencyArray Array);  
  
// DestroyDateArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyDateArray(CurrencyArray Array);  
  
// DestroyDispObjectArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyDispObjectArray(DispObjectArray Array);  
  
// DestroyDoubleArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyDoubleArray(DoubleArray Array);  
  
// DestroyErrorArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyErrorArray(ErrorArray Array);  
  
// DestroyFloatArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyFloatArray(FloatArray Array);  
  
// DestroyIntArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyIntArray(IntArray Array);  
  
// DestroyLongArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyLongArray(LongArray Array);  
  
// DestroyShortArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyShortArray(ShortArray Array);

msnshow

// DestroyUIntArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyUIntArray(UIntArray Array);  
  
// DestroyULongArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyULongArray(ULongArray Array);  
  
// DestroyUShortArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyUShortArray(UShortArray Array);  
  
// DestroyVariantArray  释放由数组占用的内存。  
//  该函数用于恢复由脚本为数组分配的内存。  
void DestroyVariantArray(VariantArray Array);  
  
// GetBufferFrom<n>DByteArray  函数系列从  n  维   
// byte  类型数组的最后一维中提取缓冲区。此函数  
//  的返回值是一个指向  byte  类型的缓冲区的指针。  
//  缓冲区的大小返回到  *plinesize  所指定的  
//  地址中。  
char * GetBufferFrom<n>DByteArray(ByteArray Array, int ind1...indn-1, size_t *pLineSize);  
  
// Fill<n>DByteArray  函数系列将  n  维  byte  数组  
//  的最后一维中填充缓冲区的内容。  
char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-1, const char* buffer, size_t  
buff_size);  
  
// lrc_variant_<Type-Name>Array  函数系列将在   
// Type-Name  中指定的类型的数组分配给变量。  
VARIANT lrc_variant_<Type-Name>Array(<Type-Name>Array array);  
  
// lrc_variant_BoolArray  将数组分配给变量。  
VARIANT lrc_variant_BoolArray(BoolArray array);  
  
// lrc_variant_BstrArray  将数组分配给变量。  
VARIANT lrc_variant_BstrArray(BstrArray array);  
  
// lrc_variant_ByteArray  将数组分配给变量。  
VARIANT lrc_variant_ByteArray(ByteArray array);  
  
// lrc_variant_CharArray  将数组分配给变量。  
VARIANT lrc_variant_CharArray(CharArray array);

msnshow

// lrc_variant_CoObjectArray  将数组分配给变量。  
VARIANT lrc_variant_CoObjectArray(CoObjectArray array);  
  
// lrc_variant_CurrencyArray  将数组分配给变量。  
VARIANT lrc_variant_CurrencyArray(CurrencyArray array);  
  
// lrc_variant_DateArray  将数组分配给变量。  
VARIANT lrc_variant_DateArray(DateArray array);  
  
// lrc_variant_DispObjectArray  将数组分配给变量。  
VARIANT lrc_variant_DispObjectArray(DispObjectArray array);  
  
// lrc_variant_DoubleArray  将数组分配给变量。  
VARIANT lrc_variant_DoubleArray(DoubleArray array);  
  
// lrc_variant_ErrorArray  将数组分配给变量。  
VARIANT lrc_variant_ErrorArray(ErrorArray array);  
  
// lrc_variant_FloatArray  将数组分配给变量。  
VARIANT lrc_variant_FloatArray(FloatArray array);  
  
// lrc_variant_IntArray  将数组分配给变量。  
VARIANT lrc_variant_IntArray(IntArray array);  
  
// lrc_variant_LongArray  将数组分配给变量。  
VARIANT lrc_variant_LongArray(LongArray array);  
  
// lrc_variant_ShortArray  将数组分配给变量。  
VARIANT lrc_variant_ShortArray(ShortArray array);  
  
// lrc_variant_UintArray  将数组分配给变量。  
VARIANT lrc_variant_UintArray(UintArray array);  
  
// lrc_variant_UlongArray  将数组分配给变量。  
VARIANT lrc_variant_UlongArray(UlongArray array);  
  
// lrc_variant_UshortArray  将数组分配给变量。  
VARIANT lrc_variant_UshortArray(UshortArray array);  
  
// lrc_variant_VariantArray  将数组分配给变量。  
VARIANT lrc_variant_VariantArray(VariantArray array);

msnshow

// lrc_variant_<Type-Name>Array_by_ref  函数系列返回对由  Type-name  指定的类型的数组的引用。返回类型  
//  为变量。  
VARIANT lrc_variant_<Type-Name>Array_by_ref( <Type-Name>Array array );  
  
// lrc_variant_BoolArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_BoolArray_by_ref(BoolArray array);  
  
// lrc_variant_BstrArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_BstrArray_by_ref(BstrArray array);  
  
// lrc_variant_ByteArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_ByteArray_by_ref(ByteArray array);  
  
// lrc_variant_CharArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_CharArray_by_ref(CharArray array);  
  
// lrc_variant_CoObjectArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_CoObjectArray_by_ref(CoObjectArray array);  
  
// lrc_variant_CurrencyArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_CurrencyArray_by_ref(CurrencyArray array);  
  
// lrc_variant_DateArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_DateArray_by_ref(DateArray array);  
  
// lrc_variant_DispObjectArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_DispObjectArray_by_ref(DispObjectArray array);  
  
// lrc_variant_DoubleArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_DoubleArray_by_ref(DoubleArray array);  
  
// lrc_variant_ErrorArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_ErrorArray_by_ref(ErrorArray array);  
  
// lrc_variant_FloatArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_FloatArray_by_ref(FloatArray array);  
  
// lrc_variant_IntArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_IntArray_by_ref(IntArray array);  
  
// lrc_variant_LongArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_LongArray_by_ref(LongArray array);  
  
// lrc_variant_ShortArray_by_ref  返回对数组的引用

msnshow

VARIANT lrc_variant_ShortArray_by_ref(ShortArray array);  
  
// lrc_variant_UintArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_UintArray_by_ref(UintArray array);  
  
// lrc_variant_UlongArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_UlongArray_by_ref(UlongArray array);  
  
// lrc_variant_UshortArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_UshortArray_by_ref(UshortArray array);  
  
// lrc_variant_VariantArray_by_ref  返回对数组的引用  
VARIANT lrc_variant_VariantArray_by_ref(VariantArray array);  
  
// lrc_Get<Type-Name>ArrayFromVariant  函数系列从变量中  
//  提取由  Type-name  指定的类型的数组。  
<Type-Name> lrc_Get<Type-Name>ArrayFromVariant const VARIANT* var);  
  
// lrc_GetBoolArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetBoolArrayFromVariant(const VARIANT* var);  
  
// lrc_GetBstrArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetBstrArrayFromVariant(const VARIANT* var);  
  
// lrc_GetByteArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetByteArrayFromVariant(const VARIANT* var);  
  
// lrc_GetCharArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetCharArrayFromVariant(const VARIANT* var);  
  
// lrc_GetCoObjectArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetCoObjectArrayFromVariant(const VARIANT* var);  
  
// lrc_GetCoInstanceArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetCoInstanceArrayFromVariant(const VARIANT* var);  
  
// lrc_GetCurrencyArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetCurrencyArrayFromVariant(const VARIANT* var);  
  
// lrc_GetDateArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetDateArrayFromVariant(const VARIANT* var);  
  
// lrc_GetDispObjectArrayFromVariant  从变量中提取数组。  
VARIANT lrc_GetDispObjectArrayFromVariant(const VARIANT* var);