Visual Basic 6.0

Kurs tworzony na podstawie playlisty z kanału YT ***thenewboston***'

Program Hello World


Module Module1
    'komentarz jednoliniowy
    Sub Main()
        Console.WriteLine("Hello")
        Console.ReadLine()
    End Sub

End Module

Co warte uwagi tekst z konsoli trzeba odczytać inaczej się zamknie i nic nie wyświetli. Kolejny przykłady programów wywoływane są zawarte w tym samym module i wywołane w funkcji Main()

Typy prymitywne

Numbers

  • Integers
    • byte
    • short
    • int
    • long
  • Real Numbers
    • float
    • double

Character

  • char
  • string

logical

  • boolean
        Dim a As Integer = 5
        Dim b As Double = 12.44
        Dim c As Char = "a"
        Dim d As String
        d = a.ToString
        Dim e As Boolean = False

        Console.WriteLine(a)
        Console.WriteLine(b)
        Console.WriteLine(c)
        Console.WriteLine(d)
        Console.WriteLine(e)
        Console.ReadLine()

Operatory

Operatory arytmetyczne

W języku VB do podstawych operatów należą: dodawanie (+), odejmowanie (-), mnożenie (*), potęgowanie (^), dzielenie (/)

Dodatkowo możemy wykonywać operacje: konkatenacji (&) oraz modulo (Mod)

        Dim b As Integer = 10
        b = b Mod 3
        Console.WriteLine("Wynik b: " & b)
        Console.ReadLine()

a także przypisywania z dodawaniem (+=), odejmowaniem (-=), mnożeniem (*=), potęgowaniem (^=), dzieleniem (=/), konkatenacją (&=); nie można stosować do inkrementacji/dekrementacji wyrażeń (++/--)

Literał pusty wywołuje słowo kluczowe Nothing

        Dim a As Integer = 5
        Dim b As Integer = 10
        Dim answer As Integer = Nothing
        answer = a / b 'wynik 0

        Console.WriteLine(answer)
        Console.ReadLine()

W przypadku dzielenia liczb całkowitych nie możemy uzyskać zmiennoprzecinkowych, stąd wynikiem działania będzie zero. W przypadku zmiany typów np. na Double otrzymamy 0.5

Operatory relacyjne

Wyróżniamy następujące operatory:

  • równości: (=) - nie istnieje forma (==) mamy natomiast do dyspozycji funkcję Equals()
  • porównań: (>),(<), (>=), (<=)
  • logiczne: And, Or, Not [odpowiada !], Xor (alternatywa rozłączna)
  • specjalne: isNot, Is, TypeOf - porównywanie obiektów

Odczytywanie danych od użytkownika

Przykład 1.

        Dim name As String = Nothing
        Dim age As Integer = Nothing
        Dim salary As Double = Nothing
        Dim message As String = Nothing

        Console.WriteLine("Podaj swoje imię:")
        name = Console.ReadLine()
        Console.WriteLine("Podaj swój wiek:")
        age = Console.ReadLine()
        Console.WriteLine("Podaj swój zarobek:")
        salary = Console.ReadLine() 'W konsoli piszemy z przecinkiem nie z kropką !
        message &= ("imię: " & name)
        message &= (", wiek: " & age)
        message &= (", zarobek: " & salary)
        Console.WriteLine("Informacje | " & message)
        Console.ReadLine() 'niezbędne by zatrzymać widok konsoli

Program wyrzuci wyjątek jeśli podane wartości nie będą zgodne ze zdeklarowanymi typami zmiennych. Instrukcja Console.ReadLine() odczytuje podane wartości w konsoli i przypisuje je do zmiennych. Zmienna message służy do składania i przechowywania napisu. Wszystkie zmienne są konwertowane do typu String

