PROSAGA码农传奇-C/C++-可以使用指向结构成员的指针来访问同一结构的另一个成员吗？

0# 一只特立独行的猪 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <H2>
    memcpy呼叫做什么
  </H2>
  <P>
    这个问题很糟糕。让我们首先看看代码：
  </p>
   <pre>
    <code>
      char repr[offsetof(struct first_member_padded_t, b)] = //some value
memcpy(repr, &a, sizeof(a));
memcpy(&(s.a), repr, sizeof(repr));

</code>
  </pre>
  <P>
    首先要注意的是
     <code>
      repr
    </code>
     已初始化，因此其中的所有元素都是给定的值。
  </p>
  <P>
    首先
     <code>
      memcpy
    </code>
     是很好的复制它的字节
     <code>
      a
    </code>
     成
     <code>
      repr
    </code>
    。
  </p>
  <P>
    如果是第二个
     <code>
      memcpy
    </code>
     是
     <code>
      memcpy(&s, repr, sizeof repr);
    </code>
    ，它会从中复制字节
     <code>
      repr
    </code>
     成
     <code>
      s
    </code>
    。这会写入字节
     <code>
      s.a
    </code>
     并且，由于的大小
     <code>
      repr
    </code>
    ，进入任何填充之间
     <code>
      s.a
    </code>
     和
     <code>
      s.b
    </code>
    。根据标准的其他部分，允许访问对象的字节（并且访问权限意味着读取和写入，每3.1 1）。所以这个副本进入
     <code>
      s
    </code>
     很好，它会导致
     <code>
      s.a
    </code>
     具有相同的价值
     <code>
      a
    </code>
     具有。
  </p>
  <P>
    然而
     <code>
      memcpy
    </code>
     使用
     <code>
      &(s.a)
    </code>
     而不是
     <code>
      &s
    </code>
    。它使用的地址
     <code>
      s.a
    </code>
     而不是地址
     <code>
      s
    </code>
    。我们知道转换
     <code>
      s.a
    </code>
     指向字符类型的指针将允许我们访问字节
     <code>
      s.a
    </code>
     （6.5 7及以上）（并将其传递给
     <code>
      memcpy
    </code>
     具有与这种转换相同的效果，如
     <code>
      memcpy
    </code>
     指定具有复制字节的效果，但不清楚它允许我们访问其他字节
     <code>
      s
    </code>
    。换句话说，我们有一个问题，我们是否可以使用
     <code>
      &s.a
    </code>
     访问除了那些以外的字节
     <code>
      s.a
    </code>
    。
  </p>
  <P>
    6.7.2.1 15告诉我们，如果指向结构的第一个成员的指针被适当地转换，结果将指向结构。所以，如果我们转换
     <code>
      &s.a
    </code>
     到指针
     <code>
      struct first_member_padding_t
    </code>
    ，它会指向
     <code>
      s
    </code>
    ，我们当然可以使用指针
     <code>
      s
    </code>
     访问中的所有字节
     <code>
      s
    </code>
    。因此，这也将很好地定义：
  </p>
   <pre>
    <code>
      memcpy((struct first_member_padding t *) &s.a, repr, sizeof repr);

</code>
  </pre>
  <P>
    然而，
     <code>
      memcpy(&s.a, repr, sizeof repr);
    </code>
     只有转换
     <code>
      &s.a
    </code>
     至
     <code>
      void *
    </code>
     （因为
     <code>
      memcpy
    </code>
     宣布采取
     <code>
      void *
    </code>
    所以
     <code>
      &s.a
    </code>
     在函数调用期间自动转换）而不是指向结构类型的指针。这是一个合适的转换吗？请注意，如果我们这样做
     <code>
      memcpy(&s, repr, sizeof repr);
    </code>
    ，它会转换
     <code>
      &s
    </code>
     至
     <code>
      void *
    </code>
    。 6.2.5 28告诉我们指针
     <code>
      void
    </code>
     具有与指向字符类型的指针相同的表示形式。请考虑以下两个陈述：
  </p>
   <pre>
    <code>
      memcpy(&s.a, repr, sizeof repr);
memcpy(&s,   repr, sizeof repr);

