2. Где достать Qt?
================
Библиотека поставляется по нескольким лицензиям, одни из которых — платные, другие — нет. Под
оконную систему X11 всегда можно с сайта www.trolltech.com легально
взять GPL-версию Qt (и использовать, естественно, только
в некоммерческих проектах). С системой Windows дело обстоит сложнее, поскольку, по мнению верхушки
TrollTech, эта система не является ареной OpenSource-разработки. Последняя бесплатная версия для
Windows — 2.3.0. Но для находчивых людей это не проблема, есть сеть eDonkey Текущей на данный
момент является версия 3.3.1. В скором времени ожидается версия 4.

3. Технические подробности Qt
=============================
Означало Qt «работало» на пользовательский интерфейс. Вот именно поэтому эта часть библиотеки наиболее
используема и наиболее развита. интересен подход к позиционированию виджетов (виджет — элемент
GUI, всё что рисуется на окошке, включая его само) — система слоёв (layout) позволяет вам забыть об абсолютном позиционировании, как о странном сне. Теперь класс Layout сам следит за тем, что вы делаете с, например, главным окном и позиционирует все внутренние виджеты вслед за изменением геометрии этого окошка.
Центральной идеей Qt является сигнально-слотовый механизм, реализующий взаимосвязь между объектами.
Этот механизм реализован посредством прекомпиляции, что позволяет использовать его без всяких
ухищрений (если вы заинтересованы в Qt, прямо в данный момент забудьте о callback-вызовах ).
Каждый Qt-объект (не только вызуальные элементы!) может генерировать некоторые сигналы, жестко
за�?итые в структуру его класса. Сигнал — это функция, объявленная в специальной секции signals
и не имеющая реализации («тела») а только передаваемые аргументы. К сигналу объекта (заметьте, не класса) могут быть подключены слоты. Слот — это всего ли�?ь метод, также объявленный в специальных секциях «slots». Слоты
могут быть доступными (секция «public slots»), защищенными («protected slots») и
скрытыми («private slots»). При помощи специального метода connect слот подсоединяется к сигналу.
Неболь�?ой пример:

connect(myValueDetector, SIGNAL(ValueChange( Value a),
myApplicationUpdater, SLOT(onValueChange( Value a ))));

После чего при каждом «испускании» сигнала ValueChange объектом myValueDetector
будет вызываться слот onValueChange объекта myApplicationUpdater.
Плюсы — к одному сигналу можно подключить несколько слотов.
Минусы — один слот нельзя использовать для нескольких сигналов (например, для обработки группы кнопок). Сравните с системой событий VCL/CLX — там как раз всё наоборот. Рассмотрим неболь�?ой пример использования сигнально-слотового механизма:

//то, что инициирует сигнал для изменения
class aValueDetector:public QObject
{
Q_OBJECT // нужно для объявления сигналов и слотов
public:
aValueDetector( Value a );
signals:
ValueChange( Value a );
}
//то, что его сможет обработать
class aApplicationUpdater:public QObject
{
Q_OBJECT
public:
aApplicationUpdater();
public slots:
onValueChange( Value a );
}
// то, что всем управляет
class aApplication
{
public:
aApplication()
{
//некоторый код
..................
//а вот теперь самое главное
connect(myValueDetector, SIGNAL(ValueChange( Value a )),
myApplicationUpdater, SLOT(onValueChange( Value a ))));
// причем, заметьте, один сигнал может вызывать и другой сигнал и иметь несколько коннектов
// одновременно
}
protected:
aValueDetector* myValueDetector;
aApplicationUpdater* myApplicationUpdater;
}

Как видите, код «немного» отличается от стандартного C++. Данный текст подаётся на вход мета-компилятора moc, который из него уже производит стандартный код C++, который затем компилируется любым компилятором. Moc отличает «свои», т.е. поддерживающие сигнально-слотовый механизм, классы от стандартных по ключевому слову Q_OBJECT в самом начале объявления класса.

Перечислим основные достоинства ядра библиотеки Qt:
* встроенная поддержка Unicode и локализации (очень хоро�?о и очень правильно реализованной, смею
заметить). В Qt4 обещают новый механизм рендеринга �?рифтов, поддерживающий Unicode.
* мощные события и фильтры событий (событие — это что-то вроде универсального сигнала, который можно посылать любому виджету, распознавать и соотвествующим образом обрабатывать с помощью фильтров. Например нажатие различных клави�?)
* многофункциональные управляемые интервалами таймеры которые делают возможным просто и быстро
вставлять много разных заданий в управляемый событиями ГП�?.
* иерархические и настраиваемые объектные деревья, организующие принадлежность объектов естественным
образом.
* защищенные указатели QGuardedPtr, которые автоматически принимают значение NULL при
уничтожении соответствующего объекта, в отличие от обычных указателей в C++, которые в этом
случае становятся «неопределенными указателями».
* Удобная документация, доступная и на русском языке (ссылки к сожалению не знаю, но могу с удовольствием выслать по заявке).

