Изменить размер массива. Удалить. Добавить элемент в массив. Увеличение массива. с++ Урок #59

[@SimpleCodeIT]

*Друзья, если вы решили изучать программирование и подписались на канал - рекомендую вам нажать колокольчик чтобы никогда не пропускать новые уроки!*

[@Альтернативноемнение-б7э]

void arrayAddFirst(int *&arr, int &size, int number) //добавить первый элемент { int *newArr = new int[size + 1]; newArr[0] = number; for (int i = 0; i < size; i++) { newArr[i + 1] = arr[i]; } size++; delete[] arr; arr = newArr; } void arrayDeleteFirst(int *&arr, int &size) //удалить первый элемент { size--; int *newArr = new int[size]; for (int i = 0; i < size; i++) { newArr[i] = arr[i + 1]; } delete[] arr; arr = newArr; } void arrayAddIndex(int *&arr, int &size, int number, int index) //добавить элемент в любое место { int *newArr = new int[size + 1]; for (int i = 0; i < size + 1; i++) if (i < index) { newArr[i] = arr[i]; } else if (i == index) { newArr[i] = number; } else if (i > index) { newArr[i] = arr[i - 1]; } size++; delete[] arr; arr = newArr; } void arrayDeleteIndex(int *&arr, int &size, int index) //удалить элемент из любого места { size--; int *newArr = new int[size]; for (int i = 0; i < size; i++) { if (i < index) { newArr[i] = arr[i]; } else if (i >= index) { newArr[i] = arr[i + 1]; } } delete[] arr; arr = newArr; }

[@kotinho7]

нужно двумерный массив обработать в отдельно функции, пытался по видеоуроку, ничего не получается, выдает ошибки: 1)declaration of 'arr' as array of references 2)expected ')' before ',' token 3)expected unqualified-id before 'int' . Можете помочь как реализовать мою задачу?

[@olexangrstetsiuk3092]

@@Альтернативноемнение-б7э , мои Вам аплодисменты за ,,медвежью услугу,, Наверное бы сегодня и не уснул перебирая в голове идеи с реализацией, особенно с возможностью вставить или удалить в любое место , и даже читая Ваш код не хватает сознания провернуть его в мыслях... Обязательно добавлю его в шпаргалки.

[@oleksa3125]

А нужно ли писать в конце функции push_back {.... newArr = nullptr; } поскольку мы потом не будем использовать указатель newArr или захотим использовать эту функцию повторно?

[@cheatack2141]

Я , кажется, не понял. Получается если использовать указатель на ссылку, которая ссылается на другой указатель, то это будет всё равно что передача указателя в функцию??? Я правильно понимаю??? Если всё так как я думаю, то урок можно считать и как урок по передаче динамического массива в функцию.

[@franciscrowley5731]

когда уже не получается смотреть все на скорости 2х)))

[@nivabul7871]

+ уже приходится пересматривать

[@naikvitlich1093]

Ох жиза бля

[@vitusink6445]

Другое дело рубить уголек в шахте... Тра-та-та-та отбойным молотком как из автомата :)))

[@ivan100kg]

Реально, впервые включил на обычную скорость, тот момент где указатель по ссылке передается) Такого приема не встречал в книжках, я бы раньше просто из функции вернул указатель и присвоил его к arr в main.

[@MelonHell]

я расширение в браузер поставил, смотрю на 3х

[@ВиталийСусский-я2м]

спасибо за тяжелый урок, до этого я думал что всю усваиваю на изи, но здесь мой мозг покинул орбиту ))

[@user12285]

+. я не могу запомнить

[@LevmurQ_Q]

Видео длится 26 минут. Смотрел его полтора часа.

[@ilyastasiuk4792]

Вот эта штука "*&" называется неконстантная ссылка. Она должна ссылаться на указатель, поскольку его адрес можно изменять. И вот с её помощью можно делать то же, что и с указателем, только она работает не напрямую с тем, на что ссылается, а через адрес другого указателя. И поэтому с помощью такой штуки можно еще и заодно изменить адрес другого указателя. Это кто не понял.

[@Kokurorokuko]

я всё равно не понял)

[@АндрейВербицкий-м4ж]

Те кто не понял, это тем более не поймут)

[@temshik.invalid]

Андрей Вербицкий я по его комменту понял)

[@illyaustymenko5184]

Понял, спасибо

[@МаксимПарадочный]

спасибо брат.Я сразу не понял что он иммел в виду но благодаря твоему коменту я тоже нихуя не понял.(ну ничего страшного(пересмотрю:)) привет из 2022 как у тебя дела ?

[@ВиталийОсипов-ф7ъ]

Прежде всего огромное спасибо за уроки, очень качественно делаете. Обычно вы крайне подробно рассматриваете все сложные, и порой даже очевидные моменты, с зарисовками в памяти и т.п. Но в данном уроке был достаточно сложный момент (указатель на ссылку), который вы как-то мимоходом упомянули, мол ну есть такая конструкция, нужна для того-то. А как это дело всё в оперативке живет, и почему без этой звездочки программа ломается, так и не объяснили. Пока на листочке не зарисовал, так и не мог понять, что в и функции, и в мэйне дважды удаляется один и тот же динамический массив, потому что указатель в мэйне, всё еще ссылается на старый адрес. Вообще когда рисовал, заметил интересное наблюдение, что ссылки и указатели, это как последовательная и параллельная электро цепи. Ссылки как бы обращаются к памяти по "цепочке", "паровозиком", имея обратную связь и обращаясь к памяти через посредника. (В данном случае при работе в функции, как я понял, конструкция *&arr ссылается на указатель *arr в мэйне, который указывает на область памяти). Т.е. если сделать конструкцию ссылка на ссылку на ссылку на указатель\переменную, то две первых из них будут хранить только значение адреса в памяти, где лежит следующая ссылка, а последняя уже адрес указателя или адрес памяти где хранится какое то значение. И соответственно обращаться к таким данным будут тоже по цепочке. А в случае с указателями, то они просто передают при присваивании или при передаче в функцию конкретный адрес памяти на который непосредственно ссылаются, а далее существуют параллельно, обращаясь к этой, как бы "общей" для них памяти напрямую, а не друг через друга.

