Программирование — страница 26 из 57

Ввод и вывод

    
        
            Предыдущая
        
        Стр. 26 из 57
        
            Следующая




    
        
            Связь с администрацией
            Обработка персональных данных
        
    



    
        Оглавление
        К карточке книги
        
            
                
                    
                        Оглавление
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        Предисловие
                    
                
            
                
                    
                        *** Обращение к читателям
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        Глава 1 Компьютеры, люди и программирование
                    
                
            
                
                    
                        1.1. Введение
                    
                
            
                
                    
                        1.2. Программное обеспечение
                    
                
            
                
                    
                        1.3. Люди
                    
                
            
                
                    
                        1.4. Компьютерные науки
                    
                
            
                
                    
                        1.5. Компьютеры повсюду
                    
                
            
                
                    
                        1.5.1. С экранами и без них
                    
                
            
                
                    
                        1.5.2. Кораблестроение
                    
                
            
                
                    
                        1.5.3. Телекоммуникации
                    
                
            
                
                    
                        1.5.4. Медицина
                    
                
            
                
                    
                        1.5.5. Информация
                    
                
            
                
                    
                        1.5.6. Вид сверху
                    
                
            
                
                    
                        1.5.7. И что?
                    
                
            
                
                    
                        1.6. Идеалы программистов
                    
                
            
                
                    
                        Часть I Основы
                    
                
            
                
                    
                        Глава 2 Hello, World!
                    
                
            
                
                    
                        2.1. Программы
                    
                
            
                
                    
                        2.2. Классическая первая программа
                    
                
            
                
                    
                        2.3. Компиляция
                    
                
            
                
                    
                        2.4. Редактирование связей
                    
                
            
                
                    
                        2.5. Среды программирования
                    
                
            
                
                    
                        Глава 3 Объекты, типы и значения
                    
                
            
                
                    
                        3.1. Ввод
                    
                
            
                
                    
                        3.2. Переменные
                    
                
            
                
                    
                        3.3. Ввод и тип
                    
                
            
                
                    
                        3.4. Операции и операторы
                    
                
            
                
                    
                        3.5. Присваивание и инициализация
                    
                
            
                
                    
                        3.5.1. Пример: выявление повторяющихся слов
                    
                
            
                
                    
                        3.6. Составные операторы присваивания
                    
                
            
                
                    
                        3.6.1. Пример: поиск повторяющихся слов
                    
                
            
                
                    
                        3.7. Имена
                    
                
            
                
                    
                        3.8. Типы и объекты
                    
                
            
                
                    
                        3.9. Типовая безопасность
                    
                
            
                
                    
                        3.9.1. Безопасные преобразования
                    
                
            
                
                    
                        3.9.2. Опасные преобразования
                    
                
            
                
                    
                        Глава 4 Вычисления
                    
                
            
                
                    
                        4.1. Вычисления
                    
                
            
                
                    
                        4.2. Цели и средства
                    
                
            
                
                    
                        4.3. Выражения
                    
                
            
                
                    
                        4.3.1. Константные выражения
                    
                
            
                
                    
                        4.3.2. Операторы
                    
                
            
                
                    
                        4.3.3. Преобразования
                    
                
            
                
                    
                        4.4. Инструкции
                    
                
            
                
                    
                        4.4.1. Инструкции выбора
                    
                
            
                
                    
                        4.4.1.1. Инструкции if
                    
                
            
                
                    
                        4.4.1.2. Инструкции switch
                    
                
            
                
                    
                        4.4.1.3. Технические подробности инструкции switch
                    
                
            
                
                    
                        4.4.2. Итерация
                    
                
            
                
                    
                        4.4.2.1. Инструкции while
                    
                
            
                
                    
                        4.4.2.2. Блоки
                    
                
            
                
                    
                        4.4.2.3. Инструкции for
                    
                
            
                
                    
                        4.5. Функции
                    
                
            
                
                    
                        4.5.1. Зачем нужны функции
                    
                
            
                
                    
                        4.5.2. Объявления функций
                    
                
            
                
                    
                        4.6. Вектор
                    
                
            
                
                    
                        4.6.1. Увеличение вектора
                    
                
            
                
                    
                        4.6.2. Числовой пример
                    
                
            
                
                    
                        4.6.3. Текстовый пример
                    
                
            
                
                    
                        4.7. Свойства языка
                    
                
            
                
                    
                        Глава 5 Ошибки
                    
                
            
                
                    
                        5.1. Введение
                    
                
            
                
                    
                        5.2. Источники ошибок
                    
                
            
                
                    
                        5.3. Ошибки во время компиляции
                    
                
            
                
                    
                        5.3.1. Синтаксические ошибки
                    
                
            
                
                    
                        5.3.2. Ошибки, связанные с типами
                    
                
            
                
                    
                        5.3.3. Не ошибки
                    
                
            
                
                    
                        5.4. Ошибки во время редактирования связей
                    
                
            
                
                    
                        5.5. Ошибки во время выполнения программы
                    
                
            
                
                    
                        5.5.1. Обработка ошибок в вызывающем модуле
                    
                
            
                
                    
                        5.5.2. Обработка ошибок в вызываемом модуле
                    
                
            
                
                    
                        5.5.3. Сообщения об ошибках
                    
                
            
                
                    
                        5.6. Исключения
                    
                
            
                
                    
                        5.6.1. Неправильные аргументы
                    
                
            
                
                    
                        5.6.2. Ошибки, связанные с диапазоном
                    
                
            
                
                    
                        5.6.3. Неправильный ввод
                    
                
            
                
                    
                        5.6.4. Суживающие преобразования
                    
                
            
                
                    
                        5.7. Логические ошибки
                    
                
            
                
                    
                        5.8. Оценк а
                    
                
            
                
                    
                        5.9. Отладка
                    
                
            
                
                    
                        5.9.1. Практические советы по отладке
                    
                
            
                
                    
                        5.10. Пред- и постусловия
                    
                
            
                
                    
                        5.10.1. Постусловия
                    
                
            
                
                    
                        5.11. Тестирование
                    
                
            
                
                    
                        Глава 6. Создание программ
                    
                
            
                
                    
                        6.1. Задача
                    
                
            
                
                    
                        6.2. Размышления над задачей
                    
                
            
                
                    
                        6.2.1. Стадии разработки программы
                    
                
            
                
                    
                        6.2.2. Стратегия
                    
                
            
                
                    
                        6.3. Назад к калькулятору!
                    
                
            
                
                    
                        6.3.1. Первое приближение
                    
                
            
                
                    
                        6.3.2. Лексемы
                    
                
            
                
                    
                        6.3.3. Реализация лексем
                    
                
            
                
                    
                        6.3.4. Использование лексем
                    
                
            
                
                    
                        6.3.5. Назад к школьной доске!
                    
                
            
                
                    
                        6.4. Грамматики
                    
                
            
                
                    
                        6.4.1. Отступление: грамматика английского языка
                    
                
            
                
                    
                        6.4.2. Запись грамматики
                    
                
            
                
                    
                        6.5. Превращение грамматики в программу
                    
                
            
                
                    
                        6.5.1. Реализация грамматических правил
                    
                
            
                
                    
                        6.5.2. Выражения
                    
                
            
                
                    
                        6.5.2.1. Выражения: первая попытка
                    
                
            
                
                    
                        6.5.2.2. Выражения: вторая попытка
                    
                
            
                
                    
                        6.5.2.3. Выражения: третья попытка (удачная)
                    
                
            
                
                    
                        6.5.3. Термы
                    
                
            
                
                    
                        6.5.4. Первичные выражения
                    
                
            
                
                    
                        6.6. Испытание первой версии
                    
                
            
                
                    
                        6.7. Испытание второй версии
                    
                
            
                
                    
                        6.8. Потоки лексем
                    
                
            
                
                    
                        6.8.1. Реализация класса Token_stream
                    
                
            
                
                    
                        6.8.2. Считывание лексем
                    
                
            
                
                    
                        6.8.3. Считывание чисел
                    
                
            
                
                    
                        6.9. Структура программы
                    
                
            
                
                    
                        Глава 7. Завершение программы
                    
                
            
                
                    
                        7.1. Введение
                    
                
            
                
                    
                        7.2. Ввод и вывод
                    
                
            
                
                    
                        7.3. Обработка ошибок
                    
                
            
                
                    
                        7.4. Отрицательные числа
                    
                
            
                
                    
                        7.5. Остаток от деления: %
                    
                
            
                
                    
                        7.6. Приведение кода в порядок
                    
                
            
                
                    
                        7.6.1. Символические константы
                    
                
            
                
                    
                        7.6.2. Использование функций
                    
                
            
                
                    
                        7.6.3. Расположение кода
                    
                
            
                
                    
                        7.6.4. Комментарии
                    
                
            
                
                    
                        7.7. Исправление ошибок
                    
                
            
                
                    
                        7.8. Переменные
                    
                
            
                
                    
                        7.8.1. Переменные и определения
                    
                
            
                
                    
                        7.8.2. Использование имен
                    
                
            
                
                    
                        7.8.3. Предопределенные имена
                    
                
            
                
                    
                        7.8.4. Все?
                    
                
            
                
                    
                        Глава 8. Технические детали: функции и прочее
                    
                
            
                
                    
                        8.1. Технические детали
                    
                
            
                
                    
                        8.2. Объявления и определения
                    
                
            
                
                    
                        8.2.1. Виды объявлений
                    
                
            
                
                    
                        8.2.2. Объявления переменных и констант
                    
                
            
                
                    
                        8.2.3. Инициализация по умолчанию
                    
                
            
                
                    
                        8.3. Заголовочные файлы
                    
                
            
                
                    
                        8.4. Область видимости
                    
                
            
                
                    
                        8.5. Вызов функции и возврат значения
                    
                
            
                
                    
                        8.5.1. Объявление аргументов и тип возвращаемого значения
                    
                
            
                
                    
                        8.5.2. Возврат значения
                    
                
            
                
                    
                        8.5.3. Передача параметров по значению
                    
                
            
                
                    
                        8.5.4. Передача параметров по константной ссылке
                    
                
            
                
                    
                        8.5.5. Передача параметров по ссылке
                    
                
            
                
                    
                        8.5.6. Сравнение механизмов передачи параметров по значению и по ссылке
                    
                
            
                
                    
                        8.5.7. Проверка аргументов и преобразование типов
                    
                
            
                
                    
                        8.5.8. Реализация вызова функции
                    
                
            
                
                    
                        8.6. Порядок вычислений
                    
                
            
                
                    
                        8.6.1. Вычисление выражения
                    
                
            
                
                    
                        8.6.2. Глобальная инициализация
                    
                
            
                
                    
                        8.7. Пространства имен
                    
                
            
                
                    
                        8.7.1. Объявления using и директивы using
                    
                
            
                
                    
                        Глава 9. Технические детали: классы и прочее
                    
                
            
                
                    
                        9.1. Типы, определенные пользователем
                    
                
            
                
                    
                        9.2. Классы и члены класса
                    
                
            
                
                    
                        9.3. Интерфейс и реализация
                    
                
            
                
                    
                        9.4. Разработка класса
                    
                
            
                
                    
                        9.4.1. Структуры и функции
                    
                
            
                
                    
                        9.4.2. Функции-члены и конструкторы
                    
                
            
                
                    
                        9.4.3. Скрываем детали
                    
                
            
                
                    
                        9.4.4. Определение функций-членов
                    
                
            
                
                    
                        9.4.5. Ссылка на текущий объект
                    
                
            
                
                    
                        9.4.6. Сообщения об ошибках
                    
                
            
                
                    
                        9.5. Перечисления
                    
                
            
                
                    
                        9.6. Перегрузка операторов
                    
                
            
                
                    
                        9. 7. Интерфейсы классов
                    
                
            
                
                    
                        9.7.1. Типы аргументов
                    
                
            
                
                    
                        9.7.2. Копирование
                    
                
            
                
                    
                        9.7.3. Конструкторы по умолчанию
                    
                
            
                
                    
                        9.7.4. Константные функции-члены
                    
                
            
                
                    
                        9.7.5. Члены и вспомогательные функции
                    
                
            
                
                    
                        9.8. Класс Date
                    
                
            
                
                    
                        Часть II Ввод и вывод
                    
                
            
                
                    
                        Глава 10 Потоки ввода и вывода
                    
                
            
                
                    
                        10.1. Ввод и вывод
                    
                
            
                
                    
                        10.2. Модель потока ввода-вывода
                    
                
            
                
                    
                        10.3. Файлы
                    
                
            
                
                    
                        10.4. Открытие файла
                    
                
            
                
                    
                        10.5. Чтение и запись файла
                    
                
            
                
                    
                        10.6. Обработка ошибок ввода-вывода
                    
                
            
                
                    
                        10.7. Считывание отдельного значения
                    
                
            
                
                    
                        10.7.1. Разделение задачи на управляемые части
                    
                
            
                
                    
                        10.7.2. Отделение диалога от функции
                    
                
            
                
                    
                        10.8. Операторы вывода, определенные пользователем
                    
                
            
                
                    
                        10.9. Операторы ввода, определенные пользователем
                    
                
            
                
                    
                        10.10. Стандартный цикл ввода
                    
                
            
                
                    
                        10.11. Чтение структурированного файла
                    
                
            
                
                    
                        10.11.1. Представление в памяти
                    
                
            
                
                    
                        10.11.2. Считывание структурированных значений
                    
                
            
                
                    
                        10.11.3. Изменение представления
                    
                
            
                
                    
                        Глава 11 Настройка ввода и вывода
                    
                
            
                
                    
                        11.1. Регулярность и нерегулярность
                    
                
            
                
                    
                        11.2. Форматирование вывода
                    
                
            
                
                    
                        11.2.1. Вывод целых чисел
                    
                
            
                
                    
                        11.2.2. Ввод целых чисел
                    
                
            
                
                    
                        11.2.3. Вывод чисел с плавающей точкой
                    
                
            
                
                    
                        11.2.4. Точность
                    
                
            
                
                    
                        11.2.5. Поля
                    
                
            
                
                    
                        11.3. Открытие файла и позиционирование
                    
                
            
                
                    
                        11.3.1. Режимы открытия файлов
                    
                
            
                
                    
                        11.3.2. Бинарные файлы
                    
                
            
                
                    
                        11.3.3. Позиционирование в файлах
                    
                
            
                
                    
                        11.4. Потоки строк
                    
                
            
                
                    
                        11.5. Ввод, ориентированный на строки
                    
                
            
                
                    
                        11.6. Классификация символов
                    
                
            
                
                    
                        11.7. Использование нестандартных разделителей
                    
                
            
                
                    
                        11.8. И еще много чего
                    
                
            
                
                    
                        Глава 12 Вывод на экран
                    
                
            
                
                    
                        12.1. Почему графика?
                    
                
            
                
                    
                        12.2. Вывод на дисплей
                    
                
            
                
                    
                        12.3. Первый пример
                    
                
            
                
                    
                        12.4. Использование библиотеки графического пользовательского интерфейса
                    
                
            
                
                    
                        12.5. Координаты
                    
                
            
                
                    
                        12.6. Класс Shape
                    
                
            
                
                    
                        12.7. Использование графических примитивов
                    
                
            
                
                    
                        12.7.1. Графические заголовочные файлы и функция main
                    
                
            
                
                    
                        12.7.2. Почти пустое окно
                    
                
            
                
                    
                        12.7.3. Оси координат
                    
                
            
                
                    
                        12.7.4. График функции
                    
                
            
                
                    
                        12.7.5. Многоугольники
                    
                
            
                
                    
                        12.7.6. Прямоугольник
                    
                
            
                
                    
                        12.7.7. Заполнение
                    
                
            
                
                    
                        12.7.8. Текст
                    
                
            
                
                    
                        12.7.9. Изображения
                    
                
            
                
                    
                        12.7.10. И многое другое
                    
                
            
                
                    
                        12.8. Запуск программы
                    
                
            
                
                    
                        12.8.1. Исходные файлы
                    
                
            
                
                    
                        Глава 13 Графические классы
                    
                
            
                
                    
                        13.1. Обзор графических классов
                    
                
            
                
                    
                        13.2. Классы Point и Line
                    
                
            
                
                    
                        13.3. Класс Lines
                    
                
            
                
                    
                        13.4. Класс Color
                    
                
            
                
                    
                        13.5. Класс Line_style
                    
                
            
                
                    
                        13.6. Класс Open_polyline
                    
                
            
                
                    
                        13.7. Класс Closed_polyline
                    
                
            
                
                    
                        13.8. Класс Polygon
                    
                
            
                
                    
                        13.9. Класс Rectangle
                    
                
            
                
                    
                        13.10. Управление неименованными объектами
                    
                
            
                
                    
                        13.11. Класс Text
                    
                
            
                
                    
                        13.12. Класс Circle
                    
                
            
                
                    
                        13.13. Класс Ellipse
                    
                
            
                
                    
                        13.14. Класс Marked_polyline
                    
                
            
                
                    
                        13.15. Класс Marks
                    
                
            
                
                    
                        13.16. Класс Mark
                    
                
            
                
                    
                        13.17. Класс Image
                    
                
            
                
                    
                        Глава 14 Проектирование графических классов
                    
                
            
                
                    
                        14.1. Принципы проектирования
                    
                
            
                
                    
                        14.1.1. Типы
                    
                
            
                
                    
                        14.1.2. Операции
                    
                
            
                
                    
                        14.1.3. Именование
                    
                
            
                
                    
                        14.1.4. Изменяемость
                    
                
            
                
                    
                        14.2. Класс Shape
                    
                
            
                
                    
                        14.2.1. Абстрактный класс
                    
                
            
                
                    
                        14.2.2. Управление доступом
                    
                
            
                
                    
                        14.2.3. Рисование фигур
                    
                
            
                
                    
                        14.2.4. Копирование и изменчивость
                    
                
            
                
                    
                        14.3. Базовые и производные классы
                    
                
            
                
                    
                        14.3.1. Схема объекта
                    
                
            
                
                    
                        14.3.2. Вывод классов и определение виртуальных функций
                    
                
            
                
                    
                        14.3.3. Замещение
                    
                
            
                
                    
                        14.3.4. Доступ
                    
                
            
                
                    
                        14.3.5. Чисто виртуальные функции
                    
                
            
                
                    
                        14.4. Преимущества объектно -ориентированного программирования
                    
                
            
                
                    
                        Глава 15 Графические функции и данные
                    
                
            
                
                    
                        15.1. Введение
                    
                
            
                
                    
                        15.2. Построение простых графиков
                    
                
            
                
                    
                        15.3. Класс Function
                    
                
            
                
                    
                        15.3.1. Аргументы по умолчанию
                    
                
            
                
                    
                        15.3.2. Новые примеры
                    
                
            
                
                    
                        15.4. Оси
                    
                
            
                
                    
                        15.5. Аппроксимация
                    
                
            
                
                    
                        15.6. Графические данные
                    
                
            
                
                    
                        15.6.1. Чтение файла
                    
                
            
                
                    
                        15.6.2. Общая схема
                    
                
            
                
                    
                        15.6.3. Масштабирование данных
                    
                
            
                
                    
                        15.6.4. Построение графика
                    
                
            
                
                    
                        Глава 16 Графические пользовательские интерфейсы
                    
                
            
                
                    
                        16.1. Альтернативы пользовательского интерфейса
                    
                
            
                
                    
                        16.2. Кнопка Next
                    
                
            
                
                    
                        16.3. Простое окно
                    
                
            
                
                    
                        16.3.1. Функции обратного вызова
                    
                
            
                
                    
                        16.3.2. Цикл ожидания
                    
                
            
                
                    
                        16.4. Класс Button и другие разновидности класса Widget
                    
                
            
                
                    
                        16.4.1. Класс Widget
                    
                
            
                
                    
                        16.4.2. Класс Button
                    
                
            
                
                    
                        16.4.3. Классы In_box и Out_box
                    
                
            
                
                    
                        16.4.4. Класс Menu
                    
                
            
                
                    
                        16.5. Пример
                    
                
            
                
                    
                        16.6. Инверсия управления
                    
                
            
                
                    
                        16.7. Добавление меню
                    
                
            
                
                    
                        16.8. Отладка программы графического пользовательского интерфейса
                    
                
            
                
                    
                        Часть III Данные и алгоритмы
                    
                
            
                
                    
                        Глава 17 Векторы и свободная память
                    
                
            
                
                    
                        17.1. Введение
                    
                
            
                
                    
                        17.2. Основы
                    
                
            
                
                    
                        17.3. Память, адреса и указатели
                    
                
            
                
                    
                        17.3.1. Оператор sizeof
                    
                
            
                
                    
                        17.4. Свободная память и указатели
                    
                
            
                
                    
                        17.4.1. Размещение в свободной памяти
                    
                
            
                
                    
                        17.4.2. Доступ с помощью указателей
                    
                
            
                
                    
                        17.4.3. Диапазоны
                    
                
            
                
                    
                        17.4.4. Инициализация
                    
                
            
                
                    
                        17.4.5. Нулевой указатель
                    
                
            
                
                    
                        17.4.6. Освобождение свободной памяти
                    
                
            
                
                    
                        17.5. Деструкторы
                    
                
            
                
                    
                        17.5.1. Обобщенные указатели
                    
                
            
                
                    
                        17.5.2. Деструкторы и свободная память
                    
                
            
                
                    
                        17.6. Доступ к элементам
                    
                
            
                
                    
                        17.7. Указатели на объекты класса
                    
                
            
                
                    
                        17.8. Путаница с типами: void* и операторы приведения типов
                    
                
            
                
                    
                        17.9. Указатели и ссылки
                    
                
            
                
                    
                        17.9.1. Указатели и ссылки как параметры функций
                    
                
            
                
                    
                        17.9.2. Указатели, ссылки и наследование
                    
                
            
                
                    
                        17.9.3. Пример: списки
                    
                
            
                
                    
                        17.9.4. Операции над списками
                    
                
            
                
                    
                        17.9.5. Использование списков
                    
                
            
                
                    
                        17.10. Указатель this
                    
                
            
                
                    
                        17.10.1. Еще раз об использовании списков
                    
                
            
                
                    
                        Глава 18 Векторы и массивы
                    
                
            
                
                    
                        18.1. Введение
                    
                
            
                
                    
                        18.2. Копирование
                    
                
            
                
                    
                        18.2.1. Конструкторы копирования
                    
                
            
                
                    
                        18.2.2. Копирующее присваивание
                    
                
            
                
                    
                        18.2.3. Терминология, связанная с копированием
                    
                
            
                
                    
                        18.3. Основные операции
                    
                
            
                
                    
                        18.3.1. Явные конструкторы
                    
                
            
                
                    
                        118.3.2. Отладка конструкторов и деструкторов
                    
                
            
                
                    
                        18.4. Доступ к элементам вектора
                    
                
            
                
                    
                        18.4.1. Перегрузка ключевого слова const
                    
                
            
                
                    
                        18.5. Массивы
                    
                
            
                
                    
                        18.5.1. Указатели на элементы массива
                    
                
            
                
                    
                        18.5.2. Указатели и массивы
                    
                
            
                
                    
                        18.5.3. Инициализация массива
                    
                
            
                
                    
                        18.5.4. Проблемы с указателями
                    
                
            
                
                    
                        18.6. Примеры: палиндром
                    
                
            
                
                    
                        18.6.1. Палиндромы, созданные с помощью класса string
                    
                
            
                
                    
                        18.6.2. Палиндромы, созданные с помощью массива
                    
                
            
                
                    
                        18.6.3. Палиндромы, созданны е с помощью указателей
                    
                
            
                
                    
                        Глава 19 Векторы, шаблоны и исключения
                    
                
            
                
                    
                        19.1. Проблемы
                    
                
            
                
                    
                        19.2. Изменение размера
                    
                
            
                
                    
                        19.2.1. Представление
                    
                
            
                
                    
                        19.2.2. Функции reserve и capacity
                    
                
            
                
                    
                        19.2.3. Функция resize
                    
                
            
                
                    
                        19.2.4. Функция push_back
                    
                
            
                
                    
                        19.2.5. Присваивание
                    
                
            
                
                    
                        19.2.6. Предыдущая версия класса vector
                    
                
            
                
                    
                        19.3. Шаблоны
                    
                
            
                
                    
                        19.3.1. Типы как шаблонные параметры
                    
                
            
                
                    
                        19.3.2. Обобщенное программирование
                    
                
            
                
                    
                        19.3.3. Контейнеры и наследование
                    
                
            
                
                    
                        19.3.4. Целые типы как шаблонные параметры
                    
                
            
                
                    
                        19.3.5. Вывод шаблонных аргументов
                    
                
            
                
                    
                        19.3.6. Обобщение класса vector
                    
                
            
                
                    
                        19.4. Проверка диапазона и исключения
                    
                
            
                
                    
                        19.4.1. Примечание: вопросы проектирования
                    
                
            
                
                    
                        19.4.1.1. Совместимость
                    
                
            
                
                    
                        19.4.1.2. Эффективность
                    
                
            
                
                    
                        19.4.1.3. Ограничения
                    
                
            
                
                    
                        19.4.1.4. Необязательная проверка
                    
                
            
                
                    
                        19.4.2. Признание: макрос
                    
                
            
                
                    
                        19.5. Ресурсы и исключения
                    
                
            
                
                    
                        19.5.1. Потенциальные проблемы управления ресурсами
                    
                
            
                
                    
                        19.5.2. Получение ресурсов — это инициализация
                    
                
            
                
                    
                        19.5.3. Гарантии
                    
                
            
                
                    
                        19.5.4. Класс auto_ptr
                    
                
            
                
                    
                        19.5.5. Принцип RAII для класса vector
                    
                
            
                
                    
                        Глава 20 Контейнеры и итераторы
                    
                
            
                
                    
                        20.1. Хранение и обработка данных
                    
                
            
                
                    
                        20.1.1. Работа с данными
                    
                
            
                
                    
                        20.1.2. Обобщение кода
                    
                
            
                
                    
                        20.2. Принципы библиотеки STL
                    
                
            
                
                    
                        20.3. Последовательности и итераторы
                    
                
            
                
                    
                        20.3.1. Вернемся к примерам
                    
                
            
                
                    
                        20.4. Связанные списки
                    
                
            
                
                    
                        20.4.1. Операции над списками
                    
                
            
                
                    
                        20.4.2. Итерация
                    
                
            
                
                    
                        20.5. Еще одно обобщение класса vector
                    
                
            
                
                    
                        20.6. Пример: простой текстовый редактор
                    
                
            
                
                    
                        20.6.1. Строки
                    
                
            
                
                    
                        20.6.2. Итерация
                    
                
            
                
                    
                        20.7. Классы vector, list и string
                    
                
            
                
                    
                        20.7.1. Операции insert и erase
                    
                
            
                
                    
                        20.8. Адаптация нашего класса vector к библиотеке STL
                    
                
            
                
                    
                        20.9. Адаптация встроенных массивов к библиотеке STL
                    
                
            
                
                    
                        20.10. Обзор контейнеров
                    
                
            
                
                    
                        20.10.1. Категории итераторов
                    
                
            
                
                    
                        Глава 21 Алгоритмы и ассоциативные массивы
                    
                
            
                
                    
                        21.1. Алгоритмы стандартной библиотеки
                    
                
            
                
                    
                        21.2. Простейший алгоритм: find()
                    
                
            
                
                    
                        21.2.1. Примеры использования обобщенных алгоритмов
                    
                
            
                
                    
                        21.3. Универсальный алгоритм поиска: find_if()
                    
                
            
                
                    
                        21.4. Объекты-функции
                    
                
            
                
                    
                        21.4.1. Абстрактная точка зрения на функции-объекты
                    
                
            
                
                    
                        21.4.2. Предикаты на членах класса
                    
                
            
                
                    
                        21.5. Численные алгоритмы
                    
                
            
                
                    
                        21.5.1. Алгоритм accumulate()
                    
                
            
                
                    
                        21.5.2. Обобщение алгоритма accumulate()
                    
                
            
                
                    
                        21.5.3. Алгоритм inner_product
                    
                
            
                
                    
                        21.5.4. Обобщение алгоритма inner_product()
                    
                
            
                
                    
                        21.6. Ассоциативные контейнеры
                    
                
            
                
                    
                        21.6.1. Ассоциативные массивы
                    
                
            
                
                    
                        21.6.2. Обзор ассоциативных массивов
                    
                
            
                
                    
                        21.6.3. Еще один пример ассоциативного массива
                    
                
            
                
                    
                        21.6.4. Алгоритм unordered_map()
                    
                
            
                
                    
                        21.6.5. Множества
                    
                
            
                
                    
                        21.7. Копирование
                    
                
            
                
                    
                        21.7.1. Алгоритм copy()
                    
                
            
                
                    
                        21.7.2. Итераторы потоков
                    
                
            
                
                    
                        21.7.3. Использование класса set для поддержания порядка
                    
                
            
                
                    
                        21.7.4. Алгоритм copy_if()
                    
                
            
                
                    
                        21.8. Сортировка и поиск
                    
                
            
                
                    
                        Часть IV Дополнительные темы
                    
                
            
                
                    
                        Глава 22 Идеалы и история
                    
                
            
                
                    
                        22.1. История, идеалы и профессионализм
                    
                
            
                
                    
                        22.1.1. Цели и философия языка программирования
                    
                
            
                
                    
                        22.1.2. Идеалы программирования
                    
                
            
                
                    
                        22.1.2.1. Чего мы хотим?
                    
                
            
                
                    
                        22.1.2.2. Общие подходы
                    
                
            
                
                    
                        22.1.2.3. Непосредственное выражение идей
                    
                
            
                
                    
                        22.1.2.4. Уровень абстракции
                    
                
            
                
                    
                        22.1.2.5. Модульность
                    
                
            
                
                    
                        22.1.2.6. Логичность и минимализм
                    
                
            
                
                    
                        22.1.3. Стили и парадигмы
                    
                
            
                
                    
                        22.2. Обзор истории языков программирования
                    
                
            
                
                    
                        22.2.1. Первые языки программирования
                    
                
            
                
                    
                        22.2.2. Корни современных языков программирования
                    
                
            
                
                    
                        22.2.2.1. Язык программирования Fortran
                    
                
            
                
                    
                        22.2.2.2. Язык программирования COBOL
                    
                
            
                
                    
                        22.2.2.3. Язык программирования Lisp
                    
                
            
                
                    
                        22.2.3. Семейство языков Algol
                    
                
            
                
                    
                        22.2.3.1. Язык программирования Algol-60
                    
                
            
                
                    
                        22.2.3.2. Язык программирования Pascal
                    
                
            
                
                    
                        22.2.3.3. Язык программирования Ada
                    
                
            
                
                    
                        22.2.4. Язык программирования Simula
                    
                
            
                
                    
                        22.2.5. Язык программирования С
                    
                
            
                
                    
                        22.2.6. Язык программирования С++
                    
                
            
                
                    
                        22.2.7. Современное состояние дел
                    
                
            
                
                    
                        22.2.8. Источники информации
                    
                
            
                
                    
                        Глава 23 Обработка текста
                    
                
            
                
                    
                        23.1. Текст
                    
                
            
                
                    
                        23.2. Строки
                    
                
            
                
                    
                        23.3. Потоки ввода-вывода
                    
                
            
                
                    
                        23.4. Ассоциативные контейнеры
                    
                
            
                
                    
                        23.4.1. Детали реализации
                    
                
            
                
                    
                        23.5. Проблема
                    
                
            
                
                    
                        23.6. Идея регулярных выражений
                    
                
            
                
                    
                        23.7. Поиск с помощью регулярных выражений
                    
                
            
                
                    
                        23.8. Синтаксис регулярных выражений
                    
                
            
                
                    
                        23.8.1. Символы и специальные символы
                    
                
            
                
                    
                        23.8.2. Классы символов
                    
                
            
                
                    
                        23.8.3. Повторения
                    
                
            
                
                    
                        23.8.4. Группировка
                    
                
            
                
                    
                        23.8.5. Варианты
                    
                
            
                
                    
                        23.8.6. Наборы символов и диапазоны
                    
                
            
                
                    
                        23.8.7. Ошибки в регулярных выражениях
                    
                
            
                
                    
                        23.9. Сравнение регулярных выражений
                    
                
            
                
                    
                        23.10. Ссылки
                    
                
            
                
                    
                        Глава 24 Числа
                    
                
            
                
                    
                        24.1. Введение
                    
                
            
                
                    
                        24.2. Размер, точность и переполнение
                    
                
            
                
                    
                        24.2.1. Пределы числовых диапазонов
                    
                
            
                
                    
                        24.3. Массивы
                    
                
            
                
                    
                        24.4. Многомерные массивы в стиле языка С
                    
                
            
                
                    
                        24.5. Библиотека Matrix
                    
                
            
                
                    
                        24.5.1. Размерности и доступ
                    
                
            
                
                    
                        24.5.2. Одномерный объект класса Matrix
                    
                
            
                
                    
                        24.5.3. Двумерный объект класса Matrix
                    
                
            
                
                    
                        24.5.4. Ввод-вывод объектов класса Matrix
                    
                
            
                
                    
                        24.5.5. Трехмерный объект класса Matrix
                    
                
            
                
                    
                        24.6. Пример: решение систем линейных уравнений
                    
                
            
                
                    
                        24.6.1. Классическое исключение Гаусса
                    
                
            
                
                    
                        24.6.2. Выбор ведущего элемента
                    
                
            
                
                    
                        24.6.3. Тестирование
                    
                
            
                
                    
                        24.7. Случайные числа
                    
                
            
                
                    
                        24.8. Стандартные математические функции
                    
                
            
                
                    
                        24.9. Комплексные числа
                    
                
            
                
                    
                        24.10. Ссылки
                    
                
            
                
                    
                        Глава 25 Программирование встроенных систем
                    
                
            
                
                    
                        25.1. Встроенные системы
                    
                
            
                
                    
                        25.2. Основные понятия
                    
                
            
                
                    
                        25.2.1. Предсказуемость
                    
                
            
                
                    
                        25.2.2. Принципы
                    
                
            
                
                    
                        25.2.3. Сохранение работоспособности после сбоя
                    
                
            
                
                    
                        25.3. Управление памятью
                    
                
            
                
                    
                        25.3.1. Проблемы со свободной памятью
                    
                
            
                
                    
                        25.3.2. Альтернатива универсальной свободной памяти
                    
                
            
                
                    
                        25.3.3. Пример пула
                    
                
            
                
                    
                        25.3.4. Пример стека
                    
                
            
                
                    
                        25.4. Адреса, указатели и массивы
                    
                
            
                
                    
                        25.4.1. Непроверяемые преобразования
                    
                
            
                
                    
                        25.4.2. Проблема: дисфункциональный интерфейс
                    
                
            
                
                    
                        25.4.3. Решение: интерфейсный класс
                    
                
            
                
                    
                        25.4.4. Наследование и контейнеры
                    
                
            
                
                    
                        25.5. Биты, байты и слова
                    
                
            
                
                    
                        25.5.1. Операции с битами и байтами
                    
                
            
                
                    
                        25.5.2. Класс bitset
                    
                
            
                
                    
                        25.5.3. Целые числа со знаком и без знака
                    
                
            
                
                    
                        25.5.4. Манипулирование битами
                    
                
            
                
                    
                        25.5.5. Битовые поля
                    
                
            
                
                    
                        25.5.6. Пример: простое шифрование
                    
                
            
                
                    
                        25.6. Стандарты программирования
                    
                
            
                
                    
                        25.6.1. Каким должен быть стандарт программирования?
                    
                
            
                
                    
                        25.6.2. Примеры правил
                    
                
            
                
                    
                        25.6.3. Реальные стандарты программирования
                    
                
            
                
                    
                        Глава 26 Тестирование
                    
                
            
                
                    
                        26.1. Чего мы хотим
                    
                
            
                
                    
                        26.1.1. Предостережение
                    
                
            
                
                    
                        26.2. Доказательства
                    
                
            
                
                    
                        26.3. Тестирование
                    
                
            
                
                    
                        26.3.1. Регрессивные тесты
                    
                
            
                
                    
                        26.3.2. Модульные тесты
                    
                
            
                
                    
                        26.3.2.1. Стратегия тестирования
                    
                
            
                
                    
                        26.3.2.2. Схема простого теста
                    
                
            
                
                    
                        26.3.2.3. Случайные последовательности
                    
                
            
                
                    
                        26.3.3. Алгоритмы и не алгоритмы
                    
                
            
                
                    
                        26.3.3.1. Зависимости
                    
                
            
                
                    
                        26.3.3.2. Управление ресурсами
                    
                
            
                
                    
                        26.3.3.3. Циклы
                    
                
            
                
                    
                        26.3.3.4. Ветвление
                    
                
            
                
                    
                        26.3.4. Системные тесты
                    
                
            
                
                    
                        26.3.4.1. Зависимости
                    
                
            
                
                    
                        26.3.5. Тестирование классов
                    
                
            
                
                    
                        26.3.6. Поиск предположений, которые не выполняются
                    
                
            
                
                    
                        26.4. Проектирование с учетом тестирования
                    
                
            
                
                    
                        26.5. Отладка
                    
                
            
                
                    
                        26.6. Производительность
                    
                
            
                
                    
                        26.6.1. Измерение времени
                    
                
            
                
                    
                        26.7. Ссылки
                    
                
            
                
                    
                        Глава 27 Язык программирования С
                    
                
            
                
                    
                        27.1. Языки С и С++: братья
                    
                
            
                
                    
                        27.1.1. Совместимость языков С и С++
                    
                
            
                
                    
                        27.1.2. Свойства языка С++, которых нет в языке С
                    
                
            
                
                    
                        27.1.3. Стандартная библиотека языка С
                    
                
            
                
                    
                        27.2. Функции
                    
                
            
                
                    
                        27.2.1. Отсутствие перегрузки имен функций
                    
                
            
                
                    
                        27.2.2. Проверка типов аргументов функций
                    
                
            
                
                    
                        27.2.3. Определения функций
                    
                
            
                
                    
                        27.2.4. Вызов функций, написанных на языке С, из программы на языке С++, и наоборот
                    
                
            
                
                    
                        27.2.5. Указатели на функции
                    
                
            
                
                    
                        27.3. Второстепенные языковые различия
                    
                
            
                
                    
                        27.3.1. Дескриптор пространства имен struct
                    
                
            
                
                    
                        27.3.2. Ключевые слова
                    
                
            
                
                    
                        27.3.3. Определения
                    
                
            
                
                    
                        27.3.4. Приведение типов в стиле языка С
                    
                
            
                
                    
                        27.3.5. Преобразование указателей типа void*
                    
                
            
                
                    
                        27.3.6. Перечисление
                    
                
            
                
                    
                        27.3.7. Пространства имен
                    
                
            
                
                    
                        27.4. Свободная память
                    
                
            
                
                    
                        27.5. Строки в стиле языка С
                    
                
            
                
                    
                        27.5.1. Строки в стиле языка С и ключевое слово const
                    
                
            
                
                    
                        27.5.2. Операции над байтами
                    
                
            
                
                    
                        27.5.3. Пример: функция strcpy()
                    
                
            
                
                    
                        27.5.4. Вопросы стиля
                    
                
            
                
                    
                        27.6. Ввод-вывод: заголовок stdio
                    
                
            
                
                    
                        27.6.1. Вывод
                    
                
            
                
                    
                        27.6.2. Ввод
                    
                
            
                
                    
                        27.6.3. Файлы
                    
                
            
                
                    
                        27.7. Константы и макросы
                    
                
            
                
                    
                        27.8. Макросы
                    
                
            
                
                    
                        27.8.1. Макросы, похожие на функции
                    
                
            
                
                    
                        27.8.2. Синтаксис макросов
                    
                
            
                
                    
                        27.8.3. Условная компиляция
                    
                
            
                
                    
                        27.9. Пример: интрузивные контейнеры
                    
                
            
                
                    
                        Часть V Приложения
                    
                
            
                
                    
                        Приложение А Краткий обзор языка
                    
                
            
                
                    
                        A.1. Общие сведения
                    
                
            
                
                    
                        A.1.1. Терминология
                    
                
            
                
                    
                        A.1.2. Старт и завершение программы
                    
                
            
                
                    
                        A.1.3. Комментарии
                    
                
            
                
                    
                        A.2. Литералы
                    
                
            
                
                    
                        A.2.1. Целочисленные литералы
                    
                
            
                
                    
                        A.2.1.1. Числовые системы
                    
                
            
                
                    
                        A.2.2. Литералы с плавающей точкой
                    
                
            
                
                    
                        A.2.3. Булевы литералы
                    
                
            
                
                    
                        A.2.4. Символьные литералы
                    
                
            
                
                    
                        A.2.5. Строковые литералы
                    
                
            
                
                    
                        A.2.6. Указательные литералы
                    
                
            
                
                    
                        A.3. Идентификаторы
                    
                
            
                
                    
                        A.3.1. Указательные литералы
                    
                
            
                
                    
                        A.4. Область видимости, класс памяти и время жизни
                    
                
            
                
                    
                        A.4.1. Область видимости
                    
                
            
                
                    
                        A.4.2. Класс памяти
                    
                
            
                
                    
                        A.4.3. Время жизни
                    
                
            
                
                    
                        A.5. Выражения
                    
                
            
                
                    
                        A.5.1. Операторы, определенные пользователем
                    
                
            
                
                    
                        A.5.2. Неявное преобразование типа
                    
                
            
                
                    
                        A.5.2.1. Продвижения
                    
                
            
                
                    
                        A.5.2.2. Преобразования
                    
                
            
                
                    
                        A.5.2.3. Преобразования, определенные пользователем
                    
                
            
                
                    
                        A.5.3. Константные выражения
                    
                
            
                
                    
                        A.5.4. Оператор sizeof
                    
                
            
                
                    
                        A.5.5. Логические выражения
                    
                
            
                
                    
                        A.5.6. Операторы new и delete
                    
                
            
                
                    
                        A.5.7. Операторы приведения
                    
                
            
                
                    
                        A.6. Инструкции
                    
                
            
                
                    
                        A.7. Объявления
                    
                
            
                
                    
                        A.7.1. Определения
                    
                
            
                
                    
                        A.8. Встроенные типы
                    
                
            
                
                    
                        A.8.1. Указатели
                    
                
            
                
                    
                        A.8.2. Массивы
                    
                
            
                
                    
                        A.8.3. Ссылки
                    
                
            
                
                    
                        A.9. Функции
                    
                
            
                
                    
                        A.9.1. Разрешение перегрузки
                    
                
            
                
                    
                        A.9.2. Аргументы по умолчанию
                    
                
            
                
                    
                        A.9.3. Неопределенные аргументы
                    
                
            
                
                    
                        A.9.4. Спецификации связей
                    
                
            
                
                    
                        A.10. Типы, определенные пользователем
                    
                
            
                
                    
                        A.10.1. Перегрузка операций
                    
                
            
                
                    
                        A.11. Перечисления
                    
                
            
                
                    
                        A.12. Классы
                    
                
            
                
                    
                        A.12.1. Доступ к членам класса
                    
                
            
                
                    
                        A.12.1.1. Указатель this
                    
                
            
                
                    
                        A.12.1.2. Друзья
                    
                
            
                
                    
                        A.12.2. Определения членов класса
                    
                
            
                
                    
                        A.12.3. Создание, уничтожение и копирование
                    
                
            
                
                    
                        A.12.3.1. Деструкторы
                    
                
            
                
                    
                        A.12.3.2. Копирование
                    
                
            
                
                    
                        A.12.4. Производные классы
                    
                
            
                
                    
                        A.12.4.1. Виртуальные функции
                    
                
            
                
                    
                        A.12.4.2. Абстрактные классы
                    
                
            
                
                    
                        A.12.4.3. Сгенерированные операции
                    
                
            
                
                    
                        A.12.5. Битовые поля
                    
                
            
                
                    
                        A.12.6. Объединения
                    
                
            
                
                    
                        A.13. Шаблоны
                    
                
            
                
                    
                        A.13.1. Шаблонные аргументы
                    
                
            
                
                    
                        A.13.2. Конкретизация шаблонов
                    
                
            
                
                    
                        A.13.3. Шаблонные типы членов-классов
                    
                
            
                
                    
                        A.14. Исключения
                    
                
            
                
                    
                        A.15. Пространства имен
                    
                
            
                
                    
                        A.16. Альтернативные имена
                    
                
            
                
                    
                        A.17. Директивы препроцессора
                    
                
            
                
                    
                        A.17.1. Директива #include
                    
                
            
                
                    
                        A.17.2. Директива #define
                    
                
            
                
                    
                        Приложение Б Обзор стандартной библиотеки
                    
                
            
                
                    
                        Б.1. Обзор
                    
                
            
                
                    
                        Б.1.1. Заголовочные файлы
                    
                
            
                
                    
                        Б.1.2. Пространство имен std
                    
                
            
                
                    
                        Б.1.3. Стиль описания
                    
                
            
                
                    
                        Б.2. Обработка ошибок
                    
                
            
                
                    
                        Б.2.1. Исключения
                    
                
            
                
                    
                        Б.3. Итераторы
                    
                
            
                
                    
                        Б.3.1. Модель итераторов
                    
                
            
                
                    
                        Б.3.2. Категории итераторов
                    
                
            
                
                    
                        Б.4. Контейнеры
                    
                
            
                
                    
                        Б.4.1. Обзор
                    
                
            
                
                    
                        Б.4.2. Типы членов
                    
                
            
                
                    
                        Б.4.3. Конструкторы, деструкторы и присваивания
                    
                
            
                
                    
                        Б.4.4. Итераторы
                    
                
            
                
                    
                        Б.4.5. Доступ к элементам
                    
                
            
                
                    
                        Б.4.6. Операции над стеком и двусторонней очередью
                    
                
            
                
                    
                        Б.4.7. Операции над списком
                    
                
            
                
                    
                        Б.4.8. Размер и емкость
                    
                
            
                
                    
                        Б.4.9. Другие операции
                    
                
            
                
                    
                        Б.4.10. Операции над ассоциативными контейнерами
                    
                
            
                
                    
                        Б.5. Алгоритмы
                    
                
            
                
                    
                        Б.5.1. Немодицифирующие алгоритмы для последовательностей
                    
                
            
                
                    
                        Б.5.2. Алгоритмы, модифицирующие последовательности
                    
                
            
                
                    
                        Б.5.3. Вспомогательные алгоритмы
                    
                
            
                
                    
                        Б.5.4. Сортировка и поиск
                    
                
            
                
                    
                        Б.5.5. Алгоритмы для множеств
                    
                
            
                
                    
                        Б.5.6. Кучи
                    
                
            
                
                    
                        Б.5.7. Перестановки
                    
                
            
                
                    
                        Б.5.8. Функции min и max
                    
                
            
                
                    
                        Б.6. Утилиты библиотеки STL
                    
                
            
                
                    
                        Б.6.1. Вставки
                    
                
            
                
                    
                        Б.6.2. Объекты-функции
                    
                
            
                
                    
                        Б.6.3. Класс pair
                    
                
            
                
                    
                        Б.7. Потоки ввода-вывода
                    
                
            
                
                    
                        Б.7.1. Иерархия потоков ввода-вывода
                    
                
            
                
                    
                        Б.7.2. Обработка ошибок
                    
                
            
                
                    
                        Б.7.3. Операции ввода
                    
                
            
                
                    
                        Б.7.4. Операции вывода
                    
                
            
                
                    
                        Б.7.5. Форматирование
                    
                
            
                
                    
                        Б.7.6. Стандартные манипуляторы
                    
                
            
                
                    
                        Б.8. Манипуляции строками
                    
                
            
                
                    
                        Б.8.1. Классификация символов
                    
                
            
                
                    
                        Б.8.2. Строки
                    
                
            
                
                    
                        Б.8.3. Сравнение регулярных выражений
                    
                
            
                
                    
                        Б.9. Численные методы
                    
                
            
                
                    
                        Б.9.1. Предельные значения
                    
                
            
                
                    
                        Б.9.2. Стандартные математические функции
                    
                
            
                
                    
                        Б.9.3. Комплексные числа
                    
                
            
                
                    
                        Б.9.4. Класс valarray
                    
                
            
                
                    
                        Б.9.5. Обобщенные числовые алгоритмы
                    
                
            
                
                    
                        Б.10. Функции стандартной библиотеки языка С
                    
                
            
                
                    
                        Б.10.1. Файлы
                    
                
            
                
                    
                        Б.10.2. Семейство функций printf()
                    
                
            
                
                    
                        Б.10.3. Строки в стиле языка С
                    
                
            
                
                    
                        Б.10.4. Память
                    
                
            
                
                    
                        Б.10.5. Дата и время
                    
                
            
                
                    
                        Б.10.6. Другие функции
                    
                
            
                
                    
                        Б.11. Другие библиотеки
                    
                
            
                
                    
                        Приложение В Начало работы со средой разработки Visual Studio
                    
                
            
                
                    
                        В.1. Запуск программы
                    
                
            
                
                    
                        В.2. Инсталляция среды разработки Visual Studio
                    
                
            
                
                    
                        В.3. Создание и запуск программ
                    
                
            
                
                    
                        В.3.1. Создание нового проекта
                    
                
            
                
                    
                        В.3.2. Используйте заголовочный файл std_lib_facilities.h
                    
                
            
                
                    
                        В.3.3. Добавление в проект исходного файла на языке С++
                    
                
            
                
                    
                        В.3.4. Ввод исходного кода
                    
                
            
                
                    
                        В.3.5. Создание исполняемого файла
                    
                
            
                
                    
                        В.3.6. Выполнение программы
                    
                
            
                
                    
                        В.3.7. Сохранение программы
                    
                
            
                
                    
                        В.4. Что дальше
                    
                
            
                
                    
                        Приложение Г Инсталляция библиотеки FLTK
                    
                
            
                
                    
                        Г.1. Введение
                    
                
            
                
                    
                        Г.2. Загрузка библиотеки FLTK
                    
                
            
                
                    
                        Г.3. Инсталляция библиотеки FLTK
                    
                
            
                
                    
                        Г.4. Использование библиотеки FLTK в среде Visual Studio
                    
                
            
                
                    
                        Г.5. Как тестировать, если не все работает
                    
                
            
                
                    
                        Приложение Д Реализация графического пользовательского интерфейса
                    
                
            
                
                    
                        Д.1. Реализация обратных вызовов
                    
                
            
                
                    
                        Д.2. Реализация класса Widget
                    
                
            
                
                    
                        Д.3. Реализация класса Window
                    
                
            
                
                    
                        Д.4. Реализация класса Vector_ref
                    
                
            
                
                    
                        Д.5. Пример: манипулирование объектами класса Widget
                    
                
            
                
                    
                        Глоссарий
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        Библиография
                    
                
            
                
                    
                        ***
                    
                
            
                
                    
                        Примечания

Ввод и вывод Предыдущая Стр. 26 из 57 Следующая

Оглавление

Ввод и вывод
Предыдущая Стр. 26 из 57 Следующая