1. Разработка консольного приложения
2. Использование встроенного отладчика
3. Пример создания Windows-приложения

- Создание проекта при помощи шаблона Windows Forms Application
- Проектировие интерфейса приложения
- Разработка кода приложения

4. Литература

     Для создания приложения необходимо выбрать пункт меню File
     и далее New Project
    Переход к следующему шагу осуществляется с помощью перевода курсора мыши в прямоугольную область рисунка, помеченную красной рамкой,  и нажатием левой клавиши мыши

    В открывшемся диалоговом окне в левой панели, содержащей дерево типов проектов, раскрыть узел Visual C++ и выделить элемент Win32. Затем в правой панели выбрать шаблон проекта Win32 Console Application, далее ввести название проекта. При создании нового проекта в поле Location необходимо указать имя каталога, в котором следует сохранить его файлы. При этом в данном каталоге автоматически будет создан другой каталог, имя которого совпадает с именем проекта. По умолчанию проекты сохраняются в папке С:\Documents and Settings\Владелец\Мои документы\Visual Studio Projects\Имя проекта.

    После выполнения всех действий нажать кнопку OK.

    В окне мастера создания шаблона проекта необходимо  нажать кнопку Finish

    Программа может состоять из нескольких модулей и файлов различных типов. Совокупность всех файлов и модулей программы образует проект (project).
    Приложение в Visual Studio .NET может состоять из нескольких проектов, совокупность которых называется термином решение (Solution).
    Для работы с решением в среде Visual Studio .NET используется окно проводника решения (Solution Explorer). Окно Solution Explorer можно отобразить на экране с помощью команды меню View | Solution Explorer. Окно Solution Explorer содержит древовидное представление элементов проектов, которые можно открывать по отдельности для модификации или выполнения задач по управлению. В дереве отображаются логические отношения решения и проектов, а также элементов решения. Если нужно отредактировать компонент проекта, следует дважды щелкнуть по его имени в окне Solution Explorer.
    Мастер создал простое решение, состоящее из одного проекта с именем решения. Проект консольного приложения содержит три основных файла: файл с расширением срр, название которого совпадает с именем проекта, и два системных фала stdafx.cpp и stdafx.h.
    В редакторе кода открываем файл с расширением срр.

    В файле автоматически генерируется заголовок функции main  и пустое тело функции. Заголовок функции несколько отличается от классического вида. Это связано с использованием строкового типа _TCHAR*, позволяющего работать не только с однобайтовыми символами, но и с двухбайтовыми символами в кодировке UNICOD, содержащей литеры всех национальных алфавитов.
    Для создания первой программы, выводящий на экран слова “Здравствуй, мир”, внутри фигурных скобок до оператора выхода из функции return набираем строку : cout<<”Hello, world”.
    Запуск программы на компиляцию и выполнение можно осуществить двумя способами: Start Debugging и  Start Without Debugging. В первом из них после выполнения программы окно вывода автоматически закрывается, а во втором в окне появляется надпись: “для продолжения нажмите любую клавишу”. Это позволяет увидеть на экране результаты вывода программы.
    Выполнение первой программы организуем с помощью пункта меню Start Without Debugging.

    В открывшемся диалоговом окне предлагается осуществить компиляцию проекта. Выбираем кнопку Yes.

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

    Список ошибок с их описаниями содержится в окне Error List. Если окно автоматически не отображается в нижней части экрана, его можно найти с помощью пункта меню View. Двойной щелчок мыши на строке с описанием ошибки в окне Error List приводит к переходу курсора в окне редактора кода к строке, в которой она произошла.
     В нашем случае ошибка связана с неописанным идентификатором cout. Cout – это стандартный поток вывода (экран монитора). Его определение содержится в библиотеке iostream. Возможно, ошибка связана с тем, что эта библиотека не подключена.
    Для проверки откроем окно проводника решения.

     В окне проводника решения выберем системный заголовочный файл stdafx.h

    Заголовочные файлы в языке С++ имеют расширение .h. Они содержат описания типов, функций и других глобальных объектов, которые использует программа. Сами глобальные объекты определяются в файлах с расширением .cpp. Эти файлы могут скомпилированы и содержаться в библиотеках. Для того, чтобы в программе можно было использовать глобальные объекты, необходимо при помощи директивы #include подключить заголовочные файлы библиотек. Заголовочные файлы представляют собой просто текст  на языке С++ с описаниями. Он может содержать строки подключения других заголовочных файлов. Системные библиотеки имеют большой размер. Их заголовочные файла содержат тысячи строк программного кода. Поэтому основное время компиляции программы пользователя может тратится на компиляцию заголовочных файлов библиотек.
    В Visual Studio .NET существует механизм предварительной компиляции заголовочных файлов, реализованный при помощи пары файлов Stdafx.h и Stdafx.cpp. В файл Stdafx.h добавляются при помощи директивы #include строки подключения необходимых для работы программы заголовочных файлов библиотек.
    В нашем примере строки подключения библиотек <stdio.h>, <tchar.h> генерируются автоматически при создании шаблона консольного приложения. Директива препроцессора #pragma once обеспечивает включение только единственной копии заголовочных файлов.
    Для возможности использования в программе операторов ввода и вывода подключаем заголовочный файл <iostream>, а также заголовочный файл <math.h> для работы с математическими функциями. Заголовочный файл библиотеки ввода и вывода не содержит расширение .h, поскольку  используется новый синтаксис языка С++.
    Сам файл Stdafx.h включается во все файлы реализации программы (*.CPP). Все другие директивы препроцессора, например , #define (определение именованных констант) и #include (подключения заголовочных файлов, не требующих предварительной компиляции) располагаются ниже строки #include <Stdafx.h>. При нарушении этих правил возникает ошибка на стадии компиляции – не найден конец файла.
    Для возврата в редактор кода программы  выбираем соответствующую вкладку.

    Язык С++ содержит новое средство для работы со сложными типами  данных пространство имен (namespace) . Пространства имен позволяют структурировать проекты, содержащие большое число типов, объединяя в одну группу близкие типы. Если над проектом работает несколько исполнителей, то, как правило, каждый из них создает свое пространство имен. Помимо структуризации, это дает возможность присваивать типам имена, не задумываясь об их уникальности. В разных пространствах имен могут существовать одноименные типы. Таким образом, пространство имен — это логическая структура для организации имен. Основное назначение пространств имен — предупредить возможные конфликты между именами. Для простых типов такая структурированность представляется избыточной, но для сложных - она осмысленна и полезна.
    Инструменты  потокового ввода-вывода языка С++ принадлежат пространству имен std. Поэтому для доступа к объектам можно явно указывать принадлежность к пространству имен, например, std::cout,  либо, что более удобно, сделать доступным все пространство имен при помощи строки
    using namespace std;
    Данная строка помещается до основной программы.
    С помощью пункта меню Start Without Debugging запускаем на выполнение исправленный вариант программы.

    В результате в окне вывода появляется нужная строка
     Далее...

    Следующая задача будет заключаться в вычислении выражения y=xb/2, где x вещественная переменная, а b целая. Для возведения в степень используем функцию pow(x,z) из математической библиотеки <math.h>. Значения переменных введем с клавиатуры. Перед вводом с клавиатуры на экран удобно напечатать текст, поясняющий, что надо вводить. В редакторе кода наберем программу, представленную на рисунке, и запустим ее на выполнение.

    На экране появляется странный результат извлечения квадратного корня из 4, который оказывается равный 1.
     Далее...

    Для выяснения причины ошибки нам потребуется встроенный в среду Visual Studio .NET отладчик программ. Ее можно открыть, выбрав команду Toolbars (Панели инструментов) в меню View (Вид), а затем Debug (Отладка).

    Одним из способов обнаружить логическую ошибку является выполнение кода программы по одной строке и изучение изменения содержимого одной или нескольких переменных. Для этого можно при работе программы войти в режим останова, а затем просмотреть код в Редакторе кода. Режим останова дает возможность просмотреть программу во время ее исполнения. Точка останова показывает то место программы, где выполнение будет остановлено, и вы сможете использовать инструменты разработки Visual Studio. Простейший способ установить точку останова— щелкнуть на сером поле слева от окна с исходным кодом программы. Можно также переместить курсор на нужную строку и щелкнуть на кнопке "Точка останова" на панели инструментов. Щелчок на этой кнопке установит точку останова, если ее там не было, и, наоборот, уберет ее, если она уже была установлена на этой строке. Теперь, если запустить программу в режиме отладки, ее выполнение остановится при достижении точки останова. Cтрока исходного кода программы  c точкой останова должна содержать исполняемый оператор. Таких точек останова в программе может быть несколько.
    Щелкнем в редакторе кода курсором мыши перед строкой, где происходит вывод на экран результата выполнения программы. Появление красного круга сигнализирует об установки точки остановки программы. Для запуска программы на отладку воспользуемся кнопкой с зеленой стрелкой на панели инструментов Debug.
    Выполнение программы приостанавливается и возникает режим ожидания действий пользователя. Оператор, который мы выбрали для создания точки останова, выделен желтым цветом, а на полосе Margin Indicator (Указатель поля) появилась стрелка.
    После остановки программы отладчиком можно продолжить ее выполнение в пошаговом режиме. Есть несколько кнопок на панели инструментов Debug, предназначенных для выполнения в пошаговом режиме. Наиболее часто используются следующие из них (в порядке расположения на панели инструментов):
    • Step Into (Шаге заходом);
    • Step Over (Шаг с обходом);
    • Step Out (Шаг с выходом).
    Есть еще одна команда контекстного меню— Run to Cursor (Выполнить до текущей позиции).
    Если курсор находится на вызове какой-либо функции, то при щелчке на кнопке Step Into (Шаг с заходом) он перейдет на первую строку этой функции. Если же щелкнуть на кнопке Step Over (Шаг с обходом), произойдет вызов функции и курсор переместится на следующую строку

    Чтобы определить значения переменных на данном этапе выполнения программы, воспользуемся окном отладки autos, представленных во вкладке на панели инструментов Debug. Окно Autos (Видимые) - это автоматическое окно, показывающее состояние переменных и свойств, которые используются в текущий момент. Окно Autos (Видимые) полезно для изучения состояния отдельных переменных и свойств. Но элементы в окне Autos (Видимые) сохраняют свои значения только для текущего (выделенного в отладчике) и предыдущего оператора (того, который только что был выполнен). Когда программа доходит до выполнения кода, не использующего эти переменные, они исчезают из окна Autos (Видимые). По умолчания окно отладки autos располагается внизу окна среды Visual Studio .NET
    Чтобы видеть содержимое переменных и свойств на протяжении всего выполнения программы, используйте окно Watch (Контрольное значение) - специальный инструмент Visual Studio, который отслеживает нужные значения, при работе в режиме останова. В Visual Studio .NET вы можете открыть до четырех окон Watch (Контрольное значение). Эти окна пронумерованы как Watch 1 (Контрольное значение 1), Watch 2 (Контрольное значение 2), Watch 3 (Контрольное значение 3) и Watch 4 (Контрольное значение 4) и находятся в подменю Watch (Контрольное значение), которое вы можете открыть, выбрав команду Windows (Окна) в меню Debug (Отладка). Также можно добавлять в окно Watch (Контрольное значение) выражения.

    Воспользуемся более простым средством и выделим курсором мыши в коде программы выражение b/2. Отладчик показывает, что его значение равно 0. Причина ошибки заключается в делении нацело, несмотря на то, что в языке C++ нет целочисленного деления. В C++ действует правило: тип результата выражения определяется старшим типом его операндов. Поскольку переменная b и константа 2 имеют целый тип, то и результат будет целый. В итоге результат вещественного деления округляется до ближайшего целого. Так как причина ошибки ясна, останавливаем работу отладчика с помощью кнопки с синим прямоугольником на панели инструментов Debug.

    Вносим исправление в текст программы, заменяя целочисленную константу 2 на вещественную 2.0, и снова запускаем отладку. В окне ввода значение переменной x вместо прежнего 4 изменяем на -4. Результат вычисления выражения b/2.0 оказывается правильным и равным 0.5. Но в окне autos видим, что значение переменной y не определено, поскольку извлекать квадратный корень из отрицательного числа нельзя. Останавливаем работу отладчика.

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

    Разработка приложения для работы с данными из предметной области “Библиотека”, позволяющего выполнять операции связанные с добавлением, удалением, заменой и поиском определенных записей. Внешний вид приложения показан на рисунке.
     Далее...

    Создание проекта при помощи шаблона Windows Forms Application
    Создание Windows-приложений начинается с того, что мы создаем новый проект типа Windows Application, выбирая соответствующий шаблон для одного из установленных языков программирования — С++ и группу приложений с управляемым кодом CLR, то есть кодом предназначенный для работы в среде выполнения .NET. Далее вводим имя приложения, указываем, где оно должно быть сохранено, и нажимаем кнопку OK.

    Интерфейс  приложения начинаем проектировать с главного меню. В окне Toolbox находим группу элементов Menus & Toolbars и выбираем MenuStrip.

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

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

    Пункт правка содержит операции, связанные с добавлением, удалением, заменой и поиском определенных записей. Вводим названия пунктов подменю правка. Названия пунктов меню хранятся в свойстве Text. В программном коде при автоматическом создании заголовков обработчиков событий используется свойство Name. По умолчанию имя обработчика события формируется из имени, отражающего тип элемента и его порядкового номера на форме, к которому добавляется через знак подчеркивания имя события. Для задания более осмысленных имен сначала выбираем соответствующий пункт меню, затем открываем окно Properties, находим свойство Name и вводим нужное имя. Эту операцию выполняем для всех пунктов подменю правка. В нашем примере задаем следующие имена Add, Delete, Find, Find_Next, Replace, Clear.

    Далее, начиная с пункта добавить, дважды щелкаем мышью на соответствующем прямоугольнике шаблона с названием пункта меню. Двойной щелчок приводит к автоматической генерации обработчика события с пустым телом. Открывается редактор кода и курсор устанавливается в теле обработчика внутри фигурных скобок. Здесь пользователь может набрать код обработчика события согласно требованиям логики приложения. К разработке кода мы вернемся после того, как будет построен интерфейс, а сейчас снова перейдем  в режим дизайна (выбрав вкладку Form1.h[Design]), и выполним эти операции для всех пунктов подменю правка. Для проверки откроем окно Properties. В этом окне выберем вкладку со значком молнии, которая содержит все события, на которые реагирует выбранный элемент. Раскроем список обработчиков события Click. Он должен содержать названия всех ранее созданных обработчиков этого события.

    Далее добавим в пункт меню вид подпункт упорядочить и откроем окно Toolbox.

    Следующий элемент интерфейса приложения – ListView. Он позволяет создавать сложные таблицы с данными.

    Для того, чтобы этот элемент выглядел действительно как таблица, установим его свойства Gridlines равным True, а View равным Details.

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

    В диалоговой панели необходимо сначала с помощью кнопки Add создать столбец, а затем, используя свойство Text, задать его заголовок.

    Определим согласно рисунку все заголовки столбцов и откроем окно Toolbox

    Далее нам потребуется многостраничный блокнот TablControl.

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

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

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

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

    Для группировки управляющих элементов на вкладке блокнота поместим в нее с панели Toolbox контейнер GroupBox.

    Зададим с помощью свойства Text заголовок рамки контейнера GroupBox., а с помощью свойства Dock растянем рамку на всю внутреннюю поверхность вкладки блокнота.

    На панеле Toolbox нам потребуются три новых элемента

    Далее поместим в контейнер GroupBox еще один внутренний контейнер и  зададим заголовок   рамки. Внутренний  контейнер будет содержать четыре элемента с панели Toolbox Label (статический текст) и четыре текстовых редактора TextBox. Используя свойство Text,  введем данные для элементов Label и очистим поля ввода текстовых редакторов TextBox.
     Далее...

    Аналогичным образом, сформируем еще два внутренних контейнера, как показано на рисунке.
     Далее...

    Добавим внутренний контейнер с кнопками PushButton из панели Toolbox. Зададим надписи на кнопках с помощью свойства Text.

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

    При выполнении, действий, связанных с пунктом меню Правка, возникает необходимость переносить данные, имеющие тип системный String, из набора текстовых редакторов в список ListView и наоборот. Все необходимые нам операции по преобразованию типа данных удобно представить в виде функций-элементов некоторого класса. Чтобы добавить в проект класс, используем пункты контекстного меню Add/Class в окне Solution Explorer.

    В открывшейся диалоговой панели необходимо выбрать категорию C++ далее шаблон C++ Class и нажать кнопку Add.

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

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

    Поскольку все функции-элементы класса MyConvert выполняют похожие действия, зададим для них  одно имя copyto. Такой механизм называется перегрузкой функций. Компилятор различает функции с одинаковыми именами по количеству и типу аргументов. Сделаем функции-элементы класса MyConvert статическими. Это позволит организовать их вызов  на основе уточненного имени MyConvert:: copyto без создания объекта класса. Нам потребуются преобразования между следующими типами данных: String ^ (строка), <String ^ >^ (массив строк), array<TextBox^>^ (массив текстовых редакторов), ListViewItem^ (отдельная строка списка). Все приведенные типы реализованы в .NET на основе классов, поэтому для их использования необходимо подключение соответствующих  пространств имен System (содержит String), System::Windows::Forms (содержит TextBox и ListViewItem), cli (содержит массив array).
    В результате заголовочный файл MyConvert.h выглядит следующим образом:
    #pragma once
    using namespace System;
    using namespace System::Windows::Forms;
    using namespace cli;
     class MyConvert
    {
    public:
    	MyConvert(void);
    	~MyConvert(void);
    static	void copyto(ListViewItem^ l, array<TextBox^>^ t,int count);
    static	void copyto(array<TextBox^>^ t,ListViewItem^ l, int count);
    static	void copyto( array<TextBox^>^ t, array<String ^ >^s, int count);
    static void copyto( array<TextBox^>^ t,String ^s, int count);
    static	void copyto( array<String ^ >^s,  array<TextBox^>^ t, int count);
    };
    Файл реализации MyConvert.cpp имеет вид:
    #include "StdAfx.h"
    #include ".\myconvert.h"
    #using <mscorlib.dll>
    MyConvert::MyConvert(void) {}
    MyConvert::~MyConvert(void) {}
    void MyConvert::copyto(ListViewItem^ l,   array<TextBox^>^ t,int count)
    {for(int i=0;i<count;i++)
    	l->SubItems [i]->Text=t[i]->Text;
    }
    void MyConvert::copyto(  array<TextBox^>^ t,ListViewItem^ l, int count)
    	{ for(int i=0;i<count;i++)
    	t[i]->Text=l->SubItems [i]->Text;
    	}
    void MyConvert::copyto(  array<TextBox^>^ t, array<String ^ >^s, int count)
    	{for(int i=0;i<count;i++)
    	t[i]->Text=s[i];
    	}
    void MyConvert::copyto(  array<TextBox^>^ t,String ^s, int count)
    	{for(int i=0;i<count;i++)
    	t[i]->Text=s;
    	}
    void MyConvert::copyto( array<String ^ >^s,   array<TextBox^>^ t, int count)
    	{for(int i=0;i<count;i++)
    	s[i]=t[i]->Text;
    	}
    Алгоритмы работы всех приведенных функций сводятся к поэлементному копированию. Для получения доступа к отдельному элементу строки списка по порядковому номеру используется индексируемое свойство SubItems. Оно содержит вложенное свойство Text, которое элемент строки списка представляет в виде системного стринга. Текстовый редактор TextBox имеет аналогичное свойство.
    Для работы программы нам потребуются вспомогательные переменные. Определим их внутри кода формы непосредственно после области, которая автоматически сгенерирована средой. Чтобы было удобно обращаться с набором текстовых редакторов, расположенных на вкладке блокнота, введем массив указателей на тип  TextBox. Для этого определим указатель на такой массив с именем m.
    array<TextBox^>^ m;
    Переменная целого типа _foundNext потребуется для организации поиска. Она будет хранить индекс последнего найденного элемента.
    int	_foundNext;
    Переменная целого типа flag необходима при реализации операции замены элементов.
    int	 flag;
    Начальные значения введенных переменных устанавливаем в обработчике события Load формы, которое возникает при отображении формы на экране. Для генерации заголовка обработчика события в режиме дизайна выделяем мышью форму, далее в окне свойств Properties открываем вкладку событий с помощью кнопки с молнией и находим в списке событие Load. Двойной щелчок мыши в данной строке в колонке значений приведет к созданию пустого обработчика события. Внутри фигурных скобок вводим следующий код.
    private: System::Void Form1_Load(System::Object^  sender, System::EventArgs^  e) {
    	_foundNext=-1;flag=0;
    		 m=gcnew   array<TextBox^>(7);
       		 m[0]=textBox5;m[1]=textBox6;m[2]=textBox7; m[3]=textBox8 ;
    	 m[4]=textBox10;m[5]= textBox11; m[6]=textBox12;	 }
    }
    Поскольку поиск не производился, то начальное значение переменной _foundNext приравниваем индексу несуществующего элемента -1. Аналогично значение переменной flag равное 0 сигнализирует об отсутствии замены. В обработчике события Load формы выделяем динамически память под массив указателей на тип TextBox. Элементам массива присваиваем значения указателей на текстовые редакторы, расположенные на форме. Этот код нельзя просто копировать, так как в вашей программе текстовые редакторы имеют другие имена.
    В обработчике события кнопки добавить определяем указатель на массив стрингов и выделяем память под массив. Используя статическую функцию из класса  MyConvert, перекопируем данные из текстовых редакторов в массив строк.  Массив строк служит аргументом конструктора при создании новой строки списка ListView.  Свойство Items, в свою очередь, представляет простой список List, содержащий строки элемента ListView. С помощью метода Add списка List  добавляем новую строку в список строк элемента ListView
    private: System::Void Add_Click(System::Object^  sender, System::EventArgs^  e) {
     array<String ^ >^ms=gcnew  array< System::String^  >(7);
     MyConvert::copyto(ms,m,7);
    	ListViewItem^  listViewItem0 =gcnew ListViewItem(ms);
    			 listView1->Items->Add(listViewItem0);
    		 }
    В обработчике события кнопки удалить организуем цикл по выделенным мышью строкам элемента ListView. К ним можно получит доступ с помощью свойства SelectedIndices. Вызов метода RemoveAt свойства Items приводит к удалению строки с заданным индексом.
    private: System::Void Delete_Click(System::Object^  sender, System::EventArgs^  e) {
    	 for(int i=listView1->SelectedIndices->Count-1;i>=0;i--)
    			 { int d=listView1->SelectedIndices [i];
    			 listView1->Items->RemoveAt(d);	 } }
    В обработчике события кнопки найти организуем цикл по всем строкам элемента ListView. Свойство Count позволяет определить их количество. При поиске производится сравнение первого элемента отдельной строки списка ListView с текстом содержащимся в первом текстовом редакторе на форме. В случае совпадения значений индекс заносится в переменную _foundNext, а также отображается в всплывающем диалоговом окне. Диалоговое окно выводится при помощи статической функции Show класса MessageBox из пространства имен System::Windows::Forms.  Окно содержит заголовок, кнопку OK и строку со значением индекса. Для перевода целого типа в строковый используется метод ToString. В случае, если текст не найден в диалоговое окно выводится текст "No Found".
    private: System::Void Find_Click(System::Object^  sender, System::EventArgs^  e) {
    int ind	;
    for(ind=0;ind<listView1->Items->Count;ind++)
    {  String^ s1 =listView1->Items[ind]->SubItems [0]->Text;
       String^ s2=m[0]->Text;
       if(String::Equals(s1,s2))
                   {_foundNext=ind;
    	  MessageBox::Show(ind.ToString(),"Find Index");
                   return;}
    }
    MessageBox::Show("No Found","Find");
    _foundNext=-1;
     }
    Код обработчика события кнопки найти далее аналогичен коду обработчика кнопки найти. Но в отличии от последнего, в нем цикл просмотра строк списка организуется, начиная со следующего элемента после найденного. Он имеет индекс  _foundNext+1.
    private: System::Void Find_Next_Click(System::Object^  sender, System::EventArgs^  e) {
    if(_foundNext==-1) return;
    int ind	;
    for(ind=_foundNext+1;ind<listView1->Items->Count;ind++)
        {  String^ s1 =listView1->Items[ind]->SubItems [0]->Text;
           String^ s2=m[0]->Text;
           if(String::Equals(s1,s2))
                 {_foundNext=ind;
    	     MessageBox::Show(ind.ToString(),"Find Index");
                     return; }
          }
    MessageBox::Show("No Found","Find");_foundNext=-1;
    }
    В обработчике события кнопки замена текстовые редакторы на форме используются для ввода новых данных, участвующих в замене выделенной строки списка ListView. Для этого выводится приглашение с помощью всплывающего диалогового окна MessageBox. При повторном входе в обработчик события кнопки это сообщение не выводится, поскольку происходит проверка значения переменной flag, имеющей два состояния. В этом случае введенные данные из текстовых редакторов на форме заносятся в выделенную строку.

    private: System::Void Replace_Click(System::Object^  sender, System::EventArgs^  e) {
    	 if(flag==0)
    		 {
    flag=1;
    	MessageBox::Show("Введите данные для замены и нажмите кнопку Заменить еще раз","Поиск");
    		 return;}

     {flag=0;
            {int ind=listView1->SelectedIndices->Count-1;
    				  if(ind!=-1)
    				  {  ListViewItem^  listViewItem0=listView1->SelectedItems [ind];
                         MyConvert::copyto(listViewItem0,m,7);
    				  }
    		 }
    	 }
     }
    В обработчике события кнопки очистить в текстовые редакторы заносятся пустые строки.
    private: System::Void Clear_Click(System::Object^  sender, System::EventArgs^  e) {
    	MyConvert::copyto(m,"",7);

## СПИСОК ЛИТЕРАТУРЫ

1. Савихин О.Г.//Сборник заданий по программированию на языке С++ в среде разработки Visual Studio .NET (массивы, строки, структуры, классы) /Н. Новгород: Фонд компьютерных изданий ННГУ,2007.Рег. Номер 145.07.06
2. Алексей Федоров, Наталия Елманова. Изучаем Visual Studio .NET. Часть 1. Знакомство со средой разработки// "КомпьютерПресс" № 4,2002
3. Алексей Федоров, Наталия Елманова. Изучаем Visual Studio .NET. Часть 2. Создание Windows-приложений// "КомпьютерПресс" № 5, 2002
4. Алексей Федоров, Наталия Елманова. Изучаем Visual Studio .NET Studio .NET. Часть 3. Компоненты Windows-приложений //"КомпьютерПресс" № 6, 2002
5. Андрей Колесов. Среда разработки Visual Studio .NET//”BYTE/Россия” № 12, 2001
6. Владимир Биллиг . Язык C# и каркас среды .NET //"BYTE/Россия" № 12, 2001
7. Троелсен.Э. С# и платформа .NET. Библиотека программиста. СПб. : Питер, 2004.796 с.
8. Оберг Роберт Дж., Торстейнсон,Питер. Архитектура .NET и программирование с помощью Visual C++.:Пер.с англ. М.:Издательский дом "Вильяме",2002. 656 с.
9. Common Intermediate Language и системное программирование в Microsoft .NET //Интернет-Университет Информационных Технологий http://www.INTUIT.ru
10. Создание Windows-приложений на основе Visual C# //Интернет-Университет Информационных Технологий http://www.INTUIT.ru
11. Visual Basic .NET //Интернет-Университет Информационных Технологий http://www.INTUIT.ru
12. Основы программирования на C# //Интернет-Университет Информационных Технологий http://www.INTUIT.ru