Спирсофилия

Новый вид заболевания: "Спирсофилия"
Первый случай зафиксирован в 1998 году, в США.

Симптомы: при упоминании/просмотре/прослушивании (и так далее) некой "Бритни Спирс":

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

Глаза: либо закатываются, либо слезятся от счастья (в особо тяжелых случаях закатываются в слезах)

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

Врачи предупреждают: будьте осторожны! Болезнь хотя и не опасна для организма (правда нарушения работы головного мозга имеют место быть), но болезнь неизлечима! Более того, зафиксированы случаи заражения даже при отсутствии непосредственного физического контакта (например, заражение через сеть Интернет)

При обнаружении больного Спирсофилией (спирсофила) в непосредственной близи от Вас, пожалуйста:
1. Не паникуйте
2. Включите ему что-нибудь из Бритни
3. Избегайте непочтительных высказываний в адрес Бритни (бывали случаи жестокого убийства, с последующим сожжением трупа)

Повторяем: БОЛЕЗНЬ НЕИЗЛЕЧИМА! Берегите свое здоровье))) Ваш минздрав.

@темы: Britney Spears

---

Бритуля в "темный период" - 2006-2007-начало 2008-го

Обыкновенная ночь Бритни в те периоды. На видео, кстати, запечатлен момент, где она цепляет Аднана, папарацци, ставшим на некоторое время ее любовником.

В начале Бритни ищет свою флешку с фотоаппарата, один из папарацци находит ее и отдает ей.

Бритуля часто использовала папарацци для "неотфильтрованного общения с миром". Здесь, на этом видео, она с сарказмом говорит примерно следующее:

"Америка верь всему что пишут, что я пью постоянно..... вы все, ведь, такие умные а я глупая. Мой менеджмент был прав, когда отправил меня в лечебницу! Мир такой хороший. такооооой хороший. И дама подошла ко мне и сказала: "Бритни иди на свет и увидь Иисуса...". Я так и сделала...потому что наш мир такой хороший"

Мир пытается ее затоптать, а она просто стебется с этого!

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

@темы: Britney Spears

---

Бритни: Изнанка мечты

- Ватсон, вы можете сказать, сколько ступенек в прихожей?
- Восемь.... ээ... семь!
- Десять, – сказал Шерлок Холмс, – Первая скрипит, на второй 2 года назад меняли доску.....

Доброго времени суток, все кто читает!

Как известно, я недавно купил 2 книги про Бритни, об этом я писал ранее. Первая называется "Бритни Спирс. Скандальная биография" (Шон Смит), а вторая - "Бритни. Изнанка мечты" (Стив Деннис). Чуть менее месяца назад я закончил читать "Скандальную биографию" и даже написал тут свою рецензию на книгу. Кто читал, возможно помнит, что я не остался доволен работой Шона... но у меня была вторая книга "Изнанка мечты" и я решил сделать перерыв между ними, чтобы было не скучно читать вторую, подозревая, что она не намного будет отличаться от первой.

К своей неподдельной радости, я почти с первых строк обнаружил, что я глубоко заблуждался и на сей раз меня ждет интересная исследовательская работа человека, который ИМЕЕТ представления о том, как нужно подходить к решению такой масштабной задачи: биография. Кроме того, что он начал буквально рыть носом землю, он собрал неплохую команду людей, и главным его советником был психолог, имеющий достойное образование и большой практический опыт (около 20-ти лет практики).

Как только я узнал о наличии такого важного игрока, то мне стало понятно, что автор настроился на глубокий анализ причинно-следственных связей и что меня ждет не легкое развлекательное чтиво (коим я пресытился, читая Шона), но труд, который потребует от меня предельного внимания к мелочам (именно из-за этого я и начал этот пост таким эпиграфом), а так же самостоятельного анализа прочитанного. Я откинулся в кресле, открыл книгу и включил мозг.

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

Начал автор с того, что добился встречи со вторым, по важности, человеком, делающим бренд "Бритни Спирс", ее бессменным менеджером Ларри Рудольфом. Когда Ларри спросил, какова его цель? Стив честно признался: "Понять, кто такая Бритни и что за человек скрывается под маской одноименного бренда". Ответ немало повеселил Ларри и он искренне пожелал удачи, потому что: "Браток... Бритни сама не знает ответ на этот вопрос, хотя мучается над ним до сегодняшнего дня, так что удача тебе понадобится".

Однако, трудности не смутили автора и он начал свои тяжелые поиски. Надо сказать, что стиль, в котором писалась книга, был интересен тем, что он не строго придерживался хронологической цепочке событий, что позволяло многие случаи и поступки Бритни "завязывать" как на будущем, так и на прошлом этой прекрасной девушки. Размах был по-истине колоссальным, потому, что Стив задел не только саму Бритни и ее родителей, а проследил за историей семьи от того момента, когда, после Второй мировой войны, на землю Луизианы ступила нога миловидной англичанки, которую увез из Британии дедушка Бритни по материнской линии.

Бедная, молоденькая дурочка, считала, что в США ее ждет прекрасная и романтическая жизнь Юга, описанная в книге "Унесенные ветром", однако, очень скоро она столкнулась с реальностью: тут люди нищенствуют и очень тяжело работают вдали от многих прелестей цивилизации, практически, живя общинным строем. Поговаривают, что из-за страха, что поехав к родителям в гости, его жена больше не вернется, дедушка Бритни так ни разу и не отпустил ее за пределы крохотного городка сельского типа, и единственной отдушиной этой бедняжки, стала рожденная ею Линн (мама Бритни), в которую та вложила всю душу и все надежды, что ее милой дочери будет уготовлена лучшая судьба.

Однако, дочь поспешила выскочить замуж, будучи еще совсем юной, за сильного и красивого парня, который совсем недавно развелся со своей первой женой. Но не зря эта местность называется "библейским поясом": здесь живут очень набожные люди, баптисты, и само слово "развод" считается незаконным. Семья Линн не была бы в восторге от такого поворота событий, поэтому, предвидя негативную реакцию родителей, Линн вышла замуж тайком, в другом штате, принеся в жертву свою мечту о яркой и пышной свадьбе. Автор позволяет ТУТ ЖЕ сделать ссылку на будущее Бритни, напомнив о небезызвестном браке с Джейсоном Александром, который продлился 55 часов.

Выйдя замуж за Джейми Спирс, Линн тут же погрязла в семейных хлопотах, похоронив себя и мечту своей мамы о том, что ее дочери уготовлено более светлое существование за пределами этой, богом забытой дыры. Через очень короткое время у них родился старший сын Брайан, а Джейми начал по-тихоньку спиваться. Линн как могла контролировала эти попойки, слезами, угрозами и договоренностями об "определенных днях, когда можно", однако, судя по-всему, потерпела фиаско и когда нервы ее были на пределе - Линн Спирс подала на развод. На дворе стоял 1980-й год, и до рождения Богини оставалось совсем немного.

Джейми смог убедить жену его простить и на некоторое время завязал с выпивкой, а в доме воцарилось шаткое перемирие. Именно в такой нервной и напряженной среде, 2 декабря, 1981 года, появилась долгожданная дочка, на которую тут же была взвалена материнская надежда, что ей уготовлена более радужная судьба, чем самой Линн. Однако рождение маленького ангела было омрачено тем, что Джейми вернулся к старому увлечению - к бутылке.

В семье возобновились скандалы, ссоры, частые разборки, рискну предположить - и драки и это не могло не повлиять на психику чудесного ребенка, в ее самом нежном возрасте. Бритни росла тихой и закрытой в себе девочкой, настолько застенчивой, что она даже не решалась сесть на коленки к Санта-Клаусу, получая скудные подарки на Рождество.

Автор находит даже объяснение алкоголизму Джейми, а именно той закономерности, что вспышка дурного порока приходится именно на те периоды, когда в семье рождается ребенок. То, что откопал исследователь, поражает до глубины души: когда Джейми было 14-ть лет, его мать покончила жизнь самоубийством, на могиле своего сына, умершего через несколько дней после рождения, оставив Джейми без материнской ласки и любви, заставив подумать, что "он не важен".....

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

Я заметил, что не могу читать эту книгу "взахлеб", хоть она написана ОЧЕНЬ интересно и профессионально. Мне часто приходится делать перерывы, чтобы хоть как-то осадить в себе тот ужас, который я читаю. Возможно, если бы книга была написана о человеке, который мне менее важен, то я бы не воспринял все это настолько тяжело, но речь шла о той самой Бритни, которую я ОЧЕНЬ сильно люблю и подобные истории словно ножом скребли по сердцу.... кроме того есть еще один фактор: я, так же как и Стив, одержим идеей разглядеть человека под брендом, поэтому, выводы, которыми автор осыпал меня, я пропускал через себя, через собственный фильтр анализа, стараясь понять, насколько они мне кажутся правильными и точными. Хочу заметить, что в подавляющем большинстве случаев я принимал его точку зрения.

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

Что же говорит по этому поводу психолог? Он утверждает, что "сгусток энергии", который наблюдали окружающие, был ни чем иным, как "сгустком тревог". От ссор и перепалок родителей Бритни все время пряталась в "собственном мире" сказок и "выступлений", воображая себя жителем прекрасной, сказочной страны, или поп-звездой "круче чем Мадонна" (ее кумир), давая "концерты" своим любимым куклам. Таким образом Бритуля научилась выстраивать вокруг себя "мыльный пузырь", под защитой которого она чувствовала себя счастливой.

Есть еще пару интересных фактов: Бритни с детства маниакально любила порядок и чистоту. Она всегда прилежная, чисто-одетая, всегда идеальный порядок в комнате... она любит одну и ту же книгу... любой психолог вам скажет, что этим внешним порядком и стабильностью, ребенок пытается контролировать тот КОЛОССАЛЬНЫЙ хаос, который творится у нее в душе!

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

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

Этот момент ОЧЕНЬ важно понять! Потому что бОльшая часть ее проблем произойдет ИМЕННО потому, что она так и не смогла нащупать "собственное я", то есть, тот стержень, который у многих людей заложен внутри, у нее оказался снаружи, зависим от внешних, неподвластных ей факторов. Добавь сюда еще постоянное понимание "я должна вот этим людям" и мы получим объяснение ее поискам, кризисам и прочим неприятностям, которые случатся с нею в будущем.

Бритуля сильно стремилась стать поп-звездой, ее увлекала ЛЮБАЯ возможность, которая только была. Вопреки распространенному мнению, что именно мать толкнула ее на "звездный путь", можно отчетливо увидеть, что именно Бри стремилась стать тем, кем стала, а мать лишь уцепилась за эту, спасительную соломинку, подстегнутая мечтой "лучшей жизни" для своей дочери, которую не смогла обрести сама.

Далее следует известная история, как Бритни попала в финал конкурса "Поиски звезды", порвав всех своих соперников по дороге. И тут всплывает еще один интересный факт: в родном городке одаренной малышки, резко возросли продажи кабельного телевидения: ВЕСЬ город хотел наблюдать и лично болеть за свою землячку! Она проиграла финал одному мальчику с минимальным разрывом: четверть звезды, но Бритуля воспринимала только первые места, поэтому, сохранив достойное лицо и пожелав сопернику удачи, она закулисами разревелась, думая, что подвела маму и весь, болеющий за нее, город.....

Однако, на родине ее встречали бурно и даже мэр обьявил день финала "официальным днем Бритни Спирс". По всюду были развешены плакаты с поздравлениями: ее встречали как настоящую звезду! Она вдруг стала доказательством того, что "возможно все", раз девочка, с такой глухой и богом забытой деревни, едва достигшая 10-ти лет - попала в телевизор и даже заняла второе место - КАЖДЫЙ может! Автоматом она ощутила 2 привычные для себя вещи:
1. Она ответственна за надежды всех этих людей
2. Ее воспринимают ТОЛЬКО как "Бритни - артиста"

Не знакомо ли?

Естественно, когда маленькая Бритничка захотела попробовать свои силы в новом клубе Микки Маус (ее вдохновили собственные успехи на конкурсе "Поиски звезды" ) мать расшиблась в лепешку, чтобы помочь дочери попасть в эту "фабрику звезд". На прослушивании Бритуля буквально поражает комиссию! Один из влиятельных лиц в диснеевской фабрике называет Бритни "тройной опасностью", так на жаргоне профессионалов зовут тех, кто одновременно прекрасно поет, отлично танцует и обладает актерскими способностями. Она была отобрана из 20 ТЫСЯЧ претендентов и начала учиться "быть звездой".

Все наставники и учителя в один голос говорят, что она - не такая как все. Например, мама Джастина, с гордостью рассказала Линн, что Джастин серьезно задумался о своем сценическом имени и остановился на "Тимберлейк" (фамилия его родного отца, а не отчима, с которым он жил). Мамы других "мышкетеров" все время стремились разузнать, какие шансы дает их детям участие в клубе и как повлияет все это на карьерный рост. Обычно все дети приходили туда с одной целью получить хороший трамплин для взлета к звездам и ни капли этого не скрывали. Бритни и Линн, были пожалуй единственными в их обществе, которые смотрели на все это как "туристы, случайно угодившие в прикольную сказку", постоянно чувствуя себя не на своем законном месте, а "просто повезло".

Лучше всего у Бритни получалось именно танцевать; это она учила Джастина и Кристину танцам, в то время, как Кристина занималась умением петь Бритули. У Бри внутри был некий "переключатель". Она, застенчивая, пугливая и тихая, у которой от страха перед выступлением просто подгибались коленки, выходя на сцену словно переключала тумблер! И вот, ровно через секунду она становилась уверенной, умелой, ловкой и неподражаемой Бритни Спирс, заставляя глаза наблюдателей приковаться к МОЩНЕЙШЕМУ источнику энергии, которую излучала. Но как только выступление заканчивалось - тумблер тут же переключался в обратное положение и перед нами вновь стояла тихая и застенчивая деревенская девочка, хлопая широко открытыми, наивными глазами. Но, как и везде прежде, она была прилежной ученицей, перфекционисткой во всем!

Однако, вскоре клуб Микки Маус закрылся и Бри с Кристинкой остались не у дел, выброшенные за борт поп-индустрии. Но Бритни настолько запомнилась диснеевскому директору, что тот "замолвил словечко" нужным людям, и вот, она, в сопровождении практически всей деревенской семьи (мама, брат, тети, дяди....) приехали в Нью-Йорк. Очутившись в самой гуще Манхеттена, разглядывая небо поверх небоскребов, а так же задыхаясь от количества машин, людей, шумов, шокированная Чуда спросила у мамы: "а где здесь пасутся коровы???"

Кроме нескольких эпизодических моментов, никак не повлиявших на ее судьбу, через какое-то время они познакомились с адвокатом, специализация которого была поп-индустрия. Его звали Ларри Рудольф. Ларри, так же как и многие, которым довелось увидеть юное дарование с "правильным положением переключателя" был поражен. Он рассмотрел некую изюминку в девочке и понял, что когда та подрастет - она поставит на колени всю поп-музыку США (а значит и мира) и сама будет диктовать моду.

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

Так или иначе, вернувшись в Луизиану, Бритни ждала своего звездного часа, постоянно названивая Ларри, с вопросом: "есть ли хоть ЧТО-НИБУДЬ???". В итоге, записав несколько демозаписей, Бритни вновь очутилась в Нью-Йорке, в офисе Ларри. На тот момент будущей Богине было менее 16-ти лет.... Ларри побегал, договариваясь о прослушиваниях и результатом его трудов стал "временный" контракт на 90 дней со звукозаписывающей студией Джайв рекордс. Уже через пару дней начались репетиции и пробы: Бритни суждено было записать свой первый и сегодня уже культовый сингл "...Baby One More Time".

Наблюдая за работой над синглом, директор "Джайв рекордс" убедился, что он не просчитался и временный контракт был аннулирован, а Бритни предложили сотрудничество, скрепленное долгосрочными обязательствами. Студия взялась со всей серьезностью за продвижение нового бренда "Бритни Спирс" и, через какое-то время на съемки одноименного клипа был приглашен известный режиссер Найджел Дик.

Существует версия, что у него, изначально, была совершенно другая задумка сюжета, но Бритни настояла на своей идее: католическая школа, скучающая в классе ученица... сразу возникает вопрос: КАК тихая, наивная и податливая девочка посмела диктовать свои условия акуле Голливуда? Однако, этому есть веское объяснение: в прилежной ученице школы Микки Мауса "включилась" заложенная ей функция - думать как то, что ты делаешь связывает тебя с твоим зрителем? И Найджел Дик, засунув свою гордость глубоко в карман, справедливо решил, что: "пожалуй, эта малышка лучше знает что ближе по-духу таким же мальчикам и девочкам как она"

Показательно, что ровно через год, на съемках клипа "Oops!.. I Did It Again" Бритни уже во всю будет диктовать собственные условия в костюмах и сценах, и когда ее идея с костюмом не понравится даже руководителям "Джайв", они все равно не посмеют в открытую перечить 18-ти летней хозяйке положения, послав бедного Найджела Дика на поиски компромисса, со словами: "ты режиссер - тебе и разруливать!". Он сможет найти компромисс, сменив предложенное платье Бри, на более скромное, но, режиссер, снявший на тот момент бОльшую часть ее клипов, больше никогда не будет приглашен сотрудничать.... заставляет задуматься!

И вот, эта БОМБА вышла и взорвала буквально ВСЕХ подростков в США! Сингл, а после альбом получили ТАКУЮ популярность и ТАКИЕ кассовые сборы, что Бритни поднялась на первые места практически всех топов Америки, побив рекорды, которые еще недавно казались незыблемыми....

Далее автор много рассказывает о реакции Бритни, о реакции НА Бритни, о ее турне по торговым центрам США и о ее тайных отношениях с ее другом по клубу Микки Мауса - Джастином. Я лишь остановлюсь на интересном случае и освещу роль Джастина в судьбе Бри, в ту пору. Кроме того, что он был ее "тайным парнем", он выполнял еще одну, более важную, на мой взгляд роль: он был стабильностью и опорой Бритули в ее тревогах, которые под давлением невообразимой славы, только усилились. Дошло до того, что Бритни стала панически бояться одиночества, и по ночам она спала крепко прижавшись к своей маме.

Положение ухудшилось во время первого мирового турне Богини (Oops!.. I Did It Again World Tour), перед европейской ее частью и врачи выписали ей лекарство "Прозак". Конечно, все происходящее вокруг не способствовало лечению, но кого это волновало? Бритуля приносила такие доходы, которые не снятся многим заводам, обеспечивающим рабочие места для тысяч людей! Она вдруг осознала, что она уже не на конкурсе талантов и у нее нет возможности просто покинуть тот поезд, который не умел тормозить, не умел ехать назад, а с каждым разом только ускорялся......

Разрыв с Джастином больно ударил по ней и она лишилась привычной опоры, которую находила в его понимающих глазах. Это случилось накануне ее очередного, мирового турне Dream Within A Dream. Но... Бритни - профи и зрители не видели, что творится у нее на душе, потому что выступая она вновь несла людям счастье и сама заряжалась энергией, а ее "переключатель" никогда не давал сбоев: как только она оказывалась на сцене - мир падал к ногам уверенной, сильной, прекрасной Владычицы умов! Никогда не давал сбоев... кроме одного раза: последнего выступления в рамках тура, который прошел в Мехико. Бритни просто остановилась посреди 5-й песни (Stronger), и выкрикнув: "извини меня, Мехико, я люблю тебя!" - покинула сцену и почти сразу же и пределы страны.

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

Для начала Бритни решила восстановить справедливость и позаботится о своей маме, к которой она была так близка: она настаивает на разводе родителей, оплачивает все их долги, переписывает их старое бунгало на имя отца, а для мамы строит шикарную усадьбу, которую называет "Безмятежность". По-сути, Бритуля сделала все, чтобы вырезать отца из семьи! Она не забыла те страдания и страхи, которые принес в их дом дурной порок ее папы.

Что же касается взаимоотношений с остальным миром, то теперь ею движет желание шокировать всех своей сексуальностью. Несколькими годами ранее она боялась этих голодных взглядов мужчин, но теперь - она купается в них! Она дразнит, она играет, она шокирует! Стремясь заполнить пробел, образовавшийся после Джастина, она становится женщиной-вамп. К ее ногам падают абсолютно все, кого она только захочет, наступает период тусовок, веселья и безудержного, беспорядочного секса.

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

Однако, точно так же, как после выступления образуется вакуум, такой же вакуум она чувствует, как только секс с очередным мужчиной заканчивается. Кроме всего прочего, она осознает, что она становится предметом гордости мужчин: "Знаешь, чувак, а я спал с Бритни Спирс!". Это не то, что она ищет! Она хочет, чтобы хотели ее, потому что она такая, а не ее, потому что она - "мегазвезда Бритни Спирс". Все чаще она употребляет слово "нормальная" в своем лексиконе: "я - нормальная, такая же как все люди", "я хочу нормальной жизни". То есть, она мечтает, что сойдя со сцены она будет превращаться в обычную, нормальную девушку, которая ходит по магазинам, сидит в кафе, ходит в кино.... чтобы люди видели в ней звезду только когда она поет для них, а в очереди за колбасой воспринимали ее так же, как и любую другую среднюю американку... но... к сожалению, так это не работает....

Для примера - пару обычных дней из жизни Бритни Спирс:



Вот, примерно так проходит каждый ее выход на улицу, уже почти 13 лет......

Между Бритни-суперзвездой и Бритни-человеком образовывается огромная трещина, которая все больше и больше растет. На сцене она сильная и властная, а дома - тихая, замкнутая и растерявшаяся. Причиной такого результата становится то, что она до сих пор не разобралась в вопросе: "кто я такая, когда не пою? Нужна ли я кому-то вне сцены?". Она стала мегазвездой не успев разобраться, понять, нащупать собственное "я".

Еще одним показательным фактом отчаянных поисков становится то, что Бритни даже пытается найти для себя нового Бога! Она, усомнившись и забросив баптизм теперь начинает увлекаться Каббалой. Конечно, в этом видно влияние Мадонны, которая уже давно из кумира превратилась в близкого друга. Мадонна дарит ей несколько старинных и очень дорогих книг по Каббале, написанных на иврите. Интересно то, что Бритуля не знает этого языка вовсе и буквы, которые написанные в этой книге она не понимает, но на вопрос: "Как же ты читаешь эти книги?", она отвечает: "Их не нужно читать. Я просто открываю книгу и медитирую на загадочные символы еврейского языка. И когда я достигаю связи с космосом, то мне объясняется что именно там написано" и Бри уверяет, что в Каббале она находит ответы на те вопросы, которых не давала ее христианская вера. (меня, как носителя этого языка не мог не улыбнуть такой подход, мне даже стало интересно: а что если попробовать такой же фокус с моими учебниками по математике? Они тоже написаны на иврите... я буду открывать их и начинать медитировать... может я лучше познаю эту науку?)))

Но, кроме шуток, нам этот случай показывает ту отчаянность, с которой мечется молодая Богиня, как только она становится "обычным человеком", то есть - вне альбомов, выступлений и восторженных взглядов толпы. Автор обращает внимание, что не вся звездная жизнь ей нравится. Например, самое ненавистное ей занятие - это встречи с фанатами. Не потому, что она черствый человек, даже наоборот: о ней отзываются как о доброй, отзывчивой и щедрой. Но та застенчивая девочка, которая с самого детства боится и опасается незнакомых людей (помните Санта-Клауса?) - вдруг вынуждена встречаться, фотографироваться и улыбаться кому-то, кого она впервые видит...

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

2004 год становится поворотным в отношениях Бритни с ее окружением. Поняв, что ее внутренний мир и ее состояние не заботят никого, кроме ее самой, она решает, что теперь не позволит ВОВСЕ собой манипулировать! Она увольняет своего менеджера Ларри и говорит, что теперь САМА будет распоряжаться собой и своим имиджем. Ей не нужны указки и она не хочет выслушивать от людей, что ей делать. Она поклялась, что расторжение 55-ти часового брака с Джейсоном Александром - это было последнее, что она сделала по чьему-то настоянию.

Несколькими годами ранее, Бритуля усвоила интересный урок: если она хочет общаться с миром, минуя фильтры имиджмейкеров, то лучше всего это сделать через папарацци. За ней и так уже несколько лет, неустанно и днем и ночью следят от 30 до 70 камер и фотоаппаратов, а стоит ей щелкнуть пальцами, как тут же налетит еще больше. Она начинает "заигрывать" с этим чудовищем, словно с собакой, которой можно бросить кость. Очень скоро она поймет, что нельзя откармливать этого монстра, потому что это совершенно не контролируемая, но очень мощная сила!

Она звонит одному из них и сообщает, что хочет лично "слить информацию" о самой себе. Назначает место, куда подъехать и не успев положить трубку, Бритуля понимает, что весь организм репортеров УЖЕ приведен в действие и толпится под порогом отеля, где была назначена встреча. Это очень слаженный организм, где все сотрудничают друг с другом, у них есть рации, и информация разлетается со скоростью света. Появляется Богиня на пороге отеля, а с ней какой-то парень, высокий, весь в наколках, бейсболка одета козырьком на бок. По толпе репортеров проносится возглас: "Что за хрень? Кто этот панк?" Бритни знакомит репортеров со своим женихом, Кевином Федерлайном.

Появление Кевина в ее жизни было очень закономерно: Брит, так стремившаяся к нормальной жизни, вдруг видит в его лице - того нормального парня, который ничем не отличается от всех нормальных людей! Он живет в обычной квартирке, ведет обычный образ жизни, и, что больше всего подкупило саму Бри - относится к ней, как к ОБЫЧНОЙ девушке! Он тот, кто подставит плечо, кто выслушает и его ВОВСЕ не заботят все статусы и ярлыки, которые навесили на нее все остальные. Это ее шанс! Она не смогла разглядеть саму себя НОРМАЛЬНУЮ, значит она увидит себя через ЕГО взгляд на нее! Вот он стержень и опора, она нашла! Между ними вспыхивает любовь и романтические отношения. Бритни хочет построить дом, завести детей и наконец, впервые в жизни, стать нормальной, такой, как все.

Я хочу особенно остановиться на этом месте и еще раз подчеркнуть: Кевин ей был НЕОБХОДИМ. Это был ее шанс рассмотреть саму себя, если хотите. Он - не рассматривает ИЛИ делает вид, что не рассматривает (тут уж как хотите, главное, что Бритни верила в это) ее как поп-звезду. Для него она - обычная девушка, которую он любит. А для Бритули, со всеми ее поисками - это то, что необходимо ей как воздух!

Опустим сейчас истории их свадьбы, построения общего дома и рождения первенца. Эти пару лет были счастливым временем для нее, но Кевина начинает мучить другой аспект: живя, как у Христа за пазухой, купаясь в роскоши и богатстве, катаясь на новеньком Ламборджини, ему не дает покоя мысль, что все это оплачивает его жена, а он - иждивенец. Мужское эго делает свое дело и он стремится начать зарабатывать деньги, чтобы успокоить собственную совесть. Кевин записывает первые два сингла и Бри, по-началу, даже поддерживает любимого мужа в его стремлениях.

Однако все это влечет последствия: он подолгу пропадает в студии и совершенно не уделяет время жене и двум детям, которых она успела родить ему. В Бритуле просыпается страх: ее бросал их папа, ее бросил Джастин.... теперь - она не видит Кевина. У нее просыпается ревность - до нее доходят разные слухи и просыпается обида: это ВОВСЕ не то, что она хотела! Ей нужна опора, ей нужен муж и отец ее детей, а она живет в неведение - вернется ли он домой сегодня? Во сколько это будет? Когда слезы и уговоры не помогают, она идет на отчаянный шаг и подает на развод. Ее логика такая: "это помогло моей маме вернуть отца в лоно семьи, в 1980 году, значит, это сработает и сейчас".

Однако Кевин воспринимает этот "сигнал" АБСОЛЮТНО по-другому! Он рассказывает свой взгляд на случившееся, в интервью журналу "Пипл": "Я работаю в поте лица, пытаюсь заработать денег для семьи и тут, словно гром среди ясного неба приходит извещение о разводе...." обиженный таким поворотом событий, Кевин принимает развод и подает встречный иск: дети должны остаться с ним. Бритничка приходит в ужас от такого поворота событий! Мало того, что она по-глупости разрушила собственный брак, так еще у нее теперь могут забрать детей!

Отойдем немного от этой темы и взглянем на Бритни-маму (ОЧЕНЬ важный момент!): когда у матери рождается первенец, естественная реакция любой девушки - это страх перед тем, что она - плохая мать. Все ли она делает на благо ребенка? Правильно ли она поступает? Все эти страхи присущи практически каждой молодой маме. А когда речь идет о Бритни, которая и так самый строгий судья для самой себя (так было всегда и во всем), кроме того - ее постоянный спутник - тревожность, которая одолевает ее с детства, тревожность, которая только усилилась с приходом славы, метания и поиски себя - то все эти подозрения о собственной состоятельности как мать еще более возрастают!

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

Говоря другими словами, Бритни с совершенно расшатанной и неустоявшийся психикой (вспомним "Прозак" еще со времен тура Oops) получает два мощнейших удара!

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

Она ищет опору в людях и находит ее в компании двух заядлых тусовщиц: Перис Хилтон и Линдси Лохан. В их компании вполне можно забыть страхи, они ездят из клуба в клуб, вплоть до 4-х утра, а там - пару часов - и рассвет.... конечно же это не самое мудрое решение, особенно если учесть тот факт, что идет судебная борьба за детей, в которой мама ночи напролет проводит в клубах, а папа, вместе с бабушкой и нянями сидит дома и смотрит за детьми... но Бритни редко поступала обдуманно, ею всегда руководила собственная импульсивность и все, даже жизненно-важные решения она привыкла принимать руководствуясь секундным позывом.

Вместе со знакомством с этими шальными девушками, приходят слухи: Бритни употребляет тяжелые наркотики. Эти подозрения смакует пресса: кроме Бритни - плохой жены и паршивой матери, предстает перед миром еще в качестве наркоманки. Масло в огонь подливают лжесвидетельства в суде ее бывшего охранника, уверявшего, что однажды застал мисс Спирс лежащей без сознания, а возле нее нашел трубку для курения крека. Хотя в одной из передач ведущая, бывшая ранее опытным адвокатом, в интервью с этим охранником напрочь разбивает эту ложь, но кого это интересует? Дело Бритни получает широкую огласку и власти намерены показать всей общественности, что "система работает и перед законом все равны".

