DynamicLinkLibraryAPI

最新推荐文章于 2024-01-08 17:18:36 发布
最新推荐文章于 2024-01-08 17:18:36 发布
阅读量1.9k 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/eclipser1987/article/details/23926395
版权

DynamicLinkLibraryAPI.h


尝试使用，动态链接库技术，来实现脚本刷新。


#pragma once

#if defined(WIN32) || defined(WIN64)
#include <Windows.h>
typedef HINSTANCE DLLHANDLER;
#elif defined(__linux__)
#include <dlfcn.h>
typedef void* DLLHANDLER;
#endif

namespace dll {
	
// 打开动态链接库。
bool OpenDLL(DLLHANDLER* pDLLHander, const char* path
#if defined(__linux__)
		, int mode = RTLD_NOW
#endif
		);


// 通过名称获得动态链接库中的函数或变量地址。
void* GetDLL(DLLHANDLER* pDLLHander, const char* name);


// 关闭动态链接库
bool CloseDLL(DLLHANDLER* pDLLHander);


}

DynamicLinkLibraryAPI.cpp

#include "DynamicLinkLibraryAPI.h"
#include <stdio.h>

namespace dll {



bool OpenDLL(DLLHANDLER* pDLLHander, const char* path
#if defined(__linux__)
		, int mode
#endif
		) {
			if (!pDLLHander || !path) {
#ifndef NDEBUG
				printf("\n=====================================================\n");
				printf("\tDEBUG:\n%s[%d]%s\t", __FILE__, __LINE__, "openDLL fial: null args");
				printf("\n=====================================================\n");
#endif
				return false;
			}
#if defined(WIN32) || defined(WIN64)
	*pDLLHander = LoadLibrary(path);
#elif defined(__linux__)
	*pDLLHander = dlopen(path, mode);
#endif

#ifndef NDEBUG
#if defined(WIN32) || defined(WIN64)
	printf("\n=====================================================\n");
	printf("\tDEBUG:\n%s[%d]path=[%s]\t", __FILE__, __LINE__, path);
	printf("\n=====================================================\n");
#elif defined(__linux__)
	printf("\n=====================================================\n");
	printf("\tDEBUG:\n%s[%d]path=[%s] mode=[%d]\t", __FILE__, __LINE__, path, mode);
	printf("\n=====================================================\n");
#endif
#endif

	return pDLLHander != nullptr;
}





void* GetDLL(DLLHANDLER* pDLLHander, const char* name) {
	if (!pDLLHander || !name) {
#ifndef NDEBUG
    printf("\n=====================================================\n");
    printf("\tDEBUG:\n%s[%d]%s\t", __FILE__, __LINE__, "getDLL fial: null args");
    printf("\n=====================================================\n");
#endif
		return nullptr;
	}
#if defined(WIN32) || defined(WIN64)
	return GetProcAddress(*pDLLHander, name);
#elif defined(__linux__)
	return dlsym(*pDLLHander, name);
#endif
}





bool CloseDLL(DLLHANDLER* pDLLHander) {
	bool flag = false;
	if (pDLLHander) {

#if defined(WIN32) || defined(WIN64)
	flag = FreeLibrary(*pDLLHander);
#elif defined(__linux__)
	flag = (dlclose(*pDLLHander) == 0);
#endif
	}
	
#ifndef NDEBUG
	if (flag) {
		printf("\n=====================================================\n");
		printf("\tDEBUG:\n%s[%d] %s\t", __FILE__, __LINE__, "closeDLL succ");
		printf("\n=====================================================\n");
	} else {
		printf("\n=====================================================\n");
		printf("\tDEBUG:\n%s[%d] %s\t", __FILE__, __LINE__, "closeDLL fail");
		printf("\n=====================================================\n");
	}
#endif

	return flag;
}


}

DynamicLinkLibraryMgr.h 

#pragma once

#include "DynamicLinkLibraryAPI.h"

#include <ostream>
#include <set>
#include <map>
#include <ctime>
#include <string.h>

#include <iostream>