В состав ядра библиотеки входят как классы для построения GUI (например: метка, поле ввода, кнопка и
т.п.), так и классы, предназначенные для организации различных струтур хранения данных (например,
списковых), работы с файлами, сетевого взаимодействия и многого другого. Некоторые из этих
возможностей реализованы в виде дополнительных модулей:
* модуль Canvas, мощный инструмент для работы с двухмерной графикой. Он использует принцип
структурирования графики, что, несомненно, будет полезно в программировании простых двухмерных
игр и подобного рода вещах. Холст состоит из нескольких «элементов», каждый элемент представлен
объектом. Поддерживается также ряд интересных возможностей, таких как collision-detection, перемещение(нет во фри�?ных версиях под виндой (( )
объектов с определенными скоростями по осям. Подробнее читаем по ссылке:
Ссылка
* модуль Network, обеспечивающий поддержку сети в приложениях.
* модуль OpenGL, позволяющий работать с трехмерной графикой при помощи портабельной библиотеки
OpenGL. Поддерживается с версии 2.3.2.
* модуль SQL, реализующий доступ к базам данных из приложений Qt. Данный модуль разбит на три уровня:
пользовательский (элементы интерфейса), программный (абстрактный доступ к базам данных) и уровень
драйверов.
* модуль Table, предоставляющий в ва�?е распоряжение сетку для отображения табличных данных. Сетка
являет собой очень мощный и гибкий интерфейс, работать с которым — одно удобольствие
* модуль XML, использующий интерфейс SAX2 и реализацию DOM второго уровня.

Это далеко не полный перечень возможностей Qt.

3. Как написать простенькое приложение на QT?
=================================================
Напишем файлик main.cpp следующего содержания:

#include
#include
int main( int argc, char **argv )
{
QApplication a( argc, argv ); // ну понятно, что без аппликухи никуда
QPushButton hello( "Привет, Мир!", 0 ); // Создаём простенькую кнопочку
hello.resize( 100, 30 ); // растягиваем её, можно при желании и на весь экран
a.setMainWidget( &hello ); // Делаем кнопку основным виджетом, это нужно для того, чтобы при закратии этой самой кнопки всё приложение завершило свою работу
hello.show(); // это чтобы нашу красоту все увидели
return a.exec(); // и как говориться "Поехали" copyright by Y. Gagarin
}

Теперь напишем файл проекта под это дело (simple.pro):

PROJECT = simple
TEMPLATE = app
CONFIG = qt warn_on debug
SOURCES = main.cpp
TARGET = simple

В командной строке наберем:

qmake simple.pro

А теперь черед утилиты make: приложение готово Запускаем, наблюдаем окошко с кнопочкой.

Вступление
В данной статье я попытаюсь рассказать, что такое traits. Будут рассмотрены некоторые примеры применения traits, которые будут заключаться как в использовании traits в на�?ем коде, так и в возможных способах рас�?ирения стандартной библиотеки C++, которая тоже использует traits. Также будут рассмотрены возможные проблемы, которые могут возникнуть при рас�?ирении стандартной библиотеки C++.

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

Ну, поехали…
�?так, приступим. Думаю, начать стоит с перевода термина traits. Обычно его переводят как «свойства». Но traits реализуются классом, поэтому обычно употребляется термин «класс свойств». Следует заметить, что свойства также можно реализовать с помощью структуры, так как в C++ это практически аналоги. Далее я буду использовать термин класс, хотя все сказанное будет в той же мере относиться к структурам.

Теперь следует дать определение свойств. Натан Майерс, разработав�?ий метод использования свойств, предложил такое определение:
Класс свойств — это класс, используемый вместо параметров �?аблона. В качестве класса он объединяет полезные типы и константы; как �?аблон, он является средством для обеспечения того «дополнительного уровня косвенности», который ре�?ает все проблемы программного обеспечения.

Определение не настолько понятное, так что давайте попробуем разобраться, что же имеется в виду. Для этого предлагается рассмотреть неболь�?ой пример. В качестве примера мы рассмотрим �?аблонный класс динамического массива. Конечно, реализовывать полностью этот класс мы не будем(у нас уже есть vector), но общие концепции мы рассмотрим.
�?так, на�? �?аблонный класс динамического массива должен иметь в качестве аргументов �?аблона:
1) тип элемента �?аблона
2) тип ссылки на элемент
3) тип аргумента функций
4) тип константной ссылки
Думаю, прокомментировать стоит только тип аргумента функций. Этот тип используется для вставки элементов в массив. Например, эффективней передать int или char по значению, чем по константной ссылке.
Тогда набросок класса будет выглядеть так:
template typename ArgT = const T&,
typename RefT = T&,
typename ConstRefT = const T&>
class vector {
// ...
public:
typedef T value_type;
typedef ArgT arg_type;
typedef RefT reference;
typedef ConstRefT const_reference;

// ...
};

Для удобства были добавлены соответствующие значения параметров �?аблона по умолчанию.
Тогда каждый пользователь на�?его класса должен будет создавать объекты класса как-то так:
// используем параметры по умолчанию
vector vec1; // эквивалентно: vector

// используем параметры по умолчанию
vector vec4; // эквивалентно: vector

Все хоро�?о, все отлично работает. Но если мы захотим реализовать, например, связанный список, то нам придется для него задавать аналогичные параметры �?аблона. Это довольно муторно, так как придется каждый раз писать одно и то же. Тогда на помощь приходят классы свойств(traits). Создадим �?аблон класса, который будет содержать все те дополнительные аргументы �?аблона:
// первичный �?аблон
// подходит в общем случае - аналог аргументов �?аблона по умолчанию
template
class elem_traits {
public:
typedef const T& arg_type;
typedef T& reference;
typedef const T& const_reference;
};

Это и будет на�? класс свойств. То есть он описывает те типы(arg_type, reference, const_reference), которые представляют на�? тип T. Таким образом, нам надо вместо несколько аргументов �?аблона писать только один дополнительный аргумент — класс свойств, который содержит в себе все нужные типы.
Тогда класс на�?его динамического массива можно переписать так:
template typename traits = elem_traits > // свойство по умолчанию
class vector {
// ...
public:
typedef T value_type;
typedef typename traits::arg_type arg_type;
typedef typename traits::reference reference;
typedef typename traits::const_reference const_reference;

// ...
};

Тогда давайте посмотрим, как пользователи на�?его динамического массива будут создавать объекты:
// используется аргумент-свойство по умолчанию
vector vec1; // эквивалентно: vector >
// тогда:
// arg_type = const int&
// reference = int&
// const_reference = const int&

// используется аргумент-свойство по умолчанию
vector vec1; // эквивалентно: vector >
// тогда:
// arg_type = const char&
// reference = char&
// const_reference = const char&