[@ВиталийСусский-я2м]

бля от души )))

[@viktort9326]

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

[@nubozxc7385]

@@viktort9326 Друг). Вот ты пишешь, люди визуально всё воспринимают, объяснить же тогда нужно что это за зверь. Они немного не правильно воспринимаете что такое ссылка, а что указатель. Ссылка это не самостоятельный объект. В то время как указатель является самостоятельным объектом. Поэтому при создании ссылки, её нужно обязательно инициализировать и она не может быть создана без инициализации как указатель или переменная например. Поэтому не нужно её воспринимать как самостоятельный объект. Вот теперь и представьте следующее: int a = 0; (Обычная целочисленная переменная). int& aRef = a; (aRef - ссылка на переменную a). int& bRef = aRef; (Создаем новую ссылку, которая инициализируется другой ссылкой.) И большинство скажет что это ссылка которая ссылается на другую ссылку. Но это не так. Как сказал выше - ссылка не самостоятельный объект, это вообще не объект. Визуально на месте ссылки представляйте объект на который она ссылается и всё станет на свои места. И выходит что int& bRef = aRef; это равнозначно что и int& bRef = a; Вот и нет никаких конструкций аля "ссылка на ссылку". По факту при инициализации новой ссылки другой ссылкой, она (новая ссылка) инициализируется не самой ссылкой (т.к. этого объекта (ссылки) попросту не существует), а непосредственно объектом (в данном случае переменной) на которую ссылается ссылка - инициализатор. И к сожалению автор немного ошибся. Он говорит что (*&arr) это указатель на ссылку, но это ссылка на указатель. Она ссылается на указатель (самостоятельный объект) который лежит в main вне функции push_back.

[@ВладиславМаксимов-р5х]

@@nubozxc7385 а можно было бы тогда сделать в функции пуш бэк указатель на указатель? это было бы тоже самое что и ссылка на указатель?

[@this.u]

@@nubozxc7385 по факту под капотом ссылка это константный указатель

[@overdoses1794]

Спасибо вам большое, благодаря вам, я стал отличником по информатике)))

[@aspi_pill]

10:00 это ссылка на указатель, т.к ссылка не является объектом, а значит указателя на ссылку быть не может. Спасибо за урок, много нового узнал

[@alexvvv5908]

Можно вместо "*&" использовать "**" (указатель на указатель?)

[@aspi_pill]

@@alexvvv5908 можно, но тогда необходимо использовать двойное разименование '**'

[@valik283]

Все остальные функции по работе с динамическим массивом: push_start(int*& arr, int &size, int value) { int *NewArray = new int[size+1]; NewArray[0] = value; for (int i = 1; i < size+1; i++) { NewArray[i] = arr[i-1]; } delete[] arr; arr = NewArray; size++; } void pop_start(int*& arr, int &size) { int* NewArray = new int[size-1]; for (int i = 1; i < size; i++) { NewArray[i-1] = arr[i]; } delete[] arr; arr = NewArray; size--; } void push_gap(int*& arr, int &size, int value, int index) { int* NewArray = new int[size + 1]; for (int i = 0; i < size+1; i++) { NewArray[i] = arr[i]; if (i != index) { cout

[@_rate_6808]

Хотел бы предложить свой вариант функций добавления и удаления элементов в середину и из середины массива соответственно, думаю он проще для понимания. Хотя они хорошо справляются, даже если указать индекс равный 0 или последнему индексу по массиву, главное, чтобы значение за пределы самого массива не выходило: void push_gap(int*& arr, int& size, const int value, const int index) { int* newArr = new int[size + 1]; for (int i = 0; i < index; i++) { newArr[i] = arr[i]; } newArr[index] = value; for (int i = index + 1; i < size + 1; i++) { newArr[i] = arr[i - 1]; } size++; delete[] arr; arr = newArr; } void pop_gap(int*& arr, int& size, const int index) { int* newArr = new int[size]; for (int i = 0; i < index; i++) { newArr[i] = arr[i]; } for (int i = index + 1; i < size; i++) { newArr[i - 1] = arr[i]; } size--; delete[] arr; arr = newArr; }

[@viper_0097]

@@essentia9 А где эта лишняя итерация? не могу найти

[@АртемЧернявський-и6ш]

По ходу записи кода написал такой комментарий к моменту с int *&arr. Так мне было проще понять. /* int*& arr - указатель на ссылку. Обычно, мы писали бы "int *arr" - только через указатель на массив, потому что int arr[] это тоже самое, что int *arr. Ссылка "&" делает то, что УКАЗАТЕЛЬ (ярлык) НА МАССИВ int *arr может меняться в функции main при изменении в push_back. Зачем? Мы одновременно переносим в функцию ярлык И массив. Это позволяет как работать с самим массивом, так и изменить куда указывает ярлык прямо в функции. Этот указатель используется в программе, в функциях FillArray и ShowArray, поэтому они теперь будут работать с нашим новым массивом с +1 элементом. */

[@alienhazzard7201]

Вообще это ссылка на указатель, а не указатель на ссылку.

[@dervis4122]

Чел я тебе удивлюсь, в прошлом видео мы изучали копирование, а в этом копирование с добавлением ещё одного элемента, меня прям прёт от того что ты делаешь уроки по нарастающей, да ещё и постепенно, я благодаря твоей подаче смог с нуля понять всё что ты объяснял, лайк под весь плейлист поставнел)

[@this.u]

как успехи?

[@RussiansNeverGiveUp]

Отличный курс! Спасибо! Так подробно еще никто не объяснял

[@simplyspenser887]

Сколь-нибудь хорошим программистом я врятли стану, но хоть шутки на Башорге теперь можно понимать. Спасибо:)

[@citrixxxx]

Как успехи?

[@geroitruda8157]

Simply Spenser,ну как дела в программировании?

[@ВсеволодЗорин-л6н]

Спасибо Вам... всё никак не мог разложить по полкам тему с указателями... спасибо за объяснение разницы между (* и *&)

[@SimpleCodeIT]

Пожалуйста!

[@ЕгорБаранов-ы6ш]

Шикарный урок, хотя как по мне, здесь стоило затронуть тему указателей на указатели)

