Go toキャンペーンに便乗してgoto文を広めたい

7/22に開始される Go toキャンペーン
に先駆けて
プログラミングでもgotoキャンペーンをしてみよう

#gotoとは
古代から存在する制御構文であり、無条件にジャンプを行う
アセンブラ時代の非常に古い文法であるため忌み嫌われる事が多いが
未だに数多くの言語に存在する
コーディング規約でgotoの禁止が明記されたり、スパゲッティーコードの原因と言われたり
使ってはいけない構文と言われる事も多いが
正しく使えばコードの可読性が上がるため、脳死でgotoは禁止と考えるべきではない

現代の言語では関数というものが存在し、goto文は関数を飛び越えられないため
gotoでスパゲッティーコードになる状況は、そもそも関数を分割すべきである

##goto論争
古い言語ではgotoが頻繁に利用されていた
1968年にコンピュータサイエンスのダイクストラが「Go To Statement Considered Harmful」
という論文を出し、一躍goto文が悪役におどりでる
本当はダイクストラの言い分は違い、もっとライトなものであったのだが
強烈なタイトルだけが独り歩きした

嫌なgoto文の例

```cpp
    goto TRAVEL;
TRAVEL:
  goto CHIBA;
IWATE:
  goto TOKYO;
CHIBA:
    goto KYOTO;
TOKYO:
    goto CANCEL;
NAGOYA:
    goto FUKUOKA;
KYOTO:
    goto NAGOYA;
FUKUOKA:
    goto IWATE;
CANCEL:

```

##構造化
以下の3つの構文でgoto文は全て置き換えることが可能

###sequence
上から順にコードは実行される
通常の言語だと、上記は満たされている

###selection
if文等の事
例えばgoto文で書くと（注：参考コード）

```cpp
#include<iostream>

using namespace std;

void hoge(bool b){
    if(b) goto LABEL_TRUE;
    cout << "false" << endl;
    goto LABEL_END;

LABEL_TRUE:
    cout << "true" << endl;
LABEL_END:
    return;     // ラベルの後に最低でも1行必要
}

int main(){
    hoge(true);
    hoge(false);
    return(1);
}

--------
true
false
```

これをif文にすれば下記のように単純にできる

```cpp
using namespace std;

void hoge(bool b){
    if(b){
        cout << "true" << endl;
    }else{
        cout << "false" << endl;
    }
}

int main(){
    hoge(true);
    hoge(false);
    return(1);
}

--------
true
false
```

これでgoto文を減らせた


###iteration
for あるいはwhile文の事

普通に0から9までのLOOPを書くとこうなる

```cpp
#include<iostream>

using namespace std;

int main(){

    int n=0;
LABEL_LOOP:
    cout << n << endl;
    n++;
    if(n >= 10) goto LABEL_END;
    
    goto LABEL_LOOP;
    
LABEL_END:
    return(1);
}


----
0
1
2
3
4
5
6
7
8
9
```

for文を使うとこうなる

```cpp
using namespace std;

int main(){

    for(int n=0; n<10; n++){
        cout << n << endl;
    }
    return(1);
}

----
0
1
2
3
4
5
6
7
8
9
```

###iteration2

```cpp

LABEL_INPUT:
    string s = input();
    if( invalid(s) ) goto LABEL_INPUT;

```

```cpp

    string s;
    do{
        s = input();
    }
    while( invalid(s)) ;

```


このようにする事で、gotoを避けることができる


#良いgoto文
上記のように、goto文を使わなくてもコードは書ける
だが、近代のプログラミング言語でもgoto文を採用するものが多い
例えば、命令を極限まで減らしシンプルに設計されたGolangにおいてもgoto文は存在するし
php、pythonやJavascriptといった言語にも採用されている

gotoのない言語としてJavaが有名だが、今後goto文が追加される可能性を考慮し予約語になっているし
多重ループを抜ける手段として、ラベル付きbreakなどがある（実質gotoと同じである）

Rubyにはgoto文が存在しないので、よく例外で多重ループで抜けるのをみかけますが
エラーじゃない時に例外を投げるというのは、良くないし
例外は、本当にパフォーマンスが悪い。
RubyのVMがどのように実装しているか細かく見てないので一般論だけど
コンテキストスイッチを行ったり。
なので、なるべく例外で多重ループを抜けたくないと思う。
その場合は関数を分割するか、フラグで管理することになるが
後述するとおり、フラグ管理は好ましくない

