#include <array>

template <size_t N>
using static_string = std::array<const char, N>;

template <size_t N, size_t ...Indexes>
constexpr static_string<N> make_static_string(const char (&str)[N], std::index_sequence<Indexes...>)
{
	return {str[Indexes] ..., '\0'};
}

template <size_t N, typename Indexes = std::make_index_sequence<N - 1>>
constexpr static_string<N> make_static_string(const char (&str)[N])
{
	return make_static_string(str, Indexes{});
}

template <typename T>
struct type_processor;

template <>
struct type_processor<float>
{
	template <size_t N>
	constexpr explicit type_processor(const static_string<N>& fmt, float fValue, char** ppOutBuff) : value(fValue), pp_out_buff(ppOutBuff)
	{
		// я не знаю (нет ни времени ни желания разбираться) как сделать проверку типа в форматной строке в compile time
		// после проверки форматная строка должна быть смещена на X позиций, чтобы следующая итерация проверяла следующий
		// тип в форматной строке

		static_assert(N >= 2 /*&& fmt[0] == '%' && fmt[1] == 'f'*/);
	}

	constexpr bool operator ()(void)
	{
		// TODO: конвертируем value в строку и записываем в pp_out_buff 
		
		// смещаем указатель pp_out_buff за блок записанных данных
		return true;
	}

	char**	pp_out_buff;
	float	value;
};

template <>
struct type_processor<int>
{
	template <size_t N>
	constexpr explicit type_processor(const static_string<N>& fmt, int nValue, char** ppOutBuff) :	value(nValue), pp_out_buff(ppOutBuff)
	{
		static_assert(N >= 2 /*&& fmt[0] == '%' && fmt[1] == 'f' && ppOutBuff != nullptr*/);
	}

	constexpr bool operator ()(void) 
	{
		// TODO: конвертируем value в строку и записываем в pp_out_buff
		
		// смещаем указатель pp_out_buff за блок записанных данных;
		return true;
	}

	char**	pp_out_buff;
	int		value;
};

template <>
struct type_processor<const char*>
{
	template <size_t N>
	constexpr explicit type_processor(const static_string<N>& fmt, const char* pValue, char** ppOutBuff) :	value(pValue), pp_out_buff(ppOutBuff)
	{
		static_assert(N >= 2 /*&& fmt[0] == '%' && fmt[1] == 'f' && ppOutBuff != nullptr*/);
	}

	constexpr bool operator ()(void) 
	{
		// TODO: копируем value в pp_out_buff 
		
		// смещаем указатель pp_out_buff за блок записанных данных
		return true;
	}

	char**		pp_out_buff;
	const char*	value;
};

template <size_t N, typename ...ArgsT>
constexpr bool my_printf(const static_string<N>& fmt, ArgsT ...vArgs)
{
	// TODO: организовать автоматический рассчет буфера под результирующую строку
	// 
	size_t szLength = 0;
	// (type_processor<ArgsT>(fmt, vArgs, (char**)&outBuff).calculate_size(szLength) && ...);

	char outBuff[256] = {0};
	return (type_processor<ArgsT>(fmt, vArgs, (char**)&outBuff)() && ...);
}

int main()
{
	constexpr auto fmt = make_static_string("%f %d %s");
	my_printf(fmt, 0.56f, 10, "some string");
	return 0;
}