Предисловие

Когда несколько лет назад в языке C++ появились шаблоны, лишь немно­гие из программистов на C++ могли предположить, какое влияние это окажет на стандарт библиотеки языка. Стандартная библиотека шаблонов (Standard Template Library) была первоначально разработана сотрудника­ми Hewlett-Packard А.А (читать далее...)

стр. 0

STL для начинающих

1.1. Шаблоны, пространства имен и тип bool

Как легко догадаться из названия, стандартная библиотека шаблонов (STL) основывается на относительно новом понятии шаблона. Поэтому мы начнем с краткого обсуждения этого предмета. Шаблонные функции Предположим, что для некоторого положительного числа .г (читать далее...)

стр. 1 2 3 4

1.2. Знакомство с STL

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

стр. 5 6 7 8 9

1.3. Векторы, списки и двусторонние очереди

В программе readwr.cpp три раза встречается слово vector. #include <vector> vector<int> v; vector<int>::iterator  i; Применение концепции вектора обеспечивает выделение непрерывной па­мяти, для чего программисты на С обычно пользуются функциями malloc, realloc и free. (читать далее...)

стр. 10 11 12

1.4. Сортировка

Ниже следует расширение программы readwr.cpp, рассмотренной в начале раздела 1.2. Эта программа сортирует вектор v, то есть располагает элемен­ты v в восходящем порядке: // sortl.cpp: Сортировка вектора. (читать далее...)

стр. 13 14 15

1.5. Алгоритм find

Следующая программа показывает, как мы можем находить требуемое зна­чение в векторе: // findl.cpp: Найти заданное значение в векторе. #include <iostream> #include <vector> #include <a (читать далее...)

стр. 16

1.6. Алгоритм copy и итератор вставки

Мы можем использовать алгоритм сору для копирования элементов одно­го контейнера в другой, причем, например, источником может быть век­тор, а приемником - список, как показывает следующая программа: // copyl.c (читать далее...)

стр. 17 18

1.8. Типы, определенные пользователем

До сих пор все контейнеры, которые мы использовали, содержали элемен­ты типа int. Кроме стандартных типов, таких как int, в контейнерах STL можно хранить типы, определенные пользователем. Так как вызов merge{.. (читать далее...)

стр. 19

1.9. Категории итераторов

Как видно из раздела 1.4, мы можем использовать алгоритм sort для масси­вов, векторов и двусторонних очередей, но не для списков. Алгоритм find, напротив, может быть использован для всех четырех типов контейнеров. (читать далее...)

стр. 20 21 22 23

1.10. Алгоритмы replace и reverse

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

стр. 24

1.11. Возвращаясь к алгоритму sort

Функция qsort из стандартной библиотеки С является достаточно общей, потому что она принимает в качестве четвертого аргумента функцию срав­нения, определяемую пользователем. При использовании алгоритма sort в разделе 1.4 (читать далее...)

стр. 25

1.12. Введение в функциональные объекты

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

стр. 26 27

1.13. Использование функций remove и remove_if

В этом разделе мы рассмотрим три алгоритма, используя их для векторов, но имея в виду, что они также применимы к двусторонним очередям и спискам. Алгоритм findjf В дополнение к алгоритму find, использовавшемуся в разделе 1.5 (читать далее...)

стр. 28 29 30

1.14. Класс auto_ptr

После того как размещена динамическая память, нужно внимательно следить за тем, чтобы она была правильно освобождена. Обычно программисты на С используют для этого malloc и free, а программисты на C++ используют так­же new и delete. (читать далее...)

стр. 31 32

Другие алгоритмы и контейнеры

2.1. Алгоритм accumulate

Нахождение суммы элементов последовательности или подпоследователь­ности лучше всего достигается с помощью алгоритма accumulate. Этот алго­ритм вместе с некоторыми другими, которые имеют отношение к вычисле­ниям, определен в заголовке numeric, а не algorithm, как большинство остальных алгоритмов. (читать далее...)

стр. 33 34

2.2. Алгоритм foreach

Мы можем использовать алгоритм for_each для вызова функции с каждым из элементов последовательности в качестве аргумента. Вот программа, которая демонстрирует это: //  for_each.cpp:  Алгоритм for_each. (читать далее...)

стр. 35

2.3. Подсчет

Алгоритм count подсчитывает, какое количество элементов последователь­ности равно заданному значению. Давайте используем этот алгоритм для того, чтобы подсчитать, сколько раз в строке встречается буква е. (читать далее...)

стр. 36

2.4. Функциональные объекты, определенные в STL

Напомним, что такие функции, как found (в предыдущем разделе), называ­ются предикатами. Они возвращают true или fake в зависимости от соблюде­ния некоторого условия. Выражение greater<int>, которое встретилось нам в разделе 1.1 (читать далее...)

стр. 37 38

2.5. Введение в ассоциативные контейнеры

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

стр. 39

2.6. Множества и множества с дубликатами

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

стр. 40 41

2.7. Словари и словари с дубликатами

Словари Происхождение термина «ассоциативный контейнер» становится ясным, как только мы начинаем рассматривать словари. Например, телефонный справочник связывает (ассоциирует) имена с номерами. (читать далее...)

стр. 42 43

2.8. Пары и сравнения

Чтобы использовать словари и словари с дубликатами более интересным способом, нам нужно познакомиться с шаблонным классом pair (пара), ко­торый полезен также и для других целей. Этот класс использует следую­щая программа: // pairs.с (читать далее...)

стр. 44 45

2.9. Снова словари

Поскольку словарь содержит пары (k, d), где k является ключом, a d - со­путствующими данными, можно предположить, что шаблон pair будет по­лезен при работе со словарями. Как и для последовательного контейнера, для ассоциативного контейнера мы можем использовать итератор i\ в этом случае выражение *i будет обозначать пару, в которой (*i).f (читать далее...)

стр. 46 47 48 49

2.10. Функции insert

Добавление новых записей в предыдущем разделе осуществляется с помо­щью оператора доступа по индексу в следующем выражении D[p]   = nr; Вместо этого оператора присваивания мы могли бы написать выражение D.i (читать далее...)

стр. 50 51

2.11.     Удаление элементов словаря

Для удаления элементов словаря имеются три функции-члена erase, объявленные следующим образом: void erase(iterator position); void erase(iterator  first,   iterator  last); size_type erase(const  key_type &x (читать далее...)

стр. 52

2.12.     Более удобные строки

До сих пор мы использовали достаточно примитивный способ работы со строками. Например, в программе тар.срр нам необходимо было выпол­нить два оператора delete[] (*i).first; D.erase(i); чтобы удалить элемент множества, на который ссылался итератор г. (читать далее...)

стр. 53 54 55 56

Последовательные контейнеры

3.1. Векторы и связанные с ними типы

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

стр. 57 58 59

3.2. Функции capacity и reserve

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

стр. 60 61 62

3.3. Обзор функций-членов класса vector

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

стр. 63 64

3.4. Двусторонние очереди

Различные типы контейнеров очень похожи в отношении способов их применения. Например, каждый из трех типов контейнеров (vector, deque и list) определяет конструктор, который использует в качестве параметров число повторений и значение, например: vector<d (читать далее...)

стр. 65 66

3.5. Списки

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

стр. 67 68 69 70

3.6. Векторы векторов

До сих пор в наших примерах излюбленным типом был vector<int>. Впол­не очевидно, что мы можем заменить int на другой тип и использовать vector<double>, vector<char> и т. п. А вправе ли мы использовать более сложный тип, чем int, double и char, между двумя угловыми скобками? (читать далее...)

стр. 71

3.7. Как избавиться от явного выделения памяти

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

стр. 72 73

Ассоциативные контейнеры

4.1. Введение

Из раздела 2.5 мы узнали, что существуют четыре типа ассоциативных кон­тейнеров: множества, множества с дубликатами, словари и словари с дубли­катами. Множества и множества с дубликатами характеризуются двумя па­раметрами шаблона, а словари и словари с дубликатами - тремя: template <c (читать далее...)

стр. 74 75 76

4.2. Функции-члены множеств

У класса set имеются три конструктора, которые могут быть определены следующим образом внутри класса: set(const Compare& comp = Compare!)); // 1 (по умолчанию) set(const value_type* first, const value_type* last, const Compare& (читать далее...)

стр. 77 78 79 80

4.3. Объединение и пересечение множеств

В этом разделе мы рассмотрим известные математические операции на­хождения пересечения и объединения двух множеств, которые проиллюс­трированы на рисунке 4.1. Рисунок 4.1. Пересечение и объединение двух множеств Для обозначения операций пересечения и объединения мы будем исполь­зовать операторы * и +, хотя в математике обычно используются обозначе­ния Пии. (читать далее...)

стр. 81 82

4.4. Отличия множеств с дубликатами от просто множеств

Мы уже обсуждали множества и множества с дубликатами в разделе 2.6, и не мешает снова обратиться к тексту программы multiset.cpp, приведен­ному в том разделе. Напомним, что каждый элемент множества уникален, в то время как множества с дубликатами могут содержать несколько эк­земпляров одинаковых элементов. (читать далее...)

стр. 83

4.5. Словари

У словарей существуют три конструктора, объявленные следующим образом: map (const Compares comp = Compared);                                       //  1 тар(const value_type*  first,  const value_type*                                last, const Compares comp = Compared);  (читать далее...)

стр. 84 85 86

4.6. Словари с дубликатами

Как стало ясно из раздела 2.7, словари с дубликатами отличаются от просто словарей тем, что они допускают два и более элементов с одинаковыми клю­чами. Рисунок 4.4 показывает возможное представление словаря с дублика­тами. (читать далее...)

стр. 87 88

4.7. Сводный указатель

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

стр. 89 90 91

Адаптеры контейнеров

5.1. Стеки

Стек (stack) представляет собой структуру данных, которая допускает только две операции, изменяющие ее размер: push (для добавления элемен­та в конце) и pop (для удаления элемента в конце). Иными словами, стек работает по принципу «последний пришел - первый ушел» (также назы­ваемому LIFO от английского Last In - First Out). (читать далее...)

стр. 92 93

5.2. Очереди

Очередь (queue) является структурой данных, в которую можно добавлять элементы с одного конца, сзади, и удалять с другого конца, спереди. Мы можем узнать и изменить значения элементов спереди и сзади, как пока­зано на рисунке 5.2 (читать далее...)

стр. 94

5.3. Очереди с приоритетами

Очередь с приоритетами (priority queue) является структурой данных, из которой, если она не пуста, можно удалить только наибольший элемент. Как и для стеков, наиболее важными функциями-членами являются push, pop и top. (читать далее...)

стр. 95 96

Функциональные объекты и адаптеры

6.1. Функциональные объекты

В разделах 1.12 и 2.4 уже рассмотрены функциональные объекты, которые зачастую бывают трудны для восприятия, поэтому мы немного поэкспе­риментируем с ними вне рамок STL. Следующая программа демонстриру­ет класс sq, который можно использовать для вычисления значения х2 це­лого числа х: II   funobjl.c (читать далее...)

стр. 97 98 99

6.2. Унарные предикаты и привязки

В математике мы можем превратить функцию двух аргументов в функцию одного аргумента, если один из аргументов сделаем константой. Напри­мер, мы можем определить функцию g как g(x)=f(x, с) где с является константой. (читать далее...)

стр. 100

6.3. Отрицатели

Программисты часто используют унарный оператор ! (не). Например, вы­ражение !(х  < у) эквивалентно х >= у Подобным же образом на функции двух аргументов действует отрицатель not2. (читать далее...)

стр. 101

6.4. Два полезных базовых класса STL

Могли ли мы найти более простой пример для обсуждения адаптера notl, чем sort(a,   a+5,  not2(less<int>())) ; встречающийся в программе not2demo.cpp в предыдущем разделе? В част­ности, можем ли мы применить notl к написанному нами функционально­му объекту, например, таким образом: sort(a,   a+5,   not2(iLessThen())) ; (читать далее...)

стр. 102 103

6.5. Функциональные объекты и алгоритм transform

Как видно из раздела 2.4, STL определяет следующие шаблонные классы, которые мы можем использовать как функциональные объекты, сопрово­див их парой скобок: plus<T>                         minus<T (читать далее...)

стр. 104 105 106

6.6. Адаптеры итераторов

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

стр. 107 108 109

Обобщенные алгоритмы

Вступление

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

стр. 110

7.1. Немодифицирующие последовательные алгоритмы

Алгоритмы в этом разделе «просматривают» последовательности, не из­меняя их. 7.1.1. АлгоритмыУш*/, count, JЪг_each, find_first_oj"иfind end Ссылки в комментариях показывают, что мы уже обсуждали большую часть следующих алгоритмов: Inputlterator find                  II Обсуждался в разделе 1.5 (читать далее...)

стр. 111 112 113 114 115

7.2. Модифицирующие последовательные алгоритмы

Алгоритмы в этом разделе изменяют последовательность, с которой работают. 7.2.1. Преобразовать Outputlterator transform (Inputlterator first,   Inputlterator last, Outputlterator result,  UnaryOperation unary_op); (читать далее...)

стр. 116 117 118 119 120 121 122 123 124 125 126 127

7.3. Алгоритмы, связанные с сортировкой

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

стр. 128 129 130 131 132 133 134 135 136 137 138 139 140 141

7.4. Обобщенные численные алгоритмы

Чтобы использовать алгоритмы, обсуждаемые в этом разделе, мы должны написать в программе #include <numeric> если работаем с версией STL, соответствующей проекту стандарта C++. Для HP STL необходимо заменить эту строчку на следующую: #include <a (читать далее...)

стр. 142 143 144

7.5. Прикладная программа: метод наименьших квадратов

Теперь мы применим алгоритмы accumulate и inner jproduct для решения из­вестной практической задачи. Предположим, что имеется набор из п пар чи­сел (х, у), где каждая пара соответствует точке на плоскости ху, и мы хотим найти прямую линию, которая является достаточно разумным приближени­ем зависимости, представленной этими точками, как показано на рисунке 7.1 (читать далее...)

стр. 145 146 147

Прикладная программа: очень большие числа

8.1. Введение

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

стр. 148 149 150

8.2. Реализация класса large

Только что упомянутая строка препроцессора находится в следующем файле заголовка largeh, который мы использовали в программе largedem.cpp: II  large.h: Многоразрядная целочисленная арифметика. #include <i (читать далее...)

стр. 151 152 153 154 155 156 157

8.3. Вычисление числа п

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

стр. 158 159 160 161

Краткая история Qt

Средства разработки Qt впервые стали известны общественности в мае 1995 года. Первоначально Qt разрабатывались Хаарвардом Нордом (исполнительным дирек­тором компании «Trollteeh») и Лириком Чеймб-Ингом (президентом «Trolltech»). (читать далее...)

стр. 0 1 2 3

Первое знакомство

«Здравствуй, Qt»

Давайте начнем с очень простой Qt-программы. Сначала мы разберем каждую строку этой программы, а затем покажем способы ее компиляции и выполнения. 1 #include <QApplication> 2 #include <Q (читать далее...)

стр. 4 5 6

Взаимодействие с пользователем

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

стр. 7

Компоновка виджетов

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

стр. 8 9 10

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

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

стр. 11 12

Создание диалоговых окон

Введение

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

стр. 13

Подклассы QDialog

Первое диалоговое окно мы создадим полностью вручную, чтобы было ясно, ка выглядит исходный код такой программы. Затем мы покажем способы построени. диалоговых окон в Qt Designer, который является средством визуального проектирс вания в Qt. (читать далее...)

стр. 14 15 16 17 18 19 20

Подробное описание технологии сигналов и слотов

Механизм сигналов и слотов играет решающую роль в разработке программ Qt. Он позволяет прикладному программисту связывать различные объекты, которые ничего не знают друг о друге. Мы уже соединяли некоторые сигналы и слоты, объяв­ляли наши собственные сигналы и слоты, реализовывали наши собственные слоты и генерировали наши собственные сигналы. (читать далее...)

стр. 21 22 23

Быстрое проектирование диалоговых окон

Средства разработки Qt спроектированы таким образом, чтобы было приятно программировать «вручную» и чтобы этот процесс был интуитивно понятен; и нет ничего необычного в разработке всего приложения Qt на «чистом» языке С++. (читать далее...)

стр. 24 25 26 27 28 29

Изменяющиеся диалоговые окна

Нами были рассмотрены способы формирования диалоговых окон, которые всегда содержат одни и те же виджеты. В некоторых случаях требуется иметь диало­говые окна, форма которых может меняться. Наиболее известны два типа изменяю­щихся диалоговых окон: расширяемые диалоговые окна (are extension dialogs) и мно­гостраничные диалоговые окна (multi-page dialogs). (читать далее...)

стр. 30 31 32 33 34

Динамические диалоговые окна

Динамическими называются диалоговые окна, которые создаются на основе файлов . ui, сделанных в Qt Designer, во время выполнения приложения. Вместо пре­образования файла . ui компилятором uic в программу на С++ мы можем загрузить этот файл на этапе выполнения, используя класс QUiLoader: QUiLoader uiLoader; (читать далее...)

стр. 35

Встроенные классы виджетов и диалоговых окон

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

стр. 36 37

Создание главных окон

Создание подкласса QMainWindow

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

стр. 38 39 40 41

Создание меню и панелей инструментов

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

стр. 42 43 44 45

Создание и настройка строки состояния

После создания меню и панелей инструментов мы готовы приступить к созда­нию строки состояния приложения Электронная таблица. Обычно строка состояния содержит два индикатора: положение текущей ячейки и формулу текущей ячейки. (читать далее...)

стр. 46 47

Реализация меню File

В данном разделе мы определим слоты и закрытые функции, необходимые для обеспечения работы меню File и для управления списком недавно используемых файлов. void MainWindow::newFile() { if (okToContinue ()) { spreadsheet->c (читать далее...)

стр. 48 49 50 51 52 53

Применение диалоговых окон

В данном разделе мы рассмотрим способы применения диалоговых окон в Qt: как они создаются и инициализируются и как они реагируют на действия пользова­теля при работе с ними. Мы будем использовать диалоговые окна Find, Go-to-Cell и Sort (найти, перейти в ячейку и сортировать), которые были созданы нами в главе 2. (читать далее...)

стр. 54 55 56 57 58 59

Сохранение настроек приложения

В конструкторе MainWindow мы уже вызывали функцию readSettingsO для за­грузки сохраненных приложением настроек. Аналогично в функции closeEvent () мы вызывали writeSettingsO для сохранения настроек. (читать далее...)

стр. 60 61

Работа со многими документами

Теперь мы готовы написать функцию main() приложения Электронная таблица: #include <QApplication> ttinclude "mainwindow.h" int main(int argc, char *argv[]) { QApplication app(argc, argv); (читать далее...)

стр. 62 63 64

Экранные заставки

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

стр. 65

Реализация функциональности приложения

Центральный виджет

Центральную область QMainWindow может занимать любой виджет. Ниже даете, краткий обзор возможных вариантов. 1. Стандартный виджет Qt В качестве центрального могут использоваться стандартные виджеты, наприме QTableWidget или QTextEdit. (читать далее...)

стр. 66

Создание подкласса QTableWidget

Класс Spreadsheet наследует QTableWidget. Виджет QTableWidget фактически яв­ляется сеткой, представляющей собой двумерный разряженный массив. На нем ото­бражается часть ячеек всей сетки, полученная при прокрутке изображения пользова­телем. (читать далее...)

стр. 67 68 69 70 71

Загрузка и сохранение

Теперь мы реализуем загрузку и сохранение файла данных для приложения Электронная таблица, используя двоичный пользовательский формат. Для этого мы используем объекты QFile и QDataStream, которые совместно обеспечивают независи­мый от платформы ввод-вывод в двоичном формате. (читать далее...)

стр. 72 73 74

Реализация меню Edit

Теперь мы готовы приступить к реализации слотов, относящихся к меню Edit данного приложения, void Spreadsheet::cut() { соруО; del(); } Слот cut () соответствует пункту меню Edit|Cut (Правка|Вырезать). (читать далее...)

стр. 75 76 77

Реализация других меню

Теперь мы реализуем слоты для пунктов меню Tools и Options. Рис. 4.7. Меню Tools и Options приложения Электронная таблица void Spreadsheet::recalculate() { for (int row = 0; row < (читать далее...)

стр. 78 79 80

Создание подкласса QTableWidgetltem

Класс Cell наследует QTableWidgetltem. Этот класс спроектирован для удобства работы с Spreadsheet, но он не имеет никаких особых связей с данным классом элек­тронной таблицы и теоретически может применяться для любого объекта QTableWid­get. (читать далее...)

стр. 81 82 83 84 85 86 87

Создание пользовательских виджетов

Настройка виджетов Qt

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

стр. 88 89 90

Создание подкласса QWidget

Многие пользовательские виджеты являются простой комбинацией существу­ющих виджетов, либо встроенных в Qt, либо других пользовательских виджетов (таких, как HexSpinBox). Если пользовательские виджеты строятся на основе сущест­вующих виджетов, то они, как правило, могут разрабатываться в Qt Designer. (читать далее...)

стр. 91 92 93 94 95 96 97 98 99

Интеграция пользовательских виджетов в Qt Designer

Прежде чем мы сможем использовать пользовательские виджеты в Qt Designer, мы должны сделать так, что Qt Designer будет знать о них. Для этого существует два способа: метод «продвижения» («promotion») и метод подключения (plugin). (читать далее...)

стр. 100 101 102

Двойная буферизация

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

стр. 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117

Управление компоновкой

Компоновка виджетов на форме

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

стр. 118 119 120 121

Стековая компоновка

Класс QStackedLayout ^менеджер стековой компоновки) управляет компоновкой набора дочерних виджетов или «страниц», показывая в каждый конкретный момент только одну из них и скрывая от пользователя остальные. (читать далее...)

стр. 122 123

Разделители

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

стр. 124 125

Области с прокруткой

Класс QScrollArea содержит область отображения, которую можно прокручи­вать, и две полосы прокрутки. Если мы хотим добавить в виджет полосы прокрутки, значительно проще использовать класс QScrollArea, чём создавать свои собственные экземпляры QScrollBar и самим реализовывать функциональность скроллинга. (читать далее...)

стр. 126

Прикрепляемые виджеты и панели инструментов

Прикрепляемыми являются виджеты, которые могут крепиться к определенным областям главного окна приложения QMainWindow или быть независимыми «пла­вающими» окнами. QMainWindow имеет четыре области крепления таких виджетов: одна сверху, одна снизу, одна слева и одна справа от центрального виджета. (читать далее...)

стр. 127 128

Многодокументный интерфейс

Приложения, которые обеспечивают работу со многими документами в цент­ральной области главного окна, называются приложениями с многодокументным интерфейсом или MDI-приложениями. В Qt MDI-приложения создаются с исполь­зованием в качестве центрального виджета класса QWorkspace и путем представления каждого документа в виде дочернего окна QWorkspace. (читать далее...)

стр. 129 130 131 132 133 134

Обработка событий

Переопределение обработчиков событий

В Qt событие (event) - это объект, производный от QEvent. Qt обрабатывает бс лее сотни типов событий, каждое из которых идентифицируется определенным зна чением перечисления. Например, QEvent: type0 возвращает QEvent: :MouseButton Press для событий нажатия кнопки мышки. (читать далее...)

стр. 135 136 137 138

Установка фильтров событий

Одним из действительно эффективных средств в модели событий Qt является возможность с помощью некоторого экземпляра объекта QObject контролировать события другого экземпляра объекта QObject еще до того, как они дойдут до послед­него. (читать далее...)

стр. 139 140 141

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

Когда мы вызываем QApplication:; ехес(), тем самым начинаем цикл обработки событий Qt. При запуске приложения Qt генерирует несколько событий для отобра­жения на экране виджетов. После этого начинает выполняться цикл обработки со­бытий: постоянно проверяется их возникновение, и эти события отправляются к объектам QObject данного приложения. (читать далее...)

стр. 142 143 144

Графика 2D и 3D

Рисование при помощи QPainter

Чтобы начать рисовать на устройстве рисования (обычно это виджет), мы прос то создаем объект QPainter и передаем ему указатель на устройство. Например: void MyWidget::paintEvent(QPaintEvent *event) { QPainter painter(this); (читать далее...)

стр. 145 146 147 148

Преобразования рисовальщика

В используемой по умолчанию координатной системе рисовальщика QPainter точка (0,0) находится в левом верхнем углу устройства рисования; значение коорди­нат х увеличивается при перемещении вправо, а значение координат у увеличивает­ся при перемещении вниз. (читать далее...)

стр. 149 150 151 152 153 154 155

Высококачественное воспроизведение изображения при помощи QImage

При рисовании мы можем столкнуться с необходимостью принятия компромис­сных решений относительно скорости и точности. Например, в системах XII и Мае OS X рисование по виджету QWidget или по пиксельной карте QPixmap основано на применении родного для платформы графического процессора (paint engine). (читать далее...)

стр. 156 157 158 159 160 161 162

Графические средства OpenGL

OpenGL является стандартным программным интерфейсом, предназначенным для воспроизведения графики 2D и 3D. Приложения Qt могут отображать графику 3D, используя модуль QtOpenGL, который рассчитан на применение системной биб­лиотеки OpenGL. (читать далее...)

стр. 163 164 165 166

Технология «drag-and-drop»

Обеспечение поддержки технологии “drag-and-drop”

Технология «drag-and-drop» состоит из двух действий: перетаскивание «захвачен­ных» объектов и их «освобождение». Виджеты в Qt могут использоваться в качестве пе­реносимых объектов, в качестве места отпускания этих объектов или в обоих качествах. (читать далее...)

стр. 167 168 169 170 171

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

До сих пор в представленных примерах мы полагались на поддержку QMimeData распространенных типов МШЕ. Так, мы вызывали QMimeData::setText() для созда­ния объекта переноса текста и использовали QMimeData: иrls() для получения содер­жимого объекта переноса типа text/uri-list. (читать далее...)

стр. 172 173 174 175

Работа с буфером обмена

помещения данных в буфер обмена и функции text(), image() или pixmap() для счи­тывания данных из буфера обмена. Мы уже приводили примеры работы с буфером обмена в приложении Электронная таблица из главы 4, Для некоторых приложений может оказаться не достаточно встроенных функ­циональных возможностей. (читать далее...)

стр. 176

Классы отображения элементов

Применение удобных классов отображения элементов

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

стр. 177 178 179 180 181 182 183

Применение заранее определенных моделей

В Qt заранее определено несколько моделей, предназначенных для использова­ния с классами представлений: QStringListModel Хранит список строк QStandardltemModel Хранит Данные произвольной иерархической структуры QDirModel Формирует структуру локальной файловой системы QSqlQueryModel Формирует набор результата SQL-запроса QSqlTableModel Формирует SQL-таблицу QSqlRelationalTableModel Формирует SQL-таблицу с внешними ключами (foreign keys) QSortFilterProxyModel . (читать далее...)

стр. 184 185 186 187

Реализация пользовательских моделей

Заранее определенные в Qt модели предлагают удобные средства обработки и просмотра данных. Однако некоторые источники данных не могут эффективно ис­пользоваться для этих моделей, й в этих случаях необходимо создавать пользова­тельские модели, оптимизированные на применение таких источников данных. (читать далее...)

стр. 188 189 190 191 192 193 194 195 196 197 198

Реализация пользовательских делегатов

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

стр. 199 200 201 202 203

Классы-контейнеры

Последовательные контейнеры

Главное преимущество Qt-контейнеров - одинаковое поведение на всех платформах и неяв­ное совместное использование данных. Неявное совместное использование или «ко­пирование при записи» - это оптимизация, позволяющая передавать контейнеры це­ликом без существенного ухудшения производительности. (читать далее...)

стр. 204 205 206 207 208 209 210 211 212

Ассоциативные контейнеры

Ассоциативный контейнер содержит произвольное количество элементов одинакового типа, индексируемых некоторым ключом. Qt содержит два основных класса ассоциативных контейнеров: QMap<K, T>HQHash<K (читать далее...)

стр. 213 214 215

Обобщенные алгоритмы

В заголовочном файле <QtAlgorithms> объявляются глобальные шаблонные функции, которые реализуют основные алгоритмы для контейнеров. Большинство этих функций работают с итераторами в стиле STL. (читать далее...)

стр. 216 217

Строки, массивы байтов и объекты произвольного типа

QString, QByteAr ray и QVariant - три класса, которые имеют много общего с контей­нерами и могут использоваться в некоторых контекстах как альтернатива контей­нерам. Кроме того, как и контейнеры, эти классы используют неявное совмещение данных для уменьшения расхода памяти и повышения быстродействия. (читать далее...)

стр. 218 219 220 221 222 223 224

Ввод-вывод

Введение

Почти в каждом приложении приходится читать или записывать файлы или вы­полнять другие операции ввода-вывода. Qt обеспечивает великолепную поддержку ввода-вывода при помощи GTODevice - мощной абстракции «устройств», способных читать и записывать блоки байтов. (читать далее...)

стр. 225 226

Чтение и запись двоичных данных

Самый простой способ загрузки и сохранения двоичных данных в Qt - получить экземпляр класса QFile, открыть файл и получить к нему доступ через объект QDataStream. QDataStream обеспечивает не зависимый от платформы формат памяти, который поддерживает такие базовые типы С++, как int и double, и многие типы данных Qt, включая QByteArray, QFont, Qlmage, QPixmap, QString и QVariant, а также классы-контейнеры Qt, например QList<T (читать далее...)

стр. 227 228 229 230 231

Чтение и запись текста

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

стр. 232 233 234 235

Работа с каталогами

Класс QDir обеспечивает не зависимые от платформы средства работы с катало­гами и получение информации о файлах. Для демонстрации способов применения класса QDi г мы напишем небольшое консольное приложение, которое подсчитывает размер дискового пространства, занимаемого всеми изображениями в указанном ка­талоге во всех его подкаталогах, вне зависимости от глубины их расположения. (читать далее...)

стр. 236 237

Ресурсы, внедренные в исполняемый модуль

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

стр. 238

Связь между процессами

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

стр. 239 240 241 242

Базы данных

Введение

Модуль QtSql средств разработки Qt обеспечивает не зависимый от платформы и типа базы данных интерфейс для доступа с помощью языка SQL к базам данных. Этот интерфейс поддерживается набором классов, использующих архитектуру Qt модель/представление для интеграции средств доступа к базам данных с интерфей­сом пользователя. (читать далее...)

стр. 243

Соединение с базой данных и выполнение запросов

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

стр. 244 245 246 247 248 249

Представление данных в табличной форме

Во многих случаях табличное представление является самым простым представ­лением набора данных для пользователей. В этом и последующих разделах мы рас­смотрим простое приложение CD Collection (Коллекция компакт-дисков), в кото­ром модель QSqlTableModel и ее подкласс QSqlRelationalTableModel используются для просмотра и взаимодействия пользователей с данными, хранимыми в базе данных. (читать далее...)

стр. 250 251 252

Создание форм по технологии «master-detail»

Теперь мы рассмотрим главную форму, которая реализует подход «master-de-tail». Главный вид представляет собой список компакт-дисков. Вид описания дета­лей представляет собой список дорожек текущего компакт-диска. (читать далее...)

стр. 253 254 255 256 257 258

Введение

Написание FTP-клиентов Написание HTTP-клиентов Написание клиент-серверных приложений на базе TCP Передача и прием дейтаграмм UDP Qt обеспечивает классы QFtp и QHttp для работы с протоколами FTP и HTTP. (читать далее...)

стр. 259

Написание FTP-клиентов

Мы начнем с примера чтения одного файла с помощью функции get(). В этом примере создается консольное приложение с именем ftpget, которое скачивает уда­ленный файл, указанный в командной строке. Давайте начнем с функции main(): int main(int argc, char *argv[]) { QCoreApplication app(argc, argv); (читать далее...)

стр. 260 261 262 263 264 265

Написание HTTP-клиента

Класс QHttp реализует клиентскую часть протокола HTTP в Qt. Он содержит различные функции для выполнения самых распространенных операций протокола HTTP, включая get() и post(), и обеспечивает средство выполнения произвольных запросов HTTP. (читать далее...)

стр. 266 267 268

Написание клиент-серверных приложений на базе TCP

Классы QTcpSocket и QTcpServer могут использоваться для реализации клиентов и серверов TCP. TCP - это транспортный протокол, который составляет основу большинства прикладных протоколов сети Интернет, включая FTP и HTTP, и кото­рый может также использоваться для создания пользовательских протоколов. (читать далее...)

стр. 269 270 271 272 273 274 275

Передача и прием дейтаграмм UDP

Класс QUdpSocket может использоваться для отправки и приема дейтаграмм UDP. UDP - это ненадежный, ориентированный на дейтаграммы протокол. Некото­рые приложения применяют протокол UDP, поскольку с ним легче работать, чем с протоколом TCP. (читать далее...)

стр. 276 277 278

XML

Введение

Чтение документов XML при помощи интерфейса SAX Чтение документов XML при помощи интерфейса DOM Запись документов XML XML (Extensible Markup Language - расширяемый язык разметки) - это уни­версальный формат текстовых файлов, который получил широкое распространение при обмене и хранении данных. (читать далее...)

стр. 279

Чтение документов XML при помощи интерфейса SAX

SAX является фактическим стандартом программного интерфейса с открытым исходным кодом, который обеспечивает чтение документов XML. Классы Qt для интерфейса SAX моделируют реализацию SAX2 Java с некото­рыми отличиями в названиях для обеспечения принятых в Qt правил обозначений названий классов и их членов. (читать далее...)

стр. 280 281 282 283

Чтение документов XML при помощи интерфейса DOM

DOM является стандартным программным интерфейсом синтаксического ана­лиза документов XML, который разработан Консорциумом всемирной паутины (W3C). Qt обеспечивает уровень 2 интерфейса DOM для чтения, обработки и запи­си документов XML без проверки их достоверности. (читать далее...)

стр. 284 285 286

Запись документов XML

Существует два основных подхода к формированию файлов XML в приложени­ях Qt: • мы можем построить дерево DOM и вызвать для него функцию save (); • мы можем сформировать файл XML вручную. Выбор между этими подходами часто не зависит от типа используемого нами ин­терфейса для чтения документов XML: SAX или DOM. (читать далее...)

стр. 287 288

Обеспечение интерактивной помощи

Введение

Всплывающие подсказки, комментарии в строке состояния и справки «что это такое?» Использование QTextBrowser в качестве простого браузера системы помощи Использование Qt Assistant для мощной интерактивной системы помощи Большинство приложений предоставляют своим пользователям систему помощи, работающую в интерактивном режиме. (читать далее...)

стр. 289

Всплывающие подсказки, комментарии в строке состояния и справки «что это такое?»

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

стр. 290 291

Использование QTextBrowser в качестве простого браузера системы помощи

Для больших приложений может потребоваться более сложная система помощи в отличие от той, которую обычно обеспечивают всплывающие подсказки, коммен­тарии в строке состояния и справки «что это такое?» (читать далее...)

стр. 292 293 294

Использование Qt Assistant для мощной интерактивной системы помощи

Qt Assistant является свободно распространяемой интерактивной системой по­мощи, поддерживаемой фирмой «Trolltech». Основным ее достоинством является поддержка индексации и поиск по всему тексту, а также возможность ее работы с наборами документации нескольких приложений. (читать далее...)

стр. 295 296

Интернационализация

Введение

Кроме латинского алфавита, используемого для английского и многих ев­ропейских языков, Qt 4 обеспечивает широкую поддержку остальных мировых сис­тем записи: • Qt применяет Unicode в программном интерфейсе и во внутренних операциях. (читать далее...)

стр. 297

Работа с Unicode

Unicode является стандартной кодировкой, которая поддерживает большинство мировых систем записи. В основе кодировки Unicode лежит идея использования для хранения символов 16 бит, а не 8, и поэтому она позволяет закодировать примерно 65 000 символов вместо только 2561. (читать далее...)

стр. 298 299 300 301 302 303 304 305 306 307 308

Динамическое переключение языков

Рис. 17.1. Динамическое меню Language Поскольку мы не знаем, какой язык захочет использовать пользователь после за­пуска приложения, мы теперь не будем загружать файлы перевода в функции main(). (читать далее...)

стр. 309 310 311 312

Перевод приложений

Перевод приложения Qt, которое содержит вызовы tr(), состоит из трех этапов: 1. Выполнение утилиты lupdate для извлечения из исходного кода приложения всех видимых пользователем строк. 2. Перевод приложения при помощи Qt Linguist. (читать далее...)

стр. 313 314 315

Многопоточная обработка

Введение

• Создание потоков • Синхронизация потоков • Взаимодействие с главным потоком • Применение классов Qt во вторичных потоках Обычные приложения с графическим интерфейсом имеют один поток (thread) выполнения и производят в каждый момент времени одну операцию. (читать далее...)

стр. 316

Создание потоков

Обеспечить многопоточную обработку в приложении Qt достаточно просто: мы только создаем подкласс QThread и переопределяем его функцию run(). Чтобы пока­зать, как это работает, мы начнем с рассмотрения программного кода очень простого подкласса QTh read, который периодически выводит на консоль заданный текст: class Thread : public QThread { Q.O (читать далее...)

стр. 317 318

Синхронизация потоков

Обычным требованием для многопоточных приложений является синхрониза­ция работы нескольких потоков. Для этого в Qt предусмотрены следующие классы: QMutex, QReadWriteLock, QSemaphore и QWaitCondition. (читать далее...)

стр. 319 320 321 322 323 324

Взаимодействие с главным потоком

При запуске приложения Qt работает только один поток - главный. Только этот поток может создать объект QApplication или QCoreApplication и вызвать для него функцию ехес(). После вызова ехес() этот поток либо ожидает возникновения како­го-нибудь события, либо обрабатывает какое-нибудь событие. (читать далее...)

стр. 325 326 327 328

Применение классов Qt во вторичных потоках

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

стр. 329 330

Создание подключаемых модулей

Введение

Динамические библиотеки (называемые также совместно используемыми биб­лиотеками или библиотеками DLL) - это независимые модули, хранимые в отдель­ном файле на диске, доступ к которым могут получать несколько приложений. (читать далее...)

стр. 331 332 333 334 335 336 337

Как обеспечить в приложении возможность подключения модулей

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

стр. 338 339 340

Написание подключаемых к приложению модулей

Подключаемый к приложению модуль является подклассом QObject и интерфей­сов, которые он собирается обеспечить. Прилагаемый к этой книге компакт-диск со­держит два подключаемых модуля, предназначенных для приложения Text Art, представленного в предыдущем разделе, и показывающих, что это приложение пра­вильно работает с несколькими подключаемыми модулями. (читать далее...)

стр. 341 342 343

Возможности, зависимые от платформы

Введение

В данной главе мы рассмотрим некоторые доступные программистам Qt воз­можности, которые зависят от платформы. Мы начнем с рассмотрения способов доступа к таким «родным» программным интерфейсам, как Win32 API в системе Windows, Carbon в системе Mac OS X и Xlib в системе XII. (читать далее...)

стр. 344

Применение «родных» программных интерфейсов

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

стр. 345 346 347 348 349 350 351 352 353 354 355

Управление сеансами в системе XII

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

стр. 356 357 358 359 360

Программирование встроенных систем

Встроенные системы

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

стр. 361

Первое знакомство с Qtopia

Приложения Qtopia Core могут разрабатываться на любой платформе, позво­ляющей запускать цепочки многоплатформенных инструментальных средств. Наи* более распространено построение кросс-компилятора GNU С++ в системе Unix. (читать далее...)

стр. 362 363

Настройка QtopiaCore

При установке Qtopia Core можно указать функции, которые мы хотим устра­нить, чтобы снизить расход памяти. В состав Qtopia Core входит сотня конфигури­руемых функций, каждой из которых соответствует какой-то препроцессорный сим­вол. (читать далее...)

стр. 364 365

Установка Qt

В данном приложении рассматривается порядок установки Qt в вашу систему с компакт-диска, который прилагается к этой книге. Компакт-диск содержит версию Qt 4.1.1 для Windows, Mac OS X и XI1 (для Linux и большинства версий Unix). (читать далее...)

стр. 366 367 368 369

С++ для программистов Java и С#

Введение вC++

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

стр. 370 371

Первое знакомство с С++

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

стр. 372 373 374 375

Основные отличия языков

Теперь мы более внимательно рассмотрим области, в которых С++ отличается от Java и С#. Многие языковые различия объясняются особенностями скомпилирован­ных модулей С++ и повышенным вниманием к производительности. (читать далее...)

стр. 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399

Стандартная библиотека С++

В данном разделе мы кратко рассмотрим стандартную библиотеку С++. На рис. Б.З приводится список базовых заголовочных файлов С++. Заголовочные файлы <exception>, <limits>, <new> и ctypeinf о> (читать далее...)

стр. 400 401