В судьбе Бритни происходит много вещей "словно нарочно". Одна из них - именно этот фактор: она знаменита и поэтому к ней повышенное внимание. Так уж построена судебная этика демократических стран: если человек известен - его накажут намного строже, чем "алкаша Васю с 5-го подъезда", это, если хотите, "показательный суд" - "перед законом все равны". Такое практикуют и в Израиле: лет 5-ть назад, президент страны получил 7 лет тюрьмы за преступление, за которое рядовой гражданин ЕСЛИ и будет судим (что не факт) то сядет МАКСИМУМ на год.

Но люди, которые в то время были близки к Бритуле все как один заявляют, что ни разу не видели ее употребляющей наркотики или находящейся под наркотическим опьянением, в добавок, они уверяют, что Бритни употребляет алкоголь точно так же, как и любой другой нормальный человек - но... во многом по причине ранее описанной, они не были услышаны. По признанию многих: "ее просто публично выпороли" не потрудившись убедиться в том, что обвинения имеют под собой вес доказательств.

Абсолютно отчаявшись, видя, что все настроены против нее, заметив, что мать проводит время с Кевином и детьми, Бритни решает, что даже ее собственная мама "на стороне противника"... поссорившись с ней окончательно, тем самым выбив еще одну опору из под своих ног, Бритуля и вовсе теряет чувство самохранения. Ко всем бедам накладывается еще одно: умирает ее любимая тетя Сандра, которая была самой мудрой в семье Спирс и всегда умела поддержать и загладить углы.

Давайте подведем итоги: Бритни обвинили во всех смертных грехах, она лишилась абсолютно всех людей, на которых могла опереться, она ощущает, как общество просто заживо сжирает ее снаружи, а собственные тревоги изнутри, задыхаясь в этом болоте своего "черного периода" с одной стороны она хочет послать сигнал SOS, донести до людей, сколько дряни творится вокруг нее, а с другой - бросить вызов всем, плюнуть в лицо, совершить акт "публичного самосожжения", ненавидя тот образ, который и стал причиной ее расшатанной психики, она решает взбунтоваться против той золотой, некогда, клетки, которую сама построила из своей мечты, теперь она намерена разрушить ее, убить "Бритни Спирс", поквитаться с ней.... "Остановись возле вон той парикмахерской!" - приказывает она своему охраннику......

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

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

Я не мог спокойно читать эти страницы, перед глазами плыли картины того отчаянья, до которого довели бедняжку, а внутри меня горело пламя сострадания к ней и злости ко всем остальным. Наверное, в тот момент, когда я читал это все, я скурил пачку сигарет, обдумывая все, что произошло с ней. С каким чувством она ехала потом в свое джипе и с какой злостью, вооружившись зонтиком она пыталась избить двухметрового амбала-негра с фотоаппаратом на шее. Тот в панике, видя пожар ярости в ее глазах, просто сбежал и закрылся в своем внедорожнике, а Бритни яростно лупила своим оружием по стеклу и двери, за которой спрятался испуганный фотограф....

Через какое-то время, она, не привыкшая жаловаться на свои трудности и публично плакать о своих бедах, решила вновь взять себя в руки. Позвонив среди ночи своему старому приятелю, директору танцевальной студии "Миллениум", она сказала: "ты не будешь так любезен открыть для меня студию?". Бритни искала укрытие там, где находила его всегда - в танцах. Она в течении двух недель занималась, чтобы восстановить форму, а после этого, появилась на пороге кабинета того самого директора и произнесла: "я хочу учить детей".

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

Дверь распахнулась, на пороге появилась девушка. На ней был спортивный костюм, волосы были собраны в пучок, а на лице сияла улыбка. "Здравствуйте дети", произнесла она и тут до учеников наконец дошло кто ИМЕННО стоит перед ними.... детский вопль и крики радости достигли такого пика, что казалось рухнут стены! Бритни подождав, пока первая волна шока пройдет, успокоила детей и начала преподавать им искусство танцевать....

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

Но нужно было искать более ощутимую и долговременную опору и она решила: раз уж в личной жизни все так плохо, то нужно восстанавливать карьеру. И у нее в голове родился план "возвращения". Поделившись своими желаниями с менеджерами Джайв, она получила необходимую ей поддержку и те тут же ринулись договариваться с МТВ-шниками, о будущем возвращении Богини на сцену. "Бритни - профессионал. Если уж она и может делать что-то с закрытыми глазами, абсолютно не напрягаясь - так это выступать!" - уверяли те. Но МТВ-шники не были столь уверены и потребовали 5 недель репетиций.

Возвращение было назначено на Video Music Awards 2007, где Бритни, своим выступлением, полагалось открыть церемонию. Наняли танцоров и хореографов, сняли зал и Бри приступила к репетициям. Когда начало получаться, радости Бритули не было предела! Она скакала по студии с радостными воплями: "У меня получится! Я сделаю это!" Профессионалу как она, 5-ти недель было через чур много, уже в конце второй она в совершенстве выучила и поднатаскала свою хореографию и начала скучать на репетициях. Чтобы поддержать тот огонь и тот боевой дух, который читался в этих прекрасных, карих глазах, вся команда шла на разные ухищрения: они придумывали игры, конкурсы, бесились и танцевали. Трудами менеджеров был приглашен крутейший стилист, чтобы нарастить ей волосы, а модный дизайнер пошил великолепный корсет, чтобы в нем она вышла и все вскрикнули "ВАУ!".

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

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

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

В дверь постучался стилист, но Бритни в ОЧЕНЬ грубой форме сказала, что не хочет его видеть и желает, чтобы волосы наращивала его помощница. Та отказалась, и Бри велела своему охраннику "выкинуть вон обоих". Охранник выполнил свою работу. Стилист, будучи модным и знаменитым, рассерженный, покинул помещение, крича, что "никогда еще не был так унижен" и посылал слова проклятия в адрес своей обидчицы. Вместе с ним, в чемоданчике, гримерку покинули и волосы, которые надо было нарастить. Менеджеры Джайв отчаянно пытались замять конфликт, но он их даже не пожелал выслушать.

Надо было где-то достать волосы... и тогда, нечеловеческими усилиями и уловками достали ключи от парикмахерской отеля и там, найдя какой-то более-менее подходящий парик, принесли Бритни. До выступления оставалось чуть более получаса и нужно было одеть корсет. Бритни приказала всем покинуть комнату и вновь закрылась со своей ассистенткой. За дверью нервно курили менеджеры Джайв и ответственные за этот номер со стороны канала МТВ. Бритни внутри пила текилу....

.... оставалось 7 минут до выхода и отчаянный менеджмент уже в панике тарабанил в дверь. Дверь распахнулась, от туда вышла в начале помощница, а потом показалась Бритуля.... на ней было надето непонятно откуда взявшееся нижнее белье, а на ногах - чулки в крупную сетку... "Бритни решила попробовать так" - промолвила помощница и над толпой столпившихся, шокированных менеджеров пронесся вопль ужаса и отчаяния: "Быстро переодеть ее! НЕМЕДЛЕННО!!!!", но тут объявили "поздно! ведите!"....

И вот танцоры вышли на сцену, а менеджеры расселись в зале, в ужасе ожидая начала выступления. По задумке, Бритни должна была четко, в один голос с фонограммой повторить: "It's Britney, bitch". Это было отрепетировано до совершенства, потому что в этот момент ее должны были снимать крупным планом, если это произойдет, думали они, то еще не все потеряно, но фонограмма началась, а губы Бритни не двигались...... в головах промелькнуло: "Все, это конец!"

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

Свидетели выступления говорили, что это было похоже на публичную казнь, а газеты во всю высмеивали выступление и фигуру Бри. Заголовки пестрели: "Сало-сила!" СМИ смешивали Бритулю с грязью. Обещанное "Возвращение" стало ничем иным, как "Самоуничтожением". От нее отвернулись буквально все, включая даже адвокатов, и в этот момент появился Сэм Латфи.

Было не понятно, кто он такой и откуда взялся, но он и раньше пытался обманным путем войти в круг Бритни, однако чуткие помощницы и прочие - отшили его. Есть сведения, что он просто встретил ее саму в каком-то кафе и не поверил своей удаче. Бритуля находилась примерно в таком состоянии, что если бы к ней в дверь постучал незнакомец и сказал бы: "Бритни, я пришел тебя спасти", то она бы с радостью бросилась к нему на шею. Именно в такой момент он и появился.

Кроме того, что он обманом пытался сделать это ранее, настораживало еще то, что против него было возбуждено 3 иска и по всем трем суд вынес запретительные приказы против Сэма. Однако, справедливости ради, не все сходятся на мнении, что Сэм такой уж злодей. Он, во-первых, заполнил пустоту, образовавшуюся вокруг Бри, решил многие ее проблемы и даже, в скором будущем он ЗАСТАВИТ Бритни помириться с собственной мамой. Кроме Сэма появился еще один человек - самый "преданный" папарацци Аднан, который не отходил от Бритни уже в течении 4-х лет. Она позвала его сама. Сэм стал менеджером и доверенным лицом Бри, а Аднан - любовником.

По воспоминаниям папарацци, в ту пору по Бритни можно было часы подводить: она жила одним и тем же распорядком дня. В 10 она выезжала из своего дома и несколько часов бесцельно ездила по трассе, туда-сюда, а за ней, неустанно ехали 30 машин и 2 вертолета папарацци. Она неслась со скоростью 130 км/ч в авангарде всего кортежа, и если случалось, что посреди загорался красный, то никто и не думал тормозить, люди не выезжали на перекресток, пока весь гудящий "состав" из 30 машин не проедет. Вдруг рация хрипела: "Она развернулась!" и все отъезжали в сторону, пропускали ее машину и продолжали преследование.

С репортерами у Брит сложились интересные отношения - они во всем помогали ей, например, услужливо заправляли ее машину, ЗАЩИЩАЛИ ее, сочувствовали ей, общались... Еще один важный момент: папарацци были ей НЕОБХОДИМЫ как воздух! В тот момент самое ужасное для Бри - было остаться одной, а папарацци выполняли роль "зрителей". Это была такая извращенная форма "выступлений", в которых с самого детства привыкла прятаться Бритуля.

После сумасшедшего марафона по трассе, она ехала в одно и тоже кафе, покупала один и тот же кофе, потом останавливалась возле одного и того же ларька, где она просила пачку Парламента и после этого она ехала домой. Вечером Бритни ездила по одним и тем же клубам и так до 4-х утра. После она шла спать, чтобы на следующий день повторить весь круг заново. Да, это опять была отчаянная попытка внешним порядком контролировать внутренний хаос. В доме была идеальная чистота - Бритни не могла усидеть на месте и если замечала пятнышко, она тут же хватала тряпку и спешила вытереть его.

Как бы то ни было, но начало 2008 года стало апогеем в злоключениях Бритни Спирс. Люди по всему миру наблюдали картину как куча полицейских машин, скорой помощи и пожарных столпились возле ее дома. Причиной послужил внезапный поступок Бри: она, после очередного свидания с детьми, отказалась их возвращать, а когда к дому была стянута полиция, закрылась с младшим в ванной комнате, как говорили в новостях, "взяв его в заложники". Сумев после 2-х часовых переговоров попасть туда, полицейские обнаружили плачушего кроху, а в углу, сжавшись в комок, на полу, вся в слезах лежала Бритни.

Этот поступок стал причиной ее первого помещения на принудительное психиатрическое обследование и родители Бритни, начали активно действовать. Ранее она, рассорившись с ними, просто не допускала их в свою жизнь, но теперь уже было не до игр.... Отец, после этого случая, серьезно решил избавится от Сэма Лутфи, которого Бритни слушала во всем (мать даже называла его "Генерал"). Когда через недолгое время, Бритни "закрыли" второй раз, Джейми Спирс добился через суд признания о недееспособности его дочери и семья смогла вырвать Бритни из лап Сэма. Спасительная миссия началась.

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

Автор делает особое ударение на факте, что не нашел никакого свидетельства того, что эти препараты прописали ей врачи и "нет никакой уверенности в том, что профессионалы согласились бы с выбором такого курса лечения". Получив бразды правления в свои руки, Джейми начал восстанавливать то, что разрушила его дочь, ее окружили теплом и лаской, а Сэм и Аднан получили запретительный приказ, которого потребовал отец в суде.

Надо сказать, что они добились неплохих успехов, потому что через считанные месяцы Бритни спросила: "Когда я опять поеду в турне?". Но кроме желания самой Бри, всех подстегивало то, что и выбора-то особо нет: выходили последние сроки, а по контракту она должна была лейблу еще один альбом и одно мировое турне. Ларри Рудольфа вернули в команду и подготовка пошла полным ходом....

...первая площадка, на которой должна была выступать Богиня, находилась в Новом Орлеане и вот туда, с грохотом, уже отправился кортеж грузовиков, везя декорации, костюмы и огромную сцену тура "Цирк". Весь мир сжал кулаки и болел, переживая и молясь, чтобы дебют прошел удачно. И когда отгремела последняя песня тура Womanizer, Бритни сжав кулак, благодарила собравшуюся публику. Она, как и ранее, опять собирала аншлаги, а кто-то из маленького городка Луизианы, гордо смотря на свою землячку, выдохнув сказал: "Да, это наша девочка! Ее так просто на лопатки не уложишь! Настоящая южанка!"....

Книга заканчивается повторной встречей автора с Ларри, где на вопрос "получилась ли книга", автор лукаво посоветовал ее прочесть и добавил: "Сегодня я преклоняюсь преклоняюсь перед этой девушкой в РАЗЫ больше, чем ранее" и на удивленный взгляд Ларри он добавил: "попробуй перенести то, что перенесла она... я думаю, что немногие бы выжили, я уж не говорю о ее ВОЗВРАЩЕНИИ"

Последним "напутствием" психолога стало пожелание для Бритни "сделать большой перерыв в карьере": "Она так и не разобралась в том, кто она такая. Опять прибегнув к привычной схеме побега из реальности через выступления, она просто спряталась от своей проблемы. Ей нужно на ДОЛГОЕ время исключить выступления из жизни. По-началу будет сложно, она будет ощущать пустоту. Ей надо наблюдаться и консультироваться с психоаналитиком, и только потом можно будет вернуться...." Однако Бритни вместо этого вновь завертела собственное золотое колесо. Ее карьера сделала полный круг.

Хочу закончить тем, что не было известно тогда, когда Стив писал свою потрясающую книгу: как показало время, Бритни начала делать эти самые, необходимые ей долгие перерывы и график ее выступлений стал намного более щадящим. Кроме того, в ее жизни появился верный спутник, который, кажется, понимает ЧТО ИМЕННО необходимо Бри. Он не рвется к славе, он просто следует неотступной тенью за ней, помогая и поддерживая во всем. Я молюсь, чтобы Богиня обрела, наконец, нужную ей опору, загладила все раны, которые она получила в прошлом и стала ДЕЙСТВИТЕЛЬНО счастливым человеком. Аминь.

Спасибо всем, кто прочел

@темы: Britney Spears

---

Учимся программировать на С++. Лекция 19. Связанные списки

Здрасте!

решение домашнего задания с предыдущей лекции

Условие:

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

Структура имеет имя, фамилию, оценки и ID-номер студента. ID номер назначается автоматически при создании студента. Предположите, что количество студентов не может выходить за рамки числа, которое может быть сохранено в переменной long. Потрудитесь сделать так, чтобы ID был уникальным для каждого студента. Имя и фамилию студент получает в конструктор. (То есть: при создании переменной студент необходимо указать имя и фамилию)

Введите студентам те же оценки, которые были в прошлом задании и распечатайте имена И ID-номера тех, кто достоин поездки на олимпиаду.

Требование: все студенты должны быть созданы в куче.


Напоминаю:

Напишите программу, которая вычисляет студента, которого нужно послать на олимпиаду по физике.
Немного о вузе: в вузе есть всего 3 курса: физика, математика и английский. В Вузе - 100 бальная система оценок. Вуз заботится о своем имени и поэтому, он не посылает на такие мероприятия студентов, у которых средняя оценка по всем курсам ниже 85. На олимпиаду должны поехать студенты, у которых оценка по физике не меньше 90.

Создайте 3 студента с такими оценками:
1. физика 95, математика 90, английский 85.
2. физика 95, математика 60, английский 60.
3. физика 80, математика 90, английский 95.

Раздайте им произвольные имена.

Программа напишет на экран имена всех студентов, которые достойны поездки на олимпиаду по физике.

Примечание: Не обязательно получать данные с "внешнего источника", можно прописать их в коде. Цель задания - работа со структурами, а не с клавиатурой.
Совет: даже больше чем совет, скорее требование: разбейте код на функции, не пишите все в main, это не красиво.

решение

Код:











Результат:




Примечание:
Я пишу начальную инициализацию переменных (в конструкторе) в столбик: лишь для удобства чтения. Так тоже можно)))

лекция

Вы не могли не заметить, в домашнем задании про трех студентов и олимпиаду по физике что-то, что явно бросалось в глаза: неудобная работа со структурами, которые с одной стороны нельзя создать в виде массива (потому что отсутствует пустой конструктор), а с другой - что-то типа массива там напрашивалось как необходимая вещь.

Можно, конечно, создать массив, но тут есть нюанс. Давайте остановимся на этом нюансе. Как мы уже выяснили, нельзя создать массив, если в структуре нет пустого конструктора. Но! Всегда можно создать массив указателей на эту структуру. Давайте рассмотрим такое создание. Допустим, что нужно заполнить массив в функции foo

void foo (MyStruct ** arr) {

// создаем структуры:
MyStruct st1(1);
MyStruct st2(2);
MyStruct st3(3);


// кладем в массив:

arr [ 0 ] = & st1;
arr [ 1 ] = & st2;
arr [ 2 ] = & st3;

}

В начале, хочу обратить внимание на параметр в функции foo: указатель на указатель (две звездочки). Почему? Ну, первая - мы так всегда передаем массивы. Потому, что как мы помним, что имя массива - это указатель на первый элемент. Вторая звездочка говорит, что наш массив - это массив указателей.

Видите ли вы проблему в этом коде, которую вижу я? Она уже должна бросаться в глаза: структуры st1, st2 и st3 созданы внутри функции и они будут уничтожены при выходе из функции. То есть, указатели, которые мы положили в массив, будут указывать на мусор, а попытка обратиться к ним свалит программу.

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

MyStruct * st1 = new MyStruct(1);
MyStruct * st2 = new MyStruct(2);
MyStruct * st3 = new MyStruct(1);

arr [ 0 ] = st1;
arr [ 1 ] = st2;
arr [ 2 ] = st3;


ИЛИ сразу вот так:

arr [ 0 ] = new MyStruct(1);
arr [ 1 ] = new MyStruct(2);
arr [ 2 ] = new MyStruct(1);

Естественно, что как только массив будет не нужен, нужно будет освободить память.

Какие минусы такого подхода? Начнем по порядку.
Во-первых - размер массива. Сейчас даже не важно, создали мы сам массив в стеке или в куче, в любом случае - у него будет фиксированный размер. Если размер нужно увеличить или уменьшить - то придется создавать другой массив с нужным размером и переписывать туда содержимое из первого.

Рассмотрим такую ситуацию: нам нужно написать программу, которая хранила бы в себе список студентов. Задание берет на себя программист, который не знает другого решения, кроме как создать массив. Он приходит к декану и спрашивает: какое максимальное число студентов может быть на курсе. Допустим, он получает ответ 60.

Программист создает массив размером в 60 ячеек и заполняет его студентами. Если студентов будет меньше, размышляет программист, то лишние ячейки будут указывать на NULL. Неплохой выход, когда не знаешь ничего более хорошего. Даже не нужно таскать за собой размер массива: допустим, нужно распечатать всех студентов, тогда цикл выполняется до тех пор, пока не достигнет 60, либо, пока не встретит первый NULL.

И вот, в середине семестра выгоняют троих. Они находятся в середине массива. Если просто освободить их места и присвоить им NULL, то у нас получатся дыры в массиве. Так как NULL в одной из ячеек означает конец списка, то дыры оставлять нельзя. Поэтому программисту нужно "двигать" студентов по массиву, и закрывать дыры.

НО! Самый печальный вариант - на этот факультет хотят записаться 90 студентов и ВУЗ решает открыть дополнительные места. Как быть? Нужно, как я уже писал выше, создавать другой массив и переписывать данные туда. Все это ОЧЕНЬ усложняет и замедляет выполнение кода. Как мы видим, массив не дает красивых решений на все случаи жизни. Однако, красивое решение есть и на этой лекции мы и поговорим о нем.

Связанные списки

Чтобы понять, что такое "связанный список" (англ. Linked List) давайте посмотрим на структуру:

struct Student {
// привычные нам данные студента
Student * next; // указатель на такую же структуру
}

И тогда можно написать вот такой код:

Student * st1 = new Student;
// заполняем данные
Student * st2 = new Student;
// заполняем данные

а теперь, далее, мы можем просто "связать" одного студента с другим:

st1->next = st2;

То есть, указатель, который находится в структуре st1 и называется next теперь указывает на структуру st2. Таким образом, мы можем связать неограниченное количество структур, одну с другой, а в последней, мы позаботимся о том, чтобы ее next указывал на NULL и тогда, проходя по листу мы будем знать, что если next указывает на NULL, то лист закончился.

Так решается первая проблема, заявленная мною сегодня: лист (далее "связанный список" я буду называть "лист"). Так вот, лист - это удобный контейнер с той точки зрения, что его размеры могут динамически изменяться! Как только нам понадобится добавить в лист еще одного студента - мы просто "привяжем" его к последнему в листе.

Как решается проблема с удалением студента из листа? Так же элегантно и просто! Допустим, у нас есть такая последовательность:

st1->st2->st3->NULL

Мы хотим удалить st2:

st1->st3->NULL

Мы делаем простую, до безобразия вещь: указатель next, структуры st1 теперь указывает на st3, то есть на то, на что указывал st2->next, в коде это выглядит так:

st1->next = st2->next;

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

Student * tmp = NULL;
tmp = st1->next;
st1->next = st1->next->next;
delete tmp;

В начале мы создадим временный указатель, которому присвоим то, на что указывает st1->next, то есть - это st2
Далее, мы говорим, что ТЕПЕРЬ st1->next будет указывать НЕ на st2, а на st2->next, но к нему мы обращаемся через st1 (я объясню далее почему именно так)
После этого, мы просто освободим то, на что указывает "временный указатель", а так как он указывает на ту ячейку памяти, на которую указывает и st2, то мы по-сути добьемся того, чего хотели - освободим st2

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

Я специально работаю с серединой, потому что работа с концом листа - элементарна, а в работе с началом листа (с первым элементом) есть нюансы, так как доступ ко всем членам листа осуществляется именно через первый элемент.

Код:












Результат:





Разбор полетов:

Ну, помолясь, приступим))))
Начнем с описания структуры: конструктор, деструктор, статическая переменная для раздачи уникального id (трюк из дом. задания). Потом - данные студента и, самое главное, указатель на следующий элемент.

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

Далее, немного отступления: первый элемент - это "ключ" ко всему листу. Через него можно попасть в любой элемент! Часто его называют head (голова листа). Если нужно передать лист в функцию - передают первый элемент. Размер не нужен, так как конец листа - это элемент, у которого next указывает на NULL.

Итак, функция распечатки. Тут есть несколько интересных моментов. Во-первых, я создаю указатель р, который в начале указывает на голову. Я буду "двигать" р (а не head), чтобы не потерять начало. В этой функции это не критично, но если бы в ней был бы еще один проход (еще один цикл), то я бы не смог его осуществить, потому что потерял бы указатель на голову.

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

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

int i = 0; // ставим "шагающую переменную" в начало

while ( i < size ) // проверяем условие: вышли ли мы за границы массива?
{
// какое-либо действие в цикле
i++; // продвигаем переменную вперед
}


А что мы имеем тут?

Student * p = head; // ставим "шагающую переменную" в начало

while ( p != NULL ) // проверяем условие: вышли ли мы за границы листа?
{
// какое-либо действие в цикле
p = p->next; // продвигаем переменную вперед
}


Далее, мы сказали, что удобней двигаться по массиву с помощью цикла for, объединив эти действия в одну строку:

for ( int i = 0; i < size; i++)

Что нам мешает сделать такой трюк тут? Ничего!

for ( Student * p = head; p != NULL; p = p->next)

или, еще короче:

for ( Student * p = head; p; p = p->next)

Далее, вы увидите, что в большинстве случаев я использую цикл for для прохода по листу.

Теперь, функция delete_student. Я хочу остановиться тут только на одном моменте: два указателя. Зачем? Чтобы понять это, надо привести такой пример: допустим, мы хотим удалить 3-й элемент. Но мы не знаем, что элемент, который нам надо удалить - третий по счету. Нам нужно попасть в этот элемент, чтобы сравнить фамилии.

Вот мы идем по листу: 1-й элемент, сравнение - не он. Двигаем р во второй элемент. 2-й элемент, сравнение - не он. Двигаем в третий. 3-й элемент, сравнение - он! Надо удалять. А что такое удалить элемент из листа? Это значит, исключить его оттуда и освободить. НО! На него указывает 2-й элемент, а он сам - на 4-й. То есть, нужно сделать так, чтобы теперь next ВТОРОГО элемента указывал на 4-й....

НО! Мы находимся в 3-м... второй мы уже прошли.... Да, бывают листы, в котором есть указатель на next (на следующий элемент) И указатель на prev (на предыдущий элемент), такой лист называют "двусторонний", но это не наш случай))) Я специально не использовал двусторонний лист, чтобы научить пользоваться вот таким, "обычным", так как он используется довольно часто, а умея пользоваться этим - легко можно понять, как пользоваться двусторонним. То есть, в нашем случае, вернуться назад - невозможно! И это - важно понять!

Поэтому, я использую такой трюк: я двигаю 2 указателя. Второй q отстает от первого р на один шаг. Таким образом, у меня в руках есть предыдущий элемент! Далее, как только я нашел нужный элемент - я говорю, что next предыдущего (то есть второго) указывает на next этого, то есть - на четвертый. После этого я удаляю этот. Если бы мне нужно было бы удалить несколько, то я бы это делал через "временный указатель", как я объяснял в теории, а потом бы приводил в порядок указатели. Но так, как это не требуется и как только я удалю элемент, я покину цикл (break), то я не стал это делать.

Хочу заметить, что ни в этой, не в следующей функции я не могу добавить/убрать первый элемент! Почему? Потому что он - указывает на голову. Поясню:

Мы создали структуру в куче, допустим, она имеет адрес 17. После этого, мы создали указатель на нее. Указатель имеет адрес 28. Это указатель на первый элемент. Теперь по адресу 28 лежит значение "17". Мы передаем указатель в функцию. Как мы знаем, создается новая переменная из типа "указатель" и у нее есть новый адрес, допустим 33, однако, в нее скопировано значение "17".

То есть, в функции, мы работаем с указателем, имеющим адрес 33 и это наша "голова". Теперь мы хотим добавить элемент в голову, либо удалить из головы... НО! Все, что мы сделаем в этой функции - мы сделаем с указателем, который имеет адрес 33, а "настоящая" голова имеет адрес 28.... То есть, наши изменения в функции не происходят с "настоящей" головой!

Есть 2 решения:
1. вернуть "голову" из функции и присвоить ее настоящей
2. передать указатель на указатель

То есть, для того, чтобы у нас была возможность изменить первый элемент, наши обе функции (add_student, delete_student) функции должны быть описаны вот так:

add_student ( Student ** head ) // ДВЕ звезды!

А присвоение "шагающему указателю" р происходило бы так:

Student * p = (*head)->next

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

Теперь, когда мы разобрали delete_student, в add_student мы легко поймем код, потому что там используется тот же трюк с двумя указателями. Единственное, на что хочу обратить внимание: создание нового студента происходит сразу со "связыванием" его в листе. Можно было сделать так же, как я сделал в main, но это лишние, никому не нужные телодвижения.

Функция free_list рекурсивная. Я буду удалять элементы, начиная с последнего. Потому, что если я напишу в начале delete p, то потом я не смогу продвинуться p = p->next, так как р уже не существует. Поэтому, я в начале пройду в конец листа, а потом, на выходе начну удалять элементы.

Конструктор и деструктор мы разбирать не будем, там нет ничего нового. Просто обратите внимание на то, что я даю начальные значения членам структуры в столбик, для удобства чтения кода.

Совет: для лучшего понимания того, что происходит в этих функциях, можно взять бумагу и ручку и схематически все нарисовать. Идти по алгоритму: "ага, этот указатель сейчас указывает сюда, тут я присваиваю то-то"... Желательно, хотя бы один раз все нарисовать, чтобы ГЛАЗАМИ на все посмотреть!

Список как объект

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

1. Мы уже видели, что существует проблема работы с первым элементом. Он требует "особого подхода"
2. Часто нужно добавлять элемент в лист, для этого необходимо найти конец. Чтобы найти конец - нужно пройти по всему листу. Можно ли это ускорить?
3. Как узнать размер листа? Только посчитать....

Сейчас мы попробуем решить все эти проблемы, однако, есть еще ряд других проблем в листе. Например, невозможно СРАЗУ попасть в 3-й элемент, нужно начать с первого и продвигаться.... эту и еще ряд проблем мы пока не можем решить. Поэтому, если нам нужна возможность попасть сразу в определенное место в листе, то тут стоит задуматься: какой именно контейнер нам подойдет лучше? Пока мы знаем только два: массив и лист, однако, есть еще, но об этом мы поговорим в других лекциях.

А пока мы приступим к решению заявленных выше проблем, а так же поговорим о "универсальном" контейнере, способным хранить любой тип переменных. Это реально? Да, конечно. Это даже желаемо! Думаю, что не смотря на явные минусы, понятно, что лист - довольно удобный контейнер для хранения данных в программе. То есть, желательно написать это все только ОДИН раз, а далее использовать готовый, отдебаженый код во всех программах, где нужен лист. Но чтобы пользоваться этим контейнером, нужно, чтобы программа умела выполнять следующие действия:

1. Добавить данные в конец или начало листа
2. Удалить данные из листа
3. Найти данные в листе

