智能交易*姚文档站

第七章转换函数

这一组函数可以将数据从一种格式(类型)转换为另一种格式(类型)。

必须特别注意NormalizeDouble()函数，因为它提供了表达价格的必要准确性。在交易操作中，如果价格的精确度超过了交易服务器所需的精确度，则会被视为不正常的报价，交易服务器不能使用没有格式化过的价格。

函数	功能
CharToString	转换符号代码到字符串
DoubleToString	以规定的精确度转换数字值到文本行
EnumToString	将任何类型的枚举值转换为字符串
NormalizeDouble	浮点数转换到规定的精确度
StringToDouble	转换包括数字代表符的字符串到双精度数字
StringToInteger	转换包括数字代表符的字符串到整型数字
StringToTime	转换包括 "yyyy.mm.dd [hh:mi]"格式的时间或者日期字符串到日期时间型
TimeToString	转换01.01.1970值到 "yyyy.mm.dd hh:mi"字符串格式
IntegerToString	整型转换成当前长度字符串
ShortToString	转换符号代码（双字节编码）到单字符串
ShortArrayToString	复制数组部分到字符串
StringToShortArray	符号-wise复制字符串到选定的无符号短整型部分数组
CharArrayToString	转换符号代码（ansi）到单符号数组
StringToCharArray	符号-wise 复制双字节编码到ANSI转换的字符串，到选定的无符字符型数组
CharArrayToStruct	将uchar类型数组复制到POD结构
StructToCharArray	将POD结构复制到uchar类型数组
ColorToARGB	转换color类型到uint类型，接收ARGB颜色显示
ColorToString	转换颜色值到"R,G,B"形式的字符串
StringToColor	转换"R,G,B" 字符串或者颜色名的字符串到颜色类型值
StringFormat	按照现格式转换数字到字符串

相关参考

使用字符编码集

# 7.1 CharToString

将一个字符型的值转换为只包含一个字符的字符串型的值。

string  CharToString( 
   uchar  char_code      // 交易品种的数值代码 
   );

1
2
3

参数

char_code

[in] ANSI字符

返回值

包含一个ANSI字符的字符串。

# 7.2 CharArrayToString

将uchar类型数组的一部分复制并转换为返回的字符串。

string  CharArrayToString( 
   uchar  array[],              // 数组 
   int    start=0,              // 开始复制数组的索引开始位置 
   int    count=-1              // 复制数组元素的数量 
   uint    codepage=CP_ACP      // 代码页 
   );

1
2
3
4
5
6

参数

array[]

[in] uchar类型的数组

Start = 0

[in] 数组中开始复制的索引位置，默认值是0

Count = -1

[in] 复制数组元素的数量，定义返回字符串的长度，默认值是 -1，这表示一直复制到数组的最后一个元素，或直到终止0。

Codepage = CP_ACP

[in] 使用的字符编码集，最常用的字符编码集有许多内置常量。

返回值

字符串

# 7.3 CharArrayToStruct

将uchar类型数组复制到POD结构。

bool  CharArrayToStruct( 
   void&         struct_object,    //结构 
   const uchar&  char_array[],     //数组 
   uint          start_pos=0       // 数组中的起始位置 
   );

1
2
3
4
5

参数

struct_object

[in] 参考任何类型的POD结构（只包含简单的数据类型）。

char_array[]

[in] uchar类型数组。

start_pos=0

[in] 数组中的位置，从这里开始复制数据。

返回值

如果成功返回true，否则返回false。

另见

StringToCharArray、 ShortArrayToString、StructToCharArray、使用代码页、FileReadStruct、 Unions (union)、MathSwap

# 7.4 StructToCharArray

将POD结构复制到uchar类型数组。

bool  StructToCharArray( 
   const void&  struct_object,     //结构 
   uchar&       char_array[],      // 数组 
   uint         start_pos=0        // 数组中的起始位置 
   );

1
2
3
4
5

参数

struct_object

[in] 参考任何类型的POD结构（只包含简单的数据类型）。

char_array[]

