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

Для того чтобы воспользоваться печью, я открываю её дверцу, забрасываю внутрь полуфабрикат и нажимаю несколько кнопок на передней панели. Через пару минут блюдо готово ( я стараюсь не стоять перед печью, чтобы мои глаза не начали светиться в темноте ).

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

■■■

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

■ Не смотрел внутрь печи.

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

■■■

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

_________________

145 стр. . Знакомство с объектно-ориентированным программированием

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

 

Приготовление блюд с помощью функций...146

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

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

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

 

Приготовление "объектно-ориентированных" блюд...146

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

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

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

 

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

_________________

154 стр. . Введение в классы

 

Моделирование реальных объектов...155

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

Функционально ориентированные программы выполняют все необходимые действия с помощью функций. Программа на С++ может вызвать функцию strcmp( ) для сравнения двух строк или функцию getLine( ) для ввода строки. В , будет показано, что даже операторы работы с потоками ввода-вывода ( cin >> и cout << ) являются не чем иным, как особым видом вызова функции.

Для выполнения действий классу Savings необходимы собственные активные свойства:

    class Savings

    {

    public :

        unsigned deposit( unsigned amount )

        {

            balance += amount ;

            return balance ;

        }

        unsigned int accountNumber ;

        float balance ;

    } ;

В приведённом примере помимо номера и баланса счёта в класс Savings добавлена функция deposit( ). Теперь класс Savings может самостоятельно управлять своим состоянием. Так же, как класс MicrowaveOven ( микроволновая печь ) содержит функцию cook( ) ( готовить ), класс Savings содержит функцию deposit( ). Функции, определённые в классе, называются функциями-членами. 

 

Зачем нужны функции-члены...155

Почему мы должны возиться с функциями-членами? Что плохого в таком фрагменте:

    class Savings

    {

    public :

        unsigned accountNumber ;

        float balance ;

    } ;

    unsigned deposit( Savings& s , unsigned amount )

    {

        s.balance += amount ;

        return s.balance ;

    }

Ещё раз напомню: пока что не обращайте внимания на символ "&" — его смысл станет понятен позже.

В этом фрагменте deposit( ) является функцией "вклада на счёт". Эта функция поддержки реализована в виде внешней функции, которая выполняет необходимые действия с экземпляром класса Savings. Конечно, такой подход имеет право на существование, но он нарушает наши правила объектно-ориентированного программирования.

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

_________________

155 стр. . Работа с классами

Когда я делаю закуску, я не должен начинать приготовление с подключения внутренних элементов микроволновой печи. И я хочу, чтобы мои классы работали так же, т.е. чтобы они без всякого внешнего вмешательства знали, как управлять своими "внутренними органами". Конечно, такие функции-члены класса Savings, как deposit( ), могут быть реализованы и в виде внешних функций. Можно даже расположить все функции, необходимые для работы со счетами, в одном месте файла. Микроволновую печь можно заставить работать, соединив необходимые провода внутри неё, но я не хочу, чтобы мои классы ( или моя микроволновая печь ) работали таким образом. Я хочу иметь класс Savings, который буду использовать в своей банковской программе, не задумываясь над тем, какова его рабочая "кухня".

 

Эта процедура включает два аспекта: создание функции-члена и её именование ( звучит довольно глупо, не правда ли? ).

 

Создание функции-члена...156

Чтобы продемонстрировать работу с функциями-членами, начнём с определения класса Student следующим образом:

    class Student

    {

    public :

        /* Добавить пройденный курс к записи */

        float addCourse( int hours , float grade )

        {

            /* Вычислить среднюю оценку с учётом времени различных курсов */

            float weightedGPA ;

            weightedGPA = semesterHours * gpa ;

            /* Добавить новый курс */

            semesterHours += hours ;

            weightedGPA += grade * hours ;

            gpa = weightedGPA / semesterHours ;

            /* Вернуть новую оценку */

            return gpa ;

        }

        int semesterHours ;

        float gpa ;

    } ;

Функция addCourse( int , float ) является функцией-членом класса Student. По сути, это такое же свойство класса Student, как и свойства semesterHours и gpa.

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

«Функции-члены не обязаны предшествовать членам-данным в объявлении класса, как сделано в приведённом выше примере. Члены класса могут быть перечислены в любом порядке. Просто я предпочитаю первыми размещать функции .»

[]

_________________

156 стр. . Введение в классы

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

[]

 

Именование членов класса...157

Функция-член во многом похожа на члена семьи. Полное имя нашей функции addCourse( int , float ) пишется как Student::addCourse( int , float ), так же как моё полное имя — Стефан Дэвис. Краткое имя этой функции — addCourse( int , float ), а моё краткое имя — Стефан. Имя класса в начале полного имени означает, что эта функция является членом класса Student ( :: между именами функции и класса является просто символом-разделителем ). Фамилия Дэвис после моего имени означает, что я являюсь членом семьи Дэвисов.

«Существует и другое название полного имени — расширенное имя.»

[]

Мы можем определить функцию addCourse( int , float ), которая не будет иметь ничего общего с классом Student ; точно так же, как могут существовать люди с именем Стефан, которые не имеют ничего общего с моей семьёй ( это можно понимать и дословно: я знаю несколько Стефанов, которые не хотят иметь ничего общего с моей семьёй ).

Вы можете создать функцию с полным именем Teacher::addCourse( int , float ) или даже с именем Golf::addCourse( int , float ). Имя addCourse( int , float ) без имени класса означает, что это обычная функция, которая не является членом какого-либо класса.

«Расширенное имя функции, не являющейся членом какого-либо класса, имеет вид ::addCourse( int , float ) .»

[]

 

Прежде чем вызывать функции-члены класса, вспомните, как мы обращались к данным-членам классов:

    class Student

    {

    public :

        int semesterHours ;

        float gpa ;

    } ;

    Student s ;

    void fn( void )

    {

        /* Обращение к данным-членам объекта s */

        s.semesterHours = 10 ;

        s.gpa = 3.0 ;

    }

_________________

157 стр. . Работа с классами

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

    Student s ;

    void fn( void )

    {

        /* Этот пример ошибочен */

        semesterHours = 10 ;

            /* Член какого объекта и какого класса? */

        Student::semesterHours = 10 ;

            /* Теперь ясно, какого класса, однако до сих пор не ясно, какого объекта */

    }

 

Обращение к функциям-членам...158

Формально между данными-членами и функциями-членами нет никакого различия. Следующая программа показывает, как можно использовать функцию-член addCourse( ).

    /* CallMemberFunction — определение и вызов */

    /*                         функции-члена класса */

    #include

    #include

    #include

    using namespace std ;

    class Student

    {

        public :

            /* Добавить пройденный курс к записи */

            float addCourse( int hours , float grade )

            {

                /* Вычислить среднюю оценку с учётом времени различных курсов */

                float weightedGPA ;

                weightedGPA = semesterHours * gpa ;

                /* Добавить новый курс */

                semesterHours += hours ;

                weightedGPA += grade * hours ;

                gpa = weightedGPA / semesterHours ;

                /* Вернуть новую оценку */

                return gpa ;

            }

            int semesterHours ;

            float gpa ;

    } ;

    int main( int nNumberofArgs , char* pszArgs[ ] )

_________________

158 стр. . Введение в классы

    {

        Student s ;

        s.semesterHours = 10 ;

        s.gpa = 3.0 ;

        /* Значения до вызова */

        cout << "До: s = ( " << s.semesterHours

                << ", " << s.gpa

                << " )" << endl ;

        s.addCourse( 3 , 4.0 ) ; /* Вызов функции-члена */

        /* Изменённые значения */

        cout << "После: s = ( " << s.semesterHours

                << ", " << s.gpa

                << " )" << endl ;

        /* Обращение к другому объекту */

        Student t ;

        t.semesterHours = 6 ;

        t.gpa = 1.0 ;

        t.addCourse( 3 , 1.5 ) ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    } 

Как видите, синтаксис вызова функции-члена такой же, как и синтаксис обращения к переменной-члену класса. Часть выражения, которая находится справа от точки, не отличается от вызова обычной функции. Единственное отличие — присутствие слева от точки имени объекта, которому принадлежит функция.

Факт вызова этой функции можно определить так: "s является объектом, на который действует addCourse( ) " ; или, другими словами, объект s представляет собой студента, к записи которого добавляется новый курс. Вы не можете получить информацию о студенте или изменить её, не указав, о каком конкретно студенте идёт речь.

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

 

Доступ к членам из функции-члена...159

Я так и слышу, как вы повторяете про себя: "Нельзя обратиться к функции-члену без указания имени объекта! Нельзя обратиться к функции-члену без указания имени объекта! Нельзя..." Запомнив это, вы смотрите на тело функции-члена Student::addCourse( ) и... что это? Ведь addCourse( ) обращается к членам класса, не уточняя имени объекта!

