C++ Probleme beim Variablen vererben mit friend

DeusExMachina · 12. Januar 2011

Moin Moin,

ich verzweifel grade ein bisschen an einem klassischem Boon Fehler, die Class Vektor soll auf die Variablen der Class Matrix nutzen können.
Diese sollen aber in der Class Matrix private sein also kann ich nicht über ne globale Variable "schummeln".

Ich bekomme aber immer wieder diese Fehler:
4_3.cpp(176) : error C2065: 'dim' : undeclared identifier
4_3.cpp(276) : error C2065: 'inv_matrix' : undeclared identifier
4_3.cpp(276) : error C2109: subscript requires array or pointer type (dieser fehler tauch öfter auf)

Muss ich diese Nochmal neu deklarieren? oder ist der Fehler so boonig das ich mir nach her selbst in den arsch beiße? Leider komm ich grad nicht weiter und bitte um den nötigen stubs in die richtige Richtung.

Danke schon mal im vorraus

Code:

#include <iostream>
#include <iomanip>
using namespace std;


//Klassen
class QuadMatrix
{
//Variabelen Definition
//Status: public:, private:, static:
private:
//Variablen
		float matrix[3][3];			//Speicher für die Quellmatrix
		float inv_matrix[3][3];		//Zwischenspeicher für die Inverse Matrix
		int dim;					//Variable zum Speichern der Dimension
		float det;					//Variable zum Speichern der Determinante

//Funktionen Definition:
//Status: public:, private:, static:

public:
		void setzeDim();				//Funktion zum Abfragen der Dimension
		void eingeben();				//Funktion zum einlesen der Werte in die Matrix
		void ausgeben();				//Funktion zum Ausgeben der Matrix
		void inv_ausgeben();			//Funktion zum Ausgeben der Matrix
		float calc_det();				//Funktion zum Berechnen der Determinate
		void invers();					//Funktion zum Berechnen der Invesersen
//friend
		friend class Vektor;					


};

class Vektor
{
//Variabelen Definition
//Status: public:, private:, static:
private:
//Variablen
		float victor[3];					//Speicher für den Vektor
		float victor_erg[3];				//Speicher für das Scalarprodukt

//Funktionen Definition:
//Status: public:, private:, static:

public:
		void vektor_eingeben();				//Funktion zum Einlesen der Werte des Vektors
		void vektor_ausgeben();				//Funktion zum Ausgeben des Vektors
		void scalarpro();					//Berechnen des Ergebnisses


};

//Hauptprogramm

int  main()
{
	QuadMatrix matrix;
	Vektor vektor;
	matrix.setzeDim();
	matrix.eingeben();
	vektor.vektor_eingeben();
	cout << "\nSie haben diese Matrix erstellt\n\n";
	matrix.ausgeben();
	cout << "\n";
	cout << "\nSie haben diesen Vektor erstellt\n\n";
	vektor.vektor_ausgeben();
	cout << "\n";
	if(matrix.calc_det() != 0)
	{
	matrix.invers();
	vektor.scalarpro();
	}
	return 0;
}


/****************************************************************************/
///////////////////////////     Funktionen      //////////////////////////////
/****************************************************************************/

//Input Output

void QuadMatrix :: setzeDim()
{
	dim = 0;
	// Abfrage der Dimension der Matrix
	while (dim != 1 && dim != 2 && dim != 3)
	{
	cout << "\nBitte Dimension der Matrix eingeben (1,2 oder 3 Dimensionen)!\n";	// Abfrage Text
	cin >> dim;																// Einlesen der Dimenson und beschreiben der Dimensonsvariablen
	}																
	return;
}

void QuadMatrix :: eingeben() 
{
	//Hilfsvariablen
	int zeile;
	int spalte;

	// Einlesen der Werte in die Matrix
	for(zeile = 1; zeile <=dim; zeile++)																// Zeilenvorlauf
	{
		for(spalte = 1; spalte <= dim; spalte++ )														// Spaltenvorlauf
		{
		cout << "Bitte Element [" << zeile << "][" << spalte << "] der Matrix eingeben!\n";	// Spaltenweises Einlesen der Werte für das Array
		cin >> matrix[zeile-1][spalte-1];																// Zuweisen des Wertes auf seinem Platz in der Matrix
		}
	}


return;
}

void QuadMatrix :: ausgeben() 
{
	//Hilfsvariablen
	int zeile;
	int spalte;

	// Ausgeben der Matrix

	for(zeile = 0; zeile <dim; zeile++)						// Zeilenvorlauf
	{
		for(spalte = 0; spalte <dim; spalte++)				// Spaltenvorlauf
		{
		cout << "|\t";
		cout << matrix[zeile][spalte];						// Spaltenweises Ausgeben der Werte der Matrix
		cout << "\t";
		}
		cout << "|\n";
	}
return;
}

