Was bedeutet die goto-Anweisung in der C-Sprache?

In der C-Sprache wird die goto-Anweisung als bedingungslose Übertragungsanweisung bezeichnet, die eine bedingungslose Übertragung der Kontrolle an eine gekennzeichnete Anweisung innerhalb derselben Funktion ermöglicht; die Syntax lautet „goto label;...label: Statement;“, wobei label can ein beliebiger einfacher Text außer C-Schlüsselwörtern sein, der vor oder nach der goto-Anweisung in einem C-Programm gesetzt werden kann.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, c99-Version, Dell G3-Computer.

C-Sprache goto-Anweisung

goto-Anweisung, in C auch als bedingungslose Übertragungsanweisung bekannt, gilt als bedingungslos, ist aber tatsächlich immer noch bedingt, sodass die bedingungslose Übertragung der Kontrolle möglich ist gleiche funktionsgekennzeichnete Anweisungen innerhalb.

Grammatik

Die Syntax der goto-Anweisung in der C-Sprache:

goto label;
..
.
label: statement;

Hier kann die Bezeichnung ein beliebiger einfacher Text außer dem C-Schlüsselwort sein und vor oder nach der goto-Anweisung im C-Programm gesetzt werden. „Flussdiagramm“ Ich habe kein Englisch angezeigt. Wenn in der goto-Anweisung ein Fehler auftritt, wird dieses Wort wahrscheinlich im Fehlerinhalt angezeigt. Gleichzeitig müssen wir nach der Bezeichnung einen Doppelpunkt (:) hinzufügen. Wir haben den Bezeichner festgelegt und dann den Startpunkt – goto bezeichner;. Zuerst müssen wir dem Computer mitteilen, dass wir springen werden, was die Rolle von „goto“ ist. Dann müssen wir ihm mitteilen, wohin wir springen möchten, was der Bezeichner ist, den wir gerade festgelegt haben. Schließlich fügen wir, wie bei anderen Anweisungen, Punkte hinzu dazu. (;) bedeutet das Ende der Aussage. So sieht die Editorseite aus.

und die laufenden Ergebnisse

Es ist ersichtlich, dass unsere 5. Zeile von printf nicht ausgeführt wurde und wir direkt zur 7. Zeile von printf kamen. Es kann zur nächsten Aussage oder nach vorne springen.

Auf diese Weise wird es zu einer einfachen Schleife ohne Endbedingung

Sie können natürlich versuchen, diesen Code auszuführen und ihm eine Endbedingung zu geben und ihn zu beurteilen Habe die Fähigkeit für und während.

Leider können wir goto nicht funktionsübergreifend verwenden. Es gibt andere Anweisungen, die implementiert werden können, daher werden wir hier nicht näher darauf eingehen.

Wenn die if-Bedingung wahr ist, weiß ich nach der Ausgabe, wenn ich mir die lange Reihe ungerader Klammern unten ansehe, dass ich die Bedingungen dafür festlegen und es dann immer wieder tun muss. Pause, es ist nervig darüber nachzudenken. Wie kann ich zu diesem Zeitpunkt warten, ohne zu gehen? Sehr bald! Wir gehen direkt zu

und springen zu

, um mit der nächsten Stufe unseres Prozesses fortzufahren.

Aber ich frage mich, ob Ihnen auf dem letzten Bild aufgefallen ist, dass wir zwei Gotos verwendet haben, die aber auf die gleiche Bezeichnung zeigten. Ja, wir können das Programm von verschiedenen Startpunkten aus zum gleichen Endpunkt springen lassen, aber das sollte so sein Beachten Sie, dass wir nicht zu zwei Labels unter demselben Ziel springen können. Wenn Sie an Ihrer Stelle wären und Sie aufgefordert würden, zu zwei oder noch mehr verschiedenen Orten zu gehen, wären Sie verwirrt Ich gehe?

Ein weiterer Unterschied zu zuvor besteht darin, dass ich nach der Kennung xiayige: ein Semikolon (;) hinzugefügt habe. Dem Bezeichner muss eine Anweisung folgen, die eine Zuweisung oder eine Anweisung sein kann. Wenn es jedoch wirklich keine Möglichkeit gibt, eine Anweisung danach hinzuzufügen, können wir ein Semikolon hinzufügen und es als leere Anweisung behandeln, damit der Bezeichner ausgeführt wird.

Ps: Tatsächlich können Sie hier eine Garbage-Variable oder andere bedeutungslose Anweisungen deklarieren, aber dadurch wird der Code schwer verständlich und es wird nicht empfohlen, dies zu tun.

Das ist es, wofür jeder goto am häufigsten verwendet. Was andere Verwendungszwecke angeht, hängt es von der Vorstellungskraft ab, wie mutig ein Mensch ist und wie produktiv das Land ist.

Das Folgende ist, wenn ich goto verwende.