Возникает вопрос: так всё-таки можно или нельзя обратиться к члену класса, не указывая его объекта? Уж поверьте мне, что нельзя. Просто когда вы обращаетесь к члену класса Student из addCourse( ), по умолчанию используется тот экземпляр класса, из которого вызвана функция addCourse( ). Вы ничего не поняли? Вернёмся к примеру.

    int main( int nNumberofArgs , char* pszArgs[ ] )

    {

        Student s ;

        s.semesterHours = 10 ;

        s.gpa = 3.0 ;

        s.addCourse( 3 , 4.0 ) ; /* Вызов функции-члена */

        Student t ;

        t.semesterHours = 6;

        t.gpa = 1.0 ;

        t.addCourse( 3 , 1.5 ) ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }

_________________

159 стр. . Работа с классами

Когда addCourse( ) вызывается для объекта s, все сокращённые имена в теле этой функции считаются членами объекта s. Таким образом, обращение к переменной semesterHours внутри функции s.addCourse( ) в действительности является обращением к переменной s.semesterHours, а обращение к gpa — обращением к s.gpa. В следующей строке функции main( ), когда addCourse( ) вызывается для объекта t того же класса Student, происходит обращение к членам класса t.semesterHours и t.gpa.

«Объект, для которого вызывается функция-член, называется "текущим", и все имена членов, записанные в сокращённом виде внутри функции-члена, считаются членами текущего объекта. Другими словами, сокращённое обращение к членам класса интерпретируется как обращение к членам текущего объекта.»

[]

 

Именование текущего объекта...160

«Как функция-член определяет, какой объект является текущим? Это не магия и не шаманство — просто адрес этого объекта всегда передаётся функции-члену как скрытый первый аргумент. Другими словами, при вызове функции-члена происходит преобразование такого вида:

s.addCourse( 3 , 2.5 ) равносильно Student::addCourse( &s , 3 , 2.5 )

( команда, приведённая в правой части выражения, синтаксически неверна; она просто показывает, как компилятор видит выражение в левой части во внутреннем представлении ).»

[]

Внутри функции, когда нужно узнать, какой именно объект является текущим, используется этот указатель. Тип текущего объекта — указатель на объект соответствующего класса. Всякий раз, когда функция-член обращается к другому члену класса, не называя имени его объекта явно, компилятор считает, что данный член является членом этого ( this ) объекта. При желании вы можете явно обращаться к членам этого объекта, используя ключевое слово this. Так что функцию Student::addCourse( ) можно переписать следующим образом:

    float Student::addCourse( int hours , float grade )

    {

        float weightedGPA ;

        weightedGPA = this -> semesterHours * this -> gpa ;

        /* добавим новый курс */

        this -> semesterHours += hours ;

        weightedGPA += hours * grade ;

        this -> gpa = weightedGPA / this -> semesterHours ;

        return this -> gpa ;

    }

Независимо от того, добавите ли вы оператор this ->  в тело функции явно или нет, результат будет одинаков.

_________________

160 стр. . Введение в классы

 

Указатели на объекты работают так же, как и указатели на простые типы.

    /* ObjPtr — Определение и использование */

    /*              указателя на объект Student */

    #include

    #include

    #include

    using namespace std ;

    class Student

    {

        public :

            int semesterHours ;

            float gpa ;

            float addCourse( int hours , float grade ) { return 0.0 ; } ;

    } ;

    int main( int argc , char* pArgs[ ] )

    {

            /* Создание объекта Student */

            Student s ;

            s.gpa = 3.0 ;

            /* Создание указателя на объект Student */

            Student* pS ;

            /* Заставляем указатель указывать на наш объект */

            pS = &s ;

            cout << "s.gpa     = " << s.gpa << "\n"

                    << "pS -> gpa = " << pS -> gpa << endl ;

            /* Пауза для того, чтобы посмотреть на результат работы программы */

             system( "PAUSE" ) ; return 0 ;

    }

 

В программе объявляется переменная s типа Student, после чего создаётся переменная pS, которая является "указателем на объект типа Student" ; другими словами, указателем Student*. Программа инициализирует значение одного из членов-данных s, и присваивает адрес s переменной pS. Затем программа обращается к объекту s — один раз по имени, а затем с использованием указателя на объект. Странную запись pS -> gpa я объясню немного позже в этой главе.

 

Разыменование указателей на объекты...169

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

_________________

169 стр. . Указатели на объекты

    int main( int argc , char* pArgs[ ] )

    {

        /* Этот пример некорректен */

        Student s ;

        Student* pS= &s ; /* Создаём указатель на объект s */

        /* Обращаемся к члену gpa объекта, на который указывает pS ( этот фрагмент неверен ) */

        *pS.gpa = 3.5 ;

        return 0 ;

    }

Как верно сказано в комментарии, этот код работать не будет. Проблема в том, что оператор "." будет выполнен раньше оператора "*".

Для изменения порядка выполнения операторов в С++ используют скобки. Так, в приведённом ниже примере компилятор сначала выполнит сложение, а затем умножение.

    int i = 2 * ( 1 + 3 ) ; /* сложение выполняется до умножения */

В применении к указателям скобки выполняют те же функции.

    int main( int argc , char* pArgs[ ] )

    {

        Student s ;

        Student* pS = &s ; /* Создаём указатель на объект s */

        /* Обращаемся к члену gpa того объекта, на который указывает pS ( теперь всё работает правильно ) */

        ( *pS ).gpa = 3.5 ;

        return 0 ;

    }

Теперь *pS вычисляет объект, на который указывает pS, а следовательно, .gpa обращается к члену этого объекта. 

 

Использование стрелок...170

Использование для разыменования указателей на объекты оператора * со скобками будет прекрасно работать. Однако даже самые твёрдолобые программисты скажут вам, что такой синтаксис разыменования очень неудобен.

Для доступа к членам объекта С++ предоставляет более удобный оператор  -> , позволяющий избежать неуклюжей конструкции со скобками и оператором * ; таким образом, pS -> gpa эквивалентно ( *pS ).gpa . В результате получаем следующий преобразованный код рассмотренной ранее программы.

    int main( int argc , char* pArgs[ ] )

    {

        Student s ;

        Student* pS = &s ; /* Создаём указатель на объект s */

        /* Обращаемся к члену gpa того объекта, на который указывает pS ( теперь всё работает правильно ) */

        pS -> gpa = 3.5 ;

        return 0 ;

    }

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

_________________

170 стр. . Введение в классы

 

Передача указателей функциям — один из способов выразить себя в области указателей. 

 

Вызов функции с передачей объекта по значению...171

Как вы знаете, С++ передаёт аргументы в функцию по ссылке при использовании в описании символа & ( см. ). Однако по умолчанию С++ передаёт функции только значения аргументов. ( Обратитесь к , если вы этого не знали. ) То же касается и составных, определённых пользователем объектов: они также передаются по значению.

    /* PassObjVal — попытка изменить значение объекта в функции оказывается неуспешной при передаче объекта по значению */

    #include

    #include

    #include

    using namespace std ;

    class Student

    {

        public :

            int semesterHours ;

            float gpa ;

    } ;

    void someFn( Student copyS )

    {

            copyS.semesterHours = 10 ;

            copyS.gpa = 3.0 ;

            cout << "Значение copyS.gpa = "

                    << copyS.gpa << "\n" ;

    }

    int main( int argc , char* pArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

            Student s ;

            s.gpa = 0.0 ;

            /* Вывод значения s.gpa до вызова someFn( ) */

            cout << "Значение s.gpa = " << s.gpa << "\n" ;

            /* Передача существующего объекта */

            cout << "Вызов someFn( Student )\n" ;

            someFn( s ) ;

            cout << "Возврат из someFn( Student )\n" ;

            /* Значение s.gpa остаётся равным 0 */

            cout << "Значение s.gpa = " << s.gpa << "\n" ;

            /* Пауза для того, чтобы посмотреть на результат работы программы */

            system( "PAUSE" ) ; return 0 ;

    }

_________________

171 стр. . Указатели на объекты

В этом примере функция main( ) создаёт объект s, а затем передаёт его в функцию someFn( ).

«Осуществляется передача по значению не самого объекта, а его копии.»

[]

Объект copyS начинает своё существование внутри функции someFn( ) и является точной копией объекта s из main( ). При этом любые изменения содержимого объекта copyS никак не отражаются на объекте s из функции main( ). Вот что даёт программа на выходе.

 

    Значение s.gpa = 0

    Вызов someFn( Student )

    Значение copyS.gpa = 3

    Возврат из someFn( Student )

    Значение s.gpa = 0

    Press any key to continue...

 

Вызов функции с передачей указателя...172

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

    /* PassObjPtr — изменение значения объекта в функции при передаче указателя на объект */

    #include

    #include

    #include

    using namespace std ;

    class Student

    {

        public :

            int semesterHours ;

            float gpa ;

    } ;

    void someFn( Student* pS )

    {

            pS -> semesterHours = 10 ;

            pS -> gpa           = 3.0 ;

            cout << "Значение pS -> gpa = "

                 << pS -> gpa << "\n" ;

    }

    int main( int argc , char* pArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

            Student s ;

            s.gpa = 0.0 ;

            /* Вывод значения s.gpa до вызова someFn( ) */

            cout << "Значение s.gpa = " << s.gpa << "\n" ;

            /* Передача существующего объекта */

            cout << "Вызов someFn( Student* )\n" ;

            someFn( &s ) ;

            cout << "Возврат из someFn( Student* )\n" ;

            /* Значение s.gpa теперь равно 3.0 */

            cout << "Значение s.gpa = " << s.gpa << "\n" ;

            /* Пауза для того, чтобы посмотреть на результат работы программы */

            system( "PAUSE" ) ; return 0 ;

    }

