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

Понравилось видео или оказалось полезным? Подпишись!

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

Уроки по программированию

[SimpleCodeIT]

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

[franciscrowley]

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

[levmurflatazara]

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

[hodbozd]

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

[ilyastasiuk]

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

[sankarshanarama]

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

[archiechellaut]

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

[overdoses]

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

[zllhmmp]

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

[pv_r]

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

[RussiansNeverGiveUp]

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

[Scriberrot]

Во время понимания int *& arr записал такой комментарий к коду. Может, кому-то пригодится:






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

Передавая указатель на массив в int*& arr, мы передаем его(указатель) по ссылке т.е. arr из функции- ссылка на arr(указатель) из main. Это значит, что все изменения с arr из функции отразятся на arr из main. Значит, ссылка на указатель(int *&) позволяет передать указатель в функцию не по значению, а по ссылке. Это в свою очередь позволяет производить изменения напрямую с arr из main (как с данными так и с самим указателем (допустим, присвоить указателю новый массив))

*/

[Arjuna]

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

[AnnTimLeo]

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

[pavlikwest]

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

[twutklz]

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

[sdqvoon]

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

[valik]

Все остальные функции по работе с динамическим массивом:
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 << NewArray[i] << "\t";
}
if (i == index) {
NewArray[index] = value;
cout << NewArray[index] << "\t";
for (int j = index + 1; j < size+1; j++) {
NewArray[j] = arr[j-1];
cout << NewArray[j] << "\t";
}
break;
}
}
delete[] arr;
arr = NewArray;
size++;
}
void pop_gap(int*& arr, int& size, int index) {
int* NewArray = new int[size - 1];
for (int i = 0; i < size; i++) {
NewArray[i] = arr[i];
if (i != index) {
cout << NewArray[i] << "\t";
}
if (i == index) {
for (int j = index; j < size-1; j++) {
NewArray[j] = arr[j + 1];
cout << NewArray[j] << "\t";
}
break;
}
}
delete[] arr;
arr = NewArray;
size--;
}

[jpqbbrk]

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

[jrhtjlg]

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