typedef复杂函数接口的解释

news2024/9/29 9:36:50

文章目录

  • typedef定义函数解释interface.h接口
      • 1、函数定义
      • 2、函数实现加载动态链接库
      • 3、sdologinentry.dll或者sdologinentry64.dll动态链接库哪个工程生成的并导出三个接口函数
      • 4、sdologinsdk.dll或者sdologinsdk64.dll动态链接库哪个工程生成并导出三个接口函数

typedef定义函数解释interface.h接口

在这里插入图片描述

typedef int (WINAPI* LPSDOLInitialize)(const SDOLAppInfo* pAppInfo);
typedef int (WINAPI* LPSDOLGetModule)(REFIID riid, void** intf);
typedef int (WINAPI* LPSDOLTerminal)();

LPSDOLInitialize m_pfSDOLInitialize;
LPSDOLGetModule m_pfSDOLGetModule;
LPSDOLTerminal m_pfSDOLTerminal;

 m_pfSDOLInitialize = (LPSDOLInitialize)GetProcAddress(m_hSDOLoginModule, "SDOLInitialize");
m_pfSDOLGetModule = (LPSDOLGetModule)GetProcAddress(m_hSDOLoginModule, "SDOLGetModule");
m_pfSDOLTerminal = (LPSDOLTerminal)GetProcAddress(m_hSDOLoginModule, "SDOLTerminal");

代码解释:

  • 这段代码定义了三个函数指针类型的对象 m_pfSDOLInitialize、m_pfSDOLGetModule 和 m_pfSDOLTerminal，分别用于指向动态链接库（DLL）中的函数 SDOLInitialize、SDOLGetModule 和 SDOLTerminal。

  • 然后，通过 GetProcAddress 函数，它尝试从 m_hSDOLoginModule 所代表的 DLL 中运行时候获取这三个函数的地址，并将这些地址分别赋值给 m_pfSDOLInitialize、m_pfSDOLGetModule 和 m_pfSDOLTerminal，使得这些函数指针指向了对应的函数。

  • 这种方式允许你在运行时通过这些函数指针调用 DLL 中的函数，而不需要在编译时链接这些函数。这通常用于动态加载和调用 DLL 中的函数，以实现插件系统或模块化的应用程序架构。

1、函数定义

typedef int (WINAPI* LPSDOLInitialize)(const SDOLAppInfo* pAppInfo);
typedef int (WINAPI* LPSDOLGetModule)(REFIID riid, void** intf);
typedef int (WINAPI* LPSDOLTerminal)();

2、函数实现加载动态链接库

bool Initial(){	
	WCHAR strExePath[MAX_PATH] = { 0 };
	WCHAR strExeName[MAX_PATH] = { 0 };
	WCHAR* strLastSlash = NULL;
	GetModuleFileNameW(NULL, strExePath, MAX_PATH);
	strExePath[MAX_PATH - 1] = 0;
	strLastSlash = wcsrchr(strExePath, TEXT('\\'));
	if (strLastSlash)
	{	// 得到EXE所在路径
		StringCchCopyW(strExeName, MAX_PATH, &strLastSlash[1]);
		*strLastSlash = 0;
		strLastSlash = wcsrchr(strExeName, TEXT('.'));
		if (strLastSlash)
			*strLastSlash = 0;
	}

	WCHAR strGameWidgetDll[MAX_PATH] = { 0 };
#ifdef _WIN64
	StringCchPrintfW(strGameWidgetDll, MAX_PATH, L"%s\\sdo\\sdologinentry64.dll", strExePath);
#else
	StringCchPrintfW(strGameWidgetDll, MAX_PATH, L"%s\\sdo\\sdologinentry.dll", strExePath);
#endif
	if (GetFileAttributesW(strGameWidgetDll) == 0xFFFFFFFF) {
		return false;
	}
//	string strEntry;
//#ifdef _WIN64
//	strEntry = PathHelper::GetFullPath("..\\sdologinentry64.dll");
//#else
//	strEntry = PathHelper::GetFullPath("..\\sdologinentry.dll");
//#endif
    m_hSDOLoginModule = ::LoadLibraryW(strGameWidgetDll);
	if (m_hSDOLoginModule == nullptr)
	{
		return false;
	}
	
	//Out-of-game login interface
	m_pfSDOLInitialize = (LPSDOLInitialize)GetProcAddress(m_hSDOLoginModule, "SDOLInitialize");
	m_pfSDOLGetModule = (LPSDOLGetModule)GetProcAddress(m_hSDOLoginModule, "SDOLGetModule");
	m_pfSDOLTerminal = (LPSDOLTerminal)GetProcAddress(m_hSDOLoginModule, "SDOLTerminal");

	if (m_pfSDOLInitialize == nullptr || m_pfSDOLGetModule == nullptr) return false;
SDOLAppInfo tmpAppInfo = {
		sizeof(SDOLAppInfo),       // 结构体大小，方便扩展
		appId,                 // 接入应用ID，从开发者网站中申请
		L"游戏名称",     // 应用名称
		L"0.1.2.0",            // 应用客户端当前版本号
		1,                    // 游戏区ID，不可用时传入-1
		1                     // 游戏组ID，不可用时传入-1
	};

	if (m_pfSDOLInitialize(&tmpAppInfo) == SDOL_ERRORCODE_OK)
	{
		m_pfSDOLGetModule(__uuidof(ISDOLLogin8), (void**)&m_pSDOLogin);
		if (m_pSDOLogin == nullptr) return false;
	}
	else
	{
		return false;
	}

	m_pSDOLogin->SetLoginMode(LauncherLoginMode);
	return CreateWorkerThread();
}

  WCHAR strExePath[MAX_PATH] = { 0 };

WCHAR strExeName[MAX_PATH] = { 0 };
WCHAR* strLastSlash = NULL;
GetModuleFileNameW(NULL, strExePath, MAX_PATH);
strExePath[MAX_PATH - 1] = 0;
strLastSlash = wcsrchr(strExePath, TEXT(‘\’));
if (strLastSlash)
{ // 得到EXE所在路径
StringCchCopyW(strExeName, MAX_PATH, &strLastSlash[1]);
*strLastSlash = 0;
strLastSlash = wcsrchr(strExeName, TEXT(‘.’));
if (strLastSlash)
*strLastSlash = 0;
}

	WCHAR strGameWidgetDll[MAX_PATH] = { 0 };
	#ifdef _WIN64
		StringCchPrintfW(strGameWidgetDll, MAX_PATH, L"%s\\sdo\\sdologinentry64.dll", strExePath);
	#else
		StringCchPrintfW(strGameWidgetDll, MAX_PATH, L"%s\\sdo\\sdologinentry.dll", strExePath);
	#endif
		if (GetFileAttributesW(strGameWidgetDll) == 0xFFFFFFFF) {
			return false;
		}
	//	string strEntry;
	//#ifdef _WIN64
	//	strEntry = PathHelper::GetFullPath("..\\sdologinentry64.dll");
	//#else
	//	strEntry = PathHelper::GetFullPath("..\\sdologinentry.dll");
	//#endif
    m_hSDOLoginModule = ::LoadLibraryW(strGameWidgetDll);
	if (m_hSDOLoginModule == nullptr)
	{
		return false;
	}