[in] uchar类型数组。

start_pos=0

[in] 数组中的位置，从这里开始添加复制的数据。

返回值

如果成功返回true，否则返回false。

注意

当复制时，如果没有足够的空间，动态数组将自动展开(ArrayResize)。如果数组不能展开到所需的值，该函数将返回一个错误。

另见

StringToCharArray、 ShortArrayToString、CharArrayToStruct、使用代码页、FileWriteStruct、 Unions (union)、MathSwap

# 7.5 ColorToARGB

该函数将颜色类型转换为uint类型以获取颜色的ARGB表示。ARGB颜色格式用于生成图形资源，文本展示，以及被用在CCanvas标准程序库类。

uint  ColorToARGB( 
   color  clr,          // 用来转换的 颜色值 
   uchar  alpha=255     // 阿尔法通道管理彩色透明度 
   );

1
2
3
4

参数

clr

[in] 颜色类型变量的颜色值。

alpha

[in] 阿尔法通道的值用来接收ARGB格式的颜色。该值可以从0（前景像素颜色不改变根本显示的颜色）设置到255（基本像素的颜色被前景像素颜色替代）。彩色透明度计算为 (1-alpha/255)*100%。换句话说，阿尔法通道的值越小颜色越透明

。用于接收ARGB格式的颜色的alpha通道的值。值可以从0(全透明——前景像素的颜色不影响底层的显示)到255(不透明——底层像素的颜色完全被前景像素的颜色所取代)。颜色透明度百分比计算为(1-alpha/255)*100%。换句话说，alpha通道的值越小，显示的颜色越透明。

返回值

以ARGB格式显示颜色，在这里Alfa, Red, Green, Blue（阿尔法通道，红，绿，蓝）的值按照四种uint类型字节系列设置。

注意

RGB是一种基本的、常用的格式，用于在计算机图形屏幕上显示像素颜色。基本颜色的名称用来设置红色，绿色和蓝色的成分。每个组件由一个字节来描述，该字节指定0到255之间的颜色饱和度(十六进制格式的0x00到0XFF)。由于白色包含所有颜色，所以它被描述为0xFFFFFF，即每三个组件中的每一个都由0xFF的最大值来表示。

然而，如果它以带有透明度的颜色覆盖，那么一些任务需要指定色彩透明度以便描述图形。阿尔法通道就是为此引入的。它作为RGB格式的额外组件实施。ARGB格式结构显示如下。

ARGB

ARGB值通常使用十六进制格式表示，每一对数字分别表示Alpha、红、绿和蓝色通道的值。例如，80FFFF00颜色代表50.2%不透明黄色。最初，0x80设置50.2%的alpha值，因为它是0xFF值的50.2%。然后，第一个FF对定义了红色组件的最高值;下一个FF就像之前的，但对于绿色部分;最后的00对表示蓝色组件可以拥有的最小值(没有蓝色)。绿色和红色的结合产生黄色。如果没有使用alpha通道，则可以将条目简化为6 RRGGBB位数，这就是为什么alpha通道值存储在uint整数类型的顶部。

根据上下文，十六进制数字可以用“0x”或“#”前缀写，例如，80FFFF00, 0x80FFFF00或#80FFFF00。

示例：

//+------------------------------------------------------------------+
//| 脚本程序开始函数                                                   |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- 设置透明度
   uchar alpha=0x55;  // 0x55 意即 55/255=21.6 % 的透明度   
   //--- 转换clrBlue 到 ARGB
   PrintFormat("0x%.8X - clrBlue",clrBlue);
   PrintFormat("0x%.8X - clrBlue ARGB with alpha=0x55 (transparency 21.6%%)",ColorToARGB(clrBlue,alpha));
   //--- 转换clrGreen 到 ARGB
   PrintFormat("0x%.8X - clrGreen",clrGreen);
   PrintFormat("0x%.8X - clrGreen ARGB with alpha=0x55 (transparency 21.6%%)",ColorToARGB(clrGreen,alpha));
   //--- 转换clrRed color 到 ARGB 
   PrintFormat("0x%.8X - clrRed",clrRed);
   PrintFormat("0x%.8X - clrRed ARGB with alpha=0x55 (transparency 21.6%%)",ColorToARGB(clrRed,alpha));
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

