blocks|key|1478114|text|是的，那是一口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1478115|cosine是一个函数指针。所以&cosine是指向那个指针的指针。然后，当我们把一个*放在它前面时，我们改变原来的指针，使它指向其他地方。|offset|length|style|CODE|1478116|就像这样：|1478117|int+i+=+5;
int+*ip+=+&i;
*ip+=+6;+++++++++/*+changes+i+to+6+*/|code-block|syntax|javascript|1478118|或者更像这样：|1478119|char+a[10],+b[10];
char+*p+=+a;
*(&p)+=+b;+++++++/*+changes+p+to+point+to+b+*/|1478120|但是在您的例子中，它更棘手，因为cosine是指向函数的指针，而不是指向数据的指针。大多数情况下，函数指针指向您在程序中定义的函数。但是在这里，我们安排使cosine指向由dlsym()函数加载的动态加载函数。|1478121|dlsym非常特殊，因为它可以返回指向数据的指针，以及指向函数的指针。所以它有一个不可能定义的返回类型。当然，它被声明为返回void+*，因为这是C中的“泛型”指针类型(请考虑malloc)。但是在纯C中，void+*是一个通用的数据指针类型；不能保证它能够与函数指针一起使用。|1478122|直截了当地说|1478123|cosine+=+dlsym(handle,+"cos");|1478124|但是现代编译器会抱怨，因为dlsym返回void+*，而cosine有类型double+(*)(double)+(即指向函数接受双重和返回双)的指针，这不是可移植的转换。|1478125|所以我们绕着谷仓，间接地设定了cosine的价值，而不是说|1478126|cosine+=+something|1478127|而是说|1478128|*(&cosine)+=+something|1478129|但是，在dlsym的情况下，这仍然是不好的，因为类型仍然不匹配。我们右边有void+*，所以左边需要void+*。解决方案是将地址&cosine转换成指针到指针到函数的地址，并将其转换为指针到指针到void或void+**，这样当我们将一个*抛到它面前时，我们又得到了一个void+*，这是分配dlsym返回值的合适目的地。因此，我们最终得到了您询问的一行：|1478130|*+(void+**)+(&cosine)+=+dlsym(handle,+"cos");|1478131|现在，重要的是要注意，我们在这里处于薄冰之中。我们使用了&和cast来绕过这样一个事实，即将指针到-void分配给“指针到函数”是不合法的。在此过程中，我们成功地沉默了编译器的警告，即我们所做的一切都是不合法的。(实际上，沉默警告恰恰是最初程序员使用这一策略的意图。)|1478132|潜在的问题是，如果数据指针和函数指针有不同的大小或表示，怎么办？这段代码用于处理函数指针cosine，就好像它是一个数据指针一样，将数据指针的比特阻塞到其中。如果数据指针在某种程度上比函数指针大，这将产生可怕的影响。(在你问“但是一个数据指针怎么会比一个函数指针大？”之前，例如，在MS编程时代的“紧凑”内存模型中，数据指针就是这样的)。|1478133|通常，玩这样的游戏来打破规则并关闭编译器警告是个坏主意。不过，就dlsym而言，这是可以接受的。dlsym不可能存在于函数指针与数据指针不同的系统中，因此，如果您使用的是dlsym，那么您必须在所有指针都相同的机器上运行，这段代码将工作。|1478134|同样值得一问的是，如果我们在调用dlsym时必须玩casts游戏，那么为什么还要带指针到指针在谷仓周围多走一圈呢？为什么不直接说|1478135|cosine+=+(double+(*)(double))dlsym(handle,+"cos");|1478136|答案是我不知道。我非常肯定，这个简单的转换也会运行得很好(同样，只要我们在一个可以存在dlsym的系统中)。也许有一些编译器会对这种情况发出警告，它们只能通过使用欺骗者双指针的伎俩才能被骗到沉默。|1478137|另见Casting+when+using+dlsym()。|1478138|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/31526876/casting-when-using-dlsym^0|0|0|6|G|7|17|1|0|0|0|0|0|G|6|25|6|2E|7|0|0|5|1Q|6|2G|6|2V|6|0|0|0|D|5|K|6|S|6|11|I|0|F|6|0|0|0|0|4|5|11|6|1E|6|1T|7|2R|4|2W|7|3C|1|3S|6|43|5|0|0|S|1|1E|4|0|18|6|0|W|5|1C|5|2D|5|0|G|5|0|0|17|5|0|2|Q|0|0^^$0|@$1|2|3|4|5|6|7|20|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|21|8|@$D|22|E|23|F|G]|$D|24|E|25|F|G]|$D|26|E|27|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|28|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|29|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|2A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|2B|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|2C|8|@$D|2D|E|2E|F|G]|$D|2F|E|2G|F|G]|$D|2H|E|2I|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|2J|8|@$D|2K|E|2L|F|G]|$D|2M|E|2N|F|G]|$D|2O|E|2P|F|G]|$D|2Q|E|2R|F|G]]|9|@]|A|$]]|$1|W|3|X|5|6|7|2S|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|2T|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|2U|8|@$D|2V|E|2W|F|G]|$D|2X|E|2Y|F|G]|$D|2Z|E|30|F|G]|$D|31|E|32|F|G]]|9|@]|A|$]]|$1|12|3|13|5|6|7|33|8|@$D|34|E|35|F|G]]|9|@]|A|$]]|$1|14|3|15|5|L|7|36|8|@]|9|@]|A|$M|N]]|$1|16|3|17|5|6|7|37|8|@]|9|@]|A|$]]|$1|18|3|19|5|L|7|38|8|@]|9|@]|A|$M|N]]|$1|1A|3|1B|5|6|7|39|8|@$D|3A|E|3B|F|G]|$D|3C|E|3D|F|G]|$D|3E|E|3F|F|G]|$D|3G|E|3H|F|G]|$D|3I|E|3J|F|G]|$D|3K|E|3L|F|G]|$D|3M|E|3N|F|G]|$D|3O|E|3P|F|G]|$D|3Q|E|3R|F|G]]|9|@]|A|$]]|$1|1C|3|1D|5|L|7|3S|8|@]|9|@]|A|$M|N]]|$1|1E|3|1F|5|6|7|3T|8|@$D|3U|E|3V|F|G]|$D|3W|E|3X|F|G]]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|3Y|8|@$D|3Z|E|40|F|G]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|41|8|@$D|42|E|43|F|G]|$D|44|E|45|F|G]|$D|46|E|47|F|G]]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|48|8|@$D|49|E|4A|F|G]]|9|@]|A|$]]|$1|1M|3|1N|5|L|7|4B|8|@]|9|@]|A|$M|N]]|$1|1O|3|1P|5|6|7|4C|8|@$D|4D|E|4E|F|G]]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|4F|8|@]|9|@$D|4G|E|4H|1|4I]]|A|$]]|$1|1S|3|-4|5|6|7|4J|8|@]|9|@]|A|$]]]|1T|$1U|$5|1V|1W|1X|A|$1Y|1Z]]]]

