3D std::vector

hi, habs nun so, jedoch soll der code etwas schöner werden....weil lesbar ist das ganze ja nicht grad schön...hm...
vielleicht doch was mit swap() ?

class Cube
{
private:           // column, row depth, faces
	int colors[3][3][3][6];

public:
    Cube()
    {
		for (int x=0;x<3;x++) for (int y=0;y<3;y++) for (int z=0;z<3;z++) for (int face=0;face<6;face++) colors[x][y][z][face] = rand() % 6;
    }

	void swap_row_in_depth(int row, int direction)
	{
                /* zB.:
                123
                456       Tiefen
                789

                Spalten 

                nach 90° Drehung:  
                741
                852
                963
                */

		int colors_help[3][3][3][6];	

		int u = 2;
		for(int depth=0;depth<3;depth++) // Schleife von Tiefe0 - Tiefe2
		{
			for (int column=0;column<3;column++) // Schleife von Spalte0 - Spalte2
			{
				if(direction) // Spalte0 -> Tiefe0
					memcpy(&colors_help[column][row][u],&colors[depth][row][column],sizeof(int) *6);
				else // Tiefe0  -> Spalte0
					memcpy(&colors_help[u][row][column],&colors[column][row][depth],sizeof(int) *6);
			}
			u--;
		}

		for (int x=0;x<3;x++) for (int z=0;z<3;z++) {
			memcpy(&colors[x][row][z],&colors_help[x][row][z],sizeof(int) *6);
		}
	}
};

Der std::vector hat nichts mit dem Vektor aus der Mathematik zu tun, daher ist es auch kein Wunder, dass du Probleme bekommst. Verwende wie jeder andere auch eine Klasse die einen Vektor im mathematischen Sinn darstellt.

welche klasse wäre da geeignet?
cu

macht man das nicht normalerweise mit matrizen??

Normalerweise schreibt man sich seine Vectorklasse selbst

Ben04

Willst du jetzt einen n-dimensionalen Vektor oder Raum? Wenn es ein n-dimensionaler Vektor sein soll dann ist std::vector das was du suchst. Ich glaub du willst aber einen Raum. Du könntest etwas wie folgt versuchen.

template<class T>
class Raum3D
{
public:
  Raum3D(size_t x, size_t y, size_t z){
    dimension[0] = 1;
    dimension[1] = x;
    dimension[2] = x*y;
    data = new T[x*y*z];
  }
  T&operator()(size_t x, size_t y, size_t z){
    return data[x*dimension[0] + y*dimension[1] + z*dimension[2]];
  }
  void swap_x_dim_with_y_dim(){
    std::swap(dimension[0], dimension[1]);
  }
private:
  size_t dimension[3];
  T*data;
};

Für einen 2 dimensionalen Raum lassen sich sämtliche Rotation und Spieglungen auf diese Weise virtuel implementieren. Für einen 3 dimensionalen Raum müsste dieser Trick auch funktionieren. Hab es allerdings noch nicht ausprobiert.

danke mal...was was machst du hier?

dimension[0] = 1;
dimension[1] = x;
dimension[2] = x*y;

eigentlich verwende ich in meinem Beispiel einen 4D vektor...
1ste dimension = spalten
2te dimension = reihen
3te dimension = tiefen
4te dimension = faces

Willst du jetzt einen n-dimensionalen Vektor oder Raum

was war da noch mal der unterschied?

cu

-> ein n-dimensionaler Vektorraum wird von n n-dimensionalen Vektoren aufgespannt
dann ja...

cu

hi, bräuchte aber:

size_t dimension[3][3][3];

und da dann ein swap....

oder vielleicht mit Boost Multidimensional Array was hübsches bauen...
[url]
http://boost.org/libs/multi_array/doc/user.html
[/url]

cu

hab mir das beispiel noch mal genau angeschaut....ist aber eigentlich e brauchbar bei dem was ich vor habe...
dimension1=spalten
dimension2=reihen
dimension3=tiefen

template<class T>
class Raum3D
{
public:
  Raum3D(size_t x, size_t y, size_t z){
    dimension[0] = 1;
    dimension[1] = x;
    dimension[2] = x*y;
    data = new T[x*y*z];
	size = x*y*z;
  }
  ~Raum3D(){
	  delete[] data;
  }
  T&operator()(size_t x, size_t y, size_t z){
    return data[x*dimension[0] + y*dimension[1] + z*dimension[2]];
  }
  void init_random(){
	  	for(int i=0;i<size;i++)
		  data[i] = rand() % 6;
  }
  void swap_x_dim_with_y_dim(){
    std::swap(dimension[0], dimension[1]);
  }
  void print_array(){
	  for(int i=0;i<size;i++)
		  cout << data[i];
  }
private:
  size_t dimension[3];
  size_t size;
  T*data;
};

int main()
{
	Raum3D<int> Raum3D(3, 3, 3);
	Raum3D.init_random();

	for(int x=0;x<3;x++){
		cout << '\n';
			for(int y=0;y<3;y++){ 
				cout << '\n';
					for(int z=0;z<3;z++){
						cout << Raum3D(x,y,z);
					}
			}
	}

	Raum3D.swap_x_dim_with_y_dim();

	cout << endl << endl;

	for(int x=0;x<3;x++){
		cout << '\n';
			for(int y=0;y<3;y++){ 
				cout << '\n';
					for(int z=0;z<3;z++){
						cout << Raum3D(x,y,z);
					}
			}
	}

	cin.get();
    return 0;
}

ausgabe:
523
410
054

550
532
014

453
413
423

523
550
453

410
532
413

054
014
423

möcht jetzt in diesem block(reihe[0]):
523
410
054

ändern zu -> entspricht einer 90° drehung nach im uhrzeigersinn...
045
512
403

cu