Initialisation de la matrice sur le tas

Comment puis-je lancer manuellement les valeurs dans le tableau sur le tas?
Si le tableau est variable locale (dans la pile), il peut être fait très élégant et facile, comme ceci:

int myArray[3] = {1,2,3};

Malheureusement, d'après le code

int * myArray = new int[3];
myArray = {1,2,3};

génère une erreur de compilation

error: expected primary-expression before ‘{’ token
error: expected `;' before ‘{’ token

Dois-je utiliser le cycle, ou pas-si-bien-de manière élégante, comme c'?

myArray[0] = 1;
myArray[1] = 2;
myArray[2] = 3;
de la porte de votre exemple, vous voulez remplir les éléments du tableau 0 .. N, 1 .. N + 1. Une boucle for feraient très bien l'affaire. Quelle est votre intention?

OriginalL'auteur Radek Simko | 2010-12-31

  1. 4

    Ce qui est intéressant: Poussant un tableau dans un vecteur

    Toutefois, si cela n'est pas fait pour vous, essayez les opérations suivantes:

    #include <algorithm>
...


const int length = 32;

int stack_array[length] = { 0 ,32, 54, ... }
int* array = new int[length];

std::copy(array, array + length, &stack_array[0]);
    Vous avez fait une erreur, il devrait être std::copy(stack_array, stack_array+5, &array[0]);
    VLA (variable length array) n'est pas une partie de C++ standard
    VLAs en C++ donc -1

    OriginalL'auteur langerra.com

  2. 3

    Vous pouvez définir la constante de tableau, comme myConstArray[] = {1, 2, 3} et ne memcpy après new int[3].

    plus généralement, l'utilisation de std::copy pour copier des objets plutôt que des modèles de bits.
    Malheureusement, c'est inefficace, au mieux, et de l'impossible, au pire (si le type est une classe sans copier/affectation).
    Avec le type qui est une classe sans copier/affectation, il serait impossible d'utiliser la constante de tableau.
    Mais si ce sont de pointeur d'un objet à lui-même?

    OriginalL'auteur Nickolay Olshevsky

  3. 2

    {1,2,3} est très limité, de la syntaxe, spécifique au stade de la structure d'initialisation (apparemment C-gamme de style a été considéré comme l'un de trop). La seule chose que vous pouvez faire, c'est comme int x[] = {1,2,3}; ou int x[3] = {1,2,3};, mais vous ne pouvez pas le faire ni int x[3]; x={1,2,3}; ni utiliser {1,2,3} dans tout autre lieu.

    Si tu fais du C++, il est préférable d'utiliser quelque chose comme std::vector au lieu de C-style des tableaux, comme ils sont considérés comme dangereux par exemple, vous ne pouvez pas savoir leur taille et devez les supprimer avec un delete[], pas normale delete. Avec std::vector, vous aurez toujours le même problème d'initialisation. Si j'ai utilisé une telle initialisation beaucoup, je serait probablement créer une macro de l'attribution d'une dummy variable locale et de la copie de la mémoire de destination.

    EDIT: Vous pouvez aussi faire comme ceci (std::vector toujours préférable):

    int* NewArray(int v1, int v2, int v3) { /* allocate and initialize */ }
int* p = NewArray(1,2,3);

    mais vous aurez à remplacer la fonction avec un nombre variable d'arguments, ou de l'utilisation va_arg qui est, encore une fois, dangereux.

    EDIT2: Ma réponse n'est valable que pour le C++03, que les autres personnes mentionnées au C++0x a quelques améliorations à ce.

    OriginalL'auteur Roman L

  4. 0

    C++0x standard a le type spécial appelé initializer_list et la syntaxe particulière (type d'expression {1, 2, 3} est std::initializer_list<int>). std::vector et std::array ont les constructeurs, donc vous pouvez écrire vector<int> v = {1, 2, 3}.

    Il n'y a pas de bonne solution en C++98/C++03.

    OriginalL'auteur crazylammer

  5. 0

    Si vous voulez une réponse générale qui fonctionne pour tous types de, ce que vous faites est:

    1. malloc() ou l'opérateur new() pour créer un tableau de non initialisée de stockage de la bonne longueur, calculé par nelts * sizeof(T)

    2. Faire un tableau constitué de l'argument pour un constructeur pour chaque élément.

    3. Appliquer le constructeur de placement de la forme de chaque élément à l'aide de l'argument correspondant.

    Cela ne fonctionne que si le même constructeur va faire pour chaque élément. Si non, vous aurez besoin d'un plus compliqué structure de données et un algorithme pour choisir le bon constructeur pour chaque élément.

    Un cas particulier est d'utiliser un tableau des éléments réels et d'utiliser le constructeur de copie et un cas spécial, c'est que, quand le type est un POD et vous pouvez simplement utiliser memcpy pour construire le beaucoup à la fois.

    Si le constructeur prend deux arguments, vous aurez besoin d'écrire un initiateur de la procédure (wrapper). Par exemple:

    pair<double> init_data[] = {make_pair(1.0,0.0), make_pair(3.0,4.0)};
void init(void *p, pair<double> d) { new (p) complex(d.first, d.second); }

    et l'utiliser à la place de tout nouveau(p).

    OriginalL'auteur Yttrill