2011/10/23

いまさらVisual Basic（手続き指向篇）

今でこそ『MacBook がほしい』と口癖のように言っている僕ですが、実はビルゲイツとマイクロソフトに魂を売り渡しており、少年期は Visual Basic とともに過ごしておりました。

そんな事はどうでもよいのですが、このたび情報処理技術者試験も終わって気持ちに少し余裕が生まれた事ですし、原点回帰という事で、ふたたび Visual Basic を動かしてみようと思い立ったわけです。

折しも、僕の周りに『将来的に仕事で使うかも知れない』という方がいらっしゃるようなので、その方の為にもなればと簡単に VB の雰囲気をまとめてみる事にしました。



【はじめに】

このエントリでは、C 言語のソースと対比させる形でオブジェクト指向以前の基本的な文法を紹介していこうと思います。具体的には、変数の宣言や基本的な制御構文、そして関数の作り方に加え、デリゲートやλ式をつまみ食いします。

あまり突っ込むと、このエントリのページがトイレットペーパーのように長くなってしまいますので本当にさわりだけ。あと、あくまで構文のおさらいが目的ですから、サンプルは思いっきりコンソールアプリケーションですよ。がっかりだね。

コンソールアプリケーションを選んでみる


【Hello, World】

まずはお約束の Hello World から。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. #include <stdio.h>  
  6.   
  7. int main() {  
  8.     printf("Hello World\n");  
  9.     return 0;  
  10. }  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.     Sub Main()  
  7.         Console.WriteLine("Hello, World")  
  8.     End Sub  
  9. End Module  

実行結果


【変数の宣言・初期化】

変数宣言の構文です。C 言語と比較すると冗長な印象を受けます。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. // int 型の変数 var を定義して、値 100 で初期化  
  6. int var = 100;  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Dim var As Integer = 100  
  6. '   ~~~    ~~~~~~~   ~~~  
  7. ' 変数名     型    初期値  


【配列の宣言・初期化】

配列の宣言の構文は、先ほどの変数の宣言に準ずる形になりますが、初期化の構文は C 言語と VB でかなり似通った形になっています。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. int array1[5];             // 配列の宣言  
  6. //  ~~~~~~~~~  
  7. //  
  8. //           +-+-+-+-+-+  
  9. //  array1 : | | | | | |  
  10. //           +-+-+-+-+-+  
  11.   
  12.   
  13. int array2[] = {1, 2, 3};   // 初期化  
  14. //  ~~~~~~~~~   ~~~~~~~  
  15. //              初期化リスト  
  16. //  
  17. //  
  18. //           +-+-+-+  
  19. //  array2 : |1|2|3|  
  20. //           +-+-+-+  
  21. //              ↑初期値が入る  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Dim array1(5) As Integer    ' 配列の宣言  
  6. '   ~~~~~  ~  
  7. '  
  8. '           +-+-+-+-+-+  
  9. '  array1 : | | | | | |  
  10. '           +-+-+-+-+-+  
  11.   
  12.   
  13. Dim array2() As Integer = {1, 2, 3} ' 初期化  
  14. '   ~~~~~~                 ~~~~~~~  
  15. '                        初期化リスト  
  16. '  
  17. '  
  18. '           +-+-+-+  
  19. '  array2 : |1|2|3|  
  20. '           +-+-+-+  
  21. '              ↑初期値が入る  

C 言語において配列の要素にアクセスする際には [ ] （角括弧）の添字演算子を用いますが、VB の場合は ( ) （丸括弧）でアクセスします。

ちなみに、多次元配列の宣言は、
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Dim multiArray(100, 200) As Integer  
のように行います。 (i, j) 要素にアクセスするには multiArray(i, j) と書きます。

好みの問題ではありますが、C 言語の multiArray[i][j] よりも見た目が直感的に解りやすい気がします。


【If 文】

VB は、{ } （中括弧）ではなく、 If ～ End If 間でひとつの If ブロックを作ります。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. #include <stdio.h>  
  6.   
  7. int main() {  
  8.       
  9.     int age = 99;  
  10.   
  11.     if(age < 20) {  
  12.         printf("お前は未成年じゃー\n");  
  13.     } else {  
  14.         printf("成人おめでとう∩( ・ω・)∩\n");  
  15.     }  
  16.   
  17.     return 0;  
  18. }  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Sub Main()  
  8.   
  9.         Dim age As Integer = 99  
  10.   
  11.         If (age < 20) Then  
  12.             Console.WriteLine("お前は未成年じゃー")  
  13.         Else  
  14.             Console.WriteLine("成人おめでとう∩( ・ω・)∩")  
  15.         End If  
  16.   
  17.     End Sub  
  18.   
  19. End Module  

