[C++] Szablon tablicy wielowymiarowej

[soku11]

WITAM!
Mam napisac szablon tablcy wielowymiarowej z typem elementow jako parametrem szablonu. Liczba wymiarow ma byc zalezna od konstruktora. I tutaj rodzi sie mi pytanie. Jak w takim razie zadeklarowac 'zalazek tej tablicy' (czyt. wskaznik) w klasie?? Bo przeciez nie wiadomo ile ma miec wymiarow, tak wiec moze to byc wskaznik, wskaznik na wskaznik, itd... Ma ktos jakis pomysl?? Z gory dzieki za rady. POZDRO

[kadiii]

Powiem ci, ze nic sensownego oprócz zrobienia tablicy wielowymiarowej w konwencji tablicy jednowymiarowej i odpowiednie wyliczanie indeksów nie przychodzi mi do głowy. To nawet pomijając te szablony to wykreowanie takiej tablicy ze zmienną liczbą wymiarów i jakoś sensownie ułożonych w pamięci. Jestem ciekaw rozwiązania, sam jak coś jutro wymyślę bardziej wypoczęty to się podzielę. Pozdro

[soku11]

No wlasnie tego sie obawialem :/ No ale coz bede narazie probowal tak kombinowac, a co z tego wyjdzie to zobaczymy Jednak jak na cos innego wpadniesz - smialo pisz Oczywiscie plusik za tworcza odpowiedz POZDRO

[Rafal88K]

Ja proponowałbym zrobić coś takiego:

Kod: Zaznacz cały

#include <iostream>
using namespace std;

template <typename T, int N>
class arrayN
{
	public:
		arrayN(int inSize = 5);
		arrayN(const arrayN<T, N>& src);
		~arrayN();

		arrayN<T, N>& operator=(const arrayN<T, N>& rhs);
		arrayN<T, N - 1>& operator[](int x);
		const arrayN<T, N - 1>& operator[](int x) const;

	private:
		void copy(const arrayN<T, N>& src);
		arrayN<T, N - 1>* mElements;
		int mSize;
};

template <typename T>
class arrayN<T, 1>
{
	public:
		arrayN(int inSize = 5);
		arrayN(const arrayN<T, 1>& src);
		~arrayN();

		arrayN<T, 1>& operator=(const arrayN<T, 1>& rhs);
		T& operator[](int x);
		const T& operator[](int x) const;

	private:
		void copy(const arrayN<T, 1>& src);
		T* mElements;
		int mSize;
};

template <typename T, int N>
arrayN<T, N>::arrayN(int inSize) : mSize(inSize)
{
	mElements = new arrayN<T, N - 1>[mSize];
	for(int i = 0; i < mSize; ++i) {
		arrayN<T, N - 1>* newArray = new arrayN<T, N - 1>[mSize];
	}
}

template <typename T, int N>
arrayN<T, N>::arrayN(const arrayN<T, N>& src)
{
	copy(src);
}

template <typename T, int N>
arrayN<T, N>::~arrayN()
{
	delete[] mElements;
}

template <typename T, int N>
arrayN<T, N>& arrayN<T, N>::operator=(const arrayN<T, N>& rhs)
{
	if(this == &rhs) {
		return *this;
	}

	delete[] mElements;

	copy(rhs);

	return *this;
}

template <typename T, int N>
arrayN<T, N - 1>& arrayN<T, N>::operator [](int x)
{
	return mElements[x];
}

template <typename T, int N>
const arrayN<T, N - 1>& arrayN<T, N>::operator [](int x) const
{
	return mElements[x];
}

template <typename T, int N>
void arrayN<T, N>::copy(const arrayN<T, N>& src)
{
	mSize = src.mSize;
	mElements = new arrayN<T, N - 1>[mSize];

	for(int i = 0; i < mSize; ++i) {
		mElements[i] = src.mElements[i];
	}
}

template <typename T>
arrayN<T, 1>::arrayN(int inSize) : mSize(inSize)
{
	mElements = new T[mSize];
}

template <typename T>
arrayN<T, 1>::arrayN(const arrayN<T,1> &src)
{
	copy(src);
}

template <typename T>
arrayN<T, 1>::~arrayN()
{
	delete[] mElements;
}

template <typename T>
arrayN<T, 1>& arrayN<T, 1>::operator=(const arrayN<T,1> &rhs)
{
	if(this == &rhs) {
		return *this;
	}

	delete[] mElements;

	copy(rhs);

	return *this;
}

template <typename T>
T& arrayN<T, 1>::operator [](int x)
{
	return mElements[x];
}

template <typename T>
const T& arrayN<T, 1>::operator [](int x) const
{
	return mElements[x];
}

template <typename T>
void arrayN<T, 1>::copy(const arrayN<T, 1>& src)
{
	mSize = src.mSize;
	mElements = new T[mSize];

	for(int i = 0; i < mSize; ++i) {
		mElements[i] = src.mElements[i];
	}
}

int main(int argc, char** argv)
{
	arrayN<int, 3> a(3);
	arrayN<int, 3> b(3);

	a[2][2][2] = 1;

	b = a;
	arrayN<int, 3> c = b;

	cout << c[2][2][2] << endl;

	cout << endl;
	return 0;
}

Nie wiem czy o to Ci dokładnie chodziło ale mam nadzieje, że pomogłem.

[soku11]

Naprawde wielkie dzieki za tyle kodu Oczywiscie wszystko dziala, jednak u mnie to ma wygladac inaczej, tj:

Kod: Zaznacz cały

array<int> tablica3(2,3,4,0);

ma tworzyc tablice wielowymiarowa o 3 wymiarach (0 konczy). A odwolywanie sie do elementow ma sie odbywac za pomoca operatora (), czyli np:

Kod: Zaznacz cały

tablica3(1,2,3)=123;
int liczba=tablica3(0,0,0);

POZDRO

[Rafal88K]

Acha to zobacz coś takiego:

Kod: Zaznacz cały

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

int add(int v = 0, ...)
{
	int value = v, result = v;

	va_list va;
	va_start(va, v);

	while (value != 0) {
		value = va_arg(va, int);
		result += value;
	}

	va_end(va);

	return result;
}

int main(int argc, char** argv)
{
	int sum;

	sum = add();
	cout << sum << endl;

	sum = add(0);
	cout << sum << endl;

	sum = add(1, 2, 3, 0);
	cout << sum << endl;

	sum = add(-2, 4, -4, -6, 8, 10, 0);
	cout << sum << endl;

	cout << endl;
	return 0;
}

Warto dać jeszcze jakieś sprawdzanie czy 0 wystąpi np. max do 10 parametrów.

[soku11]

Jeszcze raz dzieki Wlasnie tak zrobilem. POZDRO