В этом примере для всех типов используются аргументы по умолчанию. Но мы выяснили, что аргументы типа char луч�?е передавать не по константной ссылке, а по значению, то можно сделать специализацию на�?его класса свойств:
// специализация для типа char
template <>
class elem_traits {
public:
typedef const char arg_type; // определили тип, который передает по значению типы char
typedef char& reference;
typedef const char& const_reference;
};

Тогда объекты на�?его динамического массива будем создавать так:
vector vec1; // эквивалентно: vector >
// для всех типов, для которых не сделана специализация,
// все остается как прежде:
// тогда:
// arg_type = const std::string& (по ссылке)
// reference = std::string&
// const_reference = const std::string&

// а для типа char мы сделали специализацию
vector vec2; // эквивалентно: vector >
// тогда:
// arg_type = const char (по значению, а не по ссылке)
// reference = char&
// const_reference = const char&

Давайте теперь рассмотрим случай, когда мы хотим создать динамический массив с элементами типа char, но чтобы arg_type был эквивалентен char&. Специализация на�?его класса elem_traits для char уже существует, то есть ее сделать мы уже не можем. В таком случае остается создать новый класс свойств:
// обратите внимание: структура, а не класс
// (разницы никакой, это ли�?ний раз подчеркивается данным примером)
struct char_elem_traits {
// здесь переопределеяем тип аргумента функций.
// Мы договорились, что это будет char&
typedef char& arg_type; // определили тип, который передает по ссылке типы char

// остальное оставляем так же.
// Хотя ничто не ме�?ает нам переопределеить тип ссылки или константной ссылки
typedef char& reference;
typedef const char& const_reference;
};

Тогда осталось только создать нужный динамический массив:
vector vec;
// тогда:
// arg_type = char& (по ссылке, но не по константной)
// reference = char&
// const_reference = const char&

Но заметим, что класс(структура) char_elem_traits переопределяет только один тип — arg_type, а остальные остаются неимзенными по отно�?ению к elem_traits. То есть мы произвели ли�?нюю работу, определив самостоятельно типы reference и const_reference. Хоро�?о еще, что тут немного типов, а представьте, что их было бы около 20? 50? Чтобы каждый раз не переписывать общие свойства, можно воспользоваться открытым наследованием и переопределить нужные нам типы:
class char_elem_traits : public elem_traits {
public:
typedef char& arg_type; // определили тип, который передает по ссылке типы char

// типы reference и const_reference наследуются
};

Теперь можно использовать на�? класс свойств char_elem_traits точно так же, как мы делали это рань�?е.

До этого мы рассматривали только свойства, определяющие необходимые типы. Еще могут быть свойства-значения: они предоставляют нужные константы для данного типа.
Рассмотрим пример: нам надо написать �?аблон класса, которому для каждого параметра �?аблона(типа) требуются связанные с ним константы. Первая мысль будет такой(пример немного перефразирован из вопроса с форума):
template std::size_t T2 = sizeof(T) * 4,
std::size_t T3 = sizeof(T) * 2,
std::size_t T4 = sizeof(T)
// ...
>
class X {
// используем нужные константы
// T2 == sizeof(T) * 4
// T4 == sizeof(T)
};

template >
class X {
// используем нужные константы через traits:
// traits::T2 == sizeof(T) * 4
// traits::T4 == sizeof(T)
};

Дело в том, что компилятор не позволяет взять адрес enum-констант. Так что мы теперь точно знаем, что на�?а константа будет вставлена в код числом.
На данном этапе все хоро�?о. Но вдруг нам надо доработать класс так, что нужна константа вещественного типа. Но возникает такая проблема: в классах можно инициализировать только статические интегральные константы. В enum’ах тоже можно использовать только целые типы. Что же тогда делать? Остается только определить inline-фунцию, которая бы возвращала нужное значение:
template
struct x_traits {
static std::size_t T2() {
return(sizeof(T) * 4);
}

template >
class X {
// используем нужные константы через traits:
// T2: traits::T2() - возвращает тип std::size_t, можно и через enum
// T5: traits::T5() - возвращает тип double, по-другому не сделать, только функция
};

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

Теперь мы знаем основные принципы для работы с traits. Так что давайте рассмотрим пример, который помогает рас�?ирить стандартную библиотеку C++.
Давайте рассмотрим такую задачу(перефразировано из вопроса с форума):
Цитата
Я хочу определить размер файла с помощь класса ifstream. Сам файл весит боль�?е 5 Гб. Функция tellg() возвращает какое-то нереальное значение. Как можно правильно определить размер файла?

На данный момент все известные мне версии стандартной библиотеки C++ представляют позицию в файле 32-разрядным целым. Но дело в том, что обычные 32-разрядные целые числа не могут представлять размер файла, боль�?его 4 ГБ(происходит переполнение). То есть нам надо каким-либо образом заставить стандартную библиотеку использовать не 32-разрядные числа, а, например 64-разрядные(или вообще на�? собственный тип(класс), который мы опи�?ем). Как это сделать? Как вы уже догадались, помогут нам traits.
Как известно, ifstream — это только typedef от класса basic_ifstream. Сам же класс basic_ifstream принимает 2 параметра �?аблона: первый из них определяет тип символа, а второй определяет свойста(traits). Так вот эти свойста и должны определять, каким типом представлять позицию в файле, как сравнивать символы и тд. Второй параметр �?аблона класса basic_ifstream по умолчанию будет классом char_traits. Это стандартный класс, который описывает основные свойста: нужные типы, как сравнивать символы, присваивать и тд.. Так как мы не собираемся переопределять это все(нам надо заменить только 2 типа), тогда хоро�?ей идеей будет унаследоваться от класса char_traits.
У класса char_traits есть 2 интересующих нас типа(полный список типов можно найти в документации):
1) pos_type — тип, используемый для представления позиции в потоке
2) off_type — тип, используемый для представления смещений между позициями в потоке
Вот их-то как раз нам и надо переопределить. Давайте сделаем первую попытку:

template
struct long_pointer_traits : public std::char_traits {
typedef __int64 pos_type;
typedef __int64 off_type;
};

// используем long_ifstream

Но вот незадача: этот код не компилируется. Дело в том, что pos_type должен уметь конструироваться из нескольких заранее определенных типов(как показало исследование, 2). Базовые типы этого делать не умеют, так что придется написать свой собственный класс. Я не буду заострять внимание на этом классе, так как статья немного не на эту тему. Я просто приведу реализацию этого класса, а если у вас будут какие-то вопросы, то писать либо здесь, либо в PM. �?так, вот код:
// пространство имен, в которое заносятся детали реализации
namespace detail {
template
class pos_type_t {
typedef pos_type_t my_type;

// используем long_ifstream для получения размера файла

ОК, теперь все компилируется и работает. Но кроме получения позиции в файле, нам обычно надо работать еще с этими файлами(читать, писать). �?, конечно, нам приходится работать со строками. Тогда если мы попытаемся считать строку из файла таким образом:
long_ifstream infile(strFileName, std::ios::binary);
std::string res;
std::getline(infile, res);

То мы получим о�?ибку компиляции. Проблема в том, что std::string — это «всего ли�?ь» typedef от std::basic_string. Этот класс принимает 2 параметра �?аблона: первый — тип для представления символа, а второй(как вы уже, наверное, догадались) — traits. Так вот, для корректной работы нам надо определить и свой тип строки:
// "длинные" типы:
typedef std::basic_ifstream > long_ifstream;
typedef std::basic_string > long_string;

long_ifstream infile(strFileName, std::ios::binary);
long_string res;
std::getline(infile, res);

Теперь все работает прекрасно. Таким образом, для правильного взаимодействия компонентов стандартной библиотеки нам придется определять нужные типы и работать с ними. К сожалению, на данный момент я не знаю способа, как можно было бы создать нужный тип для стандартных потоков ввода/вывода(cin, cout, cerr, clog). Так что чтобы вывести такую «длинную» строку на экран, надо будет написать свой оператор вывода такой строки. Другого ре�?ения мне неизвестно(если кто-то знает — поделитесь, буду признателен).
Также хочу сказать несколько слов о совместимости и переносимости: приведенный мной код по определению размера боль�?ого файла был проверен на компиляторах VC7.1 и Intel C++ 8.0. �?спользовалась стандартная библиотека, которая идет по умолчанию с VC. При работе с ней замечено никаких о�?ибок не было. Проверялся код и с использованием STLPort версий 4.6.2 и 5.0. Компилировался он без проблем, но работал неправильно. Надеюсь, в дальней�?их версиях STLPort’а это будет исправлено и работать будет корректно, так как данный код соответствует стандарту.

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

Списки организуются на динамической памяти. Динамическая память, по мнению студента, это то, что можно получить при помощи операторов new и удалить dispose.

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

Кроме этого, средний студент часто путает список с очередью: все дело в том, что обычно на лабораторных работах дается задание реализовать очередь, выбрав для ее внутреннего устройства список. На самом деле, очередь это «нечто», что позволяет поместить туда элемент и получить его согласно правилу FIFO («First In, First Out» — «Первый во�?ел, первый вы�?ел»).

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

Допустим, программист реализует некую структуру данных, основываясь на хе�?-таблице, при этом коллизии ре�?аются списками элементов. Что может сделать программист, имеющий стереотипы наподобие предыдущих? Что-нибудь в духе:

#include

}

Что же тут неправильного? Ничего. Все сделано, вроде бы, достаточно логично. Тем не менее, показательно сделать несколько запусков и полюбоваться результатами (для измерения затраченного времени буду использовать команду bash time):

alk:~$ g++ -O5 t1.cpp -o t1

sys 0m0.000s

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

#include

}

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

Тем не менее, надо попробовать еще раз запустить тест:

alk:~$ g++ -O5 t2.cpp -o t2

sys 0m0.008s

Если вас не удивили полученные числа, то читать даль�?е вам будет совер�?енно неинтересно.

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

Все дело в том, что память не является чем-то однородным, более того, память образует иерархию по своей скорости, например: регистры процессора, ке�? первого уровня, ке�? второго уровня, оперативная память, жесткие диски… несмотря на то, что каждый «вид» памяти предназначен, по сути, для одного и того же — хранения данных — скорость доступа может сильно отличаться.
Когда процессор желает что-то прочитать из оперативной памяти, эти данные «оседают» в ке�?ах, доступ к которым быстрее, и если через некоторое время (пока запись еще не была удалена из ке�?ей) процессор вновь обратится к тому же адресу, что и рань�?е, то обращения к относительно медленной оперативной памяти не будет. Кроме того, ке�? разбит на области фиксированного размера (линии, в случае обычного Пентиума — 32 байта), и именно такими блоками происходит чтение данных из оперативной памяти. Таким образом, если, как во втором случае, происходит чтение последовательного массива целых чисел, то считывая один элемент, в ке�? попадут как минимум 8 элементов этого массива и все они боль�?е не будут требовать обращений к оперативной памяти в ближай�?ее время.

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

Кроме того, современные умные микропроцессоры, или не менее умные оптимизаторы, умеют делать предварительное чтение данных в ке�?. То есть, если читается блок в ке�?, то пока процессор с ним работает, можно прочитать в ке�? следующий блок памяти в расчете на последовательный доступ к данным (prefetch). Поэтому скорость последовательного доступа к элементам массива будет вы�?е, чем доступ к элементам «списка с указателями» даже когда размер структур более размера целого числа.

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

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

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

