Сделать взаимозаменяемые типы классов только с помощью приведения указателя, без необходимости выделения каких-либо новых объектов?

Термин Accessor является бесполезным: вы ищете < em>Прокси.

Нет никаких причин для того, чтобы прокси не передавался по значению.

// Let us imagine that NodeBase is now called Node, since there is no inheritance

class AccessorFoo {
public:
    AccessorFoo(Node& n): node(n) {}

    int bar() const { return node->bar; }

private:
    std::reference_wrapper<Node> node;
};

И тогда вы можете свободно конвертировать один аксессор в другой... хотя это пахнет. Обычно сама цель наличия метода доступа состоит в том, чтобы каким-то образом ограничить доступ, поэтому волей-неволей приводить к другому методу доступа плохо. Однако можно поддерживать приведение к более узкому методу доступа.

Я считаю, что строгие правила псевдонимов запрещают то, что вы пытаетесь сделать.

Чтобы уточнить: строгое сглаживание не имеет ничего общего с совместимостью макета, типами POD или чем-то еще. Это связано с оптимизацией. И с тем, что язык явно запрещает вам делать.

Этот документ довольно хорошо обобщает это: http://dbp-consulting.com/StrictAliasing.pdf

Если я правильно вас понял, у вас:

• Класс NodeBase с сохранением состояния и настоящая рабочая лошадка системы;
• набор типов Accessor без сохранения состояния, которые предоставляют интерфейс для NodeBase; и
• класс Node<AccessorT>, обертывающий метод доступа, предположительно предоставляющий удобные функции.

Я предполагаю последний бит, потому что, если у вас нет типа-оболочки, который делает удобные вещи, то нет причин не делать типы Accessor вашими верхним уровнем, как вы предложили: передавать AccessorFoo и AccessorBar по значению. Тот факт, что они не являются одним и тем же объектом, совершенно спорен; если вы думаете о них как об указателях, то вы заметите, что &foo != &bar не более интересно, чем иметь NodeBase* p1 = new NodeBase; NodeBase* p2 = p1; и отметить, что, конечно же, &p1 != &p2.

Если вам действительно нужна оболочка Node<AccessorT> и вы хотите сделать ее стандартной компоновки, то я бы посоветовал вам использовать отсутствие состояния ваших типов Accessor в своих интересах. Если они являются просто контейнером функциональности без сохранения состояния (а так и должно быть; зачем еще вы могли бы свободно использовать их?), тогда вы можете сделать что-то вроде этого:

struct AccessorFoo {
    int getValue(NodeBase* n) { return n->getValueFoo(); }
};

struct AccessorBar {
    int getValue(NodeBase* n) { return n->getValueBar(); }
};

template <typename AccessorT>
class Node {
    NodeBase* m_node;

public:
    int getValue() {
        AccessorT accessor;
        return accessor.getValue(m_node);
    }
};

В этом случае вы можете добавить шаблонный оператор преобразования:

template <typename OtherT>
operator Node<OtherT>() {
    return Node<OtherT>(m_node);
}

И теперь у вас есть прямое преобразование значений между любым типом Node<AccessorT>, который вам нравится.

Если вы пойдете немного дальше, вы сделаете все методы Accessor типов статическими и получите признаки шаблона.

Между прочим, раздел стандарта C++, который вы процитировали, касается поведения reinterpret_cast<T*>(p) в случае, когда и исходный, и окончательный типы являются указателями на объекты стандартного макета, и в этом случае стандарт гарантирует, что вы получите тот же указатель, что и вы. от приведения к void*, а затем к окончательному типу. Вы по-прежнему не можете использовать объект как любой другой тип, кроме типа, для которого он был создан, без вызова неопределенного поведения.

struct myPOD {
   int data1;
   // ...
};

struct myPOD_extended1 : myPOD {
   int helper() { (*(myPOD*)this)->data1 = 6; };  // type myPOD referenced here
};
struct myPOD_extended2 : myPOD { 
   int helper() { data1 = 7; };                   // no syntactic ref to myPOD
};
struct myPOD_extended3 : myPOD {
   int helper() { (*(myPOD*)this)->data1 = 8; };  // type myPOD referenced here
};
void doit(myPOD *it)
{
    ((myPOD_extended1*)it)->helper();
    // ((myPOD_extended2*)it)->helper(); // uncomment -> program/compile undefined
    ((myPOD_extended3*)it)->helper();
}

int main(int,char**)
{
    myPOD a; a.data1=5; 
    doit(&a);

    std::cout<< a.data1 << '\n';
    return 0;
}

Я считаю, что это гарантированно работает во всех соответствующих компиляторах C++ и должно печатать 8. Раскомментируйте отмеченную строку, и все ставки сняты.

Оптимизатор может сократить поиск действительных ссылок с псевдонимами, проверяя список синтаксических типов, на которые фактически ссылается функция, по списку (в 3.10p10) синтаксических типов ссылок, которые требуются для получения правильных результатов, - и когда фактические («динамические ") известен тип объекта, этот список не включает доступ через ссылку на какой-либо производный тип. Таким образом, явное (и действительное) приведение вниз от this к myPOD* в helper()s помещает myPOD в список типов, на которые там синтаксически ссылаются, и оптимизатор должен рассматривать полученные ссылки как потенциальные допустимые ссылки на (другие имена, псевдонимы) объекта. a.