// 创建已知类型的脚本函数类，及对象。
#define SCRIPTCLASS(NAME, DEFFUN)																\
class C##NAME {																					\
protected:																						\
	typedef DEFFUN;																				\
																								\
	static C##NAME* m_Instance;																	\
																								\
	C##NAME() {																					\
		m_pScripts = new std::set<DEF>;															\
	}																							\
public:																							\
																								\
	bool operator==(const C##NAME& ref) {														\
		return m_Version == ref.m_Version;														\
	}																							\
																								\
	static C##NAME* Instance() {																\
		if (!m_Instance) {																		\
			m_Instance = new C##NAME;															\
		}																						\
		return m_Instance;																		\
	}																							\
																								\
	const double GetVersion() const {															\
		return m_Version;																		\
	}																							\
																								\
	void SetVersion(double version) {															\
		m_Version = version;																	\
	}																							\
																								\
	const time_t GerCtime() const {																\
		return m_Ctime;																			\
	}																							\
																								\
	bool Reg(DLLHANDLER* dllHandler, const char* name) {										\
		void* p = dll::GetDLL(dllHandler, name);												\
		if (!p) {																				\
			std::cout << "can not find " << name << " dll fun" << std::endl;					\
			return false;																		\
		}																						\
		if (p) {																				\
			m_pScripts->insert((DEF)p);															\
		}																						\
		return true;																			\
	}																							\
																								\
	std::set<DEF>* GetScripts() {																\
		return this->m_pScripts;																\
	}																							\
																								\
	void Clear() {																				\
		this->m_pScripts->clear();																\
	}																							\
private:																						\
	double		m_Version;																		\
	time_t		m_Ctime;																		\
	std::set<DEF>* m_pScripts;																	\
};																								\
C##NAME* C##NAME::m_Instance = nullptr;															\


// 动态函数
class CDynamicLinkFun {
	// 类中声明
	friend std::ostream& operator<<(std::ostream& os, const CDynamicLinkFun& ref);
	
public:
	CDynamicLinkFun(const char* name, const char* tname, void* fun) ;

private:
	
	char m_Name[64];
	char m_Tname[128];

	void* m_Fun;

	time_t m_Ctime;
};



class CDynamicLinkLibrary {

public:
	CDynamicLinkLibrary(const char* name, const char* path) ;

	~CDynamicLinkLibrary() ;

	// 获得动态库地址
	const char* GetPath() const ;

	// 设置动态库地址
	void SetPath(const char* path) ;

	// 初始化
	bool Init() ;

	// 销毁
	bool Destory() ;

	// 重新加载
	bool Reload() ;


private:
	// 库名称
	char										m_Name[64];
	// 库地址
	char										m_Path[128];
	// 加载时间
	time_t										m_Ctime;
	// 该动态库中的所有函数
	std::map<const char*, CDynamicLinkFun*>		m_Scripts;
	// 动态链接库描述
	DLLHANDLER*									m_pDLLHander;
	// 状态：0为默认，1为已初始化
	int											m_State;
};


class CDynamicLinkLibraryMgr {

public:
	// 重新加载所有
	int reloadDLLs();
};


DynamicLinkLibraryMgr.cpp

#include "DynamicLinkLibraryMgr.h"


// 类外定义
std::ostream& operator<<(std::ostream& os, const CDynamicLinkFun& ref) {
	os << " Name:" << ref.m_Name << " TName:" << ref.m_Tname << " Address:" << std::showpoint << ref.m_Fun;
	return os;
}

CDynamicLinkFun::CDynamicLinkFun(const char* name, const char* tname, void* fun) {
	strcpy(m_Name, name);
	strcpy(m_Tname, tname);
	m_Fun = fun;

	time(&m_Ctime);
}


CDynamicLinkLibrary::CDynamicLinkLibrary(const char* name, const char* path) {
	m_State = 0;
	m_pDLLHander = new DLLHANDLER;
	strcpy(m_Name, name);
	strcpy(m_Path, path);
	time(&m_Ctime);
} 