Yup, that's a mouthful.

<code>cosine</code> is a function pointer. So <code>&amp;cosine</code> is a pointer to that pointer. And then when we slap a <code>*</code> in front of it, we're changing the original pointer, to make it point somewhere else.

It's sort of like this:

<pre><code>int i = 5;
int *ip = &amp;i;
*ip = 6; /* changes i to 6 */
</code></pre>

Or it's more like this:

<pre><code>char a[10], b[10];
char *p = a;
*(&amp;p) = b; /* changes p to point to b */
</code></pre>

But in your case it's even trickier, because <code>cosine</code> is a pointer to a function, not a pointer to data. Most of the time, function pointers point to functions you have defined in your program. But here, we're arranging to make <code>cosine</code> point to a dynamically-loaded function, loaded by the <code>dlsym()</code> function.

<code>dlsym</code> is super special because it can return pointers to data, as well as pointers to functions. So it's got an impossible-to-define return type. It's declared as returning <code>void *</code>, of course, because that's the "generic" pointer type in C. (Think <code>malloc</code>.) But in pure C, <code>void *</code> is a generic data pointer type; it's not guaranteed to be able to be used with function pointers.

The straightforward thing to do would be to just say

<pre><code>cosine = dlsym(handle, "cos");
</code></pre>

But a modern compiler will complain, because <code>dlsym</code> returns <code>void *</code>, and <code>cosine</code> has type <code>double (*)(double)</code> (that is, pointer to function taking double and returning double), and that's not a portable conversion.

