Existe-t-il un équivalent au "GoSub" du BASIC en C  ?
 
J'ai cherché, je n'ai pas trouvé, et c'est dommage, ça m'aiderait bien.
 
J'ai des pelletées de texte avec variables à afficher et réactualiser souvent, et j'aimerais pouvoir optimiser leur affichage en les mettant "à part" de ma procédure principale. Une autre procédure ferait bien l'affaire, mais vu le nombre de variables à passer en paramètres (nombre qui augmente au fur et à mesure que je rajoute d'autres variables = modification de l'en-tête de la procédure, des appels, et du prototype à chaque fois...), c'est super lourd.
 
J'aimerais donc un truc comme GoSub, qui reste dans la procédure, qui peut être appelé à n'importe quel moment, et qui retourne tranquillement là où il avait été appelé une fois son traitement terminé.
 
C'est possible ?

Ce qui s'en rapproche le plus ce sont tout simplement les fonctions.
 
Après pour ton histoire de nombre de paramètres, je te conseil de les stocker dans une structure dont tu passeras l'adresse à tes fonctions.

Le Gosub fait partie d'une époque heureusement révolue, au même titre que le Goto. Ces instructions de satan n'ont plus lieu d'être, et sont totalement inutiles dans 99.9 % des cas.
Si tu as besoin de Gosub, c'est que ton programme est mal construit. Par exemple, au lieu de passer toutes tes variables en paramètres, tu les stockes dans un conteneur quelconque (tableau, structure), et tu écris ta fonction de mise à jour de tes variables en transmettant un pointeur vers ton conteneur en paramètre.

Effectivement, j'avais jamais pensé à utiliser une structure ou un tableau pour passer un groupe de variables en paramètres. Là, le tableau, ça va être compliqué vu que mes variables sont de types différents. Par contre, pour la structure, vous faites comment ? C'est bien une structure de pointeurs que vous me proposez, dans laquelle je stocke l'adresse de toutes mes variables en début de procédure ?

Ben non, une structure toute bête

typedef struct {
   int nb;
   char *s;
   float f;
} Vars;
 
Vars mesVars;
mesVars.nb = 3;
mesVars.s = NULL;
mesVars.f = 4.3;
 
TaFonction(&mesVars);

et dans TaFonction, tu récupéres tes variables :

void TaFonction(Vars *myVars)
{
   int x = myVars->nb;
   char *s = myVars->s;
   float fl = myVars->f;
  // ...
}

typedef struct {
   int nb;
   char *s;
   float f;
} Vars;
 
Vars mesVars;
mesVars.nb = 3;
mesVars.s = NULL;
mesVars.f = 4.3;
 
TaFonction(&mesVars);

void TaFonction(Vars *myVars)
{
   int x = myVars->nb;
   char *s = myVars->s;
   float fl = myVars->f;
  // ...
}

Ha bah ouais mais mes variables sont déjà créées avant en fait (la plupart sont des éléments d'autres structures). Je peux donc pas les initialiser directement dans cette structure. Par contre, en déclarant des pointeurs dans la structure "mesVars", ça peut le faire ?

Ben oui, tu déclares des pointeurs vers tes variables dans la structure, et roulez jeunesse

Je vais faire ça, merci pour vos réponses.    
 
Entre parenthèses, petit débat : je suis un fervent opposant aux Goto, qui dénotent effectivement un "programme mal construit", vu le nombre d'autres outils à disposition (if, while, etc) pour les éviter.
En revanche, je ne suis pas aussi catégorique avec le GoSub. La preuve, cette solution de contournement avec une structure. Je trouve que ça fait encore plus "bricolage" que d'utiliser un GoSub directement. Après, je reste conscient que pour la compilation, le GoSub doit être une aberration totale, quoique je m'y connais pas assez en assembleur pour pouvoir en être sûr.  
 
Vos avis ?

Mais de toute façon, le Gosub c'est quoi ? Un bête appel de fonction tout simplement, comme le disait Tarabiscote au début. Sauf qu'en C, tu n'écris pas "Gosub Fonction(a,b)", mais "Fonction(a,b)".
Après, moi personnellement je ne vois pas du tout le rapport entre le Gosub et le passage de multiples variables en paramètre de fonction comme tu en parles

Bin ça fait longtemps que j'ai pas touché au BASIC, mais je crois me rappeler qu'avec un gosub, il n'y avait pas besoin de passer de variables en paramètres, car c'était considéré comme faisant partie de la procédure dans laquelle il était écrit (donc avec accès direct aux variables de cette procédure). C'est juste cette différence que je fais avec une autre procédure/fonction appelée. Je me trompe peut-être, merci de me corriger si besoin  

Justement, c'est en ça que le Gosub est crade, c'est qu'il ne permet pas de passer des variables en paramètre, ce qui t'oblige à utiliser des variables globales. Et les variables globales, c'est encore pire que le goto

Ce que Turkleton m'a l'air de desirer, ce sont des fonctions locales.  Comme en Ada ou en Pascal.  A noter que gcc en a comme extension (on voit de temps en temps des gens l'utiliser sans savoir que c'est une extension et avoir des problemes de portabilite).

OK, ça répond plus ou moins à ma question de savoir comment est interprété l'instruction GoSub au niveau machine. En fait, il fait un bête appel de procédure, tout en passant toutes les variables déclarées dans la procédure appelante en globales ? Effectivement, c'est TRES mal, bonjour l'utilisation de la mémoire. Enfin bon, le BASIC n'était pas fait non plus pour gérer au mieux l'optimisation de la mémoire...  
 
Je m'en retourne utiliser ta technique décrite plus haut, ça peut m'aider pas mal pour ce que je veux faire.

Oui, c'est à peu près ça je pense, mais si ça n'existe pas directement en C, je veux pas essayer de bricoler. Je vais utiliser la méthode d'Harkonnen et Tarabiscote.

Etant donné qu'en BASIC préhistorique, il n'y a pas de paramètres, effectivement, le gosub est une sorte d'appel de fonction sans paramètres. Mais si la fonction doit accéder à une variable, il faut utiliser une globale, ce qui est souvent root of all evil ...

Alors apprend la programmation sérieuse à coup de fonctions et de contextes (pointeurs sur des structures). Par exemple, regarde comment sont interfacées les fonctions de FILE.