相关参考

资源， ResourceCreate()， TextOut()，颜色类型，char, short, int 和长整型

# 7.6 ColorToString

转换颜色值为字符串 RGB形式

string  ColorToString( 
   color  color_value,     // 颜色值 
   bool   color_name       // 是否显示颜色名称 
   );

1
2
3
4

参数

color_value

[in] 颜色类型的变量颜色值

color_name

[in] 如果颜色名称与某个预定义的颜色常量相同，有必要返回颜色名称。

返回值

描述颜色的"R,G,B"字符串，其中R,G,B是十进制常量，从0到255转换为字符串。如果设置了color_name = true参数，它将尝试将颜色值转换为颜色名称。

示例：

string clr=ColorToString(C'0,255,0'); // 绿色 
Print(clr); 
  
clr=ColorToString(C'0,255,0',true);   // 获得颜色常量 
Print(clr);

1
2
3
4
5

# 7.7 DoubleToString

把数字值转换为文本串

string  DoubleToString( 
   double  value,      // 数字 
   int     digits=8    // 小数点后的数字数 
   );

1
2
3
4

参数

value

[in] 浮点类型的数字值

digits

[in] 精度格式。如果digits值在0到16之间的范围内，则将获得在小数点后具有指定位数的字符串表示法。如果digits值介于 -1和 -16之间，则将获得在小数点后指定位数的科学计数格式的字符串表示法。在所有其它情况下，字符串值将包含小数点后的8位数字。

返回值

包含具有指定准确度的数字字符串。

示例：

Print("DoubleToString(120.0 + M_PI) : ",DoubleToString(120.0+M_PI)); 
Print("DoubleToString(120.0 + M_PI,16) : ",DoubleToString(120.0+M_PI,16)); 
Print("DoubleToString(120.0 + M_PI,-16) : ",DoubleToString(120.0+M_PI,-16)); 
Print("DoubleToString(120.0 + M_PI,-1) : ",DoubleToString(120.0+M_PI,-1)); 
Print("DoubleToString(120.0 + M_PI,-20) : ",DoubleToString(120.0+M_PI,-20));

1
2
3
4
5

相关参考

NormalizeDouble ， StringToDouble

# 7.8 EnumToString

将任何枚举值转换为文本形式。

string  EnumToString( 
   any_enum  value      // 任何枚举值 
   );

1
2
3

参数

value

[in] 任何类型的枚举值。

返回值

枚举文本显示字符串。若要获得错误信息，请调用GetLastError() 函数。

注意

该函数可能在 _LastError 变量中设置以下错误值: • ERR_INTERNAL_ERROR —— 执行环境错误 • ERR_NOT_ENOUGH_MEMORY —— 内存不足无法完成操作 • ERR_INVALID_PARAMETER —— 枚举值名称错误

示例：

enum interval  // 命名常量的枚举 
  { 
   month=1,     // 一个月 
   two_months,  // 两个月 
   quarter,     // 三个月 - 一季度 
   halfyear=6,  // 半年 
   year=12,     // 一年 - 12 个月 
  }; 
//+------------------------------------------------------------------+ 
//| 脚本程序起始函数                                                   | 
//+------------------------------------------------------------------+ 
void OnStart() 
  { 
//--- 设置变量 period 等于一个月的时间 
   interval period=month; 
   Print(EnumToString(period)+"="+IntegerToString(period));
 
//--- 设置变量 period等于一个季度（三个月）的时间 
   period=quarter; 
   Print(EnumToString(period)+"="+IntegerToString(period));
 
//--- 设置变量 period等于一年（12个月）的时间 
   period=year; 
   Print(EnumToString(period)+"="+IntegerToString(period));
 
//--- 检查订单类型如何显示 
   ENUM_ORDER_TYPE type=ORDER_TYPE_BUY; 
   Print(EnumToString(type)+"="+IntegerToString(type));
 
//--- 检查错误值如何显示 
   type=WRONG_VALUE; 
   Print(EnumToString(type)+"="+IntegerToString(type));
 
// 结果： 
// 月份=1 
// 季度=3 
// 年=12 
// ORDER_TYPE_BUY=0 
// ENUM_ORDER_TYPE::-1=-1 
  }

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