So we go around the barn, and set <code>cosine</code>'s value indirectly, not by saying

<pre><code>cosine = something
</code></pre>

but rather by saying

<pre><code>*(&amp;cosine) = something
</code></pre>

But that's still no good in the <code>dlsym</code> case, because the types still don't match. We've got <code>void *</code> on the right, so we need <code>void *</code> on the left. And the solution is to take the address <code>&amp;cosine</code>, which is otherwise a pointer-to-pointer-to-function, and cast it to a pointer-to-pointer-to-<code>void</code>, or <code>void **</code>, so that when we slap a <code>*</code> in front of it we've got a <code>void *</code> again, which is a proper destination to assign <code>dlsym</code>'s return value to. So we end up with the line you were asking about:

<pre><code>* (void **) (&amp;cosine) = dlsym(handle, "cos");
</code></pre>

Now, it's important to note that we're on thin ice here. We've used the <code>&amp;</code> and the cast to get around the fact that assigning a pointer-to-<code>void</code> to a `pointer-to-function isn't strictly legal. In the process we've successfully silenced the compiler's warning that what we're doing isn't strictly legal. (Indeed, silencing the warning was precisely the original programmer's intent in employing this dodge.)

The potential problem is, what if data pointers and function pointers have different sizes or representations? This code goes to some length to treat a function pointer, <code>cosine</code>, as if it were a data pointer, jamming the bits of a data pointer into it. If, say, a data pointer were somehow bigger than a function pointer, this would have terrible effects. (And, before you ask "But how could a data pointer ever be bigger than a function pointer?", that's exactly how they were, for example, in the "compact" memory model, back in the days of MS-DOS programming.)

Normally, playing games like this to break the rules and shut off compiler warnings is a bad idea. In the case of <code>dlsym</code>, though, it's fine, I would say perfectly acceptable. <code>dlsym</code> can't exist on a system where function pointers are different from data pointers, so if you're using <code>dlsym</code> at all, you must be on a machine where all pointers are the same, and this code will work.

It's also worth asking, if we have to play games with casts when calling <code>dlsym</code>, why take the extra trip around the barm with the pointer-to-pointer? Why not just say

<pre><code>cosine = (double (*)(double))dlsym(handle, "cos");
</code></pre>

And the answer is, I don't know. I'm pretty sure this simpler cast will work just as well (again, as long as we're on a system where <code>dlsym</code> can exist at all). Perhaps there are compilers that warn about this case, that can only be tricked into silence by using the tricker, double-pointer trick.

See also <a href="https://stackoverflow.com/questions/31526876/casting-when-using-dlsym">Casting when using dlsym()</a> .

blocks|key|2263436|text|这是很恶心的东西。cosine是一个指向函数的指针，该函数接受double类型的参数并返回double。&cosine是该指针的地址。演员们说要假装那个地址是指针到指针到空的地址。强制转换前面的*是通常的取消引用操作符，因此结果是告诉编译器假装cosine的类型是void*，这样代码就可以将调用dlsym的返回值分配给cosine。好痛啊。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2263437|而且，只是为了好玩，一个void*和一个指针到函数一点关系都没有，这就是为什么代码必须经过所有的转换。C%2B%2B语言定义不能保证这是可行的。也就是说，结果是未定义的行为。|2263438|entityMap^0|9|6|V|6|19|6|1G|7|2P|1|3E|6|3O|5|44|5|4G|6|0|C|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|I|$]]

This is nasty stuff. <code>cosine</code> is a pointer to a function that takes an argument of type <code>double</code> and returns <code>double</code>. <code>&amp;cosine</code> is the address of that pointer. The cast says to pretend that that address is a pointer-to-pointer-to-void. The <code>*</code> in front of the cast is the usual dereference operator, so the result is to tell the compiler to pretend that the type of <code>cosine</code> is <code>void*</code>, so that the code can assign the return value from the call to <code>dlsym</code> to <code>cosine</code>. Phew; that hurts.

And, just for fun, a <code>void*</code> and a pointer-to-function are not at all related, which is why the code has to go through all that casting. The C++ language definition does not guarantee that this will work. I.e., the result is undefined behavior.

blocks|key|1478194|text|对于C，可以将指向void的指针转换为没有强制转换的对象的任何指针。但是，C标准并不保证可以将void+*转换为指向函数的指针--因为函数不是对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1478195|dlsym是POSIX函数；POSIX要求作为扩展，指向函数的指针必须可转换到void+*并再次返回。但是，C%2B%2B不允许在没有强制转换的情况下进行这种转换。|BOLD|1478196|无论如何，*(void+**)+(&cosine)+=+dlsym(handle,+"cos");强制转换意味着指向函数(双)返回双的指针的指针被转换为指向无效指针的指针，然后取消引用以获得void+*类型的lvalue，将dlsym的返回值赋给它。这是相当丑陋的，在需要强制转换的地方，应该以cosine+=+(double+(*)(double))dlsym(handle,+"cos")的形式编写。当涉及到C时，两者都是未定义的行为，但后者并不是那么黑暗的魔法。|1478197|entityMap^0|9|4|1B|6|0|0|5|13|6|1I|3|0|5|18|2N|6|2W|6|34|5|43|1D|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|L|$]]