Это обязательные возможности, но если мы уже пишем "универсальный" лист, то было бы неплохо, так же, чтобы лист умел еще:

1. Сказать какой у него размер
2. Добавить элемент в любое место в листе
3. Соединить два листа в один
4. Создать лист "клон" (точную копию себя)
5. Распечатать содержимое листа на экран
6. Стереть лист полностью (стереть все данные и сам лист)

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

Допустим, у нас есть структура, назовем ее "узел". В этом узле мы будем держать данные. Как можно сделать контейнер, который способен хранить ЛЮБОЙ тип переменной? Тут на помощь придет "неопределенный указатель", то есть void *. Итак, наш "узел" выглядит так:

struct Node {

void * data; // указатель, который будет содержать данные
Node * next; // указатель на следующий элемент в листе

};


Тут вроде ничего нового нет (кроме фокуса с void*) и это не решает проблему. НО! Мы можем ввести еще одну структуру, которая будет "заведующей" листом. Мы так и назовем ее "Лист":

struct List {

unsigned long size; // хранит количество элементов в листе
Node * head; // хранит указатель на голову
Node * tail; // хранит указатель на последний элемент (хвост)

};


Теперь, таким образом мы решили из "обязательных":

1. Добавить данные в конец или начало листа


Из "дополнительных":

1. Сказать какой у него размер
2. Добавить элемент в любое место в листе
3. Соединить два листа в один


При этом, у нас есть проблемы с этим:

"Обязательные":

2. Удалить данные из листа
3. Найти данные в листе


"Дополнительные":

4. Создать лист "клон" (точную копию себя)
5. Распечатать содержимое листа на экран
6. Очистить лист полностью (стереть все данные)



В чем же проблемы?

1. Для того, чтобы найти данные в листе, необходимо уметь сравнить данные))) (КЭП?) А как сравнить данные, если мы не знаем, ЧТО там лежит? Числовые переменные нужно сравнивать через оператор ==. Стринги мы сравниваем через функцию strcmp, а студентов? Студентов наверное надо сравнивать по id или по фамилии.....

2. Для того, чтобы удалить содержимое ПРАВИЛЬНО, нужно освободить память... а как? ЛИБО delete, либо delete [ ] (в листе, в качестве данных вполне может лежать массив В КАЖДОМ узле - свой....). А если предположить, что память освобождать не нужно? Кто-то еще пользуется этими данными.... нужно просто исключить его из листа.... как быть?

3. Для того, чтобы распечатать содержимое листа, нужна функция распечатки.... а у нас там void*, который может быть обычным стрингом, а может быть структурой "Студент", у которого есть имя, фамилия, id, оценки.... да мало ли?

4. Чтобы создать клон, нужно знать, как создавать то, что лежит в КАЖДОМ узле...


Как же решить эти проблемы? И вот тут на помощь нам придут указатели на функцию))). И вот мы медленно, но верно, поняв все, стоящие перед нами задачи, подошли к домашнему заданию. Оно не будет простым. Потребуется немного вспомнить материал, МНОГО думать головой и отлично понимать материал этой лекции. Думаю, что мы подошли к моменту, когда каждый точно поймет: насколько он понял все то, что я рассказываю? Если с пониманием проблем не было, то и в домашнем задании их не будет. А если есть "белые пятна", то я советую ВСЕ РАВНО пытаться решить эту задачу, так как попробовав, всегда понимаешь лучше решение другого человека. Ну, а это другое решение мы увидим уже на следующей лекции))))

Домашнее задание

Создайте две структуры Node и List так, как я описал это выше. Желательно подумать о конструкторах и деструкторах: стоит ли их создавать и если да, то какие?
Вместе с этим, имплементируйте такие функции:


List * create_list (void) - создает новый, пустой лист

void destroy_list ( List * list, void (*destroy_func) (void*) ) - уничтожает лист, с возможностью освободить память.
подробнее:
List * list - лист, который нужно уничтожить
void (*destroy_func) (void*) - указатель на функцию освобождения памяти. Функция умеет освобождать ОДИН элемент в листе, то есть, нужно вызвать ее для каждого элемента (функция принимает void* и ничего не возвращает)
при условии, что память освобождать не нужно, вместо функции будет передан NULL

void append_to_list ( List * list, void * item ) - добавить элемент item в конец листа
void prepend_to_list ( List * list, void * item ) - добавить элемент item в начало листа
bool insert_to_list ( List * list, void * item, unsigned long index ) - добавить элемент item в место номер index листа (вернет false при провале)
void remove_from_list ( List * list, void * item, short (*compare_func) (void*, void*), void (*destroy_func) (void*) ) - удалит элемент, равный item из листа
указатель на функцию void (*destroy_func) (void*) - работает так же как и в destroy_list
указатель на функцию short (*compare_func) (void*, void*) принимает для сравнения 2 элемента и возвращает:
-1 если первый меньше второго
0 если первый равен второму
1 если первый больше второго
* примечание: чуть позже, когда выучим сортировки, такая же точно функция поможет отсортировать лист

void * find_in_list( List * list, void * item, short (*compare_func) (void*, void*) ) - находит элемент item в листе
указатель short (*compare_func) (void*, void*) работает так же, как и в remove_from_list

void concat_list ( List * list1, List * list2) - соединяет два листа в один (к концу list1 привязывает list2)

void print_list ( List * list, void (*print_func) (void *) ) - распечатывает лист на экран
указатель void (*print_func) (void *) умеет указывает на функцию, которая умеет распечатать один элемент на экран

List * copy_list ( List * src, void * (*copy_item) (void * item) ) - создаст точно такой же лист, как и src
указатель void * (*copy_item) (void * item) умеет создать копию item. При копировании листа функция вызывается для каждого элемента

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


Удачи! Она вам пригодится))))

@темы: C++

---

Малышка Бритни))))

Такая маленькая, а уже - Бритни Спирс))))

Ну, лапочка же!

@темы: Britney Spears

---

Всем читать! Свершилось! Коллекция клипов Бритули!

Привет любимые!

Позвольте выдохнуть и прокричать: СВЕРШИЛОСЬ! Я хочу вам рассказать то, над чем я и "моя команда" работали в течении последних нескольких месяцев. О! Хочу сказать, что у меня была отличная команда! Я выполнял роль программиста и, немного дизайнера, еще одна девочка с Зоны, Людочка (Lyuda) - полностью отвечала за дизайн, а другая моя любимая подружка, Катюша (Hanoi) - за сайт (построение, настройки, дизайн, идеи....)

Думаю, что КОМУ мы посвятили свою работу - уточнять не нужно, все понятно без слов, а что мы построили? Мы создали программу, которую назвали Britney Spears: Videos (моя любимая коллекция). У этого проекта даже есть слоган: "Создано фанатами для фанатов!"

В чем же смысл этой программы? Если в двух словах, то скачиваешь установочный файл, жмякаешь на Make и вскакивает то, что я назвал "Помощник", это выглядит примерно так:

Помощник ведет шаг за шагом и задает вопросы, из серии: "Где лежит вот этот клип" или, например, песня. Все это происходит вот в таких красивых окошках:

А в конце, он строит коллекцию из ваших клипов, песен и прочего....

Что же такое эта коллекция? Это удобный и красивый способ навигации по клипам, песням, фоткам и т.д. нашей Богини. Представьте: у вас на рабочем столе иконка, тыкнув на которую появляется вот такое окошко:

Допустим, мы хотим посмотреть клип "Цирк". Мы тыкаем на кнопочку с изображением альбома и открывается окошко Эры:

Видите сбоку пленку? На ней - анимированные кнопочки, демонстрирующие кадры из клипа. Каждая такая кнопка откроет окно клипа. Мы договорились, что будем смотреть "Цирк", поэтому - пройдем туда)))

Чтобы рассказать функциональность этого окна, мы условно поделим его на 3 части:

1. Называется "текстовое окно". Дело в том, что с помощью кнопок, расположенных в части, под номером 3, можно посмотреть историю создания клипа, текст песни или краткую информацию (режиссер, год создания и т.д.) Все это есть как на русском, так и по-английски. Эти тексты и появляются в текстовом окне. Конкретно на картинке - краткая информация по клипу, честно стыринная с Зоны, о чем и написано ниже)))

2. Кнопки возврата в Эру или в "главное окошко"

3. Здесь, кроме "текстовых" кнопок, о которых я рассказал чуть выше, есть кнопки запуска клипа, песни, слайдшоу и передачи, о съемке клипа. Это все запустится в привычном для вас плеере, так, как вы это привыкли смотреть/слушать (у каждого свои предпочтения)

Воооооот, вот как раз "Помощник" и построит вам такую прелесть)))

Помощник умеет строить 2 "типа" такой коллекции: "Локальную" и "Съемную". Локальная коллекция рассчитана на тех, кто хранит клипы, песни и прочее на компьютере. В таком случае, как я уже писал, на рабочем столе появится иконка запуска. Съемная коллекция рассчитана на людей, которые хранят все на дисках, флешках и прочее... тогда "Помощник" создаст папочку, которую надо будет переписать на любой подобный носитель, ничего в ней не меняя и получится коллекция, которая стартует автоматически, как только такой носитель попадет в компьютер.

НО! Никто не запрещал создавать обе)))) Например, для себя, на домашнем компьютере, можно иметь "Локальную", а "Съемную" можно, к примеру, записать и подарить другу. Отличный способ ярко, красочно и интересно познакомить друга с самой прекрасной звездой на мировом поп-небосклоне!

Некоторые уже знакомы с подобной идеей: года 2 назад я делал что-то подобное, но тогда - это был диск (только "Съемная коллекция", рассчитанная на CD/DVD, и это не было так красиво))) "Помощник" умеет создать новую "съемную" коллекцию из "старой", при этом он спросит только про эру ФФ, а остальное найдет сам на "старом" диске.

Что же касается "локальной" коллекции, то "Помощник" умеет ее постоянно обновлять: вы нашли какой-то клип в более крутом качестве? Хотите, чтобы теперь коллекция запускала его? Не проблема! Просто запустите Помощник и расскажите ему про изменения, а он - сделает все сам!

Надеюсь, что вам понравилась наша идея))) Если да, что программу можно скачать с официального сайта (который мне и построила прекрасная Катюша Hanoi): ToxicSpider.ru

Вас встретит лапочка-Бритничка, а в углу будет кнопочка, открывающая сайт. Там есть подробные объяснения, страница откуда можно все скачать, форма обратной связи.

Все (ЕСТЕСТВЕННО) - абсолютно бесплатно, поддержка, объяснения и помощь - гарантируется))))

Примечание: хочу еще раз уточнить: клипы, песни и прочее мы НЕ распространяем! Тем самым нет НИКАКОГО нарушения священных для нас прав Богини и ее команды!

З.Ы. любое БЕСПЛАТНОЕ распространение программы - приветствуется и даже - желаемо))) Несите свет в массы))))

З.Ы Программа была протестирована на Windows XP и Windows 7, но нет никакого сомнения, что она будет корректно работать и на других версиях ОС Windows. Однако, если вдруг возникнет проблема - смело обращайтесь ко мне, любым, доступным вам способом!

Спасибо за внимание, жму мальчикам руки, а девочек целую в носик! Удачи, любимые))))

Ваш Паучек))))

@темы: Britney Spears

---

Учимся программировать на С++. Лекция 18. Глубже в структуры

Привет!

решение домашнего задания с предыдущей лекции

Условие:

Напишите программу, которая вычисляет студента, которого нужно послать на олимпиаду по физике.
Немного о вузе: в вузе есть всего 3 курса: физика, математика и английский. В Вузе - 100 бальная система оценок. Вуз заботится о своем имени и поэтому, он не посылает на такие мероприятия студентов, у которых средняя оценка по всем курсам ниже 85. На олимпиаду должны поехать студенты, у которых оценка по физике не меньше 90.

Создайте 3 студента с такими оценками:
1. физика 95, математика 90, английский 85.
2. физика 95, математика 60, английский 60.
3. физика 80, математика 90, английский 95.

Раздайте им произвольные имена.

Программа напишет на экран имена всех студентов, которые достойны поездки на олимпиаду по физике.

Примечание: Не обязательно получать данные с "внешнего источника", можно прописать их в коде. Цель задания - работа со структурами, а не с клавиатурой.
Совет: даже больше чем совет, скорее требование: разбейте код на функции, не пишите все в main, это не красиво.

решение

Код:









Результат:




Разбор полетов:

Начну с того, что скажу, что в моем решении есть ряд проблем. Я укажу их.

Итак, прежде всего - библиотека string.h - для некоторых функций, которые я использую в работе со стрингами. Во-вторых - энумератор. Он помогает мне с курсами. В-третьих - сама структура. Так как я не требовал номер ID, то я и не написал его.

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

Кроме того моя функция принимает стринг как const char * . Таким образом, я превращаю стринг в константу, потому что она мне нужна только для чтения. Таким образом, код будет следить за тем, чтобы я не изменил его содержимое.

Внутри функции create_student я динамически аллокирую память и делаю это убедившись, что параметры, которые я получил - мне подходят.

В функции print_good_student я проверяю условия и распечатываю только нужного студента.

Обратите внимание на преобразование типов в get_avarage.

Функция destroy_student освобождает память, которую я аллокировал под имена.

Теперь проблема: перед тем, как я освобожу память, я проверяю не является ли указатель нулем? НО! Его, изначально никто не обнулял... упс... создайте студента и сразу же передайте его в функцию destroy_student и вы увидите, как программа рухнет)))). Среди всего прочего, мы поговорим сегодня об автоматическом обнулении параметров, а так же увидим, что если правильно описать структуру, то многие проблемы решаются сами собой. Приятной лекции)))

лекция

На прошлой лекции мы познакомились с возможностью создать собственные типы. Если с энумераторами все понятно, то со структурами мы только начали. На прошлой лекции я обещал: "Естественно, что на мою переменную распространяются ВСЕ законы обычных переменных: ее можно передать в функцию, ее можно получить из функции, можно создать указатель или ссылку на нее, можно создать массив таких переменных.... но обо всем этом мы поговорим в следующий раз, а пока - достаточно.", но на самом деле, конкретно в этом, говорить не о чем... то есть: все это можно)))

То есть:

допустим, есть структура Student, а значит можно:

Student student; // создать переменную в стеке

Student * p_student = & student; // создать указатель на нее
Student & r_student = student; // создать ссылку на нее

Student array [ 100 ] ; // создать массив в стеке

Student * new_student = new Student; // создать переменную в куче (динамическая аллокация памяти)
Student * new_student = new Student ( ); // некоторые создают так (пустые скобки в конце) - на данном этапе это тоже самое, хотя причина возникновения скобок есть, об этом позже.

delete new_student; // освободить переменную, (не забываем)

Student * din_arr = new Student [ size ]; // создать массив в куче с зараннее неизвестным размером

delete [ ] din_arr; // освободить массив

Student foo (Student student); // работа с функцией (передать / получить переменную)
Student * foo (Student * student); // работа с функцией (передать / получить указатель)
Student & foo (Student & student); // работа с функцией (передать / получить ссылку)

Все, что я показал выше можно делать, то есть: созданная нами переменная НИЧЕМ, с этой точки зрения, не отличается от примитивных переменных, с которыми мы уже очень хорошо знакомы.

Давайте остановимся на этом утверждении. Из него вытекает, что можно сделать вот так:

struct Passport {

int id;
int age;

};


struct Student {

int id;
int grades [ 5 ];
Passport passport; // обратите внимание! Я выше описал структуру "Паспорт", а теперь, у студента есть переменная "паспорт", то есть - паспорт конкретного студента

};


Вопрос: можно ли так делать? Да, безусловно можно!
Сразу следущий вопрос: допустим, мы создали структуру Студент и хотим заполнить ее. Мы присваиваем студенту номер id, пишем его оценки и подходим к моменту, когда надо заполнить данные паспорта. Как мы это делаем? Ну, во-первых, я напомню, как мы работаем с примитивными переменными, лежащими в структуре:

Student student;

student.id = 5; // запись
cout << "The ID: " << student.id << endl; // чтение


По той же логике мы работаем и со структурами, внутри структур:

// запишем и прочтем ID паспорта:

student.passport.id = 12;
cout << "Student ID: " << student.id << " has passport ID: " << student.passport.id << endl;

На экран будет выдано:
Student ID: 5 has passport ID: 12

А можно ли написать так:

struct Student {

int id;
Student s; // то есть в переменной "Студент" держать переменную "Студент"?

};

Если честно - ни разу не пробовал, не думаю, что это скомпилируется, но даже если и да, то уверен, что ничего хорошего из этого не выйдет..... почему? Давайте подумаем, что произойдет, как только мы в коде объявим переменную из типа "Студент":

Student student;

Компилятор начнет ее строить: выделит память под ID, а потом начнет выделять память под "Студента" лежащего внутри. Ему нужно создать переменную студент, в которой лежит: ID и Student. То есть внутри студента будет еще один студент, внутри которого еще один студент, содержащий внутри себя студента..................... думаю, что проблема ясна)))) Если это и скомпилируется, то как только код дойдет до места, в котором впервые создается студент, то скорее всего программа сразу же рухнет, потому что сожрет всю память. Будьте внимательны)))

Как же быть, если по какой-то причине нам нужен студент внутри студента? Мы можем выйти из положения следующим образом:

struct Student {

int id;
Student * s; // то есть в переменной "Студент" лежит УКАЗАТЕЛЬ на студента

};


В таком случае, компилятор, создавая структуру "Студент" создаст в ней указатель, на такую же структуру, но, так как указатель - НЕ сама структура, и чтобы указатель указывал на структуру ее надо создать отдельно, то есть, написать так:

Student student;
student.id = 5;
student.s = new Student;

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

Работа со структурами через указатель

Я хочу кое что напомнить, а именно:

// у нас есть примитивная переменная:

int num; // объявление
num = 0; // запись
cout << "Number: " << num << endl; // чтение


// у нас есть указатель:

int * p_num; // объявление
p_num = & num; // запись в указатель
cout << "Address of num: " << p_num << endl; // чтение указателя
* p_num = 5; // запись в переменную, на которую указывает указатель
cout << "Number: " << * p_num << endl; // чтение из переменной, на которую указывает указатель


// а так же:
// вспомним, что мы можем, используя указатель, создать переменную в куче:

int * p_num = new int;

// то есть, указатель УЖЕ указывает на переменную! А значит, мы можем далее писать и читать:

* p_num = 5;
cout << "Number: " << * p_num << endl;


Как же работать, когда мы создали указатель на структуру? Допустим, мы сделали как в первом случае:

Student student;
Student * p_student = & student;

Или как во втором:

Student * p_student = new Student;

Как через указатель заполнить поле id, лежащее в студенте? Мы действуем по логике:

(*p_student).id = 5;

то есть, в скобках мы говорим: "дай мне то, на что указывает указатель p_student". А после этого мы обращаемся к тому, что получили через точку. НО! Такая запись неудобна, поэтому, придумали укороченную запись:

p_student->id = 5;

мы ставим значек "стрелочку". Она ставится так: в начале "минус" ( - ), а потом - закрывающая треугольная скобка, тот же символ, который мы пишем в сравнении "больше" ( x > 0 ). Эти 2 символа пишутся один за другим и зрительно получается "стрелочка".

Хочу подчеркнуть: обе записи СОВЕРШЕННО идентичны, но второй - более удобочитаемый, поэтому, почти все программисты (кроме задротов) используют второй способ. В нашем случае, когда в структуре студент есть указатель на студента, то после того, как аллокировали "внутреннего", мы можем заполнить его:

Student student;

student.s->id = 15; // присвоили "внутреннему" студенту, которого мы выше назвали s (плохое название, потому что оно не рассказывает назначение "внутреннего" студента), ID 15.
cout << student.s->id << endl; // прочли ID из "внутреннего" студента

Статические переменные в структурах

Допустим, мы хотим создать какой-нибудь общий параметр для всех студентов в нашем коллежде. Ну, например, проходной балл. В нашем колледже есть 2 факультета: математический и философский. Чтобы оправдать создание двух разных типов, представим, что у них разный набор курсов (что вполне допустимо). Не будем сильно напрягаться, для примера хватит двух. У философского факультета: философия и математика, у математического - математика и физика.

У обоих факультетов есть математика, но так как философам она не так нужна, как математикам, то мы допустим, что проходной балл по математике у философов 40, а у математиков - 60. Наши две структуры определены так:

struct Philosopher {

int math_pass_score;

// другие данные студента

};

struct Mathematician {

int math_pass_score;

// другие данные студента

};


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

Philosopher curr_student;

// инициализация, заполнение данных
// какой-нибудь код

if ( curr_student.grades [MATH] >= curr_student.math_pass_score)
// тут действия которые происходят, когда студент прошел математику
else
// тут - не прошел

То есть, довольно читаемо, упорядочено и прекрасно. А минусы? Ну, во-первых, нужно на инициализации заполнять эту переменную (math_pass_score) значением КАЖДЫЙ раз, когда мы создаем студента. Во-вторых, ОДИНАКОВОЕ значение у всех студентов - копируется из структуры в структуру.... а если нужно поменять это значение? И, конечно же мы не можем не заметить еще один, существенный минус: чтобы, допустим, распечатать на экран значение "проходного балла по математике для философского факультета" - нужно, чтобы БЫЛА ПЕРЕМЕННАЯ этого типа! То есть - нужно конкретную переменную из типа "студент-философ"

Как же правильно и красиво решить эту задачу? И тут на помощь приходят статические переменные. Статическая переменная и ее значение будут принадлежать не КОНКРЕТНОЙ ПЕРЕМЕННОЙ, а ВСЕМУ ТИПУ! То есть, мы напишем ее значение один раз - и это значение будет У ВСЕХ переменных типа "студент-филосов"! Нужно будет поменять? Не проблема! Мы поменяем ОДИН РАЗ! Как описать и заполнить значение такой переменной? В начале, в самой структуре (в ее описании) мы добавим ключевое слово "static", то есть:

struct Philosopher {

static int math_pass_score;

// другие данные студента

};

struct Mathematician {

static int math_pass_score;

// другие данные студента

};

А ниже, перед описанием функций, то есть там, где мы объявляем глобальные переменные, мы напишем:

int Philosopher::math_pass_score = 40;
int Mathematician::math_pass_score = 60;

То есть - имя типа переменной внутри структуры, имя структуры, 2 раза символ "двоеточие", имя статической переменной. Таким образом, значение этой переменной будет известно еще ДО того, как мы создадим переменную типа "студент". А так как эта переменная НЕ принадлежит конкретному студенту (конкретной переменной), а ВСЕМУ типу, то обращаться мы будем к ней через имя типа, а не через имя конкретной переменной. И тоже - через двойное двоеточие:

Philosopher curr_student;

// инициализация, заполнение данных
// какой-нибудь код

if ( curr_student.grades [MATH] >= Philosopher::math_pass_score)
// тут действия которые происходят, когда студент прошел математику
else
// тут - не прошел

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

Конструкторы и деструкторы

Понятие конструкторов и деструкторов, точно так же, как понятие статических переменных в структуре - это уже чистый С++ ! В С - это не работает. Что же это такое? Это, скажем так, функции, которые описаны в теле структуры. В момент, когда создается переменная из типа структуры, то есть, в момент, когда мы пишем в коде Student curr_student; вызывается функция, которая носит название "конструктор". В момент, когда наша структура выходит из области видимости и ее уничтожает система, ЛИБО, если это была динамическая аллокация и мы пишем delete curr_student;, вызывается функция, которая называется "деструктор".

До сих пор, во всех структурах которые я приводил в качестве примера, мы не видели этих функций. Это происходит потому, что если мы не описываем явно эти функции, компилятор "дарит" нам свои и они - абсолютно пустые. НО! Мы можем описать свои конструкторы и деструкторы и тогда "подарка" от компилятора не будет.

Зачем нам могут пригодиться конструкторы и деструкторы? Для того, чтобы правильно создать или уничтожить нашу структуру. Приведу пример: ну, то, что бросается сразу в глаза - обнуление переменных внутри структуры, то есть, в структуре студент, которую мы уже все хорошо знаем, есть переменная ID. Как мы уже поняли, до того, как мы напишем там значение - там лежит мусор. Мы всегда старались избегать такой ситуации, а тут я почему-то промолчал и ничего не сказал об этом....

Иногда наша структура не имеет смысла без определенного значения внутри. Допустим, не существует студента без номера студенческого билета и мы хотим обязать во время создания студента СРАЗУ ЖЕ присвоить ему такой номер.

Что же по поводу уничтожения? Давайте вспомним, что на предыдущей лекции мы создали студента и динамически аллокировали память под его имя и фамилию. Позже нам пришлось освобождать эту память, прежде чем уничтожить студента. А можно ли сделать это автоматически? Да, можно! Прописав процесс освобождения памяти в деструкторе.

Естественно, так как эти функции - особый вид функций, то они имеют немного отличающийся синтакс. Конструктор и деструктор ОБЯЗАНЫ:

1. Иметь название, совпадающее с названием структуры.
2. НЕ возвращать никаких параметров
3. Деструктор не принимает параметры.

К примеру:

struct Student {

Student( параметры ) { // конструктор

// тело функции

}

~Student ( void ) { // деструктор

// тело функции

}

};


Разберем: как я и обещал, наши "особые" функции не возвращают параметры, их имя совпадает с названием структуры, а деструктор - не принимает параметры. В конструкторе, в скобках, написано "параметры" и это может быть что угодно, включая void. Присмотримся к деструктору: перед ним стоит символ "тильда". Этот символ, на клавиатуре, находится слева от единицы и его вводят, удерживая клавишу "Shift".

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

struct Student {

Student (long id) { // конструктор
student_id = id;
}

long student_id; // член структуры

};

Как мы видим, действие, которое происходит в конструкторе - мы присваиваем переменной student_id тот id, который мы получили в конструкторе. То есть в коде, переменную "студент" нужно создавать так:

Student student (15); // создаем переменную в стеке

Student * p_student = new Student ( 15 ); // создаем переменную в куче

Обратите внимание! Если написать:

Student student;

или

Student * p_student = new Student;

то это не скомпилируется, потому что конструктора, не принимающего параметры УЖЕ НЕТ. Раньше - он был, мы "получили его в подарок" от компилятора, потому что не написали свой, но как только мы определяем свой конструктор, подарка нет. В принципе можно описать И свой пустой конструктор. Конструкторов может быть неограниченное количество! Но с одним требованием: не должно быть 2 (и более) конструктора, получающих одни и те же типы параметров! В принципе, такой фокус можно сделать с любой функцией и мы увидим это на следующей лекции, на которой я запланировал закрыть образовавшиеся пробелы, но пока - знайте - можно)))

Пока нет пустого конструктора - так же не отработает создание массива вот таким образом:

Student array [ 3 ] ;

потому что в момент создания 3-х студентов в массиве код пытается вызвать пустой конструктор в структуре, которого, как мы уже поняли, нет.

Теперь еще о "подводных камнях":

Допустим структура описана так:

struct Student {

Student (long id) { // конструктор
id = id; // присвоение значения в переменную структуры
}

long id; // переменная структуры (член структуры, на "профессиональном" языке)

};

Первая проблема, которая сразу бросается в глаза, это строка id = id;. Где первый id - должен быть член структуры, а второй id - параметр, который получает конструктор. Как компилятор понимает, что из них - что? Никак не понимает. При условии, что имена совпадают, он выбирает параметр, который передали в конструктор. То есть - в этом коде, присвоение члену структуры не происходит. Как быть?

Есть 2 выхода.

1. Не называть член структуры так же, как мы назвали параметр в конструкторе. Программисты, которые выбирают этот подход, обычно делятся на 2 типа: первые пишут перед или после имени нижнее подчеркивание, то есть, член структуры объявлен так:

long id_;

И тогда, строчка присвоения выглядит так:

id_ = id;

вторые ставят букву m в начале имени, то есть: m_id; (от англ. слова "член" "member")

2. Можно называть параметр и член одинаково, и тогда, если мы имеем ввиду член структуры, то мы пишем перед ним слово this.

this - это указатель, который работает только в структурах и он говорит: "эта структура". Член структуры объявлен как обычно:

long id;

а присвоение происходит так:

this->id = id;

Обратим внимание: так как this это указатель, то после него ставится "стрелочка", а не "точка".

И последнее, что я хотел бы показать:

Более правильно в С++ производить присвоение ДО тела конструктора. То есть не так:

Student (long id) {
id_ = id;
}


А вот так:

Student (long id) : id_(id) {
}


После скобок, в которых перечислены параметры, ставится двоеточие, потом имя члена, скобки и значение, которое в него положить. Если есть несколько членов, которые нужно инициализировать, то они перечисляются через запятую. И тогда, язык гарантирует, что все переменные, которым присвоено значение таким образом, буду проинициализированы еще ДО того, как структура будет создана! Например, если член структуры - ссылка - то это ЕДИНСТВЕННЫЙ способ назначить ей значение!

Теперь о синтаксисе: я, в примерах выше, описывал конструктор и деструктор в теле структуры. НО, как правило так не делают (можно, но так не делают, это не удобочитаемо). Прибегают к такому трюку:

struct Student {

Student ( long id ) ; // только объявление конструктора

long id_;

};

А ниже в коде, среди других функций описывают конструктор:

Student::Student (long id) : id_(id)
{
// тело конструктора
}

То же самое делают и с деструктором.


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

1. Работа со структурами через указатель
2. Статические переменные в структуре
3. Использование конструктора и деструктора.


Код:









Результат:




Разбор полетов:

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

Начнем сверху. Во-первых, из-за того, что я ниже пользуюсь функциями strlen и strcpy, мне необходимо подключить string.h.

Ниже я описываю структуру, в которой я отмечаю, что есть конструктор и деструктор. Это объявление, код этих функций я опишу ниже. Далее я объявляю "вспомогательные" функции, а после этого - выставляю начальный параметр в статическую переменную структуры. Она получит параметр 0 еще ДО старта программы.

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

Отлично. Ниже я описываю main. В нем я создаю 2 переменные из типа "Студент", одну в стеке, другую в куче. Обратим внимание, что перед созданием переменных я пишу на экран сообщение. Ниже в конструкторе, я тоже распечатаю на экран сообщения, чтобы было видно, когда отрабатывает конструктор.

После создания структуры я сразу заполняю переменные math_grade в обоих структурах. С первой я работаю через точку, так как это сама переменная, а со второй - через стрелочку, потому что это указатель на переменную.