_________________

172 стр. . Введение в классы

В этом примере аргумент, передаваемый в someFn( ), имеет тип указателя на объект Student, что записывается как Student* ( это отражает способ вызова программой функции someFn( ) ). Теперь вместо значения объекта s в функцию someFn( ) передаётся указатель на объект s. При этом соответственно изменяется и способ обращения к аргументам функции внутри её тела: теперь для разыменования указателя pS используются операторы-стрелки.

На этот раз вывод программы имеет следующий вид.

 

    Значение s.gpa = 0

    Вызов someFn( Student * )

    Значение pS -> gpa = 3

    Возврат из someFn( Student * )

    Значение s.gpa = 3

    Press any key to continue...

 

Передача объекта no ссылке...173

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

    /* PassObjRef — изменение значения объекта в функции при передаче с использованием ссылки */

    #include

    #include

    #include

    using namespace std ;

    class Student

    {

        public :

            int semesterHours ;

            float gpa ;

    } ;

    void someFn( Student& refS )

    {

            refS.semesterHours = 10 ;

             refS.gpa = 3.0 ;

            cout << "Значение refS.gpa = "

                        << refS.gpa << "\n" ;

    }

    int main( int argc , char* pArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

            Student s ;

            s.gpa = 0.0 ;

_________________

173 стр. . Указатели на объекты

            /* Вывод значения s.gpa до вызова someFn( ) */

            cout << "Значение s.gpa =  " << s.gpa << "\n" ;

            /* Передача существующего объекта */

            cout << "Вызов someFn( Student& )\n" ;

             someFn( s ) ;

            cout << "Возврат из someFn ( Student& )\n" ;

            /* Значение s.gpa теперь равно 3.0 */

            cout << "Значение s.gpa = " << s.gpa << "\n" ;

            /* Пауза для того, чтобы посмотреть на результат работы программы */

            system( "PAUSE" ) ; return 0 ;

    }

 

    Значение s.gpa = 0

    Вызов someFn( Student & )

    Значение refS.gpa = 3

    Возврат из someFn( Student & )

    Значение s.gpa = 3

    Press any key to continue...

В этой программе в функцию someFn( ) передаётся не копия объекта, а ссылка на него. Изменения, внесённые функцией someFn( ) в s, сохраняются внутри main( ).

 

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

[]

 

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

___________

14Это сделано некорректно; как минимум член valFriend не может быть определён в классе того же типа, не считая массы других ошибок. Поэтому к данному примеру следует относиться как к не более чем поясняющей сугубо теоретической модели, которая никогда не будет даже скомпилирована. — Прим. ред.

_________________

176 стр. . Введение в классы

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

Не всякий класс может быть использован для создания связанного списка. Связываемый класс объявляется так, как показано в приведённом ниже фрагменте.

    class LinkableClass

    {

        public :

            LinkableClass* pNext ;

            /* Прочие члены класса */

    } ;

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

Указатель pNext и есть тот элемент, с помощью которого дети объединяются в цепочки. Фигурально выражаясь, можно сказать, что список детей состоит из некоторого количества объектов, каждый из которых имеет тип "ребёнок". Каждый ребёнок указывает на следующего ребенка.

Головной указатель является указателем типа LinkableClass*, и если использовать аналогию с цепочкой детей, держащихся за руки, то можно сказать, что учитель указывает на объект класса "ребёнок" ( любопытно отметить, что сам учитель не является ребёнком — головной указатель не обязательно должен иметь тип LinkableClass ).

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

[]

«Преобразование целочисленного нуля в тип LinkableClass* не обязательно. С++ воспринимает 0 как значение любого типа ( в частности, как "универсальный указатель" ).»

[]

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

    void addHead( LinkableClass* pLC )

    {

        pLC -> pNext = pHead

        pHead = pLC ;

    }

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

 

Другие операции над связанным списком...177

Добавление объекта в начало списка — самая простая операция со связанным списком. Хорошее представление о работе связанного списка даёт процедура прохода по нему до конца списка.

_________________

177 стр. . Указатели на объекты

    /* Проход по связанному списку */

    LinkableClass* pL = pHead ;

    while ( pL )

    {

        /* Выполнение некоторых операций */

        /* Переход к следующему элементу */

        pL = pL -> pNext ;

    }

Сначала указатель pL инициализируется адресом первого объекта в списке ( который хранится в переменной pHead ). Затем программа входит в цикл while. Если указатель pL не нулевой, он указывает на некоторый объект LinkableClass. В этом цикле программа может выполнить те или иные действия над объектом, после чего присвоение pL = pL -> pNext "перемещает" указатель к следующему объекту списка. Если указатель становится нулевым, список исчерпан.

 

Программа LinkedListData...178

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

    /* LinkedListData — хранение данных в связанном списке */

    #include

    #include

    #include

    #include

    using namespace std ;

    /* NameDataSet — хранит имя человека ( этот объект можно легко расширить для хранения другой информации ). */

    class NameDataSet

    {

        public :

            char szName[ 128 ] ;

            /* Указатель на следующую запись в списке */

            NameDataSet* pNext ;

    } ;

    /* Указатель на первую запись списка */

    NameDataSet* pHead = 0 ;

    /* Добавление нового члена в список */

    void add( NameDataSet* pNDS )

    {

        pNDS -> pNext = pHead ;

        /* Заголовок указывает на новую запись */

        pHead = pNDS ;

    }

    /* getData — чтение имени */

    NameDataSet* getData( )

    {

_________________

178 стр. . Введение в классы

        // Читаем имя

        char nameBuffer [ 128 ] ;

        cout << "\nВведите имя:" ;

        cin >> nameBuffer ;

        /* Если это имя — 'exit'... */

        if ( ( stricmp( nameBuffer , "exit" ) == 0 ) )

        {

            /* ...вернуть нулевое значение */

            return 0 ;

        }

        /* Новая запись для заполнения */

        NameDataSet* pNDS = new NameDataSet ;

        /* Заполнение поля имени и обнуление указателя */

        strncpy( pNDS -> szName , nameBuffer , 128 ) ;

        pNDS -> szName[ 127 ] = '\0' ;

        pNDS -> pNext = 0 ;

        /* Возврат адреса созданного объекта */

        return pNDS ;

    }

    int main( int nNumberofArgs , char* pszArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        cout << "Читаем имена студентов\n"

              << "Введите 'exit' для выхода\n" ;

        /* Создание объекта NameDataSet */

        NameDataSet* pNDS ;

        while ( pNDS = getData( ) )

        {

            /* Добавление в конец списка */

            add( pNDS ) ;

        }

        /* Итерация списка для вывода записей */

        cout << "Записи:\n" ;

        pNDS = pHead ;

        while ( pNDS )

        {

            /* Вывод текущей записи */

            cout << pNDS -> szName << "\n" ;

            /* Получение следующей записи */

            pNDS = pNDS -> pNext ;

        }

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }

Несмотря на внушительную длину, программа LinkedListData относительно проста. Функция main( ) начинается с вызова функции getData( ), которая считывает элемент NameDataSet с клавиатуры. Если пользователь вводит строку "exit", getData( ) возвращает нуль. Функция main( ) вызывает функцию add( ), чтобы добавить элемент, который вернула getData( ), в конец связанного списка.

_________________

179 стр. . Указатели на объекты

Если от пользователя больше не поступает элементов NameDataSet, функция main( ) выводит на экран все элементы списка, используя функцию displayData( ).

Функция getData( ) выделяет из кучи пустой объект класса NameDataSet. После этого getData( ) ожидает ввода имени для записи его в соответствующее поле нового объекта. Если пользователь вводит в поле имени строку "exit", функция уничтожает последний созданный объект и возвращает 0. В противном случае getData( ) считывает фамилию и номер социального страхования, после чего обнуляет указатель pNext и передаёт управление вызывающей функции.

«Никогда не оставляйте связывающие указатели не проинициализированными! Старая поговорка программистов гласит: "Не уверен — обнули".»

[]

Функция getData( ) возвращает адрес объекта.

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

«Вывод программы представляет собой введённые имена в обратном порядке. Это происходит потому, что добавление элементов выполняется в начало списка. Возможна вставка элементов в конец списка, однако эта задача посложнее.»  

[]

 

Члены класса могут быть помечены как защищённые, что делает их недоступными извне класса. В отличие от защищённых, открытые ( public ) члены класса доступны для всех.