Для обнаружения подобных о�?ибок создано специализированное программное обеспечение (типа BoundsChecker от Numega), однако чаще бывает удобнее встроить механизм обнаружения утечки в свои проекты. Поэтому метод должен быть простым, и в то же время как можно более универсальным. Кроме того, не хотелось бы переписывать годами накопленные мегабайты кода, написанного и отлаженного задолго до того, как вам при�?ло в голову оградить себя от о�?ибок. Так что к списку требований добавляется стандартизация, т.е. нужно каким-то образом встроить защиту от о�?ибок в стандартный код.

Предлагаемое ре�?ение основывается на перегрузке стандартных операторов распределения памяти new и delete. Причем перегружать мы будем глобальные операторы new|delete, т.к. переписать эти операторы для каждого разработанного ранее класса было бы очень трудоемким процессом. Т.о. после перегрузки нам нужно будет только отследить распределение памяти и, соответственно, освобождение ее в момент завер�?ения программы. Все несоответствия — о�?ибка.

Реализация
Проект написан на Visual C++, но переписать его на любой другой диалект С++ не будет сли�?ком сложной задачей. Во-первых, нужно переопределить стандартные операторы new и delete так, чтобы это работало во всех проектах. Поэтому в stdafx.h добавляем следующий фрагмент:

#ifdef _DEBUG
inline void * __cdecl operator new(unsigned int size,
const char *file, int line)
{
};

inline void __cdecl operator delete(void *p)
{
};
#endif

Как видите, переопределение операторов происходит в блоке #ifdef/#endif. Это ограждает на�? код от влияния на релиз компилируемой программы. Вы, наверное, заметили, что теперь оператор new имеет три параметра вместо одного. Два дополнительных параметра содержат имя файла и номер строки, в которой выделяется память. Это удобно для обнаружения конкретного места, где происходит о�?ибка. Однако код на�?их проектов по-прежнему ссылается на оператор new, принимающий один параметр. Для исправления этого несоответствия нужно добавиить следующий фрагмент

#ifdef _DEBUG
#define DEBUG_NEW new(__FILE__, __LINE__)
#else
#define DEBUG_NEW new
#endif
#define new DEBUG_NEW

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

#ifdef _DEBUG
inline void * __cdecl operator new(unsigned int size,
const char *file, int line)
{
void *ptr = (void *)malloc(size);
AddTrack((DWORD)ptr, size, file, line);
return(ptr);
};
inline void __cdecl operator delete(void *p)
{
RemoveTrack((DWORD)p);
free(p);
};
#endif

Для полноты картины нужно переопределить операторы new[] и delete[], однако никаких существенных отличий здесь нет — творите!

Последний �?трих — пи�?ем функции AddTrack() и RemoveTrack(). Для создания списка используемых блоков памяти будем использовать стандартные средства STL:

typedef struct {
DWORD address;
DWORD size;
char file[64];
DWORD line;
} ALLOC_INFO;

if(!allocList)
return;
for(i = allocList->begin(); i != allocList->end(); i++)
{
if((*i)->address == addr)
{
allocList->remove((*i));
break;
}
}
};

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

void DumpUnfreed()
{
AllocList::iterator i;
DWORD totalSize = 0;
char buf[1024];

for(i = allocList->begin(); i != allocList->end(); i++) {
sprintf(buf, "%-50s:\t\tLINE %d,\t\tADDRESS %d\t%d unfreed\n",
(*i)->file, (*i)->line, (*i)->address, (*i)->size);
OutputDebugString(buf);
totalSize += (*i)->size;
}
sprintf(buf, "--------------------------------------------------\n");
OutputDebugString(buf);
sprintf(buf, "Total Unfreed: %d bytes\n", totalSize);
OutputDebugString(buf);
};

Надеюсь, этот проект сделает ва�?и баг-листы короче, а программы устойчивее. Удачи!

Для определения мы будем пользоваться функциями gethostname и gethostbyname из библиотеки winsock.h. Если у вас два и более сетевых подключений, программа покажет IP адрес первого в очереди.

#include <winsock.h>
#include <windows.h>

int main (int argc, char* argv[])
{
const int WSVer = 0×101;
WSAData wsaData;
hostent *h;
char Buf[128];
if (WSAStartup (WSVer, &wsaData) == 0)
{
if (gethostname (&Buf[0], 128) == 0)
{
h = gethostbyname (&Buf[0]);
if (h != NULL) MessageBox (0,inet_ntoa (*(reinterpret_cast<in_addr *>(*(h->h_addr_list)))),0,0);
else MessageBox (0,»Вы не в сети. �? IP адреса у вас нет.»,0,0);
}
WSACleanup;
}
return 0;
}

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

Узнать MAC адрес можно как предыдущим способом, с помощью GetAdaptersInfo. Но также и другим:

#include <stdio.h>
#include <windows.h>
#include <Winsock2.h>
#include <Iphlpapi.h>

///——— cpp-файл ———-

#include «stdafx.h»
char ip[]=»192.168.100.1″;