Потом, я вызываю функцию, которая распечатывает ответ на вопрос "прошел ли студент математику". Посмотрите, что там все ясно.

Примечание: я передаю переменные в функцию через указатель. Почему? Как мы уже поняли, структуры могут быть очень массивные, поэтому, если передать переменную по имени, то во время приема ее в функцию, структура будет копироваться. И в функции мы будем работать с копией, это расточительно. Поэтому лучше передавать структуры либо через указатель, либо через ссылку. А чтобы гарантировать, что в функции данные не будут изменены, можно добавить слово const, превратив переменную в константу (только для этой функции).

В конце я освобождаю динамическую аллокацию, распечатав при этом, строку сообщения. Из деструктора я тоже буду печатать на экран, чтобы показать, что он сработал. Обратите внимание, что деструктор сработал 2 раза (см. на "Результат"). Первый раз он сработал для переменной в куче, когда я написал слово delete, а второй раз - для переменной в стеке. Второй деструктор вызвался "неявно", как только переменная, созданная в стеке покинула область видимости (пределы функции main).

Ниже я описал 2 вспомогательные функции, в которых нет ничего необычного, кроме, пожалуй одного маленького момента: способа написания распечатки из is_math_pass. Так как для компилятора конец строки это точка с запятой, то в принципе, это все - одна строка. Я разбил ее на строки, чтобы удобней было читать.

Конструктор. Первое, что я делаю в конструкторе, я обнуляю члены структуры. Посмотрите, как я это делаю. Это происходит через двоеточие. Это гарантирует то, что эти члены будут "обнулены" еще до того, как начнет работать конструктор. Так делать правильно.

В самом конструкторе я получаю переменные, которые совпадают с именами членов структуры, поэтому, к членам я обращаюсь через this и стрелочку (потому что this - это указатель). На самом деле, обычно я так не делаю, я отношусь к той группе программистов, которые любят называть члены структур с нижним подчеркиванием, то есть: first_name_ и last_name_. Скорее всего, далее в примерах я буду делать так. Сейчас я специально назвал это одинаково, чтобы познакомить вас с указателем this
Я динамически аллокирую места под имена и заполняю их. При этом я пользуюсь стандартными функциями.

В деструкторе мне нужно освободить имена перед тем, как структура будет уничтожена. Если этого не сделать - будет утечка памяти! Но обратите внимание, что в деструкторе я уже не пишу this перед членами! НЕ будет ошибкой, если написать это, но просто в этом случае нет необходимости, так как других кандидатов на эти имена нет (в конструкторе имена членов совпадали с именами параметров, полученных в конструктор).

Хорошенько пройдитесь по коду и убедитесь, что в нем все досконально понятно. Если остаются неясности - нужно переписать код себе и поиграться с ним, меняя его. Обычно, когда щупаешь все сам - становится понятней)))


Это была длинная лекция, которая включала в себя много нового. Не спешите продолжать, прежде чем не усвоите эти знания. Они ВАЖНЫ!

Домашнее задание

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

Структура имеет имя, фамилию, оценки и ID-номер студента. ID номер назначается автоматически при создании студента. Предположите, что количество студентов не может выходить за рамки числа, которое может быть сохранено в переменной long. Потрудитесь сделать так, чтобы ID был уникальным для каждого студента. Имя и фамилию студент получает в конструктор. (То есть: при создании переменной студент необходимо указать имя и фамилию)

Введите студентам те же оценки, которые были в прошлом задании и распечатайте имена И ID-номера тех, кто достоин поездки на олимпиаду.

Требование: все студенты должны быть созданы в куче.

Удачи!

@темы: C++

---

Официальный день Бритни!!!!

Ровно год назад, 29 марта, 2011 года, Бритни дала мини-концерт в городе Сан-Франциско, в рамках промо-акции к своему новому альбому "Femme Fatale"! Концерт транслировался в передаче "Good Morning America". Кроме того, что тысячам повезло увидеть незабываемое шоу в живую, еще миллионы смотрели ЭТО по телевизору! Но это не все приятности, которые произошли в тот день! После исполнения песни Till The World Ends, Бритни получила сертификат о том, что 29 марта, в Сан-Франциско, отныне "официальный день Бритни Спирс"!!!!!!

Поздравляю этот прекрасный город с этим Великим днем!!!!!

Вспомним, как это было:

@темы: Britney Spears

---

Бритни Спирс - Скандальная биография. Моя рецензия на книгу.

Привет, любимки!

Паучок наконец-то прочел "Бритни Спирс - скандальная биография" Шона Смита, и решил попробовать свои силы в написании рецензии.

Немного предыстории: я долго ломался, покупать эту книгу или нет? Больше всего я боялся, что заплачу бабло говнюку, который польет грязью мой бриллиантовый Образ. Но, к счастью этого не произошло. Конечно, кроме "Скандальной биографии" я еще купил и "Изнанку мечты", но пока я ее не читал. Я решил начать с этой, так как вторую больше людей хвалит (эту похвалила только Светочка Фридум), и я решил не повторять ее ошибки: я сделаю перерыв, с месяцок, и только потом прочту вторую (она прочла обе, одну за другой и естественно, вторая ей понравилась меньше, так как в принципе, насколько я понимаю, истории, написанные в них - похожи, поэтому вторую ей было читать скучно). Но мы заболтались))))

Начало книги мне понравилось сразу. Автор начал свое исследование с того, что поехал в родные места Брит и немного пожил среди этих людей. Он описывает эту южную глубинку довольно доходчиво и перед глазами сразу всплывает образ глухого американского городка, в котором жители ведут нерасторопную жизнь, в дали от шумных мегаполисов. Уверен, что там чаще услышишь мычание коровы или стрекотание кузнечиков, чем шум двигателя, воздух чистый и свежий, а люди очень приветливы и набожны, придерживающиеся вековых традиций и понятий о том, что такое мораль, этика и культура поведения. Если вы заговорите с кем-то, то к вам будут обращаться как "сэр" или "мэм" (зависит от вас)))

Я сразу же провел параллели с нашими поселками городского типа, где люди чисты и не испорчены погоней за гламуром, славой или всеобщей лихорадкой возвыситься над остальными. Да... именно в таком месте и родилась наша чудесная девочка, которой суждено было стать кумиром миллионов людей по всему миру и вырастить уже не одно поколение на своей музыке! Шон Смит описывает семью Бритни как людей довольно бедных, но вкладывающих все силы в воспитание самого главного своего богатства - своих детишек. Отец - мотается по округе в поиске работы, а мама - сельская учительница младших классов. Хочу сказать, что без знания этих фактов сложно понять, что ИМЕННО творится в этой светлой головке и как объяснить тот или иной ее поступок, поэтому - за первую часть работы я смело ставлю ему пять с плюсом!

Однако, мой первичный восторг работой автора очень быстро сменился налетом легкого разочарования: он совершенно не пытался заглянуть и сделать вывод КАКАЯ ОНА - Бритни Спирс? Книга написана в духе газетной вырезки, и Шон лишь цитировал рассказы людей, знающих маленькую Богиньку, даже не пытаясь дать хоть поверхностный анализ их словам. Может, с одной стороны это и хорошо, но с другой, это делает чтиво намного скучнее и местами я просто боролся с собой, чтобы не пролистать главу.

Но стоит заметить, что автору удалось найти подходы к некоторым нужным людям, которые сделали эту работу вместо него. Очень интересны рассказы Рега, который был первым бой-френдом нашей сельской красавицы. Они начали встречаться, когда Бритулечке было всего 14, а Регу - около 18. Он был вхож в семью Спирсов и даже дружен с ее старшим братом Брайаном (они сверстники). Рег описывает Бри, как девочку, совершенно лишенную интереса к "мальчачим" ценностям и это было мое первое удивление, потому что мне, почему-то казалось, что она - типичная "пацанка". Однако, как оказалось, это абсолютно не так. Хочу отметить, что Рег - достоин уважения, так как у него, как ни у кого другого было ОЧЕНЬ много шансов смешать Бритни с грязью и пропиарится за счет скандальных историй, НО! Рег не позволил себе такую низость НИ РАЗУ, за что даже удостоился личной благодарности Джейми (папы Брит), правда по телефону: "Рег, я хочу тебя поблагодарить за все, что ты говоришь о моей дочери".

Хочу сказать, что моя ошибка в выводах, что Бри - пацанка, была практически единственной, так как книга почти полностью подтверждает отдельные мои догадки о характере Богини. Она прилежно училась, но только потому, что в ее характере есть черта, не позволяющая ей "отлынивать и косить". Она - обычная отличница, которая слушает маму и делает уроки, но ее ВОВСЕ не интересует почти ничто, кроме танцев, песен и, как ни странно, баскетбола)))) Даже гимнастика, которой Бритни по началу сильно заболела - быстро ей надоела и, на каком-то этапе, мама решила не мучить дочку позволив ей бросить занятия.

Книга более-менее подробно описывает период клуба "Микки Маус", но опять-таки, заслуга автора лишь в том, что он сумел найти нужного и довольно разговорчивого человека, и опять отработал лишь как стенографист, но не как исследователь. Интересен был период рождения суперзвезды Бритни Спирс, а так же мне очень понравилось ее поведение по отношению к Регу, которого она тщетно пыталась утащить с собой в мир "богатых и знаменитых", но яростное сопротивление Линн Спирс и Фелисии сделали свое дело и Рега очень некрасиво "исключили" из жизни будущей Поп-Королевы, посчитав, что тот будет огромной помехой ее творческой карьере.

Бритни находилась под жестким прессингом со стороны доброжелателей и именно это и стало "бомбой замедленного действия", так как подростковый бунт, свойственный ЛЮБОМУ нормально развивающемуся ребенку, она не реализовала вовремя, что, конечно же, только оттянуло и усилило мощь этого взрыва. Когда "рубили" Рега, этот ребенок (Бритни) еще была в стадии, в которой привитое ей с детства "да, мэм", было сильнее собственного "я". Но, как мы все понимаем, чем позже происходит неизбежное, тем страшнее последствия!

Этот гнойный нарост подросткового бунта лопнул еще в начале 2003 года и первое его последствие - 55-ти часовой брак с сельским крепышом Джейсоном Александром. Я, как и все тут, конечно же знал про этот брак ранее, но я не знал подробностей: как именно это произошло? Книга довольно ярко описала этот момент ее жизни, но "заслуга" в этом опять принадлежит не автору, а тому факту, что Джейсон продал эту историю, рассказав все до мелочей какой-то газетенке, за что отхватил немножко деньжат. Как мы видим, Рег - исключение в жизни нашей любимки... к сожалению, большинство мужиков, так или иначе появившихся в ее жизни - не достойны даже целовать землю, по которой она ходила. Слава богу, что она умная девушка и не сделала выводы о всех представителях мужского пола, по этим недоноскам!

Хотя, я совру, если скажу, что меня ХОТЬ КАК-ТО разочаровало поведение Бритни в эти несколько дней! Наоборот! Если даже предположить невероятное, что до этой истории и было несколько клеток в моем организме, которые не так сильно любили Бритулю, то после того, как я прочел, что именно произошло в те рождественские каникулы, таких ТОЧНО НЕ осталось! Мне просто хотелось хлопать в ладоши и ржать как конь, когда я читал, как этот ураган, по имени Бритни Спирс, смел последние остатки мозгов бедняги сельского паренька!

Я живо представил себе картину: он, весь такой в соляре и мазуте, закончив год, решил отпраздновать рождество, как, на его беду, в этой компании появилась ТА, которую хотят МИЛЛИОНЫ мужчин во всем мире, истекая слюнями только от одного имени... в начале был невинный флирт, но когда мама решила вмешаться в происходящее и "приструнить" свою знаменитую дочь, Бритни захотелось наглядно показать, что она уже не тот послушный ребенок и будет творить то, что она захочет! Она просто схватила этого чувака за яйца и утащила в Вегас, в один из самых дорогих отелей, где, я извиняюсь, трахала его несколько дней. Да, именно так! Потому что "занятием любовью" невозможно назвать действо, когда вас хватает божественной красоты, разъяренная фурия, и не дав опомниться, просто выжимает вас как лимон, в трехдневном, сумасшедшем секс-марафоне! Тут растеряешь последние остатки мозгов! У него не было шанса выжить!

После этого, точно так же, из-за прикола этой прекрасной, но бешеной девушки, они оба, подогретые дорогой и качественной выпивкой, ПОСРЕДИ НОЧИ, находят какую-то богом забытую часовню, в которой, чуть ли не пижаме, женятся.... и только старичок Ларри, оценив шутку, позволил себе съязвить в телеграмме, адресованной Брит: "Мои поздравления! Ты только что профукала половину своих денег". Ну разве это не красиво??? Ну разве не захватывает это безбашенная лихость несравненной Прелести? ДА! Она СПОСОБНА НА ПОСТУПОК! И я еще раз в этом убедился! Я ОБОЖАЮ таких девушек! Просто без ума от них! Правда вовремя собранный консилиум "мамочек, тетушек и друзей" все же смог исправить последствия этой выходки и Джейсона Александра, пожевав, просто выплюнули на обочину истории, подарив ему, пожалуй, самые прекрасные дни его жалкой жизни! Думаю, он не остался в накладе, даже если предположить, что не получил ни копейки денег (хоть это конечно не так, автор приводит слухи, что полмиллиона зеленых ему таки дали и он вскоре их прокутил с друзьями)

Интересно еще то, что многие ругают Бри за ее внешний вид вне сцены и красных дорожек, словно это новое явление.... Отнюдь! Так было всегда! Бритни никогда не выходила в киоск за сигаретами в вечернем платье от кутюр! Она почти всю карьеру держит пальму первенства как "самая безвкусно одетая знаменитость", заявляя при этом, что будет ходить в том, в чем ей удобно, мол "не ждите, что ради вас я буду наряжаться, словно на красную дорожку" - это высказывание, как оказалось, ТЕХ лет!

Книга заканчивается 2005 годом, немножко захватив 2006. И представляет собой подборку скудных воспоминаний немногочисленных свидетелей и салата газетных вырезок как желтой, так и официальной прессы, касающихся жизни этой великой и прекрасной девушки, которую я так люблю! Так что, дружище, BritishGift, ты был абсолютно прав в своих предположениях! Назвать это "биографией" невозможно даже с натяжкой. Она не серьезна... Это скорее обычная "хронология событий". НО! Она помогла мне расставить в хронологическом порядке некоторые вещи, которые я не знал, в какой период приткнуть, а так же понять роль некоторых людей в жизни моей любимки и совсем чуть-чуть рассказала мне некоторые вещи, о которых я не подозревал. В целом - я оцениваю труд на очень слабую троечку.

Спасибо всем, кто осилил!

@темы: Britney Spears

---

Учимся программировать на С++. Лекция 17. Собственные типы переменных

Здрасте))))

решение домашнего задания с предыдущей лекции

Условие:

Напишите функцию void print_arr(int *arr, unsigned int size), получающую массив и его размер, которая распечатывает массив на экран. Позовите функцию несколько раз. Если вызов четный, то массив распечатывается с начала, при нечетном вызове массив распечатается с конца.

Требования:
1. Запрещено менять описание функции, то есть добавлять/убирать параметры.
2. Запрещено внутри функции print_arr использовать цикл.
3. Счет вызовов начинается с 1

Пример (3 вызова):

Массив:
{0, 1, 2, 3, 4}

результат вызова 1:
4 3 2 1 0

результат вызова 2:
0 1 2 3 4

результат вызова 3:
4 3 2 1 0

решение

Код:





Результат:

лекция

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

Мы начнем по чуть-чуть. Шажок за шажком. Это важная часть не только языка, но и всего программирования в целом, потому что с того самого момента, как языки программирования дали возможность создавать собственные типы - родился совершенно новый взгляд на программирование! Это ни больше ни меньше - революция программирования! Подход, в котором собственный тип ставится "во главу угла" получил название "Объектно-ориентированное программирование" (ООП). Напомню, что пока что мы изучаем более старый подход, получивший название "процедуральное программирование", где "во главу угла" было поставлено понятие "функция".

В этой лекции мы пока не увидим ООП, потому что процедуральное еще не до конца нами исчерпано, но то, что я покажу на этой лекции - положило начало ООП.

Энумераторы (англ. Enum)

Энумераторы - это самый простой и ограниченный способ создать свой тип (typedef я не считаю). Представьте ситуацию, в которой, вам, к примеру, надо работать с днями недели. Допустим, мы создаем 7 стрингов. В первом написано "понедельник", а в последнем написано "воскресение". Тогда, во всех функциях, в которые мы получили день и хотим узнать: какой день недели мы получили, мы пишем 7 блоков if, внутри которых мы сравниваем стринги, что, конечно работает медленно.

Хорошо, говорим мы. Мы хотим упростить работу: мы договоримся, что понедельник это 1, а воскресение - 7. Становится проще работать с такими вещами, плюс мы получаем возможность быстро узнать, сколько дней прошло между понедельником и воскресением. То есть, действие 7 - 1, скажет нам, что прошло 6 дней (что невозможно сделать со стрингами). Но какой минус мы получаем автоматом? Наверное САМЫЙ главный минус - не читабельность такого кода.

Можно сделать следующую штуку: объявить 7 глобальных констант и тогда это выглядит так:

const int MONDAY = 1;
......
const int SUNDAY = 7;

и мы получаем читабельность кода. Но программеры С (впервые энумераторы появились в С) пошли далее, они сказали: давайте дадим возможность в таких случаях объявить собственный тип! Мы получим штуку, которая будет обладать преимуществами обоих подходов (стринги и числа). Мы объявим "перечисления" (значение слова "enum" в английском языке):

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};

давайте разберем: в начале мы пишем, что мы создаем энумератор (перечисление), после этого, мы пишем название нашего типа. То, что мы создали - это ТИП переменной, собственный тип! То есть на него распространяются все законы, которые, скажем, распространялись на тип int. Точно так же, как мы могли создать переменную типа int в коде:

int num;

точно так же мы можем создать переменную типа Day в коде:

Day today;

В последствии, мы можем присвоить ему значение:

today = SUNDAY;

Естественно, что тип принимает только значения, перечисленные в момент создания в фигурных скобках. Мы так же можем передать его в функцию:

// описание функции:
void foo ( Day day );

// вызов функции в коде:
foo ( today );

Понятно, что мы также можем его вернуть из функции:

Day foo ( void );

Мы можем создать указатель или ссылку на этот тип:

Day * p = & today;

Day & r = today;

Мы можем создать массив таких типов:

Day week [ 7 ];

Day week [ ] = { MONDAY, FRIDAY, SUNDAY }; // массив из трех элементов


За этими значениями стоят числа, то есть, на самом деле, MONDAY, FRIDAY, SUNDAY и т.д. - это числа. По-умолчанию, они начинаются с нуля, то есть, в том виде, в котором я создал тип Day, значение MONDAY это ноль, TUESDAY - это один и так далее, до 6-ти включительно (SUNDAY это 6) в том порядке, в котором они указаны. Это значит, что если мы пишем:

FRIDAY - MONDAY, то мы подразумеваем 4 - 0

Допустим, сегодня понедельник. Мы спрашиваем в коде: "сколько дней до пятницы?", что нужно сделать? Нужно отнять пятницу от понедельника:

int num_of_days = FRIDAY - MONDAY;

И мы получим ответ: 4 дня.

Но начало с нуля, в днях недели - не интуитивное.... поэтому, мы можем сами назначить числовые значения, при создании типа:

enum Day { MONDAY=1, TUESDAY=2, WEDNESDAY=3, THURSDAY=4, FRIDAY=5, SATURDAY=6, SUNDAY=7};

Но, если наши числовые значения тоже идут по порядку, просто не начинаются с нуля, то можно назначить лишь первое:

enum Day { MONDAY=1, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};

Мы сказали: первый элемент это 1. Далее, язык сам "раздаст" значения в порядке возрастания, то есть - обе эти записи дают совершенно идентичный результат.

Однако, мы можем написать:

enum Day { MONDAY=1, TUESDAY, WEDNESDAY=33, THURSDAY, FRIDAY, SATURDAY=538, SUNDAY};

и тогда получится следующее:

enum Day { MONDAY=1, TUESDAY=2, WEDNESDAY=33, THURSDAY=34, FRIDAY=35, SATURDAY=538, SUNDAY=539};

Я люблю писать определение энумератора "в столбик":

enum Day {
MONDAY,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY,
SUNDAY
};

И тогда это становится более читабельным:

enum Day {
MONDAY = 1,
TUESDAY,
WEDNESDAY = 33,
THURSDAY,
FRIDAY,
SATURDAY = 538, // и тогда тут можно написать комментарий, вот так и что-то объяснить
SUNDAY
};


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











результат:

Структуры

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

Что же такое структура? То, что я расскажу сейчас, раскроет только небольшую часть возможностей, но я не хочу сваливать весь объем информации сразу, для одной лекции это будет слишком.


Представьте, что мы пишем программу. В нашей программе фигурирует студент. У студента такие данные:

1. номер студенческого билета
2. имя и фамилия
3. оценки за экзамены

Ну, на первое время хватит. Согласитесь, что было бы очень удобно, если бы это было сгруппировано в один тип. Представьте, что у вас есть тип "Студент", который выгодно отличается тем, что такой тип, словно "портфель", туда можно "положить" значения сразу нескольких типов: числа... стринги...

На каждого студента, в том заведении, для которого пишется программа, заведен такой вот виртуальный портфель, в котором все про него! Мы бы могли составлять целые списки студентов: кто поехал на олимпиаду по математике? А кто - кандидат на вылет.... Но о списках мы поговорим позже, а пока создадим тип "Студент" и рассмотрим его возможности.




Давайте начнем всматриваться в то, что я написал. Я объявил новый тип переменной и дал ему имя, написав

struct Student { } ;

То есть структура Студент. Внутри фигурных скобок я напишу типы переменных, которые содержатся в структуре, раздав им понятные имена. Номер студенческого билета ("student_id") - это тип long, так как скорее всего - номер длинный. Имя и фамилию ("first_name", "last_name") я буду содержать в типе char *. Так как я не знаю, какой длины имя и фамилия у конкретного студента, то я аллокирую память с нужным мне размером, а потом скопирую туда эти данные. В ВУЗе, в котором учится студент - всего 5 курсов (отличный вуз). Поэтому, я сделаю следующую вещь: я создам массив целых чисел, размером 5 и для каждого курса выделю место. Например, математика это 0, физика - 1, английский - 2 и так далее. Скорее всего, дополнительно, я создам Enum, в котором это будет прописано.

Я хочу написать коротенькую программу, чтобы наглядно показать, как работать с этим всем. В моем сценарии, программа получит данные и заполнит поля, а потом - распечатает это на экран. Я не буду писать в коде как программа получает эти данные, потому что это мы делать умеем (например с клавиатуры), я лишь освещу работу непосредственно со структурой. Итак код:


Код:








Результат:




Ну, что, разберем?
Я создал переменную Student и назвал ее britney. Это важно понять! Тип переменной: Student, имя: britney, это все равно, как если бы я написал int britney, где int это тип, а britney - имя.

Моя переменная состоит из набора примитивных переменных: long, 2 стринга и массив int. К каждой из них я обращаюсь через точку: имя переменной (структуры) ТОЧКА имя переменной (примитивной). Я показал, как писать и читать из такой переменной. Естественно, что на мою переменную распространяются ВСЕ законы обычных переменных: ее можно передать в функцию, ее можно получить из функции, можно создать указатель или ссылку на нее, можно создать массив таких переменных.... но обо всем этом мы поговорим в следующий раз, а пока - достаточно.

Домашнее задание:

Напишите программу, которая вычисляет студента, которого нужно послать на олимпиаду по физике.
Немного о вузе: в вузе есть всего 3 курса: физика, математика и английский. В Вузе - 100 бальная система оценок. Вуз заботится о своем имени и поэтому, он не посылает на такие мероприятия студентов, у которых средняя оценка по всем курсам ниже 85. На олимпиаду должны поехать студенты, у которых оценка по физике не меньше 90.

Создайте 3 студента с такими оценками:
1. физика 95, математика 90, английский 85.
2. физика 95, математика 60, английский 60.
3. физика 80, математика 90, английский 95.

Раздайте им произвольные имена.

Программа напишет на экран имена всех студентов, которые достойны поездки на олимпиаду по физике.

Примечание: Не обязательно получать данные с "внешнего источника", можно прописать их в коде. Цель задания - работа со структурами, а не с клавиатурой.
Совет: даже больше чем совет, скорее требование: разбейте код на функции, не пишите все в main, это не красиво.

Удачи!

@темы: C++

---

Учимся программировать на С++. Лекция 16. Рекурсия

Вот мы и подошли к вкусненькому))))

лекция

В этом мире есть мало людей, которые выучив "что такое рекурсия" остаются равнодушными к этому определению. Часть студентов, увидев впервые такую возможность - восторгаются, потому что такой подход дает возможность решать просто и элегантно задачи, которые были весьма сложными, без рекурсии, НО! Есть и другая часть, которая почему-то сразу решает, что "это я не пойму никогда, поэтому - нафик" и они действительно, дав себе такую установку, уже не способны понять эту тему. Вторым мне всегда хотелось задать вопрос: "насколько вы уверены, что выбрали тот факультет, который вам нужен?" Программист, который боится нового - это все равно, как скалолаз, который боится высоты.

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

Сейчас, по прошествии лет, я понимаю, что подобный ответ был очень простой и неточный, точно так же, как если меня спросят: "а что такое Мона Лиза", а я отвечу: "портрет улыбающейся бабы". Вроде и не соврал, да? Но..... насколько я точно описал то, что висит в Лувре, то, чем восторгаются миллионы, то, что считается основным шедевром живописи?....

Рекурсия - это функция, которая вызывает саму себя, это правда (точнее - частичная правда, потому что бывают "сложные рекурсии", в которых это не совсем так). НО! Это намного больше! Это умение "мыслить наоборот", "ездить задним ходом"... то есть - это почти искусство! Приведу классический пример: вычисление факториала.

Здесь стоит напомнить, что такое "факториал"? Возможно, что немногие это помнят. Факториал - это математическое действие, такое же, как извлечение корня, возведение в степень, умножение и пр. Записывается оно так: 5! - то есть "факториал из 5-ти". Ставится цифра, из которой надо вычислить факториал, а после нее - восклицательный знак. Чему оно равно?

5! = 5 * 4 * 3 * 2 * 1 // то есть: 120


еще пример - факториал из 4

4! = 4 * 3 * 2 * 1 // то есть: 24

Я специально записал одно под другим. Давайте взглянем внимательно на первый пример: что такое 5! ? Это по-сути 5 * 4! То есть, зная что 4! это 24, нам не нужно вычислять "весь путь", нам достаточно умножить 5 на 24. К чему я это веду? Да к тому, что это, в принципе, и есть определение факториала! Более "математическим" языком это выглядит так:



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

Что мы видим? В начале написано, что n! (где n это число, из которого мы хотим вычислить факториал) равно: и вот тут теперь 2 возможности, чему равно n!: нас в начале "спрашивают", а чему равно n ? Если n равно нулю, тогда n! равно 1, а если n больше нуля, тогда n! равно нашему n умноженному, на факториал из числа, на один меньше, чем n.

То есть, предполагается такой способ вычисления. Давайте разберем на примере 3!

Мы подходим с 3! и спрашиваем чему оно равно? То есть, в нашем случае, n = 3. Нам говорят: n > 0, то есть: 3! = 3 * 2! (типа, что не понятно?) Отличненько, говорим мы... а чему же равно 2! ? И приходим к той же самой формуле (и это важно) - нам говорят: n > 0, то есть 2! = 2 * 1!.....

Ладно.... говорим мы.... а чему равно 1! ? Нам говорят: n > 0, то есть 1! = 1 * 0!..... да вы задолбали, долбанные математики! А чему равен 0! ? Вот! Отвечают они нам: в этом случае у нас есть сиюсекундный ответ! n = 0, то есть 0! = 1

Мы как бы спустились на самое дно, дорылись до однозначного ответа, и теперь надо "собрать" свои знания. У нас был вопрос чему равен 0! и мы теперь знаем, что это равно 1. Но откуда возник этот вопрос? А! Мы вроде хотели определить, чему равен 1! нам тогда сказали, что это равно 1 * 0!, но теперь мы знаем, что 0! это 1, то есть, 1! = 1 * 1

НО! Вопрос "чему равен 1!" возник потому, что мы спрашивали чему равен 2! и нам сказали, что 2! = 2 * 1! но мы то теперь знаем, чему равен 1! то есть, легко можно вычислить, чему равен 2! .... и так далее.... надеюсь понятно.

Давайте вглядимся, а чем мы собственно занимались? Мы как бы "вкапывались" сначала внутрь, а потом, там, на самом дне, получив однозначный ответ, возвращались с ним назад, по той же дороге, собирая по пути результаты предыдущих действий. И при этом - мы пользовались одной и той же функцией! То есть функция как бы "вызывала саму себя", не так ли? Опа.... знакомый звон))))

Как же вычисляется факториал в программном коде? Так же просто:




Результат:




Давайте разберем:
Пользователь ввел цифру 5.

вызов 1: Из функции main мы попадаем в функцию factorial, х = 5.
х == 0 ? - нет
тогда вычислим чему равен факториал х-1 и сохраним результат в у

вызов 2: Вызываем функцию factorial, х = 4.
х == 0 ? - нет
тогда вычислим чему равен факториал х-1 и сохраним результат в у

вызов 3: Вызываем функцию factorial, х = 3.
х == 0 ? - нет
тогда вычислим чему равен факториал х-1 и сохраним результат в у

вызов 4: Вызываем функцию factorial, х = 2.
х == 0 ? - нет
тогда вычислим чему равен факториал х-1 и сохраним результат в у

вызов 5: Вызываем функцию factorial, х = 1.
х == 0 ? - нет
тогда вычислим чему равен факториал х-1 и сохраним результат в у

вызов 6: Вызываем функцию factorial, х = 0.
х == 0 ? - да
вернем 1 в вызов 5. В итоге в у лежит 1

умножим х * у, то есть, (смотрим вызов 5) 1 * 1
и положим результат в ret. Вернем ret, который равен 1 в вызов 4
в итоге, в у от 4-го вызова мы положили 1

