ist es möglich, mit std::enable_if Klassenattribute "Aus bzw Einschalten" und den dementsprechenden Konstruktor zu aktivieren?

Im folgenden "sinnbefreiten" Beispiel will ich zeigen was mir vorschwebt.
Vorweg: mir ist bewusst, dass ich dies mit mehreren "CalcAlgo" Klassen leicht hinbekommen würde. Mich interessiert aber ob so etwas mit enable_if bzw was anderem aus den Type Traits machbar ist.

#include <array>

template <typename T>
class IAlgo {
public:
	virtual ~IAlgo(){}
	virtual const T calc(T val) = 0;
};

template <typename T>
class Algo : public IAlgo<T> {
public:
	virtual ~Algo(){}
	virtual const T calc(T val) override final {return val*val;}
};

template <typename T>
class NoneAlgo : public IAlgo<T> {
public:
	virtual ~NoneAlgo(){}
	virtual const T calc(T val) override final {return val;}
};

template <typename T, unsigned int algos = 1>
class CalcAlgo {
private:
	/*
	 * Wie kann ich dieses Attribut deaktivieren wenn algos != 1 ist?
	 * Ist dies mit std::enable_if möglich?
	 */
	IAlgo<T> &algo;

	/*
	 * Wie kann ich dieses Attribut deaktivieren wenn algos < 2 ist?
	 * Ist dies mit std::enable_if möglich?
	 */
	//std::array<IAlgo<T>,algos> &algoArray;

public:
	/*
	 * Wie kann ich diesen Konstruktor verwenden wenn enableAlgo == false ist?
	 * Ist dies mit std::enable_if möglich?
	CalcAlgo() {
		static_assert(algos==0, "Der template Parameter algos muss 0 sein!");
	}
	 */

	CalcAlgo(IAlgo<T> &algo) : algo{algo} {
		static_assert(algos==1, "Der template Parameter algos muss 1 sein!");
	}

	/*
	CalcAlgo(std::array<IAlgo<T>,algos> &algos) : algos{algos} {
		static_assert(algos>1, "Der template Parameter algos muss größer 1 sein!");
	}
	 */

	virtual ~CalcAlgo(){}

	const T calc(T val) {
		T retVal{0};

		if (algos == 1) {
			retVal = algo.calc();
		}
		/* Kommentar kann entfernt werden wenn sich das Array aktiviern/deaktivieren lässt.
		else if (algos > 1) {
			for (auto algo : algoArray) {
				retVal += algo.calc();
			}
		}
		*/
		else {
			retVal = val;
		}
		return retVal;
	}
};

int main() {
	Algo<float> algo{};
	NoneAlgo<float> noneAlgo{};

	CalcAlgo<float, 1> calcWith{algo};
	CalcAlgo<float, 0> calcWithNone{noneAlgo}; //Dies funktioniert theoretisch, (vorrausgesetzt das array ist auskommentiert) ist aber sinnlos den noneAlgo zu übergeben. Deshalb wurde dies mit static_assert unterbunden.
	//CalcAlgo<float, 0> calcNone{}; //Dies funktioniert nicht, da das Attribut CalcAlgo::algo bzw das array initializiert werden muss.
}