Угу, такая же фигня, у меня после перегрузки функций сразу идёт домашка с ссылками и указателями которые вообще не давали. Посмотрел несколько видео сразу стало понятно что от меня хотят, думаю что весь курс посмотрю.
Вы просто мой спаситель! Учусь в универе и на парах по программирования ничерта не понимаю, а вы так просто и на банальных примерах рассказываете, что невольно думаешь как этого можно было не понять, это же так просто! Огромное вам спасибо за ваш труд! Может пронимаете донаты в качестве благодарности?))))
Кажется у автора присутствует неточность про ссылки. Например если создать указатель на переменную, то у самого указателя и у переменной будут разные адреса. int a=5; int *b = &a; cout
Когда кажется ты лучше крестись, а не пиши глупые комментарии. В телефонной книжке пишем имя Андрей, но храним там телефон Наташи . (что говорит о том, указатель является переменной, хранящей адрес другой переменной.) Если написать на табличке Андрей и повесить её на Игоря то табличка, как ни странно не является человеком с именем Андрей и Игорь (Если же создать ссылку на переменную, то оказывается что адрес переменной и адрес ссылки совпадает, что говорит о том, что ссылка, как ни странно, является самой этой переменной хоть и с другим названием. Вот поэтому ее и разыменовывать не нужно.) Индейцу с именем Соколиный Глаз и Мозг Как У Динозавра советую 7 раз посмотреть урок с 15 : 42 (Соответственно своего отдельного адреса у ссылки нет. Именно поэтому нет указателя на ссылку, ссылки на ссылку, ссылки на пустое место.)
Не всегда для ссылки компилятор будет выделять память. Ссылка скрывает технические подробности. У переменной типа ссылка программист не имеет права взять его адрес. А если попытается, то получит адрес куда указывает эта ссылка. То-есть расположение ссылки в памяти полностью зависит от компилятора.
@@ДильбарМухамедова-щ3я Ну ты тоже, видно, самый умный. Мы конечно благодарны автору за 200+ уроков, но это не значит, что он не может ошибаться. Ссылка в C++ - это просто другой способ доступа к уже существующей переменной. Она фактически становится другим именем для переменной, на которую она ссылается, и используется для обращения к этой переменной. Для ссылки компилятор не выделяет память и адреса у нее нет, а указатель является переменной, которая хранит адрес, и для нее выделяется память со своим адресом. Теперь для умных объясняю: Указателя на ссылку в строгом смысле не существует, а ИМЕННО ЗАПИСЬ int&* p = ... На такое компилятор (Visual Studio) тебе ответит "Использование указателя на ссылку не допускается". То, что автор показал int* ppa = &aref; НЕ ЯВЛЯЕТСЯ, в прямом смысле, указателем на ссылку. Вместо этого, мы работаем с указателем на переменную, на которую ссылается ссылка, как бы странно это не звучало.
Адрес ссылки aref и адрес переменной а - одинаковые, на картинке в paint у Вас ошибка. Мне кажется понятней было бы в уроке сравнивать ссылку с ярлыком на переменную (как Вы это делали ранее) или сказать что ссылка - это по сути псевдоним переменной, т.е. та же переменная. А так на мой взгляд получилось немного путано. Но все равно спасибо! Мне нравятся Ваши уроки.
@@yaolegoleynik Когда говорится о взятии адреса, то надо понимать, что возвращается адрес не на переменную, а на данные, т.е. например на число 5. Переменная это просто имя для ячейки памяти, это имя существует только для компилятора. А сылка это второе имя (псевдоним) для той же самой ячейки, поэтому взятие адреса от переменной и от ссылки вернет один и тот же адрес.
Спасибо за урок! Отдельно хочу похвалить за очень граммотное построение очередности уроков, для новичка как я, с каждым последующим уроком открываются глаза на новые возможности уже знакомых по прошлым урокам действий. Так же хочу поделиться идеей выполнения предидущих уроков другим уже открывшимся сейчас способом. Так становится понятнее возможность выполнения урока разными, более осмысленными способами.
Ну кстати, если перед ссылкой при ее выводе, или обращению к ней, поставить амперсант (&), то мы будем работать (выводить) непосредственно с адресом ячейки памяти, а не с данными которые там хранятся. Так же как и в случае с указателем если его не разьеминовывать.
Здравствуйте! Спасибо большое за Ваши видео! Прекрасные видео! У меня к Вам просьба - не могли бы Вы сделать ролик, поясняющий практическое применение указателей и ссылок. Это практическое применение можно представить себе, если внимательно смотреть и слушать Ваши пояснения, но было бы просто замечательно получить эту информацию в одном ролике в разжеванном, так сказать виде. Те. чтобы ролик, возможно повторяя уже изученное, отвечал на вопрос, не 'Что такое ссылки?', а 'Зачем существуют ссылки', практическая роль ссылок, так сказать. Спасибо еще раз!
Большое спасибо за столь хорошее объяснение! Даже, когда уже давно прошел все это, иногда приходится поднимать какие-то знания, и в этом Ваше видео как всегда помогают
@@SimpleCodeIT , непонятно, почему же при присваивании указателю *ppa числа 12, сама переменная изменила значение на 12, ведь указатель *ppa присваивался адрес, где хранится запись о ссылке, а не адрес о переменной, то есть переменная "а" не должна была поменять своего значения.
Очередное открытие сделал для себя srand((int)pa); // по цифре указателя на память, она же при каждом пуске прогр. разная. Случайные числа без использования. #include srand(time(NULL));
Уроки супер, я в восторге. Только замечание: В предыдущих уроках было хорошо и понятно рассказано как работать с указателями, но...Но ни слова о том, зачем вообще так делать, зачем работать по указателям, вместо имён переменных
Прохожу курс, и могу сказать что это прекрасный материал! Простым понятным языком, очень легко и быстро материал ложится в голову, спасибо огромное! У меня в универе скоро начнется работа с windform, пытался найти курс по нему, но там большинство видео о С#, я думаю многим был бы интересен ваш курс по С++ windform)
То есть автор по ходу не сечет в ссылках, но учит других, браво! У него ссылка и переменная на которую она ссылается имеют разный адрес в памяти. Это гениально!)))
Пока разбирал тему указателей... Столько годных каналов нашел на всю эту тему. Жеесть! Щас столько ребят которые просто срут в уши и ничему не учат что ппц...
Под ссылку не выделяется выделяется никакая память. Адрес у ссылки ровно такой же, как и у переменной на которую она ссылается. Ссылки в памяти не существует.
Спасибо вам за уроки! Столкнулся с неясностями в книге с ссылками, там они идут раньше указателей(поэтому пришлось посмотреть ещё предыдущие уроки, что дало мне больше ясности гораздо). Стало гораздо понятнее!
@@SimpleCodeIT у вас очень годные уроки и за это вам честь и хвала, НО...курс по С++ публиковался на протяжении долгого периода времени, сейчас начался курс С#. Так что с такой скоростью уроки по всем этим языкам появятся спустя лет 5 а то и 10
На 15:55 Вы говорите, что под сслылку выделяется ячейка. Но это не так. Ссылка может быть применена лишь к уже существующему адресу, просто она меняет синтаксическое воплощение этого адреса. Т.е. если вывести на консоль &ppa, то будет выведен адрес ppa (это элемент "ссылка"). И он будет такой же как и адрес переменной а (т.е. если вывести &a)
@@Recon83Vl Я тоже смотрю и понять не могу, если в PPA содержится адрес AREF (не путать с адресом содержащимся в AREF), то разыменовав PPA и присвоив 12 получится, что ссылка должна ссылаться на адрес 12, а это скорее всего AV. @Aleksandr Teplyuk правильно написал, теперь понятно почему в переменной A содержится 12, если конечно это не умный компилятор, но тогда бы было очень запутанно. Хотя чёто я запутался
Чтобы не мудрить тоннами слов... я просто считаю ссылку константным указателем на объект, который(ref) разыменовывается автоматически(без оператора *). По моему это все, что нужно знать о ссылках. Под капотом компилятора это так и реализовано. И экономия при передаче параметрами огромных объектов, так же точно реализуется передачей указателя, а не копии объекта. Вся разница в отсутствии * и обязательной константности
Что то не сходиться с теорией, по теории ссылка "ARef" лежит в другой области памяти (имеет другой адрес) на которую указывает указатель "ppA", но на практике: и переменная "А" и ссылка "ARef" находятся по одному адресу, как так??? int A = 5; // переменная "A" cout
Указатели и ссылки непростая "штуковина" для новичков. Совместно с *битовыми операторами* это чаще используется для низкоуровневого программирования. Практические примеры были лучше для UI (Windows Form), Qt, Wx, OpenGL, DirectX и.т.п. *Но в общем отличный и почти полный, классический и уникальный курс по С++. на рус.* Конечно, все остальное - это уже могут быть доп. курсы.
Ссылка не хранит в памяти указатель... Это просто альтернативное имя переменной, которое нужно чтобы её можно было передавать в другие области видимости. На 16:50 у тебя нарисовано, что у ссылки и переменной разный адрес в памяти. Это не так, адрес у них одинаковый, потому что это один и тот же объект.
собственно нужно освоить и 16-ричную систему счисления. там все просто. нужно просто провести аналогию с 10-ричной и представить, что там не 10 символов (цифр), как нам привычно, а 16. И например число 15 там можно отобразить всего одним символом, как число 9 в 10-ричной системе.
Спасибо за видео, уважаемый Сергей! Уважаемые, я понял, что aref, *pa - это просто новые имена переменной a. А pa, &aref - это имена адреса этой самой переменной a! Всё просто сейчас, хотя раньше был туман!
Не совсем. "pa" - это, в нашем случае, отдельная переменная, которая хранит в себе адрес переменной "a", и для "pa" выделяется отдельная ячейка в памяти. Оператор * в данном случае позволяет получить доступ к данным, которые хранятся по адресу, который хранится в "pa". Т.е. "pa" сам по себе ничего не знает о переменной "a". Так, указатель может также хранить адрес, ни связанный с никакой переменной (адрес динамически выделенного блока памяти, адрес фиксированного аппаратного буфера и т.д.), и оператор * также можно (чисто технически) применить и непосредственно к адресу, например, *0x12345678 = 5; но стоит ли так делать, это уже отдельный вопрос)
Огромное спасибо за ваши уроки, если вдруг кто прочтет то по данному уроку такой вопрос , при выводе в консоль единовременно адреса памяти указателя и адреса памяти ссылки, адреса не совпадаю, это говорит о том что указатель занимает свой уникальный адрес в памяти, а сслыка использует адрес памяти присваимаего значения?
Про NULL вообще лучше забыть, т.к. при перезагруженной функци, foo(int a) и foo(int *a), если у вас указатель был обнулен с помощью NULL, он конвертируется в Int и будет вызвана функция foo(int a). А оно вам надо?
насколько я понял, интуитивное различие указателей и ссылок состоит в том, что указатель создает переменную, которая хранит адрес другой переменной, в то время как ссылка создает переменную, которая хранит значение другой переменной по данному адресу наверно
Создание переменной ссылочного типа - это не создание переменной как таковой, а создание нового идентификатора под какой то объект, чаще всего именованный.
Спасибо! Но в объяснении на 16-ой минуте небольшая ошибка. Адрес ссылки или указателя после ссылки/указания на переменную равны адресу той переменной, на которую указывают/ссылаются.
Есть ли у ссылок свое место в оперативной памяти? Взятие адреса оперативной памяти у указателя говорит о том что под указатели отводится определенное место в оперативной памяти. В то время как взятие адреса у ссылки возвращает адрес переменной на которую ссылается ссылка. Получается что своего места в оперативной памяти ссылки не имеют?
У Вас ошибка! Если указателю присвоить адрес ссылки, то он будет хранить адрес переменной, на которую ссылается ссылка. Потому что ссылка -- это саморазыменовывающийся указатель. И при взятии ее адреса, она возвращает адрес переменной, на которую ссылается. int a = 5; int &ref = a; int *p = &ref; std::cout
А нельзя использовать указатель для целей, которые Вы рассказали в конце? Ну тип указатель на объект, вместо ссылки на объект? Я не знаю, просто спрашиваю)
В отличие от указательной переменной, которая всегда занимает место в памяти, ссылочная переменная может не занимать место в памяти вообще (зависит от реализации компилятора).
Спасибо за урок. Немного не понял про взаимодействие указателей и ссылок. После выполнения &aref = *pa куда будет ссылаться aref? На адрес указателя pa или напрямую на адрес переменной a?
Работая с одиночными переменными память не экономишь, но приобретаешь гибкость. Экономить начинаешь, работая с массивами, с функциями, с методами классов
Это как курица = яйцо, но мы не сравниваем их, а присваиваем яйцо курице. То есть это не обычное присваивание, а скрытая перегрузка оператора = короче тут магия...
Так ссылка же хранит в себе не только данные переменной, но и адрес, почему в паинте вы указали, что ссылка хранит в себе свой адрес, или я что то недопонял?
UPD: моё утверждение ниже ошибочно, переназначать ссылку после инициализации НЕЛЬЗЯ! Да, можно. Для этого надо писать, например, так: int a = 5, b = 27; int &ra = a; //инициализируем ссылку ra = b; //в таком случае переменная 'a' станет равна 27 &ra = b; //в таком случае мы заставим ссылку 'ra' ссылаться на переменную 'b', которая равна 27
@@BadDanFeeds Чушь не пишите!!! Если вы проинициализировали ссылку ra переменной a, то переназначить на другую переменную НИКАК, можно лишь только значение менять, но не адрес.
@@РоманМороз-д2я Проверьте мой код. Выведите значение ссылки в консоль до переназначения, и после. А ещё лучше, чтобы убедиться что ссылка переназначилась, а не просто передала родительской переменной значение новой, выполните при переназначении префиксный инкремент, а затем сравните обе переменные. Вы увидите, что у 'b' прибавилось 1, а у 'а' - нет, что и будет доказательством возможности переназначения ссылки.
@@РоманМороз-д2я И не забывайте, что при использовании амперсанда при переназначении, вы как раз таки даёте компилятору указание к редактированию значения ссылки, а не ссылаемой переменной. А вот уже без амперсанда вы получите простое присваивание ссылаемой переменной нового значения.
В строчке "int *ppa = &pa;" ты пытаешься инициализировать указатель 'ppa' адресом указателя 'pa'. То есть в указатель, в котором должен лежать адрес, ты кладёшь адрес на указатель, в котором хранится адрес. Но указатели не имеют своего адреса, они и есть адрес. И поскольку в указатель 'ppa' нам надо положить адрес, а указатель 'pa' и есть адрес, то надо написать просто "int *ppa = pa;". Понял? Если нет, то вот ещё объяснение: a = 5. &a = 0046FCF0 (где '&' - оператор взятия адреса, а 0046FCF0 - сам адрес, как пример). pa = &a = 0046FCF0 (но вот *pa = a = 5, так как делаем разыменование). И поскольку 'pa' и есть адрес, а в указатель 'ppa' мы как раз и должны положить адрес, то и кладём в 'ppa' просто 'pa'. И в таком случае ppa = pa = &a = 0046FCF0. И получается, что если под амперсандом ты подразумевал ссылку, то ссылок на адрес не существует. Или, если под амперсандом ты подразумевал оператор взятия адреса, то адреса на адрес не существует. Короче, в итоге правильным вариантом будет int *ppa = pa;
Здравствуйте с удовольствием смотрю ваши уроки, но по поводу ссылки вы объясняете неправильно. Время 15:50 в оперативной памяти не выделяется никакого адреса под ссылку и ссылка никакого значения не хранит, ещё в момент компиляции наша ссылка заменяется на тот адрес на который она ссылается. Вы правильно объясняли, что за каждым именем которое мы даём переменным или функции стоит адрес в памяти. Поэтому когда мы объявили и инициализировали переменную 'а', а потом создали ссылку на неё 'refa', то получилось всё равно что мы к лэйбику 'a' за которым стоит адрес в оперативной памяти наклеили ещё один лэйбик 'refa', на тот же самый адрес. Как-то так. :)
Неправильно, ссылка не имеет своего адреса, у нее адрес будет такой же как и у переменной, соответственно, если указатель занимает в памяти 4 байта, то ссылка будет занимать 0 байт, вернее 4, но это будет все та же переменная....
Если сделать две программы, где в первой есть переменная и мы знаем еë адрес, а во второй делаем переменную-указатель такого же типа и указываем ей адрес переменной в памяти и вывести еë в консоль, будет ли значение переменной первой программы выводиться во второй программе?
Нет, адреса программы зависят от области памяти куда загрузит ее ОС. Если же речь идет о программах выполняемых одновременно, то их адресное пространство изолировано друг от друга. Нельзя из одной программы читать память другой.