умножим х * у, то есть, (смотрим вызов 4) 2 * 1
и положим результат в ret. Вернем ret, который равен 2 в вызов 3
в итоге, в у от 3-го вызова мы положили 2

умножим х * у, то есть, (смотрим вызов 3) 3 * 2
и положим результат в ret. Вернем ret, который равен 6 в вызов 2
в итоге, в у от 2-го вызова мы положили 6

умножим х * у, то есть, (смотрим вызов 2) 4 * 6
и положим результат в ret. Вернем ret, который равен 24 в вызов 1
в итоге, в у от 2-го вызова мы положили 24

умножим х * у, то есть, (смотрим вызов 1) 5 * 24
и положим результат в ret. Вернем ret, который равен 120 в вызов main
в итоге, в x от вызова main мы получили конечный ответ: 120


Теперь немного о терминах:

В нашем примере, мы закончили "углубляться" в вызовы и начали возвращаться на условии х == 0. Это условие называется "условие остановки".

Нам пришлось сделать 6 вызовов рекурсивной функции. Это число называется "глубина рекурсии".


То есть, мы сейчас имплементировали функцию факториал точно по ее определению! Можно ли, в этом случае, заменить рекурсию циклом? Да, можно! Теория гласит, что ЛЮБУЮ рекурсию можно заменить циклом! Единственный вопрос: насколько это будет менее красиво и более сложно в понимании и обработке?


Чтобы понять, к чему я клоню, мы рассмотрим пример. Программа, которую мы напишем, получает число от пользователя и высвечивает на экран бинарный вид этого числа. Я не буду писать main, потому что там нет ничего интересного, я напишу саму функцию. Для начала, я имплементирую ее в цикле:





Что мы имеем? Мы имеем 3 цикла! И все это только потому, что нам нужно писать результат в обратном порядке.... а как бы эта же функция выглядела, если бы мы имплементировали ее в рекурсии? Вы будете смеяться......



Это всё! Согласитесь, что это намного проще, элегантней и понятней! Не нужно никаких "буферов", (которые тем более, в моем решении, почему-то предполагают, что число не будет содержать более 64 символов.... это конечно же можно переписать по-другому, заморачиваясь проверками "не вышли ли мы за границу буфера", и если да, то мы сделаем новую аллокацию....) не нужно 3 прохода по этому буферу, не нужно делать непонятных телодвижений.... Рекурсия, которая пришла нам на помощь, помогла решить задачу просто и элегантно!

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

Сложная (косвенная) рекурсия

Сложная рекурсия, это несколько функций, которые вызывают друг друга "по кругу". То есть, если существует функция foo(), которая в своем коде зовет функцию bar(), а в функции bar(), в свою очередь вызывается foo(), то с одной стороны - это рекурсивное поведение, но с другой - прямого вызова foo() из самой foo() нет, она как бы "косвенно" вызывается через bar(). Такая рекурсия называется "сложной" или другое имя "косвенной".

То есть, происходит примерно следующее:

void foo ( ) {

// код

bar ( );

// код

}

void bar ( ) {

// код

foo ( );

// код

}

Для чего такое применяют? Ну, первый пример, который приходит мне в голову, это проход по папкам в компьютере, в которых лежат архивы (например rar). Я не буду имплементировать это, потому что не вижу в этом смысла: кода много, а ничего нового, в плане рекурсии, мы не увидим, чтобы не смогла показать моя схема выше, я лишь расскажу этот алгоритм в теории:

Представьте, что у вас есть папка, в которой лежат архивы, которые вам нужно распаковать. Функция foo() умеет зайти в папку и найти там файл архива, который она передаст в bar() для распаковки. bar() распаковывает архив в папку и в свою очередь зовет foo(), чтобы та проверила нет ли внутри еще одного архива. Естественно, foo(), найдя архив, вновь позовет bar()..... думаю - идея понятна.

Как правило, в такой игре участвуют две функции, но никто не запрещал создать такую тройку, четверку и так далее. Например, я недавно задался целью написать программу, которая умеет скачивать фотографии с галерей в инете. Мне очень хотелось скачать одну классную галерею с фотографиями Бритни и я начал писать. Строение галереи такое:

В категории фотографий (например - "Выступления") есть разделы по годам, в этих разделах по годам - есть альбомы конкретных выступлений. У меня было 3 функции, которые раскручивали эту карусель: manager(), download(), parser().

manager() получала ссылку, регистрировала ее (не важно по какой причине, скажем - для отчетности) и вызывала функцию download()

download(), в свою очередь умела по этой ссылке полезть, и если это был, к примеру, раздел, то она получала этот раздел к себе, в виде кода HTML, далее этот код она "скармливала" функции parser().

parser() умела понять код HTML, найти в нем ссылки на альбомы и передать их в функцию manager(), где карусель повторялась. И так, раскручивая, словно по спирали, я "докапывался" до ссылок на сами фотографии.

Не могу сказать, что это тривиальный алгоритм, но задача стояла так, что без косвенной рекурсии было бы ОЧЕНЬ сложно такое решить.

Опасность рекурсии

Рекурсивные функции - очень расточительная штука для памяти, потому что с каждым новым вызовом рекурсией "саму себя" происходит ПОЛНОЕ копирование всех переменных, и прочих вещей в стеке. Поэтому, в условиях программирования с ограниченным количеством памяти (например, программирование на каких-нибудь очень примитивных компьютерах, типа свичей и прочей ерунды, то, что называется "программирование низкого уровня"), рекурсию не используют.

Из-за этого постоянного копирования содержимого стека, если программист не правильно задал условие остановки, возможно переполнение стека и как следствие - падения программы. Такая ошибка так и называется "Переполнение стека" (англ. "Stack overflow"). Будьте внимательны!

Статические переменные

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

Статическая переменная, это такая переменная, которая инициализируется всего один раз, тогда, когда алгоритм впервые ее встречает. Если глобальная переменная объявлена статической, то она будет инициализирована еще до начала программы. Чтобы объявить переменную статической, перед ней пишут ключевое слово "static". Теперь, я на примере объясню что я сейчас написал, так как это может быть не совсем понятно из теоретического объяснения.

int main(){

// код

foo(); // первый вызов foo

// код

foo(); // второй вызов foo

}


void foo(void){
int i = 0;
i ++;
cout << "the i: " << i << endl;
}

В функции foo есть переменная i, при каждом вызове она получает значение 0, потом его увеличивают на один, то есть каждый раз на экран будет выведено "the i: 1". Это поведение нам знакомо и оно логично. НО! Стоит изменить код и написать перед i слово static, как поведение поменяется! То есть:

int main(){

// код

foo(); // первый вызов foo

// код

foo(); // второй вызов foo

}


void foo(void){
static int i = 0; // теперь i - статическая переменная! Эта строка выполнится всего ОДИН раз! (первый раз)
i ++;
cout << "the i: " << i << endl;
}

Теперь, при первом вызове распечатается строка "the i: 1", при втором "the i: 2" и так далее. То есть, При выходе из функции переменная не умрет, а продолжит существовать. А значит, она "запомнит" свое значение для следующего раза. Если переменная объявлена в рекурсии, то, как я говорил выше, при рекурсивном вызове все содержимое функции копируется в стеке, то есть - все, КРОМЕ этой переменной!

Домашнее задание

Напишите функцию void print_arr(int *arr, unsigned int size), получающую массив и его размер, которая распечатывает массив на экран. Позовите функцию несколько раз. Если вызов четный, то массив распечатывается с начала, при нечетном вызове массив распечатается с конца.

Требования:
1. Запрещено менять описание функции, то есть добавлять/убирать параметры.
2. Запрещено внутри функции print_arr использовать цикл.
3. Счет вызовов начинается с 1

Пример (3 вызова):

Массив:
{0, 1, 2, 3, 4}

результат вызова 1:
4 3 2 1 0

результат вызова 2:
0 1 2 3 4

результат вызова 3:
4 3 2 1 0

Удачи!

@темы: C++

---

Учимся программировать на С++. Лекция 15. Неопределенный указатель

Здрасте))))

решение домашнего задания с предыдущей лекции

Условие:

Напишите программу, которая получает от пользователя 2 параметра:
1. стартовое число
2. количество чисел

Программа сохранит ряд чисел, начиная со стартового, а если количество чисел равно нулю, то программа напишет "Нечего делать" и выйдет. Предположите, что пользователь ввел правильное число, то есть не нужно проверять, не выходит ли число за рамки, установленные размером типа int

Пример:

1. Пользователь ввел:
стартовое число == 12
количество чисел == 3

Программа сохранит такие числа: 12, 13, 14

2. Пользователь ввел:
стартовое число == -2
количество чисел == 5

Программа сохранит такие числа: -2, -1, 0, 1, 2

В конце можно распечатать сохраненные числа, чтобы убедиться, что все сделано правильно.

Удачи!

решение

Код:








Результат:

лекция

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

Преобразование типов

Для начала, давайте вспомним такой факт: на прошлом домашнем задании я выполнил такое, пока еще не совсем понятное действие: я отнял char от char, а результат положил в int. Я сказал, что это можно делать потому, что int хранится в большем количестве байт, чем char, значит нет потери данных, и поэтому язык позволяет это сделать.

Что же произошло, когда я отнял char от char? Создался новый char и программа сохранила его в переменной из типа int, заполнив "лишнее" место нулями. То есть произошло преобразование одного типа в другой.

Преобразование (англ. "casting") это возможность "переделать" один тип в другой. Так как все, в конечном итоге, кусок памяти, заполненный единицами и нулями, а все зависит лишь от нашего взгляда на этот кусок, то такое теоретически возможно

Хочу еще немного объяснить это. Если мы заглянем в таблицу ASCII, то мы увидим, что буква "а" это 97. То есть, в определенном куске памяти, в бинарном виде написано "97". Стоит вопрос: как смотреть на это число? Как на число или как на букву "а"? Программист, выполняя преобразование "говорит" программе каков правильный взгляд на этот, конкретный кусок памяти.

НО! во время операции в домашнем задании, когда я отнял char от char, программа сделала преобразование сама, вместо меня, поняв мои намерения потому, что я положил результат в int. Такой тип преобразования называется "неявный".

Ну, раз существует "неявный тип", то должен быть и "явный", не правда ли? И он существует! На самом деле, в С++ есть несколько способов выполнять преобразование, но я всегда пользуюсь только "простым" и на это есть причины: все остальные способы более "защищенные", то есть, программа не выполняет тупо то, что говорит ей программист, а проверяет "можно так делать или нельзя".

Почему же я не пользуюсь этим? Ответ прост: я не выполняю преобразование каждые две строки кода. Я стараюсь делать это редко и тогда, когда это ОЧЕНЬ оправдано. То есть - без этого нельзя, НО! Если уж я делаю преобразование, то я на миллион процентов уверен в том, что я делаю, поэтому дополнительные проверки со стороны программы мне не нужны. То есть, выполняя такой тип преобразования, программер как бы говорит: "Сядь и не переживай! Это - было float, а теперь int. Потому что я так хочу! Не спорь, а выполняй, тупая железяка!"

Допустим, у нас есть такой код:

int num = 97; // ascii код буквы "а"
char ch = 0;

ch = (char) num; // я "вкладываю" в int в char, выполнив "явное" преобразование

cout << ch; // на экран распечатается буква "а", а не 97.

Точно так же, можно заменить 3-ю строку таким кодом:

ch = char(num); // это считается более С++ формой преобразования

Но, в итоге - оба варианта делают одно и тоже. Лично я предпочитаю первый, просто по-привычке.

Примечание: преобразование типов - потенциально опасное место в коде, поэтому, повторюсь еще раз: оно производится только при одном условии: программист УВЕРЕН в своих действиях!

Для интереса запустите такой код:

char ch = 'a';

cout << ch << endl;
cout << (int) ch << endl;
cout << (float) ch << endl;

программа распечатает один раз "а", второй раз "97", в третий раз "97.0".


И напоследок, еще одно напоминание. Как мы помним, одно из первых домашних заданий выглядело так:

"Напишите программу, которая получает от пользователя 2 положительных числа и высчитывает среднее арифметическое между ними." (Лекция 5. Типы примитивных переменных)

Что я сделал? Я объявил переменные как float, сказав, что сделал это потому, что результат может быть дробным. Но я так же сказал, что не обязательно объявлять так:

float first_num = 0;
float second_num = 0;
float average = 0;

Кроме переменной average, можно объявить еще только одну переменную, как float, допустим переменную first_num, то есть:

float first_num = 0;
int second_num = 0;
float average = 0;

тогда код: average = (first_num + second_num) / 2; ТОЖЕ отработал бы правильно! Почему? Потому что программа, совершая действие над разными типами int и float, совершает неявное преобразование в пользу бОльшего типа, то есть в этой ситуации в float.

Однако, можно было бы поступить и так:

int first_num = 0;
int second_num = 0;
float average = 0;

То есть, изначально объявить все переменные как int (кроме average) и тогда, строка арифметического действия, ниже, выглядела бы так:

average = (float) ((first_num + second_num) / 2); ИЛИ так: average = float ((first_num + second_num) / 2);

То есть, выполнив явное преобразование.

Вы вполне можете проверить мою правоту, запустив код с теми изменениями, которые я предложил.

Неопределенный указатель или void *

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

int num = 0;
int * p_num = new int;
char ch = 'c';
char * str = "hello";
float * p_f = new float;

void * universal_pointer = NULL;

universal_pointer = & num;
universal_pointer = p_num;
universal_pointer = & ch;
universal_pointer = str;
universal_pointer = p_f;

Насколько видно из кода, можно объявить указатель на void и он обладает интересным качеством: ему можно присвоить адрес любой переменной! Однако, такой тип указателя обладает и минусом, а именно: им можно пользоваться только для того, чтобы хранить что-то, то есть код:

int a = 5;
int b = 7;
int c = 0;
void * p = &a;

c = (*p) + b; // так писать нельзя!

но можно так:
int * p_num = (int *) p; // преобразование в указатель на int
c = (*p_num) + b; // а вот так - уже можно.

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

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

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

Все это немного "висит в воздухе", но дайте время))))

Резюме: на этой лекции мы выучили способ преобразовывать один тип в другой, а так же познакомились (совсем чуть-чуть) с указателем на неопределенный тип. Так как оба знания - пока чистая теория, то домашнего задания на этот раз не будет.

@темы: C++

---

Учимся программировать на С++. Лекция 14. Динамический заем памяти.

Привет всем!

решение домашнего задания с предыдущей лекции

Условие:

Напишите 2 функции:

1. функция:

bool ascii_to_int (char * num_str, int & num);

Принимает стринг, в котором написано число и переводит его в тип "целое число" (int). Ответ "возвращается" через параметр num, а функция возвращает bool (правда - если перевод удался, ложь - если полученный стринг не является числом)

Примечание:
стринг "vasya123" - функция НЕ переведет в число, потому что стринг НЕ начинается с чисел (вернется ложь)
стринг "123vasya58" - функция переведет в число 123 и функция вернет "правда". (остаток "vasya58" - будет игнорирован)
стринг " 54" (с пробелами впереди) - будет успешно переведен в число 54

проверьте работу функции на следующих стрингах:
1. "-57" - удачно
2. "348str236" - удачно
3. "@12" - не удачно
4. "c++" - не удачно
5. " -238" - (с пробелами впереди) удачно


2. функция:

void int_to_ascii (int num, char * buf, unsigned int buf_len);

Принимает целое число через параметр num. Переводит его в стринг и ответ кладет в буфер buf.

Проверьте работу функции на числах:
1. -578
2. 33
3. 0

решение

Код:










Результат:




Пояснения:

Да..... ну во-первых, хочу признать: я немного отжег с домашним заданием))))) Сниму шляпу перед тем, у кого все получилось! Но... "не все коту масленица", пора расти)))
Задача была действительно сложной для этого уровня знаний, это правда. Особенно сложной была функция "int_to_ascii", думаю, что ее "сестра", "ascii_to_int" пошла НАМНОГО проще)))

Но, дело сделано и остался только "разбор полетов".

Для начала, внимание на операцию define. Теперь все константы я буду объявлять так. В этой константе прописан размер буфера, в который я пишу результаты из функции int_to_ascii.

В функции main нет ничего, что стоило бы объяснять, более того, писать ее было не обязательно. Я написал ее, чтобы просто проверить результаты. Праздник начинается ниже!



Разберем, в начале функцию ascii_to_int

Я получаю число, написанное в стринге и должен превратить его в int. Что я делаю? Допустим, я получил стринг: "-236", это выглядит так:

стринг из 5-ти ячеек, а именно:
ячейка 0 содержит знак "минус"
ячейка 1 содержит символ 2 (в ascii)
ячейка 2 содержит символ 3 (в ascii)
ячейка 3 содержит символ 6 (в ascii)
ячейка 4 содержит символ '\0' (конец строки)

Первым делом я обнулю ссылку, в которую я должен положить результат. Я делаю это потому, что мой алгоритм построен так, что числа прибавляются к существующим, поэтому, я обязан убедиться, что изначально там 0, иначе, если функция получила num равный 12, например.... и стринг, в котором написано "58", то результатом ее работы будет 1258, а НЕ 58, как было задумано. Почему это так, мы разберем ниже.

условие в блоке for построено так, что в блок зайдет только стринг, начинающийся с "легальных" символов, а именно: это символы цифр в ascii, пробел и знак минус. Как только в стринге появляется что-то другое - цикл заканчивается. То есть, если с самого начала там была буква, то цикл не сделает ни шагу! Аналогично, цикл закончится, если встретит символ '\0' (конец строки). Как бы "двух зайцев - одним выстрелом".

В самом начале я проверяю, не является ли конкретный символ пробелом? Если да, то я проверю, где она находится: если в начале строки, то это номально и я просто его промотаю, если в середине или в конце, то мое число на нем закончилось. Как я это проверю?

Если до сих пор я не встретил ни одну цифру, то я - в "первом" положении, иначе - я во "втором" положении. Как я знаю, встретил ли я цифру или нет? Если бы я встретил цифру, то ret был бы "правдой", так как только я встречаю цифру - я выставляю в него true, то есть: конвертация удалась.

В итоге, стринг "2 пробел 5" будет переведен как 2, а не как 25. Так как между этим стрингом и стрингом "2vasya5" нет никакой разницы.

Далее я проверяю не является ли символ знаком минус? Тут похожая логика: минус в середине числа не должен учитываться, то есть, стринг "23-567" должен быть переведенным как 23, а не как -23567. Однако, минус, поставленный в начале я запомню, чтобы сделать число негативным.

Если мы миновали эти два блока if, то мы однозначно смотрим на цифру в стринге. В нашем примере мы пришли к первой цифре и это "2". В первую очередь я выставляю true в переменную ret, так как стринг УЖЕ легальный. После, я получаю эту цифру и храню ее в переменной cur_ch. Далее мне нужно "перевести" ее из "2", написанное в ascii в реальную 2. Что я делаю? Я просто отнимаю от нее "0", написанный в ascii!

Взглянем на таблицу ascii. "0" - это 48, а "2" - это 50. То есть: 50 - 48 = 2 ))))

Почему я могу хранить результат в int? Я же раньше говорил, что char минус char будет char. НО! Почему так? Потому, что если мы пытаемся сохранить int в char, то будет проблема: int хранится в 2-х байтах или в 4-х, а вот char - меньше, ему достаточно одного. Поэтому, при переводе int в char есть опасность потерять информацию, однако - при переходе на оборот: char в int - такой опасности нет!

Отлично, далее я умножаю то, что было в num на 10. Сейчас - это лишнее действие, так как в num лежит ноль (помните, я выше говорил, что мне было очень важно обнулить num? Вот сейчас мы отчетливо видим причины этого), а потом прибавляю к num нашу цифру 2. В итоге в num сейчас лежит двойка.

Мы идем на новый шаг цикла! Так как следующий символ, на который мы смотрим - "3", то он проходит проверку для входа в блок. Он пропускает 2 первых if и попадает в код дальше. Выходит, что тут я совершаю лишнее действие и опять выставляю ret = true;, но так как подобные операции "дешевы" с точки зрения времени выполнения, то это не критично. Как и в прошлый раз, я получаю цифру, действием 51 - 48 = 3

Вот теперь становится более интересно! У нас в num лежит 2. НО! Так как за ней идет 3, то 2 - это не "единицы", это - "десятки" или больше! Я умножаю 2 на 10 и получаю 20, потом прибавляю 3 и получаю 23.

На следующем шаге, с цифрой "6" я умножу 23 на 10 и получу 230, потом прибавлю 6 и получу 236. Ну, а следующий символ уже остановит цикл, так как это символ '\0' и он не пройдет проверку для входа в блок.

Каков результат? У нас было число "-236" (отрицательное), но пока наш num равняется 236 (положительное). Но помните, что в блоке for, во втором if я запомнил: встречал ли я минус перед числом? Я положил "да, встречал" в переменную negative. Самое время это использовать! Я проверю переменную negative и если она - правда, то я сделаю положительное число отрицательным, умножив его на -1.

На этом работа закончена, функция вернет "правда", то есть - перевод удался и параметр num уже будет содержать нужное нам число!

Надеюсь, не взорвал вам мозг))) Ну, а если еще остались силы, все понятно и не надо попить чаю, чтобы остыть, то самое время браться за "вкусненькое"!



функция int_to_ascii

Как мы видим, я разделил работу функции на 2 основные части:
1. Обработка числа ноль
2. Обработка числа, отличного от нуля

С нулем все понятно: я ставлю на первое место символ "0", а на второе символ конца строки - '\0'.

Примечание: чтобы уж совсем по-хорошему, стоило возвращать из функции bool, на тот случай, чтобы вернуть false, если буфер не достаточного размера. Но я подумал об этом уже потом, когда успел написать задание. И поэтому, если есть такие читатели, кто выполняет все в режиме "реального времени", то есть сразу, как только я выкладываю задания, изменить условие было бы не честно. Когда мы будем использовать эту функцию, желающие смогут внести простые изменения, чтобы обезопасить себя.

Перейдем к случаю, когда я получил число, неравное нулю. Возьмем опять пример -236.

Я создаю стринг, который содержит цифры, совпадающие с номером ячейки. То есть, в нулевой ячейке лежит "0" (в ascii, так как это - стринг), в первой - "1" и так далее. Кроме этого, я создаю переменную, которая сохранит информацию "является ли число отрицательным" (negative) и переменную i, которая будет мне помогать как в циклах, так и вне их.

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

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

После я попадаю в цикл for. Мне нужно каким-то образом "вычленить" цифру из заданного числа. Как это можно сделать? Самый простой вариант, который пришел мне в голову - это сделать операцию "по модулю". Напомню что это такое (мы проходили):

Операция 58 по модулю 10 даст результат 8. Потому что операция возвращает ответ: чему равен остаток, при делении 58 на 10? 58 можно поделить 5 раз на целые 10 (то есть 50), а остаток будет равен 8, так как он на 10 целиком не делится. Ранее мы применяли операцию "по модулю" только когда хотели узнать: четное число или нет? То есть брали его по модулю 2.

Напомню, что число, которое мы взяли за пример: -236. На предыдущем шаге мы изменили ему знак и теперь оно равно: 236. То есть, 236 по модулю 10 даст мне цифру 6. Этот результат я использую как номер ячейки массива digits и получаю символ "6" уже в ascii!

Далее я ставлю проверку, является ли исходное число равным нулю? Пока что - эта проверка лишняя, так как мы пока только на первом шаге, а над нулем я поработал отдельно (теперь понятно, почему). Если бы это не было так, то тут цикл бы прервался и я бы не получил возможность обработать ноль.

После этого я делю 236 на 10 и получаю 23.6, а так, как результат хранится в int, то дробная часть: 0.6 - выбрасывается, то есть, num теперь равен 23. Теперь я просто сохраняю ранее полученное "6" в буфер, на нулевое место и захожу в цикл еще раз.

Получив похожим образом символ "3", я проверяю: является ли num равным нулю? Нет, он равен 23. Отлично. Делю, получаю 2.3, то есть 2, без дробной части. Запоминаю "3" в первом месте буфера и возвращаюсь в цикл с 2. Получаю символ "2", проверяю, что 2 не равно нулю и делю на 10. Мое число теперь равно 0.2, то есть - 0. Я сохраняю "2" во второй ячейке буфера, а при следующем заходе, во время проверки if ( num <= 0 ), я покину цикл.

Далее, если число было отрицательным, то я ставлю знак "минус" в последнюю ячейку. Обратите внимание на трюк! Я делаю buf [ i++ ], то есть: "верни мне ячейку из buf, равную i (по номеру ячейки), а после этого увеличь i на один. Если бы я написал buf [ ++i ], то результат был бы другой. Думаю, что все помнят причины этого.

В конце, я ставлю знак "конец строки".

Что мы имеем? У нас было число: -236, но в нашем буфере лежит его "зеркальное отражение", то есть: "632-". Вывод: нам осталось только перевернуть стринг! Этим я и займусь в следующем цикле.

Для этого, я объявляю дополнительную переменную, которая должна указывать на конец строки. Если i сейчас равен 4 и указывает на '\0', то мне нужно положить в переменную num_size 3, чтобы указывать на "-". После этого я обнулю i и он станет указателем на нулевую ячейку, то есть на "6".

Смысл такой: я буду менять местами первую и последнюю цифру, все время двигая свои "указатели" на встречу друг другу. И когда num_size станет меньше, чем i, я буду знать, что "указатели" встретились и работа закончена.

На первом шаге i равен 0 и указывает на "6", num_size равен 3 и указывает на "-". Поменяем их местами!

Я создаю дополнительную переменную tmp, в которую кладу "6", а на место "6", кладу знак "-". Теперь наш буфер выглядит так: "-32-". Самое время положить на первоначальное место знака "-" символ "6" из переменной tmp. Такой трюк называется "свопинг" (англ. "swap"). Результат: "-326".

Увеличим i и уменьшим num_size. Теперь i равен 1 и указывает на "3", num_size равен 2 и указывает на "2". Поменяем и их местами! После выполнения процедуры свопинга, наша строка выглядит так: "-236", то есть: мы добились результата! Поздравляю!

Увеличим i и уменьшим num_size. Теперь i равен 2, а num_size равен 1, то есть - цикл закончился!

Примечание: Если число было бы с нечетным количеством символов, то на последнем этапе i и num_size были бы равны и как результат мы бы поменяли символ "сам с собой", то есть - ничего бы не испортили. Но, это конечно лишнее действие и я только потом это заметил, но уже не стал менять, так как это дешевое и некритичное упущение.



Послесловие:

Это было тяжелым заданием и скорее всего - подавляющее большинство не справилось, НО! Это - не беда! Мы только учимся. Если вы пробовали и думали над проблемой, то вы уже сделали половину пути! Теперь, видя пример, нужно поступить так: нужно ОСНОВАТЕЛЬНО разобраться в решении, предложенным мною и постараться потом "по памяти" переписать это задание к себе.

Если вы смогли это сделать - вы поняли решение и в следующий раз вы сможете решить подобную задачу. Кроме того, поняв мое решение вы научились многим полезным трюкам, а значит - стали лучше уметь программировать! Неудачи не должны выбивать из колеи: на них учатся! Посветите разбору решения еще нужное количество времени и можно переходить к новому материалу. Удачи!

лекция

Существует надобность создавать переменные в куче. Мы рассмотрим один такой случай, но для начала я напомню, что мы говорили про стек и кучу, (глава 6, Память) и там я пообещал, что научу этому позже. До этого момента, все переменные, которые мы создавали - были созданы в стеке.

Немного теории. Переменная, которую надо создать в куче, создают, используя указатель на нее и делают это через оператор new:

int * p = new int;

Я создал переменную в куче. Я как бы "занял" память у операционной системы "в долг". Как известно, долги нужно отдавать, поэтому, когда переменная мне уже не нужна, я должен сказать операционной системе: "вот, спасибо за переменную, я ею пользовался, но больше мне не нужно, забери себе". Делаю я это операцией delete:

delete p;


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

Точно также, мы можем создать массив:

int * arr = new int [ 15 ];

а вернуть системе (далее я буду употреблять слово "удалить", либо слово "освободить") нужно так:

delete [ ] n;

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

Примечание:Помните, мы говорили, что нельзя создать массив так:

int n = 0; // создал переменную, в которую я получу размер массива
cin >> n; // получил размер
int arr [ n ] ; //не будет работать, так как в скобках должна быть константа!

Но здесь этого ограничения не существует! Поэтому, мы вдруг получаем возможность создавать массивы, у которых мы заранее не знаем размеров!

int n = 0; // создал переменную, в которую я получу размер массива
cin >> n; // получил размер
int * arr = new int [ n ]; // Сработает!


ВАЖНО: Если программист занимает память, то он ОБЯЗАН вернуть ее, когда она ему уже будет не нужна!


Давайте посмотрим маленький примерчик:






Окей, в принципе, все пояснения написаны в коде и добавить к этому мало что можно. Но все же:

1. процесс заема памяти в куче называется "Динамическая аллокация памяти".

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

3. В моем коде есть пару "трюков", один из которых - пустой for.
если подумать, то переменная ret используется в двух целях: считает буквы и "бежит" по массиву и дополнительный код просто не нужен. Но! Такой for - нетипичен, поэтому у программера, читающего код, либо у вас, через полгода, может возникнуть столбняк))) я предпочитаю комментировать такой код, чтобы ускорить понимание этого места.


Примечание: Существует готовая функция, которая считает количество букв в стринге. Я написал свою только ради того, чтобы напомнить еще раз как строится стринг. Однако, нет никакой необходимости так делать на самом деле. Если существуют готовые функции - пользуйтесь ими! Это значительно уменьшает количество кода, а так же ускоряет понимание программы! Вашу функцию никто не знает, а готовая - всем известна, плюс ко всему - в вашей могут быть баги, а готовая существует уже не одно десятилетие, поэтому все баги там уже исправлены)))

Эта функция называется strlen. Для ее использования нужно подключить библиотеку string.h, то есть:

#include <iostream>
#include <string.h> // подключили библиотеку string.h, где описана функция strlen
using namespace std;

int main (void) {

int str_size = 0;
char * str = NULL;

str = get_str(); // получили стринг (неважно откуда)
str_size = strlen(str); // получили размер стринга через стандартную функцию strlen

return 0;
}