«Термин "недоступные" не следует понимать буквально. Любой программист может немного повозиться с исходным текстом и убрать ключевое слово protected . Возможность сделать член защищённым разработана для того, чтобы защитить программиста от обращения к члену просто по невнимательности.»

[]

 

Зачем нужны защищённые члены...181

Для того чтобы понять смысл защиты членов класса, нужно вспомнить, каковы цели объектно-ориентированного программирования.

■■■

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

■ Создание класса, способного полноценно управлять своими внутренними членами. Несколько непоследовательно требовать от класса полноценной работы и ответственности за её результаты и одновременно позволять внешним функциям манипулировать его внутренними членами ( это то же самое, что и требовать от создателя микроволновой печи нести ответственность за мои непрофессиональные манипуляции с элементами её внутреннего устройства ).

_________________

181 стр. . Защищённые члены класса: не беспокоить!

■ Сокращение до минимума внешнего интерфейса класса. Гораздо проще изучать и использовать класс, который имеет ограниченный интерфейс ( а интерфейсом класса являются его открытые члены ). Защищённые члены скрыты от пользователя, и их не надо помнить ( в противном случае интерфейсом становится весь класс ). Такой подход называется абстракцией, которая описана в главе 11, "Знакомство с объектно-ориентированным программированием" .

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

■■■

Я так и слышу, как поклонники функционального подхода говорят: "Не нужно делать ничего противоестественного! Достаточно потребовать от программиста, чтобы он попросту не трогал некоторые члены класса". 

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

 

Как устроены защищённые члены...182

Добавление в класс ключевого слова public делает все находящиеся за ним члены класса открытыми, а значит, доступными для функций — не членов класса. Использовав ключевое слово protected, вы делаете все последующие члены класса защищёнными, т.е. недоступными для функций, которые не являются членами класса. Переключаться между защищёнными и открытыми членами класса можно сколько угодно раз.

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

    addCourse ( int hours , float grade ) — добавить пройденный курс;

    grade ( ) — вернуть текущую среднюю оценку;

    hours ( ) — вернуть количество прослушанных часов.

Оставшиеся члены класса Student можно объявить как защищённые, чтобы другие функции не могли "лезть" во внутренние дела класса Student.

    class Student

    {

      public :

        /* grade — возвращает текущую среднюю оценку */

        float grade( )

        {

            return gpa ;

        }

        /* hours — возвращает количество прослушанных часов */

        int hours( )

        {

            return semesterHours ;

        }

        /* addCourse — добавляет к записи студента прослушанный курс */

        float addCourse( int hours , float grade )

        /* Приведённые ниже члены недоступны для внешних функций */

        protected :

        int semesterHours ; /* Количество прослушанных часов */

        float gpa ; /* Средняя оценка */

    } ;

_________________

182 стр. . Введение в классы

Теперь члены semesterHours и gpa доступны только из других членов класса Student, и приведённый ниже пример работать не будет.

    Student s ;

    int main( int argc , char* pArgs[ ] )

    {

        /* Повысим свой рейтинг ( но не слишком сильно, иначе никто не поверит ) */

        s.gpa = 3.5 ; /* Вызовет ошибку при компиляции */

        float gpa = s.grade( ) ; /* Эта открытая функция считывает значение переменной, но вы не можете непосредственно изменить её значение извне */

        return 0 ;

    }

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

«Считается признаком хорошего тона не полагаться на значение защиты по умолчанию, а определить в самом начале объявления класса ключевое слово public или private . Обычно класс начинают описывать с открытых членов, формируя интерфейс класса. Описание защищённых членов класса выполняется позже.»

[]

«Члены класса могут быть защищены с помощью ещё одного ключевого слова — private . Кстати, по умолчанию при описании класса его члены считаются описанными именно как private . Разница между protected и private станет ясной при изучении наследования.»

[]

 

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

 

Защита внутреннего устройства класса...183 

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

    class Student

    {

      public :

        /* grade — делает то же, что и раньше */

        float grade( )

        {

        return gpa ;

        }

        /* Даём возможность изменения средней оценки */

            float grade( float newGPA )

            {

                float oldGPA = gpa ;

                /* Проверяем допустимость значения */

                if ( newGPA > 0 && newGPA <= 4.0 )

                {

                    gpa = newGPA ;

                }

                return oldGPA ;

            }

        /* ...всё остальное остаётся без изменений */

        protected :

        int semesterHours ; /* Количество прослушанных часов */

        float gpa ;

    } ;

_________________

183 стр. . Защищённые члены класса: не беспокоить!

Добавление новой функции grade( float ) позволяет внешним приложениям изменять содержимое gpa. Заметьте, что класс всё равно не позволяет внешним функциям полностью контролировать содержимое своих защищённых членов. Внешнее приложение не может присвоить gpa любое значение, а только то, которое лежит в диапазоне между 0 и 4.0.

Теперь класс Student обеспечивает внешний доступ к своим внутренним членам, одновременно не позволяя присвоить им недопустимое значение.

 

Классы с ограниченным интерфейсом...184

Теперь наш класс предоставляет ограниченный интерфейс. Чтобы использовать класс, достаточно знать, каковы его открытые члены, что они делают и какие аргументы принимают. Это значительно уменьшает объём информации, которую необходимо помнить для работы с классом.

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

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

 

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

 

Зачем нужны конструкторы...189

Объект можно проинициализировать на этапе его объявления, как сделал бы программист на С:

    struct Student

    {

        int semesterHours ;

        float gpa ;

    } ;

    void fn( )

    {

        Student s1 = { 0 , 0.0 } ;

        // или

        Student s2 ;

        s2.semesterHours = 0 ;

        s2.gpa = 0.0 ;

        /* ...продолжение функции... */

    }

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

    class Student

    {

      public :

         void init( )

        {

            semesterHours = 0 ;

            gpa = 0.0 ;

        }

        /* ...прочие открытые члены... */

      protected :

        int semesterHours ;

        float gpa ;

    } ;

    void fn( )

    {

        /* Создание объекта... */ 

        Student s ;

        /* ...и его инициализация */

        s.init( ) ;

        /* ...продолжение функции... */

    }

_________________

189 стр. . Создание и удаление объектов

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

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

 

Работа с конструкторами...190

 

Конструктор — это специальная функция-член, которая автоматически вызывается во время создания объекта. Конструктор должен иметь то же имя, что и класс. Таким образом компилятор сможет определить, что именно эта функция-член является конструктором. Конечно, создатели С++ могли сформулировать это правило как угодно, например, так: "Конструктором является функция с именем init( )". Как именно определено правило, не имеет значения; главное — чтобы конструктор мог быть распознан компилятором. Ещё одним свойством конструктора является то, что он не возвращает никакого значения, поскольку вызывается автоматически ( если бы конструктор и возвращал значение, его всё равно некуда было бы записать ).

 

Конструирование одного объекта...190

Класс с использованием конструктора продемонстрирован в следующем примере.

    //

    /* Constructor — пример вызова конструктора */

    //

    #include

    #include

    #include

    using namespace std ;

    class Student

    {

      public :

        Student( )

        {

            cout << "Конструируем Student" << endl ;

            semesterHours = 0 ;

            gpa = 0.0 ;

        }

        /* ...прочие открытые члены... */

      protected :

        int semesterHours ;

        float gpa ;

    } ;

    int main ( int nNumberofArgs , char* pszArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        cout << "Создание нового объекта Student" << endl ;

        Student s ;

        cout << "Создание нового объекта Student в куче" << endl ;

        Student* pS = new Student ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }

_________________

190 стр. . Введение в классы

В этом примере компилятор сам вызывает конструктор Student::Student( ) в том месте, где объявляется объект s. Тот же эффект имеет и создание объекта Student в куче, что видно из вывода данной программы.

 

    Создание нового объекта Student

    Конструируем Student

    Создание нового объекта Student в куче

    Конструируем Student

    Press any key to continue...

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

    class Student

    {

      public :

        Student( ) ;

        /* ...Остальные открытые члены... */

      protected :

        int semesterHours ;

        float gpa ;

    } ;

    Student::Student( )

    {

        cout << "Конструируем Student\n" ;

        semesterHours = 0 ;

        gpa = 0.0 ;

    }

«В данном примере добавлена небольшая функция main( ) , чтобы эту тестовую программу можно было запустить. Настоятельно рекомендую пройти эту программу в пошаговом режиме отладчика перед тем, как двигаться дальше. О том, как это сделать, вы можете прочесть в главе 10 , "Отладка программ на С++" .»

[]

Выполняя этот пример в пошаговом режиме, дойдите до строки с объявлением объекта s. Выполните команду отладчика Шаг внутрь ( Step into ) , и управление как по волшебству перейдёт к функции Student::Student( ). Продолжайте выполнение конструктора в пошаговом режиме. Когда функция закончится, управление перейдёт к следующей за объявлением объекта класса строке.

«В некоторых случаях команда Шаг внутрь ( Step into ) выполняет весь конструктор сразу, за один шаг. В таком случае вы можете просто установить в нём точку останова, что сработает в любом случае.»

[]

_________________

191 стр. . Создание и удаление объектов

 

Конструирование нескольких объектов...192

