Discussion :

[codec_abc]

Pour ce qui est de retourner plusieurs valeurs, ou d'utiliser un sucre syntaxique pour ne pas avoir de déclarer explicitement une classe spécifique ou une structure, ça peut être bien utile. Je ne trouve pas que ce soit plus moche que les tuples, après pour la sémantique qui se perd en cours de route si on en abuse, le problème se pose aussi avec les fonctions qui prennent trop d'arguments dans les langages qui ne proposent pas les "named arguments".

En fait, ca existe depuis un moment. Le terme exact est Type algébrique de données. Pour information c'est présent en Haskell depuis le tout début c'est à dire 1990. Mais comme toutes les bonnes idées en programmation elles mettent du temps pour arriver dans les langages populaires. Ca doit s'expliquer en bonne partie pour des raisons de rétro-compatibilité, c'est pourquoi on les rencontre plus souvent dans les langages récents.

[RyzenOC]

Pour moi c'est surtout pour assurer une cohérence avec le monde des maths (qui est a la base de l'informatique).
Un langage comme python (utilisé dans le scientifique) se doit par exemple d'être cohérent avec son milieu.

[air-dex]

Mouais. Ce n'est que de la syntaxe tout ça. Tous les langages ont plus ou moins des solutions pour retourner plusieurs valeurs s'ils n'ont pas la syntaxe qui va bien. Entre les listes, les maps (tableaux associatifs), les class et autres struct, etc., il y a toujours de quoi faire s'il n'y a pas de retour multiple, que ce soit nativement ou via des structures de données crées de toutes pièces (sans aller jusqu'à la chaîne de MichaelREMY ). Au pire il y a les passages par référence que beaucoup de langages supportent. Bref ce n'est pas tellement un problème en pratique.

[ijk-ref]

Mouais. Ce n'est que de la syntaxe tout ça. Tous les langages ont plus ou moins des solutions pour retourner plusieurs valeurs s'ils n'ont pas la syntaxe qui va bien. Entre les listes, les maps (tableaux associatifs), les class et autres struct, etc., il y a toujours de quoi faire s'il n'y a pas de retour multiple, que ce soit nativement ou via des structures de données crées de toutes pièces (sans aller jusqu'à la chaîne de MichaelREMY ). Au pire il y a les passages par référence que beaucoup de langages supportent. Bref ce n'est pas tellement un problème en pratique.

T'as raison, on peut tout faire avec des "Goto" pourquoi se prendre la tête avec encore plus de syntaxe !

[tomlev]

Mouais. Ce n'est que de la syntaxe tout ça.

Vu comme ça, la grande majorité des features des langages de haut niveau sont du sucre syntaxique

La boucle while ? Juste du sucre syntaxique pour un goto et un if !
L'appel à une méthode virtuelle ? Juste du sucre syntaxique pour une lookup table avec des pointeurs de fonction !

[Invité]

avec la nouvelle mode de la programmation fonctionnelle, y a des gens qui s'amusent à écrire du code live où les mots clés du langage sont des fonctions

[MABROUKI]