CDynamicLinkLibrary::~CDynamicLinkLibrary() 
{
	Destory();

	m_pDLLHander = nullptr;
}

const char* CDynamicLinkLibrary::GetPath() const {
	return this->m_Path;
}


void CDynamicLinkLibrary::SetPath(const char* path) {
	strcpy(m_Path, path);
}


bool CDynamicLinkLibrary::Init() {
	if (m_State) {
#ifndef NDEBUG
		printf("\n=====================================================\n");
		printf("\tDEBUG:\n%s[%d] %s\t", __FILE__, __LINE__, "动态链接库已初始化，无法再初始化！");
		printf("\n=====================================================\n");
#endif
		return false;
	}
	if (dll::OpenDLL(m_pDLLHander, m_Path)) {
		m_State = 1;
		// void GetScripts(std::map<const char*, const char*>& scripts)
		void (*GetScripts)(std::map<const char*, const char*>& scripts) = reinterpret_cast<void (*) (std::map<const char*, const char*>& scripts)>(dll::GetDLL(m_pDLLHander, "GetScripts"));
		if (!GetScripts) {
			return false;
		}
		std::map<const char*, const char*> __map;
		GetScripts(__map);

		for (auto kv : __map) {
			std::cout << kv.first << " " << kv.second << std::endl;
#ifndef NDEBUG
			bool flag = true;
#endif
			if (strlen(kv.first) > 0 && strlen(kv.second) > 0) {
				void* fun = dll::GetDLL(m_pDLLHander, kv.first);
				if (fun) {
					m_Scripts.insert(std::make_pair(kv.first, new CDynamicLinkFun(kv.first, kv.second, fun)));
#ifndef NDEBUG
					flag = false;
#endif
				}
			}
#ifndef NDEBUG
			if (flag) {
				printf("\n=====================================================\n");
				printf("\tDEBUG:\n%s[%d]%s %s %s\t", __FILE__, __LINE__, "load function fail", kv.first, kv.second);
				printf("\n=====================================================\n");
			}
#endif
		}

		std::cout << "\n---------------------------" << std::endl;
#ifndef NDEBUG
		for (auto kv : m_Scripts) {
			std::cout << *(kv.second) << std::endl;
		}
#endif
		return true;
	}
	return false;
}

bool CDynamicLinkLibrary::Destory() {
	if (!m_State) {
#ifndef NDEBUG
		printf("\n=====================================================\n");
		printf("\tDEBUG:\n%s[%d] %s\t", __FILE__, __LINE__, "动态链接库尚未初始化,无法销毁！");
		printf("\n=====================================================\n");
#endif
		return false;
	}
	bool rt = dll::CloseDLL(m_pDLLHander);
	if (rt) {
		m_State = 0;
	}

	for (auto kv : m_Scripts) {
		kv.second = nullptr;
	}
	m_Scripts.clear();


	return rt;
}


bool CDynamicLinkLibrary::Reload() {
	Destory();
	return Init();
}

min.cpp 

#include "DynamicLinkLibraryMgr.h"
#include <iostream>
#include <thread>
#include <fstream>
#include <string>
#include <string.h>


#if defined(WIN32) || defined(WIN64)
#define path "../Debug/SayHello.dll"
#elif defined(__linux__)
#define path "../Debug/SayHello.so"
#endif

bool bReload = true;
char path2[126] = {0};

int test(DLLHANDLER* pHandler);
int reload(DLLHANDLER* pHandler);

// SCRIPTCLASS(LoginPreScript, void (*DEF) (void*) )

int main(int argc, char **argv) {
	CDynamicLinkLibrary* pDynamicLinkLibrary = nullptr;
	if (argc == 2) {
		strcpy(path2, argv[1]);
		std::cout << "path2 " << path2 << std::endl;
		pDynamicLinkLibrary = new CDynamicLinkLibrary("test" ,path2);
	} else {
		pDynamicLinkLibrary = new CDynamicLinkLibrary("test", path);
	}

	pDynamicLinkLibrary->Init();


	return 0;
}