Каждый элемент массива конструируется отдельно. Внесём в программу Constructor небольшие изменения.

    //

    /* ConstructArray — пример вызова конструкторов */

    /*                          для массива объектов */

    //

    #include

    #include

    #include

    using namespace std ;

    class Student

    {

      public :

        Student( )

        {

            cout << "Конструируем Student" << endl ;

            semesterHours = 0 ;

            gpa = 0.0 ;

        }

        /* ...прочие открытые члены... */

      protected :

        int semesterHours ;

        float gpa ;

    } ;

    int main( int nNumberofArgs , char* pszArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        cout << "Создание массива из 5 объектов Student" << endl ;

        Student s[ 5 ] ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }

Вывод этой программы выглядит следующим образом:

    Создание массива из 5 объектов Student

    Конструируем Student

    Конструируем Student

    Конструируем Student

    Конструируем Student

    Конструируем Student

    Press any key to continue...

 

Конструирование составных объектов...192

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

_________________

192 стр. . Введение в классы

    //

    /* ConstructMembers — объекты-члены класса */

    /*                 конструируются до конструирования */

    /*                 класса, содержащего эти объекты */

    //

    #include

    #include

    #include

    using namespace std ;

    class Course

    {

        public :

            Course( )   /* пятый ход */

            {

                cout << "Конструируем Course" << endl ;

            }

    } ;

    class Student

    {

        public :

            Student( ) /* второй ход */

            {

                cout << "Конструируем Student" << endl ;

                semesterHours = 0 ;

                gpa = 0.0 ;

            }

        protected :

            int semesterHours ;

            float gpa ;

    } ;

    class Teacher

    {

        public :

            Teacher( )  /* шестой ход */

            {

                cout << "Конструируем Teacher" << endl ;

            }

        protected :

            Course c ;  /* четвёрый ход */

    } ;

    class TutorPair

    {

        public :

            TutorPair( ) /* седьмой ход */

            {

                cout << "Конструируем TutorPair" << endl ;

                noMeetings = 0 ;

            }

        protected :

            Student student ; /* первый ход*/ 

 

            Teacher teacher ; /* третий ход */

            int noMeetings ;

    } ;

    int main( int nNumberofArgs , char* pszArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        cout << "Создаём объект TutorPair" << endl ;

        TutorPair tp ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }  

_________________

193 стр. . Создание и удаление объектов

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

 

    Создаём объект TutorPair

    Конструируем Student

    Конструируем Course

    Конструируем Teacher

    Конструируем TutorPair

    Press any key to continue...

Создание объекта tp в main( ) автоматически вызывает конструктор TutorPair. Перед тем как управление будет передано телу конструктора TutorPair, вызываются конструкторы для объектов-членов student и teacher.

Конструктор Student вызывается первым, поскольку объект этого класса объявлен первым. Затем вызывается конструктор Teacher.

Конструирование члена 'с' класса Teacher ( тип этого члена — Course ) является частью процесса построения объекта класса Teacher. Каждый объект внутри класса должен быть сконструирован до того, как будет вызван конструктор класса-контейнера ( в противном случае этот конструктор не будет знать, в каком состоянии находятся члены-данные ).

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

 

«Это не означает, что TutorPair отвечает за инициализацию Student и Teacher . Каждый класс отвечает за инициализацию своего объекта, где бы тот ни создавался.»

[]

 

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

 

Зачем нужен деструктор...194

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

 

Работа с деструкторами...194

Деструктор имеет то же имя, что и класс, но только с предшествующим ему символом тильды ( ~ ) ( С++ последователен и здесь: ведь символ тильды не что иное, как символ оператора "нет", т.е. деструктор — это отрицание конструктора ).

_________________

194 стр. . Введение в классы

 Как и конструктор, деструктор не имеет типа возвращаемого значения. С учётом сказанного деструктор класса Student будет выглядеть так:

    class Student

    {

        public :

            Student( )

            {

                semesterHours = 0 ;

                gpa = 0.0 ;

            }

            ~Student( )

            {

                /* Все используемые ресурсы освобождаются здесь */

            }

            /* ...остальные открытые члены... */

        protected :

            int semesterHours ;

            float gpa ;

    } ;

Деструктор вызывается автоматически, когда объект уничтожается или, если говорить языком С++, происходит его деструкция. Чтобы избежать тавтологии ( "деструктор вызывается для деструкции объекта" ), я по возможности старался не применять этот термин. Можно также сказать "когда объект выходит из области видимости". Локальный объект выходит из области видимости, когда функция, создавшая его, доходит до команды return. Глобальный или статический объект выходит из области видимости, когда прекращается работа программы.

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

    //

    /* DestructMembers — демонстрация использования */

    /*                  конструкторов и деструкторов */

    //

    #include

    #include

    #include

    using namespace std ;

    class Course

    {

        public :

            Course( )    { cout << "Конструктор Course" << endl ; }

            ~Course( ) { cout << "Деструктор Course" << endl ; }

    } ;

    class Student

    {

        public :

            Student( )

            {

                cout << "Конструктор Student" << endl ;

                semesterHours = 0 ;

                gpa = 0.0 ;

_________________

195 стр. . Создание и удаление объектов

            }

            ~Student( ) { cout << "Деструктор Student" << endl ; }

        protected :

            int semesterHours ;

            float gpa ;

    } ;

    class Teacher

    {

        public :

            Teacher( )

            {

                cout << "Конструктор Teacher" << endl ;

                pC = new Course ;

            }

            ~Teacher( )

            {

                cout << "Деструктор Teacher" << endl ;

                delete pC ;

            }

        protected :

            Course* pC ;

    } ;

    class TutorPair

    {

        public :

            TutorPair( )

            {

                cout << "Конструктор TutorPair" << endl ;

                noMeetings = 0 ;

            }

            ~TutorPair( ) { cout << "Деструктор TutorPair" << endl ; }

        protected :

            Student student ;

            Teacher teacher ;

            int noMeetings ;

    } ;

    TutorPair* fn( )

    {

        cout << "Создание объекта TutorPair в функции fn( )"

               << endl ;

        TutorPair tp ;

        cout << "Создание объекта TutorPair в куче" << endl ;

        TutorPair* pTP = new TutorPair ;

        cout << "Возврат из функции fn ( )" << endl ;

        return pTP ;

    }

    int main( int nNumberofArgs , char* pszArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        /* Вызов функции fn( ) и возврат объекта TutorPair в куче */

        TutorPair* pTPReturned = fn( ) ;

        cout << "Получен объект в куче" << endl ;

        delete pTPReturned ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    } 

_________________

196 стр. . Введение в классы

Функция main( ) вызывает функцию fn( ), которая создаёт объект tp ( область видимости этого объекта ограничена функцией ), а также объект в куче, возвращаемый функции main( ), которая и уничтожает его, возвращая память в кучу.

При выполнении программы вы увидите на экране следующее.

 

    Создание объекта TutorPair в функции fn( )

    Конструктор Student

    Конструктор Teacher

    Конструктор Course

    Конструктор TutorPair

    Создание объекта TutorPair в куче

    Конструктор Student

    Конструктор Teacher

    Конструктор Course

    Конструктор TutorPair

    Возврат из функции fn( )

    Деструктор TutorPair

    Деструктор Teacher

    Деструктор Course

    Деструктор Student

    Получен объект в куче

    Деструктор TutorPair

    Деструктор Teacher

    Деструктор Course

    Деструктор Student

    Press any key to continue...

Здесь создаются два объекта TutorPair. Первый, tp, является локальным объектом функции fn( ), а второй, рТР, размещается в куче. Первый объект выходит из области видимости при возврате из функции и уничтожается автоматически, а второй остаётся до тех пор, пока функция main( ) не уничтожает его явным образом.

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

[]

_________________

197 стр. . Создание и удаление объектов

 

С++ позволяет программисту определить конструктор с аргументами, например:

    class Student

    {

    public :

        Student( char *pName ) ;

        /* Продолжение класса Student */

    } ;

 

Зачем конструкторам нужны аргументы...198

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

_________________ 

198 стр. . Введение в классы

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

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

 

Как использовать конструктор с аргументами...199

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

При этом нельзя забывать, что вы вызываете конструктор не как нормальную функцию и передать ему аргумент можно только в момент создания объекта. Так, приведённая ниже программа создаёт объект s класса Student, вызывая конструктор Student( char* ). Объект s уничтожается в момент возврата из функции main( ).

    //

    /* ConstructorWArg — конструктор с аргументами */

    //

    #include

    #include

    #include

    #include

    using namespace std ;

    const int MAXNAMESIZE = 40 ;

    class Student

    {

        public :

            Student( char* pName )

            {

                strncpy( name , pName , MAXNAMESIZE ) ;

                name[ MAXNAMESIZE - 1 ] = '\0' ;

                semesterHours = 0 ;

                gpa = 0.0 ;

            }

        /* ...прочие открытые члены... */

        protected :

            char name[ MAXNAMESIZE ] ;

            int semesterHours ;

            float gpa ;

    } ;

    int main( int argcs , char* pArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        Student s( "О. Danny Boy" ) ;

        Student* pS = new Student( "E. Z. Rider" ) ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    } 