void QuadMatrix :: inv_ausgeben() 
{
	//Hilfsvariablen
	int zeile;
	int spalte;

	// Ausgeben der Matrix

	for(zeile = 0; zeile <dim; zeile++)						// Zeilenvorlauf
	{
		for(spalte = 0; spalte <dim; spalte++)				// Spaltenvorlauf
		{
		cout << "|\t";
		cout << inv_matrix[zeile][spalte];					// Spaltenweises Ausgeben der Werte der Matrix
		cout << "\t";
		}
		cout << "|\n";
	}
return;
}

void Vektor :: vektor_eingeben() 
{
	//Hilfsvariablen
	int zeile;


	// Einlesen der Werte des Vektors
	for(zeile = 1; zeile <= dim; zeile++)												// Zeilenvorlauf
	{
		cout << "Bitte Element [" << zeile << "] des inhomogenen Anteils eingeben!\n";	// Spaltenweises Einlesen der Werte für das Array
		cin >> victor[zeile-1];															// Zuweisen des Wertes auf seinem Platz in der Matrix
	}


return;
}

void Vektor :: vektor_ausgeben() 
{
	//Hilfsvariablen
	int zeile;

	// Ausgeben des Vectors
	
	for(zeile = 0; zeile <dim; zeile++)				// Zeilenvorlauf
	{
		cout << "|\t";
		cout << victor[zeile];						// Zeilenweises Ausgeben der Werte des Vektors
		cout << "\t|\n";
	}
return;
}

/****************************************************************************/
///////////////////////////  Rechenoperationen  //////////////////////////////
/****************************************************************************/

float QuadMatrix :: calc_det()
{
	det=0;
	// Berechnen der Determinante
	switch(dim)
	{
	    case 1:
	        det = matrix[0][0];
		break;

		case 2:
			det = (matrix[0][0] * matrix[1][1]) - ( matrix[1][0] * matrix[0][1]);
		break;

		case 3:
			det =	(matrix[0][0] * matrix[1][1] * matrix[2][2]) +
					(matrix[0][1] * matrix[1][2] * matrix[2][0]) +
					(matrix[0][2] * matrix[1][0] * matrix[2][1]) -
					(matrix[0][2] * matrix[1][1] * matrix[2][0]) -
					(matrix[0][1] * matrix[1][0] * matrix[2][2]) -
					(matrix[0][0] * matrix[1][2] * matrix[2][1]);
		break;
	}


	cout << "\nDie Matrix hat die Determinate: ";
	cout << det;
	cout << "\n";

return det;
}

void QuadMatrix :: invers ()
{
// Berechnen der Inversen
	switch(dim)
	{
	    case 1:
	        inv_matrix[0][0] = 1.0f/det;
		break;

		case 2:
			inv_matrix[0][0] = +matrix[1][1]/det;
			inv_matrix[0][1] = -matrix[0][1]/det;
			inv_matrix[1][1] = +matrix[0][0]/det;
			inv_matrix[1][0] = -matrix[1][0]/det;
		break;

		case 3:
			inv_matrix[0][0] = +(matrix[1][1]*matrix[2][2]-matrix[1][2]*matrix[2][1])/det;
			inv_matrix[0][1] = -(matrix[0][1]*matrix[2][2]-matrix[2][1]*matrix[0][2])/det;
			inv_matrix[0][2] = +(matrix[0][1]*matrix[1][2]-matrix[1][1]*matrix[0][2])/det;
			inv_matrix[1][0] = -(matrix[1][0]*matrix[2][2]-matrix[1][2]*matrix[2][0])/det;
			inv_matrix[1][1] = +(matrix[0][0]*matrix[2][2]-matrix[0][2]*matrix[2][0])/det;
			inv_matrix[1][2] = -(matrix[0][0]*matrix[1][2]-matrix[1][0]*matrix[0][2])/det;
			inv_matrix[2][0] = +(matrix[1][0]*matrix[2][1]-matrix[1][1]*matrix[2][0])/det;
			inv_matrix[2][1] = -(matrix[0][0]*matrix[2][1]-matrix[0][1]*matrix[2][0])/det;
			inv_matrix[2][2] = +(matrix[0][0]*matrix[1][1]-matrix[0][1]*matrix[1][0])/det;
		break;
	}
	return;
}

//Prüfen auf Singulärität