// 
// int main(int argc, char **argv) {
// 
// 	if (argc == 2) {
// 		strcpy(path2, argv[1]);
// 		std::cout << "path2 " << path2 << std::endl;
// 	}
// 
// 	DLLHANDLER* pHandler = new DLLHANDLER;
// 	std::thread t(
// 		[&pHandler](){
// 
// 			for (;;) {
// 				test(pHandler);
// 			}
// 	}
// 	);
// 	t.detach();
// 
// 	for (;;) {
// 
// 		std::string str;
// 		std::getline(std::cin, str);
// 		strcpy(path2, str.c_str());
// 		std::cout << "path2 " << path2 << std::endl;
// 		reload(pHandler);
// 
// 		
// 	}
// 
// 	return 0;
// }
// 
// int reload(DLLHANDLER* pHandler) {
// 	bReload = true;
// 	return dll::CloseDLL(pHandler);
// }
// 
// int test(DLLHANDLER* pHandler) {
// 
// 	std::cout << "bReload :: " << std::boolalpha << bReload << std::endl;
// 	std::cout << "path2 :: " << path2 << std::endl;
// 	if (bReload) {
// 		bReload = false;
// 
// 		bool ret = false;
// 		if (strlen(path2) > 0) {
// 			ret = dll::OpenDLL(pHandler, path2);
// 		} else {
// 			ret = dll::OpenDLL(pHandler, path);
// 		}
// 		
// 		if (!ret) {
// 			std::cout << "can not open dll" << std::endl;
// 			return -1;
// 		}
// 
// 		CLoginPreScript::Instance()->Clear();
// 		CLoginPreScript::Instance()->Reg(pHandler, "loginPre1");
// 		CLoginPreScript::Instance()->Reg(pHandler, "loginPre2");
// 
// 	}
// 
// 	auto scripts = CLoginPreScript::Instance()->GetScripts();
// 	for (auto loginpre = scripts->begin(); loginpre != scripts->end(); loginpre++) {
// 		(*loginpre)(nullptr);
// 	}
// 
// 
// // 	bool ret =  dll::closeDLL(pHandler);
// // 	if (ret) {
// // 		std::cout << "关闭成功" << std::endl;
// // 	} else {
// // 		std::cout << "关闭失败" << std::endl;
// // 	}
// // 
// // 	ret = dll::openDLL(pHandler, path);
// // 	if (!ret) {
// // 		std::cout << "打开动态链接库失败" << std::endl;
// // 		return -1;
// // 	}
// 
// 	
// // 
// // 
// // 	void* p = dll::getDLL(pHandler, "add");
// // 	if (!p) {
// // 		std::cout << "can not get dll method" << std::endl;
// // 		return -2;
// // 	}
// // 
// // 	int (*addFun)(int, int) = (int(*)(int, int))p;
// // 	int sum = addFun(1, 8);
// // 
// // 	std::cout << "sum = " << sum << std::endl;
// // 
// // 
// // 	void* p2 = dll::getDLL(pHandler, "add2");
// // 	if (!p2) {
// // 		std::cout << "can not get dll method" << std::endl;
// // 		return -3;
// // 	}
// // 
// // 	int (*add2Fun)(int, int, int) = (int(*)(int, int, int))p2;
// // 	int sum2 = add2Fun(1, 8, 10);
// // 
// // 	std::cout << "sum2 = " << sum2 << std::endl;
// // 
// // 
// // 	void* p3 = dll::getDLL(pHandler, "sayHello");
// // 	if (!p3) {
// // 		std::cout << "can not get dll method" << std::endl;
// // 		return -4;
// // 	}
// // 	void (*sayHelloFun)() = (void(*)()) p3;
// // 
// // 	sayHelloFun();
// // 
// // 	void* (*getUser)() = (void* (*)()) dll::getDLL(pHandler, "getUser");
// // 
// // 	void* pU = getUser();
// // 
// // 	void (*printUser)(void*) = (void (*)(void*)) dll::getDLL(pHandler, "printUser");
// // 
// // 	printUser(pU);
// // 
// // #if defined(WIN32) || defined(WIN64)
// // #elif defined(__linux__)
// // 	char** name = (char**) dll::getDLL(pHandler, "name");
// // 	int* age = (int*) dll::getDLL(pHandler, "age");
// // 	std::cout << *name << std::endl;
// // 	std::cout << *age << std::endl;
// // 
// // #endif
// 
// 	std::this_thread::sleep_for(std::chrono::seconds(10));
// 
// 	return 1;
// 
// }


