C++ Community

piXelshooter

hm... ich glaub, liegt an mir, dass ich mich unglücklich ausgedrüct habe:
eher so:
Matrix<int> m(int size_a, int size_b, int size_c ...)
zugriff per
m[size_a][size_b][size_c]...
dh, dass die anzahl der dimensionen unbekannt ist, nicht deren größe

*D*Evil

Öhm ... hatte hier mal nen Template dafür gepostet ... konntest die anzahl der zeilen und spalten dynamsich festlegen ... in nem anderen Forum: http://www.spieleprogrammierer.de/phpBB2/viewtopic.php?t=8081 ...

Hrmpf!

Mit Verlaub , euer Ehren,
ich glaube er meint (so hat er es zumindest gesagt), dass er nicht die Anzahl an Elementen pro Spalte/Zeile angeben will, sondern auch die Anzahl an Dimensionen, d.h. dass es mehr als Spalten und Zeilen gibt. Sozusagen eine 3D-Matrix.

piXelshooter

das hat aber wieder nur 2 dimensionen
ich hätte lieber gerne wie gesagt n dimensionen: m[index_1][index_2]...[index_n]

Badestrand

Ach Gott ach Gott, das wird aber kompliziert Über Templates lässt sich das in der Form nicht regeln lassen.. Nur mal so, wofür brauchst du eine n-dimensionale Matrix? 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?

*D*Evil

oO Dann schreib es dir doch kurz?!

piXelshooter

(D)Evil schrieb:

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?

*D*Evil

theoretisch willst du also das bsw. in einer 3D Matrix es noch eine z koordinate gibt, richtig? Dann sollte das schön über templates machbar sein ...

Badestrand

piXelshooter schrieb:

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

life

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

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

camper

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?

life

camper schrieb:

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..

The-Kenny

Öhm... macht Boost.multi_array nicht genau das, wonach hier gesucht wird?

piXelshooter

@life yo sowas meinte ich ty
@The-Kenny hm das was ich da versteh scheint auch das zu machen

dynamisch merhdimensionale matrizen