Указатели функций-членов и фантомные классы

Результат - просто неопределенное поведение. Например, я понимаю, что b = 2083899728 и d = -552766888.

Постоянная вещь, которой вы манипулируете, скорее всего, представляет собой целочисленное значение байтов в экземпляре карты A (потому что, если бы объект действительно был B, то это смещение, где был бы расположен элемент count.

В моей реализации stdlib первым членом map является функция сравнения, в данном случае экземпляр std::less<int>. Его размер равен 1, но после этого должны быть неиспользуемые байты заполнения, чтобы выровнять другие члены карты. То есть (по крайней мере) первые четыре байта этого экземпляра std::map содержат просто мусор, который ни для чего не используется (std::less не имеет элементов данных и не хранит состояние, он просто занимает место на карте ). Это объясняет, почему код не дает сбоев — он изменяет часть экземпляра карты, которая не влияет на работу карты.

Добавьте больше элементов данных в B перед count, и теперь count++ повлияет на важные части внутреннего представления карты, и вы можете получить сбой.

Ваше приведение в определении макроса HANDLER говорит компилятору: «Заткнись! Я знаю, что делаю!».

Поэтому компилятор затыкается.

У вас все еще есть Undefined Behavior, но одно свойство UB заключается в том, что в некоторых случаях он делает то, что вы наивно ожидаете, или то, что вы хотите.

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

Или, например, заставляет носовых демонов вылетать из вашего носа.

Ура и чт.

C-приведение позволяет вам избежать неприятностей со всеми видами ужасного поведения, но это не означает, что это нормально, поэтому просто не делайте этого.

Избавьтесь от своего макроса полностью и не кастуйте. Вероятно, вы можете использовать boost::function и boost::bind, чтобы получить поведение, которое вы действительно хотите.

Ваш код вызывает неопределенное поведение, пытаясь вызвать член класса B, используя объект класса A. Мы можем попытаться объяснить, как компилятор может прийти к поведению, которое вы наблюдали, но это не так. гарантировать, что вы получите такое же поведение, если вы что-либо измените (добавите/удалите элемент, измените настройки компилятора или используйте другой компилятор).

Приведением в макросе HANDLER вы говорите компилятору не предупреждать вас об использовании несовместимых типов, а просто делать то, что вы ему говорите. В этом случае вы говорите компилятору переинтерпретировать адрес члена любого класса как адрес члена класса A.

Когда вы позже попытаетесь вызвать, например, B::multiply, эта функция не будет знать, что она не работает с объектом класса B, поэтому она с радостью удалит байты aA, которые соответствовали бы члену B::count, если бы он был B объект. Скорее всего, эти байты на самом деле используются A::funcs, но, видимо, не для чего-то критичного. Если вы измените класс A на:

class A
{
    int count;
    std::map< int, MEMFUNC > funcs;
public:
    A() : count(0) { AddLocals(); }
    ~A() {}
    int CallLocal(int nID, int x, int y)
    {
        MEMFUNC f = funcs[nID];
        if (f) return (this->*f)(x, y);
        else return 0;
    }
    int Count()
    {
        return count;
    }
    void AddLocals()
    {
        Add(ADD, HANDLER(A, plus));
        Add(MUL, HANDLER(B, multiply));
        Add(SUB, HANDLER(A, subtract));
        Add(DIV, HANDLER(B, divide));
    }
    void Add(int nID, MEMFUNC f) { funcs[nID] = f; }
    int plus(int x, int y) { return x+y; }
    int subtract(int x, int y) { return x-y; }

};

тогда печать результата aA.Count() в разных местах может показать эффект.

Компилятор вызывает ожидаемую функцию, поскольку они не являются виртуальными функциями-членами.
Единственная разница между функциями-нечленами и не виртуальными функциями-членами заключается в скрытом аргументе, который передает указатель this в функцию-член. Итак, если вы возьмете адрес невиртуальной функции-члена, вы получите фиксированный адрес, уникальный для каждой функции.
Если бы функции-члены были виртуальными, то компилятор, скорее всего, вернул бы индекс в v-таблице в качестве указателя на эту функцию (вместе с некоторым указанием на то, что это смещение v-таблицы). Затем код может определить на месте вызова, может ли он сделать прямой вызов функции-члена или ему нужно сделать косвенный вызов через v-таблицу объекта, для которого вызывается функция.