_________________

199 стр. . Аргументация конструирования

В этом примере конструктор выглядит почти так же, как и конструктор из , с тем лишь отличием, что он принимает аргумент pName, имеющий тип char*. Этот конструктор инициализирует все данные-члены нулевыми значениями, за исключением члена name, который инициализируется строкой pName.

Объект s создаётся в функции main( ). Аргумент, передаваемый конструктору, находится в строке объявления s сразу же за именем объекта. Благодаря такому объявлению студент s получил имя Danny. Закрывающая фигурная скобка функции main( ) вызывает гром и молнию деструктора на голову несчастного Danny. Аналогично создаётся объект в куче. 

 

«Многие конструкторы в этой главе нарушают правило "функции размером больше трёх строк не должны быть inline -функциями". Я просто решил облегчить вам чтение ( а теперь — ваши аплодисменты! ).» 

[]

 

В предыдущих примерах использовались данные-члены простых типов, такие как float или int. Переменные таких простых типов легко инициализировать, передав необходимое значение конструктору. Но что, если класс содержит данные-члены, которые являются объектами других классов? Рассмотрим приведённый ниже пример.

    /* ConstructingMembers — передача параметров */

    /*                      конструктору члена */

    #include

    #include

    #include

    #include

    using namespace std ;

    const int MAXNAMESIZE = 40 ;

    int nextStudentId = 0 ;

    class StudentId

    {

      public :

        StudentId( )

        {

            value = ++nextStudentId ;

            cout << "Присвоение id " << value << endl ;

        }

      protected :

_________________

204 стр. . Введение в классы

        int value ;

    } ;

    class Student

    {

      public :

        Student( char* pName )

        {

            cout << "Конструктор Student( " << pName

                  << " )" << endl ;

            strncpy( name , pName , MAXNAMESIZE ) ;

            name[ MAXNAMESIZE - 1 ] = '\0' ;

            semesterHours = 0 ;

            gpa = 0.0 ;

        }

      /* ...прочие открытые члены... */

      protected :

        char name[ MAXNAMESIZE ] ;

        int semesterHours ;

        float gpa ;

        StudentId id ;

    } ;

    int main( int argcs , char* pArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        Student s( "Chester" ) ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }

В момент создания объекту типа Student присваивается собственный идентификатор. В данном примере идентификаторы "раздаются" последовательно, с помощью глобальной переменной nextStudentId.

Наш класс Student содержит член id, который является экземпляром класса StudentId. Конструктор класса Student не может присвоить значение члену id, поскольку Student не имеет доступа к защищённым членам класса StudentId. Можно было бы сделать Student другом класса StudentId, но такой подход нарушил бы положение объектно-ориентированного программирования, утверждающее, что каждый класс должен заниматься своим делом. Нам нужна возможность вызывать конструктор класса StudentId в процессе создания класса Student.

С++ делает это автоматически, инициализируя член id с помощью конструктора по умолчанию StudentId::StudentId( ). Это происходит после вызова конструктора класса Student, но до того, как управление передаётся первой строке этого конструктора. ( Выполните в пошаговом режиме приведённую выше программу, и вы поймёте, о чём я говорю. ) Выполнение приведённой выше программы выведет на экран следующие строки:

    Присвоение id 1

    Конструктор Student( Chester )

    Press any key to continue...

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

_________________

205 стр. . Аргументация конструирования

Если программист не обеспечит свой класс конструктором, то конструктор по умолчанию, созданный С++, вызовет конструкторы всех данных-членов для их инициализации. То же касается и уничтожения объекта. Деструктор класса автоматически вызывает деструкторы всех данных-членов ( у которых они определены ).

Теперь мы знаем, что будет с конструктором по умолчанию. Но что, если мы захотим вызвать другой конструктор? Куда в этом случае нужно поместить объект? Я имею в виду следующее: представьте себе, что вместо автоматической генерации идентификатора студента, необходимо передать его конструктору Student, который в свою очередь, должен передать его конструктору StudentId.

«Для начала я покажу вам способ, который работать не будет. ( Здесь приведена только существенная для понимания часть кода — полностью программа ConstructSeparateID.cpp находится на прилагаемом компакт-диске . )»

[]

    class Student

    {

    public :

        Student( char *pName = "no name" , int ssId = 0 )

        {

            cout << "Конструктор Student( " << pName

                  << " )" << endl ;

            strncpy( name , pName , MAXNAMESIZE ) ;

            name[ MAXNAMESIZE - 1 ] = '\0' ;

            semesterHours = 0 ;

            gpa = 0.0 ;

            /* Вот это можно и не пытаться делать - толку не будет */

            StudentId id( ssId ) ;

        }

    protected :

        char name[ MAXNAMESIZE ] ;

        StudentId id ;

    } ;

Конструктор класса StudentId был переписан так, чтобы он мог принимать внешнее значение ( значение по умолчанию необходимо для того, чтобы приведённый фрагмент откомпилировался без ошибок, которые появятся в противном случае; почему — станет понятно чуть позже ). Внутри конструктора Student программист ( т.е. я ) попытался невиданным доселе способом сконструировать объект id класса StudentId.

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

 

    Присвоение id 0

    Конструктор Student( Chester )

    Присвоение id 1234

    Деструктор id 1234 

    Сообщение из функции main( )

    Press any key to continue...

    Деструктор id 0

Первая проблема заключается в том, что конструктор класса StudentId вызывается дважды: сначала с нулём и только затем с ожидаемым числом 1234. Кроме того, объект с идентификатором 1234 ликвидируется перед выводом сообщения от main( ). Очевидно, объект класса StudentId ликвидируется внутри конструктора класса Student.

_________________

206 стр. . Введение в классы

Объяснить такое странное поведение программы довольно просто. Член id уже существует к моменту перехода управления к телу конструктора Student. Поэтому вместо инициализации уже существующего члена id объявление в последней строке конструктора Student вызывает создание локального объекта с таким же именем. Этот локальный объект и уничтожается при выходе из конструктора.

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

[]

    //

    /* ConstructDataMember — передача параметра */

    /*                      конструктору члена */

    //

    #include

    #include

    #include

    #include

    using namespace std ;

    const int MAXNAMESIZE = 40 ;

    class StudentId

    {

      public :

        StudentId( int id = 0 )

        {

            value = id ;

            cout << "Присвоение id " << value << endl ;

        }

        ~StudentId( )

        {

            cout << "Деструктор id " << value << endl ;

        }

      protected :

        int value ;

    } ;

    class Student

    {

      public :

        Student( char *pName = "no name" , int ssId = 0 )

           : id( ssId )

        {

            cout << "Конструктор Student( " << pName

                 << " )" << endl ;

            strncpy( name , pName , MAXNAMESIZE ) ;

            name[ MAXNAMESIZE - 1 ] - '\0' ;

        }

      protected :

        char name[ 40 ] ;

        StudentId id ;

    } ;

    int main( int argcs , char* pArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        Student s( "Chester" , 1234 ) ;

        cout << "Сообщение из функции main" << endl ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    } 

_________________

207 стр. . Аргументация конструирования

Обратите особое внимание на первую строку конструктора. В этой строке есть кое-что, с чем вы до этого не встречались. Следующая за двоеточием команда вызывает конструкторы членов данного класса. Компилятор С++ прочтёт эту строку так: "Вызвать конструктор для члена id с аргументом ssId. Все остальные данные-члены, не вызванные явно, строить с использованием конструктора по умолчанию".

Результат работы этой программы свидетельствует, что всё получилось так, как мы и хотели.

 

    Присвоение id 1234

    Конструктор Student( Chester )

    Сообщение из функции main

    Press any key to continue...

    Деструктор id 1234

 

Конструкторы константных членов...208

Ещё одна проблема возникает при инициализации членов, объявленных как const. Вспомним, что переменная, объявленная как const, инициализируется при объявлении и после этого не может быть изменена. Каким же образом конструктор может присвоить значение константному члену? Проблема решается путём использования синтаксиса с двоеточием:

    class Mammal

    {

        public :

            Mammal( int nof ) : numberOfFeet( nof )

            { }

        protected :

            const int numberOfFeet ;

    } ;

Объект класса Mammal ( млекопитающее ) имеет постоянное количество ног ( ампутации не рассматриваются ). Таким образом, это количество следует объявить как const. Значение данному члену присваивается при создании объекта, и после этого не может быть изменено.

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

[]

 

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

_________________

208 стр. . Введение в классы

Порядок создания объектов подчиняется перечисленным ниже правилам.

■■■

■ Локальные и статические объекты создаются в том порядке, в котором они объявлены в программе.

■ Статические объекты создаются только один раз.

■ Все глобальные объекты создаются до вызова функции main( ) .

■ Нет какого-либо определённого порядка создания глобальных объектов.

■ Члены создаются в том порядке, в котором они объявлены внутри класса.

