gotoを恐れず使う兵共がfinallyや多重breakを語るｽﾚ

前ｽﾚ http://pc8.2ch.net/test/read.cgi/tech/1021364372/

goto 1000

このボタンを押せば強制終了っていう場合は
どうやって実装する？

一般的には、ボタンが押されたことを通知するメッセージを捕捉して、
トップレベルウィンドウを閉じる処理をするんだろうなぁ。
いずれにしてもメッセージ操作だけだね。

>>3
外部割り込み

ボタンの後ろに機械接点があって、押すと接点が解放しPCの電力供給を絶つようにする。

核ミサイルを発射する処理をすれば

例外的な状況こそ例外

>>8
ﾄｰﾄﾛｼﾞｰ

>>1
gotoを恐れずに使いたくないからfinallyや多重breakを使うわけだが。

本格的なプログラムを作成するために存在するC++にはなぜfinallyや多重break,continueがないのですか？

トートロジー？(▽

トポロジーの親戚さ

>>11
finallyがないのはクラスを作ってデストラクタで何とかしなさいということ。
しかもstd::auto_ptrを始めとして大体は既にそのようなクラスが存在するから自分で作ることは少ない。

//俺が思うにfinallyや多重break, continueがないのは単に思いつかなかっただけではないかという気がする。

初代C++から幾度も仕様拡張・改変が繰り返されているのに？

ところで、finallyって機能の一般的な名称としては何て言うの？
俺の脳内的には「あとしまつ部」なんだけど、これじゃ格好悪いし。

>>16
ってことは、お主は try とか catch は何て言うのよ
「finally 節」 で良いじゃん

C++がJavaのfinallyを見て言った
C++「おまえ、それでよくガベージコレクタがあるって言えたな」
Java「みんなCが好きなんだよ」

??

ああ、メモリ以外は自分で解放する必要があるってことか

Cが嫌いな奴もいるだろ
女の子とか

>>20
偏見。私は女だがCが嫌いというわけでもない。

>>21
お前が本当に女なら、おっぱい晒せ。

>>21
ずっと前からお前の事好きだった

実は私、男なの。ゲイなのよ。

ﾎﾟｰｰｰｰｰｰｰｰｰｰｰｰｩｩｩｩｩｩｯｯｯ!!!
どーも〜〜〜、ゲイでぇ〜〜〜〜〜す〜〜〜〜

gotoを恐れず使う兵共はゲイだと

ニューハーフなら受け止める

スレが危険な方向に……

これでまたさらにム板住民→キモイという方程式が確固たるものに…
>>22は氏んでくれ

次スレ立ってたのか。

>10
然り。

age

>>3
組み込みの場合のマジレス。

while(1) ;

Cとかでtry-catchサポートするようになったら
やっぱfinally無しではキツい気がする。

finallyの中身は後片付けでしかないんで
デストラクタに書けばいいだろと言う主張は
なんか面倒くさい気もするけど納得できた。

C++とは無関係にCにも例外処理とfinallyが欲しい。

>>33
try-catchに関しては、普通にC++コンパイラ使えば良いじゃん。

try-catch
使ったらそれはもうC++だよw

つ Objective-C (Cocoa)

>>33
>C++とは無関係にCにも例外処理とfinallyが欲しい。

あるんだけど。

これまた、C++と無関係なCの例外処理だから、catchに困るんだけどね。

　　　　　　　　　 　 　　:ill||||||||||l:
　　　　　　　　　　　　　:i|||||||||||||||
　　　　　　　　　　　/''';:|||||||||||||||||l:､
　　　　　　　　　　/:i　 :||||||貞|||||||i `'! gotoやめれ〜・・　　・
　　　　　　　　 　/ :|　 :||||||||||||||||||l ﾉ!
　　　　　　　 　　|　ヽ　|||||||||||||||||||| :|
　　　　　　　　　 !　!;ヽ:||||||||||||||||||||!; |
　　　　　　.＿＿|　　|/|||||||||||||||||||||; |＿＿_＿
　　　 　　 |　 ＿|　　.|/||||||||||||||||||||; |__＿__　 .|
　　　　　　|　|:＝'ヾ‐イ:||:|l|l|l|l|l|l|ll|||||' |::::::::::::|　|
　　　　　　|　|:::::::: |　|;:|||||:l|:l|l|l|:l|:||||| ｲ＝::::::|　|　　ｻﾞｰ ……
　　　　　　|　|:::::::::/　};|||||||||l|:l|l|l|:l|:|||.ﾉ:＝:::::|　|
　　　　　　|　|:::＝!川!;|||||!l|||l|:l|l||||ｰ'‐'.;:::::::::::|　|
　　　　　　|　|:::::::::!l.|ﾉ　　　　　　/ ./:::::＝:::::::|　|
　　　　　　|　|::::::::::::|:::　　　　　 ﾉ　}::::::::＝::::::|　|
　　　　　　|　￣￣~|:::　　　　　 川ﾘ￣￣￣￣　|
　　　　　　|￣l￣￣|::::　　　　　　| ~￣￣￣|￣|
　　　　　　|＿|:.::.:.:.:|:::::　　　　　　|:.:.:.:.:.::..:.:.:|＿|
　　　　　　.:.:.:.:.:.:.:.:.:|;;;::::　　　　　 .|.:.:.:.:.:.:.:.:.:..:.:.:.:

((((；ﾟдﾟ))))ﾔﾒﾏｽ!

現代のプログラミング言語で、Fortranのような言語で使用されていたGOTOを
必要としない言語は何でしょうか？

>>40
「Fortranのような言語で使用されていたGOTO」というと、こんなのか？
ttp://xlsoft.com/jp/products/intel/cvf/docs/vf-html/az/az05_54.htm

一般的なＧＯＴＯですね。
ＣやＣ＋＋等ではＧＯＴＯ使わないと思うのですが、ＧＯＴＯを必要としない
ための構造というと、どういうものなのでしょうか？

もちろんＦＯＲやＷＨＩＬＥループ、ＳＷＩＴＣＨ等はそれだとはおもうのですが。

>ＧＯＴＯを必要としないための構造というと、どういうものなのでしょうか？
つ[COME FROM文]

ttp://www.fortran.com/fortran/come_from.html

>>42
ダイキストラたんに聞いてこい。

>>40
つ[構造化定理]

>>42
>ＣやＣ＋＋等ではＧＯＴＯ使わないと思うのですが
あなたがどう思うかに関わらず
goto を必要とする人々はいます。
つーか、そういう質問をするｽﾚではありません。

>>42
継続(current-continuation)。
明示的に扱えるのはschemeくらいしか無いが。

スレタイの無理やり加減が結構好きなんだが
さりとてこれといった話題があるでもない。

現実問題goto使った汚いコードよりgoto使わない汚いコードのほうが100倍多い件

よくわかんない。
統計とってよ。

取ったら取ったでサンプルが偏ってるとか言われそうだな

ちゃんと、そう言われないと思うようなデータを取ってこいよ。

「汚い」の定義もしないで何を話しているのか・・・

お前ら良くこんな底の方にあるスレに気がついたな

>>53
定義はいらん。主観だからだ。
ヒューマンインターフェースチックな評価手法が妥当だと思われる。

汚ないコードとgotoを使う・使わないが直交しているし、
gotoを使わないコードはgotoを使うコードの100倍どころか
1000倍以上存在しているだろうから、
goto使った汚いコードよりgoto使わない汚いコードのほうがはるかに多いだろう。

goto使いたがる人間はコーディングに対して意識の高い人間だからコードはきれい。
ただgotoを排除したがる人間は噂レベルの情報を鵜呑みにする思考停止したコーディングレベルの低い人間だからコードが汚い。

すでにgotoの存在自体を知らないプログラマが大多数を占めている罠

よくわかんない。
統計とってよ。

統計統計と連呼しないで下さい。話を止める効果しかありませんよ。
ご自身の主張をなされば良いでしょう

「早起きは三文の得」と言われても、統計を要求する人なんだよ、たぶん。

その三文とは金額のことですか? それとも距離のことですか?
具体的にどんな得があるというのか説明してください。

とか?

>>58
それはないよ
ジャンプも知らない奴はデバッグできない

なぜアセンブリのgotoは許されるのかについて

っていうか、アセンブリでjmpなかったら何もできん・・・ｗ

つかお前らassertスレが大分前に落ちましたよ

gotoだろうが何だろうが頭ごなしに否定あるいは肯定をするのは自分でモノを考えていない証拠です！＞＜
プログラミングってのがそんな定型的な作業ならわざわざ人間様がやる必要はないはずです！＞＜

>>67
自分で考えているかどうかっつーより、思考停止しているだけの話だろ。

「自分で考えていない」と「思考停止している」はどう違うのか

gotoは使ってより美しくなるのなら使え、そうでないなら使うな、ではないか？

>>70
同意するけど。
「何が美しいか」は完全に個人的な感覚に属する問題だからｗ

gotoにまつわる話だけで一冊の本になりそうなんだが
どこか出してくれないかな。買うぜ。

>>71
goto排斥原理主義者にとっては「gotoが使われている」＝「最悪に醜い」だからなぁｗ

knuth先生のコードにもgotoが使われているものがあったぞ。
確かミニマックスαβ探索だったと思う。

knuth先生だって必要最低限のgoto使うことがあるのだから、原理主義はやめるべき。

goto 1

>>74
ってか、knuth は goto 擁護論者の筆頭だろ。

高徳納には先生ってつける奴多いけど何で?

趣味だろ

先生と　生徒

ﾊｧﾊｧ

ジジイは趣味じゃないからパス

　if (A) { procX; }
　else if (B) { procY; procX; }
という処理をしたいのですが、procX、procYともに関数にするほどではないけれども、
上の位置にベタで書くにはちょっと無駄なタイプをしている気がするような処理なのです。
そこで
　if (A) goto labelX;
　else if (B) goto labelY;
　else return;
　labelY: procY;
　labelX: procX;
という書き方をしました。procXとprocYの実装を一度しか書かないという縛りで
gotoを使わずに書く書き方があれば教えてくださいm(_ _)m

書き込んで気が付きましたがスレ違いっぽいですね。
すみません。

if(B) procY;
else if(!A) return;
procX;

普通にこれではマズいのか？

>>83
ぉぅっ。エレガントです…。思いつきませんでした。

実際のコードはAで判定できる箇所が多くかつ判定自体も速いので、
できればAの判定を先に持ってきたいのですが…。
先に書くべきでしたね。

if(!A) {
　if(B) procY;
　else return;
}
procX;

これで>>81と等価かな。

>>85
できるもんなんですねぇ…。
勉強になりました。ありがとうございました。

そういう思考ができない人はあまりプログラマに向いて無い希ガス

>>81
俺ならこうやってネストしちゃうな。
（例として、条件がCまで、処理がprocZまでの三段階に増えたとする）

if(!A) {
　if(!B) {
　　if(!C) return;
　　procZ;
　}
　procY;
}
procX;

誰もお前には聞いてないんだよカス

GOTO使う事によってコードが短くなる件

まあ、goto使うことで
コードが短くも速くもならないなら
使うなとは言えるなｗ

    if (flag)
        goto N0021;
    return;

N0021:
    〜

こういうコードならつい最近見た。Fortran から C に単純変換したものらしい。
こういうのがいたるところに orz

>>92
実行形式から逆コンパイルした結果も
それと同様に goto だらけになったりするんだろうなぁ。

>>89
では今度からきちんと指名 (無料) するように。

コンパイル済みの汗ソース見ればくだらない議論と気付くはずw

ちうか、わざわざ高級言語つって読み書きしやすい制御構文を用意しているのに、
それを破壊するような使い方をするなっていうのがgotoは悪派の主張なわけで、
機械語に落ちれば全部jmpだろってのはあんまり関係ないよな。

まあ、機械語レベルのjmp命令がif等の制御構文と同等のレベルで
読み書きできるような人間にゃgotoだろうがforだろうが関係ないのかもしれんが、
そうじゃない人もいるんでそういう人も思いやってくれよということで。

1.gotoはどんな事があっても絶対使うな！
2.gotoはなるべく使わない方がいい

初心者に教えるなら１の方が正しいと思う。

ちなみに俺自身がどの程度使っているか調べてみたら、
92年ごろこんな事やってた。

// ポートからマウス移動量を取得
outp(0x7fdd,0x80);goto L1;
L1: x1 =inp(0x7fd9)&0xf;
outp(0x7fdd,0xa0);goto L2;
L2: x1+=(inp(0x7fd9)&0xf)<<4;
outp(0x7fdd,0xc0);goto L3;
L3: y1 =inp(0x7fd9)&0xf;
outp(0x7fdd,0xe0);goto L4;
L4: y1+=(inp(0x7fd9)&0xf)<<4;
outp(0x7fdd,0);goto L5;
L5: wark =inp(0x7fd9);

pc98のコードだが、今となってはよく分からん。
見ての通り組み込みに近い処理なので、こういうウェイトが
必要な場合もあったんだろうな、たぶん。

ジャンプ系の命令を挟んで数clockをwaitするってこと…なのか？
要するにnop代わりにgotoを使ったと…結構アレげだな

>ジャンプ系の命令を挟んで数clockをwaitするってこと…なのか？

たぶん、そういう事をやりたかったのだと思う。
gotoはＣで書けるけど、nopはasmブロックで書かなくてはならないので
gotoを選択したんじゃないかねー。「念のため」的なコードは書かない
主義なので、このgotoが無ければ動かない機種があったのだとは思う。
14〜15年前の若かりし日のコードなんで詳しい事は思い出せないなｗ

>>100
約15年前のキミに言っておきたい。
そのコードにはコメントを入れておけとｗ

おっと、もちろん、goto使用理由に関するコメントな。

最近のコンパイラだと、最適化で消される悪寒・・・

>そのコードにはコメントを入れておけとｗ
まったくもってそうかも知れない。。。

ちなみに別な所はこんな感じ

// マウス割り込みを許可する
void pascal MOUSE::_enable()
{
asm pushf
disable();
setvect(MOUSE_VECT,MOUSE::main); // ベクタの更新
outp(0x7fdf,0x93); // マウスモードセット
int a = inp(0x0a) & 0xdf; // 8259A(スレーブ)読みだし
outp(0x0a,a); // マウス割り込み許可(8259A)
goto w1;
w1: outp(0x7fdf,0x08); // マウス割り込み許可(8255A)
goto w2;
w2: asm popf
}

これだけマメにコメント入れているのに問題のgotoだけ何のコメントも
入ってないのは一体。。。。orz

自信の有無か、切羽詰ってたのか、或いは煮詰まっていたのか。

>>104
マジックナンバー（0x7fdfとか）に対するコメントはgoodだが、
「ベクタの更新」はコメント要らない気がする。
ていうか、だからgotoにコメント入れろとｗ

goto を入れるまでも無いくらい、自然で当然な行為だったんでわ。

goto を、じゃなくてコメントを、だった。
酔ってるんで許してくれ。

nopするだけのasmブロックをマクロで定義した方が良かったと思われる。

gotoを恐れなく使うのなら、finallyやbreakなんてヌルい物じゃなく、
gotoより強力な継続をバリバリに活用する方法を語るべきだろ。

ま、要するに使う側にとっては多少CPU時間が変わろうが仕様通り動けば良いわけだから
個人で開発するぶんには、完全に好みと言うか主観なわけで。

それは議論の対象外だろ

個人的に、breakとか使わなくてもifとgotoで事足りるんだが。

そりゃ、そうだろ…

プリフェッチの関係でnopではなくjmp shortを使わないとウエイトにならないとかでしょ？
当時のPC98ではそれが普通だったっつーか俺が覚えてるくらいだから広まってはいたんじゃないか

これまで何度も言われてきたことだけど
「個人で開発するぶんには・・・」とか「***で事足りるから***は不要」とか
無意味だとは思わんかね？

andとnotとorとgotoで事足りるから制御構造は不要

nand さえあれば、andもnotもorも不要なんじゃなかったっけ？

最終的にはチューリングマシン云々とかマシン語云々に行き着くんだろうな

>>119
フルアセンブラで組むのはさすがにバカ→C言語を使う俺、最高→いやいやC++使いの俺、最高→(以下略

プログラマを顎で使うクライアントの俺、最高

作業に見合うだけのお金を払ってくれるならな。

>>81と似たケースなんだけど
if(A){
　if(B){
　　procX;
　} else {
　　procY;
　}
} else {
　procY;
}

ってなってたら判断回数を増やさずにprocYを
一箇所だけにしたい場合、

if(A){
　if(B){
　　procX;
　} else {
　　goto _Y;
　}
} else {
_Y:
　procY;
}

って書く以外にある？

if (A && B){
  procX;
} else {
  procY;
}
じゃいけないの?

それじゃプログラムが変わってしまう。

あれ、ぼけてたかも…

>>123
すげー
gotoは絶対禁止ってルール作った方がいいよｗ

>>125
特に変わってないように見えるんだけど

>>128
>>126

だいたいgoto無くて困った事ないなｗ

>>129
ああそうか、 >>125=>>126 なのか。
>>124=>126 だと思ってた

(A && B && (procX || 1)) || procY;
ネタ提供

自分はこんなくだらないことでgotoを使う/使わないなどと悩むことはしないよ。

悩むまでもなくgotoを使うということか

goto眼中無しだろ普通

>>134
当然noだ。
故意に曲解していないか？
>>135 yes

134 はギャグで言っただけだろう

はいはいthrowthrow

しかしcatch

しかしgotoの嫌われっぷりも、相当なもんだよな
実際多少gotoつかったぐらいじゃ、可読性など落ちはしない
可読性を決める要因は、goto文の有無とは殆ど関係ないところにあるのにな

C++でgoto使うと、gotoでコンストラクタすっ飛ばすんじゃねえ
とか、コンパイラに怒られたりするな
goto文はなかなか教育的だ

使うシーンが思い浮かばん
使わなきゃならない、もしくは使ったほうがいい場合が思い浮かばん
もっともJava使ってんだけどJavaにはgotoって無いよね？

残念ながらJavaはgotoをサポートしていない。

特に残念でもないｗ

まぁ、Java は goto なんか使わせたら速攻でスパゲッティなコードを書くようなプログラマを対象にした言語だからな。

kwsk

このコマンドをいれると自動で玉が出る
goto

ゴト行為はやめましょう

>>145
詳しくもなにもそのまんまなだけ。Javaが現代COBOLだとか言われているのって聞いたことない？
"普通のプログラマはまともに使いこせない"という理由で他にも元ネタの言語であるC++からtemplateなどを排除し、
メモリ管理ひとつまともにできないプログラマの為にGCを標準装備したりしている。

>>147
そういえばそういうコードはよく見るなｗ

>>144
実際には goto なくてもスパゲッティ作れる人が大量投入されてる。
(そうじゃない人も多数いるけど。まぁどの言語もなんだが。)

Javaでmainに全コードベタ書きするスタイルを採用したらgotoが必要になると思うぞ。

Dr.goto

手続き指向言語（？）にはgoto欲しいかもね

>>83
それだと評価順が変わるのでいいのか？
>>85
あとにコードが続いてたらreturnはまずい気が。

>>147
詳しくのニュアンスに違和感を覚えるのは俺だけではないはずだ

>>154
IT土方の現代コボラーさん、いらっしゃ〜い。
まぁ、IT土方なんて沢山いるから、違和感を覚えたのは君だけじゃないよ、きっと、うん。

違和感を覚えた部分はそこじゃないと思うよ多分。

>>156
IT土方さん、いらっしゃい。

コボラーにはJAVAすら使えない。

こぼらーってJavaっていう言語があること知ってるの？

>>158-159
コボラーにあやまれ！　そこの現代コボラー！

コボラーってアトランティス人みたいなもんでしょ

コボラーってどんな言語？

コボラーって伝承とか伝説でだけ出てくる空想上の生物じゃね？

>>141
機能限定のラベル付きbreak、continueなら・・・

高速電脳の斜向かいにある美容院の名前はコボル

コボルちゃん

>>158-159
Javaも書けるCOBOLプログラマはそもそもコボラーとは呼ばれない

>>167
そのJavaコードがコボルチックだったりするからコボラーと呼ばれる。
コボラーが書いたC言語のコード見たらすごかった。
全部グローバル変数にしてｗ

>>167
そりゃそうだ、現代コボラーと呼ばれるだけだから。

>>168
あるあるw

>>168
コボルにはローカル変数無いの？

ちなみにおれ、コボル覚えられなかったんだよね…(´・ω・`)
C系よりよほど難しいと思うんだが。

>>170
10年以上前にやったCOBOL85あたりではローカル変数って言う考え方は無かった
アドレスとかポインタとか意識する必要が無いからCOBOLのほうが圧倒的に簡単だと思うがの

>170
>ちなみにおれ、コボル覚えられなかったんだよね…(´・ω・`)
>C系よりよほど難しいと思うんだが。

ナカーマ（ ・∀・）人（・∀・ ）

俺もC++ならtemplateもバッチリ使いこなせてメタプロもできるし、
アセンブラやスクリプト系の言語も問題なくこなせるんだが、
COBOLだけはダメっす。

cobolはデータ依存プログラミングができるから、ある意味非常に強力。
逆に、それを使わないとグローバル変数しかない非常に貧弱な言語になってしまう。

だから、商用システムなんかにはよく使われていた。
当時は、それが生産性が高かったんだよ。

漏れのトコはエラー処理へすっ飛ばす時にgoto使ってるんだが。

goto完全毛嫌い派ってそこんとこどうなん？

>>175
あいつら馬鹿だから、もちろんそれも否定するよ。

たまに1関数１returnとか言い出す。

if( is_error( hoge, hoge ) ) {
　10行ぐらいのエラー処理
　return ERROR;
}

if( is_error( next, hoge ) ) {
　上のと同じ10行ぐらいのエラー処理
　return ERROR;
}

if( is_error( next_next, hoge ) ) {
　やっぱり同じ10行ぐらいのエラー処理
　return ERROR;
}

以下続く

こんな感じの無残なコードは、何度も見かけたもんだがｗ

例外キャッチしたら頭に戻ってやり直しってコードには躊躇なくgotoを使うな

>>179
それって catch ブロックの中から try ブロックの中あるいはその前へ飛ぶの？

for(;;) try{
// 例外が起きそうな処理
break;
}
catch(e){
}

ﾀﾞｻｯ

摩訶不思議

1関数1returnというのは「出口はひとつ」を誤解してるんだろうな。
returnが複数でも出口は一つだし。returnはある意味"goto 最後の}"だと
思えばいい。

本当の「出口が一つじゃない」というのはBASICの
100 GOSUB 200
110 PRINT "1"
120 PRINT "2"
130 END
200 INPUT A
210 IF A=1 THEN RETURN 110
220 RETURN 120
の210行と220行みたいな話を言っているはず。これはもはやreturnではなくて
gotoだからな。

じゃあ「入り口が一つ」については？

入り口も出口も複数

　　　subroutine hoge(i, j, k, *, *)
　　　k = i + j
　　　entry huge(k, *, *)
　　　k = k - 1
　　　if (k .ne. 0) return 1
　　　return 2
　　　end

　　　program main
　　　read(*,*) n1, n2
　　　call hoge(n1, n2, i, *100, *300)
100　write(*,*) n1, ' + ', n2, ' - 1 = ', i
　　　i = 10
200　write(*,*) i
　　　call huge(i, *200, *300)
300　write(*,*) 'end'
　　　end

>>186
よーし、おじさんはCOBOLつかっちゃうぞ。

PERFORM xxx THRU yyyy

goto 1;

goto\s+[\w\d]+;|^\s*[\w\d]+:
をショッキングピンクにしてgoto使いまくりだな。

色々謎な正規表現だな

189の目を盗んでラベルの後に空白文字を入れてやるぜ。
goto fuck189 ;
fuck189 :

以下のケースってgotoしたくなる。

if(a && b && c){
処理１
goto jmp;
} else if(d){
処理２
}
if(a && b){
jmp:
処理３
}

真理値表を書いてみよう。
a b c d 処理1 処理2 処理3
0 0 0 0 x x x
0 0 0 1 x o x
0 0 1 0 x x x
0 0 1 1 x o x
0 1 0 0 x x x
0 1 0 1 x o x
0 1 1 0 x x x
0 1 1 1 x o x
1 0 0 0 x x x
1 0 0 1 x o x
1 0 1 0 x x x
1 0 1 1 x o x
1 1 0 0 x x o
1 1 0 1 x o o
1 1 1 0 o x o
1 1 1 1 o x o
なんだ、goto要らないじゃん。

で、バカを晒した>>192はどこに行った?
しかし、真理値表を書かないと結論が出ない>>193も大概だがな。

>>194
if(a && b){
を省略したいってことじゃないかな。auto a,bだとして。
コンパイラにやって欲しい処理だ。

goto使ったら先輩にしつこくなじられるようになった
うぜぇｗｗｗｗｗgotoアレルギーうぜぇｗｗｗｗｗｗｗ

>>196
もともと人間関係うまくいってなかっただけじゃね？

うちの下っ端で考え無しにgoto使ってるアホがいやがる
うぜぇｗｗｗｗｗ無能下っ端うぜぇｗｗｗｗｗｗｗ

って感じだろ

http://pc11.2ch.net/test/read.cgi/tech/1169473442/553-578 あたりの続き
> 578 ：デフォルトの名無しさん：2008/02/09(土) 17:20:17
> >>570
> ＞556 名前：デフォルトの名無しさん [sage]： 2008/02/09(土) 13:55:24
> ＞まぁさ、例外あるような言語ではgotoいらないかもしれないけど、
> ＞Cとかだと普通に使うよ？
> ＞557 名前：デフォルトの名無しさん [sage]： 2008/02/09(土) 14:28:31
> ＞いや，普通には使わないわ(ww
>
> ここから始まった話題なので、
> 今に限ってはCのgotoの話をしている。pythonは今のトピックにおいて関係なし。
> Cは例外ないから>>558がgotoなしで書けるという話も決着がついてない。
> ここで例外使えばいいという指摘自体が的外れ。
> まあ実際gotoは無くてもいいが、あると遥かリソース開放とかは便利。
> むろんGCとか例外とかがあればそっちのが便利だが。

存分にどうぞ。

あ、setjmp/longjmp使うからgoto使わないわ、というオチは禁止ね。

>>199
リソース解放のためにgotoって、、、不必要に汚ないコードができるだけだろ

>>200
goto使わないともっと汚くなるんじゃない。

まぁgoto禁止の会社で、あらゆるコードが以下のように
なってるのを見たとき、「素直にgoto使え」とオモタ。

do {
　　if (hoge) {
　　　　break;
　　}
} while (0);

>>199で問題になってるコードを天災
はっきり言って呼び出し側で解放したほうがいい典型例。
呼ばれた側で解放したければ、この関数を呼んでから
解放するような関数を書けと言いたい。

> 558 名前：デフォルトの名無しさん [sage]： 2008/02/09(土) 14:35:39
> >>557
>
> そう？ファンクショントレース埋め込むときとか、以下のように
> エラーの場合、リソース開放して戻るときとか頻繁に使うなぁ。
> {
> 　　A *a = NULL; B *b = NULL; C *c = NULL; int result = E_UNKNOWN;
>
> 　　if ((a = A_new()) == NULL) {
> 　　　　result = E_MEM; goto END_FUNC;
> 　　}
> 　　if ((b = B_new()) == NULL) {
> ...
>
> END_FUNC:
> 　　if (a !=NULL && result != E_SUCCESS) {
> 　　　　A_free(a);
> 　　}
> 　　...
> }

continueもある場合は、gotoよりも明確になるように思う。

breakで外側のループを脱出するために、switchで書いたほうが良さげな
内側の多分岐がif/else if/else ifになってたりするとgoto使え、だな。

>>203
関数がエラーで返った場合、オブジェクトに変更が加えられていないことが
保証されるとする場合、それじゃだめやね。エラーが発生したら、まき戻す
処理が必要になる。

>>205
エラーの発生箇所によって巻き戻し方が違うんなら、どのみちgotoでは処理できん。
巻き戻し方が同じなら、goto先で巻き戻すのもreturn先で巻き戻すのも同じ。

と思うのだが。

>>206
>エラーの発生箇所によって巻き戻し方が違うんなら、どのみちgotoでは処理できん。

でもgoto使ったほうがスッキリかけるでしょ。

>巻き戻し方が同じなら、goto先で巻き戻すのもreturn先で巻き戻すのも同じ。

APIの使い勝手が大きく違うじゃない。

>>207
いや、だからさ、APIとしては呼び出す側は何もしなくていいの。
処理とリソース管理を分離して実装しましょう、ってだけの話。
なんで無理にgotoなんて使いたがるのか、ワケワカラン。

>>208
抽象論が多くてわかりにくい。具体的なコード書いて改善してみてくれ。

>>203でコピペされてるコードも全然具体的じゃないけどな。

巻き戻し処理って、本当に巻き戻すのか単にコピーをしておくのかどっちが多いの？
transactional memoryって効率を求めるとすると、なにかしら約束事があったほうがよいんだろうけど。
完全に透過に見える実装にしたいならos側からアプローチしたほうが楽な気もする。

>>210
結局「gotoはダメ！って教えられたからダメダ！」で、思考停止したダケの人なのね。

>>211
>巻き戻し処理って、本当に巻き戻すのか単にコピーをしておくのかどっちが多いの？

場合による。例えば、ある処理が1,2,3,4の順番で実行することがきめられてる場合
（1を実行しないと、2が実行できない場合）、実際に実行して3でエラーが発生したら、
1,2を巻き戻す処理が必要だし。

OS側からのアプローチってどんなアプローチ？

gotoなんて設計に何の影響もない
同一関数内でしか影響のないものによくもまあそんなに熱くなれるなｗ

これ眺める限りさほど奇天烈な使い方があるようにも思えないが。
http://www.google.com/codesearch?q=goto+file%3A%5C.c&hl=ja&btnG=%E3%82%BD%E3%83%BC%E3%82%B9%E3%82%B3%E3%83%BC%E3%83%89%E3%82%92%E6%A4%9C%E7%B4%A2

>>213
>gotoなんて設計に何の影響もない

gotoは設計に影響ないとしても、APIが保障するリソース管理の方針は
大いに影響がある。

下位のモジュールがエラーを返した場合、それ以下のリソースには影響
がなかったことが保障されるのであれば、モジュールは自身の管理する
モジュールを開放すればよいことが保証される。

例外とデストラクタの伝播のようなもの。

んで、Cでそれを実装するには、gotoがいいよといってるわけで。

GCC の labels as value と computed goto を使うと結構豪快に遊べるけどなw

嫌goto厨ってもしかして元N88ベーシッカーが多いのかねｗ

コンパイラ言語で goto を使っても問題ない。
どうせ機械語のジャンプ命令に置き換わるだけなんだから。

ところがインタプリタ言語にとっては goto はパフォーマンスを低下させるやっかいもの。
10 FOR I=1 TO 100
20   FOR J=1 TO 200
30     PRINT "うんこ"
40     IF J=50 THEN GOTO 70
50   NEXT J
60 NEXT I
70 FOR J=1 TO 100
80   PRINT "しっこ"
90 NEXT J
仮にこのようなコードを実行するとしよう（細かいツッコミは無しね）
インタプリタは 10行目で FOR 文に出会い、変数 I と 終了値 100 をスタックに積む
次に 20 行目で 変数 J と 終了値 200 をスタックに積む。
通常は NEXT に出会ったときに終了判定がなされ、終了値に達していれば
FOR をスタックから捨てられる。
ところが 70行目で FOR〜NEXT ループの外に飛び出してしまったため
スタックには先ほどの２つの FOR 変数 I と J が積まれたままになる。
さらに 70行目で FOR に出くわしたインタプリタはどういう振る舞いをするか。
スタックに FOR J が既に積まれていないかを検査し、もしあればそれを捨てる作業が必要になる。
実はインタプリタは FOR に出会うたびに、スタックをすべて検査して、重複していないか
確かめているのだ。
GOTO 文さえなければスタックをすべて検査する必要がなくなりパフォーマンスがいくらか上がるはずだな。

java が goto を目の敵にしているのは、このせい。インタプリタにとって goto は大敵なんか長文つかれた
どうせ誰も読んでないだろなめんどくせぇもうやめたうんこちんちん！

>>207
こういう話ではないの？
別にどっち使ったからと言って使い勝手というかAPIが変わるとは思えない。
これだったら俺も1を選ぶけど。
//その1
void hoge() //外部に公開される関数
{
void *p = malloc(65536);
//ところどころでgoto END;
END_FUNC:
free(p);
}

//その2
static void hoge_impl(void *p)
{
//ところどころでreturn;
}

void hoge() //外部に公開される関数
{
void *p = malloc(65536);
if (!p)
  hoge_impl(p);
free(p);
}

うんこちんちん！
まで読んだ。

>>212 ポカーン 自分では全然的確な例も出さずに認定かい

>>218
まだJavaをインタプリタ言語と呼んでる人がいるんだね。
正直驚いた。

実際にバイトコードインタプリタだったとしても
機械語に翻訳されりゃasmリストのjmpと一緒じゃん。
jmp命令を使えないcpuって不便そう。

結論
goto議論に熱中する奴は生産性が低い

goto :eof

つーか、BASICのインタプリタと、
Javaのインタプリタのレベルを混同してるヴァカが現存してることに驚いた。

Javaのforでスタックなんか使ってねーっての。

>>219
その2のほうさ、管理するリソースが1つだけならまだマシだが、4つも5つも
管理している場合、そのためのサブ関数が4つも5つもできることに
なるわけだが・・・。まぁgoto毛嫌いしている人には、そっちのほうが
ウレピイのかもしれんが。

リソース管理なんてif文一発だろ。
お前らもっとでかいモニタ使えよ。
int ret = 0;
if(init1())
{
　　　　　　　　if(init2())
　　　　　　　　{
　　　　　　　　　　　　　　　　if(init3())
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　　　　　ret = execute();
　　　　　　　　　　　　　　　　　　　　　　　　fin3();
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　fin2()
　　　　　　　　}
　　　　　　　　fin1();
}
return ret;

>>227
そのコードは、俺の頭ではツライ。

意外にも java がインタプリタだという事を知らない人が複数いて驚いた。
「ＪＩＴ」 について、もうすこし学びましょうね。

ほぉ。

Javaのバイトコードで、どういう風にforとスタックが関係するのか、
説明していただけますかね？

Code: Stack=3, Locals=2, Args_size=1
0: iconst_0
1: istore_1
2: iload_1
3: bipush 10
5: if_icmpgt 39
8: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
11: new #3; //class java/lang/StringBuilder
14: dup
15: invokespecial #4; //Method java/lang/StringBuilder."<init>":()V
18: ldc #5; //String line
20: invokevirtual #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
23: iload_1
24: invokevirtual #7; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
27: invokevirtual #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
30: invokevirtual #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
33: iinc 1, 1
36: goto 2
39: return

public static void main(String args[])
{
for(int i=0; i<=10; i++) {
System.out.println("line " + i );
}
}
なんというひねりのないコード。

インタプリタなのはJVMの方でJavaはコンパイラだろ。

public static void main(String args[])
{
try {
for(int i=0; i<=10; i++) {
System.out.println("line " + i );
}
} catch (Exception e) {
System.out.println("boo.");
}
}
にすると
Exception table:
from to target type
0 39 42 Class java/lang/Exception
が追加されて、ジャンプ命令で例外処理の飛ぶ先が決まるんだな。
-ここまで同じ-
39: goto 51
42: astore_1
43: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
46: ldc #11; //String boo.
48: invokevirtual #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
51: return
ただしキャッチしなければパレントクラスに飛ぶというのは例外の普通の使い方。
やってる事自体はあまり変わらないけど、言語が持ってる機構は有効に使ったほうが綺麗になるって感じなのかな？

で、どのように、
BASICインタプリタで起きるようなFOR-NEXTの対応のズレの
ようなことと、関係してくるんですか、と。

（BASICのFOR-NEXTは、FORを実行する時、NEXTにぶち当たったら
戻るためのポインタをスタックに積んでいるわけですが、それに
相当するコードはどこ？）

それに、
あるインストラクションを実行する時点での、スタックトップは
コンパイル時に確定できますよね？

仮にgotoで気ままに飛んだとしても、飛ぶ時に適宜調整すれば
問題ないわけで。

java byte code書いた人とスタック云々の人は別だよw

こりゃ失礼しました m(__

ＣＰＵが java のバイトコードを直接実行していると勘違いしている人が多いですね。
javac ⇒ バイトコード ⇒ インタプリタが実行

よくもまあこんな前世紀的話題を得々と・・・

今のSunのJVMってJITコンパイルしてないの？

>>238
まぁ、新しくプログラミングの世界に入ってくる人たちが、そういう疑問を持つことは
当然というか、ソウであって欲しいものナわけで。「先人達が行ってたから」といって
自分の思考を停止して妄信するよりははるかに良い。

ていうか、釣りだろw

釣りとしか思えないよこのインタプリタ厨。

釣りだ。
gotoのスレでパフォーマンスの話をして、釣れると思っているね

そもそも、大域変数しか使えない言語で「変数をスタックに積むって」ありえるのか？

変数宣言なし＆局所変数なしの言語の場合、変数管理表と戻り先（jump先）管理表を使うのが普通だろ？

>>243
> そもそも、大域変数しか使えない言語で「変数をスタックに積むって」ありえるのか？
>
> 変数宣言なし＆局所変数なしの言語の場合、変数管理表と戻り先（jump先）管理表を使うのが普通だろ？

BASICのFOR-NEXT制御の場合、変数名をタグとして、
FOR x IN ... 〜 NEXT x を対応させる処理系がある。
（NEXTのあとの変数名はreminderで、処理系は無視するものもある）

>>218 が得意そうに解説してるBASIC処理系では、NEXT x の x の
変数名を見て、対応するFORの処理に戻るような処理系なんだろうが、
そのような場合、FORの場所だけでなく、変数名もフレームに覚えておく
必要がある。変数の値じゃなくて、変数名そのものか、ポインタかを
タグとして書いておくわけやね。

じゃあgotoを使うなって言われるのは、
単純にスパゲッティ化するのを防ぐだけじゃなく、
スタックを開放する作業を確実にやるためだったってことだな。

つか今時どうやったら制御構文完備な言語で
goto使ってスパゲッチなコードを書けるんだよｗ

完備ってほどでもないと思うけど。

gotoは悪だ！という宣伝がコレまで続けられてきて、普通のプログラマ
はgotoを使ったスパゲティコードに関して十分知っているわけでしょ。
そういう意味では、goto邪悪論の目標は達していると思う。

それなのに会社のコーディング規約でgotoを禁止するのは、どうみても
自社のプログラマを信用していないとしか思えない。

goto禁止したところで、do { if (hoge) break; } while(0)で、gotoに近いことを
やろうと思えば出来てしまうわけだぜ。そういう会社がやるべきは、社員の
教育であってgoto撲滅では決してない。

条件分岐とループで複雑に作ってもわけ分からんしな。

ゴトーさんが泣いているぞ

おまえは、BLASの後藤か、CINTの後藤か、パラメトロンの後藤か、
なんちゃって。

>>226
その2のほうさ、管理するリソースが1つだけならまだマシだが、4つも5つも
> 管理している場合、そのためのサブ関数が4つも5つもできることに
> なるわけだが・・・。

>>219の2のどこをどう考えればリソース毎にサブ関数が必要になると思えるのやら。
hoge()の中身が増えるだけだろ。
まさかhoge_implのほうがリソース管理してるとでも読んだのか？

>>248
goto邪悪論も有害だが、goto気軽に利用論はもっと有害だな。
あくまで汚ないことをやっているという自覚を持って使うべきだ。

相変わらず曖昧論ばっかりだな

>>252
いや、そうだな。だがしかし4つも5つもリソースがあるばあいはどうすんの。
そもそもその手法じゃダメやん。

つまり>>227のようになってしまうわけだし。依存関係あると。
そうじゃないなら、やっぱりサブ関数をわけて依存関係を
チェインさせる？正気の沙汰じゃないな。

//その2
static void hoge_impl(void *p)
{
//ところどころでreturn;
}

void hoge() //外部に公開される関数
{
void *p1 = malloc(65536);
void *p2 = malloc(65536);
void *p3 = malloc(65536);
void *p4 = malloc(65536);
if (p1 && p2 && p3 && p4)
ret = hoge_impl(p);
if (p1) free(p1);
if (p2) free(p2);
if (p3) free(p3);
if (p4) free(p4);
return ret
}

で何か？

>>257
mallocならいいが、

>例えば、ある処理が1,2,3,4の順番で実行することがきめられてる場合
>（1を実行しないと、2が実行できない場合）、実際に実行して3でエラーが発生したら、
>1,2を巻き戻す処理が必要だし。

この場合はどうする

hoge()の最後でretの中身に応じて必要な回復処理すればいいだけじゃねーの？

>>259
書いてミレヨ

>>260
おいおい、どんな巻き戻しが必要なのか具体的なコードを出すのが先だろｗ

hoge_impl()の返り値にどこまで進んだかの情報を入れ込んでおけばOK

>>261
　　if (A_init() != 0) goto A_FAILED;
　　if (B_init() != 0) goto B_FAILED;
　　if (C_init() != 0) goto C_FAILED;
　　if (D_init() != 0) goto D_FAILED;

　　return 0;

D_FAILED:
　　D_finish();
C_FAILED:
　　C_finish();
B_FAILED:
　　B_finish();
A_FAILED:
　　A_finish();
　　return -1;

>>263
それのどこが巻き戻しのコード？

盛り上がってまいりました

>>263
initが失敗したら、finishでまき戻せると思ってくれ。

//その2
static void hoge_impl(void *p)
{
　　if (A_init() != 0) return A_FAILED;
　　if (B_init() != 0) return B_FAILED;
　　if (C_init() != 0) return C_FAILED;
　　if (D_init() != 0) return D_FAILED;

　　return 0;
}

void hoge() //外部に公開される関数
{
switch (hoge_impl(p)) {
case D_FAILED:
D_finish();
case C_FAILED:
C_finish();
case B_FAILED:
B_finish();
case A_FAILED:
A_finish();
return -1;
default:
return 0;
}

で何か？

もうこねーよ、ｳﾜｰﾝ

そんなコード見たことねぇｗ
goto避ける為にがんばりすぎだなｗ
大体ローカル変数にアクセスできねぇし
いちいち引数で渡しますか。

C++厨のtry/finallyなんていらねぇ！
がんばればclassのコンストラクタ、デストラクタで何とかなる！みたいだなｗ

>>269 御託はいいから、>>226が筋違いだということは理解できたか？

>>269
回復に4つも別々の関数呼ばにゃならんコードな時点で糞ケテーイ

みんな、今271が良い事を言ったぞ！

がんばることある？
大抵のものは誰かがラッパー作っているし、
ないものは確かに作ることもあるけど、面倒ならboost::shared_ptrに任せられるし。

>>269 後出しイクナイ!
ローカル変数うんぬんを言うのなら、A_finishとかが無引数なのはおかしいだろ。

>>273
禿同。こんな事にgotoとか使ってる奴はboost時代に乗り遅れてる。

でも削除子指定できるscoped_ptrほしい。
と思ったらunique_ptrは削除子していできるのか？

>>267
それってさ、一連の処理を分割してしまってるわけだけど、initしてからfinishする
までの処理を。逆にメンテナンスせいが落ちそうじゃない。goto使うよりも。

アホが見ても分かるような用途にしかgotoは使わない。

>>278
アフォが見てもわかる用途って具体的には？

>>277
A_initって名前が悪いんじゃねーかな。
たぶん>>263はA_init()は何か実際に処理をさせたいから"巻き戻し"なんて言ってるんじゃ。
だとするとA_init()はA_proc()と読みかえたほうがいいだろ。
そうすれば>>267は>>208が言うように処理とリソース管理の分離というデザインになる。

>>279
278じゃないけど多重breakとかかな？
多重breakできる言語が少しうらやましい。

それを言うとA_finishも変なネーミングだ

ファンクショントレースもgotoの話題にでてたけど、みなどうしてる？
ftraceコマンドとかあるみたいだけど、どうも共有ライブラリとかの
ファンクションコールをうまくトレースしてくんないのよね。

あぁちょっと調べてみたら、valgrindとか色々ありそうやね。

bool Init()
{
if (!InitHogeGraphics()) {goto FAILED_INIT_HOGE_GRAPHICS;}
if (!InitHogeAudio()) {goto FAILED_INIT_HOGE_AUDIO;}
if (!InitHogeInput()) {goto FAILED_INIT_HOGE_INPUT;}
return true;

FAILED_INIT_HOGE_INPUT:
UninitHogeAudio();
FAILED_INIT_HOGE_AUDIO:
UninitHogeGraphics();
FAILED_INIT_HOGE_GRAPHICS:
return false;
}

こういう使い方もダメなのか？俺的にはスマートな方法だと思ってる
初期化が重なる場合でgoto文を使わない方法って何があるのよ

>>285
やりすぎかもしれんが・・・ｗ こういうのも出来なくはないかもしれない、
気もしないでもない。
InitUninitFunc funcs[] = {
　　{InitHogeGraphics, UninititHogeGraphics},
　　{InitHogeAudio, UninititHogeAudio},
　　...
};

bool Init()
{
　　for (int i = 0; i < NELEMS(funcs); i++) {
　　　　if (!funcs[i].init()) {
　　　　　　for (int j = i; j > 0; j--) {
　　　　　　　　funcs[j].uninit();
　　　　　　}
　　　　　　return false;
　　　　}
　　}
　　return true;
}

>>285
gotoいらないじゃん

>>287
別にgotoなんて無くてもいいんだが、分かりやすいことが重要じゃない？
極論すればwhile()だけで全ての制御構造は書けるわけだし。非常に面倒くさくなるけど。

>>285で、InitHogeAudioの引数の一つがInitHogeGraphicsの結果だったりするみたいな感じで
からみあってたりすると結構面倒くさいんじゃない？

ほら、ここでもinit関数と、finish関数のAPI仕様の統一の必要性がでてきた。

「gotoは設計に関係ない」っていったやつでてこい。プログラムのアマチュア
が設計だけして、実装まるなげは本当に排除すべきだ。

>>287
いやまぁ、さきの例はそれぞれのinitとuninitが関数だからそうだけど、
たとえば単なる値の設定とそれをクリアするのに関数を用意するのはバカらしい。
それならgoto使うとかいう選択は十分にあると俺は思うな。

>>267で結論が出た話を蒸し返してる香具師がいるぞｗ

>290 のように後出しジャンケンばかりやっている奴のコードは仕事に使えん

>>285=>>263

半端なinit/finishを繰り返す時点でダメダメ

>>288
確かにまとめてひとつの関数にすれば数は少なくてすむが、
ラベルの数が多すぎるだろ。

＞分かりやすいことが重要じゃない？
分かりにくいんだよ。
制御が入ると、その制御全部チェックしないといけないだろ。
それ、順番間違ったらそれだけでバグになるだろ。

gotoなしで実現しようとすれば、
ラベルの代わりにフラグ変数を使うことになるだけじゃないか？

--
int ret_code = 0;

ret_code = !(a_init() ? A_FAILED : 0) &&
ret_code = !(b_init() ? B_FAILED : 0) &&
ret_code = !(c_init() ? C_FAILED : 0);

switch(ret_code) {
case C_FAILED: c_rollback();
case B_FAILED: b_rollback();
case A_FAILED: a_rollback();
}

return ret_code;
--

かつ、何らかの事情でinit()やrollback()を同一関数内に
まとめて書く必要がある場合(式でなく文になる場合)
こういうコードは書けないのでgotoするしかない気がする。

見直すと意味不明なコードだが気にするなｗ

>>296
> かつ、何らかの事情でinit()やrollback()を同一関数内に
> まとめて書く必要がある場合(式でなく文になる場合)

どんな状況を言いたいのかサパーリわかりません。
ちゃんとした日本語か、仮でいいからCか、どっちかで書いてくれ。

>>288
これで「わかりやすい」と思うのは書いた本人だけだと思うぞ。

つーか、UnInitって未初期化のことじゃないか
オマエラ本当にマなのか？w

>296 たぶん君は10万行以上のコード書いたことないでしょ。
それにチームでコードを書いた経験もほとんど無いように見受けられる。
素人はgoto避けたほうが身のためだよ。

gotoの代替手段があってそれがgotoより優れているならそうするｗ

でも>>267や>>286みたいに、goto回避を目的としたトリッキーなコードを書くくらいなら
イディオムとして理解できるgotoは素直に利用する方がよっぽどわかりやすい

>267をトリッキーと感じる感性でgotoを濫用されちゃ話になりませんな。

>>298

簡単な例で言えば>>267のコードで
hoge_implおよび*_initをインライン化する必要が出たら
フラグをreturnしてswitchで受けるっていうのは無理だわな、
そんときはどうする？ってこと

>>267はgoto回避のトリッキーなコードというよりも、
APIから抜ける前にチェックを「確実に」入れるための簡単なtipsなのだが。

>>300
Get：UnGetと書くマがこの世に実在してだな…

>>302
IDEでデバッグできる環境なら多少強引でもgoto回避したほうが追いやすいよ。

>>304 具体的に。

>>303
LABELを定義してgoto label するのと
フラグ定数をdefine してreturn -> switch するのと何が違うんだ？

こんな感じかな

for (int i = 0; i < 10; i++) {
　if (x[i] == 0) {
　　goto A_FAILED;
　} else {
　　a /= x[i];
}

for (int i = 0; i < 10; i++) {
　if (y[i] == 0) {
　　goto B_FAILED;
　} else {
　　b /= y[i];
}

return 0;

B_FAILED:
　something
A_FAILED:
　something
　return -1;

意図的に話をループさせて逃げようとしてますな
>>298に>>304で答えたことになると思ってんの？

>>308 >>305

309をgotoを使わずに上手く書くのってどうする？

要望にこたえて>>309に具体的に書いたので、
そちらも具体的なコードでよろしく

関数分割は無しな。
「美しい設計」にしたがって自由にリファクタリングできる業務なら
議論の余地なくgotoなんていらないだろ。ってかそんな環境ならC使わないし。

>>309 いいかげん同じようなコード書くのに飽きてきたよ。

int foo_impl() {
for (int i = 0; i < 10; i++) {
　if (x[i] == 0) {
　　return A_FAILED;
　} else {
　　a /= x[i];
}

for (int i = 0; i < 10; i++) {
　if (y[i] == 0) {
　　return B_FAILED;
　} else {
　　b /= y[i];
}

return SUCCESS;
}

int foo() { //公開されるAPI
switch (foo_impl()) {
case B_FAILED:
　something
case A_FAILED:
　something
　return -1;
default:
return 0;
}

で何がこまる？

どこまで条件の後付けを続けるのかしら…(´・ω・｀)

>>313
お前な、はっきり言わせてもらうと、馬鹿じゃねーのか？

「goto使わずに、関数分割してリソース管理と処理本体を分離する設計にしろ、
そのほうがgotoでスパゲッティにせずにリソースの解放を確実に実行できる。」
という主張に大して「関数分割はなしな」じゃ議論から逃げているとしか
受け取りようがない。

>>314
そのコードが実質的に>>309と何が違う？

>>317 過去ログ読んでろ。自分のレスだけでなく、相手のレスも真摯に読め。
話はそれからだ。

過去ログ嫁は逃げるときに便利な言葉だな。

正直、もう後出しジャンケンのワナビー初心者相手にするのは飽きた。

>319 条件の後付けで逃げてるのはキミのほうでしょ…(´・ω・｀)

飽きたといいつつ、お前は次の奴も相手するよｗ

>>317 過去ログと言わず、自分のレスの1つ前のレスを読んでみたらどうだ？

>>321もしかして僕のレス見て言ってる…？
>>296へのレスだかんね(´・ω・｀)

>>324
もちろん>>319=>>296へのレスだかんね(´・ω・｀)

296はトンヅラを決め込んだようですｗｗｗｗｗｗｗｗｗｗｗカコワリwwwwwwwwwwwww

誰もレスしていないが286が良い設計

>>267が良いコードとされた時代が懐かしいな

なんだ時代は後退してるのか

それを後退だと思うなら後退だ。

時代の最先端のコードは>>285です。

A_init()
A_FAILED
case A_FAILED
A_finish()

ソース上ばらばらなのに意味上は相変わらず密結合
メンテナンス性を悪化させる似非リファクタリングの典型

>>332 よく読むとわかるけど、ソース上の距離は>285も同じなんだよ。
文句があるのなら>285に言ってくれｗ

「処理とリソース管理の分離」を掲げた設計に対して
「ソース上ばらばら」は誉め言葉だよｗｗｗ

hoge_impl()に処理を分割した分だけ距離が離れている
A_FAILEDを別途#defineしなければならない分だけ管理要素が増えている

>>334意味不明

>>335
gotoであちこちのブロックから飛びまくるのに比べれば
> hoge_impl()に処理を分割した分だけ距離が離れている
> A_FAILEDを別途#defineしなければならない分だけ管理要素が増えている
なんて取るに足らない瑣末な問題だな

>>332の日本語訳

意味上の結合を維持したまま、処理本体とリソース管理を分離できている。
メンテナンス性を向上させるリファクタリングの典型

勘違いしないでほしいがgoto版との比較で>>267が駄目だという事ではなく
goto版も>>267もどちらも駄目だということ

公開関数であるhoge()から内部一式全てを一人で管理するような小さなモジュールなら
goto版でも>>267でもどちらでも問題にならないだろう。
そうでない規模ならgoto版も>>267もどちらも簡単に破綻する

意味不明なのは>>267のコードの
どの部分が処理本体でどの部分がリソース管理なのかが意味不明ということ

>>339 それは296にしか答えられない質問では？

>>338
つまり、巻き戻し処理のためにgotoのほうが遥かに便利という、
大元の>>199の引用元の主張は×ね。

initしてrollbackするだけという、中身が何もない例題じゃあなあ

// static void hoge_impl(void *p) {
#define return goto
　　if (A_init() != 0) return A_FAILED;
　　if (B_init() != 0) return B_FAILED;
　　if (C_init() != 0) return C_FAILED;
　　if (D_init() != 0) return D_FAILED;
#undef return
　　return 0;
// }
// void hoge() {
// switch (hoge_impl(p)) {
#define case label
case D_FAILED:
　　D_finish();
case C_FAILED:
　　C_finish();
case B_FAILED:
　　B_finish();
case A_FAILED:
　　A_finish();
　　return -1;
#undef case
// default:
// 　　return 0;
// }

嫌goto厨は早く>>213の実例を全否定してまわる作業に戻るんだ

>>336
あちこちのブロックから飛びまくるのはgotoを無秩序に使う結果

>>267で何かgotoの重要な欠点が解決されたと思う人は
343と267で何が違うのか考えてみればよい

>>345
そうなんだよ。>>343の//で印(w)をつけてくれた部分が重要なんだよ。
あと、#defineの行もミソだね。

こんなつまらんgotoを使わなくても関数で出口を纏めることができるという好例だ。

>>344
嫌goto厨？濫用を嫌う人は何人かいるみたいだけど、
gotoを全否定してる人はいないんじゃない？俺も含めて。

そんなつまらん実装上の理由で関数分割をしなくとも
gotoさえ使えば綺麗にまとまる好例とも言えるな

最近関数内関数なるものの存在を知ったんだけど、
それがあれば「関数を勝手に作れないからgoto使う」って人も、gotoなしでいけるんじゃないかな。

>>347
定石的な使い方すら絶対に許さないと必死になっているように見受けられるがｗ

個人的にはgotoが全面禁止でない限り>>267のようなコードは絶対書かないけどな

適当に書いた。
関数化したくなければブロックで書けば。
処理続行可能フラグとか変かもしれないけど、
戻り値に成功と失敗を返すなら、それをそのままこのブロックの制御に使える。

>>351で参照

// 前処理
flg = true
while(flg){
if error{
flg = false;
break;
}
break;
}

// 主処理
while(flg){
if error{
flg = false;
break;
}
break;
}

// 後処理
return flg;

みす
>>352で参照。

まあ、専用ブラウザならレス番選択して右クリしたら見れる。

なんか必死なgoto厨房ががんばってるな。
実装上の都合と設計上の都合の区別もつかないとは。

まあ俺も>>267みたいなコードはまず書かないけどなｗ

>>352
breakの数が多いのはなんでなんだぜ

必死な嫌goto厨オツｗ

設計云々なら、俺ならgotoを使わないなら最低限こう書く。
hoge_impl()だけ切り出して巻き戻しがベタ書きというのは本能的に気持ちが悪い。

int hoge_init(); // 略
void hoge_process(); // 略
void hoge_rollback(int r) {
　switch(r) { // 略
　}
}

void hoge() {
　int ret = hoge_init();
　if (!ret) {
　　hoge_process();
　} else {
　　hoge_rollback(ret);
　}
}

でも実際goto使うよ。イディオムだろこんなの。

>>357
>hoge_impl()だけ切り出して巻き戻しがベタ書きというのは本能的に気持ちが悪い。

まぁハゲドウｗ

>>357
俺も
> hoge_impl()だけ切り出して巻き戻しがベタ書きというのは本能的に気持ちが悪い。
に禿同。

こんなつまらんことにgotoを使ったりはせんが。
2重breakには使うけどな。

>>355
whileを、breakで好きな段階で抜けられるブロックとして使うため、2度目の実行をしないためにループの最後にbreakを入れる。
これはgotoの代替として普通使ってると思うけど。
まあ、ループしないのにwhile使うのはおかしいって言う人もいるけど。

んで、while 1として無限ループにしたほうが、breakで抜けますよってのを明示できるけど、
flgを入れてみたのは、全体の流れを制御するflgだと明示しつつ、
最後にbreak入れ忘れた場合でも途中でリソース不足とか2度実行のエラーになれば抜けれて安全かなと。

エラー終了と正常終了を分ける場合は、主処理のブロックの最後で、breakじゃなくreturnするかな。
配列から探して何番目かを返すようなのは、エラーとNULLが逆になる。
基本だよね。

参照は
>>361

// 主処理
while(flg){
if error{
flg = false;
break;
}
return flg; // 常にtrueが返される。
}

// エラー処理
return flg; // エラーなのでfalseが返される。

粘着同士のレベルの低い言い争い、おわった？

>>360
なんで do { ... } while (false) にしないんだぜ？

>>237
> ＣＰＵが java のバイトコードを直接実行していると勘違いしている人が多いですね。
> javac ⇒ バイトコード ⇒ インタプリタが実行

バイトコードを実行するのはインタプリタではなくてVM(仮想計算機)だ。
つまり、インタプリタじゃなくてエミュレータな。

バカ亀乙

大域脱出に限りgotoを使うという人はgotoの宛先は常にループ直後?

while (condition)
　while (condition)
　　if (something_wrong)
　　　goto A_FAILURE;
　　else something;

while (condition)
　while (condition)
　　if (something_wrong)
　　　goto B_FAILURE;
　　else something;

return 0;

B_FAILURE: something;
A_FAILURE: something; return -1;

大域脱出のときだけgoto使うよ派が書くとこうなる?

result = 0;
while (condition)
　while (condition)
　　if (something_wrong)
　　　result = A_FAILURE; goto END_OF_A;
　　else something;
END_OF_A:

if (result == 0)
　while (condition)
　　while (condition)
　　　if (something_wrong)
　　　　result = B_FAILURE; goto END_OF_B;
　　　else something;
END_OF_B:

switch (result)
case B_FAILURE: something;
case A_FAILURE: something; return -1;
default: return 0;

またコイツか・・・いいかげんウザ

コミュニケーション能力より技術力の方が大切だと思うので
こういう議論で野次馬からウザいと思われるかどうかは気にしませんｗ

>>363
ああそんなのもあったっけ。
doではじめるとwhileに書き換えられたことがあった。

それはともかく、
前処理に失敗したら主処理を飛び越して後処理ってするとき、
処理する前に判断しないとだめだろ。

それに、break忘れのリスクもあるが、戻り値の初期化忘れっていうミスを防ぐ効果もある。
どちらかというと正常か異常かを錯誤するほうが重大なミスだから
whileよりdoがよいということはないと思う。

あと、エラーなら抜けるっていうまったく同じ目的のためのブロックだから、
前処理も主処理も同じ構文使ったほうがわかりやすいしミスしにくい。

とにかく頭使わずにミスなく書くのが目的だから。

>>371
>とにかく頭使わずにミスなく書くのが目的だから。

そか。俺は頭使わずにミスなく読めるコードを書くのが目的だから
gotoで書く方が読み易い場面ではgotoを使うんだぜ

大域脱出の場合、pythonなら、breakでの脱出とfor文の判断での終了かが
はっきり分けられてるから簡単だよ。

UWSCってマクロならbreak ２っていう、2重ループ脱出命令がある。

結局自分で工夫しないといけない言語と、想定された言語があるんだよね。
そもそも、breakは内部はjmpつまりgotoなんだから受け側をswitchみたいに
自動で分けてくれてれば余計なif文でスペック落としたり、
スペックあげるためにアセンブラ使ったりしなくてすむのにな。

結局、どの言語でも共通の設計でいけるように最小限の文法にしてしまったから使いにくいんだよな。

>>372
それはいいけど>>285みたいなことされても困るんだよ。
あれは関数内でどうせリソースが有効かどうか判断する必要あるだろ。
if hoge { free(hoge); hoge = NULL }
とかな
だったらとび先は
FAILED_INIT_HOGE_INPUT:
FAILED_INIT_HOGE_AUDIO:
FAILED_INIT_HOGE_GRAPHICS:
とか全部いらなくて
FAILED:　一つで足りるんだよ。

飛び先が一つなのは分かりやすいだろ。
そもそも、gotoが分かりにくくなる理由は、飛び元と飛び先に同じラベル名が出てきてどっちからどっちに飛んでるかいちいち確認が必要だからだよ。

>>364
少なくともGNUはインタプリタと呼んでいるようだ。

http://gcc.gnu.org/onlinedocs/gcj/Invoking-gij.html
>gij is a Java bytecode interpreter included with libgcj.

>そもそも、gotoが分かりにくくなる理由は、飛び元と飛び先に同じラベル名が出てきてどっちからどっちに飛んでるかいちいち確認が必要だからだよ。

これは凄い

>>361
こんなコード書くやつがいたら、殴ってしまうかもしれない。ペシペシ

このスレってFizzBuzzすらパスしない奴がごろごろいそう・・・

中身のないコードで空虚な議論
お前らヒマだな

>>263をちょっと書き換え

　　if (A_init() != 0) goto A_FAILED;
　　if (B_init() != 0) 80+0; B_FAILED:
　　if (C_init() != 0) goto C_FAILED;
　　if (D_init() != 0) goto B_FAILED;

こっそりこういういたずらをしていく人がいるんだ。世の中には。
そういうやつと一緒に仕事しなかった人は幸せもん。

携帯開発の軍曹の話は有名らしいが、
あの戦場を生み出すのがこういうことをする人間なんだ。
本当に単なるミスであの地獄が生まれるとか思ってないよな？
ああいうのをやるやつっていうのは、
周りを引きずりおろすことで自分を立派に見せてのし上がろうとする暴力主義のやつら。特に福岡県出身のやつら。

goto肯定論者の俺でもこのスレのgoto厨には賛成できない

流れを読まずに横レス。

GOTO 使わず関数使えというのは、太古の昔、非構造化プログラミングから
構造化プログラミングへのパラダイムシフトが現在進行形だった時代の
いわば「スローガン」だと思います。

時代は移り、今は構造化プログラミングが当たり前の時代です。
そのような現在のプログラマが、私たちの先祖が使っていた GOTO 730 と
関数内部での goto FAILED; を同列に論じてしまうことに
私はいささかの疑問を感じるのです。

> 周りを引きずりおろすことで自分を立派に見せてのし上がろうとする暴力主義のやつら。特に福岡県出身のやつら。

なんだそのビ妙〜な私怨はw

こっそりって。コミットログすら書かないのか携帯の開発は。

>>381
小さい関数ならいいが、ブクブク太った巨大関数の中でホイホイと飛ばれると
読むほうは疲れるんだよ。多重breakとか限定された状況ならまだ許せるけどな。
特に考えもせずにgoto多様する馬鹿にかぎって巨大な神関数をつくりたがる。

>>379
そういうやつと仕事したことないけど、そのコードだとコンパイラ警告
でるんじゃないか？B_FAILEDの行が意味を成していないとか何とか。
擬似コードにつっこむのもあれだが。

>>381
飛び先が一箇所ならいいと思うよ。
>>379みたいないたずらされても、ループするか飛ばすかのどっちかしかないから。
goto FAILED;とかは関数につき1回だし普通は最後に飛ぶだけだし問題になることはないからね。

>>383
証拠が残せるようなシステム使ってないから。

>>382
福岡はそういう地域なんだよ。
完成品チェックって横槍いれて完成してたら強奪。奪ったらパソコン初期化して証拠隠滅。
毎度毎度そればっかり。

完成してたら強奪→正社員
奪われるばっかりの人→派遣社員

いや、別に比喩してるわけじゃなくてね。
社員同士でもそうなんだよ。

それはgoto以前の問題だし因果関係が明らかに逆。

適切に関数分割できない馬鹿だから
巨大関数の中をgotoで飛び回るコードになる。

そういう馬鹿に言うべきは「処理のまとまりごとに関数に分けろ」であって
そいつに「gotoを使うな」と言ったところで
今度は巨大なネストをフラグで引き回すコードを書くだけ。

>>385
B_FAILED の後ろがセミコロンからコロンになっているのに注意。
君はだまされる方だな。

馬鹿？

>>388
きづかなかった・・・ｗ

もしかしてあなたは、そういういたずらをチョコチョコやっているのではな
いかと、疑いたくなってきたなｗ

朱に交われば、なんとやら・・ｗ

>>387
でもこのスレで出てきてるコード読むと、
神関数つくりそうな勢いのコードが目につくんだけど。

昔一緒に仕事したひとで、
「１関数にreturnは1つしか書かない」
という信念を曲げない人がいた。
その人の書いた関数は、最後にラベルがたくさんあってgotoの山盛りだった・・・

ってあれ？デスマーチスレじゃないのか、ここ。

>>393
そいつってオレジャネ？

まさかの運命の再会

でもさ、数行の排他を必要とする関数で

　　lock();
　　if (arg == NULL) {
　　　　unlock();
　　　　return E_PARAM;
　　}
...
　　unlock();

よりも下のほうが好みだなぁ。lock()とunlock()内を関数に分離するのも馬鹿馬鹿しい
ほどの小ささだと

　　lock();
　　if (arg == NULL) {
　　　　result = E_PARAM;
　　　　goto END_FUNC;;
　　}
...
END_FUNC:
　　unlock();
　　return result;

一方、俺はfinallyを使った。

>>397
Cなんだよ、ﾊﾞｰﾔﾊﾞｰﾔ

某スレより

569 名前：デフォルトの名無しさん [sage]： 2008/02/09(土) 16:46:29
>>566
try finallyは例外を捕まえるための機構であって、ファンクション
トレースのための機構ではない。

デストラクタでロギングするほうがよっぽどスマート。try finally
に依存したロギングよりも。そしてアスペクト指向のほうが
デストラクタロギングよりももっとスマートだといっているのだよ。

finallyって例外つかまえるための機構？
例外以外にもreturnとかでも呼ばれるんじゃないの？

C++厨かよ

gotoはダメだって言っているやつって、
ループ内break、continue、関数の途中のreturnとかもダメだと思ってるの？

>>402
少なくともこのスレではそんな主張をしているレスは見あたらないね。
で、それがどうしたの？

そもそもgotoはダメだという主張自体が見当たらないのだが。
できるだけ避けろ、とか、濫用するな、ってのはあるようだがな。

>402は脳内敵をプロファイリング中でーす

gotoを書く奴はスパゲティコードを書くという前時代の妄想で脳内敵を作り上げているのはどっちだか

重要なのはgotoを使うか使わないかじゃなくて
ちゃんとコードレビューしろよってことだ

>>400
> 例外以外にもreturnとかでも呼ばれるんじゃないの？

正確には、フレームが巻き戻されるのをトラップする機能。
それを利用して、例外のハンドリング(catch)や、後始末の処理(finally)の機構が
実装されている、という表現が正確。

その「できるだけ」とはどこまでなのかという議論をしていたんじゃ？

>>407
修正箇所だけのコードレビューとかなら確かにうまくいくけどさ、
何万行のソースコードをレビューで全部網羅するって、
全然うまくいったことがないな。みんなどうしてるのだろ。
ペアプロとかのがよさそうだけど、やったことないや。

ルール：gotoを使っている関数はコードレビューの対象とする

>>411
ごめん、俺「関数のreturnは必ず一箇所でやる」ポリシーもってるから、
全部レビュー対象となる＾＾

>>412
＾＾と書いているが俺が去年やってたプロジェクトだと笑い事じゃなくて実際そうなる。

具体的に言うと、gotoを使っている関数は
フローチャートおよび詳細な動作説明をドキュメントとして準備してコードレビュー。
もちろんそういうドキュメントを用意してレビュー会で説明するのは実装者。
承認となった場合もドキュメントは保管。

なので濫用する奴なんか自然といなくなる。
誰も濫用しないから何万行のレビューなんてのも実際は発生しない。
無問題。

goto使ってる関数だけって、、、
あほらし。

if と if and only if の区別も付かない奴か。

>>414
それだけだとgoto濫用防止だけだけど、ホカにはどんなルールをきめてるん？

>>414
それとさ、組み込み系だとファンクショントレース機能があるICEとか
結構効果なのだけどさ、それも全開発者に配布？

結構効果なのだけどさ→結構高価なのだけどさ

>>417
あれこれ言ったら個人特定されるでしょ

単純なのは、一関数が一定の行数を超えたらとか
for文で()の中に書く内容が「普通じゃない」とか

ちなみに>>412の理由だけでgotoを使った場合はレビューで却下だよ。

>>420
世の中にドレダケぷろじぇくとまねーじゃが存在しているのか考えれば、
あなたがやっていることと同じようなことをやっている人は無数にいるから、
特定なんてされないと思うぞｗ

>>421
じゃあ先に君の関わったプロジェクトで採用されていたルールを教えてくれ

>>420
「普通じゃない」とかの基準で、資料作成させられて説明させられる
プログラマかわいそすｗｗｗ

もうちょいまともな基準作ったほうがイインジャナイ？

んーとね。いちいち説明しないとわからんかな。

何が「普通」かは実際には定義されているの。ここでは書かないけど。
簡単に言えばループ変数の初期化、終了条件、増分を普通に書くのが普通

>>423
説明するのが手間になるようなコードを書くほうが悪いと思うが。

>>424
「なにが普通か」の基準をきめるための努力は世の中に一杯あって、
基準めいたものもあるんじゃない？

>>425
え〜だって、俺様基準で「普通じゃないから」っていわれて、「フローチャート」
まで用意させられるのだぜｗ

>>427
フローチャートはgotoの場合じゃないの？
forの場合には何かトリッキーな式を書いた場合に
そのトリッキーな式がなぜ必要なのかを説明する
ドキュメント＋プレゼンとかそんな感じだと思うが。

>>427
俺様標準じゃなくて、一応条件が示されてるらしいぞ。
まあ俺には関係ない話だからどうでもいいと言えばどうでもいいが。

gotoに拘る人間に100ｋ行以上の開発蓄積のある人間はいない。

1m行ならわからんでもないがさすがに100k行くらいは新人以外誰でも書いてるだろ

好意のは時代を超えて無内容さが変わらないものだな

>>430
goto厨のコードを読めば、それは明らかだな。

>>431
1本の開発で一人100k行、の間違いじゃねーの？

そかも

goto使ったら詳細資料を用意しなければならないって、
使いたいとこでも使えないじゃねぇか。開発効率悪そう。

>>436
goto使うだけの理由があればそれを書けばいいんじゃないの？
処理の流れをちゃんと把握できていればフローチャートだって
簡単に書けるし。

それとも実装ドキュメントの類いを一切書かない人？

>>429
いやさ、その根拠が多くの開発者が納得いくものであればいいが、
「goto使ったら、フローチャート描かせて、説明させる。」っていってる
ようなやつが、まともな基準を示せるとは到底思えないのよね。

フローチャート書ける程度のショボイ処理ならgotoいらないだろ

>>436
わかって使っている人にとってはその通り。
ただし、こういうレビューの目的の半分は、
将来そのコードの面倒を見る他社のために実装資料を残すこと。
それが、大人のマナー

>>437
だからさ、goto使うだけでフローチャート書けっていってるのは、
基準が曖昧すぎるといってるのよ。別にgotoが適切な場合もあるし、
そうでない場合もある。whileが適切でない場合もあるし、そうで
ない場合もある。

そんなこといってたら、すべてのプログラムにたいして全部
フローチャート書けという事になるわけで。

フローチャート（笑）

他社とは限らないな。自社の別チームでも何でも。
要するに、今の実装チームが未来永劫メンテするわけじゃないということ

>>443
せめてさ、世の中に「メンテナンス性が高いプログラム」を判別しようとする
努力があって、そのための基準が研究されている事実くらい勉強した上で
そういうこといったほうがいいんじゃない？

goto使ったらコードレビューだ！とかじゃなくてさ。

可読性の定量化なぞ不可能さ。
管理面でどうしても何かしたいならば。
goto使用許可を出せる権限を
誰かに付与すればイイんじゃね？

>>441
gotoは他の構文要素と比較して、適切に使われない場合が多いという
共通認識があるからこそ、このスレも成立していると思うんだが。

適切なgotoもそうでないgotoもあり、適切なwhileもそうでないwhileもある。
だから全部やるか何もやらないかどちらかにしろ・・・では物は作れない。
現実的な判断として、かけるコストを回収できる効果があるかどうか。

というのが常識として書いていたが、考えてみればここはマ板でなく
ム板だから学生や研究者も当然いるのか。

>>446
いや、あなたがいままで言ったような判断基準より、ましな判定基準を
提供するツールはあるし（商用、フリーかかわらず）、そのことすら
知らないまま、ぷろじぇくとまねぇじゃぁをやるのは周囲を不幸にするよ、
といってるだけだけど。

>>444
浅学にして知らなかった。ポインタを示してもらえるかな。
研究者ではないので、俺はそういう勉強は足りないと自分でも思う。

ところで、俺はそういうプロジェクトに開発者として関わっていたのだが
どこからプロジェクトマネージャという誤解が発生しているのかな

コードレビューするのは結構なことだが、
くだらない決まり作って、くだらない作業させるようなプロジェクトは、
メンバのモチベーションも低いだろ。

>>448
とりあえず「複雑度」でぐぐってこいｗ

人の意見に文句だけいって自分は何も提供しない人って周囲のモチベーションさげるよねｗ
他の人、自分のかかわってたプロジェクトではどうだったのさ。
最低限そのくらい言ったら？

>>452
お前は、ナニサマナンダ

>>451
情報感謝。そういえば、そういうのも何か使ったことはあった。
ただ、そのプロジェクトだと単にビルド時に出していただけで、
それがどう使われていたのか知らない。値が高くても低くても特に何もなかった。

その値に適当な閾値を決めてレビューとかやればいいのか？
実際にプロジェクトでどういう運用がされていて、効果がどうだったのかとか、
そういう感想もあれば是非

これ以上ないくらいスレ違いだな

>>454
閾値はあるていどキビシ目にきめたほうがいいが、実際にレビューするか
どうかは、閾値が異常な値を示しているコードがバグを良く出すとか、
新規作成のものであるかとかいう事情を加味して考慮したほうがいい。

安定して動作しているモジュールを閾値より外れているから、といって
リファクタリングしたところで新たな不具合を生み出すだけ。
目的を見失わないようにしながら、やればいい。

しかし複雑度の計測もマダマダであって、あくまで一つの参考にしか
ならないが。

こないだ、goto文が使われているコードを
昔作ったものから持ってった。　キー入力の評価だから
これ以上重たくしたくもない・・・というところ。

select 文二重＋if文の底から出るのに breakを掛けるのは・・・

世の中のプロジェクトは、まだまだ、リーダーとかマネージャとか上司とかの
「コーディング規約」（訳：俺の理解できない　しんきのう　は使うな）
が支配的なのな。

分野によるが、多人数が関る（新人やアホが混じりやすい）プロジェクトでは必須
MISRA-Cとか

MISRA-Cってどの程度使われてるのかね

それはさておき、MISRA-Cを適用するような分野に
新人やアホが混じってるというのはガクブルだな

MISRA-Cは、新人やアホがまじらないための基準という意味では
まぁ有効だが、そういうやつがいない現場にとっては、無駄な
足かせにしかなっていないという矛盾がある。そして、そういうやつ
が混じらないようにする努力というのは経営陣の仕事であって、現場の
規約を固めるのはあまり意味がない。

ミスを防ぐための基準が、よけいに複雑なコードを生み出して、
逆にミスを生み出してしまうような矛盾が今のMISRA-Cにはある。

そういうやつがいない現場の数のほうが少ない

結局、まじめに処理構造を見直すのがマンドクセからgoto使うんでしょ。
gotoマンセ君は多人数での開発経験がないんじゃねーの？

C覚えて2-3年程度のアマチュアが「goto、ヤベーw」とはしゃいでるだけ。

>>463
gotoを使ったほうが可読性が高い場合に遭遇したことが無いね？

基本文献はクヌースのStructured Programming with go to Statementsですかね。
あと、このへんで、
ttp://www.cmagazine.jp/src/kinjite/c/coding.html#index32
gotoと同じくらいダメとされている手を、gotoを避けるためだけに
使ってないか？　というのは良い指標かと思う。

>>465
もちろんあるけど、しっかり考えれば考えるほど少なくなっていくよ。

>>466
break, continueがだめって書いてあるやつ、
使わなかったとしたらどう書く？
ちょっと想像つかない。

ちなみにこういうやつ書いたんです。
エラーはエラーなんだけどエラーの種類によって動作を変えるってやつ。
コードの参照は>>469


for i = 0 to 2
IE.navigate(str)
REPEAT; sleep(0.1); UNTIL !IE.busy AND IE.readystate = 4

// エラーページチェック
errortitles[4] = Status(ID, ST_TITLE)
for e = 0 to 4
ifb 1 <= Pos(errortitles[e], errortitles[4]) Then
select e
case 4 // エラーがなければ続行する。
break 2
case 0 // 接続エラーなら規定回数試行する。
sleep(2)
continue 2
default // その他エラーならエラー終了する。
SendSTR( メモ帳, errortitles[e] + "<#CR>", 1, false, false )
IE.navigate("about:blank")
result = false
exit
selend
endif
next
// ここには来ないはず
msgbox("エラー判定ミス")
exitexit
next

ちなみに>>469のエラーチェックを関数化したやつもあるけど、
エラーの種類ごとに動作を変えるとしたら、
結局呼び出し元でswitchでそれぞれの動作をしないといけない。

>>468
breakやcontinueの乱用がだめという話で、
きちんと制御構造がわけるような書き方なら問題ないのでは。
実際List37の例はひどいものだし。

>>461
ベテランプログラマだけのユートピアを作るのが経営陣の仕事だぁ？

アホか。

アセンブラ上がりのPGだが、JMP系述語＋スタック使わないで
処理できて速い方法とか、日々そんなことばかり考えてる。
メンテナンス性以前に、論理的整合性が失われて美しくないから
なんて話は、俺の頭には何のことかさっぱりわからない。

ルール：ソースは美しくなければならない

美しくなくとも。簡潔で軽妙ならば

>>472
新人は情報学科出身で、かつ優秀じゃなきゃイラネ

>>469
何段抜けるかを数字で書く多段breakって糞じゃね？

>>469
こんなソースを新人が書いたら、確実に書き直させるな。

まずもって文法が意味不明なのでとりあえず C 風に書き下してみた。

for (int i = 0; i < 2) {
　IE.navigate(str);
　do {
　　sleep(0.1);
　} while (IE.busy || IE.readystate != 4);
　errortitles[4] = Status(ID, ST_TITLE);
　for (int e = 0; e < 4; e++) {
　　if (1 <= Pos(errortitles[e], errortitles[4])) {
　　　switch (e) {
　　　case 4:
　　　　goto BREAK;
　　　case 0:
　　　　sleep(2);
　　　　goto CONTINUE;
　　　default:
　　　　SendSTR(メモ帳, errortitles[4] + "<#CR>", 1, false, false);
　　　　IE.navigate("about:blank");
　　　　result = false;
　　　　exit;
　　　}
　　}
　}
　msgbox("エラー判定ミス");
　exitexit;
CONTINUE:
}
BREAK:

>>479
途中で、読む気がうせた

VBでもないし何かと思ったらUWSCって何だ
厨房スクリプト言語？

ひとまずコード＊だけ＊読んで、前提条件あんま読んでないけど

>for (int i = 0; i < 2) {
「2回」ループする意図が良くワカラン。下のコード読めばわかるかと思って、
読もうとしたが、途中で挫折。

>　IE.navigate(str);
>　do {
>　　sleep(0.1);
>　} while (IE.busy || IE.readystate != 4);
IE.readystate==4だけじゃだめなのかな。IE.busyじゃないときだけ、readystate
が有効になるのか。ならIE.readystateが-1ならbusyとかしたほうが、
"while(IE.readystate!=4)"だけですむしわかりやすい。

>　errortitles[4] = Status(ID, ST_TITLE);
errortitles配列の、5番目にいきなり代入してるのが、なんじゃらほい。0〜4番目は、
どうなったのだろう？

>　for (int e = 0; e < 4; e++) {
>　　if (1 <= Pos(errortitles[e], errortitles[4])) {
このへんと、下をちょっと見た段階でギブアップ

余計なものを全部省いて構造だけ残すと、たぶんこう。

void f() {
　while (some_condition()) {
　　something();
　　for (int e = 0; e <= 4; e++) {
　　　if (some_condition(e)) {
　　　　switch (e) {
　　　　case 4:
　　　　　goto BREAK;
　　　　case 0:
　　　　　goto CONTINUE;
　　　　default:
　　　　　return;
　　　　}
　　　}
　　}
　　exit(-1);
CONTINUE:
　}
BREAK:
　something();
}

>>483
やっぱりだめだ・・・こういう感覚を説明して理解してもらえるかわからないが、
そのコードは「普通」じゃない。読むのがすごいシンドイ。

で、俺ならこう書く。
頭の中でしか動かしていないので合ってるかどうかは自信ないが。

void f() {
　int state = 0;
　while (state == 0 && some_condition()) {
　　something();
　　state = check_state();
　}
　if (state == 4) {
　　something();
　}
}

int check_state() {
　for (int e = 0; e <= 4; e++) {
　　if (some_condition(e)) {
　　　return e;
　　}
　}
　exit(-1); // not reached
}

まだ、ｊａｖａ はインタプリタじゃ無い、って言ってるヤツがいるみたいだけど。
中には、インタプリタじゃ無い、ヴァーチャルマシンだ、とか
もっとひどいのになると、エミュレータだ、とか、もうメチャクチャ言いたい放題・・・
ちょっと呆れたな。
これって、「モモヒキじゃ無い、スパッツだよ！」って言ってるオバサンと同じじゃん。

>>485
あぁなんとか理解できる。サンクスｗ

せっかくだから俺からも一つネタ投下。
>>485 のf()と下のコードはどっちが良いと思う？

void f() {
　while (some_condition()) {
　　something();
　　switch (check_state()) {
　　case 0:
　　　break;
　　case 4:
　　　goto END_WHILE;
　　default:
　　　return;
　　}
　}
END_WHILE:
　something();
}

>>488
俺は>>488のほうがわかりやすいｗ

>>488
case 4:でsomething呼び出して
returnしてしまえばもっと見やすいと思うが。

(ﾉ∀`) ｱﾁｬｰ

977 デフォルトの名無しさん[sage] 2008/02/13(水) 00:31:00
forループのネスト構造（２重）から一気に脱出したい時に、breakだと１重しか脱出できないので困ってます。
PHPではbreak 2;みたいに書くと２重のループから脱出できるみたいなんですが、C++で同じことができる方法はありますか？
goto文はなるべく使いたくないので……。

980 デフォルトの名無しさん[sage] 2008/02/13(水) 00:50:26
>>978
ググった時に「大域脱出するとき例外処理で〜」とか書いてあるのを見たのですが、それでしょうか。

>>979
表を描くために座標をネスト構造で回しているのですが、
描画する要素がなくなったら外に出すっていうようにしたいんです。
大人しくflagにしたほうが良いですね……。ありがとうございました。

>>491
コピペもウザイが、意図もよくわからんぞｗ

(ﾉ∀`) ｱﾁｬｰ

984 名前：デフォルトの名無しさん[sage] 投稿日：2008/02/13(水) 01:55:45
>>981
後で困りそうですがもっと単純に解決させました。
ループ部分だけクラス内で別のメンバ関数にして飛ばして、抜けたい所でreturnさせました……。

>>479
× for (int e = 0; e < 4; e++) {
○ for (int e = 0; e < 5; e++) {

>>482
＞ 「2回」ループする意図
ADSLで瞬間的に切断される場合、数秒後に再度アクセスしたら接続される場合があるので。

＞IE.readystate==4だけじゃだめなのかな。
やり方をググってまねしただけなんで。

＞5番目にいきなり代入してるのが、なんじゃらほい。
終了フラグです。
まあいいやり方じゃないけどエラーを拾う判定がちゃんと働くかテストにもなるしと入れてみた。
代入してるのはウィンドウタイトル。
あと、ループはループだけ、判断は一箇所にすると、制御が単純でわかりやすいなと思ったんだけど、
forを抜けて「ここには来ないはず」と書いた場所でbreakすればいいだけだった。

もともとが長いスクリプトだったからdefaultをexitで抜けてなかったんで
そんときのループ構造が頭にあって。
やっとすっきりしたと思ったんだけど見直せばもっとシンプルになるもんだね。

>>486
釣りいいかげんうざい。
あのね、じゃあ具体的にあんたが主張するBASICのようなコードを
JavaVMのバイトコードで示してみやがれっての。できなきゃ去れ。
二度と来るな。

>>486
せめてJavaVM実装の書籍を1冊でいいから読破してから言え、マヌケ。

まあ多重break/continueは可読性を落とすね。gotoのほうがナンボかマシ。
多重break/continueもgotoも無いのがベストつーか常識だけどｗ

>>494
> やり方をググってまねしただけなんで。

やっぱりね…
そういう姿勢だからbreakでもgotoでも汚ないコードになるんだよ。

JavaVMのハードウェア実装を知らないんだろうな、>486は。

JVMについて盛り上がっている人がいるようだが、
どのJVMのことだ?sunか?

>>500
特定の実装の話じゃないと思うが。つーか、吊りか？

ハードウェア実装？

荒らしはスルーで > 兵共

picoJava のことじゃまいか＜ハードウェア実装

Jazelleとか。
一部ソフトウエアで実行するけど。

いずれにせよBASICインタプリタとは大分違う罠

>>498
勝手な思い込みで変更する馬鹿よりましだよ。

ぐぐったら出てくるけど、作業をしているか通信をしているかをチェックするんだって。
通信が完了してから作業をするだろうけど、作業が新しい通信を要求するかもしれないだろ。
どんな流れになるかはWebサイトの作り次第だし、テストするには通信帯域を制限したり・・・

コードの流用するならそれが確かに動くかテストするべきだが、
自分でテストできないなら基本的には信用することが必要だ。

busyだけだとフレームのページで途中で抜けちゃうって話がどっかにあった。
まあレイアウトが自由にできる今はフレームなんか使ってないだろうけど。
ReadyStateだけの場合は↓。
つまり両方のチェックが必要。

http://hpcgi1.nifty.com/MADIA/VBBBS2/wwwlng.cgi?print+200510/05100089.txt
IEオブジェクトで読み込み完了まで待たせるのに以下のコードで待たせてますが、
ちゃんと読み込み完了まで待ってくれません。

どのようにすれば確実に待たすことができますか？

Do While IE.ReadyState <> READYSTATE_COMPLETE
DoEvents
Sleep 1
Loop

これならうまくいきました。
Do While IE.Busy = True Or IE.ReadyState <> READYSTATE_COMPLETE
DoEvents
Sleep 1
Loop

>>507
> コードの流用するならそれが確かに動くかテストするべきだが、
> 自分でテストできないなら基本的には信用することが必要だ。

唖然・・・
おまえみたいのはgotoを絶対に使うべきじゃないし、
そもそもプログラミングをするべきじゃない。

同意

>>509
なに俺様は完璧とか言ってんの？

そもそもコードは、誰が書いたものでも信用できない。

自分自身が書いたコードすら信用できないorz

「try 〜 catch」 を使おうが、「for/while 〜 break ラベル」 を使おうが、
汚いスパゲッティ・コードはいくらでも書ける。
たとえば、フラグ変数作って、break break break break 連発するヤツがいい例。
goto 使うやつに比べれば、「do 〜 while (false)」 や 「switch 〜 break」 を使うなど、
トリッキーなコード書いて得意満面になってるキチガイよりよっぽどマシだ。

要するに、「コードの美しさ・汚さ」と、「goto 使うな」 論は無関係。プログラミングの芸術的センスの問題だよ。
java、php、ruby そのた、言語によって大域脱出の仕方が違うのは
どの方法が正しい・優れているという基準が無いからで、どの言語作者も頭を悩ませている問題なんだろう。

goto の何が問題なのかと言えば、インタプリタやコンパイラの内部処理の都合上、
パフォーマンスを低下させる要因になっているから。
特に while(・・・) {・・・} みたいに { } ブロックを多用する言語は、goto で ”あらぬ方向” へ脱出される事を極端に嫌う。
これは { } によって確保したスタックの管理がくずれるから。
ここらへんは実際に目には見えない部分なので、なかなか理解が難しいと思う。
自分でインタプリタやコンパイラを作ってみれば経験できる事なのだが、いまどき、そこまでするヤツはおっとまた
字数制限がうざいなもっと長文書ければいくらでも語れるんだが続きはまた暇なときにでも。うんこちんちん！

長文とかどうでもいいからベンチの結果ひとつでも(張|貼)ってくれ

無茶言うなよ。java と basic と php とベンチで比べて何の意味がある？

>>514
> これは { } によって確保したスタックの管理がくずれるから。

今時、そんなソースコードにべたべたのインタプリタなんて珍しいわ。

コンパイラや、ソースコードを一回全部なめて、内部構造に
するようなインタプリタなら、ローカル変数のアクセスのために、
処理系はスタックの現在のオフセットを常にわかっている必要がある。

だから、ジャンプ元とジャンプ先でスタックのオフセットがずれるなら、
そのぶんをジャンプの直前か直後に調整して終わり。難しい話じゃない。

Javaのバイトコードを示していただきたいなぁあなたにも。

（あ、Rubyのブロックはクロージャだから別物ね）

gotoでforループの中に飛び込もうとするコードを
はじめて見たときはびっくりしたわ

というかスタックの奴等こっちでやれ。goto関係ないし。
http://pc11.2ch.net/test/read.cgi/tech/1188688416/l50

>>514はN88BASICでﾌﾞｲﾌﾞｲ言わせているビルゲイツ

MS-DOS版N88日本語BASIC(86)コンパイラー

ﾅｹﾞｰ

このすれは「どうして１たす１は２なの？どうして？どうして？」って言いそうな連中ばかりだな。

コンピュータの気持ちになってみると 1 + 1 は 10 です

>>523

ここでコンピューターの気持ちで会話してきてください。
できれば↓のスレの書き込みの翻訳してくれるとありがたい。

1101011 1100001 1101001 1110111 1100001
http://pc11.2ch.net/test/read.cgi/prog/1201423463/

goto師はどこいった

回線の問題というか、pingでtimeoutでまくり

>>518
コーヒーふいたじゃねーかｗ

どんなコードかちょっと気になるｗ

直接gotoを使ってはいないが、
ループの中にswitch-caseで飛び込むコードって奴があるな。
Duff's device でググると出てくる。
(CGの人ならPorter-Duff operatorのDuff氏とか言うと、へーとか思うはず)

do {　　　　　　　　　　　　　/* count > 0 と仮定 */
　*to = *from++;　　　　　　　/* to がインクリメントされていないことに注意 */
} while (--count > 0);

これを、下のようにして最適化か。こう書いてコンパイル通る
ことすら知らなかったわｗ

しかし昔memcpy実装させられたとき、条件判定へらす努力したり
ワード単位でコピーしたりしたんだが、標準で用意されて
いたARMのlibcに速度が遠くおよばなくて愕然とした記憶があるなｗ

switch (count % 8)　　/* count > 0 とする */
{
　case 0:　　　　 do {　*to = *from++;
　case 7:　　　　　　　 *to = *from++;
　case 6:　　　　　　　 *to = *from++;
　case 5:　　　　　　　 *to = *from++;
　case 4:　　　　　　　 *to = *from++;
　case 3:　　　　　　　 *to = *from++;
　case 2:　　　　　　　 *to = *from++;
　case 1:　　　　　　　 *to = *from++;
　　　　　　　　　} while ((count -= 8) > 0);
}

どのみち、天才の考えることは凡人には理解できないのでメンテ不可ですわ。

>>514
いいからJavaVMの実装本を読めって。
自分がどんなに時代遅れな発言をしているか
よーくわかるから。

>>514
> goto 使うやつに比べれば、「do 〜 while (false)」 や 「switch 〜 break」 を使うなど、
> トリッキーなコード書いて得意満面になってるキチガイよりよっぽどマシだ。

日本語に訳すと、
1+1を3と言うやつに比べれば、2+3を6と言う奴や3+1を2と言って得意満面に
なっているキチガイよりよっぽどマシだ。

といったところか。そんな>>514に良い言葉を教えてあげよう。
目糞鼻糞、どっちも糞。

今老舗特集やってるけど、昔からの技術をそのまま受け継いで応用することで普通の工業機械では作れないものを作れてるってさ。
確かに技術は進歩してるし、クソなコードは多いが、よい結果を出しているものはよい方法かもしれない。

紙すきのでやってたけど、手作業を機械でやることで品質の安定したものを大量に低コストにやってるが、
技術の開発は道具こそ工夫するものの人間が手でやっている。

プログラミングで自動化機械といえば、ソースコードのコンパイルとかスクリプトでの作業。
機械設備はコーディングをサポートしてくれる開発環境とかライブラリ。
そういうのを駆使して効率よく新しいものを作るのがプログラマの仕事。

決まりきったやり方が正しいのか最適なのかたまには見直してみるのもいいが、
基本はそれをまねしてやることだ。

何もかも完璧に分かってないといけないとか言ってたら時代の波に飲まれておしまいだ。

>>533
先人のコードをまねることは大切だ。
だが、自分のプログラムに応用する時には
そのコードをしっかり読んで動作を理解してから。
これができない奴はプログラムを書くべきではない。

つーか、>>494、かなり必死だなｗ

>>534
習うより慣れろだ。
正しいか間違ってるかは、うまくいくかいかないかで判断しろ。

ひょっとして、>>469がうまくいってる例だと思ってる？ まさかな。

まあ、少なくとも元のコードの動作を理解できるまでは、
それを使ったコードを人様に見せるのは止めたほうがいい。

>>536
> 習うより慣れろだ。
> 正しいか間違ってるかは、うまくいくかいかないかで判断しろ。

仕様に照らして、な。
「実は実装依存」なコードを量産されるよ？

>>529
そりゃmemcpyがコンパイラに組み込まれてたんじゃね？
そういう場合、libcのmemcpyは関数ポインタ取るためだけに用意されている。

>>537
しっかり動いてますが何か。
テスト済みですが何か。

論破されて窮地に追い込まれると、
「関係ない話は別のスレでやれ」 とか
「〜の本を読め」 とか言って相手を囲いの外に追いやろうとする
典型的な厨房の集うスレはここですか？

>>539
コピーするサイズに応じて、最適なコードをそれ専用に生成するってこと？

>>540
動けばいいと公言する奴のコードに限って実は動かないんだよ。
どうせ自分で何回か使ってみただけなんでしょ？
これだから、ゆとり世代は・・・

>>540
まさかとは思ったが、本気で>>469がうまくいってる例だと思ってるのか。
このスレのgotoを恐れずに使う兵共にとっても>>469は糞コードだぞ。

>>543
「動く」と胸を張っていえるからリリースするもんだろ。
それが動かなくなるのがバグだろ。
バグに遭遇したことないやつが存在するんなら確かにそういえるかも知れんな。

gotoの弊害はむしろ保守性の低さだろ

自分だけが使う書き捨てのプログラムなら別に>>469の糞コードでも良し

>>545
それがさあ、「動けばいい」って奴はロクなテストやってないのが相場なの。
大抵、自分の手元の環境で数回から数十回動かしてエラーが出なきゃＯＫって程度のテスト。

特に最近のゆとり君は適当にググってきたコードをコピペするからひどい。
何故動くのか理解しないまま数回動かしただけで「動きました」とか言い出す。
もうアフォかと。

>>547
テストしてないのを問題視するのはいいとして、テストもせずに駄目出しするのもどうかと思うが。

>>547
テストしてないのを問題視するのはいいとして、テストもせずに駄目出しするのもどうかと思うが。

>>548 テストしていないものは駄目出しされて当然だろう

>>550
テスト済みと書いてる字が読めないならプログラム組むな

>>551
へー、どんなテストしたの？
ちゃんと異常系までテストした？

>>552
どんな異常だよ

例えば
>>494
> ＞ 「2回」ループする意図
> ADSLで瞬間的に切断される場合、数秒後に再度アクセスしたら接続される場合があるので。

のあたり、実際に切断された場合の回復処理で正常にアクセスできたことを
切断時間などを変えながら複数の状況でテストしたのかい？
切断された後、一旦回復してすぐまた切断される状況は？

>>469って、「多重continue、ヤベッーw」なワナビー風味だね

>>554
再表示で接続できることは経験的に知っているし、
規定回数全部で接続できなかった場合でもエラーで中断するし、
中断した場合も呼び出し元からやり直すだけだし。

回復して切断したらって話だが、
REPEAT; sleep(0.1); UNTIL !IE.busy AND IE.readystate = 4
これを実行した後には、接続できたかできなかったかのどちらかしかない。
もちろん不完全な取得を完了とした場合、その先で実行できないってだけだが、
実行できなかった場合も呼び出し元で再チャレンジするし。

>>556
つまりテストしてないわけね。よくわかった。

>>557
自分で切断はしてないけど切断があったことはログでチェックしてるよ。
　

>>558 切断時間はちゃんとカバーされてるのか？

おまえら、テストしたかどうか以前に>>469は一見して糞。以上おわり。

>>559
２回続けて失敗する現象はなかった。
昨日だったか２ｃｈ鯖にアクセスできなくなってたが、その場合そもそもここまで処理が回ってこないし。

>>560が手本を見せてくれるそうです。

>>556
結局わけわからん部分は「呼び出し元で再チャレンジするから」なわけね。
だったら2回ループ回さなきゃいいのに。中途半端なことするから可読性が落ちる。

>>562
前の処理がせっかくうまくいってるのにそれを無駄にすることはないだろ。
接続エラーになったからって前の処理をやり直したら、そっちまで接続エラーになるかもしれないだろ。
これは普通にブラウザ使ってたら分かる話だ。
試行回数とインターバルは経験的に、感覚的にだ。

>>563
つまり自分が使っていた環境のことしか考えていないし、
テストも自分の普段の環境から出ていないってことね。
なるほどね。

>>542
・インライン化の恩恵を受けられる。
・人手で最適化されたコードを吐いてくれる可能性がある。
・ポインタの型によって(intptr_t)pの値が最初から
ワードの倍数になっていることを保証できる場合がある。

>>564
待ち時間は秒数で指定してあるし。
IE使ってる時点で使用環境は固定されてるし。

しかしつまらんスレだな

もういいから
gotoの話じゃないならよそでやれ

direct threaded code

gotoを一行足りと書かなくても、
容易にクラッシュしてデバッグすらできない環境があって・・・。
助けてくれ orz.

>>570
それははたして環境のせいなのか？

異常系のテストは、まずは、そういう状況をわざわざ作り出して確認するもんだ。

>>566
> IE使ってる時点で使用環境は固定されてるし。

回線まで固定されるわけじゃなかろう

>>568
このスレはgotoを語るスレではなくて
finallyや多重breakを語るスレなのでは。

>>563
> 試行回数とインターバルは経験的に、感覚的にだ。

ひでえ根拠だなｗｗｗ
うちに配属になった新人がこんなコード書いたら
即刻今のコードを完デリさせて最初から書きなおしだ。

インマルサット・インテルサットに積む電話交換機屋からブラウザアプリ屋まで
入り乱れての乱戦になっておりますw

キャプテンも忘れないであげてください

「テスト済み」なんて堂々と言うからだ。
テストっていうのがどんな物かわかってたら簡単に言えないもんだ。
そういう意味では「ポインタは理解してる」に似てるな。

と、釣りっぽくまとめてみる也。

ポインタのややこしいのは、ポインタじゃなくて宣言の方だからな。

一応鯖に負荷のかかる土日流しっぱなしにして想定した全部のパターンでうまくいくのは確認してるし
自動でかかる連続投稿規制とアクセス規制と、さらに管理者からのアクセス規制を受けるまでやって、
そーゆー規制食らった場合にも適切に処理できるのは確認済み。

んでえらそうに語ってくれる人がどういう方法でどこまでのテストを要求してるのか知らんが、
サーバーまで自分で作ってるわけじゃないって事を分かっているのかいないのか・・・。
自分でできる範囲ってのは回線を切断したり接続したりだ。

ちなみに、ほとんどの場合は回線の異常じゃなくて、２ｃｈ鯖がただシカトしてただけだった。
自分のプロバイダまでのpingは30msで失敗しないけど２ｃｈ鯖は120msくらいかかってそのうち１回くらい失敗しまくり。

あと、エラー判定が実は正常なのを異常と判断する場合があるのは最初から分かってる。
完璧に自動で判断することができないんだからしょーがない。

>>565
あぁ・・・そりゃ勝てなくて当たり前かｗ
トンクスｗ

後出しの多いやつだな・・・

単体テストと運用時のつなぐ相手のテストとの違いを
子供に理解させるのは無理だろう。

ほうほう。
単体テストってのは１行１行テストすることを言うんですかそうですか。

な。
無理だろｗ

あんな短いコードをあれ以上どう分割しろと

「単体テスト」でググレカス

>>580
結局は自分の環境でしかテストしてないと。
しかも普通に使っていただけで積極的に
様々な状況を設定したわけでもなし。

そういうのはテストとは言わないんだよ。

自分で設定しなくても実際にすべての場合で実行して結果を出してるんだからテストされてるだろ。

単体テストしろとかすべての環境でテストしろとかお前ら馬鹿かと。
たかだか数行のコードテストするために何十個もパソコン用意しろって？

>>584
ﾜﾛﾀ

だから一度「単体テスト」でググってから物言えカス

単体テストもせずに「テスト済み」かよ…こりゃダメだ。

新たな爆弾発言が出ました。
>>589
> 実際にすべての場合で実行して結果を出してるんだから

すべての場合だってさ・・・意味わかって言ってんのかね。んなわきゃないか。

レオン最高
マチルダかわいい

>>586は>>587が自分に言ってる事もわかってないに100ガパス。

IEを単体でテストできると思ってる馬鹿が多いな

ちなみに
+offsetが抜けてデータ構造が変わっていたやつは単体テストで出てきそうなもんだが、
実際には総合テストしないと出てこなかったな。
http://pc11.2ch.net/test/read.cgi/prog/1192192069/

>>596
単体テスト用のサーバ立ち上げて、
サーバ側でわざと切断したりレスポンスを変えたり、
外部仕様のカバレッジや実行パスのカバレッジが得られるような
パターンでレスポンスさせるもんじゃないの？

単体テストにIEは関係ないだろ・・・

>>596
テストする対象はIEじゃなくて糞スクリプトなんですが。

つまりIEと同じメソッドを持つダミーのオブジェクトでテストしろってことね。

>>598
そのテスト環境は既に結合テストの範疇だな。
サーバーつないだら単体テストにならないだろ？

結論：「テスト済み」なんて簡単に言うなってこった。

>>602
いや、結合テストは実稼働のサーバとの接続でやるものでしょ。
実サービスではなく糞スクリプトのテストのためのレスポンスをする
サーバにつなげるのなら単体テストの範疇と思われ。
まあ、スタブを使うようなもんだ。

>>602
> 結論：「テスト済み」なんて簡単に言うなってこった。

同意。

それにしてもマチルダかわいい。

昔、うちに監禁してた少女は死んじゃったから代わりが欲しいな・・・（冗談）

それはそうと、ぼろいビルの屋上でスナイプの練習してるけど、
周りはもっと高層なビルがたくさん・・・
ライフルが丸見えです。
僕も屋上セックスしてたら隣のビルの専門学校から丸見えでばればれだった。

>>603
ああ、そういう意味なら納得。
つまりそのサーバーはテスト用に設定した動作をするってことね。

４９日連続稼動しないとバグが発覚しない某アレの例もあるからねぇ・・・

>>400付近の遠いレスだけど、おまえらそもそもデストラクタロギングが
どんなのかしってるのか。

class TRACE {
　　TRACE(char *funcnamne, ...) { cout << log... <<endl; }
　　~TRACE() { cout << log.. <<endl; }
}

とかよういしといて、関数に下のように書くだけだぞ。tryもfinallyも
いらない。スコープぬけるときにデストラクタが呼ばれて、
かってにロギングしてくれるから。

void func {
　　TRACE trace("func", ...);
　　...実体...
}

>>608
クロージャがエスケープした時にはどうすんの？
finallyならクロージャがエスケープしようが例外が発生しようが
ちゃんとロギングできるわけだが。

>>608
それは言語依存でしょ。
フルGCな言語や処理系だとスコープ抜けた直後にデストラクタが叩かれる保証はない。

>>609
てか、そもそもC++にクロージャなんてものあったけか

>>611
ないけど、このスレはC++限定じゃないでしょ？

じゃぁtryもfinallyも前提に出来ないだろ、すべてコード上にログを
書くしかない。ならgotoまんせーだな、ファンクショントレースには。

>>613
C++限定じゃないがC限定でもない。
JavaでもPythonでもJavaScriptでもＭｏｄｕｌｅ-3でもアリじゃないの？

CとC++のみが漢の言語

>>614
わかった。じゃぁまずは、「デストラクタロギングさん、馬鹿にしてすいません。
tryとfinallyを使ったロギングなんてクソです」といえｗｗｗ

そういえばC言語のswitchはbreakで抜けるブロックだったな。
他の言語ではifの拡張だから普通にbreakでループが抜けれるから
>>469みたいなselect breakはおかしく見えちゃうんだな。

デストラクタでロギングできる言語よりも
finallyでロギングできる言語のほうが多いだろうな

そもそもfinallyに比べてデストラクタでロギングする
メリットが見えないのだが

>>616 ワケワカランｗｗｗ

C++厨がファビョりました

>>618
>そもそもfinallyに比べてデストラクタでロギングする
>メリットが見えないのだが

おまえバカだろ？

C++にfinallyが無い理由を考えろ

finallyロギングは使うたびにfinallyブロックごとコピペする必要がある。
デストラクタロギングなら変数宣言だけコピペすればよいので、
finallyロギングよりコピペ量が少なくて済む。
その点ではC#/VB.NETのusingも次点でまあ使えると俺は思う。

ロギング以外にも言えることだけど。

aspect 最強説

粘着アスペルガー最狂

うちのご近所さんたちが次から次にご近所さんを殺しまくったのは、
多分年金を全部懐に入れてて、いざ受け取ろうとしたら一円も受け取れなかったから、
「ばれたら仕方がない」って殺しまくったんだろうな。

>>623
その程度の利点かよ・・・
finallyだってマクロ一発じゃん・・・アフォらし・・・

>>613
なんだそりゃギャハwwwwwwww
オマエ、もうちょっと色々な言語、できれば現代的な言語を勉強しろよｗｗｗ

Aspect指向なんてどうでもいい。
CLOSのbefore-afterさえあれば十分。

おまえら朝っぱらから元気だな。
で、俺も>>623以外のデストラクタロギングのメリットを知りたい。

デストラクタロギングはどうも間接的すぎて気持ち悪い。
つーか、そのうちオブジェクト解放のタイミングが変わったら
とたんに使えなくなるような。
トリッキーではないが正道でもない方法に見える。

スクリプト厨の次はデストラクタ厨かよ
勘弁してくれ

急激に誰もいなくなった。
決算期前の需要で皆忙しいのかな。

>>627
マクロが使えるなんていい環境ですね。

とりあえず、仕様の表明の不十分なコード片を書くのはやめてもらいたい。
読まされるほうはたまったものではない。

>>634
読まなければ、いいじゃねーかｗ

たしかにｗ

>>529
このコーディングがC言語が生まれて１０年後くらいに発見されたとかwikiに書いてあるけど、
C言語作るときにこの書き方を想定して作ったからC言語ではswitchをbreakで抜ける仕様になってるって分かる人いるかな。

>>637
全く意味がわからないな。
switch を break で抜けられる全部の言語で >>529 が書けるなら信じてあげるよ。

>>638

>>637の言う
> switchをbreakで抜ける仕様
って、fall throughのことで、
ttp://www.catb.org/jargon//html/F/fall-through.html

breakが無いと、次のcaseが現れても抜けない仕様、という
ほうが正確かな。

複数のcaseをうまく利用することができる、という特性を生かす趣旨が
ある仕様ということはわかるけど、ループと組み合わせるという技は
発見された、としてもいいんじゃないかと思うけど。

>>633
君のところじゃboostも使えないのかい？そりゃ可哀想に。

むしろ開発者の一存で、boostが使えることが少ない

デストラクタでログ取ると、ローカル変数のトレースを取れないんだよね。

>>642
トレースしたいローカル変数より後にロギング用の変数を宣言するのはダメ？
リリース版でログを取るのでなければ、boost::formatとか使わなくても
printfベースの実装で十分だと思うし。

>>643
トレースの対象がオブジェクト（またはその属性）の場合は？

昔、
goto aho:
...
{
int baka;
...
aho:
...（bakaを使う)
}

ってやったら、bakaを確保せずにいきなりahoに飛ぶコードを吐かれた(MS-Cかな？）。
それ以来gotoは完全封印

>>639
fall through だけじゃダメだと思う。
「case は switch 直下に無くても文法的に正しい」 って仕様が含まれている必要がある。

C は case 〜 をそれ以外の単なるラベルと同列に扱うという仕様になっているから、
「>>529 のように switch 直下ではなく while の中に case を書いても正しく動く」
ということが後になって発見（正確には”確認”）されたんじゃないかと。


ところで、ふと java の仕様見たら
http://www.y-adagio.com/public/standards/tr_javalang/14.doc.htm#35518
思いっきり >>529 が書いてあるし。

>>640
え、C++だったの？
627でfinallyって言っているからC++はないと思っていたんだけど。

>>644
テンプレートで超がんがる。
DebugLogger d("%d %d\n", &var, std::make_pair(obj, &A::func));

>>645
そんな入れ子の外から飛び込むのは、どんな言語の場合でも
自殺行為に近いだろ。　入れ子の外で定義が終わってれば
別だがね。

Ｄｏで始まるループなんだけど最初の1回だけ途中までは飛ばしたいときってあるよね。
多分そういうときに使ってるんだと思うけど、
普通はなんとかする。

goto使いたがる厨房は局所的な制御ばかり見て全体的な構造の見直しをしない、と、燃料注入w

C言語の仕様としては>>645みたいなのはどうなってるのか、詳しい人教えてよ

少なくとも変数の場所は確保されてるべき。
(最適化でレジスタに割り当てられると見た目じゃわかんないけど)

goto foo;
{
　int bar = 44;
foo:
　printf("%d\n", bar);
}

で 44 が表示されるべきだったかどうだったか調べてみる...

647はfinallyの処理系依存実装を見たことないのかと

>>652
同じ関数内のループに飛び込んでるだけだろ

>>652
普通の実装ならブロックローカルな変数も関数呼び出した時点で
スタックに領域確保するんじゃねーの？

>>651
gotoは「局所的な制御」にしか使わないから。
そして「構造」は「常に全体が対象」だ。

燃料としては不足だ。

>>657
> gotoは「局所的な制御」にしか使わないから。
> そして「構造」は「常に全体が対象」だ。

もちろん>>651はそれが前提で書いていると思うが？
全体を見ずに局所だけを見ているからgotoを使いたがる
というのが>>651の趣旨だと思うが。

>>658　んじゃ。
全体を見て局所も見ていればgotoを使いたがらない。
という命題は正しいのかい？

>>659
それは言語の設計思想によるんじゃないかな。
goto前提な言語なら自然とgoto使うことになるし、
goto原則使わないのが前提な言語を使っていて、
かつ、全体の構造を考える習慣がついていれば、
gotoが必要っぽい状況になったら自然と全体の
構造を疑う方向に目が向くと思うよ。

gotoを使いたくないだけの理由で構造を変えるのは、本末転倒にならないように気をつけないとな。

gotoが必要になるのは全体の構造がおかしい兆候なのではと疑うのと、
gotoを使わないだけの理由で全体の構造を変えることとでは
天と地ほどの差があるけどな。

紙一重だろｗ
構造を見直したい程gotoが気になるなら、まず
設計に対する姿勢から疑わないと。

かわいそうな>>663には見直すことと疑うことの違いがわからないらしい。

初心者向けの指標としては有りだろう。

>>664 無駄だって、相手はgotoを使いたいという結論が先にある人なんだから。

>>664は見直したら必ず変更しなくちゃ行けないと思ってるらしい。

わかりやすい自作自演をみた。

>>665
> 初心者向けの指標としては有りだろう。

gotoを使いたがるのは初心者が多いという意味で賛成だ。

>>667
そんな君の発言「紙一重」ｗｗｗｗｗｗｗｗｗｗｗｗｗ

疑うことと構造を変えることを紙一重と言っちゃってるからねえ
かなり苦しいんじゃないの？

燃料に引火しちゃったようで、ナイーブなgoto厨さんwwwwwwwwwwwwwww

>>669
そういう意味での賛成は遠慮させていただく。

「どうしてもgotoが必要な場面になったら、構造を見直してみよう」
のようなアドバイスは、初心者向けにはいいかもしれない。
終端条件やデータ構造を見直したら、もっといい方法がみつかるかもしれない。
けれど、そのgotoが適切だと思うなら、見直す必要もない。
gotoはあくまでもきっかけとして、である。

クロージャとかlambdaが欲しいな、と思いながらgotoを書く事もある。
goto（と飛び先のラベル）の場所が適切なら、問題ない。

自演醜ス・・・

なんでgotoについて語るのに構造のことまで持ち出すんだかが
全然わかんない。論争根源の論文の
http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF
と同様なネガティヴキャンペーンにしか見えないぞ。

問題ないと言ってgoto乱発する馬鹿は
他人のgotoまみれコードを保守した経験がない
ビギナーさん

>>676　ぐちならマ板行でな。

自演認定したがる奴が自演常習者

↓次はsageで同意、と。

まさか「gotoを使う人間は使いたいから使う」などと思っている人はいないよね？
gotoつかう人は「goto使ったほうが良い」と判断しているから使うんだけど。
gotoを使わずに簡潔に書けるならば、好き好んで使ったりはしないよ。

ちぃ、はずしたか。

>>680
> gotoつかう人は「goto使ったほうが良い」と判断しているから使うんだけど。

その判断が狭すぎるという話じゃなかったのか？

goto厨は視野狭窄ということがプログラミングだけでなく議論においてもそうだということが証明されましたな

存在しない相手に対して勝利宣言か・・・

>>680
ああそうさ。必要も無いのにgoto使うというのはたしかに判断が狭いということだ。
これは開発担当のスキルの不足を反映しているのに過ぎない。
この問題の根源は開発担当に対するスキル管理の不足／欠如だよ。
悪いのはgotoやgotoを使ったプログラムやgoto使った人間では無いことを確認したいわけよ。

だけどgotoの使用判断は開発担当の職掌さ。
どのようなロジックにおいてもgotoを使わないほうが優れているという証明が出来ない限り、
goto禁止ルール自体は不当なルールだと言いたいね。

>>682
だた。失礼

プログラミング言語を作るときには、
徹底的にgotoを使わなくて済むようにしてほしいね。
多重breakをできるようにしたり、try-catch-finallyにデストラクタを用意したり。

それはJavaだ

美しいgoto文だって書けるのに。
汚いgoto文を見ただけで、「goto禁止」は、まりにも短絡的すぎ。
for〜continue〜break文にせよ、do〜while文にせよ、if文にせよ、try〜catchにせよ、
ネストしまくりでワケワカラン汚いコードを書くヤツは、そこらへんにウヨウヨいる。
いったいどうやったら、構造化言語をここまで汚く書けるのか、もう信じられんほど。
なのになぜ、goto「だけ」がこれほどまでに差別されなければならないのか。
・・・ま、そこらへを書くと、またキチガイが湧くんでホドホドにしとくが。
美しく書けばgotoは害では無い。これは確か。

>>685
とりあえず、モチツケ。
無条件goto禁止、については合理的な理由の説明は無かったはずだ。

それはわかるけど、現実は汚いgotoを書く奴が9割9分。
goto禁止したところで、そのうち9割くらいはフラグ付きwhileとか結局スパゲティを書く気がするけど。

>>689
gotoには「最後の手段」の側面もあるからね。
gotoとラベルの置き場所の自由さっぷりは両刃の剣なわけで。

で、自由奔放にgotoを使いまくってるコードを最後にみたのは何時なんだ？
なんかもう脳内事例で語ってるようにしか見えないんだが。

例えば、Linux kernel ではエラー処理に飛ぶためのgotoをいっぱい使ってるけど
全然読みづらくない。こういうgotoは全く問題にならないし、
Cで綺麗にエラー処理を書こうとしたらああならざるを得ないと思うけどな。

>>691
人格攻撃は生産的じゃない。もっと実になる議論をしようや。

ｇ○ﾋo　きたないgoto

肯定派
多重ループからの抜け出し、エラー処理、リソースの開放で定型的に使うならありだろ。
gotoを避けるというのを関数分割のタイミングにするのは馬鹿らしいし。
大体goto使ったが為のスパゲッティコードなんて大昔の非構造化BASIC以来見たことないぞ。

否定派
goto駄目。絶対。goto使う奴はコードが汚く低能！

>>696を読んでいるとgoto厨の視野の狭さがよくわかるという罠www

Linux kernelのソースクオリティを高いなんていう香具師の言うことは、
その程度の扱いを受けて当然だな。

構造を見直してもっといい設計にすれば使わずにすむgotoがあるという話と
gotoを自由奔放に使いまくるという話の間にはずいぶんと開きがあることに
>>693が気付く時は来るのだろうか。。。（遠い目

そもそもgoto絶対禁止なんて主張してる香具師、このスレにはいないと思うが（藁

%sのソースクオリティを高いなんていう香具師の言うことは、
その程度の扱いを受けて当然だな。

絶対禁止はないよな。
ただ現存する用法すべてに盲目的にケチつける奴がいるだけでｗ

>>702 そんな香具師いるか？
つーか、そもそも現存する用法すべてのリスト、このスレに挙がってるのか？

setjump, longjump だって綺麗に書きさえすればいい。

poor man's continuationか。
まあ使えばいいんじゃない？

goto厨は、なんかもう脳内事例で語ってるようにしか見えないんだが。

>>698
まぁまともな会社で、まともな品質のプログラムがかけるプログラマでも
Linuxのソースクオリティで書けるプログラマなんて少ないけどな。

>>704
ナイ、ナイ

時代は変わったな。
Linuxカーネルの可読性の低さはBSDハッカーの格好の標的だったのに。
今じゃLinuxカーネルが高品質と言われるようになったか。。。（遠い目

具体例には例外なく難癖つけるくせに
そう指摘されるといや、そんなことないよとごまかす嫌goto厨。
もう年相応の趣味を持てずただリアルでの孤独を癒す為に宗教論争スレに常駐してるだけみたいだね。

>>708
Cのマクロで例外処理を実装するような使い方はきれいなsetjmpの使い方だと思う。

>>710 goto厨は、なんかもう脳内事例で語ってるようにしか見えないんだが。

>>705
なるほど、poor man's continuationね。確かにそうかも。

まぁ継続なんて、使わんよ。

>>711
Cで例外つっても、単にジャンプすればいいだけじゃなくて、それ以外にも
C++でいうデストラクタの処理とか色々必要になるわけで。setjmpはつかわないわ。

Linuxカーネルでのgotoの使い方の話なのに、Linuxカーネルのコードの
クオリティの高さに話を逸らしてるお馬鹿さんがいますね

Linuxカーネルの可読性の低さの話なのに
無関係だということにしたい人がいますね

>>715
どうせマクロなんだからfinally実装しちゃえばいいじゃない。
NSAutoreleasePoolみたいに「暇なとき始末してね」と予約しておいて、
早めに開放したい資源(ファイルディスクリプタとか)を利用した後や、
イベントループのように定期的に戻ってくる場所で開放する手もある。

>>718
そんな難しいことできるわけないだろ
お前実装してみろよ

だいたいgotoダメって行ってるやつは、
3年目くらいで、やっとできるとまわりから認められ、
ちょっと自信が付いてきたやつ。
後輩に教える機会も増えて、得意になって、よく分からんくせに
中途半端な知識でものを語ってるんだろ。
gotoの話なんて、もう十何年も繰り返されてるのに。

もう十何年も繰り返されていてもまだgotoにしがみついてる厨房がいるねえ

3年目の先輩に頭ごなしに教えられて反発してるビギナー君の登場です

これまでの傾向

-嫌goto厨の主張はいつも抽象論の域をでない
-抽象論でgotoを否定するだけで、「おえらいさんが言ってただろ？だから従え」
　という傲慢な主張しかない
-goto肯定派の具体的な例に関しては、「構造的に考えれば、とか、構造を再度
　検討しなおせば」とか、これまた抽象論でしか返さない。

要するに、嫌goto厨の主張なぞその辺の学者のタワゴトにしかすぎず、
なんら実務面の利点を示しているわけではない。

スパゲッティコードは絶滅したと思っている人必見。>>469
こんなコードを書く香具師がgotoを使ったらどんな恐しいことになることか。

>>723
goto厨の提示したソース、どうにも実務的なのはないのだが。
あるというのならアンカーで示してくれ。

これまでの傾向

-goto厨の主張はいつも抽象論の域をでない
-抽象論でgotoを肯定するだけで、「おえらいさんが言ってただろ？だから従え」
　という傲慢な主張しかない
-goto否定派の具体的な例に関しては、「実用的ではない、とか、
gotoでも害がなければ」とか、これまた抽象論でしか返さない。

要するに、goto厨の主張なぞその辺のワナビーのタワゴトにしかすぎず、
なんら実務面の利点を示しているわけではない。

>>723にも>>726にも禿同
ようするに目糞鼻糞

GOTO 1

goto厨ってなんだよ。
goto使ったらダメとにかくダメって言ういかれぽんちに、
んなわけねーだろって言ってるだけだろ。

>>729
せいかい＾＾

ごとーさんがお怒りですよ

>>731
だれ？

俺

見やすかったらどっちでもいいよ

>>719　でけた。TRY〜END_TRYの中からreturn出来ないけど。
typedef struct ex_handler_rec_ ex_handler_rec_;
struct ex_handler_rec_ {
    ex_handler_rec_ *volatile prev_;
    jmp_buf jbuf_;
    const char *volatile ex_type_;
    void *volatile ex_data_;
};
ex_handler_rec_ *volatile current_handler_ = NULL;

#define EX_ABBREV(x) x
#define TRY { \
ex_handler_rec_ EX_ABBREV(ex_handler_); \
int EX_ABBREV(need_rethrow_) = 0; \
if (0) BREAK_TRY; /* mandate finally clause */ \
EX_ABBREV(ex_handler_).prev_ = current_handler_; \
current_handler_ = &EX_ABBREV(ex_handler_); \
if (setjmp(EX_ABBREV(ex_handler_).jbuf_) == 0) {

#define BREAK_TRY goto EX_ABBREV(break_entry_)
#define RETHROW goto EX_ABBREV(rethrow_entry_)

#define CATCH(extype) \
} else if (!extype || !strcmp(extype, EX_ABBREV(ex_handler_).ex_type_)) { \
   void *EX_ABBREV(ex_data) = EX_ABBREV(ex_handler_).ex_data_;
#define CATCH_ALL \
} else if (1) { \
   void *EX_ABBREV(ex_data) = EX_ABBREV(ex_handler_).ex_data_;

#define FINALLY \
} else { \
   if (0) goto EX_ABBREV(rethrow_entry_); /* supress warning */ \
EX_ABBREV(rethrow_entry_): \
   EX_ABBREV(need_rethrow_) = 1; \
} \
EX_ABBREV(break_entry_):; \
if (current_handler_ == &EX_ABBREV(ex_handler_)) /* no exception */ \
   current_handler_ = EX_ABBREV(ex_handler_).prev_; \
{

#define END_TRY } \
if (EX_ABBREV(need_rethrow_)) \
   throw_exception(EX_ABBREV(ex_handler_).ex_type_, EX_ABBREV(ex_handler_).ex_data_); \
    }

void throw_exception(const char *ex_type, void *ex_data) {
    ex_handler_rec_ *handler = current_handler_;
    current_handler_ = handler->prev_;
    handler->ex_type_ = ex_type;
    handler->ex_data_ = ex_data;
    printf("throw_exception %s\n", ex_type);
    longjmp(handler->jbuf_, 1);
}

こういう風に使う。EX_ABBREVマクロを再定義することでTRYのネストができる。
TRY {
#undef EX_ABBREV
#define EX_ABBREV(x) a_##x
    TRY {
        if (cond)
            BREAK_TRY;
        throw_exception("hoge", cond2 ? "abc" : NULL);
    } CATCH("fuga") {
        if (a_ex_data) /* throw_exceptionの第二引数はEX_ABBREV(ex_data)に入る */
            printf("%s fuga\n", (char *)a_ex_data);
        else
            RETHROW;
    } FINALLY {
        printf("inner finally\n");
    } END_TRY;
#undef EX_ABBREV
#define EX_ABBREV(x) x
} CATCH("fuga") {
    printf("fuga %s\n", ex_data);
} FINALLY {
    printf("outer finally\n");
} END_TRY;

きめぇぇぇぇ

具体例なんて、普及しているオープンソースのコードを引っ張ってきて
grep goto すりゃ見つかるだろ。

return 時に実行してくれない finallyに何の意味がある？
あと、for,whileなどのループ内では、このマクロは使えないね。
(BREAK_TRY のあと、ループ脱出条件を再度判定してbreak文を実行しなきゃならない：二度手間)

>>725
2chは行数制限があるから実用されているコードを貼るのは無理だね。
アンカーではなくポインタは示すので、あとは自分で調べて。
# apache が実務的なコードでないという奴はいないよな？

$ grep -r -n goto httpd-2.2.8/server
httpd-2.2.8/server/vhost.c:717: goto bad;
httpd-2.2.8/server/vhost.c:747: goto bad;
httpd-2.2.8/server/vhost.c:754: goto bad;
httpd-2.2.8/server/vhost.c:904: goto found;
httpd-2.2.8/server/vhost.c:916: goto found;
httpd-2.2.8/server/mpm/netware/mpm_netware.c:421: goto got_listener;
httpd-2.2.8/server/mpm/winnt/child.c:954: goto shutdown;
httpd-2.2.8/server/mpm/winnt/mpm_winnt.c:871: goto die_now;
httpd-2.2.8/server/mpm/experimental/event/event.c:1140: goto worker_pop;
httpd-2.2.8/server/mpm/worker/worker.c:882: goto worker_pop;
httpd-2.2.8/server/mpm/prefork/prefork.c:614: goto got_fd;
httpd-2.2.8/server/mpm/beos/beos.c:560: goto got_a_black_spot;
httpd-2.2.8/server/mpm/beos/beos.c:562: goto got_fd;
httpd-2.2.8/server/util_xml.c:58: goto read_error;
httpd-2.2.8/server/util_xml.c:79: goto read_error;
httpd-2.2.8/server/util_xml.c:88: goto read_error;
httpd-2.2.8/server/util_xml.c:93: goto parser_error;

>>741
おいおい、今さら提示しても遅いって。>>723に
> -goto肯定派の具体的な例に関しては、「構造的に考えれば、とか、構造を再度
とか
> なんら実務面の利点を示しているわけではない。
とか書いた時点で、じゃあgotoの実用的かつ正しい使い方というのは
どんな具体例があったんだよって話なんだから。

goto肯定派曰く「何も考えずにgotoを使う奴などいない」
goto否定派曰く「全てのgotoが駄目だという奴などいない」

であれば、肯定派否定派など互いにレッテルを貼っているだけで不毛な言い合いだな。
「どういう場合にgotoを使うのか、使わないのか」という具体的な議論にこそ意味があると思うが。

>>742
linuxカーネルの話は723よりも前に出ている。

ま、くだらない貶しあいには興味がないので具体例で。
vhost.cの最初の3つはこういう構造。

static void fix_hostname(request_rec *r) {
　...
　if (rv != APR_SUCCESS || scope_id) { goto bad; }
　...
　if (r->hostname[0] != '[') {
　　for (dst = host; *dst; dst++) {
　　　if (apr_islower(*dst)) { ... }
　　　else if (*dst == '.') { ...; goto bad; }
　　　else ...
　　}
　}
　...
　return;
bad:
　...
　return;
}

自分は>>744のgotoの使い方は特に問題がないと思う。見やすい。

gotoを使わずにより良いコードを書ける人は代案をよろしく。
「744のように端折られると詳細がわからないから書けない」という言い訳はなしな。

「本物」のコードへのポインタは>>741にある。必要なら本物を見てくれ。

それから、一つだけ。

抽象的な言い合いの間は散々吠えておいて、
こういう流れにされると何もいえなくなる人へ。

「お前はgotoを使うな」

vhost.cの下2つ(L904, L916)はこの関数。

static void check_hostalias(request_rec *r) {
　処理
　for (ループ条件) {
　　処理 // この部分に、条件を満たしたらcontinueというコードがある
　　if (判定条件) goto found;
　　処理 // この部分に、条件を満たしたらcontinueというコードがある
　　if (判定条件) goto found;
　}
　return;
found:
　r->server = s; // この一文のみ
}

これはごく単純なgotoの例。多重ループでも何でもないが、使わない人フラグを立ててbreak?
r->server=s; return;を二箇所に書くという書き方も、二箇所程度ならありかもね。

>>744
bad:
...
return;
な部分をマクロにしちゃえばgotoなんて使う必要ないんじゃ？

mpm_netware.cでの使われ方

for (ループ条件) {
処理
do {
処理
if (条件) goto got_listener;
処理
} while (ループ条件);
continue;
got_listener:
処理
}

>>749
goto got_listenerが一箇所なら
if (条件) {処理; break;}で済む問題だな。
複数箇所なら処理をstatic関数にすればいい。
そもそも「処理」ってくくれるぐらいまとまってるんだろ？

ちなみにこうやって具体的なコード片で議論しても
全体の構造うんぬんの話の検証にはならない。
というか、むしろ局所的な制御しか考えてないと
goto慎重派に言われても仕方ないことになるが。

このパターンは条件がどんどん後付けされるのでは？
過去何度かあったろ。いいかげん気付け。

今度のパターンは条件を後付けする必要ありません。
次から次へのgrep gotoした結果がタレ流されるパターンです。
1つの例にレスがついたらその議論を先にするのが礼儀というものだが
このスレのgoto厨は無視してひたすらgrepを続けます。
それがgotoクオリティ。

>>750
>そもそも「処理」ってくくれるぐらいまとまってるんだろ？

いや。got_listenerの後の処理は長い。
do whileで条件を満たせなかった場合はcontinueするという意図のコード。

>>751
そうか。

>>752
ならばコードを読め。>>741参照。

>>748
マクロは意図するところが十分に明確で、かつ処理が短い場合は良いアイデア。
今回の実際のコードではreturnを入れて3文なので悪くはないかも。
(r->statusに代入、ログ吐き、return)

ただしマクロの濫用もコードの可読性を落とすので避けるべき。
vhost.cはマクロについては単純なものしか使っていないので、ポリシーの違いだろうね。

正解は753でしたw

バカが浮き彫り

>>754
いや、俺が言ってる「まとまってる」のは長さじゃなくて、
使う変数の依存関係が閉じた傾向にあるという意味。

goto肯定派は実用的なコードから
「ここはこうgotoを使えばもっと綺麗になるのに」
という例を出すつもりはないのかね。

いつでもgoto慎重派にコードを書かせるのは
フェアじゃないと思うのだが？

今、>>759 が良い事を言った！
さあ「gotoを恐れずに使う兵共」の腕の見せ所だ！

>>758
そうか。閉じた傾向とか何ともいえないのでソースを読んで。

>>759
それこそ全然フェアじゃない。
・「Cで書かれた実用的なプログラムでgotoを一切使っていないもの」が一つも出されていない。
・「ここはこう」の「ここ」を見つけるために、相手にそのプログラム全体を全て読めと？

相手にコードを書かせようと思うなら、題材くらい自分で出せ。

ていうか、プログラマとして非常にガッカリなのは、

情報として>>741が出されて、それを題材にしているにも関わらず、
実際にhttpdのソースをダウンロードして自分でソースを追ってみた人が、
ここで議論している人の中に誰もいなそうってところだな。

コードリーディングしない人には、コードを語る資格も能力もないよ。

具体論になると机上の空論と違って盛り上がらないねえ

>>762は>>748や>>750は無視ということか。

grep するだけなら楽でいいもんな。プ

>>764
750は明らかに749しか読んでいないと思われ。

実際のコードに当たったらこんな発言が疑問形で出るわけがない。

>そもそも「処理」ってくくれるぐらいまとまってるんだろ？

そこに気付かない>>764自身も、他人を煽るだけで自分はコードを読んでいない。

強調するが、ここが重要ね。

　　そこに気付かない>>764自身も、他人を煽るだけで自分はコードを読んでいない。

そういう>>765は手あたり次第grepしただけ。
そうじゃないと言うのなら、
「ここはこうgotoを使えばもっと綺麗になるのに」
という例があるはずだから、それを提示しろ。

できないなら、コード読まない厨認定な。

煽ったり議論したりする暇はあるんだから、ついでにちょっとコードも読めばいいのにね。

と思うよ俺は。

>>763
一方的に「コード読め」「改善策を出せ」と言うばかりの香具師がいるからな

悪魔の証明を知らない人ｗ

>>768 オマエガナー wwwwwwwwwwwwwwwwwwwwwwwwww

>>770
そうそう。grep厨はコードの断片を見せるだけで
議論は永遠に続くことになるんだよな。アフォらし。

強調するが、ここが重要ね。

　　そこに気付かない>>766自身も、他人を煽るだけで自分はコードを読んでいない。

こういうスレを読んでいると感じるけど
2chって「馬鹿しか得るものがない」場所だよね。

何の知識もない教えて君が相手を煽りながらタダで一方的に情報を得る。
教える側は何故か相手に罵倒されながら一方的に情報を提供して自分は何一つ得るものがない。

なので普通の人は嫌になってすぐに去り
2chに残るのは自己犠牲精神に満ち溢れた聖人と馬鹿だけ。

>>774
> 何の知識もない教えて君が相手を煽りながらタダで一方的に情報を得る。

goto厨のことだね。
goto慎重派はちゃんと改善例を提示しているのに
goto厨は文句を言うばかりで何の改善例も提示しない。

>>774
たかがgrepしただけでそこまで上から目線で言える根性が気に入った。

>>775
goto肯定派もコード出してるよ。>>469とか。目が腐りそうな糞コードだけど。
ちなみに>>469は>>485という形でgotoを使わずに可読性が上がったね。

485=774=grepした人=744以降でコード断片を出した人=普通の人なので去ります

と言いつつキリ番ゲットした>>777、オメ。

777が去った今このスレの運命は776の手腕にかかっている

6.8
自動記憶域期間をもつオブジェクトの初期化子、(略)は、
文の場合と同じく実行中に宣言に到達するたびにこれを評価し、
値をそのオブジェクトに格納する。

とあるので、gotoで宣言(と初期化)をまたぎこしていると、
初期化はされないとすべきのようです。

また、C99では「可変修飾型をもつオブジェクトの宣言を飛び越しては
ならない」という制限が加わってますね。なるほど。

>>776
goto否定派もコード出してるよ。>>267とか。目が腐りそうな糞コードだけど。
ちなみに>>267は>>263という形でgotoを使って可読性が上がったね。

一人で頑張ってる嫌goto厨。
後輩に得意になって言っちゃったの？
gotoは使うなって。

異議あり！代案なーし！
異議あり！代案なーし！
異議あり！代案なーし！

>>263は>>379で否定されたがね。

　　if (A_init() != 0) goto FAILED;
　　if (B_init() != 0) 80+0; FAILED:
　　if (C_init() != 0) goto FAILED;
　　if (D_init() != 0) goto FAlLED;

FAlLED:

しかしまいったね。
・・

アホなレス乞食ががんばっていますね

>>783
代案？
すべての法律がダメだけどそれを国会議員２００人ぽっちで作れるわけないだろ。
社会保険庁ですら数万人いるのに。

>>735-736はバグってた。
CATCH節の中でthrow_exceptionするとFINALLYが走らない。
こりゃ結構恥ずかしい。インデントも崩れてるし。

ほお。

あなたに悪意を持つプログラマが goto を 80+0 と書いて
嫌がらせをするかもしれないから goto を使うべきではない

と。

ヴァァァァァァァァァァァ
ァァァァァァァァァァァ
ァァァァァァァァァァァァァァァァァァァァァァ
ァァァァァァァァァァァカ
じゃねーの？ｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗｗ

どうでもいいけどダイクストラが言ってから今年で40周年か

見事な釣り師だな

>>788
森田さんこんなところにいたんですか。

ちなみに８０＋０と書き換えた森田さんは日常的に２ｃｈ語を上司に向かって話す極めつけの２ｃｈネラで、
バカジャネーノってＡＡ使いまくりな人。

生まれは九州は福岡のとある会社の社長の息子。

「gotoを使うな」の釣り糸一本で
40年間、たぶん何百万人という単位のプログラマを釣りあげてる
恐るべしダイクストラ

>>791
大工さんはＷｈｉｌｅをgotoで書くなと言っただけじゃね？

goto使いだってwhile使えるところでgotoとか使わないだろ。

sage不可能な良スレ

>>790
『福岡人はgoto禁止』でいいんじゃね？

違うか。森田さんは80+0って書いただけでgotoは書いてないもんな。
『福岡人と仕事するときはgoto禁止』？
いや『福岡人は面接で落とせ』？

福岡禁止

80+0なんてキーワードハイライトがあれば容易に見抜けないか？
あと、0に斜線が入ったフォント使うとか（0とoのような個別の事例にしか使えないけど）。

>>797
いやそれがね、うちの会社、ウィルスバスターが更新しないように、インストーラーに手を加えた上でウィルス感染させやがるんですよ。
イントラネット管理者の統括してる本人がやるから信用しちゃうでしょ。
福岡に本社のある東京一部上場企業なんだけど。

だからエディタにキーワード追加くらい簡単にやってのけるよ。

もはや798が質の悪い吊りだと見抜く方が容易

>>797
つうか字形が違いすぎてしばらく話の流れが全く理解できなかったよ

じゃあ次、コンパイラで使われていないラベルに対して警告を出すようにする。

>>798
電子計算機損壊等業務妨害 で告訴しろ。
（告訴状作って会社の法務部に送りつけるだけでも効果あるぞ）

>>802
人事部に電話したら、「会社の方針でお前を監視してるんだから逆らうな」って言われたから。
人事部長と直接話したいって言ったけど無視された。
会社クビにされるときに人事部長を名乗る人が来たけど、なんと創価学会の池田先生に瓜二つ。

>>803
こちらへどうぞ
ttp://pc11.2ch.net/test/read.cgi/prog/1197192900/

>>803
「他人にいたずらされている」という妄想を抱いて、「なら反撃で、いたずら
し返さなければ」とイタズラして、会社側から疑いをかけられて監視されて、
あげくのはてにイタズラしていたことがバレてクビになった。

としか、文章からは読み取れない。

むしろメンヘル逝きをお勧めしたい。

結局大工は釣りだとかいう観念論しかできないんだねw

いくら上げても技術要素０％のレスで火は起こせないか

気になったので、gccでやってみた

void bar(int);
int func(int arg)
{
if(arg == 0)
goto foo;

{
int i;
i = arg*2;
foo:
bar(i);
}

}

.file "gototest.cpp"
.text
.align 2
.globl __Z4funci
.def __Z4funci; .scl 2; .type 32; .endef
__Z4funci:
pushl %ebp
movl %esp, %ebp
subl $8, %esp
cmpl $0, 8(%ebp)
jne L2
jmp L3
L2:
movl 8(%ebp), %eax
addl %eax, %eax
movl %eax, -4(%ebp)
L3:
movl -4(%ebp), %eax
movl %eax, (%esp)
call __Z3bari
leave
ret
.def __Z3bari; .scl 2; .type 32; .endef

こうなる。
やはりiは確保されません。

>>810
goto使うなっての以上に、ブロックで変数定義するなってのもある。


しかし、オブジェクトはその場所で作るしかないんだな。

だからレジスタに割り当てられてるんじゃないの？

>>812
たった4つの32ビットレジスタで計算しないといけないのにそんな無駄なことできないでしょ。
少なくとも何かをするとしたらレジスタを使う。
やるとしても小さいループのループカウンタくらいか。

goto fooすりゃi=arg*2が実行されないのは当然ダロ
何を期待してんのかわからｎ

>>813
内側のブロックで宣言できないとしたら、
外側のブロックで宣言するだけ。
実態としては何も変わらない。

>>814
ああ、テキトーに作った例だから、実際の動作は気にしないでくれ。
問題は、ブロックの中で定義した変数の領域が確保されていないのに、関数呼び出しに使われてしまうという事実ね。
多分、foo: の後にi = i+argなんてやってもダメだと思う。

>>816
ヒント: jne L2 が実行された場合は L2 のどこで「領域が確保」されていますか？

809のiの定義の後でiに代入してるのはコンパイラにiの定義をスルーさせないように、それらしい仕事をさせたかったから。

>>817
ああ、別にされてないね。

データフロー解析ぐらいは最近のコンパイラなら当たり前だよ？
ガチガチにソースコードに対応するようなコードを吐いて欲しいなら
-O0 を付けるとか...してもそこまでガチガチなコードが出るかどうか。

>>820
そういう問題じゃない。出ているコードは綺麗にソースに対応している

スタックフレームが
>subl $8, %esp
で8バイト確保されていて
iが
>-4(%ebp)
なら、関数の先頭で「確保」されてるんじゃね？

>>822
正解

>>811
＞goto使うなっての以上に、ブロックで変数定義するなってのもある。

いやこれはするだろ。
あれ、みんなしない派？

俺は、近くで定義したい派。
ブロック内で変数定義することはある。
ただ、外の変数と名前がかぶらないほうがいいかなぁ〜、くらいは気を使う。

普通は最小スコープ(内側のスコープ)で定義するのが常識

それ厳密に適用するととんでもないことに

手続き的にやろうとするから、変数を外のスコープにひっぱり出すとかが
必要になる。関数的に、なんでも再帰あちこちでreturnな書き方をすれば
それでうまくいく。

>なんでも再帰あちこちでreturn
吊り？

>>813
そんな特定のアーキテクチャに依存した話を突然持ち出されてもねえ、、、

>>829
> >なんでも再帰あちこちでreturn
> 吊り？

釣りでもなんでもない。ifやswitchが文でなく式なら、

return if (hoge) true else false;

みたいに書けるのに（3項演算子は可読性が低いから却下)、
そうでないから、

if (hoge) return true; else return false;

というように書かざるをえない、ってだけ。

３項演算子に対する嫌悪感って goto のそれに似たものがあるな

3項演算子とgotoじゃ全然違うだろ・・・これだからgoto厨は・・・

3項演算子はネストしない限りif文よりも可読性高い場合もあるだろ
特に>>831のような単純な分岐の場合は。どうせ見た目で毛嫌いして
るだけだろうけど。

>>834
ネストしたって適切なカッコさえつければ問題ないだろ。
特に>>831の場合には積極的に3項演算子を使うべき箇所と思われ。

それは再帰とは呼ばない。
ということだけは覚えてほしい

if 文のみで書こうとすると異常にネスティングが増えるケースについて
3項演算子をif文とともに使って、ネスティングを削減すると、コードがすっきりするので好きだ。

例えばループで書くと

foo() {
　cond = true
　while (cond) {
　　・・・
　　　・・・
　　　　if (...) {
　　　　　cond = false
　　　　}
　　　・・・
　　・・・
　}
}

みたいな構造で、condのようなスコープの広い変数が
必要になるのが、再帰で処理するように書き直せば、

foo() {
　・・・
　　・・・
　　　if (!...) {
　　　　foo()
　　　}
　　・・・
　・・・
}

で済む、かもしれない、ってこと。

>>836
再帰かどうかが、returnがif文の中か3項演算子の外かで左右されるとでも？

>>838
でっていう

>>838
いや、皆が問題にしてるのはそういうことではなく
while (cond) {
　　int i;
　　....
}
みたいなスタック操作の無駄のことと思われ。

末尾再帰でもないのに、それは・・・

>>838の
foo() {
　cond = true;
　while (cond) {
　　s1;s2;
　　　　if (...) {cond = false}
　　s3;s4;
　}
}
これは、condが2回目のループでfalseになるとすると、
s1,s2,s3,s4,s1,s2,s3,s4の順で実行される。
で、
foo() {
　s1;s2;
　if (!...) {foo();}
　s3;s4;
}
これは、2回目のループで(!...)がfalseになるとすると、
s1,s2,s1,s2,s3,s4,s3,s4で実行されるから順番が変わる。そこでs3;s4をifの前に持ってくるわけだ。
すると、
foo() {
_loop:
　s1;s2;s3;s4
　if(...) goto _loop;
}

みんな末尾再帰でgoto使う？

末尾再帰をgotoにするのはコンパイラのお仕事。

再帰使うならgotoはいらん。
（再帰を中断するときには使うかもしれん）

つかそれはdo{}while(..);

>>843が全然末尾再帰になっていない件について

>>751
まあ、そういうコードが含まれているプログラムの中には
脆弱性だのバグだのいっぱい含まれているものだ。

　セキュリティについて、潔癖で有名なDJBですら、結構gotoを
多くつかう。　まったく使わないで終わらせた作品としては
は、比較的私家版パッチの突っ込みが少ない publicfile くらい。
後は山のようにgoto文があってDJBは嫌いだという人間もいる。

>>841
{} がつくと何でも変数スコープを狭く取りたがるつか、
同じ変数を使いまわしてもバグにならないというか、
単たる手抜きか。

pascalみたいに手続きの最初で全部まとめて宣言しろ

>>841
それも違うだろ。それくらい最適化でどうにでもできる。

>>845
ハァ？再帰からgotoで抜けるだぁ？
これだからgoto厨は…

再帰からgotoどころかlongjmpだってしちゃうぜ！

よーし、俺はexitだ。

いいこと思いついた。
お前ら俺のプログラムのケツにストリームデータ流し込んで実行してみろ。

>>855
えっ！お前のケツにすとりーむでーｔｌｋ；ｇｈｋｌｊ；

>>851
そんな最適化をされたらデストラクタロギングが使えなくなるじゃないか！！

>>857
コンストラクタ・デストラクタが呼ばれなくなるような最適化なんて行われるわけないだろ。
少なくともC++では。

いずれ呼ばれるにしても、呼ばれるタイミングは変わるかもよ？

>>859
どこの規格無視コンパイラだ？

gotoを使う想定でロジックを組むなら、それを分かりやすく図示する方法を発明してから
にしてほしい。そうじゃないとレビューする気にもなれない。
ここで出たようなgotoを使った書き直しの例なら、gotoを使ってないロジックを例えば
NSチャートとかで書いた方が、とてもとても分かりやすくて人にも説明し安いだろう。

チームメイトにロジックを説明するようにお願いてフローチャートをもってこられたら、
とりあえずバケツもって廊下に立っててくれるようにお願いしちゃうな。
システムが使われなくなるまでその人が死なずに内容も忘れずに保守するってのが保証さ
れてたとしても、仕事ではそんなロジックは受け入れ難いな。

だいたい現実的にgotoを使った方が良い場合ってのが、想定しづらい。
リソースだのコードサイズだののためのためにgotoを使うってのは、やらないと用件が
満たせないからって理由で、設計とかコーディングとかのさらに後に最適化フェーズを
設けてそこでやるんなら認めなくもないが、元からgotoを使うのが正しい場合なんての
を考慮しながらロジックを考えるような人とは一緒に仕事はできないなぁと思う。

なんでそんな書き方になってるか説明するための資料も作んないといけないし、仕事が
増えるばっかりだ。段階的抽象化とか物事を整理するとかに興味がないかできない人な
んだなとしか思えない。

誰かが事故にあってもリカバリがきくような状態を維持しようと思ったら、少しくらい
冗長になっても、なるべくわかりやすい設計＆実装にしたいって思うのは普通だと思う
んだがなぁ。

わたしはソース読み力がありません。

まで読んだ。

>>862は>>861を読む力がありません

まで読んだ。

resource *hoge(int arg) /*失敗でNULL、成功でリソース（p4）を返す*/
{
　resorce *p1 = NULL,*p2 = NULL,*p3 = NULL, *p4 = NULL;

　p1 = GetResource1(arg); /* GetResoruce*は失敗した時にNULLを返す */
　if(!p1) goto failed;
　処理1
　p2 = GetResource2(p1);
　if(!p2) goto failed;
　処理2
　p3 = GetResource3(p1,p2);
　if(!p3) goto failed;
　処理3
　p4 = GetResource4(p3);
　if(!p4) goto failed;
　処理4

　FreeResource(p3);
　FreeResource(p2);
　FreeResource(p1);
　return p4;
failed:
　if(p4) FreeResource4(p4);
　if(p3) FreeResource3(p3);
　if(p2) FreeResource2(p2);
　if(p1) FreeResource1(p1);
　return NULL;
}

これgoto使わないとどう書く？もちろんスマートポインタ、GC、例外は使用不可。

>>864
もうそれ飽きた。いいかげん空気読め、アフォ。

各GetResourceの前にifつけてやって、
処理4

p1 = GetResource1(arg);
if(p1) {
　処理1
　p2 = GetResource2(p1);
　if(p2) {
　　処理2
　　p3 = GetResource3(p1,p2);
　　if(p3) {
　　　処理3
　　　p4 = GetResource4(p3);
　　　ｉｆ(p4) {
　　　　処理4
　　　}
　　}
　}
}
if (p3) FreeResource(p3);
if (p2) FreeResource(p2);
if (p1) FreeResource(p1);
return p4;

俺の感覚だと、読んだだけで「ああ失敗なんだな」って分かる>>864のが好きなんだよね。
あとネストが深くならないのが。

>>868
処理そのものがネスト構造になっているんだから、
コードもネストしたほうが実態がわかっていいんじゃねーの？

>>863
なにがそんなに悔しいの？

↓いつものgdgdな展開へ・・・

>>869
なるほどねー。

>>870
いや別に。リソース確保でネストさせるのが嫌いだってだけで。

自演シッパイ、オツwwww

gdgdだな

>>872
リソース確保の条件がネストしているのだから、
コードもネストしたほうが実態がわかっていいんじゃねーの？

アンカー打ち間違える奴は、gotoでもラベル打ち間違えるに決まってる件について。

>>875
なるほどねー。

>>876
>>870の>>863を>>869に読み間違えてたわwww

処理1〜3にもよるだろう。
短いならいいけど、長ければネストしたくないって人もいるだろう。
あと、エラーならその場で関数から抜けたいタイプのひともいるし、
あれだけじゃなんとも。

あ、上の>>869は>>868ねwwwww

わざとだろwwww

>>881
>>878⇒>>880はねwwww読み間違えてたのはホント。

gdgdだーwww

>>879
ネストしたくなきゃ、
if (p1 && p2 && ...) {
とすればいいだけなんじゃ？

>>879
たった3つの解放だけなんだから、解放をマクロにしちゃって
goto failedのかわりにFreeAll; return NULL;しちゃってもいいな。

いずれにせよ、このネタはもうイトフユだろ。

ネストするなとか、あいかわらず後出しジャンケンなんだね、goto厨は…
まあその後出しジャンケンも>>885で残念賞なわけだがw

↑と、ここまでいつものgdgdな展開ですた。

嫌goto厨は「異議あり対案なし」であることが証明されました。

>>882
リアルでアンカー読み違える香具師がgotoを使うのは

キ　チ　ガ　イ　に　刃　物

>>888
gotoを使わない対案ならこの短い間に3つも出ましたが何か？

「出る」と「出す」の違いくらいわかってもいいとおもうぞ。

>>891
おいおい、>>888の主語は「嫌goto厨は」なんだから、
gotoを使わない対案が出ていればそれで十分に反証になるだろw

自分の他人の区別さえつかないのか、かわいそうに。

他人が書こうが誰が書こうがgotoを使わない対案であることに何の変わりもないが？

嫌goto厨は「異議あり対案なし」であることが証明されました。

>>895
gotoを使わない対案ならこの短い間に3つも出ましたが何か？

それがなにか？

いいよ〜gdgdいいよ〜

864のgotoは不要ということで。

俺の感覚だと、見た瞬間に 864>>>867 なんだがなあ。

えーとさ。FAILEDっていうラベルの存在自体が

「物凄くソースコードの見通しを良くする、これ以上無い最高のコメント」

だと思うんだよ。

>>900=>>864 オツw

>>901
goto派が一人しかいないと思ってるなら、
君はたった一人のgoto厨に向かって何を必死に反論しているのかしら？ｗ

goto派が一人しかいないなんて話、どこの脳内議論から降ってきたのだろうか・・・
脳ミソがスパゲッティになってるんじゃないの？

ラベルに適切な英語名を振れない低学歴が吠えてるだけ

1000までgdgd

>>900
FAILEDなんてラベル、>>864にはないんだけど・・・
ラベルも扱えない香具師がgotoを使うのは

キ　チ　ガ　イ　に　刃　物

すげぇ、TYPOも許容しないほどの厳格な議論なのかと思ったら
ただの罵り合いじゃん。

gotoを適切に使うことで見通しよく書けているコードなど
オープンソースソフトウェアを少し読めばいくらでも見つかるし
まともなプログラマならばgotoを使うべきコードパターンというのを
イディオムとして持っている

が

業務の中で頭の固い奴を説き伏せてまで良いコードを書こうとは
思わないので仕事では適当にwhileやifをネストさせてその場限りの
コードをぐちゃぐちゃに書く。保守性など知らない
とりあえず「見た目上構造化」しておけばよいのだからそれ以上
考えても無駄無駄無駄。所詮は仕事

>>908
ifをネストさせない対案も複数出ているが？

さあ、今度はどんな条件を後出しするのかなwwwwwww

という思想で書き散らかされたプログラムに
腐れUMLと自動生成された糞doc、スパイスとして捏造されたテスト報告書をくっつければ

ほら高品質ソフトウェアの出来上がりでござい

if (p1 && p2 && ...) {
馬鹿馬鹿しく肥大化した分岐条件

goto failedのかわりにFreeAll; return NULL;
馬鹿が思いつきで定義する糞マクロ

イイヨイイヨー