Какой вариант на ваш взгляд лучше для интерфейса?

Question

[Dyikot]

1.

class ISerializable
{
public:
	virtual ~ISerializable() = default;

	virtual void Serialize(const std::filesystem::path& path, 
						   const std::any& data) const = 0;
	virtual std::any Deserialize(const std::filesystem::path& path) const = 0;
};

2.

struct SerializationData {};

class ISerializable
{
public:
	virtual ~ISerializable() = default;

	virtual void Serialize(const std::filesystem::path& path,
						   const SerializationData* data) const = 0;	
	virtual std::unique_ptr<SerializationData> Deserialize(
		const std::filesystem::path& path) const = 0;
};

Comments

[Adamos]

std::any без причины - признак говнокода.
Ничего страшного в том, что в метод передадут нулевой указатель, еще нет.

[maaGames]

Почти на 100% уверен, что сериализация в "путь к файла" - плохая архитектура. Открывать/закрывать файл для каждого объекта? Уверен, туда надо stream использовать.

[GavriKos]

А это интерфейс для чего? Если для сериализатора - то тогда название странное. Если для данных - то почему данные передаются в метод?

[Dyikot]

maaGames, для stream нужен path. Вот я и передаю.

[maaGames]

Dyikot, не нужен. Ты собираешься открывать/закрывать файл для чтения/записи каждого объекта. А что делать с контейнерами собрался? А если дочерний класс вызывает функцию сериализации родительского класса? А если ты хочешь не в файл сохранить, а в строку(stringstream)? А как ты собираешься десериализировать два объекта, если в функцию не передаётся смещение, относительно которого объект записан, а открыть поток ты сможешь или в начале или в конце файла, раз смещения нет никакого?

[Dyikot]

maaGames, что мешает передать сразу два объекта и там уже как надо записать?

[maaGames]

Dyikot, Хорошо, не два, а контейнер из полутора тысяч объектов. Что мешает передать в функцию полторы тысячи разнотипных аргументов? У тебя в интерфейсе всего один передаётся.
И, как уже спросил GavriKos, с какой целью ты передаёшь данные объекта в функцию сериализации этого же объекта? Или сериализаторы будут внешними объектами? Чаще всего сериализуемый класс наследуется от такого интерфейса и объект сам себя сериализует. А зачем классу самому в себя передавать указатель на себя?

[Dyikot]

GavriKos, поправил название на "ISerializator".

[Dyikot]

maaGames, я исправил название класса на сериализатор. Ну можно наследоватся от SerializationData и сделать там необьходимые поля. Если это контейнер то с const &.

[maaGames]

Dyikot, Не, ты пока не понял про что говорю. Давай сериализовывать фрукты. У тебя есть классы Апельсин и Банан. Ты будешь их наследовать от ISerializator? Или у тебя в каждом из этих классов будет объект Данные, унаследованные от ISerializator? Вот у тебя есть массив из фруктов, как ты будешь этот массив сериализовывать? В цикле для каждого вызывать метод сериализации и на каждой итерации будет файл открывать, записыаться и закрываться. А как ты потом этот массив обратно прочитаешь, если на каждой итерации надо файл не просто открывать, но и в определённое смещение смещаться?

[Dyikot]

maaGames, Вот пример из сделанного проекта:

struct SettingsData: SerializationData
{
	size_t WindowWidth = 400;
	size_t WindowHeight = 800;
	size_t ActiveResolutionIndex = 1;
	size_t SoundEffectVolume = 100;
	size_t MusicVolume = 100;

	std::string ToString() const;

	void Convert(const std::vector<std::string>& values);
};

class SettinsDataSerializer: public ISerializable
{
public:
	static constexpr char Delimetr = '\n';
public:
	std::filesystem::path GetDefaultFilePath() const;

	std::filesystem::path GetFileExtension() const;

	void Serialize(const std::filesystem::path& path, 
				   const SerializationData* data) const override;

	void Serialize(const SerializationData* data) const;

	std::unique_ptr<SerializationData> Deserialize(
		const std::filesystem::path& path) const override;

	std::unique_ptr<SerializationData> Deserialize() const;
private:
	bool IsPathRelevant(const std::filesystem::path& path) const;
};

[maaGames]

Dyikot, Понятно, то есть у тебя не сам объект сериализируется, а есть отдельные внешние объекты.
Тогда остаётся только вопрос, как ты будешь делать десериализацию, если в файл сохранено более одного объекта? Вот у тебя есть путь к файлу. Ты можешь открыть файл либо в самом начале, либо в самом конце. Чтобы открыть и перейти на произвольное место в файле, тебе надо знать это произвольное смещение.