■ Деструкторы вызываются в порядке, обратном порядку вызова конструкторов.

■■■

«Статическая переменная — это переменная, которая является локальной по отношению к функции, но при этом сохраняет своё значение между вызовами функции. Глобальная переменная — это переменная, объявленная вне какой-либо функции.»

[]

Рассмотрим каждое из приведённых выше правил.

 

Локальные объекты создаются последовательно...209

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

 

Статические объекты создаются один раз...209

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

    /* ConstructStatic — демонстрация однократного */

    /*                создания статических объектов */

    #include

    #include

    #include

    using namespace std ;

    class DoNothing

    {

        public :

            DoNothing( int initial )

            {

                cout << "DoNothing сконструирован со значением "

                     << initial

                     << endl ;

            }

    } ;

_________________

209 стр. . Аргументация конструирования

    void fn( int i )

    {

        cout << "Функции fn передано значение " << i << endl ;

        static DoNothing dn( i ) ;

    }

    int main( int argcs , char* pArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        fn( 10 ) ;

        fn( 20 ) ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }

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

Функции fn передано значение 10

DoNothing сконструирован со значением 10

Функции fn передано значение 20

Press any key to continue...

Обратите внимание, что сообщение от функции fn( ) появилось дважды, а сообщение от конструктора DoNothing — только при первом вызове fn( ).

 

Все глобальные объекты создаются до вызова main( )...210

Все глобальные объекты входят в область видимости программы. Таким образом, все они конструируются до того, как управление передаётся функции main( ).

«При отладке такой порядок может привести к неприятностям. Некоторые отладчики пытаются выполнить весь код, который находится до main( ) , и только потом передать управление пользователю. Это прекрасно подходит для С, поскольку до входа в функцию main( ) там не может быть никакого кода, написанного пользователем. Однако в С++ это может стать причиной большой головной боли, поскольку тела конструкторов для всех глобальных объектов к моменту передачи управления main( ) уже выполнены. Если хоть один из этих конструкторов содержит серьёзный "жучок", программа погибнет до того, как начнёт выполняться!»

[]

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

 

Порядок создания глобальных объектов не определён...210

Локальные объекты создаются в порядке выполнения программы. Для глобальных же объектов порядок создания не определён. Как вы помните, глобальные объекты входят в область видимости программы одновременно. Возникает вопрос: почему бы тогда компилятору не начать с начала файла с исходной программой и не создавать глобальные объекты в порядке их объявления? ( Честно говоря, я подозреваю, что на самом деле большинство компиляторов так и поступают. ) Увы, такой подход отлично работал бы, но только в том случае, если бы программа всегда состояла из одного файла.

_________________

210 стр. . Введение в классы

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

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

    class Student

    {

        public :

            Student ( unsigned id ) : studentId( id ) { }

            const int StudentId ;

    } ;

    class Tutor

    {

        public :

            Tutor ( Student& s ) : tutoredId( s.studentId ) { }

            int tutoredId ;

    } ;

    /* Создаём студента */

    Student randy( 1234 ) ;

    /* Назначаем студенту учителя */

    Tutor jenny( randy ) ;

В этом примере конструктор Student присваивает студенту идентификатор, а конструктор класса Tutor записывает этот идентификатор студента, которому нужен учитель. Программа объявляет студента randy, а затем назначает ему учителя jenny.

При этом подразумевается, что randy создаётся раньше, чем jenny; в этом-то и состоит проблема. Представьте себе, что порядок создания этих объектов будет другим. Тогда объект jenny будет построен с использованием блока памяти, который пока что не является объектом типа Student, а значит, вместо идентификатора студента в randy будет находиться непредсказуемое значение.

«Приведённый выше пример несложен и несколько надуман. Однако проблемы, создаваемые глобальными объектами, могут оказаться гораздо коварнее. Во избежание этого не допускайте, чтобы конструктор глобального объекта обращался к другому глобальному объекту.»

[]

 

Члены создаются в порядке их объявления...211

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

    class Student

    {

        public :

            Student ( int id , int age ) : sAge( age ) , sId( id ) { }

            const int sId ;

            const int sAge ;

    } ;

_________________

211 стр. . Аргументация конструирования

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

 

Деструкторы удаляют объекты в порядке, обратном порядку их создания...212

В каком бы порядке ни вызывались конструкторы объектов, вы можете быть уверены, что их деструкторы будут вызваны в обратном порядке. ( Приятно сознавать, что хоть одно правило в С++ не имеет никаких "если", "и" или "но". )

_________________

212 стр. . Введение в классы

 

Конструктор, который используется С++ для создания копий объекта, называется копирующим конструктором, или конструктором копирования. Он имеет вид X::Х( Х& ) ( или X::X( const Х& ) ), где X — имя класса. Да, это не ошибка — это действительно конструктор класса X, который требует в качестве аргумента ссылку на объект класса X. Это звучит несколько бессмысленно, но не торопитесь с выводами и позвольте объяснить, зачем такое "чудо" в С++. 

 

Зачем нужен копирующий конструктор...213

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

    void fn( Student fs )

    {

        /* Некоторые действия */

    }

    int main( int argcs , char* pArgs[ ] )

    {

        Student ms ;

        fn( ms ) ;

        return 0 ;

    }

При вызове описанной функции fn( ) ей будет передан в качестве аргумента не сам объект, а его копия.

_________________

213 стр. . Копирующий конструктор

«В С++ аргументы функции передаются по значению.»

[]

Теперь попробуем понять, что же значит — создать копию объекта. Для этого требуется конструктор, который будет создавать объект ( даже если копируется уже существующий объект ). С++ мог бы побайтово скопировать существующий объект в новый, но как быть, если побайтовая копия не совсем то, что нам нужно? Что, если мы хотим нечто иное? ( Не спрашивайте у меня пока, что такое это "иное" и зачем оно нужно. Немного терпения! ) У нас должна быть возможность самим определять, как будет создаваться копия объекта.

Таким образом, в приведённом выше примере необходим копирующий конструктор, который будет выполнять копирование объекта ms при вызове функции fn( ). Этот частный копирующий конструктор и есть Student::Student( students ) ( попробуйте-ка произнести эту скороговорку... ).

 

Использование конструктора копирования ...214

Лучший путь понять, как работает конструктор копирования, — это увидеть его в действии. Рассмотрим приведённый ниже пример с классом Student.

    //

    /* CopyConstructor — работа конструктора копирования */

    //

    #include

    #include

    #include

    #include

    using namespace std ;

    const int MAXNAMESIZE = 40 ;

    class Student

    {

      public :

        /* conventional constructor — обычный конструктор */

        Student( char *pName = "no name" , int ssId = 0 )

        {

            strcpy( name , pName ) ;

            id = ssId ;

            cout << "Конструируем " << name << endl ;

        }

        /* Копирующий конструктор */

        Student( Student& s )

        {

            strcpy( name , "Копия " ) ;

            strcat( name , s.name ) ;

            id = s.id ;

            cout << "Сконструирована " << name << endl ;

        }

        ~Student( )

        {

            cout << "Деструкция " << name << endl ;

        }

      protected :

_________________

214 стр. . Введение в классы

        char name[ MAXNAMESIZE ] ;

        int id ;

    } ;

    /* fn — передача параметра по значению */

    void fn( Student copy )

    {

        cout << "В функции fn( )" << endl ;

    }

    int main( int nNumberofArgs , char* pszArgs[ ] )

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать кириллицы */

        Student Chester( "Chester" , 1234 ) ;

        cout << "Вызов fn( )" << endl ;

        fn( Chester ) ;

        cout << "Возврат из fn( )" << endl ;

        /* Пауза для того, чтобы посмотреть на результат работы программы */

        system( "PAUSE" ) ; return 0 ;

    }

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

 

    Конструируем Chester

    Вызов fn( )

    Сконструирована Копия Chester

    В функции fn( )

    Деструкция Копия Chester

    Возврат из fn( )

    Press any key to continue...

    Деструкция Chester

Давайте внимательно рассмотрим, как же работает эта программа. Обычный конструктор выводит первую строку; затем main( ) выводит строку "Вызов...". После этого С++ вызывает копирующий конструктор для создания копии объекта Chester ( которая и передаётся функции fn( ) в качестве аргумента ). Эта копия будет ликвидирована при возврате из функции fn( ) ; исходный же объект Chester ликвидируется при выходе из main( ).

Копирующий конструктор выглядит как обычный, но обладает особенностью получать в качестве аргумента ссылку на другой объект того же класса. ( Обратите внимание, что использованный в примере копирующий конструктор, помимо простого копирования объекта, делает кое-что ещё, например выводит строку "Конструируем копию...". Эту возможность выполнять кроме собственно копирования и другие действия можно будет с успехом применить для решения разных задач. Конечно, копирующие конструкторы обычно ограничиваются созданием копий уже существующих объектов, но на самом деле они могут делать всё, что угодно программисту. )

 

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

    Student fn( ) ; /* Возвращает объект по значению */

    int main ( int argcs , char* pArgs[ ] )

    {

        Student s ;

        s = fn( ) ; /* В результате вызова fn( ) будет создан временный объект */

        return 0 ;

    }

