blocks|key|572039|text|不，我认为不写汇编是不可能的。原因是在调用目标函数之前，需要对堆栈上的内容进行精确控制，在纯C中没有真正的方法可以做到这一点。当然，在汇编中这样做很简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|572040|而且，对于所有这些参数，您都使用了PCSTR，这实际上就是const+char+*。但是由于所有这些arg都不是字符串，所以您实际上想要用于返回值和Arguments[]的是void+*或LPVOID。这是当您不知道参数的真正类型时应该使用的类型，而不是将它们转换为char+*。|offset|length|style|CODE|572041|entityMap^0|0|T|C|2F|6|2M|6|3P|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|I|$]]

No, I don't think its possible to do with without writing some assembly. The reason is you need precise control over what is on the stack before you call the target function, and there's no real way to do that in pure C. It is, of course, simple to do in Assembly though.

Also, you're using PCSTR for all of these arguments, which is really just <code>const char *</code>. But since all of these args aren't strings, what you actually want to use for return value and for Arguments[] is <code>void *</code> or <code>LPVOID</code>. This is the type you should use when you don't know the true type of the arguments, rather than casting them to <code>char *</code>.

blocks|key|2101226|text|首先:在C中不能将类型作为参数传递，剩下的唯一选项是宏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2101227|只要您执行一个LoadLibrary/GetProcAddress来调用Win32函数，这个方案就可以进行一些修改(用于参数的void*数组)。如果没有函数名字符串，那就没用了。在C中，调用函数的唯一方法是通过它的名称(标识符)，在大多数情况下，该名称会衰减到指向函数的指针。您还必须处理转换返回值的问题。|offset|length|style|CODE|2101228|我最好的选择是：|2101229|//+define+a+function+type+to+be+passed+on+to+the+next+macro
#define+Declare(ret,+cc,+fn_t,+...)+typedef+ret+(cc+*fn_t)(__VA_ARGS__)

//+for+the+time+being+doesn't+work+with+UNICODE+turned+on
#define+Call(dll,+fn,+fn_t,+...)+do+{\
++++HMODULE+lib+=+LoadLibraryA(dll);+\
++++if+(lib)+{+\
++++++++fn_t+pfn+=+(fn_t)GetProcAddress(lib,+fn);+\
++++++++if+(pfn)+{+\
++++++++++++(pfn)(__VA_ARGS__);+\
++++++++}+\
++++++++FreeLibrary(lib);+\
++++}+\
++++}+while(0)

int+main()+{
++++Declare(int,+__stdcall,+MessageBoxProc,+HWND,+LPCSTR,+LPCSTR,+UINT);

++++Call("user32.dll",+"MessageBoxA",+MessageBoxProc,+
++++++++++NULL,+((LPCSTR)"?"),+((LPCSTR)"Details"),+
++++++++++(MB_ICONWARNING+%7C+MB_CANCELTRYCONTINUE+%7C+MB_DEFBUTTON2));

++++return+0;
}|code-block|syntax|javascript|2101230|entityMap^0|0|7|Q|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

First things first: You cannot pass a type as a parameter in C. The only option you are left with is macros.

This scheme works with a little modification (array of void * for arguments), provided you are doing a <code>LoadLibrary/GetProcAddress</code> to call Win32 functions. Having a function name string otherwise will be of no use. In C, the only way you call a function is via its name (an identifier) which in most cases decays to a pointer to the function. You also have to take care of casting the return value.

My best bet:

<pre><code>// define a function type to be passed on to the next macro
#define Declare(ret, cc, fn_t, ...) typedef ret (cc *fn_t)(__VA_ARGS__)

// for the time being doesn't work with UNICODE turned on
#define Call(dll, fn, fn_t, ...) do {\
 HMODULE lib = LoadLibraryA(dll); \
 if (lib) { \
 fn_t pfn = (fn_t)GetProcAddress(lib, fn); \
 if (pfn) { \
 (pfn)(__VA_ARGS__); \
 } \
 FreeLibrary(lib); \
 } \
 } while(0)

int main() {
 Declare(int, __stdcall, MessageBoxProc, HWND, LPCSTR, LPCSTR, UINT);

 Call("user32.dll", "MessageBoxA", MessageBoxProc, 
 NULL, ((LPCSTR)"?"), ((LPCSTR)"Details"), 
 (MB_ICONWARNING | MB_CANCELTRYCONTINUE | MB_DEFBUTTON2));

 return 0;
}
</code></pre>

