Verständigungs Frage

[magicxxx]

Hi,

ich versuche diese header Darei zu kompilieren, hier ist der Teil Code davon:

#ifndef _VECTOR_H_

#define _VECTOR_H_


// Klasse vector

//

// Mathematischer Vektor

// - double-Elemente

// - grundlegende Vektoroperationen


class vector

{	friend class matrix;


public:	

	double* element;            // double-Pointer zum internen speichern der Elemente

	unsigned int n;             // Dimension des vectors


	vector() :element(0), n(0) {}                             // Standard-Constructor

	vector(const vector& v) :element(0) {*this=v;}            // Copy-Constructor

	vector(const unsigned int l, const double initval=0.0);   // Constructor: Dimension und Anfangswerte vorgebbar

	vector(const unsigned int, const double []);              // Constructor: double-array dem vector zuweisen

	vector(const matrix& mat);                                // Constructor: matrix dem vector zuweisen

	~vector() {if(element) delete[] element;}                 // Destructor

[/PHP]

jedoch kriege ich diese Fehlermeldung:

../../include/vector.h:21: error: expected ',' or '...' before '&'token

Wenn ich jedoch die Zeile

[PHP]klass matrix

, vor dem

klass vector

einfüge ist die Fehlermeldung weg.

Ich vestehe nicht wieso das so ist, die Klasse Matrix wurde doch schon in der Klasse Vector übergeben? oder?

[Klotzkopp]

Hi,

ich versuche diese header Darei zu kompilieren

Headerdateien kompiliert man eigentlich nicht. Versuchst du vielleicht, eine cpp-Datei zu kompilieren, die diese Headerdatei verwendet?

Wenn ich jedoch die Zeile

klass matrix

, vor dem

klass vector

einfüge ist die Fehlermeldung weg.

"klass" mit 'k'? Sicher?

Ich vestehe nicht wieso das so ist, die Klasse Matrix wurde doch schon in der Klasse Vector übergeben? oder?

Du hast eine friend-Deklaration, die soweit ich weiß, auch eine Forward declaration ist. Ich kann in dem Code keinen Fehler finden. Möglicherweise steckt er in der cpp-Datei oder einem anderen Header, der vorher eingebunden wird. Möglicherweise ist auch den Compiler nicht ganz in Ordnung. Welchen verwendest du?

[magicxxx]

hmm sry für die Fehler, ich meine ich kompiliere die .cpp datei und class mit c hast schon recht, hab zu schnell getippt als gedacht.

ich benutze den gcc 4.1.2

Du hast eine friend-Deklaration, die soweit ich weiß, auch eine Forward declaration ist

War das nicht so das dies jetzt nicht mehr gilt die forward deklaration?

[Klotzkopp]

ich benutze den gcc 4.1.2

Den habe ich hier auch benutzt, und der hat den Code anstandslos geschluckt. Es muss an der .cpp-Datei liegen.

War das nicht so das dies jetzt nicht mehr gilt die forward deklaration?

Könntest du die Frage verständlicher formulieren? So mit Satzzeichen oder nur einem möglichen Subjekt?

[magicxxx]

Ich meine irgendwo gelesen zu haben, dass die friend forward deklaration bei den neuen Compilern nicht mehr gilt

der .cpp code ist zu lang der passt hier nicht rein

[Klotzkopp]

Ich meine irgendwo gelesen zu haben, dass die friend forward deklaration bei den neuen Compilern nicht mehr gilt

Ich habe genau deinen Code mit genau deinem Compiler ausprobiert.

der .cpp code ist zu lang der passt hier nicht rein

Dann zeig ein Minimalbeispiel, das den Fehler reproduziert.

[magicxxx]

Hmm irgendwie hat es jetzt geklapt mit einfügen

Also ich habe versucht eine Objektdatei damit zu erzeugen, Hier erstmal der vector.cpp code

#include <iostream>

#include <fstream>

#include <strstream>

#include <cmath>


#include "vector.h"

#include "matrix.h"



// Constructor: Dimension und Anfangswerte vorgebbar

//   l: Dimension des vectors

//   initval: Anfangswert


vector::vector(const unsigned int l, const double initval)

{

	n=l;

	element=new double[n];

	for(unsigned int i=0;i<n;i++)

		element[i]=initval;

}



// Constructor: double-array dem vector zuweisen

//   l: Dimension des vectors

//   array: double-array, das dem vector zugewiesen werden soll


vector::vector(const unsigned int l, const double array[])

{

	n=l;

	element=new double[n];

	for(unsigned int i=0;i<n;i++)

		element[i]=array[i];

}



vector::vector(const matrix& mat)

{

	if(mat.cols()==1)           // Spaltenvektor

	{

		n=mat.rows();

		element=new double[n];

		for(unsigned int i=0;i<n;i++)

			element[i]=mat[i][0];

	} else if(mat.rows()==1)    // Zeilenvektor

	{

		n=mat.cols();

		element=new double[n];

		for(unsigned int i=0;i<n;i++)

			element[i]=mat[0][i];

	} else {

		std::cerr<<"In vector::vector(const matrix&) : illegal matrix size."<<std::endl;

		exit(1);

	}	

}



// Elementzugriffs-Operator

//   i: Index des Elements


double& vector::operator[](const unsigned int i)

{

	// Zul?ssigkeit des Index ?berpr?fen

	if(i>=n)

	{

		std::cerr<<"In vector::operator[] : illegal index ("<<i<<")."<<std::endl;

		exit(1);

	}

	return element[i];

}



// Elementzugriffs-Operator f?r konstantes Objekt

//   i: Index des Elements


const double vector::operator[](const unsigned int i) const

{

	// Zul?ssigkeit des Index ?berpr?fen

	if(i>=n)

	{

		std::cerr<<"In vector::operator[] : illegal index ("<<i<<")."<<std::endl;

		exit(1);

	}

	return element[i];

}



// Neudimensionierung des vectors

//   l: neue Dimension des vectors

//   save: bisherigen Inhalt retten


void vector::dim(const unsigned int l,const bool save)

{

	if(l!=n)

	{

		vector v(l);

		if(save)

		{

			for(unsigned int i=0;i<((l<n)?l:n);i++)

				v.element[i]=element[i];

		}

		*this=v;

	}

}



// alle Elemente auf einen Wert setzen

//   s: Wert


void vector::set(const double s)

{

	for(unsigned int i=0;i<n;i++)

		element[i]=s;	

}



// Achseneinheitsvektor erzeugen

//   e: Index der Achse (0..(n-1))


void vector::axis(const unsigned int e)

{

	if(e>=n)

	{

		std::cerr<<"In vector::axis : illegal index ("<<e<<")."<<std::endl;

		exit(1);

	}

	for(unsigned int i=0;i<n;i++)

		element[i]=0.0;

	element[e]=1.0;		

}



// zwei Elemente vertauschen

//   e1: Index des ersten Elements

//   e2: Index des zweiten Elements


void vector::exchange(const unsigned int e1,const unsigned int e2)

{

	if((e1>=n) || (e2>=n))

	{

		std::cerr<<"In vector::exchange : illegal index ("<<e1<<", "<<e2<<")."<<std::endl;

		exit(1);

	}

	double tmp=element[e1];

	element[e1]=element[e2];

	element[e2]=tmp;

}



// double an den vector anh?ngen

//   s: Wert des neuen Elements


void vector::append(const double s)

{

	dim(n+1);

	element[n-1]=s;

}



// vector an den vector anh?ngen

//   s: Wert des neuen Elements


void vector::append(const vector& v)

{

	dim(n+v.n);

	for(unsigned int i=1;i<=v.n;i++)

		element[n-i]=v.element[v.n-i];

}



// double in den vector einf?gen

//   e: Index des Elements

//   s: Wert des neuen Elements


void vector::insert(const unsigned int e,const double s)

{

	dim(n+1);

	for(unsigned int i=n-1;i>e;i--)

		element[i]=element[i-1];

	element[e]=s;

}



// Zuweisungs-Operator

//   v: vector, der zugewiesen werden soll


vector& vector::operator=(const vector& v)

{

	if(this!=&v)                // Selbstzuweisung vermeiden

	{

		if(element)

			delete[] element;

		n=v.n;

		if(n!=0)                  // Wenn kein leerer Vektor

		{                         // elementweise kopieren

			element=new double[n];

			for(unsigned int i=0;i<n;i++)

				element[i]=v.element[i];

		} else

			element=0;

	}

	return *this;

}



// vector zum vector hinzuaddieren

//  v: vector, der hinzuaddiert werden soll


vector& vector::operator+=(const vector& v)

{

	if(n!=v.n)

	{

		std::cerr<<"In vector::operator+= : incompatible sizes."<<std::endl;

		exit(1);

	}

	for(unsigned int i=0;i<n;i++)

		element[i]+=v.element[i];

	return *this;

}



// vector vom vector subtrahieren

//  v: vector, der subtrahiert werden soll


vector& vector::operator-=(const vector& v)

{

	if(n!=v.n)

	{

		std::cerr<<"In vector::operator-= : incompatible sizes."<<std::endl;

		exit(1);

	}

	for(unsigned int i=0;i<n;i++)

		element[i]-=v.element[i];

	return *this;

}



// vector elementweise mit vector multiplizieren

//   v: vector, der elementweise multipliziert werden soll


vector& vector::operator*=(const vector& v)

{

	if(n!=v.n)

	{

		std::cerr<<"In vector::operator*= : incompatible sizes."<<std::endl;

		exit(1);

	}

	for(unsigned int i=0;i<n;i++)

		element[i]*=v.element[i];

	return *this;

}



// vector elementweise durch vector dividieren

//   v: vector, durch den elementweise dividiert werden soll


vector& vector::operator/=(const vector& v)

{

	if(n!=v.n)

	{

		std::cerr<<"In vector::operator/= : incompatible sizes."<<std::endl;

		exit(1);

	}

	for(unsigned int i=0;i<n;i++)

	{

	 	if(v.element[i]==0)

		{

			std::cerr<<"In vector::operator/= : division by zero."<<std::endl;

			exit(1);

		}

		element[i]/=v.element[i];

	}

	return *this;

}



// vector elementweise mit double multiplizieren

//   s: Wert, mit dem elementweise multipliziert werden soll


vector& vector::operator*=(const double s)

{

	for(unsigned int i=0;i<n;i++)

		element[i]*=s;

	return *this;

}



// vector elementweise durch double dividieren

//   s: Wert, durch den elementweise dividiert werden soll


vector& vector::operator/=(const double s)

{

 	if(s==0)

	{

		std::cerr<<"In vector::operator/= : division by zero."<<std::endl;

		exit(1);

	}

	for(unsigned int i=0;i<n;i++)

		element[i]/=s;

	return *this;

}



// Vergleich auf Gleichheit

//   v1, v2: vectoren, die verglichen werden sollen


bool operator==(const vector& v1,const vector& v2)

{

	if(v1.n!=v2.n)

		return false;

	for (unsigned int i=0;i<v1.n;i++)

		if(v1[i]!=v2[i])

			return false;

	return true;

}



// lexikographischer Vergleich

//   v1, v2: vectoren, die verglichen werden sollen


bool operator<(const vector& v1,const vector& v2)

{

	unsigned int i;

	for (i=0;i<v1.n;i++)

		if(v1[i]!=v2[i])

			return (v1[i]<v2[i]);

	return false;

}



// lexikographischer Vergleich

//   v1, v2: vectoren, die verglichen werden sollen


bool operator>(const vector& v1,const vector& v2)

{

	unsigned int i;

	for (i=0;i<v1.n;i++)

		if(v1[i]!=v2[i])

			return (v1[i]>v2[i]);

	return false;

}



// Vektoraddition

//   v1, v2: vectoren, die addiert werden sollen


vector operator+(const vector& v1,const vector& v2)

{

	if(v1.n!=v2.n)

	{

		std::cerr<<"In vector::operator+ : incompatible sizes."<<std::endl;

		exit(1);

	}

	vector v(v1);

	v+=v2;

	return v;

}



// Vektorsubtraktion

//   v1, v2: vectoren, die subtrahiert werden sollen


vector operator-(const vector& v1,const vector& v2)

{

	if(v1.n!=v2.n)

	{

		std::cerr<<"In vector::operator- : incompatible sizes."<<std::endl;

		exit(1);

	}

	vector v(v1);

	v-=v2;

	return v;

}



// double mit vector multiplizieren

//   s: Wert

//   v1: vector


vector operator*(const double s,const vector& v1)

{

	vector v(v1);

	v*=s;

	return v;

}



// vector mit double multiplizieren

//   v1: vector

//   s: Wert


vector operator*(const vector& v1,const double s)

{

	vector v(v1);

	v*=s;

	return v;

}



// vector durch double dividieren

//   v1: vector

//   s: Wert


vector operator/(const vector& v1,const double s)

{

	vector v(v1);

	v/=s;

	return v;

}



// Skalarprodukt

//   v1, v2: vectoren, die skalarmultipliziert werden sollen


double operator*(const vector& v1,const vector& v2)

{

	if(v1.n!=v2.n)

	{

		std::cerr<<"In vector::operator* : incompatible sizes."<<std::endl;

		exit(1);

	}

	double sp=0.0;

	for(unsigned int i=0;i<v1.n;i++)

		sp+=v1.element[i]*v2.element[i];

	return sp;

}



// vectoren elementweise multiplizieren

//   v1,v2: vectoren, die elementweise multipliziert werden sollen


vector product(const vector& v1,const vector& v2)

{

	if(v1.n!=v2.n)

	{

		std::cerr<<"In vector::product : incompatible sizes."<<std::endl;

//		exit(1);

	}

	vector v(v1);

	v*=v2;

	return v;

}



// vectoren elementweise dividieren

//   v1,v2: vectoren, die elementweise dividiert werden sollen


vector quotient(const vector& v1,const vector& v2)

{

	if(v1.n!=v2.n)

	{

		std::cerr<<"In vector::quotient : incompatible sizes."<<std::endl;

		exit(1);

	}

	vector v(v1);

	v/=v2;

	return v;

}



// Ausgabe-Operator

//   v: vector, der ausgegeben werden soll


std::ostream& operator<<(std::ostream& ostr, vector& v)

{

	for(unsigned int i=0;i<v.n;i++)

		ostr<<v.element[i]<<' ';

	return ostr;

}



// Eingabe-Operator

//   v: vector, in den eingelesen werden soll


std::istream& operator>>(std::istream& istr,vector& v)

{

	for(unsigned int i=0;i<v.n;i++)

		istr>>v[i];

	return istr;

}



std::istrstream& operator>>(std::istrstream& istr, vector& v)

{

	for(unsigned int i=0;i<v.n;i++)

		istr>>v[i];

	return istr;

}



// Compare-Funktion f?r qsort()

int compare_PointWValue (const void *a, const void *

{

  PointWValue *A = (PointWValue *) a;

  PointWValue *B = (PointWValue *) b;


  if (A->Value > B->Value)

  {

    return (1);

  }

  else

  {

    if (A->Value < B->Value)

      return (-1);

    else

      return (0);

  }

}

[/code]

die Matrix Dateien brauchst du auch oder?

[Klotzkopp]

Ich sagte Minimalbeispiel.

Lass so viel wie möglich weg, so dass der Fehler noch auftritt.

[magicxxx]

ok das dauert dann

[magicxxx]

Ich hoffe das reicht, hier ist die Fkt aus der vector.cpp datei:

vector::vector(const matrix& mat)

{

	if(mat.cols()==1)           // Spaltenvektor

	{

		n=mat.rows();

		element=new double[n];

		for(unsigned int i=0;i<n;i++)

			element[i]=mat[i][0];

	} else if(mat.rows()==1)    // Zeilenvektor

	{

		n=mat.cols();

		element=new double[n];

		for(unsigned int i=0;i<n;i++)

			element[i]=mat[0][i];

	} else {

		std::cerr<<"In vector::vector(const matrix&) : illegal matrix size."<<std::endl;

		exit(1);

	}	

}[/PHP]

[Klotzkopp]

Ich hoffe das reicht

Ob das reicht, kannst du leicht selbst daran prüfen, ob dieses Fragment den gleichen Fehler erzeugt.

Bei mir tut es das nicht.

[magicxxx]

ich kriege den Fehler, ausser dass da jetzt noch ein paar andere Fehler auftauchen, was ja normal ist. Hast du vielleicht irgendwelche Compiler Einstellungen gemacht?

[Klotzkopp]

ich kriege den Fehler,

Du bekommst einen Fehler in vector.h, obwohl du die Datei gar nicht mehr einbindest?

Oder besteht deine vector.cpp vielleicht doch noch aus mehr Code, als du da gezeigt hast? Oder hast du vielleicht noch eine andere .cpp-Datei, die du noch gar nicht gezeigt hast?

[magicxxx]

Das ist der Code aus der vector.cpp datei auf das minimale gekürzt, da fehlt nur noch die Einbinding der Header Datei vector.h

und wenn ich versuche aus denen Objektdatei zu generieren kommt der Fehler bei mir?

Oder hab ich dich jetzt Falsch mit dem Beispiel verstanden?

Edit: Hab vergessen #include "vector.h" in vector.cpp einzufügen

Bearbeitet 5. Juni 2008 von magicxxx

[Klotzkopp]

Deklarier den Konstruktor bitte mal so:

    vector(const class matrix& mat);

Ich weiß gerade auch nicht, warum das notwendig ist, aber ich mache mich schlau .

[magicxxx]

ok danke dir, wäre nett wenn du mir das dann erklärst wenn du bescheid weist