[@АнтонМакаров-р8й]

Спасибо , хорошее объяснение . Было бы круто если бы уроки по c# вышли , либо по джаве и людей бы прибавилось это точно . В отличие от джавы по шарпу довольно таки мало уроков на ютубе , но это уже ваше дело) Еще раз спасибо ,лайк!

[@pv_r5090]

с каждым уроком делать дз всё проще и проще,решается по сути добавлением одной новой строчки.Спасибо

[@Ermine882]

Как всегда спасибо и лайк.

[@SimpleCodeIT]

Пожалуйста!

[@Arjuna114]

Интересная тема. Пришлось пару уроков прошлых пересмотреть чтобы понять окончательно ) Написал домашку не подглядывая в код урока ) Зачёт... Идём дальше )))

[@evgenyzakharov9983]

Мне кажется, что самое простое объяснение конструкции "*&" - следующее: 1. Чтобы изменить переменную "а" в функции, нужна передать её через ссылку "&a". Это было на прошлых уроках. 2. Чтобы изменить указатель, его тоже надо передать по ссылке. 3. Ссылка на указатель выглядит не "&*arr" (как в п.1), а "*&arr". (т.е. здесь наложились сразу 2 непонятки - ошибка в "указатель на ссылку" и рокировка * и &.)

[@ДавидМархевка-л5й]

Предположу что ссылка ссылается на данные в переменной, значит чтобы изменить адрес в масиве, нужно взять адрес с помощью * и потом уже вписать &, это означает что адрес будет изменён на другой.

[@dotlvforge5631]

Очень интересный урок, Сергей. Сильно зацепил) Возникает ощущение, что ниже только Assembly)))0))

[@robin2552]

Очень качественные уроки!Подробно и понятно, спасибо!

[@SimpleCodeIT]

Пожалуйста!

[@anloe6625]

Вы просто гений объяснений,спасибо вам огромное!

[@anloe6625]

@@Empty_line Ты добавляешь элемент в конец, тебе нужно создать ещё 1 ячейку в массиве

[@SimpleCodeIT]

#динамическиймассив #SimpleCode #урокипрограммирования

[@pavlikwest2485]

Не мог разобраться как добавить элемент в массив, с помощью вашего видео сделал это. Большое спасибо.

[@sankarshanarama6753]

Это магия, Сергей!)) Очень круто и подробно объяснил.

[@SeshAlex]

До этого урока у меня были некоторые затруднения с применением функций совместно с указателями. После его просмотра и совета автора - дополнительно самому поиздеваться над массивами, я все таки это сделал. Ушло в общем часов 5. Написал функции помимо тех что в уроке, добавление-удаление первого элемента из массива. Потом, функции добавления-удаления любого введенного пользователем элемента массива. Спасибо большое Сергей!

[@math1560]

Привет,не забросил?

[@dailyquote840]

@@math1560а ты?

[@Isturfore]

а ты?@@dailyquote840

[@ProHolmes]

Вообще интересная конечно штука. Чтобы добавить в сущность новый элемент, мы создаём новую сущность с добавленным элементом, а старую тихой сапой удаляем, подменяя в указателе на неё адрес новой сущности. Работает, внешнему наблюдателю (снаружи функции) разницы никакой, но почему-то ощущается как-то костыльно))

[@bignumber9483]

Функция, добавляющая новый элемент в начало массива: void PushArray(int*& arr, int &size, const int var) { int* mas = new int[size + 1]; int j = 1; for (int i = 0; i < size; i++) { mas[j] = arr[i]; j++; } mas[0] = var; delete[] arr; arr = mas; size++; }

[@Scriberrot]

Во время понимания int *& arr записал такой комментарий к коду. Может, кому-то пригодится: /*Передавая указатель на массив в int* arr, мы передаем его по значению т.е. создается новый указатель, в который присваивается адрес массива. По-этому arr из параметров функции и arr из main- совершенно разные указатели, указывающие на один и тот же массив. Изменить этот массив можно как из функции, так и из main. Но изменение адреса указателя(arr) в функции никак не повлияет на указатель(arr) из main. Передавая указатель на массив в int*& arr, мы передаем его(указатель) по ссылке т.е. arr из функции- ссылка на arr(указатель) из main. Это значит, что все изменения с arr из функции отразятся на arr из main. Значит, ссылка на указатель(int *&) позволяет передать указатель в функцию не по значению, а по ссылке. Это в свою очередь позволяет производить изменения напрямую с arr из main (как с данными так и с самим указателем (допустим, присвоить указателю новый массив)) */

[@Сергей-т9д7в]

Вот этого пояснения не хватало в уроке.

[@ВладиславМаксимов-р5х]

только вот я не понял, в функции он прибавил сайз +1 и потом еще раз увеличил сайз++, разве она не должна тогда увеличиться на 2?

[@BeforeIForget101]

@@ВладиславМаксимов-р5х size +1 в функции это просто число, в данном случае 5+1 = 6, которое показывает размер массива newArray. Запись же вида size ++ по сути аналогична size=size+1, то есть меняется само значение переменной size.

