Программирование на Visual C++

Выпуск №44 от 13 мая 2001 г.

Добрый день!

ОБРАТНАЯ СВЯЗЬ

В статье "Свойства в C++" в №43 был приведен пример "свойства", который не мог оставить меня равнодушным, как программиста, использующего язык C++ не один год.

Приведенный в статье пример, является забавной комбинацией COM и непреодолимым желанием автора сделать "как в бейсике". Кстати COM, берет начало с OLE и ActiveX, который создавался так, чтобы программистам на VB было как можно проще его использовать. А что хорошо для VB-программистов, то одна головная боль для программистов на C++. Отсюда и возникли добавляемые автоматически префиксы get_ и put_. Первый вариант класса CValue (с использованием declspec) верен, и его, с небольшими изменениями, можно использовать в качестве COM интерфейса. Но для внутреннего использования (т.е. для использования только в C++) он и все последующие мало пригодны (минусы уже были перечислены).

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

Я не буду против опубликовании вами этой статьи.

(С уважением, Илья Жарков. )
СТАТЬЯ  Эффективное использование C++ Создание классов-оберток для стандартных типов данных
(Автор: Илья Жарков)

Большое распространение технологии COM и повальное увлечение всех начинающих программистов языками программирования высокого уровня (я имею ввиду Visual Basic & Delphi), приводит к тому, что в массовом сознании закрепляется твердое убеждение, что те средства, которые используются в данных технологиях и языках, является единственно верными и правильными. А что происходит, когда программист "взрослеет"? Он, в погоне за новыми возможностями, устремляется к другим языкам, например к C++. Но тут оказывается, что в этом языке нет привычных ему средств или их реализация не лежит на поверхности. Как всегда в программировании нет времени на детальное изучение возможностей языка (печально, если оно так и не появляется) – программу надо сдать завтра в 8 утра и не часом позже. Вот так и начинается повторное изобретение велосипеда. 

Данная статья, я надеюсь, будет полезна программистам, начинающим изучать язык программирования C++, а также тем, кто хочет научиться использовать его возможности наиболее эффективным образом. Тут вы сможете прочитать о создании специальных классов, упрощающих использование стандартных типов данных и называемых "классами-обертками". Такие "классы-обертки" работают подобно нетипизированным переменным языка Visual Basic – производят нужные преобразования из одного типа в другой, а также хранят в себе несколько переменных разного типа. 

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

struct Value {

 int nVal;

 char *str;

};

А использовалось следующим образом: 

void init(Value* val) {

 val.nVal=10;

 val.str=(char*)malloc(50);

}
 

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

class CValue {

 int nVal;

 char* str;

public:

 CValue() { nVal=0; str=NULL; }

 ~CValue() { delete[] str; }

 CValue& Val(int val) { nVal=val; return *this; }

 CValue& Str(const char* string) {

  delete[] str;

  str=new char[strlen(string)+1];

  strcpy(str, string);

  return *this;

 }

 int Val() const { return nVal; }

 char* Str() const { return str; }

};
 

Вы спросите, что нам дает такое, казалось бы, громоздкое повторение предыдущей маленькой структуры. В первую очередь, контроль за значениями, хранящимися в переменных. Мы можем, например, ограничить диапазон переменной nVal значениями от 3 до 11, включив соответствующую проверку в функцию CValue& Val(int val). Благодаря спецификаторам доступа public и private (используемый неявно в начале класса) исключается несанкционированный доступ к переменным класса. Но не менее важно и то, что их значения не примут случайное значение (благодаря конструктору) и не произойдет утечки памяти (благодаря деструктору). Кроме этого очень сильно упрощается использование такой структуры. 

CValue value;

// так происходит инициализация

value.Val(10).Str("string");

// так значения используются

int n=value.Val();

char *str=value.Str();
 

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

Теперь воспользуемся таким средством C++ как перегрузка операторов и добавим в наш класс следующие функции: 

class CValue {

 ...

public:

 CValue& operator=(int val) { return Val(val); }

 CValue& operator=(const char* string) { return Str(string); }

 operator int() const { return nVal; }

 operator char*() const { return str; }

};

Это дало нам еще один способ использования объектов этого типа:

CValue value;

// инициализация

value=20;

// происходит вызов перегруженной

// функции CValue::operator=(int val)

value="string";

// происходит вызов перегруженной

// функции CValue::operator=(char* string)


// вот так теперь можно получить значения

// соответствующих переменных класса

int n=value; // неявное преобразование value к типу int

// n будет равно value.nVal

char *str=value; // неявное преобразование value к типу char*

// str будет равно value.str
 