blocks|key|572133|text|拥有这样的函数听起来是个糟糕的主意，但您可以尝试这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|572134|int+Call(LPCSTR+DllName,+LPCSTR+FunctionName,+
++USHORT+ArgumentCount,+int+args[])
{
+++void+STDCALL+(*foobar)()=lookupDLL(...);

+++switch(ArgumentCount)+{
++++++++/*+Note:+If+these+give+some+compiler+errors,+you+need+to+cast
+++++++++++each+one+to+a+func+ptr+type+with+suitable+number+of+arguments.+*/
++++++case+0:+return+foobar();
++++++case+1:+return+foobar(args[0]);
++++++...
+++}
}|code-block|syntax|javascript|572135|在32位系统上，几乎所有的值都符合32位字，较短的值作为函数调用参数的32位字推入堆栈，因此您应该能够以这种方式调用几乎所有的Win32+API函数，只需将参数转换为int和从int返回到适当类型的返回值即可。|572136|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Having a function like that sounds like a bad idea, but you can try this:

<pre><code>int Call(LPCSTR DllName, LPCSTR FunctionName, 
 USHORT ArgumentCount, int args[])
{
 void STDCALL (*foobar)()=lookupDLL(...);

 switch(ArgumentCount) {
 /* Note: If these give some compiler errors, you need to cast
 each one to a func ptr type with suitable number of arguments. */
 case 0: return foobar();
 case 1: return foobar(args[0]);
 ...
 }
}
</code></pre>

On a 32-bit system, nearly all values fit into a 32-bit word and shorter values are pushed onto stack as 32-bit words for function call arguments, so you should be able to call virtually all Win32 API functions this way, just cast the arguments to int and the return value from int to the appropriate types.

blocks|key|819810|text|我不确定您是否会对它感兴趣，但是有一个选项是shell到RunDll32.exe并让它为您执行函数调用。RunDll32有一些限制，我不认为您可以访问返回值，但是如果正确地形成命令行参数，它将调用该函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|819811|这是一个链接|offset|length|819812|entityMap|0|LINK|mutability|MUTABLE|url|http://support.microsoft.com/kb/164787^0|0|4|2|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

I'm not sure if it will be of interest to you, but an option would be to shell out to RunDll32.exe and have it execute the function call for you. RunDll32 has some limitations and I don't believe you can access the return value whatsoever but if you form the command line arguments properly it will call the function.

Here's a <a href="http://support.microsoft.com/kb/164787" rel="nofollow noreferrer">link</a>

blocks|key|819967|text|首先，应该将每个参数的大小添加为额外的参数。否则，您需要估计每个函数推入堆栈的每个参数的大小，这对于WinXX函数来说是可能的，因为它们必须与文档中的参数兼容，但很繁琐。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|819968|其次，除了varargs函数之外，没有一种“纯C”方法可以在不知道参数的情况下调用函数，而且.DLL中的函数使用的调用约定也没有约束。|819969|实际上，第二部分比第一部分更重要。|819970|理论上，您可以设置一个预处理宏/#include结构来生成所有参数类型的组合，比如11个参数，但这意味着您可以提前知道哪些类型将通过函数Call传递。如果你问我的话就有点疯狂了。|offset|length|style|CODE|819971|虽然，如果您真的想不安全地这样做，您可以传递C%2B%2B损坏的名称，并使用UnDecorateSymbolName提取参数的类型。但是，对于使用C链接导出的函数来说，这是行不通的。|819972|entityMap^0|0|0|0|1W|4|0|Y|K|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@$H|T|I|U|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@$H|W|I|X|J|K]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|O|$]]

First, you should add the size of each argument as an extra parameter. Otherwise, you need to divine the size of each parameter for each function to push onto the stack, which is possible for WinXX functions since they have to be compatible with the parameters they are documented, but tedious.

Secondly, there isn't a "pure C" way to call a function without knowing the arguments except for a varargs function, and there is no constraint on the calling convention used by a function in a .DLL.

Actually, the second part is more important than the first.

In theory, you could set up a preprocessor macro/#include structure to generate all combinations of parameter types up to, say, 11 parameters, but that implies that you know ahead of time which types will be passed through you function <code>Call</code>. Which is kind of crazy if you ask me.

