Langage C #17 - piles
HTML-код
- Опубликовано: 7 фев 2025
- Cette séance 17 va nous permettre de découvrir quelques structures de données en langage C.
🔗 Code source d'une Piles (entiers) : bit.ly/2VW5nET
🔗 Code source d'une Pile (joueurs) : bit.ly/30Y3ic0
🔗 Schéma d'une Pile : bit.ly/2O01lH5
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
💙 Si ce n'est pas encore fait, n'hésite pas à t'abonner à la chaîne
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jas...
◾ Twitch : / jachampagne
◾ RUclips (personnel) : / jasonchampagne
◾ Twitter : / jachampagne8
◾ Facebook : / jachampagne8
◾ Instagram : / jachampagne8
◾ Snapchat : / jachampagne8
🔵 Crédits :
Musique proposée par La Musique Libre
Wontolla - Can You Feel Me (ft. Nathan Brumley) : • |Musique libre de droi...
Wontolla : / iamwontolla
Nathan Brumley : / nathanbrumleysongwriter
MERCI DE VOTRE FIDÉLITÉ 💙 !
#langageC #programmation #structures
![Noob To Max With DRAGON REWORK In Blox Fruits [FULL MOVIE]](http://i.ytimg.com/vi/LnBMOinoOvA/mqdefault.jpg)
Cette séance 17 va nous permettre de découvrir quelques structures de données en langage C.
🔗 Code source d'une Piles (entiers) : bit.ly/2VW5nET
🔗 Code source d'une Pile (joueurs) : bit.ly/30Y3ic0
🔗 Schéma d'une Pile : bit.ly/2O01lH5
salut, j'ai une question : comment se fait il qu'on peut déclarer une variable de type structure(comme "next") à l'intérieure de la même structure qui la définit ? et ça fonctionne uniquement pour des pointeurs j'ai essayer pour une variable de type int et char ça n'a pas fonctionné.
mon copliateure ne reconé pas tes declaration boolienne vue que j utilise le dev c
Coucou Jason, j'ai un problème au niveau de l'énumération / définition de type Bool, les valeurs true et false ne sont pas reconnue par le compilateur de VS 2017. Ce dernier mentionnant : identificateur indéfini.
Je ne pense pas que ce soit lié au fait que je code un projet en "Visual" C++ (peut-être différent du C++ conventionnel)
FILO (First In Last Out) peut fonctionner aussi car Le premier qui rentre sera le dernier qui sort :p
ça commence à se corser pour moi mais ça reste vraiment intéressant. Très bonne vidéo, vraiment merci de partager tes connaissances avec nous, continue comme ça !
Ne lâche rien et n'hésite pas à faire des petits programmes de ton côté pour mettre ça en pratique 👍
Super tutoriel, tes explications sont simples et claires ! On peut facilement regarder la vidéo en 1.25 voir 1.5 sans se perdre ! Merci :)
Oui, voir en accéléré peut se faire sans soucis pour ceux qui comprennent bien le français. Bonne continuation à toi o/
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
c'est la premier fois de ma vie que je dois revoir plusieurs fois une vidéo pour comprendre.
normalement pour apprendre langage je regarde les vidéo une traite et une seul fois car je n'ai pas le temps.
C'est normal, ça se corse un peu, et ça met en application beaucoup de concepts vus précédemment 👍
merci infiniment pour ce fameux tutoriel sur la pile. elle me sera très utile . deux choses m'ont vraiment touché sur cette partie . Premièrement, c'est cette façon de subdiviser le
programme pour avoir un code plus lisible et plus facile à comprendre. car je me demande bien à quoi aurait ressemblé le code si l'on avait inclue toutes nos fonctions créée dans
le fichier (main.c). ahahahaahahah. Enfin j'ai bien pu apprecié l'efficacité sur les pointeurs et pour ma part je pense que c'est l'un des éléments qui fait la puissance de ce langage.
Un grand merci JASON bravooooooooooooooooooooooooooooooooooooooooooooo et un grand respect.
Oui, sans les pointeurs, le C perdrait de tout son potentiel, alors il ne faut hésiter à s'en servir à chaque fois que cela est nécessaire, c'est à dire 98% du temps :)
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8/
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Avec toi, je suis sûr et certain de bien Coder en C !
Explications trop cool et très simple
Merci et bon courage à toi en C
Oh la la, je m'incline devant ce cours de qualité !
Merci beaucoup !!!
Merci à toi pour le commentaire :)
merci infiniment pour tout
👍
J'ai clisurle lien mai j'a pas pu télécharger le code source mais grâce à votre explication j'ai pu implémenter correctement le code de A à Z. Encore une fois merci.
Bonne continuation
Merci beaucoup pour ce tuto très clair ! Bonne continuation !
De rien, à bientôt 👍
Superbe vidéo encore une fois! J'ai bien aimé la Structure de player à la fin! CHOUBACCA, sympa comme pseudo Ahahaha XD
👍
Merci beaucoup pour ces cours sur le langage C! J'ai encore quelques lacunes mais je pense qu'à force de répéter ça ira, en tout cas ta formation m'est très utile et je compte bien continuer!
De rien, et en effet, n'hésite pas à t'exercer, faire des petits programmes, voire des projets, expérimenter, tester ce que tu apprends et voir ce que tu comprends de tout ça à l'arrivée 🙂
@@formation-video Oui en plus jusqu'à maintenant je ne faisais que visionner les cours (de peur d'endommager mon pc en cas d'erreur ^^) mais il faudrait que je teste moi même aussi en même temps que le cours ce serait mieux, merci pour ta réponse!
Oui, c'est clair, et puis tu ne vas pas endommager ton PC ;)
@@formation-video génial alors!!
Encore une fois merci bien Jason :)
De rien, à bientôt 👍
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Aaaahhhhhhhh, Merci beaucoup!
De rien ;)
bonjour grand frère, merci pour la formation que le grand Dieu vous bénisse
Merci à toi 🙂
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
💙 Si ce n'est pas encore fait, n'hésite pas à t'abonner à la chaîne
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
merci beaucoup, toujours aussi utile !
De rien, bonne suite du cours ✌
vous etes un heros haha, vous etes super mon frere =D
🙂
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
Pile ce qu'il fallait !
Salut à 18:30 tu fais l'allocation dynamique et je me demande pourquoi dans l'argument du sizeof tu utilise * element et non StackElement* , sachant que pour moi StackElement* est un pointeur de type StackElement et * element le déréferencement d'élément. Du coup j'ai comparé le résultat du sizeof(StackElement*) et sizeof(*element) et ce dernier est plus grand en plus si je comprend bien *element retourne ce qui est contenu à cette adresse et à cette adresse il y a une structure de type StackElement sans préciser l'adresse de next ou la valeur de cette élément.
Bonsoir :).
En temps normal, tu pourrais remplacer le "*element" du sizeof() non pas par "StackElement*" mais "StackElement" tout court (sans l'étoile). Or, j'ai pris l'habitude de mettre directement le nom du pointeur pour l'allocation plutôt que le type. De cette façon, si je venais un jour à changer le nom du type, je n'aurais pas à toucher aux allocations, c'est tout.
Donc, tu peux sans problème faire un *malloc(sizeof(StackElement))* si tu le souhaites.
Bonjour , Bon travail merci pour vos cours très complet , pourriez vous svp d'expliquer d'avantage les pointeurs sur les structures expliquer par des exemples indépendants , merci
Tout ce qu'il y a à savoir sur les pointeurs est détaillé dans le cours sur les pointeurs : ruclips.net/video/Qra-0U_jEKs/видео.html
Leur application est la même, que ce soit avec ou sans l'utilisation de structures ;)
Bonjour/soir , je ne comprend pas la présence de ce pointeur ici 8:35 , il n’est pas défini et pointe sur rien (tu as dit qu'il pointe sur la pile mais d'où on sait ça), je ne comprend donc pas sa présence et je ne comprend pas non-lus l'utilité de *next (enfin tu l'as dit c'est pour passer a la pile d'en dessous) mais d'où on sait ça, comment ça se fait ?
En fait, je définis une double syntaxe pour ma structure de Pile. En gros, StackElement est une struct Stack, et Stack également.
Dans la structure elle-même, chaque élément de la pile doit être lié aux autres (sinon, chaque élément serait isolée et nous n'aurions aucune structure, mais que des variables isolées). Donc, on indique que chaque "maillon" (élément) de la Pile pointe vers un autre élément (sinon NULL).
Ce chaînage est nécessaire pour établir la liaison de nos éléments (tu retrouveras le même principe avec une File, une Liste, ou autre...) et permet de parcourir la structure (du premier au dernier élément).
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Bonjour Jason. Alors il y a beaucoup de manipulations que tu fais avec les pointeurs, mais je ne les comprends pas tous.
Par exemple à 30:16 lorsque tu crées une fonction print_stack pour afficher la pile dans la console, je vois bien que tu parcours toute la pile avec une boucle while mais l'action que tu fais après le print, le "st = st->next" si j'ai bien compris, ça modifie la pile pointée par st vu que celui-ci est un pointeur?
Donc je pense avoir mal compris (puisque la fonction marche), mais pourquoi la pile ne se détruit pas à chaque fois que la fonction fini de s'exécuter?
Bonjour, l'instruction st = st->next permet de déplacer le "curseur" (l'endroit où l'on se situe pour le parcours sur l'élément suivant). En gros, on commence du premier élément (avec lequel on fera nos traitement), puis on passe à l'élément suivant, jusqu'à arriver à la fin (quand st->next vaut NULL).
Par ailleurs, la Pile n'a aucune raison d'être détruite puisque nous passons un pointeur vers celle-ci dans nos fonctions. Ce qui sera détruit à la fin de la fonction, c'et le pointeur qui a été créé au départ de celle-ci, pas la structure elle-même 🙂
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
🔵 Rejoindre FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
Super explication comme toujours .... J'avais très peur de cette leçon mais maintenant je la trouve très simple et je la comprends très bien Merci Jason .
j'ai juste une remarque dans ce qui concerne la fonction top_stack dans ce fichier bit.ly/2VW5nET .
le problème se pose dans cette ligne : exit(EXIT_FAILURE); :
Si on utilise cette ligne, le compilateur va sortir du programme sans exécuter les instructions qui se suivent alors il faut renvoyer un nombre pour que la compilation du programme continue . On peut retourner un entier négatif comme vous l'avez fait dans la vidéo.
Bonne continuation ^^
Oui, si on veut être rigoureux, il faut bien gérer les codes de retour des fonctions et traiter cela ensuite dans la fonction main()
gros merci 🥰
Je t'en prie, bonne continuation en C 👋
Bonjour, il semblerai qu'il y a une erreur sur le schéma à 25:40, on crée d'abord l'élément contenant la valeur 31, donc le sommet serait plutôt en bas ?
En tout cas, j'adore vos vidéos ça m'aide à comprendre beaucoup plus de choses sur le C !
Bonjour, non, le sommet de la pile, c'est le dernier élément qui a été ajouté à la pile (et celui qui sera le premier a être dépilé). C'est pour cela qu'il faut vraiment le voir comme une pile d'objets. Le sommet d'une pile n'est jamais l'élément qui se trouve tout en bas de celle-ci 😉
parfait! et merci
👍
Super explication👏👏👏
🙏
vous aurez du utilisé un pointeur pour Player non pas utiliser la structure player directement dans la structure des pille
Par exemple dans la minute 52:20 si vous avez utilisé un pointeur ça va pas poser un probleme avec le "NULL "
Oui, c'est une solution préférable, mais je ne voulais pas compliquer le code ici, donc le exit() fait l'affaire également ;)
Hello!, à 30:30 dans print_stack(Stack st) peut-on se passer du 'return' et coder comme cela ? :
void print_stack(Stack st)
{
if(is_empty_stack(st))
printf("Rien à afficher, la pile est vide.
");
while(!is_empty_stack(st))
{
printf("[%d]
", st->value);
st = st->next;
}
}
Merci ! 😁
Bonjour, oui, tu peux. La différence ici est que ton code vérifiera la condition de la boucle.
@@formation-video Hello, mais donc dans ta version de code, ne faut-il pas un 'return' après la boucle while ? Sinon quand ce 'while' a fini de travailler, comment la fonction se conclue-t-elle ? Dans le cas du if du dessus, un 'return' fait bien sortir de la fonction, alors pourquoi pas après le 'while' ?.... Je patauge.
Avec mes meilleurs vœux ! 😁👍
Bonjour Jason, merci pour ce travail bien fait; j'aimemrais tout de même comprendre la ligne (struct StackElement *next) qui intervient dans la déclaration de la structure (typedef struct stackElement). Je m'attendais à ce qu'elle soit ignorée par le compilateur car faisant partie des champs de la structure créée.
Bonjour, et bien non, on peut parfaitement définir une structure dont un de ses membres est aussi du type de la structure.
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
Tu avait raison, au début il y a une semaine, je comprenais vraiment pas bien les piles, puis en faisant des schémas de mon côtés pour essayer de comprendre, je comprends mieux, mais d'ailleurs, c'était pas mieux de commencer par les listes chainées avant les piles ?
Merci pour tes vidéos !
Non, pas besoin de commencer avec une structure en particulier, étant donné que leur fonctionnement est différent de l'une à l'autre
@@formation-video ah d'accord, en gros celle là est plus simple. Mais une autre question, pour ajouter des éléments à la pile, on peut passer par des pointeurs au lieu d'incrémenter la nouvelle valeur directement à la pile ? En gros, on appelle juste la fonction (void) qui ajoute.
Pas compris, mais c'est ce qui est fait dans la vidéo. Dans une Pile, on ajoute des éléments par "le début". C'est ce que fait la fonction push_stack()
@@formation-video Pour ajouter un élément, toi tu as fait ça : stack = push_stack(stack, x);
Est ce qu'on pourrais modifier cette fonction pour juste l'appeler comme ça :
push_stack(stack, x);
Oui, il suffit d'adapter la structure de données 👍
Bonsoir,
J'ai une question au sur la nouvelle structure player car je ne comprends pas. En effet, 45'33" il faut créer un nouveau header pour cette nouvelle structure. Pourquoi? pourtant cette structure est utilisée par l'autre ou plutôt les deux structures forment la pile...
Qu'est-ce que tu ne comprends pas ?
dans la fonction d'affichage tu fais st=st->next , or c'est un pointeur , cela n'affecte pas la suite (tu perd pas ta tete de pile) apres l'execution de la fonction ? et si on voulait que par exemple notre st a la sortie change on met come entree Stack* st ?
tout comme dans lenght le fait de faire st=st->next cela ne te fais pas perdre la tete de la pile ?
Le but n'est pas de perdre les données de la Pile, juste de les parcourir de la première à la dernière pour les afficher, ou compter le nombre d'élements. On ne fait donc que déplacer un pointeur sur chaque élément, rien de plus ;)
oui mais le fait de deplacer le pointeur ne te fera pas perdre l'adresse de l'element de tete ?
Non du tout ;)
à 9:14 je ne comprends pas la ligne " struct StackElement *next " pourtant j'ai revus et bien compris la vidéo des pointeurs. Je dirais que le pointeur next pointe vers la structure StackElement mais je ne suis absolument pas sur. Peux-tu me corriger stp? Merci d'avance! Et au passage, super vidéo, comme toutes les autres d'ailleurs...
Bonsoir, en fait "next" est un pointeur vers une donnée de type "StackElement". Car un Pile, dans l'implémentation proposée, qu'est-ce que c'est ?
- Pile vide = NULL
- Stack avec 1 seul élément = Pile
- Stack avec 2 éléments = Pile
- Stack avec 100 élements = Pile.
Donc, pour chaîner chaque élément dans une Pile, le pointeur "next" pointe sur un autre élément de Pile (StackElement), sinon NULL (on est au bout de la Pile).
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
@@formation-video excusez moi, je ne comprends pas au niveau du pointeur:
celui ci est de type stackelement, mais il peut pointer des piles de plusieurs tailles differentes si j'ai bien compris, est ce logique qu'un pointeur d'espace fixe ici 4 bits puisse pointer plusieurs piles de tailles differentes ?
merci,
dans la fonction afficher comme dans length tu as parcouru la pile or dans la notion de pile on a pas le droit de parcourir non ? (on vide plutot la pile dans une autre et on remet )
Non, il est tout à fait possible d'afficher une Pile, que ce soit en remplissant une autre ou en la parcourant. Le principe de la Pile doit surtout respecter le fait que tu ne pourras dépiler que la dernière donnée qui a été empilée. Donc remplissage par le haut.
Titoonis
Super bien explique. au fait est ce que c'etait possible de creer ka pile et ses focntions sans pointeur? SI cest non est est uniquement parce que le passage pas valeur n'aurait pas permis d'agir sur la pile ou il ya d'autres raisons
Non, car ton ordinateur ne sait pas ce qu'est une Pile, ni l'espace que cela a besoin, et on ne connaît pas à l'avance le nombre d'éléments qu'elle aura. Donc : pointeurs et allocations de mémoire dynamiques.
@@formation-video oh je vois merci beaucoup pour avoir repondu. C'est aussi pour ca tu as utilise *Stack? Des fois quand tu utlise StackElement tu met * devant element mais quand tu utilise Stack tu ne met rien. est ce que ca veut dire que les deux sont equivalents? j'ai remarque que tu as utulise Stack uniquement avec les focntions aussi et StackElement avec les piles temporaires des fonctions
C'est surtout par rapport aux alias créés à partir de la structure avec typedef. Dans ma définition, j'ai créé deux alias :
- le premier pour dire que struct StackElement est équivalent à StackElement
- le second pour dire que struct StackElement est équivalent à *Stack
Ainsi, dans le premier on doit mentionner le pointeur, dans la seconde, il est masqué 👍
@@formation-video ah c'est plus clair maintenant merci beaucoup
De rien
bonsoir monsieur j'ai un problème d'inconpréhension au niveau de la fonction clear_stack à la 25:29 en faisant free(st) pourquoi cela ne vide pas toute la pile puisque la pile c'est st
moi j'aurais fais free(element) et j'aurais fais une erreur svp eclairez moi
Parce que si tu regardes bien, on a alloué un espace (malloc) pour chaque élément de la Pile. Il faut donc naturellement libérer (free) chaque élément à son tour.
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
@@formation-video je vois mais je ne sais pas si j'ai pas encore compris mais liberé la pile ( free(stack) ) c'est aussi la libéré de tout ses éléments pourquoi rappeler alors la fonction en retournant stack_element puisqu'il n'en a plus dans le pile
Pour faire simple, tu dois faire autant de free() que tu as fait de malloc(), donc pas qu'un seul 😉
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
@@formation-video je comprend bien ce fait je pense que ne saurais expliquer par écrit ce que je pense il y'aurait-il un moyen de vous joindre svp svp!!!!!!!
Bonsoir Jason, j'ai un problème avec l'énumération / définition de type Bool, les valeurs
true et false ne sont pas reconnue par le compilateur de VS 2017. Ce dernier
mentionnant : identificateur indéfini.
C'est vraiment curieux car ta manière est censée fonctionner de partout comme tu l'as si bien dit.
Je ne pense pas que ce soit par ce que je code un projet Visual C++ (différent du C++ conventionnel)
Bonjour, c'est Visual Studio qui ne doit pas accepter cette syntaxe. L'IDE ne te propose-t-il pas une autre syntaxe ? Ou même de directement utiliser le type bool introduit par la suite en standard dans le langage C ?
FormationVidéo Il est en effet possible d'utiliser le type Book sans passer par l'énum mais VS2017 n'aime pas non plus l'alloc mémoire d' *élément, il mais que l'assignation (le égal) pose problème :
element = malloc(sizeof(*element));
Merci encore ^^
Alors soit ton VS2017 est mal configuré, soit il faut changer d'IDE. Car la syntaxe pour le malloc est évidemment correcte :)
Est ce que *Stack et StackElement, c'est la même chose ? Je comprends pas pourquoi il y en a deux, et pourquoi l'un est un pointeur et pas l'autre ?
Stackement est un alias de Stack, c'est le principe du typedef 👍. C'est juste pour avoir deux nommages et que ce soit plus lisible au niveau du code (si on voit Stack, on pensera à la pile complète, et si on voit StackElement, on pensera à un seul élément d'une pile)
@@formation-video Mais pourquoi lorsque je remplace Stack par StackElement, j'ai une erreur ?
Si tu as bien regardé. Avec la notation "Stack", pas de pointeur indiqué, mais avec "StackElement", oui
@@formation-video donc je met un & devant ? Et sinon, j'ai une question, pourquoi on met un *devant une fonction et c'est quoi la différence ? Merci pour tes réponses.
Non : pastebin.com/hUsmXJDu
Si une fonction a comme type de retour int* par exemple, cela veut simplement dire qu'elle renvoie un pointeur sur int (entier).
Bonjour, ce que je n'arrive pas à comprendre, c'est le " *Stack " que tu as ajouté à l'énonciation de la structure de la pile. Tu dis qu'on "cache le pointeur" , ça non plus je comprends pas. Merci d'avance ! :)
Bonsoir, si je ne mettais pas cette syntaxe, il faudrait écrire la structure en faisant : Stack *st (au lieu de Stack st) et d'autres changements dans le code.
En le masquant, on évite les erreurs d'oubli de l'étoile par exemple, c'est tout :)
Ah d'accord, donc pour la machine " StackElement" et "*Stack" c'est exactement la même chose, non ?
Oui, la même structure :)
Voilà c'était pour être sûr, désolé pour la question bête xD. Merci ! :)
Il n'y a jamais de question bête =)
Bonjour,
j'ai une question par rapport au type des fonctions et au pointeur caché dans la stucture "StackElement" :
Est-ce que le fait d'appelé une fonction par "Stack nomDeFonction (param 1, ..)" est en fait une manière de créer un pointeur de fonction ?
(afin de renvoyer l'adresse de la fonction et d'éviter de renvoyer l'adresse des éléments de la structure modifié par la fonction via des pointeurs)
Merci d'avance pour vos réponses et j'apprécie énormément vos cours qui sont clairs pour la majorité !
Bonjour, cela ne concerne pas les pointeurs de fonction, c'est juste pour avoir un nom simple (ici Stack) pour représenter la structure de notre pile 👍
@@formation-video D'accord. Je pense que je commence à comprendre : si on créer une fonction avec "Stack" on demandera de fait à la fonction de retourner non seulement une stack mais avec l'adresse de celle-ci (comme on déclare "*Stack" dans la structure) en plus, est-ce correcte ?
Merci pour votre réponse et j'adore vos vidéos même si ce n'est pas toujours évident vous m'aidez & m'apprenez beaucoup !
Oui, sinon on ne pourrait pas modifier notre structure de données 😉
Merci Jason pour la qualité pédagogique et le pan sur les structures de données. On fait un saut, là partir de #17.
Bizarre, en testant le programme, la console retourne "gcc : error *.c : invalid argument . Je ne vois pas ce qui cloche..
Oui, les notions du C sont abordées les 16 premières vidéos. À partir de cette séance, tu ne vas voir que l'application dans quelques domaines du langage, et apprendre à manipuler quelques structures de données ;)
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8/
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Pour ton erreur de compilation, regarde de bien faire : gcc *.c -o prog pour compiler l'ensemble de tes fichiers source (extension ".c" tout en les liant avec les en-êtes ".h")
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8/
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
merci Jason
De rien, à bientôt =)
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8/
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Vraiment merci beaucoup pour ces explications !!
j'ai juste un petite demande : t'a pas une idée sur le jeu de dames ou un exemple d'un projet d'une jeu ...?
Tu peux voir sur la playlist des exercices pour t'entraîner. Il y en aura plusieurs au fur et à mesure et à difficulté croissante : ruclips.net/p/PLrSOXFDHBtfF6lXQpJ4hBha76DsQufiEQ
Bonjour, je ne comprends pas bien le fait de donner deux nom au typage de pile : StackElement et *Stack. J'ai bien compris que la pile et un élement c'est la même chose mais pourquoi écrire *Stack et non Stack ? Merci à toi. Belle soirée.
Bonjour, c'est une syntaxe purement usuelle pour représenter une structure de Pile. Car ici, une Pile peut avoir 0, un ou plusieurs éléments, c'est une Pile dans tous les cas
Salut. Je ne comprends pas comment tu peux utiliser Stack comme type quand tu définis ta fonction pour créer une nouvelle pile, alors que quand tu as définis ta structure, tu as donné deux noms possibles : StackElement et *Stack, mais pas Stack tout seul.
Stack new_stack(void).
Je comprends bien qu'il y-a plusieurs d'utiliser un pointeur et que tu peux ne pas mettre l'étoile devant, et dans ce cas tu obtiens non pas la valeur de la variable pointée, mais l'adresse où elle se trouve.
Pourtant, ici ce pointeur est le nom d'un type, alors Stack tout seul n'est pas définit comme un nom de type de variable, alors comment se fait-il que tu puisses créer une fonction avec comme Stack comme type de retour ?
Merci d'avance si tu peux apporter une réponse.
Je réponds sur ton autre commentaire alors ;)
Bonjour il y a un truc que je ne comprends pas dans la fonction servant à afficher la pile. J'ai l'impression que la boucle while vide la pile puisque la condition est "while (!empty_stack(st))" et pourtant quand on demande si la pile contient des elements apres son affichage la réponde et que oui il y a bien 47 et 14 dans la pile.
Bonjour, refais-toi l'algorithme dans ta tête (ou en faisant un schéma) en prenant l'ensemble du code de la fonction d'affichage, et tu comprendras 😉
Bonjour, la fonction d'affichage ne modifie pas la pile puisqu'elle ne renvoie rien en retour. Donc si tu demandes grâce à la fonction "is_empty_stack" si ta pile est vide après l'avoir affichée, c'est normal que le programme te dise qu'elle n'est pas vide.
@@Low_Han ah ouai ok merci
c'est cool et bien expliqué ...
Mais je me demande quand même un truc :
Est ce que ça ne fait pas exactement le même taf qu'un tableau ? Du coup c'est quoi le contexte pour utiliser une pile ?
Sans compter qu'en plus le tableau on peut cibler précisément un index pour récup une donnée. Du coup j'ai du mal à visualiser l'intérêt ?
Un tableau est conçu pour une besoin bien précis, là où la Pile a son propre usage aussi. On veut pouvoir implémenter des structures pour contrôler la gestion des données (dans une Pile, on ne veut justement pas pouvoir ajouter/retirer un élément de n'importe où)
Pour commencer un grand merciii pour le travail que vous faites. C'est très instructif.
Sinon, une question, c'est quoi l’intérêt de donner 2 Alias de noms a la pile ?
Bonsoir, les deux alias sont là pour rendre le code plus lisible ensuite. Comme une Pile n'ayant qu'un seul élément est aussi une Pile, il serait bizarre de dire qu'une Pile contient des Piles. Donc, avec cette syntaxe, ça permet en lisant le code de comprendre qu'une pile (Stack) possède des éléments (StackElement).
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
@@formation-video C'est très claire, un très grand merci
Petite question, pour les stacks, on reféfini à chaque fois la variable stack pour mettre à jour notre pile mais dans ce cas ne serait-il pas plus opti de passer par l'adresse de la stack et de la manipuler via des pointeurs au lieu de ce passage par valeur ?
Regarde comment est définie la structure de la Pile
@@formation-video ok je comprend un petit rafraîchissement de mémoire sur les structures et les pointeurs dans les structures n'était pas de trop 😅 Merci pour ta réponse
👍
Bonsoir, lorsqu'on crée notre structure pour la pile et que l'on crée une fonction pour retirer un un élément, le return renvoi t'il une adresse d'un élément de structure crée pour la pile ?
Bonjour, la fonction pop_stack() renvoie une "Stack", c'est-à-dire la pile moins l'élément qui a été supprimé, comme expliqué dans la vidéo 👍
Hello. dans clear_stack() optimisée à 38:39, l'appel pop_stack(st) ne suffit-il pas ?.
Pourquoi "st" = pop_stack(st) ? (qui chez moi renvoie une Segmentation fault: 11)
Merci ! 😁
Non, un simple appel à pop_stack(st) ne suffirait pas si on a plusieurs éléments dans la pile. On fait donc de tous les supprimer jusqu'à obtenir une pile vide.
Merci pour ce tuto
De rien =)
salut Jason !! d'abord je vous remercie pour tout l'aide que vous nous portez sincèrement depuis que je suis tes vidéos j'ai quitter tout les site que je suivis avant... enfin bref !
Ma question est la suivante : Comment peut on réaliser un algorithme de tri d'une pile ? j'ai essayé plusieurs fois mais je n'ai pas arrivé et est ce qu'il n y a pas une fonction prédéfinie pour l'utiliser merci d'avance jason ! c'est ASMA
love u
Bonjour, et bien si ta Pile contient des entiers, il suffit d'utiliser les algorithmes de tri habituels pour trier des nombres, simplement :).
Après, une Pile n'est pas une structure conçue pour stocker des données triées (puisqu'on empile par le haut, et la première valeur retirée de la Pile sera toujours la dernière qui y a été ajoutée).
Pour plus d'infos sur l'Algorithmie, je te renvoie sur mon début de cours : ruclips.net/p/PLrSOXFDHBtfGy7xYmf5LlNr8f-niDkf7_
donc si par exemple jai une pile de 4 element et que je veux deplacer le 3eme element en première position la solution est de parcourir jusqu'au 3eme element et je le dépile c'est faisable? bien sur en réorganiser le pointage ...
je suis débutante dans la programmation du coup j'essaye de reproduire les algos qu'on voit sauvant sur les piles je n'ai aucun interet de faire le tri et je ne sais pas si c'est utile ou pas lol pour etre honnete et puis je reve d'etre programmeur comme vous . merci pour votre réponse :) !
On peut se tutoyer ;).
Alors oui, tu peux procéder ainsi, mais le mieux, sera de dépiler toutes les valeurs qu'il faut (en les sauvegardant dans des variables), jusqu'à avoir la valeur à mettre en premier, puis ré-empiler les valeurs sauvegardées et finir par empiler la valeur qui sera en première position.
Après, un tri se fait surtout sur une Liste, pas vraiment une Pile qui n'est pas faite pour cela. Bon courage pour ton avancée en langage C
Ahh d'accord ! merci infiniment pour laide que tu ns porte Jason :) !
C'est avec plaisir, n'hésite pas si tu rencontres d'autres soucis, je réponds toujours aux commentaires :)
Bonjour, j'ai une question, je ne comprends pas l'utilité d'une pile si celle-ci est structurée de la même façon qu'une liste. En fait, ce que je veux dire, c'est que la fonction push_stack est la même que insertHead d'une liste chainée d'entier, alors qu'est-ce qui différencie ces 2 méthodes ?
Bonjour, tout dépend de l'implémentation que les gens veulent en faire.
Grosso-modo, on a 3 types de structures :
Pile : on ajoute des données par l'avant, et on retire par l'avant (la première donnée à avoir été insérée sera la dernière à être retirée).
File : on ajoute des données par l'arrière, et on retire de l'avant (la première donnée à avoir été insérée sera la première à être retirée).
Liste : plus flexible, elle ne suit pas de contrainte particulière (on peut ajouter/supprimer depuis le début, la fin, et même en plein milieu de la structure).
Chaque structure répond donc à des besoins spécifiques :)
C'est compris, merci pour votre réponse :)
De rien ;)
J'ai finalement compris les piles , par contre j'ai une petite question au niveau de la fonction pop_stack, moi j'ai juste fait return st.next sans faire le free de st, parce que la fonction clear_stack s'occupe de tout après dans main, et cela a fonctionné , est-ce une bonne manière aussi? merci.
Non, la fonction pop_stack dépile un élément. Elle doit donc faire son travail de nettoyage de ce qui a été alloué. D'ailleurs, la fonction clear_stack() utilise pop_stack() pour libérer les ressources, ce n'est pas elle qui libère directement ce qui est alloué.
Bonjour Jason,
J'ai suivi ton programme et au moment de la compilation, j'ai un warning "assignement makes pointer from integer without a cast" à la ligne qui flush la pile dans le main. Cela dit le programme s'execute quand même sans erreur. As-tu une explication de ce warning ? Merci
Bonjour, peux-tu montrer le code ? Car cette erreur risque de poser problème pour l'exécution, il faudrait la corriger
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
Salut, j'ai une question.A quoi ça sert de mettre "structure StackElement *next" à l'intérieur de la première structure ?Je ne me souvient pas que tu en ais parlé dans le cour "structure et type".
Pour le maillon suivant de la Pile.
Tu as du comprendre qu'une Pile qui n'a qu'un seul élement est aussi une Pile. Donc, elle a une valeur, et un pointeur vers l'élément suivant, et ainsi de suite. Voilà pourquoi on a donc un pointeur vers une Pile dans une Pile.
Merci j'ai enfin compris.
Bien =)
Bonjour. Je suis en train d'apprendre le C et je te remercie pour tes vidéos qui sont très claires. Cependant je dois avouer que, si j'ai regardé les 16 premières vidéos sans soucis de compréhension, je ne comprends pas bien celle-ci.En effet je ne comprends pas , concrètement , à quel moment dois-je organiser mon code comme tu le fais dans la vidéo, en pile....?Je ne sais pas si je suis clair, où s'il y a un truc que j'ai zappé au cours de la formation. Merci d'avance pour ton aide.
Bonjour, à partir de cette séance 17, ce ne sont plus des notions propres au C directement. En gros, tu as appris les notions du langage. Ici ce sont des structures de données (parmi d'autres : graphes, arbres, files, listes) qui sont des structures très utilisées en informatique pour ordonner/trier/hiérarchiser des données.
Par exemple, la mémoire virtuelle utilisée par ton programme stocke les variables que tu déclares sur une Pile, qui fonctionne sur ce même principe. En intelligence artificielle, on va retrouver des arbres, pour calculer des itinéraires de graphes, etc.
@@formation-video ok merci beaucoup pour ta réponse
De rien 👋
Je me suis arrêté à 20:39 de la vidéo, j'ai essayé de bricoler un code qui créer une piles de 10 éléments en rangeant l'adresse de chaque éléments dans un tableau, puis d'en afficher le contenu, puis de libérer chaque espace réserver (avec malloc) dans le tas (heap).
J'ai réussi (enfin je crois, le programme affiche ce que je veux), mais je me suis confronté à une question existentielle.
Quelle est la différence entre " StackElement** tab; " et " StackElement* tab[12]; " ??? voir ligne 10 du fichier main.c
Avec " StackElement* tab[12] " le code marche, alors qu'avec une suite de " StackElement** tab ", cdt *(tab+i) pour ranger les adresses des struct dedans, ça plante.
Je met mes trois fichiers en réponse.
Main.c
#include
#include
#include "pile.h"
int main()
{
int i;
type_pile* save;
type_pile* element = pileVierge();
type_pile* adresse_pile[12];
//type_pile** adresse_pile;
if(testPileVide(element))
{
printf("La pille est vide.
");
}
else
{
printf("La Pile a des elements.
");
}
for(i=0; i(-1); i--)
{
save = *(adresse_pile+i);
printf("
Element[%d] adresse %p valeur %d
", i, (*save).next, (*save).valeur);
}
putchar('
');
putchar('
');
for(i=0; i
pile.c
#include
#include
#include "pile.h"
type_pile* pileVierge(void)
{
return NULL;
}
//----------------------------------------------------------------
boolean testPileVide (type_pile* element)
{
if(element == NULL)
{
return vrai;
}
return faux;
}
//----------------------------------------------------------------
type_pile* ajoutElement(type_pile* element_precedant, int x)
{
type_pile* element_suivant = malloc(sizeof(type_pile));
if(element_suivant == NULL)
{
printf("Probleme allocation dynamique");
}
(*element_suivant).valeur = x;
(*element_suivant).next = element_precedant;
return &(*element_suivant);
}
pile.h
#ifndef __PILE__H__
#define __PILE__H__
/* Type boolean */
typedef enum
{
faux, //0
vrai //1
}boolean;
/* Définition d'une pile */
typedef struct element_pile
{
int valeur;
struct element_pile* next; //comme le "type_pile*" sauf qu'on doit appeler "struct element_pile" dans la structure.
}type_pile;
/* Liste des prototypes des fonctions */
type_pile* pileVierge(void);
boolean testPileVide (type_pile* element);
type_pile* ajoutElement(type_pile* element_precedant, int x);
#endif
bonjour, comment vous faites pour ouvrir +sieurs fichiers en même temps sur une seule console?
j'ai la peine d'ouvrir +sieurs fichiers sur linux.
Bonjour, comment ça ouvrir plusieurs fichiers sur la console ?
Salut :) , est ce qu'il est possible que je puisse utiliser le nom de la pile "stackElement" dans les fonction et non pas "stack" , sinon pourquoi ? merci vraiment !
Oui, tu peux bien nommer les choses comme tu le veux et adapter la structure comme tu préfères 🙂
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
bonjour !
quand vou avez definie la pile vous avez mis :
typedef struct stackelement
{
int value ;
struct stackelement *next ;
}stackelement, *stack ;
la question est pourquoi vous avez fait "struct stackelement *next ;" est pas directement "stackelement *next " ; vous avez deja dit dans les video precedentes que le decalaration precedente suffit .
merci !
Bonjour, en testant avec le retrait du mot "struct", tu aurais tout de suite compris pourquoi je l'ai indiqué. Simplement parce qu'à ce stade (on définit la structure), l'alias StackElement = struct StackElement n'est pas encore valide et connu pour le compilateur 😉
Salut, le compilateur me met ça quand je compile :
C:\Users\massy\AppData\Local\Temp\cca3OPEP.o:piles.c:(.text+0xf): undefined refe
rence to `new_stack'
C:\Users\massy\AppData\Local\Temp\cca3OPEP.o:piles.c:(.text+0x33): undefined ref
erence to `add_stack'
C:\Users\massy\AppData\Local\Temp\cca3OPEP.o:piles.c:(.text+0x47): undefined ref
erence to `add_stack'
collect2.exe: error: ld returned 1 exit status
Pourquoi donc ?
Vérifie que tu as bien fait les includes comme dans la vidéo.
Et de bien compiler en faisant -> gcc *.c -o prog
Salut pour quoi tu n'as pas utililse la bibliotheque stdbool.h pour declarer le type booleen ? y a til une raison ?
Bonjour, parce que sur les anciennes normes, elle n'existait pas, et comme je ne peux pas garantir que les internautes l'auront, en créant le type, je suis sûr que ça fonctionnera chez tout le monde (et ça permet au passage de voir une application de l'énumération) 😉
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Cool merci pour l’information
De rien
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Salut Jason, pourquoi dans l'enum l'ordre entre "true" et le "false" est important ? j'ai bcp peiné à retrouver cette erreur. En mettant l'inverse de ce que t'as fait je me retrouve avec un segmentation fault.
Et un Grand merci, pour tes vidéos ça m'aide énormément.
Bonjour, parce que par défaut, une énumération est numérotée, en commançant par 0, puis 1, etc. Dans ce cas, si tu viens à attribuer true à 0 et false à 1, je pense que tu comprends le problème que ça entraîne 😉
Ohh oui compris maintenant merci 👍🏻.
De rien ;)
merci !
✌
Bonjour Jason et merci pour la vidéo, elle est très clair mais j'avoue ne pas comprendre l'intérêt de cette notion ou sa puissance malgré l'exemple en fin de vidéo. Aurais tu des exemple d'utilisation concrets des piles s'il te plait ?
Bonjour, un exemple concret et facile à imagine : la pile d'un programme. Pour faire simple : chaque variable déclarée dans ton programme ou chaque appel de fonction est enregistré sur une pile. C'est la structure utilisée en mémoire (virtuelle) pour gérer ces données (j'en parlerai d'ailleurs dans ma playlist Architecture)
Prof, a propos d'une fonction de trie d'une pile on va faire la comparaison entre value ET next et on les permutes. C'est possible sur une pile??
Non, pas comme est conçue la structure. Une Pile n'est pas une structure conçue pour faire du tri, car on empile des valeurs par un côté, et on dépile par ce même côté. Si tu veux une structure triée, il faudra plutôt travailler avec une liste
Mais oui sinon, dans le principe, il suffirait de permuter les valeurs de deux maillons de la Pile. Exemple st->value avec st->next->value
FormationVidéo Merci j'ai compris prof, Sinon si j'ai bien compris le pointeur Des piles pointe sur L'element precedent et celui des files pointe sur le prochain non?? Pardon pour le derangement
Non, la Pile et la File utilisent le même système de pointeur vers l'élément suivant. Ce qui change entre les deux, c'est l'ordre d'insertion et suppression d’élément :)
Merci pour la réponse précédente. Et à quel moment parle t-on de l’implémentation de l'assembleur et du compilateur?????
Pas dans ce cours, pas de rapport direct avec le C
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
Bonjour, si je ne "veux pas" définir la structure avec typedef, mais simplement faire "struct StackElement",
comment dois-je ré-écrire la suite du code, pour les deux fonctions new_stack() et is_empty_stack() ? Je m'y perds, c'est encore pour moi un vrai labyrinthe...
Juste savoir ça, svp, ré-écrire sans typedef. Merci !
Bonjour, justement, "typedef" ne sert pas à définir de structure, mais à définir un alias.
Donc, oui, tu peux évidemment faire sans : pastebin.com/2YKJyxPy
@@formation-video Merci ! Je retourne au combat 😁
Bonsoir jason champagne merci pour la vidéo j'aimerai savoir pourquoi lorsqu'on crée une pile on utilise l'allocation dynamique d'après ce que j'ai compris on utilise l'allocation dynamique lorsqu'on veut utiliser une donnée dont la taille n'est pas connu par notre ordinateur j'ai un problème ici car lorsque qu'on crée un variable de type int on a pas besoin d'allocation mais lorsqu'on veut créer une pile on dit comme l'avez écrit stackelement *element; p = malloc(sizeof(element)); étant donné qu'on a crée la structure stackelement en mettant un typedef est ce que la machine n'a elle pas déjà réservée un espace pour les types stackelement? puisque dans la vidéo sur les structures on entrait les username, hp et mp des Player sans avoir à faire une allocation dynamique
Bonjour, avec ces structures de données, nous manipulons des pointeurs vers ces dernières, d'où la nécessité d'allouer l'espace nécessaire, car non, l'ordinateur ne sait pas à l'avance quel espace occupe une Pile 👍
Un exemple simple pour illustrer cela : pastebin.com/KvYK87mE
@@formation-video ça veut donc dire que dès que l'on utilise un pointeur dont le type est défini par une structure, nous devons automatiquement faire une allocation dynamique?
Non, pas si tu déclares un pointeur pointant vers une structure déjà déclarée : pastebin.com/Bgzr3LpD
Bonjour je comprends pas pourquoi apres avoir par exemple dépiler le 31, puis le 23 le programme dit que la pile est vide pourtant on a encore deux éléments
Bonjour, quel moment de la vidéo exactement ?
Bonjour , svp dans popstack() vous avez fait un free(st) alors que vous n'avez pas déclaré de tableau dynamique dans cette fonction comment ça se fait ?
Si tu as bien regardé le code, on travaille toujours sur la même Pile, donc celle que tu nous avons créé au départ (en faisant des allocations avec malloc).
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Bonjour ! Je voulais savoir pourquoi l'invite de commande marque le message ci-après lorsque que je tente de compiler le programme "piles" ?
Je suis sous windows 10, si cela peut bien évidemment aider ^^
Merci de votre compréhension..
C:\Users\blute\AppData\Local\Temp\cc7dOG3Y.o:main.c:(.text+0xf): undefined reference to `new_stack'
C:\Users\blute\AppData\Local\Temp\cc7dOG3Y.o:main.c:(.text+0x1f): undefined reference to `is_empty_stack'
collect2.exe: error: ld returned 1 exit status
Bonsoir, dans l'archive fournie, tu as les fichiers "stack.c" et "stack.h".
Tu peux donc créer un fichier "main.c" avec la fonction main() dedans (comme j'ai fait dans la vidéo). Toujours dans ce fichier, il ne faut pas oublier au début d'ajouter la ligne *#include** "stack.h"* pour inclure le fichier d'en-tête de la Pile, sinon les fonctions ne seront pas trouvées par le compilateur, d'où ton message d'erreur.
Le problème persiste alors que la configuration est telle que tu l'énonce dans ton message...
Toujours le même message...
Y aurait t-il un autre moyen ?
C:\Users\blute\Desktop\Codage\Piles>gcc main.c -o prog
C:\Users\blute\AppData\Local\Temp\cctFSDxv.o:main.c:(.text+0xf): undefined reference to `new_stack'
C:\Users\blute\AppData\Local\Temp\cctFSDxv.o:main.c:(.text+0x1f): undefined reference to `is_empty_stack'
collect2.exe: error: ld returned 1 exit status
Erreur d'étourderie... Je viens de trouver la subtilité ^^
Très bonne soirée
PS : Une excellent travail côté réalisation vidéo ainsi qu'une solide pédagogie à en faire trembler certains professeurs ^^
Bonne continuation...
Ah, bien que ce soit bon enfin de ton côté, bonne continuation :) !
Bonjour j'ai un souci. Enfaite je sais comment créer une pile vérifier si elle est vide ou non ajouter une pile et tout.... Mais mon souci est que j'arrive pas à comprendre pourquoi est-ce que les données s'empilent ? Qu'est-ce qui est à la base de cela ? Est-ce à cause de la structure reccurcive. struct stackelement *next? Ou pas ? J'ai un souci là dessus et je voudrai vraiment éclaircir cela avant d'attaquer les autres structures... Merci de bien m'aider
Bonjour, le schéma montré en vidéo explique le fonctionnement : chaque "maillon" de la pile est une structure composée d'une valeur (ici un entier) et d'un pointeur vers l'élément suivant. C'est l'usage du pointeur *next qui assure qui permet aux données de se suivre, et donc, de les empiler dans un ordre précis.
@@formation-video D'accord je comprends merci !!
👍
J'aurai bien preferé que les noms de fonctions soient ecrient en angalais mais bon pas grave vous avez fait une bonne video.Merci pour votre aide
J'écris personnellement mon code en anglais, et dans les vidéos, ça arrive que certaines ont des noms de variables/fonctions/classes en français. Mais c'est plutôt rare. Par contre tu ne dois pas parler de cette vidéo (sur les Piles) car les fonctions sont bien nommées en anglais justement.
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
🔵 Rejoindre FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
Salut,
je ne comprends pas pourquoi le fichier main.c fonctionne sans include stack.c
c'est bien stack.c qui contient la fonction new_stack() n'est ce pas , stack.h ne contient que le prototype de la fonction ,
de plus stack.c inclus stack.h , pourquoi pas ne pas l'inclure dans main.c au lieu de stack.h
merci !
Bonsoir,
Un include permet d'ajouter un fichier d'en-tête, et un fichier ".c" n'en est pas un, il s'agit d'un fichier source. Donc, chaque fichier source doit inclure les fichiers d'en-tête et bibliothèques dont il a besoin.
Merci pour la réponse rapide ! du coup il suffit d'avoir le fichier stack.c dans le même répertoire que main.c
Voilà. Pour le compilateur, tant qu'il connaît l'existence des fonctions (via le prototype), il saura retrouver celle-ci pour compiler le tout comme il faut et te faire un exécutable fonctionnel :).
Ne pas oublier que pour la machine, y'a pas de fonctions en réalité, ce ne sont que des adresses en mémoire, y compris pour les variables.
FormationVidéo c'est compris merci!
De rien :)
Bonjour, j'aimerai savoir pourquoi mon programme ne fonctionne pas :
main.c :
#include
#include
#include "stack.h"
int main(void)
{
Stack sta = newStack(); //on crée un pointeur nommé "sta" et de type Stack, qui prend la valeur du retour de la fonction newStack()
if(isEmptyStack(sta))
printf("La pile est vide.
");
else
printf("La pile n'est pas vide.
");
printStack(sta);
sta = pushStack(sta, 14);
sta = pushStack(sta, 47);
printStack(sta);
if(isEmptyStack(sta))
printf("La pile est vide.
");
else
printf("La pile n'est pas vide.
");
sta = clearStack(sta);
printStack(sta);
if(isEmptyStack(sta))
printf("La pile est vide.
");
else
printf("La pile n'est pas vide.
");
return 0;
}
stack.c :
#include
#include
#include "stack.h"
Stack newStack(void)
{
return NULL;
}
Bool isEmptyStack(Stack st)
{
//si l'adresse st de type Stack est NULL, on retourne true (voir enum du fichier "stack.h") et donc on sort de la fonction, donc, si on ne l'a pas fait, on retournera false (pas besoin de else)
if(st == NULL)
return true;
return false;
}
Stack pushStack(Stack st, int x)
{
StackElement *element;
element = malloc(sizeof(*element)); //on crée un tableau avec l'allocution dynamique pour notre pile
//si l'allocution a échoué, on quite le programme :
if(element == NULL)
{
fprintf(stderr, "Probleme allocation dynamique !!!
");
exit(EXIT_FAILURE);
}
//on met les valeurs en fonction des paramètres de la fonction :
element->value = x;
element->next = st;
return element;
}
Stack clearStack(Stack st)
{
StackElement *element;
//si la pile est déjà vide, on retourne le retour de newStack :
if(isEmptyStack(st))
return newStack();
//on donne à element une valeur en fonction de st, qu'on libère ensuite :
element = st->next;
free(st);
//on retourne le retour de clearStack en fonction de element, donc on va réexecuter la fonction jusqu'à ce que la pile soit vide, auquel cas il retournera le retour newStack() (voir plus haut) :
return clearStack(element);
}
void printStack(Stack st)
{
if(isEmptyStack(st))
{
printf("Rien a afficher, la pile est vide.
");
return; //on sort de la fonction sans retourner de valeur car la fonction est de type void
}
while(!isEmptyStack(st))
{
printf("[%d]
", st->value);
st = st->next;
}
}
stack.h :
#ifndef __STACK__H__
#define __STACK__H__
// --§__création d'un type booléen__§--
typedef enum
{
false, //0
true //1
}Bool;
// --§__définition d'une pile__§--
typedef struct StackElement
{
int value;
struct stackElement *next;
}StackElement, *Stack;
// --§__prototypes des fonctions__§--
Stack newStack(void); //cette fonction retourne une adresse de type Stack (voir structure)
Bool isEmptyStack(Stack st);
void printStack(Stack st);
Stack pushStack(Stack st, int x);
Stack clearStack(Stack st);
#endif
Merci beaucoup !
Bonjour, pour plus de lisibilité, peux-tu partager ton code via pastebin ?
Sinon, relis d'abord ton code, car je vois rapidement pas mal d'erreurs (par exemple dans la structure, tu as noté "stackElement" au lieu de "StackElement". Les minuscules/majuscules sont importantes.
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Merci beaucoup, mon code fonctionne très bien, et vos vidéos sont géniales !
Parfait 😉 !
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
Merci super tuto comme d'hab ! J'ai une question, peut-on changer tous les "StackElement *element" (dans les fonctions pop_stack ou push_stack) par des "Stack element" ? en fait j'ai du mal à comprendre la fin de ta déclaration de structure, quand tu écris "StackElement, *Stack"
Le meilleur moyen de le savoir, c'est de le tester, alors fais et tu verras quel comportement cela engendre au niveau de ton programme 👍
@@formation-video je viens de verifier et ca marche en faisant ce remplacement, ca me semble plus clair, je l'ecrirai donc comme ca maintenant, merci beaucoup ! (Neanmoins je ne comprends pas l'etoile devant le Stack a la fin de la declaration de la structure, en essayant de l'enlever j'ai des erreurs a la pelle)
Parce que c'est une notation avec pointeur, donc forcément, si tu l'enlèves... 😉
Si j'ai bien compris la notation *Stack correspond à l'adresse du premier élément de la pile, qu'on peut simplifier par la pile elle même ?
Non, la notation Stack* (et pas *Stack) indique un pointeur vers une structure de type Stack
Ah oui en fait on note StackElement * Stack j'avais pas bien compris que la notation était typedef struct StackElement* Stack
Je voulais parler de la notation Stack du coup
OK 👍
Bonjour !
On nous a donné un projet sur les piles et les files :
Comment implémenter une pile a l'aide de deux files ?
Comment implémenter une file a l'aide de deux piles ?
J'ai aucun problème sur tout ce qui concerne le code ! Ce que je comprends pas c'est la présentation (le schéma ) car je vois que c'est inutiles !
Pouvez vous m'expliquer l'implémentation svp !
Cordialement
Coucou,
C'est ton projet qui te demande précisément d'implémenter une Pile avec 2 Files, et une File avec 2 Piles ?
FormationVidéo ouais !
C'est étrange ce que l'on te demande sachant que les deux structures ont un fonctionnement complètement différent.
Pour une Pile, la dernière valeur insérée est la première que l'on peut retirer.
Pour une File, la dernière valeur insérée est la dernière que l'on pourra retirer.
is it possible to add an element in a specific position ??
No, the stack structure must respect the LIFO (Last In First Out) principle. For the insertion of elements at a specific position, we generally use a list 👍
Salut, y'a un petit point que j'arrive pas à éclaircir, pourquoi rajouter "*Stack" a la définition de la struct à la place de "Stack" ? On ne peux pas juste la déclarer comme pointeur à la création seulement comme ca "Stack *stack = ... " ?
Je l'avais expliqué dans les vidéos, c'est une manière de pouvoir employer la structure en masquant le pointeur. Je l'avais fait pour montrer que c'était possible (en faisant différemment sur d'autres structures de données de la formation pour que vous ayez plusieurs exemples d'implémentation).
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
💙 Si ce n'est pas encore fait, n'hésite pas à t'abonner à la chaîne
➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
pourquoi certaines fonctions ne prennent elles pas de double pointeurs, dans cetrains cas, je pense qu'il devrait y avoir des problemes des lors que nous quittons les fonction telle que push stack dans le main non ?
Tout cela vient de la manière dont a été définie la structure de la Pile. En revanche, tu verras que pour d'autres structures, j'ai fait une implémentation différente, histoire de montrer plusieurs manières de faire, et ce que cela change sur la syntaxe 😉
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
Salut , merci pour cette super video .
Je travaille avec le code::Blocks et j'ai essayé mais dans le terminal il m'a dit que la pile est toujours vide malgrés que j'ai fais l'ajout des élements à l'aide de la fonction "push_Stack" j'ai pas compris pourquoi malgrés que j'ai fait aucun erreur dans le code .merci de me répondre !
Bonjour, pourrais-tu me montrer le code complet de ta fonction "push_stack" et comment tu appelles celle-ci dans ta fonction main() ?
bonjour , celui ci est la fonction "push_stack" :
Stack push_Stack (Stack st , int x )
{
StackElement *element ;
element = malloc (sizeof(*element)) ;
if (element ==NULL)
{
printf("problème allocation dynamique .
");
}
element->value=x ;
element->next =st ;
return element ;
}
et dans la fonction main :
int main(void)
{
Stack sta=new_Stack() ;
print_Stack(sta);
printf("
-----------------------------
");
sta = push_Stack(sta,13);
sta = push_Stack(sta,26);
sta = push_Stack(sta,80);
print_Stack(sta);
return 0 ;
}
OK, et donc avec ce code, l'ajout des éléments n'est pas fait tu me dis ? Tout semble correct pourtant. Vérifie bien en revanche que tout est bon sur le nommage des fonctions, je vois par exemple que tu as mis une majuscule sur le "S" de push_Stack, ou print_Stack, donc vérifier que c'est identique partout :)
Après si ton code compile, c'est qu'il n'y a pas d'erreurs
Je reprends on code pas à pas pour en comprendre la logique, après la création de la fonction qui libère la pile, j'ai 2 erreurs répétées plusieurs fois dans la console :
dans le "main" : assigment makes pointer from integer without a cast; par exemple ici : pile1 = ajoute_element_pile(pile1,14);
puis,
sur toutes mes fonctions, par exemple : sur "pile.c" et "main.c" :multiple definition of "nouvelle_pile"
Il me semble que mon code répète bien ton code même s'il y a d'autres noms... ?!
A priori, tu dois avoir des fonctions définies deux fois, et certainement d'autres erreurs dans ton code pour avoir ces messages là. Relis bien ton code, et compare avec le mien pour identifier les erreurs éventuelles ;)
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- Jason CHAMPAGNE - jasonchampagne.fr
+---------------------------------------------------------------------------------------------------------------------------------------------+
|- COUCOU, TU VEUX :
|--- Nous rejoindre sur Discord ? discord.me/jasonchampagne
|--- Me voir en direct sur Twitch ? www.twitch.tv/jachampagne
|--- T'abonner à mon autre chaîne RUclips ? ruclips.net/user/jasonchampagne
|--- Me follow sur Twitter ? twitter.com/jachampagne8
|--- Liker la page Facebook ? facebook.com/jachampagne8
|--- Me follow sur Insta ? instagram.com/jachampagne8/
|--- M'ajouter sur Snapchat ? www.snapchat.com/add/jachampagne8
+---------------------------------------------------------------------------------------------------------------------------------------------+
bjr. mrc pour cette vidéo (même si sa fais déjà 2ans). Pour être sur d'avoir bien compris, dans la fonction main, si je fait une initialisation de ma piles en fesant Stack *stack = new_stack(); sa ne marchera pas car stack est déjà un pointeur en fesant Stack stack; ?
Bonjour, le mieux est que tu testes pour voir ce que te donnera le compilateur ;)
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
Bonjour j'ai eu un problème apres avoir la compilation quand vous avez compiler et obtenu : la pile est vide
La pile a des éléments
La pile est vide
Et bien là bas moi je n'ai obtenu qu'une seul réponse qui dit la pile est vide et pourtant j'ai mis les même code que vous
Bonjour, si ton code était identique au mien, tu te doutes que tu aurais forcément le même résultat à l'arrivée. Vérifie ce que tu as écrit, tu dois avoir des erreurs quelque part 👍
Ok
bonjour sa sera quand pour la SDL2 :'( et merci pour ce que vous faite
Bonsoir, la prochaine vidéo (celle après les Graphes) sera sur la SDL, donc la prochaine à venir =)
FormationVidéo ah merci c'est cool 🤗
:)
Il y a une chose que je ne comprend pas le type "stack" qu'on met avant la fonction push_stack c'est le type de retour n'est ce pas,alors pourquoi vous n'avez rien retourner et pourtant ça marche mais quand moi je fait ceci:
stack push_stack(stack st,int x)
{
stackelement* element=(stackelement*)malloc(sizeof(stackelement));
if(element==NULL)
{
printf("probleme allocation memoire
");
exit(1);
}
element->value=x;
element->next=st;
return st;
}
ça ne marche pas alors que je retourne bien la pile st,
ça me met que la pile est vide a chaque fois quand j'exécute
Merci bien de me répondre
Bonjour, tu as du mal lire le code, car je retourne pourtant bien une pile, en faisant le *return element*.
vous avez fait un return element,je vais essayer alors,mais je comprends quand même pas pourquoi return st ne marche pas
et selon moi on devait retourné la pile st et non element,c'est la raison pour laquelle on fait sta=push_stack(sta,13)
la fonction retourne un stack (une pile) alors pourquoi ça marche pas avec st
Relis bien le code de la fonction. On créée une variable element, qui sera la future pile en fait. Sur la première case, on met la valeur passée à la fonction, et à la suite, on met l'ancienne pile.
Donc forcément, si tu retournes "st", cette Pile au début est vide donc tu retournes à chaque fois une Pile sur laquelle rien a été ajouté, voilà pourquoi c'est toujours vide.
Si le code est pas assez clair pour toi, remplace le nom *element* par *newStack* et tu comprendras mieux :).
merci c'est plus clair maintenant
J' aime vraiment les vidéos mais je n'arrive pas à accéder au code laisser en description
Via les liens dans la description de la vidéo, tu arrives sur des pages de mon GitHub. Sur celles-ci, tu as sur la droite une icône pour télécharger l'archive : imgur.com/LqiOUki
Dans clear_stack(Stack st), je me demande et si on avait placé free(st) avant element= st ->next, est-ce qu'il efface toute les piles.?
Non, ça ne supprimerait que l'élément courant de la Pile (le premier en l'occurence). Oublie pas qu'on a fait un malloc() à chaque fois qu'on ajoute un élément à la Pile. Donc il faut autant de free()
Bonne année à toutes et tous. Je n'arrive pas à coder une fonction qui regardera un élément en particulier, et qui écrira :
"L'élément situé à la 3 ème position (dans mon exemple) a comme ' int value' : (value associée à cette 'position').
J'arrive à une usine à gaz du genre st->next->next->next...etc -> next->value. pour atterrir enfin là où je veux. C'est naze...
Comment faire ? Je ne vois pas.
Merci !😀
Tu peux utiliser un simple compteur partant à 1 (comme on pointe au départ sur le début de la Pile) et tant que ce compteur n'a pas atteint l'indice spécifié, de déplacer le pointeur sur la pile.
De là, tu pointeras alors sur le bon élément, et tu n'auras qu'à afficher le contenu de st->value 👍
C'est le même principe de parcours que pour l'affichage ou le comptage du nombre d'éléments, sauf que le point d'arrêt diffère, évidemment.
@@formation-video Je parcours la pile depuis son haut, vers son bas, en me déplaçant par st = st->next successifs, jusque par exemple le '3ème étage'. Et je récupère sa valeur ok. Ça, je peux faire parce que je suis allé d'abord calculer la hauteur de pile, pour décrémenter un compteur qui m'amène là où je veux. (J'ai réussi cela)
Mais je ne sais pas 'monter' du bas vers le haut de pile... Si c'est une meilleure solution, 'remonter dans la pile', comment faire ?
(Si j'ai bien suivi...) Merci ! 😁
Tu ne peux justement pas parcourir une pile à l'envers.
Donc, il va falloir "compter à l'envers" si tu veux l'élément en Nième position (comme on a le nombre d'éléments qu'elle contient, c'est assez facile à mettre en place).
comment tu fais pour copier coller juste en cliquant ?
sinon super video comme toujours
C'est ça, c'est une fonction standard de Sublime Text, bien pratique =)
Bonjours Jason très bonne vidéo mais je me demandais qu'elle est la différence entre = et ->
Bonjour : = est l'opérateur d'affectation tandis que la -> est l'opérateur d'accès à une donnée membre pour un pointeur vers une structure
J'aimerais avoir un eclaircicement sur un truck ou deux :
Comment on reconnais une pile vide ? , le fait de dire vide ne veut pas dire que ca n'a pas de valeur sinon on aurais dit st->value , j'ai aussi un probleme des structurese et enumeration, ces derniers ne fonctionne pas , et si j'avais envie d'afficher le premier element enregistrer de la pile c'est a dire je fais commet ?
Bonjour, tout dépend de comment tu vas représenter ta structure. Dans mon implémentation, une pile est une Pile qui n'est rien, donc la valeur NULL.
Ensuite, le principe de la Pile n'est pas censé permettre de récupérer le premier élément empilé, mais le sommet de celle-ci. Après tu peux créer une fonction pour le faire, mais ta Pile deviendrait plus une sorte de Liste ;)
ok et quel est l'interet de faire un malloc au niveau de l'ajout
d'un element
je veux aussi connaitre la difference entre stack et stackelement
Et bien d'indiquer à ton ordinateur quelle place il doit réserver en mémoire. Car il sait allouer seul un entier, un caractère, un flottant, mais un élément de Pile, non
Stack est l'écriture qui va masquer le pointeur, StackElement celle qui ne le masque pas
bonjour pourquoi avoir écrit "st" dans vos programmes? que signifie t-il?
Bonsoir, "st" est simplement un nom que je donne à ma variable pour représenter la Pile. Mais j'aurais pu évidemment lui donner n'importe quel nom
+FormationVidéo merci!
:)
Bonjour merci pour la formation
just une question pour m'éclaircir les idées un peut plus
on aurait pas pu faire : sta = new_stack();
pour vider la pile ?
et merci encore
Et que fais-tu de tout ce qui a été alloué en mémoire (et ne sera donc pas libéré = fuite mémoire) ? 😉
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
@@formation-video Ahhhhh c'est vrai, merci mec ^^
Dans ton archive d'entiers il manque un ; après int value dans la définition d'une pile et tu as laissé Player dans les paramètres de pushStack
Et quand j'inclu stack.h dans mon main ça marche pas alors que quand je fais include stack.c ça marche, je pense que c'est parce que je fais
gcc main.c -o prog
et que tu fais
gcc *.c -o prog
du coup j'imagine qu'il pack les 2 .c dans le prog.exe ?
Merci de l'avoir signalé, j'ai mis à jour l'archive et les liens sur la vidéo 👍
Et oui, il faut bien compiler tous les fichiers source, donc -> gcc *.c -o prog (ou éventuellement : gcc stack.c main.c -o prog)
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
Salut y-t-il eu des changements concernant l’affichage de pile ? , ça ne semble pas marcher pour moi
Bonjour, non, pourquoi y'aurait-il un changement ? Si cela ne fonctionne pas, c'est que tu as une erreur dans ton code.
Tu avais bien raison mon erreur était dû au push_stack Plutôt. Merci ✌️
Impeccable 👍
bonjour;
pourquoi l'or de la définition d'une pile le pointeur *next est de type struct StackElement ?
Parce qu'on aurait pas notre structure sinon, où chaque élément est "rattaché" à un autre.
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
@@formation-video
bonjour;
j'ai pas bien compris votre réponse; le ptr *next doit contenir une adresse(pourquoi le type struct StackElement et non type int)
Parce que "next" est un pointeur vers StackElement, pas un pointeur sur "int"
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖
◾ MERCI DE TON SOUTIEN ! 🔻
◾ Pas encore abonné(e) ? N'hésite pas à le faire 💙
◾ Soutenir FormationVidéo : bit.ly/2L0xNXA
◾ Site web : jasonchampagne.fr
◾ Discord : discord.me/jasonchampagne
◾ Twitch : www.twitch.tv/jachampagne
◾ RUclips (personnel) : ruclips.net/user/jasonchampagne
◾ Twitter : twitter.com/jachampagne8
◾ Facebook : facebook.com/jachampagne8
◾ Instagram : instagram.com/jachampagne8
◾ Snapchat : www.snapchat.com/add/jachampagne8
◼ ➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖➖