// TdxHqDemoCpp.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <windows.h>

using namespace std;


#pragma region 股票行情
//-------------------------------------------------------------------------------------------------------------------


//开发文档
//

//1.股票行情API均是TdxHqApi.dll文件的导出函数，包括以下函数：
//int   TdxHq_Connect(char* IP, u_short Port, char* Account, char* Password, char* Result, char* ErrInfo);
//void  TdxHq_Disconnect(int ConnectionID);
//bool  TdxHq_GetSecurityCount(int ConnectionID, byte Market, u_short& Result, char* ErrInfo)
//bool  TdxHq_GetSecurityBars(int ConnectionID, byte Category, byte Market, char* Zqdm, u_short Start, u_short& Count, char* Result, char* ErrInfo);
//bool  TdxHq_GetIndexBars(int ConnectionID,byte Category, byte Market, char* Zqdm, u_short Start, u_short& Count, char* Result, char* ErrInfo);
//bool  TdxHq_GetMinuteTimeData(int ConnectionID,byte Market, char* Zqdm, char* Result, char* ErrInfo);
//bool  TdxHq_GetHistoryMinuteTimeData(int ConnectionID,byte Market, char* Zqdm, int date, char* Result, char* ErrInfo);
//bool  TdxHq_GetTransactionData(int ConnectionID,byte Market, char* Zqdm, u_short Start, u_short& Count, char* Result, char* ErrInfo);
//bool  TdxHq_GetHistoryTransactionData(int ConnectionID,byte Market, char* Zqdm, u_short Start, u_short& Count, int date, char* Result, char* ErrInfo);
//bool  TdxHq_GetSecurityQuotes(int ConnectionID,byte Market[], char* Zqdm[], u_short& Count, char* Result, char* ErrInfo);
//bool  TdxHq_GetCompanyInfoCategory(int ConnectionID,byte Market, char* Zqdm, char* Result, char* ErrInfo);
//bool  TdxHq_GetCompanyInfoContent(int ConnectionID,byte Market, char* Zqdm, char* FileName, int Start, int Length, char* Result, char* ErrInfo);
//bool  TdxHq_GetXDXRInfo(int ConnectionID,byte Market[], char* Zqdm[],int Count, char* Result, char* ErrInfo);
//bool  TdxHq_GetFinanceInfo(int ConnectionID,byte Market[], char* Zqdm[], int Count, char* Result, char* ErrInfo);
//bool  TdxHq_GetCallAuctionData(int ConnectionID, byte Market, char* Zqdm, int Start, int& Count, char* Result, char* ErrInfo);

//bool  TdxHq_GetSecurityQuotes10(int ConnectionID, byte Market[], char* Zqdm[], u_short& Count, char* Result, char* ErrInfo);
//bool  TdxHq_GetBuySellQueue(int ConnectionID, byte Market[], char* Zqdm[], int Count, char* Result, char* ErrInfo)
//bool  TdxHq_GetDetailTransactionData(int ConnectionID, byte Market, char* Zqdm, int Start, u_short& Count, char* Result, char* ErrInfo)
//bool  TdxHq_GetDetailOriginalTransactionData(int ConnectionID, byte Market, char* Zqdm, int Start, u_short& Count, char* Result, char* ErrInfo)
//bool  TdxHq_GetDetailOrderData(int ConnectionID, byte Market, char* Zqdm, int Start, u_short& Count, char* Result, char* ErrInfo) 
// 
// 
// 
//2.API使用流程为: 应用程序先调用TdxHq_Connect连接通达信行情服务器,然后才可以调用其他接口获取行情数据,应用程序应自行处理网络断线问题,.
//接口可以建立到服务器的多个连接,这些连接不能跨线程访问,应该每一个线程只访问本线程建立的连接

//3.各个函数功能说明





/// <summary>
///  连接通达信行情服务器,服务器地址可在券商软件登录界面中的通讯设置中查得
/// </summary>
/// <param name="IP">行情服务器IP</param>
/// <param name="Port">行情服务器端口</param>
/// <param name="Account">账号,普通行情是guest, L2行情是L2账号</param>
/// <param name="Password">密码,普通行情是空串, L2行情是L2账号的密码</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返回 ConnectionID, 失败返回-1</returns>
typedef int(__stdcall* TdxHq_ConnectDelegate)(const char* IP, u_short Port, const char* Account, const char* Password, char* Result, char* ErrInfo);