Единственный минус: если указатель, который мы передадим указывает на NULL, то программа упадет. Дело в том, что стандартные функции были написаны так, чтобы занимать наименьшее количество времени. А так, как это еще и старая функция, когда мощность компьютеров была минимальной, экономили даже на проверках, сегодня концепция поменялась, поэтому мы, в своих функциях, проверяем указатели. А значит, если вы пользуетесь функцией strlen, вы либо уверены на миллион процентов, что указатель НЕ нулевой, либо, ставите проверку на вызове: if (str)

ВАЖНОЕ примечание:
когда программист пишет delete, операционная система освобождает память, НО! Она не обнуляет указатель! что это значит? Это значит, что он теперь указывает на "мусор" и поэтому при проверке if ( p == NULL ), где р - указатель, который освободили, программа ответит "нет", мы полезем к указателю и свалимся! Вывод? Если ваш указатель освобождается не в самом конце области его видимости, то следующая строка, которую ОЧЕНЬ желательно написать, выглядит так: p = NULL;

Примечание: если забывать освобождать память, то может возникнуть ситуация, при которой память, которую может вам выделить операционная система - закончится. В этом случае, при попытке аллокировать новый кусок памяти - операционная система убьет программу. Будьте ОЧЕНЬ внимательны!

Ошибка программиста, при которой в программе не освобождается память, называется "Утечка памяти" (англ. "memory leak"). Иногда - чрезвычайно сложно найти такое место в коде, где происходит утечка! Лучше - быть внимательным и не допускать такой ситуации.

Про программу, в которой есть утечка памяти, говорят: "программа течет". Лично я очень строго отношусь к программе, которая течет, я считаю такую программу не работающей, даже, если она выполняет свои функции.


Эта лекция не была очень длинной, но она была ОЧЕНЬ важной! Мы будем часто использовать динамическую аллокацию в будущем, поэтому, отнеситесь к этому серьезно.

Домашнее задание

Напишите программу, которая получает от пользователя 2 параметра:
1. стартовое число
2. количество чисел

Программа сохранит ряд чисел, начиная со стартового, а если количество чисел равно нулю, то программа напишет "Нечего делать" и выйдет. Предположите, что пользователь ввел правильное число, то есть не нужно проверять, не выходит ли число за рамки, установленные размером типа int

Пример:

1. Пользователь ввел:
стартовое число == 12
количество чисел == 3

Программа сохранит такие числа: 12, 13, 14

2. Пользователь ввел:
стартовое число == -2
количество чисел == 5

Программа сохранит такие числа: -2, -1, 0, 1, 2

В конце можно распечатать сохраненные числа, чтобы убедиться, что все сделано правильно.

Удачи!

@темы: C++

---

История одной прекрасной любви.

Среди фанатов Богини очень популярна тема "Как я стал фанатом Бритни Спирс". Некоторые подумают, что это по-привычке, мол привыкли же в школе, почти каждый год, писать сочинение на тему "Как я провел лето", но мне кажется, что это просто желание поделиться светлым и ярким чувством. Рассказать о том внезапном чуде, которое однажды осветило твою жизнь.

Я долго не хотел это писать, может потому, что не хочется быть "как все" (тупое желание, но им больны почти все), а может потому что в этой истории есть что-то очень личное.... но так как меня периодически спрашивают об этом - я сдался и вот, собственно, пишу)))


Одним солнечным майским днем (в Израиле все майские дни - солнечные), я пришел к своему другу в гости. Я не помню точное число, да и важно ли это? Я лишь помню, что календарь меня уверял, что сегодня 2009 год, суббота.

Мой друг встретил меня в прекрасном настроении и бутылочкой пивка, сообщив, что недавно он купил новый телевизор. Это был один из последних, на тот момент, телевизоров LCD, марки Samsung, довольно больших размеров. Естественно, устроившись по-удобней, мы решили вместе обсудить качество изображения, его яркие краски и прочие тех. подробности. Для этой цели нужна была яркая и качественная картинка, поэтому мы не задумываясь врубили канал MTV.

Мы довольно живо беседовали, обсуждая все эти параметры, бегали из угла в угол, чтобы получить полное представление о его преимуществе, и когда анализ уже был почти сделан, начался очередной клип. На черном фоне появилась надпись "Britney Spears", а сразу после этого нам показали прекрасную девушку, которая, совершенно обнаженная, лежит в сауне....

Нельзя сказать, что я до этого не слышал ничего о Бритни. Для этого нужно было быть либо глухим, либо жить в Северной Корее. Конечно же, в далеком 1999 году, когда хит "...Baby, One More Time" орал из каждого чайника, я уже был знаком с ней. Все дело было во мне: я был ярым поклонником "настоящей" музыки. Я всю свою жизнь любил музыку. Это началось еще с первого класса, когда я впервые услышал Высоцкого.

Скорее всего, это было влияние отца. Он всегда был моим беспрекословным авторитетом и примером для подражания. Но чуть позже я увлекся "неформальным" движением и мир получил нового панка, который яро фанател от Гражданской Обороны, отращивал эрокез и даже играл на бас-гитаре в дворовой группе со смешным названием "Не дали выпить". Поп-музыка или "попса" - это "не настоящая музыка" - утверждал я. "Там нет души, одна коммерция". Это было глупое мнение подростка-максималиста, которому в голову не приходило, что коммерция, в принципе, есть везде...

Далее меня мотало по музыкальным направлениям. Какое-то время я обожал блюзы, потом - очень тяжелый металл. Было время, что я увлекался классической музыкой, довольно сильно любил итальянцев, из которых предпочтение отдавал Паганини....

С того самого момента, когда появилась Бритни Спирс - мое отношение было к ней резко негативным. Сейчас, конечно, в это вряд ли кто поверит, но тогда... она была олицетворением самого ненавистного направления в музыке - попса! Ну, а так как она, для меня, была СИМВОЛОМ попсы, то естественно, вызывала наибольшую ненависть, с силой которой могла сравнится только ненависть к Майклу Джексону. Я вспоминаю это сейчас и такое ощущение, словно это было не со мной.....

Хотя, положа руку на сердце, я не могу сказать, что эта ненависть была заслуженной. Она была ПРИНЦИПИАЛЬНОЙ. Это можно сравнить с чувством солдата, ненавидящего другого, такого же солдата из вражеской армии, хотя, этот, конкретный парень, одетый в другую форму, возможно, ничего плохого ему лично не сделал...

Бритни меня преследовала постоянно! Услышу новую песню и сердце рапортует: "О, классная песня"... "а кто это поет" - спрашиваю я у людей. Ответ, словно приговор: "Ты что, это же Бритни Спирс!". "Жуть!" - орет мозг: "тебе уже нравится Бритни Спирс??? Ты что, офонарел? Где твои принципы? Только настоящая музыка может нравится....". Это было моей клеткой. Клеткой, которую я САМ выстроил и САМ себя в нее запер. Даже наедине, когда вокруг никого не было, мне было стыдно, что меня так заводит "Toxic" или "I Love Rock'n'roll"... да, именно стыдно!

Если по телевизору шел клип, то я спешил его выключить, потому что я боялся того, что он мне нравится... из-за этого - я ненавидел Бритни еще больше! Это имя вызывало во мне бурю негодования, по сравнению с которой ненависть папы Римского к сатанинской секте - прекрасное и светлое чувство.... вот так это и продолжалось, годами. Я сидел в собственной клетке принципов, яро доказывая всем, что моя клетка - это истина, а все остальное - от лукавого....


.... и вот, мы сидим, смотрим в новый телевизор моего друга.... начинает играть заводная музыка, резкая и ранящая..... появляется девушка в сауне......
Я даже не понял, что произошло... но я "влип" в этот телевизор, а вокруг меня все замерло. Было ощущение, что остановилось время, а на экране начался ураган! Вот она, дерзкая, яркая, прекрасная, беспощадная! Она ворвалась в мой мозг и это НЕВОЗМОЖНО было остановить! Она ворвалась и начала там все ломать и крушить! Мои клетки, которые я считал довольно крепкими, просто разлетались в пыль, а каждый новый кадр, каждая нота, каждое слово, спетое этим сладким, ангельским голосом - ранили в самое сердце!

Восторг перемешивался с паникой и я потерял ощущение времени, реальности и дар речи.....

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

Я не мог описать то чувство, которое я испытывал. С одной стороны донимал привычный стыд за собственную слабость, но он уже был сравним с тем стыдом, который одолевает ребенка, делающего то, что строго-настрого запрещает его мама и испытывает от этого невероятный кайф! Я целый день прислушивался к себе и целый день мечтал посмотреть ЭТО еще раз, но так как мне было еще пока очень стыдно, то я не сделал этого дома.

На следующий день я пришел на работу (воскресение в Израиле - рабочий день, начало недели). Первое, что я сделал - я полез в ютуб и в строке поиска, дрожащими руками, набрал то, о чем я мечтал целый вчерашний день: "Britney Spears Womanizer". Стоит ли говорить, что 2 или 3 дня я абсолютно не работал? Я наверстывал упущенное! Я смотрел ВСЕ ее клипы подряд! Я смотрел выступления, я смотрел передачи, концерты! Я читал о ней всю информацию, что только мог найти и все подряд качал! Я ОЧЕНЬ жадно все это глотал! Я понял, что влюбился, я понял, что влюбился уже давно, но сейчас я признался себе, наконец, в этом! Я просто не мог уже сдерживать это чувство! Мне хотелось орать от восторга, но меня расстраивало, что скорее всего, мой начальник это не поймет)))

Я благодарен Бритни, что она появилась в моей жизни. Без преувеличения, могу сказать, что она круто ее изменила, меня изменила! Она разрушила мои клетки и разогнала тучи над головой и теперь мне дышится очень легко, я смотрю на синее небо над головой и понимаю, что теперь я свободен! Я вынес из всего этого очень полезный урок: никогда нельзя запирать себя принципами и допускать вранья самому себе. Нужно слушать свое сердце и делать то, что оно подсказывает. Я стал добрым, веселым, независимым и открытым человеком, я стал собой! В моей жизни произошла великая революция и на флаге, который я поднял на руинах собственной глупости, написано светлое имя: "Бритни Спирс"!

@темы: Britney Spears

---

Учимся программировать на С++. Лекция 13. Закрываем пробелы

Привет!

решение домашнего задания с предыдущей лекции

Условие:

Напишите программу, которая просит у пользователя 5 чисел, от 1 до 50.
После того, как пользователь введет эти 5 чисел, высветите на экран меню, в котором будут такие возможности:
если пользователь ввел 1 - программа распечатывает весь массив
если пользователь ввел 2 - распечатывает минимальное из введенных им чисел
если пользователь ввел 3 - сумму всех чисел.

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

Удачи!

решение

Код:









Примечания:

1. Я объявил 2 переменные min и sum. Таким образом я "оптимизировал" работу программы. Так как массив задается только один раз, а спросить сумму или минимальное число можно бесконечное количество раз, то глупо высчитывать это каждый раз заново. Поэтому, программа посчитает эти значения только при первом запросе и сохранит результат. При следующем подобном запросе, она покажет уже ранее посчитанный результат. Привыкайте искать места в программе, которые потенциально ускорят ее выполнение. Это - умный подход к задаче, а значит - хорошее программирование.

2. Функция get_input_from_user написана с использованием бесконечного цикла для того, чтобы показать инструкцию break. В реальной задаче я бы написал ее так, как написал на одной из лекций. Но! Это тоже решение, оно тоже работает и я не вижу минусов в таком решении, оно - вполне легитимное.

3. В функции main, блок switch-case: присутствует пустой case (на ноль). Если бы я не написал его, то код, получив ноль - попал бы в default и отработал как "ошибочный ввод", а это - баг, так как ноль - легитимный выбор и он означает конец работы.

4. Во всех функциях, которые получают указатель - присутствует проверка на NULL. Это - правильный подход.

лекция

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

Инструкция typedef

Я когда-то говорил, что в С++ есть возможность определить собственные типы. Есть несколько способов это сделать и они зависят от сложности типа, который мы определяем. Самый простой вариант - инструкция typedef. Эта инструкция позволяет "обучить" компилятор новому типу, который, на самом деле, новым не является. Мы просто даем типу новое имя. В С эта инструкция имела более широкое применение, однако, на мой взгляд, многое было лишним. Как видно, не я один так считал, потому что в С++ исчезла надобность пользоваться этой инструкцией в ряде случаев.

На сегодняшний день, в С++ она используется, в основном для удобства. Приведу пример. Допустим, в коде нам нужно использовать тип unsigned short int, однако, каждый раз писать такое длинное словосочетание - лень. Можно прибегнуть к трюку и в начале текста, сразу после фразы using namespace std; написать следующее:

typedef unsigned short int USHORT;

теперь, везде по коду, где нам необходимо было объявить:

unsigned short int a = 0;

можно написать:

USHORT a = 0;

И компилятор будет знать, что именно мы объявили. Мы как бы "обучили" его новому типу. Но это же, конечно, не единственное применение. Часто, такой прием применяется, когда программист пользуется более сложными типами переменных, чем эти. Такие типы умеют хранить в себе огромное количество данных и по названию типа невозможно однозначно сказать, что он хранит. И вот тогда, инструкция typedef очень сильно помогает! Программист просто переименовывает тип, чтобы его применение было более понятным.

Но, изучение таких типов будет не сегодня. Сегодня мы поговорим о другом его применении, где без typedef было бы сложнее обойтись.

Указатель на функцию

Я долго думал, давать ли этот материал здесь, потому что, чтобы ощутить всю мощь этого трюка, у нас пока не хватает знаний (правда уже немного осталось до этого светлого момента, но все же...) Так вот, возможно, пример, который я покажу, будет выглядеть сильно наивным и будет непонятно, зачем этот трюк, НО! когда мы подойдем к месту, где этот трюк обычно применяют, я не хочу там рассказывать теорию этого, так как и так будет достаточно, что показать.

Но начну я не с примера, а с теории. Точно также, как можно создать переменную, а потом создать указатель на нее, так же можно описать функцию, и присвоить ее указателю на подобный тип. Но в этом случае, все не так однозначно. Почему? Потому что, указатель на переменную должен совпадать, в определенном смысле, с типом переменной.... а есть ли типы в функциях? Да, есть. Чем отличается функция одного типа, от функции другого типа? Они отличаются параметрами, которые принимает и возвращает функция. Правда только в теории это сложно объяснить, поэтому я напишу пример и мы его разберем.


Код:




Результаты 3-х разных запусков:




Ну что, начнем разбирать? Помолясь приступим)))

Итак, для начала, обратите внимание, что я объявил 3 функции, которые описал ниже main: foo1, foo2 и foo3. Как мы видим они не сильно отличаются своей имплементацией, но это лишь для яркости примера, чтобы не распылять внимание на ненужные детали.

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

Как мы видим, foo1, foo2 и foo3 - обладают такой схожестью.

Окей, пойдем далее. Я пишу слово typedef, которое как бы "говорит" компилятору: "я создаю новый тип, выучи его". После слова typedef я пишу параметр, который функции возвращают, потом в скобках я пишу звездочку, что означает "указатель", после звездочки - я пишу имя нового ТИПА, а потом, в других скобках - параметры, которые функции принимают.

Для примера: если бы я написал

typedef float (*NAME) (char a, bool b);

это означало бы, что указатель типа NAME способен указывать на такие функции:

float foo (char a, bool b);
float bar (char c, bool d);

Взглянем на строку в коде, возле которой стоит комментарий "объявление указателя на функцию". Как мы видим, я создал переменную. Ее тип FUNC, ее имя - func. В начале я присвоил ей NULL (обнулил указатель). После, я присвою ей одну из функций, в зависимости от желания пользователя. Эта переменная может содержать адрес любой функции, которая совпадает по типу. Далее, я вызову функцию через этот указатель. Все остальное в этом коде нам уже понятно, поэтому - нет смысла разбирать. Остановитесь на примере, чтобы убедиться, что все абсолютно ясно.

Примечание: Необязательно писать так:

typedef void (*FUNC)(int num);

можно так:

typedef void (*FUNC)(int); // без имени переменной num

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


Примечание: Объявить указатель на функцию без трюка с typedef можно. Тогда строка:

FUNC func = NULL;

выглядела бы так:

void (*func)(int) = NULL;

Все остальное - без изменений.

Перепишите код и скомпилируйте, чтобы во всем лично убедиться.

Команды пре-процессора или "макросы"

В начале - теория. Прежде, чем компилятор начинает компилировать код в единицы и нули, в дело вступает процесс, который называется "пре-процессор". Он редактирует код в зависимости от наших нужд и распоряжений.

Представьте себе такую ситуацию: приходит заказчик и объясняет задачу. Вы приходите к выводу, что в этой задаче вам нужен массив, размером 15 ячеек. Отлично, говорите вы... пишете очень много кода, а ваш массив, как известно, передаете в функции так: указатель и его размер. И вот вы с радостью, через месяц, приносите готовый проект, а заказчик и говорит: "задачка немного поменялась.... но совсем чуть-чуть, не серьезно...." и в процессе объяснения, вы понимаете, что массива в 15 ячеек не хватит, нужно 18....

Для заказчика - это "дешевое" изменение, а для вас? Идите, пройдитесь по всем местам в коде, где вы написали "15" и поменяйте на "18"..... уф.... а с другой стороны, вы не можете объявить массив, используя глобальную переменную (не константу), так как это нельзя делать по стандартам языка.... как быть?

На помощь приходит макро. Вы, используя команду для препроцессора, говорите: "везде, где я напишу слово SIZE, в коде, поменяй это на 15". То есть пишете 15 только ОДИН раз, а везде, где этот размер нужен, пишете "SIZE". И тогда, когда заказчик говорит "поменяй на 18" - вы меняете ТОЛЬКО в одном месте! В остальных это произойдет автоматом! Идея ясна?

Поговорим о синтаксисе. Макро начинается с символа "решетка" - "#" то есть:

#define SIZE 15

int main() {

int arr [ SIZE ] = {0};

// код ....

foo(arr, SIZE); // вызов функции, принимающей массив и его размер

return 0;
}


void foo ( int * arr, int size_of_arr ){
// код
}

Итак... препроцессор, начав свою работу ДО компилятора, проходит по тексту и ВЕЗДЕ, где он видит текст "SIZE" меняет этот текст на "15". В итоге, когда компилятор приступает к работе - текст уже поменян и ему не нужно ломать голову, что такое "SIZE".

Примечание: в конце макро-комманд НЕ ставится точка с запятой! К макро-комманде относится ВСЯ строчка, написанная после символа "решетка". Если программисту, для удобства чтения нужно перенести строку (макросы бывают длинными), то в конце строки ставится знак \ (обратный слеш или бек-слеш). Это как бы говорит пре-процессору: "строка не закончилась, я лишь продолжаю ее с новой строки, чтобы было удобно читать".

Примечание: принято при определении константы через #define, писать ее имя большими буквами. Это правила хорошего тона. Объяснение простое: когда программер видит, что в функцию передается SIZE, то он понимает, что это не переменная, определенная в блоке, а глобальная константа, определенная, к примеру, через #define. Естественно, что глобальную константу можно определить через const int SIZE = 15;, вынеся ее из блоков. То есть написав ее НЕ в какой-либо функции или блоке. (про глобальные переменные и область видимости говорилось ранее). При таком определении, обычно, тоже пишут имя большими буквами.

На самом деле, с помощью макро-команд можно писать программы! Но мы сейчас не будем рассматривать все возможности этой прикольной штуки, потому что в этом нет большой необходимости. Однако, я все же обращу внимание на один факт. Мы все хорошо помним, что программы на С++, которые мы писали до сих пор, начинаются со строки:

#include <iostream>

Как мы теперь уже поняли, это - макро-комманда. Что же она означает? Слово, после решетки, означает "добавь". То есть написано: добавь какой-то iostream. iostream - это файл (назовем это пока так), в котором написан код. То есть где-то, на компьютере лежит файл, который называется iostream. В нем имплементированы разные функции. Зачем это сделано?

Ну, есть ряд функций, которые нам нужны практически в любой программе. Например: функция, которая пишет на экран (cout) или функция, которая принимает с клавиатуры (cin). Две эти конкретные функции работают немного не привычно пока для нас.... мы ведь как привыкли видеть вызов функции? Вот так:

cout ( "Hello World") ;

а вот эта работает так:

cout << "Hello World" ;

НО! Хочу сразу уточнить.... это просто так совпало, что эти конкретные функции, из-за которых мы добавляем iostream, такие "необычные". Просто совпадение.... там вполне могут быть и "обычные" функции. И они там есть! В iostream много интересных функций, кроме этих двух, просто они пока не были нам нужны)))

Итак, что же происходит, когда препроцессор встречает инструкцию #include <iostream> ? А происходит следующее: он идет туда, где этот файл лежит (он знает дорогу), берет от туда ВЕСЬ текст, ВСЕ функции, что там есть и ПЕРЕПИСЫВАЕТ эти функции в наш код, вместо команды #include <iostream> . То есть, до того, как начинает работать компилятор, у него эти функции переписаны ВЫШЕ нашего кода, а значит, встретив в нашем коде:

cout << "Hello World" ;

он уже знает, что это такое.


Скажу вам больше: мы скоро будем писать наши программы в нескольких текстовых файлах, подключая через команду #include один к другому. Это все впереди! Только свои мы будем брать в кавычки, а те, что взяты в треугольные скобки - "стандартные". То есть:

#include <name>// подключили стандартный набор функций

#include "name" // подключили написанный нами набор функций

Такой набор функций (стандартный или собственный) называют "библиотека". Советуя написать #include <iostream> - говорят: "подключи библиотеку iostream"

Еще немного об области видимости переменной

Давайте посмотрим на код и на результат выполнения программы:


Код:




Результат:




Отличненько))) Видите ли вы то, что вижу я? Мы создали переменную n и положили туда 5. Потом, мы вызвали функцию, в которую это n передали, и изменили ее значение. Однако, возвратившись из функции мы вдруг обнаруживаем, что изменение не произошло. Я специально везде распечатываю значение n, чтобы это было наглядно видно.

Как объяснить этот феномен? Нужно подробно рассмотреть, что же произошло на самом деле. Итак, когда мы написали:

int n = 5;

В памяти создалась ячейка и в нее положили 5. Это все понятно. Что произошло, когда мы положили это в функцию? Произошло следующее: создалась ДРУГАЯ ячейка, которую мы видим ТОЛЬКО в функции и которая по завершению блока функции - умрет. В эту другую ячейку мы СКОПИРОВАЛИ ЗНАЧЕНИЕ из первой.

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

Как быть, если в функции нужно поменять значение переменной так, чтобы оно вернулось в main? Ну, самый естественный подход, это изменить код так:


Код:




Результат:



Мы просто вернем новое значение из функции, через инструкцию return (при этом не забыв поменять описание функции - она теперь возвращает int), и присвоим ее значение - первой переменной. Однако, у этого способа есть 2 минуса:

1. Как все уже поняли из функции можно вернуть не более ОДНОЙ переменной. А если нужно изменить и вернуть 2? 3? и так далее....

2. Что произошло? Мы скопировали значение 2 раза. Когда мы работаем с примитивными типами - это не страшно, они занимают считанные биты и процедура происходит быстро. НО! Скоро мы научимся создавать свои типы, а "свой" тип может "весить" НАМНОГО больше. И что же? Мы будем все это копировать туда-сюда? Это замедляет работу программы!

Примечание:Представьте ситуацию, когда вам нужно вернуть строку из функции. Если вы сделаете так:

int main(){

char * p = NULL;

//код

p = foo(); //вызов функции
cout << p << endl; //распечатка строки на экран

//код

return 0;
}

char * foo(void){
char str = "vasya";
return str;

}

программе нужно получить строку из функции. Мы объявляем указатель на char (то есть - потенциальный стринг) и принимаем то, что даст нам функция на выходе. Как только мы полезем на следующей строке распечатывать полученную строку: программа с большой вероятность - грохнется. Почему?

Что мы написали? Мы объявили стринг, который по всем законам будет жить, пока код не покинет блок. Выйдя из функции, операционная система уничтожит все буквы, которые он содержал и ВОЗМОЖНО займет это место чем-нибудь другим, а в return, то есть в указатель на место, вернет адрес первой ячейки, которая, возможно, Уже строкой не является, то есть: УЖЕ нет строки!

Мы ведь возвращаем адрес!

Поэтому поступают так:

int main(){

char * p = NULL;

//код

p = foo(p); //вызов функции
cout << p << endl; //распечатка строки на экран

//код

return 0;
}

char * foo(char * p){
//тут, пока не известным нам образом получают строку в p, и возвращают назад. и таким образом,
//операционная не убивает эту строку.
return р;

}


Примечание: обычно, если функция возвращает примитивную переменную, и нет больше кандидатов на ее место как, например, в функции "get_min()", то применяют такой способ, как я показал выше, но бывают ситуации, когда нужно получить из функции несколько параметров... о том, как обойти это ограничение - далее.



Какой выход? Как обойти эти 2 минуса? Может быть самое время вспомнить про указатели?


Код:




Результат:




Давайте вместе скажем: "ух ты! работает!" Да, работает. Но почему? Проведем анализ?
Итак, у нас есть переменная n и у нее есть адрес. В момент, когда мы попали в функцию, создалась переменная типа "указатель на int". В нее мы положили адрес n (обратите внимание, на вызов функции, а именно - как я передаю переменную).

Примечание: так как функция принимает указатель, стоит проверить, не указывает ли он на NULL, дабы избежать крушения программы. Я написал это так: if ( !p ) NULL - это ноль. Если р указывает на ноль, то if ( p ) будет ложной и код не попадет в блок if НО! Это значит что "не р" - правда (если р - ложь, то не р - правда, помним, да?) А значит, что если р указывает на ноль, то в блоке if ( !p ) - код выполнится, так как !р - правда.

После этого я обращаюсь к указателю через звездочку, то есть, я обращаюсь не к указателю, а к ячейке памяти, на которую он указывает, другими словами, я написал: "положи в ячейку памяти, на которую указывает р, значение 7" Программа обращается к р, смотрит куда он указывает, лезет по этому адресу (который является адресом переменной n, объявленной в main) и туда кладет значение. То есть - меняет значение нашей "первой переменной" напрямую, по адресу.

Примечание: если в функцию передать массив и там его изменить, то изменения отразятся на "настоящем" массиве. Потому что передача массива происходит через указатель!

Если что-то непонятно - перечитайте с начала главы. Это ОЧЕНЬ важно понять! Если понятно - я продолжу)))

Ссылки

Наравне с типом переменных "указатель" существует еще один тип, способный хранить адрес. Этот тип называется "ссылка" (англ. "reference"). В С такого типа не было, но за время существования языка С стали понятны минусы указателей:

1. Работа с ними потенциально опасна, так как указатель может указывать на ноль и нужно все время его проверять

2. Предположим, что мы поменяли функцию из foo (int n) на foo(int * n), чтобы работать напрямую с переменной, которую я обозвал "первой". Это значит, что не достаточно поменять только "заглавие" функции, потому что потом надо пройти по коду и везде, где написано что-то типа n = 7; написать *n = 7; (добавить звездочку)

Поэтому в С++ создали еще один тип, "лечащий" оба этих недуга. Объявляется ссылка так:

int n = 5; // создали переменную

int & r = n; // создали ссылку, присвоив адрес

Теперь, везде в коде, где мы будем писать:

r = 7;

мы будем менять значение n

То есть: нам не нужно дописывать звездочку! Более того: ссылка НЕ МОЖЕТ указывать на ноль! Мы получили тип обладающий всеми преимуществами переменных и указателей! С одной стороны она имеет свойство указателя: работает "напрямую" с переменной, а не с ее копией. НО - она безопасна. С другой стороны мы обращаемся к ней так же, как и к переменной, без дополнительного "геммороя" со звездочками.

Примечание: присвоить адрес переменной, в ссылке, можно только один раз! И ТОЛЬКО в момент ее создания!

Код, который я приводил выше, можно написать, оперируя новым типом "ссылка":


Код:




Результат:




Оки. Пока - достаточно)))

Сегодня мы выучили много вещей:

1. Мы выучили инструкцию typedef, через которую можно объявлять собственный тип. Пока что - это "не по-настоящему" свой, а только "эмуляция", но такой трюк тоже иногда нужен, как правило, для удобства чтения.

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

3. Мы узнали что такое пре-процессор и как им командовать.

4. Мы узнали несколько трюков в работе с функциями

5. Выучили новый тип - "ссылка" и рассмотрели его преимущества.

Домашнее задание

Напишите 2 функции:

1. функция:

bool ascii_to_int (char * num_str, int & num);

Принимает стринг, в котором написано число и переводит его в тип "целое число" (int). Ответ "возвращается" через параметр num, а функция возвращает bool (правда - если перевод удался, ложь - если полученный стринг не является числом)

Примечание:
стринг "vasya123" - функция НЕ переведет в число, потому что стринг НЕ начинается с чисел (вернется ложь)
стринг "123vasya58" - функция переведет в число 123 и функция вернет "правда". (остаток "vasya58" - будет игнорирован)
стринг " 54" (с пробелами впереди) - будет успешно переведен в число 54

проверьте работу функции на следующих стрингах:
1. "-57" - удачно
2. "348str236" - удачно
3. "@12" - не удачно
4. "c++" - не удачно
5. " -238" - (с пробелами впереди) удачно


2. функция:

void int_to_ascii (int num, char * buf, unsigned int buf_len);

Принимает целое число через параметр num. Переводит его в стринг и ответ кладет в буфер buf.

Проверьте работу функции на числах:
1. -578
2. 33
3. 0

Совет: сохраните эти функции, возможно далее мы будем их использовать. В С++ есть готовые функции, выполняющие подобную работу, но "на всем готовеньком" жить скучно)))) Обещаю, что в последствии мы рассмотрим эти готовые функции!

Удачи!

@темы: C++

---

Учимся программировать на С++. Лекция 12. Функции

решение домашнего задания с предыдущей лекции

Условие:

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

Запустите программу с фразой "I LiKe C++"

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

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

Для крутых:
Если вы считаете, что абсолютно поняли не только этот материал, но и все предыдущие, то напишите цикл подсчета так, чтобы вместо "шагающей переменной" i был использован указатель на char. Это задание на 5+ ))))

решение

Простой код:




Код "для крутых":




Результат:




Примечания:

1. Если у вас получился другой результат, но вы это заметили еще в процессе теста программы, до того, как увидели мой вариант - это довольно неплохо, потому, что это означает, что вы проверяете работу программы, а это - залог успеха. У вас просто баг: вы посчитали пробелы и значок "плюс" в пользу одного из типа букв.

2. Если у вас получился другой результат, но вы даже не обратили на это внимание, пока не прочли эти строки - это ОЧЕНЬ плохо, так как не проверять собственную программу - грубейшее упущение, которое, если вы будете программистом, будет больно вас бить по ушам, пока вы не научитесь этому простому правилу.

3. И, наконец, САМЫЙ печальный результат, это если вы написали ваш цикл так:

for ( int i=0; i < 10; i++)

а вот это 10 вы просто высчитали из конкретной строки. Это ОЧЕНЬ плохо! Такое решение просто нельзя допускать! Вы написали программу, которая работает с КОНКРЕТНОЙ строкой, а это НИКОГДА не может быть, не то что "хорошим"... это не может быть "хоть малость приемлемым" решением! Не повторяйте такую ошибку никогда! Программирование - эта та профессия, в которой нужно включать голову, а не работать на автомате!

4. Второй код я определил, как "код для крутых". Это вовсе не означает, что таким образом передвигаться по массиву круче, чем первым способом. Я стараюсь избегать такой способ, потому что игры с указателями - потенциально опасное место. Я назвал этот способ так, потому что если вы додумались до него - это означает, что то, что я рассказывал до сих пор - прочно сидит в голове, а это - шикарно! У вас прекрасный потенциал!

лекция

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

Вы спросите: "а чем мы занимались до сих пор?" Отвечу: до сих пор мы учили азбуку и наши программы - это как первые ложки фруктового пюре, которое дают полугодичному ребенку, чтобы он просто почувствовал разные вкусы.

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

Что такое функция? Функция это блок кода, которым можно пользоваться много раз. Это непонятное определение, поэтому я приведу пример.

Давайте вспомним домашнее задание с лекции 9 "Указатели". Я напомню условие:

Условие:

Напишите программу, в которой будут все типы переменных, которые мы учили ранее. В каждую переменную положите любое значение, отличное от нуля. Объявите указатели для каждого типа и присвойте указателям адреса переменных.

Программа должна:
1. Распечатать содержимое всех переменных, включая указатели (ВАЖНО! кроме содержимого указателя на char!)
2. Распечатать адреса всех переменных, включая указатели (ВАЖНО! кроме адреса переменной char!)
3. Только для указателей: распечатать содержимое переменных, на которые указывают указатели (через указатели)
4. Только для указателей: изменить содержимое переменных, на которые они указывают (через указатели)
5. Распечатать все заново, то есть повторить с 1 по 3 пункт.


Думаю, все это помнят. Так же все помнят, что мы переписали заново все это огромное количество кода, которое нужно было для решения с 1-го по 3-й пункт, 2 раза. Теперь представьте ситуацию, что в место этого мы делаем так (для примера)

int num = 10;
float f = 11.5;
и так далее, объявляем все эти переменные...

int * p_num = & num;
float * p_f = &f;
и так далее, объявляем все указатели....

потом мы пишем примерно такую строчку:
"распечатать на экран все переменные"

потом мы меняем то, что нужно было по условию:
*p_num = 12;
*p_f = 33.56;

и опять пишем ТОЛЬКО ОДНУ строчку:
"распечатать на экран все переменные"


А где-то ниже, ВСЕГО ОДИН РАЗ мы описываем, что означает наша инструкция "распечатать на экран все переменные":

распечатать на экран все переменные означает:
cout << num << endl;
cout << f << endl;

и так далее.



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

Думаю, что идея понятна. Теперь поговорим, какие преимущества дает такой подход. Их масса!

Во-первых код выглядит значительно проще! Потому что вместо того, чтобы читать все эти строки распечатки - программист понимает: "ага, вот тут происходит распечатка". Если он сомневается - он лезет в саму функцию распечатки (то, что мы назвали описанием) и ОДИН РАЗ смотрит на нее! Далее, везде, где он встречает строку "распечатать на экран все переменные", он уже знает что именно происходит. То есть, за всей этой шелухой деталей не теряется суть программы: он легче видит картину в целом.

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

А в-третьих - представьте, что мы не пользуемся функциями, а копируем и вставляем кусок кода туда, где он нужен. Внезапно выясняется, что в этом куске - баг. Тогда мы идем по коду, ищем этот кусок во всех местах и исправляем ВО ВСЕХ. А вот когда это функция - она написана только в одном месте, поэтому мы и исправляем ее один раз!


Я люблю сравнение функций с автоматом кока-колы. Человек, подходящий к автомату, чтобы купить себе баночку, точно НЕ знает, как именно этот автомат работает. Он не знает, каков механизм внутри, как автомат считает деньги, как он дает сдачу, как выбирает именно тот напиток, который заказали....

Он знает только одно: вот сюда надо бросить монеты, а вон из той дырки выпадет баночка. И этих знаний ему вполне достаточно, чтобы этим автоматом пользоваться. Функция работает по тому же самому принципу: она что-то получает, производит с этим определенные действия и отдает результат. То, что получает функция, называется "параметры", а то, что отдает - "возвращаемое значение". Она как бы возвращает результат тому, кто к ней обратился. Пишется это все так:

в начале пишут ТИП возвращаемого значения, потом ИМЯ функции, по которому мы будем обращаться к ней, после, в круглых скобках, пишут принимаемые ею ПАРАМЕТРЫ и разделяют их запятой. В конце всего этого дела идет блок, в котором и происходит вся работа функции:


float foo (int num, char letter) { блок }

Где:

float - тип возвращаемого значения
foo - имя функции
int num - первый параметр, его тип и его имя
char letter - второй параметр, тип и имя

В блоке подробненько описан алгоритм функции, то есть - ее механизм.


Как обращаются к функции? То есть - процесс купли баночки колы:

int main ( ){

int num = 5;
char letter = 'c';

// тут какой нибудь код, не относящийся к делу

float f = foo(num, letter); // обращение в функции, передача параметров по имени, после чего в переменную f будет положен результат ее работы

// тут какой нибудь код, не относящийся к делу

}


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


Код:







Результат:




Давайте начнем с того, что найдем функцию main. Мы ведь теперь поняли, что main - это функция. Это главная функция программы. Когда операционная система запускает программу - она запускает функцию main и уже из нее - запускается все остальное.

Вглядевшись в main мы УЖЕ видим огромное преимущество использования функций в программировании: по-моему - так гораздо понятней, что делает программа, или я ошибаюсь? Программа создает массив из трех чисел, заполняет весь массив числами и распечатывает его на экран. После этого, она ищет самое большое число из тех, что лежат в массиве, распечатывает его на экран и после этого - распечатывает вновь весь массив.

Я советую остановиться на коде и пока вы не прочли мои объяснения, немного изучить его. Там, в коде есть мои комментарии, которые помогут вам в этом. Мы никуда не спешим, надо взять паузу и перевести дыхание)))) все новое - всегда пугает)))


Многие наверняка задались вопросом: почему функция main написана последней? Этому, конечно, есть объяснение и я расскажу чуть ниже причины такого расположения функций. Мы пока рассмотрим каждую в отдельности и начнем именно с main.

Функция main объявляет массив из трех чисел, после заполняет его. Обратите внимание, что на данном этапе, нам не нужно знать, как именно она получает значения! Это как раз и есть наш автомат с колой, о котором мы знаем: сюда кинь денежку, отсюда выпадет баночка. Нам нужно лишь "позвать" функцию get_num и "подставить" что-то, куда функция вернет результат.

Это можно сравнить с автоматом колы, из которого не выпадает баночка, а выливается кола и нужно подставить стаканчик, иначе, если стаканчика не будет, кола выльется и утечет в канализацию, то есть - денежку мы кинули, а колу не выпили. Причем - все без обмана и винить можно только себя - колу нам дали, мы просто не взяли ее.

Теперь перенесемся на минутку в функцию get_num и посмотрим, как именно происходит получение значения. Функция написана второй сверху. Давайте рассмотрим: как мы видим, в скобках ничего не написано, а это значит, что функция не принимает параметров, они ей не нужны. Тип возвращаемого значения - int

Сейчас, мы словно смотрим на чертеж автомата с колой и можем подробно рассмотреть весь механизм. Первым делом, объявляется переменная, в которую мы положим возвращаемое значение. Как правило, я называю ее ret, просто в силу привычки. Код, написанный ниже - нам уже знаком. Мы будем крутиться в цикле, пока пользователь не введет нужное нам значение. Здесь есть маленькое дополнение: в конце цикла есть блок if, который известит пользователя об ошибке, если такая была.

Далее, мы видим слово return и после него - наша переменная. Это означает: "верни то, что лежит в этой переменной". Сразу возникают вопросы: кому верни? Тому, кто позвал тебя, в данном случае - это была функция main. Да, отлично, скажут некоторые, но по окончанию блока переменная ret перестанет существовать! Это правда, НО! Прежде чем мы уничтожим наш "ящичек" ret, мы скопируем то, что в нем лежит и это содержимое "упадет" в руки тому, кто его ловит "на том конце".

Это как лимон: прежде, чем выкинуть его на помойку - мы выдавим сок в стакан с чаем. Как только алгоритм встречает на своем пути слово return - он покидает функцию и если есть что вернуть - возвращает туда, откуда пришел в эту функцию. Вроде понятно, да?


Итак, мы снова вернулись в main. В наш массив, в определенное отделение нашего длинного ящичка, попало то, что мы получили в функции get_num. Это наш "стакан". Пойдя на повторный шаг цикла - мы подставим следующее деление, и так, пока не заполним весь массив.

Выйдя из цикла for мы попадем на следующую строку: здесь идет вызов другой функции, которая, судя по названию, умеет распечатать на экран массив. Как мы видим, до вызова функции нет никакой переменной, в которую бы вернулось значение. Вывод, который можно сделать: либо из функции ничего не возвращается, либо, нам не нужно то, что она возвращает (такое тоже бывает). Однако, эта функция, в отличии от предыдущей - принимает параметры.

Мы положили туда массив и его размер. Ожидаемо то, что функция принимает 2 параметра: int * и int. Давайте найдем "чертеж" этого "автомата с колой". Он написан чуть выше. Обратите внимание: тип возвращаемого значения обозначен как void - это новое слово, и в программировании оно означает "ничего", то есть наша функция ничего не возвращает.

Примечание: Когда функция ничего не возвращает, программист обязан написать в типе возвращаемого значения слово void. Если программист не напишет ничего, то это означает, что функция возвращает int, это, как бы, "тип по-умолчанию". Я не знаю, зачем так сделали, скорее всего у этого есть своя история... НО! Я НАСТОЯТЕЛЬНО НЕ советую пользоваться этим. Пишите ВСЕГДА тип возвращаемого значения, чтобы код был читабелен не только для вас, но и для других программистов, которые не знают эту фишку, по каким-то причинам....

Другая ситуация, когда функция ничего не принимает, вот тогда скобки можно оставить пустыми. Однако, есть ряд программистов, которые и в этом случае любят указывать явно, что функция ничего не принимает и пишут в скобках слово void. Например я, на работе, делаю так всегда. То есть, если бы я писал функцию get_num, которую мы разбирали самой первой, на работе, то я описал бы ее так:

int get_num (void) { блок }


Окей, но вернемся к начатому: функция print_array. Там немного кода и он довольно простой, поэтому я не вижу смысла его подробно описывать, мы уже должны легко понимать такой код. Единственное, на что я обращу внимание - это на мой трюк с "тройным оператором" в строке cout: я написал так для красоты, чтобы после каждого числа, которое не является последним, ставилась запятая, а после последнего - точка. Как мы можем заметить из результата (картинка под кодом), что именно так и происходит.

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

Я хочу задержаться на одном нюансе: я не совсем хорошо написал эту функцию по той причине, что хотел вам показать главное - ее работу. Однако, обратите внимание: функция принимает указатель! Это - потенциальная опасность! То есть, если тот, кто позвал функцию - передал первым параметром NULL, то программа свалится, как только попытается обратиться к arr [i] (в строке cout)! То есть - функция не защищена! Это - упущение программиста! Если бы я писал эту функцию на работе, то написал бы ее так:



Вот здесь, инструкция return без параметра - наполнена огромным смыслом! Первое, что я делаю - проверяю указатель и если он указывает на NULL, то алгоритм вернется из функции и не доберется до опасного места! То есть - я сделал свою программу более устойчивой! Советую вам стремится к устойчивости программ. Нужно нащупать золотую середину: с одной стороны относится к функции, которую вы пишете, как к самой умной (а все вокруг - дураки, совершающие глупости), но с другой - не переборщить с этим делом, чтобы не превратить функцию из пары строк, в функцию в которой сотни строк и которая переполнена огромной кучей проверок. Именно умение найти этот компромисс и является важной составляющей в умении программировать, чему мы, собственно говоря и учимся)))

Отлично, осталось совсем чуть-чуть. Разберем функцию get_max. Что она делает? Она проходит по массиву и находит максимальное число. Функция принимает параметры int * и int, а возвращает int. По сути - это все, что нам нужно знать о функции. Представьте себе ситуацию: команда программистов получила задание. В команде всегда есть главный. Он распределяет работу: он единственный, который знает, что должна делать программа, то есть видит картину целиком. Остальным программистам это знание не нужно... почему?

Потому что главный создает основной алгоритм (архитектуру) и выделяет из него независимые куски. Такого человека иногда называют "архитектор". Потом он идет к программеру Васе и говорит: "Вася, мне нужно, чтобы ты написал функцию, которая ищет максимальное число. Я вызову ее, передам ей массив и размер, а ты мне вернешь максимальное число в массиве". "Хорошо" - говорит Вася, "я понял".

Вася идет и пишет функцию. Согласитесь, что ему вовсе не обязательно знать, откуда берется массив, который ему дадут и что будут потом делать с максимальным значением, которое он найдет. Ему нужно только написать сам поиск. С другой стороны, главному, который дал Васе задание, вовсе не обязательно знать, как именно происходит этот поиск. Он пользуется функцией Васи, как аппаратом кока-колы. Он знает, что если он позовет функцию Васи и передаст туда массив и размер, то он гарантированно получит на выходе - максимальное число в массиве. То есть - функция Васи для него - "черная коробка". Он не знает, как она работает, но он знает как ею пользоваться.

Но так как мы учимся, мы все-таки заглянем в механизм, который написал этот Вася. Опустим сейчас то, что Вася - олух и он не проверил указатель, за это он получит по шее, но далее Вася сделал все по-уму. Он изначально решил, что самое большое число - это первый элемент массива. Далее - он лишь проверяет свою догадку: он запускает цикл прохода по массиву, и начинает его с единицы, так как нулевое значение нет смысла сравнивать само с собой. Если в массиве только одно число, то есть его размер равен одному, то цикл for не сделает ни шага, потому что условие изначально будет ложным (i < size) в противном случае, он сравнит текущую ячейку с максимальным числом и если в текущей ячейке будет лежать бОльшее число, чем то, что лежит в max - он перепишет число из текущей ячейки в max и пойдет далее по массиву. Таким образом, в конце алгоритма он неизбежно найдет и вернет максимальное число.


Вот, видите, мы и разобрались во всем и согласитесь - это было не очень сложно. Самое время поговорить о хорошем тоне. Несколько правил:

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

2. Функция должна быть "узкопрофильной", то есть функция, которая принимает число с клавиатуры, потом кладет его в массив, после ищет максимальное число - плохая функция. Она должна быть разбита на более мелкие: одна примет число, вторая - найдет наибольшее и т.д.

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

4. Избегайте через чур длинных функций. Длинную функцию в сотни строк - ОЧЕНЬ сложно читать. Если у вас вышла через чур длинная функция - возможно, есть куски кода, из которых можно сделать отдельные функции и просто вызывать их.

5. Функция должна быть универсальной. Это НЕ противоречит пункту 2, где я заявил, что функция должна быть "узкопрофильной"! Объясню почему:
Возьмем мою функцию get_num, она узкопрофильная, то есть все, что она делает - получает значение с клавиатуры и проверяет его. Но она НЕ универсальная и это ее минус! Чтобы сделать ее универсальной, мне стоило "границы" легальных чисел принять как параметры, то есть:


Функция, которую написал я:




Функция, которую следовало бы написать:




Думаю, разница понятна.


Теперь, последняя вещь, которую бы мне хотелось осветить в этой лекции. Напоминаю свои слова, сказанные выше:
"Многие наверняка задались вопросом: почему функция main написана последней? Этому, конечно, есть объяснение и я расскажу чуть ниже причины такого расположения функций"

Самое время поговорить про причины этого. Дело в том, что когда компилятор компилирует программу и встречает вызов функции, ему необходимо знать, что такая функция есть и ею пользуются правильно. То есть, что типы переданных параметров - соответствуют тем, которые функция принимает. Что параметр, который функция возвращает - соответствует типу переменной, куда этот параметр кладут... НО! Если функция описана ниже, чем ее вызов - ему не с чем это сравнить, так как он еще не дошел до нее (он идет сверху вниз).

Этому есть 2 способа решений:

первый способ: описывать функции так, как сделал я, то есть функция foo, которая вызывает функцию bar, написана под описанием механизма функции bar. У этого решения есть минус: нужно постоянно следить за порядком: кто кого вызывает, чтобы знать какую из них написать под какой. Когда функций много - это не очень простая задача. Поэтому я пользуюсь вторым способом.

второй способ: функции пишутся в произвольном порядке, а сверху они "объявляются", то есть, сверху я всего лишь опишу как ее зовут, что она принимает и что возвращает, как бы сказав таким способом компилятору: "ниже в коде есть описание функции, которую зовут так-то, а пользуются - так-то" и тогда, встретив вызов функции ниже, он сравнивает ее с моим объявлением, проверяет, что параметры соответствуют и идет далее. Единственное требование хорошего тона, что если вы выбрали такой способ, то функция main должна быть написана самой первой.

Чтобы было понятней, я перепишу программу, описанную выше, вторым способом:







То, что написано выше функции main - называется "объявление функции", использование функции называется "вызов функции", а само описание механизма - либо "описание", либо, более профессиональный термин - "имплементация". А так как этот способ мне более по душе, то в моих примерах я буду писать так.


Резюме: на этой лекции мы вошли в мир процедурного программирования, сделав свои первые, робкие шаги. Мы познакомились с понятием "функция" и с некоторыми правилами хорошего тона. Тема функции, как таковая, себя еще не исчерпала и материала есть еще примерно на лекцию. Я решил разбить теорию на 2 лекции, чтобы не перегружать информацией. На следующей лекции мы рассмотрим ближе параметры, которые принимает функция и познакомимся с правилами, с ограничениями и со способом эти ограничения обойти)))

Домашнее задание

Напишите программу, которая просит у пользователя 5 чисел, от 1 до 50.
После того, как пользователь введет эти 5 чисел, высветите на экран меню, в котором будут такие возможности:
если пользователь ввел 1 - программа распечатывает весь массив
если пользователь ввел 2 - распечатывает минимальное из введенных им чисел
если пользователь ввел 3 - сумму всех чисел.

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

Удачи!

@темы: C++

---

Учимся программировать на С++. Лекция 11. Циклы

Привет всем программистам))))

решение домашнего задания с предыдущей лекции

Условие:

1. Объявите массив float, длиной 3 элемента, заполните его начальными значениями, отличными от нуля.
2. Распечатайте значения.
3. Объявите указатель на float и присвойте ему адрес первого элемента в массиве, созданном на шаге (1)
4. Распечатайте значения массива, созданного на шаге (1) через указатель.
5. Поменяйте значение 2-го элемента "напрямую"
6. Поменяйте значение 3-го элемента через указатель, объявленный на шаге (3)
7. Выполните шаги 2 и 4 еще раз

решение

Код:




Результат:

лекция

На прошлой лекции речь шла о массивах. Представим, что у нас есть массив, размером в 30 ячеек и мы хотим все их распечатать на экран. Единственный способ, который нам пока известен, это такой:

cout << arr [0] << endl;
cout << arr [1] << endl;
cout << arr [2] << endl;

и так до 30. Ну, вполне ожидаемо то, что я скажу: а теперь представьте, что их 3000.... как быть? Как мы заметили, что строки отличаются между собой лишь числом в ячейке, а все остальное - одинаково. Было бы проще создать блок, и сказать программе: "повторяй этот блок с начала до конца, каждый раз для другой ячейки массива, пока не пройдешь по всему массиву", а во внутрь блока положить нашу строку распечатки.

Блок, который будет повторятся, пока не выполнит задачу, называется "цикл"

В С++ существует 3 формы создать цикл и программист выбирает одну из них, в зависимости от его нужд. Мы изучим их все, по порядку.

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

Укороченные арифетические действия.

У нас есть переменная num:

int num = 0;

мы хотим увеличить эту переменную на 5. Другими словами, получить число, которое уже лежит в переменной, прибавить к ней 5 и положить обратно, в ту же переменную. Можно это сделать так:

num = num + 5;

НО! Если у нас такая ситуация, в которой, мы увеличиваем переменную, то есть по обе стороны знака "равно" - есть одна и та же переменная, то можно использовать сокращенную запись:

num += 5;

Обе эти записи приведут к одному и тому же результату. Они - абсолютно одинаковы по своей функции. Естественно, что это работает не только с константами, тот же фокус можно сделать, вот так:

int num1 = 3;
int num2 = 4;

можно так:

num1 = num1 + num2;

а можно сокращенно:

num1 += num2;

это тоже самое. Тот же фокус работает со всеми арифметическими действиями:

num1 = num1 * num2; ИЛИ num1 *= num2; // умножение.

То же самое можно сделать с делением и вычитанием, но так, как 5 - 3 НЕ равно 3 - 5, я никогда не пользуюсь этим в делении или вычитании. Поэтому, даже не знаю, что именно будет выполнено.

Однако, часто используется увеличение и уменьшение числа на 1. И для этой формы арифметического действия придумали еще более короткую запись:

int num = 10;

num ++; // имя переменной, а после этого два знака "плюс" - означает num = num + 1;

num --; // имя переменной, а после этого два знака "минус" - означает num = num - 1;


Последнее, что хочу сказать об этом действии, это порядок выполнения действий ++ и --.

Допустим код:

int a = 0;
int b = 5;

a = b++; // в а было положено 5, а после этого b увеличили на 1. То есть, после выполнения этой строки, а равно 5, а b равно 6.


Другой код:

int c = 0;
int d = 5;

c = ++d; // заметили? знак ++ перед переменной! Это означает: в начале выполни увеличение на 1, а потом - используй новое значение.
То есть, произошло следущее: в начале увеличили d на 1, то есть оно теперь равно 6, а после в с положили это значение, то есть: d, с равны 6

Как видите, разница есть! То же самое работает и с -- . Отлично! С этими знаниями мы углубимся в изучение циклов)))

Цикл while

Как всегда, по традиции, начнем с кода:




Разберем:
1. мы объявили массив чисел arr, размером в три ячейки и положили туда числа: 41, 42, 43
2. мы объявили переменную, у которой будут такие функции: во-первых, она будет увеличиваться на один каждый шаг цикла, во-вторых - мы постоянно будем с помощью нее запрашивать каждый раз новую ячейку, а в-третьих, мы будем с помощью нее проверять, что мы не вышли за границы цикла.

Далее, мы открыли блок while. Обратите внимание, сразу после слова while, в скобках идет условие. Если условие - правда, то алгоритм зайдет в блок, если нет - пропустит его. Допустим, что условие правда. Тогда, алгоритм зашел в блок и выполнил код, написанный в блоке. Дойдя до конца блока, он снова вернется в начало и проверит условие в скобках, если условие - правда, то он снова выполнит код, написанный в блоке, если нет - пропустит и наш цикл закончится, а алгоритм продолжит далее, выполнять то, что написано после блока.

В блоке он выполнит следущее: распечатает строку и увеличит i на один.

Чтобы лучше понять это, посмотрим на это дело пошагово:


Первый шаг цикла, i равно 0:




Второй шаг цикла, i равно 1:




Третий шаг цикла, i равно 2:




Четвертый шаг цикла, i равно 3:




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

Цикл do-while

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




Для начала, я объясню, что делает программа. Программа просит у пользователя ввести число от 2 до 5 и если число введено правильно, то высвечивает его на экран, в противном случае - повторяет просьбу заново, пока пользователь не введет правильное число.

Теперь о синтаксисе:
Блок начинается со слова do, код попадает в блок. Выполняется код в блоке, а затем, после закрывающей скобки, пишется слово while в котором и написано условие. Если условие правда, то блок выполнится еще раз. Обратите внимание! после условия while стоит точка с запятой!

Как легко заметить, изначально, переменная input равна 3, то есть, если поменять этот цикл, на цикл while, о котором говорилось выше, алгоритм НИКОГДА не попадет в блок! Ну, а в случае с циклом do-while, так как условие проверяется в конце, алгоритм выполняет первый шаг в любом случае.

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

Отлично, самое время изучить цикл, который отличается от двух предыдущих.

Цикл for

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

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

Схема:

for ( 1 ; 2 ; 3 ) { блок }

Где:

1. действие, которое будет выполнено только один раз, в момент, когда алгоритм впервые попадет в цикл

2. условие

3. действие, которое надо выполнить после каждого шага цикла


Вот теперь можно писать код. Я напишу тот же код, который привел в пример в цикле while:



Отлично. Разберите этот код, чтобы убедиться, что в нем все понятно. Обратите внимание! Присвоение i = 0 произойдет ТОЛЬКО один раз, во время первого попадания в цикл! Советую остановится на этом примере, пока все не будет досконально понятно! Я часто встречал людей, у которых этот цикл не усваивается легко.

Теперь, я внесу изменение. Как я уже говорил, в С++ есть возможность объявлять переменную там, где она нужна. Например, переменная i нужна только в цикле, вне цикла она не имеет применения, поэтому, обычно ее объявляют в самом цикле, то есть, пишут так:



Я объявил переменную и сразу присвоил ей значение 0 в скобках цикла!

Примечание: так как переменная i объявлена в блоке цикла, то как только алгоритм покинет блок - переменная i перестанет существовать.

Теперь, еще маленькое дополнение. Как я уже упоминал, во время изучения блока if-else, если код в блоке имеет всего одну строку, то скобки блока можно не писать, то есть, допустима запись:



Это же допустимо и с другими циклами.

Перепишите код и запустите.

Примечание: блок for можно писать без любого из трех вещей в круглых скобках. Он будет работать, однако, точка с запятой быть обязана. К примеру, нам, по какой-то причине нужна переменная i после цикла, чтобы, например, распечатать после цикла, сколько шагов было сделано. Тогда мы напишем такой код:



Как мы видим, значение, которое я в самом начале обозначил цифрой один - пропущено. Точно так же можно пропустить любое из других, не забыв, однако точку с запятой. Естественно, если мы пропустим условие, оставив его пустым, то цикл for будет выпонятся бесконечно.

Специальные инструкции в теле цикла

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


Инструкция break

Это уже знакомая нам инструкция по блоку switch-case. В цикле она работает так: Если алгоритм ее достиг, то он моментально покинет цикл, даже не закончив его. Как правило, такая инструкция окружена условием if. Я напишу тот же пример, который использовал в цикле do-while, с изменением. А именно: программа попросит пользователя ввести число от 2 до 5, НО! Если пользователь введет ноль - то алгоритм покинет блок. Специально, самым последним действием я распечатаю строку, чтобы, когда вы перепишите код и запустите, было видно, что встретив инструкцию break до этой строки, он ее не распечатает:



Перепишите, запустите. Обратите внимание, что строка "after break" не распечатывается, если ввести 0.


Инструкция continue

Инструкция continue ставится тогда, когда мы хотим пропустить какой-то определенный шаг. Тогда цикл начнется заново, а в случае for еще будет выполнено действие в круглых скобках, помеченное у меня на схеме выше как 3.
Для наглядного примера, программа, которая распечатывает в цикле массив. НО! Она распечатывает значение ячейки только в том случае, если оно нечетное:



Алгоритм, встретив инструкцию continue, пропустит код, написанный далее и зайдет в цикл заново.

Перепишите, запустите.

Бесконечные циклы

Есть определенный вид программ, в которых встречаются бесконечные циклы. Как можно сделать цикл бесконечным? Очень просто, сделать так, чтобы условие всегда было правдой. Несколько примеров:

while ( true ) { блок } // так, например, делаю я

while ( 42 ) { блок } // так делают программисты, привыкшие к С, где не было переменной bool. Почему 42? Общепринятый прикол. Помним, что все, отличное от нуля - правда, 42 - в том числе

while ( 1 == 1 ) { блок } // 1 всегда равно 1. То есть - всегда правда

for( ; ; ) { } // как я упоминал выше, пустое условие в цикле for делает его бесконечным


Примечание: инструкции continue и break работают и в этих циклах по тем же законам.


Вот и все, для этой лекции - вполне достаточно.

Домашнее задание:

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

Запустите программу с фразой "I LiKe C++"

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

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

Для крутых:
Если вы считаете, что абсолютно поняли не только этот материал, но и все предыдущие, то напишите цикл подсчета так, чтобы вместо "шагающей переменной" i был использован указатель на char. Это задание на 5+ ))))

Удачи!

@темы: C++

---

Учимся программировать на С++. Лекция 10. Массивы

решение домашнего задания с предыдущей лекции

Условие:

Напишите программу, в которой будут все типы переменных, которые мы учили ранее. В каждую переменную положите любое значение, отличное от нуля. Объявите указатели для каждого типа и присвойте указателям адреса переменных.

Программа должна:
1. Распечатать содержимое всех переменных, включая указатели (ВАЖНО! кроме содержимого указателя на char!)
2. Распечатать адреса всех переменных, включая указатели (ВАЖНО! кроме адреса переменной char!)
3. Только для указателей: распечатать содержимое переменных, на которые указывают указатели (через указатели)
4. Только для указателей: изменить содержимое переменных, на которые они указывают (через указатели)
5. Распечатать все заново, то есть повторить с 1 по 3 пункт.

решение

Код:









Результат:

лекция

Давайте представим себе такую ситуацию: вы пишете программу, которая хранит в себе цены в магазине. В этом магазине всего 3 вещи и все они имеют порядковые номера. Заходит покупатель, смотрит на вещь, рядом написан его номер. Он вводит этот номер в компьютер и узнает ее стоимость. Как мы напишем это?