以下是动态链接库项目：

DynamicLinkLibraryScript.cpp

#include <map>

#ifndef DLL_API
	#if defined(WIN32) || defined(WIN64)
		#define DLL_API __declspec(dllexport)
	#elif defined(__linux__)
		#define DLL_API 
	#endif
#endif

extern "C" DLL_API void GetScripts(std::map<const char*, const char*>& scripts) {
	scripts.insert(std::make_pair("loginPre1", "void (*loginPre1)(void*)"));
	scripts.insert(std::make_pair("loginPre2", "void (*loginPre2)(void*)"));
	scripts.insert(std::make_pair("add", "int (*add)(int ,int )"));
	scripts.insert(std::make_pair("add2", "int (*add2)(int , int , int )"));
	scripts.insert(std::make_pair("sayHello", "void (*sayHello)()"));
	scripts.insert(std::make_pair("getUser", "void* (*getUser)()"));
	scripts.insert(std::make_pair("printUser", "void (*printUser)(void*)"));
}


LoginPreScript.cpp

#include <iostream>

// void (*LoginPre) (void*)


#ifndef DLL_API
	#if defined(WIN32) || defined(WIN64)
		#define DLL_API __declspec(dllexport)
	#elif defined(__linux__)
		#define DLL_API 
	#endif
#endif


extern "C" DLL_API void loginPre1(void* p) {

	std::cout << "loginPre1 yyyyyy" << std::endl;
}

extern "C" DLL_API void loginPre2(void* p) {

	std::cout << "loginPre2 xxxxxx" << std::endl;
}

Math.h

#pragma once


#ifndef DLL_API
#if defined(WIN32) || defined(WIN64)
#define DLL_API __declspec(dllexport)
#elif defined(__linux__)
#define DLL_API 
#endif
#endif


extern "C" int DLL_API add(int x,int y);



Math.cpp 

#include "Math.h"

int add(int x,int y) {  
	return x + y;  
}


Math2.cpp

#ifndef DLL_API
#if defined(WIN32) || defined(WIN64)
#define DLL_API __declspec(dllexport)
#elif defined(__linux__)
#define DLL_API 
#endif
#endif

extern "C" int DLL_API add2(int i, int j, int k) {

	return i + j + k + 100000;
}


SayHello2.cpp

#include <iostream>
#include <string.h>

#ifndef DLL_API
	#if defined(WIN32) || defined(WIN64)
		#define DLL_API __declspec(dllexport)
	#elif defined(__linux__)
		#define DLL_API 
	#endif
#endif

char* name = "jack";
int age = 27;


extern "C" DLL_API void sayHello() {

	std::cout << "hello 3!" << name << age << std::endl;
}

class User {
	// 类中声明
	friend std::ostream& operator<<(std::ostream& os, const User& ref);
	
	
public:
	User(const char* username, const char* password) {
		strcpy(this->username, username);
		strcpy(this->password, password);
	}

	const char* getUsername() const {
		return this->username;
	}

	const char* getPassword() const {
		return this->password;
	}
private:
	char username[64];
	char password[64];
};

// 类外定义
std::ostream& operator<<(std::ostream& os, const User& ref) {
	os << ref.username << " " << ref.password;
	return os;
}



User* pU = new User("jack", "pswd");

extern "C" DLL_API User* getUser() {
	return pU;
}

extern "C" DLL_API void printUser(User* u) {
	std::cout << *u << std::endl;
}