[@МаксимСоколов-о7т]

самое понятное для меня объяснение из всех выше

[@theodoretryman4289]

Спасибо тебе, за такое пояснение, на мой взгляд ты лучше развернул именно этот нюанс, все таки автору, нужно было чуть больше сделать на этом акцент 👍👍👍👍👍👍👍👍

[@jija5121]

спасибо,абсолютно все понятно,не единственное что не понял почему в функции size++ находится после нового массива

[@sleepyNovember_project]

о, так, я тоже затупил, но выходит следующее: //создаём новый массив, на 6 элементов int *newArray = new int[size(5) + 1]; //заполняем новый массив, копируя значения из старого for (int i = 0; i < size(5); i++); { newArray[i] = arr[i] //0 < 5 = true / newArray [0] = arr[0] / i++ //1 < 5 = true / newArray [1] = arr[1] / i++ //2 < 5 = true / newArray [2] = arr[2] / i++ //3 < 5 = true / newArray [3] = arr[3] / i++ //4 < 5 = true / newArray [4] = arr[4] / i++ //5 < 5 = false } //скопировано 5 ячеек (0, 1, 2, 3, 4) + 1 добавленная выше при создании массива, осталась с мусором. Получилось 6 цифр. вот тут эссенция затупа newArray[size(5)] = value; обращаемся именно по индексу ячейки 0 1 2 3 4 5 / int size = 5 / ячейка 6 < ВОТ //и меняем переменную со значением размера массива на 6 size++; int size = 6; теперь при обращении к переменной size, можно перечислять массив for (int i = 0; i < size(6); i++) { cout

[@avbdkfksncncbj]

я после каждого видео из этого плейлиста говорю: жесть какая! но продолжаю смотреть ибо очень интересно😆 P.S: я пришла после питона не обессудьте 🙂

[@Рыззе]

Спасибо огромное. Написал сразу же после видео две функции для записи и удаления в середине массива.

[@Джимен-ж3х]

Спасибо большое за такой подробный видеоурок , когда сидел на паре думал что эта тема не по моим силам , а оказалось все намного легче )

[@danilguseinov1430]

Не знаю, чтобы я без тебя делал!

[@tayurus]

ЧУВАК, СПАСИБО!!!!!!!!!!!!!!!!!!!!!!!!!!!

[@archiechellaut9483]

Большое спасибо вам за урок и прекрасное пояснение, Сергей!

[@djelmecanico2614]

Огромное спасибо за уроки. Немного поигрался с кодом и получилось вот такое :

[@IgorIlinoff]

классный код у тебя )

[@AnnTimLeo]

Спасибо! Самые лучшие уроки по программированию!

[@TherePython]

Спасибо огромное, Легенда

[@ИринаЧ-к6в]

Всё просто супер.

[@TGrod]

Отличные видеоролики! Спасибо вам, Сергей, за обучение))) Этот урок был самым сложный из тех, что уже посмотрел, из-за int*& arr. Никак не могу понять, как это работает. P.S. Наконец-то! Я понял, спустя 1 час, как работает int *&arr!!!. Завтра, когда всё устаканится в голове, попробую хорошо объяснить для таких, как я) P.S.S. Вроде правильно понял. В самом начале я подумал, что int *& arr означает указатель на ссылку, а ссылка указывает на сам указатель arr. Но это, как я понял, неверно. Для начала вспомним, что ссылка указывает на ячейку в памяти и как бы смотрит, что там лежит. В нашем примере это выглядит так: arr - это указатель на первый элемент в массиве. Но надо же где-то хранить адрес этого элемента? Поэтому в памяти выделяется ячейка в которую записывается адрес первого элемента массива. И у этой ячейки, в которой хранится адрес первого элемента в массиве, тоже есть свой адрес. В ссылку записывается этот адрес, и когда мы где либо её используем (ссылку) , то мы ссылаемся на ячейку в памяти, в которой хранится адрес первого элемента массива. Но так как это ссылка, то программа автоматически разименовывает (я фиг знаю как это пишется) ссылку и у нас вместо ссылки в "руках" остаётся адрес первого элемента массива. Ссылка работает как переменная. В данном случае мы в эту "переменную" записали адрес первого элемента массива, и соответственно мы можем эту переменную изменить, что мы и делаем в самом конце функции. Я постарался объяснить максимально понятным языком, но как вижу получилось очень много тафтологии. Слишком много раз написал слово адрес) Надеюсь, что кто-то поймёт. Просто без рисунка это объяснить сложно

[@none1307]

выходит что этой записью arr = newArray мы в присвоили arr адрес на первый элемент массива newArray?

[@TGrod]

@@none1307 да

[@none1307]

@@TGrod запутанно все) Спасибо дружище!

[@TGrod]

@@none1307 есть такое

[@MrJustSergei]

@@TGrod А с рисунком или видео можно визуализировать это?

[@ylikitishnik1946]

сложно но спасибо за урок хоть этот коммент некто не прочитает ну ладно

[@SimpleCodeIT]

пожалуйста =)

[@katuli3677]

прочитали аж несколько людей

[@ВладимирЧёрненький-я3е]

Суперские уроки!) Спасибо/лайк)

[@SimpleCodeIT]

Пожалуйста!

[@elnur_talybov]

в функции push_back, после удаления старого массива и присвоения указателю старого массива адрес нового массива два указателя указывают на один и тот же массив. Нужно было написать newarray = nullptr чтобы его отвязать от массива.

[@Dendrarium.walker]

Объясните пожалуйста, как мы на 19:54 присваиванием значение value в последний элемент массива, если последний элемент массива инициализируется как value-1?

[@skorp291]