int main (int argc, char* argv[])
{
//Будем использовать сокеты
WSADATA WsaData;
DWORD _ip=inet_addr (ip);
if (WSAStartup (0×0202, &WsaData)==NULL)
printf («WSA Starup OK!\n»);

//Создаём UDP-сокет и отсылаем по нему любые данные
SOCKET udp_s;
SOCKADDR_IN udp_sin;
udp_s=socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (udp_s!=SOCKET_ERROR)
{
udp_sin.sin_family = AF_INET;
udp_sin.sin_port = htons (5232); //Шлём на любой порт.
udp_sin.sin_addr.s_addr = _ip;
if (sendto (udp_s, «TEST», 5, NULL, (SOCKADDR*)&udp_sin, sizeof (udp_sin))>0)
{ //Пакет отослан. Вытаскиваем MAC-адрес из системы
MIB_IPNETTABLE * pIpNetTable = (MIB_IPNETTABLE *) new char[0xFFFF];
ULONG cbIpNetTable = 0xFFFF;
if (NO_ERROR == GetIpNetTable (pIpNetTable, &cbIpNetTable, TRUE))
{
for (DWORD i = 0; i < pIpNetTable->dwNumEntries; i++)
{
if (pIpNetTable->table[i].dwAddr == _ip&&pIpNetTable->table[i].dwType != 2)
{
printf («IP:%s MAC:%X-%X-%X-%X-%X-%X\n», ip,
pIpNetTable->table[i].bPhysAddr[0],
pIpNetTable->table[i].bPhysAddr[1],
pIpNetTable->table[i].bPhysAddr[2],
pIpNetTable->table[i].bPhysAddr[3],
pIpNetTable->table[i].bPhysAddr[4],
pIpNetTable->table[i].bPhysAddr[5]);
delete[] pIpNetTable;
closesocket (udp_s);
WSACleanup ();
return 0;
}
}
printf («MAC-address not found\n»);
delete[] pIpNetTable;
}
else printf («ERROR Open IPMAC table\n»);
}
else printf («Send data ERROR!\n»);

closesocket (udp_s);
}
else printf («ERROR open socket\n»);

WSACleanup (); //Освобождаем ресурсы
return 0;
}

Мой блог находят по следующим фразам

• Все о программировании
• языки программирования скачать
• язык PHP
• языки программирования
• языки программирования скачать


IHTMLDocument2 *HTMLDocument = NULL;
IPersistFile *PersistFile = NULL;
LONG ilFramesCount = 0;
AnsiString slTmpFileExtension = ".html";
// Falls eine Seite geladen:
if(!Form1->CppWebBrowser1->Busy && Form1->CppWebBrowser1->Document &&
AnsiString(Form1->CppWebBrowser1->LocationURL) != "about:blank" &&
SUCCEEDED(Form1->CppWebBrowser1->Document->QueryInterface(IID_IHTMLDocument2, (LPVOID*)&HTMLDocument)))
{
// HTML-Code des Hauptdokuments speichern:
if(SUCCEEDED(HTMLDocument->QueryInterface(IID_IPersistFile,(LPVOID*)&PersistFile)))
{
// HTML-Code des Hauptdokuments speichern:
PersistFile->Save(WideString(String(ExtractFilePath(ParamStr(0))+"0"+slTmpFileExtension)), false);
PersistFile->Release();
// ggf. auch Frames-Code extrahieren:
IHTMLFramesCollection2 *pFrames = NULL;
if(SUCCEEDED(HTMLDocument->get_frames(&pFrames)))
{
// Anzahl der Frames bestimmen:
pFrames->get_length(&ilFramesCount);
if(ilFramesCount < 2) ilFramesCount= 0;
VARIANT vFrame;
VARIANT ret;
vFrame.vt = VT_UINT;
// f?r jedes Frame:
for(LONG ilFrameIndex = 0; ilFrameIndex < ilFramesCount; ilFrameIndex++)
{
vFrame.lVal = ilFrameIndex;
if(SUCCEEDED(pFrames->item(&vFrame, &ret)))
{
// Zeiger auf IHTMLWindow2 des Frames besorgen:
IHTMLWindow2 *pWindow = NULL;
if(SUCCEEDED(ret.pdispVal->QueryInterface(IID_IHTMLWindow2,
(LPVOID*)&pWindow)))
{
// Zeiger auf IHTMLDocument2 des Frames besorgen:
IHTMLDocument2 *pDoc = NULL;
if(SUCCEEDED(pWindow->get_document(&pDoc)))
{
// Frame in der Datei "Framenummer.html" speichern:
IPersistFile *PersistFile = NULL;
if(SUCCEEDED(pDoc->QueryInterface(IID_IPersistFile,
(LPVOID*)&PersistFile)))
{
PersistFile->Save(WideString(String(ExtractFilePath(ParamStr(0))+
IntToStr(ilFrameIndex+1) + slTmpFileExtension)), false);
PersistFile->Release();
}
pDoc->Release();
}
pWindow->Release();
}
}
}
pFrames->Release();
}
}
HTMLDocument->Release();
TStringList* pFileStrings = new TStringList;
if(pFileStrings)
{
// Die gepufferten Dateien mit dem HTML-Code der
// Seite in die RichEdit einlesen und die Dateien l?schen:
if(FileExists(ExtractFilePath(ParamStr(0))+"0"+slTmpFileExtension))
{
Form1->Memo1->Lines->LoadFromFile(ExtractFilePath(
ParamStr(0))+"0"+slTmpFileExtension);
DeleteFile(ExtractFilePath(ParamStr(0))+"0"+slTmpFileExtension);
}
if(ilFramesCount > 0)
{
for(LONG ilFrameIndex = 0; ilFrameIndex < ilFramesCount; ilFrameIndex++)
{
if(FileExists(ExtractFilePath(ParamStr(0))+IntToStr(
ilFrameIndex+1) + slTmpFileExtension))
{
pFileStrings->LoadFromFile(ExtractFilePath(ParamStr(0))+
IntToStr(ilFrameIndex+1) + slTmpFileExtension);
Form1->Memo1->Lines->Add("\n- - - Frame " +
IntToStr(ilFrameIndex+1) + " - - -");
Form1->Memo1->Lines->Add(pFileStrings->Text);
DeleteFile(ExtractFilePath(ParamStr(0))+IntToStr(
ilFrameIndex+1) + slTmpFileExtension);
}
}
}
delete pFileStrings;
}
}
else Form1->Memo1->Lines->Clear();