For C, a pointer to <code>void</code> can be converted to any pointer to an object without a cast. However, the C standard does not guarantee that <code>void *</code> can be converted to a pointer to a function - at all, since functions are not objects.

The <code>dlsym</code> is a POSIX function; and POSIX requires that as an extension, a pointer to a function must be convertable to <code>void *</code> and back again. However C++ wouldn't allow such a conversion without a cast.

In any case the <code>*(void **) (&amp;cosine) = dlsym(handle, "cos");</code> cast means that the pointer to the pointer to a function (double) returning double is cast as pointer to pointer to void, then dereferenced to get a <code>lvalue</code> of type <code>void *</code>, to which the return value of <code>dlsym</code> is assigned to. This is rather ugly, and should be better written as <code>cosine = (double (*)(double))dlsym(handle, "cos")</code> wherever a cast is required. Both are undefined behaviour when it comes to C, but the latter is not as much dark magic.

Found this code example 

<pre><code>void *handle;
double (*cosine)(double);
handle = dlopen("libm.so", RTLD_LAZY);
*(void **) (&amp;cosine) = dlsym(handle, "cos");
</code></pre>

I use rightmost-to-left reading rule to parse the variable's type:

<pre><code>double (*cosine)(double);
</code></pre>

Here I write left-to-right but move LTR: "cosine" -> "*" -> "is a pointer"
then "(" we go outside the innermost () scope -> "(double)" -> "to function taking one double" -> and returning leftmost "double"

but what the hell is THIS? I even don't know where to start the parse from) is "&amp;cosine" a address or reference? what does the (void **) mean? why it has leftmost "*" outside??? is it dereference or type?

<pre><code>*(void **) (&amp;cosine)
</code></pre>

How to parse *(void **) (&cosine) if cosine is a fptr

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

找到此代码示例void *handle;double (*cosine)(double);handle = dlopen("libm.so", RTLD_LAZY);*(void **) (&cosine) = dlsym(handle, "cos");我使用从右到左的读取规则来解析变量的类型：double (*cos...

问如果余弦是fptr，如何解析*(void **) (& cosine )
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果余弦是fptr，如何解析*(void **) (& cosine )EN