Questo ++ classe contenente una matrice di dimensione variabile C usare allocazione dinamica della memoria?

Question

Fa fare qualcosa di simile allocazione dinamica della memoria serve?

template <class T, int _size> 
class CArray 
{ 
public:
    ... 
private:
    T m_data[_size]; 
};

Qualcuno può spiegarmi cosa sta succedendo dietro le quinte quando creo l'oggetto?

CArray<SomeObject, 32> myStupidArray;

Answer 1

Come già detto in altre risposte, i modelli sono valutati al momento della compilazione. Se siete interessati potete avere g ++ sputare gerarchia delle classi in cui è possibile verificare la sua dimensione:

template <class T, int _size>
class CArray
{
public:
private:
  T m_data[_size];
};

int main(int argc, char **argv) {
  CArray<int, 32> myStupidArray1;
  CArray<int, 8> myStupidArray2;
  CArray<int, 64> myStupidArray3;
  CArray<int, 1000> myStupidArray4;
}

Compila con -fdump-class-hierarchy:

g++ -fdump-class-hierarchy blah.cc

Ci dovrebbe essere un file chiamato blah.cc.t01.class nella directory corrente:

Class CArray<int, 32>
   size=128 align=4
   base size=128 base align=4
CArray<int, 32> (0x40be0d80) 0

Class CArray<int, 8>
   size=32 align=4
   base size=32 base align=4
CArray<int, 8> (0x40be0e80) 0

Class CArray<int, 64>
   size=256 align=4
   base size=256 base align=4
CArray<int, 64> (0x40be0f80) 0

Class CArray<int, 1000>
   size=4000 align=4
   base size=4000 base align=4
CArray<int, 1000> (0x40be6000) 0

Answer 2

No, sarà assegnata sul posto (ad esempio sia in pila, o come parte di un oggetto contenente).

Con i modelli i parametri vengono valutati al momento della compilazione in modo che il codice diventa efficace;

class CArray 
{ 
public:
    ... 
private:
    SomeObject m_data[32]; 
};

Answer 3

Modelli vengono valutati al momento della compilazione, in modo m_data [_size] è compilato come m_data [32].

Answer 4

No, non fa uso di allocazione dinamica della memoria. Il compilatore sa quanta memoria deve essere allocata, si è deciso al momento della compilazione, non in fase di esecuzione.

Non ha alcun senso per spiegare i modelli C ++ qui, sono spiegati molto bene in altri pagine, come nel C ++ faq lite .

Answer 5

La dimensione dell'array è noto al momento della compilazione, così no, non sarà utilizzato allocazione dinamica della memoria qui. Se si dichiara la matrice in un ambito funzione allora sarà messa in pila come qualsiasi altro tipo di oggetto.

Quando si definisce oggetti variabili di dimensioni come questo, ciò che sta realmente accadendo è che il compilatore sta costruendo una definizione di classe 'di ordine'. Ti basta utilizzare una definizione di classe che contiene 'T m_data [32]' in esso.

Answer 6

1- I modelli sono valutati solo in fase di compilazione. Quindi questo array sarà di dimensioni 32

2- Non è possibile creare una matrice nello stack utilizzando una variabile, deve essere una costante che può essere valutata al momento della compilazione, altrimenti è possibile utilizzare nuovi (o malloc)

Answer 7

allocazione dinamica della memoria si verifica in genere quando si chiama l'operatore new (o uno dei suoi amici). Questo alloca un blocco di memoria da una riserva memoria comunemente indicato come un cumulo. Ricordate che a differenza di allocazione statica, il compilatore non prendersi cura di libera-zione della memoria e quindi bisogna farlo manualmente utilizzando l'operatore delete (o una versione adatta di essi).