>>92624360
какого хуя везде панда открывается

Идите нахуй со своей пандой, дауны.

>>92624627
sad pand opera - нихуя не нашлось

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

>>92625119
Нахуй нам еще регаться с мылами и сотовыми на твоем сраном спам-сайте, где одна реклама небось.

>>92625127
Слышь ты, не твоя личная армия, всякой хуйней для тебя заниматься и время с ебучими регистрациями убивать.

>>92625207
Оно не ставится на сафари на маке, дебил.

>>92625284
Ну и нехуй тут свой говносайт спамить, на который все равно никто не попадет.

>>92625334
>мы все счастливо дрочим
У тебя раздвоение личности, долбоеб. Кроме тебя тут все панду видят, а не ебутся по 100500 часов с настройками какого-то говна для спамеров хуй знает зачем.

>>92625468
Иди нахуй со своим ебучим тредом, где все одну панду видят. Сажи долбоебу.

Сажи пидору

>>92625849
в жопу пошел

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

>>92625901

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

>>92625932

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

>>92625959

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

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

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

Как вы уже знаете, ваши программы могут обращаться к частным (private) элементам класса только с помощью функций-элементов этого же класса. Используя частные элементы класса вместо общих во всех ситуациях, где это только возможно, вы уменьшаете возможность программы испортить значения элементов класса, так как программа может обращаться к таким элементам только через интерфейсные функции (которые управляют доступом к частным элементам). Однако в зависимости от использования объектов вашей программы, иногда вы можете существенно увеличить производительность позволяя одному классу напрямую обращаться к частным элементам другого. В этом случае уменьшаются издержки (требуемое время выполнения) на вызов интерфейсных функций. В подобных ситуациях C++ позволяет определить класс в качестве друга (friend} другого класса и разрешает классу-другу доступ к частным элементам этого другого класса. В этом уроке объясняется, как ваши программы могут указать, что два класса являются друзьями. К концу данного урока вы освоите следующие основные концепции:

Используя ключевое слово friend, класс может сообщить C++, кто является его другом, т. е. другими словами, что другие классы могут обращаться напрямую к его частным элементам.
Частные элементы класса защищают данные класса, следовательно, вы должны ограничить круг классов-друзей только теми классами, которым действительно необходим прямой доступ к частным элементам искомого класса.
C++ позволяет ограничить дружественный доступ определенным набором функций.
Частные (private) элементы позволяют вам защищать классы и уменьшить вероятность ошибок. Таким образом, вы должны ограничить использование классов-друзей настолько, насколько это возможно. Иногда программа напрямую может изменить значения элементов класса, это увеличивает вероятность появления ошибок.

ОПРЕДЕЛЕНИЕ ДРУЗЕЙ КЛАССА

C++ позволяет друзьям определенного класса обращаться к частным элементам этого класса. Чтобы указать C++, что один класс является другом (friend) другого класса, вы просто помещаете ключевое слово friend и имя соответствующего класса-друга внутрь определения этого другого класса. Например, приведенный ниже класс book объявляет класс librarian своим другом. Поэтому объекты класса librarian могут напрямую обращаться к частным элементам класса book, используя оператор точку:

class book

{
public:
book (char , char , char *);
void show_book(void);
friend librarian;
private:
char title [64] ;
char author[64];
char catalog[64];
};

Как видите, чтобы указать друга, необходим только один оператор внутри определения класса. Например, следующая программа VIEWBOOK.CPP использует librarian в качестве друга класса book. Следовательно, функции класса librarian могут напрямую обращаться к частным элементам класса book. В данном случае программа использует функцию change_catalog класса librarian для изменения номера карточки каталога определенной книги:

char catalog[64];
};

book::book(char title, char author, char •catalog)

{
strcpy(book::title, title);
strcpy(book::author, author) ;
strcpy(book::catalog, catalog);
}

void book::show_book(void)

{
cout << "Название: " << title << endl;
cout << "Автор: " << author << endl;
cout << "Каталог: " << catalog << endl;
}

class librarian

{
public:
void change_catalog(book , char );
char get_catalog(book);
};

void librarian::change_catalog(book this_book, char new_catalog)

{
strcpy(this_book->catalog, new_catalog);
}

char librarian: :get__catalog(book this_book)

{
static char catalog[64];
strcpy(catalog, this_book.catalog);
return(catalog) ;
}

void main(void)

{
book programming( "Учимся программировать на языке C++", "Jamsa", "P101");
librarian library;
programming.show_book();
library.change_catalog(&programming, "Легкий C++ 101");
programming.show_book();
}

Как видите, программа передает объект book в функцию change_catalog класса librarian по адресу. Поскольку эта функция изменяет элемент класса book, программа должна передать параметр по адресу, а затем использовать указатель для обращения к элементу этого класса. Экспериментируйте с данной программой, попробуйте удалить оператор friend из определения класса book. Поскольку класс librarian больше не имеет доступа к частным элементам класса book, компилятор C++ сообщает о синтаксических ошибках при каждой ссылке на частные данные класса book.

О друзьях класса

Обычно единственный способ, с помощью которого ваши программы могут обращаться к частным элементам класса, заключается в использовании интерфейсных функций. В зависимости от использования объектов программы иногда может быть удобным (или более эффективным с точки зрения скорости вычислений) разрешить одному классу обращаться к частным элементам другого. Для этого вы должны информировать компилятор C++, что класс является другом (friend). Компилятор, в свою очередь, позволит классу-другу обращаться к частным элементам требуемого класса. Чтобы объявить класс другом, поместите ключевое слово friend и имя класса-друга в секцию public определения класса, как показано ниже:

class abbott

{
public:
friend costello;
// Общие элементы
private:
// Частные элементы
};

Как друзья отличаются от защищенных (protected) элементов

Из урока 26 вы узнали, что в C++ существуют защищенные (protected) элементы класса, что позволяет производным классам обращаться к защищенным элементам базового

другу обращаться к частным элементам требуемого класса. Чтобы объявить класс другом, поместите ключевое слово friend и имя класса-друга в секцию public определения класса, как показано ниже:

class abbott

{
public:
friend costello;
// Общие элементы
private:
// Частные элементы
};

Как друзья отличаются от защищенных (protected) элементов

Из урока 26 вы узнали, что в C++ существуют защищенные (protected) элементы класса, что позволяет производным классам обращаться к защищенным элементам базового класса напрямую, используя оператор точку. Помните, что к защищенным элементам класса могут обращаться только те классы, которые являются производными от данного базового класса, другими словами, классы, которые наследуют элементы базового класса (защищенные элементы класса являются как бы частными по отношению к остальным частям программы). Классы-друзья C++ обычно не связаны между собой узами наследования. Единственный способ для таких не связанных между собой классов получить доступ к частным элементам другого класса состоит в том, чтобы этот другой класс информировал компилятор, что данный класс является другом.

ОГРАНИЧЕНИЕ КОЛИЧЕСТВА ДРУЗЕЙ

Как вы только что узнали, если вы объявляете один класс другом другого класса, вы обеспечиваете классу-другу доступ к частным элементам данных этого другого класса. Вы также знаете и то, что чем больше доступа к частным данным класса, тем больше шансов на внесение ошибок в программу. Следовательно, если доступ к частным данным другого класса необходим только нескольким функциям класса, C++ позволяет указать, что только определенные функции дружественного класса будут иметь доступ к частным элементам. Предположим, например, что класс librarian, представленный в предыдущей программе, содержит много разных функций. Однако предположим, что только функциям change_catalog и get_catalog необходим доступ к частным элементам класса book. Внутри определения класса book мы можем ограничить доступ к частным элементам только этими двумя функциями, как показано ниже:

class book

{
public:
book(char , char , char );
void show_book(void);
friend char librarian::get_catalog(book);
friend void librarian: :change_catalog( book , char );
private:
char title[64];
char author[ 64 ];
char catalog[64];
};

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

О функциях-друзьях

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

public:
friend class_name::function_name(parameter types);

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

Если ваша программа начинает ссылаться на один класс из другого, вы можете получить синтаксические ошибки, если порядок определения классов неверен. В данном случае определение класса book использует прототипы функций, определенные в классе librarian. Следовательно, определение класса librarian должно предшествовать определению класса book. Однако если вы проанализируете класс librarian, то обнаружите, что он ссылается на класс book:

out << "Каталог: " << catalog << endl;
}

void librarian::change_catalog(book this_book, char new_catalog)

{
strcpy(this_book->catalog, new_catalog) ;
}

char *librarian::get_catalog(book this_book)

{
static char catalog[64];
strcpy(catalog, this_book.catalog);
return(catalog) ;
}

void main(void)

{
book programming( "Учимся программировать на C++", "Jamsa", "P101");
librarian library;
programming.show_book();
library.change_catalog(&programming, "Легкий C++ 101");
programming.show_book();
}

Как видите, программа сначала использует объявление, чтобы сообщить компилятору, что класс book будет определен позже. Поскольку объявление извещает компилятор о классе book, определение класса librarian может ссылаться на класс book, который еще не определен в программе.

Что такое идентификатор класса

Идентификатор представляет собой имя, например имя переменной или класса. Если ваши программы используют дружественные классы, то может случиться, что определение одного класса ссылается на другой класс (его имя или идентификатор), о котором компилятор C++ еще ничего не знает. В таких случаях компилятор C++ будет сообщать о синтаксических ошибках. Чтобы избавиться от ошибок типа "что следует определять сначала", C++ позволяет вам включать в начало исходного текста программы объявление класса, тем самым вводя идентификатор класса:

class class_name;

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

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

Использование в ваших программах на C++ друзей позволяет одному классу обращаться к частным элементам другого класса напрямую, используя оператор точку.
Для объявления одного класса другом (friend) другого класса вы должны внутри определения этого другого класса указать ключевое слово friend, за которым следует имя первого класса.
После объявления класса другом по отношению к другому классу, все функции-элементы класса-друга могут обращаться к частным элементам этого другого класса.
Чтобы ограничить количество дружественных методов, которые могут обращаться к частным данным класса, C++ позволяет указать дружественные функции. Для объявления функции-друга вы должны указать ключевое слово friend, за которым следует прототип функции, которой, собственно, и необходимо обращаться к частным элементам класса.
При объявлении дружественных функций вы можете получить синтаксические ошибки, если неверен порядок определений классов. Если необходимо сообщить компилятору, что идентификатор представляет имя класса, который программа определит позже, вы можете использовать оператор такого вида class class_name;.

На всем протяжении этой книги вы использовали выходной поток cout для вывода информации на экран дисплея. Аналогично, многие из ваших программ использовали входной поток cin для чтения информации с клавиатуры. Оказывается, cin и cout представляют собой классовые объекты, определяемые и создаваемые с помощью заголовочного файла iostream.h. Как объекты cin и cout поддерживают различные операторы и операции. Из данного урока вы узнаете, как расширить возможности ввода и вывода, используя функции, встроенные в классы cin и cout. К концу этого урока вы освоите следующие основные концепции:

Заголовочный файл iostream.h содержит определения классов, которые вы можете проанализировать, чтобы лучше понять потоковый ввод/вывод.
Используя метод cout.width, ваши программы могут управлять шириной вывода.
Используя метод cout.fill, ваши программы могут заменить пустые выходные символы (табуляцию и пробелы) некоторым определенным символом.
Для управления количеством цифр, выводимых выходным потоком cout для значений с плавающей точкой, ваши программы могут использовать метод cout.setprecision.
Для вывода и ввода по одному символу за один раз ваши программы могут использовать потоковые методы cout.put и cin.get.
Используя метод cin.getline, ваши программы могут вводить целую строку за один раз.
Почти любая создаваемая вами на C++ программа будет использовать cout или cin для выполнения операций В/В (ввода/вывода). Выберите время для экспериментов с программами из этого урока.

ЧТО ВНУТРИ iostream.h

Начиная с урока 1, каждая написанная вами на C++ программа включала заголовочный файл iostream.h. Этот файл содержит определения, позволяющие вашим программам использовать cout для выполнения вывода и cin для выполнения ввода. Более точно, этот файл определяет классы istream и ostream (входной поток и выходной поток), a cin и соut являются переменными (объектами) этих классов. Выберите время, чтобы напечатать файл iostream.h. Он находится в подкаталоге INCLUDE. Определения в этом файле достаточно сложны. Однако если вы пройдете по файлу медленно, то обнаружите, что большинство определений являются просто определениями классов и констант. Внутри файла вы найдете объявления переменных cin и cout.

ИСПОЛЬЗОВАНИЕ cout

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

#include <iostream.h>

#include <iomanip.h>

void main(void)

{
cout << "Мое любимое число" << setw(3) << 1001 << endl;
cout << "Мое любимое число" << setw (4) << 1001 << endl;
cout << "Мое любимое число" << setw (5) << 1001 << endl;
cout << "Мое любимое число" << setw(6) << 1001 << endl;
}

Подобным образом метод cout.width позволяет вам указать минимальное количество символов, которое будет использовать сои/для вывода следующего значения. Следующая программа COUTWIDT.CPP использует функцию cout.width для выполнения работы, аналогичной той, которую выполняет setw, что и показано ниже:

#include <iostream.h>

#include <iomanip.h>

void main (void)

{
int i;
for (i = 3; i < 7; i++)

{
cout << "Мое любимое число";
cout. width (i);
cout << 1001 << endl;
}
}

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

С:\> COUTWIDT <ENTER>

Мое любимое число1001

Мое любимое число 1001

Мое любимое число 1001

Мое любимое число 1001

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

Использование символа-заполнителя

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

Таблица информации
Профиль компании................................................ 10
Доходы и убытки компании...................................11
Члены правления компании..................................13

В данном случае вывод предваряет номера страниц точками. Функция cout.fill позволяет вам указать символ, который cout будет использовать для заполнения пустого пространства. Следующая программа COUTFILL.CPP создает таблицу, подобную приведенной выше:

#include <iostream.h>

#include <iomanip.h>

void main(void)

