000
20.12.2004, 14:13 Uhr
Mutabor
|
Hallo Forum
Ich habe mir ein zweidimensionales, dynamisches Array gebastelt.
Wer sieht hier noch Verbesserungsmöglichkeiten?
Danke in voraus.
| C++: |
#ifndef _multi_dim_array8_h
#define _multi_dim_array8_h
#include<iostream.h>
#include<stdlib.h>
#include<assert.h>
// class D1
template <class T> class D1
{
T *Data;
public :
int delta;
int s1,z1; //Dimensionsgröße
//Konstruktor
D1(int,int); //letzte Argument ist delta
~D1();
T Data_delete();
//Methoden
T Getarray(int);
T Getarray1(int);
void Setarray(T,int);
void Setarray1(T,int);
void D1_aendernplus(int,int);
void D1_aendernplus1(int,int);
int Dimsize(int);
void Deletearray();
};
// class D2
template <class T> class D2
{
public :
int delta;
int s1,s2; //Dimensionsgrößen
int z1,z2; //Dimensionszwischengrößen
D1< D1<T>* > *Data;
//Konstruktor
D2(int,int,int); //letzte Argument ist delta
~D2();
//Methoden
T Getarray(int,int);
T Getarray1(int,int);
void Setarray(T,int,int);
void Setarray1(T,int,int);
void D_aendernplus(int,int);
int Dimsize(int);
void Deletearray();
};
// class D1
template <class T>
D1<T>::D1(int d1=0,int del=0)
{
int i;
delta = del;
if(d1<=0)d1 =1;
s1 = d1;
Data = new T [d1];
assert(Data != NULL);//assert_Meldung Speicherfehler
for( i = 0; i < d1; i++)
Data[i] = (T) 0;
}
template <class T>
D1<T>::~D1()
{
delete [] Data;
}
//Funktion löscht alte Array und legt neues Array mit Dimsize 1 an
template <class T>
void D1<T>::Deletearray()
{
T *Temp;
Temp = new T [1];
assert(Temp != NULL);//assert_Meldung Speicherfehler
Temp[0] = (T) 0;
delete [] Data;
Data = Temp;
s1 = 1;
}
template <class T>
D1<T>::Data_delete()
{
delete [] Data;
return 0;
}
template <class T>
T D1<T>::Getarray(int d)
{
assert(d >= 0);//assert_Meldung wenn der Index kleiner als 0 ist
assert(d < s1);//assert_Meldung wenn der Index größer als die Dimensionsgröße ist
return Data[d];
}
template <class T>
T D1<T>::Getarray1(int d)
{
return Data[d];
}
template <class T>
void D1<T>::Setarray1(T daten,int d1)
{
Data[d1] = daten;
}
template <class T>
void D1<T>::Setarray(T daten,int d1)
{
if(d1 >= s1){
z1 = s1;
D1_aendernplus(d1,z1);
}
Data[d1] = daten;
}
template <class T>
void D1<T>::D1_aendernplus(int d1=0,int d1alt = 0)
{
T *Temp;
int j,k;
if(d1 >= s1){
if(d1 - s1 >= delta)
s1 = d1+1; //erweitert Array Data um d1
else
s1 = s1 + delta; //erweitert Array Data um delta
}
Temp = new T [s1];
assert(Temp != NULL);//assert_Meldung Speicherfehler
for( k = 0; k < s1; k++)
Temp[k] = (T) 0;
for(j = 0;j < d1alt; j++)
Temp[j] = Data[j];
delete [] Data;
Data = Temp;
}
template <class T>
void D1<T>::D1_aendernplus1(int d1=0,int d1alt = 0)
{
T *Temp;
int j,k;
d1++; //D1 gibt Position an, neue Größe D1 + 1
Temp = new T [d1];
assert(Temp != NULL);//assert_Meldung Speicherfehler
for( k = 0; k < d1; k++)
Temp[k] = (T) 0;
for(j = 0;j < d1alt; j++)
Temp[j] = Data[j];
delete [] Data;
Data = Temp;
}
//Funktion gibt die Dimensionsgröße aus
template <class T>
int D1<T>::Dimsize(int si=0)
{
int siz = 0;
switch(si){
case 1 :{ siz = s1;break;}
}
return siz;
}
// class D2
template <class T>
D2<T>::D2(int d1=0,int d2=0,int del=0)
{
int i;
delta = del;
int dummy = 0;
if(d1<=0)d1 =1;
if(d2<=0)d2 =1;
s1 = d1;
s2 = d2;
Data = new D1< D1<T>* >(d1,dummy); //0 = Dummy für delta
for(i = 0; i < d1; i++)
Data->Setarray1(new D1<T>(d2,dummy),i);
}
template <class T>
D2<T>::~D2()
{
int i;
for(i = 0; i < s1; i++)
Data->Getarray1(i)->Data_delete();
}
//Funktion löscht alte Array und legt neues Array mit Dimsize 1 an
template <class T>
void D2<T>::Deletearray()
{
int i;
for(i = 0; i < s1; i++){
Data->Getarray1(i)->Deletearray(); //////////////
}
s1 = 1;
s2 = 1;
}
template <class T>
void D2<T>::D_aendernplus(int d1=0,int d2=0)
{
int i;
int dummy = 0;
z1 = s1;
z2 = s2;
if(d1 >= s1){
if(d1 - s1 >= delta)
s1 = d1+1; //erweitert Array Data um d1
else
s1 = s1 + delta; //erweitert Array Data um delta
Data->D1_aendernplus1(s1,z1); //d1
for(i = z1; i < s1; i++){
Data->Setarray1(new D1<T>(s2,dummy),i);
} }
if(d2 >= s2){
if(d2 - s2 >= delta)
s2 = d2+1; //erweitert Array Data um d2
else
s2 = s2 + delta; //erweitert Array Data um delta
for(i = 0; i < s1; i++){
Data->Getarray1(i)->D1_aendernplus1(s2,z2); //////////////
}}
}
template <class T>
T D2<T>::Getarray(int d1,int d2)
{
assert(d1 >= 0);//assert_Meldung wenn der Index kleiner als 0 ist
assert(d2 >= 0);
assert(d1 < s1);//assert_Meldung wenn der Index größer als die Dimensionsgröße ist
assert(d2 < s2);
return Data->Getarray1(d1)->Getarray1(d2);
}
template <class T>
T D2<T>::Getarray1(int d1,int d2)
{
return Data->Getarray1(d1)->Getarray1(d2);
}
template <class T>
void D2<T>::Setarray(T daten,int d1,int d2)
{
if(d1 < 0 || d2 < 0){
D_aendernminus(d1,d2);
}
if(d1 >= s1 || d2 >= s2){
D_aendernplus(d1,d2);
}
Data->Getarray1(d1)->Setarray1(daten,d2);
}
template <class T>
void D2<T>::Setarray1(T daten,int d1,int d2)
{
Data->Getarray1(d1)->Setarray1(daten,d2);
}
//Funktion gibt die Dimensionsgröße aus
template <class T>
int D2<T>::Dimsize(int si=0)
{
int siz = 0;
switch(si){
case 1 :{ siz = s1;break;}
case 2 :{ siz = s2;break;}
}
return siz;
}
#endif
|
| Bearbeitung: |
Codetags eingefügt
|
Dieser Post wurde am 20.12.2004 um 14:39 Uhr von virtual editiert. |
