wie kann ich dann zeilen gegen spalten tauschen?
wär überhaupt std::vector mit passender klasse dafür am besten geeignet?

cu

Sowas in der Art?

cu

Gruß

vector< vector< vector< int > > > mein3dVektor;

1 dimension = row
2 dimension = column
3 dimension = depth

will row0 bis 2 gegen column0 bis 2 tauschen....

wie klappt das hier am einfachsten?

cu

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);
		}
	}
};

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.

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

cu

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

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