bonjour
La seule raison valable à mon avis pour qu'une fonction renvoie une seule valeur
1/reside dans le fonctionnement de bas niveau des appels de function (meme void) qu'il ne faut pas oublier:
Il y a une pile qui ne doit pas etre encombre par des parametres de retour ...
Pour de gros objets(classe ,structure ,tableau ) un pointeur sur l'objet est transmis,l'objet lui est stocke dans le tas, comme tous les objets exigeant un pointeur...,Meme dans le cas de pointeur sur pointeur(passage par reference en c#)....
L'avantaage de la pile est que toute la memoire allouee à celle-ci est reduite à neant au moment du return.....c.à.d desallouee....
2/un avantage conceptuel evident dans l'ecriture du code qui permet de le decouper en parties independantes les unes des autres...

[Uther]

Je ne comprend pas trop l'argument de la pile. Pourquoi son occupation mémoire serait un problème pour les valeurs de retour et pas pour les arguments?

Je pense que l'explication mathématique semble la plus logique.

[gedd]

En C# il y as les Tuples, qui remplissent très bien cette fonctionnalité

[Sve@r]

Contourner cette limite est pourtant très simple depuis plus de 20ans : sérialiser la valeur retournée !
si j'ai besoin de retourner 5 valeurs de types distincts par exemple :
-465
-True
-2012-12-15
-Michael
-12.45

il suffit de les sérialiser manuellement, c'est-à-dire les concaténer en chaines de caractère :
"465#True#2012-12-15#Michael#12.45"
Ce principe de sérialisation est disponible dans tous les langages, donc je ne vois pas pourquoi on en fait tout un article et du tapage comme ça.

Mouais, très simple. Et moi je veux retourner
-465
-True
-2012#12#15
-#
- rien (le concept, pas le mot)
-12.45
=> "465#True#2012#12#15#####12.45"


De plus, cet article n'est pas fait pour indiquer comment résoudre ce problème (bien évidemment que tous les devs de ce forum savent le résoudre dans leurs langages de prédilection !!!), mais pour que chacun donne son avis sur les raisons du problème !!!

[Invité]

En C# il y as les Tuples, qui remplissent très bien cette fonctionnalité

oui et non, c'est en effet pas pratique et pour pouvoir retourner le résultat d'une query linq il est parfois nécessaire d'avoir un type définit.

exemple au sujet d'une fonction qui recherche des mots dans des livres numérotés constitués de chapitres numérotés par livre qui contiennent des versets contenant des mots numérotés selon l'ordre dans le verset.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class WordMatch
{
  public int BookID { get; internal set; }
  public int ChapterID { get; internal set; }
  public int VerseID { get; internal set; }
  public int WordID { get; internal set; }
  internal WordMatch(int bookID, int chapterID, int verseID, int wordID)
  {
    BookID = bookID;
    ChapterID = chapterID;
    VerseID = verseID;
    WordID = wordID;
  }
}

public IQueryable<WordMatch> FindWords(Func<Words, bool> condition)
{
  return from book in Entities.Books
         from chapter in Entities.Chapters
         from verse in Entities.Verses
         from word in Entities.Words
         where chapter.BookID == book.ID
         where verse.ChapterID == chapter.ID && verse.BookID == chapter.BookID
         where word.VerseID == verse.ID && word.ChapterID == verse.ChapterID && word.BookID == verse.BookID
         where condition(word)
         select new WordMatch(book.ID, chapter.ID, verse.ID, word.ID);
}

l'idée émergeante serait donc de pouvoir écrire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public IQueryable<new(int bookID, int chapterID, int verseID, int wordID)> FindWords(Func<Words, bool> condition)
{
  return from book in Entities.Books
         from chapter in Entities.Chapters
         from verse in Entities.Verses
         from word in Entities.Words
         where chapter.BookID == book.ID
         where verse.ChapterID == chapter.ID && verse.BookID == chapter.BookID
         where word.VerseID == verse.ID && word.ChapterID == verse.ChapterID && word.BookID == verse.BookID
         where condition(word)
         select new { bookID = book.ID, chapterID = chapter.ID, verseID = verse.ID, wordID = word.ID };
}

avec un tuple, c'est pas génial, ça présentait bien en conférence en tant que perspective de conceptualisation fonctionnelle mais qui les utilise sans se dire que c'est pas joli ?

ça serait cool d'étendre la capacité de l'opérateur new selon ce concept pour avoir des types de retour anonymes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public new(int TheInt, string TheString, object TheObject) DoSomething(params...)
{
  return new { TheInt = ..., TheString = ..., TheObject = ... };
}

public new[](int TheInt, string TheString, object TheObject) DoSomething(params...);

public List<new(int TheInt, string TheString, object TheObject)> DoSomething(params...);

[Invité]

L'avantaage de la pile est que toute la memoire allouee à celle-ci est reduite à neant au moment du return.....c.à.d desallouee....

la pile n'est pas le tas même si la tas de piles est à trier sélectivement.

https://fr.wikibooks.org/wiki/Progra...ur_x86/La_pile

[Médinoc]

la pile n'est pas le tas même si la tas de piles est à trier sélectivement.

https://fr.wikibooks.org/wiki/Progra...ur_x86/La_pile

Le concept d'"allocation" est-il exclusif au tas?

Edit: ↓Wait, what?

[Invité]

Le concept d'"allocation" est-il exclusif au tas?

la pile est une structure comportementale du CPU d'accès à la mémoire RAM/Cache, plus lente que les registres mais plus rapide que les accès mémoire classiques (dwordptr). c'est à peu près la même chose pour le tas, les accès au tas consomment moins de cycles cpu que les accès mémoire classiques par adressage.

https://fr.wikipedia.org/wiki/Pile_%28informatique%29
https://en.wikipedia.org/wiki/Memory_management#DYNAMIC
http://gribblelab.org/CBootcamp/7_Me...k_vs_Heap.html

[esperanto]

Y a-t-il une raison pour laquelle les fonctions, dans la plupart des langages de programmation,
ne retournent qu'une seule valeur ? Partagez vos avis

Oui, elle est très simple et pourtant personne ne semble l'avoir mise dans les commentaires.
La raison, c'est qu'un appel de fonction est destiné à être intégré dans une expression plus complexe: c'est à dire que x := f(y) est l'exception, le plus souvent c'est e(f(y)) où e est une expression (pas forcément un appel de fonction) plus complexe.

Prenons l'exemple donné dans l'article:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(password, username) = GetUsernameAndPassword()

Ce qui me gêne avec ce genre de fonction, ce n'est pas qu'on puisse se tromper dans l'ordre des paramètres. Imaginons que je dispose d'une fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

RealName(userName)

trouvant le nom de famille à partir du login (dans une base de données par exemple). Si je cherche un nom à partir de la fonction précédente je vais devoir écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
(user, pass) = GetUserNameAndPassword()
return RealName (user)

là où avec une fonction retournant une seule valeur j'aurais pu écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return RealName(GetUserName())

Comme vous voyez, loin de simplifier l'écriture, la présence de plusieurs paramètres oblige à passer par des variables temporaires.
A moins bien entendu qu'il existe un opérateur sur les tuples permettant d'en extraire le premier élément:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return RealName (GetUserNameAndPassword() [0])

et on comprend alors que la fonction supposée rendre plusieurs valeurs renvoie en réalité une seule valeur de type tuple, c'est bien un type à part avec des opérateurs associés... à condition de les définir, ce que l'auteur de l'article n'a pas pris la peine de faire.

De même, si une autre fonction prend plusieurs paramètres, il faut définir une sémantique pour qu'un résultat de type tuple puisse être intégré: en Perl par exemple, si j'écris F(GetUserNameAndPassword()), le résultat de l'appel à GetUserNameAndPassword va être "applati" ce qui veut dire que la fonction F va recevoir deux paramètres. Mais d'autres langages pourraient considérer ce résultat comme un tuple passé comme premier paramètre de F - et d'ailleurs, serait-il passé par valeur ou par référence? Comme vous voyez, loin de simplifier les choses, ça oblige à définir une sémantique complexe.

En mathématiques, à la base les choses sont spécifiées clairement : une fonction a un ensemble de définition et un ensemble résultat. Si une fonction a deux paramètres entiers, c'est qu'en réalité son ensemble de définition est N² : elle prend en paramètre un vecteur à deux composantes. Et rien ne lui interdit de renvoyer un vecteur à deux composantes : au moment de l'appel on dispose de tous les opérateurs définis pour le type N² et seulement ceux-là. Si ensuite je veux passer le résultat dans une autre fonction, soit celle-ci prend un type N² et je peux reprendre mon résultat tel quel, soit elle prend autre chose et il faut des opérateurs pour convertir.
La question est alors de savoir quels opérateurs sont définis sur N², et là il faut reconnaitre que les matheux ont été assez peu rigoureux pour les définir. Généralement ils utilisent .x .y et .z sans se rendre compte que ce sont des opérateurs et on se demande alors ce qui se passe au delà de 4 composantes, mais ils n'y ont pas réfléchi. Un informaticien au contraire serait obligé de définir un type structuré et de nommer explicitement les composantes à l'avance.

[Invité]

Y a-t-il une raison pour laquelle les fonctions, dans la plupart des langages de programmation,
ne retournent qu'une seule valeur ? Partagez vos avis.

Oui, elle est très simple et pourtant personne ne semble l'avoir mise dans les commentaires.

La réponse au sujet, qui ouvrait la réflexion, est simple et a été donnée. Elle est structurelle inhérente à l'architecture des microprocesseurs et d'une manière générale c'est pareil pour la quasi-majorité des processeurs de l'ère actuelle.

Résumons.

Tous, et sans exception, tous, tous absolument tous les langages de programmation dits évolués (par rapport à l'assembleur qui est le langage humain primal vis à vis d'un ordinateur à microprocesseur au silicium à transistor ternaire) génèrent, comme le compilateur assembleur (TASM, NASM ou CLR/IL par exemple), et grâce à un compilateur spécifique à ce langage (c, c++, c#, pascal, ada, fortran, ruby, python, prolog...) un fichier binaire de langage machine exécutable par le processeur et décompilable en premier niveau en assembleur (ou sinon grâce à une machine d'exécution dit interpréteur qui instruction par instruction exécutera un mapping entre le langage et le code machine à exécuter par le processeur, tel que java (bytecode) ou .net (IL), permettant ainsi l'exécution d'un même programme sans recompilation sur diverses plateforme unix ou windows ou apple par exemple).

Autrement formulé, la réponse à la question est parce que le langage machine (un instruction dite d'assembleur ou opcode est en réalité un nombre), et donc l'assembleur, ne gère pas du tout les passages de variables in et out ou ref, ni même ce qu'on nomme les retours de fonctions. Le microprocesseur ne connait que les procédures i.e. les goto/return tant décriés de la programmation impérative. La gestion des paramètres in/out/return faisant d'une procédure une fonction avec ou sans paramètres et avec ou sans valeur de retour, n'est qu'un artéfact de programmation et donc de langage qui au final en langage machine deviennent de la gestion d'accès mémoire registre ou RAM direct ou via la pile et le tas.

Il faut avoir à l'esprit que malgré toutes ces choses merveilleuse et remarquables qu'on appelle technologies de développement logiciel fantastiques et spectaculaires, et même ce qu'on nomme IA, un ordinateur n'est qu'un calculateur qui fait des additions, des soustractions, des multiplications, des divisions, des tests d'agalité ou d'inégalité, et gère des pointeurs de cellule mémoire pour stoquer et récupérer des valeurs (int, float, adresse) et des goto/return à des adresse de code. du code et du data. rien d'autre. c'est du binaire 2D quelle que soit la structure de donnée matricielle hétérogène, les encapsulations, la virtualité, la généricité... qui ne sont que des artéfact de conception de programmes.

Windows 10 est une super carte perforée et internet un téléphone communautaire, rien de révolutionnaire.

Ainsi la réponse à la question est-elle liée à l'évolution des langages de programmation dits évolués vis à vis du langage machine et c'est pourquoi le .NET IL reste de l'assembleur classique bien que virtuel. Ce qui revient à dire que si une façon de faire n'est pas disponible, c'est d'abord parce que personne n'y a pensé et puis parce que personne ne l'a encore implémenté... donc si un utilisateur veut une fonctionnalité qui est faisable, il lui suffit de la soumette à l'équipe projet du domaine concerné ou sinon de créer lui-même son langage puisque tel est le sujet

Il est où ce fichu polymorphisme générique !!! Déjà C#6 et l'opérateur diamond ne semble toujours pas être au menu

https://fr.wikipedia.org/wiki/Langage_de_programmation

https://fr.wikipedia.org/wiki/Progra...n_informatique

[tomlev]

En C# il y as les Tuples, qui remplissent très bien cette fonctionnalité

Sinon c'est bien de lire le début de la discussion avant de répondre

Quand une fonction renvoie un tuple, tu sais quel est le type des éléments du tuple, mais tu ne sais pas forcément ce qu'ils représentent, puisqu'ils s'appellent Item1, Item2, etc. Donc des "vrais" tuples avec des éléments nommés, supportés directement au niveau du langage, seraient super utiles.

(accessoirement, Tuple<...> a le mauvais goût d'être un type référence, donc ça alloue une instance sur le tas, que le GC devra collecter ; avec un type valeur, il aurait suffit de le pousser sur la pile, sans coût d'allocation et de nettoyage)

[MABROUKI]

Je ne comprend pas trop l'argument de la pile. Pourquoi son occupation mémoire serait un problème pour les valeurs de retour et pas pour les arguments?

Je pense que l'explication mathématique semble la plus logique.

si tu ecris une fnction recursive(exemple factorielle),ton appel de function voit son parametre pousse dans la pile c.à.d dans une zone memoire reserve à la pile...
Si la profondeur de recursion est importante(fact 1 million) le parametre d'entree est decremente et il est empile à chaque appel ....et la pile croit ...
La pile decroit progressivement ensuite quand on atteint la valeur terminale(fact 0 si tu veux) ,la zone alouee est detruite ou desalloue si on veut...
Qaunt à la logique mathematique il faut la laisser tranquille ,s'agissant du fonctionnement du processeur X86...

[Invité]

si tu ecris une fnction recursive(exemple factorielle),ton appel de function voit son parametre pousse dans la pile c.à.d dans une zone memoire reserve à la pile...

une fonction s'appelle elle-même à l'infini ? "STACK OVERFLOW" ! Windows 95 / Dos ==> reboot.

[Uther]

si tu ecris une fnction recursive(exemple factorielle),ton appel de function voit son parametre pousse dans la pile c.à.d dans une zone memoire reserve à la pile...
Si la profondeur de recursion est importante(fact 1 million) le parametre d'entree est decremente et il est empile à chaque appel ....et la pile croit ...
La pile decroit progressivement ensuite quand on atteint la valeur terminale(fact 0 si tu veux) ,la zone alouee est detruite ou desalloue si on veut...
Qaunt à la logique mathematique il faut la laisser tranquille ,s'agissant du fonctionnement du processeur X86...

Je sais comment marche une pile, ce n'était pas la question. Ce que je disais est que rien n’empêche de pousser la valeur de retour sur la pile elle aussi, donc l'argument de la limitation a un seul registre ne tient pas vraiment. D'ailleurs les langages somme le C permettent bien de retourner des structures plus grosses qu'un registre.