注意したいのは、条件判定式の比較演算子が C 言語とは大きく異なる点です。

たとえば、C 言語では変数 a と b の等価性の判定を if(a == b) … と書きますが、VB では If a = b Then … になります（余談ですが、個人的に、これは VB における非常に悪しき仕様だと考えています。この仕様に慣れきった人が他言語でも VB の感覚のまま if 文の条件式を書いたらと考えると、軽く目眩がします）。

また、C 言語では if(a != b) … と書く判定も、VB では If a <> b Then … のように書く必要があります。

C 言語に慣れてしまっているならば、条件式や演算子に関しては、MSDN で確認した方がいいですね。


【Select Case 文（switch 文）】

より複雑な条件分岐は、Select Case 文で行います。これは、C 言語の switch 文とほぼ同じですが、予約語や構文が微妙に違うため注意が必要です。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. #include <stdio.h>  
  6.   
  7. int main() {  
  8.       
  9.     int param = 1;  
  10.   
  11.     switch (param) {  
  12.         case 0:  
  13.             printf("アタタタタタタ（以下略）\n");  
  14.             break;  
  15.         case 1:  
  16.             printf("お前はもう死んでいる\n");  
  17.             break;  
  18.         case 2:  
  19.             printf("ひでぶッ\n");  
  20.             break;  
  21.         default:  
  22.             printf("You は Shock!!\n");  
  23.             break;  
  24.     }  
  25.   
  26.     return 0;  
  27. }  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Sub Main()  
  8.   
  9.         Dim param As Integer = 1  
  10.   
  11.         Select Case param  
  12.             Case 0  
  13.                 Console.WriteLine("アタタタタタタ（以下略）")  
  14.             Case 1  
  15.                 Console.WriteLine("お前はもう死んでいる")  
  16.             Case 2  
  17.                 Console.WriteLine("ひでぶッ")  
  18.             Case Else  
  19.                 Console.WriteLine("You は Shock!!")  
  20.         End Select  
  21.   
  22.     End Sub  
  23.   
  24. End Module  


【For 文】

くりかえしの For 文です。こちらも C 言語と比較的似ており、For 変数 As 型 = 初期値 To 終了値 Step 増分 と機械的に変換できます。

【C99】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. #include <stdio.h>  
  6.   
  7. int main() {  
  8.       
  9.     for(int i = 0; i <= 10; ++i) {  
  10.         printf("i = %d\n", i);  
  11.     }  
  12.   
  13.     return 0;  
  14. }  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Sub main()  
  8.   
  9.         For i As Integer = 0 To 10 Step 1  
  10.             Console.WriteLine("i = " & i)  
  11.         Next  
  12.   
  13.     End Sub  
  14.   
  15. End Module  

C 言語には、for 文を制御するために continue 文や break 文がありました。VB にも同様に、Continue ステートメントや Exit ステートメントが存在します。


【サブプロシージャ・関数】

C 言語では一口に関数と呼んでいますが、VB では戻り値のあるものとないもので区別されます。

戻り値を返すものを『関数』、返さないものを『サブプロシージャ』と呼び分けます。まずは簡単なサブプロシージャの方から紹介しましょう。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. #include <stdio.h>  
  6.   
  7. void test(int);  
  8.   
  9. int main() {  
  10.       
  11.     test(20);  
  12.   
  13.     return 0;  
  14. }  
  15.   
  16. // =====================================  
  17. // 引数の値を表示する関数  
  18. // -------------------------------------  
  19. // 引数： i  --   int  
  20. void test(int i) {  
  21.     printf("引数の値は %d です\n", i);  
  22. }  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Sub main()  
  8.   
  9.         Test(20)    ' サブプロシージャ呼び出し  
  10.   
  11.     End Sub  
  12.   
  13.     ' =====================================  
  14.     ' 引数の値を表示するサブプロシージャ  
  15.     ' -------------------------------------  
  16.     ' 引数： i  --   Integer  
  17.     Sub Test(ByVal i As Integer)  
  18.         '    ~~~~~~~~~~~~~~~~~~  
  19.         '          引数  
  20.   
  21.         Console.WriteLine("引数の値は" & i & "です")  
  22.   
  23.     End Sub  
  24.   
  25. End Module  

