Déterminer la taille du tableau dans l'initialiseur du constructeur

Vous les gens ont tellement d'être trop compliqué. Bien sûr, vous pouvez le faire en C++. C'est bien pour lui d'utiliser un tableau normal pour plus d'efficacité. Un vecteur n'a de sens que s'il ne connaît pas la taille du tableau à l'avance, c'est à dire, il doit croître avec le temps.

Si vous pouvez connaître la taille de la matrice d'un niveau plus élevé dans la chaîne, basé sur un modèle de classe est le plus facile, car il n'y a pas d'allocation dynamique et aucune chance de fuites de mémoire:

template < int ARRAY_LEN > //you can even set to a default value here of C++'11

class MyClass
  {   
  int array[ARRAY_LEN]; //Don't need to alloc or dealloc in structure!  Works like you imagine!   
  }

//Then you set the length of each object where you declare the object, e.g.

MyClass<1024> instance; //But only works for constant values, i.e. known to compiler

Si vous ne pouvez pas savoir la longueur au lieu de vous déclarer l'objet, ou si vous souhaitez réutiliser le même objet de différentes longueurs, ou vous devez accepter une longueur inconnue, alors vous devez procéder à votre constructeur et de les libérer dans votre destructeur... (et, en théorie, assurez-vous toujours qu'il a travaillé...)

class MyClass
  {
  int *array;

  MyClass(int len) { array = calloc(sizeof(int), len); assert(array); }   
  ~MyClass() { free(array); array = NULL; } //DON'T FORGET TO FREE UP SPACE!
  }

Tu ne comprends pas il n'y a pas besoin d'utiliser de vecteur, si l'on veut utiliser des tableaux, c'est une question d'efficacité, par exemple, moins d'espace, pas de temps de copie (dans ce cas, s'il est manipulé correctement, il n'est même pas besoin de supprimer le tableau à l'intérieur d'un destructeur), etc. wichever raisons.

la réponse correcte est: (cité)

class Class
{
   int* array;
   Class(int x) : array(new int[x]) {};
};

N'essayez pas de forcer une utilisation non optimale des solutions de rechange ou vous serez confus programmeurs inexpérimentés

Désolé pour necroing ce vieux fil.
Il est en fait un moyen de trouver la taille de la matrice au moment de la compilation. Il va quelque chose comme ceci:

#include <cstdlib>

template<typename T>
    class Class
    {
        T* _Buffer;

        public:
        template<size_t SIZE>
            Class(T (&static_array)[SIZE])
            {
                _Buffer = (T*)malloc(sizeof(T) * SIZE);

                memcpy(_Buffer, static_array, sizeof(T) * SIZE);
            }

            ~Class()
            {
                if(_Buffer)
                {
                    free(_Buffer);
                    _Buffer = NULL;
                }
            }
    };

int main()
{
    int int_array[32];
    Class<int> c = Class<int>(int_array);

    return 0;
}

Alternativement, si vous détestez à malloc /nouveau, puis vous pouvez créer une taille basé sur un modèle de classe à la place. Cependant, je ne vous le recommande vraiment et la syntaxe est assez moche.

#include <cstdio>

template<typename T, size_t SIZE>
    class Class
    {
        private:
            T _Array[sz];
        public:
            Class(T (&static_array)[SIZE])
            {
                memcpy(_Array, static_array, sizeof(T) * SIZE);
            }
    };

int main()
{
    char int_array[32];
    Class<char, sizeof(int_array)> c = Class<char, sizeof(int_array)>(int_array);
    return 0;
}

De toute façon, j'espère que cela a été utile 🙂

Vous ne pouvez pas le faire en C++ - utiliser un std::vector à la place:

#include <vector>

struct A {
   std::vector <int> vec; 
   A( int size ) : vec( size ) {
   }
};

Deux options:

Utiliser std::vector. Il est ainsi facile de re-dimensionnement de la matrice.

Utiliser std::tr1::array. Cela a un statique de la taille.

Les deux peuvent être correctement initialisé dans le constructeur de l'initialiseur de la liste.