Przykład 2.

        Console.WriteLine("Podaj dwie liczby:")
        Dim a As Double = Console.ReadLine()
        Dim b As Double = Console.ReadLine()

        Console.WriteLine(a & "+" & b & " = " & (a + b))
        Console.WriteLine(a & "-" & b & " = " & (a - b))
        Console.WriteLine(a & "*" & b & " = " & (a * b))
        Console.WriteLine(a & "^" & b & " = " & (a ^ b))
        Console.WriteLine(a & "/" & b & " = " & (a / b))
        Console.WriteLine(a & " Mod " & b & " = " & (a Mod b))

        Console.ReadLine()

Program wylicza wartości operacji jednocześnie dla różnych operacji arytmetycznych.

Przykład 3.

        Dim a As Double = InputBox("Podaj liczę a", "Argument 1", a)
        Dim b As Double = InputBox("Podaj liczbę b", "Argument 2", b)

        MsgBox(a & " podniesione do potęgi " & b & " wynosi " & (a ^ b), MsgBoxStyle.Critical, "Wynik operacji")

Funkcja InputBox() odbiera od użytkownika dane (w tym wypadku chodzi o podanie liczb zmiennoprzecinkowych). Możemy określić komunikat dla użytkownika (m1), wartość etykiety (m2), wartość jaka będzie przekazywana ze zmiennej (m3) - InputBox(<m1>,<m2>,<m3>). Funkcja MsgBox() wyświetla okno dialogowe z komunikatem. Możemy określić zawartość komunikatu w oknie (k1), rodzaj komunikatu (k2), wartość etykiety (k3) - MsgBox(<k1><k2><k3>)

Wyrażenia warunkowe

Przykład 1.

        Dim a As Double = InputBox("Podaj liczę a", "Argument 1", a)
        Dim b As Double = InputBox("Podaj liczbę b", "Argument 2", b)

        If (b <> 0) Then   'alternatywnie: If (b > 0 Or b < 0) Then
            MsgBox(a & " podzielone przez " & b & " wynosi " & (a / b), MsgBoxStyle.Information, "Wynik operacji")
        Else
            MsgBox("Nie można wykonać dzielenia przez zero", MsgBoxStyle.Critical, "Błąd")
        End If

Operator (<>) jest równoznaczny z (!=) w innych językach programowania, jest on zaprzeczeniem porównania (=) i zwraca true w przypadku, gdy wartości po obu stronach nie są sobie równe. Alternatywnie można jako warunek instrukcji if można podać (b > 0 Or b < 0) gdzie (Or) oznacza logiczne lub (zapisywane jako || jak i |) w innych językach programowania. W przypadku podania jako drugiego argumentu liczby 0, wykonana zostanie instrukcja Else - wyświetlona zostanie informacja, że dzielenie przez 0 nie jest możliwe.

Przykład 2.

        Console.WriteLine("Podaj dwa napisy")
        Dim a As String = Console.ReadLine()
        Dim b As String = Console.ReadLine()

        If (a.Length = 3 Or a.Length = 6) Then
            Console.WriteLine("Napis a ma trzy lub sześć znaków.")
            Console.WriteLine(a & b)
        ElseIf (a.Length >= 7) Then
            Console.WriteLine("Napis a ma siedem lub więcej znaków")
            Console.WriteLine(a + b)
            If a.Substring(0, 1).Equals("e") Then
                Console.WriteLine("Napis zaczyna się na literę e")
            Else
                Console.WriteLine("Napis nie zaczyna się na e")
            End If
        Else
            Console.WriteLine("Napis a nie ma trzech ani sześciu znaków")
        End If
        Console.ReadLine()

Program sprawdza napisy. Zawiera instrukcje warunkowe if > elseif > else (warto zauważyć, że elseif nie wykona się w przypadku spełnienia if). Zagnieżdżona instrukcja if > else wykona się zawsze w przypadku spełnienia warunku a.Length >= 7 (chodzi o długość napisu). Instrukcja else wykona się w przypadku nie spełnienia if lub elseif. Warunek w zagnieżdżonym if > else o treści a.Substring(0, 1).Equals("e") zwróci true jeżeli pierwsza litera napisu będzie identyczna z e (dosłownie funkcja Substring(x, y) zwraca napis gdzie x oznacza początek a y koniec; między znakiem o indeksie zerowym a jeden, znajduje się pierwsza litera ciągu). Program przedstawia alternatywny sposób wykonania operacji konkatenacji z wykorzystaniem znaku + operator & jest lepszym rozwiązaniem gdyż jest przeznaczony do typu String.