Спасибо за урок!!! А вот реализация удаления елемента с середины массива: #include using namespace std; void FillArray(int *arr, int size) { for (int i = 0; i < size; i++) { arr[i] = rand() % 10; } } void ShowArray(int *arr, int size) { for (int i = 0; i < size; i++) { cout

[@ИржанДизель]

А как мне написать функцию , как в видео, но надо увеличить длину массива на число,которое вводится пользователем и заполнить эти ячейки , например , '*'

[@chap_01]

Объявления переменных необходимо читать справа налево: "arr это ссылка на указатель на int". int *&arr это не указатель на ссылку, а ссылка на указатель. Указатель на ссылку бессмысленен, т.к. этот указатель ссылался бы на ту же область памяти, где лежит значение переменной arr (в данном случае значение нулевого элемента массива arr). Без объявления аргумента arr как ссылки на указатель невозможно было бы осуществить строку arr=newarray, т.е сменить адрес arr на адрес новосозданного и расширенного newarray. Я так понял, зачем нужен был синтаксис (*&arr). Можно было бы использовать и int **arr, но тогда пришлось бы клепать двойное разыменование и запутаться в край

[@sanpaul3057]

Красава, а то автор сам не понимает че объясняет

[@antonsyski4137]

От души душевно в душу - лойс)

[@khasantochiev3829]

0:42 - Большой массив на несколько ячеек))))

[@1lrutakak811]

В функции puch_back в строке с _int* newАrrау = new int[size + 1];_ не обязательно вписывать [size + 1] достаточно после динамической инициализации вписать size++ для добавления новой ячейки в массиве. Ну и там само собой присваивание значения в эту пустую ячейку.

[@ДавидМархевка-л5й]

тогда так можно было только

[@ДмитрийЕвтушенко-к3т]

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

[@СправаФея]

с чего вдруг какому то старому значению оставаться висеть в оперативной памяти, когда удаляется весь массив полностью? по-моему, это итак понятно. не то что многие, я сомневаюсь, что вообще кто то так подумал,

[@КириллБуланов-в4б]

ЛУЧШИЙ!

[@creep1ch442]

очень помогло спс )))

[@alexeyxopyc2471]

посмотрев видео и почитав комменты пришел к выводу, что: 1. все же значки указателя и ссылки нужно писать слитно с типом данных "int*& arr", а не с переменной "int *&arr" (хотя работает одинаково, но читаемость и понимаемость становится лучше). 2. читается такой тип данных справа налево

[@russiantutorials4763]

Добавление числа в начало массива (даже сделал функцию move, которая передвигает число, причем индекс сдвига можно указать): void Move(int *&newArray, int *&arr, const int value, const int indexFrom, const int indexTo) { int temp = arr[indexFrom]; newArray[indexFrom] = value; newArray[indexTo] = temp; } void PushForward(int *&arr, int& size, const int value) { size++; int* newArray = new int[size]; Move(newArray, arr, value, 0, 1); for (int i = 2; i < size; i++) { newArray[i] = arr[i - 1]; } delete[] arr; arr = newArray; }

[@АлександрИбраимов-п3р]

у меня тоже вин 10, интерфейс такой же как у автора. Смотрю на его время 11:50, а на моих часах тоже 11:50.

[@ИсаакГерде]

ты автор?))

[@ДГаусс]

Когда писал под вашу диктовку данную программу, сгенерировались те же самые числа, что и у вас :) Спасибо!

[@bifacial605]

мб потому что ты srand не указал вначале мейна....

[@theodoretryman4289]

10:58 Я теперь понял, почему я не мог запихнуть выделение динамической памяти в пользовательскую функцию, используя знания из предыдущего урока ...

[@SLaVeRS9]

Тоже добавлю, как это понял я. В push_back мы используем int* &arr именно для того, чтобы при последнем этапе работы функции (это arr = newArray) в указатель arr, который в main записался адрес памяти newArray. И такая запись из функции в main осуществляется за счет ссылки &. Получается, что мы результат работы функции записываем на уровень выше. Если же мы в push_back используем int* arr, то при arr = newArray адрес newArray запишется в arr локально и при выходе из функции в arr он поменяется на адрес, который был у arr до входа в эту функцию.

[@dervis4122]

я поставил ровно 3000ный лайк!

[@denis4899]

Разве "int *&arr" это указатель на ссылку? Должно быть наоборот - ссылка на указатель, т.к указатель может указывать только на объекты, а ссылка объектом не является. Объясните если я ошибаюсь.

[@Rogadze]

Спасибо большое за видео. Но есть вопрос: Вы создаете функцию push_back и реализовываете в ней новый массив newArray. Но почему вы его не удаляете его после того как происходит строчка с копированием данных из одного массива в другой? Помню вы всегда говорили, что если создаем новый массив, то сразу пишем строчку для его удаления.

[@SimpleCodeIT]

Он подменяет собой массив который создан в main и удаляется в конце выполнения функции main. Пересмотрите этот момент kzbin.info/www/bejne/nKuxnKakatyDiskm31s

[@Rogadze]

Ааа, да, понял теперь. Спасибо большое за ответ.

[@SimpleCodeIT]

Пожалуйста.

[@michaelbondarev8788]

@@SimpleCodeIT но указатель newArray остается и мы имеем 2 указателя на вновь созданный массив, или он разрушится при выходе из функции как локальная переменная?

[@ИгорьБуренин-в3я]

