6.Откройте файл CExampleView.cpp и добавьте в него приведенную ниже строку, поместив сразу после строки #include "afxmt.h":

#include "CountArray.h"

7.Добавьте приведенную ниже строку в начало этого же файла, сразу после строки volatile bool keeprunning;

CCountArray сountArray;

8.Добавьте в файл ExampleView.cpp перед функцией void CExampleView:: OnCriticalsection() функции:

UINT WriteThreadProc(LPVOID param)

{ for(int x=0; x<10; ++x)

{ countArray.SetArray(x);

Sleep(1000);

} return 0; }

UINT ReadThreadProc(LPVOID param)

{ int array[10];

for (int x=0; x<20; ++x)

{ countArray.GetArray(array);

char str[50];

str[0] = 0;

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

{int len = strlen(str);

sprintf(&str[len], "%d ", array[i]); }

AfxMessageBox(str);}

return 0; }

Откомпилируйте новую версию приложения Example и запустите ее на выполнение. На экране раскроется главное окно приложения. Для запуска процесса выберите команду Thread->Critical section. Первым появится окно сообщений, отображающее текущие значения элементов защищенного массива. Каждый раз при закрытии оно будет появляться вновь, отображая обновленное содержимое массива. Всего вывод окна будет повторяться 20 раз. Значения, отображаемые в окне сообщений, будут зависеть от того, насколько быстро вы будете закрывать это окно сообщений. Первый поток записывает новые значения в массив ежесекундно, причем даже тогда, когда вы просматриваете содержимое массива с помощью второго потока.

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

Если вы внимательно проанализируете исходный текст программы, то увидите, что первый поток с именем WriteThreadProc() вызывает функцию-член SetArray() класса CCountArray десять раз за один цикл for. В каждом цикле функция SetArray() захватывает объект критической секции, заменяет содержимое массива переданным ей числом, и вновь освобождает объект критической секции.

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

Если вы хотите убедиться в том, что объект критической секции работает именно так, как описано выше, удалите строку criticalSection.Unlock(), расположенную в конце метода SetArray() класса CCountArray. Затем откомпилируйте и выполните программу. На этот раз после запуска потоков вы не увидите никаких сообщений. Поток WriteThreadProc() захватывает объект критической секции и не освобождает его, что заставляет систему остановить работу потока ReadThreadProc() раз и навсегда (или, по крайней мере, до окончания работы программы).

51.Потоки Visual C++. Работа с семафором

Работа с семафорами

Рассмотрим, как обеспечить синхронизацию потоков на основе семафоров.

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

CSemaphore(LONG lInitialCount=1,LONG lMaxCount=1,

LPCTSTR pstrName=NULL,

LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);

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

Третий параметр конструктора указывает на строку, содержащую имя объекта семафора. Поименованные семафоры становятся системными объектами и могут использоваться другими процессами. Когда два процесса вызывают семафоры с одинаковыми именами, обоим процессам будет предоставлен один и тот же семафор - это позволяет синхронизировать процессы. Вместо имени строки можно указать NULL - в этом случае семафор будет локализован внутри одного процесса. Последний параметр конструктора является указателем на набор атрибутов прав доступа, связанный с семафором. Если этот параметр равен NULL, то семафор наследует данный набор у вызвавшего его потока.

52.Потоки Visual C++. Работа с объектом события

Работа с объектами события

Объект события используется для оповещения процесса или потока о том, что произошло некоторое событие. Для работы с такими объектами предназначен класс CEvent. Конструктор класса имеет следующий прототип:

CEvent( BOOL bInitiallyOwn = FALSE, BOOL bManualReset =

FALSE, LPCTSTR lpszName = NULL,

LPSECURITY_ATTRIBUTES lpsaAttribute = NULL );

Значение первого параметра определяет начальное состояние объекта.

Если оно равно TRUE, то объект события установлен (событие произошло), а если FALSE, то объект не установлен или сброшен (событие не произошло).

Второй параметр указывает, каким образом состояние объекта будет изменяться при выполнении события. Если значение параметра равно TRUE (не ноль), то объект может быть сброшен только путем вызова метода ResetEvent класса CEvent. В противном случае объект автоматически сбрасывается после предоставления блокированному потоку доступа к ресурсу.