Although, if you really wanted to do this unsafely, you could pass down the C++ mangled name and use <code>UnDecorateSymbolName</code> to extract the types of the parameters. However, that won't work for functions exported with C linkage.

blocks|key|572271|text|很多Win32+API都使用指向具有特定布局的结构的指针。其中，一个大子集遵循一种公共模式，在调用结构之前，必须初始化第一个DWORD以使其具有结构的大小。有时，它们需要传入一个内存块，然后将结构写入其中，而内存块的大小必须是通过首先使用空指针调用相同的API并读取返回值来发现正确大小来确定的。一些API分配一个结构并返回一个指向它的指针，因此必须用第二个调用来解除该指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|572272|如果一次可以有效地调用一组API，并且可以从一个简单的字符串表示转换单个参数，那么我就不会感到惊讶了。|572273|要使这一想法普遍适用，我们必须走到相当极端的地步：|572274|typedef+void+DynamicFunction(size_t+argumentCount,+const+wchar_t+*arguments[],
+++++++++++++++++++++++++++++size_t+maxReturnValueSize,+wchar_t+*returnValue);

DynamicFunction+*GenerateDynamicFunction(const+wchar_t+*code);|code-block|syntax|javascript|572275|您将向GenerateDynamicFunction传递一个简单的代码片段，它将该代码包装在一些标准样板中，然后调用一个C编译器/链接器从它生成一个动态链接库(有很多可用的免费选项)，其中包含该函数。然后它将LoadLibrary该DLL并使用GetProcAddress查找函数，然后返回它。这将是昂贵的，但您只需做一次，并缓存产生的DynamicFunctionPtr供重复使用。您可以动态地将指针保存在哈希表中，并由代码片段本身键控。|offset|length|style|CODE|572276|样板可能是：|572277|#include+<windows.h>+
//+and+anything+else+that+might+be+handy

void+DynamicFunctionWrapper(size_t+argumentCount,+const+wchar_t+*arguments[],
+++++++++++++++++++++++++++++size_t+maxReturnValueSize,+wchar_t+*returnValue)
{
++++//+---+insert+code+snipped+here
}|572278|因此，该系统的一个示例用法是：|572279|DynamicFunction+*getUserName+=+GenerateDynamicFunction(
++++"GetUserNameW(returnValue,+(LPDWORD)(&maxReturnValueSize))");

wchar_t+userName[100];
getUserName(0,+NULL,+sizeof(userName)+/+sizeof(wchar_t),+userName);|572280|您可以通过让GenerateDynamicFunction接受参数计数来增强这一点，这样它就可以在包装器开始时生成一个检查是否传递了正确数量的参数。如果您在其中放置了一个hashtable来缓存每个遇到的codesnippet函数，那么您可以接近您的原始示例。调用函数将接受一个代码片段，而不仅仅是一个API名称，否则将是相同的。它将在哈希表中查找代码片段，如果不存在，它将调用GenerateDynamicFunction并将结果存储在哈希表中，以便下次使用。然后，它将对函数执行调用。示例用法：|572281|wchar_t+userName[100];

Call("GetUserNameW(returnValue,+(LPDWORD)(&maxReturnValueSize))",
+++++0,+NULL,+sizeof(userName)+/+sizeof(wchar_t),+userName);|572282|当然，这样做没有多大意义，除非这个想法是打开某种普通的安全漏洞。例如，将Call公开为e.g.服务。对您最初的想法来说，安全问题是存在的，但是不那么明显，因为您建议的最初方法不会那么有效。我们做得越强大，安全问题就越严重。|572283|基于注释的更新：|BOLD|572284|.NET框架有一个名为p/invoke的特性，它的存在正是为了解决您的问题。因此，如果您将此作为一个项目来学习有关内容，您可以查看p/invoke来了解它有多复杂。您可以使用脚本语言针对.NET框架，而不是实时解释脚本或将它们编译到您自己的字节码中，您可以将它们编译为IL。或者，您可以从.NET上已有的许多脚本语言中托管现有的脚本语言。|572285|entityMap^0|0|0|0|0|2W|B|3E|E|0|0|0|0|0|6|N|0|0|10|4|0|5|3|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1D|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1E|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1F|8|@$M|1G|N|1H|O|P]|$M|1I|N|1J|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1K|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1L|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1M|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1N|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1O|8|@$M|1P|N|1Q|O|P]]|9|@]|A|$]]|$1|10|3|11|5|H|7|1R|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|1S|8|@$M|1T|N|1U|O|P]]|9|@]|A|$]]|$1|14|3|15|5|6|7|1V|8|@$M|1W|N|1X|O|16]]|9|@]|A|$]]|$1|17|3|18|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|1A|$]]