コーディング規約でgotoの仕様を禁止される事が多いが
goto文は正しく使えばコードの見通しを良くし、無駄を省けるので
闇雲に禁止せずに、一度考えてみて欲しい
goto文を使うほうがコードの見通しが良くなる事も多い。

下記に良いgoto文を示す

##リソース開放

```cpp
void foo(){
    auto hoge = new Hoge();

    if( hoge == nullptr ){
        return;
    }

    if( なんかの処理() == エラー ){
        delete hoge;
        return;
    }

    if( なんかの処理2() == エラー ){
        delete hoge;
        return;
    }
    
    正常時の処理

    delete hoge;
}
```

上記のように、エラーのたびにリソースの開放が必要
ただし、newとdeleteが1対1に対応せずdeleteのほうが多くなるのは気持ち悪いし
どこかのケースでdeleteを忘れる事もあり、非常に見つけにくい不具合になりやすい

もちろん、newやmallocの場合はnullptrで判断するのが定跡

```cpp
void foo(){
    auto hoge = nullptr;    

    do{
        hoge = new Hoge();
        if( hoge == nullptr ) break;
        if( なんかの処理() == エラー ) break;
        if( なんかの処理2() == エラー ) break;
        
        正常時の処理
    }while(false);

    if(hoge != nullptr )delete hoge;
}
```

と、たとえばdo while文でbreakを使い、構造化っぽく処理をすることもできる
が、このdo~whileは無駄である。ループさせる意図がないのにwhileを使うべきではないし
間違って無限ループになると目も当てられない

newの場合はnullptrかどうかで初期化が行われたかの判断が可能だが、何かのライブラリの初期化処理だと
判別できないかもしれないので、その場合はフラグを使うことになるかもしれない


```cpp
void foo(){
    bool init = false;    

    do{
        if( !hoge_init() ) break;
        init = true;
        if( なんかの処理() == エラー ) break;
        if( なんかの処理2() == エラー ) break;

        正常時の処理
    }while(false);

    if( init ) hoge_release();
}
```

こんなフラグ制御を行い、どのような不具合が作られるか想像に易い

```cpp
void foo(){
    if( !hoge_init() ) return;
    if( なんかの処理() == エラー ) goto LABEL_ERR;
    if( なんかの処理2() == エラー )  goto LABEL_ERR;

    正常時の処理

LABEL_ERR:
    hoge_release();
}
```

gotoを利用すれば、比較的に綺麗に記述できた


C++であれば本当に正しい答えは、newなどはunique_ptr等をつかい、それ以外はカスタムデリータを使い
スコープが終われば確実に開放されるようにする事だ

```cpp
void foo(){
    auto hoge = std::make_unique<Hoge>();
    if( なんかの処理() == エラー ) return;
    if( なんかの処理2() == エラー )  return;

    正常時の処理
}
```

スマートポインタを使えば、スコープを抜けると自動で開放されるので不具合を作る可能性は減る

もちろんC言語や他の言語の場合は、newとdeleteを関数の外で行う事で対応する

```c
void bar(){
    void* buf = malloc(100);
    if(buf != 0){
        foo(buf);
        free(&buf);
    }
}

void foo(void **buf){
    if( なんかの処理() == エラー ) return;
    if( なんかの処理2() == エラー )  return;

    正常時の処理
}
```

##複数のリソース
複数のリソースの開放が絡む場合は非常に厄介だ

```cpp
void foo(){
    if(initA()){
        if(initB()){
            if(initC()){
                正常処理
                releaseC();
            }
            releaseB();
        }        
        releaseA();
    }
}
```

ネストも深く非常に嫌なコードになる
ネストが深くなると終了処理のタイミングを間違いやすくなる
ので、フラグを使って平べったっくしてみる

```cpp
void foo(){
    bool flagA = flagB = flagC = false;
    do{
        if(!initA()) break;
        flagA = true;
        if(!initB()) break;
        flagB = true;
        if(!initC()) break;
        flagC = true;
        正常処理
    }while(false);

    if(flagC)  releaseC;
    if(flagB)  releaseB;
    if(flagA)  releaseA;

}
```