</code>
  </pre>
  <P>
    这两个陈述都通过了
     <code>
      void *
    </code>
     至
     <code>
      memcpy
    </code>
    ，那两个
     <code>
      void *
    </code>
     具有相同的表示并指向相同的字节。现在，我们可以迂腐而严格地解释标准，以便它们不同，因为后者可用于访问所有字节
     <code>
      s
    </code>
     前者可能没有。然后奇怪的是，我们有两个必然相同的指针，表现不同。
  </p>
  <P>
    从理论上讲，这种对C标准的严格解释似乎是可能的，指针之间的差异可能在优化过程中产生而不是在实际实现中
     <code>
      memcpy
    </code>
    但是我不知道有任何编译器会这样做。请注意，这种解释与标准的第6.2节不一致，后者告诉我们类型和表示。解释标准，以便
     <code>
      (void *) &s.a
    </code>
     和
     <code>
      (void *) &s
    </code>
     行为不同意味着具有相同值和类型的两个事物可能表现不同，这意味着一个值由超过其值和类型的东西组成，这似乎不是6.2或标准的意图。
  </p>
  <H2>
    型双关
  </H2>
  <P>
    问题是：
  </p>
  <BLOCKQUOTE>
    <P>
      我试图理解当将值存储到结构或联合的成员中时，类型惩罚是如何工作的。
    </p>
  </BLOCKQUOTE>
  <P>
    这不是类型惩罚，因为这个术语是常用的。从技术上讲，代码可以访问
     <code>
      s.a
    </code>
     使用与其定义不同类型的左值（因为它使用
     <code>
      memcpy
    </code>
    ，定义为使用字符类型进行复制，而定义的类型是
     <code>
      int
    </code>
    ），但字节起源于
     <code>
      int
    </code>
     并且无需修改即可复制，这种复制对象字节的方式通常被认为是机械程序;它完成了一个副本而不是重新解释一个新类型的字节。类型 - 惩罚通常是指使用不同的左值来重新解释该值，例如写一个
     <code>
      unsigned int
    </code>
     和阅读
     <code>
      float
    </code>
    。
  </p>
  <P>
    无论如何，打字并不是问题的主题。
  </p>
  <H2>
    成员中的价值观
  </H2>
  <P>
    标题问：
  </p>
  <BLOCKQUOTE>
    <P>
      我们可以在结构或联盟成员中存储什么值？
    </p>
  </BLOCKQUOTE>
  <P>
    这个标题似乎与问题的内容有关。标题问题很容易回答：我们可以存储的值
    的<strong>
      在
    </强>
     成员是成员类型可以表示的那些值。但问题是继续探讨成员之间的填充。填充不会影响成员中的值。
  </p>
  <H2>
    填充需要未指定的值
  </H2>
  <P>
    问题引用了标准：
  </p>
  <BLOCKQUOTE>
    <P>
      当值存储在结构或联合类型的对象中（包括在成员对象中）时，对应于任何填充字节的对象表示的字节采用未指定的值。
    </p>
  </BLOCKQUOTE>
  <P>
    并说：
  </p>
  <BLOCKQUOTE>
    <P>
      所以我把它解释为好像我们有一个对象存储到一个成员中，使得对象的大小等于s
       <code>
        izeof(declared_type_of_the_member) + padding
      </code>
       与填充相关的字节将具有未指定的值
    </p>
  </BLOCKQUOTE>
  <P>
    标准中引用的文本表示，如果填充字节在
     <code>
      s
    </code>
     已设置为某些值，如同
     <code>
      memcpy
    </code>
    ，然后我们做
     <code>
      s.a = something;
    </code>
    ，然后不再需要填充字节来保存其先前的值。
  </p>
  <P>
    问题中的代码探讨了不同的情况。代码
     <code>
      memcpy(&(s.a), repr, sizeof(repr));
    </code>
     在6.2.6.1中意义上的结构成员中不存储值。它不存储在任何一个成员中
     <code>
      s.a
    </code>
     要么
     <code>
      s.b
    </code>
    。它正在复制字节，这与6.2.6.1中讨论的不同。
  </p>
  <P>
    6.2.6.1 6表示，例如，如果我们执行此代码：
  </p>
   <pre>
    <code>
      char repr[sizeof s] = { 0 };
memcpy(&s, repr, sizeof s); // Set all the bytes of s to known values.
s.a = 0; // Store a value in a member.
memcpy(repr, &s, sizeof s); // Get all the bytes of s to examine them.
for (size_t i = sizeof s.a; i < offsetof(struct first_member_padding_t, b); ++i)
    printf("Byte %zu = %d.\n", i, repr[i]);

</code>
  </pre>
  <P>
    那么填充的字节可能已经改变，所有零都不会被打印。
  </p>
</DIV>

1# 哈哈哈哈 | 2019-08-31 10-32

2# Moso31 | 2019-08-31 10-32