动态连接库(DLL- Dynamic Link Library)
坚持,才是力量.老实做人,踏实做事.
11-03 2965
动态连接库(DLL- Dynamic Link Library) 链接库是个很不错的想法,直接以二进制形式供用户使用,而免除用户维护代码的麻烦,或者避免用户看到实现代码.分类Windows系统上链接库分为2种, 静态链接.lib 和动态链接.dll ,而动态链接库按载入方式又分2种, Dynamic Load 和 Static load
C++_编写动态链接库
知行合一
08-17 1万+
动态链接库简介动态链接库（Dynamic Link Library 或者 Dynamic-link Library，缩写为 DLL），是微软公司在微软Windows操作系统中，实现共享函数库概念的一种方式。这些库函数的扩展名是 ”.dll”、”.ocx”（包含ActiveX控制的库）或者 “.drv”（旧式的系统驱动程序）。 动态链接提供了一种方法，使进程可以调用不属于其可执行代码的函数。函数的可
Pr：动态链接
qq_41176800的博客
03-16 1647
Premiere Pro的动态链接功能（Dynamic Link）可以在视频创作时与 After Effects 和 Audition 之间创建动态链接...
iOS-底层原理 15：dyld加载流程
lin1109221208的博客
09-27 1448
iOS 底层原理 文章汇总 本文的目的主要是分析dyld的加载流程，了解在main函数之前，底层还做了什么 引子 创建一个project，在ViewController中重写了load方法，在main中加了一个C++方法，即kcFUnc，请问它们的打印先后顺序是什么？ 运行程序，查看 load、kcFunc、main的打印顺序，下面是打印结果，通过结果可以看出其顺序是 load --> C++方法 --> main 为什么是这么一个顺序？按照常规的思维理解，main不是入口函.
EDA工具（三）Keysight ADS 2024安装教程嵌入Virtuso配置RFIC dynamic link方法
最新发布
qq_24941989的博客
01-08 8388
Keysight ADS 2024安装教程，嵌入Virtuso配置RFIC dynamic link方法。
单片机高阶技能之动态链接库技术实现
m0_37777700的博客
04-18 2347
AderStep_JeanCheng_优快云博客 https://blog.youkuaiyun.com/gatieme snmplink的博客_优快云博客 https://blog.youkuaiyun.com/qingwufeiyang12346 strongerHuang_ybhuangfugui_优快云博客 https://blog.youkuaiyun.com/ybhuangfugui/article...
动态链接库(Dynamic Link Library)学习笔记
abin_gha的专栏
05-11 1437
动态链接（Dynamic Linking）是相对于静态链接（Static Linking）而言的。程序设计中，为了能做到代码和模块的重用，程序设计者常常将常用的功能函数做成库，当程序需要实现某种功能时，就直接调用库文件中的函数，从而实现了代码的重用。早期的程序设计中，可重用的函数模块以编译好的二进制代码形式放于静态库文件中，在MS的操作系统中是Lib为后缀的文件。程
AEGP增效工具AEDynamicLinkServer：无法链接到Adobe Media Encoder
热门推荐
不积跬步，无以至千里
12-16 13万+
原地址：AEGP增效工具AEDynamicLinkServer：无法链接到Adobe Media Encoder_影视后期特效培训-薛大龙_新浪博客 http://blog.sina.com.cn/s/blog_9948ff720102wzif.html AEGP增效工具AEDynamicLinkServer：无法链接到Adobe Media Encoder Media Encod
卸载动态库DLL（Dynamic Link Library）
zhaoxj_2017的博客
06-19 2710
在给热部署系统热加载资源时，如果不掌握对象和资源的生命周期，系统运行时很容易产生一些意想不到的错误。从Jar 加载到系统中，到被替换，不同的资源生命周期是不一样的。 首先是对象，如果一个对象没有手动的丢弃，那么它的生命周期与加载它的 ClassLoader 生命周期一样。销毁对象时，只需要确保对象的引用为 null 即可，清理游离的对象的工作由GC处理。 ...
Dynamic-link library
wang010366的专栏
09-09 2418
动态链接库基本概念Dynamic-link library (or DLL) is Microsoft’s implementation of the shared library concept in the Microsoft Windows and OS/2 operating systems. These libraries usually have the file extension D
C#调用C/C++动态链接库(.dll)详解
tery001的专栏
06-04 7572
第一篇编译C的动态连接库 在实际工作中,我们经常会将C语言中的.lib和.h文件(静态库)编译成动态连接库.dll文件(这里只提供这两种文件，没有完整的工程)，以提供给其他语言平台调用。 1，必须有.lib文件，只有.h文件是无法编译动态连接库的。 2，我使用的是VS2008，这里打开VS，新建项目—〉win32控制台应用程序，输入项目名称，点击确定，图示如fig.1所示。
ps提示：不能完成“视频帧到图层”命令，因为DynamicLink不可用
Amouzy的博客
02-14 1万+
想要用Photoshop来将视频制作成gif动图，有些破解版的Photoshop可能会遇到以下问题： 结果提示：不能完成“视频帧到图层”命令，因为DynamicLink不可用。 参考了网上诸多办法，还是没法解决。最后不如直接在线视频制作gif。众里寻他，终于找到一个品质还不错且免费的网站，在此分享。 附上地址如下： https://airmore.cn/video-to-gif-online 制作出来的动图大小可能已经超过5MB,再用photoshop压缩一下就好了： 大功告成！ ...
android 动态链接,使用 REST API 创建 Dynamic Links 动态链接
weixin_42538752的博客
05-26 393
注意：完整的 Short Links API 参考文档可以在“参考文档”部分找到。您可以使用 Firebase Dynamic Links REST API 创建短动态链接。此 API 会接受一个长动态链接或一个包含动态链接参数的对象，并返回一个类似下面的网址：https://example.page.link/WXYZ使用 API 和客户端 (Android/iOS) SDK 创建的短动态链接不...
静态连接（dynamic link）和动态连接（static link）初步理解
Linuxtiger之家
07-30 8843
前两天配置QT和VTK环境，焦头烂额啊，第一次配置个环境配置这么费劲的，这俩工具都不是微软出的开发库，需要自己编译，编译时间那个长。。。3,4个小时啊，等的花都谢了，好不容易编译好了，又出现了各种问题。 首先，早就听说过这两个库是跨平台的，当时觉得好牛逼啊，作为一个鄙视wind
动态链接(dynamic link)与静态链接(static link)
lx123010的专栏
04-15 4646
静态库与动态库       静态库的所有数据都会被整合进目标代码中，因此编译成的文件比较大。它的优点就显而易见了，即编译后的执行程序不需要外部的函数库支持，因为所有使用的函数都已经被编译进去了。当然这也会成为缺点，（1）首先就是系统空间被浪费了。这是显而易见的，想象一下，如果多个程序链接了同一个库，则每一个生成的可执行文件就都会有一个库的副本，必然会浪费系统空间。（2）再者，一旦发现了静态函
Windows系统常见API
师从小白
01-05 2073
Core Audio IMMDeviceEnumerator 枚举音频设备集（IMMDeviceCollection），获取默认设备，通过ID获取设备(IMMDevice)，注册通知，取消通知(IMMNotificationClient) IMMDeviceCollection 音频设备集中数量，通过索引取出设备(IMMDevice) IMMNotificationClient IUnknow接口，继承实现IUnknow和设备状态改变、设备增加、设备删除、默认设备改变和设
C++11 std::bind std::function 高级用法
噬日者
04-24 5万+
C++11 std::bind std::function 高级用法
google protocol buffer (C++,Java序列化使用实例)
噬日者
01-21 1万+
转载,请注明出处: http://blog.youkuaiyun.com/eclipser1987/article/details/8525383  (eclipser@163.com) 1.下载安装: google protocol buffer 的官网地址是:http://code.google.com/p/protobuf/         建议下载稳定版本:protobuf-2.4.1
golang select 选择器的两种方案
噬日者
05-17 1万+
golang select 选择器 常规模式:
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值