Третий параметр конструктора указывает на строку, содержащую имя объекта события. Поименованные объекты события становятся системными объектами и могут использоваться другими процессами. Вместо имени строки можно указать NULL - в этом случае объект события будет локализован внутри одного процесса.

Последний параметр конструктора является указателем на набор атрибутов прав доступа, связанный с объектом события. Если этот параметр равен NULL, то объект события наследует данный набор у вызвавшего его потока.

Когда объект события создан, то поток, ожидающий данное событие, должен создать объект класса CSingleLock, для которого затем следует вызвать метод Lock. При этом выполнение данного потока останавливается до тех пор, пока не произойдет ожидаемое событие. Для сигнализации о том, что событие произошло, предназначена функция SetEvent класса CEvent. Она переводит объект события в состояние «сигнализирует». При этом поток, ожидающий событие, выйдет из остановленного состояния (вызванный им метод Lock завершится) и выполнение потока продолжится.

Чтобы продемонстрировать работу с объектами события, дополним наше приложение следующими функциями. Создадим два пункта меню: «Start Thread 2» и «End Thread 2». По пункту «Start Thread 2» должен запускаться процесс MyThread2, по пункту «End Thread 2» должен заканчиваться процесс MyThread2 с выдачей сообщения "MyThread2 ended". Если запуск процесса легко осуществить с помощью объекта события, то завершение процесса легче реализовать с помощью глобальной переменной.

Всем потокам процесса доступны все глобальные переменные процесса.

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

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

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

53.Программирование сетевых приложений в Visual C++. Технология Windows Socket для взаимодействия приложений. Сокеты, порты, адреса

Основным объектом, используемым в большинстве приложений для работы с сетью, является сокет. Сокеты были впервые использованы в системах UNIX в Калифорнийском университете в Беркли. Сокеты были изобретены для того, чтобы большинство сетевых соединений между разными приложениями могли быть осуществлены единообразно, так, чтобы эти приложения могли работать с сокетами таким же образом, как эти приложения осуществляют чтение и запись файлов. С тех времен сокеты претерпели значительные изменения, однако основа, которую они использовали, осталась той же.

Во времена Windows 3.x, пока сетевые возможности не были встроены в операционную систему, пользователь имел возможность приобрести различные сетевые протоколы от множества различных компаний. Каждая такая компания использовала протокол, который отличался, хотя бы немного, от протокола, использовавшегося другой компанией. В результате для каждого приложения требовалось иметь целый список различных сетевых приложений, с которыми это приложение могло работать. Многие разработчики приложений испытывали неудобства в связи с такой ситуацией. В результате, основные компании, работающие с сетевыми технологиями, включая компанию Microsoft, собрались вместе и разработали стандарт Winsock (аббревиатура для Widows Socket) API. В результате появился стандартный интерфейс, позволяющий разработчикам приложений возможность работать с сетью вне зависимости от конкретных используемых приложений.

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

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

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

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

54.Модель клиент-сервер

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

Связь клиент-сервер

При щелчке пользователя на гиперссылке в Web-броузере клиент определяет URL активизируемого соединения.

URL содержит информацию для клиента об адресе сервера, на котором должен находиться документ. Затем клиент обращается к серверу и организует с ним TCP/IP-соединение.

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

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

Клиент получает данные и обрабатывает их.

Роль компьютера (сервер или клиент) определяется установленным на нем программным обеспечением. Для выполнения компьютером роли сервера необходимо:

подключить компьютер к сети Интернет (для компьютера, к которому выполняется мало обращений, достаточно быстродействующего модема);

задать IP-адрес, с помощью которого клиенты смогут обращаться к серверу;

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

Для выполнения компьютером роли клиента необходимо:

подключить компьютер к сети Интернет;

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

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

Приложения могут использовать множество сетевых возможностей, и все эти возможности используют свойства интерфейса Winsock. Спецификацией Windows Sockets определяется интерфейс динамически загружаемой библиотеки, файл который, как правило, называется WINSOCK.DLL или WSOCK32.DLL. Функции этой библиотеки реализуются разработчиками. Приложения могут вызывать эти функции и быть уверенными, что имя, смысл аргументов и поведение каждой функции не зависят от конкретной версии установленной библиотеки.

Поначалу программирование Winsock на Visual C++ сводилось к вызову библиотечных функций API. Многие производители разработали классы, в которых инкапсулированы вызовы этих функций.

55.Создание сетевого приложения. Методы класса CAsyncSocket

Создание сетевого приложения

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

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

Класс CAsyncSocket

Класс CAsyncSocket инкапсулирует асинхронные вызовы Winsock. Он содержит набор полезных функций, использующих Winsock API.

Таблица 4.1. Методы класса CAsyncSocket

Метод	Назначение
Accept	Обрабатывает запрос на соединение, который поступает на принимающий сокет, заполняя его информацией об адресе.
AsyncSelect	Организует посылку сообщения Windows при переходе сокета в состояние готовности
Attach	Связывает дескриптор сокета с экземпляром класса CAsyncSocket, чтобы иметь возможность сформировать соединение с др. компьютером.
Bind	Ассоциирует адрес с сокетом.
Close	Закрывает сокет.
Connect	Подключает сокет к удаленному адресу и порту.
Create	Завершает процесс инициализации, начатый конструктором.
GetLastError	Возвращает код ошибки сокета.
GetPeerName	Определяет адрес IP и номер порта удаленного компьютера.
GetSockName	Возвращает адрес IP и номер порта объекта this.
Listen	Заставляет сокет следить за запросами на соединение.
OnAccept	Обрабатывает сообщение Windows, которое формируется при приеме гнездом запроса на соединение. Часто переопределяется в производных классах.
OnClose	Обрабатывает сообщение Windows, которое формируется при закрытии сокета. Часто переопределяется в производных классах.
OnConnect	Обрабатывает сообщение Windows, которое формируется после установки соединения или после неудачной попытки соединиться.
OnReceive	Обрабатывает сообщение Windows, которое формируется при появлении данных, которые можно прочесть с помощью Receive().
OnSend	Обрабатывает сообщение Windows, которое формируется при готовности гнезда принять данные, посылаемые с помощью Send().
Receive	Считывает данные с удаленного компьютера, к которому подключен сокет.
Send	Посылает данные удаленному компьютеру
SetSockOpt	Устанавливает параметры сокета
ShutDown	Оставляет сокет открытым, но предотвращает дальнейшие вызовы Send() или Receive().

56.Создание сетевого приложения. Функции обработки событий для класса сокета

Функции класса CAsyncSocket Class

Чтобы иметь возможность перехватывать и отвечать на события сокета, нам нужно создать свой собственный класс на основе класса CAsyncSocket. В этом классе будет содержаться его собственная версия функций для обработки событий, а также средства отражения событий на уровне класса диалогового окна, здесь будет использоваться указатель на диалоговое окно родительского класса нашего класса сокета. Этот указатель будет использоваться для осуществления вызова функций каждого события сокета, предварительно осуществим проверку наличия ошибок. Чтобы создать этот класс, выберем в меню Insert | New Class. В диалоговом меню создания нового класса New Class оставим тип класса таким, какой предлагается по умолчанию (MFC), введем имя класса, например, CMySocket, и укажем в качестве базового класса CAsyncSocket в списке доступных базовых классов. Нажимаем кнопку ОК, новый класс вставлен.

После того, как новый класс сокета создан, вставим переменную в класс, который будет использоваться в качестве указателя на родительское диалоговое окно. Указываем тип переменной CDialog*, имя переменной m_pWnd, доступ private. В классе необходимо определить метод, а значит, вставим новую функцию в этот класс. Тип функции void, объявим функцию в виде SetParent(CDialog* pWnd), доступ public. Редактируем созданную функцию.

void CMySocket::SetParent(CDialog *pWnd)

{

//устанавливаем указатель

m_pWnd = pWnd;

}

В классе сокета создаем функции обработки событий. Для создания функции, соответствующей событию OnAccept, вставим новую функцию в класс сокета, тип функции void, опишем функцию в виде OnAccept(int nErrorCode), доступ protected. Редактируем код.

void CMySocket::OnAccept(int nErrorCode)

{

//Есть ошибки?

if (nError == 0)

//Нет, вызываем функцию OnAccept()

((CSockDlg*)m_pWnd)->OnAccept();

}