次に、戻り値を返す関数の紹介です。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. #include <stdio.h>  
  6.   
  7. int test(int);  
  8.   
  9. int main() {  
  10.       
  11.     test(20);  
  12.   
  13.     return 0;  
  14. }  
  15.   
  16. // =====================================  
  17. // 引数の値を2乗して返す関数  
  18. // -------------------------------------  
  19. // 引数： i  --   int  
  20. int test(int i) {  
  21.     int ret = i * i;  
  22.     printf("引数の2乗は%dです\n", ret);  
  23.     return ret;  
  24. }  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Sub main()  
  8.   
  9.         Test(20)    ' サブプロシージャ呼び出し  
  10.   
  11.     End Sub  
  12.   
  13.     ' =====================================  
  14.     ' 引数の値を2乗して返す関数  
  15.     ' -------------------------------------  
  16.     ' 引数： i  --   Integer  
  17.     Function Test(ByVal i As Integer) As Integer  
  18.         '         ~~~~~~~~~~~~~~~~~~     ~~~~~~~  
  19.         '               引数            戻り値の型  
  20.   
  21.         Dim ret As Integer = i ^ 2  
  22.         Console.WriteLine("引数の2乗は" & ret & "です")  
  23.         Return ret  
  24.     End Function  
  25.   
  26. End Module  

サブプロシージャと関数の主な違いは、接頭辞が Sub から Function に変わっている事、関数は戻り値の型を明示的に記述しなければならない事、そして戻り値を Return している事などが挙げられます。


【参照渡し】

C 言語における関数への≪ポインタ渡し≫の有用性を示す最小限のサンプルとして、『引数に渡した 2 変数の中身を入れ替える swap 関数』は定番中の定番でしょう。

【C】
view plainprint?
  1. // ========================================  
  2. //  
  3. //                  C 言語  
  4. //  
  5. // ========================================  
  6. #include <stdio.h>  
  7.   
  8. void swap(int *arg1, int *arg2);  
  9.   
  10. int main() {  
  11.     int x = 10;  
  12.     int y = 20;  
  13.       
  14.     printf("x = %d, y = %d\n", x, y);  
  15.     swap(&x, &y);  
  16.     printf("x = %d, y = %d\n", x, y);  
  17.       
  18.     return 0;  
  19. }  
  20.   
  21. // ===============================  
  22. // 変数の入れ替え  
  23. // ===============================  
  24. void swap(int *arg1, int *arg2) {  
  25.     int tmp = *arg1;  
  26.     *arg1   = *arg2;  
  27.     *arg2   = tmp;  
  28. }  

幸か不幸か、VB では C 言語ほど素直にポインタを扱えません。ですが、サブプロシージャに変数を「参照渡し」すれば、上記と等価の処理を VB で実装する事ができます。

【VB】
view plainprint?
  1. '  ========================================  
  2. '  
  3. '                Visual Basic  
  4. '  
  5. '  ========================================  
  6. Module Module1  
  7.     Sub Main()  
  8.         Dim x As Integer = 10  
  9.         Dim y As Integer = 20  
  10.   
  11.         Console.WriteLine("x = " & x & ", y = " & y)  
  12.         swap(x, y)  
  13.         Console.WriteLine("x = " & x & ", y = " & y)  
  14.   
  15.     End Sub  
  16.   
  17.     ' =====================================  
  18.     ' 変数の入れ替え  
  19.     ' =====================================  
  20.     Sub swap(ByRef arg1 As Integer, ByRef arg2 As Integer)  
  21.         '    ~~~~~                  ~~~~~  
  22.         '    ※ByRefを指定すると、参照渡しになる  
  23.   
  24.         Dim tmp As Integer = arg1  
  25.         arg1 = arg2  
  26.         arg2 = tmp  
  27.     End Sub  
  28. End Module  


【デリゲート（関数ポインタ）】

VB 紹介も佳境に入ってきました。デリゲートです。これは何かというと、C 言語の関数ポインタに近い機能です。

Windows API では、ウィンドウプロシージャを OS からコールバックするために関数ポインタが用いられていました（まぁ今もなんですけど）。これと同様の仕組みを VB でも実現するため（かどうかは分かりませんが）、デリゲートという仕組みが存在します。

【C】
view plainprint?
  1. // ========================================  
  2. //                  C 言語  
  3. // ========================================  
  4.   
  5. #include <stdio.h>  
  6.   
  7. void baka(int);  
  8. void aho(int);  
  9.   
  10. int main() {  
  11.       
  12.     void(* pFunc) (int);    // 関数ポインタの宣言  
  13.   
  14.     pFunc = baka;  
  15.     pFunc(10);  
  16.   
  17.     pFunc = aho;  
  18.     pFunc(2);  
  19.       
  20.     return 0;  
  21. }  
  22.   
  23. void baka(int arg) {  
  24.     for(int i = 0; i < arg; ++i) {  
  25.         printf("ばーか\n");  
  26.     }  
  27. }  
  28.   
  29. void aho(int arg) {  
  30.     for(int i = 0; i < arg; ++i) {  
  31.         printf("アホー\n");  
  32.     }  
  33. }  