#include<stdio.h>
int main ()
{
    printf("请输入要计算的算式,四则运算优先级一样高，从左到右依次计算\n");
    int jieguo=0,sz,gongju=0,gongju2=1;
    char ysf;
    scanf("%d",&jieguo);
    if (jieguo==0)
//直接输入等号的话%d似乎是0，有待商榷！！！！！！！！
//二次修改，if语句中判断量时只有0为假，除此之外的数字都表真
    {
    printf("**,你算**呢\n");
    goto chaojijieshu;
    gongju=1;
    gongju2=0;
    }
    else if (gongju2)
    
    {
    printf("请输入运算符\n");
    
    scanf(" %c",&ysf);
    //enter包含两个命令，算是两个字符\r和\n,后面的一个会占据scanf的输入位，所以要清空,或者用空格占位
    if(ysf==&#39;=&#39;)
    printf("**,你算**呢\n");
    }
loop:
    while(ysf!=&#39;=&#39;)
    {
        if (ysf==&#39;-&#39;)
        {
            printf("请输入数字\n");
            scanf("%d",&sz);
            jieguo-=sz;
            printf("请输入运算符\n");
            fflush(stdin);//清空标准输入流(stdin) fflush是stdio.h中的函数
            scanf("%c",&ysf);
            if(ysf==&#39;=&#39;)
            {
                goto jieshu;
            }
            else
            {
                goto loop;
            }
        }
        else if (ysf==&#39;+&#39;)
        {
            printf("请输入数字\n");
            scanf("%d",&sz);
            jieguo+=sz;
            printf("请输入运算符\n");
            fflush(stdin);//清空标准输入流(stdin) fflush是stdio.h中的函数
            scanf("%c",&ysf);
            if(ysf==&#39;=&#39;)
            {
                goto jieshu;
            }
            else
            {
                goto loop;
            }
        }
        else if(ysf==&#39;*&#39;)
        {
            printf("请输入数字\n");
            scanf("%d",&sz);
            jieguo*=sz;
            printf("请输入运算符\n");
            fflush(stdin);//清空标准输入流(stdin) fflush是stdio.h中的函数
            scanf("%c",&ysf);
            if(ysf==&#39;=&#39;)
            {
                goto jieshu;
            }
            else
            {
                goto loop;
            }        }
        else if(ysf==&#39;/&#39;)
        {
            printf("请输入数字\n");
            scanf("%d",&sz);
            while(sz==0)
            {
                printf("0能做分母吗？你算**呢\n");
            }
            jieguo/=sz;
            printf("请输入运算符\n");
            fflush(stdin);//清空标准输入流(stdin) fflush是stdio.h中的函数
            scanf("%c",&ysf);
            if(ysf==&#39;=&#39;)
            {
                goto jieshu;
            }
            else
            {
                goto loop;
            }
        }
    }
jieshu:
    printf("结果是%d\n",jieguo);
chaojijieshu:
    if (gongju)
    printf("真无语，重开吧\n");
    return 0;
    
}
//注意注意！！！！！！！！！！！！
//enter算是两个命令，所以有两个字符，在进行上一次输入之后
//在来一个enter，会占据scanf的字符位
//所以要清空标准输入流
//可以利用下述语句
//fflush(stdin);
//清空标准输入流(stdin) fflush是stdio.h中的函数
//以上是最好的解决办法
//初次之外，还有被称作偏方的办法
//二次修改 除此之外，而不是初次之外，打错字了
//如
//scanf（“ %c”，&ysf”）
//在scanf中加一个空格，可以顶掉enter多出来的一个字符
//还有
//加一句
//getchar()
//用getchar来捕捉多出来的\n

说明

在任何编程语言中，都不建议使用 goto 语句。因为它使得程序的控制流难以跟踪，使程序难以理解和难以修改。任何使用 goto 语句的程序可以改写成不需要使用 goto 语句的写法。

不推荐使用goto语句的原因：

①由于goto语句是无条件跳转指令，使用goto语句后回使得程序结构变得更加复杂，不利于以后代码维护，特别是需要交交接给被人维护的时候。

②由于目前编程采用的都是结构化编程，方便移植，而当采用goto语句后就会导致在结构化编程的项目中代码不便移植，因为如果使用goto从一个结构中跳转到另一个结构，而使得结构之间有了联系，不便移植。

③由于目前C语言等高级语言具有break、continue等语法，可以很好地代替goto，所以能不使用goto就不使用goto。

推荐使用goto的场景：

①从多重循环中直接跳出。

②出错时清除资源。

③可增加程序清晰度的情况。

使用goto函数的原则：

①使用goto语句只能goto到同一函数内，而不能从一个函数里goto到另外一个函数里。

②使用goto语句在同一函数内进行goto时，goto的起点应是函数内一段小功能的结束处，goto的目的label处应是函数内另外一段小功能的开始处，不能破坏功能的实现。

③不能从一段复杂的执行状态中的位置goto到另外一个位置，比如，从多重嵌套的循环判断中跳出去就是不允许的。　

④应该避免向两个方向跳转。这样最容易导致"面条代码"，即逻辑混乱。

相关推荐：《C视频教程》

Das obige ist der detaillierte Inhalt vonWas bedeutet die goto-Anweisung in der C-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!