/// <summary>
/// 断开同服务器的连接
/// </summary>
typedef void(__stdcall* TdxHq_DisconnectDelegate)(int ConnectionID);



/// <summary>
/// 获取市场内所有证券的数量
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的证券数量</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetSecurityCountDelegate)(int ConnectionID, byte Market, u_short& Result, char* ErrInfo);


/// <summary>
/// 获取市场内从某个位置开始的1000支股票的股票代码
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Start">股票开始位置,第一个股票是0, 第二个是1, 依此类推,位置信息依据TdxHq_GetSecurityCount返回的证券总数确定</param>
/// <param name="Count">API执行后,保存了实际返回的股票数目,</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的证券代码信息,形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetSecurityListDelegate)(int ConnectionID, byte Market, u_short Start, u_short& Count, char* Result, char* ErrInfo);

/// <summary>
/// 获取证券的K线数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Category">K线种类, 0->5分钟K线    1->15分钟K线    2->30分钟K线  3->1小时K线    4->日K线  5->周K线  6->月K线  7->1分钟  8->1分钟K线  9->日K线  10->季K线  11->年K线< / param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">K线开始位置,最后一条K线位置是0, 前一条是1, 依此类推</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目, API执行后,保存了实际返回的K线数目, 最大值800</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetSecurityBarsDelegate)(int ConnectionID, byte Category, byte Market, const char* Zqdm, u_short Start, u_short& Count, char* Result, char* ErrInfo);


/// <summary>
/// 获取指数的K线数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Category">K线种类, 0->5分钟K线    1->15分钟K线    2->30分钟K线  3->1小时K线    4->日K线  5->周K线  6->月K线  7->1分钟  8->1分钟K线  9->日K线  10->季K线  11->年K线< / param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">K线开始位置,最后一条K线位置是0, 前一条是1, 依此类推</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目, API执行后,保存了实际返回的K线数目,最大值800</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetIndexBarsDelegate)(int ConnectionID, byte Category, byte Market, const char* Zqdm, u_short Start, u_short& Count, char* Result, char* ErrInfo);



/// <summary>
/// 获取分时数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetMinuteTimeDataDelegate)(int ConnectionID, byte Market, const char* Zqdm, char* Result, char* ErrInfo);


/// <summary>
/// 获取历史分时数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Date">日期, 比如2014年1月1日为整数20140101</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetHistoryMinuteTimeDataDelegate)(int ConnectionID, byte Market, const char* Zqdm, int Date, char* Result, char* ErrInfo);


/// <summary>
/// 获取分时成交数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">K线开始位置,最后一条K线位置是0, 前一条是1, 依此类推</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目, API执行后,保存了实际返回的K线数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetTransactionDataDelegate) (int ConnectionID, byte Market, const char* Zqdm, u_short Start, u_short& Count, char* Result, char* ErrInfo);




/// <summary>
/// 获取历史分时成交数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">K线开始位置,最后一条K线位置是0, 前一条是1, 依此类推</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目, API执行后,保存了实际返回的K线数目</param>
/// <param name="Date">日期, 比如2014年1月1日为整数20140101</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetHistoryTransactionDataDelegate) (int ConnectionID, byte Market, const char* Zqdm, u_short Start, u_short& Count, int Date, char* Result, char* ErrInfo);

/// <summary>
/// 批量获取多个证券的五档报价数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海, 第i个元素表示第i个证券的市场代码</param>
/// <param name="Zqdm">证券代码, Count个证券代码组成的数组</param>
/// <param name="Count">API执行前,表示用户要请求的证券数目, API执行后,保存了实际返回的数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetSecurityQuotesDelegate) (int ConnectionID, byte Market[], const char* Zqdm[], u_short& Count, char* Result, char* ErrInfo);





/// <summary>
/// 获取F10资料的分类
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetCompanyInfoCategoryDelegate) (int ConnectionID, byte Market, const char* Zqdm, char* Result, char* ErrInfo);