Поигрался к кодом - очень интересно! В моменте с добавлением в начало массива нового элемента сделал смещение итератора в цикле - newArray[i+1] = arr[i] предварительно воткнув в newArray[0] значение value ну и при удалении с перезаписью соответственно наоборот - newArray[i]=arr[i+1]. Посмотрите пожалуйста момент с добавлением нового элемента куда нибудь в центр массива, код конечно работает ,но как сделать лучше ? void push_back(int *&arr,int &size,const int value) { int* newArray = new int[size+1]; for (int i = 0; i < size; i++) { if (i==4) newArray[4] = value; int bias = i; if (bias >= 4) bias++; newArray[bias] = arr[i]; if (i == 3) bias = 5; } size++; delete[] arr; arr = newArray; } /////////////////////////////////////////////////////////////////////// void pop_back(int *&arr,int &size) { size--; int *newArray = new int[size]; for (int i = 0; i < size; i++) { int bias = i; if (i == 4) bias = 5; newArray[i] = arr[bias]; } delete[] arr; arr = newArray; }

[@Nevermind-cg5wr]

Ахахах, оказалось все так просто, я минут 30 понять не мог как мне вложеный циклы реализовать, а выходит, что он и не нужен был))) void pushFront(int *&arr, int &size, int value) { int *midArr = new int[size + 1]; for (int i = 1; i < size+1; i++) { for (int j = 0; j < i; j++) { midArr[i] = arr[j]; } } midArr[0] = value; size++; delete[] arr; arr = midArr; }

[@artem_tsukanov]

В функцию push_back стоит ли дописывать строчку: newArray = nullptr; ? Нужно ли удалять указатели после использования?

[@СправаФея]

обычно nullptr затирают указатели на массивы, которые удалены, и память из под них освободилась, дабы не допустить утечки памяти. здесь же newArray указывает на действующий массив arr. а вообще, учитывая что newArray находится в области видимости только в пределах функции, т.е. дальше в программе его вызвать нельзя - т.о. "запороть" из-за newArray мы уже ничего не можем. в общем то newArray = nullptr; для чистоты делать нужно, но здесь это смысла особого не имеет,)

[@skoripax]

Бережи тебе Господь

[@aska1218]

Решал задачку, и понял, что допустил там утечку данных только после этого урока, пойду исправлять)

[@steshapokosova1775]

До просмотра видео в новой функции реализовала добавление нового элемента по индексу, функция отработала на ура, а на выходе выдала старый адрес на массив которого уже не существует, все понять сначала не могла где кроется ошибка.. ссылка по указателю, это же гениально! реализовала код.. void CreatElementMassiv(int *&Array, int &size, int index, int Number) { size++; int* newArray = new int[size]; for (int i = 0; i < index; i++) newArray[i] = Array[i]; for (int i = index+1; i < size; i++) newArray[i] = Array[i-1]; newArray[index] = Number; delete[] Array; Array = newArray; newArray = nullptr; cout index; i--) newArray[i-1] = Array[i]; delete[] Array; Array = newArray; newArray = nullptr; cout

[@pulukchu]

1. Спасибо большое, за вашу проделанную работу, очень хорошо и доступно даете информацию. Спасибо. 2. Расскажите пожалуйста, почему в конце функции мы не удаляем временный динамический массив - newArray?

[@аоалал-х1т]

я думаю, тебе уже не надо это, но все-же) потому-что функция после срабатывания удаляет автоматически всё лежащее в ней, ну это как я понял)

[@hrachyaandreasyan4239]

​@@аоалал-х1т Но когда пишешь delete[] newArray, То значения которые даны arr пропадают, даже в том случае, когда delete пишешь после arr = newArray; Почему так?

[@АркадийЛандышев-э3д]

@@аоалал-х1т благодарю за пояснение

[@cicada666]

Пример того, как можно написать динамический массив с добавлением/удалением значения/элемента в любом месте #include using namespace std; void FillArray(int* const arr, const int size) { for (int i = 0; i < size; i++) { arr[i] = rand() % 10; } } void push_back(int *&arr, int &size, const int value, int index) { int *NewArray = new int[size+1]; for (int i = 0; i index) { NewArray[i] = arr[i - 1]; } } size++; delete[] arr; arr = NewArray; } void pop_back(int *&arr, int &size, int index) { int *NewArray = new int[size-1]; for (int i = 0; i < size; i++) { if (i < index) { NewArray[i] = arr[i]; } if (i > index) { NewArray[i-1] = arr[i]; } } delete[] arr; size--; arr = NewArray; } void ShowArray(const int* const arr, const int size) { for (int i = 0; i < size; i++) { cout

[@ВиолеттаСиницына-к9ъ]

спасибо большое💜, долго не могла понять как реализовать это задание)

[@skorp291]

Огромное спасибо за урок!!! Ниже мой вариант исполнения вашего задания: #include using namespace std; void Fill_array(int * const arr,const int size) { for (int i = 0; i < size; i++) { arr[i] = rand() % 10; } } void Show_array(int * const arr,const int size) { for (int i = 0; i < size; i++) { cout

[@nolloue5636]

Евгений Бондаренко спасибо за подсказку о удалении с мидла, не мог понять как это сделать))

[@skorp291]

TheAndroid Bot Спасибо за критику. ) Что именно Вас так впечатлило?

[@metalhead-mh1864]

Спасибо вам

[@this.u]

@@skorp291 Как успехи с обучением?

[@skorp291]

@@this.u в процессе

[@vladimirdiadichev6140]

Спасибо

[@777noob777saibot]

Кстати.Есть такая штука как побитовые операции и флаги. например 2 I 3 это (2 или 3) (0010 или 0011 ) = 0011 . Переменная a = 0000 1110 чтобы установить флаг flag1 = 0000 0001 делаем a I = flag1 Это (0000 1110 I 0000 0001 ) = 0000 1111

[@whoamixrun3851]

Спасибо вам большое.

[@henrikhohanyan2471]

int*arr - в этом случи в функцию пердаётся адрес указателя,но если мы изменим адрес етого указателя то в main() он не изменица int*&arr - а в этом случи если мы изменем адрес указателя из функции то он изменица в main() тоже ;

[@vasilykravchenko2757]