代码解释：

  • 获取当前执行程序的路径和名称：
    • 使用 GetModuleFileNameW 函数获取当前执行程序**(.exe)**的路径，并将其存储在 strExePath 中。
    • 从 strExePath 中提取出执行程序的名称并存储在 strExeName 中。
  • 提取执行程序所在目录：
    • 在 strExePath 中找到最后一个反斜杠 “” 的位置，然后将它替换为 NULL 终止字符以分隔目录路径和文件名。
    • 如果存在文件扩展名，也将其删除，以便获得纯粹的目录路径。
  • 根据当前架构构造 strGameWidgetDll 的路径：
    • 根据操作系统架构（32位或64位），构建 strGameWidgetDll 路径，这是一个包含了 “sdologinentry.dll” 或 “sdologinentry64.dll” 的完整路径。
  • 检查文件是否存在：
    • 使用 GetFileAttributesW 函数检查 strGameWidgetDll 文件是否存在，如果文件不存在，就返回 false。
  • 加载动态链接库（DLL）：
    • 使用 LoadLibraryW 函数加载 strGameWidgetDll 指定的 DLL 文件。如果加载失败，返回 false。

这段代码的目的是获取并加载一个特定的 DLL，该 DLL 位于与当前执行程序相同的目录下，根据操作系统架构选择加载 “sdologinentry.dll” 或 “sdologinentry64.dll”。如果加载成功，m_hSDOLoginModule 将包含该 DLL 的句柄，以便后续可以使用 GetProcAddress 来获取其中的函数地址。如果有任何错误发生，函数将返回 false。

m_pfSDOLInitialize = (LPSDOLInitialize)GetProcAddress(m_hSDOLoginModule, “SDOLInitialize”);

代码解释：

  • m_pfSDOLInitialize 是一个函数指针，它似乎被用来指向一个函数，该函数的名称是 “SDOLInitialize”，并且这个函数是从模块 m_hSDOLoginModule 中获取的。这种情况通常用于动态链接库（Dynamic Link Library，DLL）或共享库中的函数调用。
  • 一般来说，这段代码的目的是将 m_pfSDOLInitialize 这个函数指针指向 m_hSDOLoginModule 模块中的 “SDOLInitialize” 函数，而m_hSDOLoginModule 模块是一个动态链接库中函数调用，以便后续可以通过该函数指针来调用 “SDOLInitialize” 函数，而不必直接链接到该函数的库。这种方式通常用于在运行时加载库并调用其中的函数，而不是在编译时链接到库。
  • 在使用 m_pfSDOLInitialize 这个函数指针之前，你需要确保 m_hSDOLoginModule 已经成功加载，并且 “SDOLInitialize” 函数已经在该模块中找到。否则，使用该函数指针可能导致运行时错误。

m_pfSDOLGetModule = (LPSDOLGetModule)GetProcAddress(m_hSDOLoginModule, “SDOLGetModule”);

代码解释：

  • 定义了一个函数指针 m_pfSDOLGetModule，并使用 GetProcAddress 函数从 m_hSDOLoginModule 模块中获取 “SDOLGetModule” 函数的地址，并将其分配给 m_pfSDOLGetModule。这意味着 m_pfSDOLGetModule 现在指向了 m_hSDOLoginModule 中的 “SDOLGetModule” 函数。
  • 这种操作通常用于动态加载函数，使你能够在运行时调用这些函数，而无需在编译时将其链接到代码中。 在使用 m_pfSDOLGetModule 指向的函数之前，你需要确保 m_hSDOLoginModule 已成功加载，并且 “SDOLGetModule” 函数确实存在于该模块中，否则会导致运行时错误。

m_pfSDOLTerminal = (LPSDOLTerminal)GetProcAddress(m_hSDOLoginModule, “SDOLTerminal”);

代码解释:

  • 定义了一个函数指针 m_pfSDOLTerminal，并使用 GetProcAddress 函数从 m_hSDOLoginModule 模块中获取 “SDOLTerminal” 函数的地址，并将其分配给 m_pfSDOLTerminal。这样，m_pfSDOLTerminal 现在指向了 m_hSDOLoginModule 中的 “SDOLTerminal” 函数。
  • 这种操作允许你在运行时动态加载并调用 “SDOLTerminal” 函数，而无需在编译时将其链接到代码中。 在使用 m_pfSDOLTerminal 指向的函数之前，确保 m_hSDOLoginModule 已成功加载，且 “SDOLTerminal” 函数确实存在于该模块中，以避免运行时错误。这样的方式通常用于插件系统或需要在运行时加载不同模块的应用程序。

if (m_pfSDOLInitialize == nullptr || m_pfSDOLGetModule == nullptr) return false;

代码解释:

  • 代码检查了 m_pfSDOLInitialize 和 m_pfSDOLGetModule 这两个函数指针是否为空指针（nullptr）。如果其中任何一个为空，它返回 false，否则继续执行后续的操作。
  • 这种检查通常用于确保成功加载并获取到所需的函数地址。如果在前面的 GetProcAddress 调用中，未能获取到 “SDOLInitialize” 或 “SDOLGetModule” 函数的地址，这些函数指针将会是空指针。因此，通过检查它们是否为空，你可以在继续使用这些函数指针之前确保它们已成功获取，以避免在尝试调用这些函数时引发未定义行为或错误。
  • 这是一种常见的做法，用于提高代码的鲁棒性，特别是在涉及动态加载函数的情况下。如果函数指针不为空，那么它们将指向有效的函数，否则你可以选择采取适当的错误处理措施。

3、sdologinentry.dll或者sdologinentry64.dll动态链接库哪个工程生成的并导出三个接口函数

很明显由updatecore工程生成的sdologinentry.dll和sdologinentry64.dll的动态链接库。
在这里插入图片描述

int WINAPI SDOLInitialize(const SDOLAppInfo* pAppInfo)
{
	TCHAR path[32768*2] = {0};
	DWORD len = GetEnvironmentVariable(_T("PATH"), path, _countof(path));

	TCHAR buffer[MAX_PATH] = {0};
	GetModuleFileName(g_hModule, buffer, _countof(buffer));

	_stprintf(path+len, _T(";%s\\..\\sdologin\\"), buffer);

	SetEnvironmentVariable(_T("PATH"), path);

	SDOLAppInfo* pInfo = (SDOLAppInfo*)pAppInfo;

	// Skip update process or not
	wchar_t buffer2[MAX_PATH] = {0};
	wchar_t path2[MAX_PATH*2] = {0};
	GetModuleFileNameW(g_hModule, buffer2, _countof(buffer2));
	swprintf_s(path2, _countof(path2), L"%s\\..\\sdologin\\", buffer2);

	LicenseManager::Initial(path2);
	bool bExpired = LicenseManager::GetInstance()->GetValue<bool>("Expiration");
	bool bSkipUpdate = LicenseManager::GetInstance()->GetValue<bool>("SkipUpdate");

	if (!(bExpired == false && bSkipUpdate == true)) // !(未过期 && 跳过更新)
	{
		if (Update::GetInstance()->CheckLocalVersion())
		{
			if(!Update::GetInstance()->DownloadUpdate(pInfo->AppID, pInfo->AreaId, pInfo->GroupId))
			{
				return SDOA_FALSE;
			}
		}
		else
		{
			if (!Update::GetInstance()->ForceUpdate(pInfo->AppID, pInfo->AreaId, pInfo->GroupId))
			{
				return SDOA_FALSE;
			}
		}
	}

/*
#ifdef _WIN64
	g_hSdoLogin = LoadLibrary(_T("sdologinsdk64.dll"));
#else
	g_hSdoLogin = LoadLibrary(_T("sdologinsdk.dll"));
#endif
*/

	GetModuleFileName(g_hModule, buffer, _countof(buffer));

#ifdef _WIN64
	sprintf(buffer + strlen(buffer) - strlen("sdologinentry64.dll"), "sdologin\\sdologinsdk64.dll");
#else
	sprintf(buffer + strlen(buffer) - strlen("sdologinentry.dll"), "sdologin\\sdologinsdk.dll");
#endif

	g_hSdoLogin = LoadLibraryEx(buffer, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);

	LPSDOLInitialize pFun = (LPSDOLInitialize)GetProcAddress(g_hSdoLogin, "SDOLInitialize");
	if(pFun)
	{
		return pFun(pAppInfo);
	}
	return SDOA_FALSE;
}

