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

Понравилось видео или оказалось полезным? Подпишись!
Изменить размер массива. Удалить элемент массива. Добавить элемент в массив. Увеличение размера массива. с++ Для начинающих. Урок #59
Исходный код topic-1...
Уроки по программированию
Наша группа ВК smplcode
Подписывайтесь на канал / @simplecodeit

[@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.

[@user-pm5kv1xj3x]

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

[@this.u]

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

[@Scriberrot]

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

[@user-qu5ch6rl4f]

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

[@user-pm5kv1xj3x]

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

[@BeforeIForget101]

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

[@user-pw1nl6cr8l]

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

[@overdoses1794]

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

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

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

[@alienhazzard7201]

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

[@evgenyzakharov9983]

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

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

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

[@dervis4122]

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

[@this.u]

как успехи?

[@user-pd4gt9zz9c]

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

[@SimpleCodeIT]

Пожалуйста!

[@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 А где эта лишняя итерация? не могу найти

[@user-tw4ut5kl4z]

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

[@simplyspenser887]

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

[@citrixxxx]

Как успехи?

[@geroitruda8157]

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

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

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

[@pv_r5090]

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

[@Arjuna114]

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

[@Ermine882]

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

[@SimpleCodeIT]

Пожалуйста!

[@RussiansNeverGiveUp]

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

[@robin2552]

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

[@SimpleCodeIT]

Пожалуйста!

[@sankarshanarama6753]

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

[@SeshAlex]

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

[@math1560]

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

[@dailyquote840]

@@math1560а ты?

[@Isturfore]

а ты?@@dailyquote840

[@pavlikwest2485]

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

[@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++; }

[@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

[@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 уроке

[@alexeyxopyc2471]

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

[@dotlvforge5631]

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

[@anloe6625]

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

[@anloe6625]

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

[@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 в процессе

[@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 А с рисунком или видео можно визуализировать это?

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

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

[@SimpleCodeIT]

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

[@elnur_talybov]

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

[@chap_01]

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

[@sanpaul3057]

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

[@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; }

[@henrikhohanyan2471]

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

[@IMPALYCH]

Кому интересно, то вот простой код с дабавление и удалением элемента в любом месте массива void push_buck(int*& arr, int& size, int value, int index) { int* newArray = new int[size + 1]; newArray[index] = value; size++; for (int i = 0; i < index; i++) { newArray[i] = arr[i]; } for (int i = index + 1 ; i < size; i++) { newArray[i] = arr[i -1]; } delete[] arr; arr = newArray; } void push_buck1(int*& arr, int& size, int index) { int* newArray = new int[size + 1]; newArray[index] = NULL; size--; for (int i = 0; i < index; i++) { newArray[i] = arr[i]; } for (int i = index; i < size; i++) { newArray[i] = arr[i + 1]; } delete[] arr; arr = newArray; }

[@ylikitishnik1946]

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

[@SimpleCodeIT]

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

[@katuli3677]

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

[@Рыззе]

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

[@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

[@user-yx4vm2ig6v]

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

[@archiechellaut9483]

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

[@1lrutakak811]

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

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

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

[@ДианаАимбетова-и6м]

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

[@tayurus]

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

[@AnnTimLeo]

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

[@djelmecanico2614]

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

[@IgorIlinoff]

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

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

ЛУЧШИЙ!

[@SLaVeRS9]

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

[@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

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

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

[@denis4899]

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

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

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

[@user-rm3eu6we8c]

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

[@danilguseinov1430]

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

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

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

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

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

[@SimpleCodeIT]

Пожалуйста!

[@vasilykravchenko2757]

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

[@olexangrstetsiuk3092]

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

[@ДГаусс]

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

[@bifacial605]

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

[@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

[@ДГаусс]

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

[@daclicker]

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

[@user-rj7cf4sf6d]

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

[@user-wd4ec6bo9c]

Поигрался к кодом - очень интересно! В моменте с добавлением в начало массива нового элемента сделал смещение итератора в цикле - 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; }

[@megasergm]

чуть более интересное решение задания из конца урока: void begin(int*& arr, int& size,const int number,const int digit) { int j = 0; int* newarray = new int[++size]; for (int i = 0; i < size; i++){ if (i == number) { newarray[j] = digit; j++; } newarray[j] = arr[i]; j++; } delete[]arr; arr = newarray; } где: number- номер массива в который мы хотим поставить наше число. digit- число которое мы хотим подставить

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

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

[@sleepyNovember_project]

А я подумал что *&arr значит то, что мы берём адрес принимаемого указателя Без &, т.е: "push_back(int *arr ..." Создавался бы новый, локальный для этой функции указатель с данными принимаемого Возможно если изменить так: void push_back(int *arr, int &size, int value) а в main вызывать функцию так: push_back(&arr, size) То тоже будет работать. Но это не точно 😵

[@user-eq2of7kp9o]

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

[@creep1ch442]

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

[@khasantochiev3829]

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

[@antonsyski4137]

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

[@Mdwed]

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

[@myafo]

Кто не понял, как работает *&, то читайте. Все просто. Аргумент функции, который в своей записи имеет *& (например: int*& arr), является и ссылкой и указателем. То есть, можно бы было сказать, что *& = &*, и так было бы понятней, но синтаксис С++ указывает на то, что нужно объявлять переменную, сначала говоря про то, является ли переменная указателем(*), а только потом является ли переменная ссылкой(&). P.s. если что-то не понятно, то пишите

[@peaktop3286]

Кому интересно, вот написал функции, которые добавляют и удаляют элементы по индексу в любое место (index - индекс, по которому удалить, либо добавить на его место число, при этом до этого сдвинув массив): void Push(int *&arr, int &size, int value, int index) { int* newArray = new int[size + 1]; for (int i = 0; i < index; i++) { newArray[i] = arr[i]; } for (int i = index; i < size; i++) { newArray[i + 1] = arr[i]; } newArray[index] = value; delete[] arr; size++; arr = newArray; } void Pop(int *&arr, int &size, int index) { int *newArray = new int[size - 1]; for (int i = 0; i < index; i++) { newArray[i] = arr[i]; } for (int i = ++index; i < size; i++) { newArray[i - 1] = arr[i]; } delete [] arr; size--; arr = newArray; }

[@olexangrstetsiuk3092]

Если в парамнтрах к фунции Pop укезать индекс 0 - виснет ком'ютер.

[@dervis4122]

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

[@user-r5jflfskjlaJJFs]

Функция по добавлению элемента в массив по индексу: void push(int*& arr, int& size,const int value,const int index) { size++; int* newArray = new int[size]; for (int i = 0; i < size; i++) { if (i >= index) newArray[i+1] = arr[i]; else newArray[i] = arr[i]; } newArray[index] = value; delete[] arr; arr = newArray; } И функция по удалению элемента массива по индексу: void pop(int*& arr, int& size, const int index = -1) { size--; int* newArray = new int[size]; for (int i = 0; i < size; i++) { if (i >= index) newArray[i] = arr[i+1]; else newArray[i] = arr[i]; } delete[] arr; arr = newArray; }

[@user-r5jflfskjlaJJFs]

@@Empty_line Она дважды не увеличивается. Посмотрите повнимательнее

[@user-r5jflfskjlaJJFs]

@@Empty_line выражение [size + 1] не увеличивает само значение size, оно для массива, который должен быть на один элемент больше. А в конце через size++ значение увеличивается для внешнего массива

[@user-r5jflfskjlaJJFs]

@@Empty_line для понимания напиши код и пройдись по отладчику

[@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

[@polarix2398]

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

[@zaulgin1487]

Немного модернизировал метод, добавил 3-й аргумент - количество добавляемых элементов, а также внедрил пользовательский ввод с выбором рандомной инициализации элементов или ручной. void push_back(int*& arr, int& arraySize, const int addingElementsCount) { int* newArray = new int[arraySize + addingElementsCount]; for (int i = 0; i < arraySize; i++) { newArray[i] = arr[i]; } char choice; bool isChoice = false; while (!isChoice) { cout

[@aska1218]

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

[@shadow_spark8788]

Я чисто из интереса модифицировал функцию так, чтобы она добавляла любое количество элементов в любое место массива. Вот код: void add_mult(int*& arr, int& size) { int quantity; std::cout > quantity; std::cout pos; std::cout

[@pulukchu]

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

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

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

[@hrachyaandreasyan4239]

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

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

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

[@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, который будет содержать указатель в каждой ячейке, это еще более элегантно + из-за того, что это шаблон, можно менять тип указателей в одной строчке или иметь несколько векторов с разными типами данных, что гораздо удобнее.

[@9uslix]

*p - если изменить значение внутри функции, оно сохранится за пределами функции. Но если изменить адрес, он уже не сохранится. **p - двойной указатель, или указатель на указатель. Позволяет одновременно сохранить вне функции и адрес, и значение. *&p - ссылка на указатель. Всё то же самое, но без лишнего разыменования

[@user-yu1qi7pl9c]

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

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

ты автор?))

[@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]

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

[@minegeymer]

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

[@EntireMusic]

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

[@ДмитрийКулявец-в5у]

Вот как я выполнил задание. Ниже предоставлены только функции, т.к. вызов и вывод сделать легко в основе. void first_push_back(int*& arr, int& size, int value)//Добавляет дополнительный элемент в начало массива { size++;//увеличиваем счетчик на 1 int* newArray = new int[size];//создаём новый динамический массив newArray[0] = value;//записываем в начало нового массива дополнительное число for (int i = 1; i < size; i++) { newArray[i] = arr[i-1];//записываем в новый массив данные из старого массива } delete[]arr;//удаляем старый динамический массив arr = newArray;//делаем так, чтобы указатель что указывал на масив arr указывал на массив newArray } void midle_push_back(int*& arr, int& size, int value, int n)//Добавляет дополнительный элемент в середину массива { size++;//увеличиваем счетчик на 1 int* newArray = new int[size];//создаём новый динамический массив newArray[n - 1] = value;//записываем в конец нового массива дополнительное число for (int i = 0; i < n - 1; i++) { newArray[i] = arr[i];//записываем в новый массив данные из старого массива } for (int i = n; i < size; i++) { newArray[i] = arr[i - 1];//записываем в новый массив данные из старого массива } delete[]arr;//удаляем старый динамический массив arr = newArray;//делаем так, чтобы указатель что указывал на масив arr указывал на массив newArray }

[@user-ss5le6hx1l]

А вот мой вариантик проги, удаляющей из массива определенное число(если есть повторы, удаляется первое ) : void Delete(int *&arr,int &size,int const value) { size--; int *Newarr = new int[size]; int Num_ofelement=0,k=0; for (int i = 0; i < size; i++) { if (arr[i] != value || k == 1) { Newarr[i] = arr[Num_ofelement]; Num_ofelement++; } else { Num_ofelement++; Newarr[i] = arr[Num_ofelement]; Num_ofelement++; k++; } } delete[] arr; arr = Newarr; } Delete(arr, size, “желаемое число");

[@user-hc1uc6zq7y]

чем дальше идём , тем всё хуже и хуже начинаю понимать. приходится по нескольку раз пересматривать

[@HuskyFullfilment]

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

[@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;

[@vladimirdiadichev6140]

Спасибо

[@user-vs7of7pd5y]

Ну народ, не мог я не выложить свой код по встраиванию в середину массива произвольного числа... 1.5 часа мозговой деятельности и в итоге ПОЛУЧИЛОСЬ. Возможно это колхоз, но главное результат (на текущем этапе моего развития в С++) void FillArray(int* const arr, const int size) { for (int i = 0; i < size; i++) { arr[i] = rand() % 50; } cout

[@skoripax]

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

[@tupoy_ytub_uberi_psevdonim]

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

[@lkkath]

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

[@tupoy_ytub_uberi_psevdonim]

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

[@panda9303]

Корректно говорить что мы передаем не указатель на ссылку (чего в природе С++ не существует), а ссылку на указатель.

[@Rogadze]

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

[@SimpleCodeIT]

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

[@Rogadze]

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

[@SimpleCodeIT]

Пожалуйста.

[@michaelbondarev8788]

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

[@stilljunior1764]

//реализация удаления среднего элемента массива, который состоит из 5 элементов: void pull_middle(int*& arr, int& size) { int* newarray = new int[size-1]; int nav = 0; for (int i = 0; i < size; i++) { if (i==2) { continue; } else { newarray[nav] = arr[i]; nav++; } } size--; delete[]arr; arr = newarray; } //реализация удаления первого элемента абсолютно любого массива: void pull_front(int*& arr, int &size) { int* newarray = new int[size-1]; for (int i = 1; i < size; i++) { newarray[i - 1] = arr[i]; } size--; delete[]arr; arr = newarray; }

[@SKrandy]

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

[@fitileo]

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