Всё хорошо, только int *&arr - ссылка на указатель, а не указатель на ссылку. Очень похоже на указатель на указатель int **arr, только нельзя передавать нулл, нельзя модифицировать ссылку, не нужно разыменовывать. Когда Вы говорите "указатель на ссылку" - это очень сильно дезориентирует, потому что "указатель на ссылку" в С++ не существует. Указатель это конкретное место в памяти, заполненное адресом какой-то другой сущности, а ссылка это всего лишь альтернативное имя для уже существующей сущности.

[@olexangrstetsiuk3092]

Спасибо за замечание , но пока не хватает моего сознания до конца понять эту разницу. Наверное мне опять нужен рисунок в пеинте ;-)

[@rafk5341]

Функция для добавления числа в начало массива : void push_begin(int*& arr, int& size, int var) { int a = 0; size++; int* new_arr = new int[size]; for (int i = 0; i < size; i++) { if (i == 0){ new_arr[i] = var; } else { new_arr[i] = arr[a]; a++; } } delete[] arr; arr = new_arr; } Для удаления в начале: void pop_begin(int*& arr, int &size) { int* new_arr = new int[size - 1]; for (int i = 0; i < size; i++) { new_arr[i] = arr[i + 1]; } size--; delete[] arr; arr = new_arr; } Для добавления числа в середину : void push_mid(int*& arr, int& size, int elem, int var ) { size++; int* new_arr = new int[size]; for (int i = 0; i < size; i++) { if (i < elem) { new_arr[i] = arr[i]; } else if (i == elem) { new_arr[i] = var; } else if (i > elem) { new_arr[i] = arr[i - 1]; } } delete[] arr; arr = new_arr; } Для удаления из середины : void pop_mid(int*& arr, int& size, int elem) { size--; int* new_arr = new int[size]; for (int i = 0; i < size; i++) { if (i < elem) { new_arr[i] = arr[i]; } else if (i >= elem) { new_arr[i] = arr[i + 1]; } } delete[] arr; arr = new_arr; }

[@curator7]

*Ты уже учил раньше прогу или чисто видос посмотрел и написал код? Если 2 , то сколько времени потратил?*

[@rafk5341]

@@curator7 примерно месяц назад начал учить, щас уже на 87 уроке

[@ДГаусс]

Я бы в функциях push_back и pop_back между строчками delete[] arr и arr = newArray добавил бы arr = nullptr, чтобы затереть адрес старого массива

[@daclicker]

вот я смотрел и ту же проблему заметил, думал написать в комментах, а тут вы 😉

[@АртемЖуков-п7ш]

Зачем? он и так затирается в этой строке arr = newArray

[@xlSkyLinelx]

Код на 18ой минуте. А не проще ли воспользоваться функцией realloc из библиотеки cstdlib? Тот же результат, то же время исполнения, короче и элегантнее код. Выглядит это так: void push_back(int *&arr, int &size, const int value) { size += 1; arr = (int*)realloc(arr, size * sizeof(int)); // O(n) arr[size-1] = value; }

[@xlSkyLinelx]

@lasto4kk а в чем проблема? Это базовые вещи.. Чуть более продвинутый уровень плюсов - это создать вектор через библиотеку STL, который будет содержать указатель в каждой ячейке, это еще более элегантно + из-за того, что это шаблон, можно менять тип указателей в одной строчке или иметь несколько векторов с разными типами данных, что гораздо удобнее.

[@EntireMusic]

Попробовал сделать функцию Insert)) Оказалось, переменную в cредину массива нужно добавлять только с проверкой, что она меньше "size", а не просто присваивать, тк значение позиции передаётся из Main'a и, в теории, может быть больше размера массива, на что ругается Visual Studio.

[@Lurid_Bolete]

Спасибо за видео! Есть такой вопрос. Когда я пишу int *& arr, я могу изменить сам указатель, в отличии от записи int *arr. То есть, как я понимаю, в записи int *arr изменить указатель нельзя. А вопрос такой: зачем тогда вводить int *const arr, если что так, что при int * arr, указатель не изменяется.

[@monocode504]

Запусти этот код, а потом поменяй аргумент функции changePointer "int *arr" на "int *const arr". #include void changePointer(int *arr, int size) { int *pointer = new int[]; arr = pointer; for (int i = 0; i < size; i++) { std::cout

[@andreyvolkov3117]

@@monocode504 Запустил, не сработало

[@TGrod]

В int* arr указатель можно изменить, но он изменяется ВНУТРИ функции. То есть снаружи функции указатель будет по-прежнему указывать на старый адрес. const мы пишем, чтобы самим случайно не изменить адрес (насколько я помню). Я могу ошибаться, но вроде это работает так. Этот комент тебе уже не нужен, но может другим чем-нибудь поможет

[@pvcificv]

огромное спасибо !

[@Mdwed]

По поводу исключения элемента. Возможно стоит исключить его передавая в параметр индекс (например в результате проверки) и используя как исключение через continue в цикле записи (наверное через if). По идее, цикл отработает нужное количество раз, записав оставшиеся переменные в новый массив. Я как раз пишу приложение, в котором по событию нужно удалить элемент. Поправьте, если я понял неправильно, для меня это очень важно. Очистить память, чтобы не было присваиваний и проверок по ненужному (пустому) объекту класса из массива.

[@olegiv4814]

Спасибо. Хорошо бы иметь возможность в C++ удалять последний элемент в массиве без создания нового массива и операции копирования. Возможно в std::erase() так и сделано???

[@minegeymer]

Я так и не понял магии **&, сам посидел потестил, по идеи как я понял & запрашивает адрес указателя, и записывает адрес в новый указатель. Но тогда я решил сделать так: int** arr2 = &arr; но говорит нужно две * так как указатель на указатель.

[@notFearnir]