A lot of Win32 APIs take pointers to structs with specific layouts. Of these, a large subset follow a common pattern where the first DWORD has to be initialized to have the size of the struct before it is called. Sometimes they require a block of memory to be passed, into which they will write a struct, and the memory block must be of a size that is determined by first calling the same API with a NULL pointer and reading the return value to discover the correct size. Some APIs allocate a struct and return a pointer to it, such that the pointer must be deallocated with a second call.

I wouldn't be that surprised if the set of APIs that can be usefully called in one shot, with individual arguments convertable from a simple string representation, is quite small.

To make this idea generally applicable, we would have to go to quite an extreme:

<pre><code>typedef void DynamicFunction(size_t argumentCount, const wchar_t *arguments[],
 size_t maxReturnValueSize, wchar_t *returnValue);

DynamicFunction *GenerateDynamicFunction(const wchar_t *code);
</code></pre>

You would pass a simple snippet of code to GenerateDynamicFunction, and it would wrap that code in some standard boilerplate and then invoke a C compiler/linker to make a DLL from it (there are quite a few free options available), containing the function. It would then <code>LoadLibrary</code> that DLL and use <code>GetProcAddress</code> to find the function, and then return it. This would be expensive, but you would do it once and cache the resulting DynamicFunctionPtr for repeated use. You could do this dynamically by keeping pointers in a hashtable, keyed by the code snippets themselves.

The boilerplate might be:

<pre><code>#include &lt;windows.h&gt; 
// and anything else that might be handy

void DynamicFunctionWrapper(size_t argumentCount, const wchar_t *arguments[],
 size_t maxReturnValueSize, wchar_t *returnValue)
{
 // --- insert code snipped here
}
</code></pre>

So an example usage of this system would be:

<pre><code>DynamicFunction *getUserName = GenerateDynamicFunction(
 "GetUserNameW(returnValue, (LPDWORD)(&amp;maxReturnValueSize))");

wchar_t userName[100];
getUserName(0, NULL, sizeof(userName) / sizeof(wchar_t), userName);
</code></pre>

You could enhance this by making <code>GenerateDynamicFunction</code> accept the argument count, so it could generate a check at the start of the wrapper that the correct number of arguments has been passed. And if you put a hashtable in there to cache the functions for each encountered codesnippet, you could get close to your original example. The Call function would take a code snippet instead of just an API name, but would otherwise be the same. It would look up the code snippet in the hashtable, and if not present, it would call GenerateDynamicFunction and store the result in the hashtable for next time. It would then perform the call on the function. Example usage:

<pre><code>wchar_t userName[100];

Call("GetUserNameW(returnValue, (LPDWORD)(&amp;maxReturnValueSize))",
 0, NULL, sizeof(userName) / sizeof(wchar_t), userName);
</code></pre>

Of course there wouldn't be much point doing any of this unless the idea was to open up some kind of general security hole. e.g. to expose <code>Call</code> as a webservice. The security implications exist for your original idea, but are less apparent simply because the original approach you suggested wouldn't be that effective. The more generally powerful we make it, the more of a security problem it would be.

Update based on comments:

The .NET framework has a feature called p/invoke, which exists precisely to solve your problem. So if you are doing this as a project to learn about stuff, you could look at p/invoke to get an idea of how complex it is. You could possibly target the .NET framework with your scripting language - instead of interpreting scripts in real time, or compiling them to your own bytecode, you could compile them to IL. Or you could host an existing scripting language from the many already available on .NET.

