Russian Qt Forum

Корректно ли данное безумие или есть лучше варианты? Есть сериализация из ini файла, нужно сделать для intptr_t p = &QVector<ZZ> zz; p->resize() зная только размер ZZ.

Поверьте - не нужно. Чем быстрее Вы перестанете мудрить и  спокойно, без всяких затей, распишете сериализацию/десериализацию для каждой структуры - тем лучше. Возня с такими автоматами/пулеметами себе дороже.

В файл сохранить ручками может и не слишком сложно. Хотя мой классик умеет структуры любой вложенности сохранять достаточно просто(еще бы TODO победить, в принципе уже понял как сделать, но пока нет времени и слишком мудрено получиться):


Тут еще преимущество в том что при наличие данных о структуре, я связываю форму со структурой (на каждый тип по строчке, как правило тип один bool) называю похоже переменные и поля в форме и они "сами" связываются :)

Можно ли создать структуру, чтобы можно было узнать имя класса наследников по указателю на базовую структуру? Структуры POD без QObject.
struct A1: public Base {}
Base *b(new A1);
qDebug() << b->getName(); // "A1"

А в чём проблема?
Пишем в базовой структуре char* name[20], в конструкторе инициализируем именем класса(наследника, или базового класса). И при любом обращении b->name или a->name получаем текущий тип.
PS Или у вас более глубокие планы?

А чтобы в конструкторе не писать? Ну или чтоб у каждого наследника конструктор сам создался с такой строчкой name = type_info(this).name(); ?

c++23 что то долго ждать(и то не факт). Вот думаю как над сериализацией надругаться еще, а то моя реализация не совсем красивая(хоть и работает). У каждого объекта есть поле QMap (описание его структуры) а хотелось бы в static вынести(один на все объекты).

http://en.cppreference.com/w/cpp/types/type_info/name

Не понял, зачем нужно узнавать размер ZZ, если его и так знает QVector и resize делает под количество элементов с учётом размера типа.

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


struct B{ int a, b; QString s;}
struct A{ QVector<B> b; }a;
void *p = (void*)a.b;

нужно сделать p->resize(size) зная содержимое структуры B {сдвиг 0 int "a", сдвиг 4 int "b", сlвиг 12 QString "s" }, но не имея её определения.

А чем плохо по образцу QDataStream? Напр

C++ (Qt)
MyStream stream;
..
stream << theB.a << theB.b << theB.s; // сериализуем объект класса B
...
stream << theA.b;   // сериализуем объект класса A
..
 

Да, придется оформить операторы для вектора - но 1 раз на все типы

C++ (Qt)
template <class T>
MyStream & operator << ( MyStream & stream, const QVector<T> & vec )
{
...
}

Что-то мешает сделать

C++ (Qt)
#include "B.h"

?

Делал, но для передачи по сети. Для настроек имен нет, соответственно ini файл не забить автоматически, и QWidget объекты не связать(bool <-> QCheckBox, int <-> QLIneEdit...)

Сериализатор универсальный на несколько проектов, сделан как библиотека.
Допустим включили хеадер, в коде что писать?

Сейчас пока реализована виртуальная функция которая вызывается при загрузке из файла:

И ASSERT в сериализаторе если забуду для какойнибудь структуры строчку написать(размер не совпадет у вектора с нужным значением).

Вы как-то "все о своем" (о девичьем  :)) и уловить Вашу мысль очень непросто
Ну вот в упор не вижу как это связано с моим вопросом  :)

Что же Вы так строки сравниваете? И type_info ни с чем разбираться не будет, оно возвращает инфу для того типа что дали (как sizeof), т.е. дали void *, ну для void* и вернет - и все. С тем же успехом можно написать type_info(void *)

Расскажите чего Вы хотите добиться - только плиз БЕЗ всяких подробностей Вашей системы сериализации, которая уже успела вырасти в изрядного монстра :). Т.е. исходная задача - и все. У меня стойкое впечатление что рулите куда-то явно "не туда" (может я и ошибаюсь)

Что-то это мне напоминает :).


Неужто не можете ответить на основе тех данных, что уже есть (как обычно, в первом посте)?  ;)

Такими преобразованиями и с void * в параметрах функций вы убиваете всю информацию о типе в compile-time. Что после этого вы хотите от компилятора? :) Не издевайтесь над ним и он вам поможет.