/// <summary>
/// 获取F10资料的某一分类的内容
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="FileName">类目的文件名, 由TdxHq_GetCompanyInfoCategory返回信息中获取</param>
/// <param name="Start">类目的开始位置, 由TdxHq_GetCompanyInfoCategory返回信息中获取</param>
/// <param name="Length">类目的长度, 由TdxHq_GetCompanyInfoCategory返回信息中获取</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据,出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetCompanyInfoContentDelegate) (int ConnectionID, byte Market, const char* Zqdm, const char* FileName, int Start, int Length, char* Result, char* ErrInfo);




/// <summary>
/// 获取除权除息信息
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海, 第i个元素表示第i个证券的市场代码</param>
/// <param name="Zqdm">证券代码, Count个证券代码组成的数组</param>
/// <param name="Count">API执行前,表示用户要请求的证券数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据,出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetXDXRInfoDelegate) (int ConnectionID, byte Market[], const char* Zqdm[], int Count, char* Result, char* ErrInfo);



/// <summary>
/// 获取财务信息
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海, 第i个元素表示第i个证券的市场代码</param>
/// <param name="Zqdm">证券代码, Count个证券代码组成的数组</param>
/// <param name="Count">API执行前,表示用户要请求的证券数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据,出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetFinanceInfoDelegate) (int ConnectionID, byte Market[], const char* Zqdm[], int Count, char* Result, char* ErrInfo);



/// <summary>
/// 获取集合竞价数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">开始位置</param>
/// <param name="Count">欲获取的条数,API执行后,保存了实际返回的条数</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返回true, 失败返回false</returns>
typedef bool (__stdcall* TdxHq_GetCallAuctionDataDelegate)(int ConnectionID, byte Market, const char*  Zqdm, int Start, int& Count, char* Result, char* ErrInfo);








/// <summary>
/// 批量获取多个证券的十档报价数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海, 第i个元素表示第i个证券的市场代码</param>
/// <param name="Zqdm">证券代码, Count个证券代码组成的数组</param>
/// <param name="Count">API执行前,表示用户要请求的证券数目, API执行后,保存了实际返回的数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetSecurityQuotes10Delegate) (int ConnectionID, byte Market[], const char* Zqdm[], u_short& Count, char* Result, char* ErrInfo);



/// <summary>
/// 获取买卖队列数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetBuySellQueueDelegate) (int ConnectionID, byte Market[], const char* Zqdm[], int Count, char* Result, char* ErrInfo);






/// <summary>
/// 获取逐笔成交数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">K线开始位置,最后一条K线位置是0, 前一条是1, 依此类推</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目, API执行后,保存了实际返回的K线数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetDetailTransactionDataDelegate) (int ConnectionID, byte Market, const char* Zqdm, int Start, u_short& Count, char* Result, char* ErrInfo);



/// <summary>
/// 获取逐笔还原数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">K线开始位置,最后一条K线位置是0, 前一条是1, 依此类推</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目, API执行后,保存了实际返回的K线数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetDetailOriginalTransactionDataDelegate) (int ConnectionID, byte Market, const char* Zqdm, int Start, u_short& Count, char* Result, char* ErrInfo);




/// <summary>
/// 获取逐笔委托数据
/// </summary>
/// <param name="ConnectionID">连接ID</param>
/// <param name="Market">市场代码,   0->深圳     1->上海</param>
/// <param name="Zqdm">证券代码</param>
/// <param name="Start">K线开始位置,最后一条K线位置是0, 前一条是1, 依此类推</param>
/// <param name="Count">API执行前,表示用户要请求的K线数目, API执行后,保存了实际返回的K线数目</param>
/// <param name="Result">此API执行返回后，Result内保存了返回的查询数据, 形式为表格数据，行数据之间通过\n字符分割，列数据之间通过\t分隔。一般要分配1024*1024字节的空间。出错时为空字符串。</param>
/// <param name="ErrInfo">此API执行返回后，如果出错，保存了错误信息说明。一般要分配256字节的空间。没出错时为空字符串。</param>
/// <returns>成功返货true, 失败返回false</returns>
typedef bool(__stdcall* TdxHq_GetDetailOrderDataDelegate) (int ConnectionID, byte Market, const char* Zqdm, int Start, u_short& Count, char* Result, char* ErrInfo);





