Делаем POD классы подвижными

Question

Делаем POD классы подвижными

У меня есть класс POD, и я хочу сделать его подвижным для эффективности. Я храню все данные в std::array объект-член, и я делаю мои публичные переменные-члены ссылки на части этого std::array объект. Сделав это, теперь я могу переместить все данные, перемещая std::array экземпляр в конструкторе перемещения (я знаю, что он больше не является классом POD после написания конструкторов.).

Это хороший способ сделать это? Это действительно перемещает данные? Смотрите вывод кода ниже: после перемещения std::arrayЯ заметил, что оба объекта имеют одинаковые значения. Похоже, что он не двигается, но он копирует данные. В чем здесь проблема?

#include <array>

class MyPodClass
{
    private:
        typedef double  TYPE_x;
        typedef double  TYPE_y;
        typedef double  TYPE_z;
        typedef int     TYPE_p;
        typedef int     TYPE_r;
        typedef int     TYPE_s;
        typedef char    TYPE_k;
        typedef char    TYPE_l;
        typedef char    TYPE_m;
        typedef float   TYPE_a;
        typedef float   TYPE_b;
        typedef float   TYPE_c;

        enum TypeSizes
        {
            STARTING_POSITION_x = 0,
            STARTING_POSITION_y = STARTING_POSITION_x + sizeof(TYPE_x),
            STARTING_POSITION_z = STARTING_POSITION_y + sizeof(TYPE_y),
            STARTING_POSITION_p = STARTING_POSITION_z + sizeof(TYPE_z),
            STARTING_POSITION_r = STARTING_POSITION_p + sizeof(TYPE_p),
            STARTING_POSITION_s = STARTING_POSITION_r + sizeof(TYPE_r),
            STARTING_POSITION_k = STARTING_POSITION_s + sizeof(TYPE_s),
            STARTING_POSITION_l = STARTING_POSITION_k + sizeof(TYPE_k),
            STARTING_POSITION_m = STARTING_POSITION_l + sizeof(TYPE_l),
            STARTING_POSITION_a = STARTING_POSITION_m + sizeof(TYPE_m),
            STARTING_POSITION_b = STARTING_POSITION_a + sizeof(TYPE_a),
            STARTING_POSITION_c = STARTING_POSITION_b + sizeof(TYPE_b),
            END_POSITION        = STARTING_POSITION_c + sizeof(TYPE_c),
        };

        std::array<unsigned char, END_POSITION> MovableBulkData;

    public:
        MyPodClass()
            :   //x(*static_cast<TYPE_x*>(&MovableBulkData[STARTING_POSITION_x])),  // ERROR: Invalid type conversion. Why?
                x(*(TYPE_x*)(&MovableBulkData[STARTING_POSITION_x])),
                y(*(TYPE_y*)(&MovableBulkData[STARTING_POSITION_y])),
                z(*(TYPE_z*)(&MovableBulkData[STARTING_POSITION_z])),
                p(*(TYPE_p*)(&MovableBulkData[STARTING_POSITION_p])),
                r(*(TYPE_r*)(&MovableBulkData[STARTING_POSITION_r])),
                s(*(TYPE_s*)(&MovableBulkData[STARTING_POSITION_s])),
                k(*(TYPE_k*)(&MovableBulkData[STARTING_POSITION_k])),
                l(*(TYPE_l*)(&MovableBulkData[STARTING_POSITION_l])),
                m(*(TYPE_m*)(&MovableBulkData[STARTING_POSITION_m])),
                a(*(TYPE_a*)(&MovableBulkData[STARTING_POSITION_a])),
                b(*(TYPE_b*)(&MovableBulkData[STARTING_POSITION_b])),
                c(*(TYPE_c*)(&MovableBulkData[STARTING_POSITION_c]))
        {
        }

        MyPodClass(MyPodClass && RValue)
            :   MovableBulkData(std::move(RValue.MovableBulkData)),
                x(*(TYPE_x*)(&MovableBulkData[STARTING_POSITION_x])),
                y(*(TYPE_y*)(&MovableBulkData[STARTING_POSITION_y])),
                z(*(TYPE_z*)(&MovableBulkData[STARTING_POSITION_z])),
                p(*(TYPE_p*)(&MovableBulkData[STARTING_POSITION_p])),
                r(*(TYPE_r*)(&MovableBulkData[STARTING_POSITION_r])),
                s(*(TYPE_s*)(&MovableBulkData[STARTING_POSITION_s])),
                k(*(TYPE_k*)(&MovableBulkData[STARTING_POSITION_k])),
                l(*(TYPE_l*)(&MovableBulkData[STARTING_POSITION_l])),
                m(*(TYPE_m*)(&MovableBulkData[STARTING_POSITION_m])),
                a(*(TYPE_a*)(&MovableBulkData[STARTING_POSITION_a])),
                b(*(TYPE_b*)(&MovableBulkData[STARTING_POSITION_b])),
                c(*(TYPE_c*)(&MovableBulkData[STARTING_POSITION_c]))
        {
        }