Подскажите, нужно ли указывать в конце функции " newArray = nullptr; " ?

[@SKrandy]

А разве не нужно в конце функции добавить еще newArray = nullptr чтобы затереть указатель нового массива? Или если мы работаем с функцией, то в этом нету необходимости?

[@fitileo]

я так понимаю ссылку мы используем для экономии памяти,то есть если бы мы написали просто в параметрах *arr то когда мы передавали массив то,там в функции создаётся новая переменная которая просто указывает на ту же ячейку в памяти что и переданный массив.И ещё, *arr и arr[] это одно и тоже?

[@polarix2398]

Не указатель на ссылку, а наоборот - ссылка на указатель!!!

[@tupoy_ytub_uberi_psevdonim]

домашнее задание выполнил. у меня получилось сделать возможность добавить или удалить итый элемент массива. не с первого раза, но дошло

[@lkkath]

можете поделиться алгоритмом или кодом пожалуйста?

[@tupoy_ytub_uberi_psevdonim]

@@lkkathпростите не могу найти уже свой проект. Если надо могу скинуть все что имею, но вряд ли там выйдет найти что то

[@pavelkhmialinka6602]

void push_back(int *&arr, int &size,const int n, const int value) { int *newArray = new int[size + 1]; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { if (i == n) { newArray[i] = value; i++; } newArray[i] = arr[j]; i++; } break; } size++; delete[] arr; arr = newArray; } эта функция которая добавляет элемент массива в любой номер! ура, получилось)

[@HuskyFullfilment]

Можно было бы конечно сразу написать функцию для добавления и удаления элемента из середины массива. И задавая индекс элемента удалить или добавить в начало или конец массива.

[@laim3756]

Для тех, кто до сих пор не понял "*&"(указатель на ссылку): * - указатель на ячейку в памяти, грубо говоря, эта звёздочка всегда будет указывать на одно и тоже место в памяти. Даже если значение этой ячейки изменить, то указатель всёравно будет указывать на ту же ячейку, только с новым значением. & - просто ссылка, она не указывает на ячейку в памяти, а даёт доступ к значению переменной и возможность взаимодействия с ней. (Эта вещь удобна тем, что можно напрямую взаимодействовать с переменной, а не мудохаться с копированием в функцию и последующим её выводом) Отсюда и *&: чтоб сперва взять значения массива, используя ссылку - &a, после чего мы создаём новый массив NewArray, копируя в него все те значения, что взяли через ссылку из нашего arr, а так же изменяя размер(size+1) и добавляя новый элемент(NewArray[size++] = value), затем переадресовываем указатель на новую ячейку памяти, где мы и создали этот новый массив - arr = NewArray.

[@05lda]

Вопрос: указатели занимают место в оперативке?

[@princessmary5556]

Смотря что подразумевается под словом "указатель". Если вы имеете ввиду обычную переменную указательного типа, тогда ответ - да, занимают.

[@olegbocharnikov950]

я думаю переписать с пропуском элемента в середине можно через continue

[@aleksandrsilantev7701]

Верно. Благодаря ему можно вообще любой элемент массива удалить, даже последний и первый)) Получается универсальная вещь int* newArray = new int[size]; for (int i = 0, j = 0; i < size; i++, j++) { if (i == index) { j--; continue; } newArray[j] = arr[i]; } size -= 1; delete[] arr; arr = newArray;

[@yeskendirkuspanov5888]

мужик, благодарю

[@777noob777saibot]

Есть у меня одна мысль. Переменная это неявно созданная ссылка.Когда создаёшь переменную система неявно от тебя создаёт ссылку в виде адреса на ячейку с данными. Когда ставим оператор адреса возле переменной & получаем адрес ячейки , в которой находится ссылка(адрес на данные) и поэтому можем туда вставить адрес на другие данные...на другую переменную. При создании ссылки система неявно создаёт на неё указатель.То есть под капотом каждая ссылка имеет указатель.Почему нельзя создать ссылку на указатель... может потому что ссылка не сможет получить данные, на которые указывает указатель, а сможет только поместить другие данные в ячейку, в которой находится указатель, тем самым сломав его.....поэтому и не допускается ссылка на указатель.Но добавив оператор разыменования *& мы получаем адрес данных на который указывает указатель...и поэтому всё работает. Почему нельзя поменять адрес, на который указывает ссылка? может быть как-то мешает неявно созданный указатель на неё. Если так то довольно логично, это многое объясняет.

[@xar901]

Ееее сделал замену сл. элемента массива с увеличением массива !!!! Как же я рад ) #include using namespace std; /* добавить элемент в сл место массива */ void FillArray(int* const arr, const int size) /// заполнение массива сл. числами { for (int i = 0; i < size; i++) { arr[i] = rand() % 10; } } void ShowArray(const int* const arr, const int size) /// показываем элементы { for (int i = 0; i < size; i++) { cout

[@777noob777saibot]

Вот как увидел в функции параметр указатель на ссылку *&arr , то стал думать как они устроены под капотом и что то сильно запутался. Правильно ли я понял что указатель это адрес на ссылку.... то есть указатель это адрес на ячейку памяти, в которой хранится адрес на ячейку с данными? и этот адрес на ссылку тоже хранится в какой нибудь ячейке памяти. Тогда становится непонятно почему передать arr в параметр *&arr выходит, а передать в параметр &arr не выходит . По логике с помощью параметра &arr мы получаем адрес на arr , создав тем самым ссылку на указатель. А с помощью параметра *arr мы разыменовываем переданный указатель arr , который является адресом на ссылку...и получаем ссылку на массив? Именно поэтому имеем доступ только изменять массив , а не адрес указателя.

[@jangiryanarsen4952]

Будут ли уроки по Apple Metal API, OpenGL, OpenCL ? Спасибо.