Quelle est la signification de l'instruction goto en langage C

En langage C, l'instruction goto est appelée instruction de transfert inconditionnel, qui permet un transfert inconditionnel du contrôle vers une instruction étiquetée au sein de la même fonction ; la syntaxe est "goto label;...label: Statement;", où label peut être n'importe quoi Du texte brut autre que des mots-clés C, qui peuvent être définis avant ou après l'instruction goto dans un programme C.

L'environnement d'exploitation de ce tutoriel : système Windows 7, version c99, ordinateur Dell G3.

Instruction goto en langage C

L'instruction goto, également connue sous le nom d'instruction de transfert inconditionnel en C, est dite inconditionnelle, mais en fait elle est toujours conditionnelle. La plage de saut est toujours limitée, permettant un transfert inconditionnel de contrôle vers le. même fonction marquée des instructions à l'intérieur.

Grammar

La syntaxe de l'instruction goto en langage C :

goto label;
..
.
label: statement;

Ici, l'étiquette peut être n'importe quel texte brut à l'exception du mot-clé C, et elle peut être définie avant ou après l'instruction goto dans le programme C.

Organigramme

Utilisation

Tout d'abord, nous devons déterminer où nous voulons transférer, quel est le point final du transfert, et nous devons définir un identifiant, qui est une étiquette ( Je n'ai pas montré l'anglais, lorsqu'une erreur se produit dans l'instruction goto, ce mot est susceptible d'apparaître dans le contenu de l'erreur). En même temps, nous devons ajouter deux points (:) après l'étiquette. nous avons défini l'identifiant, puis nous avons défini le point de départ ——goto identifier ;. Nous devons d'abord dire à l'ordinateur que nous allons sauter, ce qui est le rôle de goto. Ensuite, nous devons lui dire où nous voulons sauter, qui est l'identifiant que nous venons de définir. Enfin, comme pour les autres instructions, nous ajoutons des points. à cela (;) signifie la fin de l'instruction. Voici à quoi ressemble la page de l'éditeur.

et les résultats en cours d'exécution

On voit que notre 5ème ligne de printf n'a pas été exécutée, et nous sommes passés directement à la 7ème ligne de printf.

Il peut passer à l'instruction suivante ou passer au premier plan.

De cette façon, cela devient une simple boucle sans condition de fin

Vous pouvez essayer d'exécuter ce code. Bien sûr, nous pouvons utiliser le compteur et ajouter un jugement pour lui donner une condition de fin et laisser. il a la capacité de pendant et de temps.

Malheureusement, nous ne pouvons pas utiliser goto dans toutes les fonctions. Il existe d'autres instructions qui peuvent être implémentées, nous n'entrerons donc pas dans les détails ici.

Ici, si la condition if est vraie, après l'avoir affichée, en regardant la longue chaîne de parenthèses inégales ci-dessous, je sais que je dois définir les conditions sur celles-ci, puis le faire encore et encore. pause, c'est ennuyeux d'y penser. Comment puis-je attendre sans y aller à ce moment-là ? Très bientôt ! Nous allons directement à

pour passer à l'étape suivante de notre processus.

Mais je me demande si vous avez remarqué que dans la dernière image, nous avons utilisé deux gotos, mais ils pointaient vers la même étiquette. Oui, nous pouvons faire passer le programme au même point final à partir de points de départ différents, mais cela devrait l'être. a noté que nous ne pouvons pas accéder à deux étiquettes sous le même goto. C'est facile à comprendre. Si c'était vous et que vous receviez un ordre vous demandant d'aller à deux endroits différents ou même plus, vous seriez confus, où devriez-vous le faire. J'y vais?

Une autre différence par rapport à avant est que j'ai ajouté un point-virgule (;) après l'identifiant xiayige :. Pourquoi est-ce ? L'identifiant doit être suivi d'une instruction, qui peut être une affectation ou une instruction. Mais s'il n'y a vraiment aucun moyen d'ajouter une instruction après, nous pouvons ajouter un point-virgule et le traiter comme une instruction vide pour faire fonctionner l'identifiant.

Ps : En fait, vous pouvez déclarer ici une variable poubelle, ou d'autres déclarations dénuées de sens, mais cela rendra le code difficile à comprendre, et il n'est pas recommandé de le faire.

C'est ce que tout le monde utilise goto pour faire le plus. Quant aux autres utilisations, cela dépend de votre imagination, comme le dit le vieil adage, de l'audace d'une personne et de la productivité de la terre.

Ce qui suit correspond au moment où j'utilise goto.

#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视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!