相关参考

枚举，输入变量

# 7.9 IntegerToString

此函数将整数类型的值转换为指定长度的字符串，并返回获取的字符串。

string  IntegerToString( 
   long    number,              // 数字 
   int     str_len=0,           // 字符串长度 
   ushort  fill_symbol=' '      // 填充字符 
   );

1
2
3
4
5

参数

number

[in] 转换的数字

str_len=0

[in] 字符串长度。如果生成的字符串长度大于指定的长度，则字符串不会被截断。如果小于，填充符号将被添加到字符串的左侧。

fill_symbol=' '

[in] 用于填补的字符，默认为空格。

返回值

字符串。

# 7.10 ShortToString

将字符(unicode) 转换为只包含一个字符的字符串，并返回结果字符串。

string  ShortToString( 
   ushort  symbol_code      // 字符 
   );

1
2
3

参数

symbol_code

[in] 字符代码。在这里，您可以使用包含一个字符的字符串或包含与Unicode表中与字符相对应的2字节十六进制代码的字符串。

返回值

字符串。

# 7.11 ShortArrayToString

将数组的一部分复制到返回的字符串中。

string  ShortArrayToString( 
   ushort  array[],      // 数组 
   int     start=0,      // 数组中的启动位置 
   int     count=-1      // 交易品种数 
   );

1
2
3
4
5

参数

array[]

[in] 无符号短整型(ushort)数组(wchar_t类型的模拟)。

start=0

[in] 开始位置，复制开始的索引编号，默认是0

Count = -1

[in] 复制数组元素的数量，定义返回字符串的长度，默认值是 -1，这表示一直复制到数组的最后一个元素，或直到终止0。

返回值

字符串。

# 7.12 TimeToString

将包含自1970年1月1日以来经过的秒数的值转换为 "yyyy.mm.dd hh:mi" 格式的字符串。

string  TimeToString( 
   datetime  value,                           // 数字 
   int       mode=TIME_DATE|TIME_MINUTES      // 输出形式 
   );

1
2
3
4

参数

value

[in] 时间从00:00 1970/01/01开始

mode=TIME_DATE|TIME_MINUTES

[in] 额外的数据输入格式，可以是一个或组合的标志：

"yyyy.mm.dd"为形式的标签TIME_DATE ,

以"hh:mi"为结果的 TIME_MINUTES ，

以 "hh:mi:ss"为结果的TIME_SECONDS 。

返回值

字符串。

# 7.13 NormalizeDouble

把浮点类型转换为指定精确度

double  NormalizeDouble( 
   double  value,      // 标准化号码 
   int     digits      // 小数点后的数字数 
   );

1
2
3
4

参数

value

[in] 浮点类型的数值

digits

[in] 精度格式，小数点后的位数(0-8)。

返回值

具有预设精确度的双精度类型的数值。

注意

止损，止盈和挂单价格的计算值必须用NormalizeDouble()标准化，其值可以通过Digits()获得。

请注意，当使用Print()函数打印输出到日志时，NormalizeDouble()标准化之后的数字可能包括比你想象的更多的小数位。例如：

   double a=76.671;             // 三个小数位的标准数字 
   Print("Print(76.671)=",a);   // 输出为 
   Print("DoubleToString(a,8)=",DoubleToString(a,8)); // 以预设精度输出

1
2
3

在客户端您将看到以下信息：

 DoubleToString(a,8)=76.67100000
 Print(76.671)=76.67100000000001

1
2