{
cout << "Таблица информации" << endl;
cout.fill (' . ');
cout << "Профиль компан

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

Управление цифрами значений с плавающей точкой

Если вы используете cout для вывода значения с плавающей точкой, то обычно не можете сделать каких-либо предположений о том, сколько цифр будет выводить cout no умолчанию. Однако, используя манипулятор setprecision, вы можете указать количество требуемых цифр- Следующая программа SETPREC.CPP использует манипулятор setprecision для управления количеством цифр, которые появятся справа от десятичной точки:

#include <iostream.h>

#include <iomanip.h>

void main(void)

{
float value = 1.23456;
int i;
for (i = 1; i < 6; i++) cout << setprecision(i) << value << endl;
}

Когда вы откомпилируете и запустите эту программу, на экране дисплея появится следующий вывод:

С:\>SETPREC <ENTER>

1.2

1.23

1.235

1.2346

1.23456

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

ВЫВОД И ВВОД ОДНОГО СИМВОЛА ЗА ОДИН РАЗ

В зависимости от назначения вашей программы вам, возможно, потребуется выводить символы на дисплей или читать с клавиатуры по одному символу за один раз. Для вывода одного символа за один раз ваши программы могут использовать функцию cout.put. Следующая программа COUTPUT.CPP использует эту функцию для вывода на экран сообщения Учимся программировать на языке C++! по одному символу за раз:

#include <iostream.h>

void main(void)

{
char string[] = "Учимся программировать на языке C++!";
int i;
for (i = 0; string; i++) cout.put(string) ;
}

Библиотека этапа выполнения предоставляет функцию с именем toupper, которая возвращает заглавный эквивалент строчной буквы. Следующая программа COUTUPPR.CPP использует функцию toupper для преобразования символа в верхний регистр, а затем выводит эту букву с помощью cout.put.

#include <iostream.h>

#include <ctype.h> // прототип toupper

void main(void)

{

char string[] = "Учимся программировать на языке C++!";
int i;
for (i = 0; string; i++) cout.put(string) ;
}

Библиотека этапа выполнения предоставляет функцию с именем toupper, которая возвращает заглавный эквивалент строчной буквы. Следующая программа COUTUPPR.CPP использует функцию toupper для преобразования символа в верхний регистр, а затем выводит эту букву с помощью cout.put.

#include <iostream.h>

#include <ctype.h> // прототип toupper

void main(void)

{
char string[] = "C++ language";
int i;
for (i = 0; string; i++) cout.put(toupper(string));
cout << endl << "Результирующая строка: " << string << endl;
}

Если вы откомпилируете и запустите эту программу, на экране дисплея появится следующий вывод:

С:\> COUTUPPR <ENTER>

C++ LANGUAGE

Результирующая строка: C++ language

К сожалению, функция toupper применима только к английским буквам. Прим. перев.

ЧТЕНИЕ ВВОДА С КЛАВИАТУРЫ ПО ОДНОМУ СИМВОЛУ ЗА РАЗ

Точно так же, как cout предоставляет функцию cout.put для вывода символа, cin предоставляет функцию cin.get, которая позволяет вам читать один символ данных. Чтобы воспользоваться функцией cin.get, вы просто присваиваете переменной возвращаемый этой функцией символ, как показано ниже:

letter = cin.get();

Следующая программа CIN_GET.CPP выводит сообщение, в ответ на которое вам необходимо ввести Y или N. Затем она повторяет в цикле вызов cin.get для чтения символов, пока не получит Y или N:

#include <iostream.h>

#include <ctype.h>

void main(void)

{
char letter;
cout << "Хотите продолжать? (Y/N): ";
do

{
letter = cin.get();
// Преобразовать к верхнему регистру
letter = toupper(letter);
} while ((letter != 'Y') && (letter != 'N'));
cout << endl << "Вы ввели " << letter << endl;
}

ЧТЕНИЕ С КЛАВИАТУРЫ ЦЕЛОЙ СТРОКИ

Как вы уже знаете, при использовании cin для выполнения ввода с клави

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

cin.getline(string, 64);

Когда cin.get читает символы с клавиатуры, она не будет читать символов больше, чем может вместить строка. Удобным способом определить размер массива является использование оператора C++ sizeof, как показано ниже:

сin.getline(string, sizeof(string));

Если позже вы измените размер массива, то вам не нужно будет искать и изменять каждый оператор с cin.get, встречающийся в вашей программе. Вместо этого оператор sizeof ' будет использовать корректный размер массива. Следующая программа GETLINE.CPP использует функцию cin.getline для чтения с клавиатуры строки текста:

#include <iostream.h>

void main(void)

{
char string[128];
cout << "Введите строку текста и нажмите Enter" << endl;
cin.getline(string, sizeof(string));
cout << "Вы ввели: " << string << endl;
}

Когда вы читаете символы с клавиатуры, то, возможно, вам понадобится читать символы вплоть до и включая определенный символ. Когда такой символ будет прочитан, возможно, вы захотите завершить операцию ввода. Для выполнения подобной операции ваша программа может передать искомый символ в cin.getline. Например, следующий вызов заставляет функцию cin.getline читать строку текста, пока не встретится возврат каретки, или пока не будут прочитаны 64 символа, или пока не встретится буква Я:

cin.getline(string, 64, 'Я');

Следующая программа UNTIL_Z.CPP использует cin.getline для чтения строки текста или символов вплоть до появления буквы Я (включая и эту букву):

#include <iostream.h>

void main(void)

{
char string[128];
cout << "Введите строку текста и нажмите Enter" << endl;
cin.getline(string, sizeof(string), 'Я');
cout << "Вы ввели: " << string << endl;
}

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

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Каждая созданная вами на C++ программа будет, вероятно, использовать cin или cout для выполнения операций ввода и вывода. Этот урок посвящен некоторым манипуляторам В/В и функциям, которые вы можете использовать с потоками cin и cout. По мере усложнения ваших программ они часто будут сохранять информацию в файлах. Из урока 34 вы узнаете, как в C++ выполнять операции файлового ввода и вывода. Прежде чем приступить к изучению урока 34, убедитесь, что вы освоили следующие основные концепции:

cin и cout являются объектами (переменными) классов i stream и ostream, которые определены в заголовочном файле iostream.h. А если так, они предоставляют функции, которые ваши программы могут вызывать для решения определенных задач.
Функция cout.width позволяет вашим программам указать минимальное количество символов, которые будет использовать следующее выходное значение.
Функция cout. fill позволяет вашим программам указать символ, который cout будет использовать для заполнения пустого пространства устанавливаемого с помощью cout.width или setw.
Манипулятор setprecision позволяет вашим программам управлять количеством цифр, выводимых справа от десятичной точки для значений с плавающей точкой.
Функции cin.get и cout.put позволяют вашим программам вводить или выводить один символ.
Функция cin.getline позволяет вашим программам читать строку текста с клавиатуры.

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

Для улучшения производительности за счет уменьшения издержек на вызов функции вы можете заставить компилятор C++ встроить в программу код функции, подобно тому, как это делается при замещении макрокоманд.
Используя встроенные (inline) функции, ваши программы остаются удобными для чтения (читающий программу видит вызов функции), но вы избегаете издержек на вызов функции, которые вызваны помещением параметров в стек и их последующим извлечением из стека, а также переходом к телу функции и последующим возвратом из нее.
В зависимости от требований, предъявляемых к вашей программе, иногда вам потребуется использовать язык ассемблера для решения определенной задачи.
Для упрощения применения программирования на языке ассемблера C++ позволяет определить функции на встроенном языке ассемблера внутри ваших программ на C++.
ВСТРОЕННЫЕ ФУНКЦИИ

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

#include <iostream.b>

void show_message(int count, char *message)

{
int i;
for (i = 0; i < count; i++) cout << '\a';
cout << message << endl;
}

void main(void)

{
show_message(3, "Учимся программировать на языке C++");
show_mes sage(2, "Урок 35");
}

Следующая программа NO_CALL.CPP не вызывает функцию show_message. Вместо этого она помещает внутри себя те же операторы функции при каждой ссылке на функцию:

#include <iostream.h>

void main (void)

{
int i;
for (i = 0; i < 3; i++) cout << '\a';
cout << " Учимся программировать на языке C++" << endl;
for (i = 0; i < 2; i++) cout << '\a';
cout << "Урок 35" << endl;
}

Обе программы выполняют одно и то же. Поскольку программа NO_CALL не вызывает функцию show_message, она выполняется немного быстрее, чем программа CALLBEEP. В данном случае разницу во времени выполнения определить невозможно, но, если в обычной ситуации функция будет вызываться 1000 раз, вы, вероятно, заметите небольшое увеличение производительности. Однако программа NO_CALL более запутана, чем ее двойник CALL_BEEP, следовательно, более тяжела для восприятия.

При создании программ вы всегда должны попытаться определить, когда лучше использовать обычные функции, а когда лучше воспользоваться встроенными функциями. Для более простых программ предпочтительно использовать обычные функции. Однако, если вы создаете программу, для которой производительность имеет первостепенное значение, вам следовало бы уменьшить количество вызовов функций. Один из способов уменьшения количества вызовов функций состоит в том, чтобы поместить соответствующие операторы прямо в программу, как только что было сделано в программе NO_CALL. Однако, как вы могли убедиться, замена только одной функции внесла значительную путаницу в программу. К счастью, C++ предоставляет ключевое слово inline, которое обеспечивает лучший способ.

Использование ключевого слова inline

При объявлении функции внутри программы C++ позволяет вам предварить имя функции ключевым словом inline. Если компилятор C++ встречает ключевое слово inline, он помещает в выполнимый файл (машинный язык) операторы этой функции в месте каждого ее вызова. Таким образом, можно улучшить читаемость ваших программ на C++, используя функции, и в то же время увеличить производительность, избегая издержек на вызов функций. Следующая программа INLINE.CPP определяет функции тах и min как inline:

#include <iostream.h>

inline int max(int a, int b)

{
if (a > b) return(a);
else return(b) ;
}

inline int min(int a, int b)

{
if (a < b) return(a);
else return(b);
}

void main(void)

{
cout << "Минимум из 1001 и 2002 равен " << min(1001, 2002) << endl;
cout << "Максимум из 1001 и 2002 равен " << max(1001, 2002) << endl;
}

В данном случае компилятор C++ заменит каждый вызов функции на соответствующие операторы функции. Производительность программы увеличивается без ее усложнения.

О встроенных функциях

Если компилятор C++ перед определением функции встречает ключевое слово inline, он будет заменять обращения к этой функции (вызовы) на последовательность операторов, эквивалентную выполнению функции. Таким образом ваши программы улучшают производительность, избавляясь от издержек на вызов функции и в то же время выигрывая в стиле программы, благодаря использованию функций.

ВСТРОЕННЫЕ ФУНКЦИИ И КЛАССЫ

Как вы уже знаете, при определении класса вы определяете функции этого класса внутри или вне класса. Например, класс employee определяет свои функции внутри самого класса:

class employee

{
public:
employee(char name, char position, float salary)

{
strcpy(employee::name, name);
strcpy(employee::position, position);
employee::salary = salary;
}

void show_employee(void)

{
cout << "Имя: " << name << endl;
cout << "Должность: " << position << endl;
cout << "Оклад: $" << salary << endl;
}

private:
char name [64];
char position[64];
float salary;
};

Размещая подобным образом функции внутри класса, вы тем самым объявляете их встроенными {inline). Если вы создаете встроенные функции класса этим способом, C++ дублирует функцию для каждого создаваемого объекта этого класса, помещая встроенный код при каждой ссылке на метод (функцию) класса. Преимущество такого встроенного кода состоит в увеличении производительности. Недостатком является очень быстрое увеличение объема самого определения класса. Кроме того, включение кода функции в определение класса может существенно запугать класс, делая его элементы трудными для восприятия.

Для улучшения читаемости определений ваших классов вы можете вынести функции из определения класса, как вы обычно и делаете, и разместить ключевое слово inline перед определением функции. Например, следующее определение заставляет компилятор использовать встроенные операторы для функции show_employee:

inline void employee::show_employee(void)

{
cout << "Имя: " << name << endl;
cout << "Должность: " << position << endl;
cout << "Оклад: $" << salary << endl;
}

ИСПОЛЬЗОВАНИЕ ОПЕРАТОРОВ ЯЗЫКА АССЕМБЛЕРА

ак вы знаете из урока 1, программисты могут создавать программы, используя широкий спектр языков программирования. Затем компилятор преобразует операторы программы в машинный код (нули и единицы), который понимает компьютер. Каждый тип компьютеров поддерживает промежуточный язык, называемый языком ассемблера, который попадает в категорию между машинным языком и языком программирования, таким как C++.

Язык ассемблера использует другие символы для представления инструкций машинного языка. В зависимости от назначения ваших программ, возможно, вам потребуется выполнить операции низкого уровня, для которых необходимо использовать операторы языка ассемблера. В таких случаях вы можете использовать оператор C++ asm для встраивания операторов языка ассемблера в программу. Большинство создаваемых вами программ не потребуют операторов языка ассемблера. Следующая программа USE_ASM.CPP использует оператор asm, чтобы вставить операторы языка ассемблера, необходимые для озвучивания динамика компьютера в среде MS-DOS:

#include <iostream.h>

void main(void)

{
cout << "Сейчас будет звонить!" << endl;
asm

{
MOV AH,2
MOV DL,7
INT 21H
}

cout << "Есть!" << endl;
}

Как видите, используя оператор asm, программа комбинирует C++ и операторы языка ассемблера.

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

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

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

Для улучшения производительности за счет уменьшения издержек на вызов функции вы можете заставить компилятор C++ встроить в программу код функции, подобно тому, как это делается при замещении макрокоманд.
Используя встроенные (inline) функции, ваши программы остаются удобными для чтения (читающий программу видит вызов функции), но вы избегаете издержек на вызов функции, которые вызваны помещением параметров в стек и их последующим извлечением из стека, а также переходом к телу функции и последующим возвратом из нее.
В зависимости от требований, предъявляемых к вашей программе, иногда вам потребуется использовать язык ассемблера для решения определенной задачи.
Для упрощения применения программирования на языке ассемблера C++ позволяет определить функции на встроенном языке ассемблера внутри ваших программ на C++.
ВСТРОЕННЫЕ ФУНКЦИИ

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

#include <iostream.b>

void show_message(int count, char *message)

{
int i;
for (i = 0; i < count; i++) cout << '\a';
cout << message << endl;
}

void main(void)

{
show_message(3, "Учимся программировать на языке C++");
show_mes sage(2, "Урок 35");
}

Следующая программа NO_CALL.CPP не вызывает функцию show_message. Вместо этого она помещает внутри себя те же операторы функции при каждой ссылке на функцию:

#include <iostream.h>

void main (void)

{
int i;
for (i = 0; i < 3; i++) cout << '\a';
cout << " Учимся программировать на языке C++" << endl;
for (i = 0; i < 2; i++) cout << '\a';
cout << "Урок 35" << endl;
}

Обе программы выполняют одно и то же. Поскольку программа NO_CALL не вызывает функцию show_message, она выполняется немного быстрее, чем программа CALLBEEP. В данном случае разницу во времени выполнения определить невозможно, но, если в обычной ситуации функция будет вызываться 1000 раз, вы, вероятно, заметите небольшое увеличение производительности. Однако программа NO_CALL более запутана, чем ее двойник CALL_BEEP, следовательно, более тяжела для восприятия.

При создании программ вы всегда должны попытаться определить, когда лучше использовать обычные функции, а когда лучше воспользоваться встроенными функциями. Для более простых программ предпочтительно использовать обычные функции. Однако, если вы создаете программу, для которой производительность имеет первостепенное значение, вам следовало бы уменьшить количество вызовов функций. Один из способов уменьшения количества вызовов функций состоит в том, чтобы поместить соответствующие операторы прямо в программу, как только что было сделано в программе NO_CALL. Однако, как вы могли убедиться, замена только одной функции внесла значительную путаницу в программу. К счастью, C++ предоставляет ключевое слово inline, которое обеспечивает лучший способ.

Использование ключевого слова inline

При объявлении функции внутри программы C++ позволяет вам предварить имя функции ключевым словом inline. Если компилятор C++ встречает ключевое слово inline, он помещает в выполнимый файл (машинный язык) операторы этой функции в месте каждого ее вызова. Таким образом, можно улучшить читаемость ваших программ на C++, используя функции, и в то же время увеличить производительность, избегая издержек на вызов функций. Следующая программа INLINE.CPP определяет функции тах и min как inline:

#include <iostream.h>

inline int max(int a, int b)

{
if (a > b) return(a);
else return(b) ;
}

inline int min(int a, int b)

{
if (a < b) return(a);
else return(b);
}

void main(void)

{
cout << "Минимум из 1001 и 2002 равен " << min(1001, 2002) << endl;
cout << "Максимум из 1001 и 2002 равен " << max(1001, 2002) << endl;
}

В данном случае компилятор C++ заменит каждый вызов функции на соответствующие операторы функции. Производительность программы увеличивается без ее усложнения.

О встроенных функциях

Если компилятор C++ перед определением функции встречает ключевое слово inline, он будет заменять обращения к этой функции (вызовы) на последовательность операторов, эквивалентную выполнению функции. Таким образом ваши программы улучшают производительность, избавляясь от издержек на вызов функции и в то же время выигрывая в стиле программы, благодаря использованию функций.

Как вы уже знаете, при определении класса вы определяете функции этого класса внутри или вне класса. Например, класс employee определяет свои функции внутри самого класса:

class employee

{
public:
employee(char name, char position, float salary)

{
strcpy(employee::name, name);
strcpy(employee::position, position);
employee::salary = salary;
}

void show_employee(void)

{
cout << "Имя: " << name << endl;
cout << "Должность: " << position << endl;
cout << "Оклад: $" << salary << endl;
}

private:
char name [64];
char position[64];
float salary;
};

Размещая подобным образом функции внутри класса, вы тем самым объявляете их встроенными {inline). Если вы создаете встроенные функции класса этим способом, C++ дублирует функцию для каждого создаваемого объекта этого класса, помещая встроенный код при каждой ссылке на метод (функцию) класса. Преимущество такого встроенного кода состоит в увеличении производительности. Недостатком является очень быстрое увеличение объема самого определения класса. Кроме того, включение кода функции в определение класса может существенно запугать класс, делая его элементы трудными для восприятия.

Для улучшения читаемости определений ваших классов вы можете вынести функции из определения класса, как вы обычно и делаете, и разместить ключевое слово inline перед определением функции. Например, следующее определение заставляет компилятор использовать встроенные операторы для функции show_employee:

inline void employee::show_employee(void)

{
cout << "Имя: " << name << endl;
cout << "Должность: " << position << endl;
cout << "Оклад: $" << salary << endl;
}

ИСПОЛЬЗОВАНИЕ ОПЕРАТОРОВ ЯЗЫКА АССЕМБЛЕРА

Как вы знаете из урока 1, программисты могут создавать программы, используя широкий спектр языков программирования. Затем компилятор преобразует операторы программы в машинный код (нули и единицы), который понимает компьютер. Каждый тип компьютеров поддерживает промежуточный язык, называемый языком ассемблера, который попадает в категорию между машинным языком и языком программирования, таким как C++.

Язык ассемблера использует другие символы для представления инструкций машинного языка. В зависимости от назначения ваших программ, возможно, вам потребуется выполнить операции низкого уровня, для которых необходимо использовать операторы языка ассемблера. В таких случаях вы можете использовать оператор C++ asm для встраивания операторов языка ассемблера в программу. Большинство создаваемых вами программ не потребуют операторов языка ассемблера. Следующая программа USE_ASM.CPP использует оператор asm, чтобы вставить операторы языка ассемблера, необходимые для озвучивания динамика компьютера в среде MS-DOS:

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

#include <iostream.h>

void main(void)

{
cout << "Сейчас будет звонить!" << endl;
asm

{
MOV AH,2
MOV DL,7
INT 21H
}

cout << "Есть!" << endl;
}

Как видите, используя оператор asm, программа комбинирует C++ и операторы языка ассемблера.

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

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

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

Используя выходной файловый поток, вы можете писать информацию в файл с помощью оператора вставки (<<).
Используя входной файловый поток, вы можете читать хранимую в файле информацию с помощью оператора извлечения (>>).
Для открытия и закрытия файла вы используете методы файловых классов.
Для чтения и записи файловых данных вы можете использовать операторы вставки и извлечения, а также некоторые методы файловых классов.
Многие программы, которые вы создадите в будущем, будут интенсивно использовать файлы. Выберите время для экспериментов с программами, представленными в данном уроке. И вы обнаружите, что в C++ выполнять файловые операции очень просто.

ВЫВОД В ФАЙЛОВЫЙ ПОТОК

Из урока 33 вы узнали, что cout представляет собой объект типа ostream (выходной поток). Используя класс ostream, ваши программы могут выполнять вывод в cout с использованием оператора вставки или различных методов класса, например cout.put. Заголовочный файл iostream.h определяет выходной поток cout. Аналогично, заголовочный файл f stream.h определяет класс выходного файлового потока с именем ofstream. Используя объекты класса ofstream, ваши программы могут выполнять вывод в файл. Для начала вы должны объявить объект типа ofstream, указав имя требуемого выходного файла как символьную строку, что показано ниже:

ofstream file_object("FILENAME.EXT");

Если вы указываете имя файла при объявлении объекта типа ofstream, C++ создаст новый файл на вашем диске, используя указанное имя, или перезапишет файл с таким же именем, если он уже существует на вашем диске Следующая программа OUT_FILE.CPP создает объект типа ofstream и затем использует оператор вставки для вывода нескольких строк текста в файл BOOKINFO.DAT:

#include <fstream.h>

void main(void)

{
ofstream book_file("BOOKINFO.DAT");
book_file << "Учимся программировать на языке C++, " << "Вторая редакция" << endl;
book_file << "Jamsa Press" << endl;
book_file << "22.95" << endl;
}

В данном случае программа открывает файл BOOKINFO.DAT и затем записывает три строки в файл, используя оператор вставки. Откомпилируйте и запустите эту программу. Если вы работаете в среде MS-DOS, можете использовать команду TYPE для вывода содержимого этого файла на экран:

С:\> TYPE BOOKINFO.DAT <ENTER>

Учимся программировать на языке C++, Вторая редакция

Jamsa Press

$22.95

Как видите, в C++ достаточно просто выполнить операцию вывода в файл.

ЧТЕНИЕ ИЗ ВХОДНОГО ФАЙЛОВОГО ПОТОКА

Только что вы узнали, что, используя класс ofstream, ваши программы могут быстро выполнить операции вывода в файл. Подобным образом ваши программы могут выполнить операции ввода из файла, используя объекты типа ifstream. Опять же, вы просто создаете объект, передавая ему в качестве параметра требуемое имя файла:

ifstream input_file("filename.EXT");

Следующая программа FILE_IN.CPP открывает файл BOOKINFO.DAT, который вы создали с помощью предыдущей программы, и читает, а затем отображает первые три элемента файла:

#include <iostream.h>

#include <fstream.h>

void main(void)

{
ifstream input_file("BOOKINFO.DAT") ;
char one[64], two[64], three[64];
input_file >> one;
input_file >> two;
input_file >> three;
cout << one << endl;
cout << two << endl;
cout << three << endl;
}

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

С:\> FILE_IN <ENTER>

учимся

программировать

на

Чтение целой строки файлового ввода

Из урока 33 вы узнали, что ваши программы могут использовать cin.getline для чтения целой строки с клавиатуры. Подобным образом объекты типа ifstream могут использовать getline для чтения строки файлового ввода. Следующая программа FILELINE.CPP использует функцию getline для чтения всех трех строк файла BOOKINFO.DAT:

#include <iostream.h>

#include <fstream.h>

void main(void)

{
ifstream input_file("BOOKINFO.DAT");
char one[64], two[64], three [64] ;
input_file.getline(one, sizeof(one)) ;
input_file.get line(two, sizeof(two));
input_file.getline(three, sizeof(three)) ;
cout << one << endl;
cout << two << endl;
cout << three << endl;
}

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

ОПРЕДЕЛЕНИЕ КОНЦА ФАЙЛА

Обычной файловой операцией в ваших программах является чтение содержимого файла, пока не встретится конец файла. Чтобы определить конец файла, ваши программы могут использовать функцию еоf потокового объекта. Эта функция возвращает значение 0, если конец файла еще не встретился, и 1, если встретился конец файла. Используя цикл while, ваши программы могут непрерывно читать содержимое файла, пока не найдут конец файла, как показано ниже:

while (! input_file.eof())

{
// Операторы
}

В данном случае программа будет продолжать выполнять цикл, пока функция eof возвращает ложь (0). Следующая программа TEST_EOF.CPP использует функцию eof для чтения содержимого файла BOOKINFO.DAT, пока не достигнет конца файла:

#include <iostream.h>

#include <fstream.h>

void main (void)

{
ifstream input_file("BOOKINFO.DAT");
char line[64];
while (! input_file.eof())

{
input_file.getline(line, sizeof(line));
cout << line << endl;
}
}

Аналогично, следующая программа WORD_EOF.CPP читает содержимое файла по одному слову за один раз, пока не встретится конец файла:

#include <iostream.h>

#include <fstream.h>

void main(void)

{
ifstream input_file("BOOKINFO.DAT");
char word[64] ;
while (! input_file.eof())

{
input_file >> word;
cout << word << endl;
}
}

И наконец, следующая программа CHAR_EOF.CPP читает содержимое файла по одному символу за один раз, используя функцию get, пока не встретит конец файла:

#include <iostream.h>

#include <fstream.h>

void main(void)

{
ifstream input_file("BOOKINFO.DAT");
char letter;
while (! input_file.eof())

{
letter = input_file.get();
cout << letter;
}
}

ПРОВЕРКА ОШИБОК ПРИ ВЫПОЛНЕНИИ ФАЙЛОВЫХ ОПЕРАЦИЙ

Программы, представленные до настоящего момента, предполагали, что во время файловых операций В/В не происходят ошибки. К сожалению, это сбывается не всегда. Например, если вы открываете файл для ввода, ваши программы должны проверить, что файл существует. Аналогично, если ваша программа пишет данные в файл, вам необходимо убедиться, что операция прошла успешно (к примеру, отсутствие места на диске, скорее всего, помешает записи данных). Чтобы помочь вашим программам следить за ошибками, вы можете использовать функцию fail файлового объекта. Если в процессе файловой операции ошибок не было, функция возвратит ложь (0). Однако, если встретилась ошибка, функция fail возвратит истину. Например, если программа открывает файл, ей следует использовать функцию fail, чтобы определить, произошла ли ошибка, как это показано ниже:

ifstream input_file("FILENAME.DAT");
if (input_file.fail())

{
cerr << "Ошибка открытия FILENAME.EXT" << endl;
exit(1);
}

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

#include <iostream.h>

#include <fstream.h>

void main(void)

{
char line[256] ;
ifstream input_file("BOOKINFO.DAT") ;
if (input_file.fail()) cerr << "Ошибка открытия BOOKINFO.DAT" << endl;
else

{
while ((! input_file.eof()) && (! input_file.fail()))

{
input_file.getline(line, sizeof(line)) ;
if (! input_file.fail()) cout << line << endl;
}
}
}

ЗАКРЫТИЕ ФАЙЛА, ЕСЛИ ОН БОЛЬШЕ НЕ НУЖЕН

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

input_file.close ();

Когда вы закрываете файл, все данные, которые ваша программа писала в этот файл, сбрасываются на диск, и обновляется запись каталога для этого файла.

УПРАВЛЕНИЕ ОТКРЫТИЕМ ФАЙЛА

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

ifstream output_file("FILENAME.EXT", ios::app);

В данном случае параметр ios::app указывает режим открытия файла. По мере усложнения ваших программ они будут использовать сочетание значений для режима открытия файла, которые перечислены в табл. 34.

Таблица 34. Значения режимов открытия.

Режим открытия

Назначение

ios::app
Открывает файл в режиме добавления, располагая файловый указатель в конце файла.

ios::ate Располагает файловый указатель в конце файла.
ios::in Указывает открыть файл для ввода .
ios::nocreate
Если указанный файл не существует, не создавать файл и возвратить ошибку.

ios::noreplace Если файл существует, операция открытия должна быть прервана и должна возвратить ошибку.
ios::out Указывает открыть файл для вывода.
ios::trunc Сбрасывает (перезаписывает) содержим, з существующего файла.
Следующая операция открытия файла открывает файл для вывода, используя режим ios::noreplace, чтобы предотвратить перезапись существующего файла:

ifstream output_file("FIlename.EXT", ios::out | ios::noreplace);

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

input_file.read(buffer, sizeof(buffer)) ;
output_file.write(buffer, sizeof(buffer));

Например, следующая программа STRU_OUT.CPP использует функцию write для вывода содержимого структуры в файл EMPLOYEE.DAT:

#include <iostream.h>

#include <fstream.h>

void main(void)

{
struct employee

{
char name[64];
int age;
float salary;
} worker = { "Джон Дой", 33, 25000.0 };

ofstream emp_file("EMPLOYEE.DAT") ;
emp_file.write((char ) &worker, sizeof(employee));
}

Функция write обычно получает указатель на символьную строку. Символы (char ) представляют собой оператор приведения типов, который информирует компилятор, что вы передаете указатель на другой тип. Подобным образом следующая программа STRU_IN.CPP использует метод read для чтения из файла информации о служащем:

#include <iostream.h>

#include <fstream.h>

void main(void)

{
struct employee

{
char name [6 4] ;
int age;
float salary;
} worker = { "Джон Дой", 33, 25000.0 };

ifstream emp_file("EMPLOYEE.DAT");
emp_file.read((char *) &worker, sizeof(employee));
cout << worker.name << endl;
cout << worker.age << endl;
cout << worker.salary << endl;
}

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

Заголовочный файл fstream.h определяет классы ifstream и ofstream, с помощью которых ваша программа может выполнять операции файлового ввода и вывода.
Для открытия файла на ввод или вывод вы должны объявить объект типа ifstream или ofstream, передавая конструктору этого объекта имя требуемого файла.
После того как ваша программа открыла файл для ввода или вывода, она может читать или писать данные, используя операторы извлечения (>>) и вставки (<<).
Ваши программы могут выполнять ввод или вывод символов в файл или из файла, используя функции get и put.
Ваши программы могут читать из файла целую строку, используя функцию getline.
Большинство программ читают содержимое файла, пока не встретится конец файла. Ваши программы могут определить конец файла с помощью функции eof.
Когда ваши программы выполняют файловые операции, они должны проверять состояние всех операций, чтобы убедиться, что операции выполнены успешно. Для проверки ошибок ваши программы могут использовать функцию fail.
Если вашим программам необходимо вводить или выводить такие данные, как структуры или массивы, они могут использовать методы read и write.
Если ваша программа завершила работу с файлом, его следует закрыть с помощью функции close.

Цель объектно-ориентированного программирования состоит в повторном использовании созданных вами классов, что экономит ваше время и силы. Если вы уже создали некоторый класс, то возможны ситуации, что новому классу нужны многие или даже все особенности уже существующего класса, и необходимо добавить один или несколько элементов данных или функций. В таких случаях C++ позволяет вам строить новый объект, используя характеристики уже существующего объекта. Другими словами, новый объект будет наследовать элементы существующего класса (называемого базовым классом). Когда вы строите новый класс из существующего, этот новый класс часто называется производным классом. В этом уроке впервые вводится наследование классов в C++ . К концу данного урока вы изучите следующие основные концепции:

Ели ваши программы используют наследование, то для порождения нового класса необходим базовый класс, т.е. новый класс наследует элементы базового класса.
Для инициализации элементов производного класса ваша программа должна вызвать конструкторы базового и производного классов.
Используя оператор точку, программы могут легко обращаться к элементам базового и производного классов.
В дополнение к общим (public) (доступным всем) и частным (private) (доступным методам класса) элементам C++ предоставляет защищенные (protected) элементы, которые доступны базовому и производному классам.
Для разрешения конфликта имен между элементами базового и производного классов ваша программа может использовать оператор глобального разрешения, указывая перед ним имя базового или производного класса.
Наследование является фундаментальной концепцией объектно-ориентированного программирования. Выберите время для экспериментов с программами, представленными в этом уроке. И вы обнаружите, что реально наследование реализуется очень просто и может сохранить огромные усилия, затрачиваемые на программирование.

ПРОСТОЕ НАСЛЕДОВАНИЕ

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

class employee

{
public:
employee(char , char , float);
void show_employee(void);
private:
char name[64];
char position[64];
float salary;
};

Далее предположим, что вашей программе требуется класс manager, который добавляет следующие элементы данных в класс employee:

float annual_bonus;
char company_car[64];
int stock_options;

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

Для определения этого класса вы должны указать ключевое слово class, имя manager, следующее за ним двоеточие и имя employee, как показано ниже:

Производный класс //-----> class manager : public employee { <-------// Базовый класс

// Здесь определяются элементы
};