Wyrażenia warunkowe - wybór wielokierunkowy

Wybór wielokierunkowy umożliwia instrukcja Select > Case oraz Select > Case > Else które opowiadają instrukcjom switch > case oraz switch > case > default w innych językach programowania. Instrukcja zastępuje złożonego If > ElseIf. Co warte uwagi instrukcja break nie występuje w tej konstrukcji w języku Visual Basic

        Console.WriteLine("Podaj liczbę zmiennoprzecinkową")
        Dim b As Double = Console.ReadLine()
        Console.WriteLine("Określ precyzję wyświetlania - 1, 2, 3, 4")
        Dim a As Integer = Console.ReadLine()
        Select Case a
            Case 1
                Console.WriteLine(String.Format("{0:n1}", b))
            Case 2
                Console.WriteLine(String.Format("{0:n2}", b))
            Case 3
                Console.WriteLine(String.Format("{0:n3}", b))
            Case 4
                Console.WriteLine(String.Format("{0:n4}", b))
            Case Else
                Console.WriteLine("Domyślne formatowanie" & b)
        End Select
        Console.ReadLine()

Program wyświetla w zależności od podania przez użytkownika zmiennej a rozumianej jako parametr format wyświetlanych danych. W tym wypadku chodzi o precyzję liczby zmiennoprzecinkowej - czytaj więcej: Format.String

Pętle

Jednym z typów pętli jest For > To oraz For > To > Step obie kończą się słowem kluczowym Next. Odpowiednim tych w innych językach programowania są konstrukcje typu:

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

Bez określenia skoku pętli domyślnie będzie on wynosił 1. Wtedy pomijamy wyrażenie Step.

Przykład 1.

        Console.WriteLine("Podaj początek zakresu")
        Dim start As Double = Console.ReadLine()

        Console.WriteLine("Podaj koniec zakresu")
        Dim ends As Double = Console.ReadLine()

        Console.WriteLine("Określ skok")
        Dim jump As Double = Console.ReadLine()

        For s = start To ends Step jump
            Console.WriteLine(s)
        Next

Program wyświetla dowolnie zdefiniowany ciąg liczbowy przy pomocy trzech argumentów wartości pierwszego wyrażenia, wartości ostatniego wyrażenia, wartość o którą jest podnoszone następne wyrażenie wyrażenia. Jeśli np parametry określimy jako -1, -10 oraz 2 pętla się nie wykona (podnosząc -1 o 2 nigdy nie otrzymamy -10).

Przykład 2.

Sterowanie przebiegiem działania pętli

        For s = 1 To 10
            If (s Mod 6 = 0) Then
                Exit For
            ElseIf (s Mod 2 = 0) Then
                Continue For
            End If
            Console.WriteLine(s)
        Next

Przykład demonstruje działanie instrukcji Exit For (odpowiednik break w innych językach) oraz Continue For (odpowiednik continue). Wykonanie pętli wyświetli: 1, 3, 5 gdyż podczas dojścia zmiennej s do wartości 6 pierwszy warunek okaże się prawdziwy (nastąpi przerwanie pętli), nim to nastąpi pętla ominie wartości parzyste 2 i 4 ponieważ wtedy zadziała warunek drugi.

Przykład 3.

Pętle Do > While oraz Do > Until posiadają między sobą subtelne różnice choć działają podobnie. Pierwsza z nich ("podczas gdy") wymaga podania warunku przerwania, jako zakresu liczb. Druga z nich ("aż do") określa wartość końcową graniczną.

        Dim s = 0, m = 0
        Do While s < 30
            s += 3
            Console.WriteLine(s)
        Loop
        Do Until m = 30
            m += 3
            Console.WriteLine(m)
        Loop
        Console.ReadLine()

