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

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

В программе FunctionDemo показано, как упростить программу NestDemo с помощью создания функции sumSequence( ).

_________________

81 стр. . Создание функций

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

[]

    /* FunctionDemo — демонстрация использования функций. */

    /*               Внутренний цикл программы оформлен как отдельная функция */

    #include

    #include

    #include

    using namespace std ;

    /* sumSequence — суммирует последовательность чисел, введённых     с клавиатуры, пока пользователь не введёт отрицательное число. Возвращает сумму введённых чисел */

    int sumSequence( void )

    {

        /* Бесконечный цикл */

        int accumulator = 0 ;

        for ( ; ; )

        {

            /* Ввод следующего числа */

            int value = 0 ;

            cout << "Введите следующее число: " ;

            cin >> value ;

            /* Если оно отрицательное... */

            if ( value < 0 )

            {

                /* ...тогда выходим из цикла */

                break ;

            }

            /* ...иначе добавляем число к переменной accumulator */

            accumulator = accumulator + value ;

        }

        /* Возвращаем значение суммы */

        return accumulator ;

    }

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

    {

        setlocale ( LC_ALL , ". 1251" ) ; /* печать русских текстов */

        cout << "Эта программа суммирует последовательности "

                     << "чисел. Каждая\nпоследовательность"

                     << "заканчивается отрицательным числом.\n"

                     << "Ввод серий завершается вводом "

                     << "двух отрицательных чисел подряд\n" ;

        /* Суммируем последовательности чисел... */

        int accumulatedValue ;

_________________

82 стр. . Становимся функциональными программистами

        for ( ; ; )

        {

            /* Суммируем последовательности чисел, введённых с клавиатуры */

            cout << "\nВведите следующую последовательность\n" ;

            accumulatedValue = sumSequence( ) ;

            if ( accumulatedValue == 0 ) { break ; }

            /* Вывод общей суммы на экран */

            cout << "\nОбщая сумма равна "

                        << accumulatedValue

                        << "\n" ;

        } ;

        cout << "Программа завершена\n" ;

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

        system( "PAUSE" ) ; return 0 ;

    }     

Определение функции sumSequence( )...83

Определение этой функции начинается с инструкции int sumSequence( void ). Заключённый в фигурные скобки блок кода называется телом функции. Как видите, тело функции sumSequence( ) идентично внутреннему циклу программы NestDemo. 

Вызов функции sumSequence( )...83

Главная часть программы сконцентрирована в фигурных скобках, следующих после объявления функции main( ). Эта часть кода очень напоминает программу NestDemo.

Различие состоит в том, что внутри функции main( ) содержится выражение accumulatedValue = sumSequence( ). В правой части этого выражения вызывается функция sumSequence( ). Возвращаемое функцией значение сохраняется в переменной accumulatedValue, а затем выводится на экран. Главная программа выполняет цикл до тех пор, пока значение суммы, возвращаемой внутренней функцией, остаётся отличным от 0. Нулевое значение говорит о том, что пользователь закончил вычисление сумм последовательностей. 

Разделяй и властвуй...83 

Программа FunctionDemo выделяет внутренний цикл в функцию sumSequence( ). Такое выделение отнюдь не произвольно. Функция sumSequence( ) играет свою, отдельную роль.

«Хорошую функцию можно легко описать одним предложением с минимальным количеством слов "и" и "или". Например, функция sumSequence( ) суммирует последовательность целочисленных значений, введённых пользователем. Это определение весьма компактно и легко воспринимается.»

[]

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

_________________

83 стр. . Создание функций

Вот как выглядит пример работы рассмотренной программы.

      Эта программа суммирует последовательности чисел. Каждая

      последовательность заканчивается отрицательным числом.

      Ввод серий завершается вводом двух отрицательных чисел подряд

      Введите следующую последовательность

      Введите следующее число: 1

      Введите следующее число: 2

      Введите следующее число: 3

      Введите следующее число: -1

      Общая сумма равна 6

      Введите следующую последовательность

      Введите следующее число: 1

      Введите следующее число: 2

      Введите следующее число: -1

      Общая сумма равна 3

      Введите следующую последовательность

      Введите следующее число: -1

      Программа завершена

      Press any key to continue...

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

Функцией называют логически обособленный блок кода С++, имеющий следующий вид:

      < тип возвращаемого значения > name( < аргументы функции > )

      {

           // . . .

           return < выражение > ;

      }

Аргументами функции называются значения, которые можно передать ей при вызове. В возвращаемом значении указывается результат, который функция возвращает по окончании работы. Например, в вызове функции возведения в квадрат square ( 10 ) 10 — это аргумент, а возвращаемое значение равно 100.

И аргументы, и возвращаемое значение функции необязательны. Если какой-либо элемент отсутствует, вместо него используется ключевое слово void. Значит, если вместо списка аргументов используется void, то при вызове функция не получает никаких аргументов ( как и в рассмотренной программе FunctionDemo ). Если же возвращаемый тип функции — void, то вызывающая программа не получает от функции никакого значения.

В программе FunctionDemo используется функция с именем sumSequence( ), которая не имеет аргументов и возвращает значение целочисленного типа.

«Тип аргументов функции по умолчанию — void , поэтому функцию int fn( void ) можно записать как int fn( ) .»

[]

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

_________________

84 стр. . Становимся функциональными программистами

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

Простые функции...85  

Функция sumSequence( ) возвращает целое значение. Функции могут возвращать значение любого стандартного типа, например double или char ( типы переменных рассматриваются в ).

Если функция ничего не возвращает, то возвращаемый тип помечается как void.

«Функции различаются по типу возвращаемого значения. Так, целочисленной функцией называют ту, которая возвращает целое значение. Функция, которая ничего не возвращает, известна как void-функция . Далее приведён пример функции, выполняющей некоторые действия, но не возвращающей никаких значений.»

[]

      void echoSquare( )

      {

           cout << "Введите значение:" ;

           cin >> value ;

           cout << " \n" << value*value << "\n" ;

           return ;

      }

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

«Инструкция return в void -функциях является необязательной. Если она отсутствует, то выполнение функции прекращается при достижении закрывающей фигурной скобки.»

[] 

Функции с аргументами...85 

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

