blocks|key|125600|text|void+some_function+(bool+*+ptr)+{
++Thing+*+thing+=+(Thing*)(((char*)ptr)+-+offsetof(Thing,b));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|125601|我认为没有UB。|unstyled|125602|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>void some_function (bool * ptr) {
 Thing * thing = (Thing*)(((char*)ptr) - offsetof(Thing,b));
}
</code></pre>

I think there is no UB.

blocks|key|123568|text|如果您确定指针确实指向结构中的成员b，就像有人这样做一样|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|123569|Thing+t;
some_function(&t.b);|code-block|syntax|javascript|123570|然后，您应该能够使用offsetof宏来获取指向该结构的指针：|123571|std::size_t+offset+=+offsetof(Thing,+b);
Thing*+thing+=+reinterpret_cast<Thing*>(reinterpret_cast<char*>(ptr)+-+offset);|123572|请注意，如果指针ptr实际上没有指向Thing::b成员，那么如果您使用指针thing，上面的代码将导致未定义的行为。|123573|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/types/offsetof^0|H|1|0|0|A|8|A|8|0|0|0|8|3|I|8|12|5|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|M|3|N|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

If you are sure that the pointer is really pointing to the member <code>b</code> in the structure, like if someone did
<pre><code>Thing t;
some_function(&amp;t.b);
</code></pre>
Then you should be able to use the <a href="http://en.cppreference.com/w/cpp/types/offsetof" rel="nofollow noreferrer"><code>offsetof</code></a> macro to get a pointer to the structure:
<pre><code>std::size_t offset = offsetof(Thing, b);
Thing* thing = reinterpret_cast&lt;Thing*&gt;(reinterpret_cast&lt;char*&gt;(ptr) - offset);
</code></pre>
Note that if the pointer <code>ptr</code> doesn't actually point to the <code>Thing::b</code> member, then the above code will lead to undefined behavior if you use the pointer <code>thing</code>.

blocks|key|125627|text|X*+get_ptr(bool*+b){
++++static+typename+std::aligned_storage<sizeof(X),alignof(X)>::type+buffer;

++++X*+p=static_cast<X*>(static_cast<void*>(&buffer));
++++ptrdiff_t+const+offset=static_cast<char*>(static_cast<void*>(&p->b))-static_cast<char*>(static_cast<void*>(&buffer));
++++return+static_cast<X*>(static_cast<void*>(static_cast<char*>(static_cast<void*>(b))-offset));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|125628|首先，我们创建一些可以容纳X的静态存储。然后，我们获得缓冲区中可能存在的X对象的地址，以及该对象的b元素的地址。|unstyled|offset|length|style|CODE|125629|回溯到char*，我们可以获得缓冲区中bool的偏移量，然后我们可以使用它将指向实际bool的指针调整回指向包含X的指针。|125630|entityMap^0|0|D|1|10|1|1D|1|0|3|5|J|4|16|4|1K|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]|$G|S|H|T|I|J]|$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@$G|X|H|Y|I|J]|$G|Z|H|10|I|J]|$G|11|H|12|I|J]|$G|13|H|14|I|J]]|9|@]|A|$]]|$1|M|3|-4|5|F|7|15|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>X* get_ptr(bool* b){
 static typename std::aligned_storage&lt;sizeof(X),alignof(X)&gt;::type buffer;

 X* p=static_cast&lt;X*&gt;(static_cast&lt;void*&gt;(&amp;buffer));
 ptrdiff_t const offset=static_cast&lt;char*&gt;(static_cast&lt;void*&gt;(&amp;p-&gt;b))-static_cast&lt;char*&gt;(static_cast&lt;void*&gt;(&amp;buffer));
 return static_cast&lt;X*&gt;(static_cast&lt;void*&gt;(static_cast&lt;char*&gt;(static_cast&lt;void*&gt;(b))-offset));
}
</code></pre>

First, we create some static storage that could hold an <code>X</code>. Then we get the address of the <code>X</code> object that could exist in the buffer, and the address of the <code>b</code> element of that object.

Casting back to <code>char*</code>, we can thus get the offset of the <code>bool</code> within the buffer, which we can then use to adjust a pointer to a real <code>bool</code> back to a pointer to the containing <code>X</code>.

blocks|key|125670|text|我的建议来自于Offset+from+member+pointer+without+temporary+instance中的@Rod答案，以及Offset+of+pointer+to+member中类似的@0xbadf00d答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|125671|我开始想象一种偏移量的形式来驱动指向类数据成员的指针的实现，后来我所讨论的帖子和我所做的测试证实了这一点。|125672|我不是一个C%2B%2B实践者，所以很抱歉我的简短。|125673|#include+<iostream>
#include+<cstddef>