Если функция может работать с "любым типом", попробуйте std::any (http://en.cppreference.com/w/cpp/utility/any), там эта type_info и есть. Только надолго ли пользователей этой библиотеки сериализации хватит, чтобы лестницы из else if(type_info) строить :).

QDatastream упаковывает данные в бинарный формат. Нужна информация о именах.
сериализацию. Желательно попроще, в принципе возможно надо было protobuf использовать.
В моей реализации уже все работает и пользоваться классом удобно, кроме необходимости ручного изменения размера вектора.
как бы сделать function(int size_of_struct, int size, void *p) { (QVector<size_of_struct>*)p->resize(size); }

Вы осознаёте, что с таким вызовом resize происходит вызов конструкторов не совсем того типа (точнее не вызов нужных), под который предназначен контейнер?
Когда-нибудь это повернётся в часы потраченные на отладку.

Если возникает необходимость в таком (грязном) хаке - значит что-то не так. И надо думать не о том как "дохакать", а о том как сделать правильно, естественно

POD дата, все равно из ini файла все перезатирается.

Ну поэтому я его и не сделал. Виртуальная функция с ручным изменением размера вектора.
А проблема одна, отсутствие в c++ рефлексии. Есть конечно protobuf...

Для организации вменяемой системы сериализации предлагаю посмотреть в сторону boost.

Или можно свести все, например, к такому

Объявление типа

C++ (Qt)
struct SimpleStruct
{
    int m_int;
    double m_double1;
    double m_double2; // например, добавлен при доработке позднее
};
 

Отдельное описание сериализации/десериализации

C++ (Qt)
// перечень версий сериализации (если их требуется вести)
// по умолчанию используется последняя
SERIALIZE_VERSIONS_BEGIN( SimpleStruct )
	SERIALIZE_VERSION( Version_1 )
	SERIALIZE_VERSION( Version_2 )
SERIALIZE_VERSIONS_END
 
// метод десериализации MyStruct для версии Version_1
// обеспечивает бинарную совместимость с более ранней реализацией
SERIALIZE_LOAD_BEGIN( SimpleStruct, Version_1 )
{
	archive
		.serialize( value.m_int )
		.serialize( value.m_double1 );
}
SERIALIZE_END
 
// метод сериализации/десериализации MyStruct для версии Version_2
// текущий актуальный метод сериализации/десериализации
SERIALIZE_BEGIN( SimpleStruct, Version_2 )
{
	archive
		.serialize( value.m_int )
		.serialize( value.m_double1 )
		.serialize( value.m_double2 );
}
SERIALIZE_END
 

Метод сериализации/десериализации единый SERIALIZE_BEGIN .. SERIALIZE_END, но если требуется учесть специфику, то можно использовать взамен пару SERIALIZE_LOAD_BEGIN .. SERIALIZE_END и SERIALIZE_SAVE_BEGIN .. SERIALIZE_END.

А использовать можно так

C++ (Qt)
// Примеры сериализации данных без использования версий
template < typename _Data >
void serializeData ( _Data & data )
{
	typedef _Data Data;
	// пример десериализации из std::cin
	// и сериализации в std::cout
	{
		typedef ::Serialize::Basic::OStreamArchive< std::ostream > StdOutArchive;
		typedef ::Serialize::Basic::IStreamArchive< std::istream > StdInArchive;
		Data in_data;
		StdInArchive( std::cin )
			>> in_data;
		StdOutArchive( std::cout )
			<< in_data;
	}
	// пример сериализации в QDebug
	{
		typedef ::Serialize::Basic::OStreamArchive< QDebug > QDebugArchive;
		QDebug stream = qDebug();
		QDebugArchive archive( stream );
		archive
			<< data;
	}
	// и сериализации в файл с помощью QDataStream
	{
		typedef ::Serialize::Basic::OStreamArchive< QDataStream > QDataOutArchive;
		typedef ::Serialize::Basic::IStreamArchive< QDataStream > QDataInArchive;
		QFile file( "test.bin" );
		file.open( QFile::WriteOnly );
		QDataStream out_stream( &file );
		QDataOutArchive out_archive( out_stream );
		out_archive
			<< data;
		file.close();
		file.open( QFile::ReadOnly );
		QDataStream in_stream( &file );
		QDataInArchive in_archive( in_stream );
		_Data in_data;
		in_archive
			>> in_data;
		file.close();
	}
}
int main ( int, char ** )
{
	SimpleStruct my_struct;
	serializeData( my_struct );
	return 0;
}
 

Реализация пока что проприентарная, полный код выложить не могу, только идеи).

Может и так, но перед тем как куда-то смотреть - неплохо бы понять "где проблема". Собсно сериализация - работа "не бей лежачего", проходит любая. Только не нужно впадать в манечку "схлопывания", тупое copy/paste здесь часто оказывается лучшим. Да, может и придется написать сотни (тысячи) строк вместо компактного дустовского кода - зато не будет никаких хитросплетений, "отображений" и.т.п. в которые надо мучительно вникать. Что происходит у ТС мы вряд ли узнаем, но впечатление такое что создана "своя система" c  которой теперь приходится постоянно париться. Да-да, "все работает", но только тут одна  противная мелочь, вот подправить ее - и все! Увы, эти мелочи не кончатся никогда.

И кстати. Не раз (и не 2) я полагал примерно так
И всякий раз получал за это  :)