Доступ к массиву за пределами границ в C++ и reinterpret_cast

Таким образом, поведение reinterpret_cast является неопределенным, мы может ли reinterpret_cast быть char или unsigned char, мы никогда не сможем преобразовать из char или unsigned char, если мы сделаем:

Доступ к объекту через новый указатель или ссылку вызывает неопределенное поведение. Это известно как строгое правило алиасинга.

Так что да, это нарушение строгого правила псевдонимов.

Рассмотрим код:

struct {char x[4]; char a; } foo;

int work_with_foo(int i)
{
  foo.a = 1;
  foo.x[i]++;
  return foo.a;
}

Несмотря на то, что программа будет «владеть» хранилищем в foo.x+4, тот факт, что доступ через тип массива определен только для первых четырех элементов, позволит компилятору, среди прочего, заменить приведенный выше код любым из следующее:

int work_with_foo(int i)  { foo.a = 1; foo.x[i]++; return 1; }

int work_with_foo(int i)  { foo.x[i]++; foo.a = 1; return 1; }

Вышеупомянутые замены явно разрешены Стандартом. Менее ясно, какие альтернативные способы записи приращения заставят компилятор вести себя так, как будто он перезагружает foo.a. Например, я думаю, что код *(i+(char*)&foo)+=1; определял бы поведение, когда i равняется смещению foo.a, и я думаю, что то же самое должно быть верно и для *(i+(char*)&foo.x)+=1;, но я не уверен насчет *(i+foo.x)+=1; или *(i+(char*)foo.x)+=1;.

Этот старый хак C никогда не понадобится в C++.

рассмотреть возможность:

#include <cstdint>
#include <utility>
#include <memory>

template<std::size_t Size>
struct A {
  int header;
  unsigned char payload[Size];
};

struct polyheader
{
  struct concept
  {
    virtual int& header() = 0;
    virtual unsigned char* payload() = 0;
    virtual std::size_t size() const = 0;
    virtual ~concept() = default;  // not strictly necessary, but a reasonable precaution
  };

  template<std::size_t Size>
  struct model : concept
  {
    using a_type = A<Size>;
    model(a_type a) : _a(std::move(a)) {}
    int& header() override {
      return _a.header;
    }

    unsigned char* payload() override {
      return _a.payload;
    }

    std::size_t size() const override {
      return Size;
    }

    A<Size> _a;
  };

  int& header() { return _impl->header(); }
  unsigned char* payload() { return _impl->payload(); }
  std::size_t size() const { return _impl->size(); }

  template<std::size_t Size>
  polyheader(A<Size> a) 
    : _impl(std::make_unique<model<Size>>(std::move(a)))
    {}

  std::unique_ptr<concept> _impl;
};


int main()
{
  auto p1 = polyheader(A<40>());
  auto p2 = polyheader(A<80>());

}