Atxmega: Verschiedene Größen eines Arrays in Objekten

[Jens (Gast)]

Hallo,

ich habe in einer Klasse ein Array und möchte beim Übersetzen - nicht 
zur Laufzeit! - das jedes Objekt seine eigene Arraygröße hat.

Beispiel:

class TestKlasse{
  public:
    TestKlasse(size);

    unsigned int arr[???];  //Mit new arbeiten?
};

TestKlasse obj1(100);

Muss ich da mit new arbeiten? Das will ich eigentlich vermeiden..

Danke für die Hilfe :)

[Wolfgang (Gast)]

Jens schrieb:
> Muss ich da mit new arbeiten? Das will ich eigentlich vermeiden..

Dann lege eine feste Arraygröße fest.

Irgendwoher muss der Speicher schließlich kommen.

[Rolf M. (rmagnus)]

Jens schrieb:
> class TestKlasse{
>   public:
>     TestKlasse(size);
>
>     unsigned int arr[???];  //Mit new arbeiten?
> };
>
> TestKlasse obj1(100);

template <size_t S>
class TestKlasse
{
    //...
    unsigned int arr[S];
};

TestKlasse<100> obj1;

[Carl D. (jcw2)]

Dazu könnte man Templates benutzen:

template<int SIZE> class TestKlasse{
  public:
    TestKlasse();

    unsigned int arr[SIZE];
};

TestKlasse<100> obj1;
TestKlasse<50>  obj2;

Damit schreibt man den Code einmal und alles andere verwaltet der 
Compiler. Sollte dieser nicht allzu doof sein, wird er nur Code-Teile, 
die wirklich von SIZE abhängig sind, in mehreren Instanzen anlegen.

Verdammt, schon wieder einer schneller ;-)

[Jens (Gast)]

Nun, aber das eine Objekt braucht vielleicht 100 Felder, das andere nur 
10.

Die Speichergröße möchte ich zum Zeitpunkt der Übersetzung für jedes 
Objekt festlegen, aber nicht nacher zur Laufzeit.

[Jens (Gast)]

Das ist ja ganz schön verwirrend mit den ganzen <>...
Aber ich habs fast!

Wie kann ich die Tempate Methoden untereinandere sich gegenseitig 
aufrufen lassen?

template<int SIZE> class TestKlasse{
  public:
    TestKlasse();
    void M1();
    void M2();

    unsigned int arr[SIZE];
};

template<int SIZE> 
void TestKlasse<SIZE>::M1(){
}
 
template<int SIZE> 
void TestKlasse<SIZE>::M2(){
  M2();//?????????????????????????????????????????
}

TestKlasse<100> obj1;
TestKlasse<50>  obj2;

[Dr. Sommer (Gast)]

Jens schrieb:
> template<int SIZE>
> void TestKlasse<SIZE>::M2(){
>   M2();//?????????????????????????????????????????
> }

So ist das schon richtig... Aber verwende "size_t SIZE" und nicht "int 
SIZE", dann ist das portabler, und funktioniert z.B. auch auf x86_64 
korrekt.

[Carl D. (jcw2)]

Jens schrieb:
> Wie kann ich die Tempate Methoden untereinandere sich gegenseitig
> aufrufen lassen?
>
>

> template<int SIZE> class TestKlasse{
>   public:
>     TestKlasse();
>     void M1();
>     void M2();
> 
>     unsigned int arr[SIZE];
> };
> 
> template<int SIZE>
> void TestKlasse<SIZE>::M1(){
> }
> 
> template<int SIZE>
> void TestKlasse<SIZE>::M2(){
>   M2();//?????????????????????????????????????????
> }
> 
> TestKlasse<100> obj1;
> TestKlasse<50>  obj2;
>

falls du in M2() M1() rufen wolltest, dann geht das.
So wie geschrieben, gibt es nur einen Stack-Überlauf.
Und wie schon oben geschrieben, wenn eine der Methoden tatsächlich von 
SIZE abhängt, dann gibt es die eben mehrfach und die jeweils richtige 
wird gerufen.

Zu der <>-Verwirrung: die Zeit, die man in ein vernüftig gebaute 
Template-Klasse investiert, kommt bei der Benutzung schnell wieder 
zurück. Man kann auch den Typ der Array-Element offen lassen:

template<typename T, size_t SIZE> class TestKlasse{
  public:
    TestKlasse();
    void M1();
    void M2();

    T arr[SIZE];
};

template<typename T, size_t SIZE> 
void TestKlasse<SIZE>::M1(){
}
 
template<typename T, size_t SIZE> 
void TestKlasse<SIZE>::M2() {
    M1();
}

TestKlasse<uint8_t,100> obj1;
TestKlasse<double,50>  obj2;