Ну, в начале мы объявим переменные:

int first = 0;
int second = 0;
int third = 0;

заполним цены, а потом, через switch-case высветим высветим их стоимость, в зависимости от запроса. Вроде, неплохое решение, правда? А если таких вещей 30? 300? 3000? Мы объявим 3000 переменных? Должно быть какое-то более элегантное решение, скажете вы... я не могу с вами не согласится и на этой лекции мы как раз его узнаем.

У нас замечательно идет сравнение памяти с ящичками, давайте так и продолжим. Давайте немного модернизируем некоторые из наших ящичков: они будут длинными и разбитыми на деления. Каждое деление будет пронумеровано. Цена первой вещи будет лежать в первом делении, второй - во втором и так далее. Весь ящичек будет носить одно название: "Цены".

Теперь получается более удобно! Нам говорят: "Скажи цену на второй предмет". Так... мы идем к ящичку "цены", какой предмет? Второй? Ага... второе деление... достаем от туда число и это число - и есть интересующая нас цена. НО! Так как программисты - люди необычные и у них все не так, как у людей, то первый ящичек получит цифру 0, второй - 1 и так далее))) То есть счет мы начинаем с нуля, а не с единицы. Этому есть, конечно, причина, но о ней мы поговорим позже.

Такой "длинный ящичек" с сгруппированными переменными ОДНОГО ТИПА носит название "Массив" (англ. "array"). Массив объявляется следующим образом: мы пишем тип переменных, пишем имя, далее мы открываем квадратную скобку (клавиша с русской буквой х), пишем число, которое означает количество делений в нашем ящичке, а после закрываем скобку (клавиша с русской буквой ъ), к примеру:

int prices [30]; // я объявил массив с 30-ю ячейками.

prices [5] = 18; // я положил в 6-ой ящик число 18 (почему в 6-ой? написано же 5-ть.... напоминание: начинаем с нуля!)

int curr_num = prices [3]; // я создал переменную curr_num и в нее положил то число, которое лежит в массиве prices, в 4-ой ячейке.

ОЧЕНЬ важное замечание! Во время объявления массива НЕЛЬЗЯ использовать переменную в качестве размера! То есть:

int num = 0;

cin >> num;

int arr [num]; // так писать НЕЛЬЗЯ!!!! Нужно использовать ТОЛЬКО константу!

Вы подумаете, что объявлять массивы, не зная ДО запуска программы их размера, вообще нельзя? Можно, но не так. Как объявляются массивы с размером, который, например, должен ввести пользователь с клавиатуры - мы узнаем позже.

Примечание: есть шанс, что вы попробуете написать int arr [num]; и компилятор скомпилирует это... Это произойдет только по одной причине: потому что конкретный компилятор, с которым мы работаем - умеет это делать, НО! Это фича ТОЛЬКО этого компилятора, все остальные не скомпилируют этот код, поэтому - не привыкайте к халяве)))

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

int array[5];

array[0] = 11;
array[1] = 12;
array[2] = 13;
array[3] = 14;
array[4] = 15;

Окей, мы создали массив чисел размером 5 ячеек и ВСЕ (убедитесь, что все) - заполнили числами. Как это выглядит теоретически? Вот так:



Это еще пока не взгляд в память, а только логическая схема. Давайте разберем: красным написано имя массива, черным - содержимое, а синим - "номер ячейки". Вроде все понятно, правда? А если подумать? Каким образом в памяти хранится 5 ячеек, с одинаковым именем? Как это сделано на самом деле? Это ОЧЕНЬ важно понять! Как именно это сделано на самом деле!

С++ гарантирует, что как только вы создадите массив, он выделит количество ячеек, которые вы указали ПОДРЯД! То есть один за другим! Допустим, мы создали массив элементов и каждый элемент хранится в одном байте. К примеру - массив char. Один char хранится в одном байте. Теперь, если это массив - то эти байты будут расположены один за другим! Если первый элемент получил адрес в памяти, скажем, 17, то ГАРАНТИРОВАНО!!! второй получит 18! и так далее. Это ОЧЕНЬ ВАЖНО ПОНЯТЬ!

А вот имя массива - это имя указателя, который указывает на первый элемент! То есть, другими словами, как только вы написали:

char arr[3];

случилось следующее: операционная система выделила 3 ячейки под 3 элемента, взяла адрес первого элемента, выделила ЕЩЕ одну ячейку под указатель на этот тип и туда положила адрес первого элемента! То, что я сейчас написал и выделил жирным - НУЖНО ЗНАТЬ И ПОНИМАТЬ как таблицу умножения! Читайте лекцию от начала и до сих пор, пока это на 100% не засядет в голове! Естественно, вся эта память была выделена на стеке! То есть, как только алгоритм выйдет за пределы блока, в котором объявлен массив - ВЕСЬ массив, включая указатель на него (его имя) перестанет существовать!

Окей, самое время посмотреть на память, чтобы то, что я рассказал, визуально представить. Код:

char arr [3];

arr [0] = 'a';
arr [1] = 'b';
arr [2] = 'c';

Память:



Как мы видим, что arr на самом деле, это имя указателя, хранящего в памяти адрес первого элемента. Обратим внимание на адреса элементов: все три элемента идут подряд в памяти!

Примечание: я привел в пример массив char по той причине, что char занимает один байт. Если бы это был int, который лежит в 2-х или в 4-х байтах, то пришлось бы числа адресов писать с пропуском 2 или 4, чтобы быть до конца честным, а это могло бы ввести путанницу.

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

char arr [3];
char * p;

p = arr;

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

Можно написать так:

char arr [3] = { 'a', 'b', 'c' };

Этот код выполнил следующее действие: он создал массив из 3-х char, в первую ячкейку положил букву 'a', во вторую - 'b', а в третью - 'c'. Однако, у этого способа есть минус: число, которое стоит в квадратных скобках, должно быть не меньше, чем число элементов, которые мы кладем. То есть программист должен постоянно сидеть и считать. С++ избавил его от этой необходимости, а именно? Можно писать так:

char arr [ ] = { 'a', 'b', 'c' };

то есть - если есть присвоение первоначального значения таким образом: { 'a', 'b', 'c' } или, для, например массива int - {1, 2, 3}; - нет необходимости писать его размер в квадратных скобках, компилятор сам посчитает сколько нужно!

НО! Иногда нам нужно обнулить весь массив.... то есть:

int arr [ ] = {0, 0, 0};

а если 300 ячеек? Это же убийство! А как мы знаем - обнуление важный элемент.... так вот, в случае, если массив надо "забить" нулями, во время объявления, то можно написать так:

int arr [300] = {0};

только один ноль! Но тогда требуется размер в квадратных скобках)))) И самое главное - это работает ТОЛЬКО с нулями! То есть, написав int arr [300] = {5}; - мы создадим массив размером 300 элементов, а в первую ячейку положим 5. Дальше будет мусор.

Стринги

Прежде чем мы перейдем к играм с указателями, я хочу познакомить вас с особым типом массива - массивом char. Да, мы уже видели его чуть ранее, но! У него есть маленький секрет! Часто, в программах нужно сохранять слово, а не букву, логично, да? Как сохранять слово? Нужно просто объявить массив char и побуквенно положить в него буквы. То есть слово "word" должно выглядеть примерно так:

char array [ ] = { 'w', 'o', 'r', 'd' };

НО! тут есть маленькая оговорочка.... если пользоваться таким способом, то всегда надо знать, какой размер у слова, чтобы допустим, его распечатать. То есть, там, где мы его распечатаем - нужно 2 параметра: сам массив и его размер, чтобы после буквы 'd' остановиться. Таскать за собой 2 параметра - неудобно. Поэтому, из ситуации вышли следующим образом: после последней буквы ставится 0. Как мы знаем, что 0 и '0' - две разные вещи, то есть нет никаких проблем с этим, даже, если строка должна содержать ноль как ее часть, например: "есть 0 свободных ячеек", так как 0 посередине строки - это вот такой ноль: '0'.

У ноль, который обозначает конец строки пишут так: '\0' (с бекслешем) НО! 0 и '\0' - одно и тоже.

Массив char с нулем в конце называется "стринг"

То есть наше слово выглядит на самом деле вот так:

char array [ ] = { 'w', 'o', 'r', 'd' , '\0'}; // обратите внимание!!! об этом всегда нужно помнить! Если мы хотим создать стринг, то у него всегда должно быть на одну больше ячеек, чем букв, которые составляют слово или предложение. В этой, последней ячейке должен быть ноль!

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

char str [ ] = "hello world";

или так:

char *str = "hello world";

В таком виде программа создаст стринг, то есть массив char нужного размера, плюс ноль в конце. Так, как это полагается делать.

Распечатать стринг на экран можно так:

cout << str << endl;

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

Примечание: попробовав создать стринг вторым способом, вы получите предупреждение о том, что этот способ устаревший. Это правда так. Это потому, что в С++ есть более удобная форма хранить строки и слова, и мы ее обязательно изучим, но до этого светлого момента - еще очень долгий путь)))

Арифметика указателей

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

Пример:

int arr [ ] = {1, 2, 3};
int * p = arr;

cout << *p << endl; // на экран будет выведено 1

p = p + 2;

cout << *p << endl; // на экран будет выведено 3

p = p - 1;

cout << *p << endl; // на экран будет выведено 2

*p = 48;

теперь наш arr выглядит так:

{1, 48, 3}

Разберем:
в начале, р указывает на первую ячейку массива. Действие p = p + 2 законно, потому что мы знаем, что есть три элемента. И у нас есть еще одно знание: эти элементы лежат в памяти подряд, один за другим. Теперь р указывает на 3-ю ячейку, а после p = p - 1 - на вторую.

Некоторые внимательные скажут:
позвольте.... int хранится в 2-х байтах.... то есть, если в р лежит адрес первого байта, первого int, то сделав действие p = p + 2 мы перескочим на середину второго int...

Ответ: нет. Потому что p указывает на int и программа знает, что если мы прибавляем адрес int, то нужно перескакивать 2 байта на каждую прибавленную единицу. То есть - эти действия полностью законны и отработают так, как и должны. Программист не должен переживать по этому поводу.

Многоярусные массивы и массивы указателей

Всего пару слов. Думаю, что вы уже понимаете, что нет никакой проблемы объявить массивы указателей, например массив:

int * arr [3] = {0};

содержит в себе 3 указателя на int


Более неожиданно, это то, что можно создавать многоярусные массивы в моем примере я покажу двухярусный, но нет никаких проблем создать 3-х, 4-х и так далее, по тому же принципу, то есть:

int arr [2] [3];

arr [0][0] = 1;
arr [0][1] = 2;
arr [0][2] = 3;
arr [1][0] = 4;
arr [1][1] = 5;
arr [1][2] = 6;

Создаст следующее (схема):





Точно так же этот массив можно создать и инициализировать сразу:

int arr [ ] [ ] = { {1, 2, 3} , {4, 5, 6} };

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

Домашнее задание

1. Объявите массив float, длиной 3 элемента, заполните его начальными значениями, отличными от нуля.
2. Распечатайте значения.
3. Объявите указатель на float и присвойте ему адрес первого элемента в массиве, созданном на шаге (1)
4. Распечатайте значения массива, созданного на шаге (1) через указатель.
5. Поменяйте значение 2-го элемента "напрямую"
6. Поменяйте значение 3-го элемента через указатель, объявленный на шаге (3)
7. Выполните шаги 2 и 4 еще раз.

Удачи!

@темы: C++

---

Учимся программировать на С++. Лекция 9. Указатели.

Доброго времени суток!

решение домашнего задания с предыдущей лекции

Условие:
Перепишите домашнее задание с предыдущей лекции с дополнительным требованием: в вашем коде обязан присутствовать хотя бы один блок switch-case.

Условие домашнего задания, о котором идет речь:
Напишите программу, которая получает от пользователя символ и выполняет следущие действия:

Если символ это буква - программа пишет в консоль "символ является буквой",
а также: если эта буква заглавная, то программа добавляет: "символ является заглавной буквой"

Если символ это цифра - программа пишет: "символ является цифрой",
а также, если это 5 - добавляет: "это 5",
а также, если это 7 - добавляет: "это 7",
а также, если это 9 - добавляет: "это 9"

В любом другом случае программа пишет: "символ не является ни буквой, ни цифрой"


Запустите программу со следущими символами:
a, Z, 2, 7, [ , @ (кому не видно: пятый символ - квадратная скобка, находится на той же клавише, что и русское 'х')


Подсказка: желательно вспомнить, что существует таблица ASCII и внимательно ее изучить!

решение

лекция

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

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

Область видимости переменной

Я не стал делать из этого отдельную тему, по причине, что много тут не расскажешь, НО! То, что я расскажу - вы должны знать как "отче наш"! Если ночью вас разбудить - от зубов чтобы отлетало!

Каждая переменная занимает место в памяти, это мы уже знаем. Это место занимается, как только код доходит до строки, в которой переменная объявляется. Осталось только понять, когда место освобождается? Как я уже упоминал, в том виде, в котором мы пока умеем объявлять переменную - память выделяется в стеке (помните? "стек", "куча"...). Так же я говорил, что операционная система сама отвечает за распределение памяти в стеке.

Мы объявляем переменную int num и с этого момента можем ею пользоваться до тех пор, пока она "жива". "Срок жизни" каждой переменной, обычно называют "область видимости", как только алгоритм выходит за область видимости конкретной переменной - она "умирает" и память, которую она занимала - освобождается.

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



Разберем:
переменная num существует в границах блока main, переменная symbol - только в блоке if. Немного не понятна одна деталь: что такое переменная global_var и чем она отличается от num? Вроде я говорил, что вся программа расположена в границах блока main, то есть по завершению блока - программа закончится....

Ответ: и да и нет))) а именно:
"по завершению блока main - программа закончится" - это правда
"программа расположена в границах блока main" - а вот это не совсем....

Можно открывать другие, вспомогательные блоки, на подобии main, но мы пока еще не умеем (скоро научимся). Такие блоки будут называться "функции" и они являются основой "процедурного программирования", к изучению которого мы вот-вот приступим))) пока мы учим только азбуку.

Чтобы сильно не подвесить это дело в воздухе, я лишь коснусь: global_var будет "жить" и в main и в любом другом месте кода, ВЕЗДЕ, а вот num в других функциях "виден" не будет и обращаться к нему там будет невозможно.

Теперь поговорим немного о "хорошем тоне":

Некоторые, прочитав статью, зададутся справедливым вопросом: зачем объявляют переменные в блоках и усложняют себе этим жизнь? "Тут видно, тут не видно"... объявил все переменные глобальными и не паришься....

Я понимаю этот вопрос, так как в свое время тоже его задавал. Однако, переменные должны существовать только там, где они нужны! В вашем коде не должно быть ничего лишнего! Если глобальная переменная не оправдана (а в ПОДАВЛЯЮЩЕМ большинстве случаев это так), то она не имеет права на существование!

Оправдано такое ограничение многими вещами, например, во время отлова багов, гораздо проще "проследить" где происходит ошибка, если точно знать границы видимости тех или иных переменных. Это только один из массы аргументов в эту пользу. Поэтому, глобальные переменные объявляют только тогда, когда без нее либо очень глупо, либо - невозможно, а такие случаи - очень редки. Как вывод - глобальные переменные в коде не упрощают жизнь, а круто ее усложняют)))

В принципе - я закончил эту тему. Это - ОЧЕНЬ важные знания и их не тяжело запомнить, так что ОЧЕНЬ советую постараться)))

Указатели

Вспомним картинку, которую мы уже видели раньше:



На этой лекции мы будем говорить про адреса, они на картинке обозначены синим цветом. Дело в том, что существуют типы переменных, которые способны хранить эти адреса. Эти типы имеют общее название "указатель" (англ - pointer). Слово "указатель" не случайно, так как он держит "в себе" адрес той или иной переменной, по которому к этой переменной можно обратиться, чтобы, например, изменить ее содержимое.

Объявляется указатель просто: пишется тип переменной, на которую он указывает, после этого "звездочка", после звездочки - имя. К примеру:

int * p_num;

Сразу "стравлю" вам кусочек кода + картинки, посмотрите, а потом мы подискутируем)))

уже известный нам кусок кода создает переменные, изображенные на картинке выше:

int num = 5;
float result = -7.21;
char letter = 'a', symbol = '#';

Теперь указатели:

int * p_num;
float * p_result;
char * p_letter, * p_symbol;

Обратим внимание! Во время объявления указателей на char - я использовал трюк, позволяющий объявить одинаковый тип в строчку, через запятую, НО!!! На этот раз я обязан уточнить, что ОБЕ переменные - указатели! Делаю я это звездочкой! Если бы я написал: char * p_letter, p_symbol; - то я бы объявил указатель p_letter и "обычную" переменную, содержащую символ!

Примечание: я специально дал именно такие имена указателям, чтобы было понятно, на что они указывают.

Присваиваем указателям адреса переменных:

p_num = & num;
p_result = & result;
p_letter = & letter;
p_symbol = & symbol;

Примечание: Символ & говорит компилятору: "дай мне адрес этой переменной"

Примечание: я мог объявить указатель и сразу присвоить ему адрес: int * p_num = & num;

Итак, "заглянем в память", что произошло?



Как мы видим, указатели содержат в памяти адреса присвоенных переменных, НО! Они - тоже переменные и поэтому - тоже имеют адреса))) Вывод, который напрашивается сам собой: а можно ли создать указатель, содержащий адрес другого указателя? Ответ очевиден: МОЖНО! Делается это так:

int ** p_num2; // с двумя звездочками!!!!
p_num2 = & p_num;

ИЛИ

int ** p_num2 = & p_num;

Нужно ли это? Да, бывает.... подробнее об этом далее))) За свою практику я не использовал ни разу более 3-х звездочек))) и то - 3 - огромная редкость! Мы дойдем до причин, пока просто знайте: можно.

Примечание: внимательные читатели спросят: а что будет, если объявить указатель, не присвоив ему адрес и по ошибке к нему обратиться?
Если у вас возник такой вопрос - то дайте я вас расцелую! Потому что это означает, что вы - прекрасные ученики!

Как я объяснял ранее, при объявлении переменной, операционная система не чистит и не обнуляет память, то есть, программа полезет в переменную, прочтет случайный набор единиц и нулей, "переведет" это как адрес и попытается по этому адресу обратиться. Что произойдет? Программа ТУТ ЖЕ рухнет!!! Потому что скорее всего, она обратится по адресу, ей не принадлежащему, а эту наглость операционная система простить не сможет! Программа будет убита, а система отрапортует: "segmentation fault" - и это очень печальный результат! Если вы видите такую ошибку - где-то вы нажгли с памятью непростительных вещей)))

Как же выходят с ситуации? Если нельзя сразу присвоить адрес, то его обнуляют, то есть адрес будет указывать на ячейку памяти по адресу 0. Этот нулевой адрес обозначается словом NULL (большими буквами), то есть:

int * p_num = NULL;

Примечание: В нулевой адрес ТОЖЕ нельзя обращаться! Если это сделать, то программа НЕИЗБЕЖНО рухнет! НО!!! Ведь всегда, ДО обращения можно спросить: а не указывает ли наш указатель на NULL? И если это так - не обращаться к нему! То есть:

if(p_num != NULL)

Примечание: в чем разница между случаем, когда указатель указывает на ноль и когда указатель указывает на "мусор", потому что мы не присвоили ему адрес? ИМЕННО в возможности такой проверки! Если мы напишем так:

int * p_num; // объявим, ничего не присвоив
// тут какой либо код, в котором присвоение не происходит
if(p_num != NULL) // не указывает ли указатель на ноль? Нет! Не указывает...
// отлично, скажем мы и полезем к нему.... и это будет последнее, что сделает программа, перед тем, как с грохотом рухнуть)))

Отлично, подводные камни мы прощупали, поэтому приступим к рассуждениям как пользоваться указателями. К указателю есть 2 типа обращений. В первом случае мы можем обратиться к его содержимому - то есть к адресу той переменной, на которую он указывает, а во втором - к содержимому той переменной, на которую он указывает. Как обращатся к содержимому самого указателя (к адресу переменной) мы уже поняли - точно так же, как к содержимому любой переменной, а вот как обратиться к содержимому той переменной, на которую указывает наш указатель, чтобы, допустим поменять ее содержимое? Это делают, ставя звездочку, перед указателем. Нагляднее это продемострирует следущий код:




Результат выполнения программы:




Разберем:

Я объявил 3 переменных: int a, int b и указатель на int. В начале а содержит 1, b содержит 2. Я распечатываю это, чтобы наглядно в этом убедиться. После этого, я присваиваю указателю адрес а и через указатель меняю содержимое переменной а. Я распечатываю обе переменные снова, чтобы было видно, что изменения произошли. После этого, я присваиваю указателю адрес переменной b, меняю значение b и снова распечатываю. Вглядитесь в код и в результат, чтобы убедиться, что все понятно.

Итак, на этой лекции мы выучили 2 вещи, во-первых: область видимости переменных, а во-вторых - указатели. На данном этапе, еще пока не понятно, для чего указатели нужны. У указателей ОГРОМНОЕ значение! Просто пока мы не видим где именно их применять. Наберитесь терпения!

Домашнее задание:

Напишите программу, в которой будут все типы переменных, которые мы учили ранее. В каждую переменную положите любое значение, отличное от нуля. Объявите указатели для каждого типа и присвойте указателям адреса переменных.

Программа должна:
1. Распечатать содержимое всех переменных, включая указатели (ВАЖНО! кроме содержимого указателя на char!)
2. Распечатать адреса всех переменных, включая указатели (ВАЖНО! кроме адреса переменной char!)
3. Только для указателей: распечатать содержимое переменных, на которые указывают указатели (через указатели)
4. Только для указателей: изменить содержимое переменных, на которые они указывают (через указатели)
5. Распечатать все заново, то есть повторить с 1 по 3 пункт.

Примечание: Адреса переменных, на самом деле, записываются в шестнадцатиричной системе. Цифры в этой системе: 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f (всего 16-ть). Чтобы зрительно отличить шестнадцатиричную систему от "обычной" - десятичной, перед числом добавляют ноль и букву 'x'. То есть, распечатав адрес, вы увидите примерно следующее: 0x28ff0e

Удачи!

@темы: C++

---

Учимся программировать на С++. Лекция 8. Блоки и условия. switch-case

Здрасте!

решение домашнего задания с предыдущей лекции

Условие:
Напишите программу, которая получает от пользователя символ и выполняет следующие действия:

Если символ это буква - программа пишет в консоль "символ является буквой",
а также: если эта буква заглавная, то программа добавляет: "символ является заглавной буквой"

Если символ это цифра - программа пишет: "символ является цифрой",
а также, если это 5 - добавляет: "это 5",
а также, если это 7 - добавляет: "это 7",
а также, если это 9 - добавляет: "это 9"

В любом другом случае программа пишет: "символ не является ни буквой, ни цифрой"


Запустите программу со следующими символами:
a, Z, 2, 7, [ , @ (кому не видно: пятый символ - квадратная скобка, находится на той же клавише, что и русское 'х')


Подсказка: желательно вспомнить, что существует таблица ASCII и внимательно ее изучить!

решение

Код:




Результат:

лекция

На прошлой лекции мы впервые познакомились с условиями. На самом деле, эта лекция должна была, по моей задумке, стать частью предыдущей, но посмотрев на объем информации, которую я вылил на вас в прошлый раз, я решил разбить это дело на 2 лекции. В этой лекции мы поговорим о блоке switch-case, а так же я расскажу вам про "тройной оператор". Начнем по порядку.

Блок switch-case

Блок if-else, с которым мы познакомились на предыдущей лекции имеет два недостатка:

1. Все условия взаимоисключающие. Допустим, есть 3 разных условия, но 2 из них имеют общую обработку, правда в первом делается еще что-то дополнительно. Это НЕ большой недостаток, так как вложенный if обычно легко исправляет ситуацию.

2. Если опций больше 3-х код становится неудобочитаемым. То есть, нужно напрягать глаза, чтобы найти, где именно обработается тот или иной случай. Думаю, именно этот недостаток и послужил причиной для создания блока switch-case.

Как всегда, "лучше один раз увидеть, чем 100 раз услышать", поэтому, сразу код, а потом объяснения:




Программа просит ввести цифру от 2 до 5 включительно и высвечивает на экран цифры, которые делят ее без остатка (делители).


Разберем:

В начале есть слово switch, а в скобках - переменная которую мы хотим "проверить". Как только переменная заходит в блок - она начинает искать подходящий случай, другими словами - чему из предложенных вариантов она равна.

Допустим, она равна 3. Тогда алгоритм войдет в вариант case 3: и будет строчка за строчкой выполнять код, пока не встретит на своем пути слово break. Как только это слово будет встречено, алгоритм покинет блок.

Обратим внимание, что есть опция default: Она предназначена для случаев, когда алгоритм не нашел ни одного совпадения в "специфических" случаях. Он попадает в default. Эта опция необязательна: блок switch-case прекрасно отработает без default. Просто в данном случае, было очень удобно использовать эту опцию как отлов ошибочного ввода пользователя. Не могу сказать, что default всегда используется в таком качестве.... иногда большая часть работы происходит именно в нем.

Примечание: Эклипс ставит немного не такие отступы в этом блоке, как у меня в примере.... просто я привык так....

Отлично. В общем - что такое блок switch-case вроде разобрались, осталось осветить одну мелочь: что будет, если в конце конкретного case не поставить break? Код просто продолжит в следующий case и выполнит действия, написанные там. В Java или C# это запрещено и код не скомпилируется, потому что как правило, забытый break - это ошибка программиста, НО! В С++ такое допускается и поэтому если вы ошиблись - пеняйте на себя.... хотя иногда программисты используют эту возможность.

Как это может быть использовано? Очень просто: у нас есть 2 case, которые выполняют одну и ту же работу, только один из них выполняет немного больше. Ставят case, который выполняет больше работы раньше второго и та "лишняя" работа записана в нем, потом идет другой case с "общей" работой, а потом только break. Чтобы показать наглядно, что я имею ввиду - посмотрим на пример, который я привел выше: как видите, 2 и 4 - делятся на те же цифры, за исключением одной: 4 еще делится на 4)))

Поэтому, код можно изменить так:



Обратите внимание, что Эклипс подчеркнул желтым это место, потому что с точки зрения Эклипс - это потенциально опасное место. Он как бы показывает программеру: "Обрати внимание! Этот case не заканчивается break! Это то, что ты хотел?"

Такой прием называется "проваливание". Иногда проваливание используют еще, когда оба case делают одинаковую работу. Так как нельзя написать что-то типа case 2,4:, это не пройдет компиляцию, то пишут один под другим:

case 2:
case 4:
// тут код
break;

Теперь о правилах блока:
Их несколько. Во-первых, в case нельзя писать сравнения, например case 4 > n: , так как блок отвечает на вопрос: "является ли переменная, написанная в скобках switch равной одной из следующих опций?"
Во-вторых - нельзя писать после слова case переменную! Там ТОЛЬКО константа! Это означает, что если написано case n:, то переменная n объявлена так: const тип n = значение, например: const int n = 7;

В любом case можно делать что угодно! Например открывать блок if-else или еще один switch-case... все, что требует задача!

Оператор "по модулю"

Существует математическое действие "по модулю". Я предполагаю, что многие не помнят, что оно значит, поэтому позволю себе напомнить. Я не буду давать тут точное математическое определение, а попробую построить объяснение так, чтобы было понятно.

Допустим вам дали два числа. Действие "первое число по модулю второго числа" возвращает остаток при делении первого числа на второе. Несколько примеров:

Два числа: 5 и 3
Если 5 разделить на 3, то получится, что 5 разделить на 3 будет 1 С ОСТАТКОМ 2, то есть 5 mod 3 = 2

Два числа: 20 и 5
20 делится на 5 БЕЗ ОСТАТКА, то есть 20 mod 5 = 0

Два числа: 67 и 15:
67 делится на 15 так: 4 "целых" раз по 15 (15 * 4 = 60) И ОСТАТОК 7, то есть: 67 mod 15 = 7.

Думаю - понятно.

В программирование есть действие "по модулю" и записывается оно так (по нашим примерам):
1. 5 % 3
2. 20 % 5
3. 67 % 15

Чаще всего это действие используют, когда хотят узнать, является ли число четным? if (num % 2 == 0)
Для чего я это рассказал именно сейчас? Ну, во-первых, это нужно знать, а во-вторых я использую этот оператор, чтобы объяснить следующую тему лекции "Тройной оператор"

Тройной оператор

Представим себе ситуацию, что у нас есть 2 числа. Первое мы получаем с клавиатуры, назовем его input. А ко второму такое требование: если input четный, то во второе мы положим 17, а если нечетный, то -35. Это можно написать так:

if(input % 2 == 0)
num = 17;
else
num = -35;

ИЛИ

if(input % 2) // почему??? если кто не помнит - бегом в предыдущую лекцию!
num = -35;
else
num = 17;

НО! Можно использовать тройной оператор. Тройной оператор работает так:

условие ? вернуть, если условие правда : вернуть, если условие ложь ;

Обратим внимание:

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

то есть, для нашего примера это будет выглядеть так:

num = input % 2 == 0 ? 17 : -35;

можно взять в скобки, чтобы было понятней:

num = (input % 2 == 0 ? 17 : -35);

ИЛИ

num = input % 2 ? -35 : 17;

В скобках:

num = (input % 2 ? -35 : 17);

Требование: тип возвращаемого значения в обоих случаях должен совпадать!

Для пущего примера, код программы, получающей число и пишущей на экран является число, полученное с клавиатуры, четным или нечетным:





Напишу этот код еще один раз, чтобы "приучить" вас видеть в нуле - "false". Это ОЧЕНЬ нужно, так как МНОГИЕ этим пользуются!





Прекрасно! Для этой лекции - достаточно. На ней мы познакомились с блоком switch-case, оператором "по модулю" и тройным оператором. Следующая лекция обещает быть более интересной, так как мы начинаем идти круто в гору)))

Домашнее задание

Перепишите домашнее задание с предыдущей лекции с дополнительным требованием: в вашем коде обязан присутствовать хотя бы один блок switch-case.
Удачи!

@темы: C++