Функция fn( ) возвращает объект по значению. В конечном счёте этот объект будет скопирован в s, но где он находится до этого?

Для хранения таких объектов С++ создаёт временные объекты ( такие объекты создаются и в некоторых других случаях ). "Хорошо, — скажете вы, — С++ создаёт временные объекты, но откуда он знает, когда их надо уничтожать?" ( Спасибо за хороший вопрос! ) В нашем примере это не имеет особого значения, поскольку временный объект выйдет из области видимости, как только копирующий конструктор скопирует его в s. Но что, если s будет определено как ссылка?

_________________

221 стр. . Копирующий конструктор

    int main ( int argcs , char* pArgs[ ] )

    {

        Student& refS = fn( ) ;

        /* ...Что теперь?... */

        return 0 ;

    }

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

    Student fn1( ) ;

    int fn2( Student& ) ;

    int main ( int argcs , char* pArgs[ ] )

    {

        int x ;

        /* Создаём объект Student, вызывая fn1( ), а затем передаём этот объект функции fn2( ) . fn2( ) возвращает целочисленное значение, которое используется для выполнения некоторых вычислений. Весь этот период временный объект, возвращённый функцией fn1( ), доступен */

        х = 3*fn2( fn1( ) ) + 10 ;

        /* Временный объект, который вернула функция fn1( ), становится недоступен */

        /* ...Остальной код... */

        return 0 ;

    }

Таким образом, пример с использованием ссылки неверен, поскольку объект выйдет из области видимости, a refS будет продолжать существовать, и в результате ссылка будет указывать на несуществующий объект.

 

Как избегать временных объектов...222

Вы можете подумать, что изучение всего этого копирования объектов туда и обратно — пустая трата времени. Что, если вы не хотите делать все эти копии? Самое простое решение заключается в передаче и приёме объектов функции по ссылке. Это исключает все описанные неприятности.

Но как убедиться, что С++ не создаёт временных объектов незаметно для вас? Допустим, ваш класс использует ресурсы, которые вы не хотите копировать. Что же вам делать?

Можно просто использовать вывод сообщения в копирующем конструкторе, которое предупредит вас о том, что была сделана копия. А можно объявить копирующий конструктор защищённой функцией, как показано в приведённом ниже примере.

    class Student

    {

    protected :

        Student( Student& s ){ }

    public :

        /* ...Всё остальное как обычно... */

    } ;

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

_________________

222 стр. . Введение в классы

 

Аргумент копирующего конструктора...223

Использование копирующего конструктора для создания временных объектов и копий объектов вызывает один интересный вопрос. Рассмотрим очередной пример.

    class Student

    {

    public :

        Student( Student s )

        {

            /* ...всё, что угодно... */

        }

    } ;

    void fn( Student fs )

    {

    }

    int main ( int argcs , char* pArgs[ ] )

    {

        Student ms ;

        fn( ms ) ;

        return 0 ;

    }

И в самом деле, почему бы не объявить копирующий конструктор класса Student как Student::Student( Student ) ? Однако такое объявление попросту невозможно! При попытке скомпилировать программу с таким объявлением вы получите сообщение об ошибке; Dev-C++ сообщит примерно следующее:

invalid constructor; you probably meant ' Student ( const Student& )'

Давайте подумаем, почему аргумент конструктора обязательно должен быть ссылкой? Представим, что ограничений на тип аргумента копирующего конструктора нет. В этом случае, когда main( ) вызовет функцию fn( ), компилятор С++ использует копирующий конструктор для создания копии объекта класса Student. При этом копирующий конструктор, получая объект по значению, требует вызова копирующего конструктора для создания копии объекта класса Student. И так до полного исчерпания памяти и аварийного останова...

_________________

223 стр. . Копирующий конструктор

 

Данные-члены можно сделать общими для всех объектов класса, объявив их статическими ( static ). Такие члены называются статическими данными-членами ( я бы удивился, если бы они назывались по-другому... ).

 

Зачем нужны статические члены...224

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

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

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

_________________

224 стр. . Введение в классы

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

[]

 

Использование статических членов...225

Статические данные-члены объявляются в классе с помощью ключевого слова static, как показано в приведённом ниже примере.

    class Student

    {

    public :

        Student( char *pName = "no name" ) : name( pName )

        {

            noOfStudents++ ;

        }

        ~Student( )

        {

            noOfStudents-- ;

        }

    protected :

        static int noOfStudents ;

        string name ;

    } ;

    Student s1 ;

    Student s2 ;

Член noOfStudents входит в состав класса Student, но не входит в состав объектов s1 и s2. Таким образом, для любого объекта класса Student существуют отдельные члены name и только один noOfStudents, который доступен для всех объектов класса Student.

"Хорошо,— спросите вы,— если место под noOfStudents не выделено ни в каком объекте класса Student, то где же он находится?" Ответ прост: это место не выделяется. Вы должны сами выделить для него место так, как показано ниже, int Student::noOfStudents = 0 ;

Этот своеобразный синтаксис выделяет место для статического члена класса и инициализирует его нулём. Статические данные-члены должны быть глобальными ( как статические переменные не могут быть локальными по отношению к некоторой функции ).

«Для любого члена, имя которого встречается вне класса, требуется указание класса, к которому он принадлежит.»

[]

#i_253.jpg

«Такое выделение памяти вручную удивляет, но только до тех пор, пока вы не столкнётесь с проектами, в которых используется несколько модулей с исходным кодом. С++ должен знать, в каком именно .срр -файле надо выделить пространство для статической переменной. В случае нестатических членов это не составляет проблемы, так как память выделяется там и тогда, где и когда создаётся объект класса.»

[]

_________________

225 стр. . Статические члены

 

Обращение к статическим данным-членам...226

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

    class Student

    {

    public :

        Student( )

        {

            noOfStudents++ ; /* Обращение из класса */

            /* ...остальная программа... */

        }

        static int noOfStudents ;

        /* ...то же, что и раньше... */

    } ;

    void fn( Student& s1 , Student s2 )

    {

        /* Обращение к открытому статическому члену */

        cout << "Количество студентов - "

             << s1.noOfStudents /* Обращение извне Класса */

             << "\n" ;

    }

В функции fn( ) происходит обращение к noOfStudents с использованием объекта s1. Однако, поскольку s1 и s2 имеют одинаковый доступ к члену noOfStudents, возникает вопрос: почему я выбрал именно s1? Почему я не использовал s2? На самом деле это не имеет значения. Вы можете обращаться к статическим членам, используя любой объект класса, например, так:

    /* ...Класс определяется так же, как и раньше... */

    void fn( Student& s1 , Student s2 )

    {

        /* Представленные команды приведут к идентичному результату */

        cout << "Количество студентов - "

             << s1.noOfStudents <<"\n" ;

        cout << "Количество студентов - "

             << s2.noOfStudents << "\n" ;

    }

На самом деле нам вообще не нужен объект! Можно использовать просто имя класса, как показано в следующем примере:

    /* ...Класс определяется так же, как и раньше... */

    void fn( Student& s1 , Student s2 )

    {

        /* Результат остаётся неизменным */

        cout << "Количество студентов - "

             << Student::noOfStudents

             << " \ n" ;

    }

Независимо от того, будете ли вы использовать имя объекта или нет, С++ всё равно будет использовать имя класса.

_________________

226 стр. . Введение в классы

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

[]

    class Student

    {

        static int noOfStudents ;

        Student& nextStudent( ) ;

        /* ...To же, что и раньше... */

    } ;

    void fn( Student& s )

    {

        cout << s.nextStudent( ).noOfStudents

              << "\n" ;

    }

Функция-член nextStudent( ) в этом примере не должна вызываться. Всё, что нужно знать С++ для обращения к noOfStudents, — тип возвращаемого значения, а он может это выяснить и не выполняя данную функцию[ 15 ] .

 

Применение статических данных-членов...227

Существует бесчисленное множество областей применения статических данных-членов, но здесь мы остановимся лишь на нескольких из них. Во-первых, можно использовать статические члены для хранения количества объектов, задействованных в программе. Например, в классе Student такой счётчик можно проинициализировать нулём, а затем увеличивать его на единицу внутри конструктора и уменьшать внутри деструктора. Тогда в любой момент этот статический член будет содержать количество существующих в данный момент объектов класса Student. Однако следует помнить, что этот счётчик будет содержать количество объектов, существующих в данный момент ( включая временные объекты ), а не количество студентов[ 16 ] .

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

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

___________________

15Вообще говоря, это зависит от используемого компилятора. Так, тот же Dev-C++ вызовет данную функцию, в чём легко убедиться, скомпилировав и выполнив приведённый пример ( дополнив его, естественно, функцией main( ), в которой вызывается fn( ) ). — Прим. ред.

16Ещё одно замечание: в этом случае вы должны позаботиться о том, чтобы счётчик увеличивался во всех конструкторах, включая конструктор копирования. — Прим. ред.

_________________

227 стр. . Статические члены