Przykład 4.

Przykład na dole ilustruje inny wariant opisanych pętli. Wszystko co zawarte w instrukcji Do zostanie wykonane przed sprawdzeniem warunku. Jednak w pętli Do > Until dojdzie do zapętlenia gdy np. napiszemy m += 35. Pętla Do > While zachowa się inaczej, wykona instrukcje do jeden raz po czym przerwie działanie po sprawdzeniu warunku który okażę się false

        Dim s = 0, m = 0
        Do
            s += 5
            Console.WriteLine(s)
        Loop While s < 30
        Do
            m += 5
            Console.WriteLine(m)
        Loop Until m = 30

Tablice

VB korzysta z tablic statycznych, jak i dynamicznych. Wielkość tej struktury danych może być stała lub zmieniana w trakcie wykonywania programu. Tablice indeksowane są od zera.

Przykład 1.

        Dim tab() As Integer = {1, 2, 3}
        tab = {2, 5, 7, 8}
        For Each element As Integer In tab
            Console.WriteLine(element)
        Next
        Console.ReadLine()

Przedstawiony przykład ilustruje tablice o niezdeklarowanej wielkości. Do zmiennej tab zostają przypisane trzy elementu typu Integer, po czym następuje podmiana zawartości tablicy na wartości {2, 5, 7, 8}. Do przeglądu elementów tablicy zostaje wykorzystana pętla typu For Each. W tej pętli wartości z kolejnych indeksów tablicy zostają przypisane do zmiennej element i wyświetlone na ekranie.

Przykład 2.

        Dim tab() As Integer = {1, 2, 6}
        tab(2) = 3
        Dim matrix(,) As Double
        matrix = {{1.0, 2.0, 3.0},
                  {4.1, 5.1, 6.2},
                  {7.2, 8.2, 9.2}}
        Dim Bmatrix(,,) As Long
        Bmatrix = {{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},
                   {{11, 21, 31}, {41, 51, 61}, {71, 81, 91}},
                   {{12, 22, 32}, {42, 52, 62}, {72, 82, 92}}}

        'Dla jego obrotu pętli a wykonają się trzy obroty pętli b
        For a = 0 To 2
            Console.WriteLine("-tabela: " & tab(a))
            For b = 0 To 2
                Console.WriteLine("---macież : " & matrix(a, b))
                For c = 0 To 2
                    Console.WriteLine("-----macież wielowymiarowa : " & Bmatrix(a, b, c))
                Next
            Next
        Next
        Console.ReadLine()

# Przykład przedstawia działanie tabel wielowymiarowych z charakterystyczną składnią gdy dokonujemy inicjalizacji bez określenia wymiarów macierz (,) lub macierz(,,) - kolejny przecinek dodaje nowy wymiar tablicy. Spacer po elementach tablicy/macierzy jest realizowany poprzez zagnieżdżoną pętlę for. Każdy kolejny wymiar dla zaprezentowanego przykładu wymagał będzie kolejnego bloku For <zmienna> to 2 zagnieżdżonego wewnątrz kolejnego.

# Dla jego obrotu pętli a wykonają się trzy obroty pętli b. Z kolei dla jednego obrotu b są dokonywane trzy obroty pętli c. Wniosek z tego taki, że podczas wykonania jednego obrotu pętli a zostaje wykonanych 3x3x3 obrotów pętli c czyli 18. Rachunek się zgadza, bo tyle różnych wartości zawiera właśnie zmienna Bmatrix

Uzupełnienie wiedzy:

Funkcje