using+namespace+std;

struct+Thing+{
++++int+a;
++++bool+b;
};

template<class+T,+typename+U>
std::ptrdiff_t+member_offset(U+T::*+mem)
{
++++return+
++++(+&reinterpret_cast<const+char&>(+
++++++++reinterpret_cast<const+T*>(+1+)->*mem+)+
++++++-+reinterpret_cast<const+char*>(+1+)++++++);
}

template<class+T,+typename+U>
T*+get_T_from_data_member_pointer+(U+*+ptr,+U+T::*pU)+{
++return+reinterpret_cast<T*>+(
++++++reinterpret_cast<char*>(ptr)+
++++-+member_offset(pU));
}

int+main()
{

++++Thing+thing;
++++thing.b+=+false;

++++bool+*+ptr+=+&thing.b;
++++bool+Thing::*pb+=+&Thing::b;

++++std::cout+<<+"Thing+object+address+accessed+from+Thing+test+object+lvalue;+value+is:+"+
++++++++<<+&thing+<<+"!\n";+++++
++++std::cout+<<+"Thing+object+address+derived+from+pointer+to+class+member;+value+is:+"+
++++++++<<+get_T_from_data_member_pointer(ptr,+&Thing::b)+<<+"!\n";++++
}|code-block|syntax|javascript|125674|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/12141446/offset-from-member-pointer-without-temporary-instance|1|https://stackoverflow.com/a/5617632/781933^0|7|1H|0|1Z|R|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

My proposal is derived from the @Rod answer in <a href="https://stackoverflow.com/questions/12141446/offset-from-member-pointer-without-temporary-instance">Offset from member pointer without temporary instance</a>, and the similar @0xbadf00d's one in <a href="https://stackoverflow.com/a/5617632/781933">Offset of pointer to member</a>.

I started imagining a form of offset driving the implementation of a pointer to a class data member, later confirmed by the post in question and the tests i've made.

I'm not a C++ practitioner so sorry for the brevity.

<pre><code>#include &lt;iostream&gt;
#include &lt;cstddef&gt;

using namespace std;

struct Thing {
 int a;
 bool b;
};

template&lt;class T, typename U&gt;
std::ptrdiff_t member_offset(U T::* mem)
{
 return 
 ( &amp;reinterpret_cast&lt;const char&amp;&gt;( 
 reinterpret_cast&lt;const T*&gt;( 1 )-&gt;*mem ) 
 - reinterpret_cast&lt;const char*&gt;( 1 ) );
}

template&lt;class T, typename U&gt;
T* get_T_from_data_member_pointer (U * ptr, U T::*pU) {
 return reinterpret_cast&lt;T*&gt; (
 reinterpret_cast&lt;char*&gt;(ptr) 
 - member_offset(pU));
}

int main()
{

 Thing thing;
 thing.b = false;

 bool * ptr = &amp;thing.b;
 bool Thing::*pb = &amp;Thing::b;

 std::cout &lt;&lt; "Thing object address accessed from Thing test object lvalue; value is: " 
 &lt;&lt; &amp;thing &lt;&lt; "!\n"; 
 std::cout &lt;&lt; "Thing object address derived from pointer to class member; value is: " 
 &lt;&lt; get_T_from_data_member_pointer(ptr, &amp;Thing::b) &lt;&lt; "!\n"; 
}
</code></pre>

Suppose there's a structure

<pre><code>struct Thing {
 int a;
 bool b;
};
</code></pre>

and I get a pointer to member <code>b</code> of that structure, say as parameter of some function:

<pre><code>void some_function (bool * ptr) {
 Thing * thing = /* ?? */;
}
</code></pre>

How do I get a pointer to the containing object? Most importantly: Without violating some rule in the standard, that is I want standard defined behaviour, not undefined nor implementation defined behaviour.

As side note: I know that this circumvents type safety.

Get pointer to object from pointer to some member

假设有一个结构struct Thing {  int a;  bool b;};我得到了一个指向该结构的成员b的指针，比如说作为某个函数的参数：void some_function (bool * ptr) {  Thing * thing = /* ?? */;}如何获得指向包含对象的指针？最重要的是:在不违反标准中...

问从指向某个成员的指针获取指向对象的指针
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从指向某个成员的指针获取指向对象的指针EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从指向某个成员的指针获取指向对象的指针
EN