Вставляем подобные функции для событий OnConnect, OnClose, OnReceive и OnSend. после того, как функции вставлены,нужно вставить заголовочный файл в диалоговое окно нашего приложения в класс сокета.

//MySocket.cpp

//

…

#include "MySocket.h"

После того, как требуемые функции событий созданы в классе сокета, вставим переменную,связанную с нашим классом сокета в класс диалогового окна. Для сервера нам потребуется две переменные, одна будет связана с прослушиванием запросов на соединение, а другая - связана с другим приложением. Поскольку у нас существует два объекта сокета, то в диалоговый класс (CSockDlg) вводим две переменные. Обе переменные имеют тип класс сокета (CMySocket) и доступ private. Имя одной переменной m_sListenSocket, эта переменная связана с прослушиванием запроса на соединение, вторая переменная называется, m_sConnectSocket и используется для пересылки сообщения в том и в другом направлении.

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

Замечание: Имя, соответствующее loopback,-это специальное имя, используемое в протоколе TCP/IP, которое обозначает компьютер, на котором мы работаем. Это внутреннее имя компьютера, превращаемое в адрес 127.0.0.1. Это имя и адрес компьютера, широко используемое в тех случаях, когда требуется осуществить соединение с другим приложением, установленным на том же самом компьютере, на котором мы и работаем.

BOOL CSockDlg::OnInitDialog()