【VB】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Delegate Sub Waruguchi(ByVal arg As Integer) ' デリゲート  
  8.     '                      ~~~~~~~~~~~~~~~~~~~~  
  9.     ' Integer型の引数を1つ取るサブプロシージャ  
  10.   
  11.     Sub main()  
  12.         Dim pFunc As Waruguchi  ' デリゲートの宣言  
  13.   
  14.         pFunc = New Waruguchi(AddressOf baka)  
  15.         pFunc(10)  
  16.   
  17.         pFunc = New Waruguchi(AddressOf aho)  
  18.         pFunc(2)  
  19.   
  20.     End Sub  
  21.   
  22.   
  23.     Sub baka(ByVal arg As Integer)  
  24.         For i As Integer = 0 To arg - 1 Step 1  
  25.             Console.WriteLine("ばーか")  
  26.         Next  
  27.     End Sub  
  28.   
  29.     Sub aho(ByVal arg As Integer)  
  30.         For i As Integer = 0 To arg - 1 Step 1  
  31.             Console.WriteLine("アホー")  
  32.         Next  
  33.     End Sub  
  34.   
  35. End Module  
いずれも、pFunc 経由で関数（サブプロシージャ）を呼び出している事が確認できると思います。

デリゲートはイベント処理等で真価を発揮します。たとえば『ボタンが押されたときの挙動』などを独立に関数化し、それをボタンコンポーネントのデリゲートに登録する……などの使い方が典型例ですね。

また、少しオブジェクト指向の話になりますが、Observer パターン（のようなもの）も、デリゲートのおかげで実装が容易になると考えられます。


【おまけ： λ式】

ところで、先ほどのサンプルでは、baka や aho をサブプロシージャとして独立させています。

ですが、デリゲートに登録するような関数は、普通、プログラムの中で使い回される事はほとんどありません。

その場合、先ほどのサンプル以下のように書き換えてしまう事ができます（ただし2010以降）。

【VB 2010】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Delegate Sub Waruguchi(ByVal arg As Integer)  
  8.   
  9.     Sub main()  
  10.         Dim pFunc As Waruguchi  
  11.   
  12.         ' λ式（その1）  
  13.         pFunc = Sub(arg As Integer)  
  14.                     For i As Integer = 0 To arg - 1 Step 1  
  15.                         Console.WriteLine("ばーか")  
  16.                     Next  
  17.                 End Sub  
  18.         pFunc(10)  
  19.   
  20.         'λ式（その2）  
  21.         pFunc = Sub(arg As Integer)  
  22.                     For i As Integer = 0 To arg - 1 Step 1  
  23.                         Console.WriteLine("アホー")  
  24.                     Next  
  25.                 End Sub  
  26.         pFunc(2)  
  27.   
  28.     End Sub  
  29.   
  30. End Module  
この無名のサブプロシージャは（文形式の）λ式と呼ばれるものです。もともと関数型プログラミング言語（Lisp とか Haskell とか）で用いられていた概念のようですが、VB ではあまり深い意味はなく、ただの便利な構文という解釈で充分のようです（なんか MSDN を読んでもそれ以上の解釈が見当たりませんでした…）。

ちなみに、上記のサンプルは以下のようにもうちょっとだけ簡潔に書く事ができます。

【VB 2010】
view plainprint?
  1. '  ========================================  
  2. '                Visual Basic  
  3. '  ========================================  
  4.   
  5. Module Module1  
  6.   
  7.     Sub main()  
  8.   
  9.         ' λ式（その1）  
  10.         Dim pFunc = Sub(arg As Integer)  
  11.                         For i As Integer = 0 To arg - 1 Step 1  
  12.                             Console.WriteLine("ばーか")  
  13.                         Next  
  14.                     End Sub  
  15.         pFunc(10)  
  16.   
  17.         'λ式（その2）  
  18.         pFunc = Sub(arg As Integer)  
  19.                     For i As Integer = 0 To arg - 1 Step 1  
  20.                         Console.WriteLine("アホー")  
  21.                     Next  
  22.                 End Sub  
  23.         pFunc(2)  
  24.   
  25.     End Sub  
  26.   
  27. End Module  


ここまで駆け足でオブジェクト指向以前の VB を見て回りました。

習得が容易な初心者向け言語と言われていますが、後半はそれなりに高度なトピックも含んでおり、ちょっと目を離した隙にますますわけのわからん言語へと成長を遂げたものだと感心しました。

続篇（オブジェクト指向）は暇になったらまた書こうかなぁと思っています。今回のような構文の列挙より、デザインパターンの中からお気に入りをかいつまんで紹介できたらなぁ…と。

それでは今日はこの辺でー∩( ・ω・)∩
時刻: 21:32
ラベル: , ,

0 件のコメント:

コメントを投稿

ひとことどうぞφ(・ω・,,)

登録: コメントの投稿 (Atom)