Problem mit Templates und double

Warum geht folgender Quellcode nicht?

//header.h
#include <iostream>

namespace Rechner
{
	template <typename T, T A, T B> class Addition
	{
		public:
	    	T operator()(){return A+B;}     
	};

	class Double 
	{
    	private:
         	double value;
     	public:
          	Double(float f);
           	Double(double f);
            Double(int f);
         	Double(const Double& other);

           	Double operator+=(float f);
           	Double operator+=(double f);
           	Double operator+=(int f);
           	Double operator+=(Double f);

           	Double operator-=(float f);
           	Double operator-=(double f);
           	Double operator-=(int f);
           	Double operator-=(Double f);

           	Double operator/=(float f);
           	Double operator/=(double f);
           	Double operator/=(int f);
           	Double operator/=(Double f);

           	Double operator*=(float f);
           	Double operator*=(double f);
           	Double operator*=(int f);
           	Double operator*=(Double f);

           	friend Double operator+(Double& s, float f);
           	friend Double operator+(Double& s, double f);
           	friend Double operator+(Double& s, int f);
           	friend Double operator+(Double& s, Double f);

           	friend Double operator-(Double& s, float f);
           	friend Double operator-(Double& s, double f);
           	friend Double operator-(Double& s, int f);
           	friend Double operator-(Double& s, Double f);

           	friend Double operator/(Double& s, float f);
           	friend Double operator/(Double& s, double f);
           	friend Double operator/(Double& s, int f);
           	friend Double operator/(Double& s, Double f); 

           	friend Double operator*(Double& s, float f);
           	friend Double operator*(Double& s, double f);
           	friend Double operator*(Double& s, int f);
           	friend Double operator*(Double& s, Double f);         	
 	};

	Double operator+(Double& s, float f){return s.value + f;}
	Double operator+(Double& s, double f){return s.value + f;}
	Double operator+(Double& s, int f){return s.value + f;}
	Double operator+(Double& s, Double f){return s.value + f.value;}

	Double operator-(Double& s, float f){return s.value - f;}
	Double operator-(Double& s, double f){return s.value - f;}
	Double operator-(Double& s, int f){return s.value - f;}
	Double operator-(Double& s, Double f){return s.value - f.value;}

	Double operator/(Double& s, float f){return s.value / f;}
	Double operator/(Double& s, double f){return s.value / f;}
	Double operator/(Double& s, int f){return s.value / f;}
	Double operator/(Double& s, Double f){return s.value / f.value;}

	Double operator*(Double& s, float f){return s.value * f;}
	Double operator*(Double& s, double f){return s.value * f;}
	Double operator*(Double& s, int f){return s.value * f;}
	Double operator*(Double& s, Double f){return s.value * f.value;}

	Double::Double(float f){value = f;}
	Double::Double(double f){value = f;}
	Double::Double(int f){value = f;}
	Double::Double(const Double& f){value = f.value;}
}

//main.cpp

#include "Rechner.hpp"

int main()
{
    std::cout << Rechner::Addition<Rechner::Double, 2, 3>()();
}

Ich weis das der Code nicht optimal ist, aber eigentlcih sollte er doch gehen.
Als Erklärung:
ICh wollte mit Templates son bisschen rumprobieren, in dem ich einen Taschenrechner programmiere. Damit die Leute auch mit Flieskommazahlen rechnen können musste ich eine alternative zu double bzw. float haben (siehe oben).
Doch GCC liefert den Fehler:

`class Rechner::Double' is not a valid type for a template constant parameter

Warum genau?

otze

der standard lässt nur integer werte als mögliche werte in nem template parameter zu.

dh: T darf in deinem fall nur(!) bool,char,short,wchar_t,int,long +unsigned versionen sein.
float und double werden schon nicht mehr unterstützt.

Und dass kann man auch nicht emulieren?

otze

schlecht bis gar nicht.

//edit an diesen und anderen problemen knabbere ich auch schon ne weile, alle workarounds sind irgendwie "unschön"

HumeSikkins

Wo ist hier der Vorteil zu std::plus?
Ich sehe nirgends einen Grund dafür, warum du hier non-type-Parameter verwenden möchtest.

Ich hab nie behaupted es gäbe einen Vorteil. Ich wollts halt bloß mal ausprobieren. Dann muss ich mich halt mit std::plus begnügen.