1. Вы находитесь в архивной версии форума xaker.name. Здесь собраны темы с 2007 по 2012 год, большинство инструкций и мануалов уже неактуальны.
    Скрыть объявление

Visual Basic (Основы)

Тема в разделе "Visual Basic", создана пользователем VolkKz, 16 мар 2011.

  1. VolkKz

    VolkKz Новичок

    Регистрация:
    28 ноя 2010
    Сообщения:
    37
    Симпатии:
    8
    Баллы:
    0
    Перед начинающими программистами всегда встаёт один и тот же вопрос, а именно, какой язык программирования выбрать? На чём программировать? Можно сказать, что лучше начинать с лёгкого и в то же время мощного языка - Visual Basic. Изучив приёмы программирования на VB, вы сможете без особых усилий изучить другие языки, такие как Pascal, C++ и др.

    Слово "БЕЙСИК" (BASIC) - "базовый, основной" - образовано из начальных букв английского выражения "Универсальный язык символического кодирования для начинающих". Это "для начинающих" долго вызывало пренебрежение программистов, причём подобное пренебрежение не исчезло до сих пор, несмотря на наличие префессиональных изданий VB.

    Первый IMB PC имел 16-разрядный бейсик - BASICA, разработанный IBM, а затем вытесненный миктософтским GW-BASIC и QUICK-BASIC. В последнем была убрана нумерация строк и добавлен компилятор, превращающий бейсик програму в полноценный exe файл. Наконец в 1992г. фирмой Microsoft был выпущен VB 1.0 - очень простой язык программирования для Windows 3.1. Затем были выпущены VB 3.0, VB 4.0, VB 5.0 и наконец VB 6.0. Последние две версии мало чем отличаются, в шестой версии улучшено ядро и добавлены несколько новых функций. Существует ещё язык макросов для приложений Microsoft Office (Word, Excel и т.п.). Он называется VBA (Visual Basic for Application). С его помощью можно манипулировать приложениями Office.

    Приложения написанные на Visual Basic отличаются от обычных приложений тем, что требуют для своей работы библиотеку msvbvmX0.dll, которая должна присутсвовать в каталоге Windows\System. В роли X выступает версия компилятора VB. Для VB5 - msvbvm50.dll, для VB6 - msvbvm60.dll. Эти библиотеки идут в комплекте с WinME (обе) и Win98 (только msvbvm50.dll), и естественно с более новыми версиями этих ОС. Вы не должны бояться того, что вместе с вашим приложением, вам придётся таскать за собой эту библиотеку. Она есть уже у 90% пользователей. Но если вы всё-таки боитесь за аудиторию, то можете зашить библиотеку прямо в EXE файл. Правда для этого придётся использовать средства не входящие в состав VB. Например, это можно сделать с помощью программы Fusion (фирмы BitArts).

    Некоторые также считают, что приложения VB - это не полноценные программы, а лишь псевдокод, который при запуске выполняется интерпретатором. Это не совсем так. Если вы компилируете программу в Native Code, то полученный EXE - полноценное приложение Win32, которое просто использует функции msvbvm библиотеки. А вот P-Code является псевдокодом. Вид компиляции вы можете указать в меню Project->ProjectX Properties...

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

    Visual Basic доступен в трех редакциях, каждая из которых обеспечивает определенный набор инструментов разработки. Это

    Standard Edition

    Visual Basic Standard Edition позволяет создавать достаточно мощные приложения для Microsoft Windows 95 и Windows NT. Эта редакция включает все встроенные элементы управления Visual Basic, включая связанные (data-bound) элементы управления.

    Professional Edition

    Редакция Professional обеспечивает полно-функциональный набор инструментальных средств для разработки профессиональных решений, предназначенных для тиражирования. Она включает все возможности Standard Edition плюс дополнительные элементы управления ActiveX, включая элементы управления для Internet и генератор отчетов Crystal Reports для Visual Basic (рассматривается в главе 5).

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

    Enterprise Edition

    Редакция Enterprise позволяет создавать распределенные приложения силами группы разработчиков. Она обеспечивает все возможности редакции Professional и включает также дополнительные функции, такие, как Automation Manager, Component Manager, инструментальные средства управления базами данных и Microsoft Visual SourceSafe — проект-ориентированная система управления версиями продуктов.
     
  2. VolkKz

    VolkKz Новичок

    Регистрация:
    28 ноя 2010
    Сообщения:
    37
    Симпатии:
    8
    Баллы:
    0
    Visual Basic (Основы - Часть 2)

    Установка и настройка VB
    Установка Visual Basic не отличается особой сложностью, всё стандартно. В процессе инсталляции вас попросят указать компоненты, которые будут установлены на ваш компьютер. Если на жёстком диске есть место, то лучше выбрать все компоненты, чтобы потом их не пришлось добавлять.
    Перед работой с VB его необходимо настроить. Для этого запустите VB (Пуск->Программы->Microsoft Visual Basic 6.0->Visual Basic 6). Зайдите в меню Tools->Options. Поставьте галочку "Require Variable Declaration". Это избавит вас от лишних ошибок при автоматическом определении переменных. Далее на вкладке Editor Format, в списке Font укажите Courier New Cyr. Если этого не сделать, то VB не будет корректно отображать кириллицу.
    Структура проекта VB
    Перед рассмотрением вопроса проектирования интерфейса приложения на Visual Basic, необходимо представлять, из чего вообще состоит этот проект?

    В Visual Basic любой проект состоит из следующих файлов:
    -файл каждой формы (расширение frm). Это обычный ASCII текстовый файл, в котором записан весь код, помещённый в форму, а также свойства всех помещённых на форму элементов управления и самой формы тоже;
    -файл каждой формы, содержащий бинарную информацию (например картинку в PictureBox) (расширение frx);
    -файл проекта, содержащий информацию о проекте (расширение vbp)
    информация о рабочей области проекта (workspace) (расширение vbw).

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

    Далее перечислим дополнительные файлы, которые могут быть подключены к проекту:
    -файл каждого модуля (расширение bas) Это текстовый файл;
    -файл каждого модуля классов (расширение cls). Это текстовый файл;
    -файл каждого дополнительного элемента управления (расширение ctl) Это тоже текстовый файл;
    -файл ресурсов (расширение res);
    -другие файлы (ocx, tlb, и т.д...).

    Запоминать назначение всех этих файлов не обязательно, достаточно запомнить 2 файла: frm-файл, в котором хранятся код формы и свойства всех помещённых на данную форму элементов управления. И bas-файл - модуль. В нём могут быть объявлены глобальные переменные, константы, функции и т.д. Короче, только код. Без элементов управления.

    Среда разработки VB
    Для того, чтобы понять как проектировать интерфейс, разберём для начала среду разработки Visual Basic. Запустите VB. Перед вами появится окошко, в котором вам попросят указать тип проекта. Укажите тип "Standart EXE" и нажмите ОК. На экране вы увидите следующее окно:
    [​IMG]
    В левой части расположена панель с доступными элементами управления, с которой вы можете перетаскивать нужные элементы на форму. В центре находится форма (окно) вашего приложения. Имя новой формы - Form1. Вверху расположена панель инструментов среды разработки. Справа расположены окна проекта (Project) и свойств текущего объекта (Properties). Здесь необходимо отметить, что все объекты в VB (впрочем как и в других языках высокого уровня) имеют свойства и методы. Свойства — значения, которые устанавливаются для определения вида и поведения объекта. Методы — программные процедуры, обеспечивающие выполнение объектом некоторых предопределенных действий. Например, форма обеспечивает метод Show, который обусловливает вывод формы на экран. Главное преимущество работы с объектами в том, что объекты обеспечивают программный код, который уже не требуется писать разработчику. Ему просто нужно установить свойства объекта и вызвать методы объекта, чтобы побудить объект выполнить требуемые функции. Некоторые свойства можно отредактировать только в период выполнения программы (RunTime). Многие объекты имеют однинаковые свойства. Например, свойство Caption. У формы (Form) Caption - это заголовок окна, а у элемента метки (Label) - это текст внутри метки. Постепенно вы привыкните к таким обозначениям и в последствии сможете разобраться с любым, незнакомым вам элементом управления.

    Итак, для того чтобы поместить на форму нужный вам элемент, необходимо проделать следующее: нажать мышкой на нужный вам элемент на панеле слева, например, на кнопку (Command Button). После нажатия кнопка окажется вдавленной. Теперь поместите курсор мыши на форму и растяните мышкой прямоугольник. В результате этих манипуляций у вас на форме появится кнопка, имеющая размеры прямоугольника. Если вам понадобится изменить размеры кнопки, то необходимо выделить кнопку нажатием левой кнопки и растянуть кнопку за маркеры, расположенные на вершинах кнопки. Переместить кнопку в другое место можно обычным перетаскиванием (Drag&Drop). Необходимо отметить, что не все элементы управления имеют размеры. Например, Timer. Такие элементы не видны в процессе работы приложения, но выполняют определённые функции.

    Чтобы изменить свойства элемента управления необходимо выделить его и изменить нужное свойство в окне Properties. Давайте, к примеру, поменяем заголовок формы. Ткните левой кнопкой мыши в любое место формы и в найдите в окне Properties свойство Caption. Измените его, например, на "Это моя первая форма". Заголовок будет меняться по мере ввода текста.

    Теперь давайте запустим программу. Для этого нажмите на кнопку Start, расположенной на панели инструментов и имеющей иконку кнопки Play (как на магнитофоне). После непродолжительной компиляции, перед вами появится окно вашей программы! Причём вы можете его передвигать, менять размеры, минимизировать! И всё без единой строчки кода! Фантастика! :)

    Теперь закройте программу. Это можно сделать двумя способами - нажать на крестик в правом верхнем углу формы или нажать на кнопку End, имеющей иконку кнопки Stop.

    После закрытия программы вы вернётесь в среду разработки VB. Кстати, обратите внимание на окошко Project. В нём показан только один файл - Form1. Давайте добавим ещё одну форму к нашему проекту. Для этого выберите в меню Project->Add Form. Перед вами появится окно Add Form, в котором вам предложат выбрать вид новой формы. Дважды кликните на иконке с надписью Form. Перед вами появится новая форма. Её имя Form2. Но куда же делась старая, спросите вы? Для того, чтобы увидеть нашу старую форму, нужно дважды щёлкнуть по строчке Form1 в окне Project. Щёлкнув, вы сразу увидите нашу первую форму. Обратите внимание на 2 кнопочки в окне Project. View Object и View Code. Эти кнопочки вам очень пригодятся в дальнейшем. С помощью них вы можете переключаться между двумя режимами:
    -просмотром формы, для проектированием её интерфейса;
    -просмотром кода формы.

    Теперь давайте сохраним наш проект. Для этого нажмите на кнопку Save Project (на панели пятая). Вас попросят указать каталог для сохранения и имя файла для формы №1 (Form1.frm). Затем файл Form2.frm. И наконец файл Project1.vbp (vbp - Visual Basic Project). Всё, проект сохранён. Теперь вы можете открыть его в дальнейшем кнопкой Open Project. Открывать нужно файл с расширением vbp (Visual Basic Project). Здесь могу дать один очень важный совет - почаще сохраняйтесь! А то мало ли что... То Windows глюкнет, то свет выключат...:)
     
    Последнее редактирование модератором: 2 дек 2011
  3. VolkKz

    VolkKz Новичок

    Регистрация:
    28 ноя 2010
    Сообщения:
    37
    Симпатии:
    8
    Баллы:
    0
    Visual Basic (Основы - Часть 3)

    Лёгкость работы с кодом в VB
    Технология Intellisence сильно облегчит вам жизнь в процессе программирования на VB. Эта технология Microsoft позволит вам избежать ввода большого количества кода и его корректировки. Intellisence выводит небольшое всплывающее окно с полезной информацией о текущем объекте. Наверняка вы уже видели такое окно. Такие окна бывают 3-х видов:
    1.QuickInfo. Выдаёт информацию о синтаксисе текущего оператора Visual Basic. Где бы вы не ввели имя оператора (функции) и поставили после имени пробел или октрывающую круглую скобку, то Visual Basic незамедлительно покажет информацию о синтаксисе этого оператора.
    [​IMG]
    2.List Properties/Methods. Это свойство облегчит вам работу с объектами в Visual Basic. После того, как вы поставите точку после имени какого либо объекта, VB сразу же покажет вам список всех доступных свойств и методов этого объекта
    [​IMG]
    Свойства имеют иконку:
    [​IMG]
    а методы:
    http://visualprogs.medyal.ru/lesson/5.GIF
    3.Available Constants. Эта функция выводит окно доступных констант. Например, если вы поставите знак равенства после Boolean переменной, то Visual Basic выдаст вам окно, где вы сможете выбрать из двух значений (True/False) нужное. Вам даже не придётся ничего набирать на клавиатуре!
    4.Также, Если нажать Ctrl+J, то VB выдаст список всех определенных в программе свойств, методов, констант, типов и т.д, включая встроенные в сам Visual Basic.
    Также для новичков может быть полезна функция Auto Syntax Check, которую можно включить в Tools->Options. Если галочка стоит, то Visual Basic будет следить за правильностью набранного кода в Visual Basic. Если мы наберёте строчку неверно, то VB предупредит вас об этом, выдав окно с сообщением.

    Ещё Visual Basic постоянно следит за красивостью кода :). Т.к. Visual Basic не различает большие и маленькие буквы, он будет постоянно корректировать имена переменных и функций в коде программы, чтобы они выглядели именно так, как указано в их определении. Например, если вы объявите переменную

    Код:
    Dim myVar As String
    А затем в коде программы введёте:

    Код:
    MYVAR = "VB"
    То после того, как курсор редактирования перейдет на следующую (или просто другую) строчку, VB изменит код следующим образом:

    Код:
    myVar = "VB"
    Т.е. имя переменной всегда будет написано так, как определено в операторе Dim. Это очень хорошая функция VB.

    Также Visual Basic подсвечивает цветами некоторые участки кода. Синим цветом выделяются зарезервированные слова Visual Basic. Сине-зелёным цветом (если его можно таким назвать) комментарии, остальное чёрным. Комментарии - это всё, что находится после символа ' (апостроф). При компиляции комментарии игнорируются, но при просмотре кода они очень полезны. Советую комментировать код, особенно в тех местах, где сам чёрт сломит ногу! ;). Примеры подстветки:
    Код:
    Dim prgVariable As Long ' это комментарий
    Отступы

    Про отступы я бы хотел поговорить отдельно. Отступы ОЧЕНЬ выжны при программировании. Пожалуйста, НИкогда НЕ забывайте про них! Они помогут при просмотре вашего кода. Особенно они полезны в сложных ветвлениях и циклах. Давайте рассмотрим пример:

    Код:
    If Form1.Visible = False Then
    If a = b Then
    For c = 1 To 5
    If b > c Then Exit Sub
    Next c
    End If
    End If
    Согласитесь, понять в таком коде что выполняется после чего - оччень сложно. Но если мы поставим отступы, то всё сразу станет ясно!:

    Код:
    If Form1.Visible = False Then
       &nbspIf a = b Then
           &nbspFor c = 1 To 5
                If b > c Then Exit Sub
           &nbspNext c
        End If
    End If
    Как видите, теперь сразу видно, что второй If выполниться только при выполнении первого условия, что цикл находится внутри ветвления, и т.д.

    Visual Basic предоставляет возможность сделать отступ сразу для участка кода. Для этого необходимо выделить этот участок (несколько строк) и нажать Tab. Все выделенные строки сдвинуться вправо. Если вам понадобиться сдвинуть код влево, нажимайте Shift+Tab. Всегда помните про отступы!

    Cостав кода

    Во всех языках высокого уровня программный код состоит из:
    Переменных
    Выражений
    Операторов
    Управляющих структур
    Функций
    Классов и объектов


    Опишем каждый тип подробнее:

    Переменные.

    В Visual Basic переменые хранят информацию (значения). При их использовании Visual Basic резервирует область в памяти компьютера для хранения данной информации. Каждая переменная имеет своё имя. Оно может достигать 255 символов в длину, начинается всегда с буквы латинского алфавита, за которой могут следовать другие буквы, цифры и знак подчёркивания. Регистр символов значения не имеет. Приведём несколько примеров имён переменных:

    numOfLetters - подходит
    2Bottle - неверно, т.к. начинается не с буквы
    ThisIsVeryLongName - подходит, длина 18 символов
    sng.Cos - не подходит, т.к. используется точка

    Каждая переменная имеет определённый тип. Всего в VB 14 типов переменных. Кроме того, программист может определить и свой тип. Перечислим основные типы переменных VB:

    Byte - предназначен для хранения целых чисел от 0 до 255. Если переменной такого типа присвоить значение, выходящее за эти пределы, то Visual Basic сгенерирует ошибку.

    Integer - предназначен для хранения целых чисел в диапазоне
    -32768 до +32767, т.е. размер памяти, выделяемой под такую переменную состовляет 2 байта. (256*256=65536). Символ для обозначения - "%". Зачем он нужен, мы рассмотрим далее.

    Long - предназначен для хранения целых чисел в диапазоне
    -2147483648 до +2147483647, т.е. размер памяти, выделяемой под такую переменную состовляет 4 байта. (65536*65536=4294967296). Символ для обозначения - "&".

    String - предназначен для хранения строковой (символьной) информации, т.е. попросту говоря - текста. Может хранить до 2 Гб. текста. Символ для обозначения - "$".

    Single - предназначен для хранения дробных чисел, с точностью до 7 цифр. Диапазон отрицательных значений от -3.402823Е38 до -1.401298Е-45. Диапазон положительных значений от 1.401298Е-45 до 3.402823Е38. Длина числа может достигать 38 знаков. Занимает 4 байта памяти. Вычисления с данными переменными будут приблизительными и менее быстрыми, чем с переменными целого типа. Символ для обозначения - "!".

    Double - предназначен для хранения дробных чисел, с точностью до 16 цифр. Диапазон отрицательных значений
    от 1.79769313486232Е308 до -4.94065645841247Е-324.
    Диапазон положительных значений
    от 4.94065645841247Е-324 до 1.79769313486232Е308.
    Длина числа может достигать 300 знаков. Занимает 8 байта памяти. Вычисления с данными переменными будут приблизительными и менее быстрыми, чем с переменными целого типа. Используется для научных рассчётов. Символ для обозначения - "#".

    Currency - Данный тип создан для того, чтобы избежать ошибок при преобразовании чисел из десятичной формы в двоичную и наоборот (Невозможно представить 1/10 как сумму 1/2, 1/4 и т.д). Данный тип может иметь до 4 цифр после запятой, и до 14 перед ней. Внутри данного диапазона вычисления будут точными. Вычисления выполняются так же медленно, как и в случае переменных Single и Double. Данный тип очень подходит для финансовых расчётов. Символ для обозначения - "@".

    Date - Этот тип данных позволяет хранить значения времени и даты в промежутке от полуночи 1 января 100 года до полуночи 31 декабря 9999 года. Если переменной присвается только значение даты, то время равняется 00:00.

    Boolean - очень важный и распространённый тип данных. Позволяет хранить так называемые булевы значения, т.е. только два значения - True и False. (По русски Правда и Ложь). Используется тогда, когда вам нужно хранить только значение Да или Нет.

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

    В Visual Basic переменные объявляются с помощью оператора Dim, после которого следует As и Имя_Типа переменной. Например:

    Код:
    Dim a As Long
    Dim b As Byte
    Dim c As Long
    Dim numOfLetters As Long
    Dim myString As String
    Dim isLoaded As Boolean
    Если не указывать As Имя_Типа, то переменная будет объявлена как Variant.

    После объявления переменной ей присваивается значение по умолчанию. Для стоки это - "" (пустая строка). Для чисел - 0. Для Boolean - False. Переменная может быть использована сразу после объявления.

    Переменные можно объявлять и в одной строчке, разделяя объявления запятыми:

    Код:
    Dim a As Long, Dim b As Integer
    Здесь очень важно заметить следующую особенность. Логично было бы объявить 3 переменные типа Long следующим образом:

    Код:
    Dim a, b, c As Long
    Такая привычка могла перейти, например, из языка C. Там все переменные действительно имели бы тот тип, который указан после последней переменной. Но не в Visual Basic! В результате такого объявления VB объявит 3 переменные, первая и вторая будут иметь тип Variant, и только третья - Long! Запомните это! А вообще, лучше объявлять каждую переменную в отдельной строчке. И, если необходимо, то логически отделить эти объявления можно просто вставив пустую строку между теми объявлениями, которые вы хотите отделить логически. Например, так:

    Код:
    Dim a As Long
    Dim b As Long
    
    Dim myString1 As String
    Dim myString2 As String
    
    Такие логические пробелы между строчками необходимы для избавления кода от его монотонности.

    Присвоить значение переменной можно при помощи знака равно "=". Например:

    Код:
    a = 1234567
    b = 234
    c = 133
    myString = "Visual Basic рулит"
    isLoaded = True
    В данном примере переменным присваивались константы. Но часто бывает необходимо присвоить одной переменной значение другой. Это делается следующим образом:

    Код:
    a = b 
    ' можно, т.к. переменная b "умещается"
    ' в тип Long (234<4294967296)
    
    a = b + c
    ' теперь в a хранится сумма b + c.
    
    b = c 
    ' тоже возможно (133 < 255)
    
    b = a 
    ' нельзя, т.к. переменная a не укладывается
    ' в диапазон [0-255]. Произойдёт ошибка.
    
    myString = a 
    ' Visual Basic сам преобразует число 1234567
    ' в строку "1234567", а потом присвоит это значение 
    ' переменной myString. Также возможно обратное действие.
    
    isLoaded = True
    ' всё ОК
    
    myString = myString & " однозначно!"
    ' здесь происходит слияние двух строк, в результате чего 
    ' переменная myString содержит строку: 
    ' "Visual Basic рулит однозначно!".
    
    isLoaded = a 
    ' возможно, т.к. Visual Basic сам преобразует тип Long
    ' в тип Boolean. isLoaded будет содержать True. 
    ' Почему не False? 
    ' Потому, что в VB False - это нуль, а любое, 
    ' не нулевое значение - True
    Выше, при описании типов переменных я указывал символ для обозначения. Этот символ можно (а иногда и нужно) использовать для объявления переменной, но без использования зарезервированных слов As Тип. Т.е. к примеру:

    Код:
    Dim myLongParam&
    Dim myString$
    Здесь объявлены 2 переменные, первая имеет тип Long, вторая - String. Также можно употребрять эти спец. символы для явного указания типа константам, например:

    Код:
    Call MyProc (myParam1, myParam2, 5&)
    Здесь, при вызове процедуры MyProc, последний параметр имеет тип Long. Если бы мы не указали значок &, то он (параметр) имел бы тип Byte. Это необходимо при использовании API функций.

    Выше я уже отмечал, что Visual Basic часто, незаметно для разработчика, занимается преобразованием типов переменных на лету. К примеру, мы рассматривали такой пример:

    Код:
    myString = a
    Переменная a имеет тип Long, а myString - String. Visual Basic сам преобразует переменную a в тип String, а затем присвоит значение переменной MyString. Это необходимо знать. Также, Visual Basic предоставляет в ваше распоряжение несколько функций преобразования типов: CLng, CBool, CDate, CStr и т.д. Каждая функция преобразует выражение к соответствующему типу. Рассмотрим распространённую ошибку программиста на VB. Пусть у нас есть код типа:

    Код:
    Dim a As Byte
    Dim b As Byte
    Dim c As Long
    
    a = 200
    b = 200
    
    c = a + b
    Казалось бы, что если запустить такой код на выполнение, то в переменной c будет находиться значение 400 (200 + 200). Но не тут-то было :(. Visual Basic на строке c = a + b сгенерирует ошибку Overflow (Переполнение). Дело в том, что в выражении справа от знака равно складываются 2 переменные типа Byte, и Visual Basic решает, что после вычисления этого выражения, должен остаться тот же тип - Byte. Но если вспомнить то, что тип Byte может хранить значения в диапазоне 0-255, можно понять почему VB генерирует Overflow (Переполнение). 400 далеко выходит за диапазон Byte... Здесь может возникнуть вопрос: "А как же быть? Объявлять переменные a и b типом Long?". Можно поступить и так. А можно воспользоваться функций преобразования типа CLng. Тогда работоспособный код будет выглядеть следующим образом:

    Код:
    Dim a As Byte
    Dim b As Byte
    Dim c As Long
    
    a = 200
    b = 200
    
    c = CLng(a) + CLng(b) 'Всё в порядке, 400 - входит в тип Long
    
    Немного о константах:

    В Visual Basic можно объявлять не только переменные, но и константы. Константа как и переменная, тоже хранит некоторое значение, но в отличие от переменной хранимое значение не может изменяться. Чтобы объявить константу необходимо использовать зарезервированное слово Const, за которым следует имя и значение (и возможно тип) константы:

    Код:
    Const PI = 3.1415
    Здесь объявлена константа c именем pi и значением 3.1415. После объявления она может быть использована по назначению.

    Можно отметить следующую особенность VB: для констант с плавающей точкой тип по умолчанию - Double, для целых чисел - Integer. (Это легко можно проверить встроенной функций VB - VarType). Для того, чтобы явно задать тип константы, необходимо после имени задать тип, к примеру

    Код:
    Const PI As Long = 3 ' PI = 3, PI имеет тип Long
    В Visual Basic существует очень много встроенных констант, которые с легкостью могут быть использованы в ваших программах. Например, константа vbNewLine - содержит 2 символа, с ASCII кодами 13 и 10, т.е. переход на новую строку. Список констант можно посмотреть в Object Browser'е. Для его вызова необходимо нажать F2, находясь в среде Visual Basic.

    "Видимость" переменных:

    Объявлять переменные можно в самых разных местах:
    Внутри процедуры (или функции). В этом случае переменная будет "видна" только в коде этой процедуры (или функции). Если вы попытаетесь обратиться к такой переменной внутри кода другой процедуры, то Visual Basic сгенерирует ошибку.
    В самом верху кода формы, т.е. сразу после оператора Option Explicit. Это место называется разделом General Declarations (раздел Глобальных Объявлений). Такие переменные будет "видны" в любом месте кода формы. Т.е. в любой процедуре (или функции) формы. Переменные в данном месте могут быть объявлены с помощью зарезервированных слов Private и Public. Рассмотрим 3 определения:

    Код:
    Dim myLocalVar1 As Byte
    Private myLocalVar2 As Integer
    Public myGlobalVar1 As Long
    Первые 2 определения абсолютно эквивалентны. Переменные объявленные таким образом будут видны в любом месте кода формы. Но только той формы, где они объявлены. В других формах обратиться к таким переменным будет нельзя.

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

    Код:
    Form1.myGlobalVar1 = 234 
    В разделе General Declarations модуля. Здесь действуют те же правила, что и в разделе General Declarations формы. Private (или Dim) будут "видны" только в коде модуля. А Public - везде. Отличие наблюдается только в способе доступа к переменной. Здесь не обязательно указывать имя модуля перед такой переменной. Можно просто указать её имя и всё. Хотя я не рекомендую этого делать, т.к. теряется наглядность. И, к тому же, если у вас 2 модуля, в которых объявлены переменные с одинаковыми именами, то добраться к ним можно только указав имя соответствующего модуля перед именем переменной.

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

    Переменные, объявленные в процедуре (или функции) будут "живы" только пока выполняется эта процедура (или функция). При выходе из процедуры - переменная удаляется. При очередном вызове этой процедуры - переменная заново инициализируется. Кстати, к словам Private, Public и Dim, в процедурах и функциях можно использовать зарезервированное слово Static. Такая переменная при повторном вызове этой процедуры не будет заново инициализироваться. Она будет сохранять то значение, которое было в ней после предыдущего вызова. (такие переменные очень удобно использовать в обработке события Timer'а). Например:

    Код:
    Static myStat As String ' Private Static переменная 
    Переменные уровня формы будут "живы" только пока "жива" форма. Как только объектная переменная формы будет установлена в Nothing (или после выполнения оператора Unload), все переменные уровня этой формы удаляются.

    Переменные уровня модуля "живы", пока "живёт" ваше приложение. Т.е. "живы" всегда.

    Некоторые замечания:

    Перед использованием переменной, её обязательно нужно объявить. Это избавит вас от лишних ошибок.

    Переменным нужно давать осмысленные имена. Т.е. старайтесь не использовать имена типа a1,a2,a3,ab,ccc и т.п. Поверьте, рано или поздно вы запутаетесь в своей же программе! Лучше всего переменным давать английский эквивалент того, что хранит данная переменная. Например, для хранения некоторой суммы денег, переменная может быть названа как cashMoney. Если у вас английским не очень, то можете использовать транслит, т.е. переменную назвать, например как summaDeneg. Ну и т.п. Кириллицу в имени переменной использовать нельзя.
     
    Последнее редактирование модератором: 2 дек 2011
  4. VolkKz

    VolkKz Новичок

    Регистрация:
    28 ноя 2010
    Сообщения:
    37
    Симпатии:
    8
    Баллы:
    0
    Visual Basic (Основы - Часть 4)

    Переменные
    Переменные - это кусочки памяти, где хранятся данные. Значит, если эффективно использовать переменные - мы эффективно используем память. А если мы эффективно используем память - то памяти для приложения нужно меньше и приложение работает быстрее. Так вот для того, чтобы эти данные использовать с максимальной эффективностью, и в то же время с лёгкостью, были придуманы "массивы" (Arrays), "записи" (Types) и "перечисления" (Enums).

    Массивы

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

    В программировании массивы используются довольно часто. Например, вам нужно загрузить в программу содержимое какого-нибудь файла. Если этот файл строковый, то можно использовать строку и обойтись без массива. А вот если файл бинарный (двоичный), то тут без массива просто не обойтись!

    В Visual Basic массивы определяются следующим образом:

    Код:
    Dim myArray (10) As Long
    Как вы могли заметить, определение массива отличается от определения обычной переменной только индексом, указанным в скобках. Этот индекс указывает размерность массива. В данной случае массив myArray будет содержать 11 элементов. Почему 11? Потому что нижняя граница массива начинается с нуля. [0,1,2.....9,10]. Чтобы задать определённую размерность можно использовать зарезервированное слово To:

    Код:
    Dim myArray (5 To 10) As Long
    Здесь определяется массив, размерность которого 6 элементов (5,6,7,8,9,10).

    Общий синтаксис определения массива следующий:

    Код:
    Dim ИмяМассива{НомПерв1 То НомПосл1, НомПерв2 
    То НомПосл2, ...) [As [New] ИмяТипа]


    Многомерные массивы

    Массивы можно делать многомерными. Например, объявим массив - таблицу поля шахматной доски:

    Код:
    Dim chessTable (1 To 8, 1 To 8) As String
    Этот массив представляет собой таблицу с восьми ячейками по вертикали и горизонтали.

    Итак, массив определён. Теперь необходимо узнать - как же можно добраться к элементам этого массива. Очень просто! К элементам массива нужно обращаться по индексу, к примеру, чтобы изменить нулевой элемент массива myArray нужно написать:

    Код:
    myArray(0) = 1234 
    Или, например:

    Код:
    chessTable (2,3) = "Пешка"
    Массивы переменной размерности (динамические)

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

    Код:
    Dim fileContent (119) As Byte
    Но это если файл имеет длину 120 байт. А что делать, если мы не знаем длину загружаемого файла? Определять очень большой массив, чтобы уж наверняка туда мог поместиться большой файл? Нет. Так делать нельзя. Вот здесь как раз и нужно использовать динамический массив.

    Visual Basic предоставляет довольно мощные средства для работы с такими массивами. Опеределяется такой массив следующим образом:

    Код:
    Dim myArray () As Byte
    В отличие от массивов статичных размеров, когда обращаться к элементам можно сразу после его объявления, к элементам динамического массива сразу обращаться нельзя, т.к. они ещё не инициализированы. Для начала нужно указать его новую размерность. Для это в VB есть оператор ReDim. Работает он следующим образом:

    Код:
    ReDim myArray (4)
    Теперь массив myArray имеет одну размерность с индексами от 0 до 4 (т.е. всего 5 элементов). Теперь к такому массиву можно обращаться точно так же, как и к статичному. Если в дальнейшем возникнет необходимость снова изменить размерность массива, можно ещё раз использовать ReDim.

    Но! Здесь есть подводный камень! Давайте рассмотрим маленький примерчик:

    Код:
    Dim myLong As Long
    Dim myArray() As Long ' объявляем массив
    
    ReDim myArray (2) ' одна размерность [0,1,2]
    myArray (1) = 234 ' присваиваем второму элементу чило 234
    myLong = myArray (1) ' сохраняем его в переменной myLong
    
    ReDim myArray (3) ' снова меняем размерность-теперь [0,1,2,3]
    myLong = myArray (1) ' снова пытаемся сохранить второй элемент
    На последней строке, переменной myLong присвоится 0 вместо 234! Это происходит потому, что оператор ReDim заново инициализирует (сбрасывает) все элементы массива к значению по умолчанию (как помните, для чисел - это 0, для строк ""). Но как же быть, если мы хотим изменить размеры массива, сохранив все старые элементы? Для этого нужно после оператора ReDim поставить слово Preserve. Примерно так:

    Код:
    ReDim Preserve myArray (3) ' сохраняем старые элементы
    myLong = myArray (1) ' всё в порядке
    Теперь всё в порядке.

    Полезные советы по работе с массивами в VB

    Массивы могут храниться в переменных типа Variant. Иногда это бывает удобным. В некоторых случаях без этого просто не обойтись! (Например, когда вы хотите, чтобы ваша функция возвращала массив). Чтобы сохранить какой-либо массив в переменной типа Variant необходимо просто присвоить этой переменной нужный массив:

    Код:
    Dim myVariantArray ' переменная Variant по умолчанию
    myVarianrArray = chessTable
    Обратите внимание, никакие индексы указывать не нужно!

    Теперь можно использовать копию как обычный массив:

    Код:
    myVarianrArray (0) = "Это копия"
    Если вам потребуется в коде программы узнать текущие размеры массива, то можно использовать встроенные функции Visual Basic - LBound и UBound. Первая функция возвращает нижнюю границу массива, вторая верхнюю. Подробнее об этих функциях читайте в справочнике (vbhelprus).

    Записи

    Те, кто программировал на других языках программирования (таких, как C и Pascal), наверняка сталкивались с понятием структура (C), и записью (Record в паскале). В Visual Basic аналогом структуры является запись. Запись - это новый, опеределяемый программистом тип данных, который состоит из одной и более переменных внутри. Давайте рассмотрим это на примере. Например, необходимо в программе хранить массив студентов. Причём каждый студент имеет свои характеристики: ФИО, Возраст, Ниличие Грамот. Конечно, для хранения таких данных можно использовать, например, массив, имеющий две размерности. Но это не лучший вариант. Лучше всего здесь подходят Записи! Затем из записи можно будет сделать массив! Чтобы определить запись в программе нужно использовать зарезервированное слово Type. Заканчивается запись словами End Type:

    Код:
    Private Type Student ' вместо Private могло быть и Public
       &nbspFIO As String
       &nbspAge As Byte
       &nbspHasGramot As Boolean
    End Type
    
    Заметьте, что Dim перед именем переменной указывать не нужно. Итак, мы определили запись в программе. Теперь можно объявлять переменные, имеющий тип - Student (т.е. наша новая запись). Например:

    Код:
    Dim newStud As Student
    Слово Student синим выделяться не будет, т.к. синию подсветку имеют только зарезервированные слова, встоенные в Visual Basic

    Теперь, к полям записи можно обращаться при помощи точки:

    Код:
    newStud.FIO = "Василий Васильевич Пупкин"
    newStud.Age = 19
    newStud.HasGramot = False
    
    Всё как в паскале. (ну, и почти как в С).

    Visual Basic предоставляет возможность не указывать каждый раз имя переменной типа запись, при обращении к её элементам. Это особенно полезно, когда запись имеет много внутренних членов. Для этого есть слово With:

    Код:
    With newStud
       &nbsp.FIO = "Бабай Бабаевич Бабаев"
       &nbsp.Age = 20
       &nbsp.HasGramot = True
    End With
    Настало время объявить массив элементов типа запись (точнее типа Student):

    Код:
    Dim myStudArray (20) As Student
    Здесь мы объявили массив из 21 студента. Теперь можно обращаться к элементам массива точно так же, как мы это делали раньше:

    Код:
    myStudArray(0).FIO = "Билл Гейтс"
    Как видите всё гениальное просто! Особенно в Visual Basic! :)

    Перечисления

    Перечисления тоже довольно важная и нужная штука. В принципе, вы с ними уже встречались. Где? А вспомните, что происходило, когда вы напротив Boolean переменной ставили знак равенства? Правильно, Visual Basic выдавал вам список из двух значений на выбор - True и False. Это и есть перечисление. Другими словами перечисление - это список констант. Перед использованием такого списка его необходимо определить в программе. Например, рассмотрим перечисление оценок, получаямых студентами:

    Код:
    Enum Ocenka
       &nbspNeud = 3
       &nbspHorosho = 4
       &nbspOtlichno = 5
    End Enum
    Присваивать значения константам внутри Enum не обязательно. Если этого не сделать, то константы будут принимать значения 0,1,2... и т.д.

    Теперь можно объявить переменную типа Ocenka:

    Код:
    Dim oc1 As Ocenka
    И, если вы теперь попытаетесь присвоить такой переменной значение - Visual Basic выдаст список (Neud, Horosho и Otlichno) из которого вы сможете выбрать нужное значение. Также эти константы можно использовать, например, при проверке условий, т.е. If oc1 = Horosho Then ... Но об условиях позже.

    Чтобы закрепить полученные знания, давайте переопределим нашу запись Student на вот какую:

    Код:
    Private Type Student ' вместо Private могло быть и Public
       &nbspFIO As String
       &nbspAge As Byte
       &nbspHasGramot As Boolean
        ikzamenFizika As Ocenka
        ikzamenMatan As Ocenka 
    End Type
    Теперь чтобы присвоить оценку 5 по матанализу студента под номером 3, необходимо написать:

    Код:
    myStudArray(2).ikzamenMatan = Horosho
    Теперь, как видите, код очень прозрачен. Такой код гораздо легче для понимания, поэтому прежде чем определять какие-либо данные в своей программе, сначала подумайте, как это лучше реализовать? Может лучше что-то сделать с помощью записей? Или перечислений? И т.д.

    Примечание: Те, кто программировал на паскале помнят про множества. Так вот, могу их огорчить, множеств в Visual Basic нет. Но в принципе, никто не мешает вам реализовать их самостоятельно, написав соответствующие функции.

    Выражения

    Для начала разберёмся с понятием "выражение". В любом языке программирования выражения являются основными кирпичиками, из которых строится программа. Согласно самому точному определению, которое мне попадалось, "выражение" - это "что-то, что содержит значение". За примером далеко ходить не нужно, возьмём недавний пример:

    Код:
    b = 234
    Здесь мы присваиваем переменной b значение 234. Другими словами "234" - это выражение со значением 234. А теперь, к примеру рассмотрим строчку:

    Код:
    c = b
    Здесь переменной c присваивается выражение b. Значение этого выражения -
    b = 234. Т.е. другими словами b - выражение, со значением 234. Рассмотрим более сложный пример выражения - функцию. Объявим функцию MyFunc, возвращающую байт 234:

    Код:
    Public Function MyFunc() As Byte
       &nbspMyFunc = 234
    End Function
    А теперь запишем строку:

    Код:
    c = MyFunc()
    Как вы уже наверное догадались, выражение здесь - MyFunc(), со значением 234. Т.е. после присвоения переменной c выражения MyFunc(), она будет содержать значение 234. А вот ещё пример:

    Код:
    c = 5 + 5 * 2
    Здесь выражение это 5 + 5 * 2. Значение этого выражения не трудно посчитать, оно равно 15 (не 20!). Можно было бы написать и так:

    Код:
    c = MyFunc() - 219
    Здесь значение выражение такое же, как и в предыдущем случае, но вот сами выражения разные. Это важно понимать.

    Также необходимо отметить значение скобок в выражениях. Помните скобки в школе? Так вот в Visual Basic скобки выполняют ту же функцию, что и в школе, а именно - задают приоритет операции. К примеру, модифицируем выражение 5 + 5 * 2 на:

    Код:
    c = (5 + 5) * 2
    Теперь значение этого выражения не 15, а 20! Запомните это.

    Идём дальше. Рассмотрим другие, очень распространённые выражения - выражения сравнения. Такие выражения возвращают True или False, в зависимости от получившегося значения выражения. К таким выражениям относятся:

    Код:
    Dim bRes As Boolean ' переменная для хранения результата
    Dim a As Long
    Dim b As Byte
    Dim c As Long
    
    a = 234 ' переменные для теста
    b = 5
    c = 1000
    
    bRes = c > b ' 1
    bRes = c < b ' 2
    bRes = a >= c ' 3
    bRes = b <= 4 ' 4
    bRes = b <= 5 ' 5
    bRes = a <> b ' 6
    bRes = Not (a = b) ' 7
    bRes = c = MyFunc() ' 8
    ' и им подобные...
    Итак, рассмотрим каждый случай подробно:
    Здесь, переменной типа Boolean - bRes присваивается значение выражения (c > b). Т.е. Visual Basic сравнивает эти переменные, и смотрит, c > b? Если да, то значение этого выражения сравнения - True. Если же нет, то False.
    То же самое, только bRes будет содержать значение False, т.к. c больше b, а не меньше, как указано в выражении.
    Здесь происходит сравнение значений переменных a и c. Т.е. a больше или равно c? В нашем случае a = 234, c = 1000, значит не больше и не равно (меньше). bRes будет содержать False.
    b сравнивается с числом 4. Вспомните, ведь 4 - это тоже выражение, со значением 4! Т.к. b > 4, то bRes = False.
    Здесь также происходит сравнение переменной b с числом, 5. Но на этот раз одно из условий выполнени, а именно b = 5! Значит bRes = True.
    Очевидно, что b <> a. Стало быть bRes должно быть равно True!? Да, так оно и есть... ;)
    Обратите внимание на этот пример. После выполнения этой строчки, bRes будет равно True! Здесь выражение Not (a = b) вычисляется следующим образом: сначала Visual Basic сравнивает значения a и b. После того, как VB убедится в том, что a <> b (т.е. False), он вычисляет выражение:
    Not (False). Оператор Not - это булев оператор отрицания. Он инвертирует значение. В данном случае из False получается True. (на более низком уровнем, могу добавить, что оператор Not инвертирует все биты операнда, в данном случае, т.к. False в VB - это 0, а True - FFFF, то значение выражения - True).
    Здесь ничего особенно не происходит. bRes = False. Почему? Пусть это будет вашим домашним заданием :).

    Ну и последний пример, который иллюстрирует применение выражений сравнения. Сделаем так, чтобы переменной a присвоилось значение 234, если
    Код:
    c = b, и 100, если c <> b:
    
    If c = b Then a = 234
    If c <> b Then a = 100
    А можно так:

    Код:
    If c = b Then 
       &nbspa = 234
    End If
    
    If c <> b Then 
       &nbspa = 100
    End If
    
    Оба этих варинта абсолютно эквивалентны, но теряется наглядность. Лучше использовать следующий вариант:

    Код:
    If c = b Then 
       &nbspa = 234 ' строчка #1
    Else
       &nbspa = 100 ' строчка #2
    End If
    Здесь конструкция If выполнит строчку #1 тогда и только тогда, когда c будет равно b. Если же они не будут равны, то выполниться строчка #2.

    Операторы

    Здесь опять вспомним школу. Помните простые арифметические операторы? Такие как сложение, деление, вычитание, умножение. В Visual Basic они тоже есть. И их с лёгкостью можно использовать. Давайте рассмотрим пример:

    Код:
    c = 5 + 5 * 2
    В выражении 5 + 5 * 2 используются 2 оператора: + и *. Их действия очевидны - сложение и умножение. Так же, как и в алгебре, здесь действует принцип приоритетов. Он заключается в том, что каждый оператор имеет свой приоритет. Например, умножение имеет больший приоритет, чем, скажем, сложение. Поэтому результат такого выражения не 20, а 15. Приоритет можно указать явно, поставив в нужной части выражения круглые скобки:

    Код:
    c = (5 + 5) * 2
    Теперь результат выражения - 20, т.к. сначала выполнится оператор сложения и только потом умножение.

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

    Операторы бывают разные:

    В Visual Basic операторы бывают следующих типов:

    Арифметические:
    ^ оператор возведения в степень.
    * оператор умножения.
    / оператор деления
    \ оператор целочисленного деления
    Mod оператор вычисления остатка от деления
    + оператор сложения
    - оператор вычитания
    Сравнения:
    < меньше
    > больше
    <= меньше или равно
    >= больше или равно
    = равно
    <> не равно
    Конкатенации:
    + оператор конкатенации
    & оператор конкатенации
    Логические:
    And оператор логического умножения
    Eqv оператор логической эквивалентности
    Imp оператор логической импликации
    Not оператор логического отрицания
    Or оператор логического сложения
    Xor оператор логического исключающего сложения

    Как я уже говорил, каждый оператор имеет свой приоритет, и любое выражения вычисляется с учётом этих приоритетов.
     
    Последнее редактирование модератором: 2 дек 2011
    1 человеку нравится это.

Поделиться этой страницей