blocks|key|820135|text|其他帖子是正确的，几乎肯定需要组装或其他非标准的技巧来进行调用，更不用说实际调用约定的所有细节了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|820136|Windows至少对函数使用两个不同的调用约定：stdcall和cdecl。您需要同时处理这两种情况，甚至可能需要确定使用哪一种。|offset|length|style|CODE|820137|处理此问题的一种方法是使用现有的库来封装许多细节。令人惊讶的是，有一个：利布菲。在脚本环境中使用它的一个例子是Lua+外星人的实现，它是一个Lua模块，允许在纯Lua中创建任意DLL的接口，而不是外国人本身。|820138|entityMap|0|LINK|mutability|MUTABLE|url|http://sourceware.org/libffi/|1|http://alien.luaforge.net/^0|0|O|7|W|5|0|10|3|0|1N|3|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]|$D|13|E|14|1|15]]|A|$]]|$1|J|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

The other posts are right about the almost certain need for assembly or other non-standard tricks to actually make the call, not to mention all of the details of the actual calling conventions.

Windows DLLs use at least two distinct calling conventions for functions: <code>stdcall</code> and <code>cdecl</code>. You would need to handle both, and might even need to figure out which to use.

One way to deal with this is to use an existing library to encapsulate many of the details. Amazingly, there is one: <a href="http://sourceware.org/libffi/" rel="nofollow noreferrer">libffi</a>. An example of its use in a scripting environment is the implementation of Lua <a href="http://alien.luaforge.net/" rel="nofollow noreferrer">Alien</a>, a Lua module that allows interfaces to arbitrary DLLs to be created in pure Lua aside from Alien itself.

blocks|key|2101589|text|您可以尝试这样的方法--它适用于win32+API函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2101590|int+CallFunction(int+functionPtr,+int*+stack,+int+size)
{
++++if(!stack+&&+size+>+0)
++++++++return+0;
++++for(int+i+=+0;+i+<+size;+i%2B%2B)+{
++++++++int+v+=+*stack;
++++++++__asm+{
++++++++++++push+v
++++++++}
++++++++stack%2B%2B;
++++}
++++int+r;
++++FARPROC+fp+=+(FARPROC)+functionPtr;
++++__asm+{
++++++++call+fp
++++++++mov+dword+ptr[r],+eax
++++}
++++return+r;
}|code-block|syntax|javascript|2101591|“堆栈”参数中的参数应该是相反的顺序(因为这是它们被推到堆栈上的顺序)。|2101592|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You could try something like this - it works well for win32 API functions:

<pre><code>int CallFunction(int functionPtr, int* stack, int size)
{
 if(!stack &amp;&amp; size &gt; 0)
 return 0;
 for(int i = 0; i &lt; size; i++) {
 int v = *stack;
 __asm {
 push v
 }
 stack++;
 }
 int r;
 FARPROC fp = (FARPROC) functionPtr;
 __asm {
 call fp
 mov dword ptr[r], eax
 }
 return r;
}
</code></pre>

The parameters in the "stack" argument should be in reverse order (as this is the order they are pushed onto the stack).

To allow access to the Win32 API from a scripting language (written in C), I would like to write a function such as the following:

<pre><code>void Call(LPCSTR DllName, LPCSTR FunctionName, 
 LPSTR ReturnValue, USHORT ArgumentCount, LPSTR Arguments[])
</code></pre>

which will call, generically, any Win32 API function.

(the LPSTR parameters are essentially being used as byte arrays - assume that they have been correctly sized to take the correct data type external to the function. Also I believe that some additional complexity is required to distinguish between pointer and non-pointer arguments but I'm ignoring that for the purposes of this question).

The problem I have is passing the arguments into the Win32 API functions. Because these are stdcall I can't use varargs so the implementation of 'Call' must know about the number of arguments in advance and hence it cannot be generic...

I think I can do this with assembly code (by looping over the arguments, pushing each to the stack) but is this possible in pure C?

Update: I've marked the 'No it is not possible' answer as accepted for now. I will of course change this if a C-based solution comes to light.

Update: <a href="http://www.jbrowse.com/text/rdl_en.html" rel="nofollow noreferrer">ruby/dl</a> looks like it may be implemented using a suitable mechanism. Any details on this would be appreciated.

How can I write a generic C function for calling a Win32 function?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

为了允许从脚本语言(用C编写)访问Win32 API，我想编写如下函数：void Call(LPCSTR DllName, LPCSTR FunctionName,   LPSTR ReturnValue, USHORT ArgumentCount, LPSTR Arguments[])它将一般地调用任何Win32 A...

问如何编写调用Win32函数的通用C函数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何编写调用Win32函数的通用C函数？EN