Czy istnieje sposób na statyczną inicjalizację dynamicznie przydzielanej tablicy w C++?

Question

W C++, mogę statycznie zainicjować tablicę, np .:

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

Czy istnieje prosty sposób zainicjować dynamicznie przydzielonego tablicy do zestawu natychmiastowych wartości?

int *p = new int[3]; 
p = { 1, 2, 3 }; // syntax error 

... Czy muszę koniecznie skopiować te wartości ręcznie?

Answer 1

Ty można w C++ 0x:

int* p = new int[3] { 1, 2, 3 }; 
... 
delete[] p; 

Ale lubię wektory lepiej:

std::vector<int> v { 1, 2, 3 }; 

Jeśli nie masz C++ 0x kompilator, impuls może pomóc:

#include <boost/assign/list_of.hpp> 
using boost::assign::list_of; 

vector<int> v = list_of(1)(2)(3); 

Answer 2

Nie, nie można inicjować dynamicznie utworzonej tablicy w ten sam sposób.

W większości przypadków używasz alokacji dynamicznej w sytuacjach, w których statyczna inicjalizacja w zasadzie nie ma sensu. Na przykład, gdy masz tablice zawierające tysiące przedmiotów. To zwykle nie jest wielka sprawa.

Answer 3

Musisz przypisać każdy element tablicy dynamicznej jawnie (np for lub while)

Jednak składnia int *p = new int [3](); ma zainicjować wszystkie elementy do 0 (inicjalizacji wartości $ 8,5/5)

Answer 4

Nigdy nie słyszałem o czymś takim to możliwe, że byłoby miło mieć.

Należy pamiętać, że przy inicjalizacji tablicy w kodzie tamtędy

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

..... tylko zyskuje Ci łatwiejsze pisanie kodu, a nie wydajność. W końcu procesor wykona zadanie przypisania wartości do tablicy, tak czy inaczej.

Answer 5

Korzystanie pomocnik zmienna:

const int p_data[] = {1, 2, 3}; 
int* p = (int*)memcpy(new int[3], p_data, sizeof(p_data)); 

lub jedna linia

int p_data[] = {1, 2, 3}, *p = (int*)memcpy(new int[3], p_data, sizeof(p_data)); 

Answer 6

Aby uniknąć niekończących push_backs, zazwyczaj zainicjować tr1::array i stworzyć std::vector (lub innego std Container) z wynik;

const std::tr1::array<T, 6> values = {T(1), T(2), T(3), T(4), T(5), T(6)}; 
std::vector <T> vec(values.begin(), values.end()); 

Jedyną uciążliwością jest to, że musisz podać liczbę wartości jawnie.

Można to oczywiście zrobić bez użycia numeru tr1::array;

const T values[] = {T(1), T(2), T(3), T(4), T(5), T(6)}; 
std::vector <T> vec(&values[0], &values[sizeof(values)/sizeof(values[0])]); 

Przez ciebie nie musisz podawać liczby elementów jawnie, wolę pierwszą wersję.