int WINAPI SDOLGetModule(REFIID riid, void** intf)
{
	LPSDOLGetModule pFun = (LPSDOLGetModule)GetProcAddress(g_hSdoLogin, "SDOLGetModule");
	if(pFun)
	{
		return pFun(riid, intf);
	}
	return false;
}

int WINAPI SDOLTerminal()
{
	LPSDOLTerminal pFun = (LPSDOLTerminal)GetProcAddress(g_hSdoLogin, "SDOLTerminal");
	int ret = SDOA_FALSE;
	if(pFun)
	{
		ret = pFun();
	}

	FreeLibrary(g_hSdoLogin);

	if(ret == SDOL_ERRORCODE_OK)
	{
		Update::GetInstance()->SetupUpdate();
	}
	Update::Destroy();

	return ret;
}

int WINAPI SDOLInitialize(const SDOLAppInfo* pAppInfo)

{

​ TCHAR path[32768*2] = {0};
​ DWORD len = GetEnvironmentVariable(_T(“PATH”), path, _countof(path));

​ TCHAR buffer[MAX_PATH] = {0};
​ GetModuleFileName(g_hModule, buffer, _countof(buffer));

​ _stprintf(path+len, _T(“;%s\…\sdologin\”), buffer);

​ SetEnvironmentVariable(_T(“PATH”), path);

​ SDOLAppInfo* pInfo = (SDOLAppInfo*)pAppInfo;

​ SetEnvironmentVariable(_T(“PATH”), path);

​ SDOLAppInfo* pInfo = (SDOLAppInfo*)pAppInfo;

​ // Skip update process or not
​ wchar_t buffer2[MAX_PATH] = {0};
​ wchar_t path2[MAX_PATH*2] = {0};
​ GetModuleFileNameW(g_hModule, buffer2, _countof(buffer2));
​ swprintf_s(path2, _countof(path2), L"%s\…\sdologin\", buffer2);

​ LicenseManager::Initial(path2);
​ bool bExpired = LicenseManager::GetInstance()->GetValue(“Expiration”);
​ bool bSkipUpdate = LicenseManager::GetInstance()->GetValue(“SkipUpdate”);

​ if (!(bExpired == false && bSkipUpdate == true)) // !(未过期 && 跳过更新)
​ {
​ if (Update::GetInstance()->CheckLocalVersion())
​ {
​ if(!Update::GetInstance()->DownloadUpdate(pInfo->AppID, pInfo->AreaId, pInfo->GroupId))
​ {
​ return SDOA_FALSE;
​ }
​ }
​ else
​ {
​ if (!Update::GetInstance()->ForceUpdate(pInfo->AppID, pInfo->AreaId, pInfo->GroupId))
​ {
​ return SDOA_FALSE;
​ }
​ }
​ }

/*
#ifdef _WIN64
g_hSdoLogin = LoadLibrary(_T(“sdologinsdk64.dll”));
#else
g_hSdoLogin = LoadLibrary(_T(“sdologinsdk.dll”));
#endif
*/

​ GetModuleFileName(g_hModule, buffer, _countof(buffer));

#ifdef _WIN64
sprintf(buffer + strlen(buffer) - strlen(“sdologinentry64.dll”), “sdologin\sdologinsdk64.dll”);
#else
sprintf(buffer + strlen(buffer) - strlen(“sdologinentry.dll”), “sdologin\sdologinsdk.dll”);
#endif

​ g_hSdoLogin = LoadLibraryEx(buffer, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);

​ LPSDOLInitialize pFun = (LPSDOLInitialize)GetProcAddress(g_hSdoLogin, “SDOLInitialize”);
​ if(pFun)
​ {
​ return pFun(pAppInfo);
​ }
​ return SDOA_FALSE;

}

代码解释:

  • 这段代码是一个函数 SDOLInitialize 的实现，以下是它的主要功能：
    1. 获取当前环境变量中的 PATH，并向其中添加一个目录路径。这个目录路径是 sdologin 目录，它相对于当前执行程序的目录。
    2. 初始化 LicenseManager，它的目的是获取和检查许可证信息。
    3. 检查许可证信息中的 “Expiration” 和 “SkipUpdate” 值，根据这些值决定是否跳过更新过程。
    4. 如果不跳过更新，检查本地版本并尝试下载或强制更新。
    5. 最后，通过构建动态链接库文件路径，加载 sdologinsdk.dll 或 sdologinsdk64.dll（取决于系统架构），同理并调用动态链接库中的 SDOLInitialize 函数。
  • 总体来说，这段代码的功能是在初始化时检查许可证信息，决定是否需要进行更新，并加载相应的动态链接库以继续应用程序的初始化过程。根据许可证信息，它可能跳过更新或执行更新操作。这种方式通常用于软件的自动更新或版本管理。

int WINAPI SDOLGetModule(REFIID riid, void** intf)
{
LPSDOLGetModule pFun = (LPSDOLGetModule)GetProcAddress(g_hSdoLogin, “SDOLGetModule”);
if(pFun)
{
return pFun(riid, intf);
}
return false;
}

代码解释:

  • 这段代码是一个函数 SDOLGetModule 的实现，以下是它的主要功能：
    1. 首先，它通过 GetProcAddress 函数尝试从同理并调用动态链接库中的加载的 g_hSdoLogin 动态链接库中获取名为 “SDOLGetModule” 的函数的地址，这个函数似乎是一个用于获取模块的接口（COM 接口）的函数。
    2. 如果成功获取到该函数的地址，它调用该函数，并将 riid 和 intf 参数传递给它。
    3. 如果获取和调用都成功，函数返回从 pFun 调用的结果。
    4. 如果无法获取到该函数的地址，或者获取和调用失败，函数返回 false。
  • 这段代码似乎是为了实现动态加载的模块系统，其中 SDOLGetModule 函数用于获取指定接口的模块。如果成功获取到并调用了模块中的 SDOLGetModule 函数，它将返回相应的结果，否则返回 false 表示失败。通常，这种方式用于插件系统或模块化的应用程序，可以在运行时加载不同的模块并获取它们的接口。

int WINAPI SDOLTerminal()
{
LPSDOLTerminal pFun = (LPSDOLTerminal)GetProcAddress(g_hSdoLogin, “SDOLTerminal”);
int ret = SDOA_FALSE;
if(pFun)
{
ret = pFun();
}

​ FreeLibrary(g_hSdoLogin);

​ if(ret == SDOL_ERRORCODE_OK)
​ {
​ Update::GetInstance()->SetupUpdate();
​ }
​ Update::Destroy();

​ return ret;

}

代码解释:

  • 这段代码是一个函数 SDOLTerminal 的实现，以下是它的主要功能：

    1. 首先，它通过 GetProcAddress 函数尝试从同理并调用动态链接库中的加载的 g_hSdoLogin 动态链接库中获取名为 “SDOLTerminal” 的函数的地址，似乎是一个用于终止模块操作的函数。
    2. 如果成功获取到该函数的地址，它调用该函数，并将返回的结果存储在 ret 变量中。
    3. 接着，它使用 FreeLibrary 函数释放 g_hSdoLogin 动态链接库，即卸载模块。
    4. 如果 ret 的值等于 SDOL_ERRORCODE_OK，则表示成功执行模块操作，它会调用 Update::GetInstance()->SetupUpdate() 来设置更新，否则跳过这一步。
    5. 最后，它调用 Update::Destroy() 来释放更新相关的资源，并返回 ret 的值。

  • 这段代码的主要作用是在模块操作结束时，执行一些清理工作，包括释放动态链接库，进行更新设置，以及资源的销毁。这通常用于模块的初始化和终止过程。

解释如何调用到sdologinentry.dll或者sdologinentry64.dll库中的三个函数:

SDOLInitialize

SDOLGetModule

SDOLTerminal

LIBRARY	"updatecore"

EXPORTS
	igwInitialize
	igwGetModule
	igwTerminal
	SDOLInitialize
	SDOLGetModule
	SDOLTerminal

资源解释:

  • 这是一个动态链接库（DLL）的导出符号定义部分。在这个定义中：
    • LIBRARY "updatecore" 表示该动态链接库的名称为 “updatecore”。
    • EXPORTS 下面列出了一系列函数名称，它们将会在该 DLL 中被导出，以便其他模块或程序可以调用这些函数。这些函数包括了 igwInitialize、igwGetModule、igwTerminal、SDOLInitialize、SDOLGetModule 以及 SDOLTerminal。
  • 这些导出函数通常是其他程序或模块需要使用的接口。通过将它们导出，其他程序可以通过动态链接的方式加载这个 DLL，并使用这些函数来执行特定的操作。在你之前提供的代码中，通过 GetProcAddress 函数来获取并调用这些函数，这使得你可以在运行时动态加载和使用这些功能。

4、sdologinsdk.dll或者sdologinsdk64.dll动态链接库哪个工程生成并导出三个接口函数

SDOLInitialize

SDOLGetModule

SDOLTerminal

很明显由sdk工程生成的sdologinsdk.dll和sdologinsdk64.dll的动态链接库。

在这里插入图片描述

static SDOLLogin* g_pSDOLLogin = NULL;
static SDOLInfo*  g_pSDOLInfo = NULL;
bool _SDOLGetModule(REFIID riid, void** intf);
bool _igwGetModule(REFIID riid, void** intf);

int WINAPI SDOLInitializeInternal(const SDOLAppInfo* pAppInfo)
{
	TRACET();
	TRACEI(_T("pAppInfo[0x%x]\n"), pAppInfo);

	if(pAppInfo == NULL || pAppInfo->Size != sizeof(SDOLAppInfo))
	{
		TRACEW("SDOLII pAppInfo error.");
		return SDOL_ERRORCODE_INVALIDPARAM;
	}

	if(!ModuleLoginSDK::Initial(pAppInfo))
	{
		TRACEW("ModuleLoginSDK::Initial() failed.");
		return SDOL_ERRORCODE_FAILED;
	}

	TRACEI(_T("AppID[%d] AppName[%s] AppVer[%s] AreaId[%d] GroupId[%d]\n"), 
		pAppInfo->AppID, pAppInfo->AppName, pAppInfo->AppVer, pAppInfo->AreaId, pAppInfo->GroupId);

	//ModuleLoginSDK::GetInstance()->SetAppInfo(pAppInfo);

	g_pSDOLLogin = new SDOLLogin();
	g_pSDOLInfo = new SDOLInfo();

	return SDOL_ERRORCODE_OK;
};


bool _InitObjects( const SDOLAppInfo& appInfo ) ;
int WINAPI SDOLInitialize(const SDOLAppInfo* pAppInfo)
{
	TRACET();
	TRACEI(_T("pAppInfo[0x%x]\n"), pAppInfo);
	if (NULL != pAppInfo)
	{
		TRACEI(_T("pAppInfo->Size[%d]\n"), pAppInfo->Size);
		TRACEI(_T("pAppInfo->AppID[%d]\n"), pAppInfo->AppID);
		TRACEI(_T("pAppInfo->AppName[%s]\n"), pAppInfo->AppName);
		TRACEI(_T("pAppInfo->AppVer[%s]\n"), pAppInfo->AppVer);
		TRACEI(_T("pAppInfo->AreaId[%d]\n"), pAppInfo->AreaId);
	}

	// zlc bool res = _InitObjects(*pAppInfo);
	SDOLAppInfo struAppInfo;
	memcpy(&struAppInfo, pAppInfo, sizeof(SDOLAppInfo));
	if (struAppInfo.AppID == 0)
		struAppInfo.AppID = 791000388; //zlc here
	bool res = _InitObjects(struAppInfo);
	if (!res)
	{
		return SDOL_ERRORCODE_FAILED;
	}

	ModuleLoginSDK::GetInstance()->SetWindowMode(SetWindowModeReq::OutsideGame);

	return SDOL_ERRORCODE_OK;
};



int WINAPI SDOLGetModule(REFIID riid, void** intf)
{
	TRACET();

	OLECHAR* guid = NULL; 
	StringFromIID(riid, &guid);
	TRACEI(_T("0 SDOLGetModule riid[%s]"), guid);

	bool res = false;
	res = _SDOLGetModule(riid, intf);
	if (!res)
	{
		res = _igwGetModule(riid, intf);
	}

	if (res)
	{
		OLECHAR* guid = NULL; 
		StringFromIID(riid, &guid);
		TRACEI(_T("1 SDOLGetModule riid[%s]"), guid);
	}	

	return res ? SDOL_ERRORCODE_OK:SDOL_ERRORCODE_FAILED;
};

int WINAPI SDOLTerminal()
{
	TRACET();
	TRACEI(_T(""));

	int ret = ModuleLoginSDK::Destroy();

	SAFE_DELETE(g_pSDOLLogin);

	return ret == ShutdownSuccess ? SDOL_ERRORCODE_OK : SDOL_ERRORCODE_FAILED;
};

bool _SDOLGetModule(REFIID riid, void** intf)
{
	TRACET();
	TRACEI(_T(""));

	if(riid == __uuidof(ISDOLLogin))
	{
		*intf = (void*)(ISDOLLogin*)g_pSDOLLogin;
		return true;
	}
	if(riid == __uuidof(ISDOLLogin2))
	{
		*intf = (void*)(ISDOLLogin2*)g_pSDOLLogin;
		return true;
	}
	if (riid == __uuidof(ISDOLInfo))
	{
		*intf = (void*)(ISDOLInfo*)g_pSDOLInfo;
		return true;
	}
	if(riid == __uuidof(ISDOLLogin3))
	{
		*intf = (void*)(ISDOLLogin3*)g_pSDOLLogin;
		return true;
	}
	if(riid == __uuidof(ISDOLLogin4))
	{
		*intf = (void*)(ISDOLLogin4*)g_pSDOLLogin;
		return true;
	}
	if(riid == __uuidof(ISDOLLogin5))
	{
		*intf = (void*)(ISDOLLogin5*)g_pSDOLLogin;
		return true;
	}
	if(riid == __uuidof(ISDOLLogin6))
	{
		*intf = (void*)(ISDOLLogin6*)g_pSDOLLogin;
		return true;
	}
	if(riid == __uuidof(ISDOLLogin7))
	{
		*intf = (void*)(ISDOLLogin7*)g_pSDOLLogin;
		return true;
	}
	if(riid == __uuidof(ISDOLLogin8))
	{
		*intf = (void*)(ISDOLLogin8*)g_pSDOLLogin;
		return true;
	}

	return false;
};

static SDOLLogin* g_pSDOLLogin = NULL;
static SDOLInfo* g_pSDOLInfo = NULL;
bool _SDOLGetModule(REFIID riid, void** intf);
bool _igwGetModule(REFIID riid, void** intf);

int WINAPI SDOLInitializeInternal(const SDOLAppInfo* pAppInfo)
{
TRACET();
TRACEI(_T(“pAppInfo[0x%x]\n”), pAppInfo);

​ if(pAppInfo == NULL || pAppInfo->Size != sizeof(SDOLAppInfo))
​ {
​ TRACEW(“SDOLII pAppInfo error.”);
​ return SDOL_ERRORCODE_INVALIDPARAM;
​ }

​ if(!ModuleLoginSDK::Initial(pAppInfo))
​ {
​ TRACEW(“ModuleLoginSDK::Initial() failed.”);
​ return SDOL_ERRORCODE_FAILED;
​ }

​ TRACEI(_T(“AppID[%d] AppName[%s] AppVer[%s] AreaId[%d] GroupId[%d]\n”),
​ pAppInfo->AppID, pAppInfo->AppName, pAppInfo->AppVer, pAppInfo->AreaId, pAppInfo->GroupId);

​ //ModuleLoginSDK::GetInstance()->SetAppInfo(pAppInfo);

​ g_pSDOLLogin = new SDOLLogin();
​ g_pSDOLInfo = new SDOLInfo();

​ return SDOL_ERRORCODE_OK;

};

代码解释:

  • 这段代码定义了一个名为 SDOLInitializeInternal 的函数，以下是它的主要功能：

    1. 在函数开始时，通过 TRACEI 函数和 TRACEW 函数输出一些信息，用于调试和日志记录。
    2. 首先，它检查传入的 pAppInfo 参数是否为 NULL 或其大小是否与 sizeof(SDOLAppInfo) 相符。如果不符合条件，函数会返回 SDOL_ERRORCODE_INVALIDPARAM 表示参数无效。
    3. 接着，如果上述检查通过，它调用 ModuleLoginSDK::Initial(pAppInfo) 函数，尝试进行一些初始化操作。如果初始化失败，函数返回 SDOL_ERRORCODE_FAILED 表示初始化失败。
    4. 如果初始化成功，它继续输出 pAppInfo 中的一些信息，包括了 AppID、AppName、AppVer、AreaId 和 GroupId。
    5. 然后，它创建了两个对象：g_pSDOLLogin 和 g_pSDOLInfo，分别是 SDOLLogin 和 SDOLInfo 的实例。
    6. 最后，函数返回 SDOL_ERRORCODE_OK 表示初始化成功。

  • 这段代码的主要目的是在应用程序的初始化过程中，根据传入的应用信息进行一些初始化工作，包括了调用 ModuleLoginSDK::Initial 函数，创建 SDOLLogin 和 SDOLInfo 的对象。如果初始化成功，函数返回成功状态码，否则返回失败状态码。

bool InitObjects( const SDOLAppInfo& appInfo ) ;
bool _InitObjects( const SDOLAppInfo& appInfo )
{
TRACET();
​ if(SDOLInitializeInternal(&appInfo) != SDOL_ERRORCODE_OK)
​ {
​ return false;
​ }
​ // if(g_pSDOAApp2 == NULL)
​ // {
​ // g_pSDOAApp2 = new SDOAApp2();
​ // }
​ if(g_pSDOAApp4 == NULL)
​ {
​ g_pSDOAApp4 = new SDOAApp4();
​ }
​ if(g_pSDOAAppEx == NULL)
​ {
​ g_pSDOAAppEx = new IGW2::SDOAAppEx();
​ }
​ if(g_pSDOAAppUtils == NULL)
​ {
​ g_pSDOAAppUtils = new SDOAAppUtils();
​ }
​ if(g_pSDOAClientService == NULL)
​ {
​ g_pSDOAClientService = new SDOAClientService();
​ }
return true;
}

代码解释:

  • 这段代码定义了一个名为 _InitObjects 的函数，以下是它的主要功能：
    1. 在函数开始时，通过 TRACE 函数输出一些信息，用于调试和日志记录。
    2. 接着，它调用 SDOLInitializeInternal(&appInfo) 函数，尝试进行一些初始化操作。如果 SDOLInitializeInternal 返回的值不等于 SDOL_ERRORCODE_OK，表示初始化失败，函数返回 false 表示初始化对象失败。
    3. 然后，它检查一系列全局指针（g_pSDOAApp4、g_pSDOAAppEx、g_pSDOAAppUtils 和 g_pSDOAClientService），如果其中有任何一个指针为空，它将分别创建对应的对象实例，这些对象可能是特定的应用程序对象。
    4. 最后，如果上述初始化和对象创建都成功，函数返回 true 表示初始化对象成功。
  • 这段代码的主要目的是在应用程序初始化过程中，进行一些对象的初始化和创建工作，包括了调用 SDOLInitializeInternal 函数,通过这个函数调用到SDK中的初始化函数，以及创建特定的应用程序对象。如果初始化对象成功，函数返回 true，否则返回 false。这些对象通常用于应用程序的功能实现和操作。

bool _InitObjects( const SDOLAppInfo& appInfo ) ;
int WINAPI SDOLInitialize(const SDOLAppInfo* pAppInfo)
{
TRACET();
TRACEI(_T(“pAppInfo[0x%x]\n”), pAppInfo);
if (NULL != pAppInfo)
{
TRACEI(_T(“pAppInfo->Size[%d]\n”), pAppInfo->Size);
TRACEI(_T(“pAppInfo->AppID[%d]\n”), pAppInfo->AppID);
TRACEI(_T(“pAppInfo->AppName[%s]\n”), pAppInfo->AppName);
TRACEI(_T(“pAppInfo->AppVer[%s]\n”), pAppInfo->AppVer);
TRACEI(_T(“pAppInfo->AreaId[%d]\n”), pAppInfo->AreaId);
}

​ // zlc bool res = _InitObjects(*pAppInfo);
​ SDOLAppInfo struAppInfo;
​ memcpy(&struAppInfo, pAppInfo, sizeof(SDOLAppInfo));
​ if (struAppInfo.AppID == 0)
​ struAppInfo.AppID = 791000388; //zlc here
​ bool res = _InitObjects(struAppInfo);
​ if (!res)
​ {
​ return SDOL_ERRORCODE_FAILED;
​ }

​ ModuleLoginSDK::GetInstance()->SetWindowMode(SetWindowModeReq::OutsideGame);

​ return SDOL_ERRORCODE_OK;

};

代码解释:

  • 这段代码是一个名为 SDOLInitialize 的函数的实现，以下是它的主要功能：

    1. 在函数开始时，通过一系列 TRACEI 函数调用来输出一些信息，这些信息包括了 pAppInfo 参数的各个成员的值，以便进行调试和日志记录。
    2. 接着，它创建一个名为 struAppInfo 的局部变量，并通过 memcpy 函数将 pAppInfo 的内容复制到 struAppInfo 中。然后，它检查 struAppInfo 中的 AppID 是否为 0，如果是，将其设置为 791000388。
    3. 接下来，它调用 _InitObjects 函数，将 struAppInfo 作为参数传递给它。_InitObjects 函数可能用于初始化一些对象或资源，这部分的具体逻辑在 _InitObjects 函数中实现。
    4. 如果 _InitObjects 返回 true 表示初始化成功，它将调用 ModuleLoginSDK::GetInstance()->SetWindowMode(SetWindowModeReq::OutsideGame) 来设置某种窗口模式。窗口模式的设置可能与应用程序的显示方式有关。
    5. 最后，如果初始化成功，函数返回 SDOL_ERRORCODE_OK，否则返回 SDOL_ERRORCODE_FAILED 表示初始化失败。

  • 总的来说，这段代码的目的是在应用程序初始化过程中，根据传入的应用信息进行一些初始化工作，包括了调用 _InitObjects 函数和设置窗口模式。如果初始化成功，返回成功状态码，否则返回失败状态码。

int WINAPI SDOLGetModule(REFIID riid, void** intf)
{
TRACET();

​ OLECHAR* guid = NULL;
​ StringFromIID(riid, &guid);
​ TRACEI(_T(“0 SDOLGetModule riid[%s]”), guid);

​ bool res = false;
​ res = _SDOLGetModule(riid, intf);
​ if (!res)
​ {
​ res = _igwGetModule(riid, intf);
​ }

​ if (res)
​ {
​ OLECHAR* guid = NULL;
​ StringFromIID(riid, &guid);
​ TRACEI(_T(“1 SDOLGetModule riid[%s]”), guid);
​ }

​ return res ? SDOL_ERRORCODE_OK:SDOL_ERRORCODE_FAILED;

};

代码解释:

  • 这段代码是一个名为 SDOLGetModule 的函数的实现，以下是它的主要功能：
    1. 在函数开始时，通过 TRACEI 函数和 StringFromIID 函数输出一些信息，包括 riid 参数的 GUID。
    2. 接着，它创建一个名为 guid 的指针，并通过 StringFromIID 函数将 riid 转换为字符串形式，并将结果存储在 guid 中。
    3. 然后，它调用 _SDOLGetModule 函数，传递 riid 和 intf 作为参数，以尝试获取模块。
    4. 如果 _SDOLGetModule 返回 false（表示获取模块失败），它接着调用 _igwGetModule 函数，再次尝试获取模块。
    5. 如果成功获取到模块，它再次输出 riid 的信息，然后返回 SDOL_ERRORCODE_OK 表示成功。
    6. 如果两次尝试都没有成功获取模块，它最终返回 SDOL_ERRORCODE_FAILED 表示失败。
  • 总的来说，这段代码的目的是尝试获取一个模块，首先通过 _SDOLGetModule 尝试，如果失败再通过 _igwGetModule 尝试。如果成功获取到模块，它返回成功状态码，否则返回失败状态码。

int WINAPI SDOLTerminal()
{
TRACET();
TRACEI(_T(“”));

​ int ret = ModuleLoginSDK::Destroy();

​ SAFE_DELETE(g_pSDOLLogin);

​ return ret == ShutdownSuccess ? SDOL_ERRORCODE_OK : SDOL_ERRORCODE_FAILED;

}

代码解释:

  • 这段代码是一个名为 SDOLTerminal 的函数的实现，以下是它的主要功能：
    1. 在函数开始时，通过 TRACEI 函数输出一些信息，用于调试和日志记录。
    2. 接着，它调用 ModuleLoginSDK::Destroy() 函数，该函数可能用于销毁一些模块相关的资源和对象。
    3. 将 ModuleLoginSDK::Destroy() 返回的结果存储在 ret 变量中，这个结果可能是一个表示销毁操作是否成功的值。
    4. 然后，它通过 SAFE_DELETE(g_pSDOLLogin) 来释放 g_pSDOLLogin 所指向的对象或资源。这个宏可能用于安全地删除指针，并将指针置为 nullptr。
    5. 最后，如果 ret 的值等于 ShutdownSuccess，它返回 SDOL_ERRORCODE_OK 表示终止成功，否则返回 SDOL_ERRORCODE_FAILED 表示终止失败。
  • 这段代码的主要目的是在应用程序终止时执行一些清理操作，包括销毁模块相关的资源和对象，然后返回适当的状态码以表示终止的结果。

bool _SDOLGetModule(REFIID riid, void** intf)
{
TRACET();
TRACEI(_T(“”));

​ if(riid == __uuidof(ISDOLLogin))
​ {
​ intf = (void)(ISDOLLogin*)g_pSDOLLogin;
​ return true;
​ }
​ if(riid == __uuidof(ISDOLLogin2))
​ {
​ intf = (void)(ISDOLLogin2*)g_pSDOLLogin;
​ return true;
​ }
​ if (riid == __uuidof(ISDOLInfo))
​ {
​ intf = (void)(ISDOLInfo*)g_pSDOLInfo;
​ return true;
​ }
​ if(riid == __uuidof(ISDOLLogin3))
​ {
​ intf = (void)(ISDOLLogin3*)g_pSDOLLogin;
​ return true;
​ }
​ if(riid == __uuidof(ISDOLLogin4))
​ {
​ intf = (void)(ISDOLLogin4*)g_pSDOLLogin;
​ return true;
​ }
​ if(riid == __uuidof(ISDOLLogin5))
​ {
​ intf = (void)(ISDOLLogin5*)g_pSDOLLogin;
​ return true;
​ }
​ if(riid == __uuidof(ISDOLLogin6))
​ {
​ intf = (void)(ISDOLLogin6*)g_pSDOLLogin;
​ return true;
​ }
​ if(riid == __uuidof(ISDOLLogin7))
​ {
​ intf = (void)(ISDOLLogin7*)g_pSDOLLogin;
​ return true;
​ }
​ if(riid == __uuidof(ISDOLLogin8))
​ {
​ intf = (void)(ISDOLLogin8*)g_pSDOLLogin;
​ return true;
​ }

​ return false;

};

代码解释:

  • 这段代码是一个名为 _SDOLGetModule 的函数的实现，以下是它的主要功能：
    1. 在函数开始时，通过 TRACEI 函数输出一些信息，用于调试和日志记录。
    2. 然后，它检查传入的 riid 参数是否等于特定的接口类型的 UUID（GUID）。如果 riid 匹配某个特定接口类型的 UUID，它将将 *intf 指向相应的接口指针，并返回 true 表示成功。
    3. 如果 riid 不匹配任何已知的接口类型，它返回 false 表示失败。
  • 这段代码的主要目的是根据传入的 riid 参数，尝试获取对应的接口，并将接口指针存储在 *intf 中，以便其他部分的代码可以使用这些接口进行操作。如果 riid 匹配已知接口类型，则返回 true，否则返回 false。这通常用于实现 COM 接口的获取和对象的实例化。

bool _igwGetModule(REFIID riid, void** intf)
{
if(riid == __uuidof(ISDOAApp))
{
intf = (void)(ISDOAApp*)g_pSDOAApp4;
return true;
}
if(riid == __uuidof(ISDOAApp2))
{
intf = (void)(ISDOAApp2*)g_pSDOAApp4;
return true;
}
if(riid == __uuidof(ISDOAApp3))
{
intf = (void)(ISDOAApp3*)g_pSDOAApp4;
return true;
}
if(riid == __uuidof(ISDOAApp4))
{
intf = (void)(ISDOAApp4*)g_pSDOAApp4;
return true;
}
if(riid == __uuidof(IGW2::ISDOAAppEx))
{
intf = (void)(IGW2::ISDOAAppEx*)g_pSDOAAppEx;
return true;
}
if(riid == __uuidof(ISDOAAppUtils))
{
intf = (void)(ISDOAAppUtils*)g_pSDOAAppUtils;
return true;
}
if(riid == __uuidof(ISDOAClientService))
{
intf = (void)(ISDOAClientService*)g_pSDOAClientService;
return true;
}

​ if(riid == __uuidof(IGPLUSApp))
​ {
​ intf = (void)(IGPLUSApp*)CGPlusManager::GetInstance()->getGplusAppObject();
​ return true;
​ }

​ //if(Dx7GetModule(riid, intf))
​ //{
​ // return true;
​ //}
​ if(Dx8GetModule(riid, intf))
​ {
​ return true;
​ }
​ if(Dx9GetModule(riid, intf))
​ {
​ return true;
​ }
​ if(Dx11GetModule(riid, intf))
​ {
​ return true;
​ }
​ if(GDIGetModule(riid, intf))
​ {
​ return true;
​ }
​ if(DDrawGetModule(riid, intf))
​ {
​ return true;
​ }
​ return false;

}

代码解释:

  • 这段代码是一个名为 _igwGetModule 的函数的实现，以下是它的主要功能：

    1. 它检查传入的 riid 参数是否等于特定的接口类型的 UUID（GUID）。如果 riid 匹配某个特定接口类型的 UUID，它将将 *intf 指向相应的接口指针，并返回 true 表示成功。
    2. 如果 riid 不匹配已知的接口类型，它继续检查其他接口类型，包括 Dx8GetModule、Dx9GetModule、Dx11GetModule、GDIGetModule、DDrawGetModule 等。如果传入的 riid 匹配这些接口类型中的任何一个，它同样将 *intf 指向相应的接口指针，并返回 true 表示成功。
    3. 如果所有的检查都失败，它最终返回 false 表示没有匹配的接口。

  • 这段代码的主要目的是根据传入的 riid 参数，尝试获取对应的接口，并将接口指针存储在 *intf 中，以便其他部分的代码可以使用这些接口进行操作。这是一种通用的接口获取机制，用于获取不同接口类型的对象。如果 riid 匹配已知的接口类型，它返回 true，否则返回 false。这通常用于实现 COM 接口的获取和对象的实例化。

解释如何调用到sdologinsdk.dll或者sdologinsdk64.dll库中的三个函数:

LIBRARY “sdologinsdk”

EXPORTS
SDOLInitialize
SDOLGetModule
SDOLTerminal
igwInitialize
igwGetModule
igwTerminal

代码解释:

  • 这段代码定义了一个名为 “sdologinsdk” 的动态链接库（DLL）的导出符号，它列出了一系列函数名称，这些函数将会在该 DLL 中被导出，以便其他模块或程序可以通过动态链接的方式调用这些函数。导出的函数包括了：
    1. SDOLInitialize
    2. SDOLGetModule
    3. SDOLTerminal
    4. igwInitialize
    5. igwGetModule
    6. igwTerminal
  • 这些导出函数通常是其他程序或模块需要使用的接口。通过将它们导出，其他程序可以在运行时动态加载这个 DLL，并使用这些函数来执行特定的操作。这种方式通常用于插件系统或模块化的应用程序，允许不同的模块或插件在运行时添加到应用程序中，以扩展其功能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1140374.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

redis爆满导致数据丢失

redis爆满导致数据丢失

记一则redis爆满导致数据丢失的一场事故 某功能上线后&#xff0c;发现出现问题&#xff0c;最后定位到了 redis. 由于存储的数据过多&#xff0c;导致阿里云4G大小的 redis 爆满&#xff0c;触发了回收策略。 于是临时扩容,运维同学当时未找到阿里云配置。 后面我用工具连接了…
阅读更多...
微服务-Feign

微服务-Feign

文章目录 Feign介绍Feign的基本使用自定义Feign的配置Feign性能优化Feign最佳实践 Feign介绍 RestTemplate远程调用存在的问题&#xff1a;代码可读性差&#xff0c;java代码中夹杂url&#xff1b;参数复杂很难维护 String url "http://userservice/user/" order.g…
阅读更多...
常见MySQL数据库无法启动的解决方案

常见MySQL数据库无法启动的解决方案

前言&#xff1a; 数据库无法启动是在运维中常见的问题&#xff0c;大多是重启服务器、磁盘损坏、配置不当导致的。建议您在面板计划任务中做个数据库全部备份的计划任务&#xff0c;这样在遇到问题的情况下可以及时通过备份进行恢复。 在根据下面的案例尝试恢复或者启动数据库…
阅读更多...
dedecms 文件上传（CVE-2019-8933）

dedecms 文件上传（CVE-2019-8933）

dedecms 文件上传&#xff08;CVE-2019-8933&#xff09; 漏洞简介 远程攻击者可通过在添加新模板时&#xff0c;将文件名…/index.html更改成…/index.php利用该漏洞向uploads/目录上传.php文件并执行该文件。 后台路径&#xff1a;/uploads/dede/ 后台密码&#xff1a;admi…
阅读更多...
贪心算法学习——最大数

贪心算法学习——最大数

目录 ​编辑 一&#xff0c;题目 二&#xff0c;题目接口 三&#xff0c;解题思路级代码 一&#xff0c;题目 给定一组非负整数 nums&#xff0c;重新排列每个数的顺序&#xff08;每个数不可拆分&#xff09;使之组成一个最大的整数。 注意&#xff1a;输出结果可能非常大…
阅读更多...
WEB使用百度地图展示某地地址

WEB使用百度地图展示某地地址

第一步 进入百度地图开发平台 百度地图开放平台 | 百度地图API SDK | 地图开发 第二步注册 获取AK秘钥&#xff0c;点击【创建应用】进入AK申请页面&#xff0c;填写应用名称&#xff0c;务必选择AK类型为“浏览器端”&#xff0c;JS API只支持浏览器端AK进行请求与访问 下面…
阅读更多...
AVM赛道研究：预计2024年渗透率突破50%！下一个破局点在哪儿？

AVM赛道研究：预计2024年渗透率突破50%！下一个破局点在哪儿？

作为一个典型的基础智能化细分赛道&#xff0c;全景环视&#xff08;AVM&#xff09;的发展历程值得市场借鉴。 这其中的原因包括&#xff0c;①对比渗透率仍处低位的高阶智驾&#xff0c;单一AVM赛道的产品基本进入成熟期&#xff08;渗透率继续高歌猛进&#xff09;&#xf…
阅读更多...
《算法通关村—如何基于数组（或者链表）实现栈》

《算法通关村—如何基于数组（或者链表）实现栈》

《算法通关村—如何基于数组&#xff08;或者链表&#xff09;实现栈》 理解什么是栈 栈和队列是比较特殊的线性表&#xff0c;又称之为访问受限的线性表。栈是很多表达式、符号等运算的基础&#xff0c;也是递归的底层实现。理论上递归能做的题目栈都可以&#xff0c;只是有…
阅读更多...
NLog详解

NLog详解

目录 1.简介 2.项目中使用NLog 2.1 快速使用NLog 2.2 通过配置文件使用NLog 3.NLog配置参数详解 3.1 全局配置 3.2 根元素 3.2.1 targets 3.2.1.1 layout 3.2.2 rules 3.2.3 extensions 3.2.4 include 3.2.5 variable 4.附录 1.简介 NLog是一个基于.NET平台编写…
阅读更多...
【C++代码】分糖，分饼干，摇摆序列，贪心算法--代码随想录

【C++代码】分糖，分饼干，摇摆序列，贪心算法--代码随想录

贪心的本质是选择每一阶段的局部最优&#xff0c;从而达到全局最优。靠自己手动模拟&#xff0c;如果模拟可行&#xff0c;就可以试一试贪心策略&#xff0c;如果不可行&#xff0c;可能需要动态规划。贪心算法一般分为如下四步&#xff1a; 将问题分解为若干个子问题找出适合的…
阅读更多...
Shell 邮件发送告警测试

Shell 邮件发送告警测试

1.先编辑mail配置文件 #cat /etc/mail.rc#开启ssl set ssl-verifyignore#证书目录&#xff0c;下方为centos系统证书默认位置&#xff0c;也自行生成证书并指定 set nss-config-dir/etc/pki/nssdb# 配置的第三方smtp服务器的地址及端口 set smtpsmtps://smtp.163.com:465 # 认…
阅读更多...
＜多线程章节二＞创建线程的几种常见方式

＜多线程章节二＞创建线程的几种常见方式

文章专栏 本篇文章收录于多线程&#xff0c;也欢迎翻阅博主的其他文章&#xff0c;可能也会让你有不一样的收获&#x1f604; &#x1f4a1;JavaSE语法 &#x1f4a1;数据结构 &#x1f4a1;多线程 &#x1f4a1;专栏导读 操作系统提供了一些API来操作线程&#xff0c;Java针对…
阅读更多...
python把ChestX-Det-Dataset的json样本转为COCO数据集的json格式

python把ChestX-Det-Dataset的json样本转为COCO数据集的json格式

ChestX-Det-Dataset数据集网址&#xff1a;https://github.com/Deepwise-AILab/ChestX-Det-Dataset/tree/main 数据集JSON内容&#xff1a; [{"file_name": "36199.png","syms": [],"boxes": [],"polygons": []},{"f…
阅读更多...
分享一下怎么做陪诊小程序

分享一下怎么做陪诊小程序

在当今快节奏的社会中&#xff0c;人们的生活压力越来越大&#xff0c;尤其是在大城市中&#xff0c;由于工作繁忙&#xff0c;生活节奏快&#xff0c;很多人都感到看病难、看病贵的问题。为了解决这一问题&#xff0c;陪诊小程序应运而生。陪诊小程序是一种可以提供线上预约、…
阅读更多...
基于SSM民宿预订及个性化服务系统-计算机毕设 附源码 04846

基于SSM民宿预订及个性化服务系统-计算机毕设 附源码 04846

SSM民宿预订及个性化服务系统 摘 要 伴随着国内旅游经济的迅猛发展民宿住宿行在国内也迎来了前所未有的发展机遇。传统的旅游模式已难以满足游客日益多元化的需求&#xff0c;随着人们外出度假的时间越来越长&#xff0c;导致人们在住宿的选择上更加追求舒适、个性化的住宿体验…
阅读更多...
vue+Fullcalendar

vue+Fullcalendar

vueFullcalendar: vueFullcalendar项目代码https://gitee.com/Oyxgen404/vue--fullcalendar.git
阅读更多...
CSS样式（盒子模型，内外边距等设置）

CSS样式（盒子模型，内外边距等设置）

盒子模型 目标&#xff1a;掌握盒子模型组成部分&#xff0c;使用盒子模型布局网页区域 01-选择器 结构伪类选择器 基本使用 作用&#xff1a;根据元素的结构关系查找元素。 选择器说明E:first-child查找第一个E元素E:last-child查找最后一个E元素E:nth-child(N)查找第N个E…
阅读更多...
jquery-picture-cut 任意文件上传 （CVE-2018-9208）

jquery-picture-cut 任意文件上传 （CVE-2018-9208）

jquery-picture-cut 任意文件上传 &#xff08;CVE-2018-9208&#xff09; 漏洞描述 picture cut是一个jquery插件&#xff0c;以非常友好和简单的方式处理图像&#xff0c;具有基于bootstrap或jquery ui的漂亮界面&#xff0c;具有ajax上传&#xff0c;从资源管理器拖动图像…
阅读更多...
Error: no matching distribution found for tensorflow-cpu==2.6.*

Error: no matching distribution found for tensorflow-cpu==2.6.*

目录 install_tensorflow()安装过程中遇到的问题 查找解决方案过程中&#xff1a; 解决办法&#xff1a; install_tensorflow()安装过程中遇到的问题 在服务器上安装tensorflow时&#xff0c;遇到了一个报错信息&#xff1a; 在网上找到一个类似的错误&#xff08;TensorFlow…
阅读更多...
【EI会议征稿】第二届纯数学、应用数学与计算数学国际学术会议（PACM 2024）

【EI会议征稿】第二届纯数学、应用数学与计算数学国际学术会议（PACM 2024）

第二届纯数学、应用数学与计算数学国际学术会议&#xff08;PACM 2024&#xff09; 2024 2nd International Cnference on Pure, Applied and Computational Mathematics (PACM 2024) 第二届纯数学、应用数学计算数学国际学术会议 (PACM2024) 将于2024年1月19-21日在中国厦门隆…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023