        const MyPodClass & operator=(MyPodClass && RValue)
        {
            MovableBulkData = std::move(RValue.MovableBulkData);
            return *this;
        }

        TYPE_x & x;
        TYPE_y & y;
        TYPE_z & z;
        TYPE_p & p;
        TYPE_r & r;
        TYPE_s & s;
        TYPE_k & k;
        TYPE_l & l;
        TYPE_m & m;
        TYPE_a & a;
        TYPE_b & b;
        TYPE_c & c;
};

int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
{
    MyPodClass PodObject1, PodObject2;
    PodObject1.y = 3.4;
    PodObject1.s = 4;
    PodObject1.m = 'm';
    PodObject1.a = 2.3f;

    std::cout << "PodObject1.y = " << PodObject1.y << std::endl;
    std::cout << "PodObject1.s = " << PodObject1.s << std::endl;
    std::cout << "PodObject1.m = " << PodObject1.m << std::endl;
    std::cout << "PodObject1.a = " << PodObject1.a << std::endl << std::endl;

    std::cout << "PodObject2.y = " << PodObject2.y << std::endl;
    std::cout << "PodObject2.s = " << PodObject2.s << std::endl;
    std::cout << "PodObject2.m = " << PodObject2.m << std::endl;
    std::cout << "PodObject2.a = " << PodObject2.a << std::endl << std::endl;

    std::cout << "Moving PodObject1 to PodObject2..." << std::endl << std::endl;
    PodObject2 = std::move(PodObject1);

    std::cout << "PodObject1.y = " << PodObject1.y << std::endl;
    std::cout << "PodObject1.s = " << PodObject1.s << std::endl;
    std::cout << "PodObject1.m = " << PodObject1.m << std::endl;
    std::cout << "PodObject1.a = " << PodObject1.a << std::endl << std::endl;

    std::cout << "PodObject2.y = " << PodObject2.y << std::endl;
    std::cout << "PodObject2.s = " << PodObject2.s << std::endl;
    std::cout << "PodObject2.m = " << PodObject2.m << std::endl;
    std::cout << "PodObject2.a = " << PodObject2.a << std::endl << std::endl;

    std::cout << "Modifying PodObject1 and PodObject2..." << std::endl << std::endl;
    PodObject1.s = 5;
    PodObject2.m = 'n';

    std::cout << "PodObject1.y = " << PodObject1.y << std::endl;
    std::cout << "PodObject1.s = " << PodObject1.s << std::endl;
    std::cout << "PodObject1.m = " << PodObject1.m << std::endl;
    std::cout << "PodObject1.a = " << PodObject1.a << std::endl << std::endl;

    std::cout << "PodObject2.y = " << PodObject2.y << std::endl;
    std::cout << "PodObject2.s = " << PodObject2.s << std::endl;
    std::cout << "PodObject2.m = " << PodObject2.m << std::endl;
    std::cout << "PodObject2.a = " << PodObject2.a << std::endl << std::endl;

    std::cout << std::endl;
    _wsystem(L"timeout /t 60 /nobreak");
    return 0;
}

Выход:

PodObject1.y = 3.4
PodObject1.s = 4
PodObject1.m = m
PodObject1.a = 2.3

PodObject2.y = -9.25596e+61
PodObject2.s = -858993460
PodObject2.m = ╠
PodObject2.a = -1.07374e+08

Moving PodObject1 to PodObject2...

PodObject1.y = 3.4
PodObject1.s = 4
PodObject1.m = m
PodObject1.a = 2.3

PodObject2.y = 3.4
PodObject2.s = 4
PodObject2.m = m
PodObject2.a = 2.3

Modifying PodObject1 and PodObject2...

PodObject1.y = 3.4
PodObject1.s = 5
PodObject1.m = m
PodObject1.a = 2.3

PodObject2.y = 3.4
PodObject2.s = 4
PodObject2.m = n
PodObject2.a = 2.3

3

c++ move-semantics pod

Источник

user245376 22 дек '15 в 09:53

1 ответ

Другие вопросы по тегам c++ move-semantics pod

user4323 22 дек '15 в 10:00 2015-12-22 10:00 · Answer 1 · 2015-12-22 10:00

Это неправильное использование семантики перемещения. Так как ваш класс содержит ряд простых членов данных, таких как int а также float, действительно, двигаться нечего. Вам было бы лучше с memcpy(), что, вероятно, близко к тому, что ваш компилятор дает вам бесплатно, если вы просто напишите класс обычным, наивным способом, без std::array и нет указателя гимнастики.

Семантика перемещения была бы здесь полезной, если бы ваш класс содержал, например, std::string, потому что std:: string использует динамически распределенную память, которую можно "переместить" (читай: принято) в цель перемещения.

Вышеуказанное, конечно, означает, что вы можете "исправить" вашу проблему, динамически выделяя массив, что позволит вам его переместить. Но, в конце концов, это был бы барочный способ добиться эффекта использования тривиального класса POD без гимнастики и хранения его в std::unique_ptr, что, конечно, позволяет переместить семантику.