Como inicializar memória com novo operador em C ++?

Estou apenas começando a entrar em C ++ e quero pegar alguns bons hábitos. Se eu acabei de alocar uma matriz de tipos intcom o newoperador, como posso inicializá-los todos para 0 sem repetir todos eles? Devo apenas usar memset? Existe uma maneira "C ++" de fazer isso?

É um recurso surpreendentemente pouco conhecido do C ++ (como evidenciado pelo fato de que ninguém deu isso como resposta ainda), mas na verdade possui uma sintaxe especial para inicializar um array com valor:

new int[10]();

Observe que você deve usar os parênteses vazios - não é possível, por exemplo, usar (0)ou qualquer outra coisa (é por isso que isso é útil apenas para inicialização de valor).

Isso é explicitamente permitido pela ISO C ++ 03 5.3.4 [expr.new] / 15, que diz:

Uma nova expressão que cria um objeto do tipo Tinicializa esse objeto da seguinte maneira:

...

• Se o novo inicializador for do formato (), o item será inicializado por valor (8.5);

e não restringe os tipos para os quais isso é permitido, enquanto o (expression-list)formulário é explicitamente restrito por outras regras na mesma seção, de forma que não permita tipos de matriz.

Supondo que você realmente deseja uma matriz e não um std :: vector, a "maneira C ++" seria esta

#include <algorithm> 

int* array = new int[n]; // Assuming "n" is a pre-existing variable

std::fill_n(array, n, 0); 

Mas lembre-se de que, na verdade, isso ainda é apenas um loop que atribui cada elemento a 0 (realmente não há outra maneira de fazer isso, exceto uma arquitetura especial com suporte no nível do hardware).

Há um número de métodos para alocar uma matriz do tipo intrínseco e todos esses métodos estão corretos, apesar de qual escolher, depende ...

Inicialização manual de todos os elementos em loop

int* p = new int[10];
for (int i = 0; i < 10; i++)
{
    p[i] = 0;
}

Usando a std::memsetfunção de<cstring>

int* p = new int[10];
std::memset(p, 0, sizeof(int) * 10);

Usando o std::fill_nalgoritmo de<algorithm>

int* p = new int[10];
std::fill_n(p, 10, 0);

Usando std::vectorcontêiner

std::vector<int> v(10); // elements zero'ed

Se C ++ 0x estiver disponível, usando os recursos da lista do inicializador

int a[] = { 1, 2, 3 }; // 3-element static size array
vector<int> v = { 1, 2, 3 }; // 3-element array but vector is resizeable in runtime

Se a memória que você está alocando for uma classe com um construtor que faz algo útil, o operador new chamará esse construtor e deixará seu objeto inicializado.

Mas se você estiver alocando um POD ou algo que não tenha um construtor que inicialize o estado do objeto, não poderá alocar memória e inicializá-la com o operador new em uma operação. No entanto, você tem várias opções:

1) Use uma variável de pilha. Você pode alocar e inicializar por padrão em uma etapa, assim:

int vals[100] = {0};  // first element is a matter of style

2) use memset(). Observe que, se o objeto que você está alocando não for um POD , definir incorretamente é uma má idéia. Um exemplo específico é que, se você configurar uma classe que possui funções virtuais, você explodirá a tabela e deixará seu objeto em um estado inutilizável.

3) Muitos sistemas operacionais têm chamadas que fazem o que você deseja - aloque em uma pilha e inicialize os dados em algo. Um exemplo do Windows seriaVirtualAlloc()

4) Geralmente é a melhor opção. Evite ter que gerenciar a memória você mesmo. Você pode usar contêineres STL para fazer praticamente tudo o que faria com a memória bruta, incluindo alocar e inicializar tudo de uma só vez:

std::vector<int> myInts(100, 0);  // creates a vector of 100 ints, all set to zero

Sim existe:

std::vector<int> vec(SIZE, 0);

Use um vetor em vez de uma matriz alocada dinamicamente. Os benefícios incluem não ter que se preocupar em excluir explicitamente a matriz (ela é excluída quando o vetor fica fora do escopo) e também que a memória é excluída automaticamente, mesmo se houver uma exceção lançada.

Edit: Para evitar mais downvotes drive-by de pessoas que não se preocupam em ler os comentários abaixo, devo deixar mais claro que essa resposta não diz que vetor é sempre a resposta certa. Mas com certeza é uma maneira mais C ++ do que "manualmente", certificando-se de excluir uma matriz.

Agora, com o C ++ 11, também existe o std :: array que modela uma matriz de tamanho constante (vetor vs capaz de crescer). Também existe std :: unique_ptr que gerencia uma matriz alocada dinamicamente (que pode ser combinada com a inicialização conforme respondido em outras respostas a esta pergunta). Qualquer uma dessas maneiras é mais C ++ do que manipular manualmente o ponteiro para a matriz, IMHO.

std::fillé uma maneira. Leva dois iteradores e um valor para preencher a região. Esse, ou o loop for, (suponho) seria a maneira mais C ++.

Para definir uma matriz de tipos inteiros primitivos como 0 especificamente, memseté bom, embora possa levantar sobrancelhas. Considere também calloc, embora seja um pouco inconveniente usar o C ++ por causa do elenco.

Da minha parte, eu quase sempre uso um loop.

(Não gosto de adivinhar as intenções das pessoas, mas é verdade que std::vectortodas as coisas são iguais, preferível a usar new[].)

você sempre pode usar o memset:

int myArray[10];
memset( myArray, 0, 10 * sizeof( int ));

Normalmente, para listas dinâmicas de itens, você usa a std::vector.

Geralmente, eu uso o memset ou um loop para alocação dinâmica de memória bruta, dependendo de quão variável eu prevejo que essa área de código seja no futuro.