Как избавится от шаблона?

Question

[Drottarutarnum]

Есть базовый класс настройки IO
Я выкинул все лишние

class BaseIO {
public:
	template<typename TClass>
	static void AlternateInit(AlternateParameters val) {
		TClass io = { val.port, val.pin };
		io.SetAlternate(val.alternate);
		return io.SetParameters({ Mode::Alternate });
	}



	template<typename TClass>
	static void AnalogInit(AnalogParameters val) {
		TClass io = { val.port, val.pin };
		return io.SetParameters({ Mode::Analog, val.pull });
	}
};

FА где-то ниже есть такая конструкция

using IO = class IOPort;

class IOPort : public BaseIO {
};

Все это создано для того, чтобы можно было сделать некоторые конфигурации, где класс по сути должен родиться и умереть (не надо хранить его в памяти), в одну строку

Сейчас это делается ка-то так
IOPort::AlternateInit<IOPort>({ .... });

А хотелось бы что-то такое
IOPort::AlternateInit({ .... });

Конечно, можно определять AnalogInit и AlternateInit в каждом потомке, но они должны быть статик чтобы можно было писать одной строкой. И тут проблема, виртуальный метод не может быть статик и мне придется "доверится" что его напишут, что я не очень хочу

Есть ли более красивое решение чем сейчас у меня?

Comments

[xorknown]

Ну можете переложить это на плечи класса и использовать CRTP. Будет что-то подобное. Но вы лишаетесь общего базового предка. Лучше решить это архитектурным путем, потому что у вас наследник зависит от базового класса и обратно, циклические зависимости, вроде, не очень. Почему просто не сделать это обычными функциями, раз они не работают с самой BaseIO?

template<typename TClass>
class BaseIO {
public:  
  static void AlternateInit(AlternateParameters val) {
    TClass io = { val.port, val.pin };
    io.SetAlternate(val.alternate);
    return io.SetParameters({ Mode::Alternate });
  }

  static void AnalogInit(AnalogParameters val) {
    TClass io = { val.port, val.pin };
    return io.SetParameters({ Mode::Analog, val.pull });
  }
};

class IOPort : public BaseIO<IOPort> {
};

IOPort::AlternateInit({ .... });
vs
AlternateInit<IOPort>({ .... });

[Bladegreat]

Проблему общего класса можно решить добавлением еще одного уровня абстрации.

class BaseIO {
public:  
  ...
};

tamplate <class TClass>
class InitIO : public BaseIO
{
  static void AlternateInit(AlternateParameters val) {
    TClass io = { val.port, val.pin };
    io.SetAlternate(val.alternate);
    return io.SetParameters({ Mode::Alternate });
  }

  static void AnalogInit(AnalogParameters val) {
    TClass io = { val.port, val.pin };
    return io.SetParameters({ Mode::Analog, val.pull });
  }
}

class IOPort : public InitIO<IOPort> {
};

IOPort::AlternateInit({ .... });
vs
AlternateInit<IOPort>({ .... });

Думаю также можно просто переопределить функцию в производном классе.

class IOPort : public BaseIO 
{
public:
    static void AnalogInit(AlternateParameters val)
    {
        BaseIO::AnalogInit<IOPort>(val);
    }
}; 

IOPort::AnalogInit(...);