void Vektor :: scalarpro()
{
switch(dim)
    {
     case 1:
            victor_erg[0] = inv_matrix[0][0]*victor[0];
     break;
      
     case 2:
            victor_erg[0] = (inv_matrix[0][0]*victor[0])+(inv_matrix[0][1]*victor[1]);
            victor_erg[1] = (inv_matrix[1][0]*victor[0])+(inv_matrix[1][1]*victor[1]);
     break;
                        
     case 3:
            victor_erg[0] = (inv_matrix[0][0]*victor[0])+(inv_matrix[0][1]*victor[1])+(inv_matrix[0][2]*victor[2]);
            victor_erg[1] = (inv_matrix[1][0]*victor[0])+(inv_matrix[1][1]*victor[1])+(inv_matrix[1][2]*victor[2]);
            victor_erg[2] = (inv_matrix[2][0]*victor[0])+(inv_matrix[2][1]*victor[1])+(inv_matrix[2][2]*victor[2]);
     break;
 
     }
}

Yuuri · 12. Januar 2011

friend besagt nur, dass du auf private Attribute zugreifen kannst. Du hast, wie ich sehe, aber keinerlei Referenz auf die andere Klasse, also kannst du nicht mit dim umgehen. Übergib also ein Objekt der Klasse, dann kannst du die entsprechende Variable auch nutzen.

DeusExMachina · 12. Januar 2011

Code:

..

friend class Vektor(dim inv_matrix);

..

So in der Art?

Yuuri · 12. Januar 2011

Nein, du musst irgendwo eine Referenz auf das Objekt bekommen.

Code:

void Vektor :: vektor_ausgeben( const QuadMatrix *Q ) 
{
  // ...
  for(zeile = 0; zeile < Q->dim; zeile++)
  // ...
}

// oder

void Vektor :: vektor_ausgeben( int Dimensions ) 
{
  // ...
  for(zeile = 0; zeile < Dimensions; zeile++)
  // ...
}

Theoretisch bräuchtest du friend aber zwangsweise nur, wenn irgendwelche Operatorüberladungen gebraucht werden (dort brauchte ich es wenn nur).

DeusExMachina · 12. Januar 2011

jetzt verstehe ich,

ich gehe davon aus das dies sowohl in der Funktionsdeklaration von Vektor als auch bei den Funktionsaufrufen geschehen muss?

Yuuri · 12. Januar 2011

Genau, du brauchst ja irgendwo den Zugriff auf ein spezielles Objekt und auf Klassen kannst du nicht zugreifen (außer die Felder sind statisch oder konstant).

Aber ganz ehrlich: Das System brauchst du nicht wirklich. Anstatt den Zugriff auf private Member zu erlauben, solltest du lieber die benötigten Daten über Getter und Setter regeln und diese jeder Methode übergeben. Falls gewollt auch das richtige Objekt (siehe oben Beispiel 1), aber hier auch bitte nur den Weg über Getter und Setter.

DeusExMachina · 12. Januar 2011

leider ist des friend hier gewollt ich raffs nur leider nicht ganz.

was meinst du mit getter und setter? des kenne ich nur von ruby und da kam ich damit leider nicht sowirklich klar.

Yuuri · 12. Januar 2011

Wenn du unbedingt mit friend arbeiten willst, dann kannst du dies natürlich gern machen. Einen Vorteil gibt es in dieser Geschichte allerdings nicht, eher Probleme, da Zugriff auf private Member entsteht.

über friend:

PHP:

void Vektor :: vektor_ausgeben( const QuadMatrix &Q ) 
{
  // ...
  for(zeile = 0; zeile < Q->dim; zeile++)
  // ...
}

// ...
{
  QuadMatrix mat;
  Vektor vek;
  
  // ...
  
  vek.vektor_ausgeben( mat );
}
// ...

über Getter und Setter:

PHP:

class QuadMatrix
{
  private :
    int dim;
  
  public :
    void SetDimension( int Dimension ) { dim = Dimension; }
    int GetDimension( void ) { return dim; }
};

void Vektor :: vektor_ausgeben( int Dimension ) 
{
  // ...
  for(zeile = 0; zeile < Dimension; zeile++)
  // ...
}

// ...
{
  QuadMatrix mat;
  Vektor vek;

  // ...
  
  vek.vektor_ausgeben( mat.GetDimension() );
}
// ...

DeusExMachina · 13. Januar 2011

ich verstehe zwar was du mir sagen willst aber ich bekomme das nicht hin.

Suche

C++ Probleme beim Variablen vererben mit friend

DeusExMachina

Lt. Junior Grade

Yuuri

Fleet Admiral

DeusExMachina

Lt. Junior Grade

Yuuri

Fleet Admiral

DeusExMachina

Lt. Junior Grade

Yuuri

Fleet Admiral

DeusExMachina

Lt. Junior Grade

Yuuri

Fleet Admiral

DeusExMachina

Lt. Junior Grade