Инициализация массива при создании его через new - C/C++

ОСТОРОЖНО! ЭТО ТРОЛЛЬ!
Дискуссия заморожена, решение окончательное.
— Кодт

Как инициализировать массив при его создании через new?

например

что-то вроде :

int * i=NULL;

i=new int[5]={1,2,3};

Здравствуйте, Аноним, Вы писали:

А>Как инициализировать массив при его создании через new?

Напрямую — никак. Если типы простые — то создавать массив и потом пройтись по нему в цикле и инициализировать каждый элемент.
Если элементы массива являются объектами каких-либо классов — то создать массив указателей, потом пройтись по нему в цикле и создать каждый элемент по-отдельности, через new, передавая ему нужные параметры.

Здравствуйте, Аноним, Вы писали:

А>

А>i=new int[5]={1,2,3};
А>

Не совсем понятно, "5" в этом коде -- константа? А "1, 2, 3"--?
И типы какие? Стандартные или классы?

В общем случае, если ты STL пользуешься, то можно как-то так:

template<typename T, typename TIter>
void initWith( std::vector<T>&dst, int dstCount, TIter from, TIter to )
{
    assert( dstCount >= 0 );
    dst.clear();
    dst.reserve( dstCount );
    int count = 0;
    for( TIter i = from; i != to; ++i ) {
        assert( dstCount >= ++count );
        dst.push_back( *i );
    }
    dst.resize( dstCount );
}
template<typename T, typename TIter>
void initWith( std::vector<T>&dst, int dstCount, TIter from, int initCount )
{
    initWith( dst, dstCount, from, from+initCount );
}

void foo() 
{
    std::vector<int> array;
    static const int initValues[] = { 1, 2, 3 };
    initWith( array, 5, initValues, lengthof( values ) );
}

Ну а если другая библиотека (за что я только за), то аналогичные конструкции...

Все эмоциональные формулировки не соотвествуют действительному положению вещей и приведены мной исключительно "ради красного словца". За корректными формулировками и неискажённым изложением идей, следует обращаться к их автором или воспользоваться поиском

Здравствуйте, Erop, Вы писали:

E> std::vector<int> array;
E> static const int initValues[] = { 1, 2, 3 };
E> initWith( array, 5, initValues, lengthof( values ) );
В С++0х (сейчас только в gcc 4.4+) поимеем std::initializer_list и, как следствие, std::vector<int> array = { 1,2,3 }.

Здравствуйте, Аноним, Вы писали:

А>что-то вроде :

А>

А>int * i=NULL;

А>i=new int[5]={1,2,3};
А>

1. подобные задачи принято решать вектором.
2. если уж очень нужно — есть такая штука как inplace new.
Т.е. ты можешь выделить неинициализированную память под весь массив, а затем пройтись по нему и проинициализировать его вручную, new(i+000)(1);
Кстати — NULL — C'шная приблуда. С++ style == 0

Здравствуйте, Аноним, Вы писали:

А>Как инициализировать массив при его создании через new?

А>например

А>что-то вроде :

А>

А>int * i=NULL;

А>i=new int[5]={1,2,3};
А>

Для 'new[]' поддерживается только один вид инициализатора: '()'. Т.е. можно сделать 'i = new int[5]()' и получить обнуленный массив в результате. Других иницализаторов не поддерживается, т.е. "инициализацию" придется делать потом присваиванием.

Здравствуйте, NikeByNike, Вы писали:

NBN>Кстати — NULL — C'шная приблуда. С++ style == 0

Соврешенно нет. Предание старое, откуда ноги растут — неизвестно, но — нет.

Здравствуйте, Андрей Тарасевич, Вы писали:

АТ>Здравствуйте, NikeByNike, Вы писали:

NBN>>Кстати — NULL — C'шная приблуда. С++ style == 0

АТ>Соврешенно нет. Предание старое, откуда ноги растут — неизвестно, но — нет.

В молодости читал рассуждения на тему типов, типа NULL суть есть указатель вроде (void *)0, а использование вместо этого (0) должно бы по уму вызывать предупреждение про преобразование целого в указатель, как в случае int* i = 1;
Но что-то там в С++ не срослось, и с 0 теперь можно

Здравствуйте, BigBoss, Вы писали:

NBN>>>Кстати — NULL — C'шная приблуда. С++ style == 0

АТ>>Соврешенно нет. Предание старое, откуда ноги растут — неизвестно, но — нет.

BB>В молодости читал рассуждения на тему типов, типа NULL суть есть указатель вроде (void *)0, а использование вместо этого (0) должно бы по уму вызывать предупреждение про преобразование целого в указатель, как в случае int* i = 1;
BB>Но что-то там в С++ не срослось, и с 0 теперь можно

