Est-ce que «nouveau» et «supprimer» deviennent obsolètes en C ++?

Je suis tombé sur un quiz impliquant une déclaration de tableau de différentes tailles. La première chose qui m'est venue à l'esprit est que je devrais utiliser l'allocation dynamique avec la newcommande, comme ceci:

while(T--) {
   int N;
   cin >> N;
   int *array = new int[N];
   // Do something with 'array'
   delete[] array;
}

Cependant, j'ai vu que l'une des solutions permettait le cas suivant:

while(T--) {
    int N;
    cin >> N;
    int array[N];
    // Do something with 'array'
}

Après un peu de recherche, j'ai lu que g ++ le permet, mais cela m'a fait réfléchir, dans quels cas est-il alors nécessaire d'utiliser l'allocation dynamique? Ou est-ce que le compilateur traduit cela comme une allocation dynamique?

La fonction de suppression est incluse. Notez cependant que la question ici ne concerne pas les fuites de mémoire.

Aucun extrait que vous montrez n'est un code C ++ moderne idiomatique.

newet delete(et new[]et delete[]) ne sont pas obsolètes en C ++ et ne le seront jamais. Ils sont toujours le moyen d'instancier des objets alloués dynamiquement. Cependant, comme vous devez toujours faire correspondre un newavec un delete(et un new[]avec un delete[]), il est préférable de les conserver dans des classes (bibliothèque) qui vous garantissent cela. Voir Pourquoi les programmeurs C ++ devraient-ils minimiser l'utilisation de «nouveau»? .

Votre premier extrait de code utilise un "nu" new[]et puis jamais delete[]le tableau créé. C'est un problème. std::vectorfait tout ce dont vous avez besoin ici très bien. Il utilisera une certaine forme de newcoulisses (je ne plongerai pas dans les détails d'implémentation), mais pour tout ce que vous avez à faire, c'est un tableau dynamique mais meilleur et plus sûr.

Votre deuxième extrait utilise des "tableaux de longueur variable" (VLA), une fonctionnalité C que certains compilateurs autorisent également en C ++ comme extension. Contrairement aux newVLA, ils sont essentiellement alloués sur la pile (une ressource très limitée). Mais plus important encore, ils ne sont pas une fonctionnalité C ++ standard et doivent être évités car ils ne sont pas portables. Ils ne remplacent certainement pas l'allocation dynamique (c'est-à-dire le tas).

Eh bien, pour commencer, new/ deletene sont pas obsolètes.

Dans votre cas particulier, ce n'est pas la seule solution. Ce que vous choisissez dépend de ce qui a été caché sous votre commentaire "faire quelque chose avec le tableau".

Votre 2ème exemple utilise une extension VLA non standard qui essaie d'adapter le tableau sur la pile. Cela a certaines limites - à savoir une taille limitée et l'impossibilité d'utiliser cette mémoire après que le tableau soit hors de portée. Vous ne pouvez pas le déplacer, il "disparaîtra" après le déroulement de la pile.

Donc, si votre seul objectif est de faire un calcul local, puis de jeter les données, cela pourrait fonctionner correctement. Cependant, une approche plus robuste consisterait à allouer la mémoire dynamiquement, de préférence avec std::vector. De cette façon, vous avez la possibilité de créer de l'espace pour exactement autant d'éléments que vous en avez besoin en vous basant sur une valeur d'exécution (ce que nous recherchons tout au long), mais cela se nettoiera également bien et vous pourrez le déplacer de cette portée si vous souhaitez conserver la mémoire en cours d'utilisation pour plus tard.

En revenant au début, vous vector utiliserez probablement newquelques couches plus en profondeur, mais vous ne devriez pas vous en préoccuper, car l'interface qu'elle présente est bien supérieure. En ce sens, l'utilisation newet deletepeut être considérée comme découragée.

Vos deuxièmes exemples utilisent des tableaux de longueur variable (VLA), qui sont en fait une fonctionnalité C99 ( pas C ++!), Mais néanmoins pris en charge par g ++ .

Voir aussi cette réponse .

Notez que les tableaux de longueur variable sont différents de new/ deleteet ne les "déconseillent" en aucune façon.

Sachez également que les VLA ne sont pas ISO C ++.

Le C ++ moderne offre des moyens plus simples de travailler avec des allocations dynamiques. Les pointeurs intelligents peuvent prendre soin du nettoyage après les exceptions (qui peuvent se produire n'importe où si autorisé) et les retours précoces, dès que les structures de données référencées sortent du domaine, il peut donc être judicieux de les utiliser à la place:

  int size=100;

  // This construct requires the matching delete statement.
  auto buffer_old = new int[size];

  // These versions do not require `delete`:
  std::unique_ptr<int[]> buffer_new (new int[size]);
  std::shared_ptr<int[]> buffer_new (new int[size]); 
  std::vector<int> buffer_new (size);  int* raw_access = buffer_new.data();

A partir de C ++ 14, vous pouvez également écrire

auto buffer_new = std::make_unique<int[]>(size);

cela semble encore plus agréable et empêcherait une fuite de mémoire en cas d'échec de l'allocation. A partir de C ++ 20, vous devriez pouvoir faire autant que

auto a = std::make_shared<int[]>(size);

pour moi, cela ne se compile toujours pas au moment de l'écriture avec gcc 7.4.0. Dans ces deux exemples, nous utilisons également la autodéclaration de type à gauche. Dans tous les cas, utilisez le tableau comme d'habitude:

buffer_old[0] = buffer_new[0] = 17;

Les fuites de mémoire newet les plantages de doublés deletesont quelque chose que le C ++ a été critiqué pendant de nombreuses années, étant le "point central" de l'argumentation pour passer à d'autres langages. Peut-être préférable d'éviter.

new et delete ne sont pas obsolètes.

Les objets créés par le nouvel opérateur peuvent être passés par référence. Les objets peuvent être supprimés à l'aide de la suppression.

nouveau et supprimer sont les aspects fondamentaux de la langue. La persistance d'un objet peut être gérée en utilisant new et delete. Ceux-ci ne seront certainement pas dépréciés.

L'instruction - int array [N] est un moyen de définir un tableau. Le tableau peut être utilisé dans le cadre du bloc de code englobant. Il ne peut pas être transmis comme la façon dont un objet est passé à une autre fonction.

Le premier exemple a besoin d'un delete[]à la fin, ou vous aurez une fuite de mémoire.

Le deuxième exemple utilise une longueur de tableau variable qui n'est pas prise en charge par C ++; il autorise uniquement l'expression constante pour la longueur du tableau .

Dans ce cas, il est utile d'utiliser std::vector<>comme solution; qui encapsule toutes les actions que vous pouvez effectuer sur un tableau dans une classe de modèle.

La syntaxe ressemble à C ++, mais l'idiome est similaire à l'ancien Algol60 simple. Il était courant d'avoir des blocs de code comme celui-ci:

read n;
begin
    integer array x[1:n];
    ... 
end;

L'exemple pourrait s'écrire:

while(T--) {
    int N;
    cin >> N;
    {
        int array[N];
        // Do something with 'array'
    }
}

Cela me manque parfois dans les langues actuelles;)