ich hätte gerne eine klasse, die eine n-dimensionale Matrix zur verfügung stellt. Also dass ich eine Matrix anlege, und auch direkt deren Dimensionen und Typ der abzulegenden Variablen angebe. Wie das aussehen kann weiß ich selbst nicht so genau, auf sachen wie Matrix < ... > muss ich wohl noch was warten.
Problem stellt für mich dar, die o.g. daten sinnvoll zu übergeben (vllt so: Matrix<class type>::Matrix(int dimension_eins ...); )

aber nächstes prob: Wie soll die Matrix die entsprechenden Container anlegen?

template<int dimension, class type> class Matrix
{
     type data[dimension][dimension];
};

Ist es das was du wolltest?

oO Dann schreib es dir doch kurz?!

warum so schlecht drauf? ich frag doch nur, ob einer ne idee hat...

Badestrand schrieb:

Und soll sie "quadratisch" sein, also dass die Anzahl der Zeilen, Spalten und anderen Dimensionen immer gleich sind? Oder muss für jede Dimension angegeben werden, welche Ausmaße sie hat?

nojaa, ich glaub, der arbeitsaufwand is für ne "rechteckige", also net quadratisch, matrix nicht viel größer?

Badestrand schrieb:

Und soll sie "quadratisch" sein, also dass die Anzahl der Zeilen, Spalten und anderen Dimensionen immer gleich sind? Oder muss für jede Dimension angegeben werden, welche Ausmaße sie hat?

nojaa, ich glaub, der arbeitsaufwand is für ne "rechteckige", also net quadratisch, matrix nicht viel größer?

Naja, man müsste ja nicht nur angeben, wieviele Dimensionen die Matrix hat, sondern auch, wie "groß" jede Dimension ist, also eine variable Template-Parameterzahl, jedenfalls wenn die Größen als Template-Argument übergeben werden sollen
Ich habs jedenfalls ausprobiert und ich kanns nicht

#include <iostream> 
#include <vector>
#include <limits>
#include <assert.h>
#include "windows.h"
#include <string> 

using namespace std; 

template<class T, int dims>
class DynMatrix {
public:
	unsigned* size;
	unsigned prodSizes;
	T* data;
	bool proxy;
	DynMatrix(DynMatrix<T, dims+1>& matrix, T* data, unsigned prodSizes) {
		this->size = matrix.size + 1;
		this->data = data;
		this->proxy = true;
		this->prodSizes = prodSizes;
	}
public:
	DynMatrix(const unsigned* size) {
		this->size = new unsigned[dims];
		this->prodSizes = 1;
		this->proxy = false;
		for(unsigned i = 0; i < dims; i++) {
			this->size[i] = size[i];
			this->prodSizes *= size[i];
		}
		data = new T[prodSizes];
	}

	~DynMatrix() {
		if(!proxy) {
			delete[] size;
			delete[] data;
		}
	}

	DynMatrix<T, dims-1> operator[] (unsigned pos)  {
		assert(pos < size[0]);	
		return DynMatrix<T, dims-1>(*this, data + pos*(prodSizes / size[0]), prodSizes / size[0]);	
	}
};

template<class T>
class DynMatrix<T, 1> {
public:
	unsigned* size;
	unsigned prodSizes;
	T* data;
	bool proxy;
	DynMatrix(DynMatrix<T, 2>& matrix, T* data, unsigned prodSizes) {
		this->size = matrix.size + 1;
		this->data = data;
		this->proxy = true;
		this->prodSizes = prodSizes;
	}
public:
	DynMatrix(const unsigned* size) {
		this->size = new unsigned[1];
		this->prodSizes = 1;
		this->proxy = false;
		for(unsigned i = 0; i < 1; i++) {
			this->size[i] = size[i];
			this->prodSizes *= size[i];
		}
		data = new T[prodSizes];
	}

	~DynMatrix() {
		if(!proxy) {
			delete[] size;
			delete[] data;
		}
	}

	T& operator[] (unsigned pos)  {
		assert(pos < size[0]);	
		return data[pos];
	}
};

int main()
{	
	unsigned size[] = {5,4,3,2,5};
	DynMatrix<unsigned, 5> test(size);
	test[4][2][2][1][4] = 5;
	cout << test[4][2][2][1][4];
	system("pause");
};

nur so hingeschmiert (für den proxy wird man wohl lieber ne extra klasse machen etc), aber ungefähr so?

Ich dachte, die Anzahl der Dimensionen soll dynamisch veränderbar sein?

life schrieb:

nur so hingeschmiert (für den proxy wird man wohl lieber ne extra klasse machen etc), aber ungefähr so?

Ich dachte, die Anzahl der Dimensionen soll dynamisch veränderbar sein?

Dann macht ein operator[] in der Form keinen Sinn. Wenn man aber stattdessen eine Methode get(unsigned pos[]) o.Ä. macht, kann man die Dimension auch in den Konstruktor schieben..