Хм... Может я понял мысль, но в реальности все несколько наоборот. В С можно и '(void *) 0' и целочисленный '0'. В С++ же можно только целочисленный '0'.

Здравствуйте, Андрей Тарасевич, Вы писали:

АТ>Для 'new[]' поддерживается только один вид инициализатора: '()'. Т.е. можно сделать 'i = new int[5]()' и получить обнуленный массив в результате. Других иницализаторов не поддерживается, т.е. "инициализацию" придется делать потом присваиванием.

Да эта форма инициализации, мне инвестна. Можно даже вроде не только '()' но и (33)

Хорошо, с нью все так, ну а с ptr'ом ?

Типа int * ia;

ia=int[]={1,2,3,4,5};
ia=(int[]={10,10,11,20});

Да похоже что никак. Жаль. Придется потрахаться немного по больше.

Спасибо.

Здравствуйте, Erop, Вы писали:

А>>

А>>i=new int[5]={1,2,3};
А>>

E>Не совсем понятно, "5" в этом коде -- константа? А "1, 2, 3"--?
E>И типы какие? Стандартные или классы?

E>В общем случае, если ты STL пользуешься, то можно как-то так:[c]template<typename T, typename TIter>

Совсем народ от этох "надстроек" отупел.

Какие типы — int.

Вектора, и пр. щит, не подходит — медленно.

Превратили си в скрипты, и рады.

Строка это последовательность байтов, с длинной и всё. Какие еще там супер типы string, которые в 10 раз снижают производительность программ. Нахрена это индуские вектора?!

Что размер не поменять? Да какое волшебство вы ждете от них?

Перестаньте использовать то чего не понимаете, начните отличаться, от индусов.

АТ>Соврешенно нет. Предание старое, откуда ноги растут — неизвестно

Вполне известно. Из Страуструпа и его книги "Язык программирования С++". Конечно он не так уж категоричен, но говорит что-то вроде такого:

In C, it has been popular to define a macro NULL to represent the zero pointer. Because of
C++’s tighter type checking, the use of plain 0, rather than any suggested NULL macro, leads to
fewer problems. If you feel you must define NULL , use
const int NULL = 0 ;
The const qualifier (§5.4) prevents accidental redefinition of NULL and ensures that NULL can be
used where a constant is required.

Здравствуйте, NikeByNike, Вы писали:

NBN>Здравствуйте, Аноним, Вы писали:

А>>что-то вроде :

А>>

А>>int * i=NULL;

А>>i=new int[5]={1,2,3};
А>>

NBN>1. подобные задачи принято решать вектором.
NBN>2. если уж очень нужно — есть такая штука как inplace new.
NBN>Т.е. ты можешь выделить неинициализированную память под весь массив, а затем пройтись по нему и проинициализировать его вручную, new(i+000)(1);
NBN>Кстати — NULL — C'шная приблуда. С++ style == 0

А мне надо сотни тысяч раз в секунду! Ничего что я тут со своими глупыми задачами в вам умным пристаю?!

Вектор, это всего лишь навсего выделить новую память скопировать туда то что было — это типа обманка.

Скорость работы с такими массивами

int i[100];

и vector<int> iv;

Различается в дестяки раз. А памяти лишней сколько жрется.

А потом удивляются — 8 гигов и все мало.

NULL это ПРАВИЛЬНО и только так — для скриптовиков и 0 сойдет, понятно — но указатель это 64 бита или 128 как уменя, а 0 это только 32.

А>Да эта форма инициализации, мне инвестна. Можно даже вроде не только '()' но и (33)

Нет, как и сказал Андрей, только ().
А по поводу неудобства инициализации — есть такое. Видимо, в будущем это пофиксят при помощи нового синтаксиса инициализаторов для стандартных контейнеров или пользовательских классов. Синтаксиса не помню, но что нить вроде std::vector<int> a = {1,2,3,4,5};

Здравствуйте, Lorenzo_LAMAS, Вы писали:

АТ>>Соврешенно нет. Предание старое, откуда ноги растут — неизвестно

L_L>Вполне известно. Из Страуструпа и его книги "Язык программирования С++". Конечно он не так уж категоричен, но говорит что-то вроде такого:

L_L>

L_L>In C, it has been popular to define a macro NULL to represent the zero pointer. Because of
L_L>C++’s tighter type checking, the use of plain 0, rather than any suggested NULL macro, leads to
L_L>fewer problems. If you feel you must define NULL , use
L_L>const int NULL = 0 ;
L_L>The const qualifier (§5.4) prevents accidental redefinition of NULL and ensures that NULL can be
L_L>used where a constant is required.

У меня в архитектуре int 32 бита а указатель ( это адрес, для скриптовиков ) 128 бит. И что? '0' это 0... У меня по адресу ноль есть данные...