読みやすくなったかもしれないが、無駄な do while文も無駄であるし
フラグも不具合を誘発しやすい

gotoに書き直してみる

```cpp
void foo(){
    if(!initA()) goto LABEL_END;
    if(!initB()) goto RELEASE_A;
    if(!initC()) goto RELEASE_B;
    正常処理

    releaseC;
RELEASE_B:
    releaseB;
RELEASE_A:
    releaseA;
LABEL_END;
    return;
}
```

無駄がなくなった。

もちろん、複数のリソースが絡み合う場合でも
C++ではスマートポインタによる自動リソースの開放を使うべきだ


##多重ループから抜ける
多重ループから抜ける際にgotoを使わないと可読性が下がる事がある
なぜなら、大抵の言語ではループから抜けるbreakは1つのループからしか抜けることができず
複数のループを抜けるにはフラグなどを使う必要がある

```cpp
bool flag = false;
for(int i=0; i<10 && !flag; i++ ){
    for(int j=0; j<10 && !flag; j++ ){
        for(int k=0; k<10; k++ ){
            if( buf[i][j][k] == 1 ){
                flag = true;
                break;
            }
        }
    }
}
```

外のforループの終了条件にフラグが追加される
不具合が出る可能性は無限大だ

gotoを使えば下記になる

```cpp
for(int i=0; i<10; i++ ){
    for(int j=0; j<10; j++ ){
        for(int k=0; k<10; k++ ){
            if( buf[i][j][k] == 1 ){
                goto LABEL_FOUND;
            }
        }
    }
}

LABEL_FOUND:

```

非常にわかりやすい。
もちろん王道な方法は、ループを関数に分けたりすることだ。


#おまけ（研究）

##Coroutineを作る
C言語にはコルーチンがなく不便なので作ってみた


```cpp
#include<iostream>

using namespace std;

void hoge(int &n){
    if(n==0) goto LABEL_0;
    if(n==1) goto LABEL_1;
    if(n==2) goto LABEL_2;

LABEL_0:
    cout << 0 << endl;
    n++;
    goto LABEL_END;

LABEL_1:
    cout << 1 << endl;
    n++;
    goto LABEL_END;


LABEL_2:
    cout << 2 << endl;
    n = 0;
    goto LABEL_END;

LABEL_END:
    return;
}

int main(){
    int coro = 0;
    hoge(coro);
    hoge(coro);
    hoge(coro);
    hoge(coro);
    hoge(coro);

    return(1);
}

----
0
1
2
0
1
```

あ、はい、switch case文でよくね？

```cpp
#include<iostream>

using namespace std;

void hoge(int &n){
    switch(n){
    case 0:
        cout << n << endl;
        n++;
        break;

    case 1:
        cout << n << endl;
        n++;
        break;

    case 2:
        cout << n << endl;
        n = 0;
        break;
    }


    return;
}

int main(){
    int coro = 0;
    hoge(coro);
    hoge(coro);
    hoge(coro);
    hoge(coro);
    hoge(coro);

    return(1);
}

----
0
1
2
0
1
```

##fizzbuzz

fizzbuzzも簡単に書くことができる

```cpp
#include<iostream>

using namespace std;


int main(){
    int n = 0;

LOOP:
    if(n%15 == 0) goto FIZZBUZZ;
    if(n%3 == 0) goto FIZZ;
    if(n%5 == 0) goto BUZZ;
    cout << n << endl;
    goto LOOP_FIN;

FIZZBUZZ:
    cout << "FIZZBUZZ" << endl;
    goto LOOP_FIN;

FIZZ:
    cout << "FIZZ" << endl;
    goto LOOP_FIN;

BUZZ:
    cout << "BUZZ" << endl;
    goto LOOP_FIN;


LOOP_FIN:
    n++;
    if(n < 100) goto LOOP;
    return(1);
}
```


#まとめ
gotoは無条件で否定すべきではないと思われる
if~else、do~whileやforで単純に書き換えられる箇所は書き換える方が良い事が多い
do~while(false) イデオムより、gotoに変えたほうが良い場合も多い
エラー処理、依存するリソースの開放、深いネストから抜ける際に、gotoを使う時もある

反面、上に戻るgotoは、読みにくくなる事が多いので、while等で戻る事を検討する