eh oui c encore moi! je voudrais savoir comment fait on pour renvoyer plusieur variebles à partire d´une fonction en c?
faut il faire return(a,b,c) ou return(a) return ( b) . ............. ou j´y suis pas du tout?
merci d´avance!

Tu peux pas ! Il faut utiliser des pointeurs.

mais oui c vrai! il faut me pardonner ca fait un an que g pas programmé alors je m´y remet un peu tous les jours donc ce soir c les pointeurs!
encore merci!

si tu es en C, tu utilises les pointeurs :

genre une fonction toutte bete, genre une fonction qui renvoie a et b :

void renvoie(int* a,int* b)
{
. .. / / traitement

• a = valeur que je veux mettre
• b = valeur que je veux mettre

}

void main()
{
. .. / / traitement
renvoie(&,&);
}

Evidemment, rien ne t´empeche d´en renvoyer une normalement, et de " renvoyer" l´autre par adresse :
int renvoie(int* a);
int renvoie(int* b);

. ......

ça, c´est si tu te restreint au C : il faut manipuler, a l´interieur de renvoie, non pas a, mais *a.

En C++, tu as un truc sympa : le passage par référence :

void renvoie(int& a,int& b)
{
. .. / / traitement
a = valeur que je veux mettre
b = valeur que je veux mettre
}

void main()
{
. .. / / traitement
renvoie(a,b);
}

Comme tu vois ici, on n´a plus de *, par contre, on a des & qui veulent dire " passage par référence", c´est a dire que tes variables a et b dans renvoie ne sont plus des copies, mais les originales :

autrement dit, quand tu met le & ici, toute modification de la variable dans la fonction se récpercute sur la variable du main ( de la fonction appelante)

merci pour ces precisions.

essayer plyutot les forums de http://www.developpez.com le code source est mis entre balise

Moi je trouverais pourtant ça pratique, la possibilité de retourner plusieurs valeurs. Python le fait je crois.

Ça pourrait être une extension au language...

dans le genre:
/ /Int : index basé sur 0, bool réussite ou échec
int,bool GetHostIndex(const char* name)
{
/ /divers trucs... pour le retrouver...
return Index, true;
}

int Index;
GetHostIndex(Nom)@(0,1);
if(@1)
{
Index = @0;
}

En fait le principe serait simple:
le @ servirait à récupérer des valeurs dans des chiffres symboliques, qui seraient référencés par @n, ou n est le numéro.

Du point de vue bas-niveau du compilo:
le @ servirait à associer un emplacement mémoire correspondant à la valeur de retour avec un chiffre.
La façon elle-même du compilateur de retourner les valeurs importe peu: par exemple, pour peux de données, elles pourrait les retourner dans des registres, ( c´est bien sur spécifique à l´implémentation de l´architecture). Ça pourrait se retourner par la stack pour les architectures en possédant une.
Mais ma solution préférée reste un pointeur vers une table. On aurait plus qu´à déférencer.

Je vous explique le principe du remplacage symbolique:
imaginons l´exemple plus haut sur une architecture x86:
Pour deux valeurs, l´idéal serait à mnon avis de retourner ça par les registres, disons eax pour l´index, et edx pour le bool.
Le principe est d´alors remplacer les utilisations de @n par sa " valeur".

int Index;
GetHostIndex(Nom)@(0,1);//la première valeur est dans eax: on associe eax avec @0, la deuxième dans ebx, on associe @1 avec ebx

Ensuite, reste à remplacer dans le code:
if(@1)
{
Index = @0;
}

donnant:

or @1, @1
jz . next
mov [dword Index], @0
. next:

Alors on a plus qu´à remplacer:

or ebx, ebx
jz . next
mov [dword Index], eax
. next:

Dans un autre cas: imaginons que ça soit retourné par un pointeur ( dans ebx). @0 est associé alors à [dword ebx], et @1 à [dword ebx+4]
on a plus qu´à remplacer:
mov eax, [dword ebx]
or eax, eax
jz . next
push [dword ebx+4]
pop [dword Index]
. next:

Alors, vous en pensez quoi? À votre avis, est-ce que ça serait utile?

Kelios
---------

t´es sur ke t´as 15 ans? t´as l´air balaize, enfin g pas vraiment compris ce ke t´as ecrit. euh..... c koi le but deja ? en tout cas g ratrapper mon retard g reviser les pointeurs ca fonctionne nickel.demain je passe aux structures!

En gros, tu pourrais retourner plusieurs variables...

