Multidimensjonale tabeller og return

[Herr_Dude]

Har en todimensjonal tabell (3x3 <- fast størrelse ) som jeg skal returnere fra en metode, og få inn som parameter i en annen, men.... hvordan kan jeg gjøre det ?

 

har en typedef

 

typedef double Tab3x3[3][3];

 

og ønsker å returnere en variabel av denne typen. Forslag ?

Kan være et veldig enkelt spørsmål dette, men ble sittende litt fast her...

Skal vel kunne gå ettersom jeg kjenner til størrelsen på tabellen, eller ?

[Herr_Dude]

Har forsåvidt arbeidet meg rundt problemet, men tar gjerne imot svar hvis noen vet om en grei måte å returnere en tabell av flere dimensjoner.

[Dead_Rabbit]

Har forsåvidt arbeidet meg rundt problemet, men tar gjerne imot svar hvis noen vet om en grei måte å returnere en tabell av flere dimensjoner.

Altså dette er bare en teori, en muligens ganske latterlig teori(har så vidt begynt med pekere men ikke med flere dimmensjoner), men kan det gå om å behandle den som en peker?? Og kansje klare det sånn??

Er heeeeeelt noooob innen for det området men...

Edit:Og så returnere tabell** eller noe sånn

Endret 25. mars 2004 av zirener

[☀ ❄]

Flere muligheter:

• boost::multi_array
  
• std::vector< std::vector<double> > (Du må bruke typename for å returnere denne, hvis jeg ikke tar feil)
  
• Peker til peker (som zirener sa)
  

EDIT 1: La til et mellomrom for lesbarhet

EDIT 2: Du kan selvfølgelig også bruke et endimensjonelt array med ni elementer, og så få tilgang til x,y ved å gjøre y*width + x

Endret 25. mars 2004 av Myubi

[Herr_Dude]

Fine forslag det her, men en kan altså ikke direkte returnere en tabell dersom en kjenner dimensjonene på den på lik måte som en kan gi den som et argument til en funksjon ved f.eks:

 

void teitEksempel( int tab[3][3] )
{
   tab[0][0] = 5;
}

 

Burde det ikke være en tilsvarende måte å returnere en slik tabell på ?

 

 

Edit: Håpløs setningsoppbygning på avsluttende setning.

Endret 26. mars 2004 av Herr_Dude

[søppel]

#include <iostream>
#include <string>

using namespace std;


typedef double** Tab;


Tab& funk(Tab& t)
{
return(t);
} // funk()


int main() 
{
Tab a;

a = reinterpret_cast<double**>(new double[3]);
a[0] = new double[3];
a[1] = new double[3];
a[2] = new double[3];

a[0][0] = 0;
a[0][1] = 1;
a[0][2] = 2;
a[1][0] = 3;
a[1][1] = 4;
a[1][2] = 5;
a[2][0] = 6;
a[2][1] = 7;
a[2][2] = 8;

Tab b = funk(a);

cout << b[0][0] << ' '
   << b[0][1] << ' '
   << b[0][2] << ' '
   << b[1][0] << ' '
   << b[1][1] << ' '
   << b[1][2] << ' '
   << b[2][0] << ' '
   << b[2][1] << ' '
   << b[2][2] << endl;

delete[](a[0]);
delete[](a[1]);
delete[](a[2]);
delete[](a);

return(0);
} // main()

 

..mulig dette er litt på trynet sånn her i farta.

Endret 26. mars 2004 av søppel

[søppel]

...men..

 

Jeg foretrekker å bruke std::map til n-dimensjonale strukturer, noe slikt:

 

#include <iostream>
#include <string>
#include <map>

using namespace std;


template<int ndim, typename T, typename DIM = int>
class Table;

// 2 Dimensions
template<typename T, typename DIM>
class Table<2, T, DIM> : public std::map<DIM, std::map<DIM, T> > {};

// 3 Dimensions
template<typename T, typename DIM>
class Table<3, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, T> > > {};

// 4 Dimensions
template<typename T, typename DIM>
class Table<4, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, T> > > > {};

// 5 Dimensions
template<typename T, typename DIM>
class Table<5, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, T> > > > > {};

// 6 Dimensions
template<typename T, typename DIM>
class Table<6, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, T> > > > > > {};

// 7 Dimensions
template<typename T, typename DIM>
class Table<7, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, T> > > > > > >{};

// 8 Dimensions
template<typename T, typename DIM>
class Table<8, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, T> > > > > > > > {};

// 9 Dimensions
template<typename T, typename DIM>
class Table<9, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, T> > > > > > > > > {};

// 10 Dimensions
template<typename T, typename DIM>
class Table<10, T, DIM> : public std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, std::map<DIM, T> > > > > > > > > > {};



template<int ndim, typename T, typename DIM>
Table<ndim, T, DIM>& funk(Table<ndim, T, DIM>& t)
{
return(t);
}


int main() 
{
Table<2, double> a, b;

a[0][0] = 0;
a[0][1] = 1;
a[0][2] = 2;
a[1][0] = 3;
a[1][1] = 4;
a[1][2] = 5;
a[2][0] = 6;
a[2][1] = 7;
a[2][2] = 8;

b = funk(a);

cout << b[0][0] << ' '
   << b[0][1] << ' '
   << b[0][2] << ' '
   << b[1][0] << ' '
   << b[1][1] << ' '
   << b[1][2] << ' '
   << b[2][0] << ' '
   << b[2][1] << ' '
   << b[2][2] << endl;


return(0);
} // main()

 

..men passer sef. ikke til all bruk.

Endret 26. mars 2004 av søppel

[A_N_K]

Map blir vel ganske overkill, med mindre du bruker noe annet enn heltall for å indeksere.