VB umożliwia przezywanie argumentów przez wartość jak i referencje stąd słowa kluczowe: ByVal oraz ByRef (więcej informacji: tutaj). Bloki instrukcji oznaczone jako Function muszą zwracać jakąś wartość/obiekt o zdeklarowanym typie. Muszą zawierać słowo kluczowe Return. Instrukcje oznaczane jako Sub modyfikują zmienne/obiekty nie zwracają ich.

    Sub Main()
        Dim c = a(1, 2) ' 0.5
        Dim d = b(c, 4) ' 0.5 / 4 = 0.125

        Console.WriteLine(c)
        Console.WriteLine(d)
        cc(c, d) ' 1, 1
        Console.WriteLine(a(c, d))
        Console.ReadLine()
    End Sub

    Public Function a(ByVal x As Double, ByVal y As Double) As Double
        Return x / y
    End Function

    Public Function b(ByRef x As Double, ByRef y As Double) As Double
        Return x / y
    End Function

    Public Sub cc(ByRef x As Double, ByRef y As Double)
        x += 0.5
        y += 0.875
    End Sub

W przykładzie blok instrukcji Sub cc() wykonuje operacje inkrementacji dwóch na zmiennych. Pobiera ich referencje i modyfikuje wartość. Wynikiem działania programu będzie 0,5 | 0,125 | 1 Zdefiniowanie parametrów w bloku cc() jako wartości okażę się działaniem pozbawionym sensu. Funkcja nie wykona żadnej operacji.

Obsługa wyjątków

Obsługa wyjątków w VB na poziomie zapisu nie różni się bardzo od innych języków programowania. Za przechwycenie obiektów wyjątków odpowiadają instrukcje Try > Catch. Możliwe jest użycie bardziej złożonych wariantów do obsługi wielu wyjątków Try > Catch > Catch > Finally. Instrukcją zamykającą jest End Try

    Dim message As String = Nothing

    Sub Main()
        Try
            Console.WriteLine("Oblicz kolejne potęgi liczby x:")
            Dim x As Double = Console.ReadLine()
            Console.WriteLine("Podaj zakres:")
            Dim index As Integer = Console.ReadLine()
            Dim tab(index) As Long

            For s = 0 To index
                tab(s) = x ^ s
                Console.WriteLine(x & " ^ " & s & " = " & tab(s))
            Next

        Catch e As OverflowException
            Console.WriteLine("Zakres liczb został przekroczony")
            message = e.StackTrace
            Console.WriteLine(message)

        Catch f As InvalidCastException
            Console.WriteLine("Niepoprawny format danych")
            message = f.StackTrace
            Console.WriteLine(message)
        Finally
            Console.WriteLine("Koniec wykonania programu")
        End Try

        Console.ReadLine()
    End Sub

# Program wylicza kolejne potęgi wybranej liczby. Wartość tę stosunkowo łatwo przekroczyć przy zdefiniowaniu dużych liczb na wejściu. Pętla For wykonuje iteracje od zera do wartości zmiennej index, która określa rozpiętość zakresu kolejne potęgi liczby x od zera. Pętla wypełnia wartościami tabelę o polach typu Long. W przykładzie oczekujemy liczb całkowitych, choć nie ma przeszkody wykonywać operacji na liczbach zmiennoprzecinkowych. Wystarczy zmienić typy danych na Double w zmiennych tablicowych.


Rozpatrujemy potencjalną możliwość wystąpienia dwóch sytuacji powodujących błędy:

  • OverflowException - przekroczenie zakresu typu (wartość jest zbyt duża)
  • InvalidCastException - wprowadzenie wartości niezgodnych ze zdefiniowanymi oczekiwaniami aplikacji (np. ciągi znaków)


# Bloki Catch oprócz wyświetlenia komunikatu wyświetlają stos wywołań instrukcji. Korzystamy ze zmiennej message typu String której zasięg jest dla całego modułu. Zostaje ona zdefiniowania poza blokiem Main(). Do zmiennej message zostaje przypisany ciąg znaków który jest efektem wywołania metody StackTrace dla obiektu wyjątku. Instrukcja Finally wykona się zawsze po zakończeniu programu, nawet w sytuacji wystąpienia błędu.