Проблема в следующем… Текст извлекаю из известного сайта vkontakte.ru. Предположим, захожу в поиск людей.. мне выводится несколько страниц, к примеру по 10 человек. Копирую текст для первых 10 — всё Ок. А вот если хочу скопировать текст для следущих 10 найденных, то копируется текст снова для первых 10 В код копирования страницы не вникал ибо не особо в этих приёмах разбираюсь, а если начну разбираться то уйдёт на это много времени…
Вопрос в следующем: можно как-нибудь подправить этот код или может, кто в работе с html страницами хоро�?о разбирается, предложит свой вариант для ре�?ения проблемы?

AnsiString GetAllTextFromWebPage(TCppWebBrowser *wb)
{
AnsiString s = wb->OleObject.OlePropertyGet("Document").OlePropertyGet("Body").OlePropertyGet("InnerText");
return s;
}
Сам на днях перерыл много инфы, ни чего толком не на�?ел, но при�?ел к такому изяществу, через COM-объект получае�?ь весь текст на странице
Если нужен HTML код странице, меняе�?ь только значение переменной, кажется так, пробуй:
AnsiString GetHTMLTextFromWebPage(TCppWebBrowser *wb)
{
AnsiString s = wb->OleObject.OlePropertyGet("Document").OlePropertyGet("Body").OlePropertyGet("InnerHtml");
return s;
}

Проблема в том, что в цикле браузер не успевает загрузить содержимое страницы и на этом этапе возникает о�?ибка доступа. Все ре�?иться если знать как дождаться определенного события = загрузки страницы, и только после этого запускать остальные фунциии цикла, стоит вопрос, как это сделать?

Проблема ре�?ается следущим образом, в теле цикла где происходит обработка страницы пи�?ем сразу после того как браузер получает адрес страницы CppWebBrowser->Navigate2(URL)

while (CppWebBrowser->ReadyState != 4)
{
Application->ProcessMessages();;
}

Похожая статья:
Особенности копирования текста страницы в CppWebBrowser на C++ Builder

Мой блог о программировании находят по следующим фразам

• Все о программировании
• языки программирования скачать
• язык PHP
• php программирование
• языки программирования скачать
• язык программирования assembler
• программирование на pascal

Я вместо button использовал компонент panel (это моя задумка — во время наведения курсора панелька будет подсвечена, как это реализовать я напи�?у в самом конце). Под навигацией у меня располагается Edit для ввода адреса, под ним компонент CppWebBrowser, так же нам понадобиться компонент OpenDialod — для просмотра страничек с жесткого диска. �?так, впервую очередь мы распи�?ем событие, совер�?аемое при нажатии enter в edit (с учетом того, что пользователь указал адрес сайта, событие называется — OnKeyPress). Вот код:

if (Key == VK_RETURN){ // нажат ЕНТЕР
wchar_t URL[100];
Edit1->Text.WideChar(URL,100); //Edit1 принял адрес сайта
CppWebBrowser->Navigate(URL,0,NULL,NULL,NULL); //Адрес направлен на cppwebbrowser, по�?ла загрузка
}

Далее напи�?ем код для кнопки открыть:

OpenDialog1->Execute(); //Открываем окно выбора файлов
wchar_t URL[100];
Edit1->Text=(OpenDialog1->FileName); //Присваемаем Edit название выбраного файла
Edit1->Text.WideChar(URL,100);
CppWebBrowser->Navigate(URL,0,NULL,NULL,NULL);

Кнопка назад:

CppWebBrowser->GoBack();

Кнопка вперед:

CppWebBrowser->GoForward();

Кнопка стоп:

[block]2[/block]->Stop();

Кнопка Обновить:

[block]3[/block]->Refresh();

Все готово =) Браузер будет спокойно бороздить просторы инета, под ва�?им чутким контролем. Теперь я распи�?у то, как менять цвет панелек при наведении. �?так, для начала обговорим, что стандартным цветом на�?их panel будет — clBtnFace. Теперь ставим на OnMouseMove, следующий код:

Panel1->Color=clSkyBlue; //я выбрал цвет - небесно синий

В результате чего, при наведии панель поменяет цвет, теперь заставим вернуть ее преждний цвет (если пользователь убрал мы�?ь). Сперва, мы должны выбрать событие OnMouseMove для Form1 и теперь пи�?ем код:

Panel1->Color=clBtnFace; //результат панель приняла стандартный цвет

Мой блог о программировании находят по следующим фразам

• Все о программировании
• языки программирования скачать
• язык PHP
• php программирование
• языки программирования скачать
• язык программирования assembler
• программирование на pascal

function CreateFile(IpFileName: PChar; dwDesiredAccess,

dwShareMode: DWORD; IpSecurityAttributes: PSecurityAttributes;

dwCreationDistribution, dwFlagsAndAttributes: DWORD;

hTemplateFile: THandle): THandle

Хоть ее название и начинается с create, но она позволяет не только создавать, но и открывать уже существующие файлы.

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

Функция createFile возвращает дескриптор открытого объекта ввода/вывода. Если открытие невозможно из-за о�?ибок, возвращается код INVALID_HANDLE_VALUE, а рас�?иренный код о�?ибки можно узнать, вызвав функцию GetLastError.

Закрывается файл в Win32 функцией closeHandie (не closeFile, a closeHandle! Правда, «легко» запомнить? Что поделать, так их назвали разработчики Win32).

Приведем из боль�?ого разнообразия несколько приемов использования функции CreateFile. Часто программисты хотят иметь возможность организовать посекторный доступ к физическим устройствам хранения — например к дискете. Сделать это не так уж сложно, но при этом методы для Windows 98 и Windows 2000 различаются. В Windows 2000 придется открывать устройство (‘\\.\A:’), а в Windows 98 — специальный драйвер доступа (обозначается ‘\\.\vwin32′). �? то и другое делается функцией createFile.

Чтение сектора с дискеты при помощи функции CreateFile

type

pDIOCRegs = ^TDIOCRegs;

TDIOCRegs = packed record

