Обычный полиморфизм C, каламбур и строгий псевдоним. Насколько это законно?

Авторы Стандарта не считали необходимым указывать какие-либо средства, с помощью которых lvalue типа члена структуры или объединения может использоваться для доступа к базовой структуре или объединению. Способ написания N1570 6.5p7 даже не допускает someStruct.member = 4;, если member если символьного типа. Однако возможность применять оператор & к членам структуры и объединения не имеет никакого смысла, если только авторы Стандарта не ожидают, что полученные указатели будут полезны для чего-то. Учитывая сноску 88: «Цель этого списка состоит в том, чтобы указать те обстоятельства, при которых объект может иметь или не иметь псевдоним», наиболее логичным ожиданием является то, что он был предназначен только для применения в тех случаях, когда полезные сроки жизни lvalue будут перекрываться способами это будет связано с алиасингом.

Рассмотрим две функции в приведенном ниже коде:

struct s1 {int x;};
struct s2 {int x;};
union {struct s1 v1; struct s2 v2;} arr[10];

void test1(int i, int j)
{
  int result;
  { struct s1 *p1 = &arr[i].v1; result = p1->x; }
  if (result)
    { struct s2 *p2 = &arr[j].v2; p2->x = 2; }
  { struct s1 *p3 = &arr[i].v1; result = p3->x; }
  return result;
}

void test2(int i, int j)
{
  int result;
  struct s1 *p1 = &arr[i].v1; result = p1->x;
  if (result)
    { struct s2 *p2 = &arr[j].v2; p2->x = 2; }
  result = p1->x; }
  return result;
}

В test1, даже если i == j, доступ ко всем указателям, к которым когда-либо будет осуществлен доступ в течение времени жизни p1, будет осуществляться через p1, поэтому p1 не будет иметь никакого псевдонима. Аналогично с p2 и p3. Таким образом, поскольку нет псевдонимов, не должно быть проблем, если i==j. В test2, однако, если i==j, то создание p1 и последнее использование его для доступа к p1->x будет разделено другим действием, которое обращается к этому хранилищу с указателем, не производным от p1. Следовательно, если i==j, то доступ через p2 будет псевдонимом p1, и в соответствии с N1570 5.6p7 компилятор не потребуется, чтобы учесть эту возможность.

Если правила 5.6p7 применимы даже в случаях, которые не связаны с псевдонимом, то структуры и объединения будут бесполезны. Если они применимы только в случаях, когда действительно используется псевдоним, тогда можно было бы избавиться от множества ненужных сложностей, таких как правила «Эффективного типа». К сожалению, некоторые компиляторы, такие как gcc и clang, используют правила, чтобы оправдать «оптимизацию» первой вышеупомянутой функции, а затем предполагать, что им не нужно беспокоиться о результирующем псевдониме, который присутствует в их «оптимизированной» версии, но не входит в оригинал.

Ваш код будет нормально работать в любом компиляторе, авторы которого приложат все усилия, чтобы распознать производные lvalue. Однако и gcc, и clang испортят даже указанную выше функцию test1 (), если они не вызываются с флагом -fno-strict-aliasing. Учитывая, что Стандарт даже не допускает someStruct.member = 4;, я бы посоветовал вам воздержаться от вида псевдонимов, показанного в test2() выше, и не беспокоиться о компиляторах, которые даже не могут обрабатывать test1().

Я бы сказал, что это не строго, поскольку, если вы измените структуру «foo», структура «more foo» должна измениться вместе с ней. «foo» должно стать основой «more foo», это наследование, а не совсем полиморфизм. Но вы можете использовать указатели на функции, чтобы ввести полиморфизм, чтобы помочь с этими структурами.

Пример

#include <stdio.h>
#include <stdlib.h>

#define NEW(x) (x*)malloc(sizeof(x));

typedef struct 
{
    void(*printme)(void*);

    int _foo;
    int bar;

} foo;

typedef struct 
{
    // inherits foo
    foo base;
    int more;
} more_foo;


void foo_print(void *t)
{
    foo *this = (foo*)t;

    printf("[foo]\r\n\tfoo=%d\r\n\tbar=%d\r\n[/foo]\r\n", this->bar, this->_foo);
}

void more_foo_print(void *t)
{
    more_foo *this = t;

    printf("[more foo]\r\n");

    foo_print(&this->base);

    printf("\tmore=%d\r\n", this->more);

    printf("[/more foo]\r\n");
}


void foo_construct( foo *this, int foo, int bar )
{
    this->_foo = foo;
    this->bar = bar;

    this->printme = foo_print;
}

void more_foo_construct(more_foo *t, int _foo, int bar, int more)
{
    foo_construct((foo*)t, _foo, bar);

    t->more = more;

    // Overrides printme
    t->base.printme = more_foo_print;
}

more_foo *new_more_foo(int _foo, int bar, int more)
{
    more_foo * new_mf = NEW(more_foo);

    more_foo_construct(new_mf, _foo, bar, more);

    return new_mf;
}

foo *new_foo(int _foo, int bar)
{
    foo *new_f = NEW(foo);

    foo_construct(new_f, _foo, bar);

    return new_f;
}

int main(void)
{
    foo * mf = (foo*)new_more_foo(1, 2, 3);
    foo * f = new_foo(7,8);

    mf->printme(mf);

    f->printme(f);

    return 0;
}

• printme () переопределяется при создании "more foo". (полиморфизм)

• more_foo включает foo как базовую структуру (наследование), поэтому, когда структура «foo» изменяется, «more foo» изменяется вместе с ней (например, добавляются новые значения).

• more_foo можно преобразовать как «foo».