{

CDialog::OnInitDialog();

//…

SetIcon(m_hIcon, FALSE);

//Инициализируем переменные управления

m_iType = 0;

m_strName = "loopback";

m_iPort = 4000;

//обновляем элементы управления

UpDateData(FALSE);

//Устанавливаем указатель

m_sConnectSocket.SetParent(this);

m_sListenSocket.SetParent(this);

retutn TRUE; //}

57.Посылка и прием сообщения приложением

Посылаем сообщение и получаем.

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

void CSockDlg::OnBsend()

{

int iLen;

int iSent;

//Обновляем элементы управления в соответствии с переменными

UpdateData(TRUE);

//Есть сообщение для посылки?

if (m_strMessage !="")

{

//Получаем длину сообщения

iLen = m_strMessage.GetLength();

//Посылаем сообщение

iSent=

m_sConnectSocket.Send(LPCTSTR(m_strMessage), iLen};

//Смогли послать?

if (iSent == SOCKET_ERROR)

{

}

else

{

// Добавляем сообщение в список

m_ctlSent.AddString(m_strMessage);

// Обновляем переменные согласно элементам управления

UpdateData(FALSE);

}}}

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

void CSockDlg::OnReceive()

{

char *pBuf = new char[1025];

int iBufSize = 1024;

int iRcvd;

CString strRecvd;

//Получаем сообщение

iRcvd = m_sConnectSocket.Receive(pBuf, iBufSize);

//Получили что-либо?

if (iRcvd == SOCKET_ERROR)

{

}

else

{

//Отрезаем конец сообщения

pBuf[iRcvd] = NULL;

//Копируем сообщение в CString

strRecvd = pBuf;

//добавляем сообщение в список полученных сообщений

m_ctlRecvd.AddString(strRecvd);

// обновляем переменные в соответствии с элементами управления

UpdateData(FALSE);

}

}

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

58.Отладка программ в VS. Точка останова. Установка точек останова. Команды и окна отладки

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

Терминология отладки

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

Go - выполнять до следующей точки останова или до конца программы, если далее не встретятся точки останова.

Restart - возобновить выполнение прог-мы с самого начала.

Step Over - выполнить только след-й оператор и снова остан-ся. Если оператор с точкой останова оказался вызовом функции, выполнить ее полностью и остановиться после возврата из нее.

Step into - выполнить только следующий оператор, но если он окажется вызовом функции, войти в нее и остановиться на первом же операторе внутри функции.

Step Out - выполнить всю оставшуюся часть ф-ции и остан-ся на первом же операторе ф-ции, кот-я вызвала данную функцию.

Run To Cursor - продолжить выполнение программы и остановиться на операторе, на котором находится курсор.

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

Команды меню

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

Edit->Breakpoints

View->DebugWidows ->Watch

View->DebugWidows ->Call Stack

View->DebugWidows ->Memory

View->DebugWidows ->Variables

View->DebugWidows ->Registers

View->DebugWidows ->Dissassembly

Build->Start Debug->Go

Build->Start Debug->Step Into

Build->Start Debug->Run To Cursor

Build->Start Debug->Attach to Process

Build->Debugger Remote Connection

Как только вы приступили к отладке, вместо меню Build появляется меню Debug, включающее следующие пункты.

1.Debug->Go

2.Debug->Restart

3.Debug->Stop

4.Debug->Break

5.Debug->Step Into

6.Debug->Step Over

7.Debug->Step Out

8.Debug->Run To Cursor

9. Debug->Step Into Specific Function

10.Debugging Debug->Exceptions

11. Debug->Threads

12.Debug->Show Next Statement

13.Debug->Quick Watch

В меню Debug дублируются некоторые из пунктов каскадных меню Build->Start Debug. Рассмотрим отдельные команды меню.

Установка точек останова

Проще всего установить точку останова, поместив курсор на оператор программы, перед выполнением которого вы желаете остановиться. Точка останова устанавливается с помощью клавиши <F9> или пиктограммы Insert/Remove breakpoint панели инструментов Build, которая имеет вид поднятой руки. Красная точка слева от оператора отметит точку останова.

При выборе пункта меню Edit->Breakpoints на экран выводится диалоговое окно для установки простых или условных точек останова. Например, можно остановиться там, где изменяется некоторое значение переменной. Можно также установить условные точки останова, такие как прервать выполнение программы, когда i достигает 100 и не щелкать на Go 100 раз.

Другие окна для отладки

Memory, Registers, Disassembly - эти окна обеспечивают отладку деталей программы, редко встречающихся в обычной процедуре отладки. С появлением каждой новой версии Visual С++ обст-ва, при кот-х эти окна необх-мы, встреч-ся все реже.

Окно Memory

В окне Memory содержатся шестнадцатеричные значения в каждом байте памяти от Ох00000000 до ОхFFFFFFFF. Просматривать содержимое памяти с его пом-ю утомительно. Для ввода интересующего вас адреса проще исп-ать окно Address. Обычно эти адреса копируются через буфер из окна Variables.

Окно Registers

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

Окно Disassembly

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

Применение утилиты MFC Tracer

Утилита МЕС Тгасег является автономным приложением с пунктом меню, интегрированным в VS. Для ее выполнения выберите команду Tools->MFC Tracer. Откроется диал.окно Tracer.

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

Метод Dump() существует во всех классах MFC. Если в программе что-то неправильно, код с дескриптором ошибки вызывает эту функцию, чтобы показать содержимое объекта.

59.Отладка программ в VS. Анализ значений переменных. Окно CallStact

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

Dlg.m_color=color; Dlg.m_horizcenter= horizcenter;

Поместите указатель мыши на идентификатор переменной типа соlог или horizcenter. Появится окно Data Tip, в котором выведено текущее значение этой переменной. Можно просмотреть значения локальных переменных, затем продолжить выполнение программы и проверить их снова. Но существуют и другие способы доступа к значениям переменных.

Можно щелкнуть мышью на переменной и выбрать пункт Debug->Quick Watch или щелкнуть на пиктограмме Quick Watch (на ней изображены очки). Это приведет к выводу на экран окна, которое покажет вам значение переменной или выражения и позволит при желании добавить отслеживание этой переменной в окно Watch, которое предоставляет большие возможности, чем окно Data Tip.

В окне Variables содержится много дополнительной информации, которая иногда затрудняет его использование. Если переменная указывает на объект, ее данные представлены в форме дерева: щелкнув на значке +, можно развернуть ветвь дерева, а после щелчка на значке - ветвь сворачивается.

Вверху окна Variables имеется раскрывающийся список Context. Если его раскрыть, то виден будет список имен ряда функций. Верхний элемент - это функция, в которой должен выполняться оператор. Второй элемент - это функция, которая ее вызвала. Дважды щелкнув на любом имени функции в списке, можно отобразить текст функции. При этом можно просмотреть переменные, локальные для функции, и другую информацию.

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

Размещено на Allbest.ru

...