Неправда ли это становится очень похоже на Бейсик? В конце приведу еще один пример типа, который можно использовать способом, аналогичным при использовании переменных в VB. Как известно, VB "равнодушен" к типу переменных – переменной можно присвоить и 5 и "25". В одном случае произойдет неявное преобразование из строки в число, в другом наоборот. То есть, я хочу сказать, что VB является языком со слабым контролем типов в отличие от C++, обладающим строгим контролем типов. Если кто-то скажет, что это – недостаток, то я его адресую к [1]. Примером, как можно "обойти" этот "недостаток", может служить этот шаблонный класс: 

template<class T> class CVBValue {

 T m_val;

public:

 CVBValue() {};

 CVBValue(T val) { m_val=val; }

 T Val() const { return m_val; }

 CVBValue& operator=(T val) { m_val=val; return *this; }

 CVBValue& operator=(char* str) {

  // тут происходит преобразование из char* в тип T

  // если, конечно, известно как это сделать

  return *this;

 }

 operator T() const { return m_val; }

};
 

Использование этого класса происходит уже известным вам способом: 

CVBValue<double> val; // создание экземпляра класса

val=2.5;

val="1.2345"; // преобразование из строки в тип double double

d=val; // получение текущего значения
 

Дальнейшее расширение класса зависит только от вашего воображения. Хочется вас предостеречь от излишнего упрощения использования типов. Программисты на VB могут ужаснуться, когда узнают, сколько может быть скрыто строчек кода за невинным, на первый взгляд, присваиванием. Но вы теперь это прекрасно осознаете и понимаете, что, чем более сложный код, вы напишете, тем больше вероятность появления ошибок. В данном случае, я имею в виду ошибки, появление которых можно обнаружить только во время исполнения программы. Что произойдет в описанном выше примере, если написать val="string"? В лучшем случае ничего, но вообще-то может возникнуть исключение (возможно в случае нехватки памяти). Это вынуждает нас помещать обычное приравнивание в блок 

try {

 val="1.95";

} catch (...) { }
 

Но так ли часто вы это делаете в своих программах? Наглядность программы тоже страдает: переменной, которая, как кажется, хранит число, вы приравниваете строку. Как я уже говорил, для Бейсика это может быть естественно, а для C++ –противоестественно. Отсюда вывод: помещайте потенциально опасный код в функции, а перегрузку операторов реализуйте как можно проще. 

Литература

1. Страуструп Б. Язык программирования C++. М.: "Невский Диалект" – "Издательство БИНОМ", 1999.

2. Страуструп Б. Дизайн и эволюция языка C++. М.: ДМК Пресс, 2000.

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

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

Потерю производительности можно уменьшить, если блоки проверки корректности параметров для присваивающих функций заключить между директивами условной компиляции #ifdef _DEBUG / #endif. Тогда они будут работать только в отладочной версии программы, позволяя выявить допущенные где-то в другом месте ошибки, а в окончательную сборку проекта не войдут. 

ВОПРОС-ОТВЕТ  Как задать минимальный и максимальный размер окна?
(Автор: Александр Шаргин)

Когда пользователь изменяет размеры окна, Windows сама запрашивает у программы минимальный и максимальный размеры, посылая окну сообщение WM_GETMINMAXINFO. При этом впараметре lParam размещается указатель на структуру MINMAXINFO, в которую и следует записать нужные значения. Затем нужно вернуть 0. Рассмотрим пример обработки сообщения WM_GETMINMAXINFO, при котором размер окна не может быть сделан меньше (100×100) и больше (300×300).

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {

 switch (message) {

  …

 case WM_GETMINMAXINFO:

  {

   MINMAXINFO *pInfo = (MINMAXINFO *)lParam;

   POINT ptMin = { 100, 100 }, ptMax = { 300, 300 };

   pInfo->ptMinTrackSize = ptMin;

   pInfo->ptMaxTrackSize = ptMax;

   return 0;

  }

 default:

  return DefWindowProc(hWnd, message, wParam, lParam);

 }

}

В MFC обработчик выглядит аналогичным образом, например:

void CMainFrame::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI) {

 lpMMI->ptMinTrackSize = CPoint(100, 100);

 lpMMI->ptMaxTrackSize = CPoint(300, 300);

 CFrameWnd::OnGetMinMaxInfo(lpMMI);

}

ПРИМЕЧАНИЕ

Для добавления этого обработчика можно использовать ClassWizard. Если оно не появляется в списке Messages, перейдите на вкладку Class Info и установите Message filter: Window. 

Это все на сегодня. Пока!

(Алекс Jenter jenter@rsdn.ru) (Красноярск, 2001. Рассылка является частью проекта RSDN.)





 

Главная | В избранное | Наш E-MAIL | Прислать материал | Нашёл ошибку | Наверх