SVektor<double> a = SVektor<double>(2);
	a(0) = 1;
	a(1) = 2;
	std::cout << a << std::endl;
	SVektor<double> b = a + 7.1; // nicht definiert

SVektor.t

template <class Tal>
class SVektor :
	public Vektor<Tal> {
public:
	SVektor(){
	};
	SVektor(int pDim){ dim = pDim; a = new Tal[dim];
	};
	~SVektor(){
		std::cout << "Destruktor SVektor" << std::endl;
	}
	SVektor operator+(SVektor const &b){
		SVektor c = SVektor(dim); //dim== fehlt 
		for (int i = 0; i < dim; i++){
			c.a[i] = a[i] + b.a[i]; // wesentlich schneller als operator()(i) + b(i);
		}
		return c;
	}
int dim;
Tal *a;
}

Wenn das Programm so ausgeführt wird, dann wird ein SVektor erstellt und die Dimension auf 7 gesetzt. Danach wird die Addition.
Meine Vermutung ist dass ein SVektor Objekt mit dem KonstruktorSVektor(7) ausgeführt wird. Wenn ich versuche einen Operator dementsprechend zu definieren wird trotzdem der Konstruktor ausgeführt.

template<typename Tal>
SVektor<Tal>& operator+ (SVektor<Tal> &l, double &r){
	SVektor c = SVektor(l.dim)
	for (int i = 0; i < dim; i++){
		c.a[i] = l.a[i] + r;
	}
	return c;
}

Was kann ich machen?

Danke wie immer im voraus

Nerva

mach den Konstruktor explizit.

sondern nur die Addition eines Vektors.

Ja, aber du kannst ja auch einen int in einen deiner SVektor s konvertieren. Du hast einen Konvertierungskonstruktor definiert:

SVektor(int pDim){ dim = pDim; a = new Tal[dim]; };

Stelle das Schlüsselwort explicit voran um eine solche implizite Konvertierung zu vermeiden, ganz wie bei einem der Konstruktoren von std::vector .

explicit SVektor(int pDim){ dim = pDim; a = new Tal[dim]; };

Dass du das ganze falsch und äußerst unschön gelöst hast muss ich dir nicht sagen, dass macht jemand anders. :p
Edit: Mache dich wenigstens mit std::unique_ptr vertraut.

Wenn ich versuche einen Operator dementsprechend zu definieren wird trotzdem der Konstruktor ausgeführt.

Das liegt daran dass du rvalues* nicht an non-const lvalue-Referenzen binden kannst. Wenn du das Ampersand entfernst, sollte es klappen.

SVektor<Tal> operator+ (SVektor<Tal> l, double r)

Übrigens gibst du in deinem Schnipsel eine Referenz auf ein funktionslokales Objekt (nämlich c ) zurück; solche nennt man hängende Referenzen (engl. dangling references), da sie nicht mehr auf ein existierendes Objekt verweisen. Ein Compiler dürfte dich hier mit entsprechenden Einstellungen auch warnen.

* Hier ist die Wertkategorie des Literals 7.1 ein prvalue.

Edit: Mist, zu spät.

unique_ptr kommen in Kapitel 20.3 und eine bessere Lösung gegen die hängenden Zeiger und dem kompletten Kopieren des objektes wurde auch schon in dem Buch (Der C++ Programmierer angedeutet) dauert leider alles noch bisschen bis ich so weit bin

Um drei Vektoren zu orthogonalisieren werden zB im Moment 24 Vektoren erzeugt. Soweit ich weiß lässt sich das auf 3 Input-Vektoren, 3 Output-Vektoren und einen Temporären Vektor beschränken