Ключевое слово public, которое предваряет имя класса employee, указывает, что общие (public) элементы класса employee также являются общими и в классе manager. Например, следующие операторы порождают класс manager.

class manager : public employee

{
public:
manager(char , char , char , float, float, int);
void show_manager(void);
private:
float annual_bonus;
char company_car[64];
int stock_options;
};

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

Следующая программа MGR_EMP.CPP иллюстрирует использование наследования в C++ , создавая класс manager из базового класса employee:

#include <iostream.h>

#include <string.h>

class employee

{
public:
employee(char , char , float);
void show_employee(void);
private:
char name [ 64 ];
char position[64];
float salary;
};

employee::employee(char name, char position,float salary)

{
strcpy(employee::name, name);
strcpy(employee::position, position);
employee::salary = salary;
}

void employee::show_employee(void)

{
cout << "Имя: " << name << endl;
cout << "Должность: " << position << endl;
cout << "Оклад: $" << salary << endl;
}

class manager : public employee

{
public:
manager(char , char , char , float, float, int);
void show_manager(void);
private:
float annual_bonus;
char company_car[64];
int stock_options;
};

manager::manager(char name, char position, char company_car, float salary, float bonus, int stock_options) : employee(name, position, salary)

{
strcpy(manager::company_car, company_car) ;
manager::annual_bonus = bonus ;
manager::stock_options = stock_options;
}

void manager::show_manager(void)

{
show_employee();
cout << "Машина фирмы: " << company_car << endl;
cout << "Ежегодная премия: $" << annual_bonus << endl;
cout << "Фондовый опцион: " << stock_options << endl;
}

void main(void)

{
employee worker("Джон Дой", "Программист", 35000);
manager boss("Джейн Дой", "Вице-президент ", "Lexus", 50000.0, 5000, 1000);
worker.show_employee() ;
boss.show_manager();
}

Как видите, программа определяет базовый класс employee, а затем определяет производный класс manager. Обратите внимание на конструктор manager. Когда вы порождаете класс из базового класса, конструктор производного класса должен вызвать конструктор базового класса. Чтобы вызвать конструктор базового класса, поместите двоеточие сразу же после конструктора производного класса, а затем укажите имя конструктора базового класса с требуемыми параметрами:

manager::manager(char name, char position, char company_car, float salary, float bonus, int stock_options) :
employee(name, position, salary) //————————————— Конструктор базового класса

{
strcpy(manager::company_car, company_car);
manager::annual_bonus = bonus;
manager::stock_options = stock_options;
}

Также обратите внимание, что функция show_manager вызывает функцию show_employee, которая является элементом класса employee. Поскольку класс manager является производным класса employee, класс manager может обращаться к общим элементам класса employee, как если бы все эти элементы были определены внутри класса manager,

Представление о наследовании

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

Второй пример

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

class book

{
public:
book (char , char , int);
void show_book(void);
private:
char title[64];
char author[б 4];
int pages;
};

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

char catalog[64];
int checked_out; // 1, если проверена, иначе О

Ваша программа может использовать наследование, чтобы породить класс library _card из класса book, как показано ниже:

class library_card : public book

{
public:
library_card(char , char , int, char , int);
void show_card(void);
private:
char catalog[64] ;
int checked_out;
};

Следующая программа BOOKCARD.CPP порождает класс library_card из клacca book:

#include <iostream.h>

#include <string.h>

class book

{
public:
book(char , char , int);
void show_book(void);
private:
char title [64];
char author[64];
int pages;
};

book::book(char •title, char author, int pages)

{
strcpy(book::title, title);
strcpy(book::author, author);
book::pages = pages;
}

void book::show_book(void)

{
cout << "Название: " << title << endl;
cout << "Автор: " << author << endl;
cout << "Страниц: " << pages << endl;
}

class library_card : public book

{
public:
library_card(char , char , int, char , int);
void show_card(void) ;
private:
char catalog[64];
int checked_out;
};

library_card::library_card(char title, char author, int pages, char catalog, int checked_out) : book(title, author, pages)

{
strcpy(library_card::catalog, catalog) ;
library_card::checked_out = checked_out;
}

void 1ibrary_card::show_card(void)

{
show_book() ;
cout << "Каталог: " << catalog << endl;
if (checked_out) cout << "Статус: проверена" << endl;
else cout << "Статус: свободна" << endl;
}

void main(void)

{
library_card card( "Учимся программировать на языке C++", "Jamsa", 272, "101СРР", 1);
card.show_card();
}

Как и ранее, обратите внимание, что конструктор library _card вызывает конструктор класса book для инициализации элементов класса book. Кроме того, обратите внимание на использование функции-элемента show_book класса book внутри функции show_card. Поскольку класс library_card наследует методы класса book, функция show_card может вызвать этот метод (show_book) без помощи оператора точки, как если бы этот метод был методом класса library _card.

ЧТО ТАКОЕ ЗАЩИЩЕННЫЕ ЭЛЕМЕНТЫ

При изучении определений базовых классов вы можете встретить элементы, объявленные как public, private и protected (общие, частные и защищенные). Как вы знаете, производный класс может обращаться к общим элементам базового класса, как будто они определены в производном классе. С другой стороны, производный класс не может обращаться к частным элементам базового класса напрямую. Вместо этого для обращения к таким элементам производный класс должен использовать интерфейсные функции. Защищенные элементы базового класса занимают промежуточное положение между частными и общими. Если элемент является защищенным, объекты производного класса могут обращаться к нему, как будто он является общим. Для оставшейся части вашей программы защищенные элементы являются как бы частными. Единственный способ, с помощью которого ваши программы могут обращаться к защищенным элементам, состоит в использовании интерфейсных функций. Следующее определение класса book использует метку protected, чтобы позволить классам, производным от класса book, обращаться к элементам title, author и pages напрямую, используя оператор точку:

class book

{
public:
book(char , char , int) ;
void show_book(void) ;
protected:
char title [64];
char author[64];
int pages;
};

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

Защищенные элементы обеспечивают доступ и защиту

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

РАЗРЕШЕНИЕ КОНФЛИКТА ИМЕН

Если вы порождаете один класс из другого, возможны ситуации, когда имя элемента класса в производном классе является таким же, как имя элемента в базовом классе. Если возник такой конфликт, C++ всегда использует элементы производного класса внутри функций производного класса. Например, предположим, что классы book и library_card используют элемент price. В случае класса book элемент price соответствует продажной цене книги, например $22.95. В случае класса library'_card price может включать библиотечную скидку, например $18.50. Если в вашем исходном тексте не указано явно (с помощью оператора глобального разрешения), функции класса library_card будут использовать элементы производного класса {library_card). Если же функциям класса library_card необходимо обращаться к элементу price базового класса {book), они должны использовать имя класса book и оператор разрешения, например book::price. Предположим, что функции show_card необходимо вывести обе цены. Тогда она должна использовать следующие операторы:

cout << "Библиотечная цена: $" << price << endl;
cout << "Продажная цена: $" << book::price << endl;

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Из этого урока вы узнали, что наследование в C++ позволяет вам строить /порождать) новый класс из существующего класса. Строя таким способом один класс из другого, вы уменьшаете объем программирования, что, в свою очередь, экономит ваше время. Из урока 27 вы узнаете, что C++ позволяет вам порождать класс из двух или нескольких базовых классов. Использование нескольких базовых классов для порождения класса представляет собой множественное наследование. До изучения урока 27 убедитесь, что освоили следующие основные концепции:

Наследование представляет собой способность производить новый класс из существующего базового класса.
Производный класс — это новый класс, а базовый класс — существующий класс.
Когда вы порождаете один класс из другого (базового класса), производный класс наследует элементы базового класса.
Для порождения класса из базового начинайте определение производного класса ключевым словом class, за которым следует имя класса, двоеточие и имя базового класса, например class dalmatian: dog.
Когда вы порождаете класс из базового класса, производный класс может обращаться к общим элементам базового класса, как будто эти элементы определены внутри самого производного класса. Для доступа к частным данным базового класса производный класс должен использовать интерфейсные функции базового класса.
Внутри конструктора производного класса ваша программа должна вызвать конструктор базового класса, указывая двоеточие, имя конструктора базового класса и соответствующие параметры сразу же после заголовка конструктора производного класса.
Чтобы обеспечить производным классам прямой доступ к определенным элементам базового класса, в то же время защищая эти элементы от оставшейся части программы, C++ обеспечивает защищенные {protected) элементы класса. Производный класс может обращаться к защищенным элементам базового класса, как будто они являются общими. Однако для оставшейся части программы защищенные элементы эквивалентны частным.
Если в производном и базовом классе есть элементы с одинаковым именем, то внутри функций производного класса C++ будет использовать элементы производного класса. Если функциям производного класса необходимо обратиться к элементу базового класса, вы должны использовать оператор глобального разрешения, например base class:: member.

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

Объединения C++ очень похожи на структуры, за исключением того, как C++ хранит их в памяти; кроме того, объединение может хранить значение только для одного элемента в каждый момент времени.
Объединение представляет собой структуру данных, подобную структуре C++, и состоит из частей, называемых элементами.
Объединение определяет шаблон, с помощью которого программы далее объявляют переменные.
Для обращения к определенному элементу объединения ваши программы используют оператор C++ точку.
Чтобы изменить значения элемента объединения внутри функции, ваша программа должна передать переменную объединения в функцию с помощью адреса.
Анонимное объединение представляет собой объединение, у которого нет имени (тэга).
Как вы узнаете, объединения очень похожи на структуры C++, однако способ, с помощью которого C++ хранит объединения, отличается от способа, с помощью которого C++ хранит структуры.

КАК C++ ХРАНИТ ОБЪЕДИНЕНИЯ

Внутри ваших программ объединения C++ очень похожи на структуры. Например, следующая структура определяет объединение с именем distance, содержащее два элемента:

union distance

{
int miles;
long meters;
};

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

union distance

{
union distance

{
int miles; int miles;
long meters; long meters;
} japan, germany, franee;
};
distance japan, germany, franee;

Как видите, данное объединение содержит два элемента: miles и meters. Эти объявления создают переменные, которые позволяют вам хранить расстояния до указанных стран. Как и для структуры, ваша программа может присвоить значение любому элементу. Однако в отличие от структуры значение может быть присвоено только одному элементу в каждый момент времени. Когда вы объявляете объединение, компилятор C++ распределяет память для хранения самого большого элемента объединения. В случае объединения distance компилятор распределяет достаточно памяти для хранения значения типа long, как показано на рис. 19.



Рис. 19. C++ распределяет память, достаточную для хранения только самого большого элемента объединения.

Предположим, что ваша программа присваивает значение элементу miles, как показано ниже:

japan.miles = 12123;

Если далее ваша программа присваивает значение элементу meters, значение, присвоенное элементу miles, теряется.

Следующая программа USEUNION.CPP иллюстрирует использование объединения distance. Сначала программа присваивает значение элементу

miles и выводит это значение. Затем программа присваивает значение элементу meters. При этом значение элемента miles теряется:

#include <iostream.h>

void main(void)

{
union distance

{
int miles;
long meters;
} walk;

walk.miles = 5;
cout << "Пройденное расстояние в милях " << walk.miles << endl;
walk.meters = 10000;
cout << "Пройденное расстояние в метрах " << walk.meters << endl;
}

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

Объединение хранит значение только одного элемента в каждый момент времени

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

Объединение определяет шаблон, с помощью которого ваши программы могут позднее объявлять переменные. Когда компилятор C++ встречает определение объединения, он распределяет количество памяти, достаточное для хранения только самого большого элемента объединения.

ПРЕДСТАВЛЕНИЕ ОБ АНОНИМНЫХ ОБЪЕДИНЕНИЯХ C++

Анонимное объединение представляет собой объединение, у которого нет имени. C++ предоставляет анонимные объединения, чтобы упростить использование элементов объединений, предназначенных для экономии памяти или создания псевдонимов для определенного значения. Например, предположим, что вашей программе требуются две переменные miles и meters. Кроме того, предположим, что программа использует только одну из них каждый данный момент времени. В этом случае программа могла бы использовать элементы объединения, подобного уже обсуждавшемуся объединению distance, а именно name.miles и name.meters. Следующий оператор создает анонимное (безымянное) объединение:

union

{
int miles;
long meters;
};

Как видите, объявление не использует имя объединения и не объявляет переменную объединения. Программа, в свою очередь, может обращаться к элементам с именами miles и meters без помощи точки. Следующая программа ANONYM.CPP создает анонимное объединение, которое содержит элементы miles и meters. Обратите внимание, что программа трактует элементы как обычные переменные. Однако различие между элементами и обычными переменными заключается в том, что, когда вы присваиваете значение любому из этих элементов, значение другого элемента теряется:

#include <iostream.h>

void main(void)

{
union

{
int miles;
long meters;
};

miles = 10000;
cout << "Значение в милях " << miles << endl;
meters = 150000;
cout << "Значение в метрах " << meters << endl;
}

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

Анонимные объединения позволяют вашим программам экономить пространство

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

union

{
char short_name[13];
char long_name[255];
};

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Из этого урока вы узнали, как создать объединение внутри вашей программы. Вы уже поняли, что формат объединения подобен формату структуры. Однако способ, с помощью которого C++ хранит объединения, очень отличается от способа хранения структуры. Из урока 10 вы впервые узнали, что для того, чтобы функция изменила параметр, вашей программе следует передать этот параметр в функцию с помощью указателя (или адреса памяти). Начиная с десятого урока, ваши программы использовали указатели для массивов и символьных строк. В уроке 20 вы рассмотрите операции с указателями C++ с другой стороны. До изучения урока 20 убедитесь, что вы освоили следующее:

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

ак вы уже знаете, ваши программы во время выполнения хранят информацию в переменных. До сих пор каждая переменная в программе хранила только одно значение в каждый момент времени. Однако в большинстве случаев программам необходимо хранить множество значений, например 50 тестовых очков, 100 названий книг или 1000 имен файлов. Если вашим программам необходимо хранить несколько значений, они должны использовать специальную структуру данных, называемую массивом. Для объявления массива необходимо указать имя, тип массива и количество значений, которые массив будет хранить. Этот урок описывает, как программы объявляют массивы, а затем сохраняют и обращаются к информации, содержащейся в массиве. К концу данного урока вы освоите следующие основные концепции:

Массив представляет собой структуру данных, которая позволяет одной переменной хранить несколько значений.
При объявлении массива вы должны указать тип значений, хранящихся в массиве, а также количество значений (называемых элементами массива).
Все элементы внутри массива должны быть одного и того же типа, например, int, float или char.
Для сохранения значения внутри массива вам следует указать номер элемента массива, в котором вы хотите сохранить свое значение.
Чтобы обратиться к значению, хранящемуся внутри массива, ваши программы указывают имя массива и номер элемента.
При объявлении массива программы могут использовать оператор присваивания для инициализации элементов массива.
Программы могут передавать переменные-массивы в функции точно так же, как они передают любой другой параметр.
Программы на C++ широко используют массивы. Когда в уроке 17 вы начнете работать с символьными строками (например, название книги, имя файла и т. д.), вы будете оперировать массивами символов.

ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ МАССИВА

Массив представляет собой переменную, способную хранить одно или несколько значений. Подобно переменным, используемым вашими программами до сих пор, массив должен иметь тип (например, inl, char или float) и уникальное имя. В дополнение к этому вам следует указать количество значений, которые массив будет хранить. Все сохраняемые в массиве значения должны быть одного и того же типа. Другими словами, ваша программа не может поместить значения типа float, char и long в один и тот же массив. Следующее объявление создает массив с именем test_scores, который может вмещать 100 целых значений для тестовых очков:

———————————————— Тип массива

int test_scores [100] ; //------> Размер массива

Когда компилятор C++ встречает объявление этой переменной, он распределит достаточно памяти для хранения 100 значений типа int. Значения, хранящиеся в массиве, называются элементами массива.

Массивы хранят несколько значений одного и того же типа

По мере усложнения вашим программам потребуется работать с несколькими значениями одного и того же типа. Например, программы могут хранить возраст 100 служащих или стоимость 25 акций. Вместо того чтобы заставлять программу работать со 100 или с 25 переменными с уникальными именами, C++ позволяет вам определить одну переменную — массив —, которая может хранить несколько связанных значений.

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

float part_cost[50];
int employee_age[100];
float stock_prices[25];

Обращение к элементам массива

Как вы уже знаете, массив позволяет вашим программам хранить несколько значений в одной и той же переменной. Для обращения к определенным значениям, хранящимся в массиве, используйте значение индекса, которое указывает на требуемый элемент. Например, для обращения к первому элементу массива test_scores вы должны использовать значение индекса 0. Для обращения ко второму элементу используйте индекс 1. Подобно этому, для обращения к третьему элементу используйте индекс 2. Как показано на рис. 16.1, первый элемент массива всегда имеет индекс 0, а значение индекса последнего элемента на единицу меньше размера массива:



Рис. 16.1. Как C++ индексирует элементы массива.

Важно помнить, что C++ всегда использует 0 для индекса первого элемента массива, а индекс последнего элемента на единицу меньше размера массива. Следующая программа ARRAY. CPP создает массив с именем values, который вмещает пять целочисленных значений. Далее программа присваивает элементам значения 100, 200, 300, 400 и 500:

#include <iostream.h>

void main(void)

{
int values[5]; // Объявление массива
values[0] = 100;
values[1] = 200;
values[2] = 300;
values[3] = 400;
values [4] = 500;
cout << "Массив содержит следующие значения" << endl;
cout << values [0] << ' ' << values [1] << ' ' << values [2] << ' ' << values [3] << ' ' << values [4] << endl;
}

Как видите, программа присваивает первое значение элементу 0 (va lues[0]). Она также присваивает последнее значение элементу 4 (размер Массива (5) минус 1).

Использование индекса для обращения к элементам массива

Массив позволяет вашим программам хранить несколько значений внутри одной и той же переменной. Для обращения к определенному значению внутри массива программы используют индекс. Говоря кратко, значение индекса указывает требуемый элемент массива. Все массивы C++ начинаются с элемента с индексом 0. Например, следующий оператор присваивает значение 100 первому элементу массива с именем scores:

scores[0] = 100;

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

int scores[100];

В данном случае массив представляет собой элементы от scores[0] до scores[99].

Использование индексной переменной