[Dyikot]

maaGames, буду решать проблемы по мере их поступления

[maaGames]

Dyikot, Тут прикол в чём, если ты допускаешь ошибку при проектировании интерфейса, то потом исправить уже нельзя и надо переписывать с нуля. Поэтому сперва надо продумать, что ты вообще елаешь и для чего. И как оно должно работать. Ты продумал запись/чтение только одного объекта на целый файл. Даже для двух объектов не продумал.
Если же у тебя всего один объект и есть, то нагромождение базовых классов и интерфейсов не нужны - это лишнее усложнение.

[Евгений Шатунов]

Dyikot, думаю, тебе уже понятно что никакой из обоих твоих вариантов не лучше. Потому что они оба одинаковы и одинаково плохие.
Имена выбраны плохо. Из-за этого твой код вводит в заблуждение. std::any используешь не по назначению. SerializationData - это костыль как есть и назван отвратно. Какой шаблон проектирования применяешь - тебе и самому не ясно. А применяешь ты его не по месту и полностью неправильно.
Только не думай что для тебя лично ситуация сейчас сложилась плохо. Извлекай опыт и становись грамотнее.
Ответ на твой вопрос: оба варианта - дно. А вопроса "как надо" от тебя не было. Поэтому качественных вариантов не предлагаю.
В сети просто море документов про сериалиацию. Мне этого хватило для выработки своей системы ценностей. Тебе тоже должно хватить. Но если задашь правильный вопрос, я на него отвечу.

[Dyikot]

Евгений Шатунов, maaGames, Я немного изменил. Надеюсь стало чуть лучше. Или все еще не очень? Можно еще добавить варианты передачи массива(наверно std::span) IStringConvertable объектов с дополнительным параметром в качестве разделителя.

ISerializer

class IStringConvertable
{
public:
	virtual ~IStringConvertable() = default;

	virtual std::string Convert() const = 0;
	virtual void ConvertBack(const std::string& data) = 0;
};

class ISerializer
{
public:
	virtual ~ISerializer() = default;

	virtual void Serialize(const std::filesystem::path& path,
						   const IStringConvertable& data) const = 0;
	virtual void Deserialize(const std::filesystem::path& path,
							 IStringConvertable& data) const = 0;
};

class Serializer: public ISerializer
{
public:
	void Serialize(const std::filesystem::path& path, 
				   const IStringConvertable& data) const override;
	void Deserialize(const std::filesystem::path& path, 
					 IStringConvertable& data) const override;

	template<typename T> requires std::derived_from<T, IStringConvertable>
	T Deserialize(const std::filesystem::path& path) const
	{
		T data = {};
		Deserialize(path, data);
		return data;
	}
};

void Serializer::Serialize(const std::filesystem::path& path,
						   const IStringConvertable& data) const
{
	if(std::ofstream stream(path); stream.is_open())
	{
		stream << data.Convert();
	}
}

void Serializer::Deserialize(const std::filesystem::path& path,
							 IStringConvertable& data) const
{
	if(std::ifstream stream(path); stream.is_open())
	{
		std::string buffer;
		stream >> buffer;
		data.ConvertBack(buffer);
	}
}

UPD: Добавил еще

IRangeSerializer

class IRangeSerializer
{
public:
	virtual ~IRangeSerializer() = default;

	virtual void Serialize(const std::filesystem::path& path,
						   const std::span<IStringConvertable*> range,
						   const std::string& delimetr) const = 0;
	virtual void Deserialize(const std::filesystem::path& path,
							 std::span<IStringConvertable*> range,
							 const std::string& delimetr) const = 0;
};

[Евгений Шатунов]

Dyikot, не-не. Ты на месте топчешься.
У тебя в чем проблема же? Тебе maaGames все очень хорошо описал. Ты в сокет как будешь читать и писать? А в буфер свободной памяти?
Первое дело - это объект, в который будет выполняться сериализация и из которого будут браться данные для десериализации. Это - шаблон потока (stream).
Второе - это формат сериализации. Тебе требуется во всех деталях понять шаблон посетителя (visitor).
Третье - это пейлоад, т.е. сериализуемый объект и цель десериализации. Для него есть шаблон сериализуемого (serializable).

const std::string& delimetr - зачем эту сугубо приватную тонкость формата знать внешнему коду?
Пока в коде у тебя видно что ты не совсем представляешь себе как все должно работать. Тебе не хватает структуры в голове сперва, поэтому код выглядит рваным.