Dans une extension du language, par exemple.
Bon, le truc, c´est que c´est plutôt une idée en l´air. Pour implémenter ça, il me faudrait changer du code d´un compilateur open-source ( GCC? Oulah...) ou encore faire le mien ( Mon compilo? Oulah...), bref, rien de facile et d´évident, et je sais pas si ça vaudrait toute cette peine...

Sinon, Chris_le_ouf m´a posé une bonne question:
opurquoi, au lieu de fonction(paramètres)@(x,y,z), on ferait pas tout bêtement, x,y,z = fonction(paramètres)?
Bon, je n´y vois qu´un gros inconvéniant:
les opérateurs...
Y´a l´ambiguité de l´opérateur virugle:
printf(StringPtr,StringNumber=GetString(NULL));
Soit getString une fonction retournant deux valeurs. Ici, virgule sépare-t-il les paramètres, ou les valeurs de retour? Pour le compilateur, ça ne marche pas... parce que, si c´est les paramètres, = met quelle valeur de retour dans StringNumber? D´un autre côté, dans le cas des retours, laquelle des valeurs de retour sert de chaines de caractères à printf?

Ça vient au deuxième problème: = retourne quoi dans ce cas? Dans un cas normal, il retourne la valeur unique, mais dans un cas avec plus d,une valeur, il retourne laquelle? Il en retourne pas? Ça signifirait plus de code parce que l´on ne pourrais plus compacter le code comme on pouvait le faire, avec les ifs:
if(valeur = fonction(param1,param2)
{}
vérifiant si la avleur était ! =0...

Une solution pour le un serait les parenthèses. Mais comme toujours avec les parenthèses, ça devient vite chiant, par ce que ça en rajoute toujorus plus dans la ligne de code...

Bien sur, pour le compilateur, pas de problème:
c´est pour le programmeur le problème! Son code devient plus étendu, plus gros, pour rien!

Ironiquement, c´est pour le programmeur, ce truc, la retour de valeurs multiples! Pour le compilo, il s´en fous: que ça soit par pointeur/référence dans les params, ou comme ça, il s´en tabasse royalement...

Alors, si c´est pour le programmeur, ça serait totalement absurde de le faire chier encore plus! Ça n´en vaudrait donc pas la peine, à mon avis...

Par contre, le @ n´a pas ces ambiguités:
de pars l´opérateur @() est unique, mais @n est flexible pour le compilo, et le programmeur en a moins à se préoccuper. Là ça deviendrais envisageable, à mon avis.

Autre question: que retournerais l´opérateur @()? Ça reviens au même que l´opérateur égal, non? Ben non, ce n´est pas pareil, car il permet au compilo d´associer les @n...
Niveau valeur de retour, je ne sais pas encore, mais je crois que ça retournerais un v1 || v2 || v3 || . .. || vn... donc 0 s´ils sont tous égals à zéro, 1 s´il y en a au moins un de positif. Mais ça pourrais changer.

Comme d´habitude, un avis est toujours le bienvenu

Kelios
---------

Déjà, demandes toi si c´est vraiment utile ? Et surtout, trouves toi l´interet d´aller te jeter dans les sources de GCC uniquement pour ajouter cette fonctionnalité ? Me dis pas que tu prendrais plaisir à passer des jours pour t´organiser dans ses sources.

/ *
Python le fait je crois.

• /

Oui et non, de cette façon c´est pas possible, mais incrémenter directement après le mot clé ´return´ l´est par contre, donc ça reflete l´utilisation des pointeurs.

t´es sur ke t´as 15 ans? t´as l´air balaize

hinhin Mr Ours est bien plus que balèze
en fait, il a mis 15 ans parceque il ne savait pas à quoi correspondait son age en humain, ouaip sur la planète Haèssaim ( prononcez A.S.M.) ils comptent pas pareil que sur Terre

" Déjà, demandes toi si c´est vraiment utile ? "
" Et surtout, trouves toi l´interet d´aller te jeter dans les sources de GCC uniquement pour ajouter cette fonctionnalité ? "
->>
" Pour implémenter ça, il me faudrait changer du code d´un compilateur open-source ( GCC? Oulah...) ou encore faire le mien ( Mon compilo? Oulah...), bref, rien de facile et d´évident, et je sais pas si ça vaudrait toute cette peine... "
" À votre avis, est-ce que ça serait utile? "

En tout cas, là je suis occuppé, j´ai fini par résoudre un prob ( GCC demande que les segments aient la même base adress... pfff... Alors quand il essayait d´incrémenter une variable dans la stack frame, on passait du ss habituel au ds, qui avaient des base adress différentes...) Donc je continue mon kernel....
Alors c´est sur, aller fouiller dans gcc, j´ai mieux à faire

Kelios
---------