Что дальше? Ваш неучь Страуструп нихрена не понимает вообще в СИ и СИ++... Перестаньте читать идиотов.

Здравствуйте, Erop, Вы писали:

E>В общем случае, если ты STL пользуешься, то можно как-то так:

template<typename T, typename TIter>
E>void initWith( std::vector<T>&dst, int dstCount, TIter from, TIter to )
E>{
E>    assert( dstCount >= 0 );
E>    dst.clear();
E>    dst.reserve( dstCount );
E>    int count = 0;
E>    for( TIter i = from; i != to; ++i ) {
E>        assert( dstCount >= ++count );
E>        dst.push_back( *i );
E>    }
E>    dst.resize( dstCount );
E>}
E>template<typename T, typename TIter>
E>void initWith( std::vector<T>&dst, int dstCount, TIter from, int initCount )
E>{
E>    initWith( dst, dstCount, from, from+initCount );
E>}

E>void foo() 
E>{
E>    std::vector<int> array;
E>    static const int initValues[] = { 1, 2, 3 };
E>    initWith( array, 5, initValues, lengthof( values ) );
E>}

Зачем так сложно?

#define ARRAY_LENGTH(x) sizeof(x) / sizeof(x[0])

void foo()
{
  static const int initValues[] = { 1, 2, 3 };
  std::vector<int> array(initValues, initValies + ARRAY_LENGTH(initValues));
}

Здравствуйте, Аноним, Вы писали:

А>Совсем народ от этох "надстроек" отупел.

А>Какие типы — int.

А>Вектора, и пр. щит, не подходит — медленно.

А>Превратили си в скрипты, и рады.

А>Строка это последовательность байтов, с длинной и всё. Какие еще там супер типы string, которые в 10 раз снижают производительность программ. Нахрена это индуские вектора?!

Что размер не поменять? Да какое волшебство вы ждете от них?

А>Перестаньте использовать то чего не понимаете, начните отличаться, от индусов.

Тут недавно топик был — сравнивали производитьность рабтоы с вектором и просто с массивом. Так по тестам (проверенным несколькими людьми) оказалось что вектор быстрее работает)

А>У меня в архитектуре int 32 бита а указатель ( это адрес, для скриптовиков ) 128 бит. И что? '0' это 0... У меня по адресу ноль есть данные...

Что дальше? Ваш неучь Страуструп нихрена не понимает вообще в СИ и СИ++... Перестаньте читать идиотов.

Следуя вашему совету, я не должен был читать вашего дико бредового сообщения. Простите за грубость, конечно, но не пишите фигню и не указывайте мне, кого мне читать, а кого — нет. Я уж как-нибудь сам разберусь.
Чисто для справки, не знаю, сколько вам лет, но уверен, что Страуструп знал С тогда, когда вас на свете еще не было.

Здравствуйте, catBasilio, Вы писали:

А>>Перестаньте использовать то чего не понимаете, начните отличаться, от индусов.

B>Тут недавно топик был — сравнивали производитьность рабтоы с вектором и просто с массивом. Так по тестам (проверенным несколькими людьми) оказалось что вектор быстрее работает)

Неверные разультаты

, Причем заметьте, я даже и топик не читал — так как подругому и быть не может. 1000%

А>Скорость работы с такими массивами
А>int i[100];
А>и vector<int> iv;
А>Различается в дестяки раз. А памяти лишней сколько жрется.

Бред. Чтобы не писать такого больше, элементарно поглядите код вектора и что будет, если вы напишете std::vector<int> v(some_size);

А>А потом удивляются — 8 гигов и все мало.

Учите матчасть.

А>NULL это ПРАВИЛЬНО и только так — для скриптовиков и 0 сойдет, понятно — но указатель это 64 бита или 128 как уменя, а 0 это только 32.

Т.е., вы полагаете, что если вы
int * a = 0; то у вас занулится лишь часть битов, а часть — останутся неинициализированными? Да вы жжете, батенька. А еще и Страуструп у вас — "неучь"

	От:	Аноним
	Дата:	06.04.09 11:06
	Оценка:

От:	artem_korneev	https://www.linkedin.com/in/artemkorneev/
Дата:	06.04.09 13:13
Оценка:

	От:	Erop
	Дата:	06.04.09 20:31
	Оценка:

	От:	byleas
	Дата:	06.04.09 21:25
	Оценка:

	От:	NikeByNike
	Дата:	06.04.09 21:32
	Оценка:

	От:	Андрей Тарасевич
	Дата:	06.04.09 21:54
	Оценка:	6 (1)

	От:	Lorenzo_LAMAS
	Дата:	07.04.09 05:48
	Оценка:	1 (1) +1