Можно попытаться хранить числа в независимых переменных, например:

    cin >> value1 ;

    if ( value1 >= 0 )

    {

        cin >> value2 ;

        if ( value2 >= 0 )

        {

              ...

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

_________________

92 стр. . Становимся функциональными программистами

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

    int value ;

    /* объявление массива, способного содержать до 128 чисел типа int */

    int valueArray[ 128 ] ;

    /* определение индекса, используемого для доступа к элементам массива; его значение не должно превышать 128 */

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

    {

       cin >> value ;

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

       if ( value < 0 ) break ;

       valueArray[ i ] = value ;

    }

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

Компьютер считывает число с клавиатуры и сохраняет его в следующем элементе массива valueArray. Доступ к элементам массива обеспечивается с помощью имени массива и индекса, указанного в квадратных скобках. Первый элемент массива обозначается как valueArray[ 0 ], второй — как valueArray[ 1 ] и т.д.

Запись valueArray[ i ] представляет собой i-й элемент массива. Индексная переменная i должна быть перечислимой, т.е. её типом может быть char , int или long. Если valueArray — массив целых чисел, то элемент valueArray[ i ] имеет тип int. 

Работа с массивами...93

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

    /* ArrayDemo — демонстрирует использование массивов. Считывает последовательность целых чисел и отображает их по порядку */

    #include

    #include

    #include

    using namespace std ;

    /* объявления прототипов функций */

    int sumArray( int integerArray[ ] , int sizeOfloatArray ) ;

    void displayArray( int integerArray[ ] , int sizeOfloatArray ) ;

_________________

93 стр. . Хранение последовательностей в массивах

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

    {

        setlocale ( LC_ALL , ".1251" ) ; /* печать русских текстов */

        /* Описываем счётчик цикла */

        int nAccumulator = 0 ;

        cout << "Эта программа суммирует числа,"

        << " введённые пользователем\n" ;

        cout << "Цикл прерывается, когда"

              << " пользователь вводит\n"

              << "отрицательное число\n" ;

        /* Сохраняем числа в массиве */

        int inputValues[ 128 ] ;

        int numberOfValues = 0 ;

        for ( numberOfValues = 0 ; numberOfValues < 128 ; numberOfValues++ )

        {

            /* Ввод очередного числа */

            int integerValue ;

            cout << "Введите следующее число: " ;

            cin >> integerValue ;

            /* Если оно отрицательное... */

            if ( integerValue < 0 )

           {

                /* ...тогда выходим из цикла */

                break ;

            }

            /* ...иначе сохраняем число в массиве */

            inputValues[ numberOfValues ] = integerValue ;

        }

        /* Теперь выводим значения и их сумму */

        displayArray( inputValues , numberOfValues ) ;

        cout << "Сумма введённых чисел равна "

               << sumArray( inputValues , numberOfValues )

               << endl ;

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

        system( "PAUSE" ) ; return 0 ;

    }

    /* displayArray — отображает элементы массива integerArray длиной sizeOfloatArray */

    void displayArray( int integerArray[ ] , int sizeOfArray )

    {

        cout << "В массиве хранятся"

                << " следующие значения:\n" ;

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

        {

            cout.width( 3 ) ;

            cout << i << ": " << integerArray[ i ] << endl ;

         }

        cout << endl ;

    }

_________________

94 стр. . Становимся функциональными программистами

    /* sumArray — возвращает сумму элементов целочисленного массива */

    int sumArray( int integerArray[ ] , int sizeOfArray )

    {

        int accumulator = 0 ;

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

        {

            accumulator += integerArray[ i ] ;

        }

        return accumulator ;

    }

Программа ArrayDemo начинается с объявления прототипов функций sumArray( ) и displayArray( ), которые понадобятся нам позже. Главная часть программы содержит довольно скучный цикл ввода значений. На этот раз вводимые значения сохраняются в массиве inputValues.

Если введённое значение отрицательно, цикл прерывается при помощи инструкции break, если же нет — оно копируется в массив. Целочисленная переменная numberOfValues используется в качестве индекса массива. Она инициализирована нулём в начале цикла for. При каждой итерации индекс увеличивается. В условии выполнения цикла for осуществляется контроль за тем, чтобы количество введённых чисел не превышало 128, т.е. размера массива ( после введения 128 чисел программа переходит к выводу элементов массива на экран независимо от того, ввёл пользователь отрицательное число или нет ).

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

[]

Функция main заканчивается выводом на экран содержимого массива и суммы его элементов.

«Среда Dev-C++ может помочь вам в работе с исходными текстами, в которых имеется много функций. На рис. 7.1 показано содержимое вкладки Classes ( Классы ) , в которой перечисляются все функции в исходном файле. Двойной щелчок на имени функции переносит вас в окне редактирования в строку с этой функцией.»

[]

Функция displayArray( ) содержит обычный цикл for, который используется для прохождения по массиву. Каждый очередной элемент массива добавляется к переменной accumulator. Передаваемый функции параметр sizeOfArray включает количество значений, содержащихся в массиве.

Напомню ещё раз, что индекс массива в С++ отсчитывается от 0 , а не от 1. Кроме того, обратите внимание, что цикл for прерывается в тот момент, когда значение i становится равным sizeOfArray. Вы же не хотите добавлять все 128 элементов массива integerArray к accumulator? Ни один элемент массива, индекс которого больше или равен числу sizeOfArray, учитываться не будет. Вот как выглядит пример работы с этой программой:

_________________ 

95 стр. . Хранение последовательностей в массивах

    Эта программа суммирует числа, введённые пользователем

    Цикл прерывается, когда пользователь вводит

    отрицательное число

    Введите следующее число: 1

    Введите следующее число: 2

    Введите следующее число: 3

    Введите следующее число: -1

    В массиве хранятся следующие значения:

    0: 1

    1: 2

    2: 3

    Сумма введённых чисел равна 6

    Press any key to continue...

Рис. 7.1. Вкладка Классы выводит информацию о функциях, составляющих программу

Инициализация массива...96 

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

К счастью, массив может быть инициализирован сразу во время объявления, например:

    float floatArray[ 5 ] = { 0.0 , 1.0 , 2.0 , 3.0 , 4.0 } ;

В этом фрагменте элементу floatArray[ 0 ] присваивается значение 0 , floatArray[ 1 ] — 1 , floatArray[ 2 ] — 2 и т.д.

_________________

96 стр. . Становимся функциональными программистами

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

    float floatArray[ ] = { 0.0 , 1.0 , 2.0 , 3.0 , 4.0 } ;

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

        float floatArray[ 25 ] = { 1.0 } ;

Выход за границы массива...97 

Математики перечисляют содержимое массивов, начиная с элемента номер 1. Первым элементом математического массива х является х( 1 ). Во многих языках программирования также начинают перечисление элементов массива с 1. Но в С++ массивы индексируются начиная с 0! Первый элемент массива С++ обозначается как valueArray[ 0 ]. Первый индекс массива С++ нулевой; поэтому последним элементом 128-элементного целочисленного массива является integerArray[ 127 ], а не integerArray[ 128 ].

К сожалению, в С++ не проверяется выход индекса за пределы массива. Этот язык будет рад предоставить вам доступ к элементу integerArray[ 200 ]. Более того, С++ позволит вам обратиться даже к integerArray[ -15 ]. Приведём такую аналогию. Имеется улица, на которой 128 жилых домов. Если мы захотим найти 200-й дом, идя вдоль улицы и пересчитывая дома, то его просто может не быть. Тут могут быть заброшенные руины или, хуже того, дом, стоящий уже на другой улице! Чтение значения элемента integerArray[ 200 ] может дать некоторое непредсказуемое значение или даже привести к ошибке нарушения защиты ( вы вторглись в частные владения, куда вас не звали... ), а запись — к совершенно непредсказуемым результатам. Может, ничего и не случится — вы просто попадёте в заброшенный дом, а может, вы сотрёте тем самым какие-то жизненно важные данные. Словом, случиться может что угодно — вплоть до полного краха программы.

«Самая распространённая ошибка — неправильное обращение к последнему элементу по адресу integerArray[ 128 ] . Хотя это всего лишь следующий за концом массива элемент, записывать или считывать его не менее опасно, чем любой другой некорректный адрес.»

[]

Использовать ли массивы...97 

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

И всё же в возможности повторного отображения введённых значений кроется значительное преимущество использования массивов. Массивы позволяют программе многократно обрабатывать серии чисел. Главная программа была способна передать массив входных значений функции displayArray( ) для отображения, а затем в SumArray( ) для суммирования.

_________________ 

97 стр. . Хранение последовательностей в массивах

Определение и использование массивов с элементами-массивами...98  

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

В С++ матрицы определяются следующим образом:

    int intMatrix[ 10 ][ 5 ] ;

Эта матрица может иметь 10 элементов в одном измерении и 5 в другом, что в сумме составляет 50 элементов. Другими словами, intMatrix является 10-элементным массивом, каждый элемент которого — массив из 5 элементов. Легко догадаться, что один угол матрицы обозначается intMatrix[ 0 ][ 0 ], тогда как второй — intMatrix[ 9 ][ 4 ].

Индексы intMatrix можно рассматривать в любом удобном порядке. По какой оси отложить длину 10 — решайте сами, исходя из удобства представления. Матрицу можно инициализировать так же, как и массив:

    int intMatrix[ 2 ][ 3 ] = { { 1 , 2 , 3 } , { 4 , 5 , 6 } } ;

Здесь фактически выполняется инициализация двух трёхэлементных массивов: intMatrix[ 0 ] — значениями 1, 2 и 3, a intMatrix[ 1 ] — 4, 5 и 6 соответственно. 

Элементы массива могут быть любого типа. В С++ возможны массивы любых числовых типов — float, double, long, однако символьные массивы имеют особое значение.

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

    char sMyName[ ] = { 'S' , ' t' , 'e' , 'p' , 'h' , 'e' , 'n' } ;

Моё имя можно отобразить с помощью следующей небольшой программы:

    /* CharDisplay — выводит на экран массив символов в окне MS DOS */

    #include

    #include

    #include

    using namespace std ;

    /* Объявления прототипов */

    void displayCharArray( char stringArray[ ] , int sizeOfloatArray ) ;

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

    {

        char charMyName[ ] = { 'S' , 't' , 'e' , 'p' , 'h' , 'e' , ' n' } ;

        displayCharArray( charMyName , 7 ) ;

        cout << endl ;

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

        system( "PAUSE" ) ;

        return 0 ;

    }

_________________

98 стр. . Становимся функциональными программистами

    /* displayCharArray — отображает массив символов, по одному при каждой итерации */

    void displayCharArray( char stringArray[ ] , int sizeOfloatArray )

    {

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

        {

                cout << stringArray[ i ] ;

        }

    }

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

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

Создание строки символов...99

В С++ для этой цели зарезервирован нулевой символ. Мы можем использовать '\0' для того, чтобы пометить конец символьного массива. ( Числовое значение '\0' равно нулю, однако тип '\0' — char. )

«Символ \у является символом, числовое значение которого равно у . Изменим предыдущую программу, используя это правило:»

[]

      /* DisplayString — выводит на экран массив символов в окне MS DOS */

      #include

      #include

      #include

      using namespace std ;

      /* Объявления прототипов */

      void displayString( char stringArray[ ] ) ;

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

      {

           char charMyName[ ] ={ 'S' , 't' , 'e' , 'p' , 'h' , 'e' , 'n' , 0 } ;

           displayString( charMyName ) ;

           cout << endl ;

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

           system( "PAUSE" ) ; return 0 ;

      }

_________________ 

99 стр. . Хранение последовательностей в массивах 

      /* displayString — посимвольно выводит на экран строку */

      void displayString( char stringArray[ ] )

      {

           for ( int i = 0 ; stringArray[ i ] != 0 ; i++ )

           {

              cout << stringArray[ i ] ;

           }

      }

Массив charMyName объявляется как массив символов с дополнительным нулевым символом ( \0 ) в конце. Программа displayString итеративно проходит по символьному массиву, пока не встретит нуль-символ.

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

« Строка символов — это символьный массив с завершающим нулевым символом. Зачастую его называют просто “ строкой ”, хотя в С++ имеется отдельный тип string для работы со строками.»

[]

Выбор нулевого символа в качестве завершающего не был случаен. Это связано с тем, что в С++ только нулевое значение преобразуется в логическое значение false, а все остальные — в true. Это означает, что цикл for можно записать ( что обычно и делается ) следующим образом:

    for ( int i = 0 ; stringArray[ i ] ; i++ )

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

    char szMyName[ ] = "Stephen" ;

    char szAlsoMyName[ ] = { 'S' , 't' , 'e' , 'p' , 'h' , 'e' , 'n' , '\0' } ;

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

«Строка " Stephen " содержит восемь, а не семь символов — не забывайте о нулевом символе!»  

[]

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

Вот псевдокод, описывающий данную ситуацию:

    mySon = &DadsRoom ; /* Теперь сын знает комнату отца */

    room = *mySon ; /* "Номер  комнаты равен" */

Пример работы с операторами на С++ привёден в следующем листинге:

    void fn( )

    {

        int intVar ;

        int* pintVar ;

        pintVar = &intVar ; /* Теперь pintVar указывает на intVar */

        *pintVar =10 ; /* Сохраняет 10 в переменной типа int по адресу, находящемуся в pintVar */

    }

Функция fn( ) начинается с объявления переменной intVar ; в следующей строке объявляется pintVar — указатель на переменную типа int.

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

При написании программ желательно придерживаться соглашений об именах, в соответствии с которыми первый символ в названии переменной указывает на её тип. Например, можно использовать n для int, d для double и т.д. С учётом этого соглашения имена указателей далее в книге будут начинаться с буквы р.

Унарный оператор & в выражении означает "взять адрес переменной". Таким образом, в первой строке приведённого кода находится команда сохранения адреса переменной intVar в переменной pintVar.

Представим себе, что функция fn( ) начинается с адреса 0x100 , переменная intVar расположена по адресу 0x102, а указатель pintVar — 0x106 ( такое расположение намного проще результатов работы программы Layout ; на самом деле вряд ли переменные будут храниться в памяти именно в таком порядке ).

_________________

108 стр. . Становимся функциональными программистами

Первая команда программы сохраняет значение &intVar ( 0x102 ) в указателе pintVar. Вторая строка отвечает за присвоение значения 10 переменной, хранящейся по адресу, который содержится в указателе pintVar ( в нём находится число 0x102, т.е. адрес переменной intVar ). 

Сравнение указателей и почтовых адресов...109

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

Можно хранить диван в доме по адресу 123 Main Street, и точно так же можно хранить число в памяти по адресу 0x123456. Можно взять лист бумаги и написать на нём адрес — 123 Main Street. Теперь диван хранится в доме, который находится по адресу, написанному на листке бумаги. Так работают сотрудники службы доставки: они доставляют диваны по адресу, который указан в бланке заказа, независимо от того, какой именно адрес записан в бланке ( я ни в коем случае не смеюсь над работниками службы доставки — просто это самый удобный способ объяснить указатели ).

Использовав синтаксис С++, это можно записать так:

    House myHouse ;

    House* houseAddress ;

    houseAddress = &myHouse ;

    *houseAddress = couch ;

Эта запись обозначает следующее: myHouse является домом, a houseAddress — адресом дома. Надо записать адрес дома myHouse в указатель houseAddress и доставить диван по адресу, который находится в указателе houseAddress. Теперь используем вместо дома переменную типа int:

    int myInt ;

    int* intAddress ;

    intAddress = &myInt ;

    *intAddress = 10 ;

Аналогично предыдущей записи, это поясняется так: myInt — переменная типа int. Следует сохранить адрес myInt в указателе intAddress и записать 10 в переменную, которая находится по адресу, указанному в intAddress. 

Использование разных типов указателей...109

Каждое выражение, как и переменная, имеет свой тип и значение. Тип выражения &intVar — указатель на переменную типа int, т.е. это выражение имеет тип int*. При сравнении его с объявлением указателя pintVar становится очевидно, что они одинаковы:

    int* pintVar = &intVar ; /*  Обе части этого присвоения имеют тип *int  */

Аналогично pintVar имеет тип int* , a *pintVar — тип int:

    *pintVar = 10 /* Обе части этого присвоения имеют тип int */ 

Тип переменной, на которую указывает pintVar, — int. Это эквивалентно тому, что если houseAddress является адресом дома, то, как ни странно, houseAddress указывает дом. Указатели на переменные других типов объявляются точно так же:

    double doubleVar

    double* pdoubleVar = &doubleVar

    *pdoubleVar = 10.0

_________________

109 стр. . Первое знакомство с указателями в С++

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

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

    int n1 ;

    int* pintVar ;

    pintVar = &n1 ;

    *pintVar = 100.0 ;

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

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

    int iVar ;

    double dVar = 10.0 ;

    iVar = ( int )dVar ;

Так же можно привести и указатель одного типа к другому:

    int* piVar ;

    double dVar = 10.0 ;

    double* pdVar ;

    piVar = ( int* )pdVar ;

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

      /* LayoutError — демонстрирует результат неаккуратного обращения с указателями */

      #include

      #include

      #include

      using namespace std ;

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

      {

                    /* печать кириллицы, если Вы не установите программки gccrus.exe и g++rus.exe */

            setlocale ( LC_ALL , ".1251" ) ;

        int upper = 0 ;

        int n = 0 ;

        int lower = 0 ;

          /* Вывод адресов каждой из переменных. Обратите внимание на расположение переменных в памяти компьютера */

        cout << "&upper = 0x" << &upper<< "\n" ;

        cout << "&n      = 0x" << &n  << "\n" ;

        cout << "&lower  = 0x" << &lower << "\n" ;

          /* Выводим значения объявленных переменных */

          cout << "upper = " << upper << "\n" ;

          cout << "n = " << n << "\n" ;

          cout << "lower = " << lower << "\n" ;

          /* Сохраняем значение типа double в памяти, выделенной для int */

          cout << "\nСохранение double в int\n\n" ;

        cout << "\nСохранение 13.0 по адресу &n\n\n" ; 

          double* pD = ( double* )&n ;

          *pD = 13.0 ;

          /* Показываем результаты */

          cout << "upper = " << upper << "\n" ;

          cout << "n = " << n << "\n" ;

          cout << "lower = " << lower << "\n" ;

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

          system ( "PAUSE" ) ; return 0 ;

      }

__________

13Размер указателя зависит не только от типа процессора, но и от операционной системы, используемого компилятора и так называемой модели памяти создаваемой программы. — Прим. ред.

_________________

110 стр. . Становимся функциональными программистами

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

Следующие три строки выводят значения этих переменных на экран. Не удивительно, что все три оказываются равными нулю. После этого происходит присвоение *pD = 13.0 ; , в результате которого число, имеющее тип double, записывается в переменную n, имеющую тип int. Затем все три переменные снова выводятся на экран.

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

    upper = 0

    n = 0

    lower = 0

    Сохранение double в int

    upper = 1076494336

    n = 0

    lower = 0

    Press any key to continue...

На языке домов и адресов эта программа будет выглядеть так:

    house* houseAddress = &"123 Main Street" ;

    hotel* hotelAddress ;

    hotelAddress = ( hotel* )houseAddress ;

    *hotelAddress = TheRitz ;

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

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

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

_________________

111 стр. . Первое знакомство с указателями в С++

Передача аргументов по значению...112

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

    void fn( intArg )

    {

        int intArg = 10 ;

        /* Здесь значение intArg равно 10 */

    }

    void parent( void )

    {

        int n1 = 0 ;

        fn( n1 ) ;

        /* Здесь n1 равно 0 */

    }

Функция parent( ) инициализирует переменную n1 нулём. После этого значение n1 передаётся в качестве аргумента функции fn( ). В fn( ) переменной intArg присваивается значение 10 , тем самым в fn( ) осуществляется попытка изменить аргумент функции. Поскольку в качестве аргумента выступает переменная n1, можно ожидать, что после возврата в parent( ) эта переменная должна иметь значение 10. Тем не менее n1 остаётся равной 0.

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

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

[]

Передача значений указателей...112

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

    void fn( int* pintArg )

    {

          *pintArg = 10 ;

    }

    void parent( void )

    {

          int n = 0 ;

          fn( &n ) ; /* Так передаётся адрес n */

                      /* теперь n равно 10 */

    } 

В этом случае вместо значения n функции fn( ) передаётся адрес этой переменной. Чем отличается передача значения переменной от передачи значения указателя на переменную, станет понятно, если рассмотреть присвоение, выполняющееся в функции fn( ).

Предположим, что n находится по адресу 0x102. В этом случае функции fn( ) передаётся аргумент, равный 0x102. Внутри fn( ) присвоение *pintArg = 10 выполняет запись целого значения 10 в переменную типа int, которая находится по адресу 0x102. Таким образом, нуль в переменной n заменяется на 10 , поскольку в данном случае 0x102 и есть адрес переменной n.

_________________

112 стр. . Становимся функциональными программистами

Передача аргументов по ссылке...113

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

    void fn( int& intArg )

    {

          intArg = 10 ;

    }

    void parent( void )

    {

          int n = 0 ;

          fn ( n )

          /* Теперь значение n равно 10 */

    }

В этом примере функция fn( ) получает не значение переменной n, а ссылку на неё и, в свою очередь, записывает 10 в переменную типа int, на которую ссылается intArg. 

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

« Visual С++ .NET позволяет программисту писать код, который работает в т.н. управляемом режиме ( managed mode ), когда выделение и освобождение памяти обрабатывает компилятор. Поскольку таким режимом отличается только Visual С++ .NET , в данной книге он не рассматривается.»

[]

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

        double* fn( void ) ;

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

Область видимости...113

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

/* Эта переменная доступна для всех функций и существует на протяжении всего времени работы программы ( глобальная область видимости ) */

    int intGlobal ;

    /* Переменная intChild доступна только в функции child( ) и существует только во время выполнения функции child( ) или вызываемой ею ( область видимости функции ) */

_________________

113 стр. . Первое знакомство с указателями в С++

    void child( void )

    {

          int intChild ;

    }

    /* Переменная intParent имеет область видимости функции */

    void parent( void )

    {

          int intParent = 0 ;

          child( ) ;

          int intLater = 0 ;

          intParent = intLater ;

    }

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

    {

          parent( ) ;

    }

Программа начинает выполнять функцию main( ). В первой же строке main( ) вызывает функцию parent( ). В этой функции объявляется переменная intParent, которая имеет область видимости, ограниченную функцией. Такая переменная называется локальной и доступна только в этой функции.

Во второй строке parent( ) вызывается функция child( ). Эта функция также объявляет локальную переменную — intChild, областью видимости которой является функция child( ). При этом intParent функции child( ) недоступна ( и область видимости intParent не распространяется на функцию child( ) ), но сама переменная продолжает существовать.

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

После возврата из функции child( ) продолжается выполнение подпрограммы parent( ), и в следующей строке объявляется переменная intLater, которая имеет область видимости, ограниченную функцией parent( ). В момент возврата в функцию main( ) переменные intLater и intParent выходят из области видимости и уничтожаются.

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

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

Проблемы области видимости...114

Приведённый ниже фрагмент программы будет скомпилирован, но не будет корректно работать.

    double* child( void )

    {

          double dLocalVariable ;

          return &dLocalVariable ;

    }

    void parent( void )

    {

          double* pdLocal ;

          pdLocal = child( ) ;

          *pdLocal = 1.0 ;

    }

_________________

114 стр. . Становимся функциональными программистами

Проблема в том, что переменная dLocalVariable объявлена внутри функции child( ). Следовательно, в момент возврата адреса dLocalVariable из child( ) самой переменной уже не существует и адрес ссылается на память, которая вполне может быть занята для каких-то других целей.

«Ошибки подобного типа встречаются довольно часто, а способы их появления весьма разнообразны. К сожалению, такой тип ошибки пропускается компилятором и зачастую не вызывает аварийной остановки программы. Программа может отлично работать большую часть времени, пока память, которая в прошлом выделялась под dLocalVariable , не будет выделена другой переменной. Труднее всего найти ошибки, проявляющиеся спонтанно.»  

[]

Использование блока памяти...115

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

Память в куче можно выделить, используя оператор new ; он пишется вместе с типом объекта, под который нужно выделить память. Приведённый ниже пример выделяет из кучи память для переменной типа double.

    double* child( void )

   {

         double* pdLocalVariable = new double ;

         return pdLocalVariable ;

    }

Теперь, несмотря на то что переменная pdLocalVariable имеет область видимости в пределах функции child( ), память, на которую указывает эта переменная, не будет освобождена после выполнения функции. Выделение и освобождение памяти в куче осуществляется только явно. Освобождение памяти в куче выполняется с помощью команды delete.

      void parent( void )

      {

           /* функция child( ) возвращает адрес переменной в куче */

           double* pdMyDouble = child( ) ;

           /* сохранение значения в созданной переменной */

           *pdMyDouble = 1.1 ;

           // ...

           /* возврат памяти куче */

           delete pdMyDouble ;

           pdMyDouble = 0 ;

           // ...

      }

_________________

115 стр. . Первое знакомство с указателями в С++

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

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

[]

_________________

116 стр. . Становимся функциональными программистами

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

    Таблица 9.1. Три операции над указателями

    _________________

    Операция — Результат — Действие

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

    pointer+offset — Указатель — Вычисляет адрес элемента, расположенного через offset элементов после pointer

    pointer-offset — Указатель — Операция, противоположная сложению

    pointer2-pointer1 — Смещение — Вычисляет количество элементов между pointer1 и pointer2

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ 

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

Модель памяти, построенная на примере домов ( так эффективно использованная в предыдущей главе ), поможет понять, как работают приведённые в таблице операции с указателями. Представьте себе квартал, в котором все дома пронумерованы по порядку. Дом, следующий за домом 123 Main Street, будет иметь адрес 124 Main Street ( или 122 Main Street, если вы идёте в противоположную сторону, поскольку вы левша или живёте в Англии ).

Очевидно, что в таком случае через четыре дома от моего будет находиться дом с адресом 127 Main Street. Адрес этого дома можно записать как

    123 Main Street + 4 = 127 Main Street

_________________

117 стр. . Второе знакомство с указателями

И наоборот, если поинтересоваться, сколько домов находится между домом 123 и 127, ответом будет четыре:

    127 Main Street - 123 Main Street = 4

Понятно, что любой дом находится относительно самого себя на расстоянии нуль домов:

    123 Main Street - 123 Main Street = 0

Продолжая рассуждения, становится понятно, что складывать дома 123 и 127 не имеет никакого смысла. Соответственно, суммирование двух указателей является в С++ некорректной операцией. Вы также не можете умножать или делить адреса, возводить их в квадрат или извлекать квадратный корень — словом, надеюсь, вы поняли, что я хотел сказать. 

Повторное знакомство с массивами в свете указателей...118

Обратимся к странному и мистическому миру массивов. Ещё раз воспользуемся в качестве примера домами моих соседей. Массив тоже очень похож на городской квартал. Каждый элемент массива выступает в качестве дома в этом квартале. Дома — элементы массива — отсчитываются по порядку от начала квартала. Дом на углу улицы отстоит на 0 домов от угла, следующий дом отстоит на 1 дом от угла и т.д. Пользуясь терминологией массивов, можно сказать, что cityBlock[ 0 ] представляет собой дом по адресу 123 Main Street, cityBlock[ 1 ] — дом по адресу 124 Main Street и т.д.

Теперь представим себе массив из 32-х однобайтовых значений, имеющий имя charArray. Если первый элемент массива находится по адресу 0x110 , тогда массив будет продолжаться вплоть до адреса 0x12f. Таким образом, элемент массива charArray[ 0 ] находится по адресу 0x110 , charArray[ 1 ] — по адресу 0x111 , charArray[ 2 ] — по адресу 0x112 и т.д.

Можно создать указатель ptr на нулевой элемент массива. После выполнения строки ptr = &charArray[ 0 ] ; указатель ptr будет содержать адрес 0x110. Можно прибавить к этому адресу целочисленное смещение и перейти к необходимому элементу массива. Операции над массивами с использованием указателей приведены в табл. 9.2. Эта таблица демонстрирует, каким образом добавление смещения n вызывает переход к следующему элементу массива charArray.

    Таблица 9.2. Добавление смещения

    _________________

    Смещение — Результат — Соответствует

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

    +0 — 0x110 — charArray[ 0 ]

    +1 — 0x111 — charArray[ 1 ]

    +2 — 0x112 — charArray[ 2]

    ... — ... — ...

    +n — 0х110+n — charArray[ n ]

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ 

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

Таким образом, если char* ptr — &charArray[ 0 ] ;, то *( ptr + n ) соответствует элементу charArray [ n ].

«Поскольку * имеет более высокий приоритет, чем сложение, операция *ptr + n привела бы к сложению n со значением, на которое указывает ptr . Чтобы выполнить сначала сложение и лишь затем переход к переменной по указателю, следует использовать скобки. Выражение *( ptr + n ) возвращает элемент, который находится по адресу ptr плюс n элементов.»

[]

_________________

118 стр. . Становимся функциональными программистами

В действительности соответствие между двумя формами выражений настолько строго, что С++ рассматривает элемент массива array[ n ] как *( ptr + n ), где ptr указывает на первый элемент array. С++ интерпретирует array[ n ] как *( &аrray [ 0 ] +n ). Таким образом, если дано char charArray[ 20 ], то charArray определяется как &charArray[ 0 ].

Имя массива, записанное без индекса элемента, интерпретируется как адрес нулевого элемента массива ( или просто адрес массива ). Таким образом, можно упростить приведённую выше запись, поскольку array[ n ] С++ интерпретирует как *( array + n ).

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

Концепция соответствия между индексацией массива и арифметикой указателей весьма полезна.

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

      /* displayArray — отображает элементы массива, имеющего длину nSize */

      void displayArray( int intArray[ ] , int nSize )

      {

           cout << "Значения элементов массива равны:\n" ;

           for ( int n = 0 ; n < nSize ; n++ )

           {

                 cout << n << ": " << intArray[ n ] << "\n" ;

           }

           cout << "\n" ;

      }

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

      /* displayArray — отображает элементы массива, имеющего длину nSize */

      void displayArray( int intArray[ ] , int nSize )

      {

           cout << "Значения элементов массива равны:\n" ;

           int* pArray = intArray ;

           for ( int n = 0 ; n < nSize ; n++ , pArray++ )

           {

                   cout << n << ": " << *pArray << "\n" ;

           }

           cout << "\n" ;

      }

Этот вариант функции displayArray начинается с создания указателя на первый элемент массива intArray.

«Буква р в начале имени переменной означает, что эта переменная является указателем, однако это только соглашение, а не стандарт языка С++.»

[]

_________________

119 стр. . Второе знакомство с указателями

После этого функция считывает все элементы массива по порядку. При каждом выполнении оператора for происходит вывод текущего элемента из массива intArray. Этот элемент находится по адресу рArray, который увеличивается на единицу при каждом выполнении цикла.

Убедиться в работоспособности описанной функции можно, используя её в следующей функции main( ):

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

      {

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

           displayArray( array , 4 ) ;

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

           system( "PAUSE" ) ; return 0 ;

      }

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

    Значения элементов массива равны:

    0: 4

    1: 3

    2: 2

    3: 1

    Press any key to continue...

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

Использование указателей для работы со строками...120

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

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

      /* DisplayString — вывод символьного массива с использованием указателей и индексов массива */

      #include

      #include

      #include

      using namespace std ;

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

      {

      setlocale ( LC_ALL , ".1251" ) ; /* печать русских текстов */

           /* Объявляем строку */

           char* szString = "Randy" ;

_________________

120 стр. . Становимся функциональными программистами

           cout << "Массив ' " << szString << " ' " << endl ;

           /* Выводим szString как массив */

           cout << "Выводим строку как массив: " ;

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

           {

               cout << szString[ i ] ;

           }

           cout << endl ;

           /* Воспользуемся арифметикой указателей */

           cout << "Выводим строку с помощью указателя: " ;

           char* pszString = szString ;

           while ( *pszString )

           {

               cout << *pszString ;

               pszString++ ;

           }

           cout << endl ;

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

           system( "PAUSE" ) ; return 0 ;

    }

Программа сначала проходит по массиву szString с использованием индекса массива. Цикл for прекращает работу, когда индекс достигает значения 5, равного длине строки.

Второй цикл выводит ту же строку с использованием указателя. Программа устанавливает указатель pszString равным адресу первого символа массива. Затем цикл проходит по всем символам строки до тех пор, пока символ, на который указывает pszString, не станет равен false, другими словами, пока указатель не станет указывать на нулевой символ.

«Целое значение 0 в С++ рассматривается как false , прочие целочисленные значения — как true .»

[]

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

«Разыменование и инкремент могут быть объединены ( обычно так и делается ) в единое выражение следующим образом:

    cout << *pszString++ ;

»

 []

Вывод данной программы выглядит так:

    Массив ' Randy '

    Выводим строку как массив: Randy

    Randy Выводим строку с помощью указателя: Randy

    Press any key to continue...

_________________

121 стр. . Второе знакомство с указателями

Почему при работе со строками пользуются указателями...122

Иногда некоторая запутанность работы с указателями вызывает у читателя вполне резонный вопрос: почему рекомендуется использовать указатели? Иными словами, что делает использование указателя char* предпочтительнее более простого для чтения варианта с массивами и индексами?

Ответ следует искать отчасти в человеческой природе, отчасти в истории развития С++. Компилятор языка С, прародителя С++, в те времена, когда язык появился на свет, был довольно примитивен. Тогда компиляторы не были столь сложными, как сейчас, и не могли так хорошо оптимизировать код. Код while ( *pszTarget++ = *pszSource++ ){ } может показаться читателю сложным, однако после компиляции с помощью даже самого древнего компилятора он будет состоять буквально из нескольких машинных инструкций.

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

Именно тогда и зародилась традиция писать компактные и эффективные, правда, подчас несколько загадочные на вид программы на С++, и с тех пор никто не хочет возвращаться к индексам.

«Не надейтесь, что, написав сложное и запутанное выражение на С++, вы сэкономите несколько машинных команд. В С++ нет прямой связи между количеством команд в исходном и конечном коде.»  

[]

Операции с указателями других типов...122

Нетрудно сообразить, что szTarget+n указывает на элемент szTarget[ n ], если szTarget является массивом однобайтовых значений. Если szTarget начинается по адресу 0x100 , то шестой элемент массива будет находиться по адресу 0x105.

Однако положение элемента в массиве становится не столь очевидным, если массив состоит из элементов типа int, которые занимают по четыре байта каждый. Если первый элемент такого массива находится по адресу 0x100 , то шестой будет находиться по адресу 0x114( 0x100 + ( 5 * 4 ) = 0x114 ).

Но, к счастью для нас, выражение вида array + n будет всегда указывать на элемент array[ n ], независимо от размера элемента, поскольку в таком выражении С++ самостоятельно учитывает длину элемента.

И вновь обратимся за аналогией к моему дому. Третий дом от 123 Main Street будет иметь адрес 126 Main Street, независимо от размеров стоящих на Main Street домов. 

Отличия между указателями и массивами...122

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

      void arrayPointer( )

      {

            /* Выделение памяти для 128 символов */

            char charArray[ 128 ] ;

            /* Выделение памяти для  указателя, но не для объекта, на который он указывает */

            char* pArray ;

      }

_________________

122 стр. . Становимся функциональными программистами

В этом примере для charArray выделяется 128 байт, а для pArray — четыре, ровно столько, сколько необходимо для хранения указателя. Приведённая ниже функция работать не будет.

      void arrayVsPointer( )

      {

           /* Этот фрагмент будет работать нормально */

           char charArray[ 128 ] ;

           charArray[ 10 ] = '0' ;

           *( charArray + 10 ) = '0' ;

           /* Этот фрагмент не будет работать так, как надо */

           char* pArray ;

           pArray[ 10 ] = '0' ;

           *( pArray + 10 ) = '0' ;

      }

Выражения charArray[ 10 ] и *( charArray + 10 ) с позиции компилятора эквивалентны и вполне законны. Те же выражения с использованием pArray являются бессмысленными. Несмотря на то что для С++ они являются законными, pArray не инициализирован как указатель на массив, а значит, память была выделена только для указателя. Таким образом, рАггау[ 10 ] и *( рАггау + 10 ) указывают на неизвестные и непредсказуемые значения.

«Неправильно инициализированные указатели обычно вызывают ошибку нарушения сегмента ( segment violation ). Эту ошибку вы иногда встречаете в повседневной работе со своими любимыми приложениями в своей любимой ( а может, и не очень ) операционной системе.»

[]

Второе отличие между указателями и индексами массива состоит в том, что charArray — константа, тогда как pArray — нет. Приведённый ниже цикл for, который должен инициализировать значения элементов массива, тоже не будет работать.

      void arrayVsPointer( )

      {

           char charArray[ 10 ] ;

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

           {

                 *charArray = '\0' ; /* Эта строка имеет смысл... */

                 charArray++ ; /* ... а эта нет */

           }

      }

Выражение charArray++ имеет не больше смысла, чем 10++. Правильно следует написать так:

      void arrayVsPointer( )

      {

           char charArray[ 10 ] ;

           char* pArray = charArray ;

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

           {

                 *pArray = '\0' ; /* Этот вариант будет  работать так, как надо */

                 pArray++ ;

           }

      }

_________________

123 стр. . Второе знакомство с указателями

Если есть указатели на массивы, можно предположить, что существуют и массивы указателей. Именно их мы сейчас и рассмотрим.

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

        int* pInts[ 10 ] ;

Таким образом, элемент pInts[ 0 ] является указателем на переменную типа int. Следовательно, приведённый ниже код корректен:

      void fn( )

      {

           int n1 ;

           int* pInts[ 3 ] ;

           pInts[ 0 ] = &n1 ;

           *pInts[ 0 ] = 1 ;

      }

Как и этот:

      void fn( )

      {

           int n1 , n2 , n3 ;

           int* pInts[ 3 ] = { &n1 , &n2 , &n3 } ;

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

           {

                *pInts[ i ] = 0 ;

           }

      }

И даже этот:

      void fn( )

      {

           int n1 , n2 , n3 ;

           int* pInts[ 3 ] = { ( new int ) ,

                                    ( new int ) ,

                                    ( new int ) } ;

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

           {

                *pInts[ i ] = 0 ;

           }

      }

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

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

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

Допустим, мне понадобилась функция, возвращающая название месяца по его номеру. Например, если этой функции передать число 1, она вернёт название первого месяца — "Январь". Номер месяца будет считаться неправильным, если он окажется меньше 1 или больше 12.

_________________

124 стр. . Становимся функциональными программистами

Эту функцию можно написать следующим образом:

      /* int2month( ) — возвращает название месяца */

      char* int2month( int nMonth )

      {

           char* pszReturnValue ;

           switch( nMonth )

           {

               case 1 : pszReturnValue = "Январь" ;

                      break ;

               case 2 : pszReturnValue = "Февраль" ;

                      break ;

               case 3 : pszReturnValue = "Март" ;

                      break ;

               /* и так далее... */

               default : pszReturnValue = "Неверный номер месяца"

           }

           return pszReturnValue ;

      }

«Оператор switch( ) действует так же, как совокупность операторов if .»

[]

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

      /* int2month( ) — возвращает название месяца */

      char* int2month( int nMonth )

      {

           /* проверка правильности номера месяца */

           if ( nMonth < 1 || nMonth > 12 )

           {

               return "invalid" ;

           }

           /* nMonth имеет корректное значение */

           /* Вернём имя месяца */

           char* pszMonths[ ] = { "Ошибка" ,

                                                "Январь" ,

                                                "Февраль" ,

                                                "Март" ,

                                                "Апрель" ,

                                                "Май" ,

                                                "Июнь" ,

                                                "Июль" ,

                                                "Август" ,

                                                "Сентябрь" ,

                                                "Октябрь" ,

                                                "Ноябрь" ,

                                                "Декабрь" } ;

           return pszMonths[ nMonth ] ;

      }

Сначала в этой программе проверяется корректность аргумента nMonth, т.е. что его значение лежит в диапазоне между 1 и 12 включительно ( в предыдущей программе проверка производилась, по сути, оператором default ). Если значение nMonth правильное, оно используется как смещение внутри массива, содержащего названия месяцев.

_________________

125 стр. . Второе знакомство с указателями

«Такой способ обращения к строкам по индексу особенно полезен при написании программы, работающей на разных языках. Например, массив названий месяцев может инициализироваться во время работы с названиями на разных языках, так что ptrMonth[ 1 ] всегда будет указывать на январь независимо от используемого языка.»

[] 

Доступ к аргументам main( )...126

Добавление команд вывода в ключевых точках помогает понять, что происходит в программе, и называется методом отладочной печати ( иногда именуемым WRITE ).  Метод WRITE появился во времена, когда программы писались на языке FORTRAN, в котором вывод осуществляется с помощью команды WRITE.

_________________

128 стр. . Становимся функциональными программистами

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

«Данная программа имеется на прилагаемом компакт-диске под именем ErrorProgram1.срр. »

[]

      /* ErrorProgram — эта программа усредняла бы ряд чисел, если бы не содержала как минимум одну фатальную ошибку */

      #include

      #include

      #include

      using namespace std ;

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

      {

            /* печать кириллицы, если Вы не установите программки gccrus.exe и g++rus.exe */

            setlocale (LC_ALL,".1251");

           cout << "Эта программа содержит ошибки!\n" ;

           int nSum ;

           int nNums ;

           /* Суммируем ряд чисел, пока пользователь не введёт отрицательное число, после чего выводим среднее */

           nNums = 0 ;

           while ( true )

           {

               /* Ввод очередного числа */

               int nValue ;

               cout << "Введите следующее число:" ;

               cin >> nValue ;

               cout << endl ;

               /* Если это число отрицательное... */

               if ( nValue < 0 )

               {

                      /* ...то вывести среднее значение */

                      cout << "Среднее равно: "

                              << nSum / nNums

                              << endl ;

                      break ;

               }

               /* Введеённое число не отрицательно — добавляем его к накапливаемой сумме */

               nSum += nValue ;

           }

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

           system( "PAUSE" ) ; return 0 ;

    }

_________________

129 стр.. Отладка программ на С++

После ввода этой программы создайте выполнимый файл ( клавиша ). Запустите эту программу и введите числа 1, 2 и 3, а затем -1. Вы ожидаете увидеть, что их среднее равно двум? Вместо этого очевидного результата будет выдано довольно непривлекательное сообщение об ошибке, показанное на рис. 10.1.

«Рис. 10.1 может отличаться в зависимости от используемых операционной системы и компилятора.»

[]

Рис. 10.1. Первоначальная версия программы содержит как минимум одну ошибку

Выявление "жучка" № 1...130

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

    cout << "Среднее равно: "

            << nSum / nNums

            << endl ;

«Кстати говоря, хотя это и единственное деление, использованное нами в программе, это ещё не означает, что ошибка именно в нём. Компилятор может сгенерировать команду деления в результате обработки некоторой иной инструкции, написанной программистом. Кроме того, делений хватает и в стандартной библиотеке С++.»

[]

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

    while ( true )

    {

           cout << "nNums = " << nNums << endl ;

           /* Остальная часть программы остаётся неизменной */

_________________

130 стр. . Становимся функциональными программистами

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

    Эта программа содержит ошибки!

    nNums = 0

    Введите следующее число: 1

    nNums = 0

    Введите следующее число: 2

    nNums = 0

    Введите следующее число: 3

    nNums = 0

    Введите следующее число:

Как видите, nNums инициализировано нулевым значением, но оно не увеличивается в процессе ввода новых чисел. Это неверно, и именно в этом состоит ошибка в программе. Очевидно, что количество введённых чисел nNums должно увеличиваться, чего можно легко достичь, заменив цикл while циклом for:

        for ( int nNums = 0 ; ; nNums++ )

Выявление "жучка" № 2...131 

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

    Эта программа содержит ошибки:

    Введите следующее число: 1

    Введите следующее число: 2

    Введите следующее число: 3

    Введите следующее число: -1

    Среднее равно: 229523

Очевидно, какая-то из переменных — nNums или nSum ( а возможно, и обе ) содержит неверное значение. Для того чтобы исправить ошибку, необходимо узнать, какая именно из этих переменных содержит неверную информацию. Не помешало бы также знать, что содержится в переменной nValue, поскольку она используется для подсчёта суммы в nSum.

Для этого воспользуемся методом отладочной печати. Чтобы узнать значения nValue, nSum и nNums, перепишите тело цикла for так, как показано в следующем листинге ( версия программы имеется на прилагаемом компакт-диске в файле с именем ErrorProgram2.срр ).

      /* ErrorProgram — эта программа усредняла бы ряд чисел, если бы не содержала как минимум одну фатальную ошибку */

      #include

      #include

      #include

      using namespace std ;

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

      {

            /* печать кириллицы, если Вы не установите программки gccrus.exe и g++rus.exe */

            setlocale (LC_ALL,".1251");

            cout << " Эта программа содержит ошибки!"

                    << endl ;

            /* Суммируем ряд чисел, пока пользователь не введёт отрицательное число, после чего выводим среднее */

            int nSum ;

            for ( int nNums = 0 ; ; nNums++ )

_________________

131 стр.. Отладка программ на С++

            {

               /* Ввод следующего числа */

               int nValue ;

               cout << "Введите следующее число:" ;

               cin >> nValue ;

               cout << endl ;

               /* Если введённое число отрицательно... */

               if ( nValue < 0 )

               {

                   /* ...выводим результат усреднения */

                   cout << "\nСреднее равно: "

                           << nSum / nNums

                           << "\n" ;

                   break ;

               }

               /* Вывод отладочной информации */

               cout << "nSum = " << nSum << "\n" ;

               cout << "nNums= " << nNums << "\n" ;

               cout << "nValue= " << nValue << "\n" ;

               cout << endl ;

               /* Введённое число не отрицательно, суммируем его */

               nSum += nValue ;

           }

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

           system( "PAUSE" ) ; return 0 ;

    }

Обратите внимание на то, что информация о состоянии отслеживаемых переменных nValue, nSum и nNums выводится в каждом цикле.

Ответ программы на ввод уже привычных 1, 2, 3 и -1 приведён ниже. При первом же проходе nSum принимает какое-то несуразное значение, хотя оно должно равняться нулю ( поскольку к этой переменной пока что ничего не прибавлялось ).

    Эта программа содержит ошибки!

    Введите следующее число:1

    nSum = -858993460

    nNums = 0

    nValue= 1

    Введите следующее число:2

    nSum = -858993459

    nNums= 1

    nValue= 2

    Введите следующее число:3

    nSum = -858993457

    nNums = 2

    nValue= 3

    Введите следующее число:

_________________

132 стр. . Становимся функциональными программистами

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

        int nSum = 0 ;

Примечание. Пока переменная не проинициализирована, её значение непредсказуемо.

«Теперь, когда вы нашли все ошибки, перепишите программу так, как показано в следующем листинге ( эта программа имеется на прилагаемом компакт-диске в файле ErrorProgram3.срр ) .»

[]

    /* ErrorProgram — эта программа усредняет ряд чисел и не содержит ошибок */

    #include

    #include

    #include

    using namespace std ;

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

    {

            /* печать кириллицы, если Вы не установите программки gccrus.exe и g++rus.exe */

            setlocale (LC_ALL,".1251");

        /* Суммируем ряд чисел, пока пользователь не введёт отрицательное число, после чего выводим среднее */

        int nSum = 0 ;

        for ( int nNums = 0 ; ; nNums++ )

        {

            /* Ввод следующего числа: */

            int nValue ;

            cout << "Введите следующее число:" ;

            cin >> nValue ;

            cout << endl ;

            /* Если введённое число отрицательно... */

            if ( nValue < 0 )

            {

                /* ...выводим усреднённое значение */

                cout << "\nСреднее равно: "

                        << nSum / nNums

                        << "\n" ;

                break ;

            }

            /* Введённое число не отрицательно, суммируем его */

            nSum += nValue ;

        }

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

        system( "PAUSE" ) ; return 0 ;

    } 

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

    Введите следующее число: 1

    Введите следующее число: 2

    Введите следующее число: 3

    Введите следующее число: -1

    Среднее равно: 2

    Press any key to continue...

_________________

133 стр.. Отладка программ на С++

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

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

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

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

Что такое отладчик...134

Отладчик — это утилита, встроенная, например, в Dev-C++ или Microsoft Visual Studio .NET ( в этих приложениях программы отладчиков отличаются, однако работают они по одному принципу ).

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

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

Работа с отладчиком...134

В отличие от стандартизированного языка С++, набор команд, поддерживаемый отладчиком, варьируется от производителя к производителю. К счастью, большинство отладчиков поддерживают некоторый базовый набор команд. Необходимые нам команды есть как в Dev-С++, так и в Microsoft Visual С++ .NET; в них также имеется возможность вызова этих команд с помощью меню и функциональных клавиш. В табл. 10.1 приведён список основных команд и клавиш их вызова.

    Таблица 10.1. Команды отладчиков Microsoft Visual С++ .NET и Dev-C++

    _________________

    Команда — Visual С++ — GNU С++ ( rhide )

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

    Отладка — —

    Шаг внутрь ( Step In ) — —

    Следующий шаг ( Step Over ) — —

    Продолжить выполнения — —

    Просмотр переменной ( View Variable ) — Только в меню — Только в меню

    Установка точки останова ( Set Breakpoint )* — —

    Добавить в наблюдаемые ( Add watch ) — Только в меню —

    Перезагрузка программы ( Program Reset ) — —

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ 

__________

*Щелчок слева от строки исходного текста С++ в окне редактора представляет собой альтернативный путь установки точек останова.

_________________

134 стр. . Становимся функциональными программистами

Запуск тестовой программы...135

«Лучший способ исправить ошибки в программе — пройти её пошагово. Приведённая ниже программа содержит несколько ошибок, которые надо найти и исправить. Эта программа имеется на прилагаемом компакт-диске в файле Concatenate1.срр .»

[]

    /* Concatenate - конкатенация двух строк */ 

     /*                  со вставкой " - " между ними. В этой версии имеются ошибки. */

    #include

    #include

    #include

    #include

    using namespace std ;

    void stringEmUp( char* szTarget ,

                                char* szSource1 ,

                                char* szSource2 ,

                                int nLength ) ;

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

    {

            /* печать кириллицы, если Вы не установите программки gccrus.exe и g++rus.exe */

            setlocale (LC_ALL,".1251");

        cout << "Конкатенация двух строк со вставкой \" - \"\n"

                << "( В этой версии имеются ошибки. )" << endl ;

        char szStrBuffer[ 256 ] ;

        /* Создание двух строк одинаковой длины... */

        char szString1[ 16 ] ;

        strncpy( szString1 , "This is a string" , 16 ) ;

        char szString2[ 16 ] ;

        strncpy( szString2 , "THIS IS A STRING" , 16 ) ;

        /* ...и объединение их в одну */

        stringEmUp( szStrBuffer ,

                            szString1 ,

                            szString2 ,

                            16 ) ;

        // Вывод результата

        cout << "<" << szStrBuffer << ">" << endl ;

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

        system( "PAUSE" ) ; return 0 ;

    }

        void stringEmUp(char* szTarget,

                char* szSource1,

                char* szSource2,

                int nLength)

    {

        strcpy( szTarget , szSource1 ) ;

        strcat( szTarget , " - " ) ;

        strcat( szTarget , szSource2 ) ;

    }

_________________

135 стр.. Отладка программ на С++

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

Пошаговое выполнение программы...136

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

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

[]

Команда Остановить выполнение заставляет отладчик заново начать работу с программой ( а не с того места, где вы находитесь ). Никогда не вредно перезагрузить отладчик перед началом работы.

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

Установим точку останова на первой выполнимой инструкции, щёлкнув слева от строки вывода в cout или воспользовавшись клавишами , как сказано в табл. 10.1. При этом вы увидите появившийся маленький красный кружок, говорящий об установленной точке останова ( рис. 10.2 ).

Теперь продолжим выполнение программы под отладчиком, либо выбирая команду меню Debug => Debug ( Отладка => Отладка ) , либо щелчком на соответствующей пиктограмме в панели отладки, либо при помощи клавиши . Выполнение программы немедленно прекращается на первой же строке, а подсветка строки из красной делается синей, указывая, что выполнение программы заморожено на данной строке.

Теперь вы можете выбрать в меню команду Debug => Next Step ( Отладка => Следующий шаг ) либо нажать клавишу для выполнения одной строки программы.

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

_________________

136 стр. . Становимся функциональными программистами

Рис. 10.2. Точку останова легко опознать по маленькому красному кружку

Рис. 10.3. В любой момент вы можете переключиться на окно выполняемой программы

Выполнение двух последующих инструкций приводит нас к вызову функции StringEmUp( ).

 Если опять выбрать команду Debug  =>  Next Step ( Отладка  =>  Следующий шаг ) , программа аварийно завершится. Теперь мы знаем, что проблема кроется в этой функции.

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

[]

_________________

137 стр.. Отладка программ на С++

Команда Debugs => Next Step ( Отладка => Следующий шаг ) рассматривает вызов функции как единую команду. Однако на самом деле функция состоит из ряда отдельных инструкций С++, и для отладки нам надо пройти их пошагово. Такая функциональность обеспечивается командой Debug => Step Into ( Отладка  =>  Шаг внутрь ) .

Перегрузите программу при помощи пункта меню Debug => Program Reset ( Отладка => Остановить выполнение ) либо соответствующей пиктограммы на панели отладки или клавиш . Теперь, чтобы сэкономить время, отключите установленную точку останова, щёлкнув на красном кружке, и установите новую на вызове функции stringEmUp( ) , как показано на рис. 10.4.

Рис. 10.4. Установка точки останова на вызове функции stringEmUp( )

«Вы можете установить в программе столько точек останова, сколько вам требуется.»

[]

Теперь перезапустите программу на выполнение, и она остановится на вызове функции StringEmUp( ).

 Войдите в функцию, воспользовавшись командой Debug => Step into ( Отладка => Шаг внутрь ) , как показано на рис. 10.5.

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

_________________

138 стр. . Становимся функциональными программистами

Рис. 10.5. Команда Debug => Step Into ( Отладка => Шаг внутрь ) позволяет выполнить вызов функции пошагово

Рис. 10.6. Отладчик позволяет следить за значениями переменных

_________________

139 стр.. Отладка программ на С++

Числа возле имён переменных в окне отладки — адреса, которые в данном случае малоинформативны. Строка szTarget пока что пуста, что вполне закономерно, так как мы ещё ничего в неё не скопировали. Значение строки szString1 также выглядит вполне корректно, но вот значение szString2 содержит сразу две строки — и "This is a string", и "THIS IS A STRING", чего вроде бы быть не должно.

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

«Длина строки всегда включает завершающий нулевой символ.»

[]

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

    /* Concatenate — конкатенация двух строк со вставкой " - " между ними. */

    #include

    #include

    #include

    #include

    using namespace std ;

    void StringEmUp( char* szTarget ,

                                char* szSource1 ,

                                char* szSource2 ) ;

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

    {

            /* печать кириллицы, если Вы не установите программки gccrus.exe и g++rus.exe */

            setlocale (LC_ALL,".1251"); 

        cout << "Конкатенация двух строк со вставкой \" - \"\n"

                << "( В этой версии нет ошибки. )" << endl ;

        char szStrBuffer[ 256 ] ;

        /* Определение двух строк... */

        char szString1[ ] = "This is a string" ;

        char szString2[ ] = "THIS IS A STRING" ;

        /* ...и объединение их в одну */

        StringEmUp( szStrBuffer ,

                            szString1 ,

                            szString2 ) ;

        /* Вывод результата */

        cout << "<" << szStrBuffer << ">" << endl ;

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

        system( "PAUSE" ) ; return 0 ;

    }

_________________

140 стр. . Становимся функциональными программистами

    void StringEmUp( char* szTarget ,

                                char* szSource1 ,

                                char* szSource2 )

    {

        strcpy( szTarget , szSource1 ) ;

        strcat( szTarget , " - " ) ;

        strcat( szTarget , szSource2 ) ;

    }

Вот вывод этой программы — именно такой, какой мы и ожидали:

    Конкатенация двух строк со вставкой " - "

    ( В этой версии нет ошибки. )

    Press any key to continue...

! ! ! ! ! ! ! ! ! ! ! ! ! !

    Поздравляю! Вам удалось отладить программу.

! ! ! ! ! ! ! ! ! ! ! ! ! !

_________________

141 стр.. Отладка программ на С++

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

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

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

■■■

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

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

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

■■■

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

_________________

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

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

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

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