void L2Hq()
{
	//载入dll, dll要复制到debug目录下,或者release目录下
	HMODULE TdxApiHMODULE = LoadLibrary("TdxHqApi.dll");

	//获取api函数

	TdxHq_ConnectDelegate TdxHq_Connect = (TdxHq_ConnectDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_Connect");
	TdxHq_DisconnectDelegate TdxHq_Disconnect = (TdxHq_DisconnectDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_Disconnect");
	TdxHq_GetSecurityCountDelegate TdxHq_GetSecurityCount = (TdxHq_GetSecurityCountDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetSecurityCount");
	TdxHq_GetSecurityListDelegate TdxHq_GetSecurityList = (TdxHq_GetSecurityListDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetSecurityList");
	TdxHq_GetSecurityBarsDelegate TdxHq_GetSecurityBars = (TdxHq_GetSecurityBarsDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetSecurityBars");
	TdxHq_GetIndexBarsDelegate TdxHq_GetIndexBars = (TdxHq_GetIndexBarsDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetIndexBars");
	TdxHq_GetMinuteTimeDataDelegate TdxHq_GetMinuteTimeData = (TdxHq_GetMinuteTimeDataDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetMinuteTimeData");
	TdxHq_GetHistoryMinuteTimeDataDelegate TdxHq_GetHistoryMinuteTimeData = (TdxHq_GetHistoryMinuteTimeDataDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetHistoryMinuteTimeData");
	TdxHq_GetTransactionDataDelegate TdxHq_GetTransactionData = (TdxHq_GetTransactionDataDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetTransactionData");
	TdxHq_GetHistoryTransactionDataDelegate TdxHq_GetHistoryTransactionData = (TdxHq_GetHistoryTransactionDataDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetHistoryTransactionData");
	TdxHq_GetSecurityQuotesDelegate TdxHq_GetSecurityQuotes = (TdxHq_GetSecurityQuotesDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetSecurityQuotes");
	TdxHq_GetCompanyInfoCategoryDelegate TdxHq_GetCompanyInfoCategory = (TdxHq_GetCompanyInfoCategoryDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetCompanyInfoCategory");
	TdxHq_GetCompanyInfoContentDelegate TdxHq_GetCompanyInfoContent = (TdxHq_GetCompanyInfoContentDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetCompanyInfoContent");
	TdxHq_GetXDXRInfoDelegate TdxHq_GetXDXRInfo = (TdxHq_GetXDXRInfoDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetXDXRInfo");
	TdxHq_GetFinanceInfoDelegate TdxHq_GetFinanceInfo = (TdxHq_GetFinanceInfoDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetFinanceInfo");


	TdxHq_GetSecurityQuotes10Delegate TdxHq_GetSecurityQuotes10 = (TdxHq_GetSecurityQuotes10Delegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetSecurityQuotes10");
	TdxHq_GetBuySellQueueDelegate TdxHq_GetBuySellQueue = (TdxHq_GetBuySellQueueDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetBuySellQueue");
	TdxHq_GetDetailTransactionDataDelegate TdxHq_GetDetailTransactionData = (TdxHq_GetDetailTransactionDataDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetDetailTransactionData");
	TdxHq_GetDetailOriginalTransactionDataTransactionDataDelegate TdxHq_GetDetailOriginalTransactionData = (TdxHq_GetDetailOriginalTransactionDataDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetDetailOriginalTransactionData");
	TdxHq_GetDetailOrderDataDelegate TdxHq_GetDetailOrderData = (TdxHq_GetDetailOrderDataDelegate)GetProcAddress(TdxApiHMODULE, "TdxHq_GetDetailOrderData");

	//开始获取行情数据
	char* Result = new char[1024 * 1024];
	char* ErrInfo = new char[256];



	//连接服务器

	string ServerAddress[] = {
"高级行情_深圳双线1|112.74.31.192|7719",
"高级行情_深圳双线2|124.71.222.84|7719",
"高级行情_深圳双线3|139.9.2.221|7719",
"高级行情_深圳双线4|47.112.105.142|7719",
"高级行情_深圳双线5|120.24.189.167|7719",
"高级行情_上海双线1|139.196.174.113|7719",
"高级行情_上海双线2|47.103.108.38|7719",
"高级行情_上海双线3|139.196.175.118|7719",
"高级行情_武汉电信1|119.97.185.49|7719",
"高级行情_武汉电信2|59.175.238.45|7719",
"高级行情_北京双线1|123.249.28.184|7719",
"高级行情_北京双线2|39.98.108.148|7719",
"高级行情_深圳双线6|139.9.208.12|7719",
"高级行情_深圳双线7|120.76.118.89|7719",
"高级行情_深圳双线8|139.9.211.54|7719",
"高级行情_上海双线4|123.60.164.170|7719",
"高级行情_上海双线5|106.14.221.88|7719",
"高级行情_上海双线6|123.60.162.102|7719",
"高级行情_上海双线7|47.116.113.0|7719",
"高级行情_上海双线8|47.116.113.74|7719",
"高级行情_上海双线9|47.100.220.104|7719",
"高级行情_深圳双线9|139.9.1.206|7719",
"高级行情_北京双线3|39.99.132.128|7719",
"高级行情_深圳双线10|47.112.243.219|7719",
"高级行情_深圳双线11|47.112.176.254|7719",
"高级行情_深圳双线12|47.112.102.66|7719",
"高级行情_北京双线4|119.3.183.88|7719",
"高级行情_北京双线5|139.9.143.183|7719",
"高级行情_北京双线6|120.46.206.187|7719",
"高级行情_上海双线10|47.100.176.37|7719",
"高级行情_上海双线11|101.132.115.34|7719",
"高级行情_上海双线12|106.14.195.70|7719",
"高级行情_深圳双线13|116.205.235.110|7719",
"高级行情_深圳双线14|116.205.238.42|7719",
"高级行情_深圳双线15|116.205.239.160|7719",
	};

	

	int ConnectionID = -1;
	for (auto& it : ServerAddress)
	{
		int k1 = it.find("|", 0);
		int k2 = it.find("|", k1 + 1);
		string Name = it.substr(0, k1);
		string IP = it.substr(k1 + 1, k2 - 1 - k1);
		u_short Port = atoi(it.substr(k2 + 1).c_str());

		cout <<"连接"<< Name <<"[" << IP << ":" << Port<<"]" << endl;
		ConnectionID = TdxHq_Connect(IP.c_str(), Port, "L2账号", "L2密码", Result, ErrInfo); cout << "TdxHq_Connect:" << Result << ErrInfo << endl;
		if (ConnectionID != -1)
		{
			break;
		}
	}




	
	if (ConnectionID == -1)
	{
		return;
	}

	


	//获取证券数量
	byte Market = 0;
	u_short Count = 0;
	bool bool1 = TdxHq_GetSecurityCount(ConnectionID, Market, Count, ErrInfo); cout << "TdxHq_GetSecurityCount:" << Count << ErrInfo << endl;


	//获取证券列表
	u_short Start = 0;
	Count = 0;
	bool1 = TdxHq_GetSecurityList(ConnectionID, Market, Start, Count, Result, ErrInfo); cout << "TdxHq_GetSecurityList:" << Result << ErrInfo << endl;


	//获取股票K线
	byte Category = 4;
	const char* Zqdm = "000001";
	Start = 0;
	Count = 10;
	bool1 = TdxHq_GetSecurityBars(ConnectionID, Category, Market, Zqdm, Start, Count, Result, ErrInfo); cout << "TdxHq_GetSecurityBars:" << Result << ErrInfo << endl;//数据种类, 0->5分钟K线    1->15分钟K线    2->30分钟K线  3->1小时K线    4->日K线  5->周K线  6->月K线  7->1分钟K线  8->1分钟K线  9->日K线  10->季K线  11->年K线


	//获取指数K线
	Start = 0;
	Count = 10;
	bool1 = TdxHq_GetIndexBars(ConnectionID, Category, Market, "399001", Start, Count, Result, ErrInfo); cout << "TdxHq_GetIndexBars:" << Result << ErrInfo << endl;//数据种类, 0->5分钟K线    1->15分钟K线    2->30分钟K线  3->1小时K线    4->日K线  5->周K线  6->月K线  7->1分钟K线  8->1分钟K线  9->日K线  10->季K线  11->年K线




	//获取分时图数据
	bool1 = TdxHq_GetMinuteTimeData(ConnectionID, Market, Zqdm, Result, ErrInfo); cout << "TdxHq_GetMinuteTimeData:" << Result << ErrInfo << endl;

	//获取历史分时图数据
	bool1 = TdxHq_GetHistoryMinuteTimeData(ConnectionID, Market, Zqdm, 20230904, Result, ErrInfo); cout << "TdxHq_GetHistoryMinuteTimeData:" << Result << ErrInfo << endl;


	//获取分笔图数据
	Start = 0;
	Count = 10;
	bool1 = TdxHq_GetTransactionData(ConnectionID, Market, Zqdm, Start, Count, Result, ErrInfo); cout << "TdxHq_GetTransactionData:" << Result << ErrInfo << endl;


	//获取历史分笔图数据
	Start = 0;
	Count = 10;
	bool1 = TdxHq_GetHistoryTransactionData(ConnectionID, Market, Zqdm, Start, Count, 20140904, Result, ErrInfo); ; cout << "TdxHq_GetHistoryTransactionData:" << Result << ErrInfo << endl;



	//获取五档报价数据
	u_short ZqdmCount = 2;
	byte Markets[] = { 0 ,1 };
	const char* Zqdms[] = { "000001","600000" };
	bool1 = TdxHq_GetSecurityQuotes(ConnectionID, Markets, Zqdms, ZqdmCount, Result, ErrInfo); cout << "TdxHq_GetSecurityQuotes:" << Result << ErrInfo << endl;





	//获取F10数据的类别
	bool1 = TdxHq_GetCompanyInfoCategory(ConnectionID, Market, Zqdm, Result, ErrInfo); cout << "TdxHq_GetCompanyInfoCategory:" << Result << ErrInfo << endl;



	//获取F10数据的某类别的内容
	bool1 = TdxHq_GetCompanyInfoContent(ConnectionID, Market, Zqdm, "000001.txt", 0, 100000, Result, ErrInfo); cout << "TdxHq_GetCompanyInfoContent:" << Result << ErrInfo << endl;


	//获取除权除息信息
	bool1 = TdxHq_GetXDXRInfo(ConnectionID, Markets, Zqdms, 2, Result, ErrInfo);  cout << "TdxHq_GetXDXRInfo:" << Result << ErrInfo << endl;


	//获取财务信息
	bool1 = TdxHq_GetFinanceInfo(ConnectionID, Markets, Zqdms, 2, Result, ErrInfo); cout << "TdxHq_GetFinanceInfo:" << Result << ErrInfo << endl;


	//获取集合竞价数据
	int nCount=500;
	bool1 = TdxHq_GetCallAuctionData(ConnectionID, Market, Zqdm, 0,nCount,  Result, ErrInfo); cout << "TdxHq_GetCallAuctionData:" << Result << ErrInfo << endl;




	//获取十档报价数据
	bool1 = TdxHq_GetSecurityQuotes10(ConnectionID, Markets, Zqdms, ZqdmCount, Result, ErrInfo);  cout << "TdxHq_GetSecurityQuotes10:" << Result << ErrInfo << endl;




	//获取买卖队列数据
	bool1 = TdxHq_GetBuySellQueue(ConnectionID, Markets, Zqdms, ZqdmCount, Result, ErrInfo); cout << "TdxHq_GetBuySellQueue:" << Result << ErrInfo << endl;

	//获取逐笔成交数据
	int nStart = 0;
	Count = 10;
	bool1 = TdxHq_GetDetailTransactionData(ConnectionID, Market, Zqdm, nStart, Count, Result, ErrInfo); cout << "TdxHq_GetDetailTransactionData:" << Result << ErrInfo << endl;
	
	
	//获取逐笔还原数据
	nStart = 0;
	Count = 10;
	bool1 = TdxHq_GetDetailOriginalTransactionData(ConnectionID, Market, Zqdm, nStart, Count, Result, ErrInfo); cout << "TdxHq_GetDetailOriginalTransactionData:" << Result << ErrInfo << endl;
	


	//获取逐笔委托数据
	nStart = 0;
	Count = 10;
	bool1 = TdxHq_GetDetailOrderData(ConnectionID, Market, Zqdm, nStart, Count, Result, ErrInfo); cout << "TdxHq_GetDetailOrderData:" << Result << ErrInfo << endl;




	TdxHq_Disconnect(ConnectionID);





	FreeLibrary(TdxApiHMODULE);


}

#pragma endregion



int main()
{
	cout << "股票行情演示:" << endl;
	L2Hq();


	system("pause");
}