示例：

   double pi=M_PI; 
   Print("pi = ",DoubleToString(pi,16)); 
       
   double pi_3=NormalizeDouble(M_PI,3); 
   Print("NormalizeDouble(pi,3) = ",DoubleToString(pi_3,16)) 
   ; 
   double pi_8=NormalizeDouble(M_PI,8); 
   Print("NormalizeDouble(pi,8) = ",DoubleToString(pi_8,16)); 
    
   double pi_0=NormalizeDouble(M_PI,0); 
   Print("NormalizeDouble(pi,0) = ",DoubleToString(pi_0,16)); 
/* 
   Result: 
   pi= 3.1415926535897931 
   NormalizeDouble(pi,3)= 3.1419999999999999 
   NormalizeDouble(pi,8)= 3.1415926499999998 
   NormalizeDouble(pi,0)= 3.0000000000000000 
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

相关参考

DoubleToString ，真实型(双精度，浮点) ，类型转换

# 7.14 StringToCharArray

将字符从Unicode转换为ANSI的字符串，并复制到uchar类型的数组中的选定位置。返回复制元素的数量。

int  StringToCharArray( 
   string  text_string,         // 源字符串 
   uchar&  array[],             // 数组 
   int     start=0,             // 数组中的启动位置 
   int     count=-1             // 交易品种数 
   uint    codepage=CP_ACP      // 代码页 
   );

1
2
3
4
5
6
7

参数

text_string

[in] 复制的字符串

array[]

[out] 无符字符型(uchar)数组

start=0

[in] 开始复制的起始位置，默认值是0

Count = -1

[in] 复制数组元素的数量，定义返回字符串的长度，默认值是 -1，这表示一直复制到数组的最后一个元素，或直到终止0。终端0也将被复制到目标数组中，在这种情况下，动态数组的大小可以根据需要增加到字符串的大小。如果动态数组的大小超过字符串的长度，则数组的大小不会减小。

codepage=CP_ACP

[in] 使用的字符编码集，最常用的字符编码集有许多内置常量。

返回值

复制元素的数量

# 7.15 StringToColor

使用颜色名称将RGB字符串型转变成颜色类型值

color  StringToColor( 
   string  color_string      // 字符串颜色表示 
   );

1
2
3

参量

color_string

[in] 代表颜色的RGB类型字符串类型或者其中一种预定义网页-颜色名称

返回值

颜色值

示例：

   color str_color=StringToColor("0,127,0"); 
   Print(str_color); 
   Print((string)str_color); 
//--- 变换颜色 
   str_color=StringToColor("0,128,0"); 
   Print(str_color); 
   Print((string)str_color);

1
2
3
4
5
6
7

另见

ColorToString, ColorToARGB

# 7.16 StringToDouble

将字符串转变为双精度型数字

double  StringToDouble( 
   string  value      // 字符串 
   );

1
2
3

参数

value

[in] 数字的字符串形式

返回值

双精度型值

# 7.17 StringToInteger

将字符串型转换成整数型数值。

long  StringToInteger( 
   string  value      // 字符串 
   );

1
2
3

参数

value

[in] 数字的字符串形式

返回值

整数型值

# 7.18 StringToShortArray

该函数以字符方式将字符串复制到ushort类型数组中的指定位置。返回复制元素的数量。

int  StringToShortArray( 
   string  text_string,     // 源字符串 
   ushort& array[],         // 数组 
   int     start=0,         // 数组的索引开始位置 
   int     count=-1         // 字符数量 
   );

1
2
3
4
5
6

参量 text_string [in] 字符串复制 array[] [out] 无符号短型(ushort)数组（wchar_t类型模拟） start=0 [in] 位置，开始复制的索引位置，默认值是0 count=-1 [in] 复制数组元素的数量，定义返回字符串的长度，默认值是 -1，这表示一直复制到数组的最后一个元素，或直到终止0。终端0也将被复制到目标数组中，在这种情况下，动态数组的大小可以根据需要增加到字符串的大小。如果动态数组的大小超过字符串的长度，则数组的大小不会减小。返回值复制元素的数量

# 7.19 StringToTime

该函数将包含“yyyy.mm.dd [hh：mi]”格式的字符串转换为日期时间类型的值。

datetime  StringToTime( 
   string  value      // 日前字符串 
   );

1
2
3

参数

value

[in] 以" yyyy.mm.dd hh:mi " 为格式的字符串形式

返回值

时间日期型的值，自01.01.1970起的秒数。

# 7.20 StringFormat

函数格式获得参数并返回字符串。

string  StringFormat( 
   string  format,     // 带有格式描述的字符串 
   ...     ...         // 参量 
   );

1
2
3
4

参数

format

[in] 包含格式规则方法的字符串。格式规则与 PrintFormat函数相同。

...

[in] 参数，用逗号分开。

返回值

字符串。

示例：

void OnStart()
  {
//--- 字符串变量
   string output_string;
   string temp_string;
   string format_string;
//--- 准备规范标题
   temp_string=StringFormat("Contract specification for %s:\n",_Symbol);
   StringAdd(output_string,temp_string);
//--- 整型值输出
   int digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
   temp_string=StringFormat("   SYMBOL_DIGITS = %d (number of digits after the decimal point)\n",
                            digits);
   StringAdd(output_string,temp_string);
//--- 小数点后可变数位的双精度值输出
   double point_value=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
   format_string=StringFormat("   SYMBOL_POINT = %%.%df (point value)\n",
                              digits);
   temp_string=StringFormat(format_string,point_value);
   StringAdd(output_string,temp_string);
//--- 整型值输出
   int spread=(int)SymbolInfoInteger(_Symbol,SYMBOL_SPREAD);
   temp_string=StringFormat("   SYMBOL_SPREAD = %d (current spread in points)\n",
                            spread);
   StringAdd(output_string,temp_string);
//--- 整型值输出
   int min_stop=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
   temp_string=StringFormat("   SYMBOL_TRADE_STOPS_LEVEL = %d (minimal indention in points for Stop orders)\n",
                            min_stop);
   StringAdd(output_string,temp_string);
//--- 无小数部分的双精度值输出
   double contract_size=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_CONTRACT_SIZE);
   temp_string=StringFormat("   SYMBOL_TRADE_CONTRACT_SIZE = %.f (contract size)\n",
                            contract_size);
   StringAdd(output_string,temp_string);
//--- 默认精度的双精度值输出
   double tick_size=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
   temp_string=StringFormat("   SYMBOL_TRADE_TICK_SIZE = %f (minimal price change)\n",
                            tick_size);
   StringAdd(output_string,temp_string);
//--- 决定库存费计算模式
   int swap_mode=(int)SymbolInfoInteger(_Symbol,SYMBOL_SWAP_MODE);
   string str_swap_mode;
   switch(swap_mode)
     {
      case SYMBOL_SWAP_MODE_DISABLED: str_swap_mode="SYMBOL_SWAP_MODE_DISABLED (no swaps)"; break;
      case SYMBOL_SWAP_MODE_POINTS: str_swap_mode="SYMBOL_SWAP_MODE_POINTS (in points)"; break;
      case SYMBOL_SWAP_MODE_CURRENCY_SYMBOL: str_swap_mode="SYMBOL_SWAP_MODE_CURRENCY_SYMBOL (in money, in base currency of the symbol)"; break;
      case SYMBOL_SWAP_MODE_CURRENCY_MARGIN: str_swap_mode="SYMBOL_SWAP_MODE_CURRENCY_MARGIN (in money, in margin currency of the symbol)"; break;
      case SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT: str_swap_mode="SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT (in money, in client deposit currency)"; break;
      case SYMBOL_SWAP_MODE_INTEREST_CURRENT: str_swap_mode="SYMBOL_SWAP_MODE_INTEREST_CURRENT (as the specified annual interest from the instrument price at calculation of swap)"; break;
      case SYMBOL_SWAP_MODE_INTEREST_OPEN: str_swap_mode="SYMBOL_SWAP_MODE_INTEREST_OPEN (as the specified annual interest from the position open price)"; break;
      case SYMBOL_SWAP_MODE_REOPEN_CURRENT: str_swap_mode="SYMBOL_SWAP_MODE_REOPEN_CURRENT (by reopening positions by the close price +/- specified number of points)"; break;
      case SYMBOL_SWAP_MODE_REOPEN_BID: str_swap_mode="SYMBOL_SWAP_MODE_REOPEN_BID (by reopening positions by the current Bid price +/- specified number of points)"; break;
     }
//--- 字符串值输出
   temp_string=StringFormat("   SYMBOL_SWAP_MODE = %s\n",
                            str_swap_mode);
   StringAdd(output_string,temp_string);
//--- 默认精度的双精度值输出
   double swap_long=SymbolInfoDouble(_Symbol,SYMBOL_SWAP_LONG);
   temp_string=StringFormat("   SYMBOL_SWAP_LONG = %f (long swap value)\n",
                            swap_long);
   StringAdd(output_string,temp_string);
//--- 默认精度的双精度值输出
   double swap_short=SymbolInfoDouble(_Symbol,SYMBOL_SWAP_SHORT);
   temp_string=StringFormat("   SYMBOL_SWAP_SHORT = %f (short swap value)\n",
                            swap_short);
   StringAdd(output_string,temp_string);
//--- 决定交易模式
   int trade_mode=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_MODE);
   string str_trade_mode;
   switch(trade_mode)
     {
      case SYMBOL_TRADE_MODE_DISABLED: str_trade_mode="SYMBOL_TRADE_MODE_DISABLED (trade is disabled for the symbol)"; break;
      case SYMBOL_TRADE_MODE_LONGONLY: str_trade_mode="SYMBOL_TRADE_MODE_LONGONLY (only long positions are allowed)"; break;
      case SYMBOL_TRADE_MODE_SHORTONLY: str_trade_mode="SYMBOL_TRADE_MODE_SHORTONLY (only short positions are allowed)"; break;
      case SYMBOL_TRADE_MODE_CLOSEONLY: str_trade_mode="SYMBOL_TRADE_MODE_CLOSEONLY (only position close operations are allowed)"; break;
      case SYMBOL_TRADE_MODE_FULL: str_trade_mode="SYMBOL_TRADE_MODE_FULL (no trade restrictions)"; break;
     }
//--- 字符串值输出
   temp_string=StringFormat("   SYMBOL_TRADE_MODE = %s\n",
                            str_trade_mode);
   StringAdd(output_string,temp_string);
//--- 压缩格式的双精度值输出
   double volume_min=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   temp_string=StringFormat("   SYMBOL_VOLUME_MIN = %g (minimal volume for a deal)\n",volume_min);
   StringAdd(output_string,temp_string);
//--- 压缩格式的双精度值输出
   double volume_step=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   temp_string=StringFormat("   SYMBOL_VOLUME_STEP = %g (minimal volume change step)\n",volume_step);
   StringAdd(output_string,temp_string);
//--- 压缩格式的双精度值输出
   double volume_max=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   temp_string=StringFormat("   SYMBOL_VOLUME_MAX = %g (maximal volume for a deal)\n",volume_max);
   StringAdd(output_string,temp_string);
//--- 确定合约价格计算模式
   int calc_mode=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_CALC_MODE);
   string str_calc_mode;
   switch(calc_mode)
     {
      case SYMBOL_CALC_MODE_FOREX:str_calc_mode="SYMBOL_CALC_MODE_FOREX (Forex)";break;
      case SYMBOL_CALC_MODE_FUTURES:str_calc_mode="SYMBOL_CALC_MODE_FUTURES (futures)";break;
      case SYMBOL_CALC_MODE_CFD:str_calc_mode="SYMBOL_CALC_MODE_CFD (CFD)";break;
      case SYMBOL_CALC_MODE_CFDINDEX:str_calc_mode="SYMBOL_CALC_MODE_CFDINDEX (CFD for indices)";break;
      case SYMBOL_CALC_MODE_CFDLEVERAGE:str_calc_mode="SYMBOL_CALC_MODE_CFDLEVERAGE (CFD at leverage trading)";break;
      case SYMBOL_CALC_MODE_EXCH_STOCKS:str_calc_mode="SYMBOL_CALC_MODE_EXCH_STOCKS (trading securities on a stock exchange)";break;
      case SYMBOL_CALC_MODE_EXCH_FUTURES:str_calc_mode="SYMBOL_CALC_MODE_EXCH_FUTURES (trading futures contracts on a stock exchange)";break;
      case SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS:str_calc_mode="SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS (trading futures contracts on FORTS)";break;
     }
//--- 字符串值输出
   temp_string=StringFormat("   SYMBOL_TRADE_CALC_MODE = %s\n",
                            str_calc_mode);
   StringAdd(output_string,temp_string);
//--- 小数点后两位的双精度值输出
   double margin_initial=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_INITIAL);
   temp_string=StringFormat("   SYMBOL_MARGIN_INITIAL = %.2f (initial margin)\n",
                            margin_initial);
   StringAdd(output_string,temp_string);
//--- 小数点后两位的双精度值输出
   double margin_maintenance=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_MAINTENANCE);
   temp_string=StringFormat("   SYMBOL_MARGIN_MAINTENANCE = %.2f (maintenance margin)\n",
                            margin_maintenance);
   StringAdd(output_string,temp_string);
//--- 整型值输出
   int freeze_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL);
   temp_string=StringFormat("   SYMBOL_TRADE_FREEZE_LEVEL = %d (order freeze level in points)",
                            freeze_level);
   StringAdd(output_string,temp_string);
   Print(output_string);
   Comment(output_string);
/* 执行结果
    EURUSD的合约规范：
     SYMBOL_DIGITS = 5 (小数点后的数位)
     SYMBOL_POINT = 0.00001 (点值)
     SYMBOL_SPREAD = 10 (当前点差的点)
     SYMBOL_TRADE_STOPS_LEVEL = 18 (止损订单的最小缩进点)
     SYMBOL_TRADE_CONTRACT_SIZE = 100000 (合约大小)
     SYMBOL_TRADE_TICK_SIZE = 0.000010 (最小价格变动)
     SYMBOL_SWAP_MODE = SYMBOL_SWAP_MODE_POINTS (点)
     SYMBOL_SWAP_LONG = -0.700000 (买入订单的库存费的值)
     SYMBOL_SWAP_SHORT = -1.000000 (卖出订单的库存费的值)
     SYMBOL_TRADE_MODE = SYMBOL_TRADE_MODE_FULL (无交易限制)
     SYMBOL_VOLUME_MIN = 0.01 (一笔成交的最小交易量)
     SYMBOL_VOLUME_STEP = 0.01 (最小交易量变化步骤)
     SYMBOL_VOLUME_MAX = 500 (一笔成交的最大交易量)
     SYMBOL_TRADE_CALC_MODE = SYMBOL_CALC_MODE_FOREX (外汇)
     SYMBOL_MARGIN_INITIAL = 0.00 (初始预付款)
     SYMBOL_MARGIN_MAINTENANCE = 0.00 (维持预付款)
     SYMBOL_TRADE_FREEZE_LEVEL = 0 (订单冻结水平点)
*/
  }

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

相关参考

PrintFormat, DoubleToString,ColorToString, TimeToString

← 07 第七章矩阵和向量方法 09 第九章数学函数 →

第七章 转换函数

# 7.1 CharToString

# 7.2 CharArrayToString

# 7.3 CharArrayToStruct

# 7.4 StructToCharArray

# 7.5 ColorToARGB

# 7.6 ColorToString

# 7.7 DoubleToString

# 7.8 EnumToString

# 7.9 IntegerToString

# 7.10 ShortToString

# 7.11 ShortArrayToString

# 7.12 TimeToString

# 7.13 NormalizeDouble

# 7.14 StringToCharArray

# 7.15 StringToColor

# 7.16 StringToDouble

# 7.17 StringToInteger

# 7.18 StringToShortArray

# 7.19 StringToTime

# 7.20 StringFormat

第七章转换函数