rEBX,rEDX,rECX,rEAX,rEDI, rESI, rFlags : DWORD;

end;

const VWIN32_DIOC_DOS_IOCTL = 1;

VWIN32_DIOC_DOS_INT13 = 4; //Прерывание 13

SectorSize = 512;

function ReadSector(Head, Track, Sector: Integer; buffer : pointer;

Floppy: char):Boolean;

var hDevice : THandle;

Regs : TDIOCRegs;

DevName : string; nb : Integer;

begin

if WIN32PLATFORM <> VER_PLATFORM_WIN32_NT then

begin {win95/98} hDevice := CreateFile(‘\\.\vwin32′, GENERIC_READ, 0, nil, 0,

FILE_FLAG_DELETE_ON_CLOSE, 0);

if (hDevice = INVALID_HANDLE_VALUE) then

begin

Result := FALSE;

Exit; end;

regs.rEDX := Head * $100 + Ord(Floppy in ['b', 'B']);

regs.rEAX := $201; // KOH onepam-iM read sector

regs.rEBX := DWORD(buffer); // buffer

regs.rECX := Track * $100 + Sector;

regs.rFlags := $0;

Result := DeviceloControl(hDevice,VWIN32_DIOC_DOS_INT13,

@regs, sizeof(regs), @regs, sizeof(regs), nb, nil)

and ((regs.rFlags and $1)=0); CloseHandle(hDevice);

end {win95/98}

else

begin // Windows NT/2000

DevName :=’\\.\A:’;

if Floppy in ['b', 'B'] then DevName[5] := Floppy;

hDevice := CreateFile(pChar(Devname), GENERIC_READ, FILE_SHARE_READ

or FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

if (hDevice = INVALID_HANDLE_VALUE) then

begin

Result := FALSE;

Exit;

end;

SetFilePointer(hDevice, (Sector-1)*SectorSize, nil, FILE_BEGIN); // нумерация с 1

Result := ReadFile(hDevice, buffer’;, SectorSize, nb, nil) and (nb=SectorSize);

CloseHandle(hDevice);

end; // Windows NT/2000

end;

Для чтения и записи данных в Win32 используются функции:

function ReadFile(hFile: THandle; var Buffer; nNumberOfBytesToRead: DWORD; var IpNumberOfBytesRead: DWORD; IpOverlapped: POverlapped): BOOL; function WriteFile(hFile: THandle; const Buffer; nNumberOfBytesToWrite: DWORD; var IpNumberOfBytesWritten: DWORD; IpOverlapped: POverlapped): BOOL;

Здесь все сходно с BlockRead и Blockwrite: hFile — это дескриптор файла, Buffer — адрес, по которому будут читаться (писаться) данные; третий параметр означает требуемое число читаемых (записываемых) байтов, а четвертый — фактически прочитанное (записанное). Последний параметр — IpOverlapped — обсудим чуть позже.

Функция createFile используется и для доступа к портам ввода/вывода. Часто программисты сталкиваются с задачей: как организовать обмен данными с различными нестандартными устройствами, подключенными к параллельному или последовательному порту? В Turbo Pascal для DOS был очень хоро�?ий псевдомассив Ports: пи�?е�?ь Port[x] := у; и не знае�?ь проблем. В Win32 прямой доступ к портам запрещен и приходится открывать их как файлы:

…

hCom := CreateFile(‘COM2′, GENERIC_READ or GENERIC_WRITE,

0, NIL, OPEN_EXISTING, FILE_FLAG__OVERLAPPED, 0) ;

if hCom = INVALID_HANDLE_VALUE then

begin

raise EAbort.CreateFmt(‘О�?ибка открытия порта: %d*,[GetLastError]);

end;

Самое боль�?ое отличие от предыдущего примера — в скромном флаге FILE_FLAG_OVERLAPPED.


int col[8], up_free[15], dn_free[15], coln[8] ;

main( )
{
int i ;

for ( i = 0 ; i <= 7 ; i++ )
col[i] = 1 ;
for ( i = 0 ; i <= 14 ; i++ )
up_free[i] = dn_free[i] = 1 ;
clrscr( ) ;
addqueen( ) ;
}

addqueen( )
{
int i, c, r ;
static int comb, row = -1 ;

row++ ;

/* Проверяем колонки */
for ( i = 0 ; i <= 7 ; i++ ) { /* если клетка не находится под ударом */ if ( col[i] && up_free[i+row] && dn_free[row-i+7]) { /* запоминаем, что в строке находится ферзь */ coln[row] = i ; /* маркируем колонку и диагональ */ col[i] = 0 ; up_free[i+row] = 0 ; dn_free[row-i+7] = 0 ; /* если заполнены все строки */ if ( row >= 7 )
{
comb++ ;
printf ( «\n\n\ncombination no. %d», comb ) ;
for ( r = 0 ; r <= 7 ; r++ )
{
printf ( «\n» ) ;
for ( c = 0 ; c <= 7 ; c++ )
{
if ( c == coln[r] )
printf ( » Q » ) ;
else
printf ( » . » ) ;
}
}
}
else
addqueen( ) ;

/* снимаем пометку с колонки и диагонали */
col[ coln[row] ] = 1 ;
up_free[ row + coln[row] ] = 1 ;
dn_free[ row - coln[ row ] + 7 ] = 1 ;
}
}
row— ; /* умень�?аем счетчик строк, пробуем следующую комбинацию */
}

Мой блог о программировании находят по следующим фразам

• Все о программировании
• языки программирования скачать
• язык PHP
• php программирование
• программирование C++
• языки программирования скачать
• язык программирования assembler
• программирование на pascal

Мой блог о программировании находят по следующим фразам

• Все о программировании
• языки программирования скачать
• язык PHP
• php программирование
• программирование C++
• языки программирования скачать
• язык программирования assembler
• программирование на pascal