Если ваши программы используют массив, обычной операцией является использование индексной переменной для обращения к элементам массива. Например, предположим, что переменная / содержит значение 3, следующий оператор присваивает значение 400 элементу values[3J:

values = 400;

Следующая программа SHOWARRA.CPP использует индексную переменную i внутри цикла for для вывода элементов массива. Цикл for инициализирует i нулем, так что программа может обращаться к элементу values. Цикл for завершается, когда i больше 4 (последний элемент массива):

#include <iostream.h>

void main (void)

{
int values[5]; // Объявление массива int i;
values[0] = 100;
values[1] = 200;
values[2] = 300;
values[3] = 400;
values[4] = 500;
cout << "Массив содержит следующие значения" << endl;
for (i = 0; i < 5; i++) cout << values << ' ';
}

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

for (i = 4; i >= 0; i--) cout << values << ' ';

В данном случае программа будет выводить элементы массива от большего к меньшему.

ИНИЦИАЛИЗАЦИЯ МАССИВА ПРИ ОБЪЯВЛЕНИИ

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

int values[5] = { 100, 200, 300, 400, 500 };

Подобным образом следующее объявление инициализирует массив с плавающей точкой:

float salaries[3] = { 25000.00. 35000.00, 50000.00 };

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

int values[5] = { 100, 200, 300 };

Программа не инициализирует элементы values[3] и values[4]. В зависимости от вашего компилятора, эти элементы могут содержать значение 0. Если вы не указываете размер массива, который вы инициализируете при объявлении, C++ распределит достаточно памяти, чтобы вместить все определяемые элементы. Например, следующее объявление создает массив, способяый хранить четыре целочисленных значения:

int numbers[] = { 1, 2, 3, 4 };

ПЕРЕДАЧА МАССИВОВ В ФУНКЦИИ

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

void some_function(int array[], int number_of_elements);

Следующая программа ARRAYFUN.CPP передает массивы в функцию show_array, которая использует цикл for для вывода значений массивов:

#include <iostream.h>

void show_array (int array [] , int number_of_elements)

{
int i;
for (i = 0; i < number_of_elements; i++) cout << array << ' ';
cout << endl;
}

void main(void)

{
int little_numbers[5] ={1,2,3,4,5};
int big_numbers[3] = { 1000, 2000, 3000 };
show_array(little_numbers, 5);
show_array(big_numbers, 3);
}

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

show_array(little_numbers, 5);

Следующая программа GETARRAY.CPP использует функцию get_values, ч тобы присвоить три значения массиву numbers:

#include <iostream.h>

void get_values(int array[], int number_of_elements)

{
int i;
for (i = 0; i < number_of_elements; i++)

{
cout “ "Введите значение " << i << ": ";
cin ” array ;
}
}

void main(void)

{
int numbers[3];
get_values(numbers, 3);
cout << "Значения массива" << endl;
for (int i = 0; i < 3; i++)
cout << numbers << endl;
}

Как видите, программа передает массив в функцию по имени. Функция в свою очередь присваивает массиву элементы. Из урока 10 вы узнали, что, пока ваша программа не передаст параметры в функцию с помощью адреса, функция не может изменить эти параметры. Однако, как можно заметить в данном случае, функция get_values изменяет параметр-массив numbers. Как вы узнаете из урока 20, C++ действительно передает массивы в функцию, используя указатели. Таким образом, функция может изменить элементы массива, если ей это нужно.

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

Массив представляет собой переменную, которая может хранить одно или несколько значений одного и того же типа.
Для объявления массива вам следует указать тип, имя массива, а также количество значений, хранящихся в массиве.
Значения внутри массива называются элементами массива.
Первый элемент массива хранится как элемент 0 (array[OJ), индекс последнего элемента массива на единицу меньше размера массива.
Программы часто используют индексные переменные для обращения к элементам массива.
Если функция воспринимает массив как параметр, она должна указать тип и имя, но не размер массива.
Если программа передает массив в функцию, она, как правило, передает и параметр, который сообщает функции количество элементов содержащихся в массиве.
Так как C++ передает массив в функцию с помощью адреса массива функция может изменять значения, содержащиеся в массиве.

Как вы уже знаете, ваши программы могут обращаться к частным (private) элементам класса только с помощью функций-элементов этого же класса. Используя частные элементы класса вместо общих во всех ситуациях, где это только возможно, вы уменьшаете возможность программы испортить значения элементов класса, так как программа может обращаться к таким элементам только через интерфейсные функции (которые управляют доступом к частным элементам). Однако в зависимости от использования объектов вашей программы, иногда вы можете существенно увеличить производительность позволяя одному классу напрямую обращаться к частным элементам другого. В этом случае уменьшаются издержки (требуемое время выполнения) на вызов интерфейсных функций. В подобных ситуациях C++ позволяет определить класс в качестве друга (friend} другого класса и разрешает классу-другу доступ к частным элементам этого другого класса. В этом уроке объясняется, как ваши программы могут указать, что два класса являются друзьями. К концу данного урока вы освоите следующие основные концепции:

Используя ключевое слово friend, класс может сообщить C++, кто является его другом, т. е. другими словами, что другие классы могут обращаться напрямую к его частным элементам.
Частные элементы класса защищают данные класса, следовательно, вы должны ограничить круг классов-друзей только теми классами, которым действительно необходим прямой доступ к частным элементам искомого класса.
C++ позволяет ограничить дружественный доступ определенным набором функций.
Частные (private) элементы позволяют вам защищать классы и уменьшить вероятность ошибок. Таким образом, вы должны ограничить использование классов-друзей настолько, насколько это возможно. Иногда программа напрямую может изменить значения элементов класса, это увеличивает вероятность появления ошибок.

ОПРЕДЕЛЕНИЕ ДРУЗЕЙ КЛАССА

C++ позволяет друзьям определенного класса обращаться к частным элементам этого класса. Чтобы указать C++, что один класс является другом (friend) другого класса, вы просто помещаете ключевое слово friend и имя соответствующего класса-друга внутрь определения этого другого класса. Например, приведенный ниже класс book объявляет класс librarian своим другом. Поэтому объекты класса librarian могут напрямую обращаться к частным элементам класса book, используя оператор точку:

class book

{
public:
book (char , char , char );
void show_book(void);
friend librarian;
private:
char title [64] ;
char author[64];
char catalog[64];
};

Как видите, чтобы указать друга, необходим только один оператор внутри определения класса. Например, следующая программа VIEWBOOK.CPP использует librarian в качестве друга класса book. Следовательно, функции класса librarian могут напрямую обращаться к частным элементам класса book. В данном случае программа использует функцию change_catalog класса librarian для изменения номера карточки каталога определенной книги:

#include <iostream.h>

#include <string.h>

class book

{
public:
book (char , char , char );
void show_book(void);
friend librarian;
private:
char title[64] ;
char author[64];
char catalog[64];
};

book::book(char title, char author, char •catalog)

{
strcpy(book::title, title);
strcpy(book::author, author) ;
strcpy(book::catalog, catalog);
}

void book::show_book(void)

{
cout << "Название: " << title << endl;
cout << "Автор: " << author << endl;
cout << "Каталог: " << catalog << endl;
}

class librarian

{
public:
void change_catalog(book , char );
char get_catalog(book);
};

void librarian::change_catalog(book this_book, char new_catalog)

{
strcpy(this_book->catalog, new_catalog);
}

char librarian: :get__catalog(book this_book)

{
static char catalog[64];
strcpy(catalog, this_book.catalog);
return(catalog) ;
}

void main(void)

{
book programming( "Учимся программировать на языке C++", "Jamsa", "P101");
librarian library;
programming.show_book();
library.change_catalog(&programming, "Легкий C++ 101");
programming.show_book();
}

Как видите, программа передает объект book в функцию change_catalog класса librarian по адресу. Поскольку эта функция изменяет элемент класса book, программа должна передать параметр по адресу, а затем использовать указатель для обращения к элементу этого класса. Экспериментируйте с данной программой, попробуйте удалить оператор friend из определения класса book. Поскольку класс librarian больше не имеет доступа к частным элементам класса book, компилятор C++ сообщает о синтаксических ошибках при каждой ссылке на частные данные класса book.

О друзьях класса

Обычно единственный способ, с помощью которого ваши программы могут обращаться к частным элементам класса, заключается в использовании интерфейсных функций. В зависимости от использования объектов программы иногда может быть удобным (или более эффективным с точки зрения скорости вычислений) разрешить одному классу обращаться к частным элементам другого. Для этого вы должны информировать компилятор C++, что класс является другом (friend). Компилятор, в свою очередь, позволит классу-другу обращаться к частным элементам требуемого класса. Чтобы объявить класс другом, поместите ключевое слово friend и имя класса-друга в секцию public определения класса, как показано ниже:

class abbott

{
public:
friend costello;
// Общие элементы
private:
// Частные элементы
};

Как друзья отличаются от защищенных (protected) элементов

Из урока 26 вы узнали, что в C++ существуют защищенные (protected) элементы класса, что позволяет производным классам обращаться к защищенным элементам базового класса напрямую, используя оператор точку. Помните, что к защищенным элементам класса могут обращаться только те классы, которые являются производными от данного базового класса, другими словами, классы, которые наследуют элементы базового класса (защищенные элементы класса являются как бы частными по отношению к остальным частям программы). Классы-друзья C++ обычно не связаны между собой узами наследования. Единственный способ для таких не связанных между собой классов получить доступ к частным элементам другого класса состоит в том, чтобы этот другой класс информировал компилятор, что данный класс является другом.

Как вы только что узнали, если вы объявляете один класс другом другого класса, вы обеспечиваете классу-другу доступ к частным элементам данных этого другого класса. Вы также знаете и то, что чем больше доступа к частным данным класса, тем больше шансов на внесение ошибок в программу. Следовательно, если доступ к частным данным другого класса необходим только нескольким функциям класса, C++ позволяет указать, что только определенные функции дружественного класса будут иметь доступ к частным элементам. Предположим, например, что класс librarian, представленный в предыдущей программе, содержит много разных функций. Однако предположим, что только функциям change_catalog и get_catalog необходим доступ к частным элементам класса book. Внутри определения класса book мы можем ограничить доступ к частным элементам только этими двумя функциями, как показано ниже:

class book

{
public:
book(char , char , char );
void show_book(void);
friend char librarian::get_catalog(book);
friend void librarian: :change_catalog( book , char );
private:
char title[64];
char author[ 64 ];
char catalog[64];
};

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

О функциях-друзьях

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

public:
friend class_name::function_name(parameter types);

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

Если ваша программа начинает ссылаться на один класс из другого, вы можете получить синтаксические ошибки, если порядок определения классов неверен. В данном случае определение класса book использует прототипы функций, определенные в классе librarian. Следовательно, определение класса librarian должно предшествовать определению класса book. Однако если вы проанализируете класс librarian, то обнаружите, что он ссылается на класс book:

class librarian

{
public:
void change_catalog(book , char );
char get_catalog(book);
};

Поскольку вы не можете поставить определение класса book перед определением класса librarian, C++ позволяет вам объявить класс book, тем самым сообщая компилятору, что такой класс есть, а позже определить его. Ниже показано, как это сделать:

class book; // объявление класса

Следующая программа LIMITFRI.CPP использует дружественные функции для ограничения доступа класса librarian к частным данным класса book. Обратите внимание на порядок определения классов:

#include <iostream.h>

#include <string.h>

class book;

class librarian

{
public:
void change_catalog(book , char );
char get_catalog(book);
};

class book

{
public:
book(char , char , char ) ;
void show_book (void);
friend char librarian::get_catalog(book);
friend void librarian::change_catalog( book , char );
private:
char title[64];
char author[64];
char catalog[64];
};

book::book(char title, char author, char catalog)

{
strcpy(book::title, title);
strcpy(book::author, author);
strcpy(book::catalog, catalog);
}

void book::show_book(void)

{
cout << "Название: " << title << endl;
cout << "Автор: " << author << endl;
cout << "Каталог: " << catalog << endl;
}

void librarian::change_catalog(book this_book, char new_catalog)

{
strcpy(this_book->catalog, new_catalog) ;
}

char librarian::get_catalog(book this_book)

{
static char catalog[64];
strcpy(catalog, this_book.catalog);
return(catalog) ;
}

void main(void)

{
book programming( "Учимся программировать на C++", "Jamsa", "P101");
librarian library;
programming.show_book();
library.change_catalog(&programming, "Легкий C++ 101");
programming.show_book();
}

Как видите, программа сначала использует объявление, чтобы сообщить компилятору, что класс book будет определен позже. Поскольку объявление извещает компилятор о классе book, определение класса librarian может ссылаться на класс book, который еще не определен в программе.

Что такое идентификатор класса

Идентификатор представляет собой имя, например имя переменной или класса. Если ваши программы используют дружественные классы, то может случиться, что определение одного класса ссылается на другой класс (его имя или идентификатор), о котором компилятор C++ еще ничего не знает. В таких случаях компилятор C++ будет сообщать о синтаксических ошибках. Чтобы избавиться от ошибок типа "что следует определять сначала", C++ позволяет вам включать в начало исходного текста программы объявление класса, тем самым вводя идентификатор класса:

class class_name;

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

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

Использование в ваших программах на C++ друзей позволяет одному классу обращаться к частным элементам другого класса напрямую, используя оператор точку.
Для объявления одного класса другом (friend) другого класса вы должны внутри определения этого другого класса указать ключевое слово friend, за которым следует имя первого класса.
После объявления класса другом по отношению к другому классу, все функции-элементы класса-друга могут обращаться к частным элементам этого другого класса.
Чтобы ограничить количество дружественных методов, которые могут обращаться к частным данным класса, C++ позволяет указать дружественные функции. Для объявления функции-друга вы должны указать ключевое слово friend, за которым следует прототип функции, которой, собственно, и необходимо обращаться к частным элементам класса.
При объявлении дружественных функций вы можете получить синтаксические ошибки, если неверен порядок определений классов. Если необходимо сообщить компилятору, что идентификатор представляет имя класса, который программа определит позже, вы можете использовать оператор такого вида class class_name;.

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

Исключительная ситуация (exception) представляет собой неожиданное событие — ошибку — в программе.
В ваших программах вы определяете исключительные ситуации как классы.
Чтобы заставить ваши программы следить за исключительными ситуациями, необходимо использовать оператор C++ try.
Для обнаружения определенной исключительной ситуации ваши программы используют оператор C++ catch.
Для генерации исключительной ситуации при возникновении ошибки ваши программы используют оператор C++ throw.
Если ваша программа обнаруживает исключительную ситуацию, она вызывает специальную (характерную для данной исключительной ситуации) функцию, которая называется обработчиком исключительной ситуации.
Некоторые (старые) компиляторы не поддерживают исключительные ситуации C++.
C++ ПРЕДСТАВЛЯЕТ ИСКЛЮЧИТЕЛЬНЫЕ СИТУАЦИИ КАК КЛАССЫ

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

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

class file_open_error {};
class file_read_error {};
class file_write_error {};

Позже в этом уроке вы создадите исключительные ситуации, которые используют переменные и функции-элементы класса. А пока просто поверьте, что каждая исключительная ситуация соответствует классу.

КАК ЗАСТАВИТЬ C++ ПРОВЕРЯТЬ ИСКЛЮЧИТЕЛЬНЫЕ СИТУАЦИИ

Прежде чем ваши программы могут обнаружить и отреагировать на исключительную ситуацию, вам следует использовать оператор C++ try для разрешения обнаружения исключительной ситуации. Например, следующий оператор try разрешает обнаружение исключительной ситуации для вызова функции file_соpy:

try

{
file_copy("SOURCE.ТХТ", "TARGET.ТХТ") ;
};

Сразу же за оператором try ваша программа должна разместить один или несколько операторов catch, чтобы определить, какая исключительная ситуация имела место (если она вообще была):

try

{
file_copy("SOURCE.ТХТ", "TARGET.ТХТ") ;
};

catch (file_open_error)

{
cerr << "Ошибка открытия исходного или целевого файла" << endl;
exit(1);
}

catch (file_read_error)

{
cerr << "Ошибка чтения исходного файла" << endl;
exit(1);
}

catch (file_write_error)

{
cerr << "Ошибка записи целевого файла" << endl;
exit(1);
}

Как видите, приведенный код проверяет возникновение исключительных ситуаций работы с файлами, определенных ранее. В данном случае независимо от типа ошибки код просто выводит сообщение и завершает программу. В идеале ваш код мог бы отреагировать и не так — возможно, попытаться исключить причину ошибки и повторить операцию. Если вызов функции прошел успешно и исключительная ситуация не выявлена, C++ просто игнорирует операторы catch.

ИСПОЛЬЗОВАНИЕ ОПЕРАТОРА throw ДЛЯ ГЕНЕРАЦИИ ИСКЛЮЧИТЕЛЬНОЙ СИТУАЦИИ

Сам C++ не генерирует исключительные ситуации. Их генерируют ваши программы, используя оператор C++ throw. Например, внутри функции file_copy программа может проверить условие возникновения ошибки и сгенерировать исключительную ситуацию:

void file_copy(char source, char target)

{
char line[256];
ifstream input_file(source);
ofstream output_file(target);
if (input_file.fail())
throw(file_open_error);
else
if (output_file.fail()) throw(file_open_error);
else

{
while ((! input_file.eof()) && (! input_file.fail()))

{
input_file.getline(line, sizeof(line)) ;
if (! input_file.fail()) output_file << line << endl;
else throw(file_read_error);
if (output_file.fail()) throw (file_write_error) ;
}
}
}

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

Как работают исключительные ситуации

Когда вы используете исключительные ситуации, ваша программа проверяет условие возникновения ошибки и, если необходимо, генерирует исключительную ситуацию, используя оператор throw. Когда C++ встречает оператор throw, он активизирует соответствующий обработчик исключительной ситуации (функцию, чьи операторы вы определили в классе исключительной ситуации). После завершения функции обработки исключительной ситуации C++ возвращает управление первому оператору, который следует за оператором try, разрешившим обнаружение исключительной ситуации. Далее, используя операторы catch, ваша программа может определить, какая именно исключительная ситуация возникла, и отреагировать соответствующим образом.

ОПРЕДЕЛЕНИЕ ОБРАБОТЧИКА ИСКЛЮЧИТЕЛЬНОЙ СИТУАЦИИ

Когда ваша программа генерирует исключительную ситуацию, C++ запускает обработчик исключительной ситуации (функцию), чьи операторы вы определили в классе исключительной ситуации. Например, следующий класс исключительной ситуации nuke_meltdown определяет операторы обработчика исключительной ситуации в функции nuke_meltdown:

class nuke_meltdown

{
public:
nuke_meltdown(void) { cerr << "\а\а\аРаботаю! Работаю! Работаю!" << endl; }
};

В данном случае, когда программа сгенерирует исключительную ситуацию nuke_meltdown, C++ запустит операторы функции nuke_meltdown, прежде чем возвратит управление первому оператору, следующему за оператором try, разрешающему обнаружение исключительной ситуации. Следующая программа MELTDOWN.CPP иллюстрирует использование функции nuke_meltdown. Эта программа использует оператор try для разрешения обнаружения исключительной ситуации. Далее программа вызывает функцию add_u232 c параметром amount. Если значение этого параметра меньше 255, функция выполняется успешно. Если же значение параметра превышает 255, функция генерирует исключительную ситуацию nuke_meltdown:

#include <iostream.h>

class nuke_meltdown

{
public:
nuke_meltdown(void) { cerr << "\а\а\аРаботаю! Работаю! Работаю!" << endl; }
};

void add_u232(int amount)

{
if (amount < 255) cout << "Параметр add_u232 в порядке" << endl;
else throw nuke_meltdown();
}

void main(void)

{
try

{
add_u232(255);
}
catch (nuke_meltdown)

{
cerr << "Программа устойчива" << endl;
}
}

Если вы откомпилируете и запустите эту программу, на экране дисплея появится следующий вывод:

С:\> MELTDOWN <ENTER>

Работаю! Работаю! Работаю!

Программа устойчива

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

Определение обработчика исключительной ситуации

Когда C++ обнаруживает в программе исключительную ситуацию, он запускает специальную функцию, которая называется обработчиком исключительной ситуации. Для определения обработчика исключительной ситуации вы просто создаете функцию в классе исключительной ситуации, которая имеет такое же имя, как и сама исключительная ситуация (подобно конструктору). Когда ваша программа в дальнейшем сгенерирует исключительную ситуацию, C++ автоматически вызовет соответствующий обработчик. В идеале обработчик исключительной ситуации должен выполнить операции, которые бы исправили ошибку, чтобы ваша программа могла повторить операцию, ставшую причиной ошибки. После завершения обработки исключительной ситуации выполнение вашей программы продолжается с первого оператора, следующего за оператором try, разрешившего обнаружение исключительной ситуации.

ИСПОЛЬЗОВАНИЕ ЭЛЕМЕНТОВ ДАННЫХ ИСКЛЮЧИТЕЛЬНОЙ СИТУАЦИИ

В предыдущих примерах ваши программы, используя оператор catch, могли определить, какая именно исключительная ситуация имела место, и отреагировать соответствующим образом. В идеале, чем больше информации об исключительной ситуации могут получить ваши программы, тем лучше они смогут отреагировать на ошибку. Например, в случае с исключительной ситуацией file_open_error вашей программе необходимо знать имя файла, который вызвал ошибку. Аналогично, для файловых исключительных ситуаций file_read_error или file_write_error программа, возможно, захочет узнать расположение байта, на котором произошла ошибка. Чтобы сохранить подобную информацию об исключительной ситуации, ваши программы могут просто добавить элементы данных в класс исключительной ситуации. Если в дальнейшем ваша программа сгенерирует исключительную ситуацию, она передаст эту информацию функции обработки исключительной ситуации в качестве параметра, как показано ниже:

throw file_open_error(source);
throw file_read_error(344);

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

class file_open_error

{
public:
file_open_error(char *filename) { strcpy(file_open_error::filename, filename); }
char filename[255] ;
};

ОБРАБОТКА НЕОЖИДАННЫХ ИСКЛЮЧИТЕЛЬНЫХ СИТУАЦИЙ

Из урока 11 вы узнали, что компиляторы C++ предоставляют функции библиотеки этапа выполнения, которые вы можете использовать в своих программах. Если вы читали документацию по этим функциям, то могли обратить внимание на функции, которые генерируют определенные исключительные ситуации. В таких случаях ваши программы должны проверять соответствующие исключительные ситуации. По умолчанию если ваша программа генерирует исключительную ситуацию, которая не улавливается (программа не имеет соответствующего обработчика исключительной ситуации), то запустится стандартный обработчик, предоставляемый языком C++. В большинстве случаев стандартный обработчик завершит вашу программу. Следующая программа UNCAUGHT.CPP иллюстрирует, как стандартный обработчик исключительной ситуации завершает выполнение вашей программы:

#include <iostream.h>

class some_exception { };

void main(void)

{
cout << "Перед генерацией исключительной ситуации" << endl;
throw some_exception();
cout << "Исключительная ситуация сгенерирована" << endl;
}

В данном случае, когда программа генерирует исключительную ситуацию (которая не улавливается программой), C++ вызывает стандартный обработчик исключительной ситуации, который завершает программу. Поэтому последний оператор программы, который выводит сообщение о генерации исключительной ситуации, никогда не выполняется. Вместо использования стандартного обработчика исключительной ситуации C++ ваши программы могут определить свой собственный стандартный обработчик (обработчик по умолчанию). Чтобы сообщить компилятору C++ о своем стандартном обработчике, ваши программы должны использовать функцию библиотеки этапа выполнения set_unexpected. Прототип функции set_unexpected определен в заголовочном файле except.h.

ОБЪЯВЛЕНИЕ ГЕНЕРИРУЕМЫХ ФУНКЦИЕЙ ИСКЛЮЧИТЕЛЬНЫХ СИТУАЦИЙ

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

void power_plant(long power_needed) throw (melt_down, radiation_leak);

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

ИСКЛЮЧИТЕЛЬНЫЕ СИТУАЦИИ И КЛАССЫ

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

class string

{
public:
string(char str);
void fill_string(str);
void show_string(void);
int string_length(void);
class string_empty { } ;
class string_overflow {};
private:
int length;
char string[255];
};

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

try

{
some_string.fill_string(some_long_string);
};
catch (string::string_overflow)

{
cerr << "Превышена длина строки, символы отброшены" << endl;
}

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Исключительные ситуации предназначены для упрощения и усовершенствования обнаружения и обработки ошибочных ситуаций в ваших программах. Для проверки и обнаружения исключительных ситуаций ваши программы должны использовать операторы try, catch и throw. Ваши знания исключительных ситуаций зависят от опыта программирования на C++. Прежде чем продолжить программировать на C++, убедитесь, что вы освоили следующие основные концепции:

Исключительная ситуация представляет собой неожиданную ошибку в вашей программе.
Ваши программы должны обнаруживать и обрабатывать (реагировать на) исключительные ситуации.
В программах вы определяете исключительную ситуацию как класс.
Вы должны использовать оператор try, чтобы заставить компилятор C++ разрешить обнаружение исключительных ситуаций.
Вы должны разместить оператор catch сразу же после оператора try, чтобы определить, какая именно исключительная ситуация имела место (если она вообще была).
C++ сам не генерирует исключительные ситуации. Ваши программы генерируют исключительные ситуации с помощью оператора throw.
Если ваша программа обнаруживает исключительную ситуацию, она вызывает специальную функцию, которая называется обработчиком исключительной ситуации.
Если ваши программы используют исключительные ситуации, вы можете указать в прототипе функции, что эта функция способна генерировать исключительную ситуацию.
При чтении документации по библиотеке этапа выполнения обращайте внимание на то, что некоторые функции способны генерировать исключительные ситуации.
Если ваша программа генерирует, но не улавливает (и не обрабатывает) исключительную ситуацию, C++ будет вызывать стандартный обработчик исключительной ситуации.
В заголовочном файле except.h определены прототипы функций, которые ваши программы могут использовать для указания своих собственных стандартных обработчиков не улавливаемых исключительных ситуаций.

Из урока 4 вы узнали, как объявлять и использовать переменные в своих программах. По мере усложнения программ вы будете выполнять арифметические операции, такие как сложение, вычитание, умножение и деление, над значениями, содержащимися в переменных. Данный урок описывает, как использовать арифметические операторы C++ для выполнения этих операций. К тому времени, когда вы закончите изучение данного урока, вы освоите следующие основные концепции:

Для выполнения математических операций используйте в своих программах арифметические операторы C++.
Чтобы гарантировать последовательность операций, C++ назначает приоритет каждому оператору.
Используя круглые скобки в арифметических выражениях, вы можете управлять порядком, в котором C++ выполняет операции.
Многие программы на C++ прибавляют или вычитают единицу, используя операции увеличения (++) или уменьшения (--).
После того как вы научитесь распознавать разные арифметические операторы C++, вы поймете, что выполнять математические операции очень легко!

ОСНОВНЫЕ МАТЕМАТИЧЕСКИЕ ОПЕРАЦИИ

Независимо от назначения большинство ваших программ на C++ будут складывать, вычитать, умножать или делить. Вы узнаете, что ваши программы могут выполнять арифметические операции с константами (например, 35) или с переменными (например, payment — total). Таблица 5.1 перечисляет основные математические операции C++:

Таблица 5. 1. Основные математические операции С++

Операция

Назначение

Пример

+

Сложение

total = cost + tax;

-

Вычитание

change = payment - total;

.

Умножение

tax = cost tax_rate;

/

Деление

average = total / count;

Следующая программа SHOWMATH.CPP использует cout для вывода реультата нескольких простых арифметических операций:

#include <iostream.h>

void main(void)

{
cout << "5 + 7 = " << 5 + 7 << endl;
cout << "12 - 7 = " << 12 - 7 << endl;
cout << "1.2345 2 = " << 1.23.45 2 << endl;
cout << "15 / 3 = " << 15 / 3 << endl;
}

Посмотрите внимательно на операторы программы. Обратите внимание, что каждое выражение сначала появляется в кавычках, которые обеспечивают вывод символов (например, 5 + 7 =) на экран. Затем программа выводит результат операции и символ новой строки. Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:

С:\> SHOWMATH <ENTER>

5 + 7 = 12

12 - 7 = 5

1.2345 2 = 2.469

15 / 3 = 5

В данном случае программа выполняла арифметические операции, используя только постоянные значения. Следующая программа MATHVARS.CPP выполняет арифметические операции, используя переменные:

#include <iostream.h>

void main(void)

{
float cost =15.50; // Стоимость покупки
float sales_tax = 0.06; // Налог на продажу 6%
float amount_paid = 20.00; // Деньги покупателя
float tax, change, total; // Налог на продажу, сдача покупателю и общий счет
tax = cost * sales_tax;
total = cost + tax;
change = amount_paid - total;
cout << "Стоимость покупки: $" << cost << "\tHaлor: $" << tax << "\tОбщий счет: $" << total << endl;
cout << "Сдача покупателю: $" << change << endl;
}

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

С:\> MATHVARS <ENTER>

Стоимость покупки: $15.5 Налог: $0.93 Общий счет: $16.43

Сдача покупателю: $3.57

УВЕЛИЧЕНИЕ ЗНАЧЕНИЯ ПЕРЕМЕННОЙ НА 1

Обычной операцией, которую вы будете выполнять при программировании, является прибавление 1 к значению целой переменной. Например, предположим, что ваша программа использует переменную с именем count, чтобы сохранить данные о количестве напечатанных файлов. Каждый раз, когда программа печатает файл, 1 будет добавляться к текущему значению count. Используя оператор присваивания C++, ваша программа может увеличивать значение count, как показано ниже:

count = count + 1;

В данном случае программа сначала выбирает значение count, а затем добавляет к нему единицу. Далее программа записывает результат сложения обратно в переменную count. Следующая программа INTCOUNT.CPP использует оператор присваивания для увеличения переменной count (которая первоначально содержит значение 1000) на единицу (присваивая переменной результат 1001):

#include <iostream.h>

void main(void)

{
int count = 1000;
cout << "начальное значение count равно" << count << endl;
count = count + 1;
cout << "конечное значение count равно" << count << endl;
}

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

С:\> INCCOUNT <ENTER>

начальное значение count равно 1000

конечное значение count равно 1001

Так как увеличение значения переменной представляет собой обычную операцию в программах, в C++ есть операция увеличения — двойной знак плюс (++). Операция увеличения обеспечивает быстрый способ прибавления единицы к значению переменной. Следующие операторы, например, увеличивают значение переменной count на 1:

count = count + 1; count++;

Следующая программа INC_OP.CPP использует операцию увеличения для наращивания значения переменной count на 1:

#include <iostream.h>

void main(void)

{
int count = 1000;
cout << "начальное значение count равно " << count << endl;
count++;
cout << "конечное значение count равно " << count << endl;
}

Эта программа работает так же, как INCCOUNT.CPP, которая использовала оператор присваивания для увеличения значения переменной. Когда C++ встречает операцию увеличения, он сначала выбирает значение переменной, добавляет к этому значению единицу, а затем записывает результат обратно в переменную.

Представление о префиксной (до) и постфиксной (после) операциях увеличения

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

++variable; variable++;

Так как первый оператор появляется до переменной, он называется префиксным оператором увеличения. Аналогично этому, второй оператор появляется после переменной и называется постфиксным оператором увеличения. Вам необходимо знать, что C++ трактует эти два оператора по-разному. Например, рассмотрим следующий оператор присваивания:

current_count = count++;

Этот оператор присваивания указывает C++ присвоить текущее значение count переменной current_count. В дополнение к этому постфиксный оператор увеличения заставляет C++ увеличить текущее значение count. Использование постфиксного оператора в этом случае делает показанный выше оператор эквивалентным следующим двум операторам:

current_count = count;

count = count + 1;

Теперь рассмотрим следующий оператор присваивания, который использует префиксный оператор увеличения:

current_count = ++count;

В этом случае оператор присваивания указывает C++ сначала увеличить значение count, а затем присвоить результат переменной current_count. Использование префиксного оператора увеличения делает показанный выше оператор эквивалентным следующим двум операторам:

>>92627008
Оп наебать пытается.

count = count + 1;

current_count = count;

Важно освоить префиксную и постфиксную операции увеличения, так, как они будут встречаться вам в большинстве программ на C++. Следующая программа PRE_POST.CPP иллюстрирует использование префиксной и постфиксной операций увеличения:

#include <iostream.h>

void main(void)

{
int small_count = 0;
int big_count = 1000;
cout << "small_count равно " << small_count << endl;
cout << "small_count++ производит " << small_count++ << endl;
cout << "конечное значение small_count равно " << sniall_count << endl;
cout << "big_count равно " << big_count << endl;
cout << "++big_count производит " << ++big_count << endl;
cout << "конечное значение big_count равно " << big_count << endl;
}

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

С:\> PRE_POST <ENTER>

small_count равно 0

small_count++ производит 0

конечное значение small_count равно 1

big_count равно 1000

++big_count производит 1001

конечное значение big_count равно 1001

С переменной small_count программа использует постфиксную операцию увеличения. В результате программа выводит текущее значение переменной (0), а затем увеличивает его на 1. С переменной big_count программа использует префиксную операцию увеличения. В результате программа сначала увеличивает значение переменной (1000 + 1), а затем выводит результат (1001). Найдите время, чтобы отредактировать эту программу, и сначала измените постфиксную операцию на префиксную, а затем префиксную на постфиксную. Откомпилируйте и запустите программу, обращая внимание на то, как изменение операции изменяет вывод.

С++ обеспечивает также операции уменьшения

Как вы уже знаете, двойной знак плюс (++) представляет собой оператор увеличения C++. Подобным образом двойной знак минус (--) соответствует оператору уменьшения C++, который уменьшает значение переменной на 1. Как и в случае с операцией увеличения, C++ поддерживает префиксный и постфиксный операторы уменьшения. Следующая программа DECCOUNT.CPP иллюстрирует использование оператора уменьшения C++:

#include <iostream.h>

void main(void)

{
int small_count = 0;
int big_count = 1000;
cout << "small_count равно " << small_count << endl;
cout << "small_count-- производит " << small_count-- << endl;
cout << "конечное значение small_count равно " “ small_count << endl;
cout << "big_count равно " << big_count << endl;
cout << "--big_count производит " << --big_count << endl;
cout << "конечное значение big_count равно " << big_count << endl;
}

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

С:\> DECCOUNT <ENTER”

small_count равно 0

small_count-- производит 0

конечное значение small_count равно -1

big_count равно 1000

—big_count производит 999

конечное значение big_count равно 999

Как видите, префиксный и постфиксный операторы уменьшения C++ работают так же, как и соответствующие операторы увеличения, с той лишь разницей, что они уменьшают значение переменной на 1.

ДРУГИЕ ОПЕРАТОРЫ С++

В этом уроке описаны обычные арифметические операции C++, а также операции увеличения и уменьшения. В программах на C++ вы можете встретить одну или несколько операций, перечисленных в табл. 5.2:

Таблица 5.2. Операции C++, которые вы можете встретить в программах.

Операция

Функция

%

Взятие по модулю или остаток; возвращает остаток целочисленного деления

~ Дополнение; инвертирует биты значений
& Побитовое И
| Побитовое включающее ИЛИ
^ Побитовое исключающее ИЛИ
<< Сдвиг влево; сдвигает биты значения влево на указанное количество разрядов
>> Сдвиг вправо; сдвигает биты значения вправо на указанное количество разрядов
СТАРШИНСТВО ОПЕРАЦИЙ

При выполнении арифметических операций в C++ необходимо знать, что C++ выполняет операции в определенном порядке, основанном на старшинстве операций. Например, операция умножения выполняется до сложения. Чтобы лучше понять старшинство операций, рассмотрите следующие выражения:

result =5+23;

В зависимости от порядка, в котором C++ выполняет умножение и сложение, результат будет разным:

result =5+23;
=73;
= 21;
result =5+23;
=5+6;
= 11;

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

Таблица 5.3 перечисляет старшинство операций C++. Операции, находящиеся в верхней части, имеют более высокий приоритет. Операции внутри каждой части имеют одинаковый приоритет. Если вы рассмотрите таблицу, то увидите, что в C++ умножение имеет более высокий приоритет, чем сложение. Вы не знакомы со многими операциями, представленными в таблице. В настоящее время не думайте об этих операциях. К концу изучения этой книги вы сможете использовать (и понять) каждую из них!

Таблица 5.3. Старшинство операций в C++.

Операция

Имя

Пример

:: Разрешение области видимости classname::classmember_name

::

Глобальное разрешение

::variable_name

.

Выбор элемента

object.member_name

->

Выбор элемента

pointer->membername

[]

Индексация

pointer[element]

()

Вызов функции

expression(parameters)

()

Построение значения

type(parameters)

sizeof

Размер объекта

sizeof expression

sizeof

Размер типа

sizeof(type)

++

Приращение после

variable++

++

Приращение до

++variable

--

Уменьшение после

variable--

--

Уменьшение до

-- variable

&

Адрес объекта

&variable



Разыменование

pointer

new

Создание (размещение)

new type

delete

Уничтожение (освобождение) delete pointer

delete[]

Уничтожение массива

delete pointer

~

Дополнение

~expression

!

Логическое НЕ

! expression

+

Унарный плюс

+1

-

Унарный минус

-1

()

Приведение

(type) expression

.

Выбор элемента

object.pointer

->

Выбор элемента

object->pointer



Умножение

expression * expression

/

Деление

expression / expression

%

Взятие по модулю

expression % expression

+

Сложение (плюс)

expression + expression

-

Вычитание (минус)

expression expression

Управление порядком, в котором C++ выполняет операции

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

cost = price_a + price_b 1.06;

К сожалению, в этом случае C++ сначала выполнит умножение (price_b 1.06), а затем прибавит значение price_a.

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

result =(2+3) (3+4);

C++ вычисляет данное выражение в следующем порядке:

result = (2 + 3) (3 + 4);
= (5) (3 + 4);
= 5 (7);
=57;
= 35;

Подобным образом группируя выражения внутри круглых скобок, вы можете управлять порядком, в котором C++ выполняет арифметические операции. Аналогично предыдущему примеру, ваша программа может сложить две стоимости внутри круглых скобок, как показано ниже:

cost = (price_a + price_b) 1.06;

СЛЕДИТЕ ЗА ОШИБКАМИ ПЕРЕПОЛНЕНИЯ ПРИ АРИФМЕТИЧЕСКИХ ОПЕРАЦИЯХ

Из урока 4 вы узнали, что, если вы присваиваете переменной значение, которое не входит в диапазон значений для данного типа переменной, возникает ошибка переполнения. При выполнении арифметических операций необходимо помнить о возможности возникновения ошибок переполнения. Например, следующая программа MATHOVER.CPP умножает 200 на 300 и присваивает результат переменной типа int. Однако, поскольку результат умножения (60000) превышает наибольшее возможное значение для типа int (32767), возникает ошибка переполнения:

#include <iostream.h>

void main(void)

{
int result;
result = 200 300;
cout << "200 300 = " << result << endl;
}

Когда вы откомпилируете и запустите эту программу, на экране появится следующий вывод:

С:\> MATHOVER <ENTER>

200 * 300 = -5536

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

В данном уроке вы изучали обычные арифметические операции и операции приращения C++. Чтобы программы корректно выполняли арифметические вычисления, C++ назначает каждой операции приоритет, который управляет порядком выполнения операций. Из урока 6 вы узнаете, как использовать входной поток с именем cin для выполнения операций ввода с клавиатуры. До изучения урока 6 убедитесь, что вы освоили следующее:

C++ использует операторы +,- , * и / для сложения, вычитания, умножения и деления.
C++ обеспечивает префиксные (до) и постфиксные (после) операции увеличения, которые прибавляют единицу к значению переменной.
C++ обеспечивает префиксную (до) и постфиксную (после) операции уменьшения, которые вычитают единицу из значения переменной.
Префиксные (до) операции указывают C++ сначала увеличить (или уменьшить) значение переменной, а затем использовать это значение.
Постфиксные (после) операции указывают C++ сначала использовать значение переменной, а затем увеличить (или уменьшить) его.
Чтобы гарантировать, что выражения выполняются корректно, C++ назначает каждой операции приоритет, управляющий порядком выполнения операций.
Если вам нужно управлять порядком выполнения арифметических операций, используйте круглые скобки. C++ всегда вычисляет сначала выражение в скобках.

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

• Функции группируют связанные операторы для выполнения определенной задачи.

• Ваша программа вызывает функцию, обращаясь к ее имени, за которым следуют круглые скобки, например bеер ().

• После завершения обработки большинство функций возвращают значение определенного типа, например int или float, которое программа может проверить или присвоить переменной.

• Ваши программы передают параметры (информацию) функциям, например имя, возраст или оклад служащего, заключая параметры в круглые скобки, которые следуют за именем функции.

• C++ использует прототипы функций для определения типа возвращаемого функцией значения, а также количества и типов параметров, передаваемых функции.

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

СОЗДАНИЕ И ИСПОЛЬЗОВАНИЕ ВАШИХ ПЕРВЫХ ФУНКЦИЙ

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

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

Таблица 9. Примеры смысловых имен функций.

Имя функции

Назначение функции

Print_test_scores

Печатать тестовые очки класса

Accounts_payable

Обработать счета компании

Get_user_name

Запрос имени пользователя

Print_document

Напечатать указанный документ

Calculate_income_tax

Определить подоходный налог пользователя

Функция C++ по структуре подобна программе main, которую вы использовали во всех предыдущих программах. Другими словами, имя функции предваряется ее типом, а за ним следует список параметров, описание которых появляется в скобках. Вы группируете операторы функций внутри левой и правой фигурных скобок, как показано ниже:

тип_возврата имя_функции (список_параметров)

{

объявления_переменных;
операторы;
}
Рассмотрите, например, как структура этой функции соответствует следующей программе main:

void main (void) //-----------> тип имя (список_параметров)

{
int count; // ---------------------------> объявления_переменных;
for (count = 0; count < 10; count++) cout << count << ' '; // -----> Оператор
}

Следующие операторы определяют функцию с именем show_message, которая выводит сообщение на экран, используя cout.

void show_message (void)

{
cout << "Привет, учусь программировать на C++" << endl;
}

Как вы, возможно, помните из урока 2, слово void, предшествующее имени функции, указывает функции не возвращать значение. Подобно этому, слово void, содержащееся внутри круглых скобок, указывает (компилятору C++ и программистам, читающим ваш код), что функция не использует параметры (информацию, которую программа передает функции). Следующая программа SHOW_ MSG.CPP использует функцию show_message для вывода сообщения на экран:

#include <iostream.h>

void show_message (void)

{
cout << "Привет, учусь программировать на C++" << endl;
}

void main (void)

{
cout << "Перед вызовом функции" << endl;
show_message ();
cout << "Вернулись из функции" << endl;
}

Вы уже знаете, что выполнение программы всегда начинается внутри main. Внутри main следующий оператор (вызов функции) вызывает функцию show_message:

show_message ();

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

С: \>SHOW_MSG <ENTER>

Перед вызовом функции

Привет, учусь программировать на C++

Вернулись из функции

Если программа встречает вызов функции, она начинает выполнять операторы, находящиеся внутри функции. После того как программа выполнит все операторы, которые содержит функция (другими словами, функция завершится); выполнение программы продолжается с оператора, следующего непосредственно за вызовом функции:

#include <iostream.h>

void show_message (void)

{
cout << "Привет, учусь программировать на C++" << endl;
}

void main (void)

{
cout << "Перед вызовом функции" << endl;
show_message ();
cout << "Вернулись из функции" << endl;
}

В данном случае программа выполняет первый оператор в main, которой выводит сообщение для пользователя, что программа собирается вызвать функцию. Далее программа встречает вызов функции и запускает выполнение операторов в show_messsage. После того как программа выполнит единственный оператор функции, она возвращается обратно в main и продолжает свое выполнение с оператора, непосредственно следующего за вызовом функции. В этом случае программа выводит сообщение, извещая пользователя о том, что она возвратилась из функции, и после этого заканчивает свою работу. Следующая программа TWO__MSGS.CPP использует две функции - show_title и show_lesson для вывода информации об этой книге:

#include <iostream.h>

void show_title (void)

{
cout << "Книга: Учимся программировать на C++" << endl;
}

void show_lesson (void)
{
cout << "Урок: Знакомство с функциями" << endl;
}

void main (void)
{
show_title ();
show_lesson ();
}

Когда программа начинает выполнение, она сначала вызывает функцию show_title, которая выводит сообщение с помощью cout. После завершения show_title программа вызывает функцию show_lesson, также выводящую сообщение. После завершения show_lesson программа завершается, поскольку в main больше нет операторов.

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

Вызов функции

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

function_name();

Если программа передает информацию (параметры) в функцию, она размещает эту информацию внутри круглых скобок, разделяя ее запятыми:

payroll(employee_name, employee_id, salary);

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

ПРОГРАММА МОЖЕТ ПЕРЕДАВАТЬ ИНФОРМАЦИЮ В ФУНКЦИИ

Для увеличения потенциальных возможностей ваших функций C++ позволяет программам передавать информацию (параметры) в функции. Если функция использует параметры, вы должны сообщить C++ тип каждого параметра, например int, float, char и т.д. Следующая функция show_number использует параметр типа int.

void show_number (int value)

{
cout << "Значение параметра равно " << value << endl;
}

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

show_number ( 1001 ) ; //----------------> Значение, передаваемое в функцию

C++ будет подставлять переданное число вместо каждого имени параметра value внутри функции:

show_number (1001)

void show_number (int value )

{
cout << "Значение параметра равно " << value << endl;
}

void show_number (1001)

{
cout << "Значение параметра равно " << 1001 << endl;
}

Как видите, поскольку C++ замещает значение параметра, функция show_number выводит число 1001, переданное ей главной программой.

Следующая программа USEPARAM.CPP использует функцию show_number несколько раз, каждый раз передавая разные числа:

#include <iostream.h>

void show_number (int value)

{
cout << "Значение параметра равно " << value << endl;
}

void main (void)

{
show_number (1);
show_number (1001);
show_number (-532);
}

Если вы откомпилируете и запустите эту программу, на вашем экране будет отображено следующее:

С: \>USEPARAM <ENTER>

Значение параметра равно 1

Значение параметра равно 1001

Значение параметра равно -532

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

Каждый параметр функции имеет определенный тип. В случае функции show_number параметр value должен быть типа int. Если вы попытаетесь передать в функцию значение другого типа, например с плавающей точкой, компилятор будет сообщать об ошибке. В большинстве случаев ваши программы будут передавать несколько значений в функцию. Для каждого передаваемого параметра функция должна указать имя и тип. Например, следующая программа BIGSMALL.CPP использует функцию show_big_and_little для вывода самого большого и самого маленького из трех полученных целочисленных значений:

#include <iostream.h>

void show_big_and_little (int a, int b, int c)

{
int small = a;
int big = a;

if (b > big)
big = b;

if (b < small)
small = b;

if (c > big)
big = c;

if (c < small)
small = c;

cout << "Самое большое значение равно " << big << endl;
cout << "Самое маленькое значение равно " << small << endl;
}

void main (void)

{
show_big_and_little (1, 2, 3);
show_big_and_little (500, 0, -500);
show_big_and_little (1001, 1001, 1001);
}

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

С: \> BIGSMALL <ENTER>

Самое большое значение равно 3

Самое маленькое значение равно 1

Самое большое значение равно 500

Самое маленькое значение равно -500

Самое большое значение равно 1001

Самое маленькое значение равно 1001

Наконец, следующая программа SHOW_EMP.CPP использует функцию show_employee для вывода возраста (тип int) и оклада (тип float) служащего:

#Include <iostream.h>

void show_employee (int age, float salary)

{
cout << "Возраст служащего " << age << " года (лет)" << endl;
cout << "Служащий получает $" << salary << endl;
}

void main (void)

{
show_employee (32, 25000.00);
}

Как видите, функция show_employee определяет параметры типа int и float

Передача параметров в функцию

Если ваша функция использует параметры, она должна указать уникальное имя и тип для каждого параметра. Когда программа вызывает функцию, C++ присваивает значения параметров именам параметров функции слева направо. Каждый параметр функции имеет определенный тип, например int, float или char. Значения, которые ваша программа передает в функцию, используя параметры, должны соответствовать типу параметров.

ФУНКЦИИ МОГУТ ВОЗВРАЩАТЬ РЕЗУЛЬТАТ ВЫЗВАВШЕЙ ФУНКЦИИ

Функция должна выполнять определенную задачу для вашей программы. В большинстве случаев функции будут выполнять некоторые типы вычислений. Затем функция возвратит свой результат вызвавшей функции. Когда функция возвращает значение, вы должны сообщить C++ тип значения, например int, float, char т. д. Чтобы информировать C++ о типе возвращаемого функцией значения, просто поставьте перед именем функции соответствующий тип. Например, следующая функция add_values складывает два своих целочисленных параметра и возвращает результат типа int вызвавшей программе:

int add_values (int а, int b)

{
int result;
result= а+b;
return (result);
}

В данном случае слово int, появляющееся перед именем функции, указывает тип возвращаемого значения функции. Функции используют оператор return для возврата значения вызвавшей функции. Когда ваша программа встречает оператор return, она возвращает заданное значение и завершает выполнение функции, возвращая управление вызвавшей программе. В программе вы можете использовать возвращаемое значение, как показано ниже:

result=add_values (1, 2);

В данном случае программа присваивает возвращаемое функцией значение переменной result. Ваша программа может также сразу же напечатать возвращаемое функцией значение с помощью cout, как показано ниже:

cout << "Сумма значений равна " << add_values (500, 501) << endl;

Предыдущая реализация функции add_values использовала три оператора, чтобы было легче понять смысл функции. Однако вы можете сократить функцию до единственного оператора return, как показано ниже:

int add_values (int a, int b)

{
return (a+ b);
}

Следующая программа ADDVALUE.CPP использует функцию add_values для сложения нескольких значений:

#include <iostream.h>

int add_values (int a, int b)

{
return (a+ b);
}

void main (void)

{
cout << " 100 + 200 = " << add_values(100, 200) << endl;
cout << " 500 + 501 = " << add_values(500, 501) << endl ;
cout << "-1 + 1 = " << add_values(-1, 1) << endl;
}

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

Не все функции возвращают значение типа int. Следующая функция average_ value возвращает среднее двух целочисленных значений, которое может быть дробным, например 3.5:

float average_value(int a, int b)

{
return( (a + b) / 2.0);
}

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

ФУНКЦИИ, КОТОРЫЕ НЕ ВОЗВРАЩАЮТ ЗНАЧЕНИЕ

Если функция не возвращает значение, вам необходимо предварить имя функции типом void. В противном случае вы должны предварять имя функции типом возвращаемого функцией значения, например, int, float, char и т. д. Чтобы возвратить значение вызвавшей функции, функция использует оператор return. Когда ваша программа встречает оператор return, выполнение функции завершается и указанное значение возвращается вызвавшей функции. Возможны ситуации, когда вы встретите оператор return в функции, которая не возвращает значение:

return;

В этом случае функция имеет тип void (не возвращает значение) и оператор return просто завершает выполнение функции.

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

ИСПОЛЬЗОВАНИЕ ВОЗВРАЩАЕМОГО ФУНКЦИЕЙ ЗНАЧЕНИЯ

Когда функция возвращает значение, вызвавшая программа может присвоить возвращенное значение переменной, используя оператор присваивания, как показано ниже:

payroll_amount = payroll (employee, hours, salary);

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

cout << "Служащий получил" << payroll(employee, hours, salary) < < endl;

Вызвавшая функция может также использовать возвращаемое значение в условии, как показано ниже:

if (payroll(employee, hours, salary) < 500.00)
cout << "Этот служащий нуждается в повышении" << endl;

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

ПРЕДСТАВЛЕНИЕ О ПРОТОТИПАХ ФУНКЦИЙ

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

void show_message(void);

void show_number(int);

void show_employee(int, float);

int add_values(int, int);

float average_value(int, int);

Как видите, прототип функции указывает тип возвращаемого значения, а также количество и тип каждого параметра. Обратите внимание на точку с запятой в конце каждого прототипа.

>>92627292
Это вирус, не ставьте пацаны.

float average_value ( int, int) ;

Если ваша программа вызывает функцию, для которой компилятор C++ не нашел определения или прототипа, компилятор сообщает о синтаксической ошибке. При исследовании заголовочных файлов C++ или других программ вы будете постоянно сталкиваться с прототипами функций. Следующая программа PROTO.CPP иллюстрирует использование прототипа Функции:

#include <iostream.h>

float average_value(int, int); // Прототип функции

void main(void)

{
cout << "Среднее значение 2000 и 2 равно " << average_value(2000, 2) << endl;
}

float average_value (int a, int b)

{
return((a + b) / 2.0);
}

В этом случае программа вызывает функцию average_value до того, как функция определена. Таким образом, программа использует прототип функции, который предваряет определение main. Если вы удалите прототип функции и откомпилируете эту программу, компилятор C++ будет сообщать о синтаксических ошибках.

Использование прототипов функций

Прототип функции сообщает компилятору C++ тип возвращаемого значения, а также количество и тип параметров функции. Когда вы компилируете вашу программу, компилятор C++ использует прототип каждой функции, чтобы убедиться, что вы не перепутали тип возвращаемого функцией значения (например, не присваиваете возвращаемое значение типа float переменной типа int) и что вы не передаете в качестве параметра значение неверного типа. Раньше многие компиляторы C++ не выполняли подобную проверку. В результате программисты часто тратили часы, пытаясь найти ошибки, возникающие из-за того, что вместо ожидаемого значения типа float в функцию передавалось значение типа int. Если вы встречаете синтаксическую ошибку, которая возникает из-за противоречия с прототипом функции, будьте благодарны. В прошлом компилятор не определял подобную ошибку, и ваша программа просто не работала.

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

По мере усложнения ваших программ вам следует делить их на небольшие легко управляемые части, называемые функциями. Каждая функция должна иметь уникальное имя. Присваивайте вашим функциям имена, выражающие смысл задач, которые выполняют функции.
Функции могут возвращать значение вызвавшей функции. При этом вы должны указать тип возвращаемого функцией значения (int, char и т. д.) до имени функции, в противном случае вы должны предварять имя функции словом void.
Программы передают информацию в функции с помощью параметров. Если функция получает параметры, вы должны указать уникальное имя и тип каждого параметра. Если функция не получает параметры, вы должны поместить ключевое слово void внутри круглых скобок, следующих за именем функции.
C++ должен знать тип возвращаемого значения и количество и тип параметров, которые получает функция. Если определение функции следует за использованием функции, вы должны поместить прототип функции в начале исходного файла.

>>92627333
Оп наебщик просто, троянов пропихивает, куда модеры смотрят.

При определении функций в своих программах вы должны указать тип возвращаемого функцией значения, а также количество параметров и тип каждого из них. В прошлом (если вы программировали на языке С), когда у вас была функция с именем add_values, которая работала с двумя целыми значениями, а вы хотели бы использовать подобную функцию для сложения трех целых значений, вам следовало создать функцию с другим именем. Например, вы могли бы использовать add_two_values и add_three_values. Аналогично если вы хотели использовать подобную функцию для сложения значений типа float, то вам была бы необходима еще одна функция с еще одним именем. Чтобы избежать дублирования функции, C++ позволяет вам определять несколько функций с одним и тем же именем. В процессе компиляции C++ принимает во внимание количество аргументов, используемых каждой функцией, и затем вызывает именно требуемую функцию. Предоставление компилятору выбора среди нескольких функций называется перегрузкой. В этом уроке вы научитесь использовать перегруженные функции. К концу данного урока вы освоите следующие основные концепции:

• Перегрузка функций позволяет вам использовать одно и то же имя для нескольких функций с разными типами параметров.

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

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

ПЕРВОЕ ЗНАКОМСТВО С ПЕРЕГРУЗКОЙ ФУНКЦИЙ

Перегрузка функций позволяет вашим программам определять несколько функций с одним и тем же именем и типом возвращаемого значения. Например, следующая программа перегружает функцию с именем add_values. Первое определение функции складывает два значения типа int. Второе определение функции складывает три значения. В процессе компиляции C++ корректно определяет функцию, которую необходимо использовать:

#include <iostream.h>

int add_values(int a,int b)

{
return(a + b);
)

int add_values (int a, int b, int c)

(
return(a + b + c);
)

void main(void)

{
cout << "200 + 801 = " << add_values(200, 801) << endl;
cout << "100 + 201 + 700 = " << add_values(100, 201, 700) << endl;
}

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

Подобным образом следующая программа MSG_OVR.CPP перегружает функцию show_message. Первая функция с именем show_message выводит стандартное сообщение, параметры ей не передаются. Вторая выводит передаваемое ей сообщение, а третья выводит два сообщения:

#include <iostream.h>

void show_message(void)

{
cout << "Стандартное сообщение: " << "Учимся программировать на C++" << endl;
}

void show_message(char message)

{
cout << message << endl;
}

void show_message(char first, char *second)

{
cout << first << endl;
cout << second << endl;
}

void main(void)

{
show_message();
show_message("Учимся программировать на языке C++!");
show_message("B C++ нет предрассудков!","Перегрузка - это круто!") ;
}

КОГДА НЕОБХОДИМА ПЕРЕГРУЗКА

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

int day_of_week(int julian_day)

{
// Операторы
}

int day_of_week(int month, int day, int year)

{
// Операторы
}

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

Перегрузка функций улучшает удобочитаемость программ

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

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

• Для объявления и инициализации ссылки внутри программы объявите переменную, размещая амперсанд (&) сразу же после типа переменной, и затем используйте оператор присваивания для назначения псевдонима, например int& alias_name = variable',.

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

• Внутри функции вам следует объявить параметр как ссылку, размещая амперсанд (&) после типа параметра, затем можно изменять значение параметра внутри функции без помощи указателей.

Как вы узнаете, использование указателей очень упрощает изменение значений параметров внутри функции.

ССЫЛКА ЯВЛЯЕТСЯ ПСЕВДОНИМОМ

Ссылка C++ позволяет создать псевдоним (или второе имя) для переменных в вашей программе. Для объявления ссылки внутри программы укажите знак амперсанда (&) непосредственно после типа параметра. Объявляя ссылку, вы должны сразу же присвоить ей переменную, для которой эта ссылка будет псевдонимом, как показано ниже:

int& alias_name = variable; //---> Объявление ссылки

После объявления ссылки ваша программа может использовать или переменную , или ссылку:

alias_name = 1001;
variable = 1001;

Следующая программа SHOW_REF.CPP создает ссылку с именем alias_name и присваивает псевдониму переменную number. Далее программа использует как ссылку, так и переменную:

#include <iostream.h>

void main(void)

{
int number = 501;
int& alias_name = number; // Создать ссылку
cout << "Переменная number содержит " << number << endl;
cout << "Псевдоним для number содержит " << alias_name << endl;
alias_name = alias_name + 500;
cout << "Переменная number содержит " << number << endl;
cout << "Псевдоним для number содержит " << alias_name << endl;
}

Как видите, программа прибавляет 500 к ссылке alias_name. В итоге программа прибавляет 500 также и к соответствующей переменной number, для которой ссылка служит псевдонимом или вторым именем. Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:

С:\> SHOW_REF <ENTER>

Переменная number содержит 501

Псевдоним для number содержит 501

Переменная number содержит 1001

Псевдоним для number содержит 1001

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

Объявление ссылки

Ссылка C++ представляет собой псевдоним (второе имя), которое ваши программы могут использовать для обращения к переменной. Для объявления ссылки поставьте амперсанд (&) сразу же после типа переменной, а затем укажите имя ссылки, за которым следует знак равенства и имя переменной, для которой ссылка является псевдонимом:
float& salary_alias = salary;

СПОЛЬЗОВАНИЕ ССЫЛОК В КАЧЕСТВЕ ПАРАМЕТРОВ

Основное назначение ссылки заключается в упрощении процесса изменения параметров внутри функции. Следующая программа REFERENC.CPP присваивает ссылку с именем number_alias переменной number. Программа передает ссылку на переменную в функцию change_value, которая присваивает переменной значение 1001:

#include <iostream.h>

void change_value(int &alias)

{
alias = 1001;
}

void main(void)

{
int number;
int& number_alias = number;
change_value(number_alias);
out << "Переменная number содержит " << number << endl;
}

Как вы видите, программа передает ссылку в функцию change_value. Если вы рассмотрите объявление функции, вы обнаружите, что change_value объявляет параметр alias как ссылку на значение типа int.

void change_value(int& alias)

Внутри функции change_value можете изменять значение параметра без помощи указателя. В результате звездочка () не используется и операция внутри функции становится легче для понимания.

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

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

В уроке 10 вы использовали следующую функцию для перестановки двух значений с плавающей точкой:

void swap_values(float a, float b)

{
float temp;
temp = a;
a = b;
*b = temp;
}

Как видите, функция комбинирует переменные-указатели с переменными-неуказателями. Следующая программа SWAP_REF.CPP использует ссылки на значения с плавающей точкой для упрощения функции:

#include <iostream.h>

void swap_values(float& a, float& b)
{ float temp;
temp = a;
a = b;
b = temp;
}

void main(void)

{ float big = 10000.0;
float small = 0.00001;
float& big_alias = big;
float& small_alias = small;
swap_values(big_alias, small_alias);
cout << "Big содержит " << big << endl;
cout << "Small содержит " << small << endl;
}

Как видите, функцию swap_values сейчас легче понять, однако ваша программа имеет теперь два дополнительных имени (ссылки big_alias и small_alias), за которыми вы должны следить.

ПРАВИЛА РАБОТЫ СО ССЫЛКАМИ

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

• Вы не можете получить адрес ссылки, используя оператор адреса C++.

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

• Вы не можете сравнить значения ссылок, используя операторы сравнения C++.

• Вы не можете выполнить арифметические операции над ссылкой, например добавить смещение.

•Вы не можете изменить ссылку.

По мере использования объектно-ориентированного программирования на C++ вы вернетесь к ссылкам.

Использование ссылок для изменения параметров функции

Из урока 10 вы узнали, что ваши программы с помощью указателей могут изменять значение параметров внутри функции. Для изменения параметра вы должны передать его адрес в функцию. Чтобы получить адрес параметра, используйте оператор адреса C++ (&). В свою очередь функция использует переменные-указатели (которые хранят адрес памяти). Для объявления переменной-указателя внутри функции предваряйте имя параметра звездочкой (). Чтобы изменить или использовать значение параметра внутри функции, предваряйте каждое обращение к имени этого параметра оператором разыменования C++ (). К сожалению, многие операции внутри функции комбинируют переменные-указатели и переменные-неуказатели.
Ссылки C++ упрощают процесс изменения параметров функции, избавляя от операторов, которые смешивают переменные-указатели и переменные-неуказатели.

ЧТ0 ВАМ НЕОБХОДИМО ЗНАТЬ

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

Ссылка C++ является псевдонимом (или вторым именем) переменной.
Для объявления ссылки поместите знак амперсанда (&) непосредственно после типа переменной, а затем укажите имя ссылки, за которым следует знак равенства и имя переменной, для которой ссылка является псевдонимом.
Если вы однажды присвоили ссылке значение, вы не можете его изменить.
Вам следует помещать несколько комментариев до и внутри функций, которые используют ссылки для изменения значений параметра, чтобы другие программисты, читающие ваш код, сразу обратили, на это внимание.
Чрезмерное использование ссылок может привести к слишком трудному для понимания программному коду.

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

Перегрузка оператора состоит в изменении смысла оператора (например, оператора плюс (+), который обычно в C++ используется для сложения) при использовании его с определенным классом. В данном уроке вы определите класс string и перегрузите операторы плюс и минус. Для объектов типа string оператор плюс будет добавлять указанные символы к текущему содержимому строки. Подобным образом оператор минус будет удалять каждое вхождение указанного символа из строки. К концу данного урока вы изучите следующие основные концепции:

Вы перегружаете операторы для улучшения удобочитаемости ваших программ, но перегружать операторы следует только в том случае, если это упрощает понимание вашей программы.
Для перегрузки операторов программы используют ключевое слово C++ operator.
Переопределяя оператор, вы указываете функцию, которую C++ вызывает каждый раз, когда класс использует перегруженный оператор. Эта функция, в свою очередь, выполняет соответствующую операцию.
Если ваша программа перегружает оператор для определенного класса, то смысл этого оператора изменяется только для указанного класса, оставшаяся часть программы будет продолжать использовать этот оператор для выполнения его стандартных операций.
C++ позволяет перегружать большинство операторов, за исключением четырех, перечисленных в таблице 24, которые программы не могут перегружать.
Перегрузка операторов может упростить наиболее общие операции класса и улучшить читаемость программы. Найдите время для эксперимента с программами, представленными в этом уроке, и вы обнаружите, что перегрузка операторов выполняется очень просто.

ПЕРЕГРУЗКА ОПЕРАТОРОВ ПЛЮС И МИНУС

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

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

class string

{
public:
string(char ); // Конструктор
void str_append(char );
void chr_minus(char);
void show_string(void);
private:
char data[256] ;
};

Как видите, класс определяет функцию str_append, которая добавляет указанные символы к содержимому строки класса. Аналогичным образом функция chr_minus - удаляет каждое вхождение указанного символа из строки класса. Следующая программа STRCLASS.CPP использует класс string для создания двух объектов символьных строк и манипулирования ими.

#include <iostream.h>

#include <string.h>

class string

{
public:
string(char ); // Конструктор
void str_append(char );
void chr_minus(char);
void show_string(void);
private:
char data[256] ;
};

string::string(char str)

{
strcpy(data, str);
}

void string::str_append(char str)

{
strcat(data, str);
}

void string::chr_minus(char letter)

{
char temp[256] ;
int i, j;
for (i = 0, j = 0; data; i++) // Эту букву необходимо удалить?
if (data != letter) // Если нет, присвоить ее temp
temp[j++] = data;
temp[j] = NULL; // Конец temp
// Копировать содержимое temp обратно в data
strcpy(data, temp);
}

void string::show_string(void)

{
cout << data << endl;
}

void main(void)

{
string title( "Учимся программировать на языке C++");
string lesson("Перегрузка операторов");
title.show_string() ;
title.str_append(" я учусь!");
itle.show_string();
lesson.show_string();
lesson.chr_minus('p') ;
lesson.show_string();
}

Как видите, программа использует функцию str_append для добавления символов к строковой переменной title. Программа также использует функцию chr_minus для удаления каждой буквы " р" из символьной строки lesson. В данном случае программа использует вызовы функции для выполнения этих операций. Однако, используя перегрузку операторов, программа может выполнять идентичные операции с помощью операторов плюс (+) и минус (-).

При перегрузке оператора используйте ключевое слово C++ operator вместе с прототипом и определением функции, чтобы сообщить компилятору C++, что класс будет использовать этот метод как оператор. Например, следующее определение класса использует ключевое слово operator, чтобы назначить операторы плюс и минус функциям str_append и chr_minus внутри класса string:

class string

{
public:
string(char ); // Конструктор
void operator +(char );
void operator -(char); ————— Определение операторов класса void show_string(void);
private:
char data[256];
};

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

void string::operator +(char str)

{
strcat(data, str);
}

Как видите, определение этой функции не содержит имени, поскольку здесь определяется перегруженный оператор класса. Для перегрузки оператора плюс программа не изменила обработку, которая осуществляется внутри функции (код этой функции идентичен коду предыдущей функции str_append). Вместо этого программа просто заменила имя функции ключевым словом operators соответствующим оператором. Следующая программа OPOVERLD.CPP иллюстрирует использование перегружаемых операторов плюс и минус:

#include <iostream.h>

#include <string.h>

class string

{
public:
string(char ); // Конструктор
void operator +(char );
void operator -(char);
void show_string(void);
private;
char data[256] ;
};

string::string(char str)

{
strcpy(data, str);
}

void string::operator +(char *str)

{
strcat(data, str);
}

void string::operator -(char letter)

{
char temp[256] ;
int i, j;
for (i = 0, j = 0; data; i++) if (data[il 1= letter) temp[j++] = data;
temp[j] = NULL;
strcpy(data, temp);
}

void string::show_string(void)

{
cout << data << endl;
}

void main(void)

{
string title( "Учимся программировать на C++");
string lesson("Перегрузка операторов");
title.show_string();
title + " я учусь!";
title.show_string() ;
lesson.show_string();
lesson - 'P';
lesson.show_string();
}

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

title + " я учусь!"; // Добавить текст " я учусь!"

lesson - 'р'; // Удалить букву 'р'

В данном случае синтаксис оператора законен, но немного непривычен. Обычно вы используете оператор плюс в выражении, которое возвращает результат, например, как в операторе some_str = title + "текст ";. Когда вы определяете оператор, C++ предоставляет вам полную свободу в отношении поведения оператора. Однако, как вы помните, ваша цель при перегрузке операторов состоит в том, чтобы упростить понимание ваших программ. Поэтому следующая программа STR_OVER.CPP немного изменяет предыдущую программу, чтобы позволить ей выполнять операции над переменными типа string, используя синтаксис, который более согласуется со стандартными операторами присваивания:

#include <iostream.h>

#include <string.h>

class string

{
public:
string(char ); // Конструктор
char operator +(char ) ;
char operator -(char);
void show_string(void);
private:
char data[256] ;
} ;

string::string(char str)

{
strcpy(data, str);
}

char string::operator +(char str)

{
return(strcat(data, str));
}

char string::operator -(char letter)

{
char temp[256];
int i, j;
for (i = 0, j = 0; data; i++) if (data 1= letter) temp[j++] = data;
temp[j] = NULL;
return(strcpy(data, temp));
}

void string::show_string(void)

{
cout << data << endl;
}

void main(void)

{
string title("Учимся программировать на C++");
string lesson("Перегрузка операторов");
title.show_string();
title = title + " я учусь";
title.show_string() ;
lesson.show_string();
lesson = lesson - '?';
lesson.show_string();
}

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

title = title + " учимся программировать!";

lesson = lesson - 'р';

Второй пример

При создании ваших собственных типов данных с помощью классов наиболее общей операцией будет проверка, являются ли два объекта одинаковыми. Используя перегрузку, ваши программы могут перегрузить операторы равенства (==), неравенства (!=) или другие операторы сравнения. Следующая программа COMP_STR.CPP добавляет новый оператор в класс string, который проверяет, равны ли два объекта string. Используя перегрузку операторов, ваши программы могут проверять, содержат ли строковые объекты одинаковые строки, как показано ниже:

if (some_string == another_string)

Ниже приведена реализация программы COMP_STR.CPP:

#include <iostream.h>

#include <string.h>

class string

{
public:
string(char ); // конструктор
char operator +(char );
char operator -(char);
int operator ==(string);
void show_string(void);
private:
char data[256];
};

string::string(char str)

{
strcpy(data, str);
}

char string::operator +(char str)

{
return(strcat(data, str));
}

char string::operator -(char letter)

{
char temp[256];
int i, j;
for (i = 0, j = 0; data; i++) if (data 1= letter) temp[j++] = data;
temp[j] = NULL;
return(strcpy(data, temp));
}

int string::operator ==(string str)

{
int i;
for (i = 0; data == str.data; i++)
if ((data == NULL) && (str.data == NULL)) return(1); // Равно
return (0); //He равно
}

void string::show_string(void)

{
cout << data << endl;
}

void main(void)

{
string title( "Учимся программировать на C++");
string lesson("Перегрузка операторов");
string str( "Учимся программировать на C++");
if (title == lesson) cout << "title и lesson равны" << endl;
if (str == lesson) cout << "str и lesson равны" << endl;
if (title == str) cout << "title и str равны" << endl;
}

Как видите, перегружая операторы подобным образом, вы упрощаете понимание ваших программ.

ОПЕРАТОРЫ, КОТОРЫЕ Вbl HE МОЖЕТЕ ПЕРЕГРУЗИТЬ

В общем случае ваши программы могут перегрузить почти все операторы С++. В табл. 24 перечислены операторы, которые C++ не позволяет перегружать.

Таблица 24. Операторы C++, которые ваши программы не могут перегрузить.

Оператор



Назначение

Пример

. Выбор элемента object.member
. Указатель на элемент object.member
:: Разрешение области видимости classname::member
?:

Условный оператор сравнения

с = (а > b) ? а : b;
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

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

Чтобы перегрузить оператор, вы должны определить класс, которому оператор будет назначен.
Когда вы перегружаете оператор, перегрузка действует только для класса, в котором он определяется. Если программа использует оператор с неклассовыми переменными (например, переменными типа int или float), используется стандартное определение оператора.
Чтобы перегрузить оператор класса, используйте ключевое слово C++ operator для определения метода класса, который C++ вызывает каждый раз, когда переменная класса использует оператор.
C++ не позволяет вашим программам перегружать оператор выбора элемента (.), оператор указателя на элемент (.*), оператор разрешения области видимости (::) и условный оператор сравнения (?:).

ASCII ( от англ. American Standard Code for Information Interchange) — американский стандартный код для обмена информацией. ASCII представлена в виде таблицы печатных символов и некоторых специальных управляющих символов, каждому символу соответствует уникальный код в диапазоне от [0;255]. ASCII представляет собой кодировку для представления десятичных цифр, латиницы и кириллицы, знаков препинания и управляющих символов (см. Таблица 1).

Таблица 1 — Таблица символов ASCII
№ 0 1 2 3 4 5 6 7 8 9
0 nul sox stx etx eot enq ack bel bs ht
1 nl vt ff cr so si dle dc1 dc2 dc3
2 dc4 nak syn etb can em sub esc fs gs
3 rs us space ! « # $ % & ‘
4 ( ) + , - . / 0 1
5 2 3 4 5 6 7 8 9 : ;
6 < = > ? @ A B C D E
7 F G H I J K L M N O
8 P Q R S T U V W X Y
9 Z [ \ ] ^ _ ‘ a b c
10 d e f g h i j k l m
11 n o p q r s t u v w
12 x y z { | } ~ del А Б
13 В Г Д Е Ж З И Й К Л
14 М Н О П Р С Т У Ф Х
15 Ц Ч Ш Щ ъ Ы Ь Э Ю Я
16 а б в г д е ж з и й
17 к л м н о п
18
19
20
21
22 р с т у ф х
23 ц ч ш щ ъ ы ь э ю я
24 Ё ё Є є Ї ї Ў ў ° ·
25 · № ¤
Таблица 1 представляет собой полный набор символов ASCII. В таблице ASCII, символы с нулевого по 31 включительно, являются управляющими ASCII символами. Это значит, что данные символы выполняют некоторые действия, причём эти символы печатаются с сочетанием клавиши Ctrl. В таблице 1 записано обозначение управляющих ASCII символов, но не их отображение при печати. Остальные же символы с 32 по 254 не являются управляющими и имеют вид как и в таблице 1.

Благодаря таблице ASCII появилась новая форма представления изображений, с помощью символов таблицы ASCII.

ASCII art — форма изобразительного искусства, использующая символы ASCII для представления изображений. При создании такого изображения используются символы букв, цифр и знаков пунктуации. В ASCII art используется около 95 символов таблицы ASCII. Так как национальные представления таблиц ASCII различаются, поэтому остальные 160 символов не используются в искусстве ASCII.

1
2
3
4
5
6
7
8
9
10
// искусство ASCII (ASCII art)надпись сгенерирована программой
/ __ __
/\ \__ /\ \ __
___ _____ _____ ____\ \ ,_\ __ __ \_\ \ /\_\ ___ ___ ___ ___ ___
/'___\/\ '__`\ /\ '__`\ /',__\\ \ \/ /\ \/\ \ /'_` \\/\ \ / __`\ /'___\ / __`\ /' __` __`\
/\ \__/\ \ \L\ \\ \ \L\ \/\__, `\\ \ \_\ \ \_\ \/\ \L\ \\ \ \ /\ \L\ \ __ /\ \__/ /\ \L\ \/\ \/\ \/\ \
\ \____\\ \ ,__/ \ \ ,__/\/\____/ \ \__\\ \____/\ \___,_\\ \_\\ \____//\_\\ \____\\ \____/\ \_\ \_\ \_\
\/____/ \ \ \/ \ \ \/ \/___/ \/__/ \/___/ \/__,_ / \/_/ \/___/ \/_/ \/____/ \/___/ \/_/\/_/\/_/
\ \_\ \ \_\
\/_/ \/_/ */
Изначально ASCII art выполнялось вручную, и это была рутинная работа. Сейчас существует огромное количество программ, так называемых, генераторов ASCII art. Такие программы автоматически создают ASCII изображения.

В некоторых источниках говорится, что оператор выбора if else — самостоятельный оператор. Но это не так, if else — это всего лишь форма записи оператора выбора if. Оператор if else позволяет определить программисту действие, когда условие истинно и альтернативное действие, когда условие ложно. Тогда как if позволял определить действие при истинном условии.

Синтаксис записи оператора выбора if else:

1
2
3
4
5
6
7
if (/проверяемое условие/)
{
/тело оператора выбора 1/;
} else
{
/тело оператора выбора 2/;
}
Читается так: «Если проверяемое условие истинно, то выполняется тело оператора выбора 1, иначе (то есть проверяемое условие ложно) выполняется тело оператора выбора 2«. Обратите внимание на то, как записан оператор if else. Слово else специально сдвинуто вправо для того чтобы программный код был понятен и его было удобно читать.

Рассмотрим задачу с предыдущей темы, с использованием if else. Напомню условие задачи: «Даны два числа, необходимо их сравнить».

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// if_else.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
int a, b;
cout << "Vvedite pervoe chislo: ";
cin >> a;
cout << "Vvedite vtoroe chislo: ";
cin >> b;
if ( a >= b) // если a больше либо равно b, то
{
cout << a << " >= " << b << endl;
} else // иначе
{
cout << a << " <= " << b << endl;
}
system("pause");
return 0;
}
В данном коде нас интересуют строки 14-20. Эти строки читаются так: если a (первое число) больше либо равно b (второе число), то выполнить оператор вывода в строке 16

1
cout << a << " >= " << b << endl;
иначе выполнить оператор вывода в строке 19

1
cout << a << " <= " << b << endl;
В данном ифе мы используем операции соотношений >= и <=. Условие перехода не совсем правильно, так как условие будет ложно только в том случае, если первое число будет меньше второго, во всех остальных случаях условие истинно. Значит, строку 19 нужно записать так

1
cout << a << " < " << b << endl; // в кавычках записать не меньше или равно, а просто меньше.
А вот так сработала программа (см. Рисунок 1).

CppStudio.com
Vvedite pervoe chislo: 15
Vvedite vtoroe chislo: -4
15 >= -4
Для продолжения нажмите любую клавишу . . .
Рисунок 1 — Оператор выбора if else

Покажу еще один пример использования операторов выбора if else (так называемые вложенные операторы if else для множественного выбора).

Условие задачи:
Составить алгоритм находящий значение y, если у=х, при х<0; у=0, при 0<=х<30; у=х2, при х>=30;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// inif_else.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char argv[])
{
int x, y;
cout << "Vvedite x: ";
cin >> x;
if (x < 0)
{
y = x; // выполняется, если х меньше нуля
} else
{
if ( (x >= 0) && (x < 30) )
{
y = 0; // выполняется, если х больше либо равно нуля и меньше 30
} else
{
if (x >= 30)
{
y = x x; // выполняется, если х больше либо равен 30
}
}
}
cout << "y=" << y << endl;
system("pause");
return 0;
}
В данной задаче возможны три случая:
1-й случай: х < 0;
2-й случай: х лежит в пределах от 0 (включая 0) до 30;
3-й случай: х больше или равен 30.

Заметьте новшество!! В 17 строке такую запись: if ( ( x >= 0 ) && ( x< 30 ) ), я использовал символы && — это логическое И. Операция логического И && необходима для объединения нескольких простых условий в одно составное. В нашем случае необходимо проверить истинность двух условий: первое – x >= 0, второе – х < 30. Все проверяемое условие будет истинно, если истинны два простых условия. В математике правильной записью считается такая запись: 0 <= x < 30, а в С++ правильной записью считается вот такая запись: ( x >= 0 ) && ( x < 30 ) или такая 0 <= x && x < 30. Кстати круглые скобочки () && () не обязательны, так как условия простые, но для уверенности, я прописываю, всегда, данные скобочки и вам советую.

Разбор частного случая:

Допустим, пользователь ввел число 31. Начиная со строки 12, выполняется проверка условий. Читается так: «Если х (31 в нашем случае) < 0, то выполнить оператор в строке 14». Но так как 31 > 0 условие ложно мы переходим к слову else (иначе) строка 15. Дальше проверяем, входит ли число 31 в заданный интервал. Читается так: если х>=0 и х<30 то выполнить оператор в строке 19. Но так как число 31 не входит в заданный интервал, то условие ложно. Подробно строка 17: программа сначала проверит первое простое условие х >= 0 – оно истинно, а если первое истинно, то программа перейдет к проверке второго простого условия х < 30 – оно ложно. Следовательно всё составное условие ложно, ведь в составном условии у нас используется логическая операция &&, а это значит, что все составное условие истинно только в том случае, когда истинны оба простых условия. Переходим к else (иначе ), здесь у нас последний if, (строка 22). Выполняется проверка х >= 30. Читается так: Если х >= 30 то выполнить оператор, находящийся в строке 24. Наконец-то условие истинно, итак выполнился оператор в строке 24. И строка 28 печатает получившееся значение. Ну, все, рассмотрели программу по мельчайшим деталям. Результат работы программы, в случае, если пользователь ввел число 31 (см. Рисунок 2)

CppStudio.com
Vvedite x: 31
y=961
Для продолжения нажмите любую клавишу . . .
Рисунок 2 — Оператор выбора if else

Итак мы рассмотрели оператор с одиночным выбором if и оператор с двойным выбором if else, но в С++ еще имеется оператор множественного выбора switch, который мы сейчас детально рассмотрим.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// форма записи оператора множественного выбора switch
switch (/переменная или выражение/)
{
case /константное выражение1/:
{
/группа операторов/;
break;
}
case /константное выражение2/:
{
/группа операторов/;
break;
}
//. . .
default:
{
/группа операторов/;
}
}
На начальном этапе анализируется выражение или переменная. После чего осуществляется переход к той ветви программы, для которой значение переменной или выражения совпадает с указанным константным выражением. Далее выполняется оператор или группа операторов пока не встретиться зарезервированное слово break или закрывающая фигурная скобочка. Если значение переменной или выражения не совпадает ни с одним константным выражением, то передается управление ветви программы содержащей зарезервированное слово default. После чего выполняется оператор или группа операторов данной ветви. Сейчас рассмотрим задачу с использованием оператора выбора switch.

Условие задачи: написать программу, которая складывает, вычитает, умножает, делит два числа введенных с клавиатуры. Разработать пользовательский интерфейс.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// switch.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char argv[])
{
int count; // переменная для выбора в switch
double a,b; // переменные для хранения операндов
cout << "Vvedite pervoe chislo: ";
cin >> a;
cout << "Vvedite vtoroe chislo: ";
cin >> b;
cout << "Vibirite deistvie: 1-clojenie; 2-vichitanie; 3-ymnojenie; 4-delenie: ";
cin >> count;
switch (count) // начало оператора switch
{
case 1: // если count = 1
{
cout << a << " + " << b << " = " << a + b << endl; // выполнить сложение
break;
}
case 2: // если count = 2
{
cout << a << " - " << b << " = " << a - b << endl; // выполнить вычитание
break;
}
case 3: // если count = 3
{
cout << a << " " << b << " = " << a * b << endl; // выполнить умножение
break;
}
case 4: // если count = 4
{
cout << a << " / " << b << " = " << a / b << endl; // выполнить деление
break;
}
default: // если count равно любому другому значению
cout << "Nepravilni vvod" << endl;
}
system("pause");
return 0;
}
В 9-й строке мы объявили переменную count целочисленного типа. Именно значение данной переменной программа будет сравнивать со значением константного выражения. В строке 10 объявлены две переменные вещественного типа данных, для хранения введённых чисел. Почему вещественного, объясню позже. С 17 по 41 строки записан условный оператор множественного выбора switch. На начальном этапе анализируется переменная count. Анализируется таким образом:
если переменная count равна единице, значит, выполняется блок операторов с 20-й по 23-ю строки;
если переменная count равна двойке, значит, выполняется блок операторов с 25-й по 28-ю строки;
если переменная count равна тройке, значит, выполняется блок операторов с 30-й по 33-ю строки;
если переменная count равна четырем, значит, выполняется блок операторов с 35-й по 38-ю строки;

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

1
cout << "Nepravilni vvod" << endl;
Оператор switch может содержать, а может и не содержать зарезервированное слово default. Если значение переменной не совпадет ни с одним константным выражением и не будет default, то программное управление в этом случае просто перешло бы к первому оператору после switch. В строках 19, 24, 29, 34 записаны константные выражения, с которыми программа сравнивает значение переменной count.
В строках 22, 27, 32, 37, записан оператор break. Возникает вопрос: «Зачем он нужен?» Допустим, пользователь ввел 2, то есть переменная count инициализировалась двойкой. Начинает работать условный оператор множественного выбора switch. То есть выполняется поиск двойки в константных выражениях. Сначала проверяется строка 19, мы видим, что в строке 19 константное выражение равно единице, а нам нужна двойка. Проверяем дальше. А дальше по порядку строка 24. Мы видим, что в строке 24 константное выражение равно двойке, то, что нужно!!! Переменная count равна константному выражению, выполняется блок операторов с 25 по 28 строки. И вот в 27-й строке записан оператор break, который заставляет программу перейти к первому оператору после оператора switch. В данном случае управление передается строке 42. А нужен этот переход только для того, чтобы не выполнялись заведомо ненужные действия. Если убрать оператор break, то программа будет дальше сравнивать значение переменной с константными выражениями, пока они все не закончатся и потом все равно передаст управление строке 42. Результат работы программы показан ниже (см. Рисунок 1).

Оператор множественного выбора switch C++

Рисунок 1 — Оператор множественного выбора в С++

Вернемся к сроке 10, там объявляются две переменные типа double. Наверное, возникает вопрос, «Почему вещественного типа, а не целочисленного?». Отвечаю: «Потому, что одно из действий, которые может выполнять программа является деление, а при делении результат имеет вещественный тип данных. Компилятор С++ при делении чисел обращает внимание на их типы данных. Если мы просто делим числа на калькуляторе, например 4/5=0.8 Компилятор С++ нам выдаст результат при таком делении 0. Так как оба числа являются целочисленными, значит, результат тоже будет целочисленный, то есть целая часть от обычного деления, а в нашем случае целая часть при таком делении – это 0, соответственно часть информации теряется, или как еще говорят, отсекается (восемь десятых, в нашем случае, отсекается). А если делимое и делитель поменять местами, на калькуляторе получим: 5/4=1.25; компилятор С++ покажет несколько иной результат, а именно 5/4=1 (0.25 отсекается). Такое явление в С++ называется неявным приведением типа.» Вещественный тип данных используется для более точного представления чисел, чем целочисленный (то есть отображает дробную часть).

В С++ существуют два вещественных типа данных:
1) double – вещественный тип данных двойной точности, а значит занимает вдвое больше памяти, чем тип float
2) float – вещественный тип данных одинарной точности
Практика

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

1
2
3
4
5
6
7
8
// пример использования оператора continue:
int count = 0;
do // начало цикла do while
{
continue;
count++;
}
while ( count < 10 )
Посмотрите внимательно на выше приведенный пример, и Вы увидите, что do while бесконечный, так как каждая итерация цикла приводит к выполнению оператора continue, который пропускает операцию инкремента переменной-счётчика count и переходит на следующую итерацию цикла. Таким образом значение в переменной count не меняется, а значит и условие всегда будет истинным. Разработаем программу с оператором continue. Программа должна работать циклически. Внутри цикла необходимо организовать ввод чисел.Если введено число от 0 до 10 включительно, то необходимо напечатать квадрат этого числа, иначе используя оператор continue пропустить оператор возведения в квадрат введенного числа. При введении отрицательного числа осуществить выход из цикла.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// continue.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char argv[])
{
int in_number; // переменная для хранения введённого числа
do
{
cout << "Enter number: ";
cin >> in_number; // считываем введённое число в переменную in_number
if ( in_number > 10 || in_number < 0 ) // если введённое число не входит в заданный интервал
continue; // переход на следующую итерацию цикла do while
cout << "square = " << in_number in_number << endl; // возводим в квадрат введённое число
} while ( in_number >= 0 ); // пока введённое число больше либо равно нулю цикл будет работать
system("pause");
return 0;
}
Цикличность в программе организуем циклом с постусловием - do while. В цикле сначала считываем введённое число в переменную in_number, после чего, выполняется проверка условия в операторе if. Условие оператора условного выбора if будет истинным в том случае, если введённое число будет строго меньше нуля или строго больше 10. Заданный интервал — [0;10], число взятое из этого интервала возводится в квадрат. Истинность условия оператора if приводит к выполнению оператора continue в строке 15. А оператор continue пропускает операторы в строке 16 и переходит к проверке условия продолжения цикла do while. Условие в цикле будет истинно, пока вводимые числа будут строго больше 0. Результат работы программы показан на рисунке 3.

CppStudio.com
Enter number: 15
Enter number: 11
Enter number: 5
square = 25
Enter number: 9
square = 81
Enter number: -23
Для продолжения нажмите любую клавишу . . .
Рисунок 3 — Оператор continue в С++

Сначала вводились числа 15 и 11, эти числа не входят в заданный интервал и поэтому квадрат этих чисел не вычислялся. Числа 5 и 9 принадлежат заданному интервалу, а значит программа должна вычислить их квадраты. Когда ввели отрицательное число do while завершил свою работу. Теперь переделаем эту программу так, чтобы можно было обойтись без оператора continue, то есть напишем эквивалент оператору continue.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// continue.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

int main(int argc, char argv[])
{
int in_number; // переменная для хранения введённого числа
do
{
cout << "Enter number: ";
cin >> in_number; // считываем введённое число в переменную in_number
if ( in_number <= 10 && in_number >= 0 ) // если введённое число входит в заданный интервал
//continue; // переход на следующую итерацию цикла do while
cout << "square = " << in_number in_number << endl; // возводим в квадрат введённое число
} while ( in_number >= 0 ); // пока введённое число больше либо равно нулю цикл будет работать
system("pause");
return 0;
}
В эквивалентной программе без оператора continue код уменьшился на одну строку — закомментированная строка 15. Изменилось условие оператора условного выбора if. Строка 16 - это тело оператора if, а значит, если условие в if истинно будет выполнятся оператор в строке 16.

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

Практика

Обращаюсь к новичкам, которые только начали изучать указатели: «Если вас заинтересовала эта тема и вы хотите в ней разобраться, что я могу вам сказать — ситуация не из приятных!» ))) Кто бы и как бы усердно и старательно не объяснял вам что к чему, понять указатели на указатели сложно. Сам указатель на указатель содержит в себе адрес, который ссылается на другой адрес, а он, в свою очередь, ссылается на адрес в памяти, где хранятся данные. Вроде бы и можно понять. Но как это применять на практике? Зачем оно надо??? Это понять сложнее. А надо «оно», среди прочего, для возможности работы с массивами указателей, которые указывают на память с данными (строками, например). Каждый элемент этого массива — это указатель, который содержит в себе адрес строки (первого элемента символьного массива):

Снимок

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

А в данной статье мы будем рассматривать пример, в котором перед нами ставится следующая задача: у нас есть указатель на указатель char pp (он будет содержать адрес массива указателей на строки) и размер этого массива int size, который изначально равен 0. Нам надо написать функцию, которая будет выделять динамическую память для новых элементов массива указателей и для хранения символов новых строк. Эта функция будет принимать, как параметры, указатель на указатель, размер массива указателей и строку, которую надо будет записать в выделенную под нее память. Чтобы не усложнять задачу, в ней не будет диалога с пользователем. Пять строк мы определим сразу при вызовах функции.

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <iostream>;
#include <string.h>;

using namespace std;

char AddPtr (char pp, int size, char str); //прототип функции

int main()
{
setlocale(LC_ALL, "rus");

int size = 0;//количество указателей на строки
char pp = 0;//указатель на массив указателей, которые содержат адреса строк

cout << "~~~~~Добавляем указатели на пять строк и заполняем строки данными~~~~~" << endl;
//вызов функции и присваивание возвращаемого значения
pp = AddPtr(pp, size, "11111111111111111");
size++; //=1 увеличиваем размер массива указателей

pp = AddPtr(pp, size, "22222222222222222");
size++; //2

pp = AddPtr(pp, size, "33333333333333333");
size++; //3

pp = AddPtr(pp, size, "44444444444444444");
size++; //4

pp = AddPtr(pp, size, "55555555555555555");
size++; //5

for(int i = 0; i < size; i++) //показываем все строки на экран
cout << pp << endl; //достаточно обратиться к pp - это адрес строки (0-й элемент)
cout << endl;

for(int i = 0; i < size; i++) //освобождаем память
{
delete [] pp; // сначала выделенную под строки
}
delete [] pp; // потом выделенную под массив указателей
return 0;
}

char AddPtr (char pp, int size, char str)
{
if(size == 0){
pp = new char [size+1]; //выделяем память для указателя на строку
}
else{ //если массив уже не пустой, данные надо скопировать во временный массив copy
char copy = new char [size+1]; //создаем временный массив
for(int i = 0; i < size; i++) //копируем в него адреса уже определенных строк
{
copy = pp;
}
//теперь строки хранятся в адресах copy

delete [] pp; //освобождаем память, которая указывала на строки

pp = copy; //показываем указателю на какие адреса теперь ссылаться
}

pp[size] = new char [strlen(str) + 1]; //выделяем память на новую строку
strcpy(pp[size], str); //и копируем новую строку в элемент p[size].

return pp;
}
В строке 6 объявляем прототип функции char AddPtr (char pp, int size, char str);. Перед названием функции ставим две звездочки, так как функция будет возвращать указатель на указатель. В главной функции main() все достаточно просто. Создаем указатель на указатель типа char pp, который изначально ни на что не указывает, и счетчик элементов массива указателей size - строки 12-13. Далее (строки 17 — 30) идет поочередное наращивание массива указателей и добавление в него данных, посредством вызова функции AddPtr(). При этом, каждый раз после вызова функции мы увеличиваем значение size на единицу. Теперь переместимся к самому интересному — к определению функции AddPtr() строки 44 — 66. Как уже говорилось выше, в виде параметров функция будет принимать уже объявленный нами указатель на указатель, счетчик элементов массива указателей и определённую нами строку. При первом вызове, в функцию передаётся нулевое значение счетчика size. Срабатывает if (size == 0) (строки 46 — 48) в котором мы выделяем динамическую память для первого элемента массива указателей pp = new char [size+1];. Перед квадратными скобками стоит оператор звездочка *, который показывает компилятору, что нужно выделить динамическую память под один указатель (а не просто под символ char, если бы звездочки не было). If отработал и мы перемещаемся в строку 62. Тут мы «говорим» — пусть 0-й элемент массива указателей (указатель pp[size]) указывает на массив символов размером [strlen(str) + 1] (размер определённой нами строки + 1 символ для '\n'). И следующим логичным шагом будет копирование строки, переданной в функцию, в этот выделенный участок памяти — строка 63. И в завершении работы, функция возвращает в программу указатель на указатель (тот самый указатель, который хранит адрес нулевого элемента массива указателей на строки). И наш, объявленный в main(), char pp теперь будет хранить в себе значение этого адреса, так как вызов функции выглядит так pp = AddPtr(pp, size, "11111111111111111");(присвоить значение, которое вернет функция). Функция отработала — память выделена, данные внесены.

Вызываем функцию второй раз — строка 20. При этом вызове уже сработает блок else определённый в строках 49 — 60. У нас уже есть строка, данные которой нам надо не потерять и добавляется еще одна, для которой надо создать новый указатель в массиве указателей, выделить динамическую память и записать туда данные. Поэтому создаем временную копию нашего указателя и выделяем память уже под два элемента массива указателей char copy = new char* [size+1];. Копируем в него указатель на перовую строку (нулевой элемент массива указателей) - copy = pp;. Освобождаем память, которая указывала на первую строку. Так как это массив указателей (пусть даже пока с одним элементом) чтобы освободить занимаемую им память, надо перед именем указателя поставить квадратные скобки — delete [] pp;. Нам эта память больше не нужна, так как на нее уже указывает copy[0]. И показываем указателю pp на какой новый участок памяти надо теперь ссылаться — строка 59. Так — первая строка у нас сохранена и на нее теперь указывает pp[0]. И теперь мы снова переходим к строкам 62 — 63, где выделяется память для второй строки и строка копируется в этот участок памяти.

Таких вызовов функций у нас пять. Постепенно массив указателей растет, а новые строки заполняются данными. Чтобы убедиться, что все работает правильно и все данные сохранены, показываем все строки на экран с помощью цикла for — строки 32-33. Как видите, мы обращаемся к элементам массива указателей. А так как они ссылаются на адреса строк (на 0-е элементы символьных массивов), на экран выводятся соответствующие строки.

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

1
2
3
4
for(int i = 0; i < size; i++)
{
delete [] pp;
}
Так освобождаем динамическую память, на которую ссылаются указатели из массива указателей. А далее освобождаем память, выделенную под сам массив указателей — строка 40.

Результат:

CppStudio.com
~~~~~Добавляем указатели на пять строк и заполняем строки данными~~~~~
11111111111111111
22222222222222222
33333333333333333
44444444444444444
55555555555555555

Условие этой задачи мы выполнили. Надеюсь, вы оценили главное преимущество использования указателей вместо обычных массивов. При входе в программу мы не знаем, сколько строк нам будет необходимо и какой объем памяти они будут занимать. Но мы не объявляли несколько десятков символьных массивов с размером [много памяти] (а вдруг пригодятся, если пользователь будет вводить много длинных строк). Вместо этого у нас получился один динамический массив указателей на строки, память для которых так же выделяется динамически.

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

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

Целочисленные литералы состоят из цифр от 0 до 9 со знаком +, - или без знака. Например, +25, –7, 553. Литералы с плавающей точкой могут быть записаны в виде целой и дробной частей, разделенных точкой (целая часть может отсутствовать, если она равна 0, если дробная часть равна 0, то после точки должен быть записан 0) или в экспоненциальной форме (вместо основания степени 10 используется e или E). Например, 8.1, 0.2, 3.0, –5.3E–1, 5e4.

Строковые литералы используются для представления текстовых строк. Это строка символов, заключенная в кавычки. Например, «Город Симферополь» или «Результаты вычислений». С помощью символа \ (обратный слеш) можно указать некоторые специальные и управляющие символы. Последовательность и следующего за ним символа называется управляющей последовательностью. Например, наличие в строке последовательности \n означает переход на новую строку, \t – горизонтальная табуляция, \\ — обратный слеш, \" - двойная кавычка и т.п. Символьные литералы используются для представления одиночных символов (заключаются в одинарные кавычки). Например:

1
char symbol = 'x';
Литералы для представления логических значений: true, false. Ключевое слово null является литералом, представляющим пустую ссылку, которая не ссылается ни на один объект.

Практика

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

Итак, что же такое прототип функции? Прототип имеет следующий вид.

1
2
// прототип функции
void function(int arg1, double arg2); // в конце определения всегда ставится точка с запятой
Как видно в прототипе указываются по порядку тип возвращаемого значения (в данном примере void), название функции (в данном случае function) и список параметров в скобках. Объявление прототипа должно заканчиваться точкой с запятой.

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

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

Как лучше всего использовать прототип функции. Лучше всего описание функции включить в отдельный исходный файл. После этого надо скомпилировать этот файл и получить объектный файл. Прототип следует помесить в заголовочный файл и включать его директивой #include в те исходные файлы, в которых присутствует вызов функции.

Рекурсия достаточно распространённое явление, которое встречается не только в областях науки, но и в повседневной жизни. Например, эффект Дросте, треугольник Серпинского и т. д. Самый простой вариант увидеть рекурсию – это навести Web-камеру на экран монитора компьютера, естественно, предварительно её включив. Таким образом, камера будет записывать изображение экрана компьютера, и выводить его же на этот экран, получится что-то вроде замкнутого цикла. В итоге мы будем наблюдать нечто похожее на тоннель.

В программировании рекурсия тесно связана с функциями, точнее именно благодаря функциям в программировании существует такое понятие как рекурсия или рекурсивная функция. Простыми словами, рекурсия – определение части функции (метода) через саму себя, то есть это функция, которая вызывает саму себя, непосредственно (в своём теле) или косвенно (через другую функцию). Типичными рекурсивными задачами являются задачи: нахождения n!, числа Фибоначчи. Такие задачи мы уже решали, но с использованием циклов, то есть итеративно. Вообще говоря, всё то, что решается итеративно можно решить рекурсивно, то есть с использованием рекурсивной функции. Всё решение сводится к решению основного или, как ещё его называют, базового случая. Существует такое понятие как шаг рекурсии или рекурсивный вызов. В случае, когда рекурсивная функция вызывается для решения сложной задачи (не базового случая) выполняется некоторое количество рекурсивных вызовов или шагов, с целью сведения задачи к более простой. И так до тех пор пока не получим базовое решение. Разработаем программу, в которой объявлена рекурсивная функция, вычисляющая n!

MVS
Code::Blocks
Dev-C++
QtCreator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// factorial.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

unsigned long int factorial(unsigned long int);// прототип рекурсивной функции
int i = 1; // инициализация глобальной переменной для подсчёта кол-ва рекурсивных вызовов
unsigned long int result; // глобальная переменная для хранения возвращаемого результата рекурсивной функцией

int main(int argc, char argv[])
{
int n; // локальная переменная для передачи введенного числа с клавиатуры
cout << "Enter n!: ";
cin >> n;
cout << n << "!" << "=" << factorial(n) << endl; // вызов рекурсивной функции
system("pause");
return 0;
}

unsigned long int factorial(unsigned long int f) // рекурсивная функция для нахождения n!
{
if (f == 1 || f == 0) // базовое или частное решение
return 1; // все мы знаем, что 1!=1 и 0!=1
cout << "Step\t" << i << endl;
i++; // операция инкремента шага рекурсивных вызовов
cout << "Result= " << result << endl;
result = f factorial(f - 1); // функция вызывает саму себя, причём её аргумент уже на 1 меньше
return result;
}
В строках 7, 9, 21 объявлен тип данных unsigned long int, так как значение факториала возрастает очень быстро, например уже 10! = 3 628 800. Если не хватит размера типа данных, то в результате мы получим совсем не правильное значение. В коде объявлено больше операторов, чем нужно, для нахождения n!. Это сделано для того, чтобы, отработав, программа показала, что происходит на каждом шаге рекурсивных вызовов. Обратите внимание на выделенные строки кода, строки 23, 24, 28 - это рекурсивное решение n!. Строки 23, 24 являются базовым решением рекурсивной функции, то есть, как только значение в переменной f будет равно 1 или 0 (так как мы знаем, что 1! = 1 и 0! = 1), прекратятся рекурсивные вызовы, и начнут возвращаться значения, для каждого рекурсивного вызова. Когда вернётся значение для первого рекурсивного вызова, программа вернёт значение вычисляемого факториала. В строке 28 функция factorial() вызывает саму себя, но уже её аргумент на единицу меньше. Аргумент каждый раз уменьшается, чтобы достичь частного решения. Результат работы программы (см. Рисунок 1).

CppStudio.com
Enter n!: 5
Step 1
Result= 0
Step 2
Result= 0
Step 3
Result= 0
Step 4
Result= 0
5!=120
Рисунок 1 — Рекурсия в С++

По результату работы программы хорошо виден каждый шаг и результат на каждом шаге равен нулю, кроме последнего рекурсивного обращения. Необходимо было вычислить пять факториал. Программа сделала четыре рекурсивных обращения, на пятом обращении был найден базовый случай. И как только программа получила решение базового случая, она порешала предыдущие шаги и вывела общий результат. На рисунке 1 видно всего четыре шага потому, что на пятом шаге было найдено частное решение, что в итоге вернуло конечное решение, т. е. 120. На рисунке 2 показана схема рекурсивного вычисления 5!. В схеме хорошо видно, что первый результат возвращается, когда достигнуто частное решение, но никак не сразу, после каждого рекурсивного вызова.

Рекурсивный вызов функции в С++

Рисунок 2 — Рекурсия в С++

Итак, чтобы найти 5! нужно знать 4! и умножить его на 5; 4! = 4 3! и так далее. Согласно схеме, изображённой на рисунке 2, вычисление сведётся к нахождению частного случая, то есть 1!, после чего по очереди будут возвращаться значения каждому рекурсивному вызову. Последний рекурсивный вызов вернёт значение 5!.

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

MVS
Code::Blocks
Dev-C++
QtCreator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// factorial.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
using namespace std;

unsigned long int factorial(unsigned long int);// прототип рекурсивной функции
int i = 1; // инициализация глобальной переменной для подсчёта кол-ва рекурсивных вызовов
unsigned long int result; // глобальная переменная для хранения возвращаемого результата рекурсивной функцией

int main(int argc, char argv[])
{
int n; // локальная переменная для передачи введенного числа с клавиатуры
cout << "Enter n!: ";
cin >> n;
for (int k = 1; k <= n; k++ )
{
cout << k << "!" << "=" << factorial(k) << endl; // вызов рекурсивной функции
}
system("pause");
return 0;
}

unsigned long int factorial(unsigned long int f) // рекурсивная функция для нахождения n!
{
if (f == 1 || f == 0) // базовое или частное решение
return 1; // все мы знаем, что 1!=1 и 0!=1
//cout << "Step\t"<< i <<endl;
i++;
//cout <<"Result= "<< result << endl;
result=ffactorial(f-1); // функция вызывает саму себя
return result;
}

В строках 16 — 19 объявлен цикл, в котором вызывается рекурсивная функция. Всё ненужное в программе закомментированно. Запустив программу, нужно ввести значение, до которого необходимо вычислить факториалы. Результат работы программы показан на рисунке 3.

CppStudio.com
Enter n!: 14
1!=1
2!=2
3!=6
4!=24
5!=120
6!=720
7!=5040
8!=40320
9!=362880
10!=3628800
11!=39916800
12!=479001600
13!=6227020800
14!=87178291200
Рисунок 3 — Рекурсия в С++

Теперь видно, насколько быстро возрастает факториал, кстати говоря, уже результат 14! не правильный, это и есть последствия нехватки размера типа данных. Правильное значение 14! = 87178291200.

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

MVS
Code::Blocks
Dev-C++
QtCreator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// fibonacci.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
// библиотека для форматирования выводимой информации на экран
#include <iomanip>
using namespace std;

unsigned long fibonacci(unsigned long);// прототип рекурсивной функции поиска чисел из ряда Фибоначчи

int main(int argc, char argv[])
{
unsigned long entered_number;
cout << "Enter number from the Fibonacci series: ";
cin >> entered_number;
for (int counter = 1; counter <= entered_number; counter++ )
cout << setw(2) <<counter << " = "<< fibonacci(counter) << endl; // функция setw() резервирует два места под вывод номера
system("pause");
return 0;
}

unsigned long fibonacci(unsigned long entered_number) // функция принимает один аргумент
{
if ( entered_number == 1 || entered_number == 2) // частный случай
return (entered_number -1); // ряд чисел Фибоначчи всегда начинается с 0, 1, ...
return fibonacci(entered_number-1) + fibonacci(entered_number-2); // формула поиска н-го числа, например найти восьмое по счёту число, и оно равно 7-е + 6-е
}
В строке 6 подключена библиотека <iomanip> для того, чтобы воспользоваться функцией setw(), которая в свою очередь выравнивает первый столбец чисел, то есть номера. Как мы можем заметить, сначала числа однозначные от 1 – 9, а потом идут двузначные. Если убрать данную функцию, то произойдет сдвиг влево чисел от 1 и до 9. Результат работы программы (см. Рисунок 4).

CppStudio.com
Enter number from the Fibonacci series: 30
1 = 0
2 = 1
3 = 1
4 = 2
5 = 3
6 = 5
7 = 8
8 = 13
9 = 21
10 = 34
11 = 55
12 = 89
13 = 144
14 = 233
15 = 377
16 = 610
17 = 987
18 = 1597
19 = 2584
20 = 4181
21 = 6765
22 = 10946
23 = 17711
24 = 28657
25 = 46368
26 = 75025
27 = 121393
28 = 196418
29 = 317811
30 = 514229
Рисунок 4 — Рекурсия в С++

Решение сводится к разбиению сложной задачи к двум более простым. Например, чтобы найти третье число из ряда Фибоначчи, необходимо сначала найти первое и второе, а потом сложить их. Первое число является частным случаем и равно 0 (нулю), второе число также является частным случаем и равно 1. Следовательно, третье число из ряда Фибоначчи равно сумме первого и второго = 1. Приблизительно так же рассуждала запрограммированная нами рекурсивная функция поиска чисел ряда Фибоначчи.

Разработаем ещё одну рекурсивную программу, решающую классическую задачу — «Ханойская башня». Даны три стержня, на одном из которых находится стопка n-го количества дисков, причём диски имеют не одинаковый размер (диски различного диаметра) и расположены таким образом, что по мере прохождения, сверху вниз по стержню диаметр дисков постепенно увеличивается. То есть диски меньшего размера должны лежать только на дисках большего размера. Необходимо переместить эту стопку дисков с начального стержня на любой другой из двух оставшихся (чаще всего это третий стержень). Один из стержней использовать как вспомогательный. Перемещать можно только по одному диску, при этом диск большего размера никогда не должен находиться над диском меньшего размера.

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



Программу надо написать для n-го количества дисков. Так как мы решаем данную задачу рекурсивно, то для начала необходимо найти частные случаи решения. В данной задаче частный случай только один – это когда необходимо переместить всего один диск, и в этом случае даже вспомогательный стержень не нужен, но на это просто не обращаем внимания. Теперь необходимо организовать рекурсивное решение, в случае, если количество дисков больше одного. Введём некоторые обозначения, для того, чтоб не писать лишнего:

<Б> - стержень, на котором изначально находятся диски (базовый стержень);
<П> - вспомогательный или промежуточный стержень;
<Ф> - финальный стержень – стержень, на который необходимо переместить диски.

Далее, при описании алгоритма решения задачи будем использовать эти обозначения. Чтобы переместить три диска с <Б> на<Ф> нам необходимо сначала переместить два диска с <Б> на <П> а потом переместить третий диск(самый большой) на<Ф>, так как <Ф> свободен.

Для того, чтобы переместить n дисков с <Б> на <Ф> нам необходимо сначала переместить n-1 дисков с <Б> на <П> а потом переместить n-й диск(самый большой) на <Ф>, так как <Ф> свободен. После этого необходимо переместить n-1 дисков с <П> на <Ф>, при этом использовать стержень <Б> как вспомогательный. Эти три действия и есть весь рекурсивный алгоритм. Этот же алгоритм на псевдокоде:
n-1 переместить на <П>
n переместить на <Ф>
n-1 переместить с <П> на <Ф>, при этом использовать <Б> как вспомогательный

MVS
Code::Blocks
Dev-C++
QtCreator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// hanoi_tower.cpp: определяет точку входа для консольного приложения.
// Программа, рекурсивно решающая задачу "Ханойская башня"

#include "stdafx.h"
#include <iostream>
#include <iomanip>
using namespace std;

void tower(int, int, int, int); // объявление прототипа рекурсивной функции
int count = 1; // глобальная переменная для подсчёта количества шагов

int _tmain(int argc, _TCHAR* argv[])
{
cout << "Enter of numbers of disks: ";// введите количество дисков, которые надо переместить
int number;
cin >> number;
cout << "Enter the number of basic rod: "; // введите номер стержня, на котором диски будут находится изначально
int basic_rod;
cin >> basic_rod;
cout << "Enter the number of final rod: "; // введите номер стержня, на который необходимо переместить диски
int final_rod;
cin >> final_rod;
int help_rod;
// блок определения номера вспомогательного стержня, анализируя номера начального и финального стержня
if (basic_rod != 2 && final_rod != 2 )
help_rod = 2;
else
if (basic_rod != 1 && final_rod != 1 )
help_rod = 1;
else
if (basic_rod != 3 && final_rod != 3 )
help_rod = 3;
tower(// запуск рекурсивной функции решения задачи Ханойских башен
number, // переменная, хранящая количество дисков, которые надо переместить
basic_rod, // переменная, хранящая номер стержня, на котором диски будут находится изначально
help_rod , // переменная, хранящая номер стержня, который используется, как вспомогательный
final_rod); // переменная, хранящая номер стержня, на который необходимо переместить диски
system("pause");
return 0;
}

void tower(int count_disk, int baza, int help_baza, int new_baza)
{
if ( count_disk == 1) // условие завершения рекурсивных вызовов
{
cout << setw(2) << count << ") "<< baza << " " << "->" << " " << new_baza << endl;
count++;
}
else
{
tower(count_disk -1, baza, new_baza, help_baza); // перемещаем все диски кроме самого последнего на вспомогательный стержень
tower(1, baza, help_baza, new_baza); // перемещаем последний диск с начального стержня на финальный стержень
tower(count_disk -1, help_baza, baza, new_baza); // перемещаем все диски со вспомогательного стержня на финальный
}
}
На рисунке 5 показан пример работы рекурсивной программы Ханойская башня. Сначала мы ввели количество дисков равное трём, потом ввели базовый стержень (первый), и обозначили конечный стержень (третий). Автоматически второй стержень стал вспомогательным. Программа выдала такой результат, что он полностью совпадает с анимационным решением данной задачи.

CppStudio.com
Enter of numbers of disks: 3
Enter the number of basic rod: 1
Enter the number of final rod: 3
1) 1 -> 3
2) 1 -> 2
3) 3 -> 2
4) 1 -> 3
5) 2 -> 1
6) 2 -> 3
7) 1 -> 3
Рисунок 5 — Рекурсия в С++

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

Все эти задачи можно было решить итеративно. Возникает вопрос: “Как лучше решать, итеративно или рекурсивно?”. Отвечаю: “Недостаток рекурсии в том, что она затрачивает значительно больше компьютерных ресурсов, нежели итерация. Это выражается в большой нагрузке, как на оперативную память, так и на процессор. Если очевидно решение той или иной задачи итеративным способом, то им и надо воспользоваться иначе, использовать рекурсию!” В зависимости от решаемой задачи сложность написания программ изменяется при использовании того или иного метода решения. Но чаще задача, решённая рекурсивным методом с точки зрения читабельности кода, куда понятнее и короче.

В этой статье мы расскажем о следующем:

Что такое дружественные функции и, главное, зачем они нужны.
Чем отличаются обычные методы класса от дружественных функций класса.
Как объявлять и определять дружественные функции.
Как вызывать дружественные функции из главной main() функции .
Самым важным, но и, скорее всего, самым непонятным для вас сейчас станет определение дружественной функции. Дружественная функция — это функция, которая не является членом класса, но имеет доступ к членам класса, объявленным в полях private или protected. Долго не вникайте в суть этого определения, а лучше сразу переходите к следующему абзацу. Обещаю, что после прочтения статьи вы вернетесь к этому определению и вас посетит мысль: «Ну да — так и есть! Тут все понятно!»

Приступим к основному занятию программиста — практике! В примере запрограммируем следующее: создадим класс Woman25, который, используя дружественные функции и обычные методы класса, будет получать данные об объекте (имя и вес) и выводить их на экран. Методы и friend-функции будут выполнять аналогичные действия. В этом и есть особенная польза данного примера — вы сможете посмотреть отличия в объявлении и определении дружественных функций от обычных методов класса. На основании полученных данных, программа даст пользователю совет относительно корректировки его веса. Ну что-же, лучше один раз увидеть…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include <iostream>
#include <string.h>

using namespace std;

class Woman25
{
private:
char name;//имя
int weight;//вес

friend void setData(char , int, Woman25&);//объявление дружественных функций
friend void getData(Woman25&);
public:
Woman25()//конструктор
{
name = new char [20];
strcpy(name, "Норма");
weight = 60;
}
~Woman25()//деструктор
{
delete [] name;
cout << "!!! Деструктор !!!" << endl;
}

void setData(char, int);//объявление методов класса
void getData();
void advise();
};

void setData(char n, int w, Woman25& object)//определяем friend-функцию setData
{
strcpy(object.name, n);////////////
object.weight = w;
}

void getData(Woman25& object)//определяем friend-функцию getData
{
cout << object.name << "\t: " << object.weight << " кг" << endl;
}

void Woman25::setData(char n, int w)//определяем set-метод класса
{
strcpy(name, n);
weight = w;
}

void Woman25::getData()//определяем get-метод класса
{
cout << name << "\t: " << weight << " кг" << endl;
}

void Woman25::advise()//определяем метод класса Совет (advise)
{
if(weight < 55){ //если вес меньше 55 кг
cout << "Вам надо потреблять больше калорий!" << endl;
cout << "=====================================" << endl << endl;
}else if(weight >= 55 && weight <= 65){ //если вес в пределах 55-65 кг
cout << "Ваш вес в норме!" << endl;
cout << "=====================================" << endl << endl;
}else { //если вес > 65 кг
cout << "Вам надо ограничивать себя в еде!" << endl;
cout << "=====================================" << endl << endl;
}
}

int main()
{
setlocale(LC_ALL, "rus");

Woman25 Norm; //создаем объект Norm, сработает конструктор и weight будет = 60, name - Норма
Norm.getData(); //вызов метода класса
cout << "=====================================" << endl << endl;

Woman25 Anna; //второй объект
Anna.setData("Анна", 100);
Anna.getData();
Anna.advise();

Woman25 Inna; //третий объект
setData("Инна", 50, Inna);
getData(Inna);
Inna.advise();

return 0;
}
Комментарии к исходному коду. В строках 6 — 30 создаем класс Woman25. Он содержит два приватных элемента класса: char name; и int weight;. В private также объявим дружественные функции friend void setData(char *, int, Woman25&); и friend void getData(Woman25&);. Хотя их можно объявлять и определять в любом поле класса, будь то private, public или protected, но об этом поговорим позже. Так мы сделали, чтобы показать, что несмотря на объявление дружественных функций в поле private, к ним можно обращаться напрямую из функции main(). Тогда, когда методы класса должны располагаться в поле public всегда, если мы собираемся вызывать их вне класса. Объявление дружественных функций отличается от объявления методов класса еще и тем, что перед типом возвращаемого функцией значения используется зарезервированное слово friend. Обратите внимание, что в виде параметра мы передаем этим функциям ссылку на объект нашего класса - Woman25&. В обычных методах этого не будет. В поле public расположился конструктор класса — строки 15 — 20. В нем мы задаем значение нормального веса - 60 кг, а так же, с помощью функции strcpy(name, "Норма");, вносим данные в элемент класса name. Затем в строках 21 — 25 определяем деструктор класса ~Woman25(). Его задача, освободить, выделенную конструктором, динамическую память. А для того, чтобы убедиться, что он сработал и удалил динамическую память всех созданных объектов класса при завершении работы программы, мы добавили в него строку cout << "!!! Деструктор !!!" << endl; . Строки 27 — 29 - объявление обычных методов класса.

Теперь начинается, пожалуй, самое интересное — определение вне класса наших дружественных функций и обычных методов класса. Все это располагается в строках 32 - 66. Смотрите, когда мы определяем дружественные функции , строки 32 — 36 и 38 — 41, мы не используем оператор :: двойное двоеточие (область видимости метода). Это уже говорит нам о том, что дружественная функция не принадлежит классу, не является его компонентом. А при определении остальных методов использование оператора :: является обязательным. Метод класса advise(), на основании полученных данных о весе, дает пользователю один из советов либо сообщает, что вес в норме.

Переходим в главную функцию — строки 68 — 87. Тут мы создаем объект класса Woman25 Norm;, при создании которого сработает конструктор и инициализирует элементы name и weight. Вызываем метод класса Norm.getData(); чтобы вывести на экран значение нормы. Со вторым созданным объектом Woman25 Anna; работаем, вызывая обычные set и get- методы класса, а с третьим объектом Woman25 Inna; — вызывая дружественные функции. Как видите, вызываются они как функции, которые не принадлежат классу. Объект класса мы передаем, как параметр.