Klassen-Template Syntaxfehler: Bezeichner

[H.P.Wurst]

Hallo, folgender Code liefert den Fehler: Syntaxfehler: Bezeichner "mSize" in den Zeilen 7-9. Ich verstehe nicht ganz warum. Ich bin mir auch nicht ganz sicher, ob ich überhaupt ein Template brauche.

#pragma once
#include "Matrix.h"
#include "Vector.hpp"
template<int mSize> class LinearSystem
{
private:
	Vector* mpb(mSize);
	Vector* order(mSize);
	Matrix* mpA(mSize, mSize);
public:
	LinearSystem(Matrix A, Vector b);
	Vector Solve();
	friend void Pivot<mSize>(Matrix* A, Vector* b, Vector* x, Vector* order, int i);
};

Auch bei der "friend"-Deklaration bin ich mir nicht ganz sicher, ob sie richtig geschrieben ist.

[Bashar]

Vielleicht erklärst du mal, was du da eigentlich machen willst. Die Syntaxfehler kriegt man nämlich im Zweifel am leichtesten weg, indem man die betreffenden Codezeilen löscht...

[Ein ehemaliger Benutzer]

@H-P-Wurst sagte in Klassen-Template Syntaxfehler: Bezeichner:

Vector* mpb(mSize);

Was soll mSize denn mit dem Zeiger machen?

Fehlermeldung: Copy&Paste (in VS: aus dem Output Tab!)

[H.P.Wurst]

Also ich habe ziemlich viele Fehlermeldungen. Ich habe wohl irgendwas mit dem Template falsch gemacht.
Vector ist eine eigene Klasse und mSize soll die Größe des Vektors sein. Der Konstruktor von Vektor funktioniert aber, den habe ich schon ausprobiert.

[Ein ehemaliger Benutzer]

@H-P-Wurst sagte in Klassen-Template Syntaxfehler: Bezeichner:

Also ich habe ziemlich viele Fehlermeldungen. Ich habe wohl irgendwas mit dem Template falsch gemacht.
Vector ist eine eigene Klasse und mSize soll die Größe des Vektors sein. Der Konstruktor von Vektor funktioniert aber, den habe ich schon ausprobiert.

Da ist kein Vector!

[H.P.Wurst]

Hier der Code von Vector (kompliliert ohne Fehler):

#ifndef VECTORHEADERDEF
#define VECTORHEADERDEF

class Vector
{
private:
   double* mData; // data stored in vector
   int mSize; // size of vector
public:
   Vector(const Vector& otherVector);
   Vector(int size);
   ~Vector();
   int GetSize() const;
   double& operator[](int i); // zero-based indexing
   // read-only zero-based indexing 
   double Read(int i) const;
   double& operator()(int i); // one-based indexing
   // assignment
   Vector& operator=(const Vector& otherVector);
   Vector operator+() const; // unary +
   Vector operator-() const; // unary -
   Vector operator+(const Vector& v1) const; // binary +
   Vector operator-(const Vector& v1) const; // binary -
   // scalar multiplication
   Vector operator*(double a) const;
   // p-norm method
   double CalculateNorm(int p=2) const;
   // declare length function as a friend
   friend int length(const Vector& v); 
   friend std::ostream& operator<<(std::ostream& output,
       const Vector& u);
};

// Prototype signature of length() friend function
int length(const Vector& v);

#endif
//Code from Chapter10.tex line 20 save as Vector.hpp

#include <cmath>
#include <iostream>
#include <cassert>
#include "Vector.hpp"

// Overridden copy constructor
// Allocates memory for new vector, and copies
// entries of other vector into it
Vector::Vector(const Vector& otherVector)
{
	mSize = otherVector.GetSize();
	mData = new double[mSize];
	for (int i = 0; i < mSize; i++)
	{
		mData[i] = otherVector.mData[i];
	}
}

// Constructor for vector of a given size
// Allocates memory, and initialises entries
// to zero
Vector::Vector(int size)
{
	assert(size > 0);
	mSize = size;
	mData = new double[mSize];
	for (int i = 0; i < mSize; i++)
	{
		mData[i] = 0.0;
	}
}

// Overridden destructor to correctly free memory
Vector::~Vector()
{
	delete[] mData;
}

// Method to get the size of a vector
int Vector::GetSize() const
{
	return mSize;
}

// Overloading square brackets
// Note that this uses `zero-based' indexing,
// and a check on the validity of the index
double& Vector::operator[](int i)
{
	assert(i > -1);
	assert(i < mSize);
	return mData[i];
}

// Read-only variant of []
// Note that this uses `zero-based' indexing,
// and a check on the validity of the index
double Vector::Read(int i) const
{
	Vector u(*this);
	return u[i];
}

// Overloading round brackets
// Note that this uses `one-based' indexing,
// and a check on the validity of the index
double& Vector::operator()(int i)
{
	return (*this)[i - 1];
}

// Overloading the assignment operator
Vector& Vector::operator=(const Vector& otherVector)
{
	if (mSize != otherVector.mSize)
	{
		std::cerr << "Sizes of Vectors don't match. \n";
	}
	for (int i = 0; i < mSize; i++)
	{
		mData[i] = otherVector.mData[i];
	}
	return *this;
}

// Overloading the unary + operator
Vector Vector::operator+() const
{
	Vector v(mSize);
	for (int i = 0; i < mSize; i++)
	{
		v[i] = mData[i];
	}
	return v;
}

// Overloading the unary - operator
Vector Vector::operator-() const
{
	Vector v(mSize);
	for (int i = 0; i < mSize; i++)
	{
		v[i] = -mData[i];
	}
	return v;
}

// Overloading the binary + operator
Vector Vector::operator+(const Vector& v1) const
{
	if (mSize != v1.mSize)
	{
		std::cerr << "Sizes of Vectors don't match. \n";
	}
	Vector v(mSize);
	for (int i = 0; i < mSize; i++)
	{
		v[i] = mData[i] + v1.mData[i];
	}
	return v;
}

// Overloading the binary - operator
Vector Vector::operator-(const Vector& v1) const
{
	if (mSize != v1.mSize)
	{
		std::cerr << "Sizes of Vectors don't match. \n";
	}
	Vector v(mSize);
	for (int i = 0; i < mSize; i++)
	{
		v[i] = mData[i] - v1.mData[i];
	}
	return v;
}

// Overloading scalar multiplication
Vector Vector::operator*(double a) const
{
	Vector v(mSize);
	for (int i = 0; i < mSize; i++)
	{
		v[i] = a * mData[i];
	}
	return v;
}

// Method to calculate norm (with default value p=2)
// corresponding to the Euclidean norm
double Vector::CalculateNorm(int p) const
{
	double norm_val, sum = 0.0;
	for (int i = 0; i < mSize; i++)
	{
		sum += pow(fabs(mData[i]), p);
	}
	norm_val = pow(sum, 1.0 / ((double)(p)));
	return norm_val;
}

// MATLAB style friend to get the size of a vector
int length(const Vector& v)
{
	return v.mSize;
}

std::ostream& operator<<(std::ostream& output, const Vector& u)
{
	output << "(";
	for (int i = 0; i < u.GetSize(); i++)
	{
		output << " " << u.Read(i);
	}
	output << " )";
	return output;
}
//Code from Chapter10.tex line 62 save as Vector.cpp

[Ein ehemaliger Benutzer]

@manni66 sagte in Klassen-Template Syntaxfehler: Bezeichner:

Da ist kein Vector!

[H.P.Wurst]

Wie erzeugt man denn einen Zeiger einer eigenen Klasse?

[SeppJ]

@H-P-Wurst sagte in Klassen-Template Syntaxfehler: Bezeichner:

Wie erzeugt man denn einen Zeiger einer eigenen Klasse?

So wie jeden anderen Zeiger auch. Oder hast du schon einmal einen Zeiger auf int als int *foo(123); gesehen? Wohl kaum, denn das ist kein int-Zeiger. ABER: Man braucht in C++ eigentlich nie direkte Zeiger. Und ganz selten indirekt. Und ganz bestimmt niemals in dem Zusammenhang, wie du es hier wünscht. Daher: Warum? Lass es einfach. Zumal du offensichtlich wesentliche Probleme mit Zeigern hast.

Deine Vectorklasse hat derzeit Fehler, auf die du noch nicht gestoßen bist. Du solltest mehr testen.