'New' e 'delete' estão sendo preteridos em C ++?

Eu me deparei com um questionário que envolvia declaração de matriz com tamanhos diferentes. A primeira coisa que me veio à mente é que eu precisaria usar a alocação dinâmica com o newcomando, assim:

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

No entanto, vi que uma das soluções permitia o seguinte caso:

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

Depois de um pouco de pesquisa, li que o g ++ permite isso, mas ele me fez pensar: em quais casos é necessário usar a alocação dinâmica? Ou será que o compilador traduz isso como alocação dinâmica?

A função de exclusão está incluída. Observe, no entanto, que a pergunta aqui não é sobre vazamentos de memória.

Nenhum trecho que você mostra é um código C ++ moderno e idiomático.

newe delete(e new[]e delete[]) não são preteridos no C ++ e nunca serão. Eles ainda são o caminho para instanciar objetos alocados dinamicamente. No entanto, como você sempre deve combinar a newcom a delete(e a new[]com a delete[]), é melhor mantê-las nas classes (biblioteca) que garantem isso para você. Consulte Por que os programadores de C ++ devem minimizar o uso de 'new'? .

Seu primeiro trecho usa um "nu" new[]e nunca delete[]é a matriz criada. Isso é um problema. std::vectorfaz tudo o que você precisa aqui muito bem. Ele usará alguma forma de newbastidores (não vou me aprofundar nos detalhes da implementação), mas, para todos os que você precisa saber, é uma matriz dinâmica, mas melhor e mais segura.

Seu segundo snippet usa "VLAs (Variable Length Arrays)", um recurso C que alguns compiladores também permitem no C ++ como uma extensão. Diferentemente new, os VLAs são essencialmente alocados na pilha (um recurso muito limitado). Mais importante, porém, eles não são um recurso padrão do C ++ e devem ser evitados porque não são portáteis. Eles certamente não substituem a alocação dinâmica (ou seja, heap).

Bem, para iniciantes, new/ deletenão está sendo preterido.

No seu caso específico, eles não são a única solução. O que você escolhe depende do que ficou oculto no seu comentário "faça algo com a matriz".

Seu segundo exemplo usa uma extensão VLA não padrão que tenta ajustar a matriz na pilha. Isso tem certas limitações - ou seja, tamanho limitado e a incapacidade de usar essa memória depois que a matriz sai do escopo. Você não pode movê-lo, ele "desaparecerá" depois que a pilha se desfazer.

Portanto, se seu único objetivo é fazer uma computação local e depois jogar os dados fora, pode realmente funcionar bem. No entanto, uma abordagem mais robusta seria alocar a memória dinamicamente, de preferência com std::vector. Dessa forma, você tem a capacidade de criar espaço para exatamente quantos elementos precisar, com base em um valor de tempo de execução (que é o que estamos fazendo o tempo todo), mas ele também se limpa muito bem, e você pode movê-lo deste escopo se você quiser manter a memória em uso para mais tarde.

Circulando de volta ao começo, vector vai provavelmente usar newalgumas camadas mais profundas, mas você não deve se preocupar com isso, como a interface que apresenta é muito superior. Nesse sentido, usar newe deletepode ser considerado desencorajado.

Seus segundos exemplos usam VLAs ( Arrays de Comprimento Variável), que são realmente um recurso C99 ( não C ++!), Mas, no entanto, são suportados pelo g ++ .

Veja também esta resposta .

Observe que as matrizes de comprimento variável são diferentes de new/ deletee não as "preterem" de forma alguma.

Esteja ciente de que os VLAs não são ISO C ++.

O C ++ moderno fornece maneiras mais fáceis de trabalhar com alocações dinâmicas. Os ponteiros inteligentes podem cuidar da limpeza após exceções (que podem ocorrer em qualquer lugar, se permitido) e retornos antecipados, assim que as estruturas de dados referenciadas ficarem fora do escopo, portanto, faça sentido usá-las:

  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();

No C ++ 14, você também pode escrever

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

isso parece ainda melhor e evitaria o vazamento de memória se a alocação falhar. No C ++ 20, você deve conseguir fazer o máximo

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

isso para mim ainda não é compilado no momento da escrita com o gcc 7.4.0. Nestes dois exemplos, também usamos em autovez de declaração de tipo à esquerda. Em todos os casos, use array como de costume:

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

Vazamentos de memória newe falhas de duplicação deletesão algo em que o C ++ é destruído por muitos anos, sendo o "ponto central" da argumentação para mudar para outras linguagens. Talvez seja melhor evitar.

new e delete não estão sendo preteridos.

Os objetos criados pelo novo operador podem ser passados ​​por referência. Os objetos podem ser excluídos usando delete.

new e delete são os aspectos fundamentais do idioma. A persistência de um objeto pode ser gerenciada usando new e delete. Definitivamente, essas não serão depreciadas.

A instrução array int [N] é uma maneira de definir um array. A matriz pode ser usada dentro do escopo do bloco de código anexo. Não pode ser passado como um objeto é passado para outra função.

O primeiro exemplo precisa de um delete[]no final, ou você terá um vazamento de memória.

O segundo exemplo usa o comprimento variável da matriz que não é suportado pelo C ++; que só permite constante-expressão de comprimento da matriz .

Nesse caso, é útil usar std::vector<>como solução; que agrupa todas as ações que você pode executar em uma matriz em uma classe de modelo.

A sintaxe se parece com C ++, mas o idioma é semelhante ao Algol60 antigo. Era comum ter blocos de código como este:

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

O exemplo